Gnulib Module List

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

Support for obsolete systems lacking ANSI C 89

stdlib A GNU-like <stdlib.h>.
strtol strtol function: convert string to long.
strtoul strtoul function: convert string to unsigned long.
memcmp memcmp function: compare memory areas.
memcpy memcpy function: copy memory area.
memmove memmove function: copy memory area.
memset memset function: fill memory with a constant byte.
strcspn strcspn function: search a string for any of a set of characters.
strpbrk strpbrk function: search a string for any of a set of characters.
These modules are not listed among dependencies below, for simplicity. If your package requires portability to old, obsolete systems, you need to list these modules explicitly among the modules to import through gnulib-tool.

Support for systems lacking ANSI C 89

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

Enhancements for ANSI C 89 functions

Diagnostics <assert.h>

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

Mathematics <math.h>

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

Input/output <stdio.h>

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

Memory management functions <stdlib.h>

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

Sorting functions <stdlib.h>

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

Date and time <time.h>

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

Extra functions based on ANSI C 89

Memory management functions <stdlib.h>

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

Integer arithmetic functions <stdlib.h>

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

Environment variables <stdlib.h>

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

Character handling <ctype.h>

c-ctype Character handling in C locale.

String handling <string.h>

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

Mathematics <math.h>

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

Numeric conversion functions <stdlib.h>

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

Date and time <time.h>

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

Input/Output <stdio.h>

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

Signal handling <signal.h>

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

Wide-character string handling <wchar.h>

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

Command-line arguments

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

Container data structures

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

Cryptographic computations (low-level)

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

Cryptographic computations (high-level)

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

Compiler warning management

ignore-value ignore a value to quiet a compiler warning

Misc

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

Support for systems lacking ISO C 99

Core language properties

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

Variable arguments <stdarg.h>

stdarg An <stdarg.h> that conforms to C99.

Boolean type and values <stdbool.h>

stdbool A bool that is like C23.

Basic types <stddef.h>

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

Integer types and values <stdint.h>

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

Input/output <stdio.h>

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

Process control, Numeric conversion functions <stdlib.h>

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

Unibyte characters <ctype.h>

ctype A <ctype.h> that conforms to C99.

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

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

String handling <string.h>

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

Extended multibyte and wide character utilities <wchar.h>

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

Wide character classification and mapping utilities <wctype.h>

wctype wctype function: get descriptor for a wide character property.

Characteristics of floating types <float.h>

float A correct <float.h>.

Mathematics <math.h>

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

Enhancements for ISO C 99 functions

Input/output <stdio.h>

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

Extra functions based on ISO C 99

Mathematics <math.h>

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

Numeric conversion functions <stdlib.h>

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

Extended multibyte and wide character utilities <wchar.h>

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

Support for systems lacking ISO C 11

Core language properties

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

Support for standard extensions to ISO C 11

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

Support for systems lacking draft ISO C 23

Core language properties

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

Memory management functions <stdlib.h>

aligned_alloc Allocate memory with indefinite extent and specified alignment.

String handling <string.h>

memset_explicit Erase sensitive data from memory.

Date and time <time.h>

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

Support for GNU multiple precision arithmetic

libgmp GNU Multiple Precision Arithmetic library, or its mini-gmp substitute

Support for sharing code with the GNU C Library

libc-config System definitions for code taken from the GNU C Library

Support for obsolete systems lacking POSIX:2008

strdup strdup function: duplicate a string.
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 POSIX:2008

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

Compatibility checks for POSIX:2008 functions

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

Enhancements for POSIX:2008 functions

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

Extra functions based on POSIX:2008

Input/output

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

Numeric conversion functions

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

File system functions

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

File system as inode set

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

File descriptor based Input/Output

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

File stream based Input/Output

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

Users and groups

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

Security

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

Date and time

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

Networking functions

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

Multithreading

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

Signal handling

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

Terminal I/O

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

Internationalization functions

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

Unicode string functions

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

Executing programs

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

Java

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

C#

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

Misc

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

Support for building libraries and executables

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

Support for building documentation

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

Support for maintaining and releasing projects

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

Misc

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

Support for obsolete systems lacking ANSI C 89

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

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

Enhancements for ANSI C 89 functions

Diagnostics <assert.h>

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

Mathematics <math.h>

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

Input/output <stdio.h>

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

Memory management functions <stdlib.h>

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

Sorting functions <stdlib.h>

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

Date and time <time.h>

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

Extra functions based on ANSI C 89

Memory management functions <stdlib.h>

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

Integer arithmetic functions <stdlib.h>

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

Environment variables <stdlib.h>

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

Character handling <ctype.h>

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

String handling <string.h>

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

gl_STRING_MODULE_INDICATOR([strnlen])
string
extensions
strnlen1 #include "strnlen1.h" strnlen1.c 00gnulib.m4
zzgnulib.m4
memchr
strndup #include <string.h> strndup.c strndup.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_STRNDUP
gl_CONDITIONAL([GL_COND_OBJ_STRNDUP],
[test $HAVE_STRNDUP = 0 || test $REPLACE_STRNDUP = 1])
gl_STRING_MODULE_INDICATOR([strndup])
string
extensions
strnlen [test $HAVE_STRNDUP = 0 || test $REPLACE_STRNDUP = 1]
strsep #include <string.h> strsep.c strsep.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_STRSEP
gl_CONDITIONAL([GL_COND_OBJ_STRSEP], [test $HAVE_STRSEP = 0])
AM_COND_IF([GL_COND_OBJ_STRSEP], [
gl_PREREQ_STRSEP
])
gl_STRING_MODULE_INDICATOR([strsep])
string
extensions
strpbrk [test $HAVE_STRSEP = 0]
strstr #include <string.h> strstr.c 00gnulib.m4
zzgnulib.m4
gl_FUNC_STRSTR
if test $REPLACE_STRSTR = 1; then
AC_LIBOBJ([strstr])
fi
strstr-simple
strstr-simple #include <string.h> str-two-way.h
strstr.c
strstr.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_STRSTR_SIMPLE
if test $REPLACE_STRSTR = 1; then
AC_LIBOBJ([strstr])
fi
gl_STRING_MODULE_INDICATOR([strstr])
string
builtin-expect [test $REPLACE_STRSTR = 1]
stdbool [test $REPLACE_STRSTR = 1]
memchr [test $REPLACE_STRSTR = 1]
memcmp [test $REPLACE_STRSTR = 1]
c-strstr #include "c-strstr.h" c-strstr.c 00gnulib.m4
zzgnulib.m4
strstr
astrxfrm #include "astrxfrm.h" astrxfrm.c 00gnulib.m4
zzgnulib.m4
AC_REQUIRE([AC_C_RESTRICT])
free-posix
trim #include "trim.h" trim.c 00gnulib.m4
zzgnulib.m4
xalloc
mbchar
mbiter
memmove
strdup
fstrcmp #include "fstrcmp.h" fstrcmp.c 00gnulib.m4
zzgnulib.m4
c99
diffseq
lock
tls
minmax
stdint
xalloc
xstrndup #include "xstrndup.h" xstrndup.c xstrndup.m4
00gnulib.m4
zzgnulib.m4
gl_XSTRNDUP
strndup
xalloc

Mathematics <math.h>

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

Numeric conversion functions <stdlib.h>

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

Date and time <time.h>

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

Input/Output <stdio.h>

modules/ lib/ lib/ m4/  
Module Header Implementation Autoconf macro Depends on
unlocked-io #include "unlocked-io.h" --- 00gnulib.m4
zzgnulib.m4
AC_DEFINE([GNULIB_STDIO_SINGLE_THREAD], [1],
[Define to 1 if you want the FILE stream functions getc, putc, etc.
to use unlocked I/O if available, throughout the package.
Unlocked I/O can improve performance, sometimes dramatically.
But unlocked I/O is safe only in single-threaded programs,
as well as in multithreaded programs for which you can guarantee that
every FILE stream, including stdin, stdout, stderr, is used only
in a single thread.])

AC_DEFINE([USE_UNLOCKED_IO], [GNULIB_STDIO_SINGLE_THREAD],
[An alias of GNULIB_STDIO_SINGLE_THREAD.])
unlocked-io-internal
unlocked-io-internal #include "unlocked-io.h" --- unlocked-io.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_GLIBC_UNLOCKED_IO
extensions
fwriteerror #include "fwriteerror.h" fwriteerror.c 00gnulib.m4
zzgnulib.m4
gl_MODULE_INDICATOR([fwriteerror])
errno
stdbool
vasnprintf #include "vasnprintf.h" float+.h
printf-args.h
printf-args.c
printf-parse.h
printf-parse.c
vasnprintf.c
asnprintf.c
wchar_t.m4
wint_t.m4
intmax_t.m4
stdint_h.m4
inttypes_h.m4
vasnprintf.m4
printf.m4
math_h.m4
exponentd.m4
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([AC_C_RESTRICT])
gl_FUNC_VASNPRINTF
stdio
alloca-opt
attribute
float
free-posix
limits-h
stdint
xsize
errno
memchr
assert-h
wchar
vasprintf #include <stdio.h> vasprintf.c
asprintf.c
vasprintf.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_VASPRINTF
gl_STDIO_MODULE_INDICATOR([vasprintf])
m4_ifdef([AM_XGETTEXT_OPTION],
[AM_][XGETTEXT_OPTION([--flag=asprintf:2:c-format])
AM_][XGETTEXT_OPTION([--flag=vasprintf:2:c-format])])
stdio
extensions
vasnprintf [test $HAVE_VASPRINTF = 0 || test $REPLACE_VASPRINTF = 1]
errno [test $HAVE_VASPRINTF = 0 || test $REPLACE_VASPRINTF = 1]
xprintf #include "xprintf.h" xprintf.c 00gnulib.m4
zzgnulib.m4
m4_ifdef([AM_XGETTEXT_OPTION],
[AM_][XGETTEXT_OPTION([--flag=xprintf:1:c-format])
AM_][XGETTEXT_OPTION([--flag=xvprintf:1:c-format])
AM_][XGETTEXT_OPTION([--flag=xfprintf:2:c-format])
AM_][XGETTEXT_OPTION([--flag=xvfprintf:2:c-format])])
stdio
error
exitfail
gettext-h
stdarg
xvasprintf #include "xvasprintf.h" xvasprintf.c
xasprintf.c
xalloc.h
xvasprintf.m4
00gnulib.m4
zzgnulib.m4
gl_XVASPRINTF
m4_ifdef([AM_XGETTEXT_OPTION],
[AM_][XGETTEXT_OPTION([--flag=xasprintf:1:c-format])])
stdio
vasprintf
xalloc
xalloc-die
extern-inline
xsize
stdarg
errno

Signal handling <signal.h>

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

Wide-character string handling <wchar.h>

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

Command-line arguments

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

Container data structures

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

Cryptographic computations (low-level)

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

Cryptographic computations (high-level)

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

Compiler warning management

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

Misc

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

Support for systems lacking ISO C 99

Core language properties

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

Variable arguments <stdarg.h>

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

Boolean type and values <stdbool.h>

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

Basic types <stddef.h>

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

Integer types and values <stdint.h>

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

Input/output <stdio.h>

modules/ lib/ lib/ m4/  
Module Header Implementation Autoconf macro Depends on
stdio #include <stdio.h> stdio.in.h
stdio-read.c
stdio-write.c
stdio_h.m4
musl.m4
00gnulib.m4
zzgnulib.m4
gl_STDIO_H
gl_STDIO_H_REQUIRE_DEFAULTS
AC_PROG_MKDIR_P
gl_CONDITIONAL([GL_COND_OBJ_STDIO_READ], [test $REPLACE_STDIO_READ_FUNCS = 1])
gl_CONDITIONAL([GL_COND_OBJ_STDIO_WRITE], [test $REPLACE_STDIO_WRITE_FUNCS = 1])

dnl No need to create extra modules for these functions. Everyone who uses
dnl likely needs them.
gl_STDIO_MODULE_INDICATOR([fscanf])
gl_MODULE_INDICATOR([fscanf])
gl_STDIO_MODULE_INDICATOR([scanf])
gl_MODULE_INDICATOR([scanf])
gl_STDIO_MODULE_INDICATOR([fgetc])
gl_STDIO_MODULE_INDICATOR([getc])
gl_STDIO_MODULE_INDICATOR([getchar])
gl_STDIO_MODULE_INDICATOR([fgets])
gl_STDIO_MODULE_INDICATOR([fread])

dnl No need to create extra modules for these functions. Everyone who uses
dnl likely needs them.
gl_STDIO_MODULE_INDICATOR([fprintf])
gl_STDIO_MODULE_INDICATOR([printf])
gl_STDIO_MODULE_INDICATOR([vfprintf])
gl_STDIO_MODULE_INDICATOR([vprintf])
gl_STDIO_MODULE_INDICATOR([fputc])
gl_STDIO_MODULE_INDICATOR([putc])
gl_STDIO_MODULE_INDICATOR([putchar])
gl_STDIO_MODULE_INDICATOR([fputs])
gl_STDIO_MODULE_INDICATOR([puts])
gl_STDIO_MODULE_INDICATOR([fwrite])
extensions
gen-header
include_next
snippet/arg-nonnull
snippet/c++defs
snippet/warn-on-use
ssize_t
stddef
sys_types
snprintf #include <stdio.h> snprintf.c snprintf.m4
printf.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_SNPRINTF
gl_STDIO_MODULE_INDICATOR([snprintf])
gl_MODULE_INDICATOR([snprintf])
stdio
vasnprintf [test $ac_cv_func_snprintf = no || test $REPLACE_SNPRINTF = 1]
errno [test $ac_cv_func_snprintf = no || test $REPLACE_SNPRINTF = 1]
vsnprintf #include <stdio.h> vsnprintf.c vsnprintf.m4
printf.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_VSNPRINTF
gl_STDIO_MODULE_INDICATOR([vsnprintf])
stdio
vasnprintf [test $ac_cv_func_vsnprintf = no || test $REPLACE_VSNPRINTF = 1]
errno [test $ac_cv_func_vsnprintf = no || test $REPLACE_VSNPRINTF = 1]

Process control, Numeric conversion functions <stdlib.h>

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

Unibyte characters <ctype.h>

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

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

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

String handling <string.h>

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

Extended multibyte and wide character utilities <wchar.h>

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

Wide character classification and mapping utilities <wctype.h>

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

Characteristics of floating types <float.h>

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

Mathematics <math.h>

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

Enhancements for ISO C 99 functions

Input/output <stdio.h>

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

Extra functions based on ISO C 99

Mathematics <math.h>

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

Numeric conversion functions <stdlib.h>

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

Extended multibyte and wide character utilities <wchar.h>

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

Support for systems lacking ISO C 11

Core language properties

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

Support for standard extensions to ISO C 11

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

Support for systems lacking draft ISO C 23

Core language properties

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

Memory management functions <stdlib.h>

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

String handling <string.h>

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

Date and time <time.h>

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

Support for GNU multiple precision arithmetic

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

Support for sharing code with the GNU C Library

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

Support for obsolete systems lacking POSIX:2008

modules/ lib/ lib/ m4/  
Module Header Implementation Autoconf macro Depends on
strdup #include <string.h> --- strdup.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_STRDUP
gl_STRING_MODULE_INDICATOR([strdup])
string
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 POSIX:2008

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

Compatibility checks for POSIX:2008 functions

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

Enhancements for POSIX:2008 functions

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

Extra functions based on POSIX:2008

Input/output

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

Numeric conversion functions

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

File system functions

modules/ lib/ lib/ m4/  
Module Header Implementation Autoconf macro Depends on
acl #include "acl.h" copy-acl.c
set-acl.c
00gnulib.m4
zzgnulib.m4
error
gettext-h
qcopy-acl
qset-acl
quote
acl-permissions #include "acl.h" acl-internal.h
acl-errno-valid.c
acl_entries.c
acl-internal.c
get-permissions.c
set-permissions.c
acl.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_ACL
extern-inline
fstat
stat
stdbool
sys_stat
areadlink #include "areadlink.h" areadlink.c 00gnulib.m4
zzgnulib.m4
careadlinkat
readlink
areadlink-with-size #include "areadlink.h" areadlink-with-size.c 00gnulib.m4
zzgnulib.m4
free-posix
readlink
ssize_t
stdint
unistd
areadlinkat #include "areadlink.h" areadlinkat.c
at-func.c
00gnulib.m4
zzgnulib.m4
gl_MODULE_INDICATOR([areadlinkat])
areadlink
careadlinkat
readlinkat
at-internal
errno
extensions
fchdir
fcntl-h
filename
openat-die
openat-h
save-cwd
areadlinkat-with-size #include "areadlink.h" areadlinkat-with-size.c
at-func.c
00gnulib.m4
zzgnulib.m4
gl_MODULE_INDICATOR([areadlinkat-with-size])
areadlink-with-size
stdint
readlinkat
at-internal
errno
extensions
fchdir
fcntl-h
filename
free-posix
openat-die
openat-h
save-cwd
unistd
backupfile #include "backupfile.h" backup-internal.h
backup-find.c
backupfile.c
backupfile.m4
00gnulib.m4
zzgnulib.m4
gl_BACKUPFILE
argmatch
attribute
basename-lgpl
c99
closedir
d-ino
fcntl-h
ialloc
memcmp
opendirat
readdir
realloc-gnu
renameatu
stdbool
stdckdint
stdint
xalloc-die
backup-rename #include "backupfile.h" backup-internal.h
backup-rename.c
backupfile.c
backupfile.m4
00gnulib.m4
zzgnulib.m4
gl_BACKUPFILE
argmatch
attribute
basename-lgpl
c99
closedir
d-ino
fcntl-h
ialloc
memcmp
opendirat
readdir
renameatu
stdbool
stdckdint
stdint
xalloc-oversized
canonicalize #include "canonicalize.h" canonicalize.c canonicalize.m4
lstat.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_CANONICALIZE_FILENAME_MODE
gl_MODULE_INDICATOR([canonicalize])
gl_MODULE_INDICATOR_FOR_TESTS([canonicalize])
gl_STDLIB_MODULE_INDICATOR([canonicalize_file_name])
attribute
double-slash-root
errno
extensions
fcntl-h
file-set
filename
getcwd
hash-triple-simple
idx
intprops
memmove
mempcpy
nocrash
rawmemchr
readlink
glibc-internal/scratch_buffer
stat
stdbool
sys_stat
unistd
xalloc-die
canonicalize-lgpl #include <stdlib.h> canonicalize-lgpl.c canonicalize.m4
double-slash-root.m4
lstat.m4
00gnulib.m4
zzgnulib.m4
gl_CANONICALIZE_LGPL
gl_CONDITIONAL([GL_COND_OBJ_CANONICALIZE_LGPL],
[test $HAVE_CANONICALIZE_FILE_NAME = 0 || test $REPLACE_CANONICALIZE_FILE_NAME = 1])
gl_MODULE_INDICATOR([canonicalize-lgpl])
gl_STDLIB_MODULE_INDICATOR([canonicalize_file_name])
gl_STDLIB_MODULE_INDICATOR([realpath])
extensions
stdlib
nocrash
double-slash-root [test $HAVE_CANONICALIZE_FILE_NAME = 0 || test $REPLACE_CANONICALIZE_FILE_NAME = 1]
eloop-threshold [test $HAVE_CANONICALIZE_FILE_NAME = 0 || test $REPLACE_CANONICALIZE_FILE_NAME = 1]
errno [test $HAVE_CANONICALIZE_FILE_NAME = 0 || test $REPLACE_CANONICALIZE_FILE_NAME = 1]
fcntl-h [test $HAVE_CANONICALIZE_FILE_NAME = 0 || test $REPLACE_CANONICALIZE_FILE_NAME = 1]
filename [test $HAVE_CANONICALIZE_FILE_NAME = 0 || test $REPLACE_CANONICALIZE_FILE_NAME = 1]
idx [test $HAVE_CANONICALIZE_FILE_NAME = 0 || test $REPLACE_CANONICALIZE_FILE_NAME = 1]
intprops [test $HAVE_CANONICALIZE_FILE_NAME = 0 || test $REPLACE_CANONICALIZE_FILE_NAME = 1]
libc-config [test $HAVE_CANONICALIZE_FILE_NAME = 0 || test $REPLACE_CANONICALIZE_FILE_NAME = 1]
memmove [test $HAVE_CANONICALIZE_FILE_NAME = 0 || test $REPLACE_CANONICALIZE_FILE_NAME = 1]
mempcpy [test $HAVE_CANONICALIZE_FILE_NAME = 0 || test $REPLACE_CANONICALIZE_FILE_NAME = 1]
pathmax [test $HAVE_CANONICALIZE_FILE_NAME = 0 || test $REPLACE_CANONICALIZE_FILE_NAME = 1]
rawmemchr [test $HAVE_CANONICALIZE_FILE_NAME = 0 || test $REPLACE_CANONICALIZE_FILE_NAME = 1]
readlink [test $HAVE_CANONICALIZE_FILE_NAME = 0 || test $REPLACE_CANONICALIZE_FILE_NAME = 1]
glibc-internal/scratch_buffer [test $HAVE_CANONICALIZE_FILE_NAME = 0 || test $REPLACE_CANONICALIZE_FILE_NAME = 1]
stat [test $HAVE_CANONICALIZE_FILE_NAME = 0 || test $REPLACE_CANONICALIZE_FILE_NAME = 1]
stdbool [test $HAVE_CANONICALIZE_FILE_NAME = 0 || test $REPLACE_CANONICALIZE_FILE_NAME = 1]
sys_stat [test $HAVE_CANONICALIZE_FILE_NAME = 0 || test $REPLACE_CANONICALIZE_FILE_NAME = 1]
unistd [test $HAVE_CANONICALIZE_FILE_NAME = 0 || test $REPLACE_CANONICALIZE_FILE_NAME = 1]
clean-temp #include "clean-temp.h" clean-temp.c 00gnulib.m4
zzgnulib.m4
c99
stdbool
clean-temp-simple
list
asyncsafe-spin
unistd
lock
thread-optim
error
fatal-signal
open
pathmax
tmpdir
mkdtemp
rmdir
xalloc
xalloc-die
xmalloca
linkedhash-list
linked-list
xlist
gettext-h
clean-temp-simple #include "clean-temp-simple.h" clean-temp-private.h
clean-temp-simple.c
00gnulib.m4
zzgnulib.m4
AC_DEFINE([SIGNAL_SAFE_LIST], [1], [Define if lists must be signal-safe.])
c99
stdbool
list
asyncsafe-spin
unistd
lock
thread-optim
error
fatal-signal
rmdir
linkedhash-list
gettext-h
concat-filename #include "concat-filename.h" concat-filename.c 00gnulib.m4
zzgnulib.m4
filename
malloc-posix
stpcpy
copy-file #include "copy-file.h" copy-file.c copy-file.m4
00gnulib.m4
zzgnulib.m4
gl_COPY_FILE
acl-permissions
binary-io
c99
close
copy-file-range
error
fstat
full-write
gettext-h
ignore-value
open
qcopy-acl
quote
safe-read
stat-time
stdlib
unistd
utimens
fsusage #include "fsusage.h" fsusage.c fsusage.m4
00gnulib.m4
zzgnulib.m4
gl_FSUSAGE
gl_CONDITIONAL([GL_COND_OBJ_FSUSAGE], [test $gl_cv_fs_space = yes])
AM_COND_IF([GL_COND_OBJ_FSUSAGE], [
gl_PREREQ_FSUSAGE_EXTRA
])
c99
largefile
stdbool
stdint
dirfd #include <dirent.h> dirfd.c dirfd.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_DIRFD
gl_CONDITIONAL([GL_COND_OBJ_DIRFD],
[test $ac_cv_func_dirfd = no && test $gl_cv_func_dirfd_macro = no || test $REPLACE_DIRFD = 1])
AM_COND_IF([GL_COND_OBJ_DIRFD], [
gl_PREREQ_DIRFD
])
gl_DIRENT_MODULE_INDICATOR([dirfd])
dirent
extensions
errno [test $ac_cv_func_dirfd = no && test $gl_cv_func_dirfd_macro = no || test $REPLACE_DIRFD = 1]
double-slash-root --- --- double-slash-root.m4
00gnulib.m4
zzgnulib.m4
gl_DOUBLE_SLASH_ROOT
---
euidaccess #include <unistd.h> euidaccess.c euidaccess.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_EUIDACCESS
gl_CONDITIONAL([GL_COND_OBJ_EUIDACCESS], [test $HAVE_EUIDACCESS = 0])
AM_COND_IF([GL_COND_OBJ_EUIDACCESS], [
gl_PREREQ_EUIDACCESS
])
gl_UNISTD_MODULE_INDICATOR([euidaccess])
unistd
extensions
root-uid
fcntl-h
group-member [test $HAVE_EUIDACCESS = 0]
stat [test $HAVE_EUIDACCESS = 0]
sys_stat [test $HAVE_EUIDACCESS = 0]
faccessat #include <fcntl.h>
#include <unistd.h>
faccessat.c
at-func.c
faccessat.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_FACCESSAT
gl_CONDITIONAL([GL_COND_OBJ_FACCESSAT],
[test $HAVE_FACCESSAT = 0 || test $REPLACE_FACCESSAT = 1])
AM_COND_IF([GL_COND_OBJ_FACCESSAT], [
gl_PREREQ_FACCESSAT
])
gl_MODULE_INDICATOR([faccessat])
gl_UNISTD_MODULE_INDICATOR([faccessat])
unistd
extensions
at-internal [test $HAVE_FACCESSAT = 0 || test $REPLACE_FACCESSAT = 1]
errno [test $HAVE_FACCESSAT = 0 || test $REPLACE_FACCESSAT = 1]
fchdir [test $HAVE_FACCESSAT = 0 || test $REPLACE_FACCESSAT = 1]
fcntl-h [test $HAVE_FACCESSAT = 0 || test $REPLACE_FACCESSAT = 1]
filename [test $HAVE_FACCESSAT = 0 || test $REPLACE_FACCESSAT = 1]
fstatat [test $HAVE_FACCESSAT = 0 || test $REPLACE_FACCESSAT = 1]
openat-die [test $HAVE_FACCESSAT = 0 || test $REPLACE_FACCESSAT = 1]
openat-h [test $HAVE_FACCESSAT = 0 || test $REPLACE_FACCESSAT = 1]
save-cwd [test $HAVE_FACCESSAT = 0 || test $REPLACE_FACCESSAT = 1]
euidaccess [test $HAVE_FACCESSAT = 0 || test $REPLACE_FACCESSAT = 1]
fdopendir #include <dirent.h> fdopendir.c fdopendir.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_FDOPENDIR
gl_CONDITIONAL([GL_COND_OBJ_FDOPENDIR],
[test $HAVE_FDOPENDIR = 0 || test $REPLACE_FDOPENDIR = 1])
gl_DIRENT_MODULE_INDICATOR([fdopendir])
gl_MODULE_INDICATOR([fdopendir])
dirent
extensions
at-internal [test $HAVE_FDOPENDIR = 0]
dirfd [test $HAVE_FDOPENDIR = 0]
dup [test $HAVE_FDOPENDIR = 0]
errno [test $HAVE_FDOPENDIR = 0]
fchdir [test $HAVE_FDOPENDIR = 0]
fstat [test $HAVE_FDOPENDIR = 0]
openat-die [test $HAVE_FDOPENDIR = 0]
opendir [test $HAVE_FDOPENDIR = 0]
save-cwd [test $HAVE_FDOPENDIR = 0]
fdutimensat #include <fcntl.h>
#include "utimens.h"
fdutimensat.c 00gnulib.m4
zzgnulib.m4
gl_MODULE_INDICATOR([fdutimensat])
extern-inline
futimens
utimensat
file-type #include "file-type.h" file-type.c 00gnulib.m4
zzgnulib.m4
gettext-h
sys_stat
fileblocks --- fileblocks.c fileblocks.m4
00gnulib.m4
zzgnulib.m4
gl_FILEBLOCKS
gl_CONDITIONAL([GL_COND_OBJ_FILEBLOCKS],
[test $ac_cv_member_struct_stat_st_blocks = no])
AM_COND_IF([GL_COND_OBJ_FILEBLOCKS], [
gl_PREREQ_FILEBLOCKS
])
---
filemode #include "filemode.h" filemode.c filemode.m4
00gnulib.m4
zzgnulib.m4
gl_FILEMODE
sys_stat
filename #include "filename.h" --- 00gnulib.m4
zzgnulib.m4
---
filenamecat #include "filenamecat.h" filenamecat.c filenamecat.m4
00gnulib.m4
zzgnulib.m4
gl_FILE_NAME_CONCAT
gl_MODULE_INDICATOR([filenamecat])
filenamecat-lgpl
xalloc
filenamecat-lgpl #include "filenamecat.h" filenamecat-lgpl.c filenamecat.m4
00gnulib.m4
zzgnulib.m4
gl_FILE_NAME_CONCAT_LGPL
c99
basename-lgpl
filename
malloc-posix
fts #include "fts_.h" fts.c
fts-cycle.c
fts.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_FTS
dnl Use this version of fts unconditionally, since the GNU libc and
dnl NetBSD versions have bugs and/or unnecessary limitations.
gl_CONDITIONAL([GL_COND_OBJ_FTS], [true])
alignasof
attribute
c99
closedir
cycle-check
d-ino
d-type
fchdir
fcntl
fcntl-h
flexmember
fstat
hash
i-ring
lstat
memmove
open
openat-h
opendir
opendirat
readdir
stdbool
stddef
stdint
isdir --- isdir.c
isdir.h
00gnulib.m4
zzgnulib.m4
stat
largefile --- --- largefile.m4
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([gl_LARGEFILE])
---
largefile-required --- --- largefile.m4
00gnulib.m4
zzgnulib.m4
largefile
lchmod #include <sys/stat.h> lchmod.c lchmod.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_LCHMOD
gl_CONDITIONAL([GL_COND_OBJ_LCHMOD], [test $HAVE_LCHMOD = 0])
AM_COND_IF([GL_COND_OBJ_LCHMOD], [
gl_PREREQ_LCHMOD
])
gl_SYS_STAT_MODULE_INDICATOR([lchmod])
c99 [test $HAVE_LCHMOD = 0]
errno [test $HAVE_LCHMOD = 0]
extensions
fcntl-h [test $HAVE_LCHMOD = 0]
intprops [test $HAVE_LCHMOD = 0]
lstat [test $HAVE_LCHMOD = 0]
readlink [test $HAVE_LCHMOD = 0]
sys_stat
unistd [test $HAVE_LCHMOD = 0]
lchown #include <unistd.h> lchown.c lchown.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_LCHOWN
gl_CONDITIONAL([GL_COND_OBJ_LCHOWN],
[test $HAVE_LCHOWN = 0 || test $REPLACE_LCHOWN = 1])
gl_UNISTD_MODULE_INDICATOR([lchown])
unistd
readlink [test $HAVE_LCHOWN = 0]
chown [test $HAVE_LCHOWN = 0 || test $REPLACE_LCHOWN = 1]
errno [test $HAVE_LCHOWN = 0 || test $REPLACE_LCHOWN = 1]
stdbool [test $HAVE_LCHOWN = 0 || test $REPLACE_LCHOWN = 1]
sys_stat [test $HAVE_LCHOWN = 0 || test $REPLACE_LCHOWN = 1]
lstat [test $REPLACE_LCHOWN = 1]
mkancesdirs #include "mkancesdirs.h" mkancesdirs.c mkancesdirs.m4
00gnulib.m4
zzgnulib.m4
gl_MKANCESDIRS
fcntl-h
filename
savewd
stat-macros
sys_stat
mkfifoat #include <fcntl.h>
#include <sys/stat.h>
mkfifoat.c
mknodat.c
at-func.c
mkfifoat.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_MKFIFOAT
gl_CONDITIONAL([GL_COND_OBJ_MKFIFOAT],
[test $HAVE_MKFIFOAT = 0 || test $REPLACE_MKFIFOAT = 1])
gl_CONDITIONAL([GL_COND_OBJ_MKNODAT],
[test $HAVE_MKNODAT = 0 || test $REPLACE_MKNODAT = 1])
gl_SYS_STAT_MODULE_INDICATOR([mkfifoat])
gl_SYS_STAT_MODULE_INDICATOR([mknodat])
sys_stat
extensions
fcntl-h [test $HAVE_MKFIFOAT = 0 || test $REPLACE_MKFIFOAT = 1 || test $HAVE_MKNODAT = 0 || test $REPLACE_MKNODAT = 1]
fstatat [test $REPLACE_MKFIFOAT = 1 || test $REPLACE_MKNODAT = 1]
at-internal [test $HAVE_MKFIFOAT = 0 || test $HAVE_MKNODAT = 0]
errno [test $HAVE_MKFIFOAT = 0 || test $HAVE_MKNODAT = 0]
fchdir [test $HAVE_MKFIFOAT = 0 || test $HAVE_MKNODAT = 0]
filename [test $HAVE_MKFIFOAT = 0 || test $HAVE_MKNODAT = 0]
openat-die [test $HAVE_MKFIFOAT = 0 || test $HAVE_MKNODAT = 0]
openat-h [test $HAVE_MKFIFOAT = 0 || test $HAVE_MKNODAT = 0]
save-cwd [test $HAVE_MKFIFOAT = 0 || test $HAVE_MKNODAT = 0]
mkfifo [test $HAVE_MKFIFOAT = 0]
mknod [test $HAVE_MKNODAT = 0]
mkdir-p #include "mkdir-p.h" dirchownmod.c
dirchownmod.h
mkdir-p.c
mkdir-p.m4
00gnulib.m4
zzgnulib.m4
gl_MKDIR_PARENTS
error
fcntl-h
fstat
gettext-h
lchmod
lchown
mkancesdirs
mkdir
quote
savewd
stat
stat-macros
stdbool
sys_stat
mkostemp #include <stdlib.h> mkostemp.c mkostemp.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_MKOSTEMP
gl_CONDITIONAL([GL_COND_OBJ_MKOSTEMP],
[test $HAVE_MKOSTEMP = 0 || test $REPLACE_MKOSTEMP = 1])
AM_COND_IF([GL_COND_OBJ_MKOSTEMP], [
gl_PREREQ_MKOSTEMP
])
gl_MODULE_INDICATOR([mkostemp])
gl_STDLIB_MODULE_INDICATOR([mkostemp])
stdlib
extensions
largefile
tempname [test $HAVE_MKOSTEMP = 0 || test $REPLACE_MKOSTEMP = 1]
mkostemps #include <stdlib.h> mkostemps.c mkostemps.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_MKOSTEMPS
gl_CONDITIONAL([GL_COND_OBJ_MKOSTEMPS],
[test $HAVE_MKOSTEMPS = 0 || test $REPLACE_MKOSTEMPS = 1])
gl_MODULE_INDICATOR([mkostemps])
gl_STDLIB_MODULE_INDICATOR([mkostemps])
stdlib
extensions
largefile
tempname [test $HAVE_MKOSTEMPS = 0 || test $REPLACE_MKOSTEMPS = 1]
mkstemps #include <stdlib.h> mkstemps.c mkstemps.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_MKSTEMPS
gl_CONDITIONAL([GL_COND_OBJ_MKSTEMPS], [test $HAVE_MKSTEMPS = 0])
gl_MODULE_INDICATOR([mkstemps])
gl_STDLIB_MODULE_INDICATOR([mkstemps])
stdlib
extensions
largefile
tempname [test $HAVE_MKSTEMPS = 0]
modechange #include "modechange.h" modechange.c modechange.m4
00gnulib.m4
zzgnulib.m4
gl_MODECHANGE
stat
stat-macros
stdbool
sys_stat
xalloc
mountlist #include "mountlist.h" mountlist.c fstypename.m4
mountlist.m4
00gnulib.m4
zzgnulib.m4
gl_MOUNTLIST
gl_CONDITIONAL([GL_COND_OBJ_MOUNTLIST], [test $gl_cv_list_mounted_fs = yes])
AM_COND_IF([GL_COND_OBJ_MOUNTLIST], [
gl_PREREQ_MOUNTLIST_EXTRA
])
fopen-gnu
free-posix
getline
open
unlocked-io-internal
stdbool
stdint
strstr-simple
xalloc
openat #include <fcntl.h> openat.c openat.m4
open-cloexec.m4
lstat.m4
mode_t.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_OPENAT
gl_CONDITIONAL([GL_COND_OBJ_OPENAT],
[test $HAVE_OPENAT = 0 || test $REPLACE_OPENAT = 1])
AM_COND_IF([GL_COND_OBJ_OPENAT], [
gl_PREREQ_OPENAT
])
gl_MODULE_INDICATOR([openat]) dnl for lib/getcwd.c
gl_FCNTL_MODULE_INDICATOR([openat])
fcntl-h
extensions
largefile
openat-h [test $HAVE_OPENAT = 0 || test $REPLACE_OPENAT = 1]
stdbool [test $HAVE_OPENAT = 0 || test $REPLACE_OPENAT = 1]
sys_stat [test $HAVE_OPENAT = 0 || test $REPLACE_OPENAT = 1]
cloexec [test $REPLACE_OPENAT = 1]
fstat [test $REPLACE_OPENAT = 1]
at-internal [test $HAVE_OPENAT = 0]
errno [test $HAVE_OPENAT = 0]
fchdir [test $HAVE_OPENAT = 0]
filename [test $HAVE_OPENAT = 0]
open [test $HAVE_OPENAT = 0]
openat-die [test $HAVE_OPENAT = 0]
save-cwd [test $HAVE_OPENAT = 0]
openat-die #include "openat.h" openat-die.c 00gnulib.m4
zzgnulib.m4
openat-h
error
exitfail
gettext-h
snippet/_Noreturn
pathmax #include "pathmax.h" --- pathmax.m4
00gnulib.m4
zzgnulib.m4
gl_PATHMAX
unistd
qacl --- --- 00gnulib.m4
zzgnulib.m4
qcopy-acl
qset-acl
qcopy-acl #include "acl.h" qcopy-acl.c xattr.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_XATTR
AC_REQUIRE([gl_FUNC_ACL])
if test "$use_xattr" = yes; then
QCOPY_ACL_LIB="$LIB_XATTR"
else
QCOPY_ACL_LIB="$LIB_ACL"
fi
AC_SUBST([QCOPY_ACL_LIB])
acl-permissions [test "$use_xattr" != yes]
qset-acl #include "acl.h" qset-acl.c 00gnulib.m4
zzgnulib.m4
acl-permissions
read-file #include "read-file.h" read-file.c read-file.m4
00gnulib.m4
zzgnulib.m4
gl_PREREQ_READ_FILE
fopen-gnu
free-posix
fstat
ftello
malloc-posix
memset_explicit
realloc-posix
stdint
sys_stat
readlinkat #include <fcntl.h>
#include <unistd.h>
readlinkat.c
at-func.c
readlinkat.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_READLINKAT
gl_CONDITIONAL([GL_COND_OBJ_READLINKAT],
[test $HAVE_READLINKAT = 0 || test $REPLACE_READLINKAT = 1])
gl_UNISTD_MODULE_INDICATOR([readlinkat])
unistd
extensions
at-internal [test $HAVE_READLINKAT = 0 || test $REPLACE_READLINKAT = 1]
errno [test $HAVE_READLINKAT = 0 || test $REPLACE_READLINKAT = 1]
fchdir [test $HAVE_READLINKAT = 0 || test $REPLACE_READLINKAT = 1]
fcntl-h [test $HAVE_READLINKAT = 0 || test $REPLACE_READLINKAT = 1]
filename [test $HAVE_READLINKAT = 0 || test $REPLACE_READLINKAT = 1]
fstatat [test $HAVE_READLINKAT = 1 && test $REPLACE_READLINKAT = 1]
openat-die [test $HAVE_READLINKAT = 0 || test $REPLACE_READLINKAT = 1]
openat-h [test $HAVE_READLINKAT = 0 || test $REPLACE_READLINKAT = 1]
save-cwd [test $HAVE_READLINKAT = 0 || test $REPLACE_READLINKAT = 1]
readlink [test $HAVE_READLINKAT = 0 || test $REPLACE_READLINKAT = 1]
renameatu #include "renameatu.h" at-func2.c
renameatu.c
renameat.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_RENAMEAT
if test $HAVE_RENAMEAT = 0; then
AC_LIBOBJ([at-func2])
fi
stdio
extensions
fcntl-h
filenamecat-lgpl [test $HAVE_RENAMEAT = 0 || test $REPLACE_RENAMEAT = 1]
openat-h [test $HAVE_RENAMEAT = 0 || test $REPLACE_RENAMEAT = 1]
fstatat [test $REPLACE_RENAMEAT = 1]
readlinkat [test $REPLACE_RENAMEAT = 1]
stdbool [test $REPLACE_RENAMEAT = 1]
at-internal [test $HAVE_RENAMEAT = 0]
filename [test $HAVE_RENAMEAT = 0]
fstat [test $HAVE_RENAMEAT = 0]
getcwd-lgpl [test $HAVE_RENAMEAT = 0]
openat-die [test $HAVE_RENAMEAT = 0]
rename [test $HAVE_RENAMEAT = 0]
same-inode [test $HAVE_RENAMEAT = 0]
save-cwd [test $HAVE_RENAMEAT = 0]
stat [test $HAVE_RENAMEAT = 0]
same #include "same.h" same.c same.m4
00gnulib.m4
zzgnulib.m4
gl_SAME
c99
error
dirname
fstat
fstatat
openat
same-inode
stdbool
memcmp
save-cwd #include "save-cwd.h" save-cwd.c save-cwd.m4
00gnulib.m4
zzgnulib.m4
gl_SAVE_CWD
chdir-long
fchdir
fd-safer-flag
getcwd-lgpl
open
stdbool
unistd-safer
savedir #include "savedir.h" savedir.c savedir.m4
00gnulib.m4
zzgnulib.m4
gl_SAVEDIR
closedir
dirent-safer
fdopendir
free-posix
opendir
readdir
stpcpy
xalloc
savewd #include "savewd.h" savewd.c savewd.m4
00gnulib.m4
zzgnulib.m4
gl_SAVEWD
assure
attribute
chdir
errno
extern-inline
fchdir
fcntl-safer
fcntl-h
filename
raise
stdbool
stdlib
sys_wait
unistd
xalloc
stat-macros #include "stat-macros.h" --- 00gnulib.m4
zzgnulib.m4
---
stat-time #include "stat-time.h" stat-time.c stat-time.m4
00gnulib.m4
zzgnulib.m4
gl_STAT_TIME
gl_STAT_BIRTHTIME
time-h
errno
extensions
extern-inline
stdckdint
symlink #include <unistd.h> symlink.c symlink.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_SYMLINK
gl_CONDITIONAL([GL_COND_OBJ_SYMLINK],
[test $HAVE_SYMLINK = 0 || test $REPLACE_SYMLINK = 1])
gl_UNISTD_MODULE_INDICATOR([symlink])
unistd
lstat [test $HAVE_SYMLINK = 0 || test $REPLACE_SYMLINK = 1]
symlinkat #include <fcntl.h>
#include <unistd.h>
symlinkat.c
at-func.c
symlinkat.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_SYMLINKAT
gl_CONDITIONAL([GL_COND_OBJ_SYMLINKAT],
[test $HAVE_SYMLINKAT = 0 || test $REPLACE_SYMLINKAT = 1])
gl_UNISTD_MODULE_INDICATOR([symlinkat])
unistd
extensions
fcntl-h [test $HAVE_SYMLINKAT = 0 || test $REPLACE_SYMLINKAT = 1]
at-internal [test $HAVE_SYMLINKAT = 0]
errno [test $HAVE_SYMLINKAT = 0]
fchdir [test $HAVE_SYMLINKAT = 0]
filename [test $HAVE_SYMLINKAT = 0]
openat-die [test $HAVE_SYMLINKAT = 0]
openat-h [test $HAVE_SYMLINKAT = 0]
save-cwd [test $HAVE_SYMLINKAT = 0]
symlink [test $HAVE_SYMLINKAT = 0]
fstatat [test $REPLACE_SYMLINKAT = 1]
sys_file #include <sys/file.h> sys_file.in.h sys_file_h.m4
00gnulib.m4
zzgnulib.m4
gl_SYS_FILE_H
gl_SYS_FILE_H_REQUIRE_DEFAULTS
AC_PROG_MKDIR_P
gen-header
include_next
snippet/warn-on-use
sys_ioctl #include <sys/ioctl.h> sys_ioctl.in.h sys_ioctl_h.m4
00gnulib.m4
zzgnulib.m4
gl_SYS_IOCTL_H
gl_SYS_IOCTL_H_REQUIRE_DEFAULTS
AC_PROG_MKDIR_P
gen-header
include_next
snippet/c++defs
snippet/warn-on-use
unistd
tmpdir #include "tmpdir.h" tmpdir.c tmpdir.m4
00gnulib.m4
zzgnulib.m4
gt_TMPDIR
secure_getenv
stat
stdbool
sys_stat
pathmax
unlinkdir #include "unlinkdir.h" unlinkdir.c unlinkdir.m4
00gnulib.m4
zzgnulib.m4
gl_UNLINKDIR
stdbool
priv-set
root-uid
utimecmp #include "utimecmp.h" utimecmp.c utimecmp.m4
00gnulib.m4
zzgnulib.m4
gl_UTIMECMP
dirname-lgpl
fstatat
hash
stat-time
time-h
utimensat
intprops
stdbool
stdint
assert-h
utimens #include "utimens.h" utimens.c utimens.m4
utimes.m4
00gnulib.m4
zzgnulib.m4
gl_UTIMENS
errno
extern-inline
fcntl-h
fstat
lstat
gettime
msvc-nothrow
stat
stat-time
stdbool
sys_stat
sys_time
time-h
utime
utime-h
write-any-file #include "write-any-file.h" write-any-file.c write-any-file.m4
00gnulib.m4
zzgnulib.m4
gl_WRITE_ANY_FILE
stdbool
priv-set
root-uid
xconcat-filename #include "concat-filename.h" xconcat-filename.c 00gnulib.m4
zzgnulib.m4
concat-filename
xalloc-die
xgetcwd #include "xgetcwd.h" xgetcwd.c xgetcwd.m4
00gnulib.m4
zzgnulib.m4
gl_XGETCWD
getcwd
xalloc
xreadlink #include "xreadlink.h" xreadlink.c 00gnulib.m4
zzgnulib.m4
areadlink
xalloc
xreadlinkat #include "xreadlink.h" xreadlinkat.c 00gnulib.m4
zzgnulib.m4
gl_MODULE_INDICATOR([xreadlinkat])
areadlinkat
xalloc

File system as inode set

modules/ lib/ lib/ m4/  
Module Header Implementation Autoconf macro Depends on
cycle-check #include "cycle-check.h" cycle-check.c cycle-check.m4
00gnulib.m4
zzgnulib.m4
gl_CYCLE_CHECK
assure
dev-ino
same-inode
stdbool
stdint
dev-ino #include "dev-ino.h" --- 00gnulib.m4
zzgnulib.m4
---
file-set #include "file-set.h" file-set.c 00gnulib.m4
zzgnulib.m4
hash
hash-triple-simple
stdbool
xalloc
xalloc-die
hash-triple #include "hash-triple.h" hash-triple.c 00gnulib.m4
zzgnulib.m4
hash-triple-simple
same
same-inode
i-ring #include "i-ring.h" i-ring.c i-ring.m4
00gnulib.m4
zzgnulib.m4
gl_I_RING
assert-h
stdbool
same-inode #include "same-inode.h" --- 00gnulib.m4
zzgnulib.m4
sys_types

File descriptor based Input/Output

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

File stream based Input/Output

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

Users and groups

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

Security

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

Date and time

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

Networking functions

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

Multithreading

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

Signal handling

modules/ lib/ lib/ m4/  
Module Header Implementation Autoconf macro Depends on
c-stack #include "c-stack.h" c-stack.c c-stack.m4
00gnulib.m4
zzgnulib.m4
gl_C_STACK
c99
errno
exitfail
getprogname
gettext-h
idx
ignore-value
inttypes
mempcpy
raise
sigsegv
stddef
unistd
libsigsegv #if HAVE_LIBSIGSEGV
# include <sigsegv.h>
#endif
--- libsigsegv.m4
00gnulib.m4
zzgnulib.m4
gl_LIBSIGSEGV
havelib
sig2str #include "sig2str.h" sig2str.c sig2str.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_SIG2STR
gl_CONDITIONAL([GL_COND_OBJ_SIG2STR], [test $ac_cv_func_sig2str = no])
AM_COND_IF([GL_COND_OBJ_SIG2STR], [
gl_PREREQ_SIG2STR
])
intprops
sigpipe #include <signal.h> stdio-write.c sigpipe.m4
asm-underscore.m4
00gnulib.m4
zzgnulib.m4
gl_SIGNAL_SIGPIPE
dnl Define the C macro GNULIB_SIGPIPE to 1.
gl_MODULE_INDICATOR([sigpipe])
dnl Define the substituted variable GNULIB_SIGNAL_H_SIGPIPE to 1.
gl_SIGNAL_H_REQUIRE_DEFAULTS
gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_SIGNAL_H_SIGPIPE], [1])
dnl Define the substituted variable GNULIB_STDIO_H_SIGPIPE to 1.
gl_STDIO_H_REQUIRE_DEFAULTS
AC_REQUIRE([gl_ASM_SYMBOL_PREFIX])
gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STDIO_H_SIGPIPE], [1])
dnl Define the substituted variable GNULIB_UNISTD_H_SIGPIPE to 1.
gl_UNISTD_H_REQUIRE_DEFAULTS
gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNISTD_H_SIGPIPE], [1])
msvc-nothrow
raise
signal-h
sigprocmask
stdio
unistd
sigpipe-die #include "sigpipe-die.h" sigpipe-die.c 00gnulib.m4
zzgnulib.m4
error
gettext-h
exitfail
sigpipe
sigprocmask
sigaction
sigsegv #include <sigsegv.h> sigsegv.in.h
sigsegv.c
stackvma.h
stackvma.c
mmap-anon.m4
musl.m4
sigaltstack.m4
stack-direction.m4
libsigsegv.m4
sigsegv.m4
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([gl_SIGSEGV])
if test $gl_sigsegv_uses_libsigsegv = yes; then
GL_GENERATE_SIGSEGV_H=false
else
GL_GENERATE_SIGSEGV_H=true
fi
gl_CONDITIONAL_HEADER([sigsegv.h])
AC_PROG_MKDIR_P
if $GL_GENERATE_SIGSEGV_H; then
dnl Persuade glibc to declare macros designating register
dnl indices: REG_RSP on x86_64, REG_ESP on i386.
dnl Persuade Solaris OpenIndiana to include ,
dnl which declares macros designating register indices, such as ESP on i386.
dnl Persuade Solaris OpenIndiana to declare mincore().
AC_REQUIRE([gl_USE_SYSTEM_EXTENSIONS])

gl_MUSL_LIBC

AC_REQUIRE([AC_CANONICAL_HOST])
case "$host_os" in
solaris2.11)
AC_DEFINE([SOLARIS11], [1], [Define on Solaris 11 and its derivates.])
;;
esac

gl_FUNC_MMAP_ANON

dnl Stack direction.
SV_STACK_DIRECTION

dnl Catching stack overflow requires an alternate signal stack.
dnl The old "install a guard page" trick would be unreliable, because
dnl we don't know where exactly to place the guard page.
SV_SIGALTSTACK

AC_CHECK_FUNCS_ONCE([getrlimit])
fi
gen-header
havelib
host-cpu-c-abi
stdint
getpagesize

Terminal I/O

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

Internationalization functions

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

Unicode string functions

modules/ lib/ lib/ m4/  
Module Header Implementation Autoconf macro Depends on
libunistring #if HAVE_LIBUNISTRING
# include <unitypes.h>
# include <unistr.h>
# include <uniconv.h>
# include <unistdio.h>
# include <uniname.h>
# include <unictype.h>
# include <uniwidth.h>
# include <uniwbrk.h>
# include <unilbrk.h>
# include <uninorm.h>
# include <unicase.h>
# include <uniregex.h>
# include <unistring/version.h>
#endif
libunistring.valgrind libunistring.m4
absolute-header.m4
00gnulib.m4
zzgnulib.m4
gl_LIBUNISTRING
havelib
iconv
libunistring-optional --- libunistring.valgrind libunistring-optional.m4
libunistring.m4
absolute-header.m4
00gnulib.m4
zzgnulib.m4
gl_LIBUNISTRING_OPTIONAL
havelib
iconv
unitypes #include "unitypes.h" unitypes.in.h libunistring-base.m4
00gnulib.m4
zzgnulib.m4
gl_LIBUNISTRING_LIBHEADER([0.9.11], [unitypes.h])
AC_PROG_MKDIR_P

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

Executing programs

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

Java

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

C#

modules/ lib/ lib/ m4/  
Module Header Implementation Autoconf macro Depends on
csharpcomp-script --- --- csharpcomp.m4
csharp.m4
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([gt_CSHARPCOMP])
AC_CONFIG_FILES([csharpcomp.sh:build-aux/csharpcomp.sh.in])
---
csharpcomp #include "csharpcomp.h" csharpcomp.c 00gnulib.m4
zzgnulib.m4
stdbool
xmalloca
execute
spawn-pipe
wait-process
getline
sh-quote
safe-read
error
gettext-h
memcmp
csharpcomp-script
csharpexec-script --- --- csharpexec.m4
csharp.m4
00gnulib.m4
zzgnulib.m4
# You need to invoke gt_CSHARPEXEC yourself, possibly with arguments.
AC_CONFIG_FILES([csharpexec.sh:build-aux/csharpexec.sh.in])
---
csharpexec #include "csharpexec.h" csharpexec.c
classpath.h
classpath.c
00gnulib.m4
zzgnulib.m4
stdbool
execute
xsetenv
sh-quote
xalloc
xmalloca
error
gettext-h
csharpexec-script

Misc

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

Support for building libraries and executables

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

Support for building documentation

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

Support for maintaining and releasing projects

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

Misc

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

Unclassified modules - please update MODULES.html.sh

modules/ lib/ lib/ m4/  
Module Header Implementation Autoconf macro Depends on
access #include <unistd.h> access.c access.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_ACCESS
gl_CONDITIONAL([GL_COND_OBJ_ACCESS], [test $REPLACE_ACCESS = 1])
gl_UNISTD_MODULE_INDICATOR([access])
unistd
fcntl
acosf #include <math.h> acosf.c acosf.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_ACOSF
gl_CONDITIONAL([GL_COND_OBJ_ACOSF], [test $HAVE_ACOSF = 0])
gl_MATH_MODULE_INDICATOR([acosf])
math
extensions
acos [test $HAVE_ACOSF = 0]
allocator #include "allocator.h" allocator.c 00gnulib.m4
zzgnulib.m4
---
ansi-c++-opt --- --- ansi-c++.m4
00gnulib.m4
zzgnulib.m4
---
array-map #include "gl_array_map.h" gl_array_map.c 00gnulib.m4
zzgnulib.m4
map
stdint
xsize
array-omap #include "gl_array_omap.h" gl_array_omap.c 00gnulib.m4
zzgnulib.m4
omap
xsize
array-set #include "gl_array_set.h" gl_array_set.c 00gnulib.m4
zzgnulib.m4
set
stdint
xsize
asinf #include <math.h> asinf.c asinf.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_ASINF
gl_CONDITIONAL([GL_COND_OBJ_ASINF], [test $HAVE_ASINF = 0])
gl_MATH_MODULE_INDICATOR([asinf])
math
extensions
asin [test $HAVE_ASINF = 0]
assert-h #include <assert.h> assert.in.h
verify.h
assert_h.m4
00gnulib.m4
zzgnulib.m4
gl_ASSERT_H
gl_CONDITIONAL_HEADER([assert.h])
AC_PROG_MKDIR_P
gen-header
include_next
at-internal #include "openat-priv.h" openat-proc.c 00gnulib.m4
zzgnulib.m4
AC_REQUIRE([AC_CANONICAL_HOST])
errno
fcntl-h
intprops
open [case $host_os in mingw*) false;; *) :;; esac]
sys_stat
unistd
atan2f #include <math.h> atan2f.c atan2f.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_ATAN2F
gl_CONDITIONAL([GL_COND_OBJ_ATAN2F], [test $HAVE_ATAN2F = 0])
gl_MATH_MODULE_INDICATOR([atan2f])
math
extensions
atan2 [test $HAVE_ATAN2F = 0]
atanf #include <math.h> atanf.c atanf.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_ATANF
gl_CONDITIONAL([GL_COND_OBJ_ATANF], [test $HAVE_ATANF = 0])
gl_MATH_MODULE_INDICATOR([atanf])
math
extensions
atan [test $HAVE_ATANF = 0]
avltree-omap #include "gl_avltree_omap.h" gl_avltree_omap.c
gl_avltree_ordered.h
gl_anytree_omap.h
00gnulib.m4
zzgnulib.m4
omap
bitset #include "bitset.h" bitset.c
bitset/array.c
bitset/array.h
bitset/base.h
bitset/list.c
bitset/list.h
bitset/stats.c
bitset/stats.h
bitset/table.c
bitset/table.h
bitset/vector.c
bitset/vector.h
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([AC_C_INLINE])
attribute
c99
ffsl
fopen-gnu
gettext-h
integer_length_l
obstack
stdbool
xalloc
bitsetv #include "bitsetv.h" bitsetv.c 00gnulib.m4
zzgnulib.m4
bitset
c99
xalloc
btoc32 #include <uchar.h> btoc32.c 00gnulib.m4
zzgnulib.m4
gl_UCHAR_MODULE_INDICATOR([btoc32])
uchar
mbrtoc32
btowc
c-snprintf #include "c-snprintf.h" c-snprintf.c 00gnulib.m4
zzgnulib.m4
AC_REQUIRE([AC_C_RESTRICT])
stdio
c-vasnprintf
c-vasnprintf #include "c-vasnprintf.h" c-vasnprintf.c
float+.h
printf-args.h
printf-args.c
printf-parse.h
printf-parse.c
vasnprintf.h
vasnprintf.c
wchar_t.m4
wint_t.m4
intmax_t.m4
stdint_h.m4
inttypes_h.m4
vasnprintf.m4
printf.m4
math_h.m4
exponentd.m4
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([AC_C_RESTRICT])
gl_PREREQ_VASNPRINTF_WITH_POSIX_EXTRAS
assert-h
attribute
limits-h
stdint
stdio
isnand-nolibm
isnanl-nolibm
frexpl-nolibm
printf-frexp
printf-frexpl
signbit
fpucw
free-posix
nocrash
printf-safe
alloca-opt
xsize
errno
memchr
multiarch
c-vasprintf #include "c-vasprintf.h" c-asprintf.c
c-vasprintf.c
00gnulib.m4
zzgnulib.m4
stdio
c-vasnprintf
c-vsnprintf #include "c-vsnprintf.h" c-vsnprintf.c 00gnulib.m4
zzgnulib.m4
AC_REQUIRE([AC_C_RESTRICT])
stdio
c-vasnprintf
c-xvasprintf #include "c-xvasprintf.h" c-xasprintf.c
c-xvasprintf.c
00gnulib.m4
zzgnulib.m4
stdio
c-vasprintf
xalloc-die
c32isalnum #include <uchar.h> c32isalnum.c
c32is-impl.h
mbrtoc32.m4
mbrtowc.m4
locale-fr.m4
locale-ja.m4
locale-zh.m4
codeset.m4
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([gl_UCHAR_H])
dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is
dnl determined. It describes how mbrtoc32 is implemented.
AC_REQUIRE([gl_MBSTATE_T_BROKEN])
AC_REQUIRE([gl_MBRTOC32_SANITYCHECK])
gl_UCHAR_MODULE_INDICATOR([c32isalnum])
uchar
wchar
wctype-h
localcharset [test $REPLACE_MBSTATE_T = 1]
streq [test $REPLACE_MBSTATE_T = 1]
unictype/ctype-alnum
assert-h
c32isalpha #include <uchar.h> c32isalpha.c
c32is-impl.h
mbrtoc32.m4
mbrtowc.m4
locale-fr.m4
locale-ja.m4
locale-zh.m4
codeset.m4
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([gl_UCHAR_H])
dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is
dnl determined. It describes how mbrtoc32 is implemented.
AC_REQUIRE([gl_MBSTATE_T_BROKEN])
AC_REQUIRE([gl_MBRTOC32_SANITYCHECK])
gl_UCHAR_MODULE_INDICATOR([c32isalpha])
uchar
wchar
wctype-h
localcharset [test $REPLACE_MBSTATE_T = 1]
streq [test $REPLACE_MBSTATE_T = 1]
unictype/ctype-alpha
assert-h
c32isblank #include <uchar.h> c32isblank.c
c32is-impl.h
mbrtoc32.m4
mbrtowc.m4
locale-fr.m4
locale-ja.m4
locale-zh.m4
codeset.m4
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([gl_UCHAR_H])
dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is
dnl determined. It describes how mbrtoc32 is implemented.
AC_REQUIRE([gl_MBSTATE_T_BROKEN])
AC_REQUIRE([gl_MBRTOC32_SANITYCHECK])
gl_UCHAR_MODULE_INDICATOR([c32isblank])
uchar
wchar
wctype-h
iswblank
localcharset [test $REPLACE_MBSTATE_T = 1]
streq [test $REPLACE_MBSTATE_T = 1]
unictype/ctype-blank
assert-h
c32iscntrl #include <uchar.h> c32iscntrl.c
c32is-impl.h
mbrtoc32.m4
mbrtowc.m4
locale-fr.m4
locale-ja.m4
locale-zh.m4
codeset.m4
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([gl_UCHAR_H])
dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is
dnl determined. It describes how mbrtoc32 is implemented.
AC_REQUIRE([gl_MBSTATE_T_BROKEN])
AC_REQUIRE([gl_MBRTOC32_SANITYCHECK])
gl_UCHAR_MODULE_INDICATOR([c32iscntrl])
uchar
wchar
wctype-h
localcharset [test $REPLACE_MBSTATE_T = 1]
streq [test $REPLACE_MBSTATE_T = 1]
unictype/ctype-cntrl
assert-h
c32isdigit #include <uchar.h> c32isdigit.c
c32is-impl.h
mbrtoc32.m4
mbrtowc.m4
locale-fr.m4
locale-ja.m4
locale-zh.m4
codeset.m4
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([gl_UCHAR_H])
dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is
dnl determined. It describes how mbrtoc32 is implemented.
AC_REQUIRE([gl_MBSTATE_T_BROKEN])
AC_REQUIRE([gl_MBRTOC32_SANITYCHECK])
gl_UCHAR_MODULE_INDICATOR([c32isdigit])
uchar
wchar
wctype-h
iswdigit
localcharset [test $REPLACE_MBSTATE_T = 1]
streq [test $REPLACE_MBSTATE_T = 1]
unictype/ctype-digit
assert-h
c32isgraph #include <uchar.h> c32isgraph.c
c32is-impl.h
mbrtoc32.m4
mbrtowc.m4
locale-fr.m4
locale-ja.m4
locale-zh.m4
codeset.m4
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([gl_UCHAR_H])
dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is
dnl determined. It describes how mbrtoc32 is implemented.
AC_REQUIRE([gl_MBSTATE_T_BROKEN])
AC_REQUIRE([gl_MBRTOC32_SANITYCHECK])
gl_UCHAR_MODULE_INDICATOR([c32isgraph])
uchar
wchar
wctype-h
localcharset [test $REPLACE_MBSTATE_T = 1]
streq [test $REPLACE_MBSTATE_T = 1]
unictype/ctype-graph
assert-h
c32islower #include <uchar.h> c32islower.c
c32is-impl.h
mbrtoc32.m4
mbrtowc.m4
locale-fr.m4
locale-ja.m4
locale-zh.m4
codeset.m4
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([gl_UCHAR_H])
dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is
dnl determined. It describes how mbrtoc32 is implemented.
AC_REQUIRE([gl_MBSTATE_T_BROKEN])
AC_REQUIRE([gl_MBRTOC32_SANITYCHECK])
gl_UCHAR_MODULE_INDICATOR([c32islower])
uchar
wchar
wctype-h
localcharset [test $REPLACE_MBSTATE_T = 1]
streq [test $REPLACE_MBSTATE_T = 1]
unictype/ctype-lower
assert-h
c32isprint #include <uchar.h> c32isprint.c
c32is-impl.h
mbrtoc32.m4
mbrtowc.m4
locale-fr.m4
locale-ja.m4
locale-zh.m4
codeset.m4
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([gl_UCHAR_H])
dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is
dnl determined. It describes how mbrtoc32 is implemented.
AC_REQUIRE([gl_MBSTATE_T_BROKEN])
AC_REQUIRE([gl_MBRTOC32_SANITYCHECK])
gl_UCHAR_MODULE_INDICATOR([c32isprint])
uchar
wchar
wctype-h
localcharset [test $REPLACE_MBSTATE_T = 1]
streq [test $REPLACE_MBSTATE_T = 1]
unictype/ctype-print
assert-h
c32ispunct #include <uchar.h> c32ispunct.c
c32is-impl.h
mbrtoc32.m4
mbrtowc.m4
locale-fr.m4
locale-ja.m4
locale-zh.m4
codeset.m4
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([gl_UCHAR_H])
dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is
dnl determined. It describes how mbrtoc32 is implemented.
AC_REQUIRE([gl_MBSTATE_T_BROKEN])
AC_REQUIRE([gl_MBRTOC32_SANITYCHECK])
gl_UCHAR_MODULE_INDICATOR([c32ispunct])
uchar
wchar
wctype-h
localcharset [test $REPLACE_MBSTATE_T = 1]
streq [test $REPLACE_MBSTATE_T = 1]
unictype/ctype-punct
assert-h
c32isspace #include <uchar.h> c32isspace.c
c32is-impl.h
mbrtoc32.m4
mbrtowc.m4
locale-fr.m4
locale-ja.m4
locale-zh.m4
codeset.m4
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([gl_UCHAR_H])
dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is
dnl determined. It describes how mbrtoc32 is implemented.
AC_REQUIRE([gl_MBSTATE_T_BROKEN])
AC_REQUIRE([gl_MBRTOC32_SANITYCHECK])
gl_UCHAR_MODULE_INDICATOR([c32isspace])
uchar
wchar
wctype-h
localcharset [test $REPLACE_MBSTATE_T = 1]
streq [test $REPLACE_MBSTATE_T = 1]
unictype/ctype-space
assert-h
c32isupper #include <uchar.h> c32isupper.c
c32is-impl.h
mbrtoc32.m4
mbrtowc.m4
locale-fr.m4
locale-ja.m4
locale-zh.m4
codeset.m4
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([gl_UCHAR_H])
dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is
dnl determined. It describes how mbrtoc32 is implemented.
AC_REQUIRE([gl_MBSTATE_T_BROKEN])
AC_REQUIRE([gl_MBRTOC32_SANITYCHECK])
gl_UCHAR_MODULE_INDICATOR([c32isupper])
uchar
wchar
wctype-h
localcharset [test $REPLACE_MBSTATE_T = 1]
streq [test $REPLACE_MBSTATE_T = 1]
unictype/ctype-upper
assert-h
c32isxdigit #include <uchar.h> c32isxdigit.c
c32is-impl.h
mbrtoc32.m4
mbrtowc.m4
locale-fr.m4
locale-ja.m4
locale-zh.m4
codeset.m4
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([gl_UCHAR_H])
dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is
dnl determined. It describes how mbrtoc32 is implemented.
AC_REQUIRE([gl_MBSTATE_T_BROKEN])
AC_REQUIRE([gl_MBRTOC32_SANITYCHECK])
gl_UCHAR_MODULE_INDICATOR([c32isxdigit])
uchar
wchar
wctype-h
iswxdigit
localcharset [test $REPLACE_MBSTATE_T = 1]
streq [test $REPLACE_MBSTATE_T = 1]
unictype/ctype-xdigit
assert-h
c32rtomb #include <uchar.h> c32rtomb.c c32rtomb.m4
mbrtoc32.m4
locale-fr.m4
locale-zh.m4
codeset.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_C32RTOMB
gl_CONDITIONAL([GL_COND_OBJ_C32RTOMB],
[test $HAVE_C32RTOMB = 0 || test $REPLACE_C32RTOMB = 1])
gl_UCHAR_MODULE_INDICATOR([c32rtomb])
uchar
attribute [test $HAVE_C32RTOMB = 0 || test $REPLACE_C32RTOMB = 1]
wchar [test $HAVE_C32RTOMB = 0 || test $REPLACE_C32RTOMB = 1]
wcrtomb [test $HAVE_C32RTOMB = 0 || test $REPLACE_C32RTOMB = 1]
localcharset [{ test $HAVE_C32RTOMB = 0 || test $REPLACE_C32RTOMB = 1; } && test $SMALL_WCHAR_T = 1]
streq [{ test $HAVE_C32RTOMB = 0 || test $REPLACE_C32RTOMB = 1; } && test $SMALL_WCHAR_T = 1]
c32snrtombs #include <uchar.h> c32snrtombs.c
wcsnrtombs-impl.h
c32srtombs-state.c
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([gl_UCHAR_H])
AC_LIBOBJ([c32srtombs-state])
gl_UCHAR_MODULE_INDICATOR([c32snrtombs])
uchar
wchar
assert-h
c32rtomb
wcsnrtombs [test $SMALL_WCHAR_T = 0]
c32srtombs #include <uchar.h> c32srtombs.c
wcsrtombs-impl.h
c32srtombs-state.c
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([gl_UCHAR_H])
AC_LIBOBJ([c32srtombs-state])
gl_UCHAR_MODULE_INDICATOR([c32srtombs])
uchar
wchar
assert-h
c32rtomb
wcsrtombs [test $SMALL_WCHAR_T = 0]
c32stombs #include <uchar.h> c32stombs.c 00gnulib.m4
zzgnulib.m4
gl_UCHAR_MODULE_INDICATOR([c32stombs])
uchar
wchar
c32srtombs
c32tob #include <uchar.h> c32tob.c mbrtoc32.m4
locale-fr.m4
locale-zh.m4
codeset.m4
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([gl_MBRTOC32_SANITYCHECK])
gl_UCHAR_MODULE_INDICATOR([c32tob])
uchar
c32rtomb
wctob
c32tolower #include <uchar.h> c32tolower.c
c32to-impl.h
mbrtoc32.m4
mbrtowc.m4
locale-fr.m4
locale-ja.m4
locale-zh.m4
codeset.m4
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([gl_UCHAR_H])
dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is
dnl determined. It describes how mbrtoc32 is implemented.
AC_REQUIRE([gl_MBSTATE_T_BROKEN])
AC_REQUIRE([gl_MBRTOC32_SANITYCHECK])
gl_UCHAR_MODULE_INDICATOR([c32tolower])
uchar
wchar
wctype-h
localcharset [test $REPLACE_MBSTATE_T = 1]
streq [test $REPLACE_MBSTATE_T = 1]
unicase/tolower
assert-h
c32toupper #include <uchar.h> c32toupper.c
c32to-impl.h
mbrtoc32.m4
mbrtowc.m4
locale-fr.m4
locale-ja.m4
locale-zh.m4
codeset.m4
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([gl_UCHAR_H])
dnl Determine REPLACE_MBSTATE_T, from which GNULIB_defined_mbstate_t is
dnl determined. It describes how mbrtoc32 is implemented.
AC_REQUIRE([gl_MBSTATE_T_BROKEN])
AC_REQUIRE([gl_MBRTOC32_SANITYCHECK])
gl_UCHAR_MODULE_INDICATOR([c32toupper])
uchar
wchar
wctype-h
localcharset [test $REPLACE_MBSTATE_T = 1]
streq [test $REPLACE_MBSTATE_T = 1]
unicase/toupper
assert-h
call_once #include <threads.h> call_once.c 00gnulib.m4
zzgnulib.m4
AC_REQUIRE([gl_THREADS_H])
gl_CONDITIONAL([GL_COND_OBJ_CALL_ONCE], [test $HAVE_THREADS_H = 0])
gl_THREADS_MODULE_INDICATOR([call_once])
threads-h
windows-once
careadlinkat #include "careadlinkat.h" careadlinkat.c 00gnulib.m4
zzgnulib.m4
AC_REQUIRE([AC_C_RESTRICT])
gl_CHECK_FUNCS_ANDROID([readlinkat], [[#include ]])
allocator
idx
minmax
ssize_t
unistd
cbrt-ieee #include <math.h> --- 00gnulib.m4
zzgnulib.m4
cbrt
fpieee
cbrtf #include <math.h> cbrtf.c cbrtf.m4
cbrt.m4
mathfunc.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_CBRTF
gl_CONDITIONAL([GL_COND_OBJ_CBRTF],
[test $HAVE_CBRTF = 0 || test $REPLACE_CBRTF = 1])
gl_MATH_MODULE_INDICATOR([cbrtf])
math
extensions
isfinite [test $HAVE_CBRTF = 0 || test $REPLACE_CBRTF = 1]
fabsf [test $HAVE_CBRTF = 0 || test $REPLACE_CBRTF = 1]
frexpf [test $HAVE_CBRTF = 0 || test $REPLACE_CBRTF = 1]
ldexpf [test $HAVE_CBRTF = 0 || test $REPLACE_CBRTF = 1]
cbrtf-ieee #include <math.h> --- 00gnulib.m4
zzgnulib.m4
cbrtf
fpieee
cbrtl #include <math.h> cbrtl.c cbrtl.m4
cbrt.m4
mathfunc.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_CBRTL
gl_CONDITIONAL([GL_COND_OBJ_CBRTL],
[test $HAVE_CBRTL = 0 || test $REPLACE_CBRTL = 1])
gl_MATH_MODULE_INDICATOR([cbrtl])
math
extensions
cbrt [{ test $HAVE_CBRTL = 0 || test $REPLACE_CBRTL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1]
isfinite [{ test $HAVE_CBRTL = 0 || test $REPLACE_CBRTL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
frexpl [{ test $HAVE_CBRTL = 0 || test $REPLACE_CBRTL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
ldexpl [{ test $HAVE_CBRTL = 0 || test $REPLACE_CBRTL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
cbrtl-ieee #include <math.h> --- cbrtl-ieee.m4
minus-zero.m4
signbit.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_CBRTL_IEEE
cbrtl
fpieee
ceil-ieee #include <math.h> --- ceil-ieee.m4
minus-zero.m4
signbit.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_CEIL_IEEE
ceil
ceilf-ieee #include <math.h> --- ceilf-ieee.m4
minus-zero.m4
signbit.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_CEILF_IEEE
ceilf
ceill-ieee #include <math.h> --- ceill-ieee.m4
minus-zero.m4
signbit.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_CEILL_IEEE
ceill
chdir #include <unistd.h> --- 00gnulib.m4
zzgnulib.m4
gl_UNISTD_MODULE_INDICATOR([chdir])
unistd
closedir #include <dirent.h> closedir.c
dirent-private.h
closedir.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_CLOSEDIR
gl_CONDITIONAL([GL_COND_OBJ_CLOSEDIR],
[test $HAVE_CLOSEDIR = 0 || test $REPLACE_CLOSEDIR = 1])
gl_DIRENT_MODULE_INDICATOR([closedir])
dirent
dirfd [test $HAVE_CLOSEDIR = 0 || test $REPLACE_CLOSEDIR = 1]
cnd #include <threads.h> cnd.c 00gnulib.m4
zzgnulib.m4
AC_REQUIRE([gl_THREADS_H])
gl_CONDITIONAL([GL_COND_OBJ_CND], [test $HAVE_THREADS_H = 0])
gl_THREADS_MODULE_INDICATOR([cnd])
threads-h
windows-cond
gettimeofday
copysignf #include <math.h> copysignf.c copysignf.m4
mathfunc.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_COPYSIGNF
gl_CONDITIONAL([GL_COND_OBJ_COPYSIGNF], [test $HAVE_COPYSIGNF = 0])
gl_MATH_MODULE_INDICATOR([copysignf])
math
extensions
signbit [test $HAVE_COPYSIGNF = 0]
copysignl #include <math.h> copysignl.c copysignl.m4
mathfunc.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_COPYSIGNL
gl_CONDITIONAL([GL_COND_OBJ_COPYSIGNL], [test $HAVE_COPYSIGNL = 0])
gl_MATH_MODULE_INDICATOR([copysignl])
math
extensions
copysign [test $HAVE_COPYSIGNL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1]
signbit [test $HAVE_COPYSIGNL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
cosf #include <math.h> cosf.c cosf.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_COSF
gl_CONDITIONAL([GL_COND_OBJ_COSF], [test $HAVE_COSF = 0])
gl_MATH_MODULE_INDICATOR([cosf])
math
extensions
cos [test $HAVE_COSF = 0]
coshf #include <math.h> coshf.c coshf.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_COSHF
gl_CONDITIONAL([GL_COND_OBJ_COSHF], [test $HAVE_COSHF = 0])
gl_MATH_MODULE_INDICATOR([coshf])
math
extensions
cosh [test $HAVE_COSHF = 0]
creat #include <fcntl.h> creat.c creat.m4
open-slash.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_CREAT
gl_CONDITIONAL([GL_COND_OBJ_CREAT], [test $REPLACE_CREAT = 1])
gl_FCNTL_MODULE_INDICATOR([creat])
fcntl-h
largefile
crypto/af_alg #include "af_alg.h" af_alg.c
sys-limits.h
af_alg.m4
00gnulib.m4
zzgnulib.m4
gl_AF_ALG
c99 [test $USE_AF_ALG = 1]
fflush [test $USE_AF_ALG = 1]
fseeko [test $USE_AF_ALG = 1]
ftello [test $USE_AF_ALG = 1]
fstat [test $USE_AF_ALG = 1]
sys_socket
sys_stat
crypto/gc-hmac-sha256 #include "gc.h" --- gc-hmac-sha256.m4
00gnulib.m4
zzgnulib.m4
gl_GC_HMAC_SHA256
gl_MODULE_INDICATOR([gc-hmac-sha256])
crypto/gc
crypto/hmac-sha256 [test "$ac_cv_libgcrypt" != yes]
crypto/gc-hmac-sha512 #include "gc.h" --- gc-hmac-sha512.m4
00gnulib.m4
zzgnulib.m4
gl_GC_HMAC_SHA512
gl_MODULE_INDICATOR([gc-hmac-sha512])
crypto/gc
crypto/hmac-sha512 [test "$ac_cv_libgcrypt" != yes]
crypto/gc-sha256 #include "gc.h" --- gc-sha256.m4
00gnulib.m4
zzgnulib.m4
gl_GC_SHA256
gl_MODULE_INDICATOR([gc-sha256])
crypto/gc
crypto/sha256 [test "$ac_cv_libgcrypt" != yes]
crypto/gc-sha512 #include "gc.h" --- gc-sha512.m4
00gnulib.m4
zzgnulib.m4
gl_GC_SHA512
gl_MODULE_INDICATOR([gc-sha512])
crypto/gc
crypto/sha512 [test "$ac_cv_libgcrypt" != yes]
crypto/hmac-sha256 #include "hmac.h" hmac.c
hmac-sha256.c
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([AC_C_RESTRICT])
memxor
crypto/sha256
crypto/hmac-sha512 #include "hmac.h" hmac.c
hmac-sha512.c
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([AC_C_RESTRICT])
memxor
crypto/sha512
di-set #include "di-set.h" di-set.c 00gnulib.m4
zzgnulib.m4
ino-map
hash
dosname #include "dosname.h" --- 00gnulib.m4
zzgnulib.m4
filename
dprintf-gnu #include <stdio.h> --- dprintf-gnu.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_DPRINTF_GNU
dprintf-posix
dtotimespec #include "timespec.h" dtotimespec.c 00gnulib.m4
zzgnulib.m4
intprops
timespec
dup #include <unistd.h> dup.c dup.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_DUP
gl_CONDITIONAL([GL_COND_OBJ_DUP], [test $REPLACE_DUP = 1])
AM_COND_IF([GL_COND_OBJ_DUP], [
gl_PREREQ_DUP
])
gl_UNISTD_MODULE_INDICATOR([dup])
unistd
msvc-inval [test $REPLACE_DUP = 1]
error-h #include "error.h" error.in.h error_h.m4
00gnulib.m4
zzgnulib.m4
gl_ERROR_H
gl_CONDITIONAL_HEADER([error.h])
AC_PROG_MKDIR_P
gen-header
snippet/c++defs
exp-ieee #include <math.h> --- 00gnulib.m4
zzgnulib.m4
exp
fpieee
exp2 #include <math.h> exp2.c exp2.m4
mathfunc.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_EXP2
gl_CONDITIONAL([GL_COND_OBJ_EXP2],
[test $HAVE_EXP2 = 0 || test $REPLACE_EXP2 = 1])
gl_MATH_MODULE_INDICATOR([exp2])
math
extensions
isnand [test $HAVE_EXP2 = 0 || test $REPLACE_EXP2 = 1]
round [test $HAVE_EXP2 = 0 || test $REPLACE_EXP2 = 1]
ldexp [test $HAVE_EXP2 = 0 || test $REPLACE_EXP2 = 1]
exp2-ieee #include <math.h> --- 00gnulib.m4
zzgnulib.m4
exp2
fpieee
exp2f #include <math.h> exp2f.c exp2f.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_EXP2F
gl_CONDITIONAL([GL_COND_OBJ_EXP2F], [test $HAVE_EXP2F = 0])
gl_MATH_MODULE_INDICATOR([exp2f])
math
extensions
exp2 [test $HAVE_EXP2F = 0]
exp2f-ieee #include <math.h> --- 00gnulib.m4
zzgnulib.m4
exp2f
fpieee
exp2l #include <math.h> exp2l.c
expl-table.c
exp2l.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_EXP2L
gl_CONDITIONAL([GL_COND_OBJ_EXP2L],
[test $HAVE_EXP2L = 0 || test $REPLACE_EXP2L = 1])
AM_COND_IF([GL_COND_OBJ_EXP2L], [
AC_LIBOBJ([expl-table])
])
gl_MATH_MODULE_INDICATOR([exp2l])
math
extensions
exp2 [{ test $HAVE_EXP2L = 0 || test $REPLACE_EXP2L = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1]
float [{ test $HAVE_EXP2L = 0 || test $REPLACE_EXP2L = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
isnanl [{ test $HAVE_EXP2L = 0 || test $REPLACE_EXP2L = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
roundl [{ test $HAVE_EXP2L = 0 || test $REPLACE_EXP2L = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
ldexpl [{ test $HAVE_EXP2L = 0 || test $REPLACE_EXP2L = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
exp2l-ieee #include <math.h> --- exp2l-ieee.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_EXP2L_IEEE
exp2l
fpieee
expf #include <math.h> expf.c expf.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_EXPF
gl_CONDITIONAL([GL_COND_OBJ_EXPF], [test $HAVE_EXPF = 0])
gl_MATH_MODULE_INDICATOR([expf])
math
extensions
exp [test $HAVE_EXPF = 0]
expf-ieee #include <math.h> --- 00gnulib.m4
zzgnulib.m4
expf
fpieee
expl-ieee #include <math.h> --- 00gnulib.m4
zzgnulib.m4
expl
fpieee
expm1 #include <math.h> expm1.c expm1.m4
mathfunc.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_EXPM1
gl_CONDITIONAL([GL_COND_OBJ_EXPM1],
[test $HAVE_EXPM1 = 0 || test $REPLACE_EXPM1 = 1])
gl_MATH_MODULE_INDICATOR([expm1])
math
extensions
isnand [test $HAVE_EXPM1 = 0 || test $REPLACE_EXPM1 = 1]
exp [test $HAVE_EXPM1 = 0 || test $REPLACE_EXPM1 = 1]
round [test $HAVE_EXPM1 = 0 || test $REPLACE_EXPM1 = 1]
ldexp [test $HAVE_EXPM1 = 0 || test $REPLACE_EXPM1 = 1]
expm1-ieee #include <math.h> --- expm1-ieee.m4
minus-zero.m4
signbit.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_EXPM1_IEEE
expm1
fpieee
expm1f #include <math.h> expm1f.c expm1f.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_EXPM1F
gl_CONDITIONAL([GL_COND_OBJ_EXPM1F],
[test $HAVE_EXPM1F = 0 || test $REPLACE_EXPM1F = 1])
gl_MATH_MODULE_INDICATOR([expm1f])
math
extensions
expm1 [test $HAVE_EXPM1F = 0 || test $REPLACE_EXPM1F = 1]
expm1f-ieee #include <math.h> --- expm1f-ieee.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_EXPM1F_IEEE
expm1f
fpieee
expm1-ieee [test $HAVE_EXPM1F = 0 || test $REPLACE_EXPM1F = 1]
expm1l #include <math.h> expm1l.c expm1l.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_EXPM1L
gl_CONDITIONAL([GL_COND_OBJ_EXPM1L],
[test $HAVE_EXPM1L = 0 || test $REPLACE_EXPM1L = 1])
gl_MATH_MODULE_INDICATOR([expm1l])
math
extensions
expm1 [{ test $HAVE_EXPM1L = 0 || test $REPLACE_EXPM1L = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1]
float [{ test $HAVE_EXPM1L = 0 || test $REPLACE_EXPM1L = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
isnanl [{ test $HAVE_EXPM1L = 0 || test $REPLACE_EXPM1L = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
expl [{ test $HAVE_EXPM1L = 0 || test $REPLACE_EXPM1L = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
roundl [{ test $HAVE_EXPM1L = 0 || test $REPLACE_EXPM1L = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
ldexpl [{ test $HAVE_EXPM1L = 0 || test $REPLACE_EXPM1L = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
expm1l-ieee #include <math.h> --- 00gnulib.m4
zzgnulib.m4
AC_REQUIRE([gl_FUNC_EXPM1L])
expm1l
fpieee
expm1-ieee [test $HAVE_EXPM1L = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1]
extern-inline --- --- extern-inline.m4
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([gl_EXTERN_INLINE])
---
fabs-ieee #include <math.h> --- 00gnulib.m4
zzgnulib.m4
fabs
fpieee
fabsf #include <math.h> fabsf.c fabsf.m4
mathfunc.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_FABSF
gl_CONDITIONAL([GL_COND_OBJ_FABSF], [test $HAVE_FABSF = 0])
gl_MATH_MODULE_INDICATOR([fabsf])
math
extensions
fabs [test $HAVE_FABSF = 0]
fabsf-ieee #include <math.h> --- 00gnulib.m4
zzgnulib.m4
fabsf
fpieee
fabsl #include <math.h> fabsl.c fabsl.m4
mathfunc.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_FABSL
gl_CONDITIONAL([GL_COND_OBJ_FABSL],
[test $HAVE_FABSL = 0 || test $REPLACE_FABSL = 1])
gl_MATH_MODULE_INDICATOR([fabsl])
math
extensions
fabs [{ test $HAVE_FABSL = 0 || test $REPLACE_FABSL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1]
signbit [{ test $HAVE_FABSL = 0 || test $REPLACE_FABSL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
fabsl-ieee #include <math.h> --- 00gnulib.m4
zzgnulib.m4
fabsl
fpieee
fchmodat #include <sys/stat.h> fchmodat.c
at-func.c
fchmodat.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_FCHMODAT
gl_CONDITIONAL([GL_COND_OBJ_FCHMODAT],
[test $HAVE_FCHMODAT = 0 || test $REPLACE_FCHMODAT = 1])
AM_COND_IF([GL_COND_OBJ_FCHMODAT], [
gl_PREREQ_FCHMODAT
])
gl_SYS_STAT_MODULE_INDICATOR([fchmodat])
sys_stat
extensions
errno [test $HAVE_FCHMODAT = 0 || test $REPLACE_FCHMODAT = 1]
fcntl-h [test $HAVE_FCHMODAT = 0 || test $REPLACE_FCHMODAT = 1]
unistd [test $HAVE_FCHMODAT = 0 || test $REPLACE_FCHMODAT = 1]
intprops [test $HAVE_FCHMODAT = 0 || test $REPLACE_FCHMODAT = 1]
c99 [test $REPLACE_FCHMODAT = 1]
at-internal [test $HAVE_FCHMODAT = 0]
chmod [test $HAVE_FCHMODAT = 0]
extern-inline [test $HAVE_FCHMODAT = 0]
fchdir [test $HAVE_FCHMODAT = 0]
filename [test $HAVE_FCHMODAT = 0]
lchmod [test $HAVE_FCHMODAT = 0]
openat-die [test $HAVE_FCHMODAT = 0]
openat-h [test $HAVE_FCHMODAT = 0]
save-cwd [test $HAVE_FCHMODAT = 0]
fchownat #include <unistd.h> fchownat.c
at-func.c
fchownat.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_FCHOWNAT
gl_CONDITIONAL([GL_COND_OBJ_FCHOWNAT],
[test $HAVE_FCHOWNAT = 0 || test $REPLACE_FCHOWNAT = 1])
gl_UNISTD_MODULE_INDICATOR([fchownat])
unistd
extensions
at-internal [test $HAVE_FCHOWNAT = 0 || test $REPLACE_FCHOWNAT = 1]
errno [test $HAVE_FCHOWNAT = 0 || test $REPLACE_FCHOWNAT = 1]
extern-inline [test $HAVE_FCHOWNAT = 0 || test $REPLACE_FCHOWNAT = 1]
fchdir [test $HAVE_FCHOWNAT = 0 || test $REPLACE_FCHOWNAT = 1]
fcntl-h [test $HAVE_FCHOWNAT = 0 || test $REPLACE_FCHOWNAT = 1]
filename [test $HAVE_FCHOWNAT = 0 || test $REPLACE_FCHOWNAT = 1]
lchown [test $HAVE_FCHOWNAT = 0 || test $REPLACE_FCHOWNAT = 1]
openat-die [test $HAVE_FCHOWNAT = 0 || test $REPLACE_FCHOWNAT = 1]
openat-h [test $HAVE_FCHOWNAT = 0 || test $REPLACE_FCHOWNAT = 1]
save-cwd [test $HAVE_FCHOWNAT = 0 || test $REPLACE_FCHOWNAT = 1]
fd-hook #include "fd-hook.h" fd-hook.c 00gnulib.m4
zzgnulib.m4
unistd
fdopen #include <stdio.h> fdopen.c fdopen.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_FDOPEN
gl_CONDITIONAL([GL_COND_OBJ_FDOPEN], [test $REPLACE_FDOPEN = 1])
AM_COND_IF([GL_COND_OBJ_FDOPEN], [
gl_PREREQ_FDOPEN
])
gl_STDIO_MODULE_INDICATOR([fdopen])
stdio
msvc-inval [test $REPLACE_FDOPEN = 1]
file-has-acl #include "acl.h" acl-internal.h
file-has-acl.c
acl.m4
00gnulib.m4
zzgnulib.m4
gl_FILE_HAS_ACL
acl-permissions
extern-inline
free-posix
stat
stdbool
findprog-in #include "findprog.h" findprog-in.c findprog-in.m4
eaccess.m4
00gnulib.m4
zzgnulib.m4
gl_FINDPROG_IN
stdbool
sys_stat
filename
concat-filename
access
stat
strdup-posix
malloc-posix
unistd
floor-ieee #include <math.h> --- floor-ieee.m4
minus-zero.m4
signbit.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_FLOOR_IEEE
floor
floorf-ieee #include <math.h> --- floorf-ieee.m4
minus-zero.m4
signbit.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_FLOORF_IEEE
floorf
floorl-ieee #include <math.h> --- 00gnulib.m4
zzgnulib.m4
floorl
fma #include <math.h> fma.c
float+.h
fma.m4
fegetround.m4
mathfunc.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_FMA
gl_CONDITIONAL([GL_COND_OBJ_FMA], [test $HAVE_FMA = 0 || test $REPLACE_FMA = 1])
AM_COND_IF([GL_COND_OBJ_FMA], [
gl_PREREQ_FMA
])
gl_MATH_MODULE_INDICATOR([fma])
math
float [test $HAVE_FMA = 0 || test $REPLACE_FMA = 1]
stdbool [test $HAVE_FMA = 0 || test $REPLACE_FMA = 1]
assert-h [test $HAVE_FMA = 0 || test $REPLACE_FMA = 1]
isfinite [test $HAVE_FMA = 0 || test $REPLACE_FMA = 1]
integer_length [test $HAVE_FMA = 0 || test $REPLACE_FMA = 1]
frexp [test $HAVE_FMA = 0 || test $REPLACE_FMA = 1]
ldexp [test $HAVE_FMA = 0 || test $REPLACE_FMA = 1]
fma-ieee #include <math.h> --- 00gnulib.m4
zzgnulib.m4
fma
fpieee
fmaf #include <math.h> fmaf.c
fma.c
float+.h
fmaf.m4
fegetround.m4
mathfunc.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_FMAF
gl_CONDITIONAL([GL_COND_OBJ_FMAF],
[test $HAVE_FMAF = 0 || test $REPLACE_FMAF = 1])
AM_COND_IF([GL_COND_OBJ_FMAF], [
gl_PREREQ_FMAF
])
gl_MATH_MODULE_INDICATOR([fmaf])
math
extensions
float [test $HAVE_FMAF = 0 || test $REPLACE_FMAF = 1]
stdbool [test $HAVE_FMAF = 0 || test $REPLACE_FMAF = 1]
assert-h [test $HAVE_FMAF = 0 || test $REPLACE_FMAF = 1]
isfinite [test $HAVE_FMAF = 0 || test $REPLACE_FMAF = 1]
integer_length [test $HAVE_FMAF = 0 || test $REPLACE_FMAF = 1]
frexpf [test $HAVE_FMAF = 0 || test $REPLACE_FMAF = 1]
ldexpf [test $HAVE_FMAF = 0 || test $REPLACE_FMAF = 1]
fmaf-ieee #include <math.h> --- 00gnulib.m4
zzgnulib.m4
fmaf
fpieee
fmal #include <math.h> fmal.c
fma.c
float+.h
fmal.m4
fegetround.m4
mathfunc.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_FMAL
gl_CONDITIONAL([GL_COND_OBJ_FMAL],
[test $HAVE_FMAL = 0 || test $REPLACE_FMAL = 1])
AM_COND_IF([GL_COND_OBJ_FMAL], [
gl_PREREQ_FMAL
])
gl_MATH_MODULE_INDICATOR([fmal])
math
extensions
fma [{ test $HAVE_FMAL = 0 || test $REPLACE_FMAL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1]
float [{ test $HAVE_FMAL = 0 || test $REPLACE_FMAL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
stdbool [{ test $HAVE_FMAL = 0 || test $REPLACE_FMAL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
assert-h [{ test $HAVE_FMAL = 0 || test $REPLACE_FMAL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
isfinite [{ test $HAVE_FMAL = 0 || test $REPLACE_FMAL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
integer_length [{ test $HAVE_FMAL = 0 || test $REPLACE_FMAL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
frexpl [{ test $HAVE_FMAL = 0 || test $REPLACE_FMAL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
ldexpl [{ test $HAVE_FMAL = 0 || test $REPLACE_FMAL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
fmal-ieee #include <math.h> --- 00gnulib.m4
zzgnulib.m4
fmal
fpieee
fmod-ieee #include <math.h> --- fmod-ieee.m4
minus-zero.m4
signbit.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_FMOD_IEEE
fmod
fpieee
fmodf #include <math.h> fmodf.c fmodf.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_FMODF
gl_CONDITIONAL([GL_COND_OBJ_FMODF],
[test $HAVE_FMODF = 0 || test $REPLACE_FMODF = 1])
gl_MATH_MODULE_INDICATOR([fmodf])
math
extensions
fmod [test $HAVE_FMODF = 0 || test $REPLACE_FMODF = 1]
fmodf-ieee #include <math.h> --- fmodf-ieee.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_FMODF_IEEE
fmodf
fpieee
fmod-ieee [test $HAVE_FMODF = 0]
fmodl #include <math.h> fmodl.c
fmod.c
fmodl.m4
mathfunc.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_FMODL
gl_CONDITIONAL([GL_COND_OBJ_FMODL],
[test $HAVE_FMODL = 0 || test $REPLACE_FMODL = 1])
gl_MATH_MODULE_INDICATOR([fmodl])
math
extensions
fmod [{ test $HAVE_FMODL = 0 || test $REPLACE_FMODL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1]
float [{ test $HAVE_FMODL = 0 || test $REPLACE_FMODL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
isfinite [{ test $HAVE_FMODL = 0 || test $REPLACE_FMODL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
signbit [{ test $HAVE_FMODL = 0 || test $REPLACE_FMODL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
fabsl [{ test $HAVE_FMODL = 0 || test $REPLACE_FMODL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
frexpl [{ test $HAVE_FMODL = 0 || test $REPLACE_FMODL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
truncl [{ test $HAVE_FMODL = 0 || test $REPLACE_FMODL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
ldexpl [{ test $HAVE_FMODL = 0 || test $REPLACE_FMODL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
isnanl [{ test $HAVE_FMODL = 0 || test $REPLACE_FMODL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
isinf [{ test $HAVE_FMODL = 0 || test $REPLACE_FMODL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
fmodl-ieee #include <math.h> --- fmodl-ieee.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_FMODL_IEEE
fmodl
fpieee
fmod-ieee [{ test $HAVE_FMODL = 0 || test $REPLACE_FMODL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1]
fnmatch-h #include <fnmatch.h> fnmatch.in.h fnmatch_h.m4
00gnulib.m4
zzgnulib.m4
gl_FNMATCH_H
gl_FNMATCH_H_REQUIRE_DEFAULTS
gl_CONDITIONAL_HEADER([fnmatch.h])
AC_PROG_MKDIR_P
extensions
gen-header
include_next
snippet/arg-nonnull
snippet/c++defs
snippet/warn-on-use
fprintf-gnu #include <stdio.h> --- fprintf-gnu.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_FPRINTF_GNU
fprintf-posix
frexp-ieee #include <math.h> --- 00gnulib.m4
zzgnulib.m4
frexp
fpieee
frexpf #include <math.h> frexpf.c frexpf.m4
mathfunc.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_FREXPF
gl_CONDITIONAL([GL_COND_OBJ_FREXPF],
[test $HAVE_FREXPF = 0 || test $REPLACE_FREXPF = 1])
gl_MATH_MODULE_INDICATOR([frexpf])
math
extensions
frexp [test $HAVE_FREXPF = 0 || test $REPLACE_FREXPF = 1]
frexpf-ieee #include <math.h> --- 00gnulib.m4
zzgnulib.m4
frexpf
fpieee
frexpl-ieee #include <math.h> --- 00gnulib.m4
zzgnulib.m4
frexpl
fpieee
fstat #include <sys/stat.h> fstat.c
stat-w32.h
stat-w32.c
fstat.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_FSTAT
gl_CONDITIONAL([GL_COND_OBJ_FSTAT], [test $REPLACE_FSTAT = 1])
AM_COND_IF([GL_COND_OBJ_FSTAT], [
case "$host_os" in
mingw*)
AC_LIBOBJ([stat-w32])
;;
esac
gl_PREREQ_FSTAT
])
gl_SYS_STAT_MODULE_INDICATOR([fstat])
sys_stat
largefile
pathmax [test $REPLACE_FSTAT = 1]
stat [test $REPLACE_FSTAT = 1]
stat-time [test $REPLACE_FSTAT = 1]
unistd [test $REPLACE_FSTAT = 1]
assert-h [test $REPLACE_FSTAT = 1]
msvc-nothrow [test $REPLACE_FSTAT = 1]
fstatat #include <sys/stat.h> fstatat.c
at-func.c
fstatat.m4
lstat.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_FSTATAT
gl_CONDITIONAL([GL_COND_OBJ_FSTATAT],
[test $HAVE_FSTATAT = 0 || test $REPLACE_FSTATAT = 1])
gl_SYS_STAT_MODULE_INDICATOR([fstatat])
sys_stat
extensions
at-internal [test $HAVE_FSTATAT = 0 || test $REPLACE_FSTATAT = 1]
errno [test $HAVE_FSTATAT = 0 || test $REPLACE_FSTATAT = 1]
extern-inline [test $HAVE_FSTATAT = 0 || test $REPLACE_FSTATAT = 1]
fchdir [test $HAVE_FSTATAT = 0 || test $REPLACE_FSTATAT = 1]
fcntl-h [test $HAVE_FSTATAT = 0 || test $REPLACE_FSTATAT = 1]
filename [test $HAVE_FSTATAT = 0 || test $REPLACE_FSTATAT = 1]
lstat [test $HAVE_FSTATAT = 0 || test $REPLACE_FSTATAT = 1]
openat-die [test $HAVE_FSTATAT = 0 || test $REPLACE_FSTATAT = 1]
openat-h [test $HAVE_FSTATAT = 0 || test $REPLACE_FSTATAT = 1]
save-cwd [test $HAVE_FSTATAT = 0 || test $REPLACE_FSTATAT = 1]
stat [test $HAVE_FSTATAT = 0 || test $REPLACE_FSTATAT = 1]
stat-time [test $HAVE_FSTATAT = 0 || test $REPLACE_FSTATAT = 1]
gen-header --- --- 00gnulib.m4
zzgnulib.m4
---
gen-uni-tables --- gen-uni-tables.c
unictype/3level.h
unictype/3levelbit.h
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([AC_C_INLINE])
memcmp
stdbool
strdup
strstr-simple
get-rusage-as #include "resource-ext.h" get-rusage-as.c mmap-anon.m4
00gnulib.m4
zzgnulib.m4
AC_CHECK_FUNCS_ONCE([setrlimit])
gl_FUNC_MMAP_ANON
AC_CHECK_HEADERS_ONCE([sys/mman.h])
AC_CHECK_FUNCS_ONCE([mprotect])
stdint
unistd
extensions
getpagesize
open
vma-iter
get-rusage-data #include "resource-ext.h" get-rusage-data.c mmap-anon.m4
00gnulib.m4
zzgnulib.m4
AC_CHECK_FUNCS_ONCE([sbrk setrlimit])
gl_FUNC_MMAP_ANON
stdint
unistd
extensions
getpagesize
vma-iter
get_ppid_of #include "get_ppid_of.h" get_ppid_of.c 00gnulib.m4
zzgnulib.m4
extensions
sys_types
unistd
open
get_progname_of #include "get_progname_of.h" get_progname_of.c 00gnulib.m4
zzgnulib.m4
extensions
unistd
open
getrusage #include <sys/resource.h> getrusage.c getrusage.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_GETRUSAGE
gl_CONDITIONAL([GL_COND_OBJ_GETRUSAGE], [test $HAVE_GETRUSAGE = 0])
gl_SYS_RESOURCE_MODULE_INDICATOR([getrusage])
sys_resource
stdint [test $HAVE_GETRUSAGE = 0]
git-merge-changelog --- git-merge-changelog.c 00gnulib.m4
zzgnulib.m4
c99
getopt-gnu
stdbool
stdlib
error
read-file
xlist
array-list
linkedhash-list
linked-list
rbtreehash-list
xalloc
xmalloca
fstrcmp
minmax
c-strstr
fwriteerror
memchr
memcmp
getprogname
glibc-internal/dynarray #include "dynarray.h" malloc/dynarray-skeleton.c
malloc/dynarray.h
malloc/dynarray_at_failure.c
malloc/dynarray_emplace_enlarge.c
malloc/dynarray_finalize.c
malloc/dynarray_resize.c
malloc/dynarray_resize_clear.c
00gnulib.m4
zzgnulib.m4
AC_PROG_MKDIR_P
c99
builtin-expect
gen-header
libc-config
stdbool
stddef
intprops
glibc-internal/scratch_buffer #include <scratch_buffer.h> scratch_buffer.h
malloc/scratch_buffer.h
malloc/scratch_buffer_grow.c
malloc/scratch_buffer_grow_preserve.c
malloc/scratch_buffer_set_array_size.c
00gnulib.m4
zzgnulib.m4
AC_PROG_MKDIR_P
c99
builtin-expect
gen-header
libc-config
stdbool
stddef
malloc-posix
realloc-posix
free-posix
glob-h #include <glob.h> glob.in.h
glob-libc.h
glob_h.m4
00gnulib.m4
zzgnulib.m4
gl_GLOB_H
gl_GLOB_H_REQUIRE_DEFAULTS
gl_CONDITIONAL_HEADER([glob.h])
AC_PROG_MKDIR_P
extensions
gen-header
include_next
snippet/arg-nonnull
snippet/c++defs
snippet/warn-on-use
libc-config
lstat
sys_stat
hash-map #include "gl_hash_map.h" gl_hash_map.c
gl_anyhash1.h
gl_anyhash2.h
gl_anyhash_primes.h
00gnulib.m4
zzgnulib.m4
map
stdint
xsize
c99
hash-set #include "gl_hash_set.h" gl_hash_set.c
gl_anyhash1.h
gl_anyhash2.h
gl_anyhash_primes.h
00gnulib.m4
zzgnulib.m4
set
stdint
xsize
c99
hash-triple-simple #include "hash-triple.h" hash-triple-simple.c 00gnulib.m4
zzgnulib.m4
hash-pjw
same-inode
stdbool
host-cpu-c-abi --- --- host-cpu-c-abi.m4
asm-underscore.m4
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([gl_HOST_CPU_C_ABI])
---
hypot-ieee #include <math.h> --- hypot-ieee.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_HYPOT_IEEE
hypot
fpieee
hypotf #include <math.h> hypotf.c hypotf.m4
mathfunc.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_HYPOTF
gl_CONDITIONAL([GL_COND_OBJ_HYPOTF],
[test $HAVE_HYPOTF = 0 || test $REPLACE_HYPOTF = 1])
gl_MATH_MODULE_INDICATOR([hypotf])
math
extensions
hypot [test $HAVE_HYPOTF = 0 || test $REPLACE_HYPOTF = 1]
hypotf-ieee #include <math.h> --- hypotf-ieee.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_HYPOTF_IEEE
hypotf
fpieee
hypot-ieee [test $HAVE_HYPOTF = 0 || test $REPLACE_HYPOTF = 1]
hypotl #include <math.h> hypotl.c hypotl.m4
mathfunc.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_HYPOTL
gl_CONDITIONAL([GL_COND_OBJ_HYPOTL],
[test $HAVE_HYPOTL = 0 || test $REPLACE_HYPOTL = 1])
gl_MATH_MODULE_INDICATOR([hypotl])
math
extensions
hypot [{ test $HAVE_HYPOTL = 0 || test $REPLACE_HYPOTL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1]
isfinite [{ test $HAVE_HYPOTL = 0 || test $REPLACE_HYPOTL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
fabsl [{ test $HAVE_HYPOTL = 0 || test $REPLACE_HYPOTL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
frexpl [{ test $HAVE_HYPOTL = 0 || test $REPLACE_HYPOTL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
ldexpl [{ test $HAVE_HYPOTL = 0 || test $REPLACE_HYPOTL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
sqrtl [{ test $HAVE_HYPOTL = 0 || test $REPLACE_HYPOTL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
isinf [{ test $HAVE_HYPOTL = 0 || test $REPLACE_HYPOTL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
hypotl-ieee #include <math.h> --- hypotl-ieee.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_HYPOTL_IEEE
hypotl
fpieee
hypot-ieee [{ test $HAVE_HYPOTL = 0 || test $REPLACE_HYPOTL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1]
ilogb #include <math.h> ilogb.c ilogb.m4
mathfunc.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_ILOGB
gl_CONDITIONAL([GL_COND_OBJ_ILOGB],
[test $HAVE_ILOGB = 0 || test $REPLACE_ILOGB = 1])
gl_MATH_MODULE_INDICATOR([ilogb])
math
isfinite [test $HAVE_ILOGB = 0 || test $REPLACE_ILOGB = 1]
frexp [test $HAVE_ILOGB = 0 || test $REPLACE_ILOGB = 1]
isnand [test $HAVE_ILOGB = 0 || test $REPLACE_ILOGB = 1]
ilogbf #include <math.h> ilogbf.c
ilogb.c
ilogbf.m4
mathfunc.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_ILOGBF
gl_CONDITIONAL([GL_COND_OBJ_ILOGBF],
[test $HAVE_ILOGBF = 0 || test $REPLACE_ILOGBF = 1])
gl_MATH_MODULE_INDICATOR([ilogbf])
math
extensions
isfinite [test $HAVE_ILOGBF = 0 || test $REPLACE_ILOGBF = 1]
frexpf [test $HAVE_ILOGBF = 0 || test $REPLACE_ILOGBF = 1]
isnanf [test $HAVE_ILOGBF = 0 || test $REPLACE_ILOGBF = 1]
ilogbl #include <math.h> ilogbl.c
ilogb.c
ilogbl.m4
mathfunc.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_ILOGBL
gl_CONDITIONAL([GL_COND_OBJ_ILOGBL],
[test $HAVE_ILOGBL = 0 || test $REPLACE_ILOGBL = 1])
gl_MATH_MODULE_INDICATOR([ilogbl])
math
extensions
ilogb [{ test $HAVE_ILOGBL = 0 || test $REPLACE_ILOGBL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1]
isfinite [{ test $HAVE_ILOGBL = 0 || test $REPLACE_ILOGBL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
frexpl [{ test $HAVE_ILOGBL = 0 || test $REPLACE_ILOGBL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
isnanl [{ test $HAVE_ILOGBL = 0 || test $REPLACE_ILOGBL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
ino-map #include "ino-map.h" ino-map.c 00gnulib.m4
zzgnulib.m4
assert-h
hash
integer_length #include "integer_length.h" integer_length.c
float+.h
exponentd.m4
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([gl_DOUBLE_EXPONENT_LOCATION])
float
integer_length_l #include "integer_length.h" integer_length_l.c 00gnulib.m4
zzgnulib.m4
integer_length
integer_length_ll #include "integer_length.h" integer_length_ll.c
integer_length_l.c
00gnulib.m4
zzgnulib.m4
integer_length
inttypes-incomplete #include <inttypes.h> inttypes.in.h inttypes.m4
00gnulib.m4
zzgnulib.m4
gl_INTTYPES_INCOMPLETE
gl_INTTYPES_H_REQUIRE_DEFAULTS
AC_PROG_MKDIR_P
gen-header
include_next
multiarch
snippet/arg-nonnull
snippet/c++defs
snippet/warn-on-use
stdint
isatty #include <unistd.h> isatty.c isatty.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_ISATTY
gl_CONDITIONAL([GL_COND_OBJ_ISATTY], [test $REPLACE_ISATTY = 1])
AM_COND_IF([GL_COND_OBJ_ISATTY], [
gl_PREREQ_ISATTY
])
gl_UNISTD_MODULE_INDICATOR([isatty])
unistd
msvc-inval [test $REPLACE_ISATTY = 1]
msvc-nothrow [test $REPLACE_ISATTY = 1]
iswblank #include <wctype.h> iswblank.c iswblank.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_ISWBLANK
gl_CONDITIONAL([GL_COND_OBJ_ISWBLANK],
[! { test $HAVE_ISWCNTRL = 0 || test $REPLACE_ISWCNTRL = 1; } && { test $HAVE_ISWBLANK = 0 || test $REPLACE_ISWBLANK = 1; }])
gl_WCTYPE_MODULE_INDICATOR([iswblank])
wctype-h
extensions
iswctype #include <wctype.h> iswctype.c
iswctype-impl.h
iswctype.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_ISWCTYPE
gl_CONDITIONAL([GL_COND_OBJ_ISWCTYPE],
[test $HAVE_WCTYPE_T = 0 || test $GNULIBHEADERS_OVERRIDE_WINT_T = 1])
gl_WCTYPE_MODULE_INDICATOR([iswctype])
wctype-h
iswdigit #include <wctype.h> iswdigit.c iswdigit.m4
locale-fr.m4
locale-ja.m4
locale-zh.m4
codeset.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_ISWDIGIT
gl_CONDITIONAL([GL_COND_OBJ_ISWDIGIT],
[! { test $HAVE_ISWCNTRL = 0 || test $REPLACE_ISWCNTRL = 1; } && test $REPLACE_ISWDIGIT = 1])
gl_WCTYPE_MODULE_INDICATOR([iswdigit])
wctype-h
iswxdigit #include <wctype.h> iswxdigit.c iswxdigit.m4
locale-fr.m4
locale-ja.m4
locale-zh.m4
codeset.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_ISWXDIGIT
gl_CONDITIONAL([GL_COND_OBJ_ISWXDIGIT],
[! { test $HAVE_ISWCNTRL = 0 || test $REPLACE_ISWCNTRL = 1; } && test $REPLACE_ISWXDIGIT = 1])
gl_WCTYPE_MODULE_INDICATOR([iswxdigit])
wctype-h
ldexp-ieee #include <math.h> --- 00gnulib.m4
zzgnulib.m4
ldexp
fpieee
ldexpf #include <math.h> ldexpf.c ldexpf.m4
mathfunc.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_LDEXPF
gl_CONDITIONAL([GL_COND_OBJ_LDEXPF], [test $HAVE_LDEXPF = 0])
gl_MATH_MODULE_INDICATOR([ldexpf])
math
extensions
ldexp [test $HAVE_LDEXPF = 0]
ldexpf-ieee #include <math.h> --- 00gnulib.m4
zzgnulib.m4
ldexpf
fpieee
ldexpl-ieee #include <math.h> --- 00gnulib.m4
zzgnulib.m4
ldexpl
fpieee
libtextstyle #if HAVE_LIBTEXTSTYLE
# include <textstyle.h>
#endif
--- libtextstyle.m4
00gnulib.m4
zzgnulib.m4
# You need to invoke gl_LIBTEXTSTYLE yourself, possibly with arguments.
havelib
libtextstyle-optional #include <textstyle.h> textstyle.in.h libtextstyle-optional.m4
00gnulib.m4
zzgnulib.m4
# You need to invoke gl_LIBTEXTSTYLE_OPTIONAL yourself, possibly with arguments.
if test -z "$GL_GENERATE_TEXTSTYLE_H"; then
GL_GENERATE_TEXTSTYLE_H=false
fi
gl_CONDITIONAL_HEADER([textstyle.h])
AC_PROG_MKDIR_P
gen-header
libtextstyle
stdbool
stdio
unistd
fsync
vasprintf-posix
linkedhash-map #include "gl_linkedhash_map.h" gl_linkedhash_map.c
gl_anyhash1.h
gl_anyhash2.h
gl_anyhash_primes.h
00gnulib.m4
zzgnulib.m4
map
stdint
xsize
c99
linkedhash-set #include "gl_linkedhash_set.h" gl_linkedhash_set.c
gl_anyhash1.h
gl_anyhash2.h
gl_anyhash_primes.h
00gnulib.m4
zzgnulib.m4
set
stdint
xsize
c99
list-c++ #include "gl_list.hh" --- 00gnulib.m4
zzgnulib.m4
xlist
xsublist
localeconv #include <locale.h> localeconv.c localeconv.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_LOCALECONV
gl_CONDITIONAL([GL_COND_OBJ_LOCALECONV], [test $REPLACE_LOCALECONV = 1])
AM_COND_IF([GL_COND_OBJ_LOCALECONV], [
gl_PREREQ_LOCALECONV
])
gl_LOCALE_MODULE_INDICATOR([localeconv])
locale
log-ieee #include <math.h> --- log-ieee.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_LOG_IEEE
log
fpieee
log10-ieee #include <math.h> --- log10-ieee.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_LOG10_IEEE
log10
fpieee
log10f #include <math.h> log10f.c log10f.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_LOG10F
gl_CONDITIONAL([GL_COND_OBJ_LOG10F],
[test $HAVE_LOG10F = 0 || test $REPLACE_LOG10F = 1])
gl_MATH_MODULE_INDICATOR([log10f])
math
extensions
log10 [test $HAVE_LOG10F = 0 || test $REPLACE_LOG10F = 1]
log10f-ieee #include <math.h> --- log10f-ieee.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_LOG10F_IEEE
log10f
fpieee
log10-ieee [test $HAVE_LOG10F = 0 || test $REPLACE_LOG10F = 1]
log10l #include <math.h> log10l.c log10l.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_LOG10L
gl_CONDITIONAL([GL_COND_OBJ_LOG10L],
[test $HAVE_LOG10L = 0 || test $REPLACE_LOG10L = 1])
gl_MATH_MODULE_INDICATOR([log10l])
math
extensions
log10 [{ test $HAVE_LOG10L = 0 || test $REPLACE_LOG10L = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1]
float [{ test $HAVE_LOG10L = 0 || test $REPLACE_LOG10L = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
logl [{ test $HAVE_LOG10L = 0 || test $REPLACE_LOG10L = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
log10l-ieee #include <math.h> --- 00gnulib.m4
zzgnulib.m4
log10l
fpieee
log1p-ieee #include <math.h> --- log1p-ieee.m4
minus-zero.m4
signbit.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_LOG1P_IEEE
log1p
fpieee
log1pf #include <math.h> log1pf.c log1pf.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_LOG1PF
gl_CONDITIONAL([GL_COND_OBJ_LOG1PF],
[test $HAVE_LOG1PF = 0 || test $REPLACE_LOG1PF = 1])
gl_MATH_MODULE_INDICATOR([log1pf])
math
extensions
log1p [test $HAVE_LOG1PF = 0 || test $REPLACE_LOG1PF = 1]
log1pf-ieee #include <math.h> --- log1pf-ieee.m4
minus-zero.m4
signbit.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_LOG1PF_IEEE
log1pf
fpieee
log1p-ieee [test $HAVE_LOG1PF = 0 || test $REPLACE_LOG1PF = 1]
log1pl #include <math.h> log1pl.c log1pl.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_LOG1PL
gl_CONDITIONAL([GL_COND_OBJ_LOG1PL],
[test $HAVE_LOG1PL = 0 || test $REPLACE_LOG1PL = 1])
gl_MATH_MODULE_INDICATOR([log1pl])
math
extensions
log1p [{ test $HAVE_LOG1PL = 0 || test $REPLACE_LOG1PL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1]
isnanl [{ test $HAVE_LOG1PL = 0 || test $REPLACE_LOG1PL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
logl [{ test $HAVE_LOG1PL = 0 || test $REPLACE_LOG1PL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
roundl [{ test $HAVE_LOG1PL = 0 || test $REPLACE_LOG1PL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
log1pl-ieee #include <math.h> --- log1pl-ieee.m4
minus-zero.m4
signbit.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_LOG1PL_IEEE
log1pl
fpieee
log1p-ieee [{ test $HAVE_LOG1PL = 0 || test $REPLACE_LOG1PL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1]
log2 #include <math.h> log2.c log2.m4
mathfunc.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_LOG2
gl_CONDITIONAL([GL_COND_OBJ_LOG2],
[test $HAVE_LOG2 = 0 || test $REPLACE_LOG2 = 1])
gl_MATH_MODULE_INDICATOR([log2])
math
extensions
isnand [test $HAVE_LOG2 = 0 || test $REPLACE_LOG2 = 1]
frexp [test $HAVE_LOG2 = 0 || test $REPLACE_LOG2 = 1]
log [test $HAVE_LOG2 = 0 || test $REPLACE_LOG2 = 1]
log2-ieee #include <math.h> --- log2-ieee.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_LOG2_IEEE
log2
fpieee
log2f #include <math.h> log2f.c log2f.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_LOG2F
gl_CONDITIONAL([GL_COND_OBJ_LOG2F],
[test $HAVE_LOG2F = 0 || test $REPLACE_LOG2F = 1])
gl_MATH_MODULE_INDICATOR([log2f])
math
extensions
log2 [test $HAVE_LOG2F = 0 || test $REPLACE_LOG2F = 1]
isnanf [test $HAVE_LOG2F = 0 || test $REPLACE_LOG2F = 1]
frexpf [test $HAVE_LOG2F = 0 || test $REPLACE_LOG2F = 1]
logf [test $HAVE_LOG2F = 0 || test $REPLACE_LOG2F = 1]
log2f-ieee #include <math.h> --- log2f-ieee.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_LOG2F_IEEE
log2f
fpieee
log2-ieee [test $HAVE_LOG2F = 0 || test $REPLACE_LOG2F = 1]
log2l #include <math.h> log2l.c log2l.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_LOG2L
gl_CONDITIONAL([GL_COND_OBJ_LOG2L],
[test $HAVE_LOG2L = 0 || test $REPLACE_LOG2L = 1])
gl_MATH_MODULE_INDICATOR([log2l])
math
extensions
log2 [{ test $HAVE_LOG2L = 0 || test $REPLACE_LOG2L = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1]
isnanl [{ test $HAVE_LOG2L = 0 || test $REPLACE_LOG2L = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
frexpl [{ test $HAVE_LOG2L = 0 || test $REPLACE_LOG2L = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
logl [{ test $HAVE_LOG2L = 0 || test $REPLACE_LOG2L = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
log2l-ieee #include <math.h> --- 00gnulib.m4
zzgnulib.m4
log2l
fpieee
logb-ieee #include <math.h> --- 00gnulib.m4
zzgnulib.m4
logb
fpieee
logbf #include <math.h> logbf.c
logb.c
logbf.m4
mathfunc.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_LOGBF
gl_CONDITIONAL([GL_COND_OBJ_LOGBF],
[test $HAVE_LOGBF = 0 || test $REPLACE_LOGBF = 1])
gl_MATH_MODULE_INDICATOR([logbf])
math
extensions
isfinite [test $HAVE_LOGBF = 0 || test $REPLACE_LOGBF = 1]
frexpf [test $HAVE_LOGBF = 0 || test $REPLACE_LOGBF = 1]
isnanf [test $HAVE_LOGBF = 0 || test $REPLACE_LOGBF = 1]
logbf-ieee #include <math.h> --- 00gnulib.m4
zzgnulib.m4
logbf
fpieee
logbl #include <math.h> logbl.c
logb.c
logbl.m4
mathfunc.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_LOGBL
gl_CONDITIONAL([GL_COND_OBJ_LOGBL],
[test $HAVE_LOGBL = 0 || test $REPLACE_LOGBL = 1])
gl_MATH_MODULE_INDICATOR([logbl])
math
extensions
logb [{ test $HAVE_LOGBL = 0 || test $REPLACE_LOGBL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1]
isfinite [{ test $HAVE_LOGBL = 0 || test $REPLACE_LOGBL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
frexpl [{ test $HAVE_LOGBL = 0 || test $REPLACE_LOGBL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
isnanl [{ test $HAVE_LOGBL = 0 || test $REPLACE_LOGBL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
logbl-ieee #include <math.h> --- 00gnulib.m4
zzgnulib.m4
logbl
fpieee
logf #include <math.h> logf.c logf.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_LOGF
gl_CONDITIONAL([GL_COND_OBJ_LOGF],
[test $HAVE_LOGF = 0 || test $REPLACE_LOGF = 1])
gl_MATH_MODULE_INDICATOR([logf])
math
extensions
log [test $HAVE_LOGF = 0 || test $REPLACE_LOGF = 1]
logf-ieee #include <math.h> --- logf-ieee.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_LOGF_IEEE
logf
fpieee
log-ieee [test $HAVE_LOGF = 0 || test $REPLACE_LOGF = 1]
logl-ieee #include <math.h> --- 00gnulib.m4
zzgnulib.m4
logl
fpieee
map #include "gl_map.h" gl_map.c 00gnulib.m4
zzgnulib.m4
extern-inline
stdbool
map-c++ #include "gl_map.hh" --- 00gnulib.m4
zzgnulib.m4
xmap
mbrtoc32 #include <uchar.h> mbrtoc32.c
mbrtowc-impl.h
mbrtowc-impl-utf8.h
lc-charset-dispatch.h
lc-charset-dispatch.c
mbtowc-lock.h
mbtowc-lock.c
windows-initguard.h
mbrtoc32.m4
locale-fr.m4
locale-zh.m4
codeset.m4
mbrtowc.m4
mbstate_t.m4
threadlib.m4
visibility.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_MBRTOC32
gl_CONDITIONAL([GL_COND_OBJ_MBRTOC32],
[test $HAVE_MBRTOC32 = 0 || test $REPLACE_MBRTOC32 = 1])
AM_COND_IF([GL_COND_OBJ_MBRTOC32], [
if test $REPLACE_MBSTATE_T = 1; then
AC_LIBOBJ([lc-charset-dispatch])
AC_LIBOBJ([mbtowc-lock])
gl_PREREQ_MBTOWC_LOCK
fi
gl_PREREQ_MBRTOC32
])
gl_UCHAR_MODULE_INDICATOR([mbrtoc32])
uchar
attribute [test $HAVE_MBRTOC32 = 0 || test $REPLACE_MBRTOC32 = 1]
c99 [{ test $HAVE_MBRTOC32 = 0 || test $REPLACE_MBRTOC32 = 1; } && test $REPLACE_MBSTATE_T = 0]
hard-locale [{ test $HAVE_MBRTOC32 = 0 || test $REPLACE_MBRTOC32 = 1; } && test $REPLACE_MBSTATE_T = 0]
mbrtowc [{ test $HAVE_MBRTOC32 = 0 || test $REPLACE_MBRTOC32 = 1; } && test $REPLACE_MBSTATE_T = 0]
assert-h [test $HAVE_MBRTOC32 = 0 || test $REPLACE_MBRTOC32 = 1]
localcharset [test $HAVE_MBRTOC32 = 0 || test $REPLACE_MBRTOC32 = 1]
streq [test $HAVE_MBRTOC32 = 0 || test $REPLACE_MBRTOC32 = 1]
mbsnrtoc32s #include <uchar.h> mbsnrtoc32s.c
mbsnrtowcs-impl.h
mbsrtoc32s-state.c
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([gl_UCHAR_H])
AC_LIBOBJ([mbsrtoc32s-state])
gl_UCHAR_MODULE_INDICATOR([mbsnrtoc32s])
uchar
wchar
assert-h
mbrtoc32
minmax
strnlen1
mbsnrtowcs [test $SMALL_WCHAR_T = 0]
mbsrtoc32s #include <uchar.h> mbsrtoc32s.c
mbsrtowcs-impl.h
mbsrtoc32s-state.c
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([gl_UCHAR_H])
AC_LIBOBJ([mbsrtoc32s-state])
gl_UCHAR_MODULE_INDICATOR([mbsrtoc32s])
uchar
wchar
assert-h
mbrtoc32
strnlen1
mbsrtowcs [test $SMALL_WCHAR_T = 0]
mbstoc32s #include <uchar.h> mbstoc32s.c 00gnulib.m4
zzgnulib.m4
gl_UCHAR_MODULE_INDICATOR([mbstoc32s])
uchar
wchar
mbsrtoc32s
mbstowcs #include <stdlib.h> mbstowcs.c mbstowcs.m4
mbrtowc.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_MBSTOWCS
gl_CONDITIONAL([GL_COND_OBJ_MBSTOWCS], [test $REPLACE_MBSTOWCS = 1])
AM_COND_IF([GL_COND_OBJ_MBSTOWCS], [
gl_PREREQ_MBSTOWCS
])
gl_STDLIB_MODULE_INDICATOR([mbstowcs])
stdlib
mbsrtowcs [test $REPLACE_MBSTOWCS = 1]
mbtowc #include <stdlib.h> mbtowc.c
mbtowc-impl.h
mbtowc.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_MBTOWC
gl_CONDITIONAL([GL_COND_OBJ_MBTOWC],
[test $HAVE_MBTOWC = 0 || test $REPLACE_MBTOWC = 1])
AM_COND_IF([GL_COND_OBJ_MBTOWC], [
gl_PREREQ_MBTOWC
])
gl_STDLIB_MODULE_INDICATOR([mbtowc])
stdlib
mbrtowc [test $HAVE_MBTOWC = 0 || test $REPLACE_MBTOWC = 1]
wchar [test $HAVE_MBTOWC = 0 || test $REPLACE_MBTOWC = 1]
mkdirat #include <sys/stat.h> mkdirat.c
at-func.c
mkdirat.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_MKDIRAT
gl_CONDITIONAL([GL_COND_OBJ_MKDIRAT], [test $HAVE_MKDIRAT = 0])
AM_COND_IF([GL_COND_OBJ_MKDIRAT], [
gl_PREREQ_MKDIRAT
])
gl_SYS_STAT_MODULE_INDICATOR([mkdirat])
sys_stat
extensions
at-internal [test $HAVE_MKDIRAT = 0]
errno [test $HAVE_MKDIRAT = 0]
fchdir [test $HAVE_MKDIRAT = 0]
fcntl-h [test $HAVE_MKDIRAT = 0]
filename [test $HAVE_MKDIRAT = 0]
mkdir [test $HAVE_MKDIRAT = 0]
openat-die [test $HAVE_MKDIRAT = 0]
openat-h [test $HAVE_MKDIRAT = 0]
save-cwd [test $HAVE_MKDIRAT = 0]
unistd [test $HAVE_MKDIRAT = 0]
modf-ieee #include <math.h> --- modf-ieee.m4
minus-zero.m4
signbit.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_MODF_IEEE
modf
fpieee
modff #include <math.h> modff.c modff.m4
mathfunc.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_MODFF
gl_CONDITIONAL([GL_COND_OBJ_MODFF],
[test $HAVE_MODFF = 0 || test $REPLACE_MODFF = 1])
gl_MATH_MODULE_INDICATOR([modff])
math
extensions
modf [test $HAVE_MODFF = 0 || test $REPLACE_MODFF = 1]
modff-ieee #include <math.h> --- modff-ieee.m4
minus-zero.m4
signbit.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_MODFF_IEEE
modff
fpieee
modf-ieee [test $HAVE_MODFF = 0]
modfl #include <math.h> modfl.c modfl.m4
mathfunc.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_MODFL
gl_CONDITIONAL([GL_COND_OBJ_MODFL],
[test $HAVE_MODFL = 0 || test $REPLACE_MODFL = 1])
gl_MATH_MODULE_INDICATOR([modfl])
math
extensions
modf [{ test $HAVE_MODFL = 0 || test $REPLACE_MODFL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1]
isfinite [{ test $HAVE_MODFL = 0 || test $REPLACE_MODFL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
truncl [{ test $HAVE_MODFL = 0 || test $REPLACE_MODFL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
isinf [{ test $HAVE_MODFL = 0 || test $REPLACE_MODFL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
modfl-ieee #include <math.h> --- modfl-ieee.m4
minus-zero.m4
signbit.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_MODFL_IEEE
modfl
fpieee
modf-ieee [test $HAVE_MODFL = 0 && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1]
monetary #if HAVE_MONETARY_H
#include <monetary.h>
#endif
monetary.in.h monetary_h.m4
00gnulib.m4
zzgnulib.m4
gl_MONETARY_H
gl_MONETARY_H_REQUIRE_DEFAULTS
gl_CONDITIONAL_HEADER([monetary.h])
AC_PROG_MKDIR_P
gen-header
include_next
snippet/arg-nonnull
snippet/c++defs
snippet/warn-on-use
msvc-inval #if HAVE_MSVC_INVALID_PARAMETER_HANDLER
# include "msvc-inval.h"
#endif
msvc-inval.h
msvc-inval.c
msvc-inval.m4
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([gl_MSVC_INVAL])
gl_CONDITIONAL([GL_COND_OBJ_MSVC_INVAL],
[test $HAVE_MSVC_INVALID_PARAMETER_HANDLER = 1])
---
msvc-nothrow #if GNULIB_MSVC_NOTHROW
# include "msvc-nothrow.h"
#else
# include <io.h>
#endif
msvc-nothrow.h
msvc-nothrow.c
msvc-nothrow.m4
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([gl_MSVC_NOTHROW])
gl_CONDITIONAL([GL_COND_OBJ_MSVC_NOTHROW],
[test $HAVE_MSVC_INVALID_PARAMETER_HANDLER = 1])
gl_MODULE_INDICATOR([msvc-nothrow])
msvc-inval
mtx #include <threads.h> mtx.c 00gnulib.m4
zzgnulib.m4
AC_REQUIRE([gl_THREADS_H])
gl_CONDITIONAL([GL_COND_OBJ_MTX], [test $HAVE_THREADS_H = 0])
gl_THREADS_MODULE_INDICATOR([mtx])
threads-h
pthread_mutex_timedlock
windows-mutex
windows-recmutex
windows-timedmutex
windows-timedrecmutex
multiarch --- --- multiarch.m4
00gnulib.m4
zzgnulib.m4
gl_MULTIARCH
---
nonblocking #include "nonblocking.h" nonblocking.c
stdio-read.c
stdio-write.c
nonblocking.m4
asm-underscore.m4
00gnulib.m4
zzgnulib.m4
gl_NONBLOCKING_IO
gl_FCNTL_MODULE_INDICATOR([nonblocking])
dnl Define the C macro GNULIB_NONBLOCKING to 1.
gl_MODULE_INDICATOR([nonblocking])
dnl Define the substituted variable GNULIB_STDIO_H_NONBLOCKING to 1.
gl_STDIO_H_REQUIRE_DEFAULTS
AC_REQUIRE([gl_ASM_SYMBOL_PREFIX])
gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_STDIO_H_NONBLOCKING], [1])
dnl Define the substituted variable GNULIB_UNISTD_H_NONBLOCKING to 1.
gl_UNISTD_H_REQUIRE_DEFAULTS
gl_MODULE_INDICATOR_INIT_VARIABLE([GNULIB_UNISTD_H_NONBLOCKING], [1])
fcntl-h
ioctl
msvc-nothrow
stdbool
stdio
sys_socket
unistd
obstack-printf-gnu #include <stdio.h> --- obstack-printf-gnu.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_OBSTACK_PRINTF_GNU
if test $ac_cv_func_obstack_printf = no || test $REPLACE_OBSTACK_PRINTF = 1; then
AC_LIBOBJ([obstack_printf])
fi
obstack-printf-posix
omap #include "gl_omap.h" gl_omap.c 00gnulib.m4
zzgnulib.m4
extern-inline
stdbool
omap-c++ #include "gl_omap.hh" --- 00gnulib.m4
zzgnulib.m4
xomap
openat-h #include "openat.h" --- 00gnulib.m4
zzgnulib.m4
extern-inline
fcntl-h
stdbool
sys_stat
unistd
opendir #include <dirent.h> opendir.c
dirent-private.h
opendir.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_OPENDIR
gl_CONDITIONAL([GL_COND_OBJ_OPENDIR],
[test $HAVE_OPENDIR = 0 || test $REPLACE_OPENDIR = 1])
gl_DIRENT_MODULE_INDICATOR([opendir])
dirent
largefile
filename [test $HAVE_OPENDIR = 0 || test $REPLACE_OPENDIR = 1]
unistd [test $HAVE_OPENDIR = 0 || test $REPLACE_OPENDIR = 1]
closedir [test $HAVE_OPENDIR = 0 || test $REPLACE_OPENDIR = 1]
dirfd [test $HAVE_OPENDIR = 0 || test $REPLACE_OPENDIR = 1]
opendirat #include "opendirat.h" opendirat.c 00gnulib.m4
zzgnulib.m4
c99
dirent
fcntl-h
fdopendir
openat-safer
openmp-init #ifdef _OPENMP
# include <omp.h>
#endif
omp.in.h
omp-init.c
omp_h.m4
00gnulib.m4
zzgnulib.m4
gl_OMP_H
AC_PROG_MKDIR_P
gen-header
include_next
c-ctype
setenv
oset-c++ #include "gl_oset.hh" --- 00gnulib.m4
zzgnulib.m4
xoset
passfd #include "passfd.h" passfd.c passfd.m4
00gnulib.m4
zzgnulib.m4
gl_PASSFD
cloexec
sys_socket
socketlib
pclose #include <stdio.h> pclose.c pclose.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_PCLOSE
gl_CONDITIONAL([GL_COND_OBJ_PCLOSE], [test $HAVE_PCLOSE = 0])
AM_COND_IF([GL_COND_OBJ_PCLOSE], [
gl_PREREQ_PCLOSE
])
gl_STDIO_MODULE_INDICATOR([pclose])
stdio
poll-h #include <poll.h> poll.in.h poll_h.m4
sys_socket_h.m4
00gnulib.m4
zzgnulib.m4
gl_POLL_H
gl_POLL_H_REQUIRE_DEFAULTS
AC_PROG_MKDIR_P
extensions
gen-header
include_next
snippet/c++defs
snippet/warn-on-use
posix_spawn_file_actions_addchdir #include <spawn.h> spawn_faction_addchdir.c
spawn_int.h
posix_spawn_faction_addchdir.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_POSIX_SPAWN_FILE_ACTIONS_ADDCHDIR
gl_CONDITIONAL([GL_COND_OBJ_SPAWN_FACTION_ADDCHDIR],
[test $HAVE_POSIX_SPAWN = 0 || test $REPLACE_POSIX_SPAWN = 1 || test $HAVE_POSIX_SPAWN_FILE_ACTIONS_ADDCHDIR = 0 || test $REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDCHDIR = 1])
gl_SPAWN_MODULE_INDICATOR([posix_spawn_file_actions_addchdir])
spawn
posix_spawn_file_actions_init [test $HAVE_POSIX_SPAWN = 0 || test $REPLACE_POSIX_SPAWN = 1 || test $HAVE_POSIX_SPAWN_FILE_ACTIONS_ADDCHDIR = 0 || test $REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDCHDIR = 1]
posix_spawn_file_actions_addfchdir #include <spawn.h> spawn_faction_addfchdir.c
spawn_int.h
posix_spawn_faction_addfchdir.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_POSIX_SPAWN_FILE_ACTIONS_ADDFCHDIR
gl_CONDITIONAL([GL_COND_OBJ_SPAWN_FACTION_ADDFCHDIR],
[test $HAVE_POSIX_SPAWN = 0 || test $REPLACE_POSIX_SPAWN = 1 || test $HAVE_POSIX_SPAWN_FILE_ACTIONS_ADDFCHDIR = 0 || test $REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDFCHDIR = 1])
gl_SPAWN_MODULE_INDICATOR([posix_spawn_file_actions_addfchdir])
spawn
posix_spawn_file_actions_init [test $HAVE_POSIX_SPAWN = 0 || test $REPLACE_POSIX_SPAWN = 1 || test $HAVE_POSIX_SPAWN_FILE_ACTIONS_ADDFCHDIR = 0 || test $REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDFCHDIR = 1]
posixcheck --- --- posixcheck.m4
00gnulib.m4
zzgnulib.m4
gl_POSIXCHECK
arpa_inet
ctype
dirent
fcntl-h
fnmatch-h
glob-h
iconv-h
inttypes-incomplete
langinfo
locale
math
monetary
netdb
poll-h
pty
search
signal-h
spawn
stdio
stdlib
string
strings
sys_file
sys_ioctl
sys_resource
sys_select
sys_socket
sys_stat
sys_time
sys_times
sys_utsname
sys_wait
termios
time-h
unistd
utime-h
wchar
wctype-h
powf #include <math.h> powf.c powf.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_POWF
gl_CONDITIONAL([GL_COND_OBJ_POWF], [test $HAVE_POWF = 0])
gl_MATH_MODULE_INDICATOR([powf])
math
extensions
pow [test $HAVE_POWF = 0]
printf-gnu #include <stdio.h> --- printf-gnu.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_PRINTF_GNU
printf-posix
pt_chown --- pt_chown.c
pty-private.h
00gnulib.m4
zzgnulib.m4
ptsname
root-uid
stdlib
configmake
stat
pthread-cond #include <pthread.h> pthread-cond.c pthread-cond.m4
00gnulib.m4
zzgnulib.m4
gl_PTHREAD_COND
gl_CONDITIONAL([GL_COND_OBJ_PTHREAD_COND],
[test $HAVE_PTHREAD_COND_INIT = 0 || test $REPLACE_PTHREAD_COND_INIT = 1])
gl_PTHREAD_MODULE_INDICATOR([pthread-cond])
pthread-h
windows-cond [test $gl_threads_api = windows]
pthread-mutex [test $gl_threads_api = windows]
pthread-h #include <pthread.h> pthread.in.h pthread_h.m4
threadlib.m4
00gnulib.m4
zzgnulib.m4
gl_PTHREAD_H
gl_PTHREAD_H_REQUIRE_DEFAULTS
AC_PROG_MKDIR_P
extensions
extern-inline
gen-header
sched
time-h
snippet/c++defs
snippet/_Noreturn
snippet/arg-nonnull
snippet/warn-on-use
pthread-mutex #include <pthread.h> pthread-mutex.c pthread-mutex.m4
00gnulib.m4
zzgnulib.m4
gl_PTHREAD_MUTEX
gl_CONDITIONAL([GL_COND_OBJ_PTHREAD_MUTEX],
[test $HAVE_PTHREAD_MUTEX_INIT = 0 || test $REPLACE_PTHREAD_MUTEX_INIT = 1 || test $HAVE_PTHREAD_MUTEXATTR_GETROBUST = 0 || test $REPLACE_PTHREAD_MUTEXATTR_GETROBUST = 1])
gl_PTHREAD_MODULE_INDICATOR([pthread-mutex])
pthread-h
pthread_mutex_timedlock [test $gl_threads_api != windows]
windows-timedmutex [test $gl_threads_api = windows]
windows-timedrecmutex [test $gl_threads_api = windows]
pthread-once #include <pthread.h> pthread-once.c pthread-once.m4
00gnulib.m4
zzgnulib.m4
gl_PTHREAD_ONCE
gl_CONDITIONAL([GL_COND_OBJ_PTHREAD_ONCE],
[test $HAVE_PTHREAD_ONCE = 0 || test $REPLACE_PTHREAD_ONCE = 1])
gl_PTHREAD_MODULE_INDICATOR([pthread-once])
pthread-h
windows-once [test $gl_threads_api = windows]
pthread-rwlock #include <pthread.h> pthread-rwlock.c pthread-rwlock.m4
00gnulib.m4
zzgnulib.m4
gl_PTHREAD_RWLOCK
gl_CONDITIONAL([GL_COND_OBJ_PTHREAD_RWLOCK],
[test $HAVE_PTHREAD_RWLOCK_TIMEDRDLOCK = 0 || test $REPLACE_PTHREAD_RWLOCK_TIMEDRDLOCK = 1])
gl_PTHREAD_MODULE_INDICATOR([pthread-rwlock])
pthread-h
pthread-cond [test $gl_threads_api != windows && test $REPLACE_PTHREAD_RWLOCK_INIT = 1]
nanosleep [test $gl_threads_api != windows && test $HAVE_PTHREAD_RWLOCK_INIT = 1 && test $HAVE_PTHREAD_RWLOCK_TIMEDRDLOCK = 0]
windows-timedrwlock [test $gl_threads_api = windows]
pthread-spin #include <pthread.h> pthread-spin.c pthread-spin.m4
00gnulib.m4
zzgnulib.m4
gl_PTHREAD_SPIN
gl_CONDITIONAL([GL_COND_OBJ_PTHREAD_SPIN],
[test $HAVE_PTHREAD_SPIN_INIT = 0 || test $REPLACE_PTHREAD_SPIN_INIT = 1])
gl_PTHREAD_MODULE_INDICATOR([pthread-spin])
pthread-h
stdbool [test $HAVE_PTHREAD_SPIN_INIT = 0 || test $REPLACE_PTHREAD_SPIN_INIT = 1]
windows-spin [test $gl_threads_api = windows]
pthread-thread #include <pthread.h> pthread-thread.c pthread-thread.m4
00gnulib.m4
zzgnulib.m4
gl_PTHREAD_THREAD
gl_CONDITIONAL([GL_COND_OBJ_PTHREAD_THREAD],
[test $HAVE_PTHREAD_CREATE = 0 || test $REPLACE_PTHREAD_CREATE = 1])
gl_PTHREAD_MODULE_INDICATOR([pthread-thread])
pthread-h
windows-thread [test $gl_threads_api = windows]
pthread-tss #include <pthread.h> pthread-tss.c pthread-tss.m4
00gnulib.m4
zzgnulib.m4
gl_PTHREAD_TSS
gl_CONDITIONAL([GL_COND_OBJ_PTHREAD_TSS],
[test $HAVE_PTHREAD_KEY_CREATE = 0 || test $REPLACE_PTHREAD_KEY_CREATE = 1])
gl_PTHREAD_MODULE_INDICATOR([pthread-tss])
pthread-h
windows-tls [test $gl_threads_api = windows]
pthread_mutex_timedlock #include <pthread.h> pthread_mutex_timedlock.c pthread_mutex_timedlock.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_PTHREAD_MUTEX_TIMEDLOCK
gl_CONDITIONAL([GL_COND_OBJ_PTHREAD_MUTEX_TIMEDLOCK],
[test $HAVE_PTHREAD_T = 1 && test $HAVE_PTHREAD_MUTEX_TIMEDLOCK = 0])
gl_PTHREAD_MODULE_INDICATOR([pthread_mutex_timedlock])
pthread-h
nanosleep [test $HAVE_PTHREAD_T = 1 && test $HAVE_PTHREAD_MUTEX_TIMEDLOCK = 0]
quotearg-simple --- --- 00gnulib.m4
zzgnulib.m4
quotearg
random #include <stdlib.h> random.c random.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_RANDOM
gl_CONDITIONAL([GL_COND_OBJ_RANDOM],
[test $HAVE_RANDOM = 0 || test $REPLACE_RANDOM = 1 || test $REPLACE_INITSTATE = 1 || test $REPLACE_SETSTATE = 1])
AM_COND_IF([GL_COND_OBJ_RANDOM], [
gl_PREREQ_RANDOM
])
gl_STDLIB_MODULE_INDICATOR([random])
libc-config [test $HAVE_RANDOM = 0 || test $REPLACE_RANDOM = 1 || test $REPLACE_INITSTATE = 1 || test $REPLACE_SETSTATE = 1]
stdlib
stdint [test $HAVE_RANDOM = 0 || test $REPLACE_RANDOM = 1 || test $REPLACE_INITSTATE = 1 || test $REPLACE_SETSTATE = 1]
random_r [test $HAVE_RANDOM = 0 || test $REPLACE_RANDOM = 1 || test $REPLACE_INITSTATE = 1 || test $REPLACE_SETSTATE = 1]
rbtree-omap #include "gl_rbtree_omap.h" gl_rbtree_omap.c
gl_rbtree_ordered.h
gl_anytree_omap.h
00gnulib.m4
zzgnulib.m4
omap
read #include <unistd.h> read.c read.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_READ
gl_CONDITIONAL([GL_COND_OBJ_READ], [test $REPLACE_READ = 1])
AM_COND_IF([GL_COND_OBJ_READ], [
gl_PREREQ_READ
])
gl_UNISTD_MODULE_INDICATOR([read])
unistd
msvc-inval [test $REPLACE_READ = 1]
msvc-nothrow [test $REPLACE_READ = 1]
readdir #include <dirent.h> readdir.c
dirent-private.h
readdir.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_READDIR
gl_CONDITIONAL([GL_COND_OBJ_READDIR], [test $HAVE_READDIR = 0])
gl_DIRENT_MODULE_INDICATOR([readdir])
dirent
largefile
regex-quote #include "regex-quote.h" regex-quote.c 00gnulib.m4
zzgnulib.m4
AC_REQUIRE([AC_C_RESTRICT])
stdbool
xalloc
mbuiter
relocatable-perl --- --- relocatable-lib.m4
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([gl_RELOCATABLE_NOP])
relocatable_pl=$ac_aux_dir/relocatable.pl.in
AC_SUBST_FILE([relocatable_pl])
---
remainder-ieee #include <math.h> --- remainder-ieee.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_REMAINDER_IEEE
remainder
fpieee
remainderf #include <math.h> remainderf.c
remainder.c
remainderf.m4
mathfunc.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_REMAINDERF
gl_CONDITIONAL([GL_COND_OBJ_REMAINDERF],
[test $HAVE_REMAINDERF = 0 || test $REPLACE_REMAINDERF = 1])
gl_MATH_MODULE_INDICATOR([remainderf])
math
extensions
remainder [test $HAVE_REMAINDERF = 0 || test $REPLACE_REMAINDERF = 1]
isfinite [test $HAVE_REMAINDERF = 0 || test $REPLACE_REMAINDERF = 1]
signbit [test $HAVE_REMAINDERF = 0 || test $REPLACE_REMAINDERF = 1]
fabsf [test $HAVE_REMAINDERF = 0 || test $REPLACE_REMAINDERF = 1]
fmodf [test $HAVE_REMAINDERF = 0 || test $REPLACE_REMAINDERF = 1]
isnanf [test $HAVE_REMAINDERF = 0 || test $REPLACE_REMAINDERF = 1]
isinf [test $HAVE_REMAINDERF = 0 || test $REPLACE_REMAINDERF = 1]
remainderf-ieee #include <math.h> --- remainderf-ieee.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_REMAINDERF_IEEE
remainderf
fpieee
remainder-ieee [test $HAVE_REMAINDERF = 0 || test $REPLACE_REMAINDERF = 1]
remainderl #include <math.h> remainderl.c
remainder.c
remainderl.m4
mathfunc.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_REMAINDERL
gl_CONDITIONAL([GL_COND_OBJ_REMAINDERL],
[test $HAVE_REMAINDERL = 0 || test $REPLACE_REMAINDERL = 1])
gl_MATH_MODULE_INDICATOR([remainderl])
math
extensions
remainder [{ test $HAVE_REMAINDERL = 0 || test $REPLACE_REMAINDERL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1]
float [{ test $HAVE_REMAINDERL = 0 || test $REPLACE_REMAINDERL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
isfinite [{ test $HAVE_REMAINDERL = 0 || test $REPLACE_REMAINDERL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
signbit [{ test $HAVE_REMAINDERL = 0 || test $REPLACE_REMAINDERL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
fabsl [{ test $HAVE_REMAINDERL = 0 || test $REPLACE_REMAINDERL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
fmodl [{ test $HAVE_REMAINDERL = 0 || test $REPLACE_REMAINDERL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
isnanl [{ test $HAVE_REMAINDERL = 0 || test $REPLACE_REMAINDERL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
isinf [{ test $HAVE_REMAINDERL = 0 || test $REPLACE_REMAINDERL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 0]
remainderl-ieee #include <math.h> --- remainderl-ieee.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_REMAINDERL_IEEE
remainderl
fpieee
remainder-ieee [{ test $HAVE_REMAINDERL = 0 || test $REPLACE_REMAINDERL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1]
rewinddir #include <dirent.h> rewinddir.c
dirent-private.h
rewinddir.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_REWINDDIR
gl_CONDITIONAL([GL_COND_OBJ_REWINDDIR], [test $HAVE_REWINDDIR = 0])
gl_DIRENT_MODULE_INDICATOR([rewinddir])
dirent
largefile
rint-ieee #include <math.h> --- 00gnulib.m4
zzgnulib.m4
rint
fpieee
rintf #include <math.h> rintf.c
rint.c
rintf.m4
mathfunc.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_RINTF
gl_CONDITIONAL([GL_COND_OBJ_RINTF], [test $HAVE_RINTF = 0])
gl_MATH_MODULE_INDICATOR([rintf])
math
extensions
rintf-ieee #include <math.h> --- 00gnulib.m4
zzgnulib.m4
rintf
fpieee
rintl #include <math.h> rintl.c
rint.c
rintl.m4
mathfunc.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_RINTL
gl_CONDITIONAL([GL_COND_OBJ_RINTL],
[test $HAVE_RINTL = 0 || test $REPLACE_RINTL = 1])
gl_MATH_MODULE_INDICATOR([rintl])
math
extensions
rint [{ test $HAVE_RINTL = 0 || test $REPLACE_RINTL = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1]
rintl-ieee #include <math.h> --- 00gnulib.m4
zzgnulib.m4
rintl
fpieee
root-uid #include "root-uid.h" --- 00gnulib.m4
zzgnulib.m4
---
round-ieee #include <math.h> --- round-ieee.m4
minus-zero.m4
signbit.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_ROUND_IEEE
round
floor-ieee [test $HAVE_ROUND = 0 || test $REPLACE_ROUND = 1]
ceil-ieee [test $HAVE_ROUND = 0 || test $REPLACE_ROUND = 1]
roundf-ieee #include <math.h> --- roundf-ieee.m4
minus-zero.m4
signbit.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_ROUNDF_IEEE
roundf
floorf-ieee [test $HAVE_ROUNDF = 0 || test $REPLACE_ROUNDF = 1]
ceilf-ieee [test $HAVE_ROUNDF = 0 || test $REPLACE_ROUNDF = 1]
roundl-ieee #include <math.h> --- roundl-ieee.m4
minus-zero.m4
signbit.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_ROUNDL_IEEE
roundl
floorl-ieee
ceill-ieee
sched_yield #include <sched.h> sched_yield.c sched_yield.m4
threadlib.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_SCHED_YIELD
gl_CONDITIONAL([GL_COND_OBJ_SCHED_YIELD],
[test $HAVE_SCHED_YIELD = 0 || test $REPLACE_SCHED_YIELD = 1])
gl_SCHED_MODULE_INDICATOR([sched_yield])
sched
set #include "gl_set.h" gl_set.c 00gnulib.m4
zzgnulib.m4
extern-inline
stdbool
set-c++ #include "gl_set.hh" --- 00gnulib.m4
zzgnulib.m4
xset
sethostname #include <unistd.h> sethostname.c sethostname.m4
gethostname.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_SETHOSTNAME
gl_CONDITIONAL([GL_COND_OBJ_SETHOSTNAME],
[test $HAVE_SETHOSTNAME = 0 || test $REPLACE_SETHOSTNAME = 1])
gl_UNISTD_MODULE_INDICATOR([sethostname])
unistd
errno [test $HAVE_SETHOSTNAME = 0 || test $REPLACE_SETHOSTNAME = 1]
fopen-gnu [test $HAVE_SETHOSTNAME = 0 || test $REPLACE_SETHOSTNAME = 1]
setlocale #include <locale.h> setlocale.c setlocale.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_SETLOCALE
gl_CONDITIONAL([GL_COND_OBJ_SETLOCALE], [test $REPLACE_SETLOCALE = 1])
AM_COND_IF([GL_COND_OBJ_SETLOCALE], [
gl_PREREQ_SETLOCALE
])
gl_LOCALE_MODULE_INDICATOR([setlocale])
locale
localename [test $NEED_SETLOCALE_IMPROVED = 1]
setlocale-null [test $NEED_SETLOCALE_MTSAFE = 1]
setlocale-null #include "setlocale_null.h" or #include <locale.h> setlocale_null.h
setlocale_null.c
setlocale-lock.c
windows-initguard.h
setlocale_null.m4
threadlib.m4
visibility.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_SETLOCALE_NULL
gl_CONDITIONAL([GL_COND_OBJ_SETLOCALE_LOCK],
[test $SETLOCALE_NULL_ALL_MTSAFE = 0 || test $SETLOCALE_NULL_ONE_MTSAFE = 0])
AM_COND_IF([GL_COND_OBJ_SETLOCALE_LOCK], [
gl_PREREQ_SETLOCALE_LOCK
])
gl_LOCALE_MODULE_INDICATOR([setlocale_null])
locale
snippet/arg-nonnull
sh-filename --- --- sh-filename.m4
00gnulib.m4
zzgnulib.m4
gl_SH_FILENAME
---
signal --- --- 00gnulib.m4
zzgnulib.m4
signal-h
sinf #include <math.h> sinf.c sinf.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_SINF
gl_CONDITIONAL([GL_COND_OBJ_SINF], [test $HAVE_SINF = 0])
gl_MATH_MODULE_INDICATOR([sinf])
math
extensions
sin [test $HAVE_SINF = 0]
sinhf #include <math.h> sinhf.c sinhf.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_SINHF
gl_CONDITIONAL([GL_COND_OBJ_SINHF], [test $HAVE_SINHF = 0])
gl_MATH_MODULE_INDICATOR([sinhf])
math
extensions
sinh [test $HAVE_SINHF = 0]
snippet/_Noreturn --- _Noreturn.h 00gnulib.m4
zzgnulib.m4
---
snippet/c++defs --- c++defs.h 00gnulib.m4
zzgnulib.m4
---
snprintf-gnu #include <stdio.h> --- snprintf-gnu.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_SNPRINTF_GNU
snprintf-posix
socketlib --- --- socketlib.m4
sys_socket_h.m4
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([gl_SOCKETLIB])
---
sparcv8+ --- --- sparcv8+.m4
00gnulib.m4
zzgnulib.m4
---
sprintf-gnu #include <stdio.h> --- sprintf-gnu.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_SPRINTF_GNU
sprintf-posix
sqrt-ieee #include <math.h> --- 00gnulib.m4
zzgnulib.m4
sqrt
fpieee
sqrtf #include <math.h> sqrtf.c sqrtf.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_SQRTF
gl_CONDITIONAL([GL_COND_OBJ_SQRTF], [test $HAVE_SQRTF = 0])
gl_MATH_MODULE_INDICATOR([sqrtf])
math
extensions
sqrt [test $HAVE_SQRTF = 0]
sqrtf-ieee #include <math.h> --- 00gnulib.m4
zzgnulib.m4
sqrtf
fpieee
sqrtl-ieee #include <math.h> --- 00gnulib.m4
zzgnulib.m4
sqrtl
fpieee
stat-size #include "stat-size.h" --- stat-size.m4
00gnulib.m4
zzgnulib.m4
gl_STAT_SIZE
fileblocks
sys_stat
statat #include "openat.h" statat.c 00gnulib.m4
zzgnulib.m4
gl_MODULE_INDICATOR([statat]) dnl for lib/openat.h
fstatat
stdbool-c99 #include <stdbool.h> stdbool.in.h stdbool.m4
00gnulib.m4
zzgnulib.m4
gl_STDBOOL_H
gl_CONDITIONAL_HEADER([stdbool.h])
AC_PROG_MKDIR_P
gen-header
stdnoreturn #include <stdnoreturn.h> stdnoreturn.in.h stdnoreturn.m4
00gnulib.m4
zzgnulib.m4
gl_STDNORETURN_H
gl_CONDITIONAL_HEADER([stdnoreturn.h])
AC_PROG_MKDIR_P
gen-header
snippet/_Noreturn
stdopen #include "stdopen.h" stdopen.c 00gnulib.m4
zzgnulib.m4
fcntl
unistd
strfmon_l #if HAVE_MONETARY_H
#include <monetary.h>
#endif
strfmon_l.c strfmon_l.m4
locale-fr.m4
codeset.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_STRFMON_L
gl_CONDITIONAL([GL_COND_OBJ_STRFMON_L], [test $REPLACE_STRFMON_L = 1])
AM_COND_IF([GL_COND_OBJ_STRFMON_L], [
gl_PREREQ_STRFMON_L
])
gl_MONETARY_MODULE_INDICATOR([strfmon_l])
monetary
extensions
stdbool [test $REPLACE_STRFMON_L = 1]
strftime #include "strftime.h" --- 00gnulib.m4
zzgnulib.m4
nstrftime
string-desc #include "string-desc.h" string-desc.c
string-desc-contains.c
00gnulib.m4
zzgnulib.m4
stdbool
idx
ialloc
extern-inline
memchr
memrchr
memmem
full-write
string-desc-quotearg #include "string-desc-quotearg.h" string-desc-quotearg.c 00gnulib.m4
zzgnulib.m4
string-desc
quotearg
extern-inline
strtod-obsolete #include <string.h> --- strtod-obsolete.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_STRTOD_OBSOLETE
strtod
strtold #include <stdlib.h> strtold.c
strtod.c
strtold.m4
math_h.m4
ldexpl.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_STRTOLD
gl_CONDITIONAL([GL_COND_OBJ_STRTOLD],
[test $HAVE_STRTOLD = 0 || test $REPLACE_STRTOLD = 1])
AM_COND_IF([GL_COND_OBJ_STRTOLD], [
gl_PREREQ_STRTOLD
])
gl_STDLIB_MODULE_INDICATOR([strtold])
stdlib
c-ctype [test $HAVE_STRTOLD = 0 || test $REPLACE_STRTOLD = 1]
math [test $HAVE_STRTOLD = 0 || test $REPLACE_STRTOLD = 1]
stdbool [test $HAVE_STRTOLD = 0 || test $REPLACE_STRTOLD = 1]
strtod [{ test $HAVE_STRTOLD = 0 || test $REPLACE_STRTOLD = 1; } && test $HAVE_SAME_LONG_DOUBLE_AS_DOUBLE = 1]
sys_msg #if HAVE_SYS_MSG_H
#include <sys/msg.h>
#endif
sys_msg.in.h sys_msg_h.m4
00gnulib.m4
zzgnulib.m4
gl_SYS_MSG_H
gl_CONDITIONAL_HEADER([sys/msg.h])
AC_PROG_MKDIR_P
gen-header
include_next
sys_resource #include <sys/resource.h> sys_resource.in.h sys_resource_h.m4
00gnulib.m4
zzgnulib.m4
gl_SYS_RESOURCE_H
gl_SYS_RESOURCE_H_REQUIRE_DEFAULTS
AC_PROG_MKDIR_P
gen-header
include_next
snippet/arg-nonnull
snippet/c++defs
snippet/warn-on-use
sys_time
sys_sem #if HAVE_SYS_SEM_H
#include <sys/sem.h>
#endif
sys_sem.in.h sys_sem_h.m4
00gnulib.m4
zzgnulib.m4
gl_SYS_SEM_H
gl_CONDITIONAL_HEADER([sys/sem.h])
AC_PROG_MKDIR_P
gen-header
include_next
sys_shm #if HAVE_SYS_SHM_H
#include <sys/shm.h>
#endif
sys_shm.in.h sys_shm_h.m4
00gnulib.m4
zzgnulib.m4
gl_SYS_SHM_H
gl_CONDITIONAL_HEADER([sys/shm.h])
AC_PROG_MKDIR_P
gen-header
include_next
sys_types #include <sys/types.h> sys_types.in.h sys_types_h.m4
off_t.m4
pid_t.m4
00gnulib.m4
zzgnulib.m4
gl_SYS_TYPES_H
gl_SYS_TYPES_H_REQUIRE_DEFAULTS
AC_PROG_MKDIR_P
gen-header
include_next
ssize_t
system-posix #include <stdlib.h> --- 00gnulib.m4
zzgnulib.m4
gl_STDLIB_MODULE_INDICATOR([system-posix])
stdlib
sys_wait
system-quote #include "system-quote.h" system-quote.c 00gnulib.m4
zzgnulib.m4
AC_REQUIRE([AC_C_RESTRICT])
sh-quote
stdbool
xalloc
tanf #include <math.h> tanf.c tanf.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_TANF
gl_CONDITIONAL([GL_COND_OBJ_TANF], [test $HAVE_TANF = 0])
gl_MATH_MODULE_INDICATOR([tanf])
math
extensions
tan [test $HAVE_TANF = 0]
tanhf #include <math.h> tanhf.c tanhf.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_TANHF
gl_CONDITIONAL([GL_COND_OBJ_TANHF], [test $HAVE_TANHF = 0])
gl_MATH_MODULE_INDICATOR([tanhf])
math
extensions
tanh [test $HAVE_TANHF = 0]
tcgetsid #include <termios.h> tcgetsid.c tcgetsid.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_TCGETSID
gl_CONDITIONAL([GL_COND_OBJ_TCGETSID], [test $HAVE_TCGETSID = 0])
AM_COND_IF([GL_COND_OBJ_TCGETSID], [
gl_PREREQ_TCGETSID
])
gl_TERMIOS_MODULE_INDICATOR([tcgetsid])
termios
extensions
sys_ioctl [test $HAVE_TCGETSID = 0]
term-style-control #include "term-style-control.h" term-style-control.c tcgetattr.m4
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([AC_C_INLINE])
gl_HAVE_TCGETATTR
stdbool
fatal-signal
sigaction
sigprocmask
full-write
fstat
same-inode
xalloc-die
termios #include <termios.h> termios.in.h termios_h.m4
pid_t.m4
00gnulib.m4
zzgnulib.m4
gl_TERMIOS_H
gl_TERMIOS_H_REQUIRE_DEFAULTS
AC_PROG_MKDIR_P
gen-header
include_next
snippet/c++defs
snippet/warn-on-use
thrd #include <threads.h> thrd.c thrd.m4
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([gl_THREADS_H])
gl_FUNC_THRD_JOIN
gl_CONDITIONAL([GL_COND_OBJ_THRD],
[test $HAVE_THREADS_H = 0 || test $REPLACE_THRD_CREATE = 1 || test $REPLACE_THRD_JOIN = 1])
gl_THREADS_MODULE_INDICATOR([thrd])
threads-h
windows-thread
nanosleep
thread-optim #include "thread-optim.h" --- 00gnulib.m4
zzgnulib.m4
AC_CHECK_HEADERS([sys/single_threaded.h])
---
threads #include <threads.h> --- 00gnulib.m4
zzgnulib.m4
threads-h
thrd
call_once
mtx
cnd
tss
threads-h #include <threads.h> threads.in.h
windows-thread.h
windows-mutex.h
windows-recmutex.h
windows-timedmutex.h
windows-timedrecmutex.h
windows-once.h
windows-cond.h
windows-tls.h
windows-initguard.h
threads_h.m4
threadlib.m4
00gnulib.m4
zzgnulib.m4
gl_THREADS_H
gl_THREADS_H_REQUIRE_DEFAULTS
AC_PROG_MKDIR_P
gen-header
include_next
snippet/c++defs
snippet/_Noreturn
snippet/arg-nonnull
snippet/warn-on-use
time-h
havelib
timespec-add #include "timespec.h" timespec-add.c 00gnulib.m4
zzgnulib.m4
c99
intprops
timespec
timespec-sub #include "timespec.h" timespec-sub.c 00gnulib.m4
zzgnulib.m4
c99
intprops
timespec
timevar #include "timevar.h" timevar.c 00gnulib.m4
zzgnulib.m4
c99
gethrxtime
getrusage
gettext-h
stdlib
sys_time
sys_times
xalloc
towctrans #include <wctype.h> towctrans.c
towctrans-impl.h
towctrans.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_TOWCTRANS
gl_CONDITIONAL([GL_COND_OBJ_TOWCTRANS], [test $HAVE_TOWCTRANS = 0])
gl_WCTYPE_MODULE_INDICATOR([towctrans])
wctype-h
trunc-ieee #include <math.h> --- trunc-ieee.m4
minus-zero.m4
signbit.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_TRUNC_IEEE
trunc
truncf-ieee #include <math.h> --- truncf-ieee.m4
minus-zero.m4
signbit.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_TRUNCF_IEEE
truncf
truncl-ieee #include <math.h> --- truncl-ieee.m4
minus-zero.m4
signbit.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_TRUNCL_IEEE
truncl
tss #include <threads.h> tss.c 00gnulib.m4
zzgnulib.m4
AC_REQUIRE([gl_THREADS_H])
gl_CONDITIONAL([GL_COND_OBJ_TSS], [test $HAVE_THREADS_H = 0])
gl_THREADS_MODULE_INDICATOR([tss])
threads-h
windows-tls
uchar #include <uchar.h> uchar.in.h uchar_h.m4
stdint.m4
00gnulib.m4
zzgnulib.m4
gl_UCHAR_H
gl_UCHAR_H_REQUIRE_DEFAULTS
AC_PROG_MKDIR_P
gen-header
include_next
snippet/c++defs
extern-inline
assert-h
stdint
wchar
unicase/cased #include "unicase/caseprop.h" unicase/cased.c
unicase/cased.h
unictype/bitmap.h
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([AC_C_INLINE])
unitypes
stdbool
unicase/ignorable #include "unicase/caseprop.h" unicase/ignorable.c
unicase/ignorable.h
unictype/bitmap.h
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([AC_C_INLINE])
unitypes
stdbool
unicase/special-casing #include "unicase/special-casing.h" unicase/special-casing.in.h
unicase/special-casing.c
unicase/special-casing-table.gperf
00gnulib.m4
zzgnulib.m4
AC_PROG_MKDIR_P
gen-header
gperf
unicase/tocasefold #include "unicase/casefold.h" unicase/tocasefold.c
unicase/tocasefold.h
unicase/simple-mapping.h
00gnulib.m4
zzgnulib.m4
unicase/base
unicase/u16-casemap #include "unicase/unicasemap.h" unicase/u16-casemap.c
unicase/u-casemap.h
unicase/context.h
00gnulib.m4
zzgnulib.m4
unicase/base
unicase/cased
unicase/ignorable
unicase/special-casing
unictype/combining-class
unictype/property-soft-dotted
unistr/u16-mbtouc-unsafe
unistr/u16-uctomb
unistr/u16-cpy
uninorm/u16-normalize
stdbool
unicase/u16-is-invariant #include "unicase/invariant.h" unicase/u16-is-invariant.c
unicase/u-is-invariant.h
00gnulib.m4
zzgnulib.m4
unitypes
uninorm/base
uninorm/u16-normalize
uninorm/nfd
unistr/u16-cmp
stdbool
unicase/u32-casemap #include "unicase/unicasemap.h" unicase/u32-casemap.c
unicase/u-casemap.h
unicase/context.h
00gnulib.m4
zzgnulib.m4
unicase/base
unicase/cased
unicase/ignorable
unicase/special-casing
unictype/combining-class
unictype/property-soft-dotted
unistr/u32-mbtouc-unsafe
unistr/u32-uctomb
unistr/u32-cpy
uninorm/u32-normalize
stdbool
unicase/u32-is-invariant #include "unicase/invariant.h" unicase/u32-is-invariant.c
unicase/u-is-invariant.h
00gnulib.m4
zzgnulib.m4
unitypes
uninorm/base
uninorm/u32-normalize
uninorm/nfd
unistr/u32-cmp
stdbool
unicase/u32-is-uppercase #include "unicase.h" unicase/u32-is-uppercase.c 00gnulib.m4
zzgnulib.m4
gl_LIBUNISTRING_MODULE([1.1], [unicase/u32-is-uppercase])
unicase/base
unicase/u32-is-invariant
unicase/u32-toupper
unicase/u8-casemap #include "unicase/unicasemap.h" unicase/u8-casemap.c
unicase/u-casemap.h
unicase/context.h
00gnulib.m4
zzgnulib.m4
unicase/base
unicase/cased
unicase/ignorable
unicase/special-casing
unictype/combining-class
unictype/property-soft-dotted
unistr/u8-mbtouc-unsafe
unistr/u8-uctomb
unistr/u8-cpy
uninorm/u8-normalize
stdbool
unicase/u8-is-invariant #include "unicase/invariant.h" unicase/u8-is-invariant.c
unicase/u-is-invariant.h
00gnulib.m4
zzgnulib.m4
unitypes
uninorm/base
uninorm/u8-normalize
uninorm/nfd
unistr/u8-cmp
stdbool
unictype/category-LC #include "unictype.h" unictype/categ_LC.c
unictype/categ_LC.h
00gnulib.m4
zzgnulib.m4
gl_LIBUNISTRING_MODULE([1.1], [unictype/category-LC])
unictype/base
unictype/category-longname #include "unictype.h" unictype/categ_longname.c 00gnulib.m4
zzgnulib.m4
gl_LIBUNISTRING_MODULE([0.9.8], [unictype/category-longname])
unictype/base
unictype/combining-class-all #include "unictype.h" --- 00gnulib.m4
zzgnulib.m4
unictype/base
unictype/combining-class
unictype/combining-class-byname
unictype/combining-class-longname
unictype/combining-class-name
unictype/combining-class-byname #include "unictype.h" unictype/combiningclass_byname.c
unictype/combiningclass_byname.gperf
00gnulib.m4
zzgnulib.m4
gl_LIBUNISTRING_MODULE([0.9.8], [unictype/combining-class-byname])
unictype/base
gperf
unictype/combining-class-longname #include "unictype.h" unictype/combiningclass_longname.c 00gnulib.m4
zzgnulib.m4
gl_LIBUNISTRING_MODULE([0.9.8], [unictype/combining-class-longname])
unictype/base
unictype/combining-class-name #include "unictype.h" unictype/combiningclass_name.c 00gnulib.m4
zzgnulib.m4
gl_LIBUNISTRING_MODULE([0.9.8], [unictype/combining-class-name])
unictype/base
unictype/joininggroup-all #include "unictype.h" --- 00gnulib.m4
zzgnulib.m4
unictype/base
unictype/joininggroup-byname
unictype/joininggroup-name
unictype/joininggroup-of
unictype/joininggroup-byname #include "unictype.h" unictype/joininggroup_byname.c
unictype/joininggroup_byname.gperf
00gnulib.m4
zzgnulib.m4
gl_LIBUNISTRING_MODULE([0.9.11], [unictype/joininggroup-byname])
unictype/base
gperf
unictype/joininggroup-name #include "unictype.h" unictype/joininggroup_name.c
unictype/joininggroup_name.h
00gnulib.m4
zzgnulib.m4
gl_LIBUNISTRING_MODULE([0.9.11], [unictype/joininggroup-name])
unictype/base
unictype/joininggroup-of #include "unictype.h" unictype/joininggroup_of.c
unictype/joininggroup_of.h
00gnulib.m4
zzgnulib.m4
gl_LIBUNISTRING_MODULE([0.9.11], [unictype/joininggroup-of])
unictype/base
unictype/joiningtype-all #include "unictype.h" --- 00gnulib.m4
zzgnulib.m4
unictype/base
unictype/joiningtype-byname
unictype/joiningtype-longname
unictype/joiningtype-name
unictype/joiningtype-of
unictype/joiningtype-byname #include "unictype.h" unictype/joiningtype_byname.c
unictype/joiningtype_byname.gperf
00gnulib.m4
zzgnulib.m4
gl_LIBUNISTRING_MODULE([0.9.8], [unictype/joiningtype-byname])
unictype/base
gperf
unictype/joiningtype-longname #include "unictype.h" unictype/joiningtype_longname.c 00gnulib.m4
zzgnulib.m4
gl_LIBUNISTRING_MODULE([0.9.8], [unictype/joiningtype-longname])
unictype/base
unictype/joiningtype-name #include "unictype.h" unictype/joiningtype_name.c 00gnulib.m4
zzgnulib.m4
gl_LIBUNISTRING_MODULE([0.9.8], [unictype/joiningtype-name])
unictype/base
unictype/joiningtype-of #include "unictype.h" unictype/joiningtype_of.c
unictype/joiningtype_of.h
00gnulib.m4
zzgnulib.m4
gl_LIBUNISTRING_MODULE([1.1], [unictype/joiningtype-of])
unictype/base
unictype/category-test-withtable
unictype/property-emoji #include "unictype.h" unictype/pr_emoji.c
unictype/pr_emoji.h
unictype/bitmap.h
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([AC_C_INLINE])
gl_LIBUNISTRING_MODULE([1.1], [unictype/property-emoji])
unictype/base
unictype/property-emoji-component #include "unictype.h" unictype/pr_emoji_component.c
unictype/pr_emoji_component.h
unictype/bitmap.h
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([AC_C_INLINE])
gl_LIBUNISTRING_MODULE([0.9.11], [unictype/property-emoji-component])
unictype/base
unictype/property-emoji-modifier #include "unictype.h" unictype/pr_emoji_modifier.c
unictype/pr_emoji_modifier.h
unictype/bitmap.h
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([AC_C_INLINE])
gl_LIBUNISTRING_MODULE([0.9.11], [unictype/property-emoji-modifier])
unictype/base
unictype/property-emoji-modifier-base #include "unictype.h" unictype/pr_emoji_modifier_base.c
unictype/pr_emoji_modifier_base.h
unictype/bitmap.h
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([AC_C_INLINE])
gl_LIBUNISTRING_MODULE([1.1], [unictype/property-emoji-modifier-base])
unictype/base
unictype/property-emoji-presentation #include "unictype.h" unictype/pr_emoji_presentation.c
unictype/pr_emoji_presentation.h
unictype/bitmap.h
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([AC_C_INLINE])
gl_LIBUNISTRING_MODULE([1.1], [unictype/property-emoji-presentation])
unictype/base
unictype/property-extended-pictographic #include "unictype.h" unictype/pr_extended_pictographic.c
unictype/pr_extended_pictographic.h
unictype/bitmap.h
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([AC_C_INLINE])
gl_LIBUNISTRING_MODULE([0.9.11], [unictype/property-extended-pictographic])
unictype/base
unictype/property-regional-indicator #include "unictype.h" unictype/pr_regional_indicator.c 00gnulib.m4
zzgnulib.m4
AC_REQUIRE([AC_C_INLINE])
gl_LIBUNISTRING_MODULE([0.9.11], [unictype/property-regional-indicator])
unictype/base
unigbrk/base #include "unigbrk.h" unigbrk.in.h libunistring-base.m4
00gnulib.m4
zzgnulib.m4
gl_LIBUNISTRING_LIBHEADER([0.9.11], [unigbrk.h])
AC_PROG_MKDIR_P
gen-header
unitypes
stdbool
unigbrk/u16-grapheme-breaks #include "unigbrk.h" unigbrk/u16-grapheme-breaks.c
unigbrk/u-grapheme-breaks.h
00gnulib.m4
zzgnulib.m4
gl_MODULE_INDICATOR([unigbrk/u16-grapheme-breaks])
gl_LIBUNISTRING_MODULE([1.1], [unigbrk/u16-grapheme-breaks])
unigbrk/base
unigbrk/uc-gbrk-prop
unictype/property-extended-pictographic
unistr/u16-mbtouc
stdbool
unigbrk/u16-grapheme-next #include "unigbrk.h" unigbrk/u16-grapheme-next.c 00gnulib.m4
zzgnulib.m4
gl_MODULE_INDICATOR([unigbrk/u16-grapheme-next])
gl_LIBUNISTRING_MODULE([1.1], [unigbrk/u16-grapheme-next])
unigbrk/uc-is-grapheme-break
unistr/u16-mbtouc
unigbrk/u16-grapheme-prev #include "unigbrk.h" unigbrk/u16-grapheme-prev.c 00gnulib.m4
zzgnulib.m4
gl_MODULE_INDICATOR([unigbrk/u16-grapheme-prev])
gl_LIBUNISTRING_MODULE([1.1], [unigbrk/u16-grapheme-prev])
unigbrk/uc-is-grapheme-break
unistr/u16-prev
unigbrk/u32-grapheme-breaks #include "unigbrk.h" unigbrk/u32-grapheme-breaks.c
unigbrk/u-grapheme-breaks.h
00gnulib.m4
zzgnulib.m4
gl_MODULE_INDICATOR([unigbrk/u32-grapheme-breaks])
gl_LIBUNISTRING_MODULE([1.1], [unigbrk/u32-grapheme-breaks])
unigbrk/base
unigbrk/uc-gbrk-prop
unictype/property-extended-pictographic
unistr/u32-mbtouc
stdbool
unigbrk/u32-grapheme-next #include "unigbrk.h" unigbrk/u32-grapheme-next.c 00gnulib.m4
zzgnulib.m4
gl_MODULE_INDICATOR([unigbrk/u32-grapheme-next])
gl_LIBUNISTRING_MODULE([1.1], [unigbrk/u32-grapheme-next])
unigbrk/uc-is-grapheme-break
unistr/u32-mbtouc
unigbrk/u32-grapheme-prev #include "unigbrk.h" unigbrk/u32-grapheme-prev.c 00gnulib.m4
zzgnulib.m4
gl_MODULE_INDICATOR([unigbrk/u32-grapheme-prev])
gl_LIBUNISTRING_MODULE([1.1], [unigbrk/u32-grapheme-prev])
unigbrk/uc-is-grapheme-break
unistr/u32-prev
unigbrk/u8-grapheme-breaks #include "unigbrk.h" unigbrk/u8-grapheme-breaks.c
unigbrk/u-grapheme-breaks.h
00gnulib.m4
zzgnulib.m4
gl_MODULE_INDICATOR([unigbrk/u8-grapheme-breaks])
gl_LIBUNISTRING_MODULE([1.1], [unigbrk/u8-grapheme-breaks])
unigbrk/base
unigbrk/uc-gbrk-prop
unictype/property-extended-pictographic
unistr/u8-mbtouc
stdbool
unigbrk/u8-grapheme-next #include "unigbrk.h" unigbrk/u8-grapheme-next.c 00gnulib.m4
zzgnulib.m4
gl_MODULE_INDICATOR([unigbrk/u8-grapheme-next])
gl_LIBUNISTRING_MODULE([1.1], [unigbrk/u8-grapheme-next])
unigbrk/uc-is-grapheme-break
unistr/u8-mbtouc
unigbrk/u8-grapheme-prev #include "unigbrk.h" unigbrk/u8-grapheme-prev.c 00gnulib.m4
zzgnulib.m4
gl_MODULE_INDICATOR([unigbrk/u8-grapheme-prev])
gl_LIBUNISTRING_MODULE([1.1], [unigbrk/u8-grapheme-prev])
unigbrk/uc-is-grapheme-break
unistr/u8-prev
unigbrk/uc-gbrk-prop #include "unigbrk.h" unigbrk/gbrkprop.h
unigbrk/uc-gbrk-prop.c
00gnulib.m4
zzgnulib.m4
gl_LIBUNISTRING_MODULE([1.1], [unigbrk/uc-gbrk-prop])
unigbrk/base
unigbrk/uc-grapheme-breaks #include "unigbrk.h" unigbrk/uc-grapheme-breaks.c
unigbrk/u-grapheme-breaks.h
00gnulib.m4
zzgnulib.m4
gl_MODULE_INDICATOR([unigbrk/uc-grapheme-breaks])
gl_LIBUNISTRING_MODULE([1.1], [unigbrk/uc-grapheme-breaks])
unigbrk/base
unigbrk/uc-gbrk-prop
unictype/property-extended-pictographic
stdbool
unigbrk/uc-is-grapheme-break #include "unigbrk.h" unigbrk/uc-is-grapheme-break.c 00gnulib.m4
zzgnulib.m4
gl_LIBUNISTRING_MODULE([1.1], [unigbrk/uc-is-grapheme-break])
unigbrk/base
unigbrk/uc-gbrk-prop
unigbrk/ulc-grapheme-breaks #include "unigbrk.h" unigbrk/ulc-grapheme-breaks.c 00gnulib.m4
zzgnulib.m4
gl_MODULE_INDICATOR([unigbrk/ulc-grapheme-breaks])
gl_LIBUNISTRING_MODULE([1.1], [unigbrk/ulc-grapheme-breaks])
unigbrk/base
unigbrk/u8-grapheme-breaks
uniconv/u8-conv-from-enc
c-ctype
localcharset
uninorm/compat-decomposition #include "uninorm/decompose-internal.h" uninorm/compat-decomposition.c 00gnulib.m4
zzgnulib.m4
uninorm/base
uninorm/decomposition
uninorm/decompose-internal #include "uninorm/decompose-internal.h" uninorm/decompose-internal.c 00gnulib.m4
zzgnulib.m4
unitypes
array-mergesort
uninorm/decomposition-table #include "uninorm/decomposition-table.h" uninorm/decomposition-table.c
uninorm/decomposition-table1.h
uninorm/decomposition-table2.h
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([AC_C_INLINE])
uninorm/base
uniwbrk/table #include "uniwbrk/wbrktable.h" uniwbrk/wbrktable.c 00gnulib.m4
zzgnulib.m4
---
unlinkat #include <unistd.h> unlinkat.c
at-func.c
unlinkat.m4
lstat.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_UNLINKAT
gl_CONDITIONAL([GL_COND_OBJ_UNLINKAT],
[test $HAVE_UNLINKAT = 0 || test $REPLACE_UNLINKAT = 1])
gl_UNISTD_MODULE_INDICATOR([unlinkat])
unistd
extensions
fcntl-h [test $HAVE_UNLINKAT = 0 || test $REPLACE_UNLINKAT = 1]
openat-h [test $HAVE_UNLINKAT = 0 || test $REPLACE_UNLINKAT = 1]
sys_stat [test $HAVE_UNLINKAT = 0 || test $REPLACE_UNLINKAT = 1]
at-internal [test $HAVE_UNLINKAT = 0]
errno [test $HAVE_UNLINKAT = 0]
fchdir [test $HAVE_UNLINKAT = 0]
filename [test $HAVE_UNLINKAT = 0]
openat-die [test $HAVE_UNLINKAT = 0]
rmdir [test $HAVE_UNLINKAT = 0]
save-cwd [test $HAVE_UNLINKAT = 0]
unlink [test $HAVE_UNLINKAT = 0]
utmp #include <utmp.h> utmp.in.h utmp_h.m4
pty_h.m4
termios_h.m4
00gnulib.m4
zzgnulib.m4
gl_UTMP_H
gl_UTMP_H_REQUIRE_DEFAULTS
AC_PROG_MKDIR_P
gen-header
include_next
snippet/c++defs
snippet/warn-on-use
vasnprintf-gnu #include "vasnprintf.h" --- vasnprintf-gnu.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_VASNPRINTF_GNU
vasnprintf-posix
vasnwprintf #include "vasnwprintf.h" float+.h
printf-args.h
printf-args.c
wprintf-parse.h
wprintf-parse.c
printf-parse.c
vasnwprintf.c
vasnprintf.c
asnwprintf.c
wchar_t.m4
wint_t.m4
intmax_t.m4
stdint_h.m4
inttypes_h.m4
vasnprintf.m4
printf.m4
mbrtowc.m4
math_h.m4
exponentd.m4
musl.m4
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([AC_C_RESTRICT])
gl_FUNC_VASNWPRINTF
stdio
alloca-opt
attribute
float
free-posix
limits-h
stdint
xsize
errno
memchr
assert-h
wchar
mbrtowc
wmemcpy
wmemset
vasnwprintf-gnu #include "vasnwprintf.h" --- vasnwprintf-gnu.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_VASNWPRINTF_GNU
vasnwprintf-posix
vasnwprintf-posix #include "vasnwprintf.h" --- vasnwprintf-posix.m4
printf.m4
math_h.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_VASNWPRINTF_POSIX
vasnwprintf
isnand-nolibm
isnanl-nolibm
frexp-nolibm
frexpl-nolibm
printf-frexp
printf-frexpl
signbit
fpucw
nocrash
printf-safe
multiarch
vasprintf-gnu #include "vasprintf.h" --- vasprintf-gnu.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_VASPRINTF_GNU
vasprintf-posix
vdprintf-gnu #include <stdio.h> --- vdprintf-gnu.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_VDPRINTF_GNU
vdprintf-posix
vfprintf-gnu #include <stdio.h> --- vfprintf-gnu.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_VFPRINTF_GNU
vfprintf-posix
vfscanf #include <stdio.h> --- 00gnulib.m4
zzgnulib.m4
gl_STDIO_MODULE_INDICATOR([vfscanf])
gl_MODULE_INDICATOR([vfscanf])
stdio
vma-iter #include "vma-iter.h" vma-iter.c mmap-anon.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_MMAP_ANON
AC_REQUIRE([AC_C_INLINE])
AC_CHECK_FUNCS_ONCE([mquery pstat_getprocvm])
stdint
unistd
extensions
getpagesize
open
vprintf-gnu #include <stdio.h> --- vprintf-gnu.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_VPRINTF_GNU
vprintf-posix
vscanf #include <stdio.h> --- 00gnulib.m4
zzgnulib.m4
gl_STDIO_MODULE_INDICATOR([vscanf])
gl_MODULE_INDICATOR([vscanf])
stdio
vsnprintf-gnu #include <stdio.h> --- vsnprintf-gnu.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_VSNPRINTF_GNU
vsnprintf-posix
vsprintf-gnu #include <stdio.h> --- vsprintf-gnu.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_VSPRINTF_GNU
vsprintf-posix
waitpid #include <sys/wait.h> waitpid.c waitpid.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_WAITPID
gl_CONDITIONAL([GL_COND_OBJ_WAITPID], [test $HAVE_WAITPID = 0])
gl_SYS_WAIT_MODULE_INDICATOR([waitpid])
sys_wait
wchar-single --- --- 00gnulib.m4
zzgnulib.m4
gl_MODULE_INDICATOR([wchar-single])
wchar
wcpcpy #include <wchar.h> wcpcpy.c
wcpcpy-impl.h
wcpcpy.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_WCPCPY
gl_CONDITIONAL([GL_COND_OBJ_WCPCPY], [test $HAVE_WCPCPY = 0])
gl_WCHAR_MODULE_INDICATOR([wcpcpy])
extensions
wchar
wcpncpy #include <wchar.h> wcpncpy.c
wcpncpy-impl.h
wcpncpy.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_WCPNCPY
gl_CONDITIONAL([GL_COND_OBJ_WCPNCPY], [test $HAVE_WCPNCPY = 0])
gl_WCHAR_MODULE_INDICATOR([wcpncpy])
extensions
wchar
wcscasecmp #include <wchar.h> wcscasecmp.c
wcscasecmp-impl.h
wcscasecmp.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_WCSCASECMP
gl_CONDITIONAL([GL_COND_OBJ_WCSCASECMP], [test $HAVE_WCSCASECMP = 0])
gl_WCHAR_MODULE_INDICATOR([wcscasecmp])
wchar
wctype-h [test $HAVE_WCSCASECMP = 0]
wcscat #include <wchar.h> wcscat.c
wcscat-impl.h
wcscat.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_WCSCAT
gl_CONDITIONAL([GL_COND_OBJ_WCSCAT], [test $HAVE_WCSCAT = 0])
gl_WCHAR_MODULE_INDICATOR([wcscat])
wchar
wcschr #include <wchar.h> wcschr.c
wcschr-impl.h
wcschr.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_WCSCHR
gl_CONDITIONAL([GL_COND_OBJ_WCSCHR], [test $HAVE_WCSCHR = 0])
gl_WCHAR_MODULE_INDICATOR([wcschr])
wchar
wcscmp #include <wchar.h> wcscmp.c
wcscmp-impl.h
wcscmp.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_WCSCMP
gl_CONDITIONAL([GL_COND_OBJ_WCSCMP], [test $HAVE_WCSCMP = 0])
gl_WCHAR_MODULE_INDICATOR([wcscmp])
wchar
wcscoll #include <wchar.h> wcscoll.c
wcscoll-impl.h
wcscoll.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_WCSCOLL
gl_CONDITIONAL([GL_COND_OBJ_WCSCOLL], [test $HAVE_WCSCOLL = 0])
gl_WCHAR_MODULE_INDICATOR([wcscoll])
free-posix
wchar
wcscpy #include <wchar.h> wcscpy.c
wcscpy-impl.h
wcscpy.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_WCSCPY
gl_CONDITIONAL([GL_COND_OBJ_WCSCPY], [test $HAVE_WCSCPY = 0])
gl_WCHAR_MODULE_INDICATOR([wcscpy])
wchar
wcscspn #include <wchar.h> wcscspn.c
wcscspn-impl.h
wcscspn.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_WCSCSPN
gl_CONDITIONAL([GL_COND_OBJ_WCSCSPN], [test $HAVE_WCSCSPN = 0])
gl_WCHAR_MODULE_INDICATOR([wcscspn])
wchar
wcslen [test $HAVE_WCSCSPN = 0]
wcschr [test $HAVE_WCSCSPN = 0]
wcsdup #include <wchar.h> wcsdup.c
wcsdup-impl.h
wcsdup.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_WCSDUP
gl_CONDITIONAL([GL_COND_OBJ_WCSDUP], [test $HAVE_WCSDUP = 0])
gl_WCHAR_MODULE_INDICATOR([wcsdup])
wchar
wcslen [test $HAVE_WCSDUP = 0]
wmemcpy [test $HAVE_WCSDUP = 0]
wcsftime #include <wchar.h> wcsftime.c wcsftime.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_WCSFTIME
gl_CONDITIONAL([GL_COND_OBJ_WCSFTIME], [test $REPLACE_WCSFTIME = 1])
gl_WCHAR_MODULE_INDICATOR([wcsftime])
wchar
wcslen #include <wchar.h> wcslen.c
wcslen-impl.h
wcslen.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_WCSLEN
gl_CONDITIONAL([GL_COND_OBJ_WCSLEN], [test $HAVE_WCSLEN = 0])
gl_WCHAR_MODULE_INDICATOR([wcslen])
wchar
wcsncasecmp #include <wchar.h> wcsncasecmp.c
wcsncasecmp-impl.h
wcsncasecmp.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_WCSNCASECMP
gl_CONDITIONAL([GL_COND_OBJ_WCSNCASECMP], [test $HAVE_WCSNCASECMP = 0])
gl_WCHAR_MODULE_INDICATOR([wcsncasecmp])
wchar
wctype-h [test $HAVE_WCSNCASECMP = 0]
wcsncat #include <wchar.h> wcsncat.c
wcsncat-impl.h
wcsncat.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_WCSNCAT
gl_CONDITIONAL([GL_COND_OBJ_WCSNCAT], [test $HAVE_WCSNCAT = 0])
gl_WCHAR_MODULE_INDICATOR([wcsncat])
wchar
wcsncmp #include <wchar.h> wcsncmp.c
wcsncmp-impl.h
wcsncmp.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_WCSNCMP
gl_CONDITIONAL([GL_COND_OBJ_WCSNCMP], [test $HAVE_WCSNCMP = 0])
gl_WCHAR_MODULE_INDICATOR([wcsncmp])
wchar
wcsncpy #include <wchar.h> wcsncpy.c
wcsncpy-impl.h
wcsncpy.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_WCSNCPY
gl_CONDITIONAL([GL_COND_OBJ_WCSNCPY], [test $HAVE_WCSNCPY = 0])
gl_WCHAR_MODULE_INDICATOR([wcsncpy])
wchar
wcsnlen #include <wchar.h> wcsnlen.c
wcsnlen-impl.h
wcsnlen.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_WCSNLEN
gl_CONDITIONAL([GL_COND_OBJ_WCSNLEN], [test $HAVE_WCSNLEN = 0])
gl_WCHAR_MODULE_INDICATOR([wcsnlen])
wchar
wcspbrk #include <wchar.h> wcspbrk.c
wcspbrk-impl.h
wcspbrk.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_WCSPBRK
gl_CONDITIONAL([GL_COND_OBJ_WCSPBRK], [test $HAVE_WCSPBRK = 0])
gl_WCHAR_MODULE_INDICATOR([wcspbrk])
wchar
wcschr [test $HAVE_WCSPBRK = 0]
wcsrchr #include <wchar.h> wcsrchr.c
wcsrchr-impl.h
wcsrchr.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_WCSRCHR
gl_CONDITIONAL([GL_COND_OBJ_WCSRCHR], [test $HAVE_WCSRCHR = 0])
gl_WCHAR_MODULE_INDICATOR([wcsrchr])
wchar
wcsspn #include <wchar.h> wcsspn.c
wcsspn-impl.h
wcsspn.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_WCSSPN
gl_CONDITIONAL([GL_COND_OBJ_WCSSPN], [test $HAVE_WCSSPN = 0])
gl_WCHAR_MODULE_INDICATOR([wcsspn])
wchar
wcschr [test $HAVE_WCSSPN = 0]
wcsstr #include <wchar.h> wcsstr.c
wcsstr-impl.h
wcs-two-way.h
wcsstr.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_WCSSTR
if test $HAVE_WCSSTR = 0 || test $REPLACE_WCSSTR = 1; then
AC_LIBOBJ([wcsstr])
fi
wcsstr-simple
builtin-expect [test $HAVE_WCSSTR = 0 || test $REPLACE_WCSSTR = 1]
wcschr [test $HAVE_WCSSTR = 0 || test $REPLACE_WCSSTR = 1]
wmemchr [test $HAVE_WCSSTR = 0 || test $REPLACE_WCSSTR = 1]
wmemcmp [test $HAVE_WCSSTR = 0 || test $REPLACE_WCSSTR = 1]
wcsstr-simple #include <wchar.h> wcsstr.c
wcsstr-impl.h
wcsstr.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_WCSSTR_SIMPLE
if test $HAVE_WCSSTR = 0; then
AC_LIBOBJ([wcsstr])
fi
gl_WCHAR_MODULE_INDICATOR([wcsstr])
wchar
wcschr [test $HAVE_WCSSTR = 0]
wcstok #include <wchar.h> wcstok.c
wcstok-impl.h
wcstok.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_WCSTOK
gl_CONDITIONAL([GL_COND_OBJ_WCSTOK],
[test $HAVE_WCSTOK = 0 || test $REPLACE_WCSTOK = 1])
gl_WCHAR_MODULE_INDICATOR([wcstok])
wchar
wcsspn [test $HAVE_WCSTOK = 0 || test $REPLACE_WCSTOK = 1]
wcspbrk [test $HAVE_WCSTOK = 0 || test $REPLACE_WCSTOK = 1]
wcswidth #include <wchar.h> wcswidth.c
wcswidth-impl.h
wcswidth.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_WCSWIDTH
gl_CONDITIONAL([GL_COND_OBJ_WCSWIDTH],
[test $HAVE_WCSWIDTH = 0 || test $REPLACE_WCSWIDTH = 1])
gl_WCHAR_MODULE_INDICATOR([wcswidth])
wchar
wcwidth [test $HAVE_WCSWIDTH = 0 || test $REPLACE_WCSWIDTH = 1]
wcsxfrm #include <wchar.h> wcsxfrm.c
wcsxfrm-impl.h
wcsxfrm.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_WCSXFRM
gl_CONDITIONAL([GL_COND_OBJ_WCSXFRM], [test $HAVE_WCSXFRM = 0])
gl_WCHAR_MODULE_INDICATOR([wcsxfrm])
free-posix
wchar
wctomb #include <stdlib.h> wctomb.c
wctomb-impl.h
wctomb.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_WCTOMB
gl_CONDITIONAL([GL_COND_OBJ_WCTOMB], [test $REPLACE_WCTOMB = 1])
AM_COND_IF([GL_COND_OBJ_WCTOMB], [
gl_PREREQ_WCTOMB
])
gl_STDLIB_MODULE_INDICATOR([wctomb])
stdlib
wcrtomb [test $REPLACE_WCTOMB = 1]
wchar [test $REPLACE_WCTOMB = 1]
wctrans #include <wctype.h> wctrans.c
wctrans-impl.h
wctrans.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_WCTRANS
gl_CONDITIONAL([GL_COND_OBJ_WCTRANS], [test $HAVE_WCTRANS = 0])
gl_WCTYPE_MODULE_INDICATOR([wctrans])
wctype-h
wctype-h #include <wctype.h> wctype.in.h
wctype-h.c
wctype_h.m4
wint_t.m4
00gnulib.m4
zzgnulib.m4
gl_WCTYPE_H
gl_WCTYPE_H_REQUIRE_DEFAULTS
AC_PROG_MKDIR_P
extern-inline
gen-header
include_next
snippet/c++defs
snippet/warn-on-use
windows-cond #include "windows-cond.h" windows-cond.c
windows-initguard.h
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([AC_CANONICAL_HOST])
gl_CONDITIONAL([GL_COND_OBJ_WINDOWS_COND],
[case "$host_os" in mingw*) true;; *) false;; esac])
stdbool
errno
time-h
gettimeofday
windows-mutex #include "windows-mutex.h" windows-mutex.c
windows-initguard.h
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([AC_CANONICAL_HOST])
gl_CONDITIONAL([GL_COND_OBJ_WINDOWS_MUTEX],
[case "$host_os" in mingw*) true;; *) false;; esac])
---
windows-once #include "windows-once.h" windows-once.c 00gnulib.m4
zzgnulib.m4
AC_REQUIRE([AC_CANONICAL_HOST])
gl_CONDITIONAL([GL_COND_OBJ_WINDOWS_ONCE],
[case "$host_os" in mingw*) true;; *) false;; esac])
---
windows-recmutex #include "windows-recmutex.h" windows-recmutex.c
windows-initguard.h
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([AC_CANONICAL_HOST])
gl_CONDITIONAL([GL_COND_OBJ_WINDOWS_RECMUTEX],
[case "$host_os" in mingw*) true;; *) false;; esac])
---
windows-rwlock #include "windows-rwlock.h" windows-rwlock.c
windows-initguard.h
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([AC_CANONICAL_HOST])
gl_CONDITIONAL([GL_COND_OBJ_WINDOWS_RWLOCK],
[case "$host_os" in mingw*) true;; *) false;; esac])
---
windows-spin #include "windows-spin.h" windows-spin.c 00gnulib.m4
zzgnulib.m4
AC_REQUIRE([AC_CANONICAL_HOST])
gl_CONDITIONAL([GL_COND_OBJ_WINDOWS_SPIN],
[case "$host_os" in mingw*) true;; *) false;; esac])
---
windows-thread #include "windows-thread.h" windows-thread.c 00gnulib.m4
zzgnulib.m4
AC_REQUIRE([AC_CANONICAL_HOST])
gl_CONDITIONAL([GL_COND_OBJ_WINDOWS_THREAD],
[case "$host_os" in mingw*) true;; *) false;; esac])
windows-once
windows-tls
windows-timedmutex #include "windows-timedmutex.h" windows-timedmutex.c
windows-initguard.h
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([AC_CANONICAL_HOST])
gl_CONDITIONAL([GL_COND_OBJ_WINDOWS_TIMEDMUTEX],
[case "$host_os" in mingw*) true;; *) false;; esac])
errno
time-h
gettimeofday
windows-timedrecmutex #include "windows-timedrecmutex.h" windows-timedrecmutex.c
windows-initguard.h
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([AC_CANONICAL_HOST])
gl_CONDITIONAL([GL_COND_OBJ_WINDOWS_TIMEDRECMUTEX],
[case "$host_os" in mingw*) true;; *) false;; esac])
errno
time-h
gettimeofday
windows-timedrwlock #include "windows-timedrwlock.h" windows-timedrwlock.c
windows-initguard.h
00gnulib.m4
zzgnulib.m4
AC_REQUIRE([AC_CANONICAL_HOST])
gl_CONDITIONAL([GL_COND_OBJ_WINDOWS_TIMEDRWLOCK],
[case "$host_os" in mingw*) true;; *) false;; esac])
errno
stdbool
time-h
gettimeofday
windows-tls #include "windows-tls.h" windows-tls.c 00gnulib.m4
zzgnulib.m4
AC_REQUIRE([AC_CANONICAL_HOST])
gl_CONDITIONAL([GL_COND_OBJ_WINDOWS_TLS],
[case "$host_os" in mingw*) true;; *) false;; esac])
windows-once
wmemchr #include <wchar.h> wmemchr.c
wmemchr-impl.h
wmemchr.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_WMEMCHR
gl_CONDITIONAL([GL_COND_OBJ_WMEMCHR], [test $HAVE_WMEMCHR = 0])
gl_WCHAR_MODULE_INDICATOR([wmemchr])
wchar
wmemcmp #include <wchar.h> wmemcmp.c
wmemcmp-impl.h
wmemcmp.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_WMEMCMP
gl_CONDITIONAL([GL_COND_OBJ_WMEMCMP], [test $HAVE_WMEMCMP = 0])
gl_WCHAR_MODULE_INDICATOR([wmemcmp])
wchar
wmemcpy #include <wchar.h> wmemcpy.c
wmemcpy-impl.h
wmemcpy.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_WMEMCPY
gl_CONDITIONAL([GL_COND_OBJ_WMEMCPY], [test $HAVE_WMEMCPY = 0])
gl_WCHAR_MODULE_INDICATOR([wmemcpy])
wchar
wmemmove #include <wchar.h> wmemmove.c
wmemmove-impl.h
wmemmove.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_WMEMMOVE
gl_CONDITIONAL([GL_COND_OBJ_WMEMMOVE], [test $HAVE_WMEMMOVE = 0])
gl_WCHAR_MODULE_INDICATOR([wmemmove])
wchar
wmemset #include <wchar.h> wmemset.c
wmemset-impl.h
wmemset.m4
00gnulib.m4
zzgnulib.m4
gl_FUNC_WMEMSET
gl_CONDITIONAL([GL_COND_OBJ_WMEMSET], [test $HAVE_WMEMSET = 0])
gl_WCHAR_MODULE_INDICATOR([wmemset])
wchar
xalloc-oversized #include "xalloc-oversized.h" --- 00gnulib.m4
zzgnulib.m4
stdint
xbinary-io #include "xbinary-io.h" xbinary-io.c 00gnulib.m4
zzgnulib.m4
binary-io
error
exitfail
extern-inline
gettext-h
stdbool
verify
xgetgroups #include "mgetgroups.h" xgetgroups.c 00gnulib.m4
zzgnulib.m4
gl_MODULE_INDICATOR([xgetgroups])
mgetgroups
xalloc
xhash #include "hash.h" xhash.c 00gnulib.m4
zzgnulib.m4
hash
xalloc
xmap #include "gl_xmap.h" gl_xmap.c 00gnulib.m4
zzgnulib.m4
map
extern-inline
stdbool
xalloc-die
xomap #include "gl_xomap.h" gl_xomap.c 00gnulib.m4
zzgnulib.m4
omap
extern-inline
stdbool
xalloc-die
xprintf-gnu #include "xprintf.h" --- 00gnulib.m4
zzgnulib.m4
xprintf
vprintf-gnu
vfprintf-gnu
xset #include "gl_xset.h" gl_xset.c 00gnulib.m4
zzgnulib.m4
set
extern-inline
stdbool
xalloc-die
xstdopen #include "xstdopen.h" xstdopen.c 00gnulib.m4
zzgnulib.m4
stdopen
error
gettext-h
exitfail
xstring-desc #include "xstring-desc.h" xstring-desc.c 00gnulib.m4
zzgnulib.m4
string-desc
xalloc-die
extern-inline
xvasprintf-gnu #include "xvasprintf.h" --- 00gnulib.m4
zzgnulib.m4
xvasprintf
vasprintf-gnu

Lone files - please create new modules containing them

lib/t-idcache
lib/timevar.def
lib/unictype/sy_c_whitespace.h
lib/unictype/sy_java_whitespace.h
m4/gnulib-common.m4
m4/gnulib-tool.m4
m4/locale-ar.m4
m4/locale-tr.m4
m4/pkg.m4
m4/semaphore.m4
m4/ulonglong.m4
m4/valgrind-tests.m4

Future developments

Ideally a module could consist of:
Generated by MODULES.html.sh from a git checkout as of 17 April 2023.