Thu Jun 29 15:04:42 2000 Joe Hoffert <joeh@cs.wustl.edu>

24 files changed, 1546 insertions, 37 deletions

diff --git a/PACE/pace/posix/aio.h b/PACE/pace/posix/aio.h
index 6e62892423d..6512cc3627f 100644
--- a/PACE/pace/posix/aio.h
+++ b/PACE/pace/posix/aio.h
@@ -23,24 +23,61 @@ extern "C" {
 #endif /* PACE_HAS_CPLUSPLUS */
 
   /** 
-     NEED TO ADD APPROPRIATE POSIX REFERENCE TEXT HERE.
-     */
+     PACE's implementation of the POSIX function aio_cancel.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), section 6.7.7.
+   */
   PACE_INLINE int pace_aio_cancel (int fildes, struct aiocb * aiocb);
 
+  /** 
+     PACE's implementation of the POSIX function aio_error.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), section 6.7.5.
+   */
   PACE_INLINE int pace_aio_error (const struct aiocb * aiocbp);
 
+  /** 
+     PACE's implementation of the POSIX function aio_fsync.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), section 6.7.9.
+   */
   PACE_INLINE int pace_aio_fsync (int op, struct aiocb * aiocbp);
 
+  /** 
+     PACE's implementation of the POSIX function aio_read.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), section 6.7.2.
+   */
   PACE_INLINE int pace_aio_read (struct aiocb * aiocbp);
 
+  /** 
+     PACE's implementation of the POSIX function aio_return.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), section 6.7.6.
+   */
   PACE_INLINE int pace_aio_return (struct aiocb * aiocbp);
 
+  /** 
+     PACE's implementation of the POSIX function aio_suspend.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), section 6.7.8.
+   */
   PACE_INLINE int pace_aio_suspend (const struct aiocb * const list[],
                                     int nent,
                                     const struct timespec * timeout);
 
+  /** 
+     PACE's implementation of the POSIX function aio_write.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), section 6.7.3.
+   */
   PACE_INLINE int pace_aio_write (struct aiocb * aiocbp);
 
+  /** 
+     PACE's implementation of the POSIX function lio_listio.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), section 6.7.4.
+   */
   PACE_INLINE int pace_lio_listio (int mode,
                                    struct aiocb * const list[],
                                    int nent,
diff --git a/PACE/pace/posix/assert.h b/PACE/pace/posix/assert.h
index 02b6c3fd233..a869c8c15a6 100644
--- a/PACE/pace/posix/assert.h
+++ b/PACE/pace/posix/assert.h
@@ -20,6 +20,11 @@
 extern "C" {
 #endif /* PACE_HAS_CPLUSPLUS */
 
+  /** 
+     PACE's implementation of the POSIX macro assert.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1..
+   */
   PACE_INLINE void pace_assert (int expression);
 
 # if defined (PACE_HAS_CPLUSPLUS)
diff --git a/PACE/pace/posix/ctype.h b/PACE/pace/posix/ctype.h
index 39bc255428d..3618c5c71f2 100644
--- a/PACE/pace/posix/ctype.h
+++ b/PACE/pace/posix/ctype.h
@@ -20,30 +20,95 @@
 extern "C" {
 #endif /* PACE_HAS_CPLUSPLUS */
 
+  /** 
+     PACE's implementation of the POSIX function isalnum.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE int pace_isalnum (int c);
 
+  /** 
+     PACE's implementation of the POSIX function isalpha.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE int pace_isalpha (int c);
 
+  /** 
+     PACE's implementation of the POSIX function iscntrl.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE int pace_iscntrl (int c);
 
+  /** 
+     PACE's implementation of the POSIX function isdigit.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE int pace_isdigit (int c);
 
+  /** 
+     PACE's implementation of the POSIX function isgraph.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE int pace_isgraph (int c);
 
+  /** 
+     PACE's implementation of the POSIX function islower.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE int pace_islower (int c);
 
+  /** 
+     PACE's implementation of the POSIX function isprint.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE int pace_isprint (int c);
 
+  /** 
+     PACE's implementation of the POSIX function ispunct.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE int pace_ispunct (int c);
 
+  /** 
+     PACE's implementation of the POSIX function isspace.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE int pace_isspace (int c);
 
+  /** 
+     PACE's implementation of the POSIX function isupper.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE int pace_isupper (int c);
 
+  /** 
+     PACE's implementation of the POSIX function isxdigit.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE int pace_isxdigit (int c);
 
+  /** 
+     PACE's implementation of the POSIX function tolower.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE int pace_tolower (int c);
 
+  /** 
+     PACE's implementation of the POSIX function toupper.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE int pace_toupper (int c);
 
 #if defined (PACE_HAS_CPLUSPLUS)
diff --git a/PACE/pace/posix/dirent.h b/PACE/pace/posix/dirent.h
index afa9f8cac4e..11beb6f51e0 100644
--- a/PACE/pace/posix/dirent.h
+++ b/PACE/pace/posix/dirent.h
@@ -23,16 +23,41 @@
 extern "C" {
 #endif /* PACE_HAS_CPLUSPLUS */
 
+  /** 
+     PACE's implementation of the POSIX function opendir.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 5.1.2.
+   */
   PACE_INLINE DIR * pace_opendir (const char * dirname);
 
+  /** 
+     PACE's implementation of the POSIX function readdir.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 5.1.2.
+   */
   PACE_INLINE struct dirent * pace_readdir (DIR * dirp);
 
+  /** 
+     PACE's implementation of the POSIX function readdir_r.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 5.1.2.
+   */
   PACE_INLINE int pace_readdir_r (DIR * dirp, struct dirent * entry,
                                   struct dirent ** result);
   /* Requires PACE_HAS_POSIX_PTHREAD_SEMANTICS. */
 
+  /** 
+     PACE's implementation of the POSIX function rewinddir.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 5.1.2.
+   */
   PACE_INLINE void pace_rewinddir (DIR * dirp);
 
+  /** 
+     PACE's implementation of the POSIX function closedir.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 5.1.2.
+   */
   PACE_INLINE int pace_closedir (DIR * dirp);
 
 #if defined (PACE_HAS_CPLUSPLUS)
diff --git a/PACE/pace/posix/fcntl.h b/PACE/pace/posix/fcntl.h
index 755502bbf27..f26e43beae5 100644
--- a/PACE/pace/posix/fcntl.h
+++ b/PACE/pace/posix/fcntl.h
@@ -25,8 +25,18 @@
 extern "C" {
 #endif /* PACE_HAS_CPLUSPLUS */
 
+  /** 
+     PACE's implementation of the POSIX function creat.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 5.3.2.
+   */
   PACE_INLINE int pace_creat (const char * path, pace_mode_t mode);
 
+  /** 
+     PACE's implementation of the POSIX function fcntl.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 6.5.2.
+   */
   # define pace_fcntl(X) fcntl X
   /* int fcntl (int fildes, int cmd, *//* arg *//* ... );
    *
@@ -35,6 +45,11 @@ extern "C" {
    * surrounding the arguments.
    */
 
+  /** 
+     PACE's implementation of the POSIX function open.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 5.3.1.
+   */
   # define pace_open(X) open X
   /* int open (const char *path, int oflag, *//* pace_mode_t mode *//* ... );
    *
diff --git a/PACE/pace/posix/grp.h b/PACE/pace/posix/grp.h
index 4ff45169ef1..b21614b7c8a 100644
--- a/PACE/pace/posix/grp.h
+++ b/PACE/pace/posix/grp.h
@@ -22,8 +22,18 @@
 extern "C" {
 # endif /* PACE_HAS_CPLUSPLUS */
 
+  /** 
+     PACE's implementation of the POSIX function getgrgid.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 9.2.1.
+   */
   PACE_INLINE struct group * pace_getgrgid (pace_gid_t gid);
 
+  /** 
+     PACE's implementation of the POSIX function getgrgid_r.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 9.2.1.
+   */
   PACE_INLINE int pace_getgrgid_r (pace_gid_t gid,
                                    struct group * grp,
                                    char * buffer,
@@ -31,8 +41,18 @@ extern "C" {
                                    struct group ** result);
   /* Requires PACE_HAS_POSIX_PTHREAD_SEMANTICS. */
 
+  /** 
+     PACE's implementation of the POSIX function getgrnam.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 9.2.1.
+   */
   PACE_INLINE struct group * pace_getgrnam (const char * name);
 
+  /** 
+     PACE's implementation of the POSIX function getgrnam_r.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 9.2.1.
+   */
   PACE_INLINE int pace_getgrnam_r (const char * name,
                                    struct group * grp,
                                    char * buffer,
diff --git a/PACE/pace/posix/locale.h b/PACE/pace/posix/locale.h
index d28b31381be..7af2569b8cb 100644
--- a/PACE/pace/posix/locale.h
+++ b/PACE/pace/posix/locale.h
@@ -20,6 +20,11 @@
 extern "C" {
 #endif /* PACE_HAS_CPLUSPLUS */
 
+  /** 
+     PACE's implementation of the POSIX function setlocale.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.2.
+   */
   PACE_INLINE char * pace_setlocale (int category, const char * locale);
 
 #if defined (PACE_HAS_CPLUSPLUS)
diff --git a/PACE/pace/posix/math.h b/PACE/pace/posix/math.h
index d477a0093bc..aeec5eee50f 100644
--- a/PACE/pace/posix/math.h
+++ b/PACE/pace/posix/math.h
@@ -20,48 +20,158 @@
 extern "C" {
 #endif /* PACE_HAS_CPLUSPLUS */
 
+  /** 
+     PACE's implementation of the POSIX function acos.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE double pace_acos (double x);
 
+  /** 
+     PACE's implementation of the POSIX function asin.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE double pace_asin (double x);
 
+  /** 
+     PACE's implementation of the POSIX function atan.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE double pace_atan (double x);
 
+  /** 
+     PACE's implementation of the POSIX function atan2.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE double pace_atan2 (double x, double y);
 
+  /** 
+     PACE's implementation of the POSIX function cos.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE double pace_cos (double x);
 
+  /** 
+     PACE's implementation of the POSIX function sin.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE double pace_sin (double x);
 
+  /** 
+     PACE's implementation of the POSIX function tan.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE double pace_tan (double x);
 
+  /** 
+     PACE's implementation of the POSIX function cosh.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE double pace_cosh (double x);
 
+  /** 
+     PACE's implementation of the POSIX function sinh.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE double pace_sinh (double x);
 
+  /** 
+     PACE's implementation of the POSIX function tanh.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE double pace_tanh (double x);
 
+  /** 
+     PACE's implementation of the POSIX function exp.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE double pace_exp (double x);
 
+  /** 
+     PACE's implementation of the POSIX function frexp.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE double pace_frexp (double x, int * exp);
 
+  /** 
+     PACE's implementation of the POSIX function ldexp.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE double pace_ldexp (double x, int exp);
 
+  /** 
+     PACE's implementation of the POSIX function log.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE double pace_log (double x);
 
+  /** 
+     PACE's implementation of the POSIX function log10.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE double pace_log10 (double x);
 
+  /** 
+     PACE's implementation of the POSIX function modf.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE double pace_modf (double x, double * iptr);
 
+  /** 
+     PACE's implementation of the POSIX function pow.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE double pace_pow (double x, double y);
 
+  /** 
+     PACE's implementation of the POSIX function sqrt.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE double pace_sqrt (double x);
 
+  /** 
+     PACE's implementation of the POSIX function ceil.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE double pace_ceil (double x);
 
+  /** 
+     PACE's implementation of the POSIX function fabs.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE double pace_fabs (double x);
 
+  /** 
+     PACE's implementation of the POSIX function floor.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE double pace_floor (double x);
 
+  /** 
+     PACE's implementation of the POSIX function fmod.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE double pace_fmod (double x, double y);
 
 #if defined (PACE_HAS_CPLUSPLUS)
diff --git a/PACE/pace/posix/mman.h b/PACE/pace/posix/mman.h
index 982b6c73f75..325cf0ee529 100644
--- a/PACE/pace/posix/mman.h
+++ b/PACE/pace/posix/mman.h
@@ -22,10 +22,25 @@
 extern "C" {
 #endif /* PACE_HAS_CPLUSPLUS */
 
+  /** 
+     PACE's implementation of the POSIX function mlock.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 12.1.2.
+   */
   PACE_INLINE int pace_mlock (const void * addr, size_t len);
 
+  /** 
+     PACE's implementation of the POSIX function mlockall.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 12.1.1.
+   */
   PACE_INLINE int pace_mlockall (int flags);
 
+  /** 
+     PACE's implementation of the POSIX function mmap.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 12.2.1.
+   */
   PACE_INLINE void * pace_mmap (void * addr,
                                 size_t len,
                                 int prot,
@@ -33,25 +48,60 @@ extern "C" {
                                 int fildes,
                                 off_t off);
 
+  /** 
+     PACE's implementation of the POSIX function mprotect.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 12.2.3.
+   */
   PACE_INLINE int pace_mprotect (void * addr,
                                  size_t len,
                                  int prot);
 
+  /** 
+     PACE's implementation of the POSIX function msync.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 12.2.4.
+   */
   PACE_INLINE int pace_msync (void * addr,
                               size_t len,
                               int flags);
 
+  /** 
+     PACE's implementation of the POSIX function munlock.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 12.1.2.
+   */
   PACE_INLINE int pace_munlock (const void * addr, size_t len);
 
+  /** 
+     PACE's implementation of the POSIX function munlockall.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 12.1.1.
+   */
   PACE_INLINE int pace_munlockall ();
 
+  /** 
+     PACE's implementation of the POSIX function munmap.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 12.2.2.
+   */
   PACE_INLINE int pace_munmap (void *addr, size_t len);
 
+  /** 
+     PACE's implementation of the POSIX function shm_open.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 12.3.1.
+   */
   PACE_INLINE int pace_shm_open (const char * name,
                                  int oflag,
                                  mode_t mode);
   /* Requires PACE_POSIX_C_SOURCE > 2. */
 
+  /** 
+     PACE's implementation of the POSIX function shm_open.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 12.3.2.
+   */
   PACE_INLINE int pace_shm_unlink (const char * name);
   /* Requires PACE_POSIX_C_SOURCE > 2. */
 
diff --git a/PACE/pace/posix/mqueue.h b/PACE/pace/posix/mqueue.h
index d6bf93be666..324ec98baf0 100644
--- a/PACE/pace/posix/mqueue.h
+++ b/PACE/pace/posix/mqueue.h
@@ -22,14 +22,34 @@
 extern "C" {
 #endif /* PACE_HAS_CPLUSPLUS */
 
+  /** 
+     PACE's implementation of the POSIX function mq_close.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 15.2.2.
+   */
   PACE_INLINE int pace_mq_close (mqd_t mqdes);
 
+  /** 
+     PACE's implementation of the POSIX function mq_getattr.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 15.2.8.
+   */
   PACE_INLINE int pace_mq_getattr (mqd_t mqdes,
                                    struct mq_attr * mqstat);
 
+  /** 
+     PACE's implementation of the POSIX function mq_notify.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 15.2.6.
+   */
   PACE_INLINE int pace_mq_notify (mqd_t mqdes,
                                   const struct sigevent * notification);
 
+  /** 
+     PACE's implementation of the POSIX function mq_open.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 15.2.1.
+   */
   # define pace_mq_open(X) mq_open X
   /* mqd_t mq_open (const char *name, int oflag, (*//* args *//*) ... );
    *
@@ -38,20 +58,40 @@ extern "C" {
    * surrounding the arguments.
    */
 
+  /** 
+     PACE's implementation of the POSIX function mq_receive.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 15.2.5.
+   */
   PACE_INLINE ssize_t pace_mq_receive (mqd_t mqdes,
                                        char * msg_ptr,
                                        size_t msg_len,
                                        unsigned int * nmsg_prio);
 
+  /** 
+     PACE's implementation of the POSIX function mq_send.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 15.2.4.
+   */
   PACE_INLINE int pace_mq_send (mqd_t mqdes,
                                 const char * mst_ptr,
                                 size_t msg_len,
                                 unsigned int psg_prio);
 
+  /** 
+     PACE's implementation of the POSIX function mq_setattr.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 15.2.7.
+   */
   PACE_INLINE int pace_mq_setattr (mqd_t mqdes,
                                    const struct mq_attr * mqstat,
                                    struct mq_attr * omqstat);
 
+  /** 
+     PACE's implementation of the POSIX function mq_unlink.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 15.2.3.
+   */
   PACE_INLINE int pace_mq_unlink (const char * name);
 
 #if defined (PACE_HAS_CPLUSPLUS)
diff --git a/PACE/pace/posix/pthread.h b/PACE/pace/posix/pthread.h
index 3920f482756..bf28cb5e38d 100644
--- a/PACE/pace/posix/pthread.h
+++ b/PACE/pace/posix/pthread.h
@@ -24,182 +24,499 @@
 extern "C" {
 #endif /* PACE_HAS_CPLUSPLUS */
 
+  /** 
+     PACE's implementation of the POSIX function pthread_atfork.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 3.1.3.
+   */
   PACE_INLINE int pace_pthread_atfork (void  (*prepare) (),
                                        void (*parent) (),
                                        void (*child) ());
 
+  /** 
+     PACE's implementation of the POSIX function pthread_attr_destroy.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 16.2.1.
+   */
   PACE_INLINE int pace_pthread_attr_destroy (pace_pthread_attr_t * attr);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_attr_getdetachstate.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 16.2.1.
+   */
   PACE_INLINE int pace_pthread_attr_getdetachstate (const pace_pthread_attr_t * attr,
                                                     int * detachstate);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_attr_getinheritsched.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 13.5.1.
+   */
   PACE_INLINE int pace_pthread_attr_getinheritsched (const pace_pthread_attr_t * attr,
                                                      int * inheritsched);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_attr_getschedparam.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 13.5.1.
+   */
   PACE_INLINE int pace_pthread_attr_getschedparam (const pace_pthread_attr_t * attr,
                                                    struct sched_param * param);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_attr_getschedpolicy.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 13.5.1.
+   */
   PACE_INLINE int pace_pthread_attr_getschedpolicy (const pace_pthread_attr_t * attr,
                                                     int * policy);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_attr_getscope.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 13.5.1.
+   */
   PACE_INLINE int pace_pthread_attr_getscope (const pace_pthread_attr_t * attr,
                                               int * contentionscope);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_attr_getstackaddr.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 16.2.1.
+   */
   PACE_INLINE int pace_pthread_attr_getstackaddr (const pace_pthread_attr_t * attr,
                                                   void ** stackaddr);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_attr_getstacksize.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 16.2.1.
+   */
   PACE_INLINE int pace_pthread_attr_getstacksize (const pace_pthread_attr_t * attr,
                                                   size_t * stacksize);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_attr_init.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 16.2.1.
+   */
   PACE_INLINE int pace_pthread_attr_init (pace_pthread_attr_t * attr);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_attr_setdetachstate.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 16.2.1.
+   */
   PACE_INLINE int pace_pthread_attr_setdetachstate (pace_pthread_attr_t * attr,
                                                     int detachstate);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_attr_setinheritsched.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 13.5.1.
+   */
   PACE_INLINE int pace_pthread_attr_setinheritsched (pace_pthread_attr_t * attr,
                                                      int inheritsched);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_attr_setschedparam.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 13.5.1.
+   */
   PACE_INLINE int pace_pthread_attr_setschedparam (pace_pthread_attr_t * attr,
                                                    const struct
                                                    sched_param * param);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_attr_setschedpolicy.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 13.5.1.
+   */
   PACE_INLINE int pace_pthread_attr_setschedpolicy (pace_pthread_attr_t * attr,
                                                     int policy);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_attr_setscope.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 13.5.1.
+   */
   PACE_INLINE int pace_pthread_attr_setscope (pace_pthread_attr_t * attr,
                                               int contentionscope);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_attr_setstackaddr.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 16.2.1.
+   */
   PACE_INLINE int pace_pthread_attr_setstackaddr (pace_pthread_attr_t * attr,
                                                   void * stackaddr);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_attr_setstacksize.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 16.2.1.
+   */
   PACE_INLINE int pace_pthread_attr_setstacksize (pace_pthread_attr_t * attr,
                                                   size_t stacksize);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_cancel.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 18.2.1.
+   */
   PACE_INLINE int pace_pthread_cancel (pace_pthread_t thread);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_cleanup_push.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 18.2.3.
+   */
 # define pace_pthread_cleanup_push(routine, arg) \
     pthread_cleanup_push (routine, arg)
 
+  /** 
+     PACE's implementation of the POSIX function pthread_cleanup_pop.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 18.2.3.
+   */
 # define pace_pthread_cleanup_pop(execute) \
     pthread_cleanup_pop (execute)
 
 # define PACE_PTHREAD_COND_INITIALIZER PTHREAD_COND_INITIALIZER
 
+  /** 
+     PACE's implementation of the POSIX function pthread_cond_broadcast.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 11.4.3.
+   */
   PACE_INLINE int pace_pthread_cond_broadcast (pace_pthread_cond_t * cond);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_cond_destroy.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 11.4.2.
+   */
   PACE_INLINE int pace_pthread_cond_destroy (pace_pthread_cond_t * cond);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_cond_init.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 11.4.2.
+   */
   PACE_INLINE int pace_pthread_cond_init (pace_pthread_cond_t * cond,
                                           const pace_pthread_condattr_t * attr);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_cond_signal.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 11.4.3.
+   */
   PACE_INLINE int pace_pthread_cond_signal (pace_pthread_cond_t * cond);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_cond_timedwait.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 11.4.4.
+   */
   PACE_INLINE int pace_pace_pthread_cond_timedwait (pthread_cond_t * cond,
                                                pace_pthread_mutex_t * mutex,
                                                const struct timespec * abstime);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_cond_wait.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 11.4.4.
+   */
   PACE_INLINE int pace_pthread_cond_wait (pace_pthread_cond_t * cond,
                                           pace_pthread_mutex_t * mutex);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_condattr_destroy.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 11.4.1.
+   */
   PACE_INLINE int pace_pthread_condattr_destroy (pace_pthread_condattr_t * attr);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_condattr_getpshared.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 11.4.1.
+   */
   PACE_INLINE int pace_pthread_condattr_getpshared (const pace_pthread_condattr_t * attr,
                                                     int * pshared);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_condattr_init.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 11.4.1.
+   */
   PACE_INLINE int pace_pthead_condattr_init (pace_pthread_condattr_t * attr);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_condattr_setpshared.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 11.4.1.
+   */
   PACE_INLINE int pace_pthread_condattr_setpshared (pace_pthread_condattr_t * attr,
                                                     int pshared);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_create.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 16.2.2.
+   */
   PACE_INLINE int pace_pthread_create (pace_pthread_t * thread,
                                        const pace_pthread_attr_t * attr,
                                        void * (*start_routine) (void*),
                                        void * arg);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_detach.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 16.2.4.
+   */
   PACE_INLINE int pace_pthread_detach (pace_pthread_t thread);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_equal.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 16.2.7.
+   */
   PACE_INLINE int pace_pthread_equal (pace_pthread_t t1, pthread_t t2);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_exit.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 16.2.5.
+   */
   PACE_INLINE void pace_pthread_exit (void * value_ptr);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_getschedparam.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 13.2.5.
+   */
   PACE_INLINE int pace_pthread_getschedparam (pace_pthread_t thread,
                                               int * policy,
                                               struct sched_param * param);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_getspecific.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 17.1.2.
+   */
   PACE_INLINE void * pace_pthread_getspecific (pace_pthread_key_t key);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_join.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 16.2.3.
+   */
   PACE_INLINE int pace_pthread_join (pace_pthread_t thread, void ** value_ptr);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_key_create.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 17.1.1.
+   */
   PACE_INLINE int pace_pthread_key_create (pace_pthread_key_t * key,
                                            void (*destructor)(void*));
 
+  /** 
+     PACE's implementation of the POSIX function pthread_key_delete.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 17.1.3.
+   */
   PACE_INLINE int pace_pthread_key_delete (pace_pthread_key_t key);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_kill.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 3.3.10.
+   */
   PACE_INLINE int pace_pthread_kill (pace_pthread_t thread, int sig);
 
   # define PACE_PTHREAD_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER
 
+  /** 
+     PACE's implementation of the POSIX function pthread_mutex_destroy.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 11.3.2.
+   */
   PACE_INLINE int pace_pthread_mutex_destroy (pace_pthread_mutex_t * mutex);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_mutex_getprioceiling.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 13.6.2.
+   */
   PACE_INLINE int pace_pthread_mutex_getprioceiling (pace_pthread_mutex_t * mutex,
                                                      int * prioceiling);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_mutex_init.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 11.3.2.
+   */
   PACE_INLINE int pace_pthread_mutex_init (pace_pthread_mutex_t * mutex,
                                            const pace_pthread_mutexattr_t * attr);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_mutex_lock.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 11.3.3.
+   */
   PACE_INLINE int pace_pthread_mutex_lock (pace_pthread_mutex_t * mutex);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_mutex_setprioceiling.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 13.6.2.
+   */
   PACE_INLINE int pace_pthread_mutex_setprioceiling (pace_pthread_mutex_t * mutex,
                                                      int prioceiling,
                                                      int * old_ceiling);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_mutex_trylock.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 11.3.3.
+   */
   PACE_INLINE int pace_pthread_mutex_trylock (pthread_mutex_t * mutex);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_mutex_unlock.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 11.3.3.
+   */
   PACE_INLINE int pace_pthread_mutex_unlock (pace_pthread_mutex_t * mutex);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_mutexattr_destroy.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 11.3.1.
+   */
   PACE_INLINE int pace_pthread_mutexattr_destroy (pace_pthread_mutexattr_t * sttr);
 
+  /** 
+     PACE's implementation of the POSIX function
+     pthread_mutexattr_getprioceiling.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 13.6.1.
+   */
   PACE_INLINE int pace_pthread_mutexattr_getprioceiling (pace_pthread_mutexattr_t * attr,
                                                          int * prioceiling);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_mutexattr_getprotocol.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 13.6.1.
+   */
   PACE_INLINE int pace_pthread_mutexattr_getprotocol
                   (const pace_pthread_mutexattr_t * attr, int * protocol);
 
+  /** 
+     PACE's implementation of the POSIX function
+     pthread_mutexattr_setprioceiling.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 13.6.1.
+   */
   PACE_INLINE int pace_pthread_mutexattr_setprioceiling (pace_pthread_mutexattr_t * attr,
                                                          int prioceiling);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_mutexattr_setprotocol.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 13.6.1.
+   */
   PACE_INLINE int pace_pthread_mutexattr_setprotocol (pace_pthread_mutexattr_t * attr,
                                                       int protocol);
+  /** 
+     PACE's implementation of the POSIX function pthread_mutexattr_getpshared.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 11.3.1.
+   */
   PACE_INLINE int
   pace_pthread_mutexattr_getpshared (const pace_pthread_mutexattr_t * attr,
                                      int * pshared);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_mutexattr_init.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 11.3.1.
+   */
   PACE_INLINE int pace_pthread_mutexattr_init (pace_pthread_mutexattr_t * attr);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_mutexattr_setpshared.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 11.3.1.
+   */
   PACE_INLINE int pace_pthread_mutexattr_setpshared (pace_pthread_mutexattr_t * attr,
                                                      int pshared);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_once.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 16.2.8.
+   */
   PACE_INLINE int pace_pthread_once (pace_pthread_once_t * once_control,
                                      void (*void_routine) ());
 
 # define PACE_PTHREAD_ONCE_INIT PTHREAD_ONCE_INIT
 
+  /** 
+     PACE's implementation of the POSIX function pthread_self.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 16.2.6.
+   */
   PACE_INLINE pace_pthread_t pace_pthread_self ();
 
+  /** 
+     PACE's implementation of the POSIX function pthread_setcancelstate.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 18.2.2.
+   */
   PACE_INLINE int pace_pthread_setcancelstate (int state, int * oldstate);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_setcanceltype.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 18.2.2.
+   */
   PACE_INLINE int pace_pthread_setcanceltype (int type, int * oldtype);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_setschedparam.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 13.5.2.
+   */
   PACE_INLINE int pace_pthread_setschedparam (pace_pthread_t thread,
                                               int policy,
                                               const struct sched_param * param);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_setspecific.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 17.1.2.
+   */
   PACE_INLINE int pace_pthread_setspecific (pace_pthread_key_t key, const void * value);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_sigmask.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 3.3.5.
+   */
   PACE_INLINE int pace_pthread_sigmask (int how,
                                         const sigset_t * set,
                                         sigset_t * oset);
 
+  /** 
+     PACE's implementation of the POSIX function pthread_testcancel.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 18.2.2.
+   */
   PACE_INLINE void pace_pthread_testcancel ();
 
 #if defined (PACE_HAS_CPLUSPLUS)
diff --git a/PACE/pace/posix/pwd.h b/PACE/pace/posix/pwd.h
index b62a2dabacb..94f9486f1ea 100644
--- a/PACE/pace/posix/pwd.h
+++ b/PACE/pace/posix/pwd.h
@@ -22,8 +22,18 @@
 extern "C" {
 #endif /* PACE_HAS_CPLUSPLUS */
 
+  /** 
+     PACE's implementation of the POSIX function getpwuid.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 9.2.2.
+   */
   PACE_INLINE struct passwd * pace_getpwuid (uid_t uid);
 
+  /** 
+     PACE's implementation of the POSIX function getpwuid_r.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 9.2.2.
+   */
   PACE_INLINE int pace_getpwuid_r (uid_t uid,
                                    struct passwd * pwd,
                                    char * buffer,
@@ -31,8 +41,18 @@ extern "C" {
                                    struct passwd ** result);
   /* Requires PACE_HAS_POSIX_PTHREAD_SEMANTICS. */
 
+  /** 
+     PACE's implementation of the POSIX function getpwnam.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 9.2.2.
+   */
   PACE_INLINE struct passwd * pace_getpwnam (const char * name);
 
+  /** 
+     PACE's implementation of the POSIX function getpwnam_r.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 9.2.2.
+   */
   PACE_INLINE int pace_getpwnam_r (const char * name,
                                    struct passwd * pwd,
                                    char * buffer,
diff --git a/PACE/pace/posix/sched.h b/PACE/pace/posix/sched.h
index f7e9e9abd30..8acebdf2c6f 100644
--- a/PACE/pace/posix/sched.h
+++ b/PACE/pace/posix/sched.h
@@ -22,25 +22,65 @@
 extern "C" {
 #endif /* PACE_HAS_CPLUSPLUS */
 
+  /** 
+     PACE's implementation of the POSIX function sched_get_priority_max.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 13.3.6.
+   */
   PACE_INLINE int pace_sched_get_priority_max (int policy);
 
+  /** 
+     PACE's implementation of the POSIX function sched_get_priority_min.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 13.3.6.
+   */
   PACE_INLINE int pace_sched_get_priority_min (int policy);
 
+  /** 
+     PACE's implementation of the POSIX function sched_getparam.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 13.3.2.
+   */
   PACE_INLINE int pace_sched_getparam (pid_t pid,
                                        struct sched_param * param);
 
+  /** 
+     PACE's implementation of the POSIX function sched_rr_get_interval.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 13.3.6.
+   */
   PACE_INLINE int pace_sched_rr_get_interval (pid_t pid,
                                               struct timespec * interval);
 
+  /** 
+     PACE's implementation of the POSIX function sched_setparam.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 13.3.1.
+   */
   PACE_INLINE int pace_sched_setparam (pid_t pid,
                                        const struct sched_param * param);
 
+  /** 
+     PACE's implementation of the POSIX function sched_getscheduler.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 13.3.4.
+   */
   PACE_INLINE int pace_sched_getscheduler (pid_t pid);
 
+  /** 
+     PACE's implementation of the POSIX function sched_setscheduler.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 13.3.3.
+   */
   PACE_INLINE int pace_sched_setscheduler (pid_t pid,
                                            int policy,
                                            const struct sched_param * param);
 
+  /** 
+     PACE's implementation of the POSIX function sched_yield.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 13.3.5.
+   */
   PACE_INLINE int pace_sched_yield ();
 
 #if defined (PACE_HAS_CPLUSPLUS)
diff --git a/PACE/pace/posix/semaphore.h b/PACE/pace/posix/semaphore.h
index e6ec9422f5e..7c436f622d7 100644
--- a/PACE/pace/posix/semaphore.h
+++ b/PACE/pace/posix/semaphore.h
@@ -22,14 +22,39 @@
 extern "C" {
 #endif /* PACE_HAS_CPLUSPLUS */
 
+  /** 
+     PACE's implementation of the POSIX function sem_close.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 11.2.4.
+   */
   PACE_INLINE int pace_sem_close (sem_t * sem);
 
+  /** 
+     PACE's implementation of the POSIX function sem_destroy.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 11.2.2.
+   */
   PACE_INLINE int pace_sem_destroy (sem_t * sem);
 
+  /** 
+     PACE's implementation of the POSIX function sem_getvalue.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 11.2.8.
+   */
   PACE_INLINE int pace_sem_getvalue (sem_t * sem, int * sval);
 
+  /** 
+     PACE's implementation of the POSIX function sem_init.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 11.2.1.
+   */
   PACE_INLINE int pace_sem_init (sem_t * sem, int pshared, unsigned int value);
 
+  /** 
+     PACE's implementation of the POSIX function sem_open.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 11.2.3.
+   */
   # define pace_sem_open(X) sem_open X
   /* int fprintf (FILE *stream, const char *format, (*//* args *//*) ... );
    *
@@ -38,12 +63,32 @@ extern "C" {
    * surrounding the arguments.
    */
 
+  /** 
+     PACE's implementation of the POSIX function sem_post.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 11.2.7.
+   */
   PACE_INLINE int pace_sem_post (sem_t * sem);
 
+  /** 
+     PACE's implementation of the POSIX function sem_trywait.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 11.2.6.
+   */
   PACE_INLINE int pace_sem_trywait (sem_t * sem);
 
+  /** 
+     PACE's implementation of the POSIX function sem_unlink.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 11.2.5.
+   */
   PACE_INLINE int pace_sem_unlink (const char * name);
 
+  /** 
+     PACE's implementation of the POSIX function sem_wait.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 11.2.6.
+   */
   PACE_INLINE int pace_sem_wait (sem_t * sem);
 
 #if defined (PACE_HAS_CPLUSPLUS)
diff --git a/PACE/pace/posix/setjmp.h b/PACE/pace/posix/setjmp.h
index 6a8f1c581ba..55a488b87b0 100644
--- a/PACE/pace/posix/setjmp.h
+++ b/PACE/pace/posix/setjmp.h
@@ -22,8 +22,18 @@
 extern "C" {
 #endif /* PACE_HAS_CPLUSPLUS */
 
+  /** 
+     PACE's implementation of the POSIX function sigsetjmp.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.3.1.
+   */
   PACE_INLINE int pace_sigsetjmp (sigjmp_buf env, int savemask);
 
+  /** 
+     PACE's implementation of the POSIX function siglongjmp.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.3.1.
+   */
   PACE_INLINE void pace_siglongjmp (sigjmp_buf env, int val);
 
 #if defined (PACE_HAS_CPLUSPLUS)
diff --git a/PACE/pace/posix/signal.h b/PACE/pace/posix/signal.h
index adbf862073d..1859c17b50a 100644
--- a/PACE/pace/posix/signal.h
+++ b/PACE/pace/posix/signal.h
@@ -23,41 +23,111 @@
 extern "C" {
 #endif /* PACE_HAS_CPLUSPLUS */
 
+  /** 
+     PACE's implementation of the POSIX function kill.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 3.3.2.
+   */
   PACE_INLINE int pace_kill (pid_t pid, int sig);
 
+  /** 
+     PACE's implementation of the POSIX function sigaction.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 3.3.4.
+   */
   PACE_INLINE int pace_sigaction (int sig,
                                   const struct sigaction * act,
                                   struct sigaction * oact);
 
+  /** 
+     PACE's implementation of the POSIX function sigaddset.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 3.3.3.
+   */
   PACE_INLINE int pace_sigaddset (sigset_t * set, int signo);
 
+  /** 
+     PACE's implementation of the POSIX function sigemptyset.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 3.3.3.
+   */
   PACE_INLINE int pace_sigemptyset (sigset_t * set);
 
+  /** 
+     PACE's implementation of the POSIX function sigdelset.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 3.3.3.
+   */
   PACE_INLINE int pace_sigdelset (sigset_t * set, int signo);
 
+  /** 
+     PACE's implementation of the POSIX function sigfillset.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 3.3.3.
+   */
   PACE_INLINE int pace_sigfillset (sigset_t * set);
 
+  /** 
+     PACE's implementation of the POSIX function sigismember.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 3.3.3.
+   */
   PACE_INLINE int pace_sigismember (const sigset_t * set, int signo);
 
+  /** 
+     PACE's implementation of the POSIX function sigpending.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 3.3.6.
+   */
   PACE_INLINE int pace_sigpending (sigset_t * set);
 
+  /** 
+     PACE's implementation of the POSIX function sigprocmask.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 3.3.5.
+   */
   PACE_INLINE int pace_sigprocmask (int how,
                                     const sigset_t * set,
                                     sigset_t * oset);
 
+  /** 
+     PACE's implementation of the POSIX function sigqueue.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 3.3.9.
+   */
   PACE_INLINE int pace_sigqueue (pid_t pid,
                                  int signo,
                                  const union sigval value);
 
+  /** 
+     PACE's implementation of the POSIX function sigsuspend.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 3.3.7.
+   */
   PACE_INLINE int pace_sigsuspend (const sigset_t * sigmask);
 
+  /** 
+     PACE's implementation of the POSIX function sigtimedwait.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 3.3.8.
+   */
   PACE_INLINE int pace_sigtimedwait (const sigset_t * set,
                                      siginfo_t * info,
                                      const struct timespec * timeout);
 
+  /** 
+     PACE's implementation of the POSIX function sigwait.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 3.3.8.
+   */
   PACE_INLINE int pace_sigwait (const sigset_t * set, int * sig);
   /* Requires PACE_HAS_POSIX_PTHREAD_SEMANTICS. */
 
+  /** 
+     PACE's implementation of the POSIX function sigwaitinfo.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 3.3.8.
+   */
   PACE_INLINE int pace_sigwaitinfo (const sigset_t * set, siginfo_t * info);
 
 #if defined (PACE_HAS_CPLUSPLUS)
diff --git a/PACE/pace/posix/stdio.h b/PACE/pace/posix/stdio.h
index 02f553abffd..dd24ca13aa5 100644
--- a/PACE/pace/posix/stdio.h
+++ b/PACE/pace/posix/stdio.h
@@ -29,46 +29,136 @@ extern "C" {
 
   #define pace_stdin stdin;
 
+  /** 
+     PACE's implementation of the POSIX function clearerr.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE void pace_clearerr (FILE * stream);
 
+  /** 
+     PACE's implementation of the POSIX function ctermid.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 4.7.1.
+   */
   PACE_INLINE char * pace_ctermid (char * s);
 
+  /** 
+     PACE's implementation of the POSIX function fclose.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE int pace_fclose (FILE * stream);
 
+  /** 
+     PACE's implementation of the POSIX function fdopen.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.2.2.
+   */
   PACE_INLINE FILE * pace_fdopen (int fildes, const char * type);
 
+  /** 
+     PACE's implementation of the POSIX function ferror.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE int pace_ferror (FILE * stream);
 
+  /** 
+     PACE's implementation of the POSIX function feof.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE int pace_feof (FILE * stream);
 
+  /** 
+     PACE's implementation of the POSIX function fflush.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE int pace_fflush (FILE * stream);
 
+  /** 
+     PACE's implementation of the POSIX function fileno.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.2.1.
+   */
   PACE_INLINE int pace_fileno (FILE * stream);
 
+  /** 
+     PACE's implementation of the POSIX function fgetc.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE int pace_fgetc (FILE * stream);
 
+  /** 
+     PACE's implementation of the POSIX function fgets.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE char * pace_fgets (char * s, int n, FILE * stream);
 
+  /** 
+     PACE's implementation of the POSIX function flockfile.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.2.6.
+   */
   PACE_INLINE void pace_flockfile (FILE * file);
   /* Requires PACE_HAS_REENTRANT. */
 
+  /** 
+     PACE's implementation of the POSIX function fopen.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE FILE * pace_fopen (const char * filename, const char * mode);
 
+  /** 
+     PACE's implementation of the POSIX function fprintf.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   int pace_fprintf (FILE *stream, const char *format, ...);
 
+  /** 
+     PACE's implementation of the POSIX function fputc.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE int pace_fputc (int c, FILE * stream);
 
+  /** 
+     PACE's implementation of the POSIX function fputs.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE int pace_fputs (const char * s, FILE * stream);
 
+  /** 
+     PACE's implementation of the POSIX function fread.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE size_t pace_fread (void * ptr,
                                  size_t size,
                                  size_t number_of_items,
                                  FILE * stream);
 
+  /** 
+     PACE's implementation of the POSIX function freopen.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE FILE * pace_freopen (const char * filename,
                                    const char * mode,
                                    FILE * stream);
 
+  /** 
+     PACE's implementation of the POSIX function fscanf.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   #define pace_fscanf (X) fscanf X
   /* int pace_scanf (const char *format, ... );
   *
@@ -76,53 +166,159 @@ extern "C" {
   * This is a macro and requires an additional set of parenthesis
   * surrounding the arguments.
   */
+
+  /** 
+     PACE's implementation of the POSIX function fseek.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE int pace_fseek (FILE * stream, long offset, int whence);
 
+  /** 
+     PACE's implementation of the POSIX function ftell.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE long pace_ftell (FILE * stream);
 
+  /** 
+     PACE's implementation of the POSIX function ftrylockfile.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.2.6.
+   */
   PACE_INLINE int pace_ftrylockfile (FILE * file);
   /* Requires PACE_HAS_REENTRANT. */
 
+  /** 
+     PACE's implementation of the POSIX function funlockfile.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.2.6.
+   */
   PACE_INLINE void pace_funlockfile (FILE * file);
   /* Requires PACE_HAS_REENTRANT. */
 
+  /** 
+     PACE's implementation of the POSIX function getc.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE int pace_getc (FILE * stream);
 
+  /** 
+     PACE's implementation of the POSIX function getc_unlocked.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.2.7.
+   */
   PACE_INLINE int pace_getc_unlocked (FILE * stream);
   /* Requires PACE_HAS_REENTRANT. */
 
+  /** 
+     PACE's implementation of the POSIX function getchar.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE int pace_getchar ();
 
+  /** 
+     PACE's implementation of the POSIX function getchar_unlocked.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.2.7.
+   */
   PACE_INLINE int pace_getchar_unlocked ();
   /* Requires PACE_HAS_REENTRANT. */
 
+  /** 
+     PACE's implementation of the POSIX function gets.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE char *pace_gets (char * s);
 
+  /** 
+     PACE's implementation of the POSIX function perror.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE void pace_perror (const char * s);
 
+  /** 
+     PACE's implementation of the POSIX function printf.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   int pace_printf (const char* format, ...);
 
+  /** 
+     PACE's implementation of the POSIX function putc.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE int pace_putc (int c, FILE * stream);
 
+  /** 
+     PACE's implementation of the POSIX function putc_unlocked.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.2.7.
+   */
   PACE_INLINE int pace_putc_unlocked (int c, FILE * stream);
   /* Requires PACE_HAS_REENTRANT. */
 
+  /** 
+     PACE's implementation of the POSIX function putchar.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE int pace_putchar (int c);
 
+  /** 
+     PACE's implementation of the POSIX function putchar_unlocked.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.2.7.
+   */
   PACE_INLINE int pace_putchar_unlocked (int c);
   /* Requires PACE_HAS_REENTRANT. */
 
+  /** 
+     PACE's implementation of the POSIX function puts.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE int pace_puts (const char * s);
 
+  /** 
+     PACE's implementation of the POSIX function remove.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE int pace_remove (const char * path);
 
+  /** 
+     PACE's implementation of the POSIX function rename.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 5.5.3.
+   */
   PACE_INLINE int pace_rename (const char * old_name,
                                const char * new_name);
 
+  /** 
+     PACE's implementation of the POSIX function rewind.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE void pace_rewind (FILE * stream);
 
+  /** 
+     PACE's implementation of the POSIX function sprintf.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   int pace_sprintf (char* s, const char* format, ...);
 
+  /** 
+     PACE's implementation of the POSIX function scanf.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   #define pace_scanf (X) scanf X
   /* int pace_scanf (const char *format, ... );
   *
@@ -131,9 +327,18 @@ extern "C" {
   * surrounding the arguments.
   */
 
-
+  /** 
+     PACE's implementation of the POSIX function setbuf.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE void pace_setbuf (FILE * stream, char * buf);
 
+  /** 
+     PACE's implementation of the POSIX function sscanf.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   #define pace_sscanf (X) sscanf X
   /* int pace_sscanf (const char *s, const char *format, ... );
   *
@@ -142,19 +347,27 @@ extern "C" {
   * surrounding the arguments.
   */
 
-
-  int snprintf (char *s, size_t  n, const char *format, ...);
-
+  /** 
+     PACE's implementation of the POSIX function sscanf.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE FILE * pace_tmpfile ();
 
+  /** 
+     PACE's implementation of the POSIX function tmpnam.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE char * pace_tmpnam (char * s);
 
+  /** 
+     PACE's implementation of the POSIX function ungetc.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE int pace_ungetc (int c, FILE * stream);
 
-  PACE_INLINE int pace_vsprintf (char * buffer,
-                                 const char * format,
-                                 va_list argptr);
-
 #if defined (PACE_HAS_CPLUSPLUS)
 }
 #endif /* PACE_HAS_CPLUSPLUS */
diff --git a/PACE/pace/posix/stdio.inl b/PACE/pace/posix/stdio.inl
index 4c221439f3c..15cfe6c1637 100644
--- a/PACE/pace/posix/stdio.inl
+++ b/PACE/pace/posix/stdio.inl
@@ -364,17 +364,6 @@ pace_sprintf (char* s, const char* format, ...)
   return result;
 }
 
-int
-pace_snprintf (char *s, size_t  n, const char *format, ...)
-{
-  int result = 0;
-  va_list ap;
-  va_start (ap, format);
-  result = vsnprintf (s, n, format, ap);
-  va_end (ap);
-  return result;
-}
-
 PACE_INLINE
 FILE *
 pace_tmpfile ()
@@ -395,12 +384,3 @@ pace_ungetc (int c, FILE * stream)
 {
  return ungetc (c, stream);
 }
-
-PACE_INLINE
-int
-pace_vsprintf (char * buffer,
-               const char * format,
-               va_list argptr)
-{
-  return vsprintf (buffer, format, argptr);
-}
diff --git a/PACE/pace/posix/stdlib.h b/PACE/pace/posix/stdlib.h
index a386afdd635..7bd486b49fb 100644
--- a/PACE/pace/posix/stdlib.h
+++ b/PACE/pace/posix/stdlib.h
@@ -22,24 +22,69 @@
 extern "C" {
 #endif /* PACE_HAS_CPLUSPLUS */
 
+  /** 
+     PACE's implementation of the POSIX function atoi.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE int pace_atoi (const char * str);
 
+  /** 
+     PACE's implementation of the POSIX function atol.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE long pace_atol (const char * str);
 
+  /** 
+     PACE's implementation of the POSIX function exit.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE void pace_exit (int status);
 
+  /** 
+     PACE's implementation of the POSIX function getenv.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 4.6.1.
+   */
   PACE_INLINE char * pace_getenv (const char * name);
 
+  /** 
+     PACE's implementation of the POSIX function rand_r.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.3.8.
+   */
   PACE_INLINE int pace_rand_r (unsigned int * seed);
 
   /* Memory Management. */
 
+  /** 
+     PACE's implementation of the POSIX function malloc.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE void * pace_malloc (size_t size);
 
+  /** 
+     PACE's implementation of the POSIX function calloc.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE void * pace_calloc (size_t nelem, size_t elsize);
 
+  /** 
+     PACE's implementation of the POSIX function free.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE void pace_free (void * ptr);
 
+  /** 
+     PACE's implementation of the POSIX function realloc.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE void * pace_realloc (void * ptr, size_t size);
 
 #if defined (PACE_HAS_CPLUSPLUS)
diff --git a/PACE/pace/posix/string.h b/PACE/pace/posix/string.h
index a16946fe482..ff345ee7f28 100644
--- a/PACE/pace/posix/string.h
+++ b/PACE/pace/posix/string.h
@@ -22,34 +22,109 @@
 extern "C" {
 #endif /* PACE_HAS_CPLUSPLUS */
 
+  /** 
+     PACE's implementation of the POSIX function strcat.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE char * pace_strcat (char * s1, const char * s2);
 
+  /** 
+     PACE's implementation of the POSIX function strncat.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE char * pace_strncat (char * s1, const char * s2, size_t n);
 
+  /** 
+     PACE's implementation of the POSIX function strchr.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE const char * pace_strchr (const char * s, int c);
 
+  /** 
+     PACE's implementation of the POSIX function strrchr.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE const char * pace_strrchr (const char * s, int c);
 
+  /** 
+     PACE's implementation of the POSIX function strcmp.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE int pace_strcmp (const char * s1, const char * s2);
 
+  /** 
+     PACE's implementation of the POSIX function strncmp.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE int pace_strncmp (const char * s1, const char * s2, size_t n);
 
+  /** 
+     PACE's implementation of the POSIX function strcpy.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE char * pace_strcpy (char * s1, const char * s2);
 
+  /** 
+     PACE's implementation of the POSIX function strncpy.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE char * pace_strncpy (char * s1, const char * s2, size_t n);
 
+  /** 
+     PACE's implementation of the POSIX function strcspn.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE size_t pace_strcspn (const char * s1, const char * s2);
 
+  /** 
+     PACE's implementation of the POSIX function strspn.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE size_t pace_strspn (const char * s1, const char * s2);
 
+  /** 
+     PACE's implementation of the POSIX function strlen.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE size_t pace_strlen (const char * s);
 
+  /** 
+     PACE's implementation of the POSIX function strpbrk.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE const char * pace_strpbrk (const char * s1, const char * s2);
 
+  /** 
+     PACE's implementation of the POSIX function strstr.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE const char * pace_strstr (const char * s1, const char * s2);
 
+  /** 
+     PACE's implementation of the POSIX function strtok.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.
+   */
   PACE_INLINE char * pace_strtok (char * s1, const char * s2);
 
+  /** 
+     PACE's implementation of the POSIX function strtok_r.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.3.3.
+   */
   PACE_INLINE char * pace_strtok_r (char * s,
                                     const char * sep,
                                     char ** lasts);
diff --git a/PACE/pace/posix/time.h b/PACE/pace/posix/time.h
index 42835012cc8..ab3d5081cd4 100644
--- a/PACE/pace/posix/time.h
+++ b/PACE/pace/posix/time.h
@@ -22,60 +22,135 @@
 extern "C" {
 #endif /* PACE_HAS_CPLUSPLUS */
 
+  /** 
+     PACE's implementation of the POSIX function asctime_r.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.1.1.
+   */
   PACE_INLINE char * pace_asctime_r (const struct tm * tm, char * buf);
   /* Requires PACE_HAS_POSIX_PTHREAD_SEMANTICS. */
 
+  /** 
+     PACE's implementation of the POSIX function clock_getres.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 14.2.1.
+   */
   PACE_INLINE int pace_clock_getres (clockid_t clock_id,
                                      struct timespec * res);
   /* Requires PACE_HAS_POSIX_PTHREAD_SEMANTICS. */
 
+  /** 
+     PACE's implementation of the POSIX function clock_gettime.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 14.2.1.
+   */
   PACE_INLINE int pace_clock_gettime (clockid_t clock_id,
                                       struct timespec * tp);
   /* Requires PACE_HAS_POSIX_PTHREAD_SEMANTICS. */
 
+  /** 
+     PACE's implementation of the POSIX function clock_settime.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 14.2.1.
+   */
   PACE_INLINE int pace_clock_settime (clockid_t clock_id,
                                       const struct timespec * tp);
   /* Requires PACE_HAS_POSIX_PTHREAD_SEMANTICS. */
 
+  /** 
+     PACE's implementation of the POSIX function clock_ctime_r.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.3.5.
+   */
   PACE_INLINE char * pace_ctime_r (const time_t * clock, char * buf);
   /* Requires PACE_HAS_POSIX_PTHREAD_SEMANTICS. */
 
+  /** 
+     PACE's implementation of the POSIX function clock_gmtime_r.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.3.6.
+   */
   PACE_INLINE struct tm * pace_gmtime_r (const time_t * clock,
                                          struct tm * result);
   /* Requires PACE_HAS_POSIX_PTHREAD_SEMANTICS. */
 
+  /** 
+     PACE's implementation of the POSIX function clock_localtime_r.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.3.7.
+   */
   PACE_INLINE struct tm * pace_localtime_r (const time_t * clock,
                                             struct tm * result);
   /* Requires PACE_HAS_POSIX_PTHREAD_SEMANTICS. */
 
+  /** 
+     PACE's implementation of the POSIX function nanosleep.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 14.2.5.
+   */
   PACE_INLINE int pace_nanosleep (const struct timespec * rqtp,
                                   struct timespec * rmtp);
   /* Requires PACE_HAS_POSIX_PTHREAD_SEMANTICS. */
 
+  /** 
+     PACE's implementation of the POSIX function time.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 4.5.1.
+   */
   PACE_INLINE int pace_time (time_t *tloc);
   /* Requires PACE_HAS_POSIX_PTHREAD_SEMANTICS. */
 
+  /** 
+     PACE's implementation of the POSIX function timer_create.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 14.2.2.
+   */
   PACE_INLINE int pace_timer_create (clockid_t clock_id,
                                      struct sigevent * evp,
                                      timer_t * timerid);
   /* Requires PACE_HAS_POSIX_PTHREAD_SEMANTICS. */
 
+  /** 
+     PACE's implementation of the POSIX function timer_delete.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 14.2.3.
+   */
   PACE_INLINE int pace_timer_delete (timer_t timerid);
   /* Requires PACE_HAS_POSIX_PTHREAD_SEMANTICS. */
 
+  /** 
+     PACE's implementation of the POSIX function timer_getoverrun.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 14.2.4.
+   */
   PACE_INLINE int pace_timer_getoverrun (timer_t timerid);
   /* Requires PACE_HAS_POSIX_PTHREAD_SEMANTICS. */
 
+  /** 
+     PACE's implementation of the POSIX function timer_gettime.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 14.2.4.
+   */
   PACE_INLINE int pace_timer_gettime (timer_t timerid,
                                       struct itimerspec * value);
   /* Requires PACE_HAS_POSIX_PTHREAD_SEMANTICS. */
 
+  /** 
+     PACE's implementation of the POSIX function timer_settime.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 14.2.4.
+   */
   PACE_INLINE int pace_timer_settime (timer_t timerid,
                                       int flags,
                                       const struct itimerspec * value,
                                       struct itimerspec * ovalue);
   /* Requires PACE_HAS_POSIX_PTHREAD_SEMANTICS. */
 
+  /** 
+     PACE's implementation of the POSIX function tzset.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 8.3.2.
+   */
   PACE_INLINE void pace_tzset ();
   /* Requires PACE_HAS_POSIX_PTHREAD_SEMANTICS. */
 
diff --git a/PACE/pace/posix/unistd.h b/PACE/pace/posix/unistd.h
index 1b57a71ea32..1b1ea2f6e98 100644
--- a/PACE/pace/posix/unistd.h
+++ b/PACE/pace/posix/unistd.h
@@ -24,111 +24,343 @@
 extern "C" {
 #endif /* PACE_HAS_CPLUSPLUS */
 
+  /** 
+     PACE's implementation of the POSIX function _exit.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 3.2.2.
+   */
   PACE_INLINE void pace__exit (int status);
 
+  /** 
+     PACE's implementation of the POSIX function alarm.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 3.4.1.
+   */
   PACE_INLINE unsigned int pace_alarm (unsigned int seconds);
 
+  /** 
+     PACE's implementation of the POSIX function access.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 5.6.3.
+   */
   PACE_INLINE int pace_access (const char * path, int amode);
 
+  /** 
+     PACE's implementation of the POSIX function chdir.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 5.2.1.
+   */
   PACE_INLINE int pace_chdir (const char * path);
 
+  /** 
+     PACE's implementation of the POSIX function chown.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 5.6.5.
+   */
   PACE_INLINE int pace_chown (const char * path, uid_t owner, pace_gid_t group);
 
+  /** 
+     PACE's implementation of the POSIX function close.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 6.3.1.
+   */
   PACE_INLINE int pace_close (int fildes);
 
+  /** 
+     PACE's implementation of the POSIX function dup.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 6.2.1.
+   */
   PACE_INLINE int pace_dup (int fildes);
 
+  /** 
+     PACE's implementation of the POSIX function dup2.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 6.2.1.
+   */
   PACE_INLINE int pace_dup2 (int fildes, int fildes2);
 
+  /** 
+     PACE's implementation of the POSIX function execl.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 3.1.2.
+   */
   int pace_execl (const char* path, const char* arg, ...);
 
+  /** 
+     PACE's implementation of the POSIX function execle.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 3.1.2.
+   */
   int pace_execle (const char* path, const char* arg, ...);
 
+  /** 
+     PACE's implementation of the POSIX function execlp.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 3.1.2.
+   */
   int pace_execlp (const char* file, const char* arg,  ...);
 
+  /** 
+     PACE's implementation of the POSIX function execv.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 3.1.2.
+   */
   PACE_INLINE int pace_execv (const char * path, char * const argv[]);
 
+  /** 
+     PACE's implementation of the POSIX function execve.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 3.1.2.
+   */
   PACE_INLINE int pace_execve (const char * path, char * const argv[],
                                char * const envp[]);
 
+  /** 
+     PACE's implementation of the POSIX function execvp.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 3.1.2.
+   */
   PACE_INLINE int pace_execvp (const char * file, char * const argv[]);
 
+  /** 
+     PACE's implementation of the POSIX function fdatasync.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 6.6.2.
+   */
   PACE_INLINE int pace_fdatasync (int fildes);
 
+  /** 
+     PACE's implementation of the POSIX function fork.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 3.1.1.
+   */
   PACE_INLINE pace_pid_t pace_fork ();
 
+  /** 
+     PACE's implementation of the POSIX function fpathconf.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 5.7.1.
+   */
   PACE_INLINE long pace_fpathconf (int fildes, int name);
 
+  /** 
+     PACE's implementation of the POSIX function fsync.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 6.6.1.
+   */
   PACE_INLINE int pace_fsync (int fildes);
 
+  /** 
+     PACE's implementation of the POSIX function ftruncate.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 5.6.7.
+   */
   PACE_INLINE int pace_ftruncate (int fildes, pace_off_t length);
 
+  /** 
+     PACE's implementation of the POSIX function getcwd.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 5.2.2.
+   */
   PACE_INLINE char * pace_getcwd (char * buf, size_t size);
 
+  /** 
+     PACE's implementation of the POSIX function getegid.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 4.2.1.
+   */
   PACE_INLINE uid_t pace_getegid ();
 
+  /** 
+     PACE's implementation of the POSIX function geteuid.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 4.2.1.
+   */
   PACE_INLINE uid_t pace_geteuid ();
 
+  /** 
+     PACE's implementation of the POSIX function getgid.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 4.2.1.
+   */
   PACE_INLINE uid_t pace_getgid ();
 
+  /** 
+     PACE's implementation of the POSIX function getgroups.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 4.2.3.
+   */
   PACE_INLINE int pace_getgroups (int gidsetsize, pace_gid_t grouplist[]);
 
+  /** 
+     PACE's implementation of the POSIX function getlogin.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 4.2.4.
+   */
   PACE_INLINE char * pace_getlogin ();
 
+  /** 
+     PACE's implementation of the POSIX function getlogin_r.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 4.2.4.
+   */
   PACE_INLINE int pace_getlogin_r (char * name, size_t namesize);
   /* Requires PACE_HAS_POSIX_PTHREAD_SEMANTICS. */
 
+  /** 
+     PACE's implementation of the POSIX function getpgrp.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 4.3.1.
+   */
   PACE_INLINE pace_pid_t pace_getpgrp ();
 
+  /** 
+     PACE's implementation of the POSIX function getpid.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 4.1.1.
+   */
   PACE_INLINE pace_pid_t pace_getpid ();
 
+  /** 
+     PACE's implementation of the POSIX function getppid.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 4.1.1.
+   */
   PACE_INLINE pace_pid_t pace_getppid ();
 
+  /** 
+     PACE's implementation of the POSIX function getuid.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 4.2.1.
+   */
   PACE_INLINE uid_t pace_getuid ();
 
-  #define pace_ioctl(X) ioctl X
-  /* int ioctl (int fildes, int request, (*//* args *//*))
-   *
-   * PLEASE PAY SPECIAL ATTENTION HERE!
-   * This is a macro and requires an additional set of parenthesis
-   * surrounding the arguments.
+  /** 
+     PACE's implementation of the POSIX function isatty.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 4.7.2.
    */
-
   PACE_INLINE int pace_isatty (int fildes);
 
+  /** 
+     PACE's implementation of the POSIX function link.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 5.3.4.
+   */
   PACE_INLINE int pace_link (const char * existing, const char * new_link);
 
+  /** 
+     PACE's implementation of the POSIX function lseek.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 6.5.3.
+   */
   PACE_INLINE pace_off_t pace_lseek (int fildes, off_t offset, int whence);
 
+  /** 
+     PACE's implementation of the POSIX function pathconf.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 5.7.1.
+   */
   PACE_INLINE long pace_pathconf (const char * path, int name);
 
+  /** 
+     PACE's implementation of the POSIX function pause.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 3.4.2.
+   */
   PACE_INLINE int pace_pause ();
 
+  /** 
+     PACE's implementation of the POSIX function pipe.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 6.1.1.
+   */
   PACE_INLINE int pace_pipe (int fildes[2]);
 
+  /** 
+     PACE's implementation of the POSIX function read.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 6.4.1.
+   */
   PACE_INLINE ssize_t pace_read (int fildes, void * buf, size_t nbyte);
 
+  /** 
+     PACE's implementation of the POSIX function rmdir.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 5.5.2.
+   */
   PACE_INLINE int pace_rmdir (const char * path);
 
+  /** 
+     PACE's implementation of the POSIX function setgid.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 4.2.2.
+   */
   PACE_INLINE int pace_setgid (pace_gid_t gid);
 
+  /** 
+     PACE's implementation of the POSIX function setpgid.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 4.3.3.
+   */
   PACE_INLINE int pace_setpgid (pace_pid_t pid, pid_t pgid);
 
+  /** 
+     PACE's implementation of the POSIX function setsid.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 4.3.2.
+   */
   PACE_INLINE pace_pid_t pace_setsid ();
 
+  /** 
+     PACE's implementation of the POSIX function setuid.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 4.2.2.
+   */
   PACE_INLINE int pace_setuid (uid_t uid);
 
+  /** 
+     PACE's implementation of the POSIX function sleep.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 3.4.3.
+   */
   PACE_INLINE unsigned pace_sleep (unsigned int seconds);
 
+  /** 
+     PACE's implementation of the POSIX function sysconf.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 4.8.1.
+   */
   PACE_INLINE long pace_sysconf (int name);
 
+  /** 
+     PACE's implementation of the POSIX function ttyname.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 4.7.2.
+   */
   PACE_INLINE char * pace_ttyname (int fildes);
 
+  /** 
+     PACE's implementation of the POSIX function ttyname_r.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 4.7.2.
+   */
   PACE_INLINE int pace_ttyname_r (int fildes, char * name, size_t namesize);
   /* Requires PACE_HAS_POSIX_PTHREAD_SEMANTICS. */
 
+  /** 
+     PACE's implementation of the POSIX function unlink.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 5.5.1.
+   */
   PACE_INLINE int pace_unlink (const char * path);
 
+  /** 
+     PACE's implementation of the POSIX function write.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 6.4.2.
+   */
   PACE_INLINE ssize_t pace_write (int fildes, const void * buf, size_t nbyte);
 
 #if defined (PACE_HAS_CPLUSPLUS)
diff --git a/PACE/pace/posix/utime.h b/PACE/pace/posix/utime.h
index 1a2e283cf57..1c74096fe52 100644
--- a/PACE/pace/posix/utime.h
+++ b/PACE/pace/posix/utime.h
@@ -23,6 +23,11 @@
 extern "C" {
 #endif /* PACE_HAS_CPLUSPLUS */
 
+  /** 
+     PACE's implementation of the POSIX function utime.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 5.6.6.
+   */
   PACE_INLINE int pace_utime (const char * path,
                               const struct utimbuf * times);
 
diff --git a/PACE/pace/posix/wait.h b/PACE/pace/posix/wait.h
index 551bd87698f..e73867fb026 100644
--- a/PACE/pace/posix/wait.h
+++ b/PACE/pace/posix/wait.h
@@ -22,8 +22,18 @@
 extern "C" {
 #endif /* PACE_HAS_CPLUSPLUS */
 
+  /** 
+     PACE's implementation of the POSIX function wait.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 3.2.1.
+   */
   PACE_INLINE pid_t pace_wait (int * statloc);
 
+  /** 
+     PACE's implementation of the POSIX function waitpid.
+     See POSIX standard (Internation Standard ISO/IEC 9945-1:1996;
+     IEEE Std 1003.1, 1996 Edition), Section 3.2.1.
+   */
   PACE_INLINE pid_t pace_waitpid (pid_t pid,
                                   int * statloc,
                                   int options);