1 files changed, 144 insertions, 121 deletions

diff --git a/include/spawn.h b/include/spawn.h
index 8b07bb800..95fff356f 100644
--- a/include/spawn.h
+++ b/include/spawn.h
@@ -19,36 +19,39 @@
 #ifndef	_SPAWN_H
 #define	_SPAWN_H	1
 
-#include <errno.h>
-#include <string.h>
-#include <stdlib.h>
-
 #include <features.h>
 #include <sched.h>
 #define __need_sigset_t
 #include <signal.h>
 #include <sys/types.h>
 
+/* For the tiny inlines (errno/free/memset).  */
+#include <errno.h>
+#include <string.h>
+#include <stdlib.h>
+
 
 /* Data structure to contain attributes for thread creation.  */
-typedef struct {
-	short int __flags;
-	pid_t __pgrp;
-	sigset_t __sd;
-	sigset_t __ss;
-	struct sched_param __sp;
-	int __policy;
-	int __pad[16];
+typedef struct
+{
+  short int __flags;
+  pid_t __pgrp;
+  sigset_t __sd;
+  sigset_t __ss;
+  struct sched_param __sp;
+  int __policy;
+  int __pad[16];
 } posix_spawnattr_t;
 
 
 /* Data structure to contain information about the actions to be
    performed in the new process with respect to file descriptors.  */
-typedef struct {
-	int __allocated;
-	int __used;
-	struct __spawn_action *__actions;
-	int __pad[16];
+typedef struct
+{
+  int __allocated;
+  int __used;
+  struct __spawn_action *__actions;
+  int __pad[16];
 } posix_spawn_file_actions_t;
 
 
@@ -59,7 +62,9 @@ typedef struct {
 #define POSIX_SPAWN_SETSIGMASK		0x08
 #define POSIX_SPAWN_SETSCHEDPARAM	0x10
 #define POSIX_SPAWN_SETSCHEDULER	0x20
-#define POSIX_SPAWN_USEVFORK		0x40 /* GNU extension */
+#ifdef __USE_GNU
+# define POSIX_SPAWN_USEVFORK		0x40
+#endif
 
 
 #define __POSIX_SPAWN_MASK (POSIX_SPAWN_RESETIDS		\
@@ -77,189 +82,207 @@ __BEGIN_DECLS
 
    This function is a possible cancellation point and therefore not
    marked with __THROW. */
-int posix_spawn(pid_t * restrict pid, const char * restrict path,
-		const posix_spawn_file_actions_t * restrict file_actions,
-		const posix_spawnattr_t * restrict attrp,
-		char * const argv[restrict],
-		char * const envp[restrict]);
+extern int posix_spawn (pid_t *__restrict __pid,
+			const char *__restrict __path,
+			const posix_spawn_file_actions_t *__restrict
+			__file_actions,
+			const posix_spawnattr_t *__restrict __attrp,
+			char *const __argv[__restrict_arr],
+			char *const __envp[__restrict_arr]);
 
 /* Similar to `posix_spawn' but search for FILE in the PATH.
 
    This function is a possible cancellation point and therefore not
    marked with __THROW.  */
-int posix_spawnp(pid_t *pid, const char *file,
-		 const posix_spawn_file_actions_t *file_actions,
-		 const posix_spawnattr_t *attrp,
-		 char * const argv[], char * const envp[]);
-
-/* Initialize data structure with attributes for `spawn' to default values. */
-inline static int
-posix_spawnattr_init(posix_spawnattr_t *attr)
+extern int posix_spawnp (pid_t *__pid, const char *__file,
+			 const posix_spawn_file_actions_t *__file_actions,
+			 const posix_spawnattr_t *__attrp,
+			 char *const __argv[], char *const __envp[]);
+
+
+/* Initialize data structure with attributes for `spawn' to default values.  */
+static inline
+int posix_spawnattr_init (posix_spawnattr_t *__attr)
 {
-	memset(attr, 0, sizeof(*attr));
-	return 0;
+  memset (__attr, 0, sizeof (*__attr));
+  return 0;
 }
 
 /* Free resources associated with ATTR.  */
-inline static int
-posix_spawnattr_destroy(posix_spawnattr_t *attr)
+static inline
+int posix_spawnattr_destroy (posix_spawnattr_t *__attr)
 {
-	return 0;
+  return 0;
 }
 
 /* Store signal mask for signals with default handling from ATTR in
    SIGDEFAULT.  */
-inline static int
-posix_spawnattr_getsigdefault(const posix_spawnattr_t *attr,
-			      sigset_t *sigdefault)
+static inline
+int posix_spawnattr_getsigdefault (const posix_spawnattr_t *
+					  __restrict __attr,
+					  sigset_t *__restrict __sigdefault)
 {
-	memcpy(sigdefault, &attr->__sd, sizeof(sigset_t));
-	return 0;
+  memcpy (__sigdefault, &__attr->__sd, sizeof (sigset_t));
+  return 0;
 }
 
-
 /* Set signal mask for signals with default handling in ATTR to SIGDEFAULT.  */
-inline static int
-posix_spawnattr_setsigdefault(posix_spawnattr_t *attr,
-			      const sigset_t *sigdefault)
+static inline
+int posix_spawnattr_setsigdefault (posix_spawnattr_t *__restrict __attr,
+					  const sigset_t *__restrict
+					  __sigdefault)
 {
-	memcpy(&attr->__sd, sigdefault, sizeof(sigset_t));
-	return 0;
+  memcpy (&__attr->__sd, __sigdefault, sizeof (sigset_t));
+  return 0;
 }
 
 /* Store signal mask for the new process from ATTR in SIGMASK.  */
-inline static int
-posix_spawnattr_getsigmask(const posix_spawnattr_t *attr,
-			   sigset_t *sigmask)
+static inline
+int posix_spawnattr_getsigmask (const posix_spawnattr_t *__restrict
+				       __attr,
+				       sigset_t *__restrict __sigmask)
 {
-	memcpy(sigmask, &attr->__ss, sizeof(sigset_t));
-	return 0;
+  memcpy (__sigmask, &__attr->__ss, sizeof (sigset_t));
+  return 0;
 }
 
-
 /* Set signal mask for the new process in ATTR to SIGMASK.  */
-inline static int
-posix_spawnattr_setsigmask(posix_spawnattr_t *attr,
-			   const sigset_t *sigmask)
+static inline
+int posix_spawnattr_setsigmask (posix_spawnattr_t *__restrict __attr,
+				       const sigset_t *__restrict __sigmask)
 {
-	memcpy(&attr->__ss, sigmask, sizeof(sigset_t));
-	return 0;
+  memcpy (&__attr->__ss, __sigmask, sizeof (sigset_t));
+  return 0;
 }
 
 /* Get flag word from the attribute structure.  */
-inline static int
-posix_spawnattr_getflags(const posix_spawnattr_t *attr, short int *flags)
+static inline
+int posix_spawnattr_getflags (const posix_spawnattr_t *__restrict
+				     __attr,
+				     short int *__restrict __flags)
 {
-	*flags = attr->__flags;
-	return 0;
+  *__flags = __attr->__flags;
+  return 0;
 }
 
 /* Store flags in the attribute structure.  */
-inline static int
-posix_spawnattr_setflags(posix_spawnattr_t *attr, short int flags)
+static inline
+int posix_spawnattr_setflags (posix_spawnattr_t *_attr,
+				     short int __flags)
 {
-	/* Check no invalid bits are set.  */
-	if (flags & ~__POSIX_SPAWN_MASK)
-		return EINVAL;
+  /* Check no invalid bits are set.  */
+  if (__flags & ~__POSIX_SPAWN_MASK)
+    return EINVAL;
 
-	attr->__flags = flags;
-	return 0;
+  _attr->__flags = __flags;
+  return 0;
 }
 
 /* Get process group ID from the attribute structure.  */
-inline static int
-posix_spawnattr_getpgroup(const posix_spawnattr_t *attr, pid_t *pgroup)
+static inline
+int posix_spawnattr_getpgroup (const posix_spawnattr_t *__restrict
+				      __attr, pid_t *__restrict __pgroup)
 {
-	*pgroup = attr->__pgrp;
-	return 0;
+  *__pgroup = __attr->__pgrp;
+  return 0;
 }
 
 /* Store process group ID in the attribute structure.  */
-inline static int
-posix_spawnattr_setpgroup(posix_spawnattr_t *attr, pid_t pgroup)
+static inline
+int posix_spawnattr_setpgroup (posix_spawnattr_t *__attr,
+				      pid_t __pgroup)
 {
-	attr->__pgrp = pgroup;
-	return 0;
+  __attr->__pgrp = __pgroup;
+  return 0;
 }
 
 /* Get scheduling policy from the attribute structure.  */
-inline static int
-posix_spawnattr_getschedpolicy(const posix_spawnattr_t *attr,
-			       int *schedpolicy)
+static inline
+int posix_spawnattr_getschedpolicy (const posix_spawnattr_t *
+					   __restrict __attr,
+					   int *__restrict __schedpolicy)
 {
-	*schedpolicy = attr->__policy;
-	return 0;
+  *__schedpolicy = __attr->__policy;
+  return 0;
 }
 
 /* Store scheduling policy in the attribute structure.  */
-inline static int
-posix_spawnattr_setschedpolicy(posix_spawnattr_t *attr, int schedpolicy)
+static inline
+int posix_spawnattr_setschedpolicy (posix_spawnattr_t *__attr,
+					   int __schedpolicy)
 {
-	switch (schedpolicy) {
-	case SCHED_OTHER:
-	case SCHED_FIFO:
-	case SCHED_RR:
-		break;
-	default:
-		return EINVAL;
-	}
-
-	attr->__policy = schedpolicy;
-	return 0;
+  switch (__schedpolicy) {
+  case SCHED_OTHER:
+  case SCHED_FIFO:
+  case SCHED_RR:
+    break;
+  default:
+    return EINVAL;
+  }
+
+  __attr->__policy = __schedpolicy;
+  return 0;
 }
 
 /* Get scheduling parameters from the attribute structure.  */
-static inline int
-posix_spawnattr_getschedparam(const posix_spawnattr_t *attr,
-			      struct sched_param *schedparam)
+static inline
+int posix_spawnattr_getschedparam (const posix_spawnattr_t *
+					  __restrict __attr,
+					  struct sched_param *__restrict
+					  __schedparam)
 {
-	memcpy(schedparam, &attr->__sp, sizeof(attr->__sp));
-	return 0;
+  memcpy (__schedparam, &__attr->__sp, sizeof (__attr->__sp));
+  return 0;
 }
 
 /* Store scheduling parameters in the attribute structure.  */
-static inline int
-posix_spawnattr_setschedparam(posix_spawnattr_t *attr,
-			      const struct sched_param *schedparam)
+static inline
+int posix_spawnattr_setschedparam (posix_spawnattr_t *__restrict __attr,
+					  const struct sched_param *
+					  __restrict __schedparam)
 {
-	attr->__sp = *schedparam;
-	return 0;
+  __attr->__sp = *__schedparam;
+  return 0;
 }
 
 /* Initialize data structure for file attribute for `spawn' call.  */
-inline static int
-posix_spawn_file_actions_init(posix_spawn_file_actions_t *file_actions)
+static inline
+int posix_spawn_file_actions_init (posix_spawn_file_actions_t *
+					  __file_actions)
 {
-	memset(file_actions, 0, sizeof(*file_actions));
-	return 0;
+  memset (__file_actions, 0, sizeof (*__file_actions));
+  return 0;
 }
 
 /* Free resources associated with FILE-ACTIONS.  */
-inline static int
-posix_spawn_file_actions_destroy(posix_spawn_file_actions_t *file_actions)
+static inline
+int posix_spawn_file_actions_destroy (posix_spawn_file_actions_t *
+					     __file_actions)
 {
-	free(file_actions->__actions);
-	return 0;
+  free (__file_actions->__actions);
+  return 0;
 }
 
 /* Add an action to FILE-ACTIONS which tells the implementation to call
    `open' for the given file during the `spawn' call.  */
-int posix_spawn_file_actions_addopen(posix_spawn_file_actions_t * restrict
-				     file_actions, int fd,
-				     const char * restrict path,
-				     int oflag, mode_t mode)
+extern int posix_spawn_file_actions_addopen (posix_spawn_file_actions_t *
+					     __restrict __file_actions,
+					     int __fd,
+					     const char *__restrict __path,
+					     int __oflag, mode_t __mode)
      __THROW;
 
 /* Add an action to FILE-ACTIONS which tells the implementation to call
    `close' for the given file descriptor during the `spawn' call.  */
-int posix_spawn_file_actions_addclose(posix_spawn_file_actions_t *file_actions,
-				      int fd)
+extern int posix_spawn_file_actions_addclose (posix_spawn_file_actions_t *
+					      __file_actions, int __fd)
      __THROW;
 
 /* Add an action to FILE-ACTIONS which tells the implementation to call
    `dup2' for the given file descriptors during the `spawn' call.  */
-int posix_spawn_file_actions_adddup2(posix_spawn_file_actions_t *file_actions,
-				     int fd, int newfd) __THROW;
+extern int posix_spawn_file_actions_adddup2 (posix_spawn_file_actions_t *
+					     __file_actions,
+					     int __fd, int __newfd) __THROW;
 
 __END_DECLS