| This is |
| /tmp/dgboter/bbs/rhev-vm2--rhe6x86_64/buildbot/rhe6x86_64--aarch64-none-linux-gnu/build/build-aarch64-none-linux-gnu/obj/glibc/manual/libc.info, |
| produced by makeinfo version 4.13 from libc.texinfo. |
| |
| INFO-DIR-SECTION Software libraries |
| START-INFO-DIR-ENTRY |
| * Libc: (libc). C library. |
| END-INFO-DIR-ENTRY |
| |
| INFO-DIR-SECTION GNU C library functions and macros |
| START-INFO-DIR-ENTRY |
| * ALTWERASE: (libc)Local Modes. |
| * ARGP_ERR_UNKNOWN: (libc)Argp Parser Functions. |
| * ARG_MAX: (libc)General Limits. |
| * BC_BASE_MAX: (libc)Utility Limits. |
| * BC_DIM_MAX: (libc)Utility Limits. |
| * BC_SCALE_MAX: (libc)Utility Limits. |
| * BC_STRING_MAX: (libc)Utility Limits. |
| * BRKINT: (libc)Input Modes. |
| * BUFSIZ: (libc)Controlling Buffering. |
| * CCTS_OFLOW: (libc)Control Modes. |
| * CHAR_BIT: (libc)Width of Type. |
| * CHILD_MAX: (libc)General Limits. |
| * CIGNORE: (libc)Control Modes. |
| * CLK_TCK: (libc)Processor Time. |
| * CLOCAL: (libc)Control Modes. |
| * CLOCKS_PER_SEC: (libc)CPU Time. |
| * 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. |
| * DTTOIF: (libc)Directory Entries. |
| * E2BIG: (libc)Error Codes. |
| * EACCES: (libc)Error Codes. |
| * EADDRINUSE: (libc)Error Codes. |
| * EADDRNOTAVAIL: (libc)Error Codes. |
| * EADV: (libc)Error Codes. |
| * EAFNOSUPPORT: (libc)Error Codes. |
| * EAGAIN: (libc)Error Codes. |
| * EALREADY: (libc)Error Codes. |
| * EAUTH: (libc)Error Codes. |
| * EBACKGROUND: (libc)Error Codes. |
| * EBADE: (libc)Error Codes. |
| * EBADF: (libc)Error Codes. |
| * EBADFD: (libc)Error Codes. |
| * EBADMSG: (libc)Error Codes. |
| * EBADR: (libc)Error Codes. |
| * EBADRPC: (libc)Error Codes. |
| * EBADRQC: (libc)Error Codes. |
| * EBADSLT: (libc)Error Codes. |
| * EBFONT: (libc)Error Codes. |
| * EBUSY: (libc)Error Codes. |
| * ECANCELED: (libc)Error Codes. |
| * ECHILD: (libc)Error Codes. |
| * ECHO: (libc)Local Modes. |
| * ECHOCTL: (libc)Local Modes. |
| * ECHOE: (libc)Local Modes. |
| * ECHOK: (libc)Local Modes. |
| * ECHOKE: (libc)Local Modes. |
| * ECHONL: (libc)Local Modes. |
| * ECHOPRT: (libc)Local Modes. |
| * ECHRNG: (libc)Error Codes. |
| * ECOMM: (libc)Error Codes. |
| * ECONNABORTED: (libc)Error Codes. |
| * ECONNREFUSED: (libc)Error Codes. |
| * ECONNRESET: (libc)Error Codes. |
| * ED: (libc)Error Codes. |
| * EDEADLK: (libc)Error Codes. |
| * EDEADLOCK: (libc)Error Codes. |
| * EDESTADDRREQ: (libc)Error Codes. |
| * EDIED: (libc)Error Codes. |
| * EDOM: (libc)Error Codes. |
| * EDOTDOT: (libc)Error Codes. |
| * EDQUOT: (libc)Error Codes. |
| * EEXIST: (libc)Error Codes. |
| * EFAULT: (libc)Error Codes. |
| * EFBIG: (libc)Error Codes. |
| * EFTYPE: (libc)Error Codes. |
| * EGRATUITOUS: (libc)Error Codes. |
| * EGREGIOUS: (libc)Error Codes. |
| * EHOSTDOWN: (libc)Error Codes. |
| * EHOSTUNREACH: (libc)Error Codes. |
| * EHWPOISON: (libc)Error Codes. |
| * EIDRM: (libc)Error Codes. |
| * EIEIO: (libc)Error Codes. |
| * EILSEQ: (libc)Error Codes. |
| * EINPROGRESS: (libc)Error Codes. |
| * EINTR: (libc)Error Codes. |
| * EINVAL: (libc)Error Codes. |
| * EIO: (libc)Error Codes. |
| * EISCONN: (libc)Error Codes. |
| * EISDIR: (libc)Error Codes. |
| * EISNAM: (libc)Error Codes. |
| * EKEYEXPIRED: (libc)Error Codes. |
| * EKEYREJECTED: (libc)Error Codes. |
| * EKEYREVOKED: (libc)Error Codes. |
| * EL2HLT: (libc)Error Codes. |
| * EL2NSYNC: (libc)Error Codes. |
| * EL3HLT: (libc)Error Codes. |
| * EL3RST: (libc)Error Codes. |
| * ELIBACC: (libc)Error Codes. |
| * ELIBBAD: (libc)Error Codes. |
| * ELIBEXEC: (libc)Error Codes. |
| * ELIBMAX: (libc)Error Codes. |
| * ELIBSCN: (libc)Error Codes. |
| * ELNRNG: (libc)Error Codes. |
| * ELOOP: (libc)Error Codes. |
| * EMEDIUMTYPE: (libc)Error Codes. |
| * EMFILE: (libc)Error Codes. |
| * EMLINK: (libc)Error Codes. |
| * EMSGSIZE: (libc)Error Codes. |
| * EMULTIHOP: (libc)Error Codes. |
| * ENAMETOOLONG: (libc)Error Codes. |
| * ENAVAIL: (libc)Error Codes. |
| * ENEEDAUTH: (libc)Error Codes. |
| * ENETDOWN: (libc)Error Codes. |
| * ENETRESET: (libc)Error Codes. |
| * ENETUNREACH: (libc)Error Codes. |
| * ENFILE: (libc)Error Codes. |
| * ENOANO: (libc)Error Codes. |
| * ENOBUFS: (libc)Error Codes. |
| * ENOCSI: (libc)Error Codes. |
| * ENODATA: (libc)Error Codes. |
| * ENODEV: (libc)Error Codes. |
| * ENOENT: (libc)Error Codes. |
| * ENOEXEC: (libc)Error Codes. |
| * ENOKEY: (libc)Error Codes. |
| * ENOLCK: (libc)Error Codes. |
| * ENOLINK: (libc)Error Codes. |
| * ENOMEDIUM: (libc)Error Codes. |
| * ENOMEM: (libc)Error Codes. |
| * ENOMSG: (libc)Error Codes. |
| * ENONET: (libc)Error Codes. |
| * ENOPKG: (libc)Error Codes. |
| * ENOPROTOOPT: (libc)Error Codes. |
| * ENOSPC: (libc)Error Codes. |
| * ENOSR: (libc)Error Codes. |
| * ENOSTR: (libc)Error Codes. |
| * ENOSYS: (libc)Error Codes. |
| * ENOTBLK: (libc)Error Codes. |
| * ENOTCONN: (libc)Error Codes. |
| * ENOTDIR: (libc)Error Codes. |
| * ENOTEMPTY: (libc)Error Codes. |
| * ENOTNAM: (libc)Error Codes. |
| * ENOTRECOVERABLE: (libc)Error Codes. |
| * ENOTSOCK: (libc)Error Codes. |
| * ENOTSUP: (libc)Error Codes. |
| * ENOTTY: (libc)Error Codes. |
| * ENOTUNIQ: (libc)Error Codes. |
| * ENXIO: (libc)Error Codes. |
| * EOF: (libc)EOF and Errors. |
| * EOPNOTSUPP: (libc)Error Codes. |
| * EOVERFLOW: (libc)Error Codes. |
| * EOWNERDEAD: (libc)Error Codes. |
| * EPERM: (libc)Error Codes. |
| * EPFNOSUPPORT: (libc)Error Codes. |
| * EPIPE: (libc)Error Codes. |
| * EPROCLIM: (libc)Error Codes. |
| * EPROCUNAVAIL: (libc)Error Codes. |
| * EPROGMISMATCH: (libc)Error Codes. |
| * EPROGUNAVAIL: (libc)Error Codes. |
| * EPROTO: (libc)Error Codes. |
| * EPROTONOSUPPORT: (libc)Error Codes. |
| * EPROTOTYPE: (libc)Error Codes. |
| * EQUIV_CLASS_MAX: (libc)Utility Limits. |
| * ERANGE: (libc)Error Codes. |
| * EREMCHG: (libc)Error Codes. |
| * EREMOTE: (libc)Error Codes. |
| * EREMOTEIO: (libc)Error Codes. |
| * ERESTART: (libc)Error Codes. |
| * ERFKILL: (libc)Error Codes. |
| * EROFS: (libc)Error Codes. |
| * ERPCMISMATCH: (libc)Error Codes. |
| * ESHUTDOWN: (libc)Error Codes. |
| * ESOCKTNOSUPPORT: (libc)Error Codes. |
| * ESPIPE: (libc)Error Codes. |
| * ESRCH: (libc)Error Codes. |
| * ESRMNT: (libc)Error Codes. |
| * ESTALE: (libc)Error Codes. |
| * ESTRPIPE: (libc)Error Codes. |
| * ETIME: (libc)Error Codes. |
| * ETIMEDOUT: (libc)Error Codes. |
| * ETOOMANYREFS: (libc)Error Codes. |
| * ETXTBSY: (libc)Error Codes. |
| * EUCLEAN: (libc)Error Codes. |
| * EUNATCH: (libc)Error Codes. |
| * EUSERS: (libc)Error Codes. |
| * EWOULDBLOCK: (libc)Error Codes. |
| * EXDEV: (libc)Error Codes. |
| * EXFULL: (libc)Error Codes. |
| * EXIT_FAILURE: (libc)Exit Status. |
| * EXIT_SUCCESS: (libc)Exit Status. |
| * EXPR_NEST_MAX: (libc)Utility Limits. |
| * FD_CLOEXEC: (libc)Descriptor Flags. |
| * FD_CLR: (libc)Waiting for I/O. |
| * FD_ISSET: (libc)Waiting for I/O. |
| * FD_SET: (libc)Waiting for I/O. |
| * FD_SETSIZE: (libc)Waiting for I/O. |
| * FD_ZERO: (libc)Waiting for I/O. |
| * FE_SNANS_ALWAYS_SIGNAL: (libc)Infinity and NaN. |
| * FILENAME_MAX: (libc)Limits for Files. |
| * FLUSHO: (libc)Local Modes. |
| * FOPEN_MAX: (libc)Opening Streams. |
| * FP_ILOGB0: (libc)Exponents and Logarithms. |
| * FP_ILOGBNAN: (libc)Exponents and Logarithms. |
| * FP_LLOGB0: (libc)Exponents and Logarithms. |
| * FP_LLOGBNAN: (libc)Exponents and Logarithms. |
| * F_DUPFD: (libc)Duplicating Descriptors. |
| * F_GETFD: (libc)Descriptor Flags. |
| * F_GETFL: (libc)Getting File Status Flags. |
| * F_GETLK: (libc)File Locks. |
| * F_GETOWN: (libc)Interrupt Input. |
| * F_OFD_GETLK: (libc)Open File Description Locks. |
| * F_OFD_SETLK: (libc)Open File Description Locks. |
| * F_OFD_SETLKW: (libc)Open File Description Locks. |
| * F_OK: (libc)Testing File Access. |
| * F_SETFD: (libc)Descriptor Flags. |
| * F_SETFL: (libc)Getting File Status Flags. |
| * F_SETLK: (libc)File Locks. |
| * F_SETLKW: (libc)File Locks. |
| * F_SETOWN: (libc)Interrupt Input. |
| * HUGE_VAL: (libc)Math Error Reporting. |
| * HUGE_VALF: (libc)Math Error Reporting. |
| * HUGE_VALL: (libc)Math Error Reporting. |
| * HUGE_VAL_FN: (libc)Math Error Reporting. |
| * HUGE_VAL_FNx: (libc)Math Error Reporting. |
| * HUPCL: (libc)Control Modes. |
| * I: (libc)Complex Numbers. |
| * ICANON: (libc)Local Modes. |
| * ICRNL: (libc)Input Modes. |
| * IEXTEN: (libc)Local Modes. |
| * IFNAMSIZ: (libc)Interface Naming. |
| * IFTODT: (libc)Directory Entries. |
| * IGNBRK: (libc)Input Modes. |
| * IGNCR: (libc)Input Modes. |
| * IGNPAR: (libc)Input Modes. |
| * IMAXBEL: (libc)Input Modes. |
| * INADDR_ANY: (libc)Host Address Data Type. |
| * INADDR_BROADCAST: (libc)Host Address Data Type. |
| * INADDR_LOOPBACK: (libc)Host Address Data Type. |
| * INADDR_NONE: (libc)Host Address Data Type. |
| * INFINITY: (libc)Infinity and NaN. |
| * INLCR: (libc)Input Modes. |
| * INPCK: (libc)Input Modes. |
| * IPPORT_RESERVED: (libc)Ports. |
| * IPPORT_USERRESERVED: (libc)Ports. |
| * ISIG: (libc)Local Modes. |
| * ISTRIP: (libc)Input Modes. |
| * IXANY: (libc)Input Modes. |
| * IXOFF: (libc)Input Modes. |
| * IXON: (libc)Input Modes. |
| * LINE_MAX: (libc)Utility Limits. |
| * LINK_MAX: (libc)Limits for Files. |
| * L_ctermid: (libc)Identifying the Terminal. |
| * L_cuserid: (libc)Who Logged In. |
| * L_tmpnam: (libc)Temporary Files. |
| * MAXNAMLEN: (libc)Limits for Files. |
| * MAXSYMLINKS: (libc)Symbolic Links. |
| * MAX_CANON: (libc)Limits for Files. |
| * MAX_INPUT: (libc)Limits for Files. |
| * MB_CUR_MAX: (libc)Selecting the Conversion. |
| * MB_LEN_MAX: (libc)Selecting the Conversion. |
| * MDMBUF: (libc)Control Modes. |
| * MSG_DONTROUTE: (libc)Socket Data Options. |
| * MSG_OOB: (libc)Socket Data Options. |
| * MSG_PEEK: (libc)Socket Data Options. |
| * NAME_MAX: (libc)Limits for Files. |
| * NAN: (libc)Infinity and NaN. |
| * NCCS: (libc)Mode Data Types. |
| * NGROUPS_MAX: (libc)General Limits. |
| * NOFLSH: (libc)Local Modes. |
| * NOKERNINFO: (libc)Local Modes. |
| * NSIG: (libc)Standard Signals. |
| * NULL: (libc)Null Pointer Constant. |
| * ONLCR: (libc)Output Modes. |
| * ONOEOT: (libc)Output Modes. |
| * OPEN_MAX: (libc)General Limits. |
| * OPOST: (libc)Output Modes. |
| * OXTABS: (libc)Output Modes. |
| * O_ACCMODE: (libc)Access Modes. |
| * O_APPEND: (libc)Operating Modes. |
| * O_ASYNC: (libc)Operating Modes. |
| * O_CREAT: (libc)Open-time Flags. |
| * O_DIRECTORY: (libc)Open-time Flags. |
| * O_EXCL: (libc)Open-time Flags. |
| * O_EXEC: (libc)Access Modes. |
| * O_EXLOCK: (libc)Open-time Flags. |
| * O_FSYNC: (libc)Operating Modes. |
| * O_IGNORE_CTTY: (libc)Open-time Flags. |
| * O_NDELAY: (libc)Operating Modes. |
| * O_NOATIME: (libc)Operating Modes. |
| * O_NOCTTY: (libc)Open-time Flags. |
| * O_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_TMPFILE: (libc)Open-time Flags. |
| * O_TRUNC: (libc)Open-time Flags. |
| * O_WRITE: (libc)Access Modes. |
| * O_WRONLY: (libc)Access Modes. |
| * PARENB: (libc)Control Modes. |
| * PARMRK: (libc)Input Modes. |
| * PARODD: (libc)Control Modes. |
| * PATH_MAX: (libc)Limits for Files. |
| * PA_FLAG_MASK: (libc)Parsing a Template String. |
| * PENDIN: (libc)Local Modes. |
| * PF_FILE: (libc)Local Namespace Details. |
| * PF_INET6: (libc)Internet Namespace. |
| * PF_INET: (libc)Internet Namespace. |
| * PF_LOCAL: (libc)Local Namespace Details. |
| * PF_UNIX: (libc)Local Namespace Details. |
| * PIPE_BUF: (libc)Limits for Files. |
| * 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. |
| * SNAN: (libc)Infinity and NaN. |
| * SNANF: (libc)Infinity and NaN. |
| * SNANFN: (libc)Infinity and NaN. |
| * SNANFNx: (libc)Infinity and NaN. |
| * SNANL: (libc)Infinity and NaN. |
| * SOCK_DGRAM: (libc)Communication Styles. |
| * SOCK_RAW: (libc)Communication Styles. |
| * SOCK_RDM: (libc)Communication Styles. |
| * SOCK_SEQPACKET: (libc)Communication Styles. |
| * SOCK_STREAM: (libc)Communication Styles. |
| * SOL_SOCKET: (libc)Socket-Level Options. |
| * SSIZE_MAX: (libc)General Limits. |
| * STREAM_MAX: (libc)General Limits. |
| * SUN_LEN: (libc)Local Namespace Details. |
| * S_IFMT: (libc)Testing File Type. |
| * S_ISBLK: (libc)Testing File Type. |
| * S_ISCHR: (libc)Testing File Type. |
| * S_ISDIR: (libc)Testing File Type. |
| * S_ISFIFO: (libc)Testing File Type. |
| * S_ISLNK: (libc)Testing File Type. |
| * S_ISREG: (libc)Testing File Type. |
| * S_ISSOCK: (libc)Testing File Type. |
| * S_TYPEISMQ: (libc)Testing File Type. |
| * S_TYPEISSEM: (libc)Testing File Type. |
| * S_TYPEISSHM: (libc)Testing File Type. |
| * TMP_MAX: (libc)Temporary Files. |
| * TOSTOP: (libc)Local Modes. |
| * TZNAME_MAX: (libc)General Limits. |
| * VDISCARD: (libc)Other Special. |
| * VDSUSP: (libc)Signal Characters. |
| * VEOF: (libc)Editing Characters. |
| * VEOL2: (libc)Editing Characters. |
| * VEOL: (libc)Editing Characters. |
| * VERASE: (libc)Editing Characters. |
| * VINTR: (libc)Signal Characters. |
| * VKILL: (libc)Editing Characters. |
| * VLNEXT: (libc)Other Special. |
| * VMIN: (libc)Noncanonical Input. |
| * VQUIT: (libc)Signal Characters. |
| * VREPRINT: (libc)Editing Characters. |
| * VSTART: (libc)Start/Stop Characters. |
| * VSTATUS: (libc)Other Special. |
| * VSTOP: (libc)Start/Stop Characters. |
| * VSUSP: (libc)Signal Characters. |
| * VTIME: (libc)Noncanonical Input. |
| * VWERASE: (libc)Editing Characters. |
| * WCHAR_MAX: (libc)Extended Char Intro. |
| * WCHAR_MIN: (libc)Extended Char Intro. |
| * WCOREDUMP: (libc)Process Completion Status. |
| * WEOF: (libc)EOF and Errors. |
| * WEOF: (libc)Extended Char Intro. |
| * WEXITSTATUS: (libc)Process Completion Status. |
| * WIFEXITED: (libc)Process Completion Status. |
| * WIFSIGNALED: (libc)Process Completion Status. |
| * WIFSTOPPED: (libc)Process Completion Status. |
| * WSTOPSIG: (libc)Process Completion Status. |
| * WTERMSIG: (libc)Process Completion Status. |
| * W_OK: (libc)Testing File Access. |
| * X_OK: (libc)Testing File Access. |
| * _Complex_I: (libc)Complex Numbers. |
| * _Exit: (libc)Termination Internals. |
| * _IOFBF: (libc)Controlling Buffering. |
| * _IOLBF: (libc)Controlling Buffering. |
| * _IONBF: (libc)Controlling Buffering. |
| * _Imaginary_I: (libc)Complex Numbers. |
| * _PATH_UTMP: (libc)Manipulating the Database. |
| * _PATH_WTMP: (libc)Manipulating the Database. |
| * _POSIX2_C_DEV: (libc)System Options. |
| * _POSIX2_C_VERSION: (libc)Version Supported. |
| * _POSIX2_FORT_DEV: (libc)System Options. |
| * _POSIX2_FORT_RUN: (libc)System Options. |
| * _POSIX2_LOCALEDEF: (libc)System Options. |
| * _POSIX2_SW_DEV: (libc)System Options. |
| * _POSIX_CHOWN_RESTRICTED: (libc)Options for Files. |
| * _POSIX_JOB_CONTROL: (libc)System Options. |
| * _POSIX_NO_TRUNC: (libc)Options for Files. |
| * _POSIX_SAVED_IDS: (libc)System Options. |
| * _POSIX_VDISABLE: (libc)Options for Files. |
| * _POSIX_VERSION: (libc)Version Supported. |
| * __fbufsize: (libc)Controlling Buffering. |
| * __flbf: (libc)Controlling Buffering. |
| * __fpending: (libc)Controlling Buffering. |
| * __fpurge: (libc)Flushing Buffers. |
| * __freadable: (libc)Opening Streams. |
| * __freading: (libc)Opening Streams. |
| * __fsetlocking: (libc)Streams and Threads. |
| * __fwritable: (libc)Opening Streams. |
| * __fwriting: (libc)Opening Streams. |
| * __gconv_end_fct: (libc)glibc iconv Implementation. |
| * __gconv_fct: (libc)glibc iconv Implementation. |
| * __gconv_init_fct: (libc)glibc iconv Implementation. |
| * __ppc_get_timebase: (libc)PowerPC. |
| * __ppc_get_timebase_freq: (libc)PowerPC. |
| * __ppc_mdoio: (libc)PowerPC. |
| * __ppc_mdoom: (libc)PowerPC. |
| * __ppc_set_ppr_low: (libc)PowerPC. |
| * __ppc_set_ppr_med: (libc)PowerPC. |
| * __ppc_set_ppr_med_high: (libc)PowerPC. |
| * __ppc_set_ppr_med_low: (libc)PowerPC. |
| * __ppc_set_ppr_very_low: (libc)PowerPC. |
| * __ppc_yield: (libc)PowerPC. |
| * __riscv_flush_icache: (libc)RISC-V. |
| * __va_copy: (libc)Argument Macros. |
| * _exit: (libc)Termination Internals. |
| * _flushlbf: (libc)Flushing Buffers. |
| * _tolower: (libc)Case Conversion. |
| * _toupper: (libc)Case Conversion. |
| * a64l: (libc)Encode Binary Data. |
| * abort: (libc)Aborting a Program. |
| * abs: (libc)Absolute Value. |
| * accept: (libc)Accepting Connections. |
| * access: (libc)Testing File Access. |
| * acos: (libc)Inverse Trig Functions. |
| * acosf: (libc)Inverse Trig Functions. |
| * acosfN: (libc)Inverse Trig Functions. |
| * acosfNx: (libc)Inverse Trig Functions. |
| * acosh: (libc)Hyperbolic Functions. |
| * acoshf: (libc)Hyperbolic Functions. |
| * acoshfN: (libc)Hyperbolic Functions. |
| * acoshfNx: (libc)Hyperbolic Functions. |
| * acoshl: (libc)Hyperbolic Functions. |
| * acosl: (libc)Inverse Trig Functions. |
| * addmntent: (libc)mtab. |
| * addseverity: (libc)Adding Severity Classes. |
| * adjtime: (libc)High-Resolution Calendar. |
| * adjtimex: (libc)High-Resolution Calendar. |
| * aio_cancel64: (libc)Cancel AIO Operations. |
| * aio_cancel: (libc)Cancel AIO Operations. |
| * aio_error64: (libc)Status of AIO Operations. |
| * aio_error: (libc)Status of AIO Operations. |
| * aio_fsync64: (libc)Synchronizing AIO Operations. |
| * aio_fsync: (libc)Synchronizing AIO Operations. |
| * aio_init: (libc)Configuration of AIO. |
| * aio_read64: (libc)Asynchronous Reads/Writes. |
| * aio_read: (libc)Asynchronous Reads/Writes. |
| * aio_return64: (libc)Status of AIO Operations. |
| * aio_return: (libc)Status of AIO Operations. |
| * aio_suspend64: (libc)Synchronizing AIO Operations. |
| * aio_suspend: (libc)Synchronizing AIO Operations. |
| * aio_write64: (libc)Asynchronous Reads/Writes. |
| * aio_write: (libc)Asynchronous Reads/Writes. |
| * alarm: (libc)Setting an Alarm. |
| * aligned_alloc: (libc)Aligned Memory Blocks. |
| * alloca: (libc)Variable Size Automatic. |
| * alphasort64: (libc)Scanning Directory Content. |
| * alphasort: (libc)Scanning Directory Content. |
| * argp_error: (libc)Argp Helper Functions. |
| * argp_failure: (libc)Argp Helper Functions. |
| * argp_help: (libc)Argp Help. |
| * argp_parse: (libc)Argp. |
| * argp_state_help: (libc)Argp Helper Functions. |
| * argp_usage: (libc)Argp Helper Functions. |
| * argz_add: (libc)Argz Functions. |
| * argz_add_sep: (libc)Argz Functions. |
| * argz_append: (libc)Argz Functions. |
| * argz_count: (libc)Argz Functions. |
| * argz_create: (libc)Argz Functions. |
| * argz_create_sep: (libc)Argz Functions. |
| * argz_delete: (libc)Argz Functions. |
| * argz_extract: (libc)Argz Functions. |
| * argz_insert: (libc)Argz Functions. |
| * argz_next: (libc)Argz Functions. |
| * argz_replace: (libc)Argz Functions. |
| * argz_stringify: (libc)Argz Functions. |
| * asctime: (libc)Formatting Calendar Time. |
| * asctime_r: (libc)Formatting Calendar Time. |
| * asin: (libc)Inverse Trig Functions. |
| * asinf: (libc)Inverse Trig Functions. |
| * asinfN: (libc)Inverse Trig Functions. |
| * asinfNx: (libc)Inverse Trig Functions. |
| * asinh: (libc)Hyperbolic Functions. |
| * asinhf: (libc)Hyperbolic Functions. |
| * asinhfN: (libc)Hyperbolic Functions. |
| * asinhfNx: (libc)Hyperbolic Functions. |
| * asinhl: (libc)Hyperbolic Functions. |
| * asinl: (libc)Inverse Trig Functions. |
| * asprintf: (libc)Dynamic Output. |
| * assert: (libc)Consistency Checking. |
| * assert_perror: (libc)Consistency Checking. |
| * atan2: (libc)Inverse Trig Functions. |
| * atan2f: (libc)Inverse Trig Functions. |
| * atan2fN: (libc)Inverse Trig Functions. |
| * atan2fNx: (libc)Inverse Trig Functions. |
| * atan2l: (libc)Inverse Trig Functions. |
| * atan: (libc)Inverse Trig Functions. |
| * atanf: (libc)Inverse Trig Functions. |
| * atanfN: (libc)Inverse Trig Functions. |
| * atanfNx: (libc)Inverse Trig Functions. |
| * atanh: (libc)Hyperbolic Functions. |
| * atanhf: (libc)Hyperbolic Functions. |
| * atanhfN: (libc)Hyperbolic Functions. |
| * atanhfNx: (libc)Hyperbolic Functions. |
| * atanhl: (libc)Hyperbolic Functions. |
| * atanl: (libc)Inverse Trig Functions. |
| * atexit: (libc)Cleanups on Exit. |
| * atof: (libc)Parsing of Floats. |
| * atoi: (libc)Parsing of Integers. |
| * atol: (libc)Parsing of Integers. |
| * atoll: (libc)Parsing of Integers. |
| * backtrace: (libc)Backtraces. |
| * backtrace_symbols: (libc)Backtraces. |
| * backtrace_symbols_fd: (libc)Backtraces. |
| * basename: (libc)Finding Tokens in a String. |
| * basename: (libc)Finding Tokens in a String. |
| * bcmp: (libc)String/Array Comparison. |
| * bcopy: (libc)Copying Strings and Arrays. |
| * bind: (libc)Setting Address. |
| * bind_textdomain_codeset: (libc)Charset conversion in gettext. |
| * bindtextdomain: (libc)Locating gettext catalog. |
| * brk: (libc)Resizing the Data Segment. |
| * bsearch: (libc)Array Search Function. |
| * btowc: (libc)Converting a Character. |
| * bzero: (libc)Copying Strings and Arrays. |
| * cabs: (libc)Absolute Value. |
| * cabsf: (libc)Absolute Value. |
| * cabsfN: (libc)Absolute Value. |
| * cabsfNx: (libc)Absolute Value. |
| * cabsl: (libc)Absolute Value. |
| * cacos: (libc)Inverse Trig Functions. |
| * cacosf: (libc)Inverse Trig Functions. |
| * cacosfN: (libc)Inverse Trig Functions. |
| * cacosfNx: (libc)Inverse Trig Functions. |
| * cacosh: (libc)Hyperbolic Functions. |
| * cacoshf: (libc)Hyperbolic Functions. |
| * cacoshfN: (libc)Hyperbolic Functions. |
| * cacoshfNx: (libc)Hyperbolic Functions. |
| * cacoshl: (libc)Hyperbolic Functions. |
| * cacosl: (libc)Inverse Trig Functions. |
| * call_once: (libc)Call Once. |
| * calloc: (libc)Allocating Cleared Space. |
| * canonicalize: (libc)FP Bit Twiddling. |
| * canonicalize_file_name: (libc)Symbolic Links. |
| * canonicalizef: (libc)FP Bit Twiddling. |
| * canonicalizefN: (libc)FP Bit Twiddling. |
| * canonicalizefNx: (libc)FP Bit Twiddling. |
| * canonicalizel: (libc)FP Bit Twiddling. |
| * carg: (libc)Operations on Complex. |
| * cargf: (libc)Operations on Complex. |
| * cargfN: (libc)Operations on Complex. |
| * cargfNx: (libc)Operations on Complex. |
| * cargl: (libc)Operations on Complex. |
| * casin: (libc)Inverse Trig Functions. |
| * casinf: (libc)Inverse Trig Functions. |
| * casinfN: (libc)Inverse Trig Functions. |
| * casinfNx: (libc)Inverse Trig Functions. |
| * casinh: (libc)Hyperbolic Functions. |
| * casinhf: (libc)Hyperbolic Functions. |
| * casinhfN: (libc)Hyperbolic Functions. |
| * casinhfNx: (libc)Hyperbolic Functions. |
| * casinhl: (libc)Hyperbolic Functions. |
| * casinl: (libc)Inverse Trig Functions. |
| * catan: (libc)Inverse Trig Functions. |
| * catanf: (libc)Inverse Trig Functions. |
| * catanfN: (libc)Inverse Trig Functions. |
| * catanfNx: (libc)Inverse Trig Functions. |
| * catanh: (libc)Hyperbolic Functions. |
| * catanhf: (libc)Hyperbolic Functions. |
| * catanhfN: (libc)Hyperbolic Functions. |
| * catanhfNx: (libc)Hyperbolic Functions. |
| * catanhl: (libc)Hyperbolic Functions. |
| * catanl: (libc)Inverse Trig Functions. |
| * catclose: (libc)The catgets Functions. |
| * catgets: (libc)The catgets Functions. |
| * catopen: (libc)The catgets Functions. |
| * cbrt: (libc)Exponents and Logarithms. |
| * cbrtf: (libc)Exponents and Logarithms. |
| * cbrtfN: (libc)Exponents and Logarithms. |
| * cbrtfNx: (libc)Exponents and Logarithms. |
| * cbrtl: (libc)Exponents and Logarithms. |
| * ccos: (libc)Trig Functions. |
| * ccosf: (libc)Trig Functions. |
| * ccosfN: (libc)Trig Functions. |
| * ccosfNx: (libc)Trig Functions. |
| * ccosh: (libc)Hyperbolic Functions. |
| * ccoshf: (libc)Hyperbolic Functions. |
| * ccoshfN: (libc)Hyperbolic Functions. |
| * ccoshfNx: (libc)Hyperbolic Functions. |
| * ccoshl: (libc)Hyperbolic Functions. |
| * ccosl: (libc)Trig Functions. |
| * ceil: (libc)Rounding Functions. |
| * ceilf: (libc)Rounding Functions. |
| * ceilfN: (libc)Rounding Functions. |
| * ceilfNx: (libc)Rounding Functions. |
| * ceill: (libc)Rounding Functions. |
| * cexp: (libc)Exponents and Logarithms. |
| * cexpf: (libc)Exponents and Logarithms. |
| * cexpfN: (libc)Exponents and Logarithms. |
| * cexpfNx: (libc)Exponents and Logarithms. |
| * cexpl: (libc)Exponents and Logarithms. |
| * cfgetispeed: (libc)Line Speed. |
| * cfgetospeed: (libc)Line Speed. |
| * cfmakeraw: (libc)Noncanonical Input. |
| * 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. |
| * cimagfN: (libc)Operations on Complex. |
| * cimagfNx: (libc)Operations on Complex. |
| * cimagl: (libc)Operations on Complex. |
| * clearenv: (libc)Environment Access. |
| * clearerr: (libc)Error Recovery. |
| * clearerr_unlocked: (libc)Error Recovery. |
| * clock: (libc)CPU Time. |
| * clog10: (libc)Exponents and Logarithms. |
| * clog10f: (libc)Exponents and Logarithms. |
| * clog10fN: (libc)Exponents and Logarithms. |
| * clog10fNx: (libc)Exponents and Logarithms. |
| * clog10l: (libc)Exponents and Logarithms. |
| * clog: (libc)Exponents and Logarithms. |
| * clogf: (libc)Exponents and Logarithms. |
| * clogfN: (libc)Exponents and Logarithms. |
| * clogfNx: (libc)Exponents and Logarithms. |
| * clogl: (libc)Exponents and Logarithms. |
| * close: (libc)Opening and Closing Files. |
| * closedir: (libc)Reading/Closing Directory. |
| * closelog: (libc)closelog. |
| * cnd_broadcast: (libc)ISO C Condition Variables. |
| * cnd_destroy: (libc)ISO C Condition Variables. |
| * cnd_init: (libc)ISO C Condition Variables. |
| * cnd_signal: (libc)ISO C Condition Variables. |
| * cnd_timedwait: (libc)ISO C Condition Variables. |
| * cnd_wait: (libc)ISO C Condition Variables. |
| * confstr: (libc)String Parameters. |
| * conj: (libc)Operations on Complex. |
| * conjf: (libc)Operations on Complex. |
| * conjfN: (libc)Operations on Complex. |
| * conjfNx: (libc)Operations on Complex. |
| * conjl: (libc)Operations on Complex. |
| * connect: (libc)Connecting. |
| * copy_file_range: (libc)Copying File Data. |
| * copysign: (libc)FP Bit Twiddling. |
| * copysignf: (libc)FP Bit Twiddling. |
| * copysignfN: (libc)FP Bit Twiddling. |
| * copysignfNx: (libc)FP Bit Twiddling. |
| * copysignl: (libc)FP Bit Twiddling. |
| * cos: (libc)Trig Functions. |
| * cosf: (libc)Trig Functions. |
| * cosfN: (libc)Trig Functions. |
| * cosfNx: (libc)Trig Functions. |
| * cosh: (libc)Hyperbolic Functions. |
| * coshf: (libc)Hyperbolic Functions. |
| * coshfN: (libc)Hyperbolic Functions. |
| * coshfNx: (libc)Hyperbolic Functions. |
| * coshl: (libc)Hyperbolic Functions. |
| * cosl: (libc)Trig Functions. |
| * cpow: (libc)Exponents and Logarithms. |
| * cpowf: (libc)Exponents and Logarithms. |
| * cpowfN: (libc)Exponents and Logarithms. |
| * cpowfNx: (libc)Exponents and Logarithms. |
| * cpowl: (libc)Exponents and Logarithms. |
| * cproj: (libc)Operations on Complex. |
| * cprojf: (libc)Operations on Complex. |
| * cprojfN: (libc)Operations on Complex. |
| * cprojfNx: (libc)Operations on Complex. |
| * cprojl: (libc)Operations on Complex. |
| * creal: (libc)Operations on Complex. |
| * crealf: (libc)Operations on Complex. |
| * crealfN: (libc)Operations on Complex. |
| * crealfNx: (libc)Operations on Complex. |
| * creall: (libc)Operations on Complex. |
| * creat64: (libc)Opening and Closing Files. |
| * creat: (libc)Opening and Closing Files. |
| * crypt: (libc)Passphrase Storage. |
| * crypt_r: (libc)Passphrase Storage. |
| * csin: (libc)Trig Functions. |
| * csinf: (libc)Trig Functions. |
| * csinfN: (libc)Trig Functions. |
| * csinfNx: (libc)Trig Functions. |
| * csinh: (libc)Hyperbolic Functions. |
| * csinhf: (libc)Hyperbolic Functions. |
| * csinhfN: (libc)Hyperbolic Functions. |
| * csinhfNx: (libc)Hyperbolic Functions. |
| * csinhl: (libc)Hyperbolic Functions. |
| * csinl: (libc)Trig Functions. |
| * csqrt: (libc)Exponents and Logarithms. |
| * csqrtf: (libc)Exponents and Logarithms. |
| * csqrtfN: (libc)Exponents and Logarithms. |
| * csqrtfNx: (libc)Exponents and Logarithms. |
| * csqrtl: (libc)Exponents and Logarithms. |
| * ctan: (libc)Trig Functions. |
| * ctanf: (libc)Trig Functions. |
| * ctanfN: (libc)Trig Functions. |
| * ctanfNx: (libc)Trig Functions. |
| * ctanh: (libc)Hyperbolic Functions. |
| * ctanhf: (libc)Hyperbolic Functions. |
| * ctanhfN: (libc)Hyperbolic Functions. |
| * ctanhfNx: (libc)Hyperbolic Functions. |
| * ctanhl: (libc)Hyperbolic Functions. |
| * ctanl: (libc)Trig Functions. |
| * ctermid: (libc)Identifying the Terminal. |
| * ctime: (libc)Formatting Calendar Time. |
| * ctime_r: (libc)Formatting Calendar Time. |
| * cuserid: (libc)Who Logged In. |
| * daddl: (libc)Misc FP Arithmetic. |
| * dcgettext: (libc)Translation with gettext. |
| * dcngettext: (libc)Advanced gettext functions. |
| * ddivl: (libc)Misc FP Arithmetic. |
| * 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. |
| * dmull: (libc)Misc FP Arithmetic. |
| * 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. |
| * dsubl: (libc)Misc FP Arithmetic. |
| * dup2: (libc)Duplicating Descriptors. |
| * dup: (libc)Duplicating Descriptors. |
| * ecvt: (libc)System V Number Conversion. |
| * ecvt_r: (libc)System V Number Conversion. |
| * endfsent: (libc)fstab. |
| * endgrent: (libc)Scanning All Groups. |
| * endhostent: (libc)Host Names. |
| * endmntent: (libc)mtab. |
| * endnetent: (libc)Networks Database. |
| * endnetgrent: (libc)Lookup Netgroup. |
| * endprotoent: (libc)Protocols Database. |
| * endpwent: (libc)Scanning All Users. |
| * endservent: (libc)Services Database. |
| * endutent: (libc)Manipulating the Database. |
| * endutxent: (libc)XPG Functions. |
| * envz_add: (libc)Envz Functions. |
| * envz_entry: (libc)Envz Functions. |
| * envz_get: (libc)Envz Functions. |
| * envz_merge: (libc)Envz Functions. |
| * envz_remove: (libc)Envz Functions. |
| * envz_strip: (libc)Envz Functions. |
| * erand48: (libc)SVID Random. |
| * erand48_r: (libc)SVID Random. |
| * erf: (libc)Special Functions. |
| * erfc: (libc)Special Functions. |
| * erfcf: (libc)Special Functions. |
| * erfcfN: (libc)Special Functions. |
| * erfcfNx: (libc)Special Functions. |
| * erfcl: (libc)Special Functions. |
| * erff: (libc)Special Functions. |
| * erffN: (libc)Special Functions. |
| * erffNx: (libc)Special Functions. |
| * erfl: (libc)Special Functions. |
| * err: (libc)Error Messages. |
| * errno: (libc)Checking for Errors. |
| * error: (libc)Error Messages. |
| * error_at_line: (libc)Error Messages. |
| * errx: (libc)Error Messages. |
| * execl: (libc)Executing a File. |
| * execle: (libc)Executing a File. |
| * execlp: (libc)Executing a File. |
| * execv: (libc)Executing a File. |
| * execve: (libc)Executing a File. |
| * execvp: (libc)Executing a File. |
| * exit: (libc)Normal Termination. |
| * exp10: (libc)Exponents and Logarithms. |
| * exp10f: (libc)Exponents and Logarithms. |
| * exp10fN: (libc)Exponents and Logarithms. |
| * exp10fNx: (libc)Exponents and Logarithms. |
| * exp10l: (libc)Exponents and Logarithms. |
| * exp2: (libc)Exponents and Logarithms. |
| * exp2f: (libc)Exponents and Logarithms. |
| * exp2fN: (libc)Exponents and Logarithms. |
| * exp2fNx: (libc)Exponents and Logarithms. |
| * exp2l: (libc)Exponents and Logarithms. |
| * exp: (libc)Exponents and Logarithms. |
| * expf: (libc)Exponents and Logarithms. |
| * expfN: (libc)Exponents and Logarithms. |
| * expfNx: (libc)Exponents and Logarithms. |
| * expl: (libc)Exponents and Logarithms. |
| * explicit_bzero: (libc)Erasing Sensitive Data. |
| * expm1: (libc)Exponents and Logarithms. |
| * expm1f: (libc)Exponents and Logarithms. |
| * expm1fN: (libc)Exponents and Logarithms. |
| * expm1fNx: (libc)Exponents and Logarithms. |
| * expm1l: (libc)Exponents and Logarithms. |
| * fMaddfN: (libc)Misc FP Arithmetic. |
| * fMaddfNx: (libc)Misc FP Arithmetic. |
| * fMdivfN: (libc)Misc FP Arithmetic. |
| * fMdivfNx: (libc)Misc FP Arithmetic. |
| * fMmulfN: (libc)Misc FP Arithmetic. |
| * fMmulfNx: (libc)Misc FP Arithmetic. |
| * fMsubfN: (libc)Misc FP Arithmetic. |
| * fMsubfNx: (libc)Misc FP Arithmetic. |
| * fMxaddfN: (libc)Misc FP Arithmetic. |
| * fMxaddfNx: (libc)Misc FP Arithmetic. |
| * fMxdivfN: (libc)Misc FP Arithmetic. |
| * fMxdivfNx: (libc)Misc FP Arithmetic. |
| * fMxmulfN: (libc)Misc FP Arithmetic. |
| * fMxmulfNx: (libc)Misc FP Arithmetic. |
| * fMxsubfN: (libc)Misc FP Arithmetic. |
| * fMxsubfNx: (libc)Misc FP Arithmetic. |
| * fabs: (libc)Absolute Value. |
| * fabsf: (libc)Absolute Value. |
| * fabsfN: (libc)Absolute Value. |
| * fabsfNx: (libc)Absolute Value. |
| * fabsl: (libc)Absolute Value. |
| * fadd: (libc)Misc FP Arithmetic. |
| * faddl: (libc)Misc FP Arithmetic. |
| * fchdir: (libc)Working Directory. |
| * fchmod: (libc)Setting Permissions. |
| * fchown: (libc)File Owner. |
| * fclose: (libc)Closing Streams. |
| * fcloseall: (libc)Closing Streams. |
| * fcntl: (libc)Control Operations. |
| * fcvt: (libc)System V Number Conversion. |
| * fcvt_r: (libc)System V Number Conversion. |
| * fdatasync: (libc)Synchronizing I/O. |
| * fdim: (libc)Misc FP Arithmetic. |
| * fdimf: (libc)Misc FP Arithmetic. |
| * fdimfN: (libc)Misc FP Arithmetic. |
| * fdimfNx: (libc)Misc FP Arithmetic. |
| * fdiml: (libc)Misc FP Arithmetic. |
| * fdiv: (libc)Misc FP Arithmetic. |
| * fdivl: (libc)Misc FP Arithmetic. |
| * fdopen: (libc)Descriptors and Streams. |
| * fdopendir: (libc)Opening a Directory. |
| * feclearexcept: (libc)Status bit operations. |
| * fedisableexcept: (libc)Control Functions. |
| * feenableexcept: (libc)Control Functions. |
| * fegetenv: (libc)Control Functions. |
| * fegetexcept: (libc)Control Functions. |
| * fegetexceptflag: (libc)Status bit operations. |
| * fegetmode: (libc)Control Functions. |
| * fegetround: (libc)Rounding. |
| * feholdexcept: (libc)Control Functions. |
| * feof: (libc)EOF and Errors. |
| * feof_unlocked: (libc)EOF and Errors. |
| * feraiseexcept: (libc)Status bit operations. |
| * ferror: (libc)EOF and Errors. |
| * ferror_unlocked: (libc)EOF and Errors. |
| * fesetenv: (libc)Control Functions. |
| * fesetexcept: (libc)Status bit operations. |
| * fesetexceptflag: (libc)Status bit operations. |
| * fesetmode: (libc)Control Functions. |
| * fesetround: (libc)Rounding. |
| * fetestexcept: (libc)Status bit operations. |
| * fetestexceptflag: (libc)Status bit operations. |
| * feupdateenv: (libc)Control Functions. |
| * 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. |
| * floorfN: (libc)Rounding Functions. |
| * floorfNx: (libc)Rounding Functions. |
| * floorl: (libc)Rounding Functions. |
| * fma: (libc)Misc FP Arithmetic. |
| * fmaf: (libc)Misc FP Arithmetic. |
| * fmafN: (libc)Misc FP Arithmetic. |
| * fmafNx: (libc)Misc FP Arithmetic. |
| * fmal: (libc)Misc FP Arithmetic. |
| * fmax: (libc)Misc FP Arithmetic. |
| * fmaxf: (libc)Misc FP Arithmetic. |
| * fmaxfN: (libc)Misc FP Arithmetic. |
| * fmaxfNx: (libc)Misc FP Arithmetic. |
| * fmaxl: (libc)Misc FP Arithmetic. |
| * fmaxmag: (libc)Misc FP Arithmetic. |
| * fmaxmagf: (libc)Misc FP Arithmetic. |
| * fmaxmagfN: (libc)Misc FP Arithmetic. |
| * fmaxmagfNx: (libc)Misc FP Arithmetic. |
| * fmaxmagl: (libc)Misc FP Arithmetic. |
| * fmemopen: (libc)String Streams. |
| * fmin: (libc)Misc FP Arithmetic. |
| * fminf: (libc)Misc FP Arithmetic. |
| * fminfN: (libc)Misc FP Arithmetic. |
| * fminfNx: (libc)Misc FP Arithmetic. |
| * fminl: (libc)Misc FP Arithmetic. |
| * fminmag: (libc)Misc FP Arithmetic. |
| * fminmagf: (libc)Misc FP Arithmetic. |
| * fminmagfN: (libc)Misc FP Arithmetic. |
| * fminmagfNx: (libc)Misc FP Arithmetic. |
| * fminmagl: (libc)Misc FP Arithmetic. |
| * fmod: (libc)Remainder Functions. |
| * fmodf: (libc)Remainder Functions. |
| * fmodfN: (libc)Remainder Functions. |
| * fmodfNx: (libc)Remainder Functions. |
| * fmodl: (libc)Remainder Functions. |
| * fmtmsg: (libc)Printing Formatted Messages. |
| * fmul: (libc)Misc FP Arithmetic. |
| * fmull: (libc)Misc FP Arithmetic. |
| * fnmatch: (libc)Wildcard Matching. |
| * fopen64: (libc)Opening Streams. |
| * fopen: (libc)Opening Streams. |
| * fopencookie: (libc)Streams and Cookies. |
| * fork: (libc)Creating a Process. |
| * forkpty: (libc)Pseudo-Terminal Pairs. |
| * fpathconf: (libc)Pathconf. |
| * fpclassify: (libc)Floating Point Classes. |
| * fprintf: (libc)Formatted Output Functions. |
| * fputc: (libc)Simple Output. |
| * fputc_unlocked: (libc)Simple Output. |
| * fputs: (libc)Simple Output. |
| * fputs_unlocked: (libc)Simple Output. |
| * fputwc: (libc)Simple Output. |
| * fputwc_unlocked: (libc)Simple Output. |
| * fputws: (libc)Simple Output. |
| * fputws_unlocked: (libc)Simple Output. |
| * fread: (libc)Block Input/Output. |
| * fread_unlocked: (libc)Block Input/Output. |
| * free: (libc)Freeing after Malloc. |
| * freopen64: (libc)Opening Streams. |
| * freopen: (libc)Opening Streams. |
| * frexp: (libc)Normalization Functions. |
| * frexpf: (libc)Normalization Functions. |
| * frexpfN: (libc)Normalization Functions. |
| * frexpfNx: (libc)Normalization Functions. |
| * frexpl: (libc)Normalization Functions. |
| * fromfp: (libc)Rounding Functions. |
| * fromfpf: (libc)Rounding Functions. |
| * fromfpfN: (libc)Rounding Functions. |
| * fromfpfNx: (libc)Rounding Functions. |
| * fromfpl: (libc)Rounding Functions. |
| * fromfpx: (libc)Rounding Functions. |
| * fromfpxf: (libc)Rounding Functions. |
| * fromfpxfN: (libc)Rounding Functions. |
| * fromfpxfNx: (libc)Rounding Functions. |
| * fromfpxl: (libc)Rounding Functions. |
| * fscanf: (libc)Formatted Input Functions. |
| * fseek: (libc)File Positioning. |
| * fseeko64: (libc)File Positioning. |
| * fseeko: (libc)File Positioning. |
| * fsetpos64: (libc)Portable Positioning. |
| * fsetpos: (libc)Portable Positioning. |
| * fstat64: (libc)Reading Attributes. |
| * fstat: (libc)Reading Attributes. |
| * fsub: (libc)Misc FP Arithmetic. |
| * fsubl: (libc)Misc FP Arithmetic. |
| * fsync: (libc)Synchronizing I/O. |
| * ftell: (libc)File Positioning. |
| * ftello64: (libc)File Positioning. |
| * ftello: (libc)File Positioning. |
| * ftruncate64: (libc)File Size. |
| * ftruncate: (libc)File Size. |
| * ftrylockfile: (libc)Streams and Threads. |
| * ftw64: (libc)Working with Directory Trees. |
| * ftw: (libc)Working with Directory Trees. |
| * funlockfile: (libc)Streams and Threads. |
| * futimes: (libc)File Times. |
| * fwide: (libc)Streams and I18N. |
| * fwprintf: (libc)Formatted Output Functions. |
| * fwrite: (libc)Block Input/Output. |
| * fwrite_unlocked: (libc)Block Input/Output. |
| * fwscanf: (libc)Formatted Input Functions. |
| * gamma: (libc)Special Functions. |
| * gammaf: (libc)Special Functions. |
| * gammal: (libc)Special Functions. |
| * gcvt: (libc)System V Number Conversion. |
| * get_avphys_pages: (libc)Query Memory Parameters. |
| * get_current_dir_name: (libc)Working Directory. |
| * get_nprocs: (libc)Processor Resources. |
| * get_nprocs_conf: (libc)Processor Resources. |
| * get_phys_pages: (libc)Query Memory Parameters. |
| * getauxval: (libc)Auxiliary Vector. |
| * getc: (libc)Character Input. |
| * getc_unlocked: (libc)Character Input. |
| * getchar: (libc)Character Input. |
| * getchar_unlocked: (libc)Character Input. |
| * getcontext: (libc)System V contexts. |
| * getcpu: (libc)CPU Affinity. |
| * getcwd: (libc)Working Directory. |
| * getdate: (libc)General Time String Parsing. |
| * getdate_r: (libc)General Time String Parsing. |
| * getdelim: (libc)Line Input. |
| * getdents64: (libc)Low-level Directory Access. |
| * getdomainnname: (libc)Host Identification. |
| * getegid: (libc)Reading Persona. |
| * getentropy: (libc)Unpredictable Bytes. |
| * getenv: (libc)Environment Access. |
| * geteuid: (libc)Reading Persona. |
| * getfsent: (libc)fstab. |
| * getfsfile: (libc)fstab. |
| * getfsspec: (libc)fstab. |
| * getgid: (libc)Reading Persona. |
| * getgrent: (libc)Scanning All Groups. |
| * getgrent_r: (libc)Scanning All Groups. |
| * getgrgid: (libc)Lookup Group. |
| * getgrgid_r: (libc)Lookup Group. |
| * getgrnam: (libc)Lookup Group. |
| * getgrnam_r: (libc)Lookup Group. |
| * getgrouplist: (libc)Setting Groups. |
| * getgroups: (libc)Reading Persona. |
| * gethostbyaddr: (libc)Host Names. |
| * gethostbyaddr_r: (libc)Host Names. |
| * gethostbyname2: (libc)Host Names. |
| * gethostbyname2_r: (libc)Host Names. |
| * gethostbyname: (libc)Host Names. |
| * gethostbyname_r: (libc)Host Names. |
| * gethostent: (libc)Host Names. |
| * gethostid: (libc)Host Identification. |
| * gethostname: (libc)Host Identification. |
| * getitimer: (libc)Setting an Alarm. |
| * getline: (libc)Line Input. |
| * getloadavg: (libc)Processor Resources. |
| * getlogin: (libc)Who Logged In. |
| * getmntent: (libc)mtab. |
| * getmntent_r: (libc)mtab. |
| * getnetbyaddr: (libc)Networks Database. |
| * getnetbyname: (libc)Networks Database. |
| * getnetent: (libc)Networks Database. |
| * getnetgrent: (libc)Lookup Netgroup. |
| * getnetgrent_r: (libc)Lookup Netgroup. |
| * getopt: (libc)Using Getopt. |
| * getopt_long: (libc)Getopt Long Options. |
| * getopt_long_only: (libc)Getopt Long Options. |
| * getpagesize: (libc)Query Memory Parameters. |
| * getpass: (libc)getpass. |
| * getpayload: (libc)FP Bit Twiddling. |
| * getpayloadf: (libc)FP Bit Twiddling. |
| * getpayloadfN: (libc)FP Bit Twiddling. |
| * getpayloadfNx: (libc)FP Bit Twiddling. |
| * getpayloadl: (libc)FP Bit Twiddling. |
| * getpeername: (libc)Who is Connected. |
| * getpgid: (libc)Process Group Functions. |
| * getpgrp: (libc)Process Group Functions. |
| * getpid: (libc)Process Identification. |
| * getppid: (libc)Process Identification. |
| * getpriority: (libc)Traditional Scheduling Functions. |
| * getprotobyname: (libc)Protocols Database. |
| * getprotobynumber: (libc)Protocols Database. |
| * getprotoent: (libc)Protocols Database. |
| * getpt: (libc)Allocation. |
| * getpwent: (libc)Scanning All Users. |
| * getpwent_r: (libc)Scanning All Users. |
| * getpwnam: (libc)Lookup User. |
| * getpwnam_r: (libc)Lookup User. |
| * getpwuid: (libc)Lookup User. |
| * getpwuid_r: (libc)Lookup User. |
| * getrandom: (libc)Unpredictable Bytes. |
| * getrlimit64: (libc)Limits on Resources. |
| * getrlimit: (libc)Limits on Resources. |
| * getrusage: (libc)Resource Usage. |
| * gets: (libc)Line Input. |
| * getservbyname: (libc)Services Database. |
| * getservbyport: (libc)Services Database. |
| * getservent: (libc)Services Database. |
| * getsid: (libc)Process Group Functions. |
| * getsockname: (libc)Reading Address. |
| * getsockopt: (libc)Socket Option Functions. |
| * getsubopt: (libc)Suboptions. |
| * gettext: (libc)Translation with gettext. |
| * gettid: (libc)Process Identification. |
| * gettimeofday: (libc)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. |
| * hypotfN: (libc)Exponents and Logarithms. |
| * hypotfNx: (libc)Exponents and Logarithms. |
| * hypotl: (libc)Exponents and Logarithms. |
| * iconv: (libc)Generic Conversion Interface. |
| * iconv_close: (libc)Generic Conversion Interface. |
| * iconv_open: (libc)Generic Conversion Interface. |
| * if_freenameindex: (libc)Interface Naming. |
| * if_indextoname: (libc)Interface Naming. |
| * if_nameindex: (libc)Interface Naming. |
| * if_nametoindex: (libc)Interface Naming. |
| * ilogb: (libc)Exponents and Logarithms. |
| * ilogbf: (libc)Exponents and Logarithms. |
| * ilogbfN: (libc)Exponents and Logarithms. |
| * ilogbfNx: (libc)Exponents and Logarithms. |
| * ilogbl: (libc)Exponents and Logarithms. |
| * imaxabs: (libc)Absolute Value. |
| * imaxdiv: (libc)Integer Division. |
| * in6addr_any: (libc)Host Address Data Type. |
| * in6addr_loopback: (libc)Host Address Data Type. |
| * index: (libc)Search Functions. |
| * inet_addr: (libc)Host Address Functions. |
| * inet_aton: (libc)Host Address Functions. |
| * inet_lnaof: (libc)Host Address Functions. |
| * inet_makeaddr: (libc)Host Address Functions. |
| * inet_netof: (libc)Host Address Functions. |
| * inet_network: (libc)Host Address Functions. |
| * inet_ntoa: (libc)Host Address Functions. |
| * inet_ntop: (libc)Host Address Functions. |
| * inet_pton: (libc)Host Address Functions. |
| * initgroups: (libc)Setting Groups. |
| * initstate: (libc)BSD Random. |
| * initstate_r: (libc)BSD Random. |
| * innetgr: (libc)Netgroup Membership. |
| * ioctl: (libc)IOCTLs. |
| * isalnum: (libc)Classification of Characters. |
| * isalpha: (libc)Classification of Characters. |
| * isascii: (libc)Classification of Characters. |
| * isatty: (libc)Is It a Terminal. |
| * isblank: (libc)Classification of Characters. |
| * iscanonical: (libc)Floating Point Classes. |
| * iscntrl: (libc)Classification of Characters. |
| * isdigit: (libc)Classification of Characters. |
| * iseqsig: (libc)FP Comparison Functions. |
| * isfinite: (libc)Floating Point Classes. |
| * isgraph: (libc)Classification of Characters. |
| * isgreater: (libc)FP Comparison Functions. |
| * isgreaterequal: (libc)FP Comparison Functions. |
| * isinf: (libc)Floating Point Classes. |
| * isinff: (libc)Floating Point Classes. |
| * isinfl: (libc)Floating Point Classes. |
| * isless: (libc)FP Comparison Functions. |
| * islessequal: (libc)FP Comparison Functions. |
| * islessgreater: (libc)FP Comparison Functions. |
| * islower: (libc)Classification of Characters. |
| * isnan: (libc)Floating Point Classes. |
| * isnan: (libc)Floating Point Classes. |
| * isnanf: (libc)Floating Point Classes. |
| * isnanl: (libc)Floating Point Classes. |
| * isnormal: (libc)Floating Point Classes. |
| * isprint: (libc)Classification of Characters. |
| * ispunct: (libc)Classification of Characters. |
| * issignaling: (libc)Floating Point Classes. |
| * isspace: (libc)Classification of Characters. |
| * issubnormal: (libc)Floating Point Classes. |
| * isunordered: (libc)FP Comparison Functions. |
| * isupper: (libc)Classification of Characters. |
| * iswalnum: (libc)Classification of Wide Characters. |
| * iswalpha: (libc)Classification of Wide Characters. |
| * iswblank: (libc)Classification of Wide Characters. |
| * iswcntrl: (libc)Classification of Wide Characters. |
| * iswctype: (libc)Classification of Wide Characters. |
| * iswdigit: (libc)Classification of Wide Characters. |
| * iswgraph: (libc)Classification of Wide Characters. |
| * iswlower: (libc)Classification of Wide Characters. |
| * iswprint: (libc)Classification of Wide Characters. |
| * iswpunct: (libc)Classification of Wide Characters. |
| * iswspace: (libc)Classification of Wide Characters. |
| * iswupper: (libc)Classification of Wide Characters. |
| * iswxdigit: (libc)Classification of Wide Characters. |
| * isxdigit: (libc)Classification of Characters. |
| * iszero: (libc)Floating Point Classes. |
| * j0: (libc)Special Functions. |
| * j0f: (libc)Special Functions. |
| * j0fN: (libc)Special Functions. |
| * j0fNx: (libc)Special Functions. |
| * j0l: (libc)Special Functions. |
| * j1: (libc)Special Functions. |
| * j1f: (libc)Special Functions. |
| * j1fN: (libc)Special Functions. |
| * j1fNx: (libc)Special Functions. |
| * j1l: (libc)Special Functions. |
| * jn: (libc)Special Functions. |
| * jnf: (libc)Special Functions. |
| * jnfN: (libc)Special Functions. |
| * jnfNx: (libc)Special Functions. |
| * jnl: (libc)Special Functions. |
| * jrand48: (libc)SVID Random. |
| * jrand48_r: (libc)SVID Random. |
| * kill: (libc)Signaling Another Process. |
| * killpg: (libc)Signaling Another Process. |
| * l64a: (libc)Encode Binary Data. |
| * labs: (libc)Absolute Value. |
| * lcong48: (libc)SVID Random. |
| * lcong48_r: (libc)SVID Random. |
| * ldexp: (libc)Normalization Functions. |
| * ldexpf: (libc)Normalization Functions. |
| * ldexpfN: (libc)Normalization Functions. |
| * ldexpfNx: (libc)Normalization Functions. |
| * ldexpl: (libc)Normalization Functions. |
| * ldiv: (libc)Integer Division. |
| * lfind: (libc)Array Search Function. |
| * lgamma: (libc)Special Functions. |
| * lgamma_r: (libc)Special Functions. |
| * lgammaf: (libc)Special Functions. |
| * lgammafN: (libc)Special Functions. |
| * lgammafN_r: (libc)Special Functions. |
| * lgammafNx: (libc)Special Functions. |
| * lgammafNx_r: (libc)Special Functions. |
| * lgammaf_r: (libc)Special Functions. |
| * lgammal: (libc)Special Functions. |
| * lgammal_r: (libc)Special Functions. |
| * link: (libc)Hard Links. |
| * linkat: (libc)Hard Links. |
| * lio_listio64: (libc)Asynchronous Reads/Writes. |
| * lio_listio: (libc)Asynchronous Reads/Writes. |
| * listen: (libc)Listening. |
| * llabs: (libc)Absolute Value. |
| * lldiv: (libc)Integer Division. |
| * llogb: (libc)Exponents and Logarithms. |
| * llogbf: (libc)Exponents and Logarithms. |
| * llogbfN: (libc)Exponents and Logarithms. |
| * llogbfNx: (libc)Exponents and Logarithms. |
| * llogbl: (libc)Exponents and Logarithms. |
| * llrint: (libc)Rounding Functions. |
| * llrintf: (libc)Rounding Functions. |
| * llrintfN: (libc)Rounding Functions. |
| * llrintfNx: (libc)Rounding Functions. |
| * llrintl: (libc)Rounding Functions. |
| * llround: (libc)Rounding Functions. |
| * llroundf: (libc)Rounding Functions. |
| * llroundfN: (libc)Rounding Functions. |
| * llroundfNx: (libc)Rounding Functions. |
| * llroundl: (libc)Rounding Functions. |
| * localeconv: (libc)The Lame Way to Locale Data. |
| * localtime: (libc)Broken-down Time. |
| * localtime_r: (libc)Broken-down Time. |
| * log10: (libc)Exponents and Logarithms. |
| * log10f: (libc)Exponents and Logarithms. |
| * log10fN: (libc)Exponents and Logarithms. |
| * log10fNx: (libc)Exponents and Logarithms. |
| * log10l: (libc)Exponents and Logarithms. |
| * log1p: (libc)Exponents and Logarithms. |
| * log1pf: (libc)Exponents and Logarithms. |
| * log1pfN: (libc)Exponents and Logarithms. |
| * log1pfNx: (libc)Exponents and Logarithms. |
| * log1pl: (libc)Exponents and Logarithms. |
| * log2: (libc)Exponents and Logarithms. |
| * log2f: (libc)Exponents and Logarithms. |
| * log2fN: (libc)Exponents and Logarithms. |
| * log2fNx: (libc)Exponents and Logarithms. |
| * log2l: (libc)Exponents and Logarithms. |
| * log: (libc)Exponents and Logarithms. |
| * logb: (libc)Exponents and Logarithms. |
| * logbf: (libc)Exponents and Logarithms. |
| * logbfN: (libc)Exponents and Logarithms. |
| * logbfNx: (libc)Exponents and Logarithms. |
| * logbl: (libc)Exponents and Logarithms. |
| * logf: (libc)Exponents and Logarithms. |
| * logfN: (libc)Exponents and Logarithms. |
| * logfNx: (libc)Exponents and Logarithms. |
| * login: (libc)Logging In and Out. |
| * login_tty: (libc)Logging In and Out. |
| * logl: (libc)Exponents and Logarithms. |
| * logout: (libc)Logging In and Out. |
| * logwtmp: (libc)Logging In and Out. |
| * longjmp: (libc)Non-Local Details. |
| * lrand48: (libc)SVID Random. |
| * lrand48_r: (libc)SVID Random. |
| * lrint: (libc)Rounding Functions. |
| * lrintf: (libc)Rounding Functions. |
| * lrintfN: (libc)Rounding Functions. |
| * lrintfNx: (libc)Rounding Functions. |
| * lrintl: (libc)Rounding Functions. |
| * lround: (libc)Rounding Functions. |
| * lroundf: (libc)Rounding Functions. |
| * lroundfN: (libc)Rounding Functions. |
| * lroundfNx: (libc)Rounding Functions. |
| * lroundl: (libc)Rounding Functions. |
| * lsearch: (libc)Array Search Function. |
| * lseek64: (libc)File Position Primitive. |
| * lseek: (libc)File Position Primitive. |
| * lstat64: (libc)Reading Attributes. |
| * lstat: (libc)Reading Attributes. |
| * lutimes: (libc)File Times. |
| * madvise: (libc)Memory-mapped I/O. |
| * makecontext: (libc)System V contexts. |
| * 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 Strings and Arrays. |
| * memchr: (libc)Search Functions. |
| * memcmp: (libc)String/Array Comparison. |
| * memcpy: (libc)Copying Strings and Arrays. |
| * memfd_create: (libc)Memory-mapped I/O. |
| * memfrob: (libc)Obfuscating Data. |
| * memmem: (libc)Search Functions. |
| * memmove: (libc)Copying Strings and Arrays. |
| * mempcpy: (libc)Copying Strings and Arrays. |
| * memrchr: (libc)Search Functions. |
| * memset: (libc)Copying Strings and Arrays. |
| * mkdir: (libc)Creating Directories. |
| * mkdtemp: (libc)Temporary Files. |
| * mkfifo: (libc)FIFO Special Files. |
| * mknod: (libc)Making Special Files. |
| * mkstemp: (libc)Temporary Files. |
| * mktemp: (libc)Temporary Files. |
| * mktime: (libc)Broken-down Time. |
| * mlock2: (libc)Page Lock Functions. |
| * mlock: (libc)Page Lock Functions. |
| * mlockall: (libc)Page Lock Functions. |
| * mmap64: (libc)Memory-mapped I/O. |
| * mmap: (libc)Memory-mapped I/O. |
| * modf: (libc)Rounding Functions. |
| * modff: (libc)Rounding Functions. |
| * modffN: (libc)Rounding Functions. |
| * modffNx: (libc)Rounding Functions. |
| * modfl: (libc)Rounding Functions. |
| * mount: (libc)Mount-Unmount-Remount. |
| * mprobe: (libc)Heap Consistency Checking. |
| * mprotect: (libc)Memory Protection. |
| * mrand48: (libc)SVID Random. |
| * mrand48_r: (libc)SVID Random. |
| * mremap: (libc)Memory-mapped I/O. |
| * msync: (libc)Memory-mapped I/O. |
| * mtrace: (libc)Tracing malloc. |
| * mtx_destroy: (libc)ISO C Mutexes. |
| * mtx_init: (libc)ISO C Mutexes. |
| * mtx_lock: (libc)ISO C Mutexes. |
| * mtx_timedlock: (libc)ISO C Mutexes. |
| * mtx_trylock: (libc)ISO C Mutexes. |
| * mtx_unlock: (libc)ISO C Mutexes. |
| * munlock: (libc)Page Lock Functions. |
| * munlockall: (libc)Page Lock Functions. |
| * munmap: (libc)Memory-mapped I/O. |
| * muntrace: (libc)Tracing malloc. |
| * nan: (libc)FP Bit Twiddling. |
| * nanf: (libc)FP Bit Twiddling. |
| * nanfN: (libc)FP Bit Twiddling. |
| * nanfNx: (libc)FP Bit Twiddling. |
| * nanl: (libc)FP Bit Twiddling. |
| * nanosleep: (libc)Sleeping. |
| * nearbyint: (libc)Rounding Functions. |
| * nearbyintf: (libc)Rounding Functions. |
| * nearbyintfN: (libc)Rounding Functions. |
| * nearbyintfNx: (libc)Rounding Functions. |
| * nearbyintl: (libc)Rounding Functions. |
| * nextafter: (libc)FP Bit Twiddling. |
| * nextafterf: (libc)FP Bit Twiddling. |
| * nextafterfN: (libc)FP Bit Twiddling. |
| * nextafterfNx: (libc)FP Bit Twiddling. |
| * nextafterl: (libc)FP Bit Twiddling. |
| * nextdown: (libc)FP Bit Twiddling. |
| * nextdownf: (libc)FP Bit Twiddling. |
| * nextdownfN: (libc)FP Bit Twiddling. |
| * nextdownfNx: (libc)FP Bit Twiddling. |
| * nextdownl: (libc)FP Bit Twiddling. |
| * nexttoward: (libc)FP Bit Twiddling. |
| * nexttowardf: (libc)FP Bit Twiddling. |
| * nexttowardl: (libc)FP Bit Twiddling. |
| * nextup: (libc)FP Bit Twiddling. |
| * nextupf: (libc)FP Bit Twiddling. |
| * nextupfN: (libc)FP Bit Twiddling. |
| * nextupfNx: (libc)FP Bit Twiddling. |
| * nextupl: (libc)FP Bit Twiddling. |
| * nftw64: (libc)Working with Directory Trees. |
| * nftw: (libc)Working with Directory Trees. |
| * ngettext: (libc)Advanced gettext functions. |
| * nice: (libc)Traditional Scheduling Functions. |
| * nl_langinfo: (libc)The Elegant and Fast Way. |
| * nrand48: (libc)SVID Random. |
| * nrand48_r: (libc)SVID Random. |
| * ntohl: (libc)Byte Order. |
| * ntohs: (libc)Byte Order. |
| * ntp_adjtime: (libc)High Accuracy Clock. |
| * ntp_gettime: (libc)High Accuracy Clock. |
| * obstack_1grow: (libc)Growing Objects. |
| * obstack_1grow_fast: (libc)Extra Fast Growing. |
| * obstack_alignment_mask: (libc)Obstacks Data Alignment. |
| * obstack_alloc: (libc)Allocation in an Obstack. |
| * obstack_base: (libc)Status of an Obstack. |
| * obstack_blank: (libc)Growing Objects. |
| * obstack_blank_fast: (libc)Extra Fast Growing. |
| * obstack_chunk_size: (libc)Obstack Chunks. |
| * obstack_copy0: (libc)Allocation in an Obstack. |
| * obstack_copy: (libc)Allocation in an Obstack. |
| * obstack_finish: (libc)Growing Objects. |
| * obstack_free: (libc)Freeing Obstack Objects. |
| * obstack_grow0: (libc)Growing Objects. |
| * obstack_grow: (libc)Growing Objects. |
| * obstack_init: (libc)Preparing for Obstacks. |
| * obstack_int_grow: (libc)Growing Objects. |
| * obstack_int_grow_fast: (libc)Extra Fast Growing. |
| * obstack_next_free: (libc)Status of an Obstack. |
| * obstack_object_size: (libc)Growing Objects. |
| * obstack_object_size: (libc)Status of an Obstack. |
| * obstack_printf: (libc)Dynamic Output. |
| * obstack_ptr_grow: (libc)Growing Objects. |
| * obstack_ptr_grow_fast: (libc)Extra Fast Growing. |
| * obstack_room: (libc)Extra Fast Growing. |
| * obstack_vprintf: (libc)Variable Arguments Output. |
| * offsetof: (libc)Structure Measurement. |
| * on_exit: (libc)Cleanups on Exit. |
| * open64: (libc)Opening and Closing Files. |
| * open: (libc)Opening and Closing Files. |
| * open_memstream: (libc)String Streams. |
| * opendir: (libc)Opening a Directory. |
| * openlog: (libc)openlog. |
| * openpty: (libc)Pseudo-Terminal Pairs. |
| * parse_printf_format: (libc)Parsing a Template String. |
| * pathconf: (libc)Pathconf. |
| * pause: (libc)Using Pause. |
| * pclose: (libc)Pipe to a Subprocess. |
| * perror: (libc)Error Messages. |
| * pipe: (libc)Creating a Pipe. |
| * pkey_alloc: (libc)Memory Protection. |
| * pkey_free: (libc)Memory Protection. |
| * pkey_get: (libc)Memory Protection. |
| * pkey_mprotect: (libc)Memory Protection. |
| * pkey_set: (libc)Memory Protection. |
| * popen: (libc)Pipe to a Subprocess. |
| * posix_fallocate64: (libc)Storage Allocation. |
| * posix_fallocate: (libc)Storage Allocation. |
| * posix_memalign: (libc)Aligned Memory Blocks. |
| * pow: (libc)Exponents and Logarithms. |
| * powf: (libc)Exponents and Logarithms. |
| * powfN: (libc)Exponents and Logarithms. |
| * powfNx: (libc)Exponents and Logarithms. |
| * powl: (libc)Exponents and Logarithms. |
| * pread64: (libc)I/O Primitives. |
| * pread: (libc)I/O Primitives. |
| * preadv2: (libc)Scatter-Gather. |
| * preadv64: (libc)Scatter-Gather. |
| * preadv64v2: (libc)Scatter-Gather. |
| * preadv: (libc)Scatter-Gather. |
| * printf: (libc)Formatted Output Functions. |
| * printf_size: (libc)Predefined Printf Handlers. |
| * printf_size_info: (libc)Predefined Printf Handlers. |
| * psignal: (libc)Signal Messages. |
| * pthread_cond_clockwait: (libc)Default Thread Attributes. |
| * pthread_getattr_default_np: (libc)Default Thread Attributes. |
| * pthread_getspecific: (libc)Thread-specific Data. |
| * pthread_key_create: (libc)Thread-specific Data. |
| * pthread_key_delete: (libc)Thread-specific Data. |
| * pthread_rwlock_clockrdlock: (libc)Default Thread Attributes. |
| * pthread_rwlock_clockwrlock: (libc)Default Thread Attributes. |
| * pthread_setattr_default_np: (libc)Default Thread Attributes. |
| * pthread_setspecific: (libc)Thread-specific Data. |
| * ptsname: (libc)Allocation. |
| * ptsname_r: (libc)Allocation. |
| * putc: (libc)Simple Output. |
| * putc_unlocked: (libc)Simple Output. |
| * putchar: (libc)Simple Output. |
| * putchar_unlocked: (libc)Simple Output. |
| * putenv: (libc)Environment Access. |
| * putpwent: (libc)Writing a User Entry. |
| * puts: (libc)Simple Output. |
| * pututline: (libc)Manipulating the Database. |
| * pututxline: (libc)XPG Functions. |
| * putw: (libc)Simple Output. |
| * putwc: (libc)Simple Output. |
| * putwc_unlocked: (libc)Simple Output. |
| * putwchar: (libc)Simple Output. |
| * putwchar_unlocked: (libc)Simple Output. |
| * pwrite64: (libc)I/O Primitives. |
| * pwrite: (libc)I/O Primitives. |
| * pwritev2: (libc)Scatter-Gather. |
| * pwritev64: (libc)Scatter-Gather. |
| * pwritev64v2: (libc)Scatter-Gather. |
| * pwritev: (libc)Scatter-Gather. |
| * qecvt: (libc)System V Number Conversion. |
| * qecvt_r: (libc)System V Number Conversion. |
| * qfcvt: (libc)System V Number Conversion. |
| * qfcvt_r: (libc)System V Number Conversion. |
| * qgcvt: (libc)System V Number Conversion. |
| * qsort: (libc)Array Sort Function. |
| * raise: (libc)Signaling Yourself. |
| * rand: (libc)ISO Random. |
| * rand_r: (libc)ISO Random. |
| * random: (libc)BSD Random. |
| * random_r: (libc)BSD Random. |
| * rawmemchr: (libc)Search Functions. |
| * read: (libc)I/O Primitives. |
| * readdir64: (libc)Reading/Closing Directory. |
| * readdir64_r: (libc)Reading/Closing Directory. |
| * readdir: (libc)Reading/Closing Directory. |
| * readdir_r: (libc)Reading/Closing Directory. |
| * readlink: (libc)Symbolic Links. |
| * readv: (libc)Scatter-Gather. |
| * realloc: (libc)Changing Block Size. |
| * reallocarray: (libc)Changing Block Size. |
| * realpath: (libc)Symbolic Links. |
| * recv: (libc)Receiving Data. |
| * recvfrom: (libc)Receiving Datagrams. |
| * recvmsg: (libc)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. |
| * remainderfN: (libc)Remainder Functions. |
| * remainderfNx: (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. |
| * rintfN: (libc)Rounding Functions. |
| * rintfNx: (libc)Rounding Functions. |
| * rintl: (libc)Rounding Functions. |
| * rmdir: (libc)Deleting Files. |
| * round: (libc)Rounding Functions. |
| * roundeven: (libc)Rounding Functions. |
| * roundevenf: (libc)Rounding Functions. |
| * roundevenfN: (libc)Rounding Functions. |
| * roundevenfNx: (libc)Rounding Functions. |
| * roundevenl: (libc)Rounding Functions. |
| * roundf: (libc)Rounding Functions. |
| * roundfN: (libc)Rounding Functions. |
| * roundfNx: (libc)Rounding Functions. |
| * roundl: (libc)Rounding Functions. |
| * rpmatch: (libc)Yes-or-No Questions. |
| * sbrk: (libc)Resizing the Data Segment. |
| * scalb: (libc)Normalization Functions. |
| * scalbf: (libc)Normalization Functions. |
| * scalbl: (libc)Normalization Functions. |
| * scalbln: (libc)Normalization Functions. |
| * scalblnf: (libc)Normalization Functions. |
| * scalblnfN: (libc)Normalization Functions. |
| * scalblnfNx: (libc)Normalization Functions. |
| * scalblnl: (libc)Normalization Functions. |
| * scalbn: (libc)Normalization Functions. |
| * scalbnf: (libc)Normalization Functions. |
| * scalbnfN: (libc)Normalization Functions. |
| * scalbnfNx: (libc)Normalization Functions. |
| * scalbnl: (libc)Normalization Functions. |
| * scandir64: (libc)Scanning Directory Content. |
| * scandir: (libc)Scanning Directory Content. |
| * scanf: (libc)Formatted Input Functions. |
| * sched_get_priority_max: (libc)Basic Scheduling Functions. |
| * sched_get_priority_min: (libc)Basic Scheduling Functions. |
| * sched_getaffinity: (libc)CPU Affinity. |
| * sched_getparam: (libc)Basic Scheduling Functions. |
| * sched_getscheduler: (libc)Basic Scheduling Functions. |
| * sched_rr_get_interval: (libc)Basic Scheduling Functions. |
| * sched_setaffinity: (libc)CPU Affinity. |
| * sched_setparam: (libc)Basic Scheduling Functions. |
| * sched_setscheduler: (libc)Basic Scheduling Functions. |
| * sched_yield: (libc)Basic Scheduling Functions. |
| * secure_getenv: (libc)Environment Access. |
| * seed48: (libc)SVID Random. |
| * seed48_r: (libc)SVID Random. |
| * seekdir: (libc)Random Access Directory. |
| * select: (libc)Waiting for I/O. |
| * sem_clockwait: (libc)Default Thread Attributes. |
| * sem_close: (libc)Semaphores. |
| * sem_destroy: (libc)Semaphores. |
| * sem_getvalue: (libc)Semaphores. |
| * sem_init: (libc)Semaphores. |
| * sem_open: (libc)Semaphores. |
| * sem_post: (libc)Semaphores. |
| * sem_timedwait: (libc)Semaphores. |
| * sem_trywait: (libc)Semaphores. |
| * sem_unlink: (libc)Semaphores. |
| * sem_wait: (libc)Semaphores. |
| * semctl: (libc)Semaphores. |
| * semget: (libc)Semaphores. |
| * semop: (libc)Semaphores. |
| * semtimedop: (libc)Semaphores. |
| * 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. |
| * setlinebuf: (libc)Controlling Buffering. |
| * setlocale: (libc)Setting the Locale. |
| * setlogmask: (libc)setlogmask. |
| * setmntent: (libc)mtab. |
| * setnetent: (libc)Networks Database. |
| * setnetgrent: (libc)Lookup Netgroup. |
| * setpayload: (libc)FP Bit Twiddling. |
| * setpayloadf: (libc)FP Bit Twiddling. |
| * setpayloadfN: (libc)FP Bit Twiddling. |
| * setpayloadfNx: (libc)FP Bit Twiddling. |
| * setpayloadl: (libc)FP Bit Twiddling. |
| * setpayloadsig: (libc)FP Bit Twiddling. |
| * setpayloadsigf: (libc)FP Bit Twiddling. |
| * setpayloadsigfN: (libc)FP Bit Twiddling. |
| * setpayloadsigfNx: (libc)FP Bit Twiddling. |
| * setpayloadsigl: (libc)FP Bit Twiddling. |
| * setpgid: (libc)Process Group Functions. |
| * setpgrp: (libc)Process Group Functions. |
| * setpriority: (libc)Traditional Scheduling Functions. |
| * setprotoent: (libc)Protocols Database. |
| * setpwent: (libc)Scanning All Users. |
| * setregid: (libc)Setting Groups. |
| * setreuid: (libc)Setting User ID. |
| * setrlimit64: (libc)Limits on Resources. |
| * setrlimit: (libc)Limits on Resources. |
| * setservent: (libc)Services Database. |
| * setsid: (libc)Process Group Functions. |
| * setsockopt: (libc)Socket Option Functions. |
| * setstate: (libc)BSD Random. |
| * setstate_r: (libc)BSD Random. |
| * settimeofday: (libc)High-Resolution Calendar. |
| * setuid: (libc)Setting User ID. |
| * setutent: (libc)Manipulating the Database. |
| * setutxent: (libc)XPG Functions. |
| * setvbuf: (libc)Controlling Buffering. |
| * shm_open: (libc)Memory-mapped I/O. |
| * shm_unlink: (libc)Memory-mapped I/O. |
| * shutdown: (libc)Closing a Socket. |
| * sigaction: (libc)Advanced Signal Handling. |
| * sigaddset: (libc)Signal Sets. |
| * sigaltstack: (libc)Signal Stack. |
| * sigblock: (libc)BSD Signal Handling. |
| * sigdelset: (libc)Signal Sets. |
| * sigemptyset: (libc)Signal Sets. |
| * sigfillset: (libc)Signal Sets. |
| * siginterrupt: (libc)BSD Signal Handling. |
| * sigismember: (libc)Signal Sets. |
| * siglongjmp: (libc)Non-Local Exits and Signals. |
| * sigmask: (libc)BSD Signal Handling. |
| * signal: (libc)Basic Signal Handling. |
| * signbit: (libc)FP Bit Twiddling. |
| * significand: (libc)Normalization Functions. |
| * significandf: (libc)Normalization Functions. |
| * significandl: (libc)Normalization Functions. |
| * sigpause: (libc)BSD Signal Handling. |
| * sigpending: (libc)Checking for Pending Signals. |
| * sigprocmask: (libc)Process Signal Mask. |
| * sigsetjmp: (libc)Non-Local Exits and Signals. |
| * sigsetmask: (libc)BSD Signal Handling. |
| * sigstack: (libc)Signal Stack. |
| * sigsuspend: (libc)Sigsuspend. |
| * sin: (libc)Trig Functions. |
| * sincos: (libc)Trig Functions. |
| * sincosf: (libc)Trig Functions. |
| * sincosfN: (libc)Trig Functions. |
| * sincosfNx: (libc)Trig Functions. |
| * sincosl: (libc)Trig Functions. |
| * sinf: (libc)Trig Functions. |
| * sinfN: (libc)Trig Functions. |
| * sinfNx: (libc)Trig Functions. |
| * sinh: (libc)Hyperbolic Functions. |
| * sinhf: (libc)Hyperbolic Functions. |
| * sinhfN: (libc)Hyperbolic Functions. |
| * sinhfNx: (libc)Hyperbolic Functions. |
| * sinhl: (libc)Hyperbolic Functions. |
| * sinl: (libc)Trig Functions. |
| * sleep: (libc)Sleeping. |
| * snprintf: (libc)Formatted Output Functions. |
| * socket: (libc)Creating a Socket. |
| * socketpair: (libc)Socket Pairs. |
| * sprintf: (libc)Formatted Output Functions. |
| * sqrt: (libc)Exponents and Logarithms. |
| * sqrtf: (libc)Exponents and Logarithms. |
| * sqrtfN: (libc)Exponents and Logarithms. |
| * sqrtfNx: (libc)Exponents and Logarithms. |
| * sqrtl: (libc)Exponents and Logarithms. |
| * srand48: (libc)SVID Random. |
| * srand48_r: (libc)SVID Random. |
| * srand: (libc)ISO Random. |
| * srandom: (libc)BSD Random. |
| * srandom_r: (libc)BSD Random. |
| * sscanf: (libc)Formatted Input Functions. |
| * ssignal: (libc)Basic Signal Handling. |
| * stat64: (libc)Reading Attributes. |
| * stat: (libc)Reading Attributes. |
| * stime: (libc)Simple Calendar Time. |
| * stpcpy: (libc)Copying Strings and Arrays. |
| * stpncpy: (libc)Truncating Strings. |
| * strcasecmp: (libc)String/Array Comparison. |
| * strcasestr: (libc)Search Functions. |
| * strcat: (libc)Concatenating Strings. |
| * strchr: (libc)Search Functions. |
| * strchrnul: (libc)Search Functions. |
| * strcmp: (libc)String/Array Comparison. |
| * strcoll: (libc)Collation Functions. |
| * strcpy: (libc)Copying Strings and Arrays. |
| * strcspn: (libc)Search Functions. |
| * strdup: (libc)Copying Strings and Arrays. |
| * strdupa: (libc)Copying Strings and Arrays. |
| * strerror: (libc)Error Messages. |
| * strerror_r: (libc)Error Messages. |
| * strfmon: (libc)Formatting Numbers. |
| * strfromd: (libc)Printing of Floats. |
| * strfromf: (libc)Printing of Floats. |
| * strfromfN: (libc)Printing of Floats. |
| * strfromfNx: (libc)Printing of Floats. |
| * strfroml: (libc)Printing of Floats. |
| * strfry: (libc)Shuffling Bytes. |
| * strftime: (libc)Formatting Calendar Time. |
| * strlen: (libc)String Length. |
| * strncasecmp: (libc)String/Array Comparison. |
| * strncat: (libc)Truncating Strings. |
| * strncmp: (libc)String/Array Comparison. |
| * strncpy: (libc)Truncating Strings. |
| * strndup: (libc)Truncating Strings. |
| * strndupa: (libc)Truncating Strings. |
| * strnlen: (libc)String Length. |
| * strpbrk: (libc)Search Functions. |
| * strptime: (libc)Low-Level Time String Parsing. |
| * strrchr: (libc)Search Functions. |
| * strsep: (libc)Finding Tokens in a String. |
| * strsignal: (libc)Signal Messages. |
| * strspn: (libc)Search Functions. |
| * strstr: (libc)Search Functions. |
| * strtod: (libc)Parsing of Floats. |
| * strtof: (libc)Parsing of Floats. |
| * strtofN: (libc)Parsing of Floats. |
| * strtofNx: (libc)Parsing of Floats. |
| * strtoimax: (libc)Parsing of Integers. |
| * strtok: (libc)Finding Tokens in a String. |
| * strtok_r: (libc)Finding Tokens in a String. |
| * strtol: (libc)Parsing of Integers. |
| * strtold: (libc)Parsing of Floats. |
| * strtoll: (libc)Parsing of Integers. |
| * strtoq: (libc)Parsing of Integers. |
| * strtoul: (libc)Parsing of Integers. |
| * strtoull: (libc)Parsing of Integers. |
| * strtoumax: (libc)Parsing of Integers. |
| * strtouq: (libc)Parsing of Integers. |
| * strverscmp: (libc)String/Array Comparison. |
| * strxfrm: (libc)Collation Functions. |
| * stty: (libc)BSD Terminal Modes. |
| * swapcontext: (libc)System V contexts. |
| * swprintf: (libc)Formatted Output Functions. |
| * swscanf: (libc)Formatted Input Functions. |
| * symlink: (libc)Symbolic Links. |
| * sync: (libc)Synchronizing I/O. |
| * syscall: (libc)System Calls. |
| * sysconf: (libc)Sysconf Definition. |
| * 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. |
| * tanfN: (libc)Trig Functions. |
| * tanfNx: (libc)Trig Functions. |
| * tanh: (libc)Hyperbolic Functions. |
| * tanhf: (libc)Hyperbolic Functions. |
| * tanhfN: (libc)Hyperbolic Functions. |
| * tanhfNx: (libc)Hyperbolic Functions. |
| * tanhl: (libc)Hyperbolic Functions. |
| * tanl: (libc)Trig Functions. |
| * tcdrain: (libc)Line Control. |
| * tcflow: (libc)Line Control. |
| * tcflush: (libc)Line Control. |
| * tcgetattr: (libc)Mode Functions. |
| * tcgetpgrp: (libc)Terminal Access Functions. |
| * tcgetsid: (libc)Terminal Access Functions. |
| * tcsendbreak: (libc)Line Control. |
| * tcsetattr: (libc)Mode Functions. |
| * tcsetpgrp: (libc)Terminal Access Functions. |
| * tdelete: (libc)Tree Search Function. |
| * tdestroy: (libc)Tree Search Function. |
| * telldir: (libc)Random Access Directory. |
| * tempnam: (libc)Temporary Files. |
| * textdomain: (libc)Locating gettext catalog. |
| * tfind: (libc)Tree Search Function. |
| * tgamma: (libc)Special Functions. |
| * tgammaf: (libc)Special Functions. |
| * tgammafN: (libc)Special Functions. |
| * tgammafNx: (libc)Special Functions. |
| * tgammal: (libc)Special Functions. |
| * tgkill: (libc)Signaling Another Process. |
| * thrd_create: (libc)ISO C Thread Management. |
| * thrd_current: (libc)ISO C Thread Management. |
| * thrd_detach: (libc)ISO C Thread Management. |
| * thrd_equal: (libc)ISO C Thread Management. |
| * thrd_exit: (libc)ISO C Thread Management. |
| * thrd_join: (libc)ISO C Thread Management. |
| * thrd_sleep: (libc)ISO C Thread Management. |
| * thrd_yield: (libc)ISO C Thread Management. |
| * time: (libc)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. |
| * totalorder: (libc)FP Comparison Functions. |
| * totalorderf: (libc)FP Comparison Functions. |
| * totalorderfN: (libc)FP Comparison Functions. |
| * totalorderfNx: (libc)FP Comparison Functions. |
| * totalorderl: (libc)FP Comparison Functions. |
| * totalordermag: (libc)FP Comparison Functions. |
| * totalordermagf: (libc)FP Comparison Functions. |
| * totalordermagfN: (libc)FP Comparison Functions. |
| * totalordermagfNx: (libc)FP Comparison Functions. |
| * totalordermagl: (libc)FP Comparison Functions. |
| * toupper: (libc)Case Conversion. |
| * towctrans: (libc)Wide Character Case Conversion. |
| * towlower: (libc)Wide Character Case Conversion. |
| * towupper: (libc)Wide Character Case Conversion. |
| * trunc: (libc)Rounding Functions. |
| * truncate64: (libc)File Size. |
| * truncate: (libc)File Size. |
| * truncf: (libc)Rounding Functions. |
| * truncfN: (libc)Rounding Functions. |
| * truncfNx: (libc)Rounding Functions. |
| * truncl: (libc)Rounding Functions. |
| * tsearch: (libc)Tree Search Function. |
| * tss_create: (libc)ISO C Thread-local Storage. |
| * tss_delete: (libc)ISO C Thread-local Storage. |
| * tss_get: (libc)ISO C Thread-local Storage. |
| * tss_set: (libc)ISO C Thread-local Storage. |
| * ttyname: (libc)Is It a Terminal. |
| * ttyname_r: (libc)Is It a Terminal. |
| * twalk: (libc)Tree Search Function. |
| * twalk_r: (libc)Tree Search Function. |
| * tzset: (libc)Time Zone Functions. |
| * ufromfp: (libc)Rounding Functions. |
| * ufromfpf: (libc)Rounding Functions. |
| * ufromfpfN: (libc)Rounding Functions. |
| * ufromfpfNx: (libc)Rounding Functions. |
| * ufromfpl: (libc)Rounding Functions. |
| * ufromfpx: (libc)Rounding Functions. |
| * ufromfpxf: (libc)Rounding Functions. |
| * ufromfpxfN: (libc)Rounding Functions. |
| * ufromfpxfNx: (libc)Rounding Functions. |
| * ufromfpxl: (libc)Rounding Functions. |
| * ulimit: (libc)Limits on Resources. |
| * umask: (libc)Setting Permissions. |
| * umount2: (libc)Mount-Unmount-Remount. |
| * umount: (libc)Mount-Unmount-Remount. |
| * uname: (libc)Platform Type. |
| * ungetc: (libc)How Unread. |
| * ungetwc: (libc)How Unread. |
| * unlink: (libc)Deleting Files. |
| * unlockpt: (libc)Allocation. |
| * unsetenv: (libc)Environment Access. |
| * updwtmp: (libc)Manipulating the Database. |
| * utime: (libc)File Times. |
| * utimes: (libc)File Times. |
| * utmpname: (libc)Manipulating the Database. |
| * utmpxname: (libc)XPG Functions. |
| * va_arg: (libc)Argument Macros. |
| * va_copy: (libc)Argument Macros. |
| * va_end: (libc)Argument Macros. |
| * va_start: (libc)Argument Macros. |
| * valloc: (libc)Aligned Memory Blocks. |
| * vasprintf: (libc)Variable Arguments Output. |
| * verr: (libc)Error Messages. |
| * verrx: (libc)Error Messages. |
| * versionsort64: (libc)Scanning Directory Content. |
| * versionsort: (libc)Scanning Directory Content. |
| * vfork: (libc)Creating a Process. |
| * vfprintf: (libc)Variable Arguments Output. |
| * vfscanf: (libc)Variable Arguments Input. |
| * vfwprintf: (libc)Variable Arguments Output. |
| * vfwscanf: (libc)Variable Arguments Input. |
| * vlimit: (libc)Limits on Resources. |
| * vprintf: (libc)Variable Arguments Output. |
| * vscanf: (libc)Variable Arguments Input. |
| * vsnprintf: (libc)Variable Arguments Output. |
| * vsprintf: (libc)Variable Arguments Output. |
| * vsscanf: (libc)Variable Arguments Input. |
| * vswprintf: (libc)Variable Arguments Output. |
| * vswscanf: (libc)Variable Arguments Input. |
| * vsyslog: (libc)syslog; vsyslog. |
| * vtimes: (libc)Resource Usage. |
| * vwarn: (libc)Error Messages. |
| * vwarnx: (libc)Error Messages. |
| * vwprintf: (libc)Variable Arguments Output. |
| * vwscanf: (libc)Variable Arguments Input. |
| * wait3: (libc)BSD Wait Functions. |
| * wait4: (libc)Process Completion. |
| * wait: (libc)Process Completion. |
| * waitpid: (libc)Process Completion. |
| * warn: (libc)Error Messages. |
| * warnx: (libc)Error Messages. |
| * wcpcpy: (libc)Copying Strings and Arrays. |
| * wcpncpy: (libc)Truncating Strings. |
| * wcrtomb: (libc)Converting a Character. |
| * wcscasecmp: (libc)String/Array Comparison. |
| * wcscat: (libc)Concatenating Strings. |
| * wcschr: (libc)Search Functions. |
| * wcschrnul: (libc)Search Functions. |
| * wcscmp: (libc)String/Array Comparison. |
| * wcscoll: (libc)Collation Functions. |
| * wcscpy: (libc)Copying Strings and Arrays. |
| * wcscspn: (libc)Search Functions. |
| * wcsdup: (libc)Copying Strings and Arrays. |
| * wcsftime: (libc)Formatting Calendar Time. |
| * wcslen: (libc)String Length. |
| * wcsncasecmp: (libc)String/Array Comparison. |
| * wcsncat: (libc)Truncating Strings. |
| * wcsncmp: (libc)String/Array Comparison. |
| * wcsncpy: (libc)Truncating Strings. |
| * wcsnlen: (libc)String Length. |
| * wcsnrtombs: (libc)Converting Strings. |
| * wcspbrk: (libc)Search Functions. |
| * wcsrchr: (libc)Search Functions. |
| * wcsrtombs: (libc)Converting Strings. |
| * wcsspn: (libc)Search Functions. |
| * wcsstr: (libc)Search Functions. |
| * wcstod: (libc)Parsing of Floats. |
| * wcstof: (libc)Parsing of Floats. |
| * wcstofN: (libc)Parsing of Floats. |
| * wcstofNx: (libc)Parsing of Floats. |
| * wcstoimax: (libc)Parsing of Integers. |
| * wcstok: (libc)Finding Tokens in a String. |
| * wcstol: (libc)Parsing of Integers. |
| * wcstold: (libc)Parsing of Floats. |
| * wcstoll: (libc)Parsing of Integers. |
| * wcstombs: (libc)Non-reentrant String Conversion. |
| * wcstoq: (libc)Parsing of Integers. |
| * wcstoul: (libc)Parsing of Integers. |
| * wcstoull: (libc)Parsing of Integers. |
| * wcstoumax: (libc)Parsing of Integers. |
| * wcstouq: (libc)Parsing of Integers. |
| * wcswcs: (libc)Search Functions. |
| * wcsxfrm: (libc)Collation Functions. |
| * wctob: (libc)Converting a Character. |
| * wctomb: (libc)Non-reentrant Character Conversion. |
| * wctrans: (libc)Wide Character Case Conversion. |
| * wctype: (libc)Classification of Wide Characters. |
| * wmemchr: (libc)Search Functions. |
| * wmemcmp: (libc)String/Array Comparison. |
| * wmemcpy: (libc)Copying Strings and Arrays. |
| * wmemmove: (libc)Copying Strings and Arrays. |
| * wmempcpy: (libc)Copying Strings and Arrays. |
| * wmemset: (libc)Copying Strings and Arrays. |
| * wordexp: (libc)Calling Wordexp. |
| * wordfree: (libc)Calling Wordexp. |
| * wprintf: (libc)Formatted Output Functions. |
| * write: (libc)I/O Primitives. |
| * writev: (libc)Scatter-Gather. |
| * wscanf: (libc)Formatted Input Functions. |
| * y0: (libc)Special Functions. |
| * y0f: (libc)Special Functions. |
| * y0fN: (libc)Special Functions. |
| * y0fNx: (libc)Special Functions. |
| * y0l: (libc)Special Functions. |
| * y1: (libc)Special Functions. |
| * y1f: (libc)Special Functions. |
| * y1fN: (libc)Special Functions. |
| * y1fNx: (libc)Special Functions. |
| * y1l: (libc)Special Functions. |
| * yn: (libc)Special Functions. |
| * ynf: (libc)Special Functions. |
| * ynfN: (libc)Special Functions. |
| * ynfNx: (libc)Special Functions. |
| * ynl: (libc)Special Functions. |
| END-INFO-DIR-ENTRY |
| |
| This file documents the GNU C Library. |
| |
| This is `The GNU C Library Reference Manual', for version 2.30 |
| (GNU Toolchain for the A-profile Architecture 9.2-2019.12 (arm-9.10)). |
| |
| Copyright (C) 1993-2019 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: Socket-Level Options, Prev: Socket Option Functions, Up: Socket Options |
| |
| 16.12.2 Socket-Level Options |
| ---------------------------- |
| |
| -- Constant: int SOL_SOCKET |
| Use this constant as the LEVEL argument to `getsockopt' or |
| `setsockopt' to manipulate the socket-level options described in |
| this section. |
| |
| Here is a table of socket-level option names; all are defined in the |
| header file `sys/socket.h'. |
| |
| `SO_DEBUG' |
| This option toggles recording of debugging information in the |
| underlying protocol modules. The value has type `int'; a nonzero |
| value means "yes". |
| |
| `SO_REUSEADDR' |
| This option controls whether `bind' (*note Setting Address::) |
| should permit reuse of local addresses for this socket. If you |
| enable this option, you can actually have two sockets with the |
| same Internet port number; but the system won't allow you to use |
| the two identically-named sockets in a way that would confuse the |
| Internet. The reason for this option is that some higher-level |
| Internet protocols, including FTP, require you to keep reusing the |
| same port number. |
| |
| The value has type `int'; a nonzero value means "yes". |
| |
| `SO_KEEPALIVE' |
| This option controls whether the underlying protocol should |
| periodically transmit messages on a connected socket. If the peer |
| fails to respond to these messages, the connection is considered |
| broken. The value has type `int'; a nonzero value means "yes". |
| |
| `SO_DONTROUTE' |
| This option controls whether outgoing messages bypass the normal |
| message routing facilities. If set, messages are sent directly to |
| the network interface instead. The value has type `int'; a nonzero |
| value means "yes". |
| |
| `SO_LINGER' |
| This option specifies what should happen when the socket of a type |
| that promises reliable delivery still has untransmitted messages |
| when it is closed; see *note Closing a Socket::. The value has |
| type `struct linger'. |
| |
| -- Data Type: struct linger |
| This structure type has the following members: |
| |
| `int l_onoff' |
| This field is interpreted as a boolean. If nonzero, |
| `close' blocks until the data are transmitted or the |
| timeout period has expired. |
| |
| `int l_linger' |
| This specifies the timeout period, in seconds. |
| |
| `SO_BROADCAST' |
| This option controls whether datagrams may be broadcast from the |
| socket. The value has type `int'; a nonzero value means "yes". |
| |
| `SO_OOBINLINE' |
| If this option is set, out-of-band data received on the socket is |
| placed in the normal input queue. This permits it to be read using |
| `read' or `recv' without specifying the `MSG_OOB' flag. *Note |
| Out-of-Band Data::. The value has type `int'; a nonzero value |
| means "yes". |
| |
| `SO_SNDBUF' |
| This option gets or sets the size of the output buffer. The value |
| is a `size_t', which is the size in bytes. |
| |
| `SO_RCVBUF' |
| This option gets or sets the size of the input buffer. The value |
| is a `size_t', which is the size in bytes. |
| |
| `SO_STYLE' |
| `SO_TYPE' |
| This option can be used with `getsockopt' only. It is used to get |
| the socket's communication style. `SO_TYPE' is the historical |
| name, and `SO_STYLE' is the preferred name in GNU. The value has |
| type `int' and its value designates a communication style; see |
| *note Communication Styles::. |
| |
| `SO_ERROR' |
| This option can be used with `getsockopt' only. It is used to |
| reset the error status of the socket. The value is an `int', |
| which represents the previous error status. |
| |
| |
| File: libc.info, Node: Networks Database, Prev: Socket Options, Up: Sockets |
| |
| 16.13 Networks Database |
| ======================= |
| |
| Many systems come with a database that records a list of networks known |
| to the system developer. This is usually kept either in the file |
| `/etc/networks' or in an equivalent from a name server. This data base |
| is useful for routing programs such as `route', but it is not useful |
| for programs that simply communicate over the network. We provide |
| functions to access this database, which are declared in `netdb.h'. |
| |
| -- Data Type: struct netent |
| This data type is used to represent information about entries in |
| the networks database. It has the following members: |
| |
| `char *n_name' |
| This is the "official" name of the network. |
| |
| `char **n_aliases' |
| These are alternative names for the network, represented as a |
| vector of strings. A null pointer terminates the array. |
| |
| `int n_addrtype' |
| This is the type of the network number; this is always equal |
| to `AF_INET' for Internet networks. |
| |
| `unsigned long int n_net' |
| This is the network number. Network numbers are returned in |
| host byte order; see *note Byte Order::. |
| |
| Use the `getnetbyname' or `getnetbyaddr' functions to search the |
| networks database for information about a specific network. The |
| information is returned in a statically-allocated structure; you must |
| copy the information if you need to save it. |
| |
| -- Function: struct netent * getnetbyname (const char *NAME) |
| Preliminary: | MT-Unsafe race:netbyname env locale | AS-Unsafe |
| dlopen plugin heap lock | AC-Unsafe corrupt lock fd mem | *Note |
| POSIX Safety Concepts::. |
| |
| The `getnetbyname' function returns information about the network |
| named NAME. It returns a null pointer if there is no such network. |
| |
| -- Function: struct netent * getnetbyaddr (uint32_t NET, int TYPE) |
| Preliminary: | MT-Unsafe race:netbyaddr locale | AS-Unsafe dlopen |
| plugin heap lock | AC-Unsafe corrupt lock fd mem | *Note POSIX |
| Safety Concepts::. |
| |
| The `getnetbyaddr' function returns information about the network |
| of type TYPE with number NET. You should specify a value of |
| `AF_INET' for the TYPE argument for Internet networks. |
| |
| `getnetbyaddr' returns a null pointer if there is no such network. |
| |
| You can also scan the networks database using `setnetent', |
| `getnetent' and `endnetent'. Be careful when using these functions |
| because they are not reentrant. |
| |
| -- Function: void setnetent (int STAYOPEN) |
| Preliminary: | MT-Unsafe race:netent env locale | AS-Unsafe dlopen |
| plugin heap lock | AC-Unsafe corrupt lock fd mem | *Note POSIX |
| Safety Concepts::. |
| |
| This function opens and rewinds the networks database. |
| |
| If the STAYOPEN argument is nonzero, this sets a flag so that |
| subsequent calls to `getnetbyname' or `getnetbyaddr' will not |
| close the database (as they usually would). This makes for more |
| efficiency if you call those functions several times, by avoiding |
| reopening the database for each call. |
| |
| -- Function: struct netent * getnetent (void) |
| Preliminary: | MT-Unsafe race:netent race:netentbuf env locale | |
| AS-Unsafe dlopen plugin heap lock | AC-Unsafe corrupt lock fd mem |
| | *Note POSIX Safety Concepts::. |
| |
| This function returns the next entry in the networks database. It |
| returns a null pointer if there are no more entries. |
| |
| -- Function: void endnetent (void) |
| Preliminary: | MT-Unsafe race:netent env locale | AS-Unsafe dlopen |
| plugin heap lock | AC-Unsafe corrupt lock fd mem | *Note POSIX |
| Safety Concepts::. |
| |
| This function closes the networks database. |
| |
| |
| File: libc.info, Node: Low-Level Terminal Interface, Next: Syslog, Prev: Sockets, Up: Top |
| |
| 17 Low-Level Terminal Interface |
| ******************************* |
| |
| This chapter describes functions that are specific to terminal devices. |
| You can use these functions to do things like turn off input echoing; |
| set serial line characteristics such as line speed and flow control; and |
| change which characters are used for end-of-file, command-line editing, |
| sending signals, and similar control functions. |
| |
| Most of the functions in this chapter operate on file descriptors. |
| *Note Low-Level I/O::, for more information about what a file |
| descriptor is and how to open a file descriptor for a terminal device. |
| |
| * Menu: |
| |
| * Is It a Terminal:: How to determine if a file is a terminal |
| device, and what its name is. |
| * I/O Queues:: About flow control and typeahead. |
| * Canonical or Not:: Two basic styles of input processing. |
| * Terminal Modes:: How to examine and modify flags controlling |
| details of terminal I/O: echoing, |
| signals, editing. Posix. |
| * BSD Terminal Modes:: BSD compatible terminal mode setting |
| * Line Control:: Sending break sequences, clearing |
| terminal buffers ... |
| * Noncanon Example:: How to read single characters without echo. |
| * getpass:: Prompting the user for a passphrase. |
| * Pseudo-Terminals:: How to open a pseudo-terminal. |
| |
| |
| File: libc.info, Node: Is It a Terminal, Next: I/O Queues, Up: Low-Level Terminal Interface |
| |
| 17.1 Identifying Terminals |
| ========================== |
| |
| The functions described in this chapter only work on files that |
| correspond to terminal devices. You can find out whether a file |
| descriptor is associated with a terminal by using the `isatty' function. |
| |
| Prototypes for the functions in this section are declared in the |
| header file `unistd.h'. |
| |
| -- Function: int isatty (int FILEDES) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This function returns `1' if FILEDES is a file descriptor |
| associated with an open terminal device, and 0 otherwise. |
| |
| If a file descriptor is associated with a terminal, you can get its |
| associated file name using the `ttyname' function. See also the |
| `ctermid' function, described in *note Identifying the Terminal::. |
| |
| -- Function: char * ttyname (int FILEDES) |
| Preliminary: | MT-Unsafe race:ttyname | AS-Unsafe heap lock | |
| AC-Unsafe lock fd mem | *Note POSIX Safety Concepts::. |
| |
| If the file descriptor FILEDES is associated with a terminal |
| device, the `ttyname' function returns a pointer to a |
| statically-allocated, null-terminated string containing the file |
| name of the terminal file. The value is a null pointer if the |
| file descriptor isn't associated with a terminal, or the file name |
| cannot be determined. |
| |
| -- Function: int ttyname_r (int FILEDES, char *BUF, size_t LEN) |
| Preliminary: | MT-Safe | AS-Unsafe heap | AC-Unsafe mem fd | *Note |
| POSIX Safety Concepts::. |
| |
| The `ttyname_r' function is similar to the `ttyname' function |
| except that it places its result into the user-specified buffer |
| starting at BUF with length LEN. |
| |
| The normal return value from `ttyname_r' is 0. Otherwise an error |
| number is returned to indicate the error. The following `errno' |
| error conditions are defined for this function: |
| |
| `EBADF' |
| The FILEDES argument is not a valid file descriptor. |
| |
| `ENOTTY' |
| The FILEDES is not associated with a terminal. |
| |
| `ERANGE' |
| The buffer length LEN is too small to store the string to be |
| returned. |
| |
| `ENODEV' |
| The FILEDES is associated with a terminal device that is a |
| slave pseudo-terminal, but the file name associated with that |
| device could not be determined. This is a GNU extension. |
| |
| |
| File: libc.info, Node: I/O Queues, Next: Canonical or Not, Prev: Is It a Terminal, Up: Low-Level Terminal Interface |
| |
| 17.2 I/O Queues |
| =============== |
| |
| Many of the remaining functions in this section refer to the input and |
| output queues of a terminal device. These queues implement a form of |
| buffering _within the kernel_ independent of the buffering implemented |
| by I/O streams (*note I/O on Streams::). |
| |
| The "terminal input queue" is also sometimes referred to as its |
| "typeahead buffer". It holds the characters that have been received |
| from the terminal but not yet read by any process. |
| |
| The size of the input queue is described by the `MAX_INPUT' and |
| `_POSIX_MAX_INPUT' parameters; see *note Limits for Files::. You are |
| guaranteed a queue size of at least `MAX_INPUT', but the queue might be |
| larger, and might even dynamically change size. If input flow control |
| is enabled by setting the `IXOFF' input mode bit (*note Input Modes::), |
| the terminal driver transmits STOP and START characters to the terminal |
| when necessary to prevent the queue from overflowing. Otherwise, input |
| may be lost if it comes in too fast from the terminal. In canonical |
| mode, all input stays in the queue until a newline character is |
| received, so the terminal input queue can fill up when you type a very |
| long line. *Note Canonical or Not::. |
| |
| The "terminal output queue" is like the input queue, but for output; |
| it contains characters that have been written by processes, but not yet |
| transmitted to the terminal. If output flow control is enabled by |
| setting the `IXON' input mode bit (*note Input Modes::), the terminal |
| driver obeys START and STOP characters sent by the terminal to stop and |
| restart transmission of output. |
| |
| "Clearing" the terminal input queue means discarding any characters |
| that have been received but not yet read. Similarly, clearing the |
| terminal output queue means discarding any characters that have been |
| written but not yet transmitted. |
| |
| |
| File: libc.info, Node: Canonical or Not, Next: Terminal Modes, Prev: I/O Queues, Up: Low-Level Terminal Interface |
| |
| 17.3 Two Styles of Input: Canonical or Not |
| ========================================== |
| |
| POSIX systems support two basic modes of input: canonical and |
| noncanonical. |
| |
| In "canonical input processing" mode, terminal input is processed in |
| lines terminated by newline (`'\n''), EOF, or EOL characters. No input |
| can be read until an entire line has been typed by the user, and the |
| `read' function (*note I/O Primitives::) returns at most a single line |
| of input, no matter how many bytes are requested. |
| |
| In canonical input mode, the operating system provides input editing |
| facilities: some characters are interpreted specially to perform editing |
| operations within the current line of text, such as ERASE and KILL. |
| *Note Editing Characters::. |
| |
| The constants `_POSIX_MAX_CANON' and `MAX_CANON' parameterize the |
| maximum number of bytes which may appear in a single line of canonical |
| input. *Note Limits for Files::. You are guaranteed a maximum line |
| length of at least `MAX_CANON' bytes, but the maximum might be larger, |
| and might even dynamically change size. |
| |
| In "noncanonical input processing" mode, characters are not grouped |
| into lines, and ERASE and KILL processing is not performed. The |
| granularity with which bytes are read in noncanonical input mode is |
| controlled by the MIN and TIME settings. *Note Noncanonical Input::. |
| |
| Most programs use canonical input mode, because this gives the user a |
| way to edit input line by line. The usual reason to use noncanonical |
| mode is when the program accepts single-character commands or provides |
| its own editing facilities. |
| |
| The choice of canonical or noncanonical input is controlled by the |
| `ICANON' flag in the `c_lflag' member of `struct termios'. *Note Local |
| Modes::. |
| |
| |
| File: libc.info, Node: Terminal Modes, Next: BSD Terminal Modes, Prev: Canonical or Not, Up: Low-Level Terminal Interface |
| |
| 17.4 Terminal Modes |
| =================== |
| |
| This section describes the various terminal attributes that control how |
| input and output are done. The functions, data structures, and symbolic |
| constants are all declared in the header file `termios.h'. |
| |
| Don't confuse terminal attributes with file attributes. A device |
| special file which is associated with a terminal has file attributes as |
| described in *note File Attributes::. These are unrelated to the |
| attributes of the terminal device itself, which are discussed in this |
| section. |
| |
| * Menu: |
| |
| * Mode Data Types:: The data type `struct termios' and |
| related types. |
| * Mode Functions:: Functions to read and set the terminal |
| attributes. |
| * Setting Modes:: The right way to set terminal attributes |
| reliably. |
| * Input Modes:: Flags controlling low-level input handling. |
| * Output Modes:: Flags controlling low-level output handling. |
| * Control Modes:: Flags controlling serial port behavior. |
| * Local Modes:: Flags controlling high-level input handling. |
| * Line Speed:: How to read and set the terminal line speed. |
| * Special Characters:: Characters that have special effects, |
| and how to change them. |
| * Noncanonical Input:: Controlling how long to wait for input. |
| |
| |
| File: libc.info, Node: Mode Data Types, Next: Mode Functions, Up: Terminal Modes |
| |
| 17.4.1 Terminal Mode Data Types |
| ------------------------------- |
| |
| The entire collection of attributes of a terminal is stored in a |
| structure of type `struct termios'. This structure is used with the |
| functions `tcgetattr' and `tcsetattr' to read and set the attributes. |
| |
| -- Data Type: struct termios |
| A `struct termios' records all the I/O attributes of a terminal. |
| The structure includes at least the following members: |
| |
| `tcflag_t c_iflag' |
| A bit mask specifying flags for input modes; see *note Input |
| Modes::. |
| |
| `tcflag_t c_oflag' |
| A bit mask specifying flags for output modes; see *note |
| Output Modes::. |
| |
| `tcflag_t c_cflag' |
| A bit mask specifying flags for control modes; see *note |
| Control Modes::. |
| |
| `tcflag_t c_lflag' |
| A bit mask specifying flags for local modes; see *note Local |
| Modes::. |
| |
| `cc_t c_cc[NCCS]' |
| An array specifying which characters are associated with |
| various control functions; see *note Special Characters::. |
| |
| The `struct termios' structure also contains members which encode |
| input and output transmission speeds, but the representation is |
| not specified. *Note Line Speed::, for how to examine and store |
| the speed values. |
| |
| The following sections describe the details of the members of the |
| `struct termios' structure. |
| |
| -- Data Type: tcflag_t |
| This is an unsigned integer type used to represent the various bit |
| masks for terminal flags. |
| |
| -- Data Type: cc_t |
| This is an unsigned integer type used to represent characters |
| associated with various terminal control functions. |
| |
| -- Macro: int NCCS |
| The value of this macro is the number of elements in the `c_cc' |
| array. |
| |
| |
| File: libc.info, Node: Mode Functions, Next: Setting Modes, Prev: Mode Data Types, Up: Terminal Modes |
| |
| 17.4.2 Terminal Mode Functions |
| ------------------------------ |
| |
| -- Function: int tcgetattr (int FILEDES, struct termios *TERMIOS-P) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This function is used to examine the attributes of the terminal |
| device with file descriptor FILEDES. The attributes are returned |
| in the structure that TERMIOS-P points to. |
| |
| If successful, `tcgetattr' returns 0. A return value of -1 |
| indicates an error. The following `errno' error conditions are |
| defined for this function: |
| |
| `EBADF' |
| The FILEDES argument is not a valid file descriptor. |
| |
| `ENOTTY' |
| The FILEDES is not associated with a terminal. |
| |
| -- Function: int tcsetattr (int FILEDES, int WHEN, const struct |
| termios *TERMIOS-P) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This function sets the attributes of the terminal device with file |
| descriptor FILEDES. The new attributes are taken from the |
| structure that TERMIOS-P points to. |
| |
| The WHEN argument specifies how to deal with input and output |
| already queued. It can be one of the following values: |
| |
| `TCSANOW' |
| Make the change immediately. |
| |
| `TCSADRAIN' |
| Make the change after waiting until all queued output has |
| been written. You should usually use this option when |
| changing parameters that affect output. |
| |
| `TCSAFLUSH' |
| This is like `TCSADRAIN', but also discards any queued input. |
| |
| `TCSASOFT' |
| This is a flag bit that you can add to any of the above |
| alternatives. Its meaning is to inhibit alteration of the |
| state of the terminal hardware. It is a BSD extension; it is |
| only supported on BSD systems and GNU/Hurd systems. |
| |
| Using `TCSASOFT' is exactly the same as setting the `CIGNORE' |
| bit in the `c_cflag' member of the structure TERMIOS-P points |
| to. *Note Control Modes::, for a description of `CIGNORE'. |
| |
| If this function is called from a background process on its |
| controlling terminal, normally all processes in the process group |
| are sent a `SIGTTOU' signal, in the same way as if the process |
| were trying to write to the terminal. The exception is if the |
| calling process itself is ignoring or blocking `SIGTTOU' signals, |
| in which case the operation is performed and no signal is sent. |
| *Note Job Control::. |
| |
| If successful, `tcsetattr' returns 0. A return value of -1 |
| indicates an error. The following `errno' error conditions are |
| defined for this function: |
| |
| `EBADF' |
| The FILEDES argument is not a valid file descriptor. |
| |
| `ENOTTY' |
| The FILEDES is not associated with a terminal. |
| |
| `EINVAL' |
| Either the value of the `when' argument is not valid, or |
| there is something wrong with the data in the TERMIOS-P |
| argument. |
| |
| Although `tcgetattr' and `tcsetattr' specify the terminal device with a |
| file descriptor, the attributes are those of the terminal device itself |
| and not of the file descriptor. This means that the effects of |
| changing terminal attributes are persistent; if another process opens |
| the terminal file later on, it will see the changed attributes even |
| though it doesn't have anything to do with the open file descriptor you |
| originally specified in changing the attributes. |
| |
| Similarly, if a single process has multiple or duplicated file |
| descriptors for the same terminal device, changing the terminal |
| attributes affects input and output to all of these file descriptors. |
| This means, for example, that you can't open one file descriptor or |
| stream to read from a terminal in the normal line-buffered, echoed |
| mode; and simultaneously have another file descriptor for the same |
| terminal that you use to read from it in single-character, non-echoed |
| mode. Instead, you have to explicitly switch the terminal back and |
| forth between the two modes. |
| |
| |
| File: libc.info, Node: Setting Modes, Next: Input Modes, Prev: Mode Functions, Up: Terminal Modes |
| |
| 17.4.3 Setting Terminal Modes Properly |
| -------------------------------------- |
| |
| When you set terminal modes, you should call `tcgetattr' first to get |
| the current modes of the particular terminal device, modify only those |
| modes that you are really interested in, and store the result with |
| `tcsetattr'. |
| |
| It's a bad idea to simply initialize a `struct termios' structure to |
| a chosen set of attributes and pass it directly to `tcsetattr'. Your |
| program may be run years from now, on systems that support members not |
| documented in this manual. The way to avoid setting these members to |
| unreasonable values is to avoid changing them. |
| |
| What's more, different terminal devices may require different mode |
| settings in order to function properly. So you should avoid blindly |
| copying attributes from one terminal device to another. |
| |
| When a member contains a collection of independent flags, as the |
| `c_iflag', `c_oflag' and `c_cflag' members do, even setting the entire |
| member is a bad idea, because particular operating systems have their |
| own flags. Instead, you should start with the current value of the |
| member and alter only the flags whose values matter in your program, |
| leaving any other flags unchanged. |
| |
| Here is an example of how to set one flag (`ISTRIP') in the `struct |
| termios' structure while properly preserving all the other data in the |
| structure: |
| |
| int |
| set_istrip (int desc, int value) |
| { |
| struct termios settings; |
| int result; |
| |
| result = tcgetattr (desc, &settings); |
| if (result < 0) |
| { |
| perror ("error in tcgetattr"); |
| return 0; |
| } |
| settings.c_iflag &= ~ISTRIP; |
| if (value) |
| settings.c_iflag |= ISTRIP; |
| result = tcsetattr (desc, TCSANOW, &settings); |
| if (result < 0) |
| { |
| perror ("error in tcsetattr"); |
| return 0; |
| } |
| return 1; |
| } |
| |
| |
| File: libc.info, Node: Input Modes, Next: Output Modes, Prev: Setting Modes, Up: Terminal Modes |
| |
| 17.4.4 Input Modes |
| ------------------ |
| |
| This section describes the terminal attribute flags that control fairly |
| low-level aspects of input processing: handling of parity errors, break |
| signals, flow control, and <RET> and <LFD> characters. |
| |
| All of these flags are bits in the `c_iflag' member of the `struct |
| termios' structure. The member is an integer, and you change flags |
| using the operators `&', `|' and `^'. Don't try to specify the entire |
| value for `c_iflag'--instead, change only specific flags and leave the |
| rest untouched (*note Setting Modes::). |
| |
| -- Macro: tcflag_t INPCK |
| If this bit is set, input parity checking is enabled. If it is |
| not set, no checking at all is done for parity errors on input; the |
| characters are simply passed through to the application. |
| |
| Parity checking on input processing is independent of whether |
| parity detection and generation on the underlying terminal |
| hardware is enabled; see *note Control Modes::. For example, you |
| could clear the `INPCK' input mode flag and set the `PARENB' |
| control mode flag to ignore parity errors on input, but still |
| generate parity on output. |
| |
| If this bit is set, what happens when a parity error is detected |
| depends on whether the `IGNPAR' or `PARMRK' bits are set. If |
| neither of these bits are set, a byte with a parity error is |
| passed to the application as a `'\0'' character. |
| |
| -- Macro: tcflag_t IGNPAR |
| If this bit is set, any byte with a framing or parity error is |
| ignored. This is only useful if `INPCK' is also set. |
| |
| -- Macro: tcflag_t PARMRK |
| If this bit is set, input bytes with parity or framing errors are |
| marked when passed to the program. This bit is meaningful only |
| when `INPCK' is set and `IGNPAR' is not set. |
| |
| The way erroneous bytes are marked is with two preceding bytes, |
| `377' and `0'. Thus, the program actually reads three bytes for |
| one erroneous byte received from the terminal. |
| |
| If a valid byte has the value `0377', and `ISTRIP' (see below) is |
| not set, the program might confuse it with the prefix that marks a |
| parity error. So a valid byte `0377' is passed to the program as |
| two bytes, `0377' `0377', in this case. |
| |
| -- Macro: tcflag_t ISTRIP |
| If this bit is set, valid input bytes are stripped to seven bits; |
| otherwise, all eight bits are available for programs to read. |
| |
| -- Macro: tcflag_t IGNBRK |
| If this bit is set, break conditions are ignored. |
| |
| A "break condition" is defined in the context of asynchronous |
| serial data transmission as a series of zero-value bits longer |
| than a single byte. |
| |
| -- Macro: tcflag_t BRKINT |
| If this bit is set and `IGNBRK' is not set, a break condition |
| clears the terminal input and output queues and raises a `SIGINT' |
| signal for the foreground process group associated with the |
| terminal. |
| |
| If neither `BRKINT' nor `IGNBRK' are set, a break condition is |
| passed to the application as a single `'\0'' character if `PARMRK' |
| is not set, or otherwise as a three-character sequence `'\377'', |
| `'\0'', `'\0''. |
| |
| -- Macro: tcflag_t IGNCR |
| If this bit is set, carriage return characters (`'\r'') are |
| discarded on input. Discarding carriage return may be useful on |
| terminals that send both carriage return and linefeed when you |
| type the <RET> key. |
| |
| -- Macro: tcflag_t ICRNL |
| If this bit is set and `IGNCR' is not set, carriage return |
| characters (`'\r'') received as input are passed to the |
| application as newline characters (`'\n''). |
| |
| -- Macro: tcflag_t INLCR |
| If this bit is set, newline characters (`'\n'') received as input |
| are passed to the application as carriage return characters |
| (`'\r''). |
| |
| -- Macro: tcflag_t IXOFF |
| If this bit is set, start/stop control on input is enabled. In |
| other words, the computer sends STOP and START characters as |
| necessary to prevent input from coming in faster than programs are |
| reading it. The idea is that the actual terminal hardware that is |
| generating the input data responds to a STOP character by |
| suspending transmission, and to a START character by resuming |
| transmission. *Note Start/Stop Characters::. |
| |
| -- Macro: tcflag_t IXON |
| If this bit is set, start/stop control on output is enabled. In |
| other words, if the computer receives a STOP character, it |
| suspends output until a START character is received. In this |
| case, the STOP and START characters are never passed to the |
| application program. If this bit is not set, then START and STOP |
| can be read as ordinary characters. *Note Start/Stop Characters::. |
| |
| -- Macro: tcflag_t IXANY |
| If this bit is set, any input character restarts output when |
| output has been suspended with the STOP character. Otherwise, |
| only the START character restarts output. |
| |
| This is a BSD extension; it exists only on BSD systems and |
| GNU/Linux and GNU/Hurd systems. |
| |
| -- Macro: tcflag_t IMAXBEL |
| If this bit is set, then filling up the terminal input buffer |
| sends a BEL character (code `007') to the terminal to ring the |
| bell. |
| |
| This is a BSD extension. |
| |
| |
| File: libc.info, Node: Output Modes, Next: Control Modes, Prev: Input Modes, Up: Terminal Modes |
| |
| 17.4.5 Output Modes |
| ------------------- |
| |
| This section describes the terminal flags and fields that control how |
| output characters are translated and padded for display. All of these |
| are contained in the `c_oflag' member of the `struct termios' structure. |
| |
| The `c_oflag' member itself is an integer, and you change the flags |
| and fields using the operators `&', `|', and `^'. Don't try to specify |
| the entire value for `c_oflag'--instead, change only specific flags and |
| leave the rest untouched (*note Setting Modes::). |
| |
| -- Macro: tcflag_t OPOST |
| If this bit is set, output data is processed in some unspecified |
| way so that it is displayed appropriately on the terminal device. |
| This typically includes mapping newline characters (`'\n'') onto |
| carriage return and linefeed pairs. |
| |
| If this bit isn't set, the characters are transmitted as-is. |
| |
| The following three bits are effective only if `OPOST' is set. |
| |
| -- Macro: tcflag_t ONLCR |
| If this bit is set, convert the newline character on output into a |
| pair of characters, carriage return followed by linefeed. |
| |
| -- Macro: tcflag_t OXTABS |
| If this bit is set, convert tab characters on output into the |
| appropriate number of spaces to emulate a tab stop every eight |
| columns. This bit exists only on BSD systems and GNU/Hurd |
| systems; on GNU/Linux systems it is available as `XTABS'. |
| |
| -- Macro: tcflag_t ONOEOT |
| If this bit is set, discard `C-d' characters (code `004') on |
| output. These characters cause many dial-up terminals to |
| disconnect. This bit exists only on BSD systems and GNU/Hurd |
| systems. |
| |
| |
| File: libc.info, Node: Control Modes, Next: Local Modes, Prev: Output Modes, Up: Terminal Modes |
| |
| 17.4.6 Control Modes |
| -------------------- |
| |
| This section describes the terminal flags and fields that control |
| parameters usually associated with asynchronous serial data |
| transmission. These flags may not make sense for other kinds of |
| terminal ports (such as a network connection pseudo-terminal). All of |
| these are contained in the `c_cflag' member of the `struct termios' |
| structure. |
| |
| The `c_cflag' member itself is an integer, and you change the flags |
| and fields using the operators `&', `|', and `^'. Don't try to specify |
| the entire value for `c_cflag'--instead, change only specific flags and |
| leave the rest untouched (*note Setting Modes::). |
| |
| -- Macro: tcflag_t CLOCAL |
| If this bit is set, it indicates that the terminal is connected |
| "locally" and that the modem status lines (such as carrier detect) |
| should be ignored. |
| |
| On many systems if this bit is not set and you call `open' without |
| the `O_NONBLOCK' flag set, `open' blocks until a modem connection |
| is established. |
| |
| If this bit is not set and a modem disconnect is detected, a |
| `SIGHUP' signal is sent to the controlling process group for the |
| terminal (if it has one). Normally, this causes the process to |
| exit; see *note Signal Handling::. Reading from the terminal |
| after a disconnect causes an end-of-file condition, and writing |
| causes an `EIO' error to be returned. The terminal device must be |
| closed and reopened to clear the condition. |
| |
| -- Macro: tcflag_t HUPCL |
| If this bit is set, a modem disconnect is generated when all |
| processes that have the terminal device open have either closed |
| the file or exited. |
| |
| -- Macro: tcflag_t CREAD |
| If this bit is set, input can be read from the terminal. |
| Otherwise, input is discarded when it arrives. |
| |
| -- Macro: tcflag_t CSTOPB |
| If this bit is set, two stop bits are used. Otherwise, only one |
| stop bit is used. |
| |
| -- Macro: tcflag_t PARENB |
| If this bit is set, generation and detection of a parity bit are |
| enabled. *Note Input Modes::, for information on how input parity |
| errors are handled. |
| |
| If this bit is not set, no parity bit is added to output |
| characters, and input characters are not checked for correct |
| parity. |
| |
| -- Macro: tcflag_t PARODD |
| This bit is only useful if `PARENB' is set. If `PARODD' is set, |
| odd parity is used, otherwise even parity is used. |
| |
| The control mode flags also includes a field for the number of bits |
| per character. You can use the `CSIZE' macro as a mask to extract the |
| value, like this: `settings.c_cflag & CSIZE'. |
| |
| -- Macro: tcflag_t CSIZE |
| This is a mask for the number of bits per character. |
| |
| -- Macro: tcflag_t CS5 |
| This specifies five bits per byte. |
| |
| -- Macro: tcflag_t CS6 |
| This specifies six bits per byte. |
| |
| -- Macro: tcflag_t CS7 |
| This specifies seven bits per byte. |
| |
| -- Macro: tcflag_t CS8 |
| This specifies eight bits per byte. |
| |
| The following four bits are BSD extensions; these exist only on BSD |
| systems and GNU/Hurd systems. |
| |
| -- Macro: tcflag_t CCTS_OFLOW |
| If this bit is set, enable flow control of output based on the CTS |
| wire (RS232 protocol). |
| |
| -- Macro: tcflag_t CRTS_IFLOW |
| If this bit is set, enable flow control of input based on the RTS |
| wire (RS232 protocol). |
| |
| -- Macro: tcflag_t MDMBUF |
| If this bit is set, enable carrier-based flow control of output. |
| |
| -- Macro: tcflag_t CIGNORE |
| If this bit is set, it says to ignore the control modes and line |
| speed values entirely. This is only meaningful in a call to |
| `tcsetattr'. |
| |
| The `c_cflag' member and the line speed values returned by |
| `cfgetispeed' and `cfgetospeed' will be unaffected by the call. |
| `CIGNORE' is useful if you want to set all the software modes in |
| the other members, but leave the hardware details in `c_cflag' |
| unchanged. (This is how the `TCSASOFT' flag to `tcsettattr' |
| works.) |
| |
| This bit is never set in the structure filled in by `tcgetattr'. |
| |
| |
| File: libc.info, Node: Local Modes, Next: Line Speed, Prev: Control Modes, Up: Terminal Modes |
| |
| 17.4.7 Local Modes |
| ------------------ |
| |
| This section describes the flags for the `c_lflag' member of the |
| `struct termios' structure. These flags generally control higher-level |
| aspects of input processing than the input modes flags described in |
| *note Input Modes::, such as echoing, signals, and the choice of |
| canonical or noncanonical input. |
| |
| The `c_lflag' member itself is an integer, and you change the flags |
| and fields using the operators `&', `|', and `^'. Don't try to specify |
| the entire value for `c_lflag'--instead, change only specific flags and |
| leave the rest untouched (*note Setting Modes::). |
| |
| -- Macro: tcflag_t ICANON |
| This bit, if set, enables canonical input processing mode. |
| Otherwise, input is processed in noncanonical mode. *Note |
| Canonical or Not::. |
| |
| -- Macro: tcflag_t ECHO |
| If this bit is set, echoing of input characters back to the |
| terminal is enabled. |
| |
| -- Macro: tcflag_t ECHOE |
| If this bit is set, echoing indicates erasure of input with the |
| ERASE character by erasing the last character in the current line |
| from the screen. Otherwise, the character erased is re-echoed to |
| show what has happened (suitable for a printing terminal). |
| |
| This bit only controls the display behavior; the `ICANON' bit by |
| itself controls actual recognition of the ERASE character and |
| erasure of input, without which `ECHOE' is simply irrelevant. |
| |
| -- Macro: tcflag_t ECHOPRT |
| This bit, like `ECHOE', enables display of the ERASE character in |
| a way that is geared to a hardcopy terminal. When you type the |
| ERASE character, a `\' character is printed followed by the first |
| character erased. Typing the ERASE character again just prints |
| the next character erased. Then, the next time you type a normal |
| character, a `/' character is printed before the character echoes. |
| |
| This is a BSD extension, and exists only in BSD systems and |
| GNU/Linux and GNU/Hurd systems. |
| |
| -- Macro: tcflag_t ECHOK |
| This bit enables special display of the KILL character by moving |
| to a new line after echoing the KILL character normally. The |
| behavior of `ECHOKE' (below) is nicer to look at. |
| |
| If this bit is not set, the KILL character echoes just as it would |
| if it were not the KILL character. Then it is up to the user to |
| remember that the KILL character has erased the preceding input; |
| there is no indication of this on the screen. |
| |
| This bit only controls the display behavior; the `ICANON' bit by |
| itself controls actual recognition of the KILL character and |
| erasure of input, without which `ECHOK' is simply irrelevant. |
| |
| -- Macro: tcflag_t ECHOKE |
| This bit is similar to `ECHOK'. It enables special display of the |
| KILL character by erasing on the screen the entire line that has |
| been killed. This is a BSD extension, and exists only in BSD |
| systems and GNU/Linux and GNU/Hurd systems. |
| |
| -- Macro: tcflag_t ECHONL |
| If this bit is set and the `ICANON' bit is also set, then the |
| newline (`'\n'') character is echoed even if the `ECHO' bit is not |
| set. |
| |
| -- Macro: tcflag_t ECHOCTL |
| If this bit is set and the `ECHO' bit is also set, echo control |
| characters with `^' followed by the corresponding text character. |
| Thus, control-A echoes as `^A'. This is usually the preferred mode |
| for interactive input, because echoing a control character back to |
| the terminal could have some undesired effect on the terminal. |
| |
| This is a BSD extension, and exists only in BSD systems and |
| GNU/Linux and GNU/Hurd systems. |
| |
| -- Macro: tcflag_t ISIG |
| This bit controls whether the INTR, QUIT, and SUSP characters are |
| recognized. The functions associated with these characters are |
| performed if and only if this bit is set. Being in canonical or |
| noncanonical input mode has no effect on the interpretation of |
| these characters. |
| |
| You should use caution when disabling recognition of these |
| characters. Programs that cannot be interrupted interactively are |
| very user-unfriendly. If you clear this bit, your program should |
| provide some alternate interface that allows the user to |
| interactively send the signals associated with these characters, |
| or to escape from the program. |
| |
| *Note Signal Characters::. |
| |
| -- Macro: tcflag_t IEXTEN |
| POSIX.1 gives `IEXTEN' implementation-defined meaning, so you |
| cannot rely on this interpretation on all systems. |
| |
| On BSD systems and GNU/Linux and GNU/Hurd systems, it enables the |
| LNEXT and DISCARD characters. *Note Other Special::. |
| |
| -- Macro: tcflag_t NOFLSH |
| Normally, the INTR, QUIT, and SUSP characters cause input and |
| output queues for the terminal to be cleared. If this bit is set, |
| the queues are not cleared. |
| |
| -- Macro: tcflag_t TOSTOP |
| If this bit is set and the system supports job control, then |
| `SIGTTOU' signals are generated by background processes that |
| attempt to write to the terminal. *Note Access to the Terminal::. |
| |
| The following bits are BSD extensions; they exist only on BSD systems |
| and GNU/Hurd systems. |
| |
| -- Macro: tcflag_t ALTWERASE |
| This bit determines how far the WERASE character should erase. The |
| WERASE character erases back to the beginning of a word; the |
| question is, where do words begin? |
| |
| If this bit is clear, then the beginning of a word is a |
| nonwhitespace character following a whitespace character. If the |
| bit is set, then the beginning of a word is an alphanumeric |
| character or underscore following a character which is none of |
| those. |
| |
| *Note Editing Characters::, for more information about the WERASE |
| character. |
| |
| -- Macro: tcflag_t FLUSHO |
| This is the bit that toggles when the user types the DISCARD |
| character. While this bit is set, all output is discarded. *Note |
| Other Special::. |
| |
| -- Macro: tcflag_t NOKERNINFO |
| Setting this bit disables handling of the STATUS character. *Note |
| Other Special::. |
| |
| -- Macro: tcflag_t PENDIN |
| If this bit is set, it indicates that there is a line of input that |
| needs to be reprinted. Typing the REPRINT character sets this |
| bit; the bit remains set until reprinting is finished. *Note |
| Editing Characters::. |
| |
| |
| File: libc.info, Node: Line Speed, Next: Special Characters, Prev: Local Modes, Up: Terminal Modes |
| |
| 17.4.8 Line Speed |
| ----------------- |
| |
| The terminal line speed tells the computer how fast to read and write |
| data on the terminal. |
| |
| If the terminal is connected to a real serial line, the terminal |
| speed you specify actually controls the line--if it doesn't match the |
| terminal's own idea of the speed, communication does not work. Real |
| serial ports accept only certain standard speeds. Also, particular |
| hardware may not support even all the standard speeds. Specifying a |
| speed of zero hangs up a dialup connection and turns off modem control |
| signals. |
| |
| If the terminal is not a real serial line (for example, if it is a |
| network connection), then the line speed won't really affect data |
| transmission speed, but some programs will use it to determine the |
| amount of padding needed. It's best to specify a line speed value that |
| matches the actual speed of the actual terminal, but you can safely |
| experiment with different values to vary the amount of padding. |
| |
| There are actually two line speeds for each terminal, one for input |
| and one for output. You can set them independently, but most often |
| terminals use the same speed for both directions. |
| |
| The speed values are stored in the `struct termios' structure, but |
| don't try to access them in the `struct termios' structure directly. |
| Instead, you should use the following functions to read and store them: |
| |
| -- Function: speed_t cfgetospeed (const struct termios *TERMIOS-P) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This function returns the output line speed stored in the structure |
| `*TERMIOS-P'. |
| |
| -- Function: speed_t cfgetispeed (const struct termios *TERMIOS-P) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This function returns the input line speed stored in the structure |
| `*TERMIOS-P'. |
| |
| -- Function: int cfsetospeed (struct termios *TERMIOS-P, speed_t SPEED) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This function stores SPEED in `*TERMIOS-P' as the output speed. |
| The normal return value is 0; a value of -1 indicates an error. |
| If SPEED is not a speed, `cfsetospeed' returns -1. |
| |
| -- Function: int cfsetispeed (struct termios *TERMIOS-P, speed_t SPEED) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This function stores SPEED in `*TERMIOS-P' as the input speed. |
| The normal return value is 0; a value of -1 indicates an error. |
| If SPEED is not a speed, `cfsetospeed' returns -1. |
| |
| -- Function: int cfsetspeed (struct termios *TERMIOS-P, speed_t SPEED) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This function stores SPEED in `*TERMIOS-P' as both the input and |
| output speeds. The normal return value is 0; a value of -1 |
| indicates an error. If SPEED is not a speed, `cfsetspeed' returns |
| -1. This function is an extension in 4.4 BSD. |
| |
| -- Data Type: speed_t |
| The `speed_t' type is an unsigned integer data type used to |
| represent line speeds. |
| |
| The functions `cfsetospeed' and `cfsetispeed' report errors only for |
| speed values that the system simply cannot handle. If you specify a |
| speed value that is basically acceptable, then those functions will |
| succeed. But they do not check that a particular hardware device can |
| actually support the specified speeds--in fact, they don't know which |
| device you plan to set the speed for. If you use `tcsetattr' to set |
| the speed of a particular device to a value that it cannot handle, |
| `tcsetattr' returns -1. |
| |
| *Portability note:* In the GNU C Library, the functions above accept |
| speeds measured in bits per second as input, and return speed values |
| measured in bits per second. Other libraries require speeds to be |
| indicated by special codes. For POSIX.1 portability, you must use one |
| of the following symbols to represent the speed; their precise numeric |
| values are system-dependent, but each name has a fixed meaning: `B110' |
| stands for 110 bps, `B300' for 300 bps, and so on. There is no |
| portable way to represent any speed but these, but these are the only |
| speeds that typical serial lines can support. |
| |
| B0 B50 B75 B110 B134 B150 B200 |
| B300 B600 B1200 B1800 B2400 B4800 |
| B9600 B19200 B38400 B57600 B115200 |
| B230400 B460800 |
| |
| BSD defines two additional speed symbols as aliases: `EXTA' is an |
| alias for `B19200' and `EXTB' is an alias for `B38400'. These aliases |
| are obsolete. |
| |
| |
| File: libc.info, Node: Special Characters, Next: Noncanonical Input, Prev: Line Speed, Up: Terminal Modes |
| |
| 17.4.9 Special Characters |
| ------------------------- |
| |
| In canonical input, the terminal driver recognizes a number of special |
| characters which perform various control functions. These include the |
| ERASE character (usually <DEL>) for editing input, and other editing |
| characters. The INTR character (normally `C-c') for sending a `SIGINT' |
| signal, and other signal-raising characters, may be available in either |
| canonical or noncanonical input mode. All these characters are |
| described in this section. |
| |
| The particular characters used are specified in the `c_cc' member of |
| the `struct termios' structure. This member is an array; each element |
| specifies the character for a particular role. Each element has a |
| symbolic constant that stands for the index of that element--for |
| example, `VINTR' is the index of the element that specifies the INTR |
| character, so storing `'='' in `TERMIOS.c_cc[VINTR]' specifies `=' as |
| the INTR character. |
| |
| On some systems, you can disable a particular special character |
| function by specifying the value `_POSIX_VDISABLE' for that role. This |
| value is unequal to any possible character code. *Note Options for |
| Files::, for more information about how to tell whether the operating |
| system you are using supports `_POSIX_VDISABLE'. |
| |
| * Menu: |
| |
| * Editing Characters:: Special characters that terminate lines and |
| delete text, and other editing functions. |
| * Signal Characters:: Special characters that send or raise signals |
| to or for certain classes of processes. |
| * Start/Stop Characters:: Special characters that suspend or resume |
| suspended output. |
| * Other Special:: Other special characters for BSD systems: |
| they can discard output, and print status. |
| |
| |
| File: libc.info, Node: Editing Characters, Next: Signal Characters, Up: Special Characters |
| |
| 17.4.9.1 Characters for Input Editing |
| ..................................... |
| |
| These special characters are active only in canonical input mode. |
| *Note Canonical or Not::. |
| |
| -- Macro: int VEOF |
| This is the subscript for the EOF character in the special control |
| character array. `TERMIOS.c_cc[VEOF]' holds the character itself. |
| |
| The EOF character is recognized only in canonical input mode. It |
| acts as a line terminator in the same way as a newline character, |
| but if the EOF character is typed at the beginning of a line it |
| causes `read' to return a byte count of zero, indicating |
| end-of-file. The EOF character itself is discarded. |
| |
| Usually, the EOF character is `C-d'. |
| |
| -- Macro: int VEOL |
| This is the subscript for the EOL character in the special control |
| character array. `TERMIOS.c_cc[VEOL]' holds the character itself. |
| |
| The EOL character is recognized only in canonical input mode. It |
| acts as a line terminator, just like a newline character. The EOL |
| character is not discarded; it is read as the last character in |
| the input line. |
| |
| You don't need to use the EOL character to make <RET> end a line. |
| Just set the ICRNL flag. In fact, this is the default state of |
| affairs. |
| |
| -- Macro: int VEOL2 |
| This is the subscript for the EOL2 character in the special control |
| character array. `TERMIOS.c_cc[VEOL2]' holds the character itself. |
| |
| The EOL2 character works just like the EOL character (see above), |
| but it can be a different character. Thus, you can specify two |
| characters to terminate an input line, by setting EOL to one of |
| them and EOL2 to the other. |
| |
| The EOL2 character is a BSD extension; it exists only on BSD |
| systems and GNU/Linux and GNU/Hurd systems. |
| |
| -- Macro: int VERASE |
| This is the subscript for the ERASE character in the special |
| control character array. `TERMIOS.c_cc[VERASE]' holds the |
| character itself. |
| |
| The ERASE character is recognized only in canonical input mode. |
| When the user types the erase character, the previous character |
| typed is discarded. (If the terminal generates multibyte |
| character sequences, this may cause more than one byte of input to |
| be discarded.) This cannot be used to erase past the beginning of |
| the current line of text. The ERASE character itself is discarded. |
| |
| Usually, the ERASE character is <DEL>. |
| |
| -- Macro: int VWERASE |
| This is the subscript for the WERASE character in the special |
| control character array. `TERMIOS.c_cc[VWERASE]' holds the |
| character itself. |
| |
| The WERASE character is recognized only in canonical mode. It |
| erases an entire word of prior input, and any whitespace after it; |
| whitespace characters before the word are not erased. |
| |
| The definition of a "word" depends on the setting of the |
| `ALTWERASE' mode; *note Local Modes::. |
| |
| If the `ALTWERASE' mode is not set, a word is defined as a sequence |
| of any characters except space or tab. |
| |
| If the `ALTWERASE' mode is set, a word is defined as a sequence of |
| characters containing only letters, numbers, and underscores, |
| optionally followed by one character that is not a letter, number, |
| or underscore. |
| |
| The WERASE character is usually `C-w'. |
| |
| This is a BSD extension. |
| |
| -- Macro: int VKILL |
| This is the subscript for the KILL character in the special control |
| character array. `TERMIOS.c_cc[VKILL]' holds the character itself. |
| |
| The KILL character is recognized only in canonical input mode. |
| When the user types the kill character, the entire contents of the |
| current line of input are discarded. The kill character itself is |
| discarded too. |
| |
| The KILL character is usually `C-u'. |
| |
| -- Macro: int VREPRINT |
| This is the subscript for the REPRINT character in the special |
| control character array. `TERMIOS.c_cc[VREPRINT]' holds the |
| character itself. |
| |
| The REPRINT character is recognized only in canonical mode. It |
| reprints the current input line. If some asynchronous output has |
| come while you are typing, this lets you see the line you are |
| typing clearly again. |
| |
| The REPRINT character is usually `C-r'. |
| |
| This is a BSD extension. |
| |
| |
| File: libc.info, Node: Signal Characters, Next: Start/Stop Characters, Prev: Editing Characters, Up: Special Characters |
| |
| 17.4.9.2 Characters that Cause Signals |
| ...................................... |
| |
| These special characters may be active in either canonical or |
| noncanonical input mode, but only when the `ISIG' flag is set (*note |
| Local Modes::). |
| |
| -- Macro: int VINTR |
| This is the subscript for the INTR character in the special control |
| character array. `TERMIOS.c_cc[VINTR]' holds the character itself. |
| |
| The INTR (interrupt) character raises a `SIGINT' signal for all |
| processes in the foreground job associated with the terminal. The |
| INTR character itself is then discarded. *Note Signal Handling::, |
| for more information about signals. |
| |
| Typically, the INTR character is `C-c'. |
| |
| -- Macro: int VQUIT |
| This is the subscript for the QUIT character in the special control |
| character array. `TERMIOS.c_cc[VQUIT]' holds the character itself. |
| |
| The QUIT character raises a `SIGQUIT' signal for all processes in |
| the foreground job associated with the terminal. The QUIT |
| character itself is then discarded. *Note Signal Handling::, for |
| more information about signals. |
| |
| Typically, the QUIT character is `C-\'. |
| |
| -- Macro: int VSUSP |
| This is the subscript for the SUSP character in the special control |
| character array. `TERMIOS.c_cc[VSUSP]' holds the character itself. |
| |
| The SUSP (suspend) character is recognized only if the |
| implementation supports job control (*note Job Control::). It |
| causes a `SIGTSTP' signal to be sent to all processes in the |
| foreground job associated with the terminal. The SUSP character |
| itself is then discarded. *Note Signal Handling::, for more |
| information about signals. |
| |
| Typically, the SUSP character is `C-z'. |
| |
| Few applications disable the normal interpretation of the SUSP |
| character. If your program does this, it should provide some other |
| mechanism for the user to stop the job. When the user invokes this |
| mechanism, the program should send a `SIGTSTP' signal to the process |
| group of the process, not just to the process itself. *Note Signaling |
| Another Process::. |
| |
| -- Macro: int VDSUSP |
| This is the subscript for the DSUSP character in the special |
| control character array. `TERMIOS.c_cc[VDSUSP]' holds the |
| character itself. |
| |
| The DSUSP (suspend) character is recognized only if the |
| implementation supports job control (*note Job Control::). It |
| sends a `SIGTSTP' signal, like the SUSP character, but not right |
| away--only when the program tries to read it as input. Not all |
| systems with job control support DSUSP; only BSD-compatible |
| systems do (including GNU/Hurd systems). |
| |
| *Note Signal Handling::, for more information about signals. |
| |
| Typically, the DSUSP character is `C-y'. |
| |
| |
| File: libc.info, Node: Start/Stop Characters, Next: Other Special, Prev: Signal Characters, Up: Special Characters |
| |
| 17.4.9.3 Special Characters for Flow Control |
| ............................................ |
| |
| These special characters may be active in either canonical or |
| noncanonical input mode, but their use is controlled by the flags |
| `IXON' and `IXOFF' (*note Input Modes::). |
| |
| -- Macro: int VSTART |
| This is the subscript for the START character in the special |
| control character array. `TERMIOS.c_cc[VSTART]' holds the |
| character itself. |
| |
| The START character is used to support the `IXON' and `IXOFF' |
| input modes. If `IXON' is set, receiving a START character resumes |
| suspended output; the START character itself is discarded. If |
| `IXANY' is set, receiving any character at all resumes suspended |
| output; the resuming character is not discarded unless it is the |
| START character. If `IXOFF' is set, the system may also transmit |
| START characters to the terminal. |
| |
| The usual value for the START character is `C-q'. You may not be |
| able to change this value--the hardware may insist on using `C-q' |
| regardless of what you specify. |
| |
| -- Macro: int VSTOP |
| This is the subscript for the STOP character in the special control |
| character array. `TERMIOS.c_cc[VSTOP]' holds the character itself. |
| |
| The STOP character is used to support the `IXON' and `IXOFF' input |
| modes. If `IXON' is set, receiving a STOP character causes output |
| to be suspended; the STOP character itself is discarded. If |
| `IXOFF' is set, the system may also transmit STOP characters to the |
| terminal, to prevent the input queue from overflowing. |
| |
| The usual value for the STOP character is `C-s'. You may not be |
| able to change this value--the hardware may insist on using `C-s' |
| regardless of what you specify. |
| |
| |
| File: libc.info, Node: Other Special, Prev: Start/Stop Characters, Up: Special Characters |
| |
| 17.4.9.4 Other Special Characters |
| ................................. |
| |
| -- Macro: int VLNEXT |
| This is the subscript for the LNEXT character in the special |
| control character array. `TERMIOS.c_cc[VLNEXT]' holds the |
| character itself. |
| |
| The LNEXT character is recognized only when `IEXTEN' is set, but in |
| both canonical and noncanonical mode. It disables any special |
| significance of the next character the user types. Even if the |
| character would normally perform some editing function or generate |
| a signal, it is read as a plain character. This is the analogue |
| of the `C-q' command in Emacs. "LNEXT" stands for "literal next." |
| |
| The LNEXT character is usually `C-v'. |
| |
| This character is available on BSD systems and GNU/Linux and |
| GNU/Hurd systems. |
| |
| -- Macro: int VDISCARD |
| This is the subscript for the DISCARD character in the special |
| control character array. `TERMIOS.c_cc[VDISCARD]' holds the |
| character itself. |
| |
| The DISCARD character is recognized only when `IEXTEN' is set, but |
| in both canonical and noncanonical mode. Its effect is to toggle |
| the discard-output flag. When this flag is set, all program |
| output is discarded. Setting the flag also discards all output |
| currently in the output buffer. Typing any other character resets |
| the flag. |
| |
| This character is available on BSD systems and GNU/Linux and |
| GNU/Hurd systems. |
| |
| -- Macro: int VSTATUS |
| This is the subscript for the STATUS character in the special |
| control character array. `TERMIOS.c_cc[VSTATUS]' holds the |
| character itself. |
| |
| The STATUS character's effect is to print out a status message |
| about how the current process is running. |
| |
| The STATUS character is recognized only in canonical mode, and |
| only if `NOKERNINFO' is not set. |
| |
| This character is available only on BSD systems and GNU/Hurd |
| systems. |
| |
| |
| File: libc.info, Node: Noncanonical Input, Prev: Special Characters, Up: Terminal Modes |
| |
| 17.4.10 Noncanonical Input |
| -------------------------- |
| |
| In noncanonical input mode, the special editing characters such as |
| ERASE and KILL are ignored. The system facilities for the user to edit |
| input are disabled in noncanonical mode, so that all input characters |
| (unless they are special for signal or flow-control purposes) are passed |
| to the application program exactly as typed. It is up to the |
| application program to give the user ways to edit the input, if |
| appropriate. |
| |
| Noncanonical mode offers special parameters called MIN and TIME for |
| controlling whether and how long to wait for input to be available. You |
| can even use them to avoid ever waiting--to return immediately with |
| whatever input is available, or with no input. |
| |
| The MIN and TIME are stored in elements of the `c_cc' array, which |
| is a member of the `struct termios' structure. Each element of this |
| array has a particular role, and each element has a symbolic constant |
| that stands for the index of that element. `VMIN' and `VTIME' are the |
| names for the indices in the array of the MIN and TIME slots. |
| |
| -- Macro: int VMIN |
| This is the subscript for the MIN slot in the `c_cc' array. Thus, |
| `TERMIOS.c_cc[VMIN]' is the value itself. |
| |
| The MIN slot is only meaningful in noncanonical input mode; it |
| specifies the minimum number of bytes that must be available in the |
| input queue in order for `read' to return. |
| |
| -- Macro: int VTIME |
| This is the subscript for the TIME slot in the `c_cc' array. Thus, |
| `TERMIOS.c_cc[VTIME]' is the value itself. |
| |
| The TIME slot is only meaningful in noncanonical input mode; it |
| specifies how long to wait for input before returning, in units of |
| 0.1 seconds. |
| |
| The MIN and TIME values interact to determine the criterion for when |
| `read' should return; their precise meanings depend on which of them |
| are nonzero. There are four possible cases: |
| |
| * Both TIME and MIN are nonzero. |
| |
| In this case, TIME specifies how long to wait after each input |
| character to see if more input arrives. After the first character |
| received, `read' keeps waiting until either MIN bytes have arrived |
| in all, or TIME elapses with no further input. |
| |
| `read' always blocks until the first character arrives, even if |
| TIME elapses first. `read' can return more than MIN characters if |
| more than MIN happen to be in the queue. |
| |
| * Both MIN and TIME are zero. |
| |
| In this case, `read' always returns immediately with as many |
| characters as are available in the queue, up to the number |
| requested. If no input is immediately available, `read' returns a |
| value of zero. |
| |
| * MIN is zero but TIME has a nonzero value. |
| |
| In this case, `read' waits for time TIME for input to become |
| available; the availability of a single byte is enough to satisfy |
| the read request and cause `read' to return. When it returns, it |
| returns as many characters as are available, up to the number |
| requested. If no input is available before the timer expires, |
| `read' returns a value of zero. |
| |
| * TIME is zero but MIN has a nonzero value. |
| |
| In this case, `read' waits until at least MIN bytes are available |
| in the queue. At that time, `read' returns as many characters as |
| are available, up to the number requested. `read' can return more |
| than MIN characters if more than MIN happen to be in the queue. |
| |
| What happens if MIN is 50 and you ask to read just 10 bytes? |
| Normally, `read' waits until there are 50 bytes in the buffer (or, more |
| generally, the wait condition described above is satisfied), and then |
| reads 10 of them, leaving the other 40 buffered in the operating system |
| for a subsequent call to `read'. |
| |
| *Portability note:* On some systems, the MIN and TIME slots are |
| actually the same as the EOF and EOL slots. This causes no serious |
| problem because the MIN and TIME slots are used only in noncanonical |
| input and the EOF and EOL slots are used only in canonical input, but it |
| isn't very clean. The GNU C Library allocates separate slots for these |
| uses. |
| |
| -- Function: void cfmakeraw (struct termios *TERMIOS-P) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This function provides an easy way to set up `*TERMIOS-P' for what |
| has traditionally been called "raw mode" in BSD. This uses |
| noncanonical input, and turns off most processing to give an |
| unmodified channel to the terminal. |
| |
| It does exactly this: |
| TERMIOS-P->c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP |
| |INLCR|IGNCR|ICRNL|IXON); |
| TERMIOS-P->c_oflag &= ~OPOST; |
| TERMIOS-P->c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN); |
| TERMIOS-P->c_cflag &= ~(CSIZE|PARENB); |
| TERMIOS-P->c_cflag |= CS8; |
| |
| |
| File: libc.info, Node: BSD Terminal Modes, Next: Line Control, Prev: Terminal Modes, Up: Low-Level Terminal Interface |
| |
| 17.5 BSD Terminal Modes |
| ======================= |
| |
| The usual way to get and set terminal modes is with the functions |
| described in *note Terminal Modes::. However, on some systems you can |
| use the BSD-derived functions in this section to do some of the same |
| things. On many systems, these functions do not exist. Even with the |
| GNU C Library, the functions simply fail with `errno' = `ENOSYS' with |
| many kernels, including Linux. |
| |
| The symbols used in this section are declared in `sgtty.h'. |
| |
| -- Data Type: struct sgttyb |
| This structure is an input or output parameter list for `gtty' and |
| `stty'. |
| |
| `char sg_ispeed' |
| Line speed for input |
| |
| `char sg_ospeed' |
| Line speed for output |
| |
| `char sg_erase' |
| Erase character |
| |
| `char sg_kill' |
| Kill character |
| |
| `int sg_flags' |
| Various flags |
| |
| -- Function: int gtty (int FILEDES, struct sgttyb *ATTRIBUTES) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This function gets the attributes of a terminal. |
| |
| `gtty' sets *ATTRIBUTES to describe the terminal attributes of the |
| terminal which is open with file descriptor FILEDES. |
| |
| -- Function: int stty (int FILEDES, const struct sgttyb *ATTRIBUTES) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This function sets the attributes of a terminal. |
| |
| `stty' sets the terminal attributes of the terminal which is open |
| with file descriptor FILEDES to those described by *ATTRIBUTES. |
| |
| |
| File: libc.info, Node: Line Control, Next: Noncanon Example, Prev: BSD Terminal Modes, Up: Low-Level Terminal Interface |
| |
| 17.6 Line Control Functions |
| =========================== |
| |
| These functions perform miscellaneous control actions on terminal |
| devices. As regards terminal access, they are treated like doing |
| output: if any of these functions is used by a background process on its |
| controlling terminal, normally all processes in the process group are |
| sent a `SIGTTOU' signal. The exception is if the calling process |
| itself is ignoring or blocking `SIGTTOU' signals, in which case the |
| operation is performed and no signal is sent. *Note Job Control::. |
| |
| -- Function: int tcsendbreak (int FILEDES, int DURATION) |
| Preliminary: | MT-Unsafe race:tcattr(filedes)/bsd | AS-Unsafe | |
| AC-Unsafe corrupt/bsd | *Note POSIX Safety Concepts::. |
| |
| This function generates a break condition by transmitting a stream |
| of zero bits on the terminal associated with the file descriptor |
| FILEDES. The duration of the break is controlled by the DURATION |
| argument. If zero, the duration is between 0.25 and 0.5 seconds. |
| The meaning of a nonzero value depends on the operating system. |
| |
| This function does nothing if the terminal is not an asynchronous |
| serial data port. |
| |
| The return value is normally zero. In the event of an error, a |
| value of -1 is returned. The following `errno' error conditions |
| are defined for this function: |
| |
| `EBADF' |
| The FILEDES is not a valid file descriptor. |
| |
| `ENOTTY' |
| The FILEDES is not associated with a terminal device. |
| |
| -- Function: int tcdrain (int FILEDES) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| The `tcdrain' function waits until all queued output to the |
| terminal FILEDES has been transmitted. |
| |
| This function is a cancellation point in multi-threaded programs. |
| This is a problem if the thread allocates some resources (like |
| memory, file descriptors, semaphores or whatever) at the time |
| `tcdrain' is called. If the thread gets canceled these resources |
| stay allocated until the program ends. To avoid this calls to |
| `tcdrain' should be protected using cancellation handlers. |
| |
| The return value is normally zero. In the event of an error, a |
| value of -1 is returned. The following `errno' error conditions |
| are defined for this function: |
| |
| `EBADF' |
| The FILEDES is not a valid file descriptor. |
| |
| `ENOTTY' |
| The FILEDES is not associated with a terminal device. |
| |
| `EINTR' |
| The operation was interrupted by delivery of a signal. *Note |
| Interrupted Primitives::. |
| |
| -- Function: int tcflush (int FILEDES, int QUEUE) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| The `tcflush' function is used to clear the input and/or output |
| queues associated with the terminal file FILEDES. The QUEUE |
| argument specifies which queue(s) to clear, and can be one of the |
| following values: |
| |
| `TCIFLUSH' |
| Clear any input data received, but not yet read. |
| |
| `TCOFLUSH' |
| Clear any output data written, but not yet transmitted. |
| |
| `TCIOFLUSH' |
| Clear both queued input and output. |
| |
| The return value is normally zero. In the event of an error, a |
| value of -1 is returned. The following `errno' error conditions |
| are defined for this function: |
| |
| `EBADF' |
| The FILEDES is not a valid file descriptor. |
| |
| `ENOTTY' |
| The FILEDES is not associated with a terminal device. |
| |
| `EINVAL' |
| A bad value was supplied as the QUEUE argument. |
| |
| It is unfortunate that this function is named `tcflush', because |
| the term "flush" is normally used for quite another |
| operation--waiting until all output is transmitted--and using it |
| for discarding input or output would be confusing. Unfortunately, |
| the name `tcflush' comes from POSIX and we cannot change it. |
| |
| -- Function: int tcflow (int FILEDES, int ACTION) |
| Preliminary: | MT-Unsafe race:tcattr(filedes)/bsd | AS-Unsafe | |
| AC-Safe | *Note POSIX Safety Concepts::. |
| |
| The `tcflow' function is used to perform operations relating to |
| XON/XOFF flow control on the terminal file specified by FILEDES. |
| |
| The ACTION argument specifies what operation to perform, and can |
| be one of the following values: |
| |
| `TCOOFF' |
| Suspend transmission of output. |
| |
| `TCOON' |
| Restart transmission of output. |
| |
| `TCIOFF' |
| Transmit a STOP character. |
| |
| `TCION' |
| Transmit a START character. |
| |
| For more information about the STOP and START characters, see |
| *note Special Characters::. |
| |
| The return value is normally zero. In the event of an error, a |
| value of -1 is returned. The following `errno' error conditions |
| are defined for this function: |
| |
| `EBADF' |
| The FILEDES is not a valid file descriptor. |
| |
| `ENOTTY' |
| The FILEDES is not associated with a terminal device. |
| |
| `EINVAL' |
| A bad value was supplied as the ACTION argument. |
| |
| |
| File: libc.info, Node: Noncanon Example, Next: getpass, Prev: Line Control, Up: Low-Level Terminal Interface |
| |
| 17.7 Noncanonical Mode Example |
| ============================== |
| |
| Here is an example program that shows how you can set up a terminal |
| device to read single characters in noncanonical input mode, without |
| echo. |
| |
| |
| #include <unistd.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <termios.h> |
| |
| /* Use this variable to remember original terminal attributes. */ |
| |
| struct termios saved_attributes; |
| |
| void |
| reset_input_mode (void) |
| { |
| tcsetattr (STDIN_FILENO, TCSANOW, &saved_attributes); |
| } |
| |
| void |
| set_input_mode (void) |
| { |
| struct termios tattr; |
| char *name; |
| |
| /* Make sure stdin is a terminal. */ |
| if (!isatty (STDIN_FILENO)) |
| { |
| fprintf (stderr, "Not a terminal.\n"); |
| exit (EXIT_FAILURE); |
| } |
| |
| /* Save the terminal attributes so we can restore them later. */ |
| tcgetattr (STDIN_FILENO, &saved_attributes); |
| atexit (reset_input_mode); |
| |
| /* Set the funny terminal modes. */ |
| tcgetattr (STDIN_FILENO, &tattr); |
| tattr.c_lflag &= ~(ICANON|ECHO); /* Clear ICANON and ECHO. */ |
| tattr.c_cc[VMIN] = 1; |
| tattr.c_cc[VTIME] = 0; |
| tcsetattr (STDIN_FILENO, TCSAFLUSH, &tattr); |
| } |
| |
| int |
| main (void) |
| { |
| char c; |
| |
| set_input_mode (); |
| |
| while (1) |
| { |
| read (STDIN_FILENO, &c, 1); |
| if (c == '\004') /* `C-d' */ |
| break; |
| else |
| putchar (c); |
| } |
| |
| return EXIT_SUCCESS; |
| } |
| |
| This program is careful to restore the original terminal modes before |
| exiting or terminating with a signal. It uses the `atexit' function |
| (*note Cleanups on Exit::) to make sure this is done by `exit'. |
| |
| The shell is supposed to take care of resetting the terminal modes |
| when a process is stopped or continued; see *note Job Control::. But |
| some existing shells do not actually do this, so you may wish to |
| establish handlers for job control signals that reset terminal modes. |
| The above example does so. |
| |
| |
| File: libc.info, Node: getpass, Next: Pseudo-Terminals, Prev: Noncanon Example, Up: Low-Level Terminal Interface |
| |
| 17.8 Reading Passphrases |
| ======================== |
| |
| When reading in a passphrase, it is desirable to avoid displaying it on |
| the screen, to help keep it secret. The following function handles this |
| in a convenient way. |
| |
| -- Function: char * getpass (const char *PROMPT) |
| Preliminary: | MT-Unsafe term | AS-Unsafe heap lock corrupt | |
| AC-Unsafe term lock corrupt | *Note POSIX Safety Concepts::. |
| |
| `getpass' outputs PROMPT, then reads a string in from the terminal |
| without echoing it. It tries to connect to the real terminal, |
| `/dev/tty', if possible, to encourage users not to put plaintext |
| passphrases in files; otherwise, it uses `stdin' and `stderr'. |
| `getpass' also disables the INTR, QUIT, and SUSP characters on the |
| terminal using the `ISIG' terminal attribute (*note Local Modes::). |
| The terminal is flushed before and after `getpass', so that |
| characters of a mistyped passphrase are not accidentally visible. |
| |
| In other C libraries, `getpass' may only return the first |
| `PASS_MAX' bytes of a passphrase. The GNU C Library has no limit, |
| so `PASS_MAX' is undefined. |
| |
| The prototype for this function is in `unistd.h'. `PASS_MAX' |
| would be defined in `limits.h'. |
| |
| This precise set of operations may not suit all possible situations. |
| In this case, it is recommended that users write their own `getpass' |
| substitute. For instance, a very simple substitute is as follows: |
| |
| |
| #include <termios.h> |
| #include <stdio.h> |
| |
| ssize_t |
| my_getpass (char **lineptr, size_t *n, FILE *stream) |
| { |
| struct termios old, new; |
| int nread; |
| |
| /* Turn echoing off and fail if we can't. */ |
| if (tcgetattr (fileno (stream), &old) != 0) |
| return -1; |
| new = old; |
| new.c_lflag &= ~ECHO; |
| if (tcsetattr (fileno (stream), TCSAFLUSH, &new) != 0) |
| return -1; |
| |
| /* Read the passphrase */ |
| nread = getline (lineptr, n, stream); |
| |
| /* Restore terminal. */ |
| (void) tcsetattr (fileno (stream), TCSAFLUSH, &old); |
| |
| return nread; |
| } |
| |
| The substitute takes the same parameters as `getline' (*note Line |
| Input::); the user must print any prompt desired. |
| |
| |
| File: libc.info, Node: Pseudo-Terminals, Prev: getpass, Up: Low-Level Terminal Interface |
| |
| 17.9 Pseudo-Terminals |
| ===================== |
| |
| A "pseudo-terminal" is a special interprocess communication channel |
| that acts like a terminal. One end of the channel is called the |
| "master" side or "master pseudo-terminal device", the other side is |
| called the "slave" side. Data written to the master side is received |
| by the slave side as if it was the result of a user typing at an |
| ordinary terminal, and data written to the slave side is sent to the |
| master side as if it was written on an ordinary terminal. |
| |
| Pseudo terminals are the way programs like `xterm' and `emacs' |
| implement their terminal emulation functionality. |
| |
| * Menu: |
| |
| * Allocation:: Allocating a pseudo terminal. |
| * Pseudo-Terminal Pairs:: How to open both sides of a |
| pseudo-terminal in a single operation. |
| |
| |
| File: libc.info, Node: Allocation, Next: Pseudo-Terminal Pairs, Up: Pseudo-Terminals |
| |
| 17.9.1 Allocating Pseudo-Terminals |
| ---------------------------------- |
| |
| This subsection describes functions for allocating a pseudo-terminal, |
| and for making this pseudo-terminal available for actual use. These |
| functions are declared in the header file `stdlib.h'. |
| |
| -- Function: int getpt (void) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe fd | *Note POSIX Safety |
| Concepts::. |
| |
| The `getpt' function returns a new file descriptor for the next |
| available master pseudo-terminal. The normal return value from |
| `getpt' is a non-negative integer file descriptor. In the case of |
| an error, a value of -1 is returned instead. The following |
| `errno' conditions are defined for this function: |
| |
| `ENOENT' |
| There are no free master pseudo-terminals available. |
| |
| This function is a GNU extension. |
| |
| -- Function: int grantpt (int FILEDES) |
| Preliminary: | MT-Safe locale | AS-Unsafe dlopen plugin heap lock |
| | AC-Unsafe corrupt lock fd mem | *Note POSIX Safety Concepts::. |
| |
| The `grantpt' function changes the ownership and access permission |
| of the slave pseudo-terminal device corresponding to the master |
| pseudo-terminal device associated with the file descriptor |
| FILEDES. The owner is set from the real user ID of the calling |
| process (*note Process Persona::), and the group is set to a |
| special group (typically "tty") or from the real group ID of the |
| calling process. The access permission is set such that the file |
| is both readable and writable by the owner and only writable by |
| the group. |
| |
| On some systems this function is implemented by invoking a special |
| `setuid' root program (*note How Change Persona::). As a |
| consequence, installing a signal handler for the `SIGCHLD' signal |
| (*note Job Control Signals::) may interfere with a call to |
| `grantpt'. |
| |
| The normal return value from `grantpt' is 0; a value of -1 is |
| returned in case of failure. The following `errno' error |
| conditions are defined for this function: |
| |
| `EBADF' |
| The FILEDES argument is not a valid file descriptor. |
| |
| `EINVAL' |
| The FILEDES argument is not associated with a master |
| pseudo-terminal device. |
| |
| `EACCES' |
| The slave pseudo-terminal device corresponding to the master |
| associated with FILEDES could not be accessed. |
| |
| |
| -- Function: int unlockpt (int FILEDES) |
| Preliminary: | MT-Safe | AS-Unsafe heap/bsd | AC-Unsafe mem fd | |
| *Note POSIX Safety Concepts::. |
| |
| The `unlockpt' function unlocks the slave pseudo-terminal device |
| corresponding to the master pseudo-terminal device associated with |
| the file descriptor FILEDES. On many systems, the slave can only |
| be opened after unlocking, so portable applications should always |
| call `unlockpt' before trying to open the slave. |
| |
| The normal return value from `unlockpt' is 0; a value of -1 is |
| returned in case of failure. The following `errno' error |
| conditions are defined for this function: |
| |
| `EBADF' |
| The FILEDES argument is not a valid file descriptor. |
| |
| `EINVAL' |
| The FILEDES argument is not associated with a master |
| pseudo-terminal device. |
| |
| -- Function: char * ptsname (int FILEDES) |
| Preliminary: | MT-Unsafe race:ptsname | AS-Unsafe heap/bsd | |
| AC-Unsafe mem fd | *Note POSIX Safety Concepts::. |
| |
| If the file descriptor FILEDES is associated with a master |
| pseudo-terminal device, the `ptsname' function returns a pointer |
| to a statically-allocated, null-terminated string containing the |
| file name of the associated slave pseudo-terminal file. This |
| string might be overwritten by subsequent calls to `ptsname'. |
| |
| -- Function: int ptsname_r (int FILEDES, char *BUF, size_t LEN) |
| Preliminary: | MT-Safe | AS-Unsafe heap/bsd | AC-Unsafe mem fd | |
| *Note POSIX Safety Concepts::. |
| |
| The `ptsname_r' function is similar to the `ptsname' function |
| except that it places its result into the user-specified buffer |
| starting at BUF with length LEN. |
| |
| This function is a GNU extension. |
| |
| Typical usage of these functions is illustrated by the following |
| example: |
| int |
| open_pty_pair (int *amaster, int *aslave) |
| { |
| int master, slave; |
| char *name; |
| |
| master = getpt (); |
| if (master < 0) |
| return 0; |
| |
| if (grantpt (master) < 0 || unlockpt (master) < 0) |
| goto close_master; |
| name = ptsname (master); |
| if (name == NULL) |
| goto close_master; |
| |
| slave = open (name, O_RDWR); |
| if (slave == -1) |
| goto close_master; |
| |
| *amaster = master; |
| *aslave = slave; |
| return 1; |
| |
| close_slave: |
| close (slave); |
| |
| close_master: |
| close (master); |
| return 0; |
| } |
| |
| |
| File: libc.info, Node: Pseudo-Terminal Pairs, Prev: Allocation, Up: Pseudo-Terminals |
| |
| 17.9.2 Opening a Pseudo-Terminal Pair |
| ------------------------------------- |
| |
| These functions, derived from BSD, are available in the separate |
| `libutil' library, and declared in `pty.h'. |
| |
| -- Function: int openpty (int *AMASTER, int *ASLAVE, char *NAME, const |
| struct termios *TERMP, const struct winsize *WINP) |
| Preliminary: | MT-Safe locale | AS-Unsafe dlopen plugin heap lock |
| | AC-Unsafe corrupt lock fd mem | *Note POSIX Safety Concepts::. |
| |
| This function allocates and opens a pseudo-terminal pair, |
| returning the file descriptor for the master in *AMASTER, and the |
| file descriptor for the slave in *ASLAVE. If the argument NAME is |
| not a null pointer, the file name of the slave pseudo-terminal |
| device is stored in `*name'. If TERMP is not a null pointer, the |
| terminal attributes of the slave are set to the ones specified in |
| the structure that TERMP points to (*note Terminal Modes::). |
| Likewise, if WINP is not a null pointer, the screen size of the |
| slave is set to the values specified in the structure that WINP |
| points to. |
| |
| The normal return value from `openpty' is 0; a value of -1 is |
| returned in case of failure. The following `errno' conditions are |
| defined for this function: |
| |
| `ENOENT' |
| There are no free pseudo-terminal pairs available. |
| |
| *Warning:* Using the `openpty' function with NAME not set to |
| `NULL' is *very dangerous* because it provides no protection |
| against overflowing the string NAME. You should use the `ttyname' |
| function on the file descriptor returned in *SLAVE to find out the |
| file name of the slave pseudo-terminal device instead. |
| |
| -- Function: int forkpty (int *AMASTER, char *NAME, const struct |
| termios *TERMP, const struct winsize *WINP) |
| Preliminary: | MT-Safe locale | AS-Unsafe dlopen plugin heap lock |
| | AC-Unsafe corrupt lock fd mem | *Note POSIX Safety Concepts::. |
| |
| This function is similar to the `openpty' function, but in |
| addition, forks a new process (*note Creating a Process::) and |
| makes the newly opened slave pseudo-terminal device the |
| controlling terminal (*note Controlling Terminal::) for the child |
| process. |
| |
| If the operation is successful, there are then both parent and |
| child processes and both see `forkpty' return, but with different |
| values: it returns a value of 0 in the child process and returns |
| the child's process ID in the parent process. |
| |
| If the allocation of a pseudo-terminal pair or the process creation |
| failed, `forkpty' returns a value of -1 in the parent process. |
| |
| *Warning:* The `forkpty' function has the same problems with |
| respect to the NAME argument as `openpty'. |
| |
| |
| File: libc.info, Node: Syslog, Next: Mathematics, Prev: Low-Level Terminal Interface, Up: Top |
| |
| 18 Syslog |
| ********* |
| |
| This chapter describes facilities for issuing and logging messages of |
| system administration interest. This chapter has nothing to do with |
| programs issuing messages to their own users or keeping private logs |
| (One would typically do that with the facilities described in *note I/O |
| on Streams::). |
| |
| Most systems have a facility called "Syslog" that allows programs to |
| submit messages of interest to system administrators and can be |
| configured to pass these messages on in various ways, such as printing |
| on the console, mailing to a particular person, or recording in a log |
| file for future reference. |
| |
| A program uses the facilities in this chapter to submit such |
| messages. |
| |
| * Menu: |
| |
| * Overview of Syslog:: Overview of a system's Syslog facility |
| * Submitting Syslog Messages:: Functions to submit messages to Syslog |
| |
| |
| File: libc.info, Node: Overview of Syslog, Next: Submitting Syslog Messages, Up: Syslog |
| |
| 18.1 Overview of Syslog |
| ======================= |
| |
| System administrators have to deal with lots of different kinds of |
| messages from a plethora of subsystems within each system, and usually |
| lots of systems as well. For example, an FTP server might report every |
| connection it gets. The kernel might report hardware failures on a disk |
| drive. A DNS server might report usage statistics at regular intervals. |
| |
| Some of these messages need to be brought to a system administrator's |
| attention immediately. And it may not be just any system administrator |
| - there may be a particular system administrator who deals with a |
| particular kind of message. Other messages just need to be recorded for |
| future reference if there is a problem. Still others may need to have |
| information extracted from them by an automated process that generates |
| monthly reports. |
| |
| To deal with these messages, most Unix systems have a facility called |
| "Syslog." It is generally based on a daemon called "Syslogd" Syslogd |
| listens for messages on a Unix domain socket named `/dev/log'. Based |
| on classification information in the messages and its configuration |
| file (usually `/etc/syslog.conf'), Syslogd routes them in various ways. |
| Some of the popular routings are: |
| |
| * Write to the system console |
| |
| * Mail to a specific user |
| |
| * Write to a log file |
| |
| * Pass to another daemon |
| |
| * Discard |
| |
| Syslogd can also handle messages from other systems. It listens on |
| the `syslog' UDP port as well as the local socket for messages. |
| |
| Syslog can handle messages from the kernel itself. But the kernel |
| doesn't write to `/dev/log'; rather, another daemon (sometimes called |
| "Klogd") extracts messages from the kernel and passes them on to Syslog |
| as any other process would (and it properly identifies them as messages |
| from the kernel). |
| |
| Syslog can even handle messages that the kernel issued before |
| Syslogd or Klogd was running. A Linux kernel, for example, stores |
| startup messages in a kernel message ring and they are normally still |
| there when Klogd later starts up. Assuming Syslogd is running by the |
| time Klogd starts, Klogd then passes everything in the message ring to |
| it. |
| |
| In order to classify messages for disposition, Syslog requires any |
| process that submits a message to it to provide two pieces of |
| classification information with it: |
| |
| facility |
| This identifies who submitted the message. There are a small |
| number of facilities defined. The kernel, the mail subsystem, and |
| an FTP server are examples of recognized facilities. For the |
| complete list, *Note syslog; vsyslog::. Keep in mind that these |
| are essentially arbitrary classifications. "Mail subsystem" |
| doesn't have any more meaning than the system administrator gives |
| to it. |
| |
| priority |
| This tells how important the content of the message is. Examples |
| of defined priority values are: debug, informational, warning and |
| critical. For the complete list, see *note syslog; vsyslog::. |
| Except for the fact that the priorities have a defined order, the |
| meaning of each of these priorities is entirely determined by the |
| system administrator. |
| |
| |
| A "facility/priority" is a number that indicates both the facility |
| and the priority. |
| |
| *Warning:* This terminology is not universal. Some people use |
| "level" to refer to the priority and "priority" to refer to the |
| combination of facility and priority. A Linux kernel has a concept of a |
| message "level," which corresponds both to a Syslog priority and to a |
| Syslog facility/priority (It can be both because the facility code for |
| the kernel is zero, and that makes priority and facility/priority the |
| same value). |
| |
| The GNU C Library provides functions to submit messages to Syslog. |
| They do it by writing to the `/dev/log' socket. *Note Submitting |
| Syslog Messages::. |
| |
| The GNU C Library functions only work to submit messages to the |
| Syslog facility on the same system. To submit a message to the Syslog |
| facility on another system, use the socket I/O functions to write a UDP |
| datagram to the `syslog' UDP port on that system. *Note Sockets::. |
| |
| |
| File: libc.info, Node: Submitting Syslog Messages, Prev: Overview of Syslog, Up: Syslog |
| |
| 18.2 Submitting Syslog Messages |
| =============================== |
| |
| The GNU C Library provides functions to submit messages to the Syslog |
| facility: |
| |
| * Menu: |
| |
| * openlog:: Open connection to Syslog |
| * syslog; vsyslog:: Submit message to Syslog |
| * closelog:: Close connection to Syslog |
| * setlogmask:: Cause certain messages to be ignored |
| * Syslog Example:: Example of all of the above |
| |
| These functions only work to submit messages to the Syslog facility |
| on the same system. To submit a message to the Syslog facility on |
| another system, use the socket I/O functions to write a UDP datagram to |
| the `syslog' UDP port on that system. *Note Sockets::. |
| |
| |
| File: libc.info, Node: openlog, Next: syslog; vsyslog, Up: Submitting Syslog Messages |
| |
| 18.2.1 openlog |
| -------------- |
| |
| The symbols referred to in this section are declared in the file |
| `syslog.h'. |
| |
| -- Function: void openlog (const char *IDENT, int OPTION, int FACILITY) |
| Preliminary: | MT-Safe | AS-Unsafe lock | AC-Unsafe lock fd | |
| *Note POSIX Safety Concepts::. |
| |
| `openlog' opens or reopens a connection to Syslog in preparation |
| for submitting messages. |
| |
| IDENT is an arbitrary identification string which future `syslog' |
| invocations will prefix to each message. This is intended to |
| identify the source of the message, and people conventionally set |
| it to the name of the program that will submit the messages. |
| |
| If IDENT is NULL, or if `openlog' is not called, the default |
| identification string used in Syslog messages will be the program |
| name, taken from argv[0]. |
| |
| Please note that the string pointer IDENT will be retained |
| internally by the Syslog routines. You must not free the memory |
| that IDENT points to. It is also dangerous to pass a reference to |
| an automatic variable since leaving the scope would mean ending the |
| lifetime of the variable. If you want to change the IDENT string, |
| you must call `openlog' again; overwriting the string pointed to by |
| IDENT is not thread-safe. |
| |
| You can cause the Syslog routines to drop the reference to IDENT |
| and go back to the default string (the program name taken from |
| argv[0]), by calling `closelog': *Note closelog::. |
| |
| In particular, if you are writing code for a shared library that |
| might get loaded and then unloaded (e.g. a PAM module), and you |
| use `openlog', you must call `closelog' before any point where |
| your library might get unloaded, as in this example: |
| |
| #include <syslog.h> |
| |
| void |
| shared_library_function (void) |
| { |
| openlog ("mylibrary", option, priority); |
| |
| syslog (LOG_INFO, "shared library has been invoked"); |
| |
| closelog (); |
| } |
| |
| Without the call to `closelog', future invocations of `syslog' by |
| the program using the shared library may crash, if the library gets |
| unloaded and the memory containing the string `"mylibrary"' becomes |
| unmapped. This is a limitation of the BSD syslog interface. |
| |
| `openlog' may or may not open the `/dev/log' socket, depending on |
| OPTION. If it does, it tries to open it and connect it as a |
| stream socket. If that doesn't work, it tries to open it and |
| connect it as a datagram socket. The socket has the "Close on |
| Exec" attribute, so the kernel will close it if the process |
| performs an exec. |
| |
| You don't have to use `openlog'. If you call `syslog' without |
| having called `openlog', `syslog' just opens the connection |
| implicitly and uses defaults for the information in IDENT and |
| OPTIONS. |
| |
| OPTIONS is a bit string, with the bits as defined by the following |
| single bit masks: |
| |
| `LOG_PERROR' |
| If on, `openlog' sets up the connection so that any `syslog' |
| on this connection writes its message to the calling process' |
| Standard Error stream in addition to submitting it to Syslog. |
| If off, `syslog' does not write the message to Standard Error. |
| |
| `LOG_CONS' |
| If on, `openlog' sets up the connection so that a `syslog' on |
| this connection that fails to submit a message to Syslog |
| writes the message instead to system console. If off, |
| `syslog' does not write to the system console (but of course |
| Syslog may write messages it receives to the console). |
| |
| `LOG_PID' |
| When on, `openlog' sets up the connection so that a `syslog' |
| on this connection inserts the calling process' Process ID |
| (PID) into the message. When off, `openlog' does not insert |
| the PID. |
| |
| `LOG_NDELAY' |
| When on, `openlog' opens and connects the `/dev/log' socket. |
| When off, a future `syslog' call must open and connect the |
| socket. |
| |
| *Portability note:* In early systems, the sense of this bit |
| was exactly the opposite. |
| |
| `LOG_ODELAY' |
| This bit does nothing. It exists for backward compatibility. |
| |
| |
| If any other bit in OPTIONS is on, the result is undefined. |
| |
| FACILITY is the default facility code for this connection. A |
| `syslog' on this connection that specifies default facility causes |
| this facility to be associated with the message. See `syslog' for |
| possible values. A value of zero means the default, which is |
| `LOG_USER'. |
| |
| If a Syslog connection is already open when you call `openlog', |
| `openlog' "reopens" the connection. Reopening is like opening |
| except that if you specify zero for the default facility code, the |
| default facility code simply remains unchanged and if you specify |
| LOG_NDELAY and the socket is already open and connected, `openlog' |
| just leaves it that way. |
| |
| |
| |
| File: libc.info, Node: syslog; vsyslog, Next: closelog, Prev: openlog, Up: Submitting Syslog Messages |
| |
| 18.2.2 syslog, vsyslog |
| ---------------------- |
| |
| The symbols referred to in this section are declared in the file |
| `syslog.h'. |
| |
| -- Function: void syslog (int FACILITY_PRIORITY, const char *FORMAT, |
| ...) |
| Preliminary: | MT-Safe env locale | AS-Unsafe corrupt heap lock |
| dlopen | AC-Unsafe corrupt lock mem fd | *Note POSIX Safety |
| Concepts::. |
| |
| `syslog' submits a message to the Syslog facility. It does this by |
| writing to the Unix domain socket `/dev/log'. |
| |
| `syslog' submits the message with the facility and priority |
| indicated by FACILITY_PRIORITY. The macro `LOG_MAKEPRI' generates |
| a facility/priority from a facility and a priority, as in the |
| following example: |
| |
| LOG_MAKEPRI(LOG_USER, LOG_WARNING) |
| |
| The possible values for the facility code are (macros): |
| |
| `LOG_USER' |
| A miscellaneous user process |
| |
| `LOG_MAIL' |
| Mail |
| |
| `LOG_DAEMON' |
| A miscellaneous system daemon |
| |
| `LOG_AUTH' |
| Security (authorization) |
| |
| `LOG_SYSLOG' |
| Syslog |
| |
| `LOG_LPR' |
| Central printer |
| |
| `LOG_NEWS' |
| Network news (e.g. Usenet) |
| |
| `LOG_UUCP' |
| UUCP |
| |
| `LOG_CRON' |
| Cron and At |
| |
| `LOG_AUTHPRIV' |
| Private security (authorization) |
| |
| `LOG_FTP' |
| Ftp server |
| |
| `LOG_LOCAL0' |
| Locally defined |
| |
| `LOG_LOCAL1' |
| Locally defined |
| |
| `LOG_LOCAL2' |
| Locally defined |
| |
| `LOG_LOCAL3' |
| Locally defined |
| |
| `LOG_LOCAL4' |
| Locally defined |
| |
| `LOG_LOCAL5' |
| Locally defined |
| |
| `LOG_LOCAL6' |
| Locally defined |
| |
| `LOG_LOCAL7' |
| Locally defined |
| |
| Results are undefined if the facility code is anything else. |
| |
| *NB:* `syslog' recognizes one other facility code: that of the |
| kernel. But you can't specify that facility code with these |
| functions. If you try, it looks the same to `syslog' as if you are |
| requesting the default facility. But you wouldn't want to anyway, |
| because any program that uses the GNU C Library is not the kernel. |
| |
| You can use just a priority code as FACILITY_PRIORITY. In that |
| case, `syslog' assumes the default facility established when the |
| Syslog connection was opened. *Note Syslog Example::. |
| |
| The possible values for the priority code are (macros): |
| |
| `LOG_EMERG' |
| The message says the system is unusable. |
| |
| `LOG_ALERT' |
| Action on the message must be taken immediately. |
| |
| `LOG_CRIT' |
| The message states a critical condition. |
| |
| `LOG_ERR' |
| The message describes an error. |
| |
| `LOG_WARNING' |
| The message is a warning. |
| |
| `LOG_NOTICE' |
| The message describes a normal but important event. |
| |
| `LOG_INFO' |
| The message is purely informational. |
| |
| `LOG_DEBUG' |
| The message is only for debugging purposes. |
| |
| Results are undefined if the priority code is anything else. |
| |
| If the process does not presently have a Syslog connection open |
| (i.e., it did not call `openlog'), `syslog' implicitly opens the |
| connection the same as `openlog' would, with the following defaults |
| for information that would otherwise be included in an `openlog' |
| call: The default identification string is the program name. The |
| default default facility is `LOG_USER'. The default for all the |
| connection options in OPTIONS is as if those bits were off. |
| `syslog' leaves the Syslog connection open. |
| |
| If the `/dev/log' socket is not open and connected, `syslog' opens |
| and connects it, the same as `openlog' with the `LOG_NDELAY' |
| option would. |
| |
| `syslog' leaves `/dev/log' open and connected unless its attempt |
| to send the message failed, in which case `syslog' closes it (with |
| the hope that a future implicit open will restore the Syslog |
| connection to a usable state). |
| |
| Example: |
| |
| |
| #include <syslog.h> |
| syslog (LOG_MAKEPRI(LOG_LOCAL1, LOG_ERROR), |
| "Unable to make network connection to %s. Error=%m", host); |
| |
| |
| -- Function: void vsyslog (int FACILITY_PRIORITY, const char *FORMAT, |
| va_list ARGLIST) |
| Preliminary: | MT-Safe env locale | AS-Unsafe corrupt heap lock |
| dlopen | AC-Unsafe corrupt lock mem fd | *Note POSIX Safety |
| Concepts::. |
| |
| This is functionally identical to `syslog', with the BSD style |
| variable length argument. |
| |
| |
| |
| File: libc.info, Node: closelog, Next: setlogmask, Prev: syslog; vsyslog, Up: Submitting Syslog Messages |
| |
| 18.2.3 closelog |
| --------------- |
| |
| The symbols referred to in this section are declared in the file |
| `syslog.h'. |
| |
| -- Function: void closelog (void) |
| Preliminary: | MT-Safe | AS-Unsafe lock | AC-Unsafe lock fd | |
| *Note POSIX Safety Concepts::. |
| |
| `closelog' closes the current Syslog connection, if there is one. |
| This includes closing the `/dev/log' socket, if it is open. |
| `closelog' also sets the identification string for Syslog messages |
| back to the default, if `openlog' was called with a non-NULL |
| argument to IDENT. The default identification string is the |
| program name taken from argv[0]. |
| |
| If you are writing shared library code that uses `openlog' to |
| generate custom syslog output, you should use `closelog' to drop |
| the GNU C Library's internal reference to the IDENT pointer when |
| you are done. Please read the section on `openlog' for more |
| information: *Note openlog::. |
| |
| `closelog' does not flush any buffers. You do not have to call |
| `closelog' before re-opening a Syslog connection with `openlog'. |
| Syslog connections are automatically closed on exec or exit. |
| |
| |
| |
| File: libc.info, Node: setlogmask, Next: Syslog Example, Prev: closelog, Up: Submitting Syslog Messages |
| |
| 18.2.4 setlogmask |
| ----------------- |
| |
| The symbols referred to in this section are declared in the file |
| `syslog.h'. |
| |
| -- Function: int setlogmask (int MASK) |
| Preliminary: | MT-Unsafe race:LogMask | AS-Unsafe | AC-Safe | |
| *Note POSIX Safety Concepts::. |
| |
| `setlogmask' sets a mask (the "logmask") that determines which |
| future `syslog' calls shall be ignored. If a program has not |
| called `setlogmask', `syslog' doesn't ignore any calls. You can |
| use `setlogmask' to specify that messages of particular priorities |
| shall be ignored in the future. |
| |
| A `setlogmask' call overrides any previous `setlogmask' call. |
| |
| Note that the logmask exists entirely independently of opening and |
| closing of Syslog connections. |
| |
| Setting the logmask has a similar effect to, but is not the same |
| as, configuring Syslog. The Syslog configuration may cause Syslog |
| to discard certain messages it receives, but the logmask causes |
| certain messages never to get submitted to Syslog in the first |
| place. |
| |
| MASK is a bit string with one bit corresponding to each of the |
| possible message priorities. If the bit is on, `syslog' handles |
| messages of that priority normally. If it is off, `syslog' |
| discards messages of that priority. Use the message priority |
| macros described in *note syslog; vsyslog:: and the `LOG_MASK' to |
| construct an appropriate MASK value, as in this example: |
| |
| LOG_MASK(LOG_EMERG) | LOG_MASK(LOG_ERROR) |
| |
| or |
| |
| ~(LOG_MASK(LOG_INFO)) |
| |
| There is also a `LOG_UPTO' macro, which generates a mask with the |
| bits on for a certain priority and all priorities above it: |
| |
| LOG_UPTO(LOG_ERROR) |
| |
| The unfortunate naming of the macro is due to the fact that |
| internally, higher numbers are used for lower message priorities. |
| |
| |
| |
| File: libc.info, Node: Syslog Example, Prev: setlogmask, Up: Submitting Syslog Messages |
| |
| 18.2.5 Syslog Example |
| --------------------- |
| |
| Here is an example of `openlog', `syslog', and `closelog': |
| |
| This example sets the logmask so that debug and informational |
| messages get discarded without ever reaching Syslog. So the second |
| `syslog' in the example does nothing. |
| |
| #include <syslog.h> |
| |
| setlogmask (LOG_UPTO (LOG_NOTICE)); |
| |
| openlog ("exampleprog", LOG_CONS | LOG_PID | LOG_NDELAY, LOG_LOCAL1); |
| |
| syslog (LOG_NOTICE, "Program started by User %d", getuid ()); |
| syslog (LOG_INFO, "A tree falls in a forest"); |
| |
| closelog (); |
| |
| |
| File: libc.info, Node: Mathematics, Next: Arithmetic, Prev: Syslog, Up: Top |
| |
| 19 Mathematics |
| ************** |
| |
| This chapter contains information about functions for performing |
| mathematical computations, such as trigonometric functions. Most of |
| these functions have prototypes declared in the header file `math.h'. |
| The complex-valued functions are defined in `complex.h'. |
| |
| All mathematical functions which take a floating-point argument have |
| three variants, one each for `double', `float', and `long double' |
| arguments. The `double' versions are mostly defined in ISO C89. The |
| `float' and `long double' versions are from the numeric extensions to C |
| included in ISO C99. |
| |
| Which of the three versions of a function should be used depends on |
| the situation. For most calculations, the `float' functions are the |
| fastest. On the other hand, the `long double' functions have the |
| highest precision. `double' is somewhere in between. It is usually |
| wise to pick the narrowest type that can accommodate your data. Not |
| all machines have a distinct `long double' type; it may be the same as |
| `double'. |
| |
| The GNU C Library also provides `_FloatN' and `_FloatNx' types. |
| These types are defined in ISO/IEC TS 18661-3, which extends ISO C and |
| defines floating-point types that are not machine-dependent. When such |
| a type, such as `_Float128', is supported by the GNU C Library, extra |
| variants for most of the mathematical functions provided for `double', |
| `float', and `long double' are also provided for the supported type. |
| Throughout this manual, the `_FloatN' and `_FloatNx' variants of these |
| functions are described along with the `double', `float', and `long |
| double' variants and they come from ISO/IEC TS 18661-3, unless |
| explicitly stated otherwise. |
| |
| Support for `_FloatN' or `_FloatNx' types is provided for |
| `_Float32', `_Float64' and `_Float32x' on all platforms. It is also |
| provided for `_Float128' and `_Float64x' on powerpc64le (PowerPC |
| 64-bits little-endian), x86_64, x86, ia64, aarch64, alpha, mips64, |
| riscv, s390 and sparc. |
| |
| * Menu: |
| |
| * Mathematical Constants:: Precise numeric values for often-used |
| constants. |
| * Trig Functions:: Sine, cosine, tangent, and friends. |
| * Inverse Trig Functions:: Arcsine, arccosine, etc. |
| * Exponents and Logarithms:: Also pow and sqrt. |
| * Hyperbolic Functions:: sinh, cosh, tanh, etc. |
| * Special Functions:: Bessel, gamma, erf. |
| * Errors in Math Functions:: Known Maximum Errors in Math Functions. |
| * Pseudo-Random Numbers:: Functions for generating pseudo-random |
| numbers. |
| * FP Function Optimizations:: Fast code or small code. |
| |
| |
| File: libc.info, Node: Mathematical Constants, Next: Trig Functions, Up: Mathematics |
| |
| 19.1 Predefined Mathematical Constants |
| ====================================== |
| |
| The header `math.h' defines several useful mathematical constants. All |
| values are defined as preprocessor macros starting with `M_'. The |
| values provided are: |
| |
| `M_E' |
| The base of natural logarithms. |
| |
| `M_LOG2E' |
| The logarithm to base `2' of `M_E'. |
| |
| `M_LOG10E' |
| The logarithm to base `10' of `M_E'. |
| |
| `M_LN2' |
| The natural logarithm of `2'. |
| |
| `M_LN10' |
| The natural logarithm of `10'. |
| |
| `M_PI' |
| Pi, the ratio of a circle's circumference to its diameter. |
| |
| `M_PI_2' |
| Pi divided by two. |
| |
| `M_PI_4' |
| Pi divided by four. |
| |
| `M_1_PI' |
| The reciprocal of pi (1/pi) |
| |
| `M_2_PI' |
| Two times the reciprocal of pi. |
| |
| `M_2_SQRTPI' |
| Two times the reciprocal of the square root of pi. |
| |
| `M_SQRT2' |
| The square root of two. |
| |
| `M_SQRT1_2' |
| The reciprocal of the square root of two (also the square root of |
| 1/2). |
| |
| These constants come from the Unix98 standard and were also |
| available in 4.4BSD; therefore they are only defined if |
| `_XOPEN_SOURCE=500', or a more general feature select macro, is |
| defined. The default set of features includes these constants. *Note |
| Feature Test Macros::. |
| |
| All values are of type `double'. As an extension, the GNU C Library |
| also defines these constants with type `long double'. The `long |
| double' macros have a lowercase `l' appended to their names: `M_El', |
| `M_PIl', and so forth. These are only available if `_GNU_SOURCE' is |
| defined. |
| |
| Likewise, the GNU C Library also defines these constants with the |
| types `_FloatN' and `_FloatNx' for the machines that have support for |
| such types enabled (*note Mathematics::) and if `_GNU_SOURCE' is |
| defined. When available, the macros names are appended with `fN' or |
| `fNx', such as `f128' for the type `_Float128'. |
| |
| _Note:_ Some programs use a constant named `PI' which has the same |
| value as `M_PI'. This constant is not standard; it may have appeared |
| in some old AT&T headers, and is mentioned in Stroustrup's book on C++. |
| It infringes on the user's name space, so the GNU C Library does not |
| define it. Fixing programs written to expect it is simple: replace |
| `PI' with `M_PI' throughout, or put `-DPI=M_PI' on the compiler command |
| line. |
| |
| |
| File: libc.info, Node: Trig Functions, Next: Inverse Trig Functions, Prev: Mathematical Constants, Up: Mathematics |
| |
| 19.2 Trigonometric Functions |
| ============================ |
| |
| These are the familiar `sin', `cos', and `tan' functions. The |
| arguments to all of these functions are in units of radians; recall |
| that pi radians equals 180 degrees. |
| |
| The math library normally defines `M_PI' to a `double' approximation |
| of pi. If strict ISO and/or POSIX compliance are requested this |
| constant is not defined, but you can easily define it yourself: |
| |
| #define M_PI 3.14159265358979323846264338327 |
| |
| You can also compute the value of pi with the expression `acos (-1.0)'. |
| |
| -- Function: double sin (double X) |
| -- Function: float sinf (float X) |
| -- Function: long double sinl (long double X) |
| -- Function: _FloatN sinfN (_FloatN X) |
| -- Function: _FloatNx sinfNx (_FloatNx X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions return the sine of X, where X is given in radians. |
| The return value is in the range `-1' to `1'. |
| |
| -- Function: double cos (double X) |
| -- Function: float cosf (float X) |
| -- Function: long double cosl (long double X) |
| -- Function: _FloatN cosfN (_FloatN X) |
| -- Function: _FloatNx cosfNx (_FloatNx X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions return the cosine of X, where X is given in |
| radians. The return value is in the range `-1' to `1'. |
| |
| -- Function: double tan (double X) |
| -- Function: float tanf (float X) |
| -- Function: long double tanl (long double X) |
| -- Function: _FloatN tanfN (_FloatN X) |
| -- Function: _FloatNx tanfNx (_FloatNx X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions return the tangent of X, where X is given in |
| radians. |
| |
| Mathematically, the tangent function has singularities at odd |
| multiples of pi/2. If the argument X is too close to one of these |
| singularities, `tan' will signal overflow. |
| |
| In many applications where `sin' and `cos' are used, the sine and |
| cosine of the same angle are needed at the same time. It is more |
| efficient to compute them simultaneously, so the library provides a |
| function to do that. |
| |
| -- Function: void sincos (double X, double *SINX, double *COSX) |
| -- Function: void sincosf (float X, float *SINX, float *COSX) |
| -- Function: void sincosl (long double X, long double *SINX, long |
| double *COSX) |
| -- Function: _FloatN sincosfN (_FloatN X, _FloatN *SINX, _FloatN *COSX) |
| -- Function: _FloatNx sincosfNx (_FloatNx X, _FloatNx *SINX, _FloatNx |
| *COSX) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions return the sine of X in `*SINX' and the cosine of |
| X in `*COSX', where X is given in radians. Both values, `*SINX' |
| and `*COSX', are in the range of `-1' to `1'. |
| |
| All these functions, including the `_FloatN' and `_FloatNx' |
| variants, are GNU extensions. Portable programs should be |
| prepared to cope with their absence. |
| |
| ISO C99 defines variants of the trig functions which work on complex |
| numbers. The GNU C Library provides these functions, but they are only |
| useful if your compiler supports the new complex types defined by the |
| standard. (As of this writing GCC supports complex numbers, but there |
| are bugs in the implementation.) |
| |
| -- Function: complex double csin (complex double Z) |
| -- Function: complex float csinf (complex float Z) |
| -- Function: complex long double csinl (complex long double Z) |
| -- Function: complex _FloatN csinfN (complex _FloatN Z) |
| -- Function: complex _FloatNx csinfNx (complex _FloatNx Z) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions return the complex sine of Z. The mathematical |
| definition of the complex sine is |
| |
| sin (z) = 1/(2*i) * (exp (z*i) - exp (-z*i)). |
| |
| -- Function: complex double ccos (complex double Z) |
| -- Function: complex float ccosf (complex float Z) |
| -- Function: complex long double ccosl (complex long double Z) |
| -- Function: complex _FloatN ccosfN (complex _FloatN Z) |
| -- Function: complex _FloatNx ccosfNx (complex _FloatNx Z) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions return the complex cosine of Z. The mathematical |
| definition of the complex cosine is |
| |
| cos (z) = 1/2 * (exp (z*i) + exp (-z*i)) |
| |
| -- Function: complex double ctan (complex double Z) |
| -- Function: complex float ctanf (complex float Z) |
| -- Function: complex long double ctanl (complex long double Z) |
| -- Function: complex _FloatN ctanfN (complex _FloatN Z) |
| -- Function: complex _FloatNx ctanfNx (complex _FloatNx Z) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions return the complex tangent of Z. The mathematical |
| definition of the complex tangent is |
| |
| tan (z) = -i * (exp (z*i) - exp (-z*i)) / (exp (z*i) + exp (-z*i)) |
| |
| The complex tangent has poles at pi/2 + 2n, where n is an integer. |
| `ctan' may signal overflow if Z is too close to a pole. |
| |
| |
| File: libc.info, Node: Inverse Trig Functions, Next: Exponents and Logarithms, Prev: Trig Functions, Up: Mathematics |
| |
| 19.3 Inverse Trigonometric Functions |
| ==================================== |
| |
| These are the usual arcsine, arccosine and arctangent functions, which |
| are the inverses of the sine, cosine and tangent functions respectively. |
| |
| -- Function: double asin (double X) |
| -- Function: float asinf (float X) |
| -- Function: long double asinl (long double X) |
| -- Function: _FloatN asinfN (_FloatN X) |
| -- Function: _FloatNx asinfNx (_FloatNx X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions compute the arcsine of X--that is, the value whose |
| sine is X. The value is in units of radians. Mathematically, |
| there are infinitely many such values; the one actually returned |
| is the one between `-pi/2' and `pi/2' (inclusive). |
| |
| The arcsine function is defined mathematically only over the |
| domain `-1' to `1'. If X is outside the domain, `asin' signals a |
| domain error. |
| |
| -- Function: double acos (double X) |
| -- Function: float acosf (float X) |
| -- Function: long double acosl (long double X) |
| -- Function: _FloatN acosfN (_FloatN X) |
| -- Function: _FloatNx acosfNx (_FloatNx X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions compute the arccosine of X--that is, the value |
| whose cosine is X. The value is in units of radians. |
| Mathematically, there are infinitely many such values; the one |
| actually returned is the one between `0' and `pi' (inclusive). |
| |
| The arccosine function is defined mathematically only over the |
| domain `-1' to `1'. If X is outside the domain, `acos' signals a |
| domain error. |
| |
| -- Function: double atan (double X) |
| -- Function: float atanf (float X) |
| -- Function: long double atanl (long double X) |
| -- Function: _FloatN atanfN (_FloatN X) |
| -- Function: _FloatNx atanfNx (_FloatNx X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions compute the arctangent of X--that is, the value |
| whose tangent is X. The value is in units of radians. |
| Mathematically, there are infinitely many such values; the one |
| actually returned is the one between `-pi/2' and `pi/2' |
| (inclusive). |
| |
| -- Function: double atan2 (double Y, double X) |
| -- Function: float atan2f (float Y, float X) |
| -- Function: long double atan2l (long double Y, long double X) |
| -- Function: _FloatN atan2fN (_FloatN Y, _FloatN X) |
| -- Function: _FloatNx atan2fNx (_FloatNx Y, _FloatNx X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This function computes the arctangent of Y/X, but the signs of |
| both arguments are used to determine the quadrant of the result, |
| and X is permitted to be zero. The return value is given in |
| radians and is in the range `-pi' to `pi', inclusive. |
| |
| If X and Y are coordinates of a point in the plane, `atan2' |
| returns the signed angle between the line from the origin to that |
| point and the x-axis. Thus, `atan2' is useful for converting |
| Cartesian coordinates to polar coordinates. (To compute the |
| radial coordinate, use `hypot'; see *note Exponents and |
| Logarithms::.) |
| |
| If both X and Y are zero, `atan2' returns zero. |
| |
| ISO C99 defines complex versions of the inverse trig functions. |
| |
| -- Function: complex double casin (complex double Z) |
| -- Function: complex float casinf (complex float Z) |
| -- Function: complex long double casinl (complex long double Z) |
| -- Function: complex _FloatN casinfN (complex _FloatN Z) |
| -- Function: complex _FloatNx casinfNx (complex _FloatNx Z) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions compute the complex arcsine of Z--that is, the |
| value whose sine is Z. The value returned is in radians. |
| |
| Unlike the real-valued functions, `casin' is defined for all |
| values of Z. |
| |
| -- Function: complex double cacos (complex double Z) |
| -- Function: complex float cacosf (complex float Z) |
| -- Function: complex long double cacosl (complex long double Z) |
| -- Function: complex _FloatN cacosfN (complex _FloatN Z) |
| -- Function: complex _FloatNx cacosfNx (complex _FloatNx Z) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions compute the complex arccosine of Z--that is, the |
| value whose cosine is Z. The value returned is in radians. |
| |
| Unlike the real-valued functions, `cacos' is defined for all |
| values of Z. |
| |
| -- Function: complex double catan (complex double Z) |
| -- Function: complex float catanf (complex float Z) |
| -- Function: complex long double catanl (complex long double Z) |
| -- Function: complex _FloatN catanfN (complex _FloatN Z) |
| -- Function: complex _FloatNx catanfNx (complex _FloatNx Z) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions compute the complex arctangent of Z--that is, the |
| value whose tangent is Z. The value is in units of radians. |
| |
| |
| File: libc.info, Node: Exponents and Logarithms, Next: Hyperbolic Functions, Prev: Inverse Trig Functions, Up: Mathematics |
| |
| 19.4 Exponentiation and Logarithms |
| ================================== |
| |
| -- Function: double exp (double X) |
| -- Function: float expf (float X) |
| -- Function: long double expl (long double X) |
| -- Function: _FloatN expfN (_FloatN X) |
| -- Function: _FloatNx expfNx (_FloatNx X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions compute `e' (the base of natural logarithms) raised |
| to the power X. |
| |
| If the magnitude of the result is too large to be representable, |
| `exp' signals overflow. |
| |
| -- Function: double exp2 (double X) |
| -- Function: float exp2f (float X) |
| -- Function: long double exp2l (long double X) |
| -- Function: _FloatN exp2fN (_FloatN X) |
| -- Function: _FloatNx exp2fNx (_FloatNx X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions compute `2' raised to the power X. |
| Mathematically, `exp2 (x)' is the same as `exp (x * log (2))'. |
| |
| -- Function: double exp10 (double X) |
| -- Function: float exp10f (float X) |
| -- Function: long double exp10l (long double X) |
| -- Function: _FloatN exp10fN (_FloatN X) |
| -- Function: _FloatNx exp10fNx (_FloatNx X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions compute `10' raised to the power X. |
| Mathematically, `exp10 (x)' is the same as `exp (x * log (10))'. |
| |
| The `exp10' functions are from TS 18661-4:2015. |
| |
| -- Function: double log (double X) |
| -- Function: float logf (float X) |
| -- Function: long double logl (long double X) |
| -- Function: _FloatN logfN (_FloatN X) |
| -- Function: _FloatNx logfNx (_FloatNx X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions compute the natural logarithm of X. `exp (log |
| (X))' equals X, exactly in mathematics and approximately in C. |
| |
| If X is negative, `log' signals a domain error. If X is zero, it |
| returns negative infinity; if X is too close to zero, it may |
| signal overflow. |
| |
| -- Function: double log10 (double X) |
| -- Function: float log10f (float X) |
| -- Function: long double log10l (long double X) |
| -- Function: _FloatN log10fN (_FloatN X) |
| -- Function: _FloatNx log10fNx (_FloatNx X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions return the base-10 logarithm of X. `log10 (X)' |
| equals `log (X) / log (10)'. |
| |
| |
| -- Function: double log2 (double X) |
| -- Function: float log2f (float X) |
| -- Function: long double log2l (long double X) |
| -- Function: _FloatN log2fN (_FloatN X) |
| -- Function: _FloatNx log2fNx (_FloatNx X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions return the base-2 logarithm of X. `log2 (X)' |
| equals `log (X) / log (2)'. |
| |
| -- Function: double logb (double X) |
| -- Function: float logbf (float X) |
| -- Function: long double logbl (long double X) |
| -- Function: _FloatN logbfN (_FloatN X) |
| -- Function: _FloatNx logbfNx (_FloatNx X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions extract the exponent of X and return it as a |
| floating-point value. If `FLT_RADIX' is two, `logb' is equal to |
| `floor (log2 (x))', except it's probably faster. |
| |
| If X is de-normalized, `logb' returns the exponent X would have if |
| it were normalized. If X is infinity (positive or negative), |
| `logb' returns oo. If X is zero, `logb' returns oo. It does not |
| signal. |
| |
| -- Function: int ilogb (double X) |
| -- Function: int ilogbf (float X) |
| -- Function: int ilogbl (long double X) |
| -- Function: int ilogbfN (_FloatN X) |
| -- Function: int ilogbfNx (_FloatNx X) |
| -- Function: long int llogb (double X) |
| -- Function: long int llogbf (float X) |
| -- Function: long int llogbl (long double X) |
| -- Function: long int llogbfN (_FloatN X) |
| -- Function: long int llogbfNx (_FloatNx X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions are equivalent to the corresponding `logb' |
| functions except that they return signed integer values. The |
| `ilogb', `ilogbf', and `ilogbl' functions are from ISO C99; the |
| `llogb', `llogbf', `llogbl' functions are from TS 18661-1:2014; |
| the `ilogbfN', `ilogbfNx', `llogbfN', and `llogbfNx' functions are |
| from TS 18661-3:2015. |
| |
| Since integers cannot represent infinity and NaN, `ilogb' instead |
| returns an integer that can't be the exponent of a normal floating-point |
| number. `math.h' defines constants so you can check for this. |
| |
| -- Macro: int FP_ILOGB0 |
| `ilogb' returns this value if its argument is `0'. The numeric |
| value is either `INT_MIN' or `-INT_MAX'. |
| |
| This macro is defined in ISO C99. |
| |
| -- Macro: long int FP_LLOGB0 |
| `llogb' returns this value if its argument is `0'. The numeric |
| value is either `LONG_MIN' or `-LONG_MAX'. |
| |
| This macro is defined in TS 18661-1:2014. |
| |
| -- Macro: int FP_ILOGBNAN |
| `ilogb' returns this value if its argument is `NaN'. The numeric |
| value is either `INT_MIN' or `INT_MAX'. |
| |
| This macro is defined in ISO C99. |
| |
| -- Macro: long int FP_LLOGBNAN |
| `llogb' returns this value if its argument is `NaN'. The numeric |
| value is either `LONG_MIN' or `LONG_MAX'. |
| |
| This macro is defined in TS 18661-1:2014. |
| |
| These values are system specific. They might even be the same. The |
| proper way to test the result of `ilogb' is as follows: |
| |
| i = ilogb (f); |
| if (i == FP_ILOGB0 || i == FP_ILOGBNAN) |
| { |
| if (isnan (f)) |
| { |
| /* Handle NaN. */ |
| } |
| else if (f == 0.0) |
| { |
| /* Handle 0.0. */ |
| } |
| else |
| { |
| /* Some other value with large exponent, |
| perhaps +Inf. */ |
| } |
| } |
| |
| -- Function: double pow (double BASE, double POWER) |
| -- Function: float powf (float BASE, float POWER) |
| -- Function: long double powl (long double BASE, long double POWER) |
| -- Function: _FloatN powfN (_FloatN BASE, _FloatN POWER) |
| -- Function: _FloatNx powfNx (_FloatNx BASE, _FloatNx POWER) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These are general exponentiation functions, returning BASE raised |
| to POWER. |
| |
| Mathematically, `pow' would return a complex number when BASE is |
| negative and POWER is not an integral value. `pow' can't do that, |
| so instead it signals a domain error. `pow' may also underflow or |
| overflow the destination type. |
| |
| -- Function: double sqrt (double X) |
| -- Function: float sqrtf (float X) |
| -- Function: long double sqrtl (long double X) |
| -- Function: _FloatN sqrtfN (_FloatN X) |
| -- Function: _FloatNx sqrtfNx (_FloatNx X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions return the nonnegative square root of X. |
| |
| If X is negative, `sqrt' signals a domain error. Mathematically, |
| it should return a complex number. |
| |
| -- Function: double cbrt (double X) |
| -- Function: float cbrtf (float X) |
| -- Function: long double cbrtl (long double X) |
| -- Function: _FloatN cbrtfN (_FloatN X) |
| -- Function: _FloatNx cbrtfNx (_FloatNx X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions return the cube root of X. They cannot fail; |
| every representable real value has a representable real cube root. |
| |
| -- Function: double hypot (double X, double Y) |
| -- Function: float hypotf (float X, float Y) |
| -- Function: long double hypotl (long double X, long double Y) |
| -- Function: _FloatN hypotfN (_FloatN X, _FloatN Y) |
| -- Function: _FloatNx hypotfNx (_FloatNx X, _FloatNx Y) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions return `sqrt (X*X + Y*Y)'. This is the length of |
| the hypotenuse of a right triangle with sides of length X and Y, |
| or the distance of the point (X, Y) from the origin. Using this |
| function instead of the direct formula is wise, since the error is |
| much smaller. See also the function `cabs' in *note Absolute |
| Value::. |
| |
| -- Function: double expm1 (double X) |
| -- Function: float expm1f (float X) |
| -- Function: long double expm1l (long double X) |
| -- Function: _FloatN expm1fN (_FloatN X) |
| -- Function: _FloatNx expm1fNx (_FloatNx X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions return a value equivalent to `exp (X) - 1'. They |
| are computed in a way that is accurate even if X is near zero--a |
| case where `exp (X) - 1' would be inaccurate owing to subtraction |
| of two numbers that are nearly equal. |
| |
| -- Function: double log1p (double X) |
| -- Function: float log1pf (float X) |
| -- Function: long double log1pl (long double X) |
| -- Function: _FloatN log1pfN (_FloatN X) |
| -- Function: _FloatNx log1pfNx (_FloatNx X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions return a value equivalent to `log (1 + X)'. They |
| are computed in a way that is accurate even if X is near zero. |
| |
| ISO C99 defines complex variants of some of the exponentiation and |
| logarithm functions. |
| |
| -- Function: complex double cexp (complex double Z) |
| -- Function: complex float cexpf (complex float Z) |
| -- Function: complex long double cexpl (complex long double Z) |
| -- Function: complex _FloatN cexpfN (complex _FloatN Z) |
| -- Function: complex _FloatNx cexpfNx (complex _FloatNx Z) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions return `e' (the base of natural logarithms) raised |
| to the power of Z. Mathematically, this corresponds to the value |
| |
| exp (z) = exp (creal (z)) * (cos (cimag (z)) + I * sin (cimag (z))) |
| |
| -- Function: complex double clog (complex double Z) |
| -- Function: complex float clogf (complex float Z) |
| -- Function: complex long double clogl (complex long double Z) |
| -- Function: complex _FloatN clogfN (complex _FloatN Z) |
| -- Function: complex _FloatNx clogfNx (complex _FloatNx Z) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions return the natural logarithm of Z. |
| Mathematically, this corresponds to the value |
| |
| log (z) = log (cabs (z)) + I * carg (z) |
| |
| `clog' has a pole at 0, and will signal overflow if Z equals or is |
| very close to 0. It is well-defined for all other values of Z. |
| |
| -- Function: complex double clog10 (complex double Z) |
| -- Function: complex float clog10f (complex float Z) |
| -- Function: complex long double clog10l (complex long double Z) |
| -- Function: complex _FloatN clog10fN (complex _FloatN Z) |
| -- Function: complex _FloatNx clog10fNx (complex _FloatNx Z) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions return the base 10 logarithm of the complex value |
| Z. Mathematically, this corresponds to the value |
| |
| log10 (z) = log10 (cabs (z)) + I * carg (z) / log (10) |
| |
| All these functions, including the `_FloatN' and `_FloatNx' |
| variants, are GNU extensions. |
| |
| -- Function: complex double csqrt (complex double Z) |
| -- Function: complex float csqrtf (complex float Z) |
| -- Function: complex long double csqrtl (complex long double Z) |
| -- Function: complex _FloatN csqrtfN (_FloatN Z) |
| -- Function: complex _FloatNx csqrtfNx (complex _FloatNx Z) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions return the complex square root of the argument Z. |
| Unlike the real-valued functions, they are defined for all values |
| of Z. |
| |
| -- Function: complex double cpow (complex double BASE, complex double |
| POWER) |
| -- Function: complex float cpowf (complex float BASE, complex float |
| POWER) |
| -- Function: complex long double cpowl (complex long double BASE, |
| complex long double POWER) |
| -- Function: complex _FloatN cpowfN (complex _FloatN BASE, complex |
| _FloatN POWER) |
| -- Function: complex _FloatNx cpowfNx (complex _FloatNx BASE, complex |
| _FloatNx POWER) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions return BASE raised to the power of POWER. This is |
| equivalent to `cexp (y * clog (x))' |
| |
| |
| File: libc.info, Node: Hyperbolic Functions, Next: Special Functions, Prev: Exponents and Logarithms, Up: Mathematics |
| |
| 19.5 Hyperbolic Functions |
| ========================= |
| |
| The functions in this section are related to the exponential functions; |
| see *note Exponents and Logarithms::. |
| |
| -- Function: double sinh (double X) |
| -- Function: float sinhf (float X) |
| -- Function: long double sinhl (long double X) |
| -- Function: _FloatN sinhfN (_FloatN X) |
| -- Function: _FloatNx sinhfNx (_FloatNx X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions return the hyperbolic sine of X, defined |
| mathematically as `(exp (X) - exp (-X)) / 2'. They may signal |
| overflow if X is too large. |
| |
| -- Function: double cosh (double X) |
| -- Function: float coshf (float X) |
| -- Function: long double coshl (long double X) |
| -- Function: _FloatN coshfN (_FloatN X) |
| -- Function: _FloatNx coshfNx (_FloatNx X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions return the hyperbolic cosine of X, defined |
| mathematically as `(exp (X) + exp (-X)) / 2'. They may signal |
| overflow if X is too large. |
| |
| -- Function: double tanh (double X) |
| -- Function: float tanhf (float X) |
| -- Function: long double tanhl (long double X) |
| -- Function: _FloatN tanhfN (_FloatN X) |
| -- Function: _FloatNx tanhfNx (_FloatNx X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions return the hyperbolic tangent of X, defined |
| mathematically as `sinh (X) / cosh (X)'. They may signal overflow |
| if X is too large. |
| |
| There are counterparts for the hyperbolic functions which take |
| complex arguments. |
| |
| -- Function: complex double csinh (complex double Z) |
| -- Function: complex float csinhf (complex float Z) |
| -- Function: complex long double csinhl (complex long double Z) |
| -- Function: complex _FloatN csinhfN (complex _FloatN Z) |
| -- Function: complex _FloatNx csinhfNx (complex _FloatNx Z) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions return the complex hyperbolic sine of Z, defined |
| mathematically as `(exp (Z) - exp (-Z)) / 2'. |
| |
| -- Function: complex double ccosh (complex double Z) |
| -- Function: complex float ccoshf (complex float Z) |
| -- Function: complex long double ccoshl (complex long double Z) |
| -- Function: complex _FloatN ccoshfN (complex _FloatN Z) |
| -- Function: complex _FloatNx ccoshfNx (complex _FloatNx Z) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions return the complex hyperbolic cosine of Z, defined |
| mathematically as `(exp (Z) + exp (-Z)) / 2'. |
| |
| -- Function: complex double ctanh (complex double Z) |
| -- Function: complex float ctanhf (complex float Z) |
| -- Function: complex long double ctanhl (complex long double Z) |
| -- Function: complex _FloatN ctanhfN (complex _FloatN Z) |
| -- Function: complex _FloatNx ctanhfNx (complex _FloatNx Z) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions return the complex hyperbolic tangent of Z, |
| defined mathematically as `csinh (Z) / ccosh (Z)'. |
| |
| -- Function: double asinh (double X) |
| -- Function: float asinhf (float X) |
| -- Function: long double asinhl (long double X) |
| -- Function: _FloatN asinhfN (_FloatN X) |
| -- Function: _FloatNx asinhfNx (_FloatNx X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions return the inverse hyperbolic sine of X--the value |
| whose hyperbolic sine is X. |
| |
| -- Function: double acosh (double X) |
| -- Function: float acoshf (float X) |
| -- Function: long double acoshl (long double X) |
| -- Function: _FloatN acoshfN (_FloatN X) |
| -- Function: _FloatNx acoshfNx (_FloatNx X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions return the inverse hyperbolic cosine of X--the |
| value whose hyperbolic cosine is X. If X is less than `1', |
| `acosh' signals a domain error. |
| |
| -- Function: double atanh (double X) |
| -- Function: float atanhf (float X) |
| -- Function: long double atanhl (long double X) |
| -- Function: _FloatN atanhfN (_FloatN X) |
| -- Function: _FloatNx atanhfNx (_FloatNx X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions return the inverse hyperbolic tangent of X--the |
| value whose hyperbolic tangent is X. If the absolute value of X |
| is greater than `1', `atanh' signals a domain error; if it is |
| equal to 1, `atanh' returns infinity. |
| |
| -- Function: complex double casinh (complex double Z) |
| -- Function: complex float casinhf (complex float Z) |
| -- Function: complex long double casinhl (complex long double Z) |
| -- Function: complex _FloatN casinhfN (complex _FloatN Z) |
| -- Function: complex _FloatNx casinhfNx (complex _FloatNx Z) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions return the inverse complex hyperbolic sine of |
| Z--the value whose complex hyperbolic sine is Z. |
| |
| -- Function: complex double cacosh (complex double Z) |
| -- Function: complex float cacoshf (complex float Z) |
| -- Function: complex long double cacoshl (complex long double Z) |
| -- Function: complex _FloatN cacoshfN (complex _FloatN Z) |
| -- Function: complex _FloatNx cacoshfNx (complex _FloatNx Z) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions return the inverse complex hyperbolic cosine of |
| Z--the value whose complex hyperbolic cosine is Z. Unlike the |
| real-valued functions, there are no restrictions on the value of Z. |
| |
| -- Function: complex double catanh (complex double Z) |
| -- Function: complex float catanhf (complex float Z) |
| -- Function: complex long double catanhl (complex long double Z) |
| -- Function: complex _FloatN catanhfN (complex _FloatN Z) |
| -- Function: complex _FloatNx catanhfNx (complex _FloatNx Z) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| These functions return the inverse complex hyperbolic tangent of |
| Z--the value whose complex hyperbolic tangent is Z. Unlike the |
| real-valued functions, there are no restrictions on the value of Z. |
| |
| |
| File: libc.info, Node: Special Functions, Next: Errors in Math Functions, Prev: Hyperbolic Functions, Up: Mathematics |
| |
| 19.6 Special Functions |
| ====================== |
| |
| These are some more exotic mathematical functions which are sometimes |
| useful. Currently they only have real-valued versions. |
| |
| -- Function: double erf (double X) |
| -- Function: float erff (float X) |
| -- Function: long double erfl (long double X) |
| -- Function: _FloatN erffN (_FloatN X) |
| -- Function: _FloatNx erffNx (_FloatNx X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| `erf' returns the error function of X. The error function is |
| defined as |
| erf (x) = 2/sqrt(pi) * integral from 0 to x of exp(-t^2) dt |
| |
| -- Function: double erfc (double X) |
| -- Function: float erfcf (float X) |
| -- Function: long double erfcl (long double X) |
| -- Function: _FloatN erfcfN (_FloatN X) |
| -- Function: _FloatNx erfcfNx (_FloatNx X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| `erfc' returns `1.0 - erf(X)', but computed in a fashion that |
| avoids round-off error when X is large. |
| |
| -- Function: double lgamma (double X) |
| -- Function: float lgammaf (float X) |
| -- Function: long double lgammal (long double X) |
| -- Function: _FloatN lgammafN (_FloatN X) |
| -- Function: _FloatNx lgammafNx (_FloatNx X) |
| Preliminary: | MT-Unsafe race:signgam | AS-Unsafe | AC-Safe | |
| *Note POSIX Safety Concepts::. |
| |
| `lgamma' returns the natural logarithm of the absolute value of |
| the gamma function of X. The gamma function is defined as |
| gamma (x) = integral from 0 to oo of t^(x-1) e^-t dt |
| |
| The sign of the gamma function is stored in the global variable |
| SIGNGAM, which is declared in `math.h'. It is `1' if the |
| intermediate result was positive or zero, or `-1' if it was |
| negative. |
| |
| To compute the real gamma function you can use the `tgamma' |
| function or you can compute the values as follows: |
| lgam = lgamma(x); |
| gam = signgam*exp(lgam); |
| |
| The gamma function has singularities at the non-positive integers. |
| `lgamma' will raise the zero divide exception if evaluated at a |
| singularity. |
| |
| -- Function: double lgamma_r (double X, int *SIGNP) |
| -- Function: float lgammaf_r (float X, int *SIGNP) |
| -- Function: long double lgammal_r (long double X, int *SIGNP) |
| -- Function: _FloatN lgammafN_r (_FloatN X, int *SIGNP) |
| -- Function: _FloatNx lgammafNx_r (_FloatNx X, int *SIGNP) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| `lgamma_r' is just like `lgamma', but it stores the sign of the |
| intermediate result in the variable pointed to by SIGNP instead of |
| in the SIGNGAM global. This means it is reentrant. |
| |
| The `lgammafN_r' and `lgammafNx_r' functions are GNU extensions. |
| |
| -- Function: double gamma (double X) |
| -- Function: float gammaf (float X) |
| -- Function: long double gammal (long double X) |
| Preliminary: | MT-Unsafe race:signgam | AS-Unsafe | AC-Safe | |
| *Note POSIX Safety Concepts::. |
| |
| These functions exist for compatibility reasons. They are |
| equivalent to `lgamma' etc. It is better to use `lgamma' since |
| for one the name reflects better the actual computation, and |
| moreover `lgamma' is standardized in ISO C99 while `gamma' is not. |
| |
| -- Function: double tgamma (double X) |
| -- Function: float tgammaf (float X) |
| -- Function: long double tgammal (long double X) |
| -- Function: _FloatN tgammafN (_FloatN X) |
| -- Function: _FloatNx tgammafNx (_FloatNx X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| `tgamma' applies the gamma function to X. The gamma function is |
| defined as |
| gamma (x) = integral from 0 to oo of t^(x-1) e^-t dt |
| |
| This function was introduced in ISO C99. The `_FloatN' and |
| `_FloatNx' variants were introduced in ISO/IEC TS 18661-3. |
| |
| -- Function: double j0 (double X) |
| -- Function: float j0f (float X) |
| -- Function: long double j0l (long double X) |
| -- Function: _FloatN j0fN (_FloatN X) |
| -- Function: _FloatNx j0fNx (_FloatNx X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| `j0' returns the Bessel function of the first kind of order 0 of |
| X. It may signal underflow if X is too large. |
| |
| The `_FloatN' and `_FloatNx' variants are GNU extensions. |
| |
| -- Function: double j1 (double X) |
| -- Function: float j1f (float X) |
| -- Function: long double j1l (long double X) |
| -- Function: _FloatN j1fN (_FloatN X) |
| -- Function: _FloatNx j1fNx (_FloatNx X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| `j1' returns the Bessel function of the first kind of order 1 of |
| X. It may signal underflow if X is too large. |
| |
| The `_FloatN' and `_FloatNx' variants are GNU extensions. |
| |
| -- Function: double jn (int N, double X) |
| -- Function: float jnf (int N, float X) |
| -- Function: long double jnl (int N, long double X) |
| -- Function: _FloatN jnfN (int N, _FloatN X) |
| -- Function: _FloatNx jnfNx (int N, _FloatNx X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| `jn' returns the Bessel function of the first kind of order N of |
| X. It may signal underflow if X is too large. |
| |
| The `_FloatN' and `_FloatNx' variants are GNU extensions. |
| |
| -- Function: double y0 (double X) |
| -- Function: float y0f (float X) |
| -- Function: long double y0l (long double X) |
| -- Function: _FloatN y0fN (_FloatN X) |
| -- Function: _FloatNx y0fNx (_FloatNx X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| `y0' returns the Bessel function of the second kind of order 0 of |
| X. It may signal underflow if X is too large. If X is negative, |
| `y0' signals a domain error; if it is zero, `y0' signals overflow |
| and returns -oo. |
| |
| The `_FloatN' and `_FloatNx' variants are GNU extensions. |
| |
| -- Function: double y1 (double X) |
| -- Function: float y1f (float X) |
| -- Function: long double y1l (long double X) |
| -- Function: _FloatN y1fN (_FloatN X) |
| -- Function: _FloatNx y1fNx (_FloatNx X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| `y1' returns the Bessel function of the second kind of order 1 of |
| X. It may signal underflow if X is too large. If X is negative, |
| `y1' signals a domain error; if it is zero, `y1' signals overflow |
| and returns -oo. |
| |
| The `_FloatN' and `_FloatNx' variants are GNU extensions. |
| |
| -- Function: double yn (int N, double X) |
| -- Function: float ynf (int N, float X) |
| -- Function: long double ynl (int N, long double X) |
| -- Function: _FloatN ynfN (int N, _FloatN X) |
| -- Function: _FloatNx ynfNx (int N, _FloatNx X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| `yn' returns the Bessel function of the second kind of order N of |
| X. It may signal underflow if X is too large. If X is negative, |
| `yn' signals a domain error; if it is zero, `yn' signals overflow |
| and returns -oo. |
| |
| The `_FloatN' and `_FloatNx' variants are GNU extensions. |
| |
| |
| File: libc.info, Node: Errors in Math Functions, Next: Pseudo-Random Numbers, Prev: Special Functions, Up: Mathematics |
| |
| 19.7 Known Maximum Errors in Math Functions |
| =========================================== |
| |
| This section lists the known errors of the functions in the math |
| library. Errors are measured in "units of the last place". This is a |
| measure for the relative error. For a number z with the representation |
| d.d...d*2^e (we assume IEEE floating-point numbers with base 2) the ULP |
| is represented by |
| |
| |d.d...d - (z / 2^e)| / 2^(p - 1) |
| |
| where p is the number of bits in the mantissa of the floating-point |
| number representation. Ideally the error for all functions is always |
| less than 0.5ulps in round-to-nearest mode. Using rounding bits this |
| is also possible and normally implemented for the basic operations. |
| Except for certain functions such as `sqrt', `fma' and `rint' whose |
| results are fully specified by reference to corresponding IEEE 754 |
| floating-point operations, and conversions between strings and floating |
| point, the GNU C Library does not aim for correctly rounded results for |
| functions in the math library, and does not aim for correctness in |
| whether "inexact" exceptions are raised. Instead, the goals for |
| accuracy of functions without fully specified results are as follows; |
| some functions have bugs meaning they do not meet these goals in all |
| cases. In the future, the GNU C Library may provide some other |
| correctly rounding functions under the names such as `crsin' proposed |
| for an extension to ISO C. |
| |
| * Each function with a floating-point result behaves as if it |
| computes an infinite-precision result that is within a few ulp (in |
| both real and complex parts, for functions with complex results) |
| of the mathematically correct value of the function (interpreted |
| together with ISO C or POSIX semantics for the function in |
| question) at the exact value passed as the input. Exceptions are |
| raised appropriately for this value and in accordance with IEEE |
| 754 / ISO C / POSIX semantics, and it is then rounded according to |
| the current rounding direction to the result that is returned to |
| the user. `errno' may also be set (*note Math Error Reporting::). |
| (The "inexact" exception may be raised, or not raised, even if |
| this is inconsistent with the infinite-precision value.) |
| |
| * For the IBM `long double' format, as used on PowerPC GNU/Linux, |
| the accuracy goal is weaker for input values not exactly |
| representable in 106 bits of precision; it is as if the input |
| value is some value within 0.5ulp of the value actually passed, |
| where "ulp" is interpreted in terms of a fixed-precision 106-bit |
| mantissa, but not necessarily the exact value actually passed with |
| discontiguous mantissa bits. |
| |
| * For the IBM `long double' format, functions whose results are |
| fully specified by reference to corresponding IEEE 754 |
| floating-point operations have the same accuracy goals as other |
| functions, but with the error bound being the same as that for |
| division (3ulp). Furthermore, "inexact" and "underflow" |
| exceptions may be raised for all functions for any inputs, even |
| where such exceptions are inconsistent with the returned value, |
| since the underlying floating-point arithmetic has that property. |
| |
| * Functions behave as if the infinite-precision result computed is |
| zero, infinity or NaN if and only if that is the mathematically |
| correct infinite-precision result. They behave as if the |
| infinite-precision result computed always has the same sign as the |
| mathematically correct result. |
| |
| * If the mathematical result is more than a few ulp above the |
| overflow threshold for the current rounding direction, the value |
| returned is the appropriate overflow value for the current |
| rounding direction, with the overflow exception raised. |
| |
| * If the mathematical result has magnitude well below half the least |
| subnormal magnitude, the returned value is either zero or the least |
| subnormal (in each case, with the correct sign), according to the |
| current rounding direction and with the underflow exception raised. |
| |
| * Where the mathematical result underflows (before rounding) and is |
| not exactly representable as a floating-point value, the function |
| does not behave as if the computed infinite-precision result is an |
| exact value in the subnormal range. This means that the underflow |
| exception is raised other than possibly for cases where the |
| mathematical result is very close to the underflow threshold and |
| the function behaves as if it computes an infinite-precision |
| result that does not underflow. (So there may be spurious |
| underflow exceptions in cases where the underflowing result is |
| exact, but not missing underflow exceptions in cases where it is |
| inexact.) |
| |
| * The GNU C Library does not aim for functions to satisfy other |
| properties of the underlying mathematical function, such as |
| monotonicity, where not implied by the above goals. |
| |
| * All the above applies to both real and complex parts, for complex |
| functions. |
| |
| |
| Therefore many of the functions in the math library have errors. The |
| table lists the maximum error for each function which is exposed by one |
| of the existing tests in the test suite. The table tries to cover as |
| much as possible and list the actual maximum error (or at least a |
| ballpark figure) but this is often not achieved due to the large search |
| space. |
| |
| The table lists the ULP values for different architectures. |
| Different architectures have different results since their hardware |
| support for floating-point operations varies and also the existing |
| hardware support is different. Only the round-to-nearest rounding mode |
| is covered by this table, and vector versions of functions are not |
| covered. Functions not listed do not have known errors. |
| |
| Function AArch64 ARM Alpha CSKY CSKY soft-float |
| acosf 1 1 1 1 1 |
| acos - - - - - |
| acosl 1 - 1 - - |
| acosf128 - - - - - |
| acoshf 2 2 2 2 2 |
| acosh 2 2 2 2 2 |
| acoshl 2 - 2 - - |
| acoshf128 - - - - - |
| add_ldoublef - - - - - |
| add_ldouble - - - - - |
| add_ldoublel - - - - - |
| add_ldoublef128- - - - - |
| asinf 1 1 1 1 1 |
| asin - - - - - |
| asinl 1 - 1 - - |
| asinf128 - - - - - |
| asinhf 1 1 1 1 1 |
| asinh 1 1 1 1 1 |
| asinhl 3 - 3 - - |
| asinhf128 - - - - - |
| atanf 1 1 1 1 1 |
| atan 1 - - - - |
| atanl 1 - 1 - - |
| atanf128 - - - - - |
| atan2f 1 1 1 1 1 |
| atan2 - - - - - |
| atan2l 1 - 1 - - |
| atan2f128 - - - - - |
| atanhf 2 2 2 2 2 |
| atanh 2 2 2 2 2 |
| atanhl 3 - 3 - - |
| atanhf128 - - - - - |
| cabsf - - - - - |
| cabs 1 1 1 1 1 |
| cabsl 1 - 1 - - |
| cabsf128 - - - - - |
| cacosf 2 + i 2 2 + i 2 2 + i 2 2 + i 2 2 + i 2 |
| cacos 1 + i 2 1 + i 2 1 + i 2 1 + i 2 1 + i 2 |
| cacosl 2 + i 2 - 2 + i 2 - - |
| cacosf128 - - - - - |
| cacoshf 2 + i 2 2 + i 2 2 + i 2 2 + i 2 2 + i 2 |
| cacosh 2 + i 1 2 + i 1 2 + i 1 2 + i 1 2 + i 1 |
| cacoshl 2 + i 2 - 2 + i 2 - - |
| cacoshf128 - - - - - |
| cargf 1 1 1 1 1 |
| carg 1 - - - - |
| cargl 2 - 2 - - |
| cargf128 - - - - - |
| casinf 1 + i 2 1 + i 2 1 + i 2 1 + i 2 1 + i 2 |
| casin 1 + i 2 1 + i 2 1 + i 2 1 + i 2 1 + i 2 |
| casinl 2 + i 2 - 2 + i 2 - - |
| casinf128 - - - - - |
| casinhf 2 + i 1 2 + i 1 2 + i 1 2 + i 1 2 + i 1 |
| casinh 2 + i 1 2 + i 1 2 + i 1 2 + i 1 2 + i 1 |
| casinhl 2 + i 2 - 2 + i 2 - - |
| casinhf128 - - - - - |
| catanf 1 + i 1 1 + i 1 1 + i 1 1 + i 1 1 + i 1 |
| catan 1 + i 1 1 + i 1 1 + i 1 1 + i 1 1 + i 1 |
| catanl 1 + i 1 - 1 + i 1 - - |
| catanf128 - - - - - |
| catanhf 1 + i 1 1 + i 1 1 + i 1 1 + i 1 1 + i 1 |
| catanh 1 + i 1 1 + i 1 1 + i 1 1 + i 1 1 + i 1 |
| catanhl 1 + i 1 - 1 + i 1 - - |
| catanhf128 - - - - - |
| cbrtf 1 1 1 1 1 |
| cbrt 3 3 3 3 3 |
| cbrtl 1 - 1 - - |
| cbrtf128 - - - - - |
| ccosf 1 + i 1 1 + i 1 1 + i 1 1 + i 1 1 + i 1 |
| ccos 1 + i 1 1 + i 1 1 + i 1 1 + i 1 1 + i 1 |
| ccosl 1 + i 1 - 1 + i 1 - - |
| ccosf128 - - - - - |
| ccoshf 1 + i 1 1 + i 1 1 + i 1 1 + i 1 1 + i 1 |
| ccosh 1 + i 1 1 + i 1 1 + i 1 1 + i 1 1 + i 1 |
| ccoshl 1 + i 1 - 1 + i 1 - - |
| ccoshf128 - - - - - |
| cexpf 1 + i 2 1 + i 2 1 + i 2 1 + i 2 1 + i 2 |
| cexp 2 + i 1 2 + i 1 2 + i 1 2 + i 1 2 + i 1 |
| cexpl 1 + i 1 - 1 + i 1 - - |
| cexpf128 - - - - - |
| clogf 3 + i 1 3 + i 1 3 + i 1 3 + i 1 3 + i 1 |
| clog 3 + i 1 3 + i 0 3 + i 0 3 + i 0 3 + i 0 |
| clogl 2 + i 1 - 2 + i 1 - - |
| clogf128 - - - - - |
| clog10f 4 + i 2 4 + i 2 4 + i 2 4 + i 2 4 + i 2 |
| clog10 3 + i 2 3 + i 2 3 + i 2 3 + i 2 3 + i 2 |
| clog10l 2 + i 2 - 2 + i 2 - - |
| clog10f128 - - - - - |
| cosf 1 1 1 - 1 |
| cos 1 1 1 1 1 |
| cosl 1 - 1 - - |
| cosf128 - - - - - |
| coshf 1 1 1 1 1 |
| cosh 1 1 1 1 1 |
| coshl 1 - 1 - - |
| coshf128 - - - - - |
| cpowf 5 + i 2 5 + i 2 5 + i 2 5 + i 2 5 + i 2 |
| cpow 2 + i 0 2 + i 0 2 + i 0 2 + i 0 2 + i 0 |
| cpowl 4 + i 1 - 4 + i 1 - - |
| cpowf128 - - - - - |
| csinf 1 + i 0 1 + i 0 1 + i 0 1 + i 0 1 + i 0 |
| csin 1 + i 0 1 + i 0 1 + i 0 1 + i 0 1 + i 0 |
| csinl 1 + i 1 - 1 + i 1 - - |
| csinf128 - - - - - |
| csinhf 1 + i 1 1 + i 1 1 + i 1 1 + i 1 1 + i 1 |
| csinh 0 + i 1 0 + i 1 0 + i 1 0 + i 1 0 + i 1 |
| csinhl 1 + i 1 - 1 + i 1 - - |
| csinhf128 - - - - - |
| csqrtf 2 + i 2 2 + i 2 2 + i 2 2 + i 2 2 + i 2 |
| csqrt 2 + i 2 2 + i 2 2 + i 2 2 + i 2 2 + i 2 |
| csqrtl 2 + i 2 - 2 + i 2 - - |
| csqrtf128 - - - - - |
| ctanf 1 + i 2 1 + i 2 1 + i 2 1 + i 2 1 + i 2 |
| ctan 1 + i 2 1 + i 2 1 + i 2 1 + i 2 1 + i 2 |
| ctanl 3 + i 3 - 3 + i 3 - - |
| ctanf128 - - - - - |
| ctanhf 2 + i 1 2 + i 2 2 + i 2 2 + i 2 2 + i 2 |
| ctanh 2 + i 2 2 + i 2 2 + i 2 2 + i 2 2 + i 2 |
| ctanhl 3 + i 3 - 3 + i 3 - - |
| ctanhf128 - - - - - |
| div_ldoublef - - - - - |
| div_ldouble - - - - - |
| div_ldoublel - - - - - |
| div_ldoublef128- - - - - |
| erff 1 1 1 1 1 |
| erf 1 1 1 1 1 |
| erfl 1 - 1 - - |
| erff128 - - - - - |
| erfcf 2 2 2 2 2 |
| erfc 2 3 3 3 3 |
| erfcl 2 - 2 - - |
| erfcf128 - - - - - |
| expf 1 1 1 - 1 |
| exp - - - - - |
| expl 1 - 1 - - |
| expf128 - - - - - |
| exp10f - - - - - |
| exp10 2 2 2 2 2 |
| exp10l 2 - 2 - - |
| exp10f128 - - - - - |
| exp2f 1 1 1 - 1 |
| exp2 1 1 1 1 1 |
| exp2l 1 - 1 - - |
| exp2f128 - - - - - |
| expm1f 1 1 1 1 1 |
| expm1 1 1 1 1 1 |
| expm1l 1 - 1 - - |
| expm1f128 - - - - - |
| fmaf - - - - - |
| fma - - - - - |
| fmal - - - - - |
| fmaf128 - - - - - |
| fmodf - - - - - |
| fmod - - - - - |
| fmodl - - - - - |
| fmodf128 - - - - - |
| gammaf 4 4 4 3 4 |
| gamma 3 4 4 4 4 |
| gammal 5 - 5 - - |
| gammaf128 - - - - - |
| hypotf - - - - - |
| hypot 1 1 1 1 1 |
| hypotl 1 - 1 - - |
| hypotf128 - - - - - |
| j0f 2 2 2 2 2 |
| j0 2 2 2 2 2 |
| j0l 2 - 2 - - |
| j0f128 - - - - - |
| j1f 2 2 2 2 2 |
| j1 1 1 1 1 1 |
| j1l 4 - 4 - - |
| j1f128 - - - - - |
| jnf 4 4 4 4 4 |
| jn 4 4 4 4 4 |
| jnl 7 - 7 - - |
| jnf128 - - - - - |
| lgammaf 4 4 4 3 4 |
| lgamma 3 4 4 4 4 |
| lgammal 5 - 5 - - |
| lgammaf128 - - - - - |
| logf 1 1 1 - 1 |
| log - - - - - |
| logl 1 - 1 - - |
| logf128 - - - - - |
| log10f 2 2 2 2 2 |
| log10 2 2 2 2 2 |
| log10l 1 - 1 - - |
| log10f128 - - - - - |
| log1pf 1 1 1 1 1 |
| log1p 1 1 1 1 1 |
| log1pl 2 - 2 - - |
| log1pf128 - - - - - |
| log2f 1 1 1 1 1 |
| log2 1 2 2 2 2 |
| log2l 2 - 2 - - |
| log2f128 - - - - - |
| mul_ldoublef - - - - - |
| mul_ldouble - - - - - |
| mul_ldoublel - - - - - |
| mul_ldoublef128- - - - - |
| powf 1 1 1 - 1 |
| pow 1 1 1 1 1 |
| powl 2 - 2 - - |
| powf128 - - - - - |
| pow10f - - - - - |
| pow10 - - - - 2 |
| pow10l - - - - - |
| pow10f128 - - - - - |
| sinf 1 1 1 - 1 |
| sin 1 1 1 1 1 |
| sinl 1 - 1 - - |
| sinf128 - - - - - |
| sincosf 1 1 1 - 1 |
| sincos 1 1 1 1 1 |
| sincosl 1 - 1 - - |
| sincosf128 - - - - - |
| sinhf 2 2 2 2 2 |
| sinh 2 2 2 2 2 |
| sinhl 2 - 2 - - |
| sinhf128 - - - - - |
| sqrtf - - - - - |
| sqrt - - - - - |
| sqrtl - - - - - |
| sqrtf128 - - - - - |
| sub_ldoublef - - - - - |
| sub_ldouble - - - - - |
| sub_ldoublel - - - - - |
| sub_ldoublef128- - - - - |
| tanf 1 1 1 1 1 |
| tan - - - - - |
| tanl 1 - 1 - - |
| tanf128 - - - - - |
| tanhf 2 2 2 2 2 |
| tanh 2 2 2 2 2 |
| tanhl 2 - 2 - - |
| tanhf128 - - - - - |
| tgammaf 4 4 4 4 4 |
| tgamma 5 5 5 5 5 |
| tgammal 4 - 4 - - |
| tgammaf128 - - - - - |
| y0f 1 1 1 1 1 |
| y0 2 2 2 2 2 |
| y0l 3 - 3 - - |
| y0f128 - - - - - |
| y1f 2 2 2 2 2 |
| y1 3 3 3 3 3 |
| y1l 2 - 2 - - |
| y1f128 - - - - - |
| ynf 3 3 3 3 3 |
| yn 3 3 3 3 3 |
| ynl 5 - 5 - - |
| ynf128 - - - - - |
| |
| Function ColdFire Generic HPPA IA64 M68k |
| acosf - - 1 - - |
| acos - - - 1 - |
| acosl - - - - - |
| acosf128 - - - 1 - |
| acoshf - - 2 - 1 |
| acosh - - 2 1 1 |
| acoshl - - - 1 1 |
| acoshf128 - - - 2 - |
| add_ldoublef - - - - - |
| add_ldouble - - - - - |
| add_ldoublel - - - - - |
| add_ldoublef128- - - - - |
| asinf - - 1 - - |
| asin - - - - - |
| asinl - - - - - |
| asinf128 - - - 1 - |
| asinhf - - 1 - 1 |
| asinh - - 1 1 1 |
| asinhl - - - - 1 |
| asinhf128 - - - 3 - |
| atanf - - 1 - - |
| atan - - - - - |
| atanl - - - - - |
| atanf128 - - - 1 - |
| atan2f 1 - 1 - 1 |
| atan2 - - - - - |
| atan2l - - - - 1 |
| atan2f128 - - - 1 - |
| atanhf 1 - 2 - - |
| atanh - - 2 - - |
| atanhl - - - - - |
| atanhf128 - - - 3 - |
| cabsf - - - - - |
| cabs - - 1 - 1 |
| cabsl - - - - 1 |
| cabsf128 - - - 1 - |
| cacosf - - 2 + i 2 2 + i 2 2 + i 1 |
| cacos - - 1 + i 2 1 + i 2 1 + i 1 |
| cacosl - - - 1 + i 2 1 + i 2 |
| cacosf128 - - - 2 + i 2 - |
| cacoshf 0 + i 1 - 2 + i 2 2 + i 2 1 + i 2 |
| cacosh - - 2 + i 1 2 + i 1 1 + i 1 |
| cacoshl - - - 2 + i 1 2 + i 1 |
| cacoshf128 - - - 2 + i 2 - |
| cargf - - 1 - 1 |
| carg - - - - - |
| cargl - - - - 1 |
| cargf128 - - - 2 - |
| casinf 1 + i 0 - 1 + i 2 1 + i 2 1 + i 1 |
| casin 1 + i 0 - 1 + i 2 1 + i 2 1 + i 1 |
| casinl - - 1 + i 0 1 + i 2 1 + i 2 |
| casinf128 - - - 2 + i 2 - |
| casinhf 1 + i 6 - 2 + i 1 2 + i 1 1 + i 1 |
| casinh 5 + i 3 - 5 + i 3 2 + i 1 1 + i 1 |
| casinhl - - 5 + i 3 2 + i 1 2 + i 1 |
| casinhf128 - - - 2 + i 2 - |
| catanf 0 + i 1 - 1 + i 1 0 + i 1 0 + i 1 |
| catan 0 + i 1 - 1 + i 1 1 + i 1 0 + i 1 |
| catanl - - 0 + i 1 0 + i 1 1 + i 1 |
| catanf128 - - - 1 + i 1 - |
| catanhf - - 1 + i 1 1 + i 0 1 + i 0 |
| catanh 4 + i 0 - 4 + i 1 1 + i 1 1 + i 0 |
| catanhl - - 4 + i 0 1 + i 0 1 + i 1 |
| catanhf128 - - - 1 + i 1 - |
| cbrtf - - 1 - 1 |
| cbrt 1 - 3 - 1 |
| cbrtl - - 1 - 1 |
| cbrtf128 - - - 1 - |
| ccosf 1 + i 1 - 1 + i 1 0 + i 1 - |
| ccos 1 + i 0 - 1 + i 1 1 + i 1 - |
| ccosl - - 1 + i 0 1 + i 1 1 + i 1 |
| ccosf128 - - - 1 + i 1 - |
| ccoshf 1 + i 1 - 1 + i 1 1 + i 1 - |
| ccosh 1 + i 0 - 1 + i 1 1 + i 1 - |
| ccoshl - - 1 + i 0 0 + i 1 0 + i 1 |
| ccoshf128 - - - 1 + i 1 - |
| cexpf 1 + i 1 - 1 + i 2 1 + i 2 - |
| cexp - - 2 + i 1 2 + i 1 - |
| cexpl - - - 1 + i 1 1 + i 1 |
| cexpf128 - - - 1 + i 1 - |
| clogf 1 + i 0 - 3 + i 1 3 + i 0 2 + i 1 |
| clog - - 3 + i 0 2 + i 1 3 + i 1 |
| clogl - - - 2 + i 1 3 + i 1 |
| clogf128 - - - 2 + i 1 - |
| clog10f 1 + i 1 - 4 + i 2 4 + i 1 2 + i 1 |
| clog10 0 + i 1 - 3 + i 2 3 + i 2 2 + i 1 |
| clog10l - - 0 + i 1 2 + i 1 3 + i 2 |
| clog10f128 - - - 2 + i 2 - |
| cosf 1 - 1 - - |
| cos 2 - 2 1 1 |
| cosl - - 2 - - |
| cosf128 - - - 1 - |
| coshf - - 1 - - |
| cosh - - 1 - - |
| coshl - - - - - |
| coshf128 - - - 1 - |
| cpowf 4 + i 2 - 5 + i 2 5 + i 2 3 + i 5 |
| cpow 2 + i 2 - 2 + i 2 2 + i 0 1 + i 0 |
| cpowl - - 2 + i 2 3 + i 4 3 + i 1 |
| cpowf128 - - - 4 + i 1 - |
| csinf - - 1 + i 0 1 + i 1 - |
| csin - - 1 + i 0 1 + i 0 - |
| csinl - - - 1 + i 0 1 + i 0 |
| csinf128 - - - 1 + i 1 - |
| csinhf 1 + i 1 - 1 + i 1 1 + i 1 - |
| csinh 0 + i 1 - 0 + i 1 1 + i 1 - |
| csinhl - - 0 + i 1 1 + i 1 1 + i 0 |
| csinhf128 - - - 1 + i 1 - |
| csqrtf 1 + i 0 - 2 + i 2 2 + i 2 1 + i 1 |
| csqrt - - 2 + i 2 2 + i 2 1 + i 1 |
| csqrtl - - - 2 + i 2 2 + i 2 |
| csqrtf128 - - - 2 + i 2 - |
| ctanf - - 1 + i 2 1 + i 1 1 + i 1 |
| ctan 0 + i 1 - 1 + i 2 1 + i 2 1 + i 1 |
| ctanl - - 0 + i 1 2 + i 2 2 + i 2 |
| ctanf128 - - - 3 + i 3 - |
| ctanhf 2 + i 1 - 2 + i 2 1 + i 1 1 + i 2 |
| ctanh 1 + i 0 - 2 + i 2 2 + i 2 1 + i 1 |
| ctanhl - - 1 + i 0 1 + i 2 2 + i 2 |
| ctanhf128 - - - 3 + i 3 - |
| div_ldoublef - - - - - |
| div_ldouble - - - - - |
| div_ldoublel - - - - - |
| div_ldoublef128- - - - - |
| erff - - 1 - 1 |
| erf 1 - 1 - - |
| erfl - - 1 - 1 |
| erff128 - - - 1 - |
| erfcf - - 2 - 1 |
| erfc 1 - 3 - - |
| erfcl - - 1 - 2 |
| erfcf128 - - - 2 - |
| expf - - 1 1 - |
| exp - - - - - |
| expl - - - - - |
| expf128 - - - 1 - |
| exp10f 2 - 2 - - |
| exp10 6 - 6 - - |
| exp10l - - 6 - - |
| exp10f128 - - - 2 - |
| exp2f - - 1 - - |
| exp2 - - 1 1 1 |
| exp2l - - - 1 - |
| exp2f128 - - - 1 - |
| expm1f 1 - 1 - - |
| expm1 1 - 1 1 - |
| expm1l - - 1 1 - |
| expm1f128 - - - 1 - |
| fmaf - - - - - |
| fma - - - - - |
| fmal - - - - - |
| fmaf128 - - - - - |
| fmodf - - - - - |
| fmod - - - - - |
| fmodl - - - - - |
| fmodf128 - - - - - |
| gammaf - - 4 1 1 |
| gamma - - 4 - - |
| gammal - - - - 2 |
| gammaf128 - - - - - |
| hypotf 1 - 1 - - |
| hypot - - 1 - 1 |
| hypotl - - - - 1 |
| hypotf128 - - - 1 - |
| j0f 2 - 2 2 2 |
| j0 2 - 2 2 1 |
| j0l - - 2 2 2 |
| j0f128 - - - 2 - |
| j1f 2 - 2 2 2 |
| j1 1 - 1 1 - |
| j1l - - 1 1 1 |
| j1f128 - - - 4 - |
| jnf 4 - 5 4 2 |
| jn 4 - 4 4 2 |
| jnl - - 4 4 4 |
| jnf128 - - - 7 - |
| lgammaf 2 - 4 1 1 |
| lgamma 1 - 4 - - |
| lgammal - - 1 - 2 |
| lgammaf128 - - - 5 - |
| logf - - 1 - - |
| log - - - - - |
| logl - - - - - |
| logf128 - - - 1 - |
| log10f 2 - 2 - - |
| log10 1 - 2 - - |
| log10l - - 1 - - |
| log10f128 - - - 1 - |
| log1pf 1 - 1 - - |
| log1p - - 1 - - |
| log1pl - - - - - |
| log1pf128 - - - 2 - |
| log2f - - 1 - - |
| log2 - - 2 - - |
| log2l - - - - - |
| log2f128 - - - 2 - |
| mul_ldoublef - - - - - |
| mul_ldouble - - - - - |
| mul_ldoublel - - - - - |
| mul_ldoublef128- - - - - |
| powf - - 1 - 7 |
| pow - - 1 - 1 |
| powl - - - - 9 |
| powf128 - - - 2 - |
| pow10f - - - - - |
| pow10 - - - - - |
| pow10l - - - - - |
| pow10f128 - - - - - |
| sinf - - 1 - - |
| sin - - 1 1 1 |
| sinl - - - - - |
| sinf128 - - - 1 - |
| sincosf 1 - 1 - - |
| sincos 1 - 1 1 - |
| sincosl - - 1 - - |
| sincosf128 - - - 1 - |
| sinhf - - 2 - - |
| sinh - - 2 - - |
| sinhl - - - - - |
| sinhf128 - - - 2 - |
| sqrtf - - - - - |
| sqrt - - - - - |
| sqrtl - - - - - |
| sqrtf128 - - - - - |
| sub_ldoublef - - - - - |
| sub_ldouble - - - - - |
| sub_ldoublel - - - - - |
| sub_ldoublef128- - - - - |
| tanf - - 1 - - |
| tan 1 - 1 - - |
| tanl - - 1 1 - |
| tanf128 - - - 1 - |
| tanhf - - 2 - - |
| tanh - - 2 - - |
| tanhl - - - - - |
| tanhf128 - - - 2 - |
| tgammaf 1 - 4 - 4 |
| tgamma 1 - 5 - 1 |
| tgammal - - 1 1 9 |
| tgammaf128 - - - 4 - |
| y0f 1 - 1 1 1 |
| y0 2 - 2 2 1 |
| y0l - - 2 1 1 |
| y0f128 - - - 3 - |
| y1f 2 - 2 2 3 |
| y1 3 - 3 3 1 |
| y1l - - 3 2 2 |
| y1f128 - - - 2 - |
| ynf 2 - 3 3 3 |
| yn 3 - 3 3 2 |
| ynl - - 3 3 4 |
| ynf128 - - - 5 - |
| |
| Function MIPS 32-bit MIPS 64-bit MicroBlaze Nios II PowerPC |
| acosf 1 1 1 1 1 |
| acos - - - - - |
| acosl - 1 - - 1 |
| acosf128 - - - - 1 |
| acoshf 2 2 2 2 2 |
| acosh 2 2 2 2 2 |
| acoshl - 2 - - 2 |
| acoshf128 - - - - 2 |
| add_ldoublef - - - - 1 |
| add_ldouble - - - - 1 |
| add_ldoublel - - - - - |
| add_ldoublef128- - - - - |
| asinf 1 1 1 1 1 |
| asin - - - - - |
| asinl - 1 - - 2 |
| asinf128 - - - - 1 |
| asinhf 1 1 1 1 1 |
| asinh 1 1 1 1 1 |
| asinhl - 3 - - 2 |
| asinhf128 - - - - 3 |
| atanf 1 1 1 1 1 |
| atan - - - - 1 |
| atanl - 1 - - 1 |
| atanf128 - - - - 1 |
| atan2f 1 1 1 1 1 |
| atan2 - - - - - |
| atan2l - 1 - - 2 |
| atan2f128 - - - - 1 |
| atanhf 2 2 2 2 2 |
| atanh 2 2 2 2 2 |
| atanhl - 3 - - 2 |
| atanhf128 - - - - 3 |
| cabsf - - - - - |
| cabs 1 1 1 1 1 |
| cabsl - 1 - - 1 |
| cabsf128 - - - - 1 |
| cacosf 2 + i 2 2 + i 2 2 + i 2 2 + i 2 2 + i 2 |
| cacos 1 + i 2 1 + i 2 1 + i 2 1 + i 2 1 + i 2 |
| cacosl - 2 + i 2 - - 1 + i 2 |
| cacosf128 - - - - 2 + i 2 |
| cacoshf 2 + i 2 2 + i 2 2 + i 2 2 + i 2 2 + i 2 |
| cacosh 2 + i 1 2 + i 1 2 + i 1 2 + i 1 2 + i 1 |
| cacoshl - 2 + i 2 - - 2 + i 1 |
| cacoshf128 - - - - 2 + i 2 |
| cargf 1 1 1 1 1 |
| carg - - - - 1 |
| cargl - 2 - - 2 |
| cargf128 - - - - 2 |
| casinf 1 + i 2 1 + i 2 1 + i 2 1 + i 2 1 + i 2 |
| casin 1 + i 2 1 + i 2 1 + i 2 1 + i 2 1 + i 2 |
| casinl - 2 + i 2 - - 1 + i 2 |
| casinf128 - - - - 2 + i 2 |
| casinhf 2 + i 1 2 + i 1 2 + i 1 2 + i 1 2 + i 1 |
| casinh 2 + i 1 2 + i 1 2 + i 1 2 + i 1 2 + i 1 |
| casinhl - 2 + i 2 - - 2 + i 1 |
| casinhf128 - - - - 2 + i 2 |
| catanf 1 + i 1 1 + i 1 1 + i 1 1 + i 1 1 + i 1 |
| catan 1 + i 1 1 + i 1 1 + i 1 1 + i 1 1 + i 1 |
| catanl - 1 + i 1 - - 3 + i 2 |
| catanf128 - - - - 1 + i 1 |
| catanhf 1 + i 1 1 + i 1 1 + i 1 1 + i 1 1 + i 1 |
| catanh 1 + i 1 1 + i 1 1 + i 1 1 + i 1 1 + i 1 |
| catanhl - 1 + i 1 - - 2 + i 3 |
| catanhf128 - - - - 1 + i 1 |
| cbrtf 1 1 1 1 1 |
| cbrt 3 3 3 3 3 |
| cbrtl - 1 - - 1 |
| cbrtf128 - - - - 1 |
| ccosf 1 + i 1 1 + i 1 1 + i 1 1 + i 1 1 + i 1 |
| ccos 1 + i 1 1 + i 1 1 + i 1 1 + i 1 1 + i 1 |
| ccosl - 1 + i 1 - - 1 + i 2 |
| ccosf128 - - - - 1 + i 1 |
| ccoshf 1 + i 1 1 + i 1 1 + i 1 1 + i 1 1 + i 1 |
| ccosh 1 + i 1 1 + i 1 1 + i 1 1 + i 1 1 + i 1 |
| ccoshl - 1 + i 1 - - 1 + i 2 |
| ccoshf128 - - - - 1 + i 1 |
| cexpf 1 + i 2 1 + i 2 1 + i 2 1 + i 2 1 + i 2 |
| cexp 2 + i 1 2 + i 1 2 + i 1 2 + i 1 2 + i 1 |
| cexpl - 1 + i 1 - - 2 + i 2 |
| cexpf128 - - - - 1 + i 1 |
| clogf 3 + i 1 3 + i 1 3 + i 1 3 + i 1 3 + i 1 |
| clog 3 + i 0 3 + i 0 3 + i 0 3 + i 0 3 + i 1 |
| clogl - 2 + i 1 - - 5 + i 2 |
| clogf128 - - - - 2 + i 1 |
| clog10f 4 + i 2 4 + i 2 4 + i 2 4 + i 2 4 + i 2 |
| clog10 3 + i 2 3 + i 2 3 + i 2 3 + i 2 3 + i 2 |
| clog10l - 2 + i 2 - - 3 + i 2 |
| clog10f128 - - - - 2 + i 2 |
| cosf 1 1 1 1 3 |
| cos 1 1 - 1 1 |
| cosl - 1 - - 4 |
| cosf128 - - - - 1 |
| coshf 1 1 1 1 1 |
| cosh 1 1 1 1 1 |
| coshl - 1 - - 3 |
| coshf128 - - - - 1 |
| cpowf 5 + i 2 5 + i 2 4 + i 2 5 + i 2 5 + i 2 |
| cpow 2 + i 0 2 + i 0 2 + i 0 2 + i 0 2 + i 0 |
| cpowl - 4 + i 1 - - 4 + i 2 |
| cpowf128 - - - - 4 + i 1 |
| csinf 1 + i 0 1 + i 0 1 + i 0 1 + i 0 1 + i 0 |
| csin 1 + i 0 1 + i 0 1 + i 0 1 + i 0 1 + i 0 |
| csinl - 1 + i 1 - - 2 + i 1 |
| csinf128 - - - - 1 + i 1 |
| csinhf 1 + i 1 1 + i 1 1 + i 1 1 + i 1 1 + i 1 |
| csinh 0 + i 1 0 + i 1 0 + i 1 0 + i 1 0 + i 1 |
| csinhl - 1 + i 1 - - 1 + i 2 |
| csinhf128 - - - - 1 + i 1 |
| csqrtf 2 + i 2 2 + i 2 2 + i 2 2 + i 2 2 + i 2 |
| csqrt 2 + i 2 2 + i 2 2 + i 2 2 + i 2 2 + i 2 |
| csqrtl - 2 + i 2 - - 1 + i 1 |
| csqrtf128 - - - - 2 + i 2 |
| ctanf 1 + i 2 1 + i 2 1 + i 1 1 + i 2 1 + i 2 |
| ctan 1 + i 2 1 + i 2 1 + i 2 1 + i 2 1 + i 2 |
| ctanl - 3 + i 3 - - 3 + i 2 |
| ctanf128 - - - - 3 + i 3 |
| ctanhf 2 + i 2 2 + i 2 1 + i 2 2 + i 2 2 + i 1 |
| ctanh 2 + i 2 2 + i 2 2 + i 2 2 + i 2 2 + i 2 |
| ctanhl - 3 + i 3 - - 3 + i 3 |
| ctanhf128 - - - - 3 + i 3 |
| div_ldoublef - - - - 1 |
| div_ldouble - - - - - |
| div_ldoublel - - - - - |
| div_ldoublef128- - - - - |
| erff 1 1 1 1 1 |
| erf 1 1 1 1 1 |
| erfl - 1 - - 1 |
| erff128 - - - - 1 |
| erfcf 2 2 2 2 2 |
| erfc 3 3 3 3 2 |
| erfcl - 2 - - 3 |
| erfcf128 - - - - 2 |
| expf 1 1 1 1 - |
| exp - - - - 1 |
| expl - 1 - - 1 |
| expf128 - - - - 1 |
| exp10f - - - - - |
| exp10 2 2 2 2 2 |
| exp10l - 2 - - 1 |
| exp10f128 - - - - 2 |
| exp2f 1 1 1 1 - |
| exp2 1 1 1 1 1 |
| exp2l - 1 - - 2 |
| exp2f128 - - - - 1 |
| expm1f 1 1 1 1 1 |
| expm1 1 1 1 1 1 |
| expm1l - 1 - - 1 |
| expm1f128 - - - - 1 |
| fmaf - - - - - |
| fma - - - - - |
| fmal - - - - 1 |
| fmaf128 - - - - - |
| fmodf - - - - - |
| fmod - - - - - |
| fmodl - - - - 1 |
| fmodf128 - - - - - |
| gammaf 4 4 4 4 4 |
| gamma 4 4 4 4 3 |
| gammal - 5 - - 3 |
| gammaf128 - - - - - |
| hypotf - - - - - |
| hypot 1 1 1 1 1 |
| hypotl - 1 - - 1 |
| hypotf128 - - - - 1 |
| j0f 2 2 2 2 2 |
| j0 2 2 2 2 2 |
| j0l - 2 - - 2 |
| j0f128 - - - - 2 |
| j1f 2 2 2 2 2 |
| j1 1 1 1 1 1 |
| j1l - 4 - - 2 |
| j1f128 - - - - 4 |
| jnf 4 4 4 4 4 |
| jn 4 4 4 4 4 |
| jnl - 7 - - 4 |
| jnf128 - - - - 7 |
| lgammaf 4 4 4 4 4 |
| lgamma 4 4 4 4 3 |
| lgammal - 5 - - 3 |
| lgammaf128 - - - - 5 |
| logf 1 1 1 1 1 |
| log - - - - - |
| logl - 1 - - 1 |
| logf128 - - - - 1 |
| log10f 2 2 2 2 2 |
| log10 2 2 2 2 2 |
| log10l - 1 - - 1 |
| log10f128 - - - - 1 |
| log1pf 1 1 1 1 1 |
| log1p 1 1 1 1 1 |
| log1pl - 2 - - 2 |
| log1pf128 - - - - 2 |
| log2f 1 1 1 1 1 |
| log2 2 2 2 2 1 |
| log2l - 2 - - 1 |
| log2f128 - - - - 2 |
| mul_ldoublef - - - - 1 |
| mul_ldouble - - - - 1 |
| mul_ldoublel - - - - - |
| mul_ldoublef128- - - - - |
| powf 1 1 1 3 1 |
| pow 1 1 - 1 1 |
| powl - 2 - - 1 |
| powf128 - - - - 2 |
| pow10f - - - - - |
| pow10 - - - - - |
| pow10l - - - - - |
| pow10f128 - - - - - |
| sinf 1 1 1 1 1 |
| sin 1 1 - 1 1 |
| sinl - 1 - - 1 |
| sinf128 - - - - 1 |
| sincosf 1 1 1 1 1 |
| sincos 1 1 - 1 1 |
| sincosl - 1 - - 1 |
| sincosf128 - - - - 1 |
| sinhf 2 2 2 2 2 |
| sinh 2 2 2 2 2 |
| sinhl - 2 - - 3 |
| sinhf128 - - - - 2 |
| sqrtf - - - - - |
| sqrt - - - - - |
| sqrtl - - - - 1 |
| sqrtf128 - - - - - |
| sub_ldoublef - - - - 1 |
| sub_ldouble - - - - 1 |
| sub_ldoublel - - - - - |
| sub_ldoublef128- - - - - |
| tanf 1 1 1 1 3 |
| tan - - - - - |
| tanl - 1 - - 2 |
| tanf128 - - - - 1 |
| tanhf 2 2 2 2 2 |
| tanh 2 2 2 2 2 |
| tanhl - 2 - - 1 |
| tanhf128 - - - - 2 |
| tgammaf 4 4 4 5 4 |
| tgamma 5 5 5 5 5 |
| tgammal - 4 - - 5 |
| tgammaf128 - - - - 4 |
| y0f 1 1 1 1 1 |
| y0 2 2 2 2 2 |
| y0l - 3 - - 1 |
| y0f128 - - - - 3 |
| y1f 2 2 2 2 2 |
| y1 3 3 3 3 3 |
| y1l - 2 - - 2 |
| y1f128 - - - - 2 |
| ynf 3 3 2 3 3 |
| yn 3 3 3 3 3 |
| ynl - 5 - - 2 |
| ynf128 - - - - 5 |
| |
| Function PowerPC RISC-V RISC-V S/390 SH |
| soft-float soft-float |
| acosf 1 1 1 1 1 |
| acos - - - - - |
| acosl 1 1 1 1 - |
| acosf128 - - - - - |
| acoshf 2 2 2 2 2 |
| acosh 2 2 2 2 2 |
| acoshl 1 2 2 2 - |
| acoshf128 - - - - - |
| add_ldoublef 1 - - - - |
| add_ldouble 1 - - - - |
| add_ldoublel - - - - - |
| add_ldoublef128- - - - - |
| asinf 1 1 1 1 1 |
| asin - - - - - |
| asinl 2 1 1 1 - |
| asinf128 - - - - - |
| asinhf 1 1 1 1 1 |
| asinh 1 1 1 1 1 |
| asinhl 2 3 3 3 - |
| asinhf128 - - - - - |
| atanf 1 1 1 1 1 |
| atan - - - - - |
| atanl 1 1 1 1 - |
| atanf128 - - - - - |
| atan2f 1 1 1 1 1 |
| atan2 - - - - - |
| atan2l 2 1 1 1 - |
| atan2f128 - - - - - |
| atanhf 2 2 2 2 2 |
| atanh 2 2 2 2 2 |
| atanhl 2 3 3 3 - |
| atanhf128 - - - - - |
| cabsf - - - - - |
| cabs 1 1 1 1 1 |
| cabsl 1 1 1 1 - |
| cabsf128 - - - - - |
| cacosf 2 + i 2 2 + i 2 2 + i 2 2 + i 2 2 + i 2 |
| cacos 1 + i 2 1 + i 2 1 + i 2 1 + i 2 1 + i 2 |
| cacosl 2 + i 1 2 + i 2 2 + i 2 2 + i 2 - |
| cacosf128 - - - - - |
| cacoshf 2 + i 2 2 + i 2 2 + i 2 2 + i 2 2 + i 2 |
| cacosh 2 + i 1 2 + i 1 2 + i 1 2 + i 1 2 + i 1 |
| cacoshl 1 + i 2 2 + i 2 2 + i 2 2 + i 2 - |
| cacoshf128 - - - - - |
| cargf 1 1 1 1 1 |
| carg - - - - - |
| cargl 2 2 2 2 - |
| cargf128 - - - - - |
| casinf 1 + i 2 1 + i 2 1 + i 2 1 + i 2 1 + i 2 |
| casin 1 + i 2 1 + i 2 1 + i 2 1 + i 2 1 + i 2 |
| casinl 2 + i 1 2 + i 2 2 + i 2 2 + i 2 - |
| casinf128 - - - - - |
| casinhf 2 + i 1 2 + i 1 2 + i 1 2 + i 1 2 + i 1 |
| casinh 2 + i 1 2 + i 1 2 + i 1 2 + i 1 2 + i 1 |
| casinhl 1 + i 2 2 + i 2 2 + i 2 2 + i 2 - |
| casinhf128 - - - - - |
| catanf 1 + i 1 1 + i 1 1 + i 1 1 + i 1 1 + i 1 |
| catan 1 + i 1 1 + i 1 1 + i 1 1 + i 1 1 + i 1 |
| catanl 3 + i 2 1 + i 1 1 + i 1 1 + i 1 - |
| catanf128 - - - - - |
| catanhf 1 + i 1 1 + i 1 1 + i 1 1 + i 1 1 + i 1 |
| catanh 1 + i 1 1 + i 1 1 + i 1 1 + i 1 1 + i 1 |
| catanhl 2 + i 3 1 + i 1 1 + i 1 1 + i 1 - |
| catanhf128 - - - - - |
| cbrtf 1 1 1 1 1 |
| cbrt 3 3 3 3 3 |
| cbrtl 1 1 1 1 - |
| cbrtf128 - - - - - |
| ccosf 1 + i 1 1 + i 1 1 + i 1 1 + i 1 1 + i 1 |
| ccos 1 + i 1 1 + i 1 1 + i 1 1 + i 1 1 + i 1 |
| ccosl 1 + i 2 1 + i 1 1 + i 1 1 + i 1 - |
| ccosf128 - - - - - |
| ccoshf 1 + i 1 1 + i 1 1 + i 1 1 + i 1 1 + i 1 |
| ccosh 1 + i 1 1 + i 1 1 + i 1 1 + i 1 1 + i 1 |
| ccoshl 1 + i 2 1 + i 1 1 + i 1 1 + i 1 - |
| ccoshf128 - - - - - |
| cexpf 1 + i 2 1 + i 2 1 + i 2 1 + i 2 1 + i 2 |
| cexp 2 + i 1 2 + i 1 2 + i 1 2 + i 1 2 + i 1 |
| cexpl 1 + i 1 1 + i 1 1 + i 1 1 + i 1 - |
| cexpf128 - - - - - |
| clogf 3 + i 1 3 + i 1 3 + i 1 3 + i 1 3 + i 1 |
| clog 3 + i 0 3 + i 0 3 + i 0 3 + i 0 3 + i 0 |
| clogl 2 + i 2 2 + i 1 2 + i 1 2 + i 1 - |
| clogf128 - - - - - |
| clog10f 4 + i 2 4 + i 2 4 + i 2 4 + i 2 4 + i 2 |
| clog10 3 + i 2 3 + i 2 3 + i 2 3 + i 2 3 + i 2 |
| clog10l 3 + i 2 2 + i 2 2 + i 2 2 + i 2 - |
| clog10f128 - - - - - |
| cosf 1 - - - 1 |
| cos 1 1 1 1 1 |
| cosl 4 1 1 1 - |
| cosf128 - - - - - |
| coshf 1 1 1 1 1 |
| cosh 1 1 1 1 1 |
| coshl 3 1 1 1 - |
| coshf128 - - - - - |
| cpowf 5 + i 2 5 + i 2 5 + i 2 5 + i 2 5 + i 2 |
| cpow 2 + i 0 2 + i 0 2 + i 0 2 + i 0 2 + i 0 |
| cpowl 4 + i 1 4 + i 1 4 + i 1 4 + i 1 - |
| cpowf128 - - - - - |
| csinf 1 + i 0 1 + i 0 1 + i 0 1 + i 0 1 + i 0 |
| csin 1 + i 0 1 + i 0 1 + i 0 1 + i 0 1 + i 0 |
| csinl 2 + i 1 1 + i 1 1 + i 1 1 + i 1 - |
| csinf128 - - - - - |
| csinhf 1 + i 1 1 + i 1 1 + i 1 1 + i 1 1 + i 1 |
| csinh 0 + i 1 0 + i 1 0 + i 1 0 + i 1 0 + i 1 |
| csinhl 1 + i 2 1 + i 1 1 + i 1 1 + i 1 - |
| csinhf128 - - - - - |
| csqrtf 2 + i 2 2 + i 2 2 + i 2 2 + i 2 2 + i 2 |
| csqrt 2 + i 2 2 + i 2 2 + i 2 2 + i 2 2 + i 2 |
| csqrtl 1 + i 1 2 + i 2 2 + i 2 2 + i 2 - |
| csqrtf128 - - - - - |
| ctanf 1 + i 2 1 + i 2 1 + i 2 1 + i 2 1 + i 2 |
| ctan 1 + i 2 1 + i 2 1 + i 2 1 + i 2 1 + i 2 |
| ctanl 3 + i 2 3 + i 3 3 + i 3 3 + i 3 - |
| ctanf128 - - - - - |
| ctanhf 2 + i 2 2 + i 1 2 + i 2 2 + i 1 2 + i 2 |
| ctanh 2 + i 2 2 + i 2 2 + i 2 2 + i 2 2 + i 2 |
| ctanhl 2 + i 3 3 + i 3 3 + i 3 3 + i 3 - |
| ctanhf128 - - - - - |
| div_ldoublef 1 - - - - |
| div_ldouble - - - - - |
| div_ldoublel - - - - - |
| div_ldoublef128- - - - - |
| erff 1 1 1 1 1 |
| erf 1 1 1 1 1 |
| erfl 1 1 1 1 - |
| erff128 - - - - - |
| erfcf 2 2 2 2 2 |
| erfc 3 2 3 2 3 |
| erfcl 3 2 2 2 - |
| erfcf128 - - - - - |
| expf 1 - - - - |
| exp - - - - - |
| expl 1 1 1 1 - |
| expf128 - - - - - |
| exp10f - - - - - |
| exp10 2 2 2 2 2 |
| exp10l 1 2 2 2 - |
| exp10f128 - - - - - |
| exp2f 1 - - - - |
| exp2 1 1 1 1 1 |
| exp2l 1 1 1 1 - |
| exp2f128 - - - - - |
| expm1f 1 1 1 1 1 |
| expm1 1 1 1 1 1 |
| expm1l 1 1 1 1 - |
| expm1f128 - - - - - |
| fmaf - - - - - |
| fma - - - - - |
| fmal 1 - - - - |
| fmaf128 - - - - - |
| fmodf - - - - - |
| fmod - - - - - |
| fmodl 1 - - - - |
| fmodf128 - - - - - |
| gammaf 4 3 3 3 3 |
| gamma 4 3 4 3 4 |
| gammal 3 5 5 5 - |
| gammaf128 - - - - - |
| hypotf - - - - - |
| hypot 1 1 1 1 1 |
| hypotl 1 1 1 1 - |
| hypotf128 - - - - - |
| j0f 2 2 2 2 2 |
| j0 2 2 2 2 2 |
| j0l 2 2 2 2 - |
| j0f128 - - - - - |
| j1f 2 2 2 2 2 |
| j1 1 1 1 1 1 |
| j1l 1 4 4 4 - |
| j1f128 - - - - - |
| jnf 4 4 4 4 4 |
| jn 4 4 4 4 4 |
| jnl 4 7 7 7 - |
| jnf128 - - - - - |
| lgammaf 4 3 3 3 3 |
| lgamma 4 3 4 3 4 |
| lgammal 3 5 5 5 - |
| lgammaf128 - - - - - |
| logf 1 - - - 1 |
| log - - - - - |
| logl 1 1 1 1 - |
| logf128 - - - - - |
| log10f 2 2 2 2 2 |
| log10 2 2 2 2 2 |
| log10l 1 1 1 1 - |
| log10f128 - - - - - |
| log1pf 1 1 1 1 1 |
| log1p 1 1 1 1 1 |
| log1pl 2 2 2 2 - |
| log1pf128 - - - - - |
| log2f 1 1 1 1 1 |
| log2 2 1 2 - 2 |
| log2l 1 2 2 2 - |
| log2f128 - - - - - |
| mul_ldoublef 1 - - - - |
| mul_ldouble 1 - - - - |
| mul_ldoublel - - - - - |
| mul_ldoublef128- - - - - |
| powf 1 - - - 1 |
| pow 1 1 1 1 1 |
| powl 1 2 2 2 - |
| powf128 - - - - - |
| pow10f - - - - - |
| pow10 - - - - - |
| pow10l - - - - - |
| pow10f128 - - - - - |
| sinf 1 - - - 1 |
| sin 1 1 1 1 1 |
| sinl 1 1 1 1 - |
| sinf128 - - - - - |
| sincosf 1 - - - 1 |
| sincos 1 1 1 1 1 |
| sincosl 1 1 1 1 - |
| sincosf128 - - - - - |
| sinhf 2 2 2 2 2 |
| sinh 2 2 2 2 2 |
| sinhl 3 2 2 2 - |
| sinhf128 - - - - - |
| sqrtf - - - - - |
| sqrt - - - - - |
| sqrtl 1 - - - - |
| sqrtf128 - - - - - |
| sub_ldoublef 1 - - - - |
| sub_ldouble 1 - - - - |
| sub_ldoublel - - - - - |
| sub_ldoublef128- - - - - |
| tanf 1 1 1 1 1 |
| tan - - - - - |
| tanl 2 1 1 1 - |
| tanf128 - - - - - |
| tanhf 2 2 2 2 2 |
| tanh 2 2 2 2 2 |
| tanhl 1 2 2 2 - |
| tanhf128 - - - - - |
| tgammaf 4 4 4 4 4 |
| tgamma 5 5 5 5 5 |
| tgammal 3 4 4 4 - |
| tgammaf128 - - - - - |
| y0f 1 1 1 1 1 |
| y0 2 2 2 2 2 |
| y0l 1 3 3 3 - |
| y0f128 - - - - - |
| y1f 2 2 2 2 2 |
| y1 3 3 3 3 3 |
| y1l 2 2 2 2 - |
| y1f128 - - - - - |
| ynf 3 3 3 3 3 |
| yn 3 3 3 3 3 |
| ynl 2 5 5 5 - |
| ynf128 - - - - - |
| |
| Function Sparc i686 ix86 x86_64 |
| acosf 1 - - 1 |
| acos - 1 1 - |
| acosl 1 1 1 1 |
| acosf128 - 1 1 1 |
| acoshf 2 - - 2 |
| acosh 2 1 1 2 |
| acoshl 2 2 2 2 |
| acoshf128 - 2 2 2 |
| add_ldoublef - - - - |
| add_ldouble - - - - |
| add_ldoublel - - - - |
| add_ldoublef128- - - - |
| asinf 1 - - 1 |
| asin - 1 1 - |
| asinl 1 1 1 1 |
| asinf128 - 1 1 1 |
| asinhf 1 - - 1 |
| asinh 1 1 1 1 |
| asinhl 3 3 3 3 |
| asinhf128 - 3 3 3 |
| atanf 1 - - 1 |
| atan - 1 1 - |
| atanl 1 1 1 1 |
| atanf128 - 1 1 1 |
| atan2f 1 - - 1 |
| atan2 - 1 1 - |
| atan2l 1 1 1 1 |
| atan2f128 - 1 1 1 |
| atanhf 2 - - 2 |
| atanh 2 1 1 2 |
| atanhl 3 3 3 3 |
| atanhf128 - 3 3 3 |
| cabsf - - - - |
| cabs 1 1 1 1 |
| cabsl 1 1 1 1 |
| cabsf128 - 1 1 1 |
| cacosf 2 + i 2 2 + i 2 2 + i 2 2 + i 2 |
| cacos 1 + i 2 1 + i 2 1 + i 2 1 + i 2 |
| cacosl 2 + i 2 1 + i 2 1 + i 2 1 + i 2 |
| cacosf128 - 2 + i 2 2 + i 2 2 + i 2 |
| cacoshf 2 + i 2 2 + i 2 2 + i 2 2 + i 2 |
| cacosh 2 + i 1 2 + i 1 2 + i 1 2 + i 1 |
| cacoshl 2 + i 2 2 + i 1 2 + i 1 2 + i 1 |
| cacoshf128 - 2 + i 2 2 + i 2 2 + i 2 |
| cargf 1 - - 1 |
| carg - 1 1 - |
| cargl 2 1 1 1 |
| cargf128 - 2 2 2 |
| casinf 1 + i 2 1 + i 2 1 + i 2 1 + i 2 |
| casin 1 + i 2 1 + i 2 1 + i 2 1 + i 2 |
| casinl 2 + i 2 1 + i 2 1 + i 2 1 + i 2 |
| casinf128 - 2 + i 2 2 + i 2 2 + i 2 |
| casinhf 2 + i 1 2 + i 1 2 + i 1 2 + i 1 |
| casinh 2 + i 1 2 + i 1 2 + i 1 2 + i 1 |
| casinhl 2 + i 2 2 + i 1 2 + i 1 2 + i 1 |
| casinhf128 - 2 + i 2 2 + i 2 2 + i 2 |
| catanf 1 + i 1 0 + i 1 0 + i 1 1 + i 1 |
| catan 1 + i 1 1 + i 1 1 + i 1 1 + i 1 |
| catanl 1 + i 1 1 + i 1 1 + i 1 1 + i 1 |
| catanf128 - 1 + i 1 1 + i 1 1 + i 1 |
| catanhf 1 + i 1 1 + i 0 1 + i 0 1 + i 1 |
| catanh 1 + i 1 1 + i 1 1 + i 1 1 + i 1 |
| catanhl 1 + i 1 1 + i 1 1 + i 1 1 + i 1 |
| catanhf128 - 1 + i 1 1 + i 1 1 + i 1 |
| cbrtf 1 1 1 1 |
| cbrt 3 1 1 3 |
| cbrtl 1 3 3 1 |
| cbrtf128 - 1 1 1 |
| ccosf 1 + i 1 1 + i 1 1 + i 1 1 + i 1 |
| ccos 1 + i 1 1 + i 1 1 + i 1 1 + i 1 |
| ccosl 1 + i 1 1 + i 1 1 + i 1 1 + i 1 |
| ccosf128 - 1 + i 1 1 + i 1 1 + i 1 |
| ccoshf 1 + i 1 1 + i 1 1 + i 1 1 + i 1 |
| ccosh 1 + i 1 1 + i 1 1 + i 1 1 + i 1 |
| ccoshl 1 + i 1 1 + i 1 1 + i 1 1 + i 1 |
| ccoshf128 - 1 + i 1 1 + i 1 1 + i 1 |
| cexpf 1 + i 2 1 + i 2 1 + i 2 1 + i 2 |
| cexp 2 + i 1 2 + i 1 2 + i 1 2 + i 1 |
| cexpl 1 + i 1 1 + i 1 1 + i 1 1 + i 1 |
| cexpf128 - 1 + i 1 1 + i 1 1 + i 1 |
| clogf 3 + i 1 3 + i 0 3 + i 0 3 + i 1 |
| clog 3 + i 0 2 + i 1 2 + i 1 3 + i 0 |
| clogl 4 + i 1 3 + i 1 3 + i 1 3 + i 1 |
| clogf128 - 2 + i 1 2 + i 1 2 + i 1 |
| clog10f 4 + i 2 4 + i 1 4 + i 1 4 + i 2 |
| clog10 3 + i 2 3 + i 2 3 + i 2 3 + i 2 |
| clog10l 4 + i 2 4 + i 2 4 + i 2 4 + i 2 |
| clog10f128 - 2 + i 2 2 + i 2 2 + i 2 |
| cosf 1 - 1 - |
| cos 1 1 1 1 |
| cosl 1 1 1 1 |
| cosf128 - 1 1 1 |
| coshf 1 1 1 1 |
| cosh 1 1 1 1 |
| coshl 1 2 2 2 |
| coshf128 - 1 1 1 |
| cpowf 5 + i 2 5 + i 2 5 + i 2 5 + i 2 |
| cpow 2 + i 0 2 + i 1 2 + i 0 2 + i 0 |
| cpowl 4 + i 1 3 + i 4 3 + i 4 3 + i 4 |
| cpowf128 - 4 + i 1 4 + i 1 4 + i 1 |
| csinf 1 + i 0 1 + i 1 1 + i 1 1 + i 0 |
| csin 1 + i 0 1 + i 1 1 + i 0 1 + i 0 |
| csinl 1 + i 1 1 + i 0 1 + i 0 1 + i 0 |
| csinf128 - 1 + i 1 1 + i 1 1 + i 1 |
| csinhf 1 + i 1 1 + i 1 1 + i 1 1 + i 1 |
| csinh 0 + i 1 1 + i 1 0 + i 1 0 + i 1 |
| csinhl 1 + i 1 1 + i 1 1 + i 1 1 + i 1 |
| csinhf128 - 1 + i 1 1 + i 1 1 + i 1 |
| csqrtf 2 + i 2 2 + i 2 2 + i 2 2 + i 2 |
| csqrt 2 + i 2 2 + i 2 2 + i 2 2 + i 2 |
| csqrtl 2 + i 2 2 + i 2 2 + i 2 2 + i 2 |
| csqrtf128 - 2 + i 2 2 + i 2 2 + i 2 |
| ctanf 1 + i 2 1 + i 2 1 + i 2 1 + i 2 |
| ctan 1 + i 2 1 + i 2 1 + i 2 1 + i 2 |
| ctanl 3 + i 3 2 + i 1 2 + i 1 2 + i 1 |
| ctanf128 - 3 + i 3 3 + i 3 3 + i 3 |
| ctanhf 2 + i 2 2 + i 2 2 + i 2 2 + i 2 |
| ctanh 2 + i 2 2 + i 2 2 + i 2 2 + i 2 |
| ctanhl 3 + i 3 1 + i 2 1 + i 2 1 + i 2 |
| ctanhf128 - 3 + i 3 3 + i 3 3 + i 3 |
| div_ldoublef - - - - |
| div_ldouble - - - - |
| div_ldoublel - - - - |
| div_ldoublef128- - - - |
| erff 1 1 1 1 |
| erf 1 1 1 1 |
| erfl 1 1 1 1 |
| erff128 - 1 1 1 |
| erfcf 2 2 2 2 |
| erfc 3 3 3 3 |
| erfcl 2 3 3 3 |
| erfcf128 - 2 2 2 |
| expf 1 - - - |
| exp - 1 1 - |
| expl 1 1 1 1 |
| expf128 - 1 1 1 |
| exp10f - - - - |
| exp10 2 1 1 2 |
| exp10l 2 1 1 1 |
| exp10f128 - 2 2 2 |
| exp2f 1 - - 1 |
| exp2 1 1 1 1 |
| exp2l 1 1 1 1 |
| exp2f128 - 1 1 1 |
| expm1f 1 - - 1 |
| expm1 1 1 1 1 |
| expm1l 1 2 2 2 |
| expm1f128 - 1 1 1 |
| fmaf - - - - |
| fma - - - - |
| fmal - - - - |
| fmaf128 - - - - |
| fmodf - - - - |
| fmod - - - - |
| fmodl - - - - |
| fmodf128 - - - - |
| gammaf 4 3 3 4 |
| gamma 4 4 4 4 |
| gammal 5 4 4 4 |
| gammaf128 - - - - |
| hypotf - - - - |
| hypot 1 1 1 1 |
| hypotl 1 1 1 1 |
| hypotf128 - 1 1 1 |
| j0f 2 2 2 2 |
| j0 2 2 2 2 |
| j0l 2 2 2 2 |
| j0f128 - 2 2 2 |
| j1f 2 2 2 2 |
| j1 1 2 2 1 |
| j1l 4 1 1 1 |
| j1f128 - 4 4 4 |
| jnf 4 4 4 4 |
| jn 4 4 4 4 |
| jnl 7 4 4 4 |
| jnf128 - 7 7 7 |
| lgammaf 4 3 3 4 |
| lgamma 4 4 4 4 |
| lgammal 5 4 4 4 |
| lgammaf128 - 5 5 5 |
| logf 1 - - 1 |
| log - 1 1 - |
| logl 1 1 1 1 |
| logf128 - 1 1 1 |
| log10f 2 - - 2 |
| log10 2 1 1 2 |
| log10l 1 1 1 1 |
| log10f128 - 1 1 1 |
| log1pf 1 - - 1 |
| log1p 1 1 1 1 |
| log1pl 2 2 2 2 |
| log1pf128 - 2 2 2 |
| log2f 1 1 1 1 |
| log2 2 1 1 2 |
| log2l 2 1 1 1 |
| log2f128 - 2 2 2 |
| mul_ldoublef - - - - |
| mul_ldouble - - - - |
| mul_ldoublel - - - - |
| mul_ldoublef128- - - - |
| powf 3 - - 1 |
| pow 1 1 1 1 |
| powl 2 1 1 1 |
| powf128 - 2 2 2 |
| pow10f - - - - |
| pow10 - - - - |
| pow10l - - - - |
| pow10f128 - - - - |
| sinf 1 - 1 - |
| sin 1 1 1 1 |
| sinl 1 1 1 1 |
| sinf128 - 1 1 1 |
| sincosf 1 - 1 - |
| sincos 1 1 1 1 |
| sincosl 1 1 1 1 |
| sincosf128 - 1 1 1 |
| sinhf 2 2 2 2 |
| sinh 2 2 2 2 |
| sinhl 2 2 2 2 |
| sinhf128 - 2 2 2 |
| sqrtf - - - - |
| sqrt - - - - |
| sqrtl - - - - |
| sqrtf128 - - - - |
| sub_ldoublef - - - - |
| sub_ldouble - - - - |
| sub_ldoublel - - - - |
| sub_ldoublef128- - - - |
| tanf 1 1 1 1 |
| tan - - - - |
| tanl 1 2 2 2 |
| tanf128 - 1 1 1 |
| tanhf 2 2 2 2 |
| tanh 2 2 2 2 |
| tanhl 2 3 3 3 |
| tanhf128 - 2 2 2 |
| tgammaf 5 4 4 5 |
| tgamma 5 5 5 5 |
| tgammal 4 5 5 5 |
| tgammaf128 - 4 4 4 |
| y0f 1 1 1 1 |
| y0 2 2 2 2 |
| y0l 3 1 1 1 |
| y0f128 - 3 3 3 |
| y1f 2 2 2 2 |
| y1 3 3 3 3 |
| y1l 2 2 2 2 |
| y1f128 - 2 2 2 |
| ynf 3 3 3 3 |
| yn 3 3 3 3 |
| ynl 5 4 4 4 |
| ynf128 - 5 5 5 |
| |
| |
| File: libc.info, Node: Pseudo-Random Numbers, Next: FP Function Optimizations, Prev: Errors in Math Functions, Up: Mathematics |
| |
| 19.8 Pseudo-Random Numbers |
| ========================== |
| |
| This section describes the GNU facilities for generating a series of |
| pseudo-random numbers. The numbers generated are not truly random; |
| typically, they form a sequence that repeats periodically, with a period |
| so large that you can ignore it for ordinary purposes. The random |
| number generator works by remembering a "seed" value which it uses to |
| compute the next random number and also to compute a new seed. |
| |
| Although the generated numbers look unpredictable within one run of a |
| program, the sequence of numbers is _exactly the same_ from one run to |
| the next. This is because the initial seed is always the same. This |
| is convenient when you are debugging a program, but it is unhelpful if |
| you want the program to behave unpredictably. If you want a different |
| pseudo-random series each time your program runs, you must specify a |
| different seed each time. For ordinary purposes, basing the seed on the |
| current time works well. For random numbers in cryptography, *note |
| Unpredictable Bytes::. |
| |
| You can obtain repeatable sequences of numbers on a particular |
| machine type by specifying the same initial seed value for the random |
| number generator. There is no standard meaning for a particular seed |
| value; the same seed, used in different C libraries or on different CPU |
| types, will give you different random numbers. |
| |
| The GNU C Library supports the standard ISO C random number functions |
| plus two other sets derived from BSD and SVID. The BSD and ISO C |
| functions provide identical, somewhat limited functionality. If only a |
| small number of random bits are required, we recommend you use the |
| ISO C interface, `rand' and `srand'. The SVID functions provide a more |
| flexible interface, which allows better random number generator |
| algorithms, provides more random bits (up to 48) per call, and can |
| provide random floating-point numbers. These functions are required by |
| the XPG standard and therefore will be present in all modern Unix |
| systems. |
| |
| * Menu: |
| |
| * ISO Random:: `rand' and friends. |
| * BSD Random:: `random' and friends. |
| * SVID Random:: `drand48' and friends. |
| |
| |
| File: libc.info, Node: ISO Random, Next: BSD Random, Up: Pseudo-Random Numbers |
| |
| 19.8.1 ISO C Random Number Functions |
| ------------------------------------ |
| |
| This section describes the random number functions that are part of the |
| ISO C standard. |
| |
| To use these facilities, you should include the header file |
| `stdlib.h' in your program. |
| |
| -- Macro: int RAND_MAX |
| The value of this macro is an integer constant representing the |
| largest value the `rand' function can return. In the GNU C |
| Library, it is `2147483647', which is the largest signed integer |
| representable in 32 bits. In other libraries, it may be as low as |
| `32767'. |
| |
| -- Function: int rand (void) |
| Preliminary: | MT-Safe | AS-Unsafe lock | AC-Unsafe lock | *Note |
| POSIX Safety Concepts::. |
| |
| The `rand' function returns the next pseudo-random number in the |
| series. The value ranges from `0' to `RAND_MAX'. |
| |
| -- Function: void srand (unsigned int SEED) |
| Preliminary: | MT-Safe | AS-Unsafe lock | AC-Unsafe lock | *Note |
| POSIX Safety Concepts::. |
| |
| This function establishes SEED as the seed for a new series of |
| pseudo-random numbers. If you call `rand' before a seed has been |
| established with `srand', it uses the value `1' as a default seed. |
| |
| To produce a different pseudo-random series each time your program |
| is run, do `srand (time (0))'. |
| |
| POSIX.1 extended the C standard functions to support reproducible |
| random numbers in multi-threaded programs. However, the extension is |
| badly designed and unsuitable for serious work. |
| |
| -- Function: int rand_r (unsigned int *SEED) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This function returns a random number in the range 0 to `RAND_MAX' |
| just as `rand' does. However, all its state is stored in the SEED |
| argument. This means the RNG's state can only have as many bits |
| as the type `unsigned int' has. This is far too few to provide a |
| good RNG. |
| |
| If your program requires a reentrant RNG, we recommend you use the |
| reentrant GNU extensions to the SVID random number generator. The |
| POSIX.1 interface should only be used when the GNU extensions are |
| not available. |
| |
| |
| File: libc.info, Node: BSD Random, Next: SVID Random, Prev: ISO Random, Up: Pseudo-Random Numbers |
| |
| 19.8.2 BSD Random Number Functions |
| ---------------------------------- |
| |
| This section describes a set of random number generation functions that |
| are derived from BSD. There is no advantage to using these functions |
| with the GNU C Library; we support them for BSD compatibility only. |
| |
| The prototypes for these functions are in `stdlib.h'. |
| |
| -- Function: long int random (void) |
| Preliminary: | MT-Safe | AS-Unsafe lock | AC-Unsafe lock | *Note |
| POSIX Safety Concepts::. |
| |
| This function returns the next pseudo-random number in the |
| sequence. The value returned ranges from `0' to `2147483647'. |
| |
| *NB:* Temporarily this function was defined to return a `int32_t' |
| value to indicate that the return value always contains 32 bits |
| even if `long int' is wider. The standard demands it differently. |
| Users must always be aware of the 32-bit limitation, though. |
| |
| -- Function: void srandom (unsigned int SEED) |
| Preliminary: | MT-Safe | AS-Unsafe lock | AC-Unsafe lock | *Note |
| POSIX Safety Concepts::. |
| |
| The `srandom' function sets the state of the random number |
| generator based on the integer SEED. If you supply a SEED value |
| of `1', this will cause `random' to reproduce the default set of |
| random numbers. |
| |
| To produce a different set of pseudo-random numbers each time your |
| program runs, do `srandom (time (0))'. |
| |
| -- Function: char * initstate (unsigned int SEED, char *STATE, size_t |
| SIZE) |
| Preliminary: | MT-Safe | AS-Unsafe lock | AC-Unsafe lock | *Note |
| POSIX Safety Concepts::. |
| |
| The `initstate' function is used to initialize the random number |
| generator state. The argument STATE is an array of SIZE bytes, |
| used to hold the state information. It is initialized based on |
| SEED. The size must be between 8 and 256 bytes, and should be a |
| power of two. The bigger the STATE array, the better. |
| |
| The return value is the previous value of the state information |
| array. You can use this value later as an argument to `setstate' |
| to restore that state. |
| |
| -- Function: char * setstate (char *STATE) |
| Preliminary: | MT-Safe | AS-Unsafe lock | AC-Unsafe lock | *Note |
| POSIX Safety Concepts::. |
| |
| The `setstate' function restores the random number state |
| information STATE. The argument must have been the result of a |
| previous call to INITSTATE or SETSTATE. |
| |
| The return value is the previous value of the state information |
| array. You can use this value later as an argument to `setstate' |
| to restore that state. |
| |
| If the function fails the return value is `NULL'. |
| |
| The four functions described so far in this section all work on a |
| state which is shared by all threads. The state is not directly |
| accessible to the user and can only be modified by these functions. |
| This makes it hard to deal with situations where each thread should |
| have its own pseudo-random number generator. |
| |
| The GNU C Library contains four additional functions which contain |
| the state as an explicit parameter and therefore make it possible to |
| handle thread-local PRNGs. Besides this there is no difference. In |
| fact, the four functions already discussed are implemented internally |
| using the following interfaces. |
| |
| The `stdlib.h' header contains a definition of the following type: |
| |
| -- Data Type: struct random_data |
| Objects of type `struct random_data' contain the information |
| necessary to represent the state of the PRNG. Although a complete |
| definition of the type is present the type should be treated as |
| opaque. |
| |
| The functions modifying the state follow exactly the already |
| described functions. |
| |
| -- Function: int random_r (struct random_data *restrict BUF, int32_t |
| *restrict RESULT) |
| Preliminary: | MT-Safe race:buf | AS-Safe | AC-Unsafe corrupt | |
| *Note POSIX Safety Concepts::. |
| |
| The `random_r' function behaves exactly like the `random' function |
| except that it uses and modifies the state in the object pointed |
| to by the first parameter instead of the global state. |
| |
| -- Function: int srandom_r (unsigned int SEED, struct random_data *BUF) |
| Preliminary: | MT-Safe race:buf | AS-Safe | AC-Unsafe corrupt | |
| *Note POSIX Safety Concepts::. |
| |
| The `srandom_r' function behaves exactly like the `srandom' |
| function except that it uses and modifies the state in the object |
| pointed to by the second parameter instead of the global state. |
| |
| -- Function: int initstate_r (unsigned int SEED, char *restrict |
| STATEBUF, size_t STATELEN, struct random_data *restrict BUF) |
| Preliminary: | MT-Safe race:buf | AS-Safe | AC-Unsafe corrupt | |
| *Note POSIX Safety Concepts::. |
| |
| The `initstate_r' function behaves exactly like the `initstate' |
| function except that it uses and modifies the state in the object |
| pointed to by the fourth parameter instead of the global state. |
| |
| -- Function: int setstate_r (char *restrict STATEBUF, struct |
| random_data *restrict BUF) |
| Preliminary: | MT-Safe race:buf | AS-Safe | AC-Unsafe corrupt | |
| *Note POSIX Safety Concepts::. |
| |
| The `setstate_r' function behaves exactly like the `setstate' |
| function except that it uses and modifies the state in the object |
| pointed to by the first parameter instead of the global state. |
| |
| |
| File: libc.info, Node: SVID Random, Prev: BSD Random, Up: Pseudo-Random Numbers |
| |
| 19.8.3 SVID Random Number Function |
| ---------------------------------- |
| |
| The C library on SVID systems contains yet another kind of random number |
| generator functions. They use a state of 48 bits of data. The user can |
| choose among a collection of functions which return the random bits in |
| different forms. |
| |
| Generally there are two kinds of function. The first uses a state of |
| the random number generator which is shared among several functions and |
| by all threads of the process. The second requires the user to handle |
| the state. |
| |
| All functions have in common that they use the same congruential |
| formula with the same constants. The formula is |
| |
| Y = (a * X + c) mod m |
| |
| where X is the state of the generator at the beginning and Y the state |
| at the end. `a' and `c' are constants determining the way the |
| generator works. By default they are |
| |
| a = 0x5DEECE66D = 25214903917 |
| c = 0xb = 11 |
| |
| but they can also be changed by the user. `m' is of course 2^48 since |
| the state consists of a 48-bit array. |
| |
| The prototypes for these functions are in `stdlib.h'. |
| |
| -- Function: double drand48 (void) |
| Preliminary: | MT-Unsafe race:drand48 | AS-Unsafe | AC-Unsafe |
| corrupt | *Note POSIX Safety Concepts::. |
| |
| This function returns a `double' value in the range of `0.0' to |
| `1.0' (exclusive). The random bits are determined by the global |
| state of the random number generator in the C library. |
| |
| Since the `double' type according to IEEE 754 has a 52-bit |
| mantissa this means 4 bits are not initialized by the random number |
| generator. These are (of course) chosen to be the least |
| significant bits and they are initialized to `0'. |
| |
| -- Function: double erand48 (unsigned short int XSUBI[3]) |
| Preliminary: | MT-Unsafe race:drand48 | AS-Unsafe | AC-Unsafe |
| corrupt | *Note POSIX Safety Concepts::. |
| |
| This function returns a `double' value in the range of `0.0' to |
| `1.0' (exclusive), similarly to `drand48'. The argument is an |
| array describing the state of the random number generator. |
| |
| This function can be called subsequently since it updates the |
| array to guarantee random numbers. The array should have been |
| initialized before initial use to obtain reproducible results. |
| |
| -- Function: long int lrand48 (void) |
| Preliminary: | MT-Unsafe race:drand48 | AS-Unsafe | AC-Unsafe |
| corrupt | *Note POSIX Safety Concepts::. |
| |
| The `lrand48' function returns an integer value in the range of |
| `0' to `2^31' (exclusive). Even if the size of the `long int' |
| type can take more than 32 bits, no higher numbers are returned. |
| The random bits are determined by the global state of the random |
| number generator in the C library. |
| |
| -- Function: long int nrand48 (unsigned short int XSUBI[3]) |
| Preliminary: | MT-Unsafe race:drand48 | AS-Unsafe | AC-Unsafe |
| corrupt | *Note POSIX Safety Concepts::. |
| |
| This function is similar to the `lrand48' function in that it |
| returns a number in the range of `0' to `2^31' (exclusive) but the |
| state of the random number generator used to produce the random |
| bits is determined by the array provided as the parameter to the |
| function. |
| |
| The numbers in the array are updated afterwards so that subsequent |
| calls to this function yield different results (as is expected of |
| a random number generator). The array should have been |
| initialized before the first call to obtain reproducible results. |
| |
| -- Function: long int mrand48 (void) |
| Preliminary: | MT-Unsafe race:drand48 | AS-Unsafe | AC-Unsafe |
| corrupt | *Note POSIX Safety Concepts::. |
| |
| The `mrand48' function is similar to `lrand48'. The only |
| difference is that the numbers returned are in the range `-2^31' to |
| `2^31' (exclusive). |
| |
| -- Function: long int jrand48 (unsigned short int XSUBI[3]) |
| Preliminary: | MT-Unsafe race:drand48 | AS-Unsafe | AC-Unsafe |
| corrupt | *Note POSIX Safety Concepts::. |
| |
| The `jrand48' function is similar to `nrand48'. The only |
| difference is that the numbers returned are in the range `-2^31' to |
| `2^31' (exclusive). For the `xsubi' parameter the same |
| requirements are necessary. |
| |
| The internal state of the random number generator can be initialized |
| in several ways. The methods differ in the completeness of the |
| information provided. |
| |
| -- Function: void srand48 (long int SEEDVAL) |
| Preliminary: | MT-Unsafe race:drand48 | AS-Unsafe | AC-Unsafe |
| corrupt | *Note POSIX Safety Concepts::. |
| |
| The `srand48' function sets the most significant 32 bits of the |
| internal state of the random number generator to the least |
| significant 32 bits of the SEEDVAL parameter. The lower 16 bits |
| are initialized to the value `0x330E'. Even if the `long int' |
| type contains more than 32 bits only the lower 32 bits are used. |
| |
| Owing to this limitation, initialization of the state of this |
| function is not very useful. But it makes it easy to use a |
| construct like `srand48 (time (0))'. |
| |
| A side-effect of this function is that the values `a' and `c' from |
| the internal state, which are used in the congruential formula, |
| are reset to the default values given above. This is of |
| importance once the user has called the `lcong48' function (see |
| below). |
| |
| -- Function: unsigned short int * seed48 (unsigned short int |
| SEED16V[3]) |
| Preliminary: | MT-Unsafe race:drand48 | AS-Unsafe | AC-Unsafe |
| corrupt | *Note POSIX Safety Concepts::. |
| |
| The `seed48' function initializes all 48 bits of the state of the |
| internal random number generator from the contents of the parameter |
| SEED16V. Here the lower 16 bits of the first element of SEED16V |
| initialize the least significant 16 bits of the internal state, |
| the lower 16 bits of `SEED16V[1]' initialize the mid-order 16 bits |
| of the state and the 16 lower bits of `SEED16V[2]' initialize the |
| most significant 16 bits of the state. |
| |
| Unlike `srand48' this function lets the user initialize all 48 bits |
| of the state. |
| |
| The value returned by `seed48' is a pointer to an array containing |
| the values of the internal state before the change. This might be |
| useful to restart the random number generator at a certain state. |
| Otherwise the value can simply be ignored. |
| |
| As for `srand48', the values `a' and `c' from the congruential |
| formula are reset to the default values. |
| |
| There is one more function to initialize the random number generator |
| which enables you to specify even more information by allowing you to |
| change the parameters in the congruential formula. |
| |
| -- Function: void lcong48 (unsigned short int PARAM[7]) |
| Preliminary: | MT-Unsafe race:drand48 | AS-Unsafe | AC-Unsafe |
| corrupt | *Note POSIX Safety Concepts::. |
| |
| The `lcong48' function allows the user to change the complete state |
| of the random number generator. Unlike `srand48' and `seed48', |
| this function also changes the constants in the congruential |
| formula. |
| |
| From the seven elements in the array PARAM the least significant |
| 16 bits of the entries `PARAM[0]' to `PARAM[2]' determine the |
| initial state, the least significant 16 bits of `PARAM[3]' to |
| `PARAM[5]' determine the 48 bit constant `a' and `PARAM[6]' |
| determines the 16-bit value `c'. |
| |
| All the above functions have in common that they use the global |
| parameters for the congruential formula. In multi-threaded programs it |
| might sometimes be useful to have different parameters in different |
| threads. For this reason all the above functions have a counterpart |
| which works on a description of the random number generator in the |
| user-supplied buffer instead of the global state. |
| |
| Please note that it is no problem if several threads use the global |
| state if all threads use the functions which take a pointer to an array |
| containing the state. The random numbers are computed following the |
| same loop but if the state in the array is different all threads will |
| obtain an individual random number generator. |
| |
| The user-supplied buffer must be of type `struct drand48_data'. |
| This type should be regarded as opaque and not manipulated directly. |
| |
| -- Function: int drand48_r (struct drand48_data *BUFFER, double |
| *RESULT) |
| Preliminary: | MT-Safe race:buffer | AS-Safe | AC-Unsafe corrupt | |
| *Note POSIX Safety Concepts::. |
| |
| This function is equivalent to the `drand48' function with the |
| difference that it does not modify the global random number |
| generator parameters but instead the parameters in the buffer |
| supplied through the pointer BUFFER. The random number is |
| returned in the variable pointed to by RESULT. |
| |
| The return value of the function indicates whether the call |
| succeeded. If the value is less than `0' an error occurred and |
| `errno' is set to indicate the problem. |
| |
| This function is a GNU extension and should not be used in portable |
| programs. |
| |
| -- Function: int erand48_r (unsigned short int XSUBI[3], struct |
| drand48_data *BUFFER, double *RESULT) |
| Preliminary: | MT-Safe race:buffer | AS-Safe | AC-Unsafe corrupt | |
| *Note POSIX Safety Concepts::. |
| |
| The `erand48_r' function works like `erand48', but in addition it |
| takes an argument BUFFER which describes the random number |
| generator. The state of the random number generator is taken from |
| the `xsubi' array, the parameters for the congruential formula |
| from the global random number generator data. The random number |
| is returned in the variable pointed to by RESULT. |
| |
| The return value is non-negative if the call succeeded. |
| |
| This function is a GNU extension and should not be used in portable |
| programs. |
| |
| -- Function: int lrand48_r (struct drand48_data *BUFFER, long int |
| *RESULT) |
| Preliminary: | MT-Safe race:buffer | AS-Safe | AC-Unsafe corrupt | |
| *Note POSIX Safety Concepts::. |
| |
| This function is similar to `lrand48', but in addition it takes a |
| pointer to a buffer describing the state of the random number |
| generator just like `drand48'. |
| |
| If the return value of the function is non-negative the variable |
| pointed to by RESULT contains the result. Otherwise an error |
| occurred. |
| |
| This function is a GNU extension and should not be used in portable |
| programs. |
| |
| -- Function: int nrand48_r (unsigned short int XSUBI[3], struct |
| drand48_data *BUFFER, long int *RESULT) |
| Preliminary: | MT-Safe race:buffer | AS-Safe | AC-Unsafe corrupt | |
| *Note POSIX Safety Concepts::. |
| |
| The `nrand48_r' function works like `nrand48' in that it produces |
| a random number in the range `0' to `2^31'. But instead of using |
| the global parameters for the congruential formula it uses the |
| information from the buffer pointed to by BUFFER. The state is |
| described by the values in XSUBI. |
| |
| If the return value is non-negative the variable pointed to by |
| RESULT contains the result. |
| |
| This function is a GNU extension and should not be used in portable |
| programs. |
| |
| -- Function: int mrand48_r (struct drand48_data *BUFFER, long int |
| *RESULT) |
| Preliminary: | MT-Safe race:buffer | AS-Safe | AC-Unsafe corrupt | |
| *Note POSIX Safety Concepts::. |
| |
| This function is similar to `mrand48' but like the other reentrant |
| functions it uses the random number generator described by the |
| value in the buffer pointed to by BUFFER. |
| |
| If the return value is non-negative the variable pointed to by |
| RESULT contains the result. |
| |
| This function is a GNU extension and should not be used in portable |
| programs. |
| |
| -- Function: int jrand48_r (unsigned short int XSUBI[3], struct |
| drand48_data *BUFFER, long int *RESULT) |
| Preliminary: | MT-Safe race:buffer | AS-Safe | AC-Unsafe corrupt | |
| *Note POSIX Safety Concepts::. |
| |
| The `jrand48_r' function is similar to `jrand48'. Like the other |
| reentrant functions of this function family it uses the |
| congruential formula parameters from the buffer pointed to by |
| BUFFER. |
| |
| If the return value is non-negative the variable pointed to by |
| RESULT contains the result. |
| |
| This function is a GNU extension and should not be used in portable |
| programs. |
| |
| Before any of the above functions are used the buffer of type |
| `struct drand48_data' should be initialized. The easiest way to do |
| this is to fill the whole buffer with null bytes, e.g. by |
| |
| memset (buffer, '\0', sizeof (struct drand48_data)); |
| |
| Using any of the reentrant functions of this family now will |
| automatically initialize the random number generator to the default |
| values for the state and the parameters of the congruential formula. |
| |
| The other possibility is to use any of the functions which explicitly |
| initialize the buffer. Though it might be obvious how to initialize the |
| buffer from looking at the parameter to the function, it is highly |
| recommended to use these functions since the result might not always be |
| what you expect. |
| |
| -- Function: int srand48_r (long int SEEDVAL, struct drand48_data |
| *BUFFER) |
| Preliminary: | MT-Safe race:buffer | AS-Safe | AC-Unsafe corrupt | |
| *Note POSIX Safety Concepts::. |
| |
| The description of the random number generator represented by the |
| information in BUFFER is initialized similarly to what the function |
| `srand48' does. The state is initialized from the parameter |
| SEEDVAL and the parameters for the congruential formula are |
| initialized to their default values. |
| |
| If the return value is non-negative the function call succeeded. |
| |
| This function is a GNU extension and should not be used in portable |
| programs. |
| |
| -- Function: int seed48_r (unsigned short int SEED16V[3], struct |
| drand48_data *BUFFER) |
| Preliminary: | MT-Safe race:buffer | AS-Safe | AC-Unsafe corrupt | |
| *Note POSIX Safety Concepts::. |
| |
| This function is similar to `srand48_r' but like `seed48' it |
| initializes all 48 bits of the state from the parameter SEED16V. |
| |
| If the return value is non-negative the function call succeeded. |
| It does not return a pointer to the previous state of the random |
| number generator like the `seed48' function does. If the user |
| wants to preserve the state for a later re-run s/he can copy the |
| whole buffer pointed to by BUFFER. |
| |
| This function is a GNU extension and should not be used in portable |
| programs. |
| |
| -- Function: int lcong48_r (unsigned short int PARAM[7], struct |
| drand48_data *BUFFER) |
| Preliminary: | MT-Safe race:buffer | AS-Safe | AC-Unsafe corrupt | |
| *Note POSIX Safety Concepts::. |
| |
| This function initializes all aspects of the random number |
| generator described in BUFFER with the data in PARAM. Here it is |
| especially true that the function does more than just copying the |
| contents of PARAM and BUFFER. More work is required and therefore |
| it is important to use this function rather than initializing the |
| random number generator directly. |
| |
| If the return value is non-negative the function call succeeded. |
| |
| This function is a GNU extension and should not be used in portable |
| programs. |
| |
| |
| File: libc.info, Node: FP Function Optimizations, Prev: Pseudo-Random Numbers, Up: Mathematics |
| |
| 19.9 Is Fast Code or Small Code preferred? |
| ========================================== |
| |
| If an application uses many floating point functions it is often the |
| case that the cost of the function calls themselves is not negligible. |
| Modern processors can often execute the operations themselves very |
| fast, but the function call disrupts the instruction pipeline. |
| |
| For this reason the GNU C Library provides optimizations for many of |
| the frequently-used math functions. When GNU CC is used and the user |
| activates the optimizer, several new inline functions and macros are |
| defined. These new functions and macros have the same names as the |
| library functions and so are used instead of the latter. In the case of |
| inline functions the compiler will decide whether it is reasonable to |
| use them, and this decision is usually correct. |
| |
| This means that no calls to the library functions may be necessary, |
| and can increase the speed of generated code significantly. The |
| drawback is that code size will increase, and the increase is not |
| always negligible. |
| |
| There are two kinds of inline functions: those that give the same |
| result as the library functions and others that might not set `errno' |
| and might have a reduced precision and/or argument range in comparison |
| with the library functions. The latter inline functions are only |
| available if the flag `-ffast-math' is given to GNU CC. |
| |
| In cases where the inline functions and macros are not wanted the |
| symbol `__NO_MATH_INLINES' should be defined before any system header is |
| included. This will ensure that only library functions are used. Of |
| course, it can be determined for each file in the project whether |
| giving this option is preferable or not. |
| |
| Not all hardware implements the entire IEEE 754 standard, and even |
| if it does there may be a substantial performance penalty for using some |
| of its features. For example, enabling traps on some processors forces |
| the FPU to run un-pipelined, which can more than double calculation |
| time. |
| |
| |
| File: libc.info, Node: Arithmetic, Next: Date and Time, Prev: Mathematics, Up: Top |
| |
| 20 Arithmetic Functions |
| *********************** |
| |
| This chapter contains information about functions for doing basic |
| arithmetic operations, such as splitting a float into its integer and |
| fractional parts or retrieving the imaginary part of a complex value. |
| These functions are declared in the header files `math.h' and |
| `complex.h'. |
| |
| * Menu: |
| |
| * Integers:: Basic integer types and concepts |
| * Integer Division:: Integer division with guaranteed rounding. |
| * Floating Point Numbers:: Basic concepts. IEEE 754. |
| * Floating Point Classes:: The five kinds of floating-point number. |
| * Floating Point Errors:: When something goes wrong in a calculation. |
| * Rounding:: Controlling how results are rounded. |
| * Control Functions:: Saving and restoring the FPU's state. |
| * Arithmetic Functions:: Fundamental operations provided by the library. |
| * Complex Numbers:: The types. Writing complex constants. |
| * Operations on Complex:: Projection, conjugation, decomposition. |
| * Parsing of Numbers:: Converting strings to numbers. |
| * Printing of Floats:: Converting floating-point numbers to strings. |
| * System V Number Conversion:: An archaic way to convert numbers to strings. |
| |
| |
| File: libc.info, Node: Integers, Next: Integer Division, Up: Arithmetic |
| |
| 20.1 Integers |
| ============= |
| |
| The C language defines several integer data types: integer, short |
| integer, long integer, and character, all in both signed and unsigned |
| varieties. The GNU C compiler extends the language to contain long |
| long integers as well. |
| |
| The C integer types were intended to allow code to be portable among |
| machines with different inherent data sizes (word sizes), so each type |
| may have different ranges on different machines. The problem with this |
| is that a program often needs to be written for a particular range of |
| integers, and sometimes must be written for a particular size of |
| storage, regardless of what machine the program runs on. |
| |
| To address this problem, the GNU C Library contains C type |
| definitions you can use to declare integers that meet your exact needs. |
| Because the GNU C Library header files are customized to a specific |
| machine, your program source code doesn't have to be. |
| |
| These `typedef's are in `stdint.h'. |
| |
| If you require that an integer be represented in exactly N bits, use |
| one of the following types, with the obvious mapping to bit size and |
| signedness: |
| |
| * int8_t |
| |
| * int16_t |
| |
| * int32_t |
| |
| * int64_t |
| |
| * uint8_t |
| |
| * uint16_t |
| |
| * uint32_t |
| |
| * uint64_t |
| |
| If your C compiler and target machine do not allow integers of a |
| certain size, the corresponding above type does not exist. |
| |
| If you don't need a specific storage size, but want the smallest data |
| structure with _at least_ N bits, use one of these: |
| |
| * int_least8_t |
| |
| * int_least16_t |
| |
| * int_least32_t |
| |
| * int_least64_t |
| |
| * uint_least8_t |
| |
| * uint_least16_t |
| |
| * uint_least32_t |
| |
| * uint_least64_t |
| |
| If you don't need a specific storage size, but want the data |
| structure that allows the fastest access while having at least N bits |
| (and among data structures with the same access speed, the smallest |
| one), use one of these: |
| |
| * int_fast8_t |
| |
| * int_fast16_t |
| |
| * int_fast32_t |
| |
| * int_fast64_t |
| |
| * uint_fast8_t |
| |
| * uint_fast16_t |
| |
| * uint_fast32_t |
| |
| * uint_fast64_t |
| |
| If you want an integer with the widest range possible on the |
| platform on which it is being used, use one of the following. If you |
| use these, you should write code that takes into account the variable |
| size and range of the integer. |
| |
| * intmax_t |
| |
| * uintmax_t |
| |
| The GNU C Library also provides macros that tell you the maximum and |
| minimum possible values for each integer data type. The macro names |
| follow these examples: `INT32_MAX', `UINT8_MAX', `INT_FAST32_MIN', |
| `INT_LEAST64_MIN', `UINTMAX_MAX', `INTMAX_MAX', `INTMAX_MIN'. Note |
| that there are no macros for unsigned integer minima. These are always |
| zero. Similiarly, there are macros such as `INTMAX_WIDTH' for the |
| width of these types. Those macros for integer type widths come from |
| TS 18661-1:2014. |
| |
| There are similar macros for use with C's built in integer types |
| which should come with your C compiler. These are described in *note |
| Data Type Measurements::. |
| |
| Don't forget you can use the C `sizeof' function with any of these |
| data types to get the number of bytes of storage each uses. |
| |
| |
| File: libc.info, Node: Integer Division, Next: Floating Point Numbers, Prev: Integers, Up: Arithmetic |
| |
| 20.2 Integer Division |
| ===================== |
| |
| This section describes functions for performing integer division. These |
| functions are redundant when GNU CC is used, because in GNU C the `/' |
| operator always rounds towards zero. But in other C implementations, |
| `/' may round differently with negative arguments. `div' and `ldiv' |
| are useful because they specify how to round the quotient: towards |
| zero. The remainder has the same sign as the numerator. |
| |
| These functions are specified to return a result R such that the |
| value `R.quot*DENOMINATOR + R.rem' equals NUMERATOR. |
| |
| To use these facilities, you should include the header file |
| `stdlib.h' in your program. |
| |
| -- Data Type: div_t |
| This is a structure type used to hold the result returned by the |
| `div' function. It has the following members: |
| |
| `int quot' |
| The quotient from the division. |
| |
| `int rem' |
| The remainder from the division. |
| |
| -- Function: div_t div (int NUMERATOR, int DENOMINATOR) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| The function `div' computes the quotient and remainder from the |
| division of NUMERATOR by DENOMINATOR, returning the result in a |
| structure of type `div_t'. |
| |
| If the result cannot be represented (as in a division by zero), the |
| behavior is undefined. |
| |
| Here is an example, albeit not a very useful one. |
| |
| div_t result; |
| result = div (20, -6); |
| |
| Now `result.quot' is `-3' and `result.rem' is `2'. |
| |
| -- Data Type: ldiv_t |
| This is a structure type used to hold the result returned by the |
| `ldiv' function. It has the following members: |
| |
| `long int quot' |
| The quotient from the division. |
| |
| `long int rem' |
| The remainder from the division. |
| |
| (This is identical to `div_t' except that the components are of |
| type `long int' rather than `int'.) |
| |
| -- Function: ldiv_t ldiv (long int NUMERATOR, long int DENOMINATOR) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| The `ldiv' function is similar to `div', except that the arguments |
| are of type `long int' and the result is returned as a structure |
| of type `ldiv_t'. |
| |
| -- Data Type: lldiv_t |
| This is a structure type used to hold the result returned by the |
| `lldiv' function. It has the following members: |
| |
| `long long int quot' |
| The quotient from the division. |
| |
| `long long int rem' |
| The remainder from the division. |
| |
| (This is identical to `div_t' except that the components are of |
| type `long long int' rather than `int'.) |
| |
| -- Function: lldiv_t lldiv (long long int NUMERATOR, long long int |
| DENOMINATOR) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| The `lldiv' function is like the `div' function, but the arguments |
| are of type `long long int' and the result is returned as a |
| structure of type `lldiv_t'. |
| |
| The `lldiv' function was added in ISO C99. |
| |
| -- Data Type: imaxdiv_t |
| This is a structure type used to hold the result returned by the |
| `imaxdiv' function. It has the following members: |
| |
| `intmax_t quot' |
| The quotient from the division. |
| |
| `intmax_t rem' |
| The remainder from the division. |
| |
| (This is identical to `div_t' except that the components are of |
| type `intmax_t' rather than `int'.) |
| |
| See *note Integers:: for a description of the `intmax_t' type. |
| |
| |
| -- Function: imaxdiv_t imaxdiv (intmax_t NUMERATOR, intmax_t |
| DENOMINATOR) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| The `imaxdiv' function is like the `div' function, but the |
| arguments are of type `intmax_t' and the result is returned as a |
| structure of type `imaxdiv_t'. |
| |
| See *note Integers:: for a description of the `intmax_t' type. |
| |
| The `imaxdiv' function was added in ISO C99. |
| |
| |
| File: libc.info, Node: Floating Point Numbers, Next: Floating Point Classes, Prev: Integer Division, Up: Arithmetic |
| |
| 20.3 Floating Point Numbers |
| =========================== |
| |
| Most computer hardware has support for two different kinds of numbers: |
| integers (...-3, -2, -1, 0, 1, 2, 3...) and floating-point numbers. |
| Floating-point numbers have three parts: the "mantissa", the |
| "exponent", and the "sign bit". The real number represented by a |
| floating-point value is given by (s ? -1 : 1) * 2^e * M where s is the |
| sign bit, e the exponent, and M the mantissa. *Note Floating Point |
| Concepts::, for details. (It is possible to have a different "base" |
| for the exponent, but all modern hardware uses 2.) |
| |
| Floating-point numbers can represent a finite subset of the real |
| numbers. While this subset is large enough for most purposes, it is |
| important to remember that the only reals that can be represented |
| exactly are rational numbers that have a terminating binary expansion |
| shorter than the width of the mantissa. Even simple fractions such as |
| 1/5 can only be approximated by floating point. |
| |
| Mathematical operations and functions frequently need to produce |
| values that are not representable. Often these values can be |
| approximated closely enough for practical purposes, but sometimes they |
| can't. Historically there was no way to tell when the results of a |
| calculation were inaccurate. Modern computers implement the IEEE 754 |
| standard for numerical computations, which defines a framework for |
| indicating to the program when the results of calculation are not |
| trustworthy. This framework consists of a set of "exceptions" that |
| indicate why a result could not be represented, and the special values |
| "infinity" and "not a number" (NaN). |
| |
| |
| File: libc.info, Node: Floating Point Classes, Next: Floating Point Errors, Prev: Floating Point Numbers, Up: Arithmetic |
| |
| 20.4 Floating-Point Number Classification Functions |
| =================================================== |
| |
| ISO C99 defines macros that let you determine what sort of |
| floating-point number a variable holds. |
| |
| -- Macro: int fpclassify (_float-type_ X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This is a generic macro which works on all floating-point types and |
| which returns a value of type `int'. The possible values are: |
| |
| `FP_NAN' |
| The floating-point number X is "Not a Number" (*note Infinity |
| and NaN::) |
| |
| `FP_INFINITE' |
| The value of X is either plus or minus infinity (*note |
| Infinity and NaN::) |
| |
| `FP_ZERO' |
| The value of X is zero. In floating-point formats like |
| IEEE 754, where zero can be signed, this value is also |
| returned if X is negative zero. |
| |
| `FP_SUBNORMAL' |
| Numbers whose absolute value is too small to be represented |
| in the normal format are represented in an alternate, |
| "denormalized" format (*note Floating Point Concepts::). |
| This format is less precise but can represent values closer |
| to zero. `fpclassify' returns this value for values of X in |
| this alternate format. |
| |
| `FP_NORMAL' |
| This value is returned for all other values of X. It |
| indicates that there is nothing special about the number. |
| |
| |
| `fpclassify' is most useful if more than one property of a number |
| must be tested. There are more specific macros which only test one |
| property at a time. Generally these macros execute faster than |
| `fpclassify', since there is special hardware support for them. You |
| should therefore use the specific macros whenever possible. |
| |
| -- Macro: int iscanonical (_float-type_ X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| In some floating-point formats, some values have canonical |
| (preferred) and noncanonical encodings (for IEEE interchange |
| binary formats, all encodings are canonical). This macro returns |
| a nonzero value if X has a canonical encoding. It is from TS |
| 18661-1:2014. |
| |
| Note that some formats have multiple encodings of a value which are |
| all equally canonical; `iscanonical' returns a nonzero value for |
| all such encodings. Also, formats may have encodings that do not |
| correspond to any valid value of the type. In ISO C terms these |
| are "trap representations"; in the GNU C Library, `iscanonical' |
| returns zero for such encodings. |
| |
| -- Macro: int isfinite (_float-type_ X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This macro returns a nonzero value if X is finite: not plus or |
| minus infinity, and not NaN. It is equivalent to |
| |
| (fpclassify (x) != FP_NAN && fpclassify (x) != FP_INFINITE) |
| |
| `isfinite' is implemented as a macro which accepts any |
| floating-point type. |
| |
| -- Macro: int isnormal (_float-type_ X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This macro returns a nonzero value if X is finite and normalized. |
| It is equivalent to |
| |
| (fpclassify (x) == FP_NORMAL) |
| |
| -- Macro: int isnan (_float-type_ X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This macro returns a nonzero value if X is NaN. It is equivalent |
| to |
| |
| (fpclassify (x) == FP_NAN) |
| |
| -- Macro: int issignaling (_float-type_ X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This macro returns a nonzero value if X is a signaling NaN (sNaN). |
| It is from TS 18661-1:2014. |
| |
| -- Macro: int issubnormal (_float-type_ X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This macro returns a nonzero value if X is subnormal. It is from |
| TS 18661-1:2014. |
| |
| -- Macro: int iszero (_float-type_ X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This macro returns a nonzero value if X is zero. It is from TS |
| 18661-1:2014. |
| |
| Another set of floating-point classification functions was provided |
| by BSD. The GNU C Library also supports these functions; however, we |
| recommend that you use the ISO C99 macros in new code. Those are |
| standard and will be available more widely. Also, since they are |
| macros, you do not have to worry about the type of their argument. |
| |
| -- Function: int isinf (double X) |
| -- Function: int isinff (float X) |
| -- Function: int isinfl (long double X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This function returns `-1' if X represents negative infinity, `1' |
| if X represents positive infinity, and `0' otherwise. |
| |
| -- Function: int isnan (double X) |
| -- Function: int isnanf (float X) |
| -- Function: int isnanl (long double X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This function returns a nonzero value if X is a "not a number" |
| value, and zero otherwise. |
| |
| *NB:* The `isnan' macro defined by ISO C99 overrides the BSD |
| function. This is normally not a problem, because the two |
| routines behave identically. However, if you really need to get |
| the BSD function for some reason, you can write |
| |
| (isnan) (x) |
| |
| -- Function: int finite (double X) |
| -- Function: int finitef (float X) |
| -- Function: int finitel (long double X) |
| Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety |
| Concepts::. |
| |
| This function returns a nonzero value if X is neither infinite nor |
| a "not a number" value, and zero otherwise. |
| |
| *Portability Note:* The functions listed in this section are BSD |
| extensions. |
| |
| |
| File: libc.info, Node: Floating Point Errors, Next: Rounding, Prev: Floating Point Classes, Up: Arithmetic |
| |
| 20.5 Errors in Floating-Point Calculations |
| ========================================== |
| |
| * Menu: |
| |
| * FP Exceptions:: IEEE 754 math exceptions and how to detect them. |
| * Infinity and NaN:: Special values returned by calculations. |
| * Status bit operations:: Checking for exceptions after the fact. |
| * Math Error Reporting:: How the math functions report errors. |
| |
| |
| File: libc.info, Node: FP Exceptions, Next: Infinity and NaN, Up: Floating Point Errors |
| |
| 20.5.1 FP Exceptions |
| -------------------- |
| |
| The IEEE 754 standard defines five "exceptions" that can occur during a |
| calculation. Each corresponds to a particular sort of error, such as |
| overflow. |
| |
| When exceptions occur (when exceptions are "raised", in the language |
| of the standard), one of two things can happen. By default the |
| exception is simply noted in the floating-point "status word", and the |
| program continues as if nothing had happened. The operation produces a |
| default value, which depends on the exception (see the table below). |
| Your program can check the status word to find out which exceptions |
| happened. |
| |
| Alternatively, you can enable "traps" for exceptions. In that case, |
| when an exception is raised, your program will receive the `SIGFPE' |
| signal. The default action for this signal is to terminate the |
| program. *Note Signal Handling::, for how you can change the effect of |
| the signal. |
| |
| The exceptions defined in IEEE 754 are: |
| |
| `Invalid Operation' |
| This exception is raised if the given operands are invalid for the |
| operation to be performed. Examples are (see IEEE 754, section 7): |
| 1. Addition or subtraction: oo - oo. (But oo + oo = oo). |
| |
| 2. Multiplication: 0 * oo. |
| |
| 3. Division: 0/0 or oo/oo. |
| |
| 4. Remainder: x REM y, where y is zero or x is infinite. |
| |
| 5. Square root if the operand is less than zero. More |
| generally, any mathematical function evaluated outside its |
| domain produces this exception. |
| |
| 6. Conversion of a floating-point number to an integer or decimal |
| string, when the number cannot be represented in the target |
| format (due to overflow, infinity, or NaN). |
| |
| 7. Conversion of an unrecognizable input string. |
| |
| 8. Comparison via predicates involving < or >, when one or other |
| of the operands is NaN. You can prevent this exception by |
| using the unordered comparison functions instead; see *note |
| FP Comparison Functions::. |
| |
| If the exception does not trap, the result of the operation is NaN. |
| |
| `Division by Zero' |
| This exception is raised when a finite nonzero number is divided |
| by zero. If no trap occurs the result is either +oo or -oo, |
| depending on the signs of the operands. |
| |
| `Overflow' |
| This exception is raised whenever the result cannot be represented |
| as a finite value in the precision format of the destination. If |
| no trap occurs the result depends on the sign of the intermediate |
| result and the current rounding mode (IEEE 754, section 7.3): |
| 1. Round to nearest carries all overflows to oo with the sign of |
| the intermediate result. |
| |
| 2. Round toward 0 carries all overflows to the largest |
| representable finite number with the sign of the intermediate |
| result. |
| |
| 3. Round toward -oo carries positive overflows to the largest |
| representable finite number and negative overflows to -oo. |
| |
| 4. Round toward oo carries negative overflows to the most |
| negative representable finite number and positive overflows |
| to oo. |
| |
| Whenever the overflow exception is raised, the inexact exception |
| is also raised. |
| |
| `Underflow' |
| The underflow exception is raised when an intermediate result is |
| too small to be calculated accurately, or if the operation's |
| result rounded to the destination precision is too small to be |
| normalized. |
| |
| When no trap is installed for the underflow exception, underflow is |
| signaled (via the underflow flag) only when both tininess and loss |
| of accuracy have been detected. If no trap handler is installed |
| the operation continues with an imprecise small value, or zero if |
| the destination precision cannot hold the small exact result. |
| |
| `Inexact' |
| This exception is signalled if a rounded result is not exact (such |
| as when calculating the square root of two) or a result overflows |
| without an overflow trap. |
| |
| |
| |
| Local Variables: |
| coding: utf-8 |
| End: |