Gnulib Module List

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

Support for obsolete systems lacking ANSI C 89

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

Support for systems lacking ANSI C 89

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

Enhancements for ANSI C 89 functions

Diagnostics <assert.h>

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

Mathematics <math.h>

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

Input/output <stdio.h>

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

Memory management functions <stdlib.h>

calloc-gnu calloc function that is glibc compatible.
eealloc Memory allocation with expensive empty allocations (glibc compatible).
free Work around incompatibility on older systems where free (NULL) fails.
malloc-gnu malloc function that is glibc compatible.
realloc-gnu realloc function that is glibc compatible.
pagealign_alloc Memory allocation aligned on page boundaries.

Sorting functions <stdlib.h>

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

Date and time <time.h>

fprintftime like nstrftime, but output the formatted date to a FILE* stream
strftime nstrftime function: convert date and time to string, with GNU extensions.

Extra functions based on ANSI C 89

Memory management functions <stdlib.h>

xsize Checked size_t computations.
xalloc Memory allocation with out-of-memory checking. Also see xalloc-die.
xalloc-die Report a memory allocation failure and exit.
alloca Memory allocation on the stack.
alloca-opt Memory allocation on the stack, as an optional optimization. It allows using the alloca macro if and only if the autoconf tests define HAVE_ALLOCA.
malloca Safe automatic memory allocation.
xmalloca Safe automatic memory allocation with out of memory checking.
xmemdup0 Copy a block of arbitrary bytes, and append a trailing NUL.
safe-alloc A set of macros to make calls to alloc/calloc/realloc safer.

Integer arithmetic functions <stdlib.h>

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

Environment variables <stdlib.h>

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

Character handling <ctype.h>

c-ctype Character handling in C locale.

String handling <string.h>

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

Mathematics <math.h>

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

Numeric conversion functions <stdlib.h>

c-strtod Convert string to double in C locale.
c-strtold Convert string to long double in C locale.
xstrtod Convert string to double, with error checking.
xstrtol Convert string to long or unsigned long, with error checking.
xstrtoll Convert string to long long or unsigned long long, with error checking.
xstrtold Convert string to long double, with error checking.

Date and time <time.h>

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

Input/Output <stdio.h>

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

Signal handling <signal.h>

fatal-signal Emergency actions in case of a fatal signal.
raise Send a signal to the executing process.
strsignal strsignal function: return string describing signal.

Command-line arguments

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

Container data structures

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

Cryptographic computations (low-level)

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

Cryptographic computations (high-level)

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

Compiler warning management

ignore-value ignore a value to quiet a compiler warning

Misc

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

Support for systems lacking ISO C 99

Core language properties

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

Sizes of integer types <limits.h>

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

Variable arguments <stdarg.h>

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

Boolean type and values <stdbool.h>

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

Basic types <stddef.h>

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

Integer types and values <stdint.h>

stdint A <stdint.h> that nearly conforms to C99. Assumes typical host with 8-bit bytes, two's complement representation, and no padding or trap representations, with int widths equal to 8, 16, 32, and 64 bits. {uint,int}_fast{8,16,32,64}_t may not correspond to the fastest types available on the system. Macros are used instead of typedefs.

Input/output <stdio.h>

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

Process control, Numeric conversion functions <stdlib.h>

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

Unibyte characters <ctype.h>

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

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

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

String handling <string.h>

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

Extended multibyte and wide character utilities <wchar.h>

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

Wide character classification and mapping utilities <wctype.h>

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

Characteristics of floating types <float.h>

float A correct <float.h>.

Mathematics <math.h>

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

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>

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 C11

Core language properties

stdalign A <stdalign.h> that nearly conforms to ISO C11 and C++11.

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

Compatibility checks for POSIX:2008 functions

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

Enhancements for POSIX:2008 functions

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

Extra functions based on POSIX:2008

Input/output

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

Numeric conversion functions

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

File system functions

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

File system as inode set

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

File descriptor based Input/Output

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

File stream based Input/Output

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

Users and groups

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

Security

idpriv-drop Drop uid/gid privileges of the current process.
idpriv-droptemp Drop uid/gid privileges of the current process temporarily.
priv-set Query, remove or restore a Solaris privilege

Date and time

gethrxtime Get high resolution real time.
gettime Return current time, with nanosecond resolution.
posixtm Convert a date/time string (POSIX syntax) to linear time or broken-down time.
settime Set the current time, with nanosecond resolution.
usleep usleep function: pause execution of the current thread.
xnanosleep a more convenient interface to nanosleep

Networking functions

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

Multithreading

threadlib Access to multithreading primitives.
lock Locking in multithreaded situations.
tls Thread-local storage in multithreaded situations.
thread Creating and controlling threads.
yield Yielding the processor to other threads.
cond Condition variables for multithreading.
openmp Detection of OpenMP support.

Signal handling

c-stack Stack overflow handling, causing program exit.
libsigsegv Handle page faults in user mode.
sig2str Convert between signal names and signal numbers.
sigpipe Emulation of POSIX compatible SIGPIPE behaviour.
sigpipe-die Report a SIGPIPE signal and exit.

Internationalization functions

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

Unicode string functions

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

Executing programs

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

Java

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

C#

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

Misc

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

Support for building libraries and executables

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

Support for building documentation

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

Support for maintaining and releasing projects

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

Misc

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

Support for obsolete systems lacking ANSI C 89

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

Enhancements for ANSI C 89 functions

Diagnostics <assert.h>

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

Mathematics <math.h>

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

Input/output <stdio.h>

modules/ lib/ lib/ m4/  
Module Header Implementation Autoconf macro Depends on
fflush #include <stdio.h> fflush.c
stdio-impl.h
fflush.m4
00gnulib.m4
gl_FUNC_FFLUSH
if test $REPLACE_FFLUSH = 1; then
AC_LIBOBJ([fflush])
gl_PREREQ_FFLUSH
fi
gl_MODULE_INDICATOR([fflush])
gl_STDIO_MODULE_INDICATOR([fflush])
stdio
snippet/unused-parameter [test $REPLACE_FFLUSH = 1]
fpurge [test $REPLACE_FFLUSH = 1]
ftello [test $REPLACE_FFLUSH = 1]
freading [test $REPLACE_FFLUSH = 1]
lseek [test $REPLACE_FFLUSH = 1]
unistd [test $REPLACE_FFLUSH = 1]
fseeko [test $REPLACE_FFLUSH = 1]
fseterr #include "fseterr.h" fseterr.c
stdio-impl.h
fseterr.m4
00gnulib.m4
gl_FUNC_FSETERR
if test $ac_cv_func___fseterr = no; then
AC_LIBOBJ([fseterr])
fi
---
tmpfile #include <stdio.h> tmpfile.c tmpfile.m4
00gnulib.m4
gl_FUNC_TMPFILE
if test $REPLACE_TMPFILE = 1; then
AC_LIBOBJ([tmpfile])
gl_PREREQ_TMPFILE
fi
gl_STDIO_MODULE_INDICATOR([tmpfile])
stdio
largefile
pathmax [test $REPLACE_TMPFILE = 1]
tempname [test $REPLACE_TMPFILE = 1]
tmpdir [test $REPLACE_TMPFILE = 1]

Memory management functions <stdlib.h>

modules/ lib/ lib/ m4/  
Module Header Implementation Autoconf macro Depends on
calloc-gnu #include <stdlib.h> calloc.c calloc.m4
00gnulib.m4
gl_FUNC_CALLOC_GNU
if test $REPLACE_CALLOC = 1; then
AC_LIBOBJ([calloc])
fi
gl_MODULE_INDICATOR([calloc-gnu])
calloc-posix
eealloc #include <eealloc.h> eealloc.h
eealloc.c
eealloc.m4
malloc.m4
realloc.m4
00gnulib.m4
gl_EEALLOC
extern-inline
free #include <stdlib.h> free.c free.m4
00gnulib.m4
gl_FUNC_FREE
if test $gl_cv_func_free = no; then
AC_LIBOBJ([free])
gl_PREREQ_FREE
fi
---
malloc-gnu #include <stdlib.h> malloc.c 00gnulib.m4
gl_FUNC_MALLOC_GNU
if test $REPLACE_MALLOC = 1; then
AC_LIBOBJ([malloc])
fi
gl_MODULE_INDICATOR([malloc-gnu])
malloc-posix
realloc-gnu #include <stdlib.h> realloc.c 00gnulib.m4
gl_FUNC_REALLOC_GNU
if test $REPLACE_REALLOC = 1; then
AC_LIBOBJ([realloc])
fi
gl_MODULE_INDICATOR([realloc-gnu])
realloc-posix
pagealign_alloc #include "pagealign_alloc.h" pagealign_alloc.c mmap-anon.m4
pagealign_alloc.m4
00gnulib.m4
gl_PAGEALIGN_ALLOC
error
extensions
getpagesize
gettext-h
stdlib
xalloc
unistd

Sorting functions <stdlib.h>

modules/ lib/ lib/ m4/  
Module Header Implementation Autoconf macro Depends on
array-mergesort #include "array-mergesort.h" --- 00gnulib.m4 ---
mpsort #include "mpsort.h" mpsort.c mpsort.m4
00gnulib.m4
gl_MPSORT
---
qsort_r #include <stdlib.h> qsort.c
qsort_r.c
qsort_r.m4
00gnulib.m4
gl_FUNC_QSORT_R
if test $HAVE_QSORT_R = 0; then
AC_LIBOBJ([qsort])
elif test $REPLACE_QSORT_R = 1; then
AC_LIBOBJ([qsort_r])
fi
gl_STDLIB_MODULE_INDICATOR([qsort_r])
extensions
stdlib

Date and time <time.h>

modules/ lib/ lib/ m4/  
Module Header Implementation Autoconf macro Depends on
fprintftime #include "fprintftime.h" fprintftime.c 00gnulib.m4 stdio
strftime
strftime #include "strftime.h" strftime.c tm_gmtoff.m4
strftime.m4
00gnulib.m4
gl_FUNC_GNU_STRFTIME
extensions
stdbool
time_r

Extra functions based on ANSI C 89

Memory management functions <stdlib.h>

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

Integer arithmetic functions <stdlib.h>

modules/ lib/ lib/ m4/  
Module Header Implementation Autoconf macro Depends on
count-leading-zeros #include "count-leading-zeros.h" count-leading-zeros.c count-leading-zeros.m4
00gnulib.m4
gl_COUNT_LEADING_ZEROS
extern-inline
verify
count-one-bits #include "count-one-bits.h" count-one-bits.c count-one-bits.m4
00gnulib.m4
gl_COUNT_ONE_BITS
extern-inline
count-trailing-zeros #include "count-trailing-zeros.h" count-trailing-zeros.c count-trailing-zeros.m4
00gnulib.m4
gl_COUNT_TRAILING_ZEROS
extern-inline
ffs #include <strings.h> ffs.c ffs.m4
00gnulib.m4
gl_FUNC_FFS
if test $HAVE_FFS = 0; then
AC_LIBOBJ([ffs])
fi
gl_STRINGS_MODULE_INDICATOR([ffs])
strings
ffsl #include <string.h> ffsl.h
ffsl.c
ffsl.m4
00gnulib.m4
gl_FUNC_FFSL
if test $HAVE_FFSL = 0; then
AC_LIBOBJ([ffsl])
fi
gl_STRING_MODULE_INDICATOR([ffsl])
extensions
string
ffs [test $HAVE_FFSL = 0]
ffsll #include <string.h> ffsl.h
ffsll.c
ffsll.m4
00gnulib.m4
gl_FUNC_FFSLL
if test $HAVE_FFSLL = 0; then
AC_LIBOBJ([ffsll])
fi
gl_STRING_MODULE_INDICATOR([ffsll])
extensions
string
ffs [test $HAVE_FFSLL = 0]
gcd #include "gcd.h" gcd.c 00gnulib.m4 ---
minmax #include "minmax.h" --- minmax.m4
00gnulib.m4
gl_MINMAX
---

Environment variables <stdlib.h>

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

Character handling <ctype.h>

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

String handling <string.h>

modules/ lib/ lib/ m4/  
Module Header Implementation Autoconf macro Depends on
bcopy #include <strings.h> bcopy.c 00gnulib.m4
AC_REPLACE_FUNCS(bcopy)
strings
memchr #include <string.h> memchr.c
memchr.valgrind
memchr.m4
mmap-anon.m4
00gnulib.m4
gl_FUNC_MEMCHR
if test $HAVE_MEMCHR = 0 || test $REPLACE_MEMCHR = 1; then
AC_LIBOBJ([memchr])
gl_PREREQ_MEMCHR
fi
gl_STRING_MODULE_INDICATOR([memchr])
extensions
string
memchr-obsolete
memchr2 #include "memchr2.h" memchr2.c
memchr2.valgrind
00gnulib.m4 stdint
memchr
memcmp2 #include "memcmp2.h" memcmp2.c 00gnulib.m4 ---
memmem #include <string.h> --- 00gnulib.m4
gl_FUNC_MEMMEM
if test $HAVE_MEMMEM = 0 || test $REPLACE_MEMMEM = 1; then
AC_LIBOBJ([memmem])
fi
memmem-simple
memmem-simple #include <string.h> str-two-way.h
memmem.c
memmem.m4
00gnulib.m4
gl_FUNC_MEMMEM_SIMPLE
if test $HAVE_MEMMEM = 0 || test $REPLACE_MEMMEM = 1; then
AC_LIBOBJ([memmem])
fi
gl_STRING_MODULE_INDICATOR([memmem])
extensions
string
stdint
memchr
memcmp
mempcpy #include <string.h> mempcpy.c mempcpy.m4
00gnulib.m4
gl_FUNC_MEMPCPY
if test $HAVE_MEMPCPY = 0; then
AC_LIBOBJ([mempcpy])
gl_PREREQ_MEMPCPY
fi
gl_STRING_MODULE_INDICATOR([mempcpy])
extensions
string
memrchr #include <string.h> memrchr.c memrchr.m4
00gnulib.m4
gl_FUNC_MEMRCHR
if test $ac_cv_func_memrchr = no; then
AC_LIBOBJ([memrchr])
gl_PREREQ_MEMRCHR
fi
gl_STRING_MODULE_INDICATOR([memrchr])
extensions
string
amemxfrm #include "amemxfrm.h" amemxfrm.c 00gnulib.m4 ---
rawmemchr #include <string.h> rawmemchr.c
rawmemchr.valgrind
rawmemchr.m4
00gnulib.m4
gl_FUNC_RAWMEMCHR
if test $HAVE_RAWMEMCHR = 0; then
AC_LIBOBJ([rawmemchr])
gl_PREREQ_RAWMEMCHR
fi
gl_STRING_MODULE_INDICATOR([rawmemchr])
extensions
string
stpcpy #include <string.h> stpcpy.c stpcpy.m4
00gnulib.m4
gl_FUNC_STPCPY
if test $HAVE_STPCPY = 0; then
AC_LIBOBJ([stpcpy])
gl_PREREQ_STPCPY
fi
gl_STRING_MODULE_INDICATOR([stpcpy])
extensions
string
stpncpy #include <string.h> stpncpy.c stpncpy.m4
00gnulib.m4
gl_FUNC_STPNCPY
if test $HAVE_STPNCPY = 0 || test $REPLACE_STPNCPY = 1; then
AC_LIBOBJ([stpncpy])
gl_PREREQ_STPNCPY
fi
gl_STRING_MODULE_INDICATOR([stpncpy])
extensions
string
c-strcase #include "c-strcase.h" c-strcasecmp.c
c-strncasecmp.c
00gnulib.m4 c-ctype
strcase #include <strings.h> strcasecmp.c
strncasecmp.c
strcase.m4
00gnulib.m4
gl_STRCASE
if test $HAVE_STRCASECMP = 0; then
AC_LIBOBJ([strcasecmp])
gl_PREREQ_STRCASECMP
fi
if test $HAVE_STRNCASECMP = 0; then
AC_LIBOBJ([strncasecmp])
gl_PREREQ_STRNCASECMP
fi
strings
c-strcaseeq #include "c-strcaseeq.h" --- 00gnulib.m4 c-strcase
c-ctype
c-strcasestr #include "c-strcasestr.h" c-strcasestr.c
str-two-way.h
00gnulib.m4 c-ctype
c-strcase
stdbool
memchr
memcmp
strcasestr #include <string.h> --- 00gnulib.m4
gl_FUNC_STRCASESTR
if test $HAVE_STRCASESTR = 0 || test $REPLACE_STRCASESTR = 1; then
AC_LIBOBJ([strcasestr])
gl_PREREQ_STRCASESTR
fi
strcasestr-simple
strcasestr-simple #include <string.h> strcasestr.c
str-two-way.h
strcasestr.m4
00gnulib.m4
gl_FUNC_STRCASESTR_SIMPLE
if test $HAVE_STRCASESTR = 0 || test $REPLACE_STRCASESTR = 1; then
AC_LIBOBJ([strcasestr])
gl_PREREQ_STRCASESTR
fi
gl_STRING_MODULE_INDICATOR([strcasestr])
string
stdbool
strcase
memchr
memcmp
extensions
strchrnul #include <string.h> strchrnul.c
strchrnul.valgrind
strchrnul.m4
00gnulib.m4
gl_FUNC_STRCHRNUL
if test $HAVE_STRCHRNUL = 0 || test $REPLACE_STRCHRNUL = 1; then
AC_LIBOBJ([strchrnul])
gl_PREREQ_STRCHRNUL
fi
gl_STRING_MODULE_INDICATOR([strchrnul])
string
extensions
rawmemchr [test $HAVE_STRCHRNUL = 0 || test $REPLACE_STRCHRNUL = 1]
streq #include "streq.h" --- 00gnulib.m4 ---
strerror_r-posix #include <string.h> strerror_r.c strerror_r.m4
00gnulib.m4
gl_FUNC_STRERROR_R
if test $HAVE_DECL_STRERROR_R = 0 || test $REPLACE_STRERROR_R = 1; then
AC_LIBOBJ([strerror_r])
gl_PREREQ_STRERROR_R
fi
gl_STRING_MODULE_INDICATOR([strerror_r])
string
extensions
errno [test $HAVE_DECL_STRERROR_R = 0 || test $REPLACE_STRERROR_R = 1]
lock [test $HAVE_DECL_STRERROR_R = 0 || test $REPLACE_STRERROR_R = 1]
strerror-override [test $HAVE_DECL_STRERROR_R = 0 || test $REPLACE_STRERROR_R = 1]
strnlen #include <string.h> strnlen.c strnlen.m4
00gnulib.m4
gl_FUNC_STRNLEN
if test $HAVE_DECL_STRNLEN = 0 || test $REPLACE_STRNLEN = 1; then
AC_LIBOBJ([strnlen])
gl_PREREQ_STRNLEN
fi

gl_STRING_MODULE_INDICATOR([strnlen])
string
extensions
memchr-obsolete [test $HAVE_DECL_STRNLEN = 0 || test $REPLACE_STRNLEN = 1]
strnlen1 #include "strnlen1.h" strnlen1.c 00gnulib.m4 memchr
strndup #include <string.h> strndup.c strndup.m4
00gnulib.m4
gl_FUNC_STRNDUP
if test $HAVE_STRNDUP = 0 || test $REPLACE_STRNDUP = 1; then
AC_LIBOBJ([strndup])
fi
gl_STRING_MODULE_INDICATOR([strndup])
string
extensions
strnlen [test $HAVE_STRNDUP = 0 || test $REPLACE_STRNDUP = 1]
strsep #include <string.h> strsep.c strsep.m4
00gnulib.m4
gl_FUNC_STRSEP
if test $HAVE_STRSEP = 0; then
AC_LIBOBJ([strsep])
gl_PREREQ_STRSEP
fi
gl_STRING_MODULE_INDICATOR([strsep])
string
extensions
strpbrk [test $HAVE_STRSEP = 0]
strstr #include <string.h> --- 00gnulib.m4
gl_FUNC_STRSTR
if test $REPLACE_STRSTR = 1; then
AC_LIBOBJ([strstr])
fi
strstr-simple
strstr-simple #include <string.h> str-two-way.h
strstr.c
strstr.m4
00gnulib.m4
gl_FUNC_STRSTR_SIMPLE
if test $REPLACE_STRSTR = 1; then
AC_LIBOBJ([strstr])
fi
gl_STRING_MODULE_INDICATOR([strstr])
string
stdbool [test $REPLACE_STRSTR = 1]
memchr [test $REPLACE_STRSTR = 1]
memcmp [test $REPLACE_STRSTR = 1]
c-strstr #include "c-strstr.h" c-strstr.c 00gnulib.m4 strstr
astrxfrm #include "astrxfrm.h" astrxfrm.c 00gnulib.m4 ---
trim #include "trim.h" trim.c 00gnulib.m4 xalloc
mbchar
mbiter
memmove
strdup
fstrcmp #include "fstrcmp.h" fstrcmp.c 00gnulib.m4 diffseq
lock
tls
minmax
xalloc
xstrndup #include "xstrndup.h" xstrndup.c xstrndup.m4
00gnulib.m4
gl_XSTRNDUP
strndup
xalloc

Mathematics <math.h>

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

Numeric conversion functions <stdlib.h>

modules/ lib/ lib/ m4/  
Module Header Implementation Autoconf macro Depends on
c-strtod #include "c-strtod.h" c-strtod.c c-strtod.m4
00gnulib.m4
gl_C_STRTOD
extensions
locale
strdup-posix
c-strtold #include "c-strtod.h" c-strtod.c
c-strtold.c
c-strtod.m4
00gnulib.m4
gl_C_STRTOLD
extensions
locale
strdup-posix
xstrtod #include "xstrtod.h" xstrtod.c xstrtod.m4
00gnulib.m4
gl_XSTRTOD
stdbool
xstrtol #include "xstrtol.h" xstrtol.c
xstrtoul.c
xstrtol-error.c
xstrtol.m4
00gnulib.m4
gl_XSTRTOL
assure
exitfail
error
getopt-gnu
gettext-h
intprops
inttypes-incomplete
xstrtoll #include "xstrtol.h" xstrtoll.c
xstrtoull.c
00gnulib.m4
AC_LIBOBJ([xstrtoll])
AC_LIBOBJ([xstrtoull])
AC_TYPE_LONG_LONG_INT
test $ac_cv_type_long_long_int = no \
&& AC_MSG_ERROR(
[you lack long long support; required by gnulib's xstrtoll module])
strtoll
strtoull
xstrtol
xstrtold #include "xstrtod.h" xstrtod.c
xstrtold.c
xstrtod.m4
00gnulib.m4
gl_XSTRTOLD
stdbool

Date and time <time.h>

modules/ lib/ lib/ m4/  
Module Header Implementation Autoconf macro Depends on
mktime-internal #include "mktime-internal.h" mktime.c 00gnulib.m4
gl_FUNC_MKTIME_INTERNAL
if test $REPLACE_MKTIME = 1; then
AC_LIBOBJ([mktime])
gl_PREREQ_MKTIME
fi
mktime
parse-datetime #include "parse-datetime.h" parse-datetime.y bison.m4
tm_gmtoff.m4
parse-datetime.m4
00gnulib.m4
gl_PARSE_DATETIME
c-ctype
stdbool
gettime
intprops
mktime
setenv
unsetenv
time
verify
xalloc
timegm #include <time.h> mktime-internal.h
timegm.c
timegm.m4
00gnulib.m4
gl_FUNC_TIMEGM
if test $HAVE_TIMEGM = 0 || test $REPLACE_TIMEGM = 1; then
AC_LIBOBJ([timegm])
gl_PREREQ_TIMEGM
fi
gl_TIME_MODULE_INDICATOR([timegm])
time
mktime-internal [test $HAVE_TIMEGM = 0 || test $REPLACE_TIMEGM = 1]
time_r [test $HAVE_TIMEGM = 0 || test $REPLACE_TIMEGM = 1]
tzset #include <time.h> --- tzset.m4
00gnulib.m4
gl_FUNC_TZSET
gettimeofday

Input/Output <stdio.h>

modules/ lib/ lib/ m4/  
Module Header Implementation Autoconf macro Depends on
unlocked-io #include "unlocked-io.h" --- unlocked-io.m4
00gnulib.m4
gl_FUNC_GLIBC_UNLOCKED_IO
extensions
fwriteerror #include "fwriteerror.h" fwriteerror.c 00gnulib.m4
gl_MODULE_INDICATOR([fwriteerror])
errno
stdbool
vasnprintf #include "vasnprintf.h" float+.h
printf-args.h
printf-args.c
printf-parse.h
printf-parse.c
vasnprintf.c
asnprintf.c
wchar_t.m4
wint_t.m4
longlong.m4
intmax_t.m4
stdint_h.m4
inttypes_h.m4
vasnprintf.m4
printf.m4
math_h.m4
exponentd.m4
00gnulib.m4
gl_FUNC_VASNPRINTF
alloca-opt
float
stdint
xsize
errno
memchr
verify
wchar
vasprintf #include <stdio.h> vasprintf.c
asprintf.c
vasprintf.m4
00gnulib.m4
gl_FUNC_VASPRINTF
gl_STDIO_MODULE_INDICATOR([vasprintf])
m4_ifdef([AM_XGETTEXT_OPTION],
[AM_][XGETTEXT_OPTION([--flag=asprintf:2:c-format])
AM_][XGETTEXT_OPTION([--flag=vasprintf:2:c-format])])
stdio
extensions
vasnprintf [test $HAVE_VASPRINTF = 0 || test $REPLACE_VASPRINTF = 1]
errno [test $HAVE_VASPRINTF = 0 || test $REPLACE_VASPRINTF = 1]
xprintf #include "xprintf.h" xprintf.c 00gnulib.m4
m4_ifdef([AM_XGETTEXT_OPTION],
[AM_][XGETTEXT_OPTION([--flag=xprintf:1:c-format])
AM_][XGETTEXT_OPTION([--flag=xvprintf:1:c-format])
AM_][XGETTEXT_OPTION([--flag=xfprintf:2:c-format])
AM_][XGETTEXT_OPTION([--flag=xvfprintf:2:c-format])])
error
exitfail
gettext-h
stdarg
stdio
xvasprintf #include "xvasprintf.h" xvasprintf.c
xasprintf.c
xalloc.h
xvasprintf.m4
00gnulib.m4
gl_XVASPRINTF
m4_ifdef([AM_XGETTEXT_OPTION],
[AM_][XGETTEXT_OPTION([--flag=xasprintf:1:c-format])])
vasprintf
xalloc-die
xsize
stdarg
errno

Signal handling <signal.h>

modules/ lib/ lib/ m4/  
Module Header Implementation Autoconf macro Depends on
fatal-signal #include "fatal-signal.h" fatal-signal.c fatal-signal.m4
sig_atomic_t.m4
00gnulib.m4
gl_FATAL_SIGNAL
xalloc
stdbool
unistd
sigaction
sigprocmask
raise
raise #include <signal.h> raise.c raise.m4
00gnulib.m4
gl_FUNC_RAISE
if test $HAVE_RAISE = 0 || test $REPLACE_RAISE = 1; then
AC_LIBOBJ([raise])
gl_PREREQ_RAISE
fi
gl_SIGNAL_MODULE_INDICATOR([raise])
signal-h
msvc-inval [test $HAVE_RAISE = 0 || test $REPLACE_RAISE = 1]
strsignal #include <string.h> strsignal.c
siglist.h
strsignal.m4
00gnulib.m4
gl_FUNC_STRSIGNAL
if test $HAVE_STRSIGNAL = 0 || test $REPLACE_STRSIGNAL = 1; then
AC_LIBOBJ([strsignal])
gl_PREREQ_STRSIGNAL
fi
gl_STRING_MODULE_INDICATOR([strsignal])
string
extensions
gettext-h [test $HAVE_STRSIGNAL = 0 || test $REPLACE_STRSIGNAL = 1]
lock [test $HAVE_STRSIGNAL = 0 || test $REPLACE_STRSIGNAL = 1]
tls [test $HAVE_STRSIGNAL = 0 || test $REPLACE_STRSIGNAL = 1]
snprintf [test $HAVE_STRSIGNAL = 0 || test $REPLACE_STRSIGNAL = 1]
memset [test $HAVE_STRSIGNAL = 0 || test $REPLACE_STRSIGNAL = 1]

Command-line arguments

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

Container data structures

modules/ lib/ lib/ m4/  
Module Header Implementation Autoconf macro Depends on
list #include "gl_list.h" gl_list.c 00gnulib.m4 extern-inline
stdbool
xlist #include "gl_xlist.h" gl_xlist.c 00gnulib.m4 list
extern-inline
stdbool
xalloc-die
array-list #include "gl_array_list.h" gl_array_list.c 00gnulib.m4 list
xsize
carray-list #include "gl_carray_list.h" gl_carray_list.c 00gnulib.m4 list
xsize
linked-list #include "gl_linked_list.h" gl_linked_list.c
gl_anylinked_list1.h
gl_anylinked_list2.h
00gnulib.m4 list
avltree-list #include "gl_avltree_list.h" gl_avltree_list.c
gl_anyavltree_list1.h
gl_anyavltree_list2.h
gl_anytree_list1.h
gl_anytree_list2.h
00gnulib.m4 list
rbtree-list #include "gl_rbtree_list.h" gl_rbtree_list.c
gl_anyrbtree_list1.h
gl_anyrbtree_list2.h
gl_anytree_list1.h
gl_anytree_list2.h
00gnulib.m4 list
linkedhash-list #include "gl_linkedhash_list.h" gl_linkedhash_list.c
gl_anyhash_list1.h
gl_anyhash_list2.h
gl_anylinked_list1.h
gl_anylinked_list2.h
00gnulib.m4 list
stdint
xsize
avltreehash-list #include "gl_avltreehash_list.h" gl_avltreehash_list.c
gl_anyhash_list1.h
gl_anyhash_list2.h
gl_anyavltree_list1.h
gl_anyavltree_list2.h
gl_anytree_list1.h
gl_anytree_list2.h
gl_anytreehash_list1.h
gl_anytreehash_list2.h
00gnulib.m4 list
avltree-oset
stdint
xsize
rbtreehash-list #include "gl_rbtreehash_list.h" gl_rbtreehash_list.c
gl_anyhash_list1.h
gl_anyhash_list2.h
gl_anyrbtree_list1.h
gl_anyrbtree_list2.h
gl_anytree_list1.h
gl_anytree_list2.h
gl_anytreehash_list1.h
gl_anytreehash_list2.h
00gnulib.m4 list
rbtree-oset
stdint
xsize
sublist #include "gl_sublist.h" gl_sublist.c 00gnulib.m4 list
xsublist #include "gl_xsublist.h" gl_xsublist.c 00gnulib.m4 sublist
extern-inline
xalloc-die
oset #include "gl_oset.h" gl_oset.c 00gnulib.m4 extern-inline
stdbool
xoset #include "gl_xoset.h" gl_xoset.c 00gnulib.m4 oset
extern-inline
stdbool
xalloc-die
array-oset #include "gl_array_oset.h" gl_array_oset.c 00gnulib.m4 oset
xsize
avltree-oset #include "gl_avltree_oset.h" gl_avltree_oset.c
gl_anytree_oset.h
00gnulib.m4 oset
rbtree-oset #include "gl_rbtree_oset.h" gl_rbtree_oset.c
gl_anytree_oset.h
00gnulib.m4 oset

Cryptographic computations (low-level)

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

Cryptographic computations (high-level)

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

Compiler warning management

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

Misc

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

Support for systems lacking ISO C 99

Core language properties

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

Sizes of integer types <limits.h>

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

Variable arguments <stdarg.h>

modules/ lib/ lib/ m4/  
Module Header Implementation Autoconf macro Depends on
stdarg #include <stdarg.h> stdarg.in.h stdarg.m4
00gnulib.m4
gl_STDARG_H
include_next

Boolean type and values <stdbool.h>

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

Basic types <stddef.h>

modules/ lib/ lib/ m4/  
Module Header Implementation Autoconf macro Depends on
stddef #include <stddef.h> stddef.in.h stddef_h.m4
wchar_t.m4
00gnulib.m4
gl_STDDEF_H
include_next

Integer types and values <stdint.h>

modules/ lib/ lib/ m4/  
Module Header Implementation Autoconf macro Depends on
stdint #include <stdint.h> stdint.in.h stdint.m4
longlong.m4
00gnulib.m4
gl_STDINT_H
include_next
multiarch
sys_types

Input/output <stdio.h>

modules/ lib/ lib/ m4/  
Module Header Implementation Autoconf macro Depends on
stdio #include <stdio.h> stdio.in.h stdio_h.m4
00gnulib.m4
gl_STDIO_H
extensions
include_next
snippet/arg-nonnull
snippet/c++defs
snippet/warn-on-use
ssize_t
stddef
sys_types
snprintf #include <stdio.h> snprintf.c snprintf.m4
printf.m4
00gnulib.m4
gl_FUNC_SNPRINTF
gl_STDIO_MODULE_INDICATOR([snprintf])
gl_MODULE_INDICATOR([snprintf])
stdio
vasnprintf [test $ac_cv_func_snprintf = no || test $REPLACE_SNPRINTF = 1]
errno [test $ac_cv_func_snprintf = no || test $REPLACE_SNPRINTF = 1]
vsnprintf #include <stdio.h> vsnprintf.c vsnprintf.m4
printf.m4
00gnulib.m4
gl_FUNC_VSNPRINTF
gl_STDIO_MODULE_INDICATOR([vsnprintf])
stdio
vasnprintf [test $ac_cv_func_vsnprintf = no || test $REPLACE_VSNPRINTF = 1]
errno [test $ac_cv_func_vsnprintf = no || test $REPLACE_VSNPRINTF = 1]

Process control, Numeric conversion functions <stdlib.h>

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

Unibyte characters <ctype.h>

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

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

modules/ lib/ lib/ m4/  
Module Header Implementation Autoconf macro Depends on
imaxabs #include <inttypes.h> imaxabs.c imaxabs.m4
00gnulib.m4
gl_FUNC_IMAXABS
if test $ac_cv_func_imaxabs = no; then
AC_LIBOBJ([imaxabs])
gl_PREREQ_IMAXABS
fi
gl_INTTYPES_MODULE_INDICATOR([imaxabs])
inttypes-incomplete
imaxdiv #include <inttypes.h> imaxdiv.c imaxdiv.m4
00gnulib.m4
gl_FUNC_IMAXDIV
if test $ac_cv_func_imaxdiv = no; then
AC_LIBOBJ([imaxdiv])
gl_PREREQ_IMAXDIV
fi
gl_INTTYPES_MODULE_INDICATOR([imaxdiv])
inttypes-incomplete
inttypes #include <inttypes.h> --- inttypes-pri.m4
00gnulib.m4
gl_INTTYPES_H
inttypes-incomplete
strtoimax #include <inttypes.h> strtoimax.c strtoimax.m4
longlong.m4
00gnulib.m4
gl_FUNC_STRTOIMAX
if test $HAVE_DECL_STRTOIMAX = 0 || test $REPLACE_STRTOIMAX = 1; then
AC_LIBOBJ([strtoimax])
gl_PREREQ_STRTOIMAX
fi
gl_INTTYPES_MODULE_INDICATOR([strtoimax])
inttypes-incomplete
verify [test $HAVE_DECL_STRTOIMAX = 0 || test $REPLACE_STRTOIMAX = 1]
stdint [test $HAVE_DECL_STRTOIMAX = 0 || test $REPLACE_STRTOIMAX = 1]
strtoll [{ test $HAVE_DECL_STRTOIMAX = 0 || test $REPLACE_STRTOIMAX = 1; } && test $ac_cv_type_long_long_int = yes]
strtoumax #include <inttypes.h> strtoimax.c
strtoumax.c
longlong.m4
strtoumax.m4
00gnulib.m4
gl_FUNC_STRTOUMAX
if test $HAVE_DECL_STRTOUMAX = 0 || test $REPLACE_STRTOUMAX = 1; then
AC_LIBOBJ([strtoumax])
gl_PREREQ_STRTOUMAX
fi
gl_INTTYPES_MODULE_INDICATOR([strtoumax])
inttypes-incomplete
verify [test $HAVE_DECL_STRTOUMAX = 0 || test $REPLACE_STRTOUMAX = 1]
stdint [test $HAVE_DECL_STRTOUMAX = 0 || test $REPLACE_STRTOUMAX = 1]
strtoull [{ test $HAVE_DECL_STRTOUMAX = 0 || test $REPLACE_STRTOUMAX = 1; } && test $ac_cv_type_unsigned_long_long_int = yes]

String handling <string.h>

modules/ lib/ lib/ m4/  
Module Header Implementation Autoconf macro Depends on
strncat #include <string.h> strncat.c strncat.m4
mmap-anon.m4
00gnulib.m4
gl_FUNC_STRNCAT
if test $REPLACE_STRNCAT = 1; then
AC_LIBOBJ([strncat])
gl_PREREQ_STRNCAT
fi
gl_STRING_MODULE_INDICATOR([strncat])
string

Extended multibyte and wide character utilities <wchar.h>

modules/ lib/ lib/ m4/  
Module Header Implementation Autoconf macro Depends on
wchar #include <wchar.h> wchar.in.h wchar_h.m4
wint_t.m4
00gnulib.m4
gl_WCHAR_H
include_next
snippet/arg-nonnull
snippet/c++defs
snippet/warn-on-use
stddef
btowc #include <wchar.h> btowc.c btowc.m4
locale-fr.m4
00gnulib.m4
gl_FUNC_BTOWC
if test $HAVE_BTOWC = 0 || test $REPLACE_BTOWC = 1; then
AC_LIBOBJ([btowc])
gl_PREREQ_BTOWC
fi
gl_WCHAR_MODULE_INDICATOR([btowc])
wchar
mbtowc [test $HAVE_BTOWC = 0 || test $REPLACE_BTOWC = 1]
wctob #include <wchar.h> wctob.c wctob.m4
locale-fr.m4
codeset.m4
00gnulib.m4
gl_FUNC_WCTOB
if test $HAVE_WCTOB = 0 || test $REPLACE_WCTOB = 1; then
AC_LIBOBJ([wctob])
gl_PREREQ_WCTOB
fi
gl_WCHAR_MODULE_INDICATOR([wctob])
wchar
wctomb [test $HAVE_WCTOB = 0 || test $REPLACE_WCTOB = 1]
mbsinit #include <wchar.h> mbsinit.c mbsinit.m4
mbstate_t.m4
00gnulib.m4
gl_FUNC_MBSINIT
if test $HAVE_MBSINIT = 0 || test $REPLACE_MBSINIT = 1; then
AC_LIBOBJ([mbsinit])
gl_PREREQ_MBSINIT
fi
gl_WCHAR_MODULE_INDICATOR([mbsinit])
wchar
extensions
mbrtowc [test $HAVE_MBSINIT = 0 || test $REPLACE_MBSINIT = 1]
verify [test $HAVE_MBSINIT = 0 || test $REPLACE_MBSINIT = 1]
mbrlen #include <wchar.h> mbrlen.c mbrlen.m4
mbstate_t.m4
00gnulib.m4
gl_FUNC_MBRLEN
if test $HAVE_MBRLEN = 0 || test $REPLACE_MBRLEN = 1; then
AC_LIBOBJ([mbrlen])
gl_PREREQ_MBRLEN
fi
gl_WCHAR_MODULE_INDICATOR([mbrlen])
wchar
extensions
mbrtowc [test $HAVE_MBRLEN = 0 || test $REPLACE_MBRLEN = 1]
mbrtowc #include <wchar.h> mbrtowc.c mbrtowc.m4
mbstate_t.m4
locale-fr.m4
locale-ja.m4
locale-zh.m4
codeset.m4
00gnulib.m4
gl_FUNC_MBRTOWC
if test $HAVE_MBRTOWC = 0 || test $REPLACE_MBRTOWC = 1; then
AC_LIBOBJ([mbrtowc])
gl_PREREQ_MBRTOWC
fi
gl_WCHAR_MODULE_INDICATOR([mbrtowc])
wchar
extensions
mbsinit [test $HAVE_MBRTOWC = 0 || test $REPLACE_MBRTOWC = 1]
localcharset [test $HAVE_MBRTOWC = 0 || test $REPLACE_MBRTOWC = 1]
streq [test $HAVE_MBRTOWC = 0 || test $REPLACE_MBRTOWC = 1]
verify [test $HAVE_MBRTOWC = 0 || test $REPLACE_MBRTOWC = 1]
mbsrtowcs #include <wchar.h> mbsrtowcs.c
mbsrtowcs-impl.h
mbsrtowcs-state.c
mbsrtowcs.m4
mbstate_t.m4
locale-fr.m4
locale-ja.m4
locale-zh.m4
codeset.m4
00gnulib.m4
gl_FUNC_MBSRTOWCS
if test $HAVE_MBSRTOWCS = 0 || test $REPLACE_MBSRTOWCS = 1; then
AC_LIBOBJ([mbsrtowcs])
AC_LIBOBJ([mbsrtowcs-state])
gl_PREREQ_MBSRTOWCS
fi
gl_WCHAR_MODULE_INDICATOR([mbsrtowcs])
wchar
extensions
mbrtowc [test $HAVE_MBSRTOWCS = 0 || test $REPLACE_MBSRTOWCS = 1]
strnlen1 [test $HAVE_MBSRTOWCS = 0 || test $REPLACE_MBSRTOWCS = 1]
wcrtomb #include <wchar.h> wcrtomb.c wcrtomb.m4
mbrtowc.m4
mbstate_t.m4
locale-fr.m4
locale-ja.m4
locale-zh.m4
codeset.m4
00gnulib.m4
gl_FUNC_WCRTOMB
if test $HAVE_WCRTOMB = 0 || test $REPLACE_WCRTOMB = 1; then
AC_LIBOBJ([wcrtomb])
gl_PREREQ_WCRTOMB
fi
gl_WCHAR_MODULE_INDICATOR([wcrtomb])
wchar
extensions
mbsinit [test $HAVE_WCRTOMB = 0 || test $REPLACE_WCRTOMB = 1]
wcsrtombs #include <wchar.h> wcsrtombs.c
wcsrtombs-impl.h
wcsrtombs-state.c
wcsrtombs.m4
mbrtowc.m4
mbstate_t.m4
locale-fr.m4
locale-ja.m4
locale-zh.m4
codeset.m4
00gnulib.m4
gl_FUNC_WCSRTOMBS
if test $HAVE_WCSRTOMBS = 0 || test $REPLACE_WCSRTOMBS = 1; then
AC_LIBOBJ([wcsrtombs])
AC_LIBOBJ([wcsrtombs-state])
gl_PREREQ_WCSRTOMBS
fi
gl_WCHAR_MODULE_INDICATOR([wcsrtombs])
wchar
extensions
wcrtomb [test $HAVE_WCSRTOMBS = 0 || test $REPLACE_WCSRTOMBS = 1]

Wide character classification and mapping utilities <wctype.h>

modules/ lib/ lib/ m4/  
Module Header Implementation Autoconf macro Depends on
wctype #include <wctype.h> wctype.c
wctype-impl.h
wctype.m4
00gnulib.m4
gl_FUNC_WCTYPE
if test $HAVE_WCTYPE = 0; then
AC_LIBOBJ([wctype])
fi
gl_WCTYPE_MODULE_INDICATOR([wctype])
wctype-h
iswblank [test $HAVE_WCTYPE = 0]

Characteristics of floating types <float.h>

modules/ lib/ lib/ m4/  
Module Header Implementation Autoconf macro Depends on
float #include <float.h> float.in.h
float.c
itold.c
float_h.m4
00gnulib.m4
gl_FLOAT_H
if test $REPLACE_FLOAT_LDBL = 1; then
AC_LIBOBJ([float])
fi
if test $REPLACE_ITOLD = 1; then
AC_LIBOBJ([itold])
fi
include_next

Mathematics <math.h>

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

Enhancements for ISO C 99 functions

Input/output <stdio.h>

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

Extra functions based on ISO C 99

Mathematics <math.h>

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

Numeric conversion functions <stdlib.h>

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

Extended multibyte and wide character utilities <wchar.h>

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

Support for systems lacking ISO C11

Core language properties

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

Support for obsolete systems lacking POSIX:2008

modules/ lib/ lib/ m4/  
Module Header Implementation Autoconf macro Depends on
strdup #include <string.h> strdup.c strdup.m4
00gnulib.m4
gl_FUNC_STRDUP
if test $ac_cv_func_strdup = no; then
AC_LIBOBJ([strdup])
gl_PREREQ_STRDUP
fi
gl_STRING_MODULE_INDICATOR([strdup])
string
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
AC_REQUIRE([gl_HEADER_SYS_SOCKET])
if test "$ac_cv_header_winsock2_h" = yes; then
AC_LIBOBJ([accept])
fi
gl_SYS_SOCKET_MODULE_INDICATOR([accept])
sys_socket
socketlib
errno [test "$ac_cv_header_winsock2_h" = yes]
msvc-nothrow [test "$ac_cv_header_winsock2_h" = yes]
alphasort #include <dirent.h> alphasort.c alphasort.m4
00gnulib.m4
gl_FUNC_ALPHASORT
if test $HAVE_ALPHASORT = 0; then
AC_LIBOBJ([alphasort])
gl_PREREQ_ALPHASORT
fi
gl_DIRENT_MODULE_INDICATOR([alphasort])
dirent
extensions
arpa_inet #include <arpa/inet.h> arpa_inet.in.h arpa_inet_h.m4
00gnulib.m4
gl_HEADER_ARPA_INET
AC_PROG_MKDIR_P
include_next
snippet/arg-nonnull
snippet/c++defs
snippet/warn-on-use
sys_socket
bind #include <sys/socket.h> bind.c
w32sock.h
00gnulib.m4
AC_REQUIRE([gl_HEADER_SYS_SOCKET])
if test "$ac_cv_header_winsock2_h" = yes; then
AC_LIBOBJ([bind])
fi
gl_SYS_SOCKET_MODULE_INDICATOR([bind])
sys_socket
socketlib
errno [test "$ac_cv_header_winsock2_h" = yes]
msvc-nothrow [test "$ac_cv_header_winsock2_h" = yes]
calloc-posix #include <stdlib.h> calloc.c calloc.m4
malloc.m4
00gnulib.m4
gl_FUNC_CALLOC_POSIX
if test $REPLACE_CALLOC = 1; then
AC_LIBOBJ([calloc])
fi
gl_STDLIB_MODULE_INDICATOR([calloc-posix])
stdlib
chown #include <unistd.h> chown.c
fchown-stub.c
chown.m4
00gnulib.m4
gl_FUNC_CHOWN
if test $HAVE_CHOWN = 0 || test $REPLACE_CHOWN = 1; then
AC_LIBOBJ([chown])
fi
if test $REPLACE_CHOWN = 1 && test $ac_cv_func_fchown = no; then
AC_LIBOBJ([fchown-stub])
fi
gl_UNISTD_MODULE_INDICATOR([chown])
unistd
fstat [test $HAVE_CHOWN = 0 || test $REPLACE_CHOWN = 1]
open [test $HAVE_CHOWN = 0 || test $REPLACE_CHOWN = 1]
stat [test $HAVE_CHOWN = 0 || test $REPLACE_CHOWN = 1]
stdbool [test $HAVE_CHOWN = 0 || test $REPLACE_CHOWN = 1]
sys_stat [test $HAVE_CHOWN = 0 || test $REPLACE_CHOWN = 1]
close #include <unistd.h> close.c close.m4
00gnulib.m4
gl_FUNC_CLOSE
if test $REPLACE_CLOSE = 1; then
AC_LIBOBJ([close])
fi
gl_UNISTD_MODULE_INDICATOR([close])
unistd
fd-hook [test $REPLACE_CLOSE = 1]
msvc-inval [test $REPLACE_CLOSE = 1]
connect #include <sys/socket.h> connect.c
w32sock.h
00gnulib.m4
AC_REQUIRE([gl_HEADER_SYS_SOCKET])
if test "$ac_cv_header_winsock2_h" = yes; then
AC_LIBOBJ([connect])
fi
gl_SYS_SOCKET_MODULE_INDICATOR([connect])
sys_socket
socketlib
errno [test "$ac_cv_header_winsock2_h" = yes]
msvc-nothrow [test "$ac_cv_header_winsock2_h" = yes]
dirent #include <dirent.h> dirent.in.h dirent_h.m4
unistd_h.m4
00gnulib.m4
gl_DIRENT_H
include_next
snippet/arg-nonnull
snippet/c++defs
snippet/warn-on-use
dprintf #include <stdio.h> dprintf.c dprintf.m4
00gnulib.m4
gl_FUNC_DPRINTF
gl_STDIO_MODULE_INDICATOR([dprintf])
stdio
vasnprintf [test $ac_cv_func_dprintf = no || test $REPLACE_DPRINTF = 1]
full-write [test $ac_cv_func_dprintf = no || test $REPLACE_DPRINTF = 1]
errno [test $ac_cv_func_dprintf = no || test $REPLACE_DPRINTF = 1]
dprintf-posix #include <stdio.h> --- dprintf-posix.m4
printf.m4
math_h.m4
00gnulib.m4
gl_FUNC_DPRINTF_POSIX
dprintf
nocrash
printf-safe
multiarch
vasnprintf [test $ac_cv_func_dprintf = no || test $REPLACE_DPRINTF = 1]
isnand-nolibm [test $ac_cv_func_dprintf = no || test $REPLACE_DPRINTF = 1]
isnanl-nolibm [test $ac_cv_func_dprintf = no || test $REPLACE_DPRINTF = 1]
frexp-nolibm [test $ac_cv_func_dprintf = no || test $REPLACE_DPRINTF = 1]
frexpl-nolibm [test $ac_cv_func_dprintf = no || test $REPLACE_DPRINTF = 1]
printf-frexp [test $ac_cv_func_dprintf = no || test $REPLACE_DPRINTF = 1]
printf-frexpl [test $ac_cv_func_dprintf = no || test $REPLACE_DPRINTF = 1]
signbit [test $ac_cv_func_dprintf = no || test $REPLACE_DPRINTF = 1]
fpucw [test $ac_cv_func_dprintf = no || test $REPLACE_DPRINTF = 1]
dup2 #include <unistd.h> dup2.c dup2.m4
00gnulib.m4
gl_FUNC_DUP2
if test $HAVE_DUP2 = 0 || test $REPLACE_DUP2 = 1; then
AC_LIBOBJ([dup2])
gl_PREREQ_DUP2
fi
gl_UNISTD_MODULE_INDICATOR([dup2])
unistd
dup2-obsolete
msvc-inval [test $HAVE_DUP2 = 0 || test $REPLACE_DUP2 = 1]
msvc-nothrow [test $HAVE_DUP2 = 0 || test $REPLACE_DUP2 = 1]
duplocale #include <locale.h> duplocale.c duplocale.m4
00gnulib.m4
gl_FUNC_DUPLOCALE
if test $REPLACE_DUPLOCALE = 1; then
AC_LIBOBJ([duplocale])
gl_PREREQ_DUPLOCALE
fi
gl_LOCALE_MODULE_INDICATOR([duplocale])
locale
environ #include <unistd.h> --- environ.m4
00gnulib.m4
gl_ENVIRON
gl_UNISTD_MODULE_INDICATOR([environ])
unistd
extensions
errno #include <errno.h> errno.in.h errno_h.m4
00gnulib.m4
gl_HEADER_ERRNO_H
include_next
fchdir #include <unistd.h> fchdir.c fchdir.m4
00gnulib.m4
gl_FUNC_FCHDIR
gl_UNISTD_MODULE_INDICATOR([fchdir])
unistd
assure [test $HAVE_FCHDIR = 0]
chdir [test $HAVE_FCHDIR = 0]
close [test $HAVE_FCHDIR = 0]
dirent [test $HAVE_FCHDIR = 0]
dirfd [test $HAVE_FCHDIR = 0]
dosname [test $HAVE_FCHDIR = 0]
dup2 [test $HAVE_FCHDIR = 0]
fcntl [test $HAVE_FCHDIR = 0]
fcntl-h [test $HAVE_FCHDIR = 0]
filenamecat-lgpl [test $HAVE_FCHDIR = 0]
fstat [test $HAVE_FCHDIR = 0]
getcwd-lgpl [test $HAVE_FCHDIR = 0]
malloc-posix [test $HAVE_FCHDIR = 0]
open [test $HAVE_FCHDIR = 0]
realloc-posix [test $HAVE_FCHDIR = 0]
stat [test $HAVE_FCHDIR = 0]
stdbool [test $HAVE_FCHDIR = 0]
strdup-posix [test $HAVE_FCHDIR = 0]
sys_stat [test $HAVE_FCHDIR = 0]
fclose #include <stdio.h> fclose.c fclose.m4
00gnulib.m4
gl_FUNC_FCLOSE
if test $REPLACE_FCLOSE = 1; then
AC_LIBOBJ([fclose])
fi
gl_STDIO_MODULE_INDICATOR([fclose])
stdio
close [test $REPLACE_FCLOSE = 1]
fflush [test $REPLACE_FCLOSE = 1]
freading [test $REPLACE_FCLOSE = 1]
lseek [test $REPLACE_FCLOSE = 1]
msvc-inval [test $REPLACE_FCLOSE = 1]
fcntl-h #include <fcntl.h> fcntl.in.h fcntl_h.m4
fcntl-o.m4
00gnulib.m4
gl_FCNTL_H
extensions
include_next
snippet/arg-nonnull
snippet/c++defs
snippet/warn-on-use
sys_types
unistd
fcntl #include <fcntl.h> fcntl.c fcntl.m4
00gnulib.m4
gl_FUNC_FCNTL
if test $HAVE_FCNTL = 0 || test $REPLACE_FCNTL = 1; then
AC_LIBOBJ([fcntl])
fi
gl_FCNTL_MODULE_INDICATOR([fcntl])
fcntl-h
extensions
close [test $HAVE_FCNTL = 0 || test $REPLACE_FCNTL = 1]
dup2 [test $HAVE_FCNTL = 0 || test $REPLACE_FCNTL = 1]
getdtablesize [test $HAVE_FCNTL = 0 || test $REPLACE_FCNTL = 1]
msvc-nothrow [test $HAVE_FCNTL = 0 || test $REPLACE_FCNTL = 1]
fdatasync #include <unistd.h> fdatasync.c fdatasync.m4
00gnulib.m4
gl_FUNC_FDATASYNC
if test $HAVE_FDATASYNC = 0; then
AC_LIBOBJ([fdatasync])
fi
gl_UNISTD_MODULE_INDICATOR([fdatasync])
fsync [test $HAVE_FDATASYNC = 0]
unistd
flock #include <sys/file.h> flock.c flock.m4
00gnulib.m4
gl_FUNC_FLOCK
if test $HAVE_FLOCK = 0; then
AC_LIBOBJ([flock])
gl_PREREQ_FLOCK
fi
gl_HEADER_SYS_FILE_MODULE_INDICATOR([flock])
sys_file
msvc-nothrow [test $HAVE_FLOCK = 0]
fopen #include <stdio.h> fopen.c fopen.m4
00gnulib.m4
gl_FUNC_FOPEN
if test $REPLACE_FOPEN = 1; then
AC_LIBOBJ([fopen])
gl_PREREQ_FOPEN
fi
gl_STDIO_MODULE_INDICATOR([fopen])
stdio
largefile
unistd [test $REPLACE_FOPEN = 1]
fstat [test $REPLACE_FOPEN = 1]
fprintf-posix #include <stdio.h> fprintf.c fprintf-posix.m4
printf.m4
math_h.m4
00gnulib.m4
gl_FUNC_FPRINTF_POSIX
gl_STDIO_MODULE_INDICATOR([fprintf-posix])
stdio
nocrash
printf-safe
errno
multiarch
fseterr [test $REPLACE_FPRINTF = 1]
vasnprintf [test $REPLACE_FPRINTF = 1]
isnand-nolibm [test $REPLACE_FPRINTF = 1]
isnanl-nolibm [test $REPLACE_FPRINTF = 1]
frexp-nolibm [test $REPLACE_FPRINTF = 1]
frexpl-nolibm [test $REPLACE_FPRINTF = 1]
printf-frexp [test $REPLACE_FPRINTF = 1]
printf-frexpl [test $REPLACE_FPRINTF = 1]
signbit [test $REPLACE_FPRINTF = 1]
fpucw [test $REPLACE_FPRINTF = 1]
freopen #include <stdio.h> freopen.c freopen.m4
00gnulib.m4
gl_FUNC_FREOPEN
if test $REPLACE_FREOPEN = 1; then
AC_LIBOBJ([freopen])
gl_PREREQ_FREOPEN
fi
gl_STDIO_MODULE_INDICATOR([freopen])
stdio
largefile
fseek #include <stdio.h> fseek.c fseek.m4
00gnulib.m4
gl_FUNC_FSEEK
if test $REPLACE_FSEEK = 1; then
AC_LIBOBJ([fseek])
fi
gl_STDIO_MODULE_INDICATOR([fseek])
stdio
fseeko [test $REPLACE_FSEEK = 1]
fseeko #include <stdio.h> fseeko.c
stdio-impl.h
fseeko.m4
00gnulib.m4
gl_FUNC_FSEEKO
if test $HAVE_FSEEKO = 0 || test $REPLACE_FSEEKO = 1; then
AC_LIBOBJ([fseeko])
gl_PREREQ_FSEEKO
fi
gl_STDIO_MODULE_INDICATOR([fseeko])
extensions
largefile
lseek
stdio
sys_types
fseek
fsync #include <unistd.h> fsync.c fsync.m4
00gnulib.m4
gl_FUNC_FSYNC
if test $HAVE_FSYNC = 0; then
AC_LIBOBJ([fsync])
gl_PREREQ_FSYNC
fi
gl_UNISTD_MODULE_INDICATOR([fsync])
unistd
msvc-nothrow [test $HAVE_FSYNC = 0]
ftell #include <stdio.h> ftell.c ftell.m4
00gnulib.m4
gl_FUNC_FTELL
if test $REPLACE_FTELL = 1; then
AC_LIBOBJ([ftell])
fi
gl_STDIO_MODULE_INDICATOR([ftell])
stdio
errno
ftello [test $REPLACE_FTELL = 1]
ftello #include <stdio.h> ftello.c
stdio-impl.h
fseeko.m4
ftello.m4
00gnulib.m4
gl_FUNC_FTELLO
if test $HAVE_FTELLO = 0 || test $REPLACE_FTELLO = 1; then
AC_LIBOBJ([ftello])
gl_PREREQ_FTELLO
fi
gl_STDIO_MODULE_INDICATOR([ftello])
stdio
extensions
largefile
sys_types
lseek [test $HAVE_FTELLO = 0 || test $REPLACE_FTELLO = 1]
ftell
ftruncate #include <unistd.h> ftruncate.c ftruncate.m4
00gnulib.m4
gl_FUNC_FTRUNCATE
if test $HAVE_FTRUNCATE = 0 || test $REPLACE_FTRUNCATE = 1; then
AC_LIBOBJ([ftruncate])
gl_PREREQ_FTRUNCATE
fi
gl_UNISTD_MODULE_INDICATOR([ftruncate])
unistd
sys_types
largefile
msvc-nothrow [test $HAVE_FTRUNCATE = 0 || test $REPLACE_FTRUNCATE = 1]
msvc-inval [test $HAVE_FTRUNCATE = 0 || test $REPLACE_FTRUNCATE = 1]
futimens #include <sys/stat.h> futimens.c futimens.m4
00gnulib.m4
gl_FUNC_FUTIMENS
if test $HAVE_FUTIMENS = 0 || test $REPLACE_FUTIMENS = 1; then
AC_LIBOBJ([futimens])
fi
gl_SYS_STAT_MODULE_INDICATOR([futimens])
sys_stat
extensions
utimens [test $HAVE_FUTIMENS = 0 || test $REPLACE_FUTIMENS = 1]
getaddrinfo #include <netdb.h> getaddrinfo.c
gai_strerror.c
getaddrinfo.m4
00gnulib.m4
gl_GETADDRINFO
if test $HAVE_GETADDRINFO = 0; then
AC_LIBOBJ([getaddrinfo])
fi
if test $HAVE_DECL_GAI_STRERROR = 0 || test $REPLACE_GAI_STRERROR = 1; then
AC_LIBOBJ([gai_strerror])
fi
gl_NETDB_MODULE_INDICATOR([getaddrinfo])
netdb
sys_socket
extensions
gettext-h [test $HAVE_GETADDRINFO = 0 || test $HAVE_DECL_GAI_STRERROR = 0 || test $REPLACE_GAI_STRERROR = 1]
inet_ntop [test $HAVE_GETADDRINFO = 0]
snprintf [test $HAVE_GETADDRINFO = 0]
stdbool [test $HAVE_GETADDRINFO = 0]
strdup [test $HAVE_GETADDRINFO = 0]
servent [test $HAVE_GETADDRINFO = 0]
hostent [test $HAVE_GETADDRINFO = 0]
sockets [test $HAVE_GETADDRINFO = 0]
getcwd #include <unistd.h> getcwd.c getcwd-abort-bug.m4
getcwd-path-max.m4
getcwd.m4
pathmax.m4
00gnulib.m4
gl_FUNC_GETCWD
if test $REPLACE_GETCWD = 1; then
AC_LIBOBJ([getcwd])
gl_PREREQ_GETCWD
fi
gl_MODULE_INDICATOR([getcwd])
gl_UNISTD_MODULE_INDICATOR([getcwd])
unistd
extensions
pathmax [test $REPLACE_GETCWD = 1]
mempcpy [test $REPLACE_GETCWD = 1]
d-ino [test $REPLACE_GETCWD = 1]
memmove [test $REPLACE_GETCWD = 1]
openat [test $REPLACE_GETCWD = 1]
fcntl-h [test $REPLACE_GETCWD = 1]
fdopendir [test $REPLACE_GETCWD = 1]
fstat [test $REPLACE_GETCWD = 1]
fstatat [test $REPLACE_GETCWD = 1]
opendir [test $REPLACE_GETCWD = 1]
readdir [test $REPLACE_GETCWD = 1]
rewinddir [test $REPLACE_GETCWD = 1]
closedir [test $REPLACE_GETCWD = 1]
stdbool [test $REPLACE_GETCWD = 1]
malloc-posix [test $REPLACE_GETCWD = 1]
strdup-posix [test $REPLACE_GETCWD = 1]
getcwd-lgpl #include <unistd.h> getcwd-lgpl.c getcwd.m4
00gnulib.m4
gl_FUNC_GETCWD_LGPL
if test $REPLACE_GETCWD = 1; then
AC_LIBOBJ([getcwd-lgpl])
fi
gl_UNISTD_MODULE_INDICATOR([getcwd])
unistd
strdup [test $REPLACE_GETCWD = 1]
getgroups #include <unistd.h> getgroups.c getgroups.m4
00gnulib.m4
gl_FUNC_GETGROUPS
if test $HAVE_GETGROUPS = 0 || test $REPLACE_GETGROUPS = 1; then
AC_LIBOBJ([getgroups])
fi
gl_UNISTD_MODULE_INDICATOR([getgroups])
unistd
malloc-posix [test $HAVE_GETGROUPS = 0 || test $REPLACE_GETGROUPS = 1]
stdint [test $HAVE_GETGROUPS = 0 || test $REPLACE_GETGROUPS = 1]
gethostname #include <unistd.h> gethostname.c
w32sock.h
gethostname.m4
00gnulib.m4
gl_FUNC_GETHOSTNAME
if test $HAVE_GETHOSTNAME = 0; then
AC_LIBOBJ([gethostname])
gl_PREREQ_GETHOSTNAME
fi
gl_UNISTD_MODULE_INDICATOR([gethostname])
unistd
sys_socket [test $HAVE_GETHOSTNAME = 0]
errno [test $HAVE_GETHOSTNAME = 0]
sockets [test $HAVE_GETHOSTNAME = 0]
msvc-nothrow [test $HAVE_GETHOSTNAME = 0]
getlogin #include <unistd.h> getlogin.c getlogin.m4
00gnulib.m4
gl_FUNC_GETLOGIN
if test $HAVE_GETLOGIN = 0; then
AC_LIBOBJ([getlogin])
fi
gl_UNISTD_MODULE_INDICATOR([getlogin])
unistd
getlogin_r #include <unistd.h> getlogin_r.c getlogin_r.m4
00gnulib.m4
gl_FUNC_GETLOGIN_R
if test $HAVE_GETLOGIN_R = 0 || test $REPLACE_GETLOGIN_R = 1; then
AC_LIBOBJ([getlogin_r])
gl_PREREQ_GETLOGIN_R
fi
gl_UNISTD_MODULE_INDICATOR([getlogin_r])
unistd
extensions
memchr [test $HAVE_GETLOGIN_R = 0 || test $REPLACE_GETLOGIN_R = 1]
getopt-posix #include <unistd.h> getopt.in.h
getopt.c
getopt1.c
getopt_int.h
getopt.m4
00gnulib.m4
gl_FUNC_GETOPT_POSIX
if test $REPLACE_GETOPT = 1; then
AC_LIBOBJ([getopt])
AC_LIBOBJ([getopt1])
gl_PREREQ_GETOPT
dnl Arrange for unistd.h to include getopt.h.
GNULIB_${gl_include_guard_prefix}_UNISTD_H_GETOPT=1
fi
AC_SUBST([GNULIB_${gl_include_guard_prefix}_UNISTD_H_GETOPT])
unistd
extensions
include_next
snippet/arg-nonnull
gettext-h [test $REPLACE_GETOPT = 1]
getpeername #include <sys/socket.h> getpeername.c
w32sock.h
00gnulib.m4
AC_REQUIRE([gl_HEADER_SYS_SOCKET])
if test "$ac_cv_header_winsock2_h" = yes; then
AC_LIBOBJ([getpeername])
fi
gl_SYS_SOCKET_MODULE_INDICATOR([getpeername])
sys_socket
socketlib
errno [test "$ac_cv_header_winsock2_h" = yes]
msvc-nothrow [test "$ac_cv_header_winsock2_h" = yes]
getsockname #include <sys/socket.h> getsockname.c
w32sock.h
00gnulib.m4
AC_REQUIRE([gl_HEADER_SYS_SOCKET])
if test "$ac_cv_header_winsock2_h" = yes; then
AC_LIBOBJ([getsockname])
fi
gl_SYS_SOCKET_MODULE_INDICATOR([getsockname])
sys_socket
socketlib
errno [test "$ac_cv_header_winsock2_h" = yes]
msvc-nothrow [test "$ac_cv_header_winsock2_h" = yes]
getsockopt #include <sys/socket.h> getsockopt.c
w32sock.h
00gnulib.m4
AC_REQUIRE([gl_HEADER_SYS_SOCKET])
if test "$ac_cv_header_winsock2_h" = yes; then
AC_LIBOBJ([getsockopt])
fi
gl_SYS_SOCKET_MODULE_INDICATOR([getsockopt])
sys_socket
socketlib
sys_time [test "$ac_cv_header_winsock2_h" = yes]
errno [test "$ac_cv_header_winsock2_h" = yes]
msvc-nothrow [test "$ac_cv_header_winsock2_h" = yes]
getsubopt #include <stdlib.h> getsubopt.c getsubopt.m4
00gnulib.m4
gl_FUNC_GETSUBOPT
if test $HAVE_GETSUBOPT = 0; then
AC_LIBOBJ([getsubopt])
gl_PREREQ_GETSUBOPT
fi
gl_STDLIB_MODULE_INDICATOR([getsubopt])
stdlib
extensions
strchrnul [test $HAVE_GETSUBOPT = 0]
memchr [test $HAVE_GETSUBOPT = 0]
gettimeofday #include <sys/time.h> gettimeofday.c gettimeofday.m4
00gnulib.m4
gl_FUNC_GETTIMEOFDAY
if test $HAVE_GETTIMEOFDAY = 0 || test $REPLACE_GETTIMEOFDAY = 1; then
AC_LIBOBJ([gettimeofday])
gl_PREREQ_GETTIMEOFDAY
fi
gl_SYS_TIME_MODULE_INDICATOR([gettimeofday])
sys_time
grantpt #include <stdlib.h> grantpt.c
pty-private.h
grantpt.m4
00gnulib.m4
gl_FUNC_GRANTPT
if test $HAVE_GRANTPT = 0; then
AC_LIBOBJ([grantpt])
gl_PREREQ_GRANTPT
fi
gl_STDLIB_MODULE_INDICATOR([grantpt])
stdlib
extensions
pt_chown [test $HAVE_GRANTPT = 0]
waitpid [test $HAVE_GRANTPT = 0]
configmake [test $HAVE_GRANTPT = 0]
hostent #include <netdb.h> --- hostent.m4
00gnulib.m4
gl_HOSTENT
sys_socket
iconv-h #include <iconv.h> iconv.in.h iconv_h.m4
00gnulib.m4
gl_ICONV_H
include_next
snippet/arg-nonnull
snippet/c++defs
snippet/warn-on-use
iconv_open #include <iconv.h> iconv_open.c
iconv_open-aix.gperf
iconv_open-hpux.gperf
iconv_open-irix.gperf
iconv_open-osf.gperf
iconv_open-solaris.gperf
iconv.c
iconv_close.c
iconv_open.m4
00gnulib.m4
gl_FUNC_ICONV_OPEN
if test $REPLACE_ICONV_OPEN = 1; then
AC_LIBOBJ([iconv_open])
fi
if test $REPLACE_ICONV = 1; then
AC_LIBOBJ([iconv])
AC_LIBOBJ([iconv_close])
fi
gperf
iconv-h
iconv
c-ctype [test $REPLACE_ICONV_OPEN = 1]
c-strcase [test $REPLACE_ICONV_OPEN = 1]
stdint [test $REPLACE_ICONV_UTF = 1]
unistr/u8-mbtoucr [test $REPLACE_ICONV_UTF = 1]
unistr/u8-uctomb [test $REPLACE_ICONV_UTF = 1]
inet_ntop #include <arpa/inet.h> inet_ntop.c inet_ntop.m4
sys_socket_h.m4
00gnulib.m4
gl_FUNC_INET_NTOP
if test $HAVE_INET_NTOP = 0 || test $REPLACE_INET_NTOP = 1; then
AC_LIBOBJ([inet_ntop])
gl_PREREQ_INET_NTOP
fi
gl_ARPA_INET_MODULE_INDICATOR([inet_ntop])
arpa_inet
extensions
sys_socket [test $HAVE_INET_NTOP = 0 || test $REPLACE_INET_NTOP = 1]
errno [test $HAVE_INET_NTOP = 0 || test $REPLACE_INET_NTOP = 1]
netinet_in [test $HAVE_INET_NTOP = 0 || test $REPLACE_INET_NTOP = 1]
inet_pton #include <arpa/inet.h> inet_pton.c inet_pton.m4
00gnulib.m4
gl_FUNC_INET_PTON
if test $HAVE_INET_PTON = 0 || test $REPLACE_INET_NTOP = 1; then
AC_LIBOBJ([inet_pton])
gl_PREREQ_INET_PTON
fi
gl_ARPA_INET_MODULE_INDICATOR([inet_pton])
arpa_inet
extensions
c-ctype [test $HAVE_INET_PTON = 0 || test $REPLACE_INET_NTOP = 1]
sys_socket [test $HAVE_INET_PTON = 0 || test $REPLACE_INET_NTOP = 1]
errno [test $HAVE_INET_PTON = 0 || test $REPLACE_INET_NTOP = 1]
netinet_in [test $HAVE_INET_PTON = 0 || test $REPLACE_INET_NTOP = 1]
ioctl #include <sys/ioctl.h> ioctl.c
w32sock.h
ioctl.m4
00gnulib.m4
gl_FUNC_IOCTL
if test $HAVE_IOCTL = 0 || test $REPLACE_IOCTL = 1; then
AC_LIBOBJ([ioctl])
fi
gl_SYS_IOCTL_MODULE_INDICATOR([ioctl])
sys_ioctl
sys_socket [test $HAVE_IOCTL = 0 || test $REPLACE_IOCTL = 1]
errno [test $HAVE_IOCTL = 0 || test $REPLACE_IOCTL = 1]
fd-hook [test $HAVE_IOCTL = 0 || test $REPLACE_IOCTL = 1]
msvc-nothrow [test $HAVE_IOCTL = 0 || test $REPLACE_IOCTL = 1]
isblank #include <ctype.h> isblank.c isblank.m4
00gnulib.m4
gl_FUNC_ISBLANK
if test $HAVE_ISBLANK = 0; then
AC_LIBOBJ([isblank])
fi
gl_CTYPE_MODULE_INDICATOR([isblank])
extensions
ctype
langinfo #include <langinfo.h> langinfo.in.h langinfo_h.m4
00gnulib.m4
gl_LANGINFO_H
extensions
include_next
snippet/c++defs
snippet/warn-on-use
link #include <unistd.h> link.c link.m4
00gnulib.m4
gl_FUNC_LINK
if test $HAVE_LINK = 0 || test $REPLACE_LINK = 1; then
AC_LIBOBJ([link])
fi
gl_UNISTD_MODULE_INDICATOR([link])
unistd
stat [test $HAVE_LINK = 0 || test $REPLACE_LINK = 1]
strdup-posix [test $HAVE_LINK = 0 || test $REPLACE_LINK = 1]
sys_stat [test $HAVE_LINK = 0 || test $REPLACE_LINK = 1]
linkat #include <fcntl.h>
#include <unistd.h>
at-func2.c
linkat.c
linkat.m4
00gnulib.m4
gl_FUNC_LINKAT
if test $HAVE_LINKAT = 0 || test $REPLACE_LINKAT = 1; then
AC_LIBOBJ([linkat])
AC_LIBOBJ([at-func2])
fi
gl_UNISTD_MODULE_INDICATOR([linkat])
unistd
extensions
dirname-lgpl [test $HAVE_LINKAT = 0 || test $REPLACE_LINKAT = 1]
errno [test $HAVE_LINKAT = 0 || test $REPLACE_LINKAT = 1]
fcntl-h [test $HAVE_LINKAT = 0 || test $REPLACE_LINKAT = 1]
filenamecat-lgpl [test $HAVE_LINKAT = 0 || test $REPLACE_LINKAT = 1]
link-follow [test $HAVE_LINKAT = 0 || test $REPLACE_LINKAT = 1]
areadlink [test $HAVE_LINKAT = 0 || test $REPLACE_LINKAT = 1]
at-internal [test $HAVE_LINKAT = 0 || test $REPLACE_LINKAT = 1]
dosname [test $HAVE_LINKAT = 0 || test $REPLACE_LINKAT = 1]
fstat [test $HAVE_LINKAT = 0 || test $REPLACE_LINKAT = 1]
getcwd-lgpl [test $HAVE_LINKAT = 0 || test $REPLACE_LINKAT = 1]
openat-h [test $HAVE_LINKAT = 0 || test $REPLACE_LINKAT = 1]
openat-die [test $HAVE_LINKAT = 0 || test $REPLACE_LINKAT = 1]
link [test $HAVE_LINKAT = 0 || test $REPLACE_LINKAT = 1]
lstat [test $HAVE_LINKAT = 0 || test $REPLACE_LINKAT = 1]
same-inode [test $HAVE_LINKAT = 0 || test $REPLACE_LINKAT = 1]
save-cwd [test $HAVE_LINKAT = 0 || test $REPLACE_LINKAT = 1]
symlink [test $HAVE_LINKAT = 0 || test $REPLACE_LINKAT = 1]
areadlinkat [test $REPLACE_LINKAT = 1]
fstatat [test $REPLACE_LINKAT = 1]
listen #include <sys/socket.h> listen.c
w32sock.h
00gnulib.m4
AC_REQUIRE([gl_HEADER_SYS_SOCKET])
if test "$ac_cv_header_winsock2_h" = yes; then
AC_LIBOBJ([listen])
fi
gl_SYS_SOCKET_MODULE_INDICATOR([listen])
sys_socket
socketlib
errno [test "$ac_cv_header_winsock2_h" = yes]
msvc-nothrow [test "$ac_cv_header_winsock2_h" = yes]
locale #include <locale.h> locale.in.h locale_h.m4
00gnulib.m4
gl_LOCALE_H
extensions
include_next
snippet/arg-nonnull
snippet/c++defs
snippet/warn-on-use
stddef
lseek #include <unistd.h> lseek.c lseek.m4
00gnulib.m4
gl_FUNC_LSEEK
if test $REPLACE_LSEEK = 1; then
AC_LIBOBJ([lseek])
fi
gl_UNISTD_MODULE_INDICATOR([lseek])
unistd
sys_types
largefile
msvc-nothrow [test $REPLACE_LSEEK = 1]
fstat [test $REPLACE_LSEEK = 1]
lstat #include <sys/stat.h> lstat.c lstat.m4
00gnulib.m4
gl_FUNC_LSTAT
if test $REPLACE_LSTAT = 1; then
AC_LIBOBJ([lstat])
gl_PREREQ_LSTAT
fi
gl_SYS_STAT_MODULE_INDICATOR([lstat])
sys_stat
largefile
dosname [test $REPLACE_LSTAT = 1]
stat [test $REPLACE_LSTAT = 1]
malloc-posix #include <stdlib.h> malloc.c malloc.m4
00gnulib.m4
gl_FUNC_MALLOC_POSIX
if test $REPLACE_MALLOC = 1; then
AC_LIBOBJ([malloc])
fi
gl_STDLIB_MODULE_INDICATOR([malloc-posix])
stdlib
mbsnrtowcs #include <wchar.h> mbsnrtowcs.c
mbsnrtowcs-impl.h
mbsrtowcs-state.c
mbsnrtowcs.m4
mbstate_t.m4
00gnulib.m4
gl_FUNC_MBSNRTOWCS
if test $HAVE_MBSNRTOWCS = 0 || test $REPLACE_MBSNRTOWCS = 1; then
AC_LIBOBJ([mbsnrtowcs])
AC_LIBOBJ([mbsrtowcs-state])
gl_PREREQ_MBSNRTOWCS
fi
gl_WCHAR_MODULE_INDICATOR([mbsnrtowcs])
wchar
extensions
mbrtowc [test $HAVE_MBSNRTOWCS = 0 || test $REPLACE_MBSNRTOWCS = 1]
minmax [test $HAVE_MBSNRTOWCS = 0 || test $REPLACE_MBSNRTOWCS = 1]
strnlen1 [test $HAVE_MBSNRTOWCS = 0 || test $REPLACE_MBSNRTOWCS = 1]
mkdir #include <sys/stat.h> mkdir.c mkdir.m4
00gnulib.m4
gl_FUNC_MKDIR
if test $REPLACE_MKDIR = 1; then
AC_LIBOBJ([mkdir])
fi
sys_stat
dirname-lgpl [test $REPLACE_MKDIR = 1]
mkdtemp #include <stdlib.h> mkdtemp.c mkdtemp.m4
00gnulib.m4
gl_FUNC_MKDTEMP
if test $HAVE_MKDTEMP = 0; then
AC_LIBOBJ([mkdtemp])
gl_PREREQ_MKDTEMP
fi
gl_STDLIB_MODULE_INDICATOR([mkdtemp])
stdlib
stdint [test $HAVE_MKDTEMP = 0]
tempname [test $HAVE_MKDTEMP = 0]
mkfifo #include <sys/stat.h> mkfifo.c mkfifo.m4
00gnulib.m4
gl_FUNC_MKFIFO
if test $HAVE_MKFIFO = 0 || test $REPLACE_MKFIFO = 1; then
AC_LIBOBJ([mkfifo])
fi
gl_UNISTD_MODULE_INDICATOR([mkfifo])
sys_stat
stat [test $HAVE_MKFIFO = 0 || test $REPLACE_MKFIFO = 1]
mknod #include <sys/stat.h> mknod.c mknod.m4
00gnulib.m4
gl_FUNC_MKNOD
if test $HAVE_MKNOD = 0 || test $REPLACE_MKNOD = 1; then
AC_LIBOBJ([mknod])
fi
gl_UNISTD_MODULE_INDICATOR([mknod])
sys_stat
extensions
mkfifo [test $HAVE_MKNOD = 0 || test $REPLACE_MKNOD = 1]
stat [test $HAVE_MKNOD = 0 || test $REPLACE_MKNOD = 1]
mkstemp #include <stdlib.h> mkstemp.c mkstemp.m4
00gnulib.m4
gl_FUNC_MKSTEMP
if test $HAVE_MKSTEMP = 0 || test $REPLACE_MKSTEMP = 1; then
AC_LIBOBJ([mkstemp])
gl_PREREQ_MKSTEMP
fi
gl_STDLIB_MODULE_INDICATOR([mkstemp])
stdlib
extensions
largefile
tempname [test $HAVE_MKSTEMP = 0 || test $REPLACE_MKSTEMP = 1]
net_if #include <net/if.h> net_if.in.h net_if_h.m4
00gnulib.m4
gl_HEADER_NET_IF
AC_PROG_MKDIR_P
include_next
sys_socket
netdb #include <netdb.h> netdb.in.h netdb_h.m4
00gnulib.m4
gl_HEADER_NETDB
include_next
snippet/arg-nonnull
snippet/c++defs
snippet/warn-on-use
sys_socket
netinet_in #include <netinet/in.h> netinet_in.in.h netinet_in_h.m4
00gnulib.m4
gl_HEADER_NETINET_IN
AC_PROG_MKDIR_P
include_next
sys_socket
nl_langinfo #include <langinfo.h> nl_langinfo.c nl_langinfo.m4
00gnulib.m4
gl_FUNC_NL_LANGINFO
if test $HAVE_NL_LANGINFO = 0 || test $REPLACE_NL_LANGINFO = 1; then
AC_LIBOBJ([nl_langinfo])
fi
gl_LANGINFO_MODULE_INDICATOR([nl_langinfo])
langinfo
localeconv [test $HAVE_NL_LANGINFO = 0 || test $REPLACE_NL_LANGINFO = 1]
open #include <fcntl.h> open.c open.m4
mode_t.m4
00gnulib.m4
gl_FUNC_OPEN
if test $REPLACE_OPEN = 1; then
AC_LIBOBJ([open])
gl_PREREQ_OPEN
fi
gl_FCNTL_MODULE_INDICATOR([open])
fcntl-h
largefile
fstat [test $REPLACE_OPEN = 1]
stat [test $REPLACE_OPEN = 1]
perror #include <stdio.h> perror.c perror.m4
00gnulib.m4
gl_FUNC_PERROR
if test $REPLACE_PERROR = 1; then
AC_LIBOBJ([perror])
fi
gl_STRING_MODULE_INDICATOR([perror])
stdio
errno [test $REPLACE_PERROR = 1]
strerror-override [test $REPLACE_PERROR = 1]
strerror_r-posix [test $REPLACE_PERROR = 1]
poll #include <poll.h> poll.c poll.m4
00gnulib.m4
gl_FUNC_POLL
if test $HAVE_POLL = 0 || test $REPLACE_POLL = 1; then
AC_LIBOBJ([poll])
gl_PREREQ_POLL
fi
gl_POLL_MODULE_INDICATOR([poll])
poll-h
alloca [test $HAVE_POLL = 0 || test $REPLACE_POLL = 1]
assure [test $HAVE_POLL = 0 || test $REPLACE_POLL = 1]
select [test $HAVE_POLL = 0 || test $REPLACE_POLL = 1]
sockets [test $HAVE_POLL = 0 || test $REPLACE_POLL = 1]
sys_select [test $HAVE_POLL = 0 || test $REPLACE_POLL = 1]
sys_time [test $HAVE_POLL = 0 || test $REPLACE_POLL = 1]
errno [test $HAVE_POLL = 0 || test $REPLACE_POLL = 1]
msvc-nothrow [test $HAVE_POLL = 0 || test $REPLACE_POLL = 1]
popen #include <stdio.h> popen.c popen.m4
00gnulib.m4
gl_FUNC_POPEN
if test $HAVE_POPEN = 0 || test $REPLACE_POPEN = 1; then
AC_LIBOBJ([popen])
gl_PREREQ_POPEN
fi
gl_STDIO_MODULE_INDICATOR([popen])
stdio
open [test $HAVE_POPEN = 0 || test $REPLACE_POPEN = 1]
posix_openpt #include <stdlib.h> posix_openpt.c posix_openpt.m4
00gnulib.m4
gl_FUNC_POSIX_OPENPT
if test $HAVE_POSIX_OPENPT = 0; then
AC_LIBOBJ([posix_openpt])
fi
gl_STDLIB_MODULE_INDICATOR([posix_openpt])
extensions
stdlib
posix_spawn #include <spawn.h> spawn.c posix_spawn.m4
00gnulib.m4
gl_POSIX_SPAWN
if test $HAVE_POSIX_SPAWN = 0 || test $REPLACE_POSIX_SPAWN = 1; then
AC_LIBOBJ([spawn])
AC_LIBOBJ([spawni])
gl_PREREQ_POSIX_SPAWN_INTERNAL
fi
gl_SPAWN_MODULE_INDICATOR([posix_spawn])
spawn
posix_spawn-internal [test $HAVE_POSIX_SPAWN = 0 || test $REPLACE_POSIX_SPAWN = 1]
posix_spawnattr_destroy #include <spawn.h> spawnattr_destroy.c posix_spawn.m4
00gnulib.m4
gl_POSIX_SPAWN
if test $HAVE_POSIX_SPAWN = 0 || test $REPLACE_POSIX_SPAWN = 1; then
AC_LIBOBJ([spawnattr_destroy])
fi
gl_SPAWN_MODULE_INDICATOR([posix_spawnattr_destroy])
spawn
posix_spawnattr_getflags #include <spawn.h> spawnattr_getflags.c posix_spawn.m4
00gnulib.m4
gl_POSIX_SPAWN
if test $HAVE_POSIX_SPAWN = 0 || test $REPLACE_POSIX_SPAWN = 1; then
AC_LIBOBJ([spawnattr_getflags])
fi
gl_SPAWN_MODULE_INDICATOR([posix_spawnattr_getflags])
spawn
posix_spawnattr_getpgroup #include <spawn.h> spawnattr_getpgroup.c posix_spawn.m4
00gnulib.m4
gl_POSIX_SPAWN
if test $HAVE_POSIX_SPAWN = 0 || test $REPLACE_POSIX_SPAWN = 1; then
AC_LIBOBJ([spawnattr_getpgroup])
fi
gl_SPAWN_MODULE_INDICATOR([posix_spawnattr_getpgroup])
spawn
posix_spawnattr_getschedparam #include <spawn.h> spawnattr_getschedparam.c posix_spawn.m4
00gnulib.m4
gl_POSIX_SPAWN
if test $HAVE_POSIX_SPAWN = 0 \
|| test $REPLACE_POSIX_SPAWN = 1 \
|| test $gl_cv_func_spawnattr_setschedparam = no; then
AC_LIBOBJ([spawnattr_getschedparam])
fi
gl_SPAWN_MODULE_INDICATOR([posix_spawnattr_getschedparam])
spawn
posix_spawnattr_getschedpolicy #include <spawn.h> spawnattr_getschedpolicy.c posix_spawn.m4
00gnulib.m4
gl_POSIX_SPAWN
if test $HAVE_POSIX_SPAWN = 0 \
|| test $REPLACE_POSIX_SPAWN = 1 \
|| test $gl_cv_func_spawnattr_setschedpolicy = no; then
AC_LIBOBJ([spawnattr_getschedpolicy])
fi
gl_SPAWN_MODULE_INDICATOR([posix_spawnattr_getschedpolicy])
spawn
posix_spawnattr_getsigdefault #include <spawn.h> spawnattr_getdefault.c posix_spawn.m4
00gnulib.m4
gl_POSIX_SPAWN
if test $HAVE_POSIX_SPAWN = 0 || test $REPLACE_POSIX_SPAWN = 1; then
AC_LIBOBJ([spawnattr_getdefault])
fi
gl_SPAWN_MODULE_INDICATOR([posix_spawnattr_getsigdefault])
spawn
posix_spawnattr_getsigmask #include <spawn.h> spawnattr_getsigmask.c posix_spawn.m4
00gnulib.m4
gl_POSIX_SPAWN
if test $HAVE_POSIX_SPAWN = 0 || test $REPLACE_POSIX_SPAWN = 1; then
AC_LIBOBJ([spawnattr_getsigmask])
fi
gl_SPAWN_MODULE_INDICATOR([posix_spawnattr_getsigmask])
spawn
posix_spawnattr_init #include <spawn.h> spawnattr_init.c posix_spawn.m4
00gnulib.m4
gl_POSIX_SPAWN
if test $HAVE_POSIX_SPAWN = 0 || test $REPLACE_POSIX_SPAWN = 1; then
AC_LIBOBJ([spawnattr_init])
fi
gl_SPAWN_MODULE_INDICATOR([posix_spawnattr_init])
spawn
posix_spawnattr_setflags #include <spawn.h> spawnattr_setflags.c posix_spawn.m4
00gnulib.m4
gl_POSIX_SPAWN
if test $HAVE_POSIX_SPAWN = 0 || test $REPLACE_POSIX_SPAWN = 1; then
AC_LIBOBJ([spawnattr_setflags])
fi
gl_SPAWN_MODULE_INDICATOR([posix_spawnattr_setflags])
spawn
posix_spawnattr_setpgroup #include <spawn.h> spawnattr_setpgroup.c posix_spawn.m4
00gnulib.m4
gl_POSIX_SPAWN
if test $HAVE_POSIX_SPAWN = 0 || test $REPLACE_POSIX_SPAWN = 1; then
AC_LIBOBJ([spawnattr_setpgroup])
fi
gl_SPAWN_MODULE_INDICATOR([posix_spawnattr_setpgroup])
spawn
posix_spawnattr_setschedparam #include <spawn.h> spawnattr_setschedparam.c posix_spawn.m4
00gnulib.m4
gl_POSIX_SPAWN
if test $HAVE_POSIX_SPAWN = 0 \
|| test $REPLACE_POSIX_SPAWN = 1 \
|| test $gl_cv_func_spawnattr_setschedparam = no; then
AC_LIBOBJ([spawnattr_setschedparam])
fi
gl_SPAWN_MODULE_INDICATOR([posix_spawnattr_setschedparam])
spawn
posix_spawnattr_setschedpolicy #include <spawn.h> spawnattr_setschedpolicy.c posix_spawn.m4
00gnulib.m4
gl_POSIX_SPAWN
if test $HAVE_POSIX_SPAWN = 0 \
|| test $REPLACE_POSIX_SPAWN = 1 \
|| test $gl_cv_func_spawnattr_setschedpolicy = no; then
AC_LIBOBJ([spawnattr_setschedpolicy])
fi
gl_SPAWN_MODULE_INDICATOR([posix_spawnattr_setschedpolicy])
spawn
posix_spawnattr_setsigdefault #include <spawn.h> spawnattr_setdefault.c posix_spawn.m4
00gnulib.m4
gl_POSIX_SPAWN
if test $HAVE_POSIX_SPAWN = 0 || test $REPLACE_POSIX_SPAWN = 1; then
AC_LIBOBJ([spawnattr_setdefault])
fi
gl_SPAWN_MODULE_INDICATOR([posix_spawnattr_setsigdefault])
spawn
posix_spawnattr_setsigmask #include <spawn.h> spawnattr_setsigmask.c posix_spawn.m4
00gnulib.m4
gl_POSIX_SPAWN
if test $HAVE_POSIX_SPAWN = 0 || test $REPLACE_POSIX_SPAWN = 1; then
AC_LIBOBJ([spawnattr_setsigmask])
fi
gl_SPAWN_MODULE_INDICATOR([posix_spawnattr_setsigmask])
spawn
posix_spawn_file_actions_addclose #include <spawn.h> spawn_faction_addclose.c
spawn_int.h
posix_spawn.m4
00gnulib.m4
gl_FUNC_POSIX_SPAWN_FILE_ACTIONS_ADDCLOSE
if test $HAVE_POSIX_SPAWN = 0 || test $REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDCLOSE = 1; then
AC_LIBOBJ([spawn_faction_addclose])
fi
gl_SPAWN_MODULE_INDICATOR([posix_spawn_file_actions_addclose])
spawn
getdtablesize [test $HAVE_POSIX_SPAWN = 0 || test $REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDCLOSE = 1]
posix_spawn_file_actions_init [test $HAVE_POSIX_SPAWN = 0 || test $REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDCLOSE = 1]
posix_spawn_file_actions_adddup2 #include <spawn.h> spawn_faction_adddup2.c
spawn_int.h
posix_spawn.m4
00gnulib.m4
gl_FUNC_POSIX_SPAWN_FILE_ACTIONS_ADDDUP2
if test $HAVE_POSIX_SPAWN = 0 || test $REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDDUP2 = 1; then
AC_LIBOBJ([spawn_faction_adddup2])
fi
gl_SPAWN_MODULE_INDICATOR([posix_spawn_file_actions_adddup2])
spawn
getdtablesize [test $HAVE_POSIX_SPAWN = 0 || test $REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDDUP2 = 1]
posix_spawn_file_actions_init [test $HAVE_POSIX_SPAWN = 0 || test $REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDDUP2 = 1]
posix_spawn_file_actions_addopen #include <spawn.h> spawn_faction_addopen.c
spawn_int.h
posix_spawn.m4
00gnulib.m4
gl_FUNC_POSIX_SPAWN_FILE_ACTIONS_ADDOPEN
if test $HAVE_POSIX_SPAWN = 0 || test $REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDOPEN = 1; then
AC_LIBOBJ([spawn_faction_addopen])
fi
gl_SPAWN_MODULE_INDICATOR([posix_spawn_file_actions_addopen])
spawn
getdtablesize [test $HAVE_POSIX_SPAWN = 0 || test $REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDOPEN = 1]
posix_spawn_file_actions_init [test $HAVE_POSIX_SPAWN = 0 || test $REPLACE_POSIX_SPAWN_FILE_ACTIONS_ADDOPEN = 1]
posix_spawn_file_actions_destroy #include <spawn.h> spawn_faction_destroy.c posix_spawn.m4
00gnulib.m4
gl_POSIX_SPAWN
if test $HAVE_POSIX_SPAWN = 0 || test $REPLACE_POSIX_SPAWN = 1; then
AC_LIBOBJ([spawn_faction_destroy])
fi
gl_SPAWN_MODULE_INDICATOR([posix_spawn_file_actions_destroy])
spawn
posix_spawn_file_actions_init #include <spawn.h> spawn_faction_init.c
spawn_int.h
posix_spawn.m4
00gnulib.m4
gl_POSIX_SPAWN
if test $HAVE_POSIX_SPAWN = 0 || test $REPLACE_POSIX_SPAWN = 1; then
AC_LIBOBJ([spawn_faction_init])
fi
gl_SPAWN_MODULE_INDICATOR([posix_spawn_file_actions_init])
spawn
posix_spawn-internal --- spawni.c
spawn_int.h
posix_spawn.m4
00gnulib.m4
spawn
alloca-opt
dup2
errno
open
strchrnul
posix_spawnp #include <spawn.h> spawnp.c posix_spawn.m4
00gnulib.m4
gl_POSIX_SPAWN
if test $HAVE_POSIX_SPAWN = 0 || test $REPLACE_POSIX_SPAWN = 1; then
AC_LIBOBJ([spawnp])
AC_LIBOBJ([spawni])
gl_PREREQ_POSIX_SPAWN_INTERNAL
fi
gl_SPAWN_MODULE_INDICATOR([posix_spawnp])
spawn
posix_spawn-internal [test $HAVE_POSIX_SPAWN = 0 || test $REPLACE_POSIX_SPAWN = 1]
pread #include <unistd.h> pread.c pread.m4
00gnulib.m4
gl_FUNC_PREAD
if test $HAVE_PREAD = 0 || test $REPLACE_PREAD = 1; then
AC_LIBOBJ([pread])
fi
gl_UNISTD_MODULE_INDICATOR([pread])
unistd
extensions
largefile
lseek [test $HAVE_PREAD = 0 || test $REPLACE_PREAD = 1]
read [test $HAVE_PREAD = 0 || test $REPLACE_PREAD = 1]
printf-posix #include <stdio.h> printf.c printf-posix-rpl.m4
printf.m4
asm-underscore.m4
00gnulib.m4
gl_FUNC_PRINTF_POSIX
gl_STDIO_MODULE_INDICATOR([printf-posix])
stdio
printf-safe
vfprintf-posix [test $REPLACE_PRINTF = 1]
pselect #include <sys/select.h> pselect.c pselect.m4
00gnulib.m4
gl_FUNC_PSELECT
if test $HAVE_PSELECT = 0 || test $REPLACE_PSELECT = 1; then
AC_LIBOBJ([pselect])
fi
gl_SYS_SELECT_MODULE_INDICATOR([pselect])
sys_select
pthread_sigmask [test $HAVE_PSELECT = 0 || test $REPLACE_PSELECT = 1]
select [test $HAVE_PSELECT = 0 || test $REPLACE_PSELECT = 1]
dup2 [test $REPLACE_PSELECT = 1]
pthread #include <pthread.h> pthread.c
pthread.in.h
pthread.m4
00gnulib.m4
gl_PTHREAD_CHECK
gl_MODULE_INDICATOR([pthread])
extensions
extern-inline
sched
time
ptsname #include <stdlib.h> ptsname.c ptsname.m4
00gnulib.m4
gl_FUNC_PTSNAME
if test $HAVE_PTSNAME = 0 || test $REPLACE_PTSNAME = 1; then
AC_LIBOBJ([ptsname])
gl_PREREQ_PTSNAME
fi
gl_STDLIB_MODULE_INDICATOR([ptsname])
stdlib
extensions
ptsname_r [test $HAVE_PTSNAME = 0]
pwrite #include <unistd.h> pwrite.c pwrite.m4
00gnulib.m4
gl_FUNC_PWRITE
if test $HAVE_PWRITE = 0 || test $REPLACE_PWRITE = 1; then
AC_LIBOBJ([pwrite])
fi
gl_UNISTD_MODULE_INDICATOR([pwrite])
unistd
extensions
largefile
lseek [test $HAVE_PWRITE = 0 || test $REPLACE_PWRITE = 1]
write [test $HAVE_PWRITE = 0 || test $REPLACE_PWRITE = 1]
readlink #include <unistd.h> readlink.c readlink.m4
00gnulib.m4
gl_FUNC_READLINK
if test $HAVE_READLINK = 0 || test $REPLACE_READLINK = 1; then
AC_LIBOBJ([readlink])
gl_PREREQ_READLINK
fi
gl_UNISTD_MODULE_INDICATOR([readlink])
unistd
stat [test $HAVE_READLINK = 0 || test $REPLACE_READLINK = 1]
realloc-posix #include <stdlib.h> realloc.c realloc.m4
malloc.m4
00gnulib.m4
gl_FUNC_REALLOC_POSIX
if test $REPLACE_REALLOC = 1; then
AC_LIBOBJ([realloc])
fi
gl_STDLIB_MODULE_INDICATOR([realloc-posix])
stdlib
recv #include <sys/socket.h> recv.c
w32sock.h
00gnulib.m4
AC_REQUIRE([gl_HEADER_SYS_SOCKET])
if test "$ac_cv_header_winsock2_h" = yes; then
AC_LIBOBJ([recv])
fi
gl_SYS_SOCKET_MODULE_INDICATOR([recv])
sys_socket
socketlib
errno [test "$ac_cv_header_winsock2_h" = yes]
msvc-nothrow [test "$ac_cv_header_winsock2_h" = yes]
recvfrom #include <sys/socket.h> recvfrom.c
w32sock.h
00gnulib.m4
AC_REQUIRE([gl_HEADER_SYS_SOCKET])
if test "$ac_cv_header_winsock2_h" = yes; then
AC_LIBOBJ([recvfrom])
fi
gl_SYS_SOCKET_MODULE_INDICATOR([recvfrom])
sys_socket
socketlib
errno [test "$ac_cv_header_winsock2_h" = yes]
getpeername [test "$ac_cv_header_winsock2_h" = yes]
msvc-nothrow [test "$ac_cv_header_winsock2_h" = yes]
remove #include <stdio.h> remove.c remove.m4
00gnulib.m4
gl_FUNC_REMOVE
if test $REPLACE_REMOVE = 1; then
AC_LIBOBJ([remove])
fi
gl_STDIO_MODULE_INDICATOR([remove])
stdio
rmdir [test $REPLACE_REMOVE = 1]
unlink [test $REPLACE_REMOVE = 1]
scandir #include <dirent.h> scandir.c scandir.m4
00gnulib.m4
gl_FUNC_SCANDIR
if test $HAVE_SCANDIR = 0; then
AC_LIBOBJ([scandir])
gl_PREREQ_SCANDIR
fi
gl_DIRENT_MODULE_INDICATOR([scandir])
closedir
dirent
extensions
largefile
opendir
readdir
sched #include <sched.h> sched.in.h sched_h.m4
00gnulib.m4
gl_SCHED_H
include_next
select #include <sys/select.h> select.c select.m4
00gnulib.m4
gl_FUNC_SELECT
if test $REPLACE_SELECT = 1; then
AC_LIBOBJ([select])
fi
gl_SYS_SELECT_MODULE_INDICATOR([select])
sys_select
alloca [test $REPLACE_SELECT = 1]
dup2 [test $REPLACE_SELECT = 1]
sockets [test $REPLACE_SELECT = 1]
sys_time [test $REPLACE_SELECT = 1]
msvc-nothrow [test $REPLACE_SELECT = 1]
send #include <sys/socket.h> send.c
w32sock.h
00gnulib.m4
AC_REQUIRE([gl_HEADER_SYS_SOCKET])
if test "$ac_cv_header_winsock2_h" = yes; then
AC_LIBOBJ([send])
fi
gl_SYS_SOCKET_MODULE_INDICATOR([send])
sys_socket
socketlib
errno [test "$ac_cv_header_winsock2_h" = yes]
msvc-nothrow [test "$ac_cv_header_winsock2_h" = yes]
sendto #include <sys/socket.h> sendto.c
w32sock.h
00gnulib.m4
AC_REQUIRE([gl_HEADER_SYS_SOCKET])
if test "$ac_cv_header_winsock2_h" = yes; then
AC_LIBOBJ([sendto])
fi
gl_SYS_SOCKET_MODULE_INDICATOR([sendto])
sys_socket
socketlib
errno [test "$ac_cv_header_winsock2_h" = yes]
msvc-nothrow [test "$ac_cv_header_winsock2_h" = yes]
servent #include <netdb.h> --- servent.m4
00gnulib.m4
gl_SERVENT
sys_socket
setsockopt #include <sys/socket.h> setsockopt.c
w32sock.h
00gnulib.m4
AC_REQUIRE([gl_HEADER_SYS_SOCKET])
if test "$ac_cv_header_winsock2_h" = yes; then
AC_LIBOBJ([setsockopt])
fi
gl_SYS_SOCKET_MODULE_INDICATOR([setsockopt])
sys_socket
socketlib
sys_time [test "$ac_cv_header_winsock2_h" = yes]
errno [test "$ac_cv_header_winsock2_h" = yes]
msvc-nothrow [test "$ac_cv_header_winsock2_h" = yes]
shutdown #include <sys/socket.h> shutdown.c
w32sock.h
00gnulib.m4
AC_REQUIRE([gl_HEADER_SYS_SOCKET])
if test "$ac_cv_header_winsock2_h" = yes; then
AC_LIBOBJ([shutdown])
fi
gl_SYS_SOCKET_MODULE_INDICATOR([shutdown])
sys_socket
socketlib
errno [test "$ac_cv_header_winsock2_h" = yes]
msvc-nothrow [test "$ac_cv_header_winsock2_h" = yes]
signal-h #include <signal.h> signal.in.h signal_h.m4
00gnulib.m4
gl_SIGNAL_H
include_next
snippet/arg-nonnull
snippet/c++defs
snippet/warn-on-use
extensions
sleep #include <unistd.h> sleep.c sleep.m4
00gnulib.m4
gl_FUNC_SLEEP
if test $HAVE_SLEEP = 0 || test $REPLACE_SLEEP = 1; then
AC_LIBOBJ([sleep])
fi
gl_UNISTD_MODULE_INDICATOR([sleep])
unistd
stdint [test $HAVE_SLEEP = 0 || test $REPLACE_SLEEP = 1]
verify [test $HAVE_SLEEP = 0 || test $REPLACE_SLEEP = 1]
snprintf-posix #include <stdio.h> --- snprintf-posix.m4
printf.m4
math_h.m4
00gnulib.m4
gl_FUNC_SNPRINTF_POSIX
snprintf
nocrash
printf-safe
multiarch
vasnprintf [test $ac_cv_func_snprintf = no || test $REPLACE_SNPRINTF = 1]
isnand-nolibm [test $ac_cv_func_snprintf = no || test $REPLACE_SNPRINTF = 1]
isnanl-nolibm [test $ac_cv_func_snprintf = no || test $REPLACE_SNPRINTF = 1]
frexp-nolibm [test $ac_cv_func_snprintf = no || test $REPLACE_SNPRINTF = 1]
frexpl-nolibm [test $ac_cv_func_snprintf = no || test $REPLACE_SNPRINTF = 1]
printf-frexp [test $ac_cv_func_snprintf = no || test $REPLACE_SNPRINTF = 1]
printf-frexpl [test $ac_cv_func_snprintf = no || test $REPLACE_SNPRINTF = 1]
signbit [test $ac_cv_func_snprintf = no || test $REPLACE_SNPRINTF = 1]
fpucw [test $ac_cv_func_snprintf = no || test $REPLACE_SNPRINTF = 1]
socket #include <sys/socket.h> socket.c
w32sock.h
00gnulib.m4
AC_REQUIRE([gl_HEADER_SYS_SOCKET])
if test "$ac_cv_header_winsock2_h" = yes; then
AC_LIBOBJ([socket])
fi
# When this module is used, sockets may actually occur as file descriptors,
# hence it is worth warning if the modules 'close' and 'ioctl' are not used.
m4_ifdef([gl_UNISTD_H_DEFAULTS], [AC_REQUIRE([gl_UNISTD_H_DEFAULTS])])
m4_ifdef([gl_SYS_IOCTL_H_DEFAULTS], [AC_REQUIRE([gl_SYS_IOCTL_H_DEFAULTS])])
AC_REQUIRE([gl_PREREQ_SYS_H_WINSOCK2])
if test "$ac_cv_header_winsock2_h" = yes; then
UNISTD_H_HAVE_WINSOCK2_H_AND_USE_SOCKETS=1
SYS_IOCTL_H_HAVE_WINSOCK2_H_AND_USE_SOCKETS=1
fi
gl_SYS_SOCKET_MODULE_INDICATOR([socket])
sys_socket
socketlib
errno [test "$ac_cv_header_winsock2_h" = yes]
sockets [test "$ac_cv_header_winsock2_h" = yes]
msvc-nothrow [test "$ac_cv_header_winsock2_h" = yes]
spawn #include <spawn.h> spawn.in.h spawn_h.m4
00gnulib.m4
gl_SPAWN_H
include_next
sched
snippet/arg-nonnull
snippet/c++defs
snippet/warn-on-use
sprintf-posix #include <stdio.h> sprintf.c sprintf-posix.m4
printf.m4
math_h.m4
00gnulib.m4
gl_FUNC_SPRINTF_POSIX
gl_STDIO_MODULE_INDICATOR([sprintf-posix])
stdio
nocrash
printf-safe
multiarch
vasnprintf [test $REPLACE_SPRINTF = 1]
isnand-nolibm [test $REPLACE_SPRINTF = 1]
isnanl-nolibm [test $REPLACE_SPRINTF = 1]
frexp-nolibm [test $REPLACE_SPRINTF = 1]
frexpl-nolibm [test $REPLACE_SPRINTF = 1]
printf-frexp [test $REPLACE_SPRINTF = 1]
printf-frexpl [test $REPLACE_SPRINTF = 1]
signbit [test $REPLACE_SPRINTF = 1]
fpucw [test $REPLACE_SPRINTF = 1]
stdint [test $REPLACE_SPRINTF = 1]
errno [test $REPLACE_SPRINTF = 1]
stat #include <sys/stat.h> stat.c stat.m4
00gnulib.m4
gl_FUNC_STAT
if test $REPLACE_STAT = 1; then
AC_LIBOBJ([stat])
gl_PREREQ_STAT
fi
gl_SYS_STAT_MODULE_INDICATOR([stat])
sys_stat
largefile
dosname [test $REPLACE_STAT = 1]
pathmax [test $REPLACE_STAT = 1]
stdbool [test $REPLACE_STAT = 1]
verify [test $REPLACE_STAT = 1]
strdup-posix #include <string.h> strdup.c strdup.m4
00gnulib.m4
gl_FUNC_STRDUP_POSIX
if test $ac_cv_func_strdup = no || test $REPLACE_STRDUP = 1; then
AC_LIBOBJ([strdup])
gl_PREREQ_STRDUP
fi
gl_STRING_MODULE_INDICATOR([strdup])
string
malloc-posix [test $ac_cv_func_strdup = no || test $REPLACE_STRDUP = 1]
string #include <string.h> string.in.h string_h.m4
00gnulib.m4
gl_HEADER_STRING_H
extensions
extern-inline
include_next
snippet/arg-nonnull
snippet/c++defs
snippet/warn-on-use
stddef
strings #include <strings.h> strings.in.h strings_h.m4
00gnulib.m4
gl_HEADER_STRINGS_H
include_next
snippet/arg-nonnull
snippet/c++defs
snippet/warn-on-use
sys_types
tempname #include "tempname.h" tempname.c tempname.m4
00gnulib.m4
gl_FUNC_GEN_TEMPNAME
extensions
fcntl-h
gettimeofday
lstat
secure_getenv
stdint
sys_stat
sys_time
time #include <time.h> time.in.h time_h.m4
00gnulib.m4
gl_HEADER_TIME_H
extensions
gettimeofday
include_next
snippet/arg-nonnull
snippet/c++defs
snippet/warn-on-use
stddef
time_r #include <time.h> time_r.c time_r.m4
00gnulib.m4
gl_TIME_R
if test $HAVE_LOCALTIME_R = 0 || test $REPLACE_LOCALTIME_R = 1; then
AC_LIBOBJ([time_r])
gl_PREREQ_TIME_R
fi
gl_TIME_MODULE_INDICATOR([time_r])
extensions
time
times #include <sys/times.h> times.c times.m4
00gnulib.m4
gl_FUNC_TIMES
if test $HAVE_TIMES = 0; then
AC_LIBOBJ([times])
fi
gl_SYS_TIMES_MODULE_INDICATOR([times])
sys_times
timespec #include "timespec.h" timespec.c timespec.m4
00gnulib.m4
gl_TIMESPEC
extern-inline
time
nanosleep #include <time.h> nanosleep.c nanosleep.m4
00gnulib.m4
gl_FUNC_NANOSLEEP
if test $HAVE_NANOSLEEP = 0 || test $REPLACE_NANOSLEEP = 1; then
AC_LIBOBJ([nanosleep])
gl_PREREQ_NANOSLEEP
fi
gl_TIME_MODULE_INDICATOR([nanosleep])
time
extensions
multiarch
intprops [test $HAVE_NANOSLEEP = 0 || test $REPLACE_NANOSLEEP = 1]
select [test $HAVE_NANOSLEEP = 0 || test $REPLACE_NANOSLEEP = 1]
sigaction [test $HAVE_NANOSLEEP = 0 || test $REPLACE_NANOSLEEP = 1]
stdbool [test $HAVE_NANOSLEEP = 0 || test $REPLACE_NANOSLEEP = 1]
sys_select [test $HAVE_NANOSLEEP = 0 || test $REPLACE_NANOSLEEP = 1]
sys_time [test $HAVE_NANOSLEEP = 0 || test $REPLACE_NANOSLEEP = 1]
verify [test $HAVE_NANOSLEEP = 0 || test $REPLACE_NANOSLEEP = 1]
pthread_sigmask #include <signal.h> pthread_sigmask.c pthread_sigmask.m4
00gnulib.m4
gl_FUNC_PTHREAD_SIGMASK
if test $HAVE_PTHREAD_SIGMASK = 0 || test $REPLACE_PTHREAD_SIGMASK = 1; then
AC_LIBOBJ([pthread_sigmask])
gl_PREREQ_PTHREAD_SIGMASK
fi
gl_SIGNAL_MODULE_INDICATOR([pthread_sigmask])
signal-h
threadlib
sigprocmask [test $HAVE_PTHREAD_SIGMASK = 0 || test $REPLACE_PTHREAD_SIGMASK = 1]
regex #include <regex.h> regex.h
regex.c
regex_internal.c
regex_internal.h
regexec.c
regcomp.c
eealloc.m4
regex.m4
mbstate_t.m4
00gnulib.m4
gl_REGEX
if test $ac_use_included_regex = yes; then
AC_LIBOBJ([regex])
gl_PREREQ_REGEX
fi
extensions
ssize_t
alloca-opt [test $ac_use_included_regex = yes]
btowc [test $ac_use_included_regex = yes]
gettext-h [test $ac_use_included_regex = yes]
lock [test "$ac_cv_gnu_library_2_1:$ac_use_included_regex" = no:yes]
memcmp [test $ac_use_included_regex = yes]
memmove [test $ac_use_included_regex = yes]
mbrtowc [test $ac_use_included_regex = yes]
mbsinit [test $ac_use_included_regex = yes]
nl_langinfo [test $ac_use_included_regex = yes]
stdbool [test $ac_use_included_regex = yes]
stdint [test $ac_use_included_regex = yes]
wchar [test $ac_use_included_regex = yes]
wcrtomb [test $ac_use_included_regex = yes]
wctype-h [test $ac_use_included_regex = yes]
wctype [test $ac_use_included_regex = yes]
rename #include <stdio.h> rename.c rename.m4
00gnulib.m4
gl_FUNC_RENAME
if test $REPLACE_RENAME = 1; then
AC_LIBOBJ([rename])
fi
gl_STDIO_MODULE_INDICATOR([rename])
stdio
canonicalize-lgpl [test $REPLACE_RENAME = 1]
chdir [test $REPLACE_RENAME = 1]
dirname-lgpl [test $REPLACE_RENAME = 1]
lstat [test $REPLACE_RENAME = 1]
rmdir [test $REPLACE_RENAME = 1]
same-inode [test $REPLACE_RENAME = 1]
stdbool [test $REPLACE_RENAME = 1]
strdup [test $REPLACE_RENAME = 1]
renameat #include <fcntl.h>
#include <stdio.h>
at-func2.c
renameat.c
renameat.m4
00gnulib.m4
gl_FUNC_RENAMEAT
if test $HAVE_RENAMEAT = 0 || test $REPLACE_RENAMEAT = 1; then
AC_LIBOBJ([renameat])
fi
if test $HAVE_RENAMEAT = 0; then
AC_LIBOBJ([at-func2])
fi
gl_STDIO_MODULE_INDICATOR([renameat])
stdio
extensions
fcntl-h
filenamecat-lgpl [test $HAVE_RENAMEAT = 0 || test $REPLACE_RENAMEAT = 1]
openat-h [test $HAVE_RENAMEAT = 0 || test $REPLACE_RENAMEAT = 1]
statat [test $REPLACE_RENAMEAT = 1]
stdbool [test $REPLACE_RENAMEAT = 1]
at-internal [test $HAVE_RENAMEAT = 0]
dosname [test $HAVE_RENAMEAT = 0]
getcwd-lgpl [test $HAVE_RENAMEAT = 0]
openat-die [test $HAVE_RENAMEAT = 0]
rename [test $HAVE_RENAMEAT = 0]
same-inode [test $HAVE_RENAMEAT = 0]
save-cwd [test $HAVE_RENAMEAT = 0]
rmdir #include <unistd.h> rmdir.c rmdir.m4
00gnulib.m4
gl_FUNC_RMDIR
if test $REPLACE_RMDIR = 1; then
AC_LIBOBJ([rmdir])
fi
gl_UNISTD_MODULE_INDICATOR([rmdir])
unistd
dosname [test $REPLACE_RMDIR = 1]
sys_stat [test $REPLACE_RMDIR = 1]
search #include <search.h> search.in.h search_h.m4
00gnulib.m4
gl_SEARCH_H
include_next
snippet/arg-nonnull
snippet/c++defs
snippet/warn-on-use
sigaction #include <signal.h> sigaction.c
sig-handler.h
sig-handler.c
sigaction.m4
00gnulib.m4
gl_SIGACTION
if test $HAVE_SIGACTION = 0; then
AC_LIBOBJ([sigaction])
gl_PREREQ_SIGACTION
fi
gl_SIGNAL_MODULE_INDICATOR([sigaction])
extern-inline
signal-h
sigprocmask [test $HAVE_SIGACTION = 0]
sigprocmask #include <signal.h> sigprocmask.c signalblocking.m4
00gnulib.m4
gl_SIGNALBLOCKING
if test $HAVE_POSIX_SIGNALBLOCKING = 0; then
AC_LIBOBJ([sigprocmask])
gl_PREREQ_SIGPROCMASK
fi
gl_SIGNAL_MODULE_INDICATOR([sigprocmask])
signal-h
stdint [test $HAVE_POSIX_SIGNALBLOCKING = 0]
raise [test $HAVE_POSIX_SIGNALBLOCKING = 0]
msvc-inval [test $HAVE_POSIX_SIGNALBLOCKING = 0]
socklen #include <sys/types.h>
#if HAVE_SYS_SOCKET_H
# include <sys/socket.h>
#elif HAVE_WS2TCPIP_H
# include <ws2tcpip.h>
#endif
--- socklen.m4
00gnulib.m4
gl_TYPE_SOCKLEN_T
---
ssize_t #include <sys/types.h> --- ssize_t.m4
00gnulib.m4
gt_TYPE_SSIZE_T
---
strptime #include <time.h> strptime.c strptime.m4
tm_gmtoff.m4
00gnulib.m4
gl_FUNC_STRPTIME
if test $HAVE_STRPTIME = 0; then
AC_LIBOBJ([strptime])
gl_PREREQ_STRPTIME
fi
gl_TIME_MODULE_INDICATOR([strptime])
time
extensions
sys_time [test $HAVE_STRPTIME = 0]
string [test $HAVE_STRPTIME = 0]
strcase [test $HAVE_STRPTIME = 0]
stdbool [test $HAVE_STRPTIME = 0]
time_r [test $HAVE_STRPTIME = 0]
strtok_r #include <string.h> strtok_r.c strtok_r.m4
00gnulib.m4
gl_FUNC_STRTOK_R
if test $HAVE_STRTOK_R = 0 || test $REPLACE_STRTOK_R = 1; then
AC_LIBOBJ([strtok_r])
gl_PREREQ_STRTOK_R
fi
gl_STRING_MODULE_INDICATOR([strtok_r])
string
strpbrk [test $HAVE_STRTOK_R = 0 || test $REPLACE_STRTOK_R = 1]
sys_select #include <sys/select.h> sys_select.in.h sys_select_h.m4
sys_socket_h.m4
00gnulib.m4
gl_HEADER_SYS_SELECT
AC_PROG_MKDIR_P
include_next
signal-h
snippet/c++defs
snippet/warn-on-use
sys_time
sys_socket #include <sys/socket.h> sys_socket.c
sys_socket.in.h
sys_socket_h.m4
sockpfaf.m4
00gnulib.m4
AC_REQUIRE([gl_HEADER_SYS_SOCKET])
AC_PROG_MKDIR_P
errno
extern-inline
include_next
snippet/arg-nonnull
snippet/c++defs
snippet/warn-on-use
socklen
ssize_t
stdalign
sys_uio
sys_stat #include <sys/stat.h> sys_stat.in.h sys_stat_h.m4
unistd_h.m4
00gnulib.m4
gl_HEADER_SYS_STAT_H
AC_PROG_MKDIR_P
include_next
snippet/arg-nonnull
snippet/c++defs
snippet/warn-on-use
sys_types
time
sys_time #include <sys/time.h> sys_time.in.h sys_time_h.m4
sys_socket_h.m4
00gnulib.m4
gl_HEADER_SYS_TIME_H
AC_PROG_MKDIR_P
include_next
snippet/arg-nonnull
snippet/c++defs
snippet/warn-on-use
sys_times #include <sys/times.h> sys_times.in.h sys_times_h.m4
00gnulib.m4
gl_SYS_TIMES_H
AC_PROG_MKDIR_P
include_next
snippet/arg-nonnull
snippet/warn-on-use
sys_uio #include <sys/uio.h> sys_uio.in.h sys_uio_h.m4
00gnulib.m4
gl_HEADER_SYS_UIO
AC_PROG_MKDIR_P
include_next
ssize_t
sys_types
sys_utsname #include <sys/utsname.h> sys_utsname.in.h sys_utsname_h.m4
00gnulib.m4
gl_SYS_UTSNAME_H
AC_PROG_MKDIR_P
include_next
snippet/arg-nonnull
snippet/warn-on-use
sys_wait #include <sys/wait.h> sys_wait.in.h sys_wait_h.m4
00gnulib.m4
gl_SYS_WAIT_H
AC_PROG_MKDIR_P
include_next
snippet/c++defs
snippet/warn-on-use
tsearch #include <search.h> tsearch.c tsearch.m4
00gnulib.m4
gl_FUNC_TSEARCH
if test $HAVE_TSEARCH = 0 || test $REPLACE_TSEARCH = 1; then
AC_LIBOBJ([tsearch])
gl_PREREQ_TSEARCH
fi
gl_SEARCH_MODULE_INDICATOR([tsearch])
search
ttyname_r #include <unistd.h> ttyname_r.c ttyname_r.m4
00gnulib.m4
gl_FUNC_TTYNAME_R
if test $HAVE_TTYNAME_R = 0 || test $REPLACE_TTYNAME_R = 1; then
AC_LIBOBJ([ttyname_r])
gl_PREREQ_TTYNAME_R
fi
gl_UNISTD_MODULE_INDICATOR([ttyname_r])
unistd
extensions
uname #include <sys/utsname.h> uname.c uname.m4
00gnulib.m4
gl_FUNC_UNAME
if test $HAVE_UNAME = 0; then
AC_LIBOBJ([uname])
gl_PREREQ_UNAME
fi
gl_SYS_UTSNAME_MODULE_INDICATOR([uname])
sys_utsname
gethostname [test $HAVE_UNAME = 0]
unistd #include <unistd.h> unistd.c
unistd.in.h
unistd_h.m4
off_t.m4
00gnulib.m4
gl_UNISTD_H
extern-inline
include_next
snippet/arg-nonnull
snippet/c++defs
snippet/warn-on-use
ssize_t
stddef
sys_types
unlink #include <unistd.h> unlink.c unlink.m4
00gnulib.m4
gl_FUNC_UNLINK
if test $REPLACE_UNLINK = 1; then
AC_LIBOBJ([unlink])
fi
gl_UNISTD_MODULE_INDICATOR([unlink])
unistd
dosname [test $REPLACE_UNLINK = 1]
lstat [test $REPLACE_UNLINK = 1]
unlockpt #include <stdlib.h> unlockpt.c unlockpt.m4
00gnulib.m4
gl_FUNC_UNLOCKPT
if test $HAVE_UNLOCKPT = 0; then
AC_LIBOBJ([unlockpt])
gl_PREREQ_UNLOCKPT
fi
gl_STDLIB_MODULE_INDICATOR([unlockpt])
stdlib
extensions
fcntl-h [test $HAVE_UNLOCKPT = 0]
ptsname [test $HAVE_UNLOCKPT = 0]
utimensat #include <sys/stat.h> utimensat.c
at-func.c
utimensat.m4
00gnulib.m4
gl_FUNC_UTIMENSAT
if test $HAVE_UTIMENSAT = 0 || test $REPLACE_UTIMENSAT = 1; then
AC_LIBOBJ([utimensat])
fi
gl_SYS_STAT_MODULE_INDICATOR([utimensat])
sys_stat
extensions
at-internal [test $HAVE_UTIMENSAT = 0 || test $REPLACE_UTIMENSAT = 1]
dosname [test $HAVE_UTIMENSAT = 0 || test $REPLACE_UTIMENSAT = 1]
errno [test $HAVE_UTIMENSAT = 0 || test $REPLACE_UTIMENSAT = 1]
fchdir [test $HAVE_UTIMENSAT = 0 || test $REPLACE_UTIMENSAT = 1]
fcntl-h [test $HAVE_UTIMENSAT = 0 || test $REPLACE_UTIMENSAT = 1]
openat-die [test $HAVE_UTIMENSAT = 0 || test $REPLACE_UTIMENSAT = 1]
openat-h [test $HAVE_UTIMENSAT = 0 || test $REPLACE_UTIMENSAT = 1]
save-cwd [test $HAVE_UTIMENSAT = 0 || test $REPLACE_UTIMENSAT = 1]
utimens [test $HAVE_UTIMENSAT = 0 || test $REPLACE_UTIMENSAT = 1]
fstatat [test $REPLACE_UTIMENSAT = 1]
vasnprintf-posix #include "vasnprintf.h" --- vasnprintf-posix.m4
printf.m4
math_h.m4
00gnulib.m4
gl_FUNC_VASNPRINTF_POSIX
vasnprintf
isnand-nolibm
isnanl-nolibm
frexp-nolibm
frexpl-nolibm
printf-frexp
printf-frexpl
signbit
fpucw
nocrash
printf-safe
multiarch
vasprintf-posix #include "vasprintf.h" --- vasprintf-posix.m4
printf.m4
math_h.m4
00gnulib.m4
gl_FUNC_VASPRINTF_POSIX
vasprintf
vasnprintf
isnand-nolibm
isnanl-nolibm
frexp-nolibm
frexpl-nolibm
printf-frexp
printf-frexpl
signbit
fpucw
nocrash
printf-safe
multiarch
vdprintf #include <stdio.h> vdprintf.c vdprintf.m4
00gnulib.m4
gl_FUNC_VDPRINTF
gl_STDIO_MODULE_INDICATOR([vdprintf])
stdio
vasnprintf [test $ac_cv_func_vdprintf = no || test $REPLACE_VDPRINTF = 1]
full-write [test $ac_cv_func_vdprintf = no || test $REPLACE_VDPRINTF = 1]
errno [test $ac_cv_func_vdprintf = no || test $REPLACE_VDPRINTF = 1]
vdprintf-posix #include <stdio.h> --- vdprintf-posix.m4
printf.m4
math_h.m4
00gnulib.m4
gl_FUNC_VDPRINTF_POSIX
vdprintf
nocrash
printf-safe
multiarch
vasnprintf [test $ac_cv_func_vdprintf = no || test $REPLACE_VDPRINTF = 1]
isnand-nolibm [test $ac_cv_func_vdprintf = no || test $REPLACE_VDPRINTF = 1]
isnanl-nolibm [test $ac_cv_func_vdprintf = no || test $REPLACE_VDPRINTF = 1]
frexp-nolibm [test $ac_cv_func_vdprintf = no || test $REPLACE_VDPRINTF = 1]
frexpl-nolibm [test $ac_cv_func_vdprintf = no || test $REPLACE_VDPRINTF = 1]
printf-frexp [test $ac_cv_func_vdprintf = no || test $REPLACE_VDPRINTF = 1]
printf-frexpl [test $ac_cv_func_vdprintf = no || test $REPLACE_VDPRINTF = 1]
signbit [test $ac_cv_func_vdprintf = no || test $REPLACE_VDPRINTF = 1]
fpucw [test $ac_cv_func_vdprintf = no || test $REPLACE_VDPRINTF = 1]
vfprintf-posix #include <stdio.h> vfprintf.c vfprintf-posix.m4
printf.m4
math_h.m4
00gnulib.m4
gl_FUNC_VFPRINTF_POSIX
gl_STDIO_MODULE_INDICATOR([vfprintf-posix])
stdio
nocrash
printf-safe
multiarch
fseterr [test $REPLACE_VFPRINTF = 1]
vasnprintf [test $REPLACE_VFPRINTF = 1]
isnand-nolibm [test $REPLACE_VFPRINTF = 1]
isnanl-nolibm [test $REPLACE_VFPRINTF = 1]
frexp-nolibm [test $REPLACE_VFPRINTF = 1]
frexpl-nolibm [test $REPLACE_VFPRINTF = 1]
printf-frexp [test $REPLACE_VFPRINTF = 1]
printf-frexpl [test $REPLACE_VFPRINTF = 1]
signbit [test $REPLACE_VFPRINTF = 1]
fpucw [test $REPLACE_VFPRINTF = 1]
errno [test $REPLACE_VFPRINTF = 1]
vprintf-posix #include <stdio.h> vprintf.c vprintf-posix.m4
printf.m4
00gnulib.m4
gl_FUNC_VPRINTF_POSIX
gl_STDIO_MODULE_INDICATOR([vprintf-posix])
stdio
printf-safe
vfprintf-posix [test $REPLACE_VPRINTF = 1]
vsnprintf-posix #include <stdio.h> --- vsnprintf-posix.m4
printf.m4
math_h.m4
00gnulib.m4
gl_FUNC_VSNPRINTF_POSIX
vsnprintf
nocrash
printf-safe
multiarch
vasnprintf [test $ac_cv_func_vsnprintf = no || test $REPLACE_VSNPRINTF = 1]
isnand-nolibm [test $ac_cv_func_vsnprintf = no || test $REPLACE_VSNPRINTF = 1]
isnanl-nolibm [test $ac_cv_func_vsnprintf = no || test $REPLACE_VSNPRINTF = 1]
frexp-nolibm [test $ac_cv_func_vsnprintf = no || test $REPLACE_VSNPRINTF = 1]
frexpl-nolibm [test $ac_cv_func_vsnprintf = no || test $REPLACE_VSNPRINTF = 1]
printf-frexp [test $ac_cv_func_vsnprintf = no || test $REPLACE_VSNPRINTF = 1]
printf-frexpl [test $ac_cv_func_vsnprintf = no || test $REPLACE_VSNPRINTF = 1]
signbit [test $ac_cv_func_vsnprintf = no || test $REPLACE_VSNPRINTF = 1]
fpucw [test $ac_cv_func_vsnprintf = no || test $REPLACE_VSNPRINTF = 1]
vsprintf-posix #include <stdio.h> vsprintf.c vsprintf-posix.m4
printf.m4
math_h.m4
00gnulib.m4
gl_FUNC_VSPRINTF_POSIX
gl_STDIO_MODULE_INDICATOR([vsprintf-posix])
stdio
nocrash
printf-safe
multiarch
vasnprintf [test $REPLACE_VSPRINTF = 1]
isnand-nolibm [test $REPLACE_VSPRINTF = 1]
isnanl-nolibm [test $REPLACE_VSPRINTF = 1]
frexp-nolibm [test $REPLACE_VSPRINTF = 1]
frexpl-nolibm [test $REPLACE_VSPRINTF = 1]
printf-frexp [test $REPLACE_VSPRINTF = 1]
printf-frexpl [test $REPLACE_VSPRINTF = 1]
signbit [test $REPLACE_VSPRINTF = 1]
fpucw [test $REPLACE_VSPRINTF = 1]
stdint [test $REPLACE_VSPRINTF = 1]
errno [test $REPLACE_VSPRINTF = 1]
wcsnrtombs #include <wchar.h> wcsnrtombs.c
wcsnrtombs-impl.h
wcsrtombs-state.c
wcsnrtombs.m4
mbrtowc.m4
mbstate_t.m4
locale-ja.m4
locale-zh.m4
codeset.m4
00gnulib.m4
gl_FUNC_WCSNRTOMBS
if test $HAVE_WCSNRTOMBS = 0 || test $REPLACE_WCSNRTOMBS = 1; then
AC_LIBOBJ([wcsnrtombs])
AC_LIBOBJ([wcsrtombs-state])
gl_PREREQ_WCSNRTOMBS
fi
gl_WCHAR_MODULE_INDICATOR([wcsnrtombs])
wchar
extensions
wcrtomb [test $HAVE_WCSNRTOMBS = 0 || test $REPLACE_WCSNRTOMBS = 1]
wcwidth #include <wchar.h> wcwidth.c wcwidth.m4
wchar_t.m4
wint_t.m4
00gnulib.m4
gl_FUNC_WCWIDTH
if test $HAVE_WCWIDTH = 0 || test $REPLACE_WCWIDTH = 1; then
AC_LIBOBJ([wcwidth])
fi
gl_WCHAR_MODULE_INDICATOR([wcwidth])
wchar
extensions
wctype-h [test $HAVE_WCWIDTH = 0 || test $REPLACE_WCWIDTH = 1]
localcharset [test $HAVE_WCWIDTH = 0 || test $REPLACE_WCWIDTH = 1]
streq [test $HAVE_WCWIDTH = 0 || test $REPLACE_WCWIDTH = 1]
uniwidth/width [test $HAVE_WCWIDTH = 0 || test $REPLACE_WCWIDTH = 1]
write #include <unistd.h> write.c write.m4
00gnulib.m4
gl_FUNC_WRITE
if test $REPLACE_WRITE = 1; then
AC_LIBOBJ([write])
gl_PREREQ_WRITE
fi
gl_UNISTD_MODULE_INDICATOR([write])
unistd
raise [test $REPLACE_WRITE = 1]
msvc-inval [test $REPLACE_WRITE = 1]
msvc-nothrow [test $REPLACE_WRITE = 1]

Compatibility checks for POSIX:2008 functions

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

Enhancements for POSIX:2008 functions

modules/ lib/ lib/ m4/  
Module Header Implementation Autoconf macro Depends on
chdir-long #include "chdir-long.h" chdir-long.c chdir-long.m4
pathmax.m4
00gnulib.m4
gl_FUNC_CHDIR_LONG
if test $gl_cv_have_arbitrary_file_name_length_limit = yes; then
AC_LIBOBJ([chdir-long])
gl_PREREQ_CHDIR_LONG
fi
unistd
pathmax
chdir
assure [test $gl_cv_have_arbitrary_file_name_length_limit = yes]
atexit [test $gl_cv_have_arbitrary_file_name_length_limit = yes]
fchdir [test $gl_cv_have_arbitrary_file_name_length_limit = yes]
fcntl-h [test $gl_cv_have_arbitrary_file_name_length_limit = yes]
openat [test $gl_cv_have_arbitrary_file_name_length_limit = yes]
memchr [test $gl_cv_have_arbitrary_file_name_length_limit = yes]
mempcpy [test $gl_cv_have_arbitrary_file_name_length_limit = yes]
memrchr [test $gl_cv_have_arbitrary_file_name_length_limit = yes]
stdbool [test $gl_cv_have_arbitrary_file_name_length_limit = yes]
stdlib [test $gl_cv_have_arbitrary_file_name_length_limit = yes]
dirent-safer #include "dirent-safer.h" dirent--.h
opendir-safer.c
dirent-safer.m4
00gnulib.m4
gl_DIRENT_SAFER
gl_MODULE_INDICATOR([dirent-safer])
dirent
closedir
dirfd
opendir
unistd-safer
dirname #include "dirname.h" dirname.c
basename.c
stripslash.c
00gnulib.m4
gl_DIRNAME
gl_MODULE_INDICATOR([dirname])
dirname-lgpl
xalloc
xstrndup
dirname-lgpl #include "dirname.h" dirname-lgpl.c
basename-lgpl.c
stripslash.c
dirname.m4
00gnulib.m4
gl_DIRNAME_LGPL
dosname
double-slash-root
malloc-posix
stdbool
getopt-gnu #include <getopt.h> --- 00gnulib.m4
gl_FUNC_GETOPT_GNU
if test $REPLACE_GETOPT = 1; then
AC_LIBOBJ([getopt])
AC_LIBOBJ([getopt1])
gl_PREREQ_GETOPT
dnl Arrange for unistd.h to include getopt.h.
GNULIB_${gl_include_guard_prefix}_UNISTD_H_GETOPT=1
fi
AC_SUBST([GNULIB_${gl_include_guard_prefix}_UNISTD_H_GETOPT])
gl_MODULE_INDICATOR_FOR_TESTS([getopt-gnu])
nocrash
getopt-posix
iconv_open-utf --- --- iconv_open-utf.m4
00gnulib.m4
gl_FUNC_ICONV_OPEN_UTF
iconv_open
unistd-safer #include "unistd-safer.h" unistd--.h
dup-safer.c
fd-safer.c
pipe-safer.c
unistd-safer.m4
00gnulib.m4
gl_UNISTD_SAFER
fcntl
unistd
fnmatch #include <fnmatch.h> fnmatch.in.h
fnmatch.c
fnmatch_loop.c
mbstate_t.m4
fnmatch.m4
00gnulib.m4
gl_FUNC_FNMATCH_POSIX
if test -n "$FNMATCH_H"; then
AC_LIBOBJ([fnmatch])
gl_PREREQ_FNMATCH
fi
extensions
snippet/arg-nonnull
alloca [test -n "$FNMATCH_H"]
stdbool [test -n "$FNMATCH_H"]
wchar [test -n "$FNMATCH_H"]
wctype-h [test -n "$FNMATCH_H"]
memchr [test -n "$FNMATCH_H"]
memcmp [test -n "$FNMATCH_H"]
mbsrtowcs [test -n "$FNMATCH_H"]
mbsinit [test -n "$FNMATCH_H"]
fnmatch-posix #include "fnmatch.h" --- 00gnulib.m4 fnmatch
fnmatch-gnu #include "fnmatch.h" --- 00gnulib.m4
gl_FUNC_FNMATCH_GNU
if test -n "$FNMATCH_H"; then
AC_LIBOBJ([fnmatch])
gl_PREREQ_FNMATCH
fi
fnmatch
glob #include <glob.h> glob.in.h
glob-libc.h
glob.c
glob.m4
00gnulib.m4
gl_GLOB
if test -n "$GLOB_H"; then
AC_LIBOBJ([glob])
gl_PREREQ_GLOB
fi
extensions
largefile
snippet/arg-nonnull
snippet/c++defs
snippet/warn-on-use
alloca [test -n "$GLOB_H"]
closedir [test -n "$GLOB_H"]
d-type [test -n "$GLOB_H"]
dirfd [test -n "$GLOB_H"]
fnmatch [test -n "$GLOB_H"]
getlogin_r [test -n "$GLOB_H"]
memchr [test -n "$GLOB_H"]
mempcpy [test -n "$GLOB_H"]
opendir [test -n "$GLOB_H"]
readdir [test -n "$GLOB_H"]
stdbool [test -n "$GLOB_H"]
strdup [test -n "$GLOB_H"]
sys_stat [test -n "$GLOB_H"]
unistd [test -n "$GLOB_H"]
malloc-posix [test -n "$GLOB_H"]
exclude #include "exclude.h" exclude.c 00gnulib.m4 filename
fnmatch
hash
mbscasecmp
mbuiter
regex
stdbool
verify
xalloc

Extra functions based on POSIX:2008

Input/output

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

Numeric conversion functions

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

File system functions

modules/ lib/ lib/ m4/  
Module Header Implementation Autoconf macro Depends on
acl #include "acl.h" copy-acl.c
set-acl.c
00gnulib.m4 error
gettext-h
qacl
quote
areadlink #include "areadlink.h" areadlink.c 00gnulib.m4 careadlinkat
readlink
areadlink-with-size #include "areadlink.h" areadlink-with-size.c 00gnulib.m4 readlink
ssize_t
stdint
unistd
areadlinkat #include "areadlink.h" areadlinkat.c
at-func.c
00gnulib.m4
gl_MODULE_INDICATOR([areadlinkat])
areadlink
careadlinkat
readlinkat
at-internal
dosname
errno
extensions
fchdir
fcntl-h
openat-die
openat-h
save-cwd
areadlinkat-with-size #include "areadlink.h" areadlinkat-with-size.c
at-func.c
00gnulib.m4
gl_MODULE_INDICATOR([areadlinkat-with-size])
areadlink-with-size
stdint
readlinkat
at-internal
dosname
errno
extensions
fchdir
fcntl-h
openat-die
openat-h
save-cwd
unistd
backupfile #include "backupfile.h" backupfile.c backupfile.m4
00gnulib.m4
gl_BACKUPFILE
argmatch
closedir
d-ino
dirent-safer
dirname-lgpl
memcmp
opendir
readdir
stdbool
canonicalize #include "canonicalize.h" canonicalize.c canonicalize.m4
double-slash-root.m4
00gnulib.m4
gl_FUNC_CANONICALIZE_FILENAME_MODE
gl_MODULE_INDICATOR([canonicalize])
gl_MODULE_INDICATOR_FOR_TESTS([canonicalize])
gl_STDLIB_MODULE_INDICATOR([canonicalize_file_name])
areadlink-with-size
errno
extensions
file-set
hash-triple
lstat
memmove
nocrash
pathmax
sys_stat
xalloc
xgetcwd
canonicalize-lgpl #include <stdlib.h> canonicalize-lgpl.c canonicalize.m4
double-slash-root.m4
00gnulib.m4
gl_CANONICALIZE_LGPL
if test $HAVE_CANONICALIZE_FILE_NAME = 0 || test $REPLACE_CANONICALIZE_FILE_NAME = 1; then
AC_LIBOBJ([canonicalize-lgpl])
fi
gl_MODULE_INDICATOR([canonicalize-lgpl])
gl_STDLIB_MODULE_INDICATOR([canonicalize_file_name])
gl_STDLIB_MODULE_INDICATOR([realpath])
extensions
stdlib
nocrash
alloca-opt [test $HAVE_CANONICALIZE_FILE_NAME = 0 || test $REPLACE_CANONICALIZE_FILE_NAME = 1]
errno [test $HAVE_CANONICALIZE_FILE_NAME = 0 || test $REPLACE_CANONICALIZE_FILE_NAME = 1]
lstat [test $HAVE_CANONICALIZE_FILE_NAME = 0 || test $REPLACE_CANONICALIZE_FILE_NAME = 1]
malloca [test $HAVE_CANONICALIZE_FILE_NAME = 0 || test $REPLACE_CANONICALIZE_FILE_NAME = 1]
memmove [test $HAVE_CANONICALIZE_FILE_NAME = 0 || test $REPLACE_CANONICALIZE_FILE_NAME = 1]
pathmax [test $HAVE_CANONICALIZE_FILE_NAME = 0 || test $REPLACE_CANONICALIZE_FILE_NAME = 1]
readlink [test $HAVE_CANONICALIZE_FILE_NAME = 0 || test $REPLACE_CANONICALIZE_FILE_NAME = 1]
sys_stat [test $HAVE_CANONICALIZE_FILE_NAME = 0 || test $REPLACE_CANONICALIZE_FILE_NAME = 1]
chdir-safer #include "chdir-safer.h" chdir-safer.c chdir-safer.m4
00gnulib.m4
gl_CHDIR_SAFER
errno
fchdir
fcntl-h
fstat
open
same-inode
stdbool
clean-temp #include "clean-temp.h" clean-temp.c 00gnulib.m4
AC_DEFINE([SIGNAL_SAFE_LIST], [1], [Define if lists must be signal-safe.])
stdbool
unistd
error
fatal-signal
open
pathmax
tmpdir
mkdtemp
rmdir
xalloc
xmalloca
linkedhash-list
xlist
gettext-h
concat-filename #include "concat-filename.h" concat-filename.c 00gnulib.m4 filename
malloc-posix
stpcpy
copy-file #include "copy-file.h" copy-file.c copy-file.m4
00gnulib.m4
gl_COPY_FILE
acl
binary-io
error
fstat
full-write
gettext-h
ignore-value
open
quote
safe-read
stdlib
unistd
xalloc
fsusage #include "fsusage.h" fsusage.c fsusage.m4
00gnulib.m4
gl_FSUSAGE
if test $gl_cv_fs_space = yes; then
AC_LIBOBJ([fsusage])
gl_PREREQ_FSUSAGE_EXTRA
fi
largefile
stdbool
stdint
full-read [test $gl_cv_fs_space = yes]
dirfd #include <dirent.h> dirfd.c dirfd.m4
00gnulib.m4
gl_FUNC_DIRFD
if test $ac_cv_func_dirfd = no && test $gl_cv_func_dirfd_macro = no; then
AC_LIBOBJ([dirfd])
gl_PREREQ_DIRFD
fi
gl_DIRENT_MODULE_INDICATOR([dirfd])
dirent
extensions
errno [test $ac_cv_func_dirfd = no && test $gl_cv_func_dirfd_macro = no]
double-slash-root --- --- double-slash-root.m4
00gnulib.m4
gl_DOUBLE_SLASH_ROOT
---
euidaccess #include <unistd.h> euidaccess.c euidaccess.m4
00gnulib.m4
gl_FUNC_EUIDACCESS
if test $HAVE_EUIDACCESS = 0; then
AC_LIBOBJ([euidaccess])
gl_PREREQ_EUIDACCESS
fi
gl_UNISTD_MODULE_INDICATOR([euidaccess])
unistd
extensions
root-uid
group-member [test $HAVE_EUIDACCESS = 0]
stat [test $HAVE_EUIDACCESS = 0]
sys_stat [test $HAVE_EUIDACCESS = 0]
faccessat #include <fcntl.h>
#include <unistd.h>
faccessat.c
at-func.c
faccessat.m4
00gnulib.m4
gl_FUNC_FACCESSAT
if test $HAVE_FACCESSAT = 0; then
AC_LIBOBJ([faccessat])
gl_PREREQ_FACCESSAT
fi
gl_MODULE_INDICATOR([faccessat])
gl_UNISTD_MODULE_INDICATOR([faccessat])
unistd
extensions
at-internal [test $HAVE_FACCESSAT = 0]
dosname [test $HAVE_FACCESSAT = 0]
errno [test $HAVE_FACCESSAT = 0]
fchdir [test $HAVE_FACCESSAT = 0]
fcntl-h [test $HAVE_FACCESSAT = 0]
openat-die [test $HAVE_FACCESSAT = 0]
openat-h [test $HAVE_FACCESSAT = 0]
save-cwd [test $HAVE_FACCESSAT = 0]
euidaccess [test $HAVE_FACCESSAT = 0]
fdopendir #include <dirent.h> fdopendir.c fdopendir.m4
00gnulib.m4
gl_FUNC_FDOPENDIR
if test $HAVE_FDOPENDIR = 0 || test $REPLACE_FDOPENDIR = 1; then
AC_LIBOBJ([fdopendir])
fi
gl_DIRENT_MODULE_INDICATOR([fdopendir])
gl_MODULE_INDICATOR([fdopendir])
dirent
extensions
at-internal [test $HAVE_FDOPENDIR = 0]
dup [test $HAVE_FDOPENDIR = 0]
errno [test $HAVE_FDOPENDIR = 0]
fchdir [test $HAVE_FDOPENDIR = 0]
fstat [test $HAVE_FDOPENDIR = 0]
openat-die [test $HAVE_FDOPENDIR = 0]
opendir [test $HAVE_FDOPENDIR = 0]
save-cwd [test $HAVE_FDOPENDIR = 0]
fdutimensat #include <fcntl.h>
#include "utimens.h"
fdutimensat.c 00gnulib.m4
gl_MODULE_INDICATOR([fdutimensat])
futimens
utimensat
file-type #include "file-type.h" file-type.c 00gnulib.m4 gettext-h
sys_stat
fileblocks --- fileblocks.c fileblocks.m4
00gnulib.m4
gl_FILEBLOCKS
if test $ac_cv_member_struct_stat_st_blocks = no; then
AC_LIBOBJ([fileblocks])
gl_PREREQ_FILEBLOCKS
fi
---
filemode #include "filemode.h" filemode.c filemode.m4
st_dm_mode.m4
00gnulib.m4
gl_FILEMODE
sys_stat
filename #include "filename.h" --- 00gnulib.m4 ---
filenamecat #include "filenamecat.h" filenamecat.c filenamecat.m4
00gnulib.m4
gl_FILE_NAME_CONCAT
gl_MODULE_INDICATOR([filenamecat])
filenamecat-lgpl
xalloc
filenamecat-lgpl #include "filenamecat.h" filenamecat-lgpl.c filenamecat.m4
00gnulib.m4
gl_FILE_NAME_CONCAT_LGPL
dirname-lgpl
fts #include "fts_.h" fts.c
fts-cycle.c
fts.m4
00gnulib.m4
gl_FUNC_FTS
dnl Use this version of fts unconditionally, since the GNU libc and
dnl NetBSD versions have bugs and/or unnecessary limitations.
AC_LIBOBJ([fts])
cloexec
closedir
cycle-check
d-ino
d-type
dirent-safer
dup
fchdir
fcntl-h
fcntl-safer
fdopendir
fstat
hash
i-ring
lstat
memmove
openat-h
openat-safer
opendir
readdir
stdbool
unistd-safer
isdir --- isdir.c
isdir.h
00gnulib.m4 stat
largefile --- --- largefile.m4
00gnulib.m4
AC_REQUIRE([gl_LARGEFILE])
---
lchmod #include <sys/stat.h> --- lchmod.m4
00gnulib.m4
gl_FUNC_LCHMOD
gl_SYS_STAT_MODULE_INDICATOR([lchmod])
sys_stat
extensions
lchown #include <unistd.h> lchown.c lchown.m4
00gnulib.m4
gl_FUNC_LCHOWN
if test $HAVE_LCHOWN = 0 || test $REPLACE_LCHOWN = 1; then
AC_LIBOBJ([lchown])
fi
gl_UNISTD_MODULE_INDICATOR([lchown])
unistd
chown [test $HAVE_LCHOWN = 0 || test $REPLACE_LCHOWN = 1]
errno [test $HAVE_LCHOWN = 0 || test $REPLACE_LCHOWN = 1]
lstat [test $HAVE_LCHOWN = 0 || test $REPLACE_LCHOWN = 1]
stdbool [test $HAVE_LCHOWN = 0 || test $REPLACE_LCHOWN = 1]
sys_stat [test $HAVE_LCHOWN = 0 || test $REPLACE_LCHOWN = 1]
mkancesdirs #include "mkancesdirs.h" mkancesdirs.c mkancesdirs.m4
00gnulib.m4
gl_MKANCESDIRS
dirname-lgpl
fcntl-h
savewd
stat-macros
sys_stat
mkfifoat #include <fcntl.h>
#include <sys/stat.h>
mkfifoat.c
mknodat.c
at-func.c
mkfifoat.m4
00gnulib.m4
gl_FUNC_MKFIFOAT
if test $HAVE_MKFIFOAT = 0; then
AC_LIBOBJ([mkfifoat])
fi
if test $HAVE_MKNODAT = 0; then
AC_LIBOBJ([mknodat])
fi
gl_SYS_STAT_MODULE_INDICATOR([mkfifoat])
gl_SYS_STAT_MODULE_INDICATOR([mknodat])
sys_stat
extensions
at-internal [test $HAVE_MKFIFOAT = 0 || test $HAVE_MKNODAT = 0]
dosname [test $HAVE_MKFIFOAT = 0 || test $HAVE_MKNODAT = 0]
errno [test $HAVE_MKFIFOAT = 0 || test $HAVE_MKNODAT = 0]
fchdir [test $HAVE_MKFIFOAT = 0 || test $HAVE_MKNODAT = 0]
fcntl-h [test $HAVE_MKFIFOAT = 0 || test $HAVE_MKNODAT = 0]
openat-die [test $HAVE_MKFIFOAT = 0 || test $HAVE_MKNODAT = 0]
openat-h [test $HAVE_MKFIFOAT = 0 || test $HAVE_MKNODAT = 0]
save-cwd [test $HAVE_MKFIFOAT = 0 || test $HAVE_MKNODAT = 0]
mkfifo [test $HAVE_MKFIFOAT = 0]
mknod [test $HAVE_MKNODAT = 0]
mkdir-p #include "mkdir-p.h" dirchownmod.c
dirchownmod.h
mkdir-p.c
mkdir-p.m4
00gnulib.m4
gl_MKDIR_PARENTS
error
fcntl-h
fstat
gettext-h
lchmod
lchown
mkancesdirs
quote
savewd
stat
stat-macros
stdbool
sys_stat
mkostemp #include <stdlib.h> mkostemp.c mkostemp.m4
00gnulib.m4
gl_FUNC_MKOSTEMP
if test $HAVE_MKOSTEMP = 0; then
AC_LIBOBJ([mkostemp])
gl_PREREQ_MKOSTEMP
fi
gl_MODULE_INDICATOR([mkostemp])
gl_STDLIB_MODULE_INDICATOR([mkostemp])
stdlib
extensions
largefile
tempname [test $HAVE_MKOSTEMP = 0]
mkostemps #include <stdlib.h> mkostemps.c mkostemps.m4
00gnulib.m4
gl_FUNC_MKOSTEMPS
if test $HAVE_MKOSTEMPS = 0; then
AC_LIBOBJ([mkostemps])
fi
gl_MODULE_INDICATOR([mkostemps])
gl_STDLIB_MODULE_INDICATOR([mkostemps])
stdlib
extensions
largefile
tempname [test $HAVE_MKOSTEMPS = 0]
mkstemps #include <stdlib.h> mkstemps.c mkstemps.m4
00gnulib.m4
gl_FUNC_MKSTEMPS
if test $HAVE_MKSTEMPS = 0; then
AC_LIBOBJ([mkstemps])
fi
gl_MODULE_INDICATOR([mkstemps])
gl_STDLIB_MODULE_INDICATOR([mkstemps])
stdlib
extensions
largefile
tempname [test $HAVE_MKSTEMPS = 0]
modechange #include "modechange.h" modechange.c modechange.m4
00gnulib.m4
gl_MODECHANGE
stat
stat-macros
stdbool
sys_stat
xalloc
mountlist #include "mountlist.h" mountlist.c ls-mntd-fs.m4
fstypename.m4
mountlist.m4
00gnulib.m4
gl_MOUNTLIST
if test $gl_cv_list_mounted_fs = yes; then
AC_LIBOBJ([mountlist])
gl_PREREQ_MOUNTLIST_EXTRA
fi
stdbool
stdint
strstr-simple
xalloc
openat #include <fcntl.h> openat.c openat.m4
lstat.m4
mode_t.m4
00gnulib.m4
gl_FUNC_OPENAT
if test $HAVE_OPENAT = 0 || test $REPLACE_OPENAT = 1; then
AC_LIBOBJ([openat])
gl_PREREQ_OPENAT
fi
gl_MODULE_INDICATOR([openat]) dnl for lib/getcwd.c
gl_FCNTL_MODULE_INDICATOR([openat])
fcntl-h
extensions
largefile
openat-h [test $HAVE_OPENAT = 0 || test $REPLACE_OPENAT = 1]
stdbool [test $HAVE_OPENAT = 0 || test $REPLACE_OPENAT = 1]
sys_stat [test $HAVE_OPENAT = 0 || test $REPLACE_OPENAT = 1]
fstat [test $REPLACE_OPENAT = 1]
at-internal [test $HAVE_OPENAT = 0]
dosname [test $HAVE_OPENAT = 0]
errno [test $HAVE_OPENAT = 0]
fchdir [test $HAVE_OPENAT = 0]
open [test $HAVE_OPENAT = 0]
openat-die [test $HAVE_OPENAT = 0]
save-cwd [test $HAVE_OPENAT = 0]
openat-die #include "openat.h" openat-die.c 00gnulib.m4 openat-h
error
exitfail
gettext-h
snippet/_Noreturn
pathmax #include "pathmax.h" --- pathmax.m4
00gnulib.m4
gl_PATHMAX
unistd
read-file #include "read-file.h" read-file.c read-file.m4
00gnulib.m4
gl_PREREQ_READ_FILE
fstat
ftello
malloc-posix
realloc-posix
stdint
sys_stat
readlinkat #include <fcntl.h>
#include <unistd.h>
readlinkat.c
at-func.c
readlinkat.m4
00gnulib.m4
gl_FUNC_READLINKAT
if test $HAVE_READLINKAT = 0 || test $REPLACE_READLINKAT = 1; then
AC_LIBOBJ([readlinkat])
fi
gl_UNISTD_MODULE_INDICATOR([readlinkat])
unistd
extensions
at-internal [test $HAVE_READLINKAT = 0]
dosname [test $HAVE_READLINKAT = 0]
errno [test $HAVE_READLINKAT = 0]
fchdir [test $HAVE_READLINKAT = 0]
fcntl-h [test $HAVE_READLINKAT = 0]
openat-die [test $HAVE_READLINKAT = 0]
openat-h [test $HAVE_READLINKAT = 0]
save-cwd [test $HAVE_READLINKAT = 0]
readlink [test $HAVE_READLINKAT = 0]
same #include "same.h" same.c same.m4
00gnulib.m4
gl_SAME
error
dirname
same-inode
stat
stdbool
memcmp
save-cwd #include "save-cwd.h" save-cwd.c save-cwd.m4
00gnulib.m4
gl_SAVE_CWD
chdir-long
cloexec
getcwd-lgpl
fchdir
stdbool
unistd-safer
savedir #include "savedir.h" savedir.c savedir.m4
00gnulib.m4
gl_SAVEDIR
closedir
dirent-safer
fdopendir
opendir
readdir
stpcpy
xalloc
savewd #include "savewd.h" savewd.c savewd.m4
00gnulib.m4
gl_SAVEWD
assure
chdir
dosname
errno
extern-inline
fchdir
fcntl-safer
fcntl-h
raise
stdbool
stdlib
sys_wait
xalloc
stat-macros #include "stat-macros.h" --- 00gnulib.m4 ---
stat-time #include "stat-time.h" stat-time.c stat-time.m4
00gnulib.m4
gl_STAT_TIME
gl_STAT_BIRTHTIME
time
extensions
extern-inline
symlink #include <unistd.h> symlink.c symlink.m4
00gnulib.m4
gl_FUNC_SYMLINK
if test $HAVE_SYMLINK = 0 || test $REPLACE_SYMLINK = 1; then
AC_LIBOBJ([symlink])
fi
gl_UNISTD_MODULE_INDICATOR([symlink])
unistd
lstat [test $HAVE_SYMLINK = 0 || test $REPLACE_SYMLINK = 1]
symlinkat #include <fcntl.h>
#include <unistd.h>
symlinkat.c
at-func.c
symlinkat.m4
00gnulib.m4
gl_FUNC_SYMLINKAT
if test $HAVE_SYMLINKAT = 0 || test $REPLACE_SYMLINKAT = 1; then
AC_LIBOBJ([symlinkat])
fi
gl_UNISTD_MODULE_INDICATOR([symlinkat])
unistd
extensions
at-internal [test $HAVE_SYMLINKAT = 0]
dosname [test $HAVE_SYMLINKAT = 0]
errno [test $HAVE_SYMLINKAT = 0]
fchdir [test $HAVE_SYMLINKAT = 0]
fcntl-h [test $HAVE_SYMLINKAT = 0]
openat-die [test $HAVE_SYMLINKAT = 0]
openat-h [test $HAVE_SYMLINKAT = 0]
save-cwd [test $HAVE_SYMLINKAT = 0]
symlink [test $HAVE_SYMLINKAT = 0]
fstatat [test $REPLACE_SYMLINKAT = 1]
sys_file #include <sys/file.h> sys_file.in.h sys_file_h.m4
00gnulib.m4
gl_HEADER_SYS_FILE_H
AC_PROG_MKDIR_P
include_next
snippet/warn-on-use
sys_ioctl #include <sys/ioctl.h> sys_ioctl.in.h sys_ioctl_h.m4
00gnulib.m4
gl_SYS_IOCTL_H
AC_PROG_MKDIR_P
include_next
snippet/c++defs
snippet/warn-on-use
unistd
tmpdir #include "tmpdir.h" tmpdir.c tmpdir.m4
00gnulib.m4
gt_TMPDIR
secure_getenv
stdbool
sys_stat
pathmax
unlinkdir #include "unlinkdir.h" unlinkdir.c unlinkdir.m4
00gnulib.m4
gl_UNLINKDIR
stdbool
priv-set
root-uid
utimecmp #include "utimecmp.h" utimecmp.c utimecmp.m4
00gnulib.m4
gl_UTIMECMP
hash
stat-time
time
utimens
intprops
lstat
stdbool
stdint
verify
utimens #include "utimens.h" utimens.c utimbuf.m4
utimens.m4
utimes.m4
00gnulib.m4
gl_UTIMENS
assure
errno
extern-inline
fcntl-h
fstat
lstat
gettime
stat-time
stdbool
sys_stat
sys_time
time
write-any-file #include "write-any-file.h" write-any-file.c write-any-file.m4
00gnulib.m4
gl_WRITE_ANY_FILE
stdbool
priv-set
root-uid
xconcat-filename #include "concat-filename.h" xconcat-filename.c 00gnulib.m4 concat-filename
xalloc-die
xgetcwd #include "xgetcwd.h" xgetcwd.c xgetcwd.m4
00gnulib.m4
gl_XGETCWD
getcwd
xalloc
stdbool
xreadlink #include "xreadlink.h" xreadlink.c 00gnulib.m4 areadlink
xalloc
xreadlinkat #include "xreadlink.h" xreadlinkat.c 00gnulib.m4
gl_MODULE_INDICATOR([xreadlinkat])
areadlinkat
xalloc

File system as inode set

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

File descriptor based Input/Output

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

File stream based Input/Output

modules/ lib/ lib/ m4/  
Module Header Implementation Autoconf macro Depends on
close-stream #include "close-stream.h" close-stream.c close-stream.m4
00gnulib.m4
gl_CLOSE_STREAM
gl_MODULE_INDICATOR([close-stream])
fpending
stdbool
closein #include "closein.h" closein.c closein.m4
00gnulib.m4
gl_CLOSEIN
closeout
freadahead
fflush
stdbool
closeout #include "closeout.h" closeout.c closeout.m4
00gnulib.m4
gl_CLOSEOUT
close-stream
gettext-h
error
quotearg
exitfail
stdbool
fbufmode #include "fbufmode.h" fbufmode.c
stdio-impl.h
fbufmode.m4
00gnulib.m4
gl_FUNC_FBUFMODE
---
fopen-safer #include "stdio-safer.h" stdio--.h
fopen-safer.c
00gnulib.m4
gl_MODULE_INDICATOR([fopen-safer])
fopen
unistd-safer
fpending #include "fpending.h" fpending.c fpending.m4
00gnulib.m4
gl_FUNC_FPENDING
if test $gl_cv_func___fpending = no; then
AC_LIBOBJ([fpending])
gl_PREREQ_FPENDING
fi
---
fpurge #include <stdio.h> fpurge.c
stdio-impl.h
fpurge.m4
00gnulib.m4
gl_FUNC_FPURGE
if test $HAVE_FPURGE = 0 || test $REPLACE_FPURGE = 1; then
AC_LIBOBJ([fpurge])
fi
gl_STDIO_MODULE_INDICATOR([fpurge])
stdio
freadable #include "freadable.h" freadable.c
stdio-impl.h
freadable.m4
00gnulib.m4
gl_FUNC_FREADABLE
if test $ac_cv_func___freadable = no; then
AC_LIBOBJ([freadable])
fi
stdbool
freadahead #include "freadahead.h" freadahead.c
stdio-impl.h
freadahead.m4
00gnulib.m4
gl_FUNC_FREADAHEAD
if test $ac_cv_func___freadahead = no; then
AC_LIBOBJ([freadahead])
fi
---
freading #include "freading.h" freading.c
stdio-impl.h
freading.m4
00gnulib.m4
gl_FUNC_FREADING
stdbool
freadptr #include "freadptr.h" freadptr.c
stdio-impl.h
freadptr.m4
00gnulib.m4
gl_FUNC_FREADPTR
if test $ac_cv_func___freadptr = no; then
AC_LIBOBJ([freadptr])
fi
---
freadseek #include "freadseek.h" freadseek.c
stdio-impl.h
freadseek.m4
00gnulib.m4
gl_FUNC_FREADSEEK
freadahead
freadptr
fseeko
lseek
freopen-safer #include "stdio-safer.h" stdio--.h
freopen-safer.c
00gnulib.m4
gl_MODULE_INDICATOR([freopen-safer])
dup2
freopen
open
stdbool
fwritable #include "fwritable.h" fwritable.c
stdio-impl.h
fwritable.m4
00gnulib.m4
gl_FUNC_FWRITABLE
if test $ac_cv_func___fwritable = no; then
AC_LIBOBJ([fwritable])
fi
stdbool
fwriting #include "fwriting.h" fwriting.c
stdio-impl.h
fwriting.m4
00gnulib.m4
gl_FUNC_FWRITING
if test $ac_cv_func___fwriting = no; then
AC_LIBOBJ([fwriting])
fi
stdbool
getpass #include "getpass.h" getpass.c getpass.m4
00gnulib.m4
gl_FUNC_GETPASS
if test $HAVE_GETPASS = 0; then
AC_LIBOBJ([getpass])
gl_PREREQ_GETPASS
fi
extensions
fseeko
getline
stdbool
strdup-posix
getpass-gnu #include "getpass.h" getpass.c getpass.m4
00gnulib.m4
gl_FUNC_GETPASS_GNU
if test $REPLACE_GETPASS = 1; then
AC_LIBOBJ([getpass])
gl_PREREQ_GETPASS
fi
fseeko
getline
stdbool
popen-safer #include "stdio-safer.h" stdio--.h
popen-safer.c
00gnulib.m4
gl_MODULE_INDICATOR([popen-safer])
cloexec
open
popen
unistd-safer
stdlib-safer #include "stdlib-safer.h" stdlib--.h
mkstemp-safer.c
00gnulib.m4 fd-safer-flag
mkstemp
stdlib
unistd-safer
tmpfile-safer #include "stdio-safer.h" stdio--.h
tmpfile-safer.c
00gnulib.m4
gl_MODULE_INDICATOR([tmpfile-safer])
binary-io
tmpfile
unistd-safer
xfreopen #include "xfreopen.h" xfreopen.c 00gnulib.m4 error
exitfail
freopen-safer
quote

Users and groups

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

Security

modules/ lib/ lib/ m4/  
Module Header Implementation Autoconf macro Depends on
idpriv-drop #include "idpriv.h" idpriv-drop.c idpriv.m4
00gnulib.m4
gl_IDPRIV
unistd
extensions
idpriv-droptemp #include "idpriv.h" idpriv-droptemp.c idpriv.m4
00gnulib.m4
gl_IDPRIV
unistd
extensions
priv-set #include "priv-set.h" priv-set.c priv-set.m4
00gnulib.m4
gl_PRIV_SET
errno
extern-inline
stdbool

Date and time

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

Networking functions

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

Multithreading

modules/ lib/ lib/ m4/  
Module Header Implementation Autoconf macro Depends on
threadlib --- glthread/threadlib.c threadlib.m4
00gnulib.m4
gl_THREADLIB
havelib
lock #include "glthread/lock.h" glthread/lock.c lock.m4
00gnulib.m4
gl_LOCK
gl_MODULE_INDICATOR([lock])
threadlib
tls #include "glthread/tls.h" glthread/tls.c tls.m4
00gnulib.m4
gl_TLS
threadlib
thread #include "glthread/thread.h" glthread/thread.c thread.m4
00gnulib.m4
gl_THREAD
threadlib
extern-inline
lock
yield #include "glthread/yield.h" --- yield.m4
00gnulib.m4
gl_YIELD
threadlib
cond #include "glthread/cond.h" glthread/cond.c cond.m4
00gnulib.m4
gl_COND
threadlib
lock
errno
extern-inline
stdbool
time
gettimeofday
openmp --- --- openmp.m4
00gnulib.m4
AC_OPENMP
---

Signal handling

modules/ lib/ lib/ m4/  
Module Header Implementation Autoconf macro Depends on
c-stack #include "c-stack.h" c-stack.c c-stack.m4
00gnulib.m4
gl_C_STACK
gettext-h
errno
exitfail
ignore-value
unistd
raise
sigaction
libsigsegv
libsigsegv #if HAVE_LIBSIGSEGV
# include <sigsegv.h>
#endif
--- libsigsegv.m4
00gnulib.m4
gl_LIBSIGSEGV
havelib
sig2str #include "sig2str.h" sig2str.c sig2str.m4
00gnulib.m4
gl_FUNC_SIG2STR
if test $ac_cv_func_sig2str = no; then
AC_LIBOBJ([sig2str])
gl_PREREQ_SIG2STR
fi
intprops
sigpipe #include <signal.h> stdio-write.c sigpipe.m4
asm-underscore.m4
00gnulib.m4
gl_SIGNAL_SIGPIPE
dnl Define the C macro GNULIB_SIGPIPE to 1.
gl_MODULE_INDICATOR([sigpipe])
dnl Define the substituted variable GNULIB_SIGNAL_H_SIGPIPE to 1.
AC_REQUIRE([gl_SIGNAL_H_DEFAULTS])
GNULIB_SIGNAL_H_SIGPIPE=1
dnl Define the substituted variable GNULIB_STDIO_H_SIGPIPE to 1.
AC_REQUIRE([gl_STDIO_H_DEFAULTS])
AC_REQUIRE([gl_ASM_SYMBOL_PREFIX])
GNULIB_STDIO_H_SIGPIPE=1
dnl Define the substituted variable GNULIB_UNISTD_H_SIGPIPE to 1.
AC_REQUIRE([gl_UNISTD_H_DEFAULTS])
GNULIB_UNISTD_H_SIGPIPE=1
msvc-nothrow
raise
signal-h
sigprocmask
stdio
unistd
sigpipe-die #include "sigpipe-die.h" sigpipe-die.c 00gnulib.m4 error
gettext-h
exitfail
sigpipe
sigprocmask
sigaction

Internationalization functions

modules/ lib/ lib/ m4/  
Module Header Implementation Autoconf macro Depends on
gettext #include "gettext.h" --- codeset.m4
fcntl-o.m4
gettext.m4
glibc2.m4
glibc21.m4
iconv.m4
intdiv0.m4
intl.m4
intldir.m4
intlmacosx.m4
intmax.m4
inttypes_h.m4
inttypes-pri.m4
lcmessage.m4
lock.m4
longlong.m4
nls.m4
po.m4
printf-posix.m4
progtest.m4
size_max.m4
stdint_h.m4
threadlib.m4
uintmax_t.m4
visibility.m4
wchar_t.m4
wint_t.m4
xsize.m4
00gnulib.m4
AM_GNU_GETTEXT([external])
AM_GNU_GETTEXT_VERSION([0.18.1])
extensions
gettext-h
havelib
gettext-h #include "gettext.h" --- 00gnulib.m4
AC_SUBST([LIBINTL])
AC_SUBST([LTLIBINTL])
---
propername #include "propername.h" propername.c 00gnulib.m4
m4_ifdef([AM_XGETTEXT_OPTION],
[AM_][XGETTEXT_OPTION([--keyword='proper_name:1,\"This is a proper name. See the gettext manual, section Names.\"'])
AM_][XGETTEXT_OPTION([--keyword='proper_name_utf8:1,\"This is a proper name. See the gettext manual, section Names.\"'])])
stdbool
trim
mbsstr
mbchar
mbuiter
iconv
localcharset
c-strcase
xstriconv
xalloc
gettext-h
iconv #if HAVE_ICONV
# include <iconv.h>
#endif
--- iconv.m4
00gnulib.m4
AM_ICONV
m4_ifdef([gl_ICONV_MODULE_INDICATOR],
[gl_ICONV_MODULE_INDICATOR([iconv])])
havelib
striconv #include "striconv.h" striconv.c 00gnulib.m4
if test $gl_cond_libtool = false; then
gl_ltlibdeps="$gl_ltlibdeps $LTLIBICONV"
gl_libdeps="$gl_libdeps $LIBICONV"
fi
iconv
iconv_open
strdup
c-strcase
xstriconv #include "xstriconv.h" xstriconv.c 00gnulib.m4 striconv
xalloc
striconveh #include "striconveh.h" striconveh.c
iconveh.h
00gnulib.m4
if test $gl_cond_libtool = false; then
gl_ltlibdeps="$gl_ltlibdeps $LTLIBICONV"
gl_libdeps="$gl_libdeps $LIBICONV"
fi
stdbool
iconv
iconv_open
unistr/u8-prev
unistr/u8-mbtouc-unsafe
unistr/u8-mbtouc
unistr/u8-mbtoucr
unistr/u8-uctomb
strdup
c-strcase
c-strcaseeq
memmove
xstriconveh #include "xstriconveh.h" xstriconveh.c 00gnulib.m4 striconveh
xalloc
striconveha #include "striconveha.h" striconveha.c 00gnulib.m4 stdbool
striconveh
malloca
strdup
c-strcase
localcharset #include "localcharset.h" localcharset.c
config.charset
ref-add.sin
ref-del.sin
codeset.m4
fcntl-o.m4
glibc21.m4
localcharset.m4
00gnulib.m4
gl_LOCALCHARSET
LOCALCHARSET_TESTS_ENVIRONMENT="CHARSETALIASDIR=\"\$(abs_top_builddir)/$gl_source_base\""
AC_SUBST([LOCALCHARSET_TESTS_ENVIRONMENT])
configmake
extensions
hard-locale #include "hard-locale.h" hard-locale.c hard-locale.m4
00gnulib.m4
gl_HARD_LOCALE
stdbool
strdup
localename #include "localename.h" localename.c localename.m4
intlmacosx.m4
lcmessage.m4
00gnulib.m4
gl_LOCALENAME
strdup
lock
mbmemcasecmp #include "mbmemcasecmp.h" mbmemcasecmp.c 00gnulib.m4 mbiter
mbmemcasecoll #include "mbmemcasecoll.h" mbmemcasecoll.c 00gnulib.m4 stdbool
malloca
mbrtowc
wcrtomb
memcmp2
memcoll
wchar
mbslen #include <string.h> mbslen.c mbslen.m4
00gnulib.m4
gl_FUNC_MBSLEN
gl_STRING_MODULE_INDICATOR([mbslen])
mbuiter
string
mbsnlen #include <string.h> mbsnlen.c 00gnulib.m4
gl_STRING_MODULE_INDICATOR([mbsnlen])
mbiter
string
mbschr #include <string.h> mbschr.c 00gnulib.m4
gl_STRING_MODULE_INDICATOR([mbschr])
mbuiter
string
mbsrchr #include <string.h> mbsrchr.c 00gnulib.m4
gl_STRING_MODULE_INDICATOR([mbsrchr])
mbuiter
string
mbsstr #include <string.h> mbsstr.c
str-kmp.h
00gnulib.m4
gl_STRING_MODULE_INDICATOR([mbsstr])
mbuiter
stdbool
string
mbslen
malloca
strnlen
mbscasecmp #include <string.h> mbscasecmp.c 00gnulib.m4
gl_STRING_MODULE_INDICATOR([mbscasecmp])
mbuiter
string
mbsncasecmp #include <string.h> mbsncasecmp.c 00gnulib.m4
gl_STRING_MODULE_INDICATOR([mbsncasecmp])
mbuiter
string
mbspcasecmp #include <string.h> mbspcasecmp.c 00gnulib.m4
gl_STRING_MODULE_INDICATOR([mbspcasecmp])
mbuiter
string
mbscasestr #include <string.h> mbscasestr.c
str-kmp.h
00gnulib.m4
gl_STRING_MODULE_INDICATOR([mbscasestr])
mbuiter
stdbool
string
mbslen
malloca
strnlen
mbscspn #include <string.h> mbscspn.c 00gnulib.m4
gl_STRING_MODULE_INDICATOR([mbscspn])
mbuiter
string
mbschr
strcspn
mbspbrk #include <string.h> mbspbrk.c 00gnulib.m4
gl_STRING_MODULE_INDICATOR([mbspbrk])
mbuiter
string
mbschr
strpbrk
mbsspn #include <string.h> mbsspn.c 00gnulib.m4
gl_STRING_MODULE_INDICATOR([mbsspn])
mbuiter
string
mbschr
mbssep #include <string.h> mbssep.c 00gnulib.m4
gl_STRING_MODULE_INDICATOR([mbssep])
mbuiter
string
mbspbrk
strsep
mbstok_r #include <string.h> mbstok_r.c 00gnulib.m4
gl_STRING_MODULE_INDICATOR([mbstok_r])
mbuiter
string
mbsspn
mbspbrk
strtok_r
mbswidth #include "mbswidth.h" mbswidth.c mbstate_t.m4
mbrtowc.m4
mbswidth.m4
00gnulib.m4
gl_MBSWIDTH
wchar
wctype-h
mbrtowc
mbsinit
wcwidth
extensions
memcasecmp #include "memcasecmp.h" memcasecmp.c memcasecmp.m4
00gnulib.m4
gl_MEMCASECMP
---
memcoll #include "memcoll.h" memcoll.c memcoll.m4
00gnulib.m4
gl_MEMCOLL
memcmp
xmemcoll #include "xmemcoll.h" xmemcoll.c 00gnulib.m4 memcoll
gettext-h
error
quotearg
exitfail
unicodeio #include "unicodeio.h" unicodeio.c unicodeio.m4
00gnulib.m4
gl_UNICODEIO
unistr/u8-uctomb
iconv
iconv_open
gettext-h
localcharset
error
stdio
rpmatch #include <stdlib.h> rpmatch.c rpmatch.m4
00gnulib.m4
gl_FUNC_RPMATCH
if test $HAVE_RPMATCH = 0; then
AC_LIBOBJ([rpmatch])
gl_PREREQ_RPMATCH
fi
gl_STDLIB_MODULE_INDICATOR([rpmatch])
stdlib
extensions
stdbool [test $HAVE_RPMATCH = 0]
gettext-h [test $HAVE_RPMATCH = 0]
regex [test $HAVE_RPMATCH = 0]
strdup [test $HAVE_RPMATCH = 0]
yesno #include "yesno.h" yesno.c yesno.m4
00gnulib.m4
gl_YESNO
getline
rpmatch
stdbool
bison-i18n --- --- bison-i18n.m4
00gnulib.m4
BISON_I18N
gettext

Unicode string functions

modules/ lib/ lib/ m4/  
Module Header Implementation Autoconf macro Depends on
libunistring #if HAVE_LIBUNISTRING
# include <unitypes.h>
# include <unistr.h>
# include <uniconv.h>
# include <unistdio.h>
# include <uniname.h>
# include <unictype.h>
# include <uniwidth.h>
# include <uniwbrk.h>
# include <unilbrk.h>
# include <uninorm.h>
# include <unicase.h>
# include <uniregex.h>
# include <unistring/version.h>
#endif
libunistring.valgrind libunistring.m4
absolute-header.m4
00gnulib.m4
gl_LIBUNISTRING
havelib
iconv
libunistring-optional --- libunistring.valgrind libunistring-optional.m4
libunistring.m4
absolute-header.m4
00gnulib.m4
gl_LIBUNISTRING_OPTIONAL
havelib
iconv
unitypes #include "unitypes.h" unitypes.in.h libunistring-base.m4
00gnulib.m4
gl_LIBUNISTRING_LIBHEADER([0.9], [unitypes.h])
stdint
ucs4-utf8 #include "unistr.h" --- 00gnulib.m4 unistr/u8-uctomb
ucs4-utf16 #include "unistr.h" --- 00gnulib.m4 unistr/u16-uctomb
utf8-ucs4-unsafe #include "unistr.h" --- 00gnulib.m4 unistr/u8-mbtouc-unsafe
utf16-ucs4-unsafe #include "unistr.h" --- 00gnulib.m4 unistr/u16-mbtouc-unsafe
utf8-ucs4 #include "unistr.h" --- 00gnulib.m4 unistr/u8-mbtouc
utf16-ucs4 #include "unistr.h" --- 00gnulib.m4 unistr/u16-mbtouc
unistr/base #include "unistr.h" unistr.in.h libunistring-base.m4
00gnulib.m4
gl_LIBUNISTRING_LIBHEADER([0.9.2], [unistr.h])
unitypes
snippet/unused-parameter
stdbool
inline
unistr/u8-to-u16 #include "unistr.h" unistr/u8-to-u16.c 00gnulib.m4
gl_LIBUNISTRING_MODULE([0.9.3], [unistr/u8-to-u16])
unistr/base
unistr/u8-mbtoucr
unistr/u16-uctomb
unistr/u8-to-u32 #include "unistr.h" unistr/u8-to-u32.c 00gnulib.m4
gl_LIBUNISTRING_MODULE([0.9.3], [unistr/u8-to-u32])
unistr/base
unistr/u8-mbtoucr
unistr/u16-to-u8 #include "unistr.h" unistr/u16-to-u8.c 00gnulib.m4
gl_LIBUNISTRING_MODULE([0.9.3], [unistr/u16-to-u8])
unistr/base
unistr/u16-mbtoucr
unistr/u8-uctomb
unistr/u16-to-u32 #include "unistr.h" unistr/u16-to-u32.c 00gnulib.m4
gl_LIBUNISTRING_MODULE([0.9.3], [unistr/u16-to-u32])
unistr/base
unistr/u16-mbtoucr
unistr/u32-to-u8 #include "unistr.h" unistr/u32-to-u8.c 00gnulib.m4
gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-to-u8])
unistr/base
unistr/u8-uctomb
unistr/u32-to-u16 #include "unistr.h" unistr/u32-to-u16.c 00gnulib.m4
gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-to-u16])
unistr/base
unistr/u16-uctomb
unistr/u8-check #include "unistr.h" unistr/u8-check.c 00gnulib.m4
gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-check])
unistr/base
unistr/u16-check #include "unistr.h" unistr/u16-check.c 00gnulib.m4
gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-check])
unistr/base
unistr/u32-check #include "unistr.h" unistr/u32-check.c 00gnulib.m4
gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-check])
unistr/base
unistr/u8-chr #include "unistr.h" unistr/u8-chr.c 00gnulib.m4
gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-chr])
memchr
unistr/base
unistr/u8-uctomb
unistr/u16-chr #include "unistr.h" unistr/u16-chr.c 00gnulib.m4
gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-chr])
unistr/base
unistr/u16-uctomb
unistr/u32-chr #include "unistr.h" unistr/u32-chr.c 00gnulib.m4
gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-chr])
unistr/base
unistr/u8-cmp #include "unistr.h" unistr/u8-cmp.c 00gnulib.m4
gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-cmp])
unistr/base
memcmp
unistr/u16-cmp #include "unistr.h" unistr/u16-cmp.c 00gnulib.m4
gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-cmp])
unistr/base
unistr/u32-cmp #include "unistr.h" unistr/u32-cmp.c 00gnulib.m4
gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-cmp])
unistr/base
unistr/u8-cmp2 #include "unistr.h" unistr/u8-cmp2.c
unistr/u-cmp2.h
00gnulib.m4
gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-cmp2])
unistr/base
unistr/u8-cmp
minmax
unistr/u16-cmp2 #include "unistr.h" unistr/u16-cmp2.c
unistr/u-cmp2.h
00gnulib.m4
gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-cmp2])
unistr/base
unistr/u16-cmp
minmax
unistr/u32-cmp2 #include "unistr.h" unistr/u32-cmp2.c
unistr/u-cmp2.h
00gnulib.m4
gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-cmp2])
unistr/base
unistr/u32-cmp
minmax
unistr/u8-cpy #include "unistr.h" unistr/u8-cpy.c
unistr/u-cpy.h
00gnulib.m4
gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-cpy])
unistr/base
unistr/u16-cpy #include "unistr.h" unistr/u16-cpy.c
unistr/u-cpy.h
00gnulib.m4
gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-cpy])
unistr/base
unistr/u32-cpy #include "unistr.h" unistr/u32-cpy.c
unistr/u-cpy.h
00gnulib.m4
gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-cpy])
unistr/base
unistr/u8-cpy-alloc #include "unistr.h" unistr/u8-cpy-alloc.c
unistr/u-cpy-alloc.h
00gnulib.m4
gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-cpy-alloc])
unistr/base
malloc-posix
unistr/u16-cpy-alloc #include "unistr.h" unistr/u16-cpy-alloc.c
unistr/u-cpy-alloc.h
00gnulib.m4
gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-cpy-alloc])
unistr/base
malloc-posix
unistr/u32-cpy-alloc #include "unistr.h" unistr/u32-cpy-alloc.c
unistr/u-cpy-alloc.h
00gnulib.m4
gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-cpy-alloc])
unistr/base
malloc-posix
unistr/u8-endswith #include "unistr.h" unistr/u8-endswith.c
unistr/u-endswith.h
00gnulib.m4
gl_LIBUNISTRING_MODULE([0.9], [unistr/u8-endswith])
unistr/base
unistr/u8-strlen
unistr/u8-cmp
unistr/u16-endswith #include "unistr.h" unistr/u16-endswith.c
unistr/u-endswith.h
00gnulib.m4
gl_LIBUNISTRING_MODULE([0.9], [unistr/u16-endswith])
unistr/base
unistr/u16-strlen
unistr/u16-cmp
unistr/u32-endswith #include "unistr.h" unistr/u32-endswith.c
unistr/u-endswith.h
00gnulib.m4
gl_LIBUNISTRING_MODULE([0.9], [unistr/u32-endswith])
unistr/base
unistr/u32-strlen
unistr/u32-cmp
unistr/u8-mblen #include "