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.
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	Work around incompatibility on older systems where free (NULL) fails.
malloc-gnu	malloc function that is glibc compatible.
realloc-gnu	realloc 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
strftime	nstrftime function: convert date and time to string, with GNU extensions.
time_rz	Reentrant time zone functions: localtime_rz, mktime_z, etc.

Extra functions based on ANSI C 89

Memory management functions <stdlib.h>

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.
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.
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 point 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.
strerror_r-posix	strerror_r function: get string describing error code.
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.
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.
timegm	Convert calendar time to simple time, inverse of mktime.
tzset	tzset - initialize time conversion information

Input/Output <stdio.h>

unlocked-io	Enable faster, non-thread-safe stdio functions if available.
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.
strsignal	strsignal function: return string describing signal.

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.

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/md4	Compute MD4 checksum.
crypto/md5	Compute MD5 checksum.
crypto/rijndael	Rijndael block cipher.
crypto/sha1	Compute SHA1 checksum.
crypto/sha256	Compute SHA224 and SHA256 checksums.
crypto/sha512	Compute SHA384 and SHA512 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-sha1	Password-Based Key Derivation Function according to PKCS#5/RFC2898
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.

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.
diacrit	Decomposition of composed ISO-8859-1 characters.
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.
readline	Simple implementation of readline.
readtokens	Read tokens from a stream.
readtokens0	Read NUL-separated tokens from a stream.
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.
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.

Sizes of integer types <limits.h>

size_max Provide SIZE_MAX, for cases when the stdint module cannot be used.

Variable arguments <stdarg.h>

stdarg

An <stdarg.h> that conforms to C99.

Boolean type and values <stdbool.h>

stdbool

An <stdbool.h> that nearly conforms to C99. (Nearly: casts to bool may not work.)

Basic types <stddef.h>

stddef

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

Integer types and values <stdint.h>

stdint

A <stdint.h> that nearly conforms to C99. 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 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.
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.

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.

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.
chown	chown function: change ownership of a file, following symlinks.
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>.
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 fcntl what?? If you mean a function, please say so. action 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 malloc what?? If you mean a function, please say so..
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 what?? If you mean a function, please say so., sethostent what?? If you mean a function, please say so., endhostent what?? If you mean a function, please say so., gethostbyname what?? If you mean a function, please say so., gethostbyaddr what?? If you mean a function, please say so..
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_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 a trivial 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 what?? If you mean a function, please say so., setservent what?? If you mean a function, please say so., endservent what?? If you mean a function, please say so., getservbyname what?? If you mean a function, please say so., getservbyport what?? If you mean a function, please say so., getprotoent what?? If you mean a function, please say so., setprotoent what?? If you mean a function, please say so., endprotoent what?? If you mean a function, please say so., getprotobyname what?? If you mean a function, please say so., getprotobynumber what?? If you mean a function, please say so..
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 what?? If you mean a function, please say so. and try_tempname what?? If you mean a function, please say so.: create a private temporary file or directory.
time	A more-standard <time.h>.
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.
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.
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.
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.
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.
link-follow	Determine whether link("symlink", "foo") follows the symlink.
rename-dest-slash	rename function: change the name or location of a file.
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
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-posix	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	Determination of the filename of a backup file, according to user environment variables.
canonicalize	Return the canonical absolute name of a given file.
canonicalize-lgpl	realpath, canonical_file_name: Provide canonical absolute file name
chdir-safer	like chdir, but safer
clean-temp	Temporary directories and 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	Use large files.
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
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 time stamps
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

dup3	dup3 function: copy a file descriptor, applying specific flags.
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.
getdtablesize	getdtablesize function: return maximum number of file descriptors.
fcntl-safer	File descriptor functions that avoid clobbering STD{IN,OUT,ERR}_FILENO.
openat-safer	openat function that avoids 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.
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.
binary-io	Binary mode I/O.
isapipe	Test whether a file descriptor is a pipe.
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}.

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-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}.
stdlib-safer	File stream functions that avoid clobbering std{in,out,err}.
tmpfile-safer	tmpfile function that avoids clobbering std{in,out,err}.
xfreopen	a wrapper for freopen

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

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.
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 more convenient interface to nanosleep

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.
lock	Locking in multithreaded situations.
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.

Internationalization functions

gettext	Translate messages to user's native language.
gettext-h	Translate messages to user's native language if the gettext module 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/bidicategory-byname	Find a Unicode character bidi category, given its name.
unictype/bidicategory-name	Name of Unicode character bidi category.
unictype/bidicategory-of	Determine bidi category of a Unicode character.
unictype/bidicategory-test	Test whether a Unicode character belongs to a given bidi category.
unictype/bidicategory-all	Unicode character bidi category functions.
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*.
bitrotate	Rotate bits in unsigned 8, 16, and 32 bit integers.
byteswap	Swap bytes of 16, 32 and 64 bit values.
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.
getloadavg	Return the current system load averages.
getpagesize	getpagesize function: Return memory page size.
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.
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.
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 http://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 <http://www.parisc-linux.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 http://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)

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 00gnulib.m4 gl_STDLIB_H	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 gl_FUNC_STRTOL if test $ac_cv_func_strtol = no; then AC_LIBOBJ([strtol]) fi	---
strtoul	#include <stdlib.h>	strtol.c strtoul.c	strtoul.m4 00gnulib.m4 gl_FUNC_STRTOUL if test $ac_cv_func_strtoul = no; then AC_LIBOBJ([strtoul]) fi	---
memcmp	#include <string.h>	memcmp.c	memcmp.m4 00gnulib.m4 gl_FUNC_MEMCMP if test $gl_func_memcmp = no; then AC_LIBOBJ([memcmp]) gl_PREREQ_MEMCMP fi	stdint [test $gl_func_memcmp = no]
memcpy	#include <string.h>	memcpy.c	memcpy.m4 00gnulib.m4 gl_FUNC_MEMCPY if test $ac_cv_func_memcpy = no; then AC_LIBOBJ([memcpy]) gl_PREREQ_MEMCPY fi	string
memmove	#include <string.h>	memmove.c	memmove.m4 00gnulib.m4 gl_FUNC_MEMMOVE if test $ac_cv_func_memmove = no; then AC_LIBOBJ([memmove]) gl_PREREQ_MEMMOVE fi	string
memset	#include <string.h>	memset.c	memset.m4 00gnulib.m4 gl_FUNC_MEMSET if test $ac_cv_func_memset = no; then AC_LIBOBJ([memset]) gl_PREREQ_MEMSET fi	string
strcspn	#include <string.h>	strcspn.c	strcspn.m4 00gnulib.m4 gl_FUNC_STRCSPN if test $ac_cv_func_strcspn = no; then AC_LIBOBJ([strcspn]) gl_PREREQ_STRCSPN fi	---
strpbrk	#include <string.h>	strpbrk.c	strpbrk.m4 00gnulib.m4 gl_FUNC_STRPBRK if test $HAVE_STRPBRK = 0; then AC_LIBOBJ([strpbrk]) gl_PREREQ_STRPBRK fi 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 gl_FUNC_ATEXIT if test $ac_cv_func_atexit = no; then AC_LIBOBJ([atexit]) gl_PREREQ_ATEXIT fi	---
strtod	#include <stdlib.h>	strtod.c	strtod.m4 ldexp.m4 00gnulib.m4 gl_FUNC_STRTOD if test $HAVE_STRTOD = 0 \|\| test $REPLACE_STRTOD = 1; then AC_LIBOBJ([strtod]) gl_PREREQ_STRTOD fi gl_STDLIB_MODULE_INDICATOR([strtod])	stdlib strtod-obsolete c-ctype [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 gl_FUNC_STRERROR if test $REPLACE_STRERROR = 1; then AC_LIBOBJ([strerror]) fi gl_MODULE_INDICATOR([strerror]) gl_STRING_MODULE_INDICATOR([strerror])	string errno [test $REPLACE_STRERROR = 1] intprops [test $REPLACE_STRERROR = 1] strerror-override [test $REPLACE_STRERROR = 1] verify [test $REPLACE_STRERROR = 1]
strerror-override	#include "strerror-override.h"	strerror-override.c	sys_socket_h.m4 strerror.m4 00gnulib.m4 AC_REQUIRE([gl_HEADER_ERRNO_H]) AC_REQUIRE([gl_FUNC_STRERROR_0]) if test -n "$ERRNO_H" \|\| test $REPLACE_STRERROR_0 = 1; then AC_LIBOBJ([strerror-override]) gl_PREREQ_SYS_H_WINSOCK2 fi	errno
mktime	#include <time.h>	mktime-internal.h mktime.c	mktime.m4 00gnulib.m4 gl_FUNC_MKTIME if test $REPLACE_MKTIME = 1; then AC_LIBOBJ([mktime]) gl_PREREQ_MKTIME fi gl_TIME_MODULE_INDICATOR([mktime])	multiarch time_r [test $REPLACE_MKTIME = 1]

Enhancements for ANSI C 89 functions

Diagnostics <assert.h>

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

Mathematics <math.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
fpieee	---	---	fpieee.m4 00gnulib.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 gl_FUNC_FFLUSH if test $REPLACE_FFLUSH = 1; then AC_LIBOBJ([fflush]) gl_PREREQ_FFLUSH fi gl_MODULE_INDICATOR([fflush]) gl_STDIO_MODULE_INDICATOR([fflush])	stdio snippet/unused-parameter [test $REPLACE_FFLUSH = 1] 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 gl_FUNC_FSETERR if test $ac_cv_func___fseterr = no; then AC_LIBOBJ([fseterr]) fi	---
tmpfile	#include <stdio.h>	tmpfile.c	tmpfile.m4 00gnulib.m4 gl_FUNC_TMPFILE if test $REPLACE_TMPFILE = 1; then AC_LIBOBJ([tmpfile]) gl_PREREQ_TMPFILE fi gl_STDIO_MODULE_INDICATOR([tmpfile])	stdio largefile pathmax [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 gl_FUNC_CALLOC_GNU if test $REPLACE_CALLOC = 1; then AC_LIBOBJ([calloc]) fi gl_MODULE_INDICATOR([calloc-gnu])	calloc-posix
eealloc	#include <eealloc.h>	eealloc.h eealloc.c	eealloc.m4 malloc.m4 realloc.m4 00gnulib.m4 gl_EEALLOC	extern-inline
free	#include <stdlib.h>	free.c	free.m4 00gnulib.m4 gl_FUNC_FREE if test $gl_cv_func_free = no; then AC_LIBOBJ([free]) gl_PREREQ_FREE fi	---
malloc-gnu	#include <stdlib.h>	malloc.c	00gnulib.m4 gl_FUNC_MALLOC_GNU if test $REPLACE_MALLOC = 1; then AC_LIBOBJ([malloc]) fi gl_MODULE_INDICATOR([malloc-gnu])	malloc-posix
realloc-gnu	#include <stdlib.h>	realloc.c	00gnulib.m4 gl_FUNC_REALLOC_GNU if test $REPLACE_REALLOC = 1; then AC_LIBOBJ([realloc]) fi gl_MODULE_INDICATOR([realloc-gnu])	realloc-posix
pagealign_alloc	#include "pagealign_alloc.h"	pagealign_alloc.c	mmap-anon.m4 pagealign_alloc.m4 00gnulib.m4 gl_PAGEALIGN_ALLOC	error extensions getpagesize gettext-h 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	---
mpsort	#include "mpsort.h"	mpsort.c	mpsort.m4 00gnulib.m4 gl_MPSORT	---
qsort_r	#include <stdlib.h>	qsort.c qsort_r.c	qsort_r.m4 00gnulib.m4 gl_FUNC_QSORT_R if test $HAVE_QSORT_R = 0; then AC_LIBOBJ([qsort]) elif test $REPLACE_QSORT_R = 1; then AC_LIBOBJ([qsort_r]) fi 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	stdio strftime time_rz
strftime	#include "strftime.h"	strftime.c	tm_gmtoff.m4 strftime.m4 00gnulib.m4 gl_FUNC_GNU_STRFTIME	extensions stdbool time_rz
time_rz	#include <time.h>	time-internal.h time_rz.c	time_rz.m4 00gnulib.m4 gl_TIME_RZ if test "$HAVE_TIMEZONE_T" = 0; then AC_LIBOBJ([time_rz]) fi gl_TIME_MODULE_INDICATOR([time_rz])	extensions flexmember [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] unsetenv [test "$HAVE_TIMEZONE_T" = 0]

Extra functions based on ANSI C 89

Memory management functions <stdlib.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
xsize	#include "xsize.h"	xsize.c	xsize.m4 00gnulib.m4 gl_XSIZE	extern-inline size_max
xalloc	#include "xalloc.h"	xmalloc.c	xalloc.m4 00gnulib.m4 gl_XALLOC	extern-inline xalloc-die xalloc-oversized
xalloc-die	#include "xalloc.h"	xalloc-die.c	00gnulib.m4	xalloc error gettext-h exitfail
alloca	#include <alloca.h>	alloca.c	00gnulib.m4	alloca-opt
alloca-opt	#include <alloca.h>	alloca.in.h	alloca.m4 00gnulib.m4 gl_FUNC_ALLOCA	---
malloca	#include "malloca.h"	malloca.c malloca.valgrind	malloca.m4 eealloc.m4 longlong.m4 00gnulib.m4 gl_MALLOCA	alloca-opt stdint verify
xmalloca	#include "xmalloca.h"	xmalloca.c	00gnulib.m4	malloca xalloc
xmemdup0	#include "xmemdup0.h"	xmemdup0.c	00gnulib.m4 AC_LIBOBJ([xmemdup0])	xalloc
safe-alloc	#include "safe-alloc.h"	safe-alloc.c	safe-alloc.m4 00gnulib.m4 gl_SAFE_ALLOC	---

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	count-leading-zeros.m4 00gnulib.m4 gl_COUNT_LEADING_ZEROS	extern-inline verify
count-one-bits	#include "count-one-bits.h"	count-one-bits.c	count-one-bits.m4 00gnulib.m4 gl_COUNT_ONE_BITS	extern-inline
count-trailing-zeros	#include "count-trailing-zeros.h"	count-trailing-zeros.c	count-trailing-zeros.m4 00gnulib.m4 gl_COUNT_TRAILING_ZEROS	extern-inline
ffs	#include <strings.h>	ffs.c	ffs.m4 00gnulib.m4 gl_FUNC_FFS if test $HAVE_FFS = 0; then AC_LIBOBJ([ffs]) fi gl_STRINGS_MODULE_INDICATOR([ffs])	strings
ffsl	#include <string.h>	ffsl.h ffsl.c	ffsl.m4 00gnulib.m4 gl_FUNC_FFSL if test $HAVE_FFSL = 0; then AC_LIBOBJ([ffsl]) fi gl_STRING_MODULE_INDICATOR([ffsl])	extensions string ffs [test $HAVE_FFSL = 0]
ffsll	#include <string.h>	ffsl.h ffsll.c	ffsll.m4 00gnulib.m4 gl_FUNC_FFSLL if test $HAVE_FFSLL = 0; then AC_LIBOBJ([ffsll]) fi gl_STRING_MODULE_INDICATOR([ffsll])	extensions string ffs [test $HAVE_FFSLL = 0]
gcd	#include "gcd.h"	gcd.c	00gnulib.m4	---
minmax	#include "minmax.h"	---	minmax.m4 00gnulib.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 gl_FUNC_PUTENV if test $REPLACE_PUTENV = 1; then AC_LIBOBJ([putenv]) gl_PREREQ_PUTENV fi gl_STDLIB_MODULE_INDICATOR([putenv])	stdlib environ [test $REPLACE_PUTENV = 1] malloc-posix [test $REPLACE_PUTENV = 1]
secure_getenv	#include <stdlib.h>	secure_getenv.c	secure_getenv.m4 00gnulib.m4 gl_FUNC_SECURE_GETENV if test $HAVE_SECURE_GETENV = 0; then AC_LIBOBJ([secure_getenv]) gl_PREREQ_SECURE_GETENV fi gl_STDLIB_MODULE_INDICATOR([secure_getenv])	stdlib extensions
setenv	#include <stdlib.h>	setenv.c	setenv.m4 00gnulib.m4 gl_FUNC_SETENV if test $HAVE_SETENV = 0 \|\| test $REPLACE_SETENV = 1; then AC_LIBOBJ([setenv]) fi 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 gl_FUNC_UNSETENV if test $HAVE_UNSETENV = 0 \|\| test $REPLACE_UNSETENV = 1; then AC_LIBOBJ([unsetenv]) gl_PREREQ_UNSETENV fi 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	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	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 AC_REPLACE_FUNCS(bcopy)	strings
memchr	#include <string.h>	memchr.c memchr.valgrind	memchr.m4 mmap-anon.m4 00gnulib.m4 gl_FUNC_MEMCHR if test $HAVE_MEMCHR = 0 \|\| test $REPLACE_MEMCHR = 1; then AC_LIBOBJ([memchr]) gl_PREREQ_MEMCHR fi gl_STRING_MODULE_INDICATOR([memchr])	extensions string memchr-obsolete
memchr2	#include "memchr2.h"	memchr2.c memchr2.valgrind	00gnulib.m4	stdint memchr
memcmp2	#include "memcmp2.h"	memcmp2.c	00gnulib.m4	---
memmem	#include <string.h>	---	00gnulib.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 gl_FUNC_MEMMEM_SIMPLE if test $HAVE_MEMMEM = 0 \|\| test $REPLACE_MEMMEM = 1; then AC_LIBOBJ([memmem]) fi gl_STRING_MODULE_INDICATOR([memmem])	extensions string stdint memchr memcmp
mempcpy	#include <string.h>	mempcpy.c	mempcpy.m4 00gnulib.m4 gl_FUNC_MEMPCPY if test $HAVE_MEMPCPY = 0; then AC_LIBOBJ([mempcpy]) gl_PREREQ_MEMPCPY fi gl_STRING_MODULE_INDICATOR([mempcpy])	extensions string
memrchr	#include <string.h>	memrchr.c	memrchr.m4 00gnulib.m4 gl_FUNC_MEMRCHR if test $ac_cv_func_memrchr = no; then AC_LIBOBJ([memrchr]) gl_PREREQ_MEMRCHR fi gl_STRING_MODULE_INDICATOR([memrchr])	extensions string
amemxfrm	#include "amemxfrm.h"	amemxfrm.c	00gnulib.m4	---
rawmemchr	#include <string.h>	rawmemchr.c rawmemchr.valgrind	rawmemchr.m4 00gnulib.m4 gl_FUNC_RAWMEMCHR if test $HAVE_RAWMEMCHR = 0; then AC_LIBOBJ([rawmemchr]) gl_PREREQ_RAWMEMCHR fi gl_STRING_MODULE_INDICATOR([rawmemchr])	extensions string
stpcpy	#include <string.h>	stpcpy.c	stpcpy.m4 00gnulib.m4 gl_FUNC_STPCPY if test $HAVE_STPCPY = 0; then AC_LIBOBJ([stpcpy]) gl_PREREQ_STPCPY fi gl_STRING_MODULE_INDICATOR([stpcpy])	extensions string
stpncpy	#include <string.h>	stpncpy.c	stpncpy.m4 00gnulib.m4 gl_FUNC_STPNCPY if test $HAVE_STPNCPY = 0 \|\| test $REPLACE_STPNCPY = 1; then AC_LIBOBJ([stpncpy]) gl_PREREQ_STPNCPY fi gl_STRING_MODULE_INDICATOR([stpncpy])	extensions string
c-strcase	#include "c-strcase.h"	c-strcasecmp.c c-strncasecmp.c	00gnulib.m4	c-ctype
strcase	#include <strings.h>	strcasecmp.c strncasecmp.c	strcase.m4 00gnulib.m4 gl_STRCASE if test $HAVE_STRCASECMP = 0; then AC_LIBOBJ([strcasecmp]) gl_PREREQ_STRCASECMP fi if test $HAVE_STRNCASECMP = 0; then AC_LIBOBJ([strncasecmp]) gl_PREREQ_STRNCASECMP fi	strings
c-strcaseeq	#include "c-strcaseeq.h"	---	00gnulib.m4	c-strcase c-ctype
c-strcasestr	#include "c-strcasestr.h"	c-strcasestr.c str-two-way.h	00gnulib.m4	c-ctype c-strcase stdbool memchr memcmp
strcasestr	#include <string.h>	---	00gnulib.m4 gl_FUNC_STRCASESTR if test $HAVE_STRCASESTR = 0 \|\| test $REPLACE_STRCASESTR = 1; then AC_LIBOBJ([strcasestr]) gl_PREREQ_STRCASESTR fi	strcasestr-simple
strcasestr-simple	#include <string.h>	strcasestr.c str-two-way.h	strcasestr.m4 00gnulib.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 gl_FUNC_STRCHRNUL if test $HAVE_STRCHRNUL = 0 \|\| test $REPLACE_STRCHRNUL = 1; then AC_LIBOBJ([strchrnul]) gl_PREREQ_STRCHRNUL fi gl_STRING_MODULE_INDICATOR([strchrnul])	string extensions rawmemchr [test $HAVE_STRCHRNUL = 0 \|\| test $REPLACE_STRCHRNUL = 1]
streq	#include "streq.h"	---	00gnulib.m4	---
strerror_r-posix	#include <string.h>	strerror_r.c	strerror_r.m4 00gnulib.m4 gl_FUNC_STRERROR_R if test $HAVE_DECL_STRERROR_R = 0 \|\| test $REPLACE_STRERROR_R = 1; then AC_LIBOBJ([strerror_r]) gl_PREREQ_STRERROR_R fi gl_STRING_MODULE_INDICATOR([strerror_r])	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]
strnlen	#include <string.h>	strnlen.c	strnlen.m4 00gnulib.m4 gl_FUNC_STRNLEN if test $HAVE_DECL_STRNLEN = 0 \|\| test $REPLACE_STRNLEN = 1; then AC_LIBOBJ([strnlen]) gl_PREREQ_STRNLEN fi gl_STRING_MODULE_INDICATOR([strnlen])	string extensions memchr-obsolete [test $HAVE_DECL_STRNLEN = 0 \|\| test $REPLACE_STRNLEN = 1]
strnlen1	#include "strnlen1.h"	strnlen1.c	00gnulib.m4	memchr
strndup	#include <string.h>	strndup.c	strndup.m4 00gnulib.m4 gl_FUNC_STRNDUP if test $HAVE_STRNDUP = 0 \|\| test $REPLACE_STRNDUP = 1; then AC_LIBOBJ([strndup]) fi 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 gl_FUNC_STRSEP if test $HAVE_STRSEP = 0; then AC_LIBOBJ([strsep]) gl_PREREQ_STRSEP fi gl_STRING_MODULE_INDICATOR([strsep])	string extensions strpbrk [test $HAVE_STRSEP = 0]
strstr	#include <string.h>	---	00gnulib.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 gl_FUNC_STRSTR_SIMPLE if test $REPLACE_STRSTR = 1; then AC_LIBOBJ([strstr]) fi gl_STRING_MODULE_INDICATOR([strstr])	string 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	strstr
astrxfrm	#include "astrxfrm.h"	astrxfrm.c	00gnulib.m4	---
trim	#include "trim.h"	trim.c	00gnulib.m4	xalloc mbchar mbiter memmove strdup
fstrcmp	#include "fstrcmp.h"	fstrcmp.c	00gnulib.m4	diffseq lock tls minmax stdint xalloc
xstrndup	#include "xstrndup.h"	xstrndup.c	xstrndup.m4 00gnulib.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 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 00gnulib.m4 gl_C_STRTOD	extensions locale strdup-posix
c-strtold	#include "c-strtod.h"	c-strtod.c c-strtold.c	c-strtod.m4 00gnulib.m4 gl_C_STRTOLD	extensions locale strdup-posix
xstrtod	#include "xstrtod.h"	xstrtod.c	xstrtod.m4 00gnulib.m4 gl_XSTRTOD	stdbool
xstrtol	#include "xstrtol.h"	xstrtol.c xstrtoul.c xstrtol-error.c	xstrtol.m4 00gnulib.m4 gl_XSTRTOL	assure exitfail error getopt-gnu gettext-h intprops inttypes-incomplete
xstrtoll	#include "xstrtol.h"	xstrtoll.c xstrtoull.c	00gnulib.m4 AC_LIBOBJ([xstrtoll]) AC_LIBOBJ([xstrtoull]) AC_TYPE_LONG_LONG_INT test $ac_cv_type_long_long_int = no \ && AC_MSG_ERROR( [you lack long long support; required by gnulib's xstrtoll module])	strtoll strtoull xstrtol
xstrtold	#include "xstrtod.h"	xstrtod.c xstrtold.c	xstrtod.m4 00gnulib.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 gl_FUNC_MKTIME_INTERNAL if test $REPLACE_MKTIME = 1; then AC_LIBOBJ([mktime]) gl_PREREQ_MKTIME fi	mktime
parse-datetime	#include "parse-datetime.h"	parse-datetime.y	bison.m4 tm_gmtoff.m4 parse-datetime.m4 00gnulib.m4 gl_PARSE_DATETIME	c-ctype stdbool gettime intprops mktime setenv unsetenv time verify xalloc
timegm	#include <time.h>	mktime-internal.h timegm.c	timegm.m4 00gnulib.m4 gl_FUNC_TIMEGM if test $HAVE_TIMEGM = 0 \|\| test $REPLACE_TIMEGM = 1; then AC_LIBOBJ([timegm]) gl_PREREQ_TIMEGM fi gl_TIME_MODULE_INDICATOR([timegm])	time 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.m4 00gnulib.m4 gl_FUNC_TZSET	gettimeofday

Input/Output <stdio.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
unlocked-io	#include "unlocked-io.h"	---	unlocked-io.m4 00gnulib.m4 gl_FUNC_GLIBC_UNLOCKED_IO	extensions
fwriteerror	#include "fwriteerror.h"	fwriteerror.c	00gnulib.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 longlong.m4 intmax_t.m4 stdint_h.m4 inttypes_h.m4 vasnprintf.m4 printf.m4 math_h.m4 exponentd.m4 00gnulib.m4 gl_FUNC_VASNPRINTF	alloca-opt float stdint xsize errno memchr verify wchar
vasprintf	#include <stdio.h>	vasprintf.c asprintf.c	vasprintf.m4 00gnulib.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 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])])	error exitfail gettext-h stdarg stdio
xvasprintf	#include "xvasprintf.h"	xvasprintf.c xasprintf.c xalloc.h	xvasprintf.m4 00gnulib.m4 gl_XVASPRINTF m4_ifdef([AM_XGETTEXT_OPTION], [AM_][XGETTEXT_OPTION([--flag=xasprintf:1:c-format])])	vasprintf xalloc-die 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 gl_FATAL_SIGNAL	xalloc stdbool unistd sigaction sigprocmask raise
raise	#include <signal.h>	raise.c	raise.m4 00gnulib.m4 gl_FUNC_RAISE if test $HAVE_RAISE = 0 \|\| test $REPLACE_RAISE = 1; then AC_LIBOBJ([raise]) gl_PREREQ_RAISE fi gl_SIGNAL_MODULE_INDICATOR([raise])	signal-h msvc-inval [test $HAVE_RAISE = 0 \|\| test $REPLACE_RAISE = 1]
strsignal	#include <string.h>	strsignal.c siglist.h	strsignal.m4 00gnulib.m4 gl_FUNC_STRSIGNAL if test $HAVE_STRSIGNAL = 0 \|\| test $REPLACE_STRSIGNAL = 1; then AC_LIBOBJ([strsignal]) gl_PREREQ_STRSIGNAL fi 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]

Command-line arguments

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
argmatch	#include "argmatch.h"	argmatch.c	00gnulib.m4	gettext-h error quotearg quote exitfail verify stdbool stdlib memcmp
argv-iter	#include "argv-iter.h"	argv-iter.c	00gnulib.m4	getdelim snippet/arg-nonnull stdbool
version-etc	#include "version-etc.h"	version-etc.c	version-etc.m4 00gnulib.m4 gl_VERSION_ETC	gettext-h stdarg
version-etc-fsf	---	version-etc-fsf.c	00gnulib.m4	version-etc
long-options	#include "long-options.h"	long-options.c	00gnulib.m4	getopt-gnu 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	extern-inline stdbool
xlist	#include "gl_xlist.h"	gl_xlist.c	00gnulib.m4	list extern-inline stdbool xalloc-die
array-list	#include "gl_array_list.h"	gl_array_list.c	00gnulib.m4	list xsize
carray-list	#include "gl_carray_list.h"	gl_carray_list.c	00gnulib.m4	list xsize
linked-list	#include "gl_linked_list.h"	gl_linked_list.c gl_anylinked_list1.h gl_anylinked_list2.h	00gnulib.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	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	list
linkedhash-list	#include "gl_linkedhash_list.h"	gl_linkedhash_list.c gl_anyhash_list1.h gl_anyhash_list2.h gl_anylinked_list1.h gl_anylinked_list2.h	00gnulib.m4	list stdint xsize
avltreehash-list	#include "gl_avltreehash_list.h"	gl_avltreehash_list.c gl_anyhash_list1.h gl_anyhash_list2.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	list avltree-oset stdint xsize
rbtreehash-list	#include "gl_rbtreehash_list.h"	gl_rbtreehash_list.c gl_anyhash_list1.h gl_anyhash_list2.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	list rbtree-oset stdint xsize
sublist	#include "gl_sublist.h"	gl_sublist.c	00gnulib.m4	list
xsublist	#include "gl_xsublist.h"	gl_xsublist.c	00gnulib.m4	sublist extern-inline xalloc-die
oset	#include "gl_oset.h"	gl_oset.c	00gnulib.m4	extern-inline stdbool
xoset	#include "gl_xoset.h"	gl_xoset.c	00gnulib.m4	oset extern-inline stdbool xalloc-die
array-oset	#include "gl_array_oset.h"	gl_array_oset.c	00gnulib.m4	oset xsize
avltree-oset	#include "gl_avltree_oset.h"	gl_avltree_oset.c gl_anytree_oset.h	00gnulib.m4	oset
rbtree-oset	#include "gl_rbtree_oset.h"	gl_rbtree_oset.c gl_anytree_oset.h	00gnulib.m4	oset

Cryptographic computations (low-level)

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
crypto/arcfour	#include "arcfour.h"	arcfour.c	00gnulib.m4	stdint
crypto/arctwo	#include "arctwo.h"	arctwo.c	arctwo.m4 00gnulib.m4 gl_ARCTWO	stdint bitrotate
crypto/des	#include "des.h"	des.c	00gnulib.m4	stdint stdbool memcmp
crypto/hmac-md5	#include "hmac.h"	hmac-md5.c	00gnulib.m4	memxor crypto/md5
crypto/hmac-sha1	#include "hmac.h"	hmac-sha1.c	00gnulib.m4	memxor crypto/sha1
crypto/md2	#include "md2.h"	md2.c	00gnulib.m4	minmax
crypto/md4	#include "md4.h"	md4.c	md4.m4 00gnulib.m4 gl_MD4	stdalign stdint
crypto/md5	#include "md5.h"	gl_openssl.h md5.c	gl-openssl.m4 md5.m4 00gnulib.m4 gl_MD5	extern-inline stdalign 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	stdint
crypto/sha1	#include "sha1.h"	gl_openssl.h sha1.c	gl-openssl.m4 sha1.m4 00gnulib.m4 gl_SHA1	extern-inline stdalign stdint
crypto/sha256	#include "sha256.h"	gl_openssl.h sha256.c	gl-openssl.m4 sha256.m4 00gnulib.m4 gl_SHA256	extern-inline stdalign stdint
crypto/sha512	#include "sha512.h"	gl_openssl.h sha512.c	gl-openssl.m4 sha512.m4 00gnulib.m4 gl_SHA512	extern-inline stdalign stdint u64

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 00gnulib.m4 gl_GC if test "$ac_cv_libgcrypt" = yes; then AC_LIBOBJ([gc-libgcrypt]) else AC_LIBOBJ([gc-gnulib]) fi if test $gl_cond_libtool = false; then gl_ltlibdeps="$gl_ltlibdeps $LTLIBGCRYPT" gl_libdeps="$gl_libdeps $LIBGCRYPT" fi	havelib
crypto/gc-arcfour	#include "gc.h"	---	gc-arcfour.m4 00gnulib.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 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 gl_GC_CAMELLIA	crypto/gc
crypto/gc-des	#include "gc.h"	---	gc-des.m4 00gnulib.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 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 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 gl_GC_MD2 gl_MODULE_INDICATOR([gc-md2])	crypto/gc crypto/md2
crypto/gc-md4	#include "gc.h"	---	gc-md4.m4 00gnulib.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 gl_GC_MD5 gl_MODULE_INDICATOR([gc-md5])	crypto/gc crypto/md5 [test "$ac_cv_libgcrypt" != yes]
crypto/gc-pbkdf2-sha1	#include "gc.h"	gc-pbkdf2-sha1.c	00gnulib.m4	crypto/gc crypto/gc-hmac-sha1
crypto/gc-random	#include "gc.h"	---	gc-random.m4 00gnulib.m4 gl_GC_RANDOM gl_MODULE_INDICATOR([gc-random])	crypto/gc
crypto/gc-rijndael	#include "gc.h"	---	gc-rijndael.m4 00gnulib.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 gl_GC_SHA1 gl_MODULE_INDICATOR([gc-sha1])	crypto/gc crypto/sha1 [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	---

Misc

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
base32	#include "base32.h"	base32.c	base32.m4 00gnulib.m4 gl_FUNC_BASE32	stdbool memchr
base64	#include "base64.h"	base64.c	base64.m4 00gnulib.m4 gl_FUNC_BASE64	stdbool memchr
check-version	#include "check-version.h"	check-version.c	00gnulib.m4	strverscmp
crc	#include "crc.h"	crc.c	00gnulib.m4	stdint
diacrit	#include "diacrit.h"	diacrit.c	00gnulib.m4	---
diffseq	#include "diffseq.h"	---	00gnulib.m4	---
execinfo	#include <execinfo.h>	execinfo.c execinfo.in.h	execinfo.m4 00gnulib.m4 gl_EXECINFO_H	extern-inline
getline	#include <stdio.h>	getline.c	getline.m4 00gnulib.m4 gl_FUNC_GETLINE if test $REPLACE_GETLINE = 1; then AC_LIBOBJ([getline]) gl_PREREQ_GETLINE fi gl_STDIO_MODULE_INDICATOR([getline])	stdio extensions getdelim [test $REPLACE_GETLINE = 1]
getdelim	#include <stdio.h>	getdelim.c	getdelim.m4 00gnulib.m4 gl_FUNC_GETDELIM if test $HAVE_GETDELIM = 0 \|\| test $REPLACE_GETDELIM = 1; then AC_LIBOBJ([getdelim]) gl_PREREQ_GETDELIM fi gl_STDIO_MODULE_INDICATOR([getdelim])	stdio extensions stdint [test $HAVE_GETDELIM = 0 \|\| test $REPLACE_GETDELIM = 1] realloc-posix [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 gl_GETNLINE	getndelim2 ssize_t
getndelim2	#include "getndelim2.h"	getndelim2.c	getndelim2.m4 00gnulib.m4 gl_GETNDELIM2	ssize_t stdbool stdint freadptr freadseek memchr2
linebuffer	#include "linebuffer.h"	linebuffer.c	00gnulib.m4	xalloc
memxor	#include "memxor.h"	memxor.c	memxor.m4 00gnulib.m4 gl_MEMXOR	---
obstack	#include "obstack.h"	obstack.c	obstack.m4 00gnulib.m4 AC_FUNC_OBSTACK dnl Note: AC_FUNC_OBSTACK does AC_LIBSOURCES([obstack.h, obstack.c]).	alignof gettext-h exitfail stdint stdlib
obstack-printf	#include <stdio.h>	obstack_printf.c	obstack-printf.m4 00gnulib.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 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	---
hash-pjw-bare	#include "hash-pjw-bare.h"	hash-pjw-bare.c	00gnulib.m4	---
hash	#include "hash.h"	hash.c	00gnulib.m4	bitrotate stdbool stdint xalloc-oversized
readline	#include "readline.h"	readline.c	readline.m4 00gnulib.m4 gl_FUNC_READLINE if test "$gl_cv_lib_readline" = no; then AC_LIBOBJ([readline]) gl_PREREQ_READLINE fi	havelib getline [test "$gl_cv_lib_readline" = no]
readtokens	#include "readtokens.h"	readtokens.c	readtokens.m4 00gnulib.m4 gl_READTOKENS	xalloc stdbool
readtokens0	#include "readtokens0.h"	readtokens0.c	00gnulib.m4	obstack stdbool
strverscmp	#include <string.h>	strverscmp.c	strverscmp.m4 00gnulib.m4 gl_FUNC_STRVERSCMP if test $HAVE_STRVERSCMP = 0; then AC_LIBOBJ([strverscmp]) gl_PREREQ_STRVERSCMP fi gl_STRING_MODULE_INDICATOR([strverscmp])	extensions string
filevercmp	#include "filevercmp.h"	filevercmp.c	00gnulib.m4	c-ctype stdbool string

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	---
flexmember	---	---	flexmember.m4 00gnulib.m4 AC_C_FLEXIBLE_ARRAY_MEMBER	---
fpucw	#include "fpucw.h"	---	00gnulib.m4	---
func	---	---	func.m4 00gnulib.m4 gl_FUNC	---
inline	---	---	inline.m4 00gnulib.m4 gl_INLINE	---
longlong	---	---	longlong.m4 00gnulib.m4 AC_REQUIRE([AC_TYPE_LONG_LONG_INT]) AC_REQUIRE([AC_TYPE_UNSIGNED_LONG_LONG_INT])	---
snippet/unused-parameter	---	---	00gnulib.m4	---
va-args	---	---	va-args.m4 00gnulib.m4 gl_VA_ARGS	---
vararrays	---	---	vararrays.m4 00gnulib.m4 AC_C_VARARRAYS	---
vla	---	vla.h	00gnulib.m4	vararrays

Sizes of integer types <limits.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
size_max	#include "size_max.h"	---	size_max.m4 00gnulib.m4 gl_SIZE_MAX	---

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 gl_STDARG_H	include_next

Boolean type and values <stdbool.h>

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

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 gl_STDDEF_H	include_next

Integer types and values <stdint.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
stdint	#include <stdint.h>	stdint.in.h	stdint.m4 longlong.m4 00gnulib.m4 gl_STDINT_H	include_next 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_h.m4 00gnulib.m4 gl_STDIO_H	extensions 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 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 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 gl_FUNC__EXIT if test $HAVE__EXIT = 0; then AC_LIBOBJ([_Exit]) gl_PREREQ__EXIT fi gl_STDLIB_MODULE_INDICATOR([_Exit])	stdlib
atoll	#include <stdlib.h>	atoll.c	atoll.m4 longlong.m4 00gnulib.m4 gl_FUNC_ATOLL if test $HAVE_ATOLL = 0; then AC_LIBOBJ([atoll]) gl_PREREQ_ATOLL fi gl_STDLIB_MODULE_INDICATOR([atoll])	strtoll [test $HAVE_ATOLL = 0]
strtoll	#include <stdlib.h>	strtol.c strtoll.c	longlong.m4 strtoll.m4 00gnulib.m4 gl_FUNC_STRTOLL if test $HAVE_STRTOLL = 0; then AC_LIBOBJ([strtoll]) gl_PREREQ_STRTOLL fi gl_STDLIB_MODULE_INDICATOR([strtoll])	stdlib
strtoull	#include <stdlib.h>	strtol.c strtoul.c strtoull.c	longlong.m4 strtoull.m4 00gnulib.m4 gl_FUNC_STRTOULL if test $HAVE_STRTOULL = 0; then AC_LIBOBJ([strtoull]) gl_PREREQ_STRTOULL fi gl_STDLIB_MODULE_INDICATOR([strtoull])	stdlib

Unibyte characters <ctype.h>

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
ctype	#include <ctype.h>	ctype.in.h	ctype.m4 00gnulib.m4 gl_CTYPE_H	extern-inline 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 gl_FUNC_IMAXABS if test $ac_cv_func_imaxabs = no; then AC_LIBOBJ([imaxabs]) gl_PREREQ_IMAXABS fi gl_INTTYPES_MODULE_INDICATOR([imaxabs])	inttypes-incomplete
imaxdiv	#include <inttypes.h>	imaxdiv.c	imaxdiv.m4 00gnulib.m4 gl_FUNC_IMAXDIV if test $ac_cv_func_imaxdiv = no; then AC_LIBOBJ([imaxdiv]) gl_PREREQ_IMAXDIV fi gl_INTTYPES_MODULE_INDICATOR([imaxdiv])	inttypes-incomplete
inttypes	#include <inttypes.h>	---	inttypes-pri.m4 00gnulib.m4 gl_INTTYPES_H	inttypes-incomplete extensions
strtoimax	#include <inttypes.h>	strtoimax.c	strtoimax.m4 longlong.m4 00gnulib.m4 gl_FUNC_STRTOIMAX if test $HAVE_DECL_STRTOIMAX = 0 \|\| test $REPLACE_STRTOIMAX = 1; then AC_LIBOBJ([strtoimax]) gl_PREREQ_STRTOIMAX fi gl_INTTYPES_MODULE_INDICATOR([strtoimax])	inttypes-incomplete verify [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	longlong.m4 strtoumax.m4 00gnulib.m4 gl_FUNC_STRTOUMAX if test $HAVE_DECL_STRTOUMAX = 0 \|\| test $REPLACE_STRTOUMAX = 1; then AC_LIBOBJ([strtoumax]) gl_PREREQ_STRTOUMAX fi gl_INTTYPES_MODULE_INDICATOR([strtoumax])	inttypes-incomplete verify [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 gl_FUNC_STRNCAT if test $REPLACE_STRNCAT = 1; then AC_LIBOBJ([strncat]) gl_PREREQ_STRNCAT fi 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 gl_WCHAR_H	include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use stddef
btowc	#include <wchar.h>	btowc.c	btowc.m4 locale-fr.m4 00gnulib.m4 gl_FUNC_BTOWC if test $HAVE_BTOWC = 0 \|\| test $REPLACE_BTOWC = 1; then AC_LIBOBJ([btowc]) gl_PREREQ_BTOWC fi gl_WCHAR_MODULE_INDICATOR([btowc])	wchar mbtowc [test $HAVE_BTOWC = 0 \|\| test $REPLACE_BTOWC = 1]
wctob	#include <wchar.h>	wctob.c	wctob.m4 locale-fr.m4 codeset.m4 00gnulib.m4 gl_FUNC_WCTOB if test $HAVE_WCTOB = 0 \|\| test $REPLACE_WCTOB = 1; then AC_LIBOBJ([wctob]) gl_PREREQ_WCTOB fi 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 gl_FUNC_MBSINIT if test $HAVE_MBSINIT = 0 \|\| test $REPLACE_MBSINIT = 1; then AC_LIBOBJ([mbsinit]) gl_PREREQ_MBSINIT fi gl_WCHAR_MODULE_INDICATOR([mbsinit])	wchar extensions mbrtowc [test $HAVE_MBSINIT = 0 \|\| test $REPLACE_MBSINIT = 1] verify [test $HAVE_MBSINIT = 0 \|\| test $REPLACE_MBSINIT = 1]
mbrlen	#include <wchar.h>	mbrlen.c	mbrlen.m4 mbstate_t.m4 00gnulib.m4 gl_FUNC_MBRLEN if test $HAVE_MBRLEN = 0 \|\| test $REPLACE_MBRLEN = 1; then AC_LIBOBJ([mbrlen]) gl_PREREQ_MBRLEN fi gl_WCHAR_MODULE_INDICATOR([mbrlen])	wchar extensions mbrtowc [test $HAVE_MBRLEN = 0 \|\| test $REPLACE_MBRLEN = 1]
mbrtowc	#include <wchar.h>	mbrtowc.c	mbrtowc.m4 mbstate_t.m4 locale-fr.m4 locale-ja.m4 locale-zh.m4 codeset.m4 00gnulib.m4 gl_FUNC_MBRTOWC if test $HAVE_MBRTOWC = 0 \|\| test $REPLACE_MBRTOWC = 1; then AC_LIBOBJ([mbrtowc]) gl_PREREQ_MBRTOWC fi gl_WCHAR_MODULE_INDICATOR([mbrtowc])	wchar extensions mbsinit [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] verify [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 locale-fr.m4 locale-ja.m4 locale-zh.m4 codeset.m4 00gnulib.m4 gl_FUNC_MBSRTOWCS if test $HAVE_MBSRTOWCS = 0 \|\| test $REPLACE_MBSRTOWCS = 1; then AC_LIBOBJ([mbsrtowcs]) AC_LIBOBJ([mbsrtowcs-state]) gl_PREREQ_MBSRTOWCS fi 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 gl_FUNC_WCRTOMB if test $HAVE_WCRTOMB = 0 \|\| test $REPLACE_WCRTOMB = 1; then AC_LIBOBJ([wcrtomb]) gl_PREREQ_WCRTOMB fi 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 gl_FUNC_WCSRTOMBS if test $HAVE_WCSRTOMBS = 0 \|\| test $REPLACE_WCSRTOMBS = 1; then AC_LIBOBJ([wcsrtombs]) AC_LIBOBJ([wcsrtombs-state]) gl_PREREQ_WCSRTOMBS fi 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 gl_FUNC_WCTYPE if test $HAVE_WCTYPE = 0; then AC_LIBOBJ([wctype]) fi gl_WCTYPE_MODULE_INDICATOR([wctype])	wctype-h iswblank [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 gl_FLOAT_H if test $REPLACE_FLOAT_LDBL = 1; then AC_LIBOBJ([float]) fi if test $REPLACE_ITOLD = 1; then AC_LIBOBJ([itold]) fi	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 gl_FUNC_ACOS	---
acosl	#include <math.h>	acosl.c	acosl.m4 00gnulib.m4 gl_FUNC_ACOSL if test $HAVE_ACOSL = 0; then AC_LIBOBJ([acosl]) fi 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 gl_FUNC_ASIN	---
asinl	#include <math.h>	asinl.c	asinl.m4 00gnulib.m4 gl_FUNC_ASINL if test $HAVE_ASINL = 0; then AC_LIBOBJ([asinl]) fi 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 gl_FUNC_ATAN	---
atan2	#include <math.h>	---	atan2.m4 mathfunc.m4 00gnulib.m4 gl_FUNC_ATAN2	---
atanl	#include <math.h>	atanl.c	atanl.m4 00gnulib.m4 gl_FUNC_ATANL if test $HAVE_ATANL = 0; then AC_LIBOBJ([atanl]) fi 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 gl_FUNC_CBRT if test $HAVE_CBRT = 0; then AC_LIBOBJ([cbrt]) fi 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 gl_FUNC_CEIL if test $REPLACE_CEIL = 1; then AC_LIBOBJ([ceil]) fi gl_MATH_MODULE_INDICATOR([ceil])	math float [test $REPLACE_CEIL = 1]
ceilf	#include <math.h>	ceilf.c ceil.c	ceilf.m4 00gnulib.m4 gl_FUNC_CEILF if test $HAVE_DECL_CEILF = 0 \|\| test $REPLACE_CEILF = 1; then AC_LIBOBJ([ceilf]) fi 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 gl_FUNC_CEILL if test $HAVE_DECL_CEILL = 0 \|\| test $REPLACE_CEILL = 1; then AC_LIBOBJ([ceill]) fi 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 gl_FUNC_COPYSIGN if test $HAVE_COPYSIGN = 0; then AC_LIBOBJ([copysign]) fi gl_MATH_MODULE_INDICATOR([copysign])	math signbit [test $HAVE_COPYSIGN = 0]
cos	#include <math.h>	---	cos.m4 mathfunc.m4 00gnulib.m4 gl_FUNC_COS	---
cosh	#include <math.h>	---	cosh.m4 mathfunc.m4 00gnulib.m4 gl_FUNC_COSH	---
cosl	#include <math.h>	cosl.c trigl.h sincosl.c trigl.c	cosl.m4 00gnulib.m4 gl_FUNC_COSL if test $HAVE_COSL = 0; then AC_LIBOBJ([cosl]) if test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0; then AC_LIBOBJ([sincosl]) AC_LIBOBJ([trigl]) fi 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 gl_COMMON_DOUBLE_MATHFUNC([erf])	---
erfc	#include <math.h>	---	mathfunc.m4 00gnulib.m4 gl_COMMON_DOUBLE_MATHFUNC([erfc])	---
exp	#include <math.h>	---	exp.m4 mathfunc.m4 00gnulib.m4 gl_FUNC_EXP	---
expl	#include <math.h>	expl.c expl-table.c	expl.m4 00gnulib.m4 gl_FUNC_EXPL if test $HAVE_EXPL = 0; then AC_LIBOBJ([expl]) AC_LIBOBJ([expl-table]) fi gl_MATH_MODULE_INDICATOR([expl])	math extensions exp [test $HAVE_EXPL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] float [test $HAVE_EXPL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] isnanl [test $HAVE_EXPL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] roundl [test $HAVE_EXPL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] ldexpl [test $HAVE_EXPL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
fabs	#include <math.h>	---	fabs.m4 mathfunc.m4 00gnulib.m4 gl_FUNC_FABS	---
floor	#include <math.h>	floor.c	floor.m4 00gnulib.m4 gl_FUNC_FLOOR if test $REPLACE_FLOOR = 1; then AC_LIBOBJ([floor]) fi gl_MATH_MODULE_INDICATOR([floor])	math float [test $REPLACE_FLOOR = 1]
floorf	#include <math.h>	floorf.c floor.c	floorf.m4 00gnulib.m4 gl_FUNC_FLOORF if test $HAVE_DECL_FLOORF = 0 \|\| test $REPLACE_FLOORF = 1; then AC_LIBOBJ([floorf]) fi 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 gl_FUNC_FLOORL if test $HAVE_DECL_FLOORL = 0 \|\| test $REPLACE_FLOORL = 1; then AC_LIBOBJ([floorl]) fi 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 gl_FUNC_FMOD if test $REPLACE_FMOD = 1; then AC_LIBOBJ([fmod]) fi 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 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 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 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 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 gl_FUNC_HYPOT if test $REPLACE_HYPOT = 1; then AC_LIBOBJ([hypot]) fi 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 gl_ISFINITE if test $REPLACE_ISFINITE = 1; then AC_LIBOBJ([isfinite]) fi 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 gl_ISINF if test $REPLACE_ISINF = 1; then AC_LIBOBJ([isinf]) fi gl_MATH_MODULE_INDICATOR([isinf])	math extensions float [test $REPLACE_ISINF = 1]
isnan	#include <math.h>	---	isnan.m4 00gnulib.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 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 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 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 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 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 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 gl_COMMON_DOUBLE_MATHFUNC([j0])	---
j1	#include <math.h>	---	mathfunc.m4 00gnulib.m4 gl_COMMON_DOUBLE_MATHFUNC([j1])	---
jn	#include <math.h>	---	mathfunc.m4 00gnulib.m4 gl_COMMON_DOUBLE_MATHFUNC([jn])	---
ldexp	#include <math.h>	---	ldexp.m4 00gnulib.m4 gl_FUNC_LDEXP	---
ldexpl	#include <math.h>	ldexpl.c	ldexpl.m4 00gnulib.m4 gl_FUNC_LDEXPL if test $HAVE_DECL_LDEXPL = 0 \|\| test $gl_func_ldexpl = no; then AC_LIBOBJ([ldexpl]) fi 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 gl_COMMON_DOUBLE_MATHFUNC([lgamma])	---
log	#include <math.h>	log.c	log.m4 mathfunc.m4 00gnulib.m4 AC_REQUIRE([gl_FUNC_LOG]) if test $REPLACE_LOG = 1; then AC_LIBOBJ([log]) fi gl_MATH_MODULE_INDICATOR([log])	math
log10	#include <math.h>	log10.c	log10.m4 mathfunc.m4 00gnulib.m4 gl_FUNC_LOG10 if test $REPLACE_LOG10 = 1; then AC_LIBOBJ([log10]) fi gl_MATH_MODULE_INDICATOR([log10])	math
log1p	#include <math.h>	log1p.c	log1p.m4 mathfunc.m4 00gnulib.m4 gl_FUNC_LOG1P if test $HAVE_LOG1P = 0 \|\| test $REPLACE_LOG1P = 1; then AC_LIBOBJ([log1p]) fi 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 gl_FUNC_LOGB if test $HAVE_LOGB = 0 \|\| test $REPLACE_LOGB = 1; then AC_LIBOBJ([logb]) fi 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 gl_FUNC_LOGL if test $HAVE_LOGL = 0 \|\| test $REPLACE_LOGL = 1; then AC_LIBOBJ([logl]) fi 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 gl_MATH_H	extern-inline include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use float
mathl	#include <math.h>	---	00gnulib.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 $ACOSL_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 gl_FUNC_MODF if test $REPLACE_MODF = 1; then AC_LIBOBJ([modf]) fi 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 gl_MATHFUNC([nextafter], [double], [(double, double)])	---
pow	#include <math.h>	---	pow.m4 mathfunc.m4 00gnulib.m4 gl_FUNC_POW	---
remainder	#include <math.h>	remainder.c	remainder.m4 mathfunc.m4 00gnulib.m4 gl_FUNC_REMAINDER if test $HAVE_REMAINDER = 0 \|\| test $REPLACE_REMAINDER = 1; then AC_LIBOBJ([remainder]) fi 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 gl_FUNC_RINT if test $HAVE_RINT = 0; then AC_LIBOBJ([rint]) fi gl_MATH_MODULE_INDICATOR([rint])	math
round	#include <math.h>	round.c	check-math-lib.m4 round.m4 floor.m4 ceil.m4 00gnulib.m4 gl_FUNC_ROUND if test $HAVE_ROUND = 0 \|\| test $REPLACE_ROUND = 1; then AC_LIBOBJ([round]) fi 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 gl_FUNC_ROUNDF if test $HAVE_ROUNDF = 0 \|\| test $REPLACE_ROUNDF = 1; then AC_LIBOBJ([roundf]) fi 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 gl_FUNC_ROUNDL if test $HAVE_ROUNDL = 0 \|\| test $REPLACE_ROUNDL = 1; then AC_LIBOBJ([roundl]) fi 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 gl_SIGNBIT if test $REPLACE_SIGNBIT = 1; then AC_LIBOBJ([signbitf]) AC_LIBOBJ([signbitd]) AC_LIBOBJ([signbitl]) fi 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 gl_FUNC_SIN	---
sinh	#include <math.h>	---	sinh.m4 mathfunc.m4 00gnulib.m4 gl_FUNC_SINH	---
sinl	#include <math.h>	sinl.c trigl.h sincosl.c trigl.c	sinl.m4 00gnulib.m4 gl_FUNC_SINL if test $HAVE_SINL = 0; then AC_LIBOBJ([sinl]) if test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0; then AC_LIBOBJ([sincosl]) AC_LIBOBJ([trigl]) fi 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 gl_FUNC_SQRT	---
sqrtl	#include <math.h>	sqrtl.c	sqrtl.m4 00gnulib.m4 gl_FUNC_SQRTL if test $HAVE_SQRTL = 0 \|\| test $REPLACE_SQRTL = 1; then AC_LIBOBJ([sqrtl]) fi 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 gl_FUNC_TAN	---
tanh	#include <math.h>	---	tanh.m4 mathfunc.m4 00gnulib.m4 gl_FUNC_TANH	---
tanl	#include <math.h>	tanl.c trigl.h trigl.c	tanl.m4 00gnulib.m4 gl_FUNC_TANL if test $HAVE_TANL = 0; then AC_LIBOBJ([tanl]) if test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0; then AC_LIBOBJ([trigl]) fi 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 gl_FUNC_TRUNC if test $HAVE_DECL_TRUNC = 0 \|\| test $REPLACE_TRUNC = 1; then AC_LIBOBJ([trunc]) fi 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 gl_FUNC_TRUNCF if test $HAVE_DECL_TRUNCF = 0 \|\| test $REPLACE_TRUNCF = 1; then AC_LIBOBJ([truncf]) fi 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 gl_FUNC_TRUNCL if test $HAVE_DECL_TRUNCL = 0 \|\| test $REPLACE_TRUNCL = 1; then AC_LIBOBJ([truncl]) fi 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 gl_COMMON_DOUBLE_MATHFUNC([y0])	---
y1	#include <math.h>	---	mathfunc.m4 00gnulib.m4 gl_COMMON_DOUBLE_MATHFUNC([y1])	---
yn	#include <math.h>	---	mathfunc.m4 00gnulib.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 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 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
dtoastr	#include "ftoastr.h"	ftoastr.c dtoastr.c	c-strtod.m4 00gnulib.m4 AC_REQUIRE([gl_C99_STRTOLD])	extensions intprops
ftoastr	#include "ftoastr.h"	ftoastr.c	c-strtod.m4 00gnulib.m4 AC_CHECK_FUNCS_ONCE([strtof]) AC_REQUIRE([gl_C99_STRTOLD])	extensions intprops
intprops	#include "intprops.h"	---	00gnulib.m4	---
inttostr	#include "inttostr.h"	anytostr.c imaxtostr.c inttostr.c offtostr.c umaxtostr.c uinttostr.c	inttostr.m4 00gnulib.m4 gl_INTTOSTR	intprops stdint
ldtoastr	#include "ftoastr.h"	ftoastr.c ldtoastr.c	c-strtod.m4 00gnulib.m4 AC_REQUIRE([gl_C99_STRTOLD])	extensions intprops
xstrtoimax	#include "xstrtol.h"	xstrtoimax.c	00gnulib.m4	xstrtol strtoimax
xstrtoumax	#include "xstrtol.h"	xstrtoumax.c	00gnulib.m4	xstrtol 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 gl_MBCHAR	extensions extern-inline stdbool wchar wctype-h iswblank wcwidth memcmp
mbiter	#include "mbiter.h"	mbiter.c	mbiter.m4 mbrtowc.m4 00gnulib.m4 gl_MBITER	extern-inline mbchar mbrtowc mbsinit wchar stdbool
mbuiter	#include "mbuiter.h"	mbuiter.c	mbiter.m4 mbrtowc.m4 00gnulib.m4 gl_MBITER	extern-inline mbchar mbrtowc mbsinit wchar stdbool strnlen1
mbfile	#include "mbfile.h"	mbfile.c	mbfile.m4 mbrtowc.m4 00gnulib.m4 gl_MBFILE	extern-inline mbchar mbrtowc mbsinit wchar stdbool

Support for systems lacking ISO C11

Core language properties

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

Support for obsolete systems lacking POSIX:2008

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
strdup	#include <string.h>	strdup.c	strdup.m4 00gnulib.m4 gl_FUNC_STRDUP if test $ac_cv_func_strdup = no; then AC_LIBOBJ([strdup]) gl_PREREQ_STRDUP fi 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 AC_REQUIRE([gl_HEADER_SYS_SOCKET]) if test "$ac_cv_header_winsock2_h" = yes; then AC_LIBOBJ([accept]) fi gl_SYS_SOCKET_MODULE_INDICATOR([accept])	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 gl_FUNC_ALPHASORT if test $HAVE_ALPHASORT = 0; then AC_LIBOBJ([alphasort]) gl_PREREQ_ALPHASORT fi gl_DIRENT_MODULE_INDICATOR([alphasort])	dirent extensions
arpa_inet	#include <arpa/inet.h>	arpa_inet.in.h	arpa_inet_h.m4 00gnulib.m4 gl_HEADER_ARPA_INET AC_PROG_MKDIR_P	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 AC_REQUIRE([gl_HEADER_SYS_SOCKET]) if test "$ac_cv_header_winsock2_h" = yes; then AC_LIBOBJ([bind]) fi 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 gl_FUNC_CALLOC_POSIX if test $REPLACE_CALLOC = 1; then AC_LIBOBJ([calloc]) fi gl_STDLIB_MODULE_INDICATOR([calloc-posix])	stdlib
chown	#include <unistd.h>	chown.c fchown-stub.c	chown.m4 00gnulib.m4 gl_FUNC_CHOWN if test $HAVE_CHOWN = 0 \|\| test $REPLACE_CHOWN = 1; then AC_LIBOBJ([chown]) fi if test $REPLACE_CHOWN = 1 && test $ac_cv_func_fchown = no; then AC_LIBOBJ([fchown-stub]) fi 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]
close	#include <unistd.h>	close.c	close.m4 00gnulib.m4 gl_FUNC_CLOSE if test $REPLACE_CLOSE = 1; then AC_LIBOBJ([close]) fi 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 AC_REQUIRE([gl_HEADER_SYS_SOCKET]) if test "$ac_cv_header_winsock2_h" = yes; then AC_LIBOBJ([connect]) fi 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 00gnulib.m4 gl_DIRENT_H	include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use
dprintf	#include <stdio.h>	dprintf.c	dprintf.m4 00gnulib.m4 gl_FUNC_DPRINTF gl_STDIO_MODULE_INDICATOR([dprintf])	stdio vasnprintf [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 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 gl_FUNC_DUP2 if test $HAVE_DUP2 = 0 \|\| test $REPLACE_DUP2 = 1; then AC_LIBOBJ([dup2]) gl_PREREQ_DUP2 fi gl_UNISTD_MODULE_INDICATOR([dup2])	unistd dup2-obsolete msvc-inval [test $HAVE_DUP2 = 0 \|\| test $REPLACE_DUP2 = 1] msvc-nothrow [test $HAVE_DUP2 = 0 \|\| test $REPLACE_DUP2 = 1]
duplocale	#include <locale.h>	duplocale.c	duplocale.m4 00gnulib.m4 gl_FUNC_DUPLOCALE if test $REPLACE_DUPLOCALE = 1; then AC_LIBOBJ([duplocale]) gl_PREREQ_DUPLOCALE fi gl_LOCALE_MODULE_INDICATOR([duplocale])	locale
environ	#include <unistd.h>	---	environ.m4 00gnulib.m4 gl_ENVIRON gl_UNISTD_MODULE_INDICATOR([environ])	unistd extensions
errno	#include <errno.h>	errno.in.h	errno_h.m4 00gnulib.m4 gl_HEADER_ERRNO_H	include_next
fchdir	#include <unistd.h>	fchdir.c	fchdir.m4 00gnulib.m4 gl_FUNC_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] dosname [test $HAVE_FCHDIR = 0] dup2 [test $HAVE_FCHDIR = 0] fcntl [test $HAVE_FCHDIR = 0] fcntl-h [test $HAVE_FCHDIR = 0] filenamecat-lgpl [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 gl_FUNC_FCLOSE if test $REPLACE_FCLOSE = 1; then AC_LIBOBJ([fclose]) fi 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 00gnulib.m4 gl_FCNTL_H	extensions 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 gl_FUNC_FCNTL if test $HAVE_FCNTL = 0 \|\| test $REPLACE_FCNTL = 1; then AC_LIBOBJ([fcntl]) fi 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 gl_FUNC_FDATASYNC if test $HAVE_FDATASYNC = 0; then AC_LIBOBJ([fdatasync]) fi gl_UNISTD_MODULE_INDICATOR([fdatasync])	fsync [test $HAVE_FDATASYNC = 0] unistd
flock	#include <sys/file.h>	flock.c	flock.m4 00gnulib.m4 gl_FUNC_FLOCK if test $HAVE_FLOCK = 0; then AC_LIBOBJ([flock]) gl_PREREQ_FLOCK fi gl_HEADER_SYS_FILE_MODULE_INDICATOR([flock])	sys_file msvc-nothrow [test $HAVE_FLOCK = 0]
fopen	#include <stdio.h>	fopen.c	fopen.m4 00gnulib.m4 gl_FUNC_FOPEN if test $REPLACE_FOPEN = 1; then AC_LIBOBJ([fopen]) gl_PREREQ_FOPEN fi gl_STDIO_MODULE_INDICATOR([fopen])	stdio largefile unistd [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 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] 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 gl_FUNC_FREOPEN if test $REPLACE_FREOPEN = 1; then AC_LIBOBJ([freopen]) gl_PREREQ_FREOPEN fi gl_STDIO_MODULE_INDICATOR([freopen])	stdio largefile
fseek	#include <stdio.h>	fseek.c	fseek.m4 00gnulib.m4 gl_FUNC_FSEEK if test $REPLACE_FSEEK = 1; then AC_LIBOBJ([fseek]) fi gl_STDIO_MODULE_INDICATOR([fseek])	stdio fseeko [test $REPLACE_FSEEK = 1]
fseeko	#include <stdio.h>	fseeko.c stdio-impl.h	fseeko.m4 00gnulib.m4 gl_FUNC_FSEEKO if test $HAVE_FSEEKO = 0 \|\| test $REPLACE_FSEEKO = 1; then AC_LIBOBJ([fseeko]) gl_PREREQ_FSEEKO fi gl_STDIO_MODULE_INDICATOR([fseeko])	extensions largefile lseek stdio sys_types fseek
fsync	#include <unistd.h>	fsync.c	fsync.m4 00gnulib.m4 gl_FUNC_FSYNC if test $HAVE_FSYNC = 0; then AC_LIBOBJ([fsync]) gl_PREREQ_FSYNC fi gl_UNISTD_MODULE_INDICATOR([fsync])	unistd msvc-nothrow [test $HAVE_FSYNC = 0]
ftell	#include <stdio.h>	ftell.c	ftell.m4 00gnulib.m4 gl_FUNC_FTELL if test $REPLACE_FTELL = 1; then AC_LIBOBJ([ftell]) fi 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 00gnulib.m4 gl_FUNC_FTELLO if test $HAVE_FTELLO = 0 \|\| test $REPLACE_FTELLO = 1; then AC_LIBOBJ([ftello]) gl_PREREQ_FTELLO fi gl_STDIO_MODULE_INDICATOR([ftello])	stdio extensions largefile sys_types lseek [test $HAVE_FTELLO = 0 \|\| test $REPLACE_FTELLO = 1] ftell
ftruncate	#include <unistd.h>	ftruncate.c	ftruncate.m4 00gnulib.m4 gl_FUNC_FTRUNCATE if test $HAVE_FTRUNCATE = 0 \|\| test $REPLACE_FTRUNCATE = 1; then AC_LIBOBJ([ftruncate]) gl_PREREQ_FTRUNCATE fi 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 gl_FUNC_FUTIMENS if test $HAVE_FUTIMENS = 0 \|\| test $REPLACE_FUTIMENS = 1; then AC_LIBOBJ([futimens]) fi 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 gl_GETADDRINFO if test $HAVE_GETADDRINFO = 0; then AC_LIBOBJ([getaddrinfo]) fi if test $HAVE_DECL_GAI_STRERROR = 0 \|\| test $REPLACE_GAI_STRERROR = 1; then AC_LIBOBJ([gai_strerror]) fi gl_NETDB_MODULE_INDICATOR([getaddrinfo])	netdb sys_socket extensions gettext-h [test $HAVE_GETADDRINFO = 0 \|\| test $HAVE_DECL_GAI_STRERROR = 0 \|\| test $REPLACE_GAI_STRERROR = 1] inet_ntop [test $HAVE_GETADDRINFO = 0] snprintf [test $HAVE_GETADDRINFO = 0] stdbool [test $HAVE_GETADDRINFO = 0] strdup [test $HAVE_GETADDRINFO = 0] servent [test $HAVE_GETADDRINFO = 0] hostent [test $HAVE_GETADDRINFO = 0] sockets [test $HAVE_GETADDRINFO = 0]
getcwd	#include <unistd.h>	getcwd.c	getcwd-abort-bug.m4 getcwd-path-max.m4 getcwd.m4 pathmax.m4 00gnulib.m4 gl_FUNC_GETCWD if test $REPLACE_GETCWD = 1; then AC_LIBOBJ([getcwd]) gl_PREREQ_GETCWD fi gl_MODULE_INDICATOR([getcwd]) gl_UNISTD_MODULE_INDICATOR([getcwd])	unistd extensions pathmax [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 gl_FUNC_GETCWD_LGPL if test $REPLACE_GETCWD = 1; then AC_LIBOBJ([getcwd-lgpl]) fi gl_UNISTD_MODULE_INDICATOR([getcwd])	unistd strdup [test $REPLACE_GETCWD = 1]
getgroups	#include <unistd.h>	getgroups.c	getgroups.m4 00gnulib.m4 gl_FUNC_GETGROUPS if test $HAVE_GETGROUPS = 0 \|\| test $REPLACE_GETGROUPS = 1; then AC_LIBOBJ([getgroups]) fi gl_UNISTD_MODULE_INDICATOR([getgroups])	unistd 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 gl_FUNC_GETHOSTNAME if test $HAVE_GETHOSTNAME = 0; then AC_LIBOBJ([gethostname]) gl_PREREQ_GETHOSTNAME fi 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 gl_FUNC_GETLOGIN if test $HAVE_GETLOGIN = 0; then AC_LIBOBJ([getlogin]) fi gl_UNISTD_MODULE_INDICATOR([getlogin])	unistd
getlogin_r	#include <unistd.h>	getlogin_r.c	getlogin_r.m4 00gnulib.m4 gl_FUNC_GETLOGIN_R if test $HAVE_GETLOGIN_R = 0 \|\| test $REPLACE_GETLOGIN_R = 1; then AC_LIBOBJ([getlogin_r]) gl_PREREQ_GETLOGIN_R fi gl_UNISTD_MODULE_INDICATOR([getlogin_r])	unistd extensions memchr [test $HAVE_GETLOGIN_R = 0 \|\| test $REPLACE_GETLOGIN_R = 1]
getopt-posix	#include <unistd.h>	getopt.in.h getopt.c getopt1.c getopt_int.h	getopt.m4 00gnulib.m4 gl_FUNC_GETOPT_POSIX if test $REPLACE_GETOPT = 1; then AC_LIBOBJ([getopt]) AC_LIBOBJ([getopt1]) gl_PREREQ_GETOPT dnl Arrange for unistd.h to include getopt.h. GNULIB_${gl_include_guard_prefix}_UNISTD_H_GETOPT=1 fi AC_SUBST([GNULIB_${gl_include_guard_prefix}_UNISTD_H_GETOPT])	unistd extensions include_next snippet/arg-nonnull gettext-h [test $REPLACE_GETOPT = 1]
getpeername	#include <sys/socket.h>	getpeername.c w32sock.h	00gnulib.m4 AC_REQUIRE([gl_HEADER_SYS_SOCKET]) if test "$ac_cv_header_winsock2_h" = yes; then AC_LIBOBJ([getpeername]) fi gl_SYS_SOCKET_MODULE_INDICATOR([getpeername])	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 AC_REQUIRE([gl_HEADER_SYS_SOCKET]) if test "$ac_cv_header_winsock2_h" = yes; then AC_LIBOBJ([getsockname]) fi gl_SYS_SOCKET_MODULE_INDICATOR([getsockname])	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 AC_REQUIRE([gl_HEADER_SYS_SOCKET]) if test "$ac_cv_header_winsock2_h" = yes; then AC_LIBOBJ([getsockopt]) fi gl_SYS_SOCKET_MODULE_INDICATOR([getsockopt])	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 gl_FUNC_GETSUBOPT if test $HAVE_GETSUBOPT = 0; then AC_LIBOBJ([getsubopt]) gl_PREREQ_GETSUBOPT fi gl_STDLIB_MODULE_INDICATOR([getsubopt])	stdlib extensions strchrnul [test $HAVE_GETSUBOPT = 0] memchr [test $HAVE_GETSUBOPT = 0]
gettimeofday	#include <sys/time.h>	gettimeofday.c	gettimeofday.m4 00gnulib.m4 gl_FUNC_GETTIMEOFDAY if test $HAVE_GETTIMEOFDAY = 0 \|\| test $REPLACE_GETTIMEOFDAY = 1; then AC_LIBOBJ([gettimeofday]) gl_PREREQ_GETTIMEOFDAY fi gl_SYS_TIME_MODULE_INDICATOR([gettimeofday])	sys_time
grantpt	#include <stdlib.h>	grantpt.c pty-private.h	grantpt.m4 00gnulib.m4 gl_FUNC_GRANTPT if test $HAVE_GRANTPT = 0; then AC_LIBOBJ([grantpt]) gl_PREREQ_GRANTPT fi 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 gl_HOSTENT	sys_socket
iconv-h	#include <iconv.h>	iconv.in.h	iconv_h.m4 00gnulib.m4 gl_ICONV_H	include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use
iconv_open	#include <iconv.h>	iconv_open.c iconv_open-aix.gperf iconv_open-hpux.gperf iconv_open-irix.gperf iconv_open-osf.gperf iconv_open-solaris.gperf iconv.c iconv_close.c	iconv_open.m4 00gnulib.m4 gl_FUNC_ICONV_OPEN if test $REPLACE_ICONV_OPEN = 1; then AC_LIBOBJ([iconv_open]) fi if test $REPLACE_ICONV = 1; then AC_LIBOBJ([iconv]) AC_LIBOBJ([iconv_close]) fi	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 gl_FUNC_INET_NTOP if test $HAVE_INET_NTOP = 0 \|\| test $REPLACE_INET_NTOP = 1; then AC_LIBOBJ([inet_ntop]) gl_PREREQ_INET_NTOP fi 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 gl_FUNC_INET_PTON if test $HAVE_INET_PTON = 0 \|\| test $REPLACE_INET_NTOP = 1; then AC_LIBOBJ([inet_pton]) gl_PREREQ_INET_PTON fi gl_ARPA_INET_MODULE_INDICATOR([inet_pton])	arpa_inet extensions c-ctype [test $HAVE_INET_PTON = 0 \|\| test $REPLACE_INET_NTOP = 1] sys_socket [test $HAVE_INET_PTON = 0 \|\| test $REPLACE_INET_NTOP = 1] errno [test $HAVE_INET_PTON = 0 \|\| test $REPLACE_INET_NTOP = 1] netinet_in [test $HAVE_INET_PTON = 0 \|\| test $REPLACE_INET_NTOP = 1]
ioctl	#include <sys/ioctl.h>	ioctl.c w32sock.h	ioctl.m4 00gnulib.m4 gl_FUNC_IOCTL if test $HAVE_IOCTL = 0 \|\| test $REPLACE_IOCTL = 1; then AC_LIBOBJ([ioctl]) fi 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 gl_FUNC_ISBLANK if test $HAVE_ISBLANK = 0; then AC_LIBOBJ([isblank]) fi gl_CTYPE_MODULE_INDICATOR([isblank])	extensions ctype
langinfo	#include <langinfo.h>	langinfo.in.h	langinfo_h.m4 00gnulib.m4 gl_LANGINFO_H	extensions include_next snippet/c++defs snippet/warn-on-use
link	#include <unistd.h>	link.c	link.m4 00gnulib.m4 gl_FUNC_LINK if test $HAVE_LINK = 0 \|\| test $REPLACE_LINK = 1; then AC_LIBOBJ([link]) fi gl_UNISTD_MODULE_INDICATOR([link])	unistd 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 gl_FUNC_LINKAT if test $HAVE_LINKAT = 0 \|\| test $REPLACE_LINKAT = 1; then AC_LIBOBJ([linkat]) AC_LIBOBJ([at-func2]) fi gl_UNISTD_MODULE_INDICATOR([linkat])	unistd extensions dirname-lgpl [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] link-follow [test $HAVE_LINKAT = 0 \|\| test $REPLACE_LINKAT = 1] areadlink [test $HAVE_LINKAT = 0 \|\| test $REPLACE_LINKAT = 1] at-internal [test $HAVE_LINKAT = 0 \|\| test $REPLACE_LINKAT = 1] dosname [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] openat-h [test $HAVE_LINKAT = 0 \|\| test $REPLACE_LINKAT = 1] openat-die [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] same-inode [test $HAVE_LINKAT = 0 \|\| test $REPLACE_LINKAT = 1] save-cwd [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 AC_REQUIRE([gl_HEADER_SYS_SOCKET]) if test "$ac_cv_header_winsock2_h" = yes; then AC_LIBOBJ([listen]) fi 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 gl_LOCALE_H	extensions include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use stddef
lseek	#include <unistd.h>	lseek.c	lseek.m4 00gnulib.m4 gl_FUNC_LSEEK if test $REPLACE_LSEEK = 1; then AC_LIBOBJ([lseek]) fi gl_UNISTD_MODULE_INDICATOR([lseek])	unistd sys_types largefile msvc-nothrow [test $REPLACE_LSEEK = 1] fstat [test $REPLACE_LSEEK = 1]
lstat	#include <sys/stat.h>	lstat.c	lstat.m4 00gnulib.m4 gl_FUNC_LSTAT if test $REPLACE_LSTAT = 1; then AC_LIBOBJ([lstat]) gl_PREREQ_LSTAT fi gl_SYS_STAT_MODULE_INDICATOR([lstat])	sys_stat largefile dosname [test $REPLACE_LSTAT = 1] stat [test $REPLACE_LSTAT = 1]
malloc-posix	#include <stdlib.h>	malloc.c	malloc.m4 00gnulib.m4 gl_FUNC_MALLOC_POSIX if test $REPLACE_MALLOC = 1; then AC_LIBOBJ([malloc]) fi gl_STDLIB_MODULE_INDICATOR([malloc-posix])	stdlib
mbsnrtowcs	#include <wchar.h>	mbsnrtowcs.c mbsnrtowcs-impl.h mbsrtowcs-state.c	mbsnrtowcs.m4 mbstate_t.m4 00gnulib.m4 gl_FUNC_MBSNRTOWCS if test $HAVE_MBSNRTOWCS = 0 \|\| test $REPLACE_MBSNRTOWCS = 1; then AC_LIBOBJ([mbsnrtowcs]) AC_LIBOBJ([mbsrtowcs-state]) gl_PREREQ_MBSNRTOWCS fi 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 gl_FUNC_MKDIR if test $REPLACE_MKDIR = 1; then AC_LIBOBJ([mkdir]) fi	sys_stat dirname-lgpl [test $REPLACE_MKDIR = 1]
mkdtemp	#include <stdlib.h>	mkdtemp.c	mkdtemp.m4 00gnulib.m4 gl_FUNC_MKDTEMP if test $HAVE_MKDTEMP = 0; then AC_LIBOBJ([mkdtemp]) gl_PREREQ_MKDTEMP fi 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 gl_FUNC_MKFIFO if test $HAVE_MKFIFO = 0 \|\| test $REPLACE_MKFIFO = 1; then AC_LIBOBJ([mkfifo]) fi 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 gl_FUNC_MKNOD if test $HAVE_MKNOD = 0 \|\| test $REPLACE_MKNOD = 1; then AC_LIBOBJ([mknod]) fi 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 gl_FUNC_MKSTEMP if test $HAVE_MKSTEMP = 0 \|\| test $REPLACE_MKSTEMP = 1; then AC_LIBOBJ([mkstemp]) gl_PREREQ_MKSTEMP fi 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 gl_HEADER_NET_IF AC_PROG_MKDIR_P	include_next sys_socket
netdb	#include <netdb.h>	netdb.in.h	netdb_h.m4 00gnulib.m4 gl_HEADER_NETDB	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 gl_HEADER_NETINET_IN AC_PROG_MKDIR_P	include_next sys_socket
nl_langinfo	#include <langinfo.h>	nl_langinfo.c	nl_langinfo.m4 00gnulib.m4 gl_FUNC_NL_LANGINFO if test $HAVE_NL_LANGINFO = 0 \|\| test $REPLACE_NL_LANGINFO = 1; then AC_LIBOBJ([nl_langinfo]) fi gl_LANGINFO_MODULE_INDICATOR([nl_langinfo])	langinfo localeconv [test $HAVE_NL_LANGINFO = 0 \|\| test $REPLACE_NL_LANGINFO = 1]
open	#include <fcntl.h>	open.c	open.m4 mode_t.m4 00gnulib.m4 gl_FUNC_OPEN if test $REPLACE_OPEN = 1; then AC_LIBOBJ([open]) gl_PREREQ_OPEN fi gl_FCNTL_MODULE_INDICATOR([open])	fcntl-h largefile fstat [test $REPLACE_OPEN = 1] stat [test $REPLACE_OPEN = 1]
perror	#include <stdio.h>	perror.c	perror.m4 00gnulib.m4 gl_FUNC_PERROR if test $REPLACE_PERROR = 1; then AC_LIBOBJ([perror]) fi 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 gl_FUNC_POLL if test $HAVE_POLL = 0 \|\| test $REPLACE_POLL = 1; then AC_LIBOBJ([poll]) gl_PREREQ_POLL fi 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 gl_FUNC_POPEN if test $HAVE_POPEN = 0 \|\| test $REPLACE_POPEN = 1; then AC_LIBOBJ([popen]) gl_PREREQ_POPEN fi gl_STDIO_MODULE_INDICATOR([popen])	stdio open [test $HAVE_POPEN = 0 \|\| test $REPLACE_POPEN = 1]
posix_openpt	#include <stdlib.h>	posix_openpt.c	posix_openpt.m4 00gnulib.m4 gl_FUNC_POSIX_OPENPT if test $HAVE_POSIX_OPENPT = 0; then AC_LIBOBJ([posix_openpt]) fi gl_STDLIB_MODULE_INDICATOR([posix_openpt])	extensions stdlib
posix_spawn	#include <spawn.h>	spawn.c	posix_spawn.m4 00gnulib.m4 gl_POSIX_SPAWN if test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1; then AC_LIBOBJ([spawn]) AC_LIBOBJ([spawni]) gl_PREREQ_POSIX_SPAWN_INTERNAL fi 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 gl_POSIX_SPAWN if test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1; then AC_LIBOBJ([spawnattr_destroy]) fi gl_SPAWN_MODULE_INDICATOR([posix_spawnattr_destroy])	spawn
posix_spawnattr_getflags	#include <spawn.h>	spawnattr_getflags.c	posix_spawn.m4 00gnulib.m4 gl_POSIX_SPAWN if test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1; then AC_LIBOBJ([spawnattr_getflags]) fi gl_SPAWN_MODULE_INDICATOR([posix_spawnattr_getflags])	spawn
posix_spawnattr_getpgroup	#include <spawn.h>	spawnattr_getpgroup.c	posix_spawn.m4 00gnulib.m4 gl_POSIX_SPAWN if test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1; then AC_LIBOBJ([spawnattr_getpgroup]) fi gl_SPAWN_MODULE_INDICATOR([posix_spawnattr_getpgroup])	spawn
posix_spawnattr_getschedparam	#include <spawn.h>	spawnattr_getschedparam.c	posix_spawn.m4 00gnulib.m4 gl_POSIX_SPAWN if test $HAVE_POSIX_SPAWN = 0 \ \|\| test $REPLACE_POSIX_SPAWN = 1 \ \|\| test $gl_cv_func_spawnattr_setschedparam = no; then AC_LIBOBJ([spawnattr_getschedparam]) fi gl_SPAWN_MODULE_INDICATOR([posix_spawnattr_getschedparam])	spawn
posix_spawnattr_getschedpolicy	#include <spawn.h>	spawnattr_getschedpolicy.c	posix_spawn.m4 00gnulib.m4 gl_POSIX_SPAWN if test $HAVE_POSIX_SPAWN = 0 \ \|\| test $REPLACE_POSIX_SPAWN = 1 \ \|\| test $gl_cv_func_spawnattr_setschedpolicy = no; then AC_LIBOBJ([spawnattr_getschedpolicy]) fi gl_SPAWN_MODULE_INDICATOR([posix_spawnattr_getschedpolicy])	spawn
posix_spawnattr_getsigdefault	#include <spawn.h>	spawnattr_getdefault.c	posix_spawn.m4 00gnulib.m4 gl_POSIX_SPAWN if test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1; then AC_LIBOBJ([spawnattr_getdefault]) fi gl_SPAWN_MODULE_INDICATOR([posix_spawnattr_getsigdefault])	spawn
posix_spawnattr_getsigmask	#include <spawn.h>	spawnattr_getsigmask.c	posix_spawn.m4 00gnulib.m4 gl_POSIX_SPAWN if test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1; then AC_LIBOBJ([spawnattr_getsigmask]) fi gl_SPAWN_MODULE_INDICATOR([posix_spawnattr_getsigmask])	spawn
posix_spawnattr_init	#include <spawn.h>	spawnattr_init.c	posix_spawn.m4 00gnulib.m4 gl_POSIX_SPAWN if test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1; then AC_LIBOBJ([spawnattr_init]) fi gl_SPAWN_MODULE_INDICATOR([posix_spawnattr_init])	spawn
posix_spawnattr_setflags	#include <spawn.h>	spawnattr_setflags.c	posix_spawn.m4 00gnulib.m4 gl_POSIX_SPAWN if test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1; then AC_LIBOBJ([spawnattr_setflags]) fi gl_SPAWN_MODULE_INDICATOR([posix_spawnattr_setflags])	spawn
posix_spawnattr_setpgroup	#include <spawn.h>	spawnattr_setpgroup.c	posix_spawn.m4 00gnulib.m4 gl_POSIX_SPAWN if test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1; then AC_LIBOBJ([spawnattr_setpgroup]) fi gl_SPAWN_MODULE_INDICATOR([posix_spawnattr_setpgroup])	spawn
posix_spawnattr_setschedparam	#include <spawn.h>	spawnattr_setschedparam.c	posix_spawn.m4 00gnulib.m4 gl_POSIX_SPAWN if test $HAVE_POSIX_SPAWN = 0 \ \|\| test $REPLACE_POSIX_SPAWN = 1 \ \|\| test $gl_cv_func_spawnattr_setschedparam = no; then AC_LIBOBJ([spawnattr_setschedparam]) fi gl_SPAWN_MODULE_INDICATOR([posix_spawnattr_setschedparam])	spawn
posix_spawnattr_setschedpolicy	#include <spawn.h>	spawnattr_setschedpolicy.c	posix_spawn.m4 00gnulib.m4 gl_POSIX_SPAWN if test $HAVE_POSIX_SPAWN = 0 \ \|\| test $REPLACE_POSIX_SPAWN = 1 \ \|\| test $gl_cv_func_spawnattr_setschedpolicy = no; then AC_LIBOBJ([spawnattr_setschedpolicy]) fi gl_SPAWN_MODULE_INDICATOR([posix_spawnattr_setschedpolicy])	spawn
posix_spawnattr_setsigdefault	#include <spawn.h>	spawnattr_setdefault.c	posix_spawn.m4 00gnulib.m4 gl_POSIX_SPAWN if test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1; then AC_LIBOBJ([spawnattr_setdefault]) fi gl_SPAWN_MODULE_INDICATOR([posix_spawnattr_setsigdefault])	spawn
posix_spawnattr_setsigmask	#include <spawn.h>	spawnattr_setsigmask.c	posix_spawn.m4 00gnulib.m4 gl_POSIX_SPAWN if test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1; then AC_LIBOBJ([spawnattr_setsigmask]) fi 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 gl_FUNC_POSIX_SPAWN_FILE_ACTIONS_ADDCLOSE if test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDCLOSE = 1; then AC_LIBOBJ([spawn_faction_addclose]) fi gl_SPAWN_MODULE_INDICATOR([posix_spawn_file_actions_addclose])	spawn getdtablesize [test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDCLOSE = 1] posix_spawn_file_actions_init [test $HAVE_POSIX_SPAWN = 0 \|\| 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 gl_FUNC_POSIX_SPAWN_FILE_ACTIONS_ADDDUP2 if test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDDUP2 = 1; then AC_LIBOBJ([spawn_faction_adddup2]) fi gl_SPAWN_MODULE_INDICATOR([posix_spawn_file_actions_adddup2])	spawn getdtablesize [test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDDUP2 = 1] posix_spawn_file_actions_init [test $HAVE_POSIX_SPAWN = 0 \|\| 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 gl_FUNC_POSIX_SPAWN_FILE_ACTIONS_ADDOPEN if test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDOPEN = 1; then AC_LIBOBJ([spawn_faction_addopen]) fi gl_SPAWN_MODULE_INDICATOR([posix_spawn_file_actions_addopen])	spawn getdtablesize [test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDOPEN = 1] posix_spawn_file_actions_init [test $HAVE_POSIX_SPAWN = 0 \|\| 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 gl_POSIX_SPAWN if test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1; then AC_LIBOBJ([spawn_faction_destroy]) fi 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 gl_POSIX_SPAWN if test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1; then AC_LIBOBJ([spawn_faction_init]) fi gl_SPAWN_MODULE_INDICATOR([posix_spawn_file_actions_init])	spawn
posix_spawn-internal	---	spawni.c spawn_int.h	posix_spawn.m4 00gnulib.m4	spawn alloca-opt dup2 errno open strchrnul
posix_spawnp	#include <spawn.h>	spawnp.c	posix_spawn.m4 00gnulib.m4 gl_POSIX_SPAWN if test $HAVE_POSIX_SPAWN = 0 \|\| test $REPLACE_POSIX_SPAWN = 1; then AC_LIBOBJ([spawnp]) AC_LIBOBJ([spawni]) gl_PREREQ_POSIX_SPAWN_INTERNAL fi 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 gl_FUNC_PREAD if test $HAVE_PREAD = 0 \|\| test $REPLACE_PREAD = 1; then AC_LIBOBJ([pread]) fi 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-rpl.m4 printf.m4 asm-underscore.m4 00gnulib.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 gl_FUNC_PSELECT if test $HAVE_PSELECT = 0 \|\| test $REPLACE_PSELECT = 1; then AC_LIBOBJ([pselect]) fi 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>	pthread.c pthread.in.h	pthread.m4 00gnulib.m4 gl_PTHREAD_CHECK gl_MODULE_INDICATOR([pthread])	extensions extern-inline sched time
ptsname	#include <stdlib.h>	ptsname.c	ptsname.m4 00gnulib.m4 gl_FUNC_PTSNAME if test $HAVE_PTSNAME = 0 \|\| test $REPLACE_PTSNAME = 1; then AC_LIBOBJ([ptsname]) gl_PREREQ_PTSNAME fi gl_STDLIB_MODULE_INDICATOR([ptsname])	stdlib extensions ptsname_r [test $HAVE_PTSNAME = 0]
pwrite	#include <unistd.h>	pwrite.c	pwrite.m4 00gnulib.m4 gl_FUNC_PWRITE if test $HAVE_PWRITE = 0 \|\| test $REPLACE_PWRITE = 1; then AC_LIBOBJ([pwrite]) fi 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 gl_FUNC_READLINK if test $HAVE_READLINK = 0 \|\| test $REPLACE_READLINK = 1; then AC_LIBOBJ([readlink]) gl_PREREQ_READLINK fi 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 gl_FUNC_REALLOC_POSIX if test $REPLACE_REALLOC = 1; then AC_LIBOBJ([realloc]) fi gl_STDLIB_MODULE_INDICATOR([realloc-posix])	stdlib
recv	#include <sys/socket.h>	recv.c w32sock.h	00gnulib.m4 AC_REQUIRE([gl_HEADER_SYS_SOCKET]) if test "$ac_cv_header_winsock2_h" = yes; then AC_LIBOBJ([recv]) fi 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 AC_REQUIRE([gl_HEADER_SYS_SOCKET]) if test "$ac_cv_header_winsock2_h" = yes; then AC_LIBOBJ([recvfrom]) fi gl_SYS_SOCKET_MODULE_INDICATOR([recvfrom])	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 gl_FUNC_REMOVE if test $REPLACE_REMOVE = 1; then AC_LIBOBJ([remove]) fi 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 gl_FUNC_SCANDIR if test $HAVE_SCANDIR = 0; then AC_LIBOBJ([scandir]) gl_PREREQ_SCANDIR fi gl_DIRENT_MODULE_INDICATOR([scandir])	closedir dirent extensions largefile opendir readdir
sched	#include <sched.h>	sched.in.h	sched_h.m4 00gnulib.m4 gl_SCHED_H	include_next
select	#include <sys/select.h>	select.c	select.m4 00gnulib.m4 gl_FUNC_SELECT if test $REPLACE_SELECT = 1; then AC_LIBOBJ([select]) fi 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 AC_REQUIRE([gl_HEADER_SYS_SOCKET]) if test "$ac_cv_header_winsock2_h" = yes; then AC_LIBOBJ([send]) fi 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 AC_REQUIRE([gl_HEADER_SYS_SOCKET]) if test "$ac_cv_header_winsock2_h" = yes; then AC_LIBOBJ([sendto]) fi 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 gl_SERVENT	sys_socket
setsockopt	#include <sys/socket.h>	setsockopt.c w32sock.h	00gnulib.m4 AC_REQUIRE([gl_HEADER_SYS_SOCKET]) if test "$ac_cv_header_winsock2_h" = yes; then AC_LIBOBJ([setsockopt]) fi 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 AC_REQUIRE([gl_HEADER_SYS_SOCKET]) if test "$ac_cv_header_winsock2_h" = yes; then AC_LIBOBJ([shutdown]) fi 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 00gnulib.m4 gl_SIGNAL_H	include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use extensions
sleep	#include <unistd.h>	sleep.c	sleep.m4 00gnulib.m4 gl_FUNC_SLEEP if test $HAVE_SLEEP = 0 \|\| test $REPLACE_SLEEP = 1; then AC_LIBOBJ([sleep]) fi gl_UNISTD_MODULE_INDICATOR([sleep])	unistd stdint [test $HAVE_SLEEP = 0 \|\| test $REPLACE_SLEEP = 1] verify [test $HAVE_SLEEP = 0 \|\| test $REPLACE_SLEEP = 1]
snprintf-posix	#include <stdio.h>	---	snprintf-posix.m4 printf.m4 math_h.m4 00gnulib.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 AC_REQUIRE([gl_HEADER_SYS_SOCKET]) if test "$ac_cv_header_winsock2_h" = yes; then AC_LIBOBJ([socket]) fi # 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], [AC_REQUIRE([gl_UNISTD_H_DEFAULTS])]) m4_ifdef([gl_SYS_IOCTL_H_DEFAULTS], [AC_REQUIRE([gl_SYS_IOCTL_H_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 00gnulib.m4 gl_SPAWN_H	include_next sched 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 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.m4 00gnulib.m4 gl_FUNC_STAT if test $REPLACE_STAT = 1; then AC_LIBOBJ([stat]) gl_PREREQ_STAT fi gl_SYS_STAT_MODULE_INDICATOR([stat])	sys_stat largefile dosname [test $REPLACE_STAT = 1] pathmax [test $REPLACE_STAT = 1] stdbool [test $REPLACE_STAT = 1] verify [test $REPLACE_STAT = 1]
strdup-posix	#include <string.h>	strdup.c	strdup.m4 00gnulib.m4 gl_FUNC_STRDUP_POSIX if test $ac_cv_func_strdup = no \|\| test $REPLACE_STRDUP = 1; then AC_LIBOBJ([strdup]) gl_PREREQ_STRDUP fi gl_STRING_MODULE_INDICATOR([strdup])	string malloc-posix [test $ac_cv_func_strdup = no \|\| test $REPLACE_STRDUP = 1]
string	#include <string.h>	string.in.h	string_h.m4 00gnulib.m4 gl_HEADER_STRING_H	extensions extern-inline include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use stddef
strings	#include <strings.h>	strings.in.h	strings_h.m4 00gnulib.m4 gl_HEADER_STRINGS_H	include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use sys_types
tempname	#include "tempname.h"	tempname.c	tempname.m4 00gnulib.m4 gl_FUNC_GEN_TEMPNAME	extensions fcntl-h gettimeofday lstat secure_getenv stdint sys_stat sys_time
time	#include <time.h>	time.in.h	time_h.m4 00gnulib.m4 gl_HEADER_TIME_H	extensions gettimeofday include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use stddef
time_r	#include <time.h>	time_r.c	time_r.m4 00gnulib.m4 gl_TIME_R if test $HAVE_LOCALTIME_R = 0 \|\| test $REPLACE_LOCALTIME_R = 1; then AC_LIBOBJ([time_r]) gl_PREREQ_TIME_R fi gl_TIME_MODULE_INDICATOR([time_r])	extensions time
times	#include <sys/times.h>	times.c	times.m4 00gnulib.m4 gl_FUNC_TIMES if test $HAVE_TIMES = 0; then AC_LIBOBJ([times]) fi gl_SYS_TIMES_MODULE_INDICATOR([times])	sys_times
timespec	#include "timespec.h"	timespec.c	timespec.m4 00gnulib.m4 gl_TIMESPEC	extern-inline time
nanosleep	#include <time.h>	nanosleep.c	nanosleep.m4 00gnulib.m4 gl_FUNC_NANOSLEEP if test $HAVE_NANOSLEEP = 0 \|\| test $REPLACE_NANOSLEEP = 1; then AC_LIBOBJ([nanosleep]) gl_PREREQ_NANOSLEEP fi gl_TIME_MODULE_INDICATOR([nanosleep])	time extensions multiarch intprops [test $HAVE_NANOSLEEP = 0 \|\| test $REPLACE_NANOSLEEP = 1] select [test $HAVE_NANOSLEEP = 0 \|\| test $REPLACE_NANOSLEEP = 1] sigaction [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] sys_time [test $HAVE_NANOSLEEP = 0 \|\| test $REPLACE_NANOSLEEP = 1] verify [test $HAVE_NANOSLEEP = 0 \|\| test $REPLACE_NANOSLEEP = 1]
pthread_sigmask	#include <signal.h>	pthread_sigmask.c	pthread_sigmask.m4 00gnulib.m4 gl_FUNC_PTHREAD_SIGMASK if test $HAVE_PTHREAD_SIGMASK = 0 \|\| test $REPLACE_PTHREAD_SIGMASK = 1; then AC_LIBOBJ([pthread_sigmask]) gl_PREREQ_PTHREAD_SIGMASK fi 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 gl_REGEX if test $ac_use_included_regex = yes; then AC_LIBOBJ([regex]) gl_PREREQ_REGEX fi	extensions ssize_t alloca-opt [test $ac_use_included_regex = yes] btowc [test $ac_use_included_regex = yes] gettext-h [test $ac_use_included_regex = yes] lock [test "$ac_cv_gnu_library_2_1:$ac_use_included_regex" = no: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] 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 gl_FUNC_RENAME if test $REPLACE_RENAME = 1; then AC_LIBOBJ([rename]) fi gl_STDIO_MODULE_INDICATOR([rename])	stdio canonicalize-lgpl [test $REPLACE_RENAME = 1] chdir [test $REPLACE_RENAME = 1] dirname-lgpl [test $REPLACE_RENAME = 1] lstat [test $REPLACE_RENAME = 1] rmdir [test $REPLACE_RENAME = 1] same-inode [test $REPLACE_RENAME = 1] stdbool [test $REPLACE_RENAME = 1] strdup [test $REPLACE_RENAME = 1]
renameat	#include <fcntl.h> #include <stdio.h>	at-func2.c renameat.c	renameat.m4 00gnulib.m4 gl_FUNC_RENAMEAT if test $HAVE_RENAMEAT = 0 \|\| test $REPLACE_RENAMEAT = 1; then AC_LIBOBJ([renameat]) fi if test $HAVE_RENAMEAT = 0; then AC_LIBOBJ([at-func2]) fi gl_STDIO_MODULE_INDICATOR([renameat])	stdio extensions fcntl-h filenamecat-lgpl [test $HAVE_RENAMEAT = 0 \|\| test $REPLACE_RENAMEAT = 1] openat-h [test $HAVE_RENAMEAT = 0 \|\| test $REPLACE_RENAMEAT = 1] statat [test $REPLACE_RENAMEAT = 1] stdbool [test $REPLACE_RENAMEAT = 1] at-internal [test $HAVE_RENAMEAT = 0] dosname [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]
rmdir	#include <unistd.h>	rmdir.c	rmdir.m4 00gnulib.m4 gl_FUNC_RMDIR if test $REPLACE_RMDIR = 1; then AC_LIBOBJ([rmdir]) fi gl_UNISTD_MODULE_INDICATOR([rmdir])	unistd dosname [test $REPLACE_RMDIR = 1] sys_stat [test $REPLACE_RMDIR = 1]
search	#include <search.h>	search.in.h	search_h.m4 00gnulib.m4 gl_SEARCH_H	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 gl_SIGACTION if test $HAVE_SIGACTION = 0; then AC_LIBOBJ([sigaction]) gl_PREREQ_SIGACTION fi gl_SIGNAL_MODULE_INDICATOR([sigaction])	extern-inline signal-h sigprocmask [test $HAVE_SIGACTION = 0]
sigprocmask	#include <signal.h>	sigprocmask.c	signalblocking.m4 00gnulib.m4 gl_SIGNALBLOCKING if test $HAVE_POSIX_SIGNALBLOCKING = 0; then AC_LIBOBJ([sigprocmask]) gl_PREREQ_SIGPROCMASK fi 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 gl_TYPE_SOCKLEN_T	---
ssize_t	#include <sys/types.h>	---	ssize_t.m4 00gnulib.m4 gt_TYPE_SSIZE_T	---
strptime	#include <time.h>	strptime.c	strptime.m4 tm_gmtoff.m4 00gnulib.m4 gl_FUNC_STRPTIME if test $HAVE_STRPTIME = 0; then AC_LIBOBJ([strptime]) gl_PREREQ_STRPTIME fi gl_TIME_MODULE_INDICATOR([strptime])	time 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 gl_FUNC_STRTOK_R if test $HAVE_STRTOK_R = 0 \|\| test $REPLACE_STRTOK_R = 1; then AC_LIBOBJ([strtok_r]) gl_PREREQ_STRTOK_R fi 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 gl_HEADER_SYS_SELECT AC_PROG_MKDIR_P	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 AC_REQUIRE([gl_HEADER_SYS_SOCKET]) AC_PROG_MKDIR_P	errno extern-inline include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use socklen ssize_t stdalign sys_uio
sys_stat	#include <sys/stat.h>	sys_stat.in.h	sys_stat_h.m4 unistd_h.m4 00gnulib.m4 gl_HEADER_SYS_STAT_H AC_PROG_MKDIR_P	include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use sys_types time
sys_time	#include <sys/time.h>	sys_time.in.h	sys_time_h.m4 sys_socket_h.m4 00gnulib.m4 gl_HEADER_SYS_TIME_H AC_PROG_MKDIR_P	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 gl_SYS_TIMES_H AC_PROG_MKDIR_P	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 gl_HEADER_SYS_UIO AC_PROG_MKDIR_P	include_next ssize_t sys_types
sys_utsname	#include <sys/utsname.h>	sys_utsname.in.h	sys_utsname_h.m4 00gnulib.m4 gl_SYS_UTSNAME_H AC_PROG_MKDIR_P	include_next snippet/arg-nonnull snippet/warn-on-use
sys_wait	#include <sys/wait.h>	sys_wait.in.h	sys_wait_h.m4 00gnulib.m4 gl_SYS_WAIT_H AC_PROG_MKDIR_P	include_next snippet/c++defs snippet/warn-on-use
tsearch	#include <search.h>	tsearch.c	tsearch.m4 00gnulib.m4 gl_FUNC_TSEARCH if test $HAVE_TSEARCH = 0 \|\| test $REPLACE_TSEARCH = 1; then AC_LIBOBJ([tsearch]) gl_PREREQ_TSEARCH fi gl_SEARCH_MODULE_INDICATOR([tsearch])	search
ttyname_r	#include <unistd.h>	ttyname_r.c	ttyname_r.m4 00gnulib.m4 gl_FUNC_TTYNAME_R if test $HAVE_TTYNAME_R = 0 \|\| test $REPLACE_TTYNAME_R = 1; then AC_LIBOBJ([ttyname_r]) gl_PREREQ_TTYNAME_R fi gl_UNISTD_MODULE_INDICATOR([ttyname_r])	unistd extensions
uname	#include <sys/utsname.h>	uname.c	uname.m4 00gnulib.m4 gl_FUNC_UNAME if test $HAVE_UNAME = 0; then AC_LIBOBJ([uname]) gl_PREREQ_UNAME fi 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 00gnulib.m4 gl_UNISTD_H	extern-inline 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 gl_FUNC_UNLINK if test $REPLACE_UNLINK = 1; then AC_LIBOBJ([unlink]) fi gl_UNISTD_MODULE_INDICATOR([unlink])	unistd dosname [test $REPLACE_UNLINK = 1] lstat [test $REPLACE_UNLINK = 1]
unlockpt	#include <stdlib.h>	unlockpt.c	unlockpt.m4 00gnulib.m4 gl_FUNC_UNLOCKPT if test $HAVE_UNLOCKPT = 0; then AC_LIBOBJ([unlockpt]) gl_PREREQ_UNLOCKPT fi gl_STDLIB_MODULE_INDICATOR([unlockpt])	stdlib extensions fcntl-h [test $HAVE_UNLOCKPT = 0] ptsname [test $HAVE_UNLOCKPT = 0]
utimensat	#include <sys/stat.h>	utimensat.c at-func.c	utimensat.m4 00gnulib.m4 gl_FUNC_UTIMENSAT if test $HAVE_UTIMENSAT = 0 \|\| test $REPLACE_UTIMENSAT = 1; then AC_LIBOBJ([utimensat]) fi gl_SYS_STAT_MODULE_INDICATOR([utimensat])	sys_stat extensions at-internal [test $HAVE_UTIMENSAT = 0 \|\| test $REPLACE_UTIMENSAT = 1] dosname [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] 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] 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 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 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 gl_FUNC_VDPRINTF gl_STDIO_MODULE_INDICATOR([vdprintf])	stdio vasnprintf [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 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 gl_FUNC_VFPRINTF_POSIX gl_STDIO_MODULE_INDICATOR([vfprintf-posix])	stdio nocrash printf-safe multiarch 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 gl_FUNC_VPRINTF_POSIX gl_STDIO_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 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 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 gl_FUNC_WCSNRTOMBS if test $HAVE_WCSNRTOMBS = 0 \|\| test $REPLACE_WCSNRTOMBS = 1; then AC_LIBOBJ([wcsnrtombs]) AC_LIBOBJ([wcsrtombs-state]) gl_PREREQ_WCSNRTOMBS fi 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 gl_FUNC_WCWIDTH if test $HAVE_WCWIDTH = 0 \|\| test $REPLACE_WCWIDTH = 1; then AC_LIBOBJ([wcwidth]) fi 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]
write	#include <unistd.h>	write.c	write.m4 00gnulib.m4 gl_FUNC_WRITE if test $REPLACE_WRITE = 1; then AC_LIBOBJ([write]) gl_PREREQ_WRITE fi 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 gl_CLOCK_TIME	extensions
d-ino	---	---	d-ino.m4 00gnulib.m4 gl_CHECK_TYPE_STRUCT_DIRENT_D_INO	---
d-type	---	---	d-type.m4 00gnulib.m4 gl_CHECK_TYPE_STRUCT_DIRENT_D_TYPE	---
link-follow	---	---	link-follow.m4 00gnulib.m4 gl_FUNC_LINK_FOLLOWS_SYMLINK	---
rename-dest-slash	#include <stdio.h>	---	00gnulib.m4	rename
rmdir-errno	---	---	rmdir-errno.m4 00gnulib.m4 gl_FUNC_RMDIR_NOTEMPTY	---
timer-time	#include <time.h>	---	timer_time.m4 00gnulib.m4 gl_TIMER_TIME	extensions threadlib
unlink-busy	---	---	unlink-busy.m4 00gnulib.m4 gl_FUNC_UNLINK_BUSY_TEXT	---
winsz-ioctl	---	---	jm-winsz2.m4 00gnulib.m4 gl_HEADER_TIOCGWINSZ_NEEDS_SYS_IOCTL	winsz-termios
winsz-termios	---	---	jm-winsz1.m4 00gnulib.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 gl_FUNC_CHDIR_LONG if test $gl_cv_have_arbitrary_file_name_length_limit = yes; then AC_LIBOBJ([chdir-long]) gl_PREREQ_CHDIR_LONG fi	unistd pathmax chdir assure [test $gl_cv_have_arbitrary_file_name_length_limit = yes] atexit [test $gl_cv_have_arbitrary_file_name_length_limit = yes] fchdir [test $gl_cv_have_arbitrary_file_name_length_limit = yes] fcntl-h [test $gl_cv_have_arbitrary_file_name_length_limit = yes] openat [test $gl_cv_have_arbitrary_file_name_length_limit = yes] memchr [test $gl_cv_have_arbitrary_file_name_length_limit = yes] mempcpy [test $gl_cv_have_arbitrary_file_name_length_limit = yes] memrchr [test $gl_cv_have_arbitrary_file_name_length_limit = yes] stdbool [test $gl_cv_have_arbitrary_file_name_length_limit = yes] stdlib [test $gl_cv_have_arbitrary_file_name_length_limit = yes]
dirent-safer	#include "dirent-safer.h"	dirent--.h opendir-safer.c	dirent-safer.m4 00gnulib.m4 gl_DIRENT_SAFER gl_MODULE_INDICATOR([dirent-safer])	dirent closedir dirfd opendir unistd-safer
dirname	#include "dirname.h"	dirname.c basename.c stripslash.c	00gnulib.m4 gl_DIRNAME gl_MODULE_INDICATOR([dirname])	dirname-lgpl xalloc xstrndup
dirname-lgpl	#include "dirname.h"	dirname-lgpl.c basename-lgpl.c stripslash.c	dirname.m4 00gnulib.m4 gl_DIRNAME_LGPL	dosname double-slash-root malloc-posix stdbool
getopt-gnu	#include <getopt.h>	---	00gnulib.m4 gl_FUNC_GETOPT_GNU if test $REPLACE_GETOPT = 1; then AC_LIBOBJ([getopt]) AC_LIBOBJ([getopt1]) gl_PREREQ_GETOPT dnl Arrange for unistd.h to include getopt.h. GNULIB_${gl_include_guard_prefix}_UNISTD_H_GETOPT=1 fi AC_SUBST([GNULIB_${gl_include_guard_prefix}_UNISTD_H_GETOPT]) gl_MODULE_INDICATOR_FOR_TESTS([getopt-gnu])	nocrash getopt-posix
iconv_open-utf	---	---	iconv_open-utf.m4 00gnulib.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 gl_UNISTD_SAFER	fcntl unistd
fnmatch	#include <fnmatch.h>	fnmatch.in.h fnmatch.c fnmatch_loop.c	mbstate_t.m4 fnmatch.m4 00gnulib.m4 gl_FUNC_FNMATCH_POSIX if test -n "$FNMATCH_H"; then AC_LIBOBJ([fnmatch]) gl_PREREQ_FNMATCH fi	extensions snippet/arg-nonnull alloca [test -n "$FNMATCH_H"] stdbool [test -n "$FNMATCH_H"] wchar [test -n "$FNMATCH_H"] wctype-h [test -n "$FNMATCH_H"] memchr [test -n "$FNMATCH_H"] memcmp [test -n "$FNMATCH_H"] mbsrtowcs [test -n "$FNMATCH_H"] mbsinit [test -n "$FNMATCH_H"]
fnmatch-posix	#include "fnmatch.h"	---	00gnulib.m4	fnmatch
fnmatch-gnu	#include "fnmatch.h"	---	00gnulib.m4 gl_FUNC_FNMATCH_GNU if test -n "$FNMATCH_H"; then AC_LIBOBJ([fnmatch]) gl_PREREQ_FNMATCH fi	fnmatch
glob	#include <glob.h>	glob.in.h glob-libc.h glob.c	glob.m4 00gnulib.m4 gl_GLOB if test -n "$GLOB_H"; then AC_LIBOBJ([glob]) gl_PREREQ_GLOB fi	extensions largefile snippet/arg-nonnull snippet/c++defs snippet/warn-on-use alloca [test -n "$GLOB_H"] closedir [test -n "$GLOB_H"] d-type [test -n "$GLOB_H"] dirfd [test -n "$GLOB_H"] fnmatch [test -n "$GLOB_H"] getlogin_r [test -n "$GLOB_H"] memchr [test -n "$GLOB_H"] mempcpy [test -n "$GLOB_H"] opendir [test -n "$GLOB_H"] readdir [test -n "$GLOB_H"] stdbool [test -n "$GLOB_H"] strdup [test -n "$GLOB_H"] sys_stat [test -n "$GLOB_H"] unistd [test -n "$GLOB_H"] malloc-posix [test -n "$GLOB_H"]
exclude	#include "exclude.h"	exclude.c	00gnulib.m4	filename fnmatch hash mbscasecmp mbuiter regex stdbool verify 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	xprintf vprintf-posix vfprintf-posix
xvasprintf-posix	#include "xvasprintf.h"	---	00gnulib.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 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	error gettext-h qcopy-acl qset-acl quote stdbool
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 gl_FUNC_ACL	extern-inline fstat stdbool sys_stat
areadlink	#include "areadlink.h"	areadlink.c	00gnulib.m4	careadlinkat readlink
areadlink-with-size	#include "areadlink.h"	areadlink-with-size.c	00gnulib.m4	readlink ssize_t stdint unistd
areadlinkat	#include "areadlink.h"	areadlinkat.c at-func.c	00gnulib.m4 gl_MODULE_INDICATOR([areadlinkat])	areadlink careadlinkat readlinkat at-internal dosname errno extensions fchdir fcntl-h openat-die openat-h save-cwd
areadlinkat-with-size	#include "areadlink.h"	areadlinkat-with-size.c at-func.c	00gnulib.m4 gl_MODULE_INDICATOR([areadlinkat-with-size])	areadlink-with-size stdint readlinkat at-internal dosname errno extensions fchdir fcntl-h openat-die openat-h save-cwd unistd
backupfile	#include "backupfile.h"	backupfile.c	backupfile.m4 00gnulib.m4 gl_BACKUPFILE	argmatch closedir d-ino dirent-safer dirname-lgpl memcmp opendir readdir stdbool
canonicalize	#include "canonicalize.h"	canonicalize.c	canonicalize.m4 double-slash-root.m4 00gnulib.m4 gl_FUNC_CANONICALIZE_FILENAME_MODE gl_MODULE_INDICATOR([canonicalize]) gl_MODULE_INDICATOR_FOR_TESTS([canonicalize]) gl_STDLIB_MODULE_INDICATOR([canonicalize_file_name])	areadlink-with-size errno extensions file-set hash-triple lstat memmove nocrash pathmax sys_stat xalloc xgetcwd
canonicalize-lgpl	#include <stdlib.h>	canonicalize-lgpl.c	canonicalize.m4 double-slash-root.m4 00gnulib.m4 gl_CANONICALIZE_LGPL if test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1; then AC_LIBOBJ([canonicalize-lgpl]) fi gl_MODULE_INDICATOR([canonicalize-lgpl]) gl_STDLIB_MODULE_INDICATOR([canonicalize_file_name]) gl_STDLIB_MODULE_INDICATOR([realpath])	extensions stdlib nocrash alloca-opt [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] lstat [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1] malloca [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] pathmax [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] sys_stat [test $HAVE_CANONICALIZE_FILE_NAME = 0 \|\| test $REPLACE_CANONICALIZE_FILE_NAME = 1]
chdir-safer	#include "chdir-safer.h"	chdir-safer.c	chdir-safer.m4 00gnulib.m4 gl_CHDIR_SAFER	errno fchdir fcntl-h fstat open same-inode stdbool
clean-temp	#include "clean-temp.h"	clean-temp.c	00gnulib.m4 AC_DEFINE([SIGNAL_SAFE_LIST], [1], [Define if lists must be signal-safe.])	stdbool unistd error fatal-signal open pathmax tmpdir mkdtemp rmdir xalloc xmalloca linkedhash-list xlist gettext-h
concat-filename	#include "concat-filename.h"	concat-filename.c	00gnulib.m4	filename malloc-posix stpcpy
copy-file	#include "copy-file.h"	copy-file.c	copy-file.m4 00gnulib.m4 gl_COPY_FILE	acl binary-io error fstat full-write gettext-h ignore-value open quote safe-read stdlib unistd xalloc
fsusage	#include "fsusage.h"	fsusage.c	fsusage.m4 00gnulib.m4 gl_FSUSAGE if test $gl_cv_fs_space = yes; then AC_LIBOBJ([fsusage]) gl_PREREQ_FSUSAGE_EXTRA fi	largefile stdbool stdint full-read [test $gl_cv_fs_space = yes]
dirfd	#include <dirent.h>	dirfd.c	dirfd.m4 00gnulib.m4 gl_FUNC_DIRFD if test $ac_cv_func_dirfd = no && test $gl_cv_func_dirfd_macro = no; then AC_LIBOBJ([dirfd]) gl_PREREQ_DIRFD fi gl_DIRENT_MODULE_INDICATOR([dirfd])	dirent extensions errno [test $ac_cv_func_dirfd = no && test $gl_cv_func_dirfd_macro = no]
double-slash-root	---	---	double-slash-root.m4 00gnulib.m4 gl_DOUBLE_SLASH_ROOT	---
euidaccess	#include <unistd.h>	euidaccess.c	euidaccess.m4 00gnulib.m4 gl_FUNC_EUIDACCESS if test $HAVE_EUIDACCESS = 0; then AC_LIBOBJ([euidaccess]) gl_PREREQ_EUIDACCESS fi 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 gl_FUNC_FACCESSAT if test $HAVE_FACCESSAT = 0; then AC_LIBOBJ([faccessat]) gl_PREREQ_FACCESSAT fi gl_MODULE_INDICATOR([faccessat]) gl_UNISTD_MODULE_INDICATOR([faccessat])	unistd extensions at-internal [test $HAVE_FACCESSAT = 0] dosname [test $HAVE_FACCESSAT = 0] errno [test $HAVE_FACCESSAT = 0] fchdir [test $HAVE_FACCESSAT = 0] fcntl-h [test $HAVE_FACCESSAT = 0] openat-die [test $HAVE_FACCESSAT = 0] openat-h [test $HAVE_FACCESSAT = 0] save-cwd [test $HAVE_FACCESSAT = 0] euidaccess [test $HAVE_FACCESSAT = 0]
fdopendir	#include <dirent.h>	fdopendir.c	fdopendir.m4 00gnulib.m4 gl_FUNC_FDOPENDIR if test $HAVE_FDOPENDIR = 0 \|\| test $REPLACE_FDOPENDIR = 1; then AC_LIBOBJ([fdopendir]) fi 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 gl_MODULE_INDICATOR([fdutimensat])	futimens utimensat
file-type	#include "file-type.h"	file-type.c	00gnulib.m4	gettext-h sys_stat
fileblocks	---	fileblocks.c	fileblocks.m4 00gnulib.m4 gl_FILEBLOCKS if test $ac_cv_member_struct_stat_st_blocks = no; then AC_LIBOBJ([fileblocks]) gl_PREREQ_FILEBLOCKS fi	---
filemode	#include "filemode.h"	filemode.c	filemode.m4 st_dm_mode.m4 00gnulib.m4 gl_FILEMODE	sys_stat
filename	#include "filename.h"	---	00gnulib.m4	---
filenamecat	#include "filenamecat.h"	filenamecat.c	filenamecat.m4 00gnulib.m4 gl_FILE_NAME_CONCAT gl_MODULE_INDICATOR([filenamecat])	filenamecat-lgpl xalloc
filenamecat-lgpl	#include "filenamecat.h"	filenamecat-lgpl.c	filenamecat.m4 00gnulib.m4 gl_FILE_NAME_CONCAT_LGPL	dirname-lgpl
fts	#include "fts_.h"	fts.c fts-cycle.c	fts.m4 00gnulib.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. AC_LIBOBJ([fts])	cloexec closedir cycle-check d-ino d-type dirent-safer dup fchdir fcntl-h fcntl-safer fdopendir flexmember fstat hash i-ring lstat memmove openat-h openat-safer opendir readdir stdalign stdbool stddef unistd-safer
isdir	---	isdir.c isdir.h	00gnulib.m4	stat
largefile	---	---	largefile.m4 00gnulib.m4 AC_REQUIRE([gl_LARGEFILE])	---
lchmod	#include <sys/stat.h>	---	lchmod.m4 00gnulib.m4 gl_FUNC_LCHMOD gl_SYS_STAT_MODULE_INDICATOR([lchmod])	sys_stat extensions
lchown	#include <unistd.h>	lchown.c	lchown.m4 00gnulib.m4 gl_FUNC_LCHOWN if test $HAVE_LCHOWN = 0 \|\| test $REPLACE_LCHOWN = 1; then AC_LIBOBJ([lchown]) fi gl_UNISTD_MODULE_INDICATOR([lchown])	unistd chown [test $HAVE_LCHOWN = 0 \|\| test $REPLACE_LCHOWN = 1] errno [test $HAVE_LCHOWN = 0 \|\| test $REPLACE_LCHOWN = 1] lstat [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]
mkancesdirs	#include "mkancesdirs.h"	mkancesdirs.c	mkancesdirs.m4 00gnulib.m4 gl_MKANCESDIRS	dirname-lgpl fcntl-h savewd stat-macros sys_stat
mkfifoat	#include <fcntl.h> #include <sys/stat.h>	mkfifoat.c mknodat.c at-func.c	mkfifoat.m4 00gnulib.m4 gl_FUNC_MKFIFOAT if test $HAVE_MKFIFOAT = 0; then AC_LIBOBJ([mkfifoat]) fi if test $HAVE_MKNODAT = 0; then AC_LIBOBJ([mknodat]) fi gl_SYS_STAT_MODULE_INDICATOR([mkfifoat]) gl_SYS_STAT_MODULE_INDICATOR([mknodat])	sys_stat extensions at-internal [test $HAVE_MKFIFOAT = 0 \|\| test $HAVE_MKNODAT = 0] dosname [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] fcntl-h [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 gl_MKDIR_PARENTS	error fcntl-h fstat gettext-h lchmod lchown mkancesdirs quote savewd stat stat-macros stdbool sys_stat
mkostemp	#include <stdlib.h>	mkostemp.c	mkostemp.m4 00gnulib.m4 gl_FUNC_MKOSTEMP if test $HAVE_MKOSTEMP = 0; then AC_LIBOBJ([mkostemp]) gl_PREREQ_MKOSTEMP fi gl_MODULE_INDICATOR([mkostemp]) gl_STDLIB_MODULE_INDICATOR([mkostemp])	stdlib extensions largefile tempname [test $HAVE_MKOSTEMP = 0]
mkostemps	#include <stdlib.h>	mkostemps.c	mkostemps.m4 00gnulib.m4 gl_FUNC_MKOSTEMPS if test $HAVE_MKOSTEMPS = 0; then AC_LIBOBJ([mkostemps]) fi gl_MODULE_INDICATOR([mkostemps]) gl_STDLIB_MODULE_INDICATOR([mkostemps])	stdlib extensions largefile tempname [test $HAVE_MKOSTEMPS = 0]
mkstemps	#include <stdlib.h>	mkstemps.c	mkstemps.m4 00gnulib.m4 gl_FUNC_MKSTEMPS if test $HAVE_MKSTEMPS = 0; then AC_LIBOBJ([mkstemps]) fi 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 gl_MODECHANGE	stat stat-macros stdbool sys_stat xalloc
mountlist	#include "mountlist.h"	mountlist.c	ls-mntd-fs.m4 fstypename.m4 mountlist.m4 00gnulib.m4 gl_MOUNTLIST if test $gl_cv_list_mounted_fs = yes; then AC_LIBOBJ([mountlist]) gl_PREREQ_MOUNTLIST_EXTRA fi	stdbool stdint strstr-simple xalloc
openat	#include <fcntl.h>	openat.c	openat.m4 lstat.m4 mode_t.m4 00gnulib.m4 gl_FUNC_OPENAT if test $HAVE_OPENAT = 0 \|\| test $REPLACE_OPENAT = 1; then AC_LIBOBJ([openat]) gl_PREREQ_OPENAT fi 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] fstat [test $REPLACE_OPENAT = 1] at-internal [test $HAVE_OPENAT = 0] dosname [test $HAVE_OPENAT = 0] errno [test $HAVE_OPENAT = 0] fchdir [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	openat-h error exitfail gettext-h snippet/_Noreturn
pathmax	#include "pathmax.h"	---	pathmax.m4 00gnulib.m4 gl_PATHMAX	unistd
qacl	---	---	00gnulib.m4	qcopy-acl qset-acl
qcopy-acl	#include "acl.h"	qcopy-acl.c	00gnulib.m4	acl-permissions
qset-acl	#include "acl.h"	qset-acl.c	00gnulib.m4	acl-permissions
read-file	#include "read-file.h"	read-file.c	read-file.m4 00gnulib.m4 gl_PREREQ_READ_FILE	fstat ftello malloc-posix realloc-posix stdint sys_stat
readlinkat	#include <fcntl.h> #include <unistd.h>	readlinkat.c at-func.c	readlinkat.m4 00gnulib.m4 gl_FUNC_READLINKAT if test $HAVE_READLINKAT = 0 \|\| test $REPLACE_READLINKAT = 1; then AC_LIBOBJ([readlinkat]) fi gl_UNISTD_MODULE_INDICATOR([readlinkat])	unistd extensions at-internal [test $HAVE_READLINKAT = 0] dosname [test $HAVE_READLINKAT = 0] errno [test $HAVE_READLINKAT = 0] fchdir [test $HAVE_READLINKAT = 0] fcntl-h [test $HAVE_READLINKAT = 0] openat-die [test $HAVE_READLINKAT = 0] openat-h [test $HAVE_READLINKAT = 0] save-cwd [test $HAVE_READLINKAT = 0] readlink [test $HAVE_READLINKAT = 0]
same	#include "same.h"	same.c	same.m4 00gnulib.m4 gl_SAME	error dirname same-inode stat stdbool memcmp
save-cwd	#include "save-cwd.h"	save-cwd.c	save-cwd.m4 00gnulib.m4 gl_SAVE_CWD	chdir-long cloexec getcwd-lgpl fchdir stdbool unistd-safer
savedir	#include "savedir.h"	savedir.c	savedir.m4 00gnulib.m4 gl_SAVEDIR	closedir dirent-safer fdopendir opendir readdir stpcpy xalloc
savewd	#include "savewd.h"	savewd.c	savewd.m4 00gnulib.m4 gl_SAVEWD	assure chdir dosname errno extern-inline fchdir fcntl-safer fcntl-h raise stdbool stdlib sys_wait xalloc
stat-macros	#include "stat-macros.h"	---	00gnulib.m4	---
stat-time	#include "stat-time.h"	stat-time.c	stat-time.m4 00gnulib.m4 gl_STAT_TIME gl_STAT_BIRTHTIME	time extensions extern-inline
symlink	#include <unistd.h>	symlink.c	symlink.m4 00gnulib.m4 gl_FUNC_SYMLINK if test $HAVE_SYMLINK = 0 \|\| test $REPLACE_SYMLINK = 1; then AC_LIBOBJ([symlink]) fi 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 gl_FUNC_SYMLINKAT if test $HAVE_SYMLINKAT = 0 \|\| test $REPLACE_SYMLINKAT = 1; then AC_LIBOBJ([symlinkat]) fi gl_UNISTD_MODULE_INDICATOR([symlinkat])	unistd extensions at-internal [test $HAVE_SYMLINKAT = 0] dosname [test $HAVE_SYMLINKAT = 0] errno [test $HAVE_SYMLINKAT = 0] fchdir [test $HAVE_SYMLINKAT = 0] fcntl-h [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 gl_HEADER_SYS_FILE_H AC_PROG_MKDIR_P	include_next snippet/warn-on-use
sys_ioctl	#include <sys/ioctl.h>	sys_ioctl.in.h	sys_ioctl_h.m4 00gnulib.m4 gl_SYS_IOCTL_H AC_PROG_MKDIR_P	include_next snippet/c++defs snippet/warn-on-use unistd
tmpdir	#include "tmpdir.h"	tmpdir.c	tmpdir.m4 00gnulib.m4 gt_TMPDIR	secure_getenv stdbool sys_stat pathmax
unlinkdir	#include "unlinkdir.h"	unlinkdir.c	unlinkdir.m4 00gnulib.m4 gl_UNLINKDIR	stdbool priv-set root-uid
utimecmp	#include "utimecmp.h"	utimecmp.c	utimecmp.m4 00gnulib.m4 gl_UTIMECMP	hash stat-time time utimens intprops lstat stdbool stdint verify
utimens	#include "utimens.h"	utimens.c	utimbuf.m4 utimens.m4 utimes.m4 00gnulib.m4 gl_UTIMENS	errno extern-inline fcntl-h fstat lstat gettime stat-time stdbool sys_stat sys_time time
write-any-file	#include "write-any-file.h"	write-any-file.c	write-any-file.m4 00gnulib.m4 gl_WRITE_ANY_FILE	stdbool priv-set root-uid
xconcat-filename	#include "concat-filename.h"	xconcat-filename.c	00gnulib.m4	concat-filename xalloc-die
xgetcwd	#include "xgetcwd.h"	xgetcwd.c	xgetcwd.m4 00gnulib.m4 gl_XGETCWD	getcwd xalloc stdbool
xreadlink	#include "xreadlink.h"	xreadlink.c	00gnulib.m4	areadlink xalloc
xreadlinkat	#include "xreadlink.h"	xreadlinkat.c	00gnulib.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 gl_CYCLE_CHECK	assure dev-ino same-inode stdbool stdint
dev-ino	#include "dev-ino.h"	---	00gnulib.m4	---
file-set	#include "file-set.h"	file-set.c	00gnulib.m4	hash hash-triple stdbool xalloc xalloc-die
hash-triple	#include "hash-triple.h"	hash-triple.c	00gnulib.m4	hash-pjw same same-inode
i-ring	#include "i-ring.h"	i-ring.c	i-ring.m4 00gnulib.m4 gl_I_RING	stdbool verify
same-inode	#include "same-inode.h"	---	00gnulib.m4	---

File descriptor based Input/Output

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
dup3	#include <unistd.h>	dup3.c	dup3.m4 00gnulib.m4 gl_FUNC_DUP3 gl_UNISTD_MODULE_INDICATOR([dup3])	unistd fcntl binary-io getdtablesize extensions
fd-safer-flag	#include "unistd-safer.h"	fd-safer-flag.c dup-safer-flag.c	00gnulib.m4 gl_MODULE_INDICATOR([fd-safer-flag])	cloexec fcntl unistd-safer
getdtablesize	#include <unistd.h>	getdtablesize.c	getdtablesize.m4 00gnulib.m4 gl_FUNC_GETDTABLESIZE if test $HAVE_GETDTABLESIZE = 0 \|\| test $REPLACE_GETDTABLESIZE = 1; then AC_LIBOBJ([getdtablesize]) gl_PREREQ_GETDTABLESIZE fi gl_UNISTD_MODULE_INDICATOR([getdtablesize])	unistd extensions msvc-inval [test $HAVE_GETDTABLESIZE = 0]
fcntl-safer	#include "fcntl-safer.h"	fcntl--.h creat-safer.c open-safer.c	fcntl-safer.m4 mode_t.m4 00gnulib.m4 gl_FCNTL_SAFER gl_MODULE_INDICATOR([fcntl-safer])	fcntl-h open unistd-safer
openat-safer	#include "fcntl-safer.h"	fcntl--.h openat-safer.c	fcntl-safer.m4 00gnulib.m4 gl_OPENAT_SAFER gl_MODULE_INDICATOR([openat-safer])	fcntl-safer openat unistd-safer
safe-read	#include "safe-read.h"	safe-read.c	safe-read.m4 00gnulib.m4 gl_PREREQ_SAFE_READ	read ssize_t
safe-write	#include "safe-write.h"	safe-write.c safe-read.c	safe-write.m4 safe-read.m4 00gnulib.m4 gl_PREREQ_SAFE_WRITE	ssize_t write
full-read	#include "full-read.h"	full-read.c full-write.c	00gnulib.m4	safe-read
full-write	#include "full-write.h"	full-write.c	00gnulib.m4	safe-write
binary-io	#include "binary-io.h"	binary-io.c	00gnulib.m4	extern-inline fcntl-h
isapipe	#include "isapipe.h"	isapipe.c	isapipe.m4 00gnulib.m4 gl_ISAPIPE if test $HAVE_ISAPIPE = 0; then AC_LIBOBJ([isapipe]) gl_PREREQ_ISAPIPE fi	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]
pipe-posix	#include <unistd.h>	pipe.c	pipe.m4 00gnulib.m4 gl_FUNC_PIPE if test $HAVE_PIPE = 0; then AC_LIBOBJ([pipe]) fi gl_UNISTD_MODULE_INDICATOR([pipe])	unistd
pipe2	#include <unistd.h>	pipe2.c	pipe2.m4 00gnulib.m4 gl_FUNC_PIPE2 gl_UNISTD_MODULE_INDICATOR([pipe2])	unistd fcntl-h binary-io extensions verify
pipe2-safer	#include "unistd-safer.h"	pipe2-safer.c	00gnulib.m4 gl_MODULE_INDICATOR([pipe2-safer])	fd-safer-flag pipe2 unistd-safer

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	close-stream.m4 00gnulib.m4 gl_CLOSE_STREAM gl_MODULE_INDICATOR([close-stream])	fpending stdbool
closein	#include "closein.h"	closein.c	closein.m4 00gnulib.m4 gl_CLOSEIN	closeout freadahead fflush stdbool
closeout	#include "closeout.h"	closeout.c	closeout.m4 00gnulib.m4 gl_CLOSEOUT	close-stream gettext-h error quotearg exitfail stdbool
fbufmode	#include "fbufmode.h"	fbufmode.c stdio-impl.h	fbufmode.m4 00gnulib.m4 gl_FUNC_FBUFMODE	---
fopen-safer	#include "stdio-safer.h"	stdio--.h fopen-safer.c	00gnulib.m4 gl_MODULE_INDICATOR([fopen-safer])	fopen unistd-safer
fpending	#include "fpending.h"	fpending.c	fpending.m4 00gnulib.m4 gl_FUNC_FPENDING if test $gl_cv_func___fpending = no; then AC_LIBOBJ([fpending]) gl_PREREQ_FPENDING fi	---
fpurge	#include <stdio.h>	fpurge.c stdio-impl.h	fpurge.m4 00gnulib.m4 gl_FUNC_FPURGE if test $HAVE_FPURGE = 0 \|\| test $REPLACE_FPURGE = 1; then AC_LIBOBJ([fpurge]) fi gl_STDIO_MODULE_INDICATOR([fpurge])	stdio
freadable	#include "freadable.h"	freadable.c stdio-impl.h	freadable.m4 00gnulib.m4 gl_FUNC_FREADABLE if test $ac_cv_func___freadable = no; then AC_LIBOBJ([freadable]) fi	stdbool
freadahead	#include "freadahead.h"	freadahead.c stdio-impl.h	freadahead.m4 00gnulib.m4 gl_FUNC_FREADAHEAD if test $ac_cv_func___freadahead = no; then AC_LIBOBJ([freadahead]) fi	---
freading	#include "freading.h"	freading.c stdio-impl.h	freading.m4 00gnulib.m4 gl_FUNC_FREADING	stdbool
freadptr	#include "freadptr.h"	freadptr.c stdio-impl.h	freadptr.m4 00gnulib.m4 gl_FUNC_FREADPTR if test $ac_cv_func___freadptr = no; then AC_LIBOBJ([freadptr]) fi	---
freadseek	#include "freadseek.h"	freadseek.c stdio-impl.h	freadseek.m4 00gnulib.m4 gl_FUNC_FREADSEEK	freadahead freadptr fseeko lseek
freopen-safer	#include "stdio-safer.h"	stdio--.h freopen-safer.c	00gnulib.m4 gl_MODULE_INDICATOR([freopen-safer])	dup2 freopen open stdbool
fwritable	#include "fwritable.h"	fwritable.c stdio-impl.h	fwritable.m4 00gnulib.m4 gl_FUNC_FWRITABLE if test $ac_cv_func___fwritable = no; then AC_LIBOBJ([fwritable]) fi	stdbool
fwriting	#include "fwriting.h"	fwriting.c stdio-impl.h	fwriting.m4 00gnulib.m4 gl_FUNC_FWRITING if test $ac_cv_func___fwriting = no; then AC_LIBOBJ([fwriting]) fi	stdbool
getpass	#include "getpass.h"	getpass.c	getpass.m4 00gnulib.m4 gl_FUNC_GETPASS if test $HAVE_GETPASS = 0; then AC_LIBOBJ([getpass]) gl_PREREQ_GETPASS fi	extensions fseeko getline stdbool strdup-posix
getpass-gnu	#include "getpass.h"	getpass.c	getpass.m4 00gnulib.m4 gl_FUNC_GETPASS_GNU if test $REPLACE_GETPASS = 1; then AC_LIBOBJ([getpass]) gl_PREREQ_GETPASS fi	fseeko getline stdbool
popen-safer	#include "stdio-safer.h"	stdio--.h popen-safer.c	00gnulib.m4 gl_MODULE_INDICATOR([popen-safer])	cloexec open popen unistd-safer
stdlib-safer	#include "stdlib-safer.h"	stdlib--.h mkstemp-safer.c	00gnulib.m4	fd-safer-flag mkstemp stdlib unistd-safer
tmpfile-safer	#include "stdio-safer.h"	stdio--.h tmpfile-safer.c	00gnulib.m4 gl_MODULE_INDICATOR([tmpfile-safer])	binary-io tmpfile unistd-safer
xfreopen	#include "xfreopen.h"	xfreopen.c	00gnulib.m4	error exitfail freopen-safer 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 gl_GETUGROUPS	errno
group-member	#include <unistd.h>	group-member.c	group-member.m4 00gnulib.m4 gl_FUNC_GROUP_MEMBER if test $HAVE_GROUP_MEMBER = 0; then AC_LIBOBJ([group-member]) gl_PREREQ_GROUP_MEMBER fi gl_UNISTD_MODULE_INDICATOR([group-member])	unistd extensions getgroups [test $HAVE_GROUP_MEMBER = 0] xalloc-oversized [test $HAVE_GROUP_MEMBER = 0]
idcache	#include "idcache.h"	idcache.c	idcache.m4 00gnulib.m4 gl_IDCACHE	flexmember xalloc
mgetgroups	#include "mgetgroups.h"	mgetgroups.c	mgetgroups.m4 00gnulib.m4 gl_MGETGROUPS	getgroups getugroups realloc-posix xalloc-oversized
userspec	#include "userspec.h"	userspec.c	userspec.m4 00gnulib.m4 gl_USERSPEC	posixver xalloc xstrtol strdup gettext-h intprops inttostr stdbool

Security

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
idpriv-drop	#include "idpriv.h"	idpriv-drop.c	idpriv.m4 00gnulib.m4 gl_IDPRIV	unistd extensions
idpriv-droptemp	#include "idpriv.h"	idpriv-droptemp.c	idpriv.m4 00gnulib.m4 gl_IDPRIV	unistd extensions
priv-set	#include "priv-set.h"	priv-set.c	priv-set.m4 00gnulib.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 longlong.m4 00gnulib.m4 gl_GETHRXTIME	clock-time extensions extern-inline gettime sys_time
gettime	#include "timespec.h"	gettime.c	gettime.m4 00gnulib.m4 gl_GETTIME	clock-time gettimeofday sys_time timespec extensions
posixtm	#include "posixtm.h"	posixtm.c	posixtm.m4 00gnulib.m4 gl_POSIXTM	mktime stdbool stpcpy
settime	#include "timespec.h"	settime.c	settime.m4 00gnulib.m4 gl_SETTIME	clock-time errno extensions sys_time timespec
usleep	#include <unistd.h>	usleep.c	usleep.m4 00gnulib.m4 gl_FUNC_USLEEP if test $HAVE_USLEEP = 0 \|\| test $REPLACE_USLEEP = 1; then AC_LIBOBJ([usleep]) fi 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 gl_XNANOSLEEP	dtotimespec nanosleep time

Networking functions

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
accept4	#include <sys/socket.h>	accept4.c	accept4.m4 00gnulib.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	00gnulib.m4	gethostname xalloc
canon-host	#include "canon-host.h"	canon-host.c	canon-host.m4 00gnulib.m4 gl_PREREQ_CANON_HOST	getaddrinfo strdup
sockets	#include "sockets.h"	sockets.c w32sock.h	sockets.m4 00gnulib.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 gl_THREADLIB	havelib
lock	#include "glthread/lock.h"	glthread/lock.c	lock.m4 00gnulib.m4 gl_LOCK gl_MODULE_INDICATOR([lock])	threadlib
tls	#include "glthread/tls.h"	glthread/tls.c	tls.m4 00gnulib.m4 gl_TLS	threadlib
thread	#include "glthread/thread.h"	glthread/thread.c	thread.m4 00gnulib.m4 gl_THREAD	threadlib extern-inline lock
yield	#include "glthread/yield.h"	---	yield.m4 00gnulib.m4 gl_YIELD	threadlib
cond	#include "glthread/cond.h"	glthread/cond.c	cond.m4 00gnulib.m4 gl_COND	threadlib lock errno extern-inline stdbool time gettimeofday
openmp	---	---	openmp.m4 00gnulib.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 gl_C_STACK	gettext-h errno exitfail ignore-value unistd raise sigaction libsigsegv
libsigsegv	#if HAVE_LIBSIGSEGV # include <sigsegv.h> #endif	---	libsigsegv.m4 00gnulib.m4 gl_LIBSIGSEGV	havelib
sig2str	#include "sig2str.h"	sig2str.c	sig2str.m4 00gnulib.m4 gl_FUNC_SIG2STR if test $ac_cv_func_sig2str = no; then AC_LIBOBJ([sig2str]) gl_PREREQ_SIG2STR fi	intprops
sigpipe	#include <signal.h>	stdio-write.c	sigpipe.m4 asm-underscore.m4 00gnulib.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. AC_REQUIRE([gl_SIGNAL_H_DEFAULTS]) GNULIB_SIGNAL_H_SIGPIPE=1 dnl Define the substituted variable GNULIB_STDIO_H_SIGPIPE to 1. AC_REQUIRE([gl_STDIO_H_DEFAULTS]) AC_REQUIRE([gl_ASM_SYMBOL_PREFIX]) GNULIB_STDIO_H_SIGPIPE=1 dnl Define the substituted variable GNULIB_UNISTD_H_SIGPIPE to 1. AC_REQUIRE([gl_UNISTD_H_DEFAULTS]) GNULIB_UNISTD_H_SIGPIPE=1	msvc-nothrow raise signal-h sigprocmask stdio unistd
sigpipe-die	#include "sigpipe-die.h"	sigpipe-die.c	00gnulib.m4	error gettext-h exitfail sigpipe sigprocmask sigaction

Internationalization functions

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
gettext	#include "gettext.h"	---	codeset.m4 fcntl-o.m4 gettext.m4 glibc2.m4 glibc21.m4 iconv.m4 intdiv0.m4 intl.m4 intldir.m4 intlmacosx.m4 intmax.m4 inttypes_h.m4 inttypes-pri.m4 lcmessage.m4 lock.m4 longlong.m4 nls.m4 po.m4 printf-posix.m4 progtest.m4 size_max.m4 stdint_h.m4 threadlib.m4 uintmax_t.m4 visibility.m4 wchar_t.m4 wint_t.m4 xsize.m4 00gnulib.m4 AM_GNU_GETTEXT([external]) AM_GNU_GETTEXT_VERSION([0.18.1])	extensions gettext-h havelib
gettext-h	#include "gettext.h"	---	00gnulib.m4 AC_SUBST([LIBINTL]) AC_SUBST([LTLIBINTL])	---
propername	#include "propername.h"	propername.c	00gnulib.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 AM_ICONV m4_ifdef([gl_ICONV_MODULE_INDICATOR], [gl_ICONV_MODULE_INDICATOR([iconv])])	havelib
striconv	#include "striconv.h"	striconv.c	00gnulib.m4 if test $gl_cond_libtool = false; then gl_ltlibdeps="$gl_ltlibdeps $LTLIBICONV" gl_libdeps="$gl_libdeps $LIBICONV" fi	iconv iconv_open strdup c-strcase
xstriconv	#include "xstriconv.h"	xstriconv.c	00gnulib.m4	striconv xalloc
striconveh	#include "striconveh.h"	striconveh.c iconveh.h	00gnulib.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 strdup c-strcase c-strcaseeq memmove
xstriconveh	#include "xstriconveh.h"	xstriconveh.c	00gnulib.m4	striconveh xalloc
striconveha	#include "striconveha.h"	striconveha.c	00gnulib.m4	stdbool striconveh malloca strdup c-strcase
localcharset	#include "localcharset.h"	localcharset.c config.charset ref-add.sin ref-del.sin	codeset.m4 fcntl-o.m4 glibc21.m4 localcharset.m4 00gnulib.m4 gl_LOCALCHARSET LOCALCHARSET_TESTS_ENVIRONMENT="CHARSETALIASDIR=\"\$(abs_top_builddir)/$gl_source_base\"" AC_SUBST([LOCALCHARSET_TESTS_ENVIRONMENT])	configmake extensions
hard-locale	#include "hard-locale.h"	hard-locale.c	hard-locale.m4 00gnulib.m4 gl_HARD_LOCALE	stdbool strdup
localename	#include "localename.h"	localename.c	localename.m4 intlmacosx.m4 lcmessage.m4 00gnulib.m4 gl_LOCALENAME	strdup lock langinfo
mbmemcasecmp	#include "mbmemcasecmp.h"	mbmemcasecmp.c	00gnulib.m4	mbiter
mbmemcasecoll	#include "mbmemcasecoll.h"	mbmemcasecoll.c	00gnulib.m4	stdbool malloca mbrtowc wcrtomb memcmp2 memcoll wchar
mbslen	#include <string.h>	mbslen.c	mbslen.m4 00gnulib.m4 gl_FUNC_MBSLEN gl_STRING_MODULE_INDICATOR([mbslen])	mbuiter string
mbsnlen	#include <string.h>	mbsnlen.c	00gnulib.m4 gl_STRING_MODULE_INDICATOR([mbsnlen])	mbiter string
mbschr	#include <string.h>	mbschr.c	00gnulib.m4 gl_STRING_MODULE_INDICATOR([mbschr])	mbuiter string
mbsrchr	#include <string.h>	mbsrchr.c	00gnulib.m4 gl_STRING_MODULE_INDICATOR([mbsrchr])	mbuiter string
mbsstr	#include <string.h>	mbsstr.c str-kmp.h	00gnulib.m4 gl_STRING_MODULE_INDICATOR([mbsstr])	mbuiter stdbool string mbslen malloca strnlen
mbscasecmp	#include <string.h>	mbscasecmp.c	00gnulib.m4 gl_STRING_MODULE_INDICATOR([mbscasecmp])	mbuiter string
mbsncasecmp	#include <string.h>	mbsncasecmp.c	00gnulib.m4 gl_STRING_MODULE_INDICATOR([mbsncasecmp])	mbuiter string
mbspcasecmp	#include <string.h>	mbspcasecmp.c	00gnulib.m4 gl_STRING_MODULE_INDICATOR([mbspcasecmp])	mbuiter string
mbscasestr	#include <string.h>	mbscasestr.c str-kmp.h	00gnulib.m4 gl_STRING_MODULE_INDICATOR([mbscasestr])	mbuiter stdbool string mbslen malloca strnlen
mbscspn	#include <string.h>	mbscspn.c	00gnulib.m4 gl_STRING_MODULE_INDICATOR([mbscspn])	mbuiter string mbschr strcspn
mbspbrk	#include <string.h>	mbspbrk.c	00gnulib.m4 gl_STRING_MODULE_INDICATOR([mbspbrk])	mbuiter string mbschr strpbrk
mbsspn	#include <string.h>	mbsspn.c	00gnulib.m4 gl_STRING_MODULE_INDICATOR([mbsspn])	mbuiter string mbschr
mbssep	#include <string.h>	mbssep.c	00gnulib.m4 gl_STRING_MODULE_INDICATOR([mbssep])	mbuiter string mbspbrk strsep
mbstok_r	#include <string.h>	mbstok_r.c	00gnulib.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 gl_MBSWIDTH	wchar wctype-h mbrtowc mbsinit wcwidth extensions
memcasecmp	#include "memcasecmp.h"	memcasecmp.c	memcasecmp.m4 00gnulib.m4 gl_MEMCASECMP	---
memcoll	#include "memcoll.h"	memcoll.c	memcoll.m4 00gnulib.m4 gl_MEMCOLL	memcmp
xmemcoll	#include "xmemcoll.h"	xmemcoll.c	00gnulib.m4	memcoll gettext-h error quotearg exitfail
unicodeio	#include "unicodeio.h"	unicodeio.c	unicodeio.m4 00gnulib.m4 gl_UNICODEIO	unistr/u8-uctomb iconv iconv_open gettext-h localcharset error stdio
rpmatch	#include <stdlib.h>	rpmatch.c	rpmatch.m4 00gnulib.m4 gl_FUNC_RPMATCH if test $HAVE_RPMATCH = 0; then AC_LIBOBJ([rpmatch]) gl_PREREQ_RPMATCH fi 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 gl_YESNO	getline rpmatch stdbool
bison-i18n	---	---	bison-i18n.m4 00gnulib.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 gl_LIBUNISTRING	havelib iconv
libunistring-optional	---	libunistring.valgrind	libunistring-optional.m4 libunistring.m4 absolute-header.m4 00gnulib.m4 gl_LIBUNISTRING_OPTIONAL	havelib iconv
unitypes	#include "unitypes.h"	unitypes.in.h	libunistring-base.m4 00gnulib.m4 gl_LIBUNISTRING_LIBHEADER([0.9.4], [unitypes.h])	stdint
ucs4-utf8	#include "unistr.h"	---	00gnulib.m4	unistr/u8-uctomb
ucs4-utf16	#include "unistr.h"	---	00gnulib.m4	unistr/u16-uctomb
utf8-ucs4-unsafe	#include "unistr.h"	---	00gnulib.m4	unistr/u8-mbtouc-unsafe
utf16-ucs4-unsafe	#include "unistr.h"	---	00gnulib.m4	unistr/u16-mbtouc-unsafe
utf8-ucs4	#include "unistr.h"	---	00gnulib.m4	unistr/u8-mbtouc
utf16-ucs4	#include "unistr.h"	---	00gnulib.m4	unistr/u16-mbtouc
unistr/base	#include "unistr.h"	unistr.in.h	libunistring-base.m4 00gnulib.m4 gl_LIBUNISTRING_LIBHEADER([0.9.4], [unistr.h])	unitypes snippet/unused-parameter stdbool inline
unistr/u8-to-u16	#include "unistr.h"	unistr/u8-to-u16.c	00gnulib.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 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 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 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 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 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 gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-check])	unistr/base
unistr/u16-check	#include "unistr.h"	unistr/u16-check.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-check])	unistr/base
unistr/u32-check	#include "unistr.h"	unistr/u32-check.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-check])	unistr/base
unistr/u8-chr	#include "unistr.h"	unistr/u8-chr.c	00gnulib.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 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 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-chr])	unistr/base
unistr/u8-cmp	#include "unistr.h"	unistr/u8-cmp.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-cmp])	unistr/base memcmp
unistr/u16-cmp	#include "unistr.h"	unistr/u16-cmp.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-cmp])	unistr/base
unistr/u32-cmp	#include "unistr.h"	unistr/u32-cmp.c	00gnulib.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 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 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 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 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 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 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 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 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 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 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 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 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 gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-mblen])	unistr/base
unistr/u16-mblen	#include "unistr.h"	unistr/u16-mblen.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-mblen])	unistr/base
unistr/u32-mblen	#include "unistr.h"	unistr/u32-mblen.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-mblen])	unistr/base
unistr/u8-mbsnlen	#include "unistr.h"	unistr/u8-mbsnlen.c	00gnulib.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 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 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 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 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 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 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 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 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 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 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 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 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 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 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-move])	unistr/base memmove
unistr/u8-next	#include "unistr.h"	unistr/u8-next.c	00gnulib.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 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 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 gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-prev])	unistr/base
unistr/u16-prev	#include "unistr.h"	unistr/u16-prev.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-prev])	unistr/base
unistr/u32-prev	#include "unistr.h"	unistr/u32-prev.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-prev])	unistr/base
unistr/u8-set	#include "unistr.h"	unistr/u8-set.c	00gnulib.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 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 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 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 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 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 AC_CHECK_FUNCS_ONCE([stpcpy]) 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 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 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 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 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 gl_LIBUNISTRING_MODULE([0.9.3], [unistr/u32-stpncpy])	unistr/base
unistr/u8-strcat	#include "unistr.h"	unistr/u8-strcat.c	00gnulib.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 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 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 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 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 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-strchr])	unistr/base
unistr/u8-strcmp	#include "unistr.h"	unistr/u8-strcmp.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.4], [unistr/u8-strcmp])	unistr/base
unistr/u16-strcmp	#include "unistr.h"	unistr/u16-strcmp.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-strcmp])	unistr/base
unistr/u32-strcmp	#include "unistr.h"	unistr/u32-strcmp.c	00gnulib.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 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 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 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 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 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 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 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 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 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 unistr/u-strdup.h	00gnulib.m4 AC_CHECK_FUNCS_ONCE([strdup]) gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-strdup])	unistr/base unistr/u8-strlen
unistr/u16-strdup	#include "unistr.h"	unistr/u16-strdup.c unistr/u-strdup.h	00gnulib.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 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 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 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 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-strlen])	unistr/base
unistr/u8-strmblen	#include "unistr.h"	unistr/u8-strmblen.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-strmblen])	unistr/base
unistr/u16-strmblen	#include "unistr.h"	unistr/u16-strmblen.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-strmblen])	unistr/base
unistr/u32-strmblen	#include "unistr.h"	unistr/u32-strmblen.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-strmblen])	unistr/base
unistr/u8-strmbtouc	#include "unistr.h"	unistr/u8-strmbtouc.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-strmbtouc])	unistr/base
unistr/u16-strmbtouc	#include "unistr.h"	unistr/u16-strmbtouc.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-strmbtouc])	unistr/base
unistr/u32-strmbtouc	#include "unistr.h"	unistr/u32-strmbtouc.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-strmbtouc])	unistr/base
unistr/u8-strncat	#include "unistr.h"	unistr/u8-strncat.c	00gnulib.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 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 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 gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-strncmp])	unistr/base
unistr/u16-strncmp	#include "unistr.h"	unistr/u16-strncmp.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-strncmp])	unistr/base
unistr/u32-strncmp	#include "unistr.h"	unistr/u32-strncmp.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-strncmp])	unistr/base
unistr/u8-strncpy	#include "unistr.h"	unistr/u8-strncpy.c	00gnulib.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 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 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 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 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 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 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 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 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 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 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 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 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 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 gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-strspn])	unistr/base unistr/u32-strchr
unistr/u8-strstr	#include "unistr.h"	unistr/u8-strstr.c unistr/u-strstr.h	00gnulib.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 unistr/u-strstr.h str-kmp.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.4], [unistr/u16-strstr])	unistr/base unistr/u16-strchr unistr/u16-strmbtouc unistr/u16-strlen unistr/u16-strnlen stdbool malloca
unistr/u32-strstr	#include "unistr.h"	unistr/u32-strstr.c unistr/u-strstr.h str-kmp.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.4], [unistr/u32-strstr])	unistr/base unistr/u32-strchr unistr/u32-strlen unistr/u32-strnlen stdbool malloca
unistr/u8-strtok	#include "unistr.h"	unistr/u8-strtok.c unistr/u-strtok.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [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 gl_LIBUNISTRING_MODULE([0.9], [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 gl_LIBUNISTRING_MODULE([0.9], [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 gl_MODULE_INDICATOR([unistr/u8-uctomb]) gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-uctomb])	unistr/base
unistr/u16-uctomb	#include "unistr.h"	unistr/u16-uctomb.c unistr/u16-uctomb-aux.c	00gnulib.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 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 gl_LIBUNISTRING_LIBHEADER([0.9.4], [uniconv.h])	unitypes
uniconv/u8-conv-from-enc	#include "uniconv.h"	uniconv/u8-conv-from-enc.c	00gnulib.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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 gl_LIBUNISTRING_LIBHEADER([0.9.4], [unistdio.h])	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 gl_PREREQ_PRINTF_ARGS	unitypes wchar
unistdio/ulc-asnprintf	#include "unistdio.h"	unistdio/ulc-asnprintf.c unistdio/u-asnprintf.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistdio/ulc-asnprintf])	unistdio/base unistdio/ulc-vasnprintf
unistdio/ulc-asprintf	#include "unistdio.h"	unistdio/ulc-asprintf.c unistdio/u-asprintf.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistdio/ulc-asprintf])	unistdio/base unistdio/ulc-vasprintf
unistdio/ulc-fprintf	#include "unistdio.h"	unistdio/ulc-fprintf.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [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 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 gl_LIBUNISTRING_MODULE([0.9], [unistdio/ulc-snprintf])	unistdio/base unistdio/ulc-vsnprintf
unistdio/ulc-sprintf	#include "unistdio.h"	unistdio/ulc-sprintf.c unistdio/u-sprintf.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [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 longlong.m4 intmax_t.m4 stdint_h.m4 inttypes_h.m4 exponentd.m4 00gnulib.m4 gl_PREREQ_VASNPRINTF_WITH_EXTRAS gl_LIBUNISTRING_MODULE([0.9], [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 mbsnlen isnand-nolibm isnanl-nolibm frexpl-nolibm printf-frexp printf-frexpl signbit fpucw nocrash printf-safe alloca-opt localcharset xsize errno memchr multiarch verify
unistdio/ulc-vasprintf	#include "unistdio.h"	unistdio/ulc-vasprintf.c unistdio/u-vasprintf.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unistdio/ulc-vasprintf])	unistdio/base unistdio/ulc-vasnprintf errno
unistdio/ulc-vfprintf	#include "unistdio.h"	unistdio/ulc-vfprintf.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [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 gl_LIBUNISTRING_MODULE([0.9], [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 gl_LIBUNISTRING_MODULE([0.9], [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 gl_LIBUNISTRING_MODULE([0.9], [unistdio/u8-asnprintf])	unistdio/base unistdio/u8-vasnprintf
unistdio/u8-asprintf	#include "unistdio.h"	unistdio/u8-asprintf.c unistdio/u-asprintf.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [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 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 gl_LIBUNISTRING_MODULE([0.9], [unistdio/u8-snprintf])	unistdio/base unistdio/u8-vsnprintf
unistdio/u8-sprintf	#include "unistdio.h"	unistdio/u8-sprintf.c unistdio/u-sprintf.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [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 longlong.m4 intmax_t.m4 stdint_h.m4 inttypes_h.m4 exponentd.m4 00gnulib.m4 gl_PREREQ_VASNPRINTF_WITH_EXTRAS gl_LIBUNISTRING_MODULE([0.9], [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 isnand-nolibm isnanl-nolibm frexpl-nolibm printf-frexp printf-frexpl signbit fpucw nocrash printf-safe alloca-opt localcharset xsize errno memchr multiarch verify
unistdio/u8-vasprintf	#include "unistdio.h"	unistdio/u8-vasprintf.c unistdio/u-vasprintf.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [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 gl_LIBUNISTRING_MODULE([0.9], [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 gl_LIBUNISTRING_MODULE([0.9], [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 gl_LIBUNISTRING_MODULE([0.9], [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 gl_LIBUNISTRING_MODULE([0.9], [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 gl_LIBUNISTRING_MODULE([0.9], [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 gl_LIBUNISTRING_MODULE([0.9], [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 longlong.m4 intmax_t.m4 stdint_h.m4 inttypes_h.m4 exponentd.m4 00gnulib.m4 gl_PREREQ_VASNPRINTF_WITH_EXTRAS gl_LIBUNISTRING_MODULE([0.9], [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 isnand-nolibm isnanl-nolibm frexpl-nolibm printf-frexp printf-frexpl signbit fpucw nocrash printf-safe alloca-opt localcharset xsize errno memchr multiarch verify
unistdio/u8-u8-vasprintf	#include "unistdio.h"	unistdio/u8-u8-vasprintf.c unistdio/u-vasprintf.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [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 gl_LIBUNISTRING_MODULE([0.9], [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 gl_LIBUNISTRING_MODULE([0.9], [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 gl_LIBUNISTRING_MODULE([0.9], [unistdio/u16-asnprintf])	unistdio/base unistdio/u16-vasnprintf
unistdio/u16-asprintf	#include "unistdio.h"	unistdio/u16-asprintf.c unistdio/u-asprintf.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [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 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 gl_LIBUNISTRING_MODULE([0.9], [unistdio/u16-snprintf])	unistdio/base unistdio/u16-vsnprintf
unistdio/u16-sprintf	#include "unistdio.h"	unistdio/u16-sprintf.c unistdio/u-sprintf.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [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 longlong.m4 intmax_t.m4 stdint_h.m4 inttypes_h.m4 exponentd.m4 00gnulib.m4 gl_PREREQ_VASNPRINTF_WITH_EXTRAS gl_LIBUNISTRING_MODULE([0.9], [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 isnand-nolibm isnanl-nolibm frexpl-nolibm printf-frexp printf-frexpl signbit fpucw nocrash printf-safe alloca-opt localcharset xsize errno memchr multiarch verify
unistdio/u16-vasprintf	#include "unistdio.h"	unistdio/u16-vasprintf.c unistdio/u-vasprintf.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [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 gl_LIBUNISTRING_MODULE([0.9], [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 gl_LIBUNISTRING_MODULE([0.9], [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 gl_LIBUNISTRING_MODULE([0.9], [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 gl_LIBUNISTRING_MODULE([0.9], [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 gl_LIBUNISTRING_MODULE([0.9], [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 gl_LIBUNISTRING_MODULE([0.9], [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 longlong.m4 intmax_t.m4 stdint_h.m4 inttypes_h.m4 exponentd.m4 00gnulib.m4 gl_PREREQ_VASNPRINTF_WITH_EXTRAS gl_LIBUNISTRING_MODULE([0.9], [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 isnand-nolibm isnanl-nolibm frexpl-nolibm printf-frexp printf-frexpl signbit fpucw nocrash printf-safe alloca-opt localcharset xsize errno memchr multiarch verify
unistdio/u16-u16-vasprintf	#include "unistdio.h"	unistdio/u16-u16-vasprintf.c unistdio/u-vasprintf.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [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 gl_LIBUNISTRING_MODULE([0.9], [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 gl_LIBUNISTRING_MODULE([0.9], [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 gl_LIBUNISTRING_MODULE([0.9], [unistdio/u32-asnprintf])	unistdio/base unistdio/u32-vasnprintf
unistdio/u32-asprintf	#include "unistdio.h"	unistdio/u32-asprintf.c unistdio/u-asprintf.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [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 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 gl_LIBUNISTRING_MODULE([0.9], [unistdio/u32-snprintf])	unistdio/base unistdio/u32-vsnprintf
unistdio/u32-sprintf	#include "unistdio.h"	unistdio/u32-sprintf.c unistdio/u-sprintf.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [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 longlong.m4 intmax_t.m4 stdint_h.m4 inttypes_h.m4 exponentd.m4 00gnulib.m4 gl_PREREQ_VASNPRINTF_WITH_EXTRAS gl_LIBUNISTRING_MODULE([0.9], [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 isnand-nolibm isnanl-nolibm frexpl-nolibm printf-frexp printf-frexpl signbit fpucw nocrash printf-safe alloca-opt localcharset xsize errno memchr multiarch verify
unistdio/u32-vasprintf	#include "unistdio.h"	unistdio/u32-vasprintf.c unistdio/u-vasprintf.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [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 gl_LIBUNISTRING_MODULE([0.9], [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 gl_LIBUNISTRING_MODULE([0.9], [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 gl_LIBUNISTRING_MODULE([0.9], [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 gl_LIBUNISTRING_MODULE([0.9], [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 gl_LIBUNISTRING_MODULE([0.9], [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 gl_LIBUNISTRING_MODULE([0.9], [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 longlong.m4 intmax_t.m4 stdint_h.m4 inttypes_h.m4 exponentd.m4 00gnulib.m4 gl_PREREQ_VASNPRINTF_WITH_EXTRAS gl_LIBUNISTRING_MODULE([0.9], [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 isnand-nolibm isnanl-nolibm frexpl-nolibm printf-frexp printf-frexpl signbit fpucw nocrash printf-safe alloca-opt localcharset xsize errno memchr multiarch verify
unistdio/u32-u32-vasprintf	#include "unistdio.h"	unistdio/u32-u32-vasprintf.c unistdio/u-vasprintf.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [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 gl_LIBUNISTRING_MODULE([0.9], [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 gl_LIBUNISTRING_MODULE([0.9], [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 gl_LIBUNISTRING_LIBHEADER([0.9.5], [uniname.h])	unitypes
uniname/uniname	#include "uniname.h"	uniname/gen-uninames.lisp uniname/uninames.h uniname/uniname.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [uniname/uniname])	uniname/base memcmp
unictype/base	#include "unictype.h"	unictype.in.h	libunistring-base.m4 00gnulib.m4 gl_LIBUNISTRING_LIBHEADER([0.9.4], [unictype.h])	unitypes stdbool
unictype/bidicategory-byname	#include "unictype.h"	---	00gnulib.m4	unictype/bidiclass-byname
unictype/bidicategory-name	#include "unictype.h"	---	00gnulib.m4	unictype/bidiclass-name
unictype/bidicategory-of	#include "unictype.h"	---	00gnulib.m4	unictype/bidiclass-of
unictype/bidicategory-test	#include "unictype.h"	---	00gnulib.m4	unictype/bidiclass-test
unictype/bidicategory-all	#include "unictype.h"	---	00gnulib.m4	unictype/bidiclass-all
unictype/block-list	#include "unictype.h"	unictype/blocks.c unictype/blocks.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/block-list])	unictype/base
unictype/block-of	#include "unictype.h"	---	00gnulib.m4	unictype/base unictype/block-list
unictype/block-test	#include "unictype.h"	unictype/block_test.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.5], [unictype/block-test])	unictype/base
unictype/block-all	#include "unictype.h"	---	00gnulib.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 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/category-C])	unictype/base
unictype/category-Cc	#include "unictype.h"	unictype/categ_Cc.c unictype/categ_Cc.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/category-Cc])	unictype/base
unictype/category-Cf	#include "unictype.h"	unictype/categ_Cf.c unictype/categ_Cf.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/category-Cf])	unictype/base
unictype/category-Cn	#include "unictype.h"	unictype/categ_Cn.c unictype/categ_Cn.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/category-Cn])	unictype/base
unictype/category-Co	#include "unictype.h"	unictype/categ_Co.c unictype/categ_Co.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/category-Co])	unictype/base
unictype/category-Cs	#include "unictype.h"	unictype/categ_Cs.c unictype/categ_Cs.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/category-Cs])	unictype/base
unictype/category-L	#include "unictype.h"	unictype/categ_L.c unictype/categ_L.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/category-L])	unictype/base
unictype/category-Ll	#include "unictype.h"	unictype/categ_Ll.c unictype/categ_Ll.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/category-Ll])	unictype/base
unictype/category-Lm	#include "unictype.h"	unictype/categ_Lm.c unictype/categ_Lm.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/category-Lm])	unictype/base
unictype/category-Lo	#include "unictype.h"	unictype/categ_Lo.c unictype/categ_Lo.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/category-Lo])	unictype/base
unictype/category-Lt	#include "unictype.h"	unictype/categ_Lt.c unictype/categ_Lt.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/category-Lt])	unictype/base
unictype/category-Lu	#include "unictype.h"	unictype/categ_Lu.c unictype/categ_Lu.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/category-Lu])	unictype/base
unictype/category-M	#include "unictype.h"	unictype/categ_M.c unictype/categ_M.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/category-M])	unictype/base
unictype/category-Mc	#include "unictype.h"	unictype/categ_Mc.c unictype/categ_Mc.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/category-Mc])	unictype/base
unictype/category-Me	#include "unictype.h"	unictype/categ_Me.c unictype/categ_Me.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/category-Me])	unictype/base
unictype/category-Mn	#include "unictype.h"	unictype/categ_Mn.c unictype/categ_Mn.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/category-Mn])	unictype/base
unictype/category-N	#include "unictype.h"	unictype/categ_N.c unictype/categ_N.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/category-N])	unictype/base
unictype/category-Nd	#include "unictype.h"	unictype/categ_Nd.c unictype/categ_Nd.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/category-Nd])	unictype/base
unictype/category-Nl	#include "unictype.h"	unictype/categ_Nl.c unictype/categ_Nl.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/category-Nl])	unictype/base
unictype/category-No	#include "unictype.h"	unictype/categ_No.c unictype/categ_No.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/category-No])	unictype/base
unictype/category-P	#include "unictype.h"	unictype/categ_P.c unictype/categ_P.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/category-P])	unictype/base
unictype/category-Pc	#include "unictype.h"	unictype/categ_Pc.c unictype/categ_Pc.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/category-Pc])	unictype/base
unictype/category-Pd	#include "unictype.h"	unictype/categ_Pd.c unictype/categ_Pd.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/category-Pd])	unictype/base
unictype/category-Pe	#include "unictype.h"	unictype/categ_Pe.c unictype/categ_Pe.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/category-Pe])	unictype/base
unictype/category-Pf	#include "unictype.h"	unictype/categ_Pf.c unictype/categ_Pf.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/category-Pf])	unictype/base
unictype/category-Pi	#include "unictype.h"	unictype/categ_Pi.c unictype/categ_Pi.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/category-Pi])	unictype/base
unictype/category-Po	#include "unictype.h"	unictype/categ_Po.c unictype/categ_Po.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/category-Po])	unictype/base
unictype/category-Ps	#include "unictype.h"	unictype/categ_Ps.c unictype/categ_Ps.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/category-Ps])	unictype/base
unictype/category-S	#include "unictype.h"	unictype/categ_S.c unictype/categ_S.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/category-S])	unictype/base
unictype/category-Sc	#include "unictype.h"	unictype/categ_Sc.c unictype/categ_Sc.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/category-Sc])	unictype/base
unictype/category-Sk	#include "unictype.h"	unictype/categ_Sk.c unictype/categ_Sk.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/category-Sk])	unictype/base
unictype/category-Sm	#include "unictype.h"	unictype/categ_Sm.c unictype/categ_Sm.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/category-Sm])	unictype/base
unictype/category-So	#include "unictype.h"	unictype/categ_So.c unictype/categ_So.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/category-So])	unictype/base
unictype/category-Z	#include "unictype.h"	unictype/categ_Z.c unictype/categ_Z.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/category-Z])	unictype/base
unictype/category-Zl	#include "unictype.h"	unictype/categ_Zl.c unictype/categ_Zl.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/category-Zl])	unictype/base
unictype/category-Zp	#include "unictype.h"	unictype/categ_Zp.c unictype/categ_Zp.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/category-Zp])	unictype/base
unictype/category-Zs	#include "unictype.h"	unictype/categ_Zs.c unictype/categ_Zs.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/category-Zs])	unictype/base
unictype/category-and	#include "unictype.h"	unictype/categ_and.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9], [unictype/category-name])	unictype/base
unictype/category-none	#include "unictype.h"	unictype/categ_none.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.5], [unictype/category-none])	unictype/base
unictype/category-of	#include "unictype.h"	unictype/categ_of.c unictype/categ_of.h	00gnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [unictype/category-of])	unictype/base unictype/category-none
unictype/category-or	#include "unictype.h"	unictype/categ_or.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/category-or])	unictype/base unictype/category-test-withtable
unictype/category-test	#include "unictype.h"	unictype/categ_test.c unictype/bitmap.h	00gnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.5], [unictype/category-test])	unictype/base
unictype/category-test-withtable	#include "unictype.h"	---	00gnulib.m4	unictype/base unictype/category-of
unictype/category-all	#include "unictype.h"	---	00gnulib.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 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/combining-class])	unictype/base
unictype/ctype-alnum	#include "unictype.h"	unictype/ctype_alnum.c unictype/ctype_alnum.h unictype/bitmap.h	00gnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [unictype/ctype-alnum])	unictype/base
unictype/ctype-alpha	#include "unictype.h"	unictype/ctype_alpha.c unictype/ctype_alpha.h unictype/bitmap.h	00gnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [unictype/ctype-alpha])	unictype/base
unictype/ctype-blank	#include "unictype.h"	unictype/ctype_blank.c unictype/ctype_blank.h unictype/bitmap.h	00gnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [unictype/ctype-blank])	unictype/base
unictype/ctype-cntrl	#include "unictype.h"	unictype/ctype_cntrl.c unictype/ctype_cntrl.h unictype/bitmap.h	00gnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [unictype/ctype-cntrl])	unictype/base
unictype/ctype-digit	#include "unictype.h"	unictype/ctype_digit.c unictype/ctype_digit.h unictype/bitmap.h	00gnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [unictype/ctype-digit])	unictype/base
unictype/ctype-graph	#include "unictype.h"	unictype/ctype_graph.c unictype/ctype_graph.h unictype/bitmap.h	00gnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [unictype/ctype-graph])	unictype/base
unictype/ctype-lower	#include "unictype.h"	unictype/ctype_lower.c unictype/ctype_lower.h unictype/bitmap.h	00gnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [unictype/ctype-lower])	unictype/base
unictype/ctype-print	#include "unictype.h"	unictype/ctype_print.c unictype/ctype_print.h unictype/bitmap.h	00gnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [unictype/ctype-print])	unictype/base
unictype/ctype-punct	#include "unictype.h"	unictype/ctype_punct.c unictype/ctype_punct.h unictype/bitmap.h	00gnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [unictype/ctype-punct])	unictype/base
unictype/ctype-space	#include "unictype.h"	unictype/ctype_space.c unictype/ctype_space.h unictype/bitmap.h	00gnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [unictype/ctype-space])	unictype/base
unictype/ctype-upper	#include "unictype.h"	unictype/ctype_upper.c unictype/ctype_upper.h unictype/bitmap.h	00gnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [unictype/ctype-upper])	unictype/base
unictype/ctype-xdigit	#include "unictype.h"	unictype/ctype_xdigit.c unictype/ctype_xdigit.h unictype/bitmap.h	00gnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [unictype/ctype-xdigit])	unictype/base
unictype/decimal-digit	#include "unictype.h"	unictype/decdigit.c unictype/decdigit.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/decimal-digit])	unictype/base
unictype/digit	#include "unictype.h"	unictype/digit.c unictype/digit.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/digit])	unictype/base
unictype/mirror	#include "unictype.h"	unictype/mirror.c unictype/mirror.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/mirror])	unictype/base
unictype/numeric	#include "unictype.h"	unictype/numeric.c unictype/numeric.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/numeric])	unictype/base
unictype/property-alphabetic	#include "unictype.h"	unictype/pr_alphabetic.c unictype/pr_alphabetic.h unictype/bitmap.h	00gnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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-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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [unictype/property-combining])	unictype/base
unictype/property-composite	#include "unictype.h"	unictype/pr_composite.c unictype/pr_composite.h unictype/bitmap.h	00gnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [unictype/property-deprecated])	unictype/base
unictype/property-diacritic	#include "unictype.h"	unictype/pr_diacritic.c unictype/pr_diacritic.h unictype/bitmap.h	00gnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [unictype/property-diacritic])	unictype/base
unictype/property-extender	#include "unictype.h"	unictype/pr_extender.c unictype/pr_extender.h unictype/bitmap.h	00gnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [unictype/property-lowercase])	unictype/base
unictype/property-math	#include "unictype.h"	unictype/pr_math.c unictype/pr_math.h unictype/bitmap.h	00gnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [unictype/property-terminal-punctuation])	unictype/base
unictype/property-test	#include "unictype.h"	unictype/pr_test.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unictype/property-test])	unictype/base
unictype/property-titlecase	#include "unictype.h"	unictype/pr_titlecase.c unictype/pr_titlecase.h unictype/bitmap.h	00gnulib.m4 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [unictype/property-zero-width])	unictype/base
unictype/property-all	#include "unictype.h"	---	00gnulib.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-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-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 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/scripts])	unictype/base gperf
unictype/scripts-all	#include "unictype.h"	---	00gnulib.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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [unictype/syntax-c-ident])	unictype/base
unictype/syntax-c-whitespace	#include "unictype.h"	unictype/sy_c_whitespace.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [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 AC_REQUIRE([AC_C_INLINE]) gl_LIBUNISTRING_MODULE([0.9.6], [unictype/syntax-java-ident])	unictype/base
unictype/syntax-java-whitespace	#include "unictype.h"	unictype/sy_java_whitespace.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9], [unictype/syntax-java-whitespace])	unictype/base
uniwidth/base	#include "uniwidth.h"	uniwidth.in.h localcharset.h	libunistring-base.m4 00gnulib.m4 gl_LIBUNISTRING_LIBHEADER([0.9.4], [uniwidth.h])	unitypes
uniwidth/u8-strwidth	#include "uniwidth.h"	uniwidth/u8-strwidth.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [uniwidth/u8-strwidth])	uniwidth/base uniwidth/u8-width unistr/u8-strlen
uniwidth/u8-width	#include "uniwidth.h"	uniwidth/u8-width.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [uniwidth/u8-width])	uniwidth/base uniwidth/width unistr/u8-mbtouc-unsafe
uniwidth/u16-strwidth	#include "uniwidth.h"	uniwidth/u16-strwidth.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [uniwidth/u16-strwidth])	uniwidth/base uniwidth/u16-width unistr/u16-strlen
uniwidth/u16-width	#include "uniwidth.h"	uniwidth/u16-width.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [uniwidth/u16-width])	uniwidth/base uniwidth/width unistr/u16-mbtouc-unsafe
uniwidth/u32-strwidth	#include "uniwidth.h"	uniwidth/u32-strwidth.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [uniwidth/u32-strwidth])	uniwidth/base uniwidth/u32-width unistr/u32-strlen
uniwidth/u32-width	#include "uniwidth.h"	uniwidth/u32-width.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [uniwidth/u32-width])	uniwidth/base uniwidth/width
uniwidth/width	#include "uniwidth.h"	uniwidth/width.c uniwidth/cjk.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [uniwidth/width])	uniwidth/base streq
uniwbrk/base	#include "uniwbrk.h"	uniwbrk.in.h	libunistring-base.m4 00gnulib.m4 gl_LIBUNISTRING_LIBHEADER([0.9.4], [uniwbrk.h])	unitypes
uniwbrk/ulc-wordbreaks	#include "uniwbrk.h"	uniwbrk/ulc-wordbreaks.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [uniwbrk/u8-wordbreaks])	uniwbrk/base uniwbrk/wordbreak-property uniwbrk/table unistr/u8-mbtouc-unsafe
uniwbrk/u16-wordbreaks	#include "uniwbrk.h"	uniwbrk/u16-wordbreaks.c uniwbrk/u-wordbreaks.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [uniwbrk/u16-wordbreaks])	uniwbrk/base uniwbrk/wordbreak-property uniwbrk/table unistr/u16-mbtouc-unsafe
uniwbrk/u32-wordbreaks	#include "uniwbrk.h"	uniwbrk/u32-wordbreaks.c uniwbrk/u-wordbreaks.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [uniwbrk/u32-wordbreaks])	uniwbrk/base uniwbrk/wordbreak-property uniwbrk/table unistr/u32-mbtouc-unsafe
uniwbrk/wordbreak-property	#include "uniwbrk.h"	uniwbrk/wordbreak-property.c uniwbrk/wbrkprop.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [uniwbrk/wordbreak-property])	uniwbrk/base
unilbrk/base	#include "unilbrk.h"	unilbrk.in.h	libunistring-base.m4 00gnulib.m4 gl_LIBUNISTRING_LIBHEADER([0.9.4], [unilbrk.h])	unitypes localcharset
unilbrk/tables	#include "unilbrk/lbrktables.h"	unilbrk/lbrktables.c unilbrk/lbrkprop1.h unilbrk/lbrkprop2.h	00gnulib.m4 AC_REQUIRE([AC_C_INLINE])	unilbrk/base
unilbrk/ulc-common	#include "unilbrk/ulc-common.h"	unilbrk/ulc-common.c	00gnulib.m4	c-ctype c-strcaseeq
unilbrk/u8-possible-linebreaks	#include "unilbrk.h"	unilbrk/u8-possible-linebreaks.c uniwidth/cjk.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unilbrk/u8-possible-linebreaks])	unilbrk/base unilbrk/tables unistr/u8-mbtouc-unsafe streq
unilbrk/u16-possible-linebreaks	#include "unilbrk.h"	unilbrk/u16-possible-linebreaks.c uniwidth/cjk.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unilbrk/u16-possible-linebreaks])	unilbrk/base unilbrk/tables unistr/u16-mbtouc-unsafe streq
unilbrk/u32-possible-linebreaks	#include "unilbrk.h"	unilbrk/u32-possible-linebreaks.c uniwidth/cjk.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unilbrk/u32-possible-linebreaks])	unilbrk/base unilbrk/tables streq
unilbrk/ulc-possible-linebreaks	#include "unilbrk.h"	unilbrk/ulc-possible-linebreaks.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [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/u8-width-linebreaks.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_LIBHEADER([0.9.4], [uninorm.h])	unitypes
uninorm/canonical-decomposition	#include "uninorm.h"	uninorm/canonical-decomposition.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [uninorm/canonical-decomposition])	uninorm/base uninorm/decomposition-table
uninorm/composition	#include "uninorm.h"	uninorm/composition.c uninorm/composition-table.gperf	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [uninorm/composition])	uninorm/base gperf
uninorm/decomposing-form	#include "uninorm.h"	uninorm/decomposing-form.c uninorm/normalize-internal.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.5], [uninorm/decomposing-form])	uninorm/base
uninorm/decomposition	#include "uninorm.h"	uninorm/decomposition.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [uninorm/decomposition])	uninorm/base uninorm/decomposition-table
uninorm/filter	#include "uninorm.h"	uninorm/uninorm-filter.c uninorm/normalize-internal.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [uninorm/nfd])	uninorm/base uninorm/canonical-decomposition
uninorm/nfkc	#include "uninorm.h"	uninorm/nfkc.c uninorm/normalize-internal.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_MODULE_INDICATOR_FOR_TESTS([uninorm/u8-normalize]) gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_MODULE_INDICATOR_FOR_TESTS([uninorm/u16-normalize]) gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_MODULE_INDICATOR_FOR_TESTS([uninorm/u32-normalize]) gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_LIBHEADER([0.9.4], [unicase.h])	unitypes uninorm/base stdbool
unicase/empty-prefix-context	#include "unicase.h"	unicase/empty-prefix-context.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.1], [unicase/empty-prefix-context])	unicase/base
unicase/empty-suffix-context	#include "unicase.h"	unicase/empty-suffix-context.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.1], [unicase/empty-suffix-context])	unicase/base
unicase/locale-language	#include "unicase.h"	unicase/locale-language.c unicase/locale-languages.gperf	00gnulib.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 gl_LIBUNISTRING_MODULE([0.9.6], [unicase/tolower])	unicase/base
unicase/totitle	#include "unicase.h"	unicase/totitle.c unicase/totitle.h unicase/simple-mapping.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unicase/totitle])	unicase/base
unicase/toupper	#include "unicase.h"	unicase/toupper.c unicase/toupper.h unicase/simple-mapping.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unicase/toupper])	unicase/base
unicase/ulc-casecmp	#include "unicase.h"	unicase/ulc-casecmp.c unicase/u-casecmp.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [unicase/ulc-casecoll])	unicase/base unicase/ulc-casexfrm memcmp2
unicase/ulc-casexfrm	#include "unicase.h"	unicase/ulc-casexfrm.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_MODULE_INDICATOR_FOR_TESTS([cloexec])	dup2 fcntl stdbool
findprog	#include "findprog.h"	findprog.c	findprog.m4 eaccess.m4 00gnulib.m4 gl_FINDPROG	stdbool xalloc xconcat-filename unistd strdup
findprog-lgpl	#include "findprog.h"	findprog.c findprog-lgpl.c	findprog.m4 eaccess.m4 00gnulib.m4 gl_FINDPROG gl_MODULE_INDICATOR([findprog-lgpl])	stdbool strdup concat-filename unistd
wait-process	#include "wait-process.h"	wait-process.c	wait-process.m4 sig_atomic_t.m4 00gnulib.m4 gl_WAIT_PROCESS	fatal-signal error xalloc gettext-h stdbool stdlib sys_wait unistd atexit waitpid
execute	#include "execute.h"	execute.c w32spawn.h	execute.m4 00gnulib.m4 gl_EXECUTE	cloexec dup2 error fatal-signal wait-process gettext-h msvc-nothrow spawn posix_spawnp posix_spawn_file_actions_init posix_spawn_file_actions_addopen posix_spawn_file_actions_destroy posix_spawnattr_init posix_spawnattr_setsigmask posix_spawnattr_setflags posix_spawnattr_destroy stdbool stdlib strpbrk unistd environ
spawn-pipe	#include "spawn-pipe.h"	spawn-pipe.c w32spawn.h	spawn-pipe.m4 00gnulib.m4 gl_SPAWN_PIPE	cloexec dup2 environ error fatal-signal gettext-h msvc-nothrow open pipe2 pipe2-safer 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_destroy posix_spawnattr_init posix_spawnattr_setsigmask posix_spawnattr_setflags posix_spawnattr_destroy stdbool stdlib strpbrk unistd unistd-safer wait-process
pipe-filter-gi	#include "pipe-filter.h"	pipe-filter-gi.c pipe-filter-aux.h pipe-filter-aux.c	00gnulib.m4 AC_CHECK_FUNCS_ONCE([select])	spawn-pipe wait-process error extern-inline fcntl-h gettext-h stdbool stdint stdlib sys_select unistd
pipe-filter-ii	#include "pipe-filter.h"	pipe-filter-ii.c pipe-filter-aux.h pipe-filter-aux.c	00gnulib.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	quotearg xalloc

Java

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
classpath	#include "classpath.h"	classpath.c	00gnulib.m4	stdbool xsetenv xalloc
javacomp-script	---	---	javacomp.m4 00gnulib.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	stdbool unistd javaversion execute spawn-pipe wait-process classpath xsetenv sh-quote binary-io safe-read xalloc xmalloca getline xconcat-filename fwriteerror clean-temp error xvasprintf c-strstr gettext-h javacomp-script
javaexec-script	---	---	javaexec.m4 00gnulib.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	stdbool execute classpath xsetenv sh-quote xconcat-filename xalloc xmalloca error gettext-h javaexec-script
javaversion	#include "javaversion.h"	javaversion.c javaversion.java javaversion.class	00gnulib.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 AC_REQUIRE([gt_CSHARPCOMP]) AC_CONFIG_FILES([csharpcomp.sh:build-aux/csharpcomp.sh.in])	---
csharpcomp	#include "csharpcomp.h"	csharpcomp.c	00gnulib.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 # 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	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 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])])	alloca dirname-lgpl extern-inline getopt-gnu strchrnul sysexits malloc-gnu mempcpy strndup strcase extensions vsnprintf sleep stdalign strerror memchr memmove
argp-version-etc	#include "argp-version-etc.h"	argp-version-etc.c	00gnulib.m4	argp version-etc
argz	#include <argz.h>	argz.in.h argz.c	argz.m4 00gnulib.m4 gl_FUNC_ARGZ if test -n "$ARGZ_H"; then AC_LIBOBJ([argz]) fi	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"]
bitrotate	#include "bitrotate.h"	bitrotate.c	00gnulib.m4	extern-inline stdint
byteswap	#include <byteswap.h>	byteswap.in.h	byteswap.m4 00gnulib.m4 gl_BYTESWAP	---
exitfail	#include "exitfail.h"	exitfail.c	00gnulib.m4	stdlib
error	#include "error.h"	error.c	error.m4 00gnulib.m4 gl_ERROR if test $ac_cv_lib_error_at_line = no; then AC_LIBOBJ([error]) gl_PREREQ_ERROR fi m4_ifdef([AM_XGETTEXT_OPTION], [AM_][XGETTEXT_OPTION([--flag=error:3:c-format]) AM_][XGETTEXT_OPTION([--flag=error_at_line:5:c-format])])	stdio [test $ac_cv_lib_error_at_line = no] strerror [test $ac_cv_lib_error_at_line = no] unistd [test $ac_cv_lib_error_at_line = no] msvc-nothrow [test $ac_cv_lib_error_at_line = no]
extensions	---	---	extensions.m4 00gnulib.m4	---
forkpty	#include <pty.h>	forkpty.c	pty.m4 00gnulib.m4 gl_FUNC_FORKPTY if test $HAVE_FORKPTY = 0 \|\| test $REPLACE_FORKPTY = 1; then AC_LIBOBJ([forkpty]) fi gl_PTY_MODULE_INDICATOR([forkpty])	pty openpty login_tty
getdomainname	#include <unistd.h>	getdomainname.c	getdomainname.m4 00gnulib.m4 gl_FUNC_GETDOMAINNAME if test $HAVE_DECL_GETDOMAINNAME = 0 \|\| test $REPLACE_GETDOMAINNAME = 1; then AC_LIBOBJ([getdomainname]) gl_PREREQ_GETDOMAINNAME fi 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	00gnulib.m4	getdomainname xalloc
getloadavg	#include <stdlib.h>	getloadavg.c	getloadavg.m4 00gnulib.m4 gl_GETLOADAVG if test $HAVE_GETLOADAVG = 0; then AC_LIBOBJ([getloadavg]) gl_PREREQ_GETLOADAVG fi gl_STDLIB_MODULE_INDICATOR([getloadavg])	extensions intprops stdbool stdlib
getpagesize	#include <unistd.h>	getpagesize.c	getpagesize.m4 00gnulib.m4 gl_FUNC_GETPAGESIZE if test $REPLACE_GETPAGESIZE = 1; then AC_LIBOBJ([getpagesize]) fi gl_UNISTD_MODULE_INDICATOR([getpagesize])	unistd
getusershell	#include <unistd.h>	getusershell.c	getusershell.m4 00gnulib.m4 gl_FUNC_GETUSERSHELL if test $HAVE_GETUSERSHELL = 0; then AC_LIBOBJ([getusershell]) fi gl_UNISTD_MODULE_INDICATOR([getusershell])	unistd extensions fopen-safer [test $HAVE_GETUSERSHELL = 0] xalloc [test $HAVE_GETUSERSHELL = 0]
lib-symbol-visibility	---	---	visibility.m4 00gnulib.m4 gl_VISIBILITY	---
login_tty	extern int login_tty (int);	login_tty.c	pty.m4 00gnulib.m4 gl_FUNC_LOGIN_TTY if test $ac_cv_func_login_tty = no; then AC_LIBOBJ([login_tty]) fi gl_PTY_MODULE_INDICATOR([login_tty])	pty sys_ioctl
nproc	#include "nproc.h"	nproc.c	nproc.m4 00gnulib.m4 gl_NPROC	c-ctype extensions unistd
openpty	#include <pty.h>	openpty.c	pty.m4 00gnulib.m4 gl_FUNC_OPENPTY if test $HAVE_OPENPTY = 0 \|\| test $REPLACE_OPENPTY = 1; then AC_LIBOBJ([openpty]) fi 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	intprops
physmem	#include "physmem.h"	physmem.c	physmem.m4 00gnulib.m4 gl_PHYSMEM	---
posixver	#include "posixver.h"	posixver.c	posixver.m4 00gnulib.m4 gl_POSIXVER	---
progname	#include "progname.h"	progname.c	00gnulib.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 gl_FUNC_PTSNAME_R if test $HAVE_PTSNAME_R = 0 \|\| test $REPLACE_PTSNAME_R = 1; then AC_LIBOBJ([ptsname_r]) gl_PREREQ_PTSNAME_R fi gl_STDLIB_MODULE_INDICATOR([ptsname_r])	stdlib extensions isatty [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 gl_PTY_H	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 gl_QUOTEARG	c-strcaseeq extensions gettext-h mbrtowc mbsinit memcmp quotearg-simple localcharset stdbool wchar wctype-h xalloc
quote	#include "quote.h"	---	quote.m4 00gnulib.m4 gl_QUOTE	quotearg
readutmp	#include "readutmp.h"	readutmp.c	readutmp.m4 00gnulib.m4 gl_READUTMP if test $ac_cv_header_utmp_h = yes \|\| test $ac_cv_header_utmpx_h = yes; then AC_LIBOBJ([readutmp]) fi	extensions xalloc stdbool stdint
random_r	#include <stdlib.h>	random_r.c	random_r.m4 00gnulib.m4 gl_FUNC_RANDOM_R if test $HAVE_RANDOM_R = 0 \|\| test $REPLACE_RANDOM_R = 1; then AC_LIBOBJ([random_r]) gl_PREREQ_RANDOM_R fi gl_STDLIB_MODULE_INDICATOR([random_r])	stdlib stdint
selinux-h	#include <selinux/selinux.h> #include <selinux/context.h>	getfilecon.c se-context.in.h se-selinux.in.h se-context.c se-selinux.c	selinux-context-h.m4 selinux-selinux-h.m4 00gnulib.m4 gl_HEADERS_SELINUX_SELINUX_H gl_HEADERS_SELINUX_CONTEXT_H if test "$with_selinux" != no && test "$ac_cv_header_selinux_selinux_h" = yes; then AC_LIBOBJ([getfilecon]) fi	errno extern-inline snippet/unused-parameter
selinux-at	#include "selinux-at.h"	selinux-at.c at-func.c	00gnulib.m4 AC_CHECK_HEADERS([selinux/flask.h]) AC_LIBOBJ([selinux-at])	selinux-h at-internal dosname errno extensions fchdir fcntl-h openat-die openat-h save-cwd unistd
sysexits	#include <sysexits.h>	sysexits.in.h	sysexits.m4 00gnulib.m4 gl_SYSEXITS	include_next stdlib
u64	#include "u64.h"	u64.c	00gnulib.m4	extern-inline stdint
verror	#include "verror.h"	verror.c	00gnulib.m4 m4_ifdef([AM_XGETTEXT_OPTION], [AM_][XGETTEXT_OPTION([--flag=verror:3:c-format]) AM_][XGETTEXT_OPTION([--flag=verror_at_line:5:c-format])])	error 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	---
snippet/arg-nonnull	---	---	00gnulib.m4	---
config-h	---	---	config-h.m4 00gnulib.m4 gl_CONFIG_H	---
configmake	/* Include only after all system include files. */ #include "configmake.h"	---	configmake.m4 00gnulib.m4 gl_CONFIGMAKE_PREP	---
dummy	---	dummy.c	00gnulib.m4	---
gperf	---	---	00gnulib.m4	---
havelib	---	---	lib-ld.m4 lib-link.m4 lib-prefix.m4 00gnulib.m4	---
include_next	---	---	include_next.m4 00gnulib.m4	absolute-header
ldd	---	---	ldd.m4 00gnulib.m4 gl_LDD AC_CONFIG_FILES([ldd.sh:build-aux/ldd.sh.in])	---
lib-ignore	---	---	lib-ignore.m4 00gnulib.m4 gl_IGNORE_UNUSED_LIBRARIES	---
lib-msvc-compat	---	---	ld-output-def.m4 00gnulib.m4 gl_LD_OUTPUT_DEF	---
lib-symbol-versions	---	---	ld-version-script.m4 00gnulib.m4 gl_LD_VERSION_SCRIPT	---
snippet/link-warning	---	---	00gnulib.m4 AC_REQUIRE([gl_FEATURES_H])	---
manywarnings	---	---	manywarnings.m4 00gnulib.m4	warnings
no-c++	---	---	no-c++.m4 00gnulib.m4 gt_NO_CXX	---
relocatable-lib	#include "relocatable.h"	relocatable.c	relocatable-lib.m4 00gnulib.m4 gl_RELOCATABLE_LIBRARY if test $RELOCATABLE = yes; then AC_LIBOBJ([relocatable]) fi	xalloc strdup
relocatable-lib-lgpl	#include "relocatable.h"	relocatable.c	relocatable-lib.m4 00gnulib.m4 gl_RELOCATABLE_LIBRARY	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 gl_RELOCATABLE([$gl_source_base]) if test $RELOCATABLE = yes; then AC_LIBOBJ([progreloc]) AC_LIBOBJ([relocatable]) fi	relocatable-prog-wrapper progname canonicalize-lgpl xalloc xreadlink 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 canonicalize-lgpl.c malloca.h malloca.c relocatable.h relocatable.c setenv.c c-ctype.h c-ctype.c	malloca.m4 canonicalize.m4 eealloc.m4 environ.m4 longlong.m4 readlink.m4 relocatable-lib.m4 setenv.m4 00gnulib.m4 gl_FUNC_READLINK_SEPARATE gl_CANONICALIZE_LGPL_SEPARATE gl_MALLOCA gl_RELOCATABLE_LIBRARY gl_FUNC_SETENV_SEPARATE	alloca-opt double-slash-root errno pathmax ssize_t stdbool stdint stdlib unistd environ intprops string verify
relocatable-script	---	---	relocatable-lib.m4 00gnulib.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.m4 00gnulib.m4	---
warnings	---	---	warnings.m4 00gnulib.m4	---

Support for building documentation

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

Support for maintaining and releasing projects

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
announce-gen	---	---	00gnulib.m4	---
autobuild	---	---	autobuild.m4 00gnulib.m4	---
do-release-commit-and-tag	---	---	00gnulib.m4	---
git-version-gen	---	---	00gnulib.m4	---
gitlog-to-changelog	---	---	00gnulib.m4	---
gnu-web-doc-update	---	---	00gnulib.m4	gendocs
gnumakefile	---	---	00gnulib.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	---
maintainer-makefile	---	---	00gnulib.m4 AC_CONFIG_COMMANDS_PRE([m4_ifdef([AH_HEADER], [AC_SUBST([CONFIG_INCLUDE], m4_defn([AH_HEADER]))])]) AC_REQUIRE([AC_PROG_SED])	gnumakefile useless-if-before-free vc-list-files
mktempd	---	---	00gnulib.m4	---
non-recursive-gnulib-prefix-hack	---	---	non-recursive-gnulib-prefix-hack.m4 00gnulib.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([ gl_NON_RECURSIVE_GNULIB_PREFIX_HACK([lib]) ])	---
readme-release	---	---	00gnulib.m4	announce-gen do-release-commit-and-tag gnu-web-doc-update gnupload maintainer-makefile
test-framework-sh	---	---	00gnulib.m4	---
update-copyright	---	---	00gnulib.m4	---
useless-if-before-free	---	---	00gnulib.m4	---
vc-list-files	---	---	00gnulib.m4	---

Misc

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

Unclassified modules - please update MODULES.html.sh

modules/	lib/	lib/	m4/
Module	Header	Implementation	Autoconf macro	Depends on
acosf	#include <math.h>	acosf.c	acosf.m4 00gnulib.m4 gl_FUNC_ACOSF if test $HAVE_ACOSF = 0; then AC_LIBOBJ([acosf]) fi gl_MATH_MODULE_INDICATOR([acosf])	math extensions acos [test $HAVE_ACOSF = 0]
allocator	#include "allocator.h"	allocator.c	00gnulib.m4	---
ansi-c++-opt	---	---	ansi-c++.m4 00gnulib.m4 gl_PROG_ANSI_CXX([CXX], [ANSICXX])	---
asinf	#include <math.h>	asinf.c	asinf.m4 00gnulib.m4 gl_FUNC_ASINF if test $HAVE_ASINF = 0; then AC_LIBOBJ([asinf]) fi 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 gl_ASSERT_H	include_next
at-internal	#include "openat-priv.h"	openat-proc.c	00gnulib.m4 AC_LIBOBJ([openat-proc])	errno fcntl-h intprops open sys_stat unistd
atan2f	#include <math.h>	atan2f.c	atan2f.m4 00gnulib.m4 gl_FUNC_ATAN2F if test $HAVE_ATAN2F = 0; then AC_LIBOBJ([atan2f]) fi gl_MATH_MODULE_INDICATOR([atan2f])	math extensions atan2 [test $HAVE_ATAN2F = 0]
atanf	#include <math.h>	atanf.c	atanf.m4 00gnulib.m4 gl_FUNC_ATANF if test $HAVE_ATANF = 0; then AC_LIBOBJ([atanf]) fi gl_MATH_MODULE_INDICATOR([atanf])	math extensions atan [test $HAVE_ATANF = 0]
c-snprintf	#include "c-snprintf.h"	c-snprintf.c	00gnulib.m4	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 longlong.m4 intmax_t.m4 stdint_h.m4 inttypes_h.m4 vasnprintf.m4 printf.m4 math_h.m4 exponentd.m4 00gnulib.m4 gl_PREREQ_VASNPRINTF_WITH_EXTRAS	isnand-nolibm isnanl-nolibm frexpl-nolibm printf-frexp printf-frexpl signbit fpucw nocrash printf-safe alloca-opt xsize errno memchr multiarch verify
c-vasprintf	#include "c-vasprintf.h"	c-asprintf.c c-vasprintf.c	00gnulib.m4	c-vasnprintf
c-vsnprintf	#include "c-vsnprintf.h"	c-vsnprintf.c	00gnulib.m4	c-vasnprintf
c-xvasprintf	#include "c-xvasprintf.h"	c-xasprintf.c c-xvasprintf.c	00gnulib.m4	c-vasprintf
calloc	#include <stdlib.h>	---	00gnulib.m4	calloc-gnu
careadlinkat	#include "careadlinkat.h"	careadlinkat.c	00gnulib.m4 AC_CHECK_FUNCS_ONCE([readlinkat])	allocator ssize_t unistd
cbrt-ieee	#include <math.h>	---	00gnulib.m4	cbrt fpieee
cbrtf	#include <math.h>	cbrtf.c	cbrtf.m4 cbrt.m4 mathfunc.m4 00gnulib.m4 gl_FUNC_CBRTF if test $HAVE_CBRTF = 0 \|\| test $REPLACE_CBRTF = 1; then AC_LIBOBJ([cbrtf]) fi 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	cbrtf fpieee
cbrtl	#include <math.h>	cbrtl.c	cbrtl.m4 cbrt.m4 mathfunc.m4 00gnulib.m4 gl_FUNC_CBRTL if test $HAVE_CBRTL = 0 \|\| test $REPLACE_CBRTL = 1; then AC_LIBOBJ([cbrtl]) fi 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 gl_FUNC_CBRTL_IEEE	cbrtl fpieee
ceil-ieee	#include <math.h>	---	ceil-ieee.m4 minus-zero.m4 signbit.m4 00gnulib.m4 gl_FUNC_CEIL_IEEE	ceil
ceilf-ieee	#include <math.h>	---	ceilf-ieee.m4 minus-zero.m4 signbit.m4 00gnulib.m4 gl_FUNC_CEILF_IEEE	ceilf
ceill-ieee	#include <math.h>	---	ceill-ieee.m4 minus-zero.m4 signbit.m4 00gnulib.m4 gl_FUNC_CEILL_IEEE	ceill
chdir	#include <unistd.h>	---	00gnulib.m4 gl_UNISTD_MODULE_INDICATOR([chdir])	unistd
closedir	#include <dirent.h>	closedir.c dirent-private.h	closedir.m4 00gnulib.m4 gl_FUNC_CLOSEDIR if test $HAVE_CLOSEDIR = 0 \|\| test $REPLACE_CLOSEDIR = 1; then AC_LIBOBJ([closedir]) fi gl_DIRENT_MODULE_INDICATOR([closedir])	dirent
copysignf	#include <math.h>	copysignf.c	copysignf.m4 mathfunc.m4 00gnulib.m4 gl_FUNC_COPYSIGNF if test $HAVE_COPYSIGNF = 0; then AC_LIBOBJ([copysignf]) fi gl_MATH_MODULE_INDICATOR([copysignf])	math extensions signbit [test $HAVE_COPYSIGNF = 0]
copysignl	#include <math.h>	copysignl.c	copysignl.m4 mathfunc.m4 00gnulib.m4 gl_FUNC_COPYSIGNL if test $HAVE_COPYSIGNL = 0; then AC_LIBOBJ([copysignl]) fi 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 gl_FUNC_COSF if test $HAVE_COSF = 0; then AC_LIBOBJ([cosf]) fi gl_MATH_MODULE_INDICATOR([cosf])	math extensions cos [test $HAVE_COSF = 0]
coshf	#include <math.h>	coshf.c	coshf.m4 00gnulib.m4 gl_FUNC_COSHF if test $HAVE_COSHF = 0; then AC_LIBOBJ([coshf]) fi gl_MATH_MODULE_INDICATOR([coshf])	math extensions cosh [test $HAVE_COSHF = 0]
crypto/gc-hmac-sha256	#include "gc.h"	---	gc-hmac-sha256.m4 00gnulib.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 gl_GC_HMAC_SHA512 gl_MODULE_INDICATOR([gc-hmac-sha512])	crypto/gc crypto/hmac-sha512 [test "$ac_cv_libgcrypt" != yes]
crypto/hmac-sha256	#include "hmac.h"	hmac-sha256.c	00gnulib.m4	memxor crypto/sha256
crypto/hmac-sha512	#include "hmac.h"	hmac-sha512.c	00gnulib.m4	memxor crypto/sha512
di-set	#include "di-set.h"	di-set.c	00gnulib.m4	ino-map hash
dosname	#include "dosname.h"	---	00gnulib.m4	---
dtotimespec	#include "timespec.h"	dtotimespec.c	00gnulib.m4	intprops timespec
dup	#include <unistd.h>	dup.c	dup.m4 00gnulib.m4 gl_FUNC_DUP if test $REPLACE_DUP = 1; then AC_LIBOBJ([dup]) gl_PREREQ_DUP fi gl_UNISTD_MODULE_INDICATOR([dup])	unistd msvc-inval [test $REPLACE_DUP = 1]
dup2-obsolete	#include <unistd.h>	---	dup2-obsolete.m4 00gnulib.m4 gl_FUNC_DUP2_OBSOLETE	dup2
exp-ieee	#include <math.h>	---	00gnulib.m4	exp fpieee
exp2	#include <math.h>	exp2.c	exp2.m4 mathfunc.m4 00gnulib.m4 gl_FUNC_EXP2 if test $HAVE_EXP2 = 0 \|\| test $REPLACE_EXP2 = 1; then AC_LIBOBJ([exp2]) fi 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	exp2 fpieee
exp2f	#include <math.h>	exp2f.c	exp2f.m4 00gnulib.m4 gl_FUNC_EXP2F if test $HAVE_EXP2F = 0; then AC_LIBOBJ([exp2f]) fi gl_MATH_MODULE_INDICATOR([exp2f])	math extensions exp2 [test $HAVE_EXP2F = 0]
exp2f-ieee	#include <math.h>	---	00gnulib.m4	exp2f fpieee
exp2l	#include <math.h>	exp2l.c expl-table.c	exp2l.m4 00gnulib.m4 gl_FUNC_EXP2L if test $HAVE_EXP2L = 0 \|\| test $REPLACE_EXP2L = 1; then AC_LIBOBJ([exp2l]) AC_LIBOBJ([expl-table]) fi 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 gl_FUNC_EXP2L_IEEE	exp2l fpieee
expf	#include <math.h>	expf.c	expf.m4 00gnulib.m4 gl_FUNC_EXPF if test $HAVE_EXPF = 0; then AC_LIBOBJ([expf]) fi gl_MATH_MODULE_INDICATOR([expf])	math extensions exp [test $HAVE_EXPF = 0]
expf-ieee	#include <math.h>	---	00gnulib.m4	expf fpieee
expl-ieee	#include <math.h>	---	00gnulib.m4	expl fpieee
expm1	#include <math.h>	expm1.c	expm1.m4 mathfunc.m4 00gnulib.m4 gl_FUNC_EXPM1 if test $HAVE_EXPM1 = 0 \|\| test $REPLACE_EXPM1 = 1; then AC_LIBOBJ([expm1]) fi 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 gl_FUNC_EXPM1_IEEE	expm1 fpieee
expm1f	#include <math.h>	expm1f.c	expm1f.m4 00gnulib.m4 gl_FUNC_EXPM1F if test $HAVE_EXPM1F = 0 \|\| test $REPLACE_EXPM1F = 1; then AC_LIBOBJ([expm1f]) fi gl_MATH_MODULE_INDICATOR([expm1f])	math extensions expm1 [test $HAVE_EXPM1F = 0 \|\| test $REPLACE_EXPM1F = 1]
expm1f-ieee	#include <math.h>	---	00gnulib.m4 AC_REQUIRE([gl_FUNC_EXPM1F])	expm1f fpieee expm1-ieee [test $HAVE_EXPM1F = 0]
expm1l	#include <math.h>	expm1l.c	expm1l.m4 00gnulib.m4 gl_FUNC_EXPM1L if test $HAVE_EXPM1L = 0; then AC_LIBOBJ([expm1l]) fi gl_MATH_MODULE_INDICATOR([expm1l])	math extensions expm1 [test $HAVE_EXPM1L = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] float [test $HAVE_EXPM1L = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] isnanl [test $HAVE_EXPM1L = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] expl [test $HAVE_EXPM1L = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] roundl [test $HAVE_EXPM1L = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] ldexpl [test $HAVE_EXPM1L = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
expm1l-ieee	#include <math.h>	---	00gnulib.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 AC_REQUIRE([gl_EXTERN_INLINE])	---
fabs-ieee	#include <math.h>	---	00gnulib.m4	fabs fpieee
fabsf	#include <math.h>	fabsf.c	fabsf.m4 mathfunc.m4 00gnulib.m4 gl_FUNC_FABSF if test $HAVE_FABSF = 0; then AC_LIBOBJ([fabsf]) fi gl_MATH_MODULE_INDICATOR([fabsf])	math extensions fabs [test $HAVE_FABSF = 0]
fabsf-ieee	#include <math.h>	---	00gnulib.m4	fabsf fpieee
fabsl	#include <math.h>	fabsl.c	fabsl.m4 mathfunc.m4 00gnulib.m4 gl_FUNC_FABSL if test $HAVE_FABSL = 0 \|\| test $REPLACE_FABSL = 1; then AC_LIBOBJ([fabsl]) fi 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	fabsl fpieee
fchmodat	#include <sys/stat.h>	fchmodat.c chmodat.c at-func.c	fchmodat.m4 00gnulib.m4 gl_FUNC_FCHMODAT if test $HAVE_FCHMODAT = 0; then AC_LIBOBJ([fchmodat]) fi gl_MODULE_INDICATOR([fchmodat]) dnl for lib/openat.h gl_SYS_STAT_MODULE_INDICATOR([fchmodat])	sys_stat extensions at-internal [test $HAVE_FCHMODAT = 0] dosname [test $HAVE_FCHMODAT = 0] errno [test $HAVE_FCHMODAT = 0] extern-inline [test $HAVE_FCHMODAT = 0] fchdir [test $HAVE_FCHMODAT = 0] fcntl-h [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 chownat.c at-func.c	fchownat.m4 00gnulib.m4 gl_FUNC_FCHOWNAT if test $HAVE_FCHOWNAT = 0 \|\| test $REPLACE_FCHOWNAT = 1; then AC_LIBOBJ([fchownat]) fi gl_MODULE_INDICATOR([fchownat]) dnl for lib/openat.h gl_UNISTD_MODULE_INDICATOR([fchownat])	unistd extensions at-internal [test $HAVE_FCHOWNAT = 0 \|\| test $REPLACE_FCHOWNAT = 1] dosname [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] 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] statat [test $REPLACE_FCHOWNAT = 1]
fd-hook	#include "fd-hook.h"	fd-hook.c	00gnulib.m4	unistd
fdopen	#include <stdio.h>	fdopen.c	fdopen.m4 00gnulib.m4 gl_FUNC_FDOPEN if test $REPLACE_FDOPEN = 1; then AC_LIBOBJ([fdopen]) gl_PREREQ_FDOPEN fi gl_STDIO_MODULE_INDICATOR([fdopen])	stdio msvc-inval [test $REPLACE_FDOPEN = 1]
file-has-acl	#include "acl.h"	file-has-acl.c	00gnulib.m4 gl_FILE_HAS_ACL	acl-permissions [test $gl_need_lib_has_acl]
floor-ieee	#include <math.h>	---	floor-ieee.m4 minus-zero.m4 signbit.m4 00gnulib.m4 gl_FUNC_FLOOR_IEEE	floor
floorf-ieee	#include <math.h>	---	floorf-ieee.m4 minus-zero.m4 signbit.m4 00gnulib.m4 gl_FUNC_FLOORF_IEEE	floorf
floorl-ieee	#include <math.h>	---	00gnulib.m4	floorl
fma	#include <math.h>	fma.c float+.h	fma.m4 fegetround.m4 mathfunc.m4 00gnulib.m4 gl_FUNC_FMA if test $HAVE_FMA = 0 \|\| test $REPLACE_FMA = 1; then AC_LIBOBJ([fma]) gl_PREREQ_FMA fi gl_MATH_MODULE_INDICATOR([fma])	math float [test $HAVE_FMA = 0 \|\| test $REPLACE_FMA = 1] stdbool [test $HAVE_FMA = 0 \|\| test $REPLACE_FMA = 1] verify [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	fma fpieee
fmaf	#include <math.h>	fmaf.c fma.c float+.h	fmaf.m4 fegetround.m4 mathfunc.m4 00gnulib.m4 gl_FUNC_FMAF if test $HAVE_FMAF = 0 \|\| test $REPLACE_FMAF = 1; then AC_LIBOBJ([fmaf]) gl_PREREQ_FMAF fi 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] verify [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	fmaf fpieee
fmal	#include <math.h>	fmal.c fma.c float+.h	fmal.m4 fegetround.m4 mathfunc.m4 00gnulib.m4 gl_FUNC_FMAL if test $HAVE_FMAL = 0 \|\| test $REPLACE_FMAL = 1; then AC_LIBOBJ([fmal]) gl_PREREQ_FMAL fi 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] verify [{ 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	fmal fpieee
fmod-ieee	#include <math.h>	---	fmod-ieee.m4 minus-zero.m4 signbit.m4 00gnulib.m4 gl_FUNC_FMOD_IEEE	fmod fpieee
fmodf	#include <math.h>	fmodf.c	fmodf.m4 00gnulib.m4 gl_FUNC_FMODF if test $HAVE_FMODF = 0 \|\| test $REPLACE_FMODF = 1; then AC_LIBOBJ([fmodf]) fi 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 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 gl_FUNC_FMODL if test $HAVE_FMODL = 0 \|\| test $REPLACE_FMODL = 1; then AC_LIBOBJ([fmodl]) fi 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 gl_FUNC_FMODL_IEEE	fmodl fpieee fmod-ieee [{ test $HAVE_FMODL = 0 \|\| test $REPLACE_FMODL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1]
frexp-ieee	#include <math.h>	---	00gnulib.m4	frexp fpieee
frexpf	#include <math.h>	frexpf.c	frexpf.m4 mathfunc.m4 00gnulib.m4 gl_FUNC_FREXPF if test $HAVE_FREXPF = 0 \|\| test $REPLACE_FREXPF = 1; then AC_LIBOBJ([frexpf]) fi gl_MATH_MODULE_INDICATOR([frexpf])	math extensions frexp [test $HAVE_FREXPF = 0 \|\| test $REPLACE_FREXPF = 1]
frexpf-ieee	#include <math.h>	---	00gnulib.m4	frexpf fpieee
frexpl-ieee	#include <math.h>	---	00gnulib.m4	frexpl fpieee
fstat	#include <sys/stat.h>	fstat.c	fstat.m4 00gnulib.m4 gl_FUNC_FSTAT if test $REPLACE_FSTAT = 1; then AC_LIBOBJ([fstat]) gl_PREREQ_FSTAT fi gl_SYS_STAT_MODULE_INDICATOR([fstat])	sys_stat largefile unistd [test $REPLACE_STAT = 1] msvc-inval [test $REPLACE_STAT = 1]
fstatat	#include <sys/stat.h>	fstatat.c at-func.c	fstatat.m4 lstat.m4 00gnulib.m4 gl_FUNC_FSTATAT if test $HAVE_FSTATAT = 0 \|\| test $REPLACE_FSTATAT = 1; then AC_LIBOBJ([fstatat]) fi gl_SYS_STAT_MODULE_INDICATOR([fstatat])	sys_stat extensions at-internal [test $HAVE_FSTATAT = 0 \|\| test $REPLACE_FSTATAT = 1] dosname [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] 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]
gen-uni-tables	---	gen-uni-tables.c unictype/3level.h unictype/3levelbit.h	00gnulib.m4	memcmp strdup strstr-simple
get-rusage-as	#include "resource-ext.h"	get-rusage-as.c	mmap-anon.m4 00gnulib.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 vma-iter
get-rusage-data	#include "resource-ext.h"	get-rusage-data.c	mmap-anon.m4 00gnulib.m4 AC_CHECK_FUNCS_ONCE([setrlimit]) gl_FUNC_MMAP_ANON	stdint unistd extensions getpagesize vma-iter
getdate	---	getdate.h	00gnulib.m4	parse-datetime
getopt	#include <getopt.h>	---	00gnulib.m4	getopt-gnu
getrusage	#include <sys/resource.h>	getrusage.c	getrusage.m4 00gnulib.m4 gl_FUNC_GETRUSAGE if test $HAVE_GETRUSAGE = 0; then AC_LIBOBJ([getrusage]) fi gl_SYS_RESOURCE_MODULE_INDICATOR([getrusage])	sys_resource stdint [test $HAVE_GETRUSAGE = 0]
git-merge-changelog	---	git-merge-changelog.c	00gnulib.m4	getopt-gnu stdbool stdlib progname error read-file xlist array-list linkedhash-list linked-list rbtreehash-list xalloc xmalloca fstrcmp minmax c-strstr fwriteerror memchr memcmp
host-cpu-c-abi	---	---	host-cpu-c-abi.m4 00gnulib.m4 gl_HOST_CPU_C_ABI	---
hypot-ieee	#include <math.h>	---	hypot-ieee.m4 00gnulib.m4 gl_FUNC_HYPOT_IEEE	hypot fpieee
hypotf	#include <math.h>	hypotf.c	hypotf.m4 mathfunc.m4 00gnulib.m4 gl_FUNC_HYPOTF if test $HAVE_HYPOTF = 0 \|\| test $REPLACE_HYPOTF = 1; then AC_LIBOBJ([hypotf]) fi 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 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 gl_FUNC_HYPOTL if test $HAVE_HYPOTL = 0 \|\| test $REPLACE_HYPOTL = 1; then AC_LIBOBJ([hypotl]) fi 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 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 gl_FUNC_ILOGB if test $HAVE_ILOGB = 0 \|\| test $REPLACE_ILOGB = 1; then AC_LIBOBJ([ilogb]) fi 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 gl_FUNC_ILOGBF if test $HAVE_ILOGBF = 0 \|\| test $REPLACE_ILOGBF = 1; then AC_LIBOBJ([ilogbf]) fi 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 gl_FUNC_ILOGBL if test $HAVE_ILOGBL = 0; then AC_LIBOBJ([ilogbl]) fi gl_MATH_MODULE_INDICATOR([ilogbl])	math extensions ilogb [test $HAVE_ILOGBL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1] isfinite [test $HAVE_ILOGBL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] frexpl [test $HAVE_ILOGBL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0] isnanl [test $HAVE_ILOGBL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
ino-map	#include "ino-map.h"	ino-map.c	00gnulib.m4	hash verify
integer_length	#include "integer_length.h"	integer_length.c float+.h	longlong.m4 exponentd.m4 00gnulib.m4 AC_REQUIRE([AC_TYPE_UNSIGNED_LONG_LONG_INT]) AC_REQUIRE([gl_DOUBLE_EXPONENT_LOCATION])	float
integer_length_l	#include "integer_length.h"	integer_length_l.c	longlong.m4 00gnulib.m4 AC_REQUIRE([AC_TYPE_UNSIGNED_LONG_LONG_INT])	integer_length
integer_length_ll	#include "integer_length.h"	integer_length_ll.c integer_length_l.c	longlong.m4 00gnulib.m4 AC_REQUIRE([AC_TYPE_UNSIGNED_LONG_LONG_INT])	integer_length
inttypes-incomplete	#include <inttypes.h>	inttypes.in.h	inttypes.m4 00gnulib.m4 gl_INTTYPES_INCOMPLETE	include_next multiarch snippet/arg-nonnull snippet/c++defs snippet/warn-on-use stdint
isatty	#include <unistd.h>	isatty.c	isatty.m4 00gnulib.m4 gl_FUNC_ISATTY if test $REPLACE_ISATTY = 1; then AC_LIBOBJ([isatty]) gl_PREREQ_ISATTY fi 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 gl_FUNC_ISWBLANK if test $HAVE_ISWCNTRL = 0 \|\| test $REPLACE_ISWCNTRL = 1; then : else if test $HAVE_ISWBLANK = 0 \|\| test $REPLACE_ISWBLANK = 1; then AC_LIBOBJ([iswblank]) fi fi gl_WCTYPE_MODULE_INDICATOR([iswblank])	wctype-h extensions
iswctype	#include <wctype.h>	iswctype.c iswctype-impl.h	iswctype.m4 00gnulib.m4 gl_FUNC_ISWCTYPE if test $HAVE_WCTYPE_T = 0; then AC_LIBOBJ([iswctype]) fi gl_WCTYPE_MODULE_INDICATOR([iswctype])	wctype-h
ldexp-ieee	#include <math.h>	---	00gnulib.m4	ldexp fpieee
ldexpf	#include <math.h>	ldexpf.c	ldexpf.m4 mathfunc.m4 00gnulib.m4 gl_FUNC_LDEXPF if test $HAVE_LDEXPF = 0; then AC_LIBOBJ([ldexpf]) fi gl_MATH_MODULE_INDICATOR([ldexpf])	math extensions ldexp [test $HAVE_LDEXPF = 0]
ldexpf-ieee	#include <math.h>	---	00gnulib.m4	ldexpf fpieee
ldexpl-ieee	#include <math.h>	---	00gnulib.m4	ldexpl fpieee
localeconv	#include <locale.h>	localeconv.c	localeconv.m4 00gnulib.m4 gl_FUNC_LOCALECONV if test $REPLACE_LOCALECONV = 1; then AC_LIBOBJ([localeconv]) gl_PREREQ_LOCALECONV fi gl_LOCALE_MODULE_INDICATOR([localeconv])	locale
log-ieee	#include <math.h>	---	log-ieee.m4 00gnulib.m4 gl_FUNC_LOG_IEEE	log fpieee
log10-ieee	#include <math.h>	---	log10-ieee.m4 00gnulib.m4 gl_FUNC_LOG10_IEEE	log10 fpieee
log10f	#include <math.h>	log10f.c	log10f.m4 00gnulib.m4 gl_FUNC_LOG10F if test $HAVE_LOG10F = 0 \|\| test $REPLACE_LOG10F = 1; then AC_LIBOBJ([log10f]) fi 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 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 gl_FUNC_LOG10L if test $HAVE_LOG10L = 0 \|\| test $REPLACE_LOG10L = 1; then AC_LIBOBJ([log10l]) fi 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	log10l fpieee
log1p-ieee	#include <math.h>	---	log1p-ieee.m4 minus-zero.m4 signbit.m4 00gnulib.m4 gl_FUNC_LOG1P_IEEE	log1p fpieee
log1pf	#include <math.h>	log1pf.c	log1pf.m4 00gnulib.m4 gl_FUNC_LOG1PF if test $HAVE_LOG1PF = 0 \|\| test $REPLACE_LOG1PF = 1; then AC_LIBOBJ([log1pf]) fi 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 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 gl_FUNC_LOG1PL if test $HAVE_LOG1PL = 0 \|\| test $REPLACE_LOG1PL = 1; then AC_LIBOBJ([log1pl]) fi 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 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 gl_FUNC_LOG2 if test $HAVE_LOG2 = 0 \|\| test $REPLACE_LOG2 = 1; then AC_LIBOBJ([log2]) fi 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 gl_FUNC_LOG2_IEEE	log2 fpieee
log2f	#include <math.h>	log2f.c	log2f.m4 00gnulib.m4 gl_FUNC_LOG2F if test $HAVE_LOG2F = 0 \|\| test $REPLACE_LOG2F = 1; then AC_LIBOBJ([log2f]) fi 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 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 gl_FUNC_LOG2L if test $HAVE_LOG2L = 0 \|\| test $REPLACE_LOG2L = 1; then AC_LIBOBJ([log2l]) fi 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	log2l fpieee
logb-ieee	#include <math.h>	---	00gnulib.m4	logb fpieee
logbf	#include <math.h>	logbf.c logb.c	logbf.m4 mathfunc.m4 00gnulib.m4 gl_FUNC_LOGBF if test $HAVE_LOGBF = 0 \|\| test $REPLACE_LOGBF = 1; then AC_LIBOBJ([logbf]) fi 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	logbf fpieee
logbl	#include <math.h>	logbl.c logb.c	logbl.m4 mathfunc.m4 00gnulib.m4 gl_FUNC_LOGBL if test $HAVE_LOGBL = 0 \|\| test $REPLACE_LOGBL = 1; then AC_LIBOBJ([logbl]) fi 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	logbl fpieee
logf	#include <math.h>	logf.c	logf.m4 00gnulib.m4 gl_FUNC_LOGF if test $HAVE_LOGF = 0 \|\| test $REPLACE_LOGF = 1; then AC_LIBOBJ([logf]) fi 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 gl_FUNC_LOGF_IEEE	logf fpieee log-ieee [test $HAVE_LOGF = 0 \|\| test $REPLACE_LOGF = 1]
logl-ieee	#include <math.h>	---	00gnulib.m4	logl fpieee
malloc	#include <stdlib.h>	---	00gnulib.m4	malloc-gnu
mbtowc	#include <stdlib.h>	mbtowc.c mbtowc-impl.h	mbtowc.m4 00gnulib.m4 gl_FUNC_MBTOWC if test $REPLACE_MBTOWC = 1; then AC_LIBOBJ([mbtowc]) gl_PREREQ_MBTOWC fi gl_STDLIB_MODULE_INDICATOR([mbtowc])	stdlib mbrtowc [test $REPLACE_MBTOWC = 1] wchar [test $REPLACE_MBTOWC = 1]
memchr-obsolete	#include <string.h>	---	memchr-obsolete.m4 00gnulib.m4 gl_FUNC_MEMCHR_OBSOLETE	memchr
mkdirat	#include <sys/stat.h>	mkdirat.c at-func.c	mkdirat.m4 00gnulib.m4 gl_FUNC_MKDIRAT if test $HAVE_MKDIRAT = 0; then AC_LIBOBJ([mkdirat]) gl_PREREQ_MKDIRAT fi gl_SYS_STAT_MODULE_INDICATOR([mkdirat])	sys_stat extensions at-internal [test $HAVE_MKDIRAT = 0] dosname [test $HAVE_MKDIRAT = 0] errno [test $HAVE_MKDIRAT = 0] fchdir [test $HAVE_MKDIRAT = 0] fcntl-h [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 gl_FUNC_MODF_IEEE	modf fpieee
modff	#include <math.h>	modff.c	modff.m4 mathfunc.m4 00gnulib.m4 gl_FUNC_MODFF if test $HAVE_MODFF = 0 \|\| test $REPLACE_MODFF = 1; then AC_LIBOBJ([modff]) fi 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 gl_FUNC_MODFF_IEEE	modff fpieee modf-ieee [test $HAVE_MODFF = 0]
modfl	#include <math.h>	modfl.c	modfl.m4 mathfunc.m4 00gnulib.m4 gl_FUNC_MODFL if test $HAVE_MODFL = 0 \|\| test $REPLACE_MODFL = 1; then AC_LIBOBJ([modfl]) fi 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 gl_FUNC_MODFL_IEEE	modfl fpieee modf-ieee [test $HAVE_MODFL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1]
msvc-inval	#include "msvc-inval.h"	msvc-inval.c	msvc-inval.m4 00gnulib.m4 AC_REQUIRE([gl_MSVC_INVAL]) if test $HAVE_MSVC_INVALID_PARAMETER_HANDLER = 1; then AC_LIBOBJ([msvc-inval]) fi	---
msvc-nothrow	#include "msvc-nothrow.h"	msvc-nothrow.c	msvc-nothrow.m4 00gnulib.m4 AC_REQUIRE([gl_MSVC_NOTHROW]) if test $HAVE_MSVC_INVALID_PARAMETER_HANDLER = 1; then AC_LIBOBJ([msvc-nothrow]) fi	msvc-inval
multiarch	---	---	multiarch.m4 00gnulib.m4 gl_MULTIARCH	---
nonblocking	#include "nonblocking.h"	nonblocking.c stdio-read.c stdio-write.c	nonblocking.m4 asm-underscore.m4 00gnulib.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. AC_REQUIRE([gl_STDIO_H_DEFAULTS]) AC_REQUIRE([gl_ASM_SYMBOL_PREFIX]) GNULIB_STDIO_H_NONBLOCKING=1 dnl Define the substituted variable GNULIB_UNISTD_H_NONBLOCKING to 1. AC_REQUIRE([gl_UNISTD_H_DEFAULTS]) GNULIB_UNISTD_H_NONBLOCKING=1	fcntl-h ioctl msvc-nothrow stdbool stdio sys_socket unistd
openat-h	#include "openat.h"	---	00gnulib.m4	extern-inline fcntl-h stdbool sys_stat unistd
opendir	#include <dirent.h>	opendir.c dirent-private.h	opendir.m4 00gnulib.m4 gl_FUNC_OPENDIR if test $HAVE_OPENDIR = 0 \|\| test $REPLACE_OPENDIR = 1; then AC_LIBOBJ([opendir]) fi 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]
passfd	#include "passfd.h"	passfd.c	passfd.m4 00gnulib.m4 gl_PASSFD	cloexec sys_socket socketlib
pclose	#include <stdio.h>	pclose.c	pclose.m4 00gnulib.m4 gl_FUNC_PCLOSE if test $HAVE_PCLOSE = 0; then AC_LIBOBJ([pclose]) gl_PREREQ_PCLOSE fi gl_STDIO_MODULE_INDICATOR([pclose])	stdio
pipe	---	pipe.h	00gnulib.m4	spawn-pipe
poll-h	#include <poll.h>	poll.in.h	poll_h.m4 00gnulib.m4 gl_POLL_H	extensions include_next snippet/c++defs snippet/warn-on-use
powf	#include <math.h>	powf.c	powf.m4 00gnulib.m4 gl_FUNC_POWF if test $HAVE_POWF = 0; then AC_LIBOBJ([powf]) fi gl_MATH_MODULE_INDICATOR([powf])	math extensions pow [test $HAVE_POWF = 0]
pt_chown	---	pt_chown.c pty-private.h	00gnulib.m4	ptsname root-uid stdlib configmake
quotearg-simple	---	---	00gnulib.m4	quotearg
random	#include <stdlib.h>	random.c	random.m4 00gnulib.m4 gl_FUNC_RANDOM if test $HAVE_RANDOM = 0; then AC_LIBOBJ([random]) gl_PREREQ_RANDOM fi gl_STDLIB_MODULE_INDICATOR([random])	stdlib stdint random_r [test $HAVE_RANDOM = 0]
read	#include <unistd.h>	read.c	read.m4 00gnulib.m4 gl_FUNC_READ if test $REPLACE_READ = 1; then AC_LIBOBJ([read]) gl_PREREQ_READ fi 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 gl_FUNC_READDIR if test $HAVE_READDIR = 0; then AC_LIBOBJ([readdir]) fi gl_DIRENT_MODULE_INDICATOR([readdir])	dirent largefile
realloc	#include <stdlib.h>	---	00gnulib.m4	realloc-gnu
regex-quote	#include "regex-quote.h"	regex-quote.c	00gnulib.m4	stdbool xalloc mbuiter
relocatable-perl	---	---	relocatable-lib.m4 00gnulib.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 gl_FUNC_REMAINDER_IEEE	remainder fpieee
remainderf	#include <math.h>	remainderf.c remainder.c	remainderf.m4 mathfunc.m4 00gnulib.m4 gl_FUNC_REMAINDERF if test $HAVE_REMAINDERF = 0 \|\| test $REPLACE_REMAINDERF = 1; then AC_LIBOBJ([remainderf]) fi 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 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 gl_FUNC_REMAINDERL if test $HAVE_REMAINDERL = 0 \|\| test $REPLACE_REMAINDERL = 1; then AC_LIBOBJ([remainderl]) fi 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 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 gl_FUNC_REWINDDIR if test $HAVE_REWINDDIR = 0; then AC_LIBOBJ([rewinddir]) fi gl_DIRENT_MODULE_INDICATOR([rewinddir])	dirent largefile
rint-ieee	#include <math.h>	---	00gnulib.m4	rint fpieee
rintf	#include <math.h>	rintf.c rint.c	rintf.m4 mathfunc.m4 00gnulib.m4 gl_FUNC_RINTF if test $HAVE_RINTF = 0; then AC_LIBOBJ([rintf]) fi gl_MATH_MODULE_INDICATOR([rintf])	math extensions
rintf-ieee	#include <math.h>	---	00gnulib.m4	rintf fpieee
rintl	#include <math.h>	rintl.c rint.c	rintl.m4 mathfunc.m4 00gnulib.m4 gl_FUNC_RINTL if test $HAVE_RINTL = 0; then AC_LIBOBJ([rintl]) fi gl_MATH_MODULE_INDICATOR([rintl])	math extensions rint [test $HAVE_RINTL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1]
rintl-ieee	#include <math.h>	---	00gnulib.m4	rintl fpieee
root-uid	#include "root-uid.h"	---	00gnulib.m4	---
round-ieee	#include <math.h>	---	round-ieee.m4 minus-zero.m4 signbit.m4 00gnulib.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 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 gl_FUNC_ROUNDL_IEEE	roundl floorl-ieee ceill-ieee
sethostname	#include <unistd.h>	sethostname.c	sethostname.m4 gethostname.m4 00gnulib.m4 gl_FUNC_SETHOSTNAME if test $HAVE_SETHOSTNAME = 0; then AC_LIBOBJ([sethostname]) fi gl_UNISTD_MODULE_INDICATOR([sethostname])	unistd errno [test $HAVE_SETHOSTNAME = 0]
setlocale	#include <locale.h>	setlocale.c	setlocale.m4 00gnulib.m4 gl_FUNC_SETLOCALE if test $REPLACE_SETLOCALE = 1; then AC_LIBOBJ([setlocale]) gl_PREREQ_SETLOCALE fi gl_LOCALE_MODULE_INDICATOR([setlocale])	locale localename [test $REPLACE_SETLOCALE = 1]
signal	---	---	00gnulib.m4	signal-h
sinf	#include <math.h>	sinf.c	sinf.m4 00gnulib.m4 gl_FUNC_SINF if test $HAVE_SINF = 0; then AC_LIBOBJ([sinf]) fi gl_MATH_MODULE_INDICATOR([sinf])	math extensions sin [test $HAVE_SINF = 0]
sinhf	#include <math.h>	sinhf.c	sinhf.m4 00gnulib.m4 gl_FUNC_SINHF if test $HAVE_SINHF = 0; then AC_LIBOBJ([sinhf]) fi gl_MATH_MODULE_INDICATOR([sinhf])	math extensions sinh [test $HAVE_SINHF = 0]
snippet/_Noreturn	---	---	00gnulib.m4	---
snippet/c++defs	---	---	00gnulib.m4	---
socketlib	---	---	socketlib.m4 sys_socket_h.m4 00gnulib.m4 AC_REQUIRE([gl_SOCKETLIB])	---
sqrt-ieee	#include <math.h>	---	00gnulib.m4	sqrt fpieee
sqrtf	#include <math.h>	sqrtf.c	sqrtf.m4 00gnulib.m4 gl_FUNC_SQRTF if test $HAVE_SQRTF = 0; then AC_LIBOBJ([sqrtf]) fi gl_MATH_MODULE_INDICATOR([sqrtf])	math extensions sqrt [test $HAVE_SQRTF = 0]
sqrtf-ieee	#include <math.h>	---	00gnulib.m4	sqrtf fpieee
sqrtl-ieee	#include <math.h>	---	00gnulib.m4	sqrtl fpieee
stat-size	#include "stat-size.h"	---	stat-size.m4 00gnulib.m4 gl_STAT_SIZE	fileblocks sys_stat
statat	#include "openat.h"	statat.c	00gnulib.m4 gl_MODULE_INDICATOR([statat]) dnl for lib/openat.h	fstatat
stdnoreturn	#include <stdnoreturn.h>	stdnoreturn.in.h	stdnoreturn.m4 00gnulib.m4 gl_STDNORETURN_H	snippet/_Noreturn
strtod-obsolete	#include <string.h>	---	strtod-obsolete.m4 00gnulib.m4 gl_FUNC_STRTOD_OBSOLETE	strtod
sys_resource	#include <sys/resource.h>	sys_resource.in.h	sys_resource_h.m4 00gnulib.m4 gl_HEADER_SYS_RESOURCE AC_PROG_MKDIR_P	include_next snippet/arg-nonnull snippet/c++defs snippet/warn-on-use sys_time
sys_types	#include <sys/types.h>	sys_types.in.h	sys_types_h.m4 off_t.m4 00gnulib.m4 gl_SYS_TYPES_H AC_PROG_MKDIR_P	include_next ssize_t
system-posix	#include <stdlib.h>	---	00gnulib.m4 gl_STDLIB_MODULE_INDICATOR([system-posix])	stdlib sys_wait
system-quote	#include "system-quote.h"	system-quote.c	00gnulib.m4	sh-quote xalloc
tanf	#include <math.h>	tanf.c	tanf.m4 00gnulib.m4 gl_FUNC_TANF if test $HAVE_TANF = 0; then AC_LIBOBJ([tanf]) fi gl_MATH_MODULE_INDICATOR([tanf])	math extensions tan [test $HAVE_TANF = 0]
tanhf	#include <math.h>	tanhf.c	tanhf.m4 00gnulib.m4 gl_FUNC_TANHF if test $HAVE_TANHF = 0; then AC_LIBOBJ([tanhf]) fi gl_MATH_MODULE_INDICATOR([tanhf])	math extensions tanh [test $HAVE_TANHF = 0]
tcgetsid	#include <termios.h>	tcgetsid.c	tcgetsid.m4 00gnulib.m4 gl_FUNC_TCGETSID if test $HAVE_TCGETSID = 0; then AC_LIBOBJ([tcgetsid]) gl_PREREQ_TCGETSID fi gl_TERMIOS_MODULE_INDICATOR([tcgetsid])	termios extensions sys_ioctl [test $HAVE_TCGETSID = 0]
termios	#include <termios.h>	termios.in.h	termios_h.m4 00gnulib.m4 gl_TERMIOS_H	include_next snippet/c++defs snippet/warn-on-use
timespec-add	#include "timespec.h"	timespec-add.c	00gnulib.m4	intprops timespec
timespec-sub	#include "timespec.h"	timespec-sub.c	00gnulib.m4	intprops timespec
towctrans	#include <wctype.h>	towctrans.c towctrans-impl.h	towctrans.m4 00gnulib.m4 gl_FUNC_TOWCTRANS if test $HAVE_TOWCTRANS = 0; then AC_LIBOBJ([towctrans]) fi gl_WCTYPE_MODULE_INDICATOR([towctrans])	wctype-h
trunc-ieee	#include <math.h>	---	trunc-ieee.m4 minus-zero.m4 signbit.m4 00gnulib.m4 gl_FUNC_TRUNC_IEEE	trunc
truncf-ieee	#include <math.h>	---	truncf-ieee.m4 minus-zero.m4 signbit.m4 00gnulib.m4 gl_FUNC_TRUNCF_IEEE	truncf
truncl-ieee	#include <math.h>	---	truncl-ieee.m4 minus-zero.m4 signbit.m4 00gnulib.m4 gl_FUNC_TRUNCL_IEEE	truncl
unicase/cased	#include "unicase/caseprop.h"	unicase/cased.c unicase/cased.h unictype/bitmap.h	00gnulib.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 AC_REQUIRE([AC_C_INLINE])	unitypes stdbool
unicase/special-casing	#include "unicase/special-casing.h"	unicase/special-casing.c unicase/special-casing-table.gperf	00gnulib.m4	gperf
unicase/tocasefold	#include "unicase/casefold.h"	unicase/tocasefold.c unicase/tocasefold.h unicase/simple-mapping.h	00gnulib.m4	unicase/base
unicase/u16-casemap	#include "unicase/unicasemap.h"	unicase/u16-casemap.c unicase/u-casemap.h unicase/context.h	00gnulib.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	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	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	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 gl_LIBUNISTRING_MODULE([0.9.6], [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	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	unitypes uninorm/base uninorm/u8-normalize uninorm/nfd unistr/u8-cmp stdbool
unictype/bidiclass-all	#include "unictype.h"	---	00gnulib.m4	unictype/base unictype/bidiclass-byname unictype/bidiclass-longname unictype/bidiclass-name unictype/bidiclass-of unictype/bidiclass-test
unictype/bidiclass-byname	#include "unictype.h"	unictype/bidi_byname.c unictype/bidi_byname.gperf	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.5], [unictype/bidiclass-byname])	unictype/base gperf
unictype/bidiclass-longname	#include "unictype.h"	unictype/bidi_longname.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.5], [unictype/bidiclass-longname])	unictype/base
unictype/bidiclass-name	#include "unictype.h"	unictype/bidi_name.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.5], [unictype/bidiclass-name])	unictype/base
unictype/bidiclass-of	#include "unictype.h"	unictype/bidi_of.c unictype/bidi_of.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/bidiclass-of])	unictype/base
unictype/bidiclass-test	#include "unictype.h"	unictype/bidi_test.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/bidiclass-test])	unictype/base unictype/bidiclass-of
unictype/category-LC	#include "unictype.h"	unictype/categ_LC.c unictype/categ_LC.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/category-LC])	unictype/base
unictype/category-longname	#include "unictype.h"	unictype/categ_longname.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.5], [unictype/category-longname])	unictype/base
unictype/combining-class-all	#include "unictype.h"	---	00gnulib.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 gl_LIBUNISTRING_MODULE([0.9.5], [unictype/combining-class-byname])	unictype/base gperf
unictype/combining-class-longname	#include "unictype.h"	unictype/combiningclass_longname.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.5], [unictype/combining-class-longname])	unictype/base
unictype/combining-class-name	#include "unictype.h"	unictype/combiningclass_name.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.5], [unictype/combining-class-name])	unictype/base
unictype/joininggroup-all	#include "unictype.h"	---	00gnulib.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 gl_LIBUNISTRING_MODULE([0.9.5], [unictype/joininggroup-byname])	unictype/base gperf
unictype/joininggroup-name	#include "unictype.h"	unictype/joininggroup_name.c unictype/joininggroup_name.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.5], [unictype/joininggroup-name])	unictype/base
unictype/joininggroup-of	#include "unictype.h"	unictype/joininggroup_of.c unictype/joininggroup_of.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/joininggroup-of])	unictype/base
unictype/joiningtype-all	#include "unictype.h"	---	00gnulib.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 gl_LIBUNISTRING_MODULE([0.9.5], [unictype/joiningtype-byname])	unictype/base gperf
unictype/joiningtype-longname	#include "unictype.h"	unictype/joiningtype_longname.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.5], [unictype/joiningtype-longname])	unictype/base
unictype/joiningtype-name	#include "unictype.h"	unictype/joiningtype_name.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.5], [unictype/joiningtype-name])	unictype/base
unictype/joiningtype-of	#include "unictype.h"	unictype/joiningtype_of.c unictype/joiningtype_of.h	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [unictype/joiningtype-of])	unictype/base unictype/category-test-withtable
unigbrk/base	#include "unigbrk.h"	unigbrk.in.h	libunistring-base.m4 00gnulib.m4 gl_LIBUNISTRING_LIBHEADER([0.9.4], [unigbrk.h])	unitypes stdbool
unigbrk/u16-grapheme-breaks	#include "unigbrk.h"	unigbrk/u16-grapheme-breaks.c	00gnulib.m4 gl_MODULE_INDICATOR([unigbrk/u16-grapheme-breaks]) gl_LIBUNISTRING_MODULE([0.9.6], [unigbrk/u16-grapheme-breaks])	unigbrk/uc-is-grapheme-break unistr/u16-mbtouc
unigbrk/u16-grapheme-next	#include "unigbrk.h"	unigbrk/u16-grapheme-next.c	00gnulib.m4 gl_MODULE_INDICATOR([unigbrk/u16-grapheme-next]) gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_MODULE_INDICATOR([unigbrk/u16-grapheme-prev]) gl_LIBUNISTRING_MODULE([0.9.6], [unigbrk/u16-grapheme-prev])	unigbrk/uc-is-grapheme-break unistr/u16-prev
unigbrk/u32-grapheme-breaks	#include "unigbrk.h"	unigbrk/u32-grapheme-breaks.c	00gnulib.m4 gl_MODULE_INDICATOR([unigbrk/u32-grapheme-breaks]) gl_LIBUNISTRING_MODULE([0.9.6], [unigbrk/u32-grapheme-breaks])	unigbrk/uc-is-grapheme-break unistr/u32-mbtouc
unigbrk/u32-grapheme-next	#include "unigbrk.h"	unigbrk/u32-grapheme-next.c	00gnulib.m4 gl_MODULE_INDICATOR([unigbrk/u32-grapheme-next]) gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_MODULE_INDICATOR([unigbrk/u32-grapheme-prev]) gl_LIBUNISTRING_MODULE([0.9.6], [unigbrk/u32-grapheme-prev])	unigbrk/uc-is-grapheme-break unistr/u32-prev
unigbrk/u8-grapheme-breaks	#include "unigbrk.h"	unigbrk/u8-grapheme-breaks.c	00gnulib.m4 gl_MODULE_INDICATOR([unigbrk/u8-grapheme-breaks]) gl_LIBUNISTRING_MODULE([0.9.6], [unigbrk/u8-grapheme-breaks])	unigbrk/uc-is-grapheme-break unistr/u8-mbtouc
unigbrk/u8-grapheme-next	#include "unigbrk.h"	unigbrk/u8-grapheme-next.c	00gnulib.m4 gl_MODULE_INDICATOR([unigbrk/u8-grapheme-next]) gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_MODULE_INDICATOR([unigbrk/u8-grapheme-prev]) gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_LIBUNISTRING_MODULE([0.9.6], [unigbrk/uc-gbrk-prop])	unigbrk/base
unigbrk/uc-is-grapheme-break	#include "unigbrk.h"	unigbrk/uc-is-grapheme-break.c	00gnulib.m4 gl_LIBUNISTRING_MODULE([0.9.6], [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 gl_MODULE_INDICATOR([unigbrk/ulc-grapheme-breaks]) gl_LIBUNISTRING_MODULE([0.9.6], [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	uninorm/base uninorm/decomposition
uninorm/decompose-internal	#include "uninorm/decompose-internal.h"	uninorm/decompose-internal.c	00gnulib.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 AC_REQUIRE([AC_C_INLINE])	uninorm/base
uniwbrk/table	#include "uniwbrk/wbrktable.h"	uniwbrk/wbrktable.c	00gnulib.m4	---
unlinkat	#include <unistd.h>	unlinkat.c at-func.c	unlinkat.m4 lstat.m4 00gnulib.m4 gl_FUNC_UNLINKAT if test $HAVE_UNLINKAT = 0 \|\| test $REPLACE_UNLINKAT = 1; then AC_LIBOBJ([unlinkat]) fi 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] statat [test $REPLACE_UNLINKAT = 1] at-internal [test $HAVE_UNLINKAT = 0] dosname [test $HAVE_UNLINKAT = 0] errno [test $HAVE_UNLINKAT = 0] fchdir [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]
vfscanf	#include <stdio.h>	---	00gnulib.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 gl_FUNC_MMAP_ANON AC_CHECK_FUNCS_ONCE([mquery])	stdint unistd extensions getpagesize
vscanf	#include <stdio.h>	---	00gnulib.m4 gl_STDIO_MODULE_INDICATOR([vscanf]) gl_MODULE_INDICATOR([vscanf])	stdio
waitpid	#include <sys/wait.h>	waitpid.c	waitpid.m4 00gnulib.m4 gl_FUNC_WAITPID if test $HAVE_WAITPID = 0; then AC_LIBOBJ([waitpid]) fi gl_SYS_WAIT_MODULE_INDICATOR([waitpid])	sys_wait
wcpcpy	#include <wchar.h>	wcpcpy.c wcpcpy-impl.h	wcpcpy.m4 00gnulib.m4 gl_FUNC_WCPCPY if test $HAVE_WCPCPY = 0; then AC_LIBOBJ([wcpcpy]) fi gl_WCHAR_MODULE_INDICATOR([wcpcpy])	extensions wchar
wcpncpy	#include <wchar.h>	wcpncpy.c wcpncpy-impl.h	wcpncpy.m4 00gnulib.m4 gl_FUNC_WCPNCPY if test $HAVE_WCPNCPY = 0; then AC_LIBOBJ([wcpncpy]) fi gl_WCHAR_MODULE_INDICATOR([wcpncpy])	extensions wchar
wcscasecmp	#include <wchar.h>	wcscasecmp.c wcscasecmp-impl.h	wcscasecmp.m4 00gnulib.m4 gl_FUNC_WCSCASECMP if test $HAVE_WCSCASECMP = 0; then AC_LIBOBJ([wcscasecmp]) fi 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 gl_FUNC_WCSCAT if test $HAVE_WCSCAT = 0; then AC_LIBOBJ([wcscat]) fi gl_WCHAR_MODULE_INDICATOR([wcscat])	wchar
wcschr	#include <wchar.h>	wcschr.c wcschr-impl.h	wcschr.m4 00gnulib.m4 gl_FUNC_WCSCHR if test $HAVE_WCSCHR = 0; then AC_LIBOBJ([wcschr]) fi gl_WCHAR_MODULE_INDICATOR([wcschr])	wchar
wcscmp	#include <wchar.h>	wcscmp.c wcscmp-impl.h	wcscmp.m4 00gnulib.m4 gl_FUNC_WCSCMP if test $HAVE_WCSCMP = 0; then AC_LIBOBJ([wcscmp]) fi gl_WCHAR_MODULE_INDICATOR([wcscmp])	wchar
wcscoll	#include <wchar.h>	wcscoll.c wcscoll-impl.h	wcscoll.m4 00gnulib.m4 gl_FUNC_WCSCOLL if test $HAVE_WCSCOLL = 0; then AC_LIBOBJ([wcscoll]) fi gl_WCHAR_MODULE_INDICATOR([wcscoll])	wchar
wcscpy	#include <wchar.h>	wcscpy.c wcscpy-impl.h	wcscpy.m4 00gnulib.m4 gl_FUNC_WCSCPY if test $HAVE_WCSCPY = 0; then AC_LIBOBJ([wcscpy]) fi gl_WCHAR_MODULE_INDICATOR([wcscpy])	wchar
wcscspn	#include <wchar.h>	wcscspn.c wcscspn-impl.h	wcscspn.m4 00gnulib.m4 gl_FUNC_WCSCSPN if test $HAVE_WCSCSPN = 0; then AC_LIBOBJ([wcscspn]) fi 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 gl_FUNC_WCSDUP if test $HAVE_WCSDUP = 0; then AC_LIBOBJ([wcsdup]) fi gl_WCHAR_MODULE_INDICATOR([wcsdup])	wchar wcslen [test $HAVE_WCSDUP = 0] wmemcpy [test $HAVE_WCSDUP = 0]
wcslen	#include <wchar.h>	wcslen.c wcslen-impl.h	wcslen.m4 00gnulib.m4 gl_FUNC_WCSLEN if test $HAVE_WCSLEN = 0; then AC_LIBOBJ([wcslen]) fi gl_WCHAR_MODULE_INDICATOR([wcslen])	wchar
wcsncasecmp	#include <wchar.h>	wcsncasecmp.c wcsncasecmp-impl.h	wcsncasecmp.m4 00gnulib.m4 gl_FUNC_WCSNCASECMP if test $HAVE_WCSNCASECMP = 0; then AC_LIBOBJ([wcsncasecmp]) fi 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 gl_FUNC_WCSNCAT if test $HAVE_WCSNCAT = 0; then AC_LIBOBJ([wcsncat]) fi gl_WCHAR_MODULE_INDICATOR([wcsncat])	wchar
wcsncmp	#include <wchar.h>	wcsncmp.c wcsncmp-impl.h	wcsncmp.m4 00gnulib.m4 gl_FUNC_WCSNCMP if test $HAVE_WCSNCMP = 0; then AC_LIBOBJ([wcsncmp]) fi gl_WCHAR_MODULE_INDICATOR([wcsncmp])	wchar
wcsncpy	#include <wchar.h>	wcsncpy.c wcsncpy-impl.h	wcsncpy.m4 00gnulib.m4 gl_FUNC_WCSNCPY if test $HAVE_WCSNCPY = 0; then AC_LIBOBJ([wcsncpy]) fi gl_WCHAR_MODULE_INDICATOR([wcsncpy])	wchar
wcsnlen	#include <wchar.h>	wcsnlen.c wcsnlen-impl.h	wcsnlen.m4 00gnulib.m4 gl_FUNC_WCSNLEN if test $HAVE_WCSNLEN = 0; then AC_LIBOBJ([wcsnlen]) fi gl_WCHAR_MODULE_INDICATOR([wcsnlen])	wchar
wcspbrk	#include <wchar.h>	wcspbrk.c wcspbrk-impl.h	wcspbrk.m4 00gnulib.m4 gl_FUNC_WCSPBRK if test $HAVE_WCSPBRK = 0; then AC_LIBOBJ([wcspbrk]) fi gl_WCHAR_MODULE_INDICATOR([wcspbrk])	wchar wcschr [test $HAVE_WCSPBRK = 0]
wcsrchr	#include <wchar.h>	wcsrchr.c wcsrchr-impl.h	wcsrchr.m4 00gnulib.m4 gl_FUNC_WCSRCHR if test $HAVE_WCSRCHR = 0; then AC_LIBOBJ([wcsrchr]) fi gl_WCHAR_MODULE_INDICATOR([wcsrchr])	wchar
wcsspn	#include <wchar.h>	wcsspn.c wcsspn-impl.h	wcsspn.m4 00gnulib.m4 gl_FUNC_WCSSPN if test $HAVE_WCSSPN = 0; then AC_LIBOBJ([wcsspn]) fi gl_WCHAR_MODULE_INDICATOR([wcsspn])	wchar wcschr [test $HAVE_WCSSPN = 0]
wcsstr	#include <wchar.h>	wcsstr.c wcsstr-impl.h	wcsstr.m4 00gnulib.m4 gl_FUNC_WCSSTR 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 gl_FUNC_WCSTOK if test $HAVE_WCSTOK = 0; then AC_LIBOBJ([wcstok]) fi gl_WCHAR_MODULE_INDICATOR([wcstok])	wchar wcsspn [test $HAVE_WCSTOK = 0] wcspbrk [test $HAVE_WCSTOK = 0]
wcswidth	#include <wchar.h>	wcswidth.c wcswidth-impl.h	wcswidth.m4 00gnulib.m4 gl_FUNC_WCSWIDTH if test $HAVE_WCSWIDTH = 0 \|\| test $REPLACE_WCSWIDTH = 1; then AC_LIBOBJ([wcswidth]) fi 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 gl_FUNC_WCSXFRM if test $HAVE_WCSXFRM = 0; then AC_LIBOBJ([wcsxfrm]) fi gl_WCHAR_MODULE_INDICATOR([wcsxfrm])	wchar
wctomb	#include <stdlib.h>	wctomb.c wctomb-impl.h	wctomb.m4 00gnulib.m4 gl_FUNC_WCTOMB if test $REPLACE_WCTOMB = 1; then AC_LIBOBJ([wctomb]) gl_PREREQ_WCTOMB fi 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 gl_FUNC_WCTRANS if test $HAVE_WCTRANS = 0; then AC_LIBOBJ([wctrans]) fi 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 gl_WCTYPE_H	extern-inline include_next snippet/c++defs snippet/warn-on-use
wmemchr	#include <wchar.h>	wmemchr.c wmemchr-impl.h	wmemchr.m4 00gnulib.m4 gl_FUNC_WMEMCHR if test $HAVE_WMEMCHR = 0; then AC_LIBOBJ([wmemchr]) fi gl_WCHAR_MODULE_INDICATOR([wmemchr])	wchar
wmemcmp	#include <wchar.h>	wmemcmp.c wmemcmp-impl.h	wmemcmp.m4 00gnulib.m4 gl_FUNC_WMEMCMP if test $HAVE_WMEMCMP = 0; then AC_LIBOBJ([wmemcmp]) fi gl_WCHAR_MODULE_INDICATOR([wmemcmp])	wchar
wmemcpy	#include <wchar.h>	wmemcpy.c wmemcpy-impl.h	wmemcpy.m4 00gnulib.m4 gl_FUNC_WMEMCPY if test $HAVE_WMEMCPY = 0; then AC_LIBOBJ([wmemcpy]) fi gl_WCHAR_MODULE_INDICATOR([wmemcpy])	wchar
wmemmove	#include <wchar.h>	wmemmove.c wmemmove-impl.h	wmemmove.m4 00gnulib.m4 gl_FUNC_WMEMMOVE if test $HAVE_WMEMMOVE = 0; then AC_LIBOBJ([wmemmove]) fi gl_WCHAR_MODULE_INDICATOR([wmemmove])	wchar
wmemset	#include <wchar.h>	wmemset.c wmemset-impl.h	wmemset.m4 00gnulib.m4 gl_FUNC_WMEMSET if test $HAVE_WMEMSET = 0; then AC_LIBOBJ([wmemset]) fi gl_WCHAR_MODULE_INDICATOR([wmemset])	wchar
xalloc-oversized	#include "xalloc-oversized.h"	---	00gnulib.m4	---
xgetgroups	#include "mgetgroups.h"	xgetgroups.c	00gnulib.m4 gl_MODULE_INDICATOR([xgetgroups])	mgetgroups xalloc

Lone files - please create new modules containing them

lib/t-idcache
lib/unictype/sy_c_whitespace.h
lib/unictype/sy_java_whitespace.h
m4/afs.m4
m4/gc-sha256.m4
m4/gc-sha512.m4
m4/gnulib-common.m4
m4/gnulib-tool.m4
m4/locale-ar.m4
m4/locale-tr.m4
m4/stat-macros.m4
m4/ulonglong.m4
m4/ungetc.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 from MODULES.html.sh on 3 January 2016.