Gnulib Module List

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

Support for obsolete systems lacking ANSI C 89

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

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

Support for systems lacking ANSI C 89

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

Enhancements for ANSI C 89 functions

Diagnostics <assert.h>

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

Mathematics <math.h>

fpieee

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

Input/output <stdio.h>

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

Memory management functions <stdlib.h>

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

Sorting functions <stdlib.h>

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

Date and time <time.h>

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

Extra functions based on ANSI C 89

Memory management functions <stdlib.h>

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

Integer arithmetic functions <stdlib.h>

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

Environment variables <stdlib.h>

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

Character handling <ctype.h>

c-ctype

Character handling in C locale.

String handling <string.h>

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

Mathematics <math.h>

printf-frexp

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

Numeric conversion functions <stdlib.h>

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

Date and time <time.h>

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

Input/Output <stdio.h>

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

Signal handling <signal.h>

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

Wide-character string handling <wchar.h>

wmempcpy

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

Command-line arguments

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

Container data structures

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

Cryptographic computations (low-level)

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

Cryptographic computations (high-level)

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

Compiler warning management

ignore-value

ignore a value to quiet a compiler warning

Misc

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

Support for systems lacking ISO C 99

Core language properties

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

Variable arguments <stdarg.h>

stdarg

An <stdarg.h> that conforms to C99.

Boolean type and values <stdbool.h>

stdbool

A bool that is like C23.

Basic types <stddef.h>

stddef

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

Integer types and values <stdint.h>

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

Input/output <stdio.h>

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

Process control, Numeric conversion functions <stdlib.h>

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

Unibyte characters <ctype.h>

ctype

A <ctype.h> that conforms to C99.

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

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

String handling <string.h>

strncat

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

Extended multibyte and wide character utilities <wchar.h>

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

Wide character classification and mapping utilities <wctype.h>

wctype

wctype function: get descriptor for a wide character property.

Characteristics of floating types <float.h>

float

A correct <float.h>.

Mathematics <math.h>

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

Enhancements for ISO C 99 functions

Input/output <stdio.h>

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

Extra functions based on ISO C 99

Mathematics <math.h>

printf-frexpl

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

Numeric conversion functions <stdlib.h>

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

Extended multibyte and wide character utilities <wchar.h>

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

Support for systems lacking ISO C 11

Core language properties

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

Support for standard extensions to ISO C 11

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

Support for systems lacking draft ISO C 23

Core language properties

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

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

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

Compatibility checks for POSIX:2008 functions

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

Enhancements for POSIX:2008 functions

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

Extra functions based on POSIX:2008

Input/output

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

Numeric conversion functions

human

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

File system functions

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

File system as inode set

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

File descriptor based Input/Output

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

File stream based Input/Output

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

Users and groups

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

Security

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

Date and time

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

Networking functions

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

Multithreading

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

Signal handling

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

Terminal I/O

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

Internationalization functions

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

Unicode string functions

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

Executing programs

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

Java

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

C#

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

Misc

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

Support for building libraries and executables

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

Support for building documentation

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

Support for maintaining and releasing projects

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

Misc

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

Support for obsolete systems lacking ANSI C 89

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

Support for systems lacking ANSI C 89

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

Enhancements for ANSI C 89 functions

Diagnostics <assert.h>

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

Mathematics <math.h>

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

Input/output <stdio.h>

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

Memory management functions <stdlib.h>

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

Sorting functions <stdlib.h>

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

Date and time <time.h>

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

Extra functions based on ANSI C 89

Memory management functions <stdlib.h>

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

Integer arithmetic functions <stdlib.h>

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

Environment variables <stdlib.h>

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

Character handling <ctype.h>

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

String handling <string.h>

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

Mathematics <math.h>

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

Numeric conversion functions <stdlib.h>

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

Date and time <time.h>

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

Input/Output <stdio.h>

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

Signal handling <signal.h>

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

Wide-character string handling <wchar.h>

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

Command-line arguments

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

Container data structures

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

Cryptographic computations (low-level)

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

Cryptographic computations (high-level)

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

Compiler warning management

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

Misc

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

Support for systems lacking ISO C 99

Core language properties

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

Variable arguments <stdarg.h>

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

Boolean type and values <stdbool.h>

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

Basic types <stddef.h>

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

Integer types and values <stdint.h>

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

Input/output <stdio.h>

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

Process control, Numeric conversion functions <stdlib.h>

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

Unibyte characters <ctype.h>

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

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

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

String handling <string.h>

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

Extended multibyte and wide character utilities <wchar.h>

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

Wide character classification and mapping utilities <wctype.h>

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

Characteristics of floating types <float.h>

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

Mathematics <math.h>

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

Enhancements for ISO C 99 functions

Input/output <stdio.h>

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

Extra functions based on ISO C 99

Mathematics <math.h>

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

Numeric conversion functions <stdlib.h>

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

Extended multibyte and wide character utilities <wchar.h>

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

Support for systems lacking ISO C 11

Core language properties

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

Support for standard extensions to ISO C 11

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

Support for systems lacking draft ISO C 23

Core language properties

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

Memory management functions <stdlib.h>

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

String handling <string.h>

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

Date and time <time.h>

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

Support for GNU multiple precision arithmetic

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

Support for sharing code with the GNU C Library

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

Support for obsolete systems lacking POSIX:2008

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

Support for systems lacking POSIX:2008

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

Compatibility checks for POSIX:2008 functions

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

Enhancements for POSIX:2008 functions

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

Extra functions based on POSIX:2008

Input/output

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

Numeric conversion functions

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

File system functions

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
acl	#include "acl.h"	copy-acl.c set-acl.c	00gnulib.m4 zzgnulib.m4	error gettext-h qcopy-acl qset-acl quote
acl-permissions	#include "acl.h"	acl-internal.h acl-errno-valid.c acl_entries.c acl-internal.c get-permissions.c set-permissions.c	acl.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_ACL	extern-inline fstat stat stdbool sys_stat
areadlink	#include "areadlink.h"	areadlink.c	00gnulib.m4 zzgnulib.m4	careadlinkat readlink
areadlink-with-size	#include "areadlink.h"	areadlink-with-size.c	00gnulib.m4 zzgnulib.m4	free-posix readlink ssize_t stdint unistd
areadlinkat	#include "areadlink.h"	areadlinkat.c at-func.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([areadlinkat])	areadlink careadlinkat readlinkat at-internal errno extensions fchdir fcntl-h filename openat-die openat-h save-cwd
areadlinkat-with-size	#include "areadlink.h"	areadlinkat-with-size.c at-func.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([areadlinkat-with-size])	areadlink-with-size stdint readlinkat at-internal errno extensions fchdir fcntl-h filename free-posix openat-die openat-h save-cwd unistd
backupfile	#include "backupfile.h"	backup-internal.h backup-find.c backupfile.c	backupfile.m4 00gnulib.m4 zzgnulib.m4 gl_BACKUPFILE	argmatch attribute basename-lgpl c99 closedir d-ino fcntl-h ialloc memcmp opendirat readdir realloc-gnu renameatu stdbool stdckdint stdint xalloc-die
backup-rename	#include "backupfile.h"	backup-internal.h backup-rename.c backupfile.c	backupfile.m4 00gnulib.m4 zzgnulib.m4 gl_BACKUPFILE	argmatch attribute basename-lgpl c99 closedir d-ino fcntl-h ialloc memcmp opendirat readdir renameatu stdbool stdckdint stdint xalloc-oversized
canonicalize	#include "canonicalize.h"	canonicalize.c	canonicalize.m4 lstat.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_CANONICALIZE_FILENAME_MODE gl_MODULE_INDICATOR([canonicalize]) gl_MODULE_INDICATOR_FOR_TESTS([canonicalize]) gl_STDLIB_MODULE_INDICATOR([canonicalize_file_name])	attribute double-slash-root errno extensions fcntl-h file-set filename getcwd hash-triple-simple idx intprops memmove mempcpy nocrash rawmemchr readlink glibc-internal/scratch_buffer stat stdbool sys_stat unistd xalloc-die
canonicalize-lgpl	#include <stdlib.h>	canonicalize-lgpl.c	canonicalize.m4 double-slash-root.m4 lstat.m4 00gnulib.m4 zzgnulib.m4 gl_CANONICALIZE_LGPL gl_CONDITIONAL([GL_COND_OBJ_CANONICALIZE_LGPL], [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1]) gl_MODULE_INDICATOR([canonicalize-lgpl]) gl_STDLIB_MODULE_INDICATOR([canonicalize_file_name]) gl_STDLIB_MODULE_INDICATOR([realpath])	extensions stdlib nocrash double-slash-root [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1] eloop-threshold [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1] errno [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1] fcntl-h [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1] filename [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1] idx [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1] intprops [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1] libc-config [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1] memmove [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1] mempcpy [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1] pathmax [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1] rawmemchr [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1] readlink [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1] glibc-internal/scratch_buffer [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1] stat [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1] stdbool [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1] sys_stat [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1] unistd [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1]
clean-temp	#include "clean-temp.h"	clean-temp.c	00gnulib.m4 zzgnulib.m4	c99 stdbool clean-temp-simple list asyncsafe-spin unistd lock thread-optim error fatal-signal open pathmax tmpdir mkdtemp rmdir xalloc xalloc-die xmalloca linkedhash-list linked-list xlist gettext-h
clean-temp-simple	#include "clean-temp-simple.h"	clean-temp-private.h clean-temp-simple.c	00gnulib.m4 zzgnulib.m4 AC_DEFINE([SIGNAL_SAFE_LIST], [1], [Define if lists must be signal-safe.])	c99 stdbool list asyncsafe-spin unistd lock thread-optim error fatal-signal rmdir linkedhash-list gettext-h
concat-filename	#include "concat-filename.h"	concat-filename.c	00gnulib.m4 zzgnulib.m4	filename malloc-posix stpcpy
copy-file	#include "copy-file.h"	copy-file.c	copy-file.m4 00gnulib.m4 zzgnulib.m4 gl_COPY_FILE	acl-permissions binary-io c99 close copy-file-range error fstat full-write gettext-h ignore-value open qcopy-acl quote safe-read stat-time stdlib unistd utimens
fsusage	#include "fsusage.h"	fsusage.c	fsusage.m4 00gnulib.m4 zzgnulib.m4 gl_FSUSAGE gl_CONDITIONAL([GL_COND_OBJ_FSUSAGE], [test $gl_cv_fs_space = yes]) AM_COND_IF([GL_COND_OBJ_FSUSAGE], [ gl_PREREQ_FSUSAGE_EXTRA ])	c99 largefile stdbool stdint
dirfd	#include <dirent.h>	dirfd.c	dirfd.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_DIRFD gl_CONDITIONAL([GL_COND_OBJ_DIRFD], [test $ac_cv_func_dirfd = no && test $gl_cv_func_dirfd_macro = no \|\| test $REPLACE_DIRFD = 1]) AM_COND_IF([GL_COND_OBJ_DIRFD], [ gl_PREREQ_DIRFD ]) gl_DIRENT_MODULE_INDICATOR([dirfd])	dirent extensions errno [test $ac_cv_func_dirfd = no && test $gl_cv_func_dirfd_macro = no \|\| test $REPLACE_DIRFD = 1]
double-slash-root	---	---	double-slash-root.m4 00gnulib.m4 zzgnulib.m4 gl_DOUBLE_SLASH_ROOT	---
euidaccess	#include <unistd.h>	euidaccess.c	euidaccess.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_EUIDACCESS gl_CONDITIONAL([GL_COND_OBJ_EUIDACCESS], [test $HAVE_EUIDACCESS = 0]) AM_COND_IF([GL_COND_OBJ_EUIDACCESS], [ gl_PREREQ_EUIDACCESS ]) gl_UNISTD_MODULE_INDICATOR([euidaccess])	unistd extensions root-uid fcntl-h group-member [test $HAVE_EUIDACCESS = 0] stat [test $HAVE_EUIDACCESS = 0] sys_stat [test $HAVE_EUIDACCESS = 0]
faccessat	#include <fcntl.h> #include <unistd.h>	faccessat.c at-func.c	faccessat.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FACCESSAT gl_CONDITIONAL([GL_COND_OBJ_FACCESSAT], [test $HAVE_FACCESSAT = 0 \|\| test $REPLACE_FACCESSAT = 1]) AM_COND_IF([GL_COND_OBJ_FACCESSAT], [ gl_PREREQ_FACCESSAT ]) gl_MODULE_INDICATOR([faccessat]) gl_UNISTD_MODULE_INDICATOR([faccessat])	unistd extensions at-internal [test $HAVE_FACCESSAT = 0 \|\| test $REPLACE_FACCESSAT = 1] errno [test $HAVE_FACCESSAT = 0 \|\| test $REPLACE_FACCESSAT = 1] fchdir [test $HAVE_FACCESSAT = 0 \|\| test $REPLACE_FACCESSAT = 1] fcntl-h [test $HAVE_FACCESSAT = 0 \|\| test $REPLACE_FACCESSAT = 1] filename [test $HAVE_FACCESSAT = 0 \|\| test $REPLACE_FACCESSAT = 1] fstatat [test $HAVE_FACCESSAT = 0 \|\| test $REPLACE_FACCESSAT = 1] openat-die [test $HAVE_FACCESSAT = 0 \|\| test $REPLACE_FACCESSAT = 1] openat-h [test $HAVE_FACCESSAT = 0 \|\| test $REPLACE_FACCESSAT = 1] save-cwd [test $HAVE_FACCESSAT = 0 \|\| test $REPLACE_FACCESSAT = 1] euidaccess [test $HAVE_FACCESSAT = 0 \|\| test $REPLACE_FACCESSAT = 1]
fdopendir	#include <dirent.h>	fdopendir.c	fdopendir.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FDOPENDIR gl_CONDITIONAL([GL_COND_OBJ_FDOPENDIR], [test $HAVE_FDOPENDIR = 0 \|\| test $REPLACE_FDOPENDIR = 1]) gl_DIRENT_MODULE_INDICATOR([fdopendir]) gl_MODULE_INDICATOR([fdopendir])	dirent extensions at-internal [test $HAVE_FDOPENDIR = 0] dirfd [test $HAVE_FDOPENDIR = 0] dup [test $HAVE_FDOPENDIR = 0] errno [test $HAVE_FDOPENDIR = 0] fchdir [test $HAVE_FDOPENDIR = 0] fstat [test $HAVE_FDOPENDIR = 0] openat-die [test $HAVE_FDOPENDIR = 0] opendir [test $HAVE_FDOPENDIR = 0] save-cwd [test $HAVE_FDOPENDIR = 0]
fdutimensat	#include <fcntl.h> #include "utimens.h"	fdutimensat.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([fdutimensat])	extern-inline futimens utimensat
file-type	#include "file-type.h"	file-type.c	00gnulib.m4 zzgnulib.m4	gettext-h sys_stat
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
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.c fts-cycle.c	fts.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])	alignasof attribute c99 closedir cycle-check d-ino d-type fchdir fcntl fcntl-h flexmember fstat hash i-ring lstat memmove open openat-h opendir opendirat readdir stdbool stddef stdint
isdir	---	isdir.c isdir.h	00gnulib.m4 zzgnulib.m4	stat
largefile	---	---	largefile.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_LARGEFILE])	---
largefile-required	---	---	largefile.m4 00gnulib.m4 zzgnulib.m4	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 [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 unistd [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 readlink [test $HAVE_LCHOWN = 0] chown [test $HAVE_LCHOWN = 0 \|\| test $REPLACE_LCHOWN = 1] errno [test $HAVE_LCHOWN = 0 \|\| test $REPLACE_LCHOWN = 1] stdbool [test $HAVE_LCHOWN = 0 \|\| test $REPLACE_LCHOWN = 1] sys_stat [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
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 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 [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 lchmod lchown mkancesdirs mkdir quote savewd stat stat-macros stdbool sys_stat
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 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 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 extensions largefile tempname [test $HAVE_MKSTEMPS = 0]
modechange	#include "modechange.h"	modechange.c	modechange.m4 00gnulib.m4 zzgnulib.m4 gl_MODECHANGE	stat stat-macros stdbool sys_stat xalloc
mountlist	#include "mountlist.h"	mountlist.c	fstypename.m4 mountlist.m4 00gnulib.m4 zzgnulib.m4 gl_MOUNTLIST gl_CONDITIONAL([GL_COND_OBJ_MOUNTLIST], [test $gl_cv_list_mounted_fs = yes]) AM_COND_IF([GL_COND_OBJ_MOUNTLIST], [ gl_PREREQ_MOUNTLIST_EXTRA ])	fopen-gnu free-posix getline open unlocked-io-internal stdbool stdint 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] stdbool [test $HAVE_OPENAT = 0 \|\| test $REPLACE_OPENAT = 1] sys_stat [test $HAVE_OPENAT = 0 \|\| test $REPLACE_OPENAT = 1] cloexec [test $REPLACE_OPENAT = 1] fstat [test $REPLACE_OPENAT = 1] at-internal [test $HAVE_OPENAT = 0] errno [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 snippet/_Noreturn
pathmax	#include "pathmax.h"	---	pathmax.m4 00gnulib.m4 zzgnulib.m4 gl_PATHMAX	unistd
qacl	---	---	00gnulib.m4 zzgnulib.m4	qcopy-acl qset-acl
qcopy-acl	#include "acl.h"	qcopy-acl.c	xattr.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_XATTR AC_REQUIRE([gl_FUNC_ACL]) if test "$use_xattr" = yes; then QCOPY_ACL_LIB="$LIB_XATTR" else QCOPY_ACL_LIB="$LIB_ACL" fi AC_SUBST([QCOPY_ACL_LIB])	acl-permissions [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 sys_stat
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 extensions at-internal [test $HAVE_READLINKAT = 0 \|\| test $REPLACE_READLINKAT = 1] errno [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 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] stdbool [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 stdbool memcmp
save-cwd	#include "save-cwd.h"	save-cwd.c	save-cwd.m4 00gnulib.m4 zzgnulib.m4 gl_SAVE_CWD	chdir-long fchdir fd-safer-flag getcwd-lgpl open stdbool unistd-safer
savedir	#include "savedir.h"	savedir.c	savedir.m4 00gnulib.m4 zzgnulib.m4 gl_SAVEDIR	closedir dirent-safer fdopendir free-posix opendir readdir stpcpy xalloc
savewd	#include "savewd.h"	savewd.c	savewd.m4 00gnulib.m4 zzgnulib.m4 gl_SAVEWD	assure attribute chdir errno extern-inline fchdir fcntl-safer fcntl-h filename raise stdbool stdlib sys_wait unistd 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 extensions extern-inline stdckdint
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 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 extensions fcntl-h [test $HAVE_SYMLINKAT = 0 \|\| test $REPLACE_SYMLINKAT = 1] at-internal [test $HAVE_SYMLINKAT = 0] errno [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>	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	#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
tmpdir	#include "tmpdir.h"	tmpdir.c	tmpdir.m4 00gnulib.m4 zzgnulib.m4 gt_TMPDIR	secure_getenv stat stdbool sys_stat pathmax
unlinkdir	#include "unlinkdir.h"	unlinkdir.c	unlinkdir.m4 00gnulib.m4 zzgnulib.m4 gl_UNLINKDIR	stdbool 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 stdbool stdint assert-h
utimens	#include "utimens.h"	utimens.c	utimens.m4 utimes.m4 00gnulib.m4 zzgnulib.m4 gl_UTIMENS	errno extern-inline fcntl-h fstat lstat gettime msvc-nothrow stat stat-time stdbool sys_stat sys_time 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	stdbool 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 stdbool stdint
dev-ino	#include "dev-ino.h"	---	00gnulib.m4 zzgnulib.m4	---
file-set	#include "file-set.h"	file-set.c	00gnulib.m4 zzgnulib.m4	hash hash-triple-simple stdbool xalloc xalloc-die
hash-triple	#include "hash-triple.h"	hash-triple.c	00gnulib.m4 zzgnulib.m4	hash-triple-simple same same-inode
i-ring	#include "i-ring.h"	i-ring.c	i-ring.m4 00gnulib.m4 zzgnulib.m4 gl_I_RING	assert-h stdbool
same-inode	#include "same-inode.h"	---	00gnulib.m4 zzgnulib.m4	sys_types

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
dup3	#include <unistd.h>	dup3.c	dup3.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_DUP3 gl_UNISTD_MODULE_INDICATOR([dup3])	unistd 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	safe-read
full-write	#include "full-write.h"	full-write.c	00gnulib.m4 zzgnulib.m4	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 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 ])	stdbool [test $HAVE_ISAPIPE = 0] sys_stat [test $HAVE_ISAPIPE = 0] unistd [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
pipe2	#include <unistd.h>	pipe2.c	pipe2.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_PIPE2 gl_UNISTD_MODULE_INDICATOR([pipe2])	unistd 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	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	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 stdbool
closein	#include "closein.h"	closein.c	00gnulib.m4 zzgnulib.m4	closeout freadahead fflush stdbool unistd
closeout	#include "closeout.h"	closeout.c	00gnulib.m4 zzgnulib.m4	close-stream gettext-h error quotearg exitfail stdbool unistd
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] stdbool [test $REPLACE_FOPEN_FOR_FOPEN_GNU = 1] unistd [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
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])	stdbool
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	stdbool
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 stdbool
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])	stdbool
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])	stdbool
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 extensions fopen-gnu fseeko getline stdbool 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 stdbool sys_stat 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 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 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
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 extensions getgroups [test $HAVE_GROUP_MEMBER = 0] realloc-gnu [test $HAVE_GROUP_MEMBER = 0] stdckdint [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 intprops inttostr stdbool

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 extensions c99 [test $HAVE_GETUMASK = 0] unistd [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 extensions
idpriv-droptemp	#include "idpriv.h"	idpriv-droptemp.c	idpriv.m4 00gnulib.m4 zzgnulib.m4 gl_IDPRIV	unistd extensions
priv-set	#include "priv-set.h"	priv-set.c	priv-set.m4 00gnulib.m4 zzgnulib.m4 gl_PRIV_SET	errno extern-inline stdbool

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
gettime	#include "timespec.h"	gettime.c	gettime.m4 00gnulib.m4 zzgnulib.m4 gl_GETTIME	clock-time gettimeofday sys_time 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 stdbool stdckdint time verify
settime	#include "timespec.h"	settime.c	settime.m4 00gnulib.m4 zzgnulib.m4 gl_SETTIME	clock-time errno extensions sys_time 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 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

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 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 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 AC_REQUIRE([AC_C_INLINE]) AC_CHECK_HEADERS_ONCE([pthread.h])	signal-h stdbool sigprocmask windows-spin sparcv8+
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 windows-mutex [test $gl_threads_api = windows] windows-rwlock [test $gl_threads_api = windows] windows-recmutex [test $gl_threads_api = windows] windows-once [test $gl_threads_api = windows]
simple-atomic	#include "simple-atomic.h"	simple-atomic.c	00gnulib.m4 zzgnulib.m4 AC_CHECK_HEADERS_ONCE([pthread.h])	stdint 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 extern-inline lock 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 extern-inline stdbool 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 exitfail getprogname gettext-h idx ignore-value inttypes mempcpy raise sigsegv stddef unistd
libsigsegv	#if HAVE_LIBSIGSEGV # include <sigsegv.h> #endif	---	libsigsegv.m4 00gnulib.m4 zzgnulib.m4 gl_LIBSIGSEGV	havelib
sig2str	#include "sig2str.h"	sig2str.c	sig2str.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_SIG2STR gl_CONDITIONAL([GL_COND_OBJ_SIG2STR], [test $ac_cv_func_sig2str = no]) AM_COND_IF([GL_COND_OBJ_SIG2STR], [ gl_PREREQ_SIG2STR ])	intprops
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 unistd
sigpipe-die	#include "sigpipe-die.h"	sigpipe-die.c	00gnulib.m4 zzgnulib.m4	error gettext-h 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 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 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.20])	extensions gettext-h havelib
gettext-h	#include "gettext.h"	---	00gnulib.m4 zzgnulib.m4 AC_SUBST([LIBINTL]) AC_SUBST([LTLIBINTL])	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.\"'])])	stdbool trim mbsstr mbchar mbuiter iconv localcharset c-strcase xstriconv xalloc 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-strcase
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	stdbool iconv iconv_open unistr/u8-prev unistr/u8-mbtouc-unsafe unistr/u8-mbtouc unistr/u8-mbtoucr unistr/u8-uctomb free-posix strdup c-strcase 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	stdbool striconveh malloca strdup c-strcase
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])	stdbool setlocale-null
localename	#include "localename.h"	localename.c localename-table.h localename-table.c	localename.m4 intl-thread-locale.m4 intlmacosx.m4 lcmessage.m4 00gnulib.m4 zzgnulib.m4 gl_LOCALENAME gl_LOCALE_MODULE_INDICATOR([localename])	extensions stdbool locale flexmember free-posix strdup lock langinfo setlocale-null thread-optim
mbmemcasecmp	#include "mbmemcasecmp.h"	mbmemcasecmp.c	00gnulib.m4 zzgnulib.m4	mbiter
mbmemcasecoll	#include "mbmemcasecoll.h"	mbmemcasecoll.c	00gnulib.m4 zzgnulib.m4	stdbool malloca mbrtowc wcrtomb memcmp2 memcoll wchar
mbslen	#include <string.h>	mbslen.c	mbslen.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_MBSLEN gl_STRING_MODULE_INDICATOR([mbslen])	mbuiter string
mbsnlen	#include <string.h>	mbsnlen.c	00gnulib.m4 zzgnulib.m4 gl_STRING_MODULE_INDICATOR([mbsnlen])	mbiter string
mbschr	#include <string.h>	mbschr.c	00gnulib.m4 zzgnulib.m4 gl_STRING_MODULE_INDICATOR([mbschr])	mbuiter string
mbsrchr	#include <string.h>	mbsrchr.c	00gnulib.m4 zzgnulib.m4 gl_STRING_MODULE_INDICATOR([mbsrchr])	mbuiter string
mbsstr	#include <string.h>	mbsstr.c str-kmp.h	00gnulib.m4 zzgnulib.m4 gl_STRING_MODULE_INDICATOR([mbsstr])	mbuiter stdbool string mbslen malloca strnlen
mbscasecmp	#include <string.h>	mbscasecmp.c	00gnulib.m4 zzgnulib.m4 gl_STRING_MODULE_INDICATOR([mbscasecmp])	mbuiter string
mbsncasecmp	#include <string.h>	mbsncasecmp.c	00gnulib.m4 zzgnulib.m4 gl_STRING_MODULE_INDICATOR([mbsncasecmp])	mbuiter string
mbspcasecmp	#include <string.h>	mbspcasecmp.c	00gnulib.m4 zzgnulib.m4 gl_STRING_MODULE_INDICATOR([mbspcasecmp])	mbuiter string
mbscasestr	#include <string.h>	mbscasestr.c str-kmp.h	00gnulib.m4 zzgnulib.m4 gl_STRING_MODULE_INDICATOR([mbscasestr])	mbuiter stdbool string mbslen malloca strnlen
mbscspn	#include <string.h>	mbscspn.c	00gnulib.m4 zzgnulib.m4 gl_STRING_MODULE_INDICATOR([mbscspn])	mbuiter string mbschr strcspn
mbspbrk	#include <string.h>	mbspbrk.c	00gnulib.m4 zzgnulib.m4 gl_STRING_MODULE_INDICATOR([mbspbrk])	mbuiter string mbschr strpbrk
mbsspn	#include <string.h>	mbsspn.c	00gnulib.m4 zzgnulib.m4 gl_STRING_MODULE_INDICATOR([mbsspn])	mbuiter string mbschr
mbssep	#include <string.h>	mbssep.c	00gnulib.m4 zzgnulib.m4 gl_STRING_MODULE_INDICATOR([mbssep])	mbuiter string mbspbrk strsep
mbstok_r	#include <string.h>	mbstok_r.c	00gnulib.m4 zzgnulib.m4 gl_STRING_MODULE_INDICATOR([mbstok_r])	mbuiter string mbsspn mbspbrk strtok_r
mbswidth	#include "mbswidth.h"	mbswidth.c	mbstate_t.m4 mbrtowc.m4 mbswidth.m4 00gnulib.m4 zzgnulib.m4 gl_MBSWIDTH	wchar wctype-h mbrtowc mbsinit wcwidth 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 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 localcharset error stdio
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 extensions stdbool [test $HAVE_RPMATCH = 0] gettext-h [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 stdbool
bison-i18n	---	---	bison-i18n.m4 00gnulib.m4 zzgnulib.m4 BISON_I18N	gettext

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"	unitypes.in.h	libunistring-base.m4 00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_LIBHEADER([0.9.11], [unitypes.h]) AC_PROG_MKDIR_P AH_VERBATIM([unitypes_restrict], [ /* This definition is a duplicate of the one in unitypes.h. It is here so that we can cope with an older version of unitypes.h that does not contain this definition and that is pre-installed among the public header files. */ # if defined __restrict \ \|\| 2 < __GNUC__ + (95 <= __GNUC_MINOR__) \ \|\| __clang_major__ >= 3 # define _UC_RESTRICT __restrict # elif 199901L <= __STDC_VERSION__ \|\| defined restrict # define _UC_RESTRICT restrict # else # define _UC_RESTRICT # endif ])	gen-header stdint
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([0.9.11], [unistr.h]) AC_PROG_MKDIR_P	gen-header unitypes stdbool 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([0.9.4], [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([0.9.4], [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 stdbool
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 stdbool
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 stdbool unitypes
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
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 limits-h unitypes wchar
unistdio/ulc-asnprintf	#include "unistdio.h"	unistdio/ulc-asnprintf.c unistdio/u-asnprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.2], [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([1.2], [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([1.2], [unistdio/ulc-fprintf])	unistdio/base unistdio/ulc-vasnprintf fseterr errno
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 xsize c-ctype
unistdio/ulc-snprintf	#include "unistdio.h"	unistdio/ulc-snprintf.c unistdio/u-snprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.2], [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([1.2], [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 wchar_t.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([1.2], [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 mbsnlen isnand-nolibm isnanl-nolibm frexpl-nolibm printf-frexp printf-frexpl signbit fpucw nocrash printf-safe alloca-opt localcharset xsize errno free-posix memchr multiarch assert-h
unistdio/ulc-vasprintf	#include "unistdio.h"	unistdio/ulc-vasprintf.c unistdio/u-vasprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.2], [unistdio/ulc-vasprintf])	unistdio/base unistdio/ulc-vasnprintf errno
unistdio/ulc-vfprintf	#include "unistdio.h"	unistdio/ulc-vfprintf.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.2], [unistdio/ulc-vfprintf])	unistdio/base unistdio/ulc-vasnprintf fseterr errno
unistdio/ulc-vsnprintf	#include "unistdio.h"	unistdio/ulc-vsnprintf.c unistdio/u-vsnprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.2], [unistdio/ulc-vsnprintf])	unistdio/base unistdio/ulc-vasnprintf errno
unistdio/ulc-vsprintf	#include "unistdio.h"	unistdio/ulc-vsprintf.c unistdio/u-vsprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.2], [unistdio/ulc-vsprintf])	unistdio/base unistdio/ulc-vasnprintf stdint errno
unistdio/u8-asnprintf	#include "unistdio.h"	unistdio/u8-asnprintf.c unistdio/u-asnprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([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([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 xsize
unistdio/u8-snprintf	#include "unistdio.h"	unistdio/u8-snprintf.c unistdio/u-snprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([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([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 wchar_t.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([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 isnand-nolibm isnanl-nolibm frexpl-nolibm printf-frexp printf-frexpl signbit fpucw nocrash printf-safe alloca-opt localcharset xsize errno free-posix memchr multiarch assert-h
unistdio/u8-vasprintf	#include "unistdio.h"	unistdio/u8-vasprintf.c unistdio/u-vasprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.2], [unistdio/u8-vasprintf])	unistdio/base unistdio/u8-vasnprintf errno
unistdio/u8-vsnprintf	#include "unistdio.h"	unistdio/u8-vsnprintf.c unistdio/u-vsnprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.2], [unistdio/u8-vsnprintf])	unistdio/base unistdio/u8-vasnprintf unistr/u8-cpy errno
unistdio/u8-vsprintf	#include "unistdio.h"	unistdio/u8-vsprintf.c unistdio/u-vsprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.2], [unistdio/u8-vsprintf])	unistdio/base unistdio/u8-vasnprintf stdint errno
unistdio/u8-u8-asnprintf	#include "unistdio.h"	unistdio/u8-u8-asnprintf.c unistdio/u-asnprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([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([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([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([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 wchar_t.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([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 isnand-nolibm isnanl-nolibm frexpl-nolibm printf-frexp printf-frexpl signbit fpucw nocrash printf-safe alloca-opt localcharset xsize errno free-posix memchr multiarch assert-h
unistdio/u8-u8-vasprintf	#include "unistdio.h"	unistdio/u8-u8-vasprintf.c unistdio/u-vasprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.2], [unistdio/u8-u8-vasprintf])	unistdio/base unistdio/u8-u8-vasnprintf errno
unistdio/u8-u8-vsnprintf	#include "unistdio.h"	unistdio/u8-u8-vsnprintf.c unistdio/u-vsnprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.2], [unistdio/u8-u8-vsnprintf])	unistdio/base unistdio/u8-u8-vasnprintf unistr/u8-cpy errno
unistdio/u8-u8-vsprintf	#include "unistdio.h"	unistdio/u8-u8-vsprintf.c unistdio/u-vsprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.2], [unistdio/u8-u8-vsprintf])	unistdio/base unistdio/u8-u8-vasnprintf stdint errno
unistdio/u16-asnprintf	#include "unistdio.h"	unistdio/u16-asnprintf.c unistdio/u-asnprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([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([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 xsize
unistdio/u16-snprintf	#include "unistdio.h"	unistdio/u16-snprintf.c unistdio/u-snprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([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([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 wchar_t.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([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 isnand-nolibm isnanl-nolibm frexpl-nolibm printf-frexp printf-frexpl signbit fpucw nocrash printf-safe alloca-opt localcharset xsize errno free-posix memchr multiarch assert-h
unistdio/u16-vasprintf	#include "unistdio.h"	unistdio/u16-vasprintf.c unistdio/u-vasprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.2], [unistdio/u16-vasprintf])	unistdio/base unistdio/u16-vasnprintf errno
unistdio/u16-vsnprintf	#include "unistdio.h"	unistdio/u16-vsnprintf.c unistdio/u-vsnprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.2], [unistdio/u16-vsnprintf])	unistdio/base unistdio/u16-vasnprintf unistr/u16-cpy errno
unistdio/u16-vsprintf	#include "unistdio.h"	unistdio/u16-vsprintf.c unistdio/u-vsprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.2], [unistdio/u16-vsprintf])	unistdio/base unistdio/u16-vasnprintf stdint errno
unistdio/u16-u16-asnprintf	#include "unistdio.h"	unistdio/u16-u16-asnprintf.c unistdio/u-asnprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([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([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([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([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 wchar_t.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([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 isnand-nolibm isnanl-nolibm frexpl-nolibm printf-frexp printf-frexpl signbit fpucw nocrash printf-safe alloca-opt localcharset xsize errno free-posix memchr multiarch assert-h
unistdio/u16-u16-vasprintf	#include "unistdio.h"	unistdio/u16-u16-vasprintf.c unistdio/u-vasprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.2], [unistdio/u16-u16-vasprintf])	unistdio/base unistdio/u16-u16-vasnprintf errno
unistdio/u16-u16-vsnprintf	#include "unistdio.h"	unistdio/u16-u16-vsnprintf.c unistdio/u-vsnprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.2], [unistdio/u16-u16-vsnprintf])	unistdio/base unistdio/u16-u16-vasnprintf unistr/u16-cpy errno
unistdio/u16-u16-vsprintf	#include "unistdio.h"	unistdio/u16-u16-vsprintf.c unistdio/u-vsprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.2], [unistdio/u16-u16-vsprintf])	unistdio/base unistdio/u16-u16-vasnprintf stdint errno
unistdio/u32-asnprintf	#include "unistdio.h"	unistdio/u32-asnprintf.c unistdio/u-asnprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([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([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 xsize
unistdio/u32-snprintf	#include "unistdio.h"	unistdio/u32-snprintf.c unistdio/u-snprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([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([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 wchar_t.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([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 isnand-nolibm isnanl-nolibm frexpl-nolibm printf-frexp printf-frexpl signbit fpucw nocrash printf-safe alloca-opt localcharset xsize errno free-posix memchr multiarch assert-h
unistdio/u32-vasprintf	#include "unistdio.h"	unistdio/u32-vasprintf.c unistdio/u-vasprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.2], [unistdio/u32-vasprintf])	unistdio/base unistdio/u32-vasnprintf errno
unistdio/u32-vsnprintf	#include "unistdio.h"	unistdio/u32-vsnprintf.c unistdio/u-vsnprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.2], [unistdio/u32-vsnprintf])	unistdio/base unistdio/u32-vasnprintf unistr/u32-cpy errno
unistdio/u32-vsprintf	#include "unistdio.h"	unistdio/u32-vsprintf.c unistdio/u-vsprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.2], [unistdio/u32-vsprintf])	unistdio/base unistdio/u32-vasnprintf stdint errno
unistdio/u32-u32-asnprintf	#include "unistdio.h"	unistdio/u32-u32-asnprintf.c unistdio/u-asnprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([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([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([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([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 wchar_t.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([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 isnand-nolibm isnanl-nolibm frexpl-nolibm printf-frexp printf-frexpl signbit fpucw nocrash printf-safe alloca-opt localcharset xsize errno free-posix memchr multiarch assert-h
unistdio/u32-u32-vasprintf	#include "unistdio.h"	unistdio/u32-u32-vasprintf.c unistdio/u-vasprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.2], [unistdio/u32-u32-vasprintf])	unistdio/base unistdio/u32-u32-vasnprintf errno
unistdio/u32-u32-vsnprintf	#include "unistdio.h"	unistdio/u32-u32-vsnprintf.c unistdio/u-vsnprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.2], [unistdio/u32-u32-vsnprintf])	unistdio/base unistdio/u32-u32-vasnprintf unistr/u32-cpy errno
unistdio/u32-u32-vsprintf	#include "unistdio.h"	unistdio/u32-u32-vsprintf.c unistdio/u-vsprintf.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.2], [unistdio/u32-u32-vsprintf])	unistdio/base unistdio/u32-u32-vasnprintf stdint errno
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
uniname/uniname	#include "uniname.h"	uniname/gen-uninames.lisp uniname/uninames.h uniname/uniname.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.1], [uniname/uniname])	uniname/base attribute memcmp stdbool c99
unictype/base	#include "unictype.h"	unictype.in.h	libunistring-base.m4 00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_LIBHEADER([0.9.11], [unictype.h]) AC_PROG_MKDIR_P	gen-header unitypes stdbool
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.1], [unictype/bidiclass-of])	unictype/base
unictype/bidiclass-test	#include "unictype.h"	unictype/bidi_test.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.1], [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.1], [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_LIBUNISTRING_MODULE([1.1], [unictype/category-C])	unictype/base
unictype/category-Cc	#include "unictype.h"	unictype/categ_Cc.c unictype/categ_Cc.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([1.1], [unictype/category-Cn])	unictype/base
unictype/category-Co	#include "unictype.h"	unictype/categ_Co.c unictype/categ_Co.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([1.1], [unictype/category-L])	unictype/base
unictype/category-Ll	#include "unictype.h"	unictype/categ_Ll.c unictype/categ_Ll.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.1], [unictype/category-Ll])	unictype/base
unictype/category-Lm	#include "unictype.h"	unictype/categ_Lm.c unictype/categ_Lm.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.1], [unictype/category-Lm])	unictype/base
unictype/category-Lo	#include "unictype.h"	unictype/categ_Lo.c unictype/categ_Lo.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.1], [unictype/category-Lo])	unictype/base
unictype/category-Lt	#include "unictype.h"	unictype/categ_Lt.c unictype/categ_Lt.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([0.9.11], [unictype/category-Lu])	unictype/base
unictype/category-M	#include "unictype.h"	unictype/categ_M.c unictype/categ_M.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.1], [unictype/category-M])	unictype/base
unictype/category-Mc	#include "unictype.h"	unictype/categ_Mc.c unictype/categ_Mc.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.1], [unictype/category-Mc])	unictype/base
unictype/category-Me	#include "unictype.h"	unictype/categ_Me.c unictype/categ_Me.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([1.1], [unictype/category-Mn])	unictype/base
unictype/category-N	#include "unictype.h"	unictype/categ_N.c unictype/categ_N.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.1], [unictype/category-N])	unictype/base
unictype/category-Nd	#include "unictype.h"	unictype/categ_Nd.c unictype/categ_Nd.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.1], [unictype/category-Nd])	unictype/base
unictype/category-Nl	#include "unictype.h"	unictype/categ_Nl.c unictype/categ_Nl.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([1.1], [unictype/category-P])	unictype/base
unictype/category-Pc	#include "unictype.h"	unictype/categ_Pc.c unictype/categ_Pc.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([0.9.11], [unictype/category-Pd])	unictype/base
unictype/category-Pe	#include "unictype.h"	unictype/categ_Pe.c unictype/categ_Pe.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([1.1], [unictype/category-Po])	unictype/base
unictype/category-Ps	#include "unictype.h"	unictype/categ_Ps.c unictype/categ_Ps.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([1.1], [unictype/category-S])	unictype/base
unictype/category-Sc	#include "unictype.h"	unictype/categ_Sc.c unictype/categ_Sc.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([0.9.8], [unictype/category-Sm])	unictype/base
unictype/category-So	#include "unictype.h"	unictype/categ_So.c unictype/categ_So.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.1], [unictype/category-So])	unictype/base
unictype/category-Z	#include "unictype.h"	unictype/categ_Z.c unictype/categ_Z.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([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.1], [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.1], [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.1], [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 gl_LIBUNISTRING_MODULE([0.9.8], [unictype/category-none])	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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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([0.9.11], [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.1], [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.1], [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([0.9.11], [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.1], [unictype/decimal-digit])	unictype/base
unictype/digit	#include "unictype.h"	unictype/digit.c unictype/digit.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.1], [unictype/digit])	unictype/base
unictype/mirror	#include "unictype.h"	unictype/mirror.c unictype/mirror.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9.11], [unictype/mirror])	unictype/base
unictype/numeric	#include "unictype.h"	unictype/numeric.c unictype/numeric.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([1.1], [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.1], [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-continue unictype/property-id-start unictype/property-ideographic unictype/property-ids-binary-operator unictype/property-ids-trinary-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-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-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_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([0.9.11], [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_LIBUNISTRING_MODULE([0.9.11], [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_LIBUNISTRING_MODULE([0.9.11], [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_LIBUNISTRING_MODULE([0.9.11], [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_LIBUNISTRING_MODULE([0.9.11], [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_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([0.9.11], [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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([0.9.11], [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_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([0.9.11], [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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([0.9.8], [unictype/property-hyphen])	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_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([0.9.8], [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_LIBUNISTRING_MODULE([0.9.8], [unictype/property-ids-trinary-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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([0.9.8], [unictype/property-math])	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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([0.9.11], [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_LIBUNISTRING_MODULE([0.9.8], [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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([0.9.8], [unictype/property-pattern-white-space])	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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([0.9.11], [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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([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-continue unictype/property-id-start unictype/property-ideographic unictype/property-ids-binary-operator unictype/property-ids-trinary-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-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-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.1], [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.1], [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
uniwidth/u8-strwidth	#include "uniwidth.h"	uniwidth/u8-strwidth.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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
uniwbrk/ulc-wordbreaks	#include "uniwbrk.h"	uniwbrk/ulc-wordbreaks.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.1], [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.1], [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.1], [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.1], [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.1], [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 localcharset
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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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 00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_LIBHEADER([0.9.11], [uninorm.h]) AC_PROG_MKDIR_P	gen-header unitypes
uninorm/canonical-decomposition	#include "uninorm.h"	uninorm/canonical-decomposition.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.1], [uninorm/canonical-decomposition])	uninorm/base uninorm/decomposition-table
uninorm/composition	#include "uninorm.h"	uninorm/composition.c uninorm/composition-table.gperf	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([0.9.11], [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.1], [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.1], [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_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([1.1], [uninorm/nfd])	uninorm/base uninorm/canonical-decomposition
uninorm/nfkc	#include "uninorm.h"	uninorm/nfkc.c uninorm/normalize-internal.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([1.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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 00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_LIBHEADER([0.9.11], [unicase.h]) AC_PROG_MKDIR_P	gen-header unitypes uninorm/base stdbool
unicase/empty-prefix-context	#include "unicase.h"	unicase/empty-prefix-context.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([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([0.9.11], [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([0.9.11], [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([0.9.11], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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 stdbool
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.1], [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 stdbool
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.1], [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 stdbool
unicase/u8-ct-toupper	#include "unicase.h"	unicase/u8-ct-toupper.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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.1], [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 stdbool
findprog	#include "findprog.h"	findprog.c	findprog.m4 eaccess.m4 00gnulib.m4 zzgnulib.m4 gl_FINDPROG	stdbool sys_stat xalloc xconcat-filename access stat unistd
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])	stdbool sys_stat strdup concat-filename access stat unistd
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 stdbool stdlib sys_wait unistd 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 spawn 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 stdbool stdlib sys_wait unistd 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 msvc-nothrow open pipe2 pipe2-safer spawn 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 stdbool stdlib unistd 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 stdbool stdint stdlib sys_select unistd 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 stdbool stdint stdlib sys_select unistd
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	stdbool 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	stdbool unistd 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 c-strstr gettext-h 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	stdbool execute classpath xsetenv sh-quote xconcat-filename xalloc xmalloca error gettext-h javaexec-script sh-filename
javaversion	#include "javaversion.h"	javaversion.c javaversion.java javaversion.class	00gnulib.m4 zzgnulib.m4	javaexec stdbool spawn-pipe wait-process getline gettext-h 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	stdbool xmalloca execute spawn-pipe wait-process getline sh-quote safe-read error gettext-h 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	stdbool execute xsetenv sh-quote xalloc xmalloca error gettext-h 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 malloc-gnu mempcpy strndup strcase extensions vsnprintf sleep stdbool stdio 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"] 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
byteswap	#include <byteswap.h>	byteswap.in.h	byteswap.m4 00gnulib.m4 zzgnulib.m4 gl_BYTESWAP gl_CONDITIONAL_HEADER([byteswap.h]) AC_PROG_MKDIR_P	gen-header
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 c99 ctype flexmember idx locale regex stdbool stddef stdint stdio stdlib string verify wchar wctype-h xalloc xalloc-die
exitfail	#include "exitfail.h"	exitfail.c	00gnulib.m4 zzgnulib.m4	stdlib
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 $GL_GENERATE_ERROR_H = true]) 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 stdio getprogname strerror [test $GL_GENERATE_ERROR_H = true] unistd [test $GL_GENERATE_ERROR_H = true] msvc-nothrow [test $GL_GENERATE_ERROR_H = true]
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 unistd 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 extensions netdb [test $HAVE_DECL_GETDOMAINNAME = 0 \|\| test $REPLACE_GETDOMAINNAME = 1] sys_socket [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
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) false;; ) test $HAVE_GETLOADAVG = 0 \|\| test $REPLACE_GETLOADAVG = 1;; esac] stdbool [test $HAVE_GETLOADAVG = 0 \|\| test $REPLACE_GETLOADAVG = 1] stdlib [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 $REPLACE_GETPAGESIZE = 1]) gl_UNISTD_MODULE_INDICATOR([getpagesize])	unistd
getprogname	#include <stdlib.h>	getprogname.h getprogname.c	getprogname.m4 00gnulib.m4 zzgnulib.m4 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 basename-lgpl [test $HAVE_GETPROGNAME = 0] extensions [test $HAVE_GETPROGNAME = 0] open [test $HAVE_GETPROGNAME = 0]
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 fcntl-h [test $HAVE_GETRANDOM = 0 \|\| test $REPLACE_GETRANDOM = 1] minmax [test $HAVE_GETRANDOM = 0 \|\| test $REPLACE_GETRANDOM = 1] stdbool [test $HAVE_GETRANDOM = 0 \|\| test $REPLACE_GETRANDOM = 1] open [case $host_os in mingw) 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]) gl_UNISTD_MODULE_INDICATOR([getusershell])	unistd extensions fopen-safer [test $HAVE_GETUSERSHELL = 0] unlocked-io-internal [test $HAVE_GETUSERSHELL = 0] xalloc [test $HAVE_GETUSERSHELL = 0]
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 sys_ioctl 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
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 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
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 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>	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
quotearg	#include "quotearg.h"	quotearg.c quote.h	mbstate_t.m4 mbrtowc.m4 quotearg.m4 00gnulib.m4 zzgnulib.m4 gl_QUOTEARG	attribute c-strcaseeq extensions gettext-h mbrtowc mbsinit memcmp minmax quotearg-simple localcharset stdbool stdint wchar wctype-h xalloc
quote	#include "quote.h"	---	quote.m4 00gnulib.m4 zzgnulib.m4 gl_QUOTE	quotearg
readutmp	#include "readutmp.h"	readutmp.c	readutmp.m4 00gnulib.m4 zzgnulib.m4 gl_READUTMP gl_CONDITIONAL([GL_COND_OBJ_READUTMP], [test $ac_cv_header_utmp_h = yes \|\| test $ac_cv_header_utmpx_h = yes])	extensions xalloc stdbool stdint fopen-gnu unlocked-io-internal
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 stdint
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 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 extensions fchdir fcntl-h filename openat-die openat-h save-cwd unistd
sysexits	#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
sys_random	#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
u64	#include "u64.h"	u64.c	00gnulib.m4 zzgnulib.m4	extern-inline stdint
verror	#include "verror.h"	verror.c	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])])	stdio error xvasprintf

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 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 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 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 stdbool unistd 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 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 eealloc.m4 environ.m4 free.m4 malloc.m4 mempcpy.m4 rawmemchr.m4 readlink.m4 realloc.m4 relocatable-lib.m4 setenv.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_RESTRICT]) gl_FUNC_READLINK_SEPARATE gl_CANONICALIZE_LGPL_SEPARATE 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 extern-inline fcntl-h filename idx intprops largefile libc-config pathmax ssize_t stdbool stddef stdckdint stdint stdlib string sys_stat unistd 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	---
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
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 fcntl
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 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	---
array-map	#include "gl_array_map.h"	gl_array_map.c	00gnulib.m4 zzgnulib.m4	map stdint 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 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 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-internal	#include "openat-priv.h"	openat-proc.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_CANONICAL_HOST])	errno fcntl-h intprops open [case $host_os in mingw) false;; ) :;; esac] sys_stat unistd
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 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 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
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 integer_length_l obstack stdbool xalloc
bitsetv	#include "bitsetv.h"	bitsetv.c	00gnulib.m4 zzgnulib.m4	bitset c99 xalloc
btoc32	#include <uchar.h>	btoc32.c	00gnulib.m4 zzgnulib.m4 gl_UCHAR_MODULE_INDICATOR([btoc32])	uchar mbrtoc32 btowc
c-snprintf	#include "c-snprintf.h"	c-snprintf.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_RESTRICT])	stdio c-vasnprintf
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	wchar_t.m4 wint_t.m4 intmax_t.m4 stdint_h.m4 inttypes_h.m4 vasnprintf.m4 printf.m4 math_h.m4 exponentd.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_RESTRICT]) gl_PREREQ_VASNPRINTF_WITH_POSIX_EXTRAS	assert-h attribute limits-h stdint stdio isnand-nolibm isnanl-nolibm frexpl-nolibm printf-frexp printf-frexpl signbit fpucw free-posix nocrash printf-safe alloca-opt xsize errno memchr multiarch
c-vasprintf	#include "c-vasprintf.h"	c-asprintf.c c-vasprintf.c	00gnulib.m4 zzgnulib.m4	stdio c-vasnprintf
c-vsnprintf	#include "c-vsnprintf.h"	c-vsnprintf.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_RESTRICT])	stdio c-vasnprintf
c-xvasprintf	#include "c-xvasprintf.h"	c-xasprintf.c c-xvasprintf.c	00gnulib.m4 zzgnulib.m4	stdio c-vasprintf xalloc-die
c32isalnum	#include <uchar.h>	c32isalnum.c c32is-impl.h	mbrtoc32.m4 mbrtowc.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]) gl_UCHAR_MODULE_INDICATOR([c32isalnum])	uchar wchar 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 mbrtowc.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]) gl_UCHAR_MODULE_INDICATOR([c32isalpha])	uchar wchar 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 mbrtowc.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]) gl_UCHAR_MODULE_INDICATOR([c32isblank])	uchar wchar 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 mbrtowc.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]) gl_UCHAR_MODULE_INDICATOR([c32iscntrl])	uchar wchar 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 mbrtowc.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]) gl_UCHAR_MODULE_INDICATOR([c32isdigit])	uchar wchar 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 mbrtowc.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]) gl_UCHAR_MODULE_INDICATOR([c32isgraph])	uchar wchar 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 mbrtowc.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]) gl_UCHAR_MODULE_INDICATOR([c32islower])	uchar wchar 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 mbrtowc.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]) gl_UCHAR_MODULE_INDICATOR([c32isprint])	uchar wchar 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 mbrtowc.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]) gl_UCHAR_MODULE_INDICATOR([c32ispunct])	uchar wchar wctype-h 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 mbrtowc.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]) gl_UCHAR_MODULE_INDICATOR([c32isspace])	uchar wchar 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 mbrtowc.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]) gl_UCHAR_MODULE_INDICATOR([c32isupper])	uchar wchar 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 mbrtowc.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]) gl_UCHAR_MODULE_INDICATOR([c32isxdigit])	uchar wchar 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-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 attribute [test $HAVE_C32RTOMB = 0 \|\| test $REPLACE_C32RTOMB = 1] wchar [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 wchar 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 wchar 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 wchar c32srtombs
c32tob	#include <uchar.h>	c32tob.c	mbrtoc32.m4 locale-fr.m4 locale-zh.m4 codeset.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_MBRTOC32_SANITYCHECK]) gl_UCHAR_MODULE_INDICATOR([c32tob])	uchar c32rtomb wctob
c32tolower	#include <uchar.h>	c32tolower.c c32to-impl.h	mbrtoc32.m4 mbrtowc.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]) gl_UCHAR_MODULE_INDICATOR([c32tolower])	uchar wchar 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 mbrtowc.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]) gl_UCHAR_MODULE_INDICATOR([c32toupper])	uchar wchar wctype-h localcharset [test $REPLACE_MBSTATE_T = 1] streq [test $REPLACE_MBSTATE_T = 1] unicase/toupper assert-h
call_once	#include <threads.h>	call_once.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_THREADS_H]) gl_CONDITIONAL([GL_COND_OBJ_CALL_ONCE], [test $HAVE_THREADS_H = 0]) gl_THREADS_MODULE_INDICATOR([call_once])	threads-h 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 minmax ssize_t unistd
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 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 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
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 dirfd [test $HAVE_CLOSEDIR = 0 \|\| test $REPLACE_CLOSEDIR = 1]
cnd	#include <threads.h>	cnd.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_THREADS_H]) gl_CONDITIONAL([GL_COND_OBJ_CND], [test $HAVE_THREADS_H = 0]) 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 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 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 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 extensions cosh [test $HAVE_COSHF = 0]
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 sys_stat
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
di-set	#include "di-set.h"	di-set.c	00gnulib.m4 zzgnulib.m4	ino-map hash
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
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 msvc-inval [test $REPLACE_DUP = 1]
error-h	#include "error.h"	error.in.h	error_h.m4 00gnulib.m4 zzgnulib.m4 gl_ERROR_H gl_CONDITIONAL_HEADER([error.h]) AC_PROG_MKDIR_P	gen-header 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 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 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 extensions exp2 [{ test $HAVE_EXP2L = 0 \|\| test $REPLACE_EXP2L = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] float [{ 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 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 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 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 extensions expm1 [{ test $HAVE_EXPM1L = 0 \|\| test $REPLACE_EXPM1L = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] float [{ 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]
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 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 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 extensions errno [test $HAVE_FCHMODAT = 0 \|\| test $REPLACE_FCHMODAT = 1] fcntl-h [test $HAVE_FCHMODAT = 0 \|\| test $REPLACE_FCHMODAT = 1] unistd [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 extensions at-internal [test $HAVE_FCHOWNAT = 0 \|\| test $REPLACE_FCHOWNAT = 1] errno [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
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 msvc-inval [test $REPLACE_FDOPEN = 1]
file-has-acl	#include "acl.h"	acl-internal.h file-has-acl.c	acl.m4 00gnulib.m4 zzgnulib.m4 gl_FILE_HAS_ACL	acl-permissions extern-inline free-posix stat stdbool
findprog-in	#include "findprog.h"	findprog-in.c	findprog-in.m4 eaccess.m4 00gnulib.m4 zzgnulib.m4 gl_FINDPROG_IN	stdbool sys_stat filename concat-filename access stat strdup-posix malloc-posix unistd
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 float [test $HAVE_FMA = 0 \|\| test $REPLACE_FMA = 1] stdbool [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 extensions float [test $HAVE_FMAF = 0 \|\| test $REPLACE_FMAF = 1] stdbool [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 extensions fma [{ test $HAVE_FMAL = 0 \|\| test $REPLACE_FMAL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] float [{ test $HAVE_FMAL = 0 \|\| test $REPLACE_FMAL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] stdbool [{ 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 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 extensions fmod [{ test $HAVE_FMODL = 0 \|\| test $REPLACE_FMODL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] float [{ 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
fprintf-gnu	#include <stdio.h>	---	fprintf-gnu.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_FPRINTF_GNU	fprintf-posix
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 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*) AC_LIBOBJ([stat-w32]) ;; esac gl_PREREQ_FSTAT ]) gl_SYS_STAT_MODULE_INDICATOR([fstat])	sys_stat largefile pathmax [test $REPLACE_FSTAT = 1] stat [test $REPLACE_FSTAT = 1] stat-time [test $REPLACE_FSTAT = 1] unistd [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])	sys_stat extensions at-internal [test $HAVE_FSTATAT = 0 \|\| test $REPLACE_FSTATAT = 1] errno [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]
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 stdbool strdup strstr-simple
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 unistd 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 unistd extensions getpagesize vma-iter
get_ppid_of	#include "get_ppid_of.h"	get_ppid_of.c	00gnulib.m4 zzgnulib.m4	extensions sys_types unistd open
get_progname_of	#include "get_progname_of.h"	get_progname_of.c	00gnulib.m4 zzgnulib.m4	extensions unistd open
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 stdint [test $HAVE_GETRUSAGE = 0]
git-merge-changelog	---	git-merge-changelog.c	00gnulib.m4 zzgnulib.m4	c99 getopt-gnu stdbool stdlib error read-file xlist array-list linkedhash-list linked-list rbtreehash-list xalloc xmalloca fstrcmp minmax 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 stdbool stddef intprops
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 stdbool stddef 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
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 xsize c99
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 xsize c99
hash-triple-simple	#include "hash-triple.h"	hash-triple-simple.c	00gnulib.m4 zzgnulib.m4	hash-pjw same-inode stdbool
host-cpu-c-abi	---	---	host-cpu-c-abi.m4 asm-underscore.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_HOST_CPU_C_ABI])	---
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 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 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 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 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 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
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-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
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 msvc-inval [test $REPLACE_ISATTY = 1] msvc-nothrow [test $REPLACE_ISATTY = 1]
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 00gnulib.m4 zzgnulib.m4 gl_FUNC_ISWCTYPE gl_CONDITIONAL([GL_COND_OBJ_ISWCTYPE], [test $HAVE_WCTYPE_T = 0 \|\| test $GNULIBHEADERS_OVERRIDE_WINT_T = 1]) gl_WCTYPE_MODULE_INDICATOR([iswctype])	wctype-h
iswdigit	#include <wctype.h>	iswdigit.c	iswdigit.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
iswxdigit	#include <wctype.h>	iswxdigit.c	iswxdigit.m4 locale-fr.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
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 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 stdbool stdio unistd 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 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 xsize c99
list-c++	#include "gl_list.hh"	---	00gnulib.m4 zzgnulib.m4	xlist xsublist
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])	locale
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 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 extensions log10 [{ test $HAVE_LOG10L = 0 \|\| test $REPLACE_LOG10L = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] float [{ 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 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 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 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 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 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 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 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 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
map	#include "gl_map.h"	gl_map.c	00gnulib.m4 zzgnulib.m4	extern-inline stdbool
map-c++	#include "gl_map.hh"	---	00gnulib.m4 zzgnulib.m4	xmap
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 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 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] 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]
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 wchar 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 wchar 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 wchar 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 mbsrtowcs [test $REPLACE_MBSTOWCS = 1]
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 mbrtowc [test $HAVE_MBTOWC = 0 \|\| test $REPLACE_MBTOWC = 1] wchar [test $HAVE_MBTOWC = 0 \|\| test $REPLACE_MBTOWC = 1]
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 extensions at-internal [test $HAVE_MKDIRAT = 0] errno [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 [test $HAVE_MKDIRAT = 0]
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 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 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]
monetary	#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	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_THREADS_H]) gl_CONDITIONAL([GL_COND_OBJ_MTX], [test $HAVE_THREADS_H = 0]) 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	---
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 stdbool stdio sys_socket unistd
obstack-printf-gnu	#include <stdio.h>	---	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
omap	#include "gl_omap.h"	gl_omap.c	00gnulib.m4 zzgnulib.m4	extern-inline stdbool
omap-c++	#include "gl_omap.hh"	---	00gnulib.m4 zzgnulib.m4	xomap
openat-h	#include "openat.h"	---	00gnulib.m4 zzgnulib.m4	extern-inline fcntl-h stdbool sys_stat unistd
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 largefile filename [test $HAVE_OPENDIR = 0 \|\| test $REPLACE_OPENDIR = 1] unistd [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 fcntl-h fdopendir openat-safer
openmp-init	#ifdef _OPENMP # include <omp.h> #endif	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
oset-c++	#include "gl_oset.hh"	---	00gnulib.m4 zzgnulib.m4	xoset
passfd	#include "passfd.h"	passfd.c	passfd.m4 00gnulib.m4 zzgnulib.m4 gl_PASSFD	cloexec sys_socket 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
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 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 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 ctype dirent fcntl-h fnmatch-h glob-h iconv-h inttypes-incomplete langinfo locale math monetary netdb poll-h pty search signal-h spawn stdio stdlib string strings sys_file sys_ioctl sys_resource sys_select sys_socket sys_stat sys_time sys_times sys_utsname sys_wait termios time-h unistd utime-h wchar 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 extensions pow [test $HAVE_POWF = 0]
printf-gnu	#include <stdio.h>	---	printf-gnu.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_PRINTF_GNU	printf-posix
pt_chown	---	pt_chown.c pty-private.h	00gnulib.m4 zzgnulib.m4	ptsname root-uid stdlib 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 00gnulib.m4 zzgnulib.m4 gl_PTHREAD_H gl_PTHREAD_H_REQUIRE_DEFAULTS AC_PROG_MKDIR_P	extensions extern-inline gen-header sched 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 $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 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])	pthread-h stdbool [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]
quotearg-simple	---	---	00gnulib.m4 zzgnulib.m4	quotearg
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])	libc-config [test $HAVE_RANDOM = 0 \|\| test $REPLACE_RANDOM = 1 \|\| test $REPLACE_INITSTATE = 1 \|\| test $REPLACE_SETSTATE = 1] stdlib stdint [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 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]) gl_DIRENT_MODULE_INDICATOR([readdir])	dirent largefile
regex-quote	#include "regex-quote.h"	regex-quote.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_RESTRICT])	stdbool xalloc mbuiter
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 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 extensions remainder [{ test $HAVE_REMAINDERL = 0 \|\| test $REPLACE_REMAINDERL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] float [{ 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]) gl_DIRENT_MODULE_INDICATOR([rewinddir])	dirent 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 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 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_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
set	#include "gl_set.h"	gl_set.c	00gnulib.m4 zzgnulib.m4	extern-inline stdbool
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 errno [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 localename [test $NEED_SETLOCALE_IMPROVED = 1] setlocale-null [test $NEED_SETLOCALE_MTSAFE = 1]
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 snippet/arg-nonnull
sh-filename	---	---	sh-filename.m4 00gnulib.m4 zzgnulib.m4 gl_SH_FILENAME	---
signal	---	---	00gnulib.m4 zzgnulib.m4	signal-h
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 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 extensions sinh [test $HAVE_SINHF = 0]
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
socketlib	---	---	socketlib.m4 sys_socket_h.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_SOCKETLIB])	---
sparcv8+	---	---	sparcv8+.m4 00gnulib.m4 zzgnulib.m4	---
sprintf-gnu	#include <stdio.h>	---	sprintf-gnu.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_SPRINTF_GNU	sprintf-posix
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 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
stat-size	#include "stat-size.h"	---	stat-size.m4 00gnulib.m4 zzgnulib.m4 gl_STAT_SIZE	fileblocks sys_stat
statat	#include "openat.h"	statat.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([statat]) dnl for lib/openat.h	fstatat
stdbool-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
stdnoreturn	#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
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 extensions stdbool [test $REPLACE_STRFMON_L = 1]
strftime	#include "strftime.h"	---	00gnulib.m4 zzgnulib.m4	nstrftime
string-desc	#include "string-desc.h"	string-desc.c string-desc-contains.c	00gnulib.m4 zzgnulib.m4	stdbool idx 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
strtod-obsolete	#include <string.h>	---	strtod-obsolete.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_STRTOD_OBSOLETE	strtod
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 c-ctype [test $HAVE_STRTOLD = 0 \|\| test $REPLACE_STRTOLD = 1] math [test $HAVE_STRTOLD = 0 \|\| test $REPLACE_STRTOLD = 1] stdbool [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_msg	#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_resource	#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
sys_sem	#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	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_types	#include <sys/types.h>	sys_types.in.h	sys_types_h.m4 off_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
system-posix	#include <stdlib.h>	---	00gnulib.m4 zzgnulib.m4 gl_STDLIB_MODULE_INDICATOR([system-posix])	stdlib sys_wait
system-quote	#include "system-quote.h"	system-quote.c	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([AC_C_RESTRICT])	sh-quote stdbool xalloc
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 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 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 extensions sys_ioctl [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	stdbool fatal-signal sigaction sigprocmask full-write fstat same-inode xalloc-die
termios	#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
thrd	#include <threads.h>	thrd.c	thrd.m4 00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_THREADS_H]) 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 timespec
timespec-sub	#include "timespec.h"	timespec-sub.c	00gnulib.m4 zzgnulib.m4	c99 intprops timespec
timevar	#include "timevar.h"	timevar.c	00gnulib.m4 zzgnulib.m4	c99 gethrxtime getrusage gettext-h stdlib sys_time sys_times xalloc
towctrans	#include <wctype.h>	towctrans.c towctrans-impl.h	towctrans.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_TOWCTRANS gl_CONDITIONAL([GL_COND_OBJ_TOWCTRANS], [test $HAVE_TOWCTRANS = 0]) 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	00gnulib.m4 zzgnulib.m4 AC_REQUIRE([gl_THREADS_H]) gl_CONDITIONAL([GL_COND_OBJ_TSS], [test $HAVE_THREADS_H = 0]) gl_THREADS_MODULE_INDICATOR([tss])	threads-h windows-tls
uchar	#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/c++defs extern-inline assert-h stdint wchar
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 stdbool
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 stdbool
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 stdbool
unicase/u16-is-invariant	#include "unicase/invariant.h"	unicase/u16-is-invariant.c unicase/u-is-invariant.h	00gnulib.m4 zzgnulib.m4	unitypes uninorm/base uninorm/u16-normalize uninorm/nfd unistr/u16-cmp stdbool
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 stdbool
unicase/u32-is-invariant	#include "unicase/invariant.h"	unicase/u32-is-invariant.c unicase/u-is-invariant.h	00gnulib.m4 zzgnulib.m4	unitypes uninorm/base uninorm/u32-normalize uninorm/nfd unistr/u32-cmp stdbool
unicase/u32-is-uppercase	#include "unicase.h"	unicase/u32-is-uppercase.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.1], [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 stdbool
unicase/u8-is-invariant	#include "unicase/invariant.h"	unicase/u8-is-invariant.c unicase/u-is-invariant.h	00gnulib.m4 zzgnulib.m4	unitypes uninorm/base uninorm/u8-normalize uninorm/nfd unistr/u8-cmp stdbool
unictype/category-LC	#include "unictype.h"	unictype/categ_LC.c unictype/categ_LC.h	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.1], [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/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([0.9.11], [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([0.9.11], [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([0.9.11], [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.1], [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_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([1.1], [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_LIBUNISTRING_MODULE([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_LIBUNISTRING_MODULE([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([0.9.11], [unigbrk.h]) AC_PROG_MKDIR_P	gen-header unitypes stdbool
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.1], [unigbrk/u16-grapheme-breaks])	unigbrk/base unigbrk/uc-gbrk-prop unictype/property-extended-pictographic unistr/u16-mbtouc stdbool
unigbrk/u16-grapheme-next	#include "unigbrk.h"	unigbrk/u16-grapheme-next.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([unigbrk/u16-grapheme-next]) gl_LIBUNISTRING_MODULE([1.1], [unigbrk/u16-grapheme-next])	unigbrk/uc-is-grapheme-break unistr/u16-mbtouc
unigbrk/u16-grapheme-prev	#include "unigbrk.h"	unigbrk/u16-grapheme-prev.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([unigbrk/u16-grapheme-prev]) gl_LIBUNISTRING_MODULE([1.1], [unigbrk/u16-grapheme-prev])	unigbrk/uc-is-grapheme-break unistr/u16-prev
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.1], [unigbrk/u32-grapheme-breaks])	unigbrk/base unigbrk/uc-gbrk-prop unictype/property-extended-pictographic unistr/u32-mbtouc stdbool
unigbrk/u32-grapheme-next	#include "unigbrk.h"	unigbrk/u32-grapheme-next.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([unigbrk/u32-grapheme-next]) gl_LIBUNISTRING_MODULE([1.1], [unigbrk/u32-grapheme-next])	unigbrk/uc-is-grapheme-break unistr/u32-mbtouc
unigbrk/u32-grapheme-prev	#include "unigbrk.h"	unigbrk/u32-grapheme-prev.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([unigbrk/u32-grapheme-prev]) gl_LIBUNISTRING_MODULE([1.1], [unigbrk/u32-grapheme-prev])	unigbrk/uc-is-grapheme-break unistr/u32-prev
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.1], [unigbrk/u8-grapheme-breaks])	unigbrk/base unigbrk/uc-gbrk-prop unictype/property-extended-pictographic unistr/u8-mbtouc stdbool
unigbrk/u8-grapheme-next	#include "unigbrk.h"	unigbrk/u8-grapheme-next.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([unigbrk/u8-grapheme-next]) gl_LIBUNISTRING_MODULE([1.1], [unigbrk/u8-grapheme-next])	unigbrk/uc-is-grapheme-break unistr/u8-mbtouc
unigbrk/u8-grapheme-prev	#include "unigbrk.h"	unigbrk/u8-grapheme-prev.c	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([unigbrk/u8-grapheme-prev]) gl_LIBUNISTRING_MODULE([1.1], [unigbrk/u8-grapheme-prev])	unigbrk/uc-is-grapheme-break unistr/u8-prev
unigbrk/uc-gbrk-prop	#include "unigbrk.h"	unigbrk/gbrkprop.h unigbrk/uc-gbrk-prop.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.1], [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.1], [unigbrk/uc-grapheme-breaks])	unigbrk/base unigbrk/uc-gbrk-prop unictype/property-extended-pictographic stdbool
unigbrk/uc-is-grapheme-break	#include "unigbrk.h"	unigbrk/uc-is-grapheme-break.c	00gnulib.m4 zzgnulib.m4 gl_LIBUNISTRING_MODULE([1.1], [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.1], [unigbrk/ulc-grapheme-breaks])	unigbrk/base unigbrk/u8-grapheme-breaks uniconv/u8-conv-from-enc c-ctype localcharset
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 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
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 extensions fcntl-h [test $HAVE_UNLINKAT = 0 \|\| test $REPLACE_UNLINKAT = 1] openat-h [test $HAVE_UNLINKAT = 0 \|\| test $REPLACE_UNLINKAT = 1] sys_stat [test $HAVE_UNLINKAT = 0 \|\| test $REPLACE_UNLINKAT = 1] at-internal [test $HAVE_UNLINKAT = 0] errno [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>	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
vasnprintf-gnu	#include "vasnprintf.h"	---	vasnprintf-gnu.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_VASNPRINTF_GNU	vasnprintf-posix
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	wchar_t.m4 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 alloca-opt attribute float free-posix limits-h stdint xsize errno memchr assert-h wchar mbrtowc wmemcpy wmemset
vasnwprintf-gnu	#include "vasnwprintf.h"	---	vasnwprintf-gnu.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_VASNWPRINTF_GNU	vasnwprintf-posix
vasnwprintf-posix	#include "vasnwprintf.h"	---	vasnwprintf-posix.m4 printf.m4 math_h.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_VASNWPRINTF_POSIX	vasnwprintf isnand-nolibm isnanl-nolibm frexp-nolibm frexpl-nolibm printf-frexp printf-frexpl signbit fpucw nocrash printf-safe multiarch
vasprintf-gnu	#include "vasprintf.h"	---	vasprintf-gnu.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_VASPRINTF_GNU	vasprintf-posix
vdprintf-gnu	#include <stdio.h>	---	vdprintf-gnu.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_VDPRINTF_GNU	vdprintf-posix
vfprintf-gnu	#include <stdio.h>	---	vfprintf-gnu.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_VFPRINTF_GNU	vfprintf-posix
vfscanf	#include <stdio.h>	---	00gnulib.m4 zzgnulib.m4 gl_STDIO_MODULE_INDICATOR([vfscanf]) gl_MODULE_INDICATOR([vfscanf])	stdio
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 unistd extensions getpagesize open
vprintf-gnu	#include <stdio.h>	---	vprintf-gnu.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_VPRINTF_GNU	vprintf-posix
vscanf	#include <stdio.h>	---	00gnulib.m4 zzgnulib.m4 gl_STDIO_MODULE_INDICATOR([vscanf]) gl_MODULE_INDICATOR([vscanf])	stdio
vsnprintf-gnu	#include <stdio.h>	---	vsnprintf-gnu.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_VSNPRINTF_GNU	vsnprintf-posix
vsprintf-gnu	#include <stdio.h>	---	vsprintf-gnu.m4 00gnulib.m4 zzgnulib.m4 gl_FUNC_VSPRINTF_GNU	vsprintf-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
wchar-single	---	---	00gnulib.m4 zzgnulib.m4 gl_MODULE_INDICATOR([wchar-single])	wchar
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
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
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 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
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
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]) gl_WCHAR_MODULE_INDICATOR([wcscmp])	wchar
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
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
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 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 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
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
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 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]) gl_WCHAR_MODULE_INDICATOR([wcsncat])	wchar
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]) gl_WCHAR_MODULE_INDICATOR([wcsncmp])	wchar
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
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
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 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
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 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 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 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 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
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 wcrtomb [test $REPLACE_WCTOMB = 1] wchar [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]) gl_WCTYPE_MODULE_INDICATOR([wctrans])	wctype-h
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/c++defs snippet/warn-on-use
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) true;; ) false;; esac])	stdbool errno time-h gettimeofday
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) 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) 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) 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) 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) 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) 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) true;; ) false;; esac])	errno 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) true;; ) false;; esac])	errno 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) true;; ) false;; esac])	errno stdbool 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) 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
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]) gl_WCHAR_MODULE_INDICATOR([wmemcmp])	wchar
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
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
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
xalloc-oversized	#include "xalloc-oversized.h"	---	00gnulib.m4 zzgnulib.m4	stdint
xbinary-io	#include "xbinary-io.h"	xbinary-io.c	00gnulib.m4 zzgnulib.m4	binary-io error exitfail extern-inline gettext-h stdbool verify
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 stdbool xalloc-die
xomap	#include "gl_xomap.h"	gl_xomap.c	00gnulib.m4 zzgnulib.m4	omap extern-inline stdbool xalloc-die
xprintf-gnu	#include "xprintf.h"	---	00gnulib.m4 zzgnulib.m4	xprintf vprintf-gnu vfprintf-gnu
xset	#include "gl_xset.h"	gl_xset.c	00gnulib.m4 zzgnulib.m4	set extern-inline stdbool xalloc-die
xstdopen	#include "xstdopen.h"	xstdopen.c	00gnulib.m4 zzgnulib.m4	stdopen error gettext-h exitfail
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

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/locale-ar.m4
m4/locale-tr.m4
m4/pkg.m4
m4/semaphore.m4
m4/ulonglong.m4
m4/valgrind-tests.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 17 April 2023.