main/libc0.9.32: backport posix_spawn fix

This should fix the following error when compiling posix-spawn ruby gem:

In file included from posix-spawn.c:9:0:
/usr/include/spawn.h:80:34: error: expected ';', ',' or ')' before 'pid'
 int posix_spawn(pid_t * restrict pid, const char * restrict path,
                                  ^
/usr/include/spawn.h:248:10: error: expected ';', ',' or ')' before 'file_actions'
          file_actions, int fd,
          ^

1 files changed, 399 insertions, 0 deletions

diff --git a/main/libc0.9.32/spawn-use-glibc-style-to-keep-differences-down.patch b/main/libc0.9.32/spawn-use-glibc-style-to-keep-differences-down.patch
new file mode 100644
index 0000000000..170c23840c
--- /dev/null
+++ b/main/libc0.9.32/spawn-use-glibc-style-to-keep-differences-down.patch
@@ -0,0 +1,399 @@
+From 54935c23e92c7f948ea3c561b3fac7cd4deac22a Mon Sep 17 00:00:00 2001
+From: Mike Frysinger <vapier@gentoo.org>
+Date: Tue, 27 Mar 2012 03:34:37 +0000
+Subject: spawn: use glibc style to keep differences down
+
+There's no point in reformatting the code style when we're sourcing
+most of it from glibc.  Further, the changed style breaks with older
+compilers, and pollutes the namespace with non-double leading under-
+scores.
+
+Signed-off-by: Mike Frysinger <vapier@gentoo.org>
+---
+(limited to 'include/spawn.h')
+
+diff --git a/include/spawn.h b/include/spawn.h
+index 8b07bb8..95fff35 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
+ 
+--
+cgit v0.9.1