| This is libc.info, produced by makeinfo version 5.2 from libc.texinfo. |
| |
| This file documents the GNU C Library. |
| |
| This is 'The GNU C Library Reference Manual', for version 2.19 |
| (Buildroot). |
| |
| Copyright (C) 1993-2014 Free Software Foundation, Inc. |
| |
| Permission is granted to copy, distribute and/or modify this document |
| under the terms of the GNU Free Documentation License, Version 1.3 or |
| any later version published by the Free Software Foundation; with the |
| Invariant Sections being "Free Software Needs Free Documentation" and |
| "GNU Lesser General Public License", the Front-Cover texts being "A GNU |
| Manual", and with the Back-Cover Texts as in (a) below. A copy of the |
| license is included in the section entitled "GNU Free Documentation |
| License". |
| |
| (a) The FSF's Back-Cover Text is: "You have the freedom to copy and |
| modify this GNU manual. Buying copies from the FSF supports it in |
| developing GNU and promoting software freedom." |
| INFO-DIR-SECTION Software libraries |
| START-INFO-DIR-ENTRY |
| * Libc: (libc). C library. |
| END-INFO-DIR-ENTRY |
| |
| INFO-DIR-SECTION GNU C library functions and macros |
| START-INFO-DIR-ENTRY |
| * ALTWERASE: (libc)Local Modes. |
| * ARGP_ERR_UNKNOWN: (libc)Argp Parser Functions. |
| * ARG_MAX: (libc)General Limits. |
| * BC_BASE_MAX: (libc)Utility Limits. |
| * BC_DIM_MAX: (libc)Utility Limits. |
| * BC_SCALE_MAX: (libc)Utility Limits. |
| * BC_STRING_MAX: (libc)Utility Limits. |
| * BRKINT: (libc)Input Modes. |
| * BUFSIZ: (libc)Controlling Buffering. |
| * CCTS_OFLOW: (libc)Control Modes. |
| * CHILD_MAX: (libc)General Limits. |
| * CIGNORE: (libc)Control Modes. |
| * CLK_TCK: (libc)Processor Time. |
| * CLOCAL: (libc)Control Modes. |
| * CLOCKS_PER_SEC: (libc)CPU Time. |
| * COLL_WEIGHTS_MAX: (libc)Utility Limits. |
| * CPU_CLR: (libc)CPU Affinity. |
| * CPU_ISSET: (libc)CPU Affinity. |
| * CPU_SET: (libc)CPU Affinity. |
| * CPU_SETSIZE: (libc)CPU Affinity. |
| * CPU_ZERO: (libc)CPU Affinity. |
| * CREAD: (libc)Control Modes. |
| * CRTS_IFLOW: (libc)Control Modes. |
| * CS5: (libc)Control Modes. |
| * CS6: (libc)Control Modes. |
| * CS7: (libc)Control Modes. |
| * CS8: (libc)Control Modes. |
| * CSIZE: (libc)Control Modes. |
| * CSTOPB: (libc)Control Modes. |
| * DES_FAILED: (libc)DES Encryption. |
| * DTTOIF: (libc)Directory Entries. |
| * E2BIG: (libc)Error Codes. |
| * EACCES: (libc)Error Codes. |
| * EADDRINUSE: (libc)Error Codes. |
| * EADDRNOTAVAIL: (libc)Error Codes. |
| * EADV: (libc)Error Codes. |
| * EAFNOSUPPORT: (libc)Error Codes. |
| * EAGAIN: (libc)Error Codes. |
| * EALREADY: (libc)Error Codes. |
| * EAUTH: (libc)Error Codes. |
| * EBACKGROUND: (libc)Error Codes. |
| * EBADE: (libc)Error Codes. |
| * EBADF: (libc)Error Codes. |
| * EBADFD: (libc)Error Codes. |
| * EBADMSG: (libc)Error Codes. |
| * EBADR: (libc)Error Codes. |
| * EBADRPC: (libc)Error Codes. |
| * EBADRQC: (libc)Error Codes. |
| * EBADSLT: (libc)Error Codes. |
| * EBFONT: (libc)Error Codes. |
| * EBUSY: (libc)Error Codes. |
| * ECANCELED: (libc)Error Codes. |
| * ECHILD: (libc)Error Codes. |
| * ECHO: (libc)Local Modes. |
| * ECHOCTL: (libc)Local Modes. |
| * ECHOE: (libc)Local Modes. |
| * ECHOK: (libc)Local Modes. |
| * ECHOKE: (libc)Local Modes. |
| * ECHONL: (libc)Local Modes. |
| * ECHOPRT: (libc)Local Modes. |
| * ECHRNG: (libc)Error Codes. |
| * ECOMM: (libc)Error Codes. |
| * ECONNABORTED: (libc)Error Codes. |
| * ECONNREFUSED: (libc)Error Codes. |
| * ECONNRESET: (libc)Error Codes. |
| * ED: (libc)Error Codes. |
| * EDEADLK: (libc)Error Codes. |
| * EDEADLOCK: (libc)Error Codes. |
| * EDESTADDRREQ: (libc)Error Codes. |
| * EDIED: (libc)Error Codes. |
| * EDOM: (libc)Error Codes. |
| * EDOTDOT: (libc)Error Codes. |
| * EDQUOT: (libc)Error Codes. |
| * EEXIST: (libc)Error Codes. |
| * EFAULT: (libc)Error Codes. |
| * EFBIG: (libc)Error Codes. |
| * EFTYPE: (libc)Error Codes. |
| * EGRATUITOUS: (libc)Error Codes. |
| * EGREGIOUS: (libc)Error Codes. |
| * EHOSTDOWN: (libc)Error Codes. |
| * EHOSTUNREACH: (libc)Error Codes. |
| * EHWPOISON: (libc)Error Codes. |
| * EIDRM: (libc)Error Codes. |
| * EIEIO: (libc)Error Codes. |
| * EILSEQ: (libc)Error Codes. |
| * EINPROGRESS: (libc)Error Codes. |
| * EINTR: (libc)Error Codes. |
| * EINVAL: (libc)Error Codes. |
| * EIO: (libc)Error Codes. |
| * EISCONN: (libc)Error Codes. |
| * EISDIR: (libc)Error Codes. |
| * EISNAM: (libc)Error Codes. |
| * EKEYEXPIRED: (libc)Error Codes. |
| * EKEYREJECTED: (libc)Error Codes. |
| * EKEYREVOKED: (libc)Error Codes. |
| * EL2HLT: (libc)Error Codes. |
| * EL2NSYNC: (libc)Error Codes. |
| * EL3HLT: (libc)Error Codes. |
| * EL3RST: (libc)Error Codes. |
| * ELIBACC: (libc)Error Codes. |
| * ELIBBAD: (libc)Error Codes. |
| * ELIBEXEC: (libc)Error Codes. |
| * ELIBMAX: (libc)Error Codes. |
| * ELIBSCN: (libc)Error Codes. |
| * ELNRNG: (libc)Error Codes. |
| * ELOOP: (libc)Error Codes. |
| * EMEDIUMTYPE: (libc)Error Codes. |
| * EMFILE: (libc)Error Codes. |
| * EMLINK: (libc)Error Codes. |
| * EMSGSIZE: (libc)Error Codes. |
| * EMULTIHOP: (libc)Error Codes. |
| * ENAMETOOLONG: (libc)Error Codes. |
| * ENAVAIL: (libc)Error Codes. |
| * ENEEDAUTH: (libc)Error Codes. |
| * ENETDOWN: (libc)Error Codes. |
| * ENETRESET: (libc)Error Codes. |
| * ENETUNREACH: (libc)Error Codes. |
| * ENFILE: (libc)Error Codes. |
| * ENOANO: (libc)Error Codes. |
| * ENOBUFS: (libc)Error Codes. |
| * ENOCSI: (libc)Error Codes. |
| * ENODATA: (libc)Error Codes. |
| * ENODEV: (libc)Error Codes. |
| * ENOENT: (libc)Error Codes. |
| * ENOEXEC: (libc)Error Codes. |
| * ENOKEY: (libc)Error Codes. |
| * ENOLCK: (libc)Error Codes. |
| * ENOLINK: (libc)Error Codes. |
| * ENOMEDIUM: (libc)Error Codes. |
| * ENOMEM: (libc)Error Codes. |
| * ENOMSG: (libc)Error Codes. |
| * ENONET: (libc)Error Codes. |
| * ENOPKG: (libc)Error Codes. |
| * ENOPROTOOPT: (libc)Error Codes. |
| * ENOSPC: (libc)Error Codes. |
| * ENOSR: (libc)Error Codes. |
| * ENOSTR: (libc)Error Codes. |
| * ENOSYS: (libc)Error Codes. |
| * ENOTBLK: (libc)Error Codes. |
| * ENOTCONN: (libc)Error Codes. |
| * ENOTDIR: (libc)Error Codes. |
| * ENOTEMPTY: (libc)Error Codes. |
| * ENOTNAM: (libc)Error Codes. |
| * ENOTRECOVERABLE: (libc)Error Codes. |
| * ENOTSOCK: (libc)Error Codes. |
| * ENOTSUP: (libc)Error Codes. |
| * ENOTTY: (libc)Error Codes. |
| * ENOTUNIQ: (libc)Error Codes. |
| * ENXIO: (libc)Error Codes. |
| * EOF: (libc)EOF and Errors. |
| * EOPNOTSUPP: (libc)Error Codes. |
| * EOVERFLOW: (libc)Error Codes. |
| * EOWNERDEAD: (libc)Error Codes. |
| * EPERM: (libc)Error Codes. |
| * EPFNOSUPPORT: (libc)Error Codes. |
| * EPIPE: (libc)Error Codes. |
| * EPROCLIM: (libc)Error Codes. |
| * EPROCUNAVAIL: (libc)Error Codes. |
| * EPROGMISMATCH: (libc)Error Codes. |
| * EPROGUNAVAIL: (libc)Error Codes. |
| * EPROTO: (libc)Error Codes. |
| * EPROTONOSUPPORT: (libc)Error Codes. |
| * EPROTOTYPE: (libc)Error Codes. |
| * EQUIV_CLASS_MAX: (libc)Utility Limits. |
| * ERANGE: (libc)Error Codes. |
| * EREMCHG: (libc)Error Codes. |
| * EREMOTE: (libc)Error Codes. |
| * EREMOTEIO: (libc)Error Codes. |
| * ERESTART: (libc)Error Codes. |
| * ERFKILL: (libc)Error Codes. |
| * EROFS: (libc)Error Codes. |
| * ERPCMISMATCH: (libc)Error Codes. |
| * ESHUTDOWN: (libc)Error Codes. |
| * ESOCKTNOSUPPORT: (libc)Error Codes. |
| * ESPIPE: (libc)Error Codes. |
| * ESRCH: (libc)Error Codes. |
| * ESRMNT: (libc)Error Codes. |
| * ESTALE: (libc)Error Codes. |
| * ESTRPIPE: (libc)Error Codes. |
| * ETIME: (libc)Error Codes. |
| * ETIMEDOUT: (libc)Error Codes. |
| * ETOOMANYREFS: (libc)Error Codes. |
| * ETXTBSY: (libc)Error Codes. |
| * EUCLEAN: (libc)Error Codes. |
| * EUNATCH: (libc)Error Codes. |
| * EUSERS: (libc)Error Codes. |
| * EWOULDBLOCK: (libc)Error Codes. |
| * EXDEV: (libc)Error Codes. |
| * EXFULL: (libc)Error Codes. |
| * EXIT_FAILURE: (libc)Exit Status. |
| * EXIT_SUCCESS: (libc)Exit Status. |
| * EXPR_NEST_MAX: (libc)Utility Limits. |
| * FD_CLOEXEC: (libc)Descriptor Flags. |
| * FD_CLR: (libc)Waiting for I/O. |
| * FD_ISSET: (libc)Waiting for I/O. |
| * FD_SET: (libc)Waiting for I/O. |
| * FD_SETSIZE: (libc)Waiting for I/O. |
| * FD_ZERO: (libc)Waiting for I/O. |
| * FILENAME_MAX: (libc)Limits for Files. |
| * FLUSHO: (libc)Local Modes. |
| * FOPEN_MAX: (libc)Opening Streams. |
| * FP_ILOGB0: (libc)Exponents and Logarithms. |
| * FP_ILOGBNAN: (libc)Exponents and Logarithms. |
| * F_DUPFD: (libc)Duplicating Descriptors. |
| * F_GETFD: (libc)Descriptor Flags. |
| * F_GETFL: (libc)Getting File Status Flags. |
| * F_GETLK: (libc)File Locks. |
| * F_GETOWN: (libc)Interrupt Input. |
| * F_OK: (libc)Testing File Access. |
| * F_SETFD: (libc)Descriptor Flags. |
| * F_SETFL: (libc)Getting File Status Flags. |
| * F_SETLK: (libc)File Locks. |
| * F_SETLKW: (libc)File Locks. |
| * F_SETOWN: (libc)Interrupt Input. |
| * HUGE_VAL: (libc)Math Error Reporting. |
| * HUGE_VALF: (libc)Math Error Reporting. |
| * HUGE_VALL: (libc)Math Error Reporting. |
| * HUPCL: (libc)Control Modes. |
| * I: (libc)Complex Numbers. |
| * ICANON: (libc)Local Modes. |
| * ICRNL: (libc)Input Modes. |
| * IEXTEN: (libc)Local Modes. |
| * IFNAMSIZ: (libc)Interface Naming. |
| * IFTODT: (libc)Directory Entries. |
| * IGNBRK: (libc)Input Modes. |
| * IGNCR: (libc)Input Modes. |
| * IGNPAR: (libc)Input Modes. |
| * IMAXBEL: (libc)Input Modes. |
| * INADDR_ANY: (libc)Host Address Data Type. |
| * INADDR_BROADCAST: (libc)Host Address Data Type. |
| * INADDR_LOOPBACK: (libc)Host Address Data Type. |
| * INADDR_NONE: (libc)Host Address Data Type. |
| * INFINITY: (libc)Infinity and NaN. |
| * INLCR: (libc)Input Modes. |
| * INPCK: (libc)Input Modes. |
| * IPPORT_RESERVED: (libc)Ports. |
| * IPPORT_USERRESERVED: (libc)Ports. |
| * ISIG: (libc)Local Modes. |
| * ISTRIP: (libc)Input Modes. |
| * IXANY: (libc)Input Modes. |
| * IXOFF: (libc)Input Modes. |
| * IXON: (libc)Input Modes. |
| * LINE_MAX: (libc)Utility Limits. |
| * LINK_MAX: (libc)Limits for Files. |
| * L_ctermid: (libc)Identifying the Terminal. |
| * L_cuserid: (libc)Who Logged In. |
| * L_tmpnam: (libc)Temporary Files. |
| * MAXNAMLEN: (libc)Limits for Files. |
| * MAXSYMLINKS: (libc)Symbolic Links. |
| * MAX_CANON: (libc)Limits for Files. |
| * MAX_INPUT: (libc)Limits for Files. |
| * MB_CUR_MAX: (libc)Selecting the Conversion. |
| * MB_LEN_MAX: (libc)Selecting the Conversion. |
| * MDMBUF: (libc)Control Modes. |
| * MSG_DONTROUTE: (libc)Socket Data Options. |
| * MSG_OOB: (libc)Socket Data Options. |
| * MSG_PEEK: (libc)Socket Data Options. |
| * NAME_MAX: (libc)Limits for Files. |
| * NAN: (libc)Infinity and NaN. |
| * NCCS: (libc)Mode Data Types. |
| * NGROUPS_MAX: (libc)General Limits. |
| * NOFLSH: (libc)Local Modes. |
| * NOKERNINFO: (libc)Local Modes. |
| * NSIG: (libc)Standard Signals. |
| * NULL: (libc)Null Pointer Constant. |
| * ONLCR: (libc)Output Modes. |
| * ONOEOT: (libc)Output Modes. |
| * OPEN_MAX: (libc)General Limits. |
| * OPOST: (libc)Output Modes. |
| * OXTABS: (libc)Output Modes. |
| * O_ACCMODE: (libc)Access Modes. |
| * O_APPEND: (libc)Operating Modes. |
| * O_ASYNC: (libc)Operating Modes. |
| * O_CREAT: (libc)Open-time Flags. |
| * O_EXCL: (libc)Open-time Flags. |
| * O_EXEC: (libc)Access Modes. |
| * O_EXLOCK: (libc)Open-time Flags. |
| * O_FSYNC: (libc)Operating Modes. |
| * O_IGNORE_CTTY: (libc)Open-time Flags. |
| * O_NDELAY: (libc)Operating Modes. |
| * O_NOATIME: (libc)Operating Modes. |
| * O_NOCTTY: (libc)Open-time Flags. |
| * O_NOLINK: (libc)Open-time Flags. |
| * O_NONBLOCK: (libc)Open-time Flags. |
| * O_NONBLOCK: (libc)Operating Modes. |
| * O_NOTRANS: (libc)Open-time Flags. |
| * O_RDONLY: (libc)Access Modes. |
| * O_RDWR: (libc)Access Modes. |
| * O_READ: (libc)Access Modes. |
| * O_SHLOCK: (libc)Open-time Flags. |
| * O_SYNC: (libc)Operating Modes. |
| * O_TRUNC: (libc)Open-time Flags. |
| * O_WRITE: (libc)Access Modes. |
| * O_WRONLY: (libc)Access Modes. |
| * PARENB: (libc)Control Modes. |
| * PARMRK: (libc)Input Modes. |
| * PARODD: (libc)Control Modes. |
| * PATH_MAX: (libc)Limits for Files. |
| * PA_FLAG_MASK: (libc)Parsing a Template String. |
| * PENDIN: (libc)Local Modes. |
| * PF_FILE: (libc)Local Namespace Details. |
| * PF_INET6: (libc)Internet Namespace. |
| * PF_INET: (libc)Internet Namespace. |
| * PF_LOCAL: (libc)Local Namespace Details. |
| * PF_UNIX: (libc)Local Namespace Details. |
| * PIPE_BUF: (libc)Limits for Files. |
| * P_tmpdir: (libc)Temporary Files. |
| * RAND_MAX: (libc)ISO Random. |
| * RE_DUP_MAX: (libc)General Limits. |
| * RLIM_INFINITY: (libc)Limits on Resources. |
| * R_OK: (libc)Testing File Access. |
| * SA_NOCLDSTOP: (libc)Flags for Sigaction. |
| * SA_ONSTACK: (libc)Flags for Sigaction. |
| * SA_RESTART: (libc)Flags for Sigaction. |
| * SEEK_CUR: (libc)File Positioning. |
| * SEEK_END: (libc)File Positioning. |
| * SEEK_SET: (libc)File Positioning. |
| * SIGABRT: (libc)Program Error Signals. |
| * SIGALRM: (libc)Alarm Signals. |
| * SIGBUS: (libc)Program Error Signals. |
| * SIGCHLD: (libc)Job Control Signals. |
| * SIGCLD: (libc)Job Control Signals. |
| * SIGCONT: (libc)Job Control Signals. |
| * SIGEMT: (libc)Program Error Signals. |
| * SIGFPE: (libc)Program Error Signals. |
| * SIGHUP: (libc)Termination Signals. |
| * SIGILL: (libc)Program Error Signals. |
| * SIGINFO: (libc)Miscellaneous Signals. |
| * SIGINT: (libc)Termination Signals. |
| * SIGIO: (libc)Asynchronous I/O Signals. |
| * SIGIOT: (libc)Program Error Signals. |
| * SIGKILL: (libc)Termination Signals. |
| * SIGLOST: (libc)Operation Error Signals. |
| * SIGPIPE: (libc)Operation Error Signals. |
| * SIGPOLL: (libc)Asynchronous I/O Signals. |
| * SIGPROF: (libc)Alarm Signals. |
| * SIGQUIT: (libc)Termination Signals. |
| * SIGSEGV: (libc)Program Error Signals. |
| * SIGSTOP: (libc)Job Control Signals. |
| * SIGSYS: (libc)Program Error Signals. |
| * SIGTERM: (libc)Termination Signals. |
| * SIGTRAP: (libc)Program Error Signals. |
| * SIGTSTP: (libc)Job Control Signals. |
| * SIGTTIN: (libc)Job Control Signals. |
| * SIGTTOU: (libc)Job Control Signals. |
| * SIGURG: (libc)Asynchronous I/O Signals. |
| * SIGUSR1: (libc)Miscellaneous Signals. |
| * SIGUSR2: (libc)Miscellaneous Signals. |
| * SIGVTALRM: (libc)Alarm Signals. |
| * SIGWINCH: (libc)Miscellaneous Signals. |
| * SIGXCPU: (libc)Operation Error Signals. |
| * SIGXFSZ: (libc)Operation Error Signals. |
| * SIG_ERR: (libc)Basic Signal Handling. |
| * SOCK_DGRAM: (libc)Communication Styles. |
| * SOCK_RAW: (libc)Communication Styles. |
| * SOCK_RDM: (libc)Communication Styles. |
| * SOCK_SEQPACKET: (libc)Communication Styles. |
| * SOCK_STREAM: (libc)Communication Styles. |
| * SOL_SOCKET: (libc)Socket-Level Options. |
| * SSIZE_MAX: (libc)General Limits. |
| * STREAM_MAX: (libc)General Limits. |
| * SUN_LEN: (libc)Local Namespace Details. |
| * SV_INTERRUPT: (libc)BSD Handler. |
| * SV_ONSTACK: (libc)BSD Handler. |
| * SV_RESETHAND: (libc)BSD Handler. |
| * S_IFMT: (libc)Testing File Type. |
| * S_ISBLK: (libc)Testing File Type. |
| * S_ISCHR: (libc)Testing File Type. |
| * S_ISDIR: (libc)Testing File Type. |
| * S_ISFIFO: (libc)Testing File Type. |
| * S_ISLNK: (libc)Testing File Type. |
| * S_ISREG: (libc)Testing File Type. |
| * S_ISSOCK: (libc)Testing File Type. |
| * S_TYPEISMQ: (libc)Testing File Type. |
| * S_TYPEISSEM: (libc)Testing File Type. |
| * S_TYPEISSHM: (libc)Testing File Type. |
| * TMP_MAX: (libc)Temporary Files. |
| * TOSTOP: (libc)Local Modes. |
| * TZNAME_MAX: (libc)General Limits. |
| * VDISCARD: (libc)Other Special. |
| * VDSUSP: (libc)Signal Characters. |
| * VEOF: (libc)Editing Characters. |
| * VEOL2: (libc)Editing Characters. |
| * VEOL: (libc)Editing Characters. |
| * VERASE: (libc)Editing Characters. |
| * VINTR: (libc)Signal Characters. |
| * VKILL: (libc)Editing Characters. |
| * VLNEXT: (libc)Other Special. |
| * VMIN: (libc)Noncanonical Input. |
| * VQUIT: (libc)Signal Characters. |
| * VREPRINT: (libc)Editing Characters. |
| * VSTART: (libc)Start/Stop Characters. |
| * VSTATUS: (libc)Other Special. |
| * VSTOP: (libc)Start/Stop Characters. |
| * VSUSP: (libc)Signal Characters. |
| * VTIME: (libc)Noncanonical Input. |
| * VWERASE: (libc)Editing Characters. |
| * WCHAR_MAX: (libc)Extended Char Intro. |
| * WCHAR_MIN: (libc)Extended Char Intro. |
| * WCOREDUMP: (libc)Process Completion Status. |
| * WEOF: (libc)EOF and Errors. |
| * WEOF: (libc)Extended Char Intro. |
| * WEXITSTATUS: (libc)Process Completion Status. |
| * WIFEXITED: (libc)Process Completion Status. |
| * WIFSIGNALED: (libc)Process Completion Status. |
| * WIFSTOPPED: (libc)Process Completion Status. |
| * WSTOPSIG: (libc)Process Completion Status. |
| * WTERMSIG: (libc)Process Completion Status. |
| * W_OK: (libc)Testing File Access. |
| * X_OK: (libc)Testing File Access. |
| * _Complex_I: (libc)Complex Numbers. |
| * _Exit: (libc)Termination Internals. |
| * _IOFBF: (libc)Controlling Buffering. |
| * _IOLBF: (libc)Controlling Buffering. |
| * _IONBF: (libc)Controlling Buffering. |
| * _Imaginary_I: (libc)Complex Numbers. |
| * _PATH_UTMP: (libc)Manipulating the Database. |
| * _PATH_WTMP: (libc)Manipulating the Database. |
| * _POSIX2_C_DEV: (libc)System Options. |
| * _POSIX2_C_VERSION: (libc)Version Supported. |
| * _POSIX2_FORT_DEV: (libc)System Options. |
| * _POSIX2_FORT_RUN: (libc)System Options. |
| * _POSIX2_LOCALEDEF: (libc)System Options. |
| * _POSIX2_SW_DEV: (libc)System Options. |
| * _POSIX_CHOWN_RESTRICTED: (libc)Options for Files. |
| * _POSIX_JOB_CONTROL: (libc)System Options. |
| * _POSIX_NO_TRUNC: (libc)Options for Files. |
| * _POSIX_SAVED_IDS: (libc)System Options. |
| * _POSIX_VDISABLE: (libc)Options for Files. |
| * _POSIX_VERSION: (libc)Version Supported. |
| * __fbufsize: (libc)Controlling Buffering. |
| * __flbf: (libc)Controlling Buffering. |
| * __fpending: (libc)Controlling Buffering. |
| * __fpurge: (libc)Flushing Buffers. |
| * __freadable: (libc)Opening Streams. |
| * __freading: (libc)Opening Streams. |
| * __fsetlocking: (libc)Streams and Threads. |
| * __fwritable: (libc)Opening Streams. |
| * __fwriting: (libc)Opening Streams. |
| * __gconv_end_fct: (libc)glibc iconv Implementation. |
| * __gconv_fct: (libc)glibc iconv Implementation. |
| * __gconv_init_fct: (libc)glibc iconv Implementation. |
| * __ppc_get_timebase: (libc)PowerPC. |
| * __ppc_get_timebase_freq: (libc)PowerPC. |
| * __ppc_mdoio: (libc)PowerPC. |
| * __ppc_mdoom: (libc)PowerPC. |
| * __ppc_set_ppr_low: (libc)PowerPC. |
| * __ppc_set_ppr_med: (libc)PowerPC. |
| * __ppc_set_ppr_med_low: (libc)PowerPC. |
| * __ppc_yield: (libc)PowerPC. |
| * __va_copy: (libc)Argument Macros. |
| * _exit: (libc)Termination Internals. |
| * _flushlbf: (libc)Flushing Buffers. |
| * _tolower: (libc)Case Conversion. |
| * _toupper: (libc)Case Conversion. |
| * a64l: (libc)Encode Binary Data. |
| * abort: (libc)Aborting a Program. |
| * abs: (libc)Absolute Value. |
| * accept: (libc)Accepting Connections. |
| * access: (libc)Testing File Access. |
| * acos: (libc)Inverse Trig Functions. |
| * acosf: (libc)Inverse Trig Functions. |
| * acosh: (libc)Hyperbolic Functions. |
| * acoshf: (libc)Hyperbolic Functions. |
| * acoshl: (libc)Hyperbolic Functions. |
| * acosl: (libc)Inverse Trig Functions. |
| * addmntent: (libc)mtab. |
| * addseverity: (libc)Adding Severity Classes. |
| * adjtime: (libc)High-Resolution Calendar. |
| * adjtimex: (libc)High-Resolution Calendar. |
| * aio_cancel64: (libc)Cancel AIO Operations. |
| * aio_cancel: (libc)Cancel AIO Operations. |
| * aio_error64: (libc)Status of AIO Operations. |
| * aio_error: (libc)Status of AIO Operations. |
| * aio_fsync64: (libc)Synchronizing AIO Operations. |
| * aio_fsync: (libc)Synchronizing AIO Operations. |
| * aio_init: (libc)Configuration of AIO. |
| * aio_read64: (libc)Asynchronous Reads/Writes. |
| * aio_read: (libc)Asynchronous Reads/Writes. |
| * aio_return64: (libc)Status of AIO Operations. |
| * aio_return: (libc)Status of AIO Operations. |
| * aio_suspend64: (libc)Synchronizing AIO Operations. |
| * aio_suspend: (libc)Synchronizing AIO Operations. |
| * aio_write64: (libc)Asynchronous Reads/Writes. |
| * aio_write: (libc)Asynchronous Reads/Writes. |
| * alarm: (libc)Setting an Alarm. |
| * aligned_alloc: (libc)Aligned Memory Blocks. |
| * alloca: (libc)Variable Size Automatic. |
| * alphasort64: (libc)Scanning Directory Content. |
| * alphasort: (libc)Scanning Directory Content. |
| * argp_error: (libc)Argp Helper Functions. |
| * argp_failure: (libc)Argp Helper Functions. |
| * argp_help: (libc)Argp Help. |
| * argp_parse: (libc)Argp. |
| * argp_state_help: (libc)Argp Helper Functions. |
| * argp_usage: (libc)Argp Helper Functions. |
| * argz_add: (libc)Argz Functions. |
| * argz_add_sep: (libc)Argz Functions. |
| * argz_append: (libc)Argz Functions. |
| * argz_count: (libc)Argz Functions. |
| * argz_create: (libc)Argz Functions. |
| * argz_create_sep: (libc)Argz Functions. |
| * argz_delete: (libc)Argz Functions. |
| * argz_extract: (libc)Argz Functions. |
| * argz_insert: (libc)Argz Functions. |
| * argz_next: (libc)Argz Functions. |
| * argz_replace: (libc)Argz Functions. |
| * argz_stringify: (libc)Argz Functions. |
| * asctime: (libc)Formatting Calendar Time. |
| * asctime_r: (libc)Formatting Calendar Time. |
| * asin: (libc)Inverse Trig Functions. |
| * asinf: (libc)Inverse Trig Functions. |
| * asinh: (libc)Hyperbolic Functions. |
| * asinhf: (libc)Hyperbolic Functions. |
| * asinhl: (libc)Hyperbolic Functions. |
| * asinl: (libc)Inverse Trig Functions. |
| * asprintf: (libc)Dynamic Output. |
| * assert: (libc)Consistency Checking. |
| * assert_perror: (libc)Consistency Checking. |
| * atan2: (libc)Inverse Trig Functions. |
| * atan2f: (libc)Inverse Trig Functions. |
| * atan2l: (libc)Inverse Trig Functions. |
| * atan: (libc)Inverse Trig Functions. |
| * atanf: (libc)Inverse Trig Functions. |
| * atanh: (libc)Hyperbolic Functions. |
| * atanhf: (libc)Hyperbolic Functions. |
| * atanhl: (libc)Hyperbolic Functions. |
| * atanl: (libc)Inverse Trig Functions. |
| * atexit: (libc)Cleanups on Exit. |
| * atof: (libc)Parsing of Floats. |
| * atoi: (libc)Parsing of Integers. |
| * atol: (libc)Parsing of Integers. |
| * atoll: (libc)Parsing of Integers. |
| * backtrace: (libc)Backtraces. |
| * backtrace_symbols: (libc)Backtraces. |
| * backtrace_symbols_fd: (libc)Backtraces. |
| * basename: (libc)Finding Tokens in a String. |
| * basename: (libc)Finding Tokens in a String. |
| * bcmp: (libc)String/Array Comparison. |
| * bcopy: (libc)Copying and Concatenation. |
| * bind: (libc)Setting Address. |
| * bind_textdomain_codeset: (libc)Charset conversion in gettext. |
| * bindtextdomain: (libc)Locating gettext catalog. |
| * brk: (libc)Resizing the Data Segment. |
| * bsearch: (libc)Array Search Function. |
| * btowc: (libc)Converting a Character. |
| * bzero: (libc)Copying and Concatenation. |
| * cabs: (libc)Absolute Value. |
| * cabsf: (libc)Absolute Value. |
| * cabsl: (libc)Absolute Value. |
| * cacos: (libc)Inverse Trig Functions. |
| * cacosf: (libc)Inverse Trig Functions. |
| * cacosh: (libc)Hyperbolic Functions. |
| * cacoshf: (libc)Hyperbolic Functions. |
| * cacoshl: (libc)Hyperbolic Functions. |
| * cacosl: (libc)Inverse Trig Functions. |
| * calloc: (libc)Allocating Cleared Space. |
| * canonicalize_file_name: (libc)Symbolic Links. |
| * carg: (libc)Operations on Complex. |
| * cargf: (libc)Operations on Complex. |
| * cargl: (libc)Operations on Complex. |
| * casin: (libc)Inverse Trig Functions. |
| * casinf: (libc)Inverse Trig Functions. |
| * casinh: (libc)Hyperbolic Functions. |
| * casinhf: (libc)Hyperbolic Functions. |
| * casinhl: (libc)Hyperbolic Functions. |
| * casinl: (libc)Inverse Trig Functions. |
| * catan: (libc)Inverse Trig Functions. |
| * catanf: (libc)Inverse Trig Functions. |
| * catanh: (libc)Hyperbolic Functions. |
| * catanhf: (libc)Hyperbolic Functions. |
| * catanhl: (libc)Hyperbolic Functions. |
| * catanl: (libc)Inverse Trig Functions. |
| * catclose: (libc)The catgets Functions. |
| * catgets: (libc)The catgets Functions. |
| * catopen: (libc)The catgets Functions. |
| * cbc_crypt: (libc)DES Encryption. |
| * cbrt: (libc)Exponents and Logarithms. |
| * cbrtf: (libc)Exponents and Logarithms. |
| * cbrtl: (libc)Exponents and Logarithms. |
| * ccos: (libc)Trig Functions. |
| * ccosf: (libc)Trig Functions. |
| * ccosh: (libc)Hyperbolic Functions. |
| * ccoshf: (libc)Hyperbolic Functions. |
| * ccoshl: (libc)Hyperbolic Functions. |
| * ccosl: (libc)Trig Functions. |
| * ceil: (libc)Rounding Functions. |
| * ceilf: (libc)Rounding Functions. |
| * ceill: (libc)Rounding Functions. |
| * cexp: (libc)Exponents and Logarithms. |
| * cexpf: (libc)Exponents and Logarithms. |
| * cexpl: (libc)Exponents and Logarithms. |
| * cfgetispeed: (libc)Line Speed. |
| * cfgetospeed: (libc)Line Speed. |
| * cfmakeraw: (libc)Noncanonical Input. |
| * cfree: (libc)Freeing after Malloc. |
| * cfsetispeed: (libc)Line Speed. |
| * cfsetospeed: (libc)Line Speed. |
| * cfsetspeed: (libc)Line Speed. |
| * chdir: (libc)Working Directory. |
| * chmod: (libc)Setting Permissions. |
| * chown: (libc)File Owner. |
| * cimag: (libc)Operations on Complex. |
| * cimagf: (libc)Operations on Complex. |
| * cimagl: (libc)Operations on Complex. |
| * clearenv: (libc)Environment Access. |
| * clearerr: (libc)Error Recovery. |
| * clearerr_unlocked: (libc)Error Recovery. |
| * clock: (libc)CPU Time. |
| * clog10: (libc)Exponents and Logarithms. |
| * clog10f: (libc)Exponents and Logarithms. |
| * clog10l: (libc)Exponents and Logarithms. |
| * clog: (libc)Exponents and Logarithms. |
| * clogf: (libc)Exponents and Logarithms. |
| * clogl: (libc)Exponents and Logarithms. |
| * close: (libc)Opening and Closing Files. |
| * closedir: (libc)Reading/Closing Directory. |
| * closelog: (libc)closelog. |
| * confstr: (libc)String Parameters. |
| * conj: (libc)Operations on Complex. |
| * conjf: (libc)Operations on Complex. |
| * conjl: (libc)Operations on Complex. |
| * connect: (libc)Connecting. |
| * copysign: (libc)FP Bit Twiddling. |
| * copysignf: (libc)FP Bit Twiddling. |
| * copysignl: (libc)FP Bit Twiddling. |
| * cos: (libc)Trig Functions. |
| * cosf: (libc)Trig Functions. |
| * cosh: (libc)Hyperbolic Functions. |
| * coshf: (libc)Hyperbolic Functions. |
| * coshl: (libc)Hyperbolic Functions. |
| * cosl: (libc)Trig Functions. |
| * cpow: (libc)Exponents and Logarithms. |
| * cpowf: (libc)Exponents and Logarithms. |
| * cpowl: (libc)Exponents and Logarithms. |
| * cproj: (libc)Operations on Complex. |
| * cprojf: (libc)Operations on Complex. |
| * cprojl: (libc)Operations on Complex. |
| * creal: (libc)Operations on Complex. |
| * crealf: (libc)Operations on Complex. |
| * creall: (libc)Operations on Complex. |
| * creat64: (libc)Opening and Closing Files. |
| * creat: (libc)Opening and Closing Files. |
| * crypt: (libc)crypt. |
| * crypt_r: (libc)crypt. |
| * csin: (libc)Trig Functions. |
| * csinf: (libc)Trig Functions. |
| * csinh: (libc)Hyperbolic Functions. |
| * csinhf: (libc)Hyperbolic Functions. |
| * csinhl: (libc)Hyperbolic Functions. |
| * csinl: (libc)Trig Functions. |
| * csqrt: (libc)Exponents and Logarithms. |
| * csqrtf: (libc)Exponents and Logarithms. |
| * csqrtl: (libc)Exponents and Logarithms. |
| * ctan: (libc)Trig Functions. |
| * ctanf: (libc)Trig Functions. |
| * ctanh: (libc)Hyperbolic Functions. |
| * ctanhf: (libc)Hyperbolic Functions. |
| * ctanhl: (libc)Hyperbolic Functions. |
| * ctanl: (libc)Trig Functions. |
| * ctermid: (libc)Identifying the Terminal. |
| * ctime: (libc)Formatting Calendar Time. |
| * ctime_r: (libc)Formatting Calendar Time. |
| * cuserid: (libc)Who Logged In. |
| * dcgettext: (libc)Translation with gettext. |
| * dcngettext: (libc)Advanced gettext functions. |
| * des_setparity: (libc)DES Encryption. |
| * dgettext: (libc)Translation with gettext. |
| * difftime: (libc)Elapsed Time. |
| * dirfd: (libc)Opening a Directory. |
| * dirname: (libc)Finding Tokens in a String. |
| * div: (libc)Integer Division. |
| * dngettext: (libc)Advanced gettext functions. |
| * drand48: (libc)SVID Random. |
| * drand48_r: (libc)SVID Random. |
| * drem: (libc)Remainder Functions. |
| * dremf: (libc)Remainder Functions. |
| * dreml: (libc)Remainder Functions. |
| * dup2: (libc)Duplicating Descriptors. |
| * dup: (libc)Duplicating Descriptors. |
| * ecb_crypt: (libc)DES Encryption. |
| * ecvt: (libc)System V Number Conversion. |
| * ecvt_r: (libc)System V Number Conversion. |
| * encrypt: (libc)DES Encryption. |
| * encrypt_r: (libc)DES Encryption. |
| * endfsent: (libc)fstab. |
| * endgrent: (libc)Scanning All Groups. |
| * endhostent: (libc)Host Names. |
| * endmntent: (libc)mtab. |
| * endnetent: (libc)Networks Database. |
| * endnetgrent: (libc)Lookup Netgroup. |
| * endprotoent: (libc)Protocols Database. |
| * endpwent: (libc)Scanning All Users. |
| * endservent: (libc)Services Database. |
| * endutent: (libc)Manipulating the Database. |
| * endutxent: (libc)XPG Functions. |
| * envz_add: (libc)Envz Functions. |
| * envz_entry: (libc)Envz Functions. |
| * envz_get: (libc)Envz Functions. |
| * envz_merge: (libc)Envz Functions. |
| * envz_strip: (libc)Envz Functions. |
| * erand48: (libc)SVID Random. |
| * erand48_r: (libc)SVID Random. |
| * erf: (libc)Special Functions. |
| * erfc: (libc)Special Functions. |
| * erfcf: (libc)Special Functions. |
| * erfcl: (libc)Special Functions. |
| * erff: (libc)Special Functions. |
| * erfl: (libc)Special Functions. |
| * err: (libc)Error Messages. |
| * errno: (libc)Checking for Errors. |
| * error: (libc)Error Messages. |
| * error_at_line: (libc)Error Messages. |
| * errx: (libc)Error Messages. |
| * execl: (libc)Executing a File. |
| * execle: (libc)Executing a File. |
| * execlp: (libc)Executing a File. |
| * execv: (libc)Executing a File. |
| * execve: (libc)Executing a File. |
| * execvp: (libc)Executing a File. |
| * exit: (libc)Normal Termination. |
| * exp10: (libc)Exponents and Logarithms. |
| * exp10f: (libc)Exponents and Logarithms. |
| * exp10l: (libc)Exponents and Logarithms. |
| * exp2: (libc)Exponents and Logarithms. |
| * exp2f: (libc)Exponents and Logarithms. |
| * exp2l: (libc)Exponents and Logarithms. |
| * exp: (libc)Exponents and Logarithms. |
| * expf: (libc)Exponents and Logarithms. |
| * expl: (libc)Exponents and Logarithms. |
| * expm1: (libc)Exponents and Logarithms. |
| * expm1f: (libc)Exponents and Logarithms. |
| * expm1l: (libc)Exponents and Logarithms. |
| * fabs: (libc)Absolute Value. |
| * fabsf: (libc)Absolute Value. |
| * fabsl: (libc)Absolute Value. |
| * fchdir: (libc)Working Directory. |
| * fchmod: (libc)Setting Permissions. |
| * fchown: (libc)File Owner. |
| * fclose: (libc)Closing Streams. |
| * fcloseall: (libc)Closing Streams. |
| * fcntl: (libc)Control Operations. |
| * fcvt: (libc)System V Number Conversion. |
| * fcvt_r: (libc)System V Number Conversion. |
| * fdatasync: (libc)Synchronizing I/O. |
| * fdim: (libc)Misc FP Arithmetic. |
| * fdimf: (libc)Misc FP Arithmetic. |
| * fdiml: (libc)Misc FP Arithmetic. |
| * fdopen: (libc)Descriptors and Streams. |
| * fdopendir: (libc)Opening a Directory. |
| * feclearexcept: (libc)Status bit operations. |
| * fedisableexcept: (libc)Control Functions. |
| * feenableexcept: (libc)Control Functions. |
| * fegetenv: (libc)Control Functions. |
| * fegetexcept: (libc)Control Functions. |
| * fegetexceptflag: (libc)Status bit operations. |
| * fegetround: (libc)Rounding. |
| * feholdexcept: (libc)Control Functions. |
| * feof: (libc)EOF and Errors. |
| * feof_unlocked: (libc)EOF and Errors. |
| * feraiseexcept: (libc)Status bit operations. |
| * ferror: (libc)EOF and Errors. |
| * ferror_unlocked: (libc)EOF and Errors. |
| * fesetenv: (libc)Control Functions. |
| * fesetexceptflag: (libc)Status bit operations. |
| * fesetround: (libc)Rounding. |
| * fetestexcept: (libc)Status bit operations. |
| * feupdateenv: (libc)Control Functions. |
| * fflush: (libc)Flushing Buffers. |
| * fflush_unlocked: (libc)Flushing Buffers. |
| * fgetc: (libc)Character Input. |
| * fgetc_unlocked: (libc)Character Input. |
| * fgetgrent: (libc)Scanning All Groups. |
| * fgetgrent_r: (libc)Scanning All Groups. |
| * fgetpos64: (libc)Portable Positioning. |
| * fgetpos: (libc)Portable Positioning. |
| * fgetpwent: (libc)Scanning All Users. |
| * fgetpwent_r: (libc)Scanning All Users. |
| * fgets: (libc)Line Input. |
| * fgets_unlocked: (libc)Line Input. |
| * fgetwc: (libc)Character Input. |
| * fgetwc_unlocked: (libc)Character Input. |
| * fgetws: (libc)Line Input. |
| * fgetws_unlocked: (libc)Line Input. |
| * fileno: (libc)Descriptors and Streams. |
| * fileno_unlocked: (libc)Descriptors and Streams. |
| * finite: (libc)Floating Point Classes. |
| * finitef: (libc)Floating Point Classes. |
| * finitel: (libc)Floating Point Classes. |
| * flockfile: (libc)Streams and Threads. |
| * floor: (libc)Rounding Functions. |
| * floorf: (libc)Rounding Functions. |
| * floorl: (libc)Rounding Functions. |
| * fma: (libc)Misc FP Arithmetic. |
| * fmaf: (libc)Misc FP Arithmetic. |
| * fmal: (libc)Misc FP Arithmetic. |
| * fmax: (libc)Misc FP Arithmetic. |
| * fmaxf: (libc)Misc FP Arithmetic. |
| * fmaxl: (libc)Misc FP Arithmetic. |
| * fmemopen: (libc)String Streams. |
| * fmin: (libc)Misc FP Arithmetic. |
| * fminf: (libc)Misc FP Arithmetic. |
| * fminl: (libc)Misc FP Arithmetic. |
| * fmod: (libc)Remainder Functions. |
| * fmodf: (libc)Remainder Functions. |
| * fmodl: (libc)Remainder Functions. |
| * fmtmsg: (libc)Printing Formatted Messages. |
| * fnmatch: (libc)Wildcard Matching. |
| * fopen64: (libc)Opening Streams. |
| * fopen: (libc)Opening Streams. |
| * fopencookie: (libc)Streams and Cookies. |
| * fork: (libc)Creating a Process. |
| * forkpty: (libc)Pseudo-Terminal Pairs. |
| * fpathconf: (libc)Pathconf. |
| * fpclassify: (libc)Floating Point Classes. |
| * fprintf: (libc)Formatted Output Functions. |
| * fputc: (libc)Simple Output. |
| * fputc_unlocked: (libc)Simple Output. |
| * fputs: (libc)Simple Output. |
| * fputs_unlocked: (libc)Simple Output. |
| * fputwc: (libc)Simple Output. |
| * fputwc_unlocked: (libc)Simple Output. |
| * fputws: (libc)Simple Output. |
| * fputws_unlocked: (libc)Simple Output. |
| * fread: (libc)Block Input/Output. |
| * fread_unlocked: (libc)Block Input/Output. |
| * free: (libc)Freeing after Malloc. |
| * freopen64: (libc)Opening Streams. |
| * freopen: (libc)Opening Streams. |
| * frexp: (libc)Normalization Functions. |
| * frexpf: (libc)Normalization Functions. |
| * frexpl: (libc)Normalization Functions. |
| * fscanf: (libc)Formatted Input Functions. |
| * fseek: (libc)File Positioning. |
| * fseeko64: (libc)File Positioning. |
| * fseeko: (libc)File Positioning. |
| * fsetpos64: (libc)Portable Positioning. |
| * fsetpos: (libc)Portable Positioning. |
| * fstat64: (libc)Reading Attributes. |
| * fstat: (libc)Reading Attributes. |
| * fsync: (libc)Synchronizing I/O. |
| * ftell: (libc)File Positioning. |
| * ftello64: (libc)File Positioning. |
| * ftello: (libc)File Positioning. |
| * ftruncate64: (libc)File Size. |
| * ftruncate: (libc)File Size. |
| * ftrylockfile: (libc)Streams and Threads. |
| * ftw64: (libc)Working with Directory Trees. |
| * ftw: (libc)Working with Directory Trees. |
| * funlockfile: (libc)Streams and Threads. |
| * futimes: (libc)File Times. |
| * fwide: (libc)Streams and I18N. |
| * fwprintf: (libc)Formatted Output Functions. |
| * fwrite: (libc)Block Input/Output. |
| * fwrite_unlocked: (libc)Block Input/Output. |
| * fwscanf: (libc)Formatted Input Functions. |
| * gamma: (libc)Special Functions. |
| * gammaf: (libc)Special Functions. |
| * gammal: (libc)Special Functions. |
| * gcvt: (libc)System V Number Conversion. |
| * get_avphys_pages: (libc)Query Memory Parameters. |
| * get_current_dir_name: (libc)Working Directory. |
| * get_nprocs: (libc)Processor Resources. |
| * get_nprocs_conf: (libc)Processor Resources. |
| * get_phys_pages: (libc)Query Memory Parameters. |
| * getauxval: (libc)Auxiliary Vector. |
| * getc: (libc)Character Input. |
| * getc_unlocked: (libc)Character Input. |
| * getchar: (libc)Character Input. |
| * getchar_unlocked: (libc)Character Input. |
| * getcontext: (libc)System V contexts. |
| * getcwd: (libc)Working Directory. |
| * getdate: (libc)General Time String Parsing. |
| * getdate_r: (libc)General Time String Parsing. |
| * getdelim: (libc)Line Input. |
| * getdomainnname: (libc)Host Identification. |
| * getegid: (libc)Reading Persona. |
| * getenv: (libc)Environment Access. |
| * geteuid: (libc)Reading Persona. |
| * getfsent: (libc)fstab. |
| * getfsfile: (libc)fstab. |
| * getfsspec: (libc)fstab. |
| * getgid: (libc)Reading Persona. |
| * getgrent: (libc)Scanning All Groups. |
| * getgrent_r: (libc)Scanning All Groups. |
| * getgrgid: (libc)Lookup Group. |
| * getgrgid_r: (libc)Lookup Group. |
| * getgrnam: (libc)Lookup Group. |
| * getgrnam_r: (libc)Lookup Group. |
| * getgrouplist: (libc)Setting Groups. |
| * getgroups: (libc)Reading Persona. |
| * gethostbyaddr: (libc)Host Names. |
| * gethostbyaddr_r: (libc)Host Names. |
| * gethostbyname2: (libc)Host Names. |
| * gethostbyname2_r: (libc)Host Names. |
| * gethostbyname: (libc)Host Names. |
| * gethostbyname_r: (libc)Host Names. |
| * gethostent: (libc)Host Names. |
| * gethostid: (libc)Host Identification. |
| * gethostname: (libc)Host Identification. |
| * getitimer: (libc)Setting an Alarm. |
| * getline: (libc)Line Input. |
| * getloadavg: (libc)Processor Resources. |
| * getlogin: (libc)Who Logged In. |
| * getmntent: (libc)mtab. |
| * getmntent_r: (libc)mtab. |
| * getnetbyaddr: (libc)Networks Database. |
| * getnetbyname: (libc)Networks Database. |
| * getnetent: (libc)Networks Database. |
| * getnetgrent: (libc)Lookup Netgroup. |
| * getnetgrent_r: (libc)Lookup Netgroup. |
| * getopt: (libc)Using Getopt. |
| * getopt_long: (libc)Getopt Long Options. |
| * getopt_long_only: (libc)Getopt Long Options. |
| * getpagesize: (libc)Query Memory Parameters. |
| * getpass: (libc)getpass. |
| * getpeername: (libc)Who is Connected. |
| * getpgid: (libc)Process Group Functions. |
| * getpgrp: (libc)Process Group Functions. |
| * getpid: (libc)Process Identification. |
| * getppid: (libc)Process Identification. |
| * getpriority: (libc)Traditional Scheduling Functions. |
| * getprotobyname: (libc)Protocols Database. |
| * getprotobynumber: (libc)Protocols Database. |
| * getprotoent: (libc)Protocols Database. |
| * getpt: (libc)Allocation. |
| * getpwent: (libc)Scanning All Users. |
| * getpwent_r: (libc)Scanning All Users. |
| * getpwnam: (libc)Lookup User. |
| * getpwnam_r: (libc)Lookup User. |
| * getpwuid: (libc)Lookup User. |
| * getpwuid_r: (libc)Lookup User. |
| * getrlimit64: (libc)Limits on Resources. |
| * getrlimit: (libc)Limits on Resources. |
| * getrusage: (libc)Resource Usage. |
| * gets: (libc)Line Input. |
| * getservbyname: (libc)Services Database. |
| * getservbyport: (libc)Services Database. |
| * getservent: (libc)Services Database. |
| * getsid: (libc)Process Group Functions. |
| * getsockname: (libc)Reading Address. |
| * getsockopt: (libc)Socket Option Functions. |
| * getsubopt: (libc)Suboptions. |
| * gettext: (libc)Translation with gettext. |
| * gettimeofday: (libc)High-Resolution Calendar. |
| * getuid: (libc)Reading Persona. |
| * getumask: (libc)Setting Permissions. |
| * getutent: (libc)Manipulating the Database. |
| * getutent_r: (libc)Manipulating the Database. |
| * getutid: (libc)Manipulating the Database. |
| * getutid_r: (libc)Manipulating the Database. |
| * getutline: (libc)Manipulating the Database. |
| * getutline_r: (libc)Manipulating the Database. |
| * getutmp: (libc)XPG Functions. |
| * getutmpx: (libc)XPG Functions. |
| * getutxent: (libc)XPG Functions. |
| * getutxid: (libc)XPG Functions. |
| * getutxline: (libc)XPG Functions. |
| * getw: (libc)Character Input. |
| * getwc: (libc)Character Input. |
| * getwc_unlocked: (libc)Character Input. |
| * getwchar: (libc)Character Input. |
| * getwchar_unlocked: (libc)Character Input. |
| * getwd: (libc)Working Directory. |
| * glob64: (libc)Calling Glob. |
| * glob: (libc)Calling Glob. |
| * globfree64: (libc)More Flags for Globbing. |
| * globfree: (libc)More Flags for Globbing. |
| * gmtime: (libc)Broken-down Time. |
| * gmtime_r: (libc)Broken-down Time. |
| * grantpt: (libc)Allocation. |
| * gsignal: (libc)Signaling Yourself. |
| * gtty: (libc)BSD Terminal Modes. |
| * hasmntopt: (libc)mtab. |
| * hcreate: (libc)Hash Search Function. |
| * hcreate_r: (libc)Hash Search Function. |
| * hdestroy: (libc)Hash Search Function. |
| * hdestroy_r: (libc)Hash Search Function. |
| * hsearch: (libc)Hash Search Function. |
| * hsearch_r: (libc)Hash Search Function. |
| * htonl: (libc)Byte Order. |
| * htons: (libc)Byte Order. |
| * hypot: (libc)Exponents and Logarithms. |
| * hypotf: (libc)Exponents and Logarithms. |
| * hypotl: (libc)Exponents and Logarithms. |
| * iconv: (libc)Generic Conversion Interface. |
| * iconv_close: (libc)Generic Conversion Interface. |
| * iconv_open: (libc)Generic Conversion Interface. |
| * if_freenameindex: (libc)Interface Naming. |
| * if_indextoname: (libc)Interface Naming. |
| * if_nameindex: (libc)Interface Naming. |
| * if_nametoindex: (libc)Interface Naming. |
| * ilogb: (libc)Exponents and Logarithms. |
| * ilogbf: (libc)Exponents and Logarithms. |
| * ilogbl: (libc)Exponents and Logarithms. |
| * imaxabs: (libc)Absolute Value. |
| * imaxdiv: (libc)Integer Division. |
| * in6addr_any: (libc)Host Address Data Type. |
| * in6addr_loopback: (libc)Host Address Data Type. |
| * index: (libc)Search Functions. |
| * inet_addr: (libc)Host Address Functions. |
| * inet_aton: (libc)Host Address Functions. |
| * inet_lnaof: (libc)Host Address Functions. |
| * inet_makeaddr: (libc)Host Address Functions. |
| * inet_netof: (libc)Host Address Functions. |
| * inet_network: (libc)Host Address Functions. |
| * inet_ntoa: (libc)Host Address Functions. |
| * inet_ntop: (libc)Host Address Functions. |
| * inet_pton: (libc)Host Address Functions. |
| * initgroups: (libc)Setting Groups. |
| * initstate: (libc)BSD Random. |
| * initstate_r: (libc)BSD Random. |
| * innetgr: (libc)Netgroup Membership. |
| * ioctl: (libc)IOCTLs. |
| * isalnum: (libc)Classification of Characters. |
| * isalpha: (libc)Classification of Characters. |
| * isascii: (libc)Classification of Characters. |
| * isatty: (libc)Is It a Terminal. |
| * isblank: (libc)Classification of Characters. |
| * iscntrl: (libc)Classification of Characters. |
| * isdigit: (libc)Classification of Characters. |
| * isfinite: (libc)Floating Point Classes. |
| * isgraph: (libc)Classification of Characters. |
| * isgreater: (libc)FP Comparison Functions. |
| * isgreaterequal: (libc)FP Comparison Functions. |
| * isinf: (libc)Floating Point Classes. |
| * isinff: (libc)Floating Point Classes. |
| * isinfl: (libc)Floating Point Classes. |
| * isless: (libc)FP Comparison Functions. |
| * islessequal: (libc)FP Comparison Functions. |
| * islessgreater: (libc)FP Comparison Functions. |
| * islower: (libc)Classification of Characters. |
| * isnan: (libc)Floating Point Classes. |
| * isnan: (libc)Floating Point Classes. |
| * isnanf: (libc)Floating Point Classes. |
| * isnanl: (libc)Floating Point Classes. |
| * isnormal: (libc)Floating Point Classes. |
| * isprint: (libc)Classification of Characters. |
| * ispunct: (libc)Classification of Characters. |
| * issignaling: (libc)Floating Point Classes. |
| * isspace: (libc)Classification of Characters. |
| * isunordered: (libc)FP Comparison Functions. |
| * isupper: (libc)Classification of Characters. |
| * iswalnum: (libc)Classification of Wide Characters. |
| * iswalpha: (libc)Classification of Wide Characters. |
| * iswblank: (libc)Classification of Wide Characters. |
| * iswcntrl: (libc)Classification of Wide Characters. |
| * iswctype: (libc)Classification of Wide Characters. |
| * iswdigit: (libc)Classification of Wide Characters. |
| * iswgraph: (libc)Classification of Wide Characters. |
| * iswlower: (libc)Classification of Wide Characters. |
| * iswprint: (libc)Classification of Wide Characters. |
| * iswpunct: (libc)Classification of Wide Characters. |
| * iswspace: (libc)Classification of Wide Characters. |
| * iswupper: (libc)Classification of Wide Characters. |
| * iswxdigit: (libc)Classification of Wide Characters. |
| * isxdigit: (libc)Classification of Characters. |
| * j0: (libc)Special Functions. |
| * j0f: (libc)Special Functions. |
| * j0l: (libc)Special Functions. |
| * j1: (libc)Special Functions. |
| * j1f: (libc)Special Functions. |
| * j1l: (libc)Special Functions. |
| * jn: (libc)Special Functions. |
| * jnf: (libc)Special Functions. |
| * jnl: (libc)Special Functions. |
| * jrand48: (libc)SVID Random. |
| * jrand48_r: (libc)SVID Random. |
| * kill: (libc)Signaling Another Process. |
| * killpg: (libc)Signaling Another Process. |
| * l64a: (libc)Encode Binary Data. |
| * labs: (libc)Absolute Value. |
| * lcong48: (libc)SVID Random. |
| * lcong48_r: (libc)SVID Random. |
| * ldexp: (libc)Normalization Functions. |
| * ldexpf: (libc)Normalization Functions. |
| * ldexpl: (libc)Normalization Functions. |
| * ldiv: (libc)Integer Division. |
| * lfind: (libc)Array Search Function. |
| * lgamma: (libc)Special Functions. |
| * lgamma_r: (libc)Special Functions. |
| * lgammaf: (libc)Special Functions. |
| * lgammaf_r: (libc)Special Functions. |
| * lgammal: (libc)Special Functions. |
| * lgammal_r: (libc)Special Functions. |
| * link: (libc)Hard Links. |
| * lio_listio64: (libc)Asynchronous Reads/Writes. |
| * lio_listio: (libc)Asynchronous Reads/Writes. |
| * listen: (libc)Listening. |
| * llabs: (libc)Absolute Value. |
| * lldiv: (libc)Integer Division. |
| * llrint: (libc)Rounding Functions. |
| * llrintf: (libc)Rounding Functions. |
| * llrintl: (libc)Rounding Functions. |
| * llround: (libc)Rounding Functions. |
| * llroundf: (libc)Rounding Functions. |
| * llroundl: (libc)Rounding Functions. |
| * localeconv: (libc)The Lame Way to Locale Data. |
| * localtime: (libc)Broken-down Time. |
| * localtime_r: (libc)Broken-down Time. |
| * log10: (libc)Exponents and Logarithms. |
| * log10f: (libc)Exponents and Logarithms. |
| * log10l: (libc)Exponents and Logarithms. |
| * log1p: (libc)Exponents and Logarithms. |
| * log1pf: (libc)Exponents and Logarithms. |
| * log1pl: (libc)Exponents and Logarithms. |
| * log2: (libc)Exponents and Logarithms. |
| * log2f: (libc)Exponents and Logarithms. |
| * log2l: (libc)Exponents and Logarithms. |
| * log: (libc)Exponents and Logarithms. |
| * logb: (libc)Exponents and Logarithms. |
| * logbf: (libc)Exponents and Logarithms. |
| * logbl: (libc)Exponents and Logarithms. |
| * logf: (libc)Exponents and Logarithms. |
| * login: (libc)Logging In and Out. |
| * login_tty: (libc)Logging In and Out. |
| * logl: (libc)Exponents and Logarithms. |
| * logout: (libc)Logging In and Out. |
| * logwtmp: (libc)Logging In and Out. |
| * longjmp: (libc)Non-Local Details. |
| * lrand48: (libc)SVID Random. |
| * lrand48_r: (libc)SVID Random. |
| * lrint: (libc)Rounding Functions. |
| * lrintf: (libc)Rounding Functions. |
| * lrintl: (libc)Rounding Functions. |
| * lround: (libc)Rounding Functions. |
| * lroundf: (libc)Rounding Functions. |
| * lroundl: (libc)Rounding Functions. |
| * lsearch: (libc)Array Search Function. |
| * lseek64: (libc)File Position Primitive. |
| * lseek: (libc)File Position Primitive. |
| * lstat64: (libc)Reading Attributes. |
| * lstat: (libc)Reading Attributes. |
| * lutimes: (libc)File Times. |
| * madvise: (libc)Memory-mapped I/O. |
| * makecontext: (libc)System V contexts. |
| * mallinfo: (libc)Statistics of Malloc. |
| * malloc: (libc)Basic Allocation. |
| * mallopt: (libc)Malloc Tunable Parameters. |
| * mblen: (libc)Non-reentrant Character Conversion. |
| * mbrlen: (libc)Converting a Character. |
| * mbrtowc: (libc)Converting a Character. |
| * mbsinit: (libc)Keeping the state. |
| * mbsnrtowcs: (libc)Converting Strings. |
| * mbsrtowcs: (libc)Converting Strings. |
| * mbstowcs: (libc)Non-reentrant String Conversion. |
| * mbtowc: (libc)Non-reentrant Character Conversion. |
| * mcheck: (libc)Heap Consistency Checking. |
| * memalign: (libc)Aligned Memory Blocks. |
| * memccpy: (libc)Copying and Concatenation. |
| * memchr: (libc)Search Functions. |
| * memcmp: (libc)String/Array Comparison. |
| * memcpy: (libc)Copying and Concatenation. |
| * memfrob: (libc)Trivial Encryption. |
| * memmem: (libc)Search Functions. |
| * memmove: (libc)Copying and Concatenation. |
| * mempcpy: (libc)Copying and Concatenation. |
| * memrchr: (libc)Search Functions. |
| * memset: (libc)Copying and Concatenation. |
| * mkdir: (libc)Creating Directories. |
| * mkdtemp: (libc)Temporary Files. |
| * mkfifo: (libc)FIFO Special Files. |
| * mknod: (libc)Making Special Files. |
| * mkstemp: (libc)Temporary Files. |
| * mktemp: (libc)Temporary Files. |
| * mktime: (libc)Broken-down Time. |
| * mlock: (libc)Page Lock Functions. |
| * mlockall: (libc)Page Lock Functions. |
| * mmap64: (libc)Memory-mapped I/O. |
| * mmap: (libc)Memory-mapped I/O. |
| * modf: (libc)Rounding Functions. |
| * modff: (libc)Rounding Functions. |
| * modfl: (libc)Rounding Functions. |
| * mount: (libc)Mount-Unmount-Remount. |
| * mprobe: (libc)Heap Consistency Checking. |
| * mrand48: (libc)SVID Random. |
| * mrand48_r: (libc)SVID Random. |
| * mremap: (libc)Memory-mapped I/O. |
| * msync: (libc)Memory-mapped I/O. |
| * mtrace: (libc)Tracing malloc. |
| * munlock: (libc)Page Lock Functions. |
| * munlockall: (libc)Page Lock Functions. |
| * munmap: (libc)Memory-mapped I/O. |
| * muntrace: (libc)Tracing malloc. |
| * nan: (libc)FP Bit Twiddling. |
| * nanf: (libc)FP Bit Twiddling. |
| * nanl: (libc)FP Bit Twiddling. |
| * nanosleep: (libc)Sleeping. |
| * nearbyint: (libc)Rounding Functions. |
| * nearbyintf: (libc)Rounding Functions. |
| * nearbyintl: (libc)Rounding Functions. |
| * nextafter: (libc)FP Bit Twiddling. |
| * nextafterf: (libc)FP Bit Twiddling. |
| * nextafterl: (libc)FP Bit Twiddling. |
| * nexttoward: (libc)FP Bit Twiddling. |
| * nexttowardf: (libc)FP Bit Twiddling. |
| * nexttowardl: (libc)FP Bit Twiddling. |
| * nftw64: (libc)Working with Directory Trees. |
| * nftw: (libc)Working with Directory Trees. |
| * ngettext: (libc)Advanced gettext functions. |
| * nice: (libc)Traditional Scheduling Functions. |
| * nl_langinfo: (libc)The Elegant and Fast Way. |
| * nrand48: (libc)SVID Random. |
| * nrand48_r: (libc)SVID Random. |
| * ntohl: (libc)Byte Order. |
| * ntohs: (libc)Byte Order. |
| * ntp_adjtime: (libc)High Accuracy Clock. |
| * ntp_gettime: (libc)High Accuracy Clock. |
| * obstack_1grow: (libc)Growing Objects. |
| * obstack_1grow_fast: (libc)Extra Fast Growing. |
| * obstack_alignment_mask: (libc)Obstacks Data Alignment. |
| * obstack_alloc: (libc)Allocation in an Obstack. |
| * obstack_base: (libc)Status of an Obstack. |
| * obstack_blank: (libc)Growing Objects. |
| * obstack_blank_fast: (libc)Extra Fast Growing. |
| * obstack_chunk_size: (libc)Obstack Chunks. |
| * obstack_copy0: (libc)Allocation in an Obstack. |
| * obstack_copy: (libc)Allocation in an Obstack. |
| * obstack_finish: (libc)Growing Objects. |
| * obstack_free: (libc)Freeing Obstack Objects. |
| * obstack_grow0: (libc)Growing Objects. |
| * obstack_grow: (libc)Growing Objects. |
| * obstack_init: (libc)Preparing for Obstacks. |
| * obstack_int_grow: (libc)Growing Objects. |
| * obstack_int_grow_fast: (libc)Extra Fast Growing. |
| * obstack_next_free: (libc)Status of an Obstack. |
| * obstack_object_size: (libc)Growing Objects. |
| * obstack_object_size: (libc)Status of an Obstack. |
| * obstack_printf: (libc)Dynamic Output. |
| * obstack_ptr_grow: (libc)Growing Objects. |
| * obstack_ptr_grow_fast: (libc)Extra Fast Growing. |
| * obstack_room: (libc)Extra Fast Growing. |
| * obstack_vprintf: (libc)Variable Arguments Output. |
| * offsetof: (libc)Structure Measurement. |
| * on_exit: (libc)Cleanups on Exit. |
| * open64: (libc)Opening and Closing Files. |
| * open: (libc)Opening and Closing Files. |
| * open_memstream: (libc)String Streams. |
| * opendir: (libc)Opening a Directory. |
| * openlog: (libc)openlog. |
| * openpty: (libc)Pseudo-Terminal Pairs. |
| * parse_printf_format: (libc)Parsing a Template String. |
| * pathconf: (libc)Pathconf. |
| * pause: (libc)Using Pause. |
| * pclose: (libc)Pipe to a Subprocess. |
| * perror: (libc)Error Messages. |
| * pipe: (libc)Creating a Pipe. |
| * popen: (libc)Pipe to a Subprocess. |
| * posix_memalign: (libc)Aligned Memory Blocks. |
| * pow10: (libc)Exponents and Logarithms. |
| * pow10f: (libc)Exponents and Logarithms. |
| * pow10l: (libc)Exponents and Logarithms. |
| * pow: (libc)Exponents and Logarithms. |
| * powf: (libc)Exponents and Logarithms. |
| * powl: (libc)Exponents and Logarithms. |
| * pread64: (libc)I/O Primitives. |
| * pread: (libc)I/O Primitives. |
| * printf: (libc)Formatted Output Functions. |
| * printf_size: (libc)Predefined Printf Handlers. |
| * printf_size_info: (libc)Predefined Printf Handlers. |
| * psignal: (libc)Signal Messages. |
| * pthread_getattr_default_np: (libc)Default Thread Attributes. |
| * pthread_getspecific: (libc)Thread-specific Data. |
| * pthread_key_create: (libc)Thread-specific Data. |
| * pthread_key_delete: (libc)Thread-specific Data. |
| * pthread_setattr_default_np: (libc)Default Thread Attributes. |
| * pthread_setspecific: (libc)Thread-specific Data. |
| * ptsname: (libc)Allocation. |
| * ptsname_r: (libc)Allocation. |
| * putc: (libc)Simple Output. |
| * putc_unlocked: (libc)Simple Output. |
| * putchar: (libc)Simple Output. |
| * putchar_unlocked: (libc)Simple Output. |
| * putenv: (libc)Environment Access. |
| * putpwent: (libc)Writing a User Entry. |
| * puts: (libc)Simple Output. |
| * pututline: (libc)Manipulating the Database. |
| * pututxline: (libc)XPG Functions. |
| * putw: (libc)Simple Output. |
| * putwc: (libc)Simple Output. |
| * putwc_unlocked: (libc)Simple Output. |
| * putwchar: (libc)Simple Output. |
| * putwchar_unlocked: (libc)Simple Output. |
| * pwrite64: (libc)I/O Primitives. |
| * pwrite: (libc)I/O Primitives. |
| * qecvt: (libc)System V Number Conversion. |
| * qecvt_r: (libc)System V Number Conversion. |
| * qfcvt: (libc)System V Number Conversion. |
| * qfcvt_r: (libc)System V Number Conversion. |
| * qgcvt: (libc)System V Number Conversion. |
| * qsort: (libc)Array Sort Function. |
| * raise: (libc)Signaling Yourself. |
| * rand: (libc)ISO Random. |
| * rand_r: (libc)ISO Random. |
| * random: (libc)BSD Random. |
| * random_r: (libc)BSD Random. |
| * rawmemchr: (libc)Search Functions. |
| * read: (libc)I/O Primitives. |
| * readdir64: (libc)Reading/Closing Directory. |
| * readdir64_r: (libc)Reading/Closing Directory. |
| * readdir: (libc)Reading/Closing Directory. |
| * readdir_r: (libc)Reading/Closing Directory. |
| * readlink: (libc)Symbolic Links. |
| * readv: (libc)Scatter-Gather. |
| * realloc: (libc)Changing Block Size. |
| * realpath: (libc)Symbolic Links. |
| * recv: (libc)Receiving Data. |
| * recvfrom: (libc)Receiving Datagrams. |
| * recvmsg: (libc)Receiving Datagrams. |
| * regcomp: (libc)POSIX Regexp Compilation. |
| * regerror: (libc)Regexp Cleanup. |
| * regexec: (libc)Matching POSIX Regexps. |
| * regfree: (libc)Regexp Cleanup. |
| * register_printf_function: (libc)Registering New Conversions. |
| * remainder: (libc)Remainder Functions. |
| * remainderf: (libc)Remainder Functions. |
| * remainderl: (libc)Remainder Functions. |
| * remove: (libc)Deleting Files. |
| * rename: (libc)Renaming Files. |
| * rewind: (libc)File Positioning. |
| * rewinddir: (libc)Random Access Directory. |
| * rindex: (libc)Search Functions. |
| * rint: (libc)Rounding Functions. |
| * rintf: (libc)Rounding Functions. |
| * rintl: (libc)Rounding Functions. |
| * rmdir: (libc)Deleting Files. |
| * round: (libc)Rounding Functions. |
| * roundf: (libc)Rounding Functions. |
| * roundl: (libc)Rounding Functions. |
| * rpmatch: (libc)Yes-or-No Questions. |
| * sbrk: (libc)Resizing the Data Segment. |
| * scalb: (libc)Normalization Functions. |
| * scalbf: (libc)Normalization Functions. |
| * scalbl: (libc)Normalization Functions. |
| * scalbln: (libc)Normalization Functions. |
| * scalblnf: (libc)Normalization Functions. |
| * scalblnl: (libc)Normalization Functions. |
| * scalbn: (libc)Normalization Functions. |
| * scalbnf: (libc)Normalization Functions. |
| * scalbnl: (libc)Normalization Functions. |
| * scandir64: (libc)Scanning Directory Content. |
| * scandir: (libc)Scanning Directory Content. |
| * scanf: (libc)Formatted Input Functions. |
| * sched_get_priority_max: (libc)Basic Scheduling Functions. |
| * sched_get_priority_min: (libc)Basic Scheduling Functions. |
| * sched_getaffinity: (libc)CPU Affinity. |
| * sched_getparam: (libc)Basic Scheduling Functions. |
| * sched_getscheduler: (libc)Basic Scheduling Functions. |
| * sched_rr_get_interval: (libc)Basic Scheduling Functions. |
| * sched_setaffinity: (libc)CPU Affinity. |
| * sched_setparam: (libc)Basic Scheduling Functions. |
| * sched_setscheduler: (libc)Basic Scheduling Functions. |
| * sched_yield: (libc)Basic Scheduling Functions. |
| * secure_getenv: (libc)Environment Access. |
| * seed48: (libc)SVID Random. |
| * seed48_r: (libc)SVID Random. |
| * seekdir: (libc)Random Access Directory. |
| * select: (libc)Waiting for I/O. |
| * send: (libc)Sending Data. |
| * sendmsg: (libc)Receiving Datagrams. |
| * sendto: (libc)Sending Datagrams. |
| * setbuf: (libc)Controlling Buffering. |
| * setbuffer: (libc)Controlling Buffering. |
| * setcontext: (libc)System V contexts. |
| * setdomainname: (libc)Host Identification. |
| * setegid: (libc)Setting Groups. |
| * setenv: (libc)Environment Access. |
| * seteuid: (libc)Setting User ID. |
| * setfsent: (libc)fstab. |
| * setgid: (libc)Setting Groups. |
| * setgrent: (libc)Scanning All Groups. |
| * setgroups: (libc)Setting Groups. |
| * sethostent: (libc)Host Names. |
| * sethostid: (libc)Host Identification. |
| * sethostname: (libc)Host Identification. |
| * setitimer: (libc)Setting an Alarm. |
| * setjmp: (libc)Non-Local Details. |
| * setkey: (libc)DES Encryption. |
| * setkey_r: (libc)DES Encryption. |
| * setlinebuf: (libc)Controlling Buffering. |
| * setlocale: (libc)Setting the Locale. |
| * setlogmask: (libc)setlogmask. |
| * setmntent: (libc)mtab. |
| * setnetent: (libc)Networks Database. |
| * setnetgrent: (libc)Lookup Netgroup. |
| * setpgid: (libc)Process Group Functions. |
| * setpgrp: (libc)Process Group Functions. |
| * setpriority: (libc)Traditional Scheduling Functions. |
| * setprotoent: (libc)Protocols Database. |
| * setpwent: (libc)Scanning All Users. |
| * setregid: (libc)Setting Groups. |
| * setreuid: (libc)Setting User ID. |
| * setrlimit64: (libc)Limits on Resources. |
| * setrlimit: (libc)Limits on Resources. |
| * setservent: (libc)Services Database. |
| * setsid: (libc)Process Group Functions. |
| * setsockopt: (libc)Socket Option Functions. |
| * setstate: (libc)BSD Random. |
| * setstate_r: (libc)BSD Random. |
| * settimeofday: (libc)High-Resolution Calendar. |
| * setuid: (libc)Setting User ID. |
| * setutent: (libc)Manipulating the Database. |
| * setutxent: (libc)XPG Functions. |
| * setvbuf: (libc)Controlling Buffering. |
| * shm_open: (libc)Memory-mapped I/O. |
| * shm_unlink: (libc)Memory-mapped I/O. |
| * shutdown: (libc)Closing a Socket. |
| * sigaction: (libc)Advanced Signal Handling. |
| * sigaddset: (libc)Signal Sets. |
| * sigaltstack: (libc)Signal Stack. |
| * sigblock: (libc)Blocking in BSD. |
| * sigdelset: (libc)Signal Sets. |
| * sigemptyset: (libc)Signal Sets. |
| * sigfillset: (libc)Signal Sets. |
| * siginterrupt: (libc)BSD Handler. |
| * sigismember: (libc)Signal Sets. |
| * siglongjmp: (libc)Non-Local Exits and Signals. |
| * sigmask: (libc)Blocking in BSD. |
| * signal: (libc)Basic Signal Handling. |
| * signbit: (libc)FP Bit Twiddling. |
| * significand: (libc)Normalization Functions. |
| * significandf: (libc)Normalization Functions. |
| * significandl: (libc)Normalization Functions. |
| * sigpause: (libc)Blocking in BSD. |
| * sigpending: (libc)Checking for Pending Signals. |
| * sigprocmask: (libc)Process Signal Mask. |
| * sigsetjmp: (libc)Non-Local Exits and Signals. |
| * sigsetmask: (libc)Blocking in BSD. |
| * sigstack: (libc)Signal Stack. |
| * sigsuspend: (libc)Sigsuspend. |
| * sigvec: (libc)BSD Handler. |
| * sin: (libc)Trig Functions. |
| * sincos: (libc)Trig Functions. |
| * sincosf: (libc)Trig Functions. |
| * sincosl: (libc)Trig Functions. |
| * sinf: (libc)Trig Functions. |
| * sinh: (libc)Hyperbolic Functions. |
| * sinhf: (libc)Hyperbolic Functions. |
| * sinhl: (libc)Hyperbolic Functions. |
| * sinl: (libc)Trig Functions. |
| * sleep: (libc)Sleeping. |
| * snprintf: (libc)Formatted Output Functions. |
| * socket: (libc)Creating a Socket. |
| * socketpair: (libc)Socket Pairs. |
| * sprintf: (libc)Formatted Output Functions. |
| * sqrt: (libc)Exponents and Logarithms. |
| * sqrtf: (libc)Exponents and Logarithms. |
| * sqrtl: (libc)Exponents and Logarithms. |
| * srand48: (libc)SVID Random. |
| * srand48_r: (libc)SVID Random. |
| * srand: (libc)ISO Random. |
| * srandom: (libc)BSD Random. |
| * srandom_r: (libc)BSD Random. |
| * sscanf: (libc)Formatted Input Functions. |
| * ssignal: (libc)Basic Signal Handling. |
| * stat64: (libc)Reading Attributes. |
| * stat: (libc)Reading Attributes. |
| * stime: (libc)Simple Calendar Time. |
| * stpcpy: (libc)Copying and Concatenation. |
| * stpncpy: (libc)Copying and Concatenation. |
| * strcasecmp: (libc)String/Array Comparison. |
| * strcasestr: (libc)Search Functions. |
| * strcat: (libc)Copying and Concatenation. |
| * strchr: (libc)Search Functions. |
| * strchrnul: (libc)Search Functions. |
| * strcmp: (libc)String/Array Comparison. |
| * strcoll: (libc)Collation Functions. |
| * strcpy: (libc)Copying and Concatenation. |
| * strcspn: (libc)Search Functions. |
| * strdup: (libc)Copying and Concatenation. |
| * strdupa: (libc)Copying and Concatenation. |
| * strerror: (libc)Error Messages. |
| * strerror_r: (libc)Error Messages. |
| * strfmon: (libc)Formatting Numbers. |
| * strfry: (libc)strfry. |
| * strftime: (libc)Formatting Calendar Time. |
| * strlen: (libc)String Length. |
| * strncasecmp: (libc)String/Array Comparison. |
| * strncat: (libc)Copying and Concatenation. |
| * strncmp: (libc)String/Array Comparison. |
| * strncpy: (libc)Copying and Concatenation. |
| * strndup: (libc)Copying and Concatenation. |
| * strndupa: (libc)Copying and Concatenation. |
| * strnlen: (libc)String Length. |
| * strpbrk: (libc)Search Functions. |
| * strptime: (libc)Low-Level Time String Parsing. |
| * strrchr: (libc)Search Functions. |
| * strsep: (libc)Finding Tokens in a String. |
| * strsignal: (libc)Signal Messages. |
| * strspn: (libc)Search Functions. |
| * strstr: (libc)Search Functions. |
| * strtod: (libc)Parsing of Floats. |
| * strtof: (libc)Parsing of Floats. |
| * strtoimax: (libc)Parsing of Integers. |
| * strtok: (libc)Finding Tokens in a String. |
| * strtok_r: (libc)Finding Tokens in a String. |
| * strtol: (libc)Parsing of Integers. |
| * strtold: (libc)Parsing of Floats. |
| * strtoll: (libc)Parsing of Integers. |
| * strtoq: (libc)Parsing of Integers. |
| * strtoul: (libc)Parsing of Integers. |
| * strtoull: (libc)Parsing of Integers. |
| * strtoumax: (libc)Parsing of Integers. |
| * strtouq: (libc)Parsing of Integers. |
| * strverscmp: (libc)String/Array Comparison. |
| * strxfrm: (libc)Collation Functions. |
| * stty: (libc)BSD Terminal Modes. |
| * swapcontext: (libc)System V contexts. |
| * swprintf: (libc)Formatted Output Functions. |
| * swscanf: (libc)Formatted Input Functions. |
| * symlink: (libc)Symbolic Links. |
| * sync: (libc)Synchronizing I/O. |
| * syscall: (libc)System Calls. |
| * sysconf: (libc)Sysconf Definition. |
| * sysctl: (libc)System Parameters. |
| * syslog: (libc)syslog; vsyslog. |
| * system: (libc)Running a Command. |
| * sysv_signal: (libc)Basic Signal Handling. |
| * tan: (libc)Trig Functions. |
| * tanf: (libc)Trig Functions. |
| * tanh: (libc)Hyperbolic Functions. |
| * tanhf: (libc)Hyperbolic Functions. |
| * tanhl: (libc)Hyperbolic Functions. |
| * tanl: (libc)Trig Functions. |
| * tcdrain: (libc)Line Control. |
| * tcflow: (libc)Line Control. |
| * tcflush: (libc)Line Control. |
| * tcgetattr: (libc)Mode Functions. |
| * tcgetpgrp: (libc)Terminal Access Functions. |
| * tcgetsid: (libc)Terminal Access Functions. |
| * tcsendbreak: (libc)Line Control. |
| * tcsetattr: (libc)Mode Functions. |
| * tcsetpgrp: (libc)Terminal Access Functions. |
| * tdelete: (libc)Tree Search Function. |
| * tdestroy: (libc)Tree Search Function. |
| * telldir: (libc)Random Access Directory. |
| * tempnam: (libc)Temporary Files. |
| * textdomain: (libc)Locating gettext catalog. |
| * tfind: (libc)Tree Search Function. |
| * tgamma: (libc)Special Functions. |
| * tgammaf: (libc)Special Functions. |
| * tgammal: (libc)Special Functions. |
| * time: (libc)Simple Calendar Time. |
| * timegm: (libc)Broken-down Time. |
| * timelocal: (libc)Broken-down Time. |
| * times: (libc)Processor Time. |
| * tmpfile64: (libc)Temporary Files. |
| * tmpfile: (libc)Temporary Files. |
| * tmpnam: (libc)Temporary Files. |
| * tmpnam_r: (libc)Temporary Files. |
| * toascii: (libc)Case Conversion. |
| * tolower: (libc)Case Conversion. |
| * toupper: (libc)Case Conversion. |
| * towctrans: (libc)Wide Character Case Conversion. |
| * towlower: (libc)Wide Character Case Conversion. |
| * towupper: (libc)Wide Character Case Conversion. |
| * trunc: (libc)Rounding Functions. |
| * truncate64: (libc)File Size. |
| * truncate: (libc)File Size. |
| * truncf: (libc)Rounding Functions. |
| * truncl: (libc)Rounding Functions. |
| * tsearch: (libc)Tree Search Function. |
| * ttyname: (libc)Is It a Terminal. |
| * ttyname_r: (libc)Is It a Terminal. |
| * twalk: (libc)Tree Search Function. |
| * tzset: (libc)Time Zone Functions. |
| * ulimit: (libc)Limits on Resources. |
| * umask: (libc)Setting Permissions. |
| * umount2: (libc)Mount-Unmount-Remount. |
| * umount: (libc)Mount-Unmount-Remount. |
| * uname: (libc)Platform Type. |
| * ungetc: (libc)How Unread. |
| * ungetwc: (libc)How Unread. |
| * unlink: (libc)Deleting Files. |
| * unlockpt: (libc)Allocation. |
| * unsetenv: (libc)Environment Access. |
| * updwtmp: (libc)Manipulating the Database. |
| * utime: (libc)File Times. |
| * utimes: (libc)File Times. |
| * utmpname: (libc)Manipulating the Database. |
| * utmpxname: (libc)XPG Functions. |
| * va_arg: (libc)Argument Macros. |
| * va_copy: (libc)Argument Macros. |
| * va_end: (libc)Argument Macros. |
| * va_start: (libc)Argument Macros. |
| * valloc: (libc)Aligned Memory Blocks. |
| * vasprintf: (libc)Variable Arguments Output. |
| * verr: (libc)Error Messages. |
| * verrx: (libc)Error Messages. |
| * versionsort64: (libc)Scanning Directory Content. |
| * versionsort: (libc)Scanning Directory Content. |
| * vfork: (libc)Creating a Process. |
| * vfprintf: (libc)Variable Arguments Output. |
| * vfscanf: (libc)Variable Arguments Input. |
| * vfwprintf: (libc)Variable Arguments Output. |
| * vfwscanf: (libc)Variable Arguments Input. |
| * vlimit: (libc)Limits on Resources. |
| * vprintf: (libc)Variable Arguments Output. |
| * vscanf: (libc)Variable Arguments Input. |
| * vsnprintf: (libc)Variable Arguments Output. |
| * vsprintf: (libc)Variable Arguments Output. |
| * vsscanf: (libc)Variable Arguments Input. |
| * vswprintf: (libc)Variable Arguments Output. |
| * vswscanf: (libc)Variable Arguments Input. |
| * vsyslog: (libc)syslog; vsyslog. |
| * vtimes: (libc)Resource Usage. |
| * vwarn: (libc)Error Messages. |
| * vwarnx: (libc)Error Messages. |
| * vwprintf: (libc)Variable Arguments Output. |
| * vwscanf: (libc)Variable Arguments Input. |
| * wait3: (libc)BSD Wait Functions. |
| * wait4: (libc)Process Completion. |
| * wait: (libc)Process Completion. |
| * waitpid: (libc)Process Completion. |
| * warn: (libc)Error Messages. |
| * warnx: (libc)Error Messages. |
| * wcpcpy: (libc)Copying and Concatenation. |
| * wcpncpy: (libc)Copying and Concatenation. |
| * wcrtomb: (libc)Converting a Character. |
| * wcscasecmp: (libc)String/Array Comparison. |
| * wcscat: (libc)Copying and Concatenation. |
| * wcschr: (libc)Search Functions. |
| * wcschrnul: (libc)Search Functions. |
| * wcscmp: (libc)String/Array Comparison. |
| * wcscoll: (libc)Collation Functions. |
| * wcscpy: (libc)Copying and Concatenation. |
| * wcscspn: (libc)Search Functions. |
| * wcsdup: (libc)Copying and Concatenation. |
| * wcsftime: (libc)Formatting Calendar Time. |
| * wcslen: (libc)String Length. |
| * wcsncasecmp: (libc)String/Array Comparison. |
| * wcsncat: (libc)Copying and Concatenation. |
| * wcsncmp: (libc)String/Array Comparison. |
| * wcsncpy: (libc)Copying and Concatenation. |
| * wcsnlen: (libc)String Length. |
| * wcsnrtombs: (libc)Converting Strings. |
| * wcspbrk: (libc)Search Functions. |
| * wcsrchr: (libc)Search Functions. |
| * wcsrtombs: (libc)Converting Strings. |
| * wcsspn: (libc)Search Functions. |
| * wcsstr: (libc)Search Functions. |
| * wcstod: (libc)Parsing of Floats. |
| * wcstof: (libc)Parsing of Floats. |
| * wcstoimax: (libc)Parsing of Integers. |
| * wcstok: (libc)Finding Tokens in a String. |
| * wcstol: (libc)Parsing of Integers. |
| * wcstold: (libc)Parsing of Floats. |
| * wcstoll: (libc)Parsing of Integers. |
| * wcstombs: (libc)Non-reentrant String Conversion. |
| * wcstoq: (libc)Parsing of Integers. |
| * wcstoul: (libc)Parsing of Integers. |
| * wcstoull: (libc)Parsing of Integers. |
| * wcstoumax: (libc)Parsing of Integers. |
| * wcstouq: (libc)Parsing of Integers. |
| * wcswcs: (libc)Search Functions. |
| * wcsxfrm: (libc)Collation Functions. |
| * wctob: (libc)Converting a Character. |
| * wctomb: (libc)Non-reentrant Character Conversion. |
| * wctrans: (libc)Wide Character Case Conversion. |
| * wctype: (libc)Classification of Wide Characters. |
| * wmemchr: (libc)Search Functions. |
| * wmemcmp: (libc)String/Array Comparison. |
| * wmemcpy: (libc)Copying and Concatenation. |
| * wmemmove: (libc)Copying and Concatenation. |
| * wmempcpy: (libc)Copying and Concatenation. |
| * wmemset: (libc)Copying and Concatenation. |
| * wordexp: (libc)Calling Wordexp. |
| * wordfree: (libc)Calling Wordexp. |
| * wprintf: (libc)Formatted Output Functions. |
| * write: (libc)I/O Primitives. |
| * writev: (libc)Scatter-Gather. |
| * wscanf: (libc)Formatted Input Functions. |
| * y0: (libc)Special Functions. |
| * y0f: (libc)Special Functions. |
| * y0l: (libc)Special Functions. |
| * y1: (libc)Special Functions. |
| * y1f: (libc)Special Functions. |
| * y1l: (libc)Special Functions. |
| * yn: (libc)Special Functions. |
| * ynf: (libc)Special Functions. |
| * ynl: (libc)Special Functions. |
| END-INFO-DIR-ENTRY |
| |
| |
| File: libc.info, Node: Obstack Functions, Next: Growing Objects, Prev: Freeing Obstack Objects, Up: Obstacks |
| |
| 3.2.4.5 Obstack Functions and Macros |
| .................................... |
| |
| The interfaces for using obstacks may be defined either as functions or |
| as macros, depending on the compiler. The obstack facility works with |
| all C compilers, including both ISO C and traditional C, but there are |
| precautions you must take if you plan to use compilers other than GNU C. |
| |
| If you are using an old-fashioned non-ISO C compiler, all the obstack |
| "functions" are actually defined only as macros. You can call these |
| macros like functions, but you cannot use them in any other way (for |
| example, you cannot take their address). |
| |
| Calling the macros requires a special precaution: namely, the first |
| operand (the obstack pointer) may not contain any side effects, because |
| it may be computed more than once. For example, if you write this: |
| |
| obstack_alloc (get_obstack (), 4); |
| |
| you will find that 'get_obstack' may be called several times. If you |
| use '*obstack_list_ptr++' as the obstack pointer argument, you will get |
| very strange results since the incrementation may occur several times. |
| |
| In ISO C, each function has both a macro definition and a function |
| definition. The function definition is used if you take the address of |
| the function without calling it. An ordinary call uses the macro |
| definition by default, but you can request the function definition |
| instead by writing the function name in parentheses, as shown here: |
| |
| char *x; |
| void *(*funcp) (); |
| /* Use the macro. */ |
| x = (char *) obstack_alloc (obptr, size); |
| /* Call the function. */ |
| x = (char *) (obstack_alloc) (obptr, size); |
| /* Take the address of the function. */ |
| funcp = obstack_alloc; |
| |
| This is the same situation that exists in ISO C for the standard library |
| functions. *Note Macro Definitions::. |
| |
| *Warning:* When you do use the macros, you must observe the |
| precaution of avoiding side effects in the first operand, even in ISO C. |
| |
| If you use the GNU C compiler, this precaution is not necessary, |
| because various language extensions in GNU C permit defining the macros |
| so as to compute each argument only once. |
| |
| |
| File: libc.info, Node: Growing Objects, Next: Extra Fast Growing, Prev: Obstack Functions, Up: Obstacks |
| |
| 3.2.4.6 Growing Objects |
| ....................... |
| |
| Because memory in obstack chunks is used sequentially, it is possible to |
| build up an object step by step, adding one or more bytes at a time to |
| the end of the object. With this technique, you do not need to know how |
| much data you will put in the object until you come to the end of it. |
| We call this the technique of "growing objects". The special functions |
| for adding data to the growing object are described in this section. |
| |
| You don't need to do anything special when you start to grow an |
| object. Using one of the functions to add data to the object |
| automatically starts it. However, it is necessary to say explicitly |
| when the object is finished. This is done with the function |
| 'obstack_finish'. |
| |
| The actual address of the object thus built up is not known until the |
| object is finished. Until then, it always remains possible that you |
| will add so much data that the object must be copied into a new chunk. |
| |
| While the obstack is in use for a growing object, you cannot use it |
| for ordinary allocation of another object. If you try to do so, the |
| space already added to the growing object will become part of the other |
| object. |
| |
| -- Function: void obstack_blank (struct obstack *OBSTACK-PTR, int SIZE) |
| Preliminary: | MT-Safe race:obstack-ptr | AS-Safe | AC-Unsafe |
| corrupt mem | *Note POSIX Safety Concepts::. |
| |
| The most basic function for adding to a growing object is |
| 'obstack_blank', which adds space without initializing it. |
| |
| -- Function: void obstack_grow (struct obstack *OBSTACK-PTR, void |
| *DATA, int SIZE) |
| Preliminary: | MT-Safe race:obstack-ptr | AS-Safe | AC-Unsafe |
| corrupt mem | *Note POSIX Safety Concepts::. |
| |
| To add a block of initialized space, use 'obstack_grow', which is |
| the growing-object analogue of 'obstack_copy'. It adds SIZE bytes |
| of data to the growing object, copying the contents from DATA. |
| |
| -- Function: void obstack_grow0 (struct obstack *OBSTACK-PTR, void |
| *DATA, int SIZE) |
| Preliminary: | MT-Safe race:obstack-ptr | AS-Safe | AC-Unsafe |
| corrupt mem | *Note POSIX Safety Concepts::. |
| |
| This is the growing-object analogue of 'obstack_copy0'. It adds |
| SIZE bytes copied from DATA, followed by an additional null |
| character. |
| |
| -- Function: void obstack_1grow (struct obstack *OBSTACK-PTR, char C) |
| Preliminary: | MT-Safe race:obstack-ptr | AS-Safe | AC-Unsafe |
| corrupt mem | *Note POSIX Safety Concepts::. |
| |
| To add one character at a time, use the function 'obstack_1grow'. |
| It adds a single byte containing C to the growing object. |
| |
| -- Function: void obstack_ptr_grow (struct obstack *OBSTACK-PTR, void |
| *DATA) |
| Preliminary: | MT-Safe race:obstack-ptr | AS-Safe | AC-Unsafe |
| corrupt mem | *Note POSIX Safety Concepts::. |
| |
| Adding the value of a pointer one can use the function |
| 'obstack_ptr_grow'. It adds 'sizeof (void *)' bytes containing the |
| value of DATA. |
| |
| -- Function: void obstack_int_grow (struct obstack *OBSTACK-PTR, int |
| DATA) |
| Preliminary: | MT-Safe race:obstack-ptr | AS-Safe | AC-Unsafe |
| corrupt mem | *Note POSIX Safety Concepts::. |
| |
| A single value of type 'int' can be added by using the |
| 'obstack_int_grow' function. It adds 'sizeof (int)' bytes to the |
| growing object and initializes them with the value of DATA. |
| |
| -- Function: void * obstack_finish (struct obstack *OBSTACK-PTR) |
| Preliminary: | MT-Safe race:obstack-ptr | AS-Safe | AC-Unsafe |
| corrupt | *Note POSIX Safety Concepts::. |
| |
| When you are finished growing the object, use the function |
| 'obstack_finish' to close it off and return its final address. |
| |
| Once you have finished the object, the obstack is available for |
| ordinary allocation or for growing another object. |
| |
| This function can return a null pointer under the same conditions |
| as 'obstack_alloc' (*note Allocation in an Obstack::). |
| |
| When you build an object by growing it, you will probably need to |
| know afterward how long it became. You need not keep track of this as |
| you grow the object, because you can find out the length from the |
| obstack just before finishing the object with the function |
| 'obstack_object_size', declared as follows: |
| |
| -- Function: int obstack_object_size (struct obstack *OBSTACK-PTR) |
| Preliminary: | MT-Safe race:obstack-ptr | AS-Safe | AC-Safe | *Note |
| POSIX Safety Concepts::. |
| |
| This function returns the current size of the growing object, in |
| bytes. Remember to call this function _before_ finishing the |
| object. After it is finished, 'obstack_object_size' will return |
| zero. |
| |
| If you have started growing an object and wish to cancel it, you |
| should finish it and then free it, like this: |
| |
| obstack_free (obstack_ptr, obstack_finish (obstack_ptr)); |
| |
| This has no effect if no object was growing. |
| |
| You can use 'obstack_blank' with a negative size argument to make the |
| current object smaller. Just don't try to shrink it beyond zero |
| length--there's no telling what will happen if you do that. |
| |
| |
| File: libc.info, Node: Extra Fast Growing, Next: Status of an Obstack, Prev: Growing Objects, Up: Obstacks |
| |
| 3.2.4.7 Extra Fast Growing Objects |
| .................................. |
| |
| The usual functions for growing objects incur overhead for checking |
| whether there is room for the new growth in the current chunk. If you |
| are frequently constructing objects in small steps of growth, this |
| overhead can be significant. |
| |
| You can reduce the overhead by using special "fast growth" functions |
| that grow the object without checking. In order to have a robust |
| program, you must do the checking yourself. If you do this checking in |
| the simplest way each time you are about to add data to the object, you |
| have not saved anything, because that is what the ordinary growth |
| functions do. But if you can arrange to check less often, or check more |
| efficiently, then you make the program faster. |
| |
| The function 'obstack_room' returns the amount of room available in |
| the current chunk. It is declared as follows: |
| |
| -- Function: int obstack_room (struct obstack *OBSTACK-PTR) |
| Preliminary: | MT-Safe race:obstack-ptr | AS-Safe | AC-Safe | *Note |
| POSIX Safety Concepts::. |
| |
| This returns the number of bytes that can be added safely to the |
| current growing object (or to an object about to be started) in |
| obstack OBSTACK using the fast growth functions. |
| |
| While you know there is room, you can use these fast growth functions |
| for adding data to a growing object: |
| |
| -- Function: void obstack_1grow_fast (struct obstack *OBSTACK-PTR, char |
| C) |
| Preliminary: | MT-Safe race:obstack-ptr | AS-Safe | AC-Unsafe |
| corrupt mem | *Note POSIX Safety Concepts::. |
| |
| The function 'obstack_1grow_fast' adds one byte containing the |
| character C to the growing object in obstack OBSTACK-PTR. |
| |
| -- Function: void obstack_ptr_grow_fast (struct obstack *OBSTACK-PTR, |
| void *DATA) |
| Preliminary: | MT-Safe race:obstack-ptr | AS-Safe | AC-Safe | *Note |
| POSIX Safety Concepts::. |
| |
| The function 'obstack_ptr_grow_fast' adds 'sizeof (void *)' bytes |
| containing the value of DATA to the growing object in obstack |
| OBSTACK-PTR. |
| |
| -- Function: void obstack_int_grow_fast (struct obstack *OBSTACK-PTR, |
| int DATA) |
| Preliminary: | MT-Safe race:obstack-ptr | AS-Safe | AC-Safe | *Note |
| POSIX Safety Concepts::. |
| |
| The function 'obstack_int_grow_fast' adds 'sizeof (int)' bytes |
| containing the value of DATA to the growing object in obstack |
| OBSTACK-PTR. |
| |
| -- Function: void obstack_blank_fast (struct obstack *OBSTACK-PTR, int |
| SIZE) |
| Preliminary: | MT-Safe race:obstack-ptr | AS-Safe | AC-Safe | *Note |
| POSIX Safety Concepts::. |
| |
| The function 'obstack_blank_fast' adds SIZE bytes to the growing |
| object in obstack OBSTACK-PTR without initializing them. |
| |
| When you check for space using 'obstack_room' and there is not enough |
| room for what you want to add, the fast growth functions are not safe. |
| In this case, simply use the corresponding ordinary growth function |
| instead. Very soon this will copy the object to a new chunk; then there |
| will be lots of room available again. |
| |
| So, each time you use an ordinary growth function, check afterward |
| for sufficient space using 'obstack_room'. Once the object is copied to |
| a new chunk, there will be plenty of space again, so the program will |
| start using the fast growth functions again. |
| |
| Here is an example: |
| |
| void |
| add_string (struct obstack *obstack, const char *ptr, int len) |
| { |
| while (len > 0) |
| { |
| int room = obstack_room (obstack); |
| if (room == 0) |
| { |
| /* Not enough room. Add one character slowly, |
| which may copy to a new chunk and make room. */ |
| obstack_1grow (obstack, *ptr++); |
| len--; |
| } |
| else |
| { |
| if (room > len) |
| room = len; |
| /* Add fast as much as we have room for. */ |
| len -= room; |
| while (room-- > 0) |
| obstack_1grow_fast (obstack, *ptr++); |
| } |
| } |
| } |
| |
| |
| File: libc.info, Node: Status of an Obstack, Next: Obstacks Data Alignment, Prev: Extra Fast Growing, Up: Obstacks |
| |
| 3.2.4.8 Status of an Obstack |
| ............................ |
| |
| Here are functions that provide information on the current status of |
| allocation in an obstack. You can use them to learn about an object |
| while still growing it. |
| |
| -- Function: void * obstack_base (struct obstack *OBSTACK-PTR) |
| Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Safe | *Note POSIX |
| Safety Concepts::. |
| |
| This function returns the tentative address of the beginning of the |
| currently growing object in OBSTACK-PTR. If you finish the object |
| immediately, it will have that address. If you make it larger |
| first, it may outgrow the current chunk--then its address will |
| change! |
| |
| If no object is growing, this value says where the next object you |
| allocate will start (once again assuming it fits in the current |
| chunk). |
| |
| -- Function: void * obstack_next_free (struct obstack *OBSTACK-PTR) |
| Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Safe | *Note POSIX |
| Safety Concepts::. |
| |
| This function returns the address of the first free byte in the |
| current chunk of obstack OBSTACK-PTR. This is the end of the |
| currently growing object. If no object is growing, |
| 'obstack_next_free' returns the same value as 'obstack_base'. |
| |
| -- Function: int obstack_object_size (struct obstack *OBSTACK-PTR) |
| Preliminary: | MT-Safe race:obstack-ptr | AS-Safe | AC-Safe | *Note |
| POSIX Safety Concepts::. |
| |
| This function returns the size in bytes of the currently growing |
| object. This is equivalent to |
| |
| obstack_next_free (OBSTACK-PTR) - obstack_base (OBSTACK-PTR) |
| |
| |
| File: libc.info, Node: Obstacks Data Alignment, Next: Obstack Chunks, Prev: Status of an Obstack, Up: Obstacks |
| |
| 3.2.4.9 Alignment of Data in Obstacks |
| ..................................... |
| |
| Each obstack has an "alignment boundary"; each object allocated in the |
| obstack automatically starts on an address that is a multiple of the |
| specified boundary. By default, this boundary is aligned so that the |
| object can hold any type of data. |
| |
| To access an obstack's alignment boundary, use the macro |
| 'obstack_alignment_mask', whose function prototype looks like this: |
| |
| -- Macro: int obstack_alignment_mask (struct obstack *OBSTACK-PTR) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| The value is a bit mask; a bit that is 1 indicates that the |
| corresponding bit in the address of an object should be 0. The |
| mask value should be one less than a power of 2; the effect is that |
| all object addresses are multiples of that power of 2. The default |
| value of the mask is a value that allows aligned objects to hold |
| any type of data: for example, if its value is 3, any type of data |
| can be stored at locations whose addresses are multiples of 4. A |
| mask value of 0 means an object can start on any multiple of 1 |
| (that is, no alignment is required). |
| |
| The expansion of the macro 'obstack_alignment_mask' is an lvalue, |
| so you can alter the mask by assignment. For example, this |
| statement: |
| |
| obstack_alignment_mask (obstack_ptr) = 0; |
| |
| has the effect of turning off alignment processing in the specified |
| obstack. |
| |
| Note that a change in alignment mask does not take effect until |
| _after_ the next time an object is allocated or finished in the obstack. |
| If you are not growing an object, you can make the new alignment mask |
| take effect immediately by calling 'obstack_finish'. This will finish a |
| zero-length object and then do proper alignment for the next object. |
| |
| |
| File: libc.info, Node: Obstack Chunks, Next: Summary of Obstacks, Prev: Obstacks Data Alignment, Up: Obstacks |
| |
| 3.2.4.10 Obstack Chunks |
| ....................... |
| |
| Obstacks work by allocating space for themselves in large chunks, and |
| then parceling out space in the chunks to satisfy your requests. Chunks |
| are normally 4096 bytes long unless you specify a different chunk size. |
| The chunk size includes 8 bytes of overhead that are not actually used |
| for storing objects. Regardless of the specified size, longer chunks |
| will be allocated when necessary for long objects. |
| |
| The obstack library allocates chunks by calling the function |
| 'obstack_chunk_alloc', which you must define. When a chunk is no longer |
| needed because you have freed all the objects in it, the obstack library |
| frees the chunk by calling 'obstack_chunk_free', which you must also |
| define. |
| |
| These two must be defined (as macros) or declared (as functions) in |
| each source file that uses 'obstack_init' (*note Creating Obstacks::). |
| Most often they are defined as macros like this: |
| |
| #define obstack_chunk_alloc malloc |
| #define obstack_chunk_free free |
| |
| Note that these are simple macros (no arguments). Macro definitions |
| with arguments will not work! It is necessary that |
| 'obstack_chunk_alloc' or 'obstack_chunk_free', alone, expand into a |
| function name if it is not itself a function name. |
| |
| If you allocate chunks with 'malloc', the chunk size should be a |
| power of 2. The default chunk size, 4096, was chosen because it is long |
| enough to satisfy many typical requests on the obstack yet short enough |
| not to waste too much memory in the portion of the last chunk not yet |
| used. |
| |
| -- Macro: int obstack_chunk_size (struct obstack *OBSTACK-PTR) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This returns the chunk size of the given obstack. |
| |
| Since this macro expands to an lvalue, you can specify a new chunk |
| size by assigning it a new value. Doing so does not affect the chunks |
| already allocated, but will change the size of chunks allocated for that |
| particular obstack in the future. It is unlikely to be useful to make |
| the chunk size smaller, but making it larger might improve efficiency if |
| you are allocating many objects whose size is comparable to the chunk |
| size. Here is how to do so cleanly: |
| |
| if (obstack_chunk_size (obstack_ptr) < NEW-CHUNK-SIZE) |
| obstack_chunk_size (obstack_ptr) = NEW-CHUNK-SIZE; |
| |
| |
| File: libc.info, Node: Summary of Obstacks, Prev: Obstack Chunks, Up: Obstacks |
| |
| 3.2.4.11 Summary of Obstack Functions |
| ..................................... |
| |
| Here is a summary of all the functions associated with obstacks. Each |
| takes the address of an obstack ('struct obstack *') as its first |
| argument. |
| |
| 'void obstack_init (struct obstack *OBSTACK-PTR)' |
| Initialize use of an obstack. *Note Creating Obstacks::. |
| |
| 'void *obstack_alloc (struct obstack *OBSTACK-PTR, int SIZE)' |
| Allocate an object of SIZE uninitialized bytes. *Note Allocation |
| in an Obstack::. |
| |
| 'void *obstack_copy (struct obstack *OBSTACK-PTR, void *ADDRESS, int SIZE)' |
| Allocate an object of SIZE bytes, with contents copied from |
| ADDRESS. *Note Allocation in an Obstack::. |
| |
| 'void *obstack_copy0 (struct obstack *OBSTACK-PTR, void *ADDRESS, int SIZE)' |
| Allocate an object of SIZE+1 bytes, with SIZE of them copied from |
| ADDRESS, followed by a null character at the end. *Note Allocation |
| in an Obstack::. |
| |
| 'void obstack_free (struct obstack *OBSTACK-PTR, void *OBJECT)' |
| Free OBJECT (and everything allocated in the specified obstack more |
| recently than OBJECT). *Note Freeing Obstack Objects::. |
| |
| 'void obstack_blank (struct obstack *OBSTACK-PTR, int SIZE)' |
| Add SIZE uninitialized bytes to a growing object. *Note Growing |
| Objects::. |
| |
| 'void obstack_grow (struct obstack *OBSTACK-PTR, void *ADDRESS, int SIZE)' |
| Add SIZE bytes, copied from ADDRESS, to a growing object. *Note |
| Growing Objects::. |
| |
| 'void obstack_grow0 (struct obstack *OBSTACK-PTR, void *ADDRESS, int SIZE)' |
| Add SIZE bytes, copied from ADDRESS, to a growing object, and then |
| add another byte containing a null character. *Note Growing |
| Objects::. |
| |
| 'void obstack_1grow (struct obstack *OBSTACK-PTR, char DATA-CHAR)' |
| Add one byte containing DATA-CHAR to a growing object. *Note |
| Growing Objects::. |
| |
| 'void *obstack_finish (struct obstack *OBSTACK-PTR)' |
| Finalize the object that is growing and return its permanent |
| address. *Note Growing Objects::. |
| |
| 'int obstack_object_size (struct obstack *OBSTACK-PTR)' |
| Get the current size of the currently growing object. *Note |
| Growing Objects::. |
| |
| 'void obstack_blank_fast (struct obstack *OBSTACK-PTR, int SIZE)' |
| Add SIZE uninitialized bytes to a growing object without checking |
| that there is enough room. *Note Extra Fast Growing::. |
| |
| 'void obstack_1grow_fast (struct obstack *OBSTACK-PTR, char DATA-CHAR)' |
| Add one byte containing DATA-CHAR to a growing object without |
| checking that there is enough room. *Note Extra Fast Growing::. |
| |
| 'int obstack_room (struct obstack *OBSTACK-PTR)' |
| Get the amount of room now available for growing the current |
| object. *Note Extra Fast Growing::. |
| |
| 'int obstack_alignment_mask (struct obstack *OBSTACK-PTR)' |
| The mask used for aligning the beginning of an object. This is an |
| lvalue. *Note Obstacks Data Alignment::. |
| |
| 'int obstack_chunk_size (struct obstack *OBSTACK-PTR)' |
| The size for allocating chunks. This is an lvalue. *Note Obstack |
| Chunks::. |
| |
| 'void *obstack_base (struct obstack *OBSTACK-PTR)' |
| Tentative starting address of the currently growing object. *Note |
| Status of an Obstack::. |
| |
| 'void *obstack_next_free (struct obstack *OBSTACK-PTR)' |
| Address just after the end of the currently growing object. *Note |
| Status of an Obstack::. |
| |
| |
| File: libc.info, Node: Variable Size Automatic, Prev: Obstacks, Up: Memory Allocation |
| |
| 3.2.5 Automatic Storage with Variable Size |
| ------------------------------------------ |
| |
| The function 'alloca' supports a kind of half-dynamic allocation in |
| which blocks are allocated dynamically but freed automatically. |
| |
| Allocating a block with 'alloca' is an explicit action; you can |
| allocate as many blocks as you wish, and compute the size at run time. |
| But all the blocks are freed when you exit the function that 'alloca' |
| was called from, just as if they were automatic variables declared in |
| that function. There is no way to free the space explicitly. |
| |
| The prototype for 'alloca' is in 'stdlib.h'. This function is a BSD |
| extension. |
| |
| -- Function: void * alloca (size_t SIZE) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| The return value of 'alloca' is the address of a block of SIZE |
| bytes of memory, allocated in the stack frame of the calling |
| function. |
| |
| Do not use 'alloca' inside the arguments of a function call--you will |
| get unpredictable results, because the stack space for the 'alloca' |
| would appear on the stack in the middle of the space for the function |
| arguments. An example of what to avoid is 'foo (x, alloca (4), y)'. |
| |
| * Menu: |
| |
| * Alloca Example:: Example of using 'alloca'. |
| * Advantages of Alloca:: Reasons to use 'alloca'. |
| * Disadvantages of Alloca:: Reasons to avoid 'alloca'. |
| * GNU C Variable-Size Arrays:: Only in GNU C, here is an alternative |
| method of allocating dynamically and |
| freeing automatically. |
| |
| |
| File: libc.info, Node: Alloca Example, Next: Advantages of Alloca, Up: Variable Size Automatic |
| |
| 3.2.5.1 'alloca' Example |
| ........................ |
| |
| As an example of the use of 'alloca', here is a function that opens a |
| file name made from concatenating two argument strings, and returns a |
| file descriptor or minus one signifying failure: |
| |
| int |
| open2 (char *str1, char *str2, int flags, int mode) |
| { |
| char *name = (char *) alloca (strlen (str1) + strlen (str2) + 1); |
| stpcpy (stpcpy (name, str1), str2); |
| return open (name, flags, mode); |
| } |
| |
| Here is how you would get the same results with 'malloc' and 'free': |
| |
| int |
| open2 (char *str1, char *str2, int flags, int mode) |
| { |
| char *name = (char *) malloc (strlen (str1) + strlen (str2) + 1); |
| int desc; |
| if (name == 0) |
| fatal ("virtual memory exceeded"); |
| stpcpy (stpcpy (name, str1), str2); |
| desc = open (name, flags, mode); |
| free (name); |
| return desc; |
| } |
| |
| As you can see, it is simpler with 'alloca'. But 'alloca' has other, |
| more important advantages, and some disadvantages. |
| |
| |
| File: libc.info, Node: Advantages of Alloca, Next: Disadvantages of Alloca, Prev: Alloca Example, Up: Variable Size Automatic |
| |
| 3.2.5.2 Advantages of 'alloca' |
| .............................. |
| |
| Here are the reasons why 'alloca' may be preferable to 'malloc': |
| |
| * Using 'alloca' wastes very little space and is very fast. (It is |
| open-coded by the GNU C compiler.) |
| |
| * Since 'alloca' does not have separate pools for different sizes of |
| block, space used for any size block can be reused for any other |
| size. 'alloca' does not cause memory fragmentation. |
| |
| * Nonlocal exits done with 'longjmp' (*note Non-Local Exits::) |
| automatically free the space allocated with 'alloca' when they exit |
| through the function that called 'alloca'. This is the most |
| important reason to use 'alloca'. |
| |
| To illustrate this, suppose you have a function |
| 'open_or_report_error' which returns a descriptor, like 'open', if |
| it succeeds, but does not return to its caller if it fails. If the |
| file cannot be opened, it prints an error message and jumps out to |
| the command level of your program using 'longjmp'. Let's change |
| 'open2' (*note Alloca Example::) to use this subroutine: |
| |
| int |
| open2 (char *str1, char *str2, int flags, int mode) |
| { |
| char *name = (char *) alloca (strlen (str1) + strlen (str2) + 1); |
| stpcpy (stpcpy (name, str1), str2); |
| return open_or_report_error (name, flags, mode); |
| } |
| |
| Because of the way 'alloca' works, the memory it allocates is freed |
| even when an error occurs, with no special effort required. |
| |
| By contrast, the previous definition of 'open2' (which uses |
| 'malloc' and 'free') would develop a memory leak if it were changed |
| in this way. Even if you are willing to make more changes to fix |
| it, there is no easy way to do so. |
| |
| |
| File: libc.info, Node: Disadvantages of Alloca, Next: GNU C Variable-Size Arrays, Prev: Advantages of Alloca, Up: Variable Size Automatic |
| |
| 3.2.5.3 Disadvantages of 'alloca' |
| ................................. |
| |
| These are the disadvantages of 'alloca' in comparison with 'malloc': |
| |
| * If you try to allocate more memory than the machine can provide, |
| you don't get a clean error message. Instead you get a fatal |
| signal like the one you would get from an infinite recursion; |
| probably a segmentation violation (*note Program Error Signals::). |
| |
| * Some non-GNU systems fail to support 'alloca', so it is less |
| portable. However, a slower emulation of 'alloca' written in C is |
| available for use on systems with this deficiency. |
| |
| |
| File: libc.info, Node: GNU C Variable-Size Arrays, Prev: Disadvantages of Alloca, Up: Variable Size Automatic |
| |
| 3.2.5.4 GNU C Variable-Size Arrays |
| .................................. |
| |
| In GNU C, you can replace most uses of 'alloca' with an array of |
| variable size. Here is how 'open2' would look then: |
| |
| int open2 (char *str1, char *str2, int flags, int mode) |
| { |
| char name[strlen (str1) + strlen (str2) + 1]; |
| stpcpy (stpcpy (name, str1), str2); |
| return open (name, flags, mode); |
| } |
| |
| But 'alloca' is not always equivalent to a variable-sized array, for |
| several reasons: |
| |
| * A variable size array's space is freed at the end of the scope of |
| the name of the array. The space allocated with 'alloca' remains |
| until the end of the function. |
| |
| * It is possible to use 'alloca' within a loop, allocating an |
| additional block on each iteration. This is impossible with |
| variable-sized arrays. |
| |
| *NB:* If you mix use of 'alloca' and variable-sized arrays within one |
| function, exiting a scope in which a variable-sized array was declared |
| frees all blocks allocated with 'alloca' during the execution of that |
| scope. |
| |
| |
| File: libc.info, Node: Resizing the Data Segment, Next: Locking Pages, Prev: Memory Allocation, Up: Memory |
| |
| 3.3 Resizing the Data Segment |
| ============================= |
| |
| The symbols in this section are declared in 'unistd.h'. |
| |
| You will not normally use the functions in this section, because the |
| functions described in *note Memory Allocation:: are easier to use. |
| Those are interfaces to a GNU C Library memory allocator that uses the |
| functions below itself. The functions below are simple interfaces to |
| system calls. |
| |
| -- Function: int brk (void *ADDR) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| 'brk' sets the high end of the calling process' data segment to |
| ADDR. |
| |
| The address of the end of a segment is defined to be the address of |
| the last byte in the segment plus 1. |
| |
| The function has no effect if ADDR is lower than the low end of the |
| data segment. (This is considered success, by the way). |
| |
| The function fails if it would cause the data segment to overlap |
| another segment or exceed the process' data storage limit (*note |
| Limits on Resources::). |
| |
| The function is named for a common historical case where data |
| storage and the stack are in the same segment. Data storage |
| allocation grows upward from the bottom of the segment while the |
| stack grows downward toward it from the top of the segment and the |
| curtain between them is called the "break". |
| |
| The return value is zero on success. On failure, the return value |
| is '-1' and 'errno' is set accordingly. The following 'errno' |
| values are specific to this function: |
| |
| 'ENOMEM' |
| The request would cause the data segment to overlap another |
| segment or exceed the process' data storage limit. |
| |
| -- Function: void *sbrk (ptrdiff_t DELTA) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This function is the same as 'brk' except that you specify the new |
| end of the data segment as an offset DELTA from the current end and |
| on success the return value is the address of the resulting end of |
| the data segment instead of zero. |
| |
| This means you can use 'sbrk(0)' to find out what the current end |
| of the data segment is. |
| |
| |
| File: libc.info, Node: Locking Pages, Prev: Resizing the Data Segment, Up: Memory |
| |
| 3.4 Locking Pages |
| ================= |
| |
| You can tell the system to associate a particular virtual memory page |
| with a real page frame and keep it that way -- i.e., cause the page to |
| be paged in if it isn't already and mark it so it will never be paged |
| out and consequently will never cause a page fault. This is called |
| "locking" a page. |
| |
| The functions in this chapter lock and unlock the calling process' |
| pages. |
| |
| * Menu: |
| |
| * Why Lock Pages:: Reasons to read this section. |
| * Locked Memory Details:: Everything you need to know locked |
| memory |
| * Page Lock Functions:: Here's how to do it. |
| |
| |
| File: libc.info, Node: Why Lock Pages, Next: Locked Memory Details, Up: Locking Pages |
| |
| 3.4.1 Why Lock Pages |
| -------------------- |
| |
| Because page faults cause paged out pages to be paged in transparently, |
| a process rarely needs to be concerned about locking pages. However, |
| there are two reasons people sometimes are: |
| |
| * Speed. A page fault is transparent only insofar as the process is |
| not sensitive to how long it takes to do a simple memory access. |
| Time-critical processes, especially realtime processes, may not be |
| able to wait or may not be able to tolerate variance in execution |
| speed. |
| |
| A process that needs to lock pages for this reason probably also |
| needs priority among other processes for use of the CPU. *Note |
| Priority::. |
| |
| In some cases, the programmer knows better than the system's demand |
| paging allocator which pages should remain in real memory to |
| optimize system performance. In this case, locking pages can help. |
| |
| * Privacy. If you keep secrets in virtual memory and that virtual |
| memory gets paged out, that increases the chance that the secrets |
| will get out. If a password gets written out to disk swap space, |
| for example, it might still be there long after virtual and real |
| memory have been wiped clean. |
| |
| Be aware that when you lock a page, that's one fewer page frame that |
| can be used to back other virtual memory (by the same or other |
| processes), which can mean more page faults, which means the system runs |
| more slowly. In fact, if you lock enough memory, some programs may not |
| be able to run at all for lack of real memory. |
| |
| |
| File: libc.info, Node: Locked Memory Details, Next: Page Lock Functions, Prev: Why Lock Pages, Up: Locking Pages |
| |
| 3.4.2 Locked Memory Details |
| --------------------------- |
| |
| A memory lock is associated with a virtual page, not a real frame. The |
| paging rule is: If a frame backs at least one locked page, don't page it |
| out. |
| |
| Memory locks do not stack. I.e., you can't lock a particular page |
| twice so that it has to be unlocked twice before it is truly unlocked. |
| It is either locked or it isn't. |
| |
| A memory lock persists until the process that owns the memory |
| explicitly unlocks it. (But process termination and exec cause the |
| virtual memory to cease to exist, which you might say means it isn't |
| locked any more). |
| |
| Memory locks are not inherited by child processes. (But note that on |
| a modern Unix system, immediately after a fork, the parent's and the |
| child's virtual address space are backed by the same real page frames, |
| so the child enjoys the parent's locks). *Note Creating a Process::. |
| |
| Because of its ability to impact other processes, only the superuser |
| can lock a page. Any process can unlock its own page. |
| |
| The system sets limits on the amount of memory a process can have |
| locked and the amount of real memory it can have dedicated to it. *Note |
| Limits on Resources::. |
| |
| In Linux, locked pages aren't as locked as you might think. Two |
| virtual pages that are not shared memory can nonetheless be backed by |
| the same real frame. The kernel does this in the name of efficiency |
| when it knows both virtual pages contain identical data, and does it |
| even if one or both of the virtual pages are locked. |
| |
| But when a process modifies one of those pages, the kernel must get |
| it a separate frame and fill it with the page's data. This is known as |
| a "copy-on-write page fault". It takes a small amount of time and in a |
| pathological case, getting that frame may require I/O. |
| |
| To make sure this doesn't happen to your program, don't just lock the |
| pages. Write to them as well, unless you know you won't write to them |
| ever. And to make sure you have pre-allocated frames for your stack, |
| enter a scope that declares a C automatic variable larger than the |
| maximum stack size you will need, set it to something, then return from |
| its scope. |
| |
| |
| File: libc.info, Node: Page Lock Functions, Prev: Locked Memory Details, Up: Locking Pages |
| |
| 3.4.3 Functions To Lock And Unlock Pages |
| ---------------------------------------- |
| |
| The symbols in this section are declared in 'sys/mman.h'. These |
| functions are defined by POSIX.1b, but their availability depends on |
| your kernel. If your kernel doesn't allow these functions, they exist |
| but always fail. They _are_ available with a Linux kernel. |
| |
| *Portability Note:* POSIX.1b requires that when the 'mlock' and |
| 'munlock' functions are available, the file 'unistd.h' define the macro |
| '_POSIX_MEMLOCK_RANGE' and the file 'limits.h' define the macro |
| 'PAGESIZE' to be the size of a memory page in bytes. It requires that |
| when the 'mlockall' and 'munlockall' functions are available, the |
| 'unistd.h' file define the macro '_POSIX_MEMLOCK'. The GNU C Library |
| conforms to this requirement. |
| |
| -- Function: int mlock (const void *ADDR, size_t LEN) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| 'mlock' locks a range of the calling process' virtual pages. |
| |
| The range of memory starts at address ADDR and is LEN bytes long. |
| Actually, since you must lock whole pages, it is the range of pages |
| that include any part of the specified range. |
| |
| When the function returns successfully, each of those pages is |
| backed by (connected to) a real frame (is resident) and is marked |
| to stay that way. This means the function may cause page-ins and |
| have to wait for them. |
| |
| When the function fails, it does not affect the lock status of any |
| pages. |
| |
| The return value is zero if the function succeeds. Otherwise, it |
| is '-1' and 'errno' is set accordingly. 'errno' values specific to |
| this function are: |
| |
| 'ENOMEM' |
| * At least some of the specified address range does not |
| exist in the calling process' virtual address space. |
| * The locking would cause the process to exceed its locked |
| page limit. |
| |
| 'EPERM' |
| The calling process is not superuser. |
| |
| 'EINVAL' |
| LEN is not positive. |
| |
| 'ENOSYS' |
| The kernel does not provide 'mlock' capability. |
| |
| You can lock _all_ a process' memory with 'mlockall'. You unlock |
| memory with 'munlock' or 'munlockall'. |
| |
| To avoid all page faults in a C program, you have to use |
| 'mlockall', because some of the memory a program uses is hidden |
| from the C code, e.g. the stack and automatic variables, and you |
| wouldn't know what address to tell 'mlock'. |
| |
| -- Function: int munlock (const void *ADDR, size_t LEN) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| 'munlock' unlocks a range of the calling process' virtual pages. |
| |
| 'munlock' is the inverse of 'mlock' and functions completely |
| analogously to 'mlock', except that there is no 'EPERM' failure. |
| |
| -- Function: int mlockall (int FLAGS) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| 'mlockall' locks all the pages in a process' virtual memory address |
| space, and/or any that are added to it in the future. This |
| includes the pages of the code, data and stack segment, as well as |
| shared libraries, user space kernel data, shared memory, and memory |
| mapped files. |
| |
| FLAGS is a string of single bit flags represented by the following |
| macros. They tell 'mlockall' which of its functions you want. All |
| other bits must be zero. |
| |
| 'MCL_CURRENT' |
| Lock all pages which currently exist in the calling process' |
| virtual address space. |
| |
| 'MCL_FUTURE' |
| Set a mode such that any pages added to the process' virtual |
| address space in the future will be locked from birth. This |
| mode does not affect future address spaces owned by the same |
| process so exec, which replaces a process' address space, |
| wipes out 'MCL_FUTURE'. *Note Executing a File::. |
| |
| When the function returns successfully, and you specified |
| 'MCL_CURRENT', all of the process' pages are backed by (connected |
| to) real frames (they are resident) and are marked to stay that |
| way. This means the function may cause page-ins and have to wait |
| for them. |
| |
| When the process is in 'MCL_FUTURE' mode because it successfully |
| executed this function and specified 'MCL_CURRENT', any system call |
| by the process that requires space be added to its virtual address |
| space fails with 'errno' = 'ENOMEM' if locking the additional space |
| would cause the process to exceed its locked page limit. In the |
| case that the address space addition that can't be accommodated is |
| stack expansion, the stack expansion fails and the kernel sends a |
| 'SIGSEGV' signal to the process. |
| |
| When the function fails, it does not affect the lock status of any |
| pages or the future locking mode. |
| |
| The return value is zero if the function succeeds. Otherwise, it |
| is '-1' and 'errno' is set accordingly. 'errno' values specific to |
| this function are: |
| |
| 'ENOMEM' |
| * At least some of the specified address range does not |
| exist in the calling process' virtual address space. |
| * The locking would cause the process to exceed its locked |
| page limit. |
| |
| 'EPERM' |
| The calling process is not superuser. |
| |
| 'EINVAL' |
| Undefined bits in FLAGS are not zero. |
| |
| 'ENOSYS' |
| The kernel does not provide 'mlockall' capability. |
| |
| You can lock just specific pages with 'mlock'. You unlock pages |
| with 'munlockall' and 'munlock'. |
| |
| -- Function: int munlockall (void) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| 'munlockall' unlocks every page in the calling process' virtual |
| address space and turn off 'MCL_FUTURE' future locking mode. |
| |
| The return value is zero if the function succeeds. Otherwise, it |
| is '-1' and 'errno' is set accordingly. The only way this function |
| can fail is for generic reasons that all functions and system calls |
| can fail, so there are no specific 'errno' values. |
| |
| |
| File: libc.info, Node: Character Handling, Next: String and Array Utilities, Prev: Memory, Up: Top |
| |
| 4 Character Handling |
| ******************** |
| |
| Programs that work with characters and strings often need to classify a |
| character--is it alphabetic, is it a digit, is it whitespace, and so |
| on--and perform case conversion operations on characters. The functions |
| in the header file 'ctype.h' are provided for this purpose. |
| |
| Since the choice of locale and character set can alter the |
| classifications of particular character codes, all of these functions |
| are affected by the current locale. (More precisely, they are affected |
| by the locale currently selected for character classification--the |
| 'LC_CTYPE' category; see *note Locale Categories::.) |
| |
| The ISO C standard specifies two different sets of functions. The |
| one set works on 'char' type characters, the other one on 'wchar_t' wide |
| characters (*note Extended Char Intro::). |
| |
| * Menu: |
| |
| * Classification of Characters:: Testing whether characters are |
| letters, digits, punctuation, etc. |
| |
| * Case Conversion:: Case mapping, and the like. |
| * Classification of Wide Characters:: Character class determination for |
| wide characters. |
| * Using Wide Char Classes:: Notes on using the wide character |
| classes. |
| * Wide Character Case Conversion:: Mapping of wide characters. |
| |
| |
| File: libc.info, Node: Classification of Characters, Next: Case Conversion, Up: Character Handling |
| |
| 4.1 Classification of Characters |
| ================================ |
| |
| This section explains the library functions for classifying characters. |
| For example, 'isalpha' is the function to test for an alphabetic |
| character. It takes one argument, the character to test, and returns a |
| nonzero integer if the character is alphabetic, and zero otherwise. You |
| would use it like this: |
| |
| if (isalpha (c)) |
| printf ("The character `%c' is alphabetic.\n", c); |
| |
| Each of the functions in this section tests for membership in a |
| particular class of characters; each has a name starting with 'is'. |
| Each of them takes one argument, which is a character to test, and |
| returns an 'int' which is treated as a boolean value. The character |
| argument is passed as an 'int', and it may be the constant value 'EOF' |
| instead of a real character. |
| |
| The attributes of any given character can vary between locales. |
| *Note Locales::, for more information on locales. |
| |
| These functions are declared in the header file 'ctype.h'. |
| |
| -- Function: int islower (int C) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| Returns true if C is a lower-case letter. The letter need not be |
| from the Latin alphabet, any alphabet representable is valid. |
| |
| -- Function: int isupper (int C) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| Returns true if C is an upper-case letter. The letter need not be |
| from the Latin alphabet, any alphabet representable is valid. |
| |
| -- Function: int isalpha (int C) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| Returns true if C is an alphabetic character (a letter). If |
| 'islower' or 'isupper' is true of a character, then 'isalpha' is |
| also true. |
| |
| In some locales, there may be additional characters for which |
| 'isalpha' is true--letters which are neither upper case nor lower |
| case. But in the standard '"C"' locale, there are no such |
| additional characters. |
| |
| -- Function: int isdigit (int C) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| Returns true if C is a decimal digit ('0' through '9'). |
| |
| -- Function: int isalnum (int C) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| Returns true if C is an alphanumeric character (a letter or |
| number); in other words, if either 'isalpha' or 'isdigit' is true |
| of a character, then 'isalnum' is also true. |
| |
| -- Function: int isxdigit (int C) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| Returns true if C is a hexadecimal digit. Hexadecimal digits |
| include the normal decimal digits '0' through '9' and the letters |
| 'A' through 'F' and 'a' through 'f'. |
| |
| -- Function: int ispunct (int C) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| Returns true if C is a punctuation character. This means any |
| printing character that is not alphanumeric or a space character. |
| |
| -- Function: int isspace (int C) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| Returns true if C is a "whitespace" character. In the standard |
| '"C"' locale, 'isspace' returns true for only the standard |
| whitespace characters: |
| |
| '' '' |
| space |
| |
| ''\f'' |
| formfeed |
| |
| ''\n'' |
| newline |
| |
| ''\r'' |
| carriage return |
| |
| ''\t'' |
| horizontal tab |
| |
| ''\v'' |
| vertical tab |
| |
| -- Function: int isblank (int C) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| Returns true if C is a blank character; that is, a space or a tab. |
| This function was originally a GNU extension, but was added in |
| ISO C99. |
| |
| -- Function: int isgraph (int C) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| Returns true if C is a graphic character; that is, a character that |
| has a glyph associated with it. The whitespace characters are not |
| considered graphic. |
| |
| -- Function: int isprint (int C) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| Returns true if C is a printing character. Printing characters |
| include all the graphic characters, plus the space (' ') character. |
| |
| -- Function: int iscntrl (int C) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| Returns true if C is a control character (that is, a character that |
| is not a printing character). |
| |
| -- Function: int isascii (int C) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| Returns true if C is a 7-bit 'unsigned char' value that fits into |
| the US/UK ASCII character set. This function is a BSD extension |
| and is also an SVID extension. |
| |
| |
| File: libc.info, Node: Case Conversion, Next: Classification of Wide Characters, Prev: Classification of Characters, Up: Character Handling |
| |
| 4.2 Case Conversion |
| =================== |
| |
| This section explains the library functions for performing conversions |
| such as case mappings on characters. For example, 'toupper' converts |
| any character to upper case if possible. If the character can't be |
| converted, 'toupper' returns it unchanged. |
| |
| These functions take one argument of type 'int', which is the |
| character to convert, and return the converted character as an 'int'. |
| If the conversion is not applicable to the argument given, the argument |
| is returned unchanged. |
| |
| *Compatibility Note:* In pre-ISO C dialects, instead of returning the |
| argument unchanged, these functions may fail when the argument is not |
| suitable for the conversion. Thus for portability, you may need to |
| write 'islower(c) ? toupper(c) : c' rather than just 'toupper(c)'. |
| |
| These functions are declared in the header file 'ctype.h'. |
| |
| -- Function: int tolower (int C) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| If C is an upper-case letter, 'tolower' returns the corresponding |
| lower-case letter. If C is not an upper-case letter, C is returned |
| unchanged. |
| |
| -- Function: int toupper (int C) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| If C is a lower-case letter, 'toupper' returns the corresponding |
| upper-case letter. Otherwise C is returned unchanged. |
| |
| -- Function: int toascii (int C) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This function converts C to a 7-bit 'unsigned char' value that fits |
| into the US/UK ASCII character set, by clearing the high-order |
| bits. This function is a BSD extension and is also an SVID |
| extension. |
| |
| -- Function: int _tolower (int C) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This is identical to 'tolower', and is provided for compatibility |
| with the SVID. *Note SVID::. |
| |
| -- Function: int _toupper (int C) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This is identical to 'toupper', and is provided for compatibility |
| with the SVID. |
| |
| |
| File: libc.info, Node: Classification of Wide Characters, Next: Using Wide Char Classes, Prev: Case Conversion, Up: Character Handling |
| |
| 4.3 Character class determination for wide characters |
| ===================================================== |
| |
| Amendment 1 to ISO C90 defines functions to classify wide characters. |
| Although the original ISO C90 standard already defined the type |
| 'wchar_t', no functions operating on them were defined. |
| |
| The general design of the classification functions for wide |
| characters is more general. It allows extensions to the set of |
| available classifications, beyond those which are always available. The |
| POSIX standard specifies how extensions can be made, and this is already |
| implemented in the GNU C Library implementation of the 'localedef' |
| program. |
| |
| The character class functions are normally implemented with bitsets, |
| with a bitset per character. For a given character, the appropriate |
| bitset is read from a table and a test is performed as to whether a |
| certain bit is set. Which bit is tested for is determined by the class. |
| |
| For the wide character classification functions this is made visible. |
| There is a type classification type defined, a function to retrieve this |
| value for a given class, and a function to test whether a given |
| character is in this class, using the classification value. On top of |
| this the normal character classification functions as used for 'char' |
| objects can be defined. |
| |
| -- Data type: wctype_t |
| The 'wctype_t' can hold a value which represents a character class. |
| The only defined way to generate such a value is by using the |
| 'wctype' function. |
| |
| This type is defined in 'wctype.h'. |
| |
| -- Function: wctype_t wctype (const char *PROPERTY) |
| Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX |
| Safety Concepts::. |
| |
| The 'wctype' returns a value representing a class of wide |
| characters which is identified by the string PROPERTY. Beside some |
| standard properties each locale can define its own ones. In case |
| no property with the given name is known for the current locale |
| selected for the 'LC_CTYPE' category, the function returns zero. |
| |
| The properties known in every locale are: |
| |
| '"alnum"' '"alpha"' '"cntrl"' '"digit"' |
| '"graph"' '"lower"' '"print"' '"punct"' |
| '"space"' '"upper"' '"xdigit"' |
| |
| This function is declared in 'wctype.h'. |
| |
| To test the membership of a character to one of the non-standard |
| classes the ISO C standard defines a completely new function. |
| |
| -- Function: int iswctype (wint_t WC, wctype_t DESC) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This function returns a nonzero value if WC is in the character |
| class specified by DESC. DESC must previously be returned by a |
| successful call to 'wctype'. |
| |
| This function is declared in 'wctype.h'. |
| |
| To make it easier to use the commonly-used classification functions, |
| they are defined in the C library. There is no need to use 'wctype' if |
| the property string is one of the known character classes. In some |
| situations it is desirable to construct the property strings, and then |
| it is important that 'wctype' can also handle the standard classes. |
| |
| -- Function: int iswalnum (wint_t WC) |
| Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX |
| Safety Concepts::. |
| |
| This function returns a nonzero value if WC is an alphanumeric |
| character (a letter or number); in other words, if either |
| 'iswalpha' or 'iswdigit' is true of a character, then 'iswalnum' is |
| also true. |
| |
| This function can be implemented using |
| |
| iswctype (wc, wctype ("alnum")) |
| |
| It is declared in 'wctype.h'. |
| |
| -- Function: int iswalpha (wint_t WC) |
| Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX |
| Safety Concepts::. |
| |
| Returns true if WC is an alphabetic character (a letter). If |
| 'iswlower' or 'iswupper' is true of a character, then 'iswalpha' is |
| also true. |
| |
| In some locales, there may be additional characters for which |
| 'iswalpha' is true--letters which are neither upper case nor lower |
| case. But in the standard '"C"' locale, there are no such |
| additional characters. |
| |
| This function can be implemented using |
| |
| iswctype (wc, wctype ("alpha")) |
| |
| It is declared in 'wctype.h'. |
| |
| -- Function: int iswcntrl (wint_t WC) |
| Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX |
| Safety Concepts::. |
| |
| Returns true if WC is a control character (that is, a character |
| that is not a printing character). |
| |
| This function can be implemented using |
| |
| iswctype (wc, wctype ("cntrl")) |
| |
| It is declared in 'wctype.h'. |
| |
| -- Function: int iswdigit (wint_t WC) |
| Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX |
| Safety Concepts::. |
| |
| Returns true if WC is a digit (e.g., '0' through '9'). Please note |
| that this function does not only return a nonzero value for |
| _decimal_ digits, but for all kinds of digits. A consequence is |
| that code like the following will *not* work unconditionally for |
| wide characters: |
| |
| n = 0; |
| while (iswdigit (*wc)) |
| { |
| n *= 10; |
| n += *wc++ - L'0'; |
| } |
| |
| This function can be implemented using |
| |
| iswctype (wc, wctype ("digit")) |
| |
| It is declared in 'wctype.h'. |
| |
| -- Function: int iswgraph (wint_t WC) |
| Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX |
| Safety Concepts::. |
| |
| Returns true if WC is a graphic character; that is, a character |
| that has a glyph associated with it. The whitespace characters are |
| not considered graphic. |
| |
| This function can be implemented using |
| |
| iswctype (wc, wctype ("graph")) |
| |
| It is declared in 'wctype.h'. |
| |
| -- Function: int iswlower (wint_t WC) |
| Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX |
| Safety Concepts::. |
| |
| Returns true if WC is a lower-case letter. The letter need not be |
| from the Latin alphabet, any alphabet representable is valid. |
| |
| This function can be implemented using |
| |
| iswctype (wc, wctype ("lower")) |
| |
| It is declared in 'wctype.h'. |
| |
| -- Function: int iswprint (wint_t WC) |
| Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX |
| Safety Concepts::. |
| |
| Returns true if WC is a printing character. Printing characters |
| include all the graphic characters, plus the space (' ') character. |
| |
| This function can be implemented using |
| |
| iswctype (wc, wctype ("print")) |
| |
| It is declared in 'wctype.h'. |
| |
| -- Function: int iswpunct (wint_t WC) |
| Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX |
| Safety Concepts::. |
| |
| Returns true if WC is a punctuation character. This means any |
| printing character that is not alphanumeric or a space character. |
| |
| This function can be implemented using |
| |
| iswctype (wc, wctype ("punct")) |
| |
| It is declared in 'wctype.h'. |
| |
| -- Function: int iswspace (wint_t WC) |
| Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX |
| Safety Concepts::. |
| |
| Returns true if WC is a "whitespace" character. In the standard |
| '"C"' locale, 'iswspace' returns true for only the standard |
| whitespace characters: |
| |
| 'L' '' |
| space |
| |
| 'L'\f'' |
| formfeed |
| |
| 'L'\n'' |
| newline |
| |
| 'L'\r'' |
| carriage return |
| |
| 'L'\t'' |
| horizontal tab |
| |
| 'L'\v'' |
| vertical tab |
| |
| This function can be implemented using |
| |
| iswctype (wc, wctype ("space")) |
| |
| It is declared in 'wctype.h'. |
| |
| -- Function: int iswupper (wint_t WC) |
| Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX |
| Safety Concepts::. |
| |
| Returns true if WC is an upper-case letter. The letter need not be |
| from the Latin alphabet, any alphabet representable is valid. |
| |
| This function can be implemented using |
| |
| iswctype (wc, wctype ("upper")) |
| |
| It is declared in 'wctype.h'. |
| |
| -- Function: int iswxdigit (wint_t WC) |
| Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX |
| Safety Concepts::. |
| |
| Returns true if WC is a hexadecimal digit. Hexadecimal digits |
| include the normal decimal digits '0' through '9' and the letters |
| 'A' through 'F' and 'a' through 'f'. |
| |
| This function can be implemented using |
| |
| iswctype (wc, wctype ("xdigit")) |
| |
| It is declared in 'wctype.h'. |
| |
| The GNU C Library also provides a function which is not defined in |
| the ISO C standard but which is available as a version for single byte |
| characters as well. |
| |
| -- Function: int iswblank (wint_t WC) |
| Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX |
| Safety Concepts::. |
| |
| Returns true if WC is a blank character; that is, a space or a tab. |
| This function was originally a GNU extension, but was added in |
| ISO C99. It is declared in 'wchar.h'. |
| |
| |
| File: libc.info, Node: Using Wide Char Classes, Next: Wide Character Case Conversion, Prev: Classification of Wide Characters, Up: Character Handling |
| |
| 4.4 Notes on using the wide character classes |
| ============================================= |
| |
| The first note is probably not astonishing but still occasionally a |
| cause of problems. The 'iswXXX' functions can be implemented using |
| macros and in fact, the GNU C Library does this. They are still |
| available as real functions but when the 'wctype.h' header is included |
| the macros will be used. This is the same as the 'char' type versions |
| of these functions. |
| |
| The second note covers something new. It can be best illustrated by |
| a (real-world) example. The first piece of code is an excerpt from the |
| original code. It is truncated a bit but the intention should be clear. |
| |
| int |
| is_in_class (int c, const char *class) |
| { |
| if (strcmp (class, "alnum") == 0) |
| return isalnum (c); |
| if (strcmp (class, "alpha") == 0) |
| return isalpha (c); |
| if (strcmp (class, "cntrl") == 0) |
| return iscntrl (c); |
| ... |
| return 0; |
| } |
| |
| Now, with the 'wctype' and 'iswctype' you can avoid the 'if' |
| cascades, but rewriting the code as follows is wrong: |
| |
| int |
| is_in_class (int c, const char *class) |
| { |
| wctype_t desc = wctype (class); |
| return desc ? iswctype ((wint_t) c, desc) : 0; |
| } |
| |
| The problem is that it is not guaranteed that the wide character |
| representation of a single-byte character can be found using casting. |
| In fact, usually this fails miserably. The correct solution to this |
| problem is to write the code as follows: |
| |
| int |
| is_in_class (int c, const char *class) |
| { |
| wctype_t desc = wctype (class); |
| return desc ? iswctype (btowc (c), desc) : 0; |
| } |
| |
| *Note Converting a Character::, for more information on 'btowc'. |
| Note that this change probably does not improve the performance of the |
| program a lot since the 'wctype' function still has to make the string |
| comparisons. It gets really interesting if the 'is_in_class' function |
| is called more than once for the same class name. In this case the |
| variable DESC could be computed once and reused for all the calls. |
| Therefore the above form of the function is probably not the final one. |
| |
| |
| File: libc.info, Node: Wide Character Case Conversion, Prev: Using Wide Char Classes, Up: Character Handling |
| |
| 4.5 Mapping of wide characters. |
| =============================== |
| |
| The classification functions are also generalized by the ISO C standard. |
| Instead of just allowing the two standard mappings, a locale can contain |
| others. Again, the 'localedef' program already supports generating such |
| locale data files. |
| |
| -- Data Type: wctrans_t |
| This data type is defined as a scalar type which can hold a value |
| representing the locale-dependent character mapping. There is no |
| way to construct such a value apart from using the return value of |
| the 'wctrans' function. |
| |
| This type is defined in 'wctype.h'. |
| |
| -- Function: wctrans_t wctrans (const char *PROPERTY) |
| Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX |
| Safety Concepts::. |
| |
| The 'wctrans' function has to be used to find out whether a named |
| mapping is defined in the current locale selected for the |
| 'LC_CTYPE' category. If the returned value is non-zero, you can |
| use it afterwards in calls to 'towctrans'. If the return value is |
| zero no such mapping is known in the current locale. |
| |
| Beside locale-specific mappings there are two mappings which are |
| guaranteed to be available in every locale: |
| |
| '"tolower"' '"toupper"' |
| |
| These functions are declared in 'wctype.h'. |
| |
| -- Function: wint_t towctrans (wint_t WC, wctrans_t DESC) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| 'towctrans' maps the input character WC according to the rules of |
| the mapping for which DESC is a descriptor, and returns the value |
| it finds. DESC must be obtained by a successful call to 'wctrans'. |
| |
| This function is declared in 'wctype.h'. |
| |
| For the generally available mappings, the ISO C standard defines |
| convenient shortcuts so that it is not necessary to call 'wctrans' for |
| them. |
| |
| -- Function: wint_t towlower (wint_t WC) |
| Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX |
| Safety Concepts::. |
| |
| If WC is an upper-case letter, 'towlower' returns the corresponding |
| lower-case letter. If WC is not an upper-case letter, WC is |
| returned unchanged. |
| |
| 'towlower' can be implemented using |
| |
| towctrans (wc, wctrans ("tolower")) |
| |
| This function is declared in 'wctype.h'. |
| |
| -- Function: wint_t towupper (wint_t WC) |
| Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX |
| Safety Concepts::. |
| |
| If WC is a lower-case letter, 'towupper' returns the corresponding |
| upper-case letter. Otherwise WC is returned unchanged. |
| |
| 'towupper' can be implemented using |
| |
| towctrans (wc, wctrans ("toupper")) |
| |
| This function is declared in 'wctype.h'. |
| |
| The same warnings given in the last section for the use of the wide |
| character classification functions apply here. It is not possible to |
| simply cast a 'char' type value to a 'wint_t' and use it as an argument |
| to 'towctrans' calls. |
| |
| |
| File: libc.info, Node: String and Array Utilities, Next: Character Set Handling, Prev: Character Handling, Up: Top |
| |
| 5 String and Array Utilities |
| **************************** |
| |
| Operations on strings (or arrays of characters) are an important part of |
| many programs. The GNU C Library provides an extensive set of string |
| utility functions, including functions for copying, concatenating, |
| comparing, and searching strings. Many of these functions can also |
| operate on arbitrary regions of storage; for example, the 'memcpy' |
| function can be used to copy the contents of any kind of array. |
| |
| It's fairly common for beginning C programmers to "reinvent the |
| wheel" by duplicating this functionality in their own code, but it pays |
| to become familiar with the library functions and to make use of them, |
| since this offers benefits in maintenance, efficiency, and portability. |
| |
| For instance, you could easily compare one string to another in two |
| lines of C code, but if you use the built-in 'strcmp' function, you're |
| less likely to make a mistake. And, since these library functions are |
| typically highly optimized, your program may run faster too. |
| |
| * Menu: |
| |
| * Representation of Strings:: Introduction to basic concepts. |
| * String/Array Conventions:: Whether to use a string function or an |
| arbitrary array function. |
| * String Length:: Determining the length of a string. |
| * Copying and Concatenation:: Functions to copy the contents of strings |
| and arrays. |
| * String/Array Comparison:: Functions for byte-wise and character-wise |
| comparison. |
| * Collation Functions:: Functions for collating strings. |
| * Search Functions:: Searching for a specific element or substring. |
| * Finding Tokens in a String:: Splitting a string into tokens by looking |
| for delimiters. |
| * strfry:: Function for flash-cooking a string. |
| * Trivial Encryption:: Obscuring data. |
| * Encode Binary Data:: Encoding and Decoding of Binary Data. |
| * Argz and Envz Vectors:: Null-separated string vectors. |
| |
| |
| File: libc.info, Node: Representation of Strings, Next: String/Array Conventions, Up: String and Array Utilities |
| |
| 5.1 Representation of Strings |
| ============================= |
| |
| This section is a quick summary of string concepts for beginning C |
| programmers. It describes how character strings are represented in C |
| and some common pitfalls. If you are already familiar with this |
| material, you can skip this section. |
| |
| A "string" is an array of 'char' objects. But string-valued |
| variables are usually declared to be pointers of type 'char *'. Such |
| variables do not include space for the text of a string; that has to be |
| stored somewhere else--in an array variable, a string constant, or |
| dynamically allocated memory (*note Memory Allocation::). It's up to |
| you to store the address of the chosen memory space into the pointer |
| variable. Alternatively you can store a "null pointer" in the pointer |
| variable. The null pointer does not point anywhere, so attempting to |
| reference the string it points to gets an error. |
| |
| "string" normally refers to multibyte character strings as opposed to |
| wide character strings. Wide character strings are arrays of type |
| 'wchar_t' and as for multibyte character strings usually pointers of |
| type 'wchar_t *' are used. |
| |
| By convention, a "null character", ''\0'', marks the end of a |
| multibyte character string and the "null wide character", 'L'\0'', marks |
| the end of a wide character string. For example, in testing to see |
| whether the 'char *' variable P points to a null character marking the |
| end of a string, you can write '!*P' or '*P == '\0''. |
| |
| A null character is quite different conceptually from a null pointer, |
| although both are represented by the integer '0'. |
| |
| "String literals" appear in C program source as strings of characters |
| between double-quote characters ('"') where the initial double-quote |
| character is immediately preceded by a capital 'L' (ell) character (as |
| in 'L"foo"'). In ISO C, string literals can also be formed by "string |
| concatenation": '"a" "b"' is the same as '"ab"'. For wide character |
| strings one can either use 'L"a" L"b"' or 'L"a" "b"'. Modification of |
| string literals is not allowed by the GNU C compiler, because literals |
| are placed in read-only storage. |
| |
| Character arrays that are declared 'const' cannot be modified either. |
| It's generally good style to declare non-modifiable string pointers to |
| be of type 'const char *', since this often allows the C compiler to |
| detect accidental modifications as well as providing some amount of |
| documentation about what your program intends to do with the string. |
| |
| The amount of memory allocated for the character array may extend |
| past the null character that normally marks the end of the string. In |
| this document, the term "allocated size" is always used to refer to the |
| total amount of memory allocated for the string, while the term "length" |
| refers to the number of characters up to (but not including) the |
| terminating null character. |
| |
| A notorious source of program bugs is trying to put more characters |
| in a string than fit in its allocated size. When writing code that |
| extends strings or moves characters into a pre-allocated array, you |
| should be very careful to keep track of the length of the text and make |
| explicit checks for overflowing the array. Many of the library |
| functions _do not_ do this for you! Remember also that you need to |
| allocate an extra byte to hold the null character that marks the end of |
| the string. |
| |
| Originally strings were sequences of bytes where each byte represents |
| a single character. This is still true today if the strings are encoded |
| using a single-byte character encoding. Things are different if the |
| strings are encoded using a multibyte encoding (for more information on |
| encodings see *note Extended Char Intro::). There is no difference in |
| the programming interface for these two kind of strings; the programmer |
| has to be aware of this and interpret the byte sequences accordingly. |
| |
| But since there is no separate interface taking care of these |
| differences the byte-based string functions are sometimes hard to use. |
| Since the count parameters of these functions specify bytes a call to |
| 'strncpy' could cut a multibyte character in the middle and put an |
| incomplete (and therefore unusable) byte sequence in the target buffer. |
| |
| To avoid these problems later versions of the ISO C standard |
| introduce a second set of functions which are operating on "wide |
| characters" (*note Extended Char Intro::). These functions don't have |
| the problems the single-byte versions have since every wide character is |
| a legal, interpretable value. This does not mean that cutting wide |
| character strings at arbitrary points is without problems. It normally |
| is for alphabet-based languages (except for non-normalized text) but |
| languages based on syllables still have the problem that more than one |
| wide character is necessary to complete a logical unit. This is a |
| higher level problem which the C library functions are not designed to |
| solve. But it is at least good that no invalid byte sequences can be |
| created. Also, the higher level functions can also much easier operate |
| on wide character than on multibyte characters so that a general advise |
| is to use wide characters internally whenever text is more than simply |
| copied. |
| |
| The remaining of this chapter will discuss the functions for handling |
| wide character strings in parallel with the discussion of the multibyte |
| character strings since there is almost always an exact equivalent |
| available. |
| |
| |
| File: libc.info, Node: String/Array Conventions, Next: String Length, Prev: Representation of Strings, Up: String and Array Utilities |
| |
| 5.2 String and Array Conventions |
| ================================ |
| |
| This chapter describes both functions that work on arbitrary arrays or |
| blocks of memory, and functions that are specific to null-terminated |
| arrays of characters and wide characters. |
| |
| Functions that operate on arbitrary blocks of memory have names |
| beginning with 'mem' and 'wmem' (such as 'memcpy' and 'wmemcpy') and |
| invariably take an argument which specifies the size (in bytes and wide |
| characters respectively) of the block of memory to operate on. The |
| array arguments and return values for these functions have type 'void *' |
| or 'wchar_t'. As a matter of style, the elements of the arrays used |
| with the 'mem' functions are referred to as "bytes". You can pass any |
| kind of pointer to these functions, and the 'sizeof' operator is useful |
| in computing the value for the size argument. Parameters to the 'wmem' |
| functions must be of type 'wchar_t *'. These functions are not really |
| usable with anything but arrays of this type. |
| |
| In contrast, functions that operate specifically on strings and wide |
| character strings have names beginning with 'str' and 'wcs' respectively |
| (such as 'strcpy' and 'wcscpy') and look for a null character to |
| terminate the string instead of requiring an explicit size argument to |
| be passed. (Some of these functions accept a specified maximum length, |
| but they also check for premature termination with a null character.) |
| The array arguments and return values for these functions have type |
| 'char *' and 'wchar_t *' respectively, and the array elements are |
| referred to as "characters" and "wide characters". |
| |
| In many cases, there are both 'mem' and 'str'/'wcs' versions of a |
| function. The one that is more appropriate to use depends on the exact |
| situation. When your program is manipulating arbitrary arrays or blocks |
| of storage, then you should always use the 'mem' functions. On the |
| other hand, when you are manipulating null-terminated strings it is |
| usually more convenient to use the 'str'/'wcs' functions, unless you |
| already know the length of the string in advance. The 'wmem' functions |
| should be used for wide character arrays with known size. |
| |
| Some of the memory and string functions take single characters as |
| arguments. Since a value of type 'char' is automatically promoted into |
| a value of type 'int' when used as a parameter, the functions are |
| declared with 'int' as the type of the parameter in question. In case |
| of the wide character function the situation is similarly: the parameter |
| type for a single wide character is 'wint_t' and not 'wchar_t'. This |
| would for many implementations not be necessary since the 'wchar_t' is |
| large enough to not be automatically promoted, but since the ISO C |
| standard does not require such a choice of types the 'wint_t' type is |
| used. |
| |
| |
| File: libc.info, Node: String Length, Next: Copying and Concatenation, Prev: String/Array Conventions, Up: String and Array Utilities |
| |
| 5.3 String Length |
| ================= |
| |
| You can get the length of a string using the 'strlen' function. This |
| function is declared in the header file 'string.h'. |
| |
| -- Function: size_t strlen (const char *S) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| The 'strlen' function returns the length of the null-terminated |
| string S in bytes. (In other words, it returns the offset of the |
| terminating null character within the array.) |
| |
| For example, |
| strlen ("hello, world") |
| => 12 |
| |
| When applied to a character array, the 'strlen' function returns |
| the length of the string stored there, not its allocated size. You |
| can get the allocated size of the character array that holds a |
| string using the 'sizeof' operator: |
| |
| char string[32] = "hello, world"; |
| sizeof (string) |
| => 32 |
| strlen (string) |
| => 12 |
| |
| But beware, this will not work unless STRING is the character array |
| itself, not a pointer to it. For example: |
| |
| char string[32] = "hello, world"; |
| char *ptr = string; |
| sizeof (string) |
| => 32 |
| sizeof (ptr) |
| => 4 /* (on a machine with 4 byte pointers) */ |
| |
| This is an easy mistake to make when you are working with functions |
| that take string arguments; those arguments are always pointers, |
| not arrays. |
| |
| It must also be noted that for multibyte encoded strings the return |
| value does not have to correspond to the number of characters in |
| the string. To get this value the string can be converted to wide |
| characters and 'wcslen' can be used or something like the following |
| code can be used: |
| |
| /* The input is in 'string'. |
| The length is expected in 'n'. */ |
| { |
| mbstate_t t; |
| char *scopy = string; |
| /* In initial state. */ |
| memset (&t, '\0', sizeof (t)); |
| /* Determine number of characters. */ |
| n = mbsrtowcs (NULL, &scopy, strlen (scopy), &t); |
| } |
| |
| This is cumbersome to do so if the number of characters (as opposed |
| to bytes) is needed often it is better to work with wide |
| characters. |
| |
| The wide character equivalent is declared in 'wchar.h'. |
| |
| -- Function: size_t wcslen (const wchar_t *WS) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| The 'wcslen' function is the wide character equivalent to 'strlen'. |
| The return value is the number of wide characters in the wide |
| character string pointed to by WS (this is also the offset of the |
| terminating null wide character of WS). |
| |
| Since there are no multi wide character sequences making up one |
| character the return value is not only the offset in the array, it |
| is also the number of wide characters. |
| |
| This function was introduced in Amendment 1 to ISO C90. |
| |
| -- Function: size_t strnlen (const char *S, size_t MAXLEN) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| The 'strnlen' function returns the length of the string S in bytes |
| if this length is smaller than MAXLEN bytes. Otherwise it returns |
| MAXLEN. Therefore this function is equivalent to '(strlen (S) < |
| MAXLEN ? strlen (S) : MAXLEN)' but it is more efficient and works |
| even if the string S is not null-terminated. |
| |
| char string[32] = "hello, world"; |
| strnlen (string, 32) |
| => 12 |
| strnlen (string, 5) |
| => 5 |
| |
| This function is a GNU extension and is declared in 'string.h'. |
| |
| -- Function: size_t wcsnlen (const wchar_t *WS, size_t MAXLEN) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| 'wcsnlen' is the wide character equivalent to 'strnlen'. The |
| MAXLEN parameter specifies the maximum number of wide characters. |
| |
| This function is a GNU extension and is declared in 'wchar.h'. |
| |
| |
| File: libc.info, Node: Copying and Concatenation, Next: String/Array Comparison, Prev: String Length, Up: String and Array Utilities |
| |
| 5.4 Copying and Concatenation |
| ============================= |
| |
| You can use the functions described in this section to copy the contents |
| of strings and arrays, or to append the contents of one string to |
| another. The 'str' and 'mem' functions are declared in the header file |
| 'string.h' while the 'wstr' and 'wmem' functions are declared in the |
| file 'wchar.h'. |
| |
| A helpful way to remember the ordering of the arguments to the |
| functions in this section is that it corresponds to an assignment |
| expression, with the destination array specified to the left of the |
| source array. All of these functions return the address of the |
| destination array. |
| |
| Most of these functions do not work properly if the source and |
| destination arrays overlap. For example, if the beginning of the |
| destination array overlaps the end of the source array, the original |
| contents of that part of the source array may get overwritten before it |
| is copied. Even worse, in the case of the string functions, the null |
| character marking the end of the string may be lost, and the copy |
| function might get stuck in a loop trashing all the memory allocated to |
| your program. |
| |
| All functions that have problems copying between overlapping arrays |
| are explicitly identified in this manual. In addition to functions in |
| this section, there are a few others like 'sprintf' (*note Formatted |
| Output Functions::) and 'scanf' (*note Formatted Input Functions::). |
| |
| -- Function: void * memcpy (void *restrict TO, const void *restrict |
| FROM, size_t SIZE) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| The 'memcpy' function copies SIZE bytes from the object beginning |
| at FROM into the object beginning at TO. The behavior of this |
| function is undefined if the two arrays TO and FROM overlap; use |
| 'memmove' instead if overlapping is possible. |
| |
| The value returned by 'memcpy' is the value of TO. |
| |
| Here is an example of how you might use 'memcpy' to copy the |
| contents of an array: |
| |
| struct foo *oldarray, *newarray; |
| int arraysize; |
| ... |
| memcpy (new, old, arraysize * sizeof (struct foo)); |
| |
| -- Function: wchar_t * wmemcpy (wchar_t *restrict WTO, const wchar_t |
| *restrict WFROM, size_t SIZE) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| The 'wmemcpy' function copies SIZE wide characters from the object |
| beginning at WFROM into the object beginning at WTO. The behavior |
| of this function is undefined if the two arrays WTO and WFROM |
| overlap; use 'wmemmove' instead if overlapping is possible. |
| |
| The following is a possible implementation of 'wmemcpy' but there |
| are more optimizations possible. |
| |
| wchar_t * |
| wmemcpy (wchar_t *restrict wto, const wchar_t *restrict wfrom, |
| size_t size) |
| { |
| return (wchar_t *) memcpy (wto, wfrom, size * sizeof (wchar_t)); |
| } |
| |
| The value returned by 'wmemcpy' is the value of WTO. |
| |
| This function was introduced in Amendment 1 to ISO C90. |
| |
| -- Function: void * mempcpy (void *restrict TO, const void *restrict |
| FROM, size_t SIZE) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| The 'mempcpy' function is nearly identical to the 'memcpy' |
| function. It copies SIZE bytes from the object beginning at 'from' |
| into the object pointed to by TO. But instead of returning the |
| value of TO it returns a pointer to the byte following the last |
| written byte in the object beginning at TO. I.e., the value is |
| '((void *) ((char *) TO + SIZE))'. |
| |
| This function is useful in situations where a number of objects |
| shall be copied to consecutive memory positions. |
| |
| void * |
| combine (void *o1, size_t s1, void *o2, size_t s2) |
| { |
| void *result = malloc (s1 + s2); |
| if (result != NULL) |
| mempcpy (mempcpy (result, o1, s1), o2, s2); |
| return result; |
| } |
| |
| This function is a GNU extension. |
| |
| -- Function: wchar_t * wmempcpy (wchar_t *restrict WTO, const wchar_t |
| *restrict WFROM, size_t SIZE) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| The 'wmempcpy' function is nearly identical to the 'wmemcpy' |
| function. It copies SIZE wide characters from the object beginning |
| at 'wfrom' into the object pointed to by WTO. But instead of |
| returning the value of WTO it returns a pointer to the wide |
| character following the last written wide character in the object |
| beginning at WTO. I.e., the value is 'WTO + SIZE'. |
| |
| This function is useful in situations where a number of objects |
| shall be copied to consecutive memory positions. |
| |
| The following is a possible implementation of 'wmemcpy' but there |
| are more optimizations possible. |
| |
| wchar_t * |
| wmempcpy (wchar_t *restrict wto, const wchar_t *restrict wfrom, |
| size_t size) |
| { |
| return (wchar_t *) mempcpy (wto, wfrom, size * sizeof (wchar_t)); |
| } |
| |
| This function is a GNU extension. |
| |
| -- Function: void * memmove (void *TO, const void *FROM, size_t SIZE) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| 'memmove' copies the SIZE bytes at FROM into the SIZE bytes at TO, |
| even if those two blocks of space overlap. In the case of overlap, |
| 'memmove' is careful to copy the original values of the bytes in |
| the block at FROM, including those bytes which also belong to the |
| block at TO. |
| |
| The value returned by 'memmove' is the value of TO. |
| |
| -- Function: wchar_t * wmemmove (wchar_t *WTO, const wchar_t *WFROM, |
| size_t SIZE) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| 'wmemmove' copies the SIZE wide characters at WFROM into the SIZE |
| wide characters at WTO, even if those two blocks of space overlap. |
| In the case of overlap, 'memmove' is careful to copy the original |
| values of the wide characters in the block at WFROM, including |
| those wide characters which also belong to the block at WTO. |
| |
| The following is a possible implementation of 'wmemcpy' but there |
| are more optimizations possible. |
| |
| wchar_t * |
| wmempcpy (wchar_t *restrict wto, const wchar_t *restrict wfrom, |
| size_t size) |
| { |
| return (wchar_t *) mempcpy (wto, wfrom, size * sizeof (wchar_t)); |
| } |
| |
| The value returned by 'wmemmove' is the value of WTO. |
| |
| This function is a GNU extension. |
| |
| -- Function: void * memccpy (void *restrict TO, const void *restrict |
| FROM, int C, size_t SIZE) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This function copies no more than SIZE bytes from FROM to TO, |
| stopping if a byte matching C is found. The return value is a |
| pointer into TO one byte past where C was copied, or a null pointer |
| if no byte matching C appeared in the first SIZE bytes of FROM. |
| |
| -- Function: void * memset (void *BLOCK, int C, size_t SIZE) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This function copies the value of C (converted to an 'unsigned |
| char') into each of the first SIZE bytes of the object beginning at |
| BLOCK. It returns the value of BLOCK. |
| |
| -- Function: wchar_t * wmemset (wchar_t *BLOCK, wchar_t WC, size_t |
| SIZE) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This function copies the value of WC into each of the first SIZE |
| wide characters of the object beginning at BLOCK. It returns the |
| value of BLOCK. |
| |
| -- Function: char * strcpy (char *restrict TO, const char *restrict |
| FROM) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This copies characters from the string FROM (up to and including |
| the terminating null character) into the string TO. Like 'memcpy', |
| this function has undefined results if the strings overlap. The |
| return value is the value of TO. |
| |
| -- Function: wchar_t * wcscpy (wchar_t *restrict WTO, const wchar_t |
| *restrict WFROM) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This copies wide characters from the string WFROM (up to and |
| including the terminating null wide character) into the string WTO. |
| Like 'wmemcpy', this function has undefined results if the strings |
| overlap. The return value is the value of WTO. |
| |
| -- Function: char * strncpy (char *restrict TO, const char *restrict |
| FROM, size_t SIZE) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This function is similar to 'strcpy' but always copies exactly SIZE |
| characters into TO. |
| |
| If the length of FROM is more than SIZE, then 'strncpy' copies just |
| the first SIZE characters. Note that in this case there is no null |
| terminator written into TO. |
| |
| If the length of FROM is less than SIZE, then 'strncpy' copies all |
| of FROM, followed by enough null characters to add up to SIZE |
| characters in all. This behavior is rarely useful, but it is |
| specified by the ISO C standard. |
| |
| The behavior of 'strncpy' is undefined if the strings overlap. |
| |
| Using 'strncpy' as opposed to 'strcpy' is a way to avoid bugs |
| relating to writing past the end of the allocated space for TO. |
| However, it can also make your program much slower in one common |
| case: copying a string which is probably small into a potentially |
| large buffer. In this case, SIZE may be large, and when it is, |
| 'strncpy' will waste a considerable amount of time copying null |
| characters. |
| |
| -- Function: wchar_t * wcsncpy (wchar_t *restrict WTO, const wchar_t |
| *restrict WFROM, size_t SIZE) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This function is similar to 'wcscpy' but always copies exactly SIZE |
| wide characters into WTO. |
| |
| If the length of WFROM is more than SIZE, then 'wcsncpy' copies |
| just the first SIZE wide characters. Note that in this case there |
| is no null terminator written into WTO. |
| |
| If the length of WFROM is less than SIZE, then 'wcsncpy' copies all |
| of WFROM, followed by enough null wide characters to add up to SIZE |
| wide characters in all. This behavior is rarely useful, but it is |
| specified by the ISO C standard. |
| |
| The behavior of 'wcsncpy' is undefined if the strings overlap. |
| |
| Using 'wcsncpy' as opposed to 'wcscpy' is a way to avoid bugs |
| relating to writing past the end of the allocated space for WTO. |
| However, it can also make your program much slower in one common |
| case: copying a string which is probably small into a potentially |
| large buffer. In this case, SIZE may be large, and when it is, |
| 'wcsncpy' will waste a considerable amount of time copying null |
| wide characters. |
| |
| -- Function: char * strdup (const char *S) |
| Preliminary: | MT-Safe | AS-Unsafe heap | AC-Unsafe mem | *Note |
| POSIX Safety Concepts::. |
| |
| This function copies the null-terminated string S into a newly |
| allocated string. The string is allocated using 'malloc'; see |
| *note Unconstrained Allocation::. If 'malloc' cannot allocate |
| space for the new string, 'strdup' returns a null pointer. |
| Otherwise it returns a pointer to the new string. |
| |
| -- Function: wchar_t * wcsdup (const wchar_t *WS) |
| Preliminary: | MT-Safe | AS-Unsafe heap | AC-Unsafe mem | *Note |
| POSIX Safety Concepts::. |
| |
| This function copies the null-terminated wide character string WS |
| into a newly allocated string. The string is allocated using |
| 'malloc'; see *note Unconstrained Allocation::. If 'malloc' cannot |
| allocate space for the new string, 'wcsdup' returns a null pointer. |
| Otherwise it returns a pointer to the new wide character string. |
| |
| This function is a GNU extension. |
| |
| -- Function: char * strndup (const char *S, size_t SIZE) |
| Preliminary: | MT-Safe | AS-Unsafe heap | AC-Unsafe mem | *Note |
| POSIX Safety Concepts::. |
| |
| This function is similar to 'strdup' but always copies at most SIZE |
| characters into the newly allocated string. |
| |
| If the length of S is more than SIZE, then 'strndup' copies just |
| the first SIZE characters and adds a closing null terminator. |
| Otherwise all characters are copied and the string is terminated. |
| |
| This function is different to 'strncpy' in that it always |
| terminates the destination string. |
| |
| 'strndup' is a GNU extension. |
| |
| -- Function: char * stpcpy (char *restrict TO, const char *restrict |
| FROM) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This function is like 'strcpy', except that it returns a pointer to |
| the end of the string TO (that is, the address of the terminating |
| null character 'to + strlen (from)') rather than the beginning. |
| |
| For example, this program uses 'stpcpy' to concatenate 'foo' and |
| 'bar' to produce 'foobar', which it then prints. |
| |
| |
| #include <string.h> |
| #include <stdio.h> |
| |
| int |
| main (void) |
| { |
| char buffer[10]; |
| char *to = buffer; |
| to = stpcpy (to, "foo"); |
| to = stpcpy (to, "bar"); |
| puts (buffer); |
| return 0; |
| } |
| |
| This function is not part of the ISO or POSIX standards, and is not |
| customary on Unix systems, but we did not invent it either. |
| Perhaps it comes from MS-DOG. |
| |
| Its behavior is undefined if the strings overlap. The function is |
| declared in 'string.h'. |
| |
| -- Function: wchar_t * wcpcpy (wchar_t *restrict WTO, const wchar_t |
| *restrict WFROM) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This function is like 'wcscpy', except that it returns a pointer to |
| the end of the string WTO (that is, the address of the terminating |
| null character 'wto + strlen (wfrom)') rather than the beginning. |
| |
| This function is not part of ISO or POSIX but was found useful |
| while developing the GNU C Library itself. |
| |
| The behavior of 'wcpcpy' is undefined if the strings overlap. |
| |
| 'wcpcpy' is a GNU extension and is declared in 'wchar.h'. |
| |
| -- Function: char * stpncpy (char *restrict TO, const char *restrict |
| FROM, size_t SIZE) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This function is similar to 'stpcpy' but copies always exactly SIZE |
| characters into TO. |
| |
| If the length of FROM is more than SIZE, then 'stpncpy' copies just |
| the first SIZE characters and returns a pointer to the character |
| directly following the one which was copied last. Note that in |
| this case there is no null terminator written into TO. |
| |
| If the length of FROM is less than SIZE, then 'stpncpy' copies all |
| of FROM, followed by enough null characters to add up to SIZE |
| characters in all. This behavior is rarely useful, but it is |
| implemented to be useful in contexts where this behavior of the |
| 'strncpy' is used. 'stpncpy' returns a pointer to the _first_ |
| written null character. |
| |
| This function is not part of ISO or POSIX but was found useful |
| while developing the GNU C Library itself. |
| |
| Its behavior is undefined if the strings overlap. The function is |
| declared in 'string.h'. |
| |
| -- Function: wchar_t * wcpncpy (wchar_t *restrict WTO, const wchar_t |
| *restrict WFROM, size_t SIZE) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This function is similar to 'wcpcpy' but copies always exactly |
| WSIZE characters into WTO. |
| |
| If the length of WFROM is more than SIZE, then 'wcpncpy' copies |
| just the first SIZE wide characters and returns a pointer to the |
| wide character directly following the last non-null wide character |
| which was copied last. Note that in this case there is no null |
| terminator written into WTO. |
| |
| If the length of WFROM is less than SIZE, then 'wcpncpy' copies all |
| of WFROM, followed by enough null characters to add up to SIZE |
| characters in all. This behavior is rarely useful, but it is |
| implemented to be useful in contexts where this behavior of the |
| 'wcsncpy' is used. 'wcpncpy' returns a pointer to the _first_ |
| written null character. |
| |
| This function is not part of ISO or POSIX but was found useful |
| while developing the GNU C Library itself. |
| |
| Its behavior is undefined if the strings overlap. |
| |
| 'wcpncpy' is a GNU extension and is declared in 'wchar.h'. |
| |
| -- Macro: char * strdupa (const char *S) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This macro is similar to 'strdup' but allocates the new string |
| using 'alloca' instead of 'malloc' (*note Variable Size |
| Automatic::). This means of course the returned string has the |
| same limitations as any block of memory allocated using 'alloca'. |
| |
| For obvious reasons 'strdupa' is implemented only as a macro; you |
| cannot get the address of this function. Despite this limitation |
| it is a useful function. The following code shows a situation |
| where using 'malloc' would be a lot more expensive. |
| |
| |
| #include <paths.h> |
| #include <string.h> |
| #include <stdio.h> |
| |
| const char path[] = _PATH_STDPATH; |
| |
| int |
| main (void) |
| { |
| char *wr_path = strdupa (path); |
| char *cp = strtok (wr_path, ":"); |
| |
| while (cp != NULL) |
| { |
| puts (cp); |
| cp = strtok (NULL, ":"); |
| } |
| return 0; |
| } |
| |
| Please note that calling 'strtok' using PATH directly is invalid. |
| It is also not allowed to call 'strdupa' in the argument list of |
| 'strtok' since 'strdupa' uses 'alloca' (*note Variable Size |
| Automatic::) can interfere with the parameter passing. |
| |
| This function is only available if GNU CC is used. |
| |
| -- Macro: char * strndupa (const char *S, size_t SIZE) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This function is similar to 'strndup' but like 'strdupa' it |
| allocates the new string using 'alloca' *note Variable Size |
| Automatic::. The same advantages and limitations of 'strdupa' are |
| valid for 'strndupa', too. |
| |
| This function is implemented only as a macro, just like 'strdupa'. |
| Just as 'strdupa' this macro also must not be used inside the |
| parameter list in a function call. |
| |
| 'strndupa' is only available if GNU CC is used. |
| |
| -- Function: char * strcat (char *restrict TO, const char *restrict |
| FROM) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| The 'strcat' function is similar to 'strcpy', except that the |
| characters from FROM are concatenated or appended to the end of TO, |
| instead of overwriting it. That is, the first character from FROM |
| overwrites the null character marking the end of TO. |
| |
| An equivalent definition for 'strcat' would be: |
| |
| char * |
| strcat (char *restrict to, const char *restrict from) |
| { |
| strcpy (to + strlen (to), from); |
| return to; |
| } |
| |
| This function has undefined results if the strings overlap. |
| |
| -- Function: wchar_t * wcscat (wchar_t *restrict WTO, const wchar_t |
| *restrict WFROM) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| The 'wcscat' function is similar to 'wcscpy', except that the |
| characters from WFROM are concatenated or appended to the end of |
| WTO, instead of overwriting it. That is, the first character from |
| WFROM overwrites the null character marking the end of WTO. |
| |
| An equivalent definition for 'wcscat' would be: |
| |
| wchar_t * |
| wcscat (wchar_t *wto, const wchar_t *wfrom) |
| { |
| wcscpy (wto + wcslen (wto), wfrom); |
| return wto; |
| } |
| |
| This function has undefined results if the strings overlap. |
| |
| Programmers using the 'strcat' or 'wcscat' function (or the following |
| 'strncat' or 'wcsncar' functions for that matter) can easily be |
| recognized as lazy and reckless. In almost all situations the lengths |
| of the participating strings are known (it better should be since how |
| can one otherwise ensure the allocated size of the buffer is |
| sufficient?) Or at least, one could know them if one keeps track of the |
| results of the various function calls. But then it is very inefficient |
| to use 'strcat'/'wcscat'. A lot of time is wasted finding the end of |
| the destination string so that the actual copying can start. This is a |
| common example: |
| |
| /* This function concatenates arbitrarily many strings. The last |
| parameter must be 'NULL'. */ |
| char * |
| concat (const char *str, ...) |
| { |
| va_list ap, ap2; |
| size_t total = 1; |
| const char *s; |
| char *result; |
| |
| va_start (ap, str); |
| va_copy (ap2, ap); |
| |
| /* Determine how much space we need. */ |
| for (s = str; s != NULL; s = va_arg (ap, const char *)) |
| total += strlen (s); |
| |
| va_end (ap); |
| |
| result = (char *) malloc (total); |
| if (result != NULL) |
| { |
| result[0] = '\0'; |
| |
| /* Copy the strings. */ |
| for (s = str; s != NULL; s = va_arg (ap2, const char *)) |
| strcat (result, s); |
| } |
