Do not assume EMACS_INT is the same width as a pointer.

This prepares for a future patch that will prefer 64-bit EMACS_INT if
available.  That patch can be tried now, by compiling with -DWIDE_EMACS_INT,
but it is temporarily not the default so that it can be further tested.

Also, install some other fixes for problems discovered by the static
checking of GCC 4.6.0.

Fixes: debbugs:8545 debbugs:8601 debbugs:8600 debbugs:8602

22 files changed, 354 insertions, 222 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 0df53250d7e..8d4ce09e4f7 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,118 @@
+2011-05-06  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * image.c (Finit_image_library) [!HAVE_NTGUI]: Omit unused local.
+
+        * term.c (vfatal): Remove stray call to va_end.
+        It's not needed and the C Standard doesn't allow it here anyway.
+
+        Use C99's va_copy to avoid undefined behavior on x86-64 GNU/Linux.
+        * eval.c (verror): doprnt a copy of ap, not the original.  (Bug#8545)
+
+        * eval.c (verror): OK to create a string of up to MOST_POSITIVE_FIXNUM
+        bytes.
+
+        * term.c: Don't include <stdarg.h>, as <lisp.h> does that.
+
+        * callproc.c (Fcall_process): Use 'volatile' to avoid vfork clobbering.
+
+        * process.c (Fformat_network_address): Fix typo: args2 -> *args2.
+
+        * xmenu.c (set_frame_menubar): Fix typo: int * -> int (3 times).
+
+        * coding.c (detect_coding_charset): Fix typo: * 2 -> *4 (Bug#8601).
+
+        * charset.h (struct charset.code_space): Now has 15 elements, not 16.
+        * charset.c (Fdefine_charset_internal): Don't initialize
+        charset.code_space[15].  The value was garbage, on hosts with
+        32-bit int (Bug#8600).
+
+        * lread.c (read_integer): Be more consistent with string-to-number.
+        Use string_to_number to do the actual conversion; this avoids
+        rounding errors and fixes some other screwups.  Without this fix,
+        for example, #x1fffffffffffffff was misread as -2305843009213693952.
+        (digit_to_number): Move earlier, for benefit of read_integer.
+        Return -1 if the digit is out of range for the base, -2 if it is
+        not a digit in any supported base.  (Bug#8602)
+
+        * doprnt.c (doprnt): Support arbitrary pI values, such as "I64".
+
+        * dispnew.c (scrolling_window): Return 1 if we scrolled,
+        to match comment at start of function.  This also removes a
+        GCC warning about overflow in a 32+64-bit port.
+
+        * lisp.h (EMACS_INT, EMACS_UINT, BITS_PER_EMACS_INT, pI): Simplify.
+
+        * dbusbind.c: Do not use XPNTR on a value that may be an integer.
+        Reported by Stefan Monnier in
+        <http://lists.gnu.org/archive/html/emacs-devel/2011-04/msg00919.html>.
+        (xd_remove_watch, Fdbus_init_bus, xd_read_queued_messages): Use
+        SYMBOLP-guarded XSYMBOL, not XPNTR.
+
+        * lisp.h (EMACS_INTPTR): Remove.  All uses changed to intptr_t.
+        (EMACS_UINTPTR): Likewise, with uintptr_t.
+
+        * lisp.h: Prefer 64-bit EMACS_INT if available.
+        (EMACS_INT, EMACS_UINT, BITS_PER_EMACS_INT, pI): Define to 64-bit
+        on 32-bit hosts that have 64-bit int, so that they can access
+        large files.
+        However, temporarily disable this change unless the temporary
+        symbol WIDE_EMACS_INT is defined.
+
+        * lread.c, process.c: Do not include <inttypes.h>; lisp.h does it now.
+
+        Prefer intptr_t/uintptr_t for integers the same widths as pointers.
+        This removes an assumption that EMACS_INT and long are the same
+        width as pointers.  The assumption is true for Emacs porting targets
+        now, but we want to make other targets possible.
+        * lisp.h: Include <inttypes.h>, for INTPTR_MAX, UINTPTR_MAX.
+        (EMACS_INTPTR, EMACS_UINTPTR): New macros.
+        In the rest of the code, change types of integers that hold casted
+        pointers to EMACS_INTPTR and EMACS_UINTPTR, systematically
+        replacing EMACS_INT, long, EMACS_UINT, and unsigned long.
+        (XTYPE): Don't cast arg to EMACS_UINT; normally is not needed.
+        (XSET): Cast type of XTYPE arg to EMACS_INTPTR; it is needed here.
+        No need to cast type when ORing.
+        (XPNTR): Return a value of type EMACS_INTPTR or EMACS_UINTPTR.
+        * alloc.c (lisp_align_malloc): Remove a no-longer-needed cast.
+        * doc.c (store_function_docstring): Use EMACS_INTPTR, so as not to
+        assume EMACS_INT is the same width as char *.
+        * gtkutil.c (xg_gtk_scroll_destroy, xg_tool_bar_button_cb):
+        (xg_tool_bar_callback, xg_tool_bar_help_callback, xg_make_tool_item):
+        Remove no-longer-needed casts.
+        (xg_create_scroll_bar, xg_tool_bar_button_cb, xg_tool_bar_callback):
+        (xg_tool_bar_help_callback, xg_make_tool_item):
+        Use EMACS_INTPTR to hold an integer
+        that will be cast to void *; this can avoid a GCC warning
+        if EMACS_INT is not the same width as void *.
+        * menu.c (find_and_call_menu_selection): Remove no-longer-needed cast.
+        * xdisp.c (display_echo_area_1, resize_mini_window_1):
+        (current_message_1, set_message_1):
+        Use a local to convert to proper width without a cast.
+        * xmenu.c (dialog_selection_callback): Likewise.
+
+        * sysdep.c (get_random): Don't assume EMACS_INT is no wider than long.
+        Also, don't assume VALBITS / RAND_BITS is less than 5,
+        and don't rely on undefined behavior when shifting a 1 left into
+        the sign bit.
+        * lisp.h (get_random): Change signature to match.
+
+        * lread.c (hash_string): Use size_t, not int, for hash computation.
+        Normally we prefer signed values; but hashing is special, because
+        it's better to use unsigned division on hash table sizes so that
+        the remainder is nonnegative.  Also, size_t is the natural width
+        for hashing into memory.  The previous code used 'int', which doesn't
+        retain enough info to hash well into very large tables.
+        (oblookup, oblookup_last_bucket_number, Funintern): Likewise.
+
+        * dbusbind.c: Don't possibly lose pointer info when converting.
+        (xd_remove_watch, Fdbus_init_bus, xd_read_queued_messages):
+        Use XPNTR rather than XHASH, so that the high-order bits of
+        the pointer aren't lost when converting through void *.
+
+        * eval.c (Fautoload): Don't double-shift a pointer.
+
+        * fns.c (Frandom): Let EMACS_UINT be wider than unsigned long.
+
 2011-05-06  Juanma Barranquero  <lekktu@gmail.com>
 
         * gnutls.c (DEF_GNUTLS_FN):
diff --git a/src/alloc.c b/src/alloc.c
index 842088f4e92..0bce83bfae7 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -438,7 +438,7 @@ static POINTER_TYPE *pure_alloc (size_t, int);
    ALIGNMENT must be a power of 2.  */
 
 #define ALIGN(ptr, ALIGNMENT) \
-  ((POINTER_TYPE *) ((((EMACS_UINT)(ptr)) + (ALIGNMENT) - 1) \
+  ((POINTER_TYPE *) ((((uintptr_t) (ptr)) + (ALIGNMENT) - 1) \
                      & ~((ALIGNMENT) - 1)))
 
 
@@ -876,7 +876,7 @@ struct ablocks
 #define ABLOCKS_BYTES (sizeof (struct ablocks) - BLOCK_PADDING)
 
 #define ABLOCK_ABASE(block) \
-  (((unsigned long) (block)->abase) <= (1 + 2 * ABLOCKS_SIZE)   \
+  (((uintptr_t) (block)->abase) <= (1 + 2 * ABLOCKS_SIZE)       \
    ? (struct ablocks *)(block)                                  \
    : (block)->abase)
 
@@ -888,7 +888,7 @@ struct ablocks
 #define ABLOCKS_BASE(abase) (abase)
 #else
 #define ABLOCKS_BASE(abase) \
-  (1 & (long) ABLOCKS_BUSY (abase) ? abase : ((void**)abase)[-1])
+  (1 & (intptr_t) ABLOCKS_BUSY (abase) ? abase : ((void**)abase)[-1])
 #endif
 
 /* The list of free ablock.   */
@@ -914,7 +914,7 @@ lisp_align_malloc (size_t nbytes, enum mem_type type)
   if (!free_ablock)
     {
       int i;
-      EMACS_INT aligned; /* int gets warning casting to 64-bit pointer.  */
+      intptr_t aligned; /* int gets warning casting to 64-bit pointer.  */
 
 #ifdef DOUG_LEA_MALLOC
       /* Prevent mmap'ing the chunk.  Lisp data may not be mmap'ed
@@ -977,17 +977,18 @@ lisp_align_malloc (size_t nbytes, enum mem_type type)
           abase->blocks[i].x.next_free = free_ablock;
           free_ablock = &abase->blocks[i];
         }
-      ABLOCKS_BUSY (abase) = (struct ablocks *) (long) aligned;
+      ABLOCKS_BUSY (abase) = (struct ablocks *) aligned;
 
-      eassert (0 == ((EMACS_UINT)abase) % BLOCK_ALIGN);
+      eassert (0 == ((uintptr_t) abase) % BLOCK_ALIGN);
       eassert (ABLOCK_ABASE (&abase->blocks[3]) == abase); /* 3 is arbitrary */
       eassert (ABLOCK_ABASE (&abase->blocks[0]) == abase);
       eassert (ABLOCKS_BASE (abase) == base);
-      eassert (aligned == (long) ABLOCKS_BUSY (abase));
+      eassert (aligned == (intptr_t) ABLOCKS_BUSY (abase));
     }
 
   abase = ABLOCK_ABASE (free_ablock);
-  ABLOCKS_BUSY (abase) = (struct ablocks *) (2 + (long) ABLOCKS_BUSY (abase));
+  ABLOCKS_BUSY (abase) =
+    (struct ablocks *) (2 + (intptr_t) ABLOCKS_BUSY (abase));
   val = free_ablock;
   free_ablock = free_ablock->x.next_free;
 
@@ -1000,7 +1001,7 @@ lisp_align_malloc (size_t nbytes, enum mem_type type)
   if (!val && nbytes)
     memory_full ();
 
-  eassert (0 == ((EMACS_UINT)val) % BLOCK_ALIGN);
+  eassert (0 == ((uintptr_t) val) % BLOCK_ALIGN);
   return val;
 }
 
@@ -1018,11 +1019,12 @@ lisp_align_free (POINTER_TYPE *block)
   ablock->x.next_free = free_ablock;
   free_ablock = ablock;
   /* Update busy count.  */
-  ABLOCKS_BUSY (abase) = (struct ablocks *) (-2 + (long) ABLOCKS_BUSY (abase));
+  ABLOCKS_BUSY (abase) =
+    (struct ablocks *) (-2 + (intptr_t) ABLOCKS_BUSY (abase));
 
-  if (2 > (long) ABLOCKS_BUSY (abase))
+  if (2 > (intptr_t) ABLOCKS_BUSY (abase))
     { /* All the blocks are free.  */
-      int i = 0, aligned = (long) ABLOCKS_BUSY (abase);
+      int i = 0, aligned = (intptr_t) ABLOCKS_BUSY (abase);
       struct ablock **tem = &free_ablock;
       struct ablock *atop = &abase->blocks[aligned ? ABLOCKS_SIZE : ABLOCKS_SIZE - 1];
 
@@ -1039,7 +1041,7 @@ lisp_align_free (POINTER_TYPE *block)
       eassert ((aligned & 1) == aligned);
       eassert (i == (aligned ? ABLOCKS_SIZE : ABLOCKS_SIZE - 1));
 #ifdef USE_POSIX_MEMALIGN
-      eassert ((unsigned long)ABLOCKS_BASE (abase) % BLOCK_ALIGN == 0);
+      eassert ((uintptr_t) ABLOCKS_BASE (abase) % BLOCK_ALIGN == 0);
 #endif
       free (ABLOCKS_BASE (abase));
     }
@@ -1772,7 +1774,7 @@ check_string_free_list (void)
   s = string_free_list;
   while (s != NULL)
     {
-      if ((unsigned long)s < 1024)
+      if ((uintptr_t) s < 1024)
         abort();
       s = NEXT_FREE_LISP_STRING (s);
     }
@@ -2432,10 +2434,10 @@ make_uninit_multibyte_string (EMACS_INT nchars, EMACS_INT nbytes)
   &= ~(1 << ((n) % (sizeof(int) * CHAR_BIT)))
 
 #define FLOAT_BLOCK(fptr) \
-  ((struct float_block *)(((EMACS_UINT)(fptr)) & ~(BLOCK_ALIGN - 1)))
+  ((struct float_block *) (((uintptr_t) (fptr)) & ~(BLOCK_ALIGN - 1)))
 
 #define FLOAT_INDEX(fptr) \
-  ((((EMACS_UINT)(fptr)) & (BLOCK_ALIGN - 1)) / sizeof (struct Lisp_Float))
+  ((((uintptr_t) (fptr)) & (BLOCK_ALIGN - 1)) / sizeof (struct Lisp_Float))
 
 struct float_block
 {
@@ -2544,10 +2546,10 @@ make_float (double float_value)
    / (sizeof (struct Lisp_Cons) * CHAR_BIT + 1))
 
 #define CONS_BLOCK(fptr) \
-  ((struct cons_block *)(((EMACS_UINT)(fptr)) & ~(BLOCK_ALIGN - 1)))
+  ((struct cons_block *) ((uintptr_t) (fptr) & ~(BLOCK_ALIGN - 1)))
 
 #define CONS_INDEX(fptr) \
-  ((((EMACS_UINT)(fptr)) & (BLOCK_ALIGN - 1)) / sizeof (struct Lisp_Cons))
+  (((uintptr_t) (fptr) & (BLOCK_ALIGN - 1)) / sizeof (struct Lisp_Cons))
 
 struct cons_block
 {
@@ -4021,7 +4023,7 @@ mark_maybe_pointer (void *p)
   struct mem_node *m;
 
   /* Quickly rule out some values which can't point to Lisp data.  */
-  if ((EMACS_INT) p %
+  if ((intptr_t) p %
 #ifdef USE_LSB_TAG
       8 /* USE_LSB_TAG needs Lisp data to be aligned on multiples of 8.  */
 #else
@@ -6072,7 +6074,7 @@ We divide the value by 1024 to make sure it fits in a Lisp integer.  */)
 {
   Lisp_Object end;
 
-  XSETINT (end, (EMACS_INT) (char *) sbrk (0) / 1024);
+  XSETINT (end, (intptr_t) (char *) sbrk (0) / 1024);
 
   return end;
 }
diff --git a/src/callproc.c b/src/callproc.c
index 1d3d8764ff8..946670320ca 100644
--- a/src/callproc.c
+++ b/src/callproc.c
@@ -193,7 +193,6 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
   int count = SPECPDL_INDEX ();
   volatile USE_SAFE_ALLOCA;
 
-  const unsigned char **volatile new_argv_volatile;
   register const unsigned char **new_argv;
   /* File to use for stderr in the child.
      t means use same as standard output.  */
@@ -416,7 +415,6 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
 
   SAFE_ALLOCA (new_argv, const unsigned char **,
                (nargs > 4 ? nargs - 2 : 2) * sizeof *new_argv);
-  new_argv_volatile = new_argv;
   if (nargs > 4)
     {
       register size_t i;
@@ -591,9 +589,20 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
 
     BLOCK_INPUT;
 
-    pid = vfork ();
+    /* vfork, and prevent local vars from being clobbered by the vfork.  */
+    {
+      int volatile fd_error_volatile = fd_error;
+      int volatile fd_output_volatile = fd_output;
+      int volatile output_to_buffer_volatile = output_to_buffer;
+      unsigned char const **volatile new_argv_volatile = new_argv;
+
+      pid = vfork ();
 
-    new_argv = new_argv_volatile;
+      fd_error = fd_error_volatile;
+      fd_output = fd_output_volatile;
+      output_to_buffer = output_to_buffer_volatile;
+      new_argv = new_argv_volatile;
+    }
 
     if (pid == 0)
       {
diff --git a/src/charset.c b/src/charset.c
index 52c2ebdcc4e..55fd57031ac 100644
--- a/src/charset.c
+++ b/src/charset.c
@@ -869,7 +869,7 @@ usage: (define-charset-internal ...)  */)
   ASET (attrs, charset_name, args[charset_arg_name]);
 
   val = args[charset_arg_code_space];
-  for (i = 0, dimension = 0, nchars = 1; i < 4; i++)
+  for (i = 0, dimension = 0, nchars = 1; ; i++)
     {
       int min_byte, max_byte;
 
@@ -880,10 +880,12 @@ usage: (define-charset-internal ...)  */)
       charset.code_space[i * 4] = min_byte;
       charset.code_space[i * 4 + 1] = max_byte;
       charset.code_space[i * 4 + 2] = max_byte - min_byte + 1;
-      nchars *= charset.code_space[i * 4 + 2];
-      charset.code_space[i * 4 + 3] = nchars;
       if (max_byte > 0)
         dimension = i + 1;
+      if (i == 3)
+        break;
+      nchars *= charset.code_space[i * 4 + 2];
+      charset.code_space[i * 4 + 3] = nchars;
     }
 
   val = args[charset_arg_dimension];
diff --git a/src/charset.h b/src/charset.h
index 74d55a31b43..53784bf8455 100644
--- a/src/charset.h
+++ b/src/charset.h
@@ -155,10 +155,11 @@ struct charset
      byte code of the (N+1)th dimension, <code_space>[4N+1] is a
      maximum byte code of the (N+1)th dimension, <code_space>[4N+2] is
      (<code_space>[4N+1] - <code_space>[4N] + 1), <code_space>[4N+3]
-     is a number of characters containd in the first to (N+1)th
-     dismesions.  We get `char-index' of a `code-point' from this
+     is the number of characters contained in the first through (N+1)th
+     dimensions, except that there is no <code_space>[15].
+     We get `char-index' of a `code-point' from this
      information.  */
-  int code_space[16];
+  int code_space[15];
 
   /* If B is a byte of Nth dimension of a code-point, the (N-1)th bit
      of code_space_mask[B] is set.  This array is used to quickly
diff --git a/src/coding.c b/src/coding.c
index d17346efdcb..71253df6469 100644
--- a/src/coding.c
+++ b/src/coding.c
@@ -5368,8 +5368,8 @@ detect_coding_charset (struct coding_system *coding,
               if (src == src_end)
                 goto too_short;
               ONE_MORE_BYTE (c);
-              if (c < charset->code_space[(dim - 1 - idx) * 2]
-                  || c > charset->code_space[(dim - 1 - idx) * 2 + 1])
+              if (c < charset->code_space[(dim - 1 - idx) * 4]
+                  || c > charset->code_space[(dim - 1 - idx) * 4 + 1])
                 break;
             }
           if (idx < dim)
diff --git a/src/dbusbind.c b/src/dbusbind.c
index 4c0b9bd017a..76035341540 100644
--- a/src/dbusbind.c
+++ b/src/dbusbind.c
@@ -892,7 +892,7 @@ xd_remove_watch (DBusWatch *watch, void *data)
     return;
 
   /* Unset session environment.  */
-  if (data != NULL && data == (void*) XHASH (QCdbus_session_bus))
+  if (SYMBOLP (QCdbus_session_bus) && XSYMBOL (QCdbus_session_bus) == data)
     {
       XD_DEBUG_MESSAGE ("unsetenv DBUS_SESSION_BUS_ADDRESS");
       unsetenv ("DBUS_SESSION_BUS_ADDRESS");
@@ -920,6 +920,8 @@ DEFUN ("dbus-init-bus", Fdbus_init_bus, Sdbus_init_bus, 1, 1, 0,
 {
   DBusConnection *connection;
 
+  CHECK_SYMBOL (bus);
+
   /* Open a connection to the bus.  */
   connection = xd_initialize (bus, TRUE);
 
@@ -929,7 +931,7 @@ DEFUN ("dbus-init-bus", Fdbus_init_bus, Sdbus_init_bus, 1, 1, 0,
                                             xd_add_watch,
                                             xd_remove_watch,
                                             xd_toggle_watch,
-                                            (void*) XHASH (bus), NULL))
+                                            XSYMBOL (bus), NULL))
     XD_SIGNAL1 (build_string ("Cannot add watch functions"));
 
   /* Add bus to list of registered buses.  */
@@ -1824,7 +1826,7 @@ xd_read_queued_messages (int fd, void *data, int for_read)
   if (data != NULL)
     while (!NILP (busp))
       {
-        if (data == (void*) XHASH (CAR_SAFE (busp)))
+        if (SYMBOLP (CAR_SAFE (busp)) && XSYMBOL (CAR_SAFE (busp)) == data)
           bus = CAR_SAFE (busp);
         busp = CDR_SAFE (busp);
       }
diff --git a/src/dispnew.c b/src/dispnew.c
index 13e920166c5..0457d650b3a 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -4576,8 +4576,8 @@ scrolling_window (struct window *w, int header_line_p)
   for (i = 0; i < row_entry_idx; ++i)
     row_table[row_entry_pool[i].bucket] = NULL;
 
-  /* Value is > 0 to indicate that we scrolled the display.  */
-  return nruns;
+  /* Value is 1 to indicate that we scrolled the display.  */
+  return 0 < nruns;
 }
 
 
diff --git a/src/doc.c b/src/doc.c
index 3832eb3708d..89a7d322966 100644
--- a/src/doc.c
+++ b/src/doc.c
@@ -349,10 +349,10 @@ string is passed through `substitute-command-keys'.  */)
         return Qnil;
       /* FIXME: This is not portable, as it assumes that string
          pointers have the top bit clear.  */
-      else if ((EMACS_INT) XSUBR (fun)->doc >= 0)
+      else if ((intptr_t) XSUBR (fun)->doc >= 0)
         doc = build_string (XSUBR (fun)->doc);
       else
-        doc = make_number ((EMACS_INT) XSUBR (fun)->doc);
+        doc = make_number ((intptr_t) XSUBR (fun)->doc);
     }
   else if (COMPILEDP (fun))
     {
@@ -507,7 +507,10 @@ store_function_docstring (Lisp_Object fun, EMACS_INT offset)
 
   /* Lisp_Subrs have a slot for it.  */
   if (SUBRP (fun))
-    XSUBR (fun)->doc = (char *) - offset;
+    {
+      intptr_t negative_offset = - offset;
+      XSUBR (fun)->doc = (char *) negative_offset;
+    }
 
   /* If it's a lisp form, stick it in the form.  */
   else if (CONSP (fun))
diff --git a/src/doprnt.c b/src/doprnt.c
index 7b4bd35d5b1..d2abc119912 100644
--- a/src/doprnt.c
+++ b/src/doprnt.c
@@ -70,9 +70,9 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
      %<flags><width><precision><length>character
 
    where flags is [+ -0], width is [0-9]+, precision is .[0-9]+, and length
-   is empty or l or ll.  Also, %% in a format stands for a single % in the
-   output.  A % that does not introduce a valid %-sequence causes
-   undefined behavior.
+   is empty or l or the value of the pI macro.  Also, %% in a format
+   stands for a single % in the output.  A % that does not introduce a
+   valid %-sequence causes undefined behavior.
 
    The + flag character inserts a + before any positive number, while a space
    inserts a space before any positive number; these flags only affect %d, %o,
@@ -85,11 +85,8 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
    modifier: it is supported for %d, %o, and %x conversions of integral
    arguments, must immediately precede the conversion specifier, and means that
    the respective argument is to be treated as `long int' or `unsigned long
-   int'.  Similarly, ll (two letter ells) means to use `long long int' or
-   `unsigned long long int'; this can be used only on hosts that have
-   these two types.  The empty length modifier means to use `int' or
-   `unsigned int'.  EMACS_INT arguments should use the pI macro, which
-   expands to whatever length modifier is needed for the target host.
+   int'.  Similarly, the value of the pI macro means to use EMACS_INT or
+   EMACS_UINT and the empty length modifier means `int' or `unsigned int'.
 
    The width specifier supplies a lower limit for the length of the printed
    representation.  The padding, if any, normally goes on the left, but it goes
@@ -186,6 +183,7 @@ doprnt (char *buffer, register size_t bufsize, const char *format,
           size_t size_bound = 0;
           EMACS_INT width;  /* Columns occupied by STRING on display.  */
           int long_flag = 0;
+          int pIlen = sizeof pI - 1;
 
           fmt++;
           /* Copy this one %-spec into fmtcpy.  */
@@ -201,7 +199,7 @@ doprnt (char *buffer, register size_t bufsize, const char *format,
                      %1.1000f and %1000.1f both might need 1000+ bytes.
                      Parse the width or precision, checking for overflow.  */
                   size_t n = *fmt - '0';
-                  while (fmt < format_end
+                  while (fmt + 1 < format_end
                          && '0' <= fmt[1] && fmt[1] <= '9')
                     {
                       /* Avoid size_t overflow.  Avoid int overflow too, as
@@ -218,20 +216,25 @@ doprnt (char *buffer, register size_t bufsize, const char *format,
                   if (size_bound < n)
                     size_bound = n;
                 }
-              else if (*fmt == '-' || *fmt == ' ' || *fmt == '.' || *fmt == '+')
-                ;
-              else if (*fmt == 'l')
-                {
-                  long_flag = 1 + (fmt + 1 < format_end && fmt[1] == 'l');
-                  fmt += long_flag;
-                  break;
-                }
-              else
+              else if (! (*fmt == '-' || *fmt == ' ' || *fmt == '.'
+                          || *fmt == '+'))
                 break;
               fmt++;
             }
-          if (fmt > format_end)
-            fmt = format_end;
+
+          if (0 < pIlen && pIlen <= format_end - fmt
+              && memcmp (fmt, pI, pIlen) == 0)
+            {
+              long_flag = 2;
+              memcpy (string, fmt + 1, pIlen);
+              string += pIlen;
+              fmt += pIlen;
+            }
+          else if (fmt < format_end && *fmt == 'l')
+            {
+              long_flag = 1;
+              *string++ = *++fmt;
+            }
           *string = 0;
 
           /* Make the size bound large enough to handle floating point formats
@@ -253,8 +256,7 @@ doprnt (char *buffer, register size_t bufsize, const char *format,
           switch (*fmt++)
             {
             default:
-              error ("Invalid format operation %%%s%c",
-                     "ll" + 2 - long_flag, fmt[-1]);
+              error ("Invalid format operation %s", fmtcpy);
 
 /*          case 'b': */
             case 'l':
@@ -265,12 +267,8 @@ doprnt (char *buffer, register size_t bufsize, const char *format,
 
                 if (1 < long_flag)
                   {
-#ifdef HAVE_LONG_LONG_INT
-                    long long ll = va_arg (ap, long long);
+                    EMACS_INT ll = va_arg (ap, EMACS_INT);
                     sprintf (sprintf_buffer, fmtcpy, ll);
-#else
-                    error ("Invalid format operation %%ll%c", fmt[-1]);
-#endif
                   }
                 else if (long_flag)
                   {
@@ -295,12 +293,8 @@ doprnt (char *buffer, register size_t bufsize, const char *format,
 
                 if (1 < long_flag)
                   {
-#ifdef HAVE_UNSIGNED_LONG_LONG_INT
-                    unsigned long long ull = va_arg (ap, unsigned long long);
+                    EMACS_UINT ull = va_arg (ap, EMACS_UINT);
                     sprintf (sprintf_buffer, fmtcpy, ull);
-#else
-                    error ("Invalid format operation %%ll%c", fmt[-1]);
-#endif
                   }
                 else if (long_flag)
                   {
diff --git a/src/eval.c b/src/eval.c
index ea090644c07..6b4182cb319 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -1994,7 +1994,7 @@ verror (const char *m, va_list ap)
 {
   char buf[4000];
   size_t size = sizeof buf;
-  size_t size_max = min (MOST_POSITIVE_FIXNUM, SIZE_MAX);
+  size_t size_max = min (MOST_POSITIVE_FIXNUM + 1, SIZE_MAX);
   size_t mlen = strlen (m);
   char *buffer = buf;
   size_t used;
@@ -2002,7 +2002,10 @@ verror (const char *m, va_list ap)
 
   while (1)
     {
-      used = doprnt (buffer, size, m, m + mlen, ap);
+      va_list ap_copy;
+      va_copy (ap_copy, ap);
+      used = doprnt (buffer, size, m, m + mlen, ap_copy);
+      va_end (ap_copy);
 
       /* Note: the -1 below is because `doprnt' returns the number of bytes
          excluding the terminating null byte, and it always terminates with a
@@ -2144,7 +2147,7 @@ this does nothing and returns nil.  */)
        We used to use 0 here, but that leads to accidental sharing in
        purecopy's hash-consing, so we use a (hopefully) unique integer
        instead.  */
-    docstring = make_number (XHASH (function));
+    docstring = make_number (XPNTR (function));
   return Ffset (function,
                 Fpurecopy (list5 (Qautoload, file, docstring,
                                   interactive, type)));
diff --git a/src/fns.c b/src/fns.c
index a128b9292c6..47ded456c6e 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -75,7 +75,7 @@ Other values of LIMIT are ignored.  */)
 {
   EMACS_INT val;
   Lisp_Object lispy_val;
-  unsigned long denominator;
+  EMACS_UINT denominator;
 
   if (EQ (limit, Qt))
     seed_random (getpid () + time (NULL));
@@ -88,7 +88,7 @@ Other values of LIMIT are ignored.  */)
          it's possible to get a quotient larger than n; discarding
          these values eliminates the bias that would otherwise appear
          when using a large n.  */
-      denominator = ((unsigned long)1 << VALBITS) / XFASTINT (limit);
+      denominator = ((EMACS_UINT) 1 << VALBITS) / XFASTINT (limit);
       do
         val = get_random () / denominator;
       while (val >= XFASTINT (limit));
diff --git a/src/gtkutil.c b/src/gtkutil.c
index 9d3bfe6a89c..6e54006d913 100644
--- a/src/gtkutil.c
+++ b/src/gtkutil.c
@@ -3354,7 +3354,7 @@ xg_get_scroll_id_for_window (Display *dpy, Window wid)
 static void
 xg_gtk_scroll_destroy (GtkWidget *widget, gpointer data)
 {
-  int id = (int) (EMACS_INT) data; /* The EMACS_INT cast avoids a warning. */
+  int id = (intptr_t) data;
   xg_remove_widget_from_map (id);
 }
 
@@ -3375,7 +3375,7 @@ xg_create_scroll_bar (FRAME_PTR f,
 {
   GtkWidget *wscroll;
   GtkWidget *webox;
-  int scroll_id;
+  intptr_t scroll_id;
 #ifdef HAVE_GTK3
   GtkAdjustment *vadj;
 #else
@@ -3397,11 +3397,10 @@ xg_create_scroll_bar (FRAME_PTR f,
 
   scroll_id = xg_store_widget_in_map (wscroll);
 
-  /* The EMACS_INT cast avoids a warning. */
   g_signal_connect (G_OBJECT (wscroll),
                     "destroy",
                     G_CALLBACK (xg_gtk_scroll_destroy),
-                    (gpointer) (EMACS_INT) scroll_id);
+                    (gpointer) scroll_id);
   g_signal_connect (G_OBJECT (wscroll),
                     "change-value",
                     scroll_callback,
@@ -3663,8 +3662,8 @@ xg_tool_bar_button_cb (GtkWidget *widget,
                        GdkEventButton *event,
                        gpointer user_data)
 {
-  /* Casts to avoid warnings when gpointer is 64 bits and int is 32 bits */
-  gpointer ptr = (gpointer) (EMACS_INT) event->state;
+  intptr_t state = event->state;
+  gpointer ptr = (gpointer) state;
   g_object_set_data (G_OBJECT (widget), XG_TOOL_BAR_LAST_MODIFIER, ptr);
   return FALSE;
 }
@@ -3678,10 +3677,9 @@ xg_tool_bar_button_cb (GtkWidget *widget,
 static void
 xg_tool_bar_callback (GtkWidget *w, gpointer client_data)
 {
-  /* The EMACS_INT cast avoids a warning. */
-  int idx = (int) (EMACS_INT) client_data;
+  intptr_t idx = (intptr_t) client_data;
   gpointer gmod = g_object_get_data (G_OBJECT (w), XG_TOOL_BAR_LAST_MODIFIER);
-  int mod = (int) (EMACS_INT) gmod;
+  intptr_t mod = (intptr_t) gmod;
 
   FRAME_PTR f = (FRAME_PTR) g_object_get_data (G_OBJECT (w), XG_FRAME_DATA);
   Lisp_Object key, frame;
@@ -3960,8 +3958,7 @@ xg_tool_bar_help_callback (GtkWidget *w,
                            GdkEventCrossing *event,
                            gpointer client_data)
 {
-  /* The EMACS_INT cast avoids a warning. */
-  int idx = (int) (EMACS_INT) client_data;
+  intptr_t idx = (intptr_t) client_data;
   FRAME_PTR f = (FRAME_PTR) g_object_get_data (G_OBJECT (w), XG_FRAME_DATA);
   Lisp_Object help, frame;
 
@@ -4155,14 +4152,16 @@ xg_make_tool_item (FRAME_PTR f,
 
   if (wimage)
     {
-      /* The EMACS_INT cast avoids a warning. */
+      intptr_t ii = i;
+      gpointer gi = (gpointer) ii;
+
       g_signal_connect (G_OBJECT (ti), "create-menu-proxy",
                         G_CALLBACK (xg_tool_bar_menu_proxy),
-                        (gpointer) (EMACS_INT) i);
+                        gi);
 
       g_signal_connect (G_OBJECT (wb), "clicked",
                         G_CALLBACK (xg_tool_bar_callback),
-                        (gpointer) (EMACS_INT) i);
+                        gi);
 
       g_object_set_data (G_OBJECT (weventbox), XG_FRAME_DATA, (gpointer)f);
 
@@ -4193,11 +4192,11 @@ xg_make_tool_item (FRAME_PTR f,
       g_signal_connect (G_OBJECT (weventbox),
                         "enter-notify-event",
                         G_CALLBACK (xg_tool_bar_help_callback),
-                        (gpointer) (EMACS_INT) i);
+                        gi);
       g_signal_connect (G_OBJECT (weventbox),
                         "leave-notify-event",
                         G_CALLBACK (xg_tool_bar_help_callback),
-                        (gpointer) (EMACS_INT) i);
+                        gi);
     }
 
   if (wbutton) *wbutton = wb;
diff --git a/src/image.c b/src/image.c
index c091fea045e..747142635af 100644
--- a/src/image.c
+++ b/src/image.c
@@ -8602,11 +8602,9 @@ Libraries to load are specified in alist LIBRARIES (usually, the value
 of `dynamic-library-alist', which see).  */)
   (Lisp_Object type, Lisp_Object libraries)
 {
-  Lisp_Object tested;
-
 #ifdef HAVE_NTGUI
   /* Don't try to reload the library.  */
-  tested = Fassq (type, Vlibrary_cache);
+  Lisp_Object tested = Fassq (type, Vlibrary_cache);
   if (CONSP (tested))
     return XCDR (tested);
 #endif
diff --git a/src/lisp.h b/src/lisp.h
index 3eda487148e..66f5c962be8 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -22,6 +22,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include <stdarg.h>
 #include <stddef.h>
+#include <inttypes.h>
 
 /* Use the configure flag --enable-checking[=LIST] to enable various
    types of run time checks for Lisp objects.  */
@@ -33,25 +34,28 @@ extern void check_cons_list (void);
 #define CHECK_CONS_LIST() ((void) 0)
 #endif
 
+/* Temporarily disable wider-than-pointer integers until they're tested more.
+   Build with CFLAGS='-DWIDE_EMACS_INT' to try them out.  */
+/* #undef WIDE_EMACS_INT */
+
 /* These are default choices for the types to use.  */
-#ifdef _LP64
-#ifndef EMACS_INT
-#define EMACS_INT long
-#define BITS_PER_EMACS_INT BITS_PER_LONG
-#define pI "l"
-#endif
-#ifndef EMACS_UINT
-#define EMACS_UINT unsigned long
-#endif
-#else /* not _LP64 */
 #ifndef EMACS_INT
-#define EMACS_INT int
-#define BITS_PER_EMACS_INT BITS_PER_INT
-#define pI ""
+# if BITS_PER_LONG < BITS_PER_LONG_LONG && defined WIDE_EMACS_INT
+#  define EMACS_INT long long
+#  define BITS_PER_EMACS_INT BITS_PER_LONG_LONG
+#  define pI "ll"
+# elif BITS_PER_INT < BITS_PER_LONG
+#  define EMACS_INT long
+#  define BITS_PER_EMACS_INT BITS_PER_LONG
+#  define pI "l"
+# else
+#  define EMACS_INT int
+#  define BITS_PER_EMACS_INT BITS_PER_INT
+#  define pI ""
+# endif
 #endif
 #ifndef EMACS_UINT
-#define EMACS_UINT unsigned int
-#endif
+# define EMACS_UINT unsigned EMACS_INT
 #endif
 
 /* Extra internal type checking?  */
@@ -398,7 +402,7 @@ enum pvec_type
 #ifdef USE_LSB_TAG
 
 #define TYPEMASK ((((EMACS_INT) 1) << GCTYPEBITS) - 1)
-#define XTYPE(a) ((enum Lisp_Type) (((EMACS_UINT) (a)) & TYPEMASK))
+#define XTYPE(a) ((enum Lisp_Type) ((a) & TYPEMASK))
 #ifdef USE_2_TAGS_FOR_INTS
 # define XINT(a) (((EMACS_INT) (a)) >> (GCTYPEBITS - 1))
 # define XUINT(a) (((EMACS_UINT) (a)) >> (GCTYPEBITS - 1))
@@ -408,11 +412,11 @@ enum pvec_type
 # define XUINT(a) (((EMACS_UINT) (a)) >> GCTYPEBITS)
 # define make_number(N) (((EMACS_INT) (N)) << GCTYPEBITS)
 #endif
-#define XSET(var, type, ptr)                                    \
-    (eassert (XTYPE (ptr) == 0), /* Check alignment.  */        \
-     (var) = ((EMACS_INT) (type)) | ((EMACS_INT) (ptr)))
+#define XSET(var, type, ptr)                                            \
+    (eassert (XTYPE ((intptr_t) (ptr)) == 0), /* Check alignment.  */ \
+     (var) = (type) | (intptr_t) (ptr))
 
-#define XPNTR(a) ((EMACS_INT) ((a) & ~TYPEMASK))
+#define XPNTR(a) ((intptr_t) ((a) & ~TYPEMASK))
 
 #else  /* not USE_LSB_TAG */
 
@@ -446,14 +450,14 @@ enum pvec_type
 
 #define XSET(var, type, ptr)                              \
    ((var) = ((EMACS_INT) ((EMACS_UINT) (type) << VALBITS) \
-             + ((EMACS_INT) (ptr) & VALMASK)))
+             + ((intptr_t) (ptr) & VALMASK)))
 
 #ifdef DATA_SEG_BITS
 /* DATA_SEG_BITS forces extra bits to be or'd in with any pointers
    which were stored in a Lisp_Object */
-#define XPNTR(a) ((EMACS_UINT) (((a) & VALMASK) | DATA_SEG_BITS))
+#define XPNTR(a) ((uintptr_t) (((a) & VALMASK)) | DATA_SEG_BITS))
 #else
-#define XPNTR(a) ((EMACS_UINT) ((a) & VALMASK))
+#define XPNTR(a) ((uintptr_t) ((a) & VALMASK))
 #endif
 
 #endif /* not USE_LSB_TAG */
@@ -479,7 +483,7 @@ enum pvec_type
 /* Some versions of gcc seem to consider the bitfield width when issuing
    the "cast to pointer from integer of different size" warning, so the
    cast is here to widen the value back to its natural size.  */
-# define XPNTR(v) ((EMACS_INT)((v).s.val) << GCTYPEBITS)
+# define XPNTR(v) ((intptr_t) (v).s.val << GCTYPEBITS)
 
 #else  /* !USE_LSB_TAG */
 
@@ -495,9 +499,9 @@ enum pvec_type
 #ifdef DATA_SEG_BITS
 /* DATA_SEG_BITS forces extra bits to be or'd in with any pointers
    which were stored in a Lisp_Object */
-#define XPNTR(a) (XUINT (a) | DATA_SEG_BITS)
+#define XPNTR(a) ((intptr_t) (XUINT (a) | DATA_SEG_BITS))
 #else
-#define XPNTR(a) ((EMACS_INT) XUINT (a))
+#define XPNTR(a) ((intptr_t) XUINT (a))
 #endif
 
 #endif  /* !USE_LSB_TAG */
@@ -1814,8 +1818,8 @@ typedef struct {
     XSETCDR ((x), tmp);                 \
   } while (0)
 
-/* Cast pointers to this type to compare them.  Some machines want int.  */
-#define PNTR_COMPARISON_TYPE EMACS_UINT
+/* Cast pointers to this type to compare them.  */
+#define PNTR_COMPARISON_TYPE uintptr_t
 
 /* Define a built-in function for calling from Lisp.
  `lname' should be the name to give the function in Lisp,
@@ -3354,7 +3358,7 @@ extern void flush_pending_output (int);
 extern void child_setup_tty (int);
 extern void setup_pty (int);
 extern int set_window_size (int, int, int);
-extern long get_random (void);
+extern EMACS_INT get_random (void);
 extern void seed_random (long);
 extern int emacs_open (const char *, int, int);
 extern int emacs_close (int);
diff --git a/src/lread.c b/src/lread.c
index 2139d558851..a6da09cf330 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -19,7 +19,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 
 #include <config.h>
-#include <inttypes.h>
 #include <stdio.h>
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -2250,6 +2249,26 @@ read_escape (Lisp_Object readcharfun, int stringp)
     }
 }
 
+/* Return the digit that CHARACTER stands for in the given BASE.
+   Return -1 if CHARACTER is out of range for BASE,
+   and -2 if CHARACTER is not valid for any supported BASE.  */
+static inline int
+digit_to_number (int character, int base)
+{
+  int digit;
+
+  if ('0' <= character && character <= '9')
+    digit = character - '0';
+  else if ('a' <= character && character <= 'z')
+    digit = character - 'a' + 10;
+  else if ('A' <= character && character <= 'Z')
+    digit = character - 'A' + 10;
+  else
+    return -2;
+
+  return digit < base ? digit : -1;
+}
+
 /* Read an integer in radix RADIX using READCHARFUN to read
    characters.  RADIX must be in the interval [2..36]; if it isn't, a
    read error is signaled .  Value is the integer read.  Signals an
@@ -2259,59 +2278,64 @@ read_escape (Lisp_Object readcharfun, int stringp)
 static Lisp_Object
 read_integer (Lisp_Object readcharfun, int radix)
 {
-  int ndigits = 0, invalid_p, c, sign = 0;
-  /* We use a floating point number because  */
-  double number = 0;
+  /* Room for sign, leading 0, other digits, trailing null byte.  */
+  char buf[1 + 1 + sizeof (uintmax_t) * CHAR_BIT + 1];
+
+  int valid = -1; /* 1 if valid, 0 if not, -1 if incomplete.  */
 
   if (radix < 2 || radix > 36)
-    invalid_p = 1;
+    valid = 0;
   else
     {
-      number = ndigits = invalid_p = 0;
-      sign = 1;
+      char *p = buf;
+      int c, digit;
 
       c = READCHAR;
-      if (c == '-')
+      if (c == '-' || c == '+')
         {
+          *p++ = c;
           c = READCHAR;
-          sign = -1;
         }
-      else if (c == '+')
-        c = READCHAR;
 
-      while (c >= 0)
+      if (c == '0')
         {
-          int digit;
-
-          if (c >= '0' && c <= '9')
-            digit = c - '0';
-          else if (c >= 'a' && c <= 'z')
-            digit = c - 'a' + 10;
-          else if (c >= 'A' && c <= 'Z')
-            digit = c - 'A' + 10;
-          else
-            {
-              UNREAD (c);
-              break;
-            }
+          *p++ = c;
+          valid = 1;
 
-          if (digit < 0 || digit >= radix)
-            invalid_p = 1;
+          /* Ignore redundant leading zeros, so the buffer doesn't
+             fill up with them.  */
+          do
+            c = READCHAR;
+          while (c == '0');
+        }
+
+      while (-1 <= (digit = digit_to_number (c, radix)))
+        {
+          if (digit == -1)
+            valid = 0;
+          if (valid < 0)
+            valid = 1;
+
+          if (p < buf + sizeof buf - 1)
+            *p++ = c;
+          else
+            valid = 0;
 
-          number = radix * number + digit;
-          ++ndigits;
           c = READCHAR;
         }
+
+      if (c >= 0)
+        UNREAD (c);
+      *p = '\0';
     }
 
-  if (ndigits == 0 || invalid_p)
+  if (! valid)
     {
-      char buf[50];
       sprintf (buf, "integer, radix %d", radix);
       invalid_syntax (buf, 0);
     }
 
-  return make_fixnum_or_float (sign * number);
+  return string_to_number (buf, radix, 0);
 }
 
 
@@ -3170,23 +3194,6 @@ substitute_in_interval (INTERVAL interval, Lisp_Object arg)
 }
 
 
-static inline int
-digit_to_number (int character, int base)
-{
-  int digit;
-
-  if ('0' <= character && character <= '9')
-    digit = character - '0';
-  else if ('a' <= character && character <= 'z')
-    digit = character - 'a' + 10;
-  else if ('A' <= character && character <= 'Z')
-    digit = character - 'A' + 10;
-  else
-    return -1;
-
-  return digit < base ? digit : -1;
-}
-
 #define LEAD_INT 1
 #define DOT_CHAR 2
 #define TRAIL_INT 4
@@ -3615,9 +3622,9 @@ static Lisp_Object initial_obarray;
 
 /* oblookup stores the bucket number here, for the sake of Funintern.  */
 
-static int oblookup_last_bucket_number;
+static size_t oblookup_last_bucket_number;
 
-static int hash_string (const char *ptr, int len);
+static size_t hash_string (const char *ptr, size_t len);
 
 /* Get an error if OBARRAY is not an obarray.
    If it is one, return it.  */
@@ -3759,7 +3766,7 @@ OBARRAY defaults to the value of the variable `obarray'.  */)
   (Lisp_Object name, Lisp_Object obarray)
 {
   register Lisp_Object string, tem;
-  int hash;
+  size_t hash;
 
   if (NILP (obarray)) obarray = Vobarray;
   obarray = check_obarray (obarray);
@@ -3828,8 +3835,8 @@ OBARRAY defaults to the value of the variable `obarray'.  */)
 Lisp_Object
 oblookup (Lisp_Object obarray, register const char *ptr, EMACS_INT size, EMACS_INT size_byte)
 {
-  int hash;
-  int obsize;
+  size_t hash;
+  size_t obsize;
   register Lisp_Object tail;
   Lisp_Object bucket, tem;
 
@@ -3862,21 +3869,21 @@ oblookup (Lisp_Object obarray, register const char *ptr, EMACS_INT size, EMACS_I
   return tem;
 }
 
-static int
-hash_string (const char *ptr, int len)
+static size_t
+hash_string (const char *ptr, size_t len)
 {
   register const char *p = ptr;
   register const char *end = p + len;
   register unsigned char c;
-  register int hash = 0;
+  register size_t hash = 0;
 
   while (p != end)
     {
       c = *p++;
       if (c >= 0140) c -= 40;
-      hash = ((hash<<3) + (hash>>28) + c);
+      hash = (hash << 3) + (hash >> (CHAR_BIT * sizeof hash - 4)) + c;
     }
-  return hash & 07777777777;
+  return hash;
 }
 
 void
diff --git a/src/menu.c b/src/menu.c
index f637b92679a..7a3edcb6f4f 100644
--- a/src/menu.c
+++ b/src/menu.c
@@ -800,9 +800,9 @@ digest_single_submenu (int start, int end, int top_level_items)
           if (!NILP (descrip))
             wv->lkey = descrip;
           wv->value = 0;
-          /* The EMACS_INT cast avoids a warning.  There's no problem
+          /* The intptr_t cast avoids a warning.  There's no problem
              as long as pointers have enough bits to hold small integers.  */
-          wv->call_data = (!NILP (def) ? (void *) (EMACS_INT) i : 0);
+          wv->call_data = (!NILP (def) ? (void *) (intptr_t) i : 0);
           wv->enabled = !NILP (enable);
 
           if (NILP (type))
@@ -911,9 +911,9 @@ find_and_call_menu_selection (FRAME_PTR f, int menu_bar_items_used, Lisp_Object
       else
         {
           entry = XVECTOR (vector)->contents[i + MENU_ITEMS_ITEM_VALUE];
-          /* The EMACS_INT cast avoids a warning.  There's no problem
+          /* Treat the pointer as an integer.  There's no problem
              as long as pointers have enough bits to hold small integers.  */
-          if ((int) (EMACS_INT) client_data == i)
+          if ((intptr_t) client_data == i)
             {
               int j;
               struct input_event buf;
diff --git a/src/process.c b/src/process.c
index 75dd7efd581..8a94b3e6047 100644
--- a/src/process.c
+++ b/src/process.c
@@ -28,7 +28,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <sys/file.h>
 #include <sys/stat.h>
 #include <setjmp.h>
-#include <inttypes.h>
 
 #include <unistd.h>
 #include <fcntl.h>
@@ -1386,7 +1385,7 @@ usage: (start-process NAME BUFFER PROGRAM &rest PROGRAM-ARGS)  */)
       {
         if (EQ (coding_systems, Qt))
           {
-            args2 = (Lisp_Object *) alloca ((nargs + 1) * sizeof args2);
+            args2 = (Lisp_Object *) alloca ((nargs + 1) * sizeof *args2);
             args2[0] = Qstart_process;
             for (i = 0; i < nargs; i++) args2[i + 1] = args[i];
             GCPRO2 (proc, current_dir);
diff --git a/src/sysdep.c b/src/sysdep.c
index 462e03879c6..5ad3389dd8f 100644
--- a/src/sysdep.c
+++ b/src/sysdep.c
@@ -1786,23 +1786,14 @@ seed_random (long int arg)
  * Build a full Emacs-sized word out of whatever we've got.
  * This suffices even for a 64-bit architecture with a 15-bit rand.
  */
-long
+EMACS_INT
 get_random (void)
 {
-  long val = random ();
-#if VALBITS > RAND_BITS
-  val = (val << RAND_BITS) ^ random ();
-#if VALBITS > 2*RAND_BITS
-  val = (val << RAND_BITS) ^ random ();
-#if VALBITS > 3*RAND_BITS
-  val = (val << RAND_BITS) ^ random ();
-#if VALBITS > 4*RAND_BITS
-  val = (val << RAND_BITS) ^ random ();
-#endif /* need at least 5 */
-#endif /* need at least 4 */
-#endif /* need at least 3 */
-#endif /* need at least 2 */
-  return val & ((1L << VALBITS) - 1);
+  EMACS_UINT val = 0;
+  int i;
+  for (i = 0; i < (VALBITS + RAND_BITS - 1) / RAND_BITS; i++)
+    val = (val << RAND_BITS) ^ random ();
+  return val & (((EMACS_INT) 1 << VALBITS) - 1);
 }
 
 #ifndef HAVE_STRERROR
diff --git a/src/term.c b/src/term.c
index 28709138a17..c68228cc51a 100644
--- a/src/term.c
+++ b/src/term.c
@@ -26,7 +26,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <sys/file.h>
 #include <unistd.h>
 #include <signal.h>
-#include <stdarg.h>
 #include <setjmp.h>
 
 #include "lisp.h"
@@ -3619,7 +3618,6 @@ vfatal (const char *str, va_list ap)
   vfprintf (stderr, str, ap);
   if (!(strlen (str) > 0 && str[strlen (str) - 1] == '\n'))
     fprintf (stderr, "\n");
-  va_end (ap);
   fflush (stderr);
   exit (1);
 }
diff --git a/src/xdisp.c b/src/xdisp.c
index 6d3c142f62a..88353e37925 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -8737,7 +8737,7 @@ display_echo_area (struct window *w)
   window_height_changed_p
     = with_echo_area_buffer (w, display_last_displayed_message_p,
                              display_echo_area_1,
-                             (EMACS_INT) w, Qnil, 0, 0);
+                             (intptr_t) w, Qnil, 0, 0);
 
   if (no_message_p)
     echo_area_buffer[i] = Qnil;
@@ -8756,7 +8756,8 @@ display_echo_area (struct window *w)
 static int
 display_echo_area_1 (EMACS_INT a1, Lisp_Object a2, EMACS_INT a3, EMACS_INT a4)
 {
-  struct window *w = (struct window *) a1;
+  intptr_t i1 = a1;
+  struct window *w = (struct window *) i1;
   Lisp_Object window;
   struct text_pos start;
   int window_height_changed_p = 0;
@@ -8798,7 +8799,8 @@ resize_echo_area_exactly (void)
         resize_exactly = Qnil;
 
       resized_p = with_echo_area_buffer (w, 0, resize_mini_window_1,
-                                         (EMACS_INT) w, resize_exactly, 0, 0);
+                                         (intptr_t) w, resize_exactly,
+                                         0, 0);
       if (resized_p)
         {
           ++windows_or_buffers_changed;
@@ -8818,7 +8820,8 @@ resize_echo_area_exactly (void)
 static int
 resize_mini_window_1 (EMACS_INT a1, Lisp_Object exactly, EMACS_INT a3, EMACS_INT a4)
 {
-  return resize_mini_window ((struct window *) a1, !NILP (exactly));
+  intptr_t i1 = a1;
+  return resize_mini_window ((struct window *) i1, !NILP (exactly));
 }
 
 
@@ -8984,7 +8987,7 @@ current_message (void)
   else
     {
       with_echo_area_buffer (0, 0, current_message_1,
-                             (EMACS_INT) &msg, Qnil, 0, 0);
+                             (intptr_t) &msg, Qnil, 0, 0);
       if (NILP (msg))
         echo_area_buffer[0] = Qnil;
     }
@@ -8996,7 +8999,8 @@ current_message (void)
 static int
 current_message_1 (EMACS_INT a1, Lisp_Object a2, EMACS_INT a3, EMACS_INT a4)
 {
-  Lisp_Object *msg = (Lisp_Object *) a1;
+  intptr_t i1 = a1;
+  Lisp_Object *msg = (Lisp_Object *) i1;
 
   if (Z > BEG)
     *msg = make_buffer_string (BEG, Z, 1);
@@ -9127,7 +9131,7 @@ set_message (const char *s, Lisp_Object string,
        || (STRINGP (string) && STRING_MULTIBYTE (string)));
 
   with_echo_area_buffer (0, -1, set_message_1,
-                         (EMACS_INT) s, string, nbytes, multibyte_p);
+                         (intptr_t) s, string, nbytes, multibyte_p);
   message_buf_print = 0;
   help_echo_showing_p = 0;
 }
@@ -9141,7 +9145,8 @@ set_message (const char *s, Lisp_Object string,
 static int
 set_message_1 (EMACS_INT a1, Lisp_Object a2, EMACS_INT nbytes, EMACS_INT multibyte_p)
 {
-  const char *s = (const char *) a1;
+  intptr_t i1 = a1;
+  const char *s = (const char *) i1;
   const unsigned char *msg = (const unsigned char *) s;
   Lisp_Object string = a2;
 
diff --git a/src/xmenu.c b/src/xmenu.c
index 2d6185c16e5..2a4359fa84a 100644
--- a/src/xmenu.c
+++ b/src/xmenu.c
@@ -1012,10 +1012,10 @@ set_frame_menubar (FRAME_PTR f, int first_time, int deep_p)
       menu_items = f->menu_bar_vector;
       menu_items_allocated = VECTORP (menu_items) ? ASIZE (menu_items) : 0;
       subitems = ASIZE (items) / 4;
-      submenu_start = (int *) alloca (subitems * sizeof (int *));
-      submenu_end = (int *) alloca (subitems * sizeof (int *));
+      submenu_start = (int *) alloca (subitems * sizeof (int));
+      submenu_end = (int *) alloca (subitems * sizeof (int));
       submenu_n_panes = (int *) alloca (subitems * sizeof (int));
-      submenu_top_level_items = (int *) alloca (subitems * sizeof (int *));
+      submenu_top_level_items = (int *) alloca (subitems * sizeof (int));
       init_menu_items ();
       for (i = 0; i < subitems; i++)
         {
@@ -1139,9 +1139,9 @@ set_frame_menubar (FRAME_PTR f, int first_time, int deep_p)
           wv->help = Qnil;
           /* This prevents lwlib from assuming this
              menu item is really supposed to be empty.  */
-          /* The EMACS_INT cast avoids a warning.
+          /* The intptr_t cast avoids a warning.
              This value just has to be different from small integers.  */
-          wv->call_data = (void *) (EMACS_INT) (-1);
+          wv->call_data = (void *) (intptr_t) (-1);
 
           if (prev_wv)
             prev_wv->next = wv;
@@ -1876,9 +1876,9 @@ xmenu_show (FRAME_PTR f, int x, int y, int for_click, int keymaps,
 static void
 dialog_selection_callback (GtkWidget *widget, gpointer client_data)
 {
-  /* The EMACS_INT cast avoids a warning.  There's no problem
+  /* Treat the pointer as an integer.  There's no problem
      as long as pointers have enough bits to hold small integers.  */
-  if ((int) (EMACS_INT) client_data != -1)
+  if ((intptr_t) client_data != -1)
     menu_item_selection = (Lisp_Object *) client_data;
 
   popup_activated_flag = 0;