AuroraMiddleware/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2024-11-05 21:00:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

Update.

Browse Source 
1998-06-30 11:47  Ulrich Drepper  <drepper@cygnus.com>

	* include/aio.h: New file.
	* posix/Makefile (distribute): Add bits/pthreadtypes.h.
	(tests): Build and run annexc program.
	* posix/annexc.c: New file.
	* posix/bits/posix1_lim.h: Add several more _POSIX_* limits.
	* rt/aio.h: Remove __need_timespec_t.  We can include the whole time.h.
	* rt/aio_misc.c: Include limits.h.
	* rt/aio_notify.c: Include errno.h.
	* sysdeps/unix/sysv/linux/alpha/bits/types.h: Include pthreadtypes.h.
	Define size_t.
	* sysdeps/unix/sysv/linux/bits/types.h: Likewise.
	* sysdeps/unix/sysv/linux/mips/bits/types.h: Likewise.
	* sysdeps/unix/sysv/linux/sparc/sparc64/bits/types.h: Likewise.
	* sysdeps/unix/sysv/linux/bits/errno.h: Define ENOTSUP though the
	kernel doesn't do this.
	* sysdeps/unix/sysv/linux/bits/fcntl.h: Define O_LARGEFILE only if
	__USE_LARGEFILE64 is defined.
	* sysdeps/unix/sysv/linux/bits/pthreadtypes.h: New file.  Empty.
	* sysdeps/unix/sysv/linux/bits/sched.h: Define __sched_param struct
	if requested.
	* sysdeps/unix/sysv/linux/bits/siginifo.h: Protect non-standard names.

	* stdlib/isomac.c: Avoid include_next warning.
This commit is contained in:
Ulrich Drepper 1998-06-30 12:09:42 +00:00
parent fdacb17d48
commit 4959e310bf
28 changed files with 1146 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
ChangeLog
View File

@ -1,3 +1,29 @@
1998-06-30 11:47 Ulrich Drepper <drepper@cygnus.com>
* include/aio.h: New file.
* posix/Makefile (distribute): Add bits/pthreadtypes.h.
(tests): Build and run annexc program.
* posix/annexc.c: New file.
* posix/bits/posix1_lim.h: Add several more _POSIX_* limits.
* rt/aio.h: Remove __need_timespec_t. We can include the whole time.h.
* rt/aio_misc.c: Include limits.h.
* rt/aio_notify.c: Include errno.h.
* sysdeps/unix/sysv/linux/alpha/bits/types.h: Include pthreadtypes.h.
Define size_t.
* sysdeps/unix/sysv/linux/bits/types.h: Likewise.
* sysdeps/unix/sysv/linux/mips/bits/types.h: Likewise.
* sysdeps/unix/sysv/linux/sparc/sparc64/bits/types.h: Likewise.
* sysdeps/unix/sysv/linux/bits/errno.h: Define ENOTSUP though the
kernel doesn't do this.
* sysdeps/unix/sysv/linux/bits/fcntl.h: Define O_LARGEFILE only if
__USE_LARGEFILE64 is defined.
* sysdeps/unix/sysv/linux/bits/pthreadtypes.h: New file. Empty.
* sysdeps/unix/sysv/linux/bits/sched.h: Define __sched_param struct
if requested.
* sysdeps/unix/sysv/linux/bits/siginifo.h: Protect non-standard names.
* stdlib/isomac.c: Avoid include_next warning.
1998-06-29 12:27 Ulrich Drepper <drepper@cygnus.com>
* argp/argp.h: Use __PMT instead of __P for function pointer.

1
include/aio.h Normal file
View File

@ -0,0 +1 @@
#include <rt/aio.h>

5
linuxthreads/attr.c
View File

@ -14,6 +14,7 @@
/* Handling of thread attributes */
#include <errno.h>
#include <unistd.h>
#include <sys/param.h>
#include "pthread.h"
@ -79,14 +80,14 @@ int pthread_attr_setschedparam(pthread_attr_t *attr,
if (param->sched_priority < min_prio || param->sched_priority > max_prio)
return EINVAL;
attr->schedparam = *param;
memcpy (&attr->schedparam, param, sizeof (struct sched_param));
return 0;
}
int pthread_attr_getschedparam(const pthread_attr_t *attr,
struct sched_param *param)
{
*param = attr->schedparam;
memcpy (param, &attr->schedparam, sizeof (struct sched_param));
return 0;
}

1
linuxthreads/internals.h
View File

@ -17,6 +17,7 @@
/* Includes */
#include <bits/libc-lock.h> /* for _LIBC_TSD_KEY_N */
#include <limits.h>
#include <setjmp.h>
#include <signal.h>
#include <unistd.h>

3
linuxthreads/manager.c
View File

@ -303,7 +303,8 @@ static int pthread_handle_create(pthread_t *thread, const pthread_attr_t *attr,
switch(attr->inheritsched) {
case PTHREAD_EXPLICIT_SCHED:
new_thread->p_start_args.schedpolicy = attr->schedpolicy;
new_thread->p_start_args.schedparam = attr->schedparam;
memcpy (&new_thread->p_start_args.schedparam, &attr->schedparam,
sizeof (struct sched_param));
break;
case PTHREAD_INHERIT_SCHED:
/* schedpolicy doesn't need to be set, only get priority */

1
linuxthreads/ptfork.c
View File

@ -14,6 +14,7 @@
/* The "atfork" stuff */
#include <errno.h>
#include <stddef.h>
#include <stdlib.h>
#include <unistd.h>

1
linuxthreads/pthread.c
View File

@ -14,6 +14,7 @@
/* Thread creation, initialization, and basic low-level routines */
#include <errno.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>

1
linuxthreads/semaphore.c
View File

@ -14,6 +14,7 @@
/* Semaphores a la POSIX 1003.1b */
#include <errno.h>
#include "pthread.h"
#include "semaphore.h"
#include "internals.h"

1
linuxthreads/specific.c
View File

@ -14,6 +14,7 @@
/* Thread-specific data */
#include <errno.h>
#include <stddef.h>
#include <stdlib.h>
#include "pthread.h"

1
linuxthreads/spinlock.c
View File

@ -14,6 +14,7 @@
/* Internal locks */
#include <errno.h>
#include <sched.h>
#include <time.h>
#include "pthread.h"

119
linuxthreads/sysdeps/pthread/bits/pthreadtypes.h Normal file
View File

@ -0,0 +1,119 @@
/* Linuxthreads - a simple clone()-based implementation of Posix */
/* threads for Linux. */
/* Copyright (C) 1996 Xavier Leroy (Xavier.Leroy@inria.fr) */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU Library General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU Library General Public License for more details. */
#if !defined _BITS_TYPES_H && !defined _PTHREAD_H
# error "Never include <bits/pthreadtypes.h> directly; use <sys/types.h> instead."
#endif
#ifndef _BITS_PTHREADTYPES_H
#define _BITS_PTHREADTYPES_H 1
#define __need_schedparam
#include <bits/sched.h>
/* Fast locks (not abstract because mutexes and conditions aren't abstract). */
struct _pthread_fastlock
{
long int status; /* "Free" or "taken" or head of waiting list */
int spinlock; /* For compare-and-swap emulation */
};
/* Thread descriptors */
typedef struct _pthread_descr_struct *_pthread_descr;
/* Attributes for threads. */
typedef struct
{
int detachstate;
int schedpolicy;
struct __sched_param schedparam;
int inheritsched;
int scope;
size_t guardsize;
int stackaddr_set;
void *stackaddr;
size_t stacksize;
} pthread_attr_t;
/* Conditions (not abstract because of PTHREAD_COND_INITIALIZER */
typedef struct
{
struct _pthread_fastlock c_lock; /* Protect against concurrent access */
_pthread_descr c_waiting; /* Threads waiting on this condition */
} pthread_cond_t;
/* Attribute for conditionally variables. */
typedef struct
{
int dummy;
} pthread_condattr_t;
/* Keys for thread-specific data */
typedef unsigned int pthread_key_t;
/* Mutexes (not abstract because of PTHREAD_MUTEX_INITIALIZER). */
/* (The layout is unnatural to maintain binary compatibility
with earlier releases of LinuxThreads.) */
typedef struct
{
int m_reserved; /* Reserved for future use */
int m_count; /* Depth of recursive locking */
_pthread_descr m_owner; /* Owner thread (if recursive or errcheck) */
int m_kind; /* Mutex kind: fast, recursive or errcheck */
struct _pthread_fastlock m_lock; /* Underlying fast lock */
} pthread_mutex_t;
/* Attribute for mutex. */
typedef struct
{
int mutexkind;
} pthread_mutexattr_t;
/* Once-only execution */
typedef int pthread_once_t;
#ifdef __USE_UNIX98
/* Read-write locks. */
typedef struct
{
struct _pthread_fastlock rw_lock; /* Lock to guarantee mutual exclusion */
int rw_readers; /* Number of readers */
_pthread_descr rw_writer; /* Identity of writer, or NULL if none */
_pthread_descr rw_read_waiting; /* Threads waiting for reading */
_pthread_descr rw_write_waiting; /* Threads waiting for writing */
int rw_kind; /* Reader/Writer preference selection */
int rw_pshared; /* Shared between processes or not */
} pthread_rwlock_t;
/* Attribute for read-write locks. */
typedef struct
{
int lockkind;
int pshared;
} pthread_rwlockattr_t;
#endif
/* Thread identifiers */
typedef unsigned long int pthread_t;
#endif /* bits/pthreadtypes.h */

116
linuxthreads/sysdeps/pthread/pthread.h
View File

@ -17,85 +17,34 @@
#include <features.h>
#include <errno.h>
#include <limits.h>
#include <sched.h>
#include <unistd.h>
#include <time.h>
#define __need_sigset_t
#include <signal.h>
#define __need_timespec
#include <time.h>
/* Linux has no ENOTSUP error code. */
#ifndef ENOTSUP
#define ENOTSUP EOPNOTSUPP
#endif
#include <bits/pthreadtypes.h>
__BEGIN_DECLS
/*** Types ***/
/* Thread identifiers */
typedef unsigned long int pthread_t;
/* Thread descriptors */
typedef struct _pthread_descr_struct *_pthread_descr;
/* Fast locks (not abstract because mutexes and conditions aren't abstract). */
struct _pthread_fastlock
{
long int status; /* "Free" or "taken" or head of waiting list */
int spinlock; /* For compare-and-swap emulation */
};
/* Mutexes (not abstract because of PTHREAD_MUTEX_INITIALIZER). */
/* (The layout is unnatural to maintain binary compatibility
with earlier releases of LinuxThreads.) */
typedef struct
{
int m_reserved; /* Reserved for future use */
int m_count; /* Depth of recursive locking */
_pthread_descr m_owner; /* Owner thread (if recursive or errcheck) */
int m_kind; /* Mutex kind: fast, recursive or errcheck */
struct _pthread_fastlock m_lock; /* Underlying fast lock */
} pthread_mutex_t;
/* Initializers. */
#define PTHREAD_MUTEX_INITIALIZER \
{0, 0, 0, PTHREAD_MUTEX_FAST_NP, {0, 0}}
#define PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP \
#ifdef __USE_GNU
# define PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP \
{0, 0, 0, PTHREAD_MUTEX_RECURSIVE_NP, {0, 0}}
/* Conditions (not abstract because of PTHREAD_COND_INITIALIZER */
typedef struct
{
struct _pthread_fastlock c_lock; /* Protect against concurrent access */
_pthread_descr c_waiting; /* Threads waiting on this condition */
} pthread_cond_t;
#endif
#define PTHREAD_COND_INITIALIZER {{0, 0}, 0}
#ifdef __USE_UNIX98
/* Read-write locks. */
typedef struct
{
struct _pthread_fastlock rw_lock; /* Lock to guarantee mutual exclusion */
int rw_readers; /* Number of readers */
_pthread_descr rw_writer; /* Identity of writer, or NULL if none */
_pthread_descr rw_read_waiting; /* Threads waiting for reading */
_pthread_descr rw_write_waiting; /* Threads waiting for writing */
int rw_kind; /* Reader/Writer preference selection */
int rw_pshared; /* Shared between processes or not */
} pthread_rwlock_t;
# define PTHREAD_RWLOCK_INITIALIZER \
{ {0, 0}, 0, NULL, NULL, NULL, \
PTHREAD_RWLOCK_DEFAULT_NP, PTHREAD_PROCESS_PRIVATE }
#endif
/* Attributes */
/* Values for attributes. */
enum
{
@ -121,19 +70,6 @@ enum
#define PTHREAD_SCOPE_PROCESS PTHREAD_SCOPE_PROCESS
};
typedef struct
{
int detachstate;
int schedpolicy;
struct sched_param schedparam;
int inheritsched;
int scope;
size_t guardsize;
int stackaddr_set;
void *stackaddr;
size_t stacksize;
} pthread_attr_t;
enum
{
PTHREAD_MUTEX_FAST_NP,
@ -148,46 +84,22 @@ enum
#endif
};
typedef struct
{
int mutexkind;
} pthread_mutexattr_t;
typedef struct
{
int dummy;
} pthread_condattr_t;
#ifdef __USE_UNIX98
enum
{
PTHREAD_PROCESS_PRIVATE,
# define PTHREAD_PROCESS_PRIVATE PTHREAD_PROCESS_PRIVATE
#define PTHREAD_PROCESS_PRIVATE PTHREAD_PROCESS_PRIVATE
PTHREAD_PROCESS_SHARED
# define PTHREAD_PROCESS_SHARED PTHREAD_PROCESS_SHARED
#define PTHREAD_PROCESS_SHARED PTHREAD_PROCESS_SHARED
};
#ifdef __USE_UNIX98
enum
{
PTHREAD_RWLOCK_PREFER_READER_NP,
PTHREAD_RWLOCK_PREFER_WRITER_NP,
PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_WRITER_NP
};
typedef struct
{
int lockkind;
int pshared;
} pthread_rwlockattr_t;
#endif
/* Keys for thread-specific data */
typedef unsigned int pthread_key_t;
/* Once-only execution */
typedef int pthread_once_t;
#endif /* Unix98 */
#define PTHREAD_ONCE_INIT 0
@ -592,7 +504,8 @@ extern void _pthread_cleanup_pop __P ((struct _pthread_cleanup_buffer *__buffer,
/* Install a cleanup handler as pthread_cleanup_push does, but also
saves the current cancellation type and set it to deferred cancellation. */
#define pthread_cleanup_push_defer_np(routine,arg) \
#ifdef __USE_GNU
# define pthread_cleanup_push_defer_np(routine,arg) \
{ struct _pthread_cleanup_buffer _buffer; \
_pthread_cleanup_push_defer (&_buffer, (routine), (arg));
@ -604,11 +517,12 @@ extern void _pthread_cleanup_push_defer __P ((struct _pthread_cleanup_buffer *__
restores the cancellation type that was in effect when the matching
pthread_cleanup_push_defer was called. */
#define pthread_cleanup_pop_restore_np(execute) \
# define pthread_cleanup_pop_restore_np(execute) \
_pthread_cleanup_pop_restore (&_buffer, (execute)); }
extern void _pthread_cleanup_pop_restore __P ((struct _pthread_cleanup_buffer *__buffer,
int __execute));
#endif
/* Functions for handling signals. */

11
posix/Makefile
View File

@ -26,7 +26,8 @@ headers := sys/utsname.h sys/times.h sys/wait.h sys/types.h unistd.h \
bits/posix1_lim.h bits/posix2_lim.h bits/posix_opt.h \
bits/local_lim.h tar.h bits/utsname.h bits/confname.h \
bits/waitflags.h bits/waitstatus.h sys/unistd.h sched.h \
bits/sched.h re_comp.h wait.h bits/environments.h cpio.h
bits/sched.h re_comp.h wait.h bits/environments.h cpio.h \
bits/pthreadtypes.h
distribute := confstr.h TESTS TESTS2C.sed testcases.h \
PTESTS PTESTS2C.sed ptestcases.h \
@ -132,3 +133,11 @@ endif
%.gz: %
gzip -9v -c $< > $@-tmp
mv $@-tmp $@
# Run a test on the header files we use.
# XXX Please note that for now we ignore the result of this test.
tests: $(objpfx)annexc
-$(dir $<)$(notdir $<) '$(CC)' '-I../include -I../include -I.. $(+sysdep-includes) -I../include -I../include -I..' > $<.out
$(objpfx)annexc: annexc.c
$(native-compile)

867
posix/annexc.c Normal file
View File

@ -0,0 +1,867 @@
/* Copyright (C) 1998 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with the GNU C Library; see the file COPYING.LIB. If not,
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#include <ctype.h>
#include <fnmatch.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#define TMPFILE "/tmp/macros"
#define HEADER_MAX 256
/* <aio.h>. */
static const char *const aio_syms[] =
{
"AIO_ALLDONE", "AIO_CANCELED", "AIO_NOTCANCELED", "LIO_NOP", "LIO_NOWAIT",
"LIO_READ", "LIO_WAIT", "LIO_WRITE",
/* From <fcntl.h>. */
"FD_CLOEXEC", "F_DUPFD", "F_GETFD", "F_GETFL", "F_GETLK", "F_RDLCK",
"F_SETFD", "F_SETFL", "F_SETLK", "F_SETLKW", "F_UNLCK", "F_WRLCK",
"O_ACCMODE", "O_APPEND", "O_CREAT", "O_DSYNC", "O_EXCL", "O_NOCTTY",
"O_NONBLOCK", "O_RDONLY", "O_RDWR", "O_RSYNC", "O_SYNC", "O_TRUNC",
"O_WRONLY",
/* From <signal.h>. */
"SA_NOCLDSTOP", "SA_SIGINFO", "SIGABRT", "SIGALRM", "SIGBUS", "SIGCHLD",
"SIGCONT", "SIGEV_NONE", "SIGEV_SIGNAL", "SIGEV_SIGNAL", "SIGEV_THREAD",
"SIGFPE", "SIGHUP", "SIGILL", "SIGINT", "SIGKILL", "SIGPIPE", "SIGQUIT",
"SIGRTMAX", "SIGRTMIN", "SIGSEGV", "SIGSTOP", "SIGTERM", "SIGTSTP",
"SIGTTIN", "SIGTTOU", "SIGUSR1", "SIGUSR2", "SIG_BLOCK", "SIG_DFL",
"SIG_ERR", "SIG_IGN", "SIG_SETMASK", "SIG_UNBLOCK", "SI_ASYNCIO",
"SI_MESGQ", "SI_QUEUE", "SI_TIMER", "SI_USER"
};
static const char *const aio_maybe[] =
{
"aio_cancel", "aio_error", "aio_fsync", "aio_read", "aio_return",
"aio_suspend", "aio_write", "lio_listio",
/* From <fcntl.h>. */
"creat", "fcntl", "open", "SEEK_CUR", "SEEK_END", "SEEK_SET", "S_IRGRP",
"S_IROTH", "S_IRUSR", "S_IRWXG", "S_IRWXO", "S_IRWXU", "S_ISBLK",
"S_ISCHR", "S_ISDIR", "S_ISFIFO", "S_ISGID", "S_ISREG", "S_ISUID",
"S_IWGRP", "S_IWOTH", "S_IWUSR", "S_IXGRP", "S_IXOTH", "S_IXUSR",
/* From <signal.h>. */
"kill", "raise", "sigaction", "sigaddset", "sigdelset", "sigemptyset",
"sigfillset", "sigismember", "signal", "sigpending", "sigprocmask",
"sigqueue", "sigsuspend", "sigtimedwait", "sigwait", "sigwaitinfo"
};
/* <assert.h>. */
static const char *const assert_syms[] =
{
"assert"
};
static const char *const assert_maybe[] =
{
};
/* <ctype.h>. */
static const char *const ctype_syms[] =
{
};
static const char *const ctype_maybe[] =
{
"isalnum", "isalpha", "iscntrl", "isdigit", "isgraph", "islower",
"isprint", "ispunct", "isspace", "isupper", "isxdigit", "tolower",
"toupper"
};
/* <dirent.h>. */
static const char *const dirent_syms[] =
{
};
static const char *const dirent_maybe[] =
{
"closedir", "opendir", "readdir", "readdir_r", "rewinddir"
};
/* <errno.h>. */
static const char *const errno_syms[] =
{
"E2BIG", "EACCESS", "EAGAIN", "EBADF", "EBADMSG", "EBUSY", "ECANCELED",
"ECHILD", "EDEADLK", "EDOM", "EEXIST", "EFAULT", "EFBIG", "EINPROGRESS",
"EINTR", "EINVAL", "EIO", "EISDIR", "EMFILE", "EMLINK", "EMSGSIZE",
"ENAMETOOLONG", "ENFILE", "ENODEV", "ENOENT", "ENOEXEC", "ENOLCK",
"ENOMEM", "ENOSPC", "ENOSYS", "ENOTDIR", "ENOTEMPTY", "ENOTSUP",
"ENOTTY", "ENXIO", "EPERM", "EPIPE", "ERANGE", "EROFS", "ESPIPE",
"ESRCH", "ETIMEDOUT", "EXDEV"
};
static const char *const errno_maybe[] =
{
"errno", "E*"
};
/* <fcntl.h>. */
static const char *const fcntl_syms[] =
{
"FD_CLOEXEC", "F_DUPFD", "F_GETFD", "F_GETFL", "F_GETLK", "F_RDLCK",
"F_SETFD", "F_SETFL", "F_SETLK", "F_SETLKW", "F_UNLCK", "F_WRLCK",
"O_ACCMODE", "O_APPEND", "O_CREAT", "O_DSYNC", "O_EXCL", "O_NOCTTY",
"O_NONBLOCK", "O_RDONLY", "O_RDWR", "O_RSYNC", "O_SYNC", "O_TRUNC",
"O_WRONLY"
};
static const char *const fcntl_maybe[] =
{
"creat", "fcntl", "open", "SEEK_CUR", "SEEK_END", "SEEK_SET", "S_IRGRP",
"S_IROTH", "S_IRUSR", "S_IRWXG", "S_IRWXO", "S_IRWXU", "S_ISBLK",
"S_ISCHR", "S_ISDIR", "S_ISFIFO", "S_ISGID", "S_ISREG", "S_ISUID",
"S_IWGRP", "S_IWOTH", "S_IWUSR", "S_IXGRP", "S_IXOTH", "S_IXUSR"
};
/* <float.h>. */
static const char *const float_syms[] =
{
"DBL_DIG", "DBL_EPSILON", "DBL_MANT_DIG", "DBL_MAX", "DBL_MAX_10_EXP",
"DBL_MAX_EXP", "DBL_MIN", "DBL_MIN_10_EXP", "DBL_MIN_EXP", "FLT_DIG",
"FLT_EPSILON", "FLT_MANT_DIG", "FLT_MAX", "FLT_MAX_10_EXP", "FLT_MAX_EXP",
"FLT_MIN", "FLT_MIN_10_EXP", "FLT_MIN_EXP", "FLT_RADIX", "FLT_ROUNDS",
"LDBL_DIG", "LDBL_EPSILON", "LDBL_MANT_DIG", "LDBL_MAX", "LDBL_MAX_10_EXP",
"LDBL_MAX_EXP", "LDBL_MIN", "LDBL_MIN_10_EXP", "LDBL_MIN_EXP"
};
static const char *const float_maybe[] =
{
};
/* <grp.h>. */
static const char *const grp_syms[] =
{
};
static const char *const grp_maybe[] =
{
"getgrgid", "getgrgid_r", "getgrnam", "getgrnam_r"
};
/* <limits.h>. */
static const char *const limits_syms[] =
{
"_POSIX_AIO_LISTIO_MAX", "_POSIX_AIO_MAX", "_POSIX_ARG_MAX",
"_POSIX_CHILD_MAX", "_POSIX_CLOCKRES_MAX", "_POSIX_DELAYTIMER_MAX",
"_POSIX_LINK_MAX", "_POSIX_LOGIN_NAME_MAX", "_POSIX_MAX_CANON",
"_POSIX_MAX_INPUT", "_POSIX_MQ_OPEN_MAX", "_POSIX_MQ_PRIO_MAX",
"_POSIX_NAME_MAX", "_POSIX_NGROUPS_MAX", "_POSIX_OPEN_MAX",
"_POSIX_PATH_MAX", "_POSIX_PIPE_BUF", "_POSIX_RTSIG_MAX",
"_POSIX_SEM_NSEMS_MAX", "_POSIX_SEM_VALUE_MAX", "_POSIX_SIGQUEUE_MAX",
"_POSIX_SSIZE_MAX", "_POSIX_STREAM_MAX",
"_POSIX_THREAD_DESTRUCTOR_ITERATIONS", "_POSIX_THREAD_KEYS_MAX",
"_POSIX_THREAD_THREADS_MAX", "_POSIX_TIMER_MAX", "_POSIX_TTY_NAME_MAX",
"_POSIX_TZNAME_MAX", "_POSIX_THREAD_DESTRUCTOR_ITERATIONS",
"CHAR_BIT", "CHAR_MAX", "CHAR_MIN", "INT_MAX", "INT_MIN", "MB_LEN_MAX",
"NGROUPS_MAX", "PAGESIZE", "SCHAR_MIN", "SCHAR_MAX"
};
static const char *const limits_maybe[] =
{
"AIO_LISTIO_MAX", "AIO_MAX", "ARG_MAX", "CHILD_MAX", "DELAYTIMER_MAX",
"LINK_MAX", "LOGIN_NAME_MAX", "LONG_MAX", "LONG_MIN", "MAX_CANON",
"MAX_INPUT", "MQ_OPEN_MAX", "MQ_PRIO_MAX", "NAME_MAX", "OPEN_MAX",
"PATH_MAX", "PIPE_BUF", "RTSIG_MAX", "PTHREAD_DESTRUCTOR_ITERATIONS",
"PTHREAD_KEYS_MAX", "PTHREAD_STACK_MIN", "PTHREAD_THREADS_MAX"
};
/* <locale.h>. */
static const char *const locale_syms[] =
{
"LC_ALL", "LC_COLLATE", "LC_CTYPE", "LC_MONETARY", "LC_NUMERIC",
"LC_TIME", "NULL"
};
static const char *const locale_maybe[] =
{
"LC_*", "localeconv", "setlocale"
};
/* <math.h>. */
static const char *const math_syms[] =
{
"HUGE_VAL"
};
static const char *const math_maybe[] =
{
"acos", "asin", "atan2", "atan", "ceil", "cos", "cosh", "exp",
"fabs", "floor", "fmod", "frexp", "ldexp", "log10", "log", "modf",
"pow", "sin", "sinh", "sqrt", "tan", "tanh",
"acosf", "asinf", "atan2f", "atanf", "ceilf", "cosf", "coshf", "expf",
"fabsf", "floorf", "fmodf", "frexpf", "ldexpf", "log10f", "logf", "modff",
"powf", "sinf", "sinhf", "sqrtf", "tanf", "tanhf",
"acosl", "asinl", "atan2l", "atanl", "ceill", "cosl", "coshl", "expl",
"fabsl", "floorl", "fmodl", "frexpl", "ldexpl", "log10l", "logl", "modfl",
"powl", "sinl", "sinhl", "sqrtl", "tanl", "tanhl"
};
/* <mqueue.h>. */
static const char *const mqueue_syms[] =
{
};
static const char *const mqueue_maybe[] =
{
"mq_close", "mq_getattr", "mq_notify", "mq_open", "mq_receive",
"mq_send", "mq_setattr", "mq_unlink"
};
/* <pthread.h>. */
static const char *const pthread_syms[] =
{
"PTHREAD_CANCELED", "PTHREAD_CANCEL_ASYNCHRONOUS",
"PTHREAD_CANCEL_DEFERRED", "PTHREAD_CANCEL_DISABLE", "PTHREAD_CANCEL_ENABLE",
"PTHREAD_COND_INITIALIZER", "PTHREAD_CREATE_DETACHED",
"PTHREAD_CREATE_JOINABLE", "PTHREAD_EXPLICIT_SCHED",
"PTHREAD_INHERIT_SCHED", "PTHREAD_MUTEX_INITIALIZER",
"PTHREAD_ONCE_INIT", "PTHREAD_PRIO_INHERIT", "PTHREAD_PRIO_NONE",
"PTHREAD_PRIO_PROTECT", "PTHREAD_PROCESS_PRIVATE",
"PTHREAD_PROCESS_SHARED", "PTHREAD_SCOPE_PROCESS", "PTHREAD_SCOPE_SYSTEM",
/* These come from <sched.h>. */
"SCHED_FIFO", "SCHED_OTHER", "SCHED_RR",
/* These come from <time.h>. */
"CLK_TCK", "CLOCKS_PER_SEC", "CLOCK_REALTIME", "NULL", "TIMER_ABSTIME"
};
static const char *const pthread_maybe[] =
{
"pthread_atfork", "pthread_attr_destroy", "pthread_attr_getdetachstate",
"pthread_attr_getinheritsched", "pthread_attr_getschedparam",
"pthread_attr_getschedpolicy", "pthread_attr_getscope",
"pthread_attr_getstackaddr", "pthread_attr_getstacksize",
"pthread_attr_init", "pthread_attr_setdetachstate",
"pthread_attr_setinheritsched", "pthread_attr_setschedparam",
"pthread_attr_setschedpolicy", "pthread_attr_setscope",
"pthread_attr_setstackaddr", "pthread_attr_setstacksize",
"pthread_cleanup_pop", "pthread_cleanup_push", "pthread_cond_broadcast",
"pthread_cond_destroy", "pthread_cond_init", "pthread_cond_signal",
"pthread_cond_timedwait", "pthread_cond_wait", "pthread_condattr_destroy",
"pthread_condattr_getpshared", "pthread_condattr_init",
"pthread_condattr_setpshared", "pthread_create", "pthread_detach",
"pthread_equal", "pthread_exit", "pthread_getspecific", "pthread_join",
"pthread_key_create", "pthread_key_destroy", "pthread_kill",
"pthread_mutex_destroy", "pthread_mutex_getprioceiling",
"pthread_mutex_init", "pthread_mutex_lock", "pthread_mutex_setprioceiling",
"pthread_mutex_trylock", "pthread_mutex_unlock", "pthread_mutexattr_destroy",
"pthread_mutexattr_getprioceiling", "pthread_mutexattr_getprotocol",
"pthread_mutexattr_getpshared", "pthread_mutexattr_init",
"pthread_mutexattr_setprioceiling", "pthread_mutexattr_setprotocol",
"pthread_mutexattr_setpshared", "pthread_once", "pthread_self",
"pthread_setcancelstate", "pthread_setcanceltype", "pthread_setspecific",
"pthread_sigmask", "pthread_testcancel"
/* These come from <sched.h>. */
"sched_get_priority_max", "sched_get_priority_min",
"sched_get_rr_interval", "sched_getparam", "sched_getscheduler",
"sched_setparam", "sched_setscheduler", "sched_yield",
/* These come from <time.h>. */
"asctime", "asctime_r", "clock", "clock_getres", "clock_gettime",
"clock_settime", "ctime", "ctime_r", "difftime", "gmtime", "gmtime_r",
"localtime", "localtime_r", "mktime", "nanosleep", "strftime", "time",
"timer_create", "timer_delete", "timer_getoverrun", "timer_gettime",
"timer_settime", "tzset"
};
/* <pwd.h>. */
static const char *const pwd_syms[] =
{
};
static const char *const pwd_maybe[] =
{
"getpwnam", "getpwnam_r", "getpwuid", "getpwuid_r"
};
/* <sched.h>. */
static const char *const sched_syms[] =
{
"SCHED_FIFO", "SCHED_OTHER", "SCHED_RR",
};
static const char *const sched_maybe[] =
{
"sched_get_priority_max", "sched_get_priority_min",
"sched_get_rr_interval", "sched_getparam", "sched_getscheduler",
"sched_setparam", "sched_setscheduler", "sched_yield",
/* These come from <time.h>. */
"CLK_TCK", "CLOCKS_PER_SEC", "CLOCK_REALTIME", "NULL", "TIMER_ABSTIME"
"asctime", "asctime_r", "clock", "clock_getres", "clock_gettime",
"clock_settime", "ctime", "ctime_r", "difftime", "gmtime", "gmtime_r",
"localtime", "localtime_r", "mktime", "nanosleep", "strftime", "time",
"timer_create", "timer_delete", "timer_getoverrun", "timer_gettime",
"timer_settime", "tzset"
};
/* <semaphore.h>. */
static const char *const semaphore_syms[] =
{
};
static const char *const semaphore_maybe[] =
{
"sem_close", "sem_destroy", "sem_getvalue", "sem_init", "sem_open",
"sen_post", "sem_trywait", "sem_unlink", "sem_wait"
};
/* <setjmp.h>. */
static const char *const setjmp_syms[] =
{
};
static const char *const setjmp_maybe[] =
{
"longjmp", "setjmp", "siglongjmp", "sigsetjmp"
};
/* <signal.h>. */
static const char *const signal_syms[] =
{
"SA_NOCLDSTOP", "SA_SIGINFO", "SIGABRT", "SIGALRM", "SIGBUS", "SIGCHLD",
"SIGCONT", "SIGEV_NONE", "SIGEV_SIGNAL", "SIGEV_SIGNAL", "SIGEV_THREAD",
"SIGFPE", "SIGHUP", "SIGILL", "SIGINT", "SIGKILL", "SIGPIPE", "SIGQUIT",
"SIGRTMAX", "SIGRTMIN", "SIGSEGV", "SIGSTOP", "SIGTERM", "SIGTSTP",
"SIGTTIN", "SIGTTOU", "SIGUSR1", "SIGUSR2", "SIG_BLOCK", "SIG_DFL",
"SIG_ERR", "SIG_IGN", "SIG_SETMASK", "SIG_UNBLOCK", "SI_ASYNCIO",
"SI_MESGQ", "SI_QUEUE", "SI_TIMER", "SI_USER"
};
static const char *const signal_maybe[] =
{
"kill", "raise", "sigaction", "sigaddset", "sigdelset", "sigemptyset",
"sigfillset", "sigismember", "signal", "sigpending", "sigprocmask",
"sigqueue", "sigsuspend", "sigtimedwait", "sigwait", "sigwaitinfo"
};
/* <stdarg.h>. */
static const char *const stdarg_syms[] =
{
"va_arg", "va_end", "va_list", "va_start"
};
static const char *const stdarg_maybe[] =
{
};
/* <stddef.h>. */
static const char *const stddef_syms[] =
{
"NULL", "offsetof"
};
static const char *const stddef_maybe[] =
{
};
/* <stdio.h>. */
static const char *const stdio_syms[] =
{
"BUFSIZ", "EOF", "FILENAME_MAX", "L_ctermid", "L_cuserid", "L_tmpnam",
"NULL", "SEEK_CUR", "SEEK_END", "SEEK_SET", "STREAM_MAX", "TMP_MAX",
"stderr", "stdin", "stdout", "_IOFBF", "_IOLBF", "_IONBF"
};
static const char *const stdio_maybe[] =
{
"clearerr", "fclose", "fdopen", "feof", "ferror", "fflush", "fgetc",
"fgetpos", "fgets", "fileno", "flockfile", "fopen", "fprintf", "fputc",
"fputs", "fread", "freopen", "fscanf", "fseek", "fsetpos", "ftell",
"ftrylockfile", "funlockfile", "fwrite", "getc", "getchar",
"getchar_unlocked", "getc_unlocked", "gets", "perror", "printf", "putc",
"putchar", "putchar_unlocked", "putc_unlocked", "puts", "remove", "rename",
"rewind", "scanf", "setbuf", "setvbuf", "sprintf", "sscanf", "tmpfile",
"tmpnam", "ungetc", "vfprintf", "vprintf", "vsprintf"
};
/* <stdlib.h>. */
static const char *const stdlib_syms[] =
{
"EXIT_FAILURE", "EXIT_SUCCESS", "MB_CUR_MAX", "NULL", "RAND_MAX"
};
static const char *const stdlib_maybe[] =
{
"abort", "abs", "atexit", "atof", "atoi", "atol", "bsearch", "calloc",
"div", "exit", "free", "getenv", "labs", "ldiv", "malloc", "mblen",
"mbstowcs", "mbtowc", "qsort", "rand", "rand_r", "realloc", "srand",
"strtod", "strtol", "strtoul", "system", "wcstombs", "wctomb"
};
/* <string.h>. */
static const char *const string_syms[] =
{
"NULL"
};
static const char *const string_maybe[] =
{
"memchr", "memcmp", "memcpy", "memmove", "memset", "strcat", "strchr",
"strcmp", "strcoll", "strcpy", "strcspn", "strerror", "strlen",
"strncat", "strncmp", "strncpy", "strpbrk", "strrchr", "strspn",
"strstr", "strtok", "strtok_r", "strxfrm"
};
/* <sys/mman.h>. */
static const char *const mman_syms[] =
{
"MAP_FAILED", "MAP_FIXED", "MAP_PRIVATE", "MAP_SHARED", "MCL_CURRENT",
"MCL_FUTURE", "MS_ASYNC", "MS_INVALIDATE", "MS_ASYNC", "MS_INVALIDATE",
"MS_SYNC", "PROT_EXEC", "PROT_NONE", "PROT_READ", "PROT_WRITE"
};
static const char *const mman_maybe[] =
{
"mlock", "mlockall", "mmap", "mprotect", "msync", "munlock", "munlockall",
"munmap", "shm_open", "shm_unlock"
};
/* <sys/stat.h>. */
static const char *const stat_syms[] =
{
"S_IRGRP", "S_IROTH", "S_IRUSR", "S_IRWXG", "S_IRWXO", "S_IRWXU",
"S_ISBLK", "S_ISCHR", "S_ISDIR", "S_ISFIFO", "S_ISGID", "S_ISREG",
"S_ISUID", "S_IWGRP", "S_IWOTH", "S_IWUSR", "S_IXGRP", "S_IXOTH",
"S_IXUSR", "S_TYPEISMQ", "S_TYPEISSEM", "S_TYPEISSHM"
};
static const char *const stat_maybe[] =
{
"chmod", "fchmod", "fstat", "mkdir", "mkfifo", "stat", "umask"
};
/* <sys/times.h>. */
static const char *const times_syms[] =
{
};
static const char *const times_maybe[] =
{
"times"
};
/* <sys/types.h>. */
static const char *const types_syms[] =
{
};
static const char *const types_maybe[] =
{
};
/* <sys/utsname.h>. */
static const char *const utsname_syms[] =
{
};
static const char *const utsname_maybe[] =
{
"uname"
};
/* <sys/wait.h>. */
static const char *const wait_syms[] =
{
"WEXITSTATUS", "WIFEXITED", "WIFSIGNALED", "WIFSTOPPED", "WNOHANG",
"WSTOPSIG", "WTERMSIG", "WUNTRACED"
};
static const char *const wait_maybe[] =
{
"wait", "waitpid"
};
/* <termios.h>. */
static const char *const termios_syms[] =
{
"B0", "B110", "B1200", "B134", "B150", "B1800", "B19200", "B200", "B2400",
"B300", "B38400", "B4800", "B50", "B600", "B75", "B9600", "BRKINT", "CLOCAL",
"CREAD", "CS5", "CS6", "CS7", "CS8", "CSIZE", "CSTOPN", "ECHO", "ECHOE",
"ECHOK", "ECHONL", "HUPCL", "ICANON", "ICRNL", "IEXTEN", "IGNBRK", "IGNCR",
"IGNPAR", "INCLR", "INPCK", "ISIG", "ISTRIP", "IXOFF", "IXON", "NCCS",
"NOFLSH", "OPOST", "PARENB", "PARMRK", "PARODD", "TCIFLUSH", "TCIOFF",
"TCIOFLUSH", "TCOFLUSH", "TCOOFF", "TCOON", "TCSADRAIN", "TCSAFLUSH",
"TCSANOW", "TOSTOP", "VEOF", "VEOL", "VERASE", "VINTR", "VKILL", "VMIN",
"VQUIT", "VSTART", "VSTOP", "VSUSP", "VTIME"
};
static const char *const termios_maybe[] =
{
"cfgetispeed", "cfgetospeed", "cfsetispeed", "cfsetospeed", "tcdrain",
"tcflow", "tcflush", "tcgetattr", "tcsendbrk", "tcsetattr"
};
/* <time.h>. */
static const char *const time_syms[] =
{
"CLK_TCK", "CLOCKS_PER_SEC", "CLOCK_REALTIME", "NULL", "TIMER_ABSTIME"
};
static const char *const time_maybe[] =
{
"asctime", "asctime_r", "clock", "clock_getres", "clock_gettime",
"clock_settime", "ctime", "ctime_r", "difftime", "gmtime", "gmtime_r",
"localtime", "localtime_r", "mktime", "nanosleep", "strftime", "time",
"timer_create", "timer_delete", "timer_getoverrun", "timer_gettime",
"timer_settime", "tzset"
};
/* <unistd.h>. */
static const char *const unistd_syms[] =
{
"F_OK", "NULL", "R_OK", "SEEK_CUR", "SEEK_END", "SEEK_SET", "STDERR_FILENO",
"STDIN_FILENO", "STDOUT_FILENO", "W_OK", "X_OK",
"_PC_ASYNC_IO", "_PC_CHOWN_RESTRICTED", "_PC_LINK_MAX", "_PC_MAX_CANON",
"_PC_MAX_INPUT", "_PC_NAME_MAX", "_PC_NO_TRUNC", "_PC_PATH_MAX",
"_PC_PIPE_BUF", "_PC_PRIO_IO", "_PC_SYNC_IO", "_PC_VDISABLE",
"_SC_AIO_LISTIO_MAX", "_SC_AIO_MAX", "_SC_AIO_PRIO_DELTA_MAX",
"_SC_ARG_MAX", "_SC_ASYNCHRONOUS_IO", "_SC_CHILD_MAX", "_SC_CLK_TCK",
"_SC_DELAYTIMER_MAX", "_SC_FSYNC", "_SC_GETGR_R_SIZE_MAX",
"_SC_GETPW_R_SIZE_MAX", "_SC_JOB_CONTROL", "_SC_LOGIN_NAME_MAX",
"_SC_MAPPED_FILES", "_SC_MEMLOCK", "_SC_MEMLOCK_RANGE",
"_SC_MEMORY_PROTECTION", "_SC_MESSAGE_PASSING", "_SC_MQ_OPEN_MAX",
"_SC_MQ_PRIO_MAX", "_SC_NGROUPS_MAX", "_SC_OPEN_MAX", "_SC_PAGESIZE",
"_SC_PRIORITIZED_IO", "_SC_PRIORITY_SCHEDULING", "_SC_REALTIME_SIGNALS",
"_SC_RTSIG_MAX", "_SC_SAVED_IDS", "_SC_SEMAPHORES", "_SC_SEM_NSEMS_MAX",
"_SC_SEM_VALUE_MAX", "_SC_SHARED_MEMORY_OBJECTS", "_SC_SIGQUEUE_MAX",
"_SC_STREAM_MAX", "_SC_SYNCHRONIZED_IO", "_SC_THREADS",
"_SC_THREAD_ATTR_STACKADDR", "_SC_THREAD_ATTR_STACKSIZE",
"_SC_THREAD_DESTRUCTOR_ITERATIONS", "_SC_THREAD_PRIO_INHERIT",
"_SC_THREAD_PRIORITY_SCHEDULING", "_SC_THREAD_PRIO_PROTECT",
"_SC_THREAD_PROCESS_SHARED", "_SC_THREAD_SAFE_FUNCTIONS",
"_SC_THREAD_STACK_MIN", "_SC_THREAD_THREADS_MAX", "_SC_TIMERS",
"_SC_TIMER_MAX", "_SC_TTY_NAME_MAX", "_SC_TZNAME_MAX", "_SC_VERSION"
};
static const char *const unistd_maybe[] =
{
"_POSIX_ASYNCHRONOUS_IO", "_POSIX_ASYNC_IO", "_POSIX_CHOWN_RESTRICTED",
"_POSIX_FSYNC", "_POSIX_JOB_CONTROL", "_POSIX_MAPPED_FILES",
"_POSIX_MEMLOCK", "_POSIX_MEMLOCK_RANGE", "_MEMORY_PROTECTION",
"_POSIX_MESSAGE_PASSING", "_POSIX_NO_TRUNC", "_POSIX_PRIORITIZED_IO",
"_POSIX_PRIORITY_SCHEDULING", "_POSIX_PRIO_IO", "_POSIX_REATIME_SIGNALS",
"_POSIX_SAVED_IDS", "_POSIX_SEMAPHORES", "_POSIX_SHARED_MEMORY_OBJECTS",
"_POSIX_SYNCHRONIZED_IO", "_POSIX_SYNC_IO", "_POSIX_THREADS",
"_POSIX_THREAD_ATTR_STACKADDR", "_POSIX_THREAD_ATTR_STACKSIZE",
"_POSIX_THREAD_PRIO_INHERIT", "_POSIX_THREAD_PRIO_PROTECT",
"_POSIX_THREAD_PROCESS_SHARED", "_POSIX_THREAD_SAFE_FUNCTIONS",
"_POSIX_THREAD_PRIORITY_SCHEDULING", "_POSIX_TIMERS",
"_POSIX_VDISABLE", "_POSIX_VERSION",
"_exit", "access", "alarm", "chdir", "chown", "close", "ctermid", "cuserid",
"dup2", "dup", "execl", "execle", "execlp", "execv", "execve", "execvp",
"fdatasync", "fork", "fpathconf", "fsync", "ftruncate", "getcwd", "getegid",
"geteuid", "getgid", "getgroups", "getlogin", "getlogin_r", "getpgrp",
"getpid", "getppid", "getuid", "isatty", "link", "lseek", "pathconf",
"pause", "pipe", "read", "rmdir", "setgid", "setgpid", "setsid", "setuid",
"sleep", "sleep", "sysconf", "tcgetpgrp", "tcsetpgrp", "ttyname",
"ttyname_r", "unlink", "write"
};
/* <utime.h>. */
static const char *const utime_syms[] =
{
};
static const char *const utime_maybe[] =
{
"utime"
};
static struct header
{
const char *name;
const char *const *syms;
size_t nsyms;
const char *const *maybe;
size_t nmaybe;
const char *subset;
} headers[] =
{
#define H(n) \
{ #n ".h", n##_syms, sizeof (n##_syms) / sizeof (n##_syms[0]), \
n##_maybe, sizeof (n##_maybe) / sizeof (n##_maybe[0]), NULL }
#define Hc(n, s) \
{ #n ".h", n##_syms, sizeof (n##_syms) / sizeof (n##_syms[0]), \
n##_maybe, sizeof (n##_maybe) / sizeof (n##_maybe[0]), s }
#define Hs(n) \
{ "sys/" #n ".h", n##_syms, sizeof (n##_syms) / sizeof (n##_syms[0]), \
n##_maybe, sizeof (n##_maybe) / sizeof (n##_maybe[0]), NULL }
H(aio),
H(assert),
H(ctype),
H(dirent),
H(errno),
H(fcntl),
H(float),
H(grp),
H(limits),
H(locale),
H(math),
Hc(mqueue, "_POSIX_MESSAGE_PASSING"),
H(pthread),
H(pwd),
H(sched),
H(semaphore),
H(setjmp),
H(signal),
H(stdarg),
H(stddef),
H(stdio),
H(stdlib),
H(string),
Hs(mman),
Hs(stat),
Hs(times),
Hs(types),
Hs(utsname),
Hs(wait),
H(termios),
H(time),
H(unistd),
H(utime)
};
#define NUMBER_OF_HEADERS (sizeof headers / sizeof *headers)
/* Format string to build command to invoke compiler. */
static const char fmt[] = "\
echo \"#include <%s>\" |\
%s -E -dM -D_POSIX_SOURCE %s \
-isystem `%s --print-prog-name=include` - > %s";
static const char testfmt[] = "\
echo \"#include <unistd.h>\n#ifndef %s\n#error not defined\n#endif\n\" |\
%s -E -dM -D_POSIX_SOURCE %s \
-isystem `%s --print-prog-name=include` - 2> /dev/null > %s";
/* The compiler we use (given on the command line). */
const char *CC;
/* The -I parameters for CC to find all headers. */
const char *INC;
static char *xstrndup (const char *, size_t);
static const char **get_null_defines (void);
static int check_header (const struct header *, const char **);
int
main (int argc, char *argv[])
{
int h;
int result = 0;
const char **ignore_list;
CC = argc > 1 ? argv[1] : "gcc";
INC = argc > 2 ? argv[2] : "";
if (system (NULL) == 0)
{
puts ("Sorry, no command processor.");
return EXIT_FAILURE;
}
/* First get list of symbols which are defined by the compiler. */
ignore_list = get_null_defines ();
fputs ("Tested files:\n", stdout);
for (h = 0; h < NUMBER_OF_HEADERS; ++h)
result |= check_header (&headers[h], ignore_list);
/* The test suite should return errors but for now this is not
practical. Give a warning and ask the user to correct the bugs. */
return result;
}
static char *
xstrndup (const char *s, size_t n)
{
size_t len = n;
char *new = malloc (len + 1);
if (new == NULL)
return NULL;
new[len] = '\0';
return memcpy (new, s, len);
}
static const char **
get_null_defines (void)
{
char line[BUFSIZ], *command;
char **result = NULL;
size_t result_len = 0;
size_t result_max = 0;
FILE *input;
int first = 1;
command = malloc (sizeof fmt + sizeof "/dev/null" + 2 * strlen (CC)
+ strlen (INC) + strlen (TMPFILE));
if (command == NULL)
{
puts ("No more memory.");
exit (1);
}
sprintf (command, fmt, "/dev/null", CC, INC, CC, TMPFILE);
if (system (command))
{
puts ("system() returned nonzero");
return NULL;
}
free (command);
input = fopen (TMPFILE, "r");
if (input == NULL)
{
printf ("Could not read %s: ", TMPFILE);
perror (NULL);
return NULL;
}
while (fgets (line, sizeof line, input) != NULL)
{
char *start, *end;
if (strlen (line) < 9 || line[7] != ' ')
{ /* "#define A" */
printf ("Malformed input, expected '#define MACRO'\ngot '%s'\n",
line);
continue;
}
if (line[8] == '_')
/* It's a safe identifier. */
continue;
if (result_len == result_max)
{
result_max += 10;
result = realloc (result, result_max * sizeof (char **));
if (result == NULL)
{
puts ("No more memory.");
exit (1);
}
}
start = &line[8];
for (end = start + 1; !isspace (*end) && *end != '\0'; ++end)
;
result[result_len++] = xstrndup (start, end - start);
if (first)
{
fputs ("The following identifiers will be ignored since the compiler defines them\nby default:\n", stdout);
first = 0;
}
puts (result[result_len - 1]);
}
if (result_len == result_max)
{
result_max += 1;
result = realloc (result, result_max * sizeof (char **));
if (result == NULL)
{
puts ("No more memory.");
exit (1);
}
}
result[result_len] = NULL;
fclose (input);
remove (TMPFILE);
return (const char **) result;
}
static int
check_header (const struct header *header, const char **except)
{
char line[BUFSIZ], *command;
FILE *input;
int result = 0;
int found[header->nsyms];
int i;
memset (found, '\0', header->nsyms * sizeof (int));
command = alloca (sizeof fmt + strlen (header->name) + 2 * strlen (CC)
+ strlen (INC) + strlen (TMPFILE));
if (command == NULL)
{
puts ("No more memory.");
exit (1);
}
printf ("=== %s ===\n", header->name);
sprintf (command, fmt, header->name, CC, INC, CC, TMPFILE);
/* First see whether this subset is supported at all. */
if (header->subset != NULL)
{
sprintf (line, testfmt, header->subset, CC, INC, CC, TMPFILE);
if (system (line))
{
printf ("!! not available\n");
return 0;
}
}
if (system (command))
{
puts ("system() returned nonzero");
result = 1;
}
input = fopen (TMPFILE, "r");
if (input == NULL)
{
printf ("Could not read %s: ", TMPFILE);
perror (NULL);
return 1;
}
while (fgets (line, sizeof line, input) != NULL)
{
char *endmac;
const char **ignore;
if (strlen (line) < 9 || line[7] != ' ')
{ /* "#define A" */
printf ("Malformed input, expected '#define MACRO'\ngot '%s'\n",
line);
result = 1;
continue;
}
/* Now check whether it's one of the required macros. */
for (i = 0; i < header->nsyms; ++i)
if (!strncmp (&line[8], header->syms[i], strlen (header->syms[i])))
break;
if (i < header->nsyms)
{
found[i] = 1;
continue;
}
/* Symbols starting with "_" are ok. */
if (line[8] == '_')
continue;
/* Find next char after the macro identifier; this can be either
a space or an open parenthesis. */
endmac = strpbrk (&line[8], " (");
if (endmac != NULL)
*endmac = '\0';
/* Maybe one of the symbols which are always defined. */
for (ignore = except; *ignore != NULL; ++ignore)
if (! strcmp (&line[8], *ignore))
break;
if (*ignore != NULL)
continue;
/* Otherwise the symbol better should match one of the following. */
for (i = 0; i < header->nmaybe; ++i)
if (fnmatch (header->maybe[i], &line[8], 0) == 0)
break;
if (i < header->nmaybe)
continue;
printf ("* invalid macro `%s'\n", &line[8]);
result |= 1;
}
fclose (input);
remove (TMPFILE);
for (i = 0; i < header->nsyms; ++i)
if (found[i] == 0)
printf ("** macro `%s' not defined\n", header->syms[i]);
return result;
}

32
posix/bits/posix1_lim.h
View File

@ -1,4 +1,4 @@
/* Copyright (C) 1991, 1992, 1993, 1996 Free Software Foundation, Inc.
/* Copyright (C) 1991, 1992, 1993, 1996, 1998 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
@ -28,12 +28,21 @@
/* These are the standard-mandated minimum values. */
/* Minimum number of operations in one list I/O call. */
#define _POSIX_AIO_LISTIO_MAX 2
/* Minimal number of outstanding asynchronous I/O operations. */
#define _POSIX_AIO_MAX 1
/* Maximum length of arguments to `execve', including environment. */
#define _POSIX_ARG_MAX 4096
/* Maximum simultaneous processes per real user ID. */
#define _POSIX_CHILD_MAX 6
/* Minimal number of timer expiration overruns. */
#define _POSIX_DELAYTIMER_MAX 32
/* Maximum link count of a file. */
#define _POSIX_LINK_MAX 8
@ -44,6 +53,12 @@
available in a terminal input queue. */
#define _POSIX_MAX_INPUT 255
/* Maximum number of message queues open for a process. */
#define _POSIX_MQ_OPEN_MAX 8
/* Maximum number of supported message priorities. */
#define _POSIX_MQ_PRIO_MAX 32
/* Number of simultaneous supplementary group IDs per process. */
#define _POSIX_NGROUPS_MAX 0
@ -63,6 +78,18 @@
/* Number of bytes than can be written atomically to a pipe. */
#define _POSIX_PIPE_BUF 512
/* Minimal number of realtime signals reserved for the application. */
#define _POSIX_RTSIG_MAX 8
/* Number of semaphores a process can have. */
#define _POSIX_SEM_NSEMS_MAX 256
/* Maximal value of a semaphore. */
#define _POSIX_SEM_VALUE_MAX 32767
/* Number of pending realtime signals. */
#define _POSIX_SIGQUEUE_MAX 32
/* Largest value of a `ssize_t'. */
#define _POSIX_SSIZE_MAX 32767
@ -85,6 +112,9 @@
/* Maximum number of characters in a tty name. */
#define _POSIX_TTY_NAME_MAX 9
/* Number of timer for a process. */
#define _POSIX_TIMER_MAX 32
/* Maximum length of login name. */
#define _POSIX_LOGIN_NAME_MAX 9

1
rt/aio.h
View File

@ -26,7 +26,6 @@
#include <features.h>
#include <fcntl.h>
#include <signal.h>
#define __need_timespec
#include <time.h>
#include <sys/types.h>

1
rt/aio_misc.c
View File

@ -20,6 +20,7 @@
#include <aio.h>
#include <errno.h>
#include <limits.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>

3
rt/aio_notify.c
View File

@ -1,5 +1,5 @@
/* Notify initiator of AIO request.
Copyright (C) 1997 Free Software Foundation, Inc.
Copyright (C) 1997, 1998 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
@ -18,6 +18,7 @@
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#include <errno.h>
#include <pthread.h>
#include <stdlib.h>
#include "aio_misc.h"

2
stdlib/isomac.c
View File

@ -177,7 +177,7 @@ static char *macros[] =
static const char fmt[] = "\
echo \"#include <%s>\" |\
%s -E -dM -ansi -pedantic %s -D_LIBC -I. \
-isystem `%s --print-prog-name=include` - > %s";
-isystem `%s --print-prog-name=include` - 2> /dev/null > %s";
/* The compiler we use (given on the command line). */

7
sysdeps/unix/sysv/linux/alpha/bits/types.h
View File

@ -25,6 +25,9 @@
#include <features.h>
#define __need_size_t
#include <stddef.h>
/* Convenience types. */
typedef unsigned char __u_char;
typedef unsigned short int __u_short;
@ -107,4 +110,8 @@ typedef struct
typedef int __t_scalar_t;
typedef unsigned int __t_uscalar_t;
/* Now add the thread types. */
#include <bits/pthreadtypes.h>
#endif /* bits/types.h */

3
sysdeps/unix/sysv/linux/bits/errno.h
View File

@ -24,6 +24,9 @@
# undef ERANGE
# include <linux/errno.h>
/* Linux has no ENOTSUP error code. */
# define ENOTSUP EOPNOTSUPP
# ifndef __ASSEMBLER__
/* We now need a declaration of the `errno' variable. */
extern int errno;

6
sysdeps/unix/sysv/linux/bits/fcntl.h
View File

@ -1,5 +1,5 @@
/* O_*, F_*, FD_* bit values for Linux.
Copyright (C) 1995, 1996, 1997 Free Software Foundation, Inc.
Copyright (C) 1995, 1996, 1997, 1998 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
@ -48,7 +48,9 @@
#define O_ASYNC 020000
/* XXX missing */
#define O_LARGEFILE 0
#ifdef __USE_LARGEFILE64
# define O_LARGEFILE 0
#endif
/* Values for the second argument to `fcntl'. */
#define F_DUPFD 0 /* Duplicate file descriptor. */

1
sysdeps/unix/sysv/linux/bits/pthreadtypes.h Normal file
View File

@ -0,0 +1 @@
/* No thread support. */

26
sysdeps/unix/sysv/linux/bits/sched.h
View File

@ -18,6 +18,8 @@
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#ifndef __need_schedparam
#ifndef _SCHED_H
# error "Never include <bits/sched.h> directly; use <sched.h> instead."
#endif
@ -28,12 +30,6 @@
#define SCHED_FIFO 1
#define SCHED_RR 2
/* Data structure to describe a process' schedulability. */
struct sched_param
{
int sched_priority;
};
#ifdef __USE_MISC
/* Cloning flags. */
# define CSIGNAL 0x000000ff /* Signal mask to be sent at exit. */
@ -45,6 +41,11 @@ struct sched_param
# define CLONE_PTRACE 0x00002000 /* Set if tracing continues on the child. */
#endif
/* The official definition. */
struct sched_param
{
int sched_priority;
};
__BEGIN_DECLS
@ -56,4 +57,17 @@ extern int clone __P ((int (*__fn) (void *__arg), void *__child_stack,
int __flags, void *__arg));
#endif
#endif /* need schedparam */
#if !defined __defined_schedparam \
&& (defined __need_schedparam || defined _SCHED_H)
# define __defined_schedparam 1
/* Data structure to describe a process' schedulability. */
struct __sched_param
{
int sched_priority;
};
# undef __need_schedparam
#endif
__END_DECLS

12
sysdeps/unix/sysv/linux/bits/siginfo.h
View File

@ -32,8 +32,8 @@ typedef union sigval
void *sival_ptr;
} sigval_t;
# define SI_MAX_SIZE 128
# define SI_PAD_SIZE ((SI_MAX_SIZE / sizeof (int)) - 3)
# define __SI_MAX_SIZE 128
# define __SI_PAD_SIZE ((__SI_MAX_SIZE / sizeof (int)) - 3)
typedef struct siginfo
{
@ -44,7 +44,7 @@ typedef struct siginfo
union
{
int _pad[SI_PAD_SIZE];
int _pad[__SI_PAD_SIZE];
/* kill(). */
struct
@ -237,8 +237,8 @@ enum
# define __have_sigevent_t 1
/* Structure to transport application-defined values with signals. */
# define SIGEV_MAX_SIZE 64
# define SIGEV_PAD_SIZE ((SIGEV_MAX_SIZE / sizeof (int)) - 3)
# define __SIGEV_MAX_SIZE 64
# define __SIGEV_PAD_SIZE ((__SIGEV_MAX_SIZE / sizeof (int)) - 3)
typedef struct sigevent
{
@ -248,7 +248,7 @@ typedef struct sigevent
union
{
int _pad[SIGEV_PAD_SIZE];
int _pad[__SIGEV_PAD_SIZE];
struct
{

7
sysdeps/unix/sysv/linux/bits/types.h
View File

@ -25,6 +25,9 @@
#include <features.h>
#define __need_size_t
#include <stddef.h>
/* Convenience types. */
typedef unsigned char __u_char;
typedef unsigned short __u_short;
@ -131,4 +134,8 @@ typedef __loff_t __off64_t;
typedef int __t_scalar_t;
typedef unsigned int __t_uscalar_t;
/* Now add the thread types. */
#include <bits/pthreadtypes.h>
#endif /* bits/types.h */

7
sysdeps/unix/sysv/linux/mips/bits/types.h
View File

@ -25,6 +25,9 @@
#include <features.h>
#define __need_size_t
#include <stddef.h>
/* Convenience types. */
typedef unsigned char __u_char;
typedef unsigned short __u_short;
@ -131,4 +134,8 @@ typedef __loff_t __off64_t;
typedef int __t_scalar_t;
typedef unsigned int __t_uscalar_t;
/* Now add the thread types. */
#include <bits/pthreadtypes.h>
#endif /* bits/types.h */

7
sysdeps/unix/sysv/linux/sparc/sparc64/bits/types.h
View File

@ -25,6 +25,9 @@
#include <features.h>
#define __need_size_t
#include <stddef.h>
/* Convenience types. */
typedef unsigned char __u_char;
typedef unsigned short int __u_short;
@ -117,4 +120,8 @@ typedef __u_quad_t __fsfilcnt64_t;
typedef int __t_scalar_t;
typedef unsigned int __t_uscalar_t;
/* Now add the thread types. */
#include <bits/pthreadtypes.h>
#endif /* bits/types.h */