Gnulib Module List

This is a list of the modules which make up gnulib, with dependencies.

Support for obsolete systems lacking ANSI C 89

stdlib	A GNU-like <stdlib.h>.
strtol	strtol function: convert string to `long`.
strtoul	strtoul function: convert string to `unsigned long`.
memcmp	memcmp function: compare memory areas.
memcpy	memcpy function: copy memory area.
memmove	memmove function: copy memory area.
memset	memset function: fill memory with a constant byte.
strcspn	strcspn function: search a string for any of a set of characters.
strpbrk	strpbrk function: search a string for any of a set of characters.

These modules are not listed among dependencies below, for simplicity. If your package requires portability to old, obsolete systems, you need to list these modules explicitly among the modules to import through gnulib-tool.

Support for systems lacking ANSI C 89

atexit	atexit function: register a function to be called at program termination.
ctime	ctime function: convert time to string.
localtime	localtime function: convert time to broken-down local time.
strtod	strtod function: convert string to `double`.
strerror	strerror function: return string describing error code.
strerror-override	strerror_override function: provide strings for gnulib-specific errno values
mktime	mktime function: convert broken-down time to linear time.

Enhancements for ANSI C 89 functions

Diagnostics <assert.h>

assert	Allow the installer to disable assertions through "configure --disable-assert".
assure	Run-time assert-like macros.
verify	Compile-time assert-like macros.

Mathematics <math.h>

fpieee

Ensure IEEE compliant floating-point operations (overflow and division by zero).

Input/output <stdio.h>

fflush	Discard pending data on both input and output streams.
fseterr	Set the error indicator of a stream.
tmpfile	tmpfile function: create a temporary file.

Memory management functions <stdlib.h>

calloc-gnu	calloc function that is glibc compatible.
eealloc	Memory allocation with expensive empty allocations (glibc compatible).
free-posix	Work around systems where free clobbers errno.
malloc-gnu	malloc function that is glibc compatible.
memalign	Allocate memory with indefinite extent and specified alignment.
realloc-gnu	realloc function that is glibc compatible.
reallocarray	reallocarray function that is glibc compatible.
pagealign_alloc	Memory allocation aligned on page boundaries.

Sorting functions <stdlib.h>

array-mergesort	Merge-sort algorithm on arrays.
mpsort	Sort a vector of pointers to data.
qsort_r	Reentrant sort function with GNU signature

Date and time <time.h>

fprintftime	like nstrftime, but output the formatted date to a FILE* stream
nstrftime	nstrftime function: convert date and time to string, with GNU extensions.
strftime-fixes	strftime function: convert broken-down time to string.
time	time function: return current time.
time-h	A more-standard <time.h>.
time_rz	Reentrant time zone functions: localtime_rz, mktime_z, etc.
year2038	Attempt to ensure that `time_t` can go past the year 2038.
year2038-required	Ensure that `time_t` can go past the year 2038.

Extra functions based on ANSI C 89

Memory management functions <stdlib.h>

aligned-malloc	Allocate memory with indefinite extent and specified alignment.
ialloc	Memory allocation using idx_t instead of size_t
idx	A type for indices and sizes.
immutable	Immutable data.
malloc-h	A <malloc.h> that works around platform issues.
ssfmalloc	Simple and straight-forward malloc implementation (front end).
xsize	Checked size_t computations.
xalloc	Memory allocation with out-of-memory checking. Also see xalloc-die.
xalloc-die	Report a memory allocation failure and exit.
alignalloc	Aligned memory allocation
xalignalloc	Checked aligned memory allocation
alloca	Memory allocation on the stack.
alloca-opt	Memory allocation on the stack, as an optional optimization. It allows using the alloca macro if and only if the autoconf tests define HAVE_ALLOCA.
malloca	Safe automatic memory allocation.
xmalloca	Safe automatic memory allocation with out of memory checking.
xmemdup0	Copy a block of arbitrary bytes, and append a trailing NUL.
safe-alloc	A set of macros to make calls to alloc/calloc/realloc safer.

Integer arithmetic functions <stdlib.h>

count-leading-zeros	Counts the number of leading 0-bits in a word.
count-one-bits	Counts the number of 1-bits in a word.
count-trailing-zeros	Counts the number of trailing 0-bits in a word.
ffs	Finds the index of the least-significant set bit.
ffsl	Finds the index of the least-significant set bit.
ffsll	Finds the index of the least-significant set bit.
gcd	Greatest common divisor.
minmax	MIN, MAX macros.

Environment variables <stdlib.h>

putenv	putenv function: change or add an environment variable.
secure_getenv	Look up an environment variable, returning 0 in insecure situations.
setenv	setenv function: set an environment variable.
unsetenv	unsetenv function: remove an environment variable.
xsetenv	xsetenv function: set an environment variable, with out-of-memory checking. unsetenv function: remove an environment variable.

Character handling <ctype.h>

c-ctype

Character handling in C locale.

String handling <string.h>

bcopy	Old BSD bcopy function: copy memory area.
explicit_bzero	Erase sensitive data from a buffer.
memchr	memchr function: scan memory for a byte.
memchr2	memchr2 function: scan memory for the first of two bytes.
memcmp2	Compare two memory areas with possibly different lengths.
memmem	memmem function: efficiently locate first substring in a buffer.
memmem-simple	memmem function: locate first substring in a buffer.
mempcpy	mempcpy function: copy memory area, return pointer after last written byte.
memrchr	memrchr function: scan memory for a byte, from the right end.
amemxfrm	Locale dependent memory area transformation for comparison.
rawmemchr	rawmemchr function: Find the first occurrence of C in S.
stpcpy	stpcpy function: copy a string, returning a pointer to its end.
stpncpy	stpncpy function: copy a size-bounded string, returning a pointer to its end.
c-strcase	Case-insensitive string comparison functions in C locale.
strcase	Case-insensitive string comparison functions.
c-strcaseeq	Optimized case-insensitive string comparison in C locale.
c-strcasestr	Efficient case-insensitive searching in a string in C locale.
strcasestr	strcasestr function: efficient case-insensitive search for unibyte substring.
strcasestr-simple	strcasestr function: case-insensitive search for unibyte substring.
strchrnul	strchrnul function: Find the first occurrence of C in S or the final NUL byte.
streq	Optimized string comparison.
strerrorname_np	strerrorname_np function: name of system error code.
strerror_r-posix	strerror_r function: get string describing error code.
string-buffer	A buffer that accumulates a string by piecewise concatenation.
strnlen	strnlen function: determine the length of a size-bounded string.
strnlen1	Quick string length estimation.
strndup	strndup function: duplicate a size-bounded string.
strsep	strsep function: extract token from string.
strstr	strstr function: efficiently locate first substring in a buffer.
strstr-simple	strstr function: locate first substring in a buffer.
c-strstr	Search for a substring in a string in C locale.
astrxfrm	Locale dependent string transformation for comparison.
trim	trim function: remove leading and/or trailing whitespaces
fstrcmp	Fuzzy string comparison.
xstrndup	Duplicate a bounded initial segment of a string, with out-of-memory checking.

Mathematics <math.h>

printf-frexp

printf_frexp function: split a double into fraction and mantissa, for hexadecimal printf, without requiring libm.

Numeric conversion functions <stdlib.h>

c-strtod	Convert string to double in C locale.
c-strtold	Convert string to long double in C locale.
xstrtod	Convert string to `double`, with error checking.
xstrtol	Convert string to `long` or `unsigned long`, with error checking.
xstrtol-error	Error reporting function for xstrto* functions.
xstrtoll	Convert string to `long long` or `unsigned long long`, with error checking.
xstrtold	Convert string to `long double`, with error checking.

Date and time <time.h>

mktime-internal	mktime_internal function: convert broken-down time to linear time.
parse-datetime	Convert a date/time string to linear time.
parse-datetime2	Convert a date/time string to linear time, with debugging.
timegm	Convert calendar time to simple time, inverse of mktime.
tzset	tzset function: initialize time conversion information.

Input/Output <stdio.h>

unlocked-io	Enable faster, non-thread-safe stdio functions if available, globally throughout the package.
unlocked-io-internal	Allow use of faster, non-thread-safe stdio functions if available, in specific modules.
fwriteerror	Detect write error on a stream.
vasnprintf	vsprintf with automatic memory allocation and bounded output size.
vasprintf	vsprintf with automatic memory allocation.
xprintf	a wrapper around printf that calls error upon ENOMEM or EILSEQ errors
xvasprintf	vasprintf and asprintf with out-of-memory checking. Also see xalloc-die.

Signal handling <signal.h>

fatal-signal	Emergency actions in case of a fatal signal.
raise	Send a signal to the executing process.
sigabbrev_np	sigabbrev_np function: abbreviated name of signals.
sigdescr_np	sigdescr_np function: English descriptions of signals.
strsignal	strsignal function: return string describing signal.

Wide-character string handling <wchar.h>

wmempcpy

wmempcpy function: copy wide character array, return pointer after last written wide character.

Command-line arguments

argmatch	Search for an exact or abbreviated match of a string in an array of strings.
argv-iter	iterate through argv or a --files0-from=-specified file
version-etc	Print --version and bug-reporting information in a consistent format.
version-etc-fsf	Copyright variable for FSF projects
long-options	Handle --help and --version options.

Container data structures

list	Abstract sequential list data type.
xlist	Abstract sequential list data type, with out-of-memory checking.
array-list	Sequential list data type implemented by an array.
carray-list	Sequential list data type implemented by a circular array.
linked-list	Sequential list data type implemented by a linked list.
avltree-list	Sequential list data type implemented by a binary tree.
rbtree-list	Sequential list data type implemented by a binary tree.
linkedhash-list	Sequential list data type implemented by a hash table with a linked list.
avltreehash-list	Sequential list data type implemented by a hash table with a binary tree.
rbtreehash-list	Sequential list data type implemented by a hash table with a binary tree.
sublist	Sequential list data type backed by another list.
xsublist	Sequential list data type backed by another list, with out-of-memory checking.
oset	Abstract ordered set data type.
xoset	Abstract ordered set data type, with out-of-memory checking.
array-oset	Ordered set data type implemented by an array.
avltree-oset	Ordered set data type implemented by a binary tree.
rbtree-oset	Ordered set data type implemented by a binary tree.
stack	Type-safe stack data type.

Cryptographic computations (low-level)

crypto/arcfour	ARCFOUR stream cipher implementation
crypto/arctwo	ARCTWO block cipher implementation
crypto/des	DES block cipher.
crypto/hmac-md5	Compute hashed message authentication codes with MD5.
crypto/hmac-sha1	Compute hashed message authentication codes with SHA1.
crypto/md2	Compute MD2 checksum.
crypto/md2-buffer	Compute MD2 checksum.
crypto/md4	Compute MD4 checksum.
crypto/md4-buffer	Compute MD4 checksum.
crypto/md5	Compute MD5 checksum.
crypto/md5-buffer	Compute MD5 checksum.
crypto/rijndael	Rijndael block cipher.
crypto/sha1	Compute SHA1 checksum.
crypto/sha1-buffer	Compute SHA1 checksum.
crypto/sha256	Compute SHA224 and SHA256 checksums.
crypto/sha256-buffer	Compute SHA224 and SHA256 checksums.
crypto/sha512	Compute SHA384 and SHA512 checksums.
crypto/sha512-buffer	Compute SHA384 and SHA512 checksums.
crypto/sm3	Compute SM3 checksums.
crypto/sm3-buffer	Compute SM3 checksums.

Cryptographic computations (high-level)

crypto/gc	Core files for generic crypto package
crypto/gc-arcfour	Generic crypto wrappers for ARCFOUR stream cipher.
crypto/gc-arctwo	Generic crypto wrappers for ARCTWO block cipher.
crypto/gc-camellia	Generic crypto wrappers for Camellia block cipher.
crypto/gc-des	Generic crypto wrappers for DES block cipher.
crypto/gc-hmac-md5	Generic crypto wrappers for HMAC-MD5 functions.
crypto/gc-hmac-sha1	Generic crypto wrappers for HMAC-SHA1 functions.
crypto/gc-md2	Generic crypto wrappers for MD2 functions.
crypto/gc-md4	Generic crypto wrappers for MD4 functions.
crypto/gc-md5	Generic crypto wrappers for MD5 functions.
crypto/gc-pbkdf2	Password-Based Key Derivation Function according to PKCS#5/RFC2898
crypto/gc-pbkdf2-sha1	Password-Based Key Derivation Function according to PKCS#5/RFC2898 with HMAC-SHA1
crypto/gc-random	Generic crypto random number functions.
crypto/gc-rijndael	Generic crypto wrappers for rijndael block cipher.
crypto/gc-sha1	Generic crypto wrappers for SHA-1 functions.
crypto/gc-sm3	Generic crypto wrappers for SM3 functions.

Compiler warning management

ignore-value

ignore a value to quiet a compiler warning

Misc

base32	Encode binary data using printable characters (base32).
base64	Encode binary data using printable characters (base64).
check-version	Check version string compatibility.
crc	Compute cyclic redundancy codes.
diffseq	Compute the difference between two sequences.
execinfo	A GNU-like <execinfo.h>.
getline	Read a line from a stream.
getdelim	Read character delimited data from a stream.
getnline	Read a line from a stream, with bounded memory allocation.
getndelim2	Read a line from a stream, stopping at one of 2 delimiters, with bounded memory allocation.
linebuffer	Read a line from a stream.
memxor	memxor function: binary exclusive or operation on two memory blocks
obstack	Memory allocation, optimized for stack-like allocation patterns.
obstack-printf	Formatted printing into an obstack.
obstack-printf-posix	POSIX formatted printing into an obstack.
hash-pjw	Compute a hash value for a NUL-terminated string.
hash-pjw-bare	Compute a hash value for a buffer of known size.
hash	Parameterizable hash table.
hamt	Persistent hash array mapped tries.
readline	Simple implementation of readline.
readtokens	Read tokens from a stream.
readtokens0	Read NUL-separated tokens from a stream.
stack	Type-safe stack data type.
strverscmp	Compare strings holding version numbers.
filevercmp	compare version strings and version-containing file names

Support for systems lacking ISO C 99

Core language properties

alignof	Determine alignment of types.
c99	Enable at least C99 if available.
flexmember	Flexible array member support
fpucw	Set the FPU control word, so as to allow correct `long double` computations.
func	Make sure __func__ is usable even on non-C99 platforms.
inline	Test for the `inline` keyword or equivalent and whether it is actually effective.
longlong	Define HAVE_LONG_LONG_INT if `long long int` works.
snippet/unused-parameter	A C macro for declaring that specific function parameters are not used.
va-args	Detect whether the preprocessor supports C99 variadic macros and __VA_ARGS__.
vararrays	Variable-length arrays
vla	Macros for dealing with variable length arrays.

Variable arguments <stdarg.h>

stdarg

An <stdarg.h> that conforms to C99.

Boolean type and values <stdbool.h>

stdbool

A bool that is like C23.

Basic types <stddef.h>

stddef

A <stddef.h> that works around platform issues.

Integer types and values <stdint.h>

size_max	Provide SIZE_MAX, for cases when the `stdint` module cannot be used.
stdint	A GNU-like <stdint.h>. It nearly conforms to C99 and to ISO/IEC TS 18661-1:2014. Assumes typical host with 8-bit bytes, two's complement representation, and no padding or trap representations, with int widths equal to 8, 16, 32, and 64 bits. {uint,int}_fast{8,16,32,64}_t may not correspond to the fastest types available on the system. Macros are used instead of typedefs.

Input/output <stdio.h>

stdio	A GNU-like <stdio.h>.
snprintf	snprintf function: print formatted output to a fixed length string
vsnprintf	vsnprintf function: print formatted output from an stdarg argument list to a fixed length string

Process control, Numeric conversion functions <stdlib.h>

_Exit	_Exit function: terminate current process.
atoll	atoll function: convert decimal string to `long long`.
strtoll	strtoll function: convert string to `long long`.
strtoull	strtoull function: convert string to `unsigned long long`.

Unibyte characters <ctype.h>

ctype

A <ctype.h> that conforms to C99.

Functions for greatest-width integer types <inttypes.h>

imaxabs	imaxabs function: absolute value of `intmax_t`.
imaxdiv	imaxdiv function: division of `intmax_t`.
inttypes	An <inttypes.h> that nearly conforms to C99.
strtoimax	strtoimax function: convert string to `intmax_t`.
strtoumax	strtoumax function: convert string to `uintmax_t`.

String handling <string.h>

strncat

strncat function: append part of a string to a string.

Extended multibyte and wide character utilities <wchar.h>

wchar	A <wchar.h> that works around platform issues. Note also the wchar-single module.
btowc	btowc function: convert unibyte character to wide character.
wctob	wctob function: convert wide character to unibyte character.
mbsinit	mbsinit function: test for initial conversion state.
mbrlen	mbrlen function: recognize multibyte character.
mbrtowc	mbrtowc function: convert multibyte character to wide character.
mbsrtowcs	mbsrtowcs function: convert string to wide string.
wcrtomb	wcrtomb function: convert wide character to multibyte character.
wcsrtombs	wcsrtombs function: convert wide string to string.

Wide character classification and mapping utilities <wctype.h>

wctype

wctype function: get descriptor for a wide character property.

Characteristics of floating types <float.h>

float

A correct <float.h>.

Mathematics <math.h>

acos	acos function: inverse cosine function.
acosl	acosl function: inverse cosine function with long double argument.
asin	asin function: inverse sine function.
asinl	asinl function: inverse sine function with long double argument.
atan	atan function: inverse tangent function.
atan2	atan2 function: angle of a point in the plane.
atanl	atanl function: inverse tangent function with long double argument.
cbrt	cbrt function: cube root.
ceil	ceil function: round towards positive infinity.
ceilf	ceilf function: round towards positive infinity.
ceill	ceill function: round towards positive infinity.
copysign	copysign function: copy sign into another `double` number.
cos	cos function: cosine function.
cosh	cosh function: hyperbolic cosine function.
cosl	cosl function: cosine function with long double argument.
erf	erf function: error function.
erfc	erfc function: complementary error function.
exp	exp function: exponential function.
expl	expl function: exponential function with long double argument.
fabs	fabs function: absolute value.
floor	floor function: round towards negative infinity.
floorf	floorf function: round towards negative infinity.
floorl	floorl function: round towards negative infinity.
fmod	fmod function: floating-point remainder function.
frexp	frexp function: split a double into its constituents.
frexp-nolibm	frexp function: split a double into its constituents, without requiring libm.
frexpl	frexpl function: split a `long double` into its constituents.
frexpl-nolibm	frexpl function: split a `long double` into its constituents, without requiring libm.
hypot	hypot function: length of a vector in the plane.
isfinite	isfinite macro: test for finite value (zero, subnormal, or normal, and not infinite or NaN).
isinf	isinf macro: test for positive or negative infinity
isnan	isnan macro: test for NaN value.
isnanf	isnanf function: test for NaN.
isnanf-nolibm	isnanf function: test for NaN, without requiring libm.
isnand	isnand function: test for NaN.
isnand-nolibm	isnand function: test for NaN, without requiring libm.
isnanl	isnanl function: test for NaN.
isnanl-nolibm	isnanl function: test for NaN, without requiring libm.
j0	j0 function: Bessel function of the first kind of order 0.
j1	j1 function: Bessel function of the first kind of order 1.
jn	jn function: Bessel function of the first kind of order n.
ldexp	ldexp function: multiply a `double` by a power of 2.
ldexpl	ldexpl function: multiply a `long double` by a power of 2.
lgamma	lgamma function: log of gamma function.
log	log function: natural logarithmic function.
log10	log10 function: base 10 logarithmic function.
log1p	log1p function: natural logarithm of 1 plus argument.
logb	logb function: get exponent.
logl	logl function: logarithm with long double argument.
math	A GNU-like <math.h>.
mathl	C99 functions for transcendental functions with long double arguments.
modf	modf function: get signed integer and fractional parts.
nextafter	nextafter function: next representable `double` number.
pow	pow function: power function.
remainder	remainder function: floating-point remainder function.
rint	rint function: round according to the current rounding mode.
round	round function: round toward nearest, breaking ties away from zero.
roundf	roundf function: round toward nearest, breaking ties away from zero.
roundl	roundl function: round toward nearest, breaking ties away from zero.
signbit	signbit macro: Determine the sign bit of a floating-point number.
sin	sin function: sine function.
sinh	sinh function: hyperbolic sine function.
sinl	sinl function: sine function with long double argument.
sqrt	sqrt function: square root.
sqrtl	sqrtl function: square root with long double argument.
tan	tan function: tangent function.
tanh	tanh function: hyperbolic tangent function.
tanl	tanl function: tangent function with long double argument.
trunc	trunc function: round towards zero.
truncf	truncf function: round towards zero.
truncl	truncl function: round towards zero.
y0	y0 function: Bessel function of the second kind of order 0.
y1	y1 function: Bessel function of the second kind of order 1.
yn	yn function: Bessel function of the second kind of order n.

Enhancements for ISO C 99 functions

Input/output <stdio.h>

printf-safe Ensures that the *printf functions provided by the *printf-posix modules recognize non-IEEE-754 values of long double arguments and display them as NaN (rather than producing undefined behavior).

Extra functions based on ISO C 99

Mathematics <math.h>

printf-frexpl

printf_frexpl function: split a long double into fraction and mantissa, for hexadecimal printf, without requiring libm.

Numeric conversion functions <stdlib.h>

c-dtoastr	Convert double to accurate string in C locale.
c-ldtoastr	Convert long double to accurate string in C locale.
dtoastr	Convert double to accurate string.
ftoastr	Convert float to accurate string.
intprops	Properties of integer types
inttostr	Convert integers to printable strings.
ldtoastr	Convert long double to accurate string.
xstrtoimax	Convert string to `intmax_t`, with error checking.
xstrtoumax	Convert string to `uintmax_t`, with error checking.

Extended multibyte and wide character utilities <wchar.h>

mbchar	Multibyte character data type.
mbiter	Iterating through multibyte strings.
mbuiter	Iterating through multibyte strings.
mbfile	Multibyte character I/O.

Support for systems lacking ISO C 11

Core language properties

noreturn	Macros for declaring functions as non-returning.
std-gnu11	Prefer GNU C11 and C++11 to earlier versions.
stdalign	alignas and alignof that are like C23 and C++11.

Support for standard extensions to ISO C 11

attribute	C/C++ attributes
builtin-expect	Check for __builtin_expect.
ieee754-h	An <ieee754.h> that is like GNU.
limits-h	A GNU-like <limits.h>.

Support for systems lacking draft ISO C 23

Core language properties

alignasof	alignas and alignof that are like C23 and C++11.
nullptr	A nullptr that is like C23.
stdckdint	An <stdckdint.h> that is like C23.

timespec_get	timespec_get function: return the current time with up to nanosecond resolution
timespec_getres	timespec_getres: return the timestamp resolution

accept	accept function: accept a connection to a server socket.
alphasort	alphasort function: compare entries of a directory alphabetically
arpa_inet	A GNU-like <arpa/inet.h>.
bind	bind function: bind a server socket to a port.
calloc-posix	calloc function: allocate memory with indefinite extent.
chmod	chmod function: change the permissions of a file
chmodat	chmodat and lchmodat functions: Change access permissions of a file at a directory.
chown	chown function: change ownership of a file, following symlinks.
chownat	chownat and lchownat functions: Change owner of a file at a directory.
close	close function: close a file or socket.
connect	connect function: connect a client socket.
dirent	A GNU-like <dirent.h>.
dprintf	dprintf function: print formatted output to a file descriptor
dprintf-posix	POSIX compatible dprintf function: print formatted output to a file descriptor
dup2	dup2 function: duplicate an open file descriptor.
duplocale	duplocale function: duplicate a locale object.
environ	environ variable: storage of environment variables.
errno	A POSIX-like <errno.h>.
execl	execl function: Execute a program, replacing the current process.
execle	execle function: Execute a program, replacing the current process.
execlp	execlp function: Execute a program, replacing the current process.
execv	execv function: Execute a program, replacing the current process.
execve	execve function: Execute a program, replacing the current process.
execvp	execvp function: Execute a program, replacing the current process.
execvpe	execvpe function: Execute a program, replacing the current process.
fchdir	fchdir function: change current directory, given an open file descriptor.
fclose	fclose function: close a stream.
fcntl-h	Like <fcntl.h>, but with non-working flags defined to 0.
fcntl	Support for the fcntl function, actions F_DUPFD, F_DUPFD_CLOEXEC, F_GETFD.
fdatasync	fdatasync(2) function: synchronize writes to a file.
flock	flock(2) function: advisory file locks.
fopen	fopen function: open a stream to a file.
fprintf-posix	POSIX compatible fprintf function: print formatted output to a stream
freopen	freopen function: open a stream to a file.
fseek	fseek function: Reposition a FILE stream.
fseeko	fseeko function: Reposition a FILE stream.
fsync	fsync(2) function: synchronize writes, including metadata, to a file.
ftell	ftell function: Retrieve the position of a FILE stream.
ftello	ftello function: Retrieve the position of a FILE stream.
ftruncate	ftruncate function: truncate an open file to a specified length.
futimens	Set file access and modification times of a file descriptor.
getaddrinfo	getaddrinfo function: Get address information.
getcwd	Return the current working directory.
getcwd-lgpl	Ensure getcwd(NULL, 0) returns a buffer allocated by the malloc function.
getgroups	getgroups function: return the supplementary group IDs of the current process.
gethostname	gethostname function: Return machine's hostname.
getlogin	getlogin function: Get user name.
getlogin_r	getlogin_r function: Get user name to a buffer allocated by the caller.
getopt-posix	getopt function: process command line arguments.
getpeername	getpeername function: return information about the remote end of a connected socket.
getsockname	getsockname function: return information about the local end of a connected socket.
getsockopt	getsockopt function: retrieve optional settings on a socket.
getsubopt	getsubopt: Parse comma separated list into words.
gettimeofday	gettimeofday function: return current time.
grantpt	grantpt function: Acquire ownership of the slave side of a pseudo-terminal.
hostent	Library containing gethostent function, sethostent function, endhostent function, gethostbyname function, gethostbyaddr function.
iconv-h	A GNU-like <iconv.h>.
iconv_open	Character set conversion.
inet_ntop	Convert internet address from internal to printable, presentable format.
inet_pton	Convert internet address from presentation to internal, binary, format.
ioctl	ioctl function: issue device specific requests on files, devices, or sockets.
isblank	isblank function: test whether a single-byte character is a blank.
langinfo	A GNU-like <langinfo.h>.
link	link function: create a new link for an existing file
linkat	linkat function: create a hard link, relative to two directories
listen	listen function: make a server socket ready for accepting connections.
locale	A <locale.h> that conforms to POSIX.
lseek	lseek function: Reposition a file descriptor.
lstat	lstat function: return information about a file or symbolic link.
malloc-posix	malloc function: allocate memory with indefinite extent.
mbsnrtowcs	mbsnrtowcs function: convert string to wide string.
mkdir	mkdir function: create a directory.
mkdtemp	mkdtemp function: create a private temporary directory.
mkfifo	mkfifo function: create named FIFO
mknod	mknod function: create various special devices
mkstemp	mkstemp function: create a private temporary file.
net_if	A <net/if.h> for systems lacking it.
netdb	A <netdb.h> for systems lacking it.
netinet_in	A <netinet/in.h> for systems lacking it.
nl_langinfo	nl_langinfo function: query locale dependent information.
open	open function: open a descriptor to a file.
perror	perror function: print a message describing error code.
poll	poll function: wait for some event on a set of file descriptors.
popen	popen function: open a stream to a shell command.
posix_memalign	Allocate memory with indefinite extent and specified alignment.
posix_openpt	posix_openpt function: Open the master side of a pseudo-terminal.
posix_spawn	posix_spawn function: create a child process.
posix_spawnattr_destroy	posix_spawnattr_destroy function: free a child process attributes specification.
posix_spawnattr_getflags	posix_spawnattr_getflags function: get bitmask of attributes specified for child process.
posix_spawnattr_getpgroup	posix_spawnattr_getpgroup function: get process group specified for child process.
posix_spawnattr_getschedparam	posix_spawnattr_getschedparam function: get the scheduling parameters specified for child process.
posix_spawnattr_getschedpolicy	posix_spawnattr_getschedpolicy function: get the scheduling policy specified for child process.
posix_spawnattr_getsigdefault	posix_spawnattr_getsigdefault function: get the set of signals with initially the default handler specified for child process.
posix_spawnattr_getsigmask	posix_spawnattr_getsigmask function: get the set of initially blocked signals specified for child process.
posix_spawnattr_init	posix_spawnattr_init function: initialize child process attributes specification.
posix_spawnattr_setflags	posix_spawnattr_setflags function: specify bitmask of attributes for child process.
posix_spawnattr_setpgroup	posix_spawnattr_setpgroup function: specify process group for child process.
posix_spawnattr_setschedparam	posix_spawnattr_setschedparam function: specify the scheduling parameters for child process.
posix_spawnattr_setschedpolicy	posix_spawnattr_setschedpolicy function: specify the scheduling policy for child process.
posix_spawnattr_setsigdefault	posix_spawnattr_setsigdefault function:get the specify of signals with initially the default handler for child process.
posix_spawnattr_setsigmask	posix_spawnattr_setsigmask function: specify the set of initially blocked signals for child process.
posix_spawn_file_actions_addclose	posix_spawn_file_actions_addclose function: augment a child process actions specification.
posix_spawn_file_actions_adddup2	posix_spawn_file_actions_adddup2 function: augment a child process actions specification.
posix_spawn_file_actions_addopen	posix_spawn_file_actions_addopen function: augment a child process actions specification.
posix_spawn_file_actions_destroy	posix_spawn_file_actions_destroy function: free a child process actions specification.
posix_spawn_file_actions_init	posix_spawn_file_actions_init function: initialize child process actions specification.
posix_spawn-internal	posix_spawn internals.
posix_spawnp	posix_spawnp function: create a child process.
pread	pread function: read without changing file offset
printf-posix	POSIX compatible printf function: print formatted output to standard output
pselect	pselect function: synchronous I/O multiplexing.
pthread	Implement the most essential subset of the pthreads library.
ptsname	ptsname function: Determine name of the slave side of a pseudo-terminal.
pwrite	pwrite function: write without changing file offset
readlink	readlink function: read the value of a symbolic link.
realloc-posix	realloc function: allocate memory with indefinite extent.
recv	recv function: receive (read) data from a connected socket.
recvfrom	recvfrom function: receive (read) data from a potentially unconnected socket.
remove	remove function: remove a file or directory
scandir	scandir function: collect entries of a directory
sched	A <sched.h> include file.
select	select function: synchronous I/O multiplexing.
send	send function: send (write) data to a connected socket.
sendto	sendto function: send (write) data to a potentially unconnected socket.
servent	Library containing getservent function, setservent function, endservent function, getservbyname function, getservbyport function, getprotoent function, setprotoent function, endprotoent function, getprotobyname function, getprotobynumber function.
setsockopt	setsockopt function: specify optional settings on a socket.
shutdown	shutdown function: initiate a graceful shutdown of a socket.
signal-h	A GNU-like <signal.h>.
sleep	sleep function: pause execution of the current thread.
snprintf-posix	POSIX compatible snprintf function: print formatted output to a fixed length string
socket	socket function: create a socket.
spawn	A POSIX compliant <spawn.h>.
sprintf-posix	POSIX compatible sprintf function: print formatted output to a string
stat	stat function: query file information
strdup-posix	strdup function: duplicate a string.
string	A GNU-like <string.h>.
strings	A substitute <strings.h>.
tempname	gen_tempname function and try_tempname function: create a private temporary file or directory.
time	time function: return current time.
time_r	Reentrant time functions: localtime_r, gmtime_r.
times	times function: get process times
timespec	timespec-related declarations
nanosleep	nanosleep function: pause execution for a specified time.
pthread_sigmask	POSIX compatible signal blocking for threads.
regex	Regular expression matching. This matches the current GNU C Library, so its interface differs from the standalone GNU regex library which has long been decommissioned in favor of the GNU C Library interface.
rename	rename function: change the name or location of a file.
renameat	renameat function: rename a file, relative to two directories
rmdir	rmdir function: delete a directory.
search	A GNU-like <search.h>.
sigaction	POSIX compatible signal handlers.
sigprocmask	POSIX compatible signal blocking.
socklen	Declare socklen_t in config.h if the system doesn't have it.
ssize_t	Define ssize_t if it does not already exist.
strptime	Convert a string representation of time to a tm structure.
strtok_r	strtok_r function: split string into tokens, thread safe.
sys_select	A <sys/select.h> for systems lacking it.
sys_socket	A POSIX-like <sys/socket.h>.
sys_stat	A <sys/stat.h> for systems with missing declarations.
sys_time	A <sys/time.h> that conforms better to POSIX.
sys_times	A <sys/times.h> for systems lacking it.
sys_uio	A POSIX-like <sys/uio.h>.
sys_utsname	A <sys/utsname.h> for systems which lack it.
sys_wait	A <sys/wait.h> for systems with missing declarations.
truncate	truncate function: truncate a file to a specified length.
tsearch	Binary tree data structure.
ttyname_r	ttyname_r function: Determine name of a terminal.
uname	uname function: enquire system information.
unistd	A GNU-like <unistd.h>.
unlink	unlink function: remove a file.
unlockpt	unlockpt function: Unlock the slave side of a pseudo-terminal from its master side.
utime	utime function: set access and modification times of a file.
utime-h	A <utime.h> that conforms to POSIX.
utimensat	Set file access and modification times of a file relative to a directory fd.
vasnprintf-posix	POSIX compatible vsprintf with automatic memory allocation and bounded output size.
vasprintf-posix	POSIX compatible vsprintf with automatic memory allocation.
vdprintf	vdprintf function: print formatted output to a file descriptor
vdprintf-posix	POSIX compatible vdprintf function: print formatted output to a file descriptor
vfprintf-posix	POSIX compatible vfprintf function: print formatted output to a stream
vprintf-posix	POSIX compatible vprintf function: print formatted output to standard output
vsnprintf-posix	POSIX compatible vsnprintf function: print formatted output to a fixed length string
vsprintf-posix	POSIX compatible vsprintf function: print formatted output to a string
wcsnrtombs	wcsnrtombs function: convert wide string to string.
wcwidth	Determine the number of screen columns needed for a character.
windows-spawn	Auxiliary functions for the creation of subprocesses on native Windows.
windows-stat-inodes	On native Windows platforms, ensure that `struct stat` contains values in the st_dev, st_ino fields that are able to distinguish different inodes.
windows-stat-override	On native Windows platforms, override `struct stat`.
windows-stat-timespec	On native Windows platforms, ensure that `struct stat` contains st_atim, st_mtim, st_ctim fields of type `struct timespec`, providing 100 ns resolution for the timestamps of files.
write	POSIX compatible write function: write data to a file descriptor

Compatibility checks for POSIX:2008 functions

clock-time	Check for clock_gettime and clock_settime.
d-ino	Check whether struct dirent has a member named d_ino.
d-type	Check whether struct dirent has a member named d_type.
eloop-threshold	Threshold for symbolic link loops and ELOOP
link-follow	Determine whether link("symlink", "foo") follows the symlink.
rmdir-errno	rmdir errno for nonempty directories
timer-time	Check for timer_settime. Within HAVE_TIMER_SETTIME one can assume timer_create, timer_delete and timer_gettime are available too.
unlink-busy	Test whether a running program can be unlinked.
winsz-ioctl	Test whether use of TIOCGWINSZ requires sys/ioctl.h.
winsz-termios	Test whether use of TIOCGWINSZ requires termios.h.

Enhancements for POSIX:2008 functions

chdir-long	chdir-like function that tries not to fail due to ENAMETOOLONG
basename-lgpl	Extract the last component (base name) of a file name.
dirent-safer	Directory functions that avoid clobbering STD{IN,OUT,ERR}_FILENO.
dirname	Extract specific portions of filenames.
dirname-lgpl	Extract specific portions of filenames.
getopt-gnu	GNU-like getopt function, getopt_long function, getopt_long_only function: process command line arguments.
iconv_open-utf	Character set conversion support for UTF-{16,32}{BE,LE} encodings.
unistd-safer	File descriptor functions that avoid clobbering STD{IN,OUT,ERR}_FILENO.
fnmatch	fnmatch function: wildcard matching.
fnmatch-gnu	fnmatch function: wildcard matching, with GNU extensions.
glob	glob function: Search for files and directories with paths matching a pattern, with GNU extensions.
exclude	Manage list of filenames or wildcard patterns for --exclude option processing.

Extra functions based on POSIX:2008

Input/output

xprintf-posix	A wrapper around printf with POSIX compatible format string interpretation, that calls error upon ENOMEM or EILSEQ errors.
xvasprintf-posix	vasprintf and asprintf with POSIX compatible format string interpretation and with out-of-memory checking. Also see xalloc-die.

Numeric conversion functions

human

Convert a number (usually a file size) to a human readable string, possibly with K/M/G suffix.

File system functions

acl	Access control lists of files, with diagnostics. (Unportable.)
acl-permissions	Access control lists of files. (Unportable.)
areadlink	Reading symbolic links without size limitation.
areadlink-with-size	Return the contents of a symbolic link, without size limitations.
areadlinkat	Reading symbolic links without size limitation, relative to fd.
areadlinkat-with-size	Read a symbolic link, without size limitations, relative to fd.
backupfile	Determine the name of a backup file.
backup-rename	Rename a file to a backup name.
canonicalize	Return the canonical absolute name of a given file.
canonicalize-lgpl	realpath, canonicalize_file_name: Provide canonical absolute file name
clean-temp	Temporary directories and temporary files with automatic cleanup.
clean-temp-simple	Temporary files with automatic cleanup.
concat-filename	Construct a full filename by concatenating a directory name, a relative filename, and a suffix.
copy-file	Copying of files.
fsusage	Return file system space usage info.
dirfd	Retrieving the file descriptor of an open directory stream. (Unportable.)
double-slash-root	Check whether // is distinct from /.
euidaccess	euidaccess function: check effective user's permissions for a file.
faccessat	faccessat function: check user's permissions for a file.
fdopendir	Open a directory stream from a file descriptor.
fdutimensat	Set file access and modification times, relative to a directory.
file-type	Return a string describing the type of a file.
fileblocks	Estimate number of blocks of a file, if `struct stat` doesn't have st_blocks.
filemode	Return a string (?rwxrwxrwx format) describing the type and permissions of a file.
filename	Basic filename support macros.
filenamecat	Concatenate two arbitrary file names.
filenamecat-lgpl	Concatenate two arbitrary file names.
fts	Traverse a file hierarchy.
isdir	Determine whether a directory exists.
largefile	Support for files 2 GiB and larger.
largefile-required	Require support for files 2 GiB and larger.
lchmod	lchmod that is actually chmod (!) on hosts lacking lchmod
lchown	lchown function: change ownership of a file, without following symlinks.
mkancesdirs	Ensure the existence of the ancestor directories of a file.
mkfifoat	mkfifoat function and mknodat function: create named FIFOs relative to a directory
mkdir-p	Ensure that a directory and its parents exist.
mkostemp	mkostemp function: create a private temporary file, with specific opening flags.
mkostemps	mkostemps function: create a private temporary file, with specific opening flags, and with suffix.
mkstemps	mkstemps function: create a private temporary file, with suffix
modechange	Manipulation of mode changes specified by strings (e.g. as first argument of chmod utility).
mountlist	Return list of mounted file systems.
openat	openat function: Open a file at a directory.
openat-die	Report a save- or restore-cwd failure in our openat replacement and then exit.
pathmax	Return maximum size of reasonable pathnames. (Unportable: Hurd has no limit.)
qacl	Access control lists of files. (Unportable.) This is a placeholder module for backwards compatibility. New programs should use either qcopy-acl or qset-acl or both.
qcopy-acl	Copy access control list from one file to another. (Unportable.)
qset-acl	Set access control list of a file by specifying a mode. (Unportable.)
read-file	read_file function: read the contents of a file into a string
readlinkat	readlinkat function: read symlinks relative to a directory
renameatu	renameatu function: rename a file, relative to two dirs, with unsigned flag
same	Determine whether two file names refer to the same directory entry of the same directory.
save-cwd	Save and restore the current working directory.
savedir	Return the entries of a directory (just the names) as an argz string.
savewd	Save and restore the working directory, possibly using a child process.
stat-macros	stat-related macros
stat-time	stat-related time functions
symlink	symlink function: create a symlink, if possible
symlinkat	symlinkat function: create symlinks relative to a directory
sys_file	<sys/file.h> for systems with an incomplete header.
sys_ioctl	A <sys/ioctl.h> for systems with missing declarations.
tmpdir	Determine a temporary directory.
unlinkdir	Determine whether we can unlink directories.
utimecmp	compare file timestamps
utimens	Set file access and modification times.
write-any-file	Determine whether we can write any file.
xconcat-filename	Construct a full filename by concatenating a directory name, a relative filename, and a suffix, with out-of-memory checking.
xgetcwd	Return the current working directory, without size limitations.
xreadlink	Reading symbolic links without size limitation.
xreadlinkat	Reading symbolic links without size limitation, relative to fd.

File system as inode set

cycle-check	help detect directory cycles efficiently
dev-ino	declare a simple (device, inode) struct
file-set	Very specialized set-of-files code.
hash-triple	Hash functions for file-related triples: name, device, inode.
i-ring	a simple ring buffer
same-inode	compare inodes

File descriptor based Input/Output

binary-io	Binary mode I/O.
copy-file-range	Copy parts of files
dup3	dup3 function: copy a file descriptor, applying specific flags.
fcntl-safer	File descriptor functions that avoid clobbering STD{IN,OUT,ERR}_FILENO.
fd-safer-flag	fd_safer_flag function: adjust a file descriptor result so that it avoids clobbering STD{IN,OUT,ERR}_FILENO, with specific flags.
full-read	An interface to the read function that reads all it is asked to read.
full-write	An interface to the write function that writes all it is asked to write.
getdtablesize	getdtablesize function: return tight upper bound for file descriptor values.
isapipe	Test whether a file descriptor is a pipe.
openat-safer	openat function that avoids clobbering std{in,out,err}.
pipe-posix	pipe function: Creation of a pipe.
pipe2	pipe2 function: create a pipe, with specific opening flags.
pipe2-safer	pipe2_safer function: create a pipe, with specific opening flags, without clobbering std{in,out,err}.
safe-read	An interface to the read function that retries after interrupts.
safe-write	An interface to the write function that retries after interrupts.

File stream based Input/Output

close-stream	Close a stream, with nicer error checking than fclose's.
closein	Close all standard streams, resetting seekable stdin if needed, and exiting with a diagnostic on error.
closeout	Close standard output and standard error, exiting with a diagnostic on error.
fbufmode	fbufmode function: Determine the buffering mode of a FILE stream.
fopen-gnu	fopen function: open a stream to a file, with GNU extensions.
fopen-safer	fopen function that avoids clobbering std{in,out,err}.
fpending	Determine the number of bytes waiting in the output buffer of a stream.
fpurge	fpurge function: Flush buffers.
freadable	freadable function: Determine whether a FILE stream supports reading.
freadahead	freadahead function: Determine the number of bytes waiting in the input buffer of a stream.
freading	freading function: Determine whether a FILE stream is currently doing reading.
freadptr	freadptr function: Pointer to the input buffer of a stream.
freadseek	freadseek function: Read and discard input from a stream.
freopen-safer	freopen function that avoids clobbering std{in,out,err}.
fwritable	fwritable function: Determine whether a FILE stream supports writing.
fwriting	fwriting function: Determine whether a FILE stream is currently doing writing.
getpass	getpass function: read a password from /dev/tty.
getpass-gnu	getpass function: read a password of arbitrary length from /dev/tty.
popen-safer	popen function that avoids clobbering std{in,out,err}.
supersede	Open a file, without destroying an old file with the same name.
stdlib-safer	File stream functions that avoid clobbering std{in,out,err}.
tmpfile-safer	tmpfile function that avoids clobbering std{in,out,err}.
xfreopen	Open a file, reusing a given stream, with error checking.

Users and groups

getugroups	Return the group IDs of a user.
group-member	Determine whether the current process has the permissions of a given group ID.
idcache	Username <--> uid and groupname <--> gid conversions, with cache for speed.
mgetgroups	Return the group IDs of a user or current process in malloc'd storage.
userspec	Parse a 'user:group' specifier (e.g. the first argument of chown utility).

Security

getumask	getumask function: retrieve the umask of the process (multithread-safe)
idpriv-drop	Drop uid/gid privileges of the current process.
idpriv-droptemp	Drop uid/gid privileges of the current process temporarily.
priv-set	Query, remove or restore a Solaris privilege

Date and time

gethrxtime	Get high resolution real time.
gettime	Return current time, with nanosecond resolution.
gettime-res	Return current time resolution
posixtm	Convert a date/time string (POSIX syntax) to linear time or broken-down time.
settime	Set the current time, with nanosecond resolution.
usleep	usleep function: pause execution of the current thread.
xnanosleep	A variant of nanosleep that takes a `double` argument and handles EINTR.

Networking functions

accept4	accept4 function: accept a connection on a socket, with specific opening flags.
xgethostname	Return machine's hostname, without size limitations.
canon-host	Canonicalize a host name: return a name other hosts can understand, i.e. usually the host name including FQDN.
sockets	General facilities for using sockets

Multithreading

threadlib	Access to multithreading primitives.
asyncsafe-spin	Spin locks for communication between threads and signal handlers.
lock	Locking in multithreaded situations.
simple-atomic	Simple atomic operations for multithreading.
tls	Thread-local storage in multithreaded situations.
thread	Creating and controlling threads.
yield	Yielding the processor to other threads.
cond	Condition variables for multithreading.
openmp	Detection of OpenMP support.

Signal handling

c-stack	Stack overflow handling, causing program exit.
libsigsegv	Handle page faults in user mode.
sig2str	Convert between signal names and signal numbers.
sigpipe	Emulation of POSIX compatible SIGPIPE behaviour.
sigpipe-die	Report a SIGPIPE signal and exit.
sigsegv	A simplified variant of GNU libsigsegv. It implements the most important features of GNU libsigsegv: catching SIGSEGV and catching stack overflow. It does not implement the `sigsegv_dispatcher` type (which is not multithread-safe). It supports all modern Unix-like platforms: Linux, Hurd, FreeBSD, NetBSD, OpenBSD, macOS, AIX, Solaris, Cygwin, Haiku, even IRIX. It does not support HP-UX, Minix, native Windows; on these platforms the module compiles and provides a <sigsegv.h> header file, but it does not define HAVE_SIGSEGV_RECOVERY and HAVE_STACK_OVERFLOW_RECOVERY. Unlike GNU libsigsegv, which consists of many .h and .c files, this module compiles to just two object files, rather than a library.

Terminal I/O

termcap	Information about terminal capabilities.
termcap-h	Information about terminal capabilities.
terminfo	Information about terminal capabilities.
terminfo-h	Information about terminal capabilities.

Internationalization functions

gettext	Translate messages to user's native language.
gettext-h	Translate messages to user's native language if GNU gettext is also used.
propername	Localization of proper names.
iconv	Character set conversion.
striconv	Character set conversion of strings made easy, uses iconv.
xstriconv	Character set conversion of strings made easy, uses iconv, with out-of-memory checking.
striconveh	Character set conversion of strings with error handling, uses iconv.
xstriconveh	Character set conversion of strings made easy, uses iconv, with out-of-memory checking.
striconveha	Character set conversion of strings with error handling and autodetection, uses iconv.
localcharset	Return current locale's character encoding.
hard-locale	Determine whether the current locale is different from the "C" locale.
localename	Return current locale's name, according to glibc naming conventions.
mbmemcasecmp	mbmemcasecmp function: case-insensitive memory area comparison.
mbmemcasecoll	mbmemcasecoll function: locale dependent case-insensitive memory area comparison.
mbslen	mbslen function: Determine the number of multibyte characters in a string.
mbsnlen	mbsnlen function: Determine the number of multibyte characters in a string.
mbschr	mbschr function: search a string for a character.
mbsrchr	mbsrchr function: search a string for a character, from the end.
mbsstr	mbsstr function: search for a substring in a string.
mbscasecmp	mbscasecmp function: case-insensitive string comparison.
mbsncasecmp	mbsncasecmp function: case-insensitive string prefix comparison.
mbspcasecmp	mbspcasecmp function: case-insensitive string prefix comparison.
mbscasestr	mbscasestr function: case-insensitive search for a substring in a string.
mbscspn	mbscspn function: search a string for any of a set of characters.
mbspbrk	mbspbrk function: search a string for any of a set of characters.
mbsspn	mbsspn function: search a string for any outside a set of characters.
mbssep	mbssep function: split string into tokens, thread safe.
mbstok_r	mbstok_r function: split string into tokens, thread safe.
mbswidth	Determine the number of screen columns needed for a string.
memcasecmp	Case-insensitive memory area comparison.
memcoll	Locale dependent memory area comparison.
xmemcoll	Locale dependent memory area comparison, with error checking.
unicodeio	Unicode character output to streams with locale dependent encoding.
rpmatch	Locale dependent classification of a response as matching "yes" or "no".
yesno	Read a response from the user, and its classification as matching "yes" or "no".
bison-i18n	Support for internationalization of bison-generated parsers.

Unicode string functions

libunistring	Unicode string functions.
libunistring-optional	Try to use system libunistring for Unicode string functions.
unitypes	Base types for Unicode string functions.
ucs4-utf8	Conversion UCS-4 to UTF-8.
ucs4-utf16	Conversion UCS-4 to UTF-16.
utf8-ucs4-unsafe	Conversion UTF-8 to UCS-4.
utf16-ucs4-unsafe	Conversion UTF-16 to UCS-4.
utf8-ucs4	Conversion UTF-8 to UCS-4.
utf16-ucs4	Conversion UTF-16 to UCS-4.
unistr/base	Base layer for elementary Unicode string functions.
unistr/u8-to-u16	Convert UTF-8 string to UTF-16 string.
unistr/u8-to-u32	Convert UTF-8 string to UTF-32 string.
unistr/u16-to-u8	Convert UTF-16 string to UTF-8 string.
unistr/u16-to-u32	Convert UTF-16 string to UTF-32 string.
unistr/u32-to-u8	Convert UTF-32 string to UTF-8 string.
unistr/u32-to-u16	Convert UTF-32 string to UTF-16 string.
unistr/u8-check	Check UTF-8 string.
unistr/u16-check	Check UTF-16 string.
unistr/u32-check	Check UTF-32 string.
unistr/u8-chr	Search character in piece of UTF-8 string.
unistr/u16-chr	Search character in piece of UTF-16 string.
unistr/u32-chr	Search character in piece of UTF-32 string.
unistr/u8-cmp	Compare pieces of UTF-8 strings.
unistr/u16-cmp	Compare pieces of UTF-16 strings.
unistr/u32-cmp	Compare pieces of UTF-32 strings.
unistr/u8-cmp2	Compare pieces of UTF-8 strings with possibly different lengths.
unistr/u16-cmp2	Compare pieces of UTF-16 strings with possibly different lengths.
unistr/u32-cmp2	Compare pieces of UTF-32 strings with possibly different lengths.
unistr/u8-cpy	Copy piece of UTF-8 string.
unistr/u16-cpy	Copy piece of UTF-16 string.
unistr/u32-cpy	Copy piece of UTF-32 string.
unistr/u8-cpy-alloc	Copy piece of UTF-8 string.
unistr/u16-cpy-alloc	Copy piece of UTF-16 string.
unistr/u32-cpy-alloc	Copy piece of UTF-32 string.
unistr/u8-endswith	Substring test for UTF-8 strings.
unistr/u16-endswith	Substring test for UTF-16 strings.
unistr/u32-endswith	Substring test for UTF-32 strings.
unistr/u8-mblen	Look at first character in UTF-8 string.
unistr/u16-mblen	Look at first character in UTF-16 string.
unistr/u32-mblen	Look at first character in UTF-32 string.
unistr/u8-mbsnlen	Count characters in UTF-8 string.
unistr/u16-mbsnlen	Count characters in UTF-16 string.
unistr/u32-mbsnlen	Count characters in UTF-32 string.
unistr/u8-mbtouc-unsafe	Look at first character in UTF-8 string.
unistr/u16-mbtouc-unsafe	Look at first character in UTF-16 string.
unistr/u32-mbtouc-unsafe	Look at first character in UTF-32 string.
unistr/u8-mbtouc	Look at first character in UTF-8 string.
unistr/u16-mbtouc	Look at first character in UTF-16 string.
unistr/u32-mbtouc	Look at first character in UTF-32 string.
unistr/u8-mbtoucr	Look at first character in UTF-8 string, returning an error code upon failure.
unistr/u16-mbtoucr	Look at first character in UTF-16 string, returning an error code upon failure.
unistr/u32-mbtoucr	Look at first character in UTF-32 string, returning an error code upon failure.
unistr/u8-move	Copy piece of UTF-8 string.
unistr/u16-move	Copy piece of UTF-16 string.
unistr/u32-move	Copy piece of UTF-32 string.
unistr/u8-next	Iterate over next character in UTF-8 string.
unistr/u16-next	Iterate over next character in UTF-16 string.
unistr/u32-next	Iterate over next character in UTF-32 string.
unistr/u8-prev	Iterate over previous character in UTF-8 string.
unistr/u16-prev	Iterate over previous character in UTF-16 string.
unistr/u32-prev	Iterate over previous character in UTF-32 string.
unistr/u8-set	Fill UTF-8 string.
unistr/u16-set	Fill UTF-16 string.
unistr/u32-set	Fill UTF-32 string.
unistr/u8-startswith	Substring test for UTF-8 strings.
unistr/u16-startswith	Substring test for UTF-16 strings.
unistr/u32-startswith	Substring test for UTF-32 strings.
unistr/u8-stpcpy	Copy UTF-8 string.
unistr/u16-stpcpy	Copy UTF-16 string.
unistr/u32-stpcpy	Copy UTF-32 string.
unistr/u8-stpncpy	Copy UTF-8 string.
unistr/u16-stpncpy	Copy UTF-16 string.
unistr/u32-stpncpy	Copy UTF-32 string.
unistr/u8-strcat	Concatenate UTF-8 strings.
unistr/u16-strcat	Concatenate UTF-16 strings.
unistr/u32-strcat	Concatenate UTF-32 strings.
unistr/u8-strchr	Search character in UTF-8 string.
unistr/u16-strchr	Search character in UTF-16 string.
unistr/u32-strchr	Search character in UTF-32 string.
unistr/u8-strcmp	Compare UTF-8 strings.
unistr/u16-strcmp	Compare UTF-16 strings.
unistr/u32-strcmp	Compare UTF-32 strings.
unistr/u8-strcoll	Compare UTF-8 strings using the collation rules of the current locale.
unistr/u16-strcoll	Compare UTF-16 strings using the collation rules of the current locale.
unistr/u32-strcoll	Compare UTF-32 strings using the collation rules of the current locale.
unistr/u8-strcpy	Copy UTF-8 string.
unistr/u16-strcpy	Copy UTF-16 string.
unistr/u32-strcpy	Copy UTF-32 string.
unistr/u8-strcspn	Search for some characters in UTF-8 string.
unistr/u16-strcspn	Search for some characters in UTF-16 string.
unistr/u32-strcspn	Search for some characters in UTF-32 string.
unistr/u8-strdup	Copy UTF-8 string.
unistr/u16-strdup	Copy UTF-16 string.
unistr/u32-strdup	Copy UTF-32 string.
unistr/u8-strlen	Determine length of UTF-8 string.
unistr/u16-strlen	Determine length of UTF-16 string.
unistr/u32-strlen	Determine length of UTF-32 string.
unistr/u8-strmblen	Look at first character in UTF-8 string.
unistr/u16-strmblen	Look at first character in UTF-16 string.
unistr/u32-strmblen	Look at first character in UTF-32 string.
unistr/u8-strmbtouc	Look at first character in UTF-8 string.
unistr/u16-strmbtouc	Look at first character in UTF-16 string.
unistr/u32-strmbtouc	Look at first character in UTF-32 string.
unistr/u8-strncat	Concatenate UTF-8 strings.
unistr/u16-strncat	Concatenate UTF-16 strings.
unistr/u32-strncat	Concatenate UTF-32 strings.
unistr/u8-strncmp	Compare UTF-8 strings.
unistr/u16-strncmp	Compare UTF-16 strings.
unistr/u32-strncmp	Compare UTF-32 strings.
unistr/u8-strncpy	Copy UTF-8 string.
unistr/u16-strncpy	Copy UTF-16 string.
unistr/u32-strncpy	Copy UTF-32 string.
unistr/u8-strnlen	Determine bounded length of UTF-8 string.
unistr/u16-strnlen	Determine bounded length of UTF-16 string.
unistr/u32-strnlen	Determine bounded length of UTF-32 string.
unistr/u8-strpbrk	Search for some characters in UTF-8 string.
unistr/u16-strpbrk	Search for some characters in UTF-16 string.
unistr/u32-strpbrk	Search for some characters in UTF-32 string.
unistr/u8-strrchr	Search character in UTF-8 string.
unistr/u16-strrchr	Search character in UTF-16 string.
unistr/u32-strrchr	Search character in UTF-32 string.
unistr/u8-strspn	Search for some characters in UTF-8 string.
unistr/u16-strspn	Search for some characters in UTF-16 string.
unistr/u32-strspn	Search for some characters in UTF-32 string.
unistr/u8-strstr	Substring test for UTF-8 strings.
unistr/u16-strstr	Substring test for UTF-16 strings.
unistr/u32-strstr	Substring test for UTF-32 strings.
unistr/u8-strtok	Tokenize UTF-8 string.
unistr/u16-strtok	Tokenize UTF-16 string.
unistr/u32-strtok	Tokenize UTF-32 string.
unistr/u8-uctomb	Store a character in UTF-8 string.
unistr/u16-uctomb	Store a character in UTF-16 string.
unistr/u32-uctomb	Store a character in UTF-32 string.
uniconv/base	Base layer for conversion from/to legacy encodings.
uniconv/u8-conv-from-enc	Conversion to UTF-8 from legacy encodings.
uniconv/u16-conv-from-enc	Conversion to UTF-16 from legacy encodings.
uniconv/u32-conv-from-enc	Conversion to UTF-32 from legacy encodings.
uniconv/u8-conv-to-enc	Conversion from UTF-8 to legacy encodings.
uniconv/u16-conv-to-enc	Conversion from UTF-16 to legacy encodings.
uniconv/u32-conv-to-enc	Conversion from UTF-32 to legacy encodings.
uniconv/u8-strconv-from-enc	Conversion to UTF-8 from legacy encodings.
uniconv/u16-strconv-from-enc	Conversion to UTF-16 from legacy encodings.
uniconv/u32-strconv-from-enc	Conversion to UTF-32 from legacy encodings.
uniconv/u8-strconv-to-enc	Conversion from UTF-8 to legacy encodings.
uniconv/u16-strconv-to-enc	Conversion from UTF-16 to legacy encodings.
uniconv/u32-strconv-to-enc	Conversion from UTF-32 to legacy encodings.
uniconv/u8-strconv-from-locale	Conversion to UTF-8 from the locale encoding.
uniconv/u16-strconv-from-locale	Conversion to UTF-16 from the locale encoding.
uniconv/u32-strconv-from-locale	Conversion to UTF-32 from the locale encoding.
uniconv/u8-strconv-to-locale	Conversion from UTF-8 to the locale encoding.
uniconv/u16-strconv-to-locale	Conversion from UTF-16 to the locale encoding.
uniconv/u32-strconv-to-locale	Conversion from UTF-32 to the locale encoding.
unistdio/base	Base layer for formatted output to strings.
unistdio/u-printf-args	Fetching a printf argument list.
unistdio/ulc-asnprintf	Formatted output to a string, with automatic memory allocation and bounded output size.
unistdio/ulc-asprintf	Formatted output to a string, with automatic memory allocation.
unistdio/ulc-fprintf	Print formatted output to a stream.
unistdio/ulc-printf-parse	Parsing an ASCII format string.
unistdio/ulc-snprintf	Formatted output to a fixed-length string.
unistdio/ulc-sprintf	Formatted output to a string.
unistdio/ulc-vasnprintf	Formatted output to strings.
unistdio/ulc-vasprintf	Formatted output to a string, with automatic memory allocation.
unistdio/ulc-vfprintf	Print formatted output to a stream.
unistdio/ulc-vsnprintf	Formatted output to a fixed-length string.
unistdio/ulc-vsprintf	Formatted output to a string.
unistdio/u8-asnprintf	Formatted output to an UTF-8 string, with automatic memory allocation and bounded output size.
unistdio/u8-asprintf	Formatted output to an UTF-8 string, with automatic memory allocation.
unistdio/u8-printf-parse	Parsing an UTF-8 format string.
unistdio/u8-snprintf	Formatted output to a fixed-length UTF-8 string.
unistdio/u8-sprintf	Formatted output to an UTF-8 string.
unistdio/u8-vasnprintf	Formatted output to UTF-8 strings.
unistdio/u8-vasprintf	Formatted output to an UTF-8 string, with automatic memory allocation.
unistdio/u8-vsnprintf	Formatted output to a fixed-length UTF-8 string.
unistdio/u8-vsprintf	Formatted output to an UTF-8 string.
unistdio/u8-u8-asnprintf	Formatted output to an UTF-8 string, with automatic memory allocation and bounded output size.
unistdio/u8-u8-asprintf	Formatted output to an UTF-8 string, with automatic memory allocation.
unistdio/u8-u8-snprintf	Formatted output to a fixed-length UTF-8 string.
unistdio/u8-u8-sprintf	Formatted output to an UTF-8 string.
unistdio/u8-u8-vasnprintf	Formatted output to UTF-8 strings.
unistdio/u8-u8-vasprintf	Formatted output to an UTF-8 string, with automatic memory allocation.
unistdio/u8-u8-vsnprintf	Formatted output to a fixed-length UTF-8 string.
unistdio/u8-u8-vsprintf	Formatted output to an UTF-8 string.
unistdio/u16-asnprintf	Formatted output to an UTF-16 string, with automatic memory allocation and bounded output size.
unistdio/u16-asprintf	Formatted output to an UTF-16 string, with automatic memory allocation.
unistdio/u16-printf-parse	Parsing an UTF-16 format string.
unistdio/u16-snprintf	Formatted output to a fixed-length UTF-16 string.
unistdio/u16-sprintf	Formatted output to an UTF-16 string.
unistdio/u16-vasnprintf	Formatted output to UTF-16 strings.
unistdio/u16-vasprintf	Formatted output to an UTF-16 string, with automatic memory allocation.
unistdio/u16-vsnprintf	Formatted output to a fixed-length UTF-16 string.
unistdio/u16-vsprintf	Formatted output to an UTF-16 string.
unistdio/u16-u16-asnprintf	Formatted output to an UTF-16 string, with automatic memory allocation and bounded output size.
unistdio/u16-u16-asprintf	Formatted output to an UTF-16 string, with automatic memory allocation.
unistdio/u16-u16-snprintf	Formatted output to a fixed-length UTF-16 string.
unistdio/u16-u16-sprintf	Formatted output to an UTF-16 string.
unistdio/u16-u16-vasnprintf	Formatted output to UTF-16 strings.
unistdio/u16-u16-vasprintf	Formatted output to an UTF-16 string, with automatic memory allocation.
unistdio/u16-u16-vsnprintf	Formatted output to a fixed-length UTF-16 string.
unistdio/u16-u16-vsprintf	Formatted output to an UTF-16 string.
unistdio/u32-asnprintf	Formatted output to an UTF-32 string, with automatic memory allocation and bounded output size.
unistdio/u32-asprintf	Formatted output to an UTF-32 string, with automatic memory allocation.
unistdio/u32-printf-parse	Parsing an UTF-32 format string.
unistdio/u32-snprintf	Formatted output to a fixed-length UTF-32 string.
unistdio/u32-sprintf	Formatted output to an UTF-32 string.
unistdio/u32-vasnprintf	Formatted output to UTF-32 strings.
unistdio/u32-vasprintf	Formatted output to an UTF-32 string, with automatic memory allocation.
unistdio/u32-vsnprintf	Formatted output to a fixed-length UTF-32 string.
unistdio/u32-vsprintf	Formatted output to an UTF-32 string.
unistdio/u32-u32-asnprintf	Formatted output to an UTF-32 string, with automatic memory allocation and bounded output size.
unistdio/u32-u32-asprintf	Formatted output to an UTF-32 string, with automatic memory allocation.
unistdio/u32-u32-snprintf	Formatted output to a fixed-length UTF-32 string.
unistdio/u32-u32-sprintf	Formatted output to an UTF-32 string.
unistdio/u32-u32-vasnprintf	Formatted output to UTF-32 strings.
unistdio/u32-u32-vasprintf	Formatted output to an UTF-32 string, with automatic memory allocation.
unistdio/u32-u32-vsnprintf	Formatted output to a fixed-length UTF-32 string.
unistdio/u32-u32-vsprintf	Formatted output to an UTF-32 string.
uniname/base	Base layer for Unicode character names.
uniname/uniname	Association between Unicode characters and their names.
unictype/base	Base layer for Unicode classification and properties.
unictype/bidiclass-byname	Find a Unicode character bidi class, given its name.
unictype/bidiclass-name	Name of Unicode character bidi class.
unictype/bidiclass-longname	Name of Unicode character bidi class.
unictype/bidiclass-of	Determine bidi class of a Unicode character.
unictype/bidiclass-test	Test whether a Unicode character belongs to a given bidi class.
unictype/bidiclass-all	Complete API for Unicode character bidi categories.
unictype/block-list	List of Unicode character blocks.
unictype/block-of	Determine block of a Unicode character.
unictype/block-test	Test whether a Unicode character belongs to a given Unicode block.
unictype/block-all	Complete API for blocks of Unicode characters.
unictype/category-C	Test whether a Unicode character is of general category C.
unictype/category-Cc	Test whether a Unicode character is of general category Cc.
unictype/category-Cf	Test whether a Unicode character is of general category Cf.
unictype/category-Cn	Test whether a Unicode character is of general category Cn.
unictype/category-Co	Test whether a Unicode character is of general category Co.
unictype/category-Cs	Test whether a Unicode character is of general category Cs.
unictype/category-L	Test whether a Unicode character is of general category L.
unictype/category-Ll	Test whether a Unicode character is of general category Ll.
unictype/category-Lm	Test whether a Unicode character is of general category Lm.
unictype/category-Lo	Test whether a Unicode character is of general category Lo.
unictype/category-Lt	Test whether a Unicode character is of general category Lt.
unictype/category-Lu	Test whether a Unicode character is of general category Lu.
unictype/category-M	Test whether a Unicode character is of general category M.
unictype/category-Mc	Test whether a Unicode character is of general category Mc.
unictype/category-Me	Test whether a Unicode character is of general category Me.
unictype/category-Mn	Test whether a Unicode character is of general category Mn.
unictype/category-N	Test whether a Unicode character is of general category N.
unictype/category-Nd	Test whether a Unicode character is of general category Nd.
unictype/category-Nl	Test whether a Unicode character is of general category Nl.
unictype/category-No	Test whether a Unicode character is of general category No.
unictype/category-P	Test whether a Unicode character is of general category P.
unictype/category-Pc	Test whether a Unicode character is of general category Pc.
unictype/category-Pd	Test whether a Unicode character is of general category Pd.
unictype/category-Pe	Test whether a Unicode character is of general category Pe.
unictype/category-Pf	Test whether a Unicode character is of general category Pf.
unictype/category-Pi	Test whether a Unicode character is of general category Pi.
unictype/category-Po	Test whether a Unicode character is of general category Po.
unictype/category-Ps	Test whether a Unicode character is of general category Ps.
unictype/category-S	Test whether a Unicode character is of general category S.
unictype/category-Sc	Test whether a Unicode character is of general category Sc.
unictype/category-Sk	Test whether a Unicode character is of general category Sk.
unictype/category-Sm	Test whether a Unicode character is of general category Sm.
unictype/category-So	Test whether a Unicode character is of general category So.
unictype/category-Z	Test whether a Unicode character is of general category Z.
unictype/category-Zl	Test whether a Unicode character is of general category Zl.
unictype/category-Zp	Test whether a Unicode character is of general category Zp.
unictype/category-Zs	Test whether a Unicode character is of general category Zs.
unictype/category-and	Intersection of categories of Unicode characters.
unictype/category-and-not	Set-difference of categories of Unicode characters.
unictype/category-byname	Find a Unicode character category, given its name.
unictype/category-name	Name of Unicode character category.
unictype/category-none	Empty category of Unicode characters.
unictype/category-of	Determine category of a Unicode character.
unictype/category-or	Union of categories of Unicode characters.
unictype/category-test	Test whether a Unicode character belongs to a given category.
unictype/category-test-withtable	Test whether a Unicode character belongs to a given bitmask of categories.
unictype/category-all	Complete API for Unicode character categories.
unictype/combining-class	Determine canonical combining class of a Unicode character.
unictype/ctype-alnum	Generalization of the <ctype.h> isalnum function and the <wctype.h> iswalnum function.
unictype/ctype-alpha	Generalization of the <ctype.h> isalpha function and the <wctype.h> iswalpha function.
unictype/ctype-blank	Generalization of the <ctype.h> isblank function and the <wctype.h> iswblank function.
unictype/ctype-cntrl	Generalization of the <ctype.h> iscntrl function and the <wctype.h> iswcntrl function.
unictype/ctype-digit	Generalization of the <ctype.h> isdigit function and the <wctype.h> iswdigit function.
unictype/ctype-graph	Generalization of the <ctype.h> isgraph function and the <wctype.h> iswgraph function.
unictype/ctype-lower	Generalization of the <ctype.h> islower function and the <wctype.h> iswlower function.
unictype/ctype-print	Generalization of the <ctype.h> isprint function and the <wctype.h> iswprint function.
unictype/ctype-punct	Generalization of the <ctype.h> ispunct function and the <wctype.h> iswpunct function.
unictype/ctype-space	Generalization of the <ctype.h> isspace function and the <wctype.h> iswspace function.
unictype/ctype-upper	Generalization of the <ctype.h> isupper function and the <wctype.h> iswupper function.
unictype/ctype-xdigit	Generalization of the <ctype.h> isxdigit function and the <wctype.h> iswxdigit function.
unictype/decimal-digit	Value of a decimal digit Unicode character.
unictype/digit	Value of a digit Unicode character.
unictype/mirror	Mirrored Unicode characters.
unictype/numeric	Value of a numeric Unicode character.
unictype/property-alphabetic	Test whether a Unicode character is "alphabetic".
unictype/property-ascii-hex-digit	Test whether a Unicode character is "ascii hex digit".
unictype/property-bidi-arabic-digit	Test whether a Unicode character is "bidi arabic digit".
unictype/property-bidi-arabic-right-to-left	Test whether a Unicode character is "bidi arabic right to left".
unictype/property-bidi-block-separator	Test whether a Unicode character is "bidi block separator".
unictype/property-bidi-boundary-neutral	Test whether a Unicode character is "bidi boundary neutral".
unictype/property-bidi-common-separator	Test whether a Unicode character is "bidi common separator".
unictype/property-bidi-control	Test whether a Unicode character is "bidi control".
unictype/property-bidi-embedding-or-override	Test whether a Unicode character is "bidi embedding or override".
unictype/property-bidi-eur-num-separator	Test whether a Unicode character is "bidi eur num separator".
unictype/property-bidi-eur-num-terminator	Test whether a Unicode character is "bidi eur num terminator".
unictype/property-bidi-european-digit	Test whether a Unicode character is "bidi european digit".
unictype/property-bidi-hebrew-right-to-left	Test whether a Unicode character is "bidi hebrew right to left".
unictype/property-bidi-left-to-right	Test whether a Unicode character is "bidi left to right".
unictype/property-bidi-non-spacing-mark	Test whether a Unicode character is "bidi non spacing mark".
unictype/property-bidi-other-neutral	Test whether a Unicode character is "bidi other neutral".
unictype/property-bidi-pdf	Test whether a Unicode character is "bidi pdf".
unictype/property-bidi-segment-separator	Test whether a Unicode character is "bidi segment separator".
unictype/property-bidi-whitespace	Test whether a Unicode character is "bidi whitespace".
unictype/property-byname	Find a Unicode character property, given its name.
unictype/property-case-ignorable	Test whether a Unicode character is "case ignorable".
unictype/property-cased	Test whether a Unicode character is "cased".
unictype/property-changes-when-casefolded	Test whether a Unicode character changes when casefolded.
unictype/property-changes-when-casemapped	Test whether a Unicode character changes when casemapped.
unictype/property-changes-when-lowercased	Test whether a Unicode character changes when lowercased.
unictype/property-changes-when-titlecased	Test whether a Unicode character changes when titlecased.
unictype/property-changes-when-uppercased	Test whether a Unicode character changes when uppercased.
unictype/property-combining	Test whether a Unicode character is "combining".
unictype/property-composite	Test whether a Unicode character is "composite".
unictype/property-currency-symbol	Test whether a Unicode character is "currency symbol".
unictype/property-dash	Test whether a Unicode character is "dash".
unictype/property-decimal-digit	Test whether a Unicode character is "decimal digit".
unictype/property-default-ignorable-code-point	Test whether a Unicode character is "default ignorable code point".
unictype/property-deprecated	Test whether a Unicode character is "deprecated".
unictype/property-diacritic	Test whether a Unicode character is "diacritic".
unictype/property-extender	Test whether a Unicode character is "extender".
unictype/property-format-control	Test whether a Unicode character is "format control".
unictype/property-grapheme-base	Test whether a Unicode character is "grapheme base".
unictype/property-grapheme-extend	Test whether a Unicode character is "grapheme extend".
unictype/property-grapheme-link	Test whether a Unicode character is "grapheme link".
unictype/property-hex-digit	Test whether a Unicode character is "hex digit".
unictype/property-hyphen	Test whether a Unicode character is "hyphen".
unictype/property-id-continue	Test whether a Unicode character is "id continue".
unictype/property-id-start	Test whether a Unicode character is "id start".
unictype/property-ideographic	Test whether a Unicode character is "ideographic".
unictype/property-ids-binary-operator	Test whether a Unicode character is "ids binary operator".
unictype/property-ids-trinary-operator	Test whether a Unicode character is "ids trinary operator".
unictype/property-ignorable-control	Test whether a Unicode character is "ignorable control".
unictype/property-iso-control	Test whether a Unicode character is "iso control".
unictype/property-join-control	Test whether a Unicode character is "join control".
unictype/property-left-of-pair	Test whether a Unicode character is "left of pair".
unictype/property-line-separator	Test whether a Unicode character is "line separator".
unictype/property-logical-order-exception	Test whether a Unicode character is "logical order exception".
unictype/property-lowercase	Test whether a Unicode character is "lowercase".
unictype/property-math	Test whether a Unicode character is "math".
unictype/property-non-break	Test whether a Unicode character is "non break".
unictype/property-not-a-character	Test whether a Unicode character is "not a character".
unictype/property-numeric	Test whether a Unicode character is "numeric".
unictype/property-other-alphabetic	Test whether a Unicode character is "other alphabetic".
unictype/property-other-default-ignorable-code-point	Test whether a Unicode character is "other default ignorable code point".
unictype/property-other-grapheme-extend	Test whether a Unicode character is "other grapheme extend".
unictype/property-other-id-continue	Test whether a Unicode character is "other id continue".
unictype/property-other-id-start	Test whether a Unicode character is "other id start".
unictype/property-other-lowercase	Test whether a Unicode character is "other lowercase".
unictype/property-other-math	Test whether a Unicode character is "other math".
unictype/property-other-uppercase	Test whether a Unicode character is "other uppercase".
unictype/property-paired-punctuation	Test whether a Unicode character is "paired punctuation".
unictype/property-paragraph-separator	Test whether a Unicode character is "paragraph separator".
unictype/property-pattern-syntax	Test whether a Unicode character is "pattern syntax".
unictype/property-pattern-white-space	Test whether a Unicode character is "pattern white space".
unictype/property-private-use	Test whether a Unicode character is "private use".
unictype/property-punctuation	Test whether a Unicode character is "punctuation".
unictype/property-quotation-mark	Test whether a Unicode character is "quotation mark".
unictype/property-radical	Test whether a Unicode character is "radical".
unictype/property-sentence-terminal	Test whether a Unicode character is "sentence terminal".
unictype/property-soft-dotted	Test whether a Unicode character is "soft dotted".
unictype/property-space	Test whether a Unicode character is "space".
unictype/property-terminal-punctuation	Test whether a Unicode character is "terminal punctuation".
unictype/property-test	Test whether a Unicode character has a given property.
unictype/property-titlecase	Test whether a Unicode character is "titlecase".
unictype/property-unassigned-code-value	Test whether a Unicode character is "unassigned code value".
unictype/property-unified-ideograph	Test whether a Unicode character is "unified ideograph".
unictype/property-uppercase	Test whether a Unicode character is "uppercase".
unictype/property-variation-selector	Test whether a Unicode character is "variation selector".
unictype/property-white-space	Test whether a Unicode character is "white space".
unictype/property-xid-continue	Test whether a Unicode character is "xid continue".
unictype/property-xid-start	Test whether a Unicode character is "xid start".
unictype/property-zero-width	Test whether a Unicode character is "zero width".
unictype/property-all	Complete API for Unicode character properties.
unictype/scripts	Scripts of Unicode characters.
unictype/scripts-all	Complete API for scripts of Unicode characters.
unictype/syntax-c-ident	Test whether a Unicode character can occur in identifiers in the C language.
unictype/syntax-c-whitespace	Test whether a Unicode character is whitespace in the C language syntax.
unictype/syntax-java-ident	Test whether a Unicode character can occur in identifiers in the Java language.
unictype/syntax-java-whitespace	Test whether a Unicode character is whitespace in the Java language syntax.
uniwidth/base	Base layer for Unicode string width.
uniwidth/u8-strwidth	Determine display width of UTF-8 string.
uniwidth/u8-width	Determine display width of UTF-8 string.
uniwidth/u16-strwidth	Determine display width of UTF-16 string.
uniwidth/u16-width	Determine display width of UTF-16 string.
uniwidth/u32-strwidth	Determine display width of UTF-32 string.
uniwidth/u32-width	Determine display width of UTF-32 string.
uniwidth/width	Determine display width of Unicode character.
uniwbrk/base	Base layer for word breaks.
uniwbrk/ulc-wordbreaks	Word breaks in strings.
uniwbrk/u8-wordbreaks	Word breaks in UTF-8 strings.
uniwbrk/u16-wordbreaks	Word breaks in UTF-16 strings.
uniwbrk/u32-wordbreaks	Word breaks in UTF-32 strings.
uniwbrk/wordbreak-property	Base layer for word breaks.
unilbrk/base	Base layer for line breaking.
unilbrk/tables	Line breaking auxiliary tables.
unilbrk/ulc-common	Line breaking auxiliary functions.
unilbrk/u8-possible-linebreaks	Line breaking of UTF-8 strings.
unilbrk/u16-possible-linebreaks	Line breaking of UTF-16 strings.
unilbrk/u32-possible-linebreaks	Line breaking of UTF-32 strings.
unilbrk/ulc-possible-linebreaks	Line breaking of strings.
unilbrk/u8-width-linebreaks	Line breaking of UTF-8 strings.
unilbrk/u16-width-linebreaks	Line breaking of UTF-16 strings.
unilbrk/u32-width-linebreaks	Line breaking of UTF-32 strings.
unilbrk/ulc-width-linebreaks	Line breaking of strings.
uninorm/base	Base layer for normalization forms of Unicode strings.
uninorm/canonical-decomposition	Canonical decomposition of Unicode characters.
uninorm/composition	Composition of Unicode characters.
uninorm/decomposing-form	Decomposing variant of a normalization form.
uninorm/decomposition	Decomposition of Unicode characters.
uninorm/filter	Normalization of a stream of Unicode characters.
uninorm/nfc	Canonical normalization of Unicode strings.
uninorm/nfd	Canonical decomposition of Unicode strings.
uninorm/nfkc	Compatibility normalization of Unicode strings.
uninorm/nfkd	Compatibility decomposition of Unicode strings.
uninorm/u8-normalize	Normalization of UTF-8 strings.
uninorm/u16-normalize	Normalization of UTF-16 strings.
uninorm/u32-normalize	Normalization of UTF-32 strings.
uninorm/u8-normcmp	Normalization insensitive comparison of UTF-8 strings.
uninorm/u16-normcmp	Normalization insensitive comparison of UTF-16 strings.
uninorm/u32-normcmp	Normalization insensitive comparison of UTF-32 strings.
uninorm/u8-normcoll	Locale dependent, normalization insensitive comparison of UTF-8 strings.
uninorm/u16-normcoll	Locale dependent, normalization insensitive comparison of UTF-16 strings.
uninorm/u32-normcoll	Locale dependent, normalization insensitive comparison of UTF-32 strings.
uninorm/u8-normxfrm	Locale dependent transformation for comparison of UTF-8 strings.
uninorm/u16-normxfrm	Locale dependent transformation for comparison of UTF-16 strings.
uninorm/u32-normxfrm	Locale dependent transformation for comparison of UTF-32 strings.
unicase/base	Base layer for Unicode character case mappings.
unicase/empty-prefix-context	Case-mapping context of empty prefix string.
unicase/empty-suffix-context	Case-mapping context of empty suffix string.
unicase/locale-language	Language code of current locale.
unicase/tolower	Lowercase mapping for Unicode characters (locale and context independent).
unicase/totitle	Titlecase mapping for Unicode characters (locale and context independent).
unicase/toupper	Uppercase mapping for Unicode characters (locale and context independent).
unicase/ulc-casecmp	Case and normalization insensitive comparison of strings.
unicase/ulc-casecoll	Locale dependent, case and normalization insensitive comparison of strings.
unicase/ulc-casexfrm	Locale dependent transformation for case insensitive comparison of strings.
unicase/u8-casecmp	Case and normalization insensitive comparison of UTF-8 strings.
unicase/u16-casecmp	Case and normalization insensitive comparison of UTF-16 strings.
unicase/u32-casecmp	Case and normalization insensitive comparison of UTF-32 strings.
unicase/u8-casecoll	Locale dependent, case and normalization insensitive comparison of UTF-8 strings.
unicase/u16-casecoll	Locale dependent, case and normalization insensitive comparison of UTF-16 strings.
unicase/u32-casecoll	Locale dependent, case and normalization insensitive comparison of UTF-32 strings.
unicase/u8-casefold	Casefolding mapping for UTF-8 strings (locale dependent).
unicase/u16-casefold	Casefolding mapping for UTF-16 strings (locale dependent).
unicase/u32-casefold	Casefolding mapping for UTF-32 strings (locale dependent).
unicase/u8-casexfrm	Locale dependent transformation for case insensitive comparison of UTF-8 strings.
unicase/u16-casexfrm	Locale dependent transformation for case insensitive comparison of UTF-16 strings.
unicase/u32-casexfrm	Locale dependent transformation for case insensitive comparison of UTF-32 strings.
unicase/u8-ct-casefold	Casefolding mapping for UTF-8 substrings (locale dependent).
unicase/u16-ct-casefold	Casefolding mapping for UTF-16 substrings (locale dependent).
unicase/u32-ct-casefold	Casefolding mapping for UTF-32 substrings (locale dependent).
unicase/u8-ct-tolower	Lowercase mapping for UTF-8 substrings (locale dependent).
unicase/u16-ct-tolower	Lowercase mapping for UTF-16 substrings (locale dependent).
unicase/u32-ct-tolower	Lowercase mapping for UTF-32 substrings (locale dependent).
unicase/u8-ct-totitle	Titlecase mapping for UTF-8 substrings (locale dependent).
unicase/u16-ct-totitle	Titlecase mapping for UTF-16 substrings (locale dependent).
unicase/u32-ct-totitle	Titlecase mapping for UTF-32 substrings (locale dependent).
unicase/u8-ct-toupper	Uppercase mapping for UTF-8 substrings (locale dependent).
unicase/u16-ct-toupper	Uppercase mapping for UTF-16 substrings (locale dependent).
unicase/u32-ct-toupper	Uppercase mapping for UTF-32 substrings (locale dependent).
unicase/u8-is-cased	Test whether case matters for an UTF-8 string.
unicase/u16-is-cased	Test whether case matters for an UTF-16 string.
unicase/u32-is-cased	Test whether case matters for an UTF-32 string.
unicase/u8-is-casefolded	Test whether an UTF-8 string is already case-folded.
unicase/u16-is-casefolded	Test whether an UTF-16 string is already case-folded.
unicase/u32-is-casefolded	Test whether an UTF-32 string is already case-folded.
unicase/u8-is-lowercase	Test whether an UTF-8 string is entirely lower case.
unicase/u16-is-lowercase	Test whether an UTF-16 string is entirely lower case.
unicase/u32-is-lowercase	Test whether an UTF-32 string is entirely lower case.
unicase/u8-is-titlecase	Test whether an UTF-8 string is entirely title case.
unicase/u16-is-titlecase	Test whether an UTF-16 string is entirely title case.
unicase/u32-is-titlecase	Test whether an UTF-32 string is entirely title case.
unicase/u8-is-uppercase	Test whether an UTF-8 string is entirely upper case.
unicase/u16-is-uppercase	Test whether an UTF-16 string is entirely upper case.
unicase/u8-prefix-context	Case-mapping context of prefix UTF-8 string.
unicase/u16-prefix-context	Case-mapping context of prefix UTF-16 string.
unicase/u32-prefix-context	Case-mapping context of prefix UTF-32 string.
unicase/u8-suffix-context	Case-mapping context of suffix UTF-8 string.
unicase/u16-suffix-context	Case-mapping context of suffix UTF-16 string.
unicase/u32-suffix-context	Case-mapping context of suffix UTF-32 string.
unicase/u8-tolower	Lowercase mapping for UTF-8 strings (locale dependent).
unicase/u16-tolower	Lowercase mapping for UTF-16 strings (locale dependent).
unicase/u32-tolower	Lowercase mapping for UTF-32 strings (locale dependent).
unicase/u8-totitle	Titlecase mapping for UTF-8 strings (locale dependent).
unicase/u16-totitle	Titlecase mapping for UTF-16 strings (locale dependent).
unicase/u32-totitle	Titlecase mapping for UTF-32 strings (locale dependent).
unicase/u8-toupper	Uppercase mapping for UTF-8 strings (locale dependent).
unicase/u16-toupper	Uppercase mapping for UTF-16 strings (locale dependent).
unicase/u32-toupper	Uppercase mapping for UTF-32 strings (locale dependent).

Executing programs

cloexec	Set or clear the close-on-exec descriptor flag.
findprog	Locating a program in PATH.
findprog-lgpl	Locating a program in PATH (LGPLed version).
wait-process	Waiting for a subprocess to finish.
execute	Creation of autonomous subprocesses.
spawn-pipe	Creation of subprocesses, communicating via pipes.
pipe-filter-gi	Filtering of data through a subprocess.
pipe-filter-ii	Filtering of data through a subprocess.
sh-quote	Shell quoting.

Java

classpath	Java CLASSPATH handling.
javacomp-script	Script to compile a Java program.
javacomp	Compile a Java program.
javaexec-script	Execute a Java program.
javaexec	Execute a Java program.
javaversion	Determine the Java version supported by javaexec.

C#

csharpcomp-script	Script to compile a C# program.
csharpcomp	Compile a C# program.
csharpexec-script	Script to execute a C# program.
csharpexec	Execute a C# program.

Misc

argp	Hierarchical processing of command line arguments.
argp-version-etc	Version-etc hook for Argp.
argz	Argv style string arrays in a single null delimited char*.
attribute	C/C++ attributes
bitrotate	Rotate bits in unsigned 8, 16, and 32 bit integers.
byteswap	Swap bytes of 16, 32 and 64 bit values.
dfa	DFA matcher that was initially used by GNU grep, gawk and diffutils
exitfail	Set exit status for fatal signal.
error	error and error_at_line functions: Error reporting.
extensions	Enable extensions in standard headers
forkpty	forkpty function: Open a pseudo-terminal, fork, and connect the child process to the pseudo-terminal's slave.
getdomainname	getdomainname function: Return machine's NIS domain name.
xgetdomainname	Return machine's domainname, without size limitations.
getentropy	Fill buffer with random bytes.
getloadavg	Return the current system load averages.
getpagesize	getpagesize function: Return memory page size.
getprogname	Program name management.
getrandom	Fill buffer with random bytes.
getusershell	Return names of valid user shells.
lib-symbol-visibility	Control of symbols exported by shared libraries.
login_tty	login_tty function: Assign a given terminal as controlling terminal and as standard input, standard output, standard error of the current process.
nproc	Detect the number of processors
openpty	openpty function: Open a pseudo-terminal.
parse-duration	Parse a duration given as string.
physmem	Return amount of total/available physical memory.
posixver	Determine desired POSIX specification version, according to user's environment variables.
progname	Program name management.
ptsname_r	ptsname_r function: Determine name of the slave side of a pseudo-terminal.
pty	A <pty.h> for systems that lacks it.
quotearg	Quote arguments for use in error messages.
quote	Quote arguments for use in error messages.
readutmp	Read entire utmp file into memory.
random_r	reentrant random number generator
selinux-h	SELinux-related headers for systems that lack them.
selinux-at	openat-style fd-relative functions for SE Linux
sysexits	Exit status codes for some BSD system programs.
sys_random	A GNU-like <sys/random.h>.
u64	uint64_t-like operations that work even on hosts lacking uint64_t
verror	verror and verror_at_line functions: Error reporting with va_list.

Support for building libraries and executables

absolute-header	Allows wrapping a broken system header in a gnulib replacement.
snippet/arg-nonnull	A C macro for declaring that specific arguments must not be NULL.
bison	Building bison-generated parsers.
config-h	Assume config.h exists, to avoid -DHAVE_CONFIG_H clutter in `make` output.
configmake	Access from source code to variables set by "configure" or "make".
dummy	A dummy file, to make sure the library is non-empty.
gperf	Provides the GNU gperf build tool.
havelib	Macros to search for libraries.
include_next	Allows wrapping a broken system header in a gnulib replacement.
ldd	Command to determine the dynamically linked dependencies of a program.
lib-ignore	If possible, ignore libraries that are not depended on.
lib-msvc-compat	Macros to test whether LD support --output-def.
lib-symbol-versions	Macros to test whether LD support --linker-script.
snippet/link-warning	A C macro for emitting link time warnings.
manywarnings	Helper M4 functions to help work out a set of warning parameters to use.
no-c++	Support for compiling in C mode when CC is set to a C++ compiler.
relocatable-lib	Help make libraries relocatable, that is, to allow them to function properly when copied to an arbitrary directory.
relocatable-lib-lgpl	Help make libraries relocatable, that is, to allow them to function properly when copied to an arbitrary directory.
relocatable-prog	Help make programs relocatable, that is, to allow them to function properly when copied to an arbitrary directory.
relocatable-prog-wrapper	Source for the wrapper program that is required for making programs relocatable that depend on shared libraries installed with the same installation prefix.
relocatable-script	Help make shell scripts relocatable, that is, to allow them to function properly when copied to an arbitrary directory.
snippet/warn-on-use	A C macro for emitting a warning if a function is used.
warnings	Helper M4 functions for safely adding compiler warning parameters.

Support for building documentation

agpl-3.0	Provide the GNU Affero General Public License version 3.0 in Texinfo format.
fdl	Provide the GNU Free Documentation License in Texinfo format.
fdl-1.3	Provide the GNU Free Documentation License version 1.3 in Texinfo format.
gendocs	Generate manuals in several formats from Texinfo sources. Can be used for https://www.gnu.org/software/PKG/manual/ directories.
gpl-2.0	Provide the GNU General Public License version 2.0 in Texinfo format.
gpl-3.0	Provide the GNU General Public License version 3.0 in Texinfo format.
lgpl-2.1	Provide the GNU Lesser General Public License version 2.1 in Texinfo format.
lgpl-3.0	Provide the GNU Lesser General Public License version 3.0 in Texinfo format.
pmccabe2html	Produce fancy cyclomatic code complexity charts, using pmccabe. See <https://people.debian.org/~bame/pmccabe/>.
regexprops-generic	Describe the various regular expression flavors.

Support for maintaining and releasing projects

announce-gen	Generate a release announcement message. See also readme-release.
autobuild	Macros to print information about the build, useful for the autobuild parser.
do-release-commit-and-tag	Automate the release-commit and tag process. See also readme-release.
git-version-gen	Compute a version string from a git repository.
gitlog-to-changelog	Convert git log to ChangeLog
gnu-web-doc-update	Update the official GNU web documentation for your project. See also readme-release.
gnumakefile	Add GNU-make specific rules for maintainer use.
gnupload	Upload PGP signed files to gnu.org. See https://www.gnu.org/prep/maintain/html_node/Automated-FTP-Uploads.html for more information.
maintainer-makefile	Helper GNUmakefile with syntax checks, build improvements, etc. See also readme-release.
mktempd	Create a temporary directory, much like mktemp -d does.
non-recursive-gnulib-prefix-hack	Adjust a gnulib-generated gnulib.mk file and configure script so that they are usable in a non-recursive make framework.
readme-release	Add release instructions customized for the package. You should add a line like perl -pi -e "s/\@PACKAGE\@/$package/g" README-release to autogen.sh or bootstrap.conf's epilogue function to patch the package name in. This is particularly handy for making various URLs copy-and-pastable. Note that, as with any gnulib-tool supplied file, README-release can be customized via a .diff file. This is an easy way to add package-specific instructions.
test-framework-sh	Bourne-shell-based testing framework
update-copyright	Update an FSF copyright year list to include the current year.
useless-if-before-free	Detect useless "if" tests before "free" calls.
vc-list-files	list version-controlled files (vc-agnostic)
vcs-to-changelog	Convert git log to ChangeLog

Misc

gnu-make	Determine whether recent-enough GNU Make is being used.
host-os	Define HOST_OPERATING_SYSTEM to a name for the host operating system.
nocrash	Macro that avoids crashes in configure tests.
perl	Find a new-enough version of Perl.
posix-shell	Find a POSIX-conforming shell.
uptime	Test whether /proc/uptime might exist.

Support for obsolete systems lacking ANSI C 89

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
stdlib	#include <stdlib.h>	stdlib.in.h	stdlib_h.m4 locale-fr.m4 codeset.m4 00gnulib.m4 zzgnulib.m4 gl_STDLIB_H gl_STDLIB_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	gen-header include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use snippet/_Noreturn stddef unistd
strtol	#include <stdlib.h>	strtol.c	strtol.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_STRTOL gl_CONDITIONAL([GL_COND_OBJ_STRTOL], [test $HAVE_STRTOL = 0 \|\| test $REPLACE_STRTOL = 1]) gl_STDLIB_MODULE_INDICATOR([strtol])	stdlib
strtoul	#include <stdlib.h>	strtol.c strtoul.c	strtoul.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_STRTOUL gl_CONDITIONAL([GL_COND_OBJ_STRTOUL], [test $HAVE_STRTOUL = 0 \|\| test $REPLACE_STRTOUL = 1]) gl_STDLIB_MODULE_INDICATOR([strtoul])	stdlib
memcmp	#include <string.h>	memcmp.c	memcmp.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_MEMCMP gl_CONDITIONAL([GL_COND_OBJ_MEMCMP], [test $gl_func_memcmp = no]) AM_COND_IF([GL_COND_OBJ_MEMCMP], [ gl_PREREQ_MEMCMP ])	stdint [test $gl_func_memcmp = no]
memcpy	#include <string.h>	memcpy.c	memcpy.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_MEMCPY gl_CONDITIONAL([GL_COND_OBJ_MEMCPY], [test $ac_cv_func_memcpy = no]) AM_COND_IF([GL_COND_OBJ_MEMCPY], [ gl_PREREQ_MEMCPY ])	string
memmove	#include <string.h>	memmove.c	memmove.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_MEMMOVE gl_CONDITIONAL([GL_COND_OBJ_MEMMOVE], [test $ac_cv_func_memmove = no]) AM_COND_IF([GL_COND_OBJ_MEMMOVE], [ gl_PREREQ_MEMMOVE ])	string
memset	#include <string.h>	memset.c	memset.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_MEMSET gl_CONDITIONAL([GL_COND_OBJ_MEMSET], [test $ac_cv_func_memset = no]) AM_COND_IF([GL_COND_OBJ_MEMSET], [ gl_PREREQ_MEMSET ])	string
strcspn	#include <string.h>	strcspn.c	strcspn.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_STRCSPN gl_CONDITIONAL([GL_COND_OBJ_STRCSPN], [test $ac_cv_func_strcspn = no]) AM_COND_IF([GL_COND_OBJ_STRCSPN], [ gl_PREREQ_STRCSPN ])	---
strpbrk	#include <string.h>	strpbrk.c	strpbrk.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_STRPBRK gl_CONDITIONAL([GL_COND_OBJ_STRPBRK], [test $HAVE_STRPBRK = 0]) AM_COND_IF([GL_COND_OBJ_STRPBRK], [ gl_PREREQ_STRPBRK ]) gl_STRING_MODULE_INDICATOR([strpbrk])	string

Support for systems lacking ANSI C 89

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
atexit	#include <stdlib.h>	atexit.c	atexit.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ATEXIT gl_CONDITIONAL([GL_COND_OBJ_ATEXIT], [test $ac_cv_func_atexit = no]) AM_COND_IF([GL_COND_OBJ_ATEXIT], [ gl_PREREQ_ATEXIT ])	---
ctime	#include <time.h>	ctime.c	ctime.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_CTIME gl_CONDITIONAL([GL_COND_OBJ_CTIME], [test $REPLACE_CTIME = 1]) gl_TIME_MODULE_INDICATOR([ctime])	time-h
localtime	#include <time.h>	localtime.c	localtime.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_LOCALTIME gl_CONDITIONAL([GL_COND_OBJ_LOCALTIME], [test $REPLACE_LOCALTIME = 1]) gl_TIME_MODULE_INDICATOR([localtime])	time-h
strtod	#include <stdlib.h>	strtod.c	strtod.m4 ldexp.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_STRTOD gl_CONDITIONAL([GL_COND_OBJ_STRTOD], [test $HAVE_STRTOD = 0 \|\| test $REPLACE_STRTOD = 1]) AM_COND_IF([GL_COND_OBJ_STRTOD], [ gl_PREREQ_STRTOD ]) gl_STDLIB_MODULE_INDICATOR([strtod])	stdlib strtod-obsolete c-ctype [test $HAVE_STRTOD = 0 \|\| test $REPLACE_STRTOD = 1] math [test $HAVE_STRTOD = 0 \|\| test $REPLACE_STRTOD = 1] stdbool [test $HAVE_STRTOD = 0 \|\| test $REPLACE_STRTOD = 1]
strerror	#include <string.h>	strerror.c	strerror.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_STRERROR gl_CONDITIONAL([GL_COND_OBJ_STRERROR], [test $REPLACE_STRERROR = 1]) gl_MODULE_INDICATOR([strerror]) gl_STRING_MODULE_INDICATOR([strerror])	string assert-h [test $REPLACE_STRERROR = 1] errno [test $REPLACE_STRERROR = 1] intprops [test $REPLACE_STRERROR = 1] strerror-override [test $REPLACE_STRERROR = 1]
strerror-override	#include "strerror-override.h"	strerror-override.c	sys_socket_h.m4 strerror.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_HEADER_ERRNO_H]) AC_REQUIRE([gl_FUNC_STRERROR_0]) gl_CONDITIONAL([GL_COND_OBJ_STRERROR_OVERRIDE], [test -n "$ERRNO_H" \|\| test $REPLACE_STRERROR_0 = 1]) AM_COND_IF([GL_COND_OBJ_STRERROR_OVERRIDE], [ gl_PREREQ_SYS_H_WINSOCK2 ])	errno
mktime	#include <time.h>	mktime-internal.h mktime.c	mktime.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_MKTIME if test $REPLACE_MKTIME = 1; then AC_LIBOBJ([mktime]) gl_PREREQ_MKTIME fi gl_TIME_MODULE_INDICATOR([mktime])	time-h c99 multiarch intprops [test $REPLACE_MKTIME = 1] libc-config [test $REPLACE_MKTIME = 1] stdbool [test $REPLACE_MKTIME = 1] time_r [test $REPLACE_MKTIME = 1] verify [test $REPLACE_MKTIME = 1]

Enhancements for ANSI C 89 functions

Diagnostics <assert.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
assert	#include <assert.h>	---	assert.m4 00gnulib.m4 zzgnulib.m4 gl_ASSERT	c99
assure	#include "assure.h"	---	00gnulib.m4 zzgnulib.m4	verify
verify	#include "verify.h"	---	00gnulib.m4 zzgnulib.m4	c99

Mathematics <math.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
fpieee	---	---	fpieee.m4 00gnulib.m4 zzgnulib.m4	---

Input/output <stdio.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
fflush	#include <stdio.h>	fflush.c stdio-impl.h	fflush.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FFLUSH gl_CONDITIONAL([GL_COND_OBJ_FFLUSH], [test $REPLACE_FFLUSH = 1]) AM_COND_IF([GL_COND_OBJ_FFLUSH], [ gl_PREREQ_FFLUSH ]) gl_MODULE_INDICATOR([fflush]) gl_STDIO_MODULE_INDICATOR([fflush])	stdio fpurge [test $REPLACE_FFLUSH = 1] ftello [test $REPLACE_FFLUSH = 1] freading [test $REPLACE_FFLUSH = 1] lseek [test $REPLACE_FFLUSH = 1] unistd [test $REPLACE_FFLUSH = 1] fseeko [test $REPLACE_FFLUSH = 1]
fseterr	#include "fseterr.h"	fseterr.c stdio-impl.h	fseterr.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FSETERR gl_CONDITIONAL([GL_COND_OBJ_FSETERR], [test $ac_cv_func___fseterr = no])	---
tmpfile	#include <stdio.h>	tmpfile.c	tmpfile.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_TMPFILE gl_CONDITIONAL([GL_COND_OBJ_TMPFILE], [test $REPLACE_TMPFILE = 1]) AM_COND_IF([GL_COND_OBJ_TMPFILE], [ gl_PREREQ_TMPFILE ]) gl_STDIO_MODULE_INDICATOR([tmpfile])	stdio largefile pathmax [test $REPLACE_TMPFILE = 1] stdbool [test $REPLACE_TMPFILE = 1] tempname [test $REPLACE_TMPFILE = 1] tmpdir [test $REPLACE_TMPFILE = 1]

Memory management functions <stdlib.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
calloc-gnu	#include <stdlib.h>	calloc.c	calloc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_CALLOC_GNU if test $REPLACE_CALLOC_FOR_CALLOC_GNU = 1; then AC_LIBOBJ([calloc]) fi gl_STDLIB_MODULE_INDICATOR([calloc-gnu])	calloc-posix xalloc-oversized [test $REPLACE_CALLOC_FOR_CALLOC_GNU = 1]
eealloc	#include <eealloc.h>	eealloc.h eealloc.c	eealloc.m4 malloc.m4 realloc.m4 00gnulib.m4 zzgnulib.m4 gl_EEALLOC	extern-inline
free-posix	#include <stdlib.h>	free.c	free.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FREE gl_CONDITIONAL([GL_COND_OBJ_FREE], [test $REPLACE_FREE = 1]) AM_COND_IF([GL_COND_OBJ_FREE], [ gl_PREREQ_FREE ]) gl_STDLIB_MODULE_INDICATOR([free-posix])	stdlib string wchar
malloc-gnu	#include <stdlib.h>	malloc.c	00gnulib.m4 zzgnulib.m4 gl_FUNC_MALLOC_GNU if test $REPLACE_MALLOC_FOR_MALLOC_GNU = 1; then AC_LIBOBJ([malloc]) fi gl_STDLIB_MODULE_INDICATOR([malloc-gnu])	malloc-posix xalloc-oversized [test $REPLACE_MALLOC_FOR_MALLOC_GNU = 1]
memalign	#include <malloc.h>	memalign.c	memalign.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_MEMALIGN gl_CONDITIONAL([GL_COND_OBJ_MEMALIGN], [test $REPLACE_MEMALIGN = 1]) gl_MALLOC_MODULE_INDICATOR([memalign])	malloc-h
realloc-gnu	#include <stdlib.h>	realloc.c	00gnulib.m4 zzgnulib.m4 gl_FUNC_REALLOC_GNU if test $REPLACE_REALLOC_FOR_REALLOC_GNU = 1; then AC_LIBOBJ([realloc]) fi gl_STDLIB_MODULE_INDICATOR([realloc-gnu])	realloc-posix free-posix [test $REPLACE_REALLOC_FOR_REALLOC_GNU = 1] malloc-gnu [test $REPLACE_REALLOC_FOR_REALLOC_GNU = 1] xalloc-oversized [test $REPLACE_REALLOC_FOR_REALLOC_GNU = 1]
reallocarray	#include <stdlib.h>	reallocarray.c	malloc.m4 reallocarray.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_REALLOCARRAY gl_CONDITIONAL([GL_COND_OBJ_REALLOCARRAY], [test $HAVE_REALLOCARRAY = 0 \|\| test $REPLACE_REALLOCARRAY = 1]) AM_COND_IF([GL_COND_OBJ_REALLOCARRAY], [ gl_PREREQ_REALLOCARRAY ]) gl_MODULE_INDICATOR([reallocarray]) gl_STDLIB_MODULE_INDICATOR([reallocarray])	extensions realloc-gnu [test $HAVE_REALLOCARRAY = 0 \|\| test $REPLACE_REALLOCARRAY = 1] stdckdint [test $HAVE_REALLOCARRAY = 0 \|\| test $REPLACE_REALLOCARRAY = 1] stdlib
pagealign_alloc	#include "pagealign_alloc.h"	pagealign_alloc.c	mmap-anon.m4 pagealign_alloc.m4 00gnulib.m4 zzgnulib.m4 gl_PAGEALIGN_ALLOC	error extensions getpagesize gettext-h open stdlib xalloc unistd

Sorting functions <stdlib.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
array-mergesort	#include "array-mergesort.h"	---	00gnulib.m4 zzgnulib.m4	---
mpsort	#include "mpsort.h"	mpsort.c	mpsort.m4 00gnulib.m4 zzgnulib.m4 gl_MPSORT	---
qsort_r	#include <stdlib.h>	qsort.c qsort_r.c	qsort_r.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_QSORT_R dnl If the function is missing from the system or has an unknown signature: gl_CONDITIONAL([GL_COND_OBJ_QSORT], [test $HAVE_QSORT_R = 0]) dnl If the function exists, but it has the BSD signature: gl_CONDITIONAL([GL_COND_OBJ_QSORT_R], [test $HAVE_QSORT_R = 1 && test $REPLACE_QSORT_R = 1]) gl_STDLIB_MODULE_INDICATOR([qsort_r])	extensions stdlib

Date and time <time.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
fprintftime	#include "fprintftime.h"	fprintftime.c	00gnulib.m4 zzgnulib.m4	stdio nstrftime time_rz
nstrftime	#include "strftime.h"	nstrftime.c	tm_gmtoff.m4 nstrftime.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_GNU_STRFTIME	attribute c99 errno extensions intprops libc-config stdbool time_rz
strftime-fixes	#include <time.h>	strftime-fixes.c	strftime-fixes.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_STRFTIME gl_CONDITIONAL([GL_COND_OBJ_STRFTIME_FIXES], [test $REPLACE_STRFTIME = 1]) gl_TIME_MODULE_INDICATOR([strftime])	time-h
time	#include <time.h>	time.c	time.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_TIME gl_CONDITIONAL([GL_COND_OBJ_TIME], [test $REPLACE_TIME = 1]) AM_COND_IF([GL_COND_OBJ_TIME], [ gl_PREREQ_TIME ]) gl_TIME_MODULE_INDICATOR([time])	time-h gettimeofday [test $REPLACE_TIME = 1]
time-h	#include <time.h>	time.in.h	time_h.m4 00gnulib.m4 zzgnulib.m4 gl_TIME_H gl_TIME_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	extensions gen-header include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use stddef
time_rz	#include <time.h>	time-internal.h time_rz.c	time_rz.m4 00gnulib.m4 zzgnulib.m4 gl_TIME_RZ gl_CONDITIONAL([GL_COND_OBJ_TIME_RZ], [test $HAVE_TIMEZONE_T = 0]) gl_TIME_MODULE_INDICATOR([time_rz])	c99 extensions time-h flexmember [test $HAVE_TIMEZONE_T = 0] idx [test $HAVE_TIMEZONE_T = 0] setenv [test $HAVE_TIMEZONE_T = 0] stdbool [test $HAVE_TIMEZONE_T = 0] time_r [test $HAVE_TIMEZONE_T = 0] timegm [test $HAVE_TIMEZONE_T = 0] tzset [test $HAVE_TIMEZONE_T = 0] unsetenv [test $HAVE_TIMEZONE_T = 0]
year2038	---	---	00gnulib.m4 zzgnulib.m4	largefile
year2038-required	---	---	largefile.m4 00gnulib.m4 zzgnulib.m4	largefile-required

Extra functions based on ANSI C 89

Memory management functions <stdlib.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
aligned-malloc	#include "aligned-malloc.h"	---	malloc-align.m4 00gnulib.m4 zzgnulib.m4 gl_MALLOC_ALIGNMENT AC_REQUIRE([AC_C_INLINE]) AC_CHECK_FUNCS_ONCE([memalign]) gl_CHECK_FUNCS_ANDROID([aligned_alloc], [[#include ]]) gl_CHECK_FUNCS_ANDROID([posix_memalign], [[#include ]])	stdint posix_memalign aligned_alloc memalign
ialloc	#include "ialloc.h"	ialloc.c	00gnulib.m4 zzgnulib.m4	calloc-gnu extern-inline idx malloc-gnu realloc-gnu reallocarray stdint
idx	#include "idx.h"	---	00gnulib.m4 zzgnulib.m4	stdint
immutable	#include "immutable.h"	immutable.c	immutable.m4 mprotect.m4 mmap-anon.m4 nocrash.m4 00gnulib.m4 zzgnulib.m4 gl_IMMUTABLE	stdint pathmax open ssfmalloc
malloc-h	#include <malloc.h>	malloc.in.h	malloc_h.m4 00gnulib.m4 zzgnulib.m4 gl_MALLOC_H gl_MALLOC_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	gen-header include_next snippet/c++defs snippet/warn-on-use stddef stdlib
ssfmalloc	#include "ssfmalloc.h"	ssfmalloc-bitmap.h	00gnulib.m4 zzgnulib.m4	flexmember ffs ffsll lock thread-optim oset rbtree-oset
xsize	#include "xsize.h"	xsize.c	xsize.m4 00gnulib.m4 zzgnulib.m4 gl_XSIZE	attribute extern-inline size_max
xalloc	#include "xalloc.h"	xmalloc.c	xalloc.m4 00gnulib.m4 zzgnulib.m4 gl_XALLOC gl_MODULE_INDICATOR([xalloc])	c99 calloc-gnu extern-inline ialloc idx malloc-gnu minmax realloc-gnu reallocarray stdckdint stdint xalloc-die
xalloc-die	#include "xalloc.h"	xalloc-die.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([xalloc-die])	error extern-inline gettext-h exitfail
alignalloc	#include "alignalloc.h"	alignalloc.c	alignalloc.m4 00gnulib.m4 zzgnulib.m4 gl_ALIGNALLOC	alignasof assert-h extensions extern-inline idx posix_memalign stdckdint stdint
xalignalloc	#include "alignalloc.h"	xalignalloc.c	00gnulib.m4 zzgnulib.m4	alignalloc xalloc-die
alloca	#include <alloca.h>	alloca.c	00gnulib.m4 zzgnulib.m4	alloca-opt
alloca-opt	#include <alloca.h>	alloca.in.h	alloca.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ALLOCA gl_CONDITIONAL_HEADER([alloca.h]) AC_PROG_MKDIR_P	gen-header
malloca	#include "malloca.h"	malloca.c	malloca.m4 eealloc.m4 00gnulib.m4 zzgnulib.m4 gl_MALLOCA	alloca-opt assert-h idx stdckdint stdint xalloc-oversized
xmalloca	#include "xmalloca.h"	xmalloca.c	00gnulib.m4 zzgnulib.m4	malloca xalloc xalloc-oversized
xmemdup0	#include "xmemdup0.h"	xmemdup0.c	00gnulib.m4 zzgnulib.m4	xalloc
safe-alloc	#include "safe-alloc.h"	safe-alloc.c	safe-alloc.m4 00gnulib.m4 zzgnulib.m4 gl_SAFE_ALLOC	calloc-gnu extern-inline reallocarray

Integer arithmetic functions <stdlib.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
count-leading-zeros	#include "count-leading-zeros.h"	count-leading-zeros.c	00gnulib.m4 zzgnulib.m4	extern-inline verify
count-one-bits	#include "count-one-bits.h"	count-one-bits.c	00gnulib.m4 zzgnulib.m4	extern-inline
count-trailing-zeros	#include "count-trailing-zeros.h"	count-trailing-zeros.c	00gnulib.m4 zzgnulib.m4	extern-inline
ffs	#include <strings.h>	ffs.c	ffs.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FFS gl_CONDITIONAL([GL_COND_OBJ_FFS], [test $HAVE_FFS = 0]) gl_STRINGS_MODULE_INDICATOR([ffs])	strings
ffsl	#include <string.h>	ffsl.h ffsl.c	ffsl.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FFSL gl_CONDITIONAL([GL_COND_OBJ_FFSL], [test $HAVE_FFSL = 0]) gl_STRING_MODULE_INDICATOR([ffsl])	extensions string ffs [test $HAVE_FFSL = 0]
ffsll	#include <string.h>	ffsl.h ffsll.c	ffsll.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FFSLL gl_CONDITIONAL([GL_COND_OBJ_FFSLL], [test $HAVE_FFSLL = 0 \|\| test $REPLACE_FFSLL = 1]) gl_STRING_MODULE_INDICATOR([ffsll])	extensions string ffs [test $HAVE_FFSLL = 0 \|\| test $REPLACE_FFSLL = 1]
gcd	#include "gcd.h"	gcd.c	00gnulib.m4 zzgnulib.m4	---
minmax	#include "minmax.h"	---	minmax.m4 00gnulib.m4 zzgnulib.m4 gl_MINMAX	---

Environment variables <stdlib.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
putenv	#include <stdlib.h>	putenv.c	putenv.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_PUTENV gl_CONDITIONAL([GL_COND_OBJ_PUTENV], [test $REPLACE_PUTENV = 1]) AM_COND_IF([GL_COND_OBJ_PUTENV], [ gl_PREREQ_PUTENV ]) gl_STDLIB_MODULE_INDICATOR([putenv])	stdlib environ [test $REPLACE_PUTENV = 1] free-posix [test $REPLACE_PUTENV = 1] malloc-posix [test $REPLACE_PUTENV = 1]
secure_getenv	#include <stdlib.h>	secure_getenv.c	secure_getenv.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_SECURE_GETENV gl_CONDITIONAL([GL_COND_OBJ_SECURE_GETENV], [test $HAVE_SECURE_GETENV = 0]) AM_COND_IF([GL_COND_OBJ_SECURE_GETENV], [ gl_PREREQ_SECURE_GETENV ]) gl_STDLIB_MODULE_INDICATOR([secure_getenv])	stdlib extensions
setenv	#include <stdlib.h>	setenv.c	setenv.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_SETENV gl_CONDITIONAL([GL_COND_OBJ_SETENV], [test $HAVE_SETENV = 0 \|\| test $REPLACE_SETENV = 1]) gl_STDLIB_MODULE_INDICATOR([setenv])	stdlib malloca [test $HAVE_SETENV = 0 \|\| test $REPLACE_SETENV = 1] alloca-opt [test $HAVE_SETENV = 0 \|\| test $REPLACE_SETENV = 1] unistd [test $HAVE_SETENV = 0 \|\| test $REPLACE_SETENV = 1] environ [test $HAVE_SETENV = 0 \|\| test $REPLACE_SETENV = 1]
unsetenv	#include <stdlib.h>	unsetenv.c	setenv.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_UNSETENV gl_CONDITIONAL([GL_COND_OBJ_UNSETENV], [test $HAVE_UNSETENV = 0 \|\| test $REPLACE_UNSETENV = 1]) AM_COND_IF([GL_COND_OBJ_UNSETENV], [ gl_PREREQ_UNSETENV ]) gl_STDLIB_MODULE_INDICATOR([unsetenv])	stdlib unistd [test $HAVE_UNSETENV = 0 \|\| test $REPLACE_UNSETENV = 1] environ [test $HAVE_UNSETENV = 0 \|\| test $REPLACE_UNSETENV = 1]
xsetenv	#include "xsetenv.h"	xsetenv.c	00gnulib.m4 zzgnulib.m4	setenv unsetenv error gettext-h stdlib

Character handling <ctype.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
c-ctype	#include "c-ctype.h"	c-ctype.c	00gnulib.m4 zzgnulib.m4	extern-inline stdbool

String handling <string.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
bcopy	#include <strings.h>	bcopy.c	00gnulib.m4 zzgnulib.m4 AC_REPLACE_FUNCS(bcopy)	strings
explicit_bzero	#include <string.h>	explicit_bzero.c	explicit_bzero.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_EXPLICIT_BZERO gl_CONDITIONAL([GL_COND_OBJ_EXPLICIT_BZERO], [test $HAVE_EXPLICIT_BZERO = 0]) gl_STRING_MODULE_INDICATOR([explicit_bzero])	extensions memset_explicit string
memchr	#include <string.h>	memchr.c memchr.valgrind	memchr.m4 mmap-anon.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_MEMCHR gl_CONDITIONAL([GL_COND_OBJ_MEMCHR], [test $REPLACE_MEMCHR = 1]) AM_COND_IF([GL_COND_OBJ_MEMCHR], [ gl_PREREQ_MEMCHR ]) gl_STRING_MODULE_INDICATOR([memchr])	extensions string
memchr2	#include "memchr2.h"	memchr2.c memchr2.valgrind	00gnulib.m4 zzgnulib.m4	stdint memchr
memcmp2	#include "memcmp2.h"	memcmp2.c	00gnulib.m4 zzgnulib.m4	---
memmem	#include <string.h>	memmem.c	00gnulib.m4 zzgnulib.m4 gl_FUNC_MEMMEM if test $HAVE_MEMMEM = 0 \|\| test $REPLACE_MEMMEM = 1; then AC_LIBOBJ([memmem]) fi	memmem-simple
memmem-simple	#include <string.h>	str-two-way.h memmem.c	memmem.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_MEMMEM_SIMPLE if test $HAVE_MEMMEM = 0 \|\| test $REPLACE_MEMMEM = 1; then AC_LIBOBJ([memmem]) fi gl_STRING_MODULE_INDICATOR([memmem])	builtin-expect extensions string stdint memchr memcmp
mempcpy	#include <string.h>	mempcpy.c	mempcpy.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_MEMPCPY gl_CONDITIONAL([GL_COND_OBJ_MEMPCPY], [test $HAVE_MEMPCPY = 0 \|\| test $REPLACE_MEMPCPY = 1]) AM_COND_IF([GL_COND_OBJ_MEMPCPY], [ gl_PREREQ_MEMPCPY ]) gl_STRING_MODULE_INDICATOR([mempcpy])	extensions string
memrchr	#include <string.h>	memrchr.c	memrchr.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_MEMRCHR gl_CONDITIONAL([GL_COND_OBJ_MEMRCHR], [test $ac_cv_func_memrchr = no]) AM_COND_IF([GL_COND_OBJ_MEMRCHR], [ gl_PREREQ_MEMRCHR ]) gl_STRING_MODULE_INDICATOR([memrchr])	extensions string
amemxfrm	#include "amemxfrm.h"	amemxfrm.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_RESTRICT])	free-posix
rawmemchr	#include <string.h>	rawmemchr.c rawmemchr.valgrind	rawmemchr.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_RAWMEMCHR gl_CONDITIONAL([GL_COND_OBJ_RAWMEMCHR], [test $HAVE_RAWMEMCHR = 0]) AM_COND_IF([GL_COND_OBJ_RAWMEMCHR], [ gl_PREREQ_RAWMEMCHR ]) gl_STRING_MODULE_INDICATOR([rawmemchr])	alignasof assert-h extensions stdint string
stpcpy	#include <string.h>	stpcpy.c	stpcpy.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_STPCPY gl_CONDITIONAL([GL_COND_OBJ_STPCPY], [test $HAVE_STPCPY = 0 \|\| test $REPLACE_STPCPY = 1]) AM_COND_IF([GL_COND_OBJ_STPCPY], [ gl_PREREQ_STPCPY ]) gl_STRING_MODULE_INDICATOR([stpcpy])	extensions string
stpncpy	#include <string.h>	stpncpy.c	stpncpy.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_STPNCPY gl_CONDITIONAL([GL_COND_OBJ_STPNCPY], [test $HAVE_STPNCPY = 0 \|\| test $REPLACE_STPNCPY = 1]) AM_COND_IF([GL_COND_OBJ_STPNCPY], [ gl_PREREQ_STPNCPY ]) gl_STRING_MODULE_INDICATOR([stpncpy])	extensions string
c-strcase	#include "c-strcase.h"	c-strcasecmp.c c-strncasecmp.c	00gnulib.m4 zzgnulib.m4	c-ctype
strcase	#include <strings.h>	strcasecmp.c strncasecmp.c	strcase.m4 00gnulib.m4 zzgnulib.m4 gl_STRCASE gl_CONDITIONAL([GL_COND_OBJ_STRCASECMP], [test $HAVE_STRCASECMP = 0]) AM_COND_IF([GL_COND_OBJ_STRCASECMP], [ gl_PREREQ_STRCASECMP ]) gl_CONDITIONAL([GL_COND_OBJ_STRNCASECMP], [test $HAVE_STRNCASECMP = 0]) AM_COND_IF([GL_COND_OBJ_STRNCASECMP], [ gl_PREREQ_STRNCASECMP ])	strings
c-strcaseeq	#include "c-strcaseeq.h"	---	00gnulib.m4 zzgnulib.m4	c-strcase c-ctype
c-strcasestr	#include "c-strcasestr.h"	c-strcasestr.c str-two-way.h	00gnulib.m4 zzgnulib.m4	c-ctype c-strcase stdbool memchr memcmp
strcasestr	#include <string.h>	strcasestr.c	00gnulib.m4 zzgnulib.m4 gl_FUNC_STRCASESTR if test $HAVE_STRCASESTR = 0 \|\| test $REPLACE_STRCASESTR = 1; then AC_LIBOBJ([strcasestr]) gl_PREREQ_STRCASESTR fi	stdbool strcasestr-simple
strcasestr-simple	#include <string.h>	strcasestr.c str-two-way.h	strcasestr.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_STRCASESTR_SIMPLE if test $HAVE_STRCASESTR = 0 \|\| test $REPLACE_STRCASESTR = 1; then AC_LIBOBJ([strcasestr]) gl_PREREQ_STRCASESTR fi gl_STRING_MODULE_INDICATOR([strcasestr])	string stdbool strcase memchr memcmp extensions
strchrnul	#include <string.h>	strchrnul.c strchrnul.valgrind	strchrnul.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_STRCHRNUL gl_CONDITIONAL([GL_COND_OBJ_STRCHRNUL], [test $HAVE_STRCHRNUL = 0 \|\| test $REPLACE_STRCHRNUL = 1]) AM_COND_IF([GL_COND_OBJ_STRCHRNUL], [ gl_PREREQ_STRCHRNUL ]) gl_STRING_MODULE_INDICATOR([strchrnul])	string extensions rawmemchr [test $HAVE_STRCHRNUL = 0 \|\| test $REPLACE_STRCHRNUL = 1]
streq	#include "streq.h"	---	00gnulib.m4 zzgnulib.m4	---
strerrorname_np	#include <string.h>	strerrorname_np.c	strerrorname_np.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_STRERRORNAME_NP gl_CONDITIONAL([GL_COND_OBJ_STRERRORNAME_NP], [test $HAVE_STRERRORNAME_NP = 0 \|\| test $REPLACE_STRERRORNAME_NP = 1]) gl_STRING_MODULE_INDICATOR([strerrorname_np])	extensions string
strerror_r-posix	#include <string.h>	strerror_r.c	strerror_r.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_STRERROR_R AS_IF([test $HAVE_DECL_STRERROR_R = 0 \|\| test $REPLACE_STRERROR_R = 1], [ AC_LIBOBJ([strerror_r]) gl_PREREQ_STRERROR_R ]) gl_STRING_MODULE_INDICATOR([strerror_r]) dnl For the modules argp, error. gl_MODULE_INDICATOR([strerror_r-posix])	string extensions errno [test $HAVE_DECL_STRERROR_R = 0 \|\| test $REPLACE_STRERROR_R = 1] lock [test $HAVE_DECL_STRERROR_R = 0 \|\| test $REPLACE_STRERROR_R = 1] strerror-override [test $HAVE_DECL_STRERROR_R = 0 \|\| test $REPLACE_STRERROR_R = 1]
string-buffer	#include "string-buffer.h"	string-buffer.c	00gnulib.m4 zzgnulib.m4	stdbool attribute stdarg vsnprintf-posix
strnlen	#include <string.h>	strnlen.c	strnlen.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_STRNLEN gl_CONDITIONAL([GL_COND_OBJ_STRNLEN], [test $HAVE_DECL_STRNLEN = 0 \|\| test $REPLACE_STRNLEN = 1]) AM_COND_IF([GL_COND_OBJ_STRNLEN], [ gl_PREREQ_STRNLEN ]) gl_STRING_MODULE_INDICATOR([strnlen])	string extensions
strnlen1	#include "strnlen1.h"	strnlen1.c	00gnulib.m4 zzgnulib.m4	memchr
strndup	#include <string.h>	strndup.c	strndup.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_STRNDUP gl_CONDITIONAL([GL_COND_OBJ_STRNDUP], [test $HAVE_STRNDUP = 0 \|\| test $REPLACE_STRNDUP = 1]) gl_STRING_MODULE_INDICATOR([strndup])	string extensions strnlen [test $HAVE_STRNDUP = 0 \|\| test $REPLACE_STRNDUP = 1]
strsep	#include <string.h>	strsep.c	strsep.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_STRSEP gl_CONDITIONAL([GL_COND_OBJ_STRSEP], [test $HAVE_STRSEP = 0]) AM_COND_IF([GL_COND_OBJ_STRSEP], [ gl_PREREQ_STRSEP ]) gl_STRING_MODULE_INDICATOR([strsep])	string extensions strpbrk [test $HAVE_STRSEP = 0]
strstr	#include <string.h>	strstr.c	00gnulib.m4 zzgnulib.m4 gl_FUNC_STRSTR if test $REPLACE_STRSTR = 1; then AC_LIBOBJ([strstr]) fi	strstr-simple
strstr-simple	#include <string.h>	str-two-way.h strstr.c	strstr.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_STRSTR_SIMPLE if test $REPLACE_STRSTR = 1; then AC_LIBOBJ([strstr]) fi gl_STRING_MODULE_INDICATOR([strstr])	string builtin-expect [test $REPLACE_STRSTR = 1] stdbool [test $REPLACE_STRSTR = 1] memchr [test $REPLACE_STRSTR = 1] memcmp [test $REPLACE_STRSTR = 1]
c-strstr	#include "c-strstr.h"	c-strstr.c	00gnulib.m4 zzgnulib.m4	strstr
astrxfrm	#include "astrxfrm.h"	astrxfrm.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_RESTRICT])	free-posix
trim	#include "trim.h"	trim.c	00gnulib.m4 zzgnulib.m4	xalloc mbchar mbiter memmove strdup
fstrcmp	#include "fstrcmp.h"	fstrcmp.c	00gnulib.m4 zzgnulib.m4	c99 diffseq lock tls minmax stdint xalloc
xstrndup	#include "xstrndup.h"	xstrndup.c	xstrndup.m4 00gnulib.m4 zzgnulib.m4 gl_XSTRNDUP	strndup xalloc

Mathematics <math.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
printf-frexp	#include "printf-frexp.h"	printf-frexp.c	printf-frexp.m4 frexp.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_PRINTF_FREXP	---

Numeric conversion functions <stdlib.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
c-strtod	#include "c-strtod.h"	c-strtod.c	c-strtod.m4 intl-thread-locale.m4 00gnulib.m4 zzgnulib.m4 gl_C_STRTOD	c99 extensions locale strdup-posix strtod
c-strtold	#include "c-strtod.h"	c-strtod.c c-strtold.c	c-strtod.m4 intl-thread-locale.m4 00gnulib.m4 zzgnulib.m4 gl_C_STRTOLD	c99 extensions locale strdup-posix strtold
xstrtod	#include "xstrtod.h"	xstrtod.c	xstrtod.m4 00gnulib.m4 zzgnulib.m4 gl_XSTRTOD	stdbool
xstrtol	#include "xstrtol.h"	xstrtol.c xstrtoul.c	xstrtol.m4 00gnulib.m4 zzgnulib.m4 gl_XSTRTOL	assure intprops stdint
xstrtol-error	#include "xstrtol-error.h"	xstrtol-error.c	00gnulib.m4 zzgnulib.m4	xstrtol error exitfail getopt-gnu gettext-h
xstrtoll	#include "xstrtol.h"	xstrtoll.c xstrtoull.c	00gnulib.m4 zzgnulib.m4	limits-h strtoll strtoull xstrtol
xstrtold	#include "xstrtod.h"	xstrtod.c xstrtold.c	xstrtod.m4 00gnulib.m4 zzgnulib.m4 gl_XSTRTOLD	stdbool

Date and time <time.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
mktime-internal	#include "mktime-internal.h"	mktime.c	00gnulib.m4 zzgnulib.m4 gl_FUNC_MKTIME_INTERNAL if test $WANT_MKTIME_INTERNAL = 1; then AC_LIBOBJ([mktime]) gl_PREREQ_MKTIME fi	c99 mktime
parse-datetime	#include "parse-datetime.h"	parse-datetime.y	tm_gmtoff.m4 parse-datetime.m4 00gnulib.m4 zzgnulib.m4 gl_PARSE_DATETIME	assert-h bison c99 c-ctype stdbool gettime gettext-h idx intprops inttypes mktime nstrftime setenv unsetenv time-h time_r time_rz timegm
parse-datetime2	#include "parse-datetime.h"	---	00gnulib.m4 zzgnulib.m4 AC_DEFINE([GNULIB_PARSE_DATETIME2], [1], [Define to support parse_datetime2.])	parse-datetime
timegm	#include <time.h>	mktime-internal.h timegm.c	timegm.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_TIMEGM gl_CONDITIONAL([GL_COND_OBJ_TIMEGM], [test $HAVE_TIMEGM = 0 \|\| test $REPLACE_TIMEGM = 1]) AM_COND_IF([GL_COND_OBJ_TIMEGM], [ gl_PREREQ_TIMEGM ]) gl_TIME_MODULE_INDICATOR([timegm])	time-h mktime-internal [test $HAVE_TIMEGM = 0 \|\| test $REPLACE_TIMEGM = 1] time_r [test $HAVE_TIMEGM = 0 \|\| test $REPLACE_TIMEGM = 1]
tzset	#include <time.h>	tzset.c	tzset.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_TZSET gl_CONDITIONAL([GL_COND_OBJ_TZSET], [test $REPLACE_TZSET = 1]) gl_TIME_MODULE_INDICATOR([tzset])	time-h

Input/Output <stdio.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
unlocked-io	#include "unlocked-io.h"	---	00gnulib.m4 zzgnulib.m4 AC_DEFINE([GNULIB_STDIO_SINGLE_THREAD], [1], [Define to 1 if you want the FILE stream functions getc, putc, etc. to use unlocked I/O if available, throughout the package. Unlocked I/O can improve performance, sometimes dramatically. But unlocked I/O is safe only in single-threaded programs, as well as in multithreaded programs for which you can guarantee that every FILE stream, including stdin, stdout, stderr, is used only in a single thread.]) AC_DEFINE([USE_UNLOCKED_IO], [GNULIB_STDIO_SINGLE_THREAD], [An alias of GNULIB_STDIO_SINGLE_THREAD.])	unlocked-io-internal
unlocked-io-internal	#include "unlocked-io.h"	---	unlocked-io.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_GLIBC_UNLOCKED_IO	extensions
fwriteerror	#include "fwriteerror.h"	fwriteerror.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([fwriteerror])	errno stdbool
vasnprintf	#include "vasnprintf.h"	float+.h printf-args.h printf-args.c printf-parse.h printf-parse.c vasnprintf.c asnprintf.c	wchar_t.m4 wint_t.m4 intmax_t.m4 stdint_h.m4 inttypes_h.m4 vasnprintf.m4 printf.m4 math_h.m4 exponentd.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_RESTRICT]) gl_FUNC_VASNPRINTF	stdio alloca-opt attribute float free-posix limits-h stdint xsize errno memchr assert-h wchar
vasprintf	#include <stdio.h>	vasprintf.c asprintf.c	vasprintf.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_VASPRINTF gl_STDIO_MODULE_INDICATOR([vasprintf]) m4_ifdef([AM_XGETTEXT_OPTION], [AM_][XGETTEXT_OPTION([--flag=asprintf:2:c-format]) AM_][XGETTEXT_OPTION([--flag=vasprintf:2:c-format])])	stdio extensions vasnprintf [test $HAVE_VASPRINTF = 0 \|\| test $REPLACE_VASPRINTF = 1] errno [test $HAVE_VASPRINTF = 0 \|\| test $REPLACE_VASPRINTF = 1]
xprintf	#include "xprintf.h"	xprintf.c	00gnulib.m4 zzgnulib.m4 m4_ifdef([AM_XGETTEXT_OPTION], [AM_][XGETTEXT_OPTION([--flag=xprintf:1:c-format]) AM_][XGETTEXT_OPTION([--flag=xvprintf:1:c-format]) AM_][XGETTEXT_OPTION([--flag=xfprintf:2:c-format]) AM_][XGETTEXT_OPTION([--flag=xvfprintf:2:c-format])])	stdio error exitfail gettext-h stdarg
xvasprintf	#include "xvasprintf.h"	xvasprintf.c xasprintf.c xalloc.h	xvasprintf.m4 00gnulib.m4 zzgnulib.m4 gl_XVASPRINTF m4_ifdef([AM_XGETTEXT_OPTION], [AM_][XGETTEXT_OPTION([--flag=xasprintf:1:c-format])])	stdio vasprintf xalloc xalloc-die extern-inline xsize stdarg errno

Signal handling <signal.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
fatal-signal	#include "fatal-signal.h"	fatal-signal.c	fatal-signal.m4 sig_atomic_t.m4 00gnulib.m4 zzgnulib.m4 gl_FATAL_SIGNAL	c99 stdbool unistd sigaction lock thread-optim sigprocmask raise
raise	#include <signal.h>	raise.c	raise.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_RAISE gl_CONDITIONAL([GL_COND_OBJ_RAISE], [test $HAVE_RAISE = 0 \|\| test $REPLACE_RAISE = 1]) AM_COND_IF([GL_COND_OBJ_RAISE], [ gl_PREREQ_RAISE ]) gl_SIGNAL_MODULE_INDICATOR([raise])	signal-h msvc-inval [test $HAVE_RAISE = 0 \|\| test $REPLACE_RAISE = 1]
sigabbrev_np	#include <string.h>	sigabbrev_np.c	sigabbrev_np.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_SIGABBREV_NP gl_CONDITIONAL([GL_COND_OBJ_SIGABBREV_NP], [test $HAVE_SIGABBREV_NP = 0]) gl_STRING_MODULE_INDICATOR([sigabbrev_np])	extensions string
sigdescr_np	#include <string.h>	sigdescr_np.c	sigdescr_np.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_SIGDESCR_NP gl_CONDITIONAL([GL_COND_OBJ_SIGDESCR_NP], [test $HAVE_SIGDESCR_NP = 0]) gl_STRING_MODULE_INDICATOR([sigdescr_np])	extensions string
strsignal	#include <string.h>	strsignal.c siglist.h	strsignal.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_STRSIGNAL gl_CONDITIONAL([GL_COND_OBJ_STRSIGNAL], [test $HAVE_STRSIGNAL = 0 \|\| test $REPLACE_STRSIGNAL = 1]) AM_COND_IF([GL_COND_OBJ_STRSIGNAL], [ gl_PREREQ_STRSIGNAL ]) gl_STRING_MODULE_INDICATOR([strsignal])	string extensions gettext-h [test $HAVE_STRSIGNAL = 0 \|\| test $REPLACE_STRSIGNAL = 1] lock [test $HAVE_STRSIGNAL = 0 \|\| test $REPLACE_STRSIGNAL = 1] tls [test $HAVE_STRSIGNAL = 0 \|\| test $REPLACE_STRSIGNAL = 1] snprintf [test $HAVE_STRSIGNAL = 0 \|\| test $REPLACE_STRSIGNAL = 1] memset [test $HAVE_STRSIGNAL = 0 \|\| test $REPLACE_STRSIGNAL = 1]

Wide-character string handling <wchar.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
wmempcpy	#include <wchar.h>	wmempcpy.c	wmempcpy.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_WMEMPCPY gl_CONDITIONAL([GL_COND_OBJ_WMEMPCPY], [test $HAVE_WMEMPCPY = 0 \|\| test $REPLACE_WMEMPCPY = 1]) gl_WCHAR_MODULE_INDICATOR([wmempcpy])	wchar

Command-line arguments

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
argmatch	#include "argmatch.h"	argmatch.c	00gnulib.m4 zzgnulib.m4	assert-h c99 error exitfail getprogname gettext-h memcmp quote quotearg stdbool stdlib
argv-iter	#include "argv-iter.h"	argv-iter.c	00gnulib.m4 zzgnulib.m4	getdelim snippet/arg-nonnull stdbool
version-etc	#include "version-etc.h"	version-etc.c	version-etc.m4 00gnulib.m4 zzgnulib.m4 gl_VERSION_ETC	gettext-h stdarg
version-etc-fsf	---	version-etc-fsf.c	00gnulib.m4 zzgnulib.m4	version-etc
long-options	#include "long-options.h"	long-options.c	00gnulib.m4 zzgnulib.m4	c99 exitfail getopt-gnu stdbool stdlib version-etc

Container data structures

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
list	#include "gl_list.h"	gl_list.c	00gnulib.m4 zzgnulib.m4	extern-inline stdbool
xlist	#include "gl_xlist.h"	gl_xlist.c	00gnulib.m4 zzgnulib.m4	list extern-inline stdbool xalloc-die
array-list	#include "gl_array_list.h"	gl_array_list.c	00gnulib.m4 zzgnulib.m4	list stdint xsize
carray-list	#include "gl_carray_list.h"	gl_carray_list.c	00gnulib.m4 zzgnulib.m4	list stdint xsize
linked-list	#include "gl_linked_list.h"	gl_linked_list.c gl_anylinked_list1.h gl_anylinked_list2.h	00gnulib.m4 zzgnulib.m4	list
avltree-list	#include "gl_avltree_list.h"	gl_avltree_list.c gl_anyavltree_list1.h gl_anyavltree_list2.h gl_anytree_list1.h gl_anytree_list2.h	00gnulib.m4 zzgnulib.m4	list
rbtree-list	#include "gl_rbtree_list.h"	gl_rbtree_list.c gl_anyrbtree_list1.h gl_anyrbtree_list2.h gl_anytree_list1.h gl_anytree_list2.h	00gnulib.m4 zzgnulib.m4	list
linkedhash-list	#include "gl_linkedhash_list.h"	gl_linkedhash_list.c gl_anyhash1.h gl_anyhash2.h gl_anyhash_primes.h gl_anylinked_list1.h gl_anylinked_list2.h	00gnulib.m4 zzgnulib.m4	list stdint xsize
avltreehash-list	#include "gl_avltreehash_list.h"	gl_avltreehash_list.c gl_anyhash1.h gl_anyhash2.h gl_anyhash_primes.h gl_anyavltree_list1.h gl_anyavltree_list2.h gl_anytree_list1.h gl_anytree_list2.h gl_anytreehash_list1.h gl_anytreehash_list2.h	00gnulib.m4 zzgnulib.m4	builtin-expect list avltree-oset stdint xsize
rbtreehash-list	#include "gl_rbtreehash_list.h"	gl_rbtreehash_list.c gl_anyhash1.h gl_anyhash2.h gl_anyhash_primes.h gl_anyrbtree_list1.h gl_anyrbtree_list2.h gl_anytree_list1.h gl_anytree_list2.h gl_anytreehash_list1.h gl_anytreehash_list2.h	00gnulib.m4 zzgnulib.m4	builtin-expect list rbtree-oset stdint xsize
sublist	#include "gl_sublist.h"	gl_sublist.c	00gnulib.m4 zzgnulib.m4	list stdint
xsublist	#include "gl_xsublist.h"	gl_xsublist.c	00gnulib.m4 zzgnulib.m4	sublist extern-inline xalloc-die
oset	#include "gl_oset.h"	gl_oset.c	00gnulib.m4 zzgnulib.m4	extern-inline stdbool
xoset	#include "gl_xoset.h"	gl_xoset.c	00gnulib.m4 zzgnulib.m4	oset extern-inline stdbool xalloc-die
array-oset	#include "gl_array_oset.h"	gl_array_oset.c	00gnulib.m4 zzgnulib.m4	oset xsize
avltree-oset	#include "gl_avltree_oset.h"	gl_avltree_oset.c gl_avltree_ordered.h gl_anytree_oset.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE])	oset
rbtree-oset	#include "gl_rbtree_oset.h"	gl_rbtree_oset.c gl_rbtree_ordered.h gl_anytree_oset.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE])	oset
stack	#include "stack.h"	---	00gnulib.m4 zzgnulib.m4	assure stdbool stdlib xalloc

Cryptographic computations (low-level)

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
crypto/arcfour	#include "arcfour.h"	arcfour.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_RESTRICT])	stdint
crypto/arctwo	#include "arctwo.h"	arctwo.c	arctwo.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_RESTRICT]) gl_ARCTWO	stdint bitrotate
crypto/des	#include "des.h"	des.c	00gnulib.m4 zzgnulib.m4	stdint stdbool memcmp
crypto/hmac-md5	#include "hmac.h"	hmac.c hmac-md5.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_RESTRICT])	memxor crypto/md5
crypto/hmac-sha1	#include "hmac.h"	hmac.c hmac-sha1.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_RESTRICT])	memxor crypto/sha1
crypto/md2	#include "md2.h"	md2-stream.c	00gnulib.m4 zzgnulib.m4	crypto/md2-buffer
crypto/md2-buffer	#include "md2.h"	md2.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_RESTRICT])	minmax
crypto/md4	#include "md4.h"	md4-stream.c	00gnulib.m4 zzgnulib.m4	crypto/md4-buffer
crypto/md4-buffer	#include "md4.h"	md4.c	md4.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_RESTRICT]) gl_MD4	alignasof byteswap stdint
crypto/md5	#include "md5.h"	md5-stream.c	00gnulib.m4 zzgnulib.m4	crypto/af_alg crypto/md5-buffer
crypto/md5-buffer	#include "md5.h"	gl_openssl.h md5.c	gl-openssl.m4 md5.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_RESTRICT]) gl_MD5	alignasof byteswap c99 extern-inline stdint
crypto/rijndael	#include "rijndael-alg-fst.h" #include "rijndael-api-fst.h"	rijndael-alg-fst.c rijndael-alg-fst.h rijndael-api-fst.c rijndael-api-fst.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_RESTRICT])	stdint
crypto/sha1	#include "sha1.h"	sha1-stream.c	00gnulib.m4 zzgnulib.m4	crypto/af_alg crypto/sha1-buffer
crypto/sha1-buffer	#include "sha1.h"	gl_openssl.h sha1.c	gl-openssl.m4 sha1.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_RESTRICT]) gl_SHA1	alignasof byteswap c99 extern-inline stdint
crypto/sha256	#include "sha256.h"	sha256-stream.c	00gnulib.m4 zzgnulib.m4	crypto/af_alg crypto/sha256-buffer
crypto/sha256-buffer	#include "sha256.h"	gl_openssl.h sha256.c	gl-openssl.m4 sha256.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_RESTRICT]) gl_SHA256	alignasof byteswap c99 extern-inline stdint
crypto/sha512	#include "sha512.h"	sha512-stream.c	00gnulib.m4 zzgnulib.m4	crypto/af_alg crypto/sha512-buffer
crypto/sha512-buffer	#include "sha512.h"	gl_openssl.h sha512.c	gl-openssl.m4 sha512.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_RESTRICT]) gl_SHA512	alignasof byteswap c99 extern-inline stdint u64
crypto/sm3	#include "sm3.h"	sm3-stream.c	00gnulib.m4 zzgnulib.m4	crypto/sm3-buffer
crypto/sm3-buffer	#include "sm3.h"	sm3.c	sm3.m4 00gnulib.m4 zzgnulib.m4 gl_SM3	alignasof byteswap c99 extern-inline stdint

Cryptographic computations (high-level)

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
crypto/gc	#include "gc.h"	gc-libgcrypt.c gc-gnulib.c	gc.m4 libgcrypt.m4 00gnulib.m4 zzgnulib.m4 gl_GC gl_CONDITIONAL([GL_COND_OBJ_GC_LIBGCRYPT], [test "$ac_cv_libgcrypt" = yes]) if test $gl_cond_libtool = false; then gl_ltlibdeps="$gl_ltlibdeps $LTLIBGCRYPT" gl_libdeps="$gl_libdeps $LIBGCRYPT" fi	havelib open
crypto/gc-arcfour	#include "gc.h"	---	gc-arcfour.m4 00gnulib.m4 zzgnulib.m4 gl_GC_ARCFOUR gl_MODULE_INDICATOR([gc-arcfour])	crypto/gc crypto/arcfour [test "$ac_cv_libgcrypt" != yes]
crypto/gc-arctwo	#include "gc.h"	---	gc-arctwo.m4 00gnulib.m4 zzgnulib.m4 gl_GC_ARCTWO gl_MODULE_INDICATOR([gc-arctwo])	crypto/gc crypto/arctwo [test "$ac_cv_libgcrypt" != yes]
crypto/gc-camellia	#include "gc.h"	---	gc-camellia.m4 00gnulib.m4 zzgnulib.m4 gl_GC_CAMELLIA	crypto/gc
crypto/gc-des	#include "gc.h"	---	gc-des.m4 00gnulib.m4 zzgnulib.m4 gl_GC_DES gl_MODULE_INDICATOR([gc-des])	crypto/gc crypto/des [test "$ac_cv_libgcrypt" != yes]
crypto/gc-hmac-md5	#include "gc.h"	---	gc-hmac-md5.m4 00gnulib.m4 zzgnulib.m4 gl_GC_HMAC_MD5 gl_MODULE_INDICATOR([gc-hmac-md5])	crypto/gc crypto/hmac-md5 [test "$ac_cv_libgcrypt" != yes]
crypto/gc-hmac-sha1	#include "gc.h"	---	gc-hmac-sha1.m4 00gnulib.m4 zzgnulib.m4 gl_GC_HMAC_SHA1 gl_MODULE_INDICATOR([gc-hmac-sha1])	crypto/gc crypto/hmac-sha1 [test "$ac_cv_libgcrypt" != yes]
crypto/gc-md2	#include "gc.h"	---	gc-md2.m4 00gnulib.m4 zzgnulib.m4 gl_GC_MD2 gl_MODULE_INDICATOR([gc-md2])	crypto/gc crypto/md2
crypto/gc-md4	#include "gc.h"	---	gc-md4.m4 00gnulib.m4 zzgnulib.m4 gl_GC_MD4 gl_MODULE_INDICATOR([gc-md4])	crypto/gc crypto/md4 [test "$ac_cv_libgcrypt" != yes]
crypto/gc-md5	#include "gc.h"	---	gc-md5.m4 00gnulib.m4 zzgnulib.m4 gl_GC_MD5 gl_MODULE_INDICATOR([gc-md5])	crypto/gc crypto/md5 [test "$ac_cv_libgcrypt" != yes]
crypto/gc-pbkdf2	#include "gc.h"	gc-pbkdf2.c	00gnulib.m4 zzgnulib.m4	crypto/gc
crypto/gc-pbkdf2-sha1	#include "gc.h"	gc-pbkdf2-sha1.c	00gnulib.m4 zzgnulib.m4	crypto/gc-pbkdf2 crypto/gc-hmac-sha1
crypto/gc-random	#include "gc.h"	---	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([gc-random])	crypto/gc getrandom [test "$ac_cv_libgcrypt" != yes]
crypto/gc-rijndael	#include "gc.h"	---	gc-rijndael.m4 00gnulib.m4 zzgnulib.m4 gl_GC_RIJNDAEL gl_MODULE_INDICATOR([gc-rijndael])	crypto/gc crypto/rijndael [test "$ac_cv_libgcrypt" != yes]
crypto/gc-sha1	#include "gc.h"	---	gc-sha1.m4 00gnulib.m4 zzgnulib.m4 gl_GC_SHA1 gl_MODULE_INDICATOR([gc-sha1])	crypto/gc crypto/sha1 [test "$ac_cv_libgcrypt" != yes]
crypto/gc-sm3	#include "gc.h"	---	gc-sm3.m4 00gnulib.m4 zzgnulib.m4 gl_GC_SM3 gl_MODULE_INDICATOR([gc-sm3])	crypto/gc crypto/sm3 [test "$ac_cv_libgcrypt" != yes]

Compiler warning management

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
ignore-value	#include "ignore-value.h"	---	00gnulib.m4 zzgnulib.m4	---

Misc

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
base32	#include "base32.h"	base32.c	base32.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_BASE32	ialloc stdbool memchr
base64	#include "base64.h"	base64.c	base64.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_BASE64	ialloc stdbool memchr
check-version	#include "check-version.h"	check-version.c	00gnulib.m4 zzgnulib.m4	strverscmp
crc	#include "crc.h"	crc.c	00gnulib.m4 zzgnulib.m4	stdint
diffseq	#include "diffseq.h"	---	00gnulib.m4 zzgnulib.m4	c99 stdbool
execinfo	#include <execinfo.h>	execinfo.c execinfo.in.h	execinfo.m4 00gnulib.m4 zzgnulib.m4 gl_EXECINFO_H gl_CONDITIONAL_HEADER([execinfo.h]) AC_PROG_MKDIR_P gl_CONDITIONAL([GL_COND_OBJ_EXECINFO], [$GL_GENERATE_EXECINFO_H])	extern-inline gen-header
getline	#include <stdio.h>	getline.c	getline.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_GETLINE gl_CONDITIONAL([GL_COND_OBJ_GETLINE], [test $REPLACE_GETLINE = 1]) AM_COND_IF([GL_COND_OBJ_GETLINE], [ gl_PREREQ_GETLINE ]) gl_STDIO_MODULE_INDICATOR([getline])	stdio extensions getdelim [test $REPLACE_GETLINE = 1]
getdelim	#include <stdio.h>	getdelim.c	getdelim.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_GETDELIM gl_CONDITIONAL([GL_COND_OBJ_GETDELIM], [test $HAVE_GETDELIM = 0 \|\| test $REPLACE_GETDELIM = 1]) AM_COND_IF([GL_COND_OBJ_GETDELIM], [ gl_PREREQ_GETDELIM ]) gl_STDIO_MODULE_INDICATOR([getdelim])	stdio extensions stdint [test $HAVE_GETDELIM = 0 \|\| test $REPLACE_GETDELIM = 1] errno [test $HAVE_GETDELIM = 0 \|\| test $REPLACE_GETDELIM = 1]
getnline	#include "getnline.h"	getnline.c	getnline.m4 00gnulib.m4 zzgnulib.m4 gl_GETNLINE	getndelim2 ssize_t
getndelim2	#include "getndelim2.h"	getndelim2.c	getndelim2.m4 00gnulib.m4 zzgnulib.m4 gl_GETNDELIM2	ssize_t stdbool stdint freadptr freadseek memchr2
linebuffer	#include "linebuffer.h"	linebuffer.c	00gnulib.m4 zzgnulib.m4	idx xalloc
memxor	#include "memxor.h"	memxor.c	memxor.m4 00gnulib.m4 zzgnulib.m4 gl_MEMXOR	---
obstack	#include "obstack.h"	obstack.c	obstack.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_OBSTACK gl_CONDITIONAL([GL_COND_OBJ_OBSTACK], [test "$gl_cv_func_obstack" != yes])	alignof gettext-h exitfail stdint stdlib
obstack-printf	#include <stdio.h>	obstack_printf.c	obstack-printf.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_OBSTACK_PRINTF if test $ac_cv_func_obstack_printf = no \|\| test $REPLACE_OBSTACK_PRINTF = 1; then AC_LIBOBJ([obstack_printf]) fi gl_STDIO_MODULE_INDICATOR([obstack-printf])	obstack stdio vasnprintf extensions
obstack-printf-posix	#include <stdio.h>	obstack_printf.c	obstack-printf.m4 obstack-printf-posix.m4 math_h.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_OBSTACK_PRINTF_POSIX if test $ac_cv_func_obstack_printf = no \|\| test $REPLACE_OBSTACK_PRINTF = 1; then AC_LIBOBJ([obstack_printf]) fi gl_STDIO_MODULE_INDICATOR([obstack-printf-posix])	obstack stdio vasnprintf-posix extensions
hash-pjw	#include "hash-pjw.h"	hash-pjw.c	00gnulib.m4 zzgnulib.m4	---
hash-pjw-bare	#include "hash-pjw-bare.h"	hash-pjw-bare.c	00gnulib.m4 zzgnulib.m4	---
hash	#include "hash.h"	hash.c	00gnulib.m4 zzgnulib.m4	bitrotate stdbool stdint xalloc-oversized
hamt	#include "hamt.h"	hamt.c	00gnulib.m4 zzgnulib.m4	count-one-bits extern-inline flexmember inttypes-incomplete stdbool stdint verify xalloc
readline	#include "readline.h"	readline.c	readline.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_READLINE gl_CONDITIONAL([GL_COND_OBJ_READLINE], [test "$gl_cv_lib_readline" = no]) AM_COND_IF([GL_COND_OBJ_READLINE], [ gl_PREREQ_READLINE ])	havelib getline [test "$gl_cv_lib_readline" = no]
readtokens	#include "readtokens.h"	readtokens.c	readtokens.m4 00gnulib.m4 zzgnulib.m4 gl_READTOKENS	xalloc stdbool
readtokens0	#include "readtokens0.h"	readtokens0.c	00gnulib.m4 zzgnulib.m4	obstack stdbool
stack	#include "stack.h"	---	00gnulib.m4 zzgnulib.m4	assure stdbool stdlib xalloc
strverscmp	#include <string.h>	strverscmp.c	strverscmp.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_STRVERSCMP gl_CONDITIONAL([GL_COND_OBJ_STRVERSCMP], [test $HAVE_STRVERSCMP = 0]) AM_COND_IF([GL_COND_OBJ_STRVERSCMP], [ gl_PREREQ_STRVERSCMP ]) gl_STRING_MODULE_INDICATOR([strverscmp])	extensions libc-config [test $HAVE_STRVERSCMP = 0] stdint [test $HAVE_STRVERSCMP = 0] string
filevercmp	#include "filevercmp.h"	filevercmp.c	00gnulib.m4 zzgnulib.m4	assert-h c-ctype idx stdbool

Support for systems lacking ISO C 99

Core language properties

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
alignof	#include "alignof.h"	---	00gnulib.m4 zzgnulib.m4	alignasof
c99	---	---	00gnulib.m4 zzgnulib.m4	std-gnu11
flexmember	#include "flexmember.h"	---	flexmember.m4 00gnulib.m4 zzgnulib.m4 AC_C_FLEXIBLE_ARRAY_MEMBER	---
fpucw	#include "fpucw.h"	---	00gnulib.m4 zzgnulib.m4	---
func	---	---	func.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC	---
inline	---	---	inline.m4 00gnulib.m4 zzgnulib.m4 gl_INLINE	---
longlong	---	---	longlong.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_TYPE_LONG_LONG_INT]) AC_REQUIRE([AC_TYPE_UNSIGNED_LONG_LONG_INT])	---
snippet/unused-parameter	---	unused-parameter.h	00gnulib.m4 zzgnulib.m4	---
va-args	---	---	va-args.m4 00gnulib.m4 zzgnulib.m4 gl_VA_ARGS	---
vararrays	---	---	vararrays.m4 00gnulib.m4 zzgnulib.m4 AC_C_VARARRAYS	---
vla	---	vla.h	00gnulib.m4 zzgnulib.m4	vararrays

Variable arguments <stdarg.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
stdarg	#include <stdarg.h>	stdarg.in.h	stdarg.m4 00gnulib.m4 zzgnulib.m4 gl_STDARG_H gl_CONDITIONAL_HEADER([stdarg.h]) AC_PROG_MKDIR_P	gen-header include_next

Boolean type and values <stdbool.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
stdbool	---	---	c-bool.m4 00gnulib.m4 zzgnulib.m4 gl_C_BOOL	c99

Basic types <stddef.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
stddef	#include <stddef.h>	stddef.in.h	stddef_h.m4 wchar_t.m4 00gnulib.m4 zzgnulib.m4 gl_STDDEF_H gl_STDDEF_H_REQUIRE_DEFAULTS gl_CONDITIONAL_HEADER([stddef.h]) AC_PROG_MKDIR_P	gen-header include_next extensions

Integer types and values <stdint.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
size_max	#include "size_max.h"	---	size_max.m4 00gnulib.m4 zzgnulib.m4 gl_SIZE_MAX	---
stdint	#include <stdint.h>	stdint.in.h	stdint.m4 wint_t.m4 00gnulib.m4 zzgnulib.m4 gl_STDINT_H gl_CONDITIONAL_HEADER([stdint.h]) dnl Because of gl_REPLACE_LIMITS_H: gl_CONDITIONAL_HEADER([limits.h]) AC_PROG_MKDIR_P	gen-header include_next limits-h multiarch sys_types

Input/output <stdio.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
stdio	#include <stdio.h>	stdio.in.h stdio-read.c stdio-write.c	stdio_h.m4 musl.m4 00gnulib.m4 zzgnulib.m4 gl_STDIO_H gl_STDIO_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P gl_CONDITIONAL([GL_COND_OBJ_STDIO_READ], [test $REPLACE_STDIO_READ_FUNCS = 1]) gl_CONDITIONAL([GL_COND_OBJ_STDIO_WRITE], [test $REPLACE_STDIO_WRITE_FUNCS = 1]) dnl No need to create extra modules for these functions. Everyone who uses dnl likely needs them. gl_STDIO_MODULE_INDICATOR([fscanf]) gl_MODULE_INDICATOR([fscanf]) gl_STDIO_MODULE_INDICATOR([scanf]) gl_MODULE_INDICATOR([scanf]) gl_STDIO_MODULE_INDICATOR([fgetc]) gl_STDIO_MODULE_INDICATOR([getc]) gl_STDIO_MODULE_INDICATOR([getchar]) gl_STDIO_MODULE_INDICATOR([fgets]) gl_STDIO_MODULE_INDICATOR([fread]) dnl No need to create extra modules for these functions. Everyone who uses dnl likely needs them. gl_STDIO_MODULE_INDICATOR([fprintf]) gl_STDIO_MODULE_INDICATOR([printf]) gl_STDIO_MODULE_INDICATOR([vfprintf]) gl_STDIO_MODULE_INDICATOR([vprintf]) gl_STDIO_MODULE_INDICATOR([fputc]) gl_STDIO_MODULE_INDICATOR([putc]) gl_STDIO_MODULE_INDICATOR([putchar]) gl_STDIO_MODULE_INDICATOR([fputs]) gl_STDIO_MODULE_INDICATOR([puts]) gl_STDIO_MODULE_INDICATOR([fwrite])	extensions gen-header include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use ssize_t stddef sys_types
snprintf	#include <stdio.h>	snprintf.c	snprintf.m4 printf.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_SNPRINTF gl_STDIO_MODULE_INDICATOR([snprintf]) gl_MODULE_INDICATOR([snprintf])	stdio vasnprintf [test $ac_cv_func_snprintf = no \|\| test $REPLACE_SNPRINTF = 1] errno [test $ac_cv_func_snprintf = no \|\| test $REPLACE_SNPRINTF = 1]
vsnprintf	#include <stdio.h>	vsnprintf.c	vsnprintf.m4 printf.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_VSNPRINTF gl_STDIO_MODULE_INDICATOR([vsnprintf])	stdio vasnprintf [test $ac_cv_func_vsnprintf = no \|\| test $REPLACE_VSNPRINTF = 1] errno [test $ac_cv_func_vsnprintf = no \|\| test $REPLACE_VSNPRINTF = 1]

Process control, Numeric conversion functions <stdlib.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
_Exit	#include <stdlib.h>	_Exit.c	_Exit.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC__EXIT gl_CONDITIONAL([GL_COND_OBJ__EXIT], [test $HAVE__EXIT = 0 \|\| test $REPLACE__EXIT = 1]) AM_COND_IF([GL_COND_OBJ__EXIT], [ gl_PREREQ__EXIT ]) gl_STDLIB_MODULE_INDICATOR([_Exit])	stdlib unistd
atoll	#include <stdlib.h>	atoll.c	atoll.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ATOLL gl_CONDITIONAL([GL_COND_OBJ_ATOLL], [test $HAVE_ATOLL = 0]) AM_COND_IF([GL_COND_OBJ_ATOLL], [ gl_PREREQ_ATOLL ]) gl_STDLIB_MODULE_INDICATOR([atoll])	strtoll [test $HAVE_ATOLL = 0]
strtoll	#include <stdlib.h>	strtol.c strtoll.c	strtoll.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_STRTOLL gl_CONDITIONAL([GL_COND_OBJ_STRTOLL], [test $HAVE_STRTOLL = 0 \|\| test $REPLACE_STRTOLL = 1]) AM_COND_IF([GL_COND_OBJ_STRTOLL], [ gl_PREREQ_STRTOLL ]) gl_STDLIB_MODULE_INDICATOR([strtoll])	limits-h stdlib
strtoull	#include <stdlib.h>	strtol.c strtoul.c strtoull.c	strtoull.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_STRTOULL gl_CONDITIONAL([GL_COND_OBJ_STRTOULL], [test $HAVE_STRTOULL = 0 \|\| test $REPLACE_STRTOULL = 1]) AM_COND_IF([GL_COND_OBJ_STRTOULL], [ gl_PREREQ_STRTOULL ]) gl_STDLIB_MODULE_INDICATOR([strtoull])	limits-h stdlib

Unibyte characters <ctype.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
ctype	#include <ctype.h>	ctype.in.h	ctype_h.m4 00gnulib.m4 zzgnulib.m4 gl_CTYPE_H gl_CTYPE_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	extern-inline gen-header include_next snippet/c++defs snippet/warn-on-use

Functions for greatest-width integer types <inttypes.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
imaxabs	#include <inttypes.h>	imaxabs.c	imaxabs.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_IMAXABS gl_CONDITIONAL([GL_COND_OBJ_IMAXABS], [test $HAVE_IMAXABS = 0 \|\| test $REPLACE_IMAXABS = 1]) AM_COND_IF([GL_COND_OBJ_IMAXABS], [ gl_PREREQ_IMAXABS ]) gl_INTTYPES_MODULE_INDICATOR([imaxabs])	inttypes-incomplete
imaxdiv	#include <inttypes.h>	imaxdiv.c	imaxdiv.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_IMAXDIV gl_CONDITIONAL([GL_COND_OBJ_IMAXDIV], [test $HAVE_IMAXDIV = 0 \|\| test $REPLACE_IMAXDIV = 1]) AM_COND_IF([GL_COND_OBJ_IMAXDIV], [ gl_PREREQ_IMAXDIV ]) gl_INTTYPES_MODULE_INDICATOR([imaxdiv])	inttypes-incomplete
inttypes	#include <inttypes.h>	---	00gnulib.m4 zzgnulib.m4 gl_INTTYPES_H	inttypes-incomplete extensions
strtoimax	#include <inttypes.h>	strtoimax.c	strtoimax.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_STRTOIMAX gl_CONDITIONAL([GL_COND_OBJ_STRTOIMAX], [test $HAVE_DECL_STRTOIMAX = 0 \|\| test $REPLACE_STRTOIMAX = 1]) AM_COND_IF([GL_COND_OBJ_STRTOIMAX], [ gl_PREREQ_STRTOIMAX ]) gl_INTTYPES_MODULE_INDICATOR([strtoimax])	inttypes-incomplete assert-h [test $HAVE_DECL_STRTOIMAX = 0 \|\| test $REPLACE_STRTOIMAX = 1] stdint [test $HAVE_DECL_STRTOIMAX = 0 \|\| test $REPLACE_STRTOIMAX = 1] strtoll [{ test $HAVE_DECL_STRTOIMAX = 0 \|\| test $REPLACE_STRTOIMAX = 1; } && test $ac_cv_type_long_long_int = yes]
strtoumax	#include <inttypes.h>	strtoimax.c strtoumax.c	strtoumax.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_STRTOUMAX gl_CONDITIONAL([GL_COND_OBJ_STRTOUMAX], [test $HAVE_DECL_STRTOUMAX = 0 \|\| test $REPLACE_STRTOUMAX = 1]) AM_COND_IF([GL_COND_OBJ_STRTOUMAX], [ gl_PREREQ_STRTOUMAX ]) gl_INTTYPES_MODULE_INDICATOR([strtoumax])	inttypes-incomplete assert-h [test $HAVE_DECL_STRTOUMAX = 0 \|\| test $REPLACE_STRTOUMAX = 1] stdint [test $HAVE_DECL_STRTOUMAX = 0 \|\| test $REPLACE_STRTOUMAX = 1] strtoull [{ test $HAVE_DECL_STRTOUMAX = 0 \|\| test $REPLACE_STRTOUMAX = 1; } && test $ac_cv_type_unsigned_long_long_int = yes]

String handling <string.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
strncat	#include <string.h>	strncat.c	strncat.m4 mmap-anon.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_STRNCAT gl_CONDITIONAL([GL_COND_OBJ_STRNCAT], [test $REPLACE_STRNCAT = 1]) AM_COND_IF([GL_COND_OBJ_STRNCAT], [ gl_PREREQ_STRNCAT ]) gl_STRING_MODULE_INDICATOR([strncat])	string

Extended multibyte and wide character utilities <wchar.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
wchar	#include <wchar.h>	wchar.in.h	wchar_h.m4 wint_t.m4 00gnulib.m4 zzgnulib.m4 gl_WCHAR_H gl_WCHAR_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	gen-header include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use inttypes-incomplete stddef stdlib
btowc	#include <wchar.h>	btowc.c	btowc.m4 mbrtowc.m4 locale-fr.m4 codeset.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_BTOWC gl_CONDITIONAL([GL_COND_OBJ_BTOWC], [test $HAVE_BTOWC = 0 \|\| test $REPLACE_BTOWC = 1]) AM_COND_IF([GL_COND_OBJ_BTOWC], [ gl_PREREQ_BTOWC ]) gl_WCHAR_MODULE_INDICATOR([btowc])	wchar mbtowc [test $HAVE_BTOWC = 0 \|\| test $REPLACE_BTOWC = 1] mbrtowc [test $HAVE_BTOWC = 0 \|\| test $REPLACE_BTOWC = 1]
wctob	#include <wchar.h>	wctob.c	wctob.m4 locale-fr.m4 codeset.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_WCTOB gl_CONDITIONAL([GL_COND_OBJ_WCTOB], [test $HAVE_WCTOB = 0 \|\| test $REPLACE_WCTOB = 1]) AM_COND_IF([GL_COND_OBJ_WCTOB], [ gl_PREREQ_WCTOB ]) gl_WCHAR_MODULE_INDICATOR([wctob])	wchar wctomb [test $HAVE_WCTOB = 0 \|\| test $REPLACE_WCTOB = 1]
mbsinit	#include <wchar.h>	mbsinit.c	mbsinit.m4 mbstate_t.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_MBSINIT gl_CONDITIONAL([GL_COND_OBJ_MBSINIT], [test $HAVE_MBSINIT = 0 \|\| test $REPLACE_MBSINIT = 1]) AM_COND_IF([GL_COND_OBJ_MBSINIT], [ gl_PREREQ_MBSINIT ]) gl_WCHAR_MODULE_INDICATOR([mbsinit])	wchar extensions assert-h [test $HAVE_MBSINIT = 0 \|\| test $REPLACE_MBSINIT = 1] mbrtowc [test $HAVE_MBSINIT = 0 \|\| test $REPLACE_MBSINIT = 1]
mbrlen	#include <wchar.h>	mbrlen.c	mbrlen.m4 mbstate_t.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_MBRLEN gl_CONDITIONAL([GL_COND_OBJ_MBRLEN], [test $HAVE_MBRLEN = 0 \|\| test $REPLACE_MBRLEN = 1]) AM_COND_IF([GL_COND_OBJ_MBRLEN], [ gl_PREREQ_MBRLEN ]) gl_WCHAR_MODULE_INDICATOR([mbrlen])	wchar extensions mbrtowc [test $HAVE_MBRLEN = 0 \|\| test $REPLACE_MBRLEN = 1]
mbrtowc	#include <wchar.h>	mbrtowc.c mbrtowc-impl.h mbrtowc-impl-utf8.h lc-charset-dispatch.h lc-charset-dispatch.c mbtowc-lock.h mbtowc-lock.c windows-initguard.h	mbrtowc.m4 mbstate_t.m4 locale-fr.m4 locale-ja.m4 locale-zh.m4 codeset.m4 threadlib.m4 visibility.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_MBRTOWC gl_CONDITIONAL([GL_COND_OBJ_MBRTOWC], [test $HAVE_MBRTOWC = 0 \|\| test $REPLACE_MBRTOWC = 1]) AM_COND_IF([GL_COND_OBJ_MBRTOWC], [ if test $REPLACE_MBSTATE_T = 1; then AC_LIBOBJ([lc-charset-dispatch]) AC_LIBOBJ([mbtowc-lock]) gl_PREREQ_MBTOWC_LOCK fi gl_PREREQ_MBRTOWC ]) gl_WCHAR_MODULE_INDICATOR([mbrtowc])	wchar extensions attribute [test $HAVE_MBRTOWC = 0 \|\| test $REPLACE_MBRTOWC = 1] stdint [test $HAVE_MBRTOWC = 0 \|\| test $REPLACE_MBRTOWC = 1] hard-locale [{ test $HAVE_MBRTOWC = 0 \|\| test $REPLACE_MBRTOWC = 1; } && test $REPLACE_MBSTATE_T = 0] mbsinit [{ test $HAVE_MBRTOWC = 0 \|\| test $REPLACE_MBRTOWC = 1; } && test $REPLACE_MBSTATE_T = 0] assert-h [test $HAVE_MBRTOWC = 0 \|\| test $REPLACE_MBRTOWC = 1] localcharset [test $HAVE_MBRTOWC = 0 \|\| test $REPLACE_MBRTOWC = 1] streq [test $HAVE_MBRTOWC = 0 \|\| test $REPLACE_MBRTOWC = 1]
mbsrtowcs	#include <wchar.h>	mbsrtowcs.c mbsrtowcs-impl.h mbsrtowcs-state.c	mbsrtowcs.m4 mbstate_t.m4 mbrtowc.m4 locale-fr.m4 locale-ja.m4 locale-zh.m4 codeset.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_MBSRTOWCS gl_CONDITIONAL([GL_COND_OBJ_MBSRTOWCS], [test $HAVE_MBSRTOWCS = 0 \|\| test $REPLACE_MBSRTOWCS = 1]) AM_COND_IF([GL_COND_OBJ_MBSRTOWCS], [ AC_LIBOBJ([mbsrtowcs-state]) gl_PREREQ_MBSRTOWCS ]) gl_WCHAR_MODULE_INDICATOR([mbsrtowcs])	wchar extensions mbrtowc [test $HAVE_MBSRTOWCS = 0 \|\| test $REPLACE_MBSRTOWCS = 1] strnlen1 [test $HAVE_MBSRTOWCS = 0 \|\| test $REPLACE_MBSRTOWCS = 1]
wcrtomb	#include <wchar.h>	wcrtomb.c	wcrtomb.m4 mbrtowc.m4 mbstate_t.m4 locale-fr.m4 locale-ja.m4 locale-zh.m4 codeset.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_WCRTOMB gl_CONDITIONAL([GL_COND_OBJ_WCRTOMB], [test $HAVE_WCRTOMB = 0 \|\| test $REPLACE_WCRTOMB = 1]) AM_COND_IF([GL_COND_OBJ_WCRTOMB], [ gl_PREREQ_WCRTOMB ]) gl_WCHAR_MODULE_INDICATOR([wcrtomb])	wchar extensions mbsinit [test $HAVE_WCRTOMB = 0 \|\| test $REPLACE_WCRTOMB = 1]
wcsrtombs	#include <wchar.h>	wcsrtombs.c wcsrtombs-impl.h wcsrtombs-state.c	wcsrtombs.m4 mbrtowc.m4 mbstate_t.m4 locale-fr.m4 locale-ja.m4 locale-zh.m4 codeset.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_WCSRTOMBS gl_CONDITIONAL([GL_COND_OBJ_WCSRTOMBS], [test $HAVE_WCSRTOMBS = 0 \|\| test $REPLACE_WCSRTOMBS = 1]) AM_COND_IF([GL_COND_OBJ_WCSRTOMBS], [ AC_LIBOBJ([wcsrtombs-state]) gl_PREREQ_WCSRTOMBS ]) gl_WCHAR_MODULE_INDICATOR([wcsrtombs])	wchar extensions wcrtomb [test $HAVE_WCSRTOMBS = 0 \|\| test $REPLACE_WCSRTOMBS = 1]

Wide character classification and mapping utilities <wctype.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
wctype	#include <wctype.h>	wctype.c wctype-impl.h	wctype.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_WCTYPE gl_CONDITIONAL([GL_COND_OBJ_WCTYPE], [test $HAVE_WCTYPE = 0]) gl_WCTYPE_MODULE_INDICATOR([wctype])	wctype-h iswblank [test $HAVE_WCTYPE = 0] iswdigit [test $HAVE_WCTYPE = 0] iswxdigit [test $HAVE_WCTYPE = 0]

Characteristics of floating types <float.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
float	#include <float.h>	float.in.h float.c itold.c	float_h.m4 00gnulib.m4 zzgnulib.m4 gl_FLOAT_H gl_CONDITIONAL_HEADER([float.h]) AC_PROG_MKDIR_P gl_CONDITIONAL([GL_COND_OBJ_FLOAT], [test $REPLACE_FLOAT_LDBL = 1]) gl_CONDITIONAL([GL_COND_OBJ_ITOLD], [test $REPLACE_ITOLD = 1])	gen-header include_next

Mathematics <math.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
acos	#include <math.h>	---	acos.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ACOS	---
acosl	#include <math.h>	acosl.c	acosl.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ACOSL gl_CONDITIONAL([GL_COND_OBJ_ACOSL], [test $HAVE_ACOSL = 0]) gl_MATH_MODULE_INDICATOR([acosl])	math extensions acos [test $HAVE_ACOSL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] asinl [test $HAVE_ACOSL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] sqrtl [test $HAVE_ACOSL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
asin	#include <math.h>	---	asin.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ASIN	---
asinl	#include <math.h>	asinl.c	asinl.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ASINL gl_CONDITIONAL([GL_COND_OBJ_ASINL], [test $HAVE_ASINL = 0]) gl_MATH_MODULE_INDICATOR([asinl])	math extensions asin [test $HAVE_ASINL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] sqrtl [test $HAVE_ASINL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
atan	#include <math.h>	---	atan.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ATAN	---
atan2	#include <math.h>	---	atan2.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ATAN2	---
atanl	#include <math.h>	atanl.c	atanl.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ATANL gl_CONDITIONAL([GL_COND_OBJ_ATANL], [test $HAVE_ATANL = 0]) gl_MATH_MODULE_INDICATOR([atanl])	math extensions atan [test $HAVE_ATANL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] isnanl [test $HAVE_ATANL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
cbrt	#include <math.h>	cbrt.c	cbrt.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_CBRT gl_CONDITIONAL([GL_COND_OBJ_CBRT], [test $HAVE_CBRT = 0]) gl_MATH_MODULE_INDICATOR([cbrt])	math extensions isfinite [test $HAVE_CBRT = 0] fabs [test $HAVE_CBRT = 0] frexp [test $HAVE_CBRT = 0] ldexp [test $HAVE_CBRT = 0]
ceil	#include <math.h>	ceil.c	ceil.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_CEIL gl_CONDITIONAL([GL_COND_OBJ_CEIL], [test $REPLACE_CEIL = 1]) gl_MATH_MODULE_INDICATOR([ceil])	math float [test $REPLACE_CEIL = 1]
ceilf	#include <math.h>	ceilf.c ceil.c	ceilf.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_CEILF gl_CONDITIONAL([GL_COND_OBJ_CEILF], [test $HAVE_DECL_CEILF = 0 \|\| test $REPLACE_CEILF = 1]) gl_MATH_MODULE_INDICATOR([ceilf])	math extensions float [test $HAVE_DECL_CEILF = 0 \|\| test $REPLACE_CEILF = 1]
ceill	#include <math.h>	ceill.c ceil.c	ceill.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_CEILL gl_CONDITIONAL([GL_COND_OBJ_CEILL], [test $HAVE_DECL_CEILL = 0 \|\| test $REPLACE_CEILL = 1]) gl_MATH_MODULE_INDICATOR([ceill])	math extensions ceil [{ test $HAVE_DECL_CEILL = 0 \|\| test $REPLACE_CEILL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] float [{ test $HAVE_DECL_CEILL = 0 \|\| test $REPLACE_CEILL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
copysign	#include <math.h>	copysign.c	copysign.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_COPYSIGN gl_CONDITIONAL([GL_COND_OBJ_COPYSIGN], [test $HAVE_COPYSIGN = 0]) gl_MATH_MODULE_INDICATOR([copysign])	math signbit [test $HAVE_COPYSIGN = 0]
cos	#include <math.h>	---	cos.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_COS	---
cosh	#include <math.h>	---	cosh.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_COSH	---
cosl	#include <math.h>	cosl.c trigl.h sincosl.c trigl.c	cosl.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_COSL gl_CONDITIONAL([GL_COND_OBJ_COSL], [test $HAVE_COSL = 0]) AM_COND_IF([GL_COND_OBJ_COSL], [ if test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0; then AC_LIBOBJ([sincosl]) AC_LIBOBJ([trigl]) fi ]) gl_MATH_MODULE_INDICATOR([cosl])	math extensions cos [test $HAVE_COSL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] float [test $HAVE_COSL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] isnanl [test $HAVE_COSL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] floor [test $HAVE_COSL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] floorl [test $HAVE_COSL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
erf	#include <math.h>	---	mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_COMMON_DOUBLE_MATHFUNC([erf])	---
erfc	#include <math.h>	---	mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_COMMON_DOUBLE_MATHFUNC([erfc])	---
exp	#include <math.h>	---	exp.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_EXP	---
expl	#include <math.h>	expl.c expl-table.c	expl.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_EXPL gl_CONDITIONAL([GL_COND_OBJ_EXPL], [test $HAVE_EXPL = 0 \|\| test $REPLACE_EXPL = 1]) AM_COND_IF([GL_COND_OBJ_EXPL], [ AC_LIBOBJ([expl-table]) ]) gl_MATH_MODULE_INDICATOR([expl])	math extensions exp [{ test $HAVE_EXPL = 0 \|\| test $REPLACE_EXPL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] float [{ test $HAVE_EXPL = 0 \|\| test $REPLACE_EXPL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] isnanl [{ test $HAVE_EXPL = 0 \|\| test $REPLACE_EXPL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] roundl [{ test $HAVE_EXPL = 0 \|\| test $REPLACE_EXPL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] ldexpl [{ test $HAVE_EXPL = 0 \|\| test $REPLACE_EXPL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
fabs	#include <math.h>	---	fabs.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FABS	---
floor	#include <math.h>	floor.c	floor.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_FUNC_FLOOR]) gl_CONDITIONAL([GL_COND_OBJ_FLOOR], [test $REPLACE_FLOOR = 1]) gl_MATH_MODULE_INDICATOR([floor])	math float [test $REPLACE_FLOOR = 1]
floorf	#include <math.h>	floorf.c floor.c	floorf.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FLOORF gl_CONDITIONAL([GL_COND_OBJ_FLOORF], [test $HAVE_DECL_FLOORF = 0 \|\| test $REPLACE_FLOORF = 1]) gl_MATH_MODULE_INDICATOR([floorf])	math extensions float [test $HAVE_DECL_FLOORF = 0 \|\| test $REPLACE_FLOORF = 1]
floorl	#include <math.h>	floorl.c floor.c	floorl.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_FUNC_FLOORL]) gl_CONDITIONAL([GL_COND_OBJ_FLOORL], [test $HAVE_DECL_FLOORL = 0 \|\| test $REPLACE_FLOORL = 1]) gl_MATH_MODULE_INDICATOR([floorl])	math extensions floor [{ test $HAVE_DECL_FLOORL = 0 \|\| test $REPLACE_FLOORL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] float [{ test $HAVE_DECL_FLOORL = 0 \|\| test $REPLACE_FLOORL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
fmod	#include <math.h>	fmod.c	fmod.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FMOD gl_CONDITIONAL([GL_COND_OBJ_FMOD], [test $REPLACE_FMOD = 1]) gl_MATH_MODULE_INDICATOR([fmod])	math isfinite [test $REPLACE_FMOD = 1] signbit [test $REPLACE_FMOD = 1] fabs [test $REPLACE_FMOD = 1] frexp [test $REPLACE_FMOD = 1] trunc [test $REPLACE_FMOD = 1] ldexp [test $REPLACE_FMOD = 1] isnand [test $REPLACE_FMOD = 1] isinf [test $REPLACE_FMOD = 1]
frexp	#include <math.h>	frexp.c	frexp.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_FUNC_FREXP]) if test $gl_func_frexp != yes; then AC_LIBOBJ([frexp]) fi gl_MATH_MODULE_INDICATOR([frexp])	math isnand-nolibm [test $gl_func_frexp != yes]
frexp-nolibm	#include <math.h>	frexp.c	frexp.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FREXP_NO_LIBM if test $gl_func_frexp_no_libm != yes; then AC_LIBOBJ([frexp]) fi gl_MATH_MODULE_INDICATOR([frexp])	math isnand-nolibm [test $gl_func_frexp_no_libm != yes]
frexpl	#include <math.h>	frexpl.c frexp.c	frexpl.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_FUNC_FREXPL]) if test $HAVE_DECL_FREXPL = 0 \|\| test $gl_func_frexpl = no; then AC_LIBOBJ([frexpl]) fi gl_MATH_MODULE_INDICATOR([frexpl])	math extensions frexp [{ test $HAVE_DECL_FREXPL = 0 \|\| test $gl_func_frexpl = no; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] isnanl-nolibm [{ test $HAVE_DECL_FREXPL = 0 \|\| test $gl_func_frexpl = no; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] fpucw [{ test $HAVE_DECL_FREXPL = 0 \|\| test $gl_func_frexpl = no; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
frexpl-nolibm	#include <math.h>	frexpl.c frexp.c	frexpl.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FREXPL_NO_LIBM if test $HAVE_DECL_FREXPL = 0 \|\| test $gl_func_frexpl_no_libm = no; then AC_LIBOBJ([frexpl]) fi gl_MATH_MODULE_INDICATOR([frexpl])	math frexp-nolibm [{ test $HAVE_DECL_FREXPL = 0 \|\| test $gl_func_frexpl_no_libm = no; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] isnanl-nolibm [{ test $HAVE_DECL_FREXPL = 0 \|\| test $gl_func_frexpl_no_libm = no; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] fpucw [{ test $HAVE_DECL_FREXPL = 0 \|\| test $gl_func_frexpl_no_libm = no; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
hypot	#include <math.h>	hypot.c	hypot.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_HYPOT gl_CONDITIONAL([GL_COND_OBJ_HYPOT], [test $REPLACE_HYPOT = 1]) gl_MATH_MODULE_INDICATOR([hypot])	math extensions isfinite [test $REPLACE_HYPOT = 1] fabs [test $REPLACE_HYPOT = 1] frexp [test $REPLACE_HYPOT = 1] ldexp [test $REPLACE_HYPOT = 1] sqrt [test $REPLACE_HYPOT = 1] isinf [test $REPLACE_HYPOT = 1]
isfinite	#include <math.h>	isfinite.c	isfinite.m4 check-math-lib.m4 00gnulib.m4 zzgnulib.m4 gl_ISFINITE gl_CONDITIONAL([GL_COND_OBJ_ISFINITE], [test $REPLACE_ISFINITE = 1]) gl_MATH_MODULE_INDICATOR([isfinite])	math extensions isnanf-nolibm [test $REPLACE_ISFINITE = 1] isnand-nolibm [test $REPLACE_ISFINITE = 1] isnanl-nolibm [test $REPLACE_ISFINITE = 1]
isinf	#include <math.h>	isinf.c	isinf.m4 check-math-lib.m4 00gnulib.m4 zzgnulib.m4 gl_ISINF gl_CONDITIONAL([GL_COND_OBJ_ISINF], [test $REPLACE_ISINF = 1]) gl_MATH_MODULE_INDICATOR([isinf])	math extensions float [test $REPLACE_ISINF = 1]
isnan	#include <math.h>	---	isnan.m4 00gnulib.m4 zzgnulib.m4 gl_ISNAN gl_MATH_MODULE_INDICATOR([isnan])	isnanf isnand isnanl math extensions
isnanf	#include <math.h>	isnanf.c isnan.c float+.h	exponentf.m4 isnanf.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ISNANF m4_ifdef([gl_ISNAN], [ AC_REQUIRE([gl_ISNAN]) ]) if test $HAVE_ISNANF = 0 \|\| test $REPLACE_ISNAN = 1; then AC_LIBOBJ([isnanf]) gl_PREREQ_ISNANF fi gl_MATH_MODULE_INDICATOR([isnanf])	math fpieee memcmp
isnanf-nolibm	#include "isnanf-nolibm.h"	isnanf.c isnan.c float+.h	exponentf.m4 isnanf.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ISNANF_NO_LIBM if test $gl_func_isnanf_no_libm != yes; then AC_LIBOBJ([isnanf]) gl_PREREQ_ISNANF fi	fpieee memcmp
isnand	#include <math.h>	isnand.c isnan.c float+.h	exponentd.m4 isnand.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ISNAND m4_ifdef([gl_ISNAN], [ AC_REQUIRE([gl_ISNAN]) ]) if test $HAVE_ISNAND = 0 \|\| test $REPLACE_ISNAN = 1; then AC_LIBOBJ([isnand]) gl_PREREQ_ISNAND fi gl_MATH_MODULE_INDICATOR([isnand])	math fpieee memcmp
isnand-nolibm	#include "isnand-nolibm.h"	isnand.c isnan.c float+.h	exponentd.m4 isnand.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ISNAND_NO_LIBM if test $gl_func_isnand_no_libm != yes; then AC_LIBOBJ([isnand]) gl_PREREQ_ISNAND fi	fpieee memcmp
isnanl	#include <math.h>	isnanl.c isnan.c float+.h	exponentl.m4 isnanl.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ISNANL m4_ifdef([gl_ISNAN], [ AC_REQUIRE([gl_ISNAN]) ]) if test $HAVE_ISNANL = 0 \|\| test $REPLACE_ISNAN = 1; then AC_LIBOBJ([isnanl]) gl_PREREQ_ISNANL fi gl_MATH_MODULE_INDICATOR([isnanl])	math float fpieee memcmp
isnanl-nolibm	#include "isnanl-nolibm.h"	isnanl.c isnan.c float+.h	exponentl.m4 isnanl.m4 math_h.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ISNANL_NO_LIBM if test $gl_func_isnanl_no_libm != yes; then AC_LIBOBJ([isnanl]) gl_PREREQ_ISNANL fi	float fpieee memcmp
j0	#include <math.h>	---	mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_COMMON_DOUBLE_MATHFUNC([j0])	---
j1	#include <math.h>	---	mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_COMMON_DOUBLE_MATHFUNC([j1])	---
jn	#include <math.h>	---	mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_COMMON_DOUBLE_MATHFUNC([jn])	---
ldexp	#include <math.h>	---	ldexp.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_LDEXP	---
ldexpl	#include <math.h>	ldexpl.c	ldexpl.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_LDEXPL gl_CONDITIONAL([GL_COND_OBJ_LDEXPL], [test $HAVE_DECL_LDEXPL = 0 \|\| test $gl_func_ldexpl = no]) gl_MATH_MODULE_INDICATOR([ldexpl])	math extensions ldexp [{ test $HAVE_DECL_LDEXPL = 0 \|\| test $gl_func_ldexpl = no; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] isnanl [{ test $HAVE_DECL_LDEXPL = 0 \|\| test $gl_func_ldexpl = no; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] fpucw [{ test $HAVE_DECL_LDEXPL = 0 \|\| test $gl_func_ldexpl = no; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
lgamma	#include <math.h>	---	mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_COMMON_DOUBLE_MATHFUNC([lgamma])	---
log	#include <math.h>	log.c	log.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_FUNC_LOG]) gl_CONDITIONAL([GL_COND_OBJ_LOG], [test $REPLACE_LOG = 1]) gl_MATH_MODULE_INDICATOR([log])	math
log10	#include <math.h>	log10.c	log10.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_LOG10 gl_CONDITIONAL([GL_COND_OBJ_LOG10], [test $REPLACE_LOG10 = 1]) gl_MATH_MODULE_INDICATOR([log10])	math
log1p	#include <math.h>	log1p.c	log1p.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_LOG1P gl_CONDITIONAL([GL_COND_OBJ_LOG1P], [test $HAVE_LOG1P = 0 \|\| test $REPLACE_LOG1P = 1]) gl_MATH_MODULE_INDICATOR([log1p])	math extensions isnand [test $HAVE_LOG1P = 0 \|\| test $REPLACE_LOG1P = 1] log [test $HAVE_LOG1P = 0 \|\| test $REPLACE_LOG1P = 1] round [test $HAVE_LOG1P = 0 \|\| test $REPLACE_LOG1P = 1]
logb	#include <math.h>	logb.c	logb.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_LOGB gl_CONDITIONAL([GL_COND_OBJ_LOGB], [test $HAVE_LOGB = 0 \|\| test $REPLACE_LOGB = 1]) gl_MATH_MODULE_INDICATOR([logb])	math extensions isfinite [test $HAVE_LOGB = 0 \|\| test $REPLACE_LOGB = 1] frexp [test $HAVE_LOGB = 0 \|\| test $REPLACE_LOGB = 1] isnand [test $HAVE_LOGB = 0 \|\| test $REPLACE_LOGB = 1]
logl	#include <math.h>	logl.c	logl.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_LOGL gl_CONDITIONAL([GL_COND_OBJ_LOGL], [test $HAVE_LOGL = 0 \|\| test $REPLACE_LOGL = 1]) gl_MATH_MODULE_INDICATOR([logl])	math extensions log [{ test $HAVE_LOGL = 0 \|\| test $REPLACE_LOGL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] frexpl [{ test $HAVE_LOGL = 0 \|\| test $REPLACE_LOGL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] isnanl [{ test $HAVE_LOGL = 0 \|\| test $REPLACE_LOGL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] floorl [{ test $HAVE_LOGL = 0 \|\| test $REPLACE_LOGL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
math	#include <math.h>	math.in.h math.c	math_h.m4 00gnulib.m4 zzgnulib.m4 gl_MATH_H gl_MATH_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	extern-inline gen-header include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use float
mathl	#include <math.h>	---	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_FUNC_FLOORL]) AC_REQUIRE([gl_FUNC_CEILL]) AC_REQUIRE([gl_FUNC_ACOSL]) AC_REQUIRE([gl_FUNC_ASINL]) AC_REQUIRE([gl_FUNC_ATANL]) AC_REQUIRE([gl_FUNC_COSL]) AC_REQUIRE([gl_FUNC_EXPL]) AC_REQUIRE([gl_FUNC_LOGL]) AC_REQUIRE([gl_FUNC_SINL]) AC_REQUIRE([gl_FUNC_SQRTL]) AC_REQUIRE([gl_FUNC_TANL]) LIBS="$LIBS $FLOORL_LIBM $CEILL_LIBM $ACOSL_LIBM $ASINL_LIBM $ATANL_LIBM $COSL_LIBM $EXPL_LIBM $LOGL_LIBM $SINL_LIBM $SQRTL_LIBM $TANL_LIBM"	floorl ceill acosl asinl atanl cosl expl logl sinl sqrtl tanl
modf	#include <math.h>	modf.c	modf.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_MODF gl_CONDITIONAL([GL_COND_OBJ_MODF], [test $REPLACE_MODF = 1]) gl_MATH_MODULE_INDICATOR([modf])	math isfinite [test $REPLACE_MODF = 1] trunc [test $REPLACE_MODF = 1] isinf [test $REPLACE_MODF = 1]
nextafter	#include <math.h>	---	mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_MATHFUNC([nextafter], [double], [(double, double)])	---
pow	#include <math.h>	---	pow.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_POW	---
remainder	#include <math.h>	remainder.c	remainder.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_REMAINDER gl_CONDITIONAL([GL_COND_OBJ_REMAINDER], [test $HAVE_REMAINDER = 0 \|\| test $REPLACE_REMAINDER = 1]) gl_MATH_MODULE_INDICATOR([remainder])	math isfinite [test $HAVE_REMAINDER = 0 \|\| test $REPLACE_REMAINDER = 1] signbit [test $HAVE_REMAINDER = 0 \|\| test $REPLACE_REMAINDER = 1] fabs [test $HAVE_REMAINDER = 0 \|\| test $REPLACE_REMAINDER = 1] fmod [test $HAVE_REMAINDER = 0 \|\| test $REPLACE_REMAINDER = 1] isnand [test $HAVE_REMAINDER = 0 \|\| test $REPLACE_REMAINDER = 1] isinf [test $HAVE_REMAINDER = 0 \|\| test $REPLACE_REMAINDER = 1]
rint	#include <math.h>	rint.c	rint.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_RINT gl_CONDITIONAL([GL_COND_OBJ_RINT], [test $HAVE_RINT = 0]) gl_MATH_MODULE_INDICATOR([rint])	math
round	#include <math.h>	round.c	check-math-lib.m4 round.m4 floor.m4 ceil.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ROUND gl_CONDITIONAL([GL_COND_OBJ_ROUND], [test $HAVE_ROUND = 0 \|\| test $REPLACE_ROUND = 1]) gl_MATH_MODULE_INDICATOR([round])	math extensions float [test $HAVE_ROUND = 0 \|\| test $REPLACE_ROUND = 1] floor [test $HAVE_ROUND = 0 \|\| test $REPLACE_ROUND = 1]
roundf	#include <math.h>	round.c roundf.c	check-math-lib.m4 roundf.m4 floorf.m4 ceilf.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ROUNDF gl_CONDITIONAL([GL_COND_OBJ_ROUNDF], [test $HAVE_ROUNDF = 0 \|\| test $REPLACE_ROUNDF = 1]) gl_MATH_MODULE_INDICATOR([roundf])	math extensions float [test $HAVE_ROUNDF = 0 \|\| test $REPLACE_ROUNDF = 1]
roundl	#include <math.h>	round.c roundl.c	check-math-lib.m4 roundl.m4 floorl.m4 ceill.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ROUNDL gl_CONDITIONAL([GL_COND_OBJ_ROUNDL], [test $HAVE_ROUNDL = 0 \|\| test $REPLACE_ROUNDL = 1]) gl_MATH_MODULE_INDICATOR([roundl])	math extensions round [{ test $HAVE_ROUNDL = 0 \|\| test $REPLACE_ROUNDL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] float [{ test $HAVE_ROUNDL = 0 \|\| test $REPLACE_ROUNDL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
signbit	#include <math.h>	signbitf.c signbitd.c signbitl.c float+.h	signbit.m4 00gnulib.m4 zzgnulib.m4 gl_SIGNBIT gl_CONDITIONAL([GL_COND_OBJ_SIGNBIT3], [test $REPLACE_SIGNBIT = 1]) gl_MATH_MODULE_INDICATOR([signbit])	math float [test $REPLACE_SIGNBIT = 1] isnanf-nolibm [test $REPLACE_SIGNBIT = 1] isnand-nolibm [test $REPLACE_SIGNBIT = 1] isnanl-nolibm [test $REPLACE_SIGNBIT = 1] fpieee [test $REPLACE_SIGNBIT = 1] memcmp [test $REPLACE_SIGNBIT = 1]
sin	#include <math.h>	---	sin.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_SIN	---
sinh	#include <math.h>	---	sinh.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_SINH	---
sinl	#include <math.h>	sinl.c trigl.h sincosl.c trigl.c	sinl.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_SINL gl_CONDITIONAL([GL_COND_OBJ_SINL], [test $HAVE_SINL = 0]) AM_COND_IF([GL_COND_OBJ_SINL], [ if test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0; then AC_LIBOBJ([sincosl]) AC_LIBOBJ([trigl]) fi ]) gl_MATH_MODULE_INDICATOR([sinl])	math extensions sin [test $HAVE_SINL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] float [test $HAVE_SINL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] isnanl [test $HAVE_SINL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] floor [test $HAVE_SINL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] floorl [test $HAVE_SINL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
sqrt	#include <math.h>	---	sqrt.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_SQRT	---
sqrtl	#include <math.h>	sqrtl.c	sqrtl.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_SQRTL gl_CONDITIONAL([GL_COND_OBJ_SQRTL], [test $HAVE_SQRTL = 0 \|\| test $REPLACE_SQRTL = 1]) gl_MATH_MODULE_INDICATOR([sqrtl])	math extensions sqrt [{ test $HAVE_SQRTL = 0 \|\| test $REPLACE_SQRTL = 1; }] float [{ test $HAVE_SQRTL = 0 \|\| test $REPLACE_SQRTL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] isnanl [{ test $HAVE_SQRTL = 0 \|\| test $REPLACE_SQRTL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] frexpl [{ test $HAVE_SQRTL = 0 \|\| test $REPLACE_SQRTL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] ldexpl [{ test $HAVE_SQRTL = 0 \|\| test $REPLACE_SQRTL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
tan	#include <math.h>	---	tan.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_TAN	---
tanh	#include <math.h>	---	tanh.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_TANH	---
tanl	#include <math.h>	tanl.c trigl.h trigl.c	tanl.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_TANL gl_CONDITIONAL([GL_COND_OBJ_TANL], [test $HAVE_TANL = 0]) AM_COND_IF([GL_COND_OBJ_TANL], [ if test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0; then AC_LIBOBJ([trigl]) fi ]) gl_MATH_MODULE_INDICATOR([tanl])	math extensions tan [test $HAVE_TANL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] float [test $HAVE_TANL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] isnanl [test $HAVE_TANL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] floor [test $HAVE_TANL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] floorl [test $HAVE_TANL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
trunc	#include <math.h>	trunc.c	trunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_TRUNC gl_CONDITIONAL([GL_COND_OBJ_TRUNC], [test $HAVE_DECL_TRUNC = 0 \|\| test $REPLACE_TRUNC = 1]) gl_MATH_MODULE_INDICATOR([trunc])	math extensions float [test $HAVE_DECL_TRUNC = 0 \|\| test $REPLACE_TRUNC = 1]
truncf	#include <math.h>	truncf.c trunc.c	truncf.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_TRUNCF gl_CONDITIONAL([GL_COND_OBJ_TRUNCF], [test $HAVE_DECL_TRUNCF = 0 \|\| test $REPLACE_TRUNCF = 1]) gl_MATH_MODULE_INDICATOR([truncf])	math extensions float [test $HAVE_DECL_TRUNCF = 0 \|\| test $REPLACE_TRUNCF = 1]
truncl	#include <math.h>	truncl.c trunc.c	truncl.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_TRUNCL gl_CONDITIONAL([GL_COND_OBJ_TRUNCL], [test $HAVE_DECL_TRUNCL = 0 \|\| test $REPLACE_TRUNCL = 1]) gl_MATH_MODULE_INDICATOR([truncl])	math extensions trunc [{ test $HAVE_DECL_TRUNCL = 0 \|\| test $REPLACE_TRUNCL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] float [{ test $HAVE_DECL_TRUNCL = 0 \|\| test $REPLACE_TRUNCL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
y0	#include <math.h>	---	mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_COMMON_DOUBLE_MATHFUNC([y0])	---
y1	#include <math.h>	---	mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_COMMON_DOUBLE_MATHFUNC([y1])	---
yn	#include <math.h>	---	mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_COMMON_DOUBLE_MATHFUNC([yn])	---

Enhancements for ISO C 99 functions

Input/output <stdio.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
printf-safe	---	---	00gnulib.m4 zzgnulib.m4 m4_divert_text([INIT_PREPARE], [gl_printf_safe=yes])	---

Extra functions based on ISO C 99

Mathematics <math.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
printf-frexpl	#include "printf-frexpl.h"	printf-frexpl.c printf-frexp.c	printf-frexpl.m4 frexpl.m4 ldexpl.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_PRINTF_FREXPL	printf-frexp [test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] float [test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] math [test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] fpucw [test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]

Numeric conversion functions <stdlib.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
c-dtoastr	#include "ftoastr.h"	ftoastr.c c-dtoastr.c	00gnulib.m4 zzgnulib.m4	extensions intprops c-snprintf c-strtod
c-ldtoastr	#include "ftoastr.h"	ftoastr.c c-ldtoastr.c	00gnulib.m4 zzgnulib.m4	extensions intprops c-snprintf c-strtold
dtoastr	#include "ftoastr.h"	ftoastr.c dtoastr.c	00gnulib.m4 zzgnulib.m4	extensions intprops
ftoastr	#include "ftoastr.h"	ftoastr.c	00gnulib.m4 zzgnulib.m4 gl_CHECK_FUNCS_ANDROID([strtof], [[#include ]])	extensions intprops
intprops	#include "intprops.h"	intprops-internal.h	00gnulib.m4 zzgnulib.m4	---
inttostr	#include "inttostr.h"	anytostr.c imaxtostr.c inttostr.c offtostr.c umaxtostr.c uinttostr.c	inttostr.m4 00gnulib.m4 zzgnulib.m4 gl_INTTOSTR	intprops stdint
ldtoastr	#include "ftoastr.h"	ftoastr.c ldtoastr.c	00gnulib.m4 zzgnulib.m4	extensions intprops
xstrtoimax	#include "xstrtol.h"	xstrtoimax.c	00gnulib.m4 zzgnulib.m4	xstrtol inttypes-incomplete strtoimax
xstrtoumax	#include "xstrtol.h"	xstrtoumax.c	00gnulib.m4 zzgnulib.m4	xstrtol inttypes-incomplete strtoumax

Extended multibyte and wide character utilities <wchar.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
mbchar	#include "mbchar.h"	mbchar.c	mbchar.m4 00gnulib.m4 zzgnulib.m4 gl_MBCHAR	extensions extern-inline stdbool wchar wctype-h iswblank iswdigit iswxdigit wcwidth memcmp
mbiter	#include "mbiter.h"	mbiter.c	mbiter.m4 mbrtowc.m4 00gnulib.m4 zzgnulib.m4 gl_MBITER	extern-inline mbchar mbrtowc mbsinit wchar stdbool
mbuiter	#include "mbuiter.h"	mbuiter.c	mbiter.m4 mbrtowc.m4 00gnulib.m4 zzgnulib.m4 gl_MBITER	extern-inline mbchar mbrtowc mbsinit wchar stdbool strnlen1
mbfile	#include "mbfile.h"	mbfile.c	mbfile.m4 mbrtowc.m4 00gnulib.m4 zzgnulib.m4 gl_MBFILE	extern-inline mbchar mbrtowc mbsinit wchar stdbool

Support for systems lacking ISO C 11

Core language properties

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
noreturn	#include <noreturn.h>	noreturn.h	00gnulib.m4 zzgnulib.m4	---
std-gnu11	---	---	std-gnu11.m4 00gnulib.m4 zzgnulib.m4	---
stdalign	---	stdalign.in.h	stdalign.m4 00gnulib.m4 zzgnulib.m4 gl_STDALIGN_H gl_CONDITIONAL_HEADER([stdalign.h]) AC_PROG_MKDIR_P	alignasof gen-header

Support for standard extensions to ISO C 11

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
attribute	#include "attribute.h"	---	00gnulib.m4 zzgnulib.m4	---
builtin-expect	---	---	builtin-expect.m4 00gnulib.m4 zzgnulib.m4 gl___BUILTIN_EXPECT	---
ieee754-h	#include <ieee754.h>	ieee754.in.h	ieee754-h.m4 00gnulib.m4 zzgnulib.m4 gl_IEEE754_H gl_CONDITIONAL_HEADER([ieee754.h]) AC_PROG_MKDIR_P	gen-header
limits-h	#include <limits.h>	limits.in.h	limits-h.m4 00gnulib.m4 zzgnulib.m4 gl_LIMITS_H gl_CONDITIONAL_HEADER([limits.h]) AC_PROG_MKDIR_P	gen-header include_next

Support for systems lacking draft ISO C 23

Core language properties

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
alignasof	---	---	stdalign.m4 00gnulib.m4 zzgnulib.m4 gl_ALIGNASOF	---
nullptr	---	---	nullptr.m4 00gnulib.m4 zzgnulib.m4 gl_NULLPTR	---
stdckdint	#include <stdckdint.h>	stdckdint.in.h intprops-internal.h	00gnulib.m4 zzgnulib.m4 AC_CHECK_HEADERS_ONCE([stdckdint.h]) if test $ac_cv_header_stdckdint_h = yes; then GL_GENERATE_STDCKDINT_H=false else GL_GENERATE_STDCKDINT_H=true fi gl_CONDITIONAL_HEADER([stdckdint.h]) AC_PROG_MKDIR_P	gen-header stdbool

Memory management functions <stdlib.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
aligned_alloc	#include <stdlib.h>	aligned_alloc.c	aligned_alloc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ALIGNED_ALLOC gl_CONDITIONAL([GL_COND_OBJ_ALIGNED_ALLOC], [test $REPLACE_ALIGNED_ALLOC = 1]) gl_STDLIB_MODULE_INDICATOR([aligned_alloc])	extensions stdlib

String handling <string.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
memset_explicit	#include <string.h>	memset_explicit.c	memset_explicit.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_MEMSET_EXPLICIT gl_CONDITIONAL([GL_COND_OBJ_MEMSET_EXPLICIT], [test $HAVE_MEMSET_EXPLICIT = 0]) AM_COND_IF([GL_COND_OBJ_MEMSET_EXPLICIT], [ gl_PREREQ_MEMSET_EXPLICIT ]) gl_STRING_MODULE_INDICATOR([memset_explicit])	string

Date and time <time.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
timespec_get	#include <time.h>	timespec_get.c	timespec_get.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_TIMESPEC_GET gl_CONDITIONAL([GL_COND_OBJ_TIMESPEC_GET], [test $HAVE_TIMESPEC_GET = 0 \|\| test $REPLACE_TIMESPEC_GET = 1]) gl_TIME_MODULE_INDICATOR([timespec_get])	time-h extensions gettime [test $HAVE_TIMESPEC_GET = 0 \|\| test $REPLACE_TIMESPEC_GET = 1]
timespec_getres	#include <time.h>	timespec_getres.c	timespec_getres.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_FUNC_TIMESPEC_GETRES]) gl_CONDITIONAL([GL_COND_OBJ_TIMESPEC_GETRES], [test $HAVE_TIMESPEC_GETRES = 0]) gl_TIME_MODULE_INDICATOR([timespec_getres])	extensions time-h gettime-res [test $HAVE_TIMESPEC_GETRES = 0]

Support for GNU multiple precision arithmetic

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
libgmp	#include <gmp.h>	mini-gmp-gnulib.c mini-gmp.c mini-gmp.h	libgmp.m4 00gnulib.m4 zzgnulib.m4 gl_LIBGMP gl_CONDITIONAL_HEADER([gmp.h]) AC_PROG_MKDIR_P gl_CONDITIONAL([GL_COND_OBJ_MINI_GMP_GNULIB], [test $HAVE_LIBGMP != yes])	---

Support for sharing code with the GNU C Library

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
libc-config	#include <libc-config.h>	cdefs.h libc-config.h	__inline.m4 00gnulib.m4 zzgnulib.m4 gl___INLINE	c99

Support for obsolete systems lacking POSIX:2008

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
strdup	#include <string.h>	---	strdup.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_STRDUP gl_STRING_MODULE_INDICATOR([strdup])	string

Support for systems lacking POSIX:2008

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
accept	#include <sys/socket.h>	accept.c w32sock.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_SYS_SOCKET_H]) gl_CONDITIONAL([GL_COND_OBJ_ACCEPT], [test "$ac_cv_header_winsock2_h" = yes]) gl_SYS_SOCKET_MODULE_INDICATOR([accept])	extensions sys_socket socketlib errno [test "$ac_cv_header_winsock2_h" = yes] msvc-nothrow [test "$ac_cv_header_winsock2_h" = yes]
alphasort	#include <dirent.h>	alphasort.c	alphasort.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ALPHASORT gl_CONDITIONAL([GL_COND_OBJ_ALPHASORT], [test $HAVE_ALPHASORT = 0]) AM_COND_IF([GL_COND_OBJ_ALPHASORT], [ gl_PREREQ_ALPHASORT ]) gl_DIRENT_MODULE_INDICATOR([alphasort])	dirent extensions
arpa_inet	#include <arpa/inet.h>	arpa_inet.in.h	arpa_inet_h.m4 sys_socket_h.m4 socklen.m4 00gnulib.m4 zzgnulib.m4 gl_ARPA_INET_H gl_ARPA_INET_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	gen-header include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use sys_socket
bind	#include <sys/socket.h>	bind.c w32sock.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_SYS_SOCKET_H]) gl_CONDITIONAL([GL_COND_OBJ_BIND], [test "$ac_cv_header_winsock2_h" = yes]) gl_SYS_SOCKET_MODULE_INDICATOR([bind])	sys_socket socketlib errno [test "$ac_cv_header_winsock2_h" = yes] msvc-nothrow [test "$ac_cv_header_winsock2_h" = yes]
calloc-posix	#include <stdlib.h>	calloc.c	calloc.m4 malloc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_CALLOC_POSIX if test $REPLACE_CALLOC_FOR_CALLOC_POSIX = 1; then AC_LIBOBJ([calloc]) fi gl_STDLIB_MODULE_INDICATOR([calloc-posix])	stdlib xalloc-oversized [test $REPLACE_CALLOC_FOR_CALLOC_POSIX = 1]
chmod	#include <sys/stat.h>	chmod.c	chmod.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_CHMOD gl_CONDITIONAL([GL_COND_OBJ_CHMOD], [test $REPLACE_CHMOD = 1]) AM_COND_IF([GL_COND_OBJ_CHMOD], [ gl_PREREQ_CHMOD ]) gl_SYS_STAT_MODULE_INDICATOR([chmod])	sys_stat lstat [test $REPLACE_CHMOD = 1]
chmodat	#include "openat.h"	chmodat.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([chmodat]) dnl for lib/openat.h	fchmodat
chown	#include <unistd.h>	chown.c fchown-stub.c	chown.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_CHOWN gl_CONDITIONAL([GL_COND_OBJ_CHOWN], [test $HAVE_CHOWN = 0 \|\| test $REPLACE_CHOWN = 1]) gl_CONDITIONAL([GL_COND_OBJ_FCHOWN_STUB], [test $REPLACE_CHOWN = 1 && test $ac_cv_func_fchown = no]) gl_UNISTD_MODULE_INDICATOR([chown])	unistd fstat [test $HAVE_CHOWN = 0 \|\| test $REPLACE_CHOWN = 1] open [test $HAVE_CHOWN = 0 \|\| test $REPLACE_CHOWN = 1] stat [test $HAVE_CHOWN = 0 \|\| test $REPLACE_CHOWN = 1] stdbool [test $HAVE_CHOWN = 0 \|\| test $REPLACE_CHOWN = 1] sys_stat [test $HAVE_CHOWN = 0 \|\| test $REPLACE_CHOWN = 1]
chownat	#include "openat.h"	chownat.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([chownat]) dnl for lib/openat.h	fchownat
close	#include <unistd.h>	close.c	close.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_CLOSE gl_CONDITIONAL([GL_COND_OBJ_CLOSE], [test $REPLACE_CLOSE = 1]) gl_UNISTD_MODULE_INDICATOR([close])	unistd fd-hook [test $REPLACE_CLOSE = 1] msvc-inval [test $REPLACE_CLOSE = 1]
connect	#include <sys/socket.h>	connect.c w32sock.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_SYS_SOCKET_H]) gl_CONDITIONAL([GL_COND_OBJ_CONNECT], [test "$ac_cv_header_winsock2_h" = yes]) gl_SYS_SOCKET_MODULE_INDICATOR([connect])	sys_socket socketlib errno [test "$ac_cv_header_winsock2_h" = yes] msvc-nothrow [test "$ac_cv_header_winsock2_h" = yes]
dirent	#include <dirent.h>	dirent.in.h	dirent_h.m4 unistd_h.m4 pid_t.m4 00gnulib.m4 zzgnulib.m4 gl_DIRENT_H gl_DIRENT_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	gen-header include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use
dprintf	#include <stdio.h>	dprintf.c	dprintf.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_DPRINTF gl_STDIO_MODULE_INDICATOR([dprintf])	stdio vasnprintf [test $ac_cv_func_dprintf = no \|\| test $REPLACE_DPRINTF = 1] free-posix [test $ac_cv_func_dprintf = no \|\| test $REPLACE_DPRINTF = 1] full-write [test $ac_cv_func_dprintf = no \|\| test $REPLACE_DPRINTF = 1] errno [test $ac_cv_func_dprintf = no \|\| test $REPLACE_DPRINTF = 1]
dprintf-posix	#include <stdio.h>	---	dprintf-posix.m4 printf.m4 math_h.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_DPRINTF_POSIX	dprintf nocrash printf-safe multiarch vasnprintf [test $ac_cv_func_dprintf = no \|\| test $REPLACE_DPRINTF = 1] isnand-nolibm [test $ac_cv_func_dprintf = no \|\| test $REPLACE_DPRINTF = 1] isnanl-nolibm [test $ac_cv_func_dprintf = no \|\| test $REPLACE_DPRINTF = 1] frexp-nolibm [test $ac_cv_func_dprintf = no \|\| test $REPLACE_DPRINTF = 1] frexpl-nolibm [test $ac_cv_func_dprintf = no \|\| test $REPLACE_DPRINTF = 1] printf-frexp [test $ac_cv_func_dprintf = no \|\| test $REPLACE_DPRINTF = 1] printf-frexpl [test $ac_cv_func_dprintf = no \|\| test $REPLACE_DPRINTF = 1] signbit [test $ac_cv_func_dprintf = no \|\| test $REPLACE_DPRINTF = 1] fpucw [test $ac_cv_func_dprintf = no \|\| test $REPLACE_DPRINTF = 1]
dup2	#include <unistd.h>	dup2.c	dup2.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_DUP2 gl_CONDITIONAL([GL_COND_OBJ_DUP2], [test $REPLACE_DUP2 = 1]) AM_COND_IF([GL_COND_OBJ_DUP2], [ gl_PREREQ_DUP2 ]) gl_UNISTD_MODULE_INDICATOR([dup2])	unistd msvc-inval [test $REPLACE_DUP2 = 1] msvc-nothrow [test $REPLACE_DUP2 = 1]
duplocale	#include <locale.h>	duplocale.c	duplocale.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_DUPLOCALE gl_CONDITIONAL([GL_COND_OBJ_DUPLOCALE], [test $HAVE_DUPLOCALE = 1 && test $REPLACE_DUPLOCALE = 1]) AM_COND_IF([GL_COND_OBJ_DUPLOCALE], [ gl_PREREQ_DUPLOCALE ]) gl_LOCALE_MODULE_INDICATOR([duplocale])	locale setlocale-null [test $HAVE_DUPLOCALE = 1 && test $REPLACE_DUPLOCALE = 1]
environ	#include <unistd.h>	---	environ.m4 00gnulib.m4 zzgnulib.m4 gl_ENVIRON gl_UNISTD_MODULE_INDICATOR([environ])	unistd extensions
errno	#include <errno.h>	errno.in.h	errno_h.m4 00gnulib.m4 zzgnulib.m4 gl_HEADER_ERRNO_H gl_CONDITIONAL_HEADER([errno.h]) AC_PROG_MKDIR_P	gen-header include_next
execl	#include <unistd.h>	execl.c	execl.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_EXECL gl_CONDITIONAL([GL_COND_OBJ_EXECL], [test $REPLACE_EXECL = 1]) gl_UNISTD_MODULE_INDICATOR([execl])	unistd execv [test $REPLACE_EXECL = 1] malloca [test $REPLACE_EXECL = 1]
execle	#include <unistd.h>	execle.c	execle.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_EXECLE gl_CONDITIONAL([GL_COND_OBJ_EXECLE], [test $REPLACE_EXECLE = 1]) gl_UNISTD_MODULE_INDICATOR([execle])	unistd execve [test $REPLACE_EXECLE = 1] malloca [test $REPLACE_EXECLE = 1]
execlp	#include <unistd.h>	execlp.c	execlp.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_EXECLP gl_CONDITIONAL([GL_COND_OBJ_EXECLP], [test $REPLACE_EXECLP = 1]) gl_UNISTD_MODULE_INDICATOR([execlp])	unistd execvp [test $REPLACE_EXECLP = 1] malloca [test $REPLACE_EXECLP = 1]
execv	#include <unistd.h>	execv.c	execv.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_EXECV gl_CONDITIONAL([GL_COND_OBJ_EXECV], [test $REPLACE_EXECV = 1]) gl_UNISTD_MODULE_INDICATOR([execv])	unistd environ [test $REPLACE_EXECV = 1] execve [test $REPLACE_EXECV = 1]
execve	#include <unistd.h>	execve.c	execve.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_EXECVE gl_CONDITIONAL([GL_COND_OBJ_EXECVE], [test $REPLACE_EXECVE = 1]) gl_UNISTD_MODULE_INDICATOR([execve])	unistd posix_spawn [test $REPLACE_EXECVE = 1] close [test $REPLACE_EXECVE = 1] sys_wait [test $REPLACE_EXECVE = 1] waitpid [test $REPLACE_EXECVE = 1]
execvp	#include <unistd.h>	execvp.c	execvp.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_EXECVP gl_CONDITIONAL([GL_COND_OBJ_EXECVP], [test $REPLACE_EXECVP = 1]) gl_UNISTD_MODULE_INDICATOR([execvp])	unistd environ [test $REPLACE_EXECVP = 1] execvpe [test $REPLACE_EXECVP = 1]
execvpe	#include <unistd.h>	execvpe.c	execvpe.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_EXECVPE gl_CONDITIONAL([GL_COND_OBJ_EXECVPE], [test $HAVE_EXECVPE = 0 \|\| test $REPLACE_EXECVPE = 1]) gl_UNISTD_MODULE_INDICATOR([execvpe])	unistd extensions free-posix [test $HAVE_EXECVPE = 0 \|\| test $REPLACE_EXECVPE = 1] stdbool [test $HAVE_EXECVPE = 0 \|\| test $REPLACE_EXECVPE = 1] findprog-in [test $HAVE_EXECVPE = 0 \|\| test $REPLACE_EXECVPE = 1] execve [test $HAVE_EXECVPE = 0 \|\| test $REPLACE_EXECVPE = 1]
fchdir	#include <unistd.h>	fchdir.c	fchdir.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FCHDIR gl_CONDITIONAL([GL_COND_OBJ_FCHDIR], [test $HAVE_FCHDIR = 0]) AM_COND_IF([GL_COND_OBJ_FCHDIR], [ gl_PREREQ_FCHDIR ]) gl_UNISTD_MODULE_INDICATOR([fchdir])	unistd assure [test $HAVE_FCHDIR = 0] chdir [test $HAVE_FCHDIR = 0] close [test $HAVE_FCHDIR = 0] dirent [test $HAVE_FCHDIR = 0] dirfd [test $HAVE_FCHDIR = 0] dup2 [test $HAVE_FCHDIR = 0] fcntl [test $HAVE_FCHDIR = 0] fcntl-h [test $HAVE_FCHDIR = 0] filename [test $HAVE_FCHDIR = 0] filenamecat-lgpl [test $HAVE_FCHDIR = 0] free-posix [test $HAVE_FCHDIR = 0] fstat [test $HAVE_FCHDIR = 0] getcwd-lgpl [test $HAVE_FCHDIR = 0] malloc-posix [test $HAVE_FCHDIR = 0] open [test $HAVE_FCHDIR = 0] realloc-posix [test $HAVE_FCHDIR = 0] stat [test $HAVE_FCHDIR = 0] stdbool [test $HAVE_FCHDIR = 0] strdup-posix [test $HAVE_FCHDIR = 0] sys_stat [test $HAVE_FCHDIR = 0]
fclose	#include <stdio.h>	fclose.c	fclose.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FCLOSE gl_CONDITIONAL([GL_COND_OBJ_FCLOSE], [test $REPLACE_FCLOSE = 1]) gl_STDIO_MODULE_INDICATOR([fclose])	stdio close [test $REPLACE_FCLOSE = 1] fflush [test $REPLACE_FCLOSE = 1] freading [test $REPLACE_FCLOSE = 1] lseek [test $REPLACE_FCLOSE = 1] msvc-inval [test $REPLACE_FCLOSE = 1]
fcntl-h	#include <fcntl.h>	fcntl.in.h	fcntl_h.m4 fcntl-o.m4 pid_t.m4 00gnulib.m4 zzgnulib.m4 gl_FCNTL_H gl_FCNTL_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	extensions gen-header include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use sys_types unistd
fcntl	#include <fcntl.h>	fcntl.c	fcntl.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FCNTL gl_CONDITIONAL([GL_COND_OBJ_FCNTL], [test $HAVE_FCNTL = 0 \|\| test $REPLACE_FCNTL = 1]) gl_FCNTL_MODULE_INDICATOR([fcntl])	fcntl-h extensions close [test $HAVE_FCNTL = 0 \|\| test $REPLACE_FCNTL = 1] dup2 [test $HAVE_FCNTL = 0 \|\| test $REPLACE_FCNTL = 1] getdtablesize [test $HAVE_FCNTL = 0 \|\| test $REPLACE_FCNTL = 1] msvc-nothrow [test $HAVE_FCNTL = 0 \|\| test $REPLACE_FCNTL = 1]
fdatasync	#include <unistd.h>	fdatasync.c	fdatasync.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FDATASYNC gl_CONDITIONAL([GL_COND_OBJ_FDATASYNC], [test $HAVE_FDATASYNC = 0 \|\| test $REPLACE_FDATASYNC = 1]) gl_UNISTD_MODULE_INDICATOR([fdatasync])	fsync [test $HAVE_FDATASYNC = 0 \|\| test $REPLACE_FDATASYNC = 1] unistd
flock	#include <sys/file.h>	flock.c	flock.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FLOCK gl_CONDITIONAL([GL_COND_OBJ_FLOCK], [test $HAVE_FLOCK = 0]) AM_COND_IF([GL_COND_OBJ_FLOCK], [ gl_PREREQ_FLOCK ]) gl_SYS_FILE_MODULE_INDICATOR([flock])	sys_file msvc-nothrow [test $HAVE_FLOCK = 0]
fopen	#include <stdio.h>	fopen.c	fopen.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FOPEN if test $REPLACE_FOPEN = 1; then AC_LIBOBJ([fopen]) gl_PREREQ_FOPEN fi gl_STDIO_MODULE_INDICATOR([fopen])	stdio largefile fcntl-h [test $REPLACE_FOPEN = 1] stdbool [test $REPLACE_FOPEN = 1] unistd [test $REPLACE_FOPEN = 1] close [test $REPLACE_FOPEN = 1] fstat [test $REPLACE_FOPEN = 1]
fprintf-posix	#include <stdio.h>	fprintf.c	fprintf-posix.m4 printf.m4 math_h.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FPRINTF_POSIX gl_STDIO_MODULE_INDICATOR([fprintf-posix])	stdio nocrash printf-safe errno multiarch fseterr [test $REPLACE_FPRINTF = 1] vasnprintf [test $REPLACE_FPRINTF = 1] isnand-nolibm [test $REPLACE_FPRINTF = 1] isnanl-nolibm [test $REPLACE_FPRINTF = 1] free-posix [test $REPLACE_FPRINTF = 1] frexp-nolibm [test $REPLACE_FPRINTF = 1] frexpl-nolibm [test $REPLACE_FPRINTF = 1] printf-frexp [test $REPLACE_FPRINTF = 1] printf-frexpl [test $REPLACE_FPRINTF = 1] signbit [test $REPLACE_FPRINTF = 1] fpucw [test $REPLACE_FPRINTF = 1]
freopen	#include <stdio.h>	freopen.c	freopen.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FREOPEN gl_CONDITIONAL([GL_COND_OBJ_FREOPEN], [test $REPLACE_FREOPEN = 1]) AM_COND_IF([GL_COND_OBJ_FREOPEN], [ gl_PREREQ_FREOPEN ]) gl_STDIO_MODULE_INDICATOR([freopen])	fcntl-h [test $REPLACE_FREOPEN = 1] open [test $REPLACE_FREOPEN = 1] stdio largefile
fseek	#include <stdio.h>	fseek.c	fseek.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FSEEK gl_CONDITIONAL([GL_COND_OBJ_FSEEK], [test $REPLACE_FSEEK = 1]) gl_STDIO_MODULE_INDICATOR([fseek])	stdio fseeko [test $REPLACE_FSEEK = 1]
fseeko	#include <stdio.h>	fseeko.c stdio-impl.h	fseeko.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FSEEKO gl_CONDITIONAL([GL_COND_OBJ_FSEEKO], [test $HAVE_FSEEKO = 0 \|\| test $REPLACE_FSEEKO = 1]) AM_COND_IF([GL_COND_OBJ_FSEEKO], [ gl_PREREQ_FSEEKO ]) gl_STDIO_MODULE_INDICATOR([fseeko])	extensions largefile lseek stdio sys_types fseek
fsync	#include <unistd.h>	fsync.c	fsync.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FSYNC gl_CONDITIONAL([GL_COND_OBJ_FSYNC], [test $HAVE_FSYNC = 0]) AM_COND_IF([GL_COND_OBJ_FSYNC], [ gl_PREREQ_FSYNC ]) gl_UNISTD_MODULE_INDICATOR([fsync])	unistd msvc-nothrow [test $HAVE_FSYNC = 0]
ftell	#include <stdio.h>	ftell.c	ftell.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FTELL gl_CONDITIONAL([GL_COND_OBJ_FTELL], [test $REPLACE_FTELL = 1]) gl_STDIO_MODULE_INDICATOR([ftell])	stdio errno ftello [test $REPLACE_FTELL = 1]
ftello	#include <stdio.h>	ftello.c stdio-impl.h	fseeko.m4 ftello.m4 ungetc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FTELLO gl_CONDITIONAL([GL_COND_OBJ_FTELLO], [test $HAVE_FTELLO = 0 \|\| test $REPLACE_FTELLO = 1]) AM_COND_IF([GL_COND_OBJ_FTELLO], [ gl_PREREQ_FTELLO ]) gl_STDIO_MODULE_INDICATOR([ftello])	stdio extensions largefile sys_types lseek [test $HAVE_FTELLO = 0 \|\| test $REPLACE_FTELLO = 1] intprops [test $HAVE_FTELLO = 0 \|\| test $REPLACE_FTELLO = 1] ftell
ftruncate	#include <unistd.h>	ftruncate.c	ftruncate.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FTRUNCATE gl_CONDITIONAL([GL_COND_OBJ_FTRUNCATE], [test $HAVE_FTRUNCATE = 0 \|\| test $REPLACE_FTRUNCATE = 1]) AM_COND_IF([GL_COND_OBJ_FTRUNCATE], [ gl_PREREQ_FTRUNCATE ]) gl_UNISTD_MODULE_INDICATOR([ftruncate])	unistd sys_types largefile msvc-nothrow [test $HAVE_FTRUNCATE = 0 \|\| test $REPLACE_FTRUNCATE = 1] msvc-inval [test $HAVE_FTRUNCATE = 0 \|\| test $REPLACE_FTRUNCATE = 1]
futimens	#include <sys/stat.h>	futimens.c	futimens.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FUTIMENS gl_CONDITIONAL([GL_COND_OBJ_FUTIMENS], [test $HAVE_FUTIMENS = 0 \|\| test $REPLACE_FUTIMENS = 1]) gl_SYS_STAT_MODULE_INDICATOR([futimens])	sys_stat extensions utimens [test $HAVE_FUTIMENS = 0 \|\| test $REPLACE_FUTIMENS = 1]
getaddrinfo	#include <netdb.h>	getaddrinfo.c gai_strerror.c	getaddrinfo.m4 00gnulib.m4 zzgnulib.m4 gl_GETADDRINFO gl_CONDITIONAL([GL_COND_OBJ_GETADDRINFO], [test $HAVE_GETADDRINFO = 0 \|\| test $REPLACE_GETADDRINFO = 1]) gl_CONDITIONAL([GL_COND_OBJ_GAI_STRERROR], [test $HAVE_DECL_GAI_STRERROR = 0 \|\| test $REPLACE_GAI_STRERROR = 1]) gl_NETDB_MODULE_INDICATOR([getaddrinfo])	netdb sys_socket extensions gettext-h [test $HAVE_GETADDRINFO = 0 \|\| test $REPLACE_GETADDRINFO = 1 \|\| test $HAVE_DECL_GAI_STRERROR = 0 \|\| test $REPLACE_GAI_STRERROR = 1] inet_ntop [test $HAVE_GETADDRINFO = 0 \|\| test $REPLACE_GETADDRINFO = 1] snprintf [test $HAVE_GETADDRINFO = 0 \|\| test $REPLACE_GETADDRINFO = 1] stdbool [test $HAVE_GETADDRINFO = 0 \|\| test $REPLACE_GETADDRINFO = 1] strdup [test $HAVE_GETADDRINFO = 0 \|\| test $REPLACE_GETADDRINFO = 1] servent [test $HAVE_GETADDRINFO = 0 \|\| test $REPLACE_GETADDRINFO = 1] hostent [test $HAVE_GETADDRINFO = 0 \|\| test $REPLACE_GETADDRINFO = 1] sockets [test $HAVE_GETADDRINFO = 0 \|\| test $REPLACE_GETADDRINFO = 1]
getcwd	#include <unistd.h>	getcwd.c	getcwd-abort-bug.m4 getcwd-path-max.m4 getcwd.m4 getpagesize.m4 pathmax.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_GETCWD gl_CONDITIONAL([GL_COND_OBJ_GETCWD], [test $REPLACE_GETCWD = 1]) AM_COND_IF([GL_COND_OBJ_GETCWD], [ gl_PREREQ_GETCWD ]) gl_MODULE_INDICATOR([getcwd]) gl_UNISTD_MODULE_INDICATOR([getcwd])	unistd extensions pathmax [test $REPLACE_GETCWD = 1] msvc-inval [test $REPLACE_GETCWD = 1] mempcpy [test $REPLACE_GETCWD = 1] d-ino [test $REPLACE_GETCWD = 1] memmove [test $REPLACE_GETCWD = 1] openat [test $REPLACE_GETCWD = 1] fcntl-h [test $REPLACE_GETCWD = 1] fdopendir [test $REPLACE_GETCWD = 1] fstat [test $REPLACE_GETCWD = 1] fstatat [test $REPLACE_GETCWD = 1] opendir [test $REPLACE_GETCWD = 1] readdir [test $REPLACE_GETCWD = 1] rewinddir [test $REPLACE_GETCWD = 1] closedir [test $REPLACE_GETCWD = 1] stdbool [test $REPLACE_GETCWD = 1] malloc-posix [test $REPLACE_GETCWD = 1] strdup-posix [test $REPLACE_GETCWD = 1]
getcwd-lgpl	#include <unistd.h>	getcwd-lgpl.c	getcwd.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_GETCWD_LGPL gl_CONDITIONAL([GL_COND_OBJ_GETCWD_LGPL], [test $REPLACE_GETCWD = 1]) gl_UNISTD_MODULE_INDICATOR([getcwd])	unistd free-posix [test $REPLACE_GETCWD = 1] strdup [test $REPLACE_GETCWD = 1]
getgroups	#include <unistd.h>	getgroups.c	getgroups.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_GETGROUPS gl_CONDITIONAL([GL_COND_OBJ_GETGROUPS], [test $HAVE_GETGROUPS = 0 \|\| test $REPLACE_GETGROUPS = 1]) gl_UNISTD_MODULE_INDICATOR([getgroups])	unistd free-posix [test $HAVE_GETGROUPS = 0 \|\| test $REPLACE_GETGROUPS = 1] malloc-posix [test $HAVE_GETGROUPS = 0 \|\| test $REPLACE_GETGROUPS = 1] stdint [test $HAVE_GETGROUPS = 0 \|\| test $REPLACE_GETGROUPS = 1]
gethostname	#include <unistd.h>	gethostname.c w32sock.h	gethostname.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_GETHOSTNAME gl_CONDITIONAL([GL_COND_OBJ_GETHOSTNAME], [test $HAVE_GETHOSTNAME = 0]) AM_COND_IF([GL_COND_OBJ_GETHOSTNAME], [ gl_PREREQ_GETHOSTNAME ]) gl_UNISTD_MODULE_INDICATOR([gethostname])	unistd sys_socket [test $HAVE_GETHOSTNAME = 0] errno [test $HAVE_GETHOSTNAME = 0] sockets [test $HAVE_GETHOSTNAME = 0] msvc-nothrow [test $HAVE_GETHOSTNAME = 0]
getlogin	#include <unistd.h>	getlogin.c	getlogin.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_GETLOGIN gl_CONDITIONAL([GL_COND_OBJ_GETLOGIN], [test $HAVE_GETLOGIN = 0]) gl_UNISTD_MODULE_INDICATOR([getlogin]) AC_REQUIRE([gl_LIB_GETLOGIN])	unistd
getlogin_r	#include <unistd.h>	getlogin_r.c	getlogin_r.m4 getlogin.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_GETLOGIN_R gl_CONDITIONAL([GL_COND_OBJ_GETLOGIN_R], [test $HAVE_GETLOGIN_R = 0 \|\| test $REPLACE_GETLOGIN_R = 1]) AM_COND_IF([GL_COND_OBJ_GETLOGIN_R], [ gl_PREREQ_GETLOGIN_R ]) gl_UNISTD_MODULE_INDICATOR([getlogin_r]) AC_REQUIRE([gl_LIB_GETLOGIN])	unistd extensions malloca [test $HAVE_GETLOGIN_R = 0 \|\| test $REPLACE_GETLOGIN_R = 1] memchr [test $HAVE_GETLOGIN_R = 0 \|\| test $REPLACE_GETLOGIN_R = 1]
getopt-posix	#include <unistd.h>	getopt.c getopt1.c getopt.in.h getopt-cdefs.in.h getopt-core.h getopt-ext.h getopt-pfx-core.h getopt-pfx-ext.h getopt_int.h	getopt.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_GETOPT_POSIX gl_CONDITIONAL_HEADER([getopt.h]) gl_CONDITIONAL_HEADER([getopt-cdefs.h]) AC_PROG_MKDIR_P gl_CONDITIONAL([GL_COND_OBJ_GETOPT], [test $REPLACE_GETOPT = 1]) AM_COND_IF([GL_COND_OBJ_GETOPT], [ dnl Define the substituted variable GNULIB_UNISTD_H_GETOPT to 1. gl_UNISTD_H_REQUIRE_DEFAULTS gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNISTD_H_GETOPT], [1]) ]) gl_UNISTD_MODULE_INDICATOR([getopt-posix])	unistd extensions include_next gen-header gettext-h [test $REPLACE_GETOPT = 1] snippet/arg-nonnull
getpeername	#include <sys/socket.h>	getpeername.c w32sock.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_SYS_SOCKET_H]) gl_CONDITIONAL([GL_COND_OBJ_GETPEERNAME], [test "$ac_cv_header_winsock2_h" = yes]) gl_SYS_SOCKET_MODULE_INDICATOR([getpeername])	extensions sys_socket socketlib errno [test "$ac_cv_header_winsock2_h" = yes] msvc-nothrow [test "$ac_cv_header_winsock2_h" = yes]
getsockname	#include <sys/socket.h>	getsockname.c w32sock.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_SYS_SOCKET_H]) gl_CONDITIONAL([GL_COND_OBJ_GETSOCKNAME], [test "$ac_cv_header_winsock2_h" = yes]) gl_SYS_SOCKET_MODULE_INDICATOR([getsockname])	extensions sys_socket socketlib errno [test "$ac_cv_header_winsock2_h" = yes] msvc-nothrow [test "$ac_cv_header_winsock2_h" = yes]
getsockopt	#include <sys/socket.h>	getsockopt.c w32sock.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_SYS_SOCKET_H]) gl_CONDITIONAL([GL_COND_OBJ_GETSOCKOPT], [test "$ac_cv_header_winsock2_h" = yes]) gl_SYS_SOCKET_MODULE_INDICATOR([getsockopt])	extensions sys_socket socketlib sys_time [test "$ac_cv_header_winsock2_h" = yes] errno [test "$ac_cv_header_winsock2_h" = yes] msvc-nothrow [test "$ac_cv_header_winsock2_h" = yes]
getsubopt	#include <stdlib.h>	getsubopt.c	getsubopt.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_GETSUBOPT gl_CONDITIONAL([GL_COND_OBJ_GETSUBOPT], [test $HAVE_GETSUBOPT = 0 \|\| test $REPLACE_GETSUBOPT = 1]) AM_COND_IF([GL_COND_OBJ_GETSUBOPT], [ gl_PREREQ_GETSUBOPT ]) gl_STDLIB_MODULE_INDICATOR([getsubopt])	stdlib extensions strchrnul [test $HAVE_GETSUBOPT = 0 \|\| test $REPLACE_GETSUBOPT = 1] memchr [test $HAVE_GETSUBOPT = 0 \|\| test $REPLACE_GETSUBOPT = 1]
gettimeofday	#include <sys/time.h>	gettimeofday.c	gettimeofday.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_GETTIMEOFDAY gl_CONDITIONAL([GL_COND_OBJ_GETTIMEOFDAY], [test $HAVE_GETTIMEOFDAY = 0 \|\| test $REPLACE_GETTIMEOFDAY = 1]) AM_COND_IF([GL_COND_OBJ_GETTIMEOFDAY], [ gl_PREREQ_GETTIMEOFDAY ]) gl_SYS_TIME_MODULE_INDICATOR([gettimeofday])	sys_time
grantpt	#include <stdlib.h>	grantpt.c pty-private.h	grantpt.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_GRANTPT gl_CONDITIONAL([GL_COND_OBJ_GRANTPT], [test $HAVE_GRANTPT = 0]) AM_COND_IF([GL_COND_OBJ_GRANTPT], [ gl_PREREQ_GRANTPT ]) gl_STDLIB_MODULE_INDICATOR([grantpt])	stdlib extensions pt_chown [test $HAVE_GRANTPT = 0] waitpid [test $HAVE_GRANTPT = 0] configmake [test $HAVE_GRANTPT = 0]
hostent	#include <netdb.h>	---	hostent.m4 00gnulib.m4 zzgnulib.m4 gl_HOSTENT	sys_socket
iconv-h	#if HAVE_ICONV_H # include <iconv.h> #endif	iconv.in.h	iconv_h.m4 00gnulib.m4 zzgnulib.m4 gl_ICONV_H gl_ICONV_H_REQUIRE_DEFAULTS gl_CONDITIONAL_HEADER([iconv.h]) AC_PROG_MKDIR_P	gen-header include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use
iconv_open	#if HAVE_ICONV # include <iconv.h> #endif	iconv_open.c iconv_open-aix.gperf iconv_open-hpux.gperf iconv_open-irix.gperf iconv_open-osf.gperf iconv_open-solaris.gperf iconv_open-zos.gperf iconv.c iconv_close.c	iconv_open.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ICONV_OPEN dnl Because of gl_REPLACE_ICONV_H: gl_CONDITIONAL_HEADER([iconv.h]) gl_CONDITIONAL([GL_COND_OBJ_ICONV_OPEN], [test $REPLACE_ICONV_OPEN = 1]) gl_CONDITIONAL([GL_COND_OBJ_ICONV], [test $REPLACE_ICONV = 1])	gperf iconv-h iconv c-ctype [test $REPLACE_ICONV_OPEN = 1] c-strcase [test $REPLACE_ICONV_OPEN = 1] stdint [test $REPLACE_ICONV_UTF = 1] unistr/u8-mbtoucr [test $REPLACE_ICONV_UTF = 1] unistr/u8-uctomb [test $REPLACE_ICONV_UTF = 1]
inet_ntop	#include <arpa/inet.h>	inet_ntop.c	inet_ntop.m4 sys_socket_h.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_INET_NTOP gl_CONDITIONAL([GL_COND_OBJ_INET_NTOP], [test $HAVE_INET_NTOP = 0 \|\| test $REPLACE_INET_NTOP = 1]) AM_COND_IF([GL_COND_OBJ_INET_NTOP], [ gl_PREREQ_INET_NTOP ]) gl_ARPA_INET_MODULE_INDICATOR([inet_ntop])	arpa_inet extensions sys_socket [test $HAVE_INET_NTOP = 0 \|\| test $REPLACE_INET_NTOP = 1] errno [test $HAVE_INET_NTOP = 0 \|\| test $REPLACE_INET_NTOP = 1] netinet_in [test $HAVE_INET_NTOP = 0 \|\| test $REPLACE_INET_NTOP = 1]
inet_pton	#include <arpa/inet.h>	inet_pton.c	inet_pton.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_INET_PTON gl_CONDITIONAL([GL_COND_OBJ_INET_PTON], [test $HAVE_INET_PTON = 0 \|\| test $REPLACE_INET_PTON = 1]) AM_COND_IF([GL_COND_OBJ_INET_PTON], [ gl_PREREQ_INET_PTON ]) gl_ARPA_INET_MODULE_INDICATOR([inet_pton])	arpa_inet extensions c-ctype [test $HAVE_INET_PTON = 0 \|\| test $REPLACE_INET_PTON = 1] sys_socket [test $HAVE_INET_PTON = 0 \|\| test $REPLACE_INET_PTON = 1] errno [test $HAVE_INET_PTON = 0 \|\| test $REPLACE_INET_PTON = 1] netinet_in [test $HAVE_INET_PTON = 0 \|\| test $REPLACE_INET_PTON = 1]
ioctl	#include <sys/ioctl.h>	ioctl.c w32sock.h	ioctl.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_IOCTL gl_CONDITIONAL([GL_COND_OBJ_IOCTL], [test $HAVE_IOCTL = 0 \|\| test $REPLACE_IOCTL = 1]) gl_SYS_IOCTL_MODULE_INDICATOR([ioctl])	sys_ioctl sys_socket [test $HAVE_IOCTL = 0 \|\| test $REPLACE_IOCTL = 1] errno [test $HAVE_IOCTL = 0 \|\| test $REPLACE_IOCTL = 1] fd-hook [test $HAVE_IOCTL = 0 \|\| test $REPLACE_IOCTL = 1] msvc-nothrow [test $HAVE_IOCTL = 0 \|\| test $REPLACE_IOCTL = 1]
isblank	#include <ctype.h>	isblank.c	isblank.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ISBLANK gl_CONDITIONAL([GL_COND_OBJ_ISBLANK], [test $HAVE_ISBLANK = 0]) gl_MODULE_INDICATOR([isblank]) gl_CTYPE_MODULE_INDICATOR([isblank])	extensions ctype
langinfo	#include <langinfo.h>	langinfo.in.h	langinfo_h.m4 00gnulib.m4 zzgnulib.m4 gl_LANGINFO_H gl_LANGINFO_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	extensions gen-header include_next snippet/c++defs snippet/warn-on-use
link	#include <unistd.h>	link.c	link.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_LINK gl_CONDITIONAL([GL_COND_OBJ_LINK], [test $HAVE_LINK = 0 \|\| test $REPLACE_LINK = 1]) gl_UNISTD_MODULE_INDICATOR([link])	unistd free-posix [test $HAVE_LINK = 0 \|\| test $REPLACE_LINK = 1] stat [test $HAVE_LINK = 0 \|\| test $REPLACE_LINK = 1] strdup-posix [test $HAVE_LINK = 0 \|\| test $REPLACE_LINK = 1] sys_stat [test $HAVE_LINK = 0 \|\| test $REPLACE_LINK = 1]
linkat	#include <fcntl.h> #include <unistd.h>	at-func2.c linkat.c	linkat.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_LINKAT gl_CONDITIONAL([GL_COND_OBJ_LINKAT], [test $HAVE_LINKAT = 0 \|\| test $REPLACE_LINKAT = 1]) AM_COND_IF([GL_COND_OBJ_LINKAT], [ AC_LIBOBJ([at-func2]) ]) gl_UNISTD_MODULE_INDICATOR([linkat])	unistd extensions areadlink [test $HAVE_LINKAT = 0 \|\| test $REPLACE_LINKAT = 1] at-internal [test $HAVE_LINKAT = 0 \|\| test $REPLACE_LINKAT = 1] dirname-lgpl [test $HAVE_LINKAT = 0 \|\| test $REPLACE_LINKAT = 1] eloop-threshold [test $HAVE_LINKAT = 0 \|\| test $REPLACE_LINKAT = 1] errno [test $HAVE_LINKAT = 0 \|\| test $REPLACE_LINKAT = 1] fcntl-h [test $HAVE_LINKAT = 0 \|\| test $REPLACE_LINKAT = 1] filenamecat-lgpl [test $HAVE_LINKAT = 0 \|\| test $REPLACE_LINKAT = 1] filename [test $HAVE_LINKAT = 0 \|\| test $REPLACE_LINKAT = 1] free-posix [test $HAVE_LINKAT = 0 \|\| test $REPLACE_LINKAT = 1] fstat [test $HAVE_LINKAT = 0 \|\| test $REPLACE_LINKAT = 1] getcwd-lgpl [test $HAVE_LINKAT = 0 \|\| test $REPLACE_LINKAT = 1] link-follow [test $HAVE_LINKAT = 0 \|\| test $REPLACE_LINKAT = 1] link [test $HAVE_LINKAT = 0 \|\| test $REPLACE_LINKAT = 1] lstat [test $HAVE_LINKAT = 0 \|\| test $REPLACE_LINKAT = 1] openat-die [test $HAVE_LINKAT = 0 \|\| test $REPLACE_LINKAT = 1] openat-h [test $HAVE_LINKAT = 0 \|\| test $REPLACE_LINKAT = 1] same-inode [test $HAVE_LINKAT = 0 \|\| test $REPLACE_LINKAT = 1] save-cwd [test $HAVE_LINKAT = 0 \|\| test $REPLACE_LINKAT = 1] stat [test $HAVE_LINKAT = 0 \|\| test $REPLACE_LINKAT = 1] symlink [test $HAVE_LINKAT = 0 \|\| test $REPLACE_LINKAT = 1] areadlinkat [test $REPLACE_LINKAT = 1] fstatat [test $REPLACE_LINKAT = 1]
listen	#include <sys/socket.h>	listen.c w32sock.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_SYS_SOCKET_H]) gl_CONDITIONAL([GL_COND_OBJ_LISTEN], [test "$ac_cv_header_winsock2_h" = yes]) gl_SYS_SOCKET_MODULE_INDICATOR([listen])	sys_socket socketlib errno [test "$ac_cv_header_winsock2_h" = yes] msvc-nothrow [test "$ac_cv_header_winsock2_h" = yes]
locale	#include <locale.h>	locale.in.h	locale_h.m4 00gnulib.m4 zzgnulib.m4 gl_LOCALE_H gl_LOCALE_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	extensions gen-header include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use stddef
lseek	#include <unistd.h>	lseek.c	lseek.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_LSEEK gl_CONDITIONAL([GL_COND_OBJ_LSEEK], [test $REPLACE_LSEEK = 1]) gl_UNISTD_MODULE_INDICATOR([lseek])	unistd sys_types largefile msvc-nothrow [test $WINDOWS_64_BIT_OFF_T = 1] fstat [test "$gl_cv_func_lseek_pipe" = no]
lstat	#include <sys/stat.h>	lstat.c	lstat.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_LSTAT gl_CONDITIONAL([GL_COND_OBJ_LSTAT], [test $REPLACE_LSTAT = 1]) AM_COND_IF([GL_COND_OBJ_LSTAT], [ gl_PREREQ_LSTAT ]) gl_SYS_STAT_MODULE_INDICATOR([lstat])	sys_stat largefile stat [test $REPLACE_LSTAT = 1] stat-time [test $REPLACE_LSTAT = 1]
malloc-posix	#include <stdlib.h>	malloc.c	malloc.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_FUNC_MALLOC_POSIX]) if test $REPLACE_MALLOC_FOR_MALLOC_POSIX = 1; then AC_LIBOBJ([malloc]) fi gl_STDLIB_MODULE_INDICATOR([malloc-posix])	stdlib xalloc-oversized [test $REPLACE_MALLOC_FOR_MALLOC_POSIX = 1]
mbsnrtowcs	#include <wchar.h>	mbsnrtowcs.c mbsnrtowcs-impl.h mbsrtowcs-state.c	mbsnrtowcs.m4 mbstate_t.m4 mbrtowc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_MBSNRTOWCS gl_CONDITIONAL([GL_COND_OBJ_MBSNRTOWCS], [test $HAVE_MBSNRTOWCS = 0 \|\| test $REPLACE_MBSNRTOWCS = 1]) AM_COND_IF([GL_COND_OBJ_MBSNRTOWCS], [ AC_LIBOBJ([mbsrtowcs-state]) gl_PREREQ_MBSNRTOWCS ]) gl_WCHAR_MODULE_INDICATOR([mbsnrtowcs])	wchar extensions mbrtowc [test $HAVE_MBSNRTOWCS = 0 \|\| test $REPLACE_MBSNRTOWCS = 1] minmax [test $HAVE_MBSNRTOWCS = 0 \|\| test $REPLACE_MBSNRTOWCS = 1] strnlen1 [test $HAVE_MBSNRTOWCS = 0 \|\| test $REPLACE_MBSNRTOWCS = 1]
mkdir	#include <sys/stat.h>	mkdir.c	mkdir.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_MKDIR gl_CONDITIONAL([GL_COND_OBJ_MKDIR], [test $REPLACE_MKDIR = 1]) gl_SYS_STAT_MODULE_INDICATOR([mkdir])	sys_stat dirname-lgpl [test $REPLACE_MKDIR = 1] stat [test $REPLACE_MKDIR = 1]
mkdtemp	#include <stdlib.h>	mkdtemp.c	mkdtemp.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_MKDTEMP gl_CONDITIONAL([GL_COND_OBJ_MKDTEMP], [test $HAVE_MKDTEMP = 0]) AM_COND_IF([GL_COND_OBJ_MKDTEMP], [ gl_PREREQ_MKDTEMP ]) gl_STDLIB_MODULE_INDICATOR([mkdtemp])	stdlib stdint [test $HAVE_MKDTEMP = 0] tempname [test $HAVE_MKDTEMP = 0]
mkfifo	#include <sys/stat.h>	mkfifo.c	mkfifo.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_MKFIFO gl_CONDITIONAL([GL_COND_OBJ_MKFIFO], [test $HAVE_MKFIFO = 0 \|\| test $REPLACE_MKFIFO = 1]) gl_UNISTD_MODULE_INDICATOR([mkfifo])	sys_stat stat [test $HAVE_MKFIFO = 0 \|\| test $REPLACE_MKFIFO = 1]
mknod	#include <sys/stat.h>	mknod.c	mknod.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_MKNOD gl_CONDITIONAL([GL_COND_OBJ_MKNOD], [test $HAVE_MKNOD = 0 \|\| test $REPLACE_MKNOD = 1]) gl_UNISTD_MODULE_INDICATOR([mknod])	sys_stat extensions mkfifo [test $HAVE_MKNOD = 0 \|\| test $REPLACE_MKNOD = 1] stat [test $HAVE_MKNOD = 0 \|\| test $REPLACE_MKNOD = 1]
mkstemp	#include <stdlib.h>	mkstemp.c	mkstemp.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_MKSTEMP gl_CONDITIONAL([GL_COND_OBJ_MKSTEMP], [test $HAVE_MKSTEMP = 0 \|\| test $REPLACE_MKSTEMP = 1]) AM_COND_IF([GL_COND_OBJ_MKSTEMP], [ gl_PREREQ_MKSTEMP ]) gl_STDLIB_MODULE_INDICATOR([mkstemp])	stdlib extensions largefile tempname [test $HAVE_MKSTEMP = 0 \|\| test $REPLACE_MKSTEMP = 1]
net_if	#include <net/if.h>	net_if.in.h	net_if_h.m4 00gnulib.m4 zzgnulib.m4 gl_HEADER_NET_IF gl_CONDITIONAL_HEADER([net/if.h]) AC_PROG_MKDIR_P	gen-header include_next sys_socket
netdb	#include <netdb.h>	netdb.in.h	netdb_h.m4 00gnulib.m4 zzgnulib.m4 gl_NETDB_H gl_NETDB_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	gen-header include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use sys_socket
netinet_in	#include <netinet/in.h>	netinet_in.in.h	netinet_in_h.m4 00gnulib.m4 zzgnulib.m4 gl_HEADER_NETINET_IN gl_CONDITIONAL_HEADER([netinet/in.h]) AC_PROG_MKDIR_P	gen-header include_next sys_socket
nl_langinfo	#include <langinfo.h>	nl_langinfo.c nl_langinfo-lock.c windows-initguard.h	nl_langinfo.m4 threadlib.m4 visibility.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_NL_LANGINFO gl_CONDITIONAL([GL_COND_OBJ_NL_LANGINFO], [test $HAVE_NL_LANGINFO = 0 \|\| test $REPLACE_NL_LANGINFO = 1]) gl_CONDITIONAL([GL_COND_OBJ_NL_LANGINFO_LOCK], [test $REPLACE_NL_LANGINFO = 1 && test $NL_LANGINFO_MTSAFE = 0]) if test $REPLACE_NL_LANGINFO = 1 && test $NL_LANGINFO_MTSAFE = 0; then gl_PREREQ_NL_LANGINFO_LOCK fi gl_LANGINFO_MODULE_INDICATOR([nl_langinfo])	langinfo localeconv [test $HAVE_NL_LANGINFO = 0 \|\| test $REPLACE_NL_LANGINFO = 1] setlocale-null [test $HAVE_NL_LANGINFO = 0 \|\| test $HAVE_LANGINFO_CODESET = 0]
open	#include <fcntl.h>	open.c	open.m4 open-cloexec.m4 open-slash.m4 mode_t.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_OPEN gl_CONDITIONAL([GL_COND_OBJ_OPEN], [test $REPLACE_OPEN = 1]) AM_COND_IF([GL_COND_OBJ_OPEN], [ gl_PREREQ_OPEN ]) gl_FCNTL_MODULE_INDICATOR([open])	fcntl-h largefile cloexec [test $REPLACE_OPEN = 1] fstat [test $REPLACE_OPEN = 1] stat [test $REPLACE_OPEN = 1]
perror	#include <stdio.h>	perror.c	perror.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_PERROR gl_CONDITIONAL([GL_COND_OBJ_PERROR], [test $REPLACE_PERROR = 1]) gl_STRING_MODULE_INDICATOR([perror])	stdio errno [test $REPLACE_PERROR = 1] strerror-override [test $REPLACE_PERROR = 1] strerror_r-posix [test $REPLACE_PERROR = 1]
poll	#include <poll.h>	poll.c	poll.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_POLL gl_CONDITIONAL([GL_COND_OBJ_POLL], [test $HAVE_POLL = 0 \|\| test $REPLACE_POLL = 1]) AM_COND_IF([GL_COND_OBJ_POLL], [ gl_PREREQ_POLL ]) gl_POLL_MODULE_INDICATOR([poll])	poll-h alloca [test $HAVE_POLL = 0 \|\| test $REPLACE_POLL = 1] assure [test $HAVE_POLL = 0 \|\| test $REPLACE_POLL = 1] select [test $HAVE_POLL = 0 \|\| test $REPLACE_POLL = 1] sockets [test $HAVE_POLL = 0 \|\| test $REPLACE_POLL = 1] sys_select [test $HAVE_POLL = 0 \|\| test $REPLACE_POLL = 1] sys_socket [test $HAVE_POLL = 0 \|\| test $REPLACE_POLL = 1] sys_time [test $HAVE_POLL = 0 \|\| test $REPLACE_POLL = 1] errno [test $HAVE_POLL = 0 \|\| test $REPLACE_POLL = 1] msvc-nothrow [test $HAVE_POLL = 0 \|\| test $REPLACE_POLL = 1]
popen	#include <stdio.h>	popen.c	popen.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_POPEN gl_CONDITIONAL([GL_COND_OBJ_POPEN], [test $HAVE_POPEN = 0 \|\| test $REPLACE_POPEN = 1]) AM_COND_IF([GL_COND_OBJ_POPEN], [ gl_PREREQ_POPEN ]) gl_STDIO_MODULE_INDICATOR([popen])	stdio open [test $HAVE_POPEN = 0 \|\| test $REPLACE_POPEN = 1]
posix_memalign	#include <stdlib.h>	posix_memalign.c	posix_memalign.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_POSIX_MEMALIGN gl_CONDITIONAL([GL_COND_OBJ_POSIX_MEMALIGN], [test $REPLACE_POSIX_MEMALIGN = 1]) gl_STDLIB_MODULE_INDICATOR([posix_memalign])	extensions stdlib
posix_openpt	#include <stdlib.h>	posix_openpt.c	posix_openpt.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_POSIX_OPENPT gl_CONDITIONAL([GL_COND_OBJ_POSIX_OPENPT], [test $HAVE_POSIX_OPENPT = 0 \|\| test $REPLACE_POSIX_OPENPT = 1]) gl_STDLIB_MODULE_INDICATOR([posix_openpt])	extensions stdlib
posix_spawn	#include <spawn.h>	spawn.c	posix_spawn.m4 00gnulib.m4 zzgnulib.m4 gl_POSIX_SPAWN gl_CONDITIONAL([GL_COND_OBJ_SPAWN], [test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1]) gl_SPAWN_MODULE_INDICATOR([posix_spawn])	spawn posix_spawn-internal [test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1]
posix_spawnattr_destroy	#include <spawn.h>	spawnattr_destroy.c	posix_spawn.m4 00gnulib.m4 zzgnulib.m4 gl_POSIX_SPAWN gl_CONDITIONAL([GL_COND_OBJ_SPAWNATTR_DESTROY], [test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1]) gl_SPAWN_MODULE_INDICATOR([posix_spawnattr_destroy])	spawn
posix_spawnattr_getflags	#include <spawn.h>	spawnattr_getflags.c	posix_spawn.m4 00gnulib.m4 zzgnulib.m4 gl_POSIX_SPAWN gl_CONDITIONAL([GL_COND_OBJ_SPAWNATTR_GETFLAGS], [test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1]) gl_SPAWN_MODULE_INDICATOR([posix_spawnattr_getflags])	spawn
posix_spawnattr_getpgroup	#include <spawn.h>	spawnattr_getpgroup.c	posix_spawn.m4 00gnulib.m4 zzgnulib.m4 gl_POSIX_SPAWN gl_CONDITIONAL([GL_COND_OBJ_SPAWNATTR_GETPGROUP], [test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1]) gl_SPAWN_MODULE_INDICATOR([posix_spawnattr_getpgroup])	spawn
posix_spawnattr_getschedparam	#include <spawn.h>	spawnattr_getschedparam.c	posix_spawn.m4 00gnulib.m4 zzgnulib.m4 gl_POSIX_SPAWN gl_CONDITIONAL([GL_COND_OBJ_SPAWNATTR_GETSCHEDPARAM], [test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1 \|\| test $gl_cv_func_spawnattr_setschedparam = no]) gl_SPAWN_MODULE_INDICATOR([posix_spawnattr_getschedparam])	spawn
posix_spawnattr_getschedpolicy	#include <spawn.h>	spawnattr_getschedpolicy.c	posix_spawn.m4 00gnulib.m4 zzgnulib.m4 gl_POSIX_SPAWN gl_CONDITIONAL([GL_COND_OBJ_SPAWNATTR_GETSCHEDPOLICY], [test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1 \|\| test $gl_cv_func_spawnattr_setschedpolicy = no]) gl_SPAWN_MODULE_INDICATOR([posix_spawnattr_getschedpolicy])	spawn
posix_spawnattr_getsigdefault	#include <spawn.h>	spawnattr_getdefault.c	posix_spawn.m4 00gnulib.m4 zzgnulib.m4 gl_POSIX_SPAWN gl_CONDITIONAL([GL_COND_OBJ_SPAWNATTR_GETDEFAULT], [test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1]) gl_SPAWN_MODULE_INDICATOR([posix_spawnattr_getsigdefault])	spawn
posix_spawnattr_getsigmask	#include <spawn.h>	spawnattr_getsigmask.c	posix_spawn.m4 00gnulib.m4 zzgnulib.m4 gl_POSIX_SPAWN gl_CONDITIONAL([GL_COND_OBJ_SPAWNATTR_GETSIGMASK], [test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1]) gl_SPAWN_MODULE_INDICATOR([posix_spawnattr_getsigmask])	spawn
posix_spawnattr_init	#include <spawn.h>	spawnattr_init.c	posix_spawn.m4 00gnulib.m4 zzgnulib.m4 gl_POSIX_SPAWN gl_CONDITIONAL([GL_COND_OBJ_SPAWNATTR_INIT], [test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1]) gl_SPAWN_MODULE_INDICATOR([posix_spawnattr_init])	spawn
posix_spawnattr_setflags	#include <spawn.h>	spawnattr_setflags.c	posix_spawn.m4 00gnulib.m4 zzgnulib.m4 gl_POSIX_SPAWN gl_CONDITIONAL([GL_COND_OBJ_SPAWNATTR_SETFLAGS], [test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1]) gl_SPAWN_MODULE_INDICATOR([posix_spawnattr_setflags])	spawn
posix_spawnattr_setpgroup	#include <spawn.h>	spawnattr_setpgroup.c	posix_spawn.m4 00gnulib.m4 zzgnulib.m4 gl_POSIX_SPAWN gl_CONDITIONAL([GL_COND_OBJ_SPAWNATTR_SETPGROUP], [test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1]) gl_SPAWN_MODULE_INDICATOR([posix_spawnattr_setpgroup])	spawn
posix_spawnattr_setschedparam	#include <spawn.h>	spawnattr_setschedparam.c	posix_spawn.m4 00gnulib.m4 zzgnulib.m4 gl_POSIX_SPAWN gl_CONDITIONAL([GL_COND_OBJ_SPAWNATTR_SETSCHEDPARAM], [test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1 \|\| test $gl_cv_func_spawnattr_setschedparam = no]) gl_SPAWN_MODULE_INDICATOR([posix_spawnattr_setschedparam])	spawn
posix_spawnattr_setschedpolicy	#include <spawn.h>	spawnattr_setschedpolicy.c	posix_spawn.m4 00gnulib.m4 zzgnulib.m4 gl_POSIX_SPAWN gl_CONDITIONAL([GL_COND_OBJ_SPAWNATTR_SETSCHEDPOLICY], [test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1 \|\| test $gl_cv_func_spawnattr_setschedpolicy = no]) gl_SPAWN_MODULE_INDICATOR([posix_spawnattr_setschedpolicy])	spawn
posix_spawnattr_setsigdefault	#include <spawn.h>	spawnattr_setdefault.c	posix_spawn.m4 00gnulib.m4 zzgnulib.m4 gl_POSIX_SPAWN gl_CONDITIONAL([GL_COND_OBJ_SPAWNATTR_SETDEFAULT], [test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1]) gl_SPAWN_MODULE_INDICATOR([posix_spawnattr_setsigdefault])	spawn
posix_spawnattr_setsigmask	#include <spawn.h>	spawnattr_setsigmask.c	posix_spawn.m4 00gnulib.m4 zzgnulib.m4 gl_POSIX_SPAWN gl_CONDITIONAL([GL_COND_OBJ_SPAWNATTR_SETSIGMASK], [test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1]) gl_SPAWN_MODULE_INDICATOR([posix_spawnattr_setsigmask])	spawn
posix_spawn_file_actions_addclose	#include <spawn.h>	spawn_faction_addclose.c spawn_int.h	posix_spawn.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_POSIX_SPAWN_FILE_ACTIONS_ADDCLOSE gl_CONDITIONAL([GL_COND_OBJ_SPAWN_FACTION_ADDCLOSE], [test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1 \|\| test $REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDCLOSE = 1]) gl_SPAWN_MODULE_INDICATOR([posix_spawn_file_actions_addclose])	spawn getdtablesize [test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1 \|\| test $REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDCLOSE = 1] posix_spawn_file_actions_init [test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1 \|\| test $REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDCLOSE = 1]
posix_spawn_file_actions_adddup2	#include <spawn.h>	spawn_faction_adddup2.c spawn_int.h	posix_spawn.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_POSIX_SPAWN_FILE_ACTIONS_ADDDUP2 gl_CONDITIONAL([GL_COND_OBJ_SPAWN_FACTION_ADDDUP2], [test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1 \|\| test $REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDDUP2 = 1]) gl_SPAWN_MODULE_INDICATOR([posix_spawn_file_actions_adddup2])	spawn getdtablesize [test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1 \|\| test $REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDDUP2 = 1] posix_spawn_file_actions_init [test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1 \|\| test $REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDDUP2 = 1]
posix_spawn_file_actions_addopen	#include <spawn.h>	spawn_faction_addopen.c spawn_int.h	posix_spawn.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_POSIX_SPAWN_FILE_ACTIONS_ADDOPEN gl_CONDITIONAL([GL_COND_OBJ_SPAWN_FACTION_ADDOPEN], [test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1 \|\| test $REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDOPEN = 1]) gl_SPAWN_MODULE_INDICATOR([posix_spawn_file_actions_addopen])	spawn getdtablesize [test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1 \|\| test $REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDOPEN = 1] posix_spawn_file_actions_init [test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1 \|\| test $REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDOPEN = 1]
posix_spawn_file_actions_destroy	#include <spawn.h>	spawn_faction_destroy.c	posix_spawn.m4 00gnulib.m4 zzgnulib.m4 gl_POSIX_SPAWN gl_CONDITIONAL([GL_COND_OBJ_SPAWN_FACTION_DESTROY], [test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1]) gl_SPAWN_MODULE_INDICATOR([posix_spawn_file_actions_destroy])	spawn
posix_spawn_file_actions_init	#include <spawn.h>	spawn_faction_init.c spawn_int.h	posix_spawn.m4 00gnulib.m4 zzgnulib.m4 gl_POSIX_SPAWN gl_CONDITIONAL([GL_COND_OBJ_SPAWN_FACTION_INIT], [test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1]) gl_SPAWN_MODULE_INDICATOR([posix_spawn_file_actions_init])	spawn
posix_spawn-internal	---	spawni.c spawn_int.h	posix_spawn.m4 00gnulib.m4 zzgnulib.m4 gl_POSIX_SPAWN gl_CONDITIONAL([GL_COND_OBJ_SPAWNI], [test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1]) AM_COND_IF([GL_COND_OBJ_SPAWNI], [ gl_PREREQ_POSIX_SPAWN_INTERNAL ])	spawn alloca-opt dup2 errno open sh-filename strchrnul unistd filename [test $HAVE_POSIX_SPAWN = 0] concat-filename [test $HAVE_POSIX_SPAWN = 0] findprog-in [test $HAVE_POSIX_SPAWN = 0] free-posix [test $HAVE_POSIX_SPAWN = 0] malloca [test $HAVE_POSIX_SPAWN = 0] stdbool [test $HAVE_POSIX_SPAWN = 0] windows-spawn [test $HAVE_POSIX_SPAWN = 0]
posix_spawnp	#include <spawn.h>	spawnp.c	posix_spawn.m4 00gnulib.m4 zzgnulib.m4 gl_POSIX_SPAWN gl_CONDITIONAL([GL_COND_OBJ_SPAWNP], [test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1]) gl_SPAWN_MODULE_INDICATOR([posix_spawnp])	spawn posix_spawn-internal [test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1]
pread	#include <unistd.h>	pread.c	pread.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_PREAD gl_CONDITIONAL([GL_COND_OBJ_PREAD], [test $HAVE_PREAD = 0 \|\| test $REPLACE_PREAD = 1]) gl_UNISTD_MODULE_INDICATOR([pread])	unistd extensions largefile lseek [test $HAVE_PREAD = 0 \|\| test $REPLACE_PREAD = 1] read [test $HAVE_PREAD = 0 \|\| test $REPLACE_PREAD = 1]
printf-posix	#include <stdio.h>	printf.c	printf-posix.m4 printf.m4 asm-underscore.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_PRINTF_POSIX gl_STDIO_MODULE_INDICATOR([printf-posix])	stdio printf-safe vfprintf-posix [test $REPLACE_PRINTF = 1]
pselect	#include <sys/select.h>	pselect.c	pselect.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_PSELECT gl_CONDITIONAL([GL_COND_OBJ_PSELECT], [test $HAVE_PSELECT = 0 \|\| test $REPLACE_PSELECT = 1]) gl_SYS_SELECT_MODULE_INDICATOR([pselect])	sys_select pthread_sigmask [test $HAVE_PSELECT = 0 \|\| test $REPLACE_PSELECT = 1] select [test $HAVE_PSELECT = 0 \|\| test $REPLACE_PSELECT = 1] dup2 [test $REPLACE_PSELECT = 1]
pthread	#include <pthread.h>	---	00gnulib.m4 zzgnulib.m4	pthread-h pthread-thread pthread-once pthread-mutex pthread-rwlock pthread-cond pthread-tss pthread-spin
ptsname	#include <stdlib.h>	ptsname.c	ptsname.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_PTSNAME gl_CONDITIONAL([GL_COND_OBJ_PTSNAME], [test $HAVE_PTSNAME = 0 \|\| test $REPLACE_PTSNAME = 1]) AM_COND_IF([GL_COND_OBJ_PTSNAME], [ gl_PREREQ_PTSNAME ]) gl_STDLIB_MODULE_INDICATOR([ptsname])	stdlib extensions ptsname_r [test $HAVE_PTSNAME = 0]
pwrite	#include <unistd.h>	pwrite.c	pwrite.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_PWRITE gl_CONDITIONAL([GL_COND_OBJ_PWRITE], [test $HAVE_PWRITE = 0 \|\| test $REPLACE_PWRITE = 1]) gl_UNISTD_MODULE_INDICATOR([pwrite])	unistd extensions largefile lseek [test $HAVE_PWRITE = 0 \|\| test $REPLACE_PWRITE = 1] write [test $HAVE_PWRITE = 0 \|\| test $REPLACE_PWRITE = 1]
readlink	#include <unistd.h>	readlink.c	readlink.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_READLINK gl_CONDITIONAL([GL_COND_OBJ_READLINK], [test $HAVE_READLINK = 0 \|\| test $REPLACE_READLINK = 1]) AM_COND_IF([GL_COND_OBJ_READLINK], [ gl_PREREQ_READLINK ]) gl_UNISTD_MODULE_INDICATOR([readlink])	unistd stat [test $HAVE_READLINK = 0 \|\| test $REPLACE_READLINK = 1]
realloc-posix	#include <stdlib.h>	realloc.c	realloc.m4 malloc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_REALLOC_POSIX if test $REPLACE_REALLOC_FOR_REALLOC_POSIX = 1; then AC_LIBOBJ([realloc]) fi gl_STDLIB_MODULE_INDICATOR([realloc-posix])	stdlib free-posix [test $REPLACE_REALLOC_FOR_REALLOC_POSIX = 1] malloc-posix [test $REPLACE_REALLOC_FOR_REALLOC_POSIX = 1] xalloc-oversized [test $REPLACE_REALLOC_FOR_REALLOC_POSIX = 1]
recv	#include <sys/socket.h>	recv.c w32sock.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_SYS_SOCKET_H]) gl_CONDITIONAL([GL_COND_OBJ_RECV], [test "$ac_cv_header_winsock2_h" = yes]) gl_SYS_SOCKET_MODULE_INDICATOR([recv])	sys_socket socketlib errno [test "$ac_cv_header_winsock2_h" = yes] msvc-nothrow [test "$ac_cv_header_winsock2_h" = yes]
recvfrom	#include <sys/socket.h>	recvfrom.c w32sock.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_SYS_SOCKET_H]) gl_CONDITIONAL([GL_COND_OBJ_RECVFROM], [test "$ac_cv_header_winsock2_h" = yes]) gl_SYS_SOCKET_MODULE_INDICATOR([recvfrom])	extensions sys_socket socketlib errno [test "$ac_cv_header_winsock2_h" = yes] getpeername [test "$ac_cv_header_winsock2_h" = yes] msvc-nothrow [test "$ac_cv_header_winsock2_h" = yes]
remove	#include <stdio.h>	remove.c	remove.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_REMOVE gl_CONDITIONAL([GL_COND_OBJ_REMOVE], [test $REPLACE_REMOVE = 1]) gl_STDIO_MODULE_INDICATOR([remove])	stdio rmdir [test $REPLACE_REMOVE = 1] unlink [test $REPLACE_REMOVE = 1]
scandir	#include <dirent.h>	scandir.c	scandir.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_SCANDIR gl_CONDITIONAL([GL_COND_OBJ_SCANDIR], [test $HAVE_SCANDIR = 0]) AM_COND_IF([GL_COND_OBJ_SCANDIR], [ gl_PREREQ_SCANDIR ]) gl_DIRENT_MODULE_INDICATOR([scandir])	builtin-expect closedir dirent extensions largefile opendir readdir
sched	#include <sched.h>	sched.in.h	sched_h.m4 pid_t.m4 00gnulib.m4 zzgnulib.m4 gl_SCHED_H gl_SCHED_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	gen-header include_next snippet/c++defs snippet/warn-on-use
select	#include <sys/select.h>	select.c	select.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_SELECT gl_CONDITIONAL([GL_COND_OBJ_SELECT], [test $REPLACE_SELECT = 1]) gl_SYS_SELECT_MODULE_INDICATOR([select])	sys_select alloca [test $REPLACE_SELECT = 1] dup2 [test $REPLACE_SELECT = 1] sockets [test $REPLACE_SELECT = 1] sys_time [test $REPLACE_SELECT = 1] msvc-nothrow [test $REPLACE_SELECT = 1]
send	#include <sys/socket.h>	send.c w32sock.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_SYS_SOCKET_H]) gl_CONDITIONAL([GL_COND_OBJ_SEND], [test "$ac_cv_header_winsock2_h" = yes]) gl_SYS_SOCKET_MODULE_INDICATOR([send])	sys_socket socketlib errno [test "$ac_cv_header_winsock2_h" = yes] msvc-nothrow [test "$ac_cv_header_winsock2_h" = yes]
sendto	#include <sys/socket.h>	sendto.c w32sock.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_SYS_SOCKET_H]) gl_CONDITIONAL([GL_COND_OBJ_SENDTO], [test "$ac_cv_header_winsock2_h" = yes]) gl_SYS_SOCKET_MODULE_INDICATOR([sendto])	sys_socket socketlib errno [test "$ac_cv_header_winsock2_h" = yes] msvc-nothrow [test "$ac_cv_header_winsock2_h" = yes]
servent	#include <netdb.h>	---	servent.m4 00gnulib.m4 zzgnulib.m4 gl_SERVENT	sys_socket
setsockopt	#include <sys/socket.h>	setsockopt.c w32sock.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_SYS_SOCKET_H]) gl_CONDITIONAL([GL_COND_OBJ_SETSOCKOPT], [test "$ac_cv_header_winsock2_h" = yes]) gl_SYS_SOCKET_MODULE_INDICATOR([setsockopt])	sys_socket socketlib sys_time [test "$ac_cv_header_winsock2_h" = yes] errno [test "$ac_cv_header_winsock2_h" = yes] msvc-nothrow [test "$ac_cv_header_winsock2_h" = yes]
shutdown	#include <sys/socket.h>	shutdown.c w32sock.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_SYS_SOCKET_H]) gl_CONDITIONAL([GL_COND_OBJ_SHUTDOWN], [test "$ac_cv_header_winsock2_h" = yes]) gl_SYS_SOCKET_MODULE_INDICATOR([shutdown])	sys_socket socketlib errno [test "$ac_cv_header_winsock2_h" = yes] msvc-nothrow [test "$ac_cv_header_winsock2_h" = yes]
signal-h	#include <signal.h>	signal.in.h	signal_h.m4 pid_t.m4 00gnulib.m4 zzgnulib.m4 gl_SIGNAL_H gl_SIGNAL_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	gen-header include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use extensions
sleep	#include <unistd.h>	sleep.c	sleep.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_SLEEP gl_CONDITIONAL([GL_COND_OBJ_SLEEP], [test $HAVE_SLEEP = 0 \|\| test $REPLACE_SLEEP = 1]) gl_UNISTD_MODULE_INDICATOR([sleep])	unistd assert-h [test $HAVE_SLEEP = 0 \|\| test $REPLACE_SLEEP = 1] stdint [test $HAVE_SLEEP = 0 \|\| test $REPLACE_SLEEP = 1]
snprintf-posix	#include <stdio.h>	---	snprintf-posix.m4 printf.m4 math_h.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_SNPRINTF_POSIX	snprintf nocrash printf-safe multiarch vasnprintf [test $ac_cv_func_snprintf = no \|\| test $REPLACE_SNPRINTF = 1] isnand-nolibm [test $ac_cv_func_snprintf = no \|\| test $REPLACE_SNPRINTF = 1] isnanl-nolibm [test $ac_cv_func_snprintf = no \|\| test $REPLACE_SNPRINTF = 1] frexp-nolibm [test $ac_cv_func_snprintf = no \|\| test $REPLACE_SNPRINTF = 1] frexpl-nolibm [test $ac_cv_func_snprintf = no \|\| test $REPLACE_SNPRINTF = 1] printf-frexp [test $ac_cv_func_snprintf = no \|\| test $REPLACE_SNPRINTF = 1] printf-frexpl [test $ac_cv_func_snprintf = no \|\| test $REPLACE_SNPRINTF = 1] signbit [test $ac_cv_func_snprintf = no \|\| test $REPLACE_SNPRINTF = 1] fpucw [test $ac_cv_func_snprintf = no \|\| test $REPLACE_SNPRINTF = 1]
socket	#include <sys/socket.h>	socket.c w32sock.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_SYS_SOCKET_H]) gl_CONDITIONAL([GL_COND_OBJ_SOCKET], [test "$ac_cv_header_winsock2_h" = yes]) # When this module is used, sockets may actually occur as file descriptors, # hence it is worth warning if the modules 'close' and 'ioctl' are not used. m4_ifdef([gl_UNISTD_H_DEFAULTS], [gl_UNISTD_H_REQUIRE_DEFAULTS]) m4_ifdef([gl_SYS_IOCTL_H_DEFAULTS], [gl_SYS_IOCTL_H_REQUIRE_DEFAULTS]) AC_REQUIRE([gl_PREREQ_SYS_H_WINSOCK2]) if test "$ac_cv_header_winsock2_h" = yes; then UNISTD_H_HAVE_WINSOCK2_H_AND_USE_SOCKETS=1 SYS_IOCTL_H_HAVE_WINSOCK2_H_AND_USE_SOCKETS=1 fi gl_SYS_SOCKET_MODULE_INDICATOR([socket])	sys_socket socketlib errno [test "$ac_cv_header_winsock2_h" = yes] sockets [test "$ac_cv_header_winsock2_h" = yes] msvc-nothrow [test "$ac_cv_header_winsock2_h" = yes]
spawn	#include <spawn.h>	spawn.in.h	spawn_h.m4 pid_t.m4 00gnulib.m4 zzgnulib.m4 gl_SPAWN_H gl_SPAWN_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	gen-header include_next sched signal-h snippet/arg-nonnull snippet/c++defs snippet/warn-on-use
sprintf-posix	#include <stdio.h>	sprintf.c	sprintf-posix.m4 printf.m4 math_h.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_SPRINTF_POSIX gl_STDIO_MODULE_INDICATOR([sprintf-posix])	stdio nocrash printf-safe multiarch vasnprintf [test $REPLACE_SPRINTF = 1] isnand-nolibm [test $REPLACE_SPRINTF = 1] isnanl-nolibm [test $REPLACE_SPRINTF = 1] frexp-nolibm [test $REPLACE_SPRINTF = 1] frexpl-nolibm [test $REPLACE_SPRINTF = 1] printf-frexp [test $REPLACE_SPRINTF = 1] printf-frexpl [test $REPLACE_SPRINTF = 1] signbit [test $REPLACE_SPRINTF = 1] fpucw [test $REPLACE_SPRINTF = 1] stdint [test $REPLACE_SPRINTF = 1] errno [test $REPLACE_SPRINTF = 1]
stat	#include <sys/stat.h>	stat.c stat-w32.h stat-w32.c	stat.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_STAT gl_CONDITIONAL([GL_COND_OBJ_STAT], [test $REPLACE_STAT = 1]) AM_COND_IF([GL_COND_OBJ_STAT], [ case "$host_os" in mingw*) AC_LIBOBJ([stat-w32]) ;; esac gl_PREREQ_STAT ]) gl_SYS_STAT_MODULE_INDICATOR([stat])	sys_stat largefile assert-h [test $REPLACE_STAT = 1] filename [test $REPLACE_STAT = 1] malloca [test $REPLACE_STAT = 1] pathmax [test $REPLACE_STAT = 1] stat-time [test $REPLACE_STAT = 1] stdbool [test $REPLACE_STAT = 1]
strdup-posix	#include <string.h>	strdup.c	strdup.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_STRDUP_POSIX gl_CONDITIONAL([GL_COND_OBJ_STRDUP], [test $REPLACE_STRDUP = 1]) AM_COND_IF([GL_COND_OBJ_STRDUP], [ gl_PREREQ_STRDUP ]) gl_STRING_MODULE_INDICATOR([strdup])	string malloc-posix [test $REPLACE_STRDUP = 1]
string	#include <string.h>	string.in.h	string_h.m4 00gnulib.m4 zzgnulib.m4 gl_STRING_H gl_STRING_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	extensions extern-inline gen-header include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use stddef stdlib
strings	#include <strings.h>	strings.in.h	strings_h.m4 00gnulib.m4 zzgnulib.m4 gl_STRINGS_H gl_STRINGS_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	gen-header include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use sys_types
tempname	#include "tempname.h"	tempname.c	tempname.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_GEN_TEMPNAME gl_MODULE_INDICATOR([tempname])	c99 clock-time extensions fcntl-h getrandom libc-config lstat mkdir stdbool stdint sys_stat time-h
time	#include <time.h>	time.c	time.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_TIME gl_CONDITIONAL([GL_COND_OBJ_TIME], [test $REPLACE_TIME = 1]) AM_COND_IF([GL_COND_OBJ_TIME], [ gl_PREREQ_TIME ]) gl_TIME_MODULE_INDICATOR([time])	time-h gettimeofday [test $REPLACE_TIME = 1]
time_r	#include <time.h>	time_r.c	time_r.m4 00gnulib.m4 zzgnulib.m4 gl_TIME_R gl_CONDITIONAL([GL_COND_OBJ_TIME_R], [test $HAVE_LOCALTIME_R = 0 \|\| test $REPLACE_LOCALTIME_R = 1]) AM_COND_IF([GL_COND_OBJ_TIME_R], [ gl_PREREQ_TIME_R ]) gl_TIME_MODULE_INDICATOR([time_r])	extensions time-h
times	#include <sys/times.h>	times.c	times.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_TIMES gl_CONDITIONAL([GL_COND_OBJ_TIMES], [test $HAVE_TIMES = 0]) gl_SYS_TIMES_MODULE_INDICATOR([times])	sys_times
timespec	#include "timespec.h"	timespec.c	timespec.m4 00gnulib.m4 zzgnulib.m4 gl_TIMESPEC	extern-inline snippet/arg-nonnull time-h
nanosleep	#include <time.h>	nanosleep.c	nanosleep.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_NANOSLEEP gl_CONDITIONAL([GL_COND_OBJ_NANOSLEEP], [test $HAVE_NANOSLEEP = 0 \|\| test $REPLACE_NANOSLEEP = 1]) gl_TIME_MODULE_INDICATOR([nanosleep])	time-h extensions multiarch assert-h [test $HAVE_NANOSLEEP = 0 \|\| test $REPLACE_NANOSLEEP = 1] intprops [test $HAVE_NANOSLEEP = 0 \|\| test $REPLACE_NANOSLEEP = 1] pselect [test $HAVE_NANOSLEEP = 0 \|\| test $REPLACE_NANOSLEEP = 1] stdbool [test $HAVE_NANOSLEEP = 0 \|\| test $REPLACE_NANOSLEEP = 1] sys_select [test $HAVE_NANOSLEEP = 0 \|\| test $REPLACE_NANOSLEEP = 1]
pthread_sigmask	#include <signal.h>	pthread_sigmask.c	pthread_sigmask.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_PTHREAD_SIGMASK gl_CONDITIONAL([GL_COND_OBJ_PTHREAD_SIGMASK], [test $HAVE_PTHREAD_SIGMASK = 0 \|\| test $REPLACE_PTHREAD_SIGMASK = 1]) AM_COND_IF([GL_COND_OBJ_PTHREAD_SIGMASK], [ gl_PREREQ_PTHREAD_SIGMASK ]) gl_SIGNAL_MODULE_INDICATOR([pthread_sigmask])	signal-h threadlib sigprocmask [test $HAVE_PTHREAD_SIGMASK = 0 \|\| test $REPLACE_PTHREAD_SIGMASK = 1]
regex	#include <regex.h>	regex.h regex.c regex_internal.c regex_internal.h regexec.c regcomp.c	eealloc.m4 regex.m4 mbstate_t.m4 00gnulib.m4 zzgnulib.m4 gl_REGEX gl_CONDITIONAL([GL_COND_OBJ_REGEX], [test $ac_use_included_regex = yes]) AM_COND_IF([GL_COND_OBJ_REGEX], [ gl_PREREQ_REGEX ])	c99 extensions ssize_t vararrays attribute [test $ac_use_included_regex = yes] btowc [test $ac_use_included_regex = yes] builtin-expect [test $ac_use_included_regex = yes] glibc-internal/dynarray [test $ac_use_included_regex = yes] intprops [test $ac_use_included_regex = yes] iswctype [test $ac_use_included_regex = yes] langinfo [test $ac_use_included_regex = yes] libc-config [test $ac_use_included_regex = yes] lock [test $ac_use_included_regex = yes] memcmp [test $ac_use_included_regex = yes] memmove [test $ac_use_included_regex = yes] mbrtowc [test $ac_use_included_regex = yes] mbsinit [test $ac_use_included_regex = yes] nl_langinfo [test $ac_use_included_regex = yes] stdbool [test $ac_use_included_regex = yes] stdint [test $ac_use_included_regex = yes] verify [test $ac_use_included_regex = yes] wchar [test $ac_use_included_regex = yes] wcrtomb [test $ac_use_included_regex = yes] wctype-h [test $ac_use_included_regex = yes] wctype [test $ac_use_included_regex = yes]
rename	#include <stdio.h>	rename.c	rename.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_RENAME gl_CONDITIONAL([GL_COND_OBJ_RENAME], [test $REPLACE_RENAME = 1]) gl_STDIO_MODULE_INDICATOR([rename])	stdio canonicalize-lgpl [test $REPLACE_RENAME = 1] chdir [test $REPLACE_RENAME = 1] dirname-lgpl [test $REPLACE_RENAME = 1] free-posix [test $REPLACE_RENAME = 1] lstat [test $REPLACE_RENAME = 1] rmdir [test $REPLACE_RENAME = 1] same-inode [test $REPLACE_RENAME = 1] stat [test $REPLACE_RENAME = 1] stdbool [test $REPLACE_RENAME = 1] strdup [test $REPLACE_RENAME = 1]
renameat	#include <stdio.h>	renameat.c at-func2.c	renameat.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_RENAMEAT gl_CONDITIONAL([GL_COND_OBJ_RENAMEAT], [test $HAVE_RENAMEAT = 0 \|\| test $REPLACE_RENAMEAT = 1]) if test $HAVE_RENAMEAT = 0; then AC_LIBOBJ([at-func2]) fi gl_STDIO_MODULE_INDICATOR([renameat])	renameatu [test $HAVE_RENAMEAT = 0 \|\| test $REPLACE_RENAMEAT = 1]
rmdir	#include <unistd.h>	rmdir.c	rmdir.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_RMDIR gl_CONDITIONAL([GL_COND_OBJ_RMDIR], [test $REPLACE_RMDIR = 1]) gl_UNISTD_MODULE_INDICATOR([rmdir])	unistd filename [test $REPLACE_RMDIR = 1] sys_stat [test $REPLACE_RMDIR = 1]
search	#include <search.h>	search.in.h	search_h.m4 00gnulib.m4 zzgnulib.m4 gl_SEARCH_H gl_SEARCH_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	gen-header include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use
sigaction	#include <signal.h>	sigaction.c sig-handler.h sig-handler.c	sigaction.m4 00gnulib.m4 zzgnulib.m4 gl_SIGACTION gl_CONDITIONAL([GL_COND_OBJ_SIGACTION], [test $HAVE_SIGACTION = 0]) AM_COND_IF([GL_COND_OBJ_SIGACTION], [ gl_PREREQ_SIGACTION ]) gl_SIGNAL_MODULE_INDICATOR([sigaction])	extern-inline signal-h sigprocmask [test $HAVE_SIGACTION = 0]
sigprocmask	#include <signal.h>	sigprocmask.c	signalblocking.m4 00gnulib.m4 zzgnulib.m4 gl_SIGNALBLOCKING gl_CONDITIONAL([GL_COND_OBJ_SIGPROCMASK], [test $HAVE_POSIX_SIGNALBLOCKING = 0]) AM_COND_IF([GL_COND_OBJ_SIGPROCMASK], [ gl_PREREQ_SIGPROCMASK ]) gl_SIGNAL_MODULE_INDICATOR([sigprocmask])	signal-h stdint [test $HAVE_POSIX_SIGNALBLOCKING = 0] raise [test $HAVE_POSIX_SIGNALBLOCKING = 0] msvc-inval [test $HAVE_POSIX_SIGNALBLOCKING = 0]
socklen	#include <sys/types.h> #if HAVE_SYS_SOCKET_H # include <sys/socket.h> #elif HAVE_WS2TCPIP_H # include <ws2tcpip.h> #endif	---	socklen.m4 00gnulib.m4 zzgnulib.m4 gl_TYPE_SOCKLEN_T	---
ssize_t	#include <sys/types.h>	---	ssize_t.m4 00gnulib.m4 zzgnulib.m4 gt_TYPE_SSIZE_T	---
strptime	#include <time.h>	strptime.c	strptime.m4 tm_gmtoff.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_STRPTIME gl_CONDITIONAL([GL_COND_OBJ_STRPTIME], [test $HAVE_STRPTIME = 0]) AM_COND_IF([GL_COND_OBJ_STRPTIME], [ gl_PREREQ_STRPTIME ]) gl_TIME_MODULE_INDICATOR([strptime])	time-h extensions sys_time [test $HAVE_STRPTIME = 0] string [test $HAVE_STRPTIME = 0] strcase [test $HAVE_STRPTIME = 0] stdbool [test $HAVE_STRPTIME = 0] time_r [test $HAVE_STRPTIME = 0]
strtok_r	#include <string.h>	strtok_r.c	strtok_r.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_STRTOK_R gl_CONDITIONAL([GL_COND_OBJ_STRTOK_R], [test $HAVE_STRTOK_R = 0 \|\| test $REPLACE_STRTOK_R = 1]) AM_COND_IF([GL_COND_OBJ_STRTOK_R], [ gl_PREREQ_STRTOK_R ]) gl_STRING_MODULE_INDICATOR([strtok_r])	string strpbrk [test $HAVE_STRTOK_R = 0 \|\| test $REPLACE_STRTOK_R = 1]
sys_select	#include <sys/select.h>	sys_select.in.h	sys_select_h.m4 sys_socket_h.m4 00gnulib.m4 zzgnulib.m4 gl_SYS_SELECT_H gl_SYS_SELECT_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	gen-header include_next signal-h snippet/c++defs snippet/warn-on-use sys_time
sys_socket	#include <sys/socket.h>	sys_socket.c sys_socket.in.h	sys_socket_h.m4 sockpfaf.m4 00gnulib.m4 zzgnulib.m4 gl_SYS_SOCKET_H gl_SYS_SOCKET_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	alignasof errno extern-inline gen-header include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use socklen ssize_t sys_uio
sys_stat	#include <sys/stat.h>	sys_stat.in.h	sys_stat_h.m4 unistd_h.m4 pid_t.m4 00gnulib.m4 zzgnulib.m4 gl_SYS_STAT_H gl_SYS_STAT_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	gen-header include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use sys_types time-h
sys_time	#include <sys/time.h>	sys_time.in.h	sys_time_h.m4 sys_socket_h.m4 00gnulib.m4 zzgnulib.m4 gl_SYS_TIME_H gl_SYS_TIME_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	gen-header include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use
sys_times	#include <sys/times.h>	sys_times.in.h	sys_times_h.m4 00gnulib.m4 zzgnulib.m4 gl_SYS_TIMES_H gl_SYS_TIMES_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	gen-header include_next snippet/arg-nonnull snippet/warn-on-use
sys_uio	#include <sys/uio.h>	sys_uio.in.h	sys_uio_h.m4 00gnulib.m4 zzgnulib.m4 gl_SYS_UIO_H gl_SYS_UIO_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	gen-header include_next ssize_t sys_types
sys_utsname	#include <sys/utsname.h>	sys_utsname.in.h	sys_utsname_h.m4 00gnulib.m4 zzgnulib.m4 gl_SYS_UTSNAME_H gl_SYS_UTSNAME_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	gen-header include_next snippet/arg-nonnull snippet/warn-on-use
sys_wait	#include <sys/wait.h>	sys_wait.in.h	sys_wait_h.m4 pid_t.m4 00gnulib.m4 zzgnulib.m4 gl_SYS_WAIT_H gl_SYS_WAIT_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	gen-header include_next snippet/c++defs snippet/warn-on-use
truncate	#include <unistd.h>	truncate.c	truncate.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_TRUNCATE gl_CONDITIONAL([GL_COND_OBJ_TRUNCATE], [test $HAVE_DECL_TRUNCATE = 0 \|\| test $REPLACE_TRUNCATE = 1]) AM_COND_IF([GL_COND_OBJ_TRUNCATE], [ gl_PREREQ_TRUNCATE ]) gl_UNISTD_MODULE_INDICATOR([truncate])	unistd sys_types largefile sys_stat stat [test $REPLACE_TRUNCATE = 1] open [test $HAVE_DECL_TRUNCATE = 0 \|\| test $REPLACE_TRUNCATE = 1] ftruncate [test $HAVE_DECL_TRUNCATE = 0 \|\| test $REPLACE_TRUNCATE = 1]
tsearch	#include <search.h>	tsearch.c	tsearch.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_TSEARCH gl_CONDITIONAL([GL_COND_OBJ_TSEARCH], [test $HAVE_TSEARCH = 0 \|\| test $HAVE_TWALK = 0 \|\| test $REPLACE_TSEARCH = 1 \|\| test $REPLACE_TWALK = 1]) AM_COND_IF([GL_COND_OBJ_TSEARCH], [ gl_PREREQ_TSEARCH ]) gl_SEARCH_MODULE_INDICATOR([tsearch])	search
ttyname_r	#include <unistd.h>	ttyname_r.c	ttyname_r.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_TTYNAME_R gl_CONDITIONAL([GL_COND_OBJ_TTYNAME_R], [test $HAVE_TTYNAME_R = 0 \|\| test $REPLACE_TTYNAME_R = 1]) AM_COND_IF([GL_COND_OBJ_TTYNAME_R], [ gl_PREREQ_TTYNAME_R ]) gl_UNISTD_MODULE_INDICATOR([ttyname_r])	unistd extensions
uname	#include <sys/utsname.h>	uname.c	uname.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_UNAME gl_CONDITIONAL([GL_COND_OBJ_UNAME], [test $HAVE_UNAME = 0]) AM_COND_IF([GL_COND_OBJ_UNAME], [ gl_PREREQ_UNAME ]) gl_SYS_UTSNAME_MODULE_INDICATOR([uname])	sys_utsname gethostname [test $HAVE_UNAME = 0]
unistd	#include <unistd.h>	unistd.c unistd.in.h	unistd_h.m4 off_t.m4 pid_t.m4 00gnulib.m4 zzgnulib.m4 gl_UNISTD_H gl_UNISTD_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	extern-inline gen-header include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use ssize_t stddef sys_types
unlink	#include <unistd.h>	unlink.c	unlink.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_UNLINK gl_CONDITIONAL([GL_COND_OBJ_UNLINK], [test $REPLACE_UNLINK = 1]) gl_UNISTD_MODULE_INDICATOR([unlink])	unistd filename [test $REPLACE_UNLINK = 1] lstat [test $REPLACE_UNLINK = 1] malloc-posix [test $REPLACE_UNLINK = 1]
unlockpt	#include <stdlib.h>	unlockpt.c	unlockpt.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_UNLOCKPT gl_CONDITIONAL([GL_COND_OBJ_UNLOCKPT], [test $HAVE_UNLOCKPT = 0]) AM_COND_IF([GL_COND_OBJ_UNLOCKPT], [ gl_PREREQ_UNLOCKPT ]) gl_STDLIB_MODULE_INDICATOR([unlockpt])	stdlib extensions fcntl-h [test $HAVE_UNLOCKPT = 0] ptsname [test $HAVE_UNLOCKPT = 0]
utime	#include <utime.h>	utime.c	utime.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_UTIME gl_CONDITIONAL([GL_COND_OBJ_UTIME], [test $HAVE_UTIME = 0 \|\| test $REPLACE_UTIME = 1]) AM_COND_IF([GL_COND_OBJ_UTIME], [ gl_PREREQ_UTIME ]) gl_UTIME_MODULE_INDICATOR([utime])	utime-h time-h filename [test $HAVE_UTIME = 0 \|\| test $REPLACE_UTIME = 1] malloca [test $HAVE_UTIME = 0 \|\| test $REPLACE_UTIME = 1] stat [test $HAVE_UTIME = 0 \|\| test $REPLACE_UTIME = 1] stdbool [test $HAVE_UTIME = 0 \|\| test $REPLACE_UTIME = 1]
utime-h	#include <utime.h>	utime.in.h	utime_h.m4 00gnulib.m4 zzgnulib.m4 gl_UTIME_H gl_UTIME_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	gen-header include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use
utimensat	#include <sys/stat.h>	utimensat.c at-func.c	utimensat.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_UTIMENSAT gl_CONDITIONAL([GL_COND_OBJ_UTIMENSAT], [test $HAVE_UTIMENSAT = 0 \|\| test $REPLACE_UTIMENSAT = 1]) gl_SYS_STAT_MODULE_INDICATOR([utimensat])	sys_stat extensions at-internal [test $HAVE_UTIMENSAT = 0 \|\| test $REPLACE_UTIMENSAT = 1] errno [test $HAVE_UTIMENSAT = 0 \|\| test $REPLACE_UTIMENSAT = 1] fchdir [test $HAVE_UTIMENSAT = 0 \|\| test $REPLACE_UTIMENSAT = 1] fcntl-h [test $HAVE_UTIMENSAT = 0 \|\| test $REPLACE_UTIMENSAT = 1] filename [test $HAVE_UTIMENSAT = 0 \|\| test $REPLACE_UTIMENSAT = 1] openat-die [test $HAVE_UTIMENSAT = 0 \|\| test $REPLACE_UTIMENSAT = 1] openat-h [test $HAVE_UTIMENSAT = 0 \|\| test $REPLACE_UTIMENSAT = 1] save-cwd [test $HAVE_UTIMENSAT = 0 \|\| test $REPLACE_UTIMENSAT = 1] stat-time [test $HAVE_UTIMENSAT = 0 \|\| test $REPLACE_UTIMENSAT = 1] utimens [test $HAVE_UTIMENSAT = 0 \|\| test $REPLACE_UTIMENSAT = 1] fstatat [test $REPLACE_UTIMENSAT = 1]
vasnprintf-posix	#include "vasnprintf.h"	---	vasnprintf-posix.m4 printf.m4 math_h.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_VASNPRINTF_POSIX	vasnprintf isnand-nolibm isnanl-nolibm frexp-nolibm frexpl-nolibm printf-frexp printf-frexpl signbit fpucw nocrash printf-safe multiarch
vasprintf-posix	#include "vasprintf.h"	---	vasprintf-posix.m4 printf.m4 math_h.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_VASPRINTF_POSIX	vasprintf vasnprintf [test $HAVE_VASPRINTF = 0 \|\| test $REPLACE_VASPRINTF = 1] isnand-nolibm isnanl-nolibm frexp-nolibm frexpl-nolibm printf-frexp printf-frexpl signbit fpucw nocrash printf-safe multiarch
vdprintf	#include <stdio.h>	vdprintf.c	vdprintf.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_VDPRINTF gl_STDIO_MODULE_INDICATOR([vdprintf])	stdio vasnprintf [test $ac_cv_func_vdprintf = no \|\| test $REPLACE_VDPRINTF = 1] free-posix [test $ac_cv_func_vdprintf = no \|\| test $REPLACE_VDPRINTF = 1] full-write [test $ac_cv_func_vdprintf = no \|\| test $REPLACE_VDPRINTF = 1] errno [test $ac_cv_func_vdprintf = no \|\| test $REPLACE_VDPRINTF = 1]
vdprintf-posix	#include <stdio.h>	---	vdprintf-posix.m4 printf.m4 math_h.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_VDPRINTF_POSIX	vdprintf nocrash printf-safe multiarch vasnprintf [test $ac_cv_func_vdprintf = no \|\| test $REPLACE_VDPRINTF = 1] isnand-nolibm [test $ac_cv_func_vdprintf = no \|\| test $REPLACE_VDPRINTF = 1] isnanl-nolibm [test $ac_cv_func_vdprintf = no \|\| test $REPLACE_VDPRINTF = 1] frexp-nolibm [test $ac_cv_func_vdprintf = no \|\| test $REPLACE_VDPRINTF = 1] frexpl-nolibm [test $ac_cv_func_vdprintf = no \|\| test $REPLACE_VDPRINTF = 1] printf-frexp [test $ac_cv_func_vdprintf = no \|\| test $REPLACE_VDPRINTF = 1] printf-frexpl [test $ac_cv_func_vdprintf = no \|\| test $REPLACE_VDPRINTF = 1] signbit [test $ac_cv_func_vdprintf = no \|\| test $REPLACE_VDPRINTF = 1] fpucw [test $ac_cv_func_vdprintf = no \|\| test $REPLACE_VDPRINTF = 1]
vfprintf-posix	#include <stdio.h>	vfprintf.c	vfprintf-posix.m4 printf.m4 math_h.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_VFPRINTF_POSIX gl_STDIO_MODULE_INDICATOR([vfprintf-posix]) gl_MODULE_INDICATOR([vfprintf-posix])	stdio nocrash printf-safe multiarch free-posix [test $REPLACE_VFPRINTF = 1] fseterr [test $REPLACE_VFPRINTF = 1] vasnprintf [test $REPLACE_VFPRINTF = 1] isnand-nolibm [test $REPLACE_VFPRINTF = 1] isnanl-nolibm [test $REPLACE_VFPRINTF = 1] frexp-nolibm [test $REPLACE_VFPRINTF = 1] frexpl-nolibm [test $REPLACE_VFPRINTF = 1] printf-frexp [test $REPLACE_VFPRINTF = 1] printf-frexpl [test $REPLACE_VFPRINTF = 1] signbit [test $REPLACE_VFPRINTF = 1] fpucw [test $REPLACE_VFPRINTF = 1] errno [test $REPLACE_VFPRINTF = 1]
vprintf-posix	#include <stdio.h>	vprintf.c	vprintf-posix.m4 printf.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_VPRINTF_POSIX gl_STDIO_MODULE_INDICATOR([vprintf-posix]) gl_MODULE_INDICATOR([vprintf-posix])	stdio printf-safe vfprintf-posix [test $REPLACE_VPRINTF = 1]
vsnprintf-posix	#include <stdio.h>	---	vsnprintf-posix.m4 printf.m4 math_h.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_VSNPRINTF_POSIX	vsnprintf nocrash printf-safe multiarch vasnprintf [test $ac_cv_func_vsnprintf = no \|\| test $REPLACE_VSNPRINTF = 1] isnand-nolibm [test $ac_cv_func_vsnprintf = no \|\| test $REPLACE_VSNPRINTF = 1] isnanl-nolibm [test $ac_cv_func_vsnprintf = no \|\| test $REPLACE_VSNPRINTF = 1] frexp-nolibm [test $ac_cv_func_vsnprintf = no \|\| test $REPLACE_VSNPRINTF = 1] frexpl-nolibm [test $ac_cv_func_vsnprintf = no \|\| test $REPLACE_VSNPRINTF = 1] printf-frexp [test $ac_cv_func_vsnprintf = no \|\| test $REPLACE_VSNPRINTF = 1] printf-frexpl [test $ac_cv_func_vsnprintf = no \|\| test $REPLACE_VSNPRINTF = 1] signbit [test $ac_cv_func_vsnprintf = no \|\| test $REPLACE_VSNPRINTF = 1] fpucw [test $ac_cv_func_vsnprintf = no \|\| test $REPLACE_VSNPRINTF = 1]
vsprintf-posix	#include <stdio.h>	vsprintf.c	vsprintf-posix.m4 printf.m4 math_h.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_VSPRINTF_POSIX gl_STDIO_MODULE_INDICATOR([vsprintf-posix])	stdio nocrash printf-safe multiarch vasnprintf [test $REPLACE_VSPRINTF = 1] isnand-nolibm [test $REPLACE_VSPRINTF = 1] isnanl-nolibm [test $REPLACE_VSPRINTF = 1] frexp-nolibm [test $REPLACE_VSPRINTF = 1] frexpl-nolibm [test $REPLACE_VSPRINTF = 1] printf-frexp [test $REPLACE_VSPRINTF = 1] printf-frexpl [test $REPLACE_VSPRINTF = 1] signbit [test $REPLACE_VSPRINTF = 1] fpucw [test $REPLACE_VSPRINTF = 1] stdint [test $REPLACE_VSPRINTF = 1] errno [test $REPLACE_VSPRINTF = 1]
wcsnrtombs	#include <wchar.h>	wcsnrtombs.c wcsnrtombs-impl.h wcsrtombs-state.c	wcsnrtombs.m4 mbrtowc.m4 mbstate_t.m4 locale-ja.m4 locale-zh.m4 codeset.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_WCSNRTOMBS gl_CONDITIONAL([GL_COND_OBJ_WCSNRTOMBS], [test $HAVE_WCSNRTOMBS = 0 \|\| test $REPLACE_WCSNRTOMBS = 1]) AM_COND_IF([GL_COND_OBJ_WCSNRTOMBS], [ AC_LIBOBJ([wcsrtombs-state]) gl_PREREQ_WCSNRTOMBS ]) gl_WCHAR_MODULE_INDICATOR([wcsnrtombs])	wchar extensions wcrtomb [test $HAVE_WCSNRTOMBS = 0 \|\| test $REPLACE_WCSNRTOMBS = 1]
wcwidth	#include <wchar.h>	wcwidth.c	wcwidth.m4 wchar_t.m4 wint_t.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_WCWIDTH gl_CONDITIONAL([GL_COND_OBJ_WCWIDTH], [test $HAVE_WCWIDTH = 0 \|\| test $REPLACE_WCWIDTH = 1]) AM_COND_IF([GL_COND_OBJ_WCWIDTH], [ gl_PREREQ_WCWIDTH ]) gl_WCHAR_MODULE_INDICATOR([wcwidth])	wchar extensions wctype-h [test $HAVE_WCWIDTH = 0 \|\| test $REPLACE_WCWIDTH = 1] localcharset [test $HAVE_WCWIDTH = 0 \|\| test $REPLACE_WCWIDTH = 1] streq [test $HAVE_WCWIDTH = 0 \|\| test $REPLACE_WCWIDTH = 1] uniwidth/width [test $HAVE_WCWIDTH = 0 \|\| test $REPLACE_WCWIDTH = 1]
windows-spawn	#include "windows-spawn.h"	windows-spawn.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_CANONICAL_HOST]) gl_CONDITIONAL([GL_COND_OBJ_WINDOWS_SPAWN], [case "$host_os" in mingw) true;; ) false;; esac])	findprog-in msvc-nothrow stdbool stdint stdlib strpbrk unistd malloc-posix
windows-stat-inodes	---	---	windows-stat-inodes.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_WINDOWS_STAT_INODES])	windows-stat-override
windows-stat-override	#include <sys/stat.h>	---	00gnulib.m4 zzgnulib.m4 gl_SYS_STAT_H_REQUIRE_DEFAULTS AC_REQUIRE([AC_CANONICAL_HOST]) case "$host_os" in mingw*) gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_OVERRIDES_STRUCT_STAT], [1]) ;; esac	sys_stat
windows-stat-timespec	---	---	windows-stat-timespec.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_WINDOWS_STAT_TIMESPEC])	windows-stat-override
write	#include <unistd.h>	write.c	write.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_WRITE gl_CONDITIONAL([GL_COND_OBJ_WRITE], [test $REPLACE_WRITE = 1]) AM_COND_IF([GL_COND_OBJ_WRITE], [ gl_PREREQ_WRITE ]) gl_UNISTD_MODULE_INDICATOR([write])	unistd raise [test $REPLACE_WRITE = 1] msvc-inval [test $REPLACE_WRITE = 1] msvc-nothrow [test $REPLACE_WRITE = 1]

Compatibility checks for POSIX:2008 functions

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
clock-time	---	---	clock_time.m4 00gnulib.m4 zzgnulib.m4 gl_CLOCK_TIME	extensions
d-ino	---	---	d-ino.m4 00gnulib.m4 zzgnulib.m4 gl_CHECK_TYPE_STRUCT_DIRENT_D_INO	---
d-type	---	---	d-type.m4 00gnulib.m4 zzgnulib.m4 gl_CHECK_TYPE_STRUCT_DIRENT_D_TYPE	---
eloop-threshold	#include <eloop-threshold.h>	eloop-threshold.h	00gnulib.m4 zzgnulib.m4	minmax unistd
link-follow	---	---	link-follow.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_LINK_FOLLOWS_SYMLINK	---
rmdir-errno	---	---	rmdir-errno.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_RMDIR_NOTEMPTY	---
timer-time	#include <time.h>	---	timer_time.m4 00gnulib.m4 zzgnulib.m4 gl_TIMER_TIME	extensions pthread-h
unlink-busy	---	---	unlink-busy.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_UNLINK_BUSY_TEXT	---
winsz-ioctl	---	---	jm-winsz2.m4 00gnulib.m4 zzgnulib.m4 gl_HEADER_TIOCGWINSZ_NEEDS_SYS_IOCTL	winsz-termios
winsz-termios	---	---	jm-winsz1.m4 00gnulib.m4 zzgnulib.m4 gl_HEADER_TIOCGWINSZ_IN_TERMIOS_H gl_WINSIZE_IN_PTEM	---

Enhancements for POSIX:2008 functions

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
chdir-long	#include "chdir-long.h"	chdir-long.c	chdir-long.m4 pathmax.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_CHDIR_LONG gl_CONDITIONAL([GL_COND_OBJ_CHDIR_LONG], [test $gl_cv_have_unlimited_file_name_length = no]) AM_COND_IF([GL_COND_OBJ_CHDIR_LONG], [ gl_PREREQ_CHDIR_LONG ])	unistd pathmax chdir assure [test $gl_cv_have_unlimited_file_name_length = no] atexit [test $gl_cv_have_unlimited_file_name_length = no] fchdir [test $gl_cv_have_unlimited_file_name_length = no] fcntl-h [test $gl_cv_have_unlimited_file_name_length = no] openat [test $gl_cv_have_unlimited_file_name_length = no] memchr [test $gl_cv_have_unlimited_file_name_length = no] mempcpy [test $gl_cv_have_unlimited_file_name_length = no] memrchr [test $gl_cv_have_unlimited_file_name_length = no] stdbool [test $gl_cv_have_unlimited_file_name_length = no] stdlib [test $gl_cv_have_unlimited_file_name_length = no]
basename-lgpl	#include "basename-lgpl.h"	basename-lgpl.c	00gnulib.m4 zzgnulib.m4	double-slash-root filename stdbool
dirent-safer	#include "dirent-safer.h"	dirent--.h opendir-safer.c	dirent-safer.m4 00gnulib.m4 zzgnulib.m4 gl_DIRENT_SAFER gl_MODULE_INDICATOR([dirent-safer])	dirent closedir dirfd fcntl opendir
dirname	#include "dirname.h"	dirname.c basename.c stripslash.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([dirname])	dirname-lgpl xalloc
dirname-lgpl	#include "dirname.h"	dirname-lgpl.c stripslash.c	00gnulib.m4 zzgnulib.m4	basename-lgpl double-slash-root filename malloc-posix stdbool
getopt-gnu	#include <getopt.h>	---	00gnulib.m4 zzgnulib.m4 gl_FUNC_GETOPT_GNU dnl Because of the way gl_FUNC_GETOPT_GNU is implemented (the gl_getopt_required dnl mechanism), there is no need to do any AC_LIBOBJ or AC_SUBST here; they are dnl done in the getopt-posix module.	nocrash getopt-posix
iconv_open-utf	---	---	iconv_open-utf.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ICONV_OPEN_UTF	iconv_open
unistd-safer	#include "unistd-safer.h"	unistd--.h dup-safer.c fd-safer.c pipe-safer.c	unistd-safer.m4 00gnulib.m4 zzgnulib.m4 gl_UNISTD_SAFER	fcntl unistd pipe-posix
fnmatch	#include <fnmatch.h>	fnmatch.c fnmatch_loop.c	mbstate_t.m4 fnmatch.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FNMATCH_POSIX dnl Because of gl_REPLACE_FNMATCH_H: gl_CONDITIONAL_HEADER([fnmatch.h]) if test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1; then AC_LIBOBJ([fnmatch]) gl_PREREQ_FNMATCH fi gl_FNMATCH_MODULE_INDICATOR([fnmatch])	fnmatch-h alloca-opt [test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1] attribute [test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1] btowc [test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1] builtin-expect [test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1] flexmember [test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1] idx [test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1] isblank [test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1] iswctype [test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1] libc-config [test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1] stdbool [test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1] stdckdint [test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1] strnlen [test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1] wchar [test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1] wctype-h [test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1] wmemchr [test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1] wmempcpy [test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1] memchr [test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1] memcmp [test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1] mempcpy [test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1] mbsrtowcs [test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1] mbsinit [test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1]
fnmatch-gnu	#include <fnmatch.h>	fnmatch.c	00gnulib.m4 zzgnulib.m4 gl_FUNC_FNMATCH_GNU if test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1; then AC_LIBOBJ([fnmatch]) gl_PREREQ_FNMATCH fi gl_MODULE_INDICATOR([fnmatch-gnu])	fnmatch
glob	#include <glob.h>	glob.c glob_internal.h glob_pattern_p.c globfree.c	glob.m4 00gnulib.m4 zzgnulib.m4 gl_GLOB dnl Because of gl_REPLACE_GLOB_H: gl_CONDITIONAL_HEADER([glob.h]) gl_CONDITIONAL([GL_COND_OBJ_GLOB], [test $HAVE_GLOB = 0 \|\| test $REPLACE_GLOB = 1]) AM_COND_IF([GL_COND_OBJ_GLOB], [ gl_PREREQ_GLOB ]) gl_CONDITIONAL([GL_COND_OBJ_GLOB_PATTERN_P], [test $HAVE_GLOB_PATTERN_P = 0 \|\| test $REPLACE_GLOB_PATTERN_P = 1]) gl_GLOB_MODULE_INDICATOR([glob])	glob-h c99 largefile alloca [test $HAVE_GLOB = 0 \|\| test $REPLACE_GLOB = 1] builtin-expect [test $HAVE_GLOB = 0 \|\| test $REPLACE_GLOB = 1] closedir [test $HAVE_GLOB = 0 \|\| test $REPLACE_GLOB = 1] d-type [test $HAVE_GLOB = 0 \|\| test $REPLACE_GLOB = 1] dirfd [test $HAVE_GLOB = 0 \|\| test $REPLACE_GLOB = 1] flexmember [test $HAVE_GLOB = 0 \|\| test $REPLACE_GLOB = 1] fnmatch [test $HAVE_GLOB = 0 \|\| test $REPLACE_GLOB = 1] fstatat [test $HAVE_GLOB = 0 \|\| test $REPLACE_GLOB = 1] getlogin_r [test $HAVE_GLOB = 0 \|\| test $REPLACE_GLOB = 1] libc-config [test $HAVE_GLOB = 0 \|\| test $REPLACE_GLOB = 1] memchr [test $HAVE_GLOB = 0 \|\| test $REPLACE_GLOB = 1] mempcpy [test $HAVE_GLOB = 0 \|\| test $REPLACE_GLOB = 1] opendir [test $HAVE_GLOB = 0 \|\| test $REPLACE_GLOB = 1] readdir [test $HAVE_GLOB = 0 \|\| test $REPLACE_GLOB = 1] glibc-internal/scratch_buffer [test $HAVE_GLOB = 0 \|\| test $REPLACE_GLOB = 1] stdbool [test $HAVE_GLOB = 0 \|\| test $REPLACE_GLOB = 1] stdint [test $HAVE_GLOB = 0 \|\| test $REPLACE_GLOB = 1] strdup [test $HAVE_GLOB = 0 \|\| test $REPLACE_GLOB = 1] unistd [test $HAVE_GLOB = 0 \|\| test $REPLACE_GLOB = 1] malloc-posix [test $HAVE_GLOB = 0 \|\| test $REPLACE_GLOB = 1]
exclude	#include "exclude.h"	exclude.c	00gnulib.m4 zzgnulib.m4	assert-h filename fnmatch fopen-gnu hash mbscasecmp mbuiter regex stdbool unlocked-io-internal xalloc

Extra functions based on POSIX:2008

Input/output

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
xprintf-posix	#include "xprintf.h"	---	00gnulib.m4 zzgnulib.m4	xprintf vprintf-posix vfprintf-posix
xvasprintf-posix	#include "xvasprintf.h"	---	00gnulib.m4 zzgnulib.m4	xvasprintf vasprintf-posix

Numeric conversion functions

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
human	#include "human.h"	human.c	human.m4 00gnulib.m4 zzgnulib.m4 gl_HUMAN	argmatch error intprops localeconv memmove xstrtoumax stdbool stdint

File system functions

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
acl	#include "acl.h"	copy-acl.c set-acl.c	00gnulib.m4 zzgnulib.m4	error gettext-h qcopy-acl qset-acl quote
acl-permissions	#include "acl.h"	acl-internal.h acl-errno-valid.c acl_entries.c acl-internal.c get-permissions.c set-permissions.c	acl.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ACL	extern-inline fstat stat stdbool sys_stat
areadlink	#include "areadlink.h"	areadlink.c	00gnulib.m4 zzgnulib.m4	careadlinkat readlink
areadlink-with-size	#include "areadlink.h"	areadlink-with-size.c	00gnulib.m4 zzgnulib.m4	free-posix readlink ssize_t stdint unistd
areadlinkat	#include "areadlink.h"	areadlinkat.c at-func.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([areadlinkat])	areadlink careadlinkat readlinkat at-internal errno extensions fchdir fcntl-h filename openat-die openat-h save-cwd
areadlinkat-with-size	#include "areadlink.h"	areadlinkat-with-size.c at-func.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([areadlinkat-with-size])	areadlink-with-size stdint readlinkat at-internal errno extensions fchdir fcntl-h filename free-posix openat-die openat-h save-cwd unistd
backupfile	#include "backupfile.h"	backup-internal.h backup-find.c backupfile.c	backupfile.m4 00gnulib.m4 zzgnulib.m4 gl_BACKUPFILE	argmatch attribute basename-lgpl c99 closedir d-ino fcntl-h ialloc memcmp opendirat readdir realloc-gnu renameatu stdbool stdckdint stdint xalloc-die
backup-rename	#include "backupfile.h"	backup-internal.h backup-rename.c backupfile.c	backupfile.m4 00gnulib.m4 zzgnulib.m4 gl_BACKUPFILE	argmatch attribute basename-lgpl c99 closedir d-ino fcntl-h ialloc memcmp opendirat readdir renameatu stdbool stdckdint stdint xalloc-oversized
canonicalize	#include "canonicalize.h"	canonicalize.c	canonicalize.m4 lstat.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_CANONICALIZE_FILENAME_MODE gl_MODULE_INDICATOR([canonicalize]) gl_MODULE_INDICATOR_FOR_TESTS([canonicalize]) gl_STDLIB_MODULE_INDICATOR([canonicalize_file_name])	attribute double-slash-root errno extensions fcntl-h file-set filename getcwd hash-triple-simple idx intprops memmove mempcpy nocrash rawmemchr readlink glibc-internal/scratch_buffer stat stdbool sys_stat unistd xalloc-die
canonicalize-lgpl	#include <stdlib.h>	canonicalize-lgpl.c	canonicalize.m4 double-slash-root.m4 lstat.m4 00gnulib.m4 zzgnulib.m4 gl_CANONICALIZE_LGPL gl_CONDITIONAL([GL_COND_OBJ_CANONICALIZE_LGPL], [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1]) gl_MODULE_INDICATOR([canonicalize-lgpl]) gl_STDLIB_MODULE_INDICATOR([canonicalize_file_name]) gl_STDLIB_MODULE_INDICATOR([realpath])	extensions stdlib nocrash double-slash-root [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1] eloop-threshold [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1] errno [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1] fcntl-h [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1] filename [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1] idx [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1] intprops [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1] libc-config [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1] memmove [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1] mempcpy [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1] pathmax [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1] rawmemchr [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1] readlink [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1] glibc-internal/scratch_buffer [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1] stat [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1] stdbool [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1] sys_stat [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1] unistd [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1]
clean-temp	#include "clean-temp.h"	clean-temp.c	00gnulib.m4 zzgnulib.m4	c99 stdbool clean-temp-simple list asyncsafe-spin unistd lock thread-optim error fatal-signal open pathmax tmpdir mkdtemp rmdir xalloc xalloc-die xmalloca linkedhash-list linked-list xlist gettext-h
clean-temp-simple	#include "clean-temp-simple.h"	clean-temp-private.h clean-temp-simple.c	00gnulib.m4 zzgnulib.m4 AC_DEFINE([SIGNAL_SAFE_LIST], [1], [Define if lists must be signal-safe.])	c99 stdbool list asyncsafe-spin unistd lock thread-optim error fatal-signal rmdir linkedhash-list gettext-h
concat-filename	#include "concat-filename.h"	concat-filename.c	00gnulib.m4 zzgnulib.m4	filename malloc-posix stpcpy
copy-file	#include "copy-file.h"	copy-file.c	copy-file.m4 00gnulib.m4 zzgnulib.m4 gl_COPY_FILE	acl-permissions binary-io c99 close copy-file-range error fstat full-write gettext-h ignore-value open qcopy-acl quote safe-read stat-time stdlib unistd utimens
fsusage	#include "fsusage.h"	fsusage.c	fsusage.m4 00gnulib.m4 zzgnulib.m4 gl_FSUSAGE gl_CONDITIONAL([GL_COND_OBJ_FSUSAGE], [test $gl_cv_fs_space = yes]) AM_COND_IF([GL_COND_OBJ_FSUSAGE], [ gl_PREREQ_FSUSAGE_EXTRA ])	c99 largefile stdbool stdint
dirfd	#include <dirent.h>	dirfd.c	dirfd.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_DIRFD gl_CONDITIONAL([GL_COND_OBJ_DIRFD], [test $ac_cv_func_dirfd = no && test $gl_cv_func_dirfd_macro = no \|\| test $REPLACE_DIRFD = 1]) AM_COND_IF([GL_COND_OBJ_DIRFD], [ gl_PREREQ_DIRFD ]) gl_DIRENT_MODULE_INDICATOR([dirfd])	dirent extensions errno [test $ac_cv_func_dirfd = no && test $gl_cv_func_dirfd_macro = no \|\| test $REPLACE_DIRFD = 1]
double-slash-root	---	---	double-slash-root.m4 00gnulib.m4 zzgnulib.m4 gl_DOUBLE_SLASH_ROOT	---
euidaccess	#include <unistd.h>	euidaccess.c	euidaccess.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_EUIDACCESS gl_CONDITIONAL([GL_COND_OBJ_EUIDACCESS], [test $HAVE_EUIDACCESS = 0]) AM_COND_IF([GL_COND_OBJ_EUIDACCESS], [ gl_PREREQ_EUIDACCESS ]) gl_UNISTD_MODULE_INDICATOR([euidaccess])	unistd extensions root-uid fcntl-h group-member [test $HAVE_EUIDACCESS = 0] stat [test $HAVE_EUIDACCESS = 0] sys_stat [test $HAVE_EUIDACCESS = 0]
faccessat	#include <fcntl.h> #include <unistd.h>	faccessat.c at-func.c	faccessat.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FACCESSAT gl_CONDITIONAL([GL_COND_OBJ_FACCESSAT], [test $HAVE_FACCESSAT = 0 \|\| test $REPLACE_FACCESSAT = 1]) AM_COND_IF([GL_COND_OBJ_FACCESSAT], [ gl_PREREQ_FACCESSAT ]) gl_MODULE_INDICATOR([faccessat]) gl_UNISTD_MODULE_INDICATOR([faccessat])	unistd extensions at-internal [test $HAVE_FACCESSAT = 0 \|\| test $REPLACE_FACCESSAT = 1] errno [test $HAVE_FACCESSAT = 0 \|\| test $REPLACE_FACCESSAT = 1] fchdir [test $HAVE_FACCESSAT = 0 \|\| test $REPLACE_FACCESSAT = 1] fcntl-h [test $HAVE_FACCESSAT = 0 \|\| test $REPLACE_FACCESSAT = 1] filename [test $HAVE_FACCESSAT = 0 \|\| test $REPLACE_FACCESSAT = 1] fstatat [test $HAVE_FACCESSAT = 0 \|\| test $REPLACE_FACCESSAT = 1] openat-die [test $HAVE_FACCESSAT = 0 \|\| test $REPLACE_FACCESSAT = 1] openat-h [test $HAVE_FACCESSAT = 0 \|\| test $REPLACE_FACCESSAT = 1] save-cwd [test $HAVE_FACCESSAT = 0 \|\| test $REPLACE_FACCESSAT = 1] euidaccess [test $HAVE_FACCESSAT = 0 \|\| test $REPLACE_FACCESSAT = 1]
fdopendir	#include <dirent.h>	fdopendir.c	fdopendir.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FDOPENDIR gl_CONDITIONAL([GL_COND_OBJ_FDOPENDIR], [test $HAVE_FDOPENDIR = 0 \|\| test $REPLACE_FDOPENDIR = 1]) gl_DIRENT_MODULE_INDICATOR([fdopendir]) gl_MODULE_INDICATOR([fdopendir])	dirent extensions at-internal [test $HAVE_FDOPENDIR = 0] dirfd [test $HAVE_FDOPENDIR = 0] dup [test $HAVE_FDOPENDIR = 0] errno [test $HAVE_FDOPENDIR = 0] fchdir [test $HAVE_FDOPENDIR = 0] fstat [test $HAVE_FDOPENDIR = 0] openat-die [test $HAVE_FDOPENDIR = 0] opendir [test $HAVE_FDOPENDIR = 0] save-cwd [test $HAVE_FDOPENDIR = 0]
fdutimensat	#include <fcntl.h> #include "utimens.h"	fdutimensat.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([fdutimensat])	extern-inline futimens utimensat
file-type	#include "file-type.h"	file-type.c	00gnulib.m4 zzgnulib.m4	gettext-h sys_stat