
SYNOPSIS
       #include <aio.h>

DESCRIPTION
       The <'aio'.h> header shall define the 'aiocb' structure which shall include
       at least the following members:


              int             'aio_fildes'     File descriptor.
              off_t           'aio_offset'     File offset.
              volatile void  *'aio_buf'        Location of buffer.
              size_t          'aio_nbytes'     Length of transfer.
              int             'aio_reqprio'    Request priority offset.
              struct sigevent 'aio_sigevent'   Signal number and value.
              int             'aio_lio_opcode' Operation to be performed.

       This header shall also include the following constants:

       'AIO_ALLDONE'
              A return value indicating that none of the requested  operations
              could be canceled since they are already complete.

       'AIO_CANCELED'
              A  return  value  indicating  that all requested operations have
              been canceled.

       'AIO_NOTCANCELED'

              A return value indicating that some of the requested  operations
              could not be canceled since they are in progress.

       'LIO_NOP'
              A  lio_listio()  element  operation  option  indicating  that no
              transfer is requested.

       'LIO_NOWAIT'
              A lio_listio() synchronization  operation  indicating  that  the
              calling  thread  is to continue execution while the lio_listio()
              operation is being performed, and no notification is given  when
              the operation is complete.

       'LIO_READ'
              A lio_listio() element operation option requesting a read.

       'LIO_WAIT'
              A  lio_listio()  synchronization  operation  indicating that the
              calling thread is to suspend until the lio_listio() operation is
              complete.

       'LIO_WRITE'
              A lio_listio() element operation option requesting a write.


       
SYNOPSIS
       #include <assert.h>

DESCRIPTION
       The  <'assert'.h>  header  shall define the assert() macro.  It refers to
       the macro 'NDEBUG' which is not defined  in  the  header.  If  NDEBUG  is
       defined  as  a  macro  name  before  the  inclusion of this header, the
       assert() macro shall be defined simply as:


              #define assert(ignore)((void) 0)

       Otherwise, the macro behaves as described in assert().

       The assert() macro shall be redefined according to the current state of
       NDEBUG each time <assert.h> is included.

       The  assert() macro shall be implemented as a macro, not as a function.
       If the macro definition is suppressed in  order  to  access  an  actual
       function, the behavior is undefined.

       
SYNOPSIS
       #include <complex.h>

DESCRIPTION
       The <complex.h> header shall define the following macros:

       'complex'
              Expands to '_Complex'.

       '_Complex_I'
              Expands  to  a constant expression of type const float _Complex,
              with the value of the imaginary unit (that is, a number  i  such
              that i**2=-1).

       'imaginary'
              Expands to '_Imaginary'.

       '_Imaginary_I'
              Expands  to a constant expression of type const float _Imaginary
              with the value of the imaginary unit.

       'I'      Expands to either _Imaginary_I or _Complex_I. If _Imaginary_I is
              not defined, I expands to _Complex_I.


       The  macros  imaginary and _Imaginary_I shall be defined if and only if
       the implementation supports imaginary types.

       An application may undefine and then, perhaps,  redefine  the  complex,
       imaginary, and I macros.

       
SYNOPSIS
       #include <cpio.h>

DESCRIPTION
       Values  needed  by  the  c_mode  field  of  the 'cpio' archive format are
       described as follows:

          Name     Description                               Value (Octal)
          'C_IRUSR'  Read by owner.                            0000400
          'C_IWUSR'  Write by owner.                           0000200
          'C_IXUSR'  Execute by owner.                         0000100
          'C_IRGRP'  Read by group.                            0000040
          'C_IWGRP'  Write by group.                           0000020
          'C_IXGRP'  Execute by group.                         0000010
          'C_IROTH'  Read by others.                           0000004
          'C_IWOTH'  Write by others.                          0000002
          'C_IXOTH'  Execute by others.                        0000001
          'C_ISUID'  Set user ID.                              0004000
          'C_ISGID'  Set group ID.                             0002000
          'C_ISVTX'  On directories, restricted deletion flag. 0001000
          'C_ISDIR'  Directory.                                0040000
          'C_ISFIFO' FIFO.                                     0010000
          'C_ISREG'  Regular file.                             0100000
          'C_ISBLK'  Block special.                            0060000
          'C_ISCHR'  Character special.                        0020000
          'C_ISCTG'  Reserved.                                 0110000
          'C_ISLNK'  Symbolic link.                            0120000
          'C_ISSOCK' Socket.                                   0140000

       The header shall define the symbolic constant:


              'MAGIC'    "070707"

       
SYNOPSIS
       #include <ctype.h>

DESCRIPTION 'ctype'
       Some  of the functionality described on this reference page extends the
       ISO C standard. Applications shall define the appropriate feature  test
       macro  (see  the System Interfaces volume of IEEE Std 1003.1-2001, Sec-
       tion 2.2, The Compilation Environment)  to  enable  the  visibility  of
       these symbols in this header.

       
SYNOPSIS
       #include <dirent.h>

DESCRIPTION
       The internal format of directories is unspecified.

       The <'dirent'.h> header shall define the following type:

       'DIR'    A type representing a directory stream.


       It  shall also define the structure dirent which shall include the fol-
       lowing members:


              ino_t  'd_ino'       File serial number.

              char   'd_name'[]    Name of entry.

       The type 'ino_t' shall be defined as described in <sys/types.h> .

       The character array d_name is of unspecified size, but  the  number  of
       bytes  preceding the terminating null byte shall not exceed {'NAME_MAX'}.

       
SYNOPSIS
       #include <dlfcn.h>

DESCRIPTION
       The <'dlfcn'.h> header shall define at least the following macros for use
       in the construction of a 'dlopen'() mode argument:

       'RTLD_LAZY'
              Relocations are performed at an implementation-defined time.

       'RTLD_NOW'
              Relocations are performed when the object is loaded.

       'RTLD_GLOBAL'
              All symbols are available for  relocation  processing  of  other
              modules.

       'RTLD_LOCAL'
              All  symbols are not made available for relocation processing by
              other modules.


       
SYNOPSIS
       #include <errno.h>

DESCRIPTION
       Some  of the functionality described on this reference page extends the
       ISO C standard. Any conflict between the  requirements  described  here
       and   the   ISO C   standard   is   unintentional.    This   volume  of
       IEEE Std 1003.1-2001 defers to the ISO C standard.

       The ISO C standard only requires  the  symbols  [EDOM],  [EILSEQ],  and
       [ERANGE] to be defined.

       The  <'errno'.h>  header  shall  provide a declaration for errno and give
       positive values for the  following  symbolic  constants.  Their  values
       shall be unique except as noted below.

       'E2BIG'  Argument list too long.

       'EACCES' Permission denied.

       'EADDRINUSE'
              Address in use.

       'EADDRNOTAVAIL'
              Address not available.

       'EAFNOSUPPORT'
              Address family not supported.

       'EAGAIN' Resource  unavailable,  try  again  (may  be  the  same value as
              [EWOULDBLOCK]).

       'EALREADY'
              Connection already in progress.

       'EBADF'  Bad file descriptor.

       'EBADMSG'
              Bad message.

       'EBUSY'  Device or resource busy.

       'ECANCELED'
              Operation canceled.

       'ECHILD' No child processes.

       'ECONNABORTED'
              Connection aborted.

       'ECONNREFUSED'
              Connection refused.

       ECONNRESET
              Connection reset.

       'EDEADLK'
              Resource deadlock would occur.

       'EDESTADDRREQ'
              Destination address required.

       'EDOM'   Mathematics argument out of domain of function.

       'EDQUOT' Reserved.

       'EEXIST' File exists.

       'EFAULT' Bad address.

       'EFBIG'  File too large.

       'EHOSTUNREACH'
              Host is unreachable.

       'EIDRM'  Identifier removed.

       'EILSEQ' Illegal byte sequence.

       'EINPROGRESS'
              Operation in progress.

       'EINTR'  Interrupted function.

       'EINVAL' Invalid argument.

       'EIO'    I/O error.

       'EISCONN'
              Socket is connected.

       'EISDIR' Is a directory.

       'ELOOP'  Too many levels of symbolic links.

       'EMFILE' Too many open files.

       'EMLINK' Too many links.

       'EMSGSIZE'
              Message too large.

       'EMULTIHOP'
              Reserved.

       'ENAMETOOLONG'
              Filename too long.

       'ENETDOWN'
              Network is down.

       'ENETRESET'
              Connection aborted by network.

       'ENETUNREACH'
              Network unreachable.

       'ENFILE' Too many files open in system.

       'ENOBUFS'
              No buffer space available.

       'ENODATA'
              No message is available on the STREAM head read queue.

       'ENODEV' No such device.

       'ENOENT' No such file or directory.

       'ENOEXEC'
              Executable file format error.

       'ENOLCK' No locks available.

       'ENOLINK'
              Reserved.

       'ENOMEM' Not enough space.

       'ENOMSG' No message of the desired type.

       'ENOPROTOOPT'
              Protocol not available.

       'ENOSPC' No space left on device.

       'ENOSR'  No STREAM resources.

       'ENOSTR' Not a STREAM.

       'ENOSYS' Function not supported.

       'ENOTCONN'
              The socket is not connected.

       'ENOTDIR'
              Not a directory.

       'ENOTEMPTY'
              Directory not empty.

       'ENOTSOCK'
              Not a socket.

       'ENOTSUP'
              Not supported.

       'ENOTTY' Inappropriate I/O control operation.

       'ENXIO'  No such device or address.

       'EOPNOTSUPP'
              Operation not supported on socket.

       'EOVERFLOW'
              Value too large to be stored in data type.

       'EPERM'  Operation not permitted.

       'EPIPE'  Broken pipe.

       'EPROTO' Protocol error.

       'EPROTONOSUPPORT'

              Protocol not supported.

       'EPROTOTYPE'
              Protocol wrong type for socket.

       'ERANGE' Result too large.

       'EROFS'  Read-only file system.

       'ESPIPE' Invalid seek.

       'ESRCH'  No such process.

       'ESTALE' Reserved.

       'ETIME'  Stream ioctl() timeout.

       'ETIMEDOUT'
              Connection timed out.

       'ETXTBSY'
              Text file busy.

       'EWOULDBLOCK'
              Operation would block (may be the same value as [EAGAIN]).

       'EXDEV'  Cross-device link.


       
SYNOPSIS
       #include <fcntl.h>

DESCRIPTION
       The  <'fcntl'.h> header shall define the following requests and arguments
       for use by the functions 'fcntl'() and 'open'().

       Values for cmd used by fcntl() (the following values are unique) are as
       follows:

       'F_DUPFD'
              Duplicate file descriptor.

       'F_GETFD'
              Get file descriptor flags.

       'F_SETFD'
              Set file descriptor flags.

       'F_GETFL'
              Get file status flags and file access modes.

       'F_SETFL'
              Set file status flags.

       'F_GETLK'
              Get record locking information.

       'F_SETLK'
              Set record locking information.

       'F_SETLKW'
              Set record locking information; wait if blocked.

       'F_GETOWN'
              Get process or process group ID to receive SIGURG signals.

       'F_SETOWN'
              Set process or process group ID to receive SIGURG signals.


       File descriptor flags used for fcntl() are as follows:

       'FD_CLOEXEC'
              Close the file descriptor upon execution of an exec family func-
              tion.


       Values for l_type used for record locking with fcntl()  (the  following
       values are unique) are as follows:

       'F_RDLCK'
              Shared or read lock.

       'F_UNLCK'
              Unlock.

       'F_WRLCK'
              Exclusive or write lock.


       The values used for l_whence, 'SEEK_SET', 'SEEK_CUR', and 'SEEK_END' shall be
       defined as described in <unistd.h> .

       The following values are file creation flags and are used in the  oflag
       value to open(). They shall be bitwise-distinct.

       'O_CREAT'
              Create file if it does not exist.

       'O_EXCL' Exclusive use flag.

       'O_NOCTTY'
              Do not assign controlling terminal.

       'O_TRUNC'
              Truncate flag.


       File status flags used for open() and fcntl() are as follows:

       'O_APPEND'
              Set append mode.

       'O_DSYNC'
              Write according to synchronized I/O data integrity completion.

       'O_NONBLOCK'
              Non-blocking mode.

       'O_RSYNC'
              Synchronized read I/O operations.

       'O_SYNC' Write according to synchronized I/O file integrity completion.


       Mask for use with file access modes is as follows:

       'O_ACCMODE'
              Mask for file access modes.


       File access modes used for open() and fcntl() are as follows:

       'O_RDONLY'
              Open for reading only.

       'O_RDWR' Open for reading and writing.

       'O_WRONLY'
              Open for writing only.


       The  symbolic names for file modes for use as values of mode_t shall be
       defined as described in <sys/stat.h> .

       Values for advice used by 'posix_fadvise'() are as follows:

       'POSIX_FADV_NORMAL'

              The application has no advice  to  give  on  its  behavior  with
              respect  to the specified data. It is the default characteristic
              if no advice is given for an open file.

       'POSIX_FADV_SEQUENTIAL'

              The application expects to access  the  specified  data  sequen-
              tially from lower offsets to higher offsets.

       'POSIX_FADV_RANDOM'

              The application expects to access the specified data in a random
              order.

       'POSIX_FADV_WILLNEED'

              The application expects to access the specified data in the near
              future.

       'POSIX_FADV_DONTNEED'

              The  application  expects  that it will not access the specified
              data in the near future.

       'POSIX_FADV_NOREUSE'

              The application expects to access the specified  data  once  and
              then not reuse it thereafter.


       The structure 'flock' describes a file lock. It shall include the follow-
       ing members:


              short  'l_type'   Type of lock; 'F_RDLCK', 'F_WRLCK', 'F_UNLCK'.
              short  'l_whence' Flag for starting offset.
              off_t  'l_start'  Relative offset in bytes.
              off_t  'l_len'    Size; if 0 then until EOF.
              pid_t  'l_pid'    Process ID of the process holding the lock; returned with F_GETLK.

       The mode_t, off_t, and pid_t types shall be  defined  as  described  in
       <sys/types.h> .

       
SYNOPSIS
       #include <fenv.h>

DESCRIPTION
       The <'fenv'.h> header shall define the following data types through type-
       def:

       'fenv_t' Represents the entire floating-point environment. The  floating-
              point environment refers collectively to any floating-point sta-
              tus flags and control modes supported by the implementation.

       'fexcept_t'
              Represents the floating-point status flags collectively, includ-
              ing  any  status the implementation associates with the flags. A
              floating-point status flag is a system variable whose  value  is
              set  (but  never  cleared)  when  a  floating-point exception is
              raised, which occurs as a side effect of  exceptional  floating-
              point  arithmetic  to provide auxiliary information. A floating-
              point control mode is a system variable whose value may  be  set
              by  the user to affect the subsequent behavior of floating-point
              arithmetic.


       The <fenv.h> header shall define the following constants if and only if
       the  implementation  supports  the floating-point exception by means of
       the  floating-point   functions   'feclearexcept'(),   'fegetexceptflag'(),
       'feraiseexcept'(), 'fesetexceptflag'(), and 'fetestexcept'(). Each expands to
       an integer constant expression with values such that  bitwise-inclusive
       ORs of all combinations of the constants result in distinct values.


              'FE_DIVBYZERO'
              'FE_INEXACT'
              'FE_INVALID'
              'FE_OVERFLOW'
              'FE_UNDERFLOW'

       The  <fenv.h> header shall define the following constant, which is sim-
       ply the bitwise-inclusive OR of all floating-point exception  constants
       defined above:


              'FE_ALL_EXCEPT'

       The <fenv.h> header shall define the following constants if and only if
       the implementation supports getting and setting the represented  round-
       ing  direction by means of the fegetround() and fesetround() functions.
       Each expands to an integer constant expression whose  values  are  dis-
       tinct non-negative vales.


              'FE_DOWNWARD'
              'FE_TONEAREST'
              'FE_TOWARDZERO'
              'FE_UPWARD'

       The  <fenv.h>  header shall define the following constant, which repre-
       sents  the  default  floating-point  environment  (that  is,  the   one
       installed  at  program startup) and has type pointer to const-qualified
       fenv_t. It can be used as an  argument  to  the  functions  within  the
       <fenv.h> header that manage the floating-point environment.


              'FE_DFL_ENV'

       
SYNOPSIS
       #include <'float'.h>

DESCRIPTION
       The  characteristics  of floating types are defined in terms of a model
       that describes a representation of floating-point  numbers  and  values
       that  provide  information  about  an  implementation's  floating-point
       arithmetic.

       The following parameters are used to define the model for  each  float-
       ing-point type:

       s      Sign (+-1).

       b      Base or radix of exponent representation (an integer >1).

       e      Exponent  (an  integer  between  a  minimum  e_min and a maximum
              e_max).

       p      Precision (the number of base-b digits in the significand).

       f_k    Non-negative integers less than b (the significand digits).


       A floating-point number x is defined by the following model:


       In addition to  normalized  floating-point  numbers  (f_1>0  if  x!=0),
       floating  types  may  be  able to contain other kinds of floating-point
       numbers, such as subnormal floating-point numbers  (  x!=0,  e=  e_min,
       f_1=0)  and  unnormalized  floating-point  numbers  (  x!=0,  e> e_min,
       f_1=0), and values that are not floating-point numbers, such as infini-
       ties  and  NaNs.  A NaN is an encoding signifying Not-a-Number. A quiet
       NaN propagates through almost every arithmetic operation without  rais-
       ing  a  floating-point  exception;  a  signaling NaN generally raises a
       floating-point exception when occurring as an arithmetic operand.

       The accuracy of the floating-point operations ( '+' , '-' , '*' , '/' )
       and  of  the  library functions in <math.h> and <complex.h> that return
       floating-point results is  implementation-defined.  The  implementation
       may state that the accuracy is unknown.

       All integer values in the <float.h> header, except FLT_ROUNDS, shall be
       constant expressions suitable for use in #if preprocessing  directives;
       all  floating  values  shall  be constant expressions. All except DECI-
       MAL_DIG, FLT_EVAL_METHOD, FLT_RADIX, and FLT_ROUNDS have separate names
       for  all three floating-point types. The floating-point model represen-
       tation  is  provided  for  all  values   except   FLT_EVAL_METHOD   and
       FLT_ROUNDS.

       The  rounding  mode for floating-point addition is characterized by the
       implementation-defined value of 'FLT_ROUNDS':

       -1     Indeterminable.

        0     Toward zero.

        1     To nearest.

        2     Toward positive infinity.

        3     Toward negative infinity.


       All other values  for  FLT_ROUNDS  characterize  implementation-defined
       rounding behavior.

       The  values  of operations with floating operands and values subject to
       the usual arithmetic conversions and of floating constants  are  evalu-
       ated to a format whose range and precision may be greater than required
       by the type. The use of evaluation  formats  is  characterized  by  the
       implementation-defined value of 'FLT_EVAL_METHOD':

       -1     Indeterminable.

        0     Evaluate all operations and constants just to the range and pre-
              cision of the type.

        1     Evaluate operations and constants of type float  and  double  to
              the range and precision of the double type; evaluate long double
              operations and constants to the range and precision of the  long
              double type.

        2     Evaluate all operations and constants to the range and precision
              of the long double type.


       All other negative values for FLT_EVAL_METHOD characterize  implementa-
       tion-defined behavior.

       The  values  given  in  the following list shall be defined as constant
       expressions with implementation-defined  values  that  are  greater  or
       equal in magnitude (absolute value) to those shown, with the same sign.

        * Radix of exponent representation, b.

       'FLT_RADIX'
              2



        * Number of base-FLT_RADIX digits in the  floating-point  significand,
          p.

       'FLT_MANT_DIG'

       'DBL_MANT_DIG'

       'LDBL_MANT_DIG'



        * Number  of decimal digits, n, such that any floating-point number in
          the widest supported floating type with p_max radix b digits can  be
          rounded  to  a  floating-point number with n decimal digits and back
          again without change to the value.


       'DECIMAL_DIG'
              10



        * Number of decimal digits, q, such  that  any  floating-point  number
          with  q  decimal  digits can be rounded into a floating-point number
          with p radix b digits and back again without change to the q decimal
          digits.


       'FLT_DIG'
              6

       'DBL_DIG'
              10

       'LDBL_DIG'
              10



        * Minimum  negative  integer  such that FLT_RADIX raised to that power
          minus 1 is a normalized floating-point number, e_min.

       'FLT_MIN_EXP'

       'DBL_MIN_EXP'

       'LDBL_MIN_EXP'



        * Minimum negative integer such that 10 raised to that power is in the
          range of normalized floating-point numbers.


       'FLT_MIN_10_EXP'
              -37

       'DBL_MIN_10_EXP'
              -37

       'LDBL_MIN_10_EXP'
              -37



        * Maximum  integer such that FLT_RADIX raised to that power minus 1 is
          a representable finite floating-point number, e_max.

       'FLT_MAX_EXP'

       'DBL_MAX_EXP'

       'LDBL_MAX_EXP'



        * Maximum integer such that 10 raised to that power is in the range of
          representable finite floating-point numbers.


       'FLT_MAX_10_EXP'
              +37

       'DBL_MAX_10_EXP'
              +37

       'LDBL_MAX_10_EXP'
              +37



       The  values  given  in  the following list shall be defined as constant
       expressions with implementation-defined values that are greater than or
       equal to those shown:

        * Maximum representable finite floating-point number.


       'FLT_MAX'
              1E+37

       'DBL_MAX'
              1E+37

       'LDBL_MAX'
              1E+37



       The  values  given  in  the following list shall be defined as constant
       expressions with implementation-defined (positive) values that are less
       than or equal to those shown:

        * The  difference between 1 and the least value greater than 1 that is
          representable in the given floating-point type, b**1-p.

       'FLT_EPSILON'
              1E-5

       'DBL_EPSILON'
              1E-9

       'LDBL_EPSILON'
              1E-9



        * Minimum normalized positive floating-point number, b**e_min.

       'FLT_MIN'
              1E-37

       'DBL_MIN'
              1E-37

       'LDBL_MIN'
              1E-37



