blob: 6a9ecdfb7b13a0dcba1645341d12e918415c5b79 [file] [log] [blame]
This is libc.info, produced by makeinfo version 5.2 from libc.texinfo.
This file documents the GNU C Library.
This is 'The GNU C Library Reference Manual', for version 2.19
(Buildroot).
Copyright (C) 1993-2014 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.
* 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.
* CHILD_MAX: (libc)General Limits.
* CIGNORE: (libc)Control Modes.
* CLK_TCK: (libc)Processor Time.
* CLOCAL: (libc)Control Modes.
* CLOCKS_PER_SEC: (libc)CPU Time.
* COLL_WEIGHTS_MAX: (libc)Utility Limits.
* CPU_CLR: (libc)CPU Affinity.
* CPU_ISSET: (libc)CPU Affinity.
* CPU_SET: (libc)CPU Affinity.
* CPU_SETSIZE: (libc)CPU Affinity.
* CPU_ZERO: (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.
* DES_FAILED: (libc)DES Encryption.
* 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.
* 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.
* 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_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.
* 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_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_NOLINK: (libc)Open-time Flags.
* O_NONBLOCK: (libc)Open-time Flags.
* O_NONBLOCK: (libc)Operating Modes.
* O_NOTRANS: (libc)Open-time Flags.
* 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_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.
* P_tmpdir: (libc)Temporary Files.
* RAND_MAX: (libc)ISO Random.
* RE_DUP_MAX: (libc)General Limits.
* RLIM_INFINITY: (libc)Limits on Resources.
* R_OK: (libc)Testing File Access.
* SA_NOCLDSTOP: (libc)Flags for Sigaction.
* SA_ONSTACK: (libc)Flags for Sigaction.
* SA_RESTART: (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.
* SIGQUIT: (libc)Termination Signals.
* SIGSEGV: (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.
* 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.
* SSIZE_MAX: (libc)General Limits.
* STREAM_MAX: (libc)General Limits.
* SUN_LEN: (libc)Local Namespace Details.
* SV_INTERRUPT: (libc)BSD Handler.
* SV_ONSTACK: (libc)BSD Handler.
* SV_RESETHAND: (libc)BSD Handler.
* 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.
* 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.
* _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_low: (libc)PowerPC.
* __ppc_yield: (libc)PowerPC.
* __va_copy: (libc)Argument Macros.
* _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.
* acosh: (libc)Hyperbolic Functions.
* acoshf: (libc)Hyperbolic Functions.
* acoshl: (libc)Hyperbolic Functions.
* acosl: (libc)Inverse Trig Functions.
* addmntent: (libc)mtab.
* addseverity: (libc)Adding Severity Classes.
* adjtime: (libc)High-Resolution Calendar.
* adjtimex: (libc)High-Resolution Calendar.
* 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.
* 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.
* asinh: (libc)Hyperbolic Functions.
* asinhf: (libc)Hyperbolic Functions.
* asinhl: (libc)Hyperbolic Functions.
* asinl: (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.
* atan2l: (libc)Inverse Trig Functions.
* atan: (libc)Inverse Trig Functions.
* atanf: (libc)Inverse Trig Functions.
* atanh: (libc)Hyperbolic Functions.
* atanhf: (libc)Hyperbolic Functions.
* atanhl: (libc)Hyperbolic Functions.
* atanl: (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 and Concatenation.
* 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 and Concatenation.
* cabs: (libc)Absolute Value.
* cabsf: (libc)Absolute Value.
* cabsl: (libc)Absolute Value.
* cacos: (libc)Inverse Trig Functions.
* cacosf: (libc)Inverse Trig Functions.
* cacosh: (libc)Hyperbolic Functions.
* cacoshf: (libc)Hyperbolic Functions.
* cacoshl: (libc)Hyperbolic Functions.
* cacosl: (libc)Inverse Trig Functions.
* calloc: (libc)Allocating Cleared Space.
* canonicalize_file_name: (libc)Symbolic Links.
* carg: (libc)Operations on Complex.
* cargf: (libc)Operations on Complex.
* cargl: (libc)Operations on Complex.
* casin: (libc)Inverse Trig Functions.
* casinf: (libc)Inverse Trig Functions.
* casinh: (libc)Hyperbolic Functions.
* casinhf: (libc)Hyperbolic Functions.
* casinhl: (libc)Hyperbolic Functions.
* casinl: (libc)Inverse Trig Functions.
* catan: (libc)Inverse Trig Functions.
* catanf: (libc)Inverse Trig Functions.
* catanh: (libc)Hyperbolic Functions.
* catanhf: (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.
* cbc_crypt: (libc)DES Encryption.
* cbrt: (libc)Exponents and Logarithms.
* cbrtf: (libc)Exponents and Logarithms.
* cbrtl: (libc)Exponents and Logarithms.
* ccos: (libc)Trig Functions.
* ccosf: (libc)Trig Functions.
* ccosh: (libc)Hyperbolic Functions.
* ccoshf: (libc)Hyperbolic Functions.
* ccoshl: (libc)Hyperbolic Functions.
* ccosl: (libc)Trig Functions.
* ceil: (libc)Rounding Functions.
* ceilf: (libc)Rounding Functions.
* ceill: (libc)Rounding Functions.
* cexp: (libc)Exponents and Logarithms.
* cexpf: (libc)Exponents and Logarithms.
* cexpl: (libc)Exponents and Logarithms.
* cfgetispeed: (libc)Line Speed.
* cfgetospeed: (libc)Line Speed.
* cfmakeraw: (libc)Noncanonical Input.
* cfree: (libc)Freeing after Malloc.
* cfsetispeed: (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.
* cimagl: (libc)Operations on Complex.
* clearenv: (libc)Environment Access.
* clearerr: (libc)Error Recovery.
* clearerr_unlocked: (libc)Error Recovery.
* clock: (libc)CPU Time.
* clog10: (libc)Exponents and Logarithms.
* clog10f: (libc)Exponents and Logarithms.
* clog10l: (libc)Exponents and Logarithms.
* clog: (libc)Exponents and Logarithms.
* clogf: (libc)Exponents and Logarithms.
* clogl: (libc)Exponents and Logarithms.
* close: (libc)Opening and Closing Files.
* closedir: (libc)Reading/Closing Directory.
* closelog: (libc)closelog.
* confstr: (libc)String Parameters.
* conj: (libc)Operations on Complex.
* conjf: (libc)Operations on Complex.
* conjl: (libc)Operations on Complex.
* connect: (libc)Connecting.
* copysign: (libc)FP Bit Twiddling.
* copysignf: (libc)FP Bit Twiddling.
* copysignl: (libc)FP Bit Twiddling.
* cos: (libc)Trig Functions.
* cosf: (libc)Trig Functions.
* cosh: (libc)Hyperbolic Functions.
* coshf: (libc)Hyperbolic Functions.
* coshl: (libc)Hyperbolic Functions.
* cosl: (libc)Trig Functions.
* cpow: (libc)Exponents and Logarithms.
* cpowf: (libc)Exponents and Logarithms.
* cpowl: (libc)Exponents and Logarithms.
* cproj: (libc)Operations on Complex.
* cprojf: (libc)Operations on Complex.
* cprojl: (libc)Operations on Complex.
* creal: (libc)Operations on Complex.
* crealf: (libc)Operations on Complex.
* creall: (libc)Operations on Complex.
* creat64: (libc)Opening and Closing Files.
* creat: (libc)Opening and Closing Files.
* crypt: (libc)crypt.
* crypt_r: (libc)crypt.
* csin: (libc)Trig Functions.
* csinf: (libc)Trig Functions.
* csinh: (libc)Hyperbolic Functions.
* csinhf: (libc)Hyperbolic Functions.
* csinhl: (libc)Hyperbolic Functions.
* csinl: (libc)Trig Functions.
* csqrt: (libc)Exponents and Logarithms.
* csqrtf: (libc)Exponents and Logarithms.
* csqrtl: (libc)Exponents and Logarithms.
* ctan: (libc)Trig Functions.
* ctanf: (libc)Trig Functions.
* ctanh: (libc)Hyperbolic Functions.
* ctanhf: (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.
* dcgettext: (libc)Translation with gettext.
* dcngettext: (libc)Advanced gettext functions.
* des_setparity: (libc)DES Encryption.
* dgettext: (libc)Translation with gettext.
* difftime: (libc)Elapsed Time.
* dirfd: (libc)Opening a Directory.
* dirname: (libc)Finding Tokens in a String.
* div: (libc)Integer Division.
* dngettext: (libc)Advanced gettext functions.
* drand48: (libc)SVID Random.
* drand48_r: (libc)SVID Random.
* drem: (libc)Remainder Functions.
* dremf: (libc)Remainder Functions.
* dreml: (libc)Remainder Functions.
* dup2: (libc)Duplicating Descriptors.
* dup: (libc)Duplicating Descriptors.
* ecb_crypt: (libc)DES Encryption.
* ecvt: (libc)System V Number Conversion.
* ecvt_r: (libc)System V Number Conversion.
* encrypt: (libc)DES Encryption.
* encrypt_r: (libc)DES Encryption.
* 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_strip: (libc)Envz Functions.
* erand48: (libc)SVID Random.
* erand48_r: (libc)SVID Random.
* erf: (libc)Special Functions.
* erfc: (libc)Special Functions.
* erfcf: (libc)Special Functions.
* erfcl: (libc)Special Functions.
* erff: (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.
* exp10l: (libc)Exponents and Logarithms.
* exp2: (libc)Exponents and Logarithms.
* exp2f: (libc)Exponents and Logarithms.
* exp2l: (libc)Exponents and Logarithms.
* exp: (libc)Exponents and Logarithms.
* expf: (libc)Exponents and Logarithms.
* expl: (libc)Exponents and Logarithms.
* expm1: (libc)Exponents and Logarithms.
* expm1f: (libc)Exponents and Logarithms.
* expm1l: (libc)Exponents and Logarithms.
* fabs: (libc)Absolute Value.
* fabsf: (libc)Absolute Value.
* fabsl: (libc)Absolute Value.
* 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.
* fdiml: (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.
* 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.
* fesetexceptflag: (libc)Status bit operations.
* fesetround: (libc)Rounding.
* fetestexcept: (libc)Status bit operations.
* feupdateenv: (libc)Control Functions.
* fflush: (libc)Flushing Buffers.
* fflush_unlocked: (libc)Flushing Buffers.
* 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.
* floorl: (libc)Rounding Functions.
* fma: (libc)Misc FP Arithmetic.
* fmaf: (libc)Misc FP Arithmetic.
* fmal: (libc)Misc FP Arithmetic.
* fmax: (libc)Misc FP Arithmetic.
* fmaxf: (libc)Misc FP Arithmetic.
* fmaxl: (libc)Misc FP Arithmetic.
* fmemopen: (libc)String Streams.
* fmin: (libc)Misc FP Arithmetic.
* fminf: (libc)Misc FP Arithmetic.
* fminl: (libc)Misc FP Arithmetic.
* fmod: (libc)Remainder Functions.
* fmodf: (libc)Remainder Functions.
* fmodl: (libc)Remainder Functions.
* fmtmsg: (libc)Printing Formatted Messages.
* 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.
* frexpl: (libc)Normalization 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.
* fstat64: (libc)Reading Attributes.
* fstat: (libc)Reading Attributes.
* 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.
* 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.
* getcwd: (libc)Working Directory.
* getdate: (libc)General Time String Parsing.
* getdate_r: (libc)General Time String Parsing.
* getdelim: (libc)Line Input.
* getdomainnname: (libc)Host Identification.
* getegid: (libc)Reading Persona.
* 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.
* 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.
* 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.
* gettimeofday: (libc)High-Resolution Calendar.
* 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.
* 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.
* 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.
* iscntrl: (libc)Classification of Characters.
* isdigit: (libc)Classification of Characters.
* 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.
* 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.
* j0: (libc)Special Functions.
* j0f: (libc)Special Functions.
* j0l: (libc)Special Functions.
* j1: (libc)Special Functions.
* j1f: (libc)Special Functions.
* j1l: (libc)Special Functions.
* jn: (libc)Special Functions.
* jnf: (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.
* 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.
* lgammaf_r: (libc)Special Functions.
* lgammal: (libc)Special Functions.
* lgammal_r: (libc)Special Functions.
* link: (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.
* llrint: (libc)Rounding Functions.
* llrintf: (libc)Rounding Functions.
* llrintl: (libc)Rounding Functions.
* llround: (libc)Rounding Functions.
* llroundf: (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.
* log10l: (libc)Exponents and Logarithms.
* log1p: (libc)Exponents and Logarithms.
* log1pf: (libc)Exponents and Logarithms.
* log1pl: (libc)Exponents and Logarithms.
* log2: (libc)Exponents and Logarithms.
* log2f: (libc)Exponents and Logarithms.
* log2l: (libc)Exponents and Logarithms.
* log: (libc)Exponents and Logarithms.
* logb: (libc)Exponents and Logarithms.
* logbf: (libc)Exponents and Logarithms.
* logbl: (libc)Exponents and Logarithms.
* logf: (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.
* 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.
* lrintl: (libc)Rounding Functions.
* lround: (libc)Rounding Functions.
* lroundf: (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.
* mallinfo: (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 and Concatenation.
* memchr: (libc)Search Functions.
* memcmp: (libc)String/Array Comparison.
* memcpy: (libc)Copying and Concatenation.
* memfrob: (libc)Trivial Encryption.
* memmem: (libc)Search Functions.
* memmove: (libc)Copying and Concatenation.
* mempcpy: (libc)Copying and Concatenation.
* memrchr: (libc)Search Functions.
* memset: (libc)Copying and Concatenation.
* mkdir: (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.
* 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.
* modfl: (libc)Rounding Functions.
* mount: (libc)Mount-Unmount-Remount.
* mprobe: (libc)Heap Consistency Checking.
* 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.
* 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.
* nanl: (libc)FP Bit Twiddling.
* nanosleep: (libc)Sleeping.
* nearbyint: (libc)Rounding Functions.
* nearbyintf: (libc)Rounding Functions.
* nearbyintl: (libc)Rounding Functions.
* nextafter: (libc)FP Bit Twiddling.
* nextafterf: (libc)FP Bit Twiddling.
* nextafterl: (libc)FP Bit Twiddling.
* nexttoward: (libc)FP Bit Twiddling.
* nexttowardf: (libc)FP Bit Twiddling.
* nexttowardl: (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)High Accuracy Clock.
* ntp_gettime: (libc)High Accuracy Clock.
* 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.
* 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.
* pipe: (libc)Creating a Pipe.
* popen: (libc)Pipe to a Subprocess.
* posix_memalign: (libc)Aligned Memory Blocks.
* pow10: (libc)Exponents and Logarithms.
* pow10f: (libc)Exponents and Logarithms.
* pow10l: (libc)Exponents and Logarithms.
* pow: (libc)Exponents and Logarithms.
* powf: (libc)Exponents and Logarithms.
* powl: (libc)Exponents and Logarithms.
* pread64: (libc)I/O Primitives.
* pread: (libc)I/O Primitives.
* printf: (libc)Formatted Output Functions.
* printf_size: (libc)Predefined Printf Handlers.
* printf_size_info: (libc)Predefined Printf Handlers.
* psignal: (libc)Signal Messages.
* pthread_getattr_default_np: (libc)Default Thread Attributes.
* pthread_getspecific: (libc)Thread-specific Data.
* pthread_key_create: (libc)Thread-specific Data.
* pthread_key_delete: (libc)Thread-specific Data.
* pthread_setattr_default_np: (libc)Default Thread Attributes.
* pthread_setspecific: (libc)Thread-specific Data.
* 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.
* 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.
* realpath: (libc)Symbolic Links.
* recv: (libc)Receiving Data.
* recvfrom: (libc)Receiving Datagrams.
* recvmsg: (libc)Receiving Datagrams.
* 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.
* remainderl: (libc)Remainder Functions.
* remove: (libc)Deleting Files.
* rename: (libc)Renaming Files.
* rewind: (libc)File Positioning.
* rewinddir: (libc)Random Access Directory.
* rindex: (libc)Search Functions.
* rint: (libc)Rounding Functions.
* rintf: (libc)Rounding Functions.
* rintl: (libc)Rounding Functions.
* rmdir: (libc)Deleting Files.
* round: (libc)Rounding Functions.
* roundf: (libc)Rounding Functions.
* roundl: (libc)Rounding Functions.
* rpmatch: (libc)Yes-or-No Questions.
* 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.
* scalblnl: (libc)Normalization Functions.
* scalbn: (libc)Normalization Functions.
* scalbnf: (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_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_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.
* send: (libc)Sending Data.
* sendmsg: (libc)Receiving Datagrams.
* 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.
* setkey: (libc)DES Encryption.
* setkey_r: (libc)DES Encryption.
* setlinebuf: (libc)Controlling Buffering.
* setlocale: (libc)Setting the Locale.
* setlogmask: (libc)setlogmask.
* setmntent: (libc)mtab.
* setnetent: (libc)Networks Database.
* setnetgrent: (libc)Lookup Netgroup.
* 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)High-Resolution Calendar.
* 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.
* sigaction: (libc)Advanced Signal Handling.
* sigaddset: (libc)Signal Sets.
* sigaltstack: (libc)Signal Stack.
* sigblock: (libc)Blocking in BSD.
* sigdelset: (libc)Signal Sets.
* sigemptyset: (libc)Signal Sets.
* sigfillset: (libc)Signal Sets.
* siginterrupt: (libc)BSD Handler.
* sigismember: (libc)Signal Sets.
* siglongjmp: (libc)Non-Local Exits and Signals.
* sigmask: (libc)Blocking in BSD.
* signal: (libc)Basic Signal Handling.
* signbit: (libc)FP Bit Twiddling.
* significand: (libc)Normalization Functions.
* significandf: (libc)Normalization Functions.
* significandl: (libc)Normalization Functions.
* sigpause: (libc)Blocking in BSD.
* sigpending: (libc)Checking for Pending Signals.
* sigprocmask: (libc)Process Signal Mask.
* sigsetjmp: (libc)Non-Local Exits and Signals.
* sigsetmask: (libc)Blocking in BSD.
* sigstack: (libc)Signal Stack.
* sigsuspend: (libc)Sigsuspend.
* sigvec: (libc)BSD Handler.
* sin: (libc)Trig Functions.
* sincos: (libc)Trig Functions.
* sincosf: (libc)Trig Functions.
* sincosl: (libc)Trig Functions.
* sinf: (libc)Trig Functions.
* sinh: (libc)Hyperbolic Functions.
* sinhf: (libc)Hyperbolic Functions.
* sinhl: (libc)Hyperbolic Functions.
* sinl: (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.
* 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.
* stime: (libc)Simple Calendar Time.
* stpcpy: (libc)Copying and Concatenation.
* stpncpy: (libc)Copying and Concatenation.
* strcasecmp: (libc)String/Array Comparison.
* strcasestr: (libc)Search Functions.
* strcat: (libc)Copying and Concatenation.
* strchr: (libc)Search Functions.
* strchrnul: (libc)Search Functions.
* strcmp: (libc)String/Array Comparison.
* strcoll: (libc)Collation Functions.
* strcpy: (libc)Copying and Concatenation.
* strcspn: (libc)Search Functions.
* strdup: (libc)Copying and Concatenation.
* strdupa: (libc)Copying and Concatenation.
* strerror: (libc)Error Messages.
* strerror_r: (libc)Error Messages.
* strfmon: (libc)Formatting Numbers.
* strfry: (libc)strfry.
* strftime: (libc)Formatting Calendar Time.
* strlen: (libc)String Length.
* strncasecmp: (libc)String/Array Comparison.
* strncat: (libc)Copying and Concatenation.
* strncmp: (libc)String/Array Comparison.
* strncpy: (libc)Copying and Concatenation.
* strndup: (libc)Copying and Concatenation.
* strndupa: (libc)Copying and Concatenation.
* 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.
* 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.
* sysctl: (libc)System Parameters.
* syslog: (libc)syslog; vsyslog.
* system: (libc)Running a Command.
* sysv_signal: (libc)Basic Signal Handling.
* tan: (libc)Trig Functions.
* tanf: (libc)Trig Functions.
* tanh: (libc)Hyperbolic Functions.
* tanhf: (libc)Hyperbolic Functions.
* tanhl: (libc)Hyperbolic Functions.
* tanl: (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.
* tgammal: (libc)Special Functions.
* time: (libc)Simple Calendar Time.
* timegm: (libc)Broken-down Time.
* timelocal: (libc)Broken-down Time.
* times: (libc)Processor 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.
* 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.
* truncl: (libc)Rounding Functions.
* tsearch: (libc)Tree Search Function.
* ttyname: (libc)Is It a Terminal.
* ttyname_r: (libc)Is It a Terminal.
* twalk: (libc)Tree Search Function.
* tzset: (libc)Time Zone Functions.
* ulimit: (libc)Limits on Resources.
* 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.
* unlockpt: (libc)Allocation.
* unsetenv: (libc)Environment Access.
* updwtmp: (libc)Manipulating the Database.
* utime: (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.
* 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.
* vtimes: (libc)Resource Usage.
* 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 and Concatenation.
* wcpncpy: (libc)Copying and Concatenation.
* wcrtomb: (libc)Converting a Character.
* wcscasecmp: (libc)String/Array Comparison.
* wcscat: (libc)Copying and Concatenation.
* wcschr: (libc)Search Functions.
* wcschrnul: (libc)Search Functions.
* wcscmp: (libc)String/Array Comparison.
* wcscoll: (libc)Collation Functions.
* wcscpy: (libc)Copying and Concatenation.
* wcscspn: (libc)Search Functions.
* wcsdup: (libc)Copying and Concatenation.
* wcsftime: (libc)Formatting Calendar Time.
* wcslen: (libc)String Length.
* wcsncasecmp: (libc)String/Array Comparison.
* wcsncat: (libc)Copying and Concatenation.
* wcsncmp: (libc)String/Array Comparison.
* wcsncpy: (libc)Copying and Concatenation.
* 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.
* 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 and Concatenation.
* wmemmove: (libc)Copying and Concatenation.
* wmempcpy: (libc)Copying and Concatenation.
* wmemset: (libc)Copying and Concatenation.
* 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.
* y0l: (libc)Special Functions.
* y1: (libc)Special Functions.
* y1f: (libc)Special Functions.
* y1l: (libc)Special Functions.
* yn: (libc)Special Functions.
* ynf: (libc)Special Functions.
* ynl: (libc)Special Functions.
END-INFO-DIR-ENTRY

File: libc.info, Node: Obstack Functions, Next: Growing Objects, Prev: Freeing Obstack Objects, Up: Obstacks
3.2.4.5 Obstack Functions and Macros
....................................
The interfaces for using obstacks may be defined either as functions or
as macros, depending on the compiler. The obstack facility works with
all C compilers, including both ISO C and traditional C, but there are
precautions you must take if you plan to use compilers other than GNU C.
If you are using an old-fashioned non-ISO C compiler, all the obstack
"functions" are actually defined only as macros. You can call these
macros like functions, but you cannot use them in any other way (for
example, you cannot take their address).
Calling the macros requires a special precaution: namely, the first
operand (the obstack pointer) may not contain any side effects, because
it may be computed more than once. For example, if you write this:
obstack_alloc (get_obstack (), 4);
you will find that 'get_obstack' may be called several times. If you
use '*obstack_list_ptr++' as the obstack pointer argument, you will get
very strange results since the incrementation may occur several times.
In ISO C, each function has both a macro definition and a function
definition. The function definition is used if you take the address of
the function without calling it. An ordinary call uses the macro
definition by default, but you can request the function definition
instead by writing the function name in parentheses, as shown here:
char *x;
void *(*funcp) ();
/* Use the macro. */
x = (char *) obstack_alloc (obptr, size);
/* Call the function. */
x = (char *) (obstack_alloc) (obptr, size);
/* Take the address of the function. */
funcp = obstack_alloc;
This is the same situation that exists in ISO C for the standard library
functions. *Note Macro Definitions::.
*Warning:* When you do use the macros, you must observe the
precaution of avoiding side effects in the first operand, even in ISO C.
If you use the GNU C compiler, this precaution is not necessary,
because various language extensions in GNU C permit defining the macros
so as to compute each argument only once.

File: libc.info, Node: Growing Objects, Next: Extra Fast Growing, Prev: Obstack Functions, Up: Obstacks
3.2.4.6 Growing Objects
.......................
Because memory in obstack chunks is used sequentially, it is possible to
build up an object step by step, adding one or more bytes at a time to
the end of the object. With this technique, you do not need to know how
much data you will put in the object until you come to the end of it.
We call this the technique of "growing objects". The special functions
for adding data to the growing object are described in this section.
You don't need to do anything special when you start to grow an
object. Using one of the functions to add data to the object
automatically starts it. However, it is necessary to say explicitly
when the object is finished. This is done with the function
'obstack_finish'.
The actual address of the object thus built up is not known until the
object is finished. Until then, it always remains possible that you
will add so much data that the object must be copied into a new chunk.
While the obstack is in use for a growing object, you cannot use it
for ordinary allocation of another object. If you try to do so, the
space already added to the growing object will become part of the other
object.
-- Function: void obstack_blank (struct obstack *OBSTACK-PTR, int SIZE)
Preliminary: | MT-Safe race:obstack-ptr | AS-Safe | AC-Unsafe
corrupt mem | *Note POSIX Safety Concepts::.
The most basic function for adding to a growing object is
'obstack_blank', which adds space without initializing it.
-- Function: void obstack_grow (struct obstack *OBSTACK-PTR, void
*DATA, int SIZE)
Preliminary: | MT-Safe race:obstack-ptr | AS-Safe | AC-Unsafe
corrupt mem | *Note POSIX Safety Concepts::.
To add a block of initialized space, use 'obstack_grow', which is
the growing-object analogue of 'obstack_copy'. It adds SIZE bytes
of data to the growing object, copying the contents from DATA.
-- Function: void obstack_grow0 (struct obstack *OBSTACK-PTR, void
*DATA, int SIZE)
Preliminary: | MT-Safe race:obstack-ptr | AS-Safe | AC-Unsafe
corrupt mem | *Note POSIX Safety Concepts::.
This is the growing-object analogue of 'obstack_copy0'. It adds
SIZE bytes copied from DATA, followed by an additional null
character.
-- Function: void obstack_1grow (struct obstack *OBSTACK-PTR, char C)
Preliminary: | MT-Safe race:obstack-ptr | AS-Safe | AC-Unsafe
corrupt mem | *Note POSIX Safety Concepts::.
To add one character at a time, use the function 'obstack_1grow'.
It adds a single byte containing C to the growing object.
-- Function: void obstack_ptr_grow (struct obstack *OBSTACK-PTR, void
*DATA)
Preliminary: | MT-Safe race:obstack-ptr | AS-Safe | AC-Unsafe
corrupt mem | *Note POSIX Safety Concepts::.
Adding the value of a pointer one can use the function
'obstack_ptr_grow'. It adds 'sizeof (void *)' bytes containing the
value of DATA.
-- Function: void obstack_int_grow (struct obstack *OBSTACK-PTR, int
DATA)
Preliminary: | MT-Safe race:obstack-ptr | AS-Safe | AC-Unsafe
corrupt mem | *Note POSIX Safety Concepts::.
A single value of type 'int' can be added by using the
'obstack_int_grow' function. It adds 'sizeof (int)' bytes to the
growing object and initializes them with the value of DATA.
-- Function: void * obstack_finish (struct obstack *OBSTACK-PTR)
Preliminary: | MT-Safe race:obstack-ptr | AS-Safe | AC-Unsafe
corrupt | *Note POSIX Safety Concepts::.
When you are finished growing the object, use the function
'obstack_finish' to close it off and return its final address.
Once you have finished the object, the obstack is available for
ordinary allocation or for growing another object.
This function can return a null pointer under the same conditions
as 'obstack_alloc' (*note Allocation in an Obstack::).
When you build an object by growing it, you will probably need to
know afterward how long it became. You need not keep track of this as
you grow the object, because you can find out the length from the
obstack just before finishing the object with the function
'obstack_object_size', declared as follows:
-- Function: int obstack_object_size (struct obstack *OBSTACK-PTR)
Preliminary: | MT-Safe race:obstack-ptr | AS-Safe | AC-Safe | *Note
POSIX Safety Concepts::.
This function returns the current size of the growing object, in
bytes. Remember to call this function _before_ finishing the
object. After it is finished, 'obstack_object_size' will return
zero.
If you have started growing an object and wish to cancel it, you
should finish it and then free it, like this:
obstack_free (obstack_ptr, obstack_finish (obstack_ptr));
This has no effect if no object was growing.
You can use 'obstack_blank' with a negative size argument to make the
current object smaller. Just don't try to shrink it beyond zero
length--there's no telling what will happen if you do that.

File: libc.info, Node: Extra Fast Growing, Next: Status of an Obstack, Prev: Growing Objects, Up: Obstacks
3.2.4.7 Extra Fast Growing Objects
..................................
The usual functions for growing objects incur overhead for checking
whether there is room for the new growth in the current chunk. If you
are frequently constructing objects in small steps of growth, this
overhead can be significant.
You can reduce the overhead by using special "fast growth" functions
that grow the object without checking. In order to have a robust
program, you must do the checking yourself. If you do this checking in
the simplest way each time you are about to add data to the object, you
have not saved anything, because that is what the ordinary growth
functions do. But if you can arrange to check less often, or check more
efficiently, then you make the program faster.
The function 'obstack_room' returns the amount of room available in
the current chunk. It is declared as follows:
-- Function: int obstack_room (struct obstack *OBSTACK-PTR)
Preliminary: | MT-Safe race:obstack-ptr | AS-Safe | AC-Safe | *Note
POSIX Safety Concepts::.
This returns the number of bytes that can be added safely to the
current growing object (or to an object about to be started) in
obstack OBSTACK using the fast growth functions.
While you know there is room, you can use these fast growth functions
for adding data to a growing object:
-- Function: void obstack_1grow_fast (struct obstack *OBSTACK-PTR, char
C)
Preliminary: | MT-Safe race:obstack-ptr | AS-Safe | AC-Unsafe
corrupt mem | *Note POSIX Safety Concepts::.
The function 'obstack_1grow_fast' adds one byte containing the
character C to the growing object in obstack OBSTACK-PTR.
-- Function: void obstack_ptr_grow_fast (struct obstack *OBSTACK-PTR,
void *DATA)
Preliminary: | MT-Safe race:obstack-ptr | AS-Safe | AC-Safe | *Note
POSIX Safety Concepts::.
The function 'obstack_ptr_grow_fast' adds 'sizeof (void *)' bytes
containing the value of DATA to the growing object in obstack
OBSTACK-PTR.
-- Function: void obstack_int_grow_fast (struct obstack *OBSTACK-PTR,
int DATA)
Preliminary: | MT-Safe race:obstack-ptr | AS-Safe | AC-Safe | *Note
POSIX Safety Concepts::.
The function 'obstack_int_grow_fast' adds 'sizeof (int)' bytes
containing the value of DATA to the growing object in obstack
OBSTACK-PTR.
-- Function: void obstack_blank_fast (struct obstack *OBSTACK-PTR, int
SIZE)
Preliminary: | MT-Safe race:obstack-ptr | AS-Safe | AC-Safe | *Note
POSIX Safety Concepts::.
The function 'obstack_blank_fast' adds SIZE bytes to the growing
object in obstack OBSTACK-PTR without initializing them.
When you check for space using 'obstack_room' and there is not enough
room for what you want to add, the fast growth functions are not safe.
In this case, simply use the corresponding ordinary growth function
instead. Very soon this will copy the object to a new chunk; then there
will be lots of room available again.
So, each time you use an ordinary growth function, check afterward
for sufficient space using 'obstack_room'. Once the object is copied to
a new chunk, there will be plenty of space again, so the program will
start using the fast growth functions again.
Here is an example:
void
add_string (struct obstack *obstack, const char *ptr, int len)
{
while (len > 0)
{
int room = obstack_room (obstack);
if (room == 0)
{
/* Not enough room. Add one character slowly,
which may copy to a new chunk and make room. */
obstack_1grow (obstack, *ptr++);
len--;
}
else
{
if (room > len)
room = len;
/* Add fast as much as we have room for. */
len -= room;
while (room-- > 0)
obstack_1grow_fast (obstack, *ptr++);
}
}
}

File: libc.info, Node: Status of an Obstack, Next: Obstacks Data Alignment, Prev: Extra Fast Growing, Up: Obstacks
3.2.4.8 Status of an Obstack
............................
Here are functions that provide information on the current status of
allocation in an obstack. You can use them to learn about an object
while still growing it.
-- Function: void * obstack_base (struct obstack *OBSTACK-PTR)
Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Safe | *Note POSIX
Safety Concepts::.
This function returns the tentative address of the beginning of the
currently growing object in OBSTACK-PTR. If you finish the object
immediately, it will have that address. If you make it larger
first, it may outgrow the current chunk--then its address will
change!
If no object is growing, this value says where the next object you
allocate will start (once again assuming it fits in the current
chunk).
-- Function: void * obstack_next_free (struct obstack *OBSTACK-PTR)
Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Safe | *Note POSIX
Safety Concepts::.
This function returns the address of the first free byte in the
current chunk of obstack OBSTACK-PTR. This is the end of the
currently growing object. If no object is growing,
'obstack_next_free' returns the same value as 'obstack_base'.
-- Function: int obstack_object_size (struct obstack *OBSTACK-PTR)
Preliminary: | MT-Safe race:obstack-ptr | AS-Safe | AC-Safe | *Note
POSIX Safety Concepts::.
This function returns the size in bytes of the currently growing
object. This is equivalent to
obstack_next_free (OBSTACK-PTR) - obstack_base (OBSTACK-PTR)

File: libc.info, Node: Obstacks Data Alignment, Next: Obstack Chunks, Prev: Status of an Obstack, Up: Obstacks
3.2.4.9 Alignment of Data in Obstacks
.....................................
Each obstack has an "alignment boundary"; each object allocated in the
obstack automatically starts on an address that is a multiple of the
specified boundary. By default, this boundary is aligned so that the
object can hold any type of data.
To access an obstack's alignment boundary, use the macro
'obstack_alignment_mask', whose function prototype looks like this:
-- Macro: int obstack_alignment_mask (struct obstack *OBSTACK-PTR)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
The value is a bit mask; a bit that is 1 indicates that the
corresponding bit in the address of an object should be 0. The
mask value should be one less than a power of 2; the effect is that
all object addresses are multiples of that power of 2. The default
value of the mask is a value that allows aligned objects to hold
any type of data: for example, if its value is 3, any type of data
can be stored at locations whose addresses are multiples of 4. A
mask value of 0 means an object can start on any multiple of 1
(that is, no alignment is required).
The expansion of the macro 'obstack_alignment_mask' is an lvalue,
so you can alter the mask by assignment. For example, this
statement:
obstack_alignment_mask (obstack_ptr) = 0;
has the effect of turning off alignment processing in the specified
obstack.
Note that a change in alignment mask does not take effect until
_after_ the next time an object is allocated or finished in the obstack.
If you are not growing an object, you can make the new alignment mask
take effect immediately by calling 'obstack_finish'. This will finish a
zero-length object and then do proper alignment for the next object.

File: libc.info, Node: Obstack Chunks, Next: Summary of Obstacks, Prev: Obstacks Data Alignment, Up: Obstacks
3.2.4.10 Obstack Chunks
.......................
Obstacks work by allocating space for themselves in large chunks, and
then parceling out space in the chunks to satisfy your requests. Chunks
are normally 4096 bytes long unless you specify a different chunk size.
The chunk size includes 8 bytes of overhead that are not actually used
for storing objects. Regardless of the specified size, longer chunks
will be allocated when necessary for long objects.
The obstack library allocates chunks by calling the function
'obstack_chunk_alloc', which you must define. When a chunk is no longer
needed because you have freed all the objects in it, the obstack library
frees the chunk by calling 'obstack_chunk_free', which you must also
define.
These two must be defined (as macros) or declared (as functions) in
each source file that uses 'obstack_init' (*note Creating Obstacks::).
Most often they are defined as macros like this:
#define obstack_chunk_alloc malloc
#define obstack_chunk_free free
Note that these are simple macros (no arguments). Macro definitions
with arguments will not work! It is necessary that
'obstack_chunk_alloc' or 'obstack_chunk_free', alone, expand into a
function name if it is not itself a function name.
If you allocate chunks with 'malloc', the chunk size should be a
power of 2. The default chunk size, 4096, was chosen because it is long
enough to satisfy many typical requests on the obstack yet short enough
not to waste too much memory in the portion of the last chunk not yet
used.
-- Macro: int obstack_chunk_size (struct obstack *OBSTACK-PTR)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
This returns the chunk size of the given obstack.
Since this macro expands to an lvalue, you can specify a new chunk
size by assigning it a new value. Doing so does not affect the chunks
already allocated, but will change the size of chunks allocated for that
particular obstack in the future. It is unlikely to be useful to make
the chunk size smaller, but making it larger might improve efficiency if
you are allocating many objects whose size is comparable to the chunk
size. Here is how to do so cleanly:
if (obstack_chunk_size (obstack_ptr) < NEW-CHUNK-SIZE)
obstack_chunk_size (obstack_ptr) = NEW-CHUNK-SIZE;

File: libc.info, Node: Summary of Obstacks, Prev: Obstack Chunks, Up: Obstacks
3.2.4.11 Summary of Obstack Functions
.....................................
Here is a summary of all the functions associated with obstacks. Each
takes the address of an obstack ('struct obstack *') as its first
argument.
'void obstack_init (struct obstack *OBSTACK-PTR)'
Initialize use of an obstack. *Note Creating Obstacks::.
'void *obstack_alloc (struct obstack *OBSTACK-PTR, int SIZE)'
Allocate an object of SIZE uninitialized bytes. *Note Allocation
in an Obstack::.
'void *obstack_copy (struct obstack *OBSTACK-PTR, void *ADDRESS, int SIZE)'
Allocate an object of SIZE bytes, with contents copied from
ADDRESS. *Note Allocation in an Obstack::.
'void *obstack_copy0 (struct obstack *OBSTACK-PTR, void *ADDRESS, int SIZE)'
Allocate an object of SIZE+1 bytes, with SIZE of them copied from
ADDRESS, followed by a null character at the end. *Note Allocation
in an Obstack::.
'void obstack_free (struct obstack *OBSTACK-PTR, void *OBJECT)'
Free OBJECT (and everything allocated in the specified obstack more
recently than OBJECT). *Note Freeing Obstack Objects::.
'void obstack_blank (struct obstack *OBSTACK-PTR, int SIZE)'
Add SIZE uninitialized bytes to a growing object. *Note Growing
Objects::.
'void obstack_grow (struct obstack *OBSTACK-PTR, void *ADDRESS, int SIZE)'
Add SIZE bytes, copied from ADDRESS, to a growing object. *Note
Growing Objects::.
'void obstack_grow0 (struct obstack *OBSTACK-PTR, void *ADDRESS, int SIZE)'
Add SIZE bytes, copied from ADDRESS, to a growing object, and then
add another byte containing a null character. *Note Growing
Objects::.
'void obstack_1grow (struct obstack *OBSTACK-PTR, char DATA-CHAR)'
Add one byte containing DATA-CHAR to a growing object. *Note
Growing Objects::.
'void *obstack_finish (struct obstack *OBSTACK-PTR)'
Finalize the object that is growing and return its permanent
address. *Note Growing Objects::.
'int obstack_object_size (struct obstack *OBSTACK-PTR)'
Get the current size of the currently growing object. *Note
Growing Objects::.
'void obstack_blank_fast (struct obstack *OBSTACK-PTR, int SIZE)'
Add SIZE uninitialized bytes to a growing object without checking
that there is enough room. *Note Extra Fast Growing::.
'void obstack_1grow_fast (struct obstack *OBSTACK-PTR, char DATA-CHAR)'
Add one byte containing DATA-CHAR to a growing object without
checking that there is enough room. *Note Extra Fast Growing::.
'int obstack_room (struct obstack *OBSTACK-PTR)'
Get the amount of room now available for growing the current
object. *Note Extra Fast Growing::.
'int obstack_alignment_mask (struct obstack *OBSTACK-PTR)'
The mask used for aligning the beginning of an object. This is an
lvalue. *Note Obstacks Data Alignment::.
'int obstack_chunk_size (struct obstack *OBSTACK-PTR)'
The size for allocating chunks. This is an lvalue. *Note Obstack
Chunks::.
'void *obstack_base (struct obstack *OBSTACK-PTR)'
Tentative starting address of the currently growing object. *Note
Status of an Obstack::.
'void *obstack_next_free (struct obstack *OBSTACK-PTR)'
Address just after the end of the currently growing object. *Note
Status of an Obstack::.

File: libc.info, Node: Variable Size Automatic, Prev: Obstacks, Up: Memory Allocation
3.2.5 Automatic Storage with Variable Size
------------------------------------------
The function 'alloca' supports a kind of half-dynamic allocation in
which blocks are allocated dynamically but freed automatically.
Allocating a block with 'alloca' is an explicit action; you can
allocate as many blocks as you wish, and compute the size at run time.
But all the blocks are freed when you exit the function that 'alloca'
was called from, just as if they were automatic variables declared in
that function. There is no way to free the space explicitly.
The prototype for 'alloca' is in 'stdlib.h'. This function is a BSD
extension.
-- Function: void * alloca (size_t SIZE)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
The return value of 'alloca' is the address of a block of SIZE
bytes of memory, allocated in the stack frame of the calling
function.
Do not use 'alloca' inside the arguments of a function call--you will
get unpredictable results, because the stack space for the 'alloca'
would appear on the stack in the middle of the space for the function
arguments. An example of what to avoid is 'foo (x, alloca (4), y)'.
* Menu:
* Alloca Example:: Example of using 'alloca'.
* Advantages of Alloca:: Reasons to use 'alloca'.
* Disadvantages of Alloca:: Reasons to avoid 'alloca'.
* GNU C Variable-Size Arrays:: Only in GNU C, here is an alternative
method of allocating dynamically and
freeing automatically.

File: libc.info, Node: Alloca Example, Next: Advantages of Alloca, Up: Variable Size Automatic
3.2.5.1 'alloca' Example
........................
As an example of the use of 'alloca', here is a function that opens a
file name made from concatenating two argument strings, and returns a
file descriptor or minus one signifying failure:
int
open2 (char *str1, char *str2, int flags, int mode)
{
char *name = (char *) alloca (strlen (str1) + strlen (str2) + 1);
stpcpy (stpcpy (name, str1), str2);
return open (name, flags, mode);
}
Here is how you would get the same results with 'malloc' and 'free':
int
open2 (char *str1, char *str2, int flags, int mode)
{
char *name = (char *) malloc (strlen (str1) + strlen (str2) + 1);
int desc;
if (name == 0)
fatal ("virtual memory exceeded");
stpcpy (stpcpy (name, str1), str2);
desc = open (name, flags, mode);
free (name);
return desc;
}
As you can see, it is simpler with 'alloca'. But 'alloca' has other,
more important advantages, and some disadvantages.

File: libc.info, Node: Advantages of Alloca, Next: Disadvantages of Alloca, Prev: Alloca Example, Up: Variable Size Automatic
3.2.5.2 Advantages of 'alloca'
..............................
Here are the reasons why 'alloca' may be preferable to 'malloc':
* Using 'alloca' wastes very little space and is very fast. (It is
open-coded by the GNU C compiler.)
* Since 'alloca' does not have separate pools for different sizes of
block, space used for any size block can be reused for any other
size. 'alloca' does not cause memory fragmentation.
* Nonlocal exits done with 'longjmp' (*note Non-Local Exits::)
automatically free the space allocated with 'alloca' when they exit
through the function that called 'alloca'. This is the most
important reason to use 'alloca'.
To illustrate this, suppose you have a function
'open_or_report_error' which returns a descriptor, like 'open', if
it succeeds, but does not return to its caller if it fails. If the
file cannot be opened, it prints an error message and jumps out to
the command level of your program using 'longjmp'. Let's change
'open2' (*note Alloca Example::) to use this subroutine:
int
open2 (char *str1, char *str2, int flags, int mode)
{
char *name = (char *) alloca (strlen (str1) + strlen (str2) + 1);
stpcpy (stpcpy (name, str1), str2);
return open_or_report_error (name, flags, mode);
}
Because of the way 'alloca' works, the memory it allocates is freed
even when an error occurs, with no special effort required.
By contrast, the previous definition of 'open2' (which uses
'malloc' and 'free') would develop a memory leak if it were changed
in this way. Even if you are willing to make more changes to fix
it, there is no easy way to do so.

File: libc.info, Node: Disadvantages of Alloca, Next: GNU C Variable-Size Arrays, Prev: Advantages of Alloca, Up: Variable Size Automatic
3.2.5.3 Disadvantages of 'alloca'
.................................
These are the disadvantages of 'alloca' in comparison with 'malloc':
* If you try to allocate more memory than the machine can provide,
you don't get a clean error message. Instead you get a fatal
signal like the one you would get from an infinite recursion;
probably a segmentation violation (*note Program Error Signals::).
* Some non-GNU systems fail to support 'alloca', so it is less
portable. However, a slower emulation of 'alloca' written in C is
available for use on systems with this deficiency.

File: libc.info, Node: GNU C Variable-Size Arrays, Prev: Disadvantages of Alloca, Up: Variable Size Automatic
3.2.5.4 GNU C Variable-Size Arrays
..................................
In GNU C, you can replace most uses of 'alloca' with an array of
variable size. Here is how 'open2' would look then:
int open2 (char *str1, char *str2, int flags, int mode)
{
char name[strlen (str1) + strlen (str2) + 1];
stpcpy (stpcpy (name, str1), str2);
return open (name, flags, mode);
}
But 'alloca' is not always equivalent to a variable-sized array, for
several reasons:
* A variable size array's space is freed at the end of the scope of
the name of the array. The space allocated with 'alloca' remains
until the end of the function.
* It is possible to use 'alloca' within a loop, allocating an
additional block on each iteration. This is impossible with
variable-sized arrays.
*NB:* If you mix use of 'alloca' and variable-sized arrays within one
function, exiting a scope in which a variable-sized array was declared
frees all blocks allocated with 'alloca' during the execution of that
scope.

File: libc.info, Node: Resizing the Data Segment, Next: Locking Pages, Prev: Memory Allocation, Up: Memory
3.3 Resizing the Data Segment
=============================
The symbols in this section are declared in 'unistd.h'.
You will not normally use the functions in this section, because the
functions described in *note Memory Allocation:: are easier to use.
Those are interfaces to a GNU C Library memory allocator that uses the
functions below itself. The functions below are simple interfaces to
system calls.
-- Function: int brk (void *ADDR)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
'brk' sets the high end of the calling process' data segment to
ADDR.
The address of the end of a segment is defined to be the address of
the last byte in the segment plus 1.
The function has no effect if ADDR is lower than the low end of the
data segment. (This is considered success, by the way).
The function fails if it would cause the data segment to overlap
another segment or exceed the process' data storage limit (*note
Limits on Resources::).
The function is named for a common historical case where data
storage and the stack are in the same segment. Data storage
allocation grows upward from the bottom of the segment while the
stack grows downward toward it from the top of the segment and the
curtain between them is called the "break".
The return value is zero on success. On failure, the return value
is '-1' and 'errno' is set accordingly. The following 'errno'
values are specific to this function:
'ENOMEM'
The request would cause the data segment to overlap another
segment or exceed the process' data storage limit.
-- Function: void *sbrk (ptrdiff_t DELTA)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
This function is the same as 'brk' except that you specify the new
end of the data segment as an offset DELTA from the current end and
on success the return value is the address of the resulting end of
the data segment instead of zero.
This means you can use 'sbrk(0)' to find out what the current end
of the data segment is.

File: libc.info, Node: Locking Pages, Prev: Resizing the Data Segment, Up: Memory
3.4 Locking Pages
=================
You can tell the system to associate a particular virtual memory page
with a real page frame and keep it that way -- i.e., cause the page to
be paged in if it isn't already and mark it so it will never be paged
out and consequently will never cause a page fault. This is called
"locking" a page.
The functions in this chapter lock and unlock the calling process'
pages.
* Menu:
* Why Lock Pages:: Reasons to read this section.
* Locked Memory Details:: Everything you need to know locked
memory
* Page Lock Functions:: Here's how to do it.

File: libc.info, Node: Why Lock Pages, Next: Locked Memory Details, Up: Locking Pages
3.4.1 Why Lock Pages
--------------------
Because page faults cause paged out pages to be paged in transparently,
a process rarely needs to be concerned about locking pages. However,
there are two reasons people sometimes are:
* Speed. A page fault is transparent only insofar as the process is
not sensitive to how long it takes to do a simple memory access.
Time-critical processes, especially realtime processes, may not be
able to wait or may not be able to tolerate variance in execution
speed.
A process that needs to lock pages for this reason probably also
needs priority among other processes for use of the CPU. *Note
Priority::.
In some cases, the programmer knows better than the system's demand
paging allocator which pages should remain in real memory to
optimize system performance. In this case, locking pages can help.
* Privacy. If you keep secrets in virtual memory and that virtual
memory gets paged out, that increases the chance that the secrets
will get out. If a password gets written out to disk swap space,
for example, it might still be there long after virtual and real
memory have been wiped clean.
Be aware that when you lock a page, that's one fewer page frame that
can be used to back other virtual memory (by the same or other
processes), which can mean more page faults, which means the system runs
more slowly. In fact, if you lock enough memory, some programs may not
be able to run at all for lack of real memory.

File: libc.info, Node: Locked Memory Details, Next: Page Lock Functions, Prev: Why Lock Pages, Up: Locking Pages
3.4.2 Locked Memory Details
---------------------------
A memory lock is associated with a virtual page, not a real frame. The
paging rule is: If a frame backs at least one locked page, don't page it
out.
Memory locks do not stack. I.e., you can't lock a particular page
twice so that it has to be unlocked twice before it is truly unlocked.
It is either locked or it isn't.
A memory lock persists until the process that owns the memory
explicitly unlocks it. (But process termination and exec cause the
virtual memory to cease to exist, which you might say means it isn't
locked any more).
Memory locks are not inherited by child processes. (But note that on
a modern Unix system, immediately after a fork, the parent's and the
child's virtual address space are backed by the same real page frames,
so the child enjoys the parent's locks). *Note Creating a Process::.
Because of its ability to impact other processes, only the superuser
can lock a page. Any process can unlock its own page.
The system sets limits on the amount of memory a process can have
locked and the amount of real memory it can have dedicated to it. *Note
Limits on Resources::.
In Linux, locked pages aren't as locked as you might think. Two
virtual pages that are not shared memory can nonetheless be backed by
the same real frame. The kernel does this in the name of efficiency
when it knows both virtual pages contain identical data, and does it
even if one or both of the virtual pages are locked.
But when a process modifies one of those pages, the kernel must get
it a separate frame and fill it with the page's data. This is known as
a "copy-on-write page fault". It takes a small amount of time and in a
pathological case, getting that frame may require I/O.
To make sure this doesn't happen to your program, don't just lock the
pages. Write to them as well, unless you know you won't write to them
ever. And to make sure you have pre-allocated frames for your stack,
enter a scope that declares a C automatic variable larger than the
maximum stack size you will need, set it to something, then return from
its scope.

File: libc.info, Node: Page Lock Functions, Prev: Locked Memory Details, Up: Locking Pages
3.4.3 Functions To Lock And Unlock Pages
----------------------------------------
The symbols in this section are declared in 'sys/mman.h'. These
functions are defined by POSIX.1b, but their availability depends on
your kernel. If your kernel doesn't allow these functions, they exist
but always fail. They _are_ available with a Linux kernel.
*Portability Note:* POSIX.1b requires that when the 'mlock' and
'munlock' functions are available, the file 'unistd.h' define the macro
'_POSIX_MEMLOCK_RANGE' and the file 'limits.h' define the macro
'PAGESIZE' to be the size of a memory page in bytes. It requires that
when the 'mlockall' and 'munlockall' functions are available, the
'unistd.h' file define the macro '_POSIX_MEMLOCK'. The GNU C Library
conforms to this requirement.
-- Function: int mlock (const void *ADDR, size_t LEN)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
'mlock' locks a range of the calling process' virtual pages.
The range of memory starts at address ADDR and is LEN bytes long.
Actually, since you must lock whole pages, it is the range of pages
that include any part of the specified range.
When the function returns successfully, each of those pages is
backed by (connected to) a real frame (is resident) and is marked
to stay that way. This means the function may cause page-ins and
have to wait for them.
When the function fails, it does not affect the lock status of any
pages.
The return value is zero if the function succeeds. Otherwise, it
is '-1' and 'errno' is set accordingly. 'errno' values specific to
this function are:
'ENOMEM'
* At least some of the specified address range does not
exist in the calling process' virtual address space.
* The locking would cause the process to exceed its locked
page limit.
'EPERM'
The calling process is not superuser.
'EINVAL'
LEN is not positive.
'ENOSYS'
The kernel does not provide 'mlock' capability.
You can lock _all_ a process' memory with 'mlockall'. You unlock
memory with 'munlock' or 'munlockall'.
To avoid all page faults in a C program, you have to use
'mlockall', because some of the memory a program uses is hidden
from the C code, e.g. the stack and automatic variables, and you
wouldn't know what address to tell 'mlock'.
-- Function: int munlock (const void *ADDR, size_t LEN)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
'munlock' unlocks a range of the calling process' virtual pages.
'munlock' is the inverse of 'mlock' and functions completely
analogously to 'mlock', except that there is no 'EPERM' failure.
-- Function: int mlockall (int FLAGS)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
'mlockall' locks all the pages in a process' virtual memory address
space, and/or any that are added to it in the future. This
includes the pages of the code, data and stack segment, as well as
shared libraries, user space kernel data, shared memory, and memory
mapped files.
FLAGS is a string of single bit flags represented by the following
macros. They tell 'mlockall' which of its functions you want. All
other bits must be zero.
'MCL_CURRENT'
Lock all pages which currently exist in the calling process'
virtual address space.
'MCL_FUTURE'
Set a mode such that any pages added to the process' virtual
address space in the future will be locked from birth. This
mode does not affect future address spaces owned by the same
process so exec, which replaces a process' address space,
wipes out 'MCL_FUTURE'. *Note Executing a File::.
When the function returns successfully, and you specified
'MCL_CURRENT', all of the process' pages are backed by (connected
to) real frames (they are resident) and are marked to stay that
way. This means the function may cause page-ins and have to wait
for them.
When the process is in 'MCL_FUTURE' mode because it successfully
executed this function and specified 'MCL_CURRENT', any system call
by the process that requires space be added to its virtual address
space fails with 'errno' = 'ENOMEM' if locking the additional space
would cause the process to exceed its locked page limit. In the
case that the address space addition that can't be accommodated is
stack expansion, the stack expansion fails and the kernel sends a
'SIGSEGV' signal to the process.
When the function fails, it does not affect the lock status of any
pages or the future locking mode.
The return value is zero if the function succeeds. Otherwise, it
is '-1' and 'errno' is set accordingly. 'errno' values specific to
this function are:
'ENOMEM'
* At least some of the specified address range does not
exist in the calling process' virtual address space.
* The locking would cause the process to exceed its locked
page limit.
'EPERM'
The calling process is not superuser.
'EINVAL'
Undefined bits in FLAGS are not zero.
'ENOSYS'
The kernel does not provide 'mlockall' capability.
You can lock just specific pages with 'mlock'. You unlock pages
with 'munlockall' and 'munlock'.
-- Function: int munlockall (void)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
'munlockall' unlocks every page in the calling process' virtual
address space and turn off 'MCL_FUTURE' future locking mode.
The return value is zero if the function succeeds. Otherwise, it
is '-1' and 'errno' is set accordingly. The only way this function
can fail is for generic reasons that all functions and system calls
can fail, so there are no specific 'errno' values.

File: libc.info, Node: Character Handling, Next: String and Array Utilities, Prev: Memory, Up: Top
4 Character Handling
********************
Programs that work with characters and strings often need to classify a
character--is it alphabetic, is it a digit, is it whitespace, and so
on--and perform case conversion operations on characters. The functions
in the header file 'ctype.h' are provided for this purpose.
Since the choice of locale and character set can alter the
classifications of particular character codes, all of these functions
are affected by the current locale. (More precisely, they are affected
by the locale currently selected for character classification--the
'LC_CTYPE' category; see *note Locale Categories::.)
The ISO C standard specifies two different sets of functions. The
one set works on 'char' type characters, the other one on 'wchar_t' wide
characters (*note Extended Char Intro::).
* Menu:
* Classification of Characters:: Testing whether characters are
letters, digits, punctuation, etc.
* Case Conversion:: Case mapping, and the like.
* Classification of Wide Characters:: Character class determination for
wide characters.
* Using Wide Char Classes:: Notes on using the wide character
classes.
* Wide Character Case Conversion:: Mapping of wide characters.

File: libc.info, Node: Classification of Characters, Next: Case Conversion, Up: Character Handling
4.1 Classification of Characters
================================
This section explains the library functions for classifying characters.
For example, 'isalpha' is the function to test for an alphabetic
character. It takes one argument, the character to test, and returns a
nonzero integer if the character is alphabetic, and zero otherwise. You
would use it like this:
if (isalpha (c))
printf ("The character `%c' is alphabetic.\n", c);
Each of the functions in this section tests for membership in a
particular class of characters; each has a name starting with 'is'.
Each of them takes one argument, which is a character to test, and
returns an 'int' which is treated as a boolean value. The character
argument is passed as an 'int', and it may be the constant value 'EOF'
instead of a real character.
The attributes of any given character can vary between locales.
*Note Locales::, for more information on locales.
These functions are declared in the header file 'ctype.h'.
-- Function: int islower (int C)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
Returns true if C is a lower-case letter. The letter need not be
from the Latin alphabet, any alphabet representable is valid.
-- Function: int isupper (int C)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
Returns true if C is an upper-case letter. The letter need not be
from the Latin alphabet, any alphabet representable is valid.
-- Function: int isalpha (int C)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
Returns true if C is an alphabetic character (a letter). If
'islower' or 'isupper' is true of a character, then 'isalpha' is
also true.
In some locales, there may be additional characters for which
'isalpha' is true--letters which are neither upper case nor lower
case. But in the standard '"C"' locale, there are no such
additional characters.
-- Function: int isdigit (int C)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
Returns true if C is a decimal digit ('0' through '9').
-- Function: int isalnum (int C)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
Returns true if C is an alphanumeric character (a letter or
number); in other words, if either 'isalpha' or 'isdigit' is true
of a character, then 'isalnum' is also true.
-- Function: int isxdigit (int C)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
Returns true if C is a hexadecimal digit. Hexadecimal digits
include the normal decimal digits '0' through '9' and the letters
'A' through 'F' and 'a' through 'f'.
-- Function: int ispunct (int C)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
Returns true if C is a punctuation character. This means any
printing character that is not alphanumeric or a space character.
-- Function: int isspace (int C)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
Returns true if C is a "whitespace" character. In the standard
'"C"' locale, 'isspace' returns true for only the standard
whitespace characters:
'' ''
space
''\f''
formfeed
''\n''
newline
''\r''
carriage return
''\t''
horizontal tab
''\v''
vertical tab
-- Function: int isblank (int C)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
Returns true if C is a blank character; that is, a space or a tab.
This function was originally a GNU extension, but was added in
ISO C99.
-- Function: int isgraph (int C)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
Returns true if C is a graphic character; that is, a character that
has a glyph associated with it. The whitespace characters are not
considered graphic.
-- Function: int isprint (int C)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
Returns true if C is a printing character. Printing characters
include all the graphic characters, plus the space (' ') character.
-- Function: int iscntrl (int C)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
Returns true if C is a control character (that is, a character that
is not a printing character).
-- Function: int isascii (int C)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
Returns true if C is a 7-bit 'unsigned char' value that fits into
the US/UK ASCII character set. This function is a BSD extension
and is also an SVID extension.

File: libc.info, Node: Case Conversion, Next: Classification of Wide Characters, Prev: Classification of Characters, Up: Character Handling
4.2 Case Conversion
===================
This section explains the library functions for performing conversions
such as case mappings on characters. For example, 'toupper' converts
any character to upper case if possible. If the character can't be
converted, 'toupper' returns it unchanged.
These functions take one argument of type 'int', which is the
character to convert, and return the converted character as an 'int'.
If the conversion is not applicable to the argument given, the argument
is returned unchanged.
*Compatibility Note:* In pre-ISO C dialects, instead of returning the
argument unchanged, these functions may fail when the argument is not
suitable for the conversion. Thus for portability, you may need to
write 'islower(c) ? toupper(c) : c' rather than just 'toupper(c)'.
These functions are declared in the header file 'ctype.h'.
-- Function: int tolower (int C)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
If C is an upper-case letter, 'tolower' returns the corresponding
lower-case letter. If C is not an upper-case letter, C is returned
unchanged.
-- Function: int toupper (int C)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
If C is a lower-case letter, 'toupper' returns the corresponding
upper-case letter. Otherwise C is returned unchanged.
-- Function: int toascii (int C)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
This function converts C to a 7-bit 'unsigned char' value that fits
into the US/UK ASCII character set, by clearing the high-order
bits. This function is a BSD extension and is also an SVID
extension.
-- Function: int _tolower (int C)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
This is identical to 'tolower', and is provided for compatibility
with the SVID. *Note SVID::.
-- Function: int _toupper (int C)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
This is identical to 'toupper', and is provided for compatibility
with the SVID.

File: libc.info, Node: Classification of Wide Characters, Next: Using Wide Char Classes, Prev: Case Conversion, Up: Character Handling
4.3 Character class determination for wide characters
=====================================================
Amendment 1 to ISO C90 defines functions to classify wide characters.
Although the original ISO C90 standard already defined the type
'wchar_t', no functions operating on them were defined.
The general design of the classification functions for wide
characters is more general. It allows extensions to the set of
available classifications, beyond those which are always available. The
POSIX standard specifies how extensions can be made, and this is already
implemented in the GNU C Library implementation of the 'localedef'
program.
The character class functions are normally implemented with bitsets,
with a bitset per character. For a given character, the appropriate
bitset is read from a table and a test is performed as to whether a
certain bit is set. Which bit is tested for is determined by the class.
For the wide character classification functions this is made visible.
There is a type classification type defined, a function to retrieve this
value for a given class, and a function to test whether a given
character is in this class, using the classification value. On top of
this the normal character classification functions as used for 'char'
objects can be defined.
-- Data type: wctype_t
The 'wctype_t' can hold a value which represents a character class.
The only defined way to generate such a value is by using the
'wctype' function.
This type is defined in 'wctype.h'.
-- Function: wctype_t wctype (const char *PROPERTY)
Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
Safety Concepts::.
The 'wctype' returns a value representing a class of wide
characters which is identified by the string PROPERTY. Beside some
standard properties each locale can define its own ones. In case
no property with the given name is known for the current locale
selected for the 'LC_CTYPE' category, the function returns zero.
The properties known in every locale are:
'"alnum"' '"alpha"' '"cntrl"' '"digit"'
'"graph"' '"lower"' '"print"' '"punct"'
'"space"' '"upper"' '"xdigit"'
This function is declared in 'wctype.h'.
To test the membership of a character to one of the non-standard
classes the ISO C standard defines a completely new function.
-- Function: int iswctype (wint_t WC, wctype_t DESC)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
This function returns a nonzero value if WC is in the character
class specified by DESC. DESC must previously be returned by a
successful call to 'wctype'.
This function is declared in 'wctype.h'.
To make it easier to use the commonly-used classification functions,
they are defined in the C library. There is no need to use 'wctype' if
the property string is one of the known character classes. In some
situations it is desirable to construct the property strings, and then
it is important that 'wctype' can also handle the standard classes.
-- Function: int iswalnum (wint_t WC)
Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
Safety Concepts::.
This function returns a nonzero value if WC is an alphanumeric
character (a letter or number); in other words, if either
'iswalpha' or 'iswdigit' is true of a character, then 'iswalnum' is
also true.
This function can be implemented using
iswctype (wc, wctype ("alnum"))
It is declared in 'wctype.h'.
-- Function: int iswalpha (wint_t WC)
Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
Safety Concepts::.
Returns true if WC is an alphabetic character (a letter). If
'iswlower' or 'iswupper' is true of a character, then 'iswalpha' is
also true.
In some locales, there may be additional characters for which
'iswalpha' is true--letters which are neither upper case nor lower
case. But in the standard '"C"' locale, there are no such
additional characters.
This function can be implemented using
iswctype (wc, wctype ("alpha"))
It is declared in 'wctype.h'.
-- Function: int iswcntrl (wint_t WC)
Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
Safety Concepts::.
Returns true if WC is a control character (that is, a character
that is not a printing character).
This function can be implemented using
iswctype (wc, wctype ("cntrl"))
It is declared in 'wctype.h'.
-- Function: int iswdigit (wint_t WC)
Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
Safety Concepts::.
Returns true if WC is a digit (e.g., '0' through '9'). Please note
that this function does not only return a nonzero value for
_decimal_ digits, but for all kinds of digits. A consequence is
that code like the following will *not* work unconditionally for
wide characters:
n = 0;
while (iswdigit (*wc))
{
n *= 10;
n += *wc++ - L'0';
}
This function can be implemented using
iswctype (wc, wctype ("digit"))
It is declared in 'wctype.h'.
-- Function: int iswgraph (wint_t WC)
Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
Safety Concepts::.
Returns true if WC is a graphic character; that is, a character
that has a glyph associated with it. The whitespace characters are
not considered graphic.
This function can be implemented using
iswctype (wc, wctype ("graph"))
It is declared in 'wctype.h'.
-- Function: int iswlower (wint_t WC)
Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
Safety Concepts::.
Returns true if WC is a lower-case letter. The letter need not be
from the Latin alphabet, any alphabet representable is valid.
This function can be implemented using
iswctype (wc, wctype ("lower"))
It is declared in 'wctype.h'.
-- Function: int iswprint (wint_t WC)
Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
Safety Concepts::.
Returns true if WC is a printing character. Printing characters
include all the graphic characters, plus the space (' ') character.
This function can be implemented using
iswctype (wc, wctype ("print"))
It is declared in 'wctype.h'.
-- Function: int iswpunct (wint_t WC)
Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
Safety Concepts::.
Returns true if WC is a punctuation character. This means any
printing character that is not alphanumeric or a space character.
This function can be implemented using
iswctype (wc, wctype ("punct"))
It is declared in 'wctype.h'.
-- Function: int iswspace (wint_t WC)
Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
Safety Concepts::.
Returns true if WC is a "whitespace" character. In the standard
'"C"' locale, 'iswspace' returns true for only the standard
whitespace characters:
'L' ''
space
'L'\f''
formfeed
'L'\n''
newline
'L'\r''
carriage return
'L'\t''
horizontal tab
'L'\v''
vertical tab
This function can be implemented using
iswctype (wc, wctype ("space"))
It is declared in 'wctype.h'.
-- Function: int iswupper (wint_t WC)
Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
Safety Concepts::.
Returns true if WC is an upper-case letter. The letter need not be
from the Latin alphabet, any alphabet representable is valid.
This function can be implemented using
iswctype (wc, wctype ("upper"))
It is declared in 'wctype.h'.
-- Function: int iswxdigit (wint_t WC)
Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
Safety Concepts::.
Returns true if WC is a hexadecimal digit. Hexadecimal digits
include the normal decimal digits '0' through '9' and the letters
'A' through 'F' and 'a' through 'f'.
This function can be implemented using
iswctype (wc, wctype ("xdigit"))
It is declared in 'wctype.h'.
The GNU C Library also provides a function which is not defined in
the ISO C standard but which is available as a version for single byte
characters as well.
-- Function: int iswblank (wint_t WC)
Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
Safety Concepts::.
Returns true if WC is a blank character; that is, a space or a tab.
This function was originally a GNU extension, but was added in
ISO C99. It is declared in 'wchar.h'.

File: libc.info, Node: Using Wide Char Classes, Next: Wide Character Case Conversion, Prev: Classification of Wide Characters, Up: Character Handling
4.4 Notes on using the wide character classes
=============================================
The first note is probably not astonishing but still occasionally a
cause of problems. The 'iswXXX' functions can be implemented using
macros and in fact, the GNU C Library does this. They are still
available as real functions but when the 'wctype.h' header is included
the macros will be used. This is the same as the 'char' type versions
of these functions.
The second note covers something new. It can be best illustrated by
a (real-world) example. The first piece of code is an excerpt from the
original code. It is truncated a bit but the intention should be clear.
int
is_in_class (int c, const char *class)
{
if (strcmp (class, "alnum") == 0)
return isalnum (c);
if (strcmp (class, "alpha") == 0)
return isalpha (c);
if (strcmp (class, "cntrl") == 0)
return iscntrl (c);
...
return 0;
}
Now, with the 'wctype' and 'iswctype' you can avoid the 'if'
cascades, but rewriting the code as follows is wrong:
int
is_in_class (int c, const char *class)
{
wctype_t desc = wctype (class);
return desc ? iswctype ((wint_t) c, desc) : 0;
}
The problem is that it is not guaranteed that the wide character
representation of a single-byte character can be found using casting.
In fact, usually this fails miserably. The correct solution to this
problem is to write the code as follows:
int
is_in_class (int c, const char *class)
{
wctype_t desc = wctype (class);
return desc ? iswctype (btowc (c), desc) : 0;
}
*Note Converting a Character::, for more information on 'btowc'.
Note that this change probably does not improve the performance of the
program a lot since the 'wctype' function still has to make the string
comparisons. It gets really interesting if the 'is_in_class' function
is called more than once for the same class name. In this case the
variable DESC could be computed once and reused for all the calls.
Therefore the above form of the function is probably not the final one.

File: libc.info, Node: Wide Character Case Conversion, Prev: Using Wide Char Classes, Up: Character Handling
4.5 Mapping of wide characters.
===============================
The classification functions are also generalized by the ISO C standard.
Instead of just allowing the two standard mappings, a locale can contain
others. Again, the 'localedef' program already supports generating such
locale data files.
-- Data Type: wctrans_t
This data type is defined as a scalar type which can hold a value
representing the locale-dependent character mapping. There is no
way to construct such a value apart from using the return value of
the 'wctrans' function.
This type is defined in 'wctype.h'.
-- Function: wctrans_t wctrans (const char *PROPERTY)
Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
Safety Concepts::.
The 'wctrans' function has to be used to find out whether a named
mapping is defined in the current locale selected for the
'LC_CTYPE' category. If the returned value is non-zero, you can
use it afterwards in calls to 'towctrans'. If the return value is
zero no such mapping is known in the current locale.
Beside locale-specific mappings there are two mappings which are
guaranteed to be available in every locale:
'"tolower"' '"toupper"'
These functions are declared in 'wctype.h'.
-- Function: wint_t towctrans (wint_t WC, wctrans_t DESC)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
'towctrans' maps the input character WC according to the rules of
the mapping for which DESC is a descriptor, and returns the value
it finds. DESC must be obtained by a successful call to 'wctrans'.
This function is declared in 'wctype.h'.
For the generally available mappings, the ISO C standard defines
convenient shortcuts so that it is not necessary to call 'wctrans' for
them.
-- Function: wint_t towlower (wint_t WC)
Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
Safety Concepts::.
If WC is an upper-case letter, 'towlower' returns the corresponding
lower-case letter. If WC is not an upper-case letter, WC is
returned unchanged.
'towlower' can be implemented using
towctrans (wc, wctrans ("tolower"))
This function is declared in 'wctype.h'.
-- Function: wint_t towupper (wint_t WC)
Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX
Safety Concepts::.
If WC is a lower-case letter, 'towupper' returns the corresponding
upper-case letter. Otherwise WC is returned unchanged.
'towupper' can be implemented using
towctrans (wc, wctrans ("toupper"))
This function is declared in 'wctype.h'.
The same warnings given in the last section for the use of the wide
character classification functions apply here. It is not possible to
simply cast a 'char' type value to a 'wint_t' and use it as an argument
to 'towctrans' calls.

File: libc.info, Node: String and Array Utilities, Next: Character Set Handling, Prev: Character Handling, Up: Top
5 String and Array Utilities
****************************
Operations on strings (or arrays of characters) are an important part of
many programs. The GNU C Library provides an extensive set of string
utility functions, including functions for copying, concatenating,
comparing, and searching strings. Many of these functions can also
operate on arbitrary regions of storage; for example, the 'memcpy'
function can be used to copy the contents of any kind of array.
It's fairly common for beginning C programmers to "reinvent the
wheel" by duplicating this functionality in their own code, but it pays
to become familiar with the library functions and to make use of them,
since this offers benefits in maintenance, efficiency, and portability.
For instance, you could easily compare one string to another in two
lines of C code, but if you use the built-in 'strcmp' function, you're
less likely to make a mistake. And, since these library functions are
typically highly optimized, your program may run faster too.
* Menu:
* Representation of Strings:: Introduction to basic concepts.
* String/Array Conventions:: Whether to use a string function or an
arbitrary array function.
* String Length:: Determining the length of a string.
* Copying and Concatenation:: Functions to copy the contents of strings
and arrays.
* String/Array Comparison:: Functions for byte-wise and character-wise
comparison.
* Collation Functions:: Functions for collating strings.
* Search Functions:: Searching for a specific element or substring.
* Finding Tokens in a String:: Splitting a string into tokens by looking
for delimiters.
* strfry:: Function for flash-cooking a string.
* Trivial Encryption:: Obscuring data.
* Encode Binary Data:: Encoding and Decoding of Binary Data.
* Argz and Envz Vectors:: Null-separated string vectors.

File: libc.info, Node: Representation of Strings, Next: String/Array Conventions, Up: String and Array Utilities
5.1 Representation of Strings
=============================
This section is a quick summary of string concepts for beginning C
programmers. It describes how character strings are represented in C
and some common pitfalls. If you are already familiar with this
material, you can skip this section.
A "string" is an array of 'char' objects. But string-valued
variables are usually declared to be pointers of type 'char *'. Such
variables do not include space for the text of a string; that has to be
stored somewhere else--in an array variable, a string constant, or
dynamically allocated memory (*note Memory Allocation::). It's up to
you to store the address of the chosen memory space into the pointer
variable. Alternatively you can store a "null pointer" in the pointer
variable. The null pointer does not point anywhere, so attempting to
reference the string it points to gets an error.
"string" normally refers to multibyte character strings as opposed to
wide character strings. Wide character strings are arrays of type
'wchar_t' and as for multibyte character strings usually pointers of
type 'wchar_t *' are used.
By convention, a "null character", ''\0'', marks the end of a
multibyte character string and the "null wide character", 'L'\0'', marks
the end of a wide character string. For example, in testing to see
whether the 'char *' variable P points to a null character marking the
end of a string, you can write '!*P' or '*P == '\0''.
A null character is quite different conceptually from a null pointer,
although both are represented by the integer '0'.
"String literals" appear in C program source as strings of characters
between double-quote characters ('"') where the initial double-quote
character is immediately preceded by a capital 'L' (ell) character (as
in 'L"foo"'). In ISO C, string literals can also be formed by "string
concatenation": '"a" "b"' is the same as '"ab"'. For wide character
strings one can either use 'L"a" L"b"' or 'L"a" "b"'. Modification of
string literals is not allowed by the GNU C compiler, because literals
are placed in read-only storage.
Character arrays that are declared 'const' cannot be modified either.
It's generally good style to declare non-modifiable string pointers to
be of type 'const char *', since this often allows the C compiler to
detect accidental modifications as well as providing some amount of
documentation about what your program intends to do with the string.
The amount of memory allocated for the character array may extend
past the null character that normally marks the end of the string. In
this document, the term "allocated size" is always used to refer to the
total amount of memory allocated for the string, while the term "length"
refers to the number of characters up to (but not including) the
terminating null character.
A notorious source of program bugs is trying to put more characters
in a string than fit in its allocated size. When writing code that
extends strings or moves characters into a pre-allocated array, you
should be very careful to keep track of the length of the text and make
explicit checks for overflowing the array. Many of the library
functions _do not_ do this for you! Remember also that you need to
allocate an extra byte to hold the null character that marks the end of
the string.
Originally strings were sequences of bytes where each byte represents
a single character. This is still true today if the strings are encoded
using a single-byte character encoding. Things are different if the
strings are encoded using a multibyte encoding (for more information on
encodings see *note Extended Char Intro::). There is no difference in
the programming interface for these two kind of strings; the programmer
has to be aware of this and interpret the byte sequences accordingly.
But since there is no separate interface taking care of these
differences the byte-based string functions are sometimes hard to use.
Since the count parameters of these functions specify bytes a call to
'strncpy' could cut a multibyte character in the middle and put an
incomplete (and therefore unusable) byte sequence in the target buffer.
To avoid these problems later versions of the ISO C standard
introduce a second set of functions which are operating on "wide
characters" (*note Extended Char Intro::). These functions don't have
the problems the single-byte versions have since every wide character is
a legal, interpretable value. This does not mean that cutting wide
character strings at arbitrary points is without problems. It normally
is for alphabet-based languages (except for non-normalized text) but
languages based on syllables still have the problem that more than one
wide character is necessary to complete a logical unit. This is a
higher level problem which the C library functions are not designed to
solve. But it is at least good that no invalid byte sequences can be
created. Also, the higher level functions can also much easier operate
on wide character than on multibyte characters so that a general advise
is to use wide characters internally whenever text is more than simply
copied.
The remaining of this chapter will discuss the functions for handling
wide character strings in parallel with the discussion of the multibyte
character strings since there is almost always an exact equivalent
available.

File: libc.info, Node: String/Array Conventions, Next: String Length, Prev: Representation of Strings, Up: String and Array Utilities
5.2 String and Array Conventions
================================
This chapter describes both functions that work on arbitrary arrays or
blocks of memory, and functions that are specific to null-terminated
arrays of characters and wide characters.
Functions that operate on arbitrary blocks of memory have names
beginning with 'mem' and 'wmem' (such as 'memcpy' and 'wmemcpy') and
invariably take an argument which specifies the size (in bytes and wide
characters respectively) of the block of memory to operate on. The
array arguments and return values for these functions have type 'void *'
or 'wchar_t'. As a matter of style, the elements of the arrays used
with the 'mem' functions are referred to as "bytes". You can pass any
kind of pointer to these functions, and the 'sizeof' operator is useful
in computing the value for the size argument. Parameters to the 'wmem'
functions must be of type 'wchar_t *'. These functions are not really
usable with anything but arrays of this type.
In contrast, functions that operate specifically on strings and wide
character strings have names beginning with 'str' and 'wcs' respectively
(such as 'strcpy' and 'wcscpy') and look for a null character to
terminate the string instead of requiring an explicit size argument to
be passed. (Some of these functions accept a specified maximum length,
but they also check for premature termination with a null character.)
The array arguments and return values for these functions have type
'char *' and 'wchar_t *' respectively, and the array elements are
referred to as "characters" and "wide characters".
In many cases, there are both 'mem' and 'str'/'wcs' versions of a
function. The one that is more appropriate to use depends on the exact
situation. When your program is manipulating arbitrary arrays or blocks
of storage, then you should always use the 'mem' functions. On the
other hand, when you are manipulating null-terminated strings it is
usually more convenient to use the 'str'/'wcs' functions, unless you
already know the length of the string in advance. The 'wmem' functions
should be used for wide character arrays with known size.
Some of the memory and string functions take single characters as
arguments. Since a value of type 'char' is automatically promoted into
a value of type 'int' when used as a parameter, the functions are
declared with 'int' as the type of the parameter in question. In case
of the wide character function the situation is similarly: the parameter
type for a single wide character is 'wint_t' and not 'wchar_t'. This
would for many implementations not be necessary since the 'wchar_t' is
large enough to not be automatically promoted, but since the ISO C
standard does not require such a choice of types the 'wint_t' type is
used.

File: libc.info, Node: String Length, Next: Copying and Concatenation, Prev: String/Array Conventions, Up: String and Array Utilities
5.3 String Length
=================
You can get the length of a string using the 'strlen' function. This
function is declared in the header file 'string.h'.
-- Function: size_t strlen (const char *S)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
The 'strlen' function returns the length of the null-terminated
string S in bytes. (In other words, it returns the offset of the
terminating null character within the array.)
For example,
strlen ("hello, world")
=> 12
When applied to a character array, the 'strlen' function returns
the length of the string stored there, not its allocated size. You
can get the allocated size of the character array that holds a
string using the 'sizeof' operator:
char string[32] = "hello, world";
sizeof (string)
=> 32
strlen (string)
=> 12
But beware, this will not work unless STRING is the character array
itself, not a pointer to it. For example:
char string[32] = "hello, world";
char *ptr = string;
sizeof (string)
=> 32
sizeof (ptr)
=> 4 /* (on a machine with 4 byte pointers) */
This is an easy mistake to make when you are working with functions
that take string arguments; those arguments are always pointers,
not arrays.
It must also be noted that for multibyte encoded strings the return
value does not have to correspond to the number of characters in
the string. To get this value the string can be converted to wide
characters and 'wcslen' can be used or something like the following
code can be used:
/* The input is in 'string'.
The length is expected in 'n'. */
{
mbstate_t t;
char *scopy = string;
/* In initial state. */
memset (&t, '\0', sizeof (t));
/* Determine number of characters. */
n = mbsrtowcs (NULL, &scopy, strlen (scopy), &t);
}
This is cumbersome to do so if the number of characters (as opposed
to bytes) is needed often it is better to work with wide
characters.
The wide character equivalent is declared in 'wchar.h'.
-- Function: size_t wcslen (const wchar_t *WS)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
The 'wcslen' function is the wide character equivalent to 'strlen'.
The return value is the number of wide characters in the wide
character string pointed to by WS (this is also the offset of the
terminating null wide character of WS).
Since there are no multi wide character sequences making up one
character the return value is not only the offset in the array, it
is also the number of wide characters.
This function was introduced in Amendment 1 to ISO C90.
-- Function: size_t strnlen (const char *S, size_t MAXLEN)
Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety
Concepts::.
The 'strnlen' function returns the length of the string S in bytes
if this length is smaller than MAXLEN bytes. Otherwise it returns
MAXLEN. Therefore this function is equivalent to '(strlen (S) <
MAXLEN ? strlen (S) : MAXLEN)' but it is more efficient and works
even if the string S is not null-terminated.