(_hurd_sig_post): __sig_post renamed to __msg_sig_post.
[kopensolaris-gnu/glibc.git] / manual / lang.texi
index 4d0933b..66d4184 100644 (file)
@@ -1,5 +1,5 @@
-@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 implemented by the C library really should be
 thought of as parts of the C language itself.  These facilities ought to
@@ -56,9 +56,9 @@ If @code{NDEBUG} is not defined, @code{assert} tests the value of
 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}).
@@ -82,12 +82,12 @@ detecting @emph{internal inconsistency}; it is not suitable for
 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
@@ -131,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.
@@ -193,6 +194,7 @@ additional variable arguments.  @xref{Calling Variadics}.
                          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
@@ -207,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
@@ -226,7 +228,7 @@ 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 Arguments
@@ -319,13 +321,14 @@ 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 Variadics
@@ -361,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
@@ -388,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
@@ -424,16 +430,78 @@ 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
+@smallexample
 @include add.c.texi
-@end example
+@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:
+
+@smallexample
+tree
+build (va_alist)
+     va_dcl
+@{
+@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
+
+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.
+
+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
@@ -479,9 +547,9 @@ them in a portable fashion.  They are defined in the header file
 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
@@ -497,10 +565,10 @@ this type to specify object sizes.
 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 as data types, 
+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
@@ -512,12 +580,12 @@ 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:} Pre-ANSI C implementations 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.
+@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
@@ -544,16 +612,16 @@ which give you this information in full detail.
 @cindex type measurements, integer
 
 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 define @code{LONGBITS} as the number of bits in a
-@code{long}.
+@code{long int}.
 
 @pindex limits.h
 There is no operator in the C language that can give you the number of
@@ -570,9 +638,9 @@ 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
@@ -593,27 +661,34 @@ 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 @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}.
+@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
+@comment limits.h
+@comment ANSI
 @itemx UCHAR_MAX
-These are the maximum values that can be represented by a @code{signed
-char} and @code{unsigned char}, respectively.
+
+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.
@@ -621,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.
@@ -628,64 +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
+@comment limits.h
+@comment ANSI
 @itemx USHRT_MAX
-These are the maximum values that can be represented by a @code{signed
-short int} and @code{unsigned short int}, respectively.
+
+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
+@comment limits.h
+@comment ANSI
 @itemx UINT_MAX
-These are the maximum values that can be represented by a @code{signed
-int} and @code{unsigned int}, respectively.
+
+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
+@comment limits.h
+@comment ANSI
 @itemx ULONG_MAX
-These are the maximum values that can be represented by a @code{signed
-long int} and @code{unsigned long int}, respectively.
+
+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
+@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 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
@@ -812,9 +911,6 @@ may be normalized even if its fraction is less than @code{1/@var{b}}.)
 @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.
-
 @pindex float.h
 These macro definitions can be accessed by including the header file
 @file{float.h} in your program.
@@ -838,13 +934,15 @@ 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.
 The following values indicate standard rounding modes:
 
+@need 750
+
 @table @code
 @item -1
 The mode is indeterminable.
@@ -862,18 +960,45 @@ 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.
+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
@@ -883,9 +1008,11 @@ 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
@@ -901,6 +1028,7 @@ ANSI C.
 @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 supposed to be at least @code{10}.
@@ -917,6 +1045,7 @@ normalized floating point number of type @code{float}.
 @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.
 
@@ -930,6 +1059,7 @@ 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.
 
@@ -937,7 +1067,7 @@ These are similar to @code{FLT_MIN_10_EXP}, but for the data types
 @comment ANSI
 @item FLT_MAX_EXP
 This is the largest possible exponent value for type @code{float}.  More
-precisely, this is the maximum negative integer such that value
+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}.
 
@@ -951,7 +1081,7 @@ 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 @code{10} raised to this
+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}.
 
@@ -965,6 +1095,7 @@ 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 supposed to be at least @code{1E+37}.  The value
 has type @code{float}.
@@ -975,6 +1106,7 @@ The smallest representable number is @code{- FLT_MAX}.
 @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.
@@ -982,6 +1114,7 @@ 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 in type @code{float}.  It is supposed
 to be no more than @code{1E-37}.
@@ -990,6 +1123,7 @@ to be no more than @code{1E-37}.
 @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.
@@ -997,6 +1131,7 @@ 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 supposed to
 be no greater than @code{1E-5}.
@@ -1005,11 +1140,12 @@ be no greater than @code{1E-5}.
 @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 not
 supposed to be greater than @code{1E-9}.
-@end itemize
+@end table
 
 @node IEEE Floating Point
 @subsubsection IEEE Floating Point
@@ -1031,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
@@ -1042,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
@@ -1056,7 +1192,7 @@ 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 Field Offset Measurement