@c Automatically generated from *.c and others (the comments before
@c each entry tell you which file and where in that file). DO NOT EDIT!
@c Edit the *.c files, configure with --enable-maintainer-mode,
-@c and let gather-docs build you a new copy.
-
-@c safe-ctype.c:25
-@defvr Extension HOST_CHARSET
-This macro indicates the basic character set and encoding used by the
-host: more precisely, the encoding used for character constants in
-preprocessor @samp{#if} statements (the C "execution character set").
-It is defined by @file{safe-ctype.h}, and will be an integer constant
-with one of the following values:
-
-@ftable @code
-@item HOST_CHARSET_UNKNOWN
-The host character set is unknown - that is, not one of the next two
-possibilities.
-
-@item HOST_CHARSET_ASCII
-The host character set is ASCII.
-
-@item HOST_CHARSET_EBCDIC
-The host character set is some variant of EBCDIC. (Only one of the
-nineteen EBCDIC varying characters is tested; exercise caution.)
-@end ftable
-@end defvr
-
-@c pexecute.txh:1
-@deftypefn Extension struct pex_obj *pex_init (int @var{flags}, const char *@var{pname}, const char *@var{tempbase})
-
-Prepare to execute one or more programs, with standard output of each
-program fed to standard input of the next. This is a system
-independent interface to execute a pipeline.
-
-@var{flags} is a bitwise combination of the following:
-
-@table @code
-
-@vindex PEX_RECORD_TIMES
-@item PEX_RECORD_TIMES
-Record subprocess times if possible.
-
-@vindex PEX_USE_PIPES
-@item PEX_USE_PIPES
-Use pipes for communication between processes, if possible.
-
-@vindex PEX_SAVE_TEMPS
-@item PEX_SAVE_TEMPS
-Don't delete temporary files used for communication between
-processes.
-
-@end table
-
-@var{pname} is the name of program to be executed, used in error
-messages. @var{tempbase} is a base name to use for any required
-temporary files; it may be @code{NULL} to use a randomly chosen name.
-
-@end deftypefn
-
-@c pexecute.txh:161
-@deftypefn Extension const char *pex_one (int @var{flags}, const char *@var{executable}, char * const *@var{argv}, const char *@var{pname}, const char *@var{outname}, const char *@var{errname}, int *@var{status}, int *@var{err})
-
-An interface to @code{pex_init} to permit the easy execution of a
-single program. The return value and most of the parameters are as
-for a call to @code{pex_run}. @var{flags} is restricted to a
-combination of @code{PEX_SEARCH}, @code{PEX_STDERR_TO_STDOUT}, and
-@code{PEX_BINARY_OUTPUT}. @var{outname} is interpreted as if
-@code{PEX_LAST} were set. On a successful return, *@var{status} will
-be set to the exit status of the program.
-
-@end deftypefn
-
-@c pexecute.txh:32
-@deftypefn Extension const char *pex_run (struct pex_obj *@var{obj}, int @var{flags}, const char *@var{executable}, char * const *@var{argv}, const char *@var{outname}, const char *@var{errname}, int *@var{err})
-
-Execute one program in a pipeline. On success this returns
-@code{NULL}. On failure it returns an error message, a statically
-allocated string.
-
-@var{obj} is returned by a previous call to @code{pex_init}.
-
-@var{flags} is a bitwise combination of the following:
-
-@table @code
-
-@vindex PEX_LAST
-@item PEX_LAST
-This must be set on the last program in the pipeline. In particular,
-it should be set when executing a single program. The standard output
-of the program will be sent to @var{outname}, or, if @var{outname} is
-@code{NULL}, to the standard output of the calling program. This
-should not be set if you want to call @code{pex_read_output}
-(described below). After a call to @code{pex_run} with this bit set,
-@var{pex_run} may no longer be called with the same @var{obj}.
-
-@vindex PEX_SEARCH
-@item PEX_SEARCH
-Search for the program using the user's executable search path.
-
-@vindex PEX_SUFFIX
-@item PEX_SUFFIX
-@var{outname} is a suffix. See the description of @var{outname},
-below.
-
-@vindex PEX_STDERR_TO_STDOUT
-@item PEX_STDERR_TO_STDOUT
-Send the program's standard error to standard output, if possible.
-
-@vindex PEX_BINARY_INPUT
-@vindex PEX_BINARY_OUTPUT
-@item PEX_BINARY_INPUT
-@itemx PEX_BINARY_OUTPUT
-The standard input (output) of the program should be read (written) in
-binary mode rather than text mode. These flags are ignored on systems
-which do not distinguish binary mode and text mode, such as Unix. For
-proper behavior these flags should match appropriately--a call to
-@code{pex_run} using @code{PEX_BINARY_OUTPUT} should be followed by a
-call using @code{PEX_BINARY_INPUT}.
-@end table
-
-@var{executable} is the program to execute. @var{argv} is the set of
-arguments to pass to the program; normally @code{@var{argv}[0]} will
-be a copy of @var{executable}.
-
-@var{outname} is used to set the name of the file to use for standard
-output. There are two cases in which no output file will be used: 1)
-if @code{PEX_LAST} is not set in @var{flags}, and @code{PEX_USE_PIPES}
-was set in the call to @code{pex_init}, and the system supports pipes;
-2) if @code{PEX_LAST} is set in @var{flags}, and @var{outname} is
-@code{NULL}. Otherwise the code will use a file to hold standard
-output. If @code{PEX_LAST} is not set, this file is considered to be
-a temporary file, and it will be removed when no longer needed, unless
-@code{PEX_SAVE_TEMPS} was set in the call to @code{pex_init}.
-
-There are two cases to consider when setting the name of the file to
-hold standard output.
-
-First case: @code{PEX_SUFFIX} is set in @var{flags}. In this case
-@var{outname} may not be @code{NULL}. If the @var{tempbase} parameter
-to @code{pex_init} was not @code{NULL}, then the output file name is
-the concatenation of @var{tempbase} and @var{outname}. If
-@var{tempbase} was @code{NULL}, then the output file name is a random
-file name ending in @var{outname}.
-
-Second case: @code{PEX_SUFFIX} was not set in @var{flags}. In this
-case, if @var{outname} is not @code{NULL}, it is used as the output
-file name. If @var{outname} is @code{NULL}, and @var{tempbase} was
-not NULL, the output file name is randomly chosen using
-@var{tempbase}. Otherwise the output file name is chosen completely
-at random.
-
-@var{errname} is the file name to use for standard error output. If
-it is @code{NULL}, standard error is the same as the caller.
-Otherwise, standard error is written to the named file.
-
-On an error return, the code sets @code{*@var{err}} to an @code{errno}
-value, or to 0 if there is no relevant @code{errno}.
-
-@end deftypefn
+@c run 'make stamp-functions' and gather-docs will build a new copy.
@c alloca.c:26
@deftypefn Replacement void* alloca (size_t @var{size})
@end deftypefn
-@c asprintf.c:29
+@c asprintf.c:32
@deftypefn Extension int asprintf (char **@var{resptr}, const char *@var{format}, ...)
Like @code{sprintf}, but instead of passing a pointer to a buffer, you
@end deftypefn
@c bsearch.c:33
-@deftypefn Supplemental void* bsearch (const void *@var{key}, const void *@var{base}, size_t @var{nmemb}, size_t @var{size}, int (*@var{compar})(const void *, const void *))
+@deftypefn Supplemental void* bsearch (const void *@var{key}, @
+ const void *@var{base}, size_t @var{nmemb}, size_t @var{size}, @
+ int (*@var{compar})(const void *, const void *))
Performs a search over an array of @var{nmemb} elements pointed to by
@var{base} for a member that matches the object pointed to by @var{key}.
@end deftypefn
-@c argv.c:121
+@c argv.c:138
@deftypefn Extension char** buildargv (char *@var{sp})
Given a pointer to a string, parse the string extracting fields
@code{NULL} element.
All of the memory for the pointer array and copies of the string
-is obtained from @code{malloc}. All of the memory can be returned to the
+is obtained from @code{xmalloc}. All of the memory can be returned to the
system with the single function call @code{freeargv}, which takes the
returned result of @code{buildargv}, as it's argument.
@end deftypefn
-@c choose-temp.c:42
+@c filename_cmp.c:201
+@deftypefn Extension int canonical_filename_eq (const char *@var{a}, const char *@var{b})
+
+Return non-zero if file names @var{a} and @var{b} are equivalent.
+This function compares the canonical versions of the filenames as returned by
+@code{lrealpath()}, so that so that different file names pointing to the same
+underlying file are treated as being identical.
+
+@end deftypefn
+
+@c choose-temp.c:45
@deftypefn Extension char* choose_temp_base (void)
Return a prefix for temporary file names or @code{NULL} if unable to
program is exited if a temporary directory can't be found (@code{mktemp}
fails). The buffer for the result is obtained with @code{xmalloc}.
-This function is provided for backwards compatability only. Its use is
+This function is provided for backwards compatibility only. Its use is
not recommended.
@end deftypefn
-@c make-temp-file.c:87
-@deftypefn Replacement char* choose_tmpdir ()
+@c make-temp-file.c:95
+@deftypefn Replacement const char* choose_tmpdir ()
Returns a pointer to a directory path suitable for creating temporary
files in.
@end deftypefn
@c concat.c:24
-@deftypefn Extension char* concat (const char *@var{s1}, const char *@var{s2}, @dots{}, @code{NULL})
+@deftypefn Extension char* concat (const char *@var{s1}, const char *@var{s2}, @
+ @dots{}, @code{NULL})
Concatenate zero or more of strings and return the result in freshly
-@code{xmalloc}ed memory. Returns @code{NULL} if insufficient memory is
-available. The argument list is terminated by the first @code{NULL}
-pointer encountered. Pointers to empty strings are ignored.
+@code{xmalloc}ed memory. The argument list is terminated by the first
+@code{NULL} pointer encountered. Pointers to empty strings are ignored.
@end deftypefn
-@c argv.c:49
-@deftypefn Extension char** dupargv (char **@var{vector})
+@c argv.c:487
+@deftypefn Extension int countargv (char * const *@var{argv})
+
+Return the number of elements in @var{argv}.
+Returns zero if @var{argv} is NULL.
+
+@end deftypefn
+
+@c crc32.c:140
+@deftypefn Extension {unsigned int} crc32 (const unsigned char *@var{buf}, @
+ int @var{len}, unsigned int @var{init})
+
+Compute the 32-bit CRC of @var{buf} which has length @var{len}. The
+starting value is @var{init}; this may be used to compute the CRC of
+data split across multiple buffers by passing the return value of each
+call as the @var{init} parameter of the next.
+
+This is used by the @command{gdb} remote protocol for the @samp{qCRC}
+command. In order to get the same results as gdb for a block of data,
+you must pass the first CRC parameter as @code{0xffffffff}.
+
+This CRC can be specified as:
+
+ Width : 32
+ Poly : 0x04c11db7
+ Init : parameter, typically 0xffffffff
+ RefIn : false
+ RefOut : false
+ XorOut : 0
+
+This differs from the "standard" CRC-32 algorithm in that the values
+are not reflected, and there is no final XOR value. These differences
+make it easy to compose the values of multiple blocks.
+
+@end deftypefn
+
+@c argv.c:59
+@deftypefn Extension char** dupargv (char * const *@var{vector})
Duplicate an argument vector. Simply scans through @var{vector},
duplicating each argument until the terminating @code{NULL} is found.
@end deftypefn
-@c strerror.c:567
+@c strerror.c:572
@deftypefn Extension int errno_max (void)
Returns the maximum @code{errno} value for which a corresponding
@end deftypefn
+@c argv.c:344
+@deftypefn Extension void expandargv (int *@var{argcp}, char ***@var{argvp})
+
+The @var{argcp} and @code{argvp} arguments are pointers to the usual
+@code{argc} and @code{argv} arguments to @code{main}. This function
+looks for arguments that begin with the character @samp{@@}. Any such
+arguments are interpreted as ``response files''. The contents of the
+response file are interpreted as additional command line options. In
+particular, the file is separated into whitespace-separated strings;
+each such string is taken as a command-line option. The new options
+are inserted in place of the option naming the response file, and
+@code{*argcp} and @code{*argvp} will be updated. If the value of
+@code{*argvp} is modified by this function, then the new value has
+been dynamically allocated and can be deallocated by the caller with
+@code{freeargv}. However, most callers will simply call
+@code{expandargv} near the beginning of @code{main} and allow the
+operating system to free the memory when the program exits.
+
+@end deftypefn
+
@c fdmatch.c:23
@deftypefn Extension int fdmatch (int @var{fd1}, int @var{fd2})
@end deftypefn
+@c fopen_unlocked.c:49
+@deftypefn Extension {FILE *} fdopen_unlocked (int @var{fildes}, @
+ const char * @var{mode})
+
+Opens and returns a @code{FILE} pointer via @code{fdopen}. If the
+operating system supports it, ensure that the stream is setup to avoid
+any multi-threaded locking. Otherwise return the @code{FILE} pointer
+unchanged.
+
+@end deftypefn
+
@c ffs.c:3
@deftypefn Supplemental int ffs (int @var{valu})
@end deftypefn
+@c filename_cmp.c:37
+@deftypefn Extension int filename_cmp (const char *@var{s1}, const char *@var{s2})
+
+Return zero if the two file names @var{s1} and @var{s2} are equivalent.
+If not equivalent, the returned value is similar to what @code{strcmp}
+would return. In other words, it returns a negative value if @var{s1}
+is less than @var{s2}, or a positive value if @var{s2} is greater than
+@var{s2}.
+
+This function does not normalize file names. As a result, this function
+will treat filenames that are spelled differently as different even in
+the case when the two filenames point to the same underlying file.
+However, it does handle the fact that on DOS-like file systems, forward
+and backward slashes are equal.
+
+@end deftypefn
+
+@c filename_cmp.c:183
+@deftypefn Extension int filename_eq (const void *@var{s1}, const void *@var{s2})
+
+Return non-zero if file names @var{s1} and @var{s2} are equivalent.
+This function is for use with hashtab.c hash tables.
+
+@end deftypefn
+
+@c filename_cmp.c:152
+@deftypefn Extension hashval_t filename_hash (const void *@var{s})
+
+Return the hash value for file name @var{s} that will be compared
+using filename_cmp.
+This function is for use with hashtab.c hash tables.
+
+@end deftypefn
+
+@c filename_cmp.c:94
+@deftypefn Extension int filename_ncmp (const char *@var{s1}, const char *@var{s2}, size_t @var{n})
+
+Return zero if the two file names @var{s1} and @var{s2} are equivalent
+in range @var{n}.
+If not equivalent, the returned value is similar to what @code{strncmp}
+would return. In other words, it returns a negative value if @var{s1}
+is less than @var{s2}, or a positive value if @var{s2} is greater than
+@var{s2}.
+
+This function does not normalize file names. As a result, this function
+will treat filenames that are spelled differently as different even in
+the case when the two filenames point to the same underlying file.
+However, it does handle the fact that on DOS-like file systems, forward
+and backward slashes are equal.
+
+@end deftypefn
+
@c fnmatch.txh:1
-@deftypefn Replacement int fnmatch (const char *@var{pattern}, const char *@var{string}, int @var{flags})
+@deftypefn Replacement int fnmatch (const char *@var{pattern}, @
+ const char *@var{string}, int @var{flags})
Matches @var{string} against @var{pattern}, returning zero if it
matches, @code{FNM_NOMATCH} if not. @var{pattern} may contain the
@end deftypefn
-@c argv.c:94
+@c fopen_unlocked.c:39
+@deftypefn Extension {FILE *} fopen_unlocked (const char *@var{path}, @
+ const char * @var{mode})
+
+Opens and returns a @code{FILE} pointer via @code{fopen}. If the
+operating system supports it, ensure that the stream is setup to avoid
+any multi-threaded locking. Otherwise return the @code{FILE} pointer
+unchanged.
+
+@end deftypefn
+
+@c argv.c:93
@deftypefn Extension void freeargv (char **@var{vector})
Free an argument vector that was built using @code{buildargv}. Simply
@end deftypefn
-@c getruntime.c:82
+@c fopen_unlocked.c:59
+@deftypefn Extension {FILE *} freopen_unlocked (const char * @var{path}, @
+ const char * @var{mode}, FILE * @var{stream})
+
+Opens and returns a @code{FILE} pointer via @code{freopen}. If the
+operating system supports it, ensure that the stream is setup to avoid
+any multi-threaded locking. Otherwise return the @code{FILE} pointer
+unchanged.
+
+@end deftypefn
+
+@c getruntime.c:86
@deftypefn Replacement long get_run_time (void)
Returns the time used so far, in microseconds. If possible, this is
@end deftypefn
-@c hex.c:30
+@c hex.c:33
@deftypefn Extension void hex_init (void)
Initializes the array mapping the current character set to
@end deftypefn
-@c hex.c:39
+@c hex.c:42
@deftypefn Extension int hex_p (int @var{c})
Evaluates to non-zero if the given character is a valid hex character,
@end deftypefn
-@c hex.c:47
+@c hex.c:50
@deftypefn Extension {unsigned int} hex_value (int @var{c})
Returns the numeric equivalent of the given character when interpreted
-as a hexidecimal digit. The result is undefined if you pass an
+as a hexadecimal digit. The result is undefined if you pass an
invalid hex digit. Note that the value you pass will be cast to
@code{unsigned char} within the macro.
@end deftypefn
+@c safe-ctype.c:24
+@defvr Extension HOST_CHARSET
+This macro indicates the basic character set and encoding used by the
+host: more precisely, the encoding used for character constants in
+preprocessor @samp{#if} statements (the C "execution character set").
+It is defined by @file{safe-ctype.h}, and will be an integer constant
+with one of the following values:
+
+@ftable @code
+@item HOST_CHARSET_UNKNOWN
+The host character set is unknown - that is, not one of the next two
+possibilities.
+
+@item HOST_CHARSET_ASCII
+The host character set is ASCII.
+
+@item HOST_CHARSET_EBCDIC
+The host character set is some variant of EBCDIC. (Only one of the
+nineteen EBCDIC varying characters is tested; exercise caution.)
+@end ftable
+@end defvr
+
+@c hashtab.c:327
+@deftypefn Supplemental htab_t htab_create_typed_alloc (size_t @var{size}, @
+htab_hash @var{hash_f}, htab_eq @var{eq_f}, htab_del @var{del_f}, @
+htab_alloc @var{alloc_tab_f}, htab_alloc @var{alloc_f}, @
+htab_free @var{free_f})
+
+This function creates a hash table that uses two different allocators
+@var{alloc_tab_f} and @var{alloc_f} to use for allocating the table itself
+and its entries respectively. This is useful when variables of different
+types need to be allocated with different allocators.
+
+The created hash table is slightly larger than @var{size} and it is
+initially empty (all the hash table entries are @code{HTAB_EMPTY_ENTRY}).
+The function returns the created hash table, or @code{NULL} if memory
+allocation fails.
+
+@end deftypefn
+
@c index.c:5
@deftypefn Supplemental char* index (char *@var{s}, int @var{c})
@end deftypefn
@c insque.c:6
-@deftypefn Supplemental void insque (struct qelem *@var{elem}, struct qelem *@var{pred})
+@deftypefn Supplemental void insque (struct qelem *@var{elem}, @
+ struct qelem *@var{pred})
@deftypefnx Supplemental void remque (struct qelem *@var{elem})
Routines to manipulate queues built from doubly linked lists. The
@end deftypefn
-@c safe-ctype.c:46
+@c safe-ctype.c:45
@deffn Extension ISALPHA (@var{c})
@deffnx Extension ISALNUM (@var{c})
@deffnx Extension ISBLANK (@var{c})
@end itemize
@end deffn
-@c safe-ctype.c:95
+@c safe-ctype.c:94
@deffn Extension ISIDNUM (@var{c})
@deffnx Extension ISIDST (@var{c})
@deffnx Extension IS_VSPACE (@var{c})
@end deftypefn
-@c make-relative-prefix.c:24
-@deftypefn Extension {const char*} make_relative_prefix (const char *@var{progname}, const char *@var{bin_prefix}, const char *@var{prefix})
+@c make-relative-prefix.c:23
+@deftypefn Extension {const char*} make_relative_prefix (const char *@var{progname}, @
+ const char *@var{bin_prefix}, const char *@var{prefix})
Given three paths @var{progname}, @var{bin_prefix}, @var{prefix},
return the path that is in the same position relative to
@end deftypefn
-@c make-temp-file.c:137
+@c make-temp-file.c:173
@deftypefn Replacement char* make_temp_file (const char *@var{suffix})
Return a temporary file name (as a string) or @code{NULL} if unable to
@end deftypefn
@c memchr.c:3
-@deftypefn Supplemental void* memchr (const void *@var{s}, int @var{c}, size_t @var{n})
+@deftypefn Supplemental void* memchr (const void *@var{s}, int @var{c}, @
+ size_t @var{n})
This function searches memory starting at @code{*@var{s}} for the
character @var{c}. The search only ends with the first occurrence of
@end deftypefn
@c memcmp.c:6
-@deftypefn Supplemental int memcmp (const void *@var{x}, const void *@var{y}, size_t @var{count})
+@deftypefn Supplemental int memcmp (const void *@var{x}, const void *@var{y}, @
+ size_t @var{count})
Compares the first @var{count} bytes of two areas of memory. Returns
zero if they are the same, a value less than zero if @var{x} is
@end deftypefn
@c memcpy.c:6
-@deftypefn Supplemental void* memcpy (void *@var{out}, const void *@var{in}, size_t @var{length})
+@deftypefn Supplemental void* memcpy (void *@var{out}, const void *@var{in}, @
+ size_t @var{length})
Copies @var{length} bytes from memory region @var{in} to region
@var{out}. Returns a pointer to @var{out}.
@end deftypefn
+@c memmem.c:20
+@deftypefn Supplemental void* memmem (const void *@var{haystack}, @
+ size_t @var{haystack_len} const void *@var{needle}, size_t @var{needle_len})
+
+Returns a pointer to the first occurrence of @var{needle} (length
+@var{needle_len}) in @var{haystack} (length @var{haystack_len}).
+Returns @code{NULL} if not found.
+
+@end deftypefn
+
@c memmove.c:6
-@deftypefn Supplemental void* memmove (void *@var{from}, const void *@var{to}, size_t @var{count})
+@deftypefn Supplemental void* memmove (void *@var{from}, const void *@var{to}, @
+ size_t @var{count})
Copies @var{count} bytes from memory area @var{from} to memory area
@var{to}, returning a pointer to @var{to}.
@end deftypefn
@c mempcpy.c:23
-@deftypefn Supplemental void* mempcpy (void *@var{out}, const void *@var{in}, size_t @var{length})
+@deftypefn Supplemental void* mempcpy (void *@var{out}, const void *@var{in}, @
+ size_t @var{length})
Copies @var{length} bytes from memory region @var{in} to region
@var{out}. Returns a pointer to @var{out} + @var{length}.
@end deftypefn
@c memset.c:6
-@deftypefn Supplemental void* memset (void *@var{s}, int @var{c}, size_t @var{count})
+@deftypefn Supplemental void* memset (void *@var{s}, int @var{c}, @
+ size_t @var{count})
Sets the first @var{count} bytes of @var{s} to the constant byte
@var{c}, returning a pointer to @var{s}.
@end deftypefn
-@c mkstemps.c:54
-@deftypefn Replacement int mkstemps (char *@var{template}, int @var{suffix_len})
+@c mkstemps.c:60
+@deftypefn Replacement int mkstemps (char *@var{pattern}, int @var{suffix_len})
-Generate a unique temporary file name from @var{template}.
-@var{template} has the form:
+Generate a unique temporary file name from @var{pattern}.
+@var{pattern} has the form:
@example
@var{path}/ccXXXXXX@var{suffix}
@end example
@var{suffix_len} tells us how long @var{suffix} is (it can be zero
-length). The last six characters of @var{template} before @var{suffix}
+length). The last six characters of @var{pattern} before @var{suffix}
must be @samp{XXXXXX}; they are replaced with a string that makes the
filename unique. Returns a file descriptor open on the file for
reading and writing.
@end deftypefn
-@c pexecute.txh:155
+@c pexecute.txh:278
@deftypefn Extension void pex_free (struct pex_obj @var{obj})
-Clean up and free all data associated with @var{obj}.
+Clean up and free all data associated with @var{obj}. If you have not
+yet called @code{pex_get_times} or @code{pex_get_status}, this will
+try to kill the subprocesses.
@end deftypefn
-@c pexecute.txh:131
-@deftypefn Extension int pex_get_status (struct pex_obj *@var{obj}, int @var{count}, int *@var{vector})
+@c pexecute.txh:251
+@deftypefn Extension int pex_get_status (struct pex_obj *@var{obj}, @
+ int @var{count}, int *@var{vector})
Returns the exit status of all programs run using @var{obj}.
@var{count} is the number of results expected. The results will be
@end deftypefn
-@c pexecute.txh:140
-@deftypefn Extension int pex_get_times (struct pex_obj *@var{obj}, int @var{count}, struct pex_time *@var{vector})
+@c pexecute.txh:261
+@deftypefn Extension int pex_get_times (struct pex_obj *@var{obj}, @
+ int @var{count}, struct pex_time *@var{vector})
Returns the process execution times of all programs run using
@var{obj}. @var{count} is the number of results expected. The
order of the calls to @code{pex_run}. Returns 0 on error, 1 on
success.
-@code{struct pex_time} has the following fields: @code{user_seconds},
+@code{struct pex_time} has the following fields of the type
+@code{unsigned long}: @code{user_seconds},
@code{user_microseconds}, @code{system_seconds},
@code{system_microseconds}. On systems which do not support reporting
process times, all the fields will be set to @code{0}.
@end deftypefn
-@c pexecute.txh:119
-@deftypefn Extension FILE * pex_read_output (struct pex_obj *@var{obj}, int @var{binary})
+@c pexecute.txh:2
+@deftypefn Extension {struct pex_obj *} pex_init (int @var{flags}, @
+ const char *@var{pname}, const char *@var{tempbase})
+
+Prepare to execute one or more programs, with standard output of each
+program fed to standard input of the next. This is a system
+independent interface to execute a pipeline.
+
+@var{flags} is a bitwise combination of the following:
+
+@table @code
+
+@vindex PEX_RECORD_TIMES
+@item PEX_RECORD_TIMES
+Record subprocess times if possible.
+
+@vindex PEX_USE_PIPES
+@item PEX_USE_PIPES
+Use pipes for communication between processes, if possible.
+
+@vindex PEX_SAVE_TEMPS
+@item PEX_SAVE_TEMPS
+Don't delete temporary files used for communication between
+processes.
+
+@end table
+
+@var{pname} is the name of program to be executed, used in error
+messages. @var{tempbase} is a base name to use for any required
+temporary files; it may be @code{NULL} to use a randomly chosen name.
+
+@end deftypefn
+
+@c pexecute.txh:161
+@deftypefn Extension {FILE *} pex_input_file (struct pex_obj *@var{obj}, @
+ int @var{flags}, const char *@var{in_name})
+
+Return a stream for a temporary file to pass to the first program in
+the pipeline as input.
+
+The name of the input file is chosen according to the same rules
+@code{pex_run} uses to choose output file names, based on
+@var{in_name}, @var{obj} and the @code{PEX_SUFFIX} bit in @var{flags}.
+
+Don't call @code{fclose} on the returned stream; the first call to
+@code{pex_run} closes it automatically.
+
+If @var{flags} includes @code{PEX_BINARY_OUTPUT}, open the stream in
+binary mode; otherwise, open it in the default mode. Including
+@code{PEX_BINARY_OUTPUT} in @var{flags} has no effect on Unix.
+@end deftypefn
+
+@c pexecute.txh:179
+@deftypefn Extension {FILE *} pex_input_pipe (struct pex_obj *@var{obj}, @
+ int @var{binary})
+
+Return a stream @var{fp} for a pipe connected to the standard input of
+the first program in the pipeline; @var{fp} is opened for writing.
+You must have passed @code{PEX_USE_PIPES} to the @code{pex_init} call
+that returned @var{obj}.
+
+You must close @var{fp} using @code{fclose} yourself when you have
+finished writing data to the pipeline.
+
+The file descriptor underlying @var{fp} is marked not to be inherited
+by child processes.
+
+On systems that do not support pipes, this function returns
+@code{NULL}, and sets @code{errno} to @code{EINVAL}. If you would
+like to write code that is portable to all systems the @code{pex}
+functions support, consider using @code{pex_input_file} instead.
+
+There are two opportunities for deadlock using
+@code{pex_input_pipe}:
+
+@itemize @bullet
+@item
+Most systems' pipes can buffer only a fixed amount of data; a process
+that writes to a full pipe blocks. Thus, if you write to @file{fp}
+before starting the first process, you run the risk of blocking when
+there is no child process yet to read the data and allow you to
+continue. @code{pex_input_pipe} makes no promises about the
+size of the pipe's buffer, so if you need to write any data at all
+before starting the first process in the pipeline, consider using
+@code{pex_input_file} instead.
+
+@item
+Using @code{pex_input_pipe} and @code{pex_read_output} together
+may also cause deadlock. If the output pipe fills up, so that each
+program in the pipeline is waiting for the next to read more data, and
+you fill the input pipe by writing more data to @var{fp}, then there
+is no way to make progress: the only process that could read data from
+the output pipe is you, but you are blocked on the input pipe.
+
+@end itemize
+
+@end deftypefn
+
+@c pexecute.txh:286
+@deftypefn Extension {const char *} pex_one (int @var{flags}, @
+ const char *@var{executable}, char * const *@var{argv}, @
+ const char *@var{pname}, const char *@var{outname}, const char *@var{errname}, @
+ int *@var{status}, int *@var{err})
+
+An interface to permit the easy execution of a
+single program. The return value and most of the parameters are as
+for a call to @code{pex_run}. @var{flags} is restricted to a
+combination of @code{PEX_SEARCH}, @code{PEX_STDERR_TO_STDOUT}, and
+@code{PEX_BINARY_OUTPUT}. @var{outname} is interpreted as if
+@code{PEX_LAST} were set. On a successful return, @code{*@var{status}} will
+be set to the exit status of the program.
+
+@end deftypefn
+
+@c pexecute.txh:237
+@deftypefn Extension {FILE *} pex_read_err (struct pex_obj *@var{obj}, @
+ int @var{binary})
+
+Returns a @code{FILE} pointer which may be used to read the standard
+error of the last program in the pipeline. When this is used,
+@code{PEX_LAST} should not be used in a call to @code{pex_run}. After
+this is called, @code{pex_run} may no longer be called with the same
+@var{obj}. @var{binary} should be non-zero if the file should be
+opened in binary mode. Don't call @code{fclose} on the returned file;
+it will be closed by @code{pex_free}.
+
+@end deftypefn
+
+@c pexecute.txh:224
+@deftypefn Extension {FILE *} pex_read_output (struct pex_obj *@var{obj}, @
+ int @var{binary})
Returns a @code{FILE} pointer which may be used to read the standard
output of the last program in the pipeline. When this is used,
@end deftypefn
-@c pexecute.txh:173
-@deftypefn Extension int pexecute (const char *@var{program}, char * const *@var{argv}, const char *@var{this_pname}, const char *@var{temp_base}, char **@var{errmsg_fmt}, char **@var{errmsg_arg}, int flags)
+@c pexecute.txh:34
+@deftypefn Extension {const char *} pex_run (struct pex_obj *@var{obj}, @
+ int @var{flags}, const char *@var{executable}, char * const *@var{argv}, @
+ const char *@var{outname}, const char *@var{errname}, int *@var{err})
+
+Execute one program in a pipeline. On success this returns
+@code{NULL}. On failure it returns an error message, a statically
+allocated string.
+
+@var{obj} is returned by a previous call to @code{pex_init}.
+
+@var{flags} is a bitwise combination of the following:
+
+@table @code
+
+@vindex PEX_LAST
+@item PEX_LAST
+This must be set on the last program in the pipeline. In particular,
+it should be set when executing a single program. The standard output
+of the program will be sent to @var{outname}, or, if @var{outname} is
+@code{NULL}, to the standard output of the calling program. Do @emph{not}
+set this bit if you want to call @code{pex_read_output}
+(described below). After a call to @code{pex_run} with this bit set,
+@var{pex_run} may no longer be called with the same @var{obj}.
+
+@vindex PEX_SEARCH
+@item PEX_SEARCH
+Search for the program using the user's executable search path.
+
+@vindex PEX_SUFFIX
+@item PEX_SUFFIX
+@var{outname} is a suffix. See the description of @var{outname},
+below.
+
+@vindex PEX_STDERR_TO_STDOUT
+@item PEX_STDERR_TO_STDOUT
+Send the program's standard error to standard output, if possible.
+
+@vindex PEX_BINARY_INPUT
+@vindex PEX_BINARY_OUTPUT
+@vindex PEX_BINARY_ERROR
+@item PEX_BINARY_INPUT
+@itemx PEX_BINARY_OUTPUT
+@itemx PEX_BINARY_ERROR
+The standard input (output or error) of the program should be read (written) in
+binary mode rather than text mode. These flags are ignored on systems
+which do not distinguish binary mode and text mode, such as Unix. For
+proper behavior these flags should match appropriately---a call to
+@code{pex_run} using @code{PEX_BINARY_OUTPUT} should be followed by a
+call using @code{PEX_BINARY_INPUT}.
+
+@vindex PEX_STDERR_TO_PIPE
+@item PEX_STDERR_TO_PIPE
+Send the program's standard error to a pipe, if possible. This flag
+cannot be specified together with @code{PEX_STDERR_TO_STDOUT}. This
+flag can be specified only on the last program in pipeline.
+
+@end table
+
+@var{executable} is the program to execute. @var{argv} is the set of
+arguments to pass to the program; normally @code{@var{argv}[0]} will
+be a copy of @var{executable}.
+
+@var{outname} is used to set the name of the file to use for standard
+output. There are two cases in which no output file will be used:
+
+@enumerate
+@item
+if @code{PEX_LAST} is not set in @var{flags}, and @code{PEX_USE_PIPES}
+was set in the call to @code{pex_init}, and the system supports pipes
+
+@item
+if @code{PEX_LAST} is set in @var{flags}, and @var{outname} is
+@code{NULL}
+@end enumerate
+
+@noindent
+Otherwise the code will use a file to hold standard
+output. If @code{PEX_LAST} is not set, this file is considered to be
+a temporary file, and it will be removed when no longer needed, unless
+@code{PEX_SAVE_TEMPS} was set in the call to @code{pex_init}.
+
+There are two cases to consider when setting the name of the file to
+hold standard output.
+
+@enumerate
+@item
+@code{PEX_SUFFIX} is set in @var{flags}. In this case
+@var{outname} may not be @code{NULL}. If the @var{tempbase} parameter
+to @code{pex_init} was not @code{NULL}, then the output file name is
+the concatenation of @var{tempbase} and @var{outname}. If
+@var{tempbase} was @code{NULL}, then the output file name is a random
+file name ending in @var{outname}.
+
+@item
+@code{PEX_SUFFIX} was not set in @var{flags}. In this
+case, if @var{outname} is not @code{NULL}, it is used as the output
+file name. If @var{outname} is @code{NULL}, and @var{tempbase} was
+not NULL, the output file name is randomly chosen using
+@var{tempbase}. Otherwise the output file name is chosen completely
+at random.
+@end enumerate
+
+@var{errname} is the file name to use for standard error output. If
+it is @code{NULL}, standard error is the same as the caller's.
+Otherwise, standard error is written to the named file.
+
+On an error return, the code sets @code{*@var{err}} to an @code{errno}
+value, or to 0 if there is no relevant @code{errno}.
+
+@end deftypefn
+
+@c pexecute.txh:145
+@deftypefn Extension {const char *} pex_run_in_environment (struct pex_obj *@var{obj}, @
+ int @var{flags}, const char *@var{executable}, char * const *@var{argv}, @
+ char * const *@var{env}, int @var{env_size}, const char *@var{outname}, @
+ const char *@var{errname}, int *@var{err})
+
+Execute one program in a pipeline, permitting the environment for the
+program to be specified. Behaviour and parameters not listed below are
+as for @code{pex_run}.
+
+@var{env} is the environment for the child process, specified as an array of
+character pointers. Each element of the array should point to a string of the
+form @code{VAR=VALUE}, with the exception of the last element that must be
+@code{NULL}.
+
+@end deftypefn
+
+@c pexecute.txh:301
+@deftypefn Extension int pexecute (const char *@var{program}, @
+ char * const *@var{argv}, const char *@var{this_pname}, @
+ const char *@var{temp_base}, char **@var{errmsg_fmt}, @
+ char **@var{errmsg_arg}, int @var{flags})
This is the old interface to execute one or more programs. It is
still supported for compatibility purposes, but is no longer
@end deftypefn
-@c strsignal.c:539
-@deftypefn Supplemental void psignal (unsigned @var{signo}, char *@var{message})
+@c strsignal.c:541
+@deftypefn Supplemental void psignal (int @var{signo}, char *@var{message})
Print @var{message} to the standard error, followed by a colon,
followed by the description of the signal specified by @var{signo},
@end deftypefn
-@c pexecute.txh:181
+@c pexecute.txh:312
@deftypefn Extension int pwait (int @var{pid}, int *@var{status}, int @var{flags})
Another part of the old execution interface.
@c random.c:39
@deftypefn Supplement {long int} random (void)
@deftypefnx Supplement void srandom (unsigned int @var{seed})
-@deftypefnx Supplement void* initstate (unsigned int @var{seed}, void *@var{arg_state}, unsigned long @var{n})
+@deftypefnx Supplement void* initstate (unsigned int @var{seed}, @
+ void *@var{arg_state}, unsigned long @var{n})
@deftypefnx Supplement void* setstate (void *@var{arg_state})
Random number functions. @code{random} returns a random number in the
@end deftypefn
-@c concat.c:167
-@deftypefn Extension char* reconcat (char *@var{optr}, const char *@var{s1}, @dots{}, @code{NULL})
+@c concat.c:160
+@deftypefn Extension char* reconcat (char *@var{optr}, const char *@var{s1}, @
+ @dots{}, @code{NULL})
Same as @code{concat}, except that if @var{optr} is not @code{NULL} it
is freed after the string is created. This is intended to be useful
@end deftypefn
@c setenv.c:22
-@deftypefn Supplemental int setenv (const char *@var{name}, const char *@var{value}, int @var{overwrite})
+@deftypefn Supplemental int setenv (const char *@var{name}, @
+ const char *@var{value}, int @var{overwrite})
@deftypefnx Supplemental void unsetenv (const char *@var{name})
@code{setenv} adds @var{name} to the environment with value
@end deftypefn
+@c setproctitle.c:31
+@deftypefn Supplemental void setproctitle (const char *@var{fmt}, ...)
+
+Set the title of a process to @var{fmt}. va args not supported for now,
+but defined for compatibility with BSD.
+
+@end deftypefn
+
@c strsignal.c:348
@deftypefn Extension int signo_max (void)
@end deftypefn
+@c simple-object.txh:96
+@deftypefn Extension {const char *} simple_object_attributes_compare @
+ (simple_object_attributes *@var{attrs1}, simple_object_attributes *@var{attrs2}, @
+ int *@var{err})
+
+Compare @var{attrs1} and @var{attrs2}. If they could be linked
+together without error, return @code{NULL}. Otherwise, return an
+error message and set @code{*@var{err}} to an errno value or @code{0}
+if there is no relevant errno.
+
+@end deftypefn
+
+@c simple-object.txh:81
+@deftypefn Extension {simple_object_attributes *} simple_object_fetch_attributes @
+ (simple_object_read *@var{simple_object}, const char **@var{errmsg}, int *@var{err})
+
+Fetch the attributes of @var{simple_object}. The attributes are
+internal information such as the format of the object file, or the
+architecture it was compiled for. This information will persist until
+@code{simple_object_attributes_release} is called, even if
+@var{simple_object} itself is released.
+
+On error this returns @code{NULL}, sets @code{*@var{errmsg}} to an
+error message, and sets @code{*@var{err}} to an errno value or
+@code{0} if there is no relevant errno.
+
+@end deftypefn
+
+@c simple-object.txh:49
+@deftypefn Extension {int} simple_object_find_section @
+ (simple_object_read *@var{simple_object} off_t *@var{offset}, @
+ off_t *@var{length}, const char **@var{errmsg}, int *@var{err})
+
+Look for the section @var{name} in @var{simple_object}. This returns
+information for the first section with that name.
+
+If found, return 1 and set @code{*@var{offset}} to the offset in the
+file of the section contents and set @code{*@var{length}} to the
+length of the section contents. The value in @code{*@var{offset}}
+will be relative to the offset passed to
+@code{simple_object_open_read}.
+
+If the section is not found, and no error occurs,
+@code{simple_object_find_section} returns @code{0} and set
+@code{*@var{errmsg}} to @code{NULL}.
+
+If an error occurs, @code{simple_object_find_section} returns
+@code{0}, sets @code{*@var{errmsg}} to an error message, and sets
+@code{*@var{err}} to an errno value or @code{0} if there is no
+relevant errno.
+
+@end deftypefn
+
+@c simple-object.txh:27
+@deftypefn Extension {const char *} simple_object_find_sections @
+ (simple_object_read *@var{simple_object}, int (*@var{pfn}) (void *@var{data}, @
+ const char *@var{name}, off_t @var{offset}, off_t @var{length}), @
+ void *@var{data}, int *@var{err})
+
+This function calls @var{pfn} for each section in @var{simple_object}.
+It calls @var{pfn} with the section name, the offset within the file
+of the section contents, and the length of the section contents. The
+offset within the file is relative to the offset passed to
+@code{simple_object_open_read}. The @var{data} argument to this
+function is passed along to @var{pfn}.
+
+If @var{pfn} returns @code{0}, the loop over the sections stops and
+@code{simple_object_find_sections} returns. If @var{pfn} returns some
+other value, the loop continues.
+
+On success @code{simple_object_find_sections} returns. On error it
+returns an error string, and sets @code{*@var{err}} to an errno value
+or @code{0} if there is no relevant errno.
+
+@end deftypefn
+
+@c simple-object.txh:2
+@deftypefn Extension {simple_object_read *} simple_object_open_read @
+ (int @var{descriptor}, off_t @var{offset}, const char *{segment_name}, @
+ const char **@var{errmsg}, int *@var{err})
+
+Opens an object file for reading. Creates and returns an
+@code{simple_object_read} pointer which may be passed to other
+functions to extract data from the object file.
+
+@var{descriptor} holds a file descriptor which permits reading.
+
+@var{offset} is the offset into the file; this will be @code{0} in the
+normal case, but may be a different value when reading an object file
+in an archive file.
+
+@var{segment_name} is only used with the Mach-O file format used on
+Darwin aka Mac OS X. It is required on that platform, and means to
+only look at sections within the segment with that name. The
+parameter is ignored on other systems.
+
+If an error occurs, this functions returns @code{NULL} and sets
+@code{*@var{errmsg}} to an error string and sets @code{*@var{err}} to
+an errno value or @code{0} if there is no relevant errno.
+
+@end deftypefn
+
+@c simple-object.txh:107
+@deftypefn Extension {void} simple_object_release_attributes @
+ (simple_object_attributes *@var{attrs})
+
+Release all resources associated with @var{attrs}.
+
+@end deftypefn
+
+@c simple-object.txh:73
+@deftypefn Extension {void} simple_object_release_read @
+ (simple_object_read *@var{simple_object})
+
+Release all resources associated with @var{simple_object}. This does
+not close the file descriptor.
+
+@end deftypefn
+
+@c simple-object.txh:184
+@deftypefn Extension {void} simple_object_release_write @
+ (simple_object_write *@var{simple_object})
+
+Release all resources associated with @var{simple_object}.
+
+@end deftypefn
+
+@c simple-object.txh:114
+@deftypefn Extension {simple_object_write *} simple_object_start_write @
+ (simple_object_attributes @var{attrs}, const char *@var{segment_name}, @
+ const char **@var{errmsg}, int *@var{err})
+
+Start creating a new object file using the object file format
+described in @var{attrs}. You must fetch attribute information from
+an existing object file before you can create a new one. There is
+currently no support for creating an object file de novo.
+
+@var{segment_name} is only used with Mach-O as found on Darwin aka Mac
+OS X. The parameter is required on that target. It means that all
+sections are created within the named segment. It is ignored for
+other object file formats.
+
+On error @code{simple_object_start_write} returns @code{NULL}, sets
+@code{*@var{ERRMSG}} to an error message, and sets @code{*@var{err}}
+to an errno value or @code{0} if there is no relevant errno.
+
+@end deftypefn
+
+@c simple-object.txh:153
+@deftypefn Extension {const char *} simple_object_write_add_data @
+ (simple_object_write *@var{simple_object}, @
+ simple_object_write_section *@var{section}, const void *@var{buffer}, @
+ size_t @var{size}, int @var{copy}, int *@var{err})
+
+Add data @var{buffer}/@var{size} to @var{section} in
+@var{simple_object}. If @var{copy} is non-zero, the data will be
+copied into memory if necessary. If @var{copy} is zero, @var{buffer}
+must persist until @code{simple_object_write_to_file} is called. is
+released.
+
+On success this returns @code{NULL}. On error this returns an error
+message, and sets @code{*@var{err}} to an errno value or 0 if there is
+no relevant erro.
+
+@end deftypefn
+
+@c simple-object.txh:134
+@deftypefn Extension {simple_object_write_section *} simple_object_write_create_section @
+ (simple_object_write *@var{simple_object}, const char *@var{name}, @
+ unsigned int @var{align}, const char **@var{errmsg}, int *@var{err})
+
+Add a section to @var{simple_object}. @var{name} is the name of the
+new section. @var{align} is the required alignment expressed as the
+number of required low-order 0 bits (e.g., 2 for alignment to a 32-bit
+boundary).
+
+The section is created as containing data, readable, not writable, not
+executable, not loaded at runtime. The section is not written to the
+file until @code{simple_object_write_to_file} is called.
+
+On error this returns @code{NULL}, sets @code{*@var{errmsg}} to an
+error message, and sets @code{*@var{err}} to an errno value or
+@code{0} if there is no relevant errno.
+
+@end deftypefn
+
+@c simple-object.txh:170
+@deftypefn Extension {const char *} simple_object_write_to_file @
+ (simple_object_write *@var{simple_object}, int @var{descriptor}, int *@var{err})
+
+Write the complete object file to @var{descriptor}, an open file
+descriptor. This writes out all the data accumulated by calls to
+@code{simple_object_write_create_section} and
+@var{simple_object_write_add_data}.
+
+This returns @code{NULL} on success. On error this returns an error
+message and sets @code{*@var{err}} to an errno value or @code{0} if
+there is no relevant errno.
+
+@end deftypefn
+
@c snprintf.c:28
-@deftypefn Supplemental int snprintf (char *@var{buf}, size_t @var{n}, const char *@var{format}, ...)
+@deftypefn Supplemental int snprintf (char *@var{buf}, size_t @var{n}, @
+ const char *@var{format}, ...)
-This function is similar to sprintf, but it will print at most @var{n}
-characters. On error the return value is -1, otherwise it returns the
-number of characters that would have been printed had @var{n} been
-sufficiently large, regardless of the actual value of @var{n}. Note
-some pre-C99 system libraries do not implement this correctly so users
-cannot generally rely on the return value if the system version of
-this function is used.
+This function is similar to @code{sprintf}, but it will write to
+@var{buf} at most @code{@var{n}-1} bytes of text, followed by a
+terminating null byte, for a total of @var{n} bytes.
+On error the return value is -1, otherwise it returns the number of
+bytes, not including the terminating null byte, that would have been
+written had @var{n} been sufficiently large, regardless of the actual
+value of @var{n}. Note some pre-C99 system libraries do not implement
+this correctly so users cannot generally rely on the return value if
+the system version of this function is used.
@end deftypefn
@end deftypefn
+@c splay-tree.c:305
+@deftypefn Supplemental splay_tree splay_tree_new_with_typed_alloc @
+(splay_tree_compare_fn @var{compare_fn}, @
+splay_tree_delete_key_fn @var{delete_key_fn}, @
+splay_tree_delete_value_fn @var{delete_value_fn}, @
+splay_tree_allocate_fn @var{tree_allocate_fn}, @
+splay_tree_allocate_fn @var{node_allocate_fn}, @
+splay_tree_deallocate_fn @var{deallocate_fn}, @
+void * @var{allocate_data})
+
+This function creates a splay tree that uses two different allocators
+@var{tree_allocate_fn} and @var{node_allocate_fn} to use for allocating the
+tree itself and its nodes respectively. This is useful when variables of
+different types need to be allocated with different allocators.
+
+The splay tree will use @var{compare_fn} to compare nodes,
+@var{delete_key_fn} to deallocate keys, and @var{delete_value_fn} to
+deallocate values. Keys and values will be deallocated when the
+tree is deleted using splay_tree_delete or when a node is removed
+using splay_tree_remove. splay_tree_insert will release the previously
+inserted key and value using @var{delete_key_fn} and @var{delete_value_fn}
+if the inserted key is already found in the tree.
+
+@end deftypefn
+
+@c stack-limit.c:28
+@deftypefn Extension void stack_limit_increase (unsigned long @var{pref})
+
+Attempt to increase stack size limit to @var{pref} bytes if possible.
+
+@end deftypefn
+
@c stpcpy.c:23
@deftypefn Supplemental char* stpcpy (char *@var{dst}, const char *@var{src})
@end deftypefn
@c stpncpy.c:23
-@deftypefn Supplemental char* stpncpy (char *@var{dst}, const char *@var{src}, size_t @var{len})
+@deftypefn Supplemental char* stpncpy (char *@var{dst}, const char *@var{src}, @
+ size_t @var{len})
Copies the string @var{src} into @var{dst}, copying exactly @var{len}
and padding with zeros if necessary. If @var{len} < strlen(@var{src})
@end deftypefn
-@c strerror.c:670
+@c strerror.c:675
@deftypefn Replacement {const char*} strerrno (int @var{errnum})
Given an error number returned from a system call (typically returned
@end deftypefn
-@c strerror.c:603
+@c strerror.c:608
@deftypefn Supplemental char* strerror (int @var{errnoval})
Maps an @code{errno} number to an error message string, the contents
@end deftypefn
@c strncmp.c:6
-@deftypefn Supplemental int strncmp (const char *@var{s1}, const char *@var{s2}, size_t @var{n})
+@deftypefn Supplemental int strncmp (const char *@var{s1}, @
+ const char *@var{s2}, size_t @var{n})
Compares the first @var{n} bytes of two strings, returning a value as
@code{strcmp}.
@end deftypefn
+@c strnlen.c:6
+@deftypefn Supplemental size_t strnlen (const char *@var{s}, size_t @var{maxlen})
+
+Returns the length of @var{s}, as with @code{strlen}, but never looks
+past the first @var{maxlen} characters in the string. If there is no
+'\0' character in the first @var{maxlen} characters, returns
+@var{maxlen}.
+
+@end deftypefn
+
@c strrchr.c:6
@deftypefn Supplemental char* strrchr (const char *@var{s}, int @var{c})
@end deftypefn
-@c strsignal.c:446
+@c strsignal.c:448
@deftypefn Extension {const char*} strsigno (int @var{signo})
Given an signal number, returns a pointer to a string containing the
@end deftypefn
@c strtod.c:27
-@deftypefn Supplemental double strtod (const char *@var{string}, char **@var{endptr})
+@deftypefn Supplemental double strtod (const char *@var{string}, @
+ char **@var{endptr})
This ISO C function converts the initial portion of @var{string} to a
@code{double}. If @var{endptr} is not @code{NULL}, a pointer to the
@end deftypefn
-@c strerror.c:729
+@c strerror.c:734
@deftypefn Extension int strtoerrno (const char *@var{name})
Given the symbolic name of a error number (e.g., @code{EACCES}), map it
@end deftypefn
@c strtol.c:33
-@deftypefn Supplemental {long int} strtol (const char *@var{string}, char **@var{endptr}, int @var{base})
-@deftypefnx Supplemental {unsigned long int} strtoul (const char *@var{string}, char **@var{endptr}, int @var{base})
+@deftypefn Supplemental {long int} strtol (const char *@var{string}, @
+ char **@var{endptr}, int @var{base})
+@deftypefnx Supplemental {unsigned long int} strtoul (const char *@var{string}, @
+ char **@var{endptr}, int @var{base})
The @code{strtol} function converts the string in @var{string} to a
long integer value according to the given @var{base}, which must be
@end deftypefn
-@c strsignal.c:500
+@c strtoll.c:33
+@deftypefn Supplemental {long long int} strtoll (const char *@var{string}, @
+ char **@var{endptr}, int @var{base})
+@deftypefnx Supplemental {unsigned long long int} strtoul (@
+ const char *@var{string}, char **@var{endptr}, int @var{base})
+
+The @code{strtoll} function converts the string in @var{string} to a
+long long integer value according to the given @var{base}, which must be
+between 2 and 36 inclusive, or be the special value 0. If @var{base}
+is 0, @code{strtoll} will look for the prefixes @code{0} and @code{0x}
+to indicate bases 8 and 16, respectively, else default to base 10.
+When the base is 16 (either explicitly or implicitly), a prefix of
+@code{0x} is allowed. The handling of @var{endptr} is as that of
+@code{strtod} above. The @code{strtoull} function is the same, except
+that the converted value is unsigned.
+
+@end deftypefn
+
+@c strsignal.c:502
@deftypefn Extension int strtosigno (const char *@var{name})
Given the symbolic name of a signal, map it to a signal number. If no
@end deftypefn
+@c strverscmp.c:25
+@deftypefun int strverscmp (const char *@var{s1}, const char *@var{s2})
+The @code{strverscmp} function compares the string @var{s1} against
+@var{s2}, considering them as holding indices/version numbers. Return
+value follows the same conventions as found in the @code{strverscmp}
+function. In fact, if @var{s1} and @var{s2} contain no digits,
+@code{strverscmp} behaves like @code{strcmp}.
+
+Basically, we compare strings normally (character by character), until
+we find a digit in each string - then we enter a special comparison
+mode, where each sequence of digits is taken as a whole. If we reach the
+end of these two parts without noticing a difference, we return to the
+standard comparison mode. There are two types of numeric parts:
+"integral" and "fractional" (those begin with a '0'). The types
+of the numeric parts affect the way we sort them:
+
+@itemize @bullet
+@item
+integral/integral: we compare values as you would expect.
+
+@item
+fractional/integral: the fractional part is less than the integral one.
+Again, no surprise.
+
+@item
+fractional/fractional: the things become a bit more complex.
+If the common prefix contains only leading zeroes, the longest part is less
+than the other one; else the comparison behaves normally.
+@end itemize
+
+@smallexample
+strverscmp ("no digit", "no digit")
+ @result{} 0 // @r{same behavior as strcmp.}
+strverscmp ("item#99", "item#100")
+ @result{} <0 // @r{same prefix, but 99 < 100.}
+strverscmp ("alpha1", "alpha001")
+ @result{} >0 // @r{fractional part inferior to integral one.}
+strverscmp ("part1_f012", "part1_f01")
+ @result{} >0 // @r{two fractional parts.}
+strverscmp ("foo.009", "foo.0")
+ @result{} <0 // @r{idem, but with leading zeroes only.}
+@end smallexample
+
+This function is especially useful when dealing with filename sorting,
+because filenames frequently hold indices/version numbers.
+@end deftypefun
+
+@c timeval-utils.c:43
+@deftypefn Extension void timeval_add (struct timeval *@var{a}, @
+ struct timeval *@var{b}, struct timeval *@var{result})
+
+Adds @var{a} to @var{b} and stores the result in @var{result}.
+
+@end deftypefn
+
+@c timeval-utils.c:67
+@deftypefn Extension void timeval_sub (struct timeval *@var{a}, @
+ struct timeval *@var{b}, struct timeval *@var{result})
+
+Subtracts @var{b} from @var{a} and stores the result in @var{result}.
+
+@end deftypefn
+
@c tmpnam.c:3
@deftypefn Supplemental char* tmpnam (char *@var{s})
@end deftypefn
+@c fopen_unlocked.c:31
+@deftypefn Extension void unlock_std_streams (void)
+
+If the OS supports it, ensure that the standard I/O streams,
+@code{stdin}, @code{stdout} and @code{stderr} are setup to avoid any
+multi-threaded locking. Otherwise do nothing.
+
+@end deftypefn
+
+@c fopen_unlocked.c:23
+@deftypefn Extension void unlock_stream (FILE * @var{stream})
+
+If the OS supports it, ensure that the supplied stream is setup to
+avoid any multi-threaded locking. Otherwise leave the @code{FILE}
+pointer unchanged. If the @var{stream} is @code{NULL} do nothing.
+
+@end deftypefn
+
@c vasprintf.c:47
-@deftypefn Extension int vasprintf (char **@var{resptr}, const char *@var{format}, va_list @var{args})
+@deftypefn Extension int vasprintf (char **@var{resptr}, @
+ const char *@var{format}, va_list @var{args})
Like @code{vsprintf}, but instead of passing a pointer to a buffer,
you pass a pointer to a pointer. This function will compute the size
@c vprintf.c:3
@deftypefn Supplemental int vprintf (const char *@var{format}, va_list @var{ap})
-@deftypefnx Supplemental int vfprintf (FILE *@var{stream}, const char *@var{format}, va_list @var{ap})
-@deftypefnx Supplemental int vsprintf (char *@var{str}, const char *@var{format}, va_list @var{ap})
+@deftypefnx Supplemental int vfprintf (FILE *@var{stream}, @
+ const char *@var{format}, va_list @var{ap})
+@deftypefnx Supplemental int vsprintf (char *@var{str}, @
+ const char *@var{format}, va_list @var{ap})
These functions are the same as @code{printf}, @code{fprintf}, and
@code{sprintf}, respectively, except that they are called with a
@end deftypefn
@c vsnprintf.c:28
-@deftypefn Supplemental int vsnprintf (char *@var{buf}, size_t @var{n}, const char *@var{format}, va_list @var{ap})
+@deftypefn Supplemental int vsnprintf (char *@var{buf}, size_t @var{n}, @
+ const char *@var{format}, va_list @var{ap})
-This function is similar to vsprintf, but it will print at most
-@var{n} characters. On error the return value is -1, otherwise it
-returns the number of characters that would have been printed had
-@var{n} been sufficiently large, regardless of the actual value of
-@var{n}. Note some pre-C99 system libraries do not implement this
-correctly so users cannot generally rely on the return value if the
-system version of this function is used.
+This function is similar to @code{vsprintf}, but it will write to
+@var{buf} at most @code{@var{n}-1} bytes of text, followed by a
+terminating null byte, for a total of @var{n} bytes. On error the
+return value is -1, otherwise it returns the number of characters that
+would have been printed had @var{n} been sufficiently large,
+regardless of the actual value of @var{n}. Note some pre-C99 system
+libraries do not implement this correctly so users cannot generally
+rely on the return value if the system version of this function is
+used.
@end deftypefn
@end deftypefn
+@c argv.c:289
+@deftypefn Extension int writeargv (char * const *@var{argv}, FILE *@var{file})
+
+Write each member of ARGV, handling all necessary quoting, to the file
+named by FILE, separated by whitespace. Return 0 on success, non-zero
+if an error occurred while writing to FILE.
+
+@end deftypefn
+
+@c xasprintf.c:31
+@deftypefn Replacement char* xasprintf (const char *@var{format}, ...)
+
+Print to allocated string without fail. If @code{xasprintf} fails,
+this will print a message to @code{stderr} (using the name set by
+@code{xmalloc_set_program_name}, if any) and then call @code{xexit}.
+
+@end deftypefn
+
@c xatexit.c:11
@deftypefun int xatexit (void (*@var{fn}) (void))
@end deftypefn
@c xmemdup.c:7
-@deftypefn Replacement void* xmemdup (void *@var{input}, size_t @var{copy_size}, size_t @var{alloc_size})
+@deftypefn Replacement void* xmemdup (void *@var{input}, @
+ size_t @var{copy_size}, size_t @var{alloc_size})
Duplicates a region of memory without fail. First, @var{alloc_size} bytes
are allocated, then @var{copy_size} bytes from @var{input} are copied into
@end deftypefn
+@c xvasprintf.c:38
+@deftypefn Replacement char* xvasprintf (const char *@var{format}, va_list @var{args})
+
+Print to allocated string without fail. If @code{xvasprintf} fails,
+this will print a message to @code{stderr} (using the name set by
+@code{xmalloc_set_program_name}, if any) and then call @code{xexit}.
+
+@end deftypefn
+