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.

diff --git a/Modules/_tkinter.c b/Modules/_tkinter.c
index da905596d9ae0d044a120a8f5b416a21424bb3c5..d7a4fe113c72f3c4397719a05c003f5e0518059c 100644 (file)
--- a/Modules/_tkinter.c
+++ b/Modules/_tkinter.c
@@ -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);
 }

diff --git a/Modules/flmodule.c b/Modules/flmodule.c
index c6ce439347be2b7584341675ccf14628b116bdfb..900f3812d1894dbc1d63257bc835ff82c06bc789 100644 (file)
--- a/Modules/flmodule.c
+++ b/Modules/flmodule.c
@@ -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);
 }
 

diff --git a/Modules/mpzmodule.c b/Modules/mpzmodule.c
index af44abf3c696698afb2fa6d1800c6f2b137e577b..09d46b9e8fc5a6d186dc73e6dc878206adfb9cad 100644 (file)
--- a/Modules/mpzmodule.c
+++ b/Modules/mpzmodule.c
@@ -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 */     
 

diff --git a/Objects/bufferobject.c b/Objects/bufferobject.c
index 72d424253ccc3794e8d2e3f59e218be20068b08c..c8ebd24911f6362dd8c7cf6dc5afd74f2bc4908c 100644 (file)
--- a/Objects/bufferobject.c
+++ b/Objects/bufferobject.c
@@ -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);

diff --git a/Objects/classobject.c b/Objects/classobject.c
index 4653d27b6049bcb5f182e809d6d44e228dddc866..17b7bf464ae6cf9f9920e47f43bd60b77ea9c336 100644 (file)
--- a/Objects/classobject.c
+++ b/Objects/classobject.c
@@ -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);

diff --git a/Objects/fileobject.c b/Objects/fileobject.c
index cbc1aff937f259a1495087ec5d5076f7b8e54ae3..99c0dd5e2bcd8146dd52a9913209dd383b29876a 100644 (file)
--- a/Objects/fileobject.c
+++ b/Objects/fileobject.c
@@ -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);
 }
 

diff --git a/Objects/floatobject.c b/Objects/floatobject.c
index 29ade282bd5a3a7dc581fcc109fac7c74353fb41..f455ef58912f1b18d3e767f12790ac6da20c0080 100644 (file)
--- a/Objects/floatobject.c
+++ b/Objects/floatobject.c
@@ -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;

diff --git a/Objects/funcobject.c b/Objects/funcobject.c
index 2736d6530e628ac18ebd5f310ade06e59931090f..f91cc6d903faf8cc80e64c3ef0f5bc5d87a518d4 100644 (file)
--- a/Objects/funcobject.c
+++ b/Objects/funcobject.c
@@ -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);
 }
 

diff --git a/Objects/intobject.c b/Objects/intobject.c
index 2e8939e65e308acd68471d34da48e0a1acce3b2d..d182b30e5bc4491e7fc001c2fd9c6ee60b1885d0 100644 (file)
--- a/Objects/intobject.c
+++ b/Objects/intobject.c
@@ -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;
                }

diff --git a/Objects/methodobject.c b/Objects/methodobject.c
index 580bb2f25ba789f0448ff45debc02f750c1dcd34..ec98de492a9af07dba95c8f633c2c2ec108fa035 100644 (file)
--- a/Objects/methodobject.c
+++ b/Objects/methodobject.c
@@ -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);
 }
 

diff --git a/Objects/object.c b/Objects/object.c
index 6eaff67dacdce14c39f1490b82832a169a3a6d1e..694aade004f0d2e870b9e432e25467663875464f 100644 (file)
--- a/Objects/object.c
+++ b/Objects/object.c
@@ -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 {

diff --git a/Python/thread_beos.h b/Python/thread_beos.h
index 0dff786436cb160cb29575343c916473b36b2395..5eab31a9039bd82fb1bd1ea72e01a000fa7e2dbc 100644 (file)
--- a/Python/thread_beos.h
+++ b/Python/thread_beos.h
@@ -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 ) {

diff --git a/Python/thread_cthread.h b/Python/thread_cthread.h
index 11370c56edaa1a8cf7867f0fe55b3a699b88b55d..1e6074334a1e61ef1fabcd659d1ffe98e1f6b446 100644 (file)
--- a/Python/thread_cthread.h
+++ b/Python/thread_cthread.h
@@ -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));
 }

diff --git a/Python/thread_foobar.h b/Python/thread_foobar.h
index e2c75e3b07bccc4c9865b1d127f7ad67af48d687..3be13b99ef49d65528f3d3875ce30b51d27ee67f 100644 (file)
--- a/Python/thread_foobar.h
+++ b/Python/thread_foobar.h
@@ -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));
 }

diff --git a/Python/thread_lwp.h b/Python/thread_lwp.h
index 5ad4df48568ae1e7f1d1ca7610062abd09fa4749..1588c6a08a6e7f9698b9b3227e76fd0fd595a47a 100644 (file)
--- a/Python/thread_lwp.h
+++ b/Python/thread_lwp.h
@@ -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));
 }

diff --git a/Python/thread_nt.h b/Python/thread_nt.h
index fb04f830ee845652fe6b032c2c323858f9287879..3de1c6622a5c7a0647b3f325ad20bac4b510e98e 100644 (file)
--- a/Python/thread_nt.h
+++ b/Python/thread_nt.h
@@ -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));
 }

diff --git a/Python/thread_os2.h b/Python/thread_os2.h
index 982fb6f5bf3cc429c1fe372bd1edf15729775bb3..aa972ce53993f4acdf65e9fc1a24d59f94f17662 100644 (file)
--- a/Python/thread_os2.h
+++ b/Python/thread_os2.h
@@ -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));
 }

diff --git a/Python/thread_pth.h b/Python/thread_pth.h
index 305121e7e1ac1ea7a7eb4a8f9c5f6d9a3db07514..3004650e16bc45a7dcf7a0b01f5af3959733703d 100644 (file)
--- a/Python/thread_pth.h
+++ b/Python/thread_pth.h
@@ -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++;

diff --git a/Python/thread_pthread.h b/Python/thread_pthread.h
index fd03e91611d3a61af382496c7711442a7c1f5b9c..d71811387601b9c2daedc95bb54ecf066f52d5f8 100644 (file)
--- a/Python/thread_pthread.h
+++ b/Python/thread_pthread.h
@@ -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++;

diff --git a/Python/thread_sgi.h b/Python/thread_sgi.h
index a7b3114b36be29ef6b82e2485c934812cb14f277..a699236559b3bdbc3ec59a0c1306349236928757 100644 (file)
--- a/Python/thread_sgi.h
+++ b/Python/thread_sgi.h
@@ -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");
 }

diff --git a/Python/thread_solaris.h b/Python/thread_solaris.h
index 5fc7850bcbd71d63a45ba74042b3af3426d31880..978d07d0bdf19e32930302e0ac98acb7e99e37e2 100644 (file)
--- a/Python/thread_solaris.h
+++ b/Python/thread_solaris.h
@@ -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");
 }

diff --git a/Python/thread_wince.h b/Python/thread_wince.h
index 38ead1291283e7ef8255c18d502333ea760a6914..3e2cdb9dfb04117aaf48a5e1cb06a288cca0af0f 100644 (file)
--- a/Python/thread_wince.h
+++ b/Python/thread_wince.h
@@ -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()));
 }