This is libc.info, produced by makeinfo version 7.2 from libc.texinfo.

This is ‘The GNU C Library Reference Manual’, for version 2.42.

   Copyright © 1993-2025 Free Software Foundation, Inc.

   Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.3 or
any later version published by the Free Software Foundation; with the
Invariant Sections being "Free Software Needs Free Documentation" and
"GNU Lesser General Public License", the Front-Cover texts being "A GNU
Manual", and with the Back-Cover Texts as in (a) below.  A copy of the
license is included in the section entitled "GNU Free Documentation
License".

   (a) The FSF's Back-Cover Text is: "You have the freedom to copy and
modify this GNU manual.  Buying copies from the FSF supports it in
developing GNU and promoting software freedom."
INFO-DIR-SECTION Software libraries
START-INFO-DIR-ENTRY
* Libc: (libc).                 C library.
END-INFO-DIR-ENTRY

INFO-DIR-SECTION GNU C library functions and macros
START-INFO-DIR-ENTRY
* ALTWERASE: (libc)Local Modes.
* ARGP_ERR_UNKNOWN: (libc)Argp Parser Functions.
* ARG_MAX: (libc)General Limits.
* BAUD_MAX: (libc)Line Speed.
* BC_BASE_MAX: (libc)Utility Limits.
* BC_DIM_MAX: (libc)Utility Limits.
* BC_SCALE_MAX: (libc)Utility Limits.
* BC_STRING_MAX: (libc)Utility Limits.
* BRKINT: (libc)Input Modes.
* BUFSIZ: (libc)Controlling Buffering.
* CCTS_OFLOW: (libc)Control Modes.
* CHAR_BIT: (libc)Width of Type.
* CHILD_MAX: (libc)General Limits.
* CIGNORE: (libc)Control Modes.
* CLK_TCK: (libc)Processor Time.
* CLOCAL: (libc)Control Modes.
* CLOCKS_PER_SEC: (libc)CPU Time.
* CLOCK_BOOTTIME: (libc)Getting the Time.
* CLOCK_BOOTTIME_ALARM: (libc)Getting the Time.
* CLOCK_MONOTONIC: (libc)Getting the Time.
* CLOCK_MONOTONIC_COARSE: (libc)Getting the Time.
* CLOCK_MONOTONIC_RAW: (libc)Getting the Time.
* CLOCK_PROCESS_CPUTIME_ID: (libc)Getting the Time.
* CLOCK_REALTIME: (libc)Getting the Time.
* CLOCK_REALTIME_ALARM: (libc)Getting the Time.
* CLOCK_REALTIME_COARSE: (libc)Getting the Time.
* CLOCK_TAI: (libc)Getting the Time.
* CLOCK_THREAD_CPUTIME_ID: (libc)Getting the Time.
* COLL_WEIGHTS_MAX: (libc)Utility Limits.
* CPU_ALLOC: (libc)CPU Affinity.
* CPU_ALLOC_SIZE: (libc)CPU Affinity.
* CPU_AND: (libc)CPU Affinity.
* CPU_AND_S: (libc)CPU Affinity.
* CPU_CLR: (libc)CPU Affinity.
* CPU_CLR_S: (libc)CPU Affinity.
* CPU_COUNT: (libc)CPU Affinity.
* CPU_COUNT_S: (libc)CPU Affinity.
* CPU_EQUAL: (libc)CPU Affinity.
* CPU_EQUAL_S: (libc)CPU Affinity.
* CPU_FEATURE_ACTIVE: (libc)X86.
* CPU_FEATURE_PRESENT: (libc)X86.
* CPU_FREE: (libc)CPU Affinity.
* CPU_ISSET: (libc)CPU Affinity.
* CPU_ISSET_S: (libc)CPU Affinity.
* CPU_OR: (libc)CPU Affinity.
* CPU_OR_S: (libc)CPU Affinity.
* CPU_SET: (libc)CPU Affinity.
* CPU_SETSIZE: (libc)CPU Affinity.
* CPU_SET_S: (libc)CPU Affinity.
* CPU_XOR: (libc)CPU Affinity.
* CPU_XOR_S: (libc)CPU Affinity.
* CPU_ZERO: (libc)CPU Affinity.
* CPU_ZERO_S: (libc)CPU Affinity.
* CREAD: (libc)Control Modes.
* CRTS_IFLOW: (libc)Control Modes.
* CS5: (libc)Control Modes.
* CS6: (libc)Control Modes.
* CS7: (libc)Control Modes.
* CS8: (libc)Control Modes.
* CSIZE: (libc)Control Modes.
* CSTOPB: (libc)Control Modes.
* DLFO_EH_SEGMENT_TYPE: (libc)Dynamic Linker Introspection.
* DLFO_STRUCT_HAS_EH_COUNT: (libc)Dynamic Linker Introspection.
* DLFO_STRUCT_HAS_EH_DBASE: (libc)Dynamic Linker Introspection.
* DTTOIF: (libc)Directory Entries.
* E2BIG: (libc)Error Codes.
* EACCES: (libc)Error Codes.
* EADDRINUSE: (libc)Error Codes.
* EADDRNOTAVAIL: (libc)Error Codes.
* EADV: (libc)Error Codes.
* EAFNOSUPPORT: (libc)Error Codes.
* EAGAIN: (libc)Error Codes.
* EALREADY: (libc)Error Codes.
* EAUTH: (libc)Error Codes.
* EBACKGROUND: (libc)Error Codes.
* EBADE: (libc)Error Codes.
* EBADF: (libc)Error Codes.
* EBADFD: (libc)Error Codes.
* EBADMSG: (libc)Error Codes.
* EBADR: (libc)Error Codes.
* EBADRPC: (libc)Error Codes.
* EBADRQC: (libc)Error Codes.
* EBADSLT: (libc)Error Codes.
* EBFONT: (libc)Error Codes.
* EBUSY: (libc)Error Codes.
* ECANCELED: (libc)Error Codes.
* ECHILD: (libc)Error Codes.
* ECHO: (libc)Local Modes.
* ECHOCTL: (libc)Local Modes.
* ECHOE: (libc)Local Modes.
* ECHOK: (libc)Local Modes.
* ECHOKE: (libc)Local Modes.
* ECHONL: (libc)Local Modes.
* ECHOPRT: (libc)Local Modes.
* ECHRNG: (libc)Error Codes.
* ECOMM: (libc)Error Codes.
* ECONNABORTED: (libc)Error Codes.
* ECONNREFUSED: (libc)Error Codes.
* ECONNRESET: (libc)Error Codes.
* ED: (libc)Error Codes.
* EDEADLK: (libc)Error Codes.
* EDEADLOCK: (libc)Error Codes.
* EDESTADDRREQ: (libc)Error Codes.
* EDIED: (libc)Error Codes.
* EDOM: (libc)Error Codes.
* EDOTDOT: (libc)Error Codes.
* EDQUOT: (libc)Error Codes.
* EEXIST: (libc)Error Codes.
* EFAULT: (libc)Error Codes.
* EFBIG: (libc)Error Codes.
* EFTYPE: (libc)Error Codes.
* EGRATUITOUS: (libc)Error Codes.
* EGREGIOUS: (libc)Error Codes.
* EHOSTDOWN: (libc)Error Codes.
* EHOSTUNREACH: (libc)Error Codes.
* EHWPOISON: (libc)Error Codes.
* EIDRM: (libc)Error Codes.
* EIEIO: (libc)Error Codes.
* EILSEQ: (libc)Error Codes.
* EINPROGRESS: (libc)Error Codes.
* EINTR: (libc)Error Codes.
* EINVAL: (libc)Error Codes.
* EIO: (libc)Error Codes.
* EISCONN: (libc)Error Codes.
* EISDIR: (libc)Error Codes.
* EISNAM: (libc)Error Codes.
* EKEYEXPIRED: (libc)Error Codes.
* EKEYREJECTED: (libc)Error Codes.
* EKEYREVOKED: (libc)Error Codes.
* EL2HLT: (libc)Error Codes.
* EL2NSYNC: (libc)Error Codes.
* EL3HLT: (libc)Error Codes.
* EL3RST: (libc)Error Codes.
* ELIBACC: (libc)Error Codes.
* ELIBBAD: (libc)Error Codes.
* ELIBEXEC: (libc)Error Codes.
* ELIBMAX: (libc)Error Codes.
* ELIBSCN: (libc)Error Codes.
* ELNRNG: (libc)Error Codes.
* ELOOP: (libc)Error Codes.
* EMEDIUMTYPE: (libc)Error Codes.
* EMFILE: (libc)Error Codes.
* EMLINK: (libc)Error Codes.
* EMSGSIZE: (libc)Error Codes.
* EMULTIHOP: (libc)Error Codes.
* ENAMETOOLONG: (libc)Error Codes.
* ENAVAIL: (libc)Error Codes.
* ENEEDAUTH: (libc)Error Codes.
* ENETDOWN: (libc)Error Codes.
* ENETRESET: (libc)Error Codes.
* ENETUNREACH: (libc)Error Codes.
* ENFILE: (libc)Error Codes.
* ENOANO: (libc)Error Codes.
* ENOBUFS: (libc)Error Codes.
* ENOCSI: (libc)Error Codes.
* ENODATA: (libc)Error Codes.
* ENODEV: (libc)Error Codes.
* ENOENT: (libc)Error Codes.
* ENOEXEC: (libc)Error Codes.
* ENOKEY: (libc)Error Codes.
* ENOLCK: (libc)Error Codes.
* ENOLINK: (libc)Error Codes.
* ENOMEDIUM: (libc)Error Codes.
* ENOMEM: (libc)Error Codes.
* ENOMSG: (libc)Error Codes.
* ENONET: (libc)Error Codes.
* ENOPKG: (libc)Error Codes.
* ENOPROTOOPT: (libc)Error Codes.
* ENOSPC: (libc)Error Codes.
* ENOSR: (libc)Error Codes.
* ENOSTR: (libc)Error Codes.
* ENOSYS: (libc)Error Codes.
* ENOTBLK: (libc)Error Codes.
* ENOTCONN: (libc)Error Codes.
* ENOTDIR: (libc)Error Codes.
* ENOTEMPTY: (libc)Error Codes.
* ENOTNAM: (libc)Error Codes.
* ENOTRECOVERABLE: (libc)Error Codes.
* ENOTSOCK: (libc)Error Codes.
* ENOTSUP: (libc)Error Codes.
* ENOTTY: (libc)Error Codes.
* ENOTUNIQ: (libc)Error Codes.
* ENXIO: (libc)Error Codes.
* EOF: (libc)EOF and Errors.
* EOPNOTSUPP: (libc)Error Codes.
* EOVERFLOW: (libc)Error Codes.
* EOWNERDEAD: (libc)Error Codes.
* EPERM: (libc)Error Codes.
* EPFNOSUPPORT: (libc)Error Codes.
* EPIPE: (libc)Error Codes.
* EPROCLIM: (libc)Error Codes.
* EPROCUNAVAIL: (libc)Error Codes.
* EPROGMISMATCH: (libc)Error Codes.
* EPROGUNAVAIL: (libc)Error Codes.
* EPROTO: (libc)Error Codes.
* EPROTONOSUPPORT: (libc)Error Codes.
* EPROTOTYPE: (libc)Error Codes.
* EQUIV_CLASS_MAX: (libc)Utility Limits.
* ERANGE: (libc)Error Codes.
* EREMCHG: (libc)Error Codes.
* EREMOTE: (libc)Error Codes.
* EREMOTEIO: (libc)Error Codes.
* ERESTART: (libc)Error Codes.
* ERFKILL: (libc)Error Codes.
* EROFS: (libc)Error Codes.
* ERPCMISMATCH: (libc)Error Codes.
* ESHUTDOWN: (libc)Error Codes.
* ESOCKTNOSUPPORT: (libc)Error Codes.
* ESPIPE: (libc)Error Codes.
* ESRCH: (libc)Error Codes.
* ESRMNT: (libc)Error Codes.
* ESTALE: (libc)Error Codes.
* ESTRPIPE: (libc)Error Codes.
* ETIME: (libc)Error Codes.
* ETIMEDOUT: (libc)Error Codes.
* ETOOMANYREFS: (libc)Error Codes.
* ETXTBSY: (libc)Error Codes.
* EUCLEAN: (libc)Error Codes.
* EUNATCH: (libc)Error Codes.
* EUSERS: (libc)Error Codes.
* EWOULDBLOCK: (libc)Error Codes.
* EXDEV: (libc)Error Codes.
* EXFULL: (libc)Error Codes.
* EXIT_FAILURE: (libc)Exit Status.
* EXIT_SUCCESS: (libc)Exit Status.
* EXPR_NEST_MAX: (libc)Utility Limits.
* FD_CLOEXEC: (libc)Descriptor Flags.
* FD_CLR: (libc)Waiting for I/O.
* FD_ISSET: (libc)Waiting for I/O.
* FD_SET: (libc)Waiting for I/O.
* FD_SETSIZE: (libc)Waiting for I/O.
* FD_ZERO: (libc)Waiting for I/O.
* FE_SNANS_ALWAYS_SIGNAL: (libc)Infinity and NaN.
* FILENAME_MAX: (libc)Limits for Files.
* FLUSHO: (libc)Local Modes.
* FOPEN_MAX: (libc)Opening Streams.
* FP_ILOGB0: (libc)Exponents and Logarithms.
* FP_ILOGBNAN: (libc)Exponents and Logarithms.
* FP_LLOGB0: (libc)Exponents and Logarithms.
* FP_LLOGBNAN: (libc)Exponents and Logarithms.
* F_DUPFD: (libc)Duplicating Descriptors.
* F_GETFD: (libc)Descriptor Flags.
* F_GETFL: (libc)Getting File Status Flags.
* F_GETLK: (libc)File Locks.
* F_GETOWN: (libc)Interrupt Input.
* F_OFD_GETLK: (libc)Open File Description Locks.
* F_OFD_SETLK: (libc)Open File Description Locks.
* F_OFD_SETLKW: (libc)Open File Description Locks.
* F_OK: (libc)Testing File Access.
* F_SETFD: (libc)Descriptor Flags.
* F_SETFL: (libc)Getting File Status Flags.
* F_SETLK: (libc)File Locks.
* F_SETLKW: (libc)File Locks.
* F_SETOWN: (libc)Interrupt Input.
* HUGE_VAL: (libc)Math Error Reporting.
* HUGE_VALF: (libc)Math Error Reporting.
* HUGE_VALL: (libc)Math Error Reporting.
* HUGE_VAL_FN: (libc)Math Error Reporting.
* HUGE_VAL_FNx: (libc)Math Error Reporting.
* HUPCL: (libc)Control Modes.
* I: (libc)Complex Numbers.
* ICANON: (libc)Local Modes.
* ICRNL: (libc)Input Modes.
* IEXTEN: (libc)Local Modes.
* IFNAMSIZ: (libc)Interface Naming.
* IFTODT: (libc)Directory Entries.
* IGNBRK: (libc)Input Modes.
* IGNCR: (libc)Input Modes.
* IGNPAR: (libc)Input Modes.
* IMAXBEL: (libc)Input Modes.
* INADDR_ANY: (libc)Host Address Data Type.
* INADDR_BROADCAST: (libc)Host Address Data Type.
* INADDR_LOOPBACK: (libc)Host Address Data Type.
* INADDR_NONE: (libc)Host Address Data Type.
* INFINITY: (libc)Infinity and NaN.
* INLCR: (libc)Input Modes.
* INPCK: (libc)Input Modes.
* IPPORT_RESERVED: (libc)Ports.
* IPPORT_USERRESERVED: (libc)Ports.
* ISIG: (libc)Local Modes.
* ISTRIP: (libc)Input Modes.
* IXANY: (libc)Input Modes.
* IXOFF: (libc)Input Modes.
* IXON: (libc)Input Modes.
* LINE_MAX: (libc)Utility Limits.
* LINK_MAX: (libc)Limits for Files.
* L_ctermid: (libc)Identifying the Terminal.
* L_cuserid: (libc)Who Logged In.
* L_tmpnam: (libc)Temporary Files.
* MAXNAMLEN: (libc)Limits for Files.
* MAXSYMLINKS: (libc)Symbolic Links.
* MAX_CANON: (libc)Limits for Files.
* MAX_INPUT: (libc)Limits for Files.
* MB_CUR_MAX: (libc)Selecting the Conversion.
* MB_LEN_MAX: (libc)Selecting the Conversion.
* MDMBUF: (libc)Control Modes.
* MSG_DONTROUTE: (libc)Socket Data Options.
* MSG_OOB: (libc)Socket Data Options.
* MSG_PEEK: (libc)Socket Data Options.
* NAME_MAX: (libc)Limits for Files.
* NAN: (libc)Infinity and NaN.
* NCCS: (libc)Mode Data Types.
* NGROUPS_MAX: (libc)General Limits.
* NOFLSH: (libc)Local Modes.
* NOKERNINFO: (libc)Local Modes.
* NSIG: (libc)Standard Signals.
* NULL: (libc)Null Pointer Constant.
* ONLCR: (libc)Output Modes.
* ONOEOT: (libc)Output Modes.
* OPEN_MAX: (libc)General Limits.
* OPOST: (libc)Output Modes.
* OXTABS: (libc)Output Modes.
* O_ACCMODE: (libc)Access Modes.
* O_APPEND: (libc)Operating Modes.
* O_ASYNC: (libc)Operating Modes.
* O_CREAT: (libc)Open-time Flags.
* O_DIRECTORY: (libc)Open-time Flags.
* O_EXCL: (libc)Open-time Flags.
* O_EXEC: (libc)Access Modes.
* O_EXLOCK: (libc)Open-time Flags.
* O_FSYNC: (libc)Operating Modes.
* O_IGNORE_CTTY: (libc)Open-time Flags.
* O_NDELAY: (libc)Operating Modes.
* O_NOATIME: (libc)Operating Modes.
* O_NOCTTY: (libc)Open-time Flags.
* O_NOFOLLOW: (libc)Open-time Flags.
* O_NOLINK: (libc)Open-time Flags.
* O_NONBLOCK: (libc)Open-time Flags.
* O_NONBLOCK: (libc)Operating Modes.
* O_NOTRANS: (libc)Open-time Flags.
* O_PATH: (libc)Access Modes.
* O_RDONLY: (libc)Access Modes.
* O_RDWR: (libc)Access Modes.
* O_READ: (libc)Access Modes.
* O_SHLOCK: (libc)Open-time Flags.
* O_SYNC: (libc)Operating Modes.
* O_TMPFILE: (libc)Open-time Flags.
* O_TRUNC: (libc)Open-time Flags.
* O_WRITE: (libc)Access Modes.
* O_WRONLY: (libc)Access Modes.
* PARENB: (libc)Control Modes.
* PARMRK: (libc)Input Modes.
* PARODD: (libc)Control Modes.
* PATH_MAX: (libc)Limits for Files.
* PA_FLAG_MASK: (libc)Parsing a Template String.
* PENDIN: (libc)Local Modes.
* PF_FILE: (libc)Local Namespace Details.
* PF_INET6: (libc)Internet Namespace.
* PF_INET: (libc)Internet Namespace.
* PF_LOCAL: (libc)Local Namespace Details.
* PF_UNIX: (libc)Local Namespace Details.
* PIPE_BUF: (libc)Limits for Files.
* PTHREAD_ATTR_NO_SIGMASK_NP: (libc)Initial Thread Signal Mask.
* P_tmpdir: (libc)Temporary Files.
* RAND_MAX: (libc)ISO Random.
* RE_DUP_MAX: (libc)General Limits.
* RLIM_INFINITY: (libc)Limits on Resources.
* RSEQ_SIG: (libc)Restartable Sequences.
* R_OK: (libc)Testing File Access.
* SA_NOCLDSTOP: (libc)Flags for Sigaction.
* SA_NOCLDWAIT: (libc)Flags for Sigaction.
* SA_NODEFER: (libc)Flags for Sigaction.
* SA_ONSTACK: (libc)Flags for Sigaction.
* SA_RESETHAND: (libc)Flags for Sigaction.
* SA_RESTART: (libc)Flags for Sigaction.
* SA_SIGINFO: (libc)Flags for Sigaction.
* SEEK_CUR: (libc)File Positioning.
* SEEK_END: (libc)File Positioning.
* SEEK_SET: (libc)File Positioning.
* SIGABRT: (libc)Program Error Signals.
* SIGALRM: (libc)Alarm Signals.
* SIGBUS: (libc)Program Error Signals.
* SIGCHLD: (libc)Job Control Signals.
* SIGCLD: (libc)Job Control Signals.
* SIGCONT: (libc)Job Control Signals.
* SIGEMT: (libc)Program Error Signals.
* SIGFPE: (libc)Program Error Signals.
* SIGHUP: (libc)Termination Signals.
* SIGILL: (libc)Program Error Signals.
* SIGINFO: (libc)Miscellaneous Signals.
* SIGINT: (libc)Termination Signals.
* SIGIO: (libc)Asynchronous I/O Signals.
* SIGIOT: (libc)Program Error Signals.
* SIGKILL: (libc)Termination Signals.
* SIGLOST: (libc)Operation Error Signals.
* SIGPIPE: (libc)Operation Error Signals.
* SIGPOLL: (libc)Asynchronous I/O Signals.
* SIGPROF: (libc)Alarm Signals.
* SIGPWR: (libc)Miscellaneous Signals.
* SIGQUIT: (libc)Termination Signals.
* SIGSEGV: (libc)Program Error Signals.
* SIGSTKFLT: (libc)Program Error Signals.
* SIGSTOP: (libc)Job Control Signals.
* SIGSYS: (libc)Program Error Signals.
* SIGTERM: (libc)Termination Signals.
* SIGTRAP: (libc)Program Error Signals.
* SIGTSTP: (libc)Job Control Signals.
* SIGTTIN: (libc)Job Control Signals.
* SIGTTOU: (libc)Job Control Signals.
* SIGURG: (libc)Asynchronous I/O Signals.
* SIGUSR1: (libc)Miscellaneous Signals.
* SIGUSR2: (libc)Miscellaneous Signals.
* SIGVTALRM: (libc)Alarm Signals.
* SIGWINCH: (libc)Miscellaneous Signals.
* SIGXCPU: (libc)Operation Error Signals.
* SIGXFSZ: (libc)Operation Error Signals.
* SIG_ERR: (libc)Basic Signal Handling.
* SNAN: (libc)Infinity and NaN.
* SNANF: (libc)Infinity and NaN.
* SNANFN: (libc)Infinity and NaN.
* SNANFNx: (libc)Infinity and NaN.
* SNANL: (libc)Infinity and NaN.
* SOCK_DGRAM: (libc)Communication Styles.
* SOCK_RAW: (libc)Communication Styles.
* SOCK_RDM: (libc)Communication Styles.
* SOCK_SEQPACKET: (libc)Communication Styles.
* SOCK_STREAM: (libc)Communication Styles.
* SOL_SOCKET: (libc)Socket-Level Options.
* SPEED_MAX: (libc)Line Speed.
* SSIZE_MAX: (libc)General Limits.
* STREAM_MAX: (libc)General Limits.
* SUN_LEN: (libc)Local Namespace Details.
* S_IFMT: (libc)Testing File Type.
* S_ISBLK: (libc)Testing File Type.
* S_ISCHR: (libc)Testing File Type.
* S_ISDIR: (libc)Testing File Type.
* S_ISFIFO: (libc)Testing File Type.
* S_ISLNK: (libc)Testing File Type.
* S_ISREG: (libc)Testing File Type.
* S_ISSOCK: (libc)Testing File Type.
* S_TYPEISMQ: (libc)Testing File Type.
* S_TYPEISSEM: (libc)Testing File Type.
* S_TYPEISSHM: (libc)Testing File Type.
* TIME_UTC: (libc)Getting the Time.
* TMP_MAX: (libc)Temporary Files.
* TOSTOP: (libc)Local Modes.
* TZNAME_MAX: (libc)General Limits.
* VDISCARD: (libc)Other Special.
* VDSUSP: (libc)Signal Characters.
* VEOF: (libc)Editing Characters.
* VEOL2: (libc)Editing Characters.
* VEOL: (libc)Editing Characters.
* VERASE: (libc)Editing Characters.
* VINTR: (libc)Signal Characters.
* VKILL: (libc)Editing Characters.
* VLNEXT: (libc)Other Special.
* VMIN: (libc)Noncanonical Input.
* VQUIT: (libc)Signal Characters.
* VREPRINT: (libc)Editing Characters.
* VSTART: (libc)Start/Stop Characters.
* VSTATUS: (libc)Other Special.
* VSTOP: (libc)Start/Stop Characters.
* VSUSP: (libc)Signal Characters.
* VTIME: (libc)Noncanonical Input.
* VWERASE: (libc)Editing Characters.
* WCHAR_MAX: (libc)Extended Char Intro.
* WCHAR_MIN: (libc)Extended Char Intro.
* WCOREDUMP: (libc)Process Completion Status.
* WEOF: (libc)EOF and Errors.
* WEOF: (libc)Extended Char Intro.
* WEXITSTATUS: (libc)Process Completion Status.
* WIFEXITED: (libc)Process Completion Status.
* WIFSIGNALED: (libc)Process Completion Status.
* WIFSTOPPED: (libc)Process Completion Status.
* WSTOPSIG: (libc)Process Completion Status.
* WTERMSIG: (libc)Process Completion Status.
* W_OK: (libc)Testing File Access.
* X_OK: (libc)Testing File Access.
* _Complex_I: (libc)Complex Numbers.
* _Exit: (libc)Termination Internals.
* _Fork: (libc)Creating a Process.
* _IOFBF: (libc)Controlling Buffering.
* _IOLBF: (libc)Controlling Buffering.
* _IONBF: (libc)Controlling Buffering.
* _Imaginary_I: (libc)Complex Numbers.
* _PATH_UTMP: (libc)Manipulating the Database.
* _PATH_WTMP: (libc)Manipulating the Database.
* _POSIX2_C_DEV: (libc)System Options.
* _POSIX2_C_VERSION: (libc)Version Supported.
* _POSIX2_FORT_DEV: (libc)System Options.
* _POSIX2_FORT_RUN: (libc)System Options.
* _POSIX2_LOCALEDEF: (libc)System Options.
* _POSIX2_SW_DEV: (libc)System Options.
* _POSIX_CHOWN_RESTRICTED: (libc)Options for Files.
* _POSIX_JOB_CONTROL: (libc)System Options.
* _POSIX_NO_TRUNC: (libc)Options for Files.
* _POSIX_SAVED_IDS: (libc)System Options.
* _POSIX_VDISABLE: (libc)Options for Files.
* _POSIX_VERSION: (libc)Version Supported.
* __fbufsize: (libc)Controlling Buffering.
* __flbf: (libc)Controlling Buffering.
* __fpending: (libc)Controlling Buffering.
* __fpurge: (libc)Flushing Buffers.
* __freadable: (libc)Opening Streams.
* __freading: (libc)Opening Streams.
* __fsetlocking: (libc)Streams and Threads.
* __fwritable: (libc)Opening Streams.
* __fwriting: (libc)Opening Streams.
* __gconv_end_fct: (libc)glibc iconv Implementation.
* __gconv_fct: (libc)glibc iconv Implementation.
* __gconv_init_fct: (libc)glibc iconv Implementation.
* __ppc_get_timebase: (libc)PowerPC.
* __ppc_get_timebase_freq: (libc)PowerPC.
* __ppc_mdoio: (libc)PowerPC.
* __ppc_mdoom: (libc)PowerPC.
* __ppc_set_ppr_low: (libc)PowerPC.
* __ppc_set_ppr_med: (libc)PowerPC.
* __ppc_set_ppr_med_high: (libc)PowerPC.
* __ppc_set_ppr_med_low: (libc)PowerPC.
* __ppc_set_ppr_very_low: (libc)PowerPC.
* __ppc_yield: (libc)PowerPC.
* __riscv_flush_icache: (libc)RISC-V.
* __va_copy: (libc)Argument Macros.
* __x86_get_cpuid_feature_leaf: (libc)X86.
* _dl_find_object: (libc)Dynamic Linker Introspection.
* _exit: (libc)Termination Internals.
* _flushlbf: (libc)Flushing Buffers.
* _tolower: (libc)Case Conversion.
* _toupper: (libc)Case Conversion.
* a64l: (libc)Encode Binary Data.
* abort: (libc)Aborting a Program.
* abs: (libc)Absolute Value.
* accept: (libc)Accepting Connections.
* access: (libc)Testing File Access.
* acos: (libc)Inverse Trig Functions.
* acosf: (libc)Inverse Trig Functions.
* acosfN: (libc)Inverse Trig Functions.
* acosfNx: (libc)Inverse Trig Functions.
* acosh: (libc)Hyperbolic Functions.
* acoshf: (libc)Hyperbolic Functions.
* acoshfN: (libc)Hyperbolic Functions.
* acoshfNx: (libc)Hyperbolic Functions.
* acoshl: (libc)Hyperbolic Functions.
* acosl: (libc)Inverse Trig Functions.
* acospi: (libc)Inverse Trig Functions.
* acospif: (libc)Inverse Trig Functions.
* acospifN: (libc)Inverse Trig Functions.
* acospifNx: (libc)Inverse Trig Functions.
* acospil: (libc)Inverse Trig Functions.
* addmntent: (libc)mtab.
* addseverity: (libc)Adding Severity Classes.
* adjtime: (libc)Setting and Adjusting the Time.
* adjtimex: (libc)Setting and Adjusting the Time.
* aio_cancel64: (libc)Cancel AIO Operations.
* aio_cancel: (libc)Cancel AIO Operations.
* aio_error64: (libc)Status of AIO Operations.
* aio_error: (libc)Status of AIO Operations.
* aio_fsync64: (libc)Synchronizing AIO Operations.
* aio_fsync: (libc)Synchronizing AIO Operations.
* aio_init: (libc)Configuration of AIO.
* aio_read64: (libc)Asynchronous Reads/Writes.
* aio_read: (libc)Asynchronous Reads/Writes.
* aio_return64: (libc)Status of AIO Operations.
* aio_return: (libc)Status of AIO Operations.
* aio_suspend64: (libc)Synchronizing AIO Operations.
* aio_suspend: (libc)Synchronizing AIO Operations.
* aio_write64: (libc)Asynchronous Reads/Writes.
* aio_write: (libc)Asynchronous Reads/Writes.
* alarm: (libc)Setting an Alarm.
* aligned_alloc: (libc)Aligned Memory Blocks.
* alloca: (libc)Variable Size Automatic.
* alphasort64: (libc)Scanning Directory Content.
* alphasort: (libc)Scanning Directory Content.
* arc4random: (libc)High Quality Random.
* arc4random_buf: (libc)High Quality Random.
* arc4random_uniform: (libc)High Quality Random.
* argp_error: (libc)Argp Helper Functions.
* argp_failure: (libc)Argp Helper Functions.
* argp_help: (libc)Argp Help.
* argp_parse: (libc)Argp.
* argp_state_help: (libc)Argp Helper Functions.
* argp_usage: (libc)Argp Helper Functions.
* argz_add: (libc)Argz Functions.
* argz_add_sep: (libc)Argz Functions.
* argz_append: (libc)Argz Functions.
* argz_count: (libc)Argz Functions.
* argz_create: (libc)Argz Functions.
* argz_create_sep: (libc)Argz Functions.
* argz_delete: (libc)Argz Functions.
* argz_extract: (libc)Argz Functions.
* argz_insert: (libc)Argz Functions.
* argz_next: (libc)Argz Functions.
* argz_replace: (libc)Argz Functions.
* argz_stringify: (libc)Argz Functions.
* asctime: (libc)Formatting Calendar Time.
* asctime_r: (libc)Formatting Calendar Time.
* asin: (libc)Inverse Trig Functions.
* asinf: (libc)Inverse Trig Functions.
* asinfN: (libc)Inverse Trig Functions.
* asinfNx: (libc)Inverse Trig Functions.
* asinh: (libc)Hyperbolic Functions.
* asinhf: (libc)Hyperbolic Functions.
* asinhfN: (libc)Hyperbolic Functions.
* asinhfNx: (libc)Hyperbolic Functions.
* asinhl: (libc)Hyperbolic Functions.
* asinl: (libc)Inverse Trig Functions.
* asinpi: (libc)Inverse Trig Functions.
* asinpif: (libc)Inverse Trig Functions.
* asinpifN: (libc)Inverse Trig Functions.
* asinpifNx: (libc)Inverse Trig Functions.
* asinpil: (libc)Inverse Trig Functions.
* asprintf: (libc)Dynamic Output.
* assert: (libc)Consistency Checking.
* assert_perror: (libc)Consistency Checking.
* atan2: (libc)Inverse Trig Functions.
* atan2f: (libc)Inverse Trig Functions.
* atan2fN: (libc)Inverse Trig Functions.
* atan2fNx: (libc)Inverse Trig Functions.
* atan2l: (libc)Inverse Trig Functions.
* atan2pi: (libc)Inverse Trig Functions.
* atan2pif: (libc)Inverse Trig Functions.
* atan2pifN: (libc)Inverse Trig Functions.
* atan2pifNx: (libc)Inverse Trig Functions.
* atan2pil: (libc)Inverse Trig Functions.
* atan: (libc)Inverse Trig Functions.
* atanf: (libc)Inverse Trig Functions.
* atanfN: (libc)Inverse Trig Functions.
* atanfNx: (libc)Inverse Trig Functions.
* atanh: (libc)Hyperbolic Functions.
* atanhf: (libc)Hyperbolic Functions.
* atanhfN: (libc)Hyperbolic Functions.
* atanhfNx: (libc)Hyperbolic Functions.
* atanhl: (libc)Hyperbolic Functions.
* atanl: (libc)Inverse Trig Functions.
* atanpi: (libc)Inverse Trig Functions.
* atanpif: (libc)Inverse Trig Functions.
* atanpifN: (libc)Inverse Trig Functions.
* atanpifNx: (libc)Inverse Trig Functions.
* atanpil: (libc)Inverse Trig Functions.
* atexit: (libc)Cleanups on Exit.
* atof: (libc)Parsing of Floats.
* atoi: (libc)Parsing of Integers.
* atol: (libc)Parsing of Integers.
* atoll: (libc)Parsing of Integers.
* backtrace: (libc)Backtraces.
* backtrace_symbols: (libc)Backtraces.
* backtrace_symbols_fd: (libc)Backtraces.
* basename: (libc)Finding Tokens in a String.
* basename: (libc)Finding Tokens in a String.
* bcmp: (libc)String/Array Comparison.
* bcopy: (libc)Copying Strings and Arrays.
* bind: (libc)Setting Address.
* bind_textdomain_codeset: (libc)Charset conversion in gettext.
* bindtextdomain: (libc)Locating gettext catalog.
* brk: (libc)Resizing the Data Segment.
* bsearch: (libc)Array Search Function.
* btowc: (libc)Converting a Character.
* bzero: (libc)Copying Strings and Arrays.
* cabs: (libc)Absolute Value.
* cabsf: (libc)Absolute Value.
* cabsfN: (libc)Absolute Value.
* cabsfNx: (libc)Absolute Value.
* cabsl: (libc)Absolute Value.
* cacos: (libc)Inverse Trig Functions.
* cacosf: (libc)Inverse Trig Functions.
* cacosfN: (libc)Inverse Trig Functions.
* cacosfNx: (libc)Inverse Trig Functions.
* cacosh: (libc)Hyperbolic Functions.
* cacoshf: (libc)Hyperbolic Functions.
* cacoshfN: (libc)Hyperbolic Functions.
* cacoshfNx: (libc)Hyperbolic Functions.
* cacoshl: (libc)Hyperbolic Functions.
* cacosl: (libc)Inverse Trig Functions.
* call_once: (libc)Call Once.
* calloc: (libc)Allocating Cleared Space.
* canonicalize: (libc)FP Bit Twiddling.
* canonicalize_file_name: (libc)Symbolic Links.
* canonicalizef: (libc)FP Bit Twiddling.
* canonicalizefN: (libc)FP Bit Twiddling.
* canonicalizefNx: (libc)FP Bit Twiddling.
* canonicalizel: (libc)FP Bit Twiddling.
* carg: (libc)Operations on Complex.
* cargf: (libc)Operations on Complex.
* cargfN: (libc)Operations on Complex.
* cargfNx: (libc)Operations on Complex.
* cargl: (libc)Operations on Complex.
* casin: (libc)Inverse Trig Functions.
* casinf: (libc)Inverse Trig Functions.
* casinfN: (libc)Inverse Trig Functions.
* casinfNx: (libc)Inverse Trig Functions.
* casinh: (libc)Hyperbolic Functions.
* casinhf: (libc)Hyperbolic Functions.
* casinhfN: (libc)Hyperbolic Functions.
* casinhfNx: (libc)Hyperbolic Functions.
* casinhl: (libc)Hyperbolic Functions.
* casinl: (libc)Inverse Trig Functions.
* catan: (libc)Inverse Trig Functions.
* catanf: (libc)Inverse Trig Functions.
* catanfN: (libc)Inverse Trig Functions.
* catanfNx: (libc)Inverse Trig Functions.
* catanh: (libc)Hyperbolic Functions.
* catanhf: (libc)Hyperbolic Functions.
* catanhfN: (libc)Hyperbolic Functions.
* catanhfNx: (libc)Hyperbolic Functions.
* catanhl: (libc)Hyperbolic Functions.
* catanl: (libc)Inverse Trig Functions.
* catclose: (libc)The catgets Functions.
* catgets: (libc)The catgets Functions.
* catopen: (libc)The catgets Functions.
* cbrt: (libc)Exponents and Logarithms.
* cbrtf: (libc)Exponents and Logarithms.
* cbrtfN: (libc)Exponents and Logarithms.
* cbrtfNx: (libc)Exponents and Logarithms.
* cbrtl: (libc)Exponents and Logarithms.
* ccos: (libc)Trig Functions.
* ccosf: (libc)Trig Functions.
* ccosfN: (libc)Trig Functions.
* ccosfNx: (libc)Trig Functions.
* ccosh: (libc)Hyperbolic Functions.
* ccoshf: (libc)Hyperbolic Functions.
* ccoshfN: (libc)Hyperbolic Functions.
* ccoshfNx: (libc)Hyperbolic Functions.
* ccoshl: (libc)Hyperbolic Functions.
* ccosl: (libc)Trig Functions.
* ceil: (libc)Rounding Functions.
* ceilf: (libc)Rounding Functions.
* ceilfN: (libc)Rounding Functions.
* ceilfNx: (libc)Rounding Functions.
* ceill: (libc)Rounding Functions.
* cexp: (libc)Exponents and Logarithms.
* cexpf: (libc)Exponents and Logarithms.
* cexpfN: (libc)Exponents and Logarithms.
* cexpfNx: (libc)Exponents and Logarithms.
* cexpl: (libc)Exponents and Logarithms.
* cfgetibaud: (libc)Line Speed.
* cfgetispeed: (libc)Line Speed.
* cfgetobaud: (libc)Line Speed.
* cfgetospeed: (libc)Line Speed.
* cfmakeraw: (libc)Noncanonical Input.
* cfsetbaud: (libc)Line Speed.
* cfsetibaud: (libc)Line Speed.
* cfsetispeed: (libc)Line Speed.
* cfsetobaud: (libc)Line Speed.
* cfsetospeed: (libc)Line Speed.
* cfsetspeed: (libc)Line Speed.
* chdir: (libc)Working Directory.
* chmod: (libc)Setting Permissions.
* chown: (libc)File Owner.
* cimag: (libc)Operations on Complex.
* cimagf: (libc)Operations on Complex.
* cimagfN: (libc)Operations on Complex.
* cimagfNx: (libc)Operations on Complex.
* cimagl: (libc)Operations on Complex.
* clearenv: (libc)Environment Access.
* clearerr: (libc)Error Recovery.
* clearerr_unlocked: (libc)Error Recovery.
* clock: (libc)CPU Time.
* clock_getres: (libc)Getting the Time.
* clock_gettime: (libc)Getting the Time.
* clock_nanosleep: (libc)Sleeping.
* clock_settime: (libc)Setting and Adjusting the Time.
* clog10: (libc)Exponents and Logarithms.
* clog10f: (libc)Exponents and Logarithms.
* clog10fN: (libc)Exponents and Logarithms.
* clog10fNx: (libc)Exponents and Logarithms.
* clog10l: (libc)Exponents and Logarithms.
* clog: (libc)Exponents and Logarithms.
* clogf: (libc)Exponents and Logarithms.
* clogfN: (libc)Exponents and Logarithms.
* clogfNx: (libc)Exponents and Logarithms.
* clogl: (libc)Exponents and Logarithms.
* close: (libc)Opening and Closing Files.
* close_range: (libc)Opening and Closing Files.
* closedir: (libc)Reading/Closing Directory.
* closefrom: (libc)Opening and Closing Files.
* closelog: (libc)closelog.
* cnd_broadcast: (libc)ISO C Condition Variables.
* cnd_destroy: (libc)ISO C Condition Variables.
* cnd_init: (libc)ISO C Condition Variables.
* cnd_signal: (libc)ISO C Condition Variables.
* cnd_timedwait: (libc)ISO C Condition Variables.
* cnd_wait: (libc)ISO C Condition Variables.
* compoundn: (libc)Exponents and Logarithms.
* compoundnf: (libc)Exponents and Logarithms.
* compoundnfN: (libc)Exponents and Logarithms.
* compoundnfNx: (libc)Exponents and Logarithms.
* compoundnl: (libc)Exponents and Logarithms.
* confstr: (libc)String Parameters.
* conj: (libc)Operations on Complex.
* conjf: (libc)Operations on Complex.
* conjfN: (libc)Operations on Complex.
* conjfNx: (libc)Operations on Complex.
* conjl: (libc)Operations on Complex.
* connect: (libc)Connecting.
* copy_file_range: (libc)Copying File Data.
* copysign: (libc)FP Bit Twiddling.
* copysignf: (libc)FP Bit Twiddling.
* copysignfN: (libc)FP Bit Twiddling.
* copysignfNx: (libc)FP Bit Twiddling.
* copysignl: (libc)FP Bit Twiddling.
* cos: (libc)Trig Functions.
* cosf: (libc)Trig Functions.
* cosfN: (libc)Trig Functions.
* cosfNx: (libc)Trig Functions.
* cosh: (libc)Hyperbolic Functions.
* coshf: (libc)Hyperbolic Functions.
* coshfN: (libc)Hyperbolic Functions.
* coshfNx: (libc)Hyperbolic Functions.
* coshl: (libc)Hyperbolic Functions.
* cosl: (libc)Trig Functions.
* cospi: (libc)Trig Functions.
* cospif: (libc)Trig Functions.
* cospifN: (libc)Trig Functions.
* cospifNx: (libc)Trig Functions.
* cospil: (libc)Trig Functions.
* cpow: (libc)Exponents and Logarithms.
* cpowf: (libc)Exponents and Logarithms.
* cpowfN: (libc)Exponents and Logarithms.
* cpowfNx: (libc)Exponents and Logarithms.
* cpowl: (libc)Exponents and Logarithms.
* cproj: (libc)Operations on Complex.
* cprojf: (libc)Operations on Complex.
* cprojfN: (libc)Operations on Complex.
* cprojfNx: (libc)Operations on Complex.
* cprojl: (libc)Operations on Complex.
* creal: (libc)Operations on Complex.
* crealf: (libc)Operations on Complex.
* crealfN: (libc)Operations on Complex.
* crealfNx: (libc)Operations on Complex.
* creall: (libc)Operations on Complex.
* creat64: (libc)Opening and Closing Files.
* creat: (libc)Opening and Closing Files.
* csin: (libc)Trig Functions.
* csinf: (libc)Trig Functions.
* csinfN: (libc)Trig Functions.
* csinfNx: (libc)Trig Functions.
* csinh: (libc)Hyperbolic Functions.
* csinhf: (libc)Hyperbolic Functions.
* csinhfN: (libc)Hyperbolic Functions.
* csinhfNx: (libc)Hyperbolic Functions.
* csinhl: (libc)Hyperbolic Functions.
* csinl: (libc)Trig Functions.
* csqrt: (libc)Exponents and Logarithms.
* csqrtf: (libc)Exponents and Logarithms.
* csqrtfN: (libc)Exponents and Logarithms.
* csqrtfNx: (libc)Exponents and Logarithms.
* csqrtl: (libc)Exponents and Logarithms.
* ctan: (libc)Trig Functions.
* ctanf: (libc)Trig Functions.
* ctanfN: (libc)Trig Functions.
* ctanfNx: (libc)Trig Functions.
* ctanh: (libc)Hyperbolic Functions.
* ctanhf: (libc)Hyperbolic Functions.
* ctanhfN: (libc)Hyperbolic Functions.
* ctanhfNx: (libc)Hyperbolic Functions.
* ctanhl: (libc)Hyperbolic Functions.
* ctanl: (libc)Trig Functions.
* ctermid: (libc)Identifying the Terminal.
* ctime: (libc)Formatting Calendar Time.
* ctime_r: (libc)Formatting Calendar Time.
* cuserid: (libc)Who Logged In.
* daddl: (libc)Misc FP Arithmetic.
* dcgettext: (libc)Translation with gettext.
* dcngettext: (libc)Advanced gettext functions.
* ddivl: (libc)Misc FP Arithmetic.
* dfmal: (libc)Misc FP Arithmetic.
* dgettext: (libc)Translation with gettext.
* difftime: (libc)Calculating Elapsed Time.
* dirfd: (libc)Opening a Directory.
* dirname: (libc)Finding Tokens in a String.
* div: (libc)Integer Division.
* dlinfo: (libc)Dynamic Linker Introspection.
* dmull: (libc)Misc FP Arithmetic.
* dngettext: (libc)Advanced gettext functions.
* dprintf: (libc)Formatted Output Functions.
* drand48: (libc)SVID Random.
* drand48_r: (libc)SVID Random.
* drem: (libc)Remainder Functions.
* dremf: (libc)Remainder Functions.
* dreml: (libc)Remainder Functions.
* dsqrtl: (libc)Misc FP Arithmetic.
* dsubl: (libc)Misc FP Arithmetic.
* dup2: (libc)Duplicating Descriptors.
* dup3: (libc)Duplicating Descriptors.
* dup: (libc)Duplicating Descriptors.
* ecvt: (libc)System V Number Conversion.
* ecvt_r: (libc)System V Number Conversion.
* endfsent: (libc)fstab.
* endgrent: (libc)Scanning All Groups.
* endhostent: (libc)Host Names.
* endmntent: (libc)mtab.
* endnetent: (libc)Networks Database.
* endnetgrent: (libc)Lookup Netgroup.
* endprotoent: (libc)Protocols Database.
* endpwent: (libc)Scanning All Users.
* endservent: (libc)Services Database.
* endutent: (libc)Manipulating the Database.
* endutxent: (libc)XPG Functions.
* envz_add: (libc)Envz Functions.
* envz_entry: (libc)Envz Functions.
* envz_get: (libc)Envz Functions.
* envz_merge: (libc)Envz Functions.
* envz_remove: (libc)Envz Functions.
* envz_strip: (libc)Envz Functions.
* epoll_create: (libc)Other Low-Level I/O APIs.
* epoll_wait: (libc)Other Low-Level I/O APIs.
* erand48: (libc)SVID Random.
* erand48_r: (libc)SVID Random.
* erf: (libc)Special Functions.
* erfc: (libc)Special Functions.
* erfcf: (libc)Special Functions.
* erfcfN: (libc)Special Functions.
* erfcfNx: (libc)Special Functions.
* erfcl: (libc)Special Functions.
* erff: (libc)Special Functions.
* erffN: (libc)Special Functions.
* erffNx: (libc)Special Functions.
* erfl: (libc)Special Functions.
* err: (libc)Error Messages.
* errno: (libc)Checking for Errors.
* error: (libc)Error Messages.
* error_at_line: (libc)Error Messages.
* errx: (libc)Error Messages.
* execl: (libc)Executing a File.
* execle: (libc)Executing a File.
* execlp: (libc)Executing a File.
* execv: (libc)Executing a File.
* execve: (libc)Executing a File.
* execvp: (libc)Executing a File.
* exit: (libc)Normal Termination.
* exp10: (libc)Exponents and Logarithms.
* exp10f: (libc)Exponents and Logarithms.
* exp10fN: (libc)Exponents and Logarithms.
* exp10fNx: (libc)Exponents and Logarithms.
* exp10l: (libc)Exponents and Logarithms.
* exp10m1: (libc)Exponents and Logarithms.
* exp10m1f: (libc)Exponents and Logarithms.
* exp10m1fN: (libc)Exponents and Logarithms.
* exp10m1fNx: (libc)Exponents and Logarithms.
* exp10m1l: (libc)Exponents and Logarithms.
* exp2: (libc)Exponents and Logarithms.
* exp2f: (libc)Exponents and Logarithms.
* exp2fN: (libc)Exponents and Logarithms.
* exp2fNx: (libc)Exponents and Logarithms.
* exp2l: (libc)Exponents and Logarithms.
* exp2m1: (libc)Exponents and Logarithms.
* exp2m1f: (libc)Exponents and Logarithms.
* exp2m1fN: (libc)Exponents and Logarithms.
* exp2m1fNx: (libc)Exponents and Logarithms.
* exp2m1l: (libc)Exponents and Logarithms.
* exp: (libc)Exponents and Logarithms.
* expf: (libc)Exponents and Logarithms.
* expfN: (libc)Exponents and Logarithms.
* expfNx: (libc)Exponents and Logarithms.
* expl: (libc)Exponents and Logarithms.
* explicit_bzero: (libc)Erasing Sensitive Data.
* expm1: (libc)Exponents and Logarithms.
* expm1f: (libc)Exponents and Logarithms.
* expm1fN: (libc)Exponents and Logarithms.
* expm1fNx: (libc)Exponents and Logarithms.
* expm1l: (libc)Exponents and Logarithms.
* fMaddfN: (libc)Misc FP Arithmetic.
* fMaddfNx: (libc)Misc FP Arithmetic.
* fMdivfN: (libc)Misc FP Arithmetic.
* fMdivfNx: (libc)Misc FP Arithmetic.
* fMfmafN: (libc)Misc FP Arithmetic.
* fMfmafNx: (libc)Misc FP Arithmetic.
* fMmulfN: (libc)Misc FP Arithmetic.
* fMmulfNx: (libc)Misc FP Arithmetic.
* fMsqrtfN: (libc)Misc FP Arithmetic.
* fMsqrtfNx: (libc)Misc FP Arithmetic.
* fMsubfN: (libc)Misc FP Arithmetic.
* fMsubfNx: (libc)Misc FP Arithmetic.
* fMxaddfN: (libc)Misc FP Arithmetic.
* fMxaddfNx: (libc)Misc FP Arithmetic.
* fMxdivfN: (libc)Misc FP Arithmetic.
* fMxdivfNx: (libc)Misc FP Arithmetic.
* fMxfmafN: (libc)Misc FP Arithmetic.
* fMxfmafNx: (libc)Misc FP Arithmetic.
* fMxmulfN: (libc)Misc FP Arithmetic.
* fMxmulfNx: (libc)Misc FP Arithmetic.
* fMxsqrtfN: (libc)Misc FP Arithmetic.
* fMxsqrtfNx: (libc)Misc FP Arithmetic.
* fMxsubfN: (libc)Misc FP Arithmetic.
* fMxsubfNx: (libc)Misc FP Arithmetic.
* fabs: (libc)Absolute Value.
* fabsf: (libc)Absolute Value.
* fabsfN: (libc)Absolute Value.
* fabsfNx: (libc)Absolute Value.
* fabsl: (libc)Absolute Value.
* faccessat: (libc)Testing File Access.
* fadd: (libc)Misc FP Arithmetic.
* faddl: (libc)Misc FP Arithmetic.
* fchdir: (libc)Working Directory.
* fchmod: (libc)Setting Permissions.
* fchown: (libc)File Owner.
* fclose: (libc)Closing Streams.
* fcloseall: (libc)Closing Streams.
* fcntl: (libc)Control Operations.
* fcvt: (libc)System V Number Conversion.
* fcvt_r: (libc)System V Number Conversion.
* fdatasync: (libc)Synchronizing I/O.
* fdim: (libc)Misc FP Arithmetic.
* fdimf: (libc)Misc FP Arithmetic.
* fdimfN: (libc)Misc FP Arithmetic.
* fdimfNx: (libc)Misc FP Arithmetic.
* fdiml: (libc)Misc FP Arithmetic.
* fdiv: (libc)Misc FP Arithmetic.
* fdivl: (libc)Misc FP Arithmetic.
* fdopen: (libc)Descriptors and Streams.
* fdopendir: (libc)Opening a Directory.
* feclearexcept: (libc)Status bit operations.
* fedisableexcept: (libc)Control Functions.
* feenableexcept: (libc)Control Functions.
* fegetenv: (libc)Control Functions.
* fegetexcept: (libc)Control Functions.
* fegetexceptflag: (libc)Status bit operations.
* fegetmode: (libc)Control Functions.
* fegetround: (libc)Rounding.
* feholdexcept: (libc)Control Functions.
* feof: (libc)EOF and Errors.
* feof_unlocked: (libc)EOF and Errors.
* feraiseexcept: (libc)Status bit operations.
* ferror: (libc)EOF and Errors.
* ferror_unlocked: (libc)EOF and Errors.
* fesetenv: (libc)Control Functions.
* fesetexcept: (libc)Status bit operations.
* fesetexceptflag: (libc)Status bit operations.
* fesetmode: (libc)Control Functions.
* fesetround: (libc)Rounding.
* fetestexcept: (libc)Status bit operations.
* fetestexceptflag: (libc)Status bit operations.
* feupdateenv: (libc)Control Functions.
* fexecve: (libc)Executing a File.
* fflush: (libc)Flushing Buffers.
* fflush_unlocked: (libc)Flushing Buffers.
* ffma: (libc)Misc FP Arithmetic.
* ffmal: (libc)Misc FP Arithmetic.
* fgetc: (libc)Character Input.
* fgetc_unlocked: (libc)Character Input.
* fgetgrent: (libc)Scanning All Groups.
* fgetgrent_r: (libc)Scanning All Groups.
* fgetpos64: (libc)Portable Positioning.
* fgetpos: (libc)Portable Positioning.
* fgetpwent: (libc)Scanning All Users.
* fgetpwent_r: (libc)Scanning All Users.
* fgets: (libc)Line Input.
* fgets_unlocked: (libc)Line Input.
* fgetwc: (libc)Character Input.
* fgetwc_unlocked: (libc)Character Input.
* fgetws: (libc)Line Input.
* fgetws_unlocked: (libc)Line Input.
* fileno: (libc)Descriptors and Streams.
* fileno_unlocked: (libc)Descriptors and Streams.
* finite: (libc)Floating Point Classes.
* finitef: (libc)Floating Point Classes.
* finitel: (libc)Floating Point Classes.
* flockfile: (libc)Streams and Threads.
* floor: (libc)Rounding Functions.
* floorf: (libc)Rounding Functions.
* floorfN: (libc)Rounding Functions.
* floorfNx: (libc)Rounding Functions.
* floorl: (libc)Rounding Functions.
* fma: (libc)Misc FP Arithmetic.
* fmaf: (libc)Misc FP Arithmetic.
* fmafN: (libc)Misc FP Arithmetic.
* fmafNx: (libc)Misc FP Arithmetic.
* fmal: (libc)Misc FP Arithmetic.
* fmax: (libc)Misc FP Arithmetic.
* fmaxf: (libc)Misc FP Arithmetic.
* fmaxfN: (libc)Misc FP Arithmetic.
* fmaxfNx: (libc)Misc FP Arithmetic.
* fmaximum: (libc)Misc FP Arithmetic.
* fmaximum_mag: (libc)Misc FP Arithmetic.
* fmaximum_mag_num: (libc)Misc FP Arithmetic.
* fmaximum_mag_numf: (libc)Misc FP Arithmetic.
* fmaximum_mag_numfN: (libc)Misc FP Arithmetic.
* fmaximum_mag_numfNx: (libc)Misc FP Arithmetic.
* fmaximum_mag_numl: (libc)Misc FP Arithmetic.
* fmaximum_magf: (libc)Misc FP Arithmetic.
* fmaximum_magfN: (libc)Misc FP Arithmetic.
* fmaximum_magfNx: (libc)Misc FP Arithmetic.
* fmaximum_magl: (libc)Misc FP Arithmetic.
* fmaximum_num: (libc)Misc FP Arithmetic.
* fmaximum_numf: (libc)Misc FP Arithmetic.
* fmaximum_numfN: (libc)Misc FP Arithmetic.
* fmaximum_numfNx: (libc)Misc FP Arithmetic.
* fmaximum_numl: (libc)Misc FP Arithmetic.
* fmaximumf: (libc)Misc FP Arithmetic.
* fmaximumfN: (libc)Misc FP Arithmetic.
* fmaximumfNx: (libc)Misc FP Arithmetic.
* fmaximuml: (libc)Misc FP Arithmetic.
* fmaxl: (libc)Misc FP Arithmetic.
* fmaxmag: (libc)Misc FP Arithmetic.
* fmaxmagf: (libc)Misc FP Arithmetic.
* fmaxmagfN: (libc)Misc FP Arithmetic.
* fmaxmagfNx: (libc)Misc FP Arithmetic.
* fmaxmagl: (libc)Misc FP Arithmetic.
* fmemopen: (libc)String Streams.
* fmin: (libc)Misc FP Arithmetic.
* fminf: (libc)Misc FP Arithmetic.
* fminfN: (libc)Misc FP Arithmetic.
* fminfNx: (libc)Misc FP Arithmetic.
* fminimum: (libc)Misc FP Arithmetic.
* fminimum_mag: (libc)Misc FP Arithmetic.
* fminimum_mag_num: (libc)Misc FP Arithmetic.
* fminimum_mag_numf: (libc)Misc FP Arithmetic.
* fminimum_mag_numfN: (libc)Misc FP Arithmetic.
* fminimum_mag_numfNx: (libc)Misc FP Arithmetic.
* fminimum_mag_numl: (libc)Misc FP Arithmetic.
* fminimum_magf: (libc)Misc FP Arithmetic.
* fminimum_magfN: (libc)Misc FP Arithmetic.
* fminimum_magfNx: (libc)Misc FP Arithmetic.
* fminimum_magl: (libc)Misc FP Arithmetic.
* fminimum_num: (libc)Misc FP Arithmetic.
* fminimum_numf: (libc)Misc FP Arithmetic.
* fminimum_numfN: (libc)Misc FP Arithmetic.
* fminimum_numfNx: (libc)Misc FP Arithmetic.
* fminimum_numl: (libc)Misc FP Arithmetic.
* fminimumf: (libc)Misc FP Arithmetic.
* fminimumfN: (libc)Misc FP Arithmetic.
* fminimumfNx: (libc)Misc FP Arithmetic.
* fminimuml: (libc)Misc FP Arithmetic.
* fminl: (libc)Misc FP Arithmetic.
* fminmag: (libc)Misc FP Arithmetic.
* fminmagf: (libc)Misc FP Arithmetic.
* fminmagfN: (libc)Misc FP Arithmetic.
* fminmagfNx: (libc)Misc FP Arithmetic.
* fminmagl: (libc)Misc FP Arithmetic.
* fmod: (libc)Remainder Functions.
* fmodf: (libc)Remainder Functions.
* fmodfN: (libc)Remainder Functions.
* fmodfNx: (libc)Remainder Functions.
* fmodl: (libc)Remainder Functions.
* fmtmsg: (libc)Printing Formatted Messages.
* fmul: (libc)Misc FP Arithmetic.
* fmull: (libc)Misc FP Arithmetic.
* fnmatch: (libc)Wildcard Matching.
* fopen64: (libc)Opening Streams.
* fopen: (libc)Opening Streams.
* fopencookie: (libc)Streams and Cookies.
* fork: (libc)Creating a Process.
* forkpty: (libc)Pseudo-Terminal Pairs.
* fpathconf: (libc)Pathconf.
* fpclassify: (libc)Floating Point Classes.
* fprintf: (libc)Formatted Output Functions.
* fputc: (libc)Simple Output.
* fputc_unlocked: (libc)Simple Output.
* fputs: (libc)Simple Output.
* fputs_unlocked: (libc)Simple Output.
* fputwc: (libc)Simple Output.
* fputwc_unlocked: (libc)Simple Output.
* fputws: (libc)Simple Output.
* fputws_unlocked: (libc)Simple Output.
* fread: (libc)Block Input/Output.
* fread_unlocked: (libc)Block Input/Output.
* free: (libc)Freeing after Malloc.
* freopen64: (libc)Opening Streams.
* freopen: (libc)Opening Streams.
* frexp: (libc)Normalization Functions.
* frexpf: (libc)Normalization Functions.
* frexpfN: (libc)Normalization Functions.
* frexpfNx: (libc)Normalization Functions.
* frexpl: (libc)Normalization Functions.
* fromfp: (libc)Rounding Functions.
* fromfpf: (libc)Rounding Functions.
* fromfpfN: (libc)Rounding Functions.
* fromfpfNx: (libc)Rounding Functions.
* fromfpl: (libc)Rounding Functions.
* fromfpx: (libc)Rounding Functions.
* fromfpxf: (libc)Rounding Functions.
* fromfpxfN: (libc)Rounding Functions.
* fromfpxfNx: (libc)Rounding Functions.
* fromfpxl: (libc)Rounding Functions.
* fscanf: (libc)Formatted Input Functions.
* fseek: (libc)File Positioning.
* fseeko64: (libc)File Positioning.
* fseeko: (libc)File Positioning.
* fsetpos64: (libc)Portable Positioning.
* fsetpos: (libc)Portable Positioning.
* fsqrt: (libc)Misc FP Arithmetic.
* fsqrtl: (libc)Misc FP Arithmetic.
* fstat64: (libc)Reading Attributes.
* fstat: (libc)Reading Attributes.
* fstatat64: (libc)Reading Attributes.
* fstatat: (libc)Reading Attributes.
* fsub: (libc)Misc FP Arithmetic.
* fsubl: (libc)Misc FP Arithmetic.
* fsync: (libc)Synchronizing I/O.
* ftell: (libc)File Positioning.
* ftello64: (libc)File Positioning.
* ftello: (libc)File Positioning.
* ftruncate64: (libc)File Size.
* ftruncate: (libc)File Size.
* ftrylockfile: (libc)Streams and Threads.
* ftw64: (libc)Working with Directory Trees.
* ftw: (libc)Working with Directory Trees.
* funlockfile: (libc)Streams and Threads.
* futimens: (libc)File Times.
* futimes: (libc)File Times.
* fwide: (libc)Streams and I18N.
* fwprintf: (libc)Formatted Output Functions.
* fwrite: (libc)Block Input/Output.
* fwrite_unlocked: (libc)Block Input/Output.
* fwscanf: (libc)Formatted Input Functions.
* gamma: (libc)Special Functions.
* gammaf: (libc)Special Functions.
* gammal: (libc)Special Functions.
* gcvt: (libc)System V Number Conversion.
* get_avphys_pages: (libc)Query Memory Parameters.
* get_current_dir_name: (libc)Working Directory.
* get_nprocs: (libc)Processor Resources.
* get_nprocs_conf: (libc)Processor Resources.
* get_phys_pages: (libc)Query Memory Parameters.
* getauxval: (libc)Auxiliary Vector.
* getc: (libc)Character Input.
* getc_unlocked: (libc)Character Input.
* getchar: (libc)Character Input.
* getchar_unlocked: (libc)Character Input.
* getcontext: (libc)System V contexts.
* getcpu: (libc)CPU Affinity.
* getcwd: (libc)Working Directory.
* getdate: (libc)General Time String Parsing.
* getdate_r: (libc)General Time String Parsing.
* getdelim: (libc)Line Input.
* getdents64: (libc)Low-level Directory Access.
* getdomainnname: (libc)Host Identification.
* getegid: (libc)Reading Persona.
* getentropy: (libc)Unpredictable Bytes.
* getenv: (libc)Environment Access.
* geteuid: (libc)Reading Persona.
* getfsent: (libc)fstab.
* getfsfile: (libc)fstab.
* getfsspec: (libc)fstab.
* getgid: (libc)Reading Persona.
* getgrent: (libc)Scanning All Groups.
* getgrent_r: (libc)Scanning All Groups.
* getgrgid: (libc)Lookup Group.
* getgrgid_r: (libc)Lookup Group.
* getgrnam: (libc)Lookup Group.
* getgrnam_r: (libc)Lookup Group.
* getgrouplist: (libc)Setting Groups.
* getgroups: (libc)Reading Persona.
* gethostbyaddr: (libc)Host Names.
* gethostbyaddr_r: (libc)Host Names.
* gethostbyname2: (libc)Host Names.
* gethostbyname2_r: (libc)Host Names.
* gethostbyname: (libc)Host Names.
* gethostbyname_r: (libc)Host Names.
* gethostent: (libc)Host Names.
* gethostid: (libc)Host Identification.
* gethostname: (libc)Host Identification.
* getitimer: (libc)Setting an Alarm.
* getline: (libc)Line Input.
* getloadavg: (libc)Processor Resources.
* getlogin: (libc)Who Logged In.
* getmntent: (libc)mtab.
* getmntent_r: (libc)mtab.
* getnetbyaddr: (libc)Networks Database.
* getnetbyname: (libc)Networks Database.
* getnetent: (libc)Networks Database.
* getnetgrent: (libc)Lookup Netgroup.
* getnetgrent_r: (libc)Lookup Netgroup.
* getopt: (libc)Using Getopt.
* getopt_long: (libc)Getopt Long Options.
* getopt_long_only: (libc)Getopt Long Options.
* getpagesize: (libc)Query Memory Parameters.
* getpass: (libc)getpass.
* getpayload: (libc)FP Bit Twiddling.
* getpayloadf: (libc)FP Bit Twiddling.
* getpayloadfN: (libc)FP Bit Twiddling.
* getpayloadfNx: (libc)FP Bit Twiddling.
* getpayloadl: (libc)FP Bit Twiddling.
* getpeername: (libc)Who is Connected.
* getpgid: (libc)Process Group Functions.
* getpgrp: (libc)Process Group Functions.
* getpid: (libc)Process Identification.
* getppid: (libc)Process Identification.
* getpriority: (libc)Traditional Scheduling Functions.
* getprotobyname: (libc)Protocols Database.
* getprotobynumber: (libc)Protocols Database.
* getprotoent: (libc)Protocols Database.
* getpt: (libc)Allocation.
* getpwent: (libc)Scanning All Users.
* getpwent_r: (libc)Scanning All Users.
* getpwnam: (libc)Lookup User.
* getpwnam_r: (libc)Lookup User.
* getpwuid: (libc)Lookup User.
* getpwuid_r: (libc)Lookup User.
* getrandom: (libc)Unpredictable Bytes.
* getrlimit64: (libc)Limits on Resources.
* getrlimit: (libc)Limits on Resources.
* getrusage: (libc)Resource Usage.
* gets: (libc)Line Input.
* getservbyname: (libc)Services Database.
* getservbyport: (libc)Services Database.
* getservent: (libc)Services Database.
* getsid: (libc)Process Group Functions.
* getsockname: (libc)Reading Address.
* getsockopt: (libc)Socket Option Functions.
* getsubopt: (libc)Suboptions.
* gettext: (libc)Translation with gettext.
* gettid: (libc)Process Identification.
* gettimeofday: (libc)Getting the Time.
* getuid: (libc)Reading Persona.
* getumask: (libc)Setting Permissions.
* getutent: (libc)Manipulating the Database.
* getutent_r: (libc)Manipulating the Database.
* getutid: (libc)Manipulating the Database.
* getutid_r: (libc)Manipulating the Database.
* getutline: (libc)Manipulating the Database.
* getutline_r: (libc)Manipulating the Database.
* getutmp: (libc)XPG Functions.
* getutmpx: (libc)XPG Functions.
* getutxent: (libc)XPG Functions.
* getutxid: (libc)XPG Functions.
* getutxline: (libc)XPG Functions.
* getw: (libc)Character Input.
* getwc: (libc)Character Input.
* getwc_unlocked: (libc)Character Input.
* getwchar: (libc)Character Input.
* getwchar_unlocked: (libc)Character Input.
* getwd: (libc)Working Directory.
* glob64: (libc)Calling Glob.
* glob: (libc)Calling Glob.
* globfree64: (libc)More Flags for Globbing.
* globfree: (libc)More Flags for Globbing.
* gmtime: (libc)Broken-down Time.
* gmtime_r: (libc)Broken-down Time.
* grantpt: (libc)Allocation.
* gsignal: (libc)Signaling Yourself.
* gtty: (libc)BSD Terminal Modes.
* hasmntopt: (libc)mtab.
* hcreate: (libc)Hash Search Function.
* hcreate_r: (libc)Hash Search Function.
* hdestroy: (libc)Hash Search Function.
* hdestroy_r: (libc)Hash Search Function.
* hsearch: (libc)Hash Search Function.
* hsearch_r: (libc)Hash Search Function.
* htonl: (libc)Byte Order.
* htons: (libc)Byte Order.
* hypot: (libc)Exponents and Logarithms.
* hypotf: (libc)Exponents and Logarithms.
* hypotfN: (libc)Exponents and Logarithms.
* hypotfNx: (libc)Exponents and Logarithms.
* hypotl: (libc)Exponents and Logarithms.
* iconv: (libc)Generic Conversion Interface.
* iconv_close: (libc)Generic Conversion Interface.
* iconv_open: (libc)Generic Conversion Interface.
* if_freenameindex: (libc)Interface Naming.
* if_indextoname: (libc)Interface Naming.
* if_nameindex: (libc)Interface Naming.
* if_nametoindex: (libc)Interface Naming.
* ilogb: (libc)Exponents and Logarithms.
* ilogbf: (libc)Exponents and Logarithms.
* ilogbfN: (libc)Exponents and Logarithms.
* ilogbfNx: (libc)Exponents and Logarithms.
* ilogbl: (libc)Exponents and Logarithms.
* imaxabs: (libc)Absolute Value.
* imaxdiv: (libc)Integer Division.
* in6addr_any: (libc)Host Address Data Type.
* in6addr_loopback: (libc)Host Address Data Type.
* index: (libc)Search Functions.
* inet_addr: (libc)Host Address Functions.
* inet_aton: (libc)Host Address Functions.
* inet_lnaof: (libc)Host Address Functions.
* inet_makeaddr: (libc)Host Address Functions.
* inet_netof: (libc)Host Address Functions.
* inet_network: (libc)Host Address Functions.
* inet_ntoa: (libc)Host Address Functions.
* inet_ntop: (libc)Host Address Functions.
* inet_pton: (libc)Host Address Functions.
* initgroups: (libc)Setting Groups.
* initstate: (libc)BSD Random.
* initstate_r: (libc)BSD Random.
* innetgr: (libc)Netgroup Membership.
* ioctl: (libc)IOCTLs.
* isalnum: (libc)Classification of Characters.
* isalpha: (libc)Classification of Characters.
* isascii: (libc)Classification of Characters.
* isatty: (libc)Is It a Terminal.
* isblank: (libc)Classification of Characters.
* iscanonical: (libc)Floating Point Classes.
* iscntrl: (libc)Classification of Characters.
* isdigit: (libc)Classification of Characters.
* iseqsig: (libc)FP Comparison Functions.
* isfinite: (libc)Floating Point Classes.
* isgraph: (libc)Classification of Characters.
* isgreater: (libc)FP Comparison Functions.
* isgreaterequal: (libc)FP Comparison Functions.
* isinf: (libc)Floating Point Classes.
* isinff: (libc)Floating Point Classes.
* isinfl: (libc)Floating Point Classes.
* isless: (libc)FP Comparison Functions.
* islessequal: (libc)FP Comparison Functions.
* islessgreater: (libc)FP Comparison Functions.
* islower: (libc)Classification of Characters.
* isnan: (libc)Floating Point Classes.
* isnan: (libc)Floating Point Classes.
* isnanf: (libc)Floating Point Classes.
* isnanl: (libc)Floating Point Classes.
* isnormal: (libc)Floating Point Classes.
* isprint: (libc)Classification of Characters.
* ispunct: (libc)Classification of Characters.
* issignaling: (libc)Floating Point Classes.
* isspace: (libc)Classification of Characters.
* issubnormal: (libc)Floating Point Classes.
* isunordered: (libc)FP Comparison Functions.
* isupper: (libc)Classification of Characters.
* iswalnum: (libc)Classification of Wide Characters.
* iswalpha: (libc)Classification of Wide Characters.
* iswblank: (libc)Classification of Wide Characters.
* iswcntrl: (libc)Classification of Wide Characters.
* iswctype: (libc)Classification of Wide Characters.
* iswdigit: (libc)Classification of Wide Characters.
* iswgraph: (libc)Classification of Wide Characters.
* iswlower: (libc)Classification of Wide Characters.
* iswprint: (libc)Classification of Wide Characters.
* iswpunct: (libc)Classification of Wide Characters.
* iswspace: (libc)Classification of Wide Characters.
* iswupper: (libc)Classification of Wide Characters.
* iswxdigit: (libc)Classification of Wide Characters.
* isxdigit: (libc)Classification of Characters.
* iszero: (libc)Floating Point Classes.
* j0: (libc)Special Functions.
* j0f: (libc)Special Functions.
* j0fN: (libc)Special Functions.
* j0fNx: (libc)Special Functions.
* j0l: (libc)Special Functions.
* j1: (libc)Special Functions.
* j1f: (libc)Special Functions.
* j1fN: (libc)Special Functions.
* j1fNx: (libc)Special Functions.
* j1l: (libc)Special Functions.
* jn: (libc)Special Functions.
* jnf: (libc)Special Functions.
* jnfN: (libc)Special Functions.
* jnfNx: (libc)Special Functions.
* jnl: (libc)Special Functions.
* jrand48: (libc)SVID Random.
* jrand48_r: (libc)SVID Random.
* kill: (libc)Signaling Another Process.
* killpg: (libc)Signaling Another Process.
* l64a: (libc)Encode Binary Data.
* labs: (libc)Absolute Value.
* lcong48: (libc)SVID Random.
* lcong48_r: (libc)SVID Random.
* ldexp: (libc)Normalization Functions.
* ldexpf: (libc)Normalization Functions.
* ldexpfN: (libc)Normalization Functions.
* ldexpfNx: (libc)Normalization Functions.
* ldexpl: (libc)Normalization Functions.
* ldiv: (libc)Integer Division.
* lfind: (libc)Array Search Function.
* lgamma: (libc)Special Functions.
* lgamma_r: (libc)Special Functions.
* lgammaf: (libc)Special Functions.
* lgammafN: (libc)Special Functions.
* lgammafN_r: (libc)Special Functions.
* lgammafNx: (libc)Special Functions.
* lgammafNx_r: (libc)Special Functions.
* lgammaf_r: (libc)Special Functions.
* lgammal: (libc)Special Functions.
* lgammal_r: (libc)Special Functions.
* link: (libc)Hard Links.
* linkat: (libc)Hard Links.
* lio_listio64: (libc)Asynchronous Reads/Writes.
* lio_listio: (libc)Asynchronous Reads/Writes.
* listen: (libc)Listening.
* llabs: (libc)Absolute Value.
* lldiv: (libc)Integer Division.
* llogb: (libc)Exponents and Logarithms.
* llogbf: (libc)Exponents and Logarithms.
* llogbfN: (libc)Exponents and Logarithms.
* llogbfNx: (libc)Exponents and Logarithms.
* llogbl: (libc)Exponents and Logarithms.
* llrint: (libc)Rounding Functions.
* llrintf: (libc)Rounding Functions.
* llrintfN: (libc)Rounding Functions.
* llrintfNx: (libc)Rounding Functions.
* llrintl: (libc)Rounding Functions.
* llround: (libc)Rounding Functions.
* llroundf: (libc)Rounding Functions.
* llroundfN: (libc)Rounding Functions.
* llroundfNx: (libc)Rounding Functions.
* llroundl: (libc)Rounding Functions.
* localeconv: (libc)The Lame Way to Locale Data.
* localtime: (libc)Broken-down Time.
* localtime_r: (libc)Broken-down Time.
* log10: (libc)Exponents and Logarithms.
* log10f: (libc)Exponents and Logarithms.
* log10fN: (libc)Exponents and Logarithms.
* log10fNx: (libc)Exponents and Logarithms.
* log10l: (libc)Exponents and Logarithms.
* log10p1: (libc)Exponents and Logarithms.
* log10p1f: (libc)Exponents and Logarithms.
* log10p1fN: (libc)Exponents and Logarithms.
* log10p1fNx: (libc)Exponents and Logarithms.
* log10p1l: (libc)Exponents and Logarithms.
* log1p: (libc)Exponents and Logarithms.
* log1pf: (libc)Exponents and Logarithms.
* log1pfN: (libc)Exponents and Logarithms.
* log1pfNx: (libc)Exponents and Logarithms.
* log1pl: (libc)Exponents and Logarithms.
* log2: (libc)Exponents and Logarithms.
* log2f: (libc)Exponents and Logarithms.
* log2fN: (libc)Exponents and Logarithms.
* log2fNx: (libc)Exponents and Logarithms.
* log2l: (libc)Exponents and Logarithms.
* log2p1: (libc)Exponents and Logarithms.
* log2p1f: (libc)Exponents and Logarithms.
* log2p1fN: (libc)Exponents and Logarithms.
* log2p1fNx: (libc)Exponents and Logarithms.
* log2p1l: (libc)Exponents and Logarithms.
* log: (libc)Exponents and Logarithms.
* logb: (libc)Exponents and Logarithms.
* logbf: (libc)Exponents and Logarithms.
* logbfN: (libc)Exponents and Logarithms.
* logbfNx: (libc)Exponents and Logarithms.
* logbl: (libc)Exponents and Logarithms.
* logf: (libc)Exponents and Logarithms.
* logfN: (libc)Exponents and Logarithms.
* logfNx: (libc)Exponents and Logarithms.
* login: (libc)Logging In and Out.
* login_tty: (libc)Logging In and Out.
* logl: (libc)Exponents and Logarithms.
* logout: (libc)Logging In and Out.
* logp1: (libc)Exponents and Logarithms.
* logp1f: (libc)Exponents and Logarithms.
* logp1fN: (libc)Exponents and Logarithms.
* logp1fNx: (libc)Exponents and Logarithms.
* logp1l: (libc)Exponents and Logarithms.
* logwtmp: (libc)Logging In and Out.
* longjmp: (libc)Non-Local Details.
* lrand48: (libc)SVID Random.
* lrand48_r: (libc)SVID Random.
* lrint: (libc)Rounding Functions.
* lrintf: (libc)Rounding Functions.
* lrintfN: (libc)Rounding Functions.
* lrintfNx: (libc)Rounding Functions.
* lrintl: (libc)Rounding Functions.
* lround: (libc)Rounding Functions.
* lroundf: (libc)Rounding Functions.
* lroundfN: (libc)Rounding Functions.
* lroundfNx: (libc)Rounding Functions.
* lroundl: (libc)Rounding Functions.
* lsearch: (libc)Array Search Function.
* lseek64: (libc)File Position Primitive.
* lseek: (libc)File Position Primitive.
* lstat64: (libc)Reading Attributes.
* lstat: (libc)Reading Attributes.
* lutimes: (libc)File Times.
* madvise: (libc)Memory-mapped I/O.
* makecontext: (libc)System V contexts.
* mallinfo2: (libc)Statistics of Malloc.
* malloc: (libc)Basic Allocation.
* mallopt: (libc)Malloc Tunable Parameters.
* mblen: (libc)Non-reentrant Character Conversion.
* mbrlen: (libc)Converting a Character.
* mbrtowc: (libc)Converting a Character.
* mbsinit: (libc)Keeping the state.
* mbsnrtowcs: (libc)Converting Strings.
* mbsrtowcs: (libc)Converting Strings.
* mbstowcs: (libc)Non-reentrant String Conversion.
* mbtowc: (libc)Non-reentrant Character Conversion.
* mcheck: (libc)Heap Consistency Checking.
* memalign: (libc)Aligned Memory Blocks.
* memccpy: (libc)Copying Strings and Arrays.
* memchr: (libc)Search Functions.
* memcmp: (libc)String/Array Comparison.
* memcpy: (libc)Copying Strings and Arrays.
* memfd_create: (libc)Memory-mapped I/O.
* memfrob: (libc)Obfuscating Data.
* memmem: (libc)Search Functions.
* memmove: (libc)Copying Strings and Arrays.
* mempcpy: (libc)Copying Strings and Arrays.
* memrchr: (libc)Search Functions.
* memset: (libc)Copying Strings and Arrays.
* mkdir: (libc)Creating Directories.
* mkdirat: (libc)Creating Directories.
* mkdtemp: (libc)Temporary Files.
* mkfifo: (libc)FIFO Special Files.
* mknod: (libc)Making Special Files.
* mkstemp: (libc)Temporary Files.
* mktemp: (libc)Temporary Files.
* mktime: (libc)Broken-down Time.
* mlock2: (libc)Page Lock Functions.
* mlock: (libc)Page Lock Functions.
* mlockall: (libc)Page Lock Functions.
* mmap64: (libc)Memory-mapped I/O.
* mmap: (libc)Memory-mapped I/O.
* modf: (libc)Rounding Functions.
* modff: (libc)Rounding Functions.
* modffN: (libc)Rounding Functions.
* modffNx: (libc)Rounding Functions.
* modfl: (libc)Rounding Functions.
* mount: (libc)Mount-Unmount-Remount.
* mprobe: (libc)Heap Consistency Checking.
* mprotect: (libc)Memory Protection.
* mrand48: (libc)SVID Random.
* mrand48_r: (libc)SVID Random.
* mremap: (libc)Memory-mapped I/O.
* msync: (libc)Memory-mapped I/O.
* mtrace: (libc)Tracing malloc.
* mtx_destroy: (libc)ISO C Mutexes.
* mtx_init: (libc)ISO C Mutexes.
* mtx_lock: (libc)ISO C Mutexes.
* mtx_timedlock: (libc)ISO C Mutexes.
* mtx_trylock: (libc)ISO C Mutexes.
* mtx_unlock: (libc)ISO C Mutexes.
* munlock: (libc)Page Lock Functions.
* munlockall: (libc)Page Lock Functions.
* munmap: (libc)Memory-mapped I/O.
* muntrace: (libc)Tracing malloc.
* nan: (libc)FP Bit Twiddling.
* nanf: (libc)FP Bit Twiddling.
* nanfN: (libc)FP Bit Twiddling.
* nanfNx: (libc)FP Bit Twiddling.
* nanl: (libc)FP Bit Twiddling.
* nanosleep: (libc)Sleeping.
* nearbyint: (libc)Rounding Functions.
* nearbyintf: (libc)Rounding Functions.
* nearbyintfN: (libc)Rounding Functions.
* nearbyintfNx: (libc)Rounding Functions.
* nearbyintl: (libc)Rounding Functions.
* nextafter: (libc)FP Bit Twiddling.
* nextafterf: (libc)FP Bit Twiddling.
* nextafterfN: (libc)FP Bit Twiddling.
* nextafterfNx: (libc)FP Bit Twiddling.
* nextafterl: (libc)FP Bit Twiddling.
* nextdown: (libc)FP Bit Twiddling.
* nextdownf: (libc)FP Bit Twiddling.
* nextdownfN: (libc)FP Bit Twiddling.
* nextdownfNx: (libc)FP Bit Twiddling.
* nextdownl: (libc)FP Bit Twiddling.
* nexttoward: (libc)FP Bit Twiddling.
* nexttowardf: (libc)FP Bit Twiddling.
* nexttowardl: (libc)FP Bit Twiddling.
* nextup: (libc)FP Bit Twiddling.
* nextupf: (libc)FP Bit Twiddling.
* nextupfN: (libc)FP Bit Twiddling.
* nextupfNx: (libc)FP Bit Twiddling.
* nextupl: (libc)FP Bit Twiddling.
* nftw64: (libc)Working with Directory Trees.
* nftw: (libc)Working with Directory Trees.
* ngettext: (libc)Advanced gettext functions.
* nice: (libc)Traditional Scheduling Functions.
* nl_langinfo: (libc)The Elegant and Fast Way.
* nrand48: (libc)SVID Random.
* nrand48_r: (libc)SVID Random.
* ntohl: (libc)Byte Order.
* ntohs: (libc)Byte Order.
* ntp_adjtime: (libc)Setting and Adjusting the Time.
* ntp_gettime: (libc)Setting and Adjusting the Time.
* obstack_1grow: (libc)Growing Objects.
* obstack_1grow_fast: (libc)Extra Fast Growing.
* obstack_alignment_mask: (libc)Obstacks Data Alignment.
* obstack_alloc: (libc)Allocation in an Obstack.
* obstack_base: (libc)Status of an Obstack.
* obstack_blank: (libc)Growing Objects.
* obstack_blank_fast: (libc)Extra Fast Growing.
* obstack_chunk_size: (libc)Obstack Chunks.
* obstack_copy0: (libc)Allocation in an Obstack.
* obstack_copy: (libc)Allocation in an Obstack.
* obstack_finish: (libc)Growing Objects.
* obstack_free: (libc)Freeing Obstack Objects.
* obstack_grow0: (libc)Growing Objects.
* obstack_grow: (libc)Growing Objects.
* obstack_init: (libc)Preparing for Obstacks.
* obstack_int_grow: (libc)Growing Objects.
* obstack_int_grow_fast: (libc)Extra Fast Growing.
* obstack_next_free: (libc)Status of an Obstack.
* obstack_object_size: (libc)Growing Objects.
* obstack_object_size: (libc)Status of an Obstack.
* obstack_printf: (libc)Dynamic Output.
* obstack_ptr_grow: (libc)Growing Objects.
* obstack_ptr_grow_fast: (libc)Extra Fast Growing.
* obstack_room: (libc)Extra Fast Growing.
* obstack_vprintf: (libc)Variable Arguments Output.
* offsetof: (libc)Structure Measurement.
* on_exit: (libc)Cleanups on Exit.
* open64: (libc)Opening and Closing Files.
* open: (libc)Opening and Closing Files.
* open_memstream: (libc)String Streams.
* openat64: (libc)Opening and Closing Files.
* openat: (libc)Opening and Closing Files.
* opendir: (libc)Opening a Directory.
* openlog: (libc)openlog.
* openpty: (libc)Pseudo-Terminal Pairs.
* parse_printf_format: (libc)Parsing a Template String.
* pathconf: (libc)Pathconf.
* pause: (libc)Using Pause.
* pclose: (libc)Pipe to a Subprocess.
* perror: (libc)Error Messages.
* pidfd_getpid: (libc)Querying a Process.
* pipe: (libc)Creating a Pipe.
* pkey_alloc: (libc)Memory Protection.
* pkey_free: (libc)Memory Protection.
* pkey_get: (libc)Memory Protection.
* pkey_mprotect: (libc)Memory Protection.
* pkey_set: (libc)Memory Protection.
* poll: (libc)Other Low-Level I/O APIs.
* popen: (libc)Pipe to a Subprocess.
* posix_fallocate64: (libc)Storage Allocation.
* posix_fallocate: (libc)Storage Allocation.
* posix_memalign: (libc)Aligned Memory Blocks.
* posix_openpt: (libc)Allocation.
* pow: (libc)Exponents and Logarithms.
* powf: (libc)Exponents and Logarithms.
* powfN: (libc)Exponents and Logarithms.
* powfNx: (libc)Exponents and Logarithms.
* powl: (libc)Exponents and Logarithms.
* pown: (libc)Exponents and Logarithms.
* pownf: (libc)Exponents and Logarithms.
* pownfN: (libc)Exponents and Logarithms.
* pownfNx: (libc)Exponents and Logarithms.
* pownl: (libc)Exponents and Logarithms.
* powr: (libc)Exponents and Logarithms.
* powrf: (libc)Exponents and Logarithms.
* powrfN: (libc)Exponents and Logarithms.
* powrfNx: (libc)Exponents and Logarithms.
* powrl: (libc)Exponents and Logarithms.
* pread64: (libc)I/O Primitives.
* pread: (libc)I/O Primitives.
* preadv2: (libc)Scatter-Gather.
* preadv64: (libc)Scatter-Gather.
* preadv64v2: (libc)Scatter-Gather.
* preadv: (libc)Scatter-Gather.
* printf: (libc)Formatted Output Functions.
* printf_size: (libc)Predefined Printf Handlers.
* printf_size_info: (libc)Predefined Printf Handlers.
* psignal: (libc)Signal Messages.
* pthread_attr_destroy: (libc)Creating and Destroying Threads.
* pthread_attr_getaffinity_np: (libc)Thread CPU Affinity.
* pthread_attr_getdetachstate: (libc)Creating and Destroying Threads.
* pthread_attr_getsigmask_np: (libc)Initial Thread Signal Mask.
* pthread_attr_init: (libc)Creating and Destroying Threads.
* pthread_attr_setaffinity_np: (libc)Thread CPU Affinity.
* pthread_attr_setdetachstate: (libc)Creating and Destroying Threads.
* pthread_attr_setsigmask_np: (libc)Initial Thread Signal Mask.
* pthread_barrier_destroy: (libc)POSIX Barriers.
* pthread_barrier_init: (libc)POSIX Barriers.
* pthread_barrier_wait: (libc)POSIX Barriers.
* pthread_clockjoin_np: (libc)Joining Threads.
* pthread_cond_clockwait: (libc)Waiting with Explicit Clocks.
* pthread_create: (libc)Creating and Destroying Threads.
* pthread_detach: (libc)Creating and Destroying Threads.
* pthread_equal: (libc)POSIX Threads Other APIs.
* pthread_getaffinity_np: (libc)Thread CPU Affinity.
* pthread_getattr_default_np: (libc)Default Thread Attributes.
* pthread_getcpuclockid: (libc)POSIX Threads Other APIs.
* pthread_getname_np: (libc)Thread Names.
* pthread_getspecific: (libc)Thread-specific Data.
* pthread_gettid_np: (libc)Process Identification.
* pthread_join: (libc)Creating and Destroying Threads.
* pthread_key_create: (libc)Thread-specific Data.
* pthread_key_delete: (libc)Thread-specific Data.
* pthread_kill: (libc)Creating and Destroying Threads.
* pthread_mutex_clocklock: (libc)POSIX Mutexes.
* pthread_mutex_destroy: (libc)POSIX Mutexes.
* pthread_mutex_init: (libc)POSIX Mutexes.
* pthread_mutex_lock: (libc)POSIX Mutexes.
* pthread_mutex_timedlock: (libc)POSIX Mutexes.
* pthread_mutex_trylock: (libc)POSIX Mutexes.
* pthread_mutex_unlock: (libc)POSIX Mutexes.
* pthread_mutexattr_destroy: (libc)POSIX Mutexes.
* pthread_mutexattr_gettype: (libc)POSIX Mutexes.
* pthread_mutexattr_init: (libc)POSIX Mutexes.
* pthread_mutexattr_settype: (libc)POSIX Mutexes.
* pthread_once: (libc)POSIX Threads Other APIs.
* pthread_rwlock_clockrdlock: (libc)Waiting with Explicit Clocks.
* pthread_rwlock_clockwrlock: (libc)Waiting with Explicit Clocks.
* pthread_self: (libc)Creating and Destroying Threads.
* pthread_setaffinity_np: (libc)Thread CPU Affinity.
* pthread_setattr_default_np: (libc)Default Thread Attributes.
* pthread_setname_np: (libc)Thread Names.
* pthread_setspecific: (libc)Thread-specific Data.
* pthread_sigmask: (libc)POSIX Threads Other APIs.
* pthread_spin_destroy: (libc)POSIX Spin Locks.
* pthread_spin_init: (libc)POSIX Spin Locks.
* pthread_spin_lock: (libc)POSIX Spin Locks.
* pthread_spin_trylock: (libc)POSIX Spin Locks.
* pthread_spin_unlock: (libc)POSIX Spin Locks.
* pthread_timedjoin_np: (libc)Joining Threads.
* pthread_tryjoin_np: (libc)Joining Threads.
* ptsname: (libc)Allocation.
* ptsname_r: (libc)Allocation.
* putc: (libc)Simple Output.
* putc_unlocked: (libc)Simple Output.
* putchar: (libc)Simple Output.
* putchar_unlocked: (libc)Simple Output.
* putenv: (libc)Environment Access.
* putpwent: (libc)Writing a User Entry.
* puts: (libc)Simple Output.
* pututline: (libc)Manipulating the Database.
* pututxline: (libc)XPG Functions.
* putw: (libc)Simple Output.
* putwc: (libc)Simple Output.
* putwc_unlocked: (libc)Simple Output.
* putwchar: (libc)Simple Output.
* putwchar_unlocked: (libc)Simple Output.
* pwrite64: (libc)I/O Primitives.
* pwrite: (libc)I/O Primitives.
* pwritev2: (libc)Scatter-Gather.
* pwritev64: (libc)Scatter-Gather.
* pwritev64v2: (libc)Scatter-Gather.
* pwritev: (libc)Scatter-Gather.
* qecvt: (libc)System V Number Conversion.
* qecvt_r: (libc)System V Number Conversion.
* qfcvt: (libc)System V Number Conversion.
* qfcvt_r: (libc)System V Number Conversion.
* qgcvt: (libc)System V Number Conversion.
* qsort: (libc)Array Sort Function.
* raise: (libc)Signaling Yourself.
* rand: (libc)ISO Random.
* rand_r: (libc)ISO Random.
* random: (libc)BSD Random.
* random_r: (libc)BSD Random.
* rawmemchr: (libc)Search Functions.
* read: (libc)I/O Primitives.
* readdir64: (libc)Reading/Closing Directory.
* readdir64_r: (libc)Reading/Closing Directory.
* readdir: (libc)Reading/Closing Directory.
* readdir_r: (libc)Reading/Closing Directory.
* readlink: (libc)Symbolic Links.
* readv: (libc)Scatter-Gather.
* realloc: (libc)Changing Block Size.
* reallocarray: (libc)Changing Block Size.
* realpath: (libc)Symbolic Links.
* recv: (libc)Receiving Data.
* recvfrom: (libc)Receiving Datagrams.
* recvmsg: (libc)Other Socket APIs.
* regcomp: (libc)POSIX Regexp Compilation.
* regerror: (libc)Regexp Cleanup.
* regexec: (libc)Matching POSIX Regexps.
* regfree: (libc)Regexp Cleanup.
* register_printf_function: (libc)Registering New Conversions.
* remainder: (libc)Remainder Functions.
* remainderf: (libc)Remainder Functions.
* remainderfN: (libc)Remainder Functions.
* remainderfNx: (libc)Remainder Functions.
* remainderl: (libc)Remainder Functions.
* remove: (libc)Deleting Files.
* rename: (libc)Renaming Files.
* renameat: (libc)Renaming Files.
* rewind: (libc)File Positioning.
* rewinddir: (libc)Random Access Directory.
* rindex: (libc)Search Functions.
* rint: (libc)Rounding Functions.
* rintf: (libc)Rounding Functions.
* rintfN: (libc)Rounding Functions.
* rintfNx: (libc)Rounding Functions.
* rintl: (libc)Rounding Functions.
* rmdir: (libc)Deleting Files.
* rootn: (libc)Exponents and Logarithms.
* rootnf: (libc)Exponents and Logarithms.
* rootnfN: (libc)Exponents and Logarithms.
* rootnfNx: (libc)Exponents and Logarithms.
* rootnl: (libc)Exponents and Logarithms.
* round: (libc)Rounding Functions.
* roundeven: (libc)Rounding Functions.
* roundevenf: (libc)Rounding Functions.
* roundevenfN: (libc)Rounding Functions.
* roundevenfNx: (libc)Rounding Functions.
* roundevenl: (libc)Rounding Functions.
* roundf: (libc)Rounding Functions.
* roundfN: (libc)Rounding Functions.
* roundfNx: (libc)Rounding Functions.
* roundl: (libc)Rounding Functions.
* rpmatch: (libc)Yes-or-No Questions.
* rsqrt: (libc)Exponents and Logarithms.
* rsqrtf: (libc)Exponents and Logarithms.
* rsqrtfN: (libc)Exponents and Logarithms.
* rsqrtfNx: (libc)Exponents and Logarithms.
* rsqrtl: (libc)Exponents and Logarithms.
* sbrk: (libc)Resizing the Data Segment.
* scalb: (libc)Normalization Functions.
* scalbf: (libc)Normalization Functions.
* scalbl: (libc)Normalization Functions.
* scalbln: (libc)Normalization Functions.
* scalblnf: (libc)Normalization Functions.
* scalblnfN: (libc)Normalization Functions.
* scalblnfNx: (libc)Normalization Functions.
* scalblnl: (libc)Normalization Functions.
* scalbn: (libc)Normalization Functions.
* scalbnf: (libc)Normalization Functions.
* scalbnfN: (libc)Normalization Functions.
* scalbnfNx: (libc)Normalization Functions.
* scalbnl: (libc)Normalization Functions.
* scandir64: (libc)Scanning Directory Content.
* scandir: (libc)Scanning Directory Content.
* scanf: (libc)Formatted Input Functions.
* sched_get_priority_max: (libc)Basic Scheduling Functions.
* sched_get_priority_min: (libc)Basic Scheduling Functions.
* sched_getaffinity: (libc)CPU Affinity.
* sched_getattr: (libc)Extensible Scheduling.
* sched_getcpu: (libc)CPU Affinity.
* sched_getparam: (libc)Basic Scheduling Functions.
* sched_getscheduler: (libc)Basic Scheduling Functions.
* sched_rr_get_interval: (libc)Basic Scheduling Functions.
* sched_setaffinity: (libc)CPU Affinity.
* sched_setattr: (libc)Extensible Scheduling.
* sched_setparam: (libc)Basic Scheduling Functions.
* sched_setscheduler: (libc)Basic Scheduling Functions.
* sched_yield: (libc)Basic Scheduling Functions.
* secure_getenv: (libc)Environment Access.
* seed48: (libc)SVID Random.
* seed48_r: (libc)SVID Random.
* seekdir: (libc)Random Access Directory.
* select: (libc)Waiting for I/O.
* sem_clockwait: (libc)POSIX Semaphores.
* sem_close: (libc)POSIX Semaphores.
* sem_destroy: (libc)POSIX Semaphores.
* sem_getvalue: (libc)POSIX Semaphores.
* sem_init: (libc)POSIX Semaphores.
* sem_open: (libc)POSIX Semaphores.
* sem_post: (libc)POSIX Semaphores.
* sem_timedwait: (libc)POSIX Semaphores.
* sem_trywait: (libc)POSIX Semaphores.
* sem_unlink: (libc)POSIX Semaphores.
* sem_wait: (libc)POSIX Semaphores.
* semctl: (libc)Semaphores.
* semget: (libc)Semaphores.
* semop: (libc)Semaphores.
* semtimedop: (libc)Semaphores.
* send: (libc)Sending Data.
* sendmsg: (libc)Other Socket APIs.
* sendto: (libc)Sending Datagrams.
* setbuf: (libc)Controlling Buffering.
* setbuffer: (libc)Controlling Buffering.
* setcontext: (libc)System V contexts.
* setdomainname: (libc)Host Identification.
* setegid: (libc)Setting Groups.
* setenv: (libc)Environment Access.
* seteuid: (libc)Setting User ID.
* setfsent: (libc)fstab.
* setgid: (libc)Setting Groups.
* setgrent: (libc)Scanning All Groups.
* setgroups: (libc)Setting Groups.
* sethostent: (libc)Host Names.
* sethostid: (libc)Host Identification.
* sethostname: (libc)Host Identification.
* setitimer: (libc)Setting an Alarm.
* setjmp: (libc)Non-Local Details.
* setlinebuf: (libc)Controlling Buffering.
* setlocale: (libc)Setting the Locale.
* setlogmask: (libc)setlogmask.
* setmntent: (libc)mtab.
* setnetent: (libc)Networks Database.
* setnetgrent: (libc)Lookup Netgroup.
* setpayload: (libc)FP Bit Twiddling.
* setpayloadf: (libc)FP Bit Twiddling.
* setpayloadfN: (libc)FP Bit Twiddling.
* setpayloadfNx: (libc)FP Bit Twiddling.
* setpayloadl: (libc)FP Bit Twiddling.
* setpayloadsig: (libc)FP Bit Twiddling.
* setpayloadsigf: (libc)FP Bit Twiddling.
* setpayloadsigfN: (libc)FP Bit Twiddling.
* setpayloadsigfNx: (libc)FP Bit Twiddling.
* setpayloadsigl: (libc)FP Bit Twiddling.
* setpgid: (libc)Process Group Functions.
* setpgrp: (libc)Process Group Functions.
* setpriority: (libc)Traditional Scheduling Functions.
* setprotoent: (libc)Protocols Database.
* setpwent: (libc)Scanning All Users.
* setregid: (libc)Setting Groups.
* setreuid: (libc)Setting User ID.
* setrlimit64: (libc)Limits on Resources.
* setrlimit: (libc)Limits on Resources.
* setservent: (libc)Services Database.
* setsid: (libc)Process Group Functions.
* setsockopt: (libc)Socket Option Functions.
* setstate: (libc)BSD Random.
* setstate_r: (libc)BSD Random.
* settimeofday: (libc)Setting and Adjusting the Time.
* setuid: (libc)Setting User ID.
* setutent: (libc)Manipulating the Database.
* setutxent: (libc)XPG Functions.
* setvbuf: (libc)Controlling Buffering.
* shm_open: (libc)Memory-mapped I/O.
* shm_unlink: (libc)Memory-mapped I/O.
* shutdown: (libc)Closing a Socket.
* sigabbrev_np: (libc)Signal Messages.
* sigaction: (libc)Advanced Signal Handling.
* sigaddset: (libc)Signal Sets.
* sigaltstack: (libc)Signal Stack.
* sigblock: (libc)BSD Signal Handling.
* sigdelset: (libc)Signal Sets.
* sigdescr_np: (libc)Signal Messages.
* sigemptyset: (libc)Signal Sets.
* sigfillset: (libc)Signal Sets.
* siginterrupt: (libc)BSD Signal Handling.
* sigismember: (libc)Signal Sets.
* siglongjmp: (libc)Non-Local Exits and Signals.
* sigmask: (libc)BSD Signal Handling.
* signal: (libc)Basic Signal Handling.
* signbit: (libc)FP Bit Twiddling.
* significand: (libc)Normalization Functions.
* significandf: (libc)Normalization Functions.
* significandl: (libc)Normalization Functions.
* sigpause: (libc)BSD Signal Handling.
* sigpending: (libc)Checking for Pending Signals.
* sigprocmask: (libc)Process Signal Mask.
* sigsetjmp: (libc)Non-Local Exits and Signals.
* sigsetmask: (libc)BSD Signal Handling.
* sigstack: (libc)Signal Stack.
* sigsuspend: (libc)Sigsuspend.
* sin: (libc)Trig Functions.
* sincos: (libc)Trig Functions.
* sincosf: (libc)Trig Functions.
* sincosfN: (libc)Trig Functions.
* sincosfNx: (libc)Trig Functions.
* sincosl: (libc)Trig Functions.
* sinf: (libc)Trig Functions.
* sinfN: (libc)Trig Functions.
* sinfNx: (libc)Trig Functions.
* sinh: (libc)Hyperbolic Functions.
* sinhf: (libc)Hyperbolic Functions.
* sinhfN: (libc)Hyperbolic Functions.
* sinhfNx: (libc)Hyperbolic Functions.
* sinhl: (libc)Hyperbolic Functions.
* sinl: (libc)Trig Functions.
* sinpi: (libc)Trig Functions.
* sinpif: (libc)Trig Functions.
* sinpifN: (libc)Trig Functions.
* sinpifNx: (libc)Trig Functions.
* sinpil: (libc)Trig Functions.
* sleep: (libc)Sleeping.
* snprintf: (libc)Formatted Output Functions.
* socket: (libc)Creating a Socket.
* socketpair: (libc)Socket Pairs.
* sprintf: (libc)Formatted Output Functions.
* sqrt: (libc)Exponents and Logarithms.
* sqrtf: (libc)Exponents and Logarithms.
* sqrtfN: (libc)Exponents and Logarithms.
* sqrtfNx: (libc)Exponents and Logarithms.
* sqrtl: (libc)Exponents and Logarithms.
* srand48: (libc)SVID Random.
* srand48_r: (libc)SVID Random.
* srand: (libc)ISO Random.
* srandom: (libc)BSD Random.
* srandom_r: (libc)BSD Random.
* sscanf: (libc)Formatted Input Functions.
* ssignal: (libc)Basic Signal Handling.
* stat64: (libc)Reading Attributes.
* stat: (libc)Reading Attributes.
* stdc_bit_ceil_uc: (libc)Bit Manipulation.
* stdc_bit_ceil_ui: (libc)Bit Manipulation.
* stdc_bit_ceil_ul: (libc)Bit Manipulation.
* stdc_bit_ceil_ull: (libc)Bit Manipulation.
* stdc_bit_ceil_us: (libc)Bit Manipulation.
* stdc_bit_floor_uc: (libc)Bit Manipulation.
* stdc_bit_floor_ui: (libc)Bit Manipulation.
* stdc_bit_floor_ul: (libc)Bit Manipulation.
* stdc_bit_floor_ull: (libc)Bit Manipulation.
* stdc_bit_floor_us: (libc)Bit Manipulation.
* stdc_bit_width_uc: (libc)Bit Manipulation.
* stdc_bit_width_ui: (libc)Bit Manipulation.
* stdc_bit_width_ul: (libc)Bit Manipulation.
* stdc_bit_width_ull: (libc)Bit Manipulation.
* stdc_bit_width_us: (libc)Bit Manipulation.
* stdc_count_ones_uc: (libc)Bit Manipulation.
* stdc_count_ones_ui: (libc)Bit Manipulation.
* stdc_count_ones_ul: (libc)Bit Manipulation.
* stdc_count_ones_ull: (libc)Bit Manipulation.
* stdc_count_ones_us: (libc)Bit Manipulation.
* stdc_count_zeros_uc: (libc)Bit Manipulation.
* stdc_count_zeros_ui: (libc)Bit Manipulation.
* stdc_count_zeros_ul: (libc)Bit Manipulation.
* stdc_count_zeros_ull: (libc)Bit Manipulation.
* stdc_count_zeros_us: (libc)Bit Manipulation.
* stdc_first_leading_one_uc: (libc)Bit Manipulation.
* stdc_first_leading_one_ui: (libc)Bit Manipulation.
* stdc_first_leading_one_ul: (libc)Bit Manipulation.
* stdc_first_leading_one_ull: (libc)Bit Manipulation.
* stdc_first_leading_one_us: (libc)Bit Manipulation.
* stdc_first_leading_zero_uc: (libc)Bit Manipulation.
* stdc_first_leading_zero_ui: (libc)Bit Manipulation.
* stdc_first_leading_zero_ul: (libc)Bit Manipulation.
* stdc_first_leading_zero_ull: (libc)Bit Manipulation.
* stdc_first_leading_zero_us: (libc)Bit Manipulation.
* stdc_first_trailing_one_uc: (libc)Bit Manipulation.
* stdc_first_trailing_one_ui: (libc)Bit Manipulation.
* stdc_first_trailing_one_ul: (libc)Bit Manipulation.
* stdc_first_trailing_one_ull: (libc)Bit Manipulation.
* stdc_first_trailing_one_us: (libc)Bit Manipulation.
* stdc_first_trailing_zero_uc: (libc)Bit Manipulation.
* stdc_first_trailing_zero_ui: (libc)Bit Manipulation.
* stdc_first_trailing_zero_ul: (libc)Bit Manipulation.
* stdc_first_trailing_zero_ull: (libc)Bit Manipulation.
* stdc_first_trailing_zero_us: (libc)Bit Manipulation.
* stdc_has_single_bit_uc: (libc)Bit Manipulation.
* stdc_has_single_bit_ui: (libc)Bit Manipulation.
* stdc_has_single_bit_ul: (libc)Bit Manipulation.
* stdc_has_single_bit_ull: (libc)Bit Manipulation.
* stdc_has_single_bit_us: (libc)Bit Manipulation.
* stdc_leading_ones_uc: (libc)Bit Manipulation.
* stdc_leading_ones_ui: (libc)Bit Manipulation.
* stdc_leading_ones_ul: (libc)Bit Manipulation.
* stdc_leading_ones_ull: (libc)Bit Manipulation.
* stdc_leading_ones_us: (libc)Bit Manipulation.
* stdc_leading_zeros_uc: (libc)Bit Manipulation.
* stdc_leading_zeros_ui: (libc)Bit Manipulation.
* stdc_leading_zeros_ul: (libc)Bit Manipulation.
* stdc_leading_zeros_ull: (libc)Bit Manipulation.
* stdc_leading_zeros_us: (libc)Bit Manipulation.
* stdc_trailing_ones_uc: (libc)Bit Manipulation.
* stdc_trailing_ones_ui: (libc)Bit Manipulation.
* stdc_trailing_ones_ul: (libc)Bit Manipulation.
* stdc_trailing_ones_ull: (libc)Bit Manipulation.
* stdc_trailing_ones_us: (libc)Bit Manipulation.
* stdc_trailing_zeros_uc: (libc)Bit Manipulation.
* stdc_trailing_zeros_ui: (libc)Bit Manipulation.
* stdc_trailing_zeros_ul: (libc)Bit Manipulation.
* stdc_trailing_zeros_ull: (libc)Bit Manipulation.
* stdc_trailing_zeros_us: (libc)Bit Manipulation.
* stime: (libc)Setting and Adjusting the Time.
* stpcpy: (libc)Copying Strings and Arrays.
* stpncpy: (libc)Truncating Strings.
* strcasecmp: (libc)String/Array Comparison.
* strcasestr: (libc)Search Functions.
* strcat: (libc)Concatenating Strings.
* strchr: (libc)Search Functions.
* strchrnul: (libc)Search Functions.
* strcmp: (libc)String/Array Comparison.
* strcoll: (libc)Collation Functions.
* strcpy: (libc)Copying Strings and Arrays.
* strcspn: (libc)Search Functions.
* strdup: (libc)Copying Strings and Arrays.
* strdupa: (libc)Copying Strings and Arrays.
* strerror: (libc)Error Messages.
* strerror_l: (libc)Error Messages.
* strerror_r: (libc)Error Messages.
* strerror_r: (libc)Error Messages.
* strerrordesc_np: (libc)Error Messages.
* strerrorname_np: (libc)Error Messages.
* strfmon: (libc)Formatting Numbers.
* strfromd: (libc)Printing of Floats.
* strfromf: (libc)Printing of Floats.
* strfromfN: (libc)Printing of Floats.
* strfromfNx: (libc)Printing of Floats.
* strfroml: (libc)Printing of Floats.
* strfry: (libc)Shuffling Bytes.
* strftime: (libc)Formatting Calendar Time.
* strftime_l: (libc)Formatting Calendar Time.
* strlcat: (libc)Truncating Strings.
* strlcpy: (libc)Truncating Strings.
* strlen: (libc)String Length.
* strncasecmp: (libc)String/Array Comparison.
* strncat: (libc)Truncating Strings.
* strncmp: (libc)String/Array Comparison.
* strncpy: (libc)Truncating Strings.
* strndup: (libc)Truncating Strings.
* strndupa: (libc)Truncating Strings.
* strnlen: (libc)String Length.
* strpbrk: (libc)Search Functions.
* strptime: (libc)Low-Level Time String Parsing.
* strrchr: (libc)Search Functions.
* strsep: (libc)Finding Tokens in a String.
* strsignal: (libc)Signal Messages.
* strspn: (libc)Search Functions.
* strstr: (libc)Search Functions.
* strtod: (libc)Parsing of Floats.
* strtof: (libc)Parsing of Floats.
* strtofN: (libc)Parsing of Floats.
* strtofNx: (libc)Parsing of Floats.
* strtoimax: (libc)Parsing of Integers.
* strtok: (libc)Finding Tokens in a String.
* strtok_r: (libc)Finding Tokens in a String.
* strtol: (libc)Parsing of Integers.
* strtold: (libc)Parsing of Floats.
* strtoll: (libc)Parsing of Integers.
* strtoq: (libc)Parsing of Integers.
* strtoul: (libc)Parsing of Integers.
* strtoull: (libc)Parsing of Integers.
* strtoumax: (libc)Parsing of Integers.
* strtouq: (libc)Parsing of Integers.
* strverscmp: (libc)String/Array Comparison.
* strxfrm: (libc)Collation Functions.
* stty: (libc)BSD Terminal Modes.
* swapcontext: (libc)System V contexts.
* swprintf: (libc)Formatted Output Functions.
* swscanf: (libc)Formatted Input Functions.
* symlink: (libc)Symbolic Links.
* sync: (libc)Synchronizing I/O.
* syscall: (libc)System Calls.
* sysconf: (libc)Sysconf Definition.
* syslog: (libc)syslog; vsyslog.
* system: (libc)Running a Command.
* sysv_signal: (libc)Basic Signal Handling.
* tan: (libc)Trig Functions.
* tanf: (libc)Trig Functions.
* tanfN: (libc)Trig Functions.
* tanfNx: (libc)Trig Functions.
* tanh: (libc)Hyperbolic Functions.
* tanhf: (libc)Hyperbolic Functions.
* tanhfN: (libc)Hyperbolic Functions.
* tanhfNx: (libc)Hyperbolic Functions.
* tanhl: (libc)Hyperbolic Functions.
* tanl: (libc)Trig Functions.
* tanpi: (libc)Trig Functions.
* tanpif: (libc)Trig Functions.
* tanpifN: (libc)Trig Functions.
* tanpifNx: (libc)Trig Functions.
* tanpil: (libc)Trig Functions.
* tcdrain: (libc)Line Control.
* tcflow: (libc)Line Control.
* tcflush: (libc)Line Control.
* tcgetattr: (libc)Mode Functions.
* tcgetpgrp: (libc)Terminal Access Functions.
* tcgetsid: (libc)Terminal Access Functions.
* tcsendbreak: (libc)Line Control.
* tcsetattr: (libc)Mode Functions.
* tcsetpgrp: (libc)Terminal Access Functions.
* tdelete: (libc)Tree Search Function.
* tdestroy: (libc)Tree Search Function.
* telldir: (libc)Random Access Directory.
* tempnam: (libc)Temporary Files.
* textdomain: (libc)Locating gettext catalog.
* tfind: (libc)Tree Search Function.
* tgamma: (libc)Special Functions.
* tgammaf: (libc)Special Functions.
* tgammafN: (libc)Special Functions.
* tgammafNx: (libc)Special Functions.
* tgammal: (libc)Special Functions.
* tgkill: (libc)Signaling Another Process.
* thrd_create: (libc)ISO C Thread Management.
* thrd_current: (libc)ISO C Thread Management.
* thrd_detach: (libc)ISO C Thread Management.
* thrd_equal: (libc)ISO C Thread Management.
* thrd_exit: (libc)ISO C Thread Management.
* thrd_join: (libc)ISO C Thread Management.
* thrd_sleep: (libc)ISO C Thread Management.
* thrd_yield: (libc)ISO C Thread Management.
* time: (libc)Getting the Time.
* timegm: (libc)Broken-down Time.
* timelocal: (libc)Broken-down Time.
* times: (libc)Processor Time.
* timespec_get: (libc)Getting the Time.
* timespec_getres: (libc)Getting the Time.
* tmpfile64: (libc)Temporary Files.
* tmpfile: (libc)Temporary Files.
* tmpnam: (libc)Temporary Files.
* tmpnam_r: (libc)Temporary Files.
* toascii: (libc)Case Conversion.
* tolower: (libc)Case Conversion.
* totalorder: (libc)FP Comparison Functions.
* totalorderf: (libc)FP Comparison Functions.
* totalorderfN: (libc)FP Comparison Functions.
* totalorderfNx: (libc)FP Comparison Functions.
* totalorderl: (libc)FP Comparison Functions.
* totalordermag: (libc)FP Comparison Functions.
* totalordermagf: (libc)FP Comparison Functions.
* totalordermagfN: (libc)FP Comparison Functions.
* totalordermagfNx: (libc)FP Comparison Functions.
* totalordermagl: (libc)FP Comparison Functions.
* toupper: (libc)Case Conversion.
* towctrans: (libc)Wide Character Case Conversion.
* towlower: (libc)Wide Character Case Conversion.
* towupper: (libc)Wide Character Case Conversion.
* trunc: (libc)Rounding Functions.
* truncate64: (libc)File Size.
* truncate: (libc)File Size.
* truncf: (libc)Rounding Functions.
* truncfN: (libc)Rounding Functions.
* truncfNx: (libc)Rounding Functions.
* truncl: (libc)Rounding Functions.
* tsearch: (libc)Tree Search Function.
* tss_create: (libc)ISO C Thread-local Storage.
* tss_delete: (libc)ISO C Thread-local Storage.
* tss_get: (libc)ISO C Thread-local Storage.
* tss_set: (libc)ISO C Thread-local Storage.
* ttyname: (libc)Is It a Terminal.
* ttyname_r: (libc)Is It a Terminal.
* twalk: (libc)Tree Search Function.
* twalk_r: (libc)Tree Search Function.
* tzset: (libc)Time Zone State.
* uabs: (libc)Absolute Value.
* ufromfp: (libc)Rounding Functions.
* ufromfpf: (libc)Rounding Functions.
* ufromfpfN: (libc)Rounding Functions.
* ufromfpfNx: (libc)Rounding Functions.
* ufromfpl: (libc)Rounding Functions.
* ufromfpx: (libc)Rounding Functions.
* ufromfpxf: (libc)Rounding Functions.
* ufromfpxfN: (libc)Rounding Functions.
* ufromfpxfNx: (libc)Rounding Functions.
* ufromfpxl: (libc)Rounding Functions.
* uimaxabs: (libc)Absolute Value.
* ulabs: (libc)Absolute Value.
* ulimit: (libc)Limits on Resources.
* ullabs: (libc)Absolute Value.
* umask: (libc)Setting Permissions.
* umount2: (libc)Mount-Unmount-Remount.
* umount: (libc)Mount-Unmount-Remount.
* uname: (libc)Platform Type.
* ungetc: (libc)How Unread.
* ungetwc: (libc)How Unread.
* unlink: (libc)Deleting Files.
* unlinkat: (libc)Deleting Files.
* unlockpt: (libc)Allocation.
* unsetenv: (libc)Environment Access.
* updwtmp: (libc)Manipulating the Database.
* utime: (libc)File Times.
* utimensat: (libc)File Times.
* utimes: (libc)File Times.
* utmpname: (libc)Manipulating the Database.
* utmpxname: (libc)XPG Functions.
* va_arg: (libc)Argument Macros.
* va_copy: (libc)Argument Macros.
* va_end: (libc)Argument Macros.
* va_start: (libc)Argument Macros.
* valloc: (libc)Aligned Memory Blocks.
* vasprintf: (libc)Variable Arguments Output.
* vdprintf: (libc)Variable Arguments Output.
* verr: (libc)Error Messages.
* verrx: (libc)Error Messages.
* versionsort64: (libc)Scanning Directory Content.
* versionsort: (libc)Scanning Directory Content.
* vfork: (libc)Creating a Process.
* vfprintf: (libc)Variable Arguments Output.
* vfscanf: (libc)Variable Arguments Input.
* vfwprintf: (libc)Variable Arguments Output.
* vfwscanf: (libc)Variable Arguments Input.
* vlimit: (libc)Limits on Resources.
* vprintf: (libc)Variable Arguments Output.
* vscanf: (libc)Variable Arguments Input.
* vsnprintf: (libc)Variable Arguments Output.
* vsprintf: (libc)Variable Arguments Output.
* vsscanf: (libc)Variable Arguments Input.
* vswprintf: (libc)Variable Arguments Output.
* vswscanf: (libc)Variable Arguments Input.
* vsyslog: (libc)syslog; vsyslog.
* vwarn: (libc)Error Messages.
* vwarnx: (libc)Error Messages.
* vwprintf: (libc)Variable Arguments Output.
* vwscanf: (libc)Variable Arguments Input.
* wait3: (libc)BSD Wait Functions.
* wait4: (libc)Process Completion.
* wait: (libc)Process Completion.
* waitpid: (libc)Process Completion.
* warn: (libc)Error Messages.
* warnx: (libc)Error Messages.
* wcpcpy: (libc)Copying Strings and Arrays.
* wcpncpy: (libc)Truncating Strings.
* wcrtomb: (libc)Converting a Character.
* wcscasecmp: (libc)String/Array Comparison.
* wcscat: (libc)Concatenating Strings.
* wcschr: (libc)Search Functions.
* wcschrnul: (libc)Search Functions.
* wcscmp: (libc)String/Array Comparison.
* wcscoll: (libc)Collation Functions.
* wcscpy: (libc)Copying Strings and Arrays.
* wcscspn: (libc)Search Functions.
* wcsdup: (libc)Copying Strings and Arrays.
* wcsftime: (libc)Formatting Calendar Time.
* wcslcat: (libc)Truncating Strings.
* wcslcpy: (libc)Truncating Strings.
* wcslen: (libc)String Length.
* wcsncasecmp: (libc)String/Array Comparison.
* wcsncat: (libc)Truncating Strings.
* wcsncmp: (libc)String/Array Comparison.
* wcsncpy: (libc)Truncating Strings.
* wcsnlen: (libc)String Length.
* wcsnrtombs: (libc)Converting Strings.
* wcspbrk: (libc)Search Functions.
* wcsrchr: (libc)Search Functions.
* wcsrtombs: (libc)Converting Strings.
* wcsspn: (libc)Search Functions.
* wcsstr: (libc)Search Functions.
* wcstod: (libc)Parsing of Floats.
* wcstof: (libc)Parsing of Floats.
* wcstofN: (libc)Parsing of Floats.
* wcstofNx: (libc)Parsing of Floats.
* wcstoimax: (libc)Parsing of Integers.
* wcstok: (libc)Finding Tokens in a String.
* wcstol: (libc)Parsing of Integers.
* wcstold: (libc)Parsing of Floats.
* wcstoll: (libc)Parsing of Integers.
* wcstombs: (libc)Non-reentrant String Conversion.
* wcstoq: (libc)Parsing of Integers.
* wcstoul: (libc)Parsing of Integers.
* wcstoull: (libc)Parsing of Integers.
* wcstoumax: (libc)Parsing of Integers.
* wcstouq: (libc)Parsing of Integers.
* wcswcs: (libc)Search Functions.
* wcsxfrm: (libc)Collation Functions.
* wctob: (libc)Converting a Character.
* wctomb: (libc)Non-reentrant Character Conversion.
* wctrans: (libc)Wide Character Case Conversion.
* wctype: (libc)Classification of Wide Characters.
* wmemchr: (libc)Search Functions.
* wmemcmp: (libc)String/Array Comparison.
* wmemcpy: (libc)Copying Strings and Arrays.
* wmemmove: (libc)Copying Strings and Arrays.
* wmempcpy: (libc)Copying Strings and Arrays.
* wmemset: (libc)Copying Strings and Arrays.
* wordexp: (libc)Calling Wordexp.
* wordfree: (libc)Calling Wordexp.
* wprintf: (libc)Formatted Output Functions.
* write: (libc)I/O Primitives.
* writev: (libc)Scatter-Gather.
* wscanf: (libc)Formatted Input Functions.
* y0: (libc)Special Functions.
* y0f: (libc)Special Functions.
* y0fN: (libc)Special Functions.
* y0fNx: (libc)Special Functions.
* y0l: (libc)Special Functions.
* y1: (libc)Special Functions.
* y1f: (libc)Special Functions.
* y1fN: (libc)Special Functions.
* y1fNx: (libc)Special Functions.
* y1l: (libc)Special Functions.
* yn: (libc)Special Functions.
* ynf: (libc)Special Functions.
* ynfN: (libc)Special Functions.
* ynfNx: (libc)Special Functions.
* ynl: (libc)Special Functions.
END-INFO-DIR-ENTRY


File: libc.info,  Node: Remainder Functions,  Next: FP Bit Twiddling,  Prev: Rounding Functions,  Up: Arithmetic Functions

20.8.4 Remainder Functions
--------------------------

The functions in this section compute the remainder on division of two
floating-point numbers.  Each is a little different; pick the one that
suits your problem.

 -- Function: double fmod (double NUMERATOR, double DENOMINATOR)
 -- Function: float fmodf (float NUMERATOR, float DENOMINATOR)
 -- Function: long double fmodl (long double NUMERATOR, long double
          DENOMINATOR)
 -- Function: _FloatN fmodfN (_FloatN NUMERATOR, _FloatN DENOMINATOR)
 -- Function: _FloatNx fmodfNx (_FloatNx NUMERATOR, _FloatNx
          DENOMINATOR)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     These functions compute the remainder from the division of
     NUMERATOR by DENOMINATOR.  Specifically, the return value is
     ‘NUMERATOR - N * DENOMINATOR’, where N is the quotient of NUMERATOR
     divided by DENOMINATOR, rounded towards zero to an integer.  Thus,
     ‘fmod (6.5, 2.3)’ returns ‘1.9’, which is ‘6.5’ minus ‘4.6’.

     The result has the same sign as the NUMERATOR and has magnitude
     less than the magnitude of the DENOMINATOR.

     If DENOMINATOR is zero, ‘fmod’ signals a domain error.

 -- Function: double remainder (double NUMERATOR, double DENOMINATOR)
 -- Function: float remainderf (float NUMERATOR, float DENOMINATOR)
 -- Function: long double remainderl (long double NUMERATOR, long double
          DENOMINATOR)
 -- Function: _FloatN remainderfN (_FloatN NUMERATOR, _FloatN
          DENOMINATOR)
 -- Function: _FloatNx remainderfNx (_FloatNx NUMERATOR, _FloatNx
          DENOMINATOR)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     These functions are like ‘fmod’ except that they round the internal
     quotient N to the nearest integer instead of towards zero to an
     integer.  For example, ‘remainder (6.5, 2.3)’ returns ‘-0.4’, which
     is ‘6.5’ minus ‘6.9’.

     The absolute value of the result is less than or equal to half the
     absolute value of the DENOMINATOR.  The difference between ‘fmod
     (NUMERATOR, DENOMINATOR)’ and ‘remainder (NUMERATOR, DENOMINATOR)’
     is always either DENOMINATOR, minus DENOMINATOR, or zero.

     If DENOMINATOR is zero, ‘remainder’ signals a domain error.

 -- Function: double drem (double NUMERATOR, double DENOMINATOR)
 -- Function: float dremf (float NUMERATOR, float DENOMINATOR)
 -- Function: long double dreml (long double NUMERATOR, long double
          DENOMINATOR)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     This function is another name for ‘remainder’.


File: libc.info,  Node: FP Bit Twiddling,  Next: FP Comparison Functions,  Prev: Remainder Functions,  Up: Arithmetic Functions

20.8.5 Setting and modifying single bits of FP values
-----------------------------------------------------

There are some operations that are too complicated or expensive to
perform by hand on floating-point numbers.  ISO C99 defines functions to
do these operations, which mostly involve changing single bits.

 -- Function: double copysign (double X, double Y)
 -- Function: float copysignf (float X, float Y)
 -- Function: long double copysignl (long double X, long double Y)
 -- Function: _FloatN copysignfN (_FloatN X, _FloatN Y)
 -- Function: _FloatNx copysignfNx (_FloatNx X, _FloatNx Y)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     These functions return X but with the sign of Y.  They work even if
     X or Y are NaN or zero.  Both of these can carry a sign (although
     not all implementations support it) and this is one of the few
     operations that can tell the difference.

     ‘copysign’ never raises an exception.

     This function is defined in IEC 559 (and the appendix with
     recommended functions in IEEE 754/IEEE 854).

 -- Function: int signbit (_float-type_ X)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     ‘signbit’ is a generic macro which can work on all floating-point
     types.  It returns a nonzero value if the value of X has its sign
     bit set.

     This is not the same as ‘x < 0.0’, because IEEE 754 floating point
     allows zero to be signed.  The comparison ‘-0.0 < 0.0’ is false,
     but ‘signbit (-0.0)’ will return a nonzero value.

 -- Function: double nextafter (double X, double Y)
 -- Function: float nextafterf (float X, float Y)
 -- Function: long double nextafterl (long double X, long double Y)
 -- Function: _FloatN nextafterfN (_FloatN X, _FloatN Y)
 -- Function: _FloatNx nextafterfNx (_FloatNx X, _FloatNx Y)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     The ‘nextafter’ function returns the next representable neighbor of
     X in the direction towards Y.  The size of the step between X and
     the result depends on the type of the result.  If X = Y the
     function simply returns Y.  If either value is ‘NaN’, ‘NaN’ is
     returned.  Otherwise a value corresponding to the value of the
     least significant bit in the mantissa is added or subtracted,
     depending on the direction.  ‘nextafter’ will signal overflow or
     underflow if the result goes outside of the range of normalized
     numbers.

     This function is defined in IEC 559 (and the appendix with
     recommended functions in IEEE 754/IEEE 854).

 -- Function: double nexttoward (double X, long double Y)
 -- Function: float nexttowardf (float X, long double Y)
 -- Function: long double nexttowardl (long double X, long double Y)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     These functions are identical to the corresponding versions of
     ‘nextafter’ except that their second argument is a ‘long double’.

 -- Function: double nextup (double X)
 -- Function: float nextupf (float X)
 -- Function: long double nextupl (long double X)
 -- Function: _FloatN nextupfN (_FloatN X)
 -- Function: _FloatNx nextupfNx (_FloatNx X)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     The ‘nextup’ function returns the next representable neighbor of X
     in the direction of positive infinity.  If X is the smallest
     negative subnormal number in the type of X the function returns
     ‘-0’.  If X = ‘0’ the function returns the smallest positive
     subnormal number in the type of X.  If X is NaN, NaN is returned.
     If X is +oo, +oo is returned.  ‘nextup’ is from TS 18661-1:2014 and
     TS 18661-3:2015.  ‘nextup’ never raises an exception except for
     signaling NaNs.

 -- Function: double nextdown (double X)
 -- Function: float nextdownf (float X)
 -- Function: long double nextdownl (long double X)
 -- Function: _FloatN nextdownfN (_FloatN X)
 -- Function: _FloatNx nextdownfNx (_FloatNx X)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     The ‘nextdown’ function returns the next representable neighbor of
     X in the direction of negative infinity.  If X is the smallest
     positive subnormal number in the type of X the function returns
     ‘+0’.  If X = ‘0’ the function returns the smallest negative
     subnormal number in the type of X.  If X is NaN, NaN is returned.
     If X is -oo, -oo is returned.  ‘nextdown’ is from TS 18661-1:2014
     and TS 18661-3:2015.  ‘nextdown’ never raises an exception except
     for signaling NaNs.

 -- Function: double nan (const char *TAGP)
 -- Function: float nanf (const char *TAGP)
 -- Function: long double nanl (const char *TAGP)
 -- Function: _FloatN nanfN (const char *TAGP)
 -- Function: _FloatNx nanfNx (const char *TAGP)

     Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
     Safety Concepts::.

     The ‘nan’ function returns a representation of NaN, provided that
     NaN is supported by the target platform.  ‘nan ("N-CHAR-SEQUENCE")’
     is equivalent to ‘strtod ("NAN(N-CHAR-SEQUENCE)")’.

     The argument TAGP is used in an unspecified manner.  On IEEE 754
     systems, there are many representations of NaN, and TAGP selects
     one.  On other systems it may do nothing.

 -- Function: int canonicalize (double *CX, const double *X)
 -- Function: int canonicalizef (float *CX, const float *X)
 -- Function: int canonicalizel (long double *CX, const long double *X)
 -- Function: int canonicalizefN (_FloatN *CX, const _FloatN *X)
 -- Function: int canonicalizefNx (_FloatNx *CX, const _FloatNx *X)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     In some floating-point formats, some values have canonical
     (preferred) and noncanonical encodings (for IEEE interchange binary
     formats, all encodings are canonical).  These functions, defined by
     TS 18661-1:2014 and TS 18661-3:2015, attempt to produce a canonical
     version of the floating-point value pointed to by X; if that value
     is a signaling NaN, they raise the invalid exception and produce a
     quiet NaN. If a canonical value is produced, it is stored in the
     object pointed to by CX, and these functions return zero.
     Otherwise (if a canonical value could not be produced because the
     object pointed to by X is not a valid representation of any
     floating-point value), the object pointed to by CX is unchanged and
     a nonzero value is returned.

     Note that some formats have multiple encodings of a value which are
     all equally canonical; when such an encoding is used as an input to
     this function, any such encoding of the same value (or of the
     corresponding quiet NaN, if that value is a signaling NaN) may be
     produced as output.

 -- Function: double getpayload (const double *X)
 -- Function: float getpayloadf (const float *X)
 -- Function: long double getpayloadl (const long double *X)
 -- Function: _FloatN getpayloadfN (const _FloatN *X)
 -- Function: _FloatNx getpayloadfNx (const _FloatNx *X)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     IEEE 754 defines the “payload” of a NaN to be an integer value
     encoded in the representation of the NaN. Payloads are typically
     propagated from NaN inputs to the result of a floating-point
     operation.  These functions, defined by TS 18661-1:2014 and TS
     18661-3:2015, return the payload of the NaN pointed to by X
     (returned as a positive integer, or positive zero, represented as a
     floating-point number); if X is not a NaN, they return −1.  They
     raise no floating-point exceptions even for signaling NaNs.  (The
     return value of −1 for an argument that is not a NaN is specified
     in C23; the value was unspecified in TS 18661.)

 -- Function: int setpayload (double *X, double PAYLOAD)
 -- Function: int setpayloadf (float *X, float PAYLOAD)
 -- Function: int setpayloadl (long double *X, long double PAYLOAD)
 -- Function: int setpayloadfN (_FloatN *X, _FloatN PAYLOAD)
 -- Function: int setpayloadfNx (_FloatNx *X, _FloatNx PAYLOAD)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     These functions, defined by TS 18661-1:2014 and TS 18661-3:2015,
     set the object pointed to by X to a quiet NaN with payload PAYLOAD
     and a zero sign bit and return zero.  If PAYLOAD is not a
     positive-signed integer that is a valid payload for a quiet NaN of
     the given type, the object pointed to by X is set to positive zero
     and a nonzero value is returned.  They raise no floating-point
     exceptions.

 -- Function: int setpayloadsig (double *X, double PAYLOAD)
 -- Function: int setpayloadsigf (float *X, float PAYLOAD)
 -- Function: int setpayloadsigl (long double *X, long double PAYLOAD)
 -- Function: int setpayloadsigfN (_FloatN *X, _FloatN PAYLOAD)
 -- Function: int setpayloadsigfNx (_FloatNx *X, _FloatNx PAYLOAD)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     These functions, defined by TS 18661-1:2014 and TS 18661-3:2015,
     set the object pointed to by X to a signaling NaN with payload
     PAYLOAD and a zero sign bit and return zero.  If PAYLOAD is not a
     positive-signed integer that is a valid payload for a signaling NaN
     of the given type, the object pointed to by X is set to positive
     zero and a nonzero value is returned.  They raise no floating-point
     exceptions.


File: libc.info,  Node: FP Comparison Functions,  Next: Misc FP Arithmetic,  Prev: FP Bit Twiddling,  Up: Arithmetic Functions

20.8.6 Floating-Point Comparison Functions
------------------------------------------

The standard C comparison operators provoke exceptions when one or other
of the operands is NaN. For example,

     int v = a < 1.0;

will raise an exception if A is NaN. (This does _not_ happen with ‘==’
and ‘!=’; those merely return false and true, respectively, when NaN is
examined.)  Frequently this exception is undesirable.  ISO C99 therefore
defines comparison functions that do not raise exceptions when NaN is
examined.  All of the functions are implemented as macros which allow
their arguments to be of any floating-point type.  The macros are
guaranteed to evaluate their arguments only once.  TS 18661-1:2014 adds
such a macro for an equality comparison that _does_ raise an exception
for a NaN argument; it also adds functions that provide a total ordering
on all floating-point values, including NaNs, without raising any
exceptions even for signaling NaNs.

 -- Macro: int isgreater (_real-floating_ X, _real-floating_ Y)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     This macro determines whether the argument X is greater than Y.  It
     is equivalent to ‘(X) > (Y)’, but no exception is raised if X or Y
     are NaN.

 -- Macro: int isgreaterequal (_real-floating_ X, _real-floating_ Y)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     This macro determines whether the argument X is greater than or
     equal to Y.  It is equivalent to ‘(X) >= (Y)’, but no exception is
     raised if X or Y are NaN.

 -- Macro: int isless (_real-floating_ X, _real-floating_ Y)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     This macro determines whether the argument X is less than Y.  It is
     equivalent to ‘(X) < (Y)’, but no exception is raised if X or Y are
     NaN.

 -- Macro: int islessequal (_real-floating_ X, _real-floating_ Y)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     This macro determines whether the argument X is less than or equal
     to Y.  It is equivalent to ‘(X) <= (Y)’, but no exception is raised
     if X or Y are NaN.

 -- Macro: int islessgreater (_real-floating_ X, _real-floating_ Y)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     This macro determines whether the argument X is less or greater
     than Y.  It is equivalent to ‘(X) < (Y) || (X) > (Y)’ (although it
     only evaluates X and Y once), but no exception is raised if X or Y
     are NaN.

     This macro is not equivalent to ‘X != Y’, because that expression
     is true if X or Y are NaN.

 -- Macro: int isunordered (_real-floating_ X, _real-floating_ Y)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     This macro determines whether its arguments are unordered.  In
     other words, it is true if X or Y are NaN, and false otherwise.

 -- Macro: int iseqsig (_real-floating_ X, _real-floating_ Y)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     This macro determines whether its arguments are equal.  It is
     equivalent to ‘(X) == (Y)’, but it raises the invalid exception and
     sets ‘errno’ to ‘EDOM’ if either argument is a NaN.

 -- Function: int totalorder (const double *X, const double *Y)
 -- Function: int totalorderf (const float *X, const float *Y)
 -- Function: int totalorderl (const long double *X, const long double
          *Y)
 -- Function: int totalorderfN (const _FloatN *X, const _FloatN *Y)
 -- Function: int totalorderfNx (const _FloatNx *X, const _FloatNx *Y)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     These functions determine whether the total order relationship,
     defined in IEEE 754-2008, is true for ‘*X’ and ‘*Y’, returning
     nonzero if it is true and zero if it is false.  No exceptions are
     raised even for signaling NaNs.  The relationship is true if they
     are the same floating-point value (including sign for zero and
     NaNs, and payload for NaNs), or if ‘*X’ comes before ‘*Y’ in the
     following order: negative quiet NaNs, in order of decreasing
     payload; negative signaling NaNs, in order of decreasing payload;
     negative infinity; finite numbers, in ascending order, with
     negative zero before positive zero; positive infinity; positive
     signaling NaNs, in order of increasing payload; positive quiet
     NaNs, in order of increasing payload.

 -- Function: int totalordermag (const double *X, const double *Y)
 -- Function: int totalordermagf (const float *X, const float *Y)
 -- Function: int totalordermagl (const long double *X, const long
          double *Y)
 -- Function: int totalordermagfN (const _FloatN *X, const _FloatN *Y)
 -- Function: int totalordermagfNx (const _FloatNx *X, const _FloatNx
          *Y)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     These functions determine whether the total order relationship,
     defined in IEEE 754-2008, is true for the absolute values of ‘*X’
     and ‘*Y’, returning nonzero if it is true and zero if it is false.
     No exceptions are raised even for signaling NaNs.

   Not all machines provide hardware support for these operations.  On
machines that don't, the macros can be very slow.  Therefore, you should
not use these functions when NaN is not a concern.

   *NB:* There are no macros ‘isequal’ or ‘isunequal’.  They are
unnecessary, because the ‘==’ and ‘!=’ operators do _not_ throw an
exception if one or both of the operands are NaN.


File: libc.info,  Node: Misc FP Arithmetic,  Prev: FP Comparison Functions,  Up: Arithmetic Functions

20.8.7 Miscellaneous FP arithmetic functions
--------------------------------------------

The functions in this section perform miscellaneous but common
operations that are awkward to express with C operators.  On some
processors these functions can use special machine instructions to
perform these operations faster than the equivalent C code.

 -- Function: double fmin (double X, double Y)
 -- Function: float fminf (float X, float Y)
 -- Function: long double fminl (long double X, long double Y)
 -- Function: _FloatN fminfN (_FloatN X, _FloatN Y)
 -- Function: _FloatNx fminfNx (_FloatNx X, _FloatNx Y)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     The ‘fmin’ function returns the lesser of the two values X and Y.
     It is similar to the expression
          ((x) < (y) ? (x) : (y))
     except that X and Y are only evaluated once.

     If an argument is a quiet NaN, the other argument is returned.  If
     both arguments are NaN, or either is a signaling NaN, NaN is
     returned.

 -- Function: double fmax (double X, double Y)
 -- Function: float fmaxf (float X, float Y)
 -- Function: long double fmaxl (long double X, long double Y)
 -- Function: _FloatN fmaxfN (_FloatN X, _FloatN Y)
 -- Function: _FloatNx fmaxfNx (_FloatNx X, _FloatNx Y)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     The ‘fmax’ function returns the greater of the two values X and Y.

     If an argument is a quiet NaN, the other argument is returned.  If
     both arguments are NaN, or either is a signaling NaN, NaN is
     returned.

 -- Function: double fminimum (double X, double Y)
 -- Function: float fminimumf (float X, float Y)
 -- Function: long double fminimuml (long double X, long double Y)
 -- Function: _FloatN fminimumfN (_FloatN X, _FloatN Y)
 -- Function: _FloatNx fminimumfNx (_FloatNx X, _FloatNx Y)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     The ‘fminimum’ function returns the lesser of the two values X and
     Y.  Unlike ‘fmin’, if either argument is a NaN, NaN is returned.
     Positive zero is treated as greater than negative zero.

 -- Function: double fmaximum (double X, double Y)
 -- Function: float fmaximumf (float X, float Y)
 -- Function: long double fmaximuml (long double X, long double Y)
 -- Function: _FloatN fmaximumfN (_FloatN X, _FloatN Y)
 -- Function: _FloatNx fmaximumfNx (_FloatNx X, _FloatNx Y)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     The ‘fmaximum’ function returns the greater of the two values X and
     Y.  Unlike ‘fmax’, if either argument is a NaN, NaN is returned.
     Positive zero is treated as greater than negative zero.

 -- Function: double fminimum_num (double X, double Y)
 -- Function: float fminimum_numf (float X, float Y)
 -- Function: long double fminimum_numl (long double X, long double Y)
 -- Function: _FloatN fminimum_numfN (_FloatN X, _FloatN Y)
 -- Function: _FloatNx fminimum_numfNx (_FloatNx X, _FloatNx Y)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     The ‘fminimum_num’ function returns the lesser of the two values X
     and Y.  If one argument is a number and the other is a NaN, even a
     signaling NaN, the number is returned.  Positive zero is treated as
     greater than negative zero.

 -- Function: double fmaximum_num (double X, double Y)
 -- Function: float fmaximum_numf (float X, float Y)
 -- Function: long double fmaximum_numl (long double X, long double Y)
 -- Function: _FloatN fmaximum_numfN (_FloatN X, _FloatN Y)
 -- Function: _FloatNx fmaximum_numfNx (_FloatNx X, _FloatNx Y)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     The ‘fmaximum_num’ function returns the greater of the two values X
     and Y.  If one argument is a number and the other is a NaN, even a
     signaling NaN, the number is returned.  Positive zero is treated as
     greater than negative zero.

 -- Function: double fminmag (double X, double Y)
 -- Function: float fminmagf (float X, float Y)
 -- Function: long double fminmagl (long double X, long double Y)
 -- Function: _FloatN fminmagfN (_FloatN X, _FloatN Y)
 -- Function: _FloatNx fminmagfNx (_FloatNx X, _FloatNx Y)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     These functions, from TS 18661-1:2014 and TS 18661-3:2015, return
     whichever of the two values X and Y has the smaller absolute value.
     If both have the same absolute value, or either is NaN, they behave
     the same as the ‘fmin’ functions.

 -- Function: double fmaxmag (double X, double Y)
 -- Function: float fmaxmagf (float X, float Y)
 -- Function: long double fmaxmagl (long double X, long double Y)
 -- Function: _FloatN fmaxmagfN (_FloatN X, _FloatN Y)
 -- Function: _FloatNx fmaxmagfNx (_FloatNx X, _FloatNx Y)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     These functions, from TS 18661-1:2014, return whichever of the two
     values X and Y has the greater absolute value.  If both have the
     same absolute value, or either is NaN, they behave the same as the
     ‘fmax’ functions.

 -- Function: double fminimum_mag (double X, double Y)
 -- Function: float fminimum_magf (float X, float Y)
 -- Function: long double fminimum_magl (long double X, long double Y)
 -- Function: _FloatN fminimum_magfN (_FloatN X, _FloatN Y)
 -- Function: _FloatNx fminimum_magfNx (_FloatNx X, _FloatNx Y)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     These functions return whichever of the two values X and Y has the
     smaller absolute value.  If both have the same absolute value, or
     either is NaN, they behave the same as the ‘fminimum’ functions.

 -- Function: double fmaximum_mag (double X, double Y)
 -- Function: float fmaximum_magf (float X, float Y)
 -- Function: long double fmaximum_magl (long double X, long double Y)
 -- Function: _FloatN fmaximum_magfN (_FloatN X, _FloatN Y)
 -- Function: _FloatNx fmaximum_magfNx (_FloatNx X, _FloatNx Y)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     These functions return whichever of the two values X and Y has the
     greater absolute value.  If both have the same absolute value, or
     either is NaN, they behave the same as the ‘fmaximum’ functions.

 -- Function: double fminimum_mag_num (double X, double Y)
 -- Function: float fminimum_mag_numf (float X, float Y)
 -- Function: long double fminimum_mag_numl (long double X, long double
          Y)
 -- Function: _FloatN fminimum_mag_numfN (_FloatN X, _FloatN Y)
 -- Function: _FloatNx fminimum_mag_numfNx (_FloatNx X, _FloatNx Y)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     These functions return whichever of the two values X and Y has the
     smaller absolute value.  If both have the same absolute value, or
     either is NaN, they behave the same as the ‘fminimum_num’
     functions.

 -- Function: double fmaximum_mag_num (double X, double Y)
 -- Function: float fmaximum_mag_numf (float X, float Y)
 -- Function: long double fmaximum_mag_numl (long double X, long double
          Y)
 -- Function: _FloatN fmaximum_mag_numfN (_FloatN X, _FloatN Y)
 -- Function: _FloatNx fmaximum_mag_numfNx (_FloatNx X, _FloatNx Y)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     These functions return whichever of the two values X and Y has the
     greater absolute value.  If both have the same absolute value, or
     either is NaN, they behave the same as the ‘fmaximum_num’
     functions.

 -- Function: double fdim (double X, double Y)
 -- Function: float fdimf (float X, float Y)
 -- Function: long double fdiml (long double X, long double Y)
 -- Function: _FloatN fdimfN (_FloatN X, _FloatN Y)
 -- Function: _FloatNx fdimfNx (_FloatNx X, _FloatNx Y)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     The ‘fdim’ function returns the positive difference between X and
     Y.  The positive difference is X - Y if X is greater than Y, and 0
     otherwise.

     If X, Y, or both are NaN, NaN is returned.

 -- Function: double fma (double X, double Y, double Z)
 -- Function: float fmaf (float X, float Y, float Z)
 -- Function: long double fmal (long double X, long double Y, long
          double Z)
 -- Function: _FloatN fmafN (_FloatN X, _FloatN Y, _FloatN Z)
 -- Function: _FloatNx fmafNx (_FloatNx X, _FloatNx Y, _FloatNx Z)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     The ‘fma’ function performs floating-point multiply-add.  This is
     the operation (X * Y) + Z, but the intermediate result is not
     rounded to the destination type.  This can sometimes improve the
     precision of a calculation.

     This function was introduced because some processors have a special
     instruction to perform multiply-add.  The C compiler cannot use it
     directly, because the expression ‘x*y + z’ is defined to round the
     intermediate result.  ‘fma’ lets you choose when you want to round
     only once.

     On processors which do not implement multiply-add in hardware,
     ‘fma’ can be very slow since it must avoid intermediate rounding.
     ‘math.h’ defines the symbols ‘FP_FAST_FMA’, ‘FP_FAST_FMAF’, and
     ‘FP_FAST_FMAL’ when the corresponding version of ‘fma’ is no slower
     than the expression ‘x*y + z’.  In the GNU C Library, this always
     means the operation is implemented in hardware.

 -- Function: float fadd (double X, double Y)
 -- Function: float faddl (long double X, long double Y)
 -- Function: double daddl (long double X, long double Y)
 -- Function: _FloatM fMaddfN (_FloatN X, _FloatN Y)
 -- Function: _FloatM fMaddfNx (_FloatNx X, _FloatNx Y)
 -- Function: _FloatMx fMxaddfN (_FloatN X, _FloatN Y)
 -- Function: _FloatMx fMxaddfNx (_FloatNx X, _FloatNx Y)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     These functions, from TS 18661-1:2014 and TS 18661-3:2015, return X
     + Y, rounded once to the return type of the function without any
     intermediate rounding to the type of the arguments.

 -- Function: float fsub (double X, double Y)
 -- Function: float fsubl (long double X, long double Y)
 -- Function: double dsubl (long double X, long double Y)
 -- Function: _FloatM fMsubfN (_FloatN X, _FloatN Y)
 -- Function: _FloatM fMsubfNx (_FloatNx X, _FloatNx Y)
 -- Function: _FloatMx fMxsubfN (_FloatN X, _FloatN Y)
 -- Function: _FloatMx fMxsubfNx (_FloatNx X, _FloatNx Y)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     These functions, from TS 18661-1:2014 and TS 18661-3:2015, return X
     - Y, rounded once to the return type of the function without any
     intermediate rounding to the type of the arguments.

 -- Function: float fmul (double X, double Y)
 -- Function: float fmull (long double X, long double Y)
 -- Function: double dmull (long double X, long double Y)
 -- Function: _FloatM fMmulfN (_FloatN X, _FloatN Y)
 -- Function: _FloatM fMmulfNx (_FloatNx X, _FloatNx Y)
 -- Function: _FloatMx fMxmulfN (_FloatN X, _FloatN Y)
 -- Function: _FloatMx fMxmulfNx (_FloatNx X, _FloatNx Y)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     These functions, from TS 18661-1:2014 and TS 18661-3:2015, return X
     * Y, rounded once to the return type of the function without any
     intermediate rounding to the type of the arguments.

 -- Function: float fdiv (double X, double Y)
 -- Function: float fdivl (long double X, long double Y)
 -- Function: double ddivl (long double X, long double Y)
 -- Function: _FloatM fMdivfN (_FloatN X, _FloatN Y)
 -- Function: _FloatM fMdivfNx (_FloatNx X, _FloatNx Y)
 -- Function: _FloatMx fMxdivfN (_FloatN X, _FloatN Y)
 -- Function: _FloatMx fMxdivfNx (_FloatNx X, _FloatNx Y)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     These functions, from TS 18661-1:2014 and TS 18661-3:2015, return X
     / Y, rounded once to the return type of the function without any
     intermediate rounding to the type of the arguments.

 -- Function: float fsqrt (double X)
 -- Function: float fsqrtl (long double X)
 -- Function: double dsqrtl (long double X)
 -- Function: _FloatM fMsqrtfN (_FloatN X)
 -- Function: _FloatM fMsqrtfNx (_FloatNx X)
 -- Function: _FloatMx fMxsqrtfN (_FloatN X)
 -- Function: _FloatMx fMxsqrtfNx (_FloatNx X)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     These functions, from TS 18661-1:2014 and TS 18661-3:2015, return
     the square root of X, rounded once to the return type of the
     function without any intermediate rounding to the type of the
     arguments.

 -- Function: float ffma (double X, double Y, double Z)
 -- Function: float ffmal (long double X, long double Y, long double Z)
 -- Function: double dfmal (long double X, long double Y, long double Z)
 -- Function: _FloatM fMfmafN (_FloatN X, _FloatN Y, _FloatN Z)
 -- Function: _FloatM fMfmafNx (_FloatNx X, _FloatNx Y, _FloatNx Z)
 -- Function: _FloatMx fMxfmafN (_FloatN X, _FloatN Y, _FloatN Z)
 -- Function: _FloatMx fMxfmafNx (_FloatNx X, _FloatNx Y, _FloatNx Z)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     These functions, from TS 18661-1:2014 and TS 18661-3:2015, return
     (X * Y) + Z, rounded once to the return type of the function
     without any intermediate rounding to the type of the arguments and
     without any intermediate rounding of result of the multiplication.


File: libc.info,  Node: Complex Numbers,  Next: Operations on Complex,  Prev: Arithmetic Functions,  Up: Arithmetic

20.9 Complex Numbers
====================

ISO C99 introduces support for complex numbers in C. This is done with a
new type qualifier, ‘complex’.  It is a keyword if and only if
‘complex.h’ has been included.  There are three complex types,
corresponding to the three real types: ‘float complex’, ‘double
complex’, and ‘long double complex’.

   Likewise, on machines that have support for ‘_FloatN’ or ‘_FloatNx’
enabled, the complex types ‘_FloatN complex’ and ‘_FloatNx complex’ are
also available if ‘complex.h’ has been included; *note Mathematics::.

   To construct complex numbers you need a way to indicate the imaginary
part of a number.  There is no standard notation for an imaginary
floating point constant.  Instead, ‘complex.h’ defines two macros that
can be used to create complex numbers.

 -- Macro: const float complex _Complex_I

     This macro is a representation of the complex number "0+1i".
     Multiplying a real floating-point value by ‘_Complex_I’ gives a
     complex number whose value is purely imaginary.  You can use this
     to construct complex constants:

          3.0 + 4.0i = 3.0 + 4.0 * _Complex_I

     Note that ‘_Complex_I * _Complex_I’ has the value ‘-1’, but the
     type of that value is ‘complex’.

‘_Complex_I’ is a bit of a mouthful.  ‘complex.h’ also defines a shorter
name for the same constant.

 -- Macro: const float complex I

     This macro has exactly the same value as ‘_Complex_I’.  Most of the
     time it is preferable.  However, it causes problems if you want to
     use the identifier ‘I’ for something else.  You can safely write

          #include <complex.h>
          #undef I

     if you need ‘I’ for your own purposes.  (In that case we recommend
     you also define some other short name for ‘_Complex_I’, such as
     ‘J’.)


File: libc.info,  Node: Operations on Complex,  Next: Parsing of Numbers,  Prev: Complex Numbers,  Up: Arithmetic

20.10 Projections, Conjugates, and Decomposing of Complex Numbers
=================================================================

ISO C99 also defines functions that perform basic operations on complex
numbers, such as decomposition and conjugation.  The prototypes for all
these functions are in ‘complex.h’.  All functions are available in
three variants, one for each of the three complex types.

 -- Function: double creal (complex double Z)
 -- Function: float crealf (complex float Z)
 -- Function: long double creall (complex long double Z)
 -- Function: _FloatN crealfN (complex _FloatN Z)
 -- Function: _FloatNx crealfNx (complex _FloatNx Z)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     These functions return the real part of the complex number Z.

 -- Function: double cimag (complex double Z)
 -- Function: float cimagf (complex float Z)
 -- Function: long double cimagl (complex long double Z)
 -- Function: _FloatN cimagfN (complex _FloatN Z)
 -- Function: _FloatNx cimagfNx (complex _FloatNx Z)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     These functions return the imaginary part of the complex number Z.

 -- Function: complex double conj (complex double Z)
 -- Function: complex float conjf (complex float Z)
 -- Function: complex long double conjl (complex long double Z)
 -- Function: complex _FloatN conjfN (complex _FloatN Z)
 -- Function: complex _FloatNx conjfNx (complex _FloatNx Z)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     These functions return the conjugate value of the complex number Z.
     The conjugate of a complex number has the same real part and a
     negated imaginary part.  In other words, ‘conj(a + bi) = a + -bi’.

 -- Function: double carg (complex double Z)
 -- Function: float cargf (complex float Z)
 -- Function: long double cargl (complex long double Z)
 -- Function: _FloatN cargfN (complex _FloatN Z)
 -- Function: _FloatNx cargfNx (complex _FloatNx Z)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     These functions return the argument of the complex number Z.  The
     argument of a complex number is the angle in the complex plane
     between the positive real axis and a line passing through zero and
     the number.  This angle is measured in the usual fashion and ranges
     from -pi to pi.

     ‘carg’ has a branch cut along the negative real axis.

 -- Function: complex double cproj (complex double Z)
 -- Function: complex float cprojf (complex float Z)
 -- Function: complex long double cprojl (complex long double Z)
 -- Function: complex _FloatN cprojfN (complex _FloatN Z)
 -- Function: complex _FloatNx cprojfNx (complex _FloatNx Z)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     These functions return the projection of the complex value Z onto
     the Riemann sphere.  Values with an infinite imaginary part are
     projected to positive infinity on the real axis, even if the real
     part is NaN. If the real part is infinite, the result is equivalent
     to

          INFINITY + I * copysign (0.0, cimag (z))


File: libc.info,  Node: Parsing of Numbers,  Next: Printing of Floats,  Prev: Operations on Complex,  Up: Arithmetic

20.11 Parsing of Numbers
========================

This section describes functions for "reading" integer and
floating-point numbers from a string.  It may be more convenient in some
cases to use ‘sscanf’ or one of the related functions; see *note
Formatted Input::.  But often you can make a program more robust by
finding the tokens in the string by hand, then converting the numbers
one by one.

* Menu:

* Parsing of Integers::         Functions for conversion of integer values.
* Parsing of Floats::           Functions for conversion of floating-point
				 values.


File: libc.info,  Node: Parsing of Integers,  Next: Parsing of Floats,  Up: Parsing of Numbers

20.11.1 Parsing of Integers
---------------------------

The ‘str’ functions are declared in ‘stdlib.h’ and those beginning with
‘wcs’ are declared in ‘wchar.h’.  One might wonder about the use of
‘restrict’ in the prototypes of the functions in this section.  It is
seemingly useless but the ISO C standard uses it (for the functions
defined there) so we have to do it as well.

 -- Function: long int strtol (const char *restrict STRING, char
          **restrict TAILPTR, int BASE)

     Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
     Safety Concepts::.

     The ‘strtol’ ("string-to-long") function converts the initial part
     of STRING to a signed integer, which is returned as a value of type
     ‘long int’.

     This function attempts to decompose STRING as follows:

        • A (possibly empty) sequence of whitespace characters.  Which
          characters are whitespace is determined by the ‘isspace’
          function (*note Classification of Characters::).  These are
          discarded.

        • An optional plus or minus sign (‘+’ or ‘-’).

        • A nonempty sequence of digits in the radix specified by BASE.

          If BASE is zero, decimal radix is assumed unless the series of
          digits begins with ‘0’ (specifying octal radix), or ‘0x’ or
          ‘0X’ (specifying hexadecimal radix), or ‘0b’ or ‘0B’
          (specifying binary radix; only supported when C23 features are
          enabled); in other words, the same syntax used for integer
          constants in C.

          Otherwise BASE must have a value between ‘2’ and ‘36’.  If
          BASE is ‘16’, the digits may optionally be preceded by ‘0x’ or
          ‘0X’.  If BASE is ‘2’, and C23 features are enabled, the
          digits may optionally be preceded by ‘0b’ or ‘0B’.  If base
          has no legal value the value returned is ‘0l’ and the global
          variable ‘errno’ is set to ‘EINVAL’.

        • Any remaining characters in the string.  If TAILPTR is not a
          null pointer, ‘strtol’ stores a pointer to this tail in
          ‘*TAILPTR’.

     If the string is empty, contains only whitespace, or does not
     contain an initial substring that has the expected syntax for an
     integer in the specified BASE, no conversion is performed.  In this
     case, ‘strtol’ returns a value of zero and the value stored in
     ‘*TAILPTR’ is the value of STRING.

     In a locale other than the standard ‘"C"’ locale, this function may
     recognize additional implementation-dependent syntax.

     If the string has valid syntax for an integer but the value is not
     representable because of overflow, ‘strtol’ returns either
     ‘LONG_MAX’ or ‘LONG_MIN’ (*note Range of Type::), as appropriate
     for the sign of the value.  It also sets ‘errno’ to ‘ERANGE’ to
     indicate there was overflow.

     You should not check for errors by examining the return value of
     ‘strtol’, because the string might be a valid representation of
     ‘0l’, ‘LONG_MAX’, or ‘LONG_MIN’.  Instead, check whether TAILPTR
     points to what you expect after the number (e.g.  ‘'\0'’ if the
     string should end after the number).  You also need to clear
     ‘errno’ before the call and check it afterward, in case there was
     overflow.

     There is an example at the end of this section.

 -- Function: long int wcstol (const wchar_t *restrict STRING, wchar_t
          **restrict TAILPTR, int BASE)

     Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
     Safety Concepts::.

     The ‘wcstol’ function is equivalent to the ‘strtol’ function in
     nearly all aspects but handles wide character strings.

     The ‘wcstol’ function was introduced in Amendment 1 of ISO C90.

 -- Function: unsigned long int strtoul (const char *restrict STRING,
          char **restrict TAILPTR, int BASE)

     Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
     Safety Concepts::.

     The ‘strtoul’ ("string-to-unsigned-long") function is like ‘strtol’
     except it converts to an ‘unsigned long int’ value.  The syntax is
     the same as described above for ‘strtol’.  The value returned on
     overflow is ‘ULONG_MAX’ (*note Range of Type::).

     If STRING depicts a negative number, ‘strtoul’ acts the same as
     STRTOL but casts the result to an unsigned integer.  That means for
     example that ‘strtoul’ on ‘"-1"’ returns ‘ULONG_MAX’ and an input
     more negative than ‘LONG_MIN’ returns (‘ULONG_MAX’ + 1) / 2.

     ‘strtoul’ sets ‘errno’ to ‘EINVAL’ if BASE is out of range, or
     ‘ERANGE’ on overflow.

 -- Function: unsigned long int wcstoul (const wchar_t *restrict STRING,
          wchar_t **restrict TAILPTR, int BASE)

     Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
     Safety Concepts::.

     The ‘wcstoul’ function is equivalent to the ‘strtoul’ function in
     nearly all aspects but handles wide character strings.

     The ‘wcstoul’ function was introduced in Amendment 1 of ISO C90.

 -- Function: long long int strtoll (const char *restrict STRING, char
          **restrict TAILPTR, int BASE)

     Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
     Safety Concepts::.

     The ‘strtoll’ function is like ‘strtol’ except that it returns a
     ‘long long int’ value, and accepts numbers with a correspondingly
     larger range.

     If the string has valid syntax for an integer but the value is not
     representable because of overflow, ‘strtoll’ returns either
     ‘LLONG_MAX’ or ‘LLONG_MIN’ (*note Range of Type::), as appropriate
     for the sign of the value.  It also sets ‘errno’ to ‘ERANGE’ to
     indicate there was overflow.

     The ‘strtoll’ function was introduced in ISO C99.

 -- Function: long long int wcstoll (const wchar_t *restrict STRING,
          wchar_t **restrict TAILPTR, int BASE)

     Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
     Safety Concepts::.

     The ‘wcstoll’ function is equivalent to the ‘strtoll’ function in
     nearly all aspects but handles wide character strings.

     The ‘wcstoll’ function was introduced in Amendment 1 of ISO C90.

 -- Function: long long int strtoq (const char *restrict STRING, char
          **restrict TAILPTR, int BASE)

     Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
     Safety Concepts::.

     ‘strtoq’ ("string-to-quad-word") is the BSD name for ‘strtoll’.

 -- Function: long long int wcstoq (const wchar_t *restrict STRING,
          wchar_t **restrict TAILPTR, int BASE)

     Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
     Safety Concepts::.

     The ‘wcstoq’ function is equivalent to the ‘strtoq’ function in
     nearly all aspects but handles wide character strings.

     The ‘wcstoq’ function is a GNU extension.

 -- Function: unsigned long long int strtoull (const char *restrict
          STRING, char **restrict TAILPTR, int BASE)

     Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
     Safety Concepts::.

     The ‘strtoull’ function is related to ‘strtoll’ the same way
     ‘strtoul’ is related to ‘strtol’.

     The ‘strtoull’ function was introduced in ISO C99.

 -- Function: unsigned long long int wcstoull (const wchar_t *restrict
          STRING, wchar_t **restrict TAILPTR, int BASE)

     Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
     Safety Concepts::.

     The ‘wcstoull’ function is equivalent to the ‘strtoull’ function in
     nearly all aspects but handles wide character strings.

     The ‘wcstoull’ function was introduced in Amendment 1 of ISO C90.

 -- Function: unsigned long long int strtouq (const char *restrict
          STRING, char **restrict TAILPTR, int BASE)

     Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
     Safety Concepts::.

     ‘strtouq’ is the BSD name for ‘strtoull’.

 -- Function: unsigned long long int wcstouq (const wchar_t *restrict
          STRING, wchar_t **restrict TAILPTR, int BASE)

     Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
     Safety Concepts::.

     The ‘wcstouq’ function is equivalent to the ‘strtouq’ function in
     nearly all aspects but handles wide character strings.

     The ‘wcstouq’ function is a GNU extension.

 -- Function: intmax_t strtoimax (const char *restrict STRING, char
          **restrict TAILPTR, int BASE)

     Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
     Safety Concepts::.

     The ‘strtoimax’ function is like ‘strtol’ except that it returns a
     ‘intmax_t’ value, and accepts numbers of a corresponding range.

     If the string has valid syntax for an integer but the value is not
     representable because of overflow, ‘strtoimax’ returns either
     ‘INTMAX_MAX’ or ‘INTMAX_MIN’ (*note Integers::), as appropriate for
     the sign of the value.  It also sets ‘errno’ to ‘ERANGE’ to
     indicate there was overflow.

     See *note Integers:: for a description of the ‘intmax_t’ type.  The
     ‘strtoimax’ function was introduced in ISO C99.

 -- Function: intmax_t wcstoimax (const wchar_t *restrict STRING,
          wchar_t **restrict TAILPTR, int BASE)

     Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
     Safety Concepts::.

     The ‘wcstoimax’ function is equivalent to the ‘strtoimax’ function
     in nearly all aspects but handles wide character strings.

     The ‘wcstoimax’ function was introduced in ISO C99.

 -- Function: uintmax_t strtoumax (const char *restrict STRING, char
          **restrict TAILPTR, int BASE)

     Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
     Safety Concepts::.

     The ‘strtoumax’ function is related to ‘strtoimax’ the same way
     that ‘strtoul’ is related to ‘strtol’.

     See *note Integers:: for a description of the ‘intmax_t’ type.  The
     ‘strtoumax’ function was introduced in ISO C99.

 -- Function: uintmax_t wcstoumax (const wchar_t *restrict STRING,
          wchar_t **restrict TAILPTR, int BASE)

     Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
     Safety Concepts::.

     The ‘wcstoumax’ function is equivalent to the ‘strtoumax’ function
     in nearly all aspects but handles wide character strings.

     The ‘wcstoumax’ function was introduced in ISO C99.

 -- Function: long int atol (const char *STRING)

     Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
     Safety Concepts::.

     This function is similar to the ‘strtol’ function with a BASE
     argument of ‘10’, except that it need not detect overflow errors.
     The ‘atol’ function is provided mostly for compatibility with
     existing code; using ‘strtol’ is more robust.

 -- Function: int atoi (const char *STRING)

     Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
     Safety Concepts::.

     This function is like ‘atol’, except that it returns an ‘int’.  The
     ‘atoi’ function is also considered obsolete; use ‘strtol’ instead.

 -- Function: long long int atoll (const char *STRING)

     Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
     Safety Concepts::.

     This function is similar to ‘atol’, except it returns a ‘long long
     int’.

     The ‘atoll’ function was introduced in ISO C99.  It too is obsolete
     (despite having just been added); use ‘strtoll’ instead.

   All the functions mentioned in this section so far do not handle
alternative representations of characters as described in the locale
data.  Some locales specify thousands separator and the way they have to
be used which can help to make large numbers more readable.  To read
such numbers one has to use the ‘scanf’ functions with the ‘'’ flag.

   Here is a function which parses a string as a sequence of integers
and returns the sum of them:

     int
     sum_ints_from_string (char *string)
     {
       int sum = 0;

       while (1) {
         char *tail;
         int next;

         /* Skip whitespace by hand, to detect the end.  */
         while (isspace (*string)) string++;
         if (*string == 0)
           break;

         /* There is more nonwhitespace,  */
         /* so it ought to be another number.  */
         errno = 0;
         /* Parse it.  */
         next = strtol (string, &tail, 0);
         /* Add it in, if not overflow.  */
         if (errno)
           printf ("Overflow\n");
         else
           sum += next;
         /* Advance past it.  */
         string = tail;
       }

       return sum;
     }


File: libc.info,  Node: Parsing of Floats,  Prev: Parsing of Integers,  Up: Parsing of Numbers

20.11.2 Parsing of Floats
-------------------------

The ‘str’ functions are declared in ‘stdlib.h’ and those beginning with
‘wcs’ are declared in ‘wchar.h’.  One might wonder about the use of
‘restrict’ in the prototypes of the functions in this section.  It is
seemingly useless but the ISO C standard uses it (for the functions
defined there) so we have to do it as well.

 -- Function: double strtod (const char *restrict STRING, char
          **restrict TAILPTR)

     Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
     Safety Concepts::.

     The ‘strtod’ ("string-to-double") function converts the initial
     part of STRING to a floating-point number, which is returned as a
     value of type ‘double’.

     This function attempts to decompose STRING as follows:

        • A (possibly empty) sequence of whitespace characters.  Which
          characters are whitespace is determined by the ‘isspace’
          function (*note Classification of Characters::).  These are
          discarded.

        • An optional plus or minus sign (‘+’ or ‘-’).

        • A floating point number in decimal or hexadecimal format.  The
          decimal format is:

             − A nonempty sequence of digits optionally containing a
               decimal-point character--normally ‘.’, but it depends on
               the locale (*note General Numeric::).

             − An optional exponent part, consisting of a character ‘e’
               or ‘E’, an optional sign, and a sequence of digits.

          The hexadecimal format is as follows:

             − A 0x or 0X followed by a nonempty sequence of hexadecimal
               digits optionally containing a decimal-point
               character--normally ‘.’, but it depends on the locale
               (*note General Numeric::).

             − An optional binary-exponent part, consisting of a
               character ‘p’ or ‘P’, an optional sign, and a sequence of
               digits.

        • Any remaining characters in the string.  If TAILPTR is not a
          null pointer, a pointer to this tail of the string is stored
          in ‘*TAILPTR’.

     If the string is empty, contains only whitespace, or does not
     contain an initial substring that has the expected syntax for a
     floating-point number, no conversion is performed.  In this case,
     ‘strtod’ returns a value of zero and the value returned in
     ‘*TAILPTR’ is the value of STRING.

     In a locale other than the standard ‘"C"’ or ‘"POSIX"’ locales,
     this function may recognize additional locale-dependent syntax.

     If the string has valid syntax for a floating-point number but the
     value is outside the range of a ‘double’, ‘strtod’ will signal
     overflow or underflow as described in *note Math Error Reporting::.

     ‘strtod’ recognizes four special input strings.  The strings
     ‘"inf"’ and ‘"infinity"’ are converted to oo, or to the largest
     representable value if the floating-point format doesn't support
     infinities.  You can prepend a ‘"+"’ or ‘"-"’ to specify the sign.
     Case is ignored when scanning these strings.

     The strings ‘"nan"’ and ‘"nan(CHARS...)"’ are converted to NaN.
     Again, case is ignored.  If CHARS... are provided, they are used in
     some unspecified fashion to select a particular representation of
     NaN (there can be several).

     Since zero is a valid result as well as the value returned on
     error, you should check for errors in the same way as for ‘strtol’,
     by examining ‘errno’ and TAILPTR.

 -- Function: float strtof (const char *STRING, char **TAILPTR)
 -- Function: long double strtold (const char *STRING, char **TAILPTR)

     Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
     Safety Concepts::.

     These functions are analogous to ‘strtod’, but return ‘float’ and
     ‘long double’ values respectively.  They report errors in the same
     way as ‘strtod’.  ‘strtof’ can be substantially faster than
     ‘strtod’, but has less precision; conversely, ‘strtold’ can be much
     slower but has more precision (on systems where ‘long double’ is a
     separate type).

     These functions have been GNU extensions and are new to ISO C99.

 -- Function: _FloatN strtofN (const char *STRING, char **TAILPTR)
 -- Function: _FloatNx strtofNx (const char *STRING, char **TAILPTR)

     Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
     Safety Concepts::.

     These functions are like ‘strtod’, except for the return type.

     They were introduced in ISO/IEC TS 18661-3 and are available on
     machines that support the related types; *note Mathematics::.

 -- Function: double wcstod (const wchar_t *restrict STRING, wchar_t
          **restrict TAILPTR)
 -- Function: float wcstof (const wchar_t *STRING, wchar_t **TAILPTR)
 -- Function: long double wcstold (const wchar_t *STRING, wchar_t
          **TAILPTR)
 -- Function: _FloatN wcstofN (const wchar_t *STRING, wchar_t **TAILPTR)
 -- Function: _FloatNx wcstofNx (const wchar_t *STRING, wchar_t
          **TAILPTR)

     Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
     Safety Concepts::.

     The ‘wcstod’, ‘wcstof’, ‘wcstol’, ‘wcstofN’, and ‘wcstofNx’
     functions are equivalent in nearly all aspects to the ‘strtod’,
     ‘strtof’, ‘strtold’, ‘strtofN’, and ‘strtofNx’ functions, but they
     handle wide character strings.

     The ‘wcstod’ function was introduced in Amendment 1 of ISO C90.
     The ‘wcstof’ and ‘wcstold’ functions were introduced in ISO C99.

     The ‘wcstofN’ and ‘wcstofNx’ functions are not in any standard, but
     are added to provide completeness for the non-deprecated interface
     of wide character string to floating-point conversion functions.
     They are only available on machines that support the related types;
     *note Mathematics::.

 -- Function: double atof (const char *STRING)

     Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
     Safety Concepts::.

     This function is similar to the ‘strtod’ function, except that it
     need not detect overflow and underflow errors.  The ‘atof’ function
     is provided mostly for compatibility with existing code; using
     ‘strtod’ is more robust.

   The GNU C Library also provides ‘_l’ versions of these functions,
which take an additional argument, the locale to use in conversion.

   See also *note Parsing of Integers::.


File: libc.info,  Node: Printing of Floats,  Next: System V Number Conversion,  Prev: Parsing of Numbers,  Up: Arithmetic

20.12 Printing of Floats
========================

The ‘strfrom’ functions are declared in ‘stdlib.h’.

 -- Function: int strfromd (char *restrict STRING, size_t SIZE, const
          char *restrict FORMAT, double VALUE)
 -- Function: int strfromf (char *restrict STRING, size_t SIZE, const
          char *restrict FORMAT, float VALUE)
 -- Function: int strfroml (char *restrict STRING, size_t SIZE, const
          char *restrict FORMAT, long double VALUE)

     Preliminary: | MT-Safe locale | AS-Unsafe heap | AC-Unsafe mem |
     *Note POSIX Safety Concepts::.

     The functions ‘strfromd’ ("string-from-double"), ‘strfromf’
     ("string-from-float"), and ‘strfroml’ ("string-from-long-double")
     convert the floating-point number VALUE to a string of characters
     and stores them into the area pointed to by STRING.  The conversion
     writes at most SIZE characters and respects the format specified by
     FORMAT.

     The format string must start with the character ‘%’.  An optional
     precision follows, which starts with a period, ‘.’, and may be
     followed by a decimal integer, representing the precision.  If a
     decimal integer is not specified after the period, the precision is
     taken to be zero.  The character ‘*’ is not allowed.  Finally, the
     format string ends with one of the following conversion specifiers:
     ‘a’, ‘A’, ‘e’, ‘E’, ‘f’, ‘F’, ‘g’ or ‘G’ (*note Table of Output
     Conversions::).  Invalid format strings result in undefined
     behavior.

     These functions return the number of characters that would have
     been written to STRING had SIZE been sufficiently large, not
     counting the terminating null character.  Thus, the null-terminated
     output has been completely written if and only if the returned
     value is less than SIZE.

     These functions were introduced by ISO/IEC TS 18661-1.

 -- Function: int strfromfN (char *restrict STRING, size_t SIZE, const
          char *restrict FORMAT, _FloatN VALUE)
 -- Function: int strfromfNx (char *restrict STRING, size_t SIZE, const
          char *restrict FORMAT, _FloatNx VALUE)

     Preliminary: | MT-Safe locale | AS-Unsafe heap | AC-Unsafe mem |
     *Note POSIX Safety Concepts::.

     These functions are like ‘strfromd’, except for the type of
     ‘value’.

     They were introduced in ISO/IEC TS 18661-3 and are available on
     machines that support the related types; *note Mathematics::.


File: libc.info,  Node: System V Number Conversion,  Prev: Printing of Floats,  Up: Arithmetic

20.13 Old-fashioned System V number-to-string functions
=======================================================

The old System V C library provided three functions to convert numbers
to strings, with unusual and hard-to-use semantics.  The GNU C Library
also provides these functions and some natural extensions.

   These functions are only available in the GNU C Library and on
systems descended from AT&T Unix.  Therefore, unless these functions do
precisely what you need, it is better to use ‘sprintf’, which is
standard.

   All these functions are defined in ‘stdlib.h’.

 -- Function: char * ecvt (double VALUE, int NDIGIT, int *DECPT, int
          *NEG)

     Preliminary: | MT-Unsafe race:ecvt | AS-Unsafe | AC-Safe | *Note
     POSIX Safety Concepts::.

     The function ‘ecvt’ converts the floating-point number VALUE to a
     string with at most NDIGIT decimal digits.  The returned string
     contains no decimal point or sign.  The first digit of the string
     is non-zero (unless VALUE is actually zero) and the last digit is
     rounded to nearest.  ‘*DECPT’ is set to the index in the string of
     the first digit after the decimal point.  ‘*NEG’ is set to a
     nonzero value if VALUE is negative, zero otherwise.

     If NDIGIT decimal digits would exceed the precision of a ‘double’
     it is reduced to a system-specific value.

     The returned string is statically allocated and overwritten by each
     call to ‘ecvt’.

     If VALUE is zero, it is implementation defined whether ‘*DECPT’ is
     ‘0’ or ‘1’.

     For example: ‘ecvt (12.3, 5, &d, &n)’ returns ‘"12300"’ and sets D
     to ‘2’ and N to ‘0’.

 -- Function: char * fcvt (double VALUE, int NDIGIT, int *DECPT, int
          *NEG)

     Preliminary: | MT-Unsafe race:fcvt | AS-Unsafe heap | AC-Unsafe mem
     | *Note POSIX Safety Concepts::.

     The function ‘fcvt’ is like ‘ecvt’, but NDIGIT specifies the number
     of digits after the decimal point.  If NDIGIT is less than zero,
     VALUE is rounded to the NDIGIT+1'th place to the left of the
     decimal point.  For example, if NDIGIT is ‘-1’, VALUE will be
     rounded to the nearest 10.  If NDIGIT is negative and larger than
     the number of digits to the left of the decimal point in VALUE,
     VALUE will be rounded to one significant digit.

     If NDIGIT decimal digits would exceed the precision of a ‘double’
     it is reduced to a system-specific value.

     The returned string is statically allocated and overwritten by each
     call to ‘fcvt’.

 -- Function: char * gcvt (double VALUE, int NDIGIT, char *BUF)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     ‘gcvt’ is functionally equivalent to ‘sprintf(buf, "%*g", ndigit,
     value)’.  It is provided only for compatibility's sake.  It returns
     BUF.

     If NDIGIT decimal digits would exceed the precision of a ‘double’
     it is reduced to a system-specific value.

   As extensions, the GNU C Library provides versions of these three
functions that take ‘long double’ arguments.

 -- Function: char * qecvt (long double VALUE, int NDIGIT, int *DECPT,
          int *NEG)

     Preliminary: | MT-Unsafe race:qecvt | AS-Unsafe | AC-Safe | *Note
     POSIX Safety Concepts::.

     This function is equivalent to ‘ecvt’ except that it takes a ‘long
     double’ for the first parameter and that NDIGIT is restricted by
     the precision of a ‘long double’.

 -- Function: char * qfcvt (long double VALUE, int NDIGIT, int *DECPT,
          int *NEG)

     Preliminary: | MT-Unsafe race:qfcvt | AS-Unsafe heap | AC-Unsafe
     mem | *Note POSIX Safety Concepts::.

     This function is equivalent to ‘fcvt’ except that it takes a ‘long
     double’ for the first parameter and that NDIGIT is restricted by
     the precision of a ‘long double’.

 -- Function: char * qgcvt (long double VALUE, int NDIGIT, char *BUF)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     This function is equivalent to ‘gcvt’ except that it takes a ‘long
     double’ for the first parameter and that NDIGIT is restricted by
     the precision of a ‘long double’.

   The ‘ecvt’ and ‘fcvt’ functions, and their ‘long double’ equivalents,
all return a string located in a static buffer which is overwritten by
the next call to the function.  The GNU C Library provides another set
of extended functions which write the converted string into a
user-supplied buffer.  These have the conventional ‘_r’ suffix.

   ‘gcvt_r’ is not necessary, because ‘gcvt’ already uses a
user-supplied buffer.

 -- Function: int ecvt_r (double VALUE, int NDIGIT, int *DECPT, int
          *NEG, char *BUF, size_t LEN)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     The ‘ecvt_r’ function is the same as ‘ecvt’, except that it places
     its result into the user-specified buffer pointed to by BUF, with
     length LEN.  The return value is ‘-1’ in case of an error and zero
     otherwise.

     This function is a GNU extension.

 -- Function: int fcvt_r (double VALUE, int NDIGIT, int *DECPT, int
          *NEG, char *BUF, size_t LEN)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     The ‘fcvt_r’ function is the same as ‘fcvt’, except that it places
     its result into the user-specified buffer pointed to by BUF, with
     length LEN.  The return value is ‘-1’ in case of an error and zero
     otherwise.

     This function is a GNU extension.

 -- Function: int qecvt_r (long double VALUE, int NDIGIT, int *DECPT,
          int *NEG, char *BUF, size_t LEN)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     The ‘qecvt_r’ function is the same as ‘qecvt’, except that it
     places its result into the user-specified buffer pointed to by BUF,
     with length LEN.  The return value is ‘-1’ in case of an error and
     zero otherwise.

     This function is a GNU extension.

 -- Function: int qfcvt_r (long double VALUE, int NDIGIT, int *DECPT,
          int *NEG, char *BUF, size_t LEN)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     The ‘qfcvt_r’ function is the same as ‘qfcvt’, except that it
     places its result into the user-specified buffer pointed to by BUF,
     with length LEN.  The return value is ‘-1’ in case of an error and
     zero otherwise.

     This function is a GNU extension.


File: libc.info,  Node: Bit Manipulation,  Next: Date and Time,  Prev: Arithmetic,  Up: Top

21 Bit Manipulation
*******************

This chapter contains information about functions and macros for
determining the endianness of integer types and manipulating the bits of
unsigned integers.  These functions and macros are from ISO C23 and are
declared in the header file ‘stdbit.h’.

   The following macros describe the endianness of integer types.  They
have values that are integer constant expressions.

 -- Macro: __STDC_ENDIAN_LITTLE__
     This macro represents little-endian storage.

 -- Macro: __STDC_ENDIAN_BIG__
     This macro represents big-endian storage.

 -- Macro: __STDC_ENDIAN_NATIVE__
     This macro equals ‘__STDC_ENDIAN_LITTLE__’ if integer types are
     stored in memory in little-endian format, and equals
     ‘__STDC_ENDIAN_BIG__’ if integer types are stored in memory in
     big-endian format.

   The following functions manipulate the bits of unsigned integers.
Each function family has functions for the types ‘unsigned char’,
‘unsigned short’, ‘unsigned int’, ‘unsigned long int’ and ‘unsigned long
long int’.  In addition, there is a corresponding type-generic macro
(not listed below), named the same as the functions but without any
suffix such as ‘_uc’.  The type-generic macro can only be used with an
argument of an unsigned integer type with a width of 8, 16, 32 or 64
bits, or when using a compiler with support for
‘__builtin_stdc_bit_ceil’
(https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html), etc., built-in
functions such as GCC 14.1 or later any unsigned integer type those
built-in functions support.  In GCC 14.1 that includes support for
‘unsigned __int128’ and ‘unsigned _BitInt(N)’ if supported by the
target.

 -- Function: unsigned int stdc_leading_zeros_uc (unsigned char X)
 -- Function: unsigned int stdc_leading_zeros_us (unsigned short X)
 -- Function: unsigned int stdc_leading_zeros_ui (unsigned int X)
 -- Function: unsigned int stdc_leading_zeros_ul (unsigned long int X)
 -- Function: unsigned int stdc_leading_zeros_ull (unsigned long long
          int X)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     The ‘stdc_leading_zeros’ functions count the number of leading
     (most significant) zero bits in X, starting from the most
     significant bit of the argument type.  If X is zero, they return
     the width of X in bits.

 -- Function: unsigned int stdc_leading_ones_uc (unsigned char X)
 -- Function: unsigned int stdc_leading_ones_us (unsigned short X)
 -- Function: unsigned int stdc_leading_ones_ui (unsigned int X)
 -- Function: unsigned int stdc_leading_ones_ul (unsigned long int X)
 -- Function: unsigned int stdc_leading_ones_ull (unsigned long long int
          X)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     The ‘stdc_leading_ones’ functions count the number of leading (most
     significant) one bits in X, starting from the most significant bit
     of the argument type.

 -- Function: unsigned int stdc_trailing_zeros_uc (unsigned char X)
 -- Function: unsigned int stdc_trailing_zeros_us (unsigned short X)
 -- Function: unsigned int stdc_trailing_zeros_ui (unsigned int X)
 -- Function: unsigned int stdc_trailing_zeros_ul (unsigned long int X)
 -- Function: unsigned int stdc_trailing_zeros_ull (unsigned long long
          int X)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     The ‘stdc_trailing_zeros’ functions count the number of trailing
     (least significant) zero bits in X, starting from the least
     significant bit of the argument type.  If X is zero, they return
     the width of X in bits.

 -- Function: unsigned int stdc_trailing_ones_uc (unsigned char X)
 -- Function: unsigned int stdc_trailing_ones_us (unsigned short X)
 -- Function: unsigned int stdc_trailing_ones_ui (unsigned int X)
 -- Function: unsigned int stdc_trailing_ones_ul (unsigned long int X)
 -- Function: unsigned int stdc_trailing_ones_ull (unsigned long long
          int X)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     The ‘stdc_trailing_ones’ functions count the number of trailing
     (least significant) one bits in X, starting from the least
     significant bit of the argument type.

 -- Function: unsigned int stdc_first_leading_zero_uc (unsigned char X)
 -- Function: unsigned int stdc_first_leading_zero_us (unsigned short X)
 -- Function: unsigned int stdc_first_leading_zero_ui (unsigned int X)
 -- Function: unsigned int stdc_first_leading_zero_ul (unsigned long int
          X)
 -- Function: unsigned int stdc_first_leading_zero_ull (unsigned long
          long int X)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     The ‘stdc_first_leading_zero’ functions return the position of the
     most significant zero bit in X, counting from the most significant
     bit of X as 1, or zero if there is no zero bit in X.

 -- Function: unsigned int stdc_first_leading_one_uc (unsigned char X)
 -- Function: unsigned int stdc_first_leading_one_us (unsigned short X)
 -- Function: unsigned int stdc_first_leading_one_ui (unsigned int X)
 -- Function: unsigned int stdc_first_leading_one_ul (unsigned long int
          X)
 -- Function: unsigned int stdc_first_leading_one_ull (unsigned long
          long int X)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     The ‘stdc_first_leading_one’ functions return the position of the
     most significant one bit in X, counting from the most significant
     bit of X as 1, or zero if there is no one bit in X.

 -- Function: unsigned int stdc_first_trailing_zero_uc (unsigned char X)
 -- Function: unsigned int stdc_first_trailing_zero_us (unsigned short
          X)
 -- Function: unsigned int stdc_first_trailing_zero_ui (unsigned int X)
 -- Function: unsigned int stdc_first_trailing_zero_ul (unsigned long
          int X)
 -- Function: unsigned int stdc_first_trailing_zero_ull (unsigned long
          long int X)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     The ‘stdc_first_trailing_zero’ functions return the position of the
     least significant zero bit in X, counting from the least
     significant bit of X as 1, or zero if there is no zero bit in X.

 -- Function: unsigned int stdc_first_trailing_one_uc (unsigned char X)
 -- Function: unsigned int stdc_first_trailing_one_us (unsigned short X)
 -- Function: unsigned int stdc_first_trailing_one_ui (unsigned int X)
 -- Function: unsigned int stdc_first_trailing_one_ul (unsigned long int
          X)
 -- Function: unsigned int stdc_first_trailing_one_ull (unsigned long
          long int X)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     The ‘stdc_first_trailing_one’ functions return the position of the
     least significant one bit in X, counting from the least significant
     bit of X as 1, or zero if there is no one bit in X.

 -- Function: unsigned int stdc_count_zeros_uc (unsigned char X)
 -- Function: unsigned int stdc_count_zeros_us (unsigned short X)
 -- Function: unsigned int stdc_count_zeros_ui (unsigned int X)
 -- Function: unsigned int stdc_count_zeros_ul (unsigned long int X)
 -- Function: unsigned int stdc_count_zeros_ull (unsigned long long int
          X)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     The ‘stdc_count_zeros’ functions count the number of zero bits in
     X.

 -- Function: unsigned int stdc_count_ones_uc (unsigned char X)
 -- Function: unsigned int stdc_count_ones_us (unsigned short X)
 -- Function: unsigned int stdc_count_ones_ui (unsigned int X)
 -- Function: unsigned int stdc_count_ones_ul (unsigned long int X)
 -- Function: unsigned int stdc_count_ones_ull (unsigned long long int
          X)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     The ‘stdc_count_ones’ functions count the number of one bits in X.

 -- Function: _Bool stdc_has_single_bit_uc (unsigned char X)
 -- Function: _Bool stdc_has_single_bit_us (unsigned short X)
 -- Function: _Bool stdc_has_single_bit_ui (unsigned int X)
 -- Function: _Bool stdc_has_single_bit_ul (unsigned long int X)
 -- Function: _Bool stdc_has_single_bit_ull (unsigned long long int X)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     The ‘stdc_has_single_bit’ functions return whether X has exactly
     one bit set to one.

 -- Function: unsigned int stdc_bit_width_uc (unsigned char X)
 -- Function: unsigned int stdc_bit_width_us (unsigned short X)
 -- Function: unsigned int stdc_bit_width_ui (unsigned int X)
 -- Function: unsigned int stdc_bit_width_ul (unsigned long int X)
 -- Function: unsigned int stdc_bit_width_ull (unsigned long long int X)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     The ‘stdc_bit_width’ functions return the minimum number of bits
     needed to store X, not counting leading zero bits.  If X is zero,
     they return zero.

 -- Function: unsigned char stdc_bit_floor_uc (unsigned char X)
 -- Function: unsigned short stdc_bit_floor_us (unsigned short X)
 -- Function: unsigned int stdc_bit_floor_ui (unsigned int X)
 -- Function: unsigned long int stdc_bit_floor_ul (unsigned long int X)
 -- Function: unsigned long long int stdc_bit_floor_ull (unsigned long
          long int X)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     The ‘stdc_bit_floor’ functions return the largest integer power of
     two that is less than or equal to X.  If X is zero, they return
     zero.

 -- Function: unsigned char stdc_bit_ceil_uc (unsigned char X)
 -- Function: unsigned short stdc_bit_ceil_us (unsigned short X)
 -- Function: unsigned int stdc_bit_ceil_ui (unsigned int X)
 -- Function: unsigned long int stdc_bit_ceil_ul (unsigned long int X)
 -- Function: unsigned long long int stdc_bit_ceil_ull (unsigned long
          long int X)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     The ‘stdc_bit_ceil’ functions return the smallest integer power of
     two that is greater than or equal to X.  If this cannot be
     represented in the return type, they return zero.


File: libc.info,  Node: Date and Time,  Next: Resource Usage And Limitation,  Prev: Bit Manipulation,  Up: Top

22 Date and Time
****************

This chapter describes functions for manipulating dates and times,
including functions for determining what time it is and conversion
between different time representations.

* Menu:

* Time Basics::                 Concepts and definitions.
* Time Types::                  Data types to represent time.
* Calculating Elapsed Time::    How to calculate the length of an interval.
* Processor And CPU Time::      Time a program has spent executing.
* Calendar Time::               Manipulation of "real" dates and times.
* Setting an Alarm::            Sending a signal after a specified time.
* Sleeping::                    Waiting for a period of time.


File: libc.info,  Node: Time Basics,  Next: Time Types,  Up: Date and Time

22.1 Time Basics
================

Discussing time in a technical manual can be difficult because the word
"time" in English refers to lots of different things.  In this manual,
we use a rigorous terminology to avoid confusion, and the only thing we
use the simple word "time" for is to talk about the abstract concept.

   A “calendar time”, sometimes called "absolute time", is a point in
the Earth's time continuum, for example June 9, 2024, at 13:50:06.5
Coordinated Universal Time (UTC).  UTC, formerly called Greenwich Mean
Time, is the primary time standard on Earth, and is the basis for civil
time and time zones.

   We don't speak of a "date", because that is inherent in a calendar
time.

   An “interval” is a contiguous part of the time continuum between two
calendar times, for example the hour on June 9, 2024, between 13:00 and
14:00 UTC.

   An “elapsed time” is the length of an interval, for example, 35
minutes.  People sometimes sloppily use the word "interval" to refer to
the elapsed time of some interval.

   An “amount of time” is a sum of elapsed times, which need not be of
any specific intervals.  For example, the amount of time it takes to
read a book might be 9 hours, independently of when and in how many
sittings it is read.

   A “period” is the elapsed time of an interval between two events,
especially when they are part of a sequence of regularly repeating
events.

   A “simple calendar time” is a calendar time represented as an elapsed
time since a fixed, implementation-specific calendar time called the
“epoch”.  This representation is convenient for doing calculations on
calendar times, such as finding the elapsed time between two calendar
times.  Simple calendar times are independent of time zone; they
represent the same instant in time regardless of where on the globe the
computer is.

   POSIX says that simple calendar times do not include leap seconds,
but some (otherwise POSIX-conformant) systems can be configured to
include leap seconds in simple calendar times.

   A “broken-down time” is a calendar time represented by its components
in the Gregorian calendar: year, month, day, hour, minute, and second.
A broken-down time value is relative to a specific time zone, and so it
is also sometimes called a “local time”.  Broken-down times are most
useful for input and output, as they are easier for people to
understand, but more difficult to calculate with.

   A “time zone” is a single fixed offset from UTC, along with a “time
zone abbreviation” that is a string of characters that can include ASCII
alphanumerics, ‘+’, and ‘-’.  For example, the current time zone in
Japan is 9 hours ahead (east) of the Prime Meridian with abbreviation
"JST".

   A “time zone ruleset” maps each simple calendar time to a single time
zone.  For example, Paris's time zone ruleset might list over a dozen
time zones that Paris has experienced during its history.

   “CPU time” measures the amount of time that a single process has
actively used a CPU to perform computations.  It does not include the
time that process has spent waiting for external events.  The system
tracks the CPU time used by each process separately.

   “Processor time” measures the amount of time _any_ CPU has been in
use by _any_ process.  It is a basic system resource, since there's a
limit to how much can exist in any given interval (the elapsed time of
the interval times the number of CPUs in the computer)

   People often call this CPU time, but we reserve the latter term in
this manual for the definition above.


File: libc.info,  Node: Time Types,  Next: Calculating Elapsed Time,  Prev: Time Basics,  Up: Date and Time

22.2 Time Types
===============

ISO C and POSIX define several data types for representing elapsed
times, simple calendar times, and broken-down times.

 -- Data Type: clock_t

     ‘clock_t’ is used to measure processor and CPU time.  It may be an
     integer or a floating-point type.  Its values are counts of “clock
     ticks” since some arbitrary event in the past.  The number of clock
     ticks per second is system-specific.  *Note Processor And CPU
     Time::, for further detail.

 -- Data Type: time_t

     ‘time_t’ is the simplest data type used to represent simple
     calendar time.

     In ISO C, ‘time_t’ can be either an integer or a real floating
     type, and the meaning of ‘time_t’ values is not specified.  The
     only things a strictly conforming program can do with ‘time_t’
     values are: pass them to ‘difftime’ to get the elapsed time between
     two simple calendar times (*note Calculating Elapsed Time::), and
     pass them to the functions that convert them to broken-down time
     (*note Broken-down Time::).

     On POSIX-conformant systems, ‘time_t’ is an integer type and its
     values represent the number of seconds elapsed since the “POSIX
     Epoch”, which is January 1, 1970, at 00:00:00 Coordinated Universal
     Time (UTC).  The count of seconds ignores leap seconds.
     Additionally, POSIX.1-2024 added the requirement that ‘time_t’ be
     at least 64 bits wide.

     The GNU C Library additionally guarantees that ‘time_t’ is a signed
     type, and that all of its functions operate correctly on negative
     ‘time_t’ values, which are interpreted as times before the POSIX
     Epoch.  Functions like ‘localtime’ assume the Gregorian calendar
     and UTC even though this is historically inaccurate for dates
     before 1582, for times before 1960, and for timestamps after the
     Gregorian calendar and UTC will become obsolete.  The GNU C Library
     also supports leap seconds as an option, in which case ‘time_t’
     counts leap seconds instead of ignoring them.  Currently the
     ‘time_t’ type is 64 bits wide on all platforms supported by the GNU
     C Library, except that it is 32 bits wide on a few older platforms
     unless you define ‘_TIME_BITS’ to 64.  *Note Feature Test Macros::.

 -- Data Type: struct timespec

     ‘struct timespec’ represents a simple calendar time, or an elapsed
     time, with sub-second resolution.  It is declared in ‘time.h’ and
     has the following members:

     ‘time_t tv_sec’
          The number of whole seconds elapsed since the epoch (for a
          simple calendar time) or since some other starting point (for
          an elapsed time).

     ‘long int tv_nsec’
          The number of nanoseconds elapsed since the time given by the
          ‘tv_sec’ member.

          When ‘struct timespec’ values are produced by GNU C Library
          functions, the value in this field will always be greater than
          or equal to zero, and less than 1,000,000,000.  When ‘struct
          timespec’ values are supplied to GNU C Library functions, the
          value in this field must be in the same range.

 -- Data Type: struct timeval

     ‘struct timeval’ is an older type for representing a simple
     calendar time, or an elapsed time, with sub-second resolution.  It
     is almost the same as ‘struct timespec’, but provides only
     microsecond resolution.  It is declared in ‘sys/time.h’ and has the
     following members:

     ‘time_t tv_sec’
          The number of whole seconds elapsed since the epoch (for a
          simple calendar time) or since some other starting point (for
          an elapsed time).

     ‘long int tv_usec’
          The number of microseconds elapsed since the time given by the
          ‘tv_sec’ member.

          When ‘struct timeval’ values are produced by GNU C Library
          functions, the value in this field will always be greater than
          or equal to zero, and less than 1,000,000.  When ‘struct
          timeval’ values are supplied to GNU C Library functions, the
          value in this field must be in the same range.

 -- Data Type: struct tm

     This is the data type used to represent a broken-down time.  It has
     separate fields for year, month, day, and so on.  *Note Broken-down
     Time::, for further details.


File: libc.info,  Node: Calculating Elapsed Time,  Next: Processor And CPU Time,  Prev: Time Types,  Up: Date and Time

22.3 Calculating Elapsed Time
=============================

Often, one wishes to calculate an elapsed time as the difference between
two simple calendar times.  The GNU C Library provides only one function
for this purpose.

 -- Function: double difftime (time_t END, time_t BEGIN)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     The ‘difftime’ function returns the number of seconds of elapsed
     time from calendar time BEGIN to calendar time END, as a value of
     type ‘double’.

     On POSIX-conformant systems, the advantage of using ‘difftime (END,
     BEGIN)’ over ‘END - BEGIN’ is that it will not overflow even if END
     and BEGIN are so far apart that a simple subtraction would
     overflow.  However, if they are so far apart that a ‘double’ cannot
     exactly represent the difference, the result will be inexact.

     On other systems, ‘time_t’ values might be encoded in a way that
     prevents subtraction from working directly, and then ‘difftime’
     would be the only way to compute their difference.

   The GNU C Library does not provide any functions for computing the
difference between two values of type ‘struct timespec’ or
‘struct timeval’.  Here is one way to do this calculation by hand.  It
works even on peculiar operating systems where the ‘tv_sec’ member has
an unsigned type.

     #include <stdckdint.h>
     #include <time.h>

     /* Put into *R the difference between X and Y.
        Return true if overflow occurs, false otherwise. */

     bool
     timespec_subtract (struct timespec *r,
                        struct timespec x, struct timespec y)
     {
       /* Compute nanoseconds, setting BORROW to 1 or 0
          for propagation into seconds. */
       long int nsec_diff = x.tv_nsec - y.tv_nsec;
       bool borrow = nsec_diff < 0;
       r->tv_nsec = nsec_diff + 1000000000 * borrow;

       /* Compute seconds, returning true if this overflows. */
       bool v = ckd_sub (&r->tv_sec, x.tv_sec, y.tv_sec);
       return v ^ ckd_sub (&r->tv_sec, r->tv_sec, borrow);
     }


File: libc.info,  Node: Processor And CPU Time,  Next: Calendar Time,  Prev: Calculating Elapsed Time,  Up: Date and Time

22.4 Processor And CPU Time
===========================

If you're trying to optimize your program or measure its efficiency,
it's very useful to know how much processor time it uses.  For that,
calendar time and elapsed times are useless because a process may spend
time waiting for I/O or for other processes to use the CPU.  However,
you can get the information with the functions in this section.

   CPU time (*note Time Basics::) is represented by the data type
‘clock_t’, which is a number of “clock ticks”.  It gives the total
amount of time a process has actively used a CPU since some arbitrary
event.  On GNU systems, that event is the creation of the process.
While arbitrary in general, the event is always the same event for any
particular process, so you can always measure how much time on the CPU a
particular computation takes by examining the process' CPU time before
and after the computation.

 -- Macro: CLOCKS_PER_SEC

     The number of clock ticks per second.

   On GNU/Linux and GNU/Hurd systems, ‘clock_t’ is equivalent to ‘long
int’ and ‘CLOCKS_PER_SEC’ is an integer value.  But in other systems,
both ‘clock_t’ and the macro ‘CLOCKS_PER_SEC’ can be either integer or
floating-point types.  Converting CPU time values to ‘double’ can help
code be more portable no matter what the underlying representation is.

   Note that the clock can wrap around.  On a 32bit system with
‘CLOCKS_PER_SEC’ set to one million this function will return the same
value approximately every 72 minutes.

   For additional functions to examine a process' use of processor time,
and to control it, see *note Resource Usage And Limitation::.

* Menu:

* CPU Time::                    The ‘clock’ function.
* Processor Time::              The ‘times’ function.


File: libc.info,  Node: CPU Time,  Next: Processor Time,  Up: Processor And CPU Time

22.4.1 CPU Time Inquiry
-----------------------

To get a process' CPU time, you can use the ‘clock’ function.  This
facility is declared in the header file ‘time.h’.

   In typical usage, you call the ‘clock’ function at the beginning and
end of the interval you want to time, subtract the values, and then
divide by ‘CLOCKS_PER_SEC’ (the number of clock ticks per second) to get
processor time, like this:

     #include <time.h>

     clock_t start, end;
     double cpu_time_used;

     start = clock();
     ... /* Do the work. */
     end = clock();
     cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC;

   Do not use a single CPU time as an amount of time; it doesn't work
that way.  Either do a subtraction as shown above or query processor
time directly.  *Note Processor Time::.

   Different computers and operating systems vary wildly in how they
keep track of CPU time.  It's common for the internal processor clock to
have a resolution somewhere between a hundredth and millionth of a
second.

 -- Macro: int CLOCKS_PER_SEC

     The value of this macro is the number of clock ticks per second
     measured by the ‘clock’ function.  POSIX requires that this value
     be one million independent of the actual resolution.

 -- Function: clock_t clock (void)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     This function returns the calling process' current CPU time.  If
     the CPU time is not available or cannot be represented, ‘clock’
     returns the value ‘(clock_t)(-1)’.


File: libc.info,  Node: Processor Time,  Prev: CPU Time,  Up: Processor And CPU Time

22.4.2 Processor Time Inquiry
-----------------------------

The ‘times’ function returns information about a process' consumption of
processor time in a ‘struct tms’ object, in addition to the process' CPU
time.  *Note Time Basics::.  You should include the header file
‘sys/times.h’ to use this facility.

 -- Data Type: struct tms

     The ‘tms’ structure is used to return information about process
     times.  It contains at least the following members:

     ‘clock_t tms_utime’
          This is the total processor time the calling process has used
          in executing the instructions of its program.

     ‘clock_t tms_stime’
          This is the processor time the system has used on behalf of
          the calling process.

     ‘clock_t tms_cutime’
          This is the sum of the ‘tms_utime’ values and the ‘tms_cutime’
          values of all terminated child processes of the calling
          process, whose status has been reported to the parent process
          by ‘wait’ or ‘waitpid’; see *note Process Completion::.  In
          other words, it represents the total processor time used in
          executing the instructions of all the terminated child
          processes of the calling process, excluding child processes
          which have not yet been reported by ‘wait’ or ‘waitpid’.

     ‘clock_t tms_cstime’
          This is similar to ‘tms_cutime’, but represents the total
          processor time the system has used on behalf of all the
          terminated child processes of the calling process.

     All of the times are given in numbers of clock ticks.  Unlike CPU
     time, these are the actual amounts of time; not relative to any
     event.  *Note Creating a Process::.

 -- Macro: int CLK_TCK

     This is an obsolete name for the number of clock ticks per second.
     Use ‘sysconf (_SC_CLK_TCK)’ instead.

 -- Function: clock_t times (struct tms *BUFFER)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     The ‘times’ function stores the processor time information for the
     calling process in BUFFER.

     The return value is the number of clock ticks since an arbitrary
     point in the past, e.g.  since system start-up.  ‘times’ returns
     ‘(clock_t)(-1)’ to indicate failure.

   *Portability Note:* The ‘clock’ function described in *note CPU
Time:: is specified by the ISO C standard.  The ‘times’ function is a
feature of POSIX.1.  On GNU systems, the CPU time is defined to be
equivalent to the sum of the ‘tms_utime’ and ‘tms_stime’ fields returned
by ‘times’.


File: libc.info,  Node: Calendar Time,  Next: Setting an Alarm,  Prev: Processor And CPU Time,  Up: Date and Time

22.5 Calendar Time
==================

This section describes the functions for getting, setting, and
manipulating calendar times.

* Menu:

* Getting the Time::            Functions for finding out what time it is.
* Setting and Adjusting the Time::
                                Functions for setting and adjusting
                                  the system clock.
* Broken-down Time::            Facilities for manipulating local time.
* Formatting Calendar Time::    Converting times to strings.
* Parsing Date and Time::       Convert textual time and date information back
                                 into broken-down time values.
* TZ Variable::                 How users specify the time zone ruleset.
* Time Zone State::             Time zone state variables.
* Time Functions Example::      An example program showing use of some of
				 the time functions.


File: libc.info,  Node: Getting the Time,  Next: Setting and Adjusting the Time,  Up: Calendar Time

22.5.1 Getting the Time
-----------------------

The GNU C Library provides several functions for getting the current
calendar time, with different levels of resolution.

 -- Function: time_t time (time_t *RESULT)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     This is the simplest function for getting the current calendar
     time.  It returns the calendar time as a value of type ‘time_t’; on
     POSIX systems, that means it has a resolution of one second.  It
     uses the same clock as ‘clock_gettime (CLOCK_REALTIME_COARSE)’,
     when the clock is available or ‘clock_gettime (CLOCK_REALTIME)’
     otherwise.

     If the argument RESULT is not a null pointer, the calendar time
     value is also stored in ‘*RESULT’.

     This function cannot fail.

   Some applications need more precise timekeeping than is possible with
a ‘time_t’ alone.  Some applications also need more control over what is
meant by "the current time."  For these applications, POSIX and ISO C
provide functions to retrieve the time with up to nanosecond precision,
from a variety of different clocks.  Clocks can be system-wide,
measuring time the same for all processes; or they can be per-process or
per-thread, measuring CPU time consumed by a particular process, or some
other similar resource.  Each clock has its own resolution and epoch.
POSIX and ISO C also provide functions for finding the resolution of a
clock.  There is no function to get the epoch for a clock; either it is
fixed and documented, or the clock is not meant to be used to measure
absolute times.

 -- Data Type: clockid_t

     The type ‘clockid_t’ is used for constants that indicate which of
     several POSIX system clocks one wishes to use.

   All systems that support the POSIX functions will define at least
this clock constant:

 -- Macro: clockid_t CLOCK_REALTIME

     This POSIX clock uses the POSIX Epoch, 1970-01-01 00:00:00 UTC.  It
     is close to, but not necessarily in lock-step with, the clocks of
     ‘time’ (above) and of ‘gettimeofday’ (below).

   A second clock constant which is not universal, but still very
common, is for a clock measuring “monotonic time”.  Monotonic time is
useful for measuring elapsed times, because it guarantees that those
measurements are not affected by changes to the system clock.

 -- Macro: clockid_t CLOCK_MONOTONIC

     This system-wide POSIX clock continuously measures the advancement
     of calendar time, ignoring discontinuous changes to the system's
     setting for absolute calendar time.

     The epoch for this clock is an unspecified point in the past.  The
     epoch may change if the system is rebooted or suspended.
     Therefore, ‘CLOCK_MONOTONIC’ cannot be used to measure absolute
     time, only elapsed time.

   The following clocks are defined by POSIX, but may not be supported
by all POSIX systems:

 -- Macro: clockid_t CLOCK_PROCESS_CPUTIME_ID

     This POSIX clock measures the amount of CPU time used by the
     calling process.

 -- Macro: clockid_t CLOCK_THREAD_CPUTIME_ID

     This POSIX clock measures the amount of CPU time used by the
     calling thread.

   The following clocks are Linux extensions:

 -- Macro: clockid_t CLOCK_MONOTONIC_RAW
 -- Macro: clockid_t CLOCK_REALTIME_COARSE
 -- Macro: clockid_t CLOCK_MONOTONIC_COARSE
 -- Macro: clockid_t CLOCK_BOOTTIME
 -- Macro: clockid_t CLOCK_REALTIME_ALARM
 -- Macro: clockid_t CLOCK_BOOTTIME_ALARM
 -- Macro: clockid_t CLOCK_TAI

     For details of these clocks, see the manual page clock_gettime(2)
     (Latest, online:
     <https://man7.org/linux/man-pages/man2/clock_gettime.2.html>) *Note
     Linux Kernel::.

   Systems may support additional clocks beyond those listed here.

 -- Function: int clock_gettime (clockid_t CLOCK, struct timespec *TS)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     Get the current time according to the clock identified by CLOCK,
     storing it as seconds and nanoseconds in ‘*TS’.  *Note Time
     Types::, for a description of ‘struct timespec’.

     The return value is ‘0’ on success and ‘-1’ on failure.  The
     following ‘errno’ error condition is defined for this function:

     ‘EINVAL’
          The clock identified by CLOCK is not supported.

   ‘clock_gettime’ reports the time scaled to seconds and nanoseconds,
but the actual resolution of each clock may not be as fine as one
nanosecond, and may not be the same for all clocks.  POSIX also provides
a function for finding out the actual resolution of a clock:

 -- Function: int clock_getres (clockid_t CLOCK, struct timespec *RES)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     Get the actual resolution of the clock identified by CLOCK, storing
     it in ‘*TS’.

     For instance, if the clock hardware for ‘CLOCK_REALTIME’ uses a
     quartz crystal that oscillates at 32.768 kHz, then its resolution
     would be 30.518 microseconds, and
     ‘clock_getres (CLOCK_REALTIME, &r)’ would set ‘r.tv_sec’ to 0 and
     ‘r.tv_nsec’ to 30518.

     The return value is ‘0’ on success and ‘-1’ on failure.  The
     following ‘errno’ error condition is defined for this function:

     ‘EINVAL’
          The clock identified by CLOCK is not supported.

   *Portability Note:* On some systems, including systems that use older
versions of the GNU C Library, programs that use ‘clock_gettime’ or
‘clock_setres’ must be linked with the ‘-lrt’ library.  This has not
been necessary with the GNU C Library since version 2.17.

   The following ISO C macros and functions for higher-resolution
timestamps were standardized more recently than the POSIX functions, so
they are less portable to older POSIX systems.  However, the ISO C
functions are portable to C platforms that do not support POSIX.

 -- Macro: int TIME_UTC

     This is a positive integer constant designating a simple calendar
     time base.  In the GNU C Library and other POSIX systems, this is
     equivalent to the POSIX ‘CLOCK_REALTIME’ clock.  On non-POSIX
     systems, though, the epoch is implementation-defined.

   Systems may support more than just this ISO C clock.

 -- Function: int timespec_get (struct timespec *TS, int BASE)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     Store into ‘*TS’ the current time according to the ISO C time BASE.

     The return value is BASE on success and ‘0’ on failure.

 -- Function: int timespec_getres (struct timespec *RES, int BASE)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     If TS is non-null, store into ‘*TS’ the resolution of the time
     provided by ‘timespec_get’ function for the ISO C time BASE.

     The return value is BASE on success and ‘0’ on failure.

   The previous functions, data types and constants are declared in
‘time.h’.  The GNU C Library also provides an older function for getting
the current time with a resolution of microseconds.  This function is
declared in ‘sys/time.h’.

 -- Function: int gettimeofday (struct timeval *TP, void *TZP)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     Get the current calendar time, storing it as seconds and
     microseconds in ‘*TP’.  *Note Time Types::, for a description of
     ‘struct timeval’.  The clock of ‘gettimeofday’ is close to, but not
     necessarily in lock-step with, the clocks of ‘time’ and of
     ‘clock_gettime (CLOCK_REALTIME)’ (see above).

     On some historic systems, if TZP was not a null pointer,
     information about a system-wide time zone would be written to
     ‘*TZP’.  This feature is obsolete and not supported on GNU systems.
     You should always supply a null pointer for this argument.
     Instead, use the facilities described in *note Broken-down Time::
     for working with time zones.

     This function cannot fail, and its return value is always ‘0’.

     *Portability Note:* POSIX.1-2024 removed this function.  Although
     the GNU C Library will continue to provide it indefinitely,
     portable programs should use ‘clock_gettime’ or ‘timespec_get’
     instead.


File: libc.info,  Node: Setting and Adjusting the Time,  Next: Broken-down Time,  Prev: Getting the Time,  Up: Calendar Time

22.5.2 Setting and Adjusting the Time
-------------------------------------

The clock hardware inside a modern computer is quite reliable, but it
can still be wrong.  The functions in this section allow one to set the
system's idea of the current calendar time, and to adjust the rate at
which the system counts seconds, so that the calendar time will both be
accurate, and remain accurate.

   The functions in this section require special privileges to use.
*Note Users and Groups::.

 -- Function: int clock_settime (clockid_t CLOCK, const struct timespec
          *TS)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     Change the current calendar time, according to the clock identified
     by CLOCK, to be the simple calendar time in ‘*TS’.

     Not all of the system's clocks can be changed.  For instance, the
     ‘CLOCK_REALTIME’ clock can be changed (with the appropriate
     privileges), but the ‘CLOCK_MONOTONIC’ clock cannot.

     Because simple calendar times are independent of time zone, this
     function should not be used when the time zone changes (e.g. if the
     computer is physically moved from one zone to another).  Instead,
     use the facilities described in *note Time Zone State::.

     ‘clock_settime’ causes the clock to jump forwards or backwards,
     which can cause a variety of problems.  Changing the
     ‘CLOCK_REALTIME’ clock with ‘clock_settime’ does not affect when
     timers expire (*note Setting an Alarm::) or when sleeping processes
     wake up (*note Sleeping::), which avoids some of the problems.
     Still, for small changes made while the system is running, it is
     better to use ‘ntp_adjtime’ (below) to make a smooth transition
     from one time to another.

     The return value is ‘0’ on success and ‘-1’ on failure.  The
     following ‘errno’ error conditions are defined for this function:

     ‘EINVAL’
          The clock identified by CLOCK is not supported or cannot be
          set at all, or the simple calendar time in ‘*TS’ is invalid
          (for instance, ‘ts->tv_nsec’ is negative or greater than
          999,999,999).

     ‘EPERM’
          This process does not have the privileges required to set the
          clock identified by CLOCK.

     *Portability Note*: On some systems, including systems that use
     older versions of the GNU C Library, programs that use
     ‘clock_settime’ must be linked with the ‘-lrt’ library.  This has
     not been necessary with the GNU C Library since version 2.17.

   For systems that remain up and running for long periods, it is not
enough to set the time once; one should also “discipline” the clock so
that it does not drift away from the true calendar time.

   The ‘ntp_gettime’ and ‘ntp_adjtime’ functions provide an interface to
monitor and discipline the system clock.  For example, you can fine-tune
the rate at which the clock "ticks," and make small adjustments to the
current reported calendar time smoothly, by temporarily speeding up or
slowing down the clock.

   These functions' names begin with ‘ntp_’ because they were designed
for use by programs implementing the Network Time Protocol to
synchronize a system's clock with other systems' clocks and/or with
external high-precision clock hardware.

   These functions, and the constants and structures they use, are
declared in ‘sys/timex.h’.

 -- Data Type: struct ntptimeval
     This structure is used to report information about the system
     clock.  It contains the following members:
     ‘struct timeval time’
          The current calendar time, as if retrieved by ‘gettimeofday’.
          The ‘struct timeval’ data type is described in *note Time
          Types::.

     ‘long int maxerror’
          This is the maximum error, measured in microseconds.  Unless
          updated via ‘ntp_adjtime’ periodically, this value will reach
          some platform-specific maximum value.

     ‘long int esterror’
          This is the estimated error, measured in microseconds.  This
          value can be set by ‘ntp_adjtime’ to indicate the estimated
          offset of the system clock from the true calendar time.

 -- Function: int ntp_gettime (struct ntptimeval *TPTR)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     The ‘ntp_gettime’ function sets the structure pointed to by TPTR to
     current values.  The elements of the structure afterwards contain
     the values the timer implementation in the kernel assumes.  They
     might or might not be correct.  If they are not, an ‘ntp_adjtime’
     call is necessary.

     The return value is ‘0’ on success and other values on failure.
     The following ‘errno’ error conditions are defined for this
     function:

     ‘TIME_ERROR’
          The precision clock model is not properly set up at the
          moment, thus the clock must be considered unsynchronized, and
          the values should be treated with care.

 -- Data Type: struct timex
     This structure is used to control and monitor the system clock.  It
     contains the following members:
     ‘unsigned int modes’
          This variable controls whether and which values are set.
          Several symbolic constants have to be combined with _binary
          or_ to specify the effective mode.  These constants start with
          ‘MOD_’.

     ‘long int offset’
          This value indicates the current offset of the system clock
          from the true calendar time.  The value is given in
          microseconds.  If bit ‘MOD_OFFSET’ is set in ‘modes’, the
          offset (and possibly other dependent values) can be set.  The
          offset's absolute value must not exceed ‘MAXPHASE’.

     ‘long int frequency’
          This value indicates the difference in frequency between the
          true calendar time and the system clock.  The value is
          expressed as scaled PPM (parts per million, 0.0001%).  The
          scaling is ‘1 << SHIFT_USEC’.  The value can be set with bit
          ‘MOD_FREQUENCY’, but the absolute value must not exceed
          ‘MAXFREQ’.

     ‘long int maxerror’
          This is the maximum error, measured in microseconds.  A new
          value can be set using bit ‘MOD_MAXERROR’.  Unless updated via
          ‘ntp_adjtime’ periodically, this value will increase steadily
          and reach some platform-specific maximum value.

     ‘long int esterror’
          This is the estimated error, measured in microseconds.  This
          value can be set using bit ‘MOD_ESTERROR’.

     ‘int status’
          This variable reflects the various states of the clock
          machinery.  There are symbolic constants for the significant
          bits, starting with ‘STA_’.  Some of these flags can be
          updated using the ‘MOD_STATUS’ bit.

     ‘long int constant’
          This value represents the bandwidth or stiffness of the PLL
          (phase locked loop) implemented in the kernel.  The value can
          be changed using bit ‘MOD_TIMECONST’.

     ‘long int precision’
          This value represents the accuracy or the maximum error when
          reading the system clock.  The value is expressed in
          microseconds.

     ‘long int tolerance’
          This value represents the maximum frequency error of the
          system clock in scaled PPM.  This value is used to increase
          the ‘maxerror’ every second.

     ‘struct timeval time’
          The current calendar time.

     ‘long int tick’
          The elapsed time between clock ticks in microseconds.  A clock
          tick is a periodic timer interrupt on which the system clock
          is based.

     ‘long int ppsfreq’
          This is the first of a few optional variables that are present
          only if the system clock can use a PPS (pulse per second)
          signal to discipline the system clock.  The value is expressed
          in scaled PPM and it denotes the difference in frequency
          between the system clock and the PPS signal.

     ‘long int jitter’
          This value expresses a median filtered average of the PPS
          signal's dispersion in microseconds.

     ‘int shift’
          This value is a binary exponent for the duration of the PPS
          calibration interval, ranging from ‘PPS_SHIFT’ to
          ‘PPS_SHIFTMAX’.

     ‘long int stabil’
          This value represents the median filtered dispersion of the
          PPS frequency in scaled PPM.

     ‘long int jitcnt’
          This counter represents the number of pulses where the jitter
          exceeded the allowed maximum ‘MAXTIME’.

     ‘long int calcnt’
          This counter reflects the number of successful calibration
          intervals.

     ‘long int errcnt’
          This counter represents the number of calibration errors
          (caused by large offsets or jitter).

     ‘long int stbcnt’
          This counter denotes the number of calibrations where the
          stability exceeded the threshold.

 -- Function: int ntp_adjtime (struct timex *TPTR)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     The ‘ntp_adjtime’ function sets the structure specified by TPTR to
     current values.

     In addition, ‘ntp_adjtime’ updates some settings to match what you
     pass to it in ‘*TPTR’.  Use the ‘modes’ element of ‘*TPTR’ to
     select what settings to update.  You can set ‘offset’, ‘freq’,
     ‘maxerror’, ‘esterror’, ‘status’, ‘constant’, and ‘tick’.

     ‘modes’ = zero means set nothing.

     Only the superuser can update settings.

     The return value is ‘0’ on success and other values on failure.
     The following ‘errno’ error conditions are defined for this
     function:

     ‘TIME_ERROR’
          The high accuracy clock model is not properly set up at the
          moment, thus the clock must be considered unsynchronized, and
          the values should be treated with care.  Another reason could
          be that the specified new values are not allowed.

     ‘EPERM’
          The process specified a settings update, but is not superuser.

     For more details see RFC 5905 (Network Time Protocol, Version 4)
     and related documents.

     *Portability note:* Early versions of the GNU C Library did not
     have this function, but did have the synonymous ‘adjtimex’.

 -- Function: int adjtime (const struct timeval *DELTA, struct timeval
          *OLDDELTA)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     This simpler version of ‘ntp_adjtime’ speeds up or slows down the
     system clock for a short time, in order to correct it by a small
     amount.  This avoids a discontinuous change in the calendar time
     reported by the ‘CLOCK_REALTIME’ clock, at the price of having to
     wait longer for the time to become correct.

     The DELTA argument specifies a relative adjustment to be made to
     the clock time.  If negative, the system clock is slowed down for a
     while until it has lost this much elapsed time.  If positive, the
     system clock is sped up for a while.

     If the OLDDELTA argument is not a null pointer, the ‘adjtime’
     function returns information about any previous time adjustment
     that has not yet completed.

     The return value is ‘0’ on success and ‘-1’ on failure.  The
     following ‘errno’ error condition is defined for this function:

     ‘EPERM’
          This process does not have the privileges required to adjust
          the ‘CLOCK_REALTIME’ clock.

   For compatibility, the GNU C Library also provides several older
functions for controlling the system time.  New programs should prefer
to use the functions above.

 -- Function: int stime (const time_t *NEWTIME)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     Change the ‘CLOCK_REALTIME’ calendar time to be the simple calendar
     time in ‘*NEWTIME’.  Calling this function is exactly the same as
     calling ‘clock_settime (CLOCK_REALTIME)’, except that the new time
     can only be set to a precision of one second.

     This function is no longer available on GNU systems, but it may be
     the _only_ way to set the time on very old Unix systems, so we
     continue to document it.  If it is available, it is declared in
     ‘time.h’.

     The return value is ‘0’ on success and ‘-1’ on failure.  The
     following ‘errno’ error condition is defined for this function:

     ‘EPERM’
          This process does not have the privileges required to adjust
          the ‘CLOCK_REALTIME’ clock.

 -- Function: int adjtimex (struct timex *TIMEX)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     ‘adjtimex’ is an older name for ‘ntp_adjtime’.  This function is
     only available on GNU/Linux systems.  It is declared in
     ‘sys/timex.h’.

 -- Function: int settimeofday (const struct timeval *TP, const void
          *TZP)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     Change the ‘CLOCK_REALTIME’ calendar time to be the simple calendar
     time in ‘*NEWTIME’.  This function is declared in ‘sys/time.h’.

     When TZP is a null pointer, calling this function is exactly the
     same as calling ‘clock_settime (CLOCK_REALTIME)’, except that the
     new time can only be set to a precision of one microsecond.

     When TZP is not a null pointer, the data it points to _may_ be used
     to set a system-wide idea of the current time zone.  This feature
     is obsolete and not supported on GNU systems.  Instead, use the
     facilities described in *note Time Zone State:: and in *note
     Broken-down Time:: for working with time zones.

     The return value is ‘0’ on success and ‘-1’ on failure.  The
     following ‘errno’ error conditions are defined for this function:

     ‘EPERM’
          This process does not have the privileges required to set the
          ‘CLOCK_REALTIME’ clock.

     ‘EINVAL’
          Neither TP nor TZP is a null pointer.  (For historical
          reasons, it is not possible to set the current time and the
          current time zone in the same call.)

     ‘ENOSYS’
          The operating system does not support setting time zone
          information, and TZP is not a null pointer.


File: libc.info,  Node: Broken-down Time,  Next: Formatting Calendar Time,  Prev: Setting and Adjusting the Time,  Up: Calendar Time

22.5.3 Broken-down Time
-----------------------

Simple calendar times represent absolute times as elapsed times since an
epoch.  This is convenient for computation, but has no relation to the
way people normally think of calendar time.  By contrast, “broken-down
time” is a binary representation of calendar time separated into year,
month, day, and so on.  Although broken-down time values are painful to
calculate with, they are useful for printing human readable time
information.

   A broken-down time value is always relative to a choice of time zone,
and it also indicates which time zone that is.

   The symbols in this section are declared in the header file ‘time.h’.

 -- Data Type: struct tm

     This is the data type used to represent a broken-down time.  The
     structure contains at least the following members, which can appear
     in any order.

     ‘int tm_sec’
          This is the number of full seconds since the top of the minute
          (normally in the range ‘0’ through ‘59’, but the actual upper
          limit is ‘60’, to allow for leap seconds if leap second
          support is available).

     ‘int tm_min’
          This is the number of full minutes since the top of the hour
          (in the range ‘0’ through ‘59’).

     ‘int tm_hour’
          This is the number of full hours past midnight (in the range
          ‘0’ through ‘23’).

     ‘int tm_mday’
          This is the ordinal day of the month (in the range ‘1’ through
          ‘31’).  Watch out for this one!  As the only ordinal number in
          the structure, it is inconsistent with the rest of the
          structure.

     ‘int tm_mon’
          This is the number of full calendar months since the beginning
          of the year (in the range ‘0’ through ‘11’).  Watch out for
          this one!  People usually use ordinal numbers for
          month-of-year (where January = 1).

     ‘int tm_year’
          This is the number of full calendar years since 1900.

     ‘int tm_wday’
          This is the number of full days since Sunday (in the range ‘0’
          through ‘6’).

     ‘int tm_yday’
          This is the number of full days since the beginning of the
          year (in the range ‘0’ through ‘365’).

     ‘int tm_isdst’
          This is a flag that indicates whether daylight saving time is
          (or was, or will be) in effect at the time described.  The
          value is positive if daylight saving time is in effect, zero
          if it is not, and negative if the information is not
          available.  Although this flag is useful when passing a
          broken-down time to the ‘mktime’ function, for other uses this
          flag should be ignored and the ‘tm_gmtoff’ and ‘tm_zone’
          fields should be inspected instead.

     ‘long int tm_gmtoff’
          This field describes the time zone that was used to compute
          this broken-down time value, including any adjustment for
          daylight saving; it is the number of seconds that you must add
          to UTC to get local time.  You can also think of this as the
          number of seconds east of the Prime Meridian.  For example,
          for U.S. Eastern Standard Time, the value is ‘-5*60*60’.

     ‘const char *tm_zone’
          This field is the abbreviation for the time zone that was used
          to compute this broken-down time value.

     *Portability note:* The ‘tm_gmtoff’ and ‘tm_zone’ fields are
     derived from BSD and are POSIX extensions to ISO C.  Code intended
     to be portable to operating systems that lack these fields can
     instead use time zone state variables, although those variables are
     unreliable when the ‘TZ’ environment variable has a geographical
     format.  *Note Time Zone State::.

 -- Function: struct tm * localtime (const time_t *TIME)

     Preliminary: | MT-Unsafe race:tmbuf env locale | AS-Unsafe heap
     lock | AC-Unsafe lock mem fd | *Note POSIX Safety Concepts::.

     The ‘localtime’ function converts the simple time pointed to by
     TIME to broken-down time representation, expressed relative to the
     user's specified time zone.

     The return value is a pointer to a static broken-down time
     structure, which might be overwritten by subsequent calls to
     ‘gmtime’ or ‘localtime’.  (No other library function overwrites the
     contents of this object.)  In the GNU C Library, the structure's
     ‘tm_zone’ points to a string with a storage lifetime that lasts
     indefinitely; on other platforms, the lifetime may expire when the
     ‘TZ’ environment variable is changed.

     The return value is the null pointer if TIME cannot be represented
     as a broken-down time; typically this is because the year cannot
     fit into an ‘int’.

     Calling ‘localtime’ also sets the time zone state as if ‘tzset’
     were called.  *Note Time Zone State::.

   Using the ‘localtime’ function is a big problem in multi-threaded
programs.  The result is returned in a static buffer and this is used in
all threads.  A variant function avoids this problem.

 -- Function: struct tm * localtime_r (const time_t *TIME, struct tm
          *RESULTP)

     Preliminary: | MT-Safe env locale | AS-Unsafe heap lock | AC-Unsafe
     lock mem fd | *Note POSIX Safety Concepts::.

     The ‘localtime_r’ function works just like the ‘localtime’
     function.  It takes a pointer to a variable containing a simple
     time and converts it to the broken-down time format.

     But the result is not placed in a static buffer.  Instead it is
     placed in the object of type ‘struct tm’ to which the parameter
     RESULTP points.  Also, the time zone state is not necessarily set
     as if ‘tzset’ were called.

     If the conversion is successful the function returns a pointer to
     the object the result was written into, i.e., it returns RESULTP.

 -- Function: struct tm * gmtime (const time_t *TIME)

     Preliminary: | MT-Unsafe race:tmbuf env locale | AS-Unsafe heap
     lock | AC-Unsafe lock mem fd | *Note POSIX Safety Concepts::.

     This function is similar to ‘localtime’, except that the
     broken-down time is expressed as UTC rather than relative to a
     local time zone.  The broken-down time's ‘tm_gmtoff’ is 0, and its
     ‘tm_zone’ is a string "UTC" with static storage duration.

   As for the ‘localtime’ function we have the problem that the result
is placed in a static variable.  A thread-safe replacement is also
provided for ‘gmtime’.

 -- Function: struct tm * gmtime_r (const time_t *TIME, struct tm
          *RESULTP)

     Preliminary: | MT-Safe env locale | AS-Unsafe heap lock | AC-Unsafe
     lock mem fd | *Note POSIX Safety Concepts::.

     This function is similar to ‘localtime_r’, except that it converts
     just like ‘gmtime’ the given time as UTC.

     If the conversion is successful the function returns a pointer to
     the object the result was written into, i.e., it returns RESULTP.

 -- Function: time_t mktime (struct tm *BROKENTIME)

     Preliminary: | MT-Safe env locale | AS-Unsafe heap lock | AC-Unsafe
     lock mem fd | *Note POSIX Safety Concepts::.

     The ‘mktime’ function converts a broken-down time structure to a
     simple time representation.  It also normalizes the contents of the
     broken-down time structure, and fills in some components based on
     the values of the others.

     The ‘mktime’ function ignores the specified contents of the
     ‘tm_wday’, ‘tm_yday’, ‘tm_gmtoff’, and ‘tm_zone’ members of the
     broken-down time structure.  It uses the values of the other
     components to determine the calendar time; it's permissible for
     these components to have unnormalized values outside their normal
     ranges.  The last thing that ‘mktime’ does is adjust the components
     of the BROKENTIME structure, including the members that were
     initially ignored.

     If the specified broken-down time cannot be represented as a simple
     time, ‘mktime’ returns a value of ‘(time_t)(-1)’ and does not
     modify the contents of BROKENTIME.

     Calling ‘mktime’ also sets the time zone state as if ‘tzset’ were
     called; ‘mktime’ uses this information instead of BROKENTIME's
     initial ‘tm_gmtoff’ and ‘tm_zone’ members.  *Note Time Zone
     State::.

 -- Function: time_t timelocal (struct tm *BROKENTIME)

     Preliminary: | MT-Safe env locale | AS-Unsafe heap lock | AC-Unsafe
     lock mem fd | *Note POSIX Safety Concepts::.

     ‘timelocal’ is functionally identical to ‘mktime’, but more
     mnemonically named.  Note that it is the inverse of the ‘localtime’
     function.

     *Portability note:* ‘mktime’ is essentially universally available.
     ‘timelocal’ is rather rare.

 -- Function: time_t timegm (struct tm *BROKENTIME)

     Preliminary: | MT-Safe env locale | AS-Unsafe heap lock | AC-Unsafe
     lock mem fd | *Note POSIX Safety Concepts::.

     ‘timegm’ is functionally identical to ‘mktime’ except it always
     takes the input values to be UTC regardless of any local time zone
     setting.

     Note that ‘timegm’ is the inverse of ‘gmtime’.

     *Portability note:* ‘mktime’ is essentially universally available.
     Although ‘timegm’ is standardized by C23, some other systems lack
     it; to be portable to them, you can set the ‘TZ’ environment
     variable to UTC, call ‘mktime’, then set ‘TZ’ back.


File: libc.info,  Node: Formatting Calendar Time,  Next: Parsing Date and Time,  Prev: Broken-down Time,  Up: Calendar Time

22.5.4 Formatting Calendar Time
-------------------------------

The functions described in this section format calendar time values as
strings.  These functions are declared in the header file ‘time.h’.

 -- Function: size_t strftime (char *S, size_t SIZE, const char
          *TEMPLATE, const struct tm *BROKENTIME)

     Preliminary: | MT-Safe env locale | AS-Unsafe corrupt heap lock
     dlopen | AC-Unsafe corrupt lock mem fd | *Note POSIX Safety
     Concepts::.

     This function is similar to the ‘sprintf’ function (*note Formatted
     Input::), but the conversion specifications that can appear in the
     format template TEMPLATE are specialized for printing components of
     BROKENTIME according to the locale currently specified for time
     conversion (*note Locales::) and the current time zone (*note Time
     Zone State::).

     Ordinary characters appearing in the TEMPLATE are copied to the
     output string S; this can include multibyte character sequences.
     Conversion specifiers are introduced by a ‘%’ character, followed
     by an optional flag which can be one of the following.  These flags
     are all GNU extensions.  The first three affect only the output of
     numbers:

     ‘_’
          The number is padded with spaces.

     ‘-’
          The number is not padded at all.

     ‘0’
          The number is padded with zeros even if the format specifies
          padding with spaces.

     ‘^’
          The output uses uppercase characters, but only if this is
          possible (*note Case Conversion::).

     The default action is to pad the number with zeros to keep it a
     constant width.  Numbers that do not have a range indicated below
     are never padded, since there is no natural width for them.

     Following the flag an optional specification of the width is
     possible.  This is specified in decimal notation.  If the natural
     size of the output of the field has less than the specified number
     of characters, the result is written right adjusted and space
     padded to the given size.

     An optional modifier can follow the optional flag and width
     specification.  The modifiers are:

     ‘E’
          Use the locale's alternative representation for date and time.
          This modifier applies to the ‘%c’, ‘%C’, ‘%x’, ‘%X’, ‘%y’ and
          ‘%Y’ format specifiers.  In a Japanese locale, for example,
          ‘%Ex’ might yield a date format based on the Japanese
          Emperors' reigns.

     ‘O’
          With all format specifiers that produce numbers: use the
          locale's alternative numeric symbols.

          With ‘%B’, ‘%b’, and ‘%h’: use the grammatical form for month
          names that is appropriate when the month is named by itself,
          rather than the form that is appropriate when the month is
          used as part of a complete date.  The ‘%OB’ and ‘%Ob’ formats
          are a C23 feature, specified in C23 to use the locale's
          'alternative' month name; the GNU C Library extends this
          specification to say that the form used in a complete date is
          the default and the form naming the month by itself is the
          alternative.

     If the format supports the modifier but no alternative
     representation is available, it is ignored.

     The conversion specifier ends with a format specifier taken from
     the following list.  The whole ‘%’ sequence is replaced in the
     output string as follows:

     ‘%a’
          The abbreviated weekday name according to the current locale.

     ‘%A’
          The full weekday name according to the current locale.

     ‘%b’
          The abbreviated month name according to the current locale, in
          the grammatical form used when the month is part of a complete
          date.  As a C23 feature (with a more detailed specification in
          the GNU C Library), the ‘O’ modifier can be used (‘%Ob’) to
          get the grammatical form used when the month is named by
          itself.

     ‘%B’
          The full month name according to the current locale, in the
          grammatical form used when the month is part of a complete
          date.  As a C23 feature (with a more detailed specification in
          the GNU C Library), the ‘O’ modifier can be used (‘%OB’) to
          get the grammatical form used when the month is named by
          itself.

          Note that not all languages need two different forms of the
          month names, so the text produced by ‘%B’ and ‘%OB’, and by
          ‘%b’ and ‘%Ob’, may or may not be the same, depending on the
          locale.

     ‘%c’
          The preferred calendar time representation for the current
          locale.

     ‘%C’
          The century of the year.  This is equivalent to the greatest
          integer not greater than the year divided by 100.

          If the ‘E’ modifier is specified (‘%EC’), instead produces the
          name of the period for the year (e.g. an era name) in the
          locale's alternative calendar.

     ‘%d’
          The day of the month as a decimal number (range ‘01’ through
          ‘31’).

     ‘%D’
          The date using the format ‘%m/%d/%y’.

     ‘%e’
          The day of the month like with ‘%d’, but padded with spaces
          (range ‘ 1’ through ‘31’).

     ‘%F’
          The date using the format ‘%Y-%m-%d’.  This is the form
          specified in the ISO 8601 standard and is the preferred form
          for all uses.

     ‘%g’
          The year corresponding to the ISO week number, but without the
          century (range ‘00’ through ‘99’).  This has the same format
          and value as ‘%y’, except that if the ISO week number (see
          ‘%V’) belongs to the previous or next year, that year is used
          instead.

     ‘%G’
          The year corresponding to the ISO week number.  This has the
          same format and value as ‘%Y’, except that if the ISO week
          number (see ‘%V’) belongs to the previous or next year, that
          year is used instead.

     ‘%h’
          The abbreviated month name according to the current locale.
          The action is the same as for ‘%b’.

     ‘%H’
          The hour as a decimal number, using a 24-hour clock (range
          ‘00’ through ‘23’).

     ‘%I’
          The hour as a decimal number, using a 12-hour clock (range
          ‘01’ through ‘12’).

     ‘%j’
          The day of the year as a decimal number (range ‘001’ through
          ‘366’).

     ‘%k’
          The hour as a decimal number, using a 24-hour clock like ‘%H’,
          but padded with spaces (range ‘ 0’ through ‘23’).

          This format is a GNU extension.

     ‘%l’
          The hour as a decimal number, using a 12-hour clock like ‘%I’,
          but padded with spaces (range ‘ 1’ through ‘12’).

          This format is a GNU extension.

     ‘%m’
          The month as a decimal number (range ‘01’ through ‘12’).

     ‘%M’
          The minute as a decimal number (range ‘00’ through ‘59’).

     ‘%n’
          A single ‘\n’ (newline) character.

     ‘%p’
          Either ‘AM’ or ‘PM’, according to the given time value; or the
          corresponding strings for the current locale.  Noon is treated
          as ‘PM’ and midnight as ‘AM’.  In most locales ‘AM’/‘PM’
          format is not supported, in such cases "%p" yields an empty
          string.

     ‘%P’
          Either ‘am’ or ‘pm’, according to the given time value; or the
          corresponding strings for the current locale, printed in
          lowercase characters.  Noon is treated as ‘pm’ and midnight as
          ‘am’.  In most locales ‘AM’/‘PM’ format is not supported, in
          such cases "%P" yields an empty string.

          This format is a GNU extension.

     ‘%r’
          The complete calendar time using the AM/PM format of the
          current locale.

          In the POSIX locale, this format is equivalent to ‘%I:%M:%S
          %p’.

     ‘%R’
          The hour and minute in decimal numbers using the format
          ‘%H:%M’.

     ‘%s’
          The number of seconds since the POSIX Epoch, i.e., since
          1970-01-01 00:00:00 UTC.  Leap seconds are not counted unless
          leap second support is available.

          This format is a GNU extension.

     ‘%S’
          The seconds as a decimal number (range ‘00’ through ‘60’).

     ‘%t’
          A single ‘\t’ (tabulator) character.

     ‘%T’
          The time of day using decimal numbers using the format
          ‘%H:%M:%S’.

     ‘%u’
          The day of the week as a decimal number (range ‘1’ through
          ‘7’), Monday being ‘1’.

     ‘%U’
          The week number of the current year as a decimal number (range
          ‘00’ through ‘53’), starting with the first Sunday as the
          first day of the first week.  Days preceding the first Sunday
          in the year are considered to be in week ‘00’.

     ‘%V’
          The ISO 8601 week number as a decimal number (range ‘01’
          through ‘53’).  ISO weeks start with Monday and end with
          Sunday.  Week ‘01’ of a year is the first week which has the
          majority of its days in that year; this is equivalent to the
          week containing the year's first Thursday, and it is also
          equivalent to the week containing January 4.  Week ‘01’ of a
          year can contain days from the previous year.  The week before
          week ‘01’ of a year is the last week (‘52’ or ‘53’) of the
          previous year even if it contains days from the new year.

     ‘%w’
          The day of the week as a decimal number (range ‘0’ through
          ‘6’), Sunday being ‘0’.

     ‘%W’
          The week number of the current year as a decimal number (range
          ‘00’ through ‘53’), starting with the first Monday as the
          first day of the first week.  All days preceding the first
          Monday in the year are considered to be in week ‘00’.

     ‘%x’
          The preferred date representation for the current locale.

     ‘%X’
          The preferred time of day representation for the current
          locale.

     ‘%y’
          The year without a century as a decimal number (range ‘00’
          through ‘99’).  This is equivalent to the year modulo 100.

          If the ‘E’ modifier is specified (‘%Ey’), instead produces the
          year number according to a locale-specific alternative
          calendar.  Unlike ‘%y’, the number is _not_ reduced modulo
          100.  However, by default it is zero-padded to a minimum of
          two digits (this can be overridden by an explicit field width
          or by the ‘_’ and ‘-’ flags).

     ‘%Y’
          The year as a decimal number, using the Gregorian calendar.
          Years before the year ‘1’ are numbered ‘0’, ‘-1’, and so on.

          If the ‘E’ modifier is specified (‘%EY’), instead produces a
          complete representation of the year according to the locale's
          alternative calendar.  Generally this will be some combination
          of the information produced by ‘%EC’ and ‘%Ey’.  As a GNU
          extension, the formatting flags ‘_’ or ‘-’ may be used with
          this conversion specifier; they affect how the year number is
          printed.

     ‘%z’
          RFC 5322/ISO 8601 style numeric time zone (e.g., ‘-0600’ or
          ‘+0100’), or nothing if no time zone is determinable.

          In the POSIX locale, a full RFC 5322 timestamp is generated by
          the format "%a, %d %b %Y %H:%M:%S %z" (or the equivalent
          "%a, %d %b %Y %T %z").

     ‘%Z’
          The time zone abbreviation (empty if the time zone can't be
          determined).

     ‘%%’
          A literal ‘%’ character.

     The SIZE parameter can be used to specify the maximum number of
     characters to be stored in the array S, including the terminating
     null character.  If the formatted time requires more than SIZE
     characters, ‘strftime’ returns zero and the contents of the array S
     are undefined.  Otherwise the return value indicates the number of
     characters placed in the array S, not including the terminating
     null character.

     _Warning:_ This convention for the return value which is prescribed
     in ISO C can lead to problems in some situations.  For certain
     format strings and certain locales the output really can be the
     empty string and this cannot be discovered by testing the return
     value only.  E.g., in most locales the AM/PM time format is not
     supported (most of the world uses the 24 hour time representation).
     In such locales "%p" will return the empty string, i.e., the return
     value is zero.  To detect situations like this something similar to
     the following code should be used:

          buf[0] = '\1';
          len = strftime (buf, bufsize, format, tp);
          if (len == 0 && buf[0] != '\0')
            {
              /* Something went wrong in the strftime call.  */
              ...
            }

     If S is a null pointer, ‘strftime’ does not actually write
     anything, but instead returns the number of characters it would
     have written.

     Calling ‘strftime’ also sets the time zone state as if ‘tzset’ were
     called.  *Note Time Zone State::.

     For an example of ‘strftime’, see *note Time Functions Example::.

 -- Function: size_t strftime_l (char *restrict S, size_t SIZE, const
          char *restrict TEMPLATE, const struct tm *BROKENTIME, locale_t
          LOCALE)

     Preliminary: | MT-Safe env locale | AS-Unsafe corrupt heap lock
     dlopen | AC-Unsafe corrupt lock mem fd | *Note POSIX Safety
     Concepts::.

     The ‘strftime_l’ function is equivalent to the ‘strftime’ function
     except that it operates in LOCALE rather than in the current
     locale.

 -- Function: size_t wcsftime (wchar_t *S, size_t SIZE, const wchar_t
          *TEMPLATE, const struct tm *BROKENTIME)

     Preliminary: | MT-Safe env locale | AS-Unsafe corrupt heap lock
     dlopen | AC-Unsafe corrupt lock mem fd | *Note POSIX Safety
     Concepts::.

     The ‘wcsftime’ function is equivalent to the ‘strftime’ function
     with the difference that it operates on wide character strings.
     The buffer where the result is stored, pointed to by S, must be an
     array of wide characters.  The parameter SIZE which specifies the
     size of the output buffer gives the number of wide characters, not
     the number of bytes.

     Also the format string TEMPLATE is a wide character string.  Since
     all characters needed to specify the format string are in the basic
     character set it is portably possible to write format strings in
     the C source code using the ‘L"..."’ notation.  The parameter
     BROKENTIME has the same meaning as in the ‘strftime’ call.

     The ‘wcsftime’ function supports the same flags, modifiers, and
     format specifiers as the ‘strftime’ function.

     The return value of ‘wcsftime’ is the number of wide characters
     stored in ‘s’.  When more characters would have to be written than
     can be placed in the buffer S the return value is zero, with the
     same problems indicated in the ‘strftime’ documentation.

 -- Deprecated function: char * asctime (const struct tm *BROKENTIME)

     Preliminary: | MT-Unsafe race:asctime locale | AS-Unsafe | AC-Safe
     | *Note POSIX Safety Concepts::.

     The ‘asctime’ function converts the broken-down time value that
     BROKENTIME points to into a string in a standard format:

          "Tue May 21 13:46:22 1991\n"

     The abbreviations for the days of week are: ‘Sun’, ‘Mon’, ‘Tue’,
     ‘Wed’, ‘Thu’, ‘Fri’, and ‘Sat’.

     The abbreviations for the months are: ‘Jan’, ‘Feb’, ‘Mar’, ‘Apr’,
     ‘May’, ‘Jun’, ‘Jul’, ‘Aug’, ‘Sep’, ‘Oct’, ‘Nov’, and ‘Dec’.

     Behavior is undefined if the calculated year would be less than
     1000 or greater than 9999.

     The return value points to a statically allocated string, which
     might be overwritten by subsequent calls to ‘asctime’ or ‘ctime’.
     (No other library function overwrites the contents of this string.)

     *Portability note:* This obsolescent function is deprecated in C23.
     Programs should instead use ‘strftime’ or even ‘sprintf’.

 -- Deprecated function: char * asctime_r (const struct tm *BROKENTIME,
          char *BUFFER)

     Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
     Safety Concepts::.

     This function is similar to ‘asctime’ but instead of placing the
     result in a static buffer it writes the string in the buffer
     pointed to by the parameter BUFFER.  This buffer should have room
     for at least 26 bytes, including the terminating null.  Behavior is
     undefined if the calculated year would be less than 1000 or greater
     than 9999.

     If no error occurred the function returns a pointer to the string
     the result was written into, i.e., it returns BUFFER.  Otherwise it
     returns ‘NULL’.

     *Portability Note:* POSIX.1-2024 removed this obsolescent function.
     Programs should instead use ‘strftime’ or even ‘sprintf’.

 -- Deprecated function: char * ctime (const time_t *TIME)

     Preliminary: | MT-Unsafe race:tmbuf race:asctime env locale |
     AS-Unsafe heap lock | AC-Unsafe lock mem fd | *Note POSIX Safety
     Concepts::.

     The ‘ctime’ function is similar to ‘asctime’, except that you
     specify the calendar time argument as a ‘time_t’ simple time value
     rather than in broken-down local time format.  It is equivalent to

          asctime (localtime (TIME))

     Behavior is undefined if the calculated year would be less than
     1000 or greater than 9999.

     Calling ‘ctime’ also sets the time zone state as if ‘tzset’ were
     called.  *Note Time Zone State::.

     *Portability note:* This obsolescent function is deprecated in C23.
     Programs should instead use ‘strftime’ or even ‘sprintf’.

 -- Deprecated function: char * ctime_r (const time_t *TIME, char
          *BUFFER)

     Preliminary: | MT-Safe env locale | AS-Unsafe heap lock | AC-Unsafe
     lock mem fd | *Note POSIX Safety Concepts::.

     This function is similar to ‘ctime’, but places the result in the
     string pointed to by BUFFER, and the time zone state is not
     necessarily set as if ‘tzset’ were called.  It is equivalent to:

          asctime_r (localtime_r (TIME, &(struct tm) {0}), BUFFER)

     Behavior is undefined if the calculated year would be less than
     1000 or greater than 9999.

     If no error occurred the function returns a pointer to the string
     the result was written into, i.e., it returns BUFFER.  Otherwise it
     returns ‘NULL’.

     *Portability Note:* POSIX.1-2024 removed this obsolescent function.
     Programs should instead use ‘strftime’ or even ‘sprintf’.


File: libc.info,  Node: Parsing Date and Time,  Next: TZ Variable,  Prev: Formatting Calendar Time,  Up: Calendar Time

22.5.5 Convert textual time and date information back
-----------------------------------------------------

The ISO C standard does not specify any functions which can convert the
output of the ‘strftime’ function back into a binary format.  This led
to a variety of more-or-less successful implementations with different
interfaces over the years.  Then the Unix standard was extended by the
addition of two functions: ‘strptime’ and ‘getdate’.  Both have strange
interfaces but at least they are widely available.

* Menu:

* Low-Level Time String Parsing::  Interpret string according to given format.
* General Time String Parsing::    User-friendly function to parse data and
                                    time strings.


File: libc.info,  Node: Low-Level Time String Parsing,  Next: General Time String Parsing,  Up: Parsing Date and Time

22.5.5.1 Interpret string according to given format
...................................................

The first function is rather low-level.  It is nevertheless frequently
used in software since it is better known.  Its interface and
implementation are heavily influenced by the ‘getdate’ function, which
is defined and implemented in terms of calls to ‘strptime’.

 -- Function: char * strptime (const char *S, const char *FMT, struct tm
          *TP)

     Preliminary: | MT-Safe env locale | AS-Unsafe heap lock | AC-Unsafe
     lock mem fd | *Note POSIX Safety Concepts::.

     The ‘strptime’ function parses the input string S according to the
     format string FMT and stores its results in the structure TP.

     The input string could be generated by a ‘strftime’ call or
     obtained any other way.  It does not need to be in a
     human-recognizable format; e.g.  a date passed as "02:1999:9" is
     acceptable, even though it is ambiguous without context.  As long
     as the format string FMT matches the input string the function will
     succeed.

     The user has to make sure, though, that the input can be parsed in
     a unambiguous way.  The string "1999112" can be parsed using the
     format "%Y%m%d" as 1999-1-12, 1999-11-2, or even 19991-1-2.  It is
     necessary to add appropriate separators to reliably get results.

     The format string consists of the same components as the format
     string of the ‘strftime’ function.  The only difference is that the
     flags ‘_’, ‘-’, ‘0’, and ‘^’ are not allowed.  Several of the
     distinct formats of ‘strftime’ do the same work in ‘strptime’ since
     differences like case of the input do not matter.  For reasons of
     symmetry all formats are supported, though.

     The modifiers ‘E’ and ‘O’ are also allowed everywhere the
     ‘strftime’ function allows them.

     The formats are:

     ‘%a’
     ‘%A’
          The weekday name according to the current locale, in
          abbreviated form or the full name.

     ‘%b’
     ‘%B’
     ‘%h’
          A month name according to the current locale.  All three
          specifiers will recognize both abbreviated and full month
          names.  If the locale provides two different grammatical forms
          of month names, all three specifiers will recognize both
          forms.

          As a GNU extension, the ‘O’ modifier can be used with these
          specifiers; it has no effect, as both grammatical forms of
          month names are recognized.

     ‘%c’
          The date and time representation for the current locale.

     ‘%Ec’
          Like ‘%c’ but the locale's alternative date and time format is
          used.

     ‘%C’
          The century of the year.

          It makes sense to use this format only if the format string
          also contains the ‘%y’ format.

     ‘%EC’
          The locale's representation of the period.

          Unlike ‘%C’ it sometimes makes sense to use this format since
          some cultures represent years relative to the beginning of
          eras instead of using the Gregorian years.

     ‘%d’
     ‘%e’
          The day of the month as a decimal number (range ‘1’ through
          ‘31’).  Leading zeroes are permitted but not required.

     ‘%Od’
     ‘%Oe’
          Same as ‘%d’ but using the locale's alternative numeric
          symbols.

          Leading zeroes are permitted but not required.

     ‘%D’
          Equivalent to ‘%m/%d/%y’.

     ‘%F’
          Equivalent to ‘%Y-%m-%d’, which is the ISO 8601 date format.

          This is a GNU extension following an ISO C99 extension to
          ‘strftime’.

     ‘%g’
          The year corresponding to the ISO week number, but without the
          century (range ‘00’ through ‘99’).

          _Note:_ Currently, this is not fully implemented.  The format
          is recognized, input is consumed but no field in TM is set.

          This format is a GNU extension following a GNU extension of
          ‘strftime’.

     ‘%G’
          The year corresponding to the ISO week number.

          _Note:_ Currently, this is not fully implemented.  The format
          is recognized, input is consumed but no field in TM is set.

          This format is a GNU extension following a GNU extension of
          ‘strftime’.

     ‘%H’
     ‘%k’
          The hour as a decimal number, using a 24-hour clock (range
          ‘00’ through ‘23’).

          ‘%k’ is a GNU extension following a GNU extension of
          ‘strftime’.

     ‘%OH’
          Same as ‘%H’ but using the locale's alternative numeric
          symbols.

     ‘%I’
     ‘%l’
          The hour as a decimal number, using a 12-hour clock (range
          ‘01’ through ‘12’).

          ‘%l’ is a GNU extension following a GNU extension of
          ‘strftime’.

     ‘%OI’
          Same as ‘%I’ but using the locale's alternative numeric
          symbols.

     ‘%j’
          The day of the year as a decimal number (range ‘1’ through
          ‘366’).

          Leading zeroes are permitted but not required.

     ‘%m’
          The month as a decimal number (range ‘1’ through ‘12’).

          Leading zeroes are permitted but not required.

     ‘%Om’
          Same as ‘%m’ but using the locale's alternative numeric
          symbols.

     ‘%M’
          The minute as a decimal number (range ‘0’ through ‘59’).

          Leading zeroes are permitted but not required.

     ‘%OM’
          Same as ‘%M’ but using the locale's alternative numeric
          symbols.

     ‘%n’
     ‘%t’
          Matches any whitespace.

     ‘%p’
     ‘%P’
          The locale-dependent equivalent to ‘AM’ or ‘PM’.

          This format is not useful unless ‘%I’ or ‘%l’ is also used.
          Another complication is that the locale might not define these
          values at all and therefore the conversion fails.

          ‘%P’ is a GNU extension following a GNU extension to
          ‘strftime’.

     ‘%r’
          The complete time using the AM/PM format of the current
          locale.

          A complication is that the locale might not define this format
          at all and therefore the conversion fails.

     ‘%R’
          The hour and minute in decimal numbers using the format
          ‘%H:%M’.

          ‘%R’ is a GNU extension following a GNU extension to
          ‘strftime’.

     ‘%s’
          The number of seconds since the POSIX Epoch, i.e., since
          1970-01-01 00:00:00 UTC.  Leap seconds are not counted unless
          leap second support is available.

          ‘%s’ is a GNU extension following a GNU extension to
          ‘strftime’.

     ‘%S’
          The seconds as a decimal number (range ‘0’ through ‘60’).

          Leading zeroes are permitted but not required.

          *NB:* The Unix specification says the upper bound on this
          value is ‘61’, a result of a decision to allow double leap
          seconds.  You will not see the value ‘61’ because no minute
          has more than one leap second, but the myth persists.

     ‘%OS’
          Same as ‘%S’ but using the locale's alternative numeric
          symbols.

     ‘%T’
          Equivalent to the use of ‘%H:%M:%S’ in this place.

     ‘%u’
          The day of the week as a decimal number (range ‘1’ through
          ‘7’), Monday being ‘1’.

          Leading zeroes are permitted but not required.

          _Note:_ Currently, this is not fully implemented.  The format
          is recognized, input is consumed but no field in TM is set.

     ‘%U’
          The week number of the current year as a decimal number (range
          ‘0’ through ‘53’).

          Leading zeroes are permitted but not required.

     ‘%OU’
          Same as ‘%U’ but using the locale's alternative numeric
          symbols.

     ‘%V’
          The ISO 8601 week number as a decimal number (range ‘1’
          through ‘53’).

          Leading zeroes are permitted but not required.

          _Note:_ Currently, this is not fully implemented.  The format
          is recognized, input is consumed but no field in TM is set.

     ‘%w’
          The day of the week as a decimal number (range ‘0’ through
          ‘6’), Sunday being ‘0’.

          Leading zeroes are permitted but not required.

          _Note:_ Currently, this is not fully implemented.  The format
          is recognized, input is consumed but no field in TM is set.

     ‘%Ow’
          Same as ‘%w’ but using the locale's alternative numeric
          symbols.

     ‘%W’
          The week number of the current year as a decimal number (range
          ‘0’ through ‘53’).

          Leading zeroes are permitted but not required.

          _Note:_ Currently, this is not fully implemented.  The format
          is recognized, input is consumed but no field in TM is set.

     ‘%OW’
          Same as ‘%W’ but using the locale's alternative numeric
          symbols.

     ‘%x’
          The date using the locale's date format.

     ‘%Ex’
          Like ‘%x’ but the locale's alternative data representation is
          used.

     ‘%X’
          The time using the locale's time format.

     ‘%EX’
          Like ‘%X’ but the locale's alternative time representation is
          used.

     ‘%y’
          The year without a century as a decimal number (range ‘0’
          through ‘99’).

          Leading zeroes are permitted but not required.

          Note that it is questionable to use this format without the
          ‘%C’ format.  The ‘strptime’ function does regard input values
          in the range 68 to 99 as the years 1969 to 1999 and the values
          0 to 68 as the years 2000 to 2068.  But maybe this heuristic
          fails for some input data.

          Therefore it is best to avoid ‘%y’ completely and use ‘%Y’
          instead.

     ‘%Ey’
          The offset from ‘%EC’ in the locale's alternative
          representation.

     ‘%Oy’
          The offset of the year (from ‘%C’) using the locale's
          alternative numeric symbols.

     ‘%Y’
          The year as a decimal number, using the Gregorian calendar.

     ‘%EY’
          The full alternative year representation.

     ‘%z’
          The offset from UTC in ISO 8601/RFC 5322 format.

     ‘%Z’
          The time zone abbreviation.

          _Note:_ Currently, this is not fully implemented.  The format
          is recognized, input is consumed but no field in TM is set.

     ‘%%’
          A literal ‘%’ character.

     All other characters in the format string must have a matching
     character in the input string.  Exceptions are whitespace
     characters in the input string which can match zero or more
     whitespace characters in the format string.

     *Portability Note:* The XPG standard advises applications to use at
     least one whitespace character (as specified by ‘isspace’) or other
     non-alphanumeric characters between any two conversion
     specifications.  The GNU C Library does not have this limitation
     but other libraries might have trouble parsing formats like
     "%d%m%Y%H%M%S".

     The ‘strptime’ function processes the input string from right to
     left.  Each of the three possible input elements (whitespace,
     literal, or format) are handled one after the other.  If the input
     cannot be matched to the format string the function stops.  The
     remainder of the format and input strings are not processed.

     The function returns a pointer to the first character it was unable
     to process.  If the input string contains more characters than
     required by the format string the return value points right after
     the last consumed input character.  If the whole input string is
     consumed the return value points to the ‘NULL’ byte at the end of
     the string.  If an error occurs, i.e., ‘strptime’ fails to match
     all of the format string, the function returns ‘NULL’.

   The specification of the function in the XPG standard is rather
vague, leaving out a few important pieces of information.  Most
importantly, it does not specify what happens to those elements of TM
which are not directly initialized by the different formats.  The
implementations on different Unix systems vary here.

   The GNU C Library implementation does not touch those fields which
are not directly initialized.  Exceptions are the ‘tm_wday’ and
‘tm_yday’ elements, which are recomputed if any of the year, month, or
date elements changed.  This has two implications:

   • Before calling the ‘strptime’ function for a new input string, you
     should prepare the TM structure you pass.  Normally this will mean
     initializing all values to zero.  Alternatively, you can set all
     fields to values like ‘INT_MAX’, allowing you to determine which
     elements were set by the function call.  Zero does not work here
     since it is a valid value for many of the fields.

     Careful initialization is necessary if you want to find out whether
     a certain field in TM was initialized by the function call.

   • You can construct a ‘struct tm’ value with several consecutive
     ‘strptime’ calls.  A useful application of this is e.g.  the
     parsing of two separate strings, one containing date information
     and the other time information.  By parsing one after the other
     without clearing the structure in-between, you can construct a
     complete broken-down time.

   The following example shows a function which parses a string which
contains the date information in either US style or ISO 8601 form:

     const char *
     parse_date (const char *input, struct tm *tm)
     {
       const char *cp;

       /* First clear the result structure.  */
       memset (tm, '\0', sizeof (*tm));

       /* Try the ISO format first.  */
       cp = strptime (input, "%F", tm);
       if (cp == NULL)
         {
           /* Does not match.  Try the US form.  */
           cp = strptime (input, "%D", tm);
         }

       return cp;
     }


File: libc.info,  Node: General Time String Parsing,  Prev: Low-Level Time String Parsing,  Up: Parsing Date and Time

22.5.5.2 A More User-friendly Way to Parse Times and Dates
..........................................................

The Unix standard defines another function for parsing date strings.
The interface is weird, but if the function happens to suit your
application it is just fine.  It is problematic to use this function in
multi-threaded programs or libraries, since it returns a pointer to a
static variable, and uses a global variable and global state based on an
environment variable.

 -- Variable: getdate_err

     This variable of type ‘int’ contains the error code of the last
     unsuccessful call to ‘getdate’.  Defined values are:

     1
          The environment variable ‘DATEMSK’ is not defined or null.
     2
          The template file denoted by the ‘DATEMSK’ environment
          variable cannot be opened.
     3
          Information about the template file cannot retrieved.
     4
          The template file is not a regular file.
     5
          An I/O error occurred while reading the template file.
     6
          Not enough memory available to execute the function.
     7
          The template file contains no matching template.
     8
          The input date is invalid, but would match a template
          otherwise.  This includes dates like February 31st, and dates
          which cannot be represented in a ‘time_t’ variable.

 -- Function: struct tm * getdate (const char *STRING)

     Preliminary: | MT-Unsafe race:getdate env locale | AS-Unsafe heap
     lock | AC-Unsafe lock mem fd | *Note POSIX Safety Concepts::.

     The interface to ‘getdate’ is the simplest possible for a function
     to parse a string and return the value.  STRING is the input string
     and the result is returned in a statically-allocated variable.

     The details about how the string is processed are hidden from the
     user.  In fact, they can be outside the control of the program.
     Which formats are recognized is controlled by the file named by the
     environment variable ‘DATEMSK’.  This file should contain lines of
     valid format strings which could be passed to ‘strptime’.

     The ‘getdate’ function reads these format strings one after the
     other and tries to match the input string.  The first line which
     completely matches the input string is used.

     Elements not initialized through the format string retain the
     values present at the time of the ‘getdate’ function call.

     The formats recognized by ‘getdate’ are the same as for ‘strptime’.
     See above for an explanation.  There are only a few extensions to
     the ‘strptime’ behavior:

        • If the ‘%Z’ format is given the broken-down time is based on
          the current time of the time zone matched, not of the current
          time zone of the runtime environment.

          _Note_: This is not implemented (currently).  The problem is
          that time zone abbreviations are not unique.  If a fixed time
          zone is assumed for a given string (say ‘EST’ meaning US East
          Coast time), then uses for countries other than the USA will
          fail.  So far we have found no good solution to this.

        • If only the weekday is specified the selected day depends on
          the current date.  If the current weekday is greater than or
          equal to the ‘tm_wday’ value the current week's day is chosen,
          otherwise the day next week is chosen.

        • A similar heuristic is used when only the month is given and
          not the year.  If the month is greater than or equal to the
          current month, then the current year is used.  Otherwise it
          wraps to next year.  The first day of the month is assumed if
          one is not explicitly specified.

        • The current hour, minute, and second are used if the
          appropriate value is not set through the format.

        • If no date is given tomorrow's date is used if the time is
          smaller than the current time.  Otherwise today's date is
          taken.

     It should be noted that the format in the template file need not
     only contain format elements.  The following is a list of possible
     format strings (taken from the Unix standard):

          %m
          %A %B %d, %Y %H:%M:%S
          %A
          %B
          %m/%d/%y %I %p
          %d,%m,%Y %H:%M
          at %A the %dst of %B in %Y
          run job at %I %p,%B %dnd
          %A den %d. %B %Y %H.%M Uhr

     As you can see, the template list can contain very specific strings
     like ‘run job at %I %p,%B %dnd’.  Using the above list of templates
     and assuming the current time is Mon Sep 22 12:19:47 EDT 1986, we
     can obtain the following results for the given input.

     Input          Match        Result
     Mon            %a           Mon Sep 22 12:19:47 EDT 1986
     Sun            %a           Sun Sep 28 12:19:47 EDT 1986
     Fri            %a           Fri Sep 26 12:19:47 EDT 1986
     September      %B           Mon Sep 1 12:19:47 EDT 1986
     January        %B           Thu Jan 1 12:19:47 EST 1987
     December       %B           Mon Dec 1 12:19:47 EST 1986
     Sep Mon        %b %a        Mon Sep 1 12:19:47 EDT 1986
     Jan Fri        %b %a        Fri Jan 2 12:19:47 EST 1987
     Dec Mon        %b %a        Mon Dec 1 12:19:47 EST 1986
     Jan Wed 1989   %b %a %Y     Wed Jan 4 12:19:47 EST 1989
     Fri 9          %a %H        Fri Sep 26 09:00:00 EDT 1986
     Feb 10:30      %b %H:%S     Sun Feb 1 10:00:30 EST 1987
     10:30          %H:%M        Tue Sep 23 10:30:00 EDT 1986
     13:30          %H:%M        Mon Sep 22 13:30:00 EDT 1986

     The return value of the function is a pointer to a static variable
     of type ‘struct tm’, or a null pointer if an error occurred.  The
     result is only valid until the next ‘getdate’ call, making this
     function unusable in multi-threaded applications.

     The ‘errno’ variable is _not_ changed.  Error conditions are stored
     in the global variable ‘getdate_err’.  See the description above
     for a list of the possible error values.

     _Warning:_ The ‘getdate’ function should _never_ be used in
     SUID-programs.  The reason is obvious: using the ‘DATEMSK’
     environment variable you can get the function to open any arbitrary
     file and chances are high that with some bogus input (such as a
     binary file) the program will crash.

 -- Function: int getdate_r (const char *STRING, struct tm *TP)

     Preliminary: | MT-Safe env locale | AS-Unsafe heap lock | AC-Unsafe
     lock mem fd | *Note POSIX Safety Concepts::.

     The ‘getdate_r’ function is the reentrant counterpart of ‘getdate’.
     It does not use the global variable ‘getdate_err’ to signal an
     error, but instead returns an error code.  The same error codes as
     described in the ‘getdate_err’ documentation above are used, with 0
     meaning success.

     Moreover, ‘getdate_r’ stores the broken-down time in the variable
     of type ‘struct tm’ pointed to by the second argument, rather than
     in a static variable.

     This function is not defined in the Unix standard.  Nevertheless it
     is available on some other Unix systems as well.

     The warning against using ‘getdate’ in SUID-programs applies to
     ‘getdate_r’ as well.


File: libc.info,  Node: TZ Variable,  Next: Time Zone State,  Prev: Parsing Date and Time,  Up: Calendar Time

22.5.6 Specifying the Time Zone with ‘TZ’
-----------------------------------------

In POSIX systems, a user can specify the time zone by means of the ‘TZ’
environment variable.  For information about how to set environment
variables, see *note Environment Variables::.  The functions for
accessing the time zone are declared in ‘time.h’.

   You should not normally need to set ‘TZ’.  If the system is
configured properly, the default time zone will be correct.  You might
set ‘TZ’ if you are using a computer over a network from a different
time zone, and would like times reported to you in the time zone local
to you, rather than what is local to the computer.

   The value of ‘TZ’ can be in one of the following formats:

   • The “geographical format” specifies a location that stands for the
     past and future time zones observed in that location.  *Note
     Geographical TZ::.  Here are some examples:

          Asia/Tokyo
          America/New_York
          /usr/share/zoneinfo/America/Nuuk

   • The “proleptic format” represents a time zone that has always been
     and always will be the same offset from UTC, optionally with a
     simple daylight saving scheme that has always been (and always will
     be) used every year.  *Note Proleptic TZ::.  Here are some
     examples:

          JST-9
          EST+5EDT,M3.2.0/2,M11.1.0/2
          <-02>+2<-01>,M3.5.0/-1,M10.5.0/0

   • The “colon format” begins with ‘:’.  Here is an example.

          :/etc/localtime

     Each operating system can interpret this format differently; in the
     GNU C Library, the ‘:’ is ignored and CHARACTERS are treated as if
     they specified the geographical or proleptic format.

   • As an extension to POSIX, when the value of ‘TZ’ is the empty
     string, the GNU C Library uses UTC.

   If the ‘TZ’ environment variable does not have a value, the
implementation chooses a time zone by default.  In the GNU C Library,
the default time zone is like the specification ‘TZ=/etc/localtime’ (or
‘TZ=/usr/local/etc/localtime’, depending on how the GNU C Library was
configured; *note Installation::).  Other C libraries use their own rule
for choosing the default time zone, so there is little we can say about
them.

* Menu:

* Geographical TZ::  ‘TZ’ settings like ‘America/New_York’.
* Proleptic TZ::     ‘TZ’ settings like ‘EST+5EDT,M3.2.0/2,M11.1.0/2’.


File: libc.info,  Node: Geographical TZ,  Next: Proleptic TZ,  Up: TZ Variable

22.5.6.1 Geographical Format for ‘TZ’
.....................................

The geographical format names a time zone ruleset maintained by the Time
Zone Database (http://www.iana.org/time-zones) of time zone and daylight
saving time information for most regions of the world.  This
public-domain database is maintained by a community of volunteers.

   If the format's CHARACTERS begin with ‘/’ it is an absolute file
name; otherwise the library looks for the file
‘/usr/share/zoneinfo/CHARACTERS’.  The ‘zoneinfo’ directory contains
data files describing time zone rulesets in many different parts of the
world.  The names represent major cities, with subdirectories for
geographical areas; for example, ‘America/New_York’, ‘Europe/London’,
‘Asia/Tokyo’.  These data files are installed by the system
administrator, who also sets ‘/etc/localtime’ to point to the data file
for the local time zone ruleset.

   If the file corresponding to CHARACTERS cannot be read or has invalid
data, and CHARACTERS are not in the proleptic format, then the GNU C
Library silently defaults to UTC.  However, applications should not
depend on this, as ‘TZ’ formats may be extended in the future.


File: libc.info,  Node: Proleptic TZ,  Prev: Geographical TZ,  Up: TZ Variable

22.5.6.2 Proleptic Format for ‘TZ’
..................................

Although the proleptic format is cumbersome and inaccurate for old
timestamps, POSIX.1-2017 and earlier specified details only for the
proleptic format, and you may need to use it on small systems that lack
a time zone information database.

   The proleptic format is:

     STDOFFSET[DST[OFFSET][,START[/TIME],END[/TIME]]]

   The STD string specifies the time zone abbreviation, which must be at
least three bytes long, and which can appear in unquoted or quoted form.
The unquoted form can contain only ASCII alphabetic characters.  The
quoted form can also contain ASCII digits, ‘+’, and ‘-’; it is quoted by
surrounding it by ‘<’ and ‘>’, which are not part of the abbreviation.
There is no space character separating the time zone abbreviation from
the OFFSET, so these restrictions are necessary to parse the
specification correctly.

   The OFFSET specifies the time value you must add to the local time to
get a UTC value.  It has syntax like:

     [+|-]HH[:MM[:SS]]

This is positive if the local time zone is west of the Prime Meridian
and negative if it is east; this is opposite from the usual convention
that positive time zone offsets are east of the Prime Meridian.  The
hour HH must be between 0 and 24 and may be a single digit, and the
minutes MM and seconds SS, if present, must be between 0 and 59.

   For example, to specify time in Panama, which is Eastern Standard
Time without any daylight saving time alternative:

     EST+5

   When daylight saving time is used, the proleptic format is more
complicated.  The initial STD and OFFSET specify the standard time zone,
as described above.  The DST string and OFFSET are the abbreviation and
offset for the corresponding daylight saving time zone; if the OFFSET is
omitted, it defaults to one hour ahead of standard time.

   The remainder of the proleptic format, which starts with the first
comma, describes when daylight saving time is in effect.  This remainder
is optional and if omitted, the GNU C Library defaults to the daylight
saving rules that would be used if ‘TZ’ had the value "posixrules".
However, other POSIX implementations default to different daylight
saving rules, so portable ‘TZ’ settings should not omit the remainder.

   In the remainder, the START field is when daylight saving time goes
into effect and the END field is when the change is made back to
standard time.  The following formats are recognized for these fields:

‘JN’
     This specifies the Julian day, with N between ‘1’ and ‘365’.
     February 29 is never counted, even in leap years.

‘N’
     This specifies the Julian day, with N between ‘0’ and ‘365’.
     February 29 is counted in leap years.

‘MM.W.D’
     This specifies day D of week W of month M.  The day D must be
     between ‘0’ (Sunday) and ‘6’.  The week W must be between ‘1’ and
     ‘5’; week ‘1’ is the first week in which day D occurs, and week ‘5’
     specifies the _last_ D day in the month.  The month M should be
     between ‘1’ and ‘12’.

   The TIME fields specify when, in the local time currently in effect,
the change to the other time occurs.  They have the same format as
OFFSET except the hours part can range from −167 through 167; for
example, ‘-22:30’ stands for 01:30 the previous day and ‘25:30’ stands
for 01:30 the next day.  If omitted, TIME defaults to ‘02:00:00’.

   Here are example ‘TZ’ values with daylight saving time rules.

‘EST+5EDT,M3.2.0/2,M11.1.0/2’
     In North American Eastern Standard Time (EST) and Eastern Daylight
     Time (EDT), the normal offset from UTC is 5 hours; since this is
     west of the Prime Meridian, the sign is positive.  Summer time
     begins on March's second Sunday at 2:00am, and ends on November's
     first Sunday at 2:00am.

‘IST-2IDT,M3.4.4/26,M10.5.0’
     Israel Standard Time (IST) and Israel Daylight Time (IDT) are 2
     hours ahead of the prime meridian in winter, springing forward an
     hour on March's fourth Thursday at 26:00 (i.e., 02:00 on the first
     Friday on or after March 23), and falling back on October's last
     Sunday at 02:00.

‘IST-1GMT0,M10.5.0,M3.5.0/1’
     Irish Standard Time (IST) is 1 hour behind the Prime Meridian in
     summer, falling forward to Greenwich Mean Time (GMT, the Prime
     Meridian's time), on October's last Sunday at 00:00 and springing
     back on March's last Sunday at 01:00.  This is an example of
     "negative daylight saving"; here, daylight saving time is one hour
     west of standard time instead of the more usual one hour east.

‘<-02>+2<-01>,M3.5.0/-1,M10.5.0/0’
     Most of Greenland is 2 hours behind UTC in winter.  Clocks follow
     the European Union rules of springing forward by one hour on
     March's last Sunday at 01:00 UTC (−01:00 local time) and falling
     back on October's last Sunday at 01:00 UTC (00:00 local time).  The
     numeric abbreviations ‘-02’ and ‘-01’ stand for standard and
     daylight saving time, respectively.

   The schedule of daylight saving time in any particular jurisdiction
has changed over the years.  To be strictly correct, the conversion of
dates and times in the past should be based on the schedule that was in
effect then.  However, the proleptic format does not let you specify how
the schedule has changed from year to year.  The most you can do is
specify one particular schedule--usually the present day schedule--and
this is used to convert any date, no matter when.  For precise time zone
specifications, it is best to use the geographical format.  *Note
Geographical TZ::.


File: libc.info,  Node: Time Zone State,  Next: Time Functions Example,  Prev: TZ Variable,  Up: Calendar Time

22.5.7 State Variables for Time Zones
-------------------------------------

For compatibility with POSIX, the GNU C Library defines global state
variables that depend on time zone rules specified by the ‘TZ’
environment variable.  However, these state variables are obsolescent
and are planned to be removed in a future version of POSIX, and programs
generally should avoid them because they are not thread-safe and their
values are specified only when ‘TZ’ uses the proleptic format.  *Note TZ
Variable::.  Programs should instead use the ‘tm_gmtoff’ and ‘tm_zone’
members of ‘struct tm’.  *Note Broken-down Time::.

 -- Function: void tzset (void)

     Preliminary: | MT-Safe env locale | AS-Unsafe heap lock | AC-Unsafe
     lock mem fd | *Note POSIX Safety Concepts::.

     The ‘tzset’ function initializes the state variables from the value
     of the ‘TZ’ environment variable.  It is not usually necessary for
     your program to call this function, partly because your program
     should not use the state variables, and partly because this
     function is called automatically when you use the time conversion
     functions ‘localtime’, ‘mktime’, ‘strftime’, ‘strftime_l’, and
     ‘wcsftime’, or the deprecated function ‘ctime’.  Behavior is
     undefined if one thread accesses any of these variables directly
     while another thread is calling ‘tzset’ or any other function that
     is required or allowed to behave as if it called ‘tzset’.

 -- Variable: char * tzname [2]

     The array ‘tzname’ contains two strings, which are abbreviations of
     time zones (standard and Daylight Saving) that the user has
     selected.  ‘tzname[0]’ abbreviates a standard time zone (for
     example, "EST"), and ‘tzname[1]’ abbreviates a time zone when
     daylight saving time is in use (for example, "EDT").  These
     correspond to the STD and DST strings (respectively) when the ‘TZ’
     environment variable uses the proleptic format.  The string values
     are unspecified if ‘TZ’ uses the geographical format, so it is
     generally better to use the broken-down time structure's ‘tm_zone’
     member instead.

     In the GNU C Library, the strings have a storage lifetime that
     lasts indefinitely; on some other platforms, the lifetime lasts
     only until ‘TZ’ is changed.

     The ‘tzname’ array is initialized by ‘tzset’.  Though the strings
     are declared as ‘char *’ the user must refrain from modifying them.
     Modifying the strings will almost certainly lead to trouble.

 -- Variable: long int timezone

     This contains the difference between UTC and local standard time,
     in seconds west of the Prime Meridian.  For example, in the U.S.
     Eastern time zone, the value is ‘5*60*60’.  Unlike the ‘tm_gmtoff’
     member of the broken-down time structure, this value is not
     adjusted for daylight saving, and its sign is reversed.  The value
     is unspecified if ‘TZ’ uses the geographical format, so it is
     generally better to use the broken-down time structure's
     ‘tm_gmtoff’ member instead.

 -- Variable: int daylight

     This variable is nonzero if daylight saving time rules apply.  A
     nonzero value does not necessarily mean that daylight saving time
     is now in effect; it means only that daylight saving time is
     sometimes in effect.  This variable has little or no practical use;
     it is present for POSIX compatibility.


File: libc.info,  Node: Time Functions Example,  Prev: Time Zone State,  Up: Calendar Time

22.5.8 Time Functions Example
-----------------------------

Here is an example program showing the use of some of the calendar time
functions.


     #include <time.h>
     #include <stdio.h>

     int
     main (void)
     {
       /* This buffer is big enough that the strftime calls
          below cannot possibly exhaust it. */
       char buf[256];

       /* Get the current time. */
       time_t curtime = time (NULL);

       /* Convert it to local time representation. */
       struct tm *lt = localtime (&curtime);
       if (!lt)
         return 1;

       /* Print the date and time in a simple format
          that is independent of locale. */
       strftime (buf, sizeof buf, "%Y-%m-%d %H:%M:%S", lt);
       puts (buf);

       /* Print it in a nicer English format. */
       strftime (buf, sizeof buf, "Today is %A, %B %d.", lt);
       puts (buf);
       strftime (buf, sizeof buf, "The time is %I:%M %p.", lt);
       puts (buf);

       return 0;
     }

   It produces output like this:

     2024-06-09 13:50:06
     Today is Sunday, June 09.
     The time is 01:50 PM.


File: libc.info,  Node: Setting an Alarm,  Next: Sleeping,  Prev: Calendar Time,  Up: Date and Time

22.6 Setting an Alarm
=====================

The ‘alarm’ and ‘setitimer’ functions provide a mechanism for a process
to interrupt itself in the future.  They do this by setting a timer;
when the timer expires, the process receives a signal.

   Each process has three independent interval timers available:

   • A real-time timer that counts elapsed time.  This timer sends a
     ‘SIGALRM’ signal to the process when it expires.

   • A virtual timer that counts processor time used by the process.
     This timer sends a ‘SIGVTALRM’ signal to the process when it
     expires.

   • A profiling timer that counts both processor time used by the
     process, and processor time spent in system calls on behalf of the
     process.  This timer sends a ‘SIGPROF’ signal to the process when
     it expires.

     This timer is useful for profiling in interpreters.  The interval
     timer mechanism does not have the fine granularity necessary for
     profiling native code.

   You can only have one timer of each kind set at any given time.  If
you set a timer that has not yet expired, that timer is simply reset to
the new value.

   You should establish a handler for the appropriate alarm signal using
‘signal’ or ‘sigaction’ before issuing a call to ‘setitimer’ or ‘alarm’.
Otherwise, an unusual chain of events could cause the timer to expire
before your program establishes the handler.  In this case it would be
terminated, since termination is the default action for the alarm
signals.  *Note Signal Handling::.

   To be able to use the alarm function to interrupt a system call which
might block otherwise indefinitely it is important to _not_ set the
‘SA_RESTART’ flag when registering the signal handler using ‘sigaction’.
When not using ‘sigaction’ things get even uglier: the ‘signal’ function
has fixed semantics with respect to restarts.  The BSD semantics for
this function is to set the flag.  Therefore, if ‘sigaction’ for
whatever reason cannot be used, it is necessary to use ‘sysv_signal’ and
not ‘signal’.

   The ‘setitimer’ function is the primary means for setting an alarm.
This facility is declared in the header file ‘sys/time.h’.  The ‘alarm’
function, declared in ‘unistd.h’, provides a somewhat simpler interface
for setting the real-time timer.

 -- Data Type: struct itimerval

     This structure is used to specify when a timer should expire.  It
     contains the following members:
     ‘struct timeval it_interval’
          This is the period between successive timer interrupts.  If
          zero, the alarm will only be sent once.

     ‘struct timeval it_value’
          This is the period between now and the first timer interrupt.
          If zero, the alarm is disabled.

     The ‘struct timeval’ data type is described in *note Time Types::.

 -- Function: int setitimer (int WHICH, const struct itimerval *NEW,
          struct itimerval *OLD)

     Preliminary: | MT-Safe timer | AS-Safe | AC-Safe | *Note POSIX
     Safety Concepts::.

     The ‘setitimer’ function sets the timer specified by WHICH
     according to NEW.  The WHICH argument can have a value of
     ‘ITIMER_REAL’, ‘ITIMER_VIRTUAL’, or ‘ITIMER_PROF’.

     If OLD is not a null pointer, ‘setitimer’ returns information about
     any previous unexpired timer of the same kind in the structure it
     points to.

     The return value is ‘0’ on success and ‘-1’ on failure.  The
     following ‘errno’ error conditions are defined for this function:

     ‘EINVAL’
          The timer period is too large.

 -- Function: int getitimer (int WHICH, struct itimerval *OLD)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     The ‘getitimer’ function stores information about the timer
     specified by WHICH in the structure pointed at by OLD.

     The return value and error conditions are the same as for
     ‘setitimer’.

‘ITIMER_REAL’

     This constant can be used as the WHICH argument to the ‘setitimer’
     and ‘getitimer’ functions to specify the real-time timer.

‘ITIMER_VIRTUAL’

     This constant can be used as the WHICH argument to the ‘setitimer’
     and ‘getitimer’ functions to specify the virtual timer.

‘ITIMER_PROF’

     This constant can be used as the WHICH argument to the ‘setitimer’
     and ‘getitimer’ functions to specify the profiling timer.

 -- Function: unsigned int alarm (unsigned int SECONDS)

     Preliminary: | MT-Safe timer | AS-Safe | AC-Safe | *Note POSIX
     Safety Concepts::.

     The ‘alarm’ function sets the real-time timer to expire in SECONDS
     seconds.  If you want to cancel any existing alarm, you can do this
     by calling ‘alarm’ with a SECONDS argument of zero.

     The return value indicates how many seconds remain before the
     previous alarm would have been sent.  If there was no previous
     alarm, ‘alarm’ returns zero.

   The ‘alarm’ function could be defined in terms of ‘setitimer’ like
this:

     unsigned int
     alarm (unsigned int seconds)
     {
       struct itimerval old, new;
       new.it_interval.tv_usec = 0;
       new.it_interval.tv_sec = 0;
       new.it_value.tv_usec = 0;
       new.it_value.tv_sec = (long int) seconds;
       if (setitimer (ITIMER_REAL, &new, &old) < 0)
         return 0;
       else
         return old.it_value.tv_sec;
     }

   There is an example showing the use of the ‘alarm’ function in *note
Handler Returns::.

   If you simply want your process to wait for a given number of
seconds, you should use the ‘sleep’ function.  *Note Sleeping::.

   You shouldn't count on the signal arriving precisely when the timer
expires.  In a multiprocessing environment there is typically some
amount of delay involved.

   *Portability Note:* The ‘setitimer’ and ‘getitimer’ functions are
derived from BSD Unix, while the ‘alarm’ function is specified by POSIX.
‘setitimer’ is more powerful than ‘alarm’, but ‘alarm’ is more widely
used.


File: libc.info,  Node: Sleeping,  Prev: Setting an Alarm,  Up: Date and Time

22.7 Sleeping
=============

The function ‘sleep’ gives a simple way to make the program wait for a
short interval.  If your program doesn't use signals (except to
terminate), then you can expect ‘sleep’ to wait reliably throughout the
specified interval.  Otherwise, ‘sleep’ can return sooner if a signal
arrives; if you want to wait for a given interval regardless of signals,
use ‘select’ (*note Waiting for I/O::) and don't specify any descriptors
to wait for.

 -- Function: unsigned int sleep (unsigned int SECONDS)

     Preliminary: | MT-Unsafe sig:SIGCHLD/linux | AS-Unsafe | AC-Unsafe
     | *Note POSIX Safety Concepts::.

     The ‘sleep’ function waits for SECONDS seconds or until a signal is
     delivered, whichever happens first.

     If ‘sleep’ returns because the requested interval is over, it
     returns a value of zero.  If it returns because of delivery of a
     signal, its return value is the remaining time in the sleep
     interval.

     The ‘sleep’ function is declared in ‘unistd.h’.

   Resist the temptation to implement a sleep for a fixed amount of time
by using the return value of ‘sleep’, when nonzero, to call ‘sleep’
again.  This will work with a certain amount of accuracy as long as
signals arrive infrequently.  But each signal can cause the eventual
wakeup time to be off by an additional second or so.  Suppose a few
signals happen to arrive in rapid succession by bad luck--there is no
limit on how much this could shorten or lengthen the wait.

   Instead, compute the calendar time at which the program should stop
waiting, and keep trying to wait until that calendar time.  This won't
be off by more than a second.  With just a little more work, you can use
‘select’ and make the waiting period quite accurate.  (Of course, heavy
system load can cause additional unavoidable delays--unless the machine
is dedicated to one application, there is no way you can avoid this.)

   On some systems, ‘sleep’ can do strange things if your program uses
‘SIGALRM’ explicitly.  Even if ‘SIGALRM’ signals are being ignored or
blocked when ‘sleep’ is called, ‘sleep’ might return prematurely on
delivery of a ‘SIGALRM’ signal.  If you have established a handler for
‘SIGALRM’ signals and a ‘SIGALRM’ signal is delivered while the process
is sleeping, the action taken might be just to cause ‘sleep’ to return
instead of invoking your handler.  And, if ‘sleep’ is interrupted by
delivery of a signal whose handler requests an alarm or alters the
handling of ‘SIGALRM’, this handler and ‘sleep’ will interfere.

   On GNU systems, it is safe to use ‘sleep’ and ‘SIGALRM’ in the same
program, because ‘sleep’ does not work by means of ‘SIGALRM’.

 -- Function: int nanosleep (const struct timespec *REQUESTED_TIME,
          struct timespec *REMAINING_TIME)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     If resolution to seconds is not enough, the ‘nanosleep’ function
     can be used.  As the name suggests the sleep interval can be
     specified in nanoseconds.  The actual elapsed time of the sleep
     interval might be longer since the system rounds the elapsed time
     you request up to the next integer multiple of the actual
     resolution the system can deliver.

     ‘*REQUESTED_TIME’ is the elapsed time of the interval you want to
     sleep.

     If REMAINING_TIME is not the null pointer, the function returns as
     ‘*REMAINING_TIME’ the elapsed time left in the interval for which
     you requested to sleep.  If the interval completed without getting
     interrupted by a signal, this is zero.

     ‘struct timespec’ is described in *note Time Types::.

     If the function returns because the interval is over, it returns
     zero.  Otherwise it returns -1 and sets the global variable ‘errno’
     to one of the following values:

     ‘EINTR’
          The call was interrupted because a signal was delivered to the
          thread.  If the REMAINING_TIME parameter is not the null
          pointer, the structure pointed to by REMAINING_TIME is updated
          to contain the remaining elapsed time.

     ‘EINVAL’
          The nanosecond value in the REQUESTED_TIME parameter contains
          an invalid value.  Either the value is negative or greater
          than or equal to 1000 million.

     This function is a cancellation point in multi-threaded programs.
     This is a problem if the thread allocates some resources (like
     memory, file descriptors, semaphores or whatever) at the time
     ‘nanosleep’ is called.  If the thread gets canceled, these
     resources stay allocated until the program ends.  To avoid this,
     calls to ‘nanosleep’ should be protected using cancellation
     handlers.

     The ‘nanosleep’ function is declared in ‘time.h’.

 -- Function: int clock_nanosleep (clockid_t CLOCK, int FLAGS, const
          struct timespec *REQUESTED_TIME, struct timespec
          *REMAINING_TIME)

     Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
     Concepts::.

     This function is similar to ‘nanosleep’ while additionally
     providing the caller with a way to specify the clock to be used to
     measure elapsed time and express the sleep interval in absolute or
     relative terms.  It returns zero when returning because the
     interval is over, and a positive error number corresponding to the
     error encountered otherwise.  This is different from ‘nanosleep’,
     which returns -1 upon failure and sets the global variable ‘errno’
     according to the error encountered instead.

     Except for the return value convention and the way to communicate
     an error condition the call:

          nanosleep (REQUESTED_TIME, REMAINING_TIME)

     is analogous to:

          clock_nanosleep (CLOCK_REALTIME, 0, REQUESTED_TIME, REMAINING_TIME)

     The CLOCK argument specifies the clock to use.  *Note Getting the
     Time::, for the ‘clockid_t’ type and possible values of CLOCK.  Not
     all clocks listed are supported for use with ‘clock_nanosleep’.
     For details, see the manual page clock_nanosleep(2) (Latest,
     online:
     <https://man7.org/linux/man-pages/man2/clock_nanosleep.2.html>)
     *Note Linux Kernel::.

     The FLAGS argument is either ‘0’ or ‘TIMER_ABSTIME’.  If FLAGS is
     ‘0’, then ‘clock_nanosleep’ interprets REQUESTED_TIME as an
     interval relative to the current time specified by CLOCK.  If it is
     ‘TIMER_ABSTIME’ instead, REQUESTED_TIME specifies an absolute time
     measured by CLOCK; if at the time of the call the value requested
     is less than or equal to the clock specified, then the function
     returns right away.  When FLAGS is ‘TIMER_ABSTIME’, REMAINING_TIME
     is not updated.

     The ‘clock_nanosleep’ function returns error codes as positive
     return values.  The error conditions for ‘clock_nanosleep’ are the
     same as for ‘nanosleep’, with the following conditions additionally
     defined:

     ‘EINVAL’
          The CLOCK argument is not a valid clock.

     ‘EOPNOTSUPP’
          The CLOCK argument is not supported by the kernel for
          ‘clock_nanosleep’.

     The ‘clock_nanosleep’ function is declared in ‘time.h’.