| This is libc.info, produced by makeinfo version 4.13 from libc.texinfo. |
| |
| INFO-DIR-SECTION Software libraries |
| START-INFO-DIR-ENTRY |
| * Libc: (libc). C library. |
| END-INFO-DIR-ENTRY |
| |
| INFO-DIR-SECTION GNU C library functions and macros |
| START-INFO-DIR-ENTRY |
| * ALTWERASE: (libc)Local Modes. |
| * ARGP_ERR_UNKNOWN: (libc)Argp Parser Functions. |
| * ARG_MAX: (libc)General Limits. |
| * BC_BASE_MAX: (libc)Utility Limits. |
| * BC_DIM_MAX: (libc)Utility Limits. |
| * BC_SCALE_MAX: (libc)Utility Limits. |
| * BC_STRING_MAX: (libc)Utility Limits. |
| * BRKINT: (libc)Input Modes. |
| * BUFSIZ: (libc)Controlling Buffering. |
| * CCTS_OFLOW: (libc)Control Modes. |
| * CHILD_MAX: (libc)General Limits. |
| * CIGNORE: (libc)Control Modes. |
| * CLK_TCK: (libc)CPU 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. |
| * 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. |
| * __va_copy: (libc)Argument Macros. |
| * _exit: (libc)Termination Internals. |
| * _flushlbf: (libc)Flushing Buffers. |
| * _tolower: (libc)Case Conversion. |
| * _toupper: (libc)Case Conversion. |
| * a64l: (libc)Encode Binary Data. |
| * abort: (libc)Aborting a Program. |
| * abs: (libc)Absolute Value. |
| * accept: (libc)Accepting Connections. |
| * access: (libc)Testing File Access. |
| * acos: (libc)Inverse Trig Functions. |
| * acosf: (libc)Inverse Trig Functions. |
| * acosh: (libc)Hyperbolic Functions. |
| * acoshf: (libc)Hyperbolic Functions. |
| * acoshl: (libc)Hyperbolic Functions. |
| * acosl: (libc)Inverse Trig Functions. |
| * addmntent: (libc)mtab. |
| * addseverity: (libc)Adding Severity Classes. |
| * adjtime: (libc)High-Resolution Calendar. |
| * adjtimex: (libc)High-Resolution Calendar. |
| * aio_cancel64: (libc)Cancel AIO Operations. |
| * aio_cancel: (libc)Cancel AIO Operations. |
| * aio_error64: (libc)Status of AIO Operations. |
| * aio_error: (libc)Status of AIO Operations. |
| * aio_fsync64: (libc)Synchronizing AIO Operations. |
| * aio_fsync: (libc)Synchronizing AIO Operations. |
| * aio_init: (libc)Configuration of AIO. |
| * aio_read64: (libc)Asynchronous Reads/Writes. |
| * aio_read: (libc)Asynchronous Reads/Writes. |
| * aio_return64: (libc)Status of AIO Operations. |
| * aio_return: (libc)Status of AIO Operations. |
| * aio_suspend64: (libc)Synchronizing AIO Operations. |
| * aio_suspend: (libc)Synchronizing AIO Operations. |
| * aio_write64: (libc)Asynchronous Reads/Writes. |
| * aio_write: (libc)Asynchronous Reads/Writes. |
| * alarm: (libc)Setting an Alarm. |
| * alloca: (libc)Variable Size Automatic. |
| * alphasort64: (libc)Scanning Directory Content. |
| * alphasort: (libc)Scanning Directory Content. |
| * argp_error: (libc)Argp Helper Functions. |
| * argp_failure: (libc)Argp Helper Functions. |
| * argp_help: (libc)Argp Help. |
| * argp_parse: (libc)Argp. |
| * argp_state_help: (libc)Argp Helper Functions. |
| * argp_usage: (libc)Argp Helper Functions. |
| * argz_add: (libc)Argz Functions. |
| * argz_add_sep: (libc)Argz Functions. |
| * argz_append: (libc)Argz Functions. |
| * argz_count: (libc)Argz Functions. |
| * argz_create: (libc)Argz Functions. |
| * argz_create_sep: (libc)Argz Functions. |
| * argz_delete: (libc)Argz Functions. |
| * argz_extract: (libc)Argz Functions. |
| * argz_insert: (libc)Argz Functions. |
| * argz_next: (libc)Argz Functions. |
| * argz_replace: (libc)Argz Functions. |
| * argz_stringify: (libc)Argz Functions. |
| * asctime: (libc)Formatting Calendar Time. |
| * asctime_r: (libc)Formatting Calendar Time. |
| * asin: (libc)Inverse Trig Functions. |
| * asinf: (libc)Inverse Trig Functions. |
| * asinh: (libc)Hyperbolic Functions. |
| * asinhf: (libc)Hyperbolic Functions. |
| * asinhl: (libc)Hyperbolic Functions. |
| * asinl: (libc)Inverse Trig Functions. |
| * asprintf: (libc)Dynamic Output. |
| * assert: (libc)Consistency Checking. |
| * assert_perror: (libc)Consistency Checking. |
| * atan2: (libc)Inverse Trig Functions. |
| * atan2f: (libc)Inverse Trig Functions. |
| * atan2l: (libc)Inverse Trig Functions. |
| * atan: (libc)Inverse Trig Functions. |
| * atanf: (libc)Inverse Trig Functions. |
| * atanh: (libc)Hyperbolic Functions. |
| * atanhf: (libc)Hyperbolic Functions. |
| * atanhl: (libc)Hyperbolic Functions. |
| * atanl: (libc)Inverse Trig Functions. |
| * atexit: (libc)Cleanups on Exit. |
| * atof: (libc)Parsing of Floats. |
| * atoi: (libc)Parsing of Integers. |
| * atol: (libc)Parsing of Integers. |
| * atoll: (libc)Parsing of Integers. |
| * backtrace: (libc)Backtraces. |
| * backtrace_symbols: (libc)Backtraces. |
| * backtrace_symbols_fd: (libc)Backtraces. |
| * basename: (libc)Finding Tokens in a String. |
| * basename: (libc)Finding Tokens in a String. |
| * bcmp: (libc)String/Array Comparison. |
| * bcopy: (libc)Copying and Concatenation. |
| * bind: (libc)Setting Address. |
| * bind_textdomain_codeset: (libc)Charset conversion in gettext. |
| * bindtextdomain: (libc)Locating gettext catalog. |
| * brk: (libc)Resizing the Data Segment. |
| * bsearch: (libc)Array Search Function. |
| * btowc: (libc)Converting a Character. |
| * bzero: (libc)Copying and Concatenation. |
| * cabs: (libc)Absolute Value. |
| * cabsf: (libc)Absolute Value. |
| * cabsl: (libc)Absolute Value. |
| * cacos: (libc)Inverse Trig Functions. |
| * cacosf: (libc)Inverse Trig Functions. |
| * cacosh: (libc)Hyperbolic Functions. |
| * cacoshf: (libc)Hyperbolic Functions. |
| * cacoshl: (libc)Hyperbolic Functions. |
| * cacosl: (libc)Inverse Trig Functions. |
| * calloc: (libc)Allocating Cleared Space. |
| * canonicalize_file_name: (libc)Symbolic Links. |
| * carg: (libc)Operations on Complex. |
| * cargf: (libc)Operations on Complex. |
| * cargl: (libc)Operations on Complex. |
| * casin: (libc)Inverse Trig Functions. |
| * casinf: (libc)Inverse Trig Functions. |
| * casinh: (libc)Hyperbolic Functions. |
| * casinhf: (libc)Hyperbolic Functions. |
| * casinhl: (libc)Hyperbolic Functions. |
| * casinl: (libc)Inverse Trig Functions. |
| * catan: (libc)Inverse Trig Functions. |
| * catanf: (libc)Inverse Trig Functions. |
| * catanh: (libc)Hyperbolic Functions. |
| * catanhf: (libc)Hyperbolic Functions. |
| * catanhl: (libc)Hyperbolic Functions. |
| * catanl: (libc)Inverse Trig Functions. |
| * catclose: (libc)The catgets Functions. |
| * catgets: (libc)The catgets Functions. |
| * catopen: (libc)The catgets Functions. |
| * cbc_crypt: (libc)DES Encryption. |
| * cbrt: (libc)Exponents and Logarithms. |
| * cbrtf: (libc)Exponents and Logarithms. |
| * cbrtl: (libc)Exponents and Logarithms. |
| * ccos: (libc)Trig Functions. |
| * ccosf: (libc)Trig Functions. |
| * ccosh: (libc)Hyperbolic Functions. |
| * ccoshf: (libc)Hyperbolic Functions. |
| * ccoshl: (libc)Hyperbolic Functions. |
| * ccosl: (libc)Trig Functions. |
| * ceil: (libc)Rounding Functions. |
| * ceilf: (libc)Rounding Functions. |
| * ceill: (libc)Rounding Functions. |
| * cexp: (libc)Exponents and Logarithms. |
| * cexpf: (libc)Exponents and Logarithms. |
| * cexpl: (libc)Exponents and Logarithms. |
| * cfgetispeed: (libc)Line Speed. |
| * cfgetospeed: (libc)Line Speed. |
| * cfmakeraw: (libc)Noncanonical Input. |
| * cfree: (libc)Freeing after Malloc. |
| * cfsetispeed: (libc)Line Speed. |
| * cfsetospeed: (libc)Line Speed. |
| * cfsetspeed: (libc)Line Speed. |
| * chdir: (libc)Working Directory. |
| * chmod: (libc)Setting Permissions. |
| * chown: (libc)File Owner. |
| * cimag: (libc)Operations on Complex. |
| * cimagf: (libc)Operations on Complex. |
| * cimagl: (libc)Operations on Complex. |
| * clearenv: (libc)Environment Access. |
| * clearerr: (libc)Error Recovery. |
| * clearerr_unlocked: (libc)Error Recovery. |
| * clock: (libc)CPU Time. |
| * clog10: (libc)Exponents and Logarithms. |
| * clog10f: (libc)Exponents and Logarithms. |
| * clog10l: (libc)Exponents and Logarithms. |
| * clog: (libc)Exponents and Logarithms. |
| * clogf: (libc)Exponents and Logarithms. |
| * clogl: (libc)Exponents and Logarithms. |
| * close: (libc)Opening and Closing Files. |
| * closedir: (libc)Reading/Closing Directory. |
| * closelog: (libc)closelog. |
| * confstr: (libc)String Parameters. |
| * conj: (libc)Operations on Complex. |
| * conjf: (libc)Operations on Complex. |
| * conjl: (libc)Operations on Complex. |
| * connect: (libc)Connecting. |
| * copysign: (libc)FP Bit Twiddling. |
| * copysignf: (libc)FP Bit Twiddling. |
| * copysignl: (libc)FP Bit Twiddling. |
| * cos: (libc)Trig Functions. |
| * cosf: (libc)Trig Functions. |
| * cosh: (libc)Hyperbolic Functions. |
| * coshf: (libc)Hyperbolic Functions. |
| * coshl: (libc)Hyperbolic Functions. |
| * cosl: (libc)Trig Functions. |
| * cpow: (libc)Exponents and Logarithms. |
| * cpowf: (libc)Exponents and Logarithms. |
| * cpowl: (libc)Exponents and Logarithms. |
| * cproj: (libc)Operations on Complex. |
| * cprojf: (libc)Operations on Complex. |
| * cprojl: (libc)Operations on Complex. |
| * creal: (libc)Operations on Complex. |
| * crealf: (libc)Operations on Complex. |
| * creall: (libc)Operations on Complex. |
| * creat64: (libc)Opening and Closing Files. |
| * creat: (libc)Opening and Closing Files. |
| * crypt: (libc)crypt. |
| * crypt_r: (libc)crypt. |
| * csin: (libc)Trig Functions. |
| * csinf: (libc)Trig Functions. |
| * csinh: (libc)Hyperbolic Functions. |
| * csinhf: (libc)Hyperbolic Functions. |
| * csinhl: (libc)Hyperbolic Functions. |
| * csinl: (libc)Trig Functions. |
| * csqrt: (libc)Exponents and Logarithms. |
| * csqrtf: (libc)Exponents and Logarithms. |
| * csqrtl: (libc)Exponents and Logarithms. |
| * ctan: (libc)Trig Functions. |
| * ctanf: (libc)Trig Functions. |
| * ctanh: (libc)Hyperbolic Functions. |
| * ctanhf: (libc)Hyperbolic Functions. |
| * ctanhl: (libc)Hyperbolic Functions. |
| * ctanl: (libc)Trig Functions. |
| * ctermid: (libc)Identifying the Terminal. |
| * ctime: (libc)Formatting Calendar Time. |
| * ctime_r: (libc)Formatting Calendar Time. |
| * cuserid: (libc)Who Logged In. |
| * dcgettext: (libc)Translation with gettext. |
| * dcngettext: (libc)Advanced gettext functions. |
| * des_setparity: (libc)DES Encryption. |
| * dgettext: (libc)Translation with gettext. |
| * difftime: (libc)Elapsed Time. |
| * dirfd: (libc)Opening a Directory. |
| * dirname: (libc)Finding Tokens in a String. |
| * div: (libc)Integer Division. |
| * dngettext: (libc)Advanced gettext functions. |
| * drand48: (libc)SVID Random. |
| * drand48_r: (libc)SVID Random. |
| * drem: (libc)Remainder Functions. |
| * dremf: (libc)Remainder Functions. |
| * dreml: (libc)Remainder Functions. |
| * dup2: (libc)Duplicating Descriptors. |
| * dup: (libc)Duplicating Descriptors. |
| * ecb_crypt: (libc)DES Encryption. |
| * ecvt: (libc)System V Number Conversion. |
| * ecvt_r: (libc)System V Number Conversion. |
| * encrypt: (libc)DES Encryption. |
| * encrypt_r: (libc)DES Encryption. |
| * endfsent: (libc)fstab. |
| * endgrent: (libc)Scanning All Groups. |
| * endhostent: (libc)Host Names. |
| * endmntent: (libc)mtab. |
| * endnetent: (libc)Networks Database. |
| * endnetgrent: (libc)Lookup Netgroup. |
| * endprotoent: (libc)Protocols Database. |
| * endpwent: (libc)Scanning All Users. |
| * endservent: (libc)Services Database. |
| * endutent: (libc)Manipulating the Database. |
| * endutxent: (libc)XPG Functions. |
| * envz_add: (libc)Envz Functions. |
| * envz_entry: (libc)Envz Functions. |
| * envz_get: (libc)Envz Functions. |
| * envz_merge: (libc)Envz Functions. |
| * envz_strip: (libc)Envz Functions. |
| * erand48: (libc)SVID Random. |
| * erand48_r: (libc)SVID Random. |
| * erf: (libc)Special Functions. |
| * erfc: (libc)Special Functions. |
| * erfcf: (libc)Special Functions. |
| * erfcl: (libc)Special Functions. |
| * erff: (libc)Special Functions. |
| * erfl: (libc)Special Functions. |
| * err: (libc)Error Messages. |
| * errno: (libc)Checking for Errors. |
| * error: (libc)Error Messages. |
| * error_at_line: (libc)Error Messages. |
| * errx: (libc)Error Messages. |
| * execl: (libc)Executing a File. |
| * execle: (libc)Executing a File. |
| * execlp: (libc)Executing a File. |
| * execv: (libc)Executing a File. |
| * execve: (libc)Executing a File. |
| * execvp: (libc)Executing a File. |
| * exit: (libc)Normal Termination. |
| * exp10: (libc)Exponents and Logarithms. |
| * exp10f: (libc)Exponents and Logarithms. |
| * exp10l: (libc)Exponents and Logarithms. |
| * exp2: (libc)Exponents and Logarithms. |
| * exp2f: (libc)Exponents and Logarithms. |
| * exp2l: (libc)Exponents and Logarithms. |
| * exp: (libc)Exponents and Logarithms. |
| * expf: (libc)Exponents and Logarithms. |
| * expl: (libc)Exponents and Logarithms. |
| * expm1: (libc)Exponents and Logarithms. |
| * expm1f: (libc)Exponents and Logarithms. |
| * expm1l: (libc)Exponents and Logarithms. |
| * fabs: (libc)Absolute Value. |
| * fabsf: (libc)Absolute Value. |
| * fabsl: (libc)Absolute Value. |
| * fchdir: (libc)Working Directory. |
| * fchmod: (libc)Setting Permissions. |
| * fchown: (libc)File Owner. |
| * fclean: (libc)Cleaning Streams. |
| * 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. |
| * getc: (libc)Character Input. |
| * getc_unlocked: (libc)Character Input. |
| * getchar: (libc)Character Input. |
| * getchar_unlocked: (libc)Character Input. |
| * getcontext: (libc)System V contexts. |
| * getcwd: (libc)Working Directory. |
| * getdate: (libc)General Time String Parsing. |
| * getdate_r: (libc)General Time String Parsing. |
| * getdelim: (libc)Line Input. |
| * getdomainnname: (libc)Host Identification. |
| * getegid: (libc)Reading Persona. |
| * getenv: (libc)Environment Access. |
| * geteuid: (libc)Reading Persona. |
| * getfsent: (libc)fstab. |
| * getfsfile: (libc)fstab. |
| * getfsspec: (libc)fstab. |
| * getgid: (libc)Reading Persona. |
| * getgrent: (libc)Scanning All Groups. |
| * getgrent_r: (libc)Scanning All Groups. |
| * getgrgid: (libc)Lookup Group. |
| * getgrgid_r: (libc)Lookup Group. |
| * getgrnam: (libc)Lookup Group. |
| * getgrnam_r: (libc)Lookup Group. |
| * getgrouplist: (libc)Setting Groups. |
| * getgroups: (libc)Reading Persona. |
| * gethostbyaddr: (libc)Host Names. |
| * gethostbyaddr_r: (libc)Host Names. |
| * gethostbyname2: (libc)Host Names. |
| * gethostbyname2_r: (libc)Host Names. |
| * gethostbyname: (libc)Host Names. |
| * gethostbyname_r: (libc)Host Names. |
| * gethostent: (libc)Host Names. |
| * gethostid: (libc)Host Identification. |
| * gethostname: (libc)Host Identification. |
| * getitimer: (libc)Setting an Alarm. |
| * getline: (libc)Line Input. |
| * getloadavg: (libc)Processor Resources. |
| * getlogin: (libc)Who Logged In. |
| * getmntent: (libc)mtab. |
| * getmntent_r: (libc)mtab. |
| * getnetbyaddr: (libc)Networks Database. |
| * getnetbyname: (libc)Networks Database. |
| * getnetent: (libc)Networks Database. |
| * getnetgrent: (libc)Lookup Netgroup. |
| * getnetgrent_r: (libc)Lookup Netgroup. |
| * getopt: (libc)Using Getopt. |
| * getopt_long: (libc)Getopt Long Options. |
| * getopt_long_only: (libc)Getopt Long Options. |
| * getpagesize: (libc)Query Memory Parameters. |
| * getpass: (libc)getpass. |
| * getpeername: (libc)Who is Connected. |
| * getpgid: (libc)Process Group Functions. |
| * getpgrp: (libc)Process Group Functions. |
| * getpgrp: (libc)Process Group Functions. |
| * getpid: (libc)Process Identification. |
| * getppid: (libc)Process Identification. |
| * getpriority: (libc)Traditional Scheduling Functions. |
| * getprotobyname: (libc)Protocols Database. |
| * getprotobynumber: (libc)Protocols Database. |
| * getprotoent: (libc)Protocols Database. |
| * getpt: (libc)Allocation. |
| * getpwent: (libc)Scanning All Users. |
| * getpwent_r: (libc)Scanning All Users. |
| * getpwnam: (libc)Lookup User. |
| * getpwnam_r: (libc)Lookup User. |
| * getpwuid: (libc)Lookup User. |
| * getpwuid_r: (libc)Lookup User. |
| * getrlimit64: (libc)Limits on Resources. |
| * getrlimit: (libc)Limits on Resources. |
| * getrusage: (libc)Resource Usage. |
| * gets: (libc)Line Input. |
| * getservbyname: (libc)Services Database. |
| * getservbyport: (libc)Services Database. |
| * getservent: (libc)Services Database. |
| * getsid: (libc)Process Group Functions. |
| * getsockname: (libc)Reading Address. |
| * getsockopt: (libc)Socket Option Functions. |
| * getsubopt: (libc)Suboptions. |
| * gettext: (libc)Translation with gettext. |
| * gettimeofday: (libc)High-Resolution Calendar. |
| * getuid: (libc)Reading Persona. |
| * getumask: (libc)Setting Permissions. |
| * getutent: (libc)Manipulating the Database. |
| * getutent_r: (libc)Manipulating the Database. |
| * getutid: (libc)Manipulating the Database. |
| * getutid_r: (libc)Manipulating the Database. |
| * getutline: (libc)Manipulating the Database. |
| * getutline_r: (libc)Manipulating the Database. |
| * getutmp: (libc)XPG Functions. |
| * getutmpx: (libc)XPG Functions. |
| * getutxent: (libc)XPG Functions. |
| * getutxid: (libc)XPG Functions. |
| * getutxline: (libc)XPG Functions. |
| * getw: (libc)Character Input. |
| * getwc: (libc)Character Input. |
| * getwc_unlocked: (libc)Character Input. |
| * getwchar: (libc)Character Input. |
| * getwchar_unlocked: (libc)Character Input. |
| * getwd: (libc)Working Directory. |
| * glob64: (libc)Calling Glob. |
| * glob: (libc)Calling Glob. |
| * globfree64: (libc)More Flags for Globbing. |
| * globfree: (libc)More Flags for Globbing. |
| * gmtime: (libc)Broken-down Time. |
| * gmtime_r: (libc)Broken-down Time. |
| * grantpt: (libc)Allocation. |
| * gsignal: (libc)Signaling Yourself. |
| * gtty: (libc)BSD Terminal Modes. |
| * hasmntopt: (libc)mtab. |
| * hcreate: (libc)Hash Search Function. |
| * hcreate_r: (libc)Hash Search Function. |
| * hdestroy: (libc)Hash Search Function. |
| * hdestroy_r: (libc)Hash Search Function. |
| * hsearch: (libc)Hash Search Function. |
| * hsearch_r: (libc)Hash Search Function. |
| * htonl: (libc)Byte Order. |
| * htons: (libc)Byte Order. |
| * hypot: (libc)Exponents and Logarithms. |
| * hypotf: (libc)Exponents and Logarithms. |
| * hypotl: (libc)Exponents and Logarithms. |
| * iconv: (libc)Generic Conversion Interface. |
| * iconv_close: (libc)Generic Conversion Interface. |
| * iconv_open: (libc)Generic Conversion Interface. |
| * if_freenameindex: (libc)Interface Naming. |
| * if_indextoname: (libc)Interface Naming. |
| * if_nameindex: (libc)Interface Naming. |
| * if_nametoindex: (libc)Interface Naming. |
| * ilogb: (libc)Exponents and Logarithms. |
| * ilogbf: (libc)Exponents and Logarithms. |
| * ilogbl: (libc)Exponents and Logarithms. |
| * imaxabs: (libc)Absolute Value. |
| * imaxdiv: (libc)Integer Division. |
| * in6addr_any: (libc)Host Address Data Type. |
| * in6addr_loopback: (libc)Host Address Data Type. |
| * index: (libc)Search Functions. |
| * inet_addr: (libc)Host Address Functions. |
| * inet_aton: (libc)Host Address Functions. |
| * inet_lnaof: (libc)Host Address Functions. |
| * inet_makeaddr: (libc)Host Address Functions. |
| * inet_netof: (libc)Host Address Functions. |
| * inet_network: (libc)Host Address Functions. |
| * inet_ntoa: (libc)Host Address Functions. |
| * inet_ntop: (libc)Host Address Functions. |
| * inet_pton: (libc)Host Address Functions. |
| * initgroups: (libc)Setting Groups. |
| * initstate: (libc)BSD Random. |
| * initstate_r: (libc)BSD Random. |
| * innetgr: (libc)Netgroup Membership. |
| * int: (libc)Random Access Directory. |
| * 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. |
| * 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. |
| * open_obstack_stream: (libc)Obstack 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. |
| * 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. |
| * seed48: (libc)SVID Random. |
| * seed48_r: (libc)SVID Random. |
| * seekdir: (libc)Random Access Directory. |
| * select: (libc)Waiting for I/O. |
| * send: (libc)Sending Data. |
| * sendmsg: (libc)Receiving Datagrams. |
| * sendto: (libc)Sending Datagrams. |
| * setbuf: (libc)Controlling Buffering. |
| * setbuffer: (libc)Controlling Buffering. |
| * setcontext: (libc)System V contexts. |
| * setdomainname: (libc)Host Identification. |
| * setegid: (libc)Setting Groups. |
| * setenv: (libc)Environment Access. |
| * seteuid: (libc)Setting User ID. |
| * setfsent: (libc)fstab. |
| * setgid: (libc)Setting Groups. |
| * setgrent: (libc)Scanning All Groups. |
| * setgroups: (libc)Setting Groups. |
| * sethostent: (libc)Host Names. |
| * sethostid: (libc)Host Identification. |
| * sethostname: (libc)Host Identification. |
| * setitimer: (libc)Setting an Alarm. |
| * setjmp: (libc)Non-Local Details. |
| * setkey: (libc)DES Encryption. |
| * setkey_r: (libc)DES Encryption. |
| * setlinebuf: (libc)Controlling Buffering. |
| * setlocale: (libc)Setting the Locale. |
| * setlogmask: (libc)setlogmask. |
| * setmntent: (libc)mtab. |
| * setnetent: (libc)Networks Database. |
| * setnetgrent: (libc)Lookup Netgroup. |
| * setpgid: (libc)Process Group Functions. |
| * setpgrp: (libc)Process Group Functions. |
| * setpriority: (libc)Traditional Scheduling Functions. |
| * setprotoent: (libc)Protocols Database. |
| * setpwent: (libc)Scanning All Users. |
| * setregid: (libc)Setting Groups. |
| * setreuid: (libc)Setting User ID. |
| * setrlimit64: (libc)Limits on Resources. |
| * setrlimit: (libc)Limits on Resources. |
| * setservent: (libc)Services Database. |
| * setsid: (libc)Process Group Functions. |
| * setsockopt: (libc)Socket Option Functions. |
| * setstate: (libc)BSD Random. |
| * setstate_r: (libc)BSD Random. |
| * settimeofday: (libc)High-Resolution Calendar. |
| * setuid: (libc)Setting User ID. |
| * setutent: (libc)Manipulating the Database. |
| * setutxent: (libc)XPG Functions. |
| * setvbuf: (libc)Controlling Buffering. |
| * shutdown: (libc)Closing a Socket. |
| * sigaction: (libc)Advanced Signal Handling. |
| * sigaddset: (libc)Signal Sets. |
| * sigaltstack: (libc)Signal Stack. |
| * sigblock: (libc)Blocking in BSD. |
| * sigdelset: (libc)Signal Sets. |
| * sigemptyset: (libc)Signal Sets. |
| * sigfillset: (libc)Signal Sets. |
| * siginterrupt: (libc)BSD Handler. |
| * sigismember: (libc)Signal Sets. |
| * siglongjmp: (libc)Non-Local Exits and Signals. |
| * sigmask: (libc)Blocking in BSD. |
| * signal: (libc)Basic Signal Handling. |
| * signbit: (libc)FP Bit Twiddling. |
| * significand: (libc)Normalization Functions. |
| * significandf: (libc)Normalization Functions. |
| * significandl: (libc)Normalization Functions. |
| * sigpause: (libc)Blocking in BSD. |
| * sigpending: (libc)Checking for Pending Signals. |
| * sigprocmask: (libc)Process Signal Mask. |
| * sigsetjmp: (libc)Non-Local Exits and Signals. |
| * sigsetmask: (libc)Blocking in BSD. |
| * sigstack: (libc)Signal Stack. |
| * sigsuspend: (libc)Sigsuspend. |
| * sigvec: (libc)BSD Handler. |
| * sin: (libc)Trig Functions. |
| * sincos: (libc)Trig Functions. |
| * sincosf: (libc)Trig Functions. |
| * sincosl: (libc)Trig Functions. |
| * sinf: (libc)Trig Functions. |
| * sinh: (libc)Hyperbolic Functions. |
| * sinhf: (libc)Hyperbolic Functions. |
| * sinhl: (libc)Hyperbolic Functions. |
| * sinl: (libc)Trig Functions. |
| * sleep: (libc)Sleeping. |
| * snprintf: (libc)Formatted Output Functions. |
| * socket: (libc)Creating a Socket. |
| * socketpair: (libc)Socket Pairs. |
| * sprintf: (libc)Formatted Output Functions. |
| * sqrt: (libc)Exponents and Logarithms. |
| * sqrtf: (libc)Exponents and Logarithms. |
| * sqrtl: (libc)Exponents and Logarithms. |
| * srand48: (libc)SVID Random. |
| * srand48_r: (libc)SVID Random. |
| * srand: (libc)ISO Random. |
| * srandom: (libc)BSD Random. |
| * srandom_r: (libc)BSD Random. |
| * sscanf: (libc)Formatted Input Functions. |
| * ssignal: (libc)Basic Signal Handling. |
| * stat64: (libc)Reading Attributes. |
| * stat: (libc)Reading Attributes. |
| * stime: (libc)Simple Calendar Time. |
| * stpcpy: (libc)Copying and Concatenation. |
| * stpncpy: (libc)Copying and Concatenation. |
| * strcasecmp: (libc)String/Array Comparison. |
| * strcasestr: (libc)Search Functions. |
| * strcat: (libc)Copying and Concatenation. |
| * strchr: (libc)Search Functions. |
| * strchrnul: (libc)Search Functions. |
| * strcmp: (libc)String/Array Comparison. |
| * strcoll: (libc)Collation Functions. |
| * strcpy: (libc)Copying and Concatenation. |
| * strcspn: (libc)Search Functions. |
| * strdup: (libc)Copying and Concatenation. |
| * strdupa: (libc)Copying and Concatenation. |
| * strerror: (libc)Error Messages. |
| * strerror_r: (libc)Error Messages. |
| * strfmon: (libc)Formatting Numbers. |
| * strfry: (libc)strfry. |
| * strftime: (libc)Formatting Calendar Time. |
| * strlen: (libc)String Length. |
| * strncasecmp: (libc)String/Array Comparison. |
| * strncat: (libc)Copying and Concatenation. |
| * strncmp: (libc)String/Array Comparison. |
| * strncpy: (libc)Copying and Concatenation. |
| * strndup: (libc)Copying and Concatenation. |
| * strndupa: (libc)Copying and Concatenation. |
| * strnlen: (libc)String Length. |
| * strpbrk: (libc)Search Functions. |
| * strptime: (libc)Low-Level Time String Parsing. |
| * strrchr: (libc)Search Functions. |
| * strsep: (libc)Finding Tokens in a String. |
| * strsignal: (libc)Signal Messages. |
| * strspn: (libc)Search Functions. |
| * strstr: (libc)Search Functions. |
| * strtod: (libc)Parsing of Floats. |
| * strtof: (libc)Parsing of Floats. |
| * strtoimax: (libc)Parsing of Integers. |
| * strtok: (libc)Finding Tokens in a String. |
| * strtok_r: (libc)Finding Tokens in a String. |
| * strtol: (libc)Parsing of Integers. |
| * strtold: (libc)Parsing of Floats. |
| * strtoll: (libc)Parsing of Integers. |
| * strtoq: (libc)Parsing of Integers. |
| * strtoul: (libc)Parsing of Integers. |
| * strtoull: (libc)Parsing of Integers. |
| * strtoumax: (libc)Parsing of Integers. |
| * strtouq: (libc)Parsing of Integers. |
| * strverscmp: (libc)String/Array Comparison. |
| * strxfrm: (libc)Collation Functions. |
| * stty: (libc)BSD Terminal Modes. |
| * swapcontext: (libc)System V contexts. |
| * swprintf: (libc)Formatted Output Functions. |
| * swscanf: (libc)Formatted Input Functions. |
| * symlink: (libc)Symbolic Links. |
| * sync: (libc)Synchronizing I/O. |
| * syscall: (libc)System Calls. |
| * sysconf: (libc)Sysconf Definition. |
| * sysctl: (libc)System Parameters. |
| * syslog: (libc)syslog; vsyslog. |
| * system: (libc)Running a Command. |
| * sysv_signal: (libc)Basic Signal Handling. |
| * tan: (libc)Trig Functions. |
| * tanf: (libc)Trig Functions. |
| * tanh: (libc)Hyperbolic Functions. |
| * tanhf: (libc)Hyperbolic Functions. |
| * tanhl: (libc)Hyperbolic Functions. |
| * tanl: (libc)Trig Functions. |
| * tcdrain: (libc)Line Control. |
| * tcflow: (libc)Line Control. |
| * tcflush: (libc)Line Control. |
| * tcgetattr: (libc)Mode Functions. |
| * tcgetpgrp: (libc)Terminal Access Functions. |
| * tcgetsid: (libc)Terminal Access Functions. |
| * tcsendbreak: (libc)Line Control. |
| * tcsetattr: (libc)Mode Functions. |
| * tcsetpgrp: (libc)Terminal Access Functions. |
| * tdelete: (libc)Tree Search Function. |
| * tdestroy: (libc)Tree Search Function. |
| * 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_end: (libc)Argument Macros. |
| * va_start: (libc)Argument Macros. |
| * va_start: (libc)Old Varargs. |
| * 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 |
| |
| @set REPORT_BUGS_TO <https://support.codesourcery.com/GNUToolchain/> |
| |
| This file documents the GNU C library. |
| |
| This is Edition 0.12, last updated 2007-10-27, of `The GNU C Library |
| Reference Manual', for version 2.8 (Sourcery G++ Lite 2011.03-41). |
| |
| Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2001, 2002, |
| 2003, 2007, 2008, 2010 Free Software Foundation, Inc. |
| |
| Permission is granted to copy, distribute and/or modify this document |
| under the terms of the GNU Free Documentation License, Version 1.3 or |
| any later version published by the Free Software Foundation; with the |
| Invariant Sections being "Free Software Needs Free Documentation" and |
| "GNU Lesser General Public License", the Front-Cover texts being "A GNU |
| Manual", and with the Back-Cover Texts as in (a) below. A copy of the |
| license is included in the section entitled "GNU Free Documentation |
| License". |
| |
| (a) The FSF's Back-Cover Text is: "You have the freedom to copy and |
| modify this GNU manual. Buying copies from the FSF supports it in |
| developing GNU and promoting software freedom." |
| |
| |
| File: libc.info, Node: Contributors, Next: Free Manuals, Prev: Maintenance, Up: Top |
| |
| Appendix E Contributors to the GNU C Library |
| ******************************************** |
| |
| The GNU C library was written originally by Roland McGrath, and is |
| currently maintained by Ulrich Drepper. Some parts of the library were |
| contributed or worked on by other people. |
| |
| * The `getopt' function and related code was written by Richard |
| Stallman, David J. MacKenzie, and Roland McGrath. |
| |
| * The merge sort function `qsort' was written by Michael J. Haertel. |
| |
| * The quick sort function used as a fallback by `qsort' was written |
| by Douglas C. Schmidt. |
| |
| * The memory allocation functions `malloc', `realloc' and `free' and |
| related code were written by Michael J. Haertel, Wolfram Gloger, |
| and Doug Lea. |
| |
| * Fast implementations of many of the string functions (`memcpy', |
| `strlen', etc.) were written by Torbjo"rn Granlund. |
| |
| * The `tar.h' header file was written by David J. MacKenzie. |
| |
| * The port to the MIPS DECStation running Ultrix 4 |
| (`mips-dec-ultrix4') was contributed by Brendan Kehoe and Ian |
| Lance Taylor. |
| |
| * The DES encryption function `crypt' and related functions were |
| contributed by Michael Glad. |
| |
| * The `ftw' and `nftw' functions were contributed by Ulrich Drepper. |
| |
| * The startup code to support SunOS shared libraries was contributed |
| by Tom Quinn. |
| |
| * The `mktime' function was contributed by Paul Eggert. |
| |
| * The port to the Sequent Symmetry running Dynix version 3 |
| (`i386-sequent-bsd') was contributed by Jason Merrill. |
| |
| * The timezone support code is derived from the public-domain |
| timezone package by Arthur David Olson and his many contributors. |
| |
| * The port to the DEC Alpha running OSF/1 (`alpha-dec-osf1') was |
| contributed by Brendan Kehoe, using some code written by Roland |
| McGrath. |
| |
| * The port to SGI machines running Irix 4 (`mips-sgi-irix4') was |
| contributed by Tom Quinn. |
| |
| * The port of the Mach and Hurd code to the MIPS architecture |
| (`mips-ANYTHING-gnu') was contributed by Kazumoto Kojima. |
| |
| * The floating-point printing function used by `printf' and friends |
| and the floating-point reading function used by `scanf', `strtod' |
| and friends were written by Ulrich Drepper. The multi-precision |
| integer functions used in those functions are taken from GNU MP, |
| which was contributed by Torbjo"rn Granlund. |
| |
| * The internationalization support in the library, and the support |
| programs `locale' and `localedef', were written by Ulrich Drepper. |
| Ulrich Drepper adapted the support code for message catalogs |
| (`libintl.h', etc.) from the GNU `gettext' package, which he also |
| wrote. He also contributed the `catgets' support and the entire |
| suite of multi-byte and wide-character support functions |
| (`wctype.h', `wchar.h', etc.). |
| |
| * The implementations of the `nsswitch.conf' mechanism and the files |
| and DNS backends for it were designed and written by Ulrich |
| Drepper and Roland McGrath, based on a backend interface defined |
| by Peter Eriksson. |
| |
| * The port to Linux i386/ELF (`i386-ANYTHING-linux') was contributed |
| by Ulrich Drepper, based in large part on work done in Hongjiu |
| Lu's Linux version of the GNU C Library. |
| |
| * The port to Linux/m68k (`m68k-ANYTHING-linux') was contributed by |
| Andreas Schwab. |
| |
| * The ports to Linux/ARM (`arm-ANYTHING-linuxaout') and ARM |
| standalone (`arm-ANYTHING-none'), as well as parts of the IPv6 |
| support code, were contributed by Philip Blundell. |
| |
| * Richard Henderson contributed the ELF dynamic linking code and |
| other support for the Alpha processor. |
| |
| * David Mosberger-Tang contributed the port to Linux/Alpha |
| (`alpha-ANYTHING-linux'). |
| |
| * The port to Linux on PowerPC (`powerpc-ANYTHING-linux') was |
| contributed by Geoffrey Keating. |
| |
| * Miles Bader wrote the argp argument-parsing package, and the |
| argz/envz interfaces. |
| |
| * Stephen R. van den Berg contributed a highly-optimized `strstr' |
| function. |
| |
| * Ulrich Drepper contributed the `hsearch' and `drand48' families of |
| functions; reentrant `...`_r'' versions of the `random' family; |
| System V shared memory and IPC support code; and several |
| highly-optimized string functions for iX86 processors. |
| |
| * The math functions are taken from `fdlibm-5.1' by Sun |
| Microsystems, as modified by J.T. Conklin, Ian Lance Taylor, |
| Ulrich Drepper, Andreas Schwab, and Roland McGrath. |
| |
| * The `libio' library used to implement `stdio' functions on some |
| platforms was written by Per Bothner and modified by Ulrich |
| Drepper. |
| |
| * Eric Youngdale and Ulrich Drepper implemented versioning of |
| objects on the symbol level. |
| |
| * Thorsten Kukuk provided an implementation for NIS (YP) and NIS+, |
| securelevel 0, 1 and 2. |
| |
| * Andreas Jaeger provided a test suite for the math library. |
| |
| * Mark Kettenis implemented the utmpx interface and an utmp daemon. |
| |
| * Ulrich Drepper added character conversion functions (`iconv'). |
| |
| * Thorsten Kukuk provided an implementation for a caching daemon for |
| NSS (nscd). |
| |
| * Tim Waugh provided an implementation of the POSIX.2 wordexp |
| function family. |
| |
| * Mark Kettenis provided a Hesiod NSS module. |
| |
| * The Internet-related code (most of the `inet' subdirectory) and |
| several other miscellaneous functions and header files have been |
| included from 4.4 BSD with little or no modification. The copying |
| permission notice for this code can be found in the file `LICENSES' |
| in the source distribution. |
| |
| * The random number generation functions `random', `srandom', |
| `setstate' and `initstate', which are also the basis for the |
| `rand' and `srand' functions, were written by Earl T. Cohen for |
| the University of California at Berkeley and are copyrighted by the |
| Regents of the University of California. They have undergone minor |
| changes to fit into the GNU C library and to fit the ISO C |
| standard, but the functional code is Berkeley's. |
| |
| * The DNS resolver code is taken directly from BIND 4.9.5, which |
| includes copyrighted code from UC Berkeley and from Digital |
| Equipment Corporation. See the file `LICENSES' for the text of |
| the DEC license. |
| |
| * The code to support Sun RPC is taken verbatim from Sun's |
| RPCSRC-4.0 distribution; see the file `LICENSES' for the text of |
| the license. |
| |
| * Some of the support code for Mach is taken from Mach 3.0 by CMU; |
| the file if_ppp.h is also copyright by CMU, but under a different |
| license; see the file `LICENSES' for the text of the licenses. |
| |
| * Many of the IA64 math functions are taken from a collection of |
| "Highly Optimized Mathematical Functions for Itanium" that Intel |
| makes available under a free license; see the file `LICENSES' for |
| details. |
| |
| * The `getaddrinfo' and `getnameinfo' functions and supporting code |
| were written by Craig Metz; see the file `LICENSES' for details on |
| their licensing. |
| |
| * Many of the IEEE 64-bit double precision math functions (in the |
| `sysdeps/ieee754/dbl-64' subdirectory) come from the IBM Accurate |
| Mathematical Library, contributed by IBM. |
| |
| |
| |
| File: libc.info, Node: Free Manuals, Next: Copying, Prev: Contributors, Up: Top |
| |
| Appendix F Free Software Needs Free Documentation |
| ************************************************* |
| |
| The biggest deficiency in the free software community today is not in |
| the software--it is the lack of good free documentation that we can |
| include with the free software. Many of our most important programs do |
| not come with free reference manuals and free introductory texts. |
| Documentation is an essential part of any software package; when an |
| important free software package does not come with a free manual and a |
| free tutorial, that is a major gap. We have many such gaps today. |
| |
| Consider Perl, for instance. The tutorial manuals that people |
| normally use are non-free. How did this come about? Because the |
| authors of those manuals published them with restrictive terms--no |
| copying, no modification, source files not available--which exclude |
| them from the free software world. |
| |
| That wasn't the first time this sort of thing happened, and it was |
| far from the last. Many times we have heard a GNU user eagerly |
| describe a manual that he is writing, his intended contribution to the |
| community, only to learn that he had ruined everything by signing a |
| publication contract to make it non-free. |
| |
| Free documentation, like free software, is a matter of freedom, not |
| price. The problem with the non-free manual is not that publishers |
| charge a price for printed copies--that in itself is fine. (The Free |
| Software Foundation sells printed copies of manuals, too.) The problem |
| is the restrictions on the use of the manual. Free manuals are |
| available in source code form, and give you permission to copy and |
| modify. Non-free manuals do not allow this. |
| |
| The criteria of freedom for a free manual are roughly the same as for |
| free software. Redistribution (including the normal kinds of |
| commercial redistribution) must be permitted, so that the manual can |
| accompany every copy of the program, both on-line and on paper. |
| |
| Permission for modification of the technical content is crucial too. |
| When people modify the software, adding or changing features, if they |
| are conscientious they will change the manual too--so they can provide |
| accurate and clear documentation for the modified program. A manual |
| that leaves you no choice but to write a new manual to document a |
| changed version of the program is not really available to our community. |
| |
| Some kinds of limits on the way modification is handled are |
| acceptable. For example, requirements to preserve the original |
| author's copyright notice, the distribution terms, or the list of |
| authors, are ok. It is also no problem to require modified versions to |
| include notice that they were modified. Even entire sections that may |
| not be deleted or changed are acceptable, as long as they deal with |
| nontechnical topics (like this one). These kinds of restrictions are |
| acceptable because they don't obstruct the community's normal use of |
| the manual. |
| |
| However, it must be possible to modify all the _technical_ content |
| of the manual, and then distribute the result in all the usual media, |
| through all the usual channels. Otherwise, the restrictions obstruct |
| the use of the manual, it is not free, and we need another manual to |
| replace it. |
| |
| Please spread the word about this issue. Our community continues to |
| lose manuals to proprietary publishing. If we spread the word that |
| free software needs free reference manuals and free tutorials, perhaps |
| the next person who wants to contribute by writing documentation will |
| realize, before it is too late, that only free manuals contribute to |
| the free software community. |
| |
| If you are writing documentation, please insist on publishing it |
| under the GNU Free Documentation License or another free documentation |
| license. Remember that this decision requires your approval--you don't |
| have to let the publisher decide. Some commercial publishers will use |
| a free license if you insist, but they will not propose the option; it |
| is up to you to raise the issue and say firmly that this is what you |
| want. If the publisher you are dealing with refuses, please try other |
| publishers. If you're not sure whether a proposed license is free, |
| write to <licensing@gnu.org>. |
| |
| You can encourage commercial publishers to sell more free, copylefted |
| manuals and tutorials by buying them, and particularly by buying copies |
| from the publishers that paid for their writing or for major |
| improvements. Meanwhile, try to avoid buying non-free documentation at |
| all. Check the distribution terms of a manual before you buy it, and |
| insist that whoever seeks your business must respect your freedom. |
| Check the history of the book, and try reward the publishers that have |
| paid or pay the authors to work on it. |
| |
| The Free Software Foundation maintains a list of free documentation |
| published by other publishers, at |
| `http://www.fsf.org/doc/other-free-books.html'. |
| |
| |
| File: libc.info, Node: Copying, Next: Documentation License, Prev: Free Manuals, Up: Top |
| |
| Appendix G GNU Lesser General Public License |
| ******************************************** |
| |
| Version 2.1, February 1999 |
| |
| Copyright (C) 1991, 1999 Free Software Foundation, Inc. |
| 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA |
| |
| Everyone is permitted to copy and distribute verbatim copies |
| of this license document, but changing it is not allowed. |
| |
| [This is the first released version of the Lesser GPL. It also counts |
| as the successor of the GNU Library Public License, version 2, hence the |
| version number 2.1.] |
| |
| G.0.1 Preamble |
| -------------- |
| |
| The licenses for most software are designed to take away your freedom |
| to share and change it. By contrast, the GNU General Public Licenses |
| are intended to guarantee your freedom to share and change free |
| software--to make sure the software is free for all its users. |
| |
| This license, the Lesser General Public License, applies to some |
| specially designated software--typically libraries--of the Free |
| Software Foundation and other authors who decide to use it. You can use |
| it too, but we suggest you first think carefully about whether this |
| license or the ordinary General Public License is the better strategy to |
| use in any particular case, based on the explanations below. |
| |
| When we speak of free software, we are referring to freedom of use, |
| not price. Our General Public Licenses are designed to make sure that |
| you have the freedom to distribute copies of free software (and charge |
| for this service if you wish); that you receive source code or can get |
| it if you want it; that you can change the software and use pieces of it |
| in new free programs; and that you are informed that you can do these |
| things. |
| |
| To protect your rights, we need to make restrictions that forbid |
| distributors to deny you these rights or to ask you to surrender these |
| rights. These restrictions translate to certain responsibilities for |
| you if you distribute copies of the library or if you modify it. |
| |
| For example, if you distribute copies of the library, whether gratis |
| or for a fee, you must give the recipients all the rights that we gave |
| you. You must make sure that they, too, receive or can get the source |
| code. If you link other code with the library, you must provide |
| complete object files to the recipients, so that they can relink them |
| with the library after making changes to the library and recompiling |
| it. And you must show them these terms so they know their rights. |
| |
| We protect your rights with a two-step method: (1) we copyright the |
| library, and (2) we offer you this license, which gives you legal |
| permission to copy, distribute and/or modify the library. |
| |
| To protect each distributor, we want to make it very clear that |
| there is no warranty for the free library. Also, if the library is |
| modified by someone else and passed on, the recipients should know that |
| what they have is not the original version, so that the original |
| author's reputation will not be affected by problems that might be |
| introduced by others. |
| |
| Finally, software patents pose a constant threat to the existence of |
| any free program. We wish to make sure that a company cannot |
| effectively restrict the users of a free program by obtaining a |
| restrictive license from a patent holder. Therefore, we insist that |
| any patent license obtained for a version of the library must be |
| consistent with the full freedom of use specified in this license. |
| |
| Most GNU software, including some libraries, is covered by the |
| ordinary GNU General Public License. This license, the GNU Lesser |
| General Public License, applies to certain designated libraries, and is |
| quite different from the ordinary General Public License. We use this |
| license for certain libraries in order to permit linking those |
| libraries into non-free programs. |
| |
| When a program is linked with a library, whether statically or using |
| a shared library, the combination of the two is legally speaking a |
| combined work, a derivative of the original library. The ordinary |
| General Public License therefore permits such linking only if the |
| entire combination fits its criteria of freedom. The Lesser General |
| Public License permits more lax criteria for linking other code with |
| the library. |
| |
| We call this license the "Lesser" General Public License because it |
| does _Less_ to protect the user's freedom than the ordinary General |
| Public License. It also provides other free software developers Less |
| of an advantage over competing non-free programs. These disadvantages |
| are the reason we use the ordinary General Public License for many |
| libraries. However, the Lesser license provides advantages in certain |
| special circumstances. |
| |
| For example, on rare occasions, there may be a special need to |
| encourage the widest possible use of a certain library, so that it |
| becomes a de-facto standard. To achieve this, non-free programs must be |
| allowed to use the library. A more frequent case is that a free |
| library does the same job as widely used non-free libraries. In this |
| case, there is little to gain by limiting the free library to free |
| software only, so we use the Lesser General Public License. |
| |
| In other cases, permission to use a particular library in non-free |
| programs enables a greater number of people to use a large body of free |
| software. For example, permission to use the GNU C Library in non-free |
| programs enables many more people to use the whole GNU operating |
| system, as well as its variant, the GNU/Linux operating system. |
| |
| Although the Lesser General Public License is Less protective of the |
| users' freedom, it does ensure that the user of a program that is |
| linked with the Library has the freedom and the wherewithal to run that |
| program using a modified version of the Library. |
| |
| The precise terms and conditions for copying, distribution and |
| modification follow. Pay close attention to the difference between a |
| "work based on the library" and a "work that uses the library". The |
| former contains code derived from the library, whereas the latter must |
| be combined with the library in order to run. |
| |
| GNU LESSER GENERAL PUBLIC LICENSE |
| TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION |
| 0. This License Agreement applies to any software library or other |
| program which contains a notice placed by the copyright holder or |
| other authorized party saying it may be distributed under the |
| terms of this Lesser General Public License (also called "this |
| License"). Each licensee is addressed as "you". |
| |
| A "library" means a collection of software functions and/or data |
| prepared so as to be conveniently linked with application programs |
| (which use some of those functions and data) to form executables. |
| |
| The "Library", below, refers to any such software library or work |
| which has been distributed under these terms. A "work based on the |
| Library" means either the Library or any derivative work under |
| copyright law: that is to say, a work containing the Library or a |
| portion of it, either verbatim or with modifications and/or |
| translated straightforwardly into another language. (Hereinafter, |
| translation is included without limitation in the term |
| "modification".) |
| |
| "Source code" for a work means the preferred form of the work for |
| making modifications to it. For a library, complete source code |
| means all the source code for all modules it contains, plus any |
| associated interface definition files, plus the scripts used to |
| control compilation and installation of the library. |
| |
| Activities other than copying, distribution and modification are |
| not covered by this License; they are outside its scope. The act |
| of running a program using the Library is not restricted, and |
| output from such a program is covered only if its contents |
| constitute a work based on the Library (independent of the use of |
| the Library in a tool for writing it). Whether that is true |
| depends on what the Library does and what the program that uses |
| the Library does. |
| |
| 1. You may copy and distribute verbatim copies of the Library's |
| complete source code as you receive it, in any medium, provided |
| that you conspicuously and appropriately publish on each copy an |
| appropriate copyright notice and disclaimer of warranty; keep |
| intact all the notices that refer to this License and to the |
| absence of any warranty; and distribute a copy of this License |
| along with the Library. |
| |
| You may charge a fee for the physical act of transferring a copy, |
| and you may at your option offer warranty protection in exchange |
| for a fee. |
| |
| 2. You may modify your copy or copies of the Library or any portion |
| of it, thus forming a work based on the Library, and copy and |
| distribute such modifications or work under the terms of Section 1 |
| above, provided that you also meet all of these conditions: |
| |
| a. The modified work must itself be a software library. |
| |
| b. You must cause the files modified to carry prominent notices |
| stating that you changed the files and the date of any change. |
| |
| c. You must cause the whole of the work to be licensed at no |
| charge to all third parties under the terms of this License. |
| |
| d. If a facility in the modified Library refers to a function or |
| a table of data to be supplied by an application program that |
| uses the facility, other than as an argument passed when the |
| facility is invoked, then you must make a good faith effort |
| to ensure that, in the event an application does not supply |
| such function or table, the facility still operates, and |
| performs whatever part of its purpose remains meaningful. |
| |
| (For example, a function in a library to compute square roots |
| has a purpose that is entirely well-defined independent of the |
| application. Therefore, Subsection 2d requires that any |
| application-supplied function or table used by this function |
| must be optional: if the application does not supply it, the |
| square root function must still compute square roots.) |
| |
| These requirements apply to the modified work as a whole. If |
| identifiable sections of that work are not derived from the |
| Library, and can be reasonably considered independent and separate |
| works in themselves, then this License, and its terms, do not |
| apply to those sections when you distribute them as separate |
| works. But when you distribute the same sections as part of a |
| whole which is a work based on the Library, the distribution of |
| the whole must be on the terms of this License, whose permissions |
| for other licensees extend to the entire whole, and thus to each |
| and every part regardless of who wrote it. |
| |
| Thus, it is not the intent of this section to claim rights or |
| contest your rights to work written entirely by you; rather, the |
| intent is to exercise the right to control the distribution of |
| derivative or collective works based on the Library. |
| |
| In addition, mere aggregation of another work not based on the |
| Library with the Library (or with a work based on the Library) on |
| a volume of a storage or distribution medium does not bring the |
| other work under the scope of this License. |
| |
| 3. You may opt to apply the terms of the ordinary GNU General Public |
| License instead of this License to a given copy of the Library. |
| To do this, you must alter all the notices that refer to this |
| License, so that they refer to the ordinary GNU General Public |
| License, version 2, instead of to this License. (If a newer |
| version than version 2 of the ordinary GNU General Public License |
| has appeared, then you can specify that version instead if you |
| wish.) Do not make any other change in these notices. |
| |
| Once this change is made in a given copy, it is irreversible for |
| that copy, so the ordinary GNU General Public License applies to |
| all subsequent copies and derivative works made from that copy. |
| |
| This option is useful when you wish to copy part of the code of |
| the Library into a program that is not a library. |
| |
| 4. You may copy and distribute the Library (or a portion or |
| derivative of it, under Section 2) in object code or executable |
| form under the terms of Sections 1 and 2 above provided that you |
| accompany it with the complete corresponding machine-readable |
| source code, which must be distributed under the terms of Sections |
| 1 and 2 above on a medium customarily used for software |
| interchange. |
| |
| If distribution of object code is made by offering access to copy |
| from a designated place, then offering equivalent access to copy |
| the source code from the same place satisfies the requirement to |
| distribute the source code, even though third parties are not |
| compelled to copy the source along with the object code. |
| |
| 5. A program that contains no derivative of any portion of the |
| Library, but is designed to work with the Library by being |
| compiled or linked with it, is called a "work that uses the |
| Library". Such a work, in isolation, is not a derivative work of |
| the Library, and therefore falls outside the scope of this License. |
| |
| However, linking a "work that uses the Library" with the Library |
| creates an executable that is a derivative of the Library (because |
| it contains portions of the Library), rather than a "work that |
| uses the library". The executable is therefore covered by this |
| License. Section 6 states terms for distribution of such |
| executables. |
| |
| When a "work that uses the Library" uses material from a header |
| file that is part of the Library, the object code for the work may |
| be a derivative work of the Library even though the source code is |
| not. Whether this is true is especially significant if the work |
| can be linked without the Library, or if the work is itself a |
| library. The threshold for this to be true is not precisely |
| defined by law. |
| |
| If such an object file uses only numerical parameters, data |
| structure layouts and accessors, and small macros and small inline |
| functions (ten lines or less in length), then the use of the object |
| file is unrestricted, regardless of whether it is legally a |
| derivative work. (Executables containing this object code plus |
| portions of the Library will still fall under Section 6.) |
| |
| Otherwise, if the work is a derivative of the Library, you may |
| distribute the object code for the work under the terms of Section |
| 6. Any executables containing that work also fall under Section 6, |
| whether or not they are linked directly with the Library itself. |
| |
| 6. As an exception to the Sections above, you may also combine or |
| link a "work that uses the Library" with the Library to produce a |
| work containing portions of the Library, and distribute that work |
| under terms of your choice, provided that the terms permit |
| modification of the work for the customer's own use and reverse |
| engineering for debugging such modifications. |
| |
| You must give prominent notice with each copy of the work that the |
| Library is used in it and that the Library and its use are covered |
| by this License. You must supply a copy of this License. If the |
| work during execution displays copyright notices, you must include |
| the copyright notice for the Library among them, as well as a |
| reference directing the user to the copy of this License. Also, |
| you must do one of these things: |
| |
| a. Accompany the work with the complete corresponding |
| machine-readable source code for the Library including |
| whatever changes were used in the work (which must be |
| distributed under Sections 1 and 2 above); and, if the work |
| is an executable linked with the Library, with the complete |
| machine-readable "work that uses the Library", as object code |
| and/or source code, so that the user can modify the Library |
| and then relink to produce a modified executable containing |
| the modified Library. (It is understood that the user who |
| changes the contents of definitions files in the Library will |
| not necessarily be able to recompile the application to use |
| the modified definitions.) |
| |
| b. Use a suitable shared library mechanism for linking with the |
| Library. A suitable mechanism is one that (1) uses at run |
| time a copy of the library already present on the user's |
| computer system, rather than copying library functions into |
| the executable, and (2) will operate properly with a modified |
| version of the library, if the user installs one, as long as |
| the modified version is interface-compatible with the version |
| that the work was made with. |
| |
| c. Accompany the work with a written offer, valid for at least |
| three years, to give the same user the materials specified in |
| Subsection 6a, above, for a charge no more than the cost of |
| performing this distribution. |
| |
| d. If distribution of the work is made by offering access to copy |
| from a designated place, offer equivalent access to copy the |
| above specified materials from the same place. |
| |
| e. Verify that the user has already received a copy of these |
| materials or that you have already sent this user a copy. |
| |
| For an executable, the required form of the "work that uses the |
| Library" must include any data and utility programs needed for |
| reproducing the executable from it. However, as a special |
| exception, the materials to be distributed need not include |
| anything that is normally distributed (in either source or binary |
| form) with the major components (compiler, kernel, and so on) of |
| the operating system on which the executable runs, unless that |
| component itself accompanies the executable. |
| |
| It may happen that this requirement contradicts the license |
| restrictions of other proprietary libraries that do not normally |
| accompany the operating system. Such a contradiction means you |
| cannot use both them and the Library together in an executable |
| that you distribute. |
| |
| 7. You may place library facilities that are a work based on the |
| Library side-by-side in a single library together with other |
| library facilities not covered by this License, and distribute |
| such a combined library, provided that the separate distribution |
| of the work based on the Library and of the other library |
| facilities is otherwise permitted, and provided that you do these |
| two things: |
| |
| a. Accompany the combined library with a copy of the same work |
| based on the Library, uncombined with any other library |
| facilities. This must be distributed under the terms of the |
| Sections above. |
| |
| b. Give prominent notice with the combined library of the fact |
| that part of it is a work based on the Library, and explaining |
| where to find the accompanying uncombined form of the same |
| work. |
| |
| 8. You may not copy, modify, sublicense, link with, or distribute the |
| Library except as expressly provided under this License. Any |
| attempt otherwise to copy, modify, sublicense, link with, or |
| distribute the Library is void, and will automatically terminate |
| your rights under this License. However, parties who have |
| received copies, or rights, from you under this License will not |
| have their licenses terminated so long as such parties remain in |
| full compliance. |
| |
| 9. You are not required to accept this License, since you have not |
| signed it. However, nothing else grants you permission to modify |
| or distribute the Library or its derivative works. These actions |
| are prohibited by law if you do not accept this License. |
| Therefore, by modifying or distributing the Library (or any work |
| based on the Library), you indicate your acceptance of this |
| License to do so, and all its terms and conditions for copying, |
| distributing or modifying the Library or works based on it. |
| |
| 10. Each time you redistribute the Library (or any work based on the |
| Library), the recipient automatically receives a license from the |
| original licensor to copy, distribute, link with or modify the |
| Library subject to these terms and conditions. You may not impose |
| any further restrictions on the recipients' exercise of the rights |
| granted herein. You are not responsible for enforcing compliance |
| by third parties with this License. |
| |
| 11. If, as a consequence of a court judgment or allegation of patent |
| infringement or for any other reason (not limited to patent |
| issues), conditions are imposed on you (whether by court order, |
| agreement or otherwise) that contradict the conditions of this |
| License, they do not excuse you from the conditions of this |
| License. If you cannot distribute so as to satisfy simultaneously |
| your obligations under this License and any other pertinent |
| obligations, then as a consequence you may not distribute the |
| Library at all. For example, if a patent license would not permit |
| royalty-free redistribution of the Library by all those who |
| receive copies directly or indirectly through you, then the only |
| way you could satisfy both it and this License would be to refrain |
| entirely from distribution of the Library. |
| |
| If any portion of this section is held invalid or unenforceable |
| under any particular circumstance, the balance of the section is |
| intended to apply, and the section as a whole is intended to apply |
| in other circumstances. |
| |
| It is not the purpose of this section to induce you to infringe any |
| patents or other property right claims or to contest validity of |
| any such claims; this section has the sole purpose of protecting |
| the integrity of the free software distribution system which is |
| implemented by public license practices. Many people have made |
| generous contributions to the wide range of software distributed |
| through that system in reliance on consistent application of that |
| system; it is up to the author/donor to decide if he or she is |
| willing to distribute software through any other system and a |
| licensee cannot impose that choice. |
| |
| This section is intended to make thoroughly clear what is believed |
| to be a consequence of the rest of this License. |
| |
| 12. If the distribution and/or use of the Library is restricted in |
| certain countries either by patents or by copyrighted interfaces, |
| the original copyright holder who places the Library under this |
| License may add an explicit geographical distribution limitation |
| excluding those countries, so that distribution is permitted only |
| in or among countries not thus excluded. In such case, this |
| License incorporates the limitation as if written in the body of |
| this License. |
| |
| 13. The Free Software Foundation may publish revised and/or new |
| versions of the Lesser General Public License from time to time. |
| Such new versions will be similar in spirit to the present version, |
| but may differ in detail to address new problems or concerns. |
| |
| Each version is given a distinguishing version number. If the |
| Library specifies a version number of this License which applies |
| to it and "any later version", you have the option of following |
| the terms and conditions either of that version or of any later |
| version published by the Free Software Foundation. If the Library |
| does not specify a license version number, you may choose any |
| version ever published by the Free Software Foundation. |
| |
| 14. If you wish to incorporate parts of the Library into other free |
| programs whose distribution conditions are incompatible with these, |
| write to the author to ask for permission. For software which is |
| copyrighted by the Free Software Foundation, write to the Free |
| Software Foundation; we sometimes make exceptions for this. Our |
| decision will be guided by the two goals of preserving the free |
| status of all derivatives of our free software and of promoting |
| the sharing and reuse of software generally. |
| |
| NO WARRANTY |
| 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO |
| WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE |
| LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT |
| HOLDERS AND/OR OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT |
| WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT |
| NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND |
| FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE |
| QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH YOU. SHOULD THE |
| LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY |
| SERVICING, REPAIR OR CORRECTION. |
| |
| 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN |
| WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY |
| MODIFY AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE |
| LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, |
| INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR |
| INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF |
| DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU |
| OR THIRD PARTIES OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY |
| OTHER SOFTWARE), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN |
| ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. |
| |
| END OF TERMS AND CONDITIONS |
| G.0.2 How to Apply These Terms to Your New Libraries |
| ---------------------------------------------------- |
| |
| If you develop a new library, and you want it to be of the greatest |
| possible use to the public, we recommend making it free software that |
| everyone can redistribute and change. You can do so by permitting |
| redistribution under these terms (or, alternatively, under the terms of |
| the ordinary General Public License). |
| |
| To apply these terms, attach the following notices to the library. |
| It is safest to attach them to the start of each source file to most |
| effectively convey the exclusion of warranty; and each file should have |
| at least the "copyright" line and a pointer to where the full notice is |
| found. |
| |
| ONE LINE TO GIVE THE LIBRARY'S NAME AND AN IDEA OF WHAT IT DOES. |
| Copyright (C) YEAR NAME OF AUTHOR |
| |
| This library is free software; you can redistribute it and/or modify it |
| under the terms of the GNU Lesser General Public License as published by |
| the Free Software Foundation; either version 2.1 of the License, or (at |
| your option) any later version. |
| |
| This library is distributed in the hope that it will be useful, but |
| WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| Lesser General Public License for more details. |
| |
| You should have received a copy of the GNU Lesser General Public |
| License along with this library; if not, write to the Free Software |
| Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, |
| USA. |
| |
| Also add information on how to contact you by electronic and paper |
| mail. |
| |
| You should also get your employer (if you work as a programmer) or |
| your school, if any, to sign a "copyright disclaimer" for the library, |
| if necessary. Here is a sample; alter the names: |
| |
| Yoyodyne, Inc., hereby disclaims all copyright interest in the library |
| `Frob' (a library for tweaking knobs) written by James Random Hacker. |
| |
| SIGNATURE OF TY COON, 1 April 1990 |
| Ty Coon, President of Vice |
| |
| That's all there is to it! |
| |
| |
| File: libc.info, Node: Documentation License, Next: Concept Index, Prev: Copying, Up: Top |
| |
| Appendix H GNU Free Documentation License |
| ***************************************** |
| |
| Version 1.1, March 2000 |
| |
| Copyright (C) 2000 Free Software Foundation, Inc. |
| 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA |
| |
| Everyone is permitted to copy and distribute verbatim copies |
| of this license document, but changing it is not allowed. |
| |
| 0. PREAMBLE |
| |
| The purpose of this License is to make a manual, textbook, or other |
| written document "free" in the sense of freedom: to assure everyone |
| the effective freedom to copy and redistribute it, with or without |
| modifying it, either commercially or noncommercially. Secondarily, |
| this License preserves for the author and publisher a way to get |
| credit for their work, while not being considered responsible for |
| modifications made by others. |
| |
| This License is a kind of "copyleft", which means that derivative |
| works of the document must themselves be free in the same sense. |
| It complements the GNU General Public License, which is a copyleft |
| license designed for free software. |
| |
| We have designed this License in order to use it for manuals for |
| free software, because free software needs free documentation: a |
| free program should come with manuals providing the same freedoms |
| that the software does. But this License is not limited to |
| software manuals; it can be used for any textual work, regardless |
| of subject matter or whether it is published as a printed book. |
| We recommend this License principally for works whose purpose is |
| instruction or reference. |
| |
| 1. APPLICABILITY AND DEFINITIONS |
| |
| This License applies to any manual or other work that contains a |
| notice placed by the copyright holder saying it can be distributed |
| under the terms of this License. The "Document", below, refers to |
| any such manual or work. Any member of the public is a licensee, |
| and is addressed as "you". |
| |
| A "Modified Version" of the Document means any work containing the |
| Document or a portion of it, either copied verbatim, or with |
| modifications and/or translated into another language. |
| |
| A "Secondary Section" is a named appendix or a front-matter |
| section of the Document that deals exclusively with the |
| relationship of the publishers or authors of the Document to the |
| Document's overall subject (or to related matters) and contains |
| nothing that could fall directly within that overall subject. |
| (For example, if the Document is in part a textbook of |
| mathematics, a Secondary Section may not explain any mathematics.) |
| The relationship could be a matter of historical connection with |
| the subject or with related matters, or of legal, commercial, |
| philosophical, ethical or political position regarding them. |
| |
| The "Invariant Sections" are certain Secondary Sections whose |
| titles are designated, as being those of Invariant Sections, in |
| the notice that says that the Document is released under this |
| License. |
| |
| The "Cover Texts" are certain short passages of text that are |
| listed, as Front-Cover Texts or Back-Cover Texts, in the notice |
| that says that the Document is released under this License. |
| |
| A "Transparent" copy of the Document means a machine-readable copy, |
| represented in a format whose specification is available to the |
| general public, whose contents can be viewed and edited directly |
| and straightforwardly with generic text editors or (for images |
| composed of pixels) generic paint programs or (for drawings) some |
| widely available drawing editor, and that is suitable for input to |
| text formatters or for automatic translation to a variety of |
| formats suitable for input to text formatters. A copy made in an |
| otherwise Transparent file format whose markup has been designed |
| to thwart or discourage subsequent modification by readers is not |
| Transparent. A copy that is not "Transparent" is called "Opaque". |
| |
| Examples of suitable formats for Transparent copies include plain |
| ASCII without markup, Texinfo input format, LaTeX input format, |
| SGML or XML using a publicly available DTD, and |
| standard-conforming simple HTML designed for human modification. |
| Opaque formats include PostScript, PDF, proprietary formats that |
| can be read and edited only by proprietary word processors, SGML |
| or XML for which the DTD and/or processing tools are not generally |
| available, and the machine-generated HTML produced by some word |
| processors for output purposes only. |
| |
| The "Title Page" means, for a printed book, the title page itself, |
| plus such following pages as are needed to hold, legibly, the |
| material this License requires to appear in the title page. For |
| works in formats which do not have any title page as such, "Title |
| Page" means the text near the most prominent appearance of the |
| work's title, preceding the beginning of the body of the text. |
| |
| 2. VERBATIM COPYING |
| |
| You may copy and distribute the Document in any medium, either |
| commercially or noncommercially, provided that this License, the |
| copyright notices, and the license notice saying this License |
| applies to the Document are reproduced in all copies, and that you |
| add no other conditions whatsoever to those of this License. You |
| may not use technical measures to obstruct or control the reading |
| or further copying of the copies you make or distribute. However, |
| you may accept compensation in exchange for copies. If you |
| distribute a large enough number of copies you must also follow |
| the conditions in section 3. |
| |
| You may also lend copies, under the same conditions stated above, |
| and you may publicly display copies. |
| |
| 3. COPYING IN QUANTITY |
| |
| If you publish printed copies of the Document numbering more than |
| 100, and the Document's license notice requires Cover Texts, you |
| must enclose the copies in covers that carry, clearly and legibly, |
| all these Cover Texts: Front-Cover Texts on the front cover, and |
| Back-Cover Texts on the back cover. Both covers must also clearly |
| and legibly identify you as the publisher of these copies. The |
| front cover must present the full title with all words of the |
| title equally prominent and visible. You may add other material |
| on the covers in addition. Copying with changes limited to the |
| covers, as long as they preserve the title of the Document and |
| satisfy these conditions, can be treated as verbatim copying in |
| other respects. |
| |
| If the required texts for either cover are too voluminous to fit |
| legibly, you should put the first ones listed (as many as fit |
| reasonably) on the actual cover, and continue the rest onto |
| adjacent pages. |
| |
| If you publish or distribute Opaque copies of the Document |
| numbering more than 100, you must either include a |
| machine-readable Transparent copy along with each Opaque copy, or |
| state in or with each Opaque copy a publicly-accessible |
| computer-network location containing a complete Transparent copy |
| of the Document, free of added material, which the general |
| network-using public has access to download anonymously at no |
| charge using public-standard network protocols. If you use the |
| latter option, you must take reasonably prudent steps, when you |
| begin distribution of Opaque copies in quantity, to ensure that |
| this Transparent copy will remain thus accessible at the stated |
| location until at least one year after the last time you |
| distribute an Opaque copy (directly or through your agents or |
| retailers) of that edition to the public. |
| |
| It is requested, but not required, that you contact the authors of |
| the Document well before redistributing any large number of |
| copies, to give them a chance to provide you with an updated |
| version of the Document. |
| |
| 4. MODIFICATIONS |
| |
| You may copy and distribute a Modified Version of the Document |
| under the conditions of sections 2 and 3 above, provided that you |
| release the Modified Version under precisely this License, with |
| the Modified Version filling the role of the Document, thus |
| licensing distribution and modification of the Modified Version to |
| whoever possesses a copy of it. In addition, you must do these |
| things in the Modified Version: |
| |
| A. Use in the Title Page (and on the covers, if any) a title |
| distinct from that of the Document, and from those of |
| previous versions (which should, if there were any, be listed |
| in the History section of the Document). You may use the |
| same title as a previous version if the original publisher of |
| that version gives permission. |
| |
| B. List on the Title Page, as authors, one or more persons or |
| entities responsible for authorship of the modifications in |
| the Modified Version, together with at least five of the |
| principal authors of the Document (all of its principal |
| authors, if it has less than five). |
| |
| C. State on the Title page the name of the publisher of the |
| Modified Version, as the publisher. |
| |
| D. Preserve all the copyright notices of the Document. |
| |
| E. Add an appropriate copyright notice for your modifications |
| adjacent to the other copyright notices. |
| |
| F. Include, immediately after the copyright notices, a license |
| notice giving the public permission to use the Modified |
| Version under the terms of this License, in the form shown in |
| the Addendum below. |
| |
| G. Preserve in that license notice the full lists of Invariant |
| Sections and required Cover Texts given in the Document's |
| license notice. |
| |
| H. Include an unaltered copy of this License. |
| |
| I. Preserve the section entitled "History", and its title, and |
| add to it an item stating at least the title, year, new |
| authors, and publisher of the Modified Version as given on |
| the Title Page. If there is no section entitled "History" in |
| the Document, create one stating the title, year, authors, |
| and publisher of the Document as given on its Title Page, |
| then add an item describing the Modified Version as stated in |
| the previous sentence. |
| |
| J. Preserve the network location, if any, given in the Document |
| for public access to a Transparent copy of the Document, and |
| likewise the network locations given in the Document for |
| previous versions it was based on. These may be placed in |
| the "History" section. You may omit a network location for a |
| work that was published at least four years before the |
| Document itself, or if the original publisher of the version |
| it refers to gives permission. |
| |
| K. In any section entitled "Acknowledgments" or "Dedications", |
| preserve the section's title, and preserve in the section all |
| the substance and tone of each of the contributor |
| acknowledgments and/or dedications given therein. |
| |
| L. Preserve all the Invariant Sections of the Document, |
| unaltered in their text and in their titles. Section numbers |
| or the equivalent are not considered part of the section |
| titles. |
| |
| M. Delete any section entitled "Endorsements". Such a section |
| may not be included in the Modified Version. |
| |
| N. Do not retitle any existing section as "Endorsements" or to |
| conflict in title with any Invariant Section. |
| |
| If the Modified Version includes new front-matter sections or |
| appendices that qualify as Secondary Sections and contain no |
| material copied from the Document, you may at your option |
| designate some or all of these sections as invariant. To do this, |
| add their titles to the list of Invariant Sections in the Modified |
| Version's license notice. These titles must be distinct from any |
| other section titles. |
| |
| You may add a section entitled "Endorsements", provided it contains |
| nothing but endorsements of your Modified Version by various |
| parties--for example, statements of peer review or that the text |
| has been approved by an organization as the authoritative |
| definition of a standard. |
| |
| You may add a passage of up to five words as a Front-Cover Text, |
| and a passage of up to 25 words as a Back-Cover Text, to the end |
| of the list of Cover Texts in the Modified Version. Only one |
| passage of Front-Cover Text and one of Back-Cover Text may be |
| added by (or through arrangements made by) any one entity. If the |
| Document already includes a cover text for the same cover, |
| previously added by you or by arrangement made by the same entity |
| you are acting on behalf of, you may not add another; but you may |
| replace the old one, on explicit permission from the previous |
| publisher that added the old one. |
| |
| The author(s) and publisher(s) of the Document do not by this |
| License give permission to use their names for publicity for or to |
| assert or imply endorsement of any Modified Version. |
| |
| 5. COMBINING DOCUMENTS |
| |
| You may combine the Document with other documents released under |
| this License, under the terms defined in section 4 above for |
| modified versions, provided that you include in the combination |
| all of the Invariant Sections of all of the original documents, |
| unmodified, and list them all as Invariant Sections of your |
| combined work in its license notice. |
| |
| The combined work need only contain one copy of this License, and |
| multiple identical Invariant Sections may be replaced with a single |
| copy. If there are multiple Invariant Sections with the same name |
| but different contents, make the title of each such section unique |
| by adding at the end of it, in parentheses, the name of the |
| original author or publisher of that section if known, or else a |
| unique number. Make the same adjustment to the section titles in |
| the list of Invariant Sections in the license notice of the |
| combined work. |
| |
| In the combination, you must combine any sections entitled |
| "History" in the various original documents, forming one section |
| entitled "History"; likewise combine any sections entitled |
| "Acknowledgments", and any sections entitled "Dedications". You |
| must delete all sections entitled "Endorsements." |
| |
| 6. COLLECTIONS OF DOCUMENTS |
| |
| You may make a collection consisting of the Document and other |
| documents released under this License, and replace the individual |
| copies of this License in the various documents with a single copy |
| that is included in the collection, provided that you follow the |
| rules of this License for verbatim copying of each of the |
| documents in all other respects. |
| |
| You may extract a single document from such a collection, and |
| distribute it individually under this License, provided you insert |
| a copy of this License into the extracted document, and follow |
| this License in all other respects regarding verbatim copying of |
| that document. |
| |
| 7. AGGREGATION WITH INDEPENDENT WORKS |
| |
| A compilation of the Document or its derivatives with other |
| separate and independent documents or works, in or on a volume of |
| a storage or distribution medium, does not as a whole count as a |
| Modified Version of the Document, provided no compilation |
| copyright is claimed for the compilation. Such a compilation is |
| called an "aggregate", and this License does not apply to the |
| other self-contained works thus compiled with the Document, on |
| account of their being thus compiled, if they are not themselves |
| derivative works of the Document. |
| |
| If the Cover Text requirement of section 3 is applicable to these |
| copies of the Document, then if the Document is less than one |
| quarter of the entire aggregate, the Document's Cover Texts may be |
| placed on covers that surround only the Document within the |
| aggregate. Otherwise they must appear on covers around the whole |
| aggregate. |
| |
| 8. TRANSLATION |
| |
| Translation is considered a kind of modification, so you may |
| distribute translations of the Document under the terms of section |
| 4. Replacing Invariant Sections with translations requires special |
| permission from their copyright holders, but you may include |
| translations of some or all Invariant Sections in addition to the |
| original versions of these Invariant Sections. You may include a |
| translation of this License provided that you also include the |
| original English version of this License. In case of a |
| disagreement between the translation and the original English |
| version of this License, the original English version will prevail. |
| |
| 9. TERMINATION |
| |
| You may not copy, modify, sublicense, or distribute the Document |
| except as expressly provided for under this License. Any other |
| attempt to copy, modify, sublicense or distribute the Document is |
| void, and will automatically terminate your rights under this |
| License. However, parties who have received copies, or rights, |
| from you under this License will not have their licenses |
| terminated so long as such parties remain in full compliance. |
| |
| 10. FUTURE REVISIONS OF THIS LICENSE |
| |
| The Free Software Foundation may publish new, revised versions of |
| the GNU Free Documentation License from time to time. Such new |
| versions will be similar in spirit to the present version, but may |
| differ in detail to address new problems or concerns. See |
| `http://www.gnu.org/copyleft/'. |
| |
| Each version of the License is given a distinguishing version |
| number. If the Document specifies that a particular numbered |
| version of this License "or any later version" applies to it, you |
| have the option of following the terms and conditions either of |
| that specified version or of any later version that has been |
| published (not as a draft) by the Free Software Foundation. If |
| the Document does not specify a version number of this License, |
| you may choose any version ever published (not as a draft) by the |
| Free Software Foundation. |
| |
| H.0.1 ADDENDUM: How to use this License for your documents |
| ---------------------------------------------------------- |
| |
| To use this License in a document you have written, include a copy of |
| the License in the document and put the following copyright and license |
| notices just after the title page: |
| |
| Copyright (C) YEAR YOUR NAME. |
| Permission is granted to copy, distribute and/or modify this document |
| under the terms of the GNU Free Documentation License, Version 1.1 |
| or any later version published by the Free Software Foundation; |
| with the Invariant Sections being LIST THEIR TITLES, with the |
| Front-Cover Texts being LIST, and with the Back-Cover Texts being LIST. |
| A copy of the license is included in the section entitled ``GNU |
| Free Documentation License''. |
| |
| If you have no Invariant Sections, write "with no Invariant Sections" |
| instead of saying which ones are invariant. If you have no Front-Cover |
| Texts, write "no Front-Cover Texts" instead of "Front-Cover Texts being |
| LIST"; likewise for Back-Cover Texts. |
| |
| If your document contains nontrivial examples of program code, we |
| recommend releasing these examples in parallel under your choice of |
| free software license, such as the GNU General Public License, to |
| permit their use in free software. |
| |
| |
| File: libc.info, Node: Concept Index, Next: Type Index, Prev: Documentation License, Up: Top |
| |
| Concept Index |
| ************* |
| |
| [index] |
| * Menu: |
| |
| * /etc/hostname: Host Identification. (line 86) |
| * /etc/nsswitch.conf: NSS Configuration File. |
| (line 6) |
| * 4.N BSD Unix: Berkeley Unix. (line 6) |
| * __va_copy: Copying and Concatenation. |
| (line 447) |
| * _POSIX_OPTION_ORDER environment variable.: Standard Environment. |
| (line 104) |
| * _POSIX_SAVED_IDS: How Change Persona. (line 6) |
| * abort signal: Program Error Signals. |
| (line 135) |
| * aborting a program: Aborting a Program. (line 6) |
| * absolute file name: File Name Resolution. |
| (line 19) |
| * absolute priority: Absolute Priority. (line 6) |
| * absolute value functions: Absolute Value. (line 6) |
| * accepting connections: Accepting Connections. |
| (line 6) |
| * access permission for a file: Access Permission. (line 6) |
| * access, testing for: Testing File Access. (line 6) |
| * accessing directories: Accessing Directories. |
| (line 6) |
| * address of socket: Socket Addresses. (line 6) |
| * address space <1>: Program Basics. (line 6) |
| * address space: Memory Subsystem. (line 6) |
| * alarm signal: Alarm Signals. (line 19) |
| * alarms, setting: Setting an Alarm. (line 10) |
| * alignment (in obstacks): Obstacks Data Alignment. |
| (line 6) |
| * alignment (with malloc): Aligned Memory Blocks. |
| (line 6) |
| * alloca disadvantages: Disadvantages of Alloca. |
| (line 6) |
| * alloca function: Variable Size Automatic. |
| (line 6) |
| * allocating pseudo-terminals: Allocation. (line 6) |
| * allocation (obstacks): Allocation in an Obstack. |
| (line 6) |
| * allocation debugging: Allocation Debugging. |
| (line 6) |
| * allocation hooks, for malloc: Hooks for Malloc. (line 6) |
| * allocation of memory with malloc: Basic Allocation. (line 6) |
| * allocation size of string: Representation of Strings. |
| (line 56) |
| * allocation statistics: Statistics of Malloc. |
| (line 6) |
| * alphabetic character <1>: Classification of Wide Characters. |
| (line 80) |
| * alphabetic character: Classification of Characters. |
| (line 35) |
| * alphanumeric character <1>: Classification of Wide Characters. |
| (line 68) |
| * alphanumeric character: Classification of Characters. |
| (line 48) |
| * append-access files: File Position. (line 29) |
| * argc (program argument count): Program Arguments. (line 16) |
| * argp (program argument parser): Argp. (line 6) |
| * argp parser functions: Argp Parser Functions. |
| (line 13) |
| * ARGP_HELP_FMT environment variable: Argp User Customization. |
| (line 6) |
| * argument parsing with argp: Argp. (line 6) |
| * argument promotion: Calling Variadics. (line 27) |
| * argument vectors, null-character separated: Argz and Envz Vectors. |
| (line 6) |
| * arguments (variadic functions): Receiving Arguments. (line 6) |
| * arguments, how many: How Many Arguments. (line 6) |
| * arguments, to program: Program Arguments. (line 6) |
| * argv (program argument vector): Program Arguments. (line 16) |
| * argz vectors (string vectors): Argz and Envz Vectors. |
| (line 6) |
| * arithmetic expansion: Expansion Stages. (line 22) |
| * array comparison functions: String/Array Comparison. |
| (line 6) |
| * array copy functions: Copying and Concatenation. |
| (line 10) |
| * array search function: Array Search Function. |
| (line 6) |
| * array sort function: Array Sort Function. (line 6) |
| * ASCII character: Classification of Characters. |
| (line 103) |
| * assertions: Consistency Checking. |
| (line 6) |
| * attributes of a file: Attribute Meanings. (line 6) |
| * automatic freeing: Variable Size Automatic. |
| (line 6) |
| * automatic memory allocation: Memory Allocation and C. |
| (line 19) |
| * automatic storage class: Memory Allocation and C. |
| (line 19) |
| * automatic storage with variable size: Variable Size Automatic. |
| (line 6) |
| * background job: Concepts of Job Control. |
| (line 49) |
| * background job, launching: Foreground and Background. |
| (line 62) |
| * backtrace: Backtraces. (line 6) |
| * backtrace_fd: Backtraces. (line 6) |
| * backtrace_symbols: Backtraces. (line 6) |
| * base (of floating point number): Floating Point Concepts. |
| (line 20) |
| * baud rate: Line Speed. (line 6) |
| * Berkeley Unix: Berkeley Unix. (line 6) |
| * Bessel functions: Special Functions. (line 6) |
| * bias (of floating point number exponent): Floating Point Concepts. |
| (line 27) |
| * big-endian: Byte Order. (line 6) |
| * binary I/O to a stream: Block Input/Output. (line 9) |
| * binary search function (for arrays): Array Search Function. |
| (line 6) |
| * binary stream: Binary Streams. (line 13) |
| * binding a socket address: Socket Addresses. (line 6) |
| * blank character <1>: Classification of Wide Characters. |
| (line 221) |
| * blank character: Classification of Characters. |
| (line 85) |
| * block I/O to a stream: Block Input/Output. (line 9) |
| * blocked signals: Delivery of Signal. (line 6) |
| * blocked signals, checking for: Checking for Pending Signals. |
| (line 6) |
| * blocking signals: Blocking Signals. (line 6) |
| * blocking signals, in a handler: Blocking for Handler. |
| (line 6) |
| * bootstrapping, and services: Actions in the NSS configuration. |
| (line 72) |
| * break condition, detecting: Input Modes. (line 58) |
| * break condition, generating: Line Control. (line 14) |
| * breaking a string into tokens: Finding Tokens in a String. |
| (line 6) |
| * broken pipe signal: Operation Error Signals. |
| (line 13) |
| * broken-down time <1>: Broken-down Time. (line 6) |
| * broken-down time: Calendar Time. (line 26) |
| * BSD compatibility library: Process Group Functions. |
| (line 55) |
| * BSD compatibility library.: Feature Test Macros. (line 88) |
| * BSD Unix: Berkeley Unix. (line 6) |
| * buffering of streams: Stream Buffering. (line 6) |
| * buffering, controlling: Controlling Buffering. |
| (line 8) |
| * bugs, reporting: Reporting Bugs. (line 6) |
| * bus error: Program Error Signals. |
| (line 133) |
| * butterfly: Misc FP Arithmetic. (line 43) |
| * byte order conversion, for socket: Byte Order. (line 6) |
| * byte stream: Socket Concepts. (line 12) |
| * C++ streams: Streams and I18N. (line 30) |
| * calendar time: Time Basics. (line 13) |
| * calendar time and broken-down time: Broken-down Time. (line 6) |
| * calendar, Gregorian: Calendar Time. (line 26) |
| * calling variadic functions: Calling Variadics. (line 6) |
| * canonical input processing: Canonical or Not. (line 9) |
| * capacity limits, POSIX: General Limits. (line 6) |
| * carrier detect: Control Modes. (line 21) |
| * case conversion of characters: Case Conversion. (line 6) |
| * catching signals: Delivery of Signal. (line 13) |
| * categories for locales: Locale Categories. (line 6) |
| * change working directory: Working Directory. (line 6) |
| * changing the locale: Setting the Locale. (line 18) |
| * changing the size of a block (malloc): Changing Block Size. (line 6) |
| * changing the size of a block (obstacks): Growing Objects. (line 6) |
| * channels: Stream/Descriptor Precautions. |
| (line 6) |
| * character case conversion: Case Conversion. (line 6) |
| * character predicates: Classification of Characters. |
| (line 6) |
| * character testing: Classification of Characters. |
| (line 6) |
| * checking for pending signals: Checking for Pending Signals. |
| (line 6) |
| * child process <1>: Process Creation Concepts. |
| (line 15) |
| * child process <2>: Processes. (line 13) |
| * child process: Processor Time. (line 31) |
| * child process signal: Job Control Signals. (line 14) |
| * chunks: Obstack Chunks. (line 6) |
| * classes, floating-point: Floating Point Classes. |
| (line 6) |
| * classification of characters: Classification of Characters. |
| (line 6) |
| * cleaning up a stream: Linked Channels. (line 15) |
| * clearing terminal input queue: Line Control. (line 59) |
| * client: Connections. (line 6) |
| * clock ticks: Processor And CPU Time. |
| (line 19) |
| * clock, high accuracy: High Accuracy Clock. (line 6) |
| * close-on-exec (file descriptor flag): Descriptor Flags. (line 52) |
| * closing a file descriptor: Opening and Closing Files. |
| (line 6) |
| * closing a socket: Closing a Socket. (line 6) |
| * closing a stream: Closing Streams. (line 6) |
| * collating strings: Collation Functions. (line 6) |
| * combining locales: Choosing Locale. (line 17) |
| * command argument syntax: Argument Syntax. (line 6) |
| * command arguments, parsing: Parsing Program Arguments. |
| (line 6) |
| * command line arguments: Program Arguments. (line 6) |
| * command substitution: Expansion Stages. (line 18) |
| * communication style (of a socket): Socket Concepts. (line 6) |
| * comparing strings and arrays: String/Array Comparison. |
| (line 6) |
| * Comparison Function: Comparison Functions. |
| (line 6) |
| * compiling: Configuring and compiling. |
| (line 6) |
| * complex exponentiation functions: Exponents and Logarithms. |
| (line 160) |
| * complex logarithm functions: Exponents and Logarithms. |
| (line 160) |
| * complex numbers: Complex Numbers. (line 6) |
| * complex trigonometric functions: Trig Functions. (line 56) |
| * concatenating strings: Copying and Concatenation. |
| (line 10) |
| * configuring: Configuring and compiling. |
| (line 6) |
| * conjugate complex numbers: Operations on Complex. |
| (line 6) |
| * connecting a socket: Connecting. (line 6) |
| * connection: Connections. (line 6) |
| * consistency checking: Consistency Checking. |
| (line 6) |
| * consistency checking, of heap: Heap Consistency Checking. |
| (line 6) |
| * constants <1>: Mathematical Constants. |
| (line 6) |
| * constants: Memory Concepts. (line 67) |
| * continue signal: Job Control Signals. (line 28) |
| * control character <1>: Classification of Wide Characters. |
| (line 96) |
| * control character: Classification of Characters. |
| (line 99) |
| * control operations on files: Control Operations. (line 6) |
| * controlling process: Controlling Terminal. |
| (line 13) |
| * controlling terminal: Concepts of Job Control. |
| (line 42) |
| * controlling terminal, access to: Access to the Terminal. |
| (line 6) |
| * controlling terminal, determining: Identifying the Terminal. |
| (line 6) |
| * controlling terminal, setting: Open-time Flags. (line 54) |
| * conversion specifications (printf): Formatted Output Basics. |
| (line 14) |
| * conversion specifications (scanf): Formatted Input Basics. |
| (line 18) |
| * converting byte order: Byte Order. (line 6) |
| * converting case of characters: Case Conversion. (line 6) |
| * converting file descriptor to stream: Descriptors and Streams. |
| (line 6) |
| * converting floats to integers: Rounding Functions. (line 6) |
| * converting group ID to group name: Lookup Group. (line 6) |
| * converting group name to group ID: Lookup Group. (line 6) |
| * converting host address to name: Host Names. (line 6) |
| * converting host name to address: Host Names. (line 6) |
| * converting network name to network number: Networks Database. |
| (line 6) |
| * converting network number to network name: Networks Database. |
| (line 6) |
| * converting port number to service name: Services Database. (line 6) |
| * converting service name to port number: Services Database. (line 6) |
| * converting string to collation order: Collation Functions. (line 74) |
| * converting strings to numbers: Parsing of Numbers. (line 6) |
| * converting user ID to user name: Lookup User. (line 6) |
| * converting user name to user ID: Lookup User. (line 6) |
| * cookie, for custom stream: Streams and Cookies. (line 6) |
| * copy-on-write page fault: Locked Memory Details. |
| (line 40) |
| * copying strings and arrays: Copying and Concatenation. |
| (line 10) |
| * cpu priority: Priority. (line 6) |
| * CPU time <1>: Processor Time. (line 9) |
| * CPU time <2>: Processor And CPU Time. |
| (line 19) |
| * CPU time: Time Basics. (line 37) |
| * create on open (file status flag): Open-time Flags. (line 22) |
| * creating a directory: Creating Directories. |
| (line 6) |
| * creating a FIFO special file: FIFO Special Files. (line 6) |
| * creating a pipe: Creating a Pipe. (line 6) |
| * creating a pipe to a subprocess: Pipe to a Subprocess. |
| (line 6) |
| * creating a process: Process Creation Concepts. |
| (line 15) |
| * creating a socket: Creating a Socket. (line 6) |
| * creating a socket pair: Socket Pairs. (line 6) |
| * creating special files: Making Special Files. |
| (line 6) |
| * cube root function: Exponents and Logarithms. |
| (line 130) |
| * currency symbols: Currency Symbol. (line 6) |
| * current limit: Limits on Resources. (line 17) |
| * current working directory: Working Directory. (line 6) |
| * custom streams: Custom Streams. (line 6) |
| * customizing printf: Customizing Printf. (line 6) |
| * data loss on sockets: Socket Concepts. (line 17) |
| * databases: Name Service Switch. (line 6) |
| * datagram socket: Datagrams. (line 6) |
| * datagrams, transmitting: Sending Datagrams. (line 6) |
| * date: Time Basics. (line 16) |
| * Daylight Saving Time: Broken-down Time. (line 62) |
| * decimal digit character: Classification of Characters. |
| (line 45) |
| * decimal-point separator: General Numeric. (line 13) |
| * declaration (compared to definition): Header Files. (line 17) |
| * declaring variadic functions: Calling Variadics. (line 6) |
| * decompose complex numbers: Operations on Complex. |
| (line 6) |
| * default action (for a signal): Delivery of Signal. (line 13) |
| * default action for a signal: Basic Signal Handling. |
| (line 35) |
| * default argument promotions: Calling Variadics. (line 27) |
| * default value, and NSS: Notes on NSS Configuration File. |
| (line 11) |
| * defining new printf conversions: Customizing Printf. (line 6) |
| * definition (compared to declaration): Header Files. (line 17) |
| * delayed suspend character: Signal Characters. (line 53) |
| * deleting a directory: Deleting Files. (line 52) |
| * deleting a file: Deleting Files. (line 6) |
| * delivery of signals: Delivery of Signal. (line 6) |
| * descriptors and streams: Stream/Descriptor Precautions. |
| (line 6) |
| * digit character <1>: Classification of Wide Characters. |
| (line 106) |
| * digit character: Classification of Characters. |
| (line 45) |
| * directories, accessing: Accessing Directories. |
| (line 6) |
| * directories, creating: Creating Directories. |
| (line 6) |
| * directories, deleting: Deleting Files. (line 52) |
| * directory: Directories. (line 9) |
| * directory entry: Directories. (line 9) |
| * directory hierarchy: Working with Directory Trees. |
| (line 6) |
| * directory stream: Accessing Directories. |
| (line 10) |
| * disadvantages of alloca: Disadvantages of Alloca. |
| (line 6) |
| * DISCARD character: Other Special. (line 23) |
| * division by zero: FP Exceptions. (line 6) |
| * DNS: Host Identification. (line 17) |
| * DNS server unavailable: Actions in the NSS configuration. |
| (line 30) |
| * domain (of socket): Socket Concepts. (line 33) |
| * domain error: Math Error Reporting. |
| (line 6) |
| * domain name: Host Identification. (line 21) |
| * Domain Name System: Host Identification. (line 17) |
| * dot notation, for Internet addresses: Abstract Host Addresses. |
| (line 48) |
| * DSUSP character: Signal Characters. (line 53) |
| * duplicating file descriptors: Duplicating Descriptors. |
| (line 6) |
| * dynamic memory allocation: Memory Allocation and C. |
| (line 26) |
| * EBCDIC: Extended Char Intro. (line 156) |
| * echo of terminal input: Local Modes. (line 24) |
| * effective group ID: Process Persona. (line 6) |
| * effective user ID: Process Persona. (line 6) |
| * efficiency and malloc: Efficiency and Malloc. |
| (line 6) |
| * efficiency and obstacks: Extra Fast Growing. (line 6) |
| * efficiency of chunks: Obstack Chunks. (line 6) |
| * EINTR, and restarting interrupted primitives: Interrupted Primitives. |
| (line 51) |
| * elapsed time <1>: Elapsed Time. (line 6) |
| * elapsed time: Time Basics. (line 24) |
| * encryption: Trivial Encryption. (line 6) |
| * end of file, on a stream: EOF and Errors. (line 6) |
| * end-of-file, on a file descriptor: I/O Primitives. (line 21) |
| * environment: Environment Variables. |
| (line 22) |
| * environment access: Environment Access. (line 6) |
| * environment representation: Environment Access. (line 6) |
| * environment variable: Environment Variables. |
| (line 6) |
| * environment vectors, null-character separated: Argz and Envz Vectors. |
| (line 9) |
| * envz vectors (environment vectors): Argz and Envz Vectors. |
| (line 9) |
| * EOF character: Editing Characters. (line 10) |
| * EOL character: Editing Characters. (line 22) |
| * EOL2 character: Editing Characters. (line 35) |
| * epoch: Simple Calendar Time. |
| (line 10) |
| * ERASE character: Editing Characters. (line 47) |
| * errno: System Calls. (line 55) |
| * error codes: Error Reporting. (line 6) |
| * error messages, in argp: Argp Helper Functions. |
| (line 23) |
| * error reporting: Error Reporting. (line 6) |
| * errors, mathematical: Math Error Reporting. |
| (line 6) |
| * establishing a handler: Signal Actions. (line 6) |
| * ethers: NSS Basics. (line 26) |
| * EUC: Extended Char Intro. (line 188) |
| * EUC-JP: glibc iconv Implementation. |
| (line 53) |
| * exception <1>: Program Error Signals. |
| (line 48) |
| * exception: FP Exceptions. (line 6) |
| * exclusive lock: File Locks. (line 10) |
| * exec functions: Executing a File. (line 6) |
| * execing a program: Memory Concepts. (line 90) |
| * executable: Memory Concepts. (line 67) |
| * executing a file: Executing a File. (line 6) |
| * exit status: Exit Status. (line 6) |
| * exit status value: Program Termination. (line 6) |
| * exiting a program: Memory Concepts. (line 90) |
| * expansion of shell words: Word Expansion. (line 6) |
| * exponent (of floating point number): Floating Point Concepts. |
| (line 23) |
| * exponentiation functions: Exponents and Logarithms. |
| (line 6) |
| * extending printf: Customizing Printf. (line 6) |
| * extracting file descriptor from stream: Descriptors and Streams. |
| (line 6) |
| * fcntl function: Control Operations. (line 6) |
| * FDL, GNU Free Documentation License: Documentation License. |
| (line 6) |
| * feature test macros: Feature Test Macros. (line 6) |
| * field splitting: Expansion Stages. (line 25) |
| * FIFO special file: Pipes and FIFOs. (line 12) |
| * file access permission: Access Permission. (line 6) |
| * file access time: File Times. (line 6) |
| * file attribute modification time: File Times. (line 6) |
| * file attributes: Attribute Meanings. (line 6) |
| * file creation mask: Setting Permissions. (line 6) |
| * file descriptor flags: Descriptor Flags. (line 6) |
| * file descriptor sets, for select: Waiting for I/O. (line 30) |
| * file descriptors, standard: Descriptors and Streams. |
| (line 49) |
| * file locks: File Locks. (line 6) |
| * file modification time: File Times. (line 6) |
| * file name: File Names. (line 14) |
| * file name component: Directories. (line 15) |
| * file name errors: File Name Errors. (line 6) |
| * file name resolution: File Name Resolution. |
| (line 10) |
| * file name translation flags: Open-time Flags. (line 14) |
| * file names, multiple: Hard Links. (line 6) |
| * file owner: File Owner. (line 6) |
| * file permission bits: Permission Bits. (line 15) |
| * file pointer: Streams. (line 12) |
| * file position: File Position. (line 15) |
| * file positioning on a file descriptor: File Position Primitive. |
| (line 15) |
| * file positioning on a stream: File Positioning. (line 6) |
| * file status flags: File Status Flags. (line 6) |
| * files, accessing: Memory Concepts. (line 83) |
| * filtering i/o through subprocess: Pipe to a Subprocess. |
| (line 6) |
| * flag character (printf): Output Conversion Syntax. |
| (line 60) |
| * flag character (scanf): Input Conversion Syntax. |
| (line 35) |
| * flags for sigaction: Flags for Sigaction. (line 6) |
| * flags, file name translation: Open-time Flags. (line 14) |
| * flags, open-time action: Open-time Flags. (line 17) |
| * floating point: Floating Point Numbers. |
| (line 6) |
| * floating point, IEEE: IEEE Floating Point. (line 6) |
| * floating type measurements: Floating Type Macros. |
| (line 6) |
| * floating-point classes: Floating Point Classes. |
| (line 6) |
| * floating-point exception: Program Error Signals. |
| (line 48) |
| * flow control, terminal: Line Control. (line 93) |
| * flushing a stream: Flushing Buffers. (line 6) |
| * flushing terminal output queue: Line Control. (line 34) |
| * foreground job: Concepts of Job Control. |
| (line 49) |
| * foreground job, launching: Foreground and Background. |
| (line 10) |
| * forking a process: Process Creation Concepts. |
| (line 15) |
| * format string, for printf: Formatted Output. (line 6) |
| * format string, for scanf: Formatted Input. (line 6) |
| * formatted input from a stream: Formatted Input. (line 6) |
| * formatted messages: Formatted Messages. (line 6) |
| * formatted output to a stream: Formatted Output. (line 6) |
| * FP arithmetic: FP Bit Twiddling. (line 6) |
| * FQDN: Host Identification. (line 32) |
| * frame, real memory: Memory Concepts. (line 18) |
| * free documentation: Free Manuals. (line 6) |
| * freeing (obstacks): Freeing Obstack Objects. |
| (line 6) |
| * freeing memory: Memory Concepts. (line 90) |
| * freeing memory allocated with malloc: Freeing after Malloc. |
| (line 6) |
| * fully buffered stream: Buffering Concepts. (line 15) |
| * function prototypes (variadic): Variadic Prototypes. (line 6) |
| * gamma function: Special Functions. (line 6) |
| * gcvt_r: System V Number Conversion. |
| (line 82) |
| * gencat: The gencat program. (line 6) |
| * generation of signals: Signal Generation. (line 6) |
| * generic i/o control operations: IOCTLs. (line 6) |
| * globbing: Globbing. (line 6) |
| * graphic character <1>: Classification of Wide Characters. |
| (line 126) |
| * graphic character: Classification of Characters. |
| (line 90) |
| * Gregorian calendar: Calendar Time. (line 26) |
| * group: NSS Basics. (line 26) |
| * group database: Group Database. (line 6) |
| * group ID: User and Group IDs. (line 12) |
| * group name: User and Group IDs. (line 12) |
| * group owner of a file: File Owner. (line 6) |
| * grouping of digits: General Numeric. (line 28) |
| * growing objects (in obstacks): Growing Objects. (line 6) |
| * handling multiple signals: Merged Signals. (line 6) |
| * hangup signal: Termination Signals. (line 72) |
| * hard limit: Limits on Resources. (line 24) |
| * hard link: Hard Links. (line 6) |
| * header files: Header Files. (line 6) |
| * heap consistency checking: Heap Consistency Checking. |
| (line 6) |
| * heap, dynamic allocation from: Unconstrained Allocation. |
| (line 6) |
| * heap, freeing memory from: Freeing after Malloc. |
| (line 6) |
| * hexadecimal digit character <1>: Classification of Wide Characters. |
| (line 206) |
| * hexadecimal digit character: Classification of Characters. |
| (line 53) |
| * hidden bit (of floating point number mantissa): Floating Point Concepts. |
| (line 42) |
| * hierarchy, directory: Working with Directory Trees. |
| (line 6) |
| * high-priority data: Out-of-Band Data. (line 6) |
| * high-resolution time: Calendar Time. (line 20) |
| * holes in files: File Position Primitive. |
| (line 60) |
| * home directory: Standard Environment. |
| (line 12) |
| * HOME environment variable: Standard Environment. |
| (line 12) |
| * hook functions (of custom streams): Hook Functions. (line 6) |
| * host address, Internet: Abstract Host Addresses. |
| (line 6) |
| * host name: Host Identification. (line 13) |
| * hostname: Host Identification. (line 19) |
| * hosts: NSS Basics. (line 26) |
| * hosts database: Host Names. (line 6) |
| * how many arguments: How Many Arguments. (line 6) |
| * hyperbolic functions: Hyperbolic Functions. |
| (line 6) |
| * identifying terminals: Is It a Terminal. (line 6) |
| * IEEE 754: Floating Point Numbers. |
| (line 6) |
| * IEEE floating point: Floating Point Numbers. |
| (line 6) |
| * IEEE floating point representation: IEEE Floating Point. (line 6) |
| * IEEE Std 1003.1: POSIX. (line 6) |
| * IEEE Std 1003.2: POSIX. (line 6) |
| * ignore action for a signal: Basic Signal Handling. |
| (line 40) |
| * illegal instruction: Program Error Signals. |
| (line 106) |
| * impossible events: Consistency Checking. |
| (line 6) |
| * independent channels: Independent Channels. |
| (line 6) |
| * inexact exception: FP Exceptions. (line 6) |
| * infinity: Infinity and NaN. (line 6) |
| * initial signal actions: Initial Signal Actions. |
| (line 6) |
| * inode number: Attribute Meanings. (line 191) |
| * input available signal: Asynchronous I/O Signals. |
| (line 13) |
| * input conversions, for scanf: Table of Input Conversions. |
| (line 6) |
| * input from multiple files: Waiting for I/O. (line 6) |
| * installation tools: Tools for Compilation. |
| (line 6) |
| * installing: Running make install. |
| (line 6) |
| * integer: Integers. (line 6) |
| * integer division functions: Integer Division. (line 6) |
| * integer type range: Range of Type. (line 6) |
| * integer type width: Width of Type. (line 6) |
| * interactive signals, from terminal: Local Modes. (line 94) |
| * interactive stop signal: Job Control Signals. (line 57) |
| * internal representation: Extended Char Intro. (line 12) |
| * internationalization: Locales. (line 11) |
| * Internet host address: Abstract Host Addresses. |
| (line 6) |
| * Internet namespace, for sockets: Internet Namespace. (line 6) |
| * interprocess communication, with FIFO: FIFO Special Files. (line 6) |
| * interprocess communication, with pipes: Creating a Pipe. (line 6) |
| * interprocess communication, with signals: Kill Example. (line 6) |
| * interprocess communication, with sockets: Sockets. (line 9) |
| * interrupt character: Signal Characters. (line 11) |
| * interrupt signal: Termination Signals. (line 30) |
| * interrupt-driven input: Interrupt Input. (line 6) |
| * interrupting primitives: Interrupted Primitives. |
| (line 51) |
| * interval: Time Basics. (line 20) |
| * interval timer, setting: Setting an Alarm. (line 10) |
| * INTR character: Signal Characters. (line 11) |
| * invalid exception: FP Exceptions. (line 6) |
| * inverse complex hyperbolic functions: Hyperbolic Functions. |
| (line 72) |
| * inverse complex trigonometric functions: Inverse Trig Functions. |
| (line 60) |
| * inverse hyperbolic functions: Hyperbolic Functions. |
| (line 51) |
| * inverse trigonometric functions: Inverse Trig Functions. |
| (line 6) |
| * invocation of program: Program Arguments. (line 6) |
| * IOCTLs: IOCTLs. (line 6) |
| * ISO 10646: Extended Char Intro. (line 37) |
| * ISO 2022: Extended Char Intro. (line 179) |
| * ISO 6937: Extended Char Intro. (line 202) |
| * ISO C: ISO C. (line 6) |
| * ISO-2022-JP: glibc iconv Implementation. |
| (line 53) |
| * ISO/IEC 9945-1: POSIX. (line 6) |
| * ISO/IEC 9945-2: POSIX. (line 6) |
| * job: Job Control. (line 6) |
| * job control: Job Control. (line 6) |
| * job control functions: Functions for Job Control. |
| (line 6) |
| * job control is optional: Job Control is Optional. |
| (line 6) |
| * job control signals: Job Control Signals. (line 6) |
| * job control, enabling: Initializing the Shell. |
| (line 6) |
| * Kermit the frog: Search/Sort Example. (line 103) |
| * kernel call: System Calls. (line 16) |
| * kernel header files: Linux. (line 6) |
| * KILL character: Editing Characters. (line 85) |
| * kill signal: Termination Signals. (line 70) |
| * killing a process: Signaling Another Process. |
| (line 6) |
| * Korn Shell: Wildcard Matching. (line 71) |
| * LANG environment variable <1>: Standard Environment. |
| (line 68) |
| * LANG environment variable: The catgets Functions. |
| (line 97) |
| * launching jobs: Launching Jobs. (line 6) |
| * LC_ALL environment variable <1>: Standard Environment. |
| (line 74) |
| * LC_ALL environment variable: The catgets Functions. |
| (line 97) |
| * LC_COLLATE environment variable: Standard Environment. |
| (line 80) |
| * LC_CTYPE environment variable: Standard Environment. |
| (line 83) |
| * LC_MESSAGES environment variable <1>: Standard Environment. |
| (line 87) |
| * LC_MESSAGES environment variable: The catgets Functions. |
| (line 97) |
| * LC_MONETARY environment variable: Standard Environment. |
| (line 91) |
| * LC_NUMERIC environment variable: Standard Environment. |
| (line 94) |
| * LC_TIME environment variable: Standard Environment. |
| (line 97) |
| * leap second: Broken-down Time. (line 28) |
| * length of string: Representation of Strings. |
| (line 56) |
| * level, for socket options: Socket Options. (line 9) |
| * LGPL, Lesser General Public License: Copying. (line 6) |
| * library: Introduction. (line 9) |
| * limit: Limits on Resources. (line 12) |
| * limits on resource usage: Limits on Resources. (line 6) |
| * limits, file name length: Limits for Files. (line 36) |
| * limits, floating types: Floating Type Macros. |
| (line 6) |
| * limits, integer types: Range of Type. (line 6) |
| * limits, link count of files: Limits for Files. (line 24) |
| * limits, number of open files: General Limits. (line 34) |
| * limits, number of processes: General Limits. (line 28) |
| * limits, number of supplementary group IDs: General Limits. (line 50) |
| * limits, pipe buffer size: Limits for Files. (line 44) |
| * limits, POSIX: General Limits. (line 6) |
| * limits, program argument size: General Limits. (line 24) |
| * limits, terminal input queue: Limits for Files. (line 28) |
| * limits, time zone name length: General Limits. (line 44) |
| * line buffered stream: Buffering Concepts. (line 12) |
| * line speed: Line Speed. (line 6) |
| * lines (in a text file): Binary Streams. (line 25) |
| * link: Directories. (line 9) |
| * link, hard: Hard Links. (line 6) |
| * link, soft: Symbolic Links. (line 6) |
| * link, symbolic: Symbolic Links. (line 6) |
| * linked channels: Linked Channels. (line 6) |
| * listening (sockets): Listening. (line 6) |
| * literals: Memory Concepts. (line 67) |
| * little-endian: Byte Order. (line 6) |
| * LNEXT character: Other Special. (line 9) |
| * load average: Processor Resources. (line 40) |
| * local namespace, for sockets: Local Namespace. (line 6) |
| * local network address number: Abstract Host Addresses. |
| (line 9) |
| * local time: Calendar Time. (line 26) |
| * locale categories: Locale Categories. (line 6) |
| * locale, changing: Setting the Locale. (line 18) |
| * locales: Locales. (line 11) |
| * locking pages: Locking Pages. (line 6) |
| * logarithm functions: Exponents and Logarithms. |
| (line 6) |
| * login name: User and Group IDs. (line 6) |
| * login name, determining: Who Logged In. (line 6) |
| * LOGNAME environment variable: Standard Environment. |
| (line 24) |
| * long jumps: Non-Local Exits. (line 6) |
| * long-named options: Argument Syntax. (line 50) |
| * longjmp: Advantages of Alloca. |
| (line 15) |
| * loss of data on sockets: Socket Concepts. (line 17) |
| * lost resource signal: Operation Error Signals. |
| (line 27) |
| * lower-case character <1>: Classification of Wide Characters. |
| (line 137) |
| * lower-case character: Classification of Characters. |
| (line 27) |
| * macros: Obstack Functions. (line 6) |
| * main function: Program Arguments. (line 6) |
| * malloc debugger: Allocation Debugging. |
| (line 6) |
| * malloc function: Unconstrained Allocation. |
| (line 6) |
| * mantissa (of floating point number): Floating Point Concepts. |
| (line 35) |
| * matching failure, in scanf: Formatted Input Basics. |
| (line 32) |
| * math errors: Errors in Math Functions. |
| (line 6) |
| * mathematical constants: Mathematical Constants. |
| (line 6) |
| * maximum: Misc FP Arithmetic. (line 6) |
| * maximum field width (scanf): Input Conversion Syntax. |
| (line 50) |
| * maximum limit: Limits on Resources. (line 24) |
| * maximum possible integer: Integers. (line 102) |
| * measurements of floating types: Floating Type Macros. |
| (line 6) |
| * memory allocation: Memory. (line 6) |
| * memory lock: Locking Pages. (line 6) |
| * memory mapped file: Memory Concepts. (line 83) |
| * memory mapped I/O: Memory Concepts. (line 83) |
| * memory page: Memory Subsystem. (line 33) |
| * merging of signals: Merged Signals. (line 6) |
| * MIN termios slot: Noncanonical Input. (line 26) |
| * minimum: Misc FP Arithmetic. (line 6) |
| * minimum field width (printf): Output Conversion Syntax. |
| (line 67) |
| * minimum possible integer: Integers. (line 102) |
| * mixing descriptors and streams: Stream/Descriptor Precautions. |
| (line 6) |
| * modem disconnect: Control Modes. (line 33) |
| * modem status lines: Control Modes. (line 21) |
| * monetary value formatting: The Lame Way to Locale Data. |
| (line 13) |
| * multi-threaded application: Streams and Threads. (line 6) |
| * multibyte character: Extended Char Intro. (line 156) |
| * multibyte character string: Representation of Strings. |
| (line 11) |
| * multibyte string: Representation of Strings. |
| (line 67) |
| * multiple names for one file: Hard Links. (line 6) |
| * multiplexing input: Waiting for I/O. (line 6) |
| * multiply-add: Misc FP Arithmetic. (line 6) |
| * name of running program: Error Messages. (line 70) |
| * name of socket: Socket Addresses. (line 6) |
| * Name Service Switch: Name Service Switch. (line 6) |
| * name space: Reserved Names. (line 6) |
| * names of signals: Standard Signals. (line 6) |
| * namespace (of socket): Socket Concepts. (line 33) |
| * NaN <1>: FP Bit Twiddling. (line 54) |
| * NaN: Infinity and NaN. (line 6) |
| * Netgroup: Netgroup Data. (line 6) |
| * netgroup: NSS Basics. (line 26) |
| * network byte order: Byte Order. (line 11) |
| * network number: Abstract Host Addresses. |
| (line 9) |
| * network protocol: Socket Concepts. (line 42) |
| * networks: NSS Basics. (line 26) |
| * networks database: Networks Database. (line 6) |
| * NIS: Host Identification. (line 38) |
| * NIS domain name: Host Identification. (line 38) |
| * nisplus, and booting: Actions in the NSS configuration. |
| (line 72) |
| * nisplus, and completeness: Actions in the NSS configuration. |
| (line 65) |
| * NLSPATH environment variable <1>: Standard Environment. |
| (line 100) |
| * NLSPATH environment variable: The catgets Functions. |
| (line 29) |
| * non-blocking open: Open-time Flags. (line 30) |
| * non-local exit, from signal handler: Longjmp in Handler. (line 6) |
| * non-local exits: Non-Local Exits. (line 6) |
| * noncanonical input processing: Canonical or Not. (line 26) |
| * normalization functions (floating-point): Normalization Functions. |
| (line 6) |
| * normalized floating point number: Floating Point Concepts. |
| (line 59) |
| * not a number: Infinity and NaN. (line 6) |
| * NSS: Name Service Switch. (line 6) |
| * nsswitch.conf: NSS Configuration File. |
| (line 6) |
| * null character: Representation of Strings. |
| (line 26) |
| * null pointer constant: Null Pointer Constant. |
| (line 6) |
| * null wide character: Representation of Strings. |
| (line 26) |
| * number of arguments passed: How Many Arguments. (line 6) |
| * number syntax, parsing: Parsing of Numbers. (line 6) |
| * numeric value formatting: The Lame Way to Locale Data. |
| (line 13) |
| * obstack status: Status of an Obstack. |
| (line 6) |
| * obstacks: Obstacks. (line 6) |
| * open-time action flags: Open-time Flags. (line 17) |
| * opening a file: I/O Concepts. (line 9) |
| * opening a file descriptor: Opening and Closing Files. |
| (line 6) |
| * opening a pipe: Creating a Pipe. (line 6) |
| * opening a pseudo-terminal pair: Pseudo-Terminal Pairs. |
| (line 6) |
| * opening a socket: Creating a Socket. (line 6) |
| * opening a socket pair: Socket Pairs. (line 6) |
| * opening a stream: Opening Streams. (line 6) |
| * Optimization: FP Function Optimizations. |
| (line 6) |
| * optimizing NSS: Notes on NSS Configuration File. |
| (line 27) |
| * option parsing with argp: Argp. (line 6) |
| * optional arguments: Variadic Functions. (line 6) |
| * optional POSIX features: System Options. (line 6) |
| * orientation, stream <1>: Streams and I18N. (line 38) |
| * orientation, stream: Opening Streams. (line 78) |
| * orphaned process group: Orphaned Process Groups. |
| (line 6) |
| * out-of-band data: Out-of-Band Data. (line 6) |
| * output conversions, for printf: Table of Output Conversions. |
| (line 6) |
| * output possible signal: Asynchronous I/O Signals. |
| (line 13) |
| * overflow exception: FP Exceptions. (line 6) |
| * owner of a file: File Owner. (line 6) |
| * packet: Socket Concepts. (line 12) |
| * page boundary: Aligned Memory Blocks. |
| (line 6) |
| * page fault: Memory Concepts. (line 45) |
| * page fault, copy-on-write: Locked Memory Details. |
| (line 40) |
| * page frame: Memory Concepts. (line 18) |
| * page, memory: Memory Subsystem. (line 33) |
| * page, virtual memory: Memory Concepts. (line 18) |
| * paging <1>: Locking Pages. (line 6) |
| * paging: Memory Concepts. (line 45) |
| * parameter promotion: String/Array Conventions. |
| (line 41) |
| * parent directory: File Name Resolution. |
| (line 28) |
| * parent process <1>: Process Creation Concepts. |
| (line 15) |
| * parent process: Processes. (line 13) |
| * parity checking: Input Modes. (line 17) |
| * parsing a template string: Parsing a Template String. |
| (line 6) |
| * parsing numbers (in formatted input): Parsing of Numbers. (line 6) |
| * parsing program arguments: Parsing Program Arguments. |
| (line 6) |
| * parsing tokens from a string: Finding Tokens in a String. |
| (line 6) |
| * passwd: NSS Basics. (line 26) |
| * password database: User Database. (line 6) |
| * PATH environment variable: Standard Environment. |
| (line 33) |
| * pause function: Waiting for a Signal. |
| (line 6) |
| * peeking at input: Unreading. (line 6) |
| * pending signals: Delivery of Signal. (line 6) |
| * pending signals, checking for: Checking for Pending Signals. |
| (line 6) |
| * period of time: Time Basics. (line 33) |
| * permission to access a file: Access Permission. (line 6) |
| * persona: Process Persona. (line 6) |
| * physical address: Memory Subsystem. (line 6) |
| * physical memory: Memory Subsystem. (line 6) |
| * pi (trigonometric constant): Trig Functions. (line 10) |
| * pipe: Pipes and FIFOs. (line 6) |
| * pipe signal: Operation Error Signals. |
| (line 13) |
| * pipe to a subprocess: Pipe to a Subprocess. |
| (line 6) |
| * port number: Ports. (line 6) |
| * positioning a file descriptor: File Position Primitive. |
| (line 15) |
| * positioning a stream: File Positioning. (line 6) |
| * positive difference: Misc FP Arithmetic. (line 6) |
| * POSIX: POSIX. (line 6) |
| * POSIX capacity limits: General Limits. (line 6) |
| * POSIX optional features: System Options. (line 6) |
| * POSIX.1: POSIX. (line 6) |
| * POSIX.2: POSIX. (line 6) |
| * power functions: Exponents and Logarithms. |
| (line 6) |
| * precision (of floating point number): Floating Point Concepts. |
| (line 38) |
| * precision (printf): Output Conversion Syntax. |
| (line 78) |
| * predicates on arrays: String/Array Comparison. |
| (line 6) |
| * predicates on characters: Classification of Characters. |
| (line 6) |
| * predicates on strings: String/Array Comparison. |
| (line 6) |
| * preemptive scheduling: Absolute Priority. (line 17) |
| * primitives, interrupting: Interrupted Primitives. |
| (line 51) |
| * printing character <1>: Classification of Wide Characters. |
| (line 147) |
| * printing character: Classification of Characters. |
| (line 95) |
| * priority of a process: Priority. (line 6) |
| * priority, absolute: Absolute Priority. (line 6) |
| * process <1>: Processes. (line 6) |
| * process: Program Basics. (line 6) |
| * process completion: Process Completion. (line 6) |
| * process group functions: Functions for Job Control. |
| (line 6) |
| * process group ID: Launching Jobs. (line 23) |
| * process group leader: Launching Jobs. (line 23) |
| * process groups: Job Control. (line 6) |
| * process ID: Process Creation Concepts. |
| (line 9) |
| * process image: Process Creation Concepts. |
| (line 33) |
| * process lifetime: Process Creation Concepts. |
| (line 9) |
| * process priority: Priority. (line 6) |
| * process signal mask: Process Signal Mask. (line 6) |
| * process termination: Program Termination. (line 6) |
| * processor time <1>: Processor Time. (line 9) |
| * processor time: Time Basics. (line 44) |
| * profiling alarm signal: Alarm Signals. (line 30) |
| * profiling timer: Setting an Alarm. (line 22) |
| * program: Program Basics. (line 6) |
| * program argument syntax: Argument Syntax. (line 6) |
| * program arguments: Program Arguments. (line 6) |
| * program arguments, parsing: Parsing Program Arguments. |
| (line 6) |
| * program error signals: Program Error Signals. |
| (line 6) |
| * program name: Error Messages. (line 70) |
| * program startup: Program Arguments. (line 6) |
| * program termination: Program Termination. (line 6) |
| * program termination signals: Termination Signals. (line 6) |
| * programming your own streams: Custom Streams. (line 6) |
| * project complex numbers: Operations on Complex. |
| (line 6) |
| * protocol (of socket): Socket Concepts. (line 42) |
| * protocol family: Socket Concepts. (line 42) |
| * protocols: NSS Basics. (line 26) |
| * protocols database: Protocols Database. (line 6) |
| * prototypes for variadic functions: Variadic Prototypes. (line 6) |
| * pseudo-random numbers: Pseudo-Random Numbers. |
| (line 6) |
| * pseudo-terminals: Pseudo-Terminals. (line 6) |
| * punctuation character <1>: Classification of Wide Characters. |
| (line 157) |
| * punctuation character: Classification of Characters. |
| (line 58) |
| * pushing input back: Unreading. (line 6) |
| * quick sort function (for arrays): Array Sort Function. (line 6) |
| * QUIT character: Signal Characters. (line 22) |
| * quit signal: Termination Signals. (line 36) |
| * quote removal: Expansion Stages. (line 32) |
| * race conditions, relating to job control: Launching Jobs. (line 28) |
| * race conditions, relating to signals: Signals in Handler. (line 6) |
| * radix (of floating point number): Floating Point Concepts. |
| (line 20) |
| * raising signals: Generating Signals. (line 6) |
| * random numbers: Pseudo-Random Numbers. |
| (line 6) |
| * random-access files: File Position. (line 23) |
| * range error: Math Error Reporting. |
| (line 6) |
| * range of integer type: Range of Type. (line 6) |
| * read lock: File Locks. (line 14) |
| * reading from a directory: Accessing Directories. |
| (line 6) |
| * reading from a file descriptor: I/O Primitives. (line 15) |
| * reading from a socket: Transferring Data. (line 6) |
| * reading from a stream, by blocks: Block Input/Output. (line 9) |
| * reading from a stream, by characters: Character Input. (line 6) |
| * reading from a stream, formatted: Formatted Input. (line 6) |
| * ready to run: Absolute Priority. (line 17) |
| * real group ID: Process Persona. (line 17) |
| * real user ID: Process Persona. (line 17) |
| * real-time timer: Setting an Alarm. (line 13) |
| * realtime CPU scheduling: Absolute Priority. (line 9) |
| * realtime processing: Why Lock Pages. (line 14) |
| * realtime scheduling: Realtime Scheduling. (line 6) |
| * receiving datagrams: Receiving Datagrams. (line 6) |
| * record locking: File Locks. (line 6) |
| * redirecting input and output: Duplicating Descriptors. |
| (line 6) |
| * reentrant functions: Nonreentrancy. (line 26) |
| * reentrant NSS functions: NSS Module Names. (line 21) |
| * relative file name: File Name Resolution. |
| (line 24) |
| * removal of quotes: Expansion Stages. (line 32) |
| * removing a file: Deleting Files. (line 6) |
| * removing macros that shadow functions: Macro Definitions. (line 6) |
| * renaming a file: Renaming Files. (line 8) |
| * reporting bugs: Reporting Bugs. (line 6) |
| * reporting errors: Error Reporting. (line 6) |
| * REPRINT character: Editing Characters. (line 96) |
| * reserved names: Reserved Names. (line 6) |
| * resource limits: Limits on Resources. (line 6) |
| * restarting interrupted primitives: Interrupted Primitives. |
| (line 51) |
| * restrictions on signal handler functions: Nonreentrancy. (line 6) |
| * root directory: File Name Resolution. |
| (line 19) |
| * Rot13: Trivial Encryption. (line 11) |
| * rpc: NSS Basics. (line 26) |
| * runnable process: Absolute Priority. (line 25) |
| * running a command: Running a Command. (line 6) |
| * saved set-group-ID: How Change Persona. (line 6) |
| * saved set-user-ID: How Change Persona. (line 6) |
| * scanning the group list: Scanning All Groups. (line 6) |
| * scanning the user list: Scanning All Users. (line 6) |
| * scatter-gather: Scatter-Gather. (line 6) |
| * scheduling, traditional: Traditional Scheduling. |
| (line 6) |
| * search function (for arrays): Array Search Function. |
| (line 6) |
| * search functions (for strings): Search Functions. (line 8) |
| * seed (for random numbers): Pseudo-Random Numbers. |
| (line 6) |
| * seeking on a file descriptor: File Position Primitive. |
| (line 15) |
| * seeking on a stream: File Positioning. (line 6) |
| * segmentation violation: Program Error Signals. |
| (line 108) |
| * sending a datagram: Sending Datagrams. (line 6) |
| * sending signals: Generating Signals. (line 6) |
| * sequential-access files: File Position. (line 15) |
| * server: Connections. (line 6) |
| * services: NSS Basics. (line 26) |
| * services database: Services Database. (line 6) |
| * session <1>: Concepts of Job Control. |
| (line 25) |
| * session: Job Control. (line 6) |
| * session leader: Concepts of Job Control. |
| (line 34) |
| * setting an alarm: Setting an Alarm. (line 10) |
| * setuid programs: How Change Persona. (line 6) |
| * setuid programs and file access: Testing File Access. (line 6) |
| * severity class <1>: Adding Severity Classes. |
| (line 6) |
| * severity class: Printing Formatted Messages. |
| (line 93) |
| * sgettext: GUI program problems. |
| (line 59) |
| * shadow: NSS Basics. (line 26) |
| * shadowing functions with macros: Macro Definitions. (line 6) |
| * shared lock: File Locks. (line 14) |
| * shared memory: Memory Subsystem. (line 13) |
| * shell: Concepts of Job Control. |
| (line 6) |
| * shift state: Keeping the state. (line 15) |
| * Shift_JIS: Extended Char Intro. (line 188) |
| * shrinking objects: Growing Objects. (line 90) |
| * shutting down a socket: Closing a Socket. (line 6) |
| * sigaction flags: Flags for Sigaction. (line 6) |
| * sigaction function: Advanced Signal Handling. |
| (line 6) |
| * SIGCHLD, handling of: Stopped and Terminated Jobs. |
| (line 18) |
| * sign (of floating point number): Floating Point Concepts. |
| (line 18) |
| * signal <1>: Signal Handling. (line 6) |
| * signal: FP Exceptions. (line 6) |
| * signal action: Delivery of Signal. (line 13) |
| * signal actions: Signal Actions. (line 6) |
| * signal flags: Flags for Sigaction. (line 6) |
| * signal function: Basic Signal Handling. |
| (line 6) |
| * signal handler function: Defining Handlers. (line 6) |
| * signal mask: Process Signal Mask. (line 6) |
| * signal messages: Signal Messages. (line 6) |
| * signal names: Standard Signals. (line 6) |
| * signal number: Standard Signals. (line 6) |
| * signal set: Signal Sets. (line 9) |
| * signals, generating: Generating Signals. (line 6) |
| * signedness: Integers. (line 9) |
| * significand (of floating point number): Floating Point Concepts. |
| (line 35) |
| * SIGTTIN, from background job: Access to the Terminal. |
| (line 11) |
| * SIGTTOU, from background job: Access to the Terminal. |
| (line 18) |
| * simple time: Calendar Time. (line 13) |
| * single-byte string: Representation of Strings. |
| (line 67) |
| * size of string: Representation of Strings. |
| (line 56) |
| * SJIS: Extended Char Intro. (line 188) |
| * socket: Sockets. (line 9) |
| * socket address (name) binding: Socket Addresses. (line 6) |
| * socket domain: Socket Concepts. (line 33) |
| * socket namespace: Socket Concepts. (line 33) |
| * socket option level: Socket Options. (line 9) |
| * socket options: Socket Options. (line 6) |
| * socket pair: Socket Pairs. (line 6) |
| * socket protocol: Socket Concepts. (line 42) |
| * socket shutdown: Closing a Socket. (line 6) |
| * socket, client actions: Connecting. (line 6) |
| * socket, closing: Closing a Socket. (line 6) |
| * socket, connecting: Connecting. (line 6) |
| * socket, creating: Creating a Socket. (line 6) |
| * socket, initiating a connection: Connecting. (line 6) |
| * sockets, accepting connections: Accepting Connections. |
| (line 6) |
| * sockets, listening: Listening. (line 6) |
| * sockets, server actions: Listening. (line 6) |
| * soft limit: Limits on Resources. (line 17) |
| * soft link: Symbolic Links. (line 6) |
| * sort function (for arrays): Array Sort Function. (line 6) |
| * sparse files: File Position Primitive. |
| (line 60) |
| * special files: Making Special Files. |
| (line 6) |
| * special functions: Special Functions. (line 6) |
| * specified action (for a signal): Delivery of Signal. (line 13) |
| * speed of execution: Why Lock Pages. (line 14) |
| * square root function: Exponents and Logarithms. |
| (line 122) |
| * stable sorting: Array Sort Function. (line 21) |
| * standard dot notation, for Internet addresses: Abstract Host Addresses. |
| (line 48) |
| * standard environment variables: Standard Environment. |
| (line 6) |
| * standard error file descriptor: Descriptors and Streams. |
| (line 64) |
| * standard error stream: Standard Streams. (line 24) |
| * standard file descriptors: Descriptors and Streams. |
| (line 49) |
| * standard input file descriptor: Descriptors and Streams. |
| (line 55) |
| * standard input stream: Standard Streams. (line 16) |
| * standard output file descriptor: Descriptors and Streams. |
| (line 59) |
| * standard output stream: Standard Streams. (line 20) |
| * standard streams: Standard Streams. (line 6) |
| * standards: Standards and Portability. |
| (line 6) |
| * START character: Start/Stop Characters. |
| (line 11) |
| * startup of program: Program Arguments. (line 6) |
| * stateful <1>: glibc iconv Implementation. |
| (line 594) |
| * stateful <2>: iconv Examples. (line 96) |
| * stateful <3>: Generic Conversion Interface. |
| (line 110) |
| * stateful <4>: Converting Strings. (line 65) |
| * stateful <5>: Converting a Character. |
| (line 81) |
| * stateful: Keeping the state. (line 6) |
| * static memory allocation: Memory Allocation and C. |
| (line 13) |
| * static storage class: Memory Allocation and C. |
| (line 13) |
| * STATUS character: Other Special. (line 35) |
| * status codes: Error Reporting. (line 6) |
| * status of a file: Attribute Meanings. (line 6) |
| * status of obstack: Status of an Obstack. |
| (line 6) |
| * sticky bit: Permission Bits. (line 71) |
| * STOP character: Start/Stop Characters. |
| (line 28) |
| * stop signal: Job Control Signals. (line 44) |
| * stopped job: Concepts of Job Control. |
| (line 55) |
| * stopped jobs, continuing: Continuing Stopped Jobs. |
| (line 6) |
| * stopped jobs, detecting: Stopped and Terminated Jobs. |
| (line 6) |
| * storage allocation: Memory. (line 6) |
| * stream (sockets): Socket Concepts. (line 12) |
| * stream orientation <1>: Streams and I18N. (line 38) |
| * stream orientation: Opening Streams. (line 78) |
| * stream, for I/O to a string: String Streams. (line 6) |
| * streams and descriptors: Stream/Descriptor Precautions. |
| (line 6) |
| * streams, and file descriptors: Descriptors and Streams. |
| (line 6) |
| * streams, C++: Streams and I18N. (line 30) |
| * streams, standard: Standard Streams. (line 6) |
| * string: Representation of Strings. |
| (line 11) |
| * string allocation: Representation of Strings. |
| (line 56) |
| * string collation functions: Collation Functions. (line 6) |
| * string comparison functions: String/Array Comparison. |
| (line 6) |
| * string concatenation functions: Copying and Concatenation. |
| (line 10) |
| * string copy functions: Copying and Concatenation. |
| (line 10) |
| * string length: Representation of Strings. |
| (line 56) |
| * string literal: Representation of Strings. |
| (line 35) |
| * string search functions: Search Functions. (line 8) |
| * string stream: String Streams. (line 6) |
| * string vectors, null-character separated: Argz and Envz Vectors. |
| (line 6) |
| * string, representation of: Representation of Strings. |
| (line 6) |
| * style of communication (of a socket): Socket Concepts. (line 6) |
| * subshell: Initializing the Shell. |
| (line 6) |
| * substitution of variables and commands: Expansion Stages. (line 15) |
| * successive signals: Merged Signals. (line 6) |
| * summer time: Broken-down Time. (line 62) |
| * SunOS: Berkeley Unix. (line 6) |
| * supplementary group IDs: Process Persona. (line 6) |
| * SUSP character: Signal Characters. (line 33) |
| * suspend character: Signal Characters. (line 33) |
| * SVID: SVID. (line 6) |
| * swap space: Memory Concepts. (line 18) |
| * symbolic link: Symbolic Links. (line 6) |
| * symbolic link, opening: Open-time Flags. (line 68) |
| * synchronizing <1>: Synchronizing AIO Operations. |
| (line 17) |
| * synchronizing: Synchronizing I/O. (line 6) |
| * syntax error messages, in argp: Argp Helper Functions. |
| (line 16) |
| * syntax, for program arguments: Argument Syntax. (line 6) |
| * syntax, for reading numbers: Parsing of Numbers. (line 6) |
| * sysconf <1>: Processor Resources. (line 13) |
| * sysconf: Query Memory Parameters. |
| (line 43) |
| * system call: System Calls. (line 6) |
| * system call number: System Calls. (line 42) |
| * System V Unix: SVID. (line 6) |
| * TCP (Internet protocol): Protocols Database. (line 12) |
| * template, for printf: Formatted Output. (line 6) |
| * template, for scanf: Formatted Input. (line 6) |
| * TERM environment variable: Standard Environment. |
| (line 56) |
| * terminal flow control: Line Control. (line 93) |
| * terminal identification: Is It a Terminal. (line 6) |
| * terminal input queue: I/O Queues. (line 11) |
| * terminal input queue, clearing: Line Control. (line 59) |
| * terminal input signal: Job Control Signals. (line 65) |
| * terminal line control functions: Line Control. (line 6) |
| * terminal line speed: Line Speed. (line 6) |
| * terminal mode data types: Mode Data Types. (line 6) |
| * terminal mode functions: Mode Functions. (line 6) |
| * terminal modes, BSD: BSD Terminal Modes. (line 6) |
| * terminal output queue: I/O Queues. (line 27) |
| * terminal output queue, flushing: Line Control. (line 34) |
| * terminal output signal: Job Control Signals. (line 72) |
| * terminated jobs, detecting: Stopped and Terminated Jobs. |
| (line 6) |
| * termination signal: Termination Signals. (line 22) |
| * testing access permission: Testing File Access. (line 6) |
| * testing exit status of child process: Process Completion. (line 6) |
| * text stream: Binary Streams. (line 13) |
| * thrashing: Memory Subsystem. (line 31) |
| * thread of control: Program Basics. (line 6) |
| * threads: Streams and Threads. (line 6) |
| * ticks, clock: Processor And CPU Time. |
| (line 19) |
| * tilde expansion: Expansion Stages. (line 9) |
| * time: Time Basics. (line 6) |
| * TIME termios slot: Noncanonical Input. (line 34) |
| * time zone: TZ Variable. (line 9) |
| * time zone database: TZ Variable. (line 118) |
| * time, elapsed: Time Basics. (line 24) |
| * time, high precision: High Accuracy Clock. (line 6) |
| * timer, profiling: Setting an Alarm. (line 22) |
| * timer, real-time: Setting an Alarm. (line 13) |
| * timer, virtual: Setting an Alarm. (line 17) |
| * timers, setting: Setting an Alarm. (line 10) |
| * timespec: Elapsed Time. (line 40) |
| * timeval: Elapsed Time. (line 27) |
| * timing error in signal handling: Remembering a Signal. |
| (line 72) |
| * TMPDIR environment variable: Temporary Files. (line 125) |
| * tokenizing strings: Finding Tokens in a String. |
| (line 6) |
| * tools, for installing library: Tools for Compilation. |
| (line 6) |
| * transmitting datagrams: Sending Datagrams. (line 6) |
| * tree, directory: Working with Directory Trees. |
| (line 6) |
| * triangulation: glibc iconv Implementation. |
| (line 42) |
| * trigonometric functions: Trig Functions. (line 6) |
| * type measurements, floating: Floating Type Macros. |
| (line 6) |
| * type measurements, integer: Width of Type. (line 6) |
| * type modifier character (printf): Output Conversion Syntax. |
| (line 92) |
| * type modifier character (scanf): Input Conversion Syntax. |
| (line 55) |
| * typeahead buffer: I/O Queues. (line 11) |
| * TZ environment variable: Standard Environment. |
| (line 64) |
| * UCS-2: Extended Char Intro. (line 49) |
| * UCS-4: Extended Char Intro. (line 49) |
| * ulps: Errors in Math Functions. |
| (line 6) |
| * umask: Setting Permissions. (line 6) |
| * unbuffered stream: Buffering Concepts. (line 9) |
| * unconstrained memory allocation: Unconstrained Allocation. |
| (line 6) |
| * undefining macros that shadow functions: Macro Definitions. (line 6) |
| * underflow exception: FP Exceptions. (line 6) |
| * Unicode: Extended Char Intro. (line 37) |
| * Unix, Berkeley: Berkeley Unix. (line 6) |
| * Unix, System V: SVID. (line 6) |
| * unlinking a file: Deleting Files. (line 6) |
| * unordered comparison: FP Comparison Functions. |
| (line 6) |
| * unreading characters: Unreading. (line 6) |
| * upgrading from libc5: Linux. (line 6) |
| * upper-case character <1>: Classification of Wide Characters. |
| (line 196) |
| * upper-case character: Classification of Characters. |
| (line 31) |
| * urgent data signal: Asynchronous I/O Signals. |
| (line 24) |
| * urgent socket condition: Out-of-Band Data. (line 18) |
| * usage limits: Limits on Resources. (line 6) |
| * usage messages, in argp: Argp Helper Functions. |
| (line 11) |
| * user accounting database: User Accounting Database. |
| (line 6) |
| * user database: User Database. (line 6) |
| * user ID: User and Group IDs. (line 6) |
| * user ID, determining: Who Logged In. (line 6) |
| * user name: User and Group IDs. (line 6) |
| * user signals: Miscellaneous Signals. |
| (line 12) |
| * usual file name errors: File Name Errors. (line 6) |
| * UTF-16: Extended Char Intro. (line 49) |
| * UTF-7: Extended Char Intro. (line 222) |
| * UTF-8: Extended Char Intro. (line 49) |
| * va_copy: Copying and Concatenation. |
| (line 447) |
| * variable number of arguments: Variadic Functions. (line 6) |
| * variable substitution: Expansion Stages. (line 15) |
| * variable-sized arrays: GNU C Variable-Size Arrays. |
| (line 6) |
| * variadic function argument access: Receiving Arguments. (line 6) |
| * variadic function prototypes: Variadic Prototypes. (line 6) |
| * variadic functions: Variadic Functions. (line 6) |
| * variadic functions, calling: Calling Variadics. (line 6) |
| * virtual time alarm signal: Alarm Signals. (line 24) |
| * virtual timer: Setting an Alarm. (line 17) |
| * volatile declarations: Nonreentrancy. (line 20) |
| * waiting for a signal: Waiting for a Signal. |
| (line 6) |
| * waiting for completion of child process: Process Completion. |
| (line 6) |
| * waiting for input or output: Waiting for I/O. (line 6) |
| * WERASE character: Editing Characters. (line 61) |
| * whitespace character <1>: Classification of Wide Characters. |
| (line 167) |
| * whitespace character: Classification of Characters. |
| (line 62) |
| * wide character: Extended Char Intro. (line 31) |
| * wide character string: Representation of Strings. |
| (line 21) |
| * width of integer type: Width of Type. (line 6) |
| * wildcard expansion: Expansion Stages. (line 27) |
| * wint_t: String/Array Conventions. |
| (line 41) |
| * word expansion: Word Expansion. (line 6) |
| * working directory: Working Directory. (line 6) |
| * write lock: File Locks. (line 10) |
| * writing to a file descriptor: I/O Primitives. (line 155) |
| * writing to a socket: Transferring Data. (line 6) |
| * writing to a stream, by blocks: Block Input/Output. (line 9) |
| * writing to a stream, by characters: Simple Output. (line 6) |
| * writing to a stream, formatted: Formatted Output. (line 6) |
| * YP: Host Identification. (line 38) |
| * YP domain name: Host Identification. (line 38) |
| * zero divide: FP Exceptions. (line 6) |
| |
| |
| File: libc.info, Node: Type Index, Next: Function Index, Prev: Concept Index, Up: Top |
| |
| Type Index |
| ********** |
| |
| [index] |
| * Menu: |
| |
| * __ftw64_func_t: Working with Directory Trees. |
| (line 65) |
| * __ftw_func_t: Working with Directory Trees. |
| (line 21) |
| * __nftw64_func_t: Working with Directory Trees. |
| (line 99) |
| * __nftw_func_t: Working with Directory Trees. |
| (line 73) |
| * blkcnt64_t: Attribute Meanings. (line 224) |
| * blkcnt_t: Attribute Meanings. (line 217) |
| * cc_t: Mode Data Types. (line 47) |
| * clock_t: CPU Time. (line 42) |
| * comparison_fn_t: Comparison Functions. |
| (line 32) |
| * cookie_close_function: Hook Functions. (line 60) |
| * cookie_io_functions_t: Streams and Cookies. (line 28) |
| * cookie_read_function: Hook Functions. (line 49) |
| * cookie_seek_function: Hook Functions. (line 57) |
| * cookie_write_function: Hook Functions. (line 54) |
| * cpu_set_t: CPU Affinity. (line 44) |
| * dev_t: Attribute Meanings. (line 209) |
| * DIR: Opening a Directory. (line 10) |
| * div_t: Integer Division. (line 20) |
| * enum mcheck_status: Heap Consistency Checking. |
| (line 61) |
| * fd_set: Waiting for I/O. (line 35) |
| * FILE: Streams. (line 17) |
| * fpos64_t: Portable Positioning. |
| (line 67) |
| * fpos_t: Portable Positioning. |
| (line 53) |
| * gid_t: Reading Persona. (line 16) |
| * glob64_t: Calling Glob. (line 89) |
| * glob_t: Calling Glob. (line 12) |
| * iconv_t: Generic Conversion Interface. |
| (line 16) |
| * imaxdiv_t: Integer Division. (line 84) |
| * ino64_t: Attribute Meanings. (line 201) |
| * ino_t: Attribute Meanings. (line 192) |
| * jmp_buf: Non-Local Details. (line 11) |
| * ldiv_t: Integer Division. (line 45) |
| * lldiv_t: Integer Division. (line 63) |
| * mbstate_t: Keeping the state. (line 15) |
| * mode_t: Attribute Meanings. (line 188) |
| * nlink_t: Attribute Meanings. (line 213) |
| * off64_t: File Position Primitive. |
| (line 155) |
| * off_t: File Position Primitive. |
| (line 148) |
| * pid_t: Process Identification. |
| (line 13) |
| * printf_arginfo_function: Defining the Output Handler. |
| (line 55) |
| * printf_function: Defining the Output Handler. |
| (line 35) |
| * ptrdiff_t: Important Data Types. |
| (line 14) |
| * regex_t: POSIX Regexp Compilation. |
| (line 16) |
| * regmatch_t: Regexp Subexpressions. |
| (line 15) |
| * regoff_t: Regexp Subexpressions. |
| (line 26) |
| * sig_atomic_t: Atomic Types. (line 17) |
| * sighandler_t: Basic Signal Handling. |
| (line 11) |
| * sigjmp_buf: Non-Local Exits and Signals. |
| (line 21) |
| * sigset_t: Signal Sets. (line 14) |
| * size_t: Important Data Types. |
| (line 22) |
| * speed_t: Line Speed. (line 57) |
| * ssize_t: I/O Primitives. (line 11) |
| * stack_t: Signal Stack. (line 27) |
| * struct __gconv_step: glibc iconv Implementation. |
| (line 206) |
| * struct __gconv_step_data: glibc iconv Implementation. |
| (line 274) |
| * struct aiocb: Asynchronous I/O. (line 28) |
| * struct aiocb64: Asynchronous I/O. (line 111) |
| * struct aioinit: Configuration of AIO. |
| (line 18) |
| * struct argp: Argp Parsers. (line 10) |
| * struct argp_child: Argp Children. (line 18) |
| * struct argp_option: Argp Option Vectors. (line 14) |
| * struct argp_state: Argp Parsing State. (line 11) |
| * struct dirent: Directory Entries. (line 11) |
| * struct ENTRY: Hash Search Function. |
| (line 63) |
| * struct exit_status: Manipulating the Database. |
| (line 10) |
| * struct flock: File Locks. (line 37) |
| * struct fstab: fstab. (line 10) |
| * struct FTW: Working with Directory Trees. |
| (line 107) |
| * struct group: Group Data Structure. |
| (line 10) |
| * struct hostent: Host Names. (line 21) |
| * struct if_nameindex: Interface Naming. (line 37) |
| * struct in6_addr: Host Address Data Type. |
| (line 52) |
| * struct in_addr: Host Address Data Type. |
| (line 26) |
| * struct iovec: Scatter-Gather. (line 21) |
| * struct itimerval: Setting an Alarm. (line 54) |
| * struct lconv: The Lame Way to Locale Data. |
| (line 26) |
| * struct linger: Socket-Level Options. |
| (line 50) |
| * struct mallinfo: Statistics of Malloc. |
| (line 12) |
| * struct mntent: mtab. (line 9) |
| * struct netent: Networks Database. (line 14) |
| * struct ntptimeval: High Accuracy Clock. (line 17) |
| * struct obstack: Creating Obstacks. (line 10) |
| * struct option: Getopt Long Options. (line 13) |
| * struct passwd: User Data Structure. (line 10) |
| * struct printf_info: Conversion Specifier Options. |
| (line 16) |
| * struct protoent: Protocols Database. (line 30) |
| * struct random_data: BSD Random. (line 68) |
| * struct rlimit: Limits on Resources. (line 79) |
| * struct rlimit64: Limits on Resources. (line 95) |
| * struct rusage: Resource Usage. (line 37) |
| * struct sched_param: Basic Scheduling Functions. |
| (line 30) |
| * struct servent: Services Database. (line 12) |
| * struct sgttyb: BSD Terminal Modes. (line 16) |
| * struct sigaction: Advanced Signal Handling. |
| (line 15) |
| * struct sigstack: Signal Stack. (line 97) |
| * struct sigvec: BSD Handler. (line 7) |
| * struct sockaddr: Address Formats. (line 24) |
| * struct sockaddr_in: Internet Address Formats. |
| (line 16) |
| * struct sockaddr_in6: Internet Address Formats. |
| (line 37) |
| * struct sockaddr_un: Local Namespace Details. |
| (line 25) |
| * struct stat: Attribute Meanings. (line 15) |
| * struct stat64: Attribute Meanings. (line 107) |
| * struct termios: Mode Data Types. (line 11) |
| * struct timespec: Elapsed Time. (line 40) |
| * struct timeval: Elapsed Time. (line 27) |
| * struct timex: High Accuracy Clock. (line 51) |
| * struct timezone: High-Resolution Calendar. |
| (line 15) |
| * struct tm: Broken-down Time. (line 20) |
| * struct tms: Processor Time. (line 12) |
| * struct utimbuf: File Times. (line 39) |
| * struct utmp: Manipulating the Database. |
| (line 21) |
| * struct utmpx: XPG Functions. (line 10) |
| * struct utsname: Platform Type. (line 16) |
| * struct vtimes: Resource Usage. (line 117) |
| * tcflag_t: Mode Data Types. (line 43) |
| * time_t: Simple Calendar Time. |
| (line 11) |
| * ucontext_t: System V contexts. (line 23) |
| * uid_t: Reading Persona. (line 12) |
| * union wait: BSD Wait Functions. (line 17) |
| * va_list: Argument Macros. (line 10) |
| * VISIT: Tree Search Function. |
| (line 102) |
| * wchar_t: Extended Char Intro. (line 65) |
| * wctrans_t: Wide Character Case Conversion. |
| (line 12) |
| * wctype_t: Classification of Wide Characters. |
| (line 30) |
| * wint_t: Extended Char Intro. (line 88) |
| * wordexp_t: Calling Wordexp. (line 15) |
| |
| |
| File: libc.info, Node: Function Index, Next: Variable Index, Prev: Type Index, Up: Top |
| |
| Function and Macro Index |
| ************************ |
| |
| [index] |
| * Menu: |
| |
| * *sbrk: Resizing the Data Segment. |
| (line 44) |
| * __fbufsize: Controlling Buffering. |
| (line 116) |
| * __flbf: Controlling Buffering. |
| (line 106) |
| * __fpending: Controlling Buffering. |
| (line 123) |
| * __fpurge: Flushing Buffers. (line 65) |
| * __freadable: Opening Streams. (line 176) |
| * __freading: Opening Streams. (line 193) |
| * __fsetlocking: Streams and Threads. (line 161) |
| * __fwritable: Opening Streams. (line 183) |
| * __fwriting: Opening Streams. (line 203) |
| * __va_copy: Argument Macros. (line 49) |
| * _Exit: Termination Internals. |
| (line 15) |
| * _exit: Termination Internals. |
| (line 10) |
| * _flushlbf: Flushing Buffers. (line 47) |
| * _tolower: Case Conversion. (line 39) |
| * _toupper: Case Conversion. (line 43) |
| * a64l: Encode Binary Data. (line 83) |
| * abort: Aborting a Program. (line 10) |
| * abs: Absolute Value. (line 18) |
| * accept: Accepting Connections. |
| (line 27) |
| * access: Testing File Access. (line 42) |
| * acos: Inverse Trig Functions. |
| (line 23) |
| * acosf: Inverse Trig Functions. |
| (line 24) |
| * acosh: Hyperbolic Functions. |
| (line 58) |
| * acoshf: Hyperbolic Functions. |
| (line 59) |
| * acoshl: Hyperbolic Functions. |
| (line 60) |
| * acosl: Inverse Trig Functions. |
| (line 25) |
| * addmntent: mtab. (line 175) |
| * addseverity: Adding Severity Classes. |
| (line 13) |
| * adjtime: High-Resolution Calendar. |
| (line 88) |
| * adjtimex: High-Resolution Calendar. |
| (line 121) |
| * aio_cancel: Cancel AIO Operations. |
| (line 19) |
| * aio_cancel64: Cancel AIO Operations. |
| (line 63) |
| * aio_error: Status of AIO Operations. |
| (line 15) |
| * aio_error64: Status of AIO Operations. |
| (line 33) |
| * aio_fsync: Synchronizing AIO Operations. |
| (line 18) |
| * aio_fsync64: Synchronizing AIO Operations. |
| (line 66) |
| * aio_init: Configuration of AIO. |
| (line 47) |
| * aio_read: Asynchronous Reads/Writes. |
| (line 7) |
| * aio_read64: Asynchronous Reads/Writes. |
| (line 73) |
| * aio_return: Status of AIO Operations. |
| (line 43) |
| * aio_return64: Status of AIO Operations. |
| (line 63) |
| * aio_suspend: Synchronizing AIO Operations. |
| (line 90) |
| * aio_suspend64: Synchronizing AIO Operations. |
| (line 127) |
| * aio_write: Asynchronous Reads/Writes. |
| (line 89) |
| * aio_write64: Asynchronous Reads/Writes. |
| (line 155) |
| * alarm: Setting an Alarm. (line 103) |
| * alloca: Variable Size Automatic. |
| (line 19) |
| * alphasort: Scanning Directory Content. |
| (line 40) |
| * alphasort64: Scanning Directory Content. |
| (line 75) |
| * argp_error: Argp Helper Functions. |
| (line 18) |
| * argp_failure: Argp Helper Functions. |
| (line 25) |
| * argp_help: Argp Help. (line 16) |
| * argp_parse: Argp. (line 36) |
| * argp_state_help: Argp Helper Functions. |
| (line 39) |
| * argp_usage: Argp Helper Functions. |
| (line 12) |
| * argz_add: Argz Functions. (line 66) |
| * argz_add_sep: Argz Functions. (line 71) |
| * argz_append: Argz Functions. (line 79) |
| * argz_count: Argz Functions. (line 41) |
| * argz_create: Argz Functions. (line 28) |
| * argz_create_sep: Argz Functions. (line 35) |
| * argz_delete: Argz Functions. (line 85) |
| * argz_extract: Argz Functions. (line 46) |
| * argz_insert: Argz Functions. (line 94) |
| * argz_next: Argz Functions. (line 104) |
| * argz_replace: Argz Functions. (line 132) |
| * argz_stringify: Argz Functions. (line 59) |
| * asctime: Formatting Calendar Time. |
| (line 10) |
| * asctime_r: Formatting Calendar Time. |
| (line 28) |
| * asin: Inverse Trig Functions. |
| (line 11) |
| * asinf: Inverse Trig Functions. |
| (line 12) |
| * asinh: Hyperbolic Functions. |
| (line 52) |
| * asinhf: Hyperbolic Functions. |
| (line 53) |
| * asinhl: Hyperbolic Functions. |
| (line 54) |
| * asinl: Inverse Trig Functions. |
| (line 13) |
| * asprintf: Dynamic Output. (line 10) |
| * assert: Consistency Checking. |
| (line 27) |
| * assert_perror: Consistency Checking. |
| (line 59) |
| * atan: Inverse Trig Functions. |
| (line 35) |
| * atan2: Inverse Trig Functions. |
| (line 44) |
| * atan2f: Inverse Trig Functions. |
| (line 45) |
| * atan2l: Inverse Trig Functions. |
| (line 46) |
| * atanf: Inverse Trig Functions. |
| (line 36) |
| * atanh: Hyperbolic Functions. |
| (line 65) |
| * atanhf: Hyperbolic Functions. |
| (line 66) |
| * atanhl: Hyperbolic Functions. |
| (line 67) |
| * atanl: Inverse Trig Functions. |
| (line 37) |
| * atexit: Cleanups on Exit. (line 15) |
| * atof: Parsing of Floats. (line 104) |
| * atoi: Parsing of Integers. (line 196) |
| * atol: Parsing of Integers. (line 190) |
| * atoll: Parsing of Integers. (line 201) |
| * backtrace: Backtraces. (line 16) |
| * backtrace_symbols: Backtraces. (line 35) |
| * backtrace_symbols_fd: Backtraces. (line 65) |
| * basename: Finding Tokens in a String. |
| (line 202) |
| * bcmp: String/Array Comparison. |
| (line 220) |
| * bcopy: Copying and Concatenation. |
| (line 625) |
| * bind: Setting Address. (line 13) |
| * bind_textdomain_codeset: Charset conversion in gettext. |
| (line 28) |
| * bindtextdomain: Locating gettext catalog. |
| (line 100) |
| * brk: Resizing the Data Segment. |
| (line 15) |
| * bsearch: Array Search Function. |
| (line 49) |
| * btowc: Converting a Character. |
| (line 16) |
| * bzero: Copying and Concatenation. |
| (line 631) |
| * cabs: Absolute Value. (line 39) |
| * cabsf: Absolute Value. (line 40) |
| * cabsl: Absolute Value. (line 41) |
| * cacos: Inverse Trig Functions. |
| (line 72) |
| * cacosf: Inverse Trig Functions. |
| (line 73) |
| * cacosh: Hyperbolic Functions. |
| (line 79) |
| * cacoshf: Hyperbolic Functions. |
| (line 80) |
| * cacoshl: Hyperbolic Functions. |
| (line 81) |
| * cacosl: Inverse Trig Functions. |
| (line 74) |
| * calloc: Allocating Cleared Space. |
| (line 10) |
| * canonicalize_file_name: Symbolic Links. (line 121) |
| * carg: Operations on Complex. |
| (line 29) |
| * cargf: Operations on Complex. |
| (line 30) |
| * cargl: Operations on Complex. |
| (line 31) |
| * casin: Inverse Trig Functions. |
| (line 63) |
| * casinf: Inverse Trig Functions. |
| (line 64) |
| * casinh: Hyperbolic Functions. |
| (line 73) |
| * casinhf: Hyperbolic Functions. |
| (line 74) |
| * casinhl: Hyperbolic Functions. |
| (line 75) |
| * casinl: Inverse Trig Functions. |
| (line 65) |
| * catan: Inverse Trig Functions. |
| (line 81) |
| * catanf: Inverse Trig Functions. |
| (line 82) |
| * catanh: Hyperbolic Functions. |
| (line 86) |
| * catanhf: Hyperbolic Functions. |
| (line 87) |
| * catanhl: Hyperbolic Functions. |
| (line 88) |
| * catanl: Inverse Trig Functions. |
| (line 83) |
| * catclose: The catgets Functions. |
| (line 183) |
| * catgets: The catgets Functions. |
| (line 149) |
| * catopen: The catgets Functions. |
| (line 7) |
| * cbc_crypt: DES Encryption. (line 117) |
| * cbrt: Exponents and Logarithms. |
| (line 131) |
| * cbrtf: Exponents and Logarithms. |
| (line 132) |
| * cbrtl: Exponents and Logarithms. |
| (line 133) |
| * ccos: Trig Functions. (line 71) |
| * ccosf: Trig Functions. (line 72) |
| * ccosh: Hyperbolic Functions. |
| (line 40) |
| * ccoshf: Hyperbolic Functions. |
| (line 41) |
| * ccoshl: Hyperbolic Functions. |
| (line 42) |
| * ccosl: Trig Functions. (line 73) |
| * ceil: Rounding Functions. (line 19) |
| * ceilf: Rounding Functions. (line 20) |
| * ceill: Rounding Functions. (line 21) |
| * cexp: Exponents and Logarithms. |
| (line 164) |
| * cexpf: Exponents and Logarithms. |
| (line 165) |
| * cexpl: Exponents and Logarithms. |
| (line 166) |
| * cfgetispeed: Line Speed. (line 37) |
| * cfgetospeed: Line Speed. (line 33) |
| * cfmakeraw: Noncanonical Input. (line 93) |
| * cfree: Freeing after Malloc. |
| (line 15) |
| * cfsetispeed: Line Speed. (line 46) |
| * cfsetospeed: Line Speed. (line 41) |
| * cfsetspeed: Line Speed. (line 51) |
| * chdir: Working Directory. (line 98) |
| * chmod: Setting Permissions. (line 25) |
| * chown: File Owner. (line 34) |
| * cimag: Operations on Complex. |
| (line 17) |
| * cimagf: Operations on Complex. |
| (line 18) |
| * cimagl: Operations on Complex. |
| (line 19) |
| * clearenv: Environment Access. (line 79) |
| * clearerr: Error Recovery. (line 10) |
| * clearerr_unlocked: Error Recovery. (line 17) |
| * clock: CPU Time. (line 46) |
| * clog: Exponents and Logarithms. |
| (line 172) |
| * clog10: Exponents and Logarithms. |
| (line 183) |
| * clog10f: Exponents and Logarithms. |
| (line 184) |
| * clog10l: Exponents and Logarithms. |
| (line 185) |
| * clogf: Exponents and Logarithms. |
| (line 173) |
| * clogl: Exponents and Logarithms. |
| (line 174) |
| * close: Opening and Closing Files. |
| (line 136) |
| * closedir: Reading/Closing Directory. |
| (line 91) |
| * closelog: closelog. (line 10) |
| * confstr: String Parameters. (line 10) |
| * conj: Operations on Complex. |
| (line 22) |
| * conjf: Operations on Complex. |
| (line 23) |
| * conjl: Operations on Complex. |
| (line 24) |
| * connect: Connecting. (line 13) |
| * copysign: FP Bit Twiddling. (line 11) |
| * copysignf: FP Bit Twiddling. (line 12) |
| * copysignl: FP Bit Twiddling. (line 13) |
| * cos: Trig Functions. (line 25) |
| * cosf: Trig Functions. (line 26) |
| * cosh: Hyperbolic Functions. |
| (line 17) |
| * coshf: Hyperbolic Functions. |
| (line 18) |
| * coshl: Hyperbolic Functions. |
| (line 19) |
| * cosl: Trig Functions. (line 27) |
| * cpow: Exponents and Logarithms. |
| (line 201) |
| * cpowf: Exponents and Logarithms. |
| (line 203) |
| * cpowl: Exponents and Logarithms. |
| (line 205) |
| * cproj: Operations on Complex. |
| (line 40) |
| * cprojf: Operations on Complex. |
| (line 41) |
| * cprojl: Operations on Complex. |
| (line 42) |
| * CPU_CLR: CPU Affinity. (line 78) |
| * CPU_ISSET: CPU Affinity. (line 86) |
| * CPU_SET: CPU Affinity. (line 70) |
| * CPU_ZERO: CPU Affinity. (line 65) |
| * creal: Operations on Complex. |
| (line 12) |
| * crealf: Operations on Complex. |
| (line 13) |
| * creall: Operations on Complex. |
| (line 14) |
| * creat: Opening and Closing Files. |
| (line 105) |
| * creat64: Opening and Closing Files. |
| (line 121) |
| * crypt: crypt. (line 7) |
| * crypt_r: crypt. (line 114) |
| * csin: Trig Functions. (line 63) |
| * csinf: Trig Functions. (line 64) |
| * csinh: Hyperbolic Functions. |
| (line 34) |
| * csinhf: Hyperbolic Functions. |
| (line 35) |
| * csinhl: Hyperbolic Functions. |
| (line 36) |
| * csinl: Trig Functions. (line 65) |
| * csqrt: Exponents and Logarithms. |
| (line 193) |
| * csqrtf: Exponents and Logarithms. |
| (line 194) |
| * csqrtl: Exponents and Logarithms. |
| (line 195) |
| * ctan: Trig Functions. (line 79) |
| * ctanf: Trig Functions. (line 80) |
| * ctanh: Hyperbolic Functions. |
| (line 46) |
| * ctanhf: Hyperbolic Functions. |
| (line 47) |
| * ctanhl: Hyperbolic Functions. |
| (line 48) |
| * ctanl: Trig Functions. (line 81) |
| * ctermid: Identifying the Terminal. |
| (line 16) |
| * ctime: Formatting Calendar Time. |
| (line 38) |
| * ctime_r: Formatting Calendar Time. |
| (line 48) |
| * cuserid: Who Logged In. (line 24) |
| * dcgettext: Translation with gettext. |
| (line 88) |
| * dcngettext: Advanced gettext functions. |
| (line 99) |
| * DES_FAILED: DES Encryption. (line 112) |
| * des_setparity: DES Encryption. (line 139) |
| * dgettext: Translation with gettext. |
| (line 76) |
| * difftime: Elapsed Time. (line 11) |
| * dirfd: Opening a Directory. (line 92) |
| * dirname: Finding Tokens in a String. |
| (line 262) |
| * div: Integer Division. (line 30) |
| * dngettext: Advanced gettext functions. |
| (line 91) |
| * drand48: SVID Random. (line 34) |
| * drand48_r: SVID Random. (line 158) |
| * drem: Remainder Functions. (line 27) |
| * dremf: Remainder Functions. (line 28) |
| * dreml: Remainder Functions. (line 30) |
| * DTTOIF: Directory Entries. (line 68) |
| * dup: Duplicating Descriptors. |
| (line 24) |
| * dup2: Duplicating Descriptors. |
| (line 29) |
| * ecb_crypt: DES Encryption. (line 61) |
| * ecvt: System V Number Conversion. |
| (line 18) |
| * ecvt_r: System V Number Conversion. |
| (line 94) |
| * encrypt: DES Encryption. (line 40) |
| * encrypt_r: DES Encryption. (line 50) |
| * endfsent: fstab. (line 94) |
| * endgrent: Scanning All Groups. (line 66) |
| * endhostent: Host Names. (line 207) |
| * endmntent: mtab. (line 121) |
| * endnetent: Networks Database. (line 67) |
| * endnetgrent: Lookup Netgroup. (line 65) |
| * endprotoent: Protocols Database. (line 78) |
| * endpwent: Scanning All Users. (line 66) |
| * endservent: Services Database. (line 69) |
| * endutent: Manipulating the Database. |
| (line 132) |
| * endutxent: XPG Functions. (line 85) |
| * envz_add: Envz Functions. (line 44) |
| * envz_entry: Envz Functions. (line 30) |
| * envz_get: Envz Functions. (line 37) |
| * envz_merge: Envz Functions. (line 52) |
| * envz_strip: Envz Functions. (line 62) |
| * erand48: SVID Random. (line 44) |
| * erand48_r: SVID Random. (line 173) |
| * erf: Special Functions. (line 10) |
| * erfc: Special Functions. (line 17) |
| * erfcf: Special Functions. (line 18) |
| * erfcl: Special Functions. (line 19) |
| * erff: Special Functions. (line 11) |
| * erfl: Special Functions. (line 12) |
| * err: Error Messages. (line 291) |
| * error: Error Messages. (line 145) |
| * error_at_line: Error Messages. (line 179) |
| * errx: Error Messages. (line 302) |
| * execl: Executing a File. (line 34) |
| * execle: Executing a File. (line 47) |
| * execlp: Executing a File. (line 64) |
| * execv: Executing a File. (line 18) |
| * execve: Executing a File. (line 40) |
| * execvp: Executing a File. (line 54) |
| * exit: Normal Termination. (line 11) |
| * exp: Exponents and Logarithms. |
| (line 7) |
| * exp10: Exponents and Logarithms. |
| (line 22) |
| * exp10f: Exponents and Logarithms. |
| (line 23) |
| * exp10l: Exponents and Logarithms. |
| (line 24) |
| * exp2: Exponents and Logarithms. |
| (line 16) |
| * exp2f: Exponents and Logarithms. |
| (line 17) |
| * exp2l: Exponents and Logarithms. |
| (line 18) |
| * expf: Exponents and Logarithms. |
| (line 8) |
| * expl: Exponents and Logarithms. |
| (line 9) |
| * expm1: Exponents and Logarithms. |
| (line 147) |
| * expm1f: Exponents and Logarithms. |
| (line 148) |
| * expm1l: Exponents and Logarithms. |
| (line 149) |
| * fabs: Absolute Value. (line 33) |
| * fabsf: Absolute Value. (line 34) |
| * fabsl: Absolute Value. (line 35) |
| * fchdir: Working Directory. (line 108) |
| * fchmod: Setting Permissions. (line 104) |
| * fchown: File Owner. (line 65) |
| * fclean: Cleaning Streams. (line 9) |
| * fclose: Closing Streams. (line 11) |
| * fcloseall: Closing Streams. (line 30) |
| * fcntl: Control Operations. (line 18) |
| * fcvt: System V Number Conversion. |
| (line 40) |
| * fcvt_r: System V Number Conversion. |
| (line 103) |
| * FD_CLR: Waiting for I/O. (line 59) |
| * FD_ISSET: Waiting for I/O. (line 65) |
| * FD_SET: Waiting for I/O. (line 53) |
| * FD_ZERO: Waiting for I/O. (line 49) |
| * fdatasync: Synchronizing I/O. (line 62) |
| * fdim: Misc FP Arithmetic. (line 31) |
| * fdimf: Misc FP Arithmetic. (line 32) |
| * fdiml: Misc FP Arithmetic. (line 33) |
| * fdopen: Descriptors and Streams. |
| (line 12) |
| * fdopendir: Opening a Directory. (line 53) |
| * feclearexcept: Status bit operations. |
| (line 39) |
| * fedisableexcept: Control Functions. (line 98) |
| * feenableexcept: Control Functions. (line 88) |
| * fegetenv: Control Functions. (line 30) |
| * fegetexcept: Control Functions. (line 108) |
| * fegetexceptflag: Status bit operations. |
| (line 89) |
| * fegetround: Rounding. (line 71) |
| * feholdexcept: Control Functions. (line 37) |
| * feof: EOF and Errors. (line 32) |
| * feof_unlocked: EOF and Errors. (line 38) |
| * feraiseexcept: Status bit operations. |
| (line 46) |
| * ferror: EOF and Errors. (line 46) |
| * ferror_unlocked: EOF and Errors. (line 53) |
| * fesetenv: Control Functions. (line 66) |
| * fesetexceptflag: Status bit operations. |
| (line 97) |
| * fesetround: Rounding. (line 77) |
| * fetestexcept: Status bit operations. |
| (line 58) |
| * feupdateenv: Control Functions. (line 72) |
| * fflush: Flushing Buffers. (line 26) |
| * fflush_unlocked: Flushing Buffers. (line 34) |
| * fgetc: Character Input. (line 23) |
| * fgetc_unlocked: Character Input. (line 34) |
| * fgetgrent: Scanning All Groups. (line 14) |
| * fgetgrent_r: Scanning All Groups. (line 25) |
| * fgetpos: Portable Positioning. |
| (line 77) |
| * fgetpos64: Portable Positioning. |
| (line 88) |
| * fgetpwent: Scanning All Users. (line 14) |
| * fgetpwent_r: Scanning All Users. (line 24) |
| * fgets: Line Input. (line 74) |
| * fgets_unlocked: Line Input. (line 115) |
| * fgetwc: Character Input. (line 29) |
| * fgetwc_unlocked: Character Input. (line 38) |
| * fgetws: Line Input. (line 94) |
| * fgetws_unlocked: Line Input. (line 122) |
| * fileno: Descriptors and Streams. |
| (line 37) |
| * fileno_unlocked: Descriptors and Streams. |
| (line 43) |
| * finite: Floating Point Classes. |
| (line 92) |
| * finitef: Floating Point Classes. |
| (line 93) |
| * finitel: Floating Point Classes. |
| (line 94) |
| * flockfile: Streams and Threads. (line 31) |
| * floor: Rounding Functions. (line 25) |
| * floorf: Rounding Functions. (line 26) |
| * floorl: Rounding Functions. (line 27) |
| * fma: Misc FP Arithmetic. (line 40) |
| * fmaf: Misc FP Arithmetic. (line 41) |
| * fmal: Misc FP Arithmetic. (line 43) |
| * fmax: Misc FP Arithmetic. (line 23) |
| * fmaxf: Misc FP Arithmetic. (line 24) |
| * fmaxl: Misc FP Arithmetic. (line 25) |
| * fmemopen: String Streams. (line 11) |
| * fmin: Misc FP Arithmetic. (line 12) |
| * fminf: Misc FP Arithmetic. (line 13) |
| * fminl: Misc FP Arithmetic. (line 14) |
| * fmod: Remainder Functions. (line 11) |
| * fmodf: Remainder Functions. (line 12) |
| * fmodl: Remainder Functions. (line 14) |
| * fmtmsg: Printing Formatted Messages. |
| (line 55) |
| * fnmatch: Wildcard Matching. (line 13) |
| * fopen: Opening Streams. (line 14) |
| * fopen64: Opening Streams. (line 110) |
| * fopencookie: Streams and Cookies. (line 58) |
| * fork: Creating a Process. (line 10) |
| * forkpty: Pseudo-Terminal Pairs. |
| (line 37) |
| * fpathconf: Pathconf. (line 36) |
| * fpclassify: Floating Point Classes. |
| (line 10) |
| * fprintf: Formatted Output Functions. |
| (line 26) |
| * fputc: Simple Output. (line 13) |
| * fputc_unlocked: Simple Output. (line 23) |
| * fputs: Simple Output. (line 75) |
| * fputs_unlocked: Simple Output. (line 101) |
| * fputwc: Simple Output. (line 18) |
| * fputwc_unlocked: Simple Output. (line 27) |
| * fputws: Simple Output. (line 92) |
| * fputws_unlocked: Simple Output. (line 107) |
| * fread: Block Input/Output. (line 29) |
| * fread_unlocked: Block Input/Output. (line 43) |
| * free: Freeing after Malloc. |
| (line 11) |
| * freopen: Opening Streams. (line 134) |
| * freopen64: Opening Streams. (line 158) |
| * frexp: Normalization Functions. |
| (line 17) |
| * frexpf: Normalization Functions. |
| (line 18) |
| * frexpl: Normalization Functions. |
| (line 19) |
| * fscanf: Formatted Input Functions. |
| (line 32) |
| * fseek: File Positioning. (line 63) |
| * fseeko: File Positioning. (line 79) |
| * fseeko64: File Positioning. (line 98) |
| * fsetpos: Portable Positioning. |
| (line 96) |
| * fsetpos64: Portable Positioning. |
| (line 110) |
| * fstat: Reading Attributes. (line 43) |
| * fstat64: Reading Attributes. (line 58) |
| * fsync: Synchronizing I/O. (line 30) |
| * ftell: File Positioning. (line 22) |
| * ftello: File Positioning. (line 31) |
| * ftello64: File Positioning. (line 52) |
| * ftruncate: File Size. (line 77) |
| * ftruncate64: File Size. (line 131) |
| * ftrylockfile: Streams and Threads. (line 39) |
| * ftw: Working with Directory Trees. |
| (line 127) |
| * ftw64: Working with Directory Trees. |
| (line 176) |
| * funlockfile: Streams and Threads. (line 47) |
| * futimes: File Times. (line 121) |
| * fwide: Streams and I18N. (line 59) |
| * fwprintf: Formatted Output Functions. |
| (line 30) |
| * fwrite: Block Input/Output. (line 50) |
| * fwrite_unlocked: Block Input/Output. (line 57) |
| * fwscanf: Formatted Input Functions. |
| (line 36) |
| * gamma: Special Functions. (line 51) |
| * gammaf: Special Functions. (line 52) |
| * gammal: Special Functions. (line 53) |
| * gcvt: System V Number Conversion. |
| (line 55) |
| * get_avphys_pages: Query Memory Parameters. |
| (line 72) |
| * get_current_dir_name: Working Directory. (line 87) |
| * get_nprocs: Processor Resources. (line 35) |
| * get_nprocs_conf: Processor Resources. (line 29) |
| * get_phys_pages: Query Memory Parameters. |
| (line 65) |
| * getc: Character Input. (line 44) |
| * getc_unlocked: Character Input. (line 57) |
| * getchar: Character Input. (line 67) |
| * getchar_unlocked: Character Input. (line 75) |
| * getcontext: System V contexts. (line 49) |
| * getcwd: Working Directory. (line 24) |
| * getdate: General Time String Parsing. |
| (line 45) |
| * getdate_r: General Time String Parsing. |
| (line 146) |
| * getdelim: Line Input. (line 55) |
| * getdomainnname: Host Identification. (line 99) |
| * getegid: Reading Persona. (line 30) |
| * getenv: Environment Access. (line 13) |
| * geteuid: Reading Persona. (line 26) |
| * getfsent: fstab. (line 99) |
| * getfsfile: fstab. (line 124) |
| * getfsspec: fstab. (line 110) |
| * getgid: Reading Persona. (line 23) |
| * getgrent: Scanning All Groups. (line 48) |
| * getgrent_r: Scanning All Groups. (line 56) |
| * getgrgid: Lookup Group. (line 11) |
| * getgrgid_r: Lookup Group. (line 20) |
| * getgrnam: Lookup Group. (line 37) |
| * getgrnam_r: Lookup Group. (line 47) |
| * getgrouplist: Setting Groups. (line 99) |
| * getgroups: Reading Persona. (line 34) |
| * gethostbyaddr: Host Names. (line 77) |
| * gethostbyaddr_r: Host Names. (line 174) |
| * gethostbyname: Host Names. (line 67) |
| * gethostbyname2: Host Names. (line 71) |
| * gethostbyname2_r: Host Names. (line 166) |
| * gethostbyname_r: Host Names. (line 117) |
| * gethostent: Host Names. (line 203) |
| * gethostid: Host Identification. (line 117) |
| * gethostname: Host Identification. (line 55) |
| * getitimer: Setting an Alarm. (line 84) |
| * getline: Line Input. (line 21) |
| * getloadavg: Processor Resources. (line 47) |
| * getlogin: Who Logged In. (line 17) |
| * getmntent: mtab. (line 129) |
| * getmntent_r: mtab. (line 154) |
| * getnetbyaddr: Networks Database. (line 43) |
| * getnetbyname: Networks Database. (line 38) |
| * getnetent: Networks Database. (line 63) |
| * getnetgrent: Lookup Netgroup. (line 36) |
| * getnetgrent_r: Lookup Netgroup. (line 50) |
| * getopt: Using Getopt. (line 35) |
| * getopt_long: Getopt Long Options. (line 44) |
| * getopt_long_only: Getopt Long Options. (line 95) |
| * getpagesize: Query Memory Parameters. |
| (line 34) |
| * getpass: getpass. (line 11) |
| * getpeername: Who is Connected. (line 8) |
| * getpgid: Process Group Functions. |
| (line 67) |
| * getpgrp: Process Group Functions. |
| (line 58) |
| * getpid: Process Identification. |
| (line 17) |
| * getppid: Process Identification. |
| (line 21) |
| * getpriority: Traditional Scheduling Functions. |
| (line 25) |
| * getprotobyname: Protocols Database. (line 51) |
| * getprotobynumber: Protocols Database. (line 56) |
| * getprotoent: Protocols Database. (line 74) |
| * getpt: Allocation. (line 11) |
| * getpwent: Scanning All Users. (line 47) |
| * getpwent_r: Scanning All Users. (line 57) |
| * getpwnam: Lookup User. (line 37) |
| * getpwnam_r: Lookup User. (line 47) |
| * getpwuid: Lookup User. (line 11) |
| * getpwuid_r: Lookup User. (line 20) |
| * getrlimit: Limits on Resources. (line 30) |
| * getrlimit64: Limits on Resources. (line 41) |
| * getrusage: Resource Usage. (line 11) |
| * gets: Line Input. (line 128) |
| * getservbyname: Services Database. (line 37) |
| * getservbyport: Services Database. (line 47) |
| * getservent: Services Database. (line 65) |
| * getsid: Process Group Functions. |
| (line 31) |
| * getsockname: Reading Address. (line 12) |
| * getsockopt: Socket Option Functions. |
| (line 11) |
| * getsubopt: Suboptions. (line 17) |
| * gettext: Translation with gettext. |
| (line 32) |
| * gettimeofday: High-Resolution Calendar. |
| (line 31) |
| * getuid: Reading Persona. (line 20) |
| * getumask: Setting Permissions. (line 64) |
| * getutent: Manipulating the Database. |
| (line 122) |
| * getutent_r: Manipulating the Database. |
| (line 205) |
| * getutid: Manipulating the Database. |
| (line 135) |
| * getutid_r: Manipulating the Database. |
| (line 220) |
| * getutline: Manipulating the Database. |
| (line 161) |
| * getutline_r: Manipulating the Database. |
| (line 233) |
| * getutmp: XPG Functions. (line 112) |
| * getutmpx: XPG Functions. (line 117) |
| * getutxent: XPG Functions. (line 80) |
| * getutxid: XPG Functions. (line 89) |
| * getutxline: XPG Functions. (line 94) |
| * getw: Character Input. (line 116) |
| * getwc: Character Input. (line 51) |
| * getwc_unlocked: Character Input. (line 61) |
| * getwchar: Character Input. (line 71) |
| * getwchar_unlocked: Character Input. (line 79) |
| * getwd: Working Directory. (line 76) |
| * glob: Calling Glob. (line 162) |
| * glob64: Calling Glob. (line 218) |
| * globfree: More Flags for Globbing. |
| (line 124) |
| * globfree64: More Flags for Globbing. |
| (line 130) |
| * gmtime: Broken-down Time. (line 120) |
| * gmtime_r: Broken-down Time. (line 132) |
| * grantpt: Allocation. (line 23) |
| * gsignal: Signaling Yourself. (line 16) |
| * gtty: BSD Terminal Modes. (line 35) |
| * hasmntopt: mtab. (line 196) |
| * hcreate: Hash Search Function. |
| (line 14) |
| * hcreate_r: Hash Search Function. |
| (line 107) |
| * hdestroy: Hash Search Function. |
| (line 40) |
| * hdestroy_r: Hash Search Function. |
| (line 122) |
| * hsearch: Hash Search Function. |
| (line 80) |
| * hsearch_r: Hash Search Function. |
| (line 129) |
| * htonl: Byte Order. (line 44) |
| * htons: Byte Order. (line 36) |
| * hypot: Exponents and Logarithms. |
| (line 137) |
| * hypotf: Exponents and Logarithms. |
| (line 138) |
| * hypotl: Exponents and Logarithms. |
| (line 139) |
| * iconv: Generic Conversion Interface. |
| (line 110) |
| * iconv_close: Generic Conversion Interface. |
| (line 89) |
| * iconv_open: Generic Conversion Interface. |
| (line 28) |
| * if_freenameindex: Interface Naming. (line 57) |
| * if_indextoname: Interface Naming. (line 30) |
| * if_nameindex: Interface Naming. (line 48) |
| * if_nametoindex: Interface Naming. (line 25) |
| * IFTODT: Directory Entries. (line 65) |
| * ilogb: Exponents and Logarithms. |
| (line 69) |
| * ilogbf: Exponents and Logarithms. |
| (line 70) |
| * ilogbl: Exponents and Logarithms. |
| (line 71) |
| * imaxabs: Absolute Value. (line 21) |
| * imaxdiv: Integer Division. (line 101) |
| * index: Search Functions. (line 261) |
| * inet_addr: Host Address Functions. |
| (line 19) |
| * inet_aton: Host Address Functions. |
| (line 13) |
| * inet_lnaof: Host Address Functions. |
| (line 60) |
| * inet_makeaddr: Host Address Functions. |
| (line 55) |
| * inet_netof: Host Address Functions. |
| (line 68) |
| * inet_network: Host Address Functions. |
| (line 28) |
| * inet_ntoa: Host Address Functions. |
| (line 38) |
| * inet_ntop: Host Address Functions. |
| (line 85) |
| * inet_pton: Host Address Functions. |
| (line 76) |
| * initgroups: Setting Groups. (line 81) |
| * initstate: BSD Random. (line 32) |
| * initstate_r: BSD Random. (line 89) |
| * innetgr: Netgroup Membership. (line 12) |
| * int: Random Access Directory. |
| (line 20) |
| * ioctl: IOCTLs. (line 33) |
| * isalnum: Classification of Characters. |
| (line 49) |
| * isalpha: Classification of Characters. |
| (line 36) |
| * isascii: Classification of Characters. |
| (line 104) |
| * isatty: Is It a Terminal. (line 14) |
| * isblank: Classification of Characters. |
| (line 86) |
| * iscntrl: Classification of Characters. |
| (line 100) |
| * isdigit: Classification of Characters. |
| (line 46) |
| * isfinite: Floating Point Classes. |
| (line 46) |
| * isgraph: Classification of Characters. |
| (line 91) |
| * isgreater: FP Comparison Functions. |
| (line 20) |
| * isgreaterequal: FP Comparison Functions. |
| (line 25) |
| * isinf: Floating Point Classes. |
| (line 73) |
| * isinff: Floating Point Classes. |
| (line 74) |
| * isinfl: Floating Point Classes. |
| (line 75) |
| * isless: FP Comparison Functions. |
| (line 30) |
| * islessequal: FP Comparison Functions. |
| (line 35) |
| * islessgreater: FP Comparison Functions. |
| (line 40) |
| * islower: Classification of Characters. |
| (line 28) |
| * isnan: Floating Point Classes. |
| (line 61) |
| * isnanf: Floating Point Classes. |
| (line 80) |
| * isnanl: Floating Point Classes. |
| (line 81) |
| * isnormal: Floating Point Classes. |
| (line 55) |
| * isprint: Classification of Characters. |
| (line 96) |
| * ispunct: Classification of Characters. |
| (line 59) |
| * isspace: Classification of Characters. |
| (line 63) |
| * isunordered: FP Comparison Functions. |
| (line 49) |
| * isupper: Classification of Characters. |
| (line 32) |
| * iswalnum: Classification of Wide Characters. |
| (line 69) |
| * iswalpha: Classification of Wide Characters. |
| (line 81) |
| * iswblank: Classification of Wide Characters. |
| (line 222) |
| * iswcntrl: Classification of Wide Characters. |
| (line 97) |
| * iswctype: Classification of Wide Characters. |
| (line 56) |
| * iswdigit: Classification of Wide Characters. |
| (line 107) |
| * iswgraph: Classification of Wide Characters. |
| (line 127) |
| * iswlower: Classification of Wide Characters. |
| (line 138) |
| * iswprint: Classification of Wide Characters. |
| (line 148) |
| * iswpunct: Classification of Wide Characters. |
| (line 158) |
| * iswspace: Classification of Wide Characters. |
| (line 168) |
| * iswupper: Classification of Wide Characters. |
| (line 197) |
| * iswxdigit: Classification of Wide Characters. |
| (line 207) |
| * isxdigit: Classification of Characters. |
| (line 54) |
| * j0: Special Functions. (line 68) |
| * j0f: Special Functions. (line 69) |
| * j0l: Special Functions. (line 70) |
| * j1: Special Functions. (line 74) |
| * j1f: Special Functions. (line 75) |
| * j1l: Special Functions. (line 76) |
| * jn: Special Functions. (line 80) |
| * jnf: Special Functions. (line 81) |
| * jnl: Special Functions. (line 82) |
| * jrand48: SVID Random. (line 77) |
| * jrand48_r: SVID Random. (line 226) |
| * kill: Signaling Another Process. |
| (line 27) |
| * killpg: Signaling Another Process. |
| (line 79) |
| * l64a: Encode Binary Data. (line 13) |
| * labs: Absolute Value. (line 19) |
| * lcong48: SVID Random. (line 129) |
| * lcong48_r: SVID Random. (line 282) |
| * ldexp: Normalization Functions. |
| (line 35) |
| * ldexpf: Normalization Functions. |
| (line 36) |
| * ldexpl: Normalization Functions. |
| (line 37) |
| * ldiv: Integer Division. (line 58) |
| * lfind: Array Search Function. |
| (line 13) |
| * lgamma: Special Functions. (line 23) |
| * lgamma_r: Special Functions. (line 44) |
| * lgammaf: Special Functions. (line 24) |
| * lgammaf_r: Special Functions. (line 45) |
| * lgammal: Special Functions. (line 25) |
| * lgammal_r: Special Functions. (line 46) |
| * link: Hard Links. (line 28) |
| * lio_listio: Asynchronous Reads/Writes. |
| (line 175) |
| * lio_listio64: Asynchronous Reads/Writes. |
| (line 258) |
| * listen: Listening. (line 30) |
| * llabs: Absolute Value. (line 20) |
| * lldiv: Integer Division. (line 77) |
| * llrint: Rounding Functions. (line 71) |
| * llrintf: Rounding Functions. (line 72) |
| * llrintl: Rounding Functions. (line 73) |
| * llround: Rounding Functions. (line 83) |
| * llroundf: Rounding Functions. (line 84) |
| * llroundl: Rounding Functions. (line 85) |
| * localeconv: The Lame Way to Locale Data. |
| (line 16) |
| * localtime: Broken-down Time. (line 85) |
| * localtime_r: Broken-down Time. (line 108) |
| * log: Exponents and Logarithms. |
| (line 34) |
| * log10: Exponents and Logarithms. |
| (line 44) |
| * log10f: Exponents and Logarithms. |
| (line 45) |
| * log10l: Exponents and Logarithms. |
| (line 46) |
| * log1p: Exponents and Logarithms. |
| (line 155) |
| * log1pf: Exponents and Logarithms. |
| (line 156) |
| * log1pl: Exponents and Logarithms. |
| (line 157) |
| * log2: Exponents and Logarithms. |
| (line 51) |
| * log2f: Exponents and Logarithms. |
| (line 52) |
| * log2l: Exponents and Logarithms. |
| (line 53) |
| * logb: Exponents and Logarithms. |
| (line 57) |
| * logbf: Exponents and Logarithms. |
| (line 58) |
| * logbl: Exponents and Logarithms. |
| (line 59) |
| * logf: Exponents and Logarithms. |
| (line 35) |
| * login: Logging In and Out. (line 22) |
| * login_tty: Logging In and Out. (line 14) |
| * logl: Exponents and Logarithms. |
| (line 36) |
| * logout: Logging In and Out. (line 34) |
| * logwtmp: Logging In and Out. (line 42) |
| * longjmp: Non-Local Details. (line 22) |
| * lrand48: SVID Random. (line 53) |
| * lrand48_r: SVID Random. (line 187) |
| * lrint: Rounding Functions. (line 65) |
| * lrintf: Rounding Functions. (line 66) |
| * lrintl: Rounding Functions. (line 67) |
| * lround: Rounding Functions. (line 77) |
| * lroundf: Rounding Functions. (line 78) |
| * lroundl: Rounding Functions. (line 79) |
| * lsearch: Array Search Function. |
| (line 29) |
| * lseek: File Position Primitive. |
| (line 16) |
| * lseek64: File Position Primitive. |
| (line 97) |
| * lstat: Reading Attributes. (line 69) |
| * lstat64: Reading Attributes. (line 79) |
| * lutimes: File Times. (line 108) |
| * madvise: Memory-mapped I/O. (line 237) |
| * main: Program Arguments. (line 6) |
| * makecontext: System V contexts. (line 73) |
| * mallinfo: Statistics of Malloc. |
| (line 56) |
| * malloc: Basic Allocation. (line 10) |
| * mallopt: Malloc Tunable Parameters. |
| (line 11) |
| * matherr: FP Exceptions. (line 24) |
| * mblen: Non-reentrant Character Conversion. |
| (line 73) |
| * mbrlen: Converting a Character. |
| (line 171) |
| * mbrtowc: Converting a Character. |
| (line 81) |
| * mbsinit: Keeping the state. (line 47) |
| * mbsnrtowcs: Converting Strings. (line 134) |
| * mbsrtowcs: Converting Strings. (line 15) |
| * mbstowcs: Non-reentrant String Conversion. |
| (line 13) |
| * mbtowc: Non-reentrant Character Conversion. |
| (line 8) |
| * mcheck: Heap Consistency Checking. |
| (line 11) |
| * memalign: Aligned Memory Blocks. |
| (line 18) |
| * memccpy: Copying and Concatenation. |
| (line 150) |
| * memchr: Search Functions. (line 11) |
| * memcmp: String/Array Comparison. |
| (line 25) |
| * memcpy: Copying and Concatenation. |
| (line 34) |
| * memfrob: Trivial Encryption. (line 18) |
| * memmem: Search Functions. (line 175) |
| * memmove: Copying and Concatenation. |
| (line 118) |
| * mempcpy: Copying and Concatenation. |
| (line 72) |
| * memrchr: Search Functions. (line 49) |
| * memset: Copying and Concatenation. |
| (line 157) |
| * mkdir: Creating Directories. |
| (line 10) |
| * mkdtemp: Temporary Files. (line 177) |
| * mkfifo: FIFO Special Files. (line 20) |
| * mknod: Making Special Files. |
| (line 13) |
| * mkstemp: Temporary Files. (line 159) |
| * mktemp: Temporary Files. (line 145) |
| * mktime: Broken-down Time. (line 139) |
| * mlock: Page Lock Functions. (line 20) |
| * mlockall: Page Lock Functions. (line 72) |
| * mmap: Memory-mapped I/O. (line 35) |
| * mmap64: Memory-mapped I/O. (line 128) |
| * modf: Rounding Functions. (line 89) |
| * modff: Rounding Functions. (line 90) |
| * modfl: Rounding Functions. (line 92) |
| * mount: Mount-Unmount-Remount. |
| (line 19) |
| * mprobe: Heap Consistency Checking. |
| (line 50) |
| * mrand48: SVID Random. (line 72) |
| * mrand48_r: SVID Random. (line 214) |
| * mremap: Memory-mapped I/O. (line 195) |
| * msync: Memory-mapped I/O. (line 161) |
| * mtrace: Tracing malloc. (line 7) |
| * munlock: Page Lock Functions. (line 65) |
| * munlockall: Page Lock Functions. (line 138) |
| * munmap: Memory-mapped I/O. (line 141) |
| * muntrace: Tracing malloc. (line 27) |
| * nan: FP Bit Twiddling. (line 55) |
| * nanf: FP Bit Twiddling. (line 56) |
| * nanl: FP Bit Twiddling. (line 57) |
| * nanosleep: Sleeping. (line 55) |
| * nearbyint: Rounding Functions. (line 52) |
| * nearbyintf: Rounding Functions. (line 53) |
| * nearbyintl: Rounding Functions. (line 54) |
| * nextafter: FP Bit Twiddling. (line 33) |
| * nextafterf: FP Bit Twiddling. (line 34) |
| * nextafterl: FP Bit Twiddling. (line 35) |
| * nexttoward: FP Bit Twiddling. (line 49) |
| * nexttowardf: FP Bit Twiddling. (line 50) |
| * nexttowardl: FP Bit Twiddling. (line 51) |
| * nftw: Working with Directory Trees. |
| (line 187) |
| * nftw64: Working with Directory Trees. |
| (line 250) |
| * ngettext: Advanced gettext functions. |
| (line 72) |
| * nice: Traditional Scheduling Functions. |
| (line 90) |
| * nl_langinfo: The Elegant and Fast Way. |
| (line 13) |
| * notfound: Actions in the NSS configuration. |
| (line 25) |
| * nrand48: SVID Random. (line 60) |
| * nrand48_r: SVID Random. (line 200) |
| * ntohl: Byte Order. (line 50) |
| * ntohs: Byte Order. (line 40) |
| * ntp_adjtime: High Accuracy Clock. (line 151) |
| * ntp_gettime: High Accuracy Clock. (line 36) |
| * obstack_1grow: Growing Objects. (line 46) |
| * obstack_1grow_fast: Extra Fast Growing. (line 32) |
| * obstack_alignment_mask: Obstacks Data Alignment. |
| (line 15) |
| * obstack_alloc: Allocation in an Obstack. |
| (line 11) |
| * obstack_base: Status of an Obstack. |
| (line 11) |
| * obstack_blank: Growing Objects. (line 30) |
| * obstack_blank_fast: Extra Fast Growing. (line 49) |
| * obstack_chunk_alloc: Preparing for Obstacks. |
| (line 11) |
| * obstack_chunk_free: Preparing for Obstacks. |
| (line 11) |
| * obstack_chunk_size: Obstack Chunks. (line 38) |
| * obstack_copy: Allocation in an Obstack. |
| (line 41) |
| * obstack_copy0: Allocation in an Obstack. |
| (line 47) |
| * obstack_finish: Growing Objects. (line 62) |
| * obstack_free: Freeing Obstack Objects. |
| (line 13) |
| * obstack_grow: Growing Objects. (line 35) |
| * obstack_grow0: Growing Objects. (line 41) |
| * obstack_init: Preparing for Obstacks. |
| (line 34) |
| * obstack_int_grow: Growing Objects. (line 57) |
| * obstack_int_grow_fast: Extra Fast Growing. (line 43) |
| * obstack_next_free: Status of an Obstack. |
| (line 22) |
| * obstack_object_size <1>: Status of an Obstack. |
| (line 28) |
| * obstack_object_size: Growing Objects. (line 78) |
| * obstack_printf: Dynamic Output. (line 37) |
| * obstack_ptr_grow: Growing Objects. (line 51) |
| * obstack_ptr_grow_fast: Extra Fast Growing. (line 37) |
| * obstack_room: Extra Fast Growing. (line 23) |
| * obstack_vprintf: Variable Arguments Output. |
| (line 98) |
| * offsetof: Structure Measurement. |
| (line 10) |
| * on_exit: Cleanups on Exit. (line 24) |
| * open: Opening and Closing Files. |
| (line 11) |
| * open64: Opening and Closing Files. |
| (line 93) |
| * open_memstream: String Streams. (line 73) |
| * open_obstack_stream: Obstack Streams. (line 10) |
| * opendir: Opening a Directory. (line 18) |
| * openlog: openlog. (line 10) |
| * openpty: Pseudo-Terminal Pairs. |
| (line 11) |
| * parse_printf_format: Parsing a Template String. |
| (line 17) |
| * pathconf: Pathconf. (line 14) |
| * pause: Using Pause. (line 11) |
| * pclose: Pipe to a Subprocess. |
| (line 39) |
| * perror: Error Messages. (line 46) |
| * pipe: Creating a Pipe. (line 17) |
| * popen: Pipe to a Subprocess. |
| (line 18) |
| * posix_memalign: Aligned Memory Blocks. |
| (line 26) |
| * pow: Exponents and Logarithms. |
| (line 112) |
| * pow10: Exponents and Logarithms. |
| (line 25) |
| * pow10f: Exponents and Logarithms. |
| (line 26) |
| * pow10l: Exponents and Logarithms. |
| (line 27) |
| * powf: Exponents and Logarithms. |
| (line 113) |
| * powl: Exponents and Logarithms. |
| (line 114) |
| * pread: I/O Primitives. (line 110) |
| * pread64: I/O Primitives. (line 143) |
| * printf: Formatted Output Functions. |
| (line 14) |
| * printf_size: Predefined Printf Handlers. |
| (line 12) |
| * printf_size_info: Predefined Printf Handlers. |
| (line 43) |
| * psignal: Signal Messages. (line 25) |
| * ptsname: Allocation. (line 74) |
| * ptsname_r: Allocation. (line 81) |
| * putc: Simple Output. (line 33) |
| * putc_unlocked: Simple Output. (line 47) |
| * putchar: Simple Output. (line 57) |
| * putchar_unlocked: Simple Output. (line 65) |
| * putenv: Environment Access. (line 21) |
| * putpwent: Writing a User Entry. |
| (line 7) |
| * puts: Simple Output. (line 113) |
| * pututline: Manipulating the Database. |
| (line 180) |
| * pututxline: XPG Functions. (line 99) |
| * putw: Simple Output. (line 126) |
| * putwc: Simple Output. (line 40) |
| * putwc_unlocked: Simple Output. (line 51) |
| * putwchar: Simple Output. (line 61) |
| * putwchar_unlocked: Simple Output. (line 69) |
| * pwrite: I/O Primitives. (line 265) |
| * pwrite64: I/O Primitives. (line 298) |
| * qecvt: System V Number Conversion. |
| (line 67) |
| * qecvt_r: System V Number Conversion. |
| (line 112) |
| * qfcvt: System V Number Conversion. |
| (line 73) |
| * qfcvt_r: System V Number Conversion. |
| (line 121) |
| * qgcvt: System V Number Conversion. |
| (line 78) |
| * qsort: Array Sort Function. (line 11) |
| * raise: Signaling Yourself. (line 10) |
| * rand: ISO Random. (line 20) |
| * rand_r: ISO Random. (line 36) |
| * random: BSD Random. (line 13) |
| * random_r: BSD Random. (line 78) |
| * rawmemchr: Search Functions. (line 24) |
| * read: I/O Primitives. (line 16) |
| * readdir: Reading/Closing Directory. |
| (line 11) |
| * readdir64: Reading/Closing Directory. |
| (line 75) |
| * readdir64_r: Reading/Closing Directory. |
| (line 84) |
| * readdir_r: Reading/Closing Directory. |
| (line 33) |
| * readlink: Symbolic Links. (line 71) |
| * readv: Scatter-Gather. (line 32) |
| * realloc: Changing Block Size. (line 16) |
| * realpath: Symbolic Links. (line 157) |
| * recv: Receiving Data. (line 12) |
| * recvfrom: Receiving Datagrams. (line 12) |
| * regcomp: POSIX Regexp Compilation. |
| (line 32) |
| * regerror: Regexp Cleanup. (line 25) |
| * regexec: Matching POSIX Regexps. |
| (line 14) |
| * regfree: Regexp Cleanup. (line 10) |
| * register_printf_function: Registering New Conversions. |
| (line 11) |
| * remainder: Remainder Functions. (line 43) |
| * remainderf: Remainder Functions. (line 44) |
| * remainderl: Remainder Functions. (line 46) |
| * remove: Deleting Files. (line 70) |
| * rename: Renaming Files. (line 9) |
| * rewind: File Positioning. (line 134) |
| * rewinddir: Random Access Directory. |
| (line 11) |
| * rindex: Search Functions. (line 267) |
| * rint: Rounding Functions. (line 39) |
| * rintf: Rounding Functions. (line 40) |
| * rintl: Rounding Functions. (line 41) |
| * rmdir: Deleting Files. (line 52) |
| * round: Rounding Functions. (line 58) |
| * roundf: Rounding Functions. (line 59) |
| * roundl: Rounding Functions. (line 60) |
| * rpmatch: Yes-or-No Questions. (line 16) |
| * S_ISBLK: Testing File Type. (line 34) |
| * S_ISCHR: Testing File Type. (line 30) |
| * S_ISDIR: Testing File Type. (line 27) |
| * S_ISFIFO: Testing File Type. (line 41) |
| * S_ISLNK: Testing File Type. (line 45) |
| * S_ISREG: Testing File Type. (line 38) |
| * S_ISSOCK: Testing File Type. (line 49) |
| * S_TYPEISMQ: Testing File Type. (line 99) |
| * S_TYPEISSEM: Testing File Type. (line 104) |
| * S_TYPEISSHM: Testing File Type. (line 109) |
| * scalb: Normalization Functions. |
| (line 49) |
| * scalbf: Normalization Functions. |
| (line 50) |
| * scalbl: Normalization Functions. |
| (line 51) |
| * scalbln: Normalization Functions. |
| (line 60) |
| * scalblnf: Normalization Functions. |
| (line 61) |
| * scalblnl: Normalization Functions. |
| (line 62) |
| * scalbn: Normalization Functions. |
| (line 54) |
| * scalbnf: Normalization Functions. |
| (line 55) |
| * scalbnl: Normalization Functions. |
| (line 56) |
| * scandir: Scanning Directory Content. |
| (line 14) |
| * scandir64: Scanning Directory Content. |
| (line 60) |
| * scanf: Formatted Input Functions. |
| (line 10) |
| * sched_get_priority_max: Basic Scheduling Functions. |
| (line 157) |
| * sched_get_priority_min: Basic Scheduling Functions. |
| (line 143) |
| * sched_getaffinity: CPU Affinity. (line 99) |
| * sched_getparam: Basic Scheduling Functions. |
| (line 122) |
| * sched_getscheduler: Basic Scheduling Functions. |
| (line 86) |
| * sched_rr_get_interval: Basic Scheduling Functions. |
| (line 172) |
| * sched_setaffinity: CPU Affinity. (line 122) |
| * sched_setparam: Basic Scheduling Functions. |
| (line 114) |
| * sched_setscheduler: Basic Scheduling Functions. |
| (line 36) |
| * sched_yield: Basic Scheduling Functions. |
| (line 188) |
| * seed48: SVID Random. (line 105) |
| * seed48_r: SVID Random. (line 268) |
| * seekdir: Random Access Directory. |
| (line 25) |
| * select: Waiting for I/O. (line 75) |
| * send: Sending Data. (line 14) |
| * sendto: Sending Datagrams. (line 19) |
| * setbuf: Controlling Buffering. |
| (line 78) |
| * setbuffer: Controlling Buffering. |
| (line 87) |
| * setcontext: System V contexts. (line 115) |
| * setdomainname: Host Identification. (line 108) |
| * setegid: Setting Groups. (line 11) |
| * setenv: Environment Access. (line 41) |
| * seteuid: Setting User ID. (line 11) |
| * setfsent: fstab. (line 82) |
| * setgid: Setting Groups. (line 27) |
| * setgrent: Scanning All Groups. (line 44) |
| * setgroups: Setting Groups. (line 70) |
| * sethostent: Host Names. (line 193) |
| * sethostid: Host Identification. (line 131) |
| * sethostname: Host Identification. (line 80) |
| * setitimer: Setting an Alarm. (line 69) |
| * setjmp: Non-Local Details. (line 16) |
| * setkey: DES Encryption. (line 34) |
| * setkey_r: DES Encryption. (line 48) |
| * setlinebuf: Controlling Buffering. |
| (line 95) |
| * setlocale: Setting the Locale. (line 25) |
| * setlogmask: setlogmask. (line 10) |
| * setmntent: mtab. (line 109) |
| * setnetent: Networks Database. (line 54) |
| * setnetgrent: Lookup Netgroup. (line 13) |
| * setpgid: Process Group Functions. |
| (line 83) |
| * setpgrp: Process Group Functions. |
| (line 115) |
| * setpriority: Traditional Scheduling Functions. |
| (line 47) |
| * setprotoent: Protocols Database. (line 65) |
| * setpwent: Scanning All Users. (line 43) |
| * setregid: Setting Groups. (line 38) |
| * setreuid: Setting User ID. (line 48) |
| * setrlimit: Limits on Resources. (line 51) |
| * setrlimit64: Limits on Resources. (line 69) |
| * setservent: Services Database. (line 56) |
| * setsid: Process Group Functions. |
| (line 11) |
| * setsockopt: Socket Option Functions. |
| (line 35) |
| * setstate: BSD Random. (line 43) |
| * setstate_r: BSD Random. (line 95) |
| * settimeofday: High-Resolution Calendar. |
| (line 51) |
| * setuid: Setting User ID. (line 34) |
| * setutent: Manipulating the Database. |
| (line 114) |
| * setutxent: XPG Functions. (line 76) |
| * setvbuf: Controlling Buffering. |
| (line 15) |
| * shutdown: Closing a Socket. (line 17) |
| * sigaction: Advanced Signal Handling. |
| (line 41) |
| * sigaddset: Signal Sets. (line 44) |
| * sigaltstack: Signal Stack. (line 71) |
| * sigblock: Blocking in BSD. (line 17) |
| * sigdelset: Signal Sets. (line 55) |
| * sigemptyset: Signal Sets. (line 36) |
| * sigfillset: Signal Sets. (line 40) |
| * siginterrupt: BSD Handler. (line 52) |
| * sigismember: Signal Sets. (line 64) |
| * siglongjmp: Non-Local Exits and Signals. |
| (line 30) |
| * sigmask: Blocking in BSD. (line 7) |
| * signal: Basic Signal Handling. |
| (line 21) |
| * signbit: FP Bit Twiddling. (line 24) |
| * significand: Normalization Functions. |
| (line 66) |
| * significandf: Normalization Functions. |
| (line 67) |
| * significandl: Normalization Functions. |
| (line 68) |
| * sigpause: Blocking in BSD. (line 29) |
| * sigpending: Checking for Pending Signals. |
| (line 10) |
| * sigprocmask: Process Signal Mask. (line 22) |
| * sigsetjmp: Non-Local Exits and Signals. |
| (line 25) |
| * sigsetmask: Blocking in BSD. (line 23) |
| * sigstack: Signal Stack. (line 112) |
| * sigsuspend: Sigsuspend. (line 12) |
| * sigvec: BSD Handler. (line 46) |
| * sin: Trig Functions. (line 19) |
| * sincos: Trig Functions. (line 46) |
| * sincosf: Trig Functions. (line 47) |
| * sincosl: Trig Functions. (line 49) |
| * sinf: Trig Functions. (line 20) |
| * sinh: Hyperbolic Functions. |
| (line 10) |
| * sinhf: Hyperbolic Functions. |
| (line 11) |
| * sinhl: Hyperbolic Functions. |
| (line 12) |
| * sinl: Trig Functions. (line 21) |
| * sleep: Sleeping. (line 15) |
| * snprintf: Formatted Output Functions. |
| (line 78) |
| * socket: Creating a Socket. (line 10) |
| * socketpair: Socket Pairs. (line 15) |
| * sprintf: Formatted Output Functions. |
| (line 34) |
| * sqrt: Exponents and Logarithms. |
| (line 123) |
| * sqrtf: Exponents and Logarithms. |
| (line 124) |
| * sqrtl: Exponents and Logarithms. |
| (line 125) |
| * srand: ISO Random. (line 24) |
| * srand48: SVID Random. (line 87) |
| * srand48_r: SVID Random. (line 255) |
| * srandom: BSD Random. (line 22) |
| * srandom_r: BSD Random. (line 83) |
| * sscanf: Formatted Input Functions. |
| (line 40) |
| * ssignal: Basic Signal Handling. |
| (line 138) |
| * stat: Reading Attributes. (line 12) |
| * stat64: Reading Attributes. (line 33) |
| * stime: Simple Calendar Time. |
| (line 40) |
| * stpcpy: Copying and Concatenation. |
| (line 261) |
| * stpncpy: Copying and Concatenation. |
| (line 304) |
| * strcasecmp: String/Array Comparison. |
| (line 112) |
| * strcasestr: Search Functions. (line 163) |
| * strcat: Copying and Concatenation. |
| (line 402) |
| * strchr: Search Functions. (line 56) |
| * strchrnul: Search Functions. (line 86) |
| * strcmp: String/Array Comparison. |
| (line 80) |
| * strcoll: Collation Functions. (line 39) |
| * strcpy: Copying and Concatenation. |
| (line 169) |
| * strcspn: Search Functions. (line 206) |
| * strdup: Copying and Concatenation. |
| (line 230) |
| * strdupa: Copying and Concatenation. |
| (line 351) |
| * strerror: Error Messages. (line 14) |
| * strerror_r: Error Messages. (line 28) |
| * strfmon: Formatting Numbers. (line 17) |
| * strfry: strfry. (line 16) |
| * strftime: Formatting Calendar Time. |
| (line 60) |
| * strlen: String Length. (line 10) |
| * strncasecmp: String/Array Comparison. |
| (line 143) |
| * strncat: Copying and Concatenation. |
| (line 560) |
| * strncmp: String/Array Comparison. |
| (line 130) |
| * strncpy: Copying and Concatenation. |
| (line 183) |
| * strndup: Copying and Concatenation. |
| (line 247) |
| * strndupa: Copying and Concatenation. |
| (line 389) |
| * strnlen: String Length. (line 79) |
| * strpbrk: Search Functions. (line 232) |
| * strptime: Low-Level Time String Parsing. |
| (line 13) |
| * strrchr: Search Functions. (line 120) |
| * strsep: Finding Tokens in a String. |
| (line 156) |
| * strsignal: Signal Messages. (line 15) |
| * strspn: Search Functions. (line 182) |
| * strstr: Search Functions. (line 134) |
| * strtod: Parsing of Floats. (line 14) |
| * strtof: Parsing of Floats. (line 81) |
| * strtoimax: Parsing of Integers. (line 155) |
| * strtok: Finding Tokens in a String. |
| (line 13) |
| * strtok_r: Finding Tokens in a String. |
| (line 144) |
| * strtol: Parsing of Integers. (line 14) |
| * strtold: Parsing of Floats. (line 82) |
| * strtoll: Parsing of Integers. (line 98) |
| * strtoq: Parsing of Integers. (line 119) |
| * strtoul: Parsing of Integers. (line 76) |
| * strtoull: Parsing of Integers. (line 130) |
| * strtoumax: Parsing of Integers. (line 176) |
| * strtouq: Parsing of Integers. (line 144) |
| * strverscmp: String/Array Comparison. |
| (line 178) |
| * strxfrm: Collation Functions. (line 76) |
| * stty: BSD Terminal Modes. (line 41) |
| * success: Actions in the NSS configuration. |
| (line 21) |
| * SUN_LEN: Local Namespace Details. |
| (line 47) |
| * swapcontext: System V contexts. (line 143) |
| * swprintf: Formatted Output Functions. |
| (line 56) |
| * swscanf: Formatted Input Functions. |
| (line 50) |
| * symlink: Symbolic Links. (line 46) |
| * sync: Synchronizing I/O. (line 16) |
| * syscall: System Calls. (line 40) |
| * sysconf: Sysconf Definition. (line 7) |
| * sysctl: System Parameters. (line 13) |
| * syslog: syslog; vsyslog. (line 10) |
| * system: Running a Command. (line 12) |
| * sysv_signal: Basic Signal Handling. |
| (line 129) |
| * tan: Trig Functions. (line 31) |
| * tanf: Trig Functions. (line 32) |
| * tanh: Hyperbolic Functions. |
| (line 24) |
| * tanhf: Hyperbolic Functions. |
| (line 25) |
| * tanhl: Hyperbolic Functions. |
| (line 26) |
| * tanl: Trig Functions. (line 33) |
| * tcdrain: Line Control. (line 35) |
| * tcflow: Line Control. (line 94) |
| * tcflush: Line Control. (line 60) |
| * tcgetattr: Mode Functions. (line 7) |
| * tcgetpgrp: Terminal Access Functions. |
| (line 15) |
| * tcgetsid: Terminal Access Functions. |
| (line 75) |
| * tcsendbreak: Line Control. (line 15) |
| * tcsetattr: Mode Functions. (line 23) |
| * tcsetpgrp: Terminal Access Functions. |
| (line 40) |
| * tdelete: Tree Search Function. |
| (line 67) |
| * tdestroy: Tree Search Function. |
| (line 77) |
| * TEMP_FAILURE_RETRY: Interrupted Primitives. |
| (line 21) |
| * tempnam: Temporary Files. (line 94) |
| * textdomain: Locating gettext catalog. |
| (line 71) |
| * tfind: Tree Search Function. |
| (line 55) |
| * tgamma: Special Functions. (line 59) |
| * tgammaf: Special Functions. (line 60) |
| * tgammal: Special Functions. (line 61) |
| * time: Simple Calendar Time. |
| (line 33) |
| * timegm: Broken-down Time. (line 170) |
| * timelocal: Broken-down Time. (line 161) |
| * times: Processor Time. (line 43) |
| * tmpfile: Temporary Files. (line 20) |
| * tmpfile64: Temporary Files. (line 33) |
| * tmpnam: Temporary Files. (line 45) |
| * tmpnam_r: Temporary Files. (line 67) |
| * toascii: Case Conversion. (line 33) |
| * tolower: Case Conversion. (line 24) |
| * toupper: Case Conversion. (line 29) |
| * towctrans: Wide Character Case Conversion. |
| (line 34) |
| * towlower: Wide Character Case Conversion. |
| (line 45) |
| * towupper: Wide Character Case Conversion. |
| (line 56) |
| * trunc: Rounding Functions. (line 32) |
| * truncate: File Size. (line 26) |
| * truncate64: File Size. (line 66) |
| * truncf: Rounding Functions. (line 33) |
| * truncl: Rounding Functions. (line 34) |
| * tryagain: Actions in the NSS configuration. |
| (line 35) |
| * tsearch: Tree Search Function. |
| (line 28) |
| * ttyname: Is It a Terminal. (line 22) |
| * ttyname_r: Is It a Terminal. (line 30) |
| * twalk: Tree Search Function. |
| (line 127) |
| * tzset: Time Zone Functions. (line 33) |
| * ulimit: Limits on Resources. (line 178) |
| * umask: Setting Permissions. (line 44) |
| * umount: Mount-Unmount-Remount. |
| (line 252) |
| * umount2: Mount-Unmount-Remount. |
| (line 197) |
| * uname: Platform Type. (line 70) |
| * unavail: Actions in the NSS configuration. |
| (line 29) |
| * ungetc: How Unread. (line 10) |
| * ungetwc: How Unread. (line 45) |
| * unlink: Deleting Files. (line 14) |
| * unlockpt: Allocation. (line 56) |
| * unsetenv: Environment Access. (line 58) |
| * updwtmp: Manipulating the Database. |
| (line 276) |
| * utime: File Times. (line 51) |
| * utimes: File Times. (line 97) |
| * utmpname: Manipulating the Database. |
| (line 252) |
| * utmpxname: XPG Functions. (line 104) |
| * va_alist: Old Varargs. (line 31) |
| * va_arg: Argument Macros. (line 21) |
| * va_dcl: Old Varargs. (line 35) |
| * va_end: Argument Macros. (line 32) |
| * va_start <1>: Old Varargs. (line 39) |
| * va_start: Argument Macros. (line 13) |
| * valloc: Aligned Memory Blocks. |
| (line 40) |
| * vasprintf: Variable Arguments Output. |
| (line 93) |
| * verr: Error Messages. (line 297) |
| * verrx: Error Messages. (line 309) |
| * versionsort: Scanning Directory Content. |
| (line 49) |
| * versionsort64: Scanning Directory Content. |
| (line 84) |
| * vfork: Creating a Process. (line 59) |
| * vfprintf: Variable Arguments Output. |
| (line 69) |
| * vfscanf: Variable Arguments Input. |
| (line 28) |
| * vfwprintf: Variable Arguments Output. |
| (line 74) |
| * vfwscanf: Variable Arguments Input. |
| (line 33) |
| * vlimit: Limits on Resources. (line 215) |
| * vprintf: Variable Arguments Output. |
| (line 58) |
| * vscanf: Variable Arguments Input. |
| (line 17) |
| * vsnprintf: Variable Arguments Output. |
| (line 88) |
| * vsprintf: Variable Arguments Output. |
| (line 78) |
| * vsscanf: Variable Arguments Input. |
| (line 38) |
| * vswprintf: Variable Arguments Output. |
| (line 83) |
| * vswscanf: Variable Arguments Input. |
| (line 43) |
| * vsyslog: syslog; vsyslog. (line 147) |
| * vtimes: Resource Usage. (line 108) |
| * vwarn: Error Messages. (line 274) |
| * vwarnx: Error Messages. (line 286) |
| * vwprintf: Variable Arguments Output. |
| (line 63) |
| * vwscanf: Variable Arguments Input. |
| (line 22) |
| * wait: Process Completion. (line 101) |
| * wait3: BSD Wait Functions. (line 44) |
| * wait4: Process Completion. (line 119) |
| * waitpid: Process Completion. (line 11) |
| * warn: Error Messages. (line 268) |
| * warnx: Error Messages. (line 279) |
| * WCOREDUMP: Process Completion Status. |
| (line 31) |
| * wcpcpy: Copying and Concatenation. |
| (line 291) |
| * wcpncpy: Copying and Concatenation. |
| (line 327) |
| * wcrtomb: Converting a Character. |
| (line 245) |
| * wcscasecmp: String/Array Comparison. |
| (line 121) |
| * wcscat: Copying and Concatenation. |
| (line 420) |
| * wcschr: Search Functions. (line 74) |
| * wcschrnul: Search Functions. (line 93) |
| * wcscmp: String/Array Comparison. |
| (line 96) |
| * wcscoll: Collation Functions. (line 44) |
| * wcscpy: Copying and Concatenation. |
| (line 176) |
| * wcscspn: Search Functions. (line 224) |
| * wcsdup: Copying and Concatenation. |
| (line 237) |
| * wcsftime: Formatting Calendar Time. |
| (line 395) |
| * wcslen: String Length. (line 67) |
| * wcsncasecmp: String/Array Comparison. |
| (line 151) |
| * wcsncat: Copying and Concatenation. |
| (line 580) |
| * wcsncmp: String/Array Comparison. |
| (line 137) |
| * wcsncpy: Copying and Concatenation. |
| (line 207) |
| * wcsnlen: String Length. (line 94) |
| * wcsnrtombs: Converting Strings. (line 184) |
| * wcspbrk: Search Functions. (line 251) |
| * wcsrchr: Search Functions. (line 129) |
| * wcsrtombs: Converting Strings. (line 91) |
| * wcsspn: Search Functions. (line 199) |
| * wcsstr: Search Functions. (line 148) |
| * wcstod: Parsing of Floats. (line 93) |
| * wcstof: Parsing of Floats. (line 94) |
| * wcstoimax: Parsing of Integers. (line 169) |
| * wcstok: Finding Tokens in a String. |
| (line 53) |
| * wcstol: Parsing of Integers. (line 69) |
| * wcstold: Parsing of Floats. (line 96) |
| * wcstoll: Parsing of Integers. (line 112) |
| * wcstombs: Non-reentrant String Conversion. |
| (line 49) |
| * wcstoq: Parsing of Integers. (line 123) |
| * wcstoul: Parsing of Integers. (line 91) |
| * wcstoull: Parsing of Integers. (line 137) |
| * wcstoumax: Parsing of Integers. (line 184) |
| * wcstouq: Parsing of Integers. (line 148) |
| * wcswcs: Search Functions. (line 157) |
| * wcsxfrm: Collation Functions. (line 104) |
| * wctob: Converting a Character. |
| (line 65) |
| * wctomb: Non-reentrant Character Conversion. |
| (line 38) |
| * wctrans: Wide Character Case Conversion. |
| (line 20) |
| * wctype: Classification of Wide Characters. |
| (line 37) |
| * WEXITSTATUS: Process Completion Status. |
| (line 17) |
| * WIFEXITED: Process Completion Status. |
| (line 13) |
| * WIFSIGNALED: Process Completion Status. |
| (line 22) |
| * WIFSTOPPED: Process Completion Status. |
| (line 35) |
| * wmemchr: Search Functions. (line 18) |
| * wmemcmp: String/Array Comparison. |
| (line 35) |
| * wmemcpy: Copying and Concatenation. |
| (line 51) |
| * wmemmove: Copying and Concatenation. |
| (line 128) |
| * wmempcpy: Copying and Concatenation. |
| (line 95) |
| * wmemset: Copying and Concatenation. |
| (line 163) |
| * wordexp: Calling Wordexp. (line 41) |
| * wordfree: Calling Wordexp. (line 89) |
| * wprintf: Formatted Output Functions. |
| (line 20) |
| * write: I/O Primitives. (line 157) |
| * writev: Scatter-Gather. (line 47) |
| * wscanf: Formatted Input Functions. |
| (line 21) |
| * WSTOPSIG: Process Completion Status. |
| (line 38) |
| * WTERMSIG: Process Completion Status. |
| (line 27) |
| * y0: Special Functions. (line 86) |
| * y0f: Special Functions. (line 87) |
| * y0l: Special Functions. (line 88) |
| * y1: Special Functions. (line 94) |
| * y1f: Special Functions. (line 95) |
| * y1l: Special Functions. (line 96) |
| * yn: Special Functions. (line 102) |
| * ynf: Special Functions. (line 103) |
| * ynl: Special Functions. (line 104) |
| |