This is libc.info, produced by makeinfo version 5.1 from libc.texinfo. This is ‘The GNU C Library Reference Manual’, for version 2.36 (Arm). Copyright © 1993–2022 Free Software Foundation, Inc. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with the Invariant Sections being “Free Software Needs Free Documentation” and “GNU Lesser General Public License”, the Front-Cover texts being “A GNU Manual”, and with the Back-Cover Texts as in (a) below. A copy of the license is included in the section entitled "GNU Free Documentation License". (a) The FSF’s Back-Cover Text is: “You have the freedom to copy and modify this GNU manual. Buying copies from the FSF supports it in developing GNU and promoting software freedom.” INFO-DIR-SECTION Software libraries START-INFO-DIR-ENTRY * Libc: (libc). C library. END-INFO-DIR-ENTRY INFO-DIR-SECTION GNU C library functions and macros START-INFO-DIR-ENTRY * ALTWERASE: (libc)Local Modes. * ARGP_ERR_UNKNOWN: (libc)Argp Parser Functions. * ARG_MAX: (libc)General Limits. * BC_BASE_MAX: (libc)Utility Limits. * BC_DIM_MAX: (libc)Utility Limits. * BC_SCALE_MAX: (libc)Utility Limits. * BC_STRING_MAX: (libc)Utility Limits. * BRKINT: (libc)Input Modes. * BUFSIZ: (libc)Controlling Buffering. * CCTS_OFLOW: (libc)Control Modes. * 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. * CLOCK_MONOTONIC: (libc)Getting the Time. * CLOCK_REALTIME: (libc)Getting the Time. * COLL_WEIGHTS_MAX: (libc)Utility Limits. * CPU_CLR: (libc)CPU Affinity. * CPU_FEATURE_ACTIVE: (libc)X86. * CPU_FEATURE_PRESENT: (libc)X86. * 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. * DLFO_EH_SEGMENT_TYPE: (libc)Dynamic Linker Introspection. * DLFO_STRUCT_HAS_EH_COUNT: (libc)Dynamic Linker Introspection. * DLFO_STRUCT_HAS_EH_DBASE: (libc)Dynamic Linker Introspection. * 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_NOFOLLOW: (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_PATH: (libc)Access Modes. * 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. * PTHREAD_ATTR_NO_SIGMASK_NP: (libc)Initial Thread Signal Mask. * P_tmpdir: (libc)Temporary Files. * RAND_MAX: (libc)ISO Random. * RE_DUP_MAX: (libc)General Limits. * RLIM_INFINITY: (libc)Limits on Resources. * RSEQ_SIG: (libc)Restartable Sequences. * 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. * _Fork: (libc)Creating a Process. * _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. * __x86_get_cpuid_feature_leaf: (libc)X86. * _dl_find_object: (libc)Dynamic Linker Introspection. * _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)Setting and Adjusting the Time. * adjtimex: (libc)Setting and Adjusting the Time. * 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. * arc4random: (libc)High Quality Random. * arc4random_buf: (libc)High Quality Random. * arc4random_uniform: (libc)High Quality Random. * 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. * clock_getres: (libc)Getting the Time. * clock_gettime: (libc)Getting the Time. * clock_settime: (libc)Setting and Adjusting the 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. * close_range: (libc)Opening and Closing Files. * closedir: (libc)Reading/Closing Directory. * closefrom: (libc)Opening and Closing Files. * 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. * dfmal: (libc)Misc FP Arithmetic. * dgettext: (libc)Translation with gettext. * difftime: (libc)Calculating Elapsed Time. * dirfd: (libc)Opening a Directory. * dirname: (libc)Finding Tokens in a String. * div: (libc)Integer Division. * dlinfo: (libc)Dynamic Linker Introspection. * 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. * dsqrtl: (libc)Misc FP Arithmetic. * 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. * fMfmafN: (libc)Misc FP Arithmetic. * fMfmafNx: (libc)Misc FP Arithmetic. * fMmulfN: (libc)Misc FP Arithmetic. * fMmulfNx: (libc)Misc FP Arithmetic. * fMsqrtfN: (libc)Misc FP Arithmetic. * fMsqrtfNx: (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. * fMxfmafN: (libc)Misc FP Arithmetic. * fMxfmafNx: (libc)Misc FP Arithmetic. * fMxmulfN: (libc)Misc FP Arithmetic. * fMxmulfNx: (libc)Misc FP Arithmetic. * fMxsqrtfN: (libc)Misc FP Arithmetic. * fMxsqrtfNx: (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. * fexecve: (libc)Executing a File. * fflush: (libc)Flushing Buffers. * fflush_unlocked: (libc)Flushing Buffers. * ffma: (libc)Misc FP Arithmetic. * ffmal: (libc)Misc FP Arithmetic. * 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. * fmaximum: (libc)Misc FP Arithmetic. * fmaximum_mag: (libc)Misc FP Arithmetic. * fmaximum_mag_num: (libc)Misc FP Arithmetic. * fmaximum_mag_numf: (libc)Misc FP Arithmetic. * fmaximum_mag_numfN: (libc)Misc FP Arithmetic. * fmaximum_mag_numfNx: (libc)Misc FP Arithmetic. * fmaximum_mag_numl: (libc)Misc FP Arithmetic. * fmaximum_magf: (libc)Misc FP Arithmetic. * fmaximum_magfN: (libc)Misc FP Arithmetic. * fmaximum_magfNx: (libc)Misc FP Arithmetic. * fmaximum_magl: (libc)Misc FP Arithmetic. * fmaximum_num: (libc)Misc FP Arithmetic. * fmaximum_numf: (libc)Misc FP Arithmetic. * fmaximum_numfN: (libc)Misc FP Arithmetic. * fmaximum_numfNx: (libc)Misc FP Arithmetic. * fmaximum_numl: (libc)Misc FP Arithmetic. * fmaximumf: (libc)Misc FP Arithmetic. * fmaximumfN: (libc)Misc FP Arithmetic. * fmaximumfNx: (libc)Misc FP Arithmetic. * fmaximuml: (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. * fminimum: (libc)Misc FP Arithmetic. * fminimum_mag: (libc)Misc FP Arithmetic. * fminimum_mag_num: (libc)Misc FP Arithmetic. * fminimum_mag_numf: (libc)Misc FP Arithmetic. * fminimum_mag_numfN: (libc)Misc FP Arithmetic. * fminimum_mag_numfNx: (libc)Misc FP Arithmetic. * fminimum_mag_numl: (libc)Misc FP Arithmetic. * fminimum_magf: (libc)Misc FP Arithmetic. * fminimum_magfN: (libc)Misc FP Arithmetic. * fminimum_magfNx: (libc)Misc FP Arithmetic. * fminimum_magl: (libc)Misc FP Arithmetic. * fminimum_num: (libc)Misc FP Arithmetic. * fminimum_numf: (libc)Misc FP Arithmetic. * fminimum_numfN: (libc)Misc FP Arithmetic. * fminimum_numfNx: (libc)Misc FP Arithmetic. * fminimum_numl: (libc)Misc FP Arithmetic. * fminimumf: (libc)Misc FP Arithmetic. * fminimumfN: (libc)Misc FP Arithmetic. * fminimumfNx: (libc)Misc FP Arithmetic. * fminimuml: (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. * fsqrt: (libc)Misc FP Arithmetic. * fsqrtl: (libc)Misc FP Arithmetic. * 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)Getting the Time. * 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. * mallinfo2: (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)Setting and Adjusting the Time. * ntp_gettime: (libc)Setting and Adjusting the Time. * 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_attr_getsigmask_np: (libc)Initial Thread Signal Mask. * pthread_attr_setsigmask_np: (libc)Initial Thread Signal Mask. * pthread_clockjoin_np: (libc)Waiting with Explicit Clocks. * pthread_cond_clockwait: (libc)Waiting with Explicit Clocks. * 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)Waiting with Explicit Clocks. * pthread_rwlock_clockwrlock: (libc)Waiting with Explicit Clocks. * pthread_setattr_default_np: (libc)Default Thread Attributes. * pthread_setspecific: (libc)Thread-specific Data. * pthread_timedjoin_np: (libc)Waiting with Explicit Clocks. * pthread_tryjoin_np: (libc)Waiting with Explicit Clocks. * 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)Waiting with Explicit Clocks. * 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)Setting and Adjusting the Time. * 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. * sigabbrev_np: (libc)Signal Messages. * sigaction: (libc)Advanced Signal Handling. * sigaddset: (libc)Signal Sets. * sigaltstack: (libc)Signal Stack. * sigblock: (libc)BSD Signal Handling. * sigdelset: (libc)Signal Sets. * sigdescr_np: (libc)Signal Messages. * 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)Setting and Adjusting the 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. * strerrordesc_np: (libc)Error Messages. * strerrorname_np: (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. * 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)Getting the 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. * 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  File: libc.info, Node: Streams and I18N, Next: Simple Output, Prev: Streams and Threads, Up: I/O on Streams 12.6 Streams in Internationalized Applications ============================================== ISO C90 introduced the new type ‘wchar_t’ to allow handling larger character sets. What was missing was a possibility to output strings of ‘wchar_t’ directly. One had to convert them into multibyte strings using ‘mbstowcs’ (there was no ‘mbsrtowcs’ yet) and then use the normal stream functions. While this is doable it is very cumbersome since performing the conversions is not trivial and greatly increases program complexity and size. The Unix standard early on (I think in XPG4.2) introduced two additional format specifiers for the ‘printf’ and ‘scanf’ families of functions. Printing and reading of single wide characters was made possible using the ‘%C’ specifier and wide character strings can be handled with ‘%S’. These modifiers behave just like ‘%c’ and ‘%s’ only that they expect the corresponding argument to have the wide character type and that the wide character and string are transformed into/from multibyte strings before being used. This was a beginning but it is still not good enough. Not always is it desirable to use ‘printf’ and ‘scanf’. The other, smaller and faster functions cannot handle wide characters. Second, it is not possible to have a format string for ‘printf’ and ‘scanf’ consisting of wide characters. The result is that format strings would have to be generated if they have to contain non-basic characters. In the Amendment 1 to ISO C90 a whole new set of functions was added to solve the problem. Most of the stream functions got a counterpart which take a wide character or wide character string instead of a character or string respectively. The new functions operate on the same streams (like ‘stdout’). This is different from the model of the C++ runtime library where separate streams for wide and normal I/O are used. Being able to use the same stream for wide and normal operations comes with a restriction: a stream can be used either for wide operations or for normal operations. Once it is decided there is no way back. Only a call to ‘freopen’ or ‘freopen64’ can reset the "orientation". The orientation can be decided in three ways: • If any of the normal character functions are used (this includes the ‘fread’ and ‘fwrite’ functions) the stream is marked as not wide oriented. • If any of the wide character functions are used the stream is marked as wide oriented. • The ‘fwide’ function can be used to set the orientation either way. It is important to never mix the use of wide and not wide operations on a stream. There are no diagnostics issued. The application behavior will simply be strange or the application will simply crash. The ‘fwide’ function can help avoid this. -- Function: int fwide (FILE *STREAM, int MODE) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe lock | *Note POSIX Safety Concepts::. The ‘fwide’ function can be used to set and query the state of the orientation of the stream STREAM. If the MODE parameter has a positive value the streams get wide oriented, for negative values narrow oriented. It is not possible to overwrite previous orientations with ‘fwide’. I.e., if the stream STREAM was already oriented before the call nothing is done. If MODE is zero the current orientation state is queried and nothing is changed. The ‘fwide’ function returns a negative value, zero, or a positive value if the stream is narrow, not at all, or wide oriented respectively. This function was introduced in Amendment 1 to ISO C90 and is declared in ‘wchar.h’. It is generally a good idea to orient a stream as early as possible. This can prevent surprise especially for the standard streams ‘stdin’, ‘stdout’, and ‘stderr’. If some library function in some situations uses one of these streams and this use orients the stream in a different way the rest of the application expects it one might end up with hard to reproduce errors. Remember that no errors are signal if the streams are used incorrectly. Leaving a stream unoriented after creation is normally only necessary for library functions which create streams which can be used in different contexts. When writing code which uses streams and which can be used in different contexts it is important to query the orientation of the stream before using it (unless the rules of the library interface demand a specific orientation). The following little, silly function illustrates this. void print_f (FILE *fp) { if (fwide (fp, 0) > 0) /* Positive return value means wide orientation. */ fputwc (L'f', fp); else fputc ('f', fp); } Note that in this case the function ‘print_f’ decides about the orientation of the stream if it was unoriented before (will not happen if the advice above is followed). The encoding used for the ‘wchar_t’ values is unspecified and the user must not make any assumptions about it. For I/O of ‘wchar_t’ values this means that it is impossible to write these values directly to the stream. This is not what follows from the ISO C locale model either. What happens instead is that the bytes read from or written to the underlying media are first converted into the internal encoding chosen by the implementation for ‘wchar_t’. The external encoding is determined by the ‘LC_CTYPE’ category of the current locale or by the ‘ccs’ part of the mode specification given to ‘fopen’, ‘fopen64’, ‘freopen’, or ‘freopen64’. How and when the conversion happens is unspecified and it happens invisibly to the user. Since a stream is created in the unoriented state it has at that point no conversion associated with it. The conversion which will be used is determined by the ‘LC_CTYPE’ category selected at the time the stream is oriented. If the locales are changed at the runtime this might produce surprising results unless one pays attention. This is just another good reason to orient the stream explicitly as soon as possible, perhaps with a call to ‘fwide’.  File: libc.info, Node: Simple Output, Next: Character Input, Prev: Streams and I18N, Up: I/O on Streams 12.7 Simple Output by Characters or Lines ========================================= This section describes functions for performing character- and line-oriented output. These narrow stream functions are declared in the header file ‘stdio.h’ and the wide stream functions in ‘wchar.h’. -- Function: int fputc (int C, FILE *STREAM) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe corrupt lock | *Note POSIX Safety Concepts::. The ‘fputc’ function converts the character C to type ‘unsigned char’, and writes it to the stream STREAM. ‘EOF’ is returned if a write error occurs; otherwise the character C is returned. -- Function: wint_t fputwc (wchar_t WC, FILE *STREAM) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe corrupt lock | *Note POSIX Safety Concepts::. The ‘fputwc’ function writes the wide character WC to the stream STREAM. ‘WEOF’ is returned if a write error occurs; otherwise the character WC is returned. -- Function: int fputc_unlocked (int C, FILE *STREAM) Preliminary: | MT-Safe race:stream | AS-Unsafe corrupt | AC-Unsafe corrupt | *Note POSIX Safety Concepts::. The ‘fputc_unlocked’ function is equivalent to the ‘fputc’ function except that it does not implicitly lock the stream. -- Function: wint_t fputwc_unlocked (wchar_t WC, FILE *STREAM) Preliminary: | MT-Safe race:stream | AS-Unsafe corrupt | AC-Unsafe corrupt | *Note POSIX Safety Concepts::. The ‘fputwc_unlocked’ function is equivalent to the ‘fputwc’ function except that it does not implicitly lock the stream. This function is a GNU extension. -- Function: int putc (int C, FILE *STREAM) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe corrupt lock | *Note POSIX Safety Concepts::. This is just like ‘fputc’, except that most systems implement it as a macro, making it faster. One consequence is that it may evaluate the STREAM argument more than once, which is an exception to the general rule for macros. ‘putc’ is usually the best function to use for writing a single character. -- Function: wint_t putwc (wchar_t WC, FILE *STREAM) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe corrupt lock | *Note POSIX Safety Concepts::. This is just like ‘fputwc’, except that it can be implement as a macro, making it faster. One consequence is that it may evaluate the STREAM argument more than once, which is an exception to the general rule for macros. ‘putwc’ is usually the best function to use for writing a single wide character. -- Function: int putc_unlocked (int C, FILE *STREAM) Preliminary: | MT-Safe race:stream | AS-Unsafe corrupt | AC-Unsafe corrupt | *Note POSIX Safety Concepts::. The ‘putc_unlocked’ function is equivalent to the ‘putc’ function except that it does not implicitly lock the stream. -- Function: wint_t putwc_unlocked (wchar_t WC, FILE *STREAM) Preliminary: | MT-Safe race:stream | AS-Unsafe corrupt | AC-Unsafe corrupt | *Note POSIX Safety Concepts::. The ‘putwc_unlocked’ function is equivalent to the ‘putwc’ function except that it does not implicitly lock the stream. This function is a GNU extension. -- Function: int putchar (int C) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe corrupt lock | *Note POSIX Safety Concepts::. The ‘putchar’ function is equivalent to ‘putc’ with ‘stdout’ as the value of the STREAM argument. -- Function: wint_t putwchar (wchar_t WC) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe corrupt lock | *Note POSIX Safety Concepts::. The ‘putwchar’ function is equivalent to ‘putwc’ with ‘stdout’ as the value of the STREAM argument. -- Function: int putchar_unlocked (int C) Preliminary: | MT-Unsafe race:stdout | AS-Unsafe corrupt | AC-Unsafe corrupt | *Note POSIX Safety Concepts::. The ‘putchar_unlocked’ function is equivalent to the ‘putchar’ function except that it does not implicitly lock the stream. -- Function: wint_t putwchar_unlocked (wchar_t WC) Preliminary: | MT-Unsafe race:stdout | AS-Unsafe corrupt | AC-Unsafe corrupt | *Note POSIX Safety Concepts::. The ‘putwchar_unlocked’ function is equivalent to the ‘putwchar’ function except that it does not implicitly lock the stream. This function is a GNU extension. -- Function: int fputs (const char *S, FILE *STREAM) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe corrupt lock | *Note POSIX Safety Concepts::. The function ‘fputs’ writes the string S to the stream STREAM. The terminating null character is not written. This function does _not_ add a newline character, either. It outputs only the characters in the string. This function returns ‘EOF’ if a write error occurs, and otherwise a non-negative value. For example: fputs ("Are ", stdout); fputs ("you ", stdout); fputs ("hungry?\n", stdout); outputs the text ‘Are you hungry?’ followed by a newline. -- Function: int fputws (const wchar_t *WS, FILE *STREAM) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe corrupt lock | *Note POSIX Safety Concepts::. The function ‘fputws’ writes the wide character string WS to the stream STREAM. The terminating null character is not written. This function does _not_ add a newline character, either. It outputs only the characters in the string. This function returns ‘WEOF’ if a write error occurs, and otherwise a non-negative value. -- Function: int fputs_unlocked (const char *S, FILE *STREAM) Preliminary: | MT-Safe race:stream | AS-Unsafe corrupt | AC-Unsafe corrupt | *Note POSIX Safety Concepts::. The ‘fputs_unlocked’ function is equivalent to the ‘fputs’ function except that it does not implicitly lock the stream. This function is a GNU extension. -- Function: int fputws_unlocked (const wchar_t *WS, FILE *STREAM) Preliminary: | MT-Safe race:stream | AS-Unsafe corrupt | AC-Unsafe corrupt | *Note POSIX Safety Concepts::. The ‘fputws_unlocked’ function is equivalent to the ‘fputws’ function except that it does not implicitly lock the stream. This function is a GNU extension. -- Function: int puts (const char *S) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe lock corrupt | *Note POSIX Safety Concepts::. The ‘puts’ function writes the string S to the stream ‘stdout’ followed by a newline. The terminating null character of the string is not written. (Note that ‘fputs’ does _not_ write a newline as this function does.) ‘puts’ is the most convenient function for printing simple messages. For example: puts ("This is a message."); outputs the text ‘This is a message.’ followed by a newline. -- Function: int putw (int W, FILE *STREAM) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe lock corrupt | *Note POSIX Safety Concepts::. This function writes the word W (that is, an ‘int’) to STREAM. It is provided for compatibility with SVID, but we recommend you use ‘fwrite’ instead (*note Block Input/Output::).  File: libc.info, Node: Character Input, Next: Line Input, Prev: Simple Output, Up: I/O on Streams 12.8 Character Input ==================== This section describes functions for performing character-oriented input. These narrow stream functions are declared in the header file ‘stdio.h’ and the wide character functions are declared in ‘wchar.h’. These functions return an ‘int’ or ‘wint_t’ value (for narrow and wide stream functions respectively) that is either a character of input, or the special value ‘EOF’/‘WEOF’ (usually -1). For the narrow stream functions it is important to store the result of these functions in a variable of type ‘int’ instead of ‘char’, even when you plan to use it only as a character. Storing ‘EOF’ in a ‘char’ variable truncates its value to the size of a character, so that it is no longer distinguishable from the valid character ‘(char) -1’. So always use an ‘int’ for the result of ‘getc’ and friends, and check for ‘EOF’ after the call; once you’ve verified that the result is not ‘EOF’, you can be sure that it will fit in a ‘char’ variable without loss of information. -- Function: int fgetc (FILE *STREAM) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe lock corrupt | *Note POSIX Safety Concepts::. This function reads the next character as an ‘unsigned char’ from the stream STREAM and returns its value, converted to an ‘int’. If an end-of-file condition or read error occurs, ‘EOF’ is returned instead. -- Function: wint_t fgetwc (FILE *STREAM) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe lock corrupt | *Note POSIX Safety Concepts::. This function reads the next wide character from the stream STREAM and returns its value. If an end-of-file condition or read error occurs, ‘WEOF’ is returned instead. -- Function: int fgetc_unlocked (FILE *STREAM) Preliminary: | MT-Safe race:stream | AS-Unsafe corrupt | AC-Unsafe corrupt | *Note POSIX Safety Concepts::. The ‘fgetc_unlocked’ function is equivalent to the ‘fgetc’ function except that it does not implicitly lock the stream. -- Function: wint_t fgetwc_unlocked (FILE *STREAM) Preliminary: | MT-Safe race:stream | AS-Unsafe corrupt | AC-Unsafe corrupt | *Note POSIX Safety Concepts::. The ‘fgetwc_unlocked’ function is equivalent to the ‘fgetwc’ function except that it does not implicitly lock the stream. This function is a GNU extension. -- Function: int getc (FILE *STREAM) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe lock corrupt | *Note POSIX Safety Concepts::. This is just like ‘fgetc’, except that it is permissible (and typical) for it to be implemented as a macro that evaluates the STREAM argument more than once. ‘getc’ is often highly optimized, so it is usually the best function to use to read a single character. -- Function: wint_t getwc (FILE *STREAM) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe lock corrupt | *Note POSIX Safety Concepts::. This is just like ‘fgetwc’, except that it is permissible for it to be implemented as a macro that evaluates the STREAM argument more than once. ‘getwc’ can be highly optimized, so it is usually the best function to use to read a single wide character. -- Function: int getc_unlocked (FILE *STREAM) Preliminary: | MT-Safe race:stream | AS-Unsafe corrupt | AC-Unsafe corrupt | *Note POSIX Safety Concepts::. The ‘getc_unlocked’ function is equivalent to the ‘getc’ function except that it does not implicitly lock the stream. -- Function: wint_t getwc_unlocked (FILE *STREAM) Preliminary: | MT-Safe race:stream | AS-Unsafe corrupt | AC-Unsafe corrupt | *Note POSIX Safety Concepts::. The ‘getwc_unlocked’ function is equivalent to the ‘getwc’ function except that it does not implicitly lock the stream. This function is a GNU extension. -- Function: int getchar (void) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe lock corrupt | *Note POSIX Safety Concepts::. The ‘getchar’ function is equivalent to ‘getc’ with ‘stdin’ as the value of the STREAM argument. -- Function: wint_t getwchar (void) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe lock corrupt | *Note POSIX Safety Concepts::. The ‘getwchar’ function is equivalent to ‘getwc’ with ‘stdin’ as the value of the STREAM argument. -- Function: int getchar_unlocked (void) Preliminary: | MT-Unsafe race:stdin | AS-Unsafe corrupt | AC-Unsafe corrupt | *Note POSIX Safety Concepts::. The ‘getchar_unlocked’ function is equivalent to the ‘getchar’ function except that it does not implicitly lock the stream. -- Function: wint_t getwchar_unlocked (void) Preliminary: | MT-Unsafe race:stdin | AS-Unsafe corrupt | AC-Unsafe corrupt | *Note POSIX Safety Concepts::. The ‘getwchar_unlocked’ function is equivalent to the ‘getwchar’ function except that it does not implicitly lock the stream. This function is a GNU extension. Here is an example of a function that does input using ‘fgetc’. It would work just as well using ‘getc’ instead, or using ‘getchar ()’ instead of ‘fgetc (stdin)’. The code would also work the same for the wide character stream functions. int y_or_n_p (const char *question) { fputs (question, stdout); while (1) { int c, answer; /* Write a space to separate answer from question. */ fputc (' ', stdout); /* Read the first character of the line. This should be the answer character, but might not be. */ c = tolower (fgetc (stdin)); answer = c; /* Discard rest of input line. */ while (c != '\n' && c != EOF) c = fgetc (stdin); /* Obey the answer if it was valid. */ if (answer == 'y') return 1; if (answer == 'n') return 0; /* Answer was invalid: ask for valid answer. */ fputs ("Please answer y or n:", stdout); } } -- Function: int getw (FILE *STREAM) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe lock corrupt | *Note POSIX Safety Concepts::. This function reads a word (that is, an ‘int’) from STREAM. It’s provided for compatibility with SVID. We recommend you use ‘fread’ instead (*note Block Input/Output::). Unlike ‘getc’, any ‘int’ value could be a valid result. ‘getw’ returns ‘EOF’ when it encounters end-of-file or an error, but there is no way to distinguish this from an input word with value -1.  File: libc.info, Node: Line Input, Next: Unreading, Prev: Character Input, Up: I/O on Streams 12.9 Line-Oriented Input ======================== Since many programs interpret input on the basis of lines, it is convenient to have functions to read a line of text from a stream. Standard C has functions to do this, but they aren’t very safe: null characters and even (for ‘gets’) long lines can confuse them. So the GNU C Library provides the nonstandard ‘getline’ function that makes it easy to read lines reliably. Another GNU extension, ‘getdelim’, generalizes ‘getline’. It reads a delimited record, defined as everything through the next occurrence of a specified delimiter character. All these functions are declared in ‘stdio.h’. -- Function: ssize_t getline (char **LINEPTR, size_t *N, FILE *STREAM) Preliminary: | MT-Safe | AS-Unsafe corrupt heap | AC-Unsafe lock corrupt mem | *Note POSIX Safety Concepts::. This function reads an entire line from STREAM, storing the text (including the newline and a terminating null character) in a buffer and storing the buffer address in ‘*LINEPTR’. Before calling ‘getline’, you should place in ‘*LINEPTR’ the address of a buffer ‘*N’ bytes long, allocated with ‘malloc’. If this buffer is long enough to hold the line, ‘getline’ stores the line in this buffer. Otherwise, ‘getline’ makes the buffer bigger using ‘realloc’, storing the new buffer address back in ‘*LINEPTR’ and the increased size back in ‘*N’. *Note Unconstrained Allocation::. If you set ‘*LINEPTR’ to a null pointer, and ‘*N’ to zero, before the call, then ‘getline’ allocates the initial buffer for you by calling ‘malloc’. This buffer remains allocated even if ‘getline’ encounters errors and is unable to read any bytes. In either case, when ‘getline’ returns, ‘*LINEPTR’ is a ‘char *’ which points to the text of the line. When ‘getline’ is successful, it returns the number of characters read (including the newline, but not including the terminating null). This value enables you to distinguish null characters that are part of the line from the null character inserted as a terminator. This function is a GNU extension, but it is the recommended way to read lines from a stream. The alternative standard functions are unreliable. If an error occurs or end of file is reached without any bytes read, ‘getline’ returns ‘-1’. -- Function: ssize_t getdelim (char **LINEPTR, size_t *N, int DELIMITER, FILE *STREAM) Preliminary: | MT-Safe | AS-Unsafe corrupt heap | AC-Unsafe lock corrupt mem | *Note POSIX Safety Concepts::. This function is like ‘getline’ except that the character which tells it to stop reading is not necessarily newline. The argument DELIMITER specifies the delimiter character; ‘getdelim’ keeps reading until it sees that character (or end of file). The text is stored in LINEPTR, including the delimiter character and a terminating null. Like ‘getline’, ‘getdelim’ makes LINEPTR bigger if it isn’t big enough. ‘getline’ is in fact implemented in terms of ‘getdelim’, just like this: ssize_t getline (char **lineptr, size_t *n, FILE *stream) { return getdelim (lineptr, n, '\n', stream); } -- Function: char * fgets (char *S, int COUNT, FILE *STREAM) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe lock corrupt | *Note POSIX Safety Concepts::. The ‘fgets’ function reads characters from the stream STREAM up to and including a newline character and stores them in the string S, adding a null character to mark the end of the string. You must supply COUNT characters worth of space in S, but the number of characters read is at most COUNT − 1. The extra character space is used to hold the null character at the end of the string. If the system is already at end of file when you call ‘fgets’, then the contents of the array S are unchanged and a null pointer is returned. A null pointer is also returned if a read error occurs. Otherwise, the return value is the pointer S. *Warning:* If the input data has a null character, you can’t tell. So don’t use ‘fgets’ unless you know the data cannot contain a null. Don’t use it to read files edited by the user because, if the user inserts a null character, you should either handle it properly or print a clear error message. We recommend using ‘getline’ instead of ‘fgets’. -- Function: wchar_t * fgetws (wchar_t *WS, int COUNT, FILE *STREAM) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe lock corrupt | *Note POSIX Safety Concepts::. The ‘fgetws’ function reads wide characters from the stream STREAM up to and including a newline character and stores them in the string WS, adding a null wide character to mark the end of the string. You must supply COUNT wide characters worth of space in WS, but the number of characters read is at most COUNT − 1. The extra character space is used to hold the null wide character at the end of the string. If the system is already at end of file when you call ‘fgetws’, then the contents of the array WS are unchanged and a null pointer is returned. A null pointer is also returned if a read error occurs. Otherwise, the return value is the pointer WS. *Warning:* If the input data has a null wide character (which are null bytes in the input stream), you can’t tell. So don’t use ‘fgetws’ unless you know the data cannot contain a null. Don’t use it to read files edited by the user because, if the user inserts a null character, you should either handle it properly or print a clear error message. -- Function: char * fgets_unlocked (char *S, int COUNT, FILE *STREAM) Preliminary: | MT-Safe race:stream | AS-Unsafe corrupt | AC-Unsafe corrupt | *Note POSIX Safety Concepts::. The ‘fgets_unlocked’ function is equivalent to the ‘fgets’ function except that it does not implicitly lock the stream. This function is a GNU extension. -- Function: wchar_t * fgetws_unlocked (wchar_t *WS, int COUNT, FILE *STREAM) Preliminary: | MT-Safe race:stream | AS-Unsafe corrupt | AC-Unsafe corrupt | *Note POSIX Safety Concepts::. The ‘fgetws_unlocked’ function is equivalent to the ‘fgetws’ function except that it does not implicitly lock the stream. This function is a GNU extension. -- Deprecated function: char * gets (char *S) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe lock corrupt | *Note POSIX Safety Concepts::. The function ‘gets’ reads characters from the stream ‘stdin’ up to the next newline character, and stores them in the string S. The newline character is discarded (note that this differs from the behavior of ‘fgets’, which copies the newline character into the string). If ‘gets’ encounters a read error or end-of-file, it returns a null pointer; otherwise it returns S. *Warning:* The ‘gets’ function is *very dangerous* because it provides no protection against overflowing the string S. The GNU C Library includes it for compatibility only. You should *always* use ‘fgets’ or ‘getline’ instead. To remind you of this, the linker (if using GNU ‘ld’) will issue a warning whenever you use ‘gets’.  File: libc.info, Node: Unreading, Next: Block Input/Output, Prev: Line Input, Up: I/O on Streams 12.10 Unreading =============== In parser programs it is often useful to examine the next character in the input stream without removing it from the stream. This is called “peeking ahead” at the input because your program gets a glimpse of the input it will read next. Using stream I/O, you can peek ahead at input by first reading it and then "unreading" it (also called "pushing it back" on the stream). Unreading a character makes it available to be input again from the stream, by the next call to ‘fgetc’ or other input function on that stream. * Menu: * Unreading Idea:: An explanation of unreading with pictures. * How Unread:: How to call ‘ungetc’ to do unreading.  File: libc.info, Node: Unreading Idea, Next: How Unread, Up: Unreading 12.10.1 What Unreading Means ---------------------------- Here is a pictorial explanation of unreading. Suppose you have a stream reading a file that contains just six characters, the letters ‘foobar’. Suppose you have read three characters so far. The situation looks like this: f o o b a r ^ so the next input character will be ‘b’. If instead of reading ‘b’ you unread the letter ‘o’, you get a situation like this: f o o b a r | o-- ^ so that the next input characters will be ‘o’ and ‘b’. If you unread ‘9’ instead of ‘o’, you get this situation: f o o b a r | 9-- ^ so that the next input characters will be ‘9’ and ‘b’.  File: libc.info, Node: How Unread, Prev: Unreading Idea, Up: Unreading 12.10.2 Using ‘ungetc’ To Do Unreading -------------------------------------- The function to unread a character is called ‘ungetc’, because it reverses the action of ‘getc’. -- Function: int ungetc (int C, FILE *STREAM) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe lock corrupt | *Note POSIX Safety Concepts::. The ‘ungetc’ function pushes back the character C onto the input stream STREAM. So the next input from STREAM will read C before anything else. If C is ‘EOF’, ‘ungetc’ does nothing and just returns ‘EOF’. This lets you call ‘ungetc’ with the return value of ‘getc’ without needing to check for an error from ‘getc’. The character that you push back doesn’t have to be the same as the last character that was actually read from the stream. In fact, it isn’t necessary to actually read any characters from the stream before unreading them with ‘ungetc’! But that is a strange way to write a program; usually ‘ungetc’ is used only to unread a character that was just read from the same stream. The GNU C Library supports this even on files opened in binary mode, but other systems might not. The GNU C Library only supports one character of pushback—in other words, it does not work to call ‘ungetc’ twice without doing input in between. Other systems might let you push back multiple characters; then reading from the stream retrieves the characters in the reverse order that they were pushed. Pushing back characters doesn’t alter the file; only the internal buffering for the stream is affected. If a file positioning function (such as ‘fseek’, ‘fseeko’ or ‘rewind’; *note File Positioning::) is called, any pending pushed-back characters are discarded. Unreading a character on a stream that is at end of file clears the end-of-file indicator for the stream, because it makes the character of input available. After you read that character, trying to read again will encounter end of file. -- Function: wint_t ungetwc (wint_t WC, FILE *STREAM) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe lock corrupt | *Note POSIX Safety Concepts::. The ‘ungetwc’ function behaves just like ‘ungetc’ just that it pushes back a wide character. Here is an example showing the use of ‘getc’ and ‘ungetc’ to skip over whitespace characters. When this function reaches a non-whitespace character, it unreads that character to be seen again on the next read operation on the stream. #include #include void skip_whitespace (FILE *stream) { int c; do /* No need to check for ‘EOF’ because it is not ‘isspace’, and ‘ungetc’ ignores ‘EOF’. */ c = getc (stream); while (isspace (c)); ungetc (c, stream); }  File: libc.info, Node: Block Input/Output, Next: Formatted Output, Prev: Unreading, Up: I/O on Streams 12.11 Block Input/Output ======================== This section describes how to do input and output operations on blocks of data. You can use these functions to read and write binary data, as well as to read and write text in fixed-size blocks instead of by characters or lines. Binary files are typically used to read and write blocks of data in the same format as is used to represent the data in a running program. In other words, arbitrary blocks of memory—not just character or string objects—can be written to a binary file, and meaningfully read in again by the same program. Storing data in binary form is often considerably more efficient than using the formatted I/O functions. Also, for floating-point numbers, the binary form avoids possible loss of precision in the conversion process. On the other hand, binary files can’t be examined or modified easily using many standard file utilities (such as text editors), and are not portable between different implementations of the language, or different kinds of computers. These functions are declared in ‘stdio.h’. -- Function: size_t fread (void *DATA, size_t SIZE, size_t COUNT, FILE *STREAM) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe lock corrupt | *Note POSIX Safety Concepts::. This function reads up to COUNT objects of size SIZE into the array DATA, from the stream STREAM. It returns the number of objects actually read, which might be less than COUNT if a read error occurs or the end of the file is reached. This function returns a value of zero (and doesn’t read anything) if either SIZE or COUNT is zero. If ‘fread’ encounters end of file in the middle of an object, it returns the number of complete objects read, and discards the partial object. Therefore, the stream remains at the actual end of the file. -- Function: size_t fread_unlocked (void *DATA, size_t SIZE, size_t COUNT, FILE *STREAM) Preliminary: | MT-Safe race:stream | AS-Unsafe corrupt | AC-Unsafe corrupt | *Note POSIX Safety Concepts::. The ‘fread_unlocked’ function is equivalent to the ‘fread’ function except that it does not implicitly lock the stream. This function is a GNU extension. -- Function: size_t fwrite (const void *DATA, size_t SIZE, size_t COUNT, FILE *STREAM) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe lock corrupt | *Note POSIX Safety Concepts::. This function writes up to COUNT objects of size SIZE from the array DATA, to the stream STREAM. The return value is normally COUNT, if the call succeeds. Any other value indicates some sort of error, such as running out of space. -- Function: size_t fwrite_unlocked (const void *DATA, size_t SIZE, size_t COUNT, FILE *STREAM) Preliminary: | MT-Safe race:stream | AS-Unsafe corrupt | AC-Unsafe corrupt | *Note POSIX Safety Concepts::. The ‘fwrite_unlocked’ function is equivalent to the ‘fwrite’ function except that it does not implicitly lock the stream. This function is a GNU extension.  File: libc.info, Node: Formatted Output, Next: Customizing Printf, Prev: Block Input/Output, Up: I/O on Streams 12.12 Formatted Output ====================== The functions described in this section (‘printf’ and related functions) provide a convenient way to perform formatted output. You call ‘printf’ with a "format string" or "template string" that specifies how to format the values of the remaining arguments. Unless your program is a filter that specifically performs line- or character-oriented processing, using ‘printf’ or one of the other related functions described in this section is usually the easiest and most concise way to perform output. These functions are especially useful for printing error messages, tables of data, and the like. * Menu: * Formatted Output Basics:: Some examples to get you started. * Output Conversion Syntax:: General syntax of conversion specifications. * Table of Output Conversions:: Summary of output conversions and what they do. * Integer Conversions:: Details about formatting of integers. * Floating-Point Conversions:: Details about formatting of floating-point numbers. * Other Output Conversions:: Details about formatting of strings, characters, pointers, and the like. * Formatted Output Functions:: Descriptions of the actual functions. * Dynamic Output:: Functions that allocate memory for the output. * Variable Arguments Output:: ‘vprintf’ and friends. * Parsing a Template String:: What kinds of args does a given template call for? * Example of Parsing:: Sample program using ‘parse_printf_format’.  File: libc.info, Node: Formatted Output Basics, Next: Output Conversion Syntax, Up: Formatted Output 12.12.1 Formatted Output Basics ------------------------------- The ‘printf’ function can be used to print any number of arguments. The template string argument you supply in a call provides information not only about the number of additional arguments, but also about their types and what style should be used for printing them. Ordinary characters in the template string are simply written to the output stream as-is, while "conversion specifications" introduced by a ‘%’ character in the template cause subsequent arguments to be formatted and written to the output stream. For example, int pct = 37; char filename[] = "foo.txt"; printf ("Processing of `%s' is %d%% finished.\nPlease be patient.\n", filename, pct); produces output like Processing of `foo.txt' is 37% finished. Please be patient. This example shows the use of the ‘%d’ conversion to specify that an ‘int’ argument should be printed in decimal notation, the ‘%s’ conversion to specify printing of a string argument, and the ‘%%’ conversion to print a literal ‘%’ character. There are also conversions for printing an integer argument as an unsigned value in binary, octal, decimal, or hexadecimal radix (‘%b’, ‘%o’, ‘%u’, or ‘%x’, respectively); or as a character value (‘%c’). Floating-point numbers can be printed in normal, fixed-point notation using the ‘%f’ conversion or in exponential notation using the ‘%e’ conversion. The ‘%g’ conversion uses either ‘%e’ or ‘%f’ format, depending on what is more appropriate for the magnitude of the particular number. You can control formatting more precisely by writing "modifiers" between the ‘%’ and the character that indicates which conversion to apply. These slightly alter the ordinary behavior of the conversion. For example, most conversion specifications permit you to specify a minimum field width and a flag indicating whether you want the result left- or right-justified within the field. The specific flags and modifiers that are permitted and their interpretation vary depending on the particular conversion. They’re all described in more detail in the following sections. Don’t worry if this all seems excessively complicated at first; you can almost always get reasonable free-format output without using any of the modifiers at all. The modifiers are mostly used to make the output look “prettier” in tables.  File: libc.info, Node: Output Conversion Syntax, Next: Table of Output Conversions, Prev: Formatted Output Basics, Up: Formatted Output 12.12.2 Output Conversion Syntax -------------------------------- This section provides details about the precise syntax of conversion specifications that can appear in a ‘printf’ template string. Characters in the template string that are not part of a conversion specification are printed as-is to the output stream. Multibyte character sequences (*note Character Set Handling::) are permitted in a template string. The conversion specifications in a ‘printf’ template string have the general form: % [ PARAM-NO $] FLAGS WIDTH [ . PRECISION ] TYPE CONVERSION or % [ PARAM-NO $] FLAGS WIDTH . * [ PARAM-NO $] TYPE CONVERSION For example, in the conversion specifier ‘%-10.8ld’, the ‘-’ is a flag, ‘10’ specifies the field width, the precision is ‘8’, the letter ‘l’ is a type modifier, and ‘d’ specifies the conversion style. (This particular type specifier says to print a ‘long int’ argument in decimal notation, with a minimum of 8 digits left-justified in a field at least 10 characters wide.) In more detail, output conversion specifications consist of an initial ‘%’ character followed in sequence by: • An optional specification of the parameter used for this format. Normally the parameters to the ‘printf’ function are assigned to the formats in the order of appearance in the format string. But in some situations (such as message translation) this is not desirable and this extension allows an explicit parameter to be specified. The PARAM-NO parts of the format must be integers in the range of 1 to the maximum number of arguments present to the function call. Some implementations limit this number to a certain upper bound. The exact limit can be retrieved by the following constant. -- Macro: NL_ARGMAX The value of ‘NL_ARGMAX’ is the maximum value allowed for the specification of a positional parameter in a ‘printf’ call. The actual value in effect at runtime can be retrieved by using ‘sysconf’ using the ‘_SC_NL_ARGMAX’ parameter *note Sysconf Definition::. Some systems have a quite low limit such as 9 for System V systems. The GNU C Library has no real limit. If any of the formats has a specification for the parameter position all of them in the format string shall have one. Otherwise the behavior is undefined. • Zero or more "flag characters" that modify the normal behavior of the conversion specification. • An optional decimal integer specifying the "minimum field width". If the normal conversion produces fewer characters than this, the field is padded with spaces to the specified width. This is a _minimum_ value; if the normal conversion produces more characters than this, the field is _not_ truncated. Normally, the output is right-justified within the field. You can also specify a field width of ‘*’. This means that the next argument in the argument list (before the actual value to be printed) is used as the field width. The value must be an ‘int’. If the value is negative, this means to set the ‘-’ flag (see below) and to use the absolute value as the field width. • An optional "precision" to specify the number of digits to be written for the numeric conversions. If the precision is specified, it consists of a period (‘.’) followed optionally by a decimal integer (which defaults to zero if omitted). You can also specify a precision of ‘*’. This means that the next argument in the argument list (before the actual value to be printed) is used as the precision. The value must be an ‘int’, and is ignored if it is negative. If you specify ‘*’ for both the field width and precision, the field width argument precedes the precision argument. Other C library versions may not recognize this syntax. • An optional "type modifier character", which is used to specify the data type of the corresponding argument if it differs from the default type. (For example, the integer conversions assume a type of ‘int’, but you can specify ‘h’, ‘l’, or ‘L’ for other integer types.) • A character that specifies the conversion to be applied. The exact options that are permitted and how they are interpreted vary between the different conversion specifiers. See the descriptions of the individual conversions for information about the particular options that they use. With the ‘-Wformat’ option, the GNU C compiler checks calls to ‘printf’ and related functions. It examines the format string and verifies that the correct number and types of arguments are supplied. There is also a GNU C syntax to tell the compiler that a function you write uses a ‘printf’-style format string. *Note Declaring Attributes of Functions: (gcc)Function Attributes, for more information.  File: libc.info, Node: Table of Output Conversions, Next: Integer Conversions, Prev: Output Conversion Syntax, Up: Formatted Output 12.12.3 Table of Output Conversions ----------------------------------- Here is a table summarizing what all the different conversions do: ‘%d’, ‘%i’ Print an integer as a signed decimal number. *Note Integer Conversions::, for details. ‘%d’ and ‘%i’ are synonymous for output, but are different when used with ‘scanf’ for input (*note Table of Input Conversions::). ‘%b’, ‘%B’ Print an integer as an unsigned binary number. ‘%b’ uses lower-case ‘b’ with the ‘#’ flag and ‘%B’ uses upper-case. ‘%b’ is an ISO C2X feature; ‘%B’ is an extension recommended by ISO C2X. *Note Integer Conversions::, for details. ‘%o’ Print an integer as an unsigned octal number. *Note Integer Conversions::, for details. ‘%u’ Print an integer as an unsigned decimal number. *Note Integer Conversions::, for details. ‘%x’, ‘%X’ Print an integer as an unsigned hexadecimal number. ‘%x’ uses lower-case letters and ‘%X’ uses upper-case. *Note Integer Conversions::, for details. ‘%f’ Print a floating-point number in normal (fixed-point) notation. *Note Floating-Point Conversions::, for details. ‘%e’, ‘%E’ Print a floating-point number in exponential notation. ‘%e’ uses lower-case letters and ‘%E’ uses upper-case. *Note Floating-Point Conversions::, for details. ‘%g’, ‘%G’ Print a floating-point number in either normal or exponential notation, whichever is more appropriate for its magnitude. ‘%g’ uses lower-case letters and ‘%G’ uses upper-case. *Note Floating-Point Conversions::, for details. ‘%a’, ‘%A’ Print a floating-point number in a hexadecimal fractional notation with the exponent to base 2 represented in decimal digits. ‘%a’ uses lower-case letters and ‘%A’ uses upper-case. *Note Floating-Point Conversions::, for details. ‘%c’ Print a single character. *Note Other Output Conversions::. ‘%C’ This is an alias for ‘%lc’ which is supported for compatibility with the Unix standard. ‘%s’ Print a string. *Note Other Output Conversions::. ‘%S’ This is an alias for ‘%ls’ which is supported for compatibility with the Unix standard. ‘%p’ Print the value of a pointer. *Note Other Output Conversions::. ‘%n’ Get the number of characters printed so far. *Note Other Output Conversions::. Note that this conversion specification never produces any output. ‘%m’ Print the string corresponding to the value of ‘errno’. (This is a GNU extension.) *Note Other Output Conversions::. ‘%%’ Print a literal ‘%’ character. *Note Other Output Conversions::. If the syntax of a conversion specification is invalid, unpredictable things will happen, so don’t do this. If there aren’t enough function arguments provided to supply values for all the conversion specifications in the template string, or if the arguments are not of the correct types, the results are unpredictable. If you supply more arguments than conversion specifications, the extra argument values are simply ignored; this is sometimes useful.  File: libc.info, Node: Integer Conversions, Next: Floating-Point Conversions, Prev: Table of Output Conversions, Up: Formatted Output 12.12.4 Integer Conversions --------------------------- This section describes the options for the ‘%d’, ‘%i’, ‘%b’, ‘%B’, ‘%o’, ‘%u’, ‘%x’, and ‘%X’ conversion specifications. These conversions print integers in various formats. The ‘%d’ and ‘%i’ conversion specifications both print an ‘int’ argument as a signed decimal number; while ‘b’, ‘%o’, ‘%u’, and ‘%x’ print the argument as an unsigned binary, octal, decimal, or hexadecimal number (respectively). The ‘%X’ conversion specification is just like ‘%x’ except that it uses the characters ‘ABCDEF’ as digits instead of ‘abcdef’. The ‘%B’ conversion specification is just like ‘%b’ except that, with the ‘#’ flag, the output starts with ‘0B’ instead of ‘0b’. The following flags are meaningful: ‘-’ Left-justify the result in the field (instead of the normal right-justification). ‘+’ For the signed ‘%d’ and ‘%i’ conversions, print a plus sign if the value is positive. ‘ ’ For the signed ‘%d’ and ‘%i’ conversions, if the result doesn’t start with a plus or minus sign, prefix it with a space character instead. Since the ‘+’ flag ensures that the result includes a sign, this flag is ignored if you supply both of them. ‘#’ For the ‘%o’ conversion, this forces the leading digit to be ‘0’, as if by increasing the precision. For ‘%x’ or ‘%X’, this prefixes a leading ‘0x’ or ‘0X’ (respectively) to the result. For ‘%b’ or ‘%B’, this prefixes a leading ‘0b’ or ‘0B’ (respectively) to the result. This doesn’t do anything useful for the ‘%d’, ‘%i’, or ‘%u’ conversions. Using this flag produces output which can be parsed by the ‘strtoul’ function (*note Parsing of Integers::) and ‘scanf’ with the ‘%i’ conversion (*note Numeric Input Conversions::). For the ‘%m’ conversion, print an error constant or decimal error number, instead of a (possibly translated) error message. ‘'’ Separate the digits into groups as specified by the locale specified for the ‘LC_NUMERIC’ category; *note General Numeric::. This flag is a GNU extension. ‘0’ Pad the field with zeros instead of spaces. The zeros are placed after any indication of sign or base. This flag is ignored if the ‘-’ flag is also specified, or if a precision is specified. If a precision is supplied, it specifies the minimum number of digits to appear; leading zeros are produced if necessary. If you don’t specify a precision, the number is printed with as many digits as it needs. If you convert a value of zero with an explicit precision of zero, then no characters at all are produced. Without a type modifier, the corresponding argument is treated as an ‘int’ (for the signed conversions ‘%i’ and ‘%d’) or ‘unsigned int’ (for the unsigned conversions ‘%b’, ‘%B’, ‘%o’, ‘%u’, ‘%x’, and ‘%X’). Recall that since ‘printf’ and friends are variadic, any ‘char’ and ‘short’ arguments are automatically converted to ‘int’ by the default argument promotions. For arguments of other integer types, you can use these modifiers: ‘hh’ Specifies that the argument is a ‘signed char’ or ‘unsigned char’, as appropriate. A ‘char’ argument is converted to an ‘int’ or ‘unsigned int’ by the default argument promotions anyway, but the ‘hh’ modifier says to convert it back to a ‘char’ again. This modifier was introduced in ISO C99. ‘h’ Specifies that the argument is a ‘short int’ or ‘unsigned short int’, as appropriate. A ‘short’ argument is converted to an ‘int’ or ‘unsigned int’ by the default argument promotions anyway, but the ‘h’ modifier says to convert it back to a ‘short’ again. ‘j’ Specifies that the argument is a ‘intmax_t’ or ‘uintmax_t’, as appropriate. This modifier was introduced in ISO C99. ‘l’ Specifies that the argument is a ‘long int’ or ‘unsigned long int’, as appropriate. Two ‘l’ characters are like the ‘L’ modifier, below. If used with ‘%c’ or ‘%s’ the corresponding parameter is considered as a wide character or wide character string respectively. This use of ‘l’ was introduced in Amendment 1 to ISO C90. ‘L’ ‘ll’ ‘q’ Specifies that the argument is a ‘long long int’. (This type is an extension supported by the GNU C compiler. On systems that don’t support extra-long integers, this is the same as ‘long int’.) The ‘q’ modifier is another name for the same thing, which comes from 4.4 BSD; a ‘long long int’ is sometimes called a “quad” ‘int’. ‘t’ Specifies that the argument is a ‘ptrdiff_t’. This modifier was introduced in ISO C99. ‘z’ ‘Z’ Specifies that the argument is a ‘size_t’. ‘z’ was introduced in ISO C99. ‘Z’ is a GNU extension predating this addition and should not be used in new code. Here is an example. Using the template string: "|%5d|%-5d|%+5d|%+-5d|% 5d|%05d|%5.0d|%5.2d|%d|\n" to print numbers using the different options for the ‘%d’ conversion gives results like: | 0|0 | +0|+0 | 0|00000| | 00|0| | 1|1 | +1|+1 | 1|00001| 1| 01|1| | -1|-1 | -1|-1 | -1|-0001| -1| -01|-1| |100000|100000|+100000|+100000| 100000|100000|100000|100000|100000| In particular, notice what happens in the last case where the number is too large to fit in the minimum field width specified. Here are some more examples showing how unsigned integers print under various format options, using the template string: "|%5u|%5o|%5x|%5X|%#5o|%#5x|%#5X|%#10.8x|\n" | 0| 0| 0| 0| 0| 0| 0| 00000000| | 1| 1| 1| 1| 01| 0x1| 0X1|0x00000001| |100000|303240|186a0|186A0|0303240|0x186a0|0X186A0|0x000186a0|  File: libc.info, Node: Floating-Point Conversions, Next: Other Output Conversions, Prev: Integer Conversions, Up: Formatted Output 12.12.5 Floating-Point Conversions ---------------------------------- This section discusses the conversion specifications for floating-point numbers: the ‘%f’, ‘%e’, ‘%E’, ‘%g’, and ‘%G’ conversions. The ‘%f’ conversion prints its argument in fixed-point notation, producing output of the form [‘-’]DDD‘.’DDD, where the number of digits following the decimal point is controlled by the precision you specify. The ‘%e’ conversion prints its argument in exponential notation, producing output of the form [‘-’]D‘.’DDD‘e’[‘+’|‘-’]DD. Again, the number of digits following the decimal point is controlled by the precision. The exponent always contains at least two digits. The ‘%E’ conversion is similar but the exponent is marked with the letter ‘E’ instead of ‘e’. The ‘%g’ and ‘%G’ conversions print the argument in the style of ‘%e’ or ‘%E’ (respectively) if the exponent would be less than -4 or greater than or equal to the precision; otherwise they use the ‘%f’ style. A precision of ‘0’, is taken as 1. Trailing zeros are removed from the fractional portion of the result and a decimal-point character appears only if it is followed by a digit. The ‘%a’ and ‘%A’ conversions are meant for representing floating-point numbers exactly in textual form so that they can be exchanged as texts between different programs and/or machines. The numbers are represented in the form [‘-’]‘0x’H‘.’HHH‘p’[‘+’|‘-’]DD. At the left of the decimal-point character exactly one digit is print. This character is only ‘0’ if the number is denormalized. Otherwise the value is unspecified; it is implementation dependent how many bits are used. The number of hexadecimal digits on the right side of the decimal-point character is equal to the precision. If the precision is zero it is determined to be large enough to provide an exact representation of the number (or it is large enough to distinguish two adjacent values if the ‘FLT_RADIX’ is not a power of 2, *note Floating Point Parameters::). For the ‘%a’ conversion lower-case characters are used to represent the hexadecimal number and the prefix and exponent sign are printed as ‘0x’ and ‘p’ respectively. Otherwise upper-case characters are used and ‘0X’ and ‘P’ are used for the representation of prefix and exponent string. The exponent to the base of two is printed as a decimal number using at least one digit but at most as many digits as necessary to represent the value exactly. If the value to be printed represents infinity or a NaN, the output is [‘-’]‘inf’ or ‘nan’ respectively if the conversion specifier is ‘%a’, ‘%e’, ‘%f’, or ‘%g’ and it is [‘-’]‘INF’ or ‘NAN’ respectively if the conversion is ‘%A’, ‘%E’, or ‘%G’. On some implementations, a NaN may result in longer output with information about the payload of the NaN; ISO C2X defines a macro ‘_PRINTF_NAN_LEN_MAX’ giving the maximum length of such output. The following flags can be used to modify the behavior: ‘-’ Left-justify the result in the field. Normally the result is right-justified. ‘+’ Always include a plus or minus sign in the result. ‘ ’ If the result doesn’t start with a plus or minus sign, prefix it with a space instead. Since the ‘+’ flag ensures that the result includes a sign, this flag is ignored if you supply both of them. ‘#’ Specifies that the result should always include a decimal point, even if no digits follow it. For the ‘%g’ and ‘%G’ conversions, this also forces trailing zeros after the decimal point to be left in place where they would otherwise be removed. ‘'’ Separate the digits of the integer part of the result into groups as specified by the locale specified for the ‘LC_NUMERIC’ category; *note General Numeric::. This flag is a GNU extension. ‘0’ Pad the field with zeros instead of spaces; the zeros are placed after any sign. This flag is ignored if the ‘-’ flag is also specified. The precision specifies how many digits follow the decimal-point character for the ‘%f’, ‘%e’, and ‘%E’ conversions. For these conversions, the default precision is ‘6’. If the precision is explicitly ‘0’, this suppresses the decimal point character entirely. For the ‘%g’ and ‘%G’ conversions, the precision specifies how many significant digits to print. Significant digits are the first digit before the decimal point, and all the digits after it. If the precision is ‘0’ or not specified for ‘%g’ or ‘%G’, it is treated like a value of ‘1’. If the value being printed cannot be expressed accurately in the specified number of digits, the value is rounded to the nearest number that fits. Without a type modifier, the floating-point conversions use an argument of type ‘double’. (By the default argument promotions, any ‘float’ arguments are automatically converted to ‘double’.) The following type modifier is supported: ‘L’ An uppercase ‘L’ specifies that the argument is a ‘long double’. Here are some examples showing how numbers print using the various floating-point conversions. All of the numbers were printed using this template string: "|%13.4a|%13.4f|%13.4e|%13.4g|\n" Here is the output: | 0x0.0000p+0| 0.0000| 0.0000e+00| 0| | 0x1.0000p-1| 0.5000| 5.0000e-01| 0.5| | 0x1.0000p+0| 1.0000| 1.0000e+00| 1| | -0x1.0000p+0| -1.0000| -1.0000e+00| -1| | 0x1.9000p+6| 100.0000| 1.0000e+02| 100| | 0x1.f400p+9| 1000.0000| 1.0000e+03| 1000| | 0x1.3880p+13| 10000.0000| 1.0000e+04| 1e+04| | 0x1.81c8p+13| 12345.0000| 1.2345e+04| 1.234e+04| | 0x1.86a0p+16| 100000.0000| 1.0000e+05| 1e+05| | 0x1.e240p+16| 123456.0000| 1.2346e+05| 1.235e+05| Notice how the ‘%g’ conversion drops trailing zeros.  File: libc.info, Node: Other Output Conversions, Next: Formatted Output Functions, Prev: Floating-Point Conversions, Up: Formatted Output 12.12.6 Other Output Conversions -------------------------------- This section describes miscellaneous conversions for ‘printf’. The ‘%c’ conversion prints a single character. In case there is no ‘l’ modifier the ‘int’ argument is first converted to an ‘unsigned char’. Then, if used in a wide stream function, the character is converted into the corresponding wide character. The ‘-’ flag can be used to specify left-justification in the field, but no other flags are defined, and no precision or type modifier can be given. For example: printf ("%c%c%c%c%c", 'h', 'e', 'l', 'l', 'o'); prints ‘hello’. If there is an ‘l’ modifier present the argument is expected to be of type ‘wint_t’. If used in a multibyte function the wide character is converted into a multibyte character before being added to the output. In this case more than one output byte can be produced. The ‘%s’ conversion prints a string. If no ‘l’ modifier is present the corresponding argument must be of type ‘char *’ (or ‘const char *’). If used in a wide stream function the string is first converted to a wide character string. A precision can be specified to indicate the maximum number of characters to write; otherwise characters in the string up to but not including the terminating null character are written to the output stream. The ‘-’ flag can be used to specify left-justification in the field, but no other flags or type modifiers are defined for this conversion. For example: printf ("%3s%-6s", "no", "where"); prints ‘ nowhere ’. If there is an ‘l’ modifier present, the argument is expected to be of type ‘wchar_t’ (or ‘const wchar_t *’). If you accidentally pass a null pointer as the argument for a ‘%s’ conversion, the GNU C Library prints it as ‘(null)’. We think this is more useful than crashing. But it’s not good practice to pass a null argument intentionally. The ‘%m’ conversion prints the string corresponding to the error code in ‘errno’. *Note Error Messages::. Thus: fprintf (stderr, "can't open `%s': %m\n", filename); is equivalent to: fprintf (stderr, "can't open `%s': %s\n", filename, strerror (errno)); The ‘%m’ conversion can be used with the ‘#’ flag to print an error constant, as provided by ‘strerrorname_np’. Both ‘%m’ and ‘%#m’ are GNU C Library extensions. The ‘%p’ conversion prints a pointer value. The corresponding argument must be of type ‘void *’. In practice, you can use any type of pointer. In the GNU C Library, non-null pointers are printed as unsigned integers, as if a ‘%#x’ conversion were used. Null pointers print as ‘(nil)’. (Pointers might print differently in other systems.) For example: printf ("%p", "testing"); prints ‘0x’ followed by a hexadecimal number—the address of the string constant ‘"testing"’. It does not print the word ‘testing’. You can supply the ‘-’ flag with the ‘%p’ conversion to specify left-justification, but no other flags, precision, or type modifiers are defined. The ‘%n’ conversion is unlike any of the other output conversions. It uses an argument which must be a pointer to an ‘int’, but instead of printing anything it stores the number of characters printed so far by this call at that location. The ‘h’ and ‘l’ type modifiers are permitted to specify that the argument is of type ‘short int *’ or ‘long int *’ instead of ‘int *’, but no flags, field width, or precision are permitted. For example, int nchar; printf ("%d %s%n\n", 3, "bears", &nchar); prints: 3 bears and sets ‘nchar’ to ‘7’, because ‘3 bears’ is seven characters. The ‘%%’ conversion prints a literal ‘%’ character. This conversion doesn’t use an argument, and no flags, field width, precision, or type modifiers are permitted.  File: libc.info, Node: Formatted Output Functions, Next: Dynamic Output, Prev: Other Output Conversions, Up: Formatted Output 12.12.7 Formatted Output Functions ---------------------------------- This section describes how to call ‘printf’ and related functions. Prototypes for these functions are in the header file ‘stdio.h’. Because these functions take a variable number of arguments, you _must_ declare prototypes for them before using them. Of course, the easiest way to make sure you have all the right prototypes is to just include ‘stdio.h’. -- Function: int printf (const char *TEMPLATE, …) Preliminary: | MT-Safe locale | AS-Unsafe corrupt heap | AC-Unsafe mem lock corrupt | *Note POSIX Safety Concepts::. The ‘printf’ function prints the optional arguments under the control of the template string TEMPLATE to the stream ‘stdout’. It returns the number of characters printed, or a negative value if there was an output error. -- Function: int wprintf (const wchar_t *TEMPLATE, …) Preliminary: | MT-Safe locale | AS-Unsafe corrupt heap | AC-Unsafe mem lock corrupt | *Note POSIX Safety Concepts::. The ‘wprintf’ function prints the optional arguments under the control of the wide template string TEMPLATE to the stream ‘stdout’. It returns the number of wide characters printed, or a negative value if there was an output error. -- Function: int fprintf (FILE *STREAM, const char *TEMPLATE, …) Preliminary: | MT-Safe locale | AS-Unsafe corrupt heap | AC-Unsafe mem lock corrupt | *Note POSIX Safety Concepts::. This function is just like ‘printf’, except that the output is written to the stream STREAM instead of ‘stdout’. -- Function: int fwprintf (FILE *STREAM, const wchar_t *TEMPLATE, …) Preliminary: | MT-Safe locale | AS-Unsafe corrupt heap | AC-Unsafe mem lock corrupt | *Note POSIX Safety Concepts::. This function is just like ‘wprintf’, except that the output is written to the stream STREAM instead of ‘stdout’. -- Function: int sprintf (char *S, const char *TEMPLATE, …) Preliminary: | MT-Safe locale | AS-Unsafe heap | AC-Unsafe mem | *Note POSIX Safety Concepts::. This is like ‘printf’, except that the output is stored in the character array S instead of written to a stream. A null character is written to mark the end of the string. The ‘sprintf’ function returns the number of characters stored in the array S, not including the terminating null character. The behavior of this function is undefined if copying takes place between objects that overlap—for example, if S is also given as an argument to be printed under control of the ‘%s’ conversion. *Note Copying Strings and Arrays::. *Warning:* The ‘sprintf’ function can be *dangerous* because it can potentially output more characters than can fit in the allocation size of the string S. Remember that the field width given in a conversion specification is only a _minimum_ value. To avoid this problem, you can use ‘snprintf’ or ‘asprintf’, described below. -- Function: int swprintf (wchar_t *WS, size_t SIZE, const wchar_t *TEMPLATE, …) Preliminary: | MT-Safe locale | AS-Unsafe heap | AC-Unsafe mem | *Note POSIX Safety Concepts::. This is like ‘wprintf’, except that the output is stored in the wide character array WS instead of written to a stream. A null wide character is written to mark the end of the string. The SIZE argument specifies the maximum number of characters to produce. The trailing null character is counted towards this limit, so you should allocate at least SIZE wide characters for the string WS. The return value is the number of characters generated for the given input, excluding the trailing null. If not all output fits into the provided buffer a negative value is returned. You should try again with a bigger output string. _Note:_ this is different from how ‘snprintf’ handles this situation. Note that the corresponding narrow stream function takes fewer parameters. ‘swprintf’ in fact corresponds to the ‘snprintf’ function. Since the ‘sprintf’ function can be dangerous and should be avoided the ISO C committee refused to make the same mistake again and decided to not define a function exactly corresponding to ‘sprintf’. -- Function: int snprintf (char *S, size_t SIZE, const char *TEMPLATE, …) Preliminary: | MT-Safe locale | AS-Unsafe heap | AC-Unsafe mem | *Note POSIX Safety Concepts::. The ‘snprintf’ function is similar to ‘sprintf’, except that the SIZE argument specifies the maximum number of characters to produce. The trailing null character is counted towards this limit, so you should allocate at least SIZE characters for the string S. If SIZE is zero, nothing, not even the null byte, shall be written and S may be a null pointer. The return value is the number of characters which would be generated for the given input, excluding the trailing null. If this value is greater than or equal to SIZE, not all characters from the result have been stored in S. You should try again with a bigger output string. Here is an example of doing this: /* Construct a message describing the value of a variable whose name is NAME and whose value is VALUE. */ char * make_message (char *name, char *value) { /* Guess we need no more than 100 bytes of space. */ size_t size = 100; char *buffer = xmalloc (size); /* Try to print in the allocated space. */ int buflen = snprintf (buffer, size, "value of %s is %s", name, value); if (! (0 <= buflen && buflen < SIZE_MAX)) fatal ("integer overflow"); if (buflen >= size) { /* Reallocate buffer now that we know how much space is needed. */ size = buflen; size++; buffer = xrealloc (buffer, size); /* Try again. */ snprintf (buffer, size, "value of %s is %s", name, value); } /* The last call worked, return the string. */ return buffer; } In practice, it is often easier just to use ‘asprintf’, below. *Attention:* In versions of the GNU C Library prior to 2.1 the return value is the number of characters stored, not including the terminating null; unless there was not enough space in S to store the result in which case ‘-1’ is returned. This was changed in order to comply with the ISO C99 standard.  File: libc.info, Node: Dynamic Output, Next: Variable Arguments Output, Prev: Formatted Output Functions, Up: Formatted Output 12.12.8 Dynamically Allocating Formatted Output ----------------------------------------------- The functions in this section do formatted output and place the results in dynamically allocated memory. -- Function: int asprintf (char **PTR, const char *TEMPLATE, …) Preliminary: | MT-Safe locale | AS-Unsafe heap | AC-Unsafe mem | *Note POSIX Safety Concepts::. This function is similar to ‘sprintf’, except that it dynamically allocates a string (as with ‘malloc’; *note Unconstrained Allocation::) to hold the output, instead of putting the output in a buffer you allocate in advance. The PTR argument should be the address of a ‘char *’ object, and a successful call to ‘asprintf’ stores a pointer to the newly allocated string at that location. The return value is the number of characters allocated for the buffer, or less than zero if an error occurred. Usually this means that the buffer could not be allocated. Here is how to use ‘asprintf’ to get the same result as the ‘snprintf’ example, but more easily: /* Construct a message describing the value of a variable whose name is NAME and whose value is VALUE. */ char * make_message (char *name, char *value) { char *result; if (asprintf (&result, "value of %s is %s", name, value) < 0) return NULL; return result; } -- Function: int obstack_printf (struct obstack *OBSTACK, const char *TEMPLATE, …) Preliminary: | MT-Safe race:obstack locale | AS-Unsafe corrupt heap | AC-Unsafe corrupt mem | *Note POSIX Safety Concepts::. This function is similar to ‘asprintf’, except that it uses the obstack OBSTACK to allocate the space. *Note Obstacks::. The characters are written onto the end of the current object. To get at them, you must finish the object with ‘obstack_finish’ (*note Growing Objects::).  File: libc.info, Node: Variable Arguments Output, Next: Parsing a Template String, Prev: Dynamic Output, Up: Formatted Output 12.12.9 Variable Arguments Output Functions ------------------------------------------- The functions ‘vprintf’ and friends are provided so that you can define your own variadic ‘printf’-like functions that make use of the same internals as the built-in formatted output functions. The most natural way to define such functions would be to use a language construct to say, “Call ‘printf’ and pass this template plus all of my arguments after the first five.” But there is no way to do this in C, and it would be hard to provide a way, since at the C language level there is no way to tell how many arguments your function received. Since that method is impossible, we provide alternative functions, the ‘vprintf’ series, which lets you pass a ‘va_list’ to describe “all of my arguments after the first five.” When it is sufficient to define a macro rather than a real function, the GNU C compiler provides a way to do this much more easily with macros. For example: #define myprintf(a, b, c, d, e, rest...) \ printf (mytemplate , ## rest) *Note (cpp)Variadic Macros::, for details. But this is limited to macros, and does not apply to real functions at all. Before calling ‘vprintf’ or the other functions listed in this section, you _must_ call ‘va_start’ (*note Variadic Functions::) to initialize a pointer to the variable arguments. Then you can call ‘va_arg’ to fetch the arguments that you want to handle yourself. This advances the pointer past those arguments. Once your ‘va_list’ pointer is pointing at the argument of your choice, you are ready to call ‘vprintf’. That argument and all subsequent arguments that were passed to your function are used by ‘vprintf’ along with the template that you specified separately. *Portability Note:* The value of the ‘va_list’ pointer is undetermined after the call to ‘vprintf’, so you must not use ‘va_arg’ after you call ‘vprintf’. Instead, you should call ‘va_end’ to retire the pointer from service. You can call ‘va_start’ again and begin fetching the arguments from the start of the variable argument list. (Alternatively, you can use ‘va_copy’ to make a copy of the ‘va_list’ pointer before calling ‘vfprintf’.) Calling ‘vprintf’ does not destroy the argument list of your function, merely the particular pointer that you passed to it. Prototypes for these functions are declared in ‘stdio.h’. -- Function: int vprintf (const char *TEMPLATE, va_list AP) Preliminary: | MT-Safe locale | AS-Unsafe corrupt heap | AC-Unsafe mem lock corrupt | *Note POSIX Safety Concepts::. This function is similar to ‘printf’ except that, instead of taking a variable number of arguments directly, it takes an argument list pointer AP. -- Function: int vwprintf (const wchar_t *TEMPLATE, va_list AP) Preliminary: | MT-Safe locale | AS-Unsafe corrupt heap | AC-Unsafe mem lock corrupt | *Note POSIX Safety Concepts::. This function is similar to ‘wprintf’ except that, instead of taking a variable number of arguments directly, it takes an argument list pointer AP. -- Function: int vfprintf (FILE *STREAM, const char *TEMPLATE, va_list AP) Preliminary: | MT-Safe locale | AS-Unsafe corrupt heap | AC-Unsafe mem lock corrupt | *Note POSIX Safety Concepts::. This is the equivalent of ‘fprintf’ with the variable argument list specified directly as for ‘vprintf’. -- Function: int vfwprintf (FILE *STREAM, const wchar_t *TEMPLATE, va_list AP) Preliminary: | MT-Safe locale | AS-Unsafe corrupt heap | AC-Unsafe mem lock corrupt | *Note POSIX Safety Concepts::. This is the equivalent of ‘fwprintf’ with the variable argument list specified directly as for ‘vwprintf’. -- Function: int vsprintf (char *S, const char *TEMPLATE, va_list AP) Preliminary: | MT-Safe locale | AS-Unsafe heap | AC-Unsafe mem | *Note POSIX Safety Concepts::. This is the equivalent of ‘sprintf’ with the variable argument list specified directly as for ‘vprintf’. -- Function: int vswprintf (wchar_t *WS, size_t SIZE, const wchar_t *TEMPLATE, va_list AP) Preliminary: | MT-Safe locale | AS-Unsafe heap | AC-Unsafe mem | *Note POSIX Safety Concepts::. This is the equivalent of ‘swprintf’ with the variable argument list specified directly as for ‘vwprintf’. -- Function: int vsnprintf (char *S, size_t SIZE, const char *TEMPLATE, va_list AP) Preliminary: | MT-Safe locale | AS-Unsafe heap | AC-Unsafe mem | *Note POSIX Safety Concepts::. This is the equivalent of ‘snprintf’ with the variable argument list specified directly as for ‘vprintf’. -- Function: int vasprintf (char **PTR, const char *TEMPLATE, va_list AP) Preliminary: | MT-Safe locale | AS-Unsafe heap | AC-Unsafe mem | *Note POSIX Safety Concepts::. The ‘vasprintf’ function is the equivalent of ‘asprintf’ with the variable argument list specified directly as for ‘vprintf’. -- Function: int obstack_vprintf (struct obstack *OBSTACK, const char *TEMPLATE, va_list AP) Preliminary: | MT-Safe race:obstack locale | AS-Unsafe corrupt heap | AC-Unsafe corrupt mem | *Note POSIX Safety Concepts::. The ‘obstack_vprintf’ function is the equivalent of ‘obstack_printf’ with the variable argument list specified directly as for ‘vprintf’. Here’s an example showing how you might use ‘vfprintf’. This is a function that prints error messages to the stream ‘stderr’, along with a prefix indicating the name of the program (*note Error Messages::, for a description of ‘program_invocation_short_name’). #include #include void eprintf (const char *template, ...) { va_list ap; extern char *program_invocation_short_name; fprintf (stderr, "%s: ", program_invocation_short_name); va_start (ap, template); vfprintf (stderr, template, ap); va_end (ap); } You could call ‘eprintf’ like this: eprintf ("file `%s' does not exist\n", filename); In GNU C, there is a special construct you can use to let the compiler know that a function uses a ‘printf’-style format string. Then it can check the number and types of arguments in each call to the function, and warn you when they do not match the format string. For example, take this declaration of ‘eprintf’: void eprintf (const char *template, ...) __attribute__ ((format (printf, 1, 2))); This tells the compiler that ‘eprintf’ uses a format string like ‘printf’ (as opposed to ‘scanf’; *note Formatted Input::); the format string appears as the first argument; and the arguments to satisfy the format begin with the second. *Note Declaring Attributes of Functions: (gcc)Function Attributes, for more information.  File: libc.info, Node: Parsing a Template String, Next: Example of Parsing, Prev: Variable Arguments Output, Up: Formatted Output 12.12.10 Parsing a Template String ---------------------------------- You can use the function ‘parse_printf_format’ to obtain information about the number and types of arguments that are expected by a given template string. This function permits interpreters that provide interfaces to ‘printf’ to avoid passing along invalid arguments from the user’s program, which could cause a crash. All the symbols described in this section are declared in the header file ‘printf.h’. -- Function: size_t parse_printf_format (const char *TEMPLATE, size_t N, int *ARGTYPES) Preliminary: | MT-Safe locale | AS-Safe | AC-Safe | *Note POSIX Safety Concepts::. This function returns information about the number and types of arguments expected by the ‘printf’ template string TEMPLATE. The information is stored in the array ARGTYPES; each element of this array describes one argument. This information is encoded using the various ‘PA_’ macros, listed below. The argument N specifies the number of elements in the array ARGTYPES. This is the maximum number of elements that ‘parse_printf_format’ will try to write. ‘parse_printf_format’ returns the total number of arguments required by TEMPLATE. If this number is greater than N, then the information returned describes only the first N arguments. If you want information about additional arguments, allocate a bigger array and call ‘parse_printf_format’ again. The argument types are encoded as a combination of a basic type and modifier flag bits. -- Macro: int PA_FLAG_MASK This macro is a bitmask for the type modifier flag bits. You can write the expression ‘(argtypes[i] & PA_FLAG_MASK)’ to extract just the flag bits for an argument, or ‘(argtypes[i] & ~PA_FLAG_MASK)’ to extract just the basic type code. Here are symbolic constants that represent the basic types; they stand for integer values. ‘PA_INT’ This specifies that the base type is ‘int’. ‘PA_CHAR’ This specifies that the base type is ‘int’, cast to ‘char’. ‘PA_STRING’ This specifies that the base type is ‘char *’, a null-terminated string. ‘PA_POINTER’ This specifies that the base type is ‘void *’, an arbitrary pointer. ‘PA_FLOAT’ This specifies that the base type is ‘float’. ‘PA_DOUBLE’ This specifies that the base type is ‘double’. ‘PA_LAST’ You can define additional base types for your own programs as offsets from ‘PA_LAST’. For example, if you have data types ‘foo’ and ‘bar’ with their own specialized ‘printf’ conversions, you could define encodings for these types as: #define PA_FOO PA_LAST #define PA_BAR (PA_LAST + 1) Here are the flag bits that modify a basic type. They are combined with the code for the basic type using inclusive-or. ‘PA_FLAG_PTR’ If this bit is set, it indicates that the encoded type is a pointer to the base type, rather than an immediate value. For example, ‘PA_INT|PA_FLAG_PTR’ represents the type ‘int *’. ‘PA_FLAG_SHORT’ If this bit is set, it indicates that the base type is modified with ‘short’. (This corresponds to the ‘h’ type modifier.) ‘PA_FLAG_LONG’ If this bit is set, it indicates that the base type is modified with ‘long’. (This corresponds to the ‘l’ type modifier.) ‘PA_FLAG_LONG_LONG’ If this bit is set, it indicates that the base type is modified with ‘long long’. (This corresponds to the ‘L’ type modifier.) ‘PA_FLAG_LONG_DOUBLE’ This is a synonym for ‘PA_FLAG_LONG_LONG’, used by convention with a base type of ‘PA_DOUBLE’ to indicate a type of ‘long double’. For an example of using these facilities, see *note Example of Parsing::.  File: libc.info, Node: Example of Parsing, Prev: Parsing a Template String, Up: Formatted Output 12.12.11 Example of Parsing a Template String --------------------------------------------- Here is an example of decoding argument types for a format string. We assume this is part of an interpreter which contains arguments of type ‘NUMBER’, ‘CHAR’, ‘STRING’ and ‘STRUCTURE’ (and perhaps others which are not valid here). /* Test whether the NARGS specified objects in the vector ARGS are valid for the format string FORMAT: if so, return 1. If not, return 0 after printing an error message. */ int validate_args (char *format, int nargs, OBJECT *args) { int *argtypes; int nwanted; /* Get the information about the arguments. Each conversion specification must be at least two characters long, so there cannot be more specifications than half the length of the string. */ argtypes = (int *) alloca (strlen (format) / 2 * sizeof (int)); nwanted = parse_printf_format (format, nargs, argtypes); /* Check the number of arguments. */ if (nwanted > nargs) { error ("too few arguments (at least %d required)", nwanted); return 0; } /* Check the C type wanted for each argument and see if the object given is suitable. */ for (i = 0; i < nwanted; i++) { int wanted; if (argtypes[i] & PA_FLAG_PTR) wanted = STRUCTURE; else switch (argtypes[i] & ~PA_FLAG_MASK) { case PA_INT: case PA_FLOAT: case PA_DOUBLE: wanted = NUMBER; break; case PA_CHAR: wanted = CHAR; break; case PA_STRING: wanted = STRING; break; case PA_POINTER: wanted = STRUCTURE; break; } if (TYPE (args[i]) != wanted) { error ("type mismatch for arg number %d", i); return 0; } } return 1; }  File: libc.info, Node: Customizing Printf, Next: Formatted Input, Prev: Formatted Output, Up: I/O on Streams 12.13 Customizing ‘printf’ ========================== The GNU C Library lets you define your own custom conversion specifiers for ‘printf’ template strings, to teach ‘printf’ clever ways to print the important data structures of your program. The way you do this is by registering the conversion with the function ‘register_printf_function’; see *note Registering New Conversions::. One of the arguments you pass to this function is a pointer to a handler function that produces the actual output; see *note Defining the Output Handler::, for information on how to write this function. You can also install a function that just returns information about the number and type of arguments expected by the conversion specifier. *Note Parsing a Template String::, for information about this. The facilities of this section are declared in the header file ‘printf.h’. * Menu: * Registering New Conversions:: Using ‘register_printf_function’ to register a new output conversion. * Conversion Specifier Options:: The handler must be able to get the options specified in the template when it is called. * Defining the Output Handler:: Defining the handler and arginfo functions that are passed as arguments to ‘register_printf_function’. * Printf Extension Example:: How to define a ‘printf’ handler function. * Predefined Printf Handlers:: Predefined ‘printf’ handlers. *Portability Note:* The ability to extend the syntax of ‘printf’ template strings is a GNU extension. ISO standard C has nothing similar. When using the GNU C compiler or any other compiler that interprets calls to standard I/O functions according to the rules of the language standard it is necessary to disable such handling by the appropriate compiler option. Otherwise the behavior of a program that relies on the extension is undefined.  File: libc.info, Node: Registering New Conversions, Next: Conversion Specifier Options, Up: Customizing Printf 12.13.1 Registering New Conversions ----------------------------------- The function to register a new output conversion is ‘register_printf_function’, declared in ‘printf.h’. -- Function: int register_printf_function (int SPEC, printf_function HANDLER-FUNCTION, printf_arginfo_function ARGINFO-FUNCTION) Preliminary: | MT-Unsafe const:printfext | AS-Unsafe heap lock | AC-Unsafe mem lock | *Note POSIX Safety Concepts::. This function defines the conversion specifier character SPEC. Thus, if SPEC is ‘'Y'’, it defines the conversion ‘%Y’. You can redefine the built-in conversions like ‘%s’, but flag characters like ‘#’ and type modifiers like ‘l’ can never be used as conversions; calling ‘register_printf_function’ for those characters has no effect. It is advisable not to use lowercase letters, since the ISO C standard warns that additional lowercase letters may be standardized in future editions of the standard. The HANDLER-FUNCTION is the function called by ‘printf’ and friends when this conversion appears in a template string. *Note Defining the Output Handler::, for information about how to define a function to pass as this argument. If you specify a null pointer, any existing handler function for SPEC is removed. The ARGINFO-FUNCTION is the function called by ‘parse_printf_format’ when this conversion appears in a template string. *Note Parsing a Template String::, for information about this. *Attention:* In the GNU C Library versions before 2.0 the ARGINFO-FUNCTION function did not need to be installed unless the user used the ‘parse_printf_format’ function. This has changed. Now a call to any of the ‘printf’ functions will call this function when this format specifier appears in the format string. The return value is ‘0’ on success, and ‘-1’ on failure (which occurs if SPEC is out of range). *Portability Note:* It is possible to redefine the standard output conversions but doing so is strongly discouraged because it may interfere with the behavior of programs and compiler implementations that assume the effects of the conversions conform to the relevant language standards. In addition, conforming compilers need not guarantee that the function registered for a standard conversion will be called for each such conversion in every format string in a program.  File: libc.info, Node: Conversion Specifier Options, Next: Defining the Output Handler, Prev: Registering New Conversions, Up: Customizing Printf 12.13.2 Conversion Specifier Options ------------------------------------ If you define a meaning for ‘%A’, what if the template contains ‘%+23A’ or ‘%-#A’? To implement a sensible meaning for these, the handler when called needs to be able to get the options specified in the template. Both the HANDLER-FUNCTION and ARGINFO-FUNCTION accept an argument that points to a ‘struct printf_info’, which contains information about the options appearing in an instance of the conversion specifier. This data type is declared in the header file ‘printf.h’. -- Type: struct printf_info This structure is used to pass information about the options appearing in an instance of a conversion specifier in a ‘printf’ template string to the handler and arginfo functions for that specifier. It contains the following members: ‘int prec’ This is the precision specified. The value is ‘-1’ if no precision was specified. If the precision was given as ‘*’, the ‘printf_info’ structure passed to the handler function contains the actual value retrieved from the argument list. But the structure passed to the arginfo function contains a value of ‘INT_MIN’, since the actual value is not known. ‘int width’ This is the minimum field width specified. The value is ‘0’ if no width was specified. If the field width was given as ‘*’, the ‘printf_info’ structure passed to the handler function contains the actual value retrieved from the argument list. But the structure passed to the arginfo function contains a value of ‘INT_MIN’, since the actual value is not known. ‘wchar_t spec’ This is the conversion specifier character specified. It’s stored in the structure so that you can register the same handler function for multiple characters, but still have a way to tell them apart when the handler function is called. ‘unsigned int is_long_double’ This is a boolean that is true if the ‘L’, ‘ll’, or ‘q’ type modifier was specified. For integer conversions, this indicates ‘long long int’, as opposed to ‘long double’ for floating point conversions. ‘unsigned int is_char’ This is a boolean that is true if the ‘hh’ type modifier was specified. ‘unsigned int is_short’ This is a boolean that is true if the ‘h’ type modifier was specified. ‘unsigned int is_long’ This is a boolean that is true if the ‘l’ type modifier was specified. ‘unsigned int alt’ This is a boolean that is true if the ‘#’ flag was specified. ‘unsigned int space’ This is a boolean that is true if the ‘ ’ flag was specified. ‘unsigned int left’ This is a boolean that is true if the ‘-’ flag was specified. ‘unsigned int showsign’ This is a boolean that is true if the ‘+’ flag was specified. ‘unsigned int group’ This is a boolean that is true if the ‘'’ flag was specified. ‘unsigned int extra’ This flag has a special meaning depending on the context. It could be used freely by the user-defined handlers but when called from the ‘printf’ function this variable always contains the value ‘0’. ‘unsigned int wide’ This flag is set if the stream is wide oriented. ‘wchar_t pad’ This is the character to use for padding the output to the minimum field width. The value is ‘'0'’ if the ‘0’ flag was specified, and ‘' '’ otherwise.  File: libc.info, Node: Defining the Output Handler, Next: Printf Extension Example, Prev: Conversion Specifier Options, Up: Customizing Printf 12.13.3 Defining the Output Handler ----------------------------------- Now let’s look at how to define the handler and arginfo functions which are passed as arguments to ‘register_printf_function’. *Compatibility Note:* The interface changed in the GNU C Library version 2.0. Previously the third argument was of type ‘va_list *’. You should define your handler functions with a prototype like: int FUNCTION (FILE *stream, const struct printf_info *info, const void *const *args) The STREAM argument passed to the handler function is the stream to which it should write output. The INFO argument is a pointer to a structure that contains information about the various options that were included with the conversion in the template string. You should not modify this structure inside your handler function. *Note Conversion Specifier Options::, for a description of this data structure. The ARGS is a vector of pointers to the arguments data. The number of arguments was determined by calling the argument information function provided by the user. Your handler function should return a value just like ‘printf’ does: it should return the number of characters it has written, or a negative value to indicate an error. -- Data Type: printf_function This is the data type that a handler function should have. If you are going to use ‘parse_printf_format’ in your application, you must also define a function to pass as the ARGINFO-FUNCTION argument for each new conversion you install with ‘register_printf_function’. You have to define these functions with a prototype like: int FUNCTION (const struct printf_info *info, size_t n, int *argtypes) The return value from the function should be the number of arguments the conversion expects. The function should also fill in no more than N elements of the ARGTYPES array with information about the types of each of these arguments. This information is encoded using the various ‘PA_’ macros. (You will notice that this is the same calling convention ‘parse_printf_format’ itself uses.) -- Data Type: printf_arginfo_function This type is used to describe functions that return information about the number and type of arguments used by a conversion specifier.  File: libc.info, Node: Printf Extension Example, Next: Predefined Printf Handlers, Prev: Defining the Output Handler, Up: Customizing Printf 12.13.4 ‘printf’ Extension Example ---------------------------------- Here is an example showing how to define a ‘printf’ handler function. This program defines a data structure called a ‘Widget’ and defines the ‘%W’ conversion to print information about ‘Widget *’ arguments, including the pointer value and the name stored in the data structure. The ‘%W’ conversion supports the minimum field width and left-justification options, but ignores everything else. #include #include #include typedef struct { char *name; } Widget; int print_widget (FILE *stream, const struct printf_info *info, const void *const *args) { const Widget *w; char *buffer; int len; /* Format the output into a string. */ w = *((const Widget **) (args[0])); len = asprintf (&buffer, "", w, w->name); if (len == -1) return -1; /* Pad to the minimum field width and print to the stream. */ len = fprintf (stream, "%*s", (info->left ? -info->width : info->width), buffer); /* Clean up and return. */ free (buffer); return len; } int print_widget_arginfo (const struct printf_info *info, size_t n, int *argtypes) { /* We always take exactly one argument and this is a pointer to the structure.. */ if (n > 0) argtypes[0] = PA_POINTER; return 1; } int main (void) { /* Make a widget to print. */ Widget mywidget; mywidget.name = "mywidget"; /* Register the print function for widgets. */ register_printf_function ('W', print_widget, print_widget_arginfo); /* Now print the widget. */ printf ("|%W|\n", &mywidget); printf ("|%35W|\n", &mywidget); printf ("|%-35W|\n", &mywidget); return 0; } The output produced by this program looks like: || | | | |  File: libc.info, Node: Predefined Printf Handlers, Prev: Printf Extension Example, Up: Customizing Printf 12.13.5 Predefined ‘printf’ Handlers ------------------------------------ The GNU C Library also contains a concrete and useful application of the ‘printf’ handler extension. There are two functions available which implement a special way to print floating-point numbers. -- Function: int printf_size (FILE *FP, const struct printf_info *INFO, const void *const *ARGS) Preliminary: | MT-Safe race:fp locale | AS-Unsafe corrupt heap | AC-Unsafe mem corrupt | *Note POSIX Safety Concepts::. Print a given floating point number as for the format ‘%f’ except that there is a postfix character indicating the divisor for the number to make this less than 1000. There are two possible divisors: powers of 1024 or powers of 1000. Which one is used depends on the format character specified while registered this handler. If the character is of lower case, 1024 is used. For upper case characters, 1000 is used. The postfix tag corresponds to bytes, kilobytes, megabytes, gigabytes, etc. The full table is: low Multiplier From Upper Multiplier ’ ’ 1 ’ ’ 1 k 2^10 (1024) kilo K 10^3 (1000) m 2^20 mega M 10^6 g 2^30 giga G 10^9 t 2^40 tera T 10^12 p 2^50 peta P 10^15 e 2^60 exa E 10^18 z 2^70 zetta Z 10^21 y 2^80 yotta Y 10^24 The default precision is 3, i.e., 1024 is printed with a lower-case format character as if it were ‘%.3fk’ and will yield ‘1.000k’. Due to the requirements of ‘register_printf_function’ we must also provide the function which returns information about the arguments. -- Function: int printf_size_info (const struct printf_info *INFO, size_t N, int *ARGTYPES) Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety Concepts::. This function will return in ARGTYPES the information about the used parameters in the way the ‘vfprintf’ implementation expects it. The format always takes one argument. To use these functions both functions must be registered with a call like register_printf_function ('B', printf_size, printf_size_info); Here we register the functions to print numbers as powers of 1000 since the format character ‘'B'’ is an upper-case character. If we would additionally use ‘'b'’ in a line like register_printf_function ('b', printf_size, printf_size_info); we could also print using a power of 1024. Please note that all that is different in these two lines is the format specifier. The ‘printf_size’ function knows about the difference between lower and upper case format specifiers. The use of ‘'B'’ and ‘'b'’ is no coincidence. Rather it is the preferred way to use this functionality since it is available on some other systems which also use format specifiers.  File: libc.info, Node: Formatted Input, Next: EOF and Errors, Prev: Customizing Printf, Up: I/O on Streams 12.14 Formatted Input ===================== The functions described in this section (‘scanf’ and related functions) provide facilities for formatted input analogous to the formatted output facilities. These functions provide a mechanism for reading arbitrary values under the control of a "format string" or "template string". * Menu: * Formatted Input Basics:: Some basics to get you started. * Input Conversion Syntax:: Syntax of conversion specifications. * Table of Input Conversions:: Summary of input conversions and what they do. * Numeric Input Conversions:: Details of conversions for reading numbers. * String Input Conversions:: Details of conversions for reading strings. * Dynamic String Input:: String conversions that ‘malloc’ the buffer. * Other Input Conversions:: Details of miscellaneous other conversions. * Formatted Input Functions:: Descriptions of the actual functions. * Variable Arguments Input:: ‘vscanf’ and friends.  File: libc.info, Node: Formatted Input Basics, Next: Input Conversion Syntax, Up: Formatted Input 12.14.1 Formatted Input Basics ------------------------------ Calls to ‘scanf’ are superficially similar to calls to ‘printf’ in that arbitrary arguments are read under the control of a template string. While the syntax of the conversion specifications in the template is very similar to that for ‘printf’, the interpretation of the template is oriented more towards free-format input and simple pattern matching, rather than fixed-field formatting. For example, most ‘scanf’ conversions skip over any amount of “white space” (including spaces, tabs, and newlines) in the input file, and there is no concept of precision for the numeric input conversions as there is for the corresponding output conversions. Ordinarily, non-whitespace characters in the template are expected to match characters in the input stream exactly, but a matching failure is distinct from an input error on the stream. Another area of difference between ‘scanf’ and ‘printf’ is that you must remember to supply pointers rather than immediate values as the optional arguments to ‘scanf’; the values that are read are stored in the objects that the pointers point to. Even experienced programmers tend to forget this occasionally, so if your program is getting strange errors that seem to be related to ‘scanf’, you might want to double-check this. When a "matching failure" occurs, ‘scanf’ returns immediately, leaving the first non-matching character as the next character to be read from the stream. The normal return value from ‘scanf’ is the number of values that were assigned, so you can use this to determine if a matching error happened before all the expected values were read. The ‘scanf’ function is typically used for things like reading in the contents of tables. For example, here is a function that uses ‘scanf’ to initialize an array of ‘double’: void readarray (double *array, int n) { int i; for (i=0; i scanf ("%a[a-zA-Z0-9] = %a[^\n]\n", &variable, &value)) { invalid_input_error (); return 0; } … }  File: libc.info, Node: Other Input Conversions, Next: Formatted Input Functions, Prev: Dynamic String Input, Up: Formatted Input 12.14.7 Other Input Conversions ------------------------------- This section describes the miscellaneous input conversions. The ‘%p’ conversion is used to read a pointer value. It recognizes the same syntax used by the ‘%p’ output conversion for ‘printf’ (*note Other Output Conversions::); that is, a hexadecimal number just as the ‘%x’ conversion accepts. The corresponding argument should be of type ‘void **’; that is, the address of a place to store a pointer. The resulting pointer value is not guaranteed to be valid if it was not originally written during the same program execution that reads it in. The ‘%n’ conversion produces the number of characters read so far by this call. The corresponding argument should be of type ‘int *’, unless a type modifier is in effect (*note Numeric Input Conversions::). This conversion works in the same way as the ‘%n’ conversion for ‘printf’; see *note Other Output Conversions::, for an example. The ‘%n’ conversion is the only mechanism for determining the success of literal matches or conversions with suppressed assignments. If the ‘%n’ follows the locus of a matching failure, then no value is stored for it since ‘scanf’ returns before processing the ‘%n’. If you store ‘-1’ in that argument slot before calling ‘scanf’, the presence of ‘-1’ after ‘scanf’ indicates an error occurred before the ‘%n’ was reached. Finally, the ‘%%’ conversion matches a literal ‘%’ character in the input stream, without using an argument. This conversion does not permit any flags, field width, or type modifier to be specified.  File: libc.info, Node: Formatted Input Functions, Next: Variable Arguments Input, Prev: Other Input Conversions, Up: Formatted Input 12.14.8 Formatted Input Functions --------------------------------- Here are the descriptions of the functions for performing formatted input. Prototypes for these functions are in the header file ‘stdio.h’. -- Function: int scanf (const char *TEMPLATE, …) Preliminary: | MT-Safe locale | AS-Unsafe corrupt heap | AC-Unsafe mem lock corrupt | *Note POSIX Safety Concepts::. The ‘scanf’ function reads formatted input from the stream ‘stdin’ under the control of the template string TEMPLATE. The optional arguments are pointers to the places which receive the resulting values. The return value is normally the number of successful assignments. If an end-of-file condition is detected before any matches are performed, including matches against whitespace and literal characters in the template, then ‘EOF’ is returned. -- Function: int wscanf (const wchar_t *TEMPLATE, …) Preliminary: | MT-Safe locale | AS-Unsafe corrupt heap | AC-Unsafe mem lock corrupt | *Note POSIX Safety Concepts::. The ‘wscanf’ function reads formatted input from the stream ‘stdin’ under the control of the template string TEMPLATE. The optional arguments are pointers to the places which receive the resulting values. The return value is normally the number of successful assignments. If an end-of-file condition is detected before any matches are performed, including matches against whitespace and literal characters in the template, then ‘WEOF’ is returned. -- Function: int fscanf (FILE *STREAM, const char *TEMPLATE, …) Preliminary: | MT-Safe locale | AS-Unsafe corrupt heap | AC-Unsafe mem lock corrupt | *Note POSIX Safety Concepts::. This function is just like ‘scanf’, except that the input is read from the stream STREAM instead of ‘stdin’. -- Function: int fwscanf (FILE *STREAM, const wchar_t *TEMPLATE, …) Preliminary: | MT-Safe locale | AS-Unsafe corrupt heap | AC-Unsafe mem lock corrupt | *Note POSIX Safety Concepts::. This function is just like ‘wscanf’, except that the input is read from the stream STREAM instead of ‘stdin’. -- Function: int sscanf (const char *S, const char *TEMPLATE, …) Preliminary: | MT-Safe locale | AS-Unsafe heap | AC-Unsafe mem | *Note POSIX Safety Concepts::. This is like ‘scanf’, except that the characters are taken from the null-terminated string S instead of from a stream. Reaching the end of the string is treated as an end-of-file condition. The behavior of this function is undefined if copying takes place between objects that overlap—for example, if S is also given as an argument to receive a string read under control of the ‘%s’, ‘%S’, or ‘%[’ conversion. -- Function: int swscanf (const wchar_t *WS, const wchar_t *TEMPLATE, …) Preliminary: | MT-Safe locale | AS-Unsafe heap | AC-Unsafe mem | *Note POSIX Safety Concepts::. This is like ‘wscanf’, except that the characters are taken from the null-terminated string WS instead of from a stream. Reaching the end of the string is treated as an end-of-file condition. The behavior of this function is undefined if copying takes place between objects that overlap—for example, if WS is also given as an argument to receive a string read under control of the ‘%s’, ‘%S’, or ‘%[’ conversion.  File: libc.info, Node: Variable Arguments Input, Prev: Formatted Input Functions, Up: Formatted Input 12.14.9 Variable Arguments Input Functions ------------------------------------------ The functions ‘vscanf’ and friends are provided so that you can define your own variadic ‘scanf’-like functions that make use of the same internals as the built-in formatted output functions. These functions are analogous to the ‘vprintf’ series of output functions. *Note Variable Arguments Output::, for important information on how to use them. *Portability Note:* The functions listed in this section were introduced in ISO C99 and were before available as GNU extensions. -- Function: int vscanf (const char *TEMPLATE, va_list AP) Preliminary: | MT-Safe locale | AS-Unsafe corrupt heap | AC-Unsafe mem lock corrupt | *Note POSIX Safety Concepts::. This function is similar to ‘scanf’, but instead of taking a variable number of arguments directly, it takes an argument list pointer AP of type ‘va_list’ (*note Variadic Functions::). -- Function: int vwscanf (const wchar_t *TEMPLATE, va_list AP) Preliminary: | MT-Safe locale | AS-Unsafe corrupt heap | AC-Unsafe mem lock corrupt | *Note POSIX Safety Concepts::. This function is similar to ‘wscanf’, but instead of taking a variable number of arguments directly, it takes an argument list pointer AP of type ‘va_list’ (*note Variadic Functions::). -- Function: int vfscanf (FILE *STREAM, const char *TEMPLATE, va_list AP) Preliminary: | MT-Safe locale | AS-Unsafe corrupt heap | AC-Unsafe mem lock corrupt | *Note POSIX Safety Concepts::. This is the equivalent of ‘fscanf’ with the variable argument list specified directly as for ‘vscanf’. -- Function: int vfwscanf (FILE *STREAM, const wchar_t *TEMPLATE, va_list AP) Preliminary: | MT-Safe locale | AS-Unsafe corrupt heap | AC-Unsafe mem lock corrupt | *Note POSIX Safety Concepts::. This is the equivalent of ‘fwscanf’ with the variable argument list specified directly as for ‘vwscanf’. -- Function: int vsscanf (const char *S, const char *TEMPLATE, va_list AP) Preliminary: | MT-Safe locale | AS-Unsafe heap | AC-Unsafe mem | *Note POSIX Safety Concepts::. This is the equivalent of ‘sscanf’ with the variable argument list specified directly as for ‘vscanf’. -- Function: int vswscanf (const wchar_t *S, const wchar_t *TEMPLATE, va_list AP) Preliminary: | MT-Safe locale | AS-Unsafe heap | AC-Unsafe mem | *Note POSIX Safety Concepts::. This is the equivalent of ‘swscanf’ with the variable argument list specified directly as for ‘vwscanf’. In GNU C, there is a special construct you can use to let the compiler know that a function uses a ‘scanf’-style format string. Then it can check the number and types of arguments in each call to the function, and warn you when they do not match the format string. For details, see *note Declaring Attributes of Functions: (gcc)Function Attributes.  File: libc.info, Node: EOF and Errors, Next: Error Recovery, Prev: Formatted Input, Up: I/O on Streams 12.15 End-Of-File and Errors ============================ Many of the functions described in this chapter return the value of the macro ‘EOF’ to indicate unsuccessful completion of the operation. Since ‘EOF’ is used to report both end of file and random errors, it’s often better to use the ‘feof’ function to check explicitly for end of file and ‘ferror’ to check for errors. These functions check indicators that are part of the internal state of the stream object, indicators set if the appropriate condition was detected by a previous I/O operation on that stream. -- Macro: int EOF This macro is an integer value that is returned by a number of narrow stream functions to indicate an end-of-file condition, or some other error situation. With the GNU C Library, ‘EOF’ is ‘-1’. In other libraries, its value may be some other negative number. This symbol is declared in ‘stdio.h’. -- Macro: int WEOF This macro is an integer value that is returned by a number of wide stream functions to indicate an end-of-file condition, or some other error situation. With the GNU C Library, ‘WEOF’ is ‘-1’. In other libraries, its value may be some other negative number. This symbol is declared in ‘wchar.h’. -- Function: int feof (FILE *STREAM) Preliminary: | MT-Safe | AS-Safe | AC-Unsafe lock | *Note POSIX Safety Concepts::. The ‘feof’ function returns nonzero if and only if the end-of-file indicator for the stream STREAM is set. This symbol is declared in ‘stdio.h’. -- Function: int feof_unlocked (FILE *STREAM) Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety Concepts::. The ‘feof_unlocked’ function is equivalent to the ‘feof’ function except that it does not implicitly lock the stream. This function is a GNU extension. This symbol is declared in ‘stdio.h’. -- Function: int ferror (FILE *STREAM) Preliminary: | MT-Safe | AS-Safe | AC-Unsafe lock | *Note POSIX Safety Concepts::. The ‘ferror’ function returns nonzero if and only if the error indicator for the stream STREAM is set, indicating that an error has occurred on a previous operation on the stream. This symbol is declared in ‘stdio.h’. -- Function: int ferror_unlocked (FILE *STREAM) Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety Concepts::. The ‘ferror_unlocked’ function is equivalent to the ‘ferror’ function except that it does not implicitly lock the stream. This function is a GNU extension. This symbol is declared in ‘stdio.h’. In addition to setting the error indicator associated with the stream, the functions that operate on streams also set ‘errno’ in the same way as the corresponding low-level functions that operate on file descriptors. For example, all of the functions that perform output to a stream—such as ‘fputc’, ‘printf’, and ‘fflush’—are implemented in terms of ‘write’, and all of the ‘errno’ error conditions defined for ‘write’ are meaningful for these functions. For more information about the descriptor-level I/O functions, see *note Low-Level I/O::.  File: libc.info, Node: Error Recovery, Next: Binary Streams, Prev: EOF and Errors, Up: I/O on Streams 12.16 Recovering from errors ============================ You may explicitly clear the error and EOF flags with the ‘clearerr’ function. -- Function: void clearerr (FILE *STREAM) Preliminary: | MT-Safe | AS-Safe | AC-Unsafe lock | *Note POSIX Safety Concepts::. This function clears the end-of-file and error indicators for the stream STREAM. The file positioning functions (*note File Positioning::) also clear the end-of-file indicator for the stream. -- Function: void clearerr_unlocked (FILE *STREAM) Preliminary: | MT-Safe race:stream | AS-Safe | AC-Safe | *Note POSIX Safety Concepts::. The ‘clearerr_unlocked’ function is equivalent to the ‘clearerr’ function except that it does not implicitly lock the stream. This function is a GNU extension. Note that it is _not_ correct to just clear the error flag and retry a failed stream operation. After a failed write, any number of characters since the last buffer flush may have been committed to the file, while some buffered data may have been discarded. Merely retrying can thus cause lost or repeated data. A failed read may leave the file pointer in an inappropriate position for a second try. In both cases, you should seek to a known position before retrying. Most errors that can happen are not recoverable — a second try will always fail again in the same way. So usually it is best to give up and report the error to the user, rather than install complicated recovery logic. One important exception is ‘EINTR’ (*note Interrupted Primitives::). Many stream I/O implementations will treat it as an ordinary error, which can be quite inconvenient. You can avoid this hassle by installing all signals with the ‘SA_RESTART’ flag. For similar reasons, setting nonblocking I/O on a stream’s file descriptor is not usually advisable.  File: libc.info, Node: Binary Streams, Next: File Positioning, Prev: Error Recovery, Up: I/O on Streams 12.17 Text and Binary Streams ============================= GNU systems and other POSIX-compatible operating systems organize all files as uniform sequences of characters. However, some other systems make a distinction between files containing text and files containing binary data, and the input and output facilities of ISO C provide for this distinction. This section tells you how to write programs portable to such systems. When you open a stream, you can specify either a "text stream" or a "binary stream". You indicate that you want a binary stream by specifying the ‘b’ modifier in the OPENTYPE argument to ‘fopen’; see *note Opening Streams::. Without this option, ‘fopen’ opens the file as a text stream. Text and binary streams differ in several ways: • The data read from a text stream is divided into "lines" which are terminated by newline (‘'\n'’) characters, while a binary stream is simply a long series of characters. A text stream might on some systems fail to handle lines more than 254 characters long (including the terminating newline character). • On some systems, text files can contain only printing characters, horizontal tab characters, and newlines, and so text streams may not support other characters. However, binary streams can handle any character value. • Space characters that are written immediately preceding a newline character in a text stream may disappear when the file is read in again. • More generally, there need not be a one-to-one mapping between characters that are read from or written to a text stream, and the characters in the actual file. Since a binary stream is always more capable and more predictable than a text stream, you might wonder what purpose text streams serve. Why not simply always use binary streams? The answer is that on these operating systems, text and binary streams use different file formats, and the only way to read or write “an ordinary file of text” that can work with other text-oriented programs is through a text stream. In the GNU C Library, and on all POSIX systems, there is no difference between text streams and binary streams. When you open a stream, you get the same kind of stream regardless of whether you ask for binary. This stream can handle any file content, and has none of the restrictions that text streams sometimes have.  File: libc.info, Node: File Positioning, Next: Portable Positioning, Prev: Binary Streams, Up: I/O on Streams 12.18 File Positioning ====================== The "file position" of a stream describes where in the file the stream is currently reading or writing. I/O on the stream advances the file position through the file. On GNU systems, the file position is represented as an integer, which counts the number of bytes from the beginning of the file. *Note File Position::. During I/O to an ordinary disk file, you can change the file position whenever you wish, so as to read or write any portion of the file. Some other kinds of files may also permit this. Files which support changing the file position are sometimes referred to as "random-access" files. You can use the functions in this section to examine or modify the file position indicator associated with a stream. The symbols listed below are declared in the header file ‘stdio.h’. -- Function: long int ftell (FILE *STREAM) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe lock corrupt | *Note POSIX Safety Concepts::. This function returns the current file position of the stream STREAM. This function can fail if the stream doesn’t support file positioning, or if the file position can’t be represented in a ‘long int’, and possibly for other reasons as well. If a failure occurs, a value of ‘-1’ is returned. -- Function: off_t ftello (FILE *STREAM) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe lock corrupt | *Note POSIX Safety Concepts::. The ‘ftello’ function is similar to ‘ftell’, except that it returns a value of type ‘off_t’. Systems which support this type use it to describe all file positions, unlike the POSIX specification which uses a long int. The two are not necessarily the same size. Therefore, using ftell can lead to problems if the implementation is written on top of a POSIX compliant low-level I/O implementation, and using ‘ftello’ is preferable whenever it is available. If this function fails it returns ‘(off_t) -1’. This can happen due to missing support for file positioning or internal errors. Otherwise the return value is the current file position. The function is an extension defined in the Unix Single Specification version 2. When the sources are compiled with ‘_FILE_OFFSET_BITS == 64’ on a 32 bit system this function is in fact ‘ftello64’. I.e., the LFS interface transparently replaces the old interface. -- Function: off64_t ftello64 (FILE *STREAM) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe lock corrupt | *Note POSIX Safety Concepts::. This function is similar to ‘ftello’ with the only difference that the return value is of type ‘off64_t’. This also requires that the stream STREAM was opened using either ‘fopen64’, ‘freopen64’, or ‘tmpfile64’ since otherwise the underlying file operations to position the file pointer beyond the 2^31 bytes limit might fail. If the sources are compiled with ‘_FILE_OFFSET_BITS == 64’ on a 32 bits machine this function is available under the name ‘ftello’ and so transparently replaces the old interface. -- Function: int fseek (FILE *STREAM, long int OFFSET, int WHENCE) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe lock corrupt | *Note POSIX Safety Concepts::. The ‘fseek’ function is used to change the file position of the stream STREAM. The value of WHENCE must be one of the constants ‘SEEK_SET’, ‘SEEK_CUR’, or ‘SEEK_END’, to indicate whether the OFFSET is relative to the beginning of the file, the current file position, or the end of the file, respectively. This function returns a value of zero if the operation was successful, and a nonzero value to indicate failure. A successful call also clears the end-of-file indicator of STREAM and discards any characters that were “pushed back” by the use of ‘ungetc’. ‘fseek’ either flushes any buffered output before setting the file position or else remembers it so it will be written later in its proper place in the file. -- Function: int fseeko (FILE *STREAM, off_t OFFSET, int WHENCE) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe lock corrupt | *Note POSIX Safety Concepts::. This function is similar to ‘fseek’ but it corrects a problem with ‘fseek’ in a system with POSIX types. Using a value of type ‘long int’ for the offset is not compatible with POSIX. ‘fseeko’ uses the correct type ‘off_t’ for the OFFSET parameter. For this reason it is a good idea to prefer ‘ftello’ whenever it is available since its functionality is (if different at all) closer the underlying definition. The functionality and return value are the same as for ‘fseek’. The function is an extension defined in the Unix Single Specification version 2. When the sources are compiled with ‘_FILE_OFFSET_BITS == 64’ on a 32 bit system this function is in fact ‘fseeko64’. I.e., the LFS interface transparently replaces the old interface. -- Function: int fseeko64 (FILE *STREAM, off64_t OFFSET, int WHENCE) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe lock corrupt | *Note POSIX Safety Concepts::. This function is similar to ‘fseeko’ with the only difference that the OFFSET parameter is of type ‘off64_t’. This also requires that the stream STREAM was opened using either ‘fopen64’, ‘freopen64’, or ‘tmpfile64’ since otherwise the underlying file operations to position the file pointer beyond the 2^31 bytes limit might fail. If the sources are compiled with ‘_FILE_OFFSET_BITS == 64’ on a 32 bits machine this function is available under the name ‘fseeko’ and so transparently replaces the old interface. *Portability Note:* In non-POSIX systems, ‘ftell’, ‘ftello’, ‘fseek’ and ‘fseeko’ might work reliably only on binary streams. *Note Binary Streams::. The following symbolic constants are defined for use as the WHENCE argument to ‘fseek’. They are also used with the ‘lseek’ function (*note I/O Primitives::) and to specify offsets for file locks (*note Control Operations::). -- Macro: int SEEK_SET This is an integer constant which, when used as the WHENCE argument to the ‘fseek’ or ‘fseeko’ functions, specifies that the offset provided is relative to the beginning of the file. -- Macro: int SEEK_CUR This is an integer constant which, when used as the WHENCE argument to the ‘fseek’ or ‘fseeko’ functions, specifies that the offset provided is relative to the current file position. -- Macro: int SEEK_END This is an integer constant which, when used as the WHENCE argument to the ‘fseek’ or ‘fseeko’ functions, specifies that the offset provided is relative to the end of the file. -- Function: void rewind (FILE *STREAM) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe lock corrupt | *Note POSIX Safety Concepts::. The ‘rewind’ function positions the stream STREAM at the beginning of the file. It is equivalent to calling ‘fseek’ or ‘fseeko’ on the STREAM with an OFFSET argument of ‘0L’ and a WHENCE argument of ‘SEEK_SET’, except that the return value is discarded and the error indicator for the stream is reset. These three aliases for the ‘SEEK_…’ constants exist for the sake of compatibility with older BSD systems. They are defined in two different header files: ‘fcntl.h’ and ‘sys/file.h’. ‘L_SET’ An alias for ‘SEEK_SET’. ‘L_INCR’ An alias for ‘SEEK_CUR’. ‘L_XTND’ An alias for ‘SEEK_END’.  File: libc.info, Node: Portable Positioning, Next: Stream Buffering, Prev: File Positioning, Up: I/O on Streams 12.19 Portable File-Position Functions ====================================== On GNU systems, the file position is truly a character count. You can specify any character count value as an argument to ‘fseek’ or ‘fseeko’ and get reliable results for any random access file. However, some ISO C systems do not represent file positions in this way. On some systems where text streams truly differ from binary streams, it is impossible to represent the file position of a text stream as a count of characters from the beginning of the file. For example, the file position on some systems must encode both a record offset within the file, and a character offset within the record. As a consequence, if you want your programs to be portable to these systems, you must observe certain rules: • The value returned from ‘ftell’ on a text stream has no predictable relationship to the number of characters you have read so far. The only thing you can rely on is that you can use it subsequently as the OFFSET argument to ‘fseek’ or ‘fseeko’ to move back to the same file position. • In a call to ‘fseek’ or ‘fseeko’ on a text stream, either the OFFSET must be zero, or WHENCE must be ‘SEEK_SET’ and the OFFSET must be the result of an earlier call to ‘ftell’ on the same stream. • The value of the file position indicator of a text stream is undefined while there are characters that have been pushed back with ‘ungetc’ that haven’t been read or discarded. *Note Unreading::. But even if you observe these rules, you may still have trouble for long files, because ‘ftell’ and ‘fseek’ use a ‘long int’ value to represent the file position. This type may not have room to encode all the file positions in a large file. Using the ‘ftello’ and ‘fseeko’ functions might help here since the ‘off_t’ type is expected to be able to hold all file position values but this still does not help to handle additional information which must be associated with a file position. So if you do want to support systems with peculiar encodings for the file positions, it is better to use the functions ‘fgetpos’ and ‘fsetpos’ instead. These functions represent the file position using the data type ‘fpos_t’, whose internal representation varies from system to system. These symbols are declared in the header file ‘stdio.h’. -- Data Type: fpos_t This is the type of an object that can encode information about the file position of a stream, for use by the functions ‘fgetpos’ and ‘fsetpos’. In the GNU C Library, ‘fpos_t’ is an opaque data structure that contains internal data to represent file offset and conversion state information. In other systems, it might have a different internal representation. When compiling with ‘_FILE_OFFSET_BITS == 64’ on a 32 bit machine this type is in fact equivalent to ‘fpos64_t’ since the LFS interface transparently replaces the old interface. -- Data Type: fpos64_t This is the type of an object that can encode information about the file position of a stream, for use by the functions ‘fgetpos64’ and ‘fsetpos64’. In the GNU C Library, ‘fpos64_t’ is an opaque data structure that contains internal data to represent file offset and conversion state information. In other systems, it might have a different internal representation. -- Function: int fgetpos (FILE *STREAM, fpos_t *POSITION) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe lock corrupt | *Note POSIX Safety Concepts::. This function stores the value of the file position indicator for the stream STREAM in the ‘fpos_t’ object pointed to by POSITION. If successful, ‘fgetpos’ returns zero; otherwise it returns a nonzero value and stores an implementation-defined positive value in ‘errno’. When the sources are compiled with ‘_FILE_OFFSET_BITS == 64’ on a 32 bit system the function is in fact ‘fgetpos64’. I.e., the LFS interface transparently replaces the old interface. -- Function: int fgetpos64 (FILE *STREAM, fpos64_t *POSITION) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe lock corrupt | *Note POSIX Safety Concepts::. This function is similar to ‘fgetpos’ but the file position is returned in a variable of type ‘fpos64_t’ to which POSITION points. If the sources are compiled with ‘_FILE_OFFSET_BITS == 64’ on a 32 bits machine this function is available under the name ‘fgetpos’ and so transparently replaces the old interface. -- Function: int fsetpos (FILE *STREAM, const fpos_t *POSITION) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe lock corrupt | *Note POSIX Safety Concepts::. This function sets the file position indicator for the stream STREAM to the position POSITION, which must have been set by a previous call to ‘fgetpos’ on the same stream. If successful, ‘fsetpos’ clears the end-of-file indicator on the stream, discards any characters that were “pushed back” by the use of ‘ungetc’, and returns a value of zero. Otherwise, ‘fsetpos’ returns a nonzero value and stores an implementation-defined positive value in ‘errno’. When the sources are compiled with ‘_FILE_OFFSET_BITS == 64’ on a 32 bit system the function is in fact ‘fsetpos64’. I.e., the LFS interface transparently replaces the old interface. -- Function: int fsetpos64 (FILE *STREAM, const fpos64_t *POSITION) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe lock corrupt | *Note POSIX Safety Concepts::. This function is similar to ‘fsetpos’ but the file position used for positioning is provided in a variable of type ‘fpos64_t’ to which POSITION points. If the sources are compiled with ‘_FILE_OFFSET_BITS == 64’ on a 32 bits machine this function is available under the name ‘fsetpos’ and so transparently replaces the old interface.  File: libc.info, Node: Stream Buffering, Next: Other Kinds of Streams, Prev: Portable Positioning, Up: I/O on Streams 12.20 Stream Buffering ====================== Characters that are written to a stream are normally accumulated and transmitted asynchronously to the file in a block, instead of appearing as soon as they are output by the application program. Similarly, streams often retrieve input from the host environment in blocks rather than on a character-by-character basis. This is called "buffering". If you are writing programs that do interactive input and output using streams, you need to understand how buffering works when you design the user interface to your program. Otherwise, you might find that output (such as progress or prompt messages) doesn’t appear when you intended it to, or displays some other unexpected behavior. This section deals only with controlling when characters are transmitted between the stream and the file or device, and _not_ with how things like echoing, flow control, and the like are handled on specific classes of devices. For information on common control operations on terminal devices, see *note Low-Level Terminal Interface::. You can bypass the stream buffering facilities altogether by using the low-level input and output functions that operate on file descriptors instead. *Note Low-Level I/O::. * Menu: * Buffering Concepts:: Terminology is defined here. * Flushing Buffers:: How to ensure that output buffers are flushed. * Controlling Buffering:: How to specify what kind of buffering to use.  File: libc.info, Node: Buffering Concepts, Next: Flushing Buffers, Up: Stream Buffering 12.20.1 Buffering Concepts -------------------------- There are three different kinds of buffering strategies: • Characters written to or read from an "unbuffered" stream are transmitted individually to or from the file as soon as possible. • Characters written to a "line buffered" stream are transmitted to the file in blocks when a newline character is encountered. • Characters written to or read from a "fully buffered" stream are transmitted to or from the file in blocks of arbitrary size. Newly opened streams are normally fully buffered, with one exception: a stream connected to an interactive device such as a terminal is initially line buffered. *Note Controlling Buffering::, for information on how to select a different kind of buffering. Usually the automatic selection gives you the most convenient kind of buffering for the file or device you open. The use of line buffering for interactive devices implies that output messages ending in a newline will appear immediately—which is usually what you want. Output that doesn’t end in a newline might or might not show up immediately, so if you want them to appear immediately, you should flush buffered output explicitly with ‘fflush’, as described in *note Flushing Buffers::.  File: libc.info, Node: Flushing Buffers, Next: Controlling Buffering, Prev: Buffering Concepts, Up: Stream Buffering 12.20.2 Flushing Buffers ------------------------ "Flushing" output on a buffered stream means transmitting all accumulated characters to the file. There are many circumstances when buffered output on a stream is flushed automatically: • When you try to do output and the output buffer is full. • When the stream is closed. *Note Closing Streams::. • When the program terminates by calling ‘exit’. *Note Normal Termination::. • When a newline is written, if the stream is line buffered. • Whenever an input operation on _any_ stream actually reads data from its file. If you want to flush the buffered output at another time, call ‘fflush’, which is declared in the header file ‘stdio.h’. -- Function: int fflush (FILE *STREAM) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe lock corrupt | *Note POSIX Safety Concepts::. This function causes any buffered output on STREAM to be delivered to the file. If STREAM is a null pointer, then ‘fflush’ causes buffered output on _all_ open output streams to be flushed. This function returns ‘EOF’ if a write error occurs, or zero otherwise. -- Function: int fflush_unlocked (FILE *STREAM) Preliminary: | MT-Safe race:stream | AS-Unsafe corrupt | AC-Unsafe corrupt | *Note POSIX Safety Concepts::. The ‘fflush_unlocked’ function is equivalent to the ‘fflush’ function except that it does not implicitly lock the stream. The ‘fflush’ function can be used to flush all streams currently opened. While this is useful in some situations it does often more than necessary since it might be done in situations when terminal input is required and the program wants to be sure that all output is visible on the terminal. But this means that only line buffered streams have to be flushed. Solaris introduced a function especially for this. It was always available in the GNU C Library in some form but never officially exported. -- Function: void _flushlbf (void) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe lock corrupt | *Note POSIX Safety Concepts::. The ‘_flushlbf’ function flushes all line buffered streams currently opened. This function is declared in the ‘stdio_ext.h’ header. *Compatibility Note:* Some brain-damaged operating systems have been known to be so thoroughly fixated on line-oriented input and output that flushing a line buffered stream causes a newline to be written! Fortunately, this “feature” seems to be becoming less common. You do not need to worry about this with the GNU C Library. In some situations it might be useful to not flush the output pending for a stream but instead simply forget it. If transmission is costly and the output is not needed anymore this is valid reasoning. In this situation a non-standard function introduced in Solaris and available in the GNU C Library can be used. -- Function: void __fpurge (FILE *STREAM) Preliminary: | MT-Safe race:stream | AS-Unsafe corrupt | AC-Unsafe corrupt | *Note POSIX Safety Concepts::. The ‘__fpurge’ function causes the buffer of the stream STREAM to be emptied. If the stream is currently in read mode all input in the buffer is lost. If the stream is in output mode the buffered output is not written to the device (or whatever other underlying storage) and the buffer is cleared. This function is declared in ‘stdio_ext.h’.  File: libc.info, Node: Controlling Buffering, Prev: Flushing Buffers, Up: Stream Buffering 12.20.3 Controlling Which Kind of Buffering ------------------------------------------- After opening a stream (but before any other operations have been performed on it), you can explicitly specify what kind of buffering you want it to have using the ‘setvbuf’ function. The facilities listed in this section are declared in the header file ‘stdio.h’. -- Function: int setvbuf (FILE *STREAM, char *BUF, int MODE, size_t SIZE) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe lock corrupt | *Note POSIX Safety Concepts::. This function is used to specify that the stream STREAM should have the buffering mode MODE, which can be either ‘_IOFBF’ (for full buffering), ‘_IOLBF’ (for line buffering), or ‘_IONBF’ (for unbuffered input/output). If you specify a null pointer as the BUF argument, then ‘setvbuf’ allocates a buffer itself using ‘malloc’. This buffer will be freed when you close the stream. Otherwise, BUF should be a character array that can hold at least SIZE characters. You should not free the space for this array as long as the stream remains open and this array remains its buffer. You should usually either allocate it statically, or ‘malloc’ (*note Unconstrained Allocation::) the buffer. Using an automatic array is not a good idea unless you close the file before exiting the block that declares the array. While the array remains a stream buffer, the stream I/O functions will use the buffer for their internal purposes. You shouldn’t try to access the values in the array directly while the stream is using it for buffering. The ‘setvbuf’ function returns zero on success, or a nonzero value if the value of MODE is not valid or if the request could not be honored. -- Macro: int _IOFBF The value of this macro is an integer constant expression that can be used as the MODE argument to the ‘setvbuf’ function to specify that the stream should be fully buffered. -- Macro: int _IOLBF The value of this macro is an integer constant expression that can be used as the MODE argument to the ‘setvbuf’ function to specify that the stream should be line buffered. -- Macro: int _IONBF The value of this macro is an integer constant expression that can be used as the MODE argument to the ‘setvbuf’ function to specify that the stream should be unbuffered. -- Macro: int BUFSIZ The value of this macro is an integer constant expression that is good to use for the SIZE argument to ‘setvbuf’. This value is guaranteed to be at least ‘256’. The value of ‘BUFSIZ’ is chosen on each system so as to make stream I/O efficient. So it is a good idea to use ‘BUFSIZ’ as the size for the buffer when you call ‘setvbuf’. Actually, you can get an even better value to use for the buffer size by means of the ‘fstat’ system call: it is found in the ‘st_blksize’ field of the file attributes. *Note Attribute Meanings::. Sometimes people also use ‘BUFSIZ’ as the allocation size of buffers used for related purposes, such as strings used to receive a line of input with ‘fgets’ (*note Character Input::). There is no particular reason to use ‘BUFSIZ’ for this instead of any other integer, except that it might lead to doing I/O in chunks of an efficient size. -- Function: void setbuf (FILE *STREAM, char *BUF) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe lock corrupt | *Note POSIX Safety Concepts::. If BUF is a null pointer, the effect of this function is equivalent to calling ‘setvbuf’ with a MODE argument of ‘_IONBF’. Otherwise, it is equivalent to calling ‘setvbuf’ with BUF, and a MODE of ‘_IOFBF’ and a SIZE argument of ‘BUFSIZ’. The ‘setbuf’ function is provided for compatibility with old code; use ‘setvbuf’ in all new programs. -- Function: void setbuffer (FILE *STREAM, char *BUF, size_t SIZE) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe lock corrupt | *Note POSIX Safety Concepts::. If BUF is a null pointer, this function makes STREAM unbuffered. Otherwise, it makes STREAM fully buffered using BUF as the buffer. The SIZE argument specifies the length of BUF. This function is provided for compatibility with old BSD code. Use ‘setvbuf’ instead. -- Function: void setlinebuf (FILE *STREAM) Preliminary: | MT-Safe | AS-Unsafe corrupt | AC-Unsafe lock corrupt | *Note POSIX Safety Concepts::. This function makes STREAM be line buffered, and allocates the buffer for you. This function is provided for compatibility with old BSD code. Use ‘setvbuf’ instead. It is possible to query whether a given stream is line buffered or not using a non-standard function introduced in Solaris and available in the GNU C Library. -- Function: int __flbf (FILE *STREAM) Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety Concepts::. The ‘__flbf’ function will return a nonzero value in case the stream STREAM is line buffered. Otherwise the return value is zero. This function is declared in the ‘stdio_ext.h’ header. Two more extensions allow to determine the size of the buffer and how much of it is used. These functions were also introduced in Solaris. -- Function: size_t __fbufsize (FILE *STREAM) Preliminary: | MT-Safe race:stream | AS-Unsafe corrupt | AC-Safe | *Note POSIX Safety Concepts::. The ‘__fbufsize’ function return the size of the buffer in the stream STREAM. This value can be used to optimize the use of the stream. This function is declared in the ‘stdio_ext.h’ header. -- Function: size_t __fpending (FILE *STREAM) Preliminary: | MT-Safe race:stream | AS-Unsafe corrupt | AC-Safe | *Note POSIX Safety Concepts::. The ‘__fpending’ function returns the number of bytes currently in the output buffer. For wide-oriented streams the measuring unit is wide characters. This function should not be used on buffers in read mode or opened read-only. This function is declared in the ‘stdio_ext.h’ header.  File: libc.info, Node: Other Kinds of Streams, Next: Formatted Messages, Prev: Stream Buffering, Up: I/O on Streams 12.21 Other Kinds of Streams ============================ The GNU C Library provides ways for you to define additional kinds of streams that do not necessarily correspond to an open file. One such type of stream takes input from or writes output to a string. These kinds of streams are used internally to implement the ‘sprintf’ and ‘sscanf’ functions. You can also create such a stream explicitly, using the functions described in *note String Streams::. More generally, you can define streams that do input/output to arbitrary objects using functions supplied by your program. This protocol is discussed in *note Custom Streams::. *Portability Note:* The facilities described in this section are specific to GNU. Other systems or C implementations might or might not provide equivalent functionality. * Menu: * String Streams:: Streams that get data from or put data in a string or memory buffer. * Custom Streams:: Defining your own streams with an arbitrary input data source and/or output data sink.  File: libc.info, Node: String Streams, Next: Custom Streams, Up: Other Kinds of Streams 12.21.1 String Streams ---------------------- The ‘fmemopen’ and ‘open_memstream’ functions allow you to do I/O to a string or memory buffer. These facilities are declared in ‘stdio.h’. -- Function: FILE * fmemopen (void *BUF, size_t SIZE, const char *OPENTYPE) Preliminary: | MT-Safe | AS-Unsafe heap lock | AC-Unsafe mem lock | *Note POSIX Safety Concepts::. This function opens a stream that allows the access specified by the OPENTYPE argument, that reads from or writes to the buffer specified by the argument BUF. This array must be at least SIZE bytes long. If you specify a null pointer as the BUF argument, ‘fmemopen’ dynamically allocates an array SIZE bytes long (as with ‘malloc’; *note Unconstrained Allocation::). This is really only useful if you are going to write things to the buffer and then read them back in again, because you have no way of actually getting a pointer to the buffer (for this, try ‘open_memstream’, below). The buffer is freed when the stream is closed. The argument OPENTYPE is the same as in ‘fopen’ (*note Opening Streams::). If the OPENTYPE specifies append mode, then the initial file position is set to the first null character in the buffer. Otherwise the initial file position is at the beginning of the buffer. When a stream open for writing is flushed or closed, a null character (zero byte) is written at the end of the buffer if it fits. You should add an extra byte to the SIZE argument to account for this. Attempts to write more than SIZE bytes to the buffer result in an error. For a stream open for reading, null characters (zero bytes) in the buffer do not count as “end of file”. Read operations indicate end of file only when the file position advances past SIZE bytes. So, if you want to read characters from a null-terminated string, you should supply the length of the string as the SIZE argument. Here is an example of using ‘fmemopen’ to create a stream for reading from a string: #include static char buffer[] = "foobar"; int main (void) { int ch; FILE *stream; stream = fmemopen (buffer, strlen (buffer), "r"); while ((ch = fgetc (stream)) != EOF) printf ("Got %c\n", ch); fclose (stream); return 0; } This program produces the following output: Got f Got o Got o Got b Got a Got r -- Function: FILE * open_memstream (char **PTR, size_t *SIZELOC) Preliminary: | MT-Safe | AS-Unsafe heap | AC-Unsafe mem | *Note POSIX Safety Concepts::. This function opens a stream for writing to a buffer. The buffer is allocated dynamically and grown as necessary, using ‘malloc’. After you’ve closed the stream, this buffer is your responsibility to clean up using ‘free’ or ‘realloc’. *Note Unconstrained Allocation::. When the stream is closed with ‘fclose’ or flushed with ‘fflush’, the locations PTR and SIZELOC are updated to contain the pointer to the buffer and its size. The values thus stored remain valid only as long as no further output on the stream takes place. If you do more output, you must flush the stream again to store new values before you use them again. A null character is written at the end of the buffer. This null character is _not_ included in the size value stored at SIZELOC. You can move the stream’s file position with ‘fseek’ or ‘fseeko’ (*note File Positioning::). Moving the file position past the end of the data already written fills the intervening space with zeroes. Here is an example of using ‘open_memstream’: #include int main (void) { char *bp; size_t size; FILE *stream; stream = open_memstream (&bp, &size); fprintf (stream, "hello"); fflush (stream); printf ("buf = `%s', size = %zu\n", bp, size); fprintf (stream, ", world"); fclose (stream); printf ("buf = `%s', size = %zu\n", bp, size); return 0; } This program produces the following output: buf = `hello', size = 5 buf = `hello, world', size = 12  File: libc.info, Node: Custom Streams, Prev: String Streams, Up: Other Kinds of Streams 12.21.2 Programming Your Own Custom Streams ------------------------------------------- This section describes how you can make a stream that gets input from an arbitrary data source or writes output to an arbitrary data sink programmed by you. We call these "custom streams". The functions and types described here are all GNU extensions. * Menu: * Streams and Cookies:: The "cookie" records where to fetch or store data that is read or written. * Hook Functions:: How you should define the four "hook functions" that a custom stream needs.  File: libc.info, Node: Streams and Cookies, Next: Hook Functions, Up: Custom Streams 12.21.2.1 Custom Streams and Cookies .................................... Inside every custom stream is a special object called the "cookie". This is an object supplied by you which records where to fetch or store the data read or written. It is up to you to define a data type to use for the cookie. The stream functions in the library never refer directly to its contents, and they don’t even know what the type is; they record its address with type ‘void *’. To implement a custom stream, you must specify _how_ to fetch or store the data in the specified place. You do this by defining "hook functions" to read, write, change “file position”, and close the stream. All four of these functions will be passed the stream’s cookie so they can tell where to fetch or store the data. The library functions don’t know what’s inside the cookie, but your functions will know. When you create a custom stream, you must specify the cookie pointer, and also the four hook functions stored in a structure of type ‘cookie_io_functions_t’. These facilities are declared in ‘stdio.h’. -- Data Type: cookie_io_functions_t This is a structure type that holds the functions that define the communications protocol between the stream and its cookie. It has the following members: ‘cookie_read_function_t *read’ This is the function that reads data from the cookie. If the value is a null pointer instead of a function, then read operations on this stream always return ‘EOF’. ‘cookie_write_function_t *write’ This is the function that writes data to the cookie. If the value is a null pointer instead of a function, then data written to the stream is discarded. ‘cookie_seek_function_t *seek’ This is the function that performs the equivalent of file positioning on the cookie. If the value is a null pointer instead of a function, calls to ‘fseek’ or ‘fseeko’ on this stream can only seek to locations within the buffer; any attempt to seek outside the buffer will return an ‘ESPIPE’ error. ‘cookie_close_function_t *close’ This function performs any appropriate cleanup on the cookie when closing the stream. If the value is a null pointer instead of a function, nothing special is done to close the cookie when the stream is closed. -- Function: FILE * fopencookie (void *COOKIE, const char *OPENTYPE, cookie_io_functions_t IO-FUNCTIONS) Preliminary: | MT-Safe | AS-Unsafe heap lock | AC-Unsafe mem lock | *Note POSIX Safety Concepts::. This function actually creates the stream for communicating with the COOKIE using the functions in the IO-FUNCTIONS argument. The OPENTYPE argument is interpreted as for ‘fopen’; see *note Opening Streams::. (But note that the “truncate on open” option is ignored.) The new stream is fully buffered. The ‘fopencookie’ function returns the newly created stream, or a null pointer in case of an error.  File: libc.info, Node: Hook Functions, Prev: Streams and Cookies, Up: Custom Streams 12.21.2.2 Custom Stream Hook Functions ...................................... Here are more details on how you should define the four hook functions that a custom stream needs. You should define the function to read data from the cookie as: ssize_t READER (void *COOKIE, char *BUFFER, size_t SIZE) This is very similar to the ‘read’ function; see *note I/O Primitives::. Your function should transfer up to SIZE bytes into the BUFFER, and return the number of bytes read, or zero to indicate end-of-file. You can return a value of ‘-1’ to indicate an error. You should define the function to write data to the cookie as: ssize_t WRITER (void *COOKIE, const char *BUFFER, size_t SIZE) This is very similar to the ‘write’ function; see *note I/O Primitives::. Your function should transfer up to SIZE bytes from the buffer, and return the number of bytes written. You can return a value of ‘0’ to indicate an error. You must not return any negative value. You should define the function to perform seek operations on the cookie as: int SEEKER (void *COOKIE, off64_t *POSITION, int WHENCE) For this function, the POSITION and WHENCE arguments are interpreted as for ‘fgetpos’; see *note Portable Positioning::. After doing the seek operation, your function should store the resulting file position relative to the beginning of the file in POSITION. Your function should return a value of ‘0’ on success and ‘-1’ to indicate an error. You should define the function to do cleanup operations on the cookie appropriate for closing the stream as: int CLEANER (void *COOKIE) Your function should return ‘-1’ to indicate an error, and ‘0’ otherwise. -- Data Type: cookie_read_function_t This is the data type that the read function for a custom stream should have. If you declare the function as shown above, this is the type it will have. -- Data Type: cookie_write_function_t The data type of the write function for a custom stream. -- Data Type: cookie_seek_function_t The data type of the seek function for a custom stream. -- Data Type: cookie_close_function_t The data type of the close function for a custom stream.  File: libc.info, Node: Formatted Messages, Prev: Other Kinds of Streams, Up: I/O on Streams 12.22 Formatted Messages ======================== On systems which are based on System V messages of programs (especially the system tools) are printed in a strict form using the ‘fmtmsg’ function. The uniformity sometimes helps the user to interpret messages and the strictness tests of the ‘fmtmsg’ function ensure that the programmer follows some minimal requirements. * Menu: * Printing Formatted Messages:: The ‘fmtmsg’ function. * Adding Severity Classes:: Add more severity classes. * Example:: How to use ‘fmtmsg’ and ‘addseverity’.  File: libc.info, Node: Printing Formatted Messages, Next: Adding Severity Classes, Up: Formatted Messages 12.22.1 Printing Formatted Messages ----------------------------------- Messages can be printed to standard error and/or to the console. To select the destination the programmer can use the following two values, bitwise OR combined if wanted, for the CLASSIFICATION parameter of ‘fmtmsg’: ‘MM_PRINT’ Display the message in standard error. ‘MM_CONSOLE’ Display the message on the system console. The erroneous piece of the system can be signalled by exactly one of the following values which also is bitwise ORed with the CLASSIFICATION parameter to ‘fmtmsg’: ‘MM_HARD’ The source of the condition is some hardware. ‘MM_SOFT’ The source of the condition is some software. ‘MM_FIRM’ The source of the condition is some firmware. A third component of the CLASSIFICATION parameter to ‘fmtmsg’ can describe the part of the system which detects the problem. This is done by using exactly one of the following values: ‘MM_APPL’ The erroneous condition is detected by the application. ‘MM_UTIL’ The erroneous condition is detected by a utility. ‘MM_OPSYS’ The erroneous condition is detected by the operating system. A last component of CLASSIFICATION can signal the results of this message. Exactly one of the following values can be used: ‘MM_RECOVER’ It is a recoverable error. ‘MM_NRECOV’ It is a non-recoverable error. -- Function: int fmtmsg (long int CLASSIFICATION, const char *LABEL, int SEVERITY, const char *TEXT, const char *ACTION, const char *TAG) Preliminary: | MT-Safe | AS-Unsafe lock | AC-Safe | *Note POSIX Safety Concepts::. Display a message described by its parameters on the device(s) specified in the CLASSIFICATION parameter. The LABEL parameter identifies the source of the message. The string should consist of two colon separated parts where the first part has not more than 10 and the second part not more than 14 characters. The TEXT parameter describes the condition of the error, the ACTION parameter possible steps to recover from the error and the TAG parameter is a reference to the online documentation where more information can be found. It should contain the LABEL value and a unique identification number. Each of the parameters can be a special value which means this value is to be omitted. The symbolic names for these values are: ‘MM_NULLLBL’ Ignore LABEL parameter. ‘MM_NULLSEV’ Ignore SEVERITY parameter. ‘MM_NULLMC’ Ignore CLASSIFICATION parameter. This implies that nothing is actually printed. ‘MM_NULLTXT’ Ignore TEXT parameter. ‘MM_NULLACT’ Ignore ACTION parameter. ‘MM_NULLTAG’ Ignore TAG parameter. There is another way certain fields can be omitted from the output to standard error. This is described below in the description of environment variables influencing the behavior. The SEVERITY parameter can have one of the values in the following table: ‘MM_NOSEV’ Nothing is printed, this value is the same as ‘MM_NULLSEV’. ‘MM_HALT’ This value is printed as ‘HALT’. ‘MM_ERROR’ This value is printed as ‘ERROR’. ‘MM_WARNING’ This value is printed as ‘WARNING’. ‘MM_INFO’ This value is printed as ‘INFO’. The numeric value of these five macros are between ‘0’ and ‘4’. Using the environment variable ‘SEV_LEVEL’ or using the ‘addseverity’ function one can add more severity levels with their corresponding string to print. This is described below (*note Adding Severity Classes::). If no parameter is ignored the output looks like this: LABEL: SEVERITY-STRING: TEXT TO FIX: ACTION TAG The colons, new line characters and the ‘TO FIX’ string are inserted if necessary, i.e., if the corresponding parameter is not ignored. This function is specified in the X/Open Portability Guide. It is also available on all systems derived from System V. The function returns the value ‘MM_OK’ if no error occurred. If only the printing to standard error failed, it returns ‘MM_NOMSG’. If printing to the console fails, it returns ‘MM_NOCON’. If nothing is printed ‘MM_NOTOK’ is returned. Among situations where all outputs fail this last value is also returned if a parameter value is incorrect. There are two environment variables which influence the behavior of ‘fmtmsg’. The first is ‘MSGVERB’. It is used to control the output actually happening on standard error (_not_ the console output). Each of the five fields can explicitly be enabled. To do this the user has to put the ‘MSGVERB’ variable with a format like the following in the environment before calling the ‘fmtmsg’ function the first time: MSGVERB=KEYWORD[:KEYWORD[:…]] Valid KEYWORDs are ‘label’, ‘severity’, ‘text’, ‘action’, and ‘tag’. If the environment variable is not given or is the empty string, a not supported keyword is given or the value is somehow else invalid, no part of the message is masked out. The second environment variable which influences the behavior of ‘fmtmsg’ is ‘SEV_LEVEL’. This variable and the change in the behavior of ‘fmtmsg’ is not specified in the X/Open Portability Guide. It is available in System V systems, though. It can be used to introduce new severity levels. By default, only the five severity levels described above are available. Any other numeric value would make ‘fmtmsg’ print nothing. If the user puts ‘SEV_LEVEL’ with a format like SEV_LEVEL=[DESCRIPTION[:DESCRIPTION[:…]]] in the environment of the process before the first call to ‘fmtmsg’, where DESCRIPTION has a value of the form SEVERITY-KEYWORD,LEVEL,PRINTSTRING The SEVERITY-KEYWORD part is not used by ‘fmtmsg’ but it has to be present. The LEVEL part is a string representation of a number. The numeric value must be a number greater than 4. This value must be used in the SEVERITY parameter of ‘fmtmsg’ to select this class. It is not possible to overwrite any of the predefined classes. The PRINTSTRING is the string printed when a message of this class is processed by ‘fmtmsg’ (see above, ‘fmtsmg’ does not print the numeric value but instead the string representation).  File: libc.info, Node: Adding Severity Classes, Next: Example, Prev: Printing Formatted Messages, Up: Formatted Messages 12.22.2 Adding Severity Classes ------------------------------- There is another possibility to introduce severity classes besides using the environment variable ‘SEV_LEVEL’. This simplifies the task of introducing new classes in a running program. One could use the ‘setenv’ or ‘putenv’ function to set the environment variable, but this is toilsome. -- Function: int addseverity (int SEVERITY, const char *STRING) Preliminary: | MT-Safe | AS-Unsafe heap lock | AC-Unsafe lock mem | *Note POSIX Safety Concepts::. This function allows the introduction of new severity classes which can be addressed by the SEVERITY parameter of the ‘fmtmsg’ function. The SEVERITY parameter of ‘addseverity’ must match the value for the parameter with the same name of ‘fmtmsg’, and STRING is the string printed in the actual messages instead of the numeric value. If STRING is ‘NULL’ the severity class with the numeric value according to SEVERITY is removed. It is not possible to overwrite or remove one of the default severity classes. All calls to ‘addseverity’ with SEVERITY set to one of the values for the default classes will fail. The return value is ‘MM_OK’ if the task was successfully performed. If the return value is ‘MM_NOTOK’ something went wrong. This could mean that no more memory is available or a class is not available when it has to be removed. This function is not specified in the X/Open Portability Guide although the ‘fmtsmg’ function is. It is available on System V systems.  File: libc.info, Node: Example, Prev: Adding Severity Classes, Up: Formatted Messages 12.22.3 How to use ‘fmtmsg’ and ‘addseverity’ --------------------------------------------- Here is a simple example program to illustrate the use of both functions described in this section. #include int main (void) { addseverity (5, "NOTE2"); fmtmsg (MM_PRINT, "only1field", MM_INFO, "text2", "action2", "tag2"); fmtmsg (MM_PRINT, "UX:cat", 5, "invalid syntax", "refer to manual", "UX:cat:001"); fmtmsg (MM_PRINT, "label:foo", 6, "text", "action", "tag"); return 0; } The second call to ‘fmtmsg’ illustrates a use of this function as it usually occurs on System V systems, which heavily use this function. It seems worthwhile to give a short explanation here of how this system works on System V. The value of the LABEL field (‘UX:cat’) says that the error occurred in the Unix program ‘cat’. The explanation of the error follows and the value for the ACTION parameter is ‘"refer to manual"’. One could be more specific here, if necessary. The TAG field contains, as proposed above, the value of the string given for the LABEL parameter, and additionally a unique ID (‘001’ in this case). For a GNU environment this string could contain a reference to the corresponding node in the Info page for the program. Running this program without specifying the ‘MSGVERB’ and ‘SEV_LEVEL’ function produces the following output: UX:cat: NOTE2: invalid syntax TO FIX: refer to manual UX:cat:001 We see the different fields of the message and how the extra glue (the colons and the ‘TO FIX’ string) is printed. But only one of the three calls to ‘fmtmsg’ produced output. The first call does not print anything because the LABEL parameter is not in the correct form. The string must contain two fields, separated by a colon (*note Printing Formatted Messages::). The third ‘fmtmsg’ call produced no output since the class with the numeric value ‘6’ is not defined. Although a class with numeric value ‘5’ is also not defined by default, the call to ‘addseverity’ introduces it and the second call to ‘fmtmsg’ produces the above output. When we change the environment of the program to contain ‘SEV_LEVEL=XXX,6,NOTE’ when running it we get a different result: UX:cat: NOTE2: invalid syntax TO FIX: refer to manual UX:cat:001 label:foo: NOTE: text TO FIX: action tag Now the third call to ‘fmtmsg’ produced some output and we see how the string ‘NOTE’ from the environment variable appears in the message. Now we can reduce the output by specifying which fields we are interested in. If we additionally set the environment variable ‘MSGVERB’ to the value ‘severity:label:action’ we get the following output: UX:cat: NOTE2 TO FIX: refer to manual label:foo: NOTE TO FIX: action I.e., the output produced by the TEXT and the TAG parameters to ‘fmtmsg’ vanished. Please also note that now there is no colon after the ‘NOTE’ and ‘NOTE2’ strings in the output. This is not necessary since there is no more output on this line because the text is missing.  File: libc.info, Node: Low-Level I/O, Next: File System Interface, Prev: I/O on Streams, Up: Top 13 Low-Level Input/Output ************************* This chapter describes functions for performing low-level input/output operations on file descriptors. These functions include the primitives for the higher-level I/O functions described in *note I/O on Streams::, as well as functions for performing low-level control operations for which there are no equivalents on streams. Stream-level I/O is more flexible and usually more convenient; therefore, programmers generally use the descriptor-level functions only when necessary. These are some of the usual reasons: • For reading binary files in large chunks. • For reading an entire file into core before parsing it. • To perform operations other than data transfer, which can only be done with a descriptor. (You can use ‘fileno’ to get the descriptor corresponding to a stream.) • To pass descriptors to a child process. (The child can create its own stream to use a descriptor that it inherits, but cannot inherit a stream directly.) * Menu: * Opening and Closing Files:: How to open and close file descriptors. * I/O Primitives:: Reading and writing data. * File Position Primitive:: Setting a descriptor’s file position. * Descriptors and Streams:: Converting descriptor to stream or vice-versa. * Stream/Descriptor Precautions:: Precautions needed if you use both descriptors and streams. * Scatter-Gather:: Fast I/O to discontinuous buffers. * Copying File Data:: Copying data between files. * Memory-mapped I/O:: Using files like memory. * Waiting for I/O:: How to check for input or output on multiple file descriptors. * Synchronizing I/O:: Making sure all I/O actions completed. * Asynchronous I/O:: Perform I/O in parallel. * Control Operations:: Various other operations on file descriptors. * Duplicating Descriptors:: Fcntl commands for duplicating file descriptors. * Descriptor Flags:: Fcntl commands for manipulating flags associated with file descriptors. * File Status Flags:: Fcntl commands for manipulating flags associated with open files. * File Locks:: Fcntl commands for implementing file locking. * Open File Description Locks:: Fcntl commands for implementing open file description locking. * Open File Description Locks Example:: An example of open file description lock usage * Interrupt Input:: Getting an asynchronous signal when input arrives. * IOCTLs:: Generic I/O Control operations.  File: libc.info, Node: Opening and Closing Files, Next: I/O Primitives, Up: Low-Level I/O 13.1 Opening and Closing Files ============================== This section describes the primitives for opening and closing files using file descriptors. The ‘open’ and ‘creat’ functions are declared in the header file ‘fcntl.h’, while ‘close’ is declared in ‘unistd.h’. -- Function: int open (const char *FILENAME, int FLAGS[, mode_t MODE]) Preliminary: | MT-Safe | AS-Safe | AC-Safe fd | *Note POSIX Safety Concepts::. The ‘open’ function creates and returns a new file descriptor for the file named by FILENAME. Initially, the file position indicator for the file is at the beginning of the file. The argument MODE (*note Permission Bits::) is used only when a file is created, but it doesn’t hurt to supply the argument in any case. The FLAGS argument controls how the file is to be opened. This is a bit mask; you create the value by the bitwise OR of the appropriate parameters (using the ‘|’ operator in C). *Note File Status Flags::, for the parameters available. The normal return value from ‘open’ is a non-negative integer file descriptor. In the case of an error, a value of -1 is returned instead. In addition to the usual file name errors (*note File Name Errors::), the following ‘errno’ error conditions are defined for this function: ‘EACCES’ The file exists but is not readable/writable as requested by the FLAGS argument, or the file does not exist and the directory is unwritable so it cannot be created. ‘EEXIST’ Both ‘O_CREAT’ and ‘O_EXCL’ are set, and the named file already exists. ‘EINTR’ The ‘open’ operation was interrupted by a signal. *Note Interrupted Primitives::. ‘EISDIR’ The FLAGS argument specified write access, and the file is a directory. ‘EMFILE’ The process has too many files open. The maximum number of file descriptors is controlled by the ‘RLIMIT_NOFILE’ resource limit; *note Limits on Resources::. ‘ENFILE’ The entire system, or perhaps the file system which contains the directory, cannot support any additional open files at the moment. (This problem cannot happen on GNU/Hurd systems.) ‘ENOENT’ The named file does not exist, and ‘O_CREAT’ is not specified. ‘ENOSPC’ The directory or file system that would contain the new file cannot be extended, because there is no disk space left. ‘ENXIO’ ‘O_NONBLOCK’ and ‘O_WRONLY’ are both set in the FLAGS argument, the file named by FILENAME is a FIFO (*note Pipes and FIFOs::), and no process has the file open for reading. ‘EROFS’ The file resides on a read-only file system and any of ‘O_WRONLY’, ‘O_RDWR’, and ‘O_TRUNC’ are set in the FLAGS argument, or ‘O_CREAT’ is set and the file does not already exist. If on a 32 bit machine the sources are translated with ‘_FILE_OFFSET_BITS == 64’ the function ‘open’ returns a file descriptor opened in the large file mode which enables the file handling functions to use files up to 2^63 bytes in size and offset from −2^63 to 2^63. This happens transparently for the user since all of the low-level file handling functions are equally replaced. 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 ‘open’ is called. If the thread gets canceled these resources stay allocated until the program ends. To avoid this calls to ‘open’ should be protected using cancellation handlers. The ‘open’ function is the underlying primitive for the ‘fopen’ and ‘freopen’ functions, that create streams. -- Function: int open64 (const char *FILENAME, int FLAGS[, mode_t MODE]) Preliminary: | MT-Safe | AS-Safe | AC-Safe fd | *Note POSIX Safety Concepts::. This function is similar to ‘open’. It returns a file descriptor which can be used to access the file named by FILENAME. The only difference is that on 32 bit systems the file is opened in the large file mode. I.e., file length and file offsets can exceed 31 bits. When the sources are translated with ‘_FILE_OFFSET_BITS == 64’ this function is actually available under the name ‘open’. I.e., the new, extended API using 64 bit file sizes and offsets transparently replaces the old API. -- Obsolete function: int creat (const char *FILENAME, mode_t MODE) Preliminary: | MT-Safe | AS-Safe | AC-Safe fd | *Note POSIX Safety Concepts::. This function is obsolete. The call: creat (FILENAME, MODE) is equivalent to: open (FILENAME, O_WRONLY | O_CREAT | O_TRUNC, MODE) If on a 32 bit machine the sources are translated with ‘_FILE_OFFSET_BITS == 64’ the function ‘creat’ returns a file descriptor opened in the large file mode which enables the file handling functions to use files up to 2^63 in size and offset from −2^63 to 2^63. This happens transparently for the user since all of the low-level file handling functions are equally replaced. -- Obsolete function: int creat64 (const char *FILENAME, mode_t MODE) Preliminary: | MT-Safe | AS-Safe | AC-Safe fd | *Note POSIX Safety Concepts::. This function is similar to ‘creat’. It returns a file descriptor which can be used to access the file named by FILENAME. The only difference is that on 32 bit systems the file is opened in the large file mode. I.e., file length and file offsets can exceed 31 bits. To use this file descriptor one must not use the normal operations but instead the counterparts named ‘*64’, e.g., ‘read64’. When the sources are translated with ‘_FILE_OFFSET_BITS == 64’ this function is actually available under the name ‘open’. I.e., the new, extended API using 64 bit file sizes and offsets transparently replaces the old API. -- Function: int close (int FILEDES) Preliminary: | MT-Safe | AS-Safe | AC-Safe fd | *Note POSIX Safety Concepts::. The function ‘close’ closes the file descriptor FILEDES. Closing a file has the following consequences: • The file descriptor is deallocated. • Any record locks owned by the process on the file are unlocked. • When all file descriptors associated with a pipe or FIFO have been closed, any unread data is discarded. 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 ‘close’ is called. If the thread gets canceled these resources stay allocated until the program ends. To avoid this, calls to ‘close’ should be protected using cancellation handlers. The normal return value from ‘close’ 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. ‘EINTR’ The ‘close’ call was interrupted by a signal. *Note Interrupted Primitives::. Here is an example of how to handle ‘EINTR’ properly: TEMP_FAILURE_RETRY (close (desc)); ‘ENOSPC’ ‘EIO’ ‘EDQUOT’ When the file is accessed by NFS, these errors from ‘write’ can sometimes not be detected until ‘close’. *Note I/O Primitives::, for details on their meaning. Please note that there is _no_ separate ‘close64’ function. This is not necessary since this function does not determine nor depend on the mode of the file. The kernel which performs the ‘close’ operation knows which mode the descriptor is used for and can handle this situation. To close a stream, call ‘fclose’ (*note Closing Streams::) instead of trying to close its underlying file descriptor with ‘close’. This flushes any buffered output and updates the stream object to indicate that it is closed. -- Function: int close_range (unsigned int LOWFD, unsigned int MAXFD, int FLAGS) Preliminary: | MT-Safe | AS-Safe | AC-Safe fd | *Note POSIX Safety Concepts::. The function ‘close_range’ closes the file descriptor from LOWFD to MAXFD (inclusive). This function is similar to call ‘close’ in specified file descriptor range depending on the FLAGS. This is function is only supported on recent Linux versions and the GNU C Library does not provide any fallback (the application will need to handle possible ‘ENOSYS’). The FLAGS add options on how the files are closes. Linux currently supports: ‘CLOSE_RANGE_UNSHARE’ Unshare the file descriptor table before closing file descriptors. ‘CLOSE_RANGE_CLOEXEC’ Set the ‘FD_CLOEXEC’ bit instead of closing the file descriptor. The normal return value from ‘close_range’ is 0; a value of -1 is returned in case of failure. The following ‘errno’ error conditions are defined for this function: ‘EINVAL’ The LOWFD value is larger than MAXFD or an unsupported FLAGS is used. ‘ENOMEM’ Either there is not enough memory for the operation, or the process is out of address space. It can only happnes when ‘CLOSE_RANGE_UNSHARED’ flag is used. ‘EMFILE’ The process has too many files open and it can only happens when ‘CLOSE_RANGE_UNSHARED’ flag is used. The maximum number of file descriptors is controlled by the ‘RLIMIT_NOFILE’ resource limit; *note Limits on Resources::. ‘ENOSYS’ The kernel does not implement the required functionality. -- Function: void closefrom (int LOWFD) Preliminary: | MT-Safe | AS-Safe | AC-Safe fd | *Note POSIX Safety Concepts::. The function ‘closefrom’ closes all file descriptors greater than or equal to LOWFD. This function is similar to calling ‘close’ for all open file descriptors not less than LOWFD. Already closed file descriptors are ignored.  File: libc.info, Node: I/O Primitives, Next: File Position Primitive, Prev: Opening and Closing Files, Up: Low-Level I/O 13.2 Input and Output Primitives ================================ This section describes the functions for performing primitive input and output operations on file descriptors: ‘read’, ‘write’, and ‘lseek’. These functions are declared in the header file ‘unistd.h’. -- Data Type: ssize_t This data type is used to represent the sizes of blocks that can be read or written in a single operation. It is similar to ‘size_t’, but must be a signed type. -- Function: ssize_t read (int FILEDES, void *BUFFER, size_t SIZE) Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety Concepts::. The ‘read’ function reads up to SIZE bytes from the file with descriptor FILEDES, storing the results in the BUFFER. (This is not necessarily a character string, and no terminating null character is added.) The return value is the number of bytes actually read. This might be less than SIZE; for example, if there aren’t that many bytes left in the file or if there aren’t that many bytes immediately available. The exact behavior depends on what kind of file it is. Note that reading less than SIZE bytes is not an error. A value of zero indicates end-of-file (except if the value of the SIZE argument is also zero). This is not considered an error. If you keep calling ‘read’ while at end-of-file, it will keep returning zero and doing nothing else. If ‘read’ returns at least one character, there is no way you can tell whether end-of-file was reached. But if you did reach the end, the next read will return zero. In case of an error, ‘read’ returns -1. The following ‘errno’ error conditions are defined for this function: ‘EAGAIN’ Normally, when no input is immediately available, ‘read’ waits for some input. But if the ‘O_NONBLOCK’ flag is set for the file (*note File Status Flags::), ‘read’ returns immediately without reading any data, and reports this error. *Compatibility Note:* Most versions of BSD Unix use a different error code for this: ‘EWOULDBLOCK’. In the GNU C Library, ‘EWOULDBLOCK’ is an alias for ‘EAGAIN’, so it doesn’t matter which name you use. On some systems, reading a large amount of data from a character special file can also fail with ‘EAGAIN’ if the kernel cannot find enough physical memory to lock down the user’s pages. This is limited to devices that transfer with direct memory access into the user’s memory, which means it does not include terminals, since they always use separate buffers inside the kernel. This problem never happens on GNU/Hurd systems. Any condition that could result in ‘EAGAIN’ can instead result in a successful ‘read’ which returns fewer bytes than requested. Calling ‘read’ again immediately would result in ‘EAGAIN’. ‘EBADF’ The FILEDES argument is not a valid file descriptor, or is not open for reading. ‘EINTR’ ‘read’ was interrupted by a signal while it was waiting for input. *Note Interrupted Primitives::. A signal will not necessarily cause ‘read’ to return ‘EINTR’; it may instead result in a successful ‘read’ which returns fewer bytes than requested. ‘EIO’ For many devices, and for disk files, this error code indicates a hardware error. ‘EIO’ also occurs when a background process tries to read from the controlling terminal, and the normal action of stopping the process by sending it a ‘SIGTTIN’ signal isn’t working. This might happen if the signal is being blocked or ignored, or because the process group is orphaned. *Note Job Control::, for more information about job control, and *note Signal Handling::, for information about signals. ‘EINVAL’ In some systems, when reading from a character or block device, position and size offsets must be aligned to a particular block size. This error indicates that the offsets were not properly aligned. Please note that there is no function named ‘read64’. This is not necessary since this function does not directly modify or handle the possibly wide file offset. Since the kernel handles this state internally, the ‘read’ function can be used for all cases. 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 ‘read’ is called. If the thread gets canceled these resources stay allocated until the program ends. To avoid this, calls to ‘read’ should be protected using cancellation handlers. The ‘read’ function is the underlying primitive for all of the functions that read from streams, such as ‘fgetc’. -- Function: ssize_t pread (int FILEDES, void *BUFFER, size_t SIZE, off_t OFFSET) Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety Concepts::. The ‘pread’ function is similar to the ‘read’ function. The first three arguments are identical, and the return values and error codes also correspond. The difference is the fourth argument and its handling. The data block is not read from the current position of the file descriptor ‘filedes’. Instead the data is read from the file starting at position OFFSET. The position of the file descriptor itself is not affected by the operation. The value is the same as before the call. When the source file is compiled with ‘_FILE_OFFSET_BITS == 64’ the ‘pread’ function is in fact ‘pread64’ and the type ‘off_t’ has 64 bits, which makes it possible to handle files up to 2^63 bytes in length. The return value of ‘pread’ describes the number of bytes read. In the error case it returns -1 like ‘read’ does and the error codes are also the same, with these additions: ‘EINVAL’ The value given for OFFSET is negative and therefore illegal. ‘ESPIPE’ The file descriptor FILEDES is associated with a pipe or a FIFO and this device does not allow positioning of the file pointer. The function is an extension defined in the Unix Single Specification version 2. -- Function: ssize_t pread64 (int FILEDES, void *BUFFER, size_t SIZE, off64_t OFFSET) Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety Concepts::. This function is similar to the ‘pread’ function. The difference is that the OFFSET parameter is of type ‘off64_t’ instead of ‘off_t’ which makes it possible on 32 bit machines to address files larger than 2^31 bytes and up to 2^63 bytes. The file descriptor ‘filedes’ must be opened using ‘open64’ since otherwise the large offsets possible with ‘off64_t’ will lead to errors with a descriptor in small file mode. When the source file is compiled with ‘_FILE_OFFSET_BITS == 64’ on a 32 bit machine this function is actually available under the name ‘pread’ and so transparently replaces the 32 bit interface. -- Function: ssize_t write (int FILEDES, const void *BUFFER, size_t SIZE) Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety Concepts::. The ‘write’ function writes up to SIZE bytes from BUFFER to the file with descriptor FILEDES. The data in BUFFER is not necessarily a character string and a null character is output like any other character. The return value is the number of bytes actually written. This may be SIZE, but can always be smaller. Your program should always call ‘write’ in a loop, iterating until all the data is written. Once ‘write’ returns, the data is enqueued to be written and can be read back right away, but it is not necessarily written out to permanent storage immediately. You can use ‘fsync’ when you need to be sure your data has been permanently stored before continuing. (It is more efficient for the system to batch up consecutive writes and do them all at once when convenient. Normally they will always be written to disk within a minute or less.) Modern systems provide another function ‘fdatasync’ which guarantees integrity only for the file data and is therefore faster. You can use the ‘O_FSYNC’ open mode to make ‘write’ always store the data to disk before returning; *note Operating Modes::. In the case of an error, ‘write’ returns -1. The following ‘errno’ error conditions are defined for this function: ‘EAGAIN’ Normally, ‘write’ blocks until the write operation is complete. But if the ‘O_NONBLOCK’ flag is set for the file (*note Control Operations::), it returns immediately without writing any data and reports this error. An example of a situation that might cause the process to block on output is writing to a terminal device that supports flow control, where output has been suspended by receipt of a STOP character. *Compatibility Note:* Most versions of BSD Unix use a different error code for this: ‘EWOULDBLOCK’. In the GNU C Library, ‘EWOULDBLOCK’ is an alias for ‘EAGAIN’, so it doesn’t matter which name you use. On some systems, writing a large amount of data from a character special file can also fail with ‘EAGAIN’ if the kernel cannot find enough physical memory to lock down the user’s pages. This is limited to devices that transfer with direct memory access into the user’s memory, which means it does not include terminals, since they always use separate buffers inside the kernel. This problem does not arise on GNU/Hurd systems. ‘EBADF’ The FILEDES argument is not a valid file descriptor, or is not open for writing. ‘EFBIG’ The size of the file would become larger than the implementation can support. ‘EINTR’ The ‘write’ operation was interrupted by a signal while it was blocked waiting for completion. A signal will not necessarily cause ‘write’ to return ‘EINTR’; it may instead result in a successful ‘write’ which writes fewer bytes than requested. *Note Interrupted Primitives::. ‘EIO’ For many devices, and for disk files, this error code indicates a hardware error. ‘ENOSPC’ The device containing the file is full. ‘EPIPE’ This error is returned when you try to write to a pipe or FIFO that isn’t open for reading by any process. When this happens, a ‘SIGPIPE’ signal is also sent to the process; see *note Signal Handling::. ‘EINVAL’ In some systems, when writing to a character or block device, position and size offsets must be aligned to a particular block size. This error indicates that the offsets were not properly aligned. Unless you have arranged to prevent ‘EINTR’ failures, you should check ‘errno’ after each failing call to ‘write’, and if the error was ‘EINTR’, you should simply repeat the call. *Note Interrupted Primitives::. The easy way to do this is with the macro ‘TEMP_FAILURE_RETRY’, as follows: nbytes = TEMP_FAILURE_RETRY (write (desc, buffer, count)); Please note that there is no function named ‘write64’. This is not necessary since this function does not directly modify or handle the possibly wide file offset. Since the kernel handles this state internally the ‘write’ function can be used for all cases. 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 ‘write’ is called. If the thread gets canceled these resources stay allocated until the program ends. To avoid this, calls to ‘write’ should be protected using cancellation handlers. The ‘write’ function is the underlying primitive for all of the functions that write to streams, such as ‘fputc’. -- Function: ssize_t pwrite (int FILEDES, const void *BUFFER, size_t SIZE, off_t OFFSET) Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety Concepts::. The ‘pwrite’ function is similar to the ‘write’ function. The first three arguments are identical, and the return values and error codes also correspond. The difference is the fourth argument and its handling. The data block is not written to the current position of the file descriptor ‘filedes’. Instead the data is written to the file starting at position OFFSET. The position of the file descriptor itself is not affected by the operation. The value is the same as before the call. However, on Linux, if a file is opened with ‘O_APPEND’, ‘pwrite’ appends data to the end of the file, regardless of the value of ‘offset’. When the source file is compiled with ‘_FILE_OFFSET_BITS == 64’ the ‘pwrite’ function is in fact ‘pwrite64’ and the type ‘off_t’ has 64 bits, which makes it possible to handle files up to 2^63 bytes in length. The return value of ‘pwrite’ describes the number of written bytes. In the error case it returns -1 like ‘write’ does and the error codes are also the same, with these additions: ‘EINVAL’ The value given for OFFSET is negative and therefore illegal. ‘ESPIPE’ The file descriptor FILEDES is associated with a pipe or a FIFO and this device does not allow positioning of the file pointer. The function is an extension defined in the Unix Single Specification version 2. -- Function: ssize_t pwrite64 (int FILEDES, const void *BUFFER, size_t SIZE, off64_t OFFSET) Preliminary: | MT-Safe | AS-Safe | AC-Safe | *Note POSIX Safety Concepts::. This function is similar to the ‘pwrite’ function. The difference is that the OFFSET parameter is of type ‘off64_t’ instead of ‘off_t’ which makes it possible on 32 bit machines to address files larger than 2^31 bytes and up to 2^63 bytes. The file descriptor ‘filedes’ must be opened using ‘open64’ since otherwise the large offsets possible with ‘off64_t’ will lead to errors with a descriptor in small file mode. When the source file is compiled using ‘_FILE_OFFSET_BITS == 64’ on a 32 bit machine this function is actually available under the name ‘pwrite’ and so transparently replaces the 32 bit interface.