+++ /dev/null
-.TH PTHREAD_COND 3 LinuxThreads
-
-.XREF pthread_cond_signal
-.XREF pthread_cond_broadcast
-.XREF pthread_cond_wait
-.XREF pthread_cond_timedwait
-.XREF pthread_cond_destroy
-
-.SH NAME
-pthread_cond_init, pthread_cond_destroy, pthread_cond_signal, pthread_cond_broadcast, pthread_cond_wait, pthread_cond_timedwait \- operations on conditions
-
-.SH SYNOPSIS
-#include <pthread.h>
-
-pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
-
-int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr);
-
-int pthread_cond_signal(pthread_cond_t *cond);
-
-int pthread_cond_broadcast(pthread_cond_t *cond);
-
-int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
-
-int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime);
-
-int pthread_cond_destroy(pthread_cond_t *cond);
-
-.SH DESCRIPTION
-
-A condition (short for ``condition variable'') is a synchronization
-device that allows threads to suspend execution and relinquish the
-processors until some predicate on shared data is satisfied. The basic
-operations on conditions are: signal the condition (when the
-predicate becomes true), and wait for the condition, suspending the
-thread execution until another thread signals the condition.
-
-A condition variable must always be associated with a mutex, to avoid
-the race condition where a thread prepares to wait on a condition
-variable and another thread signals the condition just before the
-first thread actually waits on it.
-
-!pthread_cond_init! initializes the condition variable |cond|, using the
-condition attributes specified in |cond_attr|, or default attributes
-if |cond_attr| is !NULL!. The LinuxThreads implementation supports no
-attributes for conditions, hence the |cond_attr| parameter is actually
-ignored.
-
-Variables of type !pthread_cond_t! can also be initialized
-statically, using the constant !PTHREAD_COND_INITIALIZER!.
-
-!pthread_cond_signal! restarts one of the threads that are waiting on
-the condition variable |cond|. If no threads are waiting on |cond|,
-nothing happens. If several threads are waiting on |cond|, exactly one
-is restarted, but it is not specified which.
-
-!pthread_cond_broadcast! restarts all the threads that are waiting on
-the condition variable |cond|. Nothing happens if no threads are
-waiting on |cond|.
-
-!pthread_cond_wait! atomically unlocks the |mutex| (as per
-!pthread_unlock_mutex!) and waits for the condition variable |cond| to
-be signaled. The thread execution is suspended and does not consume
-any CPU time until the condition variable is signaled. The |mutex|
-must be locked by the calling thread on entrance to
-!pthread_cond_wait!. Before returning to the calling thread,
-!pthread_cond_wait! re-acquires |mutex| (as per !pthread_lock_mutex!).
-
-Unlocking the mutex and suspending on the condition variable is done
-atomically. Thus, if all threads always acquire the mutex before
-signaling the condition, this guarantees that the condition cannot be
-signaled (and thus ignored) between the time a thread locks the mutex
-and the time it waits on the condition variable.
-
-!pthread_cond_timedwait! atomically unlocks |mutex| and waits on
-|cond|, as !pthread_cond_wait! does, but it also bounds the duration
-of the wait. If |cond| has not been signaled within the amount of time
-specified by |abstime|, the mutex |mutex| is re-acquired and
-!pthread_cond_timedwait! returns the error !ETIMEDOUT!.
-The |abstime| parameter specifies an absolute time, with the same
-origin as !time!(2) and !gettimeofday!(2): an |abstime| of 0
-corresponds to 00:00:00 GMT, January 1, 1970.
-
-!pthread_cond_destroy! destroys a condition variable, freeing the
-resources it might hold. No threads must be waiting on the condition
-variable on entrance to !pthread_cond_destroy!. In the LinuxThreads
-implementation, no resources are associated with condition variables,
-thus !pthread_cond_destroy! actually does nothing except checking that
-the condition has no waiting threads.
-
-.SH CANCELLATION
-
-!pthread_cond_wait! and !pthread_cond_timedwait! are cancellation
-points. If a thread is cancelled while suspended in one of these
-functions, the thread immediately resumes execution, then locks again
-the |mutex| argument to !pthread_cond_wait! and
-!pthread_cond_timedwait!, and finally executes the cancellation.
-Consequently, cleanup handlers are assured that |mutex| is locked when
-they are called.
-
-.SH "ASYNC-SIGNAL SAFETY"
-
-The condition functions are not async-signal safe, and should not be
-called from a signal handler. In particular, calling
-!pthread_cond_signal! or !pthread_cond_broadcast! from a signal
-handler may deadlock the calling thread.
-
-.SH "RETURN VALUE"
-
-All condition variable functions return 0 on success and a non-zero
-error code on error.
-
-.SH ERRORS
-
-!pthread_cond_init!, !pthread_cond_signal!, !pthread_cond_broadcast!,
-and !pthread_cond_wait! never return an error code.
-
-The !pthread_cond_timedwait! function returns the following error codes
-on error:
-.RS
-.TP
-!ETIMEDOUT!
-the condition variable was not signaled until the timeout specified by
-|abstime|
-
-.TP
-!EINTR!
-!pthread_cond_timedwait! was interrupted by a signal
-.RE
-
-The !pthread_cond_destroy! function returns the following error code
-on error:
-.RS
-.TP
-!EBUSY!
-some threads are currently waiting on |cond|.
-.RE
-
-.SH AUTHOR
-Xavier Leroy <Xavier.Leroy@inria.fr>
-
-.SH "SEE ALSO"
-!pthread_condattr_init!(3),
-!pthread_mutex_lock!(3),
-!pthread_mutex_unlock!(3),
-!gettimeofday!(2),
-!nanosleep!(2).
-
-.SH EXAMPLE
-
-Consider two shared variables |x| and |y|, protected by the mutex |mut|,
-and a condition variable |cond| that is to be signaled whenever |x|
-becomes greater than |y|.
-
-.RS
-.ft 3
-.nf
-.sp
-int x,y;
-pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
-pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
-.ft
-.LP
-.RE
-.fi
-
-Waiting until |x| is greater than |y| is performed as follows:
-
-.RS
-.ft 3
-.nf
-.sp
-pthread_mutex_lock(&mut);
-while (x <= y) {
- pthread_cond_wait(&cond, &mut);
-}
-/* operate on x and y */
-pthread_mutex_unlock(&mut);
-.ft
-.LP
-.RE
-.fi
-
-Modifications on |x| and |y| that may cause |x| to become greater than
-|y| should signal the condition if needed:
-
-.RS
-.ft 3
-.nf
-.sp
-pthread_mutex_lock(&mut);
-/* modify x and y */
-if (x > y) pthread_cond_broadcast(&cond);
-pthread_mutex_unlock(&mut);
-.ft
-.LP
-.RE
-.fi
-
-If it can be proved that at most one waiting thread needs to be waken
-up (for instance, if there are only two threads communicating through
-|x| and |y|), !pthread_cond_signal! can be used as a slightly more
-efficient alternative to !pthread_cond_broadcast!. In doubt, use
-!pthread_cond_broadcast!.
-
-To wait for |x| to becomes greater than |y| with a timeout of 5
-seconds, do:
-
-.RS
-.ft 3
-.nf
-.sp
-struct timeval now;
-struct timespec timeout;
-int retcode;
-
-pthread_mutex_lock(&mut);
-gettimeofday(&now);
-timeout.tv_sec = now.tv_sec + 5;
-timeout.tv_nsec = now.tv_usec * 1000;
-retcode = 0;
-while (x <= y && retcode != ETIMEDOUT) {
- retcode = pthread_cond_timedwait(&cond, &mut, &timeout);
-}
-if (retcode == ETIMEDOUT) {
- /* timeout occurred */
-} else {
- /* operate on x and y */
-}
-pthread_mutex_unlock(&mut);
-.ft
-.LP
-.RE
-.fi
+++ /dev/null
-.TH PTHREAD_CONDATTR 3 LinuxThreads
-
-.XREF pthread_condattr_destroy
-
-.SH NAME
-pthread_condattr_init, pthread_condattr_destroy \- condition creation attributes
-
-.SH SYNOPSIS
-#include <pthread.h>
-
-int pthread_condattr_init(pthread_condattr_t *attr);
-
-int pthread_condattr_destroy(pthread_condattr_t *attr);
-
-.SH DESCRIPTION
-
-Condition attributes can be specified at condition creation time, by passing a
-condition attribute object as second argument to !pthread_cond_init!(3).
-Passing !NULL! is equivalent to passing a condition attribute object with
-all attributes set to their default values.
-
-The LinuxThreads implementation supports no attributes for
-conditions. The functions on condition attributes are included only
-for compliance with the POSIX standard.
-
-!pthread_condattr_init! initializes the condition attribute object
-|attr| and fills it with default values for the attributes.
-!pthread_condattr_destroy! destroys a condition attribute object,
-which must not be reused until it is reinitialized. Both functions do
-nothing in the LinuxThreads implementation.
-
-.SH "RETURN VALUE"
-!pthread_condattr_init! and !pthread_condattr_destroy! always return 0.
-
-.SH AUTHOR
-Xavier Leroy <Xavier.Leroy@inria.fr>
-
-.SH "SEE ALSO"
-!pthread_cond_init!(3).
+++ /dev/null
-.TH PTHREAD_SPECIFIC 3 LinuxThreads
-
-.SH NAME
-pthread_key_create, pthread_key_delete, pthread_setspecific, pthread_getspecific \- management of thread-specific data
-
-.SH SYNOPSIS
-#include <pthread.h>
-
-int pthread_key_create(pthread_key_t *key, void (*destr_function) (void *));
-
-int pthread_key_delete(pthread_key_t key);
-
-int pthread_setspecific(pthread_key_t key, const void *pointer);
-
-void * pthread_getspecific(pthread_key_t key);
-
-.SH DESCRIPTION
-
-Programs often need global or static variables that have different
-values in different threads. Since threads share one memory space,
-this cannot be achieved with regular variables. Thread-specific data
-is the POSIX threads answer to this need.
-
-Each thread possesses a private memory block, the thread-specific data
-area, or TSD area for short. This area is indexed by TSD keys. The TSD
-area associates values of type !void *! to TSD keys. TSD keys are
-common to all threads, but the value associated with a given TSD key
-can be different in each thread.
-
-For concreteness, the TSD areas can be viewed as arrays of !void *!
-pointers, TSD keys as integer indices into these arrays, and the value
-of a TSD key as the value of the corresponding array element in the
-calling thread.
-
-When a thread is created, its TSD area initially associates !NULL!
-with all keys.
-
-!pthread_key_create! allocates a new TSD key. The key is stored in the
-location pointed to by |key|. There is a limit of !PTHREAD_KEYS_MAX!
-on the number of keys allocated at a given time. The value initially
-associated with the returned key is !NULL! in all currently executing
-threads.
-
-The |destr_function| argument, if not !NULL!, specifies a destructor
-function associated with the key. When a thread terminates via
-!pthread_exit! or by cancellation, |destr_function| is called with
-arguments the value associated with the key in that thread. The
-|destr_function| is not called if that value is !NULL!. The order in
-which destructor functions are called at thread termination time is
-unspecified.
-
-Before the destructor function is called, the !NULL! value is
-associated with the key in the current thread. A destructor function
-might, however, re-associate non-!NULL! values to that key or some
-other key. To deal with this, if after all the destructors have been
-called for all non-!NULL! values, there are still some non-!NULL!
-values with associated destructors, then the process is repeated. The
-LinuxThreads implementation stops the process after
-!PTHREAD_DESTRUCTOR_ITERATIONS! iterations, even if some non-!NULL!
-values with associated descriptors remain. Other implementations may
-loop indefinitely.
-
-!pthread_key_delete! deallocates a TSD key. It does not check whether
-non-!NULL! values are associated with that key in the currently
-executing threads, nor call the destructor function associated with
-the key.
-
-!pthread_setspecific! changes the value associated with |key| in the
-calling thread, storing the given |pointer| instead.
-
-!pthread_getspecific! returns the value currently associated with
-|key| in the calling thread.
-
-.SH "RETURN VALUE"
-
-!pthread_key_create!, !pthread_key_delete!, and !pthread_setspecific!
-return 0 on success and a non-zero error code on failure. If
-successful, !pthread_key_create! stores the newly allocated key in the
-location pointed to by its |key| argument.
-
-!pthread_getspecific! returns the value associated with |key| on
-success, and !NULL! on error.
-
-.SH ERRORS
-!pthread_key_create! returns the following error code on error:
-.RS
-.TP
-!EAGAIN!
-!PTHREAD_KEYS_MAX! keys are already allocated
-.RE
-
-!pthread_key_delete! and !pthread_setspecific! return the following
-error code on error:
-.RS
-.TP
-!EINVAL!
-|key| is not a valid, allocated TSD key
-.RE
-
-!pthread_getspecific! returns !NULL! if |key| is not a valid,
-allocated TSD key.
-
-.SH AUTHOR
-Xavier Leroy <Xavier.Leroy@inria.fr>
-
-.SH "SEE ALSO"
-pthread_create(3), pthread_exit(3), pthread_testcancel(3).
-
-.SH EXAMPLE
-
-The following code fragment allocates a thread-specific array of 100
-characters, with automatic reclaimation at thread exit:
-
-.RS
-.ft 3
-.nf
-.sp
-/* Key for the thread-specific buffer */
-static pthread_key_t buffer_key;
-
-/* Once-only initialisation of the key */
-static pthread_once_t buffer_key_once = PTHREAD_ONCE_INIT;
-
-/* Allocate the thread-specific buffer */
-void buffer_alloc(void)
-{
- pthread_once(&buffer_key_once, buffer_key_alloc);
- pthread_setspecific(buffer_key, malloc(100));
-}
-
-/* Return the thread-specific buffer */
-char * get_buffer(void)
-{
- return (char *) pthread_getspecific(buffer_key);
-}
-
-/* Allocate the key */
-static void buffer_key_alloc()
-{
- pthread_key_create(&buffer_key, buffer_destroy);
-}
-
-/* Free the thread-specific buffer */
-static void buffer_destroy(void * buf)
-{
- free(buf);
-}
-.ft
-.LP
-.RE
-.fi
+++ /dev/null
-.TH PTHREAD_MUTEX 3 LinuxThreads
-
-.XREF pthread_mutex_lock
-.XREF pthread_mutex_unlock
-.XREF pthread_mutex_trylock
-.XREF pthread_mutex_destroy
-
-.SH NAME
-pthread_mutex_init, pthread_mutex_lock, pthread_mutex_trylock, pthread_mutex_unlock, pthread_mutex_destroy \- operations on mutexes
-
-.SH SYNOPSIS
-#include <pthread.h>
-
-pthread_mutex_t fastmutex = PTHREAD_MUTEX_INITIALIZER;
-
-pthread_mutex_t recmutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
-
-pthread_mutex_t errchkmutex = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;
-
-int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr);
-
-int pthread_mutex_lock(pthread_mutex_t *mutex);
-
-int pthread_mutex_trylock(pthread_mutex_t *mutex);
-
-int pthread_mutex_unlock(pthread_mutex_t *mutex);
-
-int pthread_mutex_destroy(pthread_mutex_t *mutex);
-
-.SH DESCRIPTION
-A mutex is a MUTual EXclusion device, and is useful for protecting
-shared data structures from concurrent modifications, and implementing
-critical sections and monitors.
-
-A mutex has two possible states: unlocked (not owned by any thread),
-and locked (owned by one thread). A mutex can never be owned by two
-different threads simultaneously. A thread attempting to lock a mutex
-that is already locked by another thread is suspended until the owning
-thread unlocks the mutex first.
-
-!pthread_mutex_init! initializes the mutex object pointed to by
-|mutex| according to the mutex attributes specified in |mutexattr|.
-If |mutexattr| is !NULL!, default attributes are used instead.
-
-The LinuxThreads implementation supports only one mutex attributes,
-the |mutex kind|, which is either ``fast'', ``recursive'', or
-``error checking''. The kind of a mutex determines whether
-it can be locked again by a thread that already owns it.
-The default kind is ``fast''. See !pthread_mutexattr_init!(3) for more
-information on mutex attributes.
-
-Variables of type !pthread_mutex_t! can also be initialized
-statically, using the constants !PTHREAD_MUTEX_INITIALIZER! (for fast
-mutexes), !PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP! (for recursive
-mutexes), and !PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP! (for error checking
-mutexes).
-
-!pthread_mutex_lock! locks the given mutex. If the mutex is currently
-unlocked, it becomes locked and owned by the calling thread, and
-!pthread_mutex_lock! returns immediately. If the mutex is already
-locked by another thread, !pthread_mutex_lock! suspends the calling
-thread until the mutex is unlocked.
-
-If the mutex is already locked by the calling thread, the behavior of
-!pthread_mutex_lock! depends on the kind of the mutex. If the mutex is
-of the ``fast'' kind, the calling thread is suspended until the mutex
-is unlocked, thus effectively causing the calling thread to
-deadlock. If the mutex is of the ``error checking'' kind,
-!pthread_mutex_lock! returns immediately with the error code !EDEADLK!.
-If the mutex is of the ``recursive'' kind, !pthread_mutex_lock!
-succeeds and returns immediately, recording the number of times the
-calling thread has locked the mutex. An equal number of
-!pthread_mutex_unlock! operations must be performed before the mutex
-returns to the unlocked state.
-
-!pthread_mutex_trylock! behaves identically to !pthread_mutex_lock!,
-except that it does not block the calling thread if the mutex is
-already locked by another thread (or by the calling thread in the case
-of a ``fast'' mutex). Instead, !pthread_mutex_trylock! returns
-immediately with the error code !EBUSY!.
-
-!pthread_mutex_unlock! unlocks the given mutex. The mutex is assumed
-to be locked and owned by the calling thread on entrance to
-!pthread_mutex_unlock!. If the mutex is of the ``fast'' kind,
-!pthread_mutex_unlock! always returns it to the unlocked state. If it
-is of the ``recursive'' kind, it decrements the locking count of the
-mutex (number of !pthread_mutex_lock! operations performed on it by
-the calling thread), and only when this count reaches zero is the
-mutex actually unlocked.
-
-On ``error checking'' mutexes, !pthread_mutex_unlock! actually checks
-at run-time that the mutex is locked on entrance, and that it was
-locked by the same thread that is now calling !pthread_mutex_unlock!.
-If these conditions are not met, an error code is returned and the
-mutex remains unchanged. ``Fast'' and ``recursive'' mutexes perform
-no such checks, thus allowing a locked mutex to be unlocked by a
-thread other than its owner. This is non-portable behavior and must
-not be relied upon.
-
-!pthread_mutex_destroy! destroys a mutex object, freeing the resources
-it might hold. The mutex must be unlocked on entrance. In the
-LinuxThreads implementation, no resources are associated with mutex
-objects, thus !pthread_mutex_destroy! actually does nothing except
-checking that the mutex is unlocked.
-
-.SH CANCELLATION
-
-None of the mutex functions is a cancellation point, not even
-!pthread_mutex_lock!, in spite of the fact that it can suspend a
-thread for arbitrary durations. This way, the status of mutexes at
-cancellation points is predictable, allowing cancellation handlers to
-unlock precisely those mutexes that need to be unlocked before the
-thread stops executing. Consequently, threads using deferred
-cancellation should never hold a mutex for extended periods of time.
-
-.SH "ASYNC-SIGNAL SAFETY"
-
-The mutex functions are not async-signal safe. What this means is that
-they should not be called from a signal handler. In particular,
-calling !pthread_mutex_lock! or !pthread_mutex_unlock! from a signal
-handler may deadlock the calling thread.
-
-.SH "RETURN VALUE"
-
-!pthread_mutex_init! always returns 0. The other mutex functions
-return 0 on success and a non-zero error code on error.
-
-.SH ERRORS
-
-The !pthread_mutex_lock! function returns the following error code
-on error:
-.RS
-.TP
-!EINVAL!
-the mutex has not been properly initialized.
-
-.TP
-!EDEADLK!
-the mutex is already locked by the calling thread
-(``error checking'' mutexes only).
-.RE
-
-The !pthread_mutex_trylock! function returns the following error codes
-on error:
-.RS
-.TP
-!EBUSY!
-the mutex could not be acquired because it was currently locked.
-
-.TP
-!EINVAL!
-the mutex has not been properly initialized.
-.RE
-
-The !pthread_mutex_unlock! function returns the following error code
-on error:
-.RS
-.TP
-!EINVAL!
-the mutex has not been properly initialized.
-
-.TP
-!EPERM!
-the calling thread does not own the mutex (``error checking'' mutexes only).
-.RE
-
-The !pthread_mutex_destroy! function returns the following error code
-on error:
-.RS
-.TP
-!EBUSY!
-the mutex is currently locked.
-.RE
-
-.SH AUTHOR
-Xavier Leroy <Xavier.Leroy@inria.fr>
-
-.SH "SEE ALSO"
-!pthread_mutexattr_init!(3),
-!pthread_mutexattr_setkind_np!(3),
-!pthread_cancel!(3).
-
-.SH EXAMPLE
-
-A shared global variable |x| can be protected by a mutex as follows:
-
-.RS
-.ft 3
-.nf
-.sp
-int x;
-pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
-.ft
-.LP
-.RE
-.fi
-
-All accesses and modifications to |x| should be bracketed by calls to
-!pthread_mutex_lock! and !pthread_mutex_unlock! as follows:
-
-.RS
-.ft 3
-.nf
-.sp
-pthread_mutex_lock(&mut);
-/* operate on x */
-pthread_mutex_unlock(&mut);
-.ft
-.LP
-.RE
-.fi
-
-
+++ /dev/null
-.TH PTHREAD_MUTEXATTR_SETKIND_NP 3 LinuxThreads
-
-.XREF pthread_mutexattr_getkind_np
-
-.SH NAME
-pthread_mutexattr_setkind_np, pthread_mutexattr_getkind_np \- deprecated mutex creation attributes
-
-.SH SYNOPSIS
-#include <pthread.h>
-
-int pthread_mutexattr_setkind_np(pthread_mutexattr_t *attr, int kind);
-
-int pthread_mutexattr_getkind_np(const pthread_mutexattr_t *attr, int *kind);
-
-.SH DESCRIPTION
-
-These functions are deprecated, use !pthread_mutexattr_settype!(3)
-and !pthread_mutexattr_gettype!(3) instead.
-
-.SH "RETURN VALUE"
-!pthread_mutexattr_getkind_np! always returns 0.
-
-!pthread_mutexattr_setkind_np! returns 0 on success and a non-zero
-error code on error.
-
-.SH ERRORS
-
-On error, !pthread_mutexattr_setkind_np! returns the following error code:
-.TP
-!EINVAL!
-|kind| is neither !PTHREAD_MUTEX_FAST_NP! nor !PTHREAD_MUTEX_RECURSIVE_NP!
-nor !PTHREAD_MUTEX_ERRORCHECK_NP!
-
-.SH AUTHOR
-Xavier Leroy <Xavier.Leroy@inria.fr>
-
-.SH "SEE ALSO"
-!pthread_mutexattr_settype!(3),
-!pthread_mutexattr_gettype!(3).
+++ /dev/null
-.TH PTHREAD_ONCE 3 LinuxThreads
-
-.SH NAME
-pthread_once \- once-only initialization
-
-.SH SYNOPSIS
-#include <pthread.h>
-
-pthread_once_t once_control = PTHREAD_ONCE_INIT;
-
-int pthread_once(pthread_once_t *once_control, void (*init_routine) (void));
-
-.SH DESCRIPTION
-
-The purpose of !pthread_once! is to ensure that a piece of
-initialization code is executed at most once. The |once_control|
-argument points to a static or extern variable statically initialized
-to !PTHREAD_ONCE_INIT!.
-
-The first time !pthread_once! is called with a given |once_control|
-argument, it calls |init_routine| with no argument and changes the
-value of the |once_control| variable to record that initialization has
-been performed. Subsequent calls to !pthread_once! with the same
-!once_control! argument do nothing.
-
-.SH "RETURN VALUE"
-!pthread_once! always returns 0.
-
-.SH ERRORS
-None.
-
-.SH AUTHOR
-Xavier Leroy <Xavier.Leroy@inria.fr>
-
projects / thirdparty / man-pages.git / commitdiff
