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.

11 files changed, 110 insertions, 110 deletions

diff --git a/Python/thread_beos.h b/Python/thread_beos.h
index 0dff786436..5eab31a903 100644
--- 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 11370c56ed..1e6074334a 100644
--- 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 e2c75e3b07..3be13b99ef 100644
--- 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 5ad4df4856..1588c6a08a 100644
--- 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 fb04f830ee..3de1c6622a 100644
--- 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 982fb6f5bf..aa972ce539 100644
--- 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 305121e7e1..3004650e16 100644
--- 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 fd03e91611..d718113876 100644
--- 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 a7b3114b36..a699236559 100644
--- 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 5fc7850bcb..978d07d0bd 100644
--- 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 38ead12912..3e2cdb9dfb 100644
--- 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()));
 }