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
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-posix	realloc function: allocate memory with indefinite extent.
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 POSIX 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-recommended	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 for unibyte locales.
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	Wrappers around printf and fprintf that call error upon ENOMEM, EOVERFLOW, 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	Formatted printing into an obstack with POSIX compatible format string interpretation
hashcode-string2	Compute a hash value for a NUL-terminated string.
hashcode-mem	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>.

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 works around platform issues.

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, unless std-gnu23 is also used.
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	Provide a GCC-compatible __builtin_expect macro.
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.
std-gnu23	Prefer GNU C23 to earlier versions.
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

Support for GNU multiple precision arithmetic

libgmp	GNU Multiple Precision Arithmetic library, or its mini-gmp + mini-mpq substitute
libgmp-mpz	GNU Multiple Precision Arithmetic library (mpn_, mpz_ part), or its mini-gmp substitute
libgmp-mpq	GNU Multiple Precision Arithmetic library (mpq_* part), or its mini-mpq substitute

accept	accept function: accept a connection to a server socket.
alphasort	alphasort function: compare entries of a directory alphabetically
arpa_inet-h	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.
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-h
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-h
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 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 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 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

Input/output

xprintf-posix	Wrappers around printf and fprintf with POSIX compatible format string interpretation, that calls error upon ENOMEM, EOVERFLOW, 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.
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.
hashcode-file-inode	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. The purpose of this module is: - So that gnulib testdirs include i18n support and thus expose possible link errors on non-glibc platforms. We want to detect such link errors from within gnulib and fix them by adding $(LIBINTL) to various <program>_LDADD variables. - To fix conflicts between older versions of `gettextize` and the newer versions of files found in gnulib. See https://www.gnu.org/software/gnulib/manual/html_node/gettextize-and-autopoint.html - As a prototype if/when we someday unify gnulib-tool, libtoolize, and gettextize in a single tool.
gettext-h	Translate messages to user's native language if GNU gettext is also used.
propername	Localization of proper names.
propername-lite	Lighter-weight 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-compat-math-continue	Test whether a Unicode character is "id compat math continue".
unictype/property-id-compat-math-start	Test whether a Unicode character is "id compat math start".
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-ids-unary-operator	Test whether a Unicode character is "ids unary 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-modifier-combining-mark	Test whether a Unicode character is "modifier combining mark".
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-prepended-concatenation-mark	Test whether a Unicode character is "prepended concatenation mark".
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>	---	00gnulib.m4 zzgnulib.m4	stdlib-h
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-h
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-h
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-h [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-h
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-h
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-h
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-h

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-h strtod-obsolete c-ctype [test $HAVE_STRTOD = 0 \|\| test $REPLACE_STRTOD = 1] math-h [test $HAVE_STRTOD = 0 \|\| test $REPLACE_STRTOD = 1] bool [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-h assert-h [test $REPLACE_STRERROR = 1] errno-h [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-h
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 assert-h [test $REPLACE_MKTIME = 1] intprops [test $REPLACE_MKTIME = 1] libc-config [test $REPLACE_MKTIME = 1] bool [test $REPLACE_MKTIME = 1] stdckdint-h [test $REPLACE_MKTIME = 1] time_r [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-h fpurge [test $REPLACE_FFLUSH = 1] ftello [test $REPLACE_FFLUSH = 1] freading [test $REPLACE_FFLUSH = 1] lseek [test $REPLACE_FFLUSH = 1] unistd-h [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-h largefile pathmax [test $REPLACE_TMPFILE = 1] bool [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 extensions-aix stdckdint-h [test $REPLACE_CALLOC_FOR_CALLOC_GNU = 1]
eealloc	#include <eealloc.h>	eealloc.h eealloc.c	eealloc.m4 malloc.m4 00gnulib.m4 zzgnulib.m4 gl_EEALLOC	extern-inline stdlib-h
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-h string-h wchar-h
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 extensions-aix stdckdint-h [test $REPLACE_CALLOC_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-posix	#include <stdlib.h>	realloc.c	realloc.m4 malloc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_REALLOC_POSIX gl_FUNC_REALLOC_0_NONNULL gl_CONDITIONAL([GL_COND_OBJ_REALLOC_POSIX], [test $REPLACE_REALLOC_FOR_REALLOC_POSIX != 0]) gl_STDLIB_MODULE_INDICATOR([realloc-posix])	extensions-aix stdckdint-h [test $REPLACE_REALLOC_FOR_REALLOC_POSIX != 0] stdlib-h
reallocarray	#include <stdlib.h>	reallocarray.c	malloc.m4 realloc.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-posix [test $HAVE_REALLOCARRAY = 0 \|\| test $REPLACE_REALLOCARRAY = 1] stdckdint-h [test $HAVE_REALLOCARRAY = 0 \|\| test $REPLACE_REALLOCARRAY = 1] stdlib-h
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 gnulib-i18n open stdlib-h xalloc unistd-h

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 FreeBSD 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-h

Date and time <time.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
fprintftime	#include "fprintftime.h"	fprintftime.c strftime.c	00gnulib.m4 zzgnulib.m4	stdio-h nstrftime time_rz
nstrftime	#include "strftime.h"	nstrftime.c strftime.c	nstrftime.m4 tm_gmtoff.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_GNU_STRFTIME	attribute c-ctype c99 errno-h extensions intprops libc-config localename-unsafe-limited bool stdckdint-h 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-h
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_TZALLOC = 0 \|\| test $REPLACE_LOCALTIME_RZ = 1 \|\| test $REPLACE_MKTIME_Z = 1]) gl_TIME_MODULE_INDICATOR([time_rz])	c99 extensions time-h flexmember [test $HAVE_TZALLOC = 0 \|\| test $REPLACE_LOCALTIME_RZ = 1 \|\| test $REPLACE_MKTIME_Z = 1] idx [test $HAVE_TZALLOC = 0 \|\| test $REPLACE_LOCALTIME_RZ = 1 \|\| test $REPLACE_MKTIME_Z = 1] setenv [test $HAVE_TZALLOC = 0 \|\| test $REPLACE_LOCALTIME_RZ = 1 \|\| test $REPLACE_MKTIME_Z = 1] bool [test $HAVE_TZALLOC = 0 \|\| test $REPLACE_LOCALTIME_RZ = 1 \|\| test $REPLACE_MKTIME_Z = 1] time_r [test $HAVE_TZALLOC = 0 \|\| test $REPLACE_LOCALTIME_RZ = 1 \|\| test $REPLACE_MKTIME_Z = 1] timegm [test $HAVE_TZALLOC = 0 \|\| test $REPLACE_LOCALTIME_RZ = 1 \|\| test $REPLACE_MKTIME_Z = 1] tzset [test $HAVE_TZALLOC = 0 \|\| test $REPLACE_LOCALTIME_RZ = 1 \|\| test $REPLACE_MKTIME_Z = 1] unsetenv [test $HAVE_TZALLOC = 0 \|\| test $REPLACE_LOCALTIME_RZ = 1 \|\| test $REPLACE_MKTIME_Z = 1]
year2038	---	---	largefile.m4 00gnulib.m4 zzgnulib.m4	---
year2038-recommended	---	---	largefile.m4 00gnulib.m4 zzgnulib.m4	---

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-h posix_memalign aligned_alloc memalign
ialloc	#include "ialloc.h"	ialloc.c	00gnulib.m4 zzgnulib.m4	calloc-gnu extern-inline idx malloc-gnu realloc-posix reallocarray stdint-h
idx	#include "idx.h"	---	00gnulib.m4 zzgnulib.m4	stdint-h
immutable	#include "immutable.h"	immutable.c	immutable.m4 mprotect.m4 mmap-anon.m4 nocrash.m4 00gnulib.m4 zzgnulib.m4 gl_IMMUTABLE	stdint-h pathmax open once 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-h stdlib-h
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-posix reallocarray stdckdint-h stdint-h xalloc-die
xalloc-die	#include "xalloc.h"	xalloc-die.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([xalloc-die])	error extern-inline gettext-h gnulib-i18n 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-h stdint-h
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 malloc.m4 00gnulib.m4 zzgnulib.m4 gl_MALLOCA	alloca-opt assert-h extensions-aix idx stdckdint-h stdint-h stdlib-h 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-h
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-h 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-h 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>	---	00gnulib.m4 zzgnulib.m4	putenv-gnu
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-h 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-h malloca [test $HAVE_SETENV = 0 \|\| test $REPLACE_SETENV = 1] alloca-opt [test $HAVE_SETENV = 0 \|\| test $REPLACE_SETENV = 1] malloc-posix [test $HAVE_SETENV = 0 \|\| test $REPLACE_SETENV = 1] unistd-h [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-h unistd-h [test $HAVE_UNSETENV = 0 \|\| test $REPLACE_UNSETENV = 1] environ [test $HAVE_UNSETENV = 0 \|\| test $REPLACE_UNSETENV = 1] free-posix [test $HAVE_UNSETENV = 0 \|\| test $REPLACE_UNSETENV = 1] malloc-posix [test $HAVE_UNSETENV = 0 \|\| test $REPLACE_UNSETENV = 1]
xsetenv	#include "xsetenv.h"	xsetenv.c	00gnulib.m4 zzgnulib.m4	setenv unsetenv error gettext-h gnulib-i18n stdlib-h

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 bool

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-h
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-h
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-h
memchr2	#include "memchr2.h"	memchr2.c memchr2.valgrind	00gnulib.m4 zzgnulib.m4	stdint-h 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-h stdint-h 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-h
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-h
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])	assert-h extensions stdint-h string-h
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-h
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-h
c-strcase	#include "c-strcase.h"	---	00gnulib.m4 zzgnulib.m4	c-strcasecmp c-strncasecmp
strcase	#include <strings.h>	---	00gnulib.m4 zzgnulib.m4	strcasecmp strncasecmp
c-strcaseeq	#include "c-strcaseeq.h"	---	00gnulib.m4 zzgnulib.m4	c-strcasecmp c-ctype
c-strcasestr	#include "c-strcasestr.h"	c-strcasestr.c str-two-way.h	00gnulib.m4 zzgnulib.m4	c-ctype c-strncasecmp bool 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	bool 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-h bool strncasecmp 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-h 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-h
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, xstrerror. gl_MODULE_INDICATOR([strerror_r-posix])	string-h extensions errno-h [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 string-buffer-printf.c	00gnulib.m4 zzgnulib.m4	bool attribute string-desc stdarg-h vsnzprintf-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-h 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-h 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-h 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-h builtin-expect [test $REPLACE_STRSTR = 1] bool [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	c32isspace mbchar mbuiterf mempcpy xalloc-die
fstrcmp	#include "fstrcmp.h"	fstrcmp.c	00gnulib.m4 zzgnulib.m4	c99 diffseq once tls minmax stdint-h 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-h c-ctype 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-h c-ctype strtold
xstrtod	#include "xstrtod.h"	xstrtod.c	xstrtod.m4 00gnulib.m4 zzgnulib.m4 gl_XSTRTOD	bool
xstrtol	#include "xstrtol.h"	xstrtol.c xstrtoul.c	xstrtol.m4 00gnulib.m4 zzgnulib.m4 gl_XSTRTOL	intprops stdckdint-h stdint-h
xstrtol-error	#include "xstrtol-error.h"	xstrtol-error.c	00gnulib.m4 zzgnulib.m4	xstrtol error exitfail getopt-gnu gettext-h gnulib-i18n
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	bool

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	parse-datetime.m4 tm_gmtoff.m4 00gnulib.m4 zzgnulib.m4 gl_PARSE_DATETIME	assert-h bison c99 c-ctype bool gettime gettext-h gnulib-i18n idx intprops inttypes-h mktime stdckdint-h time-h time_r time_rz
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-h bool
vasnprintf	#include "vasnprintf.h"	float+.h printf-args.h printf-args.c printf-parse.h printf-parse.c vasnprintf.c asnprintf.c	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-h alloca-opt attribute float-h free-posix limits-h stdint-h xsize errno-h localeconv memchr assert-h wchar-h mbszero mbsnlen
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-h extensions vasnprintf [test $HAVE_VASPRINTF = 0 \|\| test $REPLACE_VASPRINTF = 1] errno-h [test $HAVE_VASPRINTF = 0 \|\| test $REPLACE_VASPRINTF = 1] stdint-h [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-h error exitfail gettext-h gnulib-i18n stdarg-h vzprintf vfzprintf
xvasprintf	#include "xvasprintf.h"	xvasprintf.c xasprintf.c xalloc.h	xvasprintf.m4 strerrorname_np.m4 00gnulib.m4 zzgnulib.m4 gl_XVASPRINTF m4_ifdef([AM_XGETTEXT_OPTION], [AM_][XGETTEXT_OPTION([--flag=xasprintf:1:c-format])])	extensions stdio-h vaszprintf xalloc xalloc-die extern-inline xsize stdarg-h errno-h

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 bool unistd-h sigaction lock once 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-h
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-h
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-h extensions gettext-h [test $HAVE_STRSIGNAL = 0 \|\| test $REPLACE_STRSIGNAL = 1] gnulib-i18n [test $HAVE_STRSIGNAL = 0 \|\| test $REPLACE_STRSIGNAL = 1] once [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-h

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 gnulib-i18n memcmp quote quotearg bool stdlib-h
argv-iter	#include "argv-iter.h"	argv-iter.c	00gnulib.m4 zzgnulib.m4	getdelim snippet/arg-nonnull bool
version-etc	#include "version-etc.h"	version-etc.c	version-etc.m4 00gnulib.m4 zzgnulib.m4 gl_VERSION_ETC	gettext-h gnulib-i18n stdarg-h
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 bool stdlib-h 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 bool
xlist	#include "gl_xlist.h"	gl_xlist.c	00gnulib.m4 zzgnulib.m4	list extern-inline bool xalloc-die
array-list	#include "gl_array_list.h"	gl_array_list.c	00gnulib.m4 zzgnulib.m4	list stdint-h xsize
carray-list	#include "gl_carray_list.h"	gl_carray_list.c	00gnulib.m4 zzgnulib.m4	list stdint-h 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-h 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-h 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-h xsize
sublist	#include "gl_sublist.h"	gl_sublist.c	00gnulib.m4 zzgnulib.m4	list stdint-h
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 bool
xoset	#include "gl_xoset.h"	gl_xoset.c	00gnulib.m4 zzgnulib.m4	oset extern-inline bool 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 bool stdlib-h 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-h
crypto/arctwo	#include "arctwo.h"	arctwo.c	arctwo.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_RESTRICT]) gl_ARCTWO	stdint-h bitrotate
crypto/des	#include "des.h"	des.c	00gnulib.m4 zzgnulib.m4	stdint-h bool 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-h
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-h
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-h
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-h
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-h
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-h 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-h

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	extern-inline ialloc bool memchr stdckdint-h
base64	#include "base64.h"	base64.c	base64.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_BASE64	extern-inline ialloc bool memchr stdckdint-h
check-version	#include "check-version.h"	check-version.c	00gnulib.m4 zzgnulib.m4	strverscmp
crc	#include "crc.h"	crc.c crc-generate-table.c	crc.m4 build-cc.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_CRC_SLICE_BY_8]) gl_BUILD_CC AC_PROG_MKDIR_P	stdint-h endian
diffseq	#include "diffseq.h"	---	00gnulib.m4 zzgnulib.m4	c99 bool
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-h 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-h extensions limits-h [test $HAVE_GETDELIM = 0 \|\| test $REPLACE_GETDELIM = 1] stdint-h [test $HAVE_GETDELIM = 0 \|\| test $REPLACE_GETDELIM = 1] errno-h [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	limits-h ssize_t bool stdint-h 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.in.h obstack.c	obstack.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_OBSTACK gl_CONDITIONAL_HEADER([obstack.h]) gl_CONDITIONAL([GL_COND_OBJ_OBSTACK], [test $HAVE_OBSTACK = 0 \|\| test $REPLACE_OBSTACK = 1]) AC_PROG_MKDIR_P	gen-header alignasof [test $HAVE_OBSTACK = 0 \|\| test $REPLACE_OBSTACK = 1] libc-config [test $HAVE_OBSTACK = 0 \|\| test $REPLACE_OBSTACK = 1] flexmember [test $HAVE_OBSTACK = 0 \|\| test $REPLACE_OBSTACK = 1] gettext-h [test $HAVE_OBSTACK = 0 \|\| test $REPLACE_OBSTACK = 1] gnulib-i18n [test $HAVE_OBSTACK = 0 \|\| test $REPLACE_OBSTACK = 1] exitfail [test $HAVE_OBSTACK = 0 \|\| test $REPLACE_OBSTACK = 1] stdckdint-h [test $HAVE_OBSTACK = 0 \|\| test $REPLACE_OBSTACK = 1] stddef-h [test $HAVE_OBSTACK = 0 \|\| test $REPLACE_OBSTACK = 1] stdint-h [test $HAVE_OBSTACK = 0 \|\| test $REPLACE_OBSTACK = 1] stdlib-h [test $HAVE_OBSTACK = 0 \|\| test $REPLACE_OBSTACK = 1]
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-h 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-h vasnprintf-posix extensions
hashcode-string2	#include "hashcode-string2.h"	hashcode-string2.c hash-pjw.h	00gnulib.m4 zzgnulib.m4	---
hashcode-mem	#include "hashcode-mem.h"	hashcode-mem.c hash-pjw-bare.h	00gnulib.m4 zzgnulib.m4	---
hash	#include "hash.h"	hash.c	00gnulib.m4 zzgnulib.m4	bitrotate calloc-posix free-posix malloc-posix next-prime bool stdint-h xalloc-oversized hashcode-string1
hamt	#include "hamt.h"	hamt.c	00gnulib.m4 zzgnulib.m4	count-one-bits extern-inline flexmember inttypes-h-incomplete bool stdint-h 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 bool
readtokens0	#include "readtokens0.h"	readtokens0.c	00gnulib.m4 zzgnulib.m4	obstack bool
stack	#include "stack.h"	---	00gnulib.m4 zzgnulib.m4	assure bool stdlib-h 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 \|\| test $REPLACE_STRVERSCMP = 1]) AM_COND_IF([GL_COND_OBJ_STRVERSCMP], [ gl_PREREQ_STRVERSCMP ]) gl_STRING_MODULE_INDICATOR([strverscmp])	extensions libc-config [test $HAVE_STRVERSCMP = 0 \|\| test $REPLACE_STRVERSCMP = 1] stdint-h [test $HAVE_STRVERSCMP = 0 \|\| test $REPLACE_STRVERSCMP = 1] string-h
filevercmp	#include "filevercmp.h"	filevercmp.c	00gnulib.m4 zzgnulib.m4	assert-h c-ctype idx bool

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>	---	00gnulib.m4 zzgnulib.m4	stdarg-h

Boolean type and values <stdbool.h>

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

Basic types <stddef.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
stddef	#include <stddef.h>	---	00gnulib.m4 zzgnulib.m4	stddef-h

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>	---	00gnulib.m4 zzgnulib.m4	stdint-h

Input/output <stdio.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
stdio	#include <stdio.h>	---	00gnulib.m4 zzgnulib.m4	stdio-h
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-h errno-h [test $ac_cv_func_snprintf = no \|\| test $REPLACE_SNPRINTF = 1] stdint-h [test $ac_cv_func_snprintf = no \|\| test $REPLACE_SNPRINTF = 1] vsnzprintf [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-h errno-h [test $ac_cv_func_vsnprintf = no \|\| test $REPLACE_VSNPRINTF = 1] stdint-h [test $ac_cv_func_vsnprintf = no \|\| test $REPLACE_VSNPRINTF = 1] vsnzprintf [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-h unistd-h
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])	stdlib-h 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-h
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-h

Unibyte characters <ctype.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
ctype	#include <ctype.h>	---	00gnulib.m4 zzgnulib.m4	ctype-h

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-h-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-h-incomplete
inttypes	#include <inttypes.h>	---	00gnulib.m4 zzgnulib.m4	inttypes-h
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-h-incomplete assert-h [test $HAVE_DECL_STRTOIMAX = 0 \|\| test $REPLACE_STRTOIMAX = 1] stdint-h [test $HAVE_DECL_STRTOIMAX = 0 \|\| test $REPLACE_STRTOIMAX = 1] strtoll [test $HAVE_DECL_STRTOIMAX = 0 \|\| test $REPLACE_STRTOIMAX = 1]
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-h-incomplete assert-h [test $HAVE_DECL_STRTOUMAX = 0 \|\| test $REPLACE_STRTOUMAX = 1] stdint-h [test $HAVE_DECL_STRTOUMAX = 0 \|\| test $REPLACE_STRTOUMAX = 1] strtoull [test $HAVE_DECL_STRTOUMAX = 0 \|\| test $REPLACE_STRTOUMAX = 1]

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-h

Extended multibyte and wide character utilities <wchar.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
wchar	#include <wchar.h>	---	00gnulib.m4 zzgnulib.m4	wchar-h
btowc	#include <wchar.h>	btowc.c	btowc.m4 mbrtowc.m4 locale-en.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-h mbszero [test $HAVE_BTOWC = 0 \|\| test $REPLACE_BTOWC = 1] mbrtowc [test $HAVE_BTOWC = 0 \|\| test $REPLACE_BTOWC = 1] mbtowc [test $HAVE_BTOWC = 0 \|\| test $REPLACE_BTOWC = 1]
wctob	#include <wchar.h>	wctob.c	wctob.m4 locale-en.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-h wctomb [test $HAVE_WCTOB = 0 \|\| test $REPLACE_WCTOB = 1]
mbsinit	#include <wchar.h>	mbsinit.c	mbsinit.m4 mbstate_t.m4 mbrtowc.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-h 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 locale-en.m4 locale-ja.m4 locale-zh.m4 codeset.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-h 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-en.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-h extensions attribute [test $HAVE_MBRTOWC = 0 \|\| test $REPLACE_MBRTOWC = 1] stdint-h [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-en.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-h 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-en.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-h 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-en.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-h 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 \|\| test $REPLACE_WCTYPE = 1]) gl_WCTYPE_MODULE_INDICATOR([wctype])	wctype-h iswblank [test $HAVE_WCTYPE = 0 \|\| test $REPLACE_WCTYPE = 1] iswdigit [test $HAVE_WCTYPE = 0 \|\| test $REPLACE_WCTYPE = 1] iswpunct [test $HAVE_WCTYPE = 0 \|\| test $REPLACE_WCTYPE = 1] iswxdigit [test $HAVE_WCTYPE = 0 \|\| test $REPLACE_WCTYPE = 1] iswctype [test $REPLACE_WCTYPE = 1]

Characteristics of floating types <float.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
float	#include <float.h>	---	00gnulib.m4 zzgnulib.m4	float-h

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-h 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-h 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-h 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-h 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-h float-h [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-h extensions float-h [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-h extensions ceil [{ test $HAVE_DECL_CEILL = 0 \|\| test $REPLACE_CEILL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] float-h [{ 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-h 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-h extensions cos [test $HAVE_COSL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] float-h [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-h extensions exp [{ test $HAVE_EXPL = 0 \|\| test $REPLACE_EXPL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] float-h [{ 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-h float-h [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-h extensions float-h [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-h extensions floor [{ test $HAVE_DECL_FLOORL = 0 \|\| test $REPLACE_FLOORL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] float-h [{ 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-h 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-h 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-h 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-h 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-h 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-h 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 exponentl.m4 exponentd.m4 math_h.m4 00gnulib.m4 zzgnulib.m4 gl_ISFINITE gl_CONDITIONAL([GL_COND_OBJ_ISFINITE], [test $REPLACE_ISFINITE = 1]) gl_MATH_MODULE_INDICATOR([isfinite])	math-h 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-h extensions float-h [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-h 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-h 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-h 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 exponentd.m4 math_h.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-h float-h fpieee memcmp
isnanl-nolibm	#include "isnanl-nolibm.h"	isnanl.c isnan.c float+.h	exponentl.m4 exponentd.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-h 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.c	ldexp.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_LDEXP gl_CONDITIONAL([GL_COND_OBJ_LDEXP], [test $REPLACE_LDEXP = 1]) gl_MATH_MODULE_INDICATOR([ldexp])	math-h isnand [test $REPLACE_LDEXP = 1] bool [test $REPLACE_LDEXP = 1]
ldexpl	#include <math.h>	ldexpl.c ldexp.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-h 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] bool [{ 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-h
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-h
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-h 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-h 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-h 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>	---	00gnulib.m4 zzgnulib.m4	math-h
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-h 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-h 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-h
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-h extensions float-h [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-h extensions float-h [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-h extensions round [{ test $HAVE_ROUNDL = 0 \|\| test $REPLACE_ROUNDL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] float-h [{ 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-h float-h [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-h extensions sin [test $HAVE_SINL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] float-h [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-h extensions sqrt [{ test $HAVE_SQRTL = 0 \|\| test $REPLACE_SQRTL = 1; }] float-h [{ 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-h extensions tan [test $HAVE_TANL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] float-h [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-h extensions float-h [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-h extensions float-h [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-h extensions trunc [{ test $HAVE_DECL_TRUNCL = 0 \|\| test $REPLACE_TRUNCL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] float-h [{ 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-h [test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] math-h [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-h
ldtoastr	#include "ftoastr.h"	ftoastr.c ldtoastr.c	00gnulib.m4 zzgnulib.m4	extensions intprops strtold
xstrtoimax	#include "xstrtol.h"	xstrtoimax.c	00gnulib.m4 zzgnulib.m4	xstrtol inttypes-h-incomplete strtoimax
xstrtoumax	#include "xstrtol.h"	xstrtoumax.c	00gnulib.m4 zzgnulib.m4	xstrtol inttypes-h-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 bool uchar-h c32isalnum c32isalpha c32isblank c32iscntrl c32isdigit c32isgraph c32islower c32isprint c32ispunct c32isspace c32isupper c32isxdigit c32tolower c32width memcmp
mbiter	#include "mbiter.h"	mbiter.c	mbiter.m4 mbrtowc.m4 00gnulib.m4 zzgnulib.m4 gl_MBITER	extern-inline mbchar mbrtoc32 mbsinit mbszero uchar-h bool
mbuiter	#include "mbuiter.h"	mbuiter.c	mbiter.m4 mbrtowc.m4 00gnulib.m4 zzgnulib.m4 gl_MBITER	extern-inline mbchar mbrtoc32 mbsinit mbszero uchar-h bool strnlen1
mbfile	#include "mbfile.h"	mbfile.c	mbfile.m4 mbrtowc.m4 00gnulib.m4 zzgnulib.m4 gl_MBFILE dnl Do not use gl_MODULE_INDICATOR([mbfile]) here: we don't want 'struct mbchar' dnl to have a different size in lib/ than in tests/. AC_DEFINE([GNULIB_MBFILE], [1], [Define to 1 if the gnulib module 'mbfile' is in use.])	extern-inline mbchar mbrtowc mbsinit mbszero wchar-h bool

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	---	---	00gnulib.m4 zzgnulib.m4	stdalign-h

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	endian [$GL_GENERATE_IEEE754_H] 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	---
std-gnu23	---	---	std-gnu23.m4 00gnulib.m4 zzgnulib.m4	---
stdckdint	#include <stdckdint.h>	---	00gnulib.m4 zzgnulib.m4	stdckdint-h

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-h malloc-posix [test $REPLACE_ALIGNED_ALLOC = 1]

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 \|\| test $REPLACE_MEMSET_EXPLICIT = 1]) AM_COND_IF([GL_COND_OBJ_MEMSET_EXPLICIT], [ gl_PREREQ_MEMSET_EXPLICIT ]) gl_STRING_MODULE_INDICATOR([memset_explicit])	string-h extensions

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 \|\| test $REPLACE_TIMESPEC_GETRES = 1]) gl_TIME_MODULE_INDICATOR([timespec_getres])	extensions time-h gettime-res [test $HAVE_TIMESPEC_GETRES = 0 \|\| test $REPLACE_TIMESPEC_GETRES = 1]

Support for GNU multiple precision arithmetic

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
libgmp	#include <gmp.h>	---	00gnulib.m4 zzgnulib.m4	libgmp-mpz libgmp-mpq
libgmp-mpz	#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])	gen-header
libgmp-mpq	#include <gmp.h>	mini-mpq-gnulib.c mini-mpq.c mini-mpq.h	00gnulib.m4 zzgnulib.m4 gl_LIBGMP gl_CONDITIONAL([GL_COND_OBJ_MINI_MPQ_GNULIB], [test $HAVE_LIBGMP != yes]) gl_MODULE_INDICATOR([libgmp-mpq])	libgmp-mpz

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

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-h

Support for systems lacking POSIX

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]) gl_MODULE_INDICATOR([accept])	extensions sys_socket-h socketlib errno-h [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-h extensions
arpa_inet-h	#include <arpa/inet.h>	arpa_inet.in.h arpa_inet.c	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	extern-inline gen-header include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use sys_socket-h
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]) gl_MODULE_INDICATOR([bind])	sys_socket-h socketlib errno-h [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])	stdckdint-h [test $REPLACE_CALLOC_FOR_CALLOC_POSIX = 1] stdlib-h
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-h 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-h 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] bool [test $HAVE_CHOWN = 0 \|\| test $REPLACE_CHOWN = 1] sys_stat-h [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]) gl_MODULE_INDICATOR([close])	unistd-h 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]) gl_MODULE_INDICATOR([connect])	sys_socket-h socketlib errno-h [test "$ac_cv_header_winsock2_h" = yes] msvc-nothrow [test "$ac_cv_header_winsock2_h" = yes]
dirent	#include <dirent.h>	---	00gnulib.m4 zzgnulib.m4	dirent-h
dprintf	#include <stdio.h>	dprintf.c	dprintf.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_DPRINTF gl_STDIO_MODULE_INDICATOR([dprintf])	stdio-h vdzprintf [test $ac_cv_func_dprintf = no \|\| test $REPLACE_DPRINTF = 1] intprops [test $ac_cv_func_dprintf = no \|\| test $REPLACE_DPRINTF = 1] errno-h [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] mixin/printf-posix [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-h 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_LOCALE_T = 0 \|\| { test $HAVE_DUPLOCALE = 1 && test $REPLACE_DUPLOCALE = 1; }]) AM_COND_IF([GL_COND_OBJ_DUPLOCALE], [ gl_PREREQ_DUPLOCALE ]) gl_LOCALE_MODULE_INDICATOR([duplocale])	locale-h freelocale [test $HAVE_LOCALE_T = 0 \|\| { test $HAVE_DUPLOCALE = 1 && test $REPLACE_DUPLOCALE = 1; }] newlocale [test $HAVE_LOCALE_T = 0 \|\| { test $HAVE_DUPLOCALE = 1 && test $REPLACE_DUPLOCALE = 1; }] setlocale-null [test $HAVE_LOCALE_T = 0 \|\| { 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-h extensions
errno	#include <errno.h>	---	00gnulib.m4 zzgnulib.m4	errno-h
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-h 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-h 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-h 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-h 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-h posix_spawn [test $REPLACE_EXECVE = 1] close [test $REPLACE_EXECVE = 1] sys_wait-h [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-h 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-h extensions free-posix [test $HAVE_EXECVPE = 0 \|\| test $REPLACE_EXECVPE = 1] bool [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 \|\| test $REPLACE_FCHDIR = 1]) AM_COND_IF([GL_COND_OBJ_FCHDIR], [ gl_PREREQ_FCHDIR ]) gl_UNISTD_MODULE_INDICATOR([fchdir])	dirent-h unistd-h assure [test $HAVE_FCHDIR = 0 \|\| test $REPLACE_FCHDIR = 1] chdir [test $HAVE_FCHDIR = 0 \|\| test $REPLACE_FCHDIR = 1] close [test $HAVE_FCHDIR = 0 \|\| test $REPLACE_FCHDIR = 1] dirfd [test $HAVE_FCHDIR = 0 \|\| test $REPLACE_FCHDIR = 1] dup2 [test $HAVE_FCHDIR = 0 \|\| test $REPLACE_FCHDIR = 1] fcntl [test $HAVE_FCHDIR = 0 \|\| test $REPLACE_FCHDIR = 1] fcntl-h [test $HAVE_FCHDIR = 0 \|\| test $REPLACE_FCHDIR = 1] filename [test $HAVE_FCHDIR = 0 \|\| test $REPLACE_FCHDIR = 1] filenamecat-lgpl [test $HAVE_FCHDIR = 0 \|\| test $REPLACE_FCHDIR = 1] free-posix [test $HAVE_FCHDIR = 0 \|\| test $REPLACE_FCHDIR = 1] fstat [test $HAVE_FCHDIR = 0 \|\| test $REPLACE_FCHDIR = 1] getcwd-lgpl [test $HAVE_FCHDIR = 0 \|\| test $REPLACE_FCHDIR = 1] malloc-posix [test $HAVE_FCHDIR = 0 \|\| test $REPLACE_FCHDIR = 1] open [test $HAVE_FCHDIR = 0 \|\| test $REPLACE_FCHDIR = 1] realloc-posix [test $HAVE_FCHDIR = 0 \|\| test $REPLACE_FCHDIR = 1] stat [test $HAVE_FCHDIR = 0 \|\| test $REPLACE_FCHDIR = 1] bool [test $HAVE_FCHDIR = 0 \|\| test $REPLACE_FCHDIR = 1] strdup-posix [test $HAVE_FCHDIR = 0 \|\| test $REPLACE_FCHDIR = 1] sys_stat-h [test $HAVE_FCHDIR = 0 \|\| test $REPLACE_FCHDIR = 1]
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-h 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] fopen [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-h unistd-h
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-h
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-h msvc-nothrow [test $HAVE_FLOCK = 0]
fopen	#include <stdio.h>	fopen.c	fopen.m4 fclose.m4 fflush.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-h largefile fcntl-h [test $REPLACE_FOPEN = 1] bool [test $REPLACE_FOPEN = 1] unistd-h [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-h nocrash printf-safe errno-h multiarch vfzprintf [test $REPLACE_FPRINTF = 1] mixin/printf-posix [test $REPLACE_FPRINTF = 1] intprops [test $REPLACE_FPRINTF = 1] fseterr [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-h 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-h 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-h sys_types-h 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-h 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-h errno-h 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-h extensions largefile sys_types-h lseek [test $HAVE_FTELLO = 0 \|\| test $REPLACE_FTELLO = 1] stdckdint-h [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-h sys_types-h 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-h 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-h sys_socket-h extensions gettext-h [test $HAVE_GETADDRINFO = 0 \|\| test $REPLACE_GETADDRINFO = 1 \|\| test $HAVE_DECL_GAI_STRERROR = 0 \|\| test $REPLACE_GAI_STRERROR = 1] gnulib-i18n [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] inet_pton [test $HAVE_GETADDRINFO = 0 \|\| test $REPLACE_GETADDRINFO = 1] snprintf [test $HAVE_GETADDRINFO = 0 \|\| test $REPLACE_GETADDRINFO = 1] bool [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 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-h 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] bool [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-h 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-h free-posix [test $HAVE_GETGROUPS = 0 \|\| test $REPLACE_GETGROUPS = 1] malloc-posix [test $HAVE_GETGROUPS = 0 \|\| test $REPLACE_GETGROUPS = 1] stdint-h [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]) gl_MODULE_INDICATOR([gethostname])	unistd-h sys_socket-h [test $HAVE_GETHOSTNAME = 0] errno-h [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 \|\| test $REPLACE_GETLOGIN = 1]) gl_UNISTD_MODULE_INDICATOR([getlogin]) AC_REQUIRE([gl_LIB_GETLOGIN])	unistd-h readutmp [test $HAVE_GETLOGIN = 0 \|\| test $REPLACE_GETLOGIN = 1]
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-h 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 sys_cdefs_h.m4 musl.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]) gl_MUSL_LIBC	unistd-h extensions include_next gen-header gettext-h [test $REPLACE_GETOPT = 1] gnulib-i18n [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]) gl_MODULE_INDICATOR([getpeername])	extensions sys_socket-h socketlib errno-h [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]) gl_MODULE_INDICATOR([getsockname])	extensions sys_socket-h socketlib errno-h [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]) gl_MODULE_INDICATOR([getsockopt])	extensions sys_socket-h socketlib sys_time-h [test "$ac_cv_header_winsock2_h" = yes] errno-h [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-h 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-h
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-h 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-h
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-strcasecmp [test $REPLACE_ICONV_OPEN = 1] stdint-h [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-h extensions sys_socket-h [test $HAVE_INET_NTOP = 0 \|\| test $REPLACE_INET_NTOP = 1] errno-h [test $HAVE_INET_NTOP = 0 \|\| test $REPLACE_INET_NTOP = 1] netinet_in-h [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-h extensions c-ctype [test $HAVE_INET_PTON = 0 \|\| test $REPLACE_INET_PTON = 1] sys_socket-h [test $HAVE_INET_PTON = 0 \|\| test $REPLACE_INET_PTON = 1] errno-h [test $HAVE_INET_PTON = 0 \|\| test $REPLACE_INET_PTON = 1] netinet_in-h [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]) gl_MODULE_INDICATOR([ioctl])	sys_ioctl-h sys_socket-h [test $HAVE_IOCTL = 0 \|\| test $REPLACE_IOCTL = 1] errno-h [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-h
langinfo	#include <langinfo.h>	---	00gnulib.m4 zzgnulib.m4	langinfo-h
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-h 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-h [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-h 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-h [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]) gl_MODULE_INDICATOR([listen])	sys_socket-h socketlib errno-h [test "$ac_cv_header_winsock2_h" = yes] msvc-nothrow [test "$ac_cv_header_winsock2_h" = yes]
locale	#include <locale.h>	---	00gnulib.m4 zzgnulib.m4	locale-h
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-h sys_types-h largefile msvc-nothrow [test $REPLACE_LSEEK = 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]) gl_MODULE_INDICATOR([lstat])	sys_stat-h 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])	stdckdint-h [test $REPLACE_CALLOC_FOR_MALLOC_POSIX = 1] stdlib-h
mbsnrtowcs	#include <wchar.h>	mbsnrtowcs.c mbsnrtowcs-impl.h mbsrtowcs-state.c	mbsnrtowcs.m4 mbstate_t.m4 mbrtowc.m4 locale-en.m4 locale-fr.m4 codeset.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-h 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-h 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-h stdint-h [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-h 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-h 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-h extensions largefile tempname [test $HAVE_MKSTEMP = 0 \|\| test $REPLACE_MKSTEMP = 1]
net_if	#include <net/if.h>	---	00gnulib.m4 zzgnulib.m4	net_if-h
netdb	#include <netdb.h>	---	00gnulib.m4 zzgnulib.m4	netdb-h
netinet_in	#include <netinet/in.h>	---	00gnulib.m4 zzgnulib.m4	netinet_in-h
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-h 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] lstat [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-h errno-h [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-h [test $HAVE_POLL = 0 \|\| test $REPLACE_POLL = 1] sys_socket-h [test $HAVE_POLL = 0 \|\| test $REPLACE_POLL = 1] sys_time-h [test $HAVE_POLL = 0 \|\| test $REPLACE_POLL = 1] errno-h [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-h 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 stdckdint-h [test $REPLACE_POSIX_MEMALIGN = 1] stdlib-h
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-h
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-h 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-h
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-h
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-h
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-h
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-h
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-h
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-h
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-h
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-h
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-h
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-h
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-h
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-h
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-h
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-h 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-h 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-h 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-h
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-h
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-h alloca-opt dup2 errno-h open sh-filename strchrnul unistd-h 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] bool [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-h 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-h 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-h 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-h 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-h 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-h 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-h stat [test $HAVE_READLINK = 0 \|\| test $REPLACE_READLINK = 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]) gl_MODULE_INDICATOR([recv])	sys_socket-h socketlib errno-h [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]) gl_MODULE_INDICATOR([recvfrom])	extensions sys_socket-h socketlib errno-h [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-h 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-h extensions extensions-aix largefile opendir readdir
sched	#include <sched.h>	---	00gnulib.m4 zzgnulib.m4	sched-h
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]) gl_MODULE_INDICATOR([select])	sys_select-h alloca [test $REPLACE_SELECT = 1] dup2 [test $REPLACE_SELECT = 1] sockets [test $REPLACE_SELECT = 1] sys_time-h [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]) gl_MODULE_INDICATOR([send])	sys_socket-h socketlib errno-h [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]) gl_MODULE_INDICATOR([sendto])	sys_socket-h socketlib errno-h [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-h netdb-h
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]) gl_MODULE_INDICATOR([setsockopt])	sys_socket-h socketlib sys_time-h [test "$ac_cv_header_winsock2_h" = yes] errno-h [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]) gl_MODULE_INDICATOR([shutdown])	sys_socket-h socketlib errno-h [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-h assert-h [test $HAVE_SLEEP = 0 \|\| test $REPLACE_SLEEP = 1] stdint-h [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] mixin/printf-posix [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]) gl_MODULE_INDICATOR([socket])	sys_socket-h socketlib errno-h [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>	---	00gnulib.m4 zzgnulib.m4	spawn-h
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-h nocrash printf-safe multiarch vszprintf [test $REPLACE_SPRINTF = 1] mixin/printf-posix [test $REPLACE_SPRINTF = 1] stdint-h [test $REPLACE_SPRINTF = 1] errno-h [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* \| windows*) AC_LIBOBJ([stat-w32]) ;; esac gl_PREREQ_STAT ]) gl_SYS_STAT_MODULE_INDICATOR([stat]) gl_MODULE_INDICATOR([stat])	sys_stat-h 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] bool [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-h malloc-posix [test $REPLACE_STRDUP = 1]
string	#include <string.h>	---	00gnulib.m4 zzgnulib.m4	string-h
strings	#include <strings.h>	---	00gnulib.m4 zzgnulib.m4	strings-h
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 bool stdint-h sys_stat-h 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-h
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] bool [test $HAVE_NANOSLEEP = 0 \|\| test $REPLACE_NANOSLEEP = 1] sys_select-h [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	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] gnulib-i18n [test $ac_use_included_regex = yes] intprops [test $ac_use_included_regex = yes] iswctype [test $ac_use_included_regex = yes] langinfo-h [test $ac_use_included_regex = yes] libc-config [test $ac_use_included_regex = yes] limits-h [test $ac_use_included_regex = yes] lock [test $ac_use_included_regex = yes] malloc-gnu [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] bool [test $ac_use_included_regex = yes] stdckdint-h [test $ac_use_included_regex = yes] stdint-h [test $ac_use_included_regex = yes] verify [test $ac_use_included_regex = yes] wchar-h [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-h 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] bool [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-h filename [test $REPLACE_RMDIR = 1] sys_stat-h [test $REPLACE_RMDIR = 1]
search	#include <search.h>	---	00gnulib.m4 zzgnulib.m4	search-h
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-h [test $HAVE_POSIX_SIGNALBLOCKING = 0] lock [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-h [test $HAVE_STRPTIME = 0] string-h [test $HAVE_STRPTIME = 0] strncasecmp [test $HAVE_STRPTIME = 0] bool [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-h strpbrk [test $HAVE_STRTOK_R = 0 \|\| test $REPLACE_STRTOK_R = 1]
sys_select	#include <sys/select.h>	---	00gnulib.m4 zzgnulib.m4	sys_select-h
sys_socket	#include <sys/socket.h>	---	00gnulib.m4 zzgnulib.m4	sys_socket-h
sys_stat	#include <sys/stat.h>	---	00gnulib.m4 zzgnulib.m4	sys_stat-h
sys_time	#include <sys/time.h>	---	00gnulib.m4 zzgnulib.m4	sys_time-h
sys_times	#include <sys/times.h>	---	00gnulib.m4 zzgnulib.m4	sys_times-h
sys_uio	#include <sys/uio.h>	---	00gnulib.m4 zzgnulib.m4	sys_uio-h
sys_utsname	#include <sys/utsname.h>	---	00gnulib.m4 zzgnulib.m4	sys_utsname-h
sys_wait	#include <sys/wait.h>	---	00gnulib.m4 zzgnulib.m4	sys_wait-h
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-h sys_types-h largefile sys_stat-h 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-h
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-h 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-h gethostname [test $HAVE_UNAME = 0]
unistd	#include <unistd.h>	---	00gnulib.m4 zzgnulib.m4	unistd-h
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-h 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-h 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] bool [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-h extensions at-internal [test $HAVE_UTIMENSAT = 0 \|\| test $REPLACE_UTIMENSAT = 1] errno-h [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 mixin/printf-posix nocrash printf-safe multiarch
vasprintf-posix	#include <stdio.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] mixin/printf-posix [test $HAVE_VASPRINTF = 0 \|\| test $REPLACE_VASPRINTF = 1] 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-h vdzprintf [test $ac_cv_func_vdprintf = no \|\| test $REPLACE_VDPRINTF = 1] intprops [test $ac_cv_func_vdprintf = no \|\| test $REPLACE_VDPRINTF = 1] errno-h [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] mixin/printf-posix [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-h nocrash printf-safe multiarch vfzprintf [test $REPLACE_VFPRINTF = 1] mixin/printf-posix [test $REPLACE_VFPRINTF = 1] intprops [test $REPLACE_VFPRINTF = 1] fseterr [test $REPLACE_VFPRINTF = 1] errno-h [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-h 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] mixin/printf-posix [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-h nocrash printf-safe multiarch vszprintf [test $REPLACE_VSPRINTF = 1] mixin/printf-posix [test $REPLACE_VSPRINTF = 1] stdint-h [test $REPLACE_VSPRINTF = 1] errno-h [test $REPLACE_VSPRINTF = 1]
wcsnrtombs	#include <wchar.h>	wcsnrtombs.c wcsnrtombs-impl.h wcsrtombs-state.c	wcsnrtombs.m4 mbrtowc.m4 mbstate_t.m4 locale-en.m4 locale-fr.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-h extensions wcrtomb [test $HAVE_WCSNRTOMBS = 0 \|\| test $REPLACE_WCSNRTOMBS = 1]
wcwidth	#include <wchar.h>	wcwidth.c	wcwidth.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-h 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-path.h" #include "windows-spawn.h"	windows-path.h windows-path.c windows-spawn.h windows-spawn.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_CANONICAL_HOST]) gl_CONDITIONAL([GL_COND_OBJ_WINDOWS_PATH], [case "$host_os" in cygwin* \| mingw* \| windows) true;; ) false;; esac]) gl_CONDITIONAL([GL_COND_OBJ_WINDOWS_SPAWN], [case "$host_os" in mingw* \| windows) true;; ) false;; esac])	environ findprog-in msvc-nothrow bool stdint-h stdlib-h strpbrk unistd-h 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* \| windows*) gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_OVERRIDES_STRUCT_STAT], [1]) ;; esac	sys_stat-h
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-h raise [test $REPLACE_WRITE = 1] msvc-inval [test $REPLACE_WRITE = 1] msvc-nothrow [test $REPLACE_WRITE = 1]

Compatibility checks for POSIX 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-h
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 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-h 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] bool [test $gl_cv_have_unlimited_file_name_length = no] stdlib-h [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 bool
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-h 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 bool
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 gl_MODULE_INDICATOR([unistd-safer])	fcntl unistd-h 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] 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] libc-config [test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1] bool [test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1] stdckdint-h [test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1] strnlen [test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1] uchar-h [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] mbsinit [test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1] btowc [{ test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1; } && test $SMALL_WCHAR_T = 0] iswctype [{ test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1; } && test $SMALL_WCHAR_T = 0] mbsrtowcs [{ test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1; } && test $SMALL_WCHAR_T = 0] wchar-h [{ test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1; } && test $SMALL_WCHAR_T = 0] wctype-h [{ test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1; } && test $SMALL_WCHAR_T = 0] wctype [{ test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1; } && test $SMALL_WCHAR_T = 0] wmemchr [{ test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1; } && test $SMALL_WCHAR_T = 0] wmempcpy [{ test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1; } && test $SMALL_WCHAR_T = 0] btoc32 [{ test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1; } && test $SMALL_WCHAR_T = 1] c32tolower [{ test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1; } && test $SMALL_WCHAR_T = 1] c32_get_type_test [{ test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1; } && test $SMALL_WCHAR_T = 1] c32_apply_type_test [{ test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1; } && test $SMALL_WCHAR_T = 1] mbsrtoc32s [{ test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1; } && test $SMALL_WCHAR_T = 1] unistr/u32-chr [{ test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1; } && test $SMALL_WCHAR_T = 1] unistr/u32-pcpy [{ test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1; } && test $SMALL_WCHAR_T = 1] unistr/u32-strcat [{ test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1; } && test $SMALL_WCHAR_T = 1] unistr/u32-strlen [{ test $HAVE_FNMATCH = 0 \|\| test $REPLACE_FNMATCH = 1; } && test $SMALL_WCHAR_T = 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] bool [test $HAVE_GLOB = 0 \|\| test $REPLACE_GLOB = 1] stdckdint-h [test $HAVE_GLOB = 0 \|\| test $REPLACE_GLOB = 1] stdint-h [test $HAVE_GLOB = 0 \|\| test $REPLACE_GLOB = 1] strdup [test $HAVE_GLOB = 0 \|\| test $REPLACE_GLOB = 1] unistd-h [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 c32tolower filename fnmatch fopen-gnu hash hashcode-string1 mbscasecmp mbuiter [test "$GNULIB_MCEL_PREFER" != yes] nullptr regex bool unlocked-io-internal xalloc

Extra functions based on POSIX

Input/output

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
xprintf-posix	#include "xprintf.h"	---	00gnulib.m4 zzgnulib.m4	xprintf vzprintf-posix vfzprintf-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 bool stdint-h

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 gnulib-i18n 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 minmax stat bool sys_stat-h stdint-h
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 limits-h readlink ssize_t stdint-h unistd-h
areadlinkat	#include "areadlink.h"	areadlinkat.c at-func.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([areadlinkat])	areadlink careadlinkat readlinkat at-internal errno-h 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-h readlinkat at-internal errno-h extensions fchdir fcntl-h filename free-posix limits-h openat-die openat-h save-cwd unistd-h
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 renameatu bool stdckdint-h stdint-h 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 bool stdckdint-h stdint-h 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-h extensions fcntl-h file-set filename getcwd hashcode-named-file idx intprops memmove mempcpy nocrash rawmemchr readlink glibc-internal/scratch_buffer stat bool stdlib-h sys_stat-h unistd-h 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-h 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-h [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] bool [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1] sys_stat-h [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1] unistd-h [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 bool clean-temp-simple list asyncsafe-spin unistd-h lock thread-optim error fatal-signal open pathmax tmpdir mkdtemp rmdir xalloc xalloc-die xmalloca hashkey-string linkedhash-list linked-list xlist gettext-h gnulib-i18n
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 bool list asyncsafe-spin unistd-h lock once thread-optim error fatal-signal rmdir linkedhash-list hashkey-string gettext-h gnulib-i18n
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 gnulib-i18n ignore-value open qcopy-acl quote safe-read stat-time stdlib-h unistd-h 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 bool stdint-h
dirfd	#include <dirent.h>	dirfd.c dirent-private.h	dirfd.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_DIRFD gl_CONDITIONAL([GL_COND_OBJ_DIRFD], [test $HAVE_DIRFD = 0 \|\| test $REPLACE_DIRFD = 1]) AM_COND_IF([GL_COND_OBJ_DIRFD], [ gl_PREREQ_DIRFD ]) gl_DIRENT_MODULE_INDICATOR([dirfd])	dirent-h extensions errno-h [test $HAVE_DIRFD = 0 \|\| 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-h extensions root-uid fcntl-h access [test $HAVE_EUIDACCESS = 0] group-member [test $HAVE_EUIDACCESS = 0] stat [test $HAVE_EUIDACCESS = 0] sys_stat-h [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-h extensions at-internal [test $HAVE_FACCESSAT = 0 \|\| test $REPLACE_FACCESSAT = 1] errno-h [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 dirent-private.h	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-h extensions at-internal [test $HAVE_FDOPENDIR = 0] dirfd [test $HAVE_FDOPENDIR = 0] dup [test $HAVE_FDOPENDIR = 0] errno-h [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	c-file-type gettext-h gnulib-i18n sys_stat-h
fileblocks	---	fileblocks.c	fileblocks.m4 00gnulib.m4 zzgnulib.m4 gl_FILEBLOCKS gl_CONDITIONAL([GL_COND_OBJ_FILEBLOCKS], [test $ac_cv_member_struct_stat_st_blocks = no]) AM_COND_IF([GL_COND_OBJ_FILEBLOCKS], [ gl_PREREQ_FILEBLOCKS ])	---
filemode	#include "filemode.h"	filemode.c	filemode.m4 00gnulib.m4 zzgnulib.m4 gl_FILEMODE	sys_stat-h
filename	#include "filename.h"	---	00gnulib.m4 zzgnulib.m4	---
filenamecat	#include "filenamecat.h"	filenamecat.c	filenamecat.m4 00gnulib.m4 zzgnulib.m4 gl_FILE_NAME_CONCAT gl_MODULE_INDICATOR([filenamecat])	filenamecat-lgpl xalloc
filenamecat-lgpl	#include "filenamecat.h"	filenamecat-lgpl.c	filenamecat.m4 00gnulib.m4 zzgnulib.m4 gl_FILE_NAME_CONCAT_LGPL	c99 basename-lgpl filename malloc-posix
fts	#include "fts_.h"	fts.in.h fts.c fts-cycle.c	fts.m4 sys_cdefs_h.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FTS dnl Use this version of fts unconditionally, since the GNU libc and dnl NetBSD versions have bugs and/or unnecessary limitations. gl_CONDITIONAL([GL_COND_OBJ_FTS], [true])	gen-header alignasof attribute c99 calloc-posix close closedir cycle-check d-ino d-type dirfd fchdir fcntl fcntl-h fcntl-safer flexmember free-posix fstat fstatat hash i-ring malloc-posix memmove openat openat-h opendirat readdir realloc-posix bool stddef-h stdint-h
isdir	---	isdir.c isdir.h	00gnulib.m4 zzgnulib.m4	stat
largefile	---	---	largefile.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_LARGEFILE])	---
lchmod	#include <sys/stat.h>	lchmod.c	lchmod.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_LCHMOD gl_CONDITIONAL([GL_COND_OBJ_LCHMOD], [test $HAVE_LCHMOD = 0]) AM_COND_IF([GL_COND_OBJ_LCHMOD], [ gl_PREREQ_LCHMOD ]) gl_SYS_STAT_MODULE_INDICATOR([lchmod])	c99 [test $HAVE_LCHMOD = 0] errno-h [test $HAVE_LCHMOD = 0] extensions fcntl-h [test $HAVE_LCHMOD = 0] intprops [test $HAVE_LCHMOD = 0] lstat [test $HAVE_LCHMOD = 0] readlink [test $HAVE_LCHMOD = 0] sys_stat-h unistd-h [test $HAVE_LCHMOD = 0]
lchown	#include <unistd.h>	lchown.c	lchown.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_LCHOWN gl_CONDITIONAL([GL_COND_OBJ_LCHOWN], [test $HAVE_LCHOWN = 0 \|\| test $REPLACE_LCHOWN = 1]) gl_UNISTD_MODULE_INDICATOR([lchown])	unistd-h readlink [test $HAVE_LCHOWN = 0] chown [test $HAVE_LCHOWN = 0 \|\| test $REPLACE_LCHOWN = 1] errno-h [test $HAVE_LCHOWN = 0 \|\| test $REPLACE_LCHOWN = 1] bool [test $HAVE_LCHOWN = 0 \|\| test $REPLACE_LCHOWN = 1] sys_stat-h [test $HAVE_LCHOWN = 0 \|\| test $REPLACE_LCHOWN = 1] lstat [test $REPLACE_LCHOWN = 1]
mkancesdirs	#include "mkancesdirs.h"	mkancesdirs.c	mkancesdirs.m4 00gnulib.m4 zzgnulib.m4 gl_MKANCESDIRS	fcntl-h filename savewd stat-macros sys_stat-h
mkfifoat	#include <fcntl.h> #include <sys/stat.h>	mkfifoat.c mknodat.c at-func.c	mkfifoat.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_MKFIFOAT gl_CONDITIONAL([GL_COND_OBJ_MKFIFOAT], [test $HAVE_MKFIFOAT = 0 \|\| test $REPLACE_MKFIFOAT = 1]) gl_CONDITIONAL([GL_COND_OBJ_MKNODAT], [test $HAVE_MKNODAT = 0 \|\| test $REPLACE_MKNODAT = 1]) gl_SYS_STAT_MODULE_INDICATOR([mkfifoat]) gl_SYS_STAT_MODULE_INDICATOR([mknodat])	sys_stat-h extensions fcntl-h [test $HAVE_MKFIFOAT = 0 \|\| test $REPLACE_MKFIFOAT = 1 \|\| test $HAVE_MKNODAT = 0 \|\| test $REPLACE_MKNODAT = 1] fstatat [test $REPLACE_MKFIFOAT = 1 \|\| test $REPLACE_MKNODAT = 1] at-internal [test $HAVE_MKFIFOAT = 0 \|\| test $HAVE_MKNODAT = 0] errno-h [test $HAVE_MKFIFOAT = 0 \|\| test $HAVE_MKNODAT = 0] fchdir [test $HAVE_MKFIFOAT = 0 \|\| test $HAVE_MKNODAT = 0] filename [test $HAVE_MKFIFOAT = 0 \|\| test $HAVE_MKNODAT = 0] openat-die [test $HAVE_MKFIFOAT = 0 \|\| test $HAVE_MKNODAT = 0] openat-h [test $HAVE_MKFIFOAT = 0 \|\| test $HAVE_MKNODAT = 0] save-cwd [test $HAVE_MKFIFOAT = 0 \|\| test $HAVE_MKNODAT = 0] mkfifo [test $HAVE_MKFIFOAT = 0] mknod [test $HAVE_MKNODAT = 0]
mkdir-p	#include "mkdir-p.h"	dirchownmod.c dirchownmod.h mkdir-p.c	mkdir-p.m4 00gnulib.m4 zzgnulib.m4 gl_MKDIR_PARENTS	error fcntl-h fstat gettext-h gnulib-i18n lchmod lchown mkancesdirs mkdir quote savewd stat stat-macros bool sys_stat-h
mkostemp	#include <stdlib.h>	mkostemp.c	mkostemp.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_MKOSTEMP gl_CONDITIONAL([GL_COND_OBJ_MKOSTEMP], [test $HAVE_MKOSTEMP = 0 \|\| test $REPLACE_MKOSTEMP = 1]) AM_COND_IF([GL_COND_OBJ_MKOSTEMP], [ gl_PREREQ_MKOSTEMP ]) gl_MODULE_INDICATOR([mkostemp]) gl_STDLIB_MODULE_INDICATOR([mkostemp])	stdlib-h extensions largefile tempname [test $HAVE_MKOSTEMP = 0 \|\| test $REPLACE_MKOSTEMP = 1]
mkostemps	#include <stdlib.h>	mkostemps.c	mkostemps.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_MKOSTEMPS gl_CONDITIONAL([GL_COND_OBJ_MKOSTEMPS], [test $HAVE_MKOSTEMPS = 0 \|\| test $REPLACE_MKOSTEMPS = 1]) gl_MODULE_INDICATOR([mkostemps]) gl_STDLIB_MODULE_INDICATOR([mkostemps])	stdlib-h extensions largefile tempname [test $HAVE_MKOSTEMPS = 0 \|\| test $REPLACE_MKOSTEMPS = 1]
mkstemps	#include <stdlib.h>	mkstemps.c	mkstemps.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_MKSTEMPS gl_CONDITIONAL([GL_COND_OBJ_MKSTEMPS], [test $HAVE_MKSTEMPS = 0]) gl_MODULE_INDICATOR([mkstemps]) gl_STDLIB_MODULE_INDICATOR([mkstemps])	stdlib-h extensions largefile tempname [test $HAVE_MKSTEMPS = 0]
modechange	#include "modechange.h"	modechange.c	modechange.m4 00gnulib.m4 zzgnulib.m4 gl_MODECHANGE	stat stat-macros bool sys_stat-h xalloc
mountlist	#include "mountlist.h"	mountlist.c	fstypename.m4 mountlist.m4 00gnulib.m4 zzgnulib.m4 gl_MOUNTLIST gl_PREREQ_MOUNTLIST_EXTRA	c-ctype fopen-gnu free-posix getline open unlocked-io-internal bool stdint-h strstr-simple xalloc
openat	#include <fcntl.h>	openat.c	openat.m4 open-cloexec.m4 lstat.m4 mode_t.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_OPENAT gl_CONDITIONAL([GL_COND_OBJ_OPENAT], [test $HAVE_OPENAT = 0 \|\| test $REPLACE_OPENAT = 1]) AM_COND_IF([GL_COND_OBJ_OPENAT], [ gl_PREREQ_OPENAT ]) gl_MODULE_INDICATOR([openat]) dnl for lib/getcwd.c gl_FCNTL_MODULE_INDICATOR([openat])	fcntl-h extensions largefile openat-h [test $HAVE_OPENAT = 0 \|\| test $REPLACE_OPENAT = 1] bool [test $HAVE_OPENAT = 0 \|\| test $REPLACE_OPENAT = 1] sys_stat-h [test $HAVE_OPENAT = 0 \|\| test $REPLACE_OPENAT = 1] cloexec [test $REPLACE_OPENAT = 1] fstat [test $REPLACE_OPENAT = 1] fstatat [test $REPLACE_OPENAT = 1] at-internal [test $HAVE_OPENAT = 0] errno-h [test $HAVE_OPENAT = 0] fchdir [test $HAVE_OPENAT = 0] filename [test $HAVE_OPENAT = 0] open [test $HAVE_OPENAT = 0] openat-die [test $HAVE_OPENAT = 0] save-cwd [test $HAVE_OPENAT = 0]
openat-die	#include "openat.h"	openat-die.c	00gnulib.m4 zzgnulib.m4	openat-h error exitfail gettext-h gnulib-i18n snippet/_Noreturn
pathmax	#include "pathmax.h"	---	pathmax.m4 00gnulib.m4 zzgnulib.m4 gl_PATHMAX	unistd-h
qacl	---	---	00gnulib.m4 zzgnulib.m4	qcopy-acl qset-acl
qcopy-acl	#include "acl.h"	qcopy-acl.c	acl.m4 xattr.m4 00gnulib.m4 zzgnulib.m4 gl_QCOPY_ACL	acl-permissions dirent-h [test "$use_xattr" = yes] file-has-acl [test "$use_xattr" = yes]
qset-acl	#include "acl.h"	qset-acl.c	00gnulib.m4 zzgnulib.m4	acl-permissions
read-file	#include "read-file.h"	read-file.c	read-file.m4 00gnulib.m4 zzgnulib.m4 gl_PREREQ_READ_FILE	fopen-gnu free-posix fstat ftello malloc-posix memset_explicit realloc-posix stdint-h sys_stat-h
readlinkat	#include <fcntl.h> #include <unistd.h>	readlinkat.c at-func.c	readlinkat.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_READLINKAT gl_CONDITIONAL([GL_COND_OBJ_READLINKAT], [test $HAVE_READLINKAT = 0 \|\| test $REPLACE_READLINKAT = 1]) gl_UNISTD_MODULE_INDICATOR([readlinkat])	unistd-h extensions at-internal [test $HAVE_READLINKAT = 0 \|\| test $REPLACE_READLINKAT = 1] errno-h [test $HAVE_READLINKAT = 0 \|\| test $REPLACE_READLINKAT = 1] fchdir [test $HAVE_READLINKAT = 0 \|\| test $REPLACE_READLINKAT = 1] fcntl-h [test $HAVE_READLINKAT = 0 \|\| test $REPLACE_READLINKAT = 1] filename [test $HAVE_READLINKAT = 0 \|\| test $REPLACE_READLINKAT = 1] fstatat [test $HAVE_READLINKAT = 1 && test $REPLACE_READLINKAT = 1] openat-die [test $HAVE_READLINKAT = 0 \|\| test $REPLACE_READLINKAT = 1] openat-h [test $HAVE_READLINKAT = 0 \|\| test $REPLACE_READLINKAT = 1] save-cwd [test $HAVE_READLINKAT = 0 \|\| test $REPLACE_READLINKAT = 1] readlink [test $HAVE_READLINKAT = 0 \|\| test $REPLACE_READLINKAT = 1]
renameatu	#include "renameatu.h"	at-func2.c renameatu.c	renameat.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_RENAMEAT if test $HAVE_RENAMEAT = 0; then AC_LIBOBJ([at-func2]) fi	stdio-h extensions fcntl-h filenamecat-lgpl [test $HAVE_RENAMEAT = 0 \|\| test $REPLACE_RENAMEAT = 1] openat-h [test $HAVE_RENAMEAT = 0 \|\| test $REPLACE_RENAMEAT = 1] fstatat [test $REPLACE_RENAMEAT = 1] readlinkat [test $REPLACE_RENAMEAT = 1] bool [test $REPLACE_RENAMEAT = 1] at-internal [test $HAVE_RENAMEAT = 0] filename [test $HAVE_RENAMEAT = 0] fstat [test $HAVE_RENAMEAT = 0] getcwd-lgpl [test $HAVE_RENAMEAT = 0] openat-die [test $HAVE_RENAMEAT = 0] rename [test $HAVE_RENAMEAT = 0] same-inode [test $HAVE_RENAMEAT = 0] save-cwd [test $HAVE_RENAMEAT = 0] stat [test $HAVE_RENAMEAT = 0]
same	#include "same.h"	same.c	same.m4 00gnulib.m4 zzgnulib.m4 gl_SAME	c99 error dirname fstat fstatat openat same-inode bool memcmp
save-cwd	#include "save-cwd.h"	save-cwd.c	save-cwd.m4 00gnulib.m4 zzgnulib.m4 gl_SAVE_CWD	chdir-long fchdir getcwd-lgpl open bool
savedir	#include "savedir.h"	savedir.c	savedir.m4 00gnulib.m4 zzgnulib.m4 gl_SAVEDIR	attribute closedir dirent-h fdopendir free-posix opendir qsort_r readdir stpcpy xalloc
savewd	#include "savewd.h"	savewd.c	savewd.m4 00gnulib.m4 zzgnulib.m4 gl_SAVEWD	assure attribute chdir errno-h extern-inline fchdir fcntl-h filename raise bool stdlib-h sys_wait-h unistd-h xalloc
stat-macros	#include "stat-macros.h"	---	00gnulib.m4 zzgnulib.m4	---
stat-time	#include "stat-time.h"	stat-time.c	stat-time.m4 00gnulib.m4 zzgnulib.m4 gl_STAT_TIME gl_STAT_BIRTHTIME	time-h errno-h extensions extern-inline stdckdint-h
symlink	#include <unistd.h>	symlink.c	symlink.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_SYMLINK gl_CONDITIONAL([GL_COND_OBJ_SYMLINK], [test $HAVE_SYMLINK = 0 \|\| test $REPLACE_SYMLINK = 1]) gl_UNISTD_MODULE_INDICATOR([symlink])	unistd-h lstat [test $HAVE_SYMLINK = 0 \|\| test $REPLACE_SYMLINK = 1]
symlinkat	#include <fcntl.h> #include <unistd.h>	symlinkat.c at-func.c	symlinkat.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_SYMLINKAT gl_CONDITIONAL([GL_COND_OBJ_SYMLINKAT], [test $HAVE_SYMLINKAT = 0 \|\| test $REPLACE_SYMLINKAT = 1]) gl_UNISTD_MODULE_INDICATOR([symlinkat])	unistd-h extensions fcntl-h [test $HAVE_SYMLINKAT = 0 \|\| test $REPLACE_SYMLINKAT = 1] at-internal [test $HAVE_SYMLINKAT = 0] errno-h [test $HAVE_SYMLINKAT = 0] fchdir [test $HAVE_SYMLINKAT = 0] filename [test $HAVE_SYMLINKAT = 0] openat-die [test $HAVE_SYMLINKAT = 0] openat-h [test $HAVE_SYMLINKAT = 0] save-cwd [test $HAVE_SYMLINKAT = 0] symlink [test $HAVE_SYMLINKAT = 0] fstatat [test $REPLACE_SYMLINKAT = 1]
sys_file	#include <sys/file.h>	---	00gnulib.m4 zzgnulib.m4	sys_file-h
sys_ioctl	#include <sys/ioctl.h>	---	00gnulib.m4 zzgnulib.m4	sys_ioctl-h
tmpdir	#include "tmpdir.h"	tmpdir.c	tmpdir.m4 00gnulib.m4 zzgnulib.m4 gt_TMPDIR	secure_getenv stat bool sys_stat-h pathmax
unlinkdir	#include "unlinkdir.h"	unlinkdir.c	unlinkdir.m4 00gnulib.m4 zzgnulib.m4 gl_UNLINKDIR	bool priv-set root-uid
utimecmp	#include "utimecmp.h"	utimecmp.c	utimecmp.m4 00gnulib.m4 zzgnulib.m4 gl_UTIMECMP	dirname-lgpl fstatat hash stat-time time-h utimensat intprops bool stdint-h assert-h
utimens	#include "utimens.h"	utimens.c	utimens.m4 utimes.m4 00gnulib.m4 zzgnulib.m4 gl_UTIMENS	errno-h extern-inline fcntl-h fstat lstat gettime msvc-nothrow stat stat-time bool sys_stat-h sys_time-h time-h utime utime-h
write-any-file	#include "write-any-file.h"	write-any-file.c	write-any-file.m4 00gnulib.m4 zzgnulib.m4 gl_WRITE_ANY_FILE	bool priv-set root-uid
xconcat-filename	#include "concat-filename.h"	xconcat-filename.c	00gnulib.m4 zzgnulib.m4	concat-filename xalloc-die
xgetcwd	#include "xgetcwd.h"	xgetcwd.c	xgetcwd.m4 00gnulib.m4 zzgnulib.m4 gl_XGETCWD	getcwd xalloc
xreadlink	#include "xreadlink.h"	xreadlink.c	00gnulib.m4 zzgnulib.m4	areadlink xalloc
xreadlinkat	#include "xreadlink.h"	xreadlinkat.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([xreadlinkat])	areadlinkat xalloc

File system as inode set

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
cycle-check	#include "cycle-check.h"	cycle-check.c	cycle-check.m4 00gnulib.m4 zzgnulib.m4 gl_CYCLE_CHECK	assure dev-ino same-inode bool stdint-h
dev-ino	#include "dev-ino.h"	---	00gnulib.m4 zzgnulib.m4	---
file-set	#include "file-set.h"	file-set.c	00gnulib.m4 zzgnulib.m4	hash hashcode-named-file bool xalloc xalloc-die
hashcode-file-inode	#include "hashcode-file.h"	hashcode-file-inode.c	00gnulib.m4 zzgnulib.m4	hashcode-named-file same same-inode
i-ring	#include "i-ring.h"	i-ring.c	i-ring.m4 00gnulib.m4 zzgnulib.m4 gl_I_RING	assert-h bool
same-inode	#include "same-inode.h"	same-inode.c	00gnulib.m4 zzgnulib.m4	extern-inline bool sys_stat-h

File descriptor based Input/Output

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
binary-io	#include "binary-io.h"	binary-io.c	00gnulib.m4 zzgnulib.m4	extern-inline fcntl-h
copy-file-range	#include <unistd.h>	copy-file-range.c	copy-file-range.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_COPY_FILE_RANGE gl_CONDITIONAL([GL_COND_OBJ_COPY_FILE_RANGE], [test $HAVE_COPY_FILE_RANGE = 0 \|\| test $REPLACE_COPY_FILE_RANGE = 1]) gl_UNISTD_MODULE_INDICATOR([copy-file-range])	largefile unistd-h
dup3	#include <unistd.h>	dup3.c	dup3.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_DUP3 gl_UNISTD_MODULE_INDICATOR([dup3])	unistd-h fcntl binary-io getdtablesize extensions
fcntl-safer	#include "fcntl-safer.h"	fcntl--.h creat-safer.c open-safer.c	fcntl-safer.m4 mode_t.m4 00gnulib.m4 zzgnulib.m4 gl_FCNTL_SAFER gl_MODULE_INDICATOR([fcntl-safer])	fcntl-h open unistd-safer
fd-safer-flag	#include "unistd-safer.h"	fd-safer-flag.c dup-safer-flag.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([fd-safer-flag])	cloexec fcntl unistd-safer
full-read	#include "full-read.h"	full-read.c full-write.c	00gnulib.m4 zzgnulib.m4	idx safe-read
full-write	#include "full-write.h"	full-write.c	00gnulib.m4 zzgnulib.m4	idx safe-write
getdtablesize	#include <unistd.h>	getdtablesize.c	getdtablesize.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_GETDTABLESIZE gl_CONDITIONAL([GL_COND_OBJ_GETDTABLESIZE], [test $HAVE_GETDTABLESIZE = 0 \|\| test $REPLACE_GETDTABLESIZE = 1]) AM_COND_IF([GL_COND_OBJ_GETDTABLESIZE], [ gl_PREREQ_GETDTABLESIZE ]) gl_UNISTD_MODULE_INDICATOR([getdtablesize])	unistd-h extensions msvc-inval [test $HAVE_GETDTABLESIZE = 0]
isapipe	#include "isapipe.h"	isapipe.c	isapipe.m4 00gnulib.m4 zzgnulib.m4 gl_ISAPIPE gl_CONDITIONAL([GL_COND_OBJ_ISAPIPE], [test $HAVE_ISAPIPE = 0]) AM_COND_IF([GL_COND_OBJ_ISAPIPE], [ gl_PREREQ_ISAPIPE ])	bool [test $HAVE_ISAPIPE = 0] sys_stat-h [test $HAVE_ISAPIPE = 0] unistd-h [test $HAVE_ISAPIPE = 0] msvc-nothrow [test $HAVE_ISAPIPE = 0] fstat [test $HAVE_ISAPIPE = 0]
openat-safer	#include "fcntl-safer.h"	fcntl--.h openat-safer.c	fcntl-safer.m4 00gnulib.m4 zzgnulib.m4 gl_OPENAT_SAFER gl_MODULE_INDICATOR([openat-safer])	fcntl-safer openat unistd-safer
pipe-posix	#include <unistd.h>	pipe.c	pipe.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_PIPE gl_CONDITIONAL([GL_COND_OBJ_PIPE], [test $HAVE_PIPE = 0]) gl_UNISTD_MODULE_INDICATOR([pipe])	unistd-h
pipe2	#include <unistd.h>	pipe2.c	pipe2.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_PIPE2 gl_UNISTD_MODULE_INDICATOR([pipe2])	unistd-h fcntl-h binary-io extensions assert-h
pipe2-safer	#include "unistd-safer.h"	pipe2-safer.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([pipe2-safer])	fd-safer-flag pipe2 unistd-safer
safe-read	#include "safe-read.h"	safe-read.c sys-limits.h	safe-read.m4 00gnulib.m4 zzgnulib.m4 gl_PREREQ_SAFE_READ	idx read ssize_t
safe-write	#include "safe-write.h"	safe-write.c safe-read.c sys-limits.h	safe-write.m4 safe-read.m4 00gnulib.m4 zzgnulib.m4 gl_PREREQ_SAFE_WRITE	idx ssize_t write

File stream based Input/Output

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
close-stream	#include "close-stream.h"	close-stream.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([close-stream])	fpending bool
closein	#include "closein.h"	closein.c	00gnulib.m4 zzgnulib.m4	closeout freadahead fflush gettext-h gnulib-i18n bool unistd-h
closeout	#include "closeout.h"	closeout.c	00gnulib.m4 zzgnulib.m4	close-stream gettext-h gnulib-i18n error quotearg exitfail bool unistd-h
fbufmode	#include "fbufmode.h"	fbufmode.c stdio-impl.h	fbufmode.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FBUFMODE	---
fopen-gnu	#include <stdio.h>	fopen.c	00gnulib.m4 zzgnulib.m4 gl_FUNC_FOPEN_GNU if test $REPLACE_FOPEN_FOR_FOPEN_GNU = 1; then AC_LIBOBJ([fopen]) gl_PREREQ_FOPEN fi gl_MODULE_INDICATOR([fopen-gnu]) gl_STDIO_MODULE_INDICATOR([fopen-gnu])	fopen open [test $REPLACE_FOPEN_FOR_FOPEN_GNU = 1] fcntl-h [test $REPLACE_FOPEN_FOR_FOPEN_GNU = 1] bool [test $REPLACE_FOPEN_FOR_FOPEN_GNU = 1] unistd-h [test $REPLACE_FOPEN_FOR_FOPEN_GNU = 1] close [test $REPLACE_FOPEN_FOR_FOPEN_GNU = 1] fstat [test $REPLACE_FOPEN_FOR_FOPEN_GNU = 1]
fopen-safer	#include "stdio-safer.h"	stdio--.h fopen-safer.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([fopen-safer])	fopen unistd-safer
fpending	#include "fpending.h"	fpending.c stdio-impl.h	fpending.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FPENDING gl_CONDITIONAL([GL_COND_OBJ_FPENDING], [test $gl_cv_func___fpending = no])	---
fpurge	#include <stdio.h>	fpurge.c stdio-impl.h	fpurge.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FPURGE gl_CONDITIONAL([GL_COND_OBJ_FPURGE], [test $HAVE_FPURGE = 0 \|\| test $REPLACE_FPURGE = 1]) gl_STDIO_MODULE_INDICATOR([fpurge])	stdio-h
freadable	#include "freadable.h"	freadable.c stdio-impl.h	freadable.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FREADABLE gl_CONDITIONAL([GL_COND_OBJ_FREADABLE], [test $ac_cv_func___freadable = no])	bool
freadahead	#include "freadahead.h"	freadahead.c stdio-impl.h	freadahead.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FREADAHEAD gl_CONDITIONAL([GL_COND_OBJ_FREADAHEAD], [test $ac_cv_func___freadahead = no])	---
freading	#include "freading.h"	freading.c stdio-impl.h	freading.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FREADING	bool
freadptr	#include "freadptr.h"	freadptr.c stdio-impl.h	freadptr.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FREADPTR gl_CONDITIONAL([GL_COND_OBJ_FREADPTR], [test $ac_cv_func___freadptr = no])	---
freadseek	#include "freadseek.h"	freadseek.c stdio-impl.h	freadseek.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FREADSEEK	freadahead freadptr fseeko lseek
freopen-safer	#include "stdio-safer.h"	stdio--.h freopen-safer.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([freopen-safer])	attribute dup2 freopen open bool
fwritable	#include "fwritable.h"	fwritable.c stdio-impl.h	fwritable.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FWRITABLE gl_CONDITIONAL([GL_COND_OBJ_FWRITABLE], [test $ac_cv_func___fwritable = no])	bool
fwriting	#include "fwriting.h"	fwriting.c stdio-impl.h	fwriting.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FWRITING gl_CONDITIONAL([GL_COND_OBJ_FWRITING], [test $ac_cv_func___fwriting = no])	bool
getpass	#include <unistd.h>	getpass.h getpass.c	getpass.m4 tcgetattr.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_GETPASS if test $HAVE_GETPASS = 0 \|\| test $REPLACE_GETPASS = 1; then AC_LIBOBJ([getpass]) gl_PREREQ_GETPASS fi gl_UNISTD_MODULE_INDICATOR([getpass])	unistd-h extensions fopen-gnu fseeko getline bool strdup-posix
getpass-gnu	#include <unistd.h>	getpass.h getpass.c	getpass.m4 tcgetattr.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_GETPASS_GNU if test $HAVE_GETPASS = 0 \|\| test $REPLACE_GETPASS_FOR_GETPASS_GNU = 1; then AC_LIBOBJ([getpass]) gl_PREREQ_GETPASS fi gl_UNISTD_MODULE_INDICATOR([getpass-gnu])	getpass
popen-safer	#include "stdio-safer.h"	stdio--.h popen-safer.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([popen-safer])	open popen unistd-safer
supersede	#include "supersede.h"	supersede.c	supersede.m4 00gnulib.m4 zzgnulib.m4 gl_SUPERSEDE	c99 fcntl-h bool sys_stat-h clean-temp tempname canonicalize open unlink free-posix ignore-value stat stat-time utimens acl-permissions qcopy-acl fdopen
stdlib-safer	#include "stdlib-safer.h"	stdlib--.h mkstemp-safer.c	00gnulib.m4 zzgnulib.m4	fd-safer-flag mkstemp stdlib-h unistd-safer
tmpfile-safer	#include "stdio-safer.h"	stdio--.h tmpfile-safer.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([tmpfile-safer])	binary-io tmpfile unistd-safer
xfreopen	#include "xfreopen.h"	xfreopen.c	00gnulib.m4 zzgnulib.m4	error exitfail freopen gettext-h gnulib-i18n quote

Users and groups

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
getugroups	#include "getugroups.h"	getugroups.c	getugroups.m4 00gnulib.m4 zzgnulib.m4 gl_GETUGROUPS	errno-h
group-member	#include <unistd.h>	group-member.c	group-member.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_GROUP_MEMBER gl_CONDITIONAL([GL_COND_OBJ_GROUP_MEMBER], [test $HAVE_GROUP_MEMBER = 0]) AM_COND_IF([GL_COND_OBJ_GROUP_MEMBER], [ gl_PREREQ_GROUP_MEMBER ]) gl_UNISTD_MODULE_INDICATOR([group-member])	unistd-h extensions getgroups [test $HAVE_GROUP_MEMBER = 0] malloc-gnu [test $HAVE_GROUP_MEMBER = 0] stdckdint-h [test $HAVE_GROUP_MEMBER = 0]
idcache	#include "idcache.h"	idcache.c	idcache.m4 00gnulib.m4 zzgnulib.m4 gl_IDCACHE	flexmember xalloc
mgetgroups	#include "mgetgroups.h"	mgetgroups.c	mgetgroups.m4 00gnulib.m4 zzgnulib.m4 gl_MGETGROUPS	free-posix getgroups getugroups realloc-posix xalloc-oversized
userspec	#include "userspec.h"	userspec.c	userspec.m4 00gnulib.m4 zzgnulib.m4 gl_USERSPEC	posixver xalloc xstrtol strdup gettext-h gnulib-i18n intprops inttostr bool

Security

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
getumask	#include <sys/stat.h>	getumask.c	getumask.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_GETUMASK gl_CONDITIONAL([GL_COND_OBJ_GETUMASK], [test $HAVE_GETUMASK = 0]) AM_COND_IF([GL_COND_OBJ_GETUMASK], [ gl_PREREQ_GETUMASK ]) gl_SYS_STAT_MODULE_INDICATOR([getumask])	sys_stat-h extensions c99 [test $HAVE_GETUMASK = 0] unistd-h [test $HAVE_GETUMASK = 0] clean-temp [test $HAVE_GETUMASK = 0] tempname [test $HAVE_GETUMASK = 0]
idpriv-drop	#include "idpriv.h"	idpriv-drop.c	idpriv.m4 00gnulib.m4 zzgnulib.m4 gl_IDPRIV	unistd-h extensions
idpriv-droptemp	#include "idpriv.h"	idpriv-droptemp.c	idpriv.m4 00gnulib.m4 zzgnulib.m4 gl_IDPRIV	unistd-h extensions
priv-set	#include "priv-set.h"	priv-set.c	priv-set.m4 00gnulib.m4 zzgnulib.m4 gl_PRIV_SET	errno-h extern-inline bool

Date and time

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
gethrxtime	#include "xtime.h"	xtime.c gethrxtime.c gethrxtime.h	gethrxtime.m4 00gnulib.m4 zzgnulib.m4 gl_GETHRXTIME	clock-time extensions extern-inline gettime sys_time-h
gettime	#include "timespec.h"	gettime.c	gettime.m4 00gnulib.m4 zzgnulib.m4 gl_GETTIME	clock-time gettimeofday sys_time-h timespec extensions
gettime-res	#include "timespec.h"	gettime-res.c	gettime.m4 00gnulib.m4 zzgnulib.m4 gl_GETTIME_RES	clock-time gettime timespec extensions
posixtm	#include "posixtm.h"	posixtm.c	posixtm.m4 00gnulib.m4 zzgnulib.m4 gl_POSIXTM	c-ctype idx mktime bool stdckdint-h time verify
settime	#include "timespec.h"	settime.c	settime.m4 00gnulib.m4 zzgnulib.m4 gl_SETTIME	clock-time errno-h extensions sys_time-h timespec
usleep	#include <unistd.h>	usleep.c	usleep.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_USLEEP gl_CONDITIONAL([GL_COND_OBJ_USLEEP], [test $HAVE_USLEEP = 0 \|\| test $REPLACE_USLEEP = 1]) gl_UNISTD_MODULE_INDICATOR([usleep])	unistd-h extensions sleep [test $HAVE_USLEEP = 0 \|\| test $REPLACE_USLEEP = 1]
xnanosleep	#include "xnanosleep.h"	xnanosleep.c	xnanosleep.m4 00gnulib.m4 zzgnulib.m4 gl_XNANOSLEEP	c99 dtotimespec intprops nanosleep time-h unistd-h

Networking functions

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
accept4	#include <sys/socket.h>	accept4.c	accept4.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ACCEPT4 gl_SYS_SOCKET_MODULE_INDICATOR([accept4])	sys_socket-h accept fcntl-h binary-io extensions msvc-nothrow
xgethostname	#include "xgethostname.h"	xgethostname.c xgetaname-impl.h	00gnulib.m4 zzgnulib.m4	free-posix gethostname xalloc
canon-host	#include "canon-host.h"	canon-host.c	canon-host.m4 00gnulib.m4 zzgnulib.m4 gl_PREREQ_CANON_HOST	getaddrinfo strdup
sockets	#include "sockets.h"	sockets.c w32sock.h	sockets.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_SOCKETS])	socketlib sys_socket-h fd-hook msvc-nothrow

Multithreading

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
threadlib	---	glthread/threadlib.c	threadlib.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_THREADLIB])	---
asyncsafe-spin	#include "asyncsafe-spin.h"	asyncsafe-spin.c	00gnulib.m4 zzgnulib.m4	signal-h bool sigprocmask spin
lock	#include "glthread/lock.h"	glthread/lock.c	lock.m4 pthread_rwlock_rdlock.m4 00gnulib.m4 zzgnulib.m4 gl_LOCK gl_MODULE_INDICATOR([lock])	extensions threadlib once windows-mutex [test $gl_threads_api = windows] windows-rwlock [test $gl_threads_api = windows] windows-recmutex [test $gl_threads_api = windows]
simple-atomic	#include "simple-atomic.h"	simple-atomic.c	atomic-cas.m4 00gnulib.m4 zzgnulib.m4 AC_CHECK_HEADERS_ONCE([pthread.h]) AC_REQUIRE([gl_ATOMIC_COMPARE_AND_SWAP])	stdint-h sparcv8+
tls	#include "glthread/tls.h"	glthread/tls.c	tls.m4 00gnulib.m4 zzgnulib.m4 gl_TLS	threadlib windows-tls [test $gl_threads_api = windows]
thread	#include "glthread/thread.h"	glthread/thread.c	thread.m4 00gnulib.m4 zzgnulib.m4 gl_THREAD	threadlib stdint-h extern-inline windows-thread [test $gl_threads_api = windows] pthread_sigmask [test $gl_threads_api = posix]
yield	#include "glthread/yield.h"	---	yield.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_YIELD])	threadlib sched_yield
cond	#include "glthread/cond.h"	glthread/cond.c	cond.m4 00gnulib.m4 zzgnulib.m4 gl_COND	threadlib lock errno-h extern-inline bool time-h windows-cond [test $gl_threads_api = windows]
openmp	#ifdef _OPENMP # include <omp.h> #endif	---	00gnulib.m4 zzgnulib.m4 AC_OPENMP	---

Signal handling

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
c-stack	#include "c-stack.h"	c-stack.c	c-stack.m4 00gnulib.m4 zzgnulib.m4 gl_C_STACK	c99 errno-h exitfail getprogname gettext-h gnulib-i18n idx ignore-value inttypes-h mempcpy raise sigsegv stddef-h unistd-h
libsigsegv	#if HAVE_LIBSIGSEGV # include <sigsegv.h> #endif	---	libsigsegv.m4 00gnulib.m4 zzgnulib.m4 gl_LIBSIGSEGV	havelib
sig2str	#include <signal.h> #include "sig2str.h" /* for SIGNUM_BOUND */	sig2str.h sig2str.c	sig2str.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_SIG2STR gl_CONDITIONAL([GL_COND_OBJ_SIG2STR], [test $HAVE_SIG2STR = 0 \|\| test $HAVE_STR2SIG = 0]) AM_COND_IF([GL_COND_OBJ_SIG2STR], [ gl_PREREQ_SIG2STR ]) gl_SIGNAL_MODULE_INDICATOR([sig2str])	signal-h
sigpipe	#include <signal.h>	stdio-write.c	sigpipe.m4 asm-underscore.m4 00gnulib.m4 zzgnulib.m4 gl_SIGNAL_SIGPIPE dnl Define the C macro GNULIB_SIGPIPE to 1. gl_MODULE_INDICATOR([sigpipe]) dnl Define the substituted variable GNULIB_SIGNAL_H_SIGPIPE to 1. gl_SIGNAL_H_REQUIRE_DEFAULTS gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SIGNAL_H_SIGPIPE], [1]) dnl Define the substituted variable GNULIB_STDIO_H_SIGPIPE to 1. gl_STDIO_H_REQUIRE_DEFAULTS AC_REQUIRE([gl_ASM_SYMBOL_PREFIX]) gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STDIO_H_SIGPIPE], [1]) dnl Define the substituted variable GNULIB_UNISTD_H_SIGPIPE to 1. gl_UNISTD_H_REQUIRE_DEFAULTS gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNISTD_H_SIGPIPE], [1])	msvc-nothrow raise signal-h sigprocmask stdio-h unistd-h
sigpipe-die	#include "sigpipe-die.h"	sigpipe-die.c	00gnulib.m4 zzgnulib.m4	error gettext-h gnulib-i18n exitfail sigpipe sigprocmask sigaction
sigsegv	#include <sigsegv.h>	sigsegv.in.h sigsegv.c stackvma.h stackvma.c	mmap-anon.m4 musl.m4 sigaltstack.m4 stack-direction.m4 libsigsegv.m4 sigsegv.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_SIGSEGV]) if test $gl_sigsegv_uses_libsigsegv = yes; then GL_GENERATE_SIGSEGV_H=false else GL_GENERATE_SIGSEGV_H=true fi gl_CONDITIONAL_HEADER([sigsegv.h]) AC_PROG_MKDIR_P if $GL_GENERATE_SIGSEGV_H; then dnl Persuade glibc to declare macros designating register dnl indices: REG_RSP on x86_64, REG_ESP on i386. dnl Persuade Solaris OpenIndiana to include , dnl which declares macros designating register indices, such as ESP on i386. dnl Persuade Solaris OpenIndiana to declare mincore(). AC_REQUIRE([gl_USE_SYSTEM_EXTENSIONS]) gl_MUSL_LIBC AC_REQUIRE([AC_CANONICAL_HOST]) case "$host_os" in solaris2.11) AC_DEFINE([SOLARIS11], [1], [Define on Solaris 11 and its derivates.]) ;; esac gl_FUNC_MMAP_ANON dnl Stack direction. SV_STACK_DIRECTION dnl Catching stack overflow requires an alternate signal stack. dnl The old "install a guard page" trick would be unreliable, because dnl we don't know where exactly to place the guard page. SV_SIGALTSTACK AC_CHECK_FUNCS_ONCE([getrlimit]) fi	gen-header havelib host-cpu-c-abi stdint-h getpagesize

Terminal I/O

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
termcap	---	tparm.c tputs.c	termcap.m4 curses.m4 00gnulib.m4 zzgnulib.m4 gl_TERMCAP	havelib attribute c-ctype
termcap-h	#include "termcap.h"	---	00gnulib.m4 zzgnulib.m4	termcap
terminfo	---	tparm.c tputs.c	terminfo.m4 curses.m4 00gnulib.m4 zzgnulib.m4 gl_TERMINFO	havelib attribute c-ctype
terminfo-h	#include "terminfo.h"	---	00gnulib.m4 zzgnulib.m4	terminfo

Internationalization functions

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
gettext	#include "gettext.h"	---	gettext.m4 build-to-host.m4 host-cpu-c-abi.m4 iconv.m4 intl-thread-locale.m4 intlmacosx.m4 nls.m4 po.m4 progtest.m4 00gnulib.m4 zzgnulib.m4 AM_GNU_GETTEXT([external]) AM_GNU_GETTEXT_VERSION([0.22])	extensions gettext-h havelib
gettext-h	#include "gettext.h"	---	00gnulib.m4 zzgnulib.m4 AC_SUBST([LIBINTL]) AC_SUBST([LTLIBINTL])	locale-h vararrays
propername	#include "propername.h"	propername.c	00gnulib.m4 zzgnulib.m4 m4_ifdef([AM_XGETTEXT_OPTION], [AM_][XGETTEXT_OPTION([--keyword='proper_name:1,\"This is a proper name. See the gettext manual, section Names.\"']) AM_][XGETTEXT_OPTION([--keyword='proper_name_utf8:1,\"This is a proper name. See the gettext manual, section Names.\"'])])	c32isalnum bool trim mbsstr mbchar mbuiter iconv localcharset c-strcasecmp xstriconv xalloc gettext-h
propername-lite	#include "propername.h"	propername-lite.c	00gnulib.m4 zzgnulib.m4 m4_ifdef([AM_XGETTEXT_OPTION], [AM_][XGETTEXT_OPTION([--keyword='proper_name_lite:1,\"This is a proper name. See the gettext manual, section Names.\"'])])	localcharset c-strcasecmp gettext-h
iconv	#if HAVE_ICONV # include <iconv.h> #endif	---	iconv.m4 00gnulib.m4 zzgnulib.m4 AM_ICONV m4_ifdef([gl_ICONV_MODULE_INDICATOR], [gl_ICONV_MODULE_INDICATOR([iconv])])	havelib
striconv	#include "striconv.h"	striconv.c	00gnulib.m4 zzgnulib.m4 if test $gl_cond_libtool = false; then gl_ltlibdeps="$gl_ltlibdeps $LTLIBICONV" gl_libdeps="$gl_libdeps $LIBICONV" fi	iconv iconv_open free-posix strdup c-strcasecmp
xstriconv	#include "xstriconv.h"	xstriconv.c	00gnulib.m4 zzgnulib.m4	striconv xalloc
striconveh	#include "striconveh.h"	striconveh.c iconveh.h	00gnulib.m4 zzgnulib.m4 if test $gl_cond_libtool = false; then gl_ltlibdeps="$gl_ltlibdeps $LTLIBICONV" gl_libdeps="$gl_libdeps $LIBICONV" fi	bool iconv iconv_open unistr/u8-prev unistr/u8-mbtouc-unsafe unistr/u8-mbtouc unistr/u8-mbtoucr unistr/u8-uctomb free-posix strdup c-strcasecmp c-strcaseeq memmove
xstriconveh	#include "xstriconveh.h"	xstriconveh.c	00gnulib.m4 zzgnulib.m4	striconveh xalloc
striconveha	#include "striconveha.h"	striconveha.c	00gnulib.m4 zzgnulib.m4	bool striconveh malloca strdup c-strcasecmp
localcharset	#include "localcharset.h"	localcharset.c	codeset.m4 localcharset.m4 00gnulib.m4 zzgnulib.m4 gl_LOCALCHARSET dnl For backward compatibility. Some packages still use this. LOCALCHARSET_TESTS_ENVIRONMENT= AC_SUBST([LOCALCHARSET_TESTS_ENVIRONMENT])	extensions
hard-locale	#include "hard-locale.h"	hard-locale.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_FUNC_SETLOCALE_NULL]) HARD_LOCALE_LIB="$SETLOCALE_NULL_LIB" AC_SUBST([HARD_LOCALE_LIB]) dnl For backward compatibility. LIB_HARD_LOCALE="$HARD_LOCALE_LIB" AC_SUBST([LIB_HARD_LOCALE])	bool setlocale-null
localename	#include "localename.h"	localename.c struniq.h	00gnulib.m4 zzgnulib.m4	locale-h localename-unsafe flexmember lock bool thread-optim
mbmemcasecmp	#include "mbmemcasecmp.h"	mbmemcasecmp.c	00gnulib.m4 zzgnulib.m4	c32tolower mbiterf
mbmemcasecoll	#include "mbmemcasecoll.h"	mbmemcasecoll.c	00gnulib.m4 zzgnulib.m4	bool wchar-h uchar-h malloca mbszero mbrtoc32 c32rtomb c32tolower memcmp2 memcoll
mbslen	#include <string.h>	mbslen.c	mbslen.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_MBSLEN gl_STRING_MODULE_INDICATOR([mbslen])	mbuiterf string-h
mbsnlen	#include <string.h>	mbsnlen.c	00gnulib.m4 zzgnulib.m4 gl_STRING_MODULE_INDICATOR([mbsnlen])	mbiterf string-h
mbschr	#include <string.h>	mbschr.c	00gnulib.m4 zzgnulib.m4 gl_STRING_MODULE_INDICATOR([mbschr])	mbuiterf string-h
mbsrchr	#include <string.h>	mbsrchr.c	00gnulib.m4 zzgnulib.m4 gl_STRING_MODULE_INDICATOR([mbsrchr])	mbuiterf string-h
mbsstr	#include <string.h>	mbsstr.c str-kmp.h	00gnulib.m4 zzgnulib.m4 gl_STRING_MODULE_INDICATOR([mbsstr])	alignasof mbuiter bool string-h mbslen malloca strnlen
mbscasecmp	#include <string.h>	mbscasecmp.c	00gnulib.m4 zzgnulib.m4 gl_STRING_MODULE_INDICATOR([mbscasecmp])	c32tolower mbuiterf [test "$GNULIB_MCEL_PREFER" != yes] stdlib-h string-h uchar-h
mbsncasecmp	#include <string.h>	mbsncasecmp.c	00gnulib.m4 zzgnulib.m4 gl_STRING_MODULE_INDICATOR([mbsncasecmp])	c32tolower mbuiterf string-h
mbspcasecmp	#include <string.h>	mbspcasecmp.c	00gnulib.m4 zzgnulib.m4 gl_STRING_MODULE_INDICATOR([mbspcasecmp])	c32tolower mbuiterf string-h
mbscasestr	#include <string.h>	mbscasestr.c str-kmp.h	00gnulib.m4 zzgnulib.m4 gl_STRING_MODULE_INDICATOR([mbscasestr])	alignasof mbuiter bool string-h mbslen malloca c32tolower strnlen
mbscspn	#include <string.h>	mbscspn.c	00gnulib.m4 zzgnulib.m4 gl_STRING_MODULE_INDICATOR([mbscspn])	mbuiterf string-h mbschr strcspn
mbspbrk	#include <string.h>	mbspbrk.c	00gnulib.m4 zzgnulib.m4 gl_STRING_MODULE_INDICATOR([mbspbrk])	mbuiterf string-h mbschr strpbrk
mbsspn	#include <string.h>	mbsspn.c	00gnulib.m4 zzgnulib.m4 gl_STRING_MODULE_INDICATOR([mbsspn])	mbuiterf string-h mbschr
mbssep	#include <string.h>	mbssep.c	00gnulib.m4 zzgnulib.m4 gl_STRING_MODULE_INDICATOR([mbssep])	mbuiterf string-h mbspbrk strsep
mbstok_r	#include <string.h>	mbstok_r.c	00gnulib.m4 zzgnulib.m4 gl_STRING_MODULE_INDICATOR([mbstok_r])	string-h mbsspn mbspbrk strtok_r
mbswidth	#include "mbswidth.h"	mbswidth.c	mbstate_t.m4 mbrtowc.m4 mbswidth.m4 00gnulib.m4 zzgnulib.m4 gl_MBSWIDTH	wchar-h uchar-h mbrtoc32 mbsinit mbszero c32width c32iscntrl extensions
memcasecmp	#include "memcasecmp.h"	memcasecmp.c	memcasecmp.m4 00gnulib.m4 zzgnulib.m4 gl_MEMCASECMP	---
memcoll	#include "memcoll.h"	memcoll.c	memcoll.m4 00gnulib.m4 zzgnulib.m4 gl_MEMCOLL	memcmp
xmemcoll	#include "xmemcoll.h"	xmemcoll.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_RESTRICT])	memcoll gettext-h gnulib-i18n error quotearg exitfail
unicodeio	#include "unicodeio.h"	unicodeio.c	unicodeio.m4 musl.m4 00gnulib.m4 zzgnulib.m4 gl_UNICODEIO	unistr/u8-uctomb iconv iconv_open gettext-h gnulib-i18n localcharset error stdio-h
rpmatch	#include <stdlib.h>	rpmatch.c	rpmatch.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_RPMATCH gl_CONDITIONAL([GL_COND_OBJ_RPMATCH], [test $HAVE_RPMATCH = 0]) AM_COND_IF([GL_COND_OBJ_RPMATCH], [ gl_PREREQ_RPMATCH ]) gl_STDLIB_MODULE_INDICATOR([rpmatch])	stdlib-h extensions bool [test $HAVE_RPMATCH = 0] gettext-h [test $HAVE_RPMATCH = 0] gnulib-i18n [test $HAVE_RPMATCH = 0] regex [test $HAVE_RPMATCH = 0] strdup [test $HAVE_RPMATCH = 0]
yesno	#include "yesno.h"	yesno.c	yesno.m4 00gnulib.m4 zzgnulib.m4 gl_YESNO	getline rpmatch bool
bison-i18n	---	---	bison-i18n.m4 build-to-host.m4 00gnulib.m4 zzgnulib.m4 BISON_I18N	---

Unicode string functions

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
libunistring	#if HAVE_LIBUNISTRING # include <unitypes.h> # include <unistr.h> # include <uniconv.h> # include <unistdio.h> # include <uniname.h> # include <unictype.h> # include <uniwidth.h> # include <uniwbrk.h> # include <unilbrk.h> # include <uninorm.h> # include <unicase.h> # include <uniregex.h> # include <unistring/version.h> #endif	libunistring.valgrind	libunistring.m4 absolute-header.m4 00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING	havelib iconv
libunistring-optional	---	libunistring.valgrind	libunistring-optional.m4 libunistring.m4 absolute-header.m4 00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_OPTIONAL	havelib iconv
unitypes	#include "unitypes.h"	---	00gnulib.m4 zzgnulib.m4	unitypes-h
ucs4-utf8	#include "unistr.h"	---	00gnulib.m4 zzgnulib.m4	unistr/u8-uctomb
ucs4-utf16	#include "unistr.h"	---	00gnulib.m4 zzgnulib.m4	unistr/u16-uctomb
utf8-ucs4-unsafe	#include "unistr.h"	---	00gnulib.m4 zzgnulib.m4	unistr/u8-mbtouc-unsafe
utf16-ucs4-unsafe	#include "unistr.h"	---	00gnulib.m4 zzgnulib.m4	unistr/u16-mbtouc-unsafe
utf8-ucs4	#include "unistr.h"	---	00gnulib.m4 zzgnulib.m4	unistr/u8-mbtouc
utf16-ucs4	#include "unistr.h"	---	00gnulib.m4 zzgnulib.m4	unistr/u16-mbtouc
unistr/base	#include "unistr.h"	unistr.in.h	libunistring-base.m4 00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_LIBHEADER([1.2], [unistr.h]) AC_PROG_MKDIR_P	gen-header unitypes-h bool inline
unistr/u8-to-u16	#include "unistr.h"	unistr/u8-to-u16.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9.3], [unistr/u8-to-u16])	unistr/base unistr/u8-mbtoucr unistr/u16-uctomb
unistr/u8-to-u32	#include "unistr.h"	unistr/u8-to-u32.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9.3], [unistr/u8-to-u32])	unistr/base unistr/u8-mbtoucr
unistr/u16-to-u8	#include "unistr.h"	unistr/u16-to-u8.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9.3], [unistr/u16-to-u8])	unistr/base unistr/u16-mbtoucr unistr/u8-uctomb
unistr/u16-to-u32	#include "unistr.h"	unistr/u16-to-u32.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9.3], [unistr/u16-to-u32])	unistr/base unistr/u16-mbtoucr
unistr/u32-to-u8	#include "unistr.h"	unistr/u32-to-u8.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-to-u8])	unistr/base unistr/u8-uctomb
unistr/u32-to-u16	#include "unistr.h"	unistr/u32-to-u16.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-to-u16])	unistr/base unistr/u16-uctomb
unistr/u8-check	#include "unistr.h"	unistr/u8-check.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-check])	unistr/base
unistr/u16-check	#include "unistr.h"	unistr/u16-check.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-check])	unistr/base
unistr/u32-check	#include "unistr.h"	unistr/u32-check.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-check])	unistr/base
unistr/u8-chr	#include "unistr.h"	unistr/u8-chr.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-chr])	memchr unistr/base unistr/u8-uctomb
unistr/u16-chr	#include "unistr.h"	unistr/u16-chr.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-chr])	unistr/base unistr/u16-uctomb
unistr/u32-chr	#include "unistr.h"	unistr/u32-chr.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-chr])	unistr/base
unistr/u8-cmp	#include "unistr.h"	unistr/u8-cmp.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-cmp])	unistr/base memcmp
unistr/u16-cmp	#include "unistr.h"	unistr/u16-cmp.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-cmp])	unistr/base
unistr/u32-cmp	#include "unistr.h"	unistr/u32-cmp.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-cmp])	unistr/base
unistr/u8-cmp2	#include "unistr.h"	unistr/u8-cmp2.c unistr/u-cmp2.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-cmp2])	unistr/base unistr/u8-cmp minmax
unistr/u16-cmp2	#include "unistr.h"	unistr/u16-cmp2.c unistr/u-cmp2.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-cmp2])	unistr/base unistr/u16-cmp minmax
unistr/u32-cmp2	#include "unistr.h"	unistr/u32-cmp2.c unistr/u-cmp2.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-cmp2])	unistr/base unistr/u32-cmp minmax
unistr/u8-cpy	#include "unistr.h"	unistr/u8-cpy.c unistr/u-cpy.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-cpy])	unistr/base
unistr/u16-cpy	#include "unistr.h"	unistr/u16-cpy.c unistr/u-cpy.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-cpy])	unistr/base
unistr/u32-cpy	#include "unistr.h"	unistr/u32-cpy.c unistr/u-cpy.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-cpy])	unistr/base
unistr/u8-cpy-alloc	#include "unistr.h"	unistr/u8-cpy-alloc.c unistr/u-cpy-alloc.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-cpy-alloc])	unistr/base malloc-posix
unistr/u16-cpy-alloc	#include "unistr.h"	unistr/u16-cpy-alloc.c unistr/u-cpy-alloc.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-cpy-alloc])	unistr/base malloc-posix
unistr/u32-cpy-alloc	#include "unistr.h"	unistr/u32-cpy-alloc.c unistr/u-cpy-alloc.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-cpy-alloc])	unistr/base malloc-posix
unistr/u8-endswith	#include "unistr.h"	unistr/u8-endswith.c unistr/u-endswith.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-endswith])	unistr/base unistr/u8-strlen unistr/u8-cmp
unistr/u16-endswith	#include "unistr.h"	unistr/u16-endswith.c unistr/u-endswith.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-endswith])	unistr/base unistr/u16-strlen unistr/u16-cmp
unistr/u32-endswith	#include "unistr.h"	unistr/u32-endswith.c unistr/u-endswith.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-endswith])	unistr/base unistr/u32-strlen unistr/u32-cmp
unistr/u8-mblen	#include "unistr.h"	unistr/u8-mblen.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-mblen])	unistr/base
unistr/u16-mblen	#include "unistr.h"	unistr/u16-mblen.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-mblen])	unistr/base
unistr/u32-mblen	#include "unistr.h"	unistr/u32-mblen.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-mblen])	unistr/base
unistr/u8-mbsnlen	#include "unistr.h"	unistr/u8-mbsnlen.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.2], [unistr/u8-mbsnlen])	unistr/base unistr/u8-mbtoucr unistr/u8-mbtouc
unistr/u16-mbsnlen	#include "unistr.h"	unistr/u16-mbsnlen.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-mbsnlen])	unistr/base unistr/u16-mbtoucr
unistr/u32-mbsnlen	#include "unistr.h"	unistr/u32-mbsnlen.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-mbsnlen])	unistr/base
unistr/u8-mbtouc-unsafe	#include "unistr.h"	unistr/u8-mbtouc-unsafe.c unistr/u8-mbtouc-unsafe-aux.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([unistr/u8-mbtouc-unsafe]) gl_LIBUNISTRING_MODULE([0.9.4], [unistr/u8-mbtouc-unsafe])	unistr/base
unistr/u16-mbtouc-unsafe	#include "unistr.h"	unistr/u16-mbtouc-unsafe.c unistr/u16-mbtouc-unsafe-aux.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([unistr/u16-mbtouc-unsafe]) gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-mbtouc-unsafe])	unistr/base
unistr/u32-mbtouc-unsafe	#include "unistr.h"	unistr/u32-mbtouc-unsafe.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([unistr/u32-mbtouc-unsafe]) gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-mbtouc-unsafe])	unistr/base
unistr/u8-mbtouc	#include "unistr.h"	unistr/u8-mbtouc.c unistr/u8-mbtouc-aux.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([unistr/u8-mbtouc]) gl_LIBUNISTRING_MODULE([1.2], [unistr/u8-mbtouc])	unistr/base
unistr/u16-mbtouc	#include "unistr.h"	unistr/u16-mbtouc.c unistr/u16-mbtouc-aux.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([unistr/u16-mbtouc]) gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-mbtouc])	unistr/base
unistr/u32-mbtouc	#include "unistr.h"	unistr/u32-mbtouc.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([unistr/u32-mbtouc]) gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-mbtouc])	unistr/base
unistr/u8-mbtoucr	#include "unistr.h"	unistr/u8-mbtoucr.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([unistr/u8-mbtoucr]) gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-mbtoucr])	unistr/base
unistr/u16-mbtoucr	#include "unistr.h"	unistr/u16-mbtoucr.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([unistr/u16-mbtoucr]) gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-mbtoucr])	unistr/base
unistr/u32-mbtoucr	#include "unistr.h"	unistr/u32-mbtoucr.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([unistr/u32-mbtoucr]) gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-mbtoucr])	unistr/base
unistr/u8-move	#include "unistr.h"	unistr/u8-move.c unistr/u-move.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-move])	unistr/base memmove
unistr/u16-move	#include "unistr.h"	unistr/u16-move.c unistr/u-move.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-move])	unistr/base memmove
unistr/u32-move	#include "unistr.h"	unistr/u32-move.c unistr/u-move.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-move])	unistr/base memmove
unistr/u8-next	#include "unistr.h"	unistr/u8-next.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-next])	unistr/base unistr/u8-strmbtouc
unistr/u16-next	#include "unistr.h"	unistr/u16-next.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-next])	unistr/base unistr/u16-strmbtouc
unistr/u32-next	#include "unistr.h"	unistr/u32-next.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-next])	unistr/base unistr/u32-strmbtouc
unistr/u8-prev	#include "unistr.h"	unistr/u8-prev.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-prev])	unistr/base
unistr/u16-prev	#include "unistr.h"	unistr/u16-prev.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-prev])	unistr/base
unistr/u32-prev	#include "unistr.h"	unistr/u32-prev.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-prev])	unistr/base
unistr/u8-set	#include "unistr.h"	unistr/u8-set.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-set])	unistr/base
unistr/u16-set	#include "unistr.h"	unistr/u16-set.c unistr/u-set.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-set])	unistr/base
unistr/u32-set	#include "unistr.h"	unistr/u32-set.c unistr/u-set.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-set])	unistr/base
unistr/u8-startswith	#include "unistr.h"	unistr/u8-startswith.c unistr/u-startswith.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-startswith])	unistr/base
unistr/u16-startswith	#include "unistr.h"	unistr/u16-startswith.c unistr/u-startswith.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-startswith])	unistr/base
unistr/u32-startswith	#include "unistr.h"	unistr/u32-startswith.c unistr/u-startswith.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-startswith])	unistr/base
unistr/u8-stpcpy	#include "unistr.h"	unistr/u8-stpcpy.c unistr/u-stpcpy.h	00gnulib.m4 zzgnulib.m4 gl_CHECK_FUNCS_ANDROID([stpcpy], [[#include ]]) gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-stpcpy])	unistr/base
unistr/u16-stpcpy	#include "unistr.h"	unistr/u16-stpcpy.c unistr/u-stpcpy.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-stpcpy])	unistr/base
unistr/u32-stpcpy	#include "unistr.h"	unistr/u32-stpcpy.c unistr/u-stpcpy.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-stpcpy])	unistr/base
unistr/u8-stpncpy	#include "unistr.h"	unistr/u8-stpncpy.c unistr/u-stpncpy.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9.3], [unistr/u8-stpncpy])	unistr/base
unistr/u16-stpncpy	#include "unistr.h"	unistr/u16-stpncpy.c unistr/u-stpncpy.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9.3], [unistr/u16-stpncpy])	unistr/base
unistr/u32-stpncpy	#include "unistr.h"	unistr/u32-stpncpy.c unistr/u-stpncpy.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9.3], [unistr/u32-stpncpy])	unistr/base
unistr/u8-strcat	#include "unistr.h"	unistr/u8-strcat.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-strcat])	unistr/base
unistr/u16-strcat	#include "unistr.h"	unistr/u16-strcat.c unistr/u-strcat.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-strcat])	unistr/base unistr/u16-strlen
unistr/u32-strcat	#include "unistr.h"	unistr/u32-strcat.c unistr/u-strcat.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-strcat])	unistr/base unistr/u32-strlen
unistr/u8-strchr	#include "unistr.h"	unistr/u8-strchr.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-strchr])	unistr/base unistr/u8-uctomb
unistr/u16-strchr	#include "unistr.h"	unistr/u16-strchr.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-strchr])	unistr/base unistr/u16-uctomb
unistr/u32-strchr	#include "unistr.h"	unistr/u32-strchr.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-strchr])	unistr/base
unistr/u8-strcmp	#include "unistr.h"	unistr/u8-strcmp.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9.4], [unistr/u8-strcmp])	unistr/base
unistr/u16-strcmp	#include "unistr.h"	unistr/u16-strcmp.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-strcmp])	unistr/base
unistr/u32-strcmp	#include "unistr.h"	unistr/u32-strcmp.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-strcmp])	unistr/base
unistr/u8-strcoll	#include "unistr.h"	unistr/u8-strcoll.c unistr/u-strcoll.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9.4], [unistr/u8-strcoll])	unistr/base unistr/u8-strcmp uniconv/u8-strconv-to-enc localcharset
unistr/u16-strcoll	#include "unistr.h"	unistr/u16-strcoll.c unistr/u-strcoll.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9.4], [unistr/u16-strcoll])	unistr/base unistr/u16-strcmp uniconv/u16-strconv-to-enc localcharset
unistr/u32-strcoll	#include "unistr.h"	unistr/u32-strcoll.c unistr/u-strcoll.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9.4], [unistr/u32-strcoll])	unistr/base unistr/u32-strcmp uniconv/u32-strconv-to-enc localcharset
unistr/u8-strcpy	#include "unistr.h"	unistr/u8-strcpy.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-strcpy])	unistr/base
unistr/u16-strcpy	#include "unistr.h"	unistr/u16-strcpy.c unistr/u-strcpy.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-strcpy])	unistr/base
unistr/u32-strcpy	#include "unistr.h"	unistr/u32-strcpy.c unistr/u-strcpy.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-strcpy])	unistr/base
unistr/u8-strcspn	#include "unistr.h"	unistr/u8-strcspn.c unistr/u-strcspn.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-strcspn])	unistr/base unistr/u8-strlen unistr/u8-strmbtouc unistr/u8-strchr
unistr/u16-strcspn	#include "unistr.h"	unistr/u16-strcspn.c unistr/u-strcspn.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-strcspn])	unistr/base unistr/u16-strlen unistr/u16-strmbtouc unistr/u16-strchr
unistr/u32-strcspn	#include "unistr.h"	unistr/u32-strcspn.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-strcspn])	unistr/base unistr/u32-strlen unistr/u32-strchr
unistr/u8-strdup	#include "unistr.h"	unistr/u8-strdup.c	00gnulib.m4 zzgnulib.m4 AC_CHECK_FUNCS_ONCE([strdup]) gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-strdup])	unistr/base
unistr/u16-strdup	#include "unistr.h"	unistr/u16-strdup.c unistr/u-strdup.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-strdup])	unistr/base unistr/u16-strlen
unistr/u32-strdup	#include "unistr.h"	unistr/u32-strdup.c unistr/u-strdup.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-strdup])	unistr/base unistr/u32-strlen
unistr/u8-strlen	#include "unistr.h"	unistr/u8-strlen.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-strlen])	unistr/base
unistr/u16-strlen	#include "unistr.h"	unistr/u16-strlen.c unistr/u-strlen.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-strlen])	unistr/base
unistr/u32-strlen	#include "unistr.h"	unistr/u32-strlen.c unistr/u-strlen.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-strlen])	unistr/base
unistr/u8-strmblen	#include "unistr.h"	unistr/u8-strmblen.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-strmblen])	unistr/base
unistr/u16-strmblen	#include "unistr.h"	unistr/u16-strmblen.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-strmblen])	unistr/base
unistr/u32-strmblen	#include "unistr.h"	unistr/u32-strmblen.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-strmblen])	unistr/base
unistr/u8-strmbtouc	#include "unistr.h"	unistr/u8-strmbtouc.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-strmbtouc])	unistr/base
unistr/u16-strmbtouc	#include "unistr.h"	unistr/u16-strmbtouc.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-strmbtouc])	unistr/base
unistr/u32-strmbtouc	#include "unistr.h"	unistr/u32-strmbtouc.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-strmbtouc])	unistr/base
unistr/u8-strncat	#include "unistr.h"	unistr/u8-strncat.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-strncat])	unistr/base strncat
unistr/u16-strncat	#include "unistr.h"	unistr/u16-strncat.c unistr/u-strncat.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-strncat])	unistr/base unistr/u16-strlen
unistr/u32-strncat	#include "unistr.h"	unistr/u32-strncat.c unistr/u-strncat.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-strncat])	unistr/base unistr/u32-strlen
unistr/u8-strncmp	#include "unistr.h"	unistr/u8-strncmp.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-strncmp])	unistr/base
unistr/u16-strncmp	#include "unistr.h"	unistr/u16-strncmp.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-strncmp])	unistr/base
unistr/u32-strncmp	#include "unistr.h"	unistr/u32-strncmp.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-strncmp])	unistr/base
unistr/u8-strncpy	#include "unistr.h"	unistr/u8-strncpy.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-strncpy])	unistr/base
unistr/u16-strncpy	#include "unistr.h"	unistr/u16-strncpy.c unistr/u-strncpy.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-strncpy])	unistr/base
unistr/u32-strncpy	#include "unistr.h"	unistr/u32-strncpy.c unistr/u-strncpy.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-strncpy])	unistr/base
unistr/u8-strnlen	#include "unistr.h"	unistr/u8-strnlen.c unistr/u-strnlen.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-strnlen])	unistr/base
unistr/u16-strnlen	#include "unistr.h"	unistr/u16-strnlen.c unistr/u-strnlen.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-strnlen])	unistr/base
unistr/u32-strnlen	#include "unistr.h"	unistr/u32-strnlen.c unistr/u-strnlen.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-strnlen])	unistr/base
unistr/u8-strpbrk	#include "unistr.h"	unistr/u8-strpbrk.c unistr/u-strpbrk.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-strpbrk])	unistr/base unistr/u8-strmbtouc unistr/u8-strchr
unistr/u16-strpbrk	#include "unistr.h"	unistr/u16-strpbrk.c unistr/u-strpbrk.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-strpbrk])	unistr/base unistr/u16-strmbtouc unistr/u16-strchr
unistr/u32-strpbrk	#include "unistr.h"	unistr/u32-strpbrk.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-strpbrk])	unistr/base unistr/u32-strchr
unistr/u8-strrchr	#include "unistr.h"	unistr/u8-strrchr.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-strrchr])	unistr/base unistr/u8-uctomb
unistr/u16-strrchr	#include "unistr.h"	unistr/u16-strrchr.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-strrchr])	unistr/base unistr/u16-uctomb
unistr/u32-strrchr	#include "unistr.h"	unistr/u32-strrchr.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-strrchr])	unistr/base
unistr/u8-strspn	#include "unistr.h"	unistr/u8-strspn.c unistr/u-strspn.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-strspn])	unistr/base unistr/u8-strlen unistr/u8-strmbtouc unistr/u8-cmp unistr/u8-strchr
unistr/u16-strspn	#include "unistr.h"	unistr/u16-strspn.c unistr/u-strspn.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-strspn])	unistr/base unistr/u16-strlen unistr/u16-strmbtouc unistr/u16-cmp unistr/u16-strchr
unistr/u32-strspn	#include "unistr.h"	unistr/u32-strspn.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-strspn])	unistr/base unistr/u32-strchr
unistr/u8-strstr	#include "unistr.h"	unistr/u8-strstr.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9.4], [unistr/u8-strstr])	unistr/base unistr/u8-strchr unistr/u8-strmbtouc strstr
unistr/u16-strstr	#include "unistr.h"	unistr/u16-strstr.c wcsstr-impl.h wcs-two-way.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9.4], [unistr/u16-strstr])	unistr/base unistr/u16-chr unistr/u16-strchr unistr/u16-cmp bool
unistr/u32-strstr	#include "unistr.h"	unistr/u32-strstr.c wcsstr-impl.h wcs-two-way.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9.4], [unistr/u32-strstr])	unistr/base unistr/u32-chr unistr/u32-strchr unistr/u32-cmp bool
unistr/u8-strtok	#include "unistr.h"	unistr/u8-strtok.c unistr/u-strtok.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unistr/u8-strtok])	unistr/base unistr/u8-strspn unistr/u8-strpbrk unistr/u8-strmblen
unistr/u16-strtok	#include "unistr.h"	unistr/u16-strtok.c unistr/u-strtok.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unistr/u16-strtok])	unistr/base unistr/u16-strspn unistr/u16-strpbrk unistr/u16-strmblen
unistr/u32-strtok	#include "unistr.h"	unistr/u32-strtok.c unistr/u-strtok.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unistr/u32-strtok])	unistr/base unistr/u32-strspn unistr/u32-strpbrk unistr/u32-strmblen
unistr/u8-uctomb	#include "unistr.h"	unistr/u8-uctomb.c unistr/u8-uctomb-aux.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([unistr/u8-uctomb]) gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-uctomb])	unistr/base attribute
unistr/u16-uctomb	#include "unistr.h"	unistr/u16-uctomb.c unistr/u16-uctomb-aux.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([unistr/u16-uctomb]) gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-uctomb])	unistr/base
unistr/u32-uctomb	#include "unistr.h"	unistr/u32-uctomb.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([unistr/u32-uctomb]) gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-uctomb])	unistr/base
uniconv/base	#include "uniconv.h"	uniconv.in.h iconveh.h striconveha.h localcharset.h	libunistring-base.m4 00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_LIBHEADER([0.9.11], [uniconv.h]) AC_PROG_MKDIR_P	gen-header bool unitypes-h
uniconv/u8-conv-from-enc	#include "uniconv.h"	uniconv/u8-conv-from-enc.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [uniconv/u8-conv-from-enc])	uniconv/base c-strcaseeq striconveha unistr/u8-check unistr/u8-mblen
uniconv/u16-conv-from-enc	#include "uniconv.h"	uniconv/u16-conv-from-enc.c uniconv/u-conv-from-enc.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_BIGENDIAN]) gl_LIBUNISTRING_MODULE([0.9], [uniconv/u16-conv-from-enc])	uniconv/base striconveha uniconv/u8-conv-from-enc unistr/u8-to-u16 unistr/u8-mblen unistr/u16-mblen
uniconv/u32-conv-from-enc	#include "uniconv.h"	uniconv/u32-conv-from-enc.c uniconv/u-conv-from-enc.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [uniconv/u32-conv-from-enc])	uniconv/base striconveha uniconv/u8-conv-from-enc unistr/u8-to-u32 unistr/u8-mblen unistr/u32-mblen
uniconv/u8-conv-to-enc	#include "uniconv.h"	uniconv/u8-conv-to-enc.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [uniconv/u8-conv-to-enc])	uniconv/base c-strcaseeq striconveha unistr/u8-check
uniconv/u16-conv-to-enc	#include "uniconv.h"	uniconv/u16-conv-to-enc.c uniconv/u-conv-to-enc.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_BIGENDIAN]) gl_LIBUNISTRING_MODULE([0.9], [uniconv/u16-conv-to-enc])	uniconv/base striconveha uniconv/u8-conv-to-enc unistr/u16-mbtoucr unistr/u8-uctomb unistr/u16-mblen unistr/u8-mblen
uniconv/u32-conv-to-enc	#include "uniconv.h"	uniconv/u32-conv-to-enc.c uniconv/u-conv-to-enc.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [uniconv/u32-conv-to-enc])	uniconv/base striconveha uniconv/u8-conv-to-enc unistr/u32-to-u8 unistr/u32-mblen unistr/u8-mblen
uniconv/u8-strconv-from-enc	#include "uniconv.h"	uniconv/u8-strconv-from-enc.c uniconv/u-strconv-from-enc.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [uniconv/u8-strconv-from-enc])	uniconv/base uniconv/u8-conv-from-enc unistr/u8-strlen
uniconv/u16-strconv-from-enc	#include "uniconv.h"	uniconv/u16-strconv-from-enc.c uniconv/u-strconv-from-enc.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [uniconv/u16-strconv-from-enc])	uniconv/base uniconv/u16-conv-from-enc unistr/u16-strlen
uniconv/u32-strconv-from-enc	#include "uniconv.h"	uniconv/u32-strconv-from-enc.c uniconv/u-strconv-from-enc.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [uniconv/u32-strconv-from-enc])	uniconv/base uniconv/u32-conv-from-enc unistr/u32-strlen
uniconv/u8-strconv-to-enc	#include "uniconv.h"	uniconv/u8-strconv-to-enc.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [uniconv/u8-strconv-to-enc])	uniconv/base c-strcaseeq striconveha unistr/u8-check unistr/u8-strlen
uniconv/u16-strconv-to-enc	#include "uniconv.h"	uniconv/u16-strconv-to-enc.c uniconv/u-strconv-to-enc.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_BIGENDIAN]) gl_LIBUNISTRING_MODULE([0.9], [uniconv/u16-strconv-to-enc])	uniconv/base striconveha uniconv/u8-strconv-to-enc unistr/u16-to-u8 unistr/u16-strlen
uniconv/u32-strconv-to-enc	#include "uniconv.h"	uniconv/u32-strconv-to-enc.c uniconv/u-strconv-to-enc.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [uniconv/u32-strconv-to-enc])	uniconv/base striconveha uniconv/u8-strconv-to-enc unistr/u32-to-u8 unistr/u32-strlen
uniconv/u8-strconv-from-locale	#include "uniconv.h"	uniconv/u8-strconv-from-locale.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [uniconv/u8-strconv-from-locale])	uniconv/base uniconv/u8-strconv-from-enc localcharset
uniconv/u16-strconv-from-locale	#include "uniconv.h"	uniconv/u16-strconv-from-locale.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [uniconv/u16-strconv-from-locale])	uniconv/base uniconv/u16-strconv-from-enc localcharset
uniconv/u32-strconv-from-locale	#include "uniconv.h"	uniconv/u32-strconv-from-locale.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [uniconv/u32-strconv-from-locale])	uniconv/base uniconv/u32-strconv-from-enc localcharset
uniconv/u8-strconv-to-locale	#include "uniconv.h"	uniconv/u8-strconv-to-locale.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [uniconv/u8-strconv-to-locale])	uniconv/base uniconv/u8-strconv-to-enc localcharset
uniconv/u16-strconv-to-locale	#include "uniconv.h"	uniconv/u16-strconv-to-locale.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [uniconv/u16-strconv-to-locale])	uniconv/base uniconv/u16-strconv-to-enc localcharset
uniconv/u32-strconv-to-locale	#include "uniconv.h"	uniconv/u32-strconv-to-locale.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [uniconv/u32-strconv-to-locale])	uniconv/base uniconv/u32-strconv-to-enc localcharset
unistdio/base	#include "unistdio.h"	unistdio.in.h	libunistring-base.m4 00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_LIBHEADER([0.9.11], [unistdio.h]) AC_PROG_MKDIR_P	gen-header unitypes-h
unistdio/u-printf-args	#include "unistdio/u-printf-args.h"	unistdio/u-printf-args.c printf-args.h printf-args.c	vasnprintf.m4 intmax_t.m4 stdint_h.m4 inttypes_h.m4 00gnulib.m4 zzgnulib.m4 gl_PREREQ_PRINTF_ARGS	stdint-h limits-h unitypes-h wchar-h
unistdio/ulc-asnprintf	#include "unistdio.h"	unistdio/ulc-asnprintf.c unistdio/u-asnprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.3]), [unistdio/ulc-asnprintf])	unistdio/base unistdio/ulc-vasnprintf
unistdio/ulc-asprintf	#include "unistdio.h"	unistdio/ulc-asprintf.c unistdio/u-asprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.3]), [unistdio/ulc-asprintf])	unistdio/base unistdio/ulc-vasprintf
unistdio/ulc-fprintf	#include "unistdio.h"	unistdio/ulc-fprintf.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.3]), [unistdio/ulc-fprintf])	unistdio/base unistdio/ulc-vasnprintf fseterr errno-h
unistdio/ulc-printf-parse	#include "unistdio/u-printf-parse.h"	unistdio/ulc-printf-parse.c printf-parse.h printf-parse.c	vasnprintf.m4 intmax_t.m4 stdint_h.m4 inttypes_h.m4 00gnulib.m4 zzgnulib.m4 gl_PREREQ_PRINTF_PARSE	unistdio/u-printf-args stdint-h xsize c-ctype
unistdio/ulc-snprintf	#include "unistdio.h"	unistdio/ulc-snprintf.c unistdio/u-snprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.3]), [unistdio/ulc-snprintf])	unistdio/base unistdio/ulc-vsnprintf
unistdio/ulc-sprintf	#include "unistdio.h"	unistdio/ulc-sprintf.c unistdio/u-sprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.3]), [unistdio/ulc-sprintf])	unistdio/base unistdio/ulc-vsprintf
unistdio/ulc-vasnprintf	#include "unistdio.h"	unistdio/ulc-vasnprintf.c vasnprintf.c	vasnprintf.m4 printf.m4 math_h.m4 wint_t.m4 intmax_t.m4 stdint_h.m4 inttypes_h.m4 exponentd.m4 00gnulib.m4 zzgnulib.m4 gl_PREREQ_VASNPRINTF_WITH_POSIX_EXTRAS gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.3]), [unistdio/ulc-vasnprintf])	unistdio/base unistdio/ulc-printf-parse unistdio/u-printf-args uniconv/u8-conv-to-enc uniconv/u16-conv-to-enc uniconv/u32-conv-to-enc unistr/u8-strlen unistr/u8-strmblen unistr/u16-strlen unistr/u16-strmblen unistr/u32-strlen unistr/u32-strmblen attribute stdint-h mbsnlen mixin/printf-posix nocrash printf-safe alloca-opt localcharset xsize errno-h free-posix localeconv memchr multiarch assert-h mbszero
unistdio/ulc-vasprintf	#include "unistdio.h"	unistdio/ulc-vasprintf.c unistdio/u-vasprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.3]), [unistdio/ulc-vasprintf])	unistdio/base unistdio/ulc-vasnprintf errno-h
unistdio/ulc-vfprintf	#include "unistdio.h"	unistdio/ulc-vfprintf.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.3]), [unistdio/ulc-vfprintf])	unistdio/base unistdio/ulc-vasnprintf fseterr errno-h
unistdio/ulc-vsnprintf	#include "unistdio.h"	unistdio/ulc-vsnprintf.c unistdio/u-vsnprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.3]), [unistdio/ulc-vsnprintf])	unistdio/base unistdio/ulc-vasnprintf errno-h
unistdio/ulc-vsprintf	#include "unistdio.h"	unistdio/ulc-vsprintf.c unistdio/u-vsprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.3]), [unistdio/ulc-vsprintf])	unistdio/base unistdio/ulc-vasnprintf stdint-h errno-h
unistdio/u8-asnprintf	#include "unistdio.h"	unistdio/u8-asnprintf.c unistdio/u-asnprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u8-asnprintf])	unistdio/base unistdio/u8-vasnprintf
unistdio/u8-asprintf	#include "unistdio.h"	unistdio/u8-asprintf.c unistdio/u-asprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u8-asprintf])	unistdio/base unistdio/u8-vasprintf
unistdio/u8-printf-parse	#include "unistdio/u-printf-parse.h"	unistdio/u8-printf-parse.c printf-parse.h printf-parse.c	vasnprintf.m4 intmax_t.m4 stdint_h.m4 inttypes_h.m4 00gnulib.m4 zzgnulib.m4 gl_PREREQ_PRINTF_PARSE	unistdio/u-printf-args stdint-h xsize
unistdio/u8-snprintf	#include "unistdio.h"	unistdio/u8-snprintf.c unistdio/u-snprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u8-snprintf])	unistdio/base unistdio/u8-vsnprintf
unistdio/u8-sprintf	#include "unistdio.h"	unistdio/u8-sprintf.c unistdio/u-sprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u8-sprintf])	unistdio/base unistdio/u8-vsprintf
unistdio/u8-vasnprintf	#include "unistdio.h"	unistdio/u8-vasnprintf.c vasnprintf.c	vasnprintf.m4 printf.m4 math_h.m4 wint_t.m4 intmax_t.m4 stdint_h.m4 inttypes_h.m4 exponentd.m4 00gnulib.m4 zzgnulib.m4 gl_PREREQ_VASNPRINTF_WITH_POSIX_EXTRAS gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u8-vasnprintf])	unistdio/base unistdio/ulc-printf-parse unistdio/u-printf-args uniconv/u8-conv-from-enc unistr/u8-cpy unistr/u8-set unistr/u8-mbsnlen unistr/u16-to-u8 unistr/u32-to-u8 unistr/u8-strlen unistr/u8-strmblen unistr/u16-strlen unistr/u16-strmblen unistr/u32-strlen unistr/u32-strmblen attribute stdint-h mixin/printf-posix nocrash printf-safe alloca-opt localcharset xsize errno-h free-posix localeconv memchr multiarch assert-h mbszero
unistdio/u8-vasprintf	#include "unistdio.h"	unistdio/u8-vasprintf.c unistdio/u-vasprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u8-vasprintf])	unistdio/base unistdio/u8-vasnprintf errno-h
unistdio/u8-vsnprintf	#include "unistdio.h"	unistdio/u8-vsnprintf.c unistdio/u-vsnprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u8-vsnprintf])	unistdio/base unistdio/u8-vasnprintf unistr/u8-cpy errno-h
unistdio/u8-vsprintf	#include "unistdio.h"	unistdio/u8-vsprintf.c unistdio/u-vsprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u8-vsprintf])	unistdio/base unistdio/u8-vasnprintf stdint-h errno-h
unistdio/u8-u8-asnprintf	#include "unistdio.h"	unistdio/u8-u8-asnprintf.c unistdio/u-asnprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u8-u8-asnprintf])	unistdio/base unistdio/u8-u8-vasnprintf
unistdio/u8-u8-asprintf	#include "unistdio.h"	unistdio/u8-u8-asprintf.c unistdio/u-asprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u8-u8-asprintf])	unistdio/base unistdio/u8-u8-vasprintf
unistdio/u8-u8-snprintf	#include "unistdio.h"	unistdio/u8-u8-snprintf.c unistdio/u-snprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u8-u8-snprintf])	unistdio/base unistdio/u8-u8-vsnprintf
unistdio/u8-u8-sprintf	#include "unistdio.h"	unistdio/u8-u8-sprintf.c unistdio/u-sprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u8-u8-sprintf])	unistdio/base unistdio/u8-u8-vsprintf
unistdio/u8-u8-vasnprintf	#include "unistdio.h"	unistdio/u8-u8-vasnprintf.c vasnprintf.c	vasnprintf.m4 printf.m4 math_h.m4 wint_t.m4 intmax_t.m4 stdint_h.m4 inttypes_h.m4 exponentd.m4 00gnulib.m4 zzgnulib.m4 gl_PREREQ_VASNPRINTF_WITH_POSIX_EXTRAS gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u8-u8-vasnprintf])	unistdio/base unistdio/u8-printf-parse unistdio/u-printf-args uniconv/u8-conv-from-enc unistr/u8-cpy unistr/u8-set unistr/u8-mbsnlen unistr/u16-to-u8 unistr/u32-to-u8 unistr/u8-strlen unistr/u8-strmblen unistr/u16-strlen unistr/u16-strmblen unistr/u32-strlen unistr/u32-strmblen attribute stdint-h mixin/printf-posix nocrash printf-safe alloca-opt localcharset xsize errno-h free-posix localeconv memchr multiarch assert-h mbszero
unistdio/u8-u8-vasprintf	#include "unistdio.h"	unistdio/u8-u8-vasprintf.c unistdio/u-vasprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u8-u8-vasprintf])	unistdio/base unistdio/u8-u8-vasnprintf errno-h
unistdio/u8-u8-vsnprintf	#include "unistdio.h"	unistdio/u8-u8-vsnprintf.c unistdio/u-vsnprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u8-u8-vsnprintf])	unistdio/base unistdio/u8-u8-vasnprintf unistr/u8-cpy errno-h
unistdio/u8-u8-vsprintf	#include "unistdio.h"	unistdio/u8-u8-vsprintf.c unistdio/u-vsprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u8-u8-vsprintf])	unistdio/base unistdio/u8-u8-vasnprintf stdint-h errno-h
unistdio/u16-asnprintf	#include "unistdio.h"	unistdio/u16-asnprintf.c unistdio/u-asnprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u16-asnprintf])	unistdio/base unistdio/u16-vasnprintf
unistdio/u16-asprintf	#include "unistdio.h"	unistdio/u16-asprintf.c unistdio/u-asprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u16-asprintf])	unistdio/base unistdio/u16-vasprintf
unistdio/u16-printf-parse	#include "unistdio/u-printf-parse.h"	unistdio/u16-printf-parse.c printf-parse.h printf-parse.c	vasnprintf.m4 intmax_t.m4 stdint_h.m4 inttypes_h.m4 00gnulib.m4 zzgnulib.m4 gl_PREREQ_PRINTF_PARSE	unistdio/u-printf-args stdint-h xsize
unistdio/u16-snprintf	#include "unistdio.h"	unistdio/u16-snprintf.c unistdio/u-snprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u16-snprintf])	unistdio/base unistdio/u16-vsnprintf
unistdio/u16-sprintf	#include "unistdio.h"	unistdio/u16-sprintf.c unistdio/u-sprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u16-sprintf])	unistdio/base unistdio/u16-vsprintf
unistdio/u16-vasnprintf	#include "unistdio.h"	unistdio/u16-vasnprintf.c vasnprintf.c	vasnprintf.m4 printf.m4 math_h.m4 wint_t.m4 intmax_t.m4 stdint_h.m4 inttypes_h.m4 exponentd.m4 00gnulib.m4 zzgnulib.m4 gl_PREREQ_VASNPRINTF_WITH_POSIX_EXTRAS gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u16-vasnprintf])	unistdio/base unistdio/ulc-printf-parse unistdio/u-printf-args uniconv/u16-conv-from-enc unistr/u16-cpy unistr/u16-set unistr/u16-mbsnlen unistr/u8-to-u16 unistr/u32-to-u16 unistr/u8-strlen unistr/u8-strmblen unistr/u16-strlen unistr/u16-strmblen unistr/u32-strlen unistr/u32-strmblen attribute stdint-h mixin/printf-posix nocrash printf-safe alloca-opt localcharset xsize errno-h free-posix localeconv memchr multiarch assert-h mbszero
unistdio/u16-vasprintf	#include "unistdio.h"	unistdio/u16-vasprintf.c unistdio/u-vasprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u16-vasprintf])	unistdio/base unistdio/u16-vasnprintf errno-h
unistdio/u16-vsnprintf	#include "unistdio.h"	unistdio/u16-vsnprintf.c unistdio/u-vsnprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u16-vsnprintf])	unistdio/base unistdio/u16-vasnprintf unistr/u16-cpy errno-h
unistdio/u16-vsprintf	#include "unistdio.h"	unistdio/u16-vsprintf.c unistdio/u-vsprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u16-vsprintf])	unistdio/base unistdio/u16-vasnprintf stdint-h errno-h
unistdio/u16-u16-asnprintf	#include "unistdio.h"	unistdio/u16-u16-asnprintf.c unistdio/u-asnprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u16-u16-asnprintf])	unistdio/base unistdio/u16-u16-vasnprintf
unistdio/u16-u16-asprintf	#include "unistdio.h"	unistdio/u16-u16-asprintf.c unistdio/u-asprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u16-u16-asprintf])	unistdio/base unistdio/u16-u16-vasprintf
unistdio/u16-u16-snprintf	#include "unistdio.h"	unistdio/u16-u16-snprintf.c unistdio/u-snprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u16-u16-snprintf])	unistdio/base unistdio/u16-u16-vsnprintf
unistdio/u16-u16-sprintf	#include "unistdio.h"	unistdio/u16-u16-sprintf.c unistdio/u-sprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u16-u16-sprintf])	unistdio/base unistdio/u16-u16-vsprintf
unistdio/u16-u16-vasnprintf	#include "unistdio.h"	unistdio/u16-u16-vasnprintf.c vasnprintf.c	vasnprintf.m4 printf.m4 math_h.m4 wint_t.m4 intmax_t.m4 stdint_h.m4 inttypes_h.m4 exponentd.m4 00gnulib.m4 zzgnulib.m4 gl_PREREQ_VASNPRINTF_WITH_POSIX_EXTRAS gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u16-u16-vasnprintf])	unistdio/base unistdio/u16-printf-parse unistdio/u-printf-args uniconv/u16-conv-from-enc unistr/u16-cpy unistr/u16-set unistr/u16-mbsnlen unistr/u8-to-u16 unistr/u32-to-u16 unistr/u8-strlen unistr/u8-strmblen unistr/u16-strlen unistr/u16-strmblen unistr/u32-strlen unistr/u32-strmblen attribute stdint-h mixin/printf-posix nocrash printf-safe alloca-opt localcharset xsize errno-h free-posix localeconv memchr multiarch assert-h mbszero
unistdio/u16-u16-vasprintf	#include "unistdio.h"	unistdio/u16-u16-vasprintf.c unistdio/u-vasprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u16-u16-vasprintf])	unistdio/base unistdio/u16-u16-vasnprintf errno-h
unistdio/u16-u16-vsnprintf	#include "unistdio.h"	unistdio/u16-u16-vsnprintf.c unistdio/u-vsnprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u16-u16-vsnprintf])	unistdio/base unistdio/u16-u16-vasnprintf unistr/u16-cpy errno-h
unistdio/u16-u16-vsprintf	#include "unistdio.h"	unistdio/u16-u16-vsprintf.c unistdio/u-vsprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u16-u16-vsprintf])	unistdio/base unistdio/u16-u16-vasnprintf stdint-h errno-h
unistdio/u32-asnprintf	#include "unistdio.h"	unistdio/u32-asnprintf.c unistdio/u-asnprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u32-asnprintf])	unistdio/base unistdio/u32-vasnprintf
unistdio/u32-asprintf	#include "unistdio.h"	unistdio/u32-asprintf.c unistdio/u-asprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u32-asprintf])	unistdio/base unistdio/u32-vasprintf
unistdio/u32-printf-parse	#include "unistdio/u-printf-parse.h"	unistdio/u32-printf-parse.c printf-parse.h printf-parse.c	vasnprintf.m4 intmax_t.m4 stdint_h.m4 inttypes_h.m4 00gnulib.m4 zzgnulib.m4 gl_PREREQ_PRINTF_PARSE	unistdio/u-printf-args stdint-h xsize
unistdio/u32-snprintf	#include "unistdio.h"	unistdio/u32-snprintf.c unistdio/u-snprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u32-snprintf])	unistdio/base unistdio/u32-vsnprintf
unistdio/u32-sprintf	#include "unistdio.h"	unistdio/u32-sprintf.c unistdio/u-sprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u32-sprintf])	unistdio/base unistdio/u32-vsprintf
unistdio/u32-vasnprintf	#include "unistdio.h"	unistdio/u32-vasnprintf.c vasnprintf.c	vasnprintf.m4 printf.m4 math_h.m4 wint_t.m4 intmax_t.m4 stdint_h.m4 inttypes_h.m4 exponentd.m4 00gnulib.m4 zzgnulib.m4 gl_PREREQ_VASNPRINTF_WITH_POSIX_EXTRAS gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u32-vasnprintf])	unistdio/base unistdio/ulc-printf-parse unistdio/u-printf-args uniconv/u32-conv-from-enc unistr/u32-cpy unistr/u32-set unistr/u32-mbsnlen unistr/u8-to-u32 unistr/u16-to-u32 unistr/u8-strlen unistr/u8-strmblen unistr/u16-strlen unistr/u16-strmblen unistr/u32-strlen unistr/u32-strmblen attribute stdint-h mixin/printf-posix nocrash printf-safe alloca-opt localcharset xsize errno-h free-posix localeconv memchr multiarch assert-h mbszero
unistdio/u32-vasprintf	#include "unistdio.h"	unistdio/u32-vasprintf.c unistdio/u-vasprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u32-vasprintf])	unistdio/base unistdio/u32-vasnprintf errno-h
unistdio/u32-vsnprintf	#include "unistdio.h"	unistdio/u32-vsnprintf.c unistdio/u-vsnprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u32-vsnprintf])	unistdio/base unistdio/u32-vasnprintf unistr/u32-cpy errno-h
unistdio/u32-vsprintf	#include "unistdio.h"	unistdio/u32-vsprintf.c unistdio/u-vsprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u32-vsprintf])	unistdio/base unistdio/u32-vasnprintf stdint-h errno-h
unistdio/u32-u32-asnprintf	#include "unistdio.h"	unistdio/u32-u32-asnprintf.c unistdio/u-asnprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u32-u32-asnprintf])	unistdio/base unistdio/u32-u32-vasnprintf
unistdio/u32-u32-asprintf	#include "unistdio.h"	unistdio/u32-u32-asprintf.c unistdio/u-asprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u32-u32-asprintf])	unistdio/base unistdio/u32-u32-vasprintf
unistdio/u32-u32-snprintf	#include "unistdio.h"	unistdio/u32-u32-snprintf.c unistdio/u-snprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u32-u32-snprintf])	unistdio/base unistdio/u32-u32-vsnprintf
unistdio/u32-u32-sprintf	#include "unistdio.h"	unistdio/u32-u32-sprintf.c unistdio/u-sprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u32-u32-sprintf])	unistdio/base unistdio/u32-u32-vsprintf
unistdio/u32-u32-vasnprintf	#include "unistdio.h"	unistdio/u32-u32-vasnprintf.c vasnprintf.c	vasnprintf.m4 printf.m4 math_h.m4 wint_t.m4 intmax_t.m4 stdint_h.m4 inttypes_h.m4 exponentd.m4 00gnulib.m4 zzgnulib.m4 gl_PREREQ_VASNPRINTF_WITH_POSIX_EXTRAS gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u32-u32-vasnprintf])	unistdio/base unistdio/u32-printf-parse unistdio/u-printf-args uniconv/u32-conv-from-enc unistr/u32-cpy unistr/u32-set unistr/u32-mbsnlen unistr/u8-to-u32 unistr/u16-to-u32 unistr/u8-strlen unistr/u8-strmblen unistr/u16-strlen unistr/u16-strmblen unistr/u32-strlen unistr/u32-strmblen attribute stdint-h mixin/printf-posix nocrash printf-safe alloca-opt localcharset xsize errno-h free-posix localeconv memchr multiarch assert-h mbszero
unistdio/u32-u32-vasprintf	#include "unistdio.h"	unistdio/u32-u32-vasprintf.c unistdio/u-vasprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u32-u32-vasprintf])	unistdio/base unistdio/u32-u32-vasnprintf errno-h
unistdio/u32-u32-vsnprintf	#include "unistdio.h"	unistdio/u32-u32-vsnprintf.c unistdio/u-vsnprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u32-u32-vsnprintf])	unistdio/base unistdio/u32-u32-vasnprintf unistr/u32-cpy errno-h
unistdio/u32-u32-vsprintf	#include "unistdio.h"	unistdio/u32-u32-vsprintf.c unistdio/u-vsprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE(m4_ifdef([gl_PRINTF_SUPPORT_N_DIRECTIVE],[999.9],[1.2]), [unistdio/u32-u32-vsprintf])	unistdio/base unistdio/u32-u32-vasnprintf stdint-h errno-h
uniname/base	#include "uniname.h"	uniname.in.h	libunistring-base.m4 00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_LIBHEADER([0.9.5], [uniname.h]) AC_PROG_MKDIR_P	gen-header unitypes-h
uniname/uniname	#include "uniname.h"	uniname/gen-uninames.lisp uniname/uninames.h uniname/uniname.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [uniname/uniname])	uniname/base attribute memcmp bool c99
unictype/base	#include "unictype.h"	unictype.in.h	libunistring-base.m4 unictype_h.m4 00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_LIBHEADER([1.3], [unictype.h]) gl_UNICTYPE_H gl_UNICTYPE_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	gen-header unitypes-h bool
unictype/bidiclass-byname	#include "unictype.h"	unictype/bidi_byname.c unictype/bidi_byname.gperf	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9.11], [unictype/bidiclass-byname])	unictype/base gperf
unictype/bidiclass-name	#include "unictype.h"	unictype/bidi_name.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9.11], [unictype/bidiclass-name])	unictype/base
unictype/bidiclass-longname	#include "unictype.h"	unictype/bidi_longname.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9.11], [unictype/bidiclass-longname])	unictype/base
unictype/bidiclass-of	#include "unictype.h"	unictype/bidi_of.c unictype/bidi_of.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unictype/bidiclass-of])	unictype/base
unictype/bidiclass-test	#include "unictype.h"	unictype/bidi_test.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unictype/bidiclass-test])	unictype/base unictype/bidiclass-of
unictype/bidiclass-all	#include "unictype.h"	---	00gnulib.m4 zzgnulib.m4	unictype/base unictype/bidiclass-byname unictype/bidiclass-longname unictype/bidiclass-name unictype/bidiclass-of unictype/bidiclass-test
unictype/block-list	#include "unictype.h"	unictype/blocks.c unictype/blocks.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unictype/block-list])	unictype/base
unictype/block-of	#include "unictype.h"	---	00gnulib.m4 zzgnulib.m4	unictype/base unictype/block-list
unictype/block-test	#include "unictype.h"	unictype/block_test.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9.11], [unictype/block-test])	unictype/base
unictype/block-all	#include "unictype.h"	---	00gnulib.m4 zzgnulib.m4	unictype/block-of unictype/block-test unictype/block-list
unictype/category-C	#include "unictype.h"	unictype/categ_C.c unictype/categ_C.h	00gnulib.m4 zzgnulib.m4 gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/category-C])	unictype/base
unictype/category-Cc	#include "unictype.h"	unictype/categ_Cc.c unictype/categ_Cc.h	00gnulib.m4 zzgnulib.m4 gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.8], [unictype/category-Cc])	unictype/base
unictype/category-Cf	#include "unictype.h"	unictype/categ_Cf.c unictype/categ_Cf.h	00gnulib.m4 zzgnulib.m4 gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.1], [unictype/category-Cf])	unictype/base
unictype/category-Cn	#include "unictype.h"	unictype/categ_Cn.c unictype/categ_Cn.h	00gnulib.m4 zzgnulib.m4 gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/category-Cn])	unictype/base
unictype/category-Co	#include "unictype.h"	unictype/categ_Co.c unictype/categ_Co.h	00gnulib.m4 zzgnulib.m4 gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.8], [unictype/category-Co])	unictype/base
unictype/category-Cs	#include "unictype.h"	unictype/categ_Cs.c unictype/categ_Cs.h	00gnulib.m4 zzgnulib.m4 gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.8], [unictype/category-Cs])	unictype/base
unictype/category-L	#include "unictype.h"	unictype/categ_L.c unictype/categ_L.h	00gnulib.m4 zzgnulib.m4 gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/category-L])	unictype/base
unictype/category-Ll	#include "unictype.h"	unictype/categ_Ll.c unictype/categ_Ll.h	00gnulib.m4 zzgnulib.m4 gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/category-Ll])	unictype/base
unictype/category-Lm	#include "unictype.h"	unictype/categ_Lm.c unictype/categ_Lm.h	00gnulib.m4 zzgnulib.m4 gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/category-Lm])	unictype/base
unictype/category-Lo	#include "unictype.h"	unictype/categ_Lo.c unictype/categ_Lo.h	00gnulib.m4 zzgnulib.m4 gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/category-Lo])	unictype/base
unictype/category-Lt	#include "unictype.h"	unictype/categ_Lt.c unictype/categ_Lt.h	00gnulib.m4 zzgnulib.m4 gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.8], [unictype/category-Lt])	unictype/base
unictype/category-Lu	#include "unictype.h"	unictype/categ_Lu.c unictype/categ_Lu.h	00gnulib.m4 zzgnulib.m4 gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/category-Lu])	unictype/base
unictype/category-M	#include "unictype.h"	unictype/categ_M.c unictype/categ_M.h	00gnulib.m4 zzgnulib.m4 gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/category-M])	unictype/base
unictype/category-Mc	#include "unictype.h"	unictype/categ_Mc.c unictype/categ_Mc.h	00gnulib.m4 zzgnulib.m4 gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/category-Mc])	unictype/base
unictype/category-Me	#include "unictype.h"	unictype/categ_Me.c unictype/categ_Me.h	00gnulib.m4 zzgnulib.m4 gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.8], [unictype/category-Me])	unictype/base
unictype/category-Mn	#include "unictype.h"	unictype/categ_Mn.c unictype/categ_Mn.h	00gnulib.m4 zzgnulib.m4 gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/category-Mn])	unictype/base
unictype/category-N	#include "unictype.h"	unictype/categ_N.c unictype/categ_N.h	00gnulib.m4 zzgnulib.m4 gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/category-N])	unictype/base
unictype/category-Nd	#include "unictype.h"	unictype/categ_Nd.c unictype/categ_Nd.h	00gnulib.m4 zzgnulib.m4 gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/category-Nd])	unictype/base
unictype/category-Nl	#include "unictype.h"	unictype/categ_Nl.c unictype/categ_Nl.h	00gnulib.m4 zzgnulib.m4 gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.8], [unictype/category-Nl])	unictype/base
unictype/category-No	#include "unictype.h"	unictype/categ_No.c unictype/categ_No.h	00gnulib.m4 zzgnulib.m4 gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.1], [unictype/category-No])	unictype/base
unictype/category-P	#include "unictype.h"	unictype/categ_P.c unictype/categ_P.h	00gnulib.m4 zzgnulib.m4 gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/category-P])	unictype/base
unictype/category-Pc	#include "unictype.h"	unictype/categ_Pc.c unictype/categ_Pc.h	00gnulib.m4 zzgnulib.m4 gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.8], [unictype/category-Pc])	unictype/base
unictype/category-Pd	#include "unictype.h"	unictype/categ_Pd.c unictype/categ_Pd.h	00gnulib.m4 zzgnulib.m4 gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/category-Pd])	unictype/base
unictype/category-Pe	#include "unictype.h"	unictype/categ_Pe.c unictype/categ_Pe.h	00gnulib.m4 zzgnulib.m4 gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.11], [unictype/category-Pe])	unictype/base
unictype/category-Pf	#include "unictype.h"	unictype/categ_Pf.c unictype/categ_Pf.h	00gnulib.m4 zzgnulib.m4 gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.8], [unictype/category-Pf])	unictype/base
unictype/category-Pi	#include "unictype.h"	unictype/categ_Pi.c unictype/categ_Pi.h	00gnulib.m4 zzgnulib.m4 gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.8], [unictype/category-Pi])	unictype/base
unictype/category-Po	#include "unictype.h"	unictype/categ_Po.c unictype/categ_Po.h	00gnulib.m4 zzgnulib.m4 gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/category-Po])	unictype/base
unictype/category-Ps	#include "unictype.h"	unictype/categ_Ps.c unictype/categ_Ps.h	00gnulib.m4 zzgnulib.m4 gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.11], [unictype/category-Ps])	unictype/base
unictype/category-S	#include "unictype.h"	unictype/categ_S.c unictype/categ_S.h	00gnulib.m4 zzgnulib.m4 gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/category-S])	unictype/base
unictype/category-Sc	#include "unictype.h"	unictype/categ_Sc.c unictype/categ_Sc.h	00gnulib.m4 zzgnulib.m4 gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.11], [unictype/category-Sc])	unictype/base
unictype/category-Sk	#include "unictype.h"	unictype/categ_Sk.c unictype/categ_Sk.h	00gnulib.m4 zzgnulib.m4 gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.11], [unictype/category-Sk])	unictype/base
unictype/category-Sm	#include "unictype.h"	unictype/categ_Sm.c unictype/categ_Sm.h	00gnulib.m4 zzgnulib.m4 gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/category-Sm])	unictype/base
unictype/category-So	#include "unictype.h"	unictype/categ_So.c unictype/categ_So.h	00gnulib.m4 zzgnulib.m4 gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/category-So])	unictype/base
unictype/category-Z	#include "unictype.h"	unictype/categ_Z.c unictype/categ_Z.h	00gnulib.m4 zzgnulib.m4 gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.8], [unictype/category-Z])	unictype/base
unictype/category-Zl	#include "unictype.h"	unictype/categ_Zl.c unictype/categ_Zl.h	00gnulib.m4 zzgnulib.m4 gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.8], [unictype/category-Zl])	unictype/base
unictype/category-Zp	#include "unictype.h"	unictype/categ_Zp.c unictype/categ_Zp.h	00gnulib.m4 zzgnulib.m4 gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.8], [unictype/category-Zp])	unictype/base
unictype/category-Zs	#include "unictype.h"	unictype/categ_Zs.c unictype/categ_Zs.h	00gnulib.m4 zzgnulib.m4 gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.8], [unictype/category-Zs])	unictype/base
unictype/category-and	#include "unictype.h"	unictype/categ_and.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unictype/category-and])	unictype/base unictype/category-none unictype/category-test-withtable
unictype/category-and-not	#include "unictype.h"	unictype/categ_and_not.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unictype/category-and-not])	unictype/base unictype/category-none unictype/category-test-withtable
unictype/category-byname	#include "unictype.h"	unictype/categ_byname.c unictype/categ_byname.gperf	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unictype/category-byname])	unictype/base unictype/category-C unictype/category-Cc unictype/category-Cf unictype/category-Cn unictype/category-Co unictype/category-Cs unictype/category-L unictype/category-LC unictype/category-Ll unictype/category-Lm unictype/category-Lo unictype/category-Lt unictype/category-Lu unictype/category-M unictype/category-Mc unictype/category-Me unictype/category-Mn unictype/category-N unictype/category-Nd unictype/category-Nl unictype/category-No unictype/category-P unictype/category-Pc unictype/category-Pd unictype/category-Pe unictype/category-Pf unictype/category-Pi unictype/category-Po unictype/category-Ps unictype/category-S unictype/category-Sc unictype/category-Sk unictype/category-Sm unictype/category-So unictype/category-Z unictype/category-Zl unictype/category-Zp unictype/category-Zs unictype/category-none gperf
unictype/category-name	#include "unictype.h"	unictype/categ_name.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9.8], [unictype/category-name])	unictype/base
unictype/category-none	#include "unictype.h"	unictype/categ_none.c	00gnulib.m4 zzgnulib.m4 dnl Since _UC_CATEGORY_NONE is not exported from an installed libunistring, dnl don't use gl_LIBUNISTRING_MODULE here.	unictype/base
unictype/category-of	#include "unictype.h"	unictype/categ_of.c unictype/categ_of.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([1.3], [unictype/category-of])	unictype/base unictype/category-none
unictype/category-or	#include "unictype.h"	unictype/categ_or.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unictype/category-or])	unictype/base unictype/category-test-withtable
unictype/category-test	#include "unictype.h"	unictype/categ_test.c unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.8], [unictype/category-test])	unictype/base
unictype/category-test-withtable	#include "unictype.h"	---	00gnulib.m4 zzgnulib.m4	unictype/base unictype/category-of
unictype/category-all	#include "unictype.h"	---	00gnulib.m4 zzgnulib.m4	unictype/category-C unictype/category-Cc unictype/category-Cf unictype/category-Cn unictype/category-Co unictype/category-Cs unictype/category-L unictype/category-LC unictype/category-Ll unictype/category-Lm unictype/category-Lo unictype/category-Lt unictype/category-Lu unictype/category-M unictype/category-Mc unictype/category-Me unictype/category-Mn unictype/category-N unictype/category-Nd unictype/category-Nl unictype/category-No unictype/category-P unictype/category-Pc unictype/category-Pd unictype/category-Pe unictype/category-Pf unictype/category-Pi unictype/category-Po unictype/category-Ps unictype/category-S unictype/category-Sc unictype/category-Sk unictype/category-Sm unictype/category-So unictype/category-Z unictype/category-Zl unictype/category-Zp unictype/category-Zs unictype/category-and unictype/category-and-not unictype/category-byname unictype/category-longname unictype/category-name unictype/category-of unictype/category-or unictype/category-test unictype/category-test-withtable
unictype/combining-class	#include "unictype.h"	unictype/combiningclass.c unictype/combiningclass.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unictype/combining-class])	unictype/base
unictype/ctype-alnum	#include "unictype.h"	unictype/ctype_alnum.c unictype/ctype_alnum.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([1.3], [unictype/ctype-alnum])	unictype/base
unictype/ctype-alpha	#include "unictype.h"	unictype/ctype_alpha.c unictype/ctype_alpha.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([1.3], [unictype/ctype-alpha])	unictype/base
unictype/ctype-blank	#include "unictype.h"	unictype/ctype_blank.c unictype/ctype_blank.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.8], [unictype/ctype-blank])	unictype/base
unictype/ctype-cntrl	#include "unictype.h"	unictype/ctype_cntrl.c unictype/ctype_cntrl.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.8], [unictype/ctype-cntrl])	unictype/base
unictype/ctype-digit	#include "unictype.h"	unictype/ctype_digit.c unictype/ctype_digit.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.8], [unictype/ctype-digit])	unictype/base
unictype/ctype-graph	#include "unictype.h"	unictype/ctype_graph.c unictype/ctype_graph.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([1.3], [unictype/ctype-graph])	unictype/base
unictype/ctype-lower	#include "unictype.h"	unictype/ctype_lower.c unictype/ctype_lower.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([1.3], [unictype/ctype-lower])	unictype/base
unictype/ctype-print	#include "unictype.h"	unictype/ctype_print.c unictype/ctype_print.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([1.3], [unictype/ctype-print])	unictype/base
unictype/ctype-punct	#include "unictype.h"	unictype/ctype_punct.c unictype/ctype_punct.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([1.3], [unictype/ctype-punct])	unictype/base
unictype/ctype-space	#include "unictype.h"	unictype/ctype_space.c unictype/ctype_space.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.8], [unictype/ctype-space])	unictype/base
unictype/ctype-upper	#include "unictype.h"	unictype/ctype_upper.c unictype/ctype_upper.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([1.3], [unictype/ctype-upper])	unictype/base
unictype/ctype-xdigit	#include "unictype.h"	unictype/ctype_xdigit.c unictype/ctype_xdigit.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.8], [unictype/ctype-xdigit])	unictype/base
unictype/decimal-digit	#include "unictype.h"	unictype/decdigit.c unictype/decdigit.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unictype/decimal-digit])	unictype/base
unictype/digit	#include "unictype.h"	unictype/digit.c unictype/digit.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unictype/digit])	unictype/base
unictype/mirror	#include "unictype.h"	unictype/mirror.c unictype/mirror.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unictype/mirror])	unictype/base
unictype/numeric	#include "unictype.h"	unictype/numeric.c unictype/numeric.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unictype/numeric])	unictype/base
unictype/property-alphabetic	#include "unictype.h"	unictype/pr_alphabetic.c unictype/pr_alphabetic.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-alphabetic])	unictype/base
unictype/property-ascii-hex-digit	#include "unictype.h"	unictype/pr_ascii_hex_digit.c unictype/pr_ascii_hex_digit.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.8], [unictype/property-ascii-hex-digit])	unictype/base
unictype/property-bidi-arabic-digit	#include "unictype.h"	unictype/pr_bidi_arabic_digit.c unictype/pr_bidi_arabic_digit.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-bidi-arabic-digit])	unictype/base unictype/bidiclass-of
unictype/property-bidi-arabic-right-to-left	#include "unictype.h"	unictype/pr_bidi_arabic_right_to_left.c unictype/pr_bidi_arabic_right_to_left.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-bidi-arabic-right-to-left])	unictype/base unictype/bidiclass-of
unictype/property-bidi-block-separator	#include "unictype.h"	unictype/pr_bidi_block_separator.c unictype/pr_bidi_block_separator.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-bidi-block-separator])	unictype/base unictype/bidiclass-of
unictype/property-bidi-boundary-neutral	#include "unictype.h"	unictype/pr_bidi_boundary_neutral.c unictype/pr_bidi_boundary_neutral.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-bidi-boundary-neutral])	unictype/base unictype/bidiclass-of
unictype/property-bidi-common-separator	#include "unictype.h"	unictype/pr_bidi_common_separator.c unictype/pr_bidi_common_separator.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-bidi-common-separator])	unictype/base unictype/bidiclass-of
unictype/property-bidi-control	#include "unictype.h"	unictype/pr_bidi_control.c unictype/pr_bidi_control.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-bidi-control])	unictype/base unictype/bidiclass-of
unictype/property-bidi-embedding-or-override	#include "unictype.h"	unictype/pr_bidi_embedding_or_override.c unictype/pr_bidi_embedding_or_override.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-bidi-embedding-or-override])	unictype/base unictype/bidiclass-of
unictype/property-bidi-eur-num-separator	#include "unictype.h"	unictype/pr_bidi_eur_num_separator.c unictype/pr_bidi_eur_num_separator.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-bidi-eur-num-separator])	unictype/base unictype/bidiclass-of
unictype/property-bidi-eur-num-terminator	#include "unictype.h"	unictype/pr_bidi_eur_num_terminator.c unictype/pr_bidi_eur_num_terminator.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-bidi-eur-num-terminator])	unictype/base unictype/bidiclass-of
unictype/property-bidi-european-digit	#include "unictype.h"	unictype/pr_bidi_european_digit.c unictype/pr_bidi_european_digit.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-bidi-european-digit])	unictype/base unictype/bidiclass-of
unictype/property-bidi-hebrew-right-to-left	#include "unictype.h"	unictype/pr_bidi_hebrew_right_to_left.c unictype/pr_bidi_hebrew_right_to_left.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-bidi-hebrew-right-to-left])	unictype/base unictype/bidiclass-of
unictype/property-bidi-left-to-right	#include "unictype.h"	unictype/pr_bidi_left_to_right.c unictype/pr_bidi_left_to_right.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-bidi-left-to-right])	unictype/base unictype/bidiclass-of
unictype/property-bidi-non-spacing-mark	#include "unictype.h"	unictype/pr_bidi_non_spacing_mark.c unictype/pr_bidi_non_spacing_mark.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-bidi-non-spacing-mark])	unictype/base unictype/bidiclass-of
unictype/property-bidi-other-neutral	#include "unictype.h"	unictype/pr_bidi_other_neutral.c unictype/pr_bidi_other_neutral.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-bidi-other-neutral])	unictype/base unictype/bidiclass-of
unictype/property-bidi-pdf	#include "unictype.h"	unictype/pr_bidi_pdf.c unictype/pr_bidi_pdf.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-bidi-pdf])	unictype/base unictype/bidiclass-of
unictype/property-bidi-segment-separator	#include "unictype.h"	unictype/pr_bidi_segment_separator.c unictype/pr_bidi_segment_separator.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-bidi-segment-separator])	unictype/base unictype/bidiclass-of
unictype/property-bidi-whitespace	#include "unictype.h"	unictype/pr_bidi_whitespace.c unictype/pr_bidi_whitespace.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-bidi-whitespace])	unictype/base unictype/bidiclass-of
unictype/property-byname	#include "unictype.h"	unictype/pr_byname.c unictype/pr_byname.gperf	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unictype/property-byname])	unictype/base unictype/property-alphabetic unictype/property-ascii-hex-digit unictype/property-bidi-arabic-digit unictype/property-bidi-arabic-right-to-left unictype/property-bidi-block-separator unictype/property-bidi-boundary-neutral unictype/property-bidi-common-separator unictype/property-bidi-control unictype/property-bidi-embedding-or-override unictype/property-bidi-eur-num-separator unictype/property-bidi-eur-num-terminator unictype/property-bidi-european-digit unictype/property-bidi-hebrew-right-to-left unictype/property-bidi-left-to-right unictype/property-bidi-non-spacing-mark unictype/property-bidi-other-neutral unictype/property-bidi-pdf unictype/property-bidi-segment-separator unictype/property-bidi-whitespace unictype/property-case-ignorable unictype/property-cased unictype/property-changes-when-casefolded unictype/property-changes-when-casemapped unictype/property-changes-when-lowercased unictype/property-changes-when-titlecased unictype/property-changes-when-uppercased unictype/property-combining unictype/property-composite unictype/property-currency-symbol unictype/property-dash unictype/property-decimal-digit unictype/property-default-ignorable-code-point unictype/property-deprecated unictype/property-diacritic unictype/property-extender unictype/property-format-control unictype/property-grapheme-base unictype/property-grapheme-extend unictype/property-grapheme-link unictype/property-hex-digit unictype/property-hyphen unictype/property-id-compat-math-continue unictype/property-id-compat-math-start unictype/property-id-continue unictype/property-id-start unictype/property-ideographic unictype/property-ids-binary-operator unictype/property-ids-trinary-operator unictype/property-ids-unary-operator unictype/property-ignorable-control unictype/property-iso-control unictype/property-join-control unictype/property-left-of-pair unictype/property-line-separator unictype/property-logical-order-exception unictype/property-lowercase unictype/property-math unictype/property-modifier-combining-mark unictype/property-non-break unictype/property-not-a-character unictype/property-numeric unictype/property-other-alphabetic unictype/property-other-default-ignorable-code-point unictype/property-other-grapheme-extend unictype/property-other-id-continue unictype/property-other-id-start unictype/property-other-lowercase unictype/property-other-math unictype/property-other-uppercase unictype/property-paired-punctuation unictype/property-paragraph-separator unictype/property-pattern-syntax unictype/property-pattern-white-space unictype/property-prepended-concatenation-mark unictype/property-private-use unictype/property-punctuation unictype/property-quotation-mark unictype/property-radical unictype/property-regional-indicator unictype/property-sentence-terminal unictype/property-soft-dotted unictype/property-space unictype/property-terminal-punctuation unictype/property-titlecase unictype/property-unassigned-code-value unictype/property-unified-ideograph unictype/property-uppercase unictype/property-variation-selector unictype/property-white-space unictype/property-xid-continue unictype/property-xid-start unictype/property-zero-width gperf
unictype/property-case-ignorable	#include "unictype.h"	unictype/pr_case_ignorable.c unictype/pr_case_ignorable.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-case-ignorable])	unictype/base
unictype/property-cased	#include "unictype.h"	unictype/pr_cased.c unictype/pr_cased.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-cased])	unictype/base
unictype/property-changes-when-casefolded	#include "unictype.h"	unictype/pr_changes_when_casefolded.c unictype/pr_changes_when_casefolded.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-changes-when-casefolded])	unictype/base
unictype/property-changes-when-casemapped	#include "unictype.h"	unictype/pr_changes_when_casemapped.c unictype/pr_changes_when_casemapped.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-changes-when-casemapped])	unictype/base
unictype/property-changes-when-lowercased	#include "unictype.h"	unictype/pr_changes_when_lowercased.c unictype/pr_changes_when_lowercased.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-changes-when-lowercased])	unictype/base
unictype/property-changes-when-titlecased	#include "unictype.h"	unictype/pr_changes_when_titlecased.c unictype/pr_changes_when_titlecased.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-changes-when-titlecased])	unictype/base
unictype/property-changes-when-uppercased	#include "unictype.h"	unictype/pr_changes_when_uppercased.c unictype/pr_changes_when_uppercased.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-changes-when-uppercased])	unictype/base
unictype/property-combining	#include "unictype.h"	unictype/pr_combining.c unictype/pr_combining.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-combining])	unictype/base
unictype/property-composite	#include "unictype.h"	unictype/pr_composite.c unictype/pr_composite.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-composite])	unictype/base
unictype/property-currency-symbol	#include "unictype.h"	unictype/pr_currency_symbol.c unictype/pr_currency_symbol.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.11], [unictype/property-currency-symbol])	unictype/base unictype/category-test unictype/category-Sc
unictype/property-dash	#include "unictype.h"	unictype/pr_dash.c unictype/pr_dash.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-dash])	unictype/base
unictype/property-decimal-digit	#include "unictype.h"	unictype/pr_decimal_digit.c unictype/pr_decimal_digit.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-decimal-digit])	unictype/base unictype/category-test unictype/category-Nd
unictype/property-default-ignorable-code-point	#include "unictype.h"	unictype/pr_default_ignorable_code_point.c unictype/pr_default_ignorable_code_point.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.11], [unictype/property-default-ignorable-code-point])	unictype/base
unictype/property-deprecated	#include "unictype.h"	unictype/pr_deprecated.c unictype/pr_deprecated.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.8], [unictype/property-deprecated])	unictype/base
unictype/property-diacritic	#include "unictype.h"	unictype/pr_diacritic.c unictype/pr_diacritic.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-diacritic])	unictype/base
unictype/property-extender	#include "unictype.h"	unictype/pr_extender.c unictype/pr_extender.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-extender])	unictype/base
unictype/property-format-control	#include "unictype.h"	unictype/pr_format_control.c unictype/pr_format_control.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.8], [unictype/property-format-control])	unictype/base
unictype/property-grapheme-base	#include "unictype.h"	unictype/pr_grapheme_base.c unictype/pr_grapheme_base.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-grapheme-base])	unictype/base
unictype/property-grapheme-extend	#include "unictype.h"	unictype/pr_grapheme_extend.c unictype/pr_grapheme_extend.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-grapheme-extend])	unictype/base
unictype/property-grapheme-link	#include "unictype.h"	unictype/pr_grapheme_link.c unictype/pr_grapheme_link.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-grapheme-link])	unictype/base
unictype/property-hex-digit	#include "unictype.h"	unictype/pr_hex_digit.c unictype/pr_hex_digit.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.8], [unictype/property-hex-digit])	unictype/base
unictype/property-hyphen	#include "unictype.h"	unictype/pr_hyphen.c unictype/pr_hyphen.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.8], [unictype/property-hyphen])	unictype/base
unictype/property-id-compat-math-continue	#include "unictype.h"	unictype/pr_id_compat_math_continue.c unictype/pr_id_compat_math_continue.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.2], [unictype/property-id-compat-math-continue])	unictype/base
unictype/property-id-compat-math-start	#include "unictype.h"	unictype/pr_id_compat_math_start.c unictype/pr_id_compat_math_start.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.2], [unictype/property-id-compat-math-start])	unictype/base
unictype/property-id-continue	#include "unictype.h"	unictype/pr_id_continue.c unictype/pr_id_continue.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-id-continue])	unictype/base
unictype/property-id-start	#include "unictype.h"	unictype/pr_id_start.c unictype/pr_id_start.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-id-start])	unictype/base
unictype/property-ideographic	#include "unictype.h"	unictype/pr_ideographic.c unictype/pr_ideographic.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-ideographic])	unictype/base
unictype/property-ids-binary-operator	#include "unictype.h"	unictype/pr_ids_binary_operator.c unictype/pr_ids_binary_operator.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.2], [unictype/property-ids-binary-operator])	unictype/base
unictype/property-ids-trinary-operator	#include "unictype.h"	unictype/pr_ids_trinary_operator.c unictype/pr_ids_trinary_operator.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.8], [unictype/property-ids-trinary-operator])	unictype/base
unictype/property-ids-unary-operator	#include "unictype.h"	unictype/pr_ids_unary_operator.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.2], [unictype/property-ids-unary-operator])	unictype/base
unictype/property-ignorable-control	#include "unictype.h"	unictype/pr_ignorable_control.c unictype/pr_ignorable_control.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.1], [unictype/property-ignorable-control])	unictype/base
unictype/property-iso-control	#include "unictype.h"	unictype/pr_iso_control.c unictype/pr_iso_control.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.8], [unictype/property-iso-control])	unictype/base unictype/category-test unictype/category-Cc
unictype/property-join-control	#include "unictype.h"	unictype/pr_join_control.c unictype/pr_join_control.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.8], [unictype/property-join-control])	unictype/base
unictype/property-left-of-pair	#include "unictype.h"	unictype/pr_left_of_pair.c unictype/pr_left_of_pair.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.8], [unictype/property-left-of-pair])	unictype/base
unictype/property-line-separator	#include "unictype.h"	unictype/pr_line_separator.c unictype/pr_line_separator.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.8], [unictype/property-line-separator])	unictype/base
unictype/property-logical-order-exception	#include "unictype.h"	unictype/pr_logical_order_exception.c unictype/pr_logical_order_exception.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.8], [unictype/property-logical-order-exception])	unictype/base
unictype/property-lowercase	#include "unictype.h"	unictype/pr_lowercase.c unictype/pr_lowercase.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-lowercase])	unictype/base
unictype/property-math	#include "unictype.h"	unictype/pr_math.c unictype/pr_math.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-math])	unictype/base
unictype/property-modifier-combining-mark	#include "unictype.h"	unictype/pr_modifier_combining_mark.c unictype/pr_modifier_combining_mark.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-modifier-combining-mark])	unictype/base
unictype/property-non-break	#include "unictype.h"	unictype/pr_non_break.c unictype/pr_non_break.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.8], [unictype/property-non-break])	unictype/base
unictype/property-not-a-character	#include "unictype.h"	unictype/pr_not_a_character.c unictype/pr_not_a_character.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.8], [unictype/property-not-a-character])	unictype/base
unictype/property-numeric	#include "unictype.h"	unictype/pr_numeric.c unictype/pr_numeric.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-numeric])	unictype/base
unictype/property-other-alphabetic	#include "unictype.h"	unictype/pr_other_alphabetic.c unictype/pr_other_alphabetic.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-other-alphabetic])	unictype/base
unictype/property-other-default-ignorable-code-point	#include "unictype.h"	unictype/pr_other_default_ignorable_code_point.c unictype/pr_other_default_ignorable_code_point.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.8], [unictype/property-other-default-ignorable-code-point])	unictype/base
unictype/property-other-grapheme-extend	#include "unictype.h"	unictype/pr_other_grapheme_extend.c unictype/pr_other_grapheme_extend.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-other-grapheme-extend])	unictype/base
unictype/property-other-id-continue	#include "unictype.h"	unictype/pr_other_id_continue.c unictype/pr_other_id_continue.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.2], [unictype/property-other-id-continue])	unictype/base
unictype/property-other-id-start	#include "unictype.h"	unictype/pr_other_id_start.c unictype/pr_other_id_start.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.8], [unictype/property-other-id-start])	unictype/base
unictype/property-other-lowercase	#include "unictype.h"	unictype/pr_other_lowercase.c unictype/pr_other_lowercase.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.1], [unictype/property-other-lowercase])	unictype/base
unictype/property-other-math	#include "unictype.h"	unictype/pr_other_math.c unictype/pr_other_math.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.8], [unictype/property-other-math])	unictype/base
unictype/property-other-uppercase	#include "unictype.h"	unictype/pr_other_uppercase.c unictype/pr_other_uppercase.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.8], [unictype/property-other-uppercase])	unictype/base
unictype/property-paired-punctuation	#include "unictype.h"	unictype/pr_paired_punctuation.c unictype/pr_paired_punctuation.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.8], [unictype/property-paired-punctuation])	unictype/base
unictype/property-paragraph-separator	#include "unictype.h"	unictype/pr_paragraph_separator.c unictype/pr_paragraph_separator.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.8], [unictype/property-paragraph-separator])	unictype/base
unictype/property-pattern-syntax	#include "unictype.h"	unictype/pr_pattern_syntax.c unictype/pr_pattern_syntax.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.8], [unictype/property-pattern-syntax])	unictype/base
unictype/property-pattern-white-space	#include "unictype.h"	unictype/pr_pattern_white_space.c unictype/pr_pattern_white_space.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.8], [unictype/property-pattern-white-space])	unictype/base
unictype/property-prepended-concatenation-mark	#include "unictype.h"	unictype/pr_prepended_concatenation_mark.c unictype/pr_prepended_concatenation_mark.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.2], [unictype/property-prepended-concatenation-mark])	unictype/base
unictype/property-private-use	#include "unictype.h"	unictype/pr_private_use.c unictype/pr_private_use.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.8], [unictype/property-private-use])	unictype/base
unictype/property-punctuation	#include "unictype.h"	unictype/pr_punctuation.c unictype/pr_punctuation.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-punctuation])	unictype/base unictype/category-test unictype/category-P
unictype/property-quotation-mark	#include "unictype.h"	unictype/pr_quotation_mark.c unictype/pr_quotation_mark.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.8], [unictype/property-quotation-mark])	unictype/base
unictype/property-radical	#include "unictype.h"	unictype/pr_radical.c unictype/pr_radical.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.8], [unictype/property-radical])	unictype/base
unictype/property-sentence-terminal	#include "unictype.h"	unictype/pr_sentence_terminal.c unictype/pr_sentence_terminal.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-sentence-terminal])	unictype/base
unictype/property-soft-dotted	#include "unictype.h"	unictype/pr_soft_dotted.c unictype/pr_soft_dotted.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.1], [unictype/property-soft-dotted])	unictype/base
unictype/property-space	#include "unictype.h"	unictype/pr_space.c unictype/pr_space.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.8], [unictype/property-space])	unictype/base unictype/category-test unictype/category-Zs
unictype/property-terminal-punctuation	#include "unictype.h"	unictype/pr_terminal_punctuation.c unictype/pr_terminal_punctuation.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-terminal-punctuation])	unictype/base
unictype/property-test	#include "unictype.h"	unictype/pr_test.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9.8], [unictype/property-test])	unictype/base
unictype/property-titlecase	#include "unictype.h"	unictype/pr_titlecase.c unictype/pr_titlecase.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.8], [unictype/property-titlecase])	unictype/base unictype/category-test unictype/category-Lt
unictype/property-unassigned-code-value	#include "unictype.h"	unictype/pr_unassigned_code_value.c unictype/pr_unassigned_code_value.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-unassigned-code-value])	unictype/base
unictype/property-unified-ideograph	#include "unictype.h"	unictype/pr_unified_ideograph.c unictype/pr_unified_ideograph.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.2], [unictype/property-unified-ideograph])	unictype/base
unictype/property-uppercase	#include "unictype.h"	unictype/pr_uppercase.c unictype/pr_uppercase.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-uppercase])	unictype/base
unictype/property-variation-selector	#include "unictype.h"	unictype/pr_variation_selector.c unictype/pr_variation_selector.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.11], [unictype/property-variation-selector])	unictype/base
unictype/property-white-space	#include "unictype.h"	unictype/pr_white_space.c unictype/pr_white_space.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.8], [unictype/property-white-space])	unictype/base
unictype/property-xid-continue	#include "unictype.h"	unictype/pr_xid_continue.c unictype/pr_xid_continue.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-xid-continue])	unictype/base
unictype/property-xid-start	#include "unictype.h"	unictype/pr_xid_start.c unictype/pr_xid_start.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-xid-start])	unictype/base
unictype/property-zero-width	#include "unictype.h"	unictype/pr_zero_width.c unictype/pr_zero_width.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.1], [unictype/property-zero-width])	unictype/base
unictype/property-all	#include "unictype.h"	---	00gnulib.m4 zzgnulib.m4	unictype/property-alphabetic unictype/property-ascii-hex-digit unictype/property-bidi-arabic-digit unictype/property-bidi-arabic-right-to-left unictype/property-bidi-block-separator unictype/property-bidi-boundary-neutral unictype/property-bidi-common-separator unictype/property-bidi-control unictype/property-bidi-embedding-or-override unictype/property-bidi-eur-num-separator unictype/property-bidi-eur-num-terminator unictype/property-bidi-european-digit unictype/property-bidi-hebrew-right-to-left unictype/property-bidi-left-to-right unictype/property-bidi-non-spacing-mark unictype/property-bidi-other-neutral unictype/property-bidi-pdf unictype/property-bidi-segment-separator unictype/property-bidi-whitespace unictype/property-byname unictype/property-case-ignorable unictype/property-cased unictype/property-changes-when-casefolded unictype/property-changes-when-casemapped unictype/property-changes-when-lowercased unictype/property-changes-when-titlecased unictype/property-changes-when-uppercased unictype/property-combining unictype/property-composite unictype/property-currency-symbol unictype/property-dash unictype/property-decimal-digit unictype/property-default-ignorable-code-point unictype/property-deprecated unictype/property-diacritic unictype/property-emoji unictype/property-emoji-component unictype/property-emoji-modifier unictype/property-emoji-modifier-base unictype/property-emoji-presentation unictype/property-extended-pictographic unictype/property-extender unictype/property-format-control unictype/property-grapheme-base unictype/property-grapheme-extend unictype/property-grapheme-link unictype/property-hex-digit unictype/property-hyphen unictype/property-id-compat-math-continue unictype/property-id-compat-math-start unictype/property-id-continue unictype/property-id-start unictype/property-ideographic unictype/property-ids-binary-operator unictype/property-ids-trinary-operator unictype/property-ids-unary-operator unictype/property-ignorable-control unictype/property-iso-control unictype/property-join-control unictype/property-left-of-pair unictype/property-line-separator unictype/property-logical-order-exception unictype/property-lowercase unictype/property-math unictype/property-modifier-combining-mark unictype/property-non-break unictype/property-not-a-character unictype/property-numeric unictype/property-other-alphabetic unictype/property-other-default-ignorable-code-point unictype/property-other-grapheme-extend unictype/property-other-id-continue unictype/property-other-id-start unictype/property-other-lowercase unictype/property-other-math unictype/property-other-uppercase unictype/property-paired-punctuation unictype/property-paragraph-separator unictype/property-pattern-syntax unictype/property-pattern-white-space unictype/property-prepended-concatenation-mark unictype/property-private-use unictype/property-punctuation unictype/property-quotation-mark unictype/property-radical unictype/property-regional-indicator unictype/property-sentence-terminal unictype/property-soft-dotted unictype/property-space unictype/property-terminal-punctuation unictype/property-test unictype/property-titlecase unictype/property-unassigned-code-value unictype/property-unified-ideograph unictype/property-uppercase unictype/property-variation-selector unictype/property-white-space unictype/property-xid-continue unictype/property-xid-start unictype/property-zero-width
unictype/scripts	#include "unictype.h"	unictype/scripts.c unictype/scripts.h unictype/scripts_byname.gperf	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unictype/scripts])	unictype/base gperf
unictype/scripts-all	#include "unictype.h"	---	00gnulib.m4 zzgnulib.m4	unictype/scripts
unictype/syntax-c-ident	#include "unictype.h"	unictype/sy_c_ident.c unictype/sy_c_ident.h unictype/identsyntaxmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.8], [unictype/syntax-c-ident])	unictype/base
unictype/syntax-c-whitespace	#include "unictype.h"	unictype/sy_c_whitespace.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9.8], [unictype/syntax-c-whitespace])	unictype/base
unictype/syntax-java-ident	#include "unictype.h"	unictype/sy_java_ident.c unictype/sy_java_ident.h unictype/identsyntaxmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([1.3], [unictype/syntax-java-ident])	unictype/base
unictype/syntax-java-whitespace	#include "unictype.h"	unictype/sy_java_whitespace.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9.8], [unictype/syntax-java-whitespace])	unictype/base
uniwidth/base	#include "uniwidth.h"	uniwidth.in.h localcharset.h	libunistring-base.m4 00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_LIBHEADER([0.9.11], [uniwidth.h]) AC_PROG_MKDIR_P	gen-header unitypes-h
uniwidth/u8-strwidth	#include "uniwidth.h"	uniwidth/u8-strwidth.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [uniwidth/u8-strwidth])	uniwidth/base uniwidth/u8-width unistr/u8-strlen
uniwidth/u8-width	#include "uniwidth.h"	uniwidth/u8-width.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [uniwidth/u8-width])	uniwidth/base uniwidth/width unistr/u8-mbtouc-unsafe
uniwidth/u16-strwidth	#include "uniwidth.h"	uniwidth/u16-strwidth.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [uniwidth/u16-strwidth])	uniwidth/base uniwidth/u16-width unistr/u16-strlen
uniwidth/u16-width	#include "uniwidth.h"	uniwidth/u16-width.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [uniwidth/u16-width])	uniwidth/base uniwidth/width unistr/u16-mbtouc-unsafe
uniwidth/u32-strwidth	#include "uniwidth.h"	uniwidth/u32-strwidth.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [uniwidth/u32-strwidth])	uniwidth/base uniwidth/u32-width unistr/u32-strlen
uniwidth/u32-width	#include "uniwidth.h"	uniwidth/u32-width.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [uniwidth/u32-width])	uniwidth/base uniwidth/width
uniwidth/width	#include "uniwidth.h"	uniwidth/width.c uniwidth/cjk.h uniwidth/width0.h uniwidth/width2.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [uniwidth/width])	uniwidth/base streq
uniwbrk/base	#include "uniwbrk.h"	uniwbrk.in.h	libunistring-base.m4 00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_LIBHEADER([0.9.11], [uniwbrk.h]) AC_PROG_MKDIR_P	gen-header unitypes-h
uniwbrk/ulc-wordbreaks	#include "uniwbrk.h"	uniwbrk/ulc-wordbreaks.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [uniwbrk/ulc-wordbreaks])	uniwbrk/base uniwbrk/u8-wordbreaks unilbrk/ulc-common uniconv/u8-conv-from-enc c-ctype localcharset
uniwbrk/u8-wordbreaks	#include "uniwbrk.h"	uniwbrk/u8-wordbreaks.c uniwbrk/u-wordbreaks.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [uniwbrk/u8-wordbreaks])	uniwbrk/base uniwbrk/wordbreak-property uniwbrk/table unictype/property-extended-pictographic unistr/u8-mbtouc-unsafe
uniwbrk/u16-wordbreaks	#include "uniwbrk.h"	uniwbrk/u16-wordbreaks.c uniwbrk/u-wordbreaks.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [uniwbrk/u16-wordbreaks])	uniwbrk/base uniwbrk/wordbreak-property uniwbrk/table unictype/property-extended-pictographic unistr/u16-mbtouc-unsafe
uniwbrk/u32-wordbreaks	#include "uniwbrk.h"	uniwbrk/u32-wordbreaks.c uniwbrk/u-wordbreaks.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [uniwbrk/u32-wordbreaks])	uniwbrk/base uniwbrk/wordbreak-property uniwbrk/table unictype/property-extended-pictographic unistr/u32-mbtouc-unsafe
uniwbrk/wordbreak-property	#include "uniwbrk.h"	uniwbrk/wordbreak-property.c uniwbrk/wbrkprop.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [uniwbrk/wordbreak-property])	uniwbrk/base
unilbrk/base	#include "unilbrk.h"	unilbrk.in.h	libunistring-base.m4 00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_LIBHEADER([0.9.11], [unilbrk.h]) AC_PROG_MKDIR_P	gen-header unitypes-h localcharset bool
unilbrk/tables	#include "unilbrk/lbrktables.h"	unilbrk/lbrktables.c unilbrk/lbrkprop1.h unilbrk/lbrkprop2.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE])	unilbrk/base
unilbrk/ulc-common	#include "unilbrk/ulc-common.h"	unilbrk/ulc-common.c	00gnulib.m4 zzgnulib.m4	c-ctype c-strcaseeq
unilbrk/u8-possible-linebreaks	#include "unilbrk.h"	unilbrk/internal.h unilbrk/u8-possible-linebreaks.c uniwidth/cjk.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unilbrk/u8-possible-linebreaks])	unilbrk/base unilbrk/tables unistr/u8-mbtouc-unsafe streq
unilbrk/u16-possible-linebreaks	#include "unilbrk.h"	unilbrk/internal.h unilbrk/u16-possible-linebreaks.c uniwidth/cjk.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unilbrk/u16-possible-linebreaks])	unilbrk/base unilbrk/tables unistr/u16-mbtouc-unsafe streq
unilbrk/u32-possible-linebreaks	#include "unilbrk.h"	unilbrk/internal.h unilbrk/u32-possible-linebreaks.c uniwidth/cjk.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unilbrk/u32-possible-linebreaks])	unilbrk/base unilbrk/tables streq
unilbrk/ulc-possible-linebreaks	#include "unilbrk.h"	unilbrk/ulc-possible-linebreaks.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unilbrk/ulc-possible-linebreaks])	unilbrk/base unilbrk/u8-possible-linebreaks unilbrk/ulc-common uniconv/u8-conv-from-enc c-ctype
unilbrk/u8-width-linebreaks	#include "unilbrk.h"	unilbrk/internal.h unilbrk/u8-width-linebreaks.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unilbrk/u8-width-linebreaks])	unilbrk/base unilbrk/u8-possible-linebreaks uniwidth/width unistr/u8-mbtouc-unsafe
unilbrk/u16-width-linebreaks	#include "unilbrk.h"	unilbrk/u16-width-linebreaks.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unilbrk/u16-width-linebreaks])	unilbrk/base unilbrk/u16-possible-linebreaks uniwidth/width unistr/u16-mbtouc-unsafe
unilbrk/u32-width-linebreaks	#include "unilbrk.h"	unilbrk/u32-width-linebreaks.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unilbrk/u32-width-linebreaks])	unilbrk/base unilbrk/u32-possible-linebreaks uniwidth/width
unilbrk/ulc-width-linebreaks	#include "unilbrk.h"	unilbrk/ulc-width-linebreaks.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unilbrk/ulc-width-linebreaks])	unilbrk/base unilbrk/u8-width-linebreaks unilbrk/ulc-common uniconv/u8-conv-from-enc c-ctype
uninorm/base	#include "uninorm.h"	uninorm.in.h	libunistring-base.m4 uninorm_h.m4 00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_LIBHEADER([1.2], [uninorm.h]) gl_UNINORM_H gl_UNINORM_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	gen-header unitypes-h
uninorm/canonical-decomposition	#include "uninorm.h"	uninorm/canonical-decomposition.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [uninorm/canonical-decomposition])	uninorm/base uninorm/decomposition-table
uninorm/composition	#include "uninorm.h"	uninorm/composition.c uninorm/composition-table.gperf uninorm/composition-table-bounds.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [uninorm/composition])	uninorm/base gperf
uninorm/decomposing-form	#include "uninorm.h"	uninorm/decomposing-form.c uninorm/normalize-internal.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9.11], [uninorm/decomposing-form])	uninorm/base
uninorm/decomposition	#include "uninorm.h"	uninorm/decomposition.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [uninorm/decomposition])	uninorm/base uninorm/decomposition-table
uninorm/filter	#include "uninorm.h"	uninorm/uninorm-filter.c uninorm/normalize-internal.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [uninorm/filter])	uninorm/base unictype/combining-class uninorm/decompose-internal malloc-posix
uninorm/nfc	#include "uninorm.h"	uninorm/nfc.c uninorm/normalize-internal.h	00gnulib.m4 zzgnulib.m4 gl_UNINORM_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [uninorm/nfc])	uninorm/base uninorm/canonical-decomposition uninorm/composition uninorm/nfd
uninorm/nfd	#include "uninorm.h"	uninorm/nfd.c uninorm/normalize-internal.h	00gnulib.m4 zzgnulib.m4 gl_UNINORM_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [uninorm/nfd])	uninorm/base uninorm/canonical-decomposition
uninorm/nfkc	#include "uninorm.h"	uninorm/nfkc.c uninorm/normalize-internal.h	00gnulib.m4 zzgnulib.m4 gl_UNINORM_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [uninorm/nfkc])	uninorm/base uninorm/compat-decomposition uninorm/composition uninorm/nfkd
uninorm/nfkd	#include "uninorm.h"	uninorm/nfkd.c uninorm/normalize-internal.h	00gnulib.m4 zzgnulib.m4 gl_UNINORM_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [uninorm/nfkd])	uninorm/base uninorm/compat-decomposition
uninorm/u8-normalize	#include "uninorm.h"	uninorm/u8-normalize.c uninorm/normalize-internal.h uninorm/u-normalize-internal.h	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR_FOR_TESTS([uninorm/u8-normalize]) gl_LIBUNISTRING_MODULE([1.3], [uninorm/u8-normalize])	uninorm/base unistr/u8-mbtouc-unsafe unistr/u8-uctomb unistr/u8-cpy unictype/combining-class uninorm/decompose-internal
uninorm/u16-normalize	#include "uninorm.h"	uninorm/u16-normalize.c uninorm/normalize-internal.h uninorm/u-normalize-internal.h	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR_FOR_TESTS([uninorm/u16-normalize]) gl_LIBUNISTRING_MODULE([1.3], [uninorm/u16-normalize])	uninorm/base unistr/u16-mbtouc-unsafe unistr/u16-uctomb unistr/u16-cpy unictype/combining-class uninorm/decompose-internal
uninorm/u32-normalize	#include "uninorm.h"	uninorm/u32-normalize.c uninorm/normalize-internal.h uninorm/u-normalize-internal.h	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR_FOR_TESTS([uninorm/u32-normalize]) gl_LIBUNISTRING_MODULE([1.3], [uninorm/u32-normalize])	uninorm/base unistr/u32-mbtouc-unsafe unistr/u32-uctomb unistr/u32-cpy unictype/combining-class uninorm/decompose-internal
uninorm/u8-normcmp	#include "uninorm.h"	uninorm/u8-normcmp.c uninorm/u-normcmp.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [uninorm/u8-normcmp])	uninorm/base uninorm/u8-normalize unistr/u8-cmp2 minmax
uninorm/u16-normcmp	#include "uninorm.h"	uninorm/u16-normcmp.c uninorm/u-normcmp.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [uninorm/u16-normcmp])	uninorm/base uninorm/u16-normalize unistr/u16-cmp2 minmax
uninorm/u32-normcmp	#include "uninorm.h"	uninorm/u32-normcmp.c uninorm/u-normcmp.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [uninorm/u32-normcmp])	uninorm/base uninorm/u32-normalize unistr/u32-cmp2 minmax
uninorm/u8-normcoll	#include "uninorm.h"	uninorm/u8-normcoll.c uninorm/u-normcoll.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [uninorm/u8-normcoll])	uninorm/base uninorm/u8-normxfrm memcmp2
uninorm/u16-normcoll	#include "uninorm.h"	uninorm/u16-normcoll.c uninorm/u-normcoll.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [uninorm/u16-normcoll])	uninorm/base uninorm/u16-normxfrm memcmp2
uninorm/u32-normcoll	#include "uninorm.h"	uninorm/u32-normcoll.c uninorm/u-normcoll.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [uninorm/u32-normcoll])	uninorm/base uninorm/u32-normxfrm memcmp2
uninorm/u8-normxfrm	#include "uninorm.h"	uninorm/u8-normxfrm.c uninorm/u-normxfrm.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [uninorm/u8-normxfrm])	uninorm/base uninorm/u8-normalize uniconv/u8-conv-to-enc localcharset amemxfrm
uninorm/u16-normxfrm	#include "uninorm.h"	uninorm/u16-normxfrm.c uninorm/u-normxfrm.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [uninorm/u16-normxfrm])	uninorm/base uninorm/u16-normalize uniconv/u16-conv-to-enc localcharset amemxfrm
uninorm/u32-normxfrm	#include "uninorm.h"	uninorm/u32-normxfrm.c uninorm/u-normxfrm.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [uninorm/u32-normxfrm])	uninorm/base uninorm/u32-normalize uniconv/u32-conv-to-enc localcharset amemxfrm
unicase/base	#include "unicase.h"	unicase.in.h	libunistring-base.m4 unicase_h.m4 00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_LIBHEADER([1.2], [unicase.h]) gl_UNICASE_H gl_UNICASE_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	gen-header unitypes-h uninorm/base bool
unicase/empty-prefix-context	#include "unicase.h"	unicase/empty-prefix-context.c	00gnulib.m4 zzgnulib.m4 gl_UNICASE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.11], [unicase/empty-prefix-context])	unicase/base
unicase/empty-suffix-context	#include "unicase.h"	unicase/empty-suffix-context.c	00gnulib.m4 zzgnulib.m4 gl_UNICASE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.11], [unicase/empty-suffix-context])	unicase/base
unicase/locale-language	#include "unicase.h"	unicase/locale-language.c unicase/locale-languages.gperf	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9.3], [unicase/locale-language])	unicase/base localename gperf
unicase/tolower	#include "unicase.h"	unicase/tolower.c unicase/tolower.h unicase/simple-mapping.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/tolower])	unicase/base
unicase/totitle	#include "unicase.h"	unicase/totitle.c unicase/totitle.h unicase/simple-mapping.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/totitle])	unicase/base
unicase/toupper	#include "unicase.h"	unicase/toupper.c unicase/toupper.h unicase/simple-mapping.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/toupper])	unicase/base
unicase/ulc-casecmp	#include "unicase.h"	unicase/ulc-casecmp.c unicase/u-casecmp.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/ulc-casecmp])	unicase/base unicase/u8-casefold uninorm/decomposing-form uniconv/u8-conv-from-enc unistr/u8-cmp2 localcharset minmax
unicase/ulc-casecoll	#include "unicase.h"	unicase/ulc-casecoll.c unicase/u-casecoll.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/ulc-casecoll])	unicase/base unicase/ulc-casexfrm memcmp2
unicase/ulc-casexfrm	#include "unicase.h"	unicase/ulc-casexfrm.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/ulc-casexfrm])	unicase/base unicase/u8-casexfrm uniconv/u8-conv-from-enc localcharset
unicase/u8-casecmp	#include "unicase.h"	unicase/u8-casecmp.c unicase/u-casecmp.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u8-casecmp])	unicase/base unicase/u8-casefold uninorm/decomposing-form unistr/u8-cmp2 minmax
unicase/u16-casecmp	#include "unicase.h"	unicase/u16-casecmp.c unicase/u-casecmp.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u16-casecmp])	unicase/base unicase/u16-casefold uninorm/decomposing-form unistr/u16-cmp2 minmax
unicase/u32-casecmp	#include "unicase.h"	unicase/u32-casecmp.c unicase/u-casecmp.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u32-casecmp])	unicase/base unicase/u32-casefold uninorm/decomposing-form unistr/u32-cmp2 minmax
unicase/u8-casecoll	#include "unicase.h"	unicase/u8-casecoll.c unicase/u-casecoll.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u8-casecoll])	unicase/base unicase/u8-casexfrm memcmp2
unicase/u16-casecoll	#include "unicase.h"	unicase/u16-casecoll.c unicase/u-casecoll.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u16-casecoll])	unicase/base unicase/u16-casexfrm memcmp2
unicase/u32-casecoll	#include "unicase.h"	unicase/u32-casecoll.c unicase/u-casecoll.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u32-casecoll])	unicase/base unicase/u32-casexfrm memcmp2
unicase/u8-casefold	#include "unicase.h"	unicase/u8-casefold.c unicase/u-casefold.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u8-casefold])	unicase/base unicase/u8-ct-casefold unicase/empty-prefix-context unicase/empty-suffix-context
unicase/u16-casefold	#include "unicase.h"	unicase/u16-casefold.c unicase/u-casefold.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u16-casefold])	unicase/base unicase/u16-ct-casefold unicase/empty-prefix-context unicase/empty-suffix-context
unicase/u32-casefold	#include "unicase.h"	unicase/u32-casefold.c unicase/u-casefold.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u32-casefold])	unicase/base unicase/u32-ct-casefold unicase/empty-prefix-context unicase/empty-suffix-context
unicase/u8-casexfrm	#include "unicase.h"	unicase/u8-casexfrm.c unicase/u-casexfrm.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u8-casexfrm])	unicase/base unicase/u8-casefold uniconv/u8-conv-to-enc localcharset amemxfrm
unicase/u16-casexfrm	#include "unicase.h"	unicase/u16-casexfrm.c unicase/u-casexfrm.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u16-casexfrm])	unicase/base unicase/u16-casefold uniconv/u16-conv-to-enc localcharset amemxfrm
unicase/u32-casexfrm	#include "unicase.h"	unicase/u32-casexfrm.c unicase/u-casexfrm.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u32-casexfrm])	unicase/base unicase/u32-casefold uniconv/u32-conv-to-enc localcharset amemxfrm
unicase/u8-ct-casefold	#include "unicase.h"	unicase/u8-ct-casefold.c unicase/u-ct-casefold.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u8-ct-casefold])	unicase/base unicase/u8-casemap unicase/special-casing unicase/tocasefold uninorm/decomposing-form uninorm/u8-normalize uninorm/nfd
unicase/u16-ct-casefold	#include "unicase.h"	unicase/u16-ct-casefold.c unicase/u-ct-casefold.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u16-ct-casefold])	unicase/base unicase/u16-casemap unicase/special-casing unicase/tocasefold uninorm/decomposing-form uninorm/u16-normalize uninorm/nfd
unicase/u32-ct-casefold	#include "unicase.h"	unicase/u32-ct-casefold.c unicase/u-ct-casefold.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u32-ct-casefold])	unicase/base unicase/u32-casemap unicase/special-casing unicase/tocasefold uninorm/decomposing-form uninorm/u32-normalize uninorm/nfd
unicase/u8-ct-tolower	#include "unicase.h"	unicase/u8-ct-tolower.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u8-ct-tolower])	unicase/base unicase/u8-casemap unicase/special-casing unicase/toupper
unicase/u16-ct-tolower	#include "unicase.h"	unicase/u16-ct-tolower.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u16-ct-tolower])	unicase/base unicase/u8-casemap unicase/special-casing unicase/toupper
unicase/u32-ct-tolower	#include "unicase.h"	unicase/u32-ct-tolower.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u32-ct-tolower])	unicase/base unicase/u8-casemap unicase/special-casing unicase/toupper
unicase/u8-ct-totitle	#include "unicase.h"	unicase/u8-ct-totitle.c unicase/u-ct-totitle.h unicase/context.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u8-ct-totitle])	unicase/base unicase/cased unicase/ignorable unicase/special-casing unicase/totitle unicase/tolower uniwbrk/u8-wordbreaks unictype/combining-class unictype/property-soft-dotted unistr/u8-mbtouc-unsafe unistr/u8-uctomb unistr/u8-cpy uninorm/u8-normalize bool
unicase/u16-ct-totitle	#include "unicase.h"	unicase/u16-ct-totitle.c unicase/u-ct-totitle.h unicase/context.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u16-ct-totitle])	unicase/base unicase/cased unicase/ignorable unicase/special-casing unicase/totitle unicase/tolower uniwbrk/u16-wordbreaks unictype/combining-class unictype/property-soft-dotted unistr/u16-mbtouc-unsafe unistr/u16-uctomb unistr/u16-cpy uninorm/u16-normalize bool
unicase/u32-ct-totitle	#include "unicase.h"	unicase/u32-ct-totitle.c unicase/u-ct-totitle.h unicase/context.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u32-ct-totitle])	unicase/base unicase/cased unicase/ignorable unicase/special-casing unicase/totitle unicase/tolower uniwbrk/u32-wordbreaks unictype/combining-class unictype/property-soft-dotted unistr/u32-mbtouc-unsafe unistr/u32-uctomb unistr/u32-cpy uninorm/u32-normalize bool
unicase/u8-ct-toupper	#include "unicase.h"	unicase/u8-ct-toupper.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u8-ct-toupper])	unicase/base unicase/u8-casemap unicase/special-casing unicase/toupper
unicase/u16-ct-toupper	#include "unicase.h"	unicase/u16-ct-toupper.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u16-ct-toupper])	unicase/base unicase/u8-casemap unicase/special-casing unicase/toupper
unicase/u32-ct-toupper	#include "unicase.h"	unicase/u32-ct-toupper.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u32-ct-toupper])	unicase/base unicase/u8-casemap unicase/special-casing unicase/toupper
unicase/u8-is-cased	#include "unicase.h"	unicase/u8-is-cased.c unicase/u-is-cased.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u8-is-cased])	unicase/base unicase/u8-toupper unicase/u8-tolower unicase/u8-totitle uninorm/u8-normalize uninorm/nfd unistr/u8-cmp
unicase/u16-is-cased	#include "unicase.h"	unicase/u16-is-cased.c unicase/u-is-cased.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u16-is-cased])	unicase/base unicase/u16-toupper unicase/u16-tolower unicase/u16-totitle uninorm/u16-normalize uninorm/nfd unistr/u16-cmp
unicase/u32-is-cased	#include "unicase.h"	unicase/u32-is-cased.c unicase/u-is-cased.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u32-is-cased])	unicase/base unicase/u32-toupper unicase/u32-tolower unicase/u32-totitle uninorm/u32-normalize uninorm/nfd unistr/u32-cmp
unicase/u8-is-casefolded	#include "unicase.h"	unicase/u8-is-casefolded.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u8-is-casefolded])	unicase/base unicase/u8-is-invariant unicase/u8-casefold
unicase/u16-is-casefolded	#include "unicase.h"	unicase/u16-is-casefolded.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.2], [unicase/u16-is-casefolded])	unicase/base unicase/u16-is-invariant unicase/u16-casefold
unicase/u32-is-casefolded	#include "unicase.h"	unicase/u32-is-casefolded.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u32-is-casefolded])	unicase/base unicase/u32-is-invariant unicase/u32-casefold
unicase/u8-is-lowercase	#include "unicase.h"	unicase/u8-is-lowercase.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u8-is-lowercase])	unicase/base unicase/u8-is-invariant unicase/u8-tolower
unicase/u16-is-lowercase	#include "unicase.h"	unicase/u16-is-lowercase.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u16-is-lowercase])	unicase/base unicase/u16-is-invariant unicase/u16-tolower
unicase/u32-is-lowercase	#include "unicase.h"	unicase/u32-is-lowercase.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u32-is-lowercase])	unicase/base unicase/u32-is-invariant unicase/u32-tolower
unicase/u8-is-titlecase	#include "unicase.h"	unicase/u8-is-titlecase.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u8-is-titlecase])	unicase/base unicase/u8-is-invariant unicase/u8-totitle
unicase/u16-is-titlecase	#include "unicase.h"	unicase/u16-is-titlecase.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u16-is-titlecase])	unicase/base unicase/u16-is-invariant unicase/u16-totitle
unicase/u32-is-titlecase	#include "unicase.h"	unicase/u32-is-titlecase.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u32-is-titlecase])	unicase/base unicase/u32-is-invariant unicase/u32-totitle
unicase/u8-is-uppercase	#include "unicase.h"	unicase/u8-is-uppercase.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u8-is-uppercase])	unicase/base unicase/u8-is-invariant unicase/u8-toupper
unicase/u16-is-uppercase	#include "unicase.h"	unicase/u16-is-uppercase.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u16-is-uppercase])	unicase/base unicase/u16-is-invariant unicase/u16-toupper
unicase/u8-prefix-context	#include "unicase.h"	unicase/u8-prefix-context.c unicase/u-prefix-context.h unicase/context.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u8-prefix-context])	unicase/base unicase/empty-prefix-context unicase/ignorable unictype/combining-class unistr/u8-mbtouc-unsafe unistr/u8-prev
unicase/u16-prefix-context	#include "unicase.h"	unicase/u16-prefix-context.c unicase/u-prefix-context.h unicase/context.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u16-prefix-context])	unicase/base unicase/empty-prefix-context unicase/ignorable unictype/combining-class unistr/u16-mbtouc-unsafe unistr/u16-prev
unicase/u32-prefix-context	#include "unicase.h"	unicase/u32-prefix-context.c unicase/u-prefix-context.h unicase/context.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u32-prefix-context])	unicase/base unicase/empty-prefix-context unicase/ignorable unictype/combining-class unistr/u32-mbtouc-unsafe unistr/u32-prev
unicase/u8-suffix-context	#include "unicase.h"	unicase/u8-suffix-context.c unicase/u-suffix-context.h unicase/context.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u8-suffix-context])	unicase/base unicase/empty-prefix-context unicase/ignorable unictype/combining-class unistr/u8-mbtouc-unsafe
unicase/u16-suffix-context	#include "unicase.h"	unicase/u16-suffix-context.c unicase/u-suffix-context.h unicase/context.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u16-suffix-context])	unicase/base unicase/empty-prefix-context unicase/ignorable unictype/combining-class unistr/u16-mbtouc-unsafe
unicase/u32-suffix-context	#include "unicase.h"	unicase/u32-suffix-context.c unicase/u-suffix-context.h unicase/context.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u32-suffix-context])	unicase/base unicase/empty-prefix-context unicase/ignorable unictype/combining-class unistr/u32-mbtouc-unsafe
unicase/u8-tolower	#include "unicase.h"	unicase/u8-tolower.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u8-tolower])	unicase/base unicase/u8-casemap unicase/special-casing unicase/empty-prefix-context unicase/empty-suffix-context unicase/tolower
unicase/u16-tolower	#include "unicase.h"	unicase/u16-tolower.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u16-tolower])	unicase/base unicase/u16-casemap unicase/special-casing unicase/empty-prefix-context unicase/empty-suffix-context unicase/tolower
unicase/u32-tolower	#include "unicase.h"	unicase/u32-tolower.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u32-tolower])	unicase/base unicase/u32-casemap unicase/special-casing unicase/empty-prefix-context unicase/empty-suffix-context unicase/tolower
unicase/u8-totitle	#include "unicase.h"	unicase/u8-totitle.c unicase/u-totitle.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u8-totitle])	unicase/base unicase/u8-ct-totitle unicase/empty-prefix-context unicase/empty-suffix-context
unicase/u16-totitle	#include "unicase.h"	unicase/u16-totitle.c unicase/u-totitle.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u16-totitle])	unicase/base unicase/u16-ct-totitle unicase/empty-prefix-context unicase/empty-suffix-context
unicase/u32-totitle	#include "unicase.h"	unicase/u32-totitle.c unicase/u-totitle.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u32-totitle])	unicase/base unicase/u32-ct-totitle unicase/empty-prefix-context unicase/empty-suffix-context
unicase/u8-toupper	#include "unicase.h"	unicase/u8-toupper.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u8-toupper])	unicase/base unicase/u8-casemap unicase/special-casing unicase/empty-prefix-context unicase/empty-suffix-context unicase/toupper
unicase/u16-toupper	#include "unicase.h"	unicase/u16-toupper.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u16-toupper])	unicase/base unicase/u16-casemap unicase/special-casing unicase/empty-prefix-context unicase/empty-suffix-context unicase/toupper
unicase/u32-toupper	#include "unicase.h"	unicase/u32-toupper.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u32-toupper])	unicase/base unicase/u32-casemap unicase/special-casing unicase/empty-prefix-context unicase/empty-suffix-context unicase/toupper

Executing programs

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
cloexec	#include "cloexec.h"	cloexec.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR_FOR_TESTS([cloexec])	dup2 fcntl bool
findprog	#include "findprog.h"	findprog.c	findprog.m4 eaccess.m4 00gnulib.m4 zzgnulib.m4 gl_FINDPROG	bool sys_stat-h xalloc xconcat-filename access stat unistd-h
findprog-lgpl	#include "findprog.h"	findprog.c findprog-lgpl.c	findprog.m4 eaccess.m4 00gnulib.m4 zzgnulib.m4 gl_FINDPROG gl_MODULE_INDICATOR([findprog-lgpl])	bool sys_stat-h strdup concat-filename access stat unistd-h
wait-process	#include "wait-process.h"	wait-process.c	wait-process.m4 sig_atomic_t.m4 00gnulib.m4 zzgnulib.m4 gl_WAIT_PROCESS	fatal-signal error xalloc xalloc-die gettext-h gnulib-i18n bool stdlib-h sys_wait-h unistd-h atexit waitpid
execute	#include "execute.h"	execute.c	execute.m4 00gnulib.m4 zzgnulib.m4 gl_EXECUTE	dup2 canonicalize environ error fatal-signal filename findprog-in free-posix msvc-nothrow gettext-h gnulib-i18n spawn-h posix_spawn posix_spawnp posix_spawn_file_actions_init posix_spawn_file_actions_addopen posix_spawn_file_actions_addchdir posix_spawn_file_actions_destroy posix_spawnattr_init posix_spawnattr_setsigmask posix_spawnattr_setflags posix_spawnattr_destroy bool stdlib-h sys_wait-h unistd-h wait-process windows-spawn xalloc-die
spawn-pipe	#include "spawn-pipe.h"	spawn-pipe.c os2-spawn.h os2-spawn.c	spawn-pipe.m4 00gnulib.m4 zzgnulib.m4 gl_SPAWN_PIPE AC_REQUIRE([AC_CANONICAL_HOST]) gl_CONDITIONAL([GL_COND_OBJ_OS2_SPAWN], [case "$host_os" in os2) true;; ) false;; esac])	dup2 canonicalize environ error fatal-signal filename findprog-in free-posix gettext-h gnulib-i18n msvc-nothrow open pipe2 pipe2-safer spawn-h posix_spawn posix_spawnp posix_spawn_file_actions_init posix_spawn_file_actions_addclose posix_spawn_file_actions_adddup2 posix_spawn_file_actions_addopen posix_spawn_file_actions_addchdir posix_spawn_file_actions_destroy posix_spawnattr_init posix_spawnattr_setpgroup posix_spawnattr_setsigmask posix_spawnattr_setflags posix_spawnattr_destroy bool stdlib-h unistd-h unistd-safer wait-process windows-spawn xalloc-die
pipe-filter-gi	#include "pipe-filter.h"	pipe-filter-gi.c pipe-filter-aux.h pipe-filter-aux.c	00gnulib.m4 zzgnulib.m4 AC_CHECK_FUNCS_ONCE([select])	spawn-pipe wait-process error extern-inline fcntl-h free-posix gettext-h gnulib-i18n bool stdint-h stdlib-h sys_select-h unistd-h xalloc
pipe-filter-ii	#include "pipe-filter.h"	pipe-filter-ii.c pipe-filter-aux.h pipe-filter-aux.c	00gnulib.m4 zzgnulib.m4 AC_CHECK_FUNCS_ONCE([select])	spawn-pipe wait-process error extern-inline fcntl-h gettext-h gnulib-i18n bool stdint-h stdlib-h sys_select-h unistd-h
sh-quote	#include "sh-quote.h"	sh-quote.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_RESTRICT])	quotearg xalloc

Java

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
classpath	#include "classpath.h"	classpath.c	00gnulib.m4 zzgnulib.m4	bool xsetenv xalloc
javacomp-script	---	---	javacomp.m4 00gnulib.m4 zzgnulib.m4 # You need to invoke gt_JAVACOMP yourself, possibly with arguments. AC_CONFIG_FILES([javacomp.sh:build-aux/javacomp.sh.in])	---
javacomp	#include "javacomp.h"	javacomp.c	00gnulib.m4 zzgnulib.m4	bool unistd-h javaversion execute spawn-pipe wait-process classpath xsetenv sh-quote binary-io open safe-read xalloc xmalloca getline xconcat-filename fwriteerror fopen-gnu clean-temp stat error xvasprintf verify c-strstr gettext-h gnulib-i18n javacomp-script sh-filename
javaexec-script	---	---	javaexec.m4 00gnulib.m4 zzgnulib.m4 # You need to invoke gt_JAVAEXEC yourself, possibly with arguments. AC_CONFIG_FILES([javaexec.sh:build-aux/javaexec.sh.in])	---
javaexec	#include "javaexec.h"	javaexec.c	00gnulib.m4 zzgnulib.m4	bool execute classpath xsetenv sh-quote xconcat-filename xalloc xmalloca error gettext-h gnulib-i18n javaexec-script sh-filename
javaversion	#include "javaversion.h"	javaversion.c javaversion.java javaversion.class	00gnulib.m4 zzgnulib.m4	javaexec bool spawn-pipe wait-process getline gettext-h gnulib-i18n configmake

C#

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
csharpcomp-script	---	---	csharpcomp.m4 csharp.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gt_CSHARPCOMP]) AC_CONFIG_FILES([csharpcomp.sh:build-aux/csharpcomp.sh.in])	---
csharpcomp	#include "csharpcomp.h"	csharpcomp.c	00gnulib.m4 zzgnulib.m4	bool error xconcat-filename cygpath execute spawn-pipe wait-process getline scandir alphasort sh-quote safe-read xmalloca xvasprintf gettext-h gnulib-i18n memcmp csharpcomp-script
csharpexec-script	---	---	csharpexec.m4 csharp.m4 00gnulib.m4 zzgnulib.m4 # You need to invoke gt_CSHARPEXEC yourself, possibly with arguments. AC_CONFIG_FILES([csharpexec.sh:build-aux/csharpexec.sh.in])	---
csharpexec	#include "csharpexec.h"	csharpexec.c classpath.h classpath.c	00gnulib.m4 zzgnulib.m4	bool stat error dirname xconcat-filename canonicalize cygpath execute spawn-pipe wait-process xsetenv scandir alphasort sh-quote xalloc xmalloca copy-file clean-temp-simple clean-temp gettext-h gnulib-i18n csharpexec-script

Misc

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
argp	#include "argp.h"	argp-ba.c argp-eexst.c argp-fmtstream.c argp-fmtstream.h argp-fs-xinl.c argp-help.c argp-namefrob.h argp-parse.c argp-pin.c argp-pv.c argp-pvh.c argp-xinl.c	argp.m4 00gnulib.m4 zzgnulib.m4 gl_ARGP m4_ifdef([AM_XGETTEXT_OPTION], [AM_][XGETTEXT_OPTION([--flag=argp_error:2:c-format]) AM_][XGETTEXT_OPTION([--flag=argp_failure:4:c-format])])	alignasof alloca basename-lgpl extern-inline getopt-gnu strchrnul sysexits-h malloc-gnu mempcpy strndup strcasecmp extensions vsnprintf sleep bool stdio-h strerror memchr memmove
argp-version-etc	#include "argp-version-etc.h"	argp-version-etc.c	00gnulib.m4 zzgnulib.m4	argp version-etc
argz	#include <argz.h>	argz.in.h argz.c	argz.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ARGZ gl_CONDITIONAL_HEADER([argz.h]) AC_PROG_MKDIR_P gl_CONDITIONAL([GL_COND_OBJ_ARGZ], [test -n "$ARGZ_H"])	gen-header memmove [test -n "$ARGZ_H"] mempcpy [test -n "$ARGZ_H"] realloc-posix [test -n "$ARGZ_H"] stpcpy [test -n "$ARGZ_H"] strndup [test -n "$ARGZ_H"] strnlen [test -n "$ARGZ_H"] strstr [test -n "$ARGZ_H"]
attribute	#include "attribute.h"	---	00gnulib.m4 zzgnulib.m4	---
bitrotate	#include "bitrotate.h"	bitrotate.c	00gnulib.m4 zzgnulib.m4	extern-inline stdint-h
byteswap	#include <byteswap.h>	byteswap.in.h byteswap.c	byteswap.m4 00gnulib.m4 zzgnulib.m4 gl_BYTESWAP gl_CONDITIONAL_HEADER([byteswap.h]) AC_PROG_MKDIR_P	gen-header extern-inline [$GL_GENERATE_BYTESWAP_H] bool [$GL_GENERATE_BYTESWAP_H] stdint-h [$GL_GENERATE_BYTESWAP_H]
dfa	#include "dfa.h" #include "localeinfo.h"	dfa.c dfa.h localeinfo.c localeinfo.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE])	assert c32isprint c32isspace c32rtomb c32tob c32tolower c32toupper c99 ctype-h flexmember gettext-h gnulib-i18n idx locale-h mbrtoc32-regular mbszero regex bool stddef-h stdint-h stdio-h stdlib-h string-h uchar-h verify wchar-h xalloc xalloc-die
exitfail	#include "exitfail.h"	exitfail.c	00gnulib.m4 zzgnulib.m4	stdlib-h
error	#include <error.h>	error.c	error.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_ERROR_H]) gl_ERROR gl_CONDITIONAL([GL_COND_OBJ_ERROR], [test $COMPILE_ERROR_C = 1]) AM_COND_IF([GL_COND_OBJ_ERROR], [ gl_PREREQ_ERROR ]) m4_ifdef([AM_XGETTEXT_OPTION], [AM_][XGETTEXT_OPTION([--flag=error:3:c-format]) AM_][XGETTEXT_OPTION([--flag=error_at_line:5:c-format])])	error-h stddef-h stdio-h getprogname [test $COMPILE_ERROR_C = 1] gettext-h [test $COMPILE_ERROR_C = 1] gnulib-i18n [test $COMPILE_ERROR_C = 1] strerror [test $COMPILE_ERROR_C = 1] unistd-h [test $COMPILE_ERROR_C = 1] msvc-nothrow [test $COMPILE_ERROR_C = 1]
extensions	---	---	extensions.m4 00gnulib.m4 zzgnulib.m4	---
forkpty	#include <pty.h>	forkpty.c	pty.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FORKPTY gl_CONDITIONAL([GL_COND_OBJ_FORKPTY], [test $HAVE_FORKPTY = 0 \|\| test $REPLACE_FORKPTY = 1]) gl_PTY_MODULE_INDICATOR([forkpty])	pty-h unistd-h openpty login_tty
getdomainname	#include <unistd.h>	getdomainname.c	getdomainname.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_GETDOMAINNAME gl_CONDITIONAL([GL_COND_OBJ_GETDOMAINNAME], [test $HAVE_DECL_GETDOMAINNAME = 0 \|\| test $REPLACE_GETDOMAINNAME = 1]) AM_COND_IF([GL_COND_OBJ_GETDOMAINNAME], [ gl_PREREQ_GETDOMAINNAME ]) gl_UNISTD_MODULE_INDICATOR([getdomainname])	unistd-h extensions netdb-h [test $HAVE_DECL_GETDOMAINNAME = 0 \|\| test $REPLACE_GETDOMAINNAME = 1] sys_socket-h [test $HAVE_DECL_GETDOMAINNAME = 0 \|\| test $REPLACE_GETDOMAINNAME = 1]
xgetdomainname	#include "xgetdomainname.h"	xgetdomainname.c xgetaname-impl.h	00gnulib.m4 zzgnulib.m4	free-posix getdomainname xalloc
getentropy	#include <unistd.h>	getentropy.c	getentropy.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_GETENTROPY gl_CONDITIONAL([GL_COND_OBJ_GETENTROPY], [test $HAVE_GETENTROPY = 0 \|\| test $REPLACE_GETENTROPY = 1]) gl_UNISTD_MODULE_INDICATOR([getentropy])	getrandom [test $HAVE_GETENTROPY = 0 \|\| test $REPLACE_GETENTROPY = 1] extensions unistd-h
getloadavg	#include <stdlib.h>	getloadavg.c	getloadavg.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_CANONICAL_HOST]) gl_GETLOADAVG gl_CONDITIONAL([GL_COND_OBJ_GETLOADAVG], [test $HAVE_GETLOADAVG = 0 \|\| test $REPLACE_GETLOADAVG = 1]) AM_COND_IF([GL_COND_OBJ_GETLOADAVG], [ gl_PREREQ_GETLOADAVG ]) gl_STDLIB_MODULE_INDICATOR([getloadavg])	extensions intprops [test $HAVE_GETLOADAVG = 0 \|\| test $REPLACE_GETLOADAVG = 1] open [case $host_os in mingw* \| windows) false;; ) test $HAVE_GETLOADAVG = 0 \|\| test $REPLACE_GETLOADAVG = 1;; esac] bool [test $HAVE_GETLOADAVG = 0 \|\| test $REPLACE_GETLOADAVG = 1] stdlib-h [test $HAVE_GETLOADAVG = 0 \|\| test $REPLACE_GETLOADAVG = 1]
getpagesize	#include <unistd.h>	getpagesize.c	getpagesize.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_GETPAGESIZE gl_CONDITIONAL([GL_COND_OBJ_GETPAGESIZE], [test $HAVE_GETPAGESIZE = 0 \|\| test $REPLACE_GETPAGESIZE = 1]) gl_UNISTD_MODULE_INDICATOR([getpagesize])	unistd-h
getprogname	#include <stdlib.h>	getprogname.h getprogname.c	getprogname.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_CANONICAL_HOST]) gl_FUNC_GETPROGNAME gl_CONDITIONAL([GL_COND_OBJ_GETPROGNAME], [test $HAVE_GETPROGNAME = 0 \|\| test $REPLACE_GETPROGNAME = 1]) AM_COND_IF([GL_COND_OBJ_GETPROGNAME], [ gl_PREREQ_GETPROGNAME ]) gl_STDLIB_MODULE_INDICATOR([getprogname])	stdlib-h basename-lgpl [test $HAVE_GETPROGNAME = 0] extensions [test $HAVE_GETPROGNAME = 0] open [test $HAVE_GETPROGNAME = 0 && case "$host_os" in irix* \| osf* \| sco* \| unixware) true;; ) false;; esac]
getrandom	#include <sys/random.h>	getrandom.c	getrandom.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_CANONICAL_HOST]) gl_FUNC_GETRANDOM gl_CONDITIONAL([GL_COND_OBJ_GETRANDOM], [test $HAVE_GETRANDOM = 0 \|\| test $REPLACE_GETRANDOM = 1]) gl_SYS_RANDOM_MODULE_INDICATOR([getrandom])	sys_random-h fcntl-h [test $HAVE_GETRANDOM = 0 \|\| test $REPLACE_GETRANDOM = 1] minmax [test $HAVE_GETRANDOM = 0 \|\| test $REPLACE_GETRANDOM = 1] bool [test $HAVE_GETRANDOM = 0 \|\| test $REPLACE_GETRANDOM = 1] open [case $host_os in mingw* \| windows) false;; ) test $HAVE_GETRANDOM = 0 \|\| test $REPLACE_GETRANDOM = 1;; esac]
getusershell	#include <unistd.h>	getusershell.c	getusershell.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_GETUSERSHELL gl_CONDITIONAL([GL_COND_OBJ_GETUSERSHELL], [test $HAVE_GETUSERSHELL = 0 \|\| test $REPLACE_GETUSERSHELL = 1]) AM_COND_IF([GL_COND_OBJ_GETUSERSHELL], [ gl_PREREQ_GETUSERSHELL ]) gl_UNISTD_MODULE_INDICATOR([getusershell])	unistd-h extensions fopen [test $HAVE_GETUSERSHELL = 0 \|\| test $REPLACE_GETUSERSHELL = 1] getline [test $HAVE_GETUSERSHELL = 0 \|\| test $REPLACE_GETUSERSHELL = 1] filename [test $HAVE_GETUSERSHELL = 0 \|\| test $REPLACE_GETUSERSHELL = 1] xalloc [test $HAVE_GETUSERSHELL = 0 \|\| test $REPLACE_GETUSERSHELL = 1]
lib-symbol-visibility	---	---	visibility.m4 00gnulib.m4 zzgnulib.m4 gl_VISIBILITY	---
login_tty	#include <utmp.h>	login_tty.c	login_tty.m4 pty.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_LOGIN_TTY gl_CONDITIONAL([GL_COND_OBJ_LOGIN_TTY], [test $HAVE_LOGIN_TTY = 0]) gl_UTMP_MODULE_INDICATOR([login_tty])	utmp-h sys_ioctl-h open [test $HAVE_LOGIN_TTY = 0]
nproc	#include "nproc.h"	nproc.c	nproc.m4 00gnulib.m4 zzgnulib.m4 gl_NPROC	c-ctype extensions minmax unistd-h
openpty	#include <pty.h>	openpty.c	pty.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_OPENPTY gl_CONDITIONAL([GL_COND_OBJ_OPENPTY], [test $HAVE_OPENPTY = 0 \|\| test $REPLACE_OPENPTY = 1]) gl_PTY_MODULE_INDICATOR([openpty])	pty-h extensions fcntl-h [test $HAVE_OPENPTY = 0 \|\| test $REPLACE_OPENPTY = 1] posix_openpt [test $HAVE_OPENPTY = 0 \|\| test $REPLACE_OPENPTY = 1] ioctl [test $HAVE_OPENPTY = 0 \|\| test $REPLACE_OPENPTY = 1]
parse-duration	#include "parse-duration.h"	parse-duration.c	00gnulib.m4 zzgnulib.m4	intprops
physmem	#include "physmem.h"	physmem.c	physmem.m4 00gnulib.m4 zzgnulib.m4 gl_PHYSMEM	unistd-h full-read
posixver	#include "posixver.h"	posixver.c	posixver.m4 00gnulib.m4 zzgnulib.m4 gl_POSIXVER	---
progname	#include "progname.h"	progname.c	00gnulib.m4 zzgnulib.m4 AC_CHECK_DECLS([program_invocation_name], [], [], [#include ]) AC_CHECK_DECLS([program_invocation_short_name], [], [], [#include ])	---
ptsname_r	#include <stdlib.h>	ptsname_r.c	ptsname_r.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_PTSNAME_R gl_CONDITIONAL([GL_COND_OBJ_PTSNAME_R], [test $HAVE_PTSNAME_R = 0 \|\| test $REPLACE_PTSNAME_R = 1]) AM_COND_IF([GL_COND_OBJ_PTSNAME_R], [ gl_PREREQ_PTSNAME_R ]) gl_STDLIB_MODULE_INDICATOR([ptsname_r])	stdlib-h extensions isatty [test $HAVE_PTSNAME_R = 0 \|\| test $REPLACE_PTSNAME_R = 1] stat [test $HAVE_PTSNAME_R = 0 \|\| test $REPLACE_PTSNAME_R = 1] ttyname_r [test $HAVE_PTSNAME_R = 0 \|\| test $REPLACE_PTSNAME_R = 1]
pty	#include <pty.h>	---	00gnulib.m4 zzgnulib.m4	pty-h
quotearg	#include "quotearg.h"	quotearg.c quote.h	quotearg.m4 00gnulib.m4 zzgnulib.m4 gl_QUOTEARG	attribute c-strcaseeq c32isprint extensions gettext-h gnulib-i18n mbszero mbrtoc32 mbsinit memcmp minmax quotearg-simple localcharset bool stdint-h uchar-h xalloc
quote	#include "quote.h"	---	quote.m4 00gnulib.m4 zzgnulib.m4 gl_QUOTE	quotearg
readutmp	#include "readutmp.h"	readutmp.c boot-time-aux.h	readutmp.m4 systemd.m4 00gnulib.m4 zzgnulib.m4 gl_READUTMP	extensions idx stat-time gettimeofday bool stdint-h strnlen time-h unlocked-io-internal xalloc
random_r	#include <stdlib.h>	random_r.c	random_r.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_RANDOM_R gl_CONDITIONAL([GL_COND_OBJ_RANDOM_R], [test $HAVE_RANDOM_R = 0 \|\| test $REPLACE_RANDOM_R = 1]) AM_COND_IF([GL_COND_OBJ_RANDOM_R], [ gl_PREREQ_RANDOM_R ]) gl_STDLIB_MODULE_INDICATOR([random_r])	c99 libc-config [test $HAVE_RANDOM_R = 0 \|\| test $REPLACE_RANDOM_R = 1] stdlib-h stdint-h
selinux-h	#include <selinux/selinux.h> #include <selinux/context.h> #include <selinux/label.h>	getfilecon.c se-context.in.h se-label.in.h se-selinux.in.h se-context.c se-label.c se-selinux.c	selinux-context-h.m4 selinux-label-h.m4 selinux-selinux-h.m4 00gnulib.m4 zzgnulib.m4 gl_HEADERS_SELINUX_SELINUX_H gl_HEADERS_SELINUX_CONTEXT_H gl_HEADERS_SELINUX_LABEL_H gl_CONDITIONAL_HEADER([selinux/context.h]) gl_CONDITIONAL_HEADER([selinux/label.h]) AC_PROG_MKDIR_P gl_CONDITIONAL([GL_COND_OBJ_GETFILECON], [test "$with_selinux" != no && test "$ac_cv_header_selinux_selinux_h" = yes])	errno-h sys_types-h extern-inline gen-header
selinux-at	#include "selinux-at.h"	selinux-at.c at-func.c	00gnulib.m4 zzgnulib.m4 AC_CHECK_HEADERS([selinux/flask.h])	selinux-h at-internal errno-h extensions fchdir fcntl-h filename openat-die openat-h save-cwd unistd-h
sysexits	#include <sysexits.h>	---	00gnulib.m4 zzgnulib.m4	sysexits-h
sys_random	#include <sys/random.h>	---	00gnulib.m4 zzgnulib.m4	sys_random-h
u64	#include "u64.h"	u64.c	00gnulib.m4 zzgnulib.m4	byteswap extern-inline bool stdint-h
verror	#include <error.h>	---	00gnulib.m4 zzgnulib.m4 m4_ifdef([AM_XGETTEXT_OPTION], [AM_][XGETTEXT_OPTION([--flag=verror:3:c-format]) AM_][XGETTEXT_OPTION([--flag=verror_at_line:5:c-format])])	error

Support for building libraries and executables

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
absolute-header	---	---	absolute-header.m4 00gnulib.m4 zzgnulib.m4	---
snippet/arg-nonnull	---	arg-nonnull.h	00gnulib.m4 zzgnulib.m4	---
bison	---	---	bison.m4 00gnulib.m4 zzgnulib.m4 # See the comments in bison.m4.	---
config-h	---	---	config-h.m4 00gnulib.m4 zzgnulib.m4 gl_CONFIG_H	---
configmake	#include "configmake.h"	---	configmake.m4 build-to-host.m4 00gnulib.m4 zzgnulib.m4 gl_CONFIGMAKE AC_PROG_MKDIR_P	gen-header
dummy	---	dummy.c	00gnulib.m4 zzgnulib.m4	---
gperf	---	---	00gnulib.m4 zzgnulib.m4	---
havelib	---	---	lib-ld.m4 lib-link.m4 lib-prefix.m4 host-cpu-c-abi.m4 00gnulib.m4 zzgnulib.m4 AC_DEFUN([gl_HAVE_MODULE_HAVELIB])	---
include_next	---	---	include_next.m4 00gnulib.m4 zzgnulib.m4	absolute-header
ldd	---	---	ldd.m4 00gnulib.m4 zzgnulib.m4 gl_LDD AC_CONFIG_FILES([ldd.sh:build-aux/ldd.sh.in])	---
lib-ignore	---	---	lib-ignore.m4 00gnulib.m4 zzgnulib.m4 gl_IGNORE_UNUSED_LIBRARIES	---
lib-msvc-compat	---	---	ld-output-def.m4 00gnulib.m4 zzgnulib.m4 gl_LD_OUTPUT_DEF	---
lib-symbol-versions	---	---	ld-version-script.m4 00gnulib.m4 zzgnulib.m4 gl_LD_VERSION_SCRIPT	---
snippet/link-warning	---	---	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_FEATURES_H]) AC_PROG_MKDIR_P	gen-header
manywarnings	---	---	manywarnings.m4 manywarnings-c++.m4 00gnulib.m4 zzgnulib.m4	warnings
no-c++	---	---	no-c++.m4 00gnulib.m4 zzgnulib.m4 gt_NO_CXX	---
relocatable-lib	#include "relocatable.h"	relocatable.c relocatable.valgrind	relocatable-lib.m4 build-to-host.m4 00gnulib.m4 zzgnulib.m4 gl_RELOCATABLE_LIBRARY if test $RELOCATABLE = yes; then AC_LIBOBJ([relocatable]) fi	xalloc strdup
relocatable-lib-lgpl	#include "relocatable.h"	relocatable.c relocatable.valgrind	relocatable-lib.m4 build-to-host.m4 00gnulib.m4 zzgnulib.m4 gl_RELOCATABLE_LIBRARY if test $RELOCATABLE = yes; then AC_LIBOBJ([relocatable]) fi	strdup
relocatable-prog	#include "relocatable.h" #include "progname.h"	relocatable.h relocatable.c progreloc.c	relocatable.m4 relocatable-lib.m4 lib-ld.m4 host-cpu-c-abi.m4 00gnulib.m4 zzgnulib.m4 gl_RELOCATABLE([$gl_source_base]) gl_CONDITIONAL([GL_COND_OBJ_PROGRELOC], [test $RELOCATABLE = yes]) AM_COND_IF([GL_COND_OBJ_PROGRELOC], [ AC_LIBOBJ([relocatable]) ])	relocatable-prog-wrapper progname canonicalize-lgpl xalloc xreadlink open bool unistd-h memcmp strdup
relocatable-prog-wrapper	---	relocwrapper.c progname.h progname.c progreloc.c areadlink.h areadlink.c careadlinkat.h careadlinkat.c allocator.h allocator.c readlink.c stat.c stat-time.h stat-time.c canonicalize-lgpl.c scratch_buffer.h malloc/scratch_buffer.h malloc/scratch_buffer_grow.c malloc/scratch_buffer_grow_preserve.c malloc/scratch_buffer_set_array_size.c malloc.c realloc.c free.c mempcpy.c rawmemchr.c malloca.h malloca.c relocatable.h relocatable.c setenv.c c-ctype.h c-ctype.c	largefile.m4 malloca.m4 canonicalize.m4 lstat.m4 environ.m4 free.m4 malloc.m4 mempcpy.m4 rawmemchr.m4 readlink.m4 realloc.m4 relocatable-lib.m4 build-to-host.m4 setenv.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_RESTRICT]) gl_FUNC_READLINK_SEPARATE gl_CANONICALIZE_LGPL_SEPARATE AC_REQUIRE([gl_FUNC_MALLOC_POSIX]) gl_FUNC_REALLOC_POSIX gl_FUNC_FREE gl_FUNC_MEMPCPY gl_FUNC_RAWMEMCHR gl_MALLOCA gl_RELOCATABLE_LIBRARY gl_FUNC_SETENV_SEPARATE	alignasof assert-h c99 double-slash-root eloop-threshold environ errno-h extern-inline fcntl-h filename idx intprops largefile libc-config limits-h pathmax ssize_t bool stddef-h stdckdint-h stdint-h stdlib-h string-h sys_stat-h unistd-h xalloc-oversized
relocatable-script	---	---	relocatable-lib.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_RELOCATABLE_NOP]) relocatable_sh=$ac_aux_dir/relocatable.sh.in AC_SUBST_FILE([relocatable_sh])	---
snippet/warn-on-use	---	warn-on-use.h	warn-on-use.m4 00gnulib.m4 zzgnulib.m4	---
warnings	---	---	warnings.m4 00gnulib.m4 zzgnulib.m4	---

Support for building documentation

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
agpl-3.0	---	---	00gnulib.m4 zzgnulib.m4	---
fdl	---	---	00gnulib.m4 zzgnulib.m4	---
fdl-1.3	---	---	00gnulib.m4 zzgnulib.m4	---
gendocs	---	---	00gnulib.m4 zzgnulib.m4	---
gpl-2.0	---	---	00gnulib.m4 zzgnulib.m4	---
gpl-3.0	---	---	00gnulib.m4 zzgnulib.m4	---
lgpl-2.1	---	---	00gnulib.m4 zzgnulib.m4	---
lgpl-3.0	---	---	00gnulib.m4 zzgnulib.m4	---
pmccabe2html	---	---	00gnulib.m4 zzgnulib.m4 AC_PATH_PROG([PMCCABE], [pmccabe], [false])	---
regexprops-generic	---	---	00gnulib.m4 zzgnulib.m4	---

Support for maintaining and releasing projects

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
announce-gen	---	---	00gnulib.m4 zzgnulib.m4	---
autobuild	---	---	autobuild.m4 00gnulib.m4 zzgnulib.m4	---
do-release-commit-and-tag	---	---	00gnulib.m4 zzgnulib.m4	---
git-version-gen	---	---	00gnulib.m4 zzgnulib.m4	package-version
gitlog-to-changelog	---	---	00gnulib.m4 zzgnulib.m4	---
gnu-web-doc-update	---	---	00gnulib.m4 zzgnulib.m4	gendocs
gnumakefile	---	---	00gnulib.m4 zzgnulib.m4 # Autoconf 2.61a.99 and earlier don't support linking a file only # in VPATH builds. But since GNUmakefile is for maintainer use # only, it does not matter if we skip the link with older autoconf. # Automake 1.10.1 and earlier try to remove GNUmakefile in non-VPATH # builds, so use a shell variable to bypass this. GNUmakefile=GNUmakefile m4_if(m4_version_compare([2.61a.100], m4_defn([m4_PACKAGE_VERSION])), [1], [], [AC_CONFIG_LINKS([$GNUmakefile:$GNUmakefile], [], [GNUmakefile=$GNUmakefile])])	---
gnupload	---	---	00gnulib.m4 zzgnulib.m4	---
maintainer-makefile	---	---	00gnulib.m4 zzgnulib.m4 AC_CONFIG_COMMANDS_PRE([m4_ifdef([AH_HEADER], [AC_SUBST([CONFIG_INCLUDE], m4_defn([AH_HEADER]))])]) AC_REQUIRE([AC_PROG_SED]) AC_REQUIRE([AC_PROG_GREP])	gnumakefile useless-if-before-free vc-list-files
mktempd	---	---	00gnulib.m4 zzgnulib.m4	---
non-recursive-gnulib-prefix-hack	---	---	non-recursive-gnulib-prefix-hack.m4 00gnulib.m4 zzgnulib.m4 dnl Run our hack near the end, just before config.status creation. dnl It must happen late, i.e., after gl_LIBOBJS has been finalized. AC_CONFIG_COMMANDS_PRE([ dnl Note we can't currently pass $gl_source_base instead of 'lib', dnl because $gl_source_base is unset or the wrong value in the references dnl generated in m4/non-recursive-gnulib-prefix-hack.m4 gl_NON_RECURSIVE_GNULIB_PREFIX_HACK([lib]) ])	---
readme-release	---	---	00gnulib.m4 zzgnulib.m4	announce-gen do-release-commit-and-tag gnu-web-doc-update gnupload maintainer-makefile
test-framework-sh	---	---	00gnulib.m4 zzgnulib.m4	---
update-copyright	---	---	00gnulib.m4 zzgnulib.m4	---
useless-if-before-free	---	---	00gnulib.m4 zzgnulib.m4	---
vc-list-files	---	---	00gnulib.m4 zzgnulib.m4	---
vcs-to-changelog	---	---	00gnulib.m4 zzgnulib.m4	---

Misc

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
gnu-make	---	---	gnu-make.m4 00gnulib.m4 zzgnulib.m4 gl_GNU_MAKE	---
host-os	---	---	host-os.m4 00gnulib.m4 zzgnulib.m4 gl_HOST_OS	---
nocrash	---	---	nocrash.m4 00gnulib.m4 zzgnulib.m4	---
perl	---	---	perl.m4 00gnulib.m4 zzgnulib.m4 gl_PERL	---
posix-shell	---	---	posix-shell.m4 00gnulib.m4 zzgnulib.m4 gl_POSIX_SHELL AC_PROG_MKDIR_P	gen-header
uptime	---	---	uptime.m4 00gnulib.m4 zzgnulib.m4 gl_SYS_PROC_UPTIME	---

Unclassified modules - please update MODULES.html.sh

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
abort-debug	#include <stdlib.h>	abort-debug.c	abort-debug.m4 00gnulib.m4 zzgnulib.m4 gl_ABORT_DEBUG gl_CONDITIONAL([GL_COND_OBJ_ABORT_DEBUG], [test $REPLACE_ABORT = 1]) gl_STDLIB_MODULE_INDICATOR([abort-debug])	stdlib-h stack-trace
access	#include <unistd.h>	access.c	access.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ACCESS gl_CONDITIONAL([GL_COND_OBJ_ACCESS], [test $REPLACE_ACCESS = 1]) gl_UNISTD_MODULE_INDICATOR([access])	unistd-h fcntl stat
acosf	#include <math.h>	acosf.c	acosf.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ACOSF gl_CONDITIONAL([GL_COND_OBJ_ACOSF], [test $HAVE_ACOSF = 0]) gl_MATH_MODULE_INDICATOR([acosf])	math-h extensions acos [test $HAVE_ACOSF = 0]
allocator	#include "allocator.h"	allocator.c	00gnulib.m4 zzgnulib.m4	---
ansi-c++-opt	---	---	ansi-c++.m4 00gnulib.m4 zzgnulib.m4	---
arpa_inet	#include <arpa/inet.h>	---	00gnulib.m4 zzgnulib.m4	arpa_inet-h
array-map	#include "gl_array_map.h"	gl_array_map.c	00gnulib.m4 zzgnulib.m4	map stdint-h xsize
array-omap	#include "gl_array_omap.h"	gl_array_omap.c	00gnulib.m4 zzgnulib.m4	omap xsize
array-set	#include "gl_array_set.h"	gl_array_set.c	00gnulib.m4 zzgnulib.m4	set stdint-h xsize
asinf	#include <math.h>	asinf.c	asinf.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ASINF gl_CONDITIONAL([GL_COND_OBJ_ASINF], [test $HAVE_ASINF = 0]) gl_MATH_MODULE_INDICATOR([asinf])	math-h extensions asin [test $HAVE_ASINF = 0]
assert-h	#include <assert.h>	assert.in.h verify.h	assert_h.m4 00gnulib.m4 zzgnulib.m4 gl_ASSERT_H gl_CONDITIONAL_HEADER([assert.h]) AC_PROG_MKDIR_P	gen-header include_next
at-init	#include "at-init.h"	at-init.c	00gnulib.m4 zzgnulib.m4	---
at-internal	#include "openat-priv.h"	openat-proc.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_CANONICAL_HOST])	errno-h fcntl-h intprops open [case $host_os in mingw* \| windows) false;; ) :;; esac] sys_stat-h unistd-h
atan2f	#include <math.h>	atan2f.c	atan2f.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ATAN2F gl_CONDITIONAL([GL_COND_OBJ_ATAN2F], [test $HAVE_ATAN2F = 0]) gl_MATH_MODULE_INDICATOR([atan2f])	math-h extensions atan2 [test $HAVE_ATAN2F = 0]
atanf	#include <math.h>	atanf.c	atanf.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ATANF gl_CONDITIONAL([GL_COND_OBJ_ATANF], [test $HAVE_ATANF = 0]) gl_MATH_MODULE_INDICATOR([atanf])	math-h extensions atan [test $HAVE_ATANF = 0]
avltree-omap	#include "gl_avltree_omap.h"	gl_avltree_omap.c gl_avltree_ordered.h gl_anytree_omap.h	00gnulib.m4 zzgnulib.m4	omap
bcp47	#include "bcp47.h"	bcp47.c	00gnulib.m4 zzgnulib.m4	bool c-ctype
bitset	#include "bitset.h"	bitset.c bitset/array.c bitset/array.h bitset/base.h bitset/list.c bitset/list.h bitset/stats.c bitset/stats.h bitset/table.c bitset/table.h bitset/vector.c bitset/vector.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE])	attribute c99 ffsl fopen-gnu gettext-h gnulib-i18n integer_length_l obstack bool xalloc
bitsetv	#include "bitsetv.h"	bitsetv.c	00gnulib.m4 zzgnulib.m4	bitset c99 xalloc
bool	---	---	c-bool.m4 00gnulib.m4 zzgnulib.m4 gl_C_BOOL	c99
boot-time	#include "boot-time.h"	boot-time.c boot-time-aux.h readutmp.h	readutmp.m4 00gnulib.m4 zzgnulib.m4 gl_PREREQ_READUTMP_H	extensions idx stat-time gettimeofday bool time-h unlocked-io-internal
bsearch	#include <stdlib.h>	---	00gnulib.m4 zzgnulib.m4	---
btoc32	#include <uchar.h>	btoc32.c	00gnulib.m4 zzgnulib.m4 gl_UCHAR_MODULE_INDICATOR([btoc32])	uchar-h mbszero mbrtoc32 btowc
c-file-type	#include "file-type.h"	c-file-type.c	00gnulib.m4 zzgnulib.m4	sys_stat-h
c-nstrftime	#include "strftime.h"	c-nstrftime.c strftime.c	c-nstrftime.m4 tm_gmtoff.m4 00gnulib.m4 zzgnulib.m4 gl_C_GNU_STRFTIME	attribute c-ctype c99 errno-h extensions intprops libc-config locale-h bool stdckdint-h time_rz
c-snprintf	#include "c-snprintf.h"	c-snprintf.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_RESTRICT])	stdint-h stdio-h c-vsnzprintf
c-snzprintf	#include "c-snprintf.h"	c-snzprintf.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_RESTRICT])	stdint-h stdio-h c-vasnprintf
c-snzprintf-gnu	#include "c-snprintf.h"	---	00gnulib.m4 zzgnulib.m4 gl_PREREQ_VASNPRINTF_WITH_GNU_EXTRAS	c-snzprintf mixin/printf-gnu
c-strcasecmp	#include "c-strcase.h"	c-strcasecmp.c	00gnulib.m4 zzgnulib.m4	c-ctype
c-strncasecmp	#include "c-strcase.h"	c-strncasecmp.c	00gnulib.m4 zzgnulib.m4	c-ctype
c-strtof	#include "c-strtod.h"	c-strtof.c c-strtod.c	c-strtod.m4 intl-thread-locale.m4 00gnulib.m4 zzgnulib.m4 gl_C_STRTOF	c99 extensions locale-h c-ctype strtof
c-vasnprintf	#include "c-vasnprintf.h"	c-vasnprintf.c float+.h printf-args.h printf-args.c printf-parse.h printf-parse.c vasnprintf.h vasnprintf.c	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]) AC_LIBOBJ([printf-args]) AC_LIBOBJ([printf-parse]) gl_PREREQ_PRINTF_ARGS gl_PREREQ_PRINTF_PARSE gl_PREREQ_VASNPRINTF_WITH_POSIX_EXTRAS	assert-h attribute limits-h stdint-h stdio-h mixin/printf-posix free-posix nocrash printf-safe alloca-opt xsize errno-h localeconv memchr multiarch mbszero mbsnlen
c-vasprintf	#include "c-vasprintf.h"	c-asprintf.c c-vasprintf.c	00gnulib.m4 zzgnulib.m4	stdint-h stdio-h c-vasnprintf
c-vaszprintf	#include "c-vasprintf.h"	c-aszprintf.c c-vaszprintf.c	00gnulib.m4 zzgnulib.m4	stdint-h stdio-h c-vasnprintf
c-vaszprintf-gnu	#include "c-vasprintf.h"	---	00gnulib.m4 zzgnulib.m4 gl_PREREQ_VASNPRINTF_WITH_GNU_EXTRAS	c-vaszprintf mixin/printf-gnu
c-vsnprintf	#include "c-vsnprintf.h"	c-vsnprintf.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_RESTRICT])	stdint-h stdio-h c-vsnzprintf
c-vsnzprintf	#include "c-vsnprintf.h"	c-vsnzprintf.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_RESTRICT])	stdint-h stdio-h c-vasnprintf
c-vsnzprintf-gnu	#include "c-vsnprintf.h"	---	00gnulib.m4 zzgnulib.m4 gl_PREREQ_VASNPRINTF_WITH_GNU_EXTRAS	c-vsnzprintf mixin/printf-gnu
c-xvasprintf	#include "c-xvasprintf.h"	c-xasprintf.c c-xvasprintf.c	strerrorname_np.m4 00gnulib.m4 zzgnulib.m4 gl_OPTIONAL_STRERRORNAME_NP	extensions stdio-h c-vaszprintf xalloc-die
c32_apply_mapping	#include <uchar.h>	c32_apply_mapping.c	00gnulib.m4 zzgnulib.m4 gl_UCHAR_MODULE_INDICATOR([c32_apply_mapping])	uchar-h towctrans
c32_apply_type_test	#include <uchar.h>	c32_apply_type_test.c	00gnulib.m4 zzgnulib.m4 gl_UCHAR_MODULE_INDICATOR([c32_apply_type_test])	uchar-h iswctype
c32_get_mapping	#include <uchar.h>	c32_get_mapping.c	00gnulib.m4 zzgnulib.m4 gl_UCHAR_MODULE_INDICATOR([c32_get_mapping])	uchar-h wctrans c32tolower c32toupper
c32_get_type_test	#include <uchar.h>	c32_get_type_test.c	00gnulib.m4 zzgnulib.m4 gl_UCHAR_MODULE_INDICATOR([c32_get_type_test])	uchar-h wctype c32isalnum c32isalpha c32isblank c32iscntrl c32isdigit c32isgraph c32islower c32isprint c32ispunct c32isspace c32isupper c32isxdigit
c32isalnum	#include <uchar.h>	c32isalnum.c c32is-impl.h	mbrtoc32.m4 c32rtomb.m4 mbrtowc.m4 locale-en.m4 locale-fr.m4 locale-ja.m4 locale-zh.m4 codeset.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_UCHAR_H]) dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is dnl determined. It describes how mbrtoc32 is implemented. AC_REQUIRE([gl_MBSTATE_T_BROKEN]) AC_REQUIRE([gl_MBRTOC32_SANITYCHECK]) AC_REQUIRE([gl_C32RTOMB_SANITYCHECK]) gl_UCHAR_MODULE_INDICATOR([c32isalnum])	uchar-h wchar-h wctype-h localcharset [test $REPLACE_MBSTATE_T = 1] streq [test $REPLACE_MBSTATE_T = 1] unictype/ctype-alnum assert-h
c32isalpha	#include <uchar.h>	c32isalpha.c c32is-impl.h	mbrtoc32.m4 c32rtomb.m4 mbrtowc.m4 locale-en.m4 locale-fr.m4 locale-ja.m4 locale-zh.m4 codeset.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_UCHAR_H]) dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is dnl determined. It describes how mbrtoc32 is implemented. AC_REQUIRE([gl_MBSTATE_T_BROKEN]) AC_REQUIRE([gl_MBRTOC32_SANITYCHECK]) AC_REQUIRE([gl_C32RTOMB_SANITYCHECK]) gl_UCHAR_MODULE_INDICATOR([c32isalpha])	uchar-h wchar-h wctype-h localcharset [test $REPLACE_MBSTATE_T = 1] streq [test $REPLACE_MBSTATE_T = 1] unictype/ctype-alpha assert-h
c32isblank	#include <uchar.h>	c32isblank.c c32is-impl.h	mbrtoc32.m4 c32rtomb.m4 mbrtowc.m4 locale-en.m4 locale-fr.m4 locale-ja.m4 locale-zh.m4 codeset.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_UCHAR_H]) dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is dnl determined. It describes how mbrtoc32 is implemented. AC_REQUIRE([gl_MBSTATE_T_BROKEN]) AC_REQUIRE([gl_MBRTOC32_SANITYCHECK]) AC_REQUIRE([gl_C32RTOMB_SANITYCHECK]) gl_UCHAR_MODULE_INDICATOR([c32isblank])	uchar-h wchar-h wctype-h iswblank localcharset [test $REPLACE_MBSTATE_T = 1] streq [test $REPLACE_MBSTATE_T = 1] unictype/ctype-blank assert-h
c32iscntrl	#include <uchar.h>	c32iscntrl.c c32is-impl.h	mbrtoc32.m4 c32rtomb.m4 mbrtowc.m4 locale-en.m4 locale-fr.m4 locale-ja.m4 locale-zh.m4 codeset.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_UCHAR_H]) dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is dnl determined. It describes how mbrtoc32 is implemented. AC_REQUIRE([gl_MBSTATE_T_BROKEN]) AC_REQUIRE([gl_MBRTOC32_SANITYCHECK]) AC_REQUIRE([gl_C32RTOMB_SANITYCHECK]) gl_UCHAR_MODULE_INDICATOR([c32iscntrl])	uchar-h wchar-h wctype-h localcharset [test $REPLACE_MBSTATE_T = 1] streq [test $REPLACE_MBSTATE_T = 1] unictype/ctype-cntrl assert-h
c32isdigit	#include <uchar.h>	c32isdigit.c c32is-impl.h	mbrtoc32.m4 c32rtomb.m4 mbrtowc.m4 locale-en.m4 locale-fr.m4 locale-ja.m4 locale-zh.m4 codeset.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_UCHAR_H]) dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is dnl determined. It describes how mbrtoc32 is implemented. AC_REQUIRE([gl_MBSTATE_T_BROKEN]) AC_REQUIRE([gl_MBRTOC32_SANITYCHECK]) AC_REQUIRE([gl_C32RTOMB_SANITYCHECK]) gl_UCHAR_MODULE_INDICATOR([c32isdigit])	uchar-h wchar-h wctype-h iswdigit localcharset [test $REPLACE_MBSTATE_T = 1] streq [test $REPLACE_MBSTATE_T = 1] unictype/ctype-digit assert-h
c32isgraph	#include <uchar.h>	c32isgraph.c c32is-impl.h	mbrtoc32.m4 c32rtomb.m4 mbrtowc.m4 locale-en.m4 locale-fr.m4 locale-ja.m4 locale-zh.m4 codeset.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_UCHAR_H]) dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is dnl determined. It describes how mbrtoc32 is implemented. AC_REQUIRE([gl_MBSTATE_T_BROKEN]) AC_REQUIRE([gl_MBRTOC32_SANITYCHECK]) AC_REQUIRE([gl_C32RTOMB_SANITYCHECK]) gl_UCHAR_MODULE_INDICATOR([c32isgraph])	uchar-h wchar-h wctype-h localcharset [test $REPLACE_MBSTATE_T = 1] streq [test $REPLACE_MBSTATE_T = 1] unictype/ctype-graph assert-h
c32islower	#include <uchar.h>	c32islower.c c32is-impl.h	mbrtoc32.m4 c32rtomb.m4 mbrtowc.m4 locale-en.m4 locale-fr.m4 locale-ja.m4 locale-zh.m4 codeset.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_UCHAR_H]) dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is dnl determined. It describes how mbrtoc32 is implemented. AC_REQUIRE([gl_MBSTATE_T_BROKEN]) AC_REQUIRE([gl_MBRTOC32_SANITYCHECK]) AC_REQUIRE([gl_C32RTOMB_SANITYCHECK]) gl_UCHAR_MODULE_INDICATOR([c32islower])	uchar-h wchar-h wctype-h localcharset [test $REPLACE_MBSTATE_T = 1] streq [test $REPLACE_MBSTATE_T = 1] unictype/ctype-lower assert-h
c32isprint	#include <uchar.h>	c32isprint.c c32is-impl.h	mbrtoc32.m4 c32rtomb.m4 mbrtowc.m4 locale-en.m4 locale-fr.m4 locale-ja.m4 locale-zh.m4 codeset.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_UCHAR_H]) dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is dnl determined. It describes how mbrtoc32 is implemented. AC_REQUIRE([gl_MBSTATE_T_BROKEN]) AC_REQUIRE([gl_MBRTOC32_SANITYCHECK]) AC_REQUIRE([gl_C32RTOMB_SANITYCHECK]) gl_UCHAR_MODULE_INDICATOR([c32isprint])	uchar-h wchar-h wctype-h localcharset [test $REPLACE_MBSTATE_T = 1] streq [test $REPLACE_MBSTATE_T = 1] unictype/ctype-print assert-h
c32ispunct	#include <uchar.h>	c32ispunct.c c32is-impl.h	mbrtoc32.m4 c32rtomb.m4 mbrtowc.m4 locale-en.m4 locale-fr.m4 locale-ja.m4 locale-zh.m4 codeset.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_UCHAR_H]) dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is dnl determined. It describes how mbrtoc32 is implemented. AC_REQUIRE([gl_MBSTATE_T_BROKEN]) AC_REQUIRE([gl_MBRTOC32_SANITYCHECK]) AC_REQUIRE([gl_C32RTOMB_SANITYCHECK]) gl_UCHAR_MODULE_INDICATOR([c32ispunct])	uchar-h wchar-h wctype-h iswpunct localcharset [test $REPLACE_MBSTATE_T = 1] streq [test $REPLACE_MBSTATE_T = 1] unictype/ctype-punct assert-h
c32isspace	#include <uchar.h>	c32isspace.c c32is-impl.h	mbrtoc32.m4 c32rtomb.m4 mbrtowc.m4 locale-en.m4 locale-fr.m4 locale-ja.m4 locale-zh.m4 codeset.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_UCHAR_H]) dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is dnl determined. It describes how mbrtoc32 is implemented. AC_REQUIRE([gl_MBSTATE_T_BROKEN]) AC_REQUIRE([gl_MBRTOC32_SANITYCHECK]) AC_REQUIRE([gl_C32RTOMB_SANITYCHECK]) gl_UCHAR_MODULE_INDICATOR([c32isspace])	uchar-h wchar-h wctype-h localcharset [test $REPLACE_MBSTATE_T = 1] streq [test $REPLACE_MBSTATE_T = 1] unictype/ctype-space assert-h
c32isupper	#include <uchar.h>	c32isupper.c c32is-impl.h	mbrtoc32.m4 c32rtomb.m4 mbrtowc.m4 locale-en.m4 locale-fr.m4 locale-ja.m4 locale-zh.m4 codeset.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_UCHAR_H]) dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is dnl determined. It describes how mbrtoc32 is implemented. AC_REQUIRE([gl_MBSTATE_T_BROKEN]) AC_REQUIRE([gl_MBRTOC32_SANITYCHECK]) AC_REQUIRE([gl_C32RTOMB_SANITYCHECK]) gl_UCHAR_MODULE_INDICATOR([c32isupper])	uchar-h wchar-h wctype-h localcharset [test $REPLACE_MBSTATE_T = 1] streq [test $REPLACE_MBSTATE_T = 1] unictype/ctype-upper assert-h
c32isxdigit	#include <uchar.h>	c32isxdigit.c c32is-impl.h	mbrtoc32.m4 c32rtomb.m4 mbrtowc.m4 locale-en.m4 locale-fr.m4 locale-ja.m4 locale-zh.m4 codeset.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_UCHAR_H]) dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is dnl determined. It describes how mbrtoc32 is implemented. AC_REQUIRE([gl_MBSTATE_T_BROKEN]) AC_REQUIRE([gl_MBRTOC32_SANITYCHECK]) AC_REQUIRE([gl_C32RTOMB_SANITYCHECK]) gl_UCHAR_MODULE_INDICATOR([c32isxdigit])	uchar-h wchar-h wctype-h iswxdigit localcharset [test $REPLACE_MBSTATE_T = 1] streq [test $REPLACE_MBSTATE_T = 1] unictype/ctype-xdigit assert-h
c32rtomb	#include <uchar.h>	c32rtomb.c	c32rtomb.m4 mbrtoc32.m4 locale-en.m4 locale-fr.m4 locale-zh.m4 codeset.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_C32RTOMB gl_CONDITIONAL([GL_COND_OBJ_C32RTOMB], [test $HAVE_C32RTOMB = 0 \|\| test $REPLACE_C32RTOMB = 1]) gl_UCHAR_MODULE_INDICATOR([c32rtomb])	uchar-h attribute [test $HAVE_C32RTOMB = 0 \|\| test $REPLACE_C32RTOMB = 1] wchar-h [test $HAVE_C32RTOMB = 0 \|\| test $REPLACE_C32RTOMB = 1] wcrtomb [test $HAVE_C32RTOMB = 0 \|\| test $REPLACE_C32RTOMB = 1] localcharset [{ test $HAVE_C32RTOMB = 0 \|\| test $REPLACE_C32RTOMB = 1; } && test $SMALL_WCHAR_T = 1] streq [{ test $HAVE_C32RTOMB = 0 \|\| test $REPLACE_C32RTOMB = 1; } && test $SMALL_WCHAR_T = 1]
c32snrtombs	#include <uchar.h>	c32snrtombs.c wcsnrtombs-impl.h c32srtombs-state.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_UCHAR_H]) AC_LIBOBJ([c32srtombs-state]) gl_UCHAR_MODULE_INDICATOR([c32snrtombs])	uchar-h wchar-h assert-h c32rtomb wcsnrtombs [test $SMALL_WCHAR_T = 0]
c32srtombs	#include <uchar.h>	c32srtombs.c wcsrtombs-impl.h c32srtombs-state.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_UCHAR_H]) AC_LIBOBJ([c32srtombs-state]) gl_UCHAR_MODULE_INDICATOR([c32srtombs])	uchar-h wchar-h assert-h c32rtomb wcsrtombs [test $SMALL_WCHAR_T = 0]
c32stombs	#include <uchar.h>	c32stombs.c	00gnulib.m4 zzgnulib.m4 gl_UCHAR_MODULE_INDICATOR([c32stombs])	uchar-h wchar-h mbszero c32srtombs
c32swidth	#include <uchar.h>	c32swidth.c wcswidth-impl.h	locale-ja.m4 locale-zh.m4 codeset.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_UCHAR_H]) dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is dnl determined. It describes how mbrtoc32 is implemented. AC_REQUIRE([gl_MBSTATE_T_BROKEN]) AC_REQUIRE([gl_MBRTOC32_SANITYCHECK]) gl_UCHAR_MODULE_INDICATOR([c32swidth])	uchar-h wchar-h wcswidth c32width
c32tob	#include <uchar.h>	c32tob.c	mbrtoc32.m4 c32rtomb.m4 locale-en.m4 locale-fr.m4 locale-zh.m4 codeset.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_MBRTOC32_SANITYCHECK]) AC_REQUIRE([gl_C32RTOMB_SANITYCHECK]) gl_UCHAR_MODULE_INDICATOR([c32tob])	uchar-h mbszero c32rtomb wctob
c32tolower	#include <uchar.h>	c32tolower.c c32to-impl.h	mbrtoc32.m4 c32rtomb.m4 mbrtowc.m4 locale-en.m4 locale-fr.m4 locale-ja.m4 locale-zh.m4 codeset.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_UCHAR_H]) dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is dnl determined. It describes how mbrtoc32 is implemented. AC_REQUIRE([gl_MBSTATE_T_BROKEN]) AC_REQUIRE([gl_MBRTOC32_SANITYCHECK]) AC_REQUIRE([gl_C32RTOMB_SANITYCHECK]) gl_UCHAR_MODULE_INDICATOR([c32tolower])	uchar-h wchar-h wctype-h localcharset [test $REPLACE_MBSTATE_T = 1] streq [test $REPLACE_MBSTATE_T = 1] unicase/tolower assert-h
c32toupper	#include <uchar.h>	c32toupper.c c32to-impl.h	mbrtoc32.m4 c32rtomb.m4 mbrtowc.m4 locale-en.m4 locale-fr.m4 locale-ja.m4 locale-zh.m4 codeset.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_UCHAR_H]) dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is dnl determined. It describes how mbrtoc32 is implemented. AC_REQUIRE([gl_MBSTATE_T_BROKEN]) AC_REQUIRE([gl_MBRTOC32_SANITYCHECK]) AC_REQUIRE([gl_C32RTOMB_SANITYCHECK]) gl_UCHAR_MODULE_INDICATOR([c32toupper])	uchar-h wchar-h wctype-h localcharset [test $REPLACE_MBSTATE_T = 1] streq [test $REPLACE_MBSTATE_T = 1] unicase/toupper assert-h
c32width	#include <uchar.h>	c32width.c	mbrtoc32.m4 c32rtomb.m4 mbrtowc.m4 locale-en.m4 locale-fr.m4 locale-ja.m4 locale-zh.m4 codeset.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_UCHAR_H]) dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is dnl determined. It describes how mbrtoc32 is implemented. AC_REQUIRE([gl_MBSTATE_T_BROKEN]) AC_REQUIRE([gl_MBRTOC32_SANITYCHECK]) AC_REQUIRE([gl_C32RTOMB_SANITYCHECK]) gl_UCHAR_MODULE_INDICATOR([c32width])	uchar-h wchar-h wcwidth uniwidth/width
call_once	#include <threads.h>	call_once.c	call_once.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_THREADS_H]) gl_FUNC_CALL_ONCE gl_CONDITIONAL([GL_COND_OBJ_CALL_ONCE], [test $HAVE_THREADS_H = 0 \|\| test $REPLACE_CALL_ONCE = 1]) gl_THREADS_MODULE_INDICATOR([call_once])	threads-h pthread-once windows-once
careadlinkat	#include "careadlinkat.h"	careadlinkat.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_RESTRICT]) gl_CHECK_FUNCS_ANDROID([readlinkat], [[#include ]])	allocator idx limits-h minmax ssize_t unistd-h
cbrt-ieee	#include <math.h>	---	00gnulib.m4 zzgnulib.m4	cbrt fpieee
cbrtf	#include <math.h>	cbrtf.c	cbrtf.m4 cbrt.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_CBRTF gl_CONDITIONAL([GL_COND_OBJ_CBRTF], [test $HAVE_CBRTF = 0 \|\| test $REPLACE_CBRTF = 1]) gl_MATH_MODULE_INDICATOR([cbrtf])	math-h extensions isfinite [test $HAVE_CBRTF = 0 \|\| test $REPLACE_CBRTF = 1] fabsf [test $HAVE_CBRTF = 0 \|\| test $REPLACE_CBRTF = 1] frexpf [test $HAVE_CBRTF = 0 \|\| test $REPLACE_CBRTF = 1] ldexpf [test $HAVE_CBRTF = 0 \|\| test $REPLACE_CBRTF = 1]
cbrtf-ieee	#include <math.h>	---	00gnulib.m4 zzgnulib.m4	cbrtf fpieee
cbrtl	#include <math.h>	cbrtl.c	cbrtl.m4 cbrt.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_CBRTL gl_CONDITIONAL([GL_COND_OBJ_CBRTL], [test $HAVE_CBRTL = 0 \|\| test $REPLACE_CBRTL = 1]) gl_MATH_MODULE_INDICATOR([cbrtl])	math-h extensions cbrt [{ test $HAVE_CBRTL = 0 \|\| test $REPLACE_CBRTL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] isfinite [{ test $HAVE_CBRTL = 0 \|\| test $REPLACE_CBRTL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] frexpl [{ test $HAVE_CBRTL = 0 \|\| test $REPLACE_CBRTL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] ldexpl [{ test $HAVE_CBRTL = 0 \|\| test $REPLACE_CBRTL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
cbrtl-ieee	#include <math.h>	---	cbrtl-ieee.m4 minus-zero.m4 signbit.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_CBRTL_IEEE	cbrtl fpieee
ceil-ieee	#include <math.h>	---	ceil-ieee.m4 minus-zero.m4 signbit.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_CEIL_IEEE	ceil
ceilf-ieee	#include <math.h>	---	ceilf-ieee.m4 minus-zero.m4 signbit.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_CEILF_IEEE	ceilf
ceill-ieee	#include <math.h>	---	ceill-ieee.m4 minus-zero.m4 signbit.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_CEILL_IEEE	ceill
chdir	#include <unistd.h>	---	00gnulib.m4 zzgnulib.m4 gl_UNISTD_MODULE_INDICATOR([chdir])	unistd-h
closedir	#include <dirent.h>	closedir.c dirent-private.h	closedir.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_CLOSEDIR gl_CONDITIONAL([GL_COND_OBJ_CLOSEDIR], [test $HAVE_CLOSEDIR = 0 \|\| test $REPLACE_CLOSEDIR = 1]) gl_DIRENT_MODULE_INDICATOR([closedir])	dirent-h dirfd [test $HAVE_CLOSEDIR = 0 \|\| test $REPLACE_CLOSEDIR = 1]
cnd	#include <threads.h>	cnd.c	cnd.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_THREADS_H]) gl_FUNC_CND_INIT gl_CONDITIONAL([GL_COND_OBJ_CND], [test $HAVE_THREADS_H = 0 \|\| test $REPLACE_CND_INIT = 1]) gl_THREADS_MODULE_INDICATOR([cnd])	threads-h windows-cond gettimeofday
copysignf	#include <math.h>	copysignf.c	copysignf.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_COPYSIGNF gl_CONDITIONAL([GL_COND_OBJ_COPYSIGNF], [test $HAVE_COPYSIGNF = 0]) gl_MATH_MODULE_INDICATOR([copysignf])	math-h extensions signbit [test $HAVE_COPYSIGNF = 0]
copysignl	#include <math.h>	copysignl.c	copysignl.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_COPYSIGNL gl_CONDITIONAL([GL_COND_OBJ_COPYSIGNL], [test $HAVE_COPYSIGNL = 0]) gl_MATH_MODULE_INDICATOR([copysignl])	math-h extensions copysign [test $HAVE_COPYSIGNL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] signbit [test $HAVE_COPYSIGNL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
cosf	#include <math.h>	cosf.c	cosf.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_COSF gl_CONDITIONAL([GL_COND_OBJ_COSF], [test $HAVE_COSF = 0]) gl_MATH_MODULE_INDICATOR([cosf])	math-h extensions cos [test $HAVE_COSF = 0]
coshf	#include <math.h>	coshf.c	coshf.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_COSHF gl_CONDITIONAL([GL_COND_OBJ_COSHF], [test $HAVE_COSHF = 0]) gl_MATH_MODULE_INDICATOR([coshf])	math-h extensions cosh [test $HAVE_COSHF = 0]
crc-x86_64	#include "crc-x86_64.h"	crc-x86_64-pclmul.c	crc-x86_64.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_CRC_X86_64_PCLMUL])	stdint-h crc
creat	#include <fcntl.h>	creat.c	creat.m4 open-slash.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_CREAT gl_CONDITIONAL([GL_COND_OBJ_CREAT], [test $REPLACE_CREAT = 1]) gl_FCNTL_MODULE_INDICATOR([creat])	fcntl-h largefile
crypto/af_alg	#include "af_alg.h"	af_alg.c sys-limits.h	af_alg.m4 00gnulib.m4 zzgnulib.m4 gl_AF_ALG	c99 [test $USE_AF_ALG = 1] fflush [test $USE_AF_ALG = 1] fseeko [test $USE_AF_ALG = 1] ftello [test $USE_AF_ALG = 1] fstat [test $USE_AF_ALG = 1] sys_socket-h sys_stat-h
crypto/gc-hmac-sha256	#include "gc.h"	---	gc-hmac-sha256.m4 00gnulib.m4 zzgnulib.m4 gl_GC_HMAC_SHA256 gl_MODULE_INDICATOR([gc-hmac-sha256])	crypto/gc crypto/hmac-sha256 [test "$ac_cv_libgcrypt" != yes]
crypto/gc-hmac-sha512	#include "gc.h"	---	gc-hmac-sha512.m4 00gnulib.m4 zzgnulib.m4 gl_GC_HMAC_SHA512 gl_MODULE_INDICATOR([gc-hmac-sha512])	crypto/gc crypto/hmac-sha512 [test "$ac_cv_libgcrypt" != yes]
crypto/gc-sha256	#include "gc.h"	---	gc-sha256.m4 00gnulib.m4 zzgnulib.m4 gl_GC_SHA256 gl_MODULE_INDICATOR([gc-sha256])	crypto/gc crypto/sha256 [test "$ac_cv_libgcrypt" != yes]
crypto/gc-sha512	#include "gc.h"	---	gc-sha512.m4 00gnulib.m4 zzgnulib.m4 gl_GC_SHA512 gl_MODULE_INDICATOR([gc-sha512])	crypto/gc crypto/sha512 [test "$ac_cv_libgcrypt" != yes]
crypto/hmac-sha256	#include "hmac.h"	hmac.c hmac-sha256.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_RESTRICT])	memxor crypto/sha256
crypto/hmac-sha512	#include "hmac.h"	hmac.c hmac-sha512.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_RESTRICT])	memxor crypto/sha512
ctype-h	#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/arg-nonnull snippet/c++defs snippet/warn-on-use
cygpath	#include "cygpath.h"	cygpath.c	00gnulib.m4 zzgnulib.m4	xalloc free-posix gettext-h gnulib-i18n
dcomp-script	---	---	dcomp.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gt_DCOMP]) AC_CONFIG_FILES([dcomp.sh:build-aux/dcomp.sh.in])	---
di-set	#include "di-set.h"	di-set.c	00gnulib.m4 zzgnulib.m4	ino-map hash stdint-h
dirent-h	#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	assert-h extensions gen-header include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use
dosname	#include "dosname.h"	---	00gnulib.m4 zzgnulib.m4	filename
dprintf-gnu	#include <stdio.h>	---	dprintf-gnu.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_DPRINTF_GNU	dprintf-posix mixin/printf-gnu
dtotimespec	#include "timespec.h"	dtotimespec.c	00gnulib.m4 zzgnulib.m4	intprops timespec
dup	#include <unistd.h>	dup.c	dup.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_DUP gl_CONDITIONAL([GL_COND_OBJ_DUP], [test $REPLACE_DUP = 1]) AM_COND_IF([GL_COND_OBJ_DUP], [ gl_PREREQ_DUP ]) gl_UNISTD_MODULE_INDICATOR([dup])	unistd-h msvc-inval [test $REPLACE_DUP = 1]
dzprintf	#include <stdio.h>	dzprintf.c	00gnulib.m4 zzgnulib.m4 gl_STDIO_MODULE_INDICATOR([dzprintf])	stdio-h vasnprintf intprops free-posix full-write errno-h
dzprintf-gnu	#include <stdio.h>	---	00gnulib.m4 zzgnulib.m4 gl_PREREQ_VASNPRINTF_WITH_GNU_EXTRAS	dzprintf-posix mixin/printf-gnu
dzprintf-posix	#include <stdio.h>	---	00gnulib.m4 zzgnulib.m4 gl_PREREQ_VASNPRINTF_WITH_POSIX_EXTRAS	dzprintf mixin/printf-posix
endian	#include <endian.h>	endian.in.h endian.c	endian_h.m4 00gnulib.m4 zzgnulib.m4 gl_ENDIAN_H gl_CONDITIONAL_HEADER([endian.h]) AC_PROG_MKDIR_P	gen-header include_next extern-inline [$GL_GENERATE_ENDIAN_H && test $ENDIAN_H_JUST_MISSING_STDINT = 0] byteswap [$GL_GENERATE_ENDIAN_H && test $ENDIAN_H_JUST_MISSING_STDINT = 0] stdint-h [$GL_GENERATE_ENDIAN_H]
errno-h	#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 extensions-aix
errno-iter	#include "errno-iter.h"	errno-iter.c	00gnulib.m4 zzgnulib.m4	---
error-h	#include <error.h>	error.in.h	error_h.m4 00gnulib.m4 zzgnulib.m4 gl_ERROR_H AC_PROG_MKDIR_P	gen-header include_next snippet/c++defs
exp-ieee	#include <math.h>	---	00gnulib.m4 zzgnulib.m4	exp fpieee
exp2	#include <math.h>	exp2.c	exp2.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_EXP2 gl_CONDITIONAL([GL_COND_OBJ_EXP2], [test $HAVE_EXP2 = 0 \|\| test $REPLACE_EXP2 = 1]) gl_MATH_MODULE_INDICATOR([exp2])	math-h extensions isnand [test $HAVE_EXP2 = 0 \|\| test $REPLACE_EXP2 = 1] round [test $HAVE_EXP2 = 0 \|\| test $REPLACE_EXP2 = 1] ldexp [test $HAVE_EXP2 = 0 \|\| test $REPLACE_EXP2 = 1]
exp2-ieee	#include <math.h>	---	00gnulib.m4 zzgnulib.m4	exp2 fpieee
exp2f	#include <math.h>	exp2f.c	exp2f.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_EXP2F gl_CONDITIONAL([GL_COND_OBJ_EXP2F], [test $HAVE_EXP2F = 0]) gl_MATH_MODULE_INDICATOR([exp2f])	math-h extensions exp2 [test $HAVE_EXP2F = 0]
exp2f-ieee	#include <math.h>	---	00gnulib.m4 zzgnulib.m4	exp2f fpieee
exp2l	#include <math.h>	exp2l.c expl-table.c	exp2l.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_EXP2L gl_CONDITIONAL([GL_COND_OBJ_EXP2L], [test $HAVE_EXP2L = 0 \|\| test $REPLACE_EXP2L = 1]) AM_COND_IF([GL_COND_OBJ_EXP2L], [ AC_LIBOBJ([expl-table]) ]) gl_MATH_MODULE_INDICATOR([exp2l])	math-h extensions exp2 [{ test $HAVE_EXP2L = 0 \|\| test $REPLACE_EXP2L = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] float-h [{ test $HAVE_EXP2L = 0 \|\| test $REPLACE_EXP2L = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] isnanl [{ test $HAVE_EXP2L = 0 \|\| test $REPLACE_EXP2L = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] roundl [{ test $HAVE_EXP2L = 0 \|\| test $REPLACE_EXP2L = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] ldexpl [{ test $HAVE_EXP2L = 0 \|\| test $REPLACE_EXP2L = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
exp2l-ieee	#include <math.h>	---	exp2l-ieee.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_EXP2L_IEEE	exp2l fpieee
expf	#include <math.h>	expf.c	expf.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_EXPF gl_CONDITIONAL([GL_COND_OBJ_EXPF], [test $HAVE_EXPF = 0]) gl_MATH_MODULE_INDICATOR([expf])	math-h extensions exp [test $HAVE_EXPF = 0]
expf-ieee	#include <math.h>	---	00gnulib.m4 zzgnulib.m4	expf fpieee
expl-ieee	#include <math.h>	---	00gnulib.m4 zzgnulib.m4	expl fpieee
expm1	#include <math.h>	expm1.c	expm1.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_EXPM1 gl_CONDITIONAL([GL_COND_OBJ_EXPM1], [test $HAVE_EXPM1 = 0 \|\| test $REPLACE_EXPM1 = 1]) gl_MATH_MODULE_INDICATOR([expm1])	math-h extensions isnand [test $HAVE_EXPM1 = 0 \|\| test $REPLACE_EXPM1 = 1] exp [test $HAVE_EXPM1 = 0 \|\| test $REPLACE_EXPM1 = 1] round [test $HAVE_EXPM1 = 0 \|\| test $REPLACE_EXPM1 = 1] ldexp [test $HAVE_EXPM1 = 0 \|\| test $REPLACE_EXPM1 = 1]
expm1-ieee	#include <math.h>	---	expm1-ieee.m4 minus-zero.m4 signbit.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_EXPM1_IEEE	expm1 fpieee
expm1f	#include <math.h>	expm1f.c	expm1f.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_EXPM1F gl_CONDITIONAL([GL_COND_OBJ_EXPM1F], [test $HAVE_EXPM1F = 0 \|\| test $REPLACE_EXPM1F = 1]) gl_MATH_MODULE_INDICATOR([expm1f])	math-h extensions expm1 [test $HAVE_EXPM1F = 0 \|\| test $REPLACE_EXPM1F = 1]
expm1f-ieee	#include <math.h>	---	expm1f-ieee.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_EXPM1F_IEEE	expm1f fpieee expm1-ieee [test $HAVE_EXPM1F = 0 \|\| test $REPLACE_EXPM1F = 1]
expm1l	#include <math.h>	expm1l.c	expm1l.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_EXPM1L gl_CONDITIONAL([GL_COND_OBJ_EXPM1L], [test $HAVE_EXPM1L = 0 \|\| test $REPLACE_EXPM1L = 1]) gl_MATH_MODULE_INDICATOR([expm1l])	math-h extensions expm1 [{ test $HAVE_EXPM1L = 0 \|\| test $REPLACE_EXPM1L = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] float-h [{ test $HAVE_EXPM1L = 0 \|\| test $REPLACE_EXPM1L = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] isnanl [{ test $HAVE_EXPM1L = 0 \|\| test $REPLACE_EXPM1L = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] expl [{ test $HAVE_EXPM1L = 0 \|\| test $REPLACE_EXPM1L = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] roundl [{ test $HAVE_EXPM1L = 0 \|\| test $REPLACE_EXPM1L = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] ldexpl [{ test $HAVE_EXPM1L = 0 \|\| test $REPLACE_EXPM1L = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
expm1l-ieee	#include <math.h>	---	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_FUNC_EXPM1L])	expm1l fpieee expm1-ieee [test $HAVE_EXPM1L = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1]
extensions-aix	---	---	extensions-aix.m4 00gnulib.m4 zzgnulib.m4	---
extern-inline	---	---	extern-inline.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_EXTERN_INLINE])	---
fabs-ieee	#include <math.h>	---	00gnulib.m4 zzgnulib.m4	fabs fpieee
fabsf	#include <math.h>	fabsf.c	fabsf.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FABSF gl_CONDITIONAL([GL_COND_OBJ_FABSF], [test $HAVE_FABSF = 0]) gl_MATH_MODULE_INDICATOR([fabsf])	math-h extensions fabs [test $HAVE_FABSF = 0]
fabsf-ieee	#include <math.h>	---	00gnulib.m4 zzgnulib.m4	fabsf fpieee
fabsl	#include <math.h>	fabsl.c	fabsl.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FABSL gl_CONDITIONAL([GL_COND_OBJ_FABSL], [test $HAVE_FABSL = 0 \|\| test $REPLACE_FABSL = 1]) gl_MATH_MODULE_INDICATOR([fabsl])	math-h extensions fabs [{ test $HAVE_FABSL = 0 \|\| test $REPLACE_FABSL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] signbit [{ test $HAVE_FABSL = 0 \|\| test $REPLACE_FABSL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
fabsl-ieee	#include <math.h>	---	00gnulib.m4 zzgnulib.m4	fabsl fpieee
fchmodat	#include <sys/stat.h>	fchmodat.c at-func.c	fchmodat.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FCHMODAT gl_CONDITIONAL([GL_COND_OBJ_FCHMODAT], [test $HAVE_FCHMODAT = 0 \|\| test $REPLACE_FCHMODAT = 1]) AM_COND_IF([GL_COND_OBJ_FCHMODAT], [ gl_PREREQ_FCHMODAT ]) gl_SYS_STAT_MODULE_INDICATOR([fchmodat])	sys_stat-h extensions errno-h [test $HAVE_FCHMODAT = 0 \|\| test $REPLACE_FCHMODAT = 1] fcntl-h [test $HAVE_FCHMODAT = 0 \|\| test $REPLACE_FCHMODAT = 1] unistd-h [test $HAVE_FCHMODAT = 0 \|\| test $REPLACE_FCHMODAT = 1] intprops [test $HAVE_FCHMODAT = 0 \|\| test $REPLACE_FCHMODAT = 1] c99 [test $REPLACE_FCHMODAT = 1] at-internal [test $HAVE_FCHMODAT = 0] chmod [test $HAVE_FCHMODAT = 0] extern-inline [test $HAVE_FCHMODAT = 0] fchdir [test $HAVE_FCHMODAT = 0] filename [test $HAVE_FCHMODAT = 0] lchmod [test $HAVE_FCHMODAT = 0] openat-die [test $HAVE_FCHMODAT = 0] openat-h [test $HAVE_FCHMODAT = 0] save-cwd [test $HAVE_FCHMODAT = 0]
fchownat	#include <unistd.h>	fchownat.c at-func.c	fchownat.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FCHOWNAT gl_CONDITIONAL([GL_COND_OBJ_FCHOWNAT], [test $HAVE_FCHOWNAT = 0 \|\| test $REPLACE_FCHOWNAT = 1]) gl_UNISTD_MODULE_INDICATOR([fchownat])	unistd-h extensions at-internal [test $HAVE_FCHOWNAT = 0 \|\| test $REPLACE_FCHOWNAT = 1] errno-h [test $HAVE_FCHOWNAT = 0 \|\| test $REPLACE_FCHOWNAT = 1] extern-inline [test $HAVE_FCHOWNAT = 0 \|\| test $REPLACE_FCHOWNAT = 1] fchdir [test $HAVE_FCHOWNAT = 0 \|\| test $REPLACE_FCHOWNAT = 1] fcntl-h [test $HAVE_FCHOWNAT = 0 \|\| test $REPLACE_FCHOWNAT = 1] filename [test $HAVE_FCHOWNAT = 0 \|\| test $REPLACE_FCHOWNAT = 1] lchown [test $HAVE_FCHOWNAT = 0 \|\| test $REPLACE_FCHOWNAT = 1] openat-die [test $HAVE_FCHOWNAT = 0 \|\| test $REPLACE_FCHOWNAT = 1] openat-h [test $HAVE_FCHOWNAT = 0 \|\| test $REPLACE_FCHOWNAT = 1] save-cwd [test $HAVE_FCHOWNAT = 0 \|\| test $REPLACE_FCHOWNAT = 1]
fd-hook	#include "fd-hook.h"	fd-hook.c	00gnulib.m4 zzgnulib.m4	unistd-h
fdopen	#include <stdio.h>	fdopen.c	fdopen.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FDOPEN gl_CONDITIONAL([GL_COND_OBJ_FDOPEN], [test $REPLACE_FDOPEN = 1]) AM_COND_IF([GL_COND_OBJ_FDOPEN], [ gl_PREREQ_FDOPEN ]) gl_STDIO_MODULE_INDICATOR([fdopen])	stdio-h msvc-inval [test $REPLACE_FDOPEN = 1]
fenv	#include <fenv.h>	---	00gnulib.m4 zzgnulib.m4	fenv-h
fenv-environment	#include <fenv.h>	fenv-env.c fenv-env-update.c fenv-env-hold.c fenv-private.h	fenv-environment.m4 mathfunc.m4 musl.m4 00gnulib.m4 zzgnulib.m4 gl_FENV_ENVIRONMENT gl_CONDITIONAL([GL_COND_OBJ_FENV_ENVIRONMENT], [test $HAVE_FESETENV = 0 \|\| test $REPLACE_FESETENV = 1]) gl_CONDITIONAL([GL_COND_OBJ_FENV_ENVIRONMENT_UPDATE], [test $HAVE_FEUPDATEENV = 0 \|\| test $REPLACE_FEUPDATEENV = 1]) gl_CONDITIONAL([GL_COND_OBJ_FENV_ENVIRONMENT_HOLD], [test $HAVE_FEHOLDEXCEPT = 0 \|\| test $REPLACE_FEHOLDEXCEPT = 1]) gl_FENV_MODULE_INDICATOR([fegetenv]) gl_FENV_MODULE_INDICATOR([fesetenv]) gl_FENV_MODULE_INDICATOR([feupdateenv]) gl_FENV_MODULE_INDICATOR([feholdexcept]) gl_MUSL_LIBC	fenv-h extensions verify fenv-exceptions-tracking-c99 fenv-exceptions-trapping
fenv-exceptions-state-c23	#include <fenv.h>	fenv-except-state-test.c	fenv-exceptions-state-c23.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FENV_EXCEPTIONS_STATE_C23 gl_CONDITIONAL([GL_COND_OBJ_FENV_EXCEPTIONS_STATE_C23], [test $HAVE_FETESTEXCEPTFLAG = 0]) gl_FENV_MODULE_INDICATOR([fetestexceptflag])	fenv-h fenv-exceptions-state-c99
fenv-exceptions-state-c99	#include <fenv.h>	fenv-except-state-get.c fenv-except-state-set.c fenv-private.h	fenv-exceptions-state.m4 fenv-exceptions.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FENV_EXCEPTIONS_STATE gl_CONDITIONAL([GL_COND_OBJ_FENV_EXCEPTIONS_STATE_GET], [test $HAVE_FEGETEXCEPTFLAG = 0 \|\| test $REPLACE_FEGETEXCEPTFLAG = 1]) gl_CONDITIONAL([GL_COND_OBJ_FENV_EXCEPTIONS_STATE_SET], [test $HAVE_FESETEXCEPTFLAG = 0 \|\| test $REPLACE_FESETEXCEPTFLAG = 1]) gl_FENV_MODULE_INDICATOR([fegetexceptflag]) gl_FENV_MODULE_INDICATOR([fesetexceptflag])	fenv-h
fenv-exceptions-tracking-c23	#include <fenv.h>	fenv-except-tracking-set.c fenv-private.h	fenv-exceptions-tracking-c23.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FENV_EXCEPTIONS_TRACKING_C23 gl_CONDITIONAL([GL_COND_OBJ_FENV_EXCEPTIONS_TRACKING_C23], [test $HAVE_FESETEXCEPT = 0 \|\| test $REPLACE_FESETEXCEPT = 1]) gl_FENV_MODULE_INDICATOR([fesetexcept])	fenv-h fenv-exceptions-tracking-c99
fenv-exceptions-tracking-c99	#include <fenv.h>	fenv-except-tracking-clear.c fenv-except-tracking-test.c fenv-except-tracking-raise.c fenv-private.h	fenv-exceptions-tracking.m4 fenv-exceptions.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FENV_EXCEPTIONS_TRACKING gl_CONDITIONAL([GL_COND_OBJ_FENV_EXCEPTIONS_TRACKING_CLEAR], [test $HAVE_FECLEAREXCEPT = 0 \|\| test $REPLACE_FECLEAREXCEPT = 1]) gl_CONDITIONAL([GL_COND_OBJ_FENV_EXCEPTIONS_TRACKING_TEST], [test $HAVE_FETESTEXCEPT = 0 \|\| test $REPLACE_FETESTEXCEPT = 1]) gl_CONDITIONAL([GL_COND_OBJ_FENV_EXCEPTIONS_TRACKING_RAISE], [test $HAVE_FERAISEEXCEPT = 0 \|\| test $REPLACE_FERAISEEXCEPT = 1]) gl_FENV_MODULE_INDICATOR([feclearexcept]) gl_FENV_MODULE_INDICATOR([fetestexcept]) gl_FENV_MODULE_INDICATOR([feraiseexcept])	fenv-h
fenv-exceptions-trapping	#include <fenv.h>	fenv-except-trapping.c fenv-private.h	fenv-exceptions-trapping.m4 mathfunc.m4 musl.m4 00gnulib.m4 zzgnulib.m4 gl_FENV_EXCEPTIONS_TRAPPING gl_CONDITIONAL([GL_COND_OBJ_FENV_EXCEPTIONS_TRAPPING], [test $HAVE_FEENABLEEXCEPT = 0 \|\| test $REPLACE_FEENABLEEXCEPT = 1]) gl_FENV_MODULE_INDICATOR([feenableexcept]) gl_FENV_MODULE_INDICATOR([fedisableexcept]) gl_FENV_MODULE_INDICATOR([fegetexcept]) gl_MODULE_INDICATOR([feenableexcept])	fenv-h extensions
fenv-h	#include <fenv.h>	fenv.in.h	fenv_h.m4 00gnulib.m4 zzgnulib.m4 gl_FENV_H gl_FENV_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	gen-header include_next snippet/c++defs snippet/warn-on-use
fenv-rounding	#include <fenv.h>	fenv-round.c fenv-private.h	fenv-rounding.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FENV_ROUNDING gl_CONDITIONAL([GL_COND_OBJ_FENV_ROUNDING], [test $HAVE_FESETROUND = 0 \|\| test $REPLACE_FESETROUND = 1]) gl_FENV_MODULE_INDICATOR([fegetround]) gl_FENV_MODULE_INDICATOR([fesetround])	fenv-h
file-has-acl	#include "acl.h"	acl-internal.h file-has-acl.c	acl.m4 selinux-selinux-h.m4 00gnulib.m4 zzgnulib.m4 gl_FILE_HAS_ACL	acl-permissions assert-h attribute dirent-h errno-h extern-inline minmax free-posix limits-h stdint-h malloc-posix ssize_t stat bool stdckdint-h
findprog-in	#include "findprog.h"	findprog-in.c	findprog-in.m4 eaccess.m4 00gnulib.m4 zzgnulib.m4 gl_FINDPROG_IN	bool sys_stat-h filename concat-filename access stat strdup-posix malloc-posix unistd-h
float-h	#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 \|\| test $REPLACE_FLOAT_SNAN = 1]) gl_CONDITIONAL([GL_COND_OBJ_ITOLD], [test $REPLACE_ITOLD = 1]) dnl Prerequisites of lib/float.c. AC_REQUIRE([gl_BIGENDIAN])	gen-header include_next
floor-ieee	#include <math.h>	---	floor-ieee.m4 minus-zero.m4 signbit.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FLOOR_IEEE	floor
floorf-ieee	#include <math.h>	---	floorf-ieee.m4 minus-zero.m4 signbit.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FLOORF_IEEE	floorf
floorl-ieee	#include <math.h>	---	00gnulib.m4 zzgnulib.m4	floorl
fma	#include <math.h>	fma.c float+.h	fma.m4 fegetround.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FMA gl_CONDITIONAL([GL_COND_OBJ_FMA], [test $HAVE_FMA = 0 \|\| test $REPLACE_FMA = 1]) AM_COND_IF([GL_COND_OBJ_FMA], [ gl_PREREQ_FMA ]) gl_MATH_MODULE_INDICATOR([fma])	math-h float-h [test $HAVE_FMA = 0 \|\| test $REPLACE_FMA = 1] bool [test $HAVE_FMA = 0 \|\| test $REPLACE_FMA = 1] assert-h [test $HAVE_FMA = 0 \|\| test $REPLACE_FMA = 1] isfinite [test $HAVE_FMA = 0 \|\| test $REPLACE_FMA = 1] integer_length [test $HAVE_FMA = 0 \|\| test $REPLACE_FMA = 1] frexp [test $HAVE_FMA = 0 \|\| test $REPLACE_FMA = 1] ldexp [test $HAVE_FMA = 0 \|\| test $REPLACE_FMA = 1]
fma-ieee	#include <math.h>	---	00gnulib.m4 zzgnulib.m4	fma fpieee
fmaf	#include <math.h>	fmaf.c fma.c float+.h	fmaf.m4 fegetround.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FMAF gl_CONDITIONAL([GL_COND_OBJ_FMAF], [test $HAVE_FMAF = 0 \|\| test $REPLACE_FMAF = 1]) AM_COND_IF([GL_COND_OBJ_FMAF], [ gl_PREREQ_FMAF ]) gl_MATH_MODULE_INDICATOR([fmaf])	math-h extensions float-h [test $HAVE_FMAF = 0 \|\| test $REPLACE_FMAF = 1] bool [test $HAVE_FMAF = 0 \|\| test $REPLACE_FMAF = 1] assert-h [test $HAVE_FMAF = 0 \|\| test $REPLACE_FMAF = 1] isfinite [test $HAVE_FMAF = 0 \|\| test $REPLACE_FMAF = 1] integer_length [test $HAVE_FMAF = 0 \|\| test $REPLACE_FMAF = 1] frexpf [test $HAVE_FMAF = 0 \|\| test $REPLACE_FMAF = 1] ldexpf [test $HAVE_FMAF = 0 \|\| test $REPLACE_FMAF = 1]
fmaf-ieee	#include <math.h>	---	00gnulib.m4 zzgnulib.m4	fmaf fpieee
fmal	#include <math.h>	fmal.c fma.c float+.h	fmal.m4 fegetround.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FMAL gl_CONDITIONAL([GL_COND_OBJ_FMAL], [test $HAVE_FMAL = 0 \|\| test $REPLACE_FMAL = 1]) AM_COND_IF([GL_COND_OBJ_FMAL], [ gl_PREREQ_FMAL ]) gl_MATH_MODULE_INDICATOR([fmal])	math-h extensions fma [{ test $HAVE_FMAL = 0 \|\| test $REPLACE_FMAL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] float-h [{ test $HAVE_FMAL = 0 \|\| test $REPLACE_FMAL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] bool [{ test $HAVE_FMAL = 0 \|\| test $REPLACE_FMAL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] assert-h [{ test $HAVE_FMAL = 0 \|\| test $REPLACE_FMAL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] isfinite [{ test $HAVE_FMAL = 0 \|\| test $REPLACE_FMAL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] integer_length [{ test $HAVE_FMAL = 0 \|\| test $REPLACE_FMAL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] frexpl [{ test $HAVE_FMAL = 0 \|\| test $REPLACE_FMAL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] ldexpl [{ test $HAVE_FMAL = 0 \|\| test $REPLACE_FMAL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
fmal-ieee	#include <math.h>	---	00gnulib.m4 zzgnulib.m4	fmal fpieee
fmod-ieee	#include <math.h>	---	fmod-ieee.m4 minus-zero.m4 signbit.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FMOD_IEEE	fmod fpieee
fmodf	#include <math.h>	fmodf.c	fmodf.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FMODF gl_CONDITIONAL([GL_COND_OBJ_FMODF], [test $HAVE_FMODF = 0 \|\| test $REPLACE_FMODF = 1]) gl_MATH_MODULE_INDICATOR([fmodf])	math-h extensions fmod [test $HAVE_FMODF = 0 \|\| test $REPLACE_FMODF = 1]
fmodf-ieee	#include <math.h>	---	fmodf-ieee.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FMODF_IEEE	fmodf fpieee fmod-ieee [test $HAVE_FMODF = 0]
fmodl	#include <math.h>	fmodl.c fmod.c	fmodl.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FMODL gl_CONDITIONAL([GL_COND_OBJ_FMODL], [test $HAVE_FMODL = 0 \|\| test $REPLACE_FMODL = 1]) gl_MATH_MODULE_INDICATOR([fmodl])	math-h extensions fmod [{ test $HAVE_FMODL = 0 \|\| test $REPLACE_FMODL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] float-h [{ test $HAVE_FMODL = 0 \|\| test $REPLACE_FMODL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] isfinite [{ test $HAVE_FMODL = 0 \|\| test $REPLACE_FMODL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] signbit [{ test $HAVE_FMODL = 0 \|\| test $REPLACE_FMODL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] fabsl [{ test $HAVE_FMODL = 0 \|\| test $REPLACE_FMODL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] frexpl [{ test $HAVE_FMODL = 0 \|\| test $REPLACE_FMODL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] truncl [{ test $HAVE_FMODL = 0 \|\| test $REPLACE_FMODL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] ldexpl [{ test $HAVE_FMODL = 0 \|\| test $REPLACE_FMODL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] isnanl [{ test $HAVE_FMODL = 0 \|\| test $REPLACE_FMODL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] isinf [{ test $HAVE_FMODL = 0 \|\| test $REPLACE_FMODL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
fmodl-ieee	#include <math.h>	---	fmodl-ieee.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FMODL_IEEE	fmodl fpieee fmod-ieee [{ test $HAVE_FMODL = 0 \|\| test $REPLACE_FMODL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1]
fnmatch-h	#include <fnmatch.h>	fnmatch.in.h	fnmatch_h.m4 00gnulib.m4 zzgnulib.m4 gl_FNMATCH_H gl_FNMATCH_H_REQUIRE_DEFAULTS gl_CONDITIONAL_HEADER([fnmatch.h]) AC_PROG_MKDIR_P	extensions gen-header include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use
fpe-trapping	#include "fpe-trapping.h"	---	fpe-trapping.m4 00gnulib.m4 zzgnulib.m4 gl_FPE_TRAPPING	extensions fenv-exceptions-tracking-c99 fenv-exceptions-trapping
fprintf-gnu	#include <stdio.h>	---	fprintf-gnu.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FPRINTF_GNU	fprintf-posix mixin/printf-gnu
freelocale	#include <locale.h>	freelocale.c	freelocale.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FREELOCALE gl_CONDITIONAL([GL_COND_OBJ_FREELOCALE], [test $HAVE_LOCALE_T = 0]) AM_COND_IF([GL_COND_OBJ_FREELOCALE], [ gl_PREREQ_FREELOCALE ]) gl_LOCALE_MODULE_INDICATOR([freelocale])	locale-h
frexp-ieee	#include <math.h>	---	00gnulib.m4 zzgnulib.m4	frexp fpieee
frexpf	#include <math.h>	frexpf.c	frexpf.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FREXPF gl_CONDITIONAL([GL_COND_OBJ_FREXPF], [test $HAVE_FREXPF = 0 \|\| test $REPLACE_FREXPF = 1]) gl_MATH_MODULE_INDICATOR([frexpf])	math-h extensions frexp [test $HAVE_FREXPF = 0 \|\| test $REPLACE_FREXPF = 1]
frexpf-ieee	#include <math.h>	---	00gnulib.m4 zzgnulib.m4	frexpf fpieee
frexpl-ieee	#include <math.h>	---	00gnulib.m4 zzgnulib.m4	frexpl fpieee
fstat	#include <sys/stat.h>	fstat.c stat-w32.h stat-w32.c	fstat.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FSTAT gl_CONDITIONAL([GL_COND_OBJ_FSTAT], [test $REPLACE_FSTAT = 1]) AM_COND_IF([GL_COND_OBJ_FSTAT], [ case "$host_os" in mingw* \| windows*) AC_LIBOBJ([stat-w32]) ;; esac gl_PREREQ_FSTAT ]) gl_SYS_STAT_MODULE_INDICATOR([fstat]) gl_MODULE_INDICATOR([fstat])	sys_stat-h largefile pathmax [test $REPLACE_FSTAT = 1] stat [test $REPLACE_FSTAT = 1] stat-time [test $REPLACE_FSTAT = 1] unistd-h [test $REPLACE_FSTAT = 1] assert-h [test $REPLACE_FSTAT = 1] msvc-nothrow [test $REPLACE_FSTAT = 1]
fstatat	#include <sys/stat.h>	fstatat.c at-func.c	fstatat.m4 lstat.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FSTATAT gl_CONDITIONAL([GL_COND_OBJ_FSTATAT], [test $HAVE_FSTATAT = 0 \|\| test $REPLACE_FSTATAT = 1]) gl_SYS_STAT_MODULE_INDICATOR([fstatat]) gl_MODULE_INDICATOR([fstatat])	sys_stat-h extensions at-internal [test $HAVE_FSTATAT = 0 \|\| test $REPLACE_FSTATAT = 1] errno-h [test $HAVE_FSTATAT = 0 \|\| test $REPLACE_FSTATAT = 1] extern-inline [test $HAVE_FSTATAT = 0 \|\| test $REPLACE_FSTATAT = 1] fchdir [test $HAVE_FSTATAT = 0 \|\| test $REPLACE_FSTATAT = 1] fcntl-h [test $HAVE_FSTATAT = 0 \|\| test $REPLACE_FSTATAT = 1] filename [test $HAVE_FSTATAT = 0 \|\| test $REPLACE_FSTATAT = 1] lstat [test $HAVE_FSTATAT = 0 \|\| test $REPLACE_FSTATAT = 1] openat-die [test $HAVE_FSTATAT = 0 \|\| test $REPLACE_FSTATAT = 1] openat-h [test $HAVE_FSTATAT = 0 \|\| test $REPLACE_FSTATAT = 1] save-cwd [test $HAVE_FSTATAT = 0 \|\| test $REPLACE_FSTATAT = 1] stat [test $HAVE_FSTATAT = 0 \|\| test $REPLACE_FSTATAT = 1] stat-time [test $HAVE_FSTATAT = 0 \|\| test $REPLACE_FSTATAT = 1]
fzprintf	#include <stdio.h>	fzprintf.c	00gnulib.m4 zzgnulib.m4 gl_STDIO_MODULE_INDICATOR([fzprintf])	stdio-h vasnprintf intprops free-posix fseterr errno-h
fzprintf-gnu	#include <stdio.h>	---	00gnulib.m4 zzgnulib.m4 gl_PREREQ_VASNPRINTF_WITH_GNU_EXTRAS	fzprintf-posix mixin/printf-gnu
fzprintf-posix	#include <stdio.h>	---	00gnulib.m4 zzgnulib.m4 gl_PREREQ_VASNPRINTF_WITH_POSIX_EXTRAS	fzprintf mixin/printf-posix
gen-header	---	---	00gnulib.m4 zzgnulib.m4	---
gen-uni-tables	---	gen-uni-tables.c unictype/3level.h unictype/3levelbit.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE])	memcmp bool strdup strstr-simple str_startswith str_endswith
get-rusage-as	#include "resource-ext.h"	get-rusage-as.c	mmap-anon.m4 00gnulib.m4 zzgnulib.m4 AC_CHECK_FUNCS_ONCE([setrlimit]) gl_FUNC_MMAP_ANON AC_CHECK_HEADERS_ONCE([sys/mman.h]) AC_CHECK_FUNCS_ONCE([mprotect])	stdint-h unistd-h extensions getpagesize open vma-iter
get-rusage-data	#include "resource-ext.h"	get-rusage-data.c	mmap-anon.m4 00gnulib.m4 zzgnulib.m4 AC_CHECK_FUNCS_ONCE([sbrk setrlimit]) gl_FUNC_MMAP_ANON	stdint-h unistd-h extensions getpagesize vma-iter str_endswith
get_ppid_of	#include "get_ppid_of.h"	get_ppid_of.c	00gnulib.m4 zzgnulib.m4	extensions sys_types-h unistd-h open
get_progname_of	#include "get_progname_of.h"	get_progname_of.c	00gnulib.m4 zzgnulib.m4	extensions unistd-h open
getlocalename_l-simple	#include <locale.h>	getlocalename_l.c struniq.h	getlocalename_l.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_GETLOCALENAME_L_SIMPLE gl_CONDITIONAL([GL_COND_OBJ_GETLOCALENAME_L], [test $HAVE_GETLOCALENAME_L = 0 \|\| test $REPLACE_GETLOCALENAME_L = 1]) AM_COND_IF([GL_COND_OBJ_GETLOCALENAME_L], [ gl_PREREQ_GETLOCALENAME_L_SIMPLE ]) gl_MODULE_INDICATOR([getlocalename_l]) gl_LOCALE_MODULE_INDICATOR([getlocalename_l])	locale-h extensions getlocalename_l-unsafe [test $HAVE_GETLOCALENAME_L = 0 \|\| test $REPLACE_GETLOCALENAME_L = 1] flexmember [test $HAVE_GETLOCALENAME_L = 0 \|\| test $REPLACE_GETLOCALENAME_L = 1] lock [test $HAVE_GETLOCALENAME_L = 0 \|\| test $REPLACE_GETLOCALENAME_L = 1] bool [test $HAVE_GETLOCALENAME_L = 0 \|\| test $REPLACE_GETLOCALENAME_L = 1] thread-optim [test $HAVE_GETLOCALENAME_L = 0 \|\| test $REPLACE_GETLOCALENAME_L = 1]
getlocalename_l-unsafe	#include "getlocalename_l-unsafe.h"	getlocalename_l-unsafe.c localename-table.h localename-table.c struniq.h	getlocalename_l.m4 intl-thread-locale.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_GETLOCALENAME_L_UNSAFE gl_PREREQ_GETLOCALENAME_L_UNSAFE gl_LOCALE_MODULE_INDICATOR([getlocalename_l-unsafe])	locale-h getlocalename_l-unsafe-limited flexmember lock bool thread-optim setlocale-fixes setlocale-null free-posix
getlocalename_l-unsafe-limited	#include "getlocalename_l-unsafe.h"	getlocalename_l-unsafe.c	getlocalename_l.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_CANONICAL_HOST]) gl_CONDITIONAL([GL_COND_OBJ_GETLOCALENAME_L_UNSAFE_LIMITED], [case "$host_os" in netbsd* \| solaris) true;; ) false;; esac])	locale-h setlocale-null
getpayload	#include <math.h>	getpayload.c	mathfunc.m4 getpayload.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_GETPAYLOAD gl_CONDITIONAL([GL_COND_OBJ_GETPAYLOAD], [test $HAVE_GETPAYLOAD = 0 \|\| test $REPLACE_GETPAYLOAD = 1]) gl_MATH_MODULE_INDICATOR([getpayload])	math-h extensions float-h [test $HAVE_GETPAYLOAD = 0 \|\| test $REPLACE_GETPAYLOAD = 1] stdint-h [test $HAVE_GETPAYLOAD = 0 \|\| test $REPLACE_GETPAYLOAD = 1] isnand [test $HAVE_GETPAYLOAD = 0 \|\| test $REPLACE_GETPAYLOAD = 1]
getpayloadf	#include <math.h>	getpayloadf.c	mathfunc.m4 getpayload.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_GETPAYLOADF gl_CONDITIONAL([GL_COND_OBJ_GETPAYLOADF], [test $HAVE_GETPAYLOADF = 0 \|\| test $REPLACE_GETPAYLOADF = 1]) gl_MATH_MODULE_INDICATOR([getpayloadf])	math-h extensions float-h [test $HAVE_GETPAYLOADF = 0 \|\| test $REPLACE_GETPAYLOADF = 1] stdint-h [test $HAVE_GETPAYLOADF = 0 \|\| test $REPLACE_GETPAYLOADF = 1] isnanf [test $HAVE_GETPAYLOADF = 0 \|\| test $REPLACE_GETPAYLOADF = 1]
getpayloadl	#include <math.h>	getpayloadl.c	mathfunc.m4 getpayload.m4 exponentl.m4 exponentd.m4 math_h.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_GETPAYLOADL gl_CONDITIONAL([GL_COND_OBJ_GETPAYLOADL], [test $HAVE_GETPAYLOADL = 0 \|\| test $REPLACE_GETPAYLOADL = 1]) gl_MATH_MODULE_INDICATOR([getpayloadl])	math-h extensions getpayload [{ test $HAVE_GETPAYLOADL = 0 \|\| test $REPLACE_GETPAYLOADL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] float-h [{ test $HAVE_GETPAYLOADL = 0 \|\| test $REPLACE_GETPAYLOADL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] stdint-h [{ test $HAVE_GETPAYLOADL = 0 \|\| test $REPLACE_GETPAYLOADL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] isnanl [{ test $HAVE_GETPAYLOADL = 0 \|\| test $REPLACE_GETPAYLOADL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] snan [{ test $HAVE_GETPAYLOADL = 0 \|\| test $REPLACE_GETPAYLOADL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
getrusage	#include <sys/resource.h>	getrusage.c	getrusage.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_GETRUSAGE gl_CONDITIONAL([GL_COND_OBJ_GETRUSAGE], [test $HAVE_GETRUSAGE = 0]) gl_SYS_RESOURCE_MODULE_INDICATOR([getrusage])	sys_resource-h stdint-h [test $HAVE_GETRUSAGE = 0]
git-merge-changelog	---	git-merge-changelog.c	00gnulib.m4 zzgnulib.m4	c99 getopt-gnu idx bool stdint-h stdlib-h error read-file xlist array-list linkedhash-list linked-list rbtreehash-list xalloc xmalloca fstrcmp minmax str_startswith c-strstr fwriteerror memchr memcmp getprogname
glibc-internal/dynarray	#include "dynarray.h"	malloc/dynarray-skeleton.c malloc/dynarray.h malloc/dynarray_at_failure.c malloc/dynarray_emplace_enlarge.c malloc/dynarray_finalize.c malloc/dynarray_resize.c malloc/dynarray_resize_clear.c	00gnulib.m4 zzgnulib.m4 AC_PROG_MKDIR_P	c99 builtin-expect gen-header libc-config bool stdckdint-h stddef-h
glibc-internal/scratch_buffer	#include <scratch_buffer.h>	scratch_buffer.h malloc/scratch_buffer.h malloc/scratch_buffer_grow.c malloc/scratch_buffer_grow_preserve.c malloc/scratch_buffer_set_array_size.c	00gnulib.m4 zzgnulib.m4 AC_PROG_MKDIR_P	c99 builtin-expect gen-header libc-config bool stddef-h malloc-posix realloc-posix free-posix
glob-h	#include <glob.h>	glob.in.h glob-libc.h	glob_h.m4 00gnulib.m4 zzgnulib.m4 gl_GLOB_H gl_GLOB_H_REQUIRE_DEFAULTS gl_CONDITIONAL_HEADER([glob.h]) AC_PROG_MKDIR_P	extensions gen-header include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use libc-config lstat sys_stat-h
gnulib-i18n	---	---	gnulib-i18n.m4 build-to-host.m4 00gnulib.m4 zzgnulib.m4 GNULIB_I18N	---
gocomp-script	---	---	gocomp.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gt_GOCOMP]) AC_CONFIG_FILES([gocomp.sh:build-aux/gocomp.sh.in])	---
hash-map	#include "gl_hash_map.h"	gl_hash_map.c gl_anyhash1.h gl_anyhash2.h gl_anyhash_primes.h	00gnulib.m4 zzgnulib.m4	map stdint-h xsize c99
hash-pjw	#include "hashcode-string2.h"	---	00gnulib.m4 zzgnulib.m4	hashcode-string2
hash-pjw-bare	#include "hashcode-mem.h"	---	00gnulib.m4 zzgnulib.m4	hashcode-mem
hash-set	#include "gl_hash_set.h"	gl_hash_set.c gl_anyhash1.h gl_anyhash2.h gl_anyhash_primes.h	00gnulib.m4 zzgnulib.m4	set stdint-h xsize c99
hash-triple	#include "hashcode-file.h"	---	00gnulib.m4 zzgnulib.m4	hashcode-file-inode
hashcode-named-file	#include "hashcode-file.h"	hashcode-named-file.c hash-triple.h	00gnulib.m4 zzgnulib.m4	hashcode-string2 same-inode bool
hashcode-string1	#include "hashcode-string1.h"	hashcode-string1.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([hashcode-string1])	bitrotate
hashkey-string	#include "hashkey-string.h"	hashkey-string.c	00gnulib.m4 zzgnulib.m4	bool
hasmntopt	#include <mntent.h>	hasmntopt.c	hasmntopt.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_HASMNTOPT gl_CONDITIONAL([GL_COND_OBJ_HASMNTOPT], [test $HAVE_SETMNTENT = 1 && { test $HAVE_HASMNTOPT = 0 \|\| test $REPLACE_HASMNTOPT = 1; }]) AM_COND_IF([GL_COND_OBJ_HASMNTOPT], [ gl_PREREQ_HASMNTOPT ]) gl_MNTENT_MODULE_INDICATOR([hasmntopt])	mntent-h
host-cpu-c-abi	---	---	host-cpu-c-abi.m4 asm-underscore.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_HOST_CPU_C_ABI])	---
htonl	#include <arpa/inet.h>	---	htonl.m4 sys_socket_h.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_HTONL	arpa_inet-h endian
hypot-ieee	#include <math.h>	---	hypot-ieee.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_HYPOT_IEEE	hypot fpieee
hypotf	#include <math.h>	hypotf.c	hypotf.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_HYPOTF gl_CONDITIONAL([GL_COND_OBJ_HYPOTF], [test $HAVE_HYPOTF = 0 \|\| test $REPLACE_HYPOTF = 1]) gl_MATH_MODULE_INDICATOR([hypotf])	math-h extensions hypot [test $HAVE_HYPOTF = 0 \|\| test $REPLACE_HYPOTF = 1]
hypotf-ieee	#include <math.h>	---	hypotf-ieee.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_HYPOTF_IEEE	hypotf fpieee hypot-ieee [test $HAVE_HYPOTF = 0 \|\| test $REPLACE_HYPOTF = 1]
hypotl	#include <math.h>	hypotl.c	hypotl.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_HYPOTL gl_CONDITIONAL([GL_COND_OBJ_HYPOTL], [test $HAVE_HYPOTL = 0 \|\| test $REPLACE_HYPOTL = 1]) gl_MATH_MODULE_INDICATOR([hypotl])	math-h extensions hypot [{ test $HAVE_HYPOTL = 0 \|\| test $REPLACE_HYPOTL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] isfinite [{ test $HAVE_HYPOTL = 0 \|\| test $REPLACE_HYPOTL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] fabsl [{ test $HAVE_HYPOTL = 0 \|\| test $REPLACE_HYPOTL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] frexpl [{ test $HAVE_HYPOTL = 0 \|\| test $REPLACE_HYPOTL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] ldexpl [{ test $HAVE_HYPOTL = 0 \|\| test $REPLACE_HYPOTL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] sqrtl [{ test $HAVE_HYPOTL = 0 \|\| test $REPLACE_HYPOTL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] isinf [{ test $HAVE_HYPOTL = 0 \|\| test $REPLACE_HYPOTL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
hypotl-ieee	#include <math.h>	---	hypotl-ieee.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_HYPOTL_IEEE	hypotl fpieee hypot-ieee [{ test $HAVE_HYPOTL = 0 \|\| test $REPLACE_HYPOTL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1]
ilogb	#include <math.h>	ilogb.c	ilogb.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ILOGB gl_CONDITIONAL([GL_COND_OBJ_ILOGB], [test $HAVE_ILOGB = 0 \|\| test $REPLACE_ILOGB = 1]) gl_MATH_MODULE_INDICATOR([ilogb])	math-h isfinite [test $HAVE_ILOGB = 0 \|\| test $REPLACE_ILOGB = 1] frexp [test $HAVE_ILOGB = 0 \|\| test $REPLACE_ILOGB = 1] isnand [test $HAVE_ILOGB = 0 \|\| test $REPLACE_ILOGB = 1]
ilogbf	#include <math.h>	ilogbf.c ilogb.c	ilogbf.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ILOGBF gl_CONDITIONAL([GL_COND_OBJ_ILOGBF], [test $HAVE_ILOGBF = 0 \|\| test $REPLACE_ILOGBF = 1]) gl_MATH_MODULE_INDICATOR([ilogbf])	math-h extensions isfinite [test $HAVE_ILOGBF = 0 \|\| test $REPLACE_ILOGBF = 1] frexpf [test $HAVE_ILOGBF = 0 \|\| test $REPLACE_ILOGBF = 1] isnanf [test $HAVE_ILOGBF = 0 \|\| test $REPLACE_ILOGBF = 1]
ilogbl	#include <math.h>	ilogbl.c ilogb.c	ilogbl.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ILOGBL gl_CONDITIONAL([GL_COND_OBJ_ILOGBL], [test $HAVE_ILOGBL = 0 \|\| test $REPLACE_ILOGBL = 1]) gl_MATH_MODULE_INDICATOR([ilogbl])	math-h extensions ilogb [{ test $HAVE_ILOGBL = 0 \|\| test $REPLACE_ILOGBL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] isfinite [{ test $HAVE_ILOGBL = 0 \|\| test $REPLACE_ILOGBL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] frexpl [{ test $HAVE_ILOGBL = 0 \|\| test $REPLACE_ILOGBL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] isnanl [{ test $HAVE_ILOGBL = 0 \|\| test $REPLACE_ILOGBL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
ino-map	#include "ino-map.h"	ino-map.c	00gnulib.m4 zzgnulib.m4	assert-h hash
integer_length	#include "integer_length.h"	integer_length.c float+.h	exponentd.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_DOUBLE_EXPONENT_LOCATION])	float-h
integer_length_l	#include "integer_length.h"	integer_length_l.c	00gnulib.m4 zzgnulib.m4	integer_length
integer_length_ll	#include "integer_length.h"	integer_length_ll.c integer_length_l.c	00gnulib.m4 zzgnulib.m4	integer_length
inttypes-h	#include <inttypes.h>	---	00gnulib.m4 zzgnulib.m4 gl_INTTYPES_H	inttypes-h-incomplete extensions
inttypes-h-incomplete	#include <inttypes.h>	inttypes.in.h	inttypes.m4 00gnulib.m4 zzgnulib.m4 gl_INTTYPES_INCOMPLETE gl_INTTYPES_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	gen-header include_next multiarch snippet/arg-nonnull snippet/c++defs snippet/warn-on-use stdint-h
inttypes-incomplete	#include <inttypes.h>	---	00gnulib.m4 zzgnulib.m4	inttypes-h-incomplete
isalnum_l	#include <ctype.h>	isalnum_l.c is_l-impl.h	isalnum_l.m4 intl-thread-locale.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ISALNUM_L gl_CONDITIONAL([GL_COND_OBJ_ISALNUM_L], [test $HAVE_ISALNUM_L = 0]) gl_MODULE_INDICATOR([isalnum_l]) gl_CTYPE_MODULE_INDICATOR([isalnum_l])	ctype-h locale-h extensions
isalpha_l	#include <ctype.h>	isalpha_l.c is_l-impl.h	isalpha_l.m4 intl-thread-locale.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ISALPHA_L gl_CONDITIONAL([GL_COND_OBJ_ISALPHA_L], [test $HAVE_ISALPHA_L = 0]) gl_MODULE_INDICATOR([isalpha_l]) gl_CTYPE_MODULE_INDICATOR([isalpha_l])	ctype-h locale-h extensions
isatty	#include <unistd.h>	isatty.c	isatty.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ISATTY gl_CONDITIONAL([GL_COND_OBJ_ISATTY], [test $REPLACE_ISATTY = 1]) AM_COND_IF([GL_COND_OBJ_ISATTY], [ gl_PREREQ_ISATTY ]) gl_UNISTD_MODULE_INDICATOR([isatty])	unistd-h msvc-inval [test $REPLACE_ISATTY = 1] msvc-nothrow [test $REPLACE_ISATTY = 1] str_endswith [test $REPLACE_ISATTY = 1]
isblank_l	#include <ctype.h>	isblank_l.c is_l-impl.h	isblank_l.m4 intl-thread-locale.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ISBLANK_L gl_CONDITIONAL([GL_COND_OBJ_ISBLANK_L], [test $HAVE_ISBLANK_L = 0]) gl_MODULE_INDICATOR([isblank_l]) gl_CTYPE_MODULE_INDICATOR([isblank_l])	ctype-h locale-h extensions
iscntrl_l	#include <ctype.h>	iscntrl_l.c is_l-impl.h	iscntrl_l.m4 intl-thread-locale.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ISCNTRL_L gl_CONDITIONAL([GL_COND_OBJ_ISCNTRL_L], [test $HAVE_ISCNTRL_L = 0]) gl_MODULE_INDICATOR([iscntrl_l]) gl_CTYPE_MODULE_INDICATOR([iscntrl_l])	ctype-h locale-h extensions
isdigit_l	#include <ctype.h>	isdigit_l.c	isdigit_l.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ISDIGIT_L gl_CONDITIONAL([GL_COND_OBJ_ISDIGIT_L], [test $HAVE_ISDIGIT_L = 0]) gl_MODULE_INDICATOR([isdigit_l]) gl_CTYPE_MODULE_INDICATOR([isdigit_l])	ctype-h locale-h extensions
isgraph_l	#include <ctype.h>	isgraph_l.c is_l-impl.h	isgraph_l.m4 intl-thread-locale.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ISGRAPH_L gl_CONDITIONAL([GL_COND_OBJ_ISGRAPH_L], [test $HAVE_ISGRAPH_L = 0]) gl_MODULE_INDICATOR([isgraph_l]) gl_CTYPE_MODULE_INDICATOR([isgraph_l])	ctype-h locale-h extensions
islower_l	#include <ctype.h>	islower_l.c is_l-impl.h	islower_l.m4 intl-thread-locale.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ISLOWER_L gl_CONDITIONAL([GL_COND_OBJ_ISLOWER_L], [test $HAVE_ISLOWER_L = 0]) gl_MODULE_INDICATOR([islower_l]) gl_CTYPE_MODULE_INDICATOR([islower_l])	ctype-h locale-h extensions
isprint_l	#include <ctype.h>	isprint_l.c is_l-impl.h	isprint_l.m4 intl-thread-locale.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ISPRINT_L gl_CONDITIONAL([GL_COND_OBJ_ISPRINT_L], [test $HAVE_ISPRINT_L = 0]) gl_MODULE_INDICATOR([isprint_l]) gl_CTYPE_MODULE_INDICATOR([isprint_l])	ctype-h locale-h extensions
ispunct_l	#include <ctype.h>	ispunct_l.c is_l-impl.h	ispunct_l.m4 intl-thread-locale.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ISPUNCT_L gl_CONDITIONAL([GL_COND_OBJ_ISPUNCT_L], [test $HAVE_ISPUNCT_L = 0]) gl_MODULE_INDICATOR([ispunct_l]) gl_CTYPE_MODULE_INDICATOR([ispunct_l])	ctype-h locale-h extensions
isspace_l	#include <ctype.h>	isspace_l.c is_l-impl.h	isspace_l.m4 intl-thread-locale.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ISSPACE_L gl_CONDITIONAL([GL_COND_OBJ_ISSPACE_L], [test $HAVE_ISSPACE_L = 0]) gl_MODULE_INDICATOR([isspace_l]) gl_CTYPE_MODULE_INDICATOR([isspace_l])	ctype-h locale-h extensions
isupper_l	#include <ctype.h>	isupper_l.c is_l-impl.h	isupper_l.m4 intl-thread-locale.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ISUPPER_L gl_CONDITIONAL([GL_COND_OBJ_ISUPPER_L], [test $HAVE_ISUPPER_L = 0]) gl_MODULE_INDICATOR([isupper_l]) gl_CTYPE_MODULE_INDICATOR([isupper_l])	ctype-h locale-h extensions
iswblank	#include <wctype.h>	iswblank.c	iswblank.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ISWBLANK gl_CONDITIONAL([GL_COND_OBJ_ISWBLANK], [! { test $HAVE_ISWCNTRL = 0 \|\| test $REPLACE_ISWCNTRL = 1; } && { test $HAVE_ISWBLANK = 0 \|\| test $REPLACE_ISWBLANK = 1; }]) gl_WCTYPE_MODULE_INDICATOR([iswblank])	wctype-h extensions
iswctype	#include <wctype.h>	iswctype.c iswctype-impl.h	iswctype.m4 wctype.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ISWCTYPE gl_CONDITIONAL([GL_COND_OBJ_ISWCTYPE], [test $HAVE_WCTYPE_T = 0 \|\| test $GNULIBHEADERS_OVERRIDE_WINT_T = 1 \|\| test $REPLACE_WCTYPE = 1]) gl_WCTYPE_MODULE_INDICATOR([iswctype])	wctype-h
iswdigit	#include <wctype.h>	iswdigit.c	iswdigit.m4 locale-en.m4 locale-fr.m4 locale-ja.m4 locale-zh.m4 codeset.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ISWDIGIT gl_CONDITIONAL([GL_COND_OBJ_ISWDIGIT], [! { test $HAVE_ISWCNTRL = 0 \|\| test $REPLACE_ISWCNTRL = 1; } && test $REPLACE_ISWDIGIT = 1]) gl_WCTYPE_MODULE_INDICATOR([iswdigit])	wctype-h
iswpunct	#include <wctype.h>	iswpunct.c	iswpunct.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ISWPUNCT gl_CONDITIONAL([GL_COND_OBJ_ISWPUNCT], [! { test $HAVE_ISWCNTRL = 0 \|\| test $REPLACE_ISWCNTRL = 1; } && test $REPLACE_ISWPUNCT = 1]) gl_WCTYPE_MODULE_INDICATOR([iswpunct])	wctype-h
iswxdigit	#include <wctype.h>	iswxdigit.c	iswxdigit.m4 locale-en.m4 locale-ja.m4 locale-zh.m4 codeset.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ISWXDIGIT gl_CONDITIONAL([GL_COND_OBJ_ISWXDIGIT], [! { test $HAVE_ISWCNTRL = 0 \|\| test $REPLACE_ISWCNTRL = 1; } && test $REPLACE_ISWXDIGIT = 1]) gl_WCTYPE_MODULE_INDICATOR([iswxdigit])	wctype-h
isxdigit_l	#include <ctype.h>	isxdigit_l.c	isxdigit_l.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ISXDIGIT_L gl_CONDITIONAL([GL_COND_OBJ_ISXDIGIT_L], [test $HAVE_ISXDIGIT_L = 0]) gl_MODULE_INDICATOR([isxdigit_l]) gl_CTYPE_MODULE_INDICATOR([isxdigit_l])	ctype-h locale-h extensions
jit/cache	#include "jit/cache.h"	---	valgrind-helper.m4 00gnulib.m4 zzgnulib.m4 gl_VALGRIND_HELPER AC_REQUIRE([AC_C_INLINE]) AC_CHECK_FUNCS([__clear_cache])	stdint-h
kwset	#include "kwset.h"	kwset.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE])	idx memchr2 minmax nullptr obstack snippet/arg-nonnull stdckdint-h stdint-h verify xalloc
langinfo-h	#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
ldexp-ieee	#include <math.h>	---	00gnulib.m4 zzgnulib.m4	ldexp fpieee
ldexpf	#include <math.h>	ldexpf.c	ldexpf.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_LDEXPF gl_CONDITIONAL([GL_COND_OBJ_LDEXPF], [test $HAVE_LDEXPF = 0]) gl_MATH_MODULE_INDICATOR([ldexpf])	math-h extensions ldexp [test $HAVE_LDEXPF = 0]
ldexpf-ieee	#include <math.h>	---	00gnulib.m4 zzgnulib.m4	ldexpf fpieee
ldexpl-ieee	#include <math.h>	---	00gnulib.m4 zzgnulib.m4	ldexpl fpieee
libtextstyle	#if HAVE_LIBTEXTSTYLE # include <textstyle.h> #endif	---	libtextstyle.m4 00gnulib.m4 zzgnulib.m4 # You need to invoke gl_LIBTEXTSTYLE yourself, possibly with arguments.	havelib
libtextstyle-optional	#include <textstyle.h>	textstyle.in.h	libtextstyle-optional.m4 00gnulib.m4 zzgnulib.m4 # You need to invoke gl_LIBTEXTSTYLE_OPTIONAL yourself, possibly with arguments. if test -z "$GL_GENERATE_TEXTSTYLE_H"; then GL_GENERATE_TEXTSTYLE_H=false fi gl_CONDITIONAL_HEADER([textstyle.h]) AC_PROG_MKDIR_P	gen-header libtextstyle bool stdio-h unistd-h fsync vasprintf-posix
linkedhash-map	#include "gl_linkedhash_map.h"	gl_linkedhash_map.c gl_anyhash1.h gl_anyhash2.h gl_anyhash_primes.h	00gnulib.m4 zzgnulib.m4	map stdint-h xsize c99
linkedhash-set	#include "gl_linkedhash_set.h"	gl_linkedhash_set.c gl_anyhash1.h gl_anyhash2.h gl_anyhash_primes.h	00gnulib.m4 zzgnulib.m4	set stdint-h xsize c99
list-c++	#include "gl_list.hh"	---	00gnulib.m4 zzgnulib.m4	xlist xsublist
locale-h	#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-h bool
localeconv	#include <locale.h>	localeconv.c	localeconv.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_LOCALECONV gl_CONDITIONAL([GL_COND_OBJ_LOCALECONV], [test $REPLACE_LOCALECONV = 1]) AM_COND_IF([GL_COND_OBJ_LOCALECONV], [ gl_PREREQ_LOCALECONV ]) gl_LOCALE_MODULE_INDICATOR([localeconv]) gl_MODULE_INDICATOR([localeconv])	locale-h
localename-environ	#include "localename.h"	localename-environ.c	localename.m4 intlmacosx.m4 00gnulib.m4 zzgnulib.m4 gl_LOCALENAME_ENVIRON gl_LOCALE_MODULE_INDICATOR([localename-environ])	---
localename-unsafe	#include "localename.h"	localename-unsafe.c	localename.m4 intl-thread-locale.m4 intlmacosx.m4 lcmessage.m4 musl.m4 00gnulib.m4 zzgnulib.m4 gl_LOCALENAME_UNSAFE gl_LOCALE_MODULE_INDICATOR([localename-unsafe]) gl_MUSL_LIBC	localename-unsafe-limited localename-environ extensions locale-h strdup lock getlocalename_l-unsafe setlocale-null-unlocked
localename-unsafe-limited	#include "localename.h"	localename-unsafe.c	localename.m4 intl-thread-locale.m4 lcmessage.m4 00gnulib.m4 zzgnulib.m4 gl_LOCALENAME_UNSAFE_LIMITED AC_REQUIRE([AC_CANONICAL_HOST]) gl_CONDITIONAL([GL_COND_OBJ_LOCALENAME_UNSAFE_LIMITED], [case "$host_os" in netbsd* \| solaris) true;; ) false;; esac])	extensions locale-h getlocalename_l-unsafe-limited setlocale-null-unlocked
log-ieee	#include <math.h>	---	log-ieee.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_LOG_IEEE	log fpieee
log10-ieee	#include <math.h>	---	log10-ieee.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_LOG10_IEEE	log10 fpieee
log10f	#include <math.h>	log10f.c	log10f.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_LOG10F gl_CONDITIONAL([GL_COND_OBJ_LOG10F], [test $HAVE_LOG10F = 0 \|\| test $REPLACE_LOG10F = 1]) gl_MATH_MODULE_INDICATOR([log10f])	math-h extensions log10 [test $HAVE_LOG10F = 0 \|\| test $REPLACE_LOG10F = 1]
log10f-ieee	#include <math.h>	---	log10f-ieee.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_LOG10F_IEEE	log10f fpieee log10-ieee [test $HAVE_LOG10F = 0 \|\| test $REPLACE_LOG10F = 1]
log10l	#include <math.h>	log10l.c	log10l.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_LOG10L gl_CONDITIONAL([GL_COND_OBJ_LOG10L], [test $HAVE_LOG10L = 0 \|\| test $REPLACE_LOG10L = 1]) gl_MATH_MODULE_INDICATOR([log10l])	math-h extensions log10 [{ test $HAVE_LOG10L = 0 \|\| test $REPLACE_LOG10L = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] float-h [{ test $HAVE_LOG10L = 0 \|\| test $REPLACE_LOG10L = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] logl [{ test $HAVE_LOG10L = 0 \|\| test $REPLACE_LOG10L = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
log10l-ieee	#include <math.h>	---	00gnulib.m4 zzgnulib.m4	log10l fpieee
log1p-ieee	#include <math.h>	---	log1p-ieee.m4 minus-zero.m4 signbit.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_LOG1P_IEEE	log1p fpieee
log1pf	#include <math.h>	log1pf.c	log1pf.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_LOG1PF gl_CONDITIONAL([GL_COND_OBJ_LOG1PF], [test $HAVE_LOG1PF = 0 \|\| test $REPLACE_LOG1PF = 1]) gl_MATH_MODULE_INDICATOR([log1pf])	math-h extensions log1p [test $HAVE_LOG1PF = 0 \|\| test $REPLACE_LOG1PF = 1]
log1pf-ieee	#include <math.h>	---	log1pf-ieee.m4 minus-zero.m4 signbit.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_LOG1PF_IEEE	log1pf fpieee log1p-ieee [test $HAVE_LOG1PF = 0 \|\| test $REPLACE_LOG1PF = 1]
log1pl	#include <math.h>	log1pl.c	log1pl.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_LOG1PL gl_CONDITIONAL([GL_COND_OBJ_LOG1PL], [test $HAVE_LOG1PL = 0 \|\| test $REPLACE_LOG1PL = 1]) gl_MATH_MODULE_INDICATOR([log1pl])	math-h extensions log1p [{ test $HAVE_LOG1PL = 0 \|\| test $REPLACE_LOG1PL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] isnanl [{ test $HAVE_LOG1PL = 0 \|\| test $REPLACE_LOG1PL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] logl [{ test $HAVE_LOG1PL = 0 \|\| test $REPLACE_LOG1PL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] roundl [{ test $HAVE_LOG1PL = 0 \|\| test $REPLACE_LOG1PL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
log1pl-ieee	#include <math.h>	---	log1pl-ieee.m4 minus-zero.m4 signbit.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_LOG1PL_IEEE	log1pl fpieee log1p-ieee [{ test $HAVE_LOG1PL = 0 \|\| test $REPLACE_LOG1PL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1]
log2	#include <math.h>	log2.c	log2.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_LOG2 gl_CONDITIONAL([GL_COND_OBJ_LOG2], [test $HAVE_LOG2 = 0 \|\| test $REPLACE_LOG2 = 1]) gl_MATH_MODULE_INDICATOR([log2])	math-h extensions isnand [test $HAVE_LOG2 = 0 \|\| test $REPLACE_LOG2 = 1] frexp [test $HAVE_LOG2 = 0 \|\| test $REPLACE_LOG2 = 1] log [test $HAVE_LOG2 = 0 \|\| test $REPLACE_LOG2 = 1]
log2-ieee	#include <math.h>	---	log2-ieee.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_LOG2_IEEE	log2 fpieee
log2f	#include <math.h>	log2f.c	log2f.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_LOG2F gl_CONDITIONAL([GL_COND_OBJ_LOG2F], [test $HAVE_LOG2F = 0 \|\| test $REPLACE_LOG2F = 1]) gl_MATH_MODULE_INDICATOR([log2f])	math-h extensions log2 [test $HAVE_LOG2F = 0 \|\| test $REPLACE_LOG2F = 1] isnanf [test $HAVE_LOG2F = 0 \|\| test $REPLACE_LOG2F = 1] frexpf [test $HAVE_LOG2F = 0 \|\| test $REPLACE_LOG2F = 1] logf [test $HAVE_LOG2F = 0 \|\| test $REPLACE_LOG2F = 1]
log2f-ieee	#include <math.h>	---	log2f-ieee.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_LOG2F_IEEE	log2f fpieee log2-ieee [test $HAVE_LOG2F = 0 \|\| test $REPLACE_LOG2F = 1]
log2l	#include <math.h>	log2l.c	log2l.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_LOG2L gl_CONDITIONAL([GL_COND_OBJ_LOG2L], [test $HAVE_LOG2L = 0 \|\| test $REPLACE_LOG2L = 1]) gl_MATH_MODULE_INDICATOR([log2l])	math-h extensions log2 [{ test $HAVE_LOG2L = 0 \|\| test $REPLACE_LOG2L = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] isnanl [{ test $HAVE_LOG2L = 0 \|\| test $REPLACE_LOG2L = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] frexpl [{ test $HAVE_LOG2L = 0 \|\| test $REPLACE_LOG2L = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] logl [{ test $HAVE_LOG2L = 0 \|\| test $REPLACE_LOG2L = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
log2l-ieee	#include <math.h>	---	00gnulib.m4 zzgnulib.m4	log2l fpieee
logb-ieee	#include <math.h>	---	00gnulib.m4 zzgnulib.m4	logb fpieee
logbf	#include <math.h>	logbf.c logb.c	logbf.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_LOGBF gl_CONDITIONAL([GL_COND_OBJ_LOGBF], [test $HAVE_LOGBF = 0 \|\| test $REPLACE_LOGBF = 1]) gl_MATH_MODULE_INDICATOR([logbf])	math-h extensions isfinite [test $HAVE_LOGBF = 0 \|\| test $REPLACE_LOGBF = 1] frexpf [test $HAVE_LOGBF = 0 \|\| test $REPLACE_LOGBF = 1] isnanf [test $HAVE_LOGBF = 0 \|\| test $REPLACE_LOGBF = 1]
logbf-ieee	#include <math.h>	---	00gnulib.m4 zzgnulib.m4	logbf fpieee
logbl	#include <math.h>	logbl.c logb.c	logbl.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_LOGBL gl_CONDITIONAL([GL_COND_OBJ_LOGBL], [test $HAVE_LOGBL = 0 \|\| test $REPLACE_LOGBL = 1]) gl_MATH_MODULE_INDICATOR([logbl])	math-h extensions logb [{ test $HAVE_LOGBL = 0 \|\| test $REPLACE_LOGBL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] isfinite [{ test $HAVE_LOGBL = 0 \|\| test $REPLACE_LOGBL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] frexpl [{ test $HAVE_LOGBL = 0 \|\| test $REPLACE_LOGBL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] isnanl [{ test $HAVE_LOGBL = 0 \|\| test $REPLACE_LOGBL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
logbl-ieee	#include <math.h>	---	00gnulib.m4 zzgnulib.m4	logbl fpieee
logf	#include <math.h>	logf.c	logf.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_LOGF gl_CONDITIONAL([GL_COND_OBJ_LOGF], [test $HAVE_LOGF = 0 \|\| test $REPLACE_LOGF = 1]) gl_MATH_MODULE_INDICATOR([logf])	math-h extensions log [test $HAVE_LOGF = 0 \|\| test $REPLACE_LOGF = 1]
logf-ieee	#include <math.h>	---	logf-ieee.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_LOGF_IEEE	logf fpieee log-ieee [test $HAVE_LOGF = 0 \|\| test $REPLACE_LOGF = 1]
logl-ieee	#include <math.h>	---	00gnulib.m4 zzgnulib.m4	logl fpieee
logp1	#include <math.h>	logp1.c	logp1.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_LOGP1 gl_CONDITIONAL([GL_COND_OBJ_LOGP1], [test $HAVE_LOGP1 = 0]) gl_MATH_MODULE_INDICATOR([logp1])	math-h log1p [test $HAVE_LOGP1 = 0]
logp1f	#include <math.h>	logp1f.c	logp1f.m4 logp1.m4 isnand.m4 log.m4 round.m4 floor.m4 ceil.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_LOGP1F gl_CONDITIONAL([GL_COND_OBJ_LOGP1F], [test $HAVE_LOGP1F = 0]) gl_MATH_MODULE_INDICATOR([logp1f])	math-h log1pf [test $HAVE_LOGP1F = 0]
logp1l	#include <math.h>	logp1l.c	logp1l.m4 logp1.m4 isnand.m4 log.m4 round.m4 floor.m4 ceil.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_LOGP1L gl_CONDITIONAL([GL_COND_OBJ_LOGP1L], [test $HAVE_LOGP1L = 0]) gl_MATH_MODULE_INDICATOR([logp1l])	math-h log1pl [test $HAVE_LOGP1L = 0]
map	#include "gl_map.h"	gl_map.c	00gnulib.m4 zzgnulib.m4	extern-inline bool
map-c++	#include "gl_map.hh"	---	00gnulib.m4 zzgnulib.m4	xmap
math-h	#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-h
mbiterf	#include "mbiterf.h"	mbiterf.c	mbiter.m4 mbrtowc.m4 00gnulib.m4 zzgnulib.m4 gl_MBITER	extern-inline mbchar mbrtoc32 mbsinit mbszero uchar-h bool
mbrtoc16	#include <uchar.h>	mbrtoc16.c	mbrtoc16.m4 locale-en.m4 locale-fr.m4 locale-zh.m4 codeset.m4 mbrtowc.m4 mbstate_t.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_MBRTOC16 gl_CONDITIONAL([GL_COND_OBJ_MBRTOC16], [test $HAVE_MBRTOC16 = 0 \|\| test $REPLACE_MBRTOC16 = 1]) AM_COND_IF([GL_COND_OBJ_MBRTOC16], [ gl_PREREQ_MBRTOC16 ]) gl_UCHAR_MODULE_INDICATOR([mbrtoc16])	uchar-h uchar-h-c23 [test $HAVE_MBRTOC16 = 0 \|\| test $REPLACE_MBRTOC16 = 1] mbrtoc32 [test $HAVE_MBRTOC16 = 0 \|\| test $REPLACE_MBRTOC16 = 1] mbsinit [test $HAVE_MBRTOC16 = 0 \|\| test $REPLACE_MBRTOC16 = 1] c99 [test $HAVE_MBRTOC16 = 0 \|\| test $REPLACE_MBRTOC16 = 1] assert-h [test $HAVE_MBRTOC16 = 0 \|\| test $REPLACE_MBRTOC16 = 1]
mbrtoc32	#include <uchar.h>	mbrtoc32.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	mbrtoc32.m4 c32rtomb.m4 locale-en.m4 locale-fr.m4 locale-zh.m4 codeset.m4 mbrtowc.m4 mbstate_t.m4 threadlib.m4 visibility.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_MBRTOC32 gl_CONDITIONAL([GL_COND_OBJ_MBRTOC32], [test $HAVE_MBRTOC32 = 0 \|\| test $REPLACE_MBRTOC32 = 1]) AM_COND_IF([GL_COND_OBJ_MBRTOC32], [ if test $REPLACE_MBSTATE_T = 1; then AC_LIBOBJ([lc-charset-dispatch]) AC_LIBOBJ([mbtowc-lock]) gl_PREREQ_MBTOWC_LOCK fi gl_PREREQ_MBRTOC32 ]) gl_UCHAR_MODULE_INDICATOR([mbrtoc32])	uchar-h attribute [test $HAVE_MBRTOC32 = 0 \|\| test $REPLACE_MBRTOC32 = 1] c99 [{ test $HAVE_MBRTOC32 = 0 \|\| test $REPLACE_MBRTOC32 = 1; } && test $REPLACE_MBSTATE_T = 0] hard-locale [{ test $HAVE_MBRTOC32 = 0 \|\| test $REPLACE_MBRTOC32 = 1; } && test $REPLACE_MBSTATE_T = 0] mbrtowc [{ test $HAVE_MBRTOC32 = 0 \|\| test $REPLACE_MBRTOC32 = 1; } && test $REPLACE_MBSTATE_T = 0] mbsinit [{ test $HAVE_MBRTOC32 = 0 \|\| test $REPLACE_MBRTOC32 = 1; } && test $REPLACE_MBSTATE_T = 0] mbszero [{ test $HAVE_MBRTOC32 = 0 \|\| test $REPLACE_MBRTOC32 = 1; } && test $REPLACE_MBSTATE_T = 0] assert-h [test $HAVE_MBRTOC32 = 0 \|\| test $REPLACE_MBRTOC32 = 1] localcharset [test $HAVE_MBRTOC32 = 0 \|\| test $REPLACE_MBRTOC32 = 1] streq [test $HAVE_MBRTOC32 = 0 \|\| test $REPLACE_MBRTOC32 = 1]
mbrtoc32-regular	#include <uchar.h>	---	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([mbrtoc32-regular])	mbrtoc32
mbs_endswith	#include <string.h>	mbs_endswith.c	00gnulib.m4 zzgnulib.m4 gl_STRING_MODULE_INDICATOR([mbs_endswith])	string-h bool str_endswith mbslen mbiter
mbs_startswith	#include <string.h>	---	00gnulib.m4 zzgnulib.m4 gl_STRING_MODULE_INDICATOR([mbs_startswith])	string-h bool str_startswith
mbsnrtoc32s	#include <uchar.h>	mbsnrtoc32s.c mbsnrtowcs-impl.h mbsrtoc32s-state.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_UCHAR_H]) AC_LIBOBJ([mbsrtoc32s-state]) gl_UCHAR_MODULE_INDICATOR([mbsnrtoc32s])	uchar-h wchar-h assert-h mbrtoc32 minmax strnlen1 mbsnrtowcs [test $SMALL_WCHAR_T = 0]
mbsrtoc32s	#include <uchar.h>	mbsrtoc32s.c mbsrtowcs-impl.h mbsrtoc32s-state.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_UCHAR_H]) AC_LIBOBJ([mbsrtoc32s-state]) gl_UCHAR_MODULE_INDICATOR([mbsrtoc32s])	uchar-h wchar-h assert-h mbrtoc32 strnlen1 mbsrtowcs [test $SMALL_WCHAR_T = 0]
mbstoc32s	#include <uchar.h>	mbstoc32s.c	00gnulib.m4 zzgnulib.m4 gl_UCHAR_MODULE_INDICATOR([mbstoc32s])	uchar-h wchar-h mbszero mbsrtoc32s
mbstowcs	#include <stdlib.h>	mbstowcs.c	mbstowcs.m4 mbrtowc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_MBSTOWCS gl_CONDITIONAL([GL_COND_OBJ_MBSTOWCS], [test $REPLACE_MBSTOWCS = 1]) AM_COND_IF([GL_COND_OBJ_MBSTOWCS], [ gl_PREREQ_MBSTOWCS ]) gl_STDLIB_MODULE_INDICATOR([mbstowcs])	stdlib-h mbszero [test $REPLACE_MBSTOWCS = 1] mbsrtowcs [test $REPLACE_MBSTOWCS = 1]
mbszero	#include <wchar.h>	mbszero.c	mbstate_t.m4 mbrtowc.m4 locale-ja.m4 locale-zh.m4 codeset.m4 musl.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_TYPE_MBSTATE_T]) gl_MBSTATE_T_BROKEN gl_MUSL_LIBC gl_WCHAR_MODULE_INDICATOR([mbszero])	wchar-h
mbtowc	#include <stdlib.h>	mbtowc.c mbtowc-impl.h	mbtowc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_MBTOWC gl_CONDITIONAL([GL_COND_OBJ_MBTOWC], [test $HAVE_MBTOWC = 0 \|\| test $REPLACE_MBTOWC = 1]) AM_COND_IF([GL_COND_OBJ_MBTOWC], [ gl_PREREQ_MBTOWC ]) gl_STDLIB_MODULE_INDICATOR([mbtowc])	stdlib-h wchar-h [test $HAVE_MBTOWC = 0 \|\| test $REPLACE_MBTOWC = 1] mbszero [test $HAVE_MBTOWC = 0 \|\| test $REPLACE_MBTOWC = 1] mbrtowc [test $HAVE_MBTOWC = 0 \|\| test $REPLACE_MBTOWC = 1]
mbuiterf	#include "mbuiterf.h"	mbuiterf.c	mbiter.m4 mbrtowc.m4 00gnulib.m4 zzgnulib.m4 gl_MBITER	extern-inline mbchar mbrtoc32 mbsinit mbszero uchar-h bool strnlen1
mcel	#include "mcel.h"	mcel.c	00gnulib.m4 zzgnulib.m4	assert-h builtin-expect extern-inline limits-h mbrtoc32 bool uchar-h verify
mcel-prefer	---	---	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([mcel-prefer])	mcel
mem-hash-map	#include "mem-hash-map.h"	mem-hash-map.c	00gnulib.m4 zzgnulib.m4	next-prime obstack xalloc
memccpy	#include <string.h>	---	00gnulib.m4 zzgnulib.m4	---
mixin/printf-gnu	---	---	00gnulib.m4 zzgnulib.m4 # Conditionally invoke gl_PREREQ_VASNPRINTF_WITH_GNU_EXTRAS.	mixin/printf-posix
mixin/printf-posix	---	---	00gnulib.m4 zzgnulib.m4 # Conditionally invoke gl_PREREQ_VASNPRINTF_WITH_POSIX_EXTRAS.	isnand-nolibm isnanl-nolibm frexp-nolibm frexpl-nolibm printf-frexp printf-frexpl signbit fpucw
mkdirat	#include <sys/stat.h>	mkdirat.c at-func.c	mkdirat.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_MKDIRAT gl_CONDITIONAL([GL_COND_OBJ_MKDIRAT], [test $HAVE_MKDIRAT = 0]) AM_COND_IF([GL_COND_OBJ_MKDIRAT], [ gl_PREREQ_MKDIRAT ]) gl_SYS_STAT_MODULE_INDICATOR([mkdirat])	sys_stat-h extensions at-internal [test $HAVE_MKDIRAT = 0] errno-h [test $HAVE_MKDIRAT = 0] fchdir [test $HAVE_MKDIRAT = 0] fcntl-h [test $HAVE_MKDIRAT = 0] filename [test $HAVE_MKDIRAT = 0] mkdir [test $HAVE_MKDIRAT = 0] openat-die [test $HAVE_MKDIRAT = 0] openat-h [test $HAVE_MKDIRAT = 0] save-cwd [test $HAVE_MKDIRAT = 0] unistd-h [test $HAVE_MKDIRAT = 0]
mntent	#if HAVE_MNTENT_H #include <mntent.h> #endif	---	00gnulib.m4 zzgnulib.m4	mntent-h
mntent-h	#if HAVE_MNTENT_H #include <mntent.h> #endif	mntent.in.h	mntent_h.m4 00gnulib.m4 zzgnulib.m4 gl_MNTENT_H gl_MNTENT_H_REQUIRE_DEFAULTS gl_CONDITIONAL_HEADER([mntent.h]) AC_PROG_MKDIR_P	gen-header include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use
modf-ieee	#include <math.h>	---	modf-ieee.m4 minus-zero.m4 signbit.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_MODF_IEEE	modf fpieee
modff	#include <math.h>	modff.c	modff.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_MODFF gl_CONDITIONAL([GL_COND_OBJ_MODFF], [test $HAVE_MODFF = 0 \|\| test $REPLACE_MODFF = 1]) gl_MATH_MODULE_INDICATOR([modff])	math-h extensions modf [test $HAVE_MODFF = 0 \|\| test $REPLACE_MODFF = 1]
modff-ieee	#include <math.h>	---	modff-ieee.m4 minus-zero.m4 signbit.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_MODFF_IEEE	modff fpieee modf-ieee [test $HAVE_MODFF = 0]
modfl	#include <math.h>	modfl.c	modfl.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_MODFL gl_CONDITIONAL([GL_COND_OBJ_MODFL], [test $HAVE_MODFL = 0 \|\| test $REPLACE_MODFL = 1]) gl_MATH_MODULE_INDICATOR([modfl])	math-h extensions modf [{ test $HAVE_MODFL = 0 \|\| test $REPLACE_MODFL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] isfinite [{ test $HAVE_MODFL = 0 \|\| test $REPLACE_MODFL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] truncl [{ test $HAVE_MODFL = 0 \|\| test $REPLACE_MODFL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] isinf [{ test $HAVE_MODFL = 0 \|\| test $REPLACE_MODFL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
modfl-ieee	#include <math.h>	---	modfl-ieee.m4 minus-zero.m4 signbit.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_MODFL_IEEE	modfl fpieee modf-ieee [test $HAVE_MODFL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1]
modula2comp-script	---	---	modula2comp.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gt_MODULA2COMP])	---
monetary	#if HAVE_MONETARY_H #include <monetary.h> #endif	---	00gnulib.m4 zzgnulib.m4	monetary-h
monetary-h	#if HAVE_MONETARY_H #include <monetary.h> #endif	monetary.in.h	monetary_h.m4 00gnulib.m4 zzgnulib.m4 gl_MONETARY_H gl_MONETARY_H_REQUIRE_DEFAULTS gl_CONDITIONAL_HEADER([monetary.h]) AC_PROG_MKDIR_P	gen-header include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use
msvc-inval	#if HAVE_MSVC_INVALID_PARAMETER_HANDLER # include "msvc-inval.h" #endif	msvc-inval.h msvc-inval.c	msvc-inval.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_MSVC_INVAL]) gl_CONDITIONAL([GL_COND_OBJ_MSVC_INVAL], [test $HAVE_MSVC_INVALID_PARAMETER_HANDLER = 1])	---
msvc-nothrow	#if GNULIB_MSVC_NOTHROW # include "msvc-nothrow.h" #else # include <io.h> #endif	msvc-nothrow.h msvc-nothrow.c	msvc-nothrow.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_MSVC_NOTHROW]) gl_CONDITIONAL([GL_COND_OBJ_MSVC_NOTHROW], [test $HAVE_MSVC_INVALID_PARAMETER_HANDLER = 1]) gl_MODULE_INDICATOR([msvc-nothrow])	msvc-inval
mtx	#include <threads.h>	mtx.c	mtx.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_THREADS_H]) gl_FUNC_MTX_INIT gl_CONDITIONAL([GL_COND_OBJ_MTX], [test $HAVE_THREADS_H = 0 \|\| test $REPLACE_MTX_INIT = 1]) gl_THREADS_MODULE_INDICATOR([mtx])	threads-h pthread_mutex_timedlock windows-mutex windows-recmutex windows-timedmutex windows-timedrecmutex
multiarch	---	---	multiarch.m4 00gnulib.m4 zzgnulib.m4 gl_MULTIARCH	---
nan	#include "nan.h"	---	00gnulib.m4 zzgnulib.m4	---
net_if-h	#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-h
netdb-h	#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-h
netinet_in-h	#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-h
newlocale	#include <locale.h>	newlocale.c	newlocale.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_NEWLOCALE gl_CONDITIONAL([GL_COND_OBJ_NEWLOCALE], [test $HAVE_LOCALE_T = 0 \|\| { test $REPLACE_NEWLOCALE = 1 && test "$gt_localename_enhances_locale_funcs" != yes; }]) AM_COND_IF([GL_COND_OBJ_NEWLOCALE], [ gl_PREREQ_NEWLOCALE ]) gl_LOCALE_MODULE_INDICATOR([newlocale])	locale-h localename-environ
next-prime	#include "next-prime.h"	next-prime.c	00gnulib.m4 zzgnulib.m4	bool stdint-h
nonblocking	#include "nonblocking.h"	nonblocking.c stdio-read.c stdio-write.c	nonblocking.m4 asm-underscore.m4 00gnulib.m4 zzgnulib.m4 gl_NONBLOCKING_IO gl_FCNTL_MODULE_INDICATOR([nonblocking]) dnl Define the C macro GNULIB_NONBLOCKING to 1. gl_MODULE_INDICATOR([nonblocking]) dnl Define the substituted variable GNULIB_STDIO_H_NONBLOCKING to 1. gl_STDIO_H_REQUIRE_DEFAULTS AC_REQUIRE([gl_ASM_SYMBOL_PREFIX]) gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STDIO_H_NONBLOCKING], [1]) dnl Define the substituted variable GNULIB_UNISTD_H_NONBLOCKING to 1. gl_UNISTD_H_REQUIRE_DEFAULTS gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNISTD_H_NONBLOCKING], [1])	fcntl-h ioctl msvc-nothrow bool stdio-h sys_socket-h unistd-h
obstack-printf-gnu	#include <stdio.h>	obstack_printf.c	obstack-printf-gnu.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_OBSTACK_PRINTF_GNU if test $ac_cv_func_obstack_printf = no \|\| test $REPLACE_OBSTACK_PRINTF = 1; then AC_LIBOBJ([obstack_printf]) fi	obstack-printf-posix mixin/printf-gnu
obstack-zprintf	#include <stdio.h>	obstack_zprintf.c obstack_printf.c	00gnulib.m4 zzgnulib.m4 gl_STDIO_MODULE_INDICATOR([obstack-zprintf])	obstack stdio-h vasnprintf
obstack-zprintf-gnu	#include <stdio.h>	---	00gnulib.m4 zzgnulib.m4 gl_PREREQ_VASNPRINTF_WITH_GNU_EXTRAS	obstack-zprintf-posix mixin/printf-gnu
obstack-zprintf-posix	#include <stdio.h>	---	00gnulib.m4 zzgnulib.m4 gl_PREREQ_VASNPRINTF_WITH_POSIX_EXTRAS	obstack-zprintf mixin/printf-posix
omap	#include "gl_omap.h"	gl_omap.c	00gnulib.m4 zzgnulib.m4	extern-inline bool
omap-c++	#include "gl_omap.hh"	---	00gnulib.m4 zzgnulib.m4	xomap
once	#include "glthread/once.h"	glthread/once.c	once.m4 00gnulib.m4 zzgnulib.m4 gl_ONCE	extensions threadlib pthread-once [test $gl_threads_api = posix] windows-once [test $gl_threads_api = windows]
openat-h	#include "openat.h"	---	00gnulib.m4 zzgnulib.m4	extern-inline fcntl-h bool sys_stat-h unistd-h
opendir	#include <dirent.h>	opendir.c dirent-private.h	opendir.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_OPENDIR gl_CONDITIONAL([GL_COND_OBJ_OPENDIR], [test $HAVE_OPENDIR = 0 \|\| test $REPLACE_OPENDIR = 1]) gl_DIRENT_MODULE_INDICATOR([opendir])	dirent-h largefile filename [test $HAVE_OPENDIR = 0 \|\| test $REPLACE_OPENDIR = 1] unistd-h [test $HAVE_OPENDIR = 0 \|\| test $REPLACE_OPENDIR = 1] closedir [test $HAVE_OPENDIR = 0 \|\| test $REPLACE_OPENDIR = 1] dirfd [test $HAVE_OPENDIR = 0 \|\| test $REPLACE_OPENDIR = 1]
opendirat	#include "opendirat.h"	opendirat.c	00gnulib.m4 zzgnulib.m4	c99 dirent-h fcntl-h fdopendir openat
openmp-init	#include <omp.h>	omp.in.h omp-init.c	omp_h.m4 00gnulib.m4 zzgnulib.m4 gl_OMP_H AC_PROG_MKDIR_P	gen-header include_next c-ctype setenv
options	#include "options.h"	options.c	00gnulib.m4 zzgnulib.m4	getopt-gnu stdcountof-h
oset-c++	#include "gl_oset.hh"	---	00gnulib.m4 zzgnulib.m4	xoset
package-version	---	---	init-package-version.m4 00gnulib.m4 zzgnulib.m4	---
passfd	#include "passfd.h"	passfd.c	passfd.m4 00gnulib.m4 zzgnulib.m4 gl_PASSFD	cloexec sys_socket-h socketlib
pclose	#include <stdio.h>	pclose.c	pclose.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_PCLOSE gl_CONDITIONAL([GL_COND_OBJ_PCLOSE], [test $HAVE_PCLOSE = 0]) AM_COND_IF([GL_COND_OBJ_PCLOSE], [ gl_PREREQ_PCLOSE ]) gl_STDIO_MODULE_INDICATOR([pclose])	stdio-h
poll-h	#include <poll.h>	poll.in.h	poll_h.m4 sys_socket_h.m4 00gnulib.m4 zzgnulib.m4 gl_POLL_H gl_POLL_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	extensions gen-header include_next snippet/c++defs snippet/warn-on-use
posix_spawn_file_actions_addchdir	#include <spawn.h>	spawn_faction_addchdir.c spawn_int.h	posix_spawn_faction_addchdir.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_POSIX_SPAWN_FILE_ACTIONS_ADDCHDIR gl_CONDITIONAL([GL_COND_OBJ_SPAWN_FACTION_ADDCHDIR], [test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1 \|\| test $HAVE_POSIX_SPAWN_FILE_ACTIONS_ADDCHDIR = 0 \|\| test $REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDCHDIR = 1]) gl_SPAWN_MODULE_INDICATOR([posix_spawn_file_actions_addchdir])	spawn-h posix_spawn_file_actions_init [test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1 \|\| test $HAVE_POSIX_SPAWN_FILE_ACTIONS_ADDCHDIR = 0 \|\| test $REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDCHDIR = 1]
posix_spawn_file_actions_addfchdir	#include <spawn.h>	spawn_faction_addfchdir.c spawn_int.h	posix_spawn_faction_addfchdir.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_POSIX_SPAWN_FILE_ACTIONS_ADDFCHDIR gl_CONDITIONAL([GL_COND_OBJ_SPAWN_FACTION_ADDFCHDIR], [test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1 \|\| test $HAVE_POSIX_SPAWN_FILE_ACTIONS_ADDFCHDIR = 0 \|\| test $REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDFCHDIR = 1]) gl_SPAWN_MODULE_INDICATOR([posix_spawn_file_actions_addfchdir])	spawn-h posix_spawn_file_actions_init [test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1 \|\| test $HAVE_POSIX_SPAWN_FILE_ACTIONS_ADDFCHDIR = 0 \|\| test $REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDFCHDIR = 1]
posixcheck	---	---	posixcheck.m4 00gnulib.m4 zzgnulib.m4 gl_POSIXCHECK	arpa_inet-h ctype-h dirent-h fcntl-h fnmatch-h glob-h iconv-h inttypes-h-incomplete langinfo-h locale-h malloc-h math-h monetary-h netdb-h poll-h pthread-h pty-h sched-h search-h signal-h spawn-h stdio-h stdlib-h string-h strings-h sys_file-h sys_ioctl-h sys_random-h sys_resource-h sys_select-h sys_socket-h sys_stat-h sys_time-h sys_times-h sys_utsname-h sys_wait-h termios-h threads-h time-h uchar-h unistd-h utime-h utmp-h wchar-h wctype-h
powf	#include <math.h>	powf.c	powf.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_POWF gl_CONDITIONAL([GL_COND_OBJ_POWF], [test $HAVE_POWF = 0]) gl_MATH_MODULE_INDICATOR([powf])	math-h extensions pow [test $HAVE_POWF = 0]
printf-gnu	#include <stdio.h>	---	printf-gnu.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_PRINTF_GNU	printf-posix mixin/printf-gnu
printf-with-n-directive	---	---	printf-with-n-directive.m4 00gnulib.m4 zzgnulib.m4 gl_PRINTF_SUPPORT_N_DIRECTIVE	---
pt_chown	---	pt_chown.c pty-private.h	00gnulib.m4 zzgnulib.m4	ptsname root-uid stdlib-h configmake stat
pthread-cond	#include <pthread.h>	pthread-cond.c	pthread-cond.m4 00gnulib.m4 zzgnulib.m4 gl_PTHREAD_COND gl_CONDITIONAL([GL_COND_OBJ_PTHREAD_COND], [test $HAVE_PTHREAD_COND_INIT = 0 \|\| test $REPLACE_PTHREAD_COND_INIT = 1]) gl_PTHREAD_MODULE_INDICATOR([pthread-cond])	pthread-h windows-cond [test $gl_threads_api = windows] pthread-mutex [test $gl_threads_api = windows]
pthread-h	#include <pthread.h>	pthread.in.h	pthread_h.m4 threadlib.m4 pthread-spin.m4 00gnulib.m4 zzgnulib.m4 gl_PTHREAD_H gl_PTHREAD_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	extensions extern-inline gen-header sched-h time-h snippet/c++defs snippet/_Noreturn snippet/arg-nonnull snippet/warn-on-use
pthread-mutex	#include <pthread.h>	pthread-mutex.c	pthread-mutex.m4 00gnulib.m4 zzgnulib.m4 gl_PTHREAD_MUTEX gl_CONDITIONAL([GL_COND_OBJ_PTHREAD_MUTEX], [test $HAVE_PTHREAD_MUTEX_INIT = 0 \|\| test $REPLACE_PTHREAD_MUTEX_INIT = 1 \|\| test $HAVE_PTHREAD_MUTEXATTR_GETROBUST = 0 \|\| test $REPLACE_PTHREAD_MUTEXATTR_GETROBUST = 1]) gl_PTHREAD_MODULE_INDICATOR([pthread-mutex])	pthread-h pthread_mutex_timedlock [test $gl_threads_api != windows] windows-timedmutex [test $gl_threads_api = windows] windows-timedrecmutex [test $gl_threads_api = windows]
pthread-once	#include <pthread.h>	pthread-once.c	pthread-once.m4 00gnulib.m4 zzgnulib.m4 gl_PTHREAD_ONCE gl_CONDITIONAL([GL_COND_OBJ_PTHREAD_ONCE], [test $HAVE_PTHREAD_ONCE = 0 \|\| test $REPLACE_PTHREAD_ONCE = 1]) gl_PTHREAD_MODULE_INDICATOR([pthread-once])	pthread-h windows-once [test $gl_threads_api = windows]
pthread-rwlock	#include <pthread.h>	pthread-rwlock.c	pthread-rwlock.m4 00gnulib.m4 zzgnulib.m4 gl_PTHREAD_RWLOCK gl_CONDITIONAL([GL_COND_OBJ_PTHREAD_RWLOCK], [test $REPLACE_PTHREAD_RWLOCK_INIT = 1 \|\| test $HAVE_PTHREAD_RWLOCK_TIMEDRDLOCK = 0 \|\| test $REPLACE_PTHREAD_RWLOCK_TIMEDRDLOCK = 1]) gl_PTHREAD_MODULE_INDICATOR([pthread-rwlock])	pthread-h pthread-cond [test $gl_threads_api != windows && test $REPLACE_PTHREAD_RWLOCK_INIT = 1] nanosleep [test $gl_threads_api != windows && test $HAVE_PTHREAD_RWLOCK_INIT = 1 && test $HAVE_PTHREAD_RWLOCK_TIMEDRDLOCK = 0] windows-timedrwlock [test $gl_threads_api = windows]
pthread-spin	#include <pthread.h>	pthread-spin.c	pthread-spin.m4 atomic-cas.m4 00gnulib.m4 zzgnulib.m4 gl_PTHREAD_SPIN gl_CONDITIONAL([GL_COND_OBJ_PTHREAD_SPIN], [test $HAVE_PTHREAD_SPIN_INIT = 0 \|\| test $REPLACE_PTHREAD_SPIN_INIT = 1]) gl_PTHREAD_MODULE_INDICATOR([pthread-spin]) AC_REQUIRE([gl_ATOMIC_COMPARE_AND_SWAP])	pthread-h bool [test $HAVE_PTHREAD_SPIN_INIT = 0 \|\| test $REPLACE_PTHREAD_SPIN_INIT = 1] windows-spin [test $gl_threads_api = windows]
pthread-thread	#include <pthread.h>	pthread-thread.c	pthread-thread.m4 00gnulib.m4 zzgnulib.m4 gl_PTHREAD_THREAD gl_CONDITIONAL([GL_COND_OBJ_PTHREAD_THREAD], [test $HAVE_PTHREAD_CREATE = 0 \|\| test $REPLACE_PTHREAD_CREATE = 1]) gl_PTHREAD_MODULE_INDICATOR([pthread-thread])	pthread-h windows-thread [test $gl_threads_api = windows]
pthread-tss	#include <pthread.h>	pthread-tss.c	pthread-tss.m4 00gnulib.m4 zzgnulib.m4 gl_PTHREAD_TSS gl_CONDITIONAL([GL_COND_OBJ_PTHREAD_TSS], [test $HAVE_PTHREAD_KEY_CREATE = 0 \|\| test $REPLACE_PTHREAD_KEY_CREATE = 1]) gl_PTHREAD_MODULE_INDICATOR([pthread-tss])	pthread-h windows-tls [test $gl_threads_api = windows]
pthread_mutex_timedlock	#include <pthread.h>	pthread_mutex_timedlock.c	pthread_mutex_timedlock.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_PTHREAD_MUTEX_TIMEDLOCK gl_CONDITIONAL([GL_COND_OBJ_PTHREAD_MUTEX_TIMEDLOCK], [test $HAVE_PTHREAD_T = 1 && test $HAVE_PTHREAD_MUTEX_TIMEDLOCK = 0]) gl_PTHREAD_MODULE_INDICATOR([pthread_mutex_timedlock])	pthread-h nanosleep [test $HAVE_PTHREAD_T = 1 && test $HAVE_PTHREAD_MUTEX_TIMEDLOCK = 0]
pty-h	#include <pty.h>	pty.in.h	pty_h.m4 00gnulib.m4 zzgnulib.m4 gl_PTY_H gl_PTY_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	gen-header include_next snippet/c++defs snippet/warn-on-use termios-h
putenv-gnu	#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-h environ [test $REPLACE_PUTENV = 1] free-posix [test $REPLACE_PUTENV = 1] malloc-posix [test $REPLACE_PUTENV = 1] unsetenv [test $REPLACE_PUTENV = 1]
qsort	#include <stdlib.h>	---	00gnulib.m4 zzgnulib.m4	---
quotearg-simple	---	---	00gnulib.m4 zzgnulib.m4	quotearg
rand	#include <stdlib.h>	rand.c	rand.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_RAND gl_CONDITIONAL([GL_COND_OBJ_RAND], [test $REPLACE_RAND = 1]) gl_STDLIB_MODULE_INDICATOR([rand])	stdlib-h random [test $REPLACE_RAND = 1]
random	#include <stdlib.h>	random.c	random.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_RANDOM gl_CONDITIONAL([GL_COND_OBJ_RANDOM], [test $HAVE_RANDOM = 0 \|\| test $REPLACE_RANDOM = 1 \|\| test $REPLACE_INITSTATE = 1 \|\| test $REPLACE_SETSTATE = 1]) AM_COND_IF([GL_COND_OBJ_RANDOM], [ gl_PREREQ_RANDOM ]) gl_STDLIB_MODULE_INDICATOR([random])	stdlib-h libc-config [test $HAVE_RANDOM = 0 \|\| test $REPLACE_RANDOM = 1 \|\| test $REPLACE_INITSTATE = 1 \|\| test $REPLACE_SETSTATE = 1] lock [test $HAVE_RANDOM = 0 \|\| test $REPLACE_RANDOM = 1 \|\| test $REPLACE_INITSTATE = 1 \|\| test $REPLACE_SETSTATE = 1] stdint-h [test $HAVE_RANDOM = 0 \|\| test $REPLACE_RANDOM = 1 \|\| test $REPLACE_INITSTATE = 1 \|\| test $REPLACE_SETSTATE = 1] random_r [test $HAVE_RANDOM = 0 \|\| test $REPLACE_RANDOM = 1 \|\| test $REPLACE_INITSTATE = 1 \|\| test $REPLACE_SETSTATE = 1]
rbtree-omap	#include "gl_rbtree_omap.h"	gl_rbtree_omap.c gl_rbtree_ordered.h gl_anytree_omap.h	00gnulib.m4 zzgnulib.m4	omap
read	#include <unistd.h>	read.c	read.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_READ gl_CONDITIONAL([GL_COND_OBJ_READ], [test $REPLACE_READ = 1]) AM_COND_IF([GL_COND_OBJ_READ], [ gl_PREREQ_READ ]) gl_UNISTD_MODULE_INDICATOR([read])	unistd-h msvc-inval [test $REPLACE_READ = 1] msvc-nothrow [test $REPLACE_READ = 1]
readdir	#include <dirent.h>	readdir.c dirent-private.h	readdir.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_READDIR gl_CONDITIONAL([GL_COND_OBJ_READDIR], [test $HAVE_READDIR = 0 \|\| test $REPLACE_READDIR = 1]) gl_DIRENT_MODULE_INDICATOR([readdir])	dirent-h largefile
realloc-gnu	#include <stdlib.h>	---	00gnulib.m4 zzgnulib.m4	realloc-posix
regex-quote	#include "regex-quote.h"	regex-quote.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_RESTRICT])	bool xalloc mbuiter mempcpy
relocatable-perl	---	---	relocatable-lib.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_RELOCATABLE_NOP]) relocatable_pl=$ac_aux_dir/relocatable.pl.in AC_SUBST_FILE([relocatable_pl])	---
remainder-ieee	#include <math.h>	---	remainder-ieee.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_REMAINDER_IEEE	remainder fpieee
remainderf	#include <math.h>	remainderf.c remainder.c	remainderf.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_REMAINDERF gl_CONDITIONAL([GL_COND_OBJ_REMAINDERF], [test $HAVE_REMAINDERF = 0 \|\| test $REPLACE_REMAINDERF = 1]) gl_MATH_MODULE_INDICATOR([remainderf])	math-h extensions remainder [test $HAVE_REMAINDERF = 0 \|\| test $REPLACE_REMAINDERF = 1] isfinite [test $HAVE_REMAINDERF = 0 \|\| test $REPLACE_REMAINDERF = 1] signbit [test $HAVE_REMAINDERF = 0 \|\| test $REPLACE_REMAINDERF = 1] fabsf [test $HAVE_REMAINDERF = 0 \|\| test $REPLACE_REMAINDERF = 1] fmodf [test $HAVE_REMAINDERF = 0 \|\| test $REPLACE_REMAINDERF = 1] isnanf [test $HAVE_REMAINDERF = 0 \|\| test $REPLACE_REMAINDERF = 1] isinf [test $HAVE_REMAINDERF = 0 \|\| test $REPLACE_REMAINDERF = 1]
remainderf-ieee	#include <math.h>	---	remainderf-ieee.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_REMAINDERF_IEEE	remainderf fpieee remainder-ieee [test $HAVE_REMAINDERF = 0 \|\| test $REPLACE_REMAINDERF = 1]
remainderl	#include <math.h>	remainderl.c remainder.c	remainderl.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_REMAINDERL gl_CONDITIONAL([GL_COND_OBJ_REMAINDERL], [test $HAVE_REMAINDERL = 0 \|\| test $REPLACE_REMAINDERL = 1]) gl_MATH_MODULE_INDICATOR([remainderl])	math-h extensions remainder [{ test $HAVE_REMAINDERL = 0 \|\| test $REPLACE_REMAINDERL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] float-h [{ test $HAVE_REMAINDERL = 0 \|\| test $REPLACE_REMAINDERL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] isfinite [{ test $HAVE_REMAINDERL = 0 \|\| test $REPLACE_REMAINDERL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] signbit [{ test $HAVE_REMAINDERL = 0 \|\| test $REPLACE_REMAINDERL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] fabsl [{ test $HAVE_REMAINDERL = 0 \|\| test $REPLACE_REMAINDERL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] fmodl [{ test $HAVE_REMAINDERL = 0 \|\| test $REPLACE_REMAINDERL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] isnanl [{ test $HAVE_REMAINDERL = 0 \|\| test $REPLACE_REMAINDERL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] isinf [{ test $HAVE_REMAINDERL = 0 \|\| test $REPLACE_REMAINDERL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
remainderl-ieee	#include <math.h>	---	remainderl-ieee.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_REMAINDERL_IEEE	remainderl fpieee remainder-ieee [{ test $HAVE_REMAINDERL = 0 \|\| test $REPLACE_REMAINDERL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1]
rewinddir	#include <dirent.h>	rewinddir.c dirent-private.h	rewinddir.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_REWINDDIR gl_CONDITIONAL([GL_COND_OBJ_REWINDDIR], [test $HAVE_REWINDDIR = 0 \|\| test $REPLACE_REWINDDIR = 1]) gl_DIRENT_MODULE_INDICATOR([rewinddir])	dirent-h largefile
rint-ieee	#include <math.h>	---	00gnulib.m4 zzgnulib.m4	rint fpieee
rintf	#include <math.h>	rintf.c rint.c	rintf.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_RINTF gl_CONDITIONAL([GL_COND_OBJ_RINTF], [test $HAVE_RINTF = 0]) gl_MATH_MODULE_INDICATOR([rintf])	math-h extensions
rintf-ieee	#include <math.h>	---	00gnulib.m4 zzgnulib.m4	rintf fpieee
rintl	#include <math.h>	rintl.c rint.c	rintl.m4 mathfunc.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_RINTL gl_CONDITIONAL([GL_COND_OBJ_RINTL], [test $HAVE_RINTL = 0 \|\| test $REPLACE_RINTL = 1]) gl_MATH_MODULE_INDICATOR([rintl])	math-h extensions rint [{ test $HAVE_RINTL = 0 \|\| test $REPLACE_RINTL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1]
rintl-ieee	#include <math.h>	---	00gnulib.m4 zzgnulib.m4	rintl fpieee
root-uid	#include "root-uid.h"	---	00gnulib.m4 zzgnulib.m4	---
round-ieee	#include <math.h>	---	round-ieee.m4 minus-zero.m4 signbit.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ROUND_IEEE	round floor-ieee [test $HAVE_ROUND = 0 \|\| test $REPLACE_ROUND = 1] ceil-ieee [test $HAVE_ROUND = 0 \|\| test $REPLACE_ROUND = 1]
roundf-ieee	#include <math.h>	---	roundf-ieee.m4 minus-zero.m4 signbit.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ROUNDF_IEEE	roundf floorf-ieee [test $HAVE_ROUNDF = 0 \|\| test $REPLACE_ROUNDF = 1] ceilf-ieee [test $HAVE_ROUNDF = 0 \|\| test $REPLACE_ROUNDF = 1]
roundl-ieee	#include <math.h>	---	roundl-ieee.m4 minus-zero.m4 signbit.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ROUNDL_IEEE	roundl floorl-ieee ceill-ieee
sched-h	#include <sched.h>	sched.in.h	sched_h.m4 pid_t.m4 sys_cdefs_h.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
sched_yield	#include <sched.h>	sched_yield.c	sched_yield.m4 threadlib.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_SCHED_YIELD gl_CONDITIONAL([GL_COND_OBJ_SCHED_YIELD], [test $HAVE_SCHED_YIELD = 0 \|\| test $REPLACE_SCHED_YIELD = 1]) gl_SCHED_MODULE_INDICATOR([sched_yield])	sched-h
search-h	#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
set	#include "gl_set.h"	gl_set.c	00gnulib.m4 zzgnulib.m4	extern-inline bool
set-c++	#include "gl_set.hh"	---	00gnulib.m4 zzgnulib.m4	xset
sethostname	#include <unistd.h>	sethostname.c	sethostname.m4 gethostname.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_SETHOSTNAME gl_CONDITIONAL([GL_COND_OBJ_SETHOSTNAME], [test $HAVE_SETHOSTNAME = 0 \|\| test $REPLACE_SETHOSTNAME = 1]) gl_UNISTD_MODULE_INDICATOR([sethostname])	unistd-h errno-h [test $HAVE_SETHOSTNAME = 0 \|\| test $REPLACE_SETHOSTNAME = 1] fopen-gnu [test $HAVE_SETHOSTNAME = 0 \|\| test $REPLACE_SETHOSTNAME = 1]
setlocale	#include <locale.h>	setlocale.c	setlocale.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_SETLOCALE gl_CONDITIONAL([GL_COND_OBJ_SETLOCALE], [test $REPLACE_SETLOCALE = 1]) AM_COND_IF([GL_COND_OBJ_SETLOCALE], [ gl_PREREQ_SETLOCALE ]) gl_LOCALE_MODULE_INDICATOR([setlocale])	locale-h setlocale-fixes [test $NEED_SETLOCALE_IMPROVED = 1] localename [test $NEED_SETLOCALE_IMPROVED = 1] localename-environ [test $NEED_SETLOCALE_IMPROVED = 1] setlocale-null [test $NEED_SETLOCALE_MTSAFE = 1]
setlocale-fixes	#include "setlocale-fixes.h"	setlocale-fixes.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_CANONICAL_HOST]) gl_CONDITIONAL([GL_COND_OBJ_SETLOCALE_FIXES], [case "$host_os" in mingw* \| windows* \| -android) true;; *) false;; esac])	---
setlocale-null	#include "setlocale_null.h" or #include <locale.h>	setlocale_null.h setlocale_null.c setlocale-lock.c windows-initguard.h	setlocale_null.m4 threadlib.m4 visibility.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_SETLOCALE_NULL gl_CONDITIONAL([GL_COND_OBJ_SETLOCALE_LOCK], [test $SETLOCALE_NULL_ALL_MTSAFE = 0 \|\| test $SETLOCALE_NULL_ONE_MTSAFE = 0]) AM_COND_IF([GL_COND_OBJ_SETLOCALE_LOCK], [ gl_PREREQ_SETLOCALE_LOCK ]) gl_LOCALE_MODULE_INDICATOR([setlocale_null])	locale-h snippet/arg-nonnull setlocale-null-unlocked
setlocale-null-unlocked	#include "setlocale_null.h"	setlocale_null-unlocked.c	00gnulib.m4 zzgnulib.m4	locale-h snippet/arg-nonnull
setpayload	#include <math.h>	setpayload.c	mathfunc.m4 setpayload.m4 nan-mips.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_SETPAYLOAD gl_CONDITIONAL([GL_COND_OBJ_SETPAYLOAD], [test $HAVE_SETPAYLOAD = 0]) gl_MATH_MODULE_INDICATOR([setpayload])	math-h extensions float-h [test $HAVE_SETPAYLOAD = 0] stdint-h [test $HAVE_SETPAYLOAD = 0] signed-nan [test $HAVE_SETPAYLOAD = 0]
setpayloadf	#include <math.h>	setpayloadf.c	mathfunc.m4 setpayload.m4 nan-mips.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_SETPAYLOADF gl_CONDITIONAL([GL_COND_OBJ_SETPAYLOADF], [test $HAVE_SETPAYLOADF = 0]) gl_MATH_MODULE_INDICATOR([setpayloadf])	math-h extensions float-h [test $HAVE_SETPAYLOADF = 0] stdint-h [test $HAVE_SETPAYLOADF = 0] signed-nan [test $HAVE_SETPAYLOADF = 0]
setpayloadl	#include <math.h>	setpayloadl.c	mathfunc.m4 setpayload.m4 exponentl.m4 exponentd.m4 math_h.m4 nan-mips.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_SETPAYLOADL gl_CONDITIONAL([GL_COND_OBJ_SETPAYLOADL], [test $HAVE_SETPAYLOADL = 0]) gl_MATH_MODULE_INDICATOR([setpayloadl])	math-h extensions setpayload [test $HAVE_SETPAYLOADL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] float-h [test $HAVE_SETPAYLOADL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] stdint-h [test $HAVE_SETPAYLOADL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] signed-nan [test $HAVE_SETPAYLOADL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] snan [test $HAVE_SETPAYLOADL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
setpayloadsig	#include <math.h>	setpayloadsig.c	mathfunc.m4 setpayloadsig.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_SETPAYLOADSIG gl_CONDITIONAL([GL_COND_OBJ_SETPAYLOADSIG], [test $HAVE_SETPAYLOADSIG = 0]) gl_MATH_MODULE_INDICATOR([setpayloadsig])	math-h extensions float-h [test $HAVE_SETPAYLOADSIG = 0] stdint-h [test $HAVE_SETPAYLOADSIG = 0] signed-snan [test $HAVE_SETPAYLOADSIG = 0]
setpayloadsigf	#include <math.h>	setpayloadsigf.c	mathfunc.m4 setpayloadsig.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_SETPAYLOADSIGF gl_CONDITIONAL([GL_COND_OBJ_SETPAYLOADSIGF], [test $HAVE_SETPAYLOADSIGF = 0]) gl_MATH_MODULE_INDICATOR([setpayloadsigf])	math-h extensions float-h [test $HAVE_SETPAYLOADSIGF = 0] stdint-h [test $HAVE_SETPAYLOADSIGF = 0] signed-snan [test $HAVE_SETPAYLOADSIGF = 0]
setpayloadsigl	#include <math.h>	setpayloadsigl.c	mathfunc.m4 setpayloadsig.m4 exponentl.m4 exponentd.m4 math_h.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_SETPAYLOADSIGL gl_CONDITIONAL([GL_COND_OBJ_SETPAYLOADSIGL], [test $HAVE_SETPAYLOADSIGL = 0]) gl_MATH_MODULE_INDICATOR([setpayloadsigl])	math-h extensions setpayloadsig [test $HAVE_SETPAYLOADSIGL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] float-h [test $HAVE_SETPAYLOADSIGL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] stdint-h [test $HAVE_SETPAYLOADSIGL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] signed-snan [test $HAVE_SETPAYLOADSIGL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
sf-istream	#include "sf-istream.h"	sf-istream.c	00gnulib.m4 zzgnulib.m4	string-desc
sfl-istream	#include "sfl-istream.h"	sfl-istream.c	00gnulib.m4 zzgnulib.m4	sf-istream
sh-filename	---	---	sh-filename.m4 00gnulib.m4 zzgnulib.m4 gl_SH_FILENAME	---
signal	#include <signal.h>	---	00gnulib.m4 zzgnulib.m4	signal-h
signed-nan	#include "signed-nan.h"	---	00gnulib.m4 zzgnulib.m4	nan signbit
signed-snan	#include "signed-snan.h"	---	00gnulib.m4 zzgnulib.m4	signed-nan snan
sinf	#include <math.h>	sinf.c	sinf.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_SINF gl_CONDITIONAL([GL_COND_OBJ_SINF], [test $HAVE_SINF = 0]) gl_MATH_MODULE_INDICATOR([sinf])	math-h extensions sin [test $HAVE_SINF = 0]
sinhf	#include <math.h>	sinhf.c	sinhf.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_SINHF gl_CONDITIONAL([GL_COND_OBJ_SINHF], [test $HAVE_SINHF = 0]) gl_MATH_MODULE_INDICATOR([sinhf])	math-h extensions sinh [test $HAVE_SINHF = 0]
snan	#include "snan.h"	---	snan.m4 exponentf.m4 exponentd.m4 exponentl.m4 math_h.m4 nan-mips.m4 00gnulib.m4 zzgnulib.m4 gl_SNAN gl_NAN_MIPS	nan
snippet/_Noreturn	---	_Noreturn.h	00gnulib.m4 zzgnulib.m4	---
snippet/c++defs	---	c++defs.h	00gnulib.m4 zzgnulib.m4	---
snprintf-gnu	#include <stdio.h>	---	snprintf-gnu.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_SNPRINTF_GNU	snprintf-posix mixin/printf-gnu
snzprintf	#include <stdio.h>	snzprintf.c	00gnulib.m4 zzgnulib.m4 gl_STDIO_MODULE_INDICATOR([snzprintf])	stdio-h vasnprintf errno-h stdint-h
snzprintf-gnu	#include <stdio.h>	---	00gnulib.m4 zzgnulib.m4 gl_PREREQ_VASNPRINTF_WITH_GNU_EXTRAS	snzprintf-posix mixin/printf-gnu
snzprintf-posix	#include <stdio.h>	---	00gnulib.m4 zzgnulib.m4 gl_PREREQ_VASNPRINTF_WITH_POSIX_EXTRAS	snzprintf mixin/printf-posix
socketlib	---	---	socketlib.m4 sys_socket_h.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_SOCKETLIB])	---
sparcv8+	---	---	sparcv8+.m4 00gnulib.m4 zzgnulib.m4	---
spawn-h	#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-h signal-h snippet/arg-nonnull snippet/c++defs snippet/warn-on-use
spin	#include "glthread/spin.h"	glthread/spin.c	atomic-cas.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_ATOMIC_COMPARE_AND_SWAP]) gl_CONDITIONAL([GL_COND_OBJ_SPIN], [case "$host_os" in mingw* \| windows) false;; ) true;; esac])	windows-spin sparcv8+
sprintf-gnu	#include <stdio.h>	---	sprintf-gnu.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_SPRINTF_GNU	sprintf-posix mixin/printf-gnu
sqrt-ieee	#include <math.h>	---	00gnulib.m4 zzgnulib.m4	sqrt fpieee
sqrtf	#include <math.h>	sqrtf.c	sqrtf.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_SQRTF gl_CONDITIONAL([GL_COND_OBJ_SQRTF], [test $HAVE_SQRTF = 0]) gl_MATH_MODULE_INDICATOR([sqrtf])	math-h extensions sqrt [test $HAVE_SQRTF = 0]
sqrtf-ieee	#include <math.h>	---	00gnulib.m4 zzgnulib.m4	sqrtf fpieee
sqrtl-ieee	#include <math.h>	---	00gnulib.m4 zzgnulib.m4	sqrtl fpieee
stack-trace	#include <stdlib.h>	stack-trace-impl.h stack-trace.c	stack-trace.m4 00gnulib.m4 zzgnulib.m4 gl_STACK_TRACE gl_CONDITIONAL([GL_COND_OBJ_STACK_TRACE], [test $CAN_PRINT_STACK_TRACE = 1]) gl_STDLIB_MODULE_INDICATOR([stack-trace]) gl_MODULE_INDICATOR([stack-trace])	stdlib-h execinfo
stat-size	#include "stat-size.h"	---	stat-size.m4 00gnulib.m4 zzgnulib.m4 gl_STAT_SIZE	fileblocks sys_stat-h
statat	#include "openat.h"	statat.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([statat]) dnl for lib/openat.h	fstatat
stdalign-h	---	stdalign.in.h	stdalign.m4 00gnulib.m4 zzgnulib.m4 gl_STDALIGN_H gl_CONDITIONAL_HEADER([stdalign.h]) AC_PROG_MKDIR_P	alignasof gen-header
stdarg-h	#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
stdbit	#include <stdbit.h>	---	00gnulib.m4 zzgnulib.m4	stdbit-h stdc_leading_zeros stdc_leading_ones stdc_trailing_zeros stdc_trailing_ones stdc_first_leading_zero stdc_first_leading_one stdc_first_trailing_zero stdc_first_trailing_one stdc_count_zeros stdc_count_ones stdc_has_single_bit stdc_bit_width stdc_bit_floor stdc_bit_ceil
stdbit-h	#include <stdbit.h>	stdbit.in.h stdbit.c	stdbit_h.m4 00gnulib.m4 zzgnulib.m4 gl_STDBIT_H gl_CONDITIONAL_HEADER([stdbit.h]) AC_PROG_MKDIR_P	gen-header extern-inline [$GL_GENERATE_STDBIT_H] bool [$GL_GENERATE_STDBIT_H]
stdbool-c99	#include <stdbool.h>	---	00gnulib.m4 zzgnulib.m4	stdbool-h-c99
stdbool-h-c99	#include <stdbool.h>	stdbool.in.h	stdbool.m4 00gnulib.m4 zzgnulib.m4 gl_STDBOOL_H gl_CONDITIONAL_HEADER([stdbool.h]) AC_PROG_MKDIR_P	gen-header
stdc_bit_ceil	#include <stdbit.h>	stdc_bit_ceil.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_STDBIT_H]) GL_STDC_BIT_CEIL=1	stdbit-h stdc_bit_width
stdc_bit_floor	#include <stdbit.h>	stdc_bit_floor.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_STDBIT_H]) GL_STDC_BIT_FLOOR=1	stdbit-h stdc_bit_width
stdc_bit_width	#include <stdbit.h>	stdc_bit_width.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_STDBIT_H]) GL_STDC_BIT_WIDTH=1	stdbit-h stdc_leading_zeros
stdc_count_ones	#include <stdbit.h>	stdc_count_ones.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_STDBIT_H]) GL_STDC_COUNT_ONES=1	stdbit-h
stdc_count_zeros	#include <stdbit.h>	stdc_count_zeros.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_STDBIT_H]) GL_STDC_COUNT_ZEROS=1	stdbit-h stdc_count_ones
stdc_first_leading_one	#include <stdbit.h>	stdc_first_leading_one.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_STDBIT_H]) GL_STDC_FIRST_LEADING_ONE=1	stdbit-h stdc_leading_zeros
stdc_first_leading_zero	#include <stdbit.h>	stdc_first_leading_zero.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_STDBIT_H]) GL_STDC_FIRST_LEADING_ZERO=1	stdbit-h stdc_leading_ones
stdc_first_trailing_one	#include <stdbit.h>	stdc_first_trailing_one.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_STDBIT_H]) GL_STDC_FIRST_TRAILING_ONE=1	stdbit-h stdc_trailing_zeros
stdc_first_trailing_zero	#include <stdbit.h>	stdc_first_trailing_zero.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_STDBIT_H]) GL_STDC_FIRST_TRAILING_ZERO=1	stdbit-h stdc_trailing_ones
stdc_has_single_bit	#include <stdbit.h>	stdc_has_single_bit.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_STDBIT_H]) GL_STDC_HAS_SINGLE_BIT=1	stdbit-h
stdc_leading_ones	#include <stdbit.h>	stdc_leading_ones.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_STDBIT_H]) GL_STDC_LEADING_ONES=1	stdbit-h stdc_leading_zeros
stdc_leading_zeros	#include <stdbit.h>	stdc_leading_zeros.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_STDBIT_H]) GL_STDC_LEADING_ZEROS=1	stdbit-h
stdc_trailing_ones	#include <stdbit.h>	stdc_trailing_ones.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_STDBIT_H]) GL_STDC_TRAILING_ONES=1	stdbit-h stdc_trailing_zeros
stdc_trailing_zeros	#include <stdbit.h>	stdc_trailing_zeros.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_STDBIT_H]) GL_STDC_TRAILING_ZEROS=1	stdbit-h
stdckdint-h	#include <stdckdint.h>	stdckdint.in.h intprops-internal.h	stdckdint_h.m4 00gnulib.m4 zzgnulib.m4 gl_STDCKDINT_H gl_CONDITIONAL_HEADER([stdckdint.h]) AC_PROG_MKDIR_P	gen-header bool
stdcountof-h	#include <stdcountof.h>	stdcountof.in.h	stdcountof_h.m4 00gnulib.m4 zzgnulib.m4 gl_STDCOUNTOF_H gl_CONDITIONAL_HEADER([stdcountof.h]) AC_PROG_MKDIR_P	gen-header
stddef-h	#include <stddef.h>	stddef.in.h	stddef_h.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
stdint-h	#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-h
stdio-h	#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-h sys_types-h
stdlib-h	#include <stdlib.h>	stdlib.c stdlib.in.h	stdlib_h.m4 locale-en.m4 codeset.m4 00gnulib.m4 zzgnulib.m4 gl_STDLIB_H gl_STDLIB_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	gen-header extern-inline include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use snippet/_Noreturn stddef-h unistd-h
stdnoreturn	#include <stdnoreturn.h>	---	00gnulib.m4 zzgnulib.m4	stdnoreturn-h
stdnoreturn-h	#include <stdnoreturn.h>	stdnoreturn.in.h	stdnoreturn.m4 00gnulib.m4 zzgnulib.m4 gl_STDNORETURN_H gl_CONDITIONAL_HEADER([stdnoreturn.h]) AC_PROG_MKDIR_P	gen-header snippet/_Noreturn
stdopen	#include "stdopen.h"	stdopen.c	00gnulib.m4 zzgnulib.m4	fcntl unistd-h
str_endswith	#include <string.h>	str_endswith.c	00gnulib.m4 zzgnulib.m4 gl_STRING_MODULE_INDICATOR([str_endswith])	string-h bool
str_startswith	#include <string.h>	str_startswith.c	00gnulib.m4 zzgnulib.m4 gl_STRING_MODULE_INDICATOR([str_startswith])	string-h bool
strcasecmp	#include <strings.h>	strcasecmp.c	strcasecmp.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_STRCASECMP gl_CONDITIONAL([GL_COND_OBJ_STRCASECMP], [test $HAVE_STRCASECMP = 0 \|\| test $REPLACE_STRCASECMP = 1]) AM_COND_IF([GL_COND_OBJ_STRCASECMP], [ gl_PREREQ_STRCASECMP ]) gl_STRINGS_MODULE_INDICATOR([strcasecmp])	strings-h
strcasecmp_l	#include <strings.h>	strcasecmp_l.c	strcasecmp_l.m4 strcasecmp.m4 intl-thread-locale.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_STRCASECMP_L gl_CONDITIONAL([GL_COND_OBJ_STRCASECMP_L], [test $HAVE_STRCASECMP_L = 0 \|\| test $REPLACE_STRCASECMP_L = 1]) AM_COND_IF([GL_COND_OBJ_STRCASECMP_L], [ gl_PREREQ_STRCASECMP_L ]) gl_MODULE_INDICATOR([strcasecmp_l]) gl_STRINGS_MODULE_INDICATOR([strcasecmp_l])	strings-h locale-h extensions c-strcasecmp [test $HAVE_STRCASECMP_L = 0 \|\| test $REPLACE_STRCASECMP_L = 1] tolower_l [test $HAVE_STRCASECMP_L = 0 \|\| test $REPLACE_STRCASECMP_L = 1]
strerror_l	#include <string.h>	strerror_l.c	strerror_l.m4 intl-thread-locale.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_STRERROR_L gl_CONDITIONAL([GL_COND_OBJ_STRERROR_L], [test $HAVE_STRERROR_L = 0 \|\| test $REPLACE_STRERROR_L = 1]) AM_COND_IF([GL_COND_OBJ_STRERROR_L], [ gl_PREREQ_STRERROR_L ]) gl_MODULE_INDICATOR([strerror_l]) gl_STRING_MODULE_INDICATOR([strerror_l])	string-h locale-h extensions errno-h [test $HAVE_STRERROR_L = 0 \|\| test $REPLACE_STRERROR_L = 1] at-init [test $HAVE_STRERROR_L = 0 \|\| test $REPLACE_STRERROR_L = 1] errno-iter [test $HAVE_STRERROR_L = 0 \|\| test $REPLACE_STRERROR_L = 1] write [test $HAVE_STRERROR_L = 0 \|\| test $REPLACE_STRERROR_L = 1] tls [test $HAVE_STRERROR_L = 0 \|\| test $REPLACE_STRERROR_L = 1] once [test $HAVE_STRERROR_L = 0 \|\| test $REPLACE_STRERROR_L = 1] strerror [test $HAVE_STRERROR_L = 0 \|\| test $REPLACE_STRERROR_L = 1] strdup [test $HAVE_STRERROR_L = 0 \|\| test $REPLACE_STRERROR_L = 1] calloc-posix [test $HAVE_STRERROR_L = 0 \|\| test $REPLACE_STRERROR_L = 1] strerror_r-posix [test $HAVE_STRERROR_L = 0 \|\| test $REPLACE_STRERROR_L = 1]
strfmon_l	#if HAVE_MONETARY_H #include <monetary.h> #endif	strfmon_l.c	strfmon_l.m4 locale-fr.m4 codeset.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_STRFMON_L gl_CONDITIONAL([GL_COND_OBJ_STRFMON_L], [test $REPLACE_STRFMON_L = 1]) AM_COND_IF([GL_COND_OBJ_STRFMON_L], [ gl_PREREQ_STRFMON_L ]) gl_MONETARY_MODULE_INDICATOR([strfmon_l])	monetary-h extensions bool [test $REPLACE_STRFMON_L = 1]
string-buffer-reversed	#include "string-buffer-reversed.h"	string-buffer-reversed.c string-buffer-reversed-printf.c	00gnulib.m4 zzgnulib.m4	bool attribute string-desc stdarg-h vsnzprintf-posix
string-desc	#include "string-desc.h"	string-desc.c string-desc-contains.c	00gnulib.m4 zzgnulib.m4	bool idx c-ctype ialloc extern-inline memchr memrchr memmem full-write
string-desc-quotearg	#include "string-desc-quotearg.h"	string-desc-quotearg.c	00gnulib.m4 zzgnulib.m4	string-desc quotearg extern-inline
string-h	#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-h stdlib-h
strings-h	#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-h
strncasecmp	#include <strings.h>	strncasecmp.c	strncasecmp.m4 strcasecmp.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_STRNCASECMP gl_CONDITIONAL([GL_COND_OBJ_STRNCASECMP], [test $HAVE_STRNCASECMP = 0 \|\| test $REPLACE_STRNCASECMP = 1]) AM_COND_IF([GL_COND_OBJ_STRNCASECMP], [ gl_PREREQ_STRNCASECMP ]) gl_STRINGS_MODULE_INDICATOR([strncasecmp])	strings-h
strncasecmp_l	#include <strings.h>	strncasecmp_l.c	strncasecmp_l.m4 strcasecmp.m4 intl-thread-locale.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_STRNCASECMP_L gl_CONDITIONAL([GL_COND_OBJ_STRNCASECMP_L], [test $HAVE_STRNCASECMP_L = 0 \|\| test $REPLACE_STRNCASECMP_L = 1]) AM_COND_IF([GL_COND_OBJ_STRNCASECMP_L], [ gl_PREREQ_STRNCASECMP_L ]) gl_MODULE_INDICATOR([strncasecmp_l]) gl_STRINGS_MODULE_INDICATOR([strncasecmp_l])	strings-h locale-h extensions c-strncasecmp [test $HAVE_STRNCASECMP_L = 0 \|\| test $REPLACE_STRNCASECMP_L = 1] tolower_l [test $HAVE_STRNCASECMP_L = 0 \|\| test $REPLACE_STRNCASECMP_L = 1]
strncmp	#include <string.h>	---	00gnulib.m4 zzgnulib.m4	---
strncpy	#include <string.h>	---	00gnulib.m4 zzgnulib.m4	string-h
strtod-obsolete	#include <string.h>	---	strtod-obsolete.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_STRTOD_OBSOLETE	strtod
strtof	#include <stdlib.h>	strtof.c strtod.c	strtof.m4 ldexpf.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_STRTOF gl_CONDITIONAL([GL_COND_OBJ_STRTOF], [test $HAVE_STRTOF = 0 \|\| test $REPLACE_STRTOF = 1]) AM_COND_IF([GL_COND_OBJ_STRTOF], [ gl_PREREQ_STRTOF ]) gl_STDLIB_MODULE_INDICATOR([strtof])	stdlib-h c-ctype [test $HAVE_STRTOF = 0 \|\| test $REPLACE_STRTOF = 1] math-h [test $HAVE_STRTOF = 0 \|\| test $REPLACE_STRTOF = 1] bool [test $HAVE_STRTOF = 0 \|\| test $REPLACE_STRTOF = 1]
strtold	#include <stdlib.h>	strtold.c strtod.c	strtold.m4 math_h.m4 ldexpl.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_STRTOLD gl_CONDITIONAL([GL_COND_OBJ_STRTOLD], [test $HAVE_STRTOLD = 0 \|\| test $REPLACE_STRTOLD = 1]) AM_COND_IF([GL_COND_OBJ_STRTOLD], [ gl_PREREQ_STRTOLD ]) gl_STDLIB_MODULE_INDICATOR([strtold])	stdlib-h c-ctype [test $HAVE_STRTOLD = 0 \|\| test $REPLACE_STRTOLD = 1] math-h [test $HAVE_STRTOLD = 0 \|\| test $REPLACE_STRTOLD = 1] bool [test $HAVE_STRTOLD = 0 \|\| test $REPLACE_STRTOLD = 1] strtod [{ test $HAVE_STRTOLD = 0 \|\| test $REPLACE_STRTOLD = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1]
sys_file-h	#include <sys/file.h>	sys_file.in.h	sys_file_h.m4 00gnulib.m4 zzgnulib.m4 gl_SYS_FILE_H gl_SYS_FILE_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	gen-header include_next snippet/warn-on-use
sys_ioctl-h	#include <sys/ioctl.h>	sys_ioctl.in.h	sys_ioctl_h.m4 00gnulib.m4 zzgnulib.m4 gl_SYS_IOCTL_H gl_SYS_IOCTL_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	gen-header include_next snippet/c++defs snippet/warn-on-use unistd-h
sys_msg	#if HAVE_SYS_MSG_H #include <sys/msg.h> #endif	---	00gnulib.m4 zzgnulib.m4	sys_msg-h
sys_msg-h	#if HAVE_SYS_MSG_H #include <sys/msg.h> #endif	sys_msg.in.h	sys_msg_h.m4 00gnulib.m4 zzgnulib.m4 gl_SYS_MSG_H gl_CONDITIONAL_HEADER([sys/msg.h]) AC_PROG_MKDIR_P	gen-header include_next
sys_random-h	#include <sys/random.h>	sys_random.in.h	sys_random_h.m4 00gnulib.m4 zzgnulib.m4 gl_SYS_RANDOM_H gl_SYS_RANDOM_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	gen-header include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use
sys_resource	#include <sys/resource.h>	---	00gnulib.m4 zzgnulib.m4	sys_resource-h
sys_resource-h	#include <sys/resource.h>	sys_resource.in.h	sys_resource_h.m4 00gnulib.m4 zzgnulib.m4 gl_SYS_RESOURCE_H gl_SYS_RESOURCE_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	gen-header include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use sys_time-h
sys_select-h	#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-h
sys_sem	#if HAVE_SYS_SEM_H #include <sys/sem.h> #endif	---	00gnulib.m4 zzgnulib.m4	sys_sem-h
sys_sem-h	#if HAVE_SYS_SEM_H #include <sys/sem.h> #endif	sys_sem.in.h	sys_sem_h.m4 00gnulib.m4 zzgnulib.m4 gl_SYS_SEM_H gl_CONDITIONAL_HEADER([sys/sem.h]) AC_PROG_MKDIR_P	gen-header include_next
sys_shm	#if HAVE_SYS_SHM_H #include <sys/shm.h> #endif	---	00gnulib.m4 zzgnulib.m4	sys_shm-h
sys_shm-h	#if HAVE_SYS_SHM_H #include <sys/shm.h> #endif	sys_shm.in.h	sys_shm_h.m4 00gnulib.m4 zzgnulib.m4 gl_SYS_SHM_H gl_CONDITIONAL_HEADER([sys/shm.h]) AC_PROG_MKDIR_P	gen-header include_next
sys_socket-h	#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-h extern-inline gen-header include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use socklen ssize_t sys_uio-h
sys_stat-h	#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-h time-h
sys_time-h	#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-h	#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_types	#include <sys/types.h>	---	00gnulib.m4 zzgnulib.m4	sys_types-h
sys_types-h	#include <sys/types.h>	sys_types.in.h	sys_types_h.m4 off_t.m4 off64_t.m4 pid_t.m4 00gnulib.m4 zzgnulib.m4 gl_SYS_TYPES_H gl_SYS_TYPES_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	gen-header include_next ssize_t
sys_uio-h	#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-h
sys_un	#include <sys/un.h>	---	00gnulib.m4 zzgnulib.m4	sys_un-h
sys_un-h	#include <sys/un.h>	sys_un.in.h	sys_un_h.m4 00gnulib.m4 zzgnulib.m4 gl_SYS_UN_H gl_CONDITIONAL_HEADER([sys/un.h]) AC_PROG_MKDIR_P	gen-header include_next sys_socket-h
sys_utsname-h	#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-h	#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
sysexits-h	#include <sysexits.h>	sysexits.in.h	sysexits.m4 00gnulib.m4 zzgnulib.m4 gl_SYSEXITS gl_CONDITIONAL_HEADER([sysexits.h]) AC_PROG_MKDIR_P	gen-header include_next stdlib-h
system-posix	#include <stdlib.h>	---	00gnulib.m4 zzgnulib.m4 gl_STDLIB_MODULE_INDICATOR([system-posix])	stdlib-h sys_wait-h
system-quote	#include "system-quote.h"	system-quote.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_RESTRICT])	sh-quote bool xalloc
szprintf	#include <stdio.h>	szprintf.c	00gnulib.m4 zzgnulib.m4 gl_STDIO_MODULE_INDICATOR([szprintf])	stdio-h vasnprintf errno-h stdint-h
szprintf-gnu	#include <stdio.h>	---	00gnulib.m4 zzgnulib.m4 gl_PREREQ_VASNPRINTF_WITH_GNU_EXTRAS	szprintf-posix mixin/printf-gnu
szprintf-posix	#include <stdio.h>	---	00gnulib.m4 zzgnulib.m4 gl_PREREQ_VASNPRINTF_WITH_POSIX_EXTRAS	szprintf mixin/printf-posix
tanf	#include <math.h>	tanf.c	tanf.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_TANF gl_CONDITIONAL([GL_COND_OBJ_TANF], [test $HAVE_TANF = 0]) gl_MATH_MODULE_INDICATOR([tanf])	math-h extensions tan [test $HAVE_TANF = 0]
tanhf	#include <math.h>	tanhf.c	tanhf.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_TANHF gl_CONDITIONAL([GL_COND_OBJ_TANHF], [test $HAVE_TANHF = 0]) gl_MATH_MODULE_INDICATOR([tanhf])	math-h extensions tanh [test $HAVE_TANHF = 0]
tcgetsid	#include <termios.h>	tcgetsid.c	tcgetsid.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_TCGETSID gl_CONDITIONAL([GL_COND_OBJ_TCGETSID], [test $HAVE_TCGETSID = 0]) AM_COND_IF([GL_COND_OBJ_TCGETSID], [ gl_PREREQ_TCGETSID ]) gl_TERMIOS_MODULE_INDICATOR([tcgetsid])	termios-h extensions sys_ioctl-h [test $HAVE_TCGETSID = 0]
term-style-control	#include "term-style-control.h"	term-style-control.c	tcgetattr.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_HAVE_TCGETATTR	bool fatal-signal sigaction sigprocmask full-write fstat same-inode xalloc-die
termios	#include <termios.h>	---	00gnulib.m4 zzgnulib.m4	termios-h
termios-h	#include <termios.h>	termios.in.h	termios_h.m4 pid_t.m4 00gnulib.m4 zzgnulib.m4 gl_TERMIOS_H gl_TERMIOS_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	gen-header include_next snippet/c++defs snippet/warn-on-use
test-xfail	---	---	musl.m4 00gnulib.m4 zzgnulib.m4 gl_MUSL_LIBC gl_CONDITIONAL([LIBC_IS_GNU], [case "$host_os" in -gnu \| gnu) true ;; ) false ;; esac]) gl_CONDITIONAL([LIBC_IS_MUSL], [case "$host_os" in -musl \| midipix) true ;; ) false ;; esac]) gl_CONDITIONAL([OS_IS_MACOS], [case "$host_os" in darwin) true ;; ) false ;; esac]) gl_CONDITIONAL([OS_IS_MACOS11], [case "$host_os" in darwin20.) true ;; ) false ;; esac]) gl_CONDITIONAL([OS_IS_MACOS12], [case "$host_os" in darwin21.) true ;; ) false ;; esac]) gl_CONDITIONAL([OS_IS_MACOS13], [case "$host_os" in darwin22.) true ;; ) false ;; esac]) gl_CONDITIONAL([OS_IS_MACOS14], [case "$host_os" in darwin23.) true ;; ) false ;; esac]) gl_CONDITIONAL([OS_IS_FREEBSD], [case "$host_os" in freebsd* \| dragonfly) true ;; ) false ;; esac]) gl_CONDITIONAL([OS_IS_NETBSD], [case "$host_os" in netbsd) true ;; ) false ;; esac]) gl_CONDITIONAL([OS_IS_OPENBSD], [case "$host_os" in openbsd) true ;; ) false ;; esac]) gl_CONDITIONAL([OS_IS_AIX], [case "$host_os" in aix) true ;; ) false ;; esac]) gl_CONDITIONAL([OS_IS_SOLARIS11], [case "$host_os" in solaris2.11) true ;; ) false ;; esac]) gl_CONDITIONAL([OS_IS_CYGWIN], [case "$host_os" in cygwin) true ;; ) false ;; esac]) gl_CONDITIONAL([OS_IS_NATIVE_WINDOWS], [case "$host_os" in mingw* \| windows) true ;; ) false ;; esac]) is_mingw=false; is_msvc=false case "$host_os" in windows-msvc) is_msvc=true ;; mingw* \| windows) AC_EGREP_CPP([Special], [ #ifdef _MSC_VER Special #endif ], [is_msvc=true], [is_mingw=true]) ;; esac gl_CONDITIONAL([PLATFORM_IS_MINGW], [$is_mingw]) gl_CONDITIONAL([PLATFORM_IS_MSVC], [$is_msvc]) gl_CONDITIONAL([OS_IS_HAIKU], [case "$host_os" in haiku) true ;; ) false ;; esac]) gl_CONDITIONAL([OS_IS_ANDROID], [case "$host_os" in linux-androideabi) true ;; *) false ;; esac])	---
thrd	#include <threads.h>	thrd.c	thrd.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_THREADS_H]) gl_FUNC_THRD_CREATE gl_FUNC_THRD_JOIN gl_CONDITIONAL([GL_COND_OBJ_THRD], [test $HAVE_THREADS_H = 0 \|\| test $REPLACE_THRD_CREATE = 1 \|\| test $REPLACE_THRD_JOIN = 1]) gl_THREADS_MODULE_INDICATOR([thrd])	threads-h windows-thread nanosleep
thread-optim	#include "thread-optim.h"	---	00gnulib.m4 zzgnulib.m4 AC_CHECK_HEADERS([sys/single_threaded.h])	---
threads	#include <threads.h>	---	00gnulib.m4 zzgnulib.m4	threads-h thrd call_once mtx cnd tss
threads-h	#include <threads.h>	threads.in.h windows-thread.h windows-mutex.h windows-recmutex.h windows-timedmutex.h windows-timedrecmutex.h windows-once.h windows-cond.h windows-tls.h windows-initguard.h	threads_h.m4 threadlib.m4 00gnulib.m4 zzgnulib.m4 gl_THREADS_H gl_THREADS_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	gen-header include_next snippet/c++defs snippet/_Noreturn snippet/arg-nonnull snippet/warn-on-use time-h havelib
timespec-add	#include "timespec.h"	timespec-add.c	00gnulib.m4 zzgnulib.m4	c99 intprops bool stdckdint-h timespec
timespec-sub	#include "timespec.h"	timespec-sub.c	00gnulib.m4 zzgnulib.m4	c99 intprops bool stdckdint-h timespec
timevar	#include "timevar.h"	timevar.c	00gnulib.m4 zzgnulib.m4	c99 gethrxtime getrusage gettext-h gnulib-i18n stdlib-h sys_time-h sys_times-h xalloc
tolower_l	#include <ctype.h>	tolower_l.c to_l-impl.h	tolower_l.m4 intl-thread-locale.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_TOLOWER_L gl_CONDITIONAL([GL_COND_OBJ_TOLOWER_L], [test $HAVE_TOLOWER_L = 0]) gl_MODULE_INDICATOR([tolower_l]) gl_CTYPE_MODULE_INDICATOR([tolower_l])	ctype-h locale-h extensions
totalorder	#include <math.h>	totalorder.c	mathfunc.m4 totalorder.m4 nan-mips.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_TOTALORDER gl_CONDITIONAL([GL_COND_OBJ_TOTALORDER], [test $HAVE_TOTALORDER = 0 \|\| test $REPLACE_TOTALORDER = 1]) gl_MATH_MODULE_INDICATOR([totalorder])	math-h extensions isnand [test $HAVE_TOTALORDER = 0 \|\| test $REPLACE_TOTALORDER = 1] signbit [test $HAVE_TOTALORDER = 0 \|\| test $REPLACE_TOTALORDER = 1]
totalorderf	#include <math.h>	totalorderf.c	mathfunc.m4 totalorder.m4 nan-mips.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_TOTALORDERF gl_CONDITIONAL([GL_COND_OBJ_TOTALORDERF], [test $HAVE_TOTALORDERF = 0 \|\| test $REPLACE_TOTALORDERF = 1]) gl_MATH_MODULE_INDICATOR([totalorderf])	math-h extensions isnanf [test $HAVE_TOTALORDERF = 0 \|\| test $REPLACE_TOTALORDERF = 1] signbit [test $HAVE_TOTALORDERF = 0 \|\| test $REPLACE_TOTALORDERF = 1]
totalorderl	#include <math.h>	totalorderl.c	mathfunc.m4 totalorder.m4 nan-mips.m4 signbit.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_TOTALORDERL gl_CONDITIONAL([GL_COND_OBJ_TOTALORDERL], [test $HAVE_TOTALORDERL = 0 \|\| test $REPLACE_TOTALORDERL = 1]) gl_MATH_MODULE_INDICATOR([totalorderl])	math-h extensions totalorder [{ test $HAVE_TOTALORDERL = 0 \|\| test $REPLACE_TOTALORDERL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] float-h [{ test $HAVE_TOTALORDERL = 0 \|\| test $REPLACE_TOTALORDERL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] bool [{ test $HAVE_TOTALORDERL = 0 \|\| test $REPLACE_TOTALORDERL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] isnanl [{ test $HAVE_TOTALORDERL = 0 \|\| test $REPLACE_TOTALORDERL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] signbit [{ test $HAVE_TOTALORDERL = 0 \|\| test $REPLACE_TOTALORDERL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
totalordermag	#include <math.h>	totalordermag.c	mathfunc.m4 totalordermag.m4 nan-mips.m4 signbit.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_TOTALORDERMAG gl_CONDITIONAL([GL_COND_OBJ_TOTALORDERMAG], [test $HAVE_TOTALORDERMAG = 0 \|\| test $REPLACE_TOTALORDERMAG = 1]) gl_MATH_MODULE_INDICATOR([totalordermag])	math-h extensions verify [test $HAVE_TOTALORDERMAG = 0 \|\| test $REPLACE_TOTALORDERMAG = 1] isnand [test $HAVE_TOTALORDERMAG = 0 \|\| test $REPLACE_TOTALORDERMAG = 1] signbit [test $HAVE_TOTALORDERMAG = 0 \|\| test $REPLACE_TOTALORDERMAG = 1]
totalordermagf	#include <math.h>	totalordermagf.c	mathfunc.m4 totalordermag.m4 nan-mips.m4 signbit.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_TOTALORDERMAGF gl_CONDITIONAL([GL_COND_OBJ_TOTALORDERMAGF], [test $HAVE_TOTALORDERMAGF = 0 \|\| test $REPLACE_TOTALORDERMAGF = 1]) gl_MATH_MODULE_INDICATOR([totalordermagf])	math-h extensions verify [test $HAVE_TOTALORDERMAGF = 0 \|\| test $REPLACE_TOTALORDERMAGF = 1] isnanf [test $HAVE_TOTALORDERMAGF = 0 \|\| test $REPLACE_TOTALORDERMAGF = 1] signbit [test $HAVE_TOTALORDERMAGF = 0 \|\| test $REPLACE_TOTALORDERMAGF = 1]
totalordermagl	#include <math.h>	totalordermagl.c	mathfunc.m4 totalordermag.m4 nan-mips.m4 signbit.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_TOTALORDERMAGL gl_CONDITIONAL([GL_COND_OBJ_TOTALORDERMAGL], [test $HAVE_TOTALORDERMAGL = 0 \|\| test $REPLACE_TOTALORDERMAGL = 1]) gl_MATH_MODULE_INDICATOR([totalordermagl])	math-h extensions totalordermag [{ test $HAVE_TOTALORDERMAGL = 0 \|\| test $REPLACE_TOTALORDERMAGL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] float-h [{ test $HAVE_TOTALORDERMAGL = 0 \|\| test $REPLACE_TOTALORDERMAGL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] bool [{ test $HAVE_TOTALORDERMAGL = 0 \|\| test $REPLACE_TOTALORDERMAGL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] stdint-h [{ test $HAVE_TOTALORDERMAGL = 0 \|\| test $REPLACE_TOTALORDERMAGL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] verify [{ test $HAVE_TOTALORDERMAGL = 0 \|\| test $REPLACE_TOTALORDERMAGL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] isnanl [{ test $HAVE_TOTALORDERMAGL = 0 \|\| test $REPLACE_TOTALORDERMAGL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] signbit [{ test $HAVE_TOTALORDERMAGL = 0 \|\| test $REPLACE_TOTALORDERMAGL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
toupper_l	#include <ctype.h>	toupper_l.c to_l-impl.h	toupper_l.m4 intl-thread-locale.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_TOUPPER_L gl_CONDITIONAL([GL_COND_OBJ_TOUPPER_L], [test $HAVE_TOUPPER_L = 0]) gl_MODULE_INDICATOR([toupper_l]) gl_CTYPE_MODULE_INDICATOR([toupper_l])	ctype-h locale-h extensions
towctrans	#include <wctype.h>	towctrans.c towctrans-impl.h	towctrans.m4 wctrans.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_TOWCTRANS gl_CONDITIONAL([GL_COND_OBJ_TOWCTRANS], [test $HAVE_TOWCTRANS = 0 \|\| test $REPLACE_WCTRANS = 1]) gl_WCTYPE_MODULE_INDICATOR([towctrans])	wctype-h
trunc-ieee	#include <math.h>	---	trunc-ieee.m4 minus-zero.m4 signbit.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_TRUNC_IEEE	trunc
truncf-ieee	#include <math.h>	---	truncf-ieee.m4 minus-zero.m4 signbit.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_TRUNCF_IEEE	truncf
truncl-ieee	#include <math.h>	---	truncl-ieee.m4 minus-zero.m4 signbit.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_TRUNCL_IEEE	truncl
tss	#include <threads.h>	tss.c	tss.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_THREADS_H]) gl_FUNC_TSS_CREATE gl_CONDITIONAL([GL_COND_OBJ_TSS], [test $HAVE_THREADS_H = 0 \|\| test $REPLACE_TSS_CREATE = 1]) gl_THREADS_MODULE_INDICATOR([tss])	threads-h windows-tls
tzname	#include <time.h>	---	tzname.m4 00gnulib.m4 zzgnulib.m4 gl_TZNAME gl_TIME_MODULE_INDICATOR([tzname])	time-h
uchar	#include <uchar.h>	---	00gnulib.m4 zzgnulib.m4	uchar-h
uchar-c23	#include <uchar.h>	---	00gnulib.m4 zzgnulib.m4	uchar-h-c23
uchar-h	#include <uchar.h>	uchar.in.h	uchar_h.m4 stdint.m4 00gnulib.m4 zzgnulib.m4 gl_UCHAR_H gl_UCHAR_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	gen-header include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use extern-inline assert-h stdint-h wchar-h wctype-h
uchar-h-c23	#include <uchar.h>	lc-charset-unicode.h lc-charset-unicode.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_CANONICAL_HOST]) AC_REQUIRE([AM_ICONV]) AC_DEFINE([GL_CHAR32_T_IS_UNICODE], [1], [Define if gnulib's char32_t values are always Unicode code points.]) dnl On macOS, FreeBSD, NetBSD, Solaris, the functions mbrtoc32 and c32rtomb dnl need to convert between the wchar_t encoding and Unicode. case "$host_os" in darwin* \| freebsd* \| dragonfly* \| netbsd* \| solaris) AC_DEFINE([GL_CHAR32_T_VS_WCHAR_T_NEEDS_CONVERSION], [1], [Define if gnulib needs to convert between the wchar_t encoding and Unicode.]) LIBC32CONV="$LIBICONV" LTLIBC32CONV="$LTLIBICONV" ;; ) LIBC32CONV= LTLIBC32CONV= ;; esac AC_SUBST([LIBC32CONV]) AC_SUBST([LTLIBC32CONV])	uchar-h wchar-h iconv localcharset streq once tls mbszero wcrtomb unistr/u8-mbtouc unistr/u8-uctomb mbrtowc
unicase/cased	#include "unicase/caseprop.h"	unicase/cased.c unicase/cased.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE])	unitypes-h bool
unicase/ignorable	#include "unicase/caseprop.h"	unicase/ignorable.c unicase/ignorable.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE])	unitypes-h bool
unicase/special-casing	#include "unicase/special-casing.h"	unicase/special-casing.in.h unicase/special-casing.c unicase/special-casing-table.gperf	00gnulib.m4 zzgnulib.m4 AC_PROG_MKDIR_P	gen-header gperf
unicase/tocasefold	#include "unicase/casefold.h"	unicase/tocasefold.c unicase/tocasefold.h unicase/simple-mapping.h	00gnulib.m4 zzgnulib.m4	unicase/base
unicase/u16-casemap	#include "unicase/unicasemap.h"	unicase/u16-casemap.c unicase/u-casemap.h unicase/context.h	00gnulib.m4 zzgnulib.m4	unicase/base unicase/cased unicase/ignorable unicase/special-casing unictype/combining-class unictype/property-soft-dotted unistr/u16-mbtouc-unsafe unistr/u16-uctomb unistr/u16-cpy uninorm/u16-normalize bool
unicase/u16-is-invariant	#include "unicase/invariant.h"	unicase/u16-is-invariant.c unicase/u-is-invariant.h	00gnulib.m4 zzgnulib.m4	unitypes-h uninorm/base uninorm/u16-normalize uninorm/nfd unistr/u16-cmp bool
unicase/u32-casemap	#include "unicase/unicasemap.h"	unicase/u32-casemap.c unicase/u-casemap.h unicase/context.h	00gnulib.m4 zzgnulib.m4	unicase/base unicase/cased unicase/ignorable unicase/special-casing unictype/combining-class unictype/property-soft-dotted unistr/u32-mbtouc-unsafe unistr/u32-uctomb unistr/u32-cpy uninorm/u32-normalize bool
unicase/u32-is-invariant	#include "unicase/invariant.h"	unicase/u32-is-invariant.c unicase/u-is-invariant.h	00gnulib.m4 zzgnulib.m4	unitypes-h uninorm/base uninorm/u32-normalize uninorm/nfd unistr/u32-cmp bool
unicase/u32-is-uppercase	#include "unicase.h"	unicase/u32-is-uppercase.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unicase/u32-is-uppercase])	unicase/base unicase/u32-is-invariant unicase/u32-toupper
unicase/u8-casemap	#include "unicase/unicasemap.h"	unicase/u8-casemap.c unicase/u-casemap.h unicase/context.h	00gnulib.m4 zzgnulib.m4	unicase/base unicase/cased unicase/ignorable unicase/special-casing unictype/combining-class unictype/property-soft-dotted unistr/u8-mbtouc-unsafe unistr/u8-uctomb unistr/u8-cpy uninorm/u8-normalize bool
unicase/u8-is-invariant	#include "unicase/invariant.h"	unicase/u8-is-invariant.c unicase/u-is-invariant.h	00gnulib.m4 zzgnulib.m4	unitypes-h uninorm/base uninorm/u8-normalize uninorm/nfd unistr/u8-cmp bool
unictype/category-LC	#include "unictype.h"	unictype/categ_LC.c unictype/categ_LC.h	00gnulib.m4 zzgnulib.m4 gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/category-LC])	unictype/base
unictype/category-longname	#include "unictype.h"	unictype/categ_longname.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9.8], [unictype/category-longname])	unictype/base
unictype/combining-class-all	#include "unictype.h"	---	00gnulib.m4 zzgnulib.m4	unictype/base unictype/combining-class unictype/combining-class-byname unictype/combining-class-longname unictype/combining-class-name
unictype/combining-class-byname	#include "unictype.h"	unictype/combiningclass_byname.c unictype/combiningclass_byname.gperf	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9.8], [unictype/combining-class-byname])	unictype/base gperf
unictype/combining-class-longname	#include "unictype.h"	unictype/combiningclass_longname.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9.8], [unictype/combining-class-longname])	unictype/base
unictype/combining-class-name	#include "unictype.h"	unictype/combiningclass_name.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9.8], [unictype/combining-class-name])	unictype/base
unictype/incb-all	#include "unictype.h"	---	00gnulib.m4 zzgnulib.m4	unictype/base unictype/incb-byname unictype/incb-name unictype/incb-of
unictype/incb-byname	#include "unictype.h"	unictype/incb_byname.c unictype/incb_byname.gperf	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.2], [unictype/incb-byname])	unictype/base gperf
unictype/incb-name	#include "unictype.h"	unictype/incb_name.c unictype/incb_name.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.2], [unictype/incb-name])	unictype/base
unictype/incb-of	#include "unictype.h"	unictype/incb_of.c unictype/incb_of.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unictype/incb-of])	unictype/base
unictype/joininggroup-all	#include "unictype.h"	---	00gnulib.m4 zzgnulib.m4	unictype/base unictype/joininggroup-byname unictype/joininggroup-name unictype/joininggroup-of
unictype/joininggroup-byname	#include "unictype.h"	unictype/joininggroup_byname.c unictype/joininggroup_byname.gperf	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unictype/joininggroup-byname])	unictype/base gperf
unictype/joininggroup-name	#include "unictype.h"	unictype/joininggroup_name.c unictype/joininggroup_name.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unictype/joininggroup-name])	unictype/base
unictype/joininggroup-of	#include "unictype.h"	unictype/joininggroup_of.c unictype/joininggroup_of.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unictype/joininggroup-of])	unictype/base
unictype/joiningtype-all	#include "unictype.h"	---	00gnulib.m4 zzgnulib.m4	unictype/base unictype/joiningtype-byname unictype/joiningtype-longname unictype/joiningtype-name unictype/joiningtype-of
unictype/joiningtype-byname	#include "unictype.h"	unictype/joiningtype_byname.c unictype/joiningtype_byname.gperf	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9.8], [unictype/joiningtype-byname])	unictype/base gperf
unictype/joiningtype-longname	#include "unictype.h"	unictype/joiningtype_longname.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9.8], [unictype/joiningtype-longname])	unictype/base
unictype/joiningtype-name	#include "unictype.h"	unictype/joiningtype_name.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9.8], [unictype/joiningtype-name])	unictype/base
unictype/joiningtype-of	#include "unictype.h"	unictype/joiningtype_of.c unictype/joiningtype_of.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unictype/joiningtype-of])	unictype/base unictype/category-test-withtable
unictype/property-emoji	#include "unictype.h"	unictype/pr_emoji.c unictype/pr_emoji.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-emoji])	unictype/base
unictype/property-emoji-component	#include "unictype.h"	unictype/pr_emoji_component.c unictype/pr_emoji_component.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.11], [unictype/property-emoji-component])	unictype/base
unictype/property-emoji-modifier	#include "unictype.h"	unictype/pr_emoji_modifier.c unictype/pr_emoji_modifier.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.11], [unictype/property-emoji-modifier])	unictype/base
unictype/property-emoji-modifier-base	#include "unictype.h"	unictype/pr_emoji_modifier_base.c unictype/pr_emoji_modifier_base.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.1], [unictype/property-emoji-modifier-base])	unictype/base
unictype/property-emoji-presentation	#include "unictype.h"	unictype/pr_emoji_presentation.c unictype/pr_emoji_presentation.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unictype/property-emoji-presentation])	unictype/base
unictype/property-extended-pictographic	#include "unictype.h"	unictype/pr_extended_pictographic.c unictype/pr_extended_pictographic.h unictype/bitmap.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.11], [unictype/property-extended-pictographic])	unictype/base
unictype/property-regional-indicator	#include "unictype.h"	unictype/pr_regional_indicator.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_UNICTYPE_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([0.9.11], [unictype/property-regional-indicator])	unictype/base
unigbrk/base	#include "unigbrk.h"	unigbrk.in.h	libunistring-base.m4 00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_LIBHEADER([1.2], [unigbrk.h]) AC_PROG_MKDIR_P	gen-header unitypes-h bool
unigbrk/u16-grapheme-breaks	#include "unigbrk.h"	unigbrk/u16-grapheme-breaks.c unigbrk/u-grapheme-breaks.h	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([unigbrk/u16-grapheme-breaks]) gl_LIBUNISTRING_MODULE([1.3], [unigbrk/u16-grapheme-breaks])	unigbrk/base unigbrk/uc-gbrk-prop unictype/incb-of unictype/property-extended-pictographic unistr/u16-mbtouc bool
unigbrk/u16-grapheme-next	#include "unigbrk.h"	unigbrk/u16-grapheme-next.c unigbrk/u-grapheme-next.h	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([unigbrk/u16-grapheme-next]) gl_LIBUNISTRING_MODULE([1.4], [unigbrk/u16-grapheme-next])	unigbrk/base unigbrk/uc-gbrk-prop unictype/incb-of unictype/property-extended-pictographic unistr/u16-mbtouc bool
unigbrk/u16-grapheme-prev	#include "unigbrk.h"	unigbrk/u16-grapheme-prev.c unigbrk/u-grapheme-prev.h	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([unigbrk/u16-grapheme-prev]) gl_LIBUNISTRING_MODULE([1.4], [unigbrk/u16-grapheme-prev])	unigbrk/base unigbrk/uc-gbrk-prop unictype/incb-of unictype/property-extended-pictographic unistr/u16-prev bool
unigbrk/u32-grapheme-breaks	#include "unigbrk.h"	unigbrk/u32-grapheme-breaks.c unigbrk/u-grapheme-breaks.h	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([unigbrk/u32-grapheme-breaks]) gl_LIBUNISTRING_MODULE([1.3], [unigbrk/u32-grapheme-breaks])	unigbrk/base unigbrk/uc-gbrk-prop unictype/incb-of unictype/property-extended-pictographic unistr/u32-mbtouc bool
unigbrk/u32-grapheme-next	#include "unigbrk.h"	unigbrk/u32-grapheme-next.c unigbrk/u-grapheme-next.h	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([unigbrk/u32-grapheme-next]) gl_LIBUNISTRING_MODULE([1.4], [unigbrk/u32-grapheme-next])	unigbrk/base unigbrk/uc-gbrk-prop unictype/incb-of unictype/property-extended-pictographic unistr/u32-mbtouc bool
unigbrk/u32-grapheme-prev	#include "unigbrk.h"	unigbrk/u32-grapheme-prev.c unigbrk/u-grapheme-prev.h	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([unigbrk/u32-grapheme-prev]) gl_LIBUNISTRING_MODULE([1.4], [unigbrk/u32-grapheme-prev])	unigbrk/base unigbrk/uc-gbrk-prop unictype/incb-of unictype/property-extended-pictographic unistr/u32-prev bool
unigbrk/u8-grapheme-breaks	#include "unigbrk.h"	unigbrk/u8-grapheme-breaks.c unigbrk/u-grapheme-breaks.h	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([unigbrk/u8-grapheme-breaks]) gl_LIBUNISTRING_MODULE([1.3], [unigbrk/u8-grapheme-breaks])	unigbrk/base unigbrk/uc-gbrk-prop unictype/incb-of unictype/property-extended-pictographic unistr/u8-mbtouc bool
unigbrk/u8-grapheme-next	#include "unigbrk.h"	unigbrk/u8-grapheme-next.c unigbrk/u-grapheme-next.h	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([unigbrk/u8-grapheme-next]) gl_LIBUNISTRING_MODULE([1.4], [unigbrk/u8-grapheme-next])	unigbrk/base unigbrk/uc-gbrk-prop unictype/incb-of unictype/property-extended-pictographic unistr/u8-mbtouc bool
unigbrk/u8-grapheme-prev	#include "unigbrk.h"	unigbrk/u8-grapheme-prev.c unigbrk/u-grapheme-prev.h	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([unigbrk/u8-grapheme-prev]) gl_LIBUNISTRING_MODULE([1.4], [unigbrk/u8-grapheme-prev])	unigbrk/base unigbrk/uc-gbrk-prop unictype/incb-of unictype/property-extended-pictographic unistr/u8-prev bool
unigbrk/uc-gbrk-prop	#include "unigbrk.h"	unigbrk/gbrkprop.h unigbrk/uc-gbrk-prop.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unigbrk/uc-gbrk-prop])	unigbrk/base
unigbrk/uc-grapheme-breaks	#include "unigbrk.h"	unigbrk/uc-grapheme-breaks.c unigbrk/u-grapheme-breaks.h	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([unigbrk/uc-grapheme-breaks]) gl_LIBUNISTRING_MODULE([1.3], [unigbrk/uc-grapheme-breaks])	unigbrk/base unigbrk/uc-gbrk-prop unictype/incb-of unictype/property-extended-pictographic bool
unigbrk/uc-is-grapheme-break	#include "unigbrk.h"	unigbrk/uc-is-grapheme-break.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.3], [unigbrk/uc-is-grapheme-break])	unigbrk/base unigbrk/uc-gbrk-prop
unigbrk/ulc-grapheme-breaks	#include "unigbrk.h"	unigbrk/ulc-grapheme-breaks.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([unigbrk/ulc-grapheme-breaks]) gl_LIBUNISTRING_MODULE([1.3], [unigbrk/ulc-grapheme-breaks])	unigbrk/base unigbrk/u8-grapheme-breaks uniconv/u8-conv-from-enc c-ctype localcharset
unimetadata/base	#include "unimetadata.h"	unimetadata.in.h	libunistring-base.m4 unimetadata_h.m4 00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_LIBHEADER([1.2], [unimetadata.h]) gl_UNIMETADATA_H gl_UNIMETADATA_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	gen-header
unimetadata/u-version	#include "unimetadata.h"	unimetadata/u-version.c	00gnulib.m4 zzgnulib.m4 gl_UNIMETADATA_H_REQUIRE_DEFAULTS gl_LIBUNISTRING_MODULE_WITH_VARIABLE([1.3], [unimetadata/u-version])	unimetadata/base
uninorm/compat-decomposition	#include "uninorm/decompose-internal.h"	uninorm/compat-decomposition.c	00gnulib.m4 zzgnulib.m4	uninorm/base uninorm/decomposition
uninorm/decompose-internal	#include "uninorm/decompose-internal.h"	uninorm/decompose-internal.c	00gnulib.m4 zzgnulib.m4	unitypes-h array-mergesort
uninorm/decomposition-table	#include "uninorm/decomposition-table.h"	uninorm/decomposition-table.c uninorm/decomposition-table1.h uninorm/decomposition-table2.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_INLINE])	uninorm/base
unistd-h	#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 fcntl-h ssize_t stddef-h sys_types-h
unistr/u16-pcpy	#include "unistr.h"	unistr/u16-pcpy.c unistr/u-pcpy.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.2], [unistr/u16-pcpy])	unistr/base unistr/u16-cpy
unistr/u32-pcpy	#include "unistr.h"	unistr/u32-pcpy.c unistr/u-pcpy.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.2], [unistr/u32-pcpy])	unistr/base unistr/u32-cpy
unistr/u8-pcpy	#include "unistr.h"	unistr/u8-pcpy.c unistr/u-pcpy.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.2], [unistr/u8-pcpy])	unistr/base unistr/u8-cpy
unitypes-h	#include "unitypes.h"	unitypes.in.h	unitypes_h.m4 libunistring-base.m4 00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_LIBHEADER([0.9.11], [unitypes.h]) AC_PROG_MKDIR_P gl_UNITYPES_H	gen-header stdint-h
uniwbrk/table	#include "uniwbrk/wbrktable.h"	uniwbrk/wbrktable.c	00gnulib.m4 zzgnulib.m4	---
unlinkat	#include <unistd.h>	unlinkat.c at-func.c	unlinkat.m4 lstat.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_UNLINKAT gl_CONDITIONAL([GL_COND_OBJ_UNLINKAT], [test $HAVE_UNLINKAT = 0 \|\| test $REPLACE_UNLINKAT = 1]) gl_UNISTD_MODULE_INDICATOR([unlinkat])	unistd-h extensions fcntl-h [test $HAVE_UNLINKAT = 0 \|\| test $REPLACE_UNLINKAT = 1] openat-h [test $HAVE_UNLINKAT = 0 \|\| test $REPLACE_UNLINKAT = 1] sys_stat-h [test $HAVE_UNLINKAT = 0 \|\| test $REPLACE_UNLINKAT = 1] at-internal [test $HAVE_UNLINKAT = 0] errno-h [test $HAVE_UNLINKAT = 0] fchdir [test $HAVE_UNLINKAT = 0] filename [test $HAVE_UNLINKAT = 0] openat-die [test $HAVE_UNLINKAT = 0] rmdir [test $HAVE_UNLINKAT = 0] save-cwd [test $HAVE_UNLINKAT = 0] unlink [test $HAVE_UNLINKAT = 0]
utmp	#include <utmp.h>	---	00gnulib.m4 zzgnulib.m4	utmp-h
utmp-h	#include <utmp.h>	utmp.in.h	utmp_h.m4 pty_h.m4 termios_h.m4 00gnulib.m4 zzgnulib.m4 gl_UTMP_H gl_UTMP_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	gen-header include_next snippet/c++defs snippet/warn-on-use
valgrind-tests	---	---	valgrind-tests.m4 00gnulib.m4 zzgnulib.m4 gl_VALGRIND_TESTS	---
vasnprintf-gnu	#include "vasnprintf.h"	---	vasnprintf-gnu.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_VASNPRINTF_GNU	vasnprintf-posix mixin/printf-gnu
vasnwprintf	#include "vasnwprintf.h"	float+.h printf-args.h printf-args.c wprintf-parse.h wprintf-parse.c printf-parse.c vasnwprintf.c vasnprintf.c asnwprintf.c	wint_t.m4 intmax_t.m4 stdint_h.m4 inttypes_h.m4 vasnprintf.m4 printf.m4 mbrtowc.m4 math_h.m4 exponentd.m4 musl.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_RESTRICT]) gl_FUNC_VASNWPRINTF	stdio-h alloca-opt attribute float-h free-posix limits-h stdint-h xsize errno-h memchr assert-h wchar-h localeconv mbszero mbrtowc wmemcpy wmemset
vasnwprintf-gnu	#include "vasnwprintf.h"	---	vasnwprintf-gnu.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_VASNWPRINTF_GNU	vasnwprintf-posix mixin/printf-gnu
vasnwprintf-posix	#include "vasnwprintf.h"	---	vasnwprintf-posix.m4 printf.m4 math_h.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_VASNWPRINTF_POSIX	vasnwprintf mixin/printf-posix nocrash printf-safe multiarch
vasprintf-gnu	#include <stdio.h>	---	vasprintf-gnu.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_VASPRINTF_GNU	vasprintf-posix mixin/printf-gnu
vaszprintf	#include <stdio.h>	vaszprintf.c aszprintf.c	00gnulib.m4 zzgnulib.m4 gl_STDIO_MODULE_INDICATOR([vaszprintf]) m4_ifdef([AM_XGETTEXT_OPTION], [AM_][XGETTEXT_OPTION([--flag=aszprintf:2:c-format]) AM_][XGETTEXT_OPTION([--flag=vaszprintf:2:c-format])])	stdio-h vasnprintf errno-h stdint-h
vaszprintf-gnu	#include <stdio.h>	---	00gnulib.m4 zzgnulib.m4 gl_PREREQ_VASNPRINTF_WITH_GNU_EXTRAS	vaszprintf-posix mixin/printf-gnu
vaszprintf-posix	#include <stdio.h>	---	00gnulib.m4 zzgnulib.m4 gl_PREREQ_VASNPRINTF_WITH_POSIX_EXTRAS	vaszprintf mixin/printf-posix
vc-mtime	#include "vc-mtime.h"	vc-mtime.c	00gnulib.m4 zzgnulib.m4	time-h bool spawn-pipe wait-process execute safe-read error getline xstrtol stat-time windows-cygpath filename xalloc xgetcwd canonicalize-lgpl xvasprintf str_startswith map xmap hash-map hashkey-string getdelim gettext-h gnulib-i18n
vdprintf-gnu	#include <stdio.h>	---	vdprintf-gnu.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_VDPRINTF_GNU	vdprintf-posix mixin/printf-gnu
vdzprintf	#include <stdio.h>	vdzprintf.c	00gnulib.m4 zzgnulib.m4 gl_STDIO_MODULE_INDICATOR([vdzprintf])	stdio-h vasnprintf intprops free-posix full-write errno-h
vdzprintf-gnu	#include <stdio.h>	---	00gnulib.m4 zzgnulib.m4 gl_PREREQ_VASNPRINTF_WITH_GNU_EXTRAS	vdzprintf-posix mixin/printf-gnu
vdzprintf-posix	#include <stdio.h>	---	00gnulib.m4 zzgnulib.m4 gl_PREREQ_VASNPRINTF_WITH_POSIX_EXTRAS	vdzprintf mixin/printf-posix
version-stamp	---	---	version-stamp.m4 00gnulib.m4 zzgnulib.m4	---
vfprintf-gnu	#include <stdio.h>	---	vfprintf-gnu.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_VFPRINTF_GNU	vfprintf-posix mixin/printf-gnu
vfscanf	#include <stdio.h>	---	00gnulib.m4 zzgnulib.m4 gl_STDIO_MODULE_INDICATOR([vfscanf]) gl_MODULE_INDICATOR([vfscanf])	stdio-h
vfzprintf	#include <stdio.h>	vfzprintf.c	00gnulib.m4 zzgnulib.m4 gl_STDIO_MODULE_INDICATOR([vfzprintf])	stdio-h vasnprintf intprops free-posix fseterr errno-h
vfzprintf-gnu	#include <stdio.h>	---	00gnulib.m4 zzgnulib.m4 gl_PREREQ_VASNPRINTF_WITH_GNU_EXTRAS	vfzprintf-posix mixin/printf-gnu
vfzprintf-posix	#include <stdio.h>	---	00gnulib.m4 zzgnulib.m4 gl_PREREQ_VASNPRINTF_WITH_POSIX_EXTRAS	vfzprintf mixin/printf-posix
vma-iter	#include "vma-iter.h"	vma-iter.c	mmap-anon.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_MMAP_ANON AC_REQUIRE([AC_C_INLINE]) AC_CHECK_FUNCS_ONCE([mquery pstat_getprocvm])	stdint-h unistd-h extensions getpagesize open
vma-prot	#include "vma-prot.h"	vma-prot.c	00gnulib.m4 zzgnulib.m4	stdint-h vma-iter
vprintf-gnu	#include <stdio.h>	---	vprintf-gnu.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_VPRINTF_GNU	vprintf-posix mixin/printf-gnu
vscanf	#include <stdio.h>	---	00gnulib.m4 zzgnulib.m4 gl_STDIO_MODULE_INDICATOR([vscanf]) gl_MODULE_INDICATOR([vscanf])	stdio-h
vsnprintf-gnu	#include <stdio.h>	---	vsnprintf-gnu.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_VSNPRINTF_GNU	vsnprintf-posix mixin/printf-gnu
vsnzprintf	#include <stdio.h>	vsnzprintf.c	00gnulib.m4 zzgnulib.m4 gl_STDIO_MODULE_INDICATOR([vsnzprintf])	stdio-h vasnprintf errno-h stdint-h
vsnzprintf-gnu	#include <stdio.h>	---	00gnulib.m4 zzgnulib.m4 gl_PREREQ_VASNPRINTF_WITH_GNU_EXTRAS	vsnzprintf-posix mixin/printf-gnu
vsnzprintf-posix	#include <stdio.h>	---	00gnulib.m4 zzgnulib.m4 gl_PREREQ_VASNPRINTF_WITH_POSIX_EXTRAS	vsnzprintf mixin/printf-posix
vsprintf-gnu	#include <stdio.h>	---	vsprintf-gnu.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_VSPRINTF_GNU	vsprintf-posix mixin/printf-gnu
vszprintf	#include <stdio.h>	vszprintf.c	00gnulib.m4 zzgnulib.m4 gl_STDIO_MODULE_INDICATOR([vszprintf])	stdio-h vasnprintf errno-h stdint-h
vszprintf-gnu	#include <stdio.h>	---	00gnulib.m4 zzgnulib.m4 gl_PREREQ_VASNPRINTF_WITH_GNU_EXTRAS	vszprintf-posix mixin/printf-gnu
vszprintf-posix	#include <stdio.h>	---	00gnulib.m4 zzgnulib.m4 gl_PREREQ_VASNPRINTF_WITH_POSIX_EXTRAS	vszprintf mixin/printf-posix
vzprintf	#include <stdio.h>	vzprintf.c	00gnulib.m4 zzgnulib.m4 gl_STDIO_MODULE_INDICATOR([vzprintf])	stdio-h vfzprintf
vzprintf-gnu	#include <stdio.h>	---	00gnulib.m4 zzgnulib.m4 gl_PREREQ_VASNPRINTF_WITH_GNU_EXTRAS	vzprintf-posix mixin/printf-gnu
vzprintf-posix	#include <stdio.h>	---	00gnulib.m4 zzgnulib.m4 gl_PREREQ_VASNPRINTF_WITH_POSIX_EXTRAS	vzprintf mixin/printf-posix
waitpid	#include <sys/wait.h>	waitpid.c	waitpid.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_WAITPID gl_CONDITIONAL([GL_COND_OBJ_WAITPID], [test $HAVE_WAITPID = 0]) gl_SYS_WAIT_MODULE_INDICATOR([waitpid])	sys_wait-h
wchar-h	#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 extern-inline inttypes-h-incomplete stddef-h stdlib-h
wchar-single	---	---	00gnulib.m4 zzgnulib.m4 AC_DEFINE([GNULIB_WCHAR_SINGLE_LOCALE], [1], [Define to 1 to enable more efficient wchar replacements, where we know the locale charset will not change between calls.]) dnl For backward compatibility: gl_MODULE_INDICATOR([wchar-single])	wchar-h
wcpcpy	#include <wchar.h>	wcpcpy.c wcpcpy-impl.h	wcpcpy.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_WCPCPY gl_CONDITIONAL([GL_COND_OBJ_WCPCPY], [test $HAVE_WCPCPY = 0]) gl_WCHAR_MODULE_INDICATOR([wcpcpy])	extensions wchar-h
wcpncpy	#include <wchar.h>	wcpncpy.c wcpncpy-impl.h	wcpncpy.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_WCPNCPY gl_CONDITIONAL([GL_COND_OBJ_WCPNCPY], [test $HAVE_WCPNCPY = 0]) gl_WCHAR_MODULE_INDICATOR([wcpncpy])	extensions wchar-h
wcscasecmp	#include <wchar.h>	wcscasecmp.c wcscasecmp-impl.h	wcscasecmp.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_WCSCASECMP gl_CONDITIONAL([GL_COND_OBJ_WCSCASECMP], [test $HAVE_WCSCASECMP = 0]) gl_WCHAR_MODULE_INDICATOR([wcscasecmp])	wchar-h wctype-h [test $HAVE_WCSCASECMP = 0]
wcscat	#include <wchar.h>	wcscat.c wcscat-impl.h	wcscat.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_WCSCAT gl_CONDITIONAL([GL_COND_OBJ_WCSCAT], [test $HAVE_WCSCAT = 0]) gl_WCHAR_MODULE_INDICATOR([wcscat])	wchar-h
wcschr	#include <wchar.h>	wcschr.c wcschr-impl.h	wcschr.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_WCSCHR gl_CONDITIONAL([GL_COND_OBJ_WCSCHR], [test $HAVE_WCSCHR = 0]) gl_WCHAR_MODULE_INDICATOR([wcschr])	wchar-h
wcscmp	#include <wchar.h>	wcscmp.c wcscmp-impl.h	wcscmp.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_WCSCMP gl_CONDITIONAL([GL_COND_OBJ_WCSCMP], [test $HAVE_WCSCMP = 0 \|\| test $REPLACE_WCSCMP = 1]) gl_WCHAR_MODULE_INDICATOR([wcscmp])	wchar-h
wcscoll	#include <wchar.h>	wcscoll.c wcscoll-impl.h	wcscoll.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_WCSCOLL gl_CONDITIONAL([GL_COND_OBJ_WCSCOLL], [test $HAVE_WCSCOLL = 0]) gl_WCHAR_MODULE_INDICATOR([wcscoll])	free-posix wchar-h
wcscpy	#include <wchar.h>	wcscpy.c wcscpy-impl.h	wcscpy.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_WCSCPY gl_CONDITIONAL([GL_COND_OBJ_WCSCPY], [test $HAVE_WCSCPY = 0]) gl_WCHAR_MODULE_INDICATOR([wcscpy])	wchar-h
wcscspn	#include <wchar.h>	wcscspn.c wcscspn-impl.h	wcscspn.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_WCSCSPN gl_CONDITIONAL([GL_COND_OBJ_WCSCSPN], [test $HAVE_WCSCSPN = 0]) gl_WCHAR_MODULE_INDICATOR([wcscspn])	wchar-h wcslen [test $HAVE_WCSCSPN = 0] wcschr [test $HAVE_WCSCSPN = 0]
wcsdup	#include <wchar.h>	wcsdup.c wcsdup-impl.h	wcsdup.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_WCSDUP gl_CONDITIONAL([GL_COND_OBJ_WCSDUP], [test $HAVE_WCSDUP = 0]) gl_WCHAR_MODULE_INDICATOR([wcsdup])	wchar-h wcslen [test $HAVE_WCSDUP = 0] wmemcpy [test $HAVE_WCSDUP = 0]
wcsftime	#include <wchar.h>	wcsftime.c	wcsftime.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_WCSFTIME gl_CONDITIONAL([GL_COND_OBJ_WCSFTIME], [test $REPLACE_WCSFTIME = 1]) gl_WCHAR_MODULE_INDICATOR([wcsftime])	wchar-h
wcslen	#include <wchar.h>	wcslen.c wcslen-impl.h	wcslen.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_WCSLEN gl_CONDITIONAL([GL_COND_OBJ_WCSLEN], [test $HAVE_WCSLEN = 0]) gl_WCHAR_MODULE_INDICATOR([wcslen])	wchar-h
wcsncasecmp	#include <wchar.h>	wcsncasecmp.c wcsncasecmp-impl.h	wcsncasecmp.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_WCSNCASECMP gl_CONDITIONAL([GL_COND_OBJ_WCSNCASECMP], [test $HAVE_WCSNCASECMP = 0]) gl_WCHAR_MODULE_INDICATOR([wcsncasecmp])	wchar-h wctype-h [test $HAVE_WCSNCASECMP = 0]
wcsncat	#include <wchar.h>	wcsncat.c wcsncat-impl.h	wcsncat.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_WCSNCAT gl_CONDITIONAL([GL_COND_OBJ_WCSNCAT], [test $HAVE_WCSNCAT = 0 \|\| test $REPLACE_WCSNCAT = 1]) gl_WCHAR_MODULE_INDICATOR([wcsncat])	wchar-h
wcsncmp	#include <wchar.h>	wcsncmp.c wcsncmp-impl.h	wcsncmp.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_WCSNCMP gl_CONDITIONAL([GL_COND_OBJ_WCSNCMP], [test $HAVE_WCSNCMP = 0 \|\| test $REPLACE_WCSNCMP = 1]) gl_WCHAR_MODULE_INDICATOR([wcsncmp])	wchar-h
wcsncpy	#include <wchar.h>	wcsncpy.c wcsncpy-impl.h	wcsncpy.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_WCSNCPY gl_CONDITIONAL([GL_COND_OBJ_WCSNCPY], [test $HAVE_WCSNCPY = 0]) gl_WCHAR_MODULE_INDICATOR([wcsncpy])	wchar-h
wcsnlen	#include <wchar.h>	wcsnlen.c wcsnlen-impl.h	wcsnlen.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_WCSNLEN gl_CONDITIONAL([GL_COND_OBJ_WCSNLEN], [test $HAVE_WCSNLEN = 0]) gl_WCHAR_MODULE_INDICATOR([wcsnlen])	wchar-h
wcspbrk	#include <wchar.h>	wcspbrk.c wcspbrk-impl.h	wcspbrk.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_WCSPBRK gl_CONDITIONAL([GL_COND_OBJ_WCSPBRK], [test $HAVE_WCSPBRK = 0]) gl_WCHAR_MODULE_INDICATOR([wcspbrk])	wchar-h wcschr [test $HAVE_WCSPBRK = 0]
wcsrchr	#include <wchar.h>	wcsrchr.c wcsrchr-impl.h	wcsrchr.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_WCSRCHR gl_CONDITIONAL([GL_COND_OBJ_WCSRCHR], [test $HAVE_WCSRCHR = 0]) gl_WCHAR_MODULE_INDICATOR([wcsrchr])	wchar-h
wcsspn	#include <wchar.h>	wcsspn.c wcsspn-impl.h	wcsspn.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_WCSSPN gl_CONDITIONAL([GL_COND_OBJ_WCSSPN], [test $HAVE_WCSSPN = 0]) gl_WCHAR_MODULE_INDICATOR([wcsspn])	wchar-h wcschr [test $HAVE_WCSSPN = 0]
wcsstr	#include <wchar.h>	wcsstr.c wcsstr-impl.h wcs-two-way.h	wcsstr.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_WCSSTR if test $HAVE_WCSSTR = 0 \|\| test $REPLACE_WCSSTR = 1; then AC_LIBOBJ([wcsstr]) fi	wcsstr-simple builtin-expect [test $HAVE_WCSSTR = 0 \|\| test $REPLACE_WCSSTR = 1] wcschr [test $HAVE_WCSSTR = 0 \|\| test $REPLACE_WCSSTR = 1] wmemchr [test $HAVE_WCSSTR = 0 \|\| test $REPLACE_WCSSTR = 1] wmemcmp [test $HAVE_WCSSTR = 0 \|\| test $REPLACE_WCSSTR = 1]
wcsstr-simple	#include <wchar.h>	wcsstr.c wcsstr-impl.h	wcsstr.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_WCSSTR_SIMPLE if test $HAVE_WCSSTR = 0; then AC_LIBOBJ([wcsstr]) fi gl_WCHAR_MODULE_INDICATOR([wcsstr])	wchar-h wcschr [test $HAVE_WCSSTR = 0]
wcstok	#include <wchar.h>	wcstok.c wcstok-impl.h	wcstok.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_WCSTOK gl_CONDITIONAL([GL_COND_OBJ_WCSTOK], [test $HAVE_WCSTOK = 0 \|\| test $REPLACE_WCSTOK = 1]) gl_WCHAR_MODULE_INDICATOR([wcstok])	wchar-h wcsspn [test $HAVE_WCSTOK = 0 \|\| test $REPLACE_WCSTOK = 1] wcspbrk [test $HAVE_WCSTOK = 0 \|\| test $REPLACE_WCSTOK = 1]
wcswidth	#include <wchar.h>	wcswidth.c wcswidth-impl.h	wcswidth.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_WCSWIDTH gl_CONDITIONAL([GL_COND_OBJ_WCSWIDTH], [test $HAVE_WCSWIDTH = 0 \|\| test $REPLACE_WCSWIDTH = 1]) gl_WCHAR_MODULE_INDICATOR([wcswidth])	wchar-h wcwidth [test $HAVE_WCSWIDTH = 0 \|\| test $REPLACE_WCSWIDTH = 1]
wcsxfrm	#include <wchar.h>	wcsxfrm.c wcsxfrm-impl.h	wcsxfrm.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_WCSXFRM gl_CONDITIONAL([GL_COND_OBJ_WCSXFRM], [test $HAVE_WCSXFRM = 0]) gl_WCHAR_MODULE_INDICATOR([wcsxfrm])	free-posix wchar-h
wctomb	#include <stdlib.h>	wctomb.c wctomb-impl.h	wctomb.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_WCTOMB gl_CONDITIONAL([GL_COND_OBJ_WCTOMB], [test $REPLACE_WCTOMB = 1]) AM_COND_IF([GL_COND_OBJ_WCTOMB], [ gl_PREREQ_WCTOMB ]) gl_STDLIB_MODULE_INDICATOR([wctomb])	stdlib-h wchar-h [test $REPLACE_WCTOMB = 1] mbszero [test $REPLACE_WCTOMB = 1] wcrtomb [test $REPLACE_WCTOMB = 1]
wctrans	#include <wctype.h>	wctrans.c wctrans-impl.h	wctrans.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_WCTRANS gl_CONDITIONAL([GL_COND_OBJ_WCTRANS], [test $HAVE_WCTRANS = 0 \|\| test $REPLACE_WCTRANS = 1]) gl_WCTYPE_MODULE_INDICATOR([wctrans])	wctype-h towctrans [test $REPLACE_WCTRANS = 1]
wctype-h	#include <wctype.h>	wctype.in.h wctype-h.c	wctype_h.m4 wint_t.m4 00gnulib.m4 zzgnulib.m4 gl_WCTYPE_H gl_WCTYPE_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	extern-inline gen-header include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use
wgetcwd-lgpl	#include <wchar.h>	wgetcwd-lgpl.c	00gnulib.m4 zzgnulib.m4 gl_WCHAR_MODULE_INDICATOR([wgetcwd])	wchar-h free-posix
windows-cond	#include "windows-cond.h"	windows-cond.c windows-initguard.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_CANONICAL_HOST]) gl_CONDITIONAL([GL_COND_OBJ_WINDOWS_COND], [case "$host_os" in mingw* \| windows) true;; ) false;; esac])	bool errno-h time-h gettimeofday
windows-cygpath	#include "windows-cygpath.h"	windows-cygpath.c	00gnulib.m4 zzgnulib.m4	spawn-pipe wait-process getline xalloc free-posix gettext-h gnulib-i18n
windows-mutex	#include "windows-mutex.h"	windows-mutex.c windows-initguard.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_CANONICAL_HOST]) gl_CONDITIONAL([GL_COND_OBJ_WINDOWS_MUTEX], [case "$host_os" in mingw* \| windows) true;; ) false;; esac])	---
windows-once	#include "windows-once.h"	windows-once.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_CANONICAL_HOST]) gl_CONDITIONAL([GL_COND_OBJ_WINDOWS_ONCE], [case "$host_os" in mingw* \| windows) true;; ) false;; esac])	---
windows-recmutex	#include "windows-recmutex.h"	windows-recmutex.c windows-initguard.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_CANONICAL_HOST]) gl_CONDITIONAL([GL_COND_OBJ_WINDOWS_RECMUTEX], [case "$host_os" in mingw* \| windows) true;; ) false;; esac])	---
windows-rwlock	#include "windows-rwlock.h"	windows-rwlock.c windows-initguard.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_CANONICAL_HOST]) gl_CONDITIONAL([GL_COND_OBJ_WINDOWS_RWLOCK], [case "$host_os" in mingw* \| windows) true;; ) false;; esac])	---
windows-spin	#include "windows-spin.h"	windows-spin.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_CANONICAL_HOST]) gl_CONDITIONAL([GL_COND_OBJ_WINDOWS_SPIN], [case "$host_os" in mingw* \| windows) true;; ) false;; esac])	---
windows-thread	#include "windows-thread.h"	windows-thread.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_CANONICAL_HOST]) gl_CONDITIONAL([GL_COND_OBJ_WINDOWS_THREAD], [case "$host_os" in mingw* \| windows) true;; ) false;; esac])	windows-once windows-tls
windows-timedmutex	#include "windows-timedmutex.h"	windows-timedmutex.c windows-initguard.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_CANONICAL_HOST]) gl_CONDITIONAL([GL_COND_OBJ_WINDOWS_TIMEDMUTEX], [case "$host_os" in mingw* \| windows) true;; ) false;; esac])	errno-h time-h gettimeofday
windows-timedrecmutex	#include "windows-timedrecmutex.h"	windows-timedrecmutex.c windows-initguard.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_CANONICAL_HOST]) gl_CONDITIONAL([GL_COND_OBJ_WINDOWS_TIMEDRECMUTEX], [case "$host_os" in mingw* \| windows) true;; ) false;; esac])	errno-h time-h gettimeofday
windows-timedrwlock	#include "windows-timedrwlock.h"	windows-timedrwlock.c windows-initguard.h	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_CANONICAL_HOST]) gl_CONDITIONAL([GL_COND_OBJ_WINDOWS_TIMEDRWLOCK], [case "$host_os" in mingw* \| windows) true;; ) false;; esac])	errno-h bool time-h gettimeofday
windows-tls	#include "windows-tls.h"	windows-tls.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_CANONICAL_HOST]) gl_CONDITIONAL([GL_COND_OBJ_WINDOWS_TLS], [case "$host_os" in mingw* \| windows) true;; ) false;; esac])	windows-once
wmemchr	#include <wchar.h>	wmemchr.c wmemchr-impl.h	wmemchr.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_WMEMCHR gl_CONDITIONAL([GL_COND_OBJ_WMEMCHR], [test $HAVE_WMEMCHR = 0]) gl_WCHAR_MODULE_INDICATOR([wmemchr])	wchar-h
wmemcmp	#include <wchar.h>	wmemcmp.c wmemcmp-impl.h	wmemcmp.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_WMEMCMP gl_CONDITIONAL([GL_COND_OBJ_WMEMCMP], [test $HAVE_WMEMCMP = 0 \|\| test $REPLACE_WMEMCMP = 1]) gl_WCHAR_MODULE_INDICATOR([wmemcmp])	wchar-h
wmemcpy	#include <wchar.h>	wmemcpy.c wmemcpy-impl.h	wmemcpy.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_WMEMCPY gl_CONDITIONAL([GL_COND_OBJ_WMEMCPY], [test $HAVE_WMEMCPY = 0]) gl_WCHAR_MODULE_INDICATOR([wmemcpy])	wchar-h
wmemmove	#include <wchar.h>	wmemmove.c wmemmove-impl.h	wmemmove.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_WMEMMOVE gl_CONDITIONAL([GL_COND_OBJ_WMEMMOVE], [test $HAVE_WMEMMOVE = 0]) gl_WCHAR_MODULE_INDICATOR([wmemmove])	wchar-h
wmemset	#include <wchar.h>	wmemset.c wmemset-impl.h	wmemset.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_WMEMSET gl_CONDITIONAL([GL_COND_OBJ_WMEMSET], [test $HAVE_WMEMSET = 0]) gl_WCHAR_MODULE_INDICATOR([wmemset])	wchar-h
xalloc-oversized	#include "xalloc-oversized.h"	---	00gnulib.m4 zzgnulib.m4	stdint-h
xbinary-io	#include "xbinary-io.h"	xbinary-io.c	00gnulib.m4 zzgnulib.m4	binary-io error exitfail extern-inline gettext-h gnulib-i18n bool verify
xgetcwd-lgpl	#include "xgetcwd.h"	xgetcwd.c	xgetcwd.m4 00gnulib.m4 zzgnulib.m4 gl_XGETCWD	getcwd-lgpl xalloc
xgetgroups	#include "mgetgroups.h"	xgetgroups.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([xgetgroups])	mgetgroups xalloc
xhash	#include "hash.h"	xhash.c	00gnulib.m4 zzgnulib.m4	hash xalloc
xmap	#include "gl_xmap.h"	gl_xmap.c	00gnulib.m4 zzgnulib.m4	map extern-inline bool xalloc-die
xomap	#include "gl_xomap.h"	gl_xomap.c	00gnulib.m4 zzgnulib.m4	omap extern-inline bool xalloc-die
xprintf-gnu	#include "xprintf.h"	---	00gnulib.m4 zzgnulib.m4	xprintf vzprintf-gnu vfzprintf-gnu
xset	#include "gl_xset.h"	gl_xset.c	00gnulib.m4 zzgnulib.m4	set extern-inline bool xalloc-die
xstdopen	#include "xstdopen.h"	xstdopen.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([xstdopen])	stdopen error gettext-h gnulib-i18n exitfail
xstrerror	#include "xstrerror.h"	xstrerror.c	00gnulib.m4 zzgnulib.m4	gettext-h gnulib-i18n strerror_r-posix xalloc xvasprintf
xstring-buffer	#include "string-buffer.h"	xstring-buffer.c xstring-buffer-printf.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([xstring-buffer])	string-buffer xalloc-die
xstring-buffer-reversed	#include "string-buffer-reversed.h"	xstring-buffer-reversed.c xstring-buffer-reversed-printf.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([xstring-buffer-reversed])	string-buffer-reversed xalloc-die
xstring-desc	#include "xstring-desc.h"	xstring-desc.c	00gnulib.m4 zzgnulib.m4	string-desc xalloc-die extern-inline
xvasprintf-gnu	#include "xvasprintf.h"	---	00gnulib.m4 zzgnulib.m4	xvasprintf vasprintf-gnu
zprintf	#include <stdio.h>	zprintf.c	00gnulib.m4 zzgnulib.m4 gl_STDIO_MODULE_INDICATOR([zprintf])	stdio-h vfzprintf
zprintf-gnu	#include <stdio.h>	---	00gnulib.m4 zzgnulib.m4 gl_PREREQ_VASNPRINTF_WITH_GNU_EXTRAS	zprintf-posix mixin/printf-gnu
zprintf-posix	#include <stdio.h>	---	00gnulib.m4 zzgnulib.m4 gl_PREREQ_VASNPRINTF_WITH_POSIX_EXTRAS	zprintf mixin/printf-posix

Lone files - please create new modules containing them

lib/t-idcache
lib/timevar.def
lib/unictype/sy_c_whitespace.h
lib/unictype/sy_java_whitespace.h
m4/gnulib-common.m4
m4/gnulib-tool.m4
m4/libdl.m4
m4/locale-ar.m4
m4/locale-tr.m4
m4/semaphore.m4
m4/ulonglong.m4
m4/windows-rc.m4

Future developments

Ideally a module could consist of:

A header file: lib/module.h
One or more implementation files: lib/module.c et al.
One or more autoconf macro files: m4/module.m4 et al.
A configure.ac fragment, Makefile.am fragment, dependency list: modules/module
A testsuite: source files in tests/ and metainformation (a configure.ac fragment, Makefile.am fragment, dependency list) in modules/module-tests
Some documentation
A POT file and some PO files

Generated by MODULES.html.sh from a git checkout as of 4 July 2025.