diff --git a/Misc/NEWS b/Misc/NEWS
index 424820d..61ccad6 100644
--- a/Misc/NEWS
+++ b/Misc/NEWS
@@ -183,6 +183,8 @@
 Build
 -----
 
+- Bug #1568842: Fix test for uintptr_t.
+
 - Patch #1540470, for OpenBSD 4.0.
 
 - Patch #1545507: Exclude ctypes package in Win64 MSI file.
diff --git a/configure b/configure
index 6b96c77..cc3fd3f 100755
--- a/configure
+++ b/configure
@@ -1,5 +1,5 @@
 #! /bin/sh
-# From configure.in Revision: 51727 .
+# From configure.in Revision: 51998 .
 # Guess values for system-dependent variables and create Makefiles.
 # Generated by GNU Autoconf 2.59 for python 2.5.
 #
@@ -10073,20 +10073,26 @@
 
 fi
 
-echo "$as_me:$LINENO: checking for uintptr_t support" >&5
-echo $ECHO_N "checking for uintptr_t support... $ECHO_C" >&6
-have_uintptr_t=no
-cat >conftest.$ac_ext <<_ACEOF
+echo "$as_me:$LINENO: checking for uintptr_t" >&5
+echo $ECHO_N "checking for uintptr_t... $ECHO_C" >&6
+if test "${ac_cv_type_uintptr_t+set}" = set; then
+  echo $ECHO_N "(cached) $ECHO_C" >&6
+else
+  cat >conftest.$ac_ext <<_ACEOF
 /* confdefs.h.  */
 _ACEOF
 cat confdefs.h >>conftest.$ac_ext
 cat >>conftest.$ac_ext <<_ACEOF
 /* end confdefs.h.  */
+#include <stdint.h>
 
 int
 main ()
 {
-uintptr_t x; x = (uintptr_t)0;
+if ((uintptr_t *) 0)
+  return 0;
+if (sizeof (uintptr_t))
+  return 0;
   ;
   return 0;
 }
@@ -10113,23 +10119,23 @@
   ac_status=$?
   echo "$as_me:$LINENO: \$? = $ac_status" >&5
   (exit $ac_status); }; }; then
-
-
-cat >>confdefs.h <<\_ACEOF
-#define HAVE_UINTPTR_T 1
-_ACEOF
-
-  have_uintptr_t=yes
-
+  ac_cv_type_uintptr_t=yes
 else
   echo "$as_me: failed program was:" >&5
 sed 's/^/| /' conftest.$ac_ext >&5
 
+ac_cv_type_uintptr_t=no
 fi
 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
-echo "$as_me:$LINENO: result: $have_uintptr_t" >&5
-echo "${ECHO_T}$have_uintptr_t" >&6
-if test "$have_uintptr_t" = yes ; then
+fi
+echo "$as_me:$LINENO: result: $ac_cv_type_uintptr_t" >&5
+echo "${ECHO_T}$ac_cv_type_uintptr_t" >&6
+if test $ac_cv_type_uintptr_t = yes; then
+
+cat >>confdefs.h <<_ACEOF
+#define HAVE_UINTPTR_T 1
+_ACEOF
+
 echo "$as_me:$LINENO: checking for uintptr_t" >&5
 echo $ECHO_N "checking for uintptr_t... $ECHO_C" >&6
 if test "${ac_cv_type_uintptr_t+set}" = set; then
@@ -10546,6 +10552,8 @@
 
 fi
 
+
+
 # Hmph. AC_CHECK_SIZEOF() doesn't include <sys/types.h>.
 echo "$as_me:$LINENO: checking size of off_t" >&5
 echo $ECHO_N "checking size of off_t... $ECHO_C" >&6
diff --git a/configure.in b/configure.in
index 711e19e..c5d69f9 100644
--- a/configure.in
+++ b/configure.in
@@ -1197,16 +1197,10 @@
 AC_CHECK_SIZEOF(long long, 8)
 fi
 
-AC_MSG_CHECKING(for uintptr_t support)
-have_uintptr_t=no
-AC_TRY_COMPILE([], [uintptr_t x; x = (uintptr_t)0;], [
-  AC_DEFINE(HAVE_UINTPTR_T, 1, [Define this if you have the type uintptr_t.]) 
-  have_uintptr_t=yes
-])
-AC_MSG_RESULT($have_uintptr_t)
-if test "$have_uintptr_t" = yes ; then
-AC_CHECK_SIZEOF(uintptr_t, 4)
-fi
+AC_CHECK_TYPES(uintptr_t, 
+   [AC_CHECK_SIZEOF(uintptr_t, 4)], 
+   [], [#include <stdint.h>])
+
 
 # Hmph. AC_CHECK_SIZEOF() doesn't include <sys/types.h>.
 AC_MSG_CHECKING(size of off_t)
diff --git a/pyconfig.h.in b/pyconfig.h.in
index a3d7f6e..8448439 100644
--- a/pyconfig.h.in
+++ b/pyconfig.h.in
@@ -677,7 +677,7 @@
 /* Define this if you have tcl and TCL_UTF_MAX==6 */
 #undef HAVE_UCS4_TCL
 
-/* Define this if you have the type uintptr_t. */
+/* Define to 1 if the system has the type `uintptr_t'. */
 #undef HAVE_UINTPTR_T
 
 /* Define to 1 if you have the `uname' function. */
