(_hurd_sig_post): __sig_post renamed to __msg_sig_post.
[kopensolaris-gnu/glibc.git] / manual / lang.texi
index 545e43a..66d4184 100644 (file)
@@ -1,19 +1,20 @@
-@node Language Features, Summary of Library Facilities, System Configuration Limits, Top
-@appendix Library Facilities that are Part of the C Language
+@node Language Features, Library Summary, System Configuration, Top
+@appendix C Language Facilities in the Library
 
-Some of the facilities that are implemented by the C library really should
-be thought of as parts of the C language itself.  These facilities ought 
-to be documented in the C Language Manual, not in the library manual; but
+Some of the facilities implemented by the C library really should be
+thought of as parts of the C language itself.  These facilities ought to
+be documented in the C Language Manual, not in the library manual; but
 since we don't have the language manual yet, and documentation for these
 features has been written, we are publishing it here.
 
-@menu 
-* Consistency Checking::     Using @code{assert} to abort
-                               if something ``impossible'' happens.
-* Variadic Functions::       Defining functions with varying numbers of args.
-* Null Pointer Constant::    The macro @code{NULL}.
-* Important Data Types::     Data types for object sizes.
-* Data Type Measurements::   Parameters of data type representations.
+@menu
+* Consistency Checking::        Using @code{assert} to abort if
+                                something ``impossible'' happens.
+* Variadic Functions::          Defining functions with varying numbers
+                                 of args. 
+* Null Pointer Constant::       The macro @code{NULL}.
+* Important Data Types::        Data types for object sizes.
+* Data Type Measurements::      Parameters of data type representations.
 @end menu
 
 @node Consistency Checking
@@ -48,16 +49,16 @@ without indicating anything might be wrong.
 @comment ANSI
 @deftypefn Macro void assert (int @var{expression})
 Verify the programmer's belief that @var{expression} should be nonzero
-at a certain point in the program.
+at this point in the program.
 
 If @code{NDEBUG} is not defined, @code{assert} tests the value of
 @var{expression}.  If it is false (zero), @code{assert} aborts the
 program (@pxref{Aborting a Program}) after printing a message of the
 form:
 
-@example
+@smallexample
 @file{@var{file}}:@var{linenum}: Assertion `@var{expression}' failed.
-@end example
+@end smallexample
 
 @noindent
 on the standard error stream @code{stderr} (@pxref{Standard Streams}).
@@ -65,26 +66,28 @@ The filename and line number are taken from the C preprocessor macros
 @code{__FILE__} and @code{__LINE__} and specify where the call to
 @code{assert} was written.
 
-If the preprocessor macro @code{NDEBUG} is defined before
+If the preprocessor macro @code{NDEBUG} is defined at the point where
 @file{assert.h} is included, the @code{assert} macro is defined to do
-absolutely nothing.  Even the argument expression @var{expression} is
-not evaluated, so you should avoid calling @code{assert} with arguments
-that involve side effects.
+absolutely nothing.
 
-For example, @code{assert (++i > 0);} is a bad idea, because @code{i}
-will not be incremented if @code{NDEBUG} is defined.
+@strong{Warning:} Even the argument expression @var{expression} is not
+evaluated if @code{NDEBUG} is in effect.  So never use @code{assert}
+with arguments that involve side effects.  For example, @code{assert
+(++i > 0);} is a bad idea, because @code{i} will not be incremented if
+@code{NDEBUG} is defined.
 @end deftypefn
 
 @strong{Usage note:} The @code{assert} facility is designed for
 detecting @emph{internal inconsistency}; it is not suitable for
-reporting invalid input or improper usage.
+reporting invalid input or improper usage by @emph{the user} of the
+program.
 
-The information in the diagnostic messages printd by the @code{assert}
-macro is intended to to help you, the programmer, track down the cause
-of a bug, but is not really useful for telling a user of your program
-why his or her input was invalid or why a command could not be carried
-out.  So you can't use @code{assert} to print the error messages for
-these eventualities.
+The information in the diagnostic messages printed by the @code{assert}
+macro is intended to help you, the programmer, track down the cause of a
+bug, but is not really useful for telling a user of your program why his
+or her input was invalid or why a command could not be carried out.  So
+you can't use @code{assert} to print the error messages for these
+eventualities.
 
 What's more, your program should not abort when given invalid input, as
 @code{assert} would do---it should exit with nonzero status (@pxref{Exit
@@ -116,11 +119,10 @@ but incompatible, mechanism for defining functions with variable numbers
 of arguments, using @file{varargs.h}.
 
 @menu
-* Why Variadic::        Reasons for making functions take variable arguments.
-* How Variadic::        How to define and call variadic functions.
-* Argument Macros::     Detailed specification of the macros
-                          for accessing variable arguments.
-* Variadic Example::    A complete example.
+* Why Variadic::                Reasons for making functions take
+                                 variable arguments. 
+* How Variadic::                How to define and call variadic functions.
+* Variadic Example::            A complete example.
 @end menu
 
 @node Why Variadic
@@ -129,9 +131,10 @@ of arguments, using @file{varargs.h}.
 Ordinary C functions take a fixed number of arguments.  When you define
 a function, you specify the data type for each argument.  Every call to
 the function should supply the expected number of arguments, with types
-that can be converted to the specified ones.  Thus, if the function foo
-is declared with @code{int foo (int, char *);} then you must call it
-with two arguments, a number (any kind will do) and a string pointer.
+that can be converted to the specified ones.  Thus, if the function
+@samp{foo} is declared with @code{int foo (int, char *);} then you must
+call it with two arguments, a number (any kind will do) and a string
+pointer.
 
 But some functions perform operations that can meaningfully accept an
 unlimited number of arguments.
@@ -169,7 +172,7 @@ Defining and using a variadic function involves three steps:
 @item
 @emph{Define} the function as variadic, using an ellipsis
 (@samp{@dots{}}) in the argument list, and using special macros to
-access the variable arguments.  @xref{Receiving Argument Values}.
+access the variable arguments.  @xref{Receiving Arguments}.
 
 @item
 @emph{Declare} the function as variadic, using a prototype with an
@@ -178,21 +181,27 @@ ellipsis (@samp{@dots{}}), in all the files which call it.
 
 @item
 @emph{Call} the function by writing the fixed arguments followed by the
-additional variable arguments.  @xref{Calling Variadic Functions}.
+additional variable arguments.  @xref{Calling Variadics}.
 @end itemize
 
 @menu
-* Variadic Prototypes::         How to make a prototype for a function
-                                  with variable arguments.
-* Receiving Argument Values::   Steps you must follow to access the
-                                  optional argument values.
-* How Many Arguments::          How to decide whether there are more arguments.
-* Calling Variadic Functions::  Things you need to know about calling
-                                  variable arguments functions.
+* Variadic Prototypes::  How to make a prototype for a function
+                         with variable arguments.
+* Receiving Arguments::  Steps you must follow to access the
+                         optional argument values.
+* How Many Arguments::   How to decide whether there are more arguments. 
+* Calling Variadics::    Things you need to know about calling
+                         variable arguments functions.
+* Argument Macros::      Detailed specification of the macros
+                         for accessing variable arguments.
+* Old Varargs::                 The pre-ANSI way of defining variadic functions.
 @end menu
 
 @node Variadic Prototypes
 @subsubsection Syntax for Variable Arguments
+@cindex function prototypes (variadic)
+@cindex prototypes for variadic functions
+@cindex variadic function prototypes
 
 A function that accepts a variable number of arguments must be declared
 with a prototype that says so.   You write the fixed arguments as usual,
@@ -200,13 +209,13 @@ and then tack on @samp{@dots{}} to indicate the possibility of
 additional arguments.  The syntax of ANSI C requires at least one fixed
 argument before the @samp{@dots{}}.  For example,
 
-@example
+@smallexample
 int 
 func (const char *a, int b, @dots{})
 @{
   @dots{}
 @}     
-@end example
+@end smallexample
 
 @noindent
 outlines a definition of a function @code{func} which returns an
@@ -219,11 +228,13 @@ argument must not be declared @code{register} in the function
 definition.  Furthermore, this argument's type must be
 @dfn{self-promoting}: that is, the default promotions must not change
 its type.  This rules out array and function types, as well as
-@code{float}, @code{char} (whether signed or not) and @code{short}
+@code{float}, @code{char} (whether signed or not) and @w{@code{short int}}
 (whether signed or not).  This is actually an ANSI C requirement.
 
-@node Receiving Argument Values
+@node Receiving Arguments
 @subsubsection Receiving the Argument Values
+@cindex variadic function argument access
+@cindex arguments (variadic functions)
 
 Ordinary fixed arguments have individual names, and you can use these
 names to access their values.  But optional arguments have no
@@ -251,8 +262,8 @@ arguments than were supplied in the call, but you will get garbage
 values if you try to access too many arguments.
 
 @item
-You call @code{va_end} to indicate that you are finished with the
-argument pointer variable.
+You indicate that you are finished with the argument pointer variable by
+calling @code{va_end}.
 
 (In practice, with most C compilers, calling @code{va_end} does nothing
 and you do not really need to call it.  This is always true in the GNU C
@@ -260,20 +271,23 @@ compiler.  But you might as well call @code{va_end} just in case your
 program is someday compiled with a peculiar compiler.)
 @end enumerate
 
+@xref{Argument Macros}, for the full definitions of @code{va_start}, 
+@code{va_arg} and @code{va_end}.
+
 Steps 1 and 3 must be performed in the function that accepts the
 optional arguments.  However, you can pass the @code{va_list} variable
 as an argument to another function and perform all or part of step 2
 there.
 
 You can perform the entire sequence of the three steps multiple times
-within a single function invocation.  And, if you don't want to look at
-the optional arguments, you can do these steps zero times.
+within a single function invocation.  If you want to ignore the optional
+arguments, you can do these steps zero times.
 
 You can have more than one argument pointer variable if you like.  You
 can initialize each variable with @code{va_start} when you wish, and
 then you can fetch arguments with each argument pointer as you wish.
 Each argument pointer variable will sequence through the same set of
-argument values.
+argument values, but at its own pace.
 
 @strong{Portability note:} With some compilers, once you pass an
 argument pointer value to a subroutine, you must not keep using the same
@@ -284,6 +298,9 @@ regardless.
 
 @node How Many Arguments
 @subsubsection How Many Arguments Were Supplied
+@cindex number of arguments passed
+@cindex how many arguments
+@cindex arguments, how many
 
 There is no general way for a function to determine the number and type
 of the optional arguments it was called with.  So whoever designs the
@@ -304,27 +321,34 @@ otherwise use a default value.
 
 A required argument can be used as a pattern to specify both the number
 and types of the optional arguments.  The format string argument to
-@code{printf} is one example of this.
+@code{printf} is one example of this (@pxref{Formatted Output Functions}).
 
 Another possibility is to pass an ``end marker'' value as the last
 optional argument.  For example, for a function that manipulates an
 arbitrary number of pointer arguments, a null pointer might indicate the
 end of the argument list.  (This assumes that a null pointer isn't
-otherwise meaningful to the function.)
+otherwise meaningful to the function.)  The @code{execl} function works
+in just this way; see @ref{Executing a File}.
 
 
-@node Calling Variadic Functions
+@node Calling Variadics
 @subsubsection Calling Variadic Functions
+@cindex variadic functions, calling
+@cindex calling variadic functions
+@cindex declaring variadic functions
+
+You don't have to write anything special when you call a variadic function.
+Just write the arguments (required arguments, followed by optional ones)
+inside parentheses, separated by commas, as usual.  But you should prepare
+by declaring the function with a prototype, and you must know how the
+argument values are converted.
 
 In principle, functions that are @emph{defined} to be variadic must also
 be @emph{declared} to be variadic using a function prototype whenever
-you call them.  This is because some C compilers use a different calling
-convention to pass the same set of argument values to a function 
-depending on whether that function takes variable arguments or fixed
-arguments.
-@cindex function prototypes
-@cindex prototypes for variadic functions
-@cindex variadic functions need prototypes
+you call them.  (@xref{Variadic Prototypes}, for how.)  This is because
+some C compilers use a different calling convention to pass the same set
+of argument values to a function depending on whether that function
+takes variable arguments or fixed arguments.
 
 In practice, the GNU C compiler always passes a given set of argument
 types in the same way regardless of whether they are optional or
@@ -340,12 +364,12 @@ have to declare as variadic---for example, @code{open} and
 Since the prototype doesn't specify types for optional arguments, in a
 call to a variadic function the @dfn{default argument promotions} are
 performed on the optional argument values.  This means the objects of
-type @code{char} or @code{short int} (whether signed or not) are
-promoted to either @code{int} or @code{unsigned int}, as appropriate;
-and that objects of type @code{float} are promoted to type
+type @code{char} or @w{@code{short int}} (whether signed or not) are
+promoted to either @code{int} or @w{@code{unsigned int}}, as
+appropriate; and that objects of type @code{float} are promoted to type
 @code{double}.  So, if the caller passes a @code{char} as an optional
-argument, it is promoted to a @code{int}, and the function should get it
-with @code{va_arg (@var{ap}, int)}.
+argument, it is promoted to an @code{int}, and the function should get
+it with @code{va_arg (@var{ap}, int)}.
 
 Conversion of the required arguments is controlled by the function
 prototype in the usual way: the argument expression is converted to the
@@ -353,7 +377,7 @@ declared argument type as if it were being assigned to a variable of
 that type.
 
 @node Argument Macros
-@subsection Argument Access Macros
+@subsubsection Argument Access Macros
 
 Here are descriptions of the macros used to retrieve variable arguments.
 These macros are defined in the header file @file{stdarg.h}.
@@ -367,10 +391,13 @@ The type @code{va_list} is used for argument pointer variables.
 
 @comment stdarg.h
 @comment ANSI
-@deftypefn {Macro} void va_start (va_list @var{ap}, @var{last_required})
+@deftypefn {Macro} void va_start (va_list @var{ap}, @var{last-required})
 This macro initializes the argument pointer variable @var{ap} to point
 to the first of the optional arguments of the current function;
-@var{last_required} must be the last required argument to the function.
+@var{last-required} must be the last required argument to the function.
+
+@xref{Old Varargs}, for an alternate definition of @code{va_start}
+found in the header file @file{varargs.h}.
 @end deftypefn
 
 @comment stdarg.h
@@ -403,76 +430,126 @@ use it except for reasons of portability.
 @node Variadic Example
 @subsection Example of a Variadic Function
 
-Here is a complete sample function that accepts variable numbers of
+Here is a complete sample function that accepts a variable number of
 arguments.  The first argument to the function is the count of remaining
 arguments, which are added up and the result returned.  While trivial,
 this function is sufficient to illustrate how to use the variable
 arguments facility.
 
 @comment Yes, this example has been tested.
-@example
-#include <stdarg.h>
+@smallexample
+@include add.c.texi
+@end smallexample
+
+@node Old Varargs
+@subsubsection Old-Style Variadic Functions
+
+@pindex varargs.h
+Before ANSI C, programmers used a slightly different facility for
+writing variadic functions.  The GNU C compiler still supports it;
+currently, it is more portable than the ANSI C facility, since support
+for ANSI C is still not universal.  The header file which defines the
+old-fashioned variadic facility is called @file{varargs.h}.
+
+Using @file{varargs.h} is almost the same as using @file{stdarg.h}.
+There is no difference in how you call a variadic function;
+@xref{Calling Variadics}.  The only difference is in how you define
+them.  First of all, you must use old-style non-prototype syntax, like
+this:
 
-int 
-add_em_up (int count, @dots{})
+@smallexample
+tree
+build (va_alist)
+     va_dcl
 @{
-  va_list ap;
-  int i, sum;
-
-  va_start (ap, count);           /* @r{Initialize the argument list.} */
-
-  sum = 0;
-  for (i = 0; i < count; i++)
-    sum = sum + va_arg (ap, int); /* @r{Get the next argument value.} */
-
-  va_end (ap);                    /* @r{Clean up.} */
-  return sum;
-@}
+@end smallexample
+
+Secondly, you must give @code{va_start} just one argument, like this:
+
+@smallexample
+  va_list p;
+  va_start (p);
+@end smallexample
+
+These are the special macros used for defining old-style variadic
+functions:
+
+@comment varargs.h
+@comment Unix
+@deffn Macro va_alist
+This macro stands for the argument name list required in a variadic
+function.  
+@end deffn
+
+@comment varargs.h
+@comment Unix
+@deffn Macro va_dcl
+This macro declares the implicit argument or arguments for a variadic
+function.
+@end deffn
+
+@comment varargs.h
+@comment Unix
+@deftypefn {Macro} void va_start (va_list @var{ap})
+This macro, as defined in @file{varargs.h}, initializes the argument
+pointer variable @var{ap} to point to the first argument of the current
+function.
+@end deftypefn
 
-void
-main ()
-@{
-  /* @r{This call prints 16.} */
-  printf ("%d\n", add_em_up (3, 5, 5, 6));
+The other argument macros, @code{va_arg} and @code{va_end}, are the same
+in @file{varargs.h} as in @file{stdarg.h}; see @ref{Argument Macros} for
+details.
 
-  /* @r{This call prints 55.} */
-  printf ("%d\n", add_em_up (10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
-@}
-@end example
+It does not work to include both @file{varargs.h} and @file{stdarg.h} in
+the same compilation; they define @code{va_start} in conflicting ways.
 
 @node Null Pointer Constant
 @section Null Pointer Constant
+@cindex null pointer constant
+
+The null pointer constant is guaranteed not to point to any real object.
+You can assign it to any pointer variable since it has type @code{void
+*}.  The preferred way to write a null pointer constant is with
+@code{NULL}.
 
 @comment stddef.h
 @comment ANSI
 @deftypevr Macro {void *} NULL
-@cindex null pointer
-This is a null pointer constant.  It can be assigned to any pointer
-variable since it has type @code{void *}, and is guaranteed not to
-point to any real object.  This macro is the best way to get a null
-pointer value.  You can also use @code{0} or @code{(void *)0} as a null
-pointer constant, but using @code{NULL} makes the purpose of the
-constant more evident.  
-
-When passing a null pointer as an argument to a function for which there
-is no prototype declaration in scope, you should explicitly cast
-@code{NULL} or @code{0} into a pointer of the appropriate type.  Again,
-this is because the default argument promotions may not do the right
-thing.
+This is a null pointer constant.
 @end deftypevr
 
+You can also use @code{0} or @code{(void *)0} as a null pointer
+constant, but using @code{NULL} is cleaner because it makes the purpose
+of the constant more evident.
+
+If you use the null pointer constant as a function argument, then for
+complete portability you should make sure that the function has a
+prototype declaration.  Otherwise, if the target machine has two
+different pointer representations, the compiler won't know which
+representation to use for that argument.  You can avoid the problem by
+explicitly casting the constant to the proper pointer type, but we
+recommend instead adding a prototype for the function you are calling.
+
 @node Important Data Types
 @section Important Data Types
 
+The result of subtracting two pointers in C is always an integer, but the
+precise data type varies from C compiler to C compiler.  Likewise, the
+data type of the result of @code{sizeof} also varies between compilers.
+ANSI defines standard aliases for these two types, so you can refer to
+them in a portable fashion.  They are defined in the header file 
+@file{stddef.h}.
+@pindex stddef.h
+
 @comment stddef.h
 @comment ANSI
 @deftp {Data Type} ptrdiff_t
 This is the signed integer type of the result of subtracting two
 pointers.  For example, with the declaration @code{char *p1, *p2;}, the
 expression @code{p2 - p1} is of type @code{ptrdiff_t}.  This will
-probably be one of the standard signed integer types (@code{short int},
-@code{int} or @code{long int}), but might be a nonstandard type that
-exists only for this purpose.
+probably be one of the standard signed integer types (@w{@code{short
+int}}, @code{int} or @w{@code{long int}}), but might be a nonstandard
+type that exists only for this purpose.
 @end deftp
 
 @comment stddef.h
@@ -481,31 +558,34 @@ exists only for this purpose.
 This is an unsigned integer type used to represent the sizes of objects.
 The result of the @code{sizeof} operator is of this type, and functions
 such as @code{malloc} (@pxref{Unconstrained Allocation}) and
-@code{memcpy} (@pxref{Copying and Concatenation}) that manipulate
-objects of arbitrary sizes accept arguments of this type to specify
-object sizes.
+@code{memcpy} (@pxref{Copying and Concatenation}) accept arguments of
+this type to specify object sizes.
+
+@strong{Usage Note:} @code{size_t} is the preferred way to declare any
+arguments or variables that hold the size of an object.
 @end deftp
 
-In the GNU system @code{size_t} is equivalent to one of the types 
-@code{unsigned int} and @code{unsigned long int}.  These types have
-identical properties on the GNU system, and for most purposes, you
-can use them interchangeably.  However, they are distinct types, 
-and in certain contexts, you may not treat them as identical.  For
-example, when you specify the type of a function argument in a 
-function prototype, it makes a difference which one you use.  If
-the system header files declare @code{malloc} with an argument
-of type @code{size_t} and you declare @code{malloc} with an argument
-of type @code{unsigned int}, you will get a compilation error if
-@code{size_t} happens to be @code{unsigned long int} on your system.
-To avoid any possibility of error, when a function argument is
-supposed to have type @code{size_t}, always write the type as
-@code{size_t}, and make no assumptions about what that type might
-actually be.
-
-@strong{Compatibility Note:}  Types such as @code{size_t} are new
-features of ANSI C.  Older, pre-ANSI C implementations have
-traditionally used @code{unsigned int} for representing object sizes
-and @code{int} for pointer subtraction results.
+In the GNU system @code{size_t} is equivalent to either
+@w{@code{unsigned int}} or @w{@code{unsigned long int}}.  These types
+have identical properties on the GNU system, and for most purposes, you
+can use them interchangeably.  However, they are distinct as data types,
+which makes a difference in certain contexts.
+
+For example, when you specify the type of a function argument in a
+function prototype, it makes a difference which one you use.  If the
+system header files declare @code{malloc} with an argument of type
+@code{size_t} and you declare @code{malloc} with an argument of type
+@code{unsigned int}, you will get a compilation error if @code{size_t}
+happens to be @code{unsigned long int} on your system.  To avoid any
+possibility of error, when a function argument or value is supposed to
+have type @code{size_t}, never declare its type in any other way.
+
+@strong{Compatibility Note:} Implementations of C before the advent of
+ANSI C generally used @code{unsigned int} for representing object sizes
+and @code{int} for pointer subtraction results.  They did not
+necessarily define either @code{size_t} or @code{ptrdiff_t}.  Unix
+systems did define @code{size_t}, in @file{sys/types.h}, but the
+definition was usually a signed type.
 
 @node Data Type Measurements
 @section Data Type Measurements
@@ -514,50 +594,39 @@ Most of the time, if you choose the proper C data type for each object
 in your program, you need not be concerned with just how it is
 represented or how many bits it uses.  When you do need such
 information, the C language itself does not provide a way to get it.
-But the information is available in macros defined in the header files
-@file{limits.h} and @file{float.h}.
+The header files @file{limits.h} and @file{float.h} contain macros
+which give you this information in full detail.
 
 @menu
-* Integer Type Macros::    Parameters that measure the integer types.
-* Floating Type Macros::   Parameters that measure the floating point types.
-* Structure Measurement::  Getting measurements on structure types.
+* Width of Type::           How many bits does an integer type hold?
+* Range of Type::           What are the largest and smallest values
+                            that an integer type can hold?
+* Floating Type Macros::    Parameters that measure the floating point types. 
+* Structure Measurement::   Getting measurements on structure types.
 @end menu
 
-@node Integer Type Macros
-@subsection Integer Data Type Macros
-@cindex integer type measurements
-@cindex measurements of integer types
+@node Width of Type
+@subsection Computing the Width of an Integer Data Type
+@cindex integer type width
+@cindex width of integer type
 @cindex type measurements, integer
-@cindex limits, integer types
 
 The most common reason that a program needs to know how many bits are in
-an integer type is for using an array of @code{long} as a bit vector.
+an integer type is for using an array of @code{long int} as a bit vector.
 You can access the bit at index @var{n} with
 
-@example
-vector[@var{n} / LONGBITS} & (1 << (@var{n} % LONGBITS))
-@end example
+@smallexample
+vector[@var{n} / LONGBITS] & (1 << (@var{n} % LONGBITS))
+@end smallexample
 
 @noindent
-provided you can define @code{LONGBITS} as the number of bits in a
-@code{long}.
-
-Another reason you might want to know the actual representation of an
-integer type is so that you can decide which type has sufficient range
-for a particular use.  For example, you might want to define a certain
-object as type @code{int} provided that has at least 20 bits of
-precision, and use @code{long} otherwise.
+provided you define @code{LONGBITS} as the number of bits in a
+@code{long int}.
 
 @pindex limits.h
 There is no operator in the C language that can give you the number of
-bits in an integer data type.  But you can get the information from the
-following macros defined in the header file @file{limits.h}.  The values
-of these macros are all integer constant expressions.
-
-The @samp{MAX} and @samp{MIN} macros for @code{char} and @code{short}
-types have values of type @code{int}.  The @samp{MAX} and @samp{MIN}
-macros for the other types have values of the same type described by the
-macro---thus, @code{ULONG_MAX} has type @code{unsigned long int}.
+bits in an integer data type.  But you can compute it from the macro
+@code{CHAR_BIT}, defined in the header file @file{limits.h}.
 
 @table @code
 @comment limits.h
@@ -569,29 +638,57 @@ The value has type @code{int}.
 You can compute the number of bits in any data type @var{type} like
 this:
 
-@example
+@smallexample
 sizeof (@var{type}) * CHAR_BIT
-@end example
+@end smallexample
+@end table
 
+@node Range of Type
+@subsection Range of an Integer Type
+@cindex integer type range
+@cindex range of integer type
+@cindex limits, integer types
+
+Suppose you need to store an integer value which can range from zero to
+one million.  Which is the smallest type you can use?  There is no
+general rule; it depends on the C compiler and target machine.  You can
+use the @samp{MIN} and @samp{MAX} macros in @file{limits.h} to determine
+which type will work.
+
+Each signed integer type has a pair of macros which give the smallest
+and largest values that it can hold.  Each unsigned integer type has one
+such macro, for the maximum value; the minimum value is, of course,
+zero.
+
+The values of these macros are all integer constant expressions.  The
+@samp{MAX} and @samp{MIN} macros for @code{char} and @w{@code{short
+int}} types have values of type @code{int}.  The @samp{MAX} and
+@samp{MIN} macros for the other types have values of the same type
+described by the macro---thus, @code{ULONG_MAX} has type
+@w{@code{unsigned long int}}.
+
+@comment Extra blank lines make it look better.
+@table @code
 @comment limits.h
 @comment ANSI
 @item SCHAR_MIN
-This is the minimum value that can be represented by a @code{signed char}.
+
+This is the minimum value that can be represented by a @w{@code{signed char}}.
 
 @comment limits.h
 @comment ANSI
 @item SCHAR_MAX
-This is the maximum value that can be represented by a @code{signed char}.
-
 @comment limits.h
 @comment ANSI
-@item UCHAR_MAX
-This is the maximum value that can be represented by a @code{unsigned char}.
-(The minimum value of an @code{unsigned char} is zero.)
+@itemx UCHAR_MAX
+
+These are the maximum values that can be represented by a
+@w{@code{signed char}} and @w{@code{unsigned char}}, respectively.
 
 @comment limits.h
 @comment ANSI
 @item CHAR_MIN
+
 This is the minimum value that can be represented by a @code{char}.
 It's equal to @code{SCHAR_MIN} if @code{char} is signed, or zero
 otherwise.
@@ -599,6 +696,7 @@ otherwise.
 @comment limits.h
 @comment ANSI
 @item CHAR_MAX
+
 This is the maximum value that can be represented by a @code{char}.
 It's equal to @code{SCHAR_MAX} if @code{char} is signed, or
 @code{UCHAR_MAX} otherwise.
@@ -606,85 +704,87 @@ It's equal to @code{SCHAR_MAX} if @code{char} is signed, or
 @comment limits.h
 @comment ANSI
 @item SHRT_MIN
-This is the minimum value that can be represented by a @code{signed
-short int}.  On most machines that the GNU C library runs on,
+
+This is the minimum value that can be represented by a @w{@code{signed
+short int}}.  On most machines that the GNU C library runs on,
 @code{short} integers are 16-bit quantities.
 
 @comment limits.h
 @comment ANSI
 @item SHRT_MAX
-This is the maximum value that can be represented by a @code{signed
-short int}.
-
 @comment limits.h
 @comment ANSI
-@item USHRT_MAX
-This is the maximum value that can be represented by an @code{unsigned
-short int}.  (The minimum value of an @code{unsigned short int} is zero.)
+@itemx USHRT_MAX
+
+These are the maximum values that can be represented by a
+@w{@code{signed short int}} and @w{@code{unsigned short int}},
+respectively.
 
 @comment limits.h
 @comment ANSI
 @item INT_MIN
-This is the minimum value that can be represented by a @code{signed
-int}.  On most machines that the GNU C system runs on, an @code{int} is
+
+This is the minimum value that can be represented by a @w{@code{signed
+int}}.  On most machines that the GNU C system runs on, an @code{int} is
 a 32-bit quantity.
 
 @comment limits.h
 @comment ANSI
 @item INT_MAX
-This is the maximum value that can be represented by a @code{signed
-int}.
-
 @comment limits.h
 @comment ANSI
-@item UINT_MAX
-This is the maximum value that can be represented by an @code{unsigned
-int}.  (The minimum value of an @code{unsigned int} is zero.)
+@itemx UINT_MAX
+
+These are the maximum values that can be represented by, respectively,
+the type @w{@code{signed int}} and the type @w{@code{unsigned int}}.
 
 @comment limits.h
 @comment ANSI
 @item LONG_MIN
-This is the minimum value that can be represented by a @code{signed long
-int}.  On most machines that the GNU C system runs on, @code{long}
+
+This is the minimum value that can be represented by a @w{@code{signed
+long int}}.  On most machines that the GNU C system runs on, @code{long}
 integers are 32-bit quantities, the same size as @code{int}.
 
 @comment limits.h
 @comment ANSI
 @item LONG_MAX
-This is the maximum value that can be represented by a @code{signed long
-int}.
-
 @comment limits.h
 @comment ANSI
-@item ULONG_MAX
-This is the maximum value that can be represented by an @code{unsigned
-long int}.  (The minimum value of an @code{unsigned long int} is zero.)
+@itemx ULONG_MAX
+
+These are the maximum values that can be represented by a
+@w{@code{signed long int}} and @code{unsigned long int}, respectively.
 
 @comment limits.h
 @comment GNU
 @item LONG_LONG_MIN
-This is the minimum value that can be represented by a @code{signed long
-long int}.  On most machines that the GNU C system runs on, @code{long
-long} integers are 64-bit quantities.
+
+This is the minimum value that can be represented by a @w{@code{signed
+long long int}}.  On most machines that the GNU C system runs on,
+@w{@code{long long}} integers are 64-bit quantities.
 
 @comment limits.h
 @comment GNU
 @item LONG_LONG_MAX
-This is the maximum value that can be represented by a @code{signed long
-long int}.
+@comment limits.h
+@comment ANSI
+@itemx ULONG_LONG_MAX
+
+These are the maximum values that can be represented by a @code{signed
+long long int} and @code{unsigned long long int}, respectively.
 
 @comment limits.h
 @comment GNU
-@item ULONG_LONG_MAX
-This is the maximum value that can be represented by an @code{unsigned
-long long int}.  (The minimum value of an @code{unsigned long int} is
-zero.)
+@item WCHAR_MAX
+
+This is the maximum value that can be represented by a @code{wchar_t}.
+@xref{Wide Char Intro}.
 @end table
 
 The header file @file{limits.h} also defines some additional constants
 that parameterize various operating system and file system limits.  These
-constants are described in @ref{System Parameters} and @ref{File System
-Parameters}.
+constants are described in @ref{System Configuration}.
 
 @node Floating Type Macros
 @subsection Floating Type Macros
@@ -693,84 +793,86 @@ Parameters}.
 @cindex type measurements, floating
 @cindex limits, floating types
 
-Because floating-point numbers are represented internally as approximate
-quantities, algorithms for manipulating floating-point data often need
-to take account of  the accuracy of the representation.
+The specific representation of floating point numbers varies from
+machine to machine.  Because floating point numbers are represented
+internally as approximate quantities, algorithms for manipulating
+floating point data often need to take account of the precise details of
+the machine's floating point representation.
 
 Some of the functions in the C library itself need this information; for
-example, the algorithms for printing and reading floating-point numbers
-(@pxref{Input/Output on Streams}) and for calculating trigonometric and
+example, the algorithms for printing and reading floating point numbers
+(@pxref{I/O on Streams}) and for calculating trigonometric and
 irrational functions (@pxref{Mathematics}) use it to avoid round-off
 error and loss of accuracy.  User programs that implement numerical
 analysis techniques also often need this information in order to
 minimize or compute error bounds.
 
-The specific representation of floating-point numbers varies from
-machine to machine.  The header file @file{float.h} describes the
-format used by your machine.
+The header file @file{float.h} describes the format used by your
+machine.
 
 @menu
 * Floating Point Concepts::     Definitions of terminology.
-* Floating Type Parameters::    Descriptions of the individual macros.
-* IEEE Floating Point::         How one common representation is described.
+* Floating Point Parameters::   Details of specific macros.
+* IEEE Floating Point::         The measurements for one common
+                                 representation. 
 @end menu
 
 @node Floating Point Concepts
 @subsubsection Floating Point Representation Concepts
 
-This section introduces the terminology used to characterize the
-parameters of floating-point representations.
+This section introduces the terminology for describing floating point
+representations.
 
 You are probably already familiar with most of these concepts in terms
-of scientific or exponential notation for floating-point numbers.  For
+of scientific or exponential notation for floating point numbers.  For
 example, the number @code{123456.0} could be expressed in exponential
 notation as @code{1.23456e+05}, a shorthand notation indicating that the
 mantissa @code{1.23456} is multiplied by the base @code{10} raised to
 power @code{5}.
 
-More formally, the internal representation of a floating-point number
+More formally, the internal representation of a floating point number
 can be characterized in terms of the following parameters:
 
 @itemize @bullet
 @item
-@cindex sign (of floating-point number)
+@cindex sign (of floating point number)
 The @dfn{sign} is either @code{-1} or @code{1}.
 
 @item
-@cindex base (of floating-point number)
-@cindex radix (of floating-point number)
-The @dfn{base} or @dfn{radix} for exponentiation; an integer greater
-than @code{1}.  This is a constant for the particular representation.
+@cindex base (of floating point number)
+@cindex radix (of floating point number)
+The @dfn{base} or @dfn{radix} for exponentiation, an integer greater
+than @code{1}.  This is a constant for a particular representation.
 
 @item
-@cindex exponent (of floating-point number)
+@cindex exponent (of floating point number)
 The @dfn{exponent} to which the base is raised.  The upper and lower
-bounds of the exponent value are constants for the particular
+bounds of the exponent value are constants for a particular
 representation.
 
-@cindex bias (of floating-point number exponent)
-Sometimes, in the actual bits representing the floating-point number,
+@cindex bias (of floating point number exponent)
+Sometimes, in the actual bits representing the floating point number,
 the exponent is @dfn{biased} by adding a constant to it, to make it
 always be represented as an unsigned quantity.  This is only important
 if you have some reason to pick apart the bit fields making up the
-floating-point number by hand, which is something for which the GNU
+floating point number by hand, which is something for which the GNU
 library provides no support.  So this is ignored in the discussion that
 follows.
 
 @item
-@cindex mantissa (of floating-point number)
-@cindex significand (of floating-point number)
-The value of the @dfn{mantissa} or @dfn{significand}, which is an
-unsigned integer.
+@cindex mantissa (of floating point number)
+@cindex significand (of floating point number)
+The @dfn{mantissa} or @dfn{significand}, an unsigned integer which is a
+part of each floating point number.
 
 @item 
-@cindex precision (of floating-point number)
+@cindex precision (of floating point number)
 The @dfn{precision} of the mantissa.  If the base of the representation
 is @var{b}, then the precision is the number of base-@var{b} digits in
-the mantissa.  This is a constant for the particular representation.
+the mantissa.  This is a constant for a particular representation.
 
-@cindex hidden bit (of floating-point number mantissa)
-Many floating-point representations have an implicit @dfn{hidden bit} in
+@cindex hidden bit (of floating point number mantissa)
+Many floating point representations have an implicit @dfn{hidden bit} in
 the mantissa.  This is a bit which is present virtually in the mantissa,
 but not stored in memory because its value is always 1 in a normalized
 number.  The precision figure (see above) includes any hidden bits.
@@ -779,26 +881,35 @@ Again, the GNU library provides no facilities for dealing with such
 low-level aspects of the representation.
 @end itemize
 
-The mantissa of a floating-point number actually represents an implicit
+The mantissa of a floating point number actually represents an implicit
 fraction whose denominator is the base raised to the power of the
 precision.  Since the largest representable mantissa is one less than
 this denominator, the value of the fraction is always strictly less than
-@code{1}.  The mathematical value of a floating-point number is then the
-product of this fraction; the sign; and the base raised to the exponent.
-
-@cindex normalized floating-point number
-If the floating-point number is @dfn{normalized}, the mantissa is also
-greater than or equal to the base raised to the power of one less
-than the precision (unless the number represents a floating-point zero,
-in which case the mantissa is zero).  The fractional quantity is
-therefore greater than or equal to @code{1/@var{b}}, where @var{b} is
-the base.
-
-@node Floating-Point Parameters
-@subsubsection Floating-Point Parameters
-
-@strong{Incomplete:}  This section needs some more concrete examples
-of what these parameters mean and how to use them in a program.
+@code{1}.  The mathematical value of a floating point number is then the
+product of this fraction, the sign, and the base raised to the exponent.
+
+@cindex normalized floating point number
+We say that the floating point number is @dfn{normalized} if the
+fraction is at least @code{1/@var{b}}, where @var{b} is the base.  In
+other words, the mantissa would be too large to fit if it were
+multiplied by the base.  Non-normalized numbers are sometimes called
+@dfn{denormal}; they contain less precision than the representation
+normally can hold.
+
+If the number is not normalized, then you can subtract @code{1} from the
+exponent while multiplying the mantissa by the base, and get another
+floating point number with the same value.  @dfn{Normalization} consists
+of doing this repeatedly until the number is normalized.  Two distinct
+normalized floating point numbers cannot be equal in value.
+
+(There is an exception to this rule: if the mantissa is zero, it is
+considered normalized.  Another exception happens on certain machines
+where the exponent is as small as the representation can hold.  Then
+it is impossible to subtract @code{1} from the exponent, so a number
+may be normalized even if its fraction is less than @code{1/@var{b}}.)
+
+@node Floating Point Parameters
+@subsubsection Floating Point Parameters
 
 @pindex float.h
 These macro definitions can be accessed by including the header file
@@ -808,8 +919,8 @@ Macro names starting with @samp{FLT_} refer to the @code{float} type,
 while names beginning with @samp{DBL_} refer to the @code{double} type
 and names beginning with @samp{LDBL_} refer to the @code{long double}
 type.  (Currently GCC does not support @code{long double} as a distinct
-data type, so the values for the @samp{LDBL_} constants are equal to as
-the corresponding constants for the @code{double} type.)@refill
+data type, so the values for the @samp{LDBL_} constants are equal to the
+corresponding constants for the @code{double} type.)@refill
 
 Of these macros, only @code{FLT_RADIX} is guaranteed to be a constant
 expression.  The other macros listed here cannot be reliably used in
@@ -817,18 +928,21 @@ places that require constant expressions, such as @samp{#if}
 preprocessing directives or in the dimensions of static arrays.
 
 Although the ANSI C standard specifies minimum and maximum values for
-most of these parameters, the GNU C implementation uses whatever
-floating-point representations are supported by the underlying hardware.
-So whether GNU C actually satisfies the ANSI C requirements depends on
-what machine it is running on.
+most of these parameters, the GNU C implementation uses whatever values
+describe the floating point representation of the target machine.  So in
+principle GNU C actually satisfies the ANSI C requirements only if the
+target machine is suitable.  In practice, all the machines currently
+supported are suitable.
 
-@itemize @bullet
+@table @code
 @comment float.h
 @comment ANSI
 @item FLT_ROUNDS
-This value characterizes the rounding mode for floating-point addition.
+This value characterizes the rounding mode for floating point addition.
 The following values indicate standard rounding modes:
 
+@need 750
+
 @table @code
 @item -1
 The mode is indeterminable.
@@ -846,30 +960,59 @@ Rounding is towards negative infinity.
 Any other value represents a machine-dependent nonstandard rounding
 mode.
 
+On most machines, the value is @code{1}, in accordance with the IEEE
+standard for floating point.
+
+Here is a table showing how certain values round for each possible value
+of @code{FLT_ROUNDS}, if the other aspects of the representation match
+the IEEE single-precision standard.
+
+@smallexample
+                0      1             2             3
+ 1.00000003    1.0    1.0           1.00000012    1.0
+ 1.00000007    1.0    1.00000012    1.00000012    1.0
+-1.00000003   -1.0   -1.0          -1.0          -1.00000012
+-1.00000007   -1.0   -1.00000012   -1.0          -1.00000012
+@end smallexample
+
 @comment float.h
 @comment ANSI
 @item FLT_RADIX
 This is the value of the base, or radix, of exponent representation.
 This is guaranteed to be a constant expression, unlike the other macros
-described in this section.
+described in this section.  The value is 2 on all machines we know of
+except the IBM 360 and derivatives.
 
 @comment float.h
 @comment ANSI
 @item FLT_MANT_DIG
-This is the number of base-@code{FLT_RADIX} digits in the floating-point
-mantissa for the @code{float} data type.
+This is the number of base-@code{FLT_RADIX} digits in the floating point
+mantissa for the @code{float} data type.  The following expression
+yields @code{1.0} (even though mathematically it should not) due to the
+limited number of mantissa digits:
+
+@smallexample
+float radix = FLT_RADIX;
+
+1.0f + 1.0f / radix / radix / @dots{} / radix
+@end smallexample
+
+@noindent
+where @code{radix} appears @code{FLT_MANT_DIG} times.
 
 @comment float.h
 @comment ANSI
 @item DBL_MANT_DIG
 @itemx LDBL_MANT_DIG
-This is the number of base-@code{FLT_RADIX} digits in the floating-point
+This is the number of base-@code{FLT_RADIX} digits in the floating point
 mantissa for the data types @code{double} and @code{long double},
 respectively.
 
+@comment Extra blank lines make it look better.
 @comment float.h
 @comment ANSI
 @item FLT_DIG
+
 This is the number of decimal digits of precision for the @code{float}
 data type.  Technically, if @var{p} and @var{b} are the precision and
 base (respectively) for the representation, then the decimal precision
@@ -878,54 +1021,55 @@ point number with @var{q} base 10 digits can be rounded to a floating
 point number with @var{p} base @var{b} digits and back again, without
 change to the @var{q} decimal digits.
 
-The value of this macro is guaranteed to be at least @code{6}.
+The value of this macro is supposed to be at least @code{6}, to satisfy
+ANSI C.
 
 @comment float.h
 @comment ANSI
 @item DBL_DIG
 @itemx LDBL_DIG
+
 These are similar to @code{FLT_DIG}, but for the data types
 @code{double} and @code{long double}, respectively.  The values of these
-macros are guaranteed to be at least @code{10}.
+macros are supposed to be at least @code{10}.
 
 @comment float.h
 @comment ANSI
 @item FLT_MIN_EXP
-This is the minimum negative integer such that the mathematical value
+This is the smallest possible exponent value for type @code{float}.
+More precisely, is the minimum negative integer such that the value
 @code{FLT_RADIX} raised to this power minus 1 can be represented as a
-normalized floating-point number of type @code{float}.  In terms of the
-actual implementation, this is just the smallest value that can be
-represented in the exponent field of the number.
+normalized floating point number of type @code{float}.
 
 @comment float.h
 @comment ANSI
 @item DBL_MIN_EXP
 @itemx LDBL_MIN_EXP
+
 These are similar to @code{FLT_MIN_EXP}, but for the data types
 @code{double} and @code{long double}, respectively.
 
 @comment float.h
 @comment ANSI
 @item FLT_MIN_10_EXP
-This is the minimum negative integer such that the mathematical value
-@code{10} raised to this power minus 1 can be represented as a
-normalized floating-point number of type @code{float}.  This is
-guaranteed to be no greater than @code{-37}.
+This is the minimum negative integer such that @code{10} raised to this
+power minus 1 can be represented as a normalized floating point number
+of type @code{float}.  This is supposed to be @code{-37} or even less.
 
 @comment float.h
 @comment ANSI
 @item DBL_MIN_10_EXP
+@itemx LDBL_MIN_10_EXP
 These are similar to @code{FLT_MIN_10_EXP}, but for the data types
 @code{double} and @code{long double}, respectively.
 
 @comment float.h
 @comment ANSI
 @item FLT_MAX_EXP
-This is the maximum negative integer such that the mathematical value
+This is the largest possible exponent value for type @code{float}.  More
+precisely, this is the maximum positive integer such that value
 @code{FLT_RADIX} raised to this power minus 1 can be represented as a
-floating-point number of type @code{float}.  In terms of the actual
-implementation, this is just the largest value that can be represented
-in the exponent field of the number.
+floating point number of type @code{float}.
 
 @comment float.h
 @comment ANSI
@@ -937,10 +1081,9 @@ These are similar to @code{FLT_MAX_EXP}, but for the data types
 @comment float.h
 @comment ANSI
 @item FLT_MAX_10_EXP
-This is the maximum negative integer such that the mathematical value
-@code{10} raised to this power minus 1 can be represented as a
-normalized floating-point number of type @code{float}.  This is
-guaranteed to be at least @code{37}.
+This is the maximum positive integer such that @code{10} raised to this
+power minus 1 can be represented as a normalized floating point number
+of type @code{float}.  This is supposed to be at least @code{37}.
 
 @comment float.h
 @comment ANSI
@@ -952,14 +1095,18 @@ These are similar to @code{FLT_MAX_10_EXP}, but for the data types
 @comment float.h
 @comment ANSI
 @item FLT_MAX
+
 The value of this macro is the maximum number representable in type
-@code{float}.  It is guaranteed to be at least @code{1E+37}.  The value
+@code{float}.  It is supposed to be at least @code{1E+37}.  The value
 has type @code{float}.
 
+The smallest representable number is @code{- FLT_MAX}.
+
 @comment float.h
 @comment ANSI
 @item DBL_MAX
 @itemx LDBL_MAX
+
 These are similar to @code{FLT_MAX}, but for the data types
 @code{double} and @code{long double}, respectively.  The type of the
 macro's value is the same as the type it describes.
@@ -967,14 +1114,16 @@ macro's value is the same as the type it describes.
 @comment float.h
 @comment ANSI
 @item FLT_MIN
-The value of this macro is the minimum normalized positive
-floating-point number that is representable by type @code{float}, and is
-guaranteed to be no more than @code{1E-37}.
+
+The value of this macro is the minimum normalized positive floating
+point number that is representable in type @code{float}.  It is supposed
+to be no more than @code{1E-37}.
 
 @comment float.h
 @comment ANSI
 @item DBL_MIN
 @itemx LDBL_MIN
+
 These are similar to @code{FLT_MIN}, but for the data types
 @code{double} and @code{long double}, respectively.  The type of the
 macro's value is the same as the type it describes.
@@ -982,29 +1131,32 @@ macro's value is the same as the type it describes.
 @comment float.h
 @comment ANSI
 @item FLT_EPSILON
-This is the minimum positive floating-point number of type @code{float}
-such that @code{1.0 + FLT_EPSILON != 1.0} is true.  It's guaranteed to
+
+This is the minimum positive floating point number of type @code{float}
+such that @code{1.0 + FLT_EPSILON != 1.0} is true.  It's supposed to
 be no greater than @code{1E-5}.
 
 @comment float.h
 @comment ANSI
 @item DBL_EPSILON
 @itemx LDBL_EPSILON
-These are similar to @code{FLT_MIN}, but for the data types
+
+These are similar to @code{FLT_EPSILON}, but for the data types
 @code{double} and @code{long double}, respectively.  The type of the
-macro's value is the same as the type it describes.  The values are
-never greater than @code{1E-9}.
-@end itemize
+macro's value is the same as the type it describes.  The values are not
+supposed to be greater than @code{1E-9}.
+@end table
 
 @node IEEE Floating Point
 @subsubsection IEEE Floating Point
-@cindex IEEE floating-point representation 
-@cindex floating-point, IEEE
+@cindex IEEE floating point representation 
+@cindex floating point, IEEE
 
-Here is an example showing how the floating type measurements work for
-the most common floating point representation, specified by the
-@cite{IEEE Standard for Binary Floating-Point Arithmetic (ANSI/IEEE Std
-754-1985)}.  Nearly all computers today use this format.
+Here is an example showing how the floating type measurements come out
+for the most common floating point representation, specified by the
+@cite{IEEE Standard for Binary Floating Point Arithmetic (ANSI/IEEE Std
+754-1985)}.  Nearly all computers designed since the 1980s use this
+format.
 
 The IEEE single-precision float representation uses a base of 2.  There
 is a sign bit, a mantissa with 23 bits plus one hidden bit (so the total
@@ -1015,7 +1167,7 @@ So, for an implementation that uses this representation for the
 @code{float} data type, appropriate values for the corresponding
 parameters are:
 
-@example
+@smallexample
 FLT_RADIX                             2
 FLT_MANT_DIG                         24
 FLT_DIG                               6
@@ -1026,11 +1178,11 @@ FLT_MAX_10_EXP                      +38
 FLT_MIN                 1.17549435E-38F
 FLT_MAX                 3.40282347E+38F
 FLT_EPSILON             1.19209290E-07F
-@end example
+@end smallexample
 
 Here are the values for the @code{double} data type:
 
-@example
+@smallexample
 DBL_MANT_DIG                         53
 DBL_DIG                              15
 DBL_MIN_EXP                       -1021
@@ -1040,13 +1192,13 @@ DBL_MAX_10_EXP                      308
 DBL_MAX         1.7976931348623157E+308
 DBL_MIN         2.2250738585072014E-308
 DBL_EPSILON     2.2204460492503131E-016
-@end example
+@end smallexample
 
 @node Structure Measurement
-@subsection Structure Type Measurement
+@subsection Structure Field Offset Measurement
 
 You can use @code{offsetof} to measure the location within a structure
-type of a particular structure field.
+type of a particular structure member.
 
 @comment stddef.h
 @comment ANSI