blob: 5954eb980732bb22aca7ce3c4d1f61aff8a75c31 [file] [log] [blame]
This is /home/vagrant/rpmbuild/BUILD/build-eglibc/manual/libc.info,
produced by makeinfo version 4.13 from libc.texinfo.
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.
* 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.
* 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_getattr_default_np: (libc)Default Thread Attributes.
* 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.
* 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
This file documents the GNU C Library.
This is `The GNU C Library Reference Manual', for version
2.18-2013.10 (EGLIBC).
Copyright (C) 1993-2013 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."

File: libc.info, Node: String/Array Comparison, Next: Collation Functions, Prev: Copying and Concatenation, Up: String and Array Utilities
5.5 String/Array Comparison
===========================
You can use the functions in this section to perform comparisons on the
contents of strings and arrays. As well as checking for equality, these
functions can also be used as the ordering functions for sorting
operations. *Note Searching and Sorting::, for an example of this.
Unlike most comparison operations in C, the string comparison
functions return a nonzero value if the strings are _not_ equivalent
rather than if they are. The sign of the value indicates the relative
ordering of the first characters in the strings that are not
equivalent: a negative value indicates that the first string is "less"
than the second, while a positive value indicates that the first string
is "greater".
The most common use of these functions is to check only for equality.
This is canonically done with an expression like `! strcmp (s1, s2)'.
All of these functions are declared in the header file `string.h'.
-- Function: int memcmp (const void *A1, const void *A2, size_t SIZE)
The function `memcmp' compares the SIZE bytes of memory beginning
at A1 against the SIZE bytes of memory beginning at A2. The value
returned has the same sign as the difference between the first
differing pair of bytes (interpreted as `unsigned char' objects,
then promoted to `int').
If the contents of the two blocks are equal, `memcmp' returns `0'.
-- Function: int wmemcmp (const wchar_t *A1, const wchar_t *A2, size_t
SIZE)
The function `wmemcmp' compares the SIZE wide characters beginning
at A1 against the SIZE wide characters beginning at A2. The value
returned is smaller than or larger than zero depending on whether
the first differing wide character is A1 is smaller or larger than
the corresponding character in A2.
If the contents of the two blocks are equal, `wmemcmp' returns `0'.
On arbitrary arrays, the `memcmp' function is mostly useful for
testing equality. It usually isn't meaningful to do byte-wise ordering
comparisons on arrays of things other than bytes. For example, a
byte-wise comparison on the bytes that make up floating-point numbers
isn't likely to tell you anything about the relationship between the
values of the floating-point numbers.
`wmemcmp' is really only useful to compare arrays of type `wchar_t'
since the function looks at `sizeof (wchar_t)' bytes at a time and this
number of bytes is system dependent.
You should also be careful about using `memcmp' to compare objects
that can contain "holes", such as the padding inserted into structure
objects to enforce alignment requirements, extra space at the end of
unions, and extra characters at the ends of strings whose length is less
than their allocated size. The contents of these "holes" are
indeterminate and may cause strange behavior when performing byte-wise
comparisons. For more predictable results, perform an explicit
component-wise comparison.
For example, given a structure type definition like:
struct foo
{
unsigned char tag;
union
{
double f;
long i;
char *p;
} value;
};
you are better off writing a specialized comparison function to compare
`struct foo' objects instead of comparing them with `memcmp'.
-- Function: int strcmp (const char *S1, const char *S2)
The `strcmp' function compares the string S1 against S2, returning
a value that has the same sign as the difference between the first
differing pair of characters (interpreted as `unsigned char'
objects, then promoted to `int').
If the two strings are equal, `strcmp' returns `0'.
A consequence of the ordering used by `strcmp' is that if S1 is an
initial substring of S2, then S1 is considered to be "less than"
S2.
`strcmp' does not take sorting conventions of the language the
strings are written in into account. To get that one has to use
`strcoll'.
-- Function: int wcscmp (const wchar_t *WS1, const wchar_t *WS2)
The `wcscmp' function compares the wide character string WS1
against WS2. The value returned is smaller than or larger than
zero depending on whether the first differing wide character is
WS1 is smaller or larger than the corresponding character in WS2.
If the two strings are equal, `wcscmp' returns `0'.
A consequence of the ordering used by `wcscmp' is that if WS1 is
an initial substring of WS2, then WS1 is considered to be "less
than" WS2.
`wcscmp' does not take sorting conventions of the language the
strings are written in into account. To get that one has to use
`wcscoll'.
-- Function: int strcasecmp (const char *S1, const char *S2)
This function is like `strcmp', except that differences in case are
ignored. How uppercase and lowercase characters are related is
determined by the currently selected locale. In the standard `"C"'
locale the characters A" and a" do not match but in a locale which
regards these characters as parts of the alphabet they do match.
`strcasecmp' is derived from BSD.
-- Function: int wcscasecmp (const wchar_t *WS1, const wchar_t *WS2)
This function is like `wcscmp', except that differences in case are
ignored. How uppercase and lowercase characters are related is
determined by the currently selected locale. In the standard `"C"'
locale the characters A" and a" do not match but in a locale which
regards these characters as parts of the alphabet they do match.
`wcscasecmp' is a GNU extension.
-- Function: int strncmp (const char *S1, const char *S2, size_t SIZE)
This function is the similar to `strcmp', except that no more than
SIZE characters are compared. In other words, if the two strings
are the same in their first SIZE characters, the return value is
zero.
-- Function: int wcsncmp (const wchar_t *WS1, const wchar_t *WS2,
size_t SIZE)
This function is the similar to `wcscmp', except that no more than
SIZE wide characters are compared. In other words, if the two
strings are the same in their first SIZE wide characters, the
return value is zero.
-- Function: int strncasecmp (const char *S1, const char *S2, size_t N)
This function is like `strncmp', except that differences in case
are ignored. Like `strcasecmp', it is locale dependent how
uppercase and lowercase characters are related.
`strncasecmp' is a GNU extension.
-- Function: int wcsncasecmp (const wchar_t *WS1, const wchar_t *S2,
size_t N)
This function is like `wcsncmp', except that differences in case
are ignored. Like `wcscasecmp', it is locale dependent how
uppercase and lowercase characters are related.
`wcsncasecmp' is a GNU extension.
Here are some examples showing the use of `strcmp' and `strncmp'
(equivalent examples can be constructed for the wide character
functions). These examples assume the use of the ASCII character set.
(If some other character set--say, EBCDIC--is used instead, then the
glyphs are associated with different numeric codes, and the return
values and ordering may differ.)
strcmp ("hello", "hello")
=> 0 /* These two strings are the same. */
strcmp ("hello", "Hello")
=> 32 /* Comparisons are case-sensitive. */
strcmp ("hello", "world")
=> -15 /* The character `'h'' comes before `'w''. */
strcmp ("hello", "hello, world")
=> -44 /* Comparing a null character against a comma. */
strncmp ("hello", "hello, world", 5)
=> 0 /* The initial 5 characters are the same. */
strncmp ("hello, world", "hello, stupid world!!!", 5)
=> 0 /* The initial 5 characters are the same. */
-- Function: int strverscmp (const char *S1, const char *S2)
The `strverscmp' function compares the string S1 against S2,
considering them as holding indices/version numbers. The return
value follows the same conventions as found in the `strcmp'
function. In fact, if S1 and S2 contain no digits, `strverscmp'
behaves like `strcmp'.
Basically, we compare strings normally (character by character),
until we find a digit in each string - then we enter a special
comparison mode, where each sequence of digits is taken as a
whole. If we reach the end of these two parts without noticing a
difference, we return to the standard comparison mode. There are
two types of numeric parts: "integral" and "fractional" (those
begin with a '0'). The types of the numeric parts affect the way
we sort them:
* integral/integral: we compare values as you would expect.
* fractional/integral: the fractional part is less than the
integral one. Again, no surprise.
* fractional/fractional: the things become a bit more complex.
If the common prefix contains only leading zeroes, the
longest part is less than the other one; else the comparison
behaves normally.
strverscmp ("no digit", "no digit")
=> 0 /* same behavior as strcmp. */
strverscmp ("item#99", "item#100")
=> <0 /* same prefix, but 99 < 100. */
strverscmp ("alpha1", "alpha001")
=> >0 /* fractional part inferior to integral one. */
strverscmp ("part1_f012", "part1_f01")
=> >0 /* two fractional parts. */
strverscmp ("foo.009", "foo.0")
=> <0 /* idem, but with leading zeroes only. */
This function is especially useful when dealing with filename
sorting, because filenames frequently hold indices/version numbers.
`strverscmp' is a GNU extension.
-- Function: int bcmp (const void *A1, const void *A2, size_t SIZE)
This is an obsolete alias for `memcmp', derived from BSD.

File: libc.info, Node: Collation Functions, Next: Search Functions, Prev: String/Array Comparison, Up: String and Array Utilities
5.6 Collation Functions
=======================
In some locales, the conventions for lexicographic ordering differ from
the strict numeric ordering of character codes. For example, in Spanish
most glyphs with diacritical marks such as accents are not considered
distinct letters for the purposes of collation. On the other hand, the
two-character sequence `ll' is treated as a single letter that is
collated immediately after `l'.
You can use the functions `strcoll' and `strxfrm' (declared in the
headers file `string.h') and `wcscoll' and `wcsxfrm' (declared in the
headers file `wchar') to compare strings using a collation ordering
appropriate for the current locale. The locale used by these functions
in particular can be specified by setting the locale for the
`LC_COLLATE' category; see *note Locales::.
In the standard C locale, the collation sequence for `strcoll' is
the same as that for `strcmp'. Similarly, `wcscoll' and `wcscmp' are
the same in this situation.
Effectively, the way these functions work is by applying a mapping to
transform the characters in a string to a byte sequence that represents
the string's position in the collating sequence of the current locale.
Comparing two such byte sequences in a simple fashion is equivalent to
comparing the strings with the locale's collating sequence.
The functions `strcoll' and `wcscoll' perform this translation
implicitly, in order to do one comparison. By contrast, `strxfrm' and
`wcsxfrm' perform the mapping explicitly. If you are making multiple
comparisons using the same string or set of strings, it is likely to be
more efficient to use `strxfrm' or `wcsxfrm' to transform all the
strings just once, and subsequently compare the transformed strings
with `strcmp' or `wcscmp'.
-- Function: int strcoll (const char *S1, const char *S2)
The `strcoll' function is similar to `strcmp' but uses the
collating sequence of the current locale for collation (the
`LC_COLLATE' locale).
-- Function: int wcscoll (const wchar_t *WS1, const wchar_t *WS2)
The `wcscoll' function is similar to `wcscmp' but uses the
collating sequence of the current locale for collation (the
`LC_COLLATE' locale).
Here is an example of sorting an array of strings, using `strcoll'
to compare them. The actual sort algorithm is not written here; it
comes from `qsort' (*note Array Sort Function::). The job of the code
shown here is to say how to compare the strings while sorting them.
(Later on in this section, we will show a way to do this more
efficiently using `strxfrm'.)
/* This is the comparison function used with `qsort'. */
int
compare_elements (const void *v1, const void *v2)
{
char * const *p1 = v1;
char * const *p1 = v2;
return strcoll (*p1, *p2);
}
/* This is the entry point--the function to sort
strings using the locale's collating sequence. */
void
sort_strings (char **array, int nstrings)
{
/* Sort `temp_array' by comparing the strings. */
qsort (array, nstrings,
sizeof (char *), compare_elements);
}
-- Function: size_t strxfrm (char *restrict TO, const char *restrict
FROM, size_t SIZE)
The function `strxfrm' transforms the string FROM using the
collation transformation determined by the locale currently
selected for collation, and stores the transformed string in the
array TO. Up to SIZE characters (including a terminating null
character) are stored.
The behavior is undefined if the strings TO and FROM overlap; see
*note Copying and Concatenation::.
The return value is the length of the entire transformed string.
This value is not affected by the value of SIZE, but if it is
greater or equal than SIZE, it means that the transformed string
did not entirely fit in the array TO. In this case, only as much
of the string as actually fits was stored. To get the whole
transformed string, call `strxfrm' again with a bigger output
array.
The transformed string may be longer than the original string, and
it may also be shorter.
If SIZE is zero, no characters are stored in TO. In this case,
`strxfrm' simply returns the number of characters that would be
the length of the transformed string. This is useful for
determining what size the allocated array should be. It does not
matter what TO is if SIZE is zero; TO may even be a null pointer.
-- Function: size_t wcsxfrm (wchar_t *restrict WTO, const wchar_t
*WFROM, size_t SIZE)
The function `wcsxfrm' transforms wide character string WFROM
using the collation transformation determined by the locale
currently selected for collation, and stores the transformed
string in the array WTO. Up to SIZE wide characters (including a
terminating null character) are stored.
The behavior is undefined if the strings WTO and WFROM overlap;
see *note Copying and Concatenation::.
The return value is the length of the entire transformed wide
character string. This value is not affected by the value of
SIZE, but if it is greater or equal than SIZE, it means that the
transformed wide character string did not entirely fit in the
array WTO. In this case, only as much of the wide character
string as actually fits was stored. To get the whole transformed
wide character string, call `wcsxfrm' again with a bigger output
array.
The transformed wide character string may be longer than the
original wide character string, and it may also be shorter.
If SIZE is zero, no characters are stored in TO. In this case,
`wcsxfrm' simply returns the number of wide characters that would
be the length of the transformed wide character string. This is
useful for determining what size the allocated array should be
(remember to multiply with `sizeof (wchar_t)'). It does not
matter what WTO is if SIZE is zero; WTO may even be a null pointer.
Here is an example of how you can use `strxfrm' when you plan to do
many comparisons. It does the same thing as the previous example, but
much faster, because it has to transform each string only once, no
matter how many times it is compared with other strings. Even the time
needed to allocate and free storage is much less than the time we save,
when there are many strings.
struct sorter { char *input; char *transformed; };
/* This is the comparison function used with `qsort'
to sort an array of `struct sorter'. */
int
compare_elements (const void *v1, const void *v2)
{
const struct sorter *p1 = v1;
const struct sorter *p2 = v2;
return strcmp (p1->transformed, p2->transformed);
}
/* This is the entry point--the function to sort
strings using the locale's collating sequence. */
void
sort_strings_fast (char **array, int nstrings)
{
struct sorter temp_array[nstrings];
int i;
/* Set up `temp_array'. Each element contains
one input string and its transformed string. */
for (i = 0; i < nstrings; i++)
{
size_t length = strlen (array[i]) * 2;
char *transformed;
size_t transformed_length;
temp_array[i].input = array[i];
/* First try a buffer perhaps big enough. */
transformed = (char *) xmalloc (length);
/* Transform `array[i]'. */
transformed_length = strxfrm (transformed, array[i], length);
/* If the buffer was not large enough, resize it
and try again. */
if (transformed_length >= length)
{
/* Allocate the needed space. +1 for terminating
`NUL' character. */
transformed = (char *) xrealloc (transformed,
transformed_length + 1);
/* The return value is not interesting because we know
how long the transformed string is. */
(void) strxfrm (transformed, array[i],
transformed_length + 1);
}
temp_array[i].transformed = transformed;
}
/* Sort `temp_array' by comparing transformed strings. */
qsort (temp_array, sizeof (struct sorter),
nstrings, compare_elements);
/* Put the elements back in the permanent array
in their sorted order. */
for (i = 0; i < nstrings; i++)
array[i] = temp_array[i].input;
/* Free the strings we allocated. */
for (i = 0; i < nstrings; i++)
free (temp_array[i].transformed);
}
The interesting part of this code for the wide character version
would look like this:
void
sort_strings_fast (wchar_t **array, int nstrings)
{
...
/* Transform `array[i]'. */
transformed_length = wcsxfrm (transformed, array[i], length);
/* If the buffer was not large enough, resize it
and try again. */
if (transformed_length >= length)
{
/* Allocate the needed space. +1 for terminating
`NUL' character. */
transformed = (wchar_t *) xrealloc (transformed,
(transformed_length + 1)
* sizeof (wchar_t));
/* The return value is not interesting because we know
how long the transformed string is. */
(void) wcsxfrm (transformed, array[i],
transformed_length + 1);
}
...
Note the additional multiplication with `sizeof (wchar_t)' in the
`realloc' call.
*Compatibility Note:* The string collation functions are a new
feature of ISO C90. Older C dialects have no equivalent feature. The
wide character versions were introduced in Amendment 1 to ISO C90.

File: libc.info, Node: Search Functions, Next: Finding Tokens in a String, Prev: Collation Functions, Up: String and Array Utilities
5.7 Search Functions
====================
This section describes library functions which perform various kinds of
searching operations on strings and arrays. These functions are
declared in the header file `string.h'.
-- Function: void * memchr (const void *BLOCK, int C, size_t SIZE)
This function finds the first occurrence of the byte C (converted
to an `unsigned char') in the initial SIZE bytes of the object
beginning at BLOCK. The return value is a pointer to the located
byte, or a null pointer if no match was found.
-- Function: wchar_t * wmemchr (const wchar_t *BLOCK, wchar_t WC,
size_t SIZE)
This function finds the first occurrence of the wide character WC
in the initial SIZE wide characters of the object beginning at
BLOCK. The return value is a pointer to the located wide
character, or a null pointer if no match was found.
-- Function: void * rawmemchr (const void *BLOCK, int C)
Often the `memchr' function is used with the knowledge that the
byte C is available in the memory block specified by the
parameters. But this means that the SIZE parameter is not really
needed and that the tests performed with it at runtime (to check
whether the end of the block is reached) are not needed.
The `rawmemchr' function exists for just this situation which is
surprisingly frequent. The interface is similar to `memchr' except
that the SIZE parameter is missing. The function will look beyond
the end of the block pointed to by BLOCK in case the programmer
made an error in assuming that the byte C is present in the block.
In this case the result is unspecified. Otherwise the return
value is a pointer to the located byte.
This function is of special interest when looking for the end of a
string. Since all strings are terminated by a null byte a call
like
rawmemchr (str, '\0')
will never go beyond the end of the string.
This function is a GNU extension.
-- Function: void * memrchr (const void *BLOCK, int C, size_t SIZE)
The function `memrchr' is like `memchr', except that it searches
backwards from the end of the block defined by BLOCK and SIZE
(instead of forwards from the front).
This function is a GNU extension.
-- Function: char * strchr (const char *STRING, int C)
The `strchr' function finds the first occurrence of the character
C (converted to a `char') in the null-terminated string beginning
at STRING. The return value is a pointer to the located
character, or a null pointer if no match was found.
For example,
strchr ("hello, world", 'l')
=> "llo, world"
strchr ("hello, world", '?')
=> NULL
The terminating null character is considered to be part of the
string, so you can use this function get a pointer to the end of a
string by specifying a null character as the value of the C
argument.
When `strchr' returns a null pointer, it does not let you know the
position of the terminating null character it has found. If you
need that information, it is better (but less portable) to use
`strchrnul' than to search for it a second time.
-- Function: wchar_t * wcschr (const wchar_t *WSTRING, int WC)
The `wcschr' function finds the first occurrence of the wide
character WC in the null-terminated wide character string
beginning at WSTRING. The return value is a pointer to the
located wide character, or a null pointer if no match was found.
The terminating null character is considered to be part of the wide
character string, so you can use this function get a pointer to
the end of a wide character string by specifying a null wude
character as the value of the WC argument. It would be better
(but less portable) to use `wcschrnul' in this case, though.
-- Function: char * strchrnul (const char *STRING, int C)
`strchrnul' is the same as `strchr' except that if it does not
find the character, it returns a pointer to string's terminating
null character rather than a null pointer.
This function is a GNU extension.
-- Function: wchar_t * wcschrnul (const wchar_t *WSTRING, wchar_t WC)
`wcschrnul' is the same as `wcschr' except that if it does not
find the wide character, it returns a pointer to wide character
string's terminating null wide character rather than a null
pointer.
This function is a GNU extension.
One useful, but unusual, use of the `strchr' function is when one
wants to have a pointer pointing to the NUL byte terminating a string.
This is often written in this way:
s += strlen (s);
This is almost optimal but the addition operation duplicated a bit of
the work already done in the `strlen' function. A better solution is
this:
s = strchr (s, '\0');
There is no restriction on the second parameter of `strchr' so it
could very well also be the NUL character. Those readers thinking very
hard about this might now point out that the `strchr' function is more
expensive than the `strlen' function since we have two abort criteria.
This is right. But in the GNU C Library the implementation of `strchr'
is optimized in a special way so that `strchr' actually is faster.
-- Function: char * strrchr (const char *STRING, int C)
The function `strrchr' is like `strchr', except that it searches
backwards from the end of the string STRING (instead of forwards
from the front).
For example,
strrchr ("hello, world", 'l')
=> "ld"
-- Function: wchar_t * wcsrchr (const wchar_t *WSTRING, wchar_t C)
The function `wcsrchr' is like `wcschr', except that it searches
backwards from the end of the string WSTRING (instead of forwards
from the front).
-- Function: char * strstr (const char *HAYSTACK, const char *NEEDLE)
This is like `strchr', except that it searches HAYSTACK for a
substring NEEDLE rather than just a single character. It returns
a pointer into the string HAYSTACK that is the first character of
the substring, or a null pointer if no match was found. If NEEDLE
is an empty string, the function returns HAYSTACK.
For example,
strstr ("hello, world", "l")
=> "llo, world"
strstr ("hello, world", "wo")
=> "world"
-- Function: wchar_t * wcsstr (const wchar_t *HAYSTACK, const wchar_t
*NEEDLE)
This is like `wcschr', except that it searches HAYSTACK for a
substring NEEDLE rather than just a single wide character. It
returns a pointer into the string HAYSTACK that is the first wide
character of the substring, or a null pointer if no match was
found. If NEEDLE is an empty string, the function returns
HAYSTACK.
-- Function: wchar_t * wcswcs (const wchar_t *HAYSTACK, const wchar_t
*NEEDLE)
`wcswcs' is an deprecated alias for `wcsstr'. This is the name
originally used in the X/Open Portability Guide before the
Amendment 1 to ISO C90 was published.
-- Function: char * strcasestr (const char *HAYSTACK, const char
*NEEDLE)
This is like `strstr', except that it ignores case in searching for
the substring. Like `strcasecmp', it is locale dependent how
uppercase and lowercase characters are related.
For example,
strcasestr ("hello, world", "L")
=> "llo, world"
strcasestr ("hello, World", "wo")
=> "World"
-- Function: void * memmem (const void *HAYSTACK, size_t HAYSTACK-LEN,
const void *NEEDLE, size_t NEEDLE-LEN)
This is like `strstr', but NEEDLE and HAYSTACK are byte arrays
rather than null-terminated strings. NEEDLE-LEN is the length of
NEEDLE and HAYSTACK-LEN is the length of HAYSTACK.
This function is a GNU extension.
-- Function: size_t strspn (const char *STRING, const char *SKIPSET)
The `strspn' ("string span") function returns the length of the
initial substring of STRING that consists entirely of characters
that are members of the set specified by the string SKIPSET. The
order of the characters in SKIPSET is not important.
For example,
strspn ("hello, world", "abcdefghijklmnopqrstuvwxyz")
=> 5
Note that "character" is here used in the sense of byte. In a
string using a multibyte character encoding (abstract) character
consisting of more than one byte are not treated as an entity.
Each byte is treated separately. The function is not
locale-dependent.
-- Function: size_t wcsspn (const wchar_t *WSTRING, const wchar_t
*SKIPSET)
The `wcsspn' ("wide character string span") function returns the
length of the initial substring of WSTRING that consists entirely
of wide characters that are members of the set specified by the
string SKIPSET. The order of the wide characters in SKIPSET is not
important.
-- Function: size_t strcspn (const char *STRING, const char *STOPSET)
The `strcspn' ("string complement span") function returns the
length of the initial substring of STRING that consists entirely
of characters that are _not_ members of the set specified by the
string STOPSET. (In other words, it returns the offset of the
first character in STRING that is a member of the set STOPSET.)
For example,
strcspn ("hello, world", " \t\n,.;!?")
=> 5
Note that "character" is here used in the sense of byte. In a
string using a multibyte character encoding (abstract) character
consisting of more than one byte are not treated as an entity.
Each byte is treated separately. The function is not
locale-dependent.
-- Function: size_t wcscspn (const wchar_t *WSTRING, const wchar_t
*STOPSET)
The `wcscspn' ("wide character string complement span") function
returns the length of the initial substring of WSTRING that
consists entirely of wide characters that are _not_ members of the
set specified by the string STOPSET. (In other words, it returns
the offset of the first character in STRING that is a member of
the set STOPSET.)
-- Function: char * strpbrk (const char *STRING, const char *STOPSET)
The `strpbrk' ("string pointer break") function is related to
`strcspn', except that it returns a pointer to the first character
in STRING that is a member of the set STOPSET instead of the
length of the initial substring. It returns a null pointer if no
such character from STOPSET is found.
For example,
strpbrk ("hello, world", " \t\n,.;!?")
=> ", world"
Note that "character" is here used in the sense of byte. In a
string using a multibyte character encoding (abstract) character
consisting of more than one byte are not treated as an entity.
Each byte is treated separately. The function is not
locale-dependent.
-- Function: wchar_t * wcspbrk (const wchar_t *WSTRING, const wchar_t
*STOPSET)
The `wcspbrk' ("wide character string pointer break") function is
related to `wcscspn', except that it returns a pointer to the first
wide character in WSTRING that is a member of the set STOPSET
instead of the length of the initial substring. It returns a null
pointer if no such character from STOPSET is found.
5.7.1 Compatibility String Search Functions
-------------------------------------------
-- Function: char * index (const char *STRING, int C)
`index' is another name for `strchr'; they are exactly the same.
New code should always use `strchr' since this name is defined in
ISO C while `index' is a BSD invention which never was available
on System V derived systems.
-- Function: char * rindex (const char *STRING, int C)
`rindex' is another name for `strrchr'; they are exactly the same.
New code should always use `strrchr' since this name is defined in
ISO C while `rindex' is a BSD invention which never was available
on System V derived systems.

File: libc.info, Node: Finding Tokens in a String, Next: strfry, Prev: Search Functions, Up: String and Array Utilities
5.8 Finding Tokens in a String
==============================
It's fairly common for programs to have a need to do some simple kinds
of lexical analysis and parsing, such as splitting a command string up
into tokens. You can do this with the `strtok' function, declared in
the header file `string.h'.
-- Function: char * strtok (char *restrict NEWSTRING, const char
*restrict DELIMITERS)
A string can be split into tokens by making a series of calls to
the function `strtok'.
The string to be split up is passed as the NEWSTRING argument on
the first call only. The `strtok' function uses this to set up
some internal state information. Subsequent calls to get
additional tokens from the same string are indicated by passing a
null pointer as the NEWSTRING argument. Calling `strtok' with
another non-null NEWSTRING argument reinitializes the state
information. It is guaranteed that no other library function ever
calls `strtok' behind your back (which would mess up this internal
state information).
The DELIMITERS argument is a string that specifies a set of
delimiters that may surround the token being extracted. All the
initial characters that are members of this set are discarded.
The first character that is _not_ a member of this set of
delimiters marks the beginning of the next token. The end of the
token is found by looking for the next character that is a member
of the delimiter set. This character in the original string
NEWSTRING is overwritten by a null character, and the pointer to
the beginning of the token in NEWSTRING is returned.
On the next call to `strtok', the searching begins at the next
character beyond the one that marked the end of the previous token.
Note that the set of delimiters DELIMITERS do not have to be the
same on every call in a series of calls to `strtok'.
If the end of the string NEWSTRING is reached, or if the remainder
of string consists only of delimiter characters, `strtok' returns
a null pointer.
Note that "character" is here used in the sense of byte. In a
string using a multibyte character encoding (abstract) character
consisting of more than one byte are not treated as an entity.
Each byte is treated separately. The function is not
locale-dependent.
-- Function: wchar_t * wcstok (wchar_t *NEWSTRING, const wchar_t
*DELIMITERS)
A string can be split into tokens by making a series of calls to
the function `wcstok'.
The string to be split up is passed as the NEWSTRING argument on
the first call only. The `wcstok' function uses this to set up
some internal state information. Subsequent calls to get
additional tokens from the same wide character string are
indicated by passing a null pointer as the NEWSTRING argument.
Calling `wcstok' with another non-null NEWSTRING argument
reinitializes the state information. It is guaranteed that no
other library function ever calls `wcstok' behind your back (which
would mess up this internal state information).
The DELIMITERS argument is a wide character string that specifies
a set of delimiters that may surround the token being extracted.
All the initial wide characters that are members of this set are
discarded. The first wide character that is _not_ a member of
this set of delimiters marks the beginning of the next token. The
end of the token is found by looking for the next wide character
that is a member of the delimiter set. This wide character in the
original wide character string NEWSTRING is overwritten by a null
wide character, and the pointer to the beginning of the token in
NEWSTRING is returned.
On the next call to `wcstok', the searching begins at the next
wide character beyond the one that marked the end of the previous
token. Note that the set of delimiters DELIMITERS do not have to
be the same on every call in a series of calls to `wcstok'.
If the end of the wide character string NEWSTRING is reached, or
if the remainder of string consists only of delimiter wide
characters, `wcstok' returns a null pointer.
Note that "character" is here used in the sense of byte. In a
string using a multibyte character encoding (abstract) character
consisting of more than one byte are not treated as an entity.
Each byte is treated separately. The function is not
locale-dependent.
*Warning:* Since `strtok' and `wcstok' alter the string they is
parsing, you should always copy the string to a temporary buffer before
parsing it with `strtok'/`wcstok' (*note Copying and Concatenation::).
If you allow `strtok' or `wcstok' to modify a string that came from
another part of your program, you are asking for trouble; that string
might be used for other purposes after `strtok' or `wcstok' has
modified it, and it would not have the expected value.
The string that you are operating on might even be a constant. Then
when `strtok' or `wcstok' tries to modify it, your program will get a
fatal signal for writing in read-only memory. *Note Program Error
Signals::. Even if the operation of `strtok' or `wcstok' would not
require a modification of the string (e.g., if there is exactly one
token) the string can (and in the GNU C Library case will) be modified.
This is a special case of a general principle: if a part of a program
does not have as its purpose the modification of a certain data
structure, then it is error-prone to modify the data structure
temporarily.
The functions `strtok' and `wcstok' are not reentrant. *Note
Nonreentrancy::, for a discussion of where and why reentrancy is
important.
Here is a simple example showing the use of `strtok'.
#include <string.h>
#include <stddef.h>
...
const char string[] = "words separated by spaces -- and, punctuation!";
const char delimiters[] = " .,;:!-";
char *token, *cp;
...
cp = strdupa (string); /* Make writable copy. */
token = strtok (cp, delimiters); /* token => "words" */
token = strtok (NULL, delimiters); /* token => "separated" */
token = strtok (NULL, delimiters); /* token => "by" */
token = strtok (NULL, delimiters); /* token => "spaces" */
token = strtok (NULL, delimiters); /* token => "and" */
token = strtok (NULL, delimiters); /* token => "punctuation" */
token = strtok (NULL, delimiters); /* token => NULL */
The GNU C Library contains two more functions for tokenizing a string
which overcome the limitation of non-reentrancy. They are only
available for multibyte character strings.
-- Function: char * strtok_r (char *NEWSTRING, const char *DELIMITERS,
char **SAVE_PTR)
Just like `strtok', this function splits the string into several
tokens which can be accessed by successive calls to `strtok_r'.
The difference is that the information about the next token is
stored in the space pointed to by the third argument, SAVE_PTR,
which is a pointer to a string pointer. Calling `strtok_r' with a
null pointer for NEWSTRING and leaving SAVE_PTR between the calls
unchanged does the job without hindering reentrancy.
This function is defined in POSIX.1 and can be found on many
systems which support multi-threading.
-- Function: char * strsep (char **STRING_PTR, const char *DELIMITER)
This function has a similar functionality as `strtok_r' with the
NEWSTRING argument replaced by the SAVE_PTR argument. The
initialization of the moving pointer has to be done by the user.
Successive calls to `strsep' move the pointer along the tokens
separated by DELIMITER, returning the address of the next token
and updating STRING_PTR to point to the beginning of the next
token.
One difference between `strsep' and `strtok_r' is that if the
input string contains more than one character from DELIMITER in a
row `strsep' returns an empty string for each pair of characters
from DELIMITER. This means that a program normally should test
for `strsep' returning an empty string before processing it.
This function was introduced in 4.3BSD and therefore is widely
available.
Here is how the above example looks like when `strsep' is used.
#include <string.h>
#include <stddef.h>
...
const char string[] = "words separated by spaces -- and, punctuation!";
const char delimiters[] = " .,;:!-";
char *running;
char *token;
...
running = strdupa (string);
token = strsep (&running, delimiters); /* token => "words" */
token = strsep (&running, delimiters); /* token => "separated" */
token = strsep (&running, delimiters); /* token => "by" */
token = strsep (&running, delimiters); /* token => "spaces" */
token = strsep (&running, delimiters); /* token => "" */
token = strsep (&running, delimiters); /* token => "" */
token = strsep (&running, delimiters); /* token => "" */
token = strsep (&running, delimiters); /* token => "and" */
token = strsep (&running, delimiters); /* token => "" */
token = strsep (&running, delimiters); /* token => "punctuation" */
token = strsep (&running, delimiters); /* token => "" */
token = strsep (&running, delimiters); /* token => NULL */
-- Function: char * basename (const char *FILENAME)
The GNU version of the `basename' function returns the last
component of the path in FILENAME. This function is the preferred
usage, since it does not modify the argument, FILENAME, and
respects trailing slashes. The prototype for `basename' can be
found in `string.h'. Note, this function is overriden by the XPG
version, if `libgen.h' is included.
Example of using GNU `basename':
#include <string.h>
int
main (int argc, char *argv[])
{
char *prog = basename (argv[0]);
if (argc < 2)
{
fprintf (stderr, "Usage %s <arg>\n", prog);
exit (1);
}
...
}
*Portability Note:* This function may produce different results on
different systems.
-- Function: char * basename (const char *PATH)
This is the standard XPG defined `basename'. It is similar in
spirit to the GNU version, but may modify the PATH by removing
trailing '/' characters. If the PATH is made up entirely of '/'
characters, then "/" will be returned. Also, if PATH is `NULL' or
an empty string, then "." is returned. The prototype for the XPG
version can be found in `libgen.h'.
Example of using XPG `basename':
#include <libgen.h>
int
main (int argc, char *argv[])
{
char *prog;
char *path = strdupa (argv[0]);
prog = basename (path);
if (argc < 2)
{
fprintf (stderr, "Usage %s <arg>\n", prog);
exit (1);
}
...
}
-- Function: char * dirname (char *PATH)
The `dirname' function is the compliment to the XPG version of
`basename'. It returns the parent directory of the file specified
by PATH. If PATH is `NULL', an empty string, or contains no '/'
characters, then "." is returned. The prototype for this function
can be found in `libgen.h'.

File: libc.info, Node: strfry, Next: Trivial Encryption, Prev: Finding Tokens in a String, Up: String and Array Utilities
5.9 strfry
==========
The function below addresses the perennial programming quandary: "How do
I take good data in string form and painlessly turn it into garbage?"
This is actually a fairly simple task for C programmers who do not use
the GNU C Library string functions, but for programs based on the GNU C
Library, the `strfry' function is the preferred method for destroying
string data.
The prototype for this function is in `string.h'.
-- Function: char * strfry (char *STRING)
`strfry' creates a pseudorandom anagram of a string, replacing the
input with the anagram in place. For each position in the string,
`strfry' swaps it with a position in the string selected at random
(from a uniform distribution). The two positions may be the same.
The return value of `strfry' is always STRING.
*Portability Note:* This function is unique to the GNU C Library.

File: libc.info, Node: Trivial Encryption, Next: Encode Binary Data, Prev: strfry, Up: String and Array Utilities
5.10 Trivial Encryption
=======================
The `memfrob' function converts an array of data to something
unrecognizable and back again. It is not encryption in its usual sense
since it is easy for someone to convert the encrypted data back to clear
text. The transformation is analogous to Usenet's "Rot13" encryption
method for obscuring offensive jokes from sensitive eyes and such.
Unlike Rot13, `memfrob' works on arbitrary binary data, not just text.
For true encryption, *Note Cryptographic Functions::.
This function is declared in `string.h'.
-- Function: void * memfrob (void *MEM, size_t LENGTH)
`memfrob' transforms (frobnicates) each byte of the data structure
at MEM, which is LENGTH bytes long, by bitwise exclusive oring it
with binary 00101010. It does the transformation in place and its
return value is always MEM.
Note that `memfrob' a second time on the same data structure
returns it to its original state.
This is a good function for hiding information from someone who
doesn't want to see it or doesn't want to see it very much. To
really prevent people from retrieving the information, use
stronger encryption such as that described in *Note Cryptographic
Functions::.
*Portability Note:* This function is unique to the GNU C Library.

File: libc.info, Node: Encode Binary Data, Next: Argz and Envz Vectors, Prev: Trivial Encryption, Up: String and Array Utilities
5.11 Encode Binary Data
=======================
To store or transfer binary data in environments which only support text
one has to encode the binary data by mapping the input bytes to
characters in the range allowed for storing or transfering. SVID
systems (and nowadays XPG compliant systems) provide minimal support for
this task.
-- Function: char * l64a (long int N)
This function encodes a 32-bit input value using characters from
the basic character set. It returns a pointer to a 7 character
buffer which contains an encoded version of N. To encode a series
of bytes the user must copy the returned string to a destination
buffer. It returns the empty string if N is zero, which is
somewhat bizarre but mandated by the standard.
*Warning:* Since a static buffer is used this function should not
be used in multi-threaded programs. There is no thread-safe
alternative to this function in the C library.
*Compatibility Note:* The XPG standard states that the return
value of `l64a' is undefined if N is negative. In the GNU
implementation, `l64a' treats its argument as unsigned, so it will
return a sensible encoding for any nonzero N; however, portable
programs should not rely on this.
To encode a large buffer `l64a' must be called in a loop, once for
each 32-bit word of the buffer. For example, one could do
something like this:
char *
encode (const void *buf, size_t len)
{
/* We know in advance how long the buffer has to be. */
unsigned char *in = (unsigned char *) buf;
char *out = malloc (6 + ((len + 3) / 4) * 6 + 1);
char *cp = out, *p;
/* Encode the length. */
/* Using `htonl' is necessary so that the data can be
decoded even on machines with different byte order.
`l64a' can return a string shorter than 6 bytes, so
we pad it with encoding of 0 ('.') at the end by
hand. */
p = stpcpy (cp, l64a (htonl (len)));
cp = mempcpy (p, "......", 6 - (p - cp));
while (len > 3)
{
unsigned long int n = *in++;
n = (n << 8) | *in++;
n = (n << 8) | *in++;
n = (n << 8) | *in++;
len -= 4;
p = stpcpy (cp, l64a (htonl (n)));
cp = mempcpy (p, "......", 6 - (p - cp));
}
if (len > 0)
{
unsigned long int n = *in++;
if (--len > 0)
{
n = (n << 8) | *in++;
if (--len > 0)
n = (n << 8) | *in;
}
cp = stpcpy (cp, l64a (htonl (n)));
}
*cp = '\0';
return out;
}
It is strange that the library does not provide the complete
functionality needed but so be it.
To decode data produced with `l64a' the following function should be
used.
-- Function: long int a64l (const char *STRING)
The parameter STRING should contain a string which was produced by
a call to `l64a'. The function processes at least 6 characters of
this string, and decodes the characters it finds according to the
table below. It stops decoding when it finds a character not in
the table, rather like `atoi'; if you have a buffer which has been
broken into lines, you must be careful to skip over the
end-of-line characters.
The decoded number is returned as a `long int' value.
The `l64a' and `a64l' functions use a base 64 encoding, in which
each character of an encoded string represents six bits of an input
word. These symbols are used for the base 64 digits:
0 1 2 3 4 5 6 7
0 `.' `/' `0' `1' `2' `3' `4' `5'
8 `6' `7' `8' `9' `A' `B' `C' `D'
16 `E' `F' `G' `H' `I' `J' `K' `L'
24 `M' `N' `O' `P' `Q' `R' `S' `T'
32 `U' `V' `W' `X' `Y' `Z' `a' `b'
40 `c' `d' `e' `f' `g' `h' `i' `j'
48 `k' `l' `m' `n' `o' `p' `q' `r'
56 `s' `t' `u' `v' `w' `x' `y' `z'
This encoding scheme is not standard. There are some other encoding
methods which are much more widely used (UU encoding, MIME encoding).
Generally, it is better to use one of these encodings.

File: libc.info, Node: Argz and Envz Vectors, Prev: Encode Binary Data, Up: String and Array Utilities
5.12 Argz and Envz Vectors
==========================
"argz vectors" are vectors of strings in a contiguous block of memory,
each element separated from its neighbors by null-characters (`'\0'').
"Envz vectors" are an extension of argz vectors where each element
is a name-value pair, separated by a `'='' character (as in a Unix
environment).
* Menu:
* Argz Functions:: Operations on argz vectors.
* Envz Functions:: Additional operations on environment vectors.

File: libc.info, Node: Argz Functions, Next: Envz Functions, Up: Argz and Envz Vectors
5.12.1 Argz Functions
---------------------
Each argz vector is represented by a pointer to the first element, of
type `char *', and a size, of type `size_t', both of which can be
initialized to `0' to represent an empty argz vector. All argz
functions accept either a pointer and a size argument, or pointers to
them, if they will be modified.
The argz functions use `malloc'/`realloc' to allocate/grow argz
vectors, and so any argz vector creating using these functions may be
freed by using `free'; conversely, any argz function that may grow a
string expects that string to have been allocated using `malloc' (those
argz functions that only examine their arguments or modify them in
place will work on any sort of memory). *Note Unconstrained
Allocation::.
All argz functions that do memory allocation have a return type of
`error_t', and return `0' for success, and `ENOMEM' if an allocation
error occurs.
These functions are declared in the standard include file `argz.h'.
-- Function: error_t argz_create (char *const ARGV[], char **ARGZ,
size_t *ARGZ_LEN)
The `argz_create' function converts the Unix-style argument vector
ARGV (a vector of pointers to normal C strings, terminated by
`(char *)0'; *note Program Arguments::) into an argz vector with
the same elements, which is returned in ARGZ and ARGZ_LEN.
-- Function: error_t argz_create_sep (const char *STRING, int SEP,
char **ARGZ, size_t *ARGZ_LEN)
The `argz_create_sep' function converts the null-terminated string
STRING into an argz vector (returned in ARGZ and ARGZ_LEN) by
splitting it into elements at every occurrence of the character
SEP.
-- Function: size_t argz_count (const char *ARGZ, size_t ARG_LEN)
Returns the number of elements in the argz vector ARGZ and
ARGZ_LEN.
-- Function: void argz_extract (const char *ARGZ, size_t ARGZ_LEN,
char **ARGV)
The `argz_extract' function converts the argz vector ARGZ and
ARGZ_LEN into a Unix-style argument vector stored in ARGV, by
putting pointers to every element in ARGZ into successive
positions in ARGV, followed by a terminator of `0'. ARGV must be
pre-allocated with enough space to hold all the elements in ARGZ
plus the terminating `(char *)0' (`(argz_count (ARGZ, ARGZ_LEN) +
1) * sizeof (char *)' bytes should be enough). Note that the
string pointers stored into ARGV point into ARGZ--they are not
copies--and so ARGZ must be copied if it will be changed while
ARGV is still active. This function is useful for passing the
elements in ARGZ to an exec function (*note Executing a File::).
-- Function: void argz_stringify (char *ARGZ, size_t LEN, int SEP)
The `argz_stringify' converts ARGZ into a normal string with the
elements separated by the character SEP, by replacing each `'\0''
inside ARGZ (except the last one, which terminates the string)
with SEP. This is handy for printing ARGZ in a readable manner.
-- Function: error_t argz_add (char **ARGZ, size_t *ARGZ_LEN, const
char *STR)
The `argz_add' function adds the string STR to the end of the argz
vector `*ARGZ', and updates `*ARGZ' and `*ARGZ_LEN' accordingly.
-- Function: error_t argz_add_sep (char **ARGZ, size_t *ARGZ_LEN,
const char *STR, int DELIM)
The `argz_add_sep' function is similar to `argz_add', but STR is
split into separate elements in the result at occurrences of the
character DELIM. This is useful, for instance, for adding the
components of a Unix search path to an argz vector, by using a
value of `':'' for DELIM.
-- Function: error_t argz_append (char **ARGZ, size_t *ARGZ_LEN, const
char *BUF, size_t BUF_LEN)
The `argz_append' function appends BUF_LEN bytes starting at BUF
to the argz vector `*ARGZ', reallocating `*ARGZ' to accommodate
it, and adding BUF_LEN to `*ARGZ_LEN'.
-- Function: void argz_delete (char **ARGZ, size_t *ARGZ_LEN, char
*ENTRY)
If ENTRY points to the beginning of one of the elements in the
argz vector `*ARGZ', the `argz_delete' function will remove this
entry and reallocate `*ARGZ', modifying `*ARGZ' and `*ARGZ_LEN'
accordingly. Note that as destructive argz functions usually
reallocate their argz argument, pointers into argz vectors such as
ENTRY will then become invalid.
-- Function: error_t argz_insert (char **ARGZ, size_t *ARGZ_LEN, char
*BEFORE, const char *ENTRY)
The `argz_insert' function inserts the string ENTRY into the argz
vector `*ARGZ' at a point just before the existing element pointed
to by BEFORE, reallocating `*ARGZ' and updating `*ARGZ' and
`*ARGZ_LEN'. If BEFORE is `0', ENTRY is added to the end instead
(as if by `argz_add'). Since the first element is in fact the
same as `*ARGZ', passing in `*ARGZ' as the value of BEFORE will
result in ENTRY being inserted at the beginning.
-- Function: char * argz_next (const char *ARGZ, size_t ARGZ_LEN,
const char *ENTRY)
The `argz_next' function provides a convenient way of iterating
over the elements in the argz vector ARGZ. It returns a pointer
to the next element in ARGZ after the element ENTRY, or `0' if
there are no elements following ENTRY. If ENTRY is `0', the first
element of ARGZ is returned.
This behavior suggests two styles of iteration:
char *entry = 0;
while ((entry = argz_next (ARGZ, ARGZ_LEN, entry)))
ACTION;
(the double parentheses are necessary to make some C compilers
shut up about what they consider a questionable `while'-test) and:
char *entry;
for (entry = ARGZ;
entry;
entry = argz_next (ARGZ, ARGZ_LEN, entry))
ACTION;
Note that the latter depends on ARGZ having a value of `0' if it
is empty (rather than a pointer to an empty block of memory); this
invariant is maintained for argz vectors created by the functions
here.
-- Function: error_t argz_replace (char **ARGZ, size_t *ARGZ_LEN,
const char *STR, const char *WITH, unsigned *REPLACE_COUNT)
Replace any occurrences of the string STR in ARGZ with WITH,
reallocating ARGZ as necessary. If REPLACE_COUNT is non-zero,
`*REPLACE_COUNT' will be incremented by number of replacements
performed.

File: libc.info, Node: Envz Functions, Prev: Argz Functions, Up: Argz and Envz Vectors
5.12.2 Envz Functions
---------------------
Envz vectors are just argz vectors with additional constraints on the
form of each element; as such, argz functions can also be used on them,
where it makes sense.
Each element in an envz vector is a name-value pair, separated by a
`'='' character; if multiple `'='' characters are present in an
element, those after the first are considered part of the value, and
treated like all other non-`'\0'' characters.
If _no_ `'='' characters are present in an element, that element is
considered the name of a "null" entry, as distinct from an entry with an
empty value: `envz_get' will return `0' if given the name of null
entry, whereas an entry with an empty value would result in a value of
`""'; `envz_entry' will still find such entries, however. Null entries
can be removed with `envz_strip' function.
As with argz functions, envz functions that may allocate memory (and
thus fail) have a return type of `error_t', and return either `0' or
`ENOMEM'.
These functions are declared in the standard include file `envz.h'.
-- Function: char * envz_entry (const char *ENVZ, size_t ENVZ_LEN,
const char *NAME)
The `envz_entry' function finds the entry in ENVZ with the name
NAME, and returns a pointer to the whole entry--that is, the argz
element which begins with NAME followed by a `'='' character. If
there is no entry with that name, `0' is returned.
-- Function: char * envz_get (const char *ENVZ, size_t ENVZ_LEN, const
char *NAME)
The `envz_get' function finds the entry in ENVZ with the name NAME
(like `envz_entry'), and returns a pointer to the value portion of
that entry (following the `'=''). If there is no entry with that
name (or only a null entry), `0' is returned.
-- Function: error_t envz_add (char **ENVZ, size_t *ENVZ_LEN, const
char *NAME, const char *VALUE)
The `envz_add' function adds an entry to `*ENVZ' (updating `*ENVZ'
and `*ENVZ_LEN') with the name NAME, and value VALUE. If an entry
with the same name already exists in ENVZ, it is removed first.
If VALUE is `0', then the new entry will the special null type of
entry (mentioned above).
-- Function: error_t envz_merge (char **ENVZ, size_t *ENVZ_LEN, const
char *ENVZ2, size_t ENVZ2_LEN, int OVERRIDE)
The `envz_merge' function adds each entry in ENVZ2 to ENVZ, as if
with `envz_add', updating `*ENVZ' and `*ENVZ_LEN'. If OVERRIDE is
true, then values in ENVZ2 will supersede those with the same name
in ENVZ, otherwise not.
Null entries are treated just like other entries in this respect,
so a null entry in ENVZ can prevent an entry of the same name in
ENVZ2 from being added to ENVZ, if OVERRIDE is false.
-- Function: void envz_strip (char **ENVZ, size_t *ENVZ_LEN)
The `envz_strip' function removes any null entries from ENVZ,
updating `*ENVZ' and `*ENVZ_LEN'.

File: libc.info, Node: Character Set Handling, Next: Locales, Prev: String and Array Utilities, Up: Top
6 Character Set Handling
************************
Character sets used in the early days of computing had only six, seven,
or eight bits for each character: there was never a case where more than
eight bits (one byte) were used to represent a single character. The
limitations of this approach became more apparent as more people
grappled with non-Roman character sets, where not all the characters
that make up a language's character set can be represented by 2^8
choices. This chapter shows the functionality that was added to the C
library to support multiple character sets.
* Menu:
* Extended Char Intro:: Introduction to Extended Characters.
* Charset Function Overview:: Overview about Character Handling
Functions.
* Restartable multibyte conversion:: Restartable multibyte conversion
Functions.
* Non-reentrant Conversion:: Non-reentrant Conversion Function.
* Generic Charset Conversion:: Generic Charset Conversion.

File: libc.info, Node: Extended Char Intro, Next: Charset Function Overview, Up: Character Set Handling
6.1 Introduction to Extended Characters
=======================================
A variety of solutions is available to overcome the differences between
character sets with a 1:1 relation between bytes and characters and
character sets with ratios of 2:1 or 4:1. The remainder of this
section gives a few examples to help understand the design decisions
made while developing the functionality of the C library.
A distinction we have to make right away is between internal and
external representation. "Internal representation" means the
representation used by a program while keeping the text in memory.
External representations are used when text is stored or transmitted
through some communication channel. Examples of external
representations include files waiting in a directory to be read and
parsed.
Traditionally there has been no difference between the two
representations. It was equally comfortable and useful to use the same
single-byte representation internally and externally. This comfort
level decreases with more and larger character sets.
One of the problems to overcome with the internal representation is
handling text that is externally encoded using different character
sets. Assume a program that reads two texts and compares them using
some metric. The comparison can be usefully done only if the texts are
internally kept in a common format.
For such a common format (= character set) eight bits are certainly
no longer enough. So the smallest entity will have to grow: "wide
characters" will now be used. Instead of one byte per character, two or
four will be used instead. (Three are not good to address in memory and
more than four bytes seem not to be necessary).
As shown in some other part of this manual, a completely new family
has been created of functions that can handle wide character texts in
memory. The most commonly used character sets for such internal wide
character representations are Unicode and ISO 10646 (also known as UCS
for Universal Character Set). Unicode was originally planned as a
16-bit character set; whereas, ISO 10646 was designed to be a 31-bit
large code space. The two standards are practically identical. They
have the same character repertoire and code table, but Unicode specifies
added semantics. At the moment, only characters in the first `0x10000'
code positions (the so-called Basic Multilingual Plane, BMP) have been
assigned, but the assignment of more specialized characters outside this
16-bit space is already in progress. A number of encodings have been
defined for Unicode and ISO 10646 characters: UCS-2 is a 16-bit word
that can only represent characters from the BMP, UCS-4 is a 32-bit word
than can represent any Unicode and ISO 10646 character, UTF-8 is an
ASCII compatible encoding where ASCII characters are represented by
ASCII bytes and non-ASCII characters by sequences of 2-6 non-ASCII
bytes, and finally UTF-16 is an extension of UCS-2 in which pairs of
certain UCS-2 words can be used to encode non-BMP characters up to
`0x10ffff'.
To represent wide characters the `char' type is not suitable. For
this reason the ISO C standard introduces a new type that is designed
to keep one character of a wide character string. To maintain the
similarity there is also a type corresponding to `int' for those
functions that take a single wide character.
-- Data type: wchar_t
This data type is used as the base type for wide character strings.
In other words, arrays of objects of this type are the equivalent
of `char[]' for multibyte character strings. The type is defined
in `stddef.h'.
The ISO C90 standard, where `wchar_t' was introduced, does not say
anything specific about the representation. It only requires that
this type is capable of storing all elements of the basic
character set. Therefore it would be legitimate to define
`wchar_t' as `char', which might make sense for embedded systems.
But in the GNU C Library `wchar_t' is always 32 bits wide and,
therefore, capable of representing all UCS-4 values and,
therefore, covering all of ISO 10646. Some Unix systems define
`wchar_t' as a 16-bit type and thereby follow Unicode very
strictly. This definition is perfectly fine with the standard,
but it also means that to represent all characters from Unicode
and ISO 10646 one has to use UTF-16 surrogate characters, which is
in fact a multi-wide-character encoding. But resorting to
multi-wide-character encoding contradicts the purpose of the
`wchar_t' type.
-- Data type: wint_t
`wint_t' is a data type used for parameters and variables that
contain a single wide character. As the name suggests this type
is the equivalent of `int' when using the normal `char' strings.
The types `wchar_t' and `wint_t' often have the same
representation if their size is 32 bits wide but if `wchar_t' is
defined as `char' the type `wint_t' must be defined as `int' due
to the parameter promotion.
This type is defined in `wchar.h' and was introduced in
Amendment 1 to ISO C90.
As there are for the `char' data type macros are available for
specifying the minimum and maximum value representable in an object of
type `wchar_t'.
-- Macro: wint_t WCHAR_MIN
The macro `WCHAR_MIN' evaluates to the minimum value representable
by an object of type `wint_t'.
This macro was introduced in Amendment 1 to ISO C90.
-- Macro: wint_t WCHAR_MAX
The macro `WCHAR_MAX' evaluates to the maximum value representable
by an object of type `wint_t'.
This macro was introduced in Amendment 1 to ISO C90.
Another special wide character value is the equivalent to `EOF'.
-- Macro: wint_t WEOF
The macro `WEOF' evaluates to a constant expression of type
`wint_t' whose value is different from any member of the extended
character set.
`WEOF' need not be the same value as `EOF' and unlike `EOF' it
also need _not_ be negative. In other words, sloppy code like
{
int c;
...
while ((c = getc (fp)) < 0)
...
}
has to be rewritten to use `WEOF' explicitly when wide characters
are used:
{
wint_t c;
...
while ((c = wgetc (fp)) != WEOF)
...
}
This macro was introduced in Amendment 1 to ISO C90 and is defined
in `wchar.h'.
These internal representations present problems when it comes to
storing and transmittal. Because each single wide character consists
of more than one byte, they are affected by byte-ordering. Thus,
machines with different endianesses would see different values when
accessing the same data. This byte ordering concern also applies for
communication protocols that are all byte-based and therefore require
that the sender has to decide about splitting the wide character in
bytes. A last (but not least important) point is that wide characters
often require more storage space than a customized byte-oriented
character set.
For all the above reasons, an external encoding that is different
from the internal encoding is often used if the latter is UCS-2 or
UCS-4. The external encoding is byte-based and can be chosen
appropriately for the environment and for the texts to be handled. A
variety of different character sets can be used for this external
encoding (information that will not be exhaustively presented
here-instead, a description of the major groups will suffice). All of
the ASCII-based character sets fulfill one requirement: they are
"filesystem safe." This means that the character `'/'' is used in the
encoding _only_ to represent itself. Things are a bit different for
character sets like EBCDIC (Extended Binary Coded Decimal Interchange
Code, a character set family used by IBM), but if the operating system
does not understand EBCDIC directly the parameters-to-system calls have
to be converted first anyhow.
* The simplest character sets are single-byte character sets. There
can be only up to 256 characters (for 8 bit character sets), which
is not sufficient to cover all languages but might be sufficient
to handle a specific text. Handling of a 8 bit character sets is
simple. This is not true for other kinds presented later, and
therefore, the application one uses might require the use of 8 bit
character sets.
* The ISO 2022 standard defines a mechanism for extended character
sets where one character _can_ be represented by more than one
byte. This is achieved by associating a state with the text.
Characters that can be used to change the state can be embedded in
the text. Each byte in the text might have a different
interpretation in each state. The state might even influence
whether a given byte stands for a character on its own or whether
it has to be combined with some more bytes.
In most uses of ISO 2022 the defined character sets do not allow
state changes that cover more than the next character. This has
the big advantage that whenever one can identify the beginning of
the byte sequence of a character one can interpret a text
correctly. Examples of character sets using this policy are the
various EUC character sets (used by Sun's operating systems,
EUC-JP, EUC-KR, EUC-TW, and EUC-CN) or Shift_JIS (SJIS, a Japanese
encoding).
But there are also character sets using a state that is valid for
more than one character and has to be changed by another byte
sequence. Examples for this are ISO-2022-JP, ISO-2022-KR, and
ISO-2022-CN.
* Early attempts to fix 8 bit character sets for other languages
using the Roman alphabet lead to character sets like ISO 6937.
Here bytes representing characters like the acute accent do not
produce output themselves: one has to combine them with other
characters to get the desired result. For example, the byte
sequence `0xc2 0x61' (non-spacing acute accent, followed by
lower-case `a') to get the "small a with acute" character. To
get the acute accent character on its own, one has to write `0xc2
0x20' (the non-spacing acute followed by a space).
Character sets like ISO 6937 are used in some embedded systems such
as teletex.
* Instead of converting the Unicode or ISO 10646 text used
internally, it is often also sufficient to simply use an encoding
different than UCS-2/UCS-4. The Unicode and ISO 10646 standards
even specify such an encoding: UTF-8. This encoding is able to
represent all of ISO 10646 31 bits in a byte string of length one
to six.
There were a few other attempts to encode ISO 10646 such as UTF-7,
but UTF-8 is today the only encoding that should be used. In
fact, with any luck UTF-8 will soon be the only external encoding
that has to be supported. It proves to be universally usable and
its only disadvantage is that it favors Roman languages by making
the byte string representation of other scripts (Cyrillic, Greek,
Asian scripts) longer than necessary if using a specific character
set for these scripts. Methods like the Unicode compression
scheme can alleviate these problems.
The question remaining is: how to select the character set or
encoding to use. The answer: you cannot decide about it yourself, it
is decided by the developers of the system or the majority of the
users. Since the goal is interoperability one has to use whatever the
other people one works with use. If there are no constraints, the
selection is based on the requirements the expected circle of users
will have. In other words, if a project is expected to be used in
only, say, Russia it is fine to use KOI8-R or a similar character set.
But if at the same time people from, say, Greece are participating one
should use a character set that allows all people to collaborate.
The most widely useful solution seems to be: go with the most general
character set, namely ISO 10646. Use UTF-8 as the external encoding
and problems about users not being able to use their own language
adequately are a thing of the past.
One final comment about the choice of the wide character
representation is necessary at this point. We have said above that the
natural choice is using Unicode or ISO 10646. This is not required,
but at least encouraged, by the ISO C standard. The standard defines
at least a macro `__STDC_ISO_10646__' that is only defined on systems
where the `wchar_t' type encodes ISO 10646 characters. If this symbol
is not defined one should avoid making assumptions about the wide
character representation. If the programmer uses only the functions
provided by the C library to handle wide character strings there should
be no compatibility problems with other systems.

File: libc.info, Node: Charset Function Overview, Next: Restartable multibyte conversion, Prev: Extended Char Intro, Up: Character Set Handling
6.2 Overview about Character Handling Functions
===============================================
A Unix C library contains three different sets of functions in two
families to handle character set conversion. One of the function
families (the most commonly used) is specified in the ISO C90 standard
and, therefore, is portable even beyond the Unix world. Unfortunately
this family is the least useful one. These functions should be avoided
whenever possible, especially when developing libraries (as opposed to
applications).
The second family of functions got introduced in the early Unix
standards (XPG2) and is still part of the latest and greatest Unix
standard: Unix 98. It is also the most powerful and useful set of
functions. But we will start with the functions defined in Amendment 1
to ISO C90.

File: libc.info, Node: Restartable multibyte conversion, Next: Non-reentrant Conversion, Prev: Charset Function Overview, Up: Character Set Handling
6.3 Restartable Multibyte Conversion Functions
==============================================
The ISO C standard defines functions to convert strings from a
multibyte representation to wide character strings. There are a number
of peculiarities:
* The character set assumed for the multibyte encoding is not
specified as an argument to the functions. Instead the character
set specified by the `LC_CTYPE' category of the current locale is
used; see *note Locale Categories::.
* The functions handling more than one character at a time require
NUL terminated strings as the argument (i.e., converting blocks of
text does not work unless one can add a NUL byte at an appropriate
place). The GNU C Library contains some extensions to the
standard that allow specifying a size, but basically they also
expect terminated strings.
Despite these limitations the ISO C functions can be used in many
contexts. In graphical user interfaces, for instance, it is not
uncommon to have functions that require text to be displayed in a wide
character string if the text is not simple ASCII. The text itself might
come from a file with translations and the user should decide about the
current locale, which determines the translation and therefore also the
external encoding used. In such a situation (and many others) the
functions described here are perfect. If more freedom while performing
the conversion is necessary take a look at the `iconv' functions (*note
Generic Charset Conversion::).
* Menu:
* Selecting the Conversion:: Selecting the conversion and its properties.
* Keeping the state:: Representing the state of the conversion.
* Converting a Character:: Converting Single Characters.
* Converting Strings:: Converting Multibyte and Wide Character
Strings.
* Multibyte Conversion Example:: A Complete Multibyte Conversion Example.

File: libc.info, Node: Selecting the Conversion, Next: Keeping the state, Up: Restartable multibyte conversion
6.3.1 Selecting the conversion and its properties
-------------------------------------------------
We already said above that the currently selected locale for the
`LC_CTYPE' category decides about the conversion that is performed by
the functions we are about to describe. Each locale uses its own
character set (given as an argument to `localedef') and this is the one
assumed as the external multibyte encoding. The wide character set is
always UCS-4 in the GNU C Library.
A characteristic of each multibyte character set is the maximum
number of bytes that can be necessary to represent one character. This
information is quite important when writing code that uses the
conversion functions (as shown in the examples below). The ISO C
standard defines two macros that provide this information.
-- Macro: int MB_LEN_MAX
`MB_LEN_MAX' specifies the maximum number of bytes in the multibyte
sequence for a single character in any of the supported locales.
It is a compile-time constant and is defined in `limits.h'.
-- Macro: int MB_CUR_MAX
`MB_CUR_MAX' expands into a positive integer expression that is the
maximum number of bytes in a multibyte character in the current
locale. The value is never greater than `MB_LEN_MAX'. Unlike
`MB_LEN_MAX' this macro need not be a compile-time constant, and in
the GNU C Library it is not.
`MB_CUR_MAX' is defined in `stdlib.h'.
Two different macros are necessary since strictly ISO C90 compilers
do not allow variable length array definitions, but still it is
desirable to avoid dynamic allocation. This incomplete piece of code
shows the problem:
{
char buf[MB_LEN_MAX];
ssize_t len = 0;
while (! feof (fp))
{
fread (&buf[len], 1, MB_CUR_MAX - len, fp);
/* ... process buf */
len -= used;
}
}
The code in the inner loop is expected to have always enough bytes in
the array BUF to convert one multibyte character. The array BUF has to
be sized statically since many compilers do not allow a variable size.
The `fread' call makes sure that `MB_CUR_MAX' bytes are always
available in BUF. Note that it isn't a problem if `MB_CUR_MAX' is not
a compile-time constant.

File: libc.info, Node: Keeping the state, Next: Converting a Character, Prev: Selecting the Conversion, Up: Restartable multibyte conversion
6.3.2 Representing the state of the conversion
----------------------------------------------
In the introduction of this chapter it was said that certain character
sets use a "stateful" encoding. That is, the encoded values depend in
some way on the previous bytes in the text.
Since the conversion functions allow converting a text in more than
one step we must have a way to pass this information from one call of
the functions to another.
-- Data type: mbstate_t
A variable of type `mbstate_t' can contain all the information
about the "shift state" needed from one call to a conversion
function to another.
`mbstate_t' is defined in `wchar.h'. It was introduced in
Amendment 1 to ISO C90.
To use objects of type `mbstate_t' the programmer has to define such
objects (normally as local variables on the stack) and pass a pointer to
the object to the conversion functions. This way the conversion
function can update the object if the current multibyte character set
is stateful.
There is no specific function or initializer to put the state object
in any specific state. The rules are that the object should always
represent the initial state before the first use, and this is achieved
by clearing the whole variable with code such as follows:
{
mbstate_t state;
memset (&state, '\0', sizeof (state));
/* from now on STATE can be used. */
...
}
When using the conversion functions to generate output it is often
necessary to test whether the current state corresponds to the initial
state. This is necessary, for example, to decide whether to emit
escape sequences to set the state to the initial state at certain
sequence points. Communication protocols often require this.
-- Function: int mbsinit (const mbstate_t *PS)
The `mbsinit' function determines whether the state object pointed
to by PS is in the initial state. If PS is a null pointer or the
object is in the initial state the return value is nonzero.
Otherwise it is zero.
`mbsinit' was introduced in Amendment 1 to ISO C90 and is declared
in `wchar.h'.
Code using `mbsinit' often looks similar to this:
{
mbstate_t state;
memset (&state, '\0', sizeof (state));
/* Use STATE. */
...
if (! mbsinit (&state))
{
/* Emit code to return to initial state. */
const wchar_t empty[] = L"";
const wchar_t *srcp = empty;
wcsrtombs (outbuf, &srcp, outbuflen, &state);
}
...
}
The code to emit the escape sequence to get back to the initial
state is interesting. The `wcsrtombs' function can be used to
determine the necessary output code (*note Converting Strings::).
Please note that with the GNU C Library it is not necessary to perform
this extra action for the conversion from multibyte text to wide
character text since the wide character encoding is not stateful. But
there is nothing mentioned in any standard that prohibits making
`wchar_t' using a stateful encoding.

File: libc.info, Node: Converting a Character, Next: Converting Strings, Prev: Keeping the state, Up: Restartable multibyte conversion
6.3.3 Converting Single Characters
----------------------------------
The most fundamental of the conversion functions are those dealing with
single characters. Please note that this does not always mean single
bytes. But since there is very often a subset of the multibyte
character set that consists of single byte sequences, there are
functions to help with converting bytes. Frequently, ASCII is a subpart
of the multibyte character set. In such a scenario, each ASCII
character stands for itself, and all other characters have at least a
first byte that is beyond the range 0 to 127.
-- Function: wint_t btowc (int C)
The `btowc' function ("byte to wide character") converts a valid
single byte character C in the initial shift state into the wide
character equivalent using the conversion rules from the currently
selected locale of the `LC_CTYPE' category.
If `(unsigned char) C' is no valid single byte multibyte character
or if C is `EOF', the function returns `WEOF'.
Please note the restriction of C being tested for validity only in
the initial shift state. No `mbstate_t' object is used from which
the state information is taken, and the function also does not use
any static state.
The `btowc' function was introduced in Amendment 1 to ISO C90 and
is declared in `wchar.h'.
Despite the limitation that the single byte value is always
interpreted in the initial state, this function is actually useful most
of the time. Most characters are either entirely single-byte character
sets or they are extension to ASCII. But then it is possible to write
code like this (not that this specific example is very useful):
wchar_t *
itow (unsigned long int val)
{
static wchar_t buf[30];
wchar_t *wcp = &buf[29];
*wcp = L'\0';
while (val != 0)
{
*--wcp = btowc ('0' + val % 10);
val /= 10;
}
if (wcp == &buf[29])
*--wcp = L'0';
return wcp;
}
Why is it necessary to use such a complicated implementation and not
simply cast `'0' + val % 10' to a wide character? The answer is that
there is no guarantee that one can perform this kind of arithmetic on
the character of the character set used for `wchar_t' representation.
In other situations the bytes are not constant at compile time and so
the compiler cannot do the work. In situations like this, using
`btowc' is required.
There is also a function for the conversion in the other direction.
-- Function: int wctob (wint_t C)
The `wctob' function ("wide character to byte") takes as the
parameter a valid wide character. If the multibyte representation
for this character in the initial state is exactly one byte long,
the return value of this function is this character. Otherwise
the return value is `EOF'.
`wctob' was introduced in Amendment 1 to ISO C90 and is declared
in `wchar.h'.
There are more general functions to convert single character from
multibyte representation to wide characters and vice versa. These
functions pose no limit on the length of the multibyte representation
and they also do not require it to be in the initial state.
-- Function: size_t mbrtowc (wchar_t *restrict PWC, const char
*restrict S, size_t N, mbstate_t *restrict PS)
The `mbrtowc' function ("multibyte restartable to wide character")
converts the next multibyte character in the string pointed to by
S into a wide character and stores it in the wide character string
pointed to by PWC. The conversion is performed according to the
locale currently selected for the `LC_CTYPE' category. If the
conversion for the character set used in the locale requires a
state, the multibyte string is interpreted in the state
represented by the object pointed to by PS. If PS is a null
pointer, a static, internal state variable used only by the
`mbrtowc' function is used.
If the next multibyte character corresponds to the NUL wide
character, the return value of the function is 0 and the state
object is afterwards in the initial state. If the next N or fewer
bytes form a correct multibyte character, the return value is the
number of bytes starting from S that form the multibyte character.
The conversion state is updated according to the bytes consumed in
the conversion. In both cases the wide character (either the
`L'\0'' or the one found in the conversion) is stored in the
string pointed to by PWC if PWC is not null.
If the first N bytes of the multibyte string possibly form a valid
multibyte character but there are more than N bytes needed to
complete it, the return value of the function is `(size_t) -2' and
no value is stored. Please note that this can happen even if N
has a value greater than or equal to `MB_CUR_MAX' since the input
might contain redundant shift sequences.
If the first `n' bytes of the multibyte string cannot possibly form
a valid multibyte character, no value is stored, the global
variable `errno' is set to the value `EILSEQ', and the function
returns `(size_t) -1'. The conversion state is afterwards
undefined.
`mbrtowc' was introduced in Amendment 1 to ISO C90 and is declared
in `wchar.h'.
Use of `mbrtowc' is straightforward. A function that copies a
multibyte string into a wide character string while at the same time
converting all lowercase characters into uppercase could look like this
(this is not the final version, just an example; it has no error
checking, and sometimes leaks memory):
wchar_t *
mbstouwcs (const char *s)
{
size_t len = strlen (s);
wchar_t *result = malloc ((len + 1) * sizeof (wchar_t));
wchar_t *wcp = result;
wchar_t tmp[1];
mbstate_t state;
size_t nbytes;
memset (&state, '\0', sizeof (state));
while ((nbytes = mbrtowc (tmp, s, len, &state)) > 0)
{
if (nbytes >= (size_t) -2)
/* Invalid input string. */
return NULL;
*wcp++ = towupper (tmp[0]);
len -= nbytes;
s += nbytes;
}
return result;
}
The use of `mbrtowc' should be clear. A single wide character is
stored in `TMP[0]', and the number of consumed bytes is stored in the
variable NBYTES. If the conversion is successful, the uppercase
variant of the wide character is stored in the RESULT array and the
pointer to the input string and the number of available bytes is
adjusted.
The only non-obvious thing about `mbrtowc' might be the way memory
is allocated for the result. The above code uses the fact that there
can never be more wide characters in the converted results than there
are bytes in the multibyte input string. This method yields a
pessimistic guess about the size of the result, and if many wide
character strings have to be constructed this way or if the strings are
long, the extra memory required to be allocated because the input
string contains multibyte characters might be significant. The
allocated memory block can be resized to the correct size before
returning it, but a better solution might be to allocate just the right
amount of space for the result right away. Unfortunately there is no
function to compute the length of the wide character string directly
from the multibyte string. There is, however, a function that does
part of the work.
-- Function: size_t mbrlen (const char *restrict S, size_t N,
mbstate_t *PS)
The `mbrlen' function ("multibyte restartable length") computes
the number of at most N bytes starting at S, which form the next
valid and complete multibyte character.
If the next multibyte character corresponds to the NUL wide
character, the return value is 0. If the next N bytes form a valid
multibyte character, the number of bytes belonging to this
multibyte character byte sequence is returned.
If the first N bytes possibly form a valid multibyte character but
the character is incomplete, the return value is `(size_t) -2'.
Otherwise the multibyte character sequence is invalid and the
return value is `(size_t) -1'.
The multibyte sequence is interpreted in the state represented by
the object pointed to by PS. If PS is a null pointer, a state
object local to `mbrlen' is used.
`mbrlen' was introduced in Amendment 1 to ISO C90 and is declared
in `wchar.h'.
The attentive reader now will note that `mbrlen' can be implemented
as
mbrtowc (NULL, s, n, ps != NULL ? ps : &internal)
This is true and in fact is mentioned in the official specification.
How can this function be used to determine the length of the wide
character string created from a multibyte character string? It is not
directly usable, but we can define a function `mbslen' using it:
size_t
mbslen (const char *s)
{
mbstate_t state;
size_t result = 0;
size_t nbytes;
memset (&state, '\0', sizeof (state));
while ((nbytes = mbrlen (s, MB_LEN_MAX, &state)) > 0)
{
if (nbytes >= (size_t) -2)
/* Something is wrong. */
return (size_t) -1;
s += nbytes;
++result;
}
return result;
}
This function simply calls `mbrlen' for each multibyte character in
the string and counts the number of function calls. Please note that
we here use `MB_LEN_MAX' as the size argument in the `mbrlen' call.
This is acceptable since a) this value is larger then the length of the
longest multibyte character sequence and b) we know that the string S
ends with a NUL byte, which cannot be part of any other multibyte
character sequence but the one representing the NUL wide character.
Therefore, the `mbrlen' function will never read invalid memory.
Now that this function is available (just to make this clear, this
function is _not_ part of the GNU C Library) we can compute the number
of wide character required to store the converted multibyte character
string S using
wcs_bytes = (mbslen (s) + 1) * sizeof (wchar_t);
Please note that the `mbslen' function is quite inefficient. The
implementation of `mbstouwcs' with `mbslen' would have to perform the
conversion of the multibyte character input string twice, and this
conversion might be quite expensive. So it is necessary to think about
the consequences of using the easier but imprecise method before doing
the work twice.
-- Function: size_t wcrtomb (char *restrict S, wchar_t WC, mbstate_t
*restrict PS)
The `wcrtomb' function ("wide character restartable to multibyte")
converts a single wide character into a multibyte string
corresponding to that wide character.
If S is a null pointer, the function resets the state stored in
the objects pointed to by PS (or the internal `mbstate_t' object)
to the initial state. This can also be achieved by a call like
this:
wcrtombs (temp_buf, L'\0', ps)
since, if S is a null pointer, `wcrtomb' performs as if it writes
into an internal buffer, which is guaranteed to be large enough.
If WC is the NUL wide character, `wcrtomb' emits, if necessary, a
shift sequence to get the state PS into the initial state followed
by a single NUL byte, which is stored in the string S.
Otherwise a byte sequence (possibly including shift sequences) is
written into the string S. This only happens if WC is a valid wide
character (i.e., it has a multibyte representation in the
character set selected by locale of the `LC_CTYPE' category). If
WC is no valid wide character, nothing is stored in the strings S,
`errno' is set to `EILSEQ', the conversion state in PS is
undefined and the return value is `(size_t) -1'.
If no error occurred the function returns the number of bytes
stored in the string S. This includes all bytes representing shift
sequences.
One word about the interface of the function: there is no parameter
specifying the length of the array S. Instead the function
assumes that there are at least `MB_CUR_MAX' bytes available since
this is the maximum length of any byte sequence representing a
single character. So the caller has to make sure that there is
enough space available, otherwise buffer overruns can occur.
`wcrtomb' was introduced in Amendment 1 to ISO C90 and is declared
in `wchar.h'.
Using `wcrtomb' is as easy as using `mbrtowc'. The following
example appends a wide character string to a multibyte character string.
Again, the code is not really useful (or correct), it is simply here to
demonstrate the use and some problems.
char *
mbscatwcs (char *s, size_t len, const wchar_t *ws)
{
mbstate_t state;
/* Find the end of the existing string. */
char *wp = strchr (s, '\0');
len -= wp - s;
memset (&state, '\0', sizeof (state));
do
{
size_t nbytes;
if (len < MB_CUR_LEN)
{
/* We cannot guarantee that the next
character fits into the buffer, so
return an error. */
errno = E2BIG;
return NULL;
}
nbytes = wcrtomb (wp, *ws, &state);
if (nbytes == (size_t) -1)
/* Error in the conversion. */
return NULL;
len -= nbytes;
wp += nbytes;
}
while (*ws++ != L'\0');
return s;
}
First the function has to find the end of the string currently in the
array S. The `strchr' call does this very efficiently since a
requirement for multibyte character representations is that the NUL byte
is never used except to represent itself (and in this context, the end
of the string).
After initializing the state object the loop is entered where the
first task is to make sure there is enough room in the array S. We
abort if there are not at least `MB_CUR_LEN' bytes available. This is
not always optimal but we have no other choice. We might have less
than `MB_CUR_LEN' bytes available but the next multibyte character
might also be only one byte long. At the time the `wcrtomb' call
returns it is too late to decide whether the buffer was large enough.
If this solution is unsuitable, there is a very slow but more accurate
solution.
...
if (len < MB_CUR_LEN)
{
mbstate_t temp_state;
memcpy (&temp_state, &state, sizeof (state));
if (wcrtomb (NULL, *ws, &temp_state) > len)
{
/* We cannot guarantee that the next
character fits into the buffer, so
return an error. */
errno = E2BIG;
return NULL;
}
}
...
Here we perform the conversion that might overflow the buffer so that
we are afterwards in the position to make an exact decision about the
buffer size. Please note the `NULL' argument for the destination
buffer in the new `wcrtomb' call; since we are not interested in the
converted text at this point, this is a nice way to express this. The
most unusual thing about this piece of code certainly is the duplication
of the conversion state object, but if a change of the state is
necessary to emit the next multibyte character, we want to have the
same shift state change performed in the real conversion. Therefore,
we have to preserve the initial shift state information.
There are certainly many more and even better solutions to this
problem. This example is only provided for educational purposes.

File: libc.info, Node: Converting Strings, Next: Multibyte Conversion Example, Prev: Converting a Character, Up: Restartable multibyte conversion
6.3.4 Converting Multibyte and Wide Character Strings
-----------------------------------------------------
The functions described in the previous section only convert a single
character at a time. Most operations to be performed in real-world
programs include strings and therefore the ISO C standard also defines
conversions on entire strings. However, the defined set of functions
is quite limited; therefore, the GNU C Library contains a few
extensions that can help in some important situations.
-- Function: size_t mbsrtowcs (wchar_t *restrict DST, const char
**restrict SRC, size_t LEN, mbstate_t *restrict PS)
The `mbsrtowcs' function ("multibyte string restartable to wide
character string") converts an NUL-terminated multibyte character
string at `*SRC' into an equivalent wide character string,
including the NUL wide character at the end. The conversion is
started using the state information from the object pointed to by
PS or from an internal object of `mbsrtowcs' if PS is a null
pointer. Before returning, the state object is updated to match
the state after the last converted character. The state is the
initial state if the terminating NUL byte is reached and converted.
If DST is not a null pointer, the result is stored in the array
pointed to by DST; otherwise, the conversion result is not
available since it is stored in an internal buffer.
If LEN wide characters are stored in the array DST before reaching
the end of the input string, the conversion stops and LEN is
returned. If DST is a null pointer, LEN is never checked.
Another reason for a premature return from the function call is if
the input string contains an invalid multibyte sequence. In this
case the global variable `errno' is set to `EILSEQ' and the
function returns `(size_t) -1'.
In all other cases the function returns the number of wide
characters converted during this call. If DST is not null,
`mbsrtowcs' stores in the pointer pointed to by SRC either a null
pointer (if the NUL byte in the input string was reached) or the
address of the byte following the last converted multibyte
character.
`mbsrtowcs' was introduced in Amendment 1 to ISO C90 and is
declared in `wchar.h'.
The definition of the `mbsrtowcs' function has one important
limitation. The requirement that DST has to be a NUL-terminated string
provides problems if one wants to convert buffers with text. A buffer
is normally no collection of NUL-terminated strings but instead a
continuous collection of lines, separated by newline characters. Now
assume that a function to convert one line from a buffer is needed.
Since the line is not NUL-terminated, the source pointer cannot
directly point into the unmodified text buffer. This means, either one
inserts the NUL byte at the appropriate place for the time of the
`mbsrtowcs' function call (which is not doable for a read-only buffer
or in a multi-threaded application) or one copies the line in an extra
buffer where it can be terminated by a NUL byte. Note that it is not
in general possible to limit the number of characters to convert by
setting the parameter LEN to any specific value. Since it is not known
how many bytes each multibyte character sequence is in length, one can
only guess.
There is still a problem with the method of NUL-terminating a line
right after the newline character, which could lead to very strange
results. As said in the description of the `mbsrtowcs' function above
the conversion state is guaranteed to be in the initial shift state
after processing the NUL byte at the end of the input string. But this
NUL byte is not really part of the text (i.e., the conversion state
after the newline in the original text could be something different
than the initial shift state and therefore the first character of the
next line is encoded using this state). But the state in question is
never accessible to the user since the conversion stops after the NUL
byte (which resets the state). Most stateful character sets in use
today require that the shift state after a newline be the initial
state-but this is not a strict guarantee. Therefore, simply
NUL-terminating a piece of a running text is not always an adequate
solution and, therefore, should never be used in generally used code.
The generic conversion interface (*note Generic Charset Conversion::)
does not have this limitation (it simply works on buffers, not
strings), and the GNU C Library contains a set of functions that take
additional parameters specifying the maximal number of bytes that are
consumed from the input string. This way the problem of `mbsrtowcs''s
example above could be solved by determining the line length and
passing this length to the function.
-- Function: size_t wcsrtombs (char *restrict DST, const wchar_t
**restrict SRC, size_t LEN, mbstate_t *restrict PS)
The `wcsrtombs' function ("wide character string restartable to
multibyte string") converts the NUL-terminated wide character
string at `*SRC' into an equivalent multibyte character string and
stores the result in the array pointed to by DST. The NUL wide
character is also converted. The conversion starts in the state
described in the object pointed to by PS or by a state object
locally to `wcsrtombs' in case PS is a null pointer. If DST is a
null pointer, the conversion is performed as usual but the result
is not available. If all characters of the input string were
successfully converted and if DST is not a null pointer, the
pointer pointed to by SRC gets assigned a null pointer.
If one of the wide characters in the input string has no valid
multibyte character equivalent, the conversion stops early, sets
the global variable `errno' to `EILSEQ', and returns `(size_t) -1'.
Another reason for a premature stop is if DST is not a null
pointer and the next converted character would require more than
LEN bytes in total to the array DST. In this case (and if DEST is
not a null pointer) the pointer pointed to by SRC is assigned a
value pointing to the wide character right after the last one
successfully converted.
Except in the case of an encoding error the return value of the
`wcsrtombs' function is the number of bytes in all the multibyte
character sequences stored in DST. Before returning the state in
the object pointed to by PS (or the internal object in case PS is
a null pointer) is updated to reflect the state after the last
conversion. The state is the initial shift state in case the
terminating NUL wide character was converted.
The `wcsrtombs' function was introduced in Amendment 1 to ISO C90
and is declared in `wchar.h'.
The restriction mentioned above for the `mbsrtowcs' function applies
here also. There is no possibility of directly controlling the number
of input characters. One has to place the NUL wide character at the
correct place or control the consumed input indirectly via the
available output array size (the LEN parameter).
-- Function: size_t mbsnrtowcs (wchar_t *restrict DST, const char
**restrict SRC, size_t NMC, size_t LEN, mbstate_t *restrict
PS)
The `mbsnrtowcs' function is very similar to the `mbsrtowcs'
function. All the parameters are the same except for NMC, which is
new. The return value is the same as for `mbsrtowcs'.
This new parameter specifies how many bytes at most can be used
from the multibyte character string. In other words, the
multibyte character string `*SRC' need not be NUL-terminated. But
if a NUL byte is found within the NMC first bytes of the string,
the conversion stops here.
This function is a GNU extension. It is meant to work around the
problems mentioned above. Now it is possible to convert a buffer
with multibyte character text piece for piece without having to
care about inserting NUL bytes and the effect of NUL bytes on the
conversion state.
A function to convert a multibyte string into a wide character string
and display it could be written like this (this is not a really useful
example):
void
showmbs (const char *src, FILE *fp)
{
mbstate_t state;
int cnt = 0;
memset (&state, '\0', sizeof (state));
while (1)
{
wchar_t linebuf[100];
const char *endp = strchr (src, '\n');
size_t n;
/* Exit if there is no more line. */
if (endp == NULL)
break;
n = mbsnrtowcs (linebuf, &src, endp - src, 99, &state);
linebuf[n] = L'\0';
fprintf (fp, "line %d: \"%S\"\n", linebuf);