Trent Mick <trentm@activestate.com>:
The common technique for printing out a pointer has been to cast to a long and use the "%lx" printf modifier. This is incorrect on Win64 where casting to a long truncates the pointer. The "%p" formatter should be used instead. The problem as stated by Tim: > Unfortunately, the C committee refused to define what %p conversion "looks > like" -- they explicitly allowed it to be implementation-defined. Older > versions of Microsoft C even stuck a colon in the middle of the address (in > the days of segment+offset addressing)! The result is that the hex value of a pointer will maybe/maybe not have a 0x prepended to it. Notes on the patch: There are two main classes of changes: - in the various repr() functions that print out pointers - debugging printf's in the various thread_*.h files (these are why the patch is large) Closes SourceForge patch #100505.
This commit is contained in:
Fred Drake
parent
d49e5b4667
commit
a44d353e2b
|
|
@ -1705,7 +1705,7 @@ Tktt_Repr(self)
|
|||
TkttObject *v = (TkttObject *)self;
|
||||
char buf[100];
|
||||
|
||||
sprintf(buf, "<tktimertoken at 0x%lx%s>", (long)v,
|
||||
sprintf(buf, "<tktimertoken at %p%s>", v,
|
||||
v->func == NULL ? ", handler deleted" : "");
|
||||
return PyString_FromString(buf);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -435,8 +435,8 @@ generic_repr(g)
|
|||
genericobject *g;
|
||||
{
|
||||
char buf[100];
|
||||
sprintf(buf, "<FORMS_object at %lx, objclass=%d>",
|
||||
(long)g, g->ob_generic->objclass);
|
||||
sprintf(buf, "<FORMS_object at %p, objclass=%d>",
|
||||
g, g->ob_generic->objclass);
|
||||
return PyString_FromString(buf);
|
||||
}
|
||||
|
||||
|
|
@ -1906,8 +1906,8 @@ form_repr(f)
|
|||
formobject *f;
|
||||
{
|
||||
char buf[100];
|
||||
sprintf(buf, "<FORMS_form at %lx, window=%ld>",
|
||||
(long)f, f->ob_form->window);
|
||||
sprintf(buf, "<FORMS_form at %p, window=%ld>",
|
||||
f, f->ob_form->window);
|
||||
return PyString_FromString(buf);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -262,7 +262,7 @@ mpz_format(objp, base, withname)
|
|||
|
||||
#ifdef MPZ_DEBUG
|
||||
fprintf(stderr,
|
||||
"mpz_format: cp (str end) 0x%x, begin 0x%x, diff %d, i %d\n",
|
||||
"mpz_format: cp (str end) %p, begin %p, diff %d, i %d\n",
|
||||
cp, PyString_AS_STRING(strobjp),
|
||||
cp - PyString_AS_STRING(strobjp), i);
|
||||
#endif /* def MPZ_DEBUG */
|
||||
|
|
@ -1765,7 +1765,7 @@ void *mp_allocate( alloc_size )
|
|||
Py_FatalError("mp_allocate failure");
|
||||
|
||||
#ifdef MPZ_DEBUG
|
||||
fprintf(stderr, "mp_allocate : address 0x%08x\n", res);
|
||||
fprintf(stderr, "mp_allocate : address %08p\n", res);
|
||||
#endif /* def MPZ_DEBUG */
|
||||
|
||||
MP_SET_TEST(res,alloc_size);
|
||||
|
|
@ -1782,7 +1782,7 @@ void *mp_reallocate( ptr, old_size, new_size )
|
|||
void *res;
|
||||
|
||||
#ifdef MPZ_DEBUG
|
||||
fprintf(stderr, "mp_reallocate: old address 0x%08x, old size %ld\n",
|
||||
fprintf(stderr, "mp_reallocate: old address %08p, old size %ld\n",
|
||||
ptr, old_size);
|
||||
#endif /* def MPZ_DEBUG */
|
||||
|
||||
|
|
@ -1792,7 +1792,7 @@ void *mp_reallocate( ptr, old_size, new_size )
|
|||
Py_FatalError("mp_reallocate failure");
|
||||
|
||||
#ifdef MPZ_DEBUG
|
||||
fprintf(stderr, "mp_reallocate: new address 0x%08x, new size %ld\n",
|
||||
fprintf(stderr, "mp_reallocate: new address %08p, new size %ld\n",
|
||||
res, new_size);
|
||||
#endif /* def MPZ_DEBUG */
|
||||
|
||||
|
|
@ -1808,7 +1808,7 @@ void mp_free( ptr, size )
|
|||
{
|
||||
|
||||
#ifdef MPZ_DEBUG
|
||||
fprintf(stderr, "mp_free : old address 0x%08x, old size %ld\n",
|
||||
fprintf(stderr, "mp_free : old address %08p, old size %ld\n",
|
||||
ptr, size);
|
||||
#endif /* def MPZ_DEBUG */
|
||||
|
||||
|
|
|
|||
|
|
@ -241,20 +241,20 @@ buffer_repr(self)
|
|||
|
||||
if ( self->b_base == NULL )
|
||||
{
|
||||
sprintf(buf, "<%s buffer ptr %lx, size %d at %lx>",
|
||||
sprintf(buf, "<%s buffer ptr %p, size %d at %p>",
|
||||
status,
|
||||
(long)self->b_ptr,
|
||||
self->b_ptr,
|
||||
self->b_size,
|
||||
(long)self);
|
||||
self);
|
||||
}
|
||||
else
|
||||
{
|
||||
sprintf(buf, "<%s buffer for %lx, ptr %lx, size %d at %lx>",
|
||||
sprintf(buf, "<%s buffer for %p, ptr %p, size %d at %p>",
|
||||
status,
|
||||
(long)self->b_base,
|
||||
(long)self->b_ptr,
|
||||
self->b_base,
|
||||
self->b_ptr,
|
||||
self->b_size,
|
||||
(long)self);
|
||||
self);
|
||||
}
|
||||
|
||||
return PyString_FromString(buf);
|
||||
|
|
|
|||
|
|
@ -353,11 +353,11 @@ class_repr(op)
|
|||
else
|
||||
name = PyString_AsString(op->cl_name);
|
||||
if (mod == NULL || !PyString_Check(mod))
|
||||
sprintf(buf, "<class ?.%.100s at %lx>", name, (long)op);
|
||||
sprintf(buf, "<class ?.%.100s at %p>", name, op);
|
||||
else
|
||||
sprintf(buf, "<class %.50s.%.50s at %lx>",
|
||||
sprintf(buf, "<class %.50s.%.50s at %p>",
|
||||
PyString_AsString(mod),
|
||||
name, (long)op);
|
||||
name, op);
|
||||
return PyString_FromString(buf);
|
||||
}
|
||||
|
||||
|
|
@ -805,12 +805,12 @@ instance_repr(inst)
|
|||
cname = "?";
|
||||
PyErr_Clear();
|
||||
if (mod == NULL || !PyString_Check(mod))
|
||||
sprintf(buf, "<?.%.100s instance at %lx>",
|
||||
cname, (long)inst);
|
||||
sprintf(buf, "<?.%.100s instance at %p>",
|
||||
cname, inst);
|
||||
else
|
||||
sprintf(buf, "<%.50s.%.50s instance at %lx>",
|
||||
sprintf(buf, "<%.50s.%.50s instance at %p>",
|
||||
PyString_AsString(mod),
|
||||
cname, (long)inst);
|
||||
cname, inst);
|
||||
return PyString_FromString(buf);
|
||||
}
|
||||
res = PyEval_CallObject(func, (PyObject *)NULL);
|
||||
|
|
@ -1704,8 +1704,8 @@ instancemethod_repr(a)
|
|||
icname = PyString_AsString(iclassname);
|
||||
else
|
||||
icname = "?";
|
||||
sprintf(buf, "<method %.60s.%.60s of %.60s instance at %lx>",
|
||||
fcname, fname, icname, (long)self);
|
||||
sprintf(buf, "<method %.60s.%.60s of %.60s instance at %p>",
|
||||
fcname, fname, icname, self);
|
||||
}
|
||||
Py_XDECREF(funcname);
|
||||
return PyString_FromString(buf);
|
||||
|
|
|
|||
|
|
@ -240,11 +240,11 @@ file_repr(f)
|
|||
PyFileObject *f;
|
||||
{
|
||||
char buf[300];
|
||||
sprintf(buf, "<%s file '%.256s', mode '%.10s' at %lx>",
|
||||
sprintf(buf, "<%s file '%.256s', mode '%.10s' at %p>",
|
||||
f->f_fp == NULL ? "closed" : "open",
|
||||
PyString_AsString(f->f_name),
|
||||
PyString_AsString(f->f_mode),
|
||||
(long)f);
|
||||
f);
|
||||
return PyString_FromString(buf);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -806,8 +806,8 @@ PyFloat_Fini()
|
|||
char buf[100];
|
||||
PyFloat_AsString(buf, p);
|
||||
fprintf(stderr,
|
||||
"# <float at %lx, refcnt=%d, val=%s>\n",
|
||||
(long)p, p->ob_refcnt, buf);
|
||||
"# <float at %p, refcnt=%d, val=%s>\n",
|
||||
p, p->ob_refcnt, buf);
|
||||
}
|
||||
}
|
||||
list = list->next;
|
||||
|
|
|
|||
|
|
@ -202,11 +202,11 @@ func_repr(op)
|
|||
{
|
||||
char buf[140];
|
||||
if (op->func_name == Py_None)
|
||||
sprintf(buf, "<anonymous function at %lx>", (long)op);
|
||||
sprintf(buf, "<anonymous function at %p>", op);
|
||||
else
|
||||
sprintf(buf, "<function %.100s at %lx>",
|
||||
sprintf(buf, "<function %.100s at %p>",
|
||||
PyString_AsString(op->func_name),
|
||||
(long)op);
|
||||
op);
|
||||
return PyString_FromString(buf);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -957,8 +957,8 @@ PyInt_Fini()
|
|||
i++, p++) {
|
||||
if (PyInt_Check(p) && p->ob_refcnt != 0)
|
||||
fprintf(stderr,
|
||||
"# <int at %lx, refcnt=%d, val=%ld>\n",
|
||||
(long)p, p->ob_refcnt, p->ob_ival);
|
||||
"# <int at %p, refcnt=%d, val=%ld>\n",
|
||||
p, p->ob_refcnt, p->ob_ival);
|
||||
}
|
||||
list = list->next;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -148,9 +148,9 @@ meth_repr(m)
|
|||
sprintf(buf, "<built-in function %.80s>", m->m_ml->ml_name);
|
||||
else
|
||||
sprintf(buf,
|
||||
"<built-in method %.80s of %.80s object at %lx>",
|
||||
"<built-in method %.80s of %.80s object at %p>",
|
||||
m->m_ml->ml_name, m->m_self->ob_type->tp_name,
|
||||
(long)m->m_self);
|
||||
m->m_self);
|
||||
return PyString_FromString(buf);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -229,12 +229,12 @@ PyObject_Print(op, fp, flags)
|
|||
}
|
||||
else {
|
||||
if (op->ob_refcnt <= 0)
|
||||
fprintf(fp, "<refcnt %u at %lx>",
|
||||
op->ob_refcnt, (long)op);
|
||||
fprintf(fp, "<refcnt %u at %p>",
|
||||
op->ob_refcnt, op);
|
||||
else if (op->ob_type->tp_print == NULL) {
|
||||
if (op->ob_type->tp_repr == NULL) {
|
||||
fprintf(fp, "<%s object at %lx>",
|
||||
op->ob_type->tp_name, (long)op);
|
||||
fprintf(fp, "<%s object at %p>",
|
||||
op->ob_type->tp_name, op);
|
||||
}
|
||||
else {
|
||||
PyObject *s;
|
||||
|
|
@ -280,8 +280,8 @@ PyObject_Repr(v)
|
|||
return PyString_FromString("<NULL>");
|
||||
else if (v->ob_type->tp_repr == NULL) {
|
||||
char buf[120];
|
||||
sprintf(buf, "<%.80s object at %lx>",
|
||||
v->ob_type->tp_name, (long)v);
|
||||
sprintf(buf, "<%.80s object at %p>",
|
||||
v->ob_type->tp_name, v);
|
||||
return PyString_FromString(buf);
|
||||
}
|
||||
else {
|
||||
|
|
|
|||
|
|
@ -262,7 +262,7 @@ PyThread_type_lock PyThread_allocate_lock( void )
|
|||
return (PyThread_type_lock)NULL;
|
||||
}
|
||||
|
||||
dprintf(("PyThread_allocate_lock() -> %lx\n", (long)lock));
|
||||
dprintf(("PyThread_allocate_lock() -> %p\n", lock));
|
||||
return (PyThread_type_lock) lock;
|
||||
}
|
||||
|
||||
|
|
@ -270,7 +270,7 @@ void PyThread_free_lock( PyThread_type_lock lock )
|
|||
{
|
||||
status_t retval;
|
||||
|
||||
dprintf(("PyThread_free_lock(%lx) called\n", (long)lock));
|
||||
dprintf(("PyThread_free_lock(%p) called\n", lock));
|
||||
|
||||
retval = benaphore_destroy( (benaphore_t *)lock );
|
||||
if( retval != EOK ) {
|
||||
|
|
@ -284,7 +284,7 @@ int PyThread_acquire_lock( PyThread_type_lock lock, int waitflag )
|
|||
int success;
|
||||
status_t retval;
|
||||
|
||||
dprintf(("PyThread_acquire_lock(%lx, %d) called\n", (long)lock, waitflag));
|
||||
dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
|
||||
|
||||
if( waitflag ) {
|
||||
retval = benaphore_lock( (benaphore_t *)lock );
|
||||
|
|
@ -300,7 +300,7 @@ int PyThread_acquire_lock( PyThread_type_lock lock, int waitflag )
|
|||
/* TODO: that's bad, raise an exception */
|
||||
}
|
||||
|
||||
dprintf(("PyThread_acquire_lock(%lx, %d) -> %d\n", (long)lock, waitflag, success));
|
||||
dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
|
||||
return success;
|
||||
}
|
||||
|
||||
|
|
@ -308,7 +308,7 @@ void PyThread_release_lock( PyThread_type_lock lock )
|
|||
{
|
||||
status_t retval;
|
||||
|
||||
dprintf(("PyThread_release_lock(%lx) called\n", (long)lock));
|
||||
dprintf(("PyThread_release_lock(%p) called\n", lock));
|
||||
|
||||
retval = benaphore_unlock( (benaphore_t *)lock );
|
||||
if( retval != EOK ) {
|
||||
|
|
@ -336,7 +336,7 @@ PyThread_type_sema PyThread_allocate_sema( int value )
|
|||
return 0;
|
||||
}
|
||||
|
||||
dprintf(("PyThread_allocate_sema() -> %lx\n", (long) sema));
|
||||
dprintf(("PyThread_allocate_sema() -> %p\n", sema));
|
||||
return (PyThread_type_sema) sema;
|
||||
}
|
||||
|
||||
|
|
@ -344,7 +344,7 @@ void PyThread_free_sema( PyThread_type_sema sema )
|
|||
{
|
||||
status_t retval;
|
||||
|
||||
dprintf(("PyThread_free_sema(%lx) called\n", (long) sema));
|
||||
dprintf(("PyThread_free_sema(%p) called\n", sema));
|
||||
|
||||
retval = delete_sem( (sem_id)sema );
|
||||
if( retval != B_NO_ERROR ) {
|
||||
|
|
@ -357,7 +357,7 @@ int PyThread_down_sema( PyThread_type_sema sema, int waitflag )
|
|||
{
|
||||
status_t retval;
|
||||
|
||||
dprintf(("PyThread_down_sema(%lx, %d) called\n", (long) sema, waitflag));
|
||||
dprintf(("PyThread_down_sema(%p, %d) called\n", sema, waitflag));
|
||||
|
||||
if( waitflag ) {
|
||||
retval = acquire_sem( (sem_id)sema );
|
||||
|
|
@ -370,7 +370,7 @@ int PyThread_down_sema( PyThread_type_sema sema, int waitflag )
|
|||
return 0;
|
||||
}
|
||||
|
||||
dprintf(("PyThread_down_sema(%lx) return\n", (long) sema));
|
||||
dprintf(("PyThread_down_sema(%p) return\n", sema));
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
|
@ -378,7 +378,7 @@ void PyThread_up_sema( PyThread_type_sema sema )
|
|||
{
|
||||
status_t retval;
|
||||
|
||||
dprintf(("PyThread_up_sema(%lx)\n", (long) sema));
|
||||
dprintf(("PyThread_up_sema(%p)\n", sema));
|
||||
|
||||
retval = release_sem( (sem_id)sema );
|
||||
if( retval != B_NO_ERROR ) {
|
||||
|
|
|
|||
|
|
@ -129,13 +129,13 @@ PyThread_type_lock PyThread_allocate_lock _P0()
|
|||
free((void *) lock);
|
||||
lock = 0;
|
||||
}
|
||||
dprintf(("PyThread_allocate_lock() -> %lx\n", (long)lock));
|
||||
dprintf(("PyThread_allocate_lock() -> %p\n", lock));
|
||||
return (PyThread_type_lock) lock;
|
||||
}
|
||||
|
||||
void PyThread_free_lock _P1(lock, PyThread_type_lock lock)
|
||||
{
|
||||
dprintf(("PyThread_free_lock(%lx) called\n", (long)lock));
|
||||
dprintf(("PyThread_free_lock(%p) called\n", lock));
|
||||
mutex_free(lock);
|
||||
}
|
||||
|
||||
|
|
@ -143,20 +143,20 @@ int PyThread_acquire_lock _P2(lock, PyThread_type_lock lock, waitflag, int waitf
|
|||
{
|
||||
int success = FALSE;
|
||||
|
||||
dprintf(("PyThread_acquire_lock(%lx, %d) called\n", (long)lock, waitflag));
|
||||
dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
|
||||
if (waitflag) { /* blocking */
|
||||
mutex_lock(lock);
|
||||
success = TRUE;
|
||||
} else { /* non blocking */
|
||||
success = mutex_try_lock(lock);
|
||||
}
|
||||
dprintf(("PyThread_acquire_lock(%lx, %d) -> %d\n", (long)lock, waitflag, success));
|
||||
dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
|
||||
return success;
|
||||
}
|
||||
|
||||
void PyThread_release_lock _P1(lock, PyThread_type_lock lock)
|
||||
{
|
||||
dprintf(("PyThread_release_lock(%lx) called\n", (long)lock));
|
||||
dprintf(("PyThread_release_lock(%p) called\n", lock));
|
||||
mutex_unlock((mutex_t )lock);
|
||||
}
|
||||
|
||||
|
|
@ -181,23 +181,23 @@ PyThread_type_sema PyThread_allocate_sema _P1(value, int value)
|
|||
if (!initialized)
|
||||
PyThread_init_thread();
|
||||
|
||||
dprintf(("PyThread_allocate_sema() -> %lx\n", (long) sema));
|
||||
dprintf(("PyThread_allocate_sema() -> %p\n", sema));
|
||||
return (PyThread_type_sema) sema;
|
||||
}
|
||||
|
||||
void PyThread_free_sema _P1(sema, PyThread_type_sema sema)
|
||||
{
|
||||
dprintf(("PyThread_free_sema(%lx) called\n", (long) sema));
|
||||
dprintf(("PyThread_free_sema(%p) called\n", sema));
|
||||
}
|
||||
|
||||
int PyThread_down_sema _P2(sema, PyThread_type_sema sema, waitflag, int waitflag)
|
||||
{
|
||||
dprintf(("PyThread_down_sema(%lx, %d) called\n", (long) sema, waitflag));
|
||||
dprintf(("PyThread_down_sema(%lx) return\n", (long) sema));
|
||||
dprintf(("PyThread_down_sema(%p, %d) called\n", sema, waitflag));
|
||||
dprintf(("PyThread_down_sema(%p) return\n", sema));
|
||||
return -1;
|
||||
}
|
||||
|
||||
void PyThread_up_sema _P1(sema, PyThread_type_sema sema)
|
||||
{
|
||||
dprintf(("PyThread_up_sema(%lx)\n", (long) sema));
|
||||
dprintf(("PyThread_up_sema(%p)\n", sema));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -108,27 +108,27 @@ PyThread_type_lock PyThread_allocate_lock _P0()
|
|||
if (!initialized)
|
||||
PyThread_init_thread();
|
||||
|
||||
dprintf(("PyThread_allocate_lock() -> %lx\n", (long)lock));
|
||||
dprintf(("PyThread_allocate_lock() -> %p\n", lock));
|
||||
return (PyThread_type_lock) lock;
|
||||
}
|
||||
|
||||
void PyThread_free_lock _P1(lock, PyThread_type_lock lock)
|
||||
{
|
||||
dprintf(("PyThread_free_lock(%lx) called\n", (long)lock));
|
||||
dprintf(("PyThread_free_lock(%p) called\n", lock));
|
||||
}
|
||||
|
||||
int PyThread_acquire_lock _P2(lock, PyThread_type_lock lock, waitflag, int waitflag)
|
||||
{
|
||||
int success;
|
||||
|
||||
dprintf(("PyThread_acquire_lock(%lx, %d) called\n", (long)lock, waitflag));
|
||||
dprintf(("PyThread_acquire_lock(%lx, %d) -> %d\n", (long)lock, waitflag, success));
|
||||
dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
|
||||
dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
|
||||
return success;
|
||||
}
|
||||
|
||||
void PyThread_release_lock _P1(lock, PyThread_type_lock lock)
|
||||
{
|
||||
dprintf(("PyThread_release_lock(%lx) called\n", (long)lock));
|
||||
dprintf(("PyThread_release_lock(%p) called\n", lock));
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -140,23 +140,23 @@ PyThread_type_sema PyThread_allocate_sema _P1(value, int value)
|
|||
if (!initialized)
|
||||
PyThread_init_thread();
|
||||
|
||||
dprintf(("PyThread_allocate_sema() -> %lx\n", (long) sema));
|
||||
dprintf(("PyThread_allocate_sema() -> %p\n", sema));
|
||||
return (PyThread_type_sema) sema;
|
||||
}
|
||||
|
||||
void PyThread_free_sema _P1(sema, PyThread_type_sema sema)
|
||||
{
|
||||
dprintf(("PyThread_free_sema(%lx) called\n", (long) sema));
|
||||
dprintf(("PyThread_free_sema(%p) called\n", sema));
|
||||
}
|
||||
|
||||
int PyThread_down_sema _P2(sema, PyThread_type_sema sema, waitflag, int waitflag)
|
||||
{
|
||||
dprintf(("PyThread_down_sema(%lx, %d) called\n", (long) sema, waitflag));
|
||||
dprintf(("PyThread_down_sema(%lx) return\n", (long) sema));
|
||||
dprintf(("PyThread_down_sema(%p, %d) called\n", sema, waitflag));
|
||||
dprintf(("PyThread_down_sema(%p) return\n", sema));
|
||||
return -1;
|
||||
}
|
||||
|
||||
void PyThread_up_sema _P1(sema, PyThread_type_sema sema)
|
||||
{
|
||||
dprintf(("PyThread_up_sema(%lx)\n", (long) sema));
|
||||
dprintf(("PyThread_up_sema(%p)\n", sema));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -137,13 +137,13 @@ PyThread_type_lock PyThread_allocate_lock _P0()
|
|||
lock->lock_locked = 0;
|
||||
(void) mon_create(&lock->lock_monitor);
|
||||
(void) cv_create(&lock->lock_condvar, lock->lock_monitor);
|
||||
dprintf(("PyThread_allocate_lock() -> %lx\n", (long)lock));
|
||||
dprintf(("PyThread_allocate_lock() -> %p\n", lock));
|
||||
return (PyThread_type_lock) lock;
|
||||
}
|
||||
|
||||
void PyThread_free_lock _P1(lock, PyThread_type_lock lock)
|
||||
{
|
||||
dprintf(("PyThread_free_lock(%lx) called\n", (long)lock));
|
||||
dprintf(("PyThread_free_lock(%p) called\n", lock));
|
||||
mon_destroy(((struct lock *) lock)->lock_monitor);
|
||||
free((char *) lock);
|
||||
}
|
||||
|
|
@ -152,7 +152,7 @@ int PyThread_acquire_lock _P2(lock, PyThread_type_lock lock, waitflag, int waitf
|
|||
{
|
||||
int success;
|
||||
|
||||
dprintf(("PyThread_acquire_lock(%lx, %d) called\n", (long)lock, waitflag));
|
||||
dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
|
||||
success = 0;
|
||||
|
||||
(void) mon_enter(((struct lock *) lock)->lock_monitor);
|
||||
|
|
@ -165,13 +165,13 @@ int PyThread_acquire_lock _P2(lock, PyThread_type_lock lock, waitflag, int waitf
|
|||
}
|
||||
cv_broadcast(((struct lock *) lock)->lock_condvar);
|
||||
mon_exit(((struct lock *) lock)->lock_monitor);
|
||||
dprintf(("PyThread_acquire_lock(%lx, %d) -> %d\n", (long)lock, waitflag, success));
|
||||
dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
|
||||
return success;
|
||||
}
|
||||
|
||||
void PyThread_release_lock _P1(lock, PyThread_type_lock lock)
|
||||
{
|
||||
dprintf(("PyThread_release_lock(%lx) called\n", (long)lock));
|
||||
dprintf(("PyThread_release_lock(%p) called\n", lock));
|
||||
(void) mon_enter(((struct lock *) lock)->lock_monitor);
|
||||
((struct lock *) lock)->lock_locked = 0;
|
||||
cv_broadcast(((struct lock *) lock)->lock_condvar);
|
||||
|
|
@ -188,23 +188,23 @@ PyThread_type_sema PyThread_allocate_sema _P1(value, int value)
|
|||
if (!initialized)
|
||||
PyThread_init_thread();
|
||||
|
||||
dprintf(("PyThread_allocate_sema() -> %lx\n", (long) sema));
|
||||
dprintf(("PyThread_allocate_sema() -> %p\n", sema));
|
||||
return (PyThread_type_sema) sema;
|
||||
}
|
||||
|
||||
void PyThread_free_sema _P1(sema, PyThread_type_sema sema)
|
||||
{
|
||||
dprintf(("PyThread_free_sema(%lx) called\n", (long) sema));
|
||||
dprintf(("PyThread_free_sema(%p) called\n", sema));
|
||||
}
|
||||
|
||||
int PyThread_down_sema _P2(sema, PyThread_type_sema sema, waitflag, int waitflag)
|
||||
{
|
||||
dprintf(("PyThread_down_sema(%lx, %d) called\n", (long) sema, waitflag));
|
||||
dprintf(("PyThread_down_sema(%lx) return\n", (long) sema));
|
||||
dprintf(("PyThread_down_sema(%p, %d) called\n", sema, waitflag));
|
||||
dprintf(("PyThread_down_sema(%p) return\n", sema));
|
||||
return -1;
|
||||
}
|
||||
|
||||
void PyThread_up_sema _P1(sema, PyThread_type_sema sema)
|
||||
{
|
||||
dprintf(("PyThread_up_sema(%lx)\n", (long) sema));
|
||||
dprintf(("PyThread_up_sema(%p)\n", sema));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -273,14 +273,14 @@ PyThread_type_lock PyThread_allocate_lock(void)
|
|||
|
||||
aLock = AllocNonRecursiveMutex() ;
|
||||
|
||||
dprintf(("%ld: PyThread_allocate_lock() -> %lx\n", PyThread_get_thread_ident(), (long)aLock));
|
||||
dprintf(("%ld: PyThread_allocate_lock() -> %p\n", PyThread_get_thread_ident(), aLock));
|
||||
|
||||
return (PyThread_type_lock) aLock;
|
||||
}
|
||||
|
||||
void PyThread_free_lock(PyThread_type_lock aLock)
|
||||
{
|
||||
dprintf(("%ld: PyThread_free_lock(%lx) called\n", PyThread_get_thread_ident(),(long)aLock));
|
||||
dprintf(("%ld: PyThread_free_lock(%p) called\n", PyThread_get_thread_ident(),aLock));
|
||||
|
||||
FreeNonRecursiveMutex(aLock) ;
|
||||
}
|
||||
|
|
@ -295,21 +295,21 @@ int PyThread_acquire_lock(PyThread_type_lock aLock, int waitflag)
|
|||
{
|
||||
int success ;
|
||||
|
||||
dprintf(("%ld: PyThread_acquire_lock(%lx, %d) called\n", PyThread_get_thread_ident(),(long)aLock, waitflag));
|
||||
dprintf(("%ld: PyThread_acquire_lock(%p, %d) called\n", PyThread_get_thread_ident(),aLock, waitflag));
|
||||
|
||||
success = aLock && EnterNonRecursiveMutex((PNRMUTEX) aLock, (waitflag == 1 ? INFINITE : 0)) == WAIT_OBJECT_0 ;
|
||||
|
||||
dprintf(("%ld: PyThread_acquire_lock(%lx, %d) -> %d\n", PyThread_get_thread_ident(),(long)aLock, waitflag, success));
|
||||
dprintf(("%ld: PyThread_acquire_lock(%p, %d) -> %d\n", PyThread_get_thread_ident(),aLock, waitflag, success));
|
||||
|
||||
return success;
|
||||
}
|
||||
|
||||
void PyThread_release_lock(PyThread_type_lock aLock)
|
||||
{
|
||||
dprintf(("%ld: PyThread_release_lock(%lx) called\n", PyThread_get_thread_ident(),(long)aLock));
|
||||
dprintf(("%ld: PyThread_release_lock(%p) called\n", PyThread_get_thread_ident(),aLock));
|
||||
|
||||
if (!(aLock && LeaveNonRecursiveMutex((PNRMUTEX) aLock)))
|
||||
dprintf(("%ld: Could not PyThread_release_lock(%lx) error: %l\n", PyThread_get_thread_ident(), (long)aLock, GetLastError()));
|
||||
dprintf(("%ld: Could not PyThread_release_lock(%p) error: %l\n", PyThread_get_thread_ident(), aLock, GetLastError()));
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -328,14 +328,14 @@ PyThread_type_sema PyThread_allocate_sema(int value)
|
|||
INT_MAX, /* Maximum value */
|
||||
NULL); /* Name of semaphore */
|
||||
|
||||
dprintf(("%ld: PyThread_allocate_sema() -> %lx\n", PyThread_get_thread_ident(), (long)aSemaphore));
|
||||
dprintf(("%ld: PyThread_allocate_sema() -> %p\n", PyThread_get_thread_ident(), aSemaphore));
|
||||
|
||||
return (PyThread_type_sema) aSemaphore;
|
||||
}
|
||||
|
||||
void PyThread_free_sema(PyThread_type_sema aSemaphore)
|
||||
{
|
||||
dprintf(("%ld: PyThread_free_sema(%lx) called\n", PyThread_get_thread_ident(), (long)aSemaphore));
|
||||
dprintf(("%ld: PyThread_free_sema(%p) called\n", PyThread_get_thread_ident(), aSemaphore));
|
||||
|
||||
CloseHandle((HANDLE) aSemaphore);
|
||||
}
|
||||
|
|
@ -347,11 +347,11 @@ int PyThread_down_sema(PyThread_type_sema aSemaphore, int waitflag)
|
|||
{
|
||||
DWORD waitResult;
|
||||
|
||||
dprintf(("%ld: PyThread_down_sema(%lx) called\n", PyThread_get_thread_ident(), (long)aSemaphore));
|
||||
dprintf(("%ld: PyThread_down_sema(%p) called\n", PyThread_get_thread_ident(), aSemaphore));
|
||||
|
||||
waitResult = WaitForSingleObject( (HANDLE) aSemaphore, INFINITE);
|
||||
|
||||
dprintf(("%ld: PyThread_down_sema(%lx) return: %l\n", PyThread_get_thread_ident(),(long) aSemaphore, waitResult));
|
||||
dprintf(("%ld: PyThread_down_sema(%p) return: %l\n", PyThread_get_thread_ident(), aSemaphore, waitResult));
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -362,5 +362,5 @@ void PyThread_up_sema(PyThread_type_sema aSemaphore)
|
|||
1, /* increment count by one */
|
||||
NULL); /* not interested in previous count */
|
||||
|
||||
dprintf(("%ld: PyThread_up_sema(%lx)\n", PyThread_get_thread_ident(), (long)aSemaphore));
|
||||
dprintf(("%ld: PyThread_up_sema(%p)\n", PyThread_get_thread_ident(), aSemaphore));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -141,14 +141,14 @@ PyThread_type_lock PyThread_allocate_lock(void)
|
|||
0, /* shared ? */
|
||||
0); /* initial state */
|
||||
|
||||
dprintf(("%ld: PyThread_allocate_lock() -> %lx\n", PyThread_get_thread_ident(), (long)aLock));
|
||||
dprintf(("%ld: PyThread_allocate_lock() -> %p\n", PyThread_get_thread_ident(), aLock));
|
||||
|
||||
return (PyThread_type_lock) aLock;
|
||||
}
|
||||
|
||||
void PyThread_free_lock(PyThread_type_lock aLock)
|
||||
{
|
||||
dprintf(("%ld: PyThread_free_lock(%lx) called\n", PyThread_get_thread_ident(),(long)aLock));
|
||||
dprintf(("%ld: PyThread_free_lock(%p) called\n", PyThread_get_thread_ident(),aLock));
|
||||
|
||||
DosCloseMutexSem((HMTX)aLock);
|
||||
}
|
||||
|
|
@ -166,8 +166,8 @@ int PyThread_acquire_lock(PyThread_type_lock aLock, int waitflag)
|
|||
PID pid = 0;
|
||||
TID tid = 0;
|
||||
|
||||
dprintf(("%ld: PyThread_acquire_lock(%lx, %d) called\n", PyThread_get_thread_ident(),
|
||||
(long)aLock, waitflag));
|
||||
dprintf(("%ld: PyThread_acquire_lock(%p, %d) called\n", PyThread_get_thread_ident(),
|
||||
aLock, waitflag));
|
||||
|
||||
DosQueryMutexSem((HMTX)aLock,&pid,&tid,&count);
|
||||
if( tid == PyThread_get_thread_ident() ) { /* if we own this lock */
|
||||
|
|
@ -181,19 +181,19 @@ int PyThread_acquire_lock(PyThread_type_lock aLock, int waitflag)
|
|||
}
|
||||
}
|
||||
|
||||
dprintf(("%ld: PyThread_acquire_lock(%lx, %d) -> %d\n",
|
||||
PyThread_get_thread_ident(),(long)aLock, waitflag, success));
|
||||
dprintf(("%ld: PyThread_acquire_lock(%p, %d) -> %d\n",
|
||||
PyThread_get_thread_ident(),aLock, waitflag, success));
|
||||
|
||||
return success;
|
||||
}
|
||||
|
||||
void PyThread_release_lock(PyThread_type_lock aLock)
|
||||
{
|
||||
dprintf(("%ld: PyThread_release_lock(%lx) called\n", PyThread_get_thread_ident(),(long)aLock));
|
||||
dprintf(("%ld: PyThread_release_lock(%p) called\n", PyThread_get_thread_ident(),aLock));
|
||||
|
||||
if ( DosReleaseMutexSem( (HMTX) aLock ) != 0 ) {
|
||||
dprintf(("%ld: Could not PyThread_release_lock(%lx) error: %l\n",
|
||||
PyThread_get_thread_ident(), (long)aLock, GetLastError()));
|
||||
dprintf(("%ld: Could not PyThread_release_lock(%p) error: %l\n",
|
||||
PyThread_get_thread_ident(), aLock, GetLastError()));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -217,5 +217,5 @@ int PyThread_down_sema(PyThread_type_sema aSemaphore, int waitflag)
|
|||
|
||||
void PyThread_up_sema(PyThread_type_sema aSemaphore)
|
||||
{
|
||||
dprintf(("%ld: PyThread_up_sema(%lx)\n", PyThread_get_thread_ident(), (long)aSemaphore));
|
||||
dprintf(("%ld: PyThread_up_sema(%p)\n", PyThread_get_thread_ident(), aSemaphore));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -168,7 +168,7 @@ PyThread_type_lock PyThread_allocate_lock _P0()
|
|||
lock = NULL;
|
||||
}
|
||||
}
|
||||
dprintf(("PyThread_allocate_lock() -> %lx\n", (long)lock));
|
||||
dprintf(("PyThread_allocate_lock() -> %p\n", lock));
|
||||
return (PyThread_type_lock) lock;
|
||||
}
|
||||
|
||||
|
|
@ -177,7 +177,7 @@ void PyThread_free_lock _P1(lock, PyThread_type_lock lock)
|
|||
pth_lock *thelock = (pth_lock *)lock;
|
||||
int status, error = 0;
|
||||
|
||||
dprintf(("PyThread_free_lock(%lx) called\n", (long)lock));
|
||||
dprintf(("PyThread_free_lock(%p) called\n", lock));
|
||||
|
||||
free((void *)thelock);
|
||||
}
|
||||
|
|
@ -188,7 +188,7 @@ int PyThread_acquire_lock _P2(lock, PyThread_type_lock lock, waitflag, int waitf
|
|||
pth_lock *thelock = (pth_lock *)lock;
|
||||
int status, error = 0;
|
||||
|
||||
dprintf(("PyThread_acquire_lock(%lx, %d) called\n", (long)lock, waitflag));
|
||||
dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
|
||||
|
||||
status = pth_mutex_acquire(&thelock->mut, !waitflag, NULL);
|
||||
CHECK_STATUS("pth_mutex_acquire[1]");
|
||||
|
|
@ -215,7 +215,7 @@ int PyThread_acquire_lock _P2(lock, PyThread_type_lock lock, waitflag, int waitf
|
|||
success = 1;
|
||||
}
|
||||
if (error) success = 0;
|
||||
dprintf(("PyThread_acquire_lock(%lx, %d) -> %d\n", (long)lock, waitflag, success));
|
||||
dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
|
||||
return success;
|
||||
}
|
||||
|
||||
|
|
@ -224,7 +224,7 @@ void PyThread_release_lock _P1(lock, PyThread_type_lock lock)
|
|||
pth_lock *thelock = (pth_lock *)lock;
|
||||
int status, error = 0;
|
||||
|
||||
dprintf(("PyThread_release_lock(%lx) called\n", (long)lock));
|
||||
dprintf(("PyThread_release_lock(%p) called\n", lock));
|
||||
|
||||
status = pth_mutex_acquire( &thelock->mut, 0, NULL );
|
||||
CHECK_STATUS("pth_mutex_acquire[3]");
|
||||
|
|
@ -270,7 +270,7 @@ PyThread_type_sema PyThread_allocate_sema _P1(value, int value)
|
|||
sema = NULL;
|
||||
}
|
||||
}
|
||||
dprintf(("PyThread_allocate_sema() -> %lx\n", (long) sema));
|
||||
dprintf(("PyThread_allocate_sema() -> %p\n", sema));
|
||||
return (PyThread_type_sema) sema;
|
||||
}
|
||||
|
||||
|
|
@ -279,7 +279,7 @@ void PyThread_free_sema _P1(sema, PyThread_type_sema sema)
|
|||
int status, error = 0;
|
||||
struct semaphore *thesema = (struct semaphore *) sema;
|
||||
|
||||
dprintf(("PyThread_free_sema(%lx) called\n", (long) sema));
|
||||
dprintf(("PyThread_free_sema(%p) called\n", sema));
|
||||
free((void *) thesema);
|
||||
}
|
||||
|
||||
|
|
@ -288,7 +288,7 @@ int PyThread_down_sema _P2(sema, PyThread_type_sema sema, waitflag, int waitflag
|
|||
int status, error = 0, success;
|
||||
struct semaphore *thesema = (struct semaphore *) sema;
|
||||
|
||||
dprintf(("PyThread_down_sema(%lx, %d) called\n", (long) sema, waitflag));
|
||||
dprintf(("PyThread_down_sema(%p, %d) called\n", sema, waitflag));
|
||||
status = pth_mutex_acquire(&thesema->mutex, !waitflag, NULL);
|
||||
CHECK_STATUS("pth_mutex_acquire");
|
||||
if (waitflag) {
|
||||
|
|
@ -308,7 +308,7 @@ int PyThread_down_sema _P2(sema, PyThread_type_sema sema, waitflag, int waitflag
|
|||
success = 0;
|
||||
status = pth_mutex_release(&thesema->mutex);
|
||||
CHECK_STATUS("pth_mutex_release");
|
||||
dprintf(("PyThread_down_sema(%lx) return\n", (long) sema));
|
||||
dprintf(("PyThread_down_sema(%p) return\n", sema));
|
||||
return success;
|
||||
}
|
||||
|
||||
|
|
@ -317,7 +317,7 @@ void PyThread_up_sema _P1(sema, PyThread_type_sema sema)
|
|||
int status, error = 0;
|
||||
struct semaphore *thesema = (struct semaphore *) sema;
|
||||
|
||||
dprintf(("PyThread_up_sema(%lx)\n", (long) sema));
|
||||
dprintf(("PyThread_up_sema(%p)\n", sema));
|
||||
status = pth_mutex_acquire(&thesema->mutex, 0, NULL);
|
||||
CHECK_STATUS("pth_mutex_acquire");
|
||||
thesema->value++;
|
||||
|
|
|
|||
|
|
@ -272,7 +272,7 @@ PyThread_type_lock PyThread_allocate_lock _P0()
|
|||
}
|
||||
}
|
||||
|
||||
dprintf(("PyThread_allocate_lock() -> %lx\n", (long)lock));
|
||||
dprintf(("PyThread_allocate_lock() -> %p\n", lock));
|
||||
return (PyThread_type_lock) lock;
|
||||
}
|
||||
|
||||
|
|
@ -281,7 +281,7 @@ void PyThread_free_lock _P1(lock, PyThread_type_lock lock)
|
|||
pthread_lock *thelock = (pthread_lock *)lock;
|
||||
int status, error = 0;
|
||||
|
||||
dprintf(("PyThread_free_lock(%lx) called\n", (long)lock));
|
||||
dprintf(("PyThread_free_lock(%p) called\n", lock));
|
||||
|
||||
status = pthread_mutex_destroy( &thelock->mut );
|
||||
CHECK_STATUS("pthread_mutex_destroy");
|
||||
|
|
@ -298,7 +298,7 @@ int PyThread_acquire_lock _P2(lock, PyThread_type_lock lock, waitflag, int waitf
|
|||
pthread_lock *thelock = (pthread_lock *)lock;
|
||||
int status, error = 0;
|
||||
|
||||
dprintf(("PyThread_acquire_lock(%lx, %d) called\n", (long)lock, waitflag));
|
||||
dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
|
||||
|
||||
status = pthread_mutex_lock( &thelock->mut );
|
||||
CHECK_STATUS("pthread_mutex_lock[1]");
|
||||
|
|
@ -325,7 +325,7 @@ int PyThread_acquire_lock _P2(lock, PyThread_type_lock lock, waitflag, int waitf
|
|||
success = 1;
|
||||
}
|
||||
if (error) success = 0;
|
||||
dprintf(("PyThread_acquire_lock(%lx, %d) -> %d\n", (long)lock, waitflag, success));
|
||||
dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
|
||||
return success;
|
||||
}
|
||||
|
||||
|
|
@ -334,7 +334,7 @@ void PyThread_release_lock _P1(lock, PyThread_type_lock lock)
|
|||
pthread_lock *thelock = (pthread_lock *)lock;
|
||||
int status, error = 0;
|
||||
|
||||
dprintf(("PyThread_release_lock(%lx) called\n", (long)lock));
|
||||
dprintf(("PyThread_release_lock(%p) called\n", lock));
|
||||
|
||||
status = pthread_mutex_lock( &thelock->mut );
|
||||
CHECK_STATUS("pthread_mutex_lock[3]");
|
||||
|
|
@ -382,7 +382,7 @@ PyThread_type_sema PyThread_allocate_sema _P1(value, int value)
|
|||
sema = NULL;
|
||||
}
|
||||
}
|
||||
dprintf(("PyThread_allocate_sema() -> %lx\n", (long) sema));
|
||||
dprintf(("PyThread_allocate_sema() -> %p\n", sema));
|
||||
return (PyThread_type_sema) sema;
|
||||
}
|
||||
|
||||
|
|
@ -391,7 +391,7 @@ void PyThread_free_sema _P1(sema, PyThread_type_sema sema)
|
|||
int status, error = 0;
|
||||
struct semaphore *thesema = (struct semaphore *) sema;
|
||||
|
||||
dprintf(("PyThread_free_sema(%lx) called\n", (long) sema));
|
||||
dprintf(("PyThread_free_sema(%p) called\n", sema));
|
||||
status = pthread_cond_destroy(&thesema->cond);
|
||||
CHECK_STATUS("pthread_cond_destroy");
|
||||
status = pthread_mutex_destroy(&thesema->mutex);
|
||||
|
|
@ -404,7 +404,7 @@ int PyThread_down_sema _P2(sema, PyThread_type_sema sema, waitflag, int waitflag
|
|||
int status, error = 0, success;
|
||||
struct semaphore *thesema = (struct semaphore *) sema;
|
||||
|
||||
dprintf(("PyThread_down_sema(%lx, %d) called\n", (long) sema, waitflag));
|
||||
dprintf(("PyThread_down_sema(%p, %d) called\n", sema, waitflag));
|
||||
status = pthread_mutex_lock(&thesema->mutex);
|
||||
CHECK_STATUS("pthread_mutex_lock");
|
||||
if (waitflag) {
|
||||
|
|
@ -424,7 +424,7 @@ int PyThread_down_sema _P2(sema, PyThread_type_sema sema, waitflag, int waitflag
|
|||
success = 0;
|
||||
status = pthread_mutex_unlock(&thesema->mutex);
|
||||
CHECK_STATUS("pthread_mutex_unlock");
|
||||
dprintf(("PyThread_down_sema(%lx) return\n", (long) sema));
|
||||
dprintf(("PyThread_down_sema(%p) return\n", sema));
|
||||
return success;
|
||||
}
|
||||
|
||||
|
|
@ -433,7 +433,7 @@ void PyThread_up_sema _P1(sema, PyThread_type_sema sema)
|
|||
int status, error = 0;
|
||||
struct semaphore *thesema = (struct semaphore *) sema;
|
||||
|
||||
dprintf(("PyThread_up_sema(%lx)\n", (long) sema));
|
||||
dprintf(("PyThread_up_sema(%p)\n", sema));
|
||||
status = pthread_mutex_lock(&thesema->mutex);
|
||||
CHECK_STATUS("pthread_mutex_lock");
|
||||
thesema->value++;
|
||||
|
|
|
|||
|
|
@ -119,7 +119,7 @@ static void PyThread__init_thread _P0()
|
|||
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));
|
||||
dprintf(("trying to use addr %p-%p for shared arena\n", addr, addr+size));
|
||||
errno = 0;
|
||||
if ((addr = usconfig(CONF_ATTACHADDR, addr)) < 0 && errno != 0)
|
||||
perror("usconfig - CONF_ATTACHADDR (set)");
|
||||
|
|
@ -157,7 +157,7 @@ static void PyThread__init_thread _P0()
|
|||
(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)));
|
||||
dprintf(("arena start: %p, arena size: %ld\n", shared_arena, (long) usconfig(CONF_GETSIZE, shared_arena)));
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -224,7 +224,7 @@ int PyThread_start_new_thread _P2(func, void (*func) _P((void *)), arg, void *ar
|
|||
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",
|
||||
dprintf(("trying to use addr %p-%p for sproc\n",
|
||||
addr, addr+size));
|
||||
errno = 0;
|
||||
if ((addr = usconfig(CONF_ATTACHADDR, addr)) < 0 &&
|
||||
|
|
@ -375,13 +375,13 @@ PyThread_type_lock PyThread_allocate_lock _P0()
|
|||
if ((lock = usnewlock(shared_arena)) == NULL)
|
||||
perror("usnewlock");
|
||||
(void) usinitlock(lock);
|
||||
dprintf(("PyThread_allocate_lock() -> %lx\n", (long)lock));
|
||||
dprintf(("PyThread_allocate_lock() -> %p\n", lock));
|
||||
return (PyThread_type_lock) lock;
|
||||
}
|
||||
|
||||
void PyThread_free_lock _P1(lock, PyThread_type_lock lock)
|
||||
{
|
||||
dprintf(("PyThread_free_lock(%lx) called\n", (long)lock));
|
||||
dprintf(("PyThread_free_lock(%p) called\n", lock));
|
||||
usfreelock((ulock_t) lock, shared_arena);
|
||||
}
|
||||
|
||||
|
|
@ -389,7 +389,7 @@ int PyThread_acquire_lock _P2(lock, PyThread_type_lock lock, waitflag, int waitf
|
|||
{
|
||||
int success;
|
||||
|
||||
dprintf(("PyThread_acquire_lock(%lx, %d) called\n", (long)lock, waitflag));
|
||||
dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
|
||||
errno = 0; /* clear it just in case */
|
||||
if (waitflag)
|
||||
success = ussetlock((ulock_t) lock);
|
||||
|
|
@ -397,13 +397,13 @@ int PyThread_acquire_lock _P2(lock, PyThread_type_lock lock, waitflag, int waitf
|
|||
success = uscsetlock((ulock_t) lock, 1); /* Try it once */
|
||||
if (success < 0)
|
||||
perror(waitflag ? "ussetlock" : "uscsetlock");
|
||||
dprintf(("PyThread_acquire_lock(%lx, %d) -> %d\n", (long)lock, waitflag, success));
|
||||
dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
|
||||
return success;
|
||||
}
|
||||
|
||||
void PyThread_release_lock _P1(lock, PyThread_type_lock lock)
|
||||
{
|
||||
dprintf(("PyThread_release_lock(%lx) called\n", (long)lock));
|
||||
dprintf(("PyThread_release_lock(%p) called\n", lock));
|
||||
if (usunsetlock((ulock_t) lock) < 0)
|
||||
perror("usunsetlock");
|
||||
}
|
||||
|
|
@ -420,13 +420,13 @@ PyThread_type_sema PyThread_allocate_sema _P1(value, int value)
|
|||
|
||||
if ((sema = usnewsema(shared_arena, value)) == NULL)
|
||||
perror("usnewsema");
|
||||
dprintf(("PyThread_allocate_sema() -> %lx\n", (long) sema));
|
||||
dprintf(("PyThread_allocate_sema() -> %p\n", sema));
|
||||
return (PyThread_type_sema) sema;
|
||||
}
|
||||
|
||||
void PyThread_free_sema _P1(sema, PyThread_type_sema sema)
|
||||
{
|
||||
dprintf(("PyThread_free_sema(%lx) called\n", (long) sema));
|
||||
dprintf(("PyThread_free_sema(%p) called\n", sema));
|
||||
usfreesema((usema_t *) sema, shared_arena);
|
||||
}
|
||||
|
||||
|
|
@ -434,20 +434,20 @@ int PyThread_down_sema _P2(sema, PyThread_type_sema sema, waitflag, int waitflag
|
|||
{
|
||||
int success;
|
||||
|
||||
dprintf(("PyThread_down_sema(%lx) called\n", (long) sema));
|
||||
dprintf(("PyThread_down_sema(%p) called\n", sema));
|
||||
if (waitflag)
|
||||
success = uspsema((usema_t *) sema);
|
||||
else
|
||||
success = uscpsema((usema_t *) sema);
|
||||
if (success < 0)
|
||||
perror(waitflag ? "uspsema" : "uscpsema");
|
||||
dprintf(("PyThread_down_sema(%lx) return\n", (long) sema));
|
||||
dprintf(("PyThread_down_sema(%p) return\n", sema));
|
||||
return success;
|
||||
}
|
||||
|
||||
void PyThread_up_sema _P1(sema, PyThread_type_sema sema)
|
||||
{
|
||||
dprintf(("PyThread_up_sema(%lx)\n", (long) sema));
|
||||
dprintf(("PyThread_up_sema(%p)\n", sema));
|
||||
if (usvsema((usema_t *) sema) < 0)
|
||||
perror("usvsema");
|
||||
}
|
||||
|
|
|
|||
|
|
@ -157,13 +157,13 @@ PyThread_type_lock PyThread_allocate_lock _P0()
|
|||
free((void *) lock);
|
||||
lock = 0;
|
||||
}
|
||||
dprintf(("PyThread_allocate_lock() -> %lx\n", (long)lock));
|
||||
dprintf(("PyThread_allocate_lock() -> %p\n", lock));
|
||||
return (PyThread_type_lock) lock;
|
||||
}
|
||||
|
||||
void PyThread_free_lock _P1(lock, PyThread_type_lock lock)
|
||||
{
|
||||
dprintf(("PyThread_free_lock(%lx) called\n", (long)lock));
|
||||
dprintf(("PyThread_free_lock(%p) called\n", lock));
|
||||
mutex_destroy((mutex_t *) lock);
|
||||
free((void *) lock);
|
||||
}
|
||||
|
|
@ -172,7 +172,7 @@ int PyThread_acquire_lock _P2(lock, PyThread_type_lock lock, waitflag, int waitf
|
|||
{
|
||||
int success;
|
||||
|
||||
dprintf(("PyThread_acquire_lock(%lx, %d) called\n", (long)lock, waitflag));
|
||||
dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
|
||||
if (waitflag)
|
||||
success = mutex_lock((mutex_t *) lock);
|
||||
else
|
||||
|
|
@ -181,13 +181,13 @@ int PyThread_acquire_lock _P2(lock, PyThread_type_lock lock, waitflag, int waitf
|
|||
perror(waitflag ? "mutex_lock" : "mutex_trylock");
|
||||
else
|
||||
success = !success; /* solaris does it the other way round */
|
||||
dprintf(("PyThread_acquire_lock(%lx, %d) -> %d\n", (long)lock, waitflag, success));
|
||||
dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
|
||||
return success;
|
||||
}
|
||||
|
||||
void PyThread_release_lock _P1(lock, PyThread_type_lock lock)
|
||||
{
|
||||
dprintf(("PyThread_release_lock(%lx) called\n", (long)lock));
|
||||
dprintf(("PyThread_release_lock(%p) called\n", lock));
|
||||
if (mutex_unlock((mutex_t *) lock))
|
||||
perror("mutex_unlock");
|
||||
}
|
||||
|
|
@ -208,13 +208,13 @@ PyThread_type_sema PyThread_allocate_sema _P1(value, int value)
|
|||
free((void *) sema);
|
||||
sema = 0;
|
||||
}
|
||||
dprintf(("PyThread_allocate_sema() -> %lx\n", (long) sema));
|
||||
dprintf(("PyThread_allocate_sema() -> %p\n", sema));
|
||||
return (PyThread_type_sema) sema;
|
||||
}
|
||||
|
||||
void PyThread_free_sema _P1(sema, PyThread_type_sema sema)
|
||||
{
|
||||
dprintf(("PyThread_free_sema(%lx) called\n", (long) sema));
|
||||
dprintf(("PyThread_free_sema(%p) called\n", sema));
|
||||
if (sema_destroy((sema_t *) sema))
|
||||
perror("sema_destroy");
|
||||
free((void *) sema);
|
||||
|
|
@ -224,7 +224,7 @@ int PyThread_down_sema _P2(sema, PyThread_type_sema sema, waitflag, int waitflag
|
|||
{
|
||||
int success;
|
||||
|
||||
dprintf(("PyThread_down_sema(%lx) called\n", (long) sema));
|
||||
dprintf(("PyThread_down_sema(%p) called\n", sema));
|
||||
if (waitflag)
|
||||
success = sema_wait((sema_t *) sema);
|
||||
else
|
||||
|
|
@ -237,13 +237,13 @@ int PyThread_down_sema _P2(sema, PyThread_type_sema sema, waitflag, int waitflag
|
|||
}
|
||||
else
|
||||
success = !success;
|
||||
dprintf(("PyThread_down_sema(%lx) return %d\n", (long) sema, success));
|
||||
dprintf(("PyThread_down_sema(%p) return %d\n", sema, success));
|
||||
return success;
|
||||
}
|
||||
|
||||
void PyThread_up_sema _P1(sema, PyThread_type_sema sema)
|
||||
{
|
||||
dprintf(("PyThread_up_sema(%lx)\n", (long) sema));
|
||||
dprintf(("PyThread_up_sema(%p)\n", sema));
|
||||
if (sema_post((sema_t *) sema))
|
||||
perror("sema_post");
|
||||
}
|
||||
|
|
|
|||
|
|
@ -144,14 +144,14 @@ PyThread_type_lock PyThread_allocate_lock(void)
|
|||
1, /* Is initially signalled */
|
||||
NULL); /* Name of event */
|
||||
|
||||
dprintf(("%ld: PyThread_allocate_lock() -> %lx\n", PyThread_get_thread_ident(), (long)aLock));
|
||||
dprintf(("%ld: PyThread_allocate_lock() -> %p\n", PyThread_get_thread_ident(), aLock));
|
||||
|
||||
return (PyThread_type_lock) aLock;
|
||||
}
|
||||
|
||||
void PyThread_free_lock(PyThread_type_lock aLock)
|
||||
{
|
||||
dprintf(("%ld: PyThread_free_lock(%lx) called\n", PyThread_get_thread_ident(),(long)aLock));
|
||||
dprintf(("%ld: PyThread_free_lock(%p) called\n", PyThread_get_thread_ident(),aLock));
|
||||
|
||||
CloseHandle(aLock);
|
||||
}
|
||||
|
|
@ -167,7 +167,7 @@ int PyThread_acquire_lock(PyThread_type_lock aLock, int waitflag)
|
|||
int success = 1;
|
||||
DWORD waitResult;
|
||||
|
||||
dprintf(("%ld: PyThread_acquire_lock(%lx, %d) called\n", PyThread_get_thread_ident(),(long)aLock, waitflag));
|
||||
dprintf(("%ld: PyThread_acquire_lock(%p, %d) called\n", PyThread_get_thread_ident(),aLock, waitflag));
|
||||
|
||||
#ifndef DEBUG
|
||||
waitResult = WaitForSingleObject(aLock, (waitflag == 1 ? INFINITE : 0));
|
||||
|
|
@ -185,17 +185,17 @@ int PyThread_acquire_lock(PyThread_type_lock aLock, int waitflag)
|
|||
success = 0; /* We failed */
|
||||
}
|
||||
|
||||
dprintf(("%ld: PyThread_acquire_lock(%lx, %d) -> %d\n", PyThread_get_thread_ident(),(long)aLock, waitflag, success));
|
||||
dprintf(("%ld: PyThread_acquire_lock(%p, %d) -> %d\n", PyThread_get_thread_ident(),aLock, waitflag, success));
|
||||
|
||||
return success;
|
||||
}
|
||||
|
||||
void PyThread_release_lock(PyThread_type_lock aLock)
|
||||
{
|
||||
dprintf(("%ld: PyThread_release_lock(%lx) called\n", PyThread_get_thread_ident(),(long)aLock));
|
||||
dprintf(("%ld: PyThread_release_lock(%p) called\n", PyThread_get_thread_ident(),aLock));
|
||||
|
||||
if (!SetEvent(aLock))
|
||||
dprintf(("%ld: Could not PyThread_release_lock(%lx) error: %l\n", PyThread_get_thread_ident(), (long)aLock, GetLastError()));
|
||||
dprintf(("%ld: Could not PyThread_release_lock(%p) error: %l\n", PyThread_get_thread_ident(), aLock, GetLastError()));
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue