mirrors/cpython
1
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-08-03 16:39:00 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 8

Merge back to main trunk

Browse source
This commit is contained in:
Guido van Rossum 1994-08-30 08:27:36 +00:00
parent 013142a95f
commit 1d5735e846
37 changed files with 681 additions and 831 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Python/cgensupport.c
View file

@ -1,5 +1,5 @@
/***********************************************************
Copyright 1991, 1992, 1993 by Stichting Mathematisch Centrum,
Copyright 1991, 1992, 1993, 1994 by Stichting Mathematisch Centrum,
Amsterdam, The Netherlands.
All Rights Reserved

2
Python/fmod.c
View file

@ -1,5 +1,5 @@
/***********************************************************
Copyright 1991, 1992, 1993 by Stichting Mathematisch Centrum,
Copyright 1991, 1992, 1993, 1994 by Stichting Mathematisch Centrum,
Amsterdam, The Netherlands.
All Rights Reserved

33
Python/frozenmain.c
View file

@ -1,5 +1,5 @@
/***********************************************************
Copyright 1991, 1992, 1993 by Stichting Mathematisch Centrum,
Copyright 1991, 1992, 1993, 1994 by Stichting Mathematisch Centrum,
Amsterdam, The Netherlands.
All Rights Reserved
@ -28,9 +28,14 @@ OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
extern char *getenv();
extern char *getversion();
extern char *getcopyright();
extern int debugging;
extern int verbose;
extern int killprint;
extern int suppress_print;
static char *argv0;
main(argc, argv)
int argc;
@ -39,17 +44,29 @@ main(argc, argv)
char *p;
int n, sts;
int inspect = 0;
int unbuffered = 0;
argv0 = argv[0];
if ((p = getenv("PYTHONDEBUG")) && *p != '\0')
debugging = 1;
if ((p = getenv("PYTHONSUPPRESS")) && *p != '\0')
suppress_print = 1;
if ((p = getenv("PYTHONVERBOSE")) && *p != '\0')
verbose = 1;
if ((p = getenv("PYTHONINSPECT")) && *p != '\0')
inspect = 1;
if ((p = getenv("PYTHONKILLPRINT")) && *p != '\0')
killprint = 1;
if ((p = getenv("PYTHONUNBUFFERED")) && *p != '\0')
unbuffered = 1;
initargs(&argc, &argv);
if (unbuffered) {
setbuf(stdout, (char *)NULL);
setbuf(stderr, (char *)NULL);
}
if (verbose)
fprintf(stderr, "Python %s\n%s\n",
getversion(), getcopyright());
initall();
setpythonargv(argc, argv);
@ -69,3 +86,9 @@ main(argc, argv)
goaway(sts);
/*NOTREACHED*/
}
char *
getprogramname()
{
return argv0;
}

24
Python/getcwd.c
View file

@ -1,5 +1,5 @@
/***********************************************************
Copyright 1991, 1992, 1993 by Stichting Mathematisch Centrum,
Copyright 1991, 1992, 1993, 1994 by Stichting Mathematisch Centrum,
Amsterdam, The Netherlands.
All Rights Reserved
@ -25,16 +25,20 @@ OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
/* Two PD getcwd() implementations.
Author: Guido van Rossum, CWI Amsterdam, Jan 1991, <guido@cwi.nl>. */
/* #define NO_GETWD /* Turn this on to popen pwd instead of calling getwd() */
#include <stdio.h>
#include <errno.h>
#ifndef NO_GETWD
#ifdef HAVE_GETWD
/* Default: Version for BSD systems -- use getwd() */
/* Version for BSD systems -- use getwd() */
#include "sys/param.h"
#ifdef HAVE_SYS_PARAM_H
#include <sys/param.h>
#endif
#ifndef MAXPATHLEN
#define MAXPATHLEN 1024
#endif
extern char *getwd();
@ -63,11 +67,13 @@ getcwd(buf, size)
return buf;
}
#else
#else /* !HAVE_GETWD */
/* NO_GETWD defined: Version for backward UNIXes -- popen /bin/pwd */
/* Version for really old UNIX systems -- use pipe from pwd */
#ifndef PWD_CMD
#define PWD_CMD "/bin/pwd"
#endif
char *
getcwd(buf, size)
@ -97,4 +103,4 @@ getcwd(buf, size)
return buf;
}
#endif
#endif /* !HAVE_GETWD */

19
Python/marshal.c
View file

@ -1,5 +1,5 @@
/***********************************************************
Copyright 1991, 1992, 1993 by Stichting Mathematisch Centrum,
Copyright 1991, 1992, 1993, 1994 by Stichting Mathematisch Centrum,
Amsterdam, The Netherlands.
All Rights Reserved
@ -304,10 +304,8 @@ r_object(p)
case TYPE_FLOAT:
{
extern double strtod PROTO((const char *, char **));
extern double atof PROTO((const char *));
char buf[256];
double res;
char *end;
n = r_byte(p);
if (r_string(buf, (int)n, p) != n) {
err_setstr(EOFError,
@ -315,18 +313,7 @@ r_object(p)
return NULL;
}
buf[n] = '\0';
errno = 0;
res = strtod(buf, &end);
if (*end != '\0') {
err_setstr(ValueError, "bad float syntax");
return NULL;
}
if (errno != 0) {
err_setstr(ValueError,
"float constant too large");
return NULL;
}
return newfloatobject(res);
return newfloatobject(atof(buf));
}
case TYPE_STRING:

145
Python/modsupport.c
View file

@ -1,5 +1,5 @@
/***********************************************************
Copyright 1991, 1992, 1993 by Stichting Mathematisch Centrum,
Copyright 1991, 1992, 1993, 1994 by Stichting Mathematisch Centrum,
Amsterdam, The Netherlands.
All Rights Reserved
@ -28,10 +28,22 @@ OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include "modsupport.h"
#include "import.h"
#ifdef MPW /* MPW pushes 'extended' for float and double types with varargs */
typedef extended va_double;
#else
typedef double va_double;
#endif
/* initmodule2() has an additional parameter, 'passthrough', which is
passed as 'self' to functions defined in the module. This is used
e.g. by dynamically loaded modules on the Mac. */
object *
initmodule(name, methods)
initmodule2(name, methods, passthrough)
char *name;
struct methodlist *methods;
object *passthrough;
{
object *m, *d, *v;
struct methodlist *ml;
@ -47,7 +59,7 @@ initmodule(name, methods)
fatal("out of mem for method name");
sprintf(namebuf, "%s.%s", name, ml->ml_name);
v = newmethodobject(namebuf, ml->ml_meth,
(object *)NULL, ml->ml_varargs);
(object *)passthrough, ml->ml_varargs);
/* XXX The malloc'ed memory in namebuf is never freed */
if (v == NULL || dictinsert(d, ml->ml_name, v) != 0) {
fprintf(stderr, "initializing module: %s\n", name);
@ -58,6 +70,16 @@ initmodule(name, methods)
return m;
}
/* The standard initmodule() passes NULL for 'self' */
object *
initmodule(name, methods)
char *name;
struct methodlist *methods;
{
return initmodule2(name, methods, (object *)NULL);
}
/* Helper for mkvalue() to scan the length of a format */
@ -99,7 +121,6 @@ do_arg(arg, p_format, p_va)
va_list *p_va;
{
char *format = *p_format;
va_list va = *p_va;
if (arg == NULL)
return 0; /* Incomplete tuple or list */
@ -112,7 +133,7 @@ do_arg(arg, p_format, p_va)
return 0;
n = gettuplesize(arg);
for (i = 0; i < n; i++) {
if (!do_arg(gettupleitem(arg, i), &format, &va))
if (!do_arg(gettupleitem(arg, i), &format, p_va))
return 0;
}
if (*format++ != ')')
@ -124,65 +145,67 @@ do_arg(arg, p_format, p_va)
return 0;
case 'b': /* byte -- very short int */ {
char *p = va_arg(va, char *);
if (is_intobject(arg))
*p = getintvalue(arg);
else
char *p = va_arg(*p_va, char *);
long ival = getintvalue(arg);
if (ival == -1 && err_occurred())
return 0;
else
*p = ival;
break;
}
case 'h': /* short int */ {
short *p = va_arg(va, short *);
if (is_intobject(arg))
*p = getintvalue(arg);
else
short *p = va_arg(*p_va, short *);
long ival = getintvalue(arg);
if (ival == -1 && err_occurred())
return 0;
else
*p = ival;
break;
}
case 'i': /* int */ {
int *p = va_arg(va, int *);
if (is_intobject(arg))
*p = getintvalue(arg);
else
int *p = va_arg(*p_va, int *);
long ival = getintvalue(arg);
if (ival == -1 && err_occurred())
return 0;
else
*p = ival;
break;
}
case 'l': /* long int */ {
long *p = va_arg(va, long *);
if (is_intobject(arg))
*p = getintvalue(arg);
else
long *p = va_arg(*p_va, long *);
long ival = getintvalue(arg);
if (ival == -1 && err_occurred())
return 0;
else
*p = ival;
break;
}
case 'f': /* float */ {
float *p = va_arg(va, float *);
if (is_floatobject(arg))
*p = getfloatvalue(arg);
else if (is_intobject(arg))
*p = (float)getintvalue(arg);
else
float *p = va_arg(*p_va, float *);
double dval = getfloatvalue(arg);
if (err_occurred())
return 0;
else
*p = dval;
break;
}
case 'd': /* double */ {
double *p = va_arg(va, double *);
if (is_floatobject(arg))
*p = getfloatvalue(arg);
else if (is_intobject(arg))
*p = (double)getintvalue(arg);
else
double *p = va_arg(*p_va, double *);
double dval = getfloatvalue(arg);
if (err_occurred())
return 0;
else
*p = dval;
break;
}
case 'c': /* char */ {
char *p = va_arg(va, char *);
char *p = va_arg(*p_va, char *);
if (is_stringobject(arg) && getstringsize(arg) == 1)
*p = getstringvalue(arg)[0];
else
@ -191,13 +214,13 @@ do_arg(arg, p_format, p_va)
}
case 's': /* string */ {
char **p = va_arg(va, char **);
char **p = va_arg(*p_va, char **);
if (is_stringobject(arg))
*p = getstringvalue(arg);
else
return 0;
if (*format == '#') {
int *q = va_arg(va, int *);
int *q = va_arg(*p_va, int *);
*q = getstringsize(arg);
format++;
}
@ -209,7 +232,7 @@ do_arg(arg, p_format, p_va)
}
case 'z': /* string, may be NULL (None) */ {
char **p = va_arg(va, char **);
char **p = va_arg(*p_va, char **);
if (arg == None)
*p = 0;
else if (is_stringobject(arg))
@ -217,7 +240,7 @@ do_arg(arg, p_format, p_va)
else
return 0;
if (*format == '#') {
int *q = va_arg(va, int *);
int *q = va_arg(*p_va, int *);
if (arg == None)
*q = 0;
else
@ -232,7 +255,7 @@ do_arg(arg, p_format, p_va)
}
case 'S': /* string object */ {
object **p = va_arg(va, object **);
object **p = va_arg(*p_va, object **);
if (is_stringobject(arg))
*p = arg;
else
@ -241,8 +264,37 @@ do_arg(arg, p_format, p_va)
}
case 'O': /* object */ {
object **p = va_arg(va, object **);
*p = arg;
typeobject *type;
object **p;
if (*format == '!') {
format++;
type = va_arg(*p_va, typeobject*);
if (arg->ob_type != type)
return 0;
else {
p = va_arg(*p_va, object **);
*p = arg;
}
}
else if (*format == '?') {
inquiry pred = va_arg(*p_va, inquiry);
format++;
if ((*pred)(arg)) {
p = va_arg(*p_va, object **);
*p = arg;
}
}
else if (*format == '&') {
binaryfunc convert = va_arg(*p_va, binaryfunc);
void *addr = va_arg(*p_va, void *);
format++;
if (! (*convert)(arg, addr))
return 0;
}
else {
p = va_arg(*p_va, object **);
*p = arg;
}
break;
}
@ -253,13 +305,12 @@ do_arg(arg, p_format, p_va)
}
*p_va = va;
*p_format = format;
return 1;
}
#ifdef USE_STDARG
#ifdef HAVE_STDARG_PROTOTYPES
/* VARARGS2 */
int getargs(object *arg, char *format, ...)
#else
@ -270,7 +321,7 @@ int getargs(va_alist) va_dcl
char *f;
int ok;
va_list va;
#ifdef USE_STDARG
#ifdef HAVE_STDARG_PROTOTYPES
va_start(va, format);
#else
@ -458,7 +509,7 @@ do_mkvalue(p_format, p_va)
case 'f':
case 'd':
return newfloatobject((double)va_arg(*p_va, double));
return newfloatobject((double)va_arg(*p_va, va_double));
case 'c':
{
@ -517,7 +568,7 @@ do_mkvalue(p_format, p_va)
}
}
#ifdef USE_STDARG
#ifdef HAVE_STDARG_PROTOTYPES
/* VARARGS 2 */
object *mkvalue(char *format, ...)
#else
@ -527,7 +578,7 @@ object *mkvalue(va_alist) va_dcl
{
va_list va;
object* retval;
#ifdef USE_STDARG
#ifdef HAVE_STDARG_PROTOTYPES
va_start(va, format);
#else
char *format;

67
Python/pythonmain.c
View file

@ -1,5 +1,5 @@
/***********************************************************
Copyright 1991, 1992, 1993 by Stichting Mathematisch Centrum,
Copyright 1991, 1992, 1993, 1994 by Stichting Mathematisch Centrum,
Amsterdam, The Netherlands.
All Rights Reserved
@ -26,9 +26,9 @@ OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include "allobjects.h"
extern int debugging; /* Defined in parser.c */
extern int verbose; /* Defined in import.c */
extern int killprint; /* Defined in ceval.c */
extern int debugging; /* Needed in parser.c, declared in pythonrun.c */
extern int verbose; /* Needed in import.c, declared in pythonrun.c */
extern int suppress_print; /* Needed in ceval.c, declared in pythonrun.c */
/* Interface to getopt(): */
extern int optind;
@ -37,7 +37,11 @@ extern int getopt(); /* PROTO((int, char **, char *)); -- not standardized */
extern char *getenv();
main(argc, argv)
extern char *getversion();
extern char *getcopyright();
int
realmain(argc, argv)
int argc;
char **argv;
{
@ -48,19 +52,20 @@ main(argc, argv)
FILE *fp = stdin;
char *p;
int inspect = 0;
int unbuffered = 0;
if ((p = getenv("PYTHONDEBUG")) && *p != '\0')
debugging = 1;
if ((p = getenv("PYTHONSUPPRESS")) && *p != '\0')
suppress_print = 1;
if ((p = getenv("PYTHONVERBOSE")) && *p != '\0')
verbose = 1;
if ((p = getenv("PYTHONINSPECT")) && *p != '\0')
inspect = 1;
if ((p = getenv("PYTHONKILLPRINT")) && *p != '\0')
killprint = 1;
initargs(&argc, &argv);
if ((p = getenv("PYTHONUNBUFFERED")) && *p != '\0')
unbuffered = 1;
while ((c = getopt(argc, argv, "c:dikv")) != EOF) {
while ((c = getopt(argc, argv, "c:disuv")) != EOF) {
if (c == 'c') {
/* -c is the last option; following arguments
that look like options are left for the
@ -82,8 +87,12 @@ main(argc, argv)
inspect++;
break;
case 'k':
killprint++;
case 's':
suppress_print++;
break;
case 'u':
unbuffered++;
break;
case 'v':
@ -94,16 +103,21 @@ main(argc, argv)
default:
fprintf(stderr,
"usage: %s [-d] [-i] [-k] [-v] [-c cmd | file | -] [arg] ...\n",
"usage: %s [-d] [-i] [-s] [-u ] [-v] [-c cmd | file | -] [arg] ...\n",
argv[0]);
fprintf(stderr, "\
\n\
Options and arguments (and corresponding environment variables):\n\
-d : debug output from parser (also PYTHONDEBUG=x)\n\
-i : inspect interactively after running script (also PYTHONINSPECT=x)\n\
-k : kill printing expression statement (also PYTHONKILLPRINT=x)\n\
-s : suppress the printing of top level expressions (also PYTHONSUPPRESS=x)\n\
-u : unbuffered stdout and stderr (also PYTHONUNBUFFERED=x)\n\
-v : verbose (trace import statements) (also PYTHONVERBOSE=x)\n\
-c cmd : program passed in as string (terminates option list)\n\
");
/* ANSI does not allow strings > 512 chars
and MPW doesn't like it either -- so split it! */
fprintf(stderr, "\
file : program read from script file\n\
- : program read from stdin (default; interactive mode if a tty)\n\
arg ...: arguments passed to program in sys.argv[1:]\n\
@ -118,9 +132,25 @@ PYTHONPATH : colon-separated list of directories prefixed to the\n\
}
}
if (unbuffered) {
#ifndef MPW
setbuf(stdout, (char *)NULL);
setbuf(stderr, (char *)NULL);
#else
/* On MPW (3.2) unbuffered seems to hang */
setvbuf(stdout, (char *)NULL, _IOLBF, BUFSIZ);
setvbuf(stderr, (char *)NULL, _IOLBF, BUFSIZ);
#endif
}
if (command == NULL && optind < argc && strcmp(argv[optind], "-") != 0)
filename = argv[optind];
if (verbose ||
command == NULL && filename == NULL && isatty((int)fileno(fp)))
fprintf(stderr, "Python %s\n%s\n",
getversion(), getcopyright());
if (filename != NULL) {
if ((fp = fopen(filename, "r")) == NULL) {
@ -146,15 +176,22 @@ PYTHONPATH : colon-separated list of directories prefixed to the\n\
else {
if (filename == NULL && isatty((int)fileno(fp))) {
char *startup = getenv("PYTHONSTARTUP");
#ifdef macintosh
if (startup == NULL)
startup = "PythonStartup";
#endif
if (startup != NULL && startup[0] != '\0') {
FILE *fp = fopen(startup, "r");
if (fp != NULL) {
(void) run_script(fp, startup);
err_clear();
fclose(fp);
}
}
}
sts = run(fp, filename == NULL ? "<stdin>" : filename) != 0;
if (filename != NULL)
fclose(fp);
}
if (inspect && isatty((int)fileno(stdin)) &&

4
Python/strerror.c
View file

@ -1,5 +1,5 @@
/***********************************************************
Copyright 1991, 1992, 1993 by Stichting Mathematisch Centrum,
Copyright 1991, 1992, 1993, 1994 by Stichting Mathematisch Centrum,
Amsterdam, The Netherlands.
All Rights Reserved
@ -41,7 +41,7 @@ strerror(err)
return buf;
}
#ifdef THINK_C
#ifdef macintosh
int sys_nerr = 0;
char *sys_errlist[1] = 0;
#endif

7
Python/structmember.c
View file

@ -1,5 +1,5 @@
/***********************************************************
Copyright 1991, 1992, 1993 by Stichting Mathematisch Centrum,
Copyright 1991, 1992, 1993, 1994 by Stichting Mathematisch Centrum,
Amsterdam, The Netherlands.
All Rights Reserved
@ -144,6 +144,11 @@ setmember(addr, mlist, name, v)
err_setstr(TypeError, "readonly attribute");
return -1;
}
if (v == NULL && l->type != T_OBJECT) {
err_setstr(TypeError,
"can't delete numeric/char attribute");
return -1;
}
addr += l->offset;
switch (l->type) {
case T_BYTE:

22
Python/sysmodule.c
View file

@ -1,5 +1,5 @@
/***********************************************************
Copyright 1991, 1992, 1993 by Stichting Mathematisch Centrum,
Copyright 1991, 1992, 1993, 1994 by Stichting Mathematisch Centrum,
Amsterdam, The Netherlands.
All Rights Reserved
@ -168,16 +168,22 @@ list_builtin_module_names()
addlistitem(list, name);
DECREF(name);
}
if (sortlist(list) != 0) {
DECREF(list);
list = NULL;
}
return list;
}
void
initsys()
{
extern long getmaxint PROTO((void));
extern char *getversion PROTO((void));
extern char *getcopyright PROTO((void));
extern int fclose PROTO((FILE *));
extern char version[];
object *v = newstringobject(version);
object *m = initmodule("sys", sys_methods);
object *v;
sysdict = getmoduledict(m);
INCREF(sysdict);
/* NB keep an extra ref to the std files to avoid closing them
@ -186,17 +192,21 @@ initsys()
sysout = newopenfileobject(stdout, "<stdout>", "w", fclose);
syserr = newopenfileobject(stderr, "<stderr>", "w", fclose);
if (err_occurred())
fatal("can't create sys.* objects");
fatal("can't initialize sys.std{in,out,err}");
dictinsert(sysdict, "stdin", sysin);
dictinsert(sysdict, "stdout", sysout);
dictinsert(sysdict, "stderr", syserr);
dictinsert(sysdict, "version", v);
dictinsert(sysdict, "version", v = newstringobject(getversion()));
XDECREF(v);
dictinsert(sysdict, "copyright", v = newstringobject(getcopyright()));
XDECREF(v);
dictinsert(sysdict, "maxint", v = newintobject(getmaxint()));
XDECREF(v);
dictinsert(sysdict, "modules", get_modules());
dictinsert(sysdict, "builtin_module_names",
list_builtin_module_names());
if (err_occurred())
fatal("can't insert sys.* objects in sys dict");
DECREF(v);
}
static object *

609
Python/thread.c
View file

@ -1,5 +1,5 @@
/***********************************************************
Copyright 1991, 1992, 1993 by Stichting Mathematisch Centrum,
Copyright 1991, 1992, 1993, 1994 by Stichting Mathematisch Centrum,
Amsterdam, The Netherlands.
All Rights Reserved
@ -22,66 +22,44 @@ OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
******************************************************************/
/* Thread package.
This is intended to be usable independently from Python.
The implementation for system foobar is in a file thread_foobar.h
which is included by this file dependent on config settings.
Stuff shared by all thread_*.h files is collected here. */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <stdio.h>
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#else
extern char *getenv();
#endif
#include "thread.h"
#ifdef DEBUG
static int thread_debug = 0;
#define dprintf(args) ((thread_debug & 1) && printf args)
#define d2printf(args) ((thread_debug & 8) && printf args)
#else
#define dprintf(args)
#define d2printf(args)
#ifdef __ksr__
#define _POSIX_THREADS
#endif
#ifndef _POSIX_THREADS
#ifdef __sgi
#include <stdlib.h>
#include <stdio.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/prctl.h>
#include <ulocks.h>
#include <errno.h>
#define HDR_SIZE 2680 /* sizeof(ushdr_t) */
#define MAXPROC 100 /* max # of threads that can be started */
static usptr_t *shared_arena;
static ulock_t count_lock; /* protection for some variables */
static ulock_t wait_lock; /* lock used to wait for other threads */
static int waiting_for_threads; /* protected by count_lock */
static int nthreads; /* protected by count_lock */
static int exit_status;
static int do_exit; /* indicates that the program is to exit */
static int exiting; /* we're already exiting (for maybe_exit) */
static pid_t my_pid; /* PID of main thread */
static pid_t pidlist[MAXPROC]; /* PIDs of other threads */
static int maxpidindex; /* # of PIDs in pidlist */
#endif /* __sgi */
#ifdef SOLARIS
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include </usr/include/thread.h>
#undef sun
#define SGI_THREADS
#endif
#ifdef sun
#include <lwp/lwp.h>
#include <lwp/stackdep.h>
#define STACKSIZE 1000 /* stacksize for a thread */
#define NSTACKS 2 /* # stacks to be put in cache initialy */
#ifdef HAVE_THREAD_H
#define SOLARIS_THREADS
#endif
#if defined(sun) && !defined(SOLARIS_THREADS)
#define SUN_LWP
#endif
struct lock {
int lock_locked;
cv_t lock_condvar;
mon_t lock_monitor;
};
#endif /* sun */
#ifdef C_THREADS
#include <cthreads.h>
#endif /* C_THREADS */
#ifdef _POSIX_THREADS
#include <pthread.h>
#endif /* _POSIX_THREADS */
#ifdef __STDC__
@ -96,58 +74,21 @@ struct lock {
#define _P2(v1,t1,v2,t2) (v1,v2) t1; t2;
#endif /* __STDC__ */
#ifdef DEBUG
static int thread_debug = 0;
#define dprintf(args) ((thread_debug & 1) && printf args)
#define d2printf(args) ((thread_debug & 8) && printf args)
#else
#define dprintf(args)
#define d2printf(args)
#endif
static int initialized;
#ifdef __sgi
/*
* This routine is called as a signal handler when another thread
* exits. When that happens, we must see whether we have to exit as
* well (because of an exit_prog()) or whether we should continue on.
*/
static void exit_sig _P0()
{
d2printf(("exit_sig called\n"));
if (exiting && getpid() == my_pid) {
d2printf(("already exiting\n"));
return;
}
if (do_exit) {
d2printf(("exiting in exit_sig\n"));
#ifdef DEBUG
if ((thread_debug & 8) == 0)
thread_debug &= ~1; /* don't produce debug messages */
#endif
exit_thread();
}
}
static void _init_thread(); /* Forward */
/*
* This routine is called when a process calls exit(). If that wasn't
* done from the library, we do as if an exit_prog() was intended.
*/
static void maybe_exit _P0()
{
dprintf(("maybe_exit called\n"));
if (exiting) {
dprintf(("already exiting\n"));
return;
}
exit_prog(0);
}
#endif /* __sgi */
/*
* Initialization.
*/
void init_thread _P0()
{
#ifdef __sgi
struct sigaction s;
#ifdef USE_DL
long addr, size;
#endif /* USE_DL */
#endif /* __sgi */
#ifdef DEBUG
char *p = getenv("THREADDEBUG");
@ -162,465 +103,31 @@ void init_thread _P0()
return;
initialized = 1;
dprintf(("init_thread called\n"));
#ifdef __sgi
#ifdef USE_DL
if ((size = usconfig(CONF_INITSIZE, 64*1024)) < 0)
perror("usconfig - CONF_INITSIZE (check)");
if (usconfig(CONF_INITSIZE, size) < 0)
perror("usconfig - CONF_INITSIZE (reset)");
addr = (long) dl_getrange(size + HDR_SIZE);
dprintf(("trying to use addr %lx-%lx for shared arena\n", addr, addr+size));
errno = 0;
if ((addr = usconfig(CONF_ATTACHADDR, addr)) < 0 && errno != 0)
perror("usconfig - CONF_ATTACHADDR (set)");
#endif /* USE_DL */
if (usconfig(CONF_INITUSERS, 16) < 0)
perror("usconfig - CONF_INITUSERS");
my_pid = getpid(); /* so that we know which is the main thread */
atexit(maybe_exit);
s.sa_handler = exit_sig;
sigemptyset(&s.sa_mask);
/*sigaddset(&s.sa_mask, SIGUSR1);*/
s.sa_flags = 0;
sigaction(SIGUSR1, &s, 0);
if (prctl(PR_SETEXITSIG, SIGUSR1) < 0)
perror("prctl - PR_SETEXITSIG");
if (usconfig(CONF_ARENATYPE, US_SHAREDONLY) < 0)
perror("usconfig - CONF_ARENATYPE");
#ifdef DEBUG
if (thread_debug & 4)
usconfig(CONF_LOCKTYPE, US_DEBUGPLUS);
else if (thread_debug & 2)
usconfig(CONF_LOCKTYPE, US_DEBUG);
#endif /* DEBUG */
if ((shared_arena = usinit(tmpnam(0))) == 0)
perror("usinit");
#ifdef USE_DL
if (usconfig(CONF_ATTACHADDR, addr) < 0) /* reset address */
perror("usconfig - CONF_ATTACHADDR (reset)");
#endif /* USE_DL */
if ((count_lock = usnewlock(shared_arena)) == NULL)
perror("usnewlock (count_lock)");
(void) usinitlock(count_lock);
if ((wait_lock = usnewlock(shared_arena)) == NULL)
perror("usnewlock (wait_lock)");
dprintf(("arena start: %lx, arena size: %ld\n", (long) shared_arena, (long) usconfig(CONF_GETSIZE, shared_arena)));
#endif /* __sgi */
#ifdef SOLARIS
/* nothing */
#endif
#ifdef sun
lwp_setstkcache(STACKSIZE, NSTACKS);
#endif /* sun */
#ifdef C_THREADS
cthread_init();
#endif /* C_THREADS */
_init_thread();
}
/*
* Thread support.
*/
#ifdef SOLARIS
struct func_arg {
void (*func) _P((void *));
void *arg;
};
static void *new_func _P1(funcarg, void *funcarg)
{
void (*func) _P((void *));
void *arg;
func = ((struct func_arg *) funcarg)->func;
arg = ((struct func_arg *) funcarg)->arg;
free(funcarg);
(*func)(arg);
return 0;
}
#endif /* SOLARIS */
int start_new_thread _P2(func, void (*func) _P((void *)), arg, void *arg)
{
#ifdef SOLARIS
struct func_arg *funcarg;
#ifdef SGI_THREADS
#include "thread_sgi.h"
#endif
#ifdef sun
thread_t tid;
#endif /* sun */
#if defined(__sgi) && defined(USE_DL)
long addr, size;
static int local_initialized = 0;
#endif /* __sgi and USE_DL */
#ifdef SOLARIS_THREADS
#include "thread_solaris.h"
#endif
#ifdef SUN_LWP
#include "thread_lwp.h"
#endif
#ifdef _POSIX_THREADS
pthread_t th;
#include "thread_pthread.h"
#endif
int success = 0; /* init not needed when SOLARIS and */
/* C_THREADS implemented properly */
dprintf(("start_new_thread called\n"));
if (!initialized)
init_thread();
#ifdef __sgi
switch (ussetlock(count_lock)) {
case 0: return 0;
case -1: perror("ussetlock (count_lock)");
}
if (maxpidindex >= MAXPROC)
success = -1;
else {
#ifdef USE_DL
if (!local_initialized) {
if ((size = usconfig(CONF_INITSIZE, 64*1024)) < 0)
perror("usconfig - CONF_INITSIZE (check)");
if (usconfig(CONF_INITSIZE, size) < 0)
perror("usconfig - CONF_INITSIZE (reset)");
addr = (long) dl_getrange(size + HDR_SIZE);
dprintf(("trying to use addr %lx-%lx for sproc\n", addr, addr+size));
errno = 0;
if ((addr = usconfig(CONF_ATTACHADDR, addr)) < 0 && errno != 0)
perror("usconfig - CONF_ATTACHADDR (set)");
}
#endif /* USE_DL */
if ((success = sproc(func, PR_SALL, arg)) < 0)
perror("sproc");
#ifdef USE_DL
if (!local_initialized) {
if (usconfig(CONF_ATTACHADDR, addr) < 0) /* reset address */
perror("usconfig - CONF_ATTACHADDR (reset)");
local_initialized = 1;
}
#endif /* USE_DL */
if (success >= 0) {
nthreads++;
pidlist[maxpidindex++] = success;
}
}
if (usunsetlock(count_lock) < 0)
perror("usunsetlock (count_lock)");
#endif /* __sgi */
#ifdef SOLARIS
funcarg = (struct func_arg *) malloc(sizeof(struct func_arg));
funcarg->func = func;
funcarg->arg = arg;
if (thr_create(0, 0, new_func, funcarg, THR_NEW_LWP, 0)) {
perror("thr_create");
free((void *) funcarg);
success = -1;
}
#endif /* SOLARIS */
#ifdef sun
success = lwp_create(&tid, func, MINPRIO, 0, lwp_newstk(), 1, arg);
#endif /* sun */
#ifdef C_THREADS
(void) cthread_fork(func, arg);
#endif /* C_THREADS */
#ifdef _POSIX_THREADS
pthread_create(&th, NULL, func, arg);
#include "thread_cthread.h"
#endif
return success < 0 ? 0 : 1;
}
static void do_exit_thread _P1(no_cleanup, int no_cleanup)
{
dprintf(("exit_thread called\n"));
if (!initialized)
if (no_cleanup)
_exit(0);
else
exit(0);
#ifdef __sgi
if (ussetlock(count_lock) < 0)
perror("ussetlock (count_lock)");
nthreads--;
if (getpid() == my_pid) {
/* main thread; wait for other threads to exit */
exiting = 1;
if (do_exit) {
int i;
/* notify other threads */
if (nthreads >= 0) {
dprintf(("kill other threads\n"));
for (i = 0; i < maxpidindex; i++)
(void) kill(pidlist[i], SIGKILL);
_exit(exit_status);
}
}
waiting_for_threads = 1;
if (ussetlock(wait_lock) < 0)
perror("ussetlock (wait_lock)");
for (;;) {
if (nthreads < 0) {
dprintf(("really exit (%d)\n", exit_status));
if (no_cleanup)
_exit(exit_status);
else
exit(exit_status);
}
if (usunsetlock(count_lock) < 0)
perror("usunsetlock (count_lock)");
dprintf(("waiting for other threads (%d)\n", nthreads));
if (ussetlock(wait_lock) < 0)
perror("ussetlock (wait_lock)");
if (ussetlock(count_lock) < 0)
perror("ussetlock (count_lock)");
}
}
/* not the main thread */
if (waiting_for_threads) {
dprintf(("main thread is waiting\n"));
if (usunsetlock(wait_lock) < 0)
perror("usunsetlock (wait_lock)");
} else if (do_exit)
(void) kill(my_pid, SIGUSR1);
if (usunsetlock(count_lock) < 0)
perror("usunsetlock (count_lock)");
_exit(0);
#endif /* __sgi */
#ifdef SOLARIS
thr_exit(0);
#endif /* SOLARIS */
#ifdef sun
lwp_destroy(SELF);
#endif /* sun */
#ifdef C_THREADS
cthread_exit(0);
#endif /* C_THREADS */
}
void exit_thread _P0()
{
do_exit_thread(0);
}
void _exit_thread _P0()
{
do_exit_thread(1);
}
static void do_exit_prog _P2(status, int status, no_cleanup, int no_cleanup)
{
dprintf(("exit_prog(%d) called\n", status));
if (!initialized)
if (no_cleanup)
_exit(status);
else
exit(status);
#ifdef __sgi
do_exit = 1;
exit_status = status;
do_exit_thread(no_cleanup);
#endif
#ifdef SOLARIS
if (no_cleanup)
_exit(status);
else
exit(status);
#endif
#ifdef sun
pod_exit(status);
#endif
}
void exit_prog _P1(status, int status)
{
do_exit_prog(status, 0);
}
void _exit_prog _P1(status, int status)
{
do_exit_prog(status, 1);
}
/*
* Lock support.
*/
type_lock allocate_lock _P0()
{
#ifdef __sgi
ulock_t lock;
#ifdef FOOBAR_THREADS
#include "thread_foobar.h"
#endif
#ifdef SOLARIS
mutex_t *lock;
#endif
#ifdef sun
struct lock *lock;
extern char *malloc();
#endif
dprintf(("allocate_lock called\n"));
if (!initialized)
init_thread();
#ifdef __sgi
if ((lock = usnewlock(shared_arena)) == NULL)
perror("usnewlock");
(void) usinitlock(lock);
#endif /* __sgi */
#ifdef SOLARIS
lock = (mutex_t *) malloc(sizeof(mutex_t));
if (mutex_init(lock, USYNC_THREAD, 0)) {
perror("mutex_init");
free((void *) lock);
lock = 0;
}
#endif /* SOLARIS */
#ifdef sun
lock = (struct lock *) malloc(sizeof(struct lock));
lock->lock_locked = 0;
(void) mon_create(&lock->lock_monitor);
(void) cv_create(&lock->lock_condvar, lock->lock_monitor);
#endif /* sun */
dprintf(("allocate_lock() -> %lx\n", (long)lock));
return (type_lock) lock;
}
void free_lock _P1(lock, type_lock lock)
{
dprintf(("free_lock(%lx) called\n", (long)lock));
#ifdef __sgi
usfreelock((ulock_t) lock, shared_arena);
#endif /* __sgi */
#ifdef SOLARIS
mutex_destroy((mutex_t *) lock);
free((void *) lock);
#endif
#ifdef sun
mon_destroy(((struct lock *) lock)->lock_monitor);
free((char *) lock);
#endif /* sun */
}
int acquire_lock _P2(lock, type_lock lock, waitflag, int waitflag)
{
int success;
dprintf(("acquire_lock(%lx, %d) called\n", (long)lock, waitflag));
#ifdef __sgi
errno = 0; /* clear it just in case */
if (waitflag)
success = ussetlock((ulock_t) lock);
else
success = uscsetlock((ulock_t) lock, 1); /* Try it once */
if (success < 0)
perror(waitflag ? "ussetlock" : "uscsetlock");
#endif /* __sgi */
#ifdef SOLARIS
if (waitflag)
success = mutex_lock((mutex_t *) lock);
else
success = mutex_trylock((mutex_t *) lock);
if (success < 0)
perror(waitflag ? "mutex_lock" : "mutex_trylock");
else
success = !success; /* solaris does it the other way round */
#endif /* SOLARIS */
#ifdef sun
success = 0;
(void) mon_enter(((struct lock *) lock)->lock_monitor);
if (waitflag)
while (((struct lock *) lock)->lock_locked)
cv_wait(((struct lock *) lock)->lock_condvar);
if (!((struct lock *) lock)->lock_locked) {
success = 1;
((struct lock *) lock)->lock_locked = 1;
}
cv_broadcast(((struct lock *) lock)->lock_condvar);
mon_exit(((struct lock *) lock)->lock_monitor);
#endif /* sun */
dprintf(("acquire_lock(%lx, %d) -> %d\n", (long)lock, waitflag, success));
return success;
}
void release_lock _P1(lock, type_lock lock)
{
dprintf(("release_lock(%lx) called\n", (long)lock));
#ifdef __sgi
if (usunsetlock((ulock_t) lock) < 0)
perror("usunsetlock");
#endif /* __sgi */
#ifdef SOLARIS
if (mutex_unlock((mutex_t *) lock))
perror("mutex_unlock");
#endif /* SOLARIS */
#ifdef sun
(void) mon_enter(((struct lock *) lock)->lock_monitor);
((struct lock *) lock)->lock_locked = 0;
cv_broadcast(((struct lock *) lock)->lock_condvar);
mon_exit(((struct lock *) lock)->lock_monitor);
#endif /* sun */
}
/*
* Semaphore support.
*/
type_sema allocate_sema _P1(value, int value)
{
#ifdef __sgi
usema_t *sema;
#endif /* __sgi */
#ifdef SOLARIS
sema_t *sema;
#endif
dprintf(("allocate_sema called\n"));
if (!initialized)
init_thread();
#ifdef __sgi
if ((sema = usnewsema(shared_arena, value)) == NULL)
perror("usnewsema");
#endif /* __sgi */
#ifdef SOLARIS
sema = (sema_t *) malloc(sizeof(sema_t));
if (sema_init(sema, value, USYNC_THREAD, 0)) {
perror("sema_init");
free((void *) sema);
sema = 0;
}
#endif /* SOLARIS */
dprintf(("allocate_sema() -> %lx\n", (long) sema));
return (type_sema) sema;
}
void free_sema _P1(sema, type_sema sema)
{
dprintf(("free_sema(%lx) called\n", (long) sema));
#ifdef __sgi
usfreesema((usema_t *) sema, shared_arena);
#endif /* __sgi */
#ifdef SOLARIS
if (sema_destroy((sema_t *) sema))
perror("sema_destroy");
free((void *) sema);
#endif /* SOLARIS */
}
void down_sema _P1(sema, type_sema sema)
{
dprintf(("down_sema(%lx) called\n", (long) sema));
#ifdef __sgi
if (uspsema((usema_t *) sema) < 0)
perror("uspsema");
#endif
#ifdef SOLARIS
if (sema_wait((sema_t *) sema))
perror("sema_wait");
#endif
dprintf(("down_sema(%lx) return\n", (long) sema));
}
void up_sema _P1(sema, type_sema sema)
{
dprintf(("up_sema(%lx)\n", (long) sema));
#ifdef __sgi
if (usvsema((usema_t *) sema) < 0)
perror("usvsema");
#endif /* __sgi */
#ifdef SOLARIS
if (sema_post((sema_t *) sema))
perror("sema_post");
#endif
}
*/