bug-gnu-emacs
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

bug#8873: Integer overflow and signedness fixes (2011-06-15 batch)


From: Paul Eggert
Subject: bug#8873: Integer overflow and signedness fixes (2011-06-15 batch)
Date: Wed, 15 Jun 2011 12:53:36 -0700
User-agent: Mozilla/5.0 (X11; U; Linux x86_64; en-US; rv:1.9.2.17) Gecko/20110428 Fedora/3.1.10-1.fc14 Thunderbird/3.1.10

This is a followup to Emacs bug 8794, where I wrote that
I was squashing int-overflow bugs while making another patch.
Here's the first batch of these bug fixes.  Individually they're
all fairly trivial but collectively they're big enough so that
it's probably worth a bug report.  I plan to install this patch
shortly.

# Bazaar merge directive format 2 (Bazaar 0.90)
# revision_id: eggert@cs.ucla.edu-20110615194052-ckpvo0l7qr44bqlp
# target_branch: bzr+ssh://eggert@bzr.savannah.gnu.org/emacs/trunk
# testament_sha1: c229ce990f77f2c9841a0da12d97cf2969430203
# timestamp: 2011-06-15 12:47:49 -0700
# base_revision_id: eggert@cs.ucla.edu-20110615185018-wrgk8r9xdltspb7e
# 
# Begin patch
=== modified file 'src/ChangeLog'
--- src/ChangeLog       2011-06-15 18:36:00 +0000
+++ src/ChangeLog       2011-06-15 19:40:52 +0000
@@ -1,3 +1,253 @@
+2011-06-15  Paul Eggert  <eggert@cs.ucla.edu>
+
+       Integer overflow and signedness fixes.
+
+       * ccl.c (ASCENDING_ORDER): New macro, to work around GCC bug 43772.
+       (GET_CCL_RANGE, IN_INT_RANGE): Use it.
+
+       * fileio.c: Don't assume EMACS_INT fits in off_t.
+       (emacs_lseek): New static function.
+       (Finsert_file_contents, Fwrite_region): Use it.
+       Use SEEK_SET, SEEK_CUR, SEEK_END as appropriate.
+
+       * fns.c (Fload_average): Don't assume 100 * load average fits in int.
+
+       * fns.c: Don't overflow int when computing a list length.
+       * fns.c (QUIT_COUNT_HEURISTIC): New constant.
+       (Flength, Fsafe_length): Use EMACS_INT, not int, to avoid unwanted
+       truncation on 64-bit hosts.  Check for QUIT every
+       QUIT_COUNT_HEURISTIC entries rather than every other entry; that's
+       faster and is responsive enough.
+       (Flength): Report an error instead of overflowing an integer.
+       (Fsafe_length): Return a float if the value is not representable
+       as a fixnum.  This shouldn't happen except in contrived situations.
+       (Fnthcdr, Fsort): Don't assume list length fits in int.
+       (Fcopy_sequence): Don't assume vector length fits in int.
+
+       * alloc.c: Check that resized vectors' lengths fit in fixnums.
+       (header_size, word_size): New constants.
+       (allocate_vectorlike): Don't check size overflow here.
+       (allocate_vector): Check it here instead, since this is the only
+       caller of allocate_vectorlike that could cause overflow.
+       Check that the new vector's length is representable as a fixnum.
+
+       * fns.c (next_almost_prime): Don't return a multiple of 3 or 5.
+       The previous code was bogus.  For example, next_almost_prime (32)
+       returned 39, which is undesirable as it is a multiple of 3; and
+       next_almost_prime (24) returned 25, which is a multiple of 5 so
+       why was the code bothering to check for multiples of 7?
+
+       * bytecode.c (exec_byte_code): Use ptrdiff_t, not int, for vector 
length.
+
+       * eval.c, doprnt.c (SIZE_MAX): Remove; inttypes.h defines this now.
+
+       Variadic C functions now count arguments with ptrdiff_t.
+       This partly undoes my 2011-03-30 change, which replaced int with size_t.
+       Back then I didn't know that the Emacs coding style prefers signed int.
+       Also, in the meantime I found a few more instances where arguments
+       were being counted with int, which may truncate counts on 64-bit
+       machines, or EMACS_INT, which may be unnecessarily wide.
+       * lisp.h (struct Lisp_Subr.function.aMANY)
+       (DEFUN_ARGS_MANY, internal_condition_case_n, safe_call):
+       Arg counts are now ptrdiff_t, not size_t.
+       All variadic functions and their callers changed accordingly.
+       (struct gcpro.nvars): Now size_t, not size_t.  All uses changed.
+       * bytecode.c (exec_byte_code): Check maxdepth for overflow,
+       to avoid potential buffer overrun.  Don't assume arg counts fit in 
'int'.
+       * callint.c (Fcall_interactively): Check arg count for overflow,
+       to avoid potential buffer overrun.  Use signed char, not 'int',
+       for 'varies' array, so that we needn't bother to check its size
+       calculation for overflow.
+       * editfns.c (Fformat): Use ptrdiff_t, not EMACS_INT, to count args.
+       * eval.c (apply_lambda):
+       * fns.c (Fmapconcat): Use XFASTINT, not XINT, to get args length.
+       (struct textprop_rec.argnum): Now ptrdiff_t, not int.  All uses changed.
+       (mapconcat): Use ptrdiff_t, not int and EMACS_INT, to count args.
+
+       * callint.c (Fcall_interactively): Don't use index var as event count.
+
+       * vm-limit.c (check_memory_limits): Fix incorrect extern function decls.
+       * mem-limits.h (SIZE): Remove; no longer used.
+
+       * xterm.c (x_alloc_nearest_color_1): Prefer int to long when int works.
+
+       Remove unnecessary casts.
+       * xterm.c (x_term_init):
+       * xfns.c (x_set_border_pixel):
+       * widget.c (create_frame_gcs): Remove casts to unsigned long etc.
+       These aren't needed now that we assume ANSI C.
+
+       * sound.c (Fplay_sound_internal): Remove cast to unsigned long.
+       It's more likely to cause problems (due to unsigned overflow)
+       than to cure them.
+
+       * dired.c (Ffile_attributes): Don't use 32-bit hack on 64-bit hosts.
+
+       * unexelf.c (unexec): Don't assume BSS addr fits in unsigned.
+
+       * xterm.c (handle_one_xevent): Omit unnecessary casts to unsigned.
+
+       * keyboard.c (modify_event_symbol): Don't limit alist len to UINT_MAX.
+
+       * lisp.h (CHAR_TABLE_SET): Omit now-redundant test.
+
+       * lread.c (Fload): Don't compare a possibly-garbage time_t value.
+
+       GLYPH_CODE_FACE returns EMACS_INT, not int.
+       * dispextern.h (merge_faces):
+       * xfaces.c (merge_faces):
+       * xdisp.c (get_next_display_element, next_element_from_display_vector):
+       Don't assume EMACS_INT fits in int.
+
+       * character.h (CHAR_VALID_P): Remove unused parameter.
+       * fontset.c, lisp.h, xdisp.c: All uses changed.
+
+       * editfns.c (Ftranslate_region_internal): Omit redundant test.
+
+       * fns.c (concat): Minor tuning based on overflow analysis.
+       This doesn't fix any bugs.  Use int to hold character, instead
+       of constantly refetching from Emacs object.  Use XFASTINT, not
+       XINT, for value known to be a character.  Don't bother comparing
+       a single byte to 0400, as it's always less.
+
+       * floatfns.c (Fexpt):
+       * fileio.c (make_temp_name): Omit unnecessary cast to unsigned.
+
+       * editfns.c (Ftranslate_region_internal): Use int, not EMACS_INT
+       for characters.
+
+       * doc.c (get_doc_string): Omit (unsigned)c that mishandled negatives.
+
+       * data.c (Faset): If ARRAY is a string, check that NEWELT is a char.
+       Without this fix, on a 64-bit host (aset S 0 4294967386) would
+       incorrectly succeed when S was a string, because 4294967386 was
+       truncated before it was used.
+
+       * chartab.c (Fchar_table_range): Use CHARACTERP to check range.
+       Otherwise, an out-of-range integer could cause undefined behavior
+       on a 64-bit host.
+
+       * composite.c: Use int, not EMACS_INT, for characters.
+       (fill_gstring_body, composition_compute_stop_pos): Use int, not
+       EMACS_INT, for values that are known to be in character range.
+       This doesn't fix any bugs but is the usual style inside Emacs and
+       may generate better code on 32-bit machines.
+
+       Make sure a 64-bit char is never passed to ENCODE_CHAR.
+       This is for reasons similar to the recent CHAR_STRING fix.
+       * charset.c (Fencode_char): Check that character arg is actually
+       a character.  Pass an int to ENCODE_CHAR.
+       * charset.h (ENCODE_CHAR): Verify that the character argument is no
+       wider than 'int', as a compile-time check to prevent future regressions
+       in this area.
+
+       * character.c (char_string): Remove unnecessary casts.
+
+       Make sure a 64-bit char is never passed to CHAR_STRING.
+       Otherwise, CHAR_STRING would do the wrong thing on a 64-bit platform,
+       by silently ignoring the top 32 bits, allowing some values
+       that were far too large to be valid characters.
+       * character.h: Include <verify.h>.
+       (CHAR_STRING, CHAR_STRING_ADVANCE): Verify that the character
+       arguments are no wider than unsigned, as a compile-time check
+       to prevent future regressions in this area.
+       * data.c (Faset):
+       * editfns.c (Fchar_to_string, general_insert_function, Finsert_char)
+       (Fsubst_char_in_region):
+       * fns.c (concat):
+       * xdisp.c (decode_mode_spec_coding):
+       Adjust to CHAR_STRING's new requirement.
+       * editfns.c (Finsert_char, Fsubst_char_in_region):
+       * fns.c (concat): Check that character args are actually
+       characters.  Without this test, these functions did the wrong
+       thing with wildly out-of-range values on 64-bit hosts.
+
+       Remove incorrect casts to 'unsigned' that lose info on 64-bit hosts.
+       These casts should not be needed on 32-bit hosts, either.
+       * keyboard.c (read_char):
+       * lread.c (Fload): Remove casts to unsigned.
+
+       * lisp.h (UNSIGNED_CMP): New macro.
+       This fixes comparison bugs on 64-bit hosts.
+       (ASCII_CHAR_P): Use it.
+       * casefiddle.c (casify_object):
+       * character.h (ASCII_BYTE_P, CHAR_VALID_P)
+       (SINGLE_BYTE_CHAR_P, CHAR_STRING):
+       * composite.h (COMPOSITION_ENCODE_RULE_VALID):
+       * dispextern.h (FACE_FROM_ID):
+       * keyboard.c (read_char): Use UNSIGNED_CMP.
+
+       * xmenu.c (dialog_selection_callback) [!USE_GTK]: Cast to intptr_t,
+       not to EMACS_INT, to avoid GCC warning.
+
+       * xfns.c (x_set_scroll_bar_default_width): Remove unused 'int' locals.
+
+       * buffer.h (PTR_BYTE_POS, BUF_PTR_BYTE_POS): Remove harmful cast.
+       The cast incorrectly truncated 64-bit byte offsets to 32 bits, and
+       isn't needed on 32-bit machines.
+
+       * buffer.c (Fgenerate_new_buffer_name):
+       Use EMACS_INT for count, not int.
+       (advance_to_char_boundary): Return EMACS_INT, not int.
+
+       * data.c (Qcompiled_function): Now static.
+
+       * window.c (window_body_lines): Now static.
+
+       * image.c (gif_load): Rename local to avoid shadowing.
+
+       * lisp.h (SAFE_ALLOCA_LISP): Check for integer overflow.
+       (struct Lisp_Save_Value): Use ptrdiff_t, not int, for 'integer' member.
+       * alloc.c (make_save_value): Integer argument is now of type
+       ptrdiff_t, not int.
+       (mark_object): Use ptrdiff_t, not int.
+       * lisp.h (pD): New macro.
+       * print.c (print_object): Use it.
+
+       * alloc.c: Use EMACS_INT, not int, to count objects.
+       (total_conses, total_markers, total_symbols, total_vector_size)
+       (total_free_conses, total_free_markers, total_free_symbols)
+       (total_free_floats, total_floats, total_free_intervals)
+       (total_intervals, total_strings, total_free_strings):
+       Now EMACS_INT, not int.  All uses changed.
+       (Fgarbage_collect): Compute overall total using a double, so that
+       integer overflow is less likely to be a problem.  Check for overflow
+       when converting back to an integer.
+       (n_interval_blocks, n_string_blocks, n_float_blocks, n_cons_blocks)
+       (n_vectors, n_symbol_blocks, n_marker_blocks): Remove.
+       These were 'int' variables that could overflow on 64-bit hosts;
+       they were never used, so remove them instead of repairing them.
+       (nzombies, ngcs, max_live, max_zombies): Now EMACS_INT, not 'int'.
+       (inhibit_garbage_collection): Set gc_cons_threshold to max value.
+       Previously, this ceilinged at INT_MAX, but that doesn't work on
+       64-bit machines.
+       (allocate_pseudovector): Don't use EMACS_INT when int would do.
+
+       * alloc.c (Fmake_bool_vector): Don't assume vector size fits in int.
+       (allocate_vectorlike): Check for ptrdiff_t overflow.
+       (mark_vectorlike, mark_char_table, mark_object): Avoid EMACS_UINT
+       when a (possibly-narrower) signed value would do just as well.
+       We prefer using signed arithmetic, to avoid comparison confusion.
+
+       * alloc.c: Catch some string size overflows that we were missing.
+       (XMALLOC_OVERRUN_CHECK_SIZE) [!XMALLOC_OVERRUN_CHECK]: Define to 0,
+       for convenience in STRING_BYTES_MAX.
+       (STRING_BYTES_MAX): New macro, superseding the old one in lisp.h.
+       The definition here is exact; the one in lisp.h was approximate.
+       (allocate_string_data): Check for string overflow.  This catches
+       some instances we weren't catching before.  Also, it catches
+       size_t overflow on (unusual) hosts where SIZE_MAX <= min
+       (PTRDIFF_MAX, MOST_POSITIVE_FIXNUM), e.g., when size_t is 32 bits
+       and ptrdiff_t and EMACS_INT are both 64 bits.
+
+       * character.c, coding.c, doprnt.c, editfns.c, eval.c:
+       All uses of STRING_BYTES_MAX replaced by STRING_BYTES_BOUND.
+       * lisp.h (STRING_BYTES_BOUND): Renamed from STRING_BYTES_MAX.
+
+       * character.c (string_escape_byte8): Fix nbytes/nchars typo.
+
+       * alloc.c (Fmake_string): Check for out-of-range init.
+
 2011-06-15  Stefan Monnier  <monnier@iro.umontreal.ca>
 
        * eval.c (Fdefvaralias): Also mark the target as variable-special-p.

=== modified file 'src/alloc.c'
--- src/alloc.c 2011-06-06 19:43:39 +0000
+++ src/alloc.c 2011-06-14 21:30:16 +0000
@@ -180,9 +180,9 @@
 
 /* Number of live and free conses etc.  */
 
-static int total_conses, total_markers, total_symbols, total_vector_size;
-static int total_free_conses, total_free_markers, total_free_symbols;
-static int total_free_floats, total_floats;
+static EMACS_INT total_conses, total_markers, total_symbols, total_vector_size;
+static EMACS_INT total_free_conses, total_free_markers, total_free_symbols;
+static EMACS_INT total_free_floats, total_floats;
 
 /* Points to memory space allocated as "spare", to be freed if we run
    out of memory.  We keep one large block, four cons-blocks, and
@@ -485,7 +485,9 @@
 }
 
 
-#ifdef XMALLOC_OVERRUN_CHECK
+#ifndef XMALLOC_OVERRUN_CHECK
+#define XMALLOC_OVERRUN_CHECK_SIZE 0
+#else
 
 /* Check for overrun in malloc'ed buffers by wrapping a 16 byte header
    and a 16 byte trailer around each block.
@@ -1336,16 +1338,12 @@
 
 /* Number of free and live intervals.  */
 
-static int total_free_intervals, total_intervals;
+static EMACS_INT total_free_intervals, total_intervals;
 
 /* List of free intervals.  */
 
 static INTERVAL interval_free_list;
 
-/* Total number of interval blocks now in use.  */
-
-static int n_interval_blocks;
-
 
 /* Initialize interval allocation.  */
 
@@ -1355,7 +1353,6 @@
   interval_block = NULL;
   interval_block_index = INTERVAL_BLOCK_SIZE;
   interval_free_list = 0;
-  n_interval_blocks = 0;
 }
 
 
@@ -1387,7 +1384,6 @@
          newi->next = interval_block;
          interval_block = newi;
          interval_block_index = 0;
-         n_interval_blocks++;
        }
       val = &interval_block->intervals[interval_block_index++];
     }
@@ -1580,10 +1576,9 @@
 
 static struct sblock *large_sblocks;
 
-/* List of string_block structures, and how many there are.  */
+/* List of string_block structures.  */
 
 static struct string_block *string_blocks;
-static int n_string_blocks;
 
 /* Free-list of Lisp_Strings.  */
 
@@ -1591,7 +1586,7 @@
 
 /* Number of live and free Lisp_Strings.  */
 
-static int total_strings, total_free_strings;
+static EMACS_INT total_strings, total_free_strings;
 
 /* Number of bytes used by live strings.  */
 
@@ -1659,6 +1654,18 @@
 
 #define GC_STRING_EXTRA (GC_STRING_OVERRUN_COOKIE_SIZE)
 
+/* Exact bound on the number of bytes in a string, not counting the
+   terminating null.  A string cannot contain more bytes than
+   STRING_BYTES_BOUND, nor can it be so long that the size_t
+   arithmetic in allocate_string_data would overflow while it is
+   calculating a value to be passed to malloc.  */
+#define STRING_BYTES_MAX                                         \
+  min (STRING_BYTES_BOUND,                                       \
+       ((SIZE_MAX - XMALLOC_OVERRUN_CHECK_SIZE - GC_STRING_EXTRA  \
+        - offsetof (struct sblock, first_data)                   \
+        - SDATA_DATA_OFFSET)                                     \
+       & ~(sizeof (EMACS_INT) - 1)))
+
 /* Initialize string allocation.  Called from init_alloc_once.  */
 
 static void
@@ -1667,7 +1674,6 @@
   total_strings = total_free_strings = total_string_size = 0;
   oldest_sblock = current_sblock = large_sblocks = NULL;
   string_blocks = NULL;
-  n_string_blocks = 0;
   string_free_list = NULL;
   empty_unibyte_string = make_pure_string ("", 0, 0, 0);
   empty_multibyte_string = make_pure_string ("", 0, 0, 1);
@@ -1799,7 +1805,6 @@
       memset (b, 0, sizeof *b);
       b->next = string_blocks;
       string_blocks = b;
-      ++n_string_blocks;
 
       for (i = STRING_BLOCK_SIZE - 1; i >= 0; --i)
        {
@@ -1858,6 +1863,9 @@
   struct sblock *b;
   EMACS_INT needed, old_nbytes;
 
+  if (STRING_BYTES_MAX < nbytes)
+    string_overflow ();
+
   /* Determine the number of bytes needed to store NBYTES bytes
      of string data.  */
   needed = SDATA_SIZE (nbytes);
@@ -2025,7 +2033,6 @@
          && total_free_strings > STRING_BLOCK_SIZE)
        {
          lisp_free (b);
-         --n_string_blocks;
          string_free_list = free_list_before;
        }
       else
@@ -2186,9 +2193,9 @@
   EMACS_INT nbytes;
 
   CHECK_NATNUM (length);
-  CHECK_NUMBER (init);
+  CHECK_CHARACTER (init);
 
-  c = XINT (init);
+  c = XFASTINT (init);
   if (ASCII_CHAR_P (c))
     {
       nbytes = XINT (length);
@@ -2229,7 +2236,6 @@
 {
   register Lisp_Object val;
   struct Lisp_Bool_Vector *p;
-  int real_init, i;
   EMACS_INT length_in_chars, length_in_elts;
   int bits_per_value;
 
@@ -2251,9 +2257,7 @@
   p = XBOOL_VECTOR (val);
   p->size = XFASTINT (length);
 
-  real_init = (NILP (init) ? 0 : -1);
-  for (i = 0; i < length_in_chars ; i++)
-    p->data[i] = real_init;
+  memset (p->data, NILP (init) ? 0 : -1, length_in_chars);
 
   /* Clear the extraneous bits in the last byte.  */
   if (XINT (length) != length_in_chars * BOOL_VECTOR_BITS_PER_CHAR)
@@ -2463,10 +2467,6 @@
 
 static int float_block_index;
 
-/* Total number of float blocks now in use.  */
-
-static int n_float_blocks;
-
 /* Free-list of Lisp_Floats.  */
 
 static struct Lisp_Float *float_free_list;
@@ -2480,7 +2480,6 @@
   float_block = NULL;
   float_block_index = FLOAT_BLOCK_SIZE; /* Force alloc of new float_block.   */
   float_free_list = 0;
-  n_float_blocks = 0;
 }
 
 
@@ -2514,7 +2513,6 @@
          memset (new->gcmarkbits, 0, sizeof new->gcmarkbits);
          float_block = new;
          float_block_index = 0;
-         n_float_blocks++;
        }
       XSETFLOAT (val, &float_block->floats[float_block_index]);
       float_block_index++;
@@ -2579,10 +2577,6 @@
 
 static struct Lisp_Cons *cons_free_list;
 
-/* Total number of cons blocks now in use.  */
-
-static int n_cons_blocks;
-
 
 /* Initialize cons allocation.  */
 
@@ -2592,7 +2586,6 @@
   cons_block = NULL;
   cons_block_index = CONS_BLOCK_SIZE; /* Force alloc of new cons_block.  */
   cons_free_list = 0;
-  n_cons_blocks = 0;
 }
 
 
@@ -2636,7 +2629,6 @@
          new->next = cons_block;
          cons_block = new;
          cons_block_index = 0;
-         n_cons_blocks++;
        }
       XSETCONS (val, &cons_block->conses[cons_block_index]);
       cons_block_index++;
@@ -2705,7 +2697,7 @@
        doc: /* Return a newly created list with specified arguments as 
elements.
 Any number of arguments, even zero arguments, are allowed.
 usage: (list &rest OBJECTS)  */)
-  (size_t nargs, register Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   register Lisp_Object val;
   val = Qnil;
@@ -2775,10 +2767,12 @@
 
 static struct Lisp_Vector *all_vectors;
 
-/* Total number of vector-like objects now in use.  */
-
-static int n_vectors;
-
+/* Handy constants for vectorlike objects.  */
+enum
+  {
+    header_size = offsetof (struct Lisp_Vector, contents),
+    word_size = sizeof (Lisp_Object)
+  };
 
 /* Value is a pointer to a newly allocated Lisp_Vector structure
    with room for LEN Lisp_Objects.  */
@@ -2788,11 +2782,6 @@
 {
   struct Lisp_Vector *p;
   size_t nbytes;
-  int header_size = offsetof (struct Lisp_Vector, contents);
-  int word_size = sizeof p->contents[0];
-
-  if ((SIZE_MAX - header_size) / word_size < len)
-    memory_full (SIZE_MAX);
 
   MALLOC_BLOCK_INPUT;
 
@@ -2822,18 +2811,22 @@
 
   MALLOC_UNBLOCK_INPUT;
 
-  ++n_vectors;
   return p;
 }
 
 
-/* Allocate a vector with NSLOTS slots.  */
+/* Allocate a vector with LEN slots.  */
 
 struct Lisp_Vector *
-allocate_vector (EMACS_INT nslots)
+allocate_vector (EMACS_INT len)
 {
-  struct Lisp_Vector *v = allocate_vectorlike (nslots);
-  v->header.size = nslots;
+  struct Lisp_Vector *v;
+  ptrdiff_t nbytes_max = min (PTRDIFF_MAX, SIZE_MAX);
+
+  if (min ((nbytes_max - header_size) / word_size, MOST_POSITIVE_FIXNUM) < len)
+    memory_full (SIZE_MAX);
+  v = allocate_vectorlike (len);
+  v->header.size = len;
   return v;
 }
 
@@ -2844,7 +2837,7 @@
 allocate_pseudovector (int memlen, int lisplen, EMACS_INT tag)
 {
   struct Lisp_Vector *v = allocate_vectorlike (memlen);
-  EMACS_INT i;
+  int i;
 
   /* Only the first lisplen slots will be traced normally by the GC.  */
   for (i = 0; i < lisplen; ++i)
@@ -2925,10 +2918,10 @@
        doc: /* Return a newly created vector with specified arguments as 
elements.
 Any number of arguments, even zero arguments, are allowed.
 usage: (vector &rest OBJECTS)  */)
-  (register size_t nargs, Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   register Lisp_Object len, val;
-  register size_t i;
+  ptrdiff_t i;
   register struct Lisp_Vector *p;
 
   XSETFASTINT (len, nargs);
@@ -2956,15 +2949,15 @@
 arguments will not be dynamically bound but will be instead pushed on the
 stack before executing the byte-code.
 usage: (make-byte-code ARGLIST BYTE-CODE CONSTANTS DEPTH &optional DOCSTRING 
INTERACTIVE-SPEC &rest ELEMENTS)  */)
-  (register size_t nargs, Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   register Lisp_Object len, val;
-  register size_t i;
+  ptrdiff_t i;
   register struct Lisp_Vector *p;
 
   XSETFASTINT (len, nargs);
   if (!NILP (Vpurify_flag))
-    val = make_pure_vector ((EMACS_INT) nargs);
+    val = make_pure_vector (nargs);
   else
     val = Fmake_vector (len, Qnil);
 
@@ -3018,10 +3011,6 @@
 
 static struct Lisp_Symbol *symbol_free_list;
 
-/* Total number of symbol blocks now in use.  */
-
-static int n_symbol_blocks;
-
 
 /* Initialize symbol allocation.  */
 
@@ -3031,7 +3020,6 @@
   symbol_block = NULL;
   symbol_block_index = SYMBOL_BLOCK_SIZE;
   symbol_free_list = 0;
-  n_symbol_blocks = 0;
 }
 
 
@@ -3064,7 +3052,6 @@
          new->next = symbol_block;
          symbol_block = new;
          symbol_block_index = 0;
-         n_symbol_blocks++;
        }
       XSETSYMBOL (val, &symbol_block->symbols[symbol_block_index]);
       symbol_block_index++;
@@ -3112,17 +3099,12 @@
 
 static union Lisp_Misc *marker_free_list;
 
-/* Total number of marker blocks now in use.  */
-
-static int n_marker_blocks;
-
 static void
 init_marker (void)
 {
   marker_block = NULL;
   marker_block_index = MARKER_BLOCK_SIZE;
   marker_free_list = 0;
-  n_marker_blocks = 0;
 }
 
 /* Return a newly allocated Lisp_Misc object, with no substructure.  */
@@ -3151,7 +3133,6 @@
          new->next = marker_block;
          marker_block = new;
          marker_block_index = 0;
-         n_marker_blocks++;
          total_free_markers += MARKER_BLOCK_SIZE;
        }
       XSETMISC (val, &marker_block->markers[marker_block_index]);
@@ -3184,7 +3165,7 @@
    The unwind function can get the C values back using XSAVE_VALUE.  */
 
 Lisp_Object
-make_save_value (void *pointer, int integer)
+make_save_value (void *pointer, ptrdiff_t integer)
 {
   register Lisp_Object val;
   register struct Lisp_Save_Value *p;
@@ -3929,11 +3910,11 @@
 
 /* Number of zombie objects.  */
 
-static int nzombies;
+static EMACS_INT nzombies;
 
 /* Number of garbage collections.  */
 
-static int ngcs;
+static EMACS_INT ngcs;
 
 /* Average percentage of zombies per collection.  */
 
@@ -3941,7 +3922,7 @@
 
 /* Max. number of live and zombie objects.  */
 
-static int max_live, max_zombies;
+static EMACS_INT max_live, max_zombies;
 
 /* Average number of live objects per GC.  */
 
@@ -3952,7 +3933,7 @@
   (void)
 {
   Lisp_Object args[8], zombie_list = Qnil;
-  int i;
+  EMACS_INT i;
   for (i = 0; i < nzombies; i++)
     zombie_list = Fcons (zombies[i], zombie_list);
   args[0] = build_string ("%d GCs, avg live/zombies = %.2f/%.2f (%f%%), max 
%d/%d\nzombies: %S");
@@ -4262,7 +4243,7 @@
 check_gcpros (void)
 {
   struct gcpro *p;
-  size_t i;
+  ptrdiff_t i;
 
   for (p = gcprolist; p; p = p->next)
     for (i = 0; i < p->nvars; ++i)
@@ -4279,7 +4260,7 @@
 {
   int i;
 
-  fprintf (stderr, "\nZombies kept alive = %d:\n", nzombies);
+  fprintf (stderr, "\nZombies kept alive = %"pI":\n", nzombies);
   for (i = 0; i < min (MAX_ZOMBIES, nzombies); ++i)
     {
       fprintf (stderr, "  %d = ", i);
@@ -4851,9 +4832,8 @@
 inhibit_garbage_collection (void)
 {
   int count = SPECPDL_INDEX ();
-  int nbits = min (VALBITS, BITS_PER_INT);
 
-  specbind (Qgc_cons_threshold, make_number (((EMACS_INT) 1 << (nbits - 1)) - 
1));
+  specbind (Qgc_cons_threshold, make_number (MOST_POSITIVE_FIXNUM));
   return count;
 }
 
@@ -4873,7 +4853,7 @@
 {
   register struct specbinding *bind;
   char stack_top_variable;
-  register size_t i;
+  ptrdiff_t i;
   int message_p;
   Lisp_Object total[8];
   int count = SPECPDL_INDEX ();
@@ -5103,9 +5083,10 @@
   if (gc_cons_threshold < 10000)
     gc_cons_threshold = 10000;
 
+  gc_relative_threshold = 0;
   if (FLOATP (Vgc_cons_percentage))
     { /* Set gc_cons_combined_threshold.  */
-      EMACS_INT tot = 0;
+      double tot = 0;
 
       tot += total_conses  * sizeof (struct Lisp_Cons);
       tot += total_symbols * sizeof (struct Lisp_Symbol);
@@ -5116,10 +5097,15 @@
       tot += total_intervals * sizeof (struct interval);
       tot += total_strings * sizeof (struct Lisp_String);
 
-      gc_relative_threshold = tot * XFLOAT_DATA (Vgc_cons_percentage);
+      tot *= XFLOAT_DATA (Vgc_cons_percentage);
+      if (0 < tot)
+       {
+         if (tot < TYPE_MAXIMUM (EMACS_INT))
+           gc_relative_threshold = tot;
+         else
+           gc_relative_threshold = TYPE_MAXIMUM (EMACS_INT);
+       }
     }
-  else
-    gc_relative_threshold = 0;
 
   if (garbage_collection_messages)
     {
@@ -5250,8 +5236,8 @@
 static void
 mark_vectorlike (struct Lisp_Vector *ptr)
 {
-  register EMACS_UINT size = ptr->header.size;
-  register EMACS_UINT i;
+  EMACS_INT size = ptr->header.size;
+  EMACS_INT i;
 
   eassert (!VECTOR_MARKED_P (ptr));
   VECTOR_MARK (ptr);           /* Else mark it */
@@ -5273,8 +5259,8 @@
 static void
 mark_char_table (struct Lisp_Vector *ptr)
 {
-  register EMACS_UINT size = ptr->header.size & PSEUDOVECTOR_SIZE_MASK;
-  register EMACS_UINT i;
+  int size = ptr->header.size & PSEUDOVECTOR_SIZE_MASK;
+  int i;
 
   eassert (!VECTOR_MARKED_P (ptr));
   VECTOR_MARK (ptr);
@@ -5402,12 +5388,11 @@
           recursion there.  */
        {
          register struct Lisp_Vector *ptr = XVECTOR (obj);
-         register EMACS_UINT size = ptr->header.size;
-         register EMACS_UINT i;
+         int size = ptr->header.size & PSEUDOVECTOR_SIZE_MASK;
+         int i;
 
          CHECK_LIVE (live_vector_p);
          VECTOR_MARK (ptr);    /* Else mark it */
-         size &= PSEUDOVECTOR_SIZE_MASK;
          for (i = 0; i < size; i++) /* and then mark its elements */
            {
              if (i != COMPILED_CONSTANTS)
@@ -5534,7 +5519,7 @@
            if (ptr->dogc)
              {
                Lisp_Object *p = (Lisp_Object *) ptr->pointer;
-               int nelt;
+               ptrdiff_t nelt;
                for (nelt = ptr->integer; nelt > 0; nelt--, p++)
                  mark_maybe_object (*p);
              }
@@ -5734,7 +5719,7 @@
     register struct cons_block *cblk;
     struct cons_block **cprev = &cons_block;
     register int lim = cons_block_index;
-    register int num_free = 0, num_used = 0;
+    EMACS_INT num_free = 0, num_used = 0;
 
     cons_free_list = 0;
 
@@ -5795,7 +5780,6 @@
            /* Unhook from the free list.  */
            cons_free_list = cblk->conses[0].u.chain;
            lisp_align_free (cblk);
-           n_cons_blocks--;
          }
        else
          {
@@ -5812,7 +5796,7 @@
     register struct float_block *fblk;
     struct float_block **fprev = &float_block;
     register int lim = float_block_index;
-    register int num_free = 0, num_used = 0;
+    EMACS_INT num_free = 0, num_used = 0;
 
     float_free_list = 0;
 
@@ -5842,7 +5826,6 @@
            /* Unhook from the free list.  */
            float_free_list = fblk->floats[0].u.chain;
            lisp_align_free (fblk);
-           n_float_blocks--;
          }
        else
          {
@@ -5859,7 +5842,7 @@
     register struct interval_block *iblk;
     struct interval_block **iprev = &interval_block;
     register int lim = interval_block_index;
-    register int num_free = 0, num_used = 0;
+    EMACS_INT num_free = 0, num_used = 0;
 
     interval_free_list = 0;
 
@@ -5892,7 +5875,6 @@
            /* Unhook from the free list.  */
            interval_free_list = INTERVAL_PARENT (&iblk->intervals[0]);
            lisp_free (iblk);
-           n_interval_blocks--;
          }
        else
          {
@@ -5909,7 +5891,7 @@
     register struct symbol_block *sblk;
     struct symbol_block **sprev = &symbol_block;
     register int lim = symbol_block_index;
-    register int num_free = 0, num_used = 0;
+    EMACS_INT num_free = 0, num_used = 0;
 
     symbol_free_list = NULL;
 
@@ -5956,7 +5938,6 @@
            /* Unhook from the free list.  */
            symbol_free_list = sblk->symbols[0].next;
            lisp_free (sblk);
-           n_symbol_blocks--;
          }
        else
          {
@@ -5974,7 +5955,7 @@
     register struct marker_block *mblk;
     struct marker_block **mprev = &marker_block;
     register int lim = marker_block_index;
-    register int num_free = 0, num_used = 0;
+    EMACS_INT num_free = 0, num_used = 0;
 
     marker_free_list = 0;
 
@@ -6013,7 +5994,6 @@
            /* Unhook from the free list.  */
            marker_free_list = mblk->markers[0].u_free.chain;
            lisp_free (mblk);
-           n_marker_blocks--;
          }
        else
          {
@@ -6063,7 +6043,6 @@
            all_vectors = vector->header.next.vector;
          next = vector->header.next.vector;
          lisp_free (vector);
-         n_vectors--;
          vector = next;
 
        }

=== modified file 'src/buffer.c'
--- src/buffer.c        2011-06-11 21:31:32 +0000
+++ src/buffer.c        2011-06-13 08:00:15 +0000
@@ -850,8 +850,8 @@
   (register Lisp_Object name, Lisp_Object ignore)
 {
   register Lisp_Object gentemp, tem;
-  int count;
-  char number[10];
+  EMACS_INT count;
+  char number[INT_BUFSIZE_BOUND (EMACS_INT) + sizeof "<>"];
 
   CHECK_STRING (name);
 
@@ -865,7 +865,7 @@
   count = 1;
   while (1)
     {
-      sprintf (number, "<%d>", ++count);
+      sprintf (number, "<%"pI"d>", ++count);
       gentemp = concat2 (name, build_string (number));
       tem = Fstring_equal (gentemp, ignore);
       if (!NILP (tem))
@@ -1969,7 +1969,7 @@
 /* Advance BYTE_POS up to a character boundary
    and return the adjusted position.  */
 
-static int
+static EMACS_INT
 advance_to_char_boundary (EMACS_INT byte_pos)
 {
   int c;

=== modified file 'src/buffer.h'
--- src/buffer.h        2011-06-10 20:52:30 +0000
+++ src/buffer.h        2011-06-11 05:46:16 +0000
@@ -338,7 +338,7 @@
 
 #define PTR_BYTE_POS(ptr) \
 ((ptr) - (current_buffer)->text->beg                                       \
- - (ptr - (current_buffer)->text->beg <= (unsigned) (GPT_BYTE - BEG_BYTE) ? 0 
: GAP_SIZE) \
+ - (ptr - (current_buffer)->text->beg <= GPT_BYTE - BEG_BYTE ? 0 : GAP_SIZE) \
  + BEG_BYTE)
 
 /* Return character at byte position POS.  */
@@ -397,7 +397,7 @@
 
 #define BUF_PTR_BYTE_POS(buf, ptr)                             \
 ((ptr) - (buf)->text->beg                                      \
- - (ptr - (buf)->text->beg <= (unsigned) (BUF_GPT_BYTE ((buf)) - BEG_BYTE)\
+ - (ptr - (buf)->text->beg <= BUF_GPT_BYTE (buf) - BEG_BYTE    \
     ? 0 : BUF_GAP_SIZE ((buf)))                                        \
  + BEG_BYTE)
 

=== modified file 'src/bytecode.c'
--- src/bytecode.c      2011-06-01 14:19:45 +0000
+++ src/bytecode.c      2011-06-14 20:12:13 +0000
@@ -433,7 +433,7 @@
 
 Lisp_Object
 exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
-               Lisp_Object args_template, int nargs, Lisp_Object *args)
+               Lisp_Object args_template, ptrdiff_t nargs, Lisp_Object *args)
 {
   int count = SPECPDL_INDEX ();
 #ifdef BYTE_CODE_METER
@@ -444,7 +444,7 @@
   /* Lisp_Object v1, v2; */
   Lisp_Object *vectorp;
 #ifdef BYTE_CODE_SAFE
-  int const_length;
+  ptrdiff_t const_length;
   Lisp_Object *stacke;
   int bytestr_length;
 #endif
@@ -464,7 +464,7 @@
 
   CHECK_STRING (bytestr);
   CHECK_VECTOR (vector);
-  CHECK_NUMBER (maxdepth);
+  CHECK_NATNUM (maxdepth);
 
 #ifdef BYTE_CODE_SAFE
   const_length = ASIZE (vector);
@@ -486,6 +486,8 @@
   stack.byte_string = bytestr;
   stack.pc = stack.byte_string_start = SDATA (bytestr);
   stack.constants = vector;
+  if (min (PTRDIFF_MAX, SIZE_MAX) / sizeof (Lisp_Object) < XFASTINT (maxdepth))
+    memory_full (SIZE_MAX);
   top = (Lisp_Object *) alloca (XFASTINT (maxdepth)
                                          * sizeof (Lisp_Object));
 #if BYTE_MAINTAIN_TOP
@@ -502,14 +504,14 @@
 
   if (INTEGERP (args_template))
     {
-      int at = XINT (args_template);
+      ptrdiff_t at = XINT (args_template);
       int rest = at & 128;
       int mandatory = at & 127;
-      int nonrest = at >> 8;
+      ptrdiff_t nonrest = at >> 8;
       eassert (mandatory <= nonrest);
       if (nargs <= nonrest)
        {
-         int i;
+         ptrdiff_t i;
          for (i = 0 ; i < nargs; i++, args++)
            PUSH (*args);
          if (nargs < mandatory)
@@ -528,7 +530,7 @@
        }
       else if (rest)
        {
-         int i;
+         ptrdiff_t i;
          for (i = 0 ; i < nonrest; i++, args++)
            PUSH (*args);
          PUSH (Flist (nargs - nonrest, args));

=== modified file 'src/callint.c'
--- src/callint.c       2011-05-12 07:07:06 +0000
+++ src/callint.c       2011-06-14 18:57:19 +0000
@@ -269,10 +269,9 @@
   /* If varies[i] > 0, the i'th argument shouldn't just have its value
      in this call quoted in the command history.  It should be
      recorded as a call to the function named callint_argfuns[varies[i]].  */
-  int *varies;
+  signed char *varies;
 
-  register size_t i;
-  size_t nargs;
+  ptrdiff_t i, nargs;
   int foo;
   char prompt1[100];
   char *tem1;
@@ -339,7 +338,7 @@
     {
       Lisp_Object input;
       Lisp_Object funval = Findirect_function (function, Qt);
-      i = num_input_events;
+      size_t events = num_input_events;
       input = specs;
       /* Compute the arg values using the user's expression.  */
       GCPRO2 (input, filter_specs);
@@ -347,7 +346,7 @@
                     CONSP (funval) && EQ (Qclosure, XCAR (funval))
                     ? Qt : Qnil);
       UNGCPRO;
-      if (i != num_input_events || !NILP (record_flag))
+      if (events != num_input_events || !NILP (record_flag))
        {
          /* We should record this command on the command history.  */
          Lisp_Object values;
@@ -465,9 +464,14 @@
        break;
     }
 
+  if (min (MOST_POSITIVE_FIXNUM,
+          min (PTRDIFF_MAX, SIZE_MAX) / sizeof (Lisp_Object))
+      < nargs)
+    memory_full (SIZE_MAX);
+
   args = (Lisp_Object *) alloca (nargs * sizeof (Lisp_Object));
   visargs = (Lisp_Object *) alloca (nargs * sizeof (Lisp_Object));
-  varies = (int *) alloca (nargs * sizeof (int));
+  varies = (signed char *) alloca (nargs);
 
   for (i = 0; i < nargs; i++)
     {

=== modified file 'src/callproc.c'
--- src/callproc.c      2011-05-31 05:12:19 +0000
+++ src/callproc.c      2011-06-14 18:57:19 +0000
@@ -184,7 +184,7 @@
 If you quit, the process is killed with SIGINT, or SIGKILL if you quit again.
 
 usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
-  (size_t nargs, register Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   Lisp_Object infile, buffer, current_dir, path;
   volatile int display_p_volatile;
@@ -231,7 +231,7 @@
   /* Decide the coding-system for giving arguments.  */
   {
     Lisp_Object val, *args2;
-    size_t i;
+    ptrdiff_t i;
 
     /* If arguments are supplied, we may have to encode them.  */
     if (nargs >= 5)
@@ -422,7 +422,7 @@
               (nargs > 4 ? nargs - 2 : 2) * sizeof *new_argv);
   if (nargs > 4)
     {
-      register size_t i;
+      ptrdiff_t i;
       struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
 
       GCPRO5 (infile, buffer, current_dir, path, error_file);
@@ -716,7 +716,7 @@
        {
          if (EQ (coding_systems, Qt))
            {
-             size_t i;
+             ptrdiff_t i;
 
              SAFE_ALLOCA (args2, Lisp_Object *, (nargs + 1) * sizeof *args2);
              args2[0] = Qcall_process;
@@ -944,7 +944,7 @@
 If you quit, the process is killed with SIGINT, or SIGKILL if you quit again.
 
 usage: (call-process-region START END PROGRAM &optional DELETE BUFFER DISPLAY 
&rest ARGS)  */)
-  (size_t nargs, register Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   struct gcpro gcpro1;
   Lisp_Object filename_string;
@@ -953,7 +953,7 @@
   /* Qt denotes we have not yet called Ffind_operation_coding_system.  */
   Lisp_Object coding_systems;
   Lisp_Object val, *args2;
-  size_t i;
+  ptrdiff_t i;
   char *tempfile;
   Lisp_Object tmpdir, pattern;
 

=== modified file 'src/casefiddle.c'
--- src/casefiddle.c    2011-04-14 05:04:02 +0000
+++ src/casefiddle.c    2011-06-12 23:25:12 +0000
@@ -52,7 +52,7 @@
       /* If the character has higher bits set
         above the flags, return it unchanged.
         It is not a real character.  */
-      if ((unsigned) XFASTINT (obj) > (unsigned) flagbits)
+      if (UNSIGNED_CMP (XFASTINT (obj), >, flagbits))
        return obj;
 
       c1 = XFASTINT (obj) & ~flagbits;

=== modified file 'src/ccl.c'
--- src/ccl.c   2011-05-31 06:05:00 +0000
+++ src/ccl.c   2011-06-15 19:40:52 +0000
@@ -745,11 +745,15 @@
 
 #endif
 
+/* Use "&" rather than "&&" to suppress a bogus GCC warning; see
+   <http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43772>.  */
+#define ASCENDING_ORDER(lo, med, hi) (((lo) <= (med)) & ((med) <= (hi)))
+
 #define GET_CCL_RANGE(var, ccl_prog, ic, lo, hi)               \
   do                                                           \
     {                                                          \
       EMACS_INT prog_word = XINT ((ccl_prog)[ic]);             \
-      if (! ((lo) <= prog_word && prog_word <= (hi)))          \
+      if (! ASCENDING_ORDER (lo, prog_word, hi))               \
        CCL_INVALID_CMD;                                        \
       (var) = prog_word;                                       \
     }                                                          \
@@ -761,7 +765,7 @@
 #define GET_CCL_INT(var, ccl_prog, ic)                         \
   GET_CCL_RANGE (var, ccl_prog, ic, INT_MIN, INT_MAX)
 
-#define IN_INT_RANGE(val) (INT_MIN <= (val) && (val) <= INT_MAX)
+#define IN_INT_RANGE(val) ASCENDING_ORDER (INT_MIN, val, INT_MAX)
 
 /* Encode one character CH to multibyte form and write to the current
    output buffer.  If CH is less than 256, CH is written as is.  */

=== modified file 'src/character.c'
--- src/character.c     2011-06-06 19:43:39 +0000
+++ src/character.c     2011-06-14 18:57:19 +0000
@@ -123,7 +123,7 @@
 
   if (c & CHAR_MODIFIER_MASK)
     {
-      c = (unsigned) char_resolve_modifier_mask ((int) c);
+      c = char_resolve_modifier_mask (c);
       /* If C still has any modifier bits, just ignore it.  */
       c &= ~CHAR_MODIFIER_MASK;
     }
@@ -838,7 +838,7 @@
   if (multibyte)
     {
       if ((MOST_POSITIVE_FIXNUM - nchars) / 3 < byte8_count
-         || (STRING_BYTES_MAX - nbytes) / 2 < byte8_count)
+         || (STRING_BYTES_BOUND - nbytes) / 2 < byte8_count)
        string_overflow ();
 
       /* Convert 2-byte sequence of byte8 chars to 4-byte octal.  */
@@ -847,7 +847,7 @@
     }
   else
     {
-      if ((STRING_BYTES_MAX - nchars) / 3 < byte8_count)
+      if ((STRING_BYTES_BOUND - nbytes) / 3 < byte8_count)
        string_overflow ();
 
       /* Convert 1-byte sequence of byte8 chars to 4-byte octal.  */
@@ -893,9 +893,9 @@
        doc: /*
 Concatenate all the argument characters and make the result a string.
 usage: (string &rest CHARACTERS)  */)
-  (size_t n, Lisp_Object *args)
+  (ptrdiff_t n, Lisp_Object *args)
 {
-  size_t i;
+  ptrdiff_t i;
   int c;
   unsigned char *buf, *p;
   Lisp_Object str;
@@ -919,9 +919,9 @@
 DEFUN ("unibyte-string", Funibyte_string, Sunibyte_string, 0, MANY, 0,
        doc: /* Concatenate all the argument bytes and make the result a 
unibyte string.
 usage: (unibyte-string &rest BYTES)  */)
-  (size_t n, Lisp_Object *args)
+  (ptrdiff_t n, Lisp_Object *args)
 {
-  size_t i;
+  ptrdiff_t i;
   int c;
   unsigned char *buf, *p;
   Lisp_Object str;

=== modified file 'src/character.h'
--- src/character.h     2011-06-01 02:49:12 +0000
+++ src/character.h     2011-06-15 18:57:45 +0000
@@ -23,6 +23,8 @@
 #ifndef EMACS_CHARACTER_H
 #define EMACS_CHARACTER_H
 
+#include <verify.h>
+
 /* character code      1st byte   byte sequence
    --------------      --------   -------------
         0-7F           00..7F     0xxxxxxx
@@ -102,13 +104,13 @@
 #define make_char(c) make_number (c)
 
 /* Nonzero iff C is an ASCII byte.  */
-#define ASCII_BYTE_P(c) ((unsigned) (c) < 0x80)
+#define ASCII_BYTE_P(c) UNSIGNED_CMP (c, <, 0x80)
 
 /* Nonzero iff X is a character.  */
 #define CHARACTERP(x) (NATNUMP (x) && XFASTINT (x) <= MAX_CHAR)
 
-/* Nonzero iff C is valid as a character code.  GENERICP is not used.  */
-#define CHAR_VALID_P(c, genericp) ((unsigned) (c) <= MAX_CHAR)
+/* Nonzero iff C is valid as a character code.  */
+#define CHAR_VALID_P(c) UNSIGNED_CMP (c, <=, MAX_CHAR)
 
 /* Check if Lisp object X is a character or not.  */
 #define CHECK_CHARACTER(x) \
@@ -129,7 +131,7 @@
   } while (0)
 
 /* Nonzero iff C is a character of code less than 0x100.  */
-#define SINGLE_BYTE_CHAR_P(c) ((unsigned) (c) < 0x100)
+#define SINGLE_BYTE_CHAR_P(c) UNSIGNED_CMP (c, <, 0x100)
 
 /* Nonzero if character C has a printable glyph.  */
 #define CHAR_PRINTABLE_P(c)    \
@@ -161,19 +163,19 @@
    Returns the length of the multibyte form.  */
 
 #define CHAR_STRING(c, p)                      \
-  ((unsigned) (c) <= MAX_1_BYTE_CHAR           \
+  (UNSIGNED_CMP (c, <=, MAX_1_BYTE_CHAR)       \
    ? ((p)[0] = (c),                            \
       1)                                       \
-   : (unsigned) (c) <= MAX_2_BYTE_CHAR         \
+   : UNSIGNED_CMP (c, <=, MAX_2_BYTE_CHAR)     \
    ? ((p)[0] = (0xC0 | ((c) >> 6)),            \
       (p)[1] = (0x80 | ((c) & 0x3F)),          \
       2)                                       \
-   : (unsigned) (c) <= MAX_3_BYTE_CHAR         \
+   : UNSIGNED_CMP (c, <=, MAX_3_BYTE_CHAR)     \
    ? ((p)[0] = (0xE0 | ((c) >> 12)),           \
       (p)[1] = (0x80 | (((c) >> 6) & 0x3F)),   \
       (p)[2] = (0x80 | ((c) & 0x3F)),          \
       3)                                       \
-   : char_string ((unsigned) c, p))
+   : verify_expr (sizeof (c) <= sizeof (unsigned), char_string (c, p)))
 
 /* Store multibyte form of byte B in P.  The caller should allocate at
    least MAX_MULTIBYTE_LENGTH bytes area at P in advance.  Returns the
@@ -201,7 +203,10 @@
        *(p)++ = (0x80 | (((c) >> 6) & 0x3F)),  \
        *(p)++ = (0x80 | ((c) & 0x3F));         \
     else                                       \
-      (p) += char_string ((c), (p));           \
+      {                                                \
+       verify (sizeof (c) <= sizeof (unsigned));       \
+       (p) += char_string (c, p);              \
+      }                                                \
   } while (0)
 
 

=== modified file 'src/charset.c'
--- src/charset.c       2011-06-06 19:43:39 +0000
+++ src/charset.c       2011-06-14 18:57:19 +0000
@@ -844,7 +844,7 @@
        Sdefine_charset_internal, charset_arg_max, MANY, 0,
        doc: /* For internal use only.
 usage: (define-charset-internal ...)  */)
-  (size_t nargs, Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   /* Charset attr vector.  */
   Lisp_Object attrs;
@@ -1862,14 +1862,15 @@
 code-point in CCS.  Currently not supported and just ignored.  */)
   (Lisp_Object ch, Lisp_Object charset, Lisp_Object restriction)
 {
-  int id;
+  int c, id;
   unsigned code;
   struct charset *charsetp;
 
   CHECK_CHARSET_GET_ID (charset, id);
-  CHECK_NATNUM (ch);
+  CHECK_CHARACTER (ch);
+  c = XFASTINT (ch);
   charsetp = CHARSET_FROM_ID (id);
-  code = ENCODE_CHAR (charsetp, XINT (ch));
+  code = ENCODE_CHAR (charsetp, c);
   if (code == CHARSET_INVALID_CODE (charsetp))
     return Qnil;
   return INTEGER_TO_CONS (code);
@@ -2144,11 +2145,11 @@
        1, MANY, 0,
        doc: /* Assign higher priority to the charsets given as arguments.
 usage: (set-charset-priority &rest charsets)  */)
-  (size_t nargs, Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   Lisp_Object new_head, old_list, arglist[2];
   Lisp_Object list_2022, list_emacs_mule;
-  size_t i;
+  ptrdiff_t i;
   int id;
 
   old_list = Fcopy_sequence (Vcharset_ordered_list);

=== modified file 'src/charset.h'
--- src/charset.h       2011-05-31 06:05:00 +0000
+++ src/charset.h       2011-06-15 18:57:45 +0000
@@ -27,6 +27,8 @@
 #ifndef EMACS_CHARSET_H
 #define EMACS_CHARSET_H
 
+#include <verify.h>
+
 /* Index to arguments of Fdefine_charset_internal.  */
 
 enum define_charset_arg_index
@@ -424,28 +426,30 @@
 /* Return a code point of CHAR in CHARSET.
    Try some optimization before calling encode_char.  */
 
-#define ENCODE_CHAR(charset, c)                                                
 \
-  ((ASCII_CHAR_P (c) && (charset)->ascii_compatible_p)                  \
-   ? (c)                                                                \
-   : ((charset)->unified_p                                              \
-      || (charset)->method == CHARSET_METHOD_SUBSET                     \
-      || (charset)->method == CHARSET_METHOD_SUPERSET)                  \
-   ? encode_char ((charset), (c))                                       \
-   : ((c) < (charset)->min_char || (c) > (charset)->max_char)           \
-   ? (charset)->invalid_code                                            \
-   : (charset)->method == CHARSET_METHOD_OFFSET                                
 \
-   ? ((charset)->code_linear_p                                          \
-      ? (c) - (charset)->code_offset + (charset)->min_code              \
-      : encode_char ((charset), (c)))                                   \
-   : (charset)->method == CHARSET_METHOD_MAP                            \
-   ? (((charset)->compact_codes_p                                       \
-       && CHAR_TABLE_P (CHARSET_ENCODER (charset)))                     \
-      ? (charset_work = CHAR_TABLE_REF (CHARSET_ENCODER (charset), (c)), \
-        (NILP (charset_work)                                            \
-         ? (charset)->invalid_code                                      \
-         : XFASTINT (charset_work)))                                    \
-      : encode_char ((charset), (c)))                                   \
-   : encode_char ((charset), (c)))
+#define ENCODE_CHAR(charset, c)                                                
\
+  (verify_expr                                                         \
+   (sizeof (c) <= sizeof (int),                                                
\
+    (ASCII_CHAR_P (c) && (charset)->ascii_compatible_p                 \
+     ? (c)                                                             \
+     : ((charset)->unified_p                                           \
+       || (charset)->method == CHARSET_METHOD_SUBSET                   \
+       || (charset)->method == CHARSET_METHOD_SUPERSET)                \
+     ? encode_char (charset, c)                                                
\
+     : (c) < (charset)->min_char || (c) > (charset)->max_char          \
+     ? (charset)->invalid_code                                         \
+     : (charset)->method == CHARSET_METHOD_OFFSET                      \
+     ? ((charset)->code_linear_p                                       \
+       ? (c) - (charset)->code_offset + (charset)->min_code            \
+       : encode_char (charset, c))                                     \
+     : (charset)->method == CHARSET_METHOD_MAP                         \
+     ? (((charset)->compact_codes_p                                    \
+        && CHAR_TABLE_P (CHARSET_ENCODER (charset)))                   \
+       ? (charset_work = CHAR_TABLE_REF (CHARSET_ENCODER (charset), c), \
+          (NILP (charset_work)                                         \
+           ? (charset)->invalid_code                                   \
+           : XFASTINT (charset_work)))                                 \
+       : encode_char (charset, c))                                     \
+     : encode_char (charset, c))))
 
 
 /* Set to 1 when a charset map is loaded to warn that a buffer text

=== modified file 'src/chartab.c'
--- src/chartab.c       2011-05-12 07:07:06 +0000
+++ src/chartab.c       2011-06-13 01:38:25 +0000
@@ -524,15 +524,15 @@
 
   if (EQ (range, Qnil))
     val = XCHAR_TABLE (char_table)->defalt;
-  else if (INTEGERP (range))
-    val = CHAR_TABLE_REF (char_table, XINT (range));
+  else if (CHARACTERP (range))
+    val = CHAR_TABLE_REF (char_table, XFASTINT (range));
   else if (CONSP (range))
     {
       int from, to;
 
       CHECK_CHARACTER_CAR (range);
       CHECK_CHARACTER_CDR (range);
-      val = char_table_ref_and_range (char_table, XINT (XCAR (range)),
+      val = char_table_ref_and_range (char_table, XFASTINT (XCAR (range)),
                                      &from, &to);
       /* Not yet implemented. */
     }

=== modified file 'src/coding.c'
--- src/coding.c        2011-06-06 19:43:39 +0000
+++ src/coding.c        2011-06-14 18:57:19 +0000
@@ -1071,7 +1071,7 @@
 static void
 coding_alloc_by_realloc (struct coding_system *coding, EMACS_INT bytes)
 {
-  if (STRING_BYTES_MAX - coding->dst_bytes < bytes)
+  if (STRING_BYTES_BOUND - coding->dst_bytes < bytes)
     string_overflow ();
   coding->destination = (unsigned char *) xrealloc (coding->destination,
                                                    coding->dst_bytes + bytes);
@@ -9278,7 +9278,7 @@
 contents of BUFFER instead of reading the file.
 
 usage: (find-operation-coding-system OPERATION ARGUMENTS...)  */)
-  (size_t nargs, Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   Lisp_Object operation, target_idx, target, val;
   register Lisp_Object chain;
@@ -9355,9 +9355,9 @@
 all but the first one are ignored.
 
 usage: (set-coding-system-priority &rest coding-systems)  */)
-  (size_t nargs, Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
-  size_t i, j;
+  ptrdiff_t i, j;
   int changed[coding_category_max];
   enum coding_category priorities[coding_category_max];
 
@@ -9461,7 +9461,7 @@
        Sdefine_coding_system_internal, coding_arg_max, MANY, 0,
        doc: /* For internal use only.
 usage: (define-coding-system-internal ...)  */)
-  (size_t nargs, Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   Lisp_Object name;
   Lisp_Object spec_vec;                /* [ ATTRS ALIASE EOL_TYPE ] */

=== modified file 'src/composite.c'
--- src/composite.c     2011-05-31 06:05:00 +0000
+++ src/composite.c     2011-06-13 01:35:47 +0000
@@ -858,7 +858,7 @@
   for (i = 0; i < len; i++)
     {
       Lisp_Object g = LGSTRING_GLYPH (gstring, i);
-      EMACS_INT c = XINT (AREF (header, i + 1));
+      int c = XFASTINT (AREF (header, i + 1));
 
       if (NILP (g))
        {
@@ -995,7 +995,8 @@
 void
 composition_compute_stop_pos (struct composition_it *cmp_it, EMACS_INT 
charpos, EMACS_INT bytepos, EMACS_INT endpos, Lisp_Object string)
 {
-  EMACS_INT start, end, c;
+  EMACS_INT start, end;
+  int c;
   Lisp_Object prop, val;
   /* This is from forward_to_next_line_start in xdisp.c.  */
   const int MAX_NEWLINE_DISTANCE = 500;

=== modified file 'src/composite.h'
--- src/composite.h     2011-06-06 19:43:39 +0000
+++ src/composite.h     2011-06-12 23:25:12 +0000
@@ -151,7 +151,7 @@
 /* Nonzero if the global reference point GREF and new reference point NREF are
    valid.  */
 #define COMPOSITION_ENCODE_RULE_VALID(gref, nref)      \
-  ((unsigned) (gref) < 12 && (unsigned) (nref) < 12)
+  (UNSIGNED_CMP (gref, <, 12) && UNSIGNED_CMP (nref, <, 12))
 
 /* Return encoded composition rule for the pair of global reference
    point GREF and new reference point NREF.  Arguments must be valid.  */

=== modified file 'src/data.c'
--- src/data.c  2011-06-10 20:05:21 +0000
+++ src/data.c  2011-06-14 18:57:19 +0000
@@ -2148,61 +2148,62 @@
       CHECK_CHARACTER (idx);
       CHAR_TABLE_SET (array, idxval, newelt);
     }
-  else if (STRING_MULTIBYTE (array))
+  else
     {
-      EMACS_INT idxval_byte, prev_bytes, new_bytes, nbytes;
-      unsigned char workbuf[MAX_MULTIBYTE_LENGTH], *p0 = workbuf, *p1;
+      int c;
 
       if (idxval < 0 || idxval >= SCHARS (array))
        args_out_of_range (array, idx);
       CHECK_CHARACTER (newelt);
-
-      nbytes = SBYTES (array);
-
-      idxval_byte = string_char_to_byte (array, idxval);
-      p1 = SDATA (array) + idxval_byte;
-      prev_bytes = BYTES_BY_CHAR_HEAD (*p1);
-      new_bytes = CHAR_STRING (XINT (newelt), p0);
-      if (prev_bytes != new_bytes)
+      c = XFASTINT (newelt);
+
+      if (STRING_MULTIBYTE (array))
        {
-         /* We must relocate the string data.  */
-         EMACS_INT nchars = SCHARS (array);
-         unsigned char *str;
-         USE_SAFE_ALLOCA;
+         EMACS_INT idxval_byte, prev_bytes, new_bytes, nbytes;
+         unsigned char workbuf[MAX_MULTIBYTE_LENGTH], *p0 = workbuf, *p1;
 
-         SAFE_ALLOCA (str, unsigned char *, nbytes);
-         memcpy (str, SDATA (array), nbytes);
-         allocate_string_data (XSTRING (array), nchars,
-                               nbytes + new_bytes - prev_bytes);
-         memcpy (SDATA (array), str, idxval_byte);
+         nbytes = SBYTES (array);
+         idxval_byte = string_char_to_byte (array, idxval);
          p1 = SDATA (array) + idxval_byte;
-         memcpy (p1 + new_bytes, str + idxval_byte + prev_bytes,
-                 nbytes - (idxval_byte + prev_bytes));
-         SAFE_FREE ();
-         clear_string_char_byte_cache ();
+         prev_bytes = BYTES_BY_CHAR_HEAD (*p1);
+         new_bytes = CHAR_STRING (c, p0);
+         if (prev_bytes != new_bytes)
+           {
+             /* We must relocate the string data.  */
+             EMACS_INT nchars = SCHARS (array);
+             unsigned char *str;
+             USE_SAFE_ALLOCA;
+
+             SAFE_ALLOCA (str, unsigned char *, nbytes);
+             memcpy (str, SDATA (array), nbytes);
+             allocate_string_data (XSTRING (array), nchars,
+                                   nbytes + new_bytes - prev_bytes);
+             memcpy (SDATA (array), str, idxval_byte);
+             p1 = SDATA (array) + idxval_byte;
+             memcpy (p1 + new_bytes, str + idxval_byte + prev_bytes,
+                     nbytes - (idxval_byte + prev_bytes));
+             SAFE_FREE ();
+             clear_string_char_byte_cache ();
+           }
+         while (new_bytes--)
+           *p1++ = *p0++;
        }
-      while (new_bytes--)
-       *p1++ = *p0++;
-    }
-  else
-    {
-      if (idxval < 0 || idxval >= SCHARS (array))
-       args_out_of_range (array, idx);
-      CHECK_NUMBER (newelt);
-
-      if (XINT (newelt) >= 0 && ! SINGLE_BYTE_CHAR_P (XINT (newelt)))
+      else
        {
-         int i;
+         if (! SINGLE_BYTE_CHAR_P (c))
+           {
+             int i;
 
-         for (i = SBYTES (array) - 1; i >= 0; i--)
-           if (SREF (array, i) >= 0x80)
-             args_out_of_range (array, newelt);
-         /* ARRAY is an ASCII string.  Convert it to a multibyte
-            string, and try `aset' again.  */
-         STRING_SET_MULTIBYTE (array);
-         return Faset (array, idx, newelt);
+             for (i = SBYTES (array) - 1; i >= 0; i--)
+               if (SREF (array, i) >= 0x80)
+                 args_out_of_range (array, newelt);
+             /* ARRAY is an ASCII string.  Convert it to a multibyte
+                string, and try `aset' again.  */
+             STRING_SET_MULTIBYTE (array);
+             return Faset (array, idx, newelt);
+           }
+         SSET (array, idxval, c);
        }
-      SSET (array, idxval, XINT (newelt));
     }
 
   return newelt;
@@ -2502,18 +2503,18 @@
     Amin
   };
 
-static Lisp_Object float_arith_driver (double, size_t, enum arithop,
-                                       size_t, Lisp_Object *);
+static Lisp_Object float_arith_driver (double, ptrdiff_t, enum arithop,
+                                       ptrdiff_t, Lisp_Object *);
 static Lisp_Object
-arith_driver (enum arithop code, size_t nargs, register Lisp_Object *args)
+arith_driver (enum arithop code, ptrdiff_t nargs, Lisp_Object *args)
 {
   register Lisp_Object val;
-  register size_t argnum;
+  ptrdiff_t argnum;
   register EMACS_INT accum = 0;
   register EMACS_INT next;
 
   int overflow = 0;
-  size_t ok_args;
+  ptrdiff_t ok_args;
   EMACS_INT ok_accum;
 
   switch (SWITCH_ENUM_CAST (code))
@@ -2617,8 +2618,8 @@
 #define isnan(x) ((x) != (x))
 
 static Lisp_Object
-float_arith_driver (double accum, register size_t argnum, enum arithop code,
-                   size_t nargs, register Lisp_Object *args)
+float_arith_driver (double accum, ptrdiff_t argnum, enum arithop code,
+                   ptrdiff_t nargs, Lisp_Object *args)
 {
   register Lisp_Object val;
   double next;
@@ -2680,7 +2681,7 @@
 DEFUN ("+", Fplus, Splus, 0, MANY, 0,
        doc: /* Return sum of any number of arguments, which are numbers or 
markers.
 usage: (+ &rest NUMBERS-OR-MARKERS)  */)
-  (size_t nargs, Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   return arith_driver (Aadd, nargs, args);
 }
@@ -2690,7 +2691,7 @@
 With one arg, negates it.  With more than one arg,
 subtracts all but the first from the first.
 usage: (- &optional NUMBER-OR-MARKER &rest MORE-NUMBERS-OR-MARKERS)  */)
-  (size_t nargs, Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   return arith_driver (Asub, nargs, args);
 }
@@ -2698,7 +2699,7 @@
 DEFUN ("*", Ftimes, Stimes, 0, MANY, 0,
        doc: /* Return product of any number of arguments, which are numbers or 
markers.
 usage: (* &rest NUMBERS-OR-MARKERS)  */)
-  (size_t nargs, Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   return arith_driver (Amult, nargs, args);
 }
@@ -2707,9 +2708,9 @@
        doc: /* Return first argument divided by all the remaining arguments.
 The arguments must be numbers or markers.
 usage: (/ DIVIDEND DIVISOR &rest DIVISORS)  */)
-  (size_t nargs, Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
-  size_t argnum;
+  ptrdiff_t argnum;
   for (argnum = 2; argnum < nargs; argnum++)
     if (FLOATP (args[argnum]))
       return float_arith_driver (0, 0, Adiv, nargs, args);
@@ -2791,7 +2792,7 @@
        doc: /* Return largest of all the arguments (which must be numbers or 
markers).
 The value is always a number; markers are converted to numbers.
 usage: (max NUMBER-OR-MARKER &rest NUMBERS-OR-MARKERS)  */)
-  (size_t nargs, Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   return arith_driver (Amax, nargs, args);
 }
@@ -2800,7 +2801,7 @@
        doc: /* Return smallest of all the arguments (which must be numbers or 
markers).
 The value is always a number; markers are converted to numbers.
 usage: (min NUMBER-OR-MARKER &rest NUMBERS-OR-MARKERS)  */)
-  (size_t nargs, Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   return arith_driver (Amin, nargs, args);
 }
@@ -2809,7 +2810,7 @@
        doc: /* Return bitwise-and of all the arguments.
 Arguments may be integers, or markers converted to integers.
 usage: (logand &rest INTS-OR-MARKERS)  */)
-  (size_t nargs, Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   return arith_driver (Alogand, nargs, args);
 }
@@ -2818,7 +2819,7 @@
        doc: /* Return bitwise-or of all the arguments.
 Arguments may be integers, or markers converted to integers.
 usage: (logior &rest INTS-OR-MARKERS)  */)
-  (size_t nargs, Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   return arith_driver (Alogior, nargs, args);
 }
@@ -2827,7 +2828,7 @@
        doc: /* Return bitwise-exclusive-or of all the arguments.
 Arguments may be integers, or markers converted to integers.
 usage: (logxor &rest INTS-OR-MARKERS)  */)
-  (size_t nargs, Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   return arith_driver (Alogxor, nargs, args);
 }

=== modified file 'src/dbusbind.c'
--- src/dbusbind.c      2011-05-24 07:41:16 +0000
+++ src/dbusbind.c      2011-06-14 18:57:19 +0000
@@ -1078,7 +1078,7 @@
   => "i686"
 
 usage: (dbus-call-method BUS SERVICE PATH INTERFACE METHOD &optional :timeout 
TIMEOUT &rest ARGS)  */)
-  (size_t nargs, register Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   Lisp_Object bus, service, path, interface, method;
   Lisp_Object result;
@@ -1090,7 +1090,7 @@
   DBusError derror;
   unsigned int dtype;
   int timeout = -1;
-  size_t i = 5;
+  ptrdiff_t i = 5;
   char signature[DBUS_MAXIMUM_SIGNATURE_LENGTH];
 
   /* Check parameters.  */
@@ -1143,7 +1143,7 @@
        {
          XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
          XD_DEBUG_VALID_LISP_OBJECT_P (args[i+1]);
-         XD_DEBUG_MESSAGE ("Parameter%lu %s %s", (unsigned long) (i-4),
+         XD_DEBUG_MESSAGE ("Parameter%"pD"d %s %s", i - 4,
                            SDATA (format2 ("%s", args[i], Qnil)),
                            SDATA (format2 ("%s", args[i+1], Qnil)));
          ++i;
@@ -1151,7 +1151,7 @@
       else
        {
          XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
-         XD_DEBUG_MESSAGE ("Parameter%lu %s", (unsigned long) (i-4),
+         XD_DEBUG_MESSAGE ("Parameter%"pD"d %s", i - 4,
                            SDATA (format2 ("%s", args[i], Qnil)));
        }
 
@@ -1260,7 +1260,7 @@
   -| i686
 
 usage: (dbus-call-method-asynchronously BUS SERVICE PATH INTERFACE METHOD 
HANDLER &optional :timeout TIMEOUT &rest ARGS)  */)
-  (size_t nargs, register Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   Lisp_Object bus, service, path, interface, method, handler;
   Lisp_Object result;
@@ -1271,7 +1271,7 @@
   unsigned int dtype;
   dbus_uint32_t serial;
   int timeout = -1;
-  size_t i = 6;
+  ptrdiff_t i = 6;
   char signature[DBUS_MAXIMUM_SIGNATURE_LENGTH];
 
   /* Check parameters.  */
@@ -1326,7 +1326,7 @@
        {
          XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
          XD_DEBUG_VALID_LISP_OBJECT_P (args[i+1]);
-         XD_DEBUG_MESSAGE ("Parameter%lu %s %s", (unsigned long) (i-4),
+         XD_DEBUG_MESSAGE ("Parameter%"pD"d %s %s", i - 4,
                            SDATA (format2 ("%s", args[i], Qnil)),
                            SDATA (format2 ("%s", args[i+1], Qnil)));
          ++i;
@@ -1334,7 +1334,7 @@
       else
        {
          XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
-         XD_DEBUG_MESSAGE ("Parameter%lu %s", (unsigned long) (i - 4),
+         XD_DEBUG_MESSAGE ("Parameter%"pD"d %s", i - 4,
                            SDATA (format2 ("%s", args[i], Qnil)));
        }
 
@@ -1386,7 +1386,7 @@
 This is an internal function, it shall not be used outside dbus.el.
 
 usage: (dbus-method-return-internal BUS SERIAL SERVICE &rest ARGS)  */)
-  (size_t nargs, register Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   Lisp_Object bus, service;
   struct gcpro gcpro1, gcpro2;
@@ -1395,7 +1395,7 @@
   DBusMessageIter iter;
   dbus_uint32_t serial;
   unsigned int ui_serial, dtype;
-  size_t i;
+  ptrdiff_t i;
   char signature[DBUS_MAXIMUM_SIGNATURE_LENGTH];
 
   /* Check parameters.  */
@@ -1435,7 +1435,7 @@
        {
          XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
          XD_DEBUG_VALID_LISP_OBJECT_P (args[i+1]);
-         XD_DEBUG_MESSAGE ("Parameter%lu %s %s", (unsigned long) (i-2),
+         XD_DEBUG_MESSAGE ("Parameter%"pD"d %s %s", i - 2,
                            SDATA (format2 ("%s", args[i], Qnil)),
                            SDATA (format2 ("%s", args[i+1], Qnil)));
          ++i;
@@ -1443,7 +1443,7 @@
       else
        {
          XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
-         XD_DEBUG_MESSAGE ("Parameter%lu %s", (unsigned long) (i-2),
+         XD_DEBUG_MESSAGE ("Parameter%"pD"d %s", i - 2,
                            SDATA (format2 ("%s", args[i], Qnil)));
        }
 
@@ -1475,7 +1475,7 @@
 This is an internal function, it shall not be used outside dbus.el.
 
 usage: (dbus-method-error-internal BUS SERIAL SERVICE &rest ARGS)  */)
-  (size_t nargs, register Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   Lisp_Object bus, service;
   struct gcpro gcpro1, gcpro2;
@@ -1484,7 +1484,7 @@
   DBusMessageIter iter;
   dbus_uint32_t serial;
   unsigned int ui_serial, dtype;
-  size_t i;
+  ptrdiff_t i;
   char signature[DBUS_MAXIMUM_SIGNATURE_LENGTH];
 
   /* Check parameters.  */
@@ -1525,7 +1525,7 @@
        {
          XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
          XD_DEBUG_VALID_LISP_OBJECT_P (args[i+1]);
-         XD_DEBUG_MESSAGE ("Parameter%lu %s %s", (unsigned long) (i-2),
+         XD_DEBUG_MESSAGE ("Parameter%"pD"d %s %s", i - 2,
                            SDATA (format2 ("%s", args[i], Qnil)),
                            SDATA (format2 ("%s", args[i+1], Qnil)));
          ++i;
@@ -1533,7 +1533,7 @@
       else
        {
          XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
-         XD_DEBUG_MESSAGE ("Parameter%lu %s", (unsigned long) (i-2),
+         XD_DEBUG_MESSAGE ("Parameter%"pD"d %s", i - 2,
                            SDATA (format2 ("%s", args[i], Qnil)));
        }
 
@@ -1588,7 +1588,7 @@
   "org.gnu.Emacs.FileManager" "FileModified" "/home/albinus/.emacs")
 
 usage: (dbus-send-signal BUS SERVICE PATH INTERFACE SIGNAL &rest ARGS)  */)
-  (size_t nargs, register Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   Lisp_Object bus, service, path, interface, signal;
   struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
@@ -1596,7 +1596,7 @@
   DBusMessage *dmessage;
   DBusMessageIter iter;
   unsigned int dtype;
-  size_t i;
+  ptrdiff_t i;
   char signature[DBUS_MAXIMUM_SIGNATURE_LENGTH];
 
   /* Check parameters.  */
@@ -1640,7 +1640,7 @@
        {
          XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
          XD_DEBUG_VALID_LISP_OBJECT_P (args[i+1]);
-         XD_DEBUG_MESSAGE ("Parameter%lu %s %s", (unsigned long) (i-4),
+         XD_DEBUG_MESSAGE ("Parameter%"pD"d %s %s", i - 4,
                            SDATA (format2 ("%s", args[i], Qnil)),
                            SDATA (format2 ("%s", args[i+1], Qnil)));
          ++i;
@@ -1648,7 +1648,7 @@
       else
        {
          XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
-         XD_DEBUG_MESSAGE ("Parameter%lu %s", (unsigned long) (i-4),
+         XD_DEBUG_MESSAGE ("Parameter%"pD"d %s", i - 4,
                            SDATA (format2 ("%s", args[i], Qnil)));
        }
 
@@ -1919,11 +1919,11 @@
   => :already-owner.
 
 usage: (dbus-register-service BUS SERVICE &rest FLAGS)  */)
-  (size_t nargs, register Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   Lisp_Object bus, service;
   DBusConnection *connection;
-  size_t i;
+  ptrdiff_t i;
   unsigned int value;
   unsigned int flags = 0;
   int result;
@@ -2019,13 +2019,13 @@
 `dbus-unregister-object' for removing the registration.
 
 usage: (dbus-register-signal BUS SERVICE PATH INTERFACE SIGNAL HANDLER &rest 
ARGS) */)
-  (size_t nargs, register Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   Lisp_Object bus, service, path, interface, signal, handler;
   struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5, gcpro6;
   Lisp_Object uname, key, key1, value;
   DBusConnection *connection;
-  size_t i;
+  ptrdiff_t i;
   char rule[DBUS_MAXIMUM_MATCH_RULE_LENGTH];
   char x[DBUS_MAXIMUM_MATCH_RULE_LENGTH];
   DBusError derror;
@@ -2095,7 +2095,7 @@
        if (!NILP (args[i]))
          {
            CHECK_STRING (args[i]);
-           sprintf (x, ",arg%lu='%s'", (unsigned long) (i-6),
+           sprintf (x, ",arg%"pD"d='%s'", i - 6,
                     SDATA (args[i]));
            strcat (rule, x);
          }

=== modified file 'src/dired.c'
--- src/dired.c 2011-06-06 19:43:39 +0000
+++ src/dired.c 2011-06-13 06:34:04 +0000
@@ -978,11 +978,14 @@
   values[4] = make_time (s.st_atime);
   values[5] = make_time (s.st_mtime);
   values[6] = make_time (s.st_ctime);
-  values[7] = make_fixnum_or_float (s.st_size);
-  /* If the size is negative, and its type is long, convert it back to
-     positive.  */
-  if (s.st_size < 0 && sizeof (s.st_size) == sizeof (long))
-    values[7] = make_float ((double) ((unsigned long) s.st_size));
+
+  /* If the file size is a 4-byte type, assume that files of sizes in
+     the 2-4 GiB range wrap around to negative values, as this is a
+     common bug on older 32-bit platforms.  */
+  if (sizeof (s.st_size) == 4)
+    values[7] = make_fixnum_or_float (s.st_size & 0xffffffffu);
+  else
+    values[7] = make_fixnum_or_float (s.st_size);
 
   filemodestring (&s, modes);
   values[8] = make_string (modes, 10);

=== modified file 'src/dispextern.h'
--- src/dispextern.h    2011-06-11 01:48:59 +0000
+++ src/dispextern.h    2011-06-13 05:15:27 +0000
@@ -1729,7 +1729,7 @@
    face doesn't exist.  */
 
 #define FACE_FROM_ID(F, ID)                            \
-     (((unsigned) (ID) < FRAME_FACE_CACHE (F)->used)   \
+     (UNSIGNED_CMP (ID, <, FRAME_FACE_CACHE (F)->used) \
       ? FRAME_FACE_CACHE (F)->faces_by_id[ID]          \
       : NULL)
 
@@ -3163,7 +3163,7 @@
                              EMACS_INT pos, EMACS_INT bufpos,
                              EMACS_INT region_beg, EMACS_INT region_end,
                              EMACS_INT *endptr, enum face_id, int mouse);
-int merge_faces (struct frame *, Lisp_Object, int, int);
+int merge_faces (struct frame *, Lisp_Object, EMACS_INT, int);
 int compute_char_face (struct frame *, int, Lisp_Object);
 void free_all_realized_faces (Lisp_Object);
 extern Lisp_Object Qforeground_color, Qbackground_color;

=== modified file 'src/doc.c'
--- src/doc.c   2011-05-12 07:07:06 +0000
+++ src/doc.c   2011-06-13 02:09:34 +0000
@@ -253,9 +253,12 @@
          else if (c == '_')
            *to++ = 037;
          else
-           error ("\
+           {
+             unsigned char uc = c;
+             error ("\
 Invalid data in documentation file -- %c followed by code %03o",
-                  1, (unsigned)c);
+                    1, uc);
+           }
        }
       else
        *to++ = *from++;

=== modified file 'src/doprnt.c'
--- src/doprnt.c        2011-06-06 19:43:39 +0000
+++ src/doprnt.c        2011-06-14 20:09:52 +0000
@@ -118,10 +118,6 @@
    another macro.  */
 #include "character.h"
 
-#ifndef SIZE_MAX
-# define SIZE_MAX ((size_t) -1)
-#endif
-
 #ifndef DBL_MAX_10_EXP
 #define DBL_MAX_10_EXP 308 /* IEEE double */
 #endif
@@ -329,7 +325,7 @@
                minlen = atoi (&fmtcpy[1]);
              string = va_arg (ap, char *);
              tem = strlen (string);
-             if (tem > STRING_BYTES_MAX)
+             if (STRING_BYTES_BOUND < tem)
                error ("String for %%s or %%S format is too long");
              width = strwidth (string, tem);
              goto doit1;
@@ -338,7 +334,7 @@
            doit:
              /* Coming here means STRING contains ASCII only.  */
              tem = strlen (string);
-             if (tem > STRING_BYTES_MAX)
+             if (STRING_BYTES_BOUND < tem)
                error ("Format width or precision too large");
              width = tem;
            doit1:

=== modified file 'src/editfns.c'
--- src/editfns.c       2011-06-06 19:43:39 +0000
+++ src/editfns.c       2011-06-14 18:57:19 +0000
@@ -96,7 +96,7 @@
                                     void (*) (Lisp_Object, EMACS_INT,
                                               EMACS_INT, EMACS_INT,
                                               EMACS_INT, int),
-                                    int, size_t, Lisp_Object *);
+                                    int, ptrdiff_t, Lisp_Object *);
 static Lisp_Object subst_char_in_region_unwind (Lisp_Object);
 static Lisp_Object subst_char_in_region_unwind_1 (Lisp_Object);
 static void transpose_markers (EMACS_INT, EMACS_INT, EMACS_INT, EMACS_INT,
@@ -185,12 +185,13 @@
 usage: (char-to-string CHAR)  */)
   (Lisp_Object character)
 {
-  int len;
+  int c, len;
   unsigned char str[MAX_MULTIBYTE_LENGTH];
 
   CHECK_CHARACTER (character);
+  c = XFASTINT (character);
 
-  len = CHAR_STRING (XFASTINT (character), str);
+  len = CHAR_STRING (c, str);
   return make_string_from_bytes ((char *) str, 1, len);
 }
 
@@ -1857,7 +1858,7 @@
 year values as low as 1901 do work.
 
 usage: (encode-time SECOND MINUTE HOUR DAY MONTH YEAR &optional ZONE)  */)
-  (size_t nargs, register Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   time_t value;
   struct tm tm;
@@ -2193,9 +2194,9 @@
                         void (*insert_from_string_func)
                              (Lisp_Object, EMACS_INT, EMACS_INT,
                               EMACS_INT, EMACS_INT, int),
-                        int inherit, size_t nargs, Lisp_Object *args)
+                        int inherit, ptrdiff_t nargs, Lisp_Object *args)
 {
-  register size_t argnum;
+  ptrdiff_t argnum;
   register Lisp_Object val;
 
   for (argnum = 0; argnum < nargs; argnum++)
@@ -2203,16 +2204,15 @@
       val = args[argnum];
       if (CHARACTERP (val))
        {
+         int c = XFASTINT (val);
          unsigned char str[MAX_MULTIBYTE_LENGTH];
          int len;
 
          if (!NILP (BVAR (current_buffer, enable_multibyte_characters)))
-           len = CHAR_STRING (XFASTINT (val), str);
+           len = CHAR_STRING (c, str);
          else
            {
-             str[0] = (ASCII_CHAR_P (XINT (val))
-                       ? XINT (val)
-                       : multibyte_char_to_unibyte (XINT (val)));
+             str[0] = ASCII_CHAR_P (c) ? c : multibyte_char_to_unibyte (c);
              len = 1;
            }
          (*insert_func) ((char *) str, len);
@@ -2258,7 +2258,7 @@
 and insert the result.
 
 usage: (insert &rest ARGS)  */)
-  (size_t nargs, register Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   general_insert_function (insert, insert_from_string, 0, nargs, args);
   return Qnil;
@@ -2277,7 +2277,7 @@
 to unibyte for insertion.
 
 usage: (insert-and-inherit &rest ARGS)  */)
-  (size_t nargs, register Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   general_insert_function (insert_and_inherit, insert_from_string, 1,
                           nargs, args);
@@ -2294,7 +2294,7 @@
 to unibyte for insertion.
 
 usage: (insert-before-markers &rest ARGS)  */)
-  (size_t nargs, register Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   general_insert_function (insert_before_markers,
                           insert_from_string_before_markers, 0,
@@ -2313,7 +2313,7 @@
 to unibyte for insertion.
 
 usage: (insert-before-markers-and-inherit &rest ARGS)  */)
-  (size_t nargs, register Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   general_insert_function (insert_before_markers_and_inherit,
                           insert_from_string_before_markers, 1,
@@ -2332,16 +2332,17 @@
   register EMACS_INT stringlen;
   register int i;
   register EMACS_INT n;
-  int len;
+  int c, len;
   unsigned char str[MAX_MULTIBYTE_LENGTH];
 
-  CHECK_NUMBER (character);
+  CHECK_CHARACTER (character);
   CHECK_NUMBER (count);
+  c = XFASTINT (character);
 
   if (!NILP (BVAR (current_buffer, enable_multibyte_characters)))
-    len = CHAR_STRING (XFASTINT (character), str);
+    len = CHAR_STRING (c, str);
   else
-    str[0] = XFASTINT (character), len = 1;
+    str[0] = c, len = 1;
   if (BUF_BYTES_MAX / len < XINT (count))
     error ("Maximum buffer size would be exceeded");
   n = XINT (count) * len;
@@ -2784,17 +2785,20 @@
   int maybe_byte_combining = COMBINING_NO;
   EMACS_INT last_changed = 0;
   int multibyte_p = !NILP (BVAR (current_buffer, enable_multibyte_characters));
+  int fromc, toc;
 
  restart:
 
   validate_region (&start, &end);
-  CHECK_NUMBER (fromchar);
-  CHECK_NUMBER (tochar);
+  CHECK_CHARACTER (fromchar);
+  CHECK_CHARACTER (tochar);
+  fromc = XFASTINT (fromchar);
+  toc = XFASTINT (tochar);
 
   if (multibyte_p)
     {
-      len = CHAR_STRING (XFASTINT (fromchar), fromstr);
-      if (CHAR_STRING (XFASTINT (tochar), tostr) != len)
+      len = CHAR_STRING (fromc, fromstr);
+      if (CHAR_STRING (toc, tostr) != len)
        error ("Characters in `subst-char-in-region' have different 
byte-lengths");
       if (!ASCII_BYTE_P (*tostr))
        {
@@ -2811,8 +2815,8 @@
   else
     {
       len = 1;
-      fromstr[0] = XFASTINT (fromchar);
-      tostr[0] = XFASTINT (tochar);
+      fromstr[0] = fromc;
+      tostr[0] = toc;
     }
 
   pos = XINT (start);
@@ -3084,14 +3088,11 @@
            }
          else
            {
-             EMACS_INT c;
-
              nc = oc;
              val = CHAR_TABLE_REF (table, oc);
-             if (CHARACTERP (val)
-                 && (c = XINT (val), CHAR_VALID_P (c, 0)))
+             if (CHARACTERP (val))
                {
-                 nc = c;
+                 nc = XFASTINT (val);
                  str_len = CHAR_STRING (nc, buf);
                  str = buf;
                }
@@ -3385,7 +3386,7 @@
 also `current-message'.
 
 usage: (message FORMAT-STRING &rest ARGS)  */)
-  (size_t nargs, Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   if (NILP (args[0])
       || (STRINGP (args[0])
@@ -3413,7 +3414,7 @@
 message; let the minibuffer contents show.
 
 usage: (message-box FORMAT-STRING &rest ARGS)  */)
-  (size_t nargs, Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   if (NILP (args[0]))
     {
@@ -3470,7 +3471,7 @@
 message; let the minibuffer contents show.
 
 usage: (message-or-box FORMAT-STRING &rest ARGS)  */)
-  (size_t nargs, Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
 #ifdef HAVE_MENUS
   if ((NILP (last_nonmenu_event) || CONSP (last_nonmenu_event))
@@ -3494,11 +3495,11 @@
 Remaining arguments form a sequence of PROPERTY VALUE pairs for text
 properties to add to the result.
 usage: (propertize STRING &rest PROPERTIES)  */)
-  (size_t nargs, Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   Lisp_Object properties, string;
   struct gcpro gcpro1, gcpro2;
-  size_t i;
+  ptrdiff_t i;
 
   /* Number of args must be odd.  */
   if ((nargs & 1) == 0)
@@ -3583,13 +3584,13 @@
 specifier truncates the string to the given width.
 
 usage: (format STRING &rest OBJECTS)  */)
-  (size_t nargs, register Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
-  EMACS_INT n;         /* The number of the next arg to substitute */
+  ptrdiff_t n;         /* The number of the next arg to substitute */
   char initial_buffer[4000];
   char *buf = initial_buffer;
   EMACS_INT bufsize = sizeof initial_buffer;
-  EMACS_INT max_bufsize = STRING_BYTES_MAX + 1;
+  EMACS_INT max_bufsize = STRING_BYTES_BOUND + 1;
   char *p;
   Lisp_Object buf_save_value IF_LINT (= {0});
   register char *format, *end, *format_start;
@@ -3634,7 +3635,7 @@
 
   /* Allocate the info and discarded tables.  */
   {
-    EMACS_INT i;
+    ptrdiff_t i;
     if ((SIZE_MAX - formatlen) / sizeof (struct info) <= nargs)
       memory_full (SIZE_MAX);
     SAFE_ALLOCA (info, struct info *, (nargs + 1) * sizeof *info + formatlen);
@@ -3673,7 +3674,7 @@
   while (format != end)
     {
       /* The values of N and FORMAT when the loop body is entered.  */
-      EMACS_INT n0 = n;
+      ptrdiff_t n0 = n;
       char *format0 = format;
 
       /* Bytes needed to represent the output of this conversion.  */

=== modified file 'src/eval.c'
--- src/eval.c  2011-06-15 18:36:00 +0000
+++ src/eval.c  2011-06-15 18:52:30 +0000
@@ -32,10 +32,6 @@
 #include "xterm.h"
 #endif
 
-#ifndef SIZE_MAX
-# define SIZE_MAX ((size_t) -1)
-#endif
-
 /* This definition is duplicated in alloc.c and keyboard.c.  */
 /* Putting it in lisp.h makes cc bomb out!  */
 
@@ -139,7 +135,7 @@
 
 int handling_signal;
 
-static Lisp_Object funcall_lambda (Lisp_Object, size_t, Lisp_Object *);
+static Lisp_Object funcall_lambda (Lisp_Object, ptrdiff_t, Lisp_Object *);
 static void unwind_to_catch (struct catchtag *, Lisp_Object) NO_RETURN;
 static int interactive_p (int);
 static Lisp_Object apply_lambda (Lisp_Object fun, Lisp_Object args);
@@ -1053,7 +1049,7 @@
   Lisp_Object *temps, tem, lexenv;
   register Lisp_Object elt, varlist;
   int count = SPECPDL_INDEX ();
-  register size_t argnum;
+  ptrdiff_t argnum;
   struct gcpro gcpro1, gcpro2;
   USE_SAFE_ALLOCA;
 
@@ -1609,8 +1605,8 @@
    and ARGS as second argument.  */
 
 Lisp_Object
-internal_condition_case_n (Lisp_Object (*bfun) (size_t, Lisp_Object *),
-                          size_t nargs,
+internal_condition_case_n (Lisp_Object (*bfun) (ptrdiff_t, Lisp_Object *),
+                          ptrdiff_t nargs,
                           Lisp_Object *args,
                           Lisp_Object handlers,
                           Lisp_Object (*hfun) (Lisp_Object))
@@ -1995,7 +1991,7 @@
 {
   char buf[4000];
   size_t size = sizeof buf;
-  size_t size_max = STRING_BYTES_MAX + 1;
+  size_t size_max = STRING_BYTES_BOUND + 1;
   size_t mlen = strlen (m);
   char *buffer = buf;
   size_t used;
@@ -2337,7 +2333,7 @@
        {
          /* Pass a vector of evaluated arguments.  */
          Lisp_Object *vals;
-         register size_t argnum = 0;
+         ptrdiff_t argnum = 0;
          USE_SAFE_ALLOCA;
 
          SAFE_ALLOCA_LISP (vals, XINT (numargs));
@@ -2467,9 +2463,9 @@
 Then return the value FUNCTION returns.
 Thus, (apply '+ 1 2 '(3 4)) returns 10.
 usage: (apply FUNCTION &rest ARGUMENTS)  */)
-  (size_t nargs, Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
-  register size_t i, numargs;
+  ptrdiff_t i, numargs;
   register Lisp_Object spread_arg;
   register Lisp_Object *funcall_args;
   Lisp_Object fun, retval;
@@ -2551,7 +2547,7 @@
 /* Run hook variables in various ways.  */
 
 static Lisp_Object
-funcall_nil (size_t nargs, Lisp_Object *args)
+funcall_nil (ptrdiff_t nargs, Lisp_Object *args)
 {
   Ffuncall (nargs, args);
   return Qnil;
@@ -2572,10 +2568,10 @@
 Do not use `make-local-variable' to make a hook variable buffer-local.
 Instead, use `add-hook' and specify t for the LOCAL argument.
 usage: (run-hooks &rest HOOKS)  */)
-  (size_t nargs, Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   Lisp_Object hook[1];
-  register size_t i;
+  ptrdiff_t i;
 
   for (i = 0; i < nargs; i++)
     {
@@ -2601,7 +2597,7 @@
 Do not use `make-local-variable' to make a hook variable buffer-local.
 Instead, use `add-hook' and specify t for the LOCAL argument.
 usage: (run-hook-with-args HOOK &rest ARGS)  */)
-  (size_t nargs, Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   return run_hook_with_args (nargs, args, funcall_nil);
 }
@@ -2621,13 +2617,13 @@
 Do not use `make-local-variable' to make a hook variable buffer-local.
 Instead, use `add-hook' and specify t for the LOCAL argument.
 usage: (run-hook-with-args-until-success HOOK &rest ARGS)  */)
-  (size_t nargs, Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   return run_hook_with_args (nargs, args, Ffuncall);
 }
 
 static Lisp_Object
-funcall_not (size_t nargs, Lisp_Object *args)
+funcall_not (ptrdiff_t nargs, Lisp_Object *args)
 {
   return NILP (Ffuncall (nargs, args)) ? Qt : Qnil;
 }
@@ -2646,13 +2642,13 @@
 Do not use `make-local-variable' to make a hook variable buffer-local.
 Instead, use `add-hook' and specify t for the LOCAL argument.
 usage: (run-hook-with-args-until-failure HOOK &rest ARGS)  */)
-  (size_t nargs, Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   return NILP (run_hook_with_args (nargs, args, funcall_not)) ? Qt : Qnil;
 }
 
 static Lisp_Object
-run_hook_wrapped_funcall (size_t nargs, Lisp_Object *args)
+run_hook_wrapped_funcall (ptrdiff_t nargs, Lisp_Object *args)
 {
   Lisp_Object tmp = args[0], ret;
   args[0] = args[1];
@@ -2670,7 +2666,7 @@
 As soon as a call to WRAP-FUNCTION returns non-nil, `run-hook-wrapped'
 aborts and returns that value.
 usage: (run-hook-wrapped HOOK WRAP-FUNCTION &rest ARGS)  */)
-     (size_t nargs, Lisp_Object *args)
+     (ptrdiff_t nargs, Lisp_Object *args)
 {
   return run_hook_with_args (nargs, args, run_hook_wrapped_funcall);
 }
@@ -2683,8 +2679,8 @@
    except that it isn't necessary to gcpro ARGS[0].  */
 
 Lisp_Object
-run_hook_with_args (size_t nargs, Lisp_Object *args,
-                   Lisp_Object (*funcall) (size_t nargs, Lisp_Object *args))
+run_hook_with_args (ptrdiff_t nargs, Lisp_Object *args,
+                   Lisp_Object (*funcall) (ptrdiff_t nargs, Lisp_Object *args))
 {
   Lisp_Object sym, val, ret = Qnil;
   struct gcpro gcpro1, gcpro2, gcpro3;
@@ -2957,16 +2953,16 @@
 Return the value that function returns.
 Thus, (funcall 'cons 'x 'y) returns (x . y).
 usage: (funcall FUNCTION &rest ARGUMENTS)  */)
-  (size_t nargs, Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   Lisp_Object fun, original_fun;
   Lisp_Object funcar;
-  size_t numargs = nargs - 1;
+  ptrdiff_t numargs = nargs - 1;
   Lisp_Object lisp_numargs;
   Lisp_Object val;
   struct backtrace backtrace;
   register Lisp_Object *internal_args;
-  register size_t i;
+  ptrdiff_t i;
 
   QUIT;
   if ((consing_since_gc > gc_cons_threshold
@@ -3120,14 +3116,13 @@
 apply_lambda (Lisp_Object fun, Lisp_Object args)
 {
   Lisp_Object args_left;
-  size_t numargs;
+  ptrdiff_t i, numargs;
   register Lisp_Object *arg_vector;
   struct gcpro gcpro1, gcpro2, gcpro3;
-  register size_t i;
   register Lisp_Object tem;
   USE_SAFE_ALLOCA;
 
-  numargs = XINT (Flength (args));
+  numargs = XFASTINT (Flength (args));
   SAFE_ALLOCA_LISP (arg_vector, numargs);
   args_left = args;
 
@@ -3163,12 +3158,12 @@
    FUN must be either a lambda-expression or a compiled-code object.  */
 
 static Lisp_Object
-funcall_lambda (Lisp_Object fun, size_t nargs,
+funcall_lambda (Lisp_Object fun, ptrdiff_t nargs,
                register Lisp_Object *arg_vector)
 {
   Lisp_Object val, syms_left, next, lexenv;
   int count = SPECPDL_INDEX ();
-  size_t i;
+  ptrdiff_t i;
   int optional, rest;
 
   if (CONSP (fun))
@@ -3585,7 +3580,7 @@
            }
          else
            {
-             size_t i;
+             ptrdiff_t i;
              for (i = 0; i < backlist->nargs; i++)
                {
                  if (i) write_string (" ", -1);
@@ -3645,7 +3640,7 @@
 mark_backtrace (void)
 {
   register struct backtrace *backlist;
-  register size_t i;
+  ptrdiff_t i;
 
   for (backlist = backtrace_list; backlist; backlist = backlist->next)
     {

=== modified file 'src/fileio.c'
--- src/fileio.c        2011-06-06 19:43:39 +0000
+++ src/fileio.c        2011-06-15 19:29:18 +0000
@@ -643,7 +643,7 @@
 
   if (!make_temp_name_count_initialized_p)
     {
-      make_temp_name_count = (unsigned) time (NULL);
+      make_temp_name_count = time (NULL);
       make_temp_name_count_initialized_p = 1;
     }
 
@@ -3109,6 +3109,21 @@
   return Qnil;
 }
 
+/* Reposition FD to OFFSET, based on WHENCE.  This acts like lseek
+   except that it also tests for OFFSET being out of lseek's range.  */
+static off_t
+emacs_lseek (int fd, EMACS_INT offset, int whence)
+{
+  /* Use "&" rather than "&&" to suppress a bogus GCC warning; see
+     <http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43772>.  */
+  if (! ((TYPE_MINIMUM (off_t) <= offset) & (offset <= TYPE_MAXIMUM (off_t))))
+    {
+      errno = EINVAL;
+      return -1;
+    }
+  return lseek (fd, offset, whence);
+}
+
 
 DEFUN ("insert-file-contents", Finsert_file_contents, Sinsert_file_contents,
        1, 5, 0,
@@ -3317,7 +3332,7 @@
                  nread = emacs_read (fd, read_buf, 1024);
                  if (nread >= 0)
                    {
-                     if (lseek (fd, st.st_size - (1024 * 3), 0) < 0)
+                     if (lseek (fd, st.st_size - (1024 * 3), SEEK_SET) < 0)
                        report_file_error ("Setting file position",
                                           Fcons (orig_filename, Qnil));
                      nread += emacs_read (fd, read_buf + nread, 1024 * 3);
@@ -3361,7 +3376,7 @@
                  specpdl_ptr--;
 
                  /* Rewind the file for the actual read done later.  */
-                 if (lseek (fd, 0, 0) < 0)
+                 if (lseek (fd, 0, SEEK_SET) < 0)
                    report_file_error ("Setting file position",
                                       Fcons (orig_filename, Qnil));
                }
@@ -3428,7 +3443,7 @@
 
       if (XINT (beg) != 0)
        {
-         if (lseek (fd, XINT (beg), 0) < 0)
+         if (emacs_lseek (fd, XINT (beg), SEEK_SET) < 0)
            report_file_error ("Setting file position",
                               Fcons (orig_filename, Qnil));
        }
@@ -3500,7 +3515,7 @@
            break;
          /* How much can we scan in the next step?  */
          trial = min (curpos, sizeof buffer);
-         if (lseek (fd, curpos - trial, 0) < 0)
+         if (emacs_lseek (fd, curpos - trial, SEEK_SET) < 0)
            report_file_error ("Setting file position",
                               Fcons (orig_filename, Qnil));
 
@@ -3618,7 +3633,7 @@
       /* First read the whole file, performing code conversion into
         CONVERSION_BUFFER.  */
 
-      if (lseek (fd, XINT (beg), 0) < 0)
+      if (emacs_lseek (fd, XINT (beg), SEEK_SET) < 0)
        report_file_error ("Setting file position",
                           Fcons (orig_filename, Qnil));
 
@@ -3817,7 +3832,7 @@
 
   if (XINT (beg) != 0 || !NILP (replace))
     {
-      if (lseek (fd, XINT (beg), 0) < 0)
+      if (emacs_lseek (fd, XINT (beg), SEEK_SET) < 0)
        report_file_error ("Setting file position",
                           Fcons (orig_filename, Qnil));
     }
@@ -4549,9 +4564,9 @@
       long ret;
 
       if (NUMBERP (append))
-       ret = lseek (desc, XINT (append), 1);
+       ret = emacs_lseek (desc, XINT (append), SEEK_CUR);
       else
-       ret = lseek (desc, 0, 2);
+       ret = lseek (desc, 0, SEEK_END);
       if (ret < 0)
        {
 #ifdef CLASH_DETECTION

=== modified file 'src/floatfns.c'
--- src/floatfns.c      2011-05-05 06:31:14 +0000
+++ src/floatfns.c      2011-06-13 02:27:16 +0000
@@ -507,7 +507,7 @@
              if (y & 1)
                acc *= x;
              x *= x;
-             y = (unsigned)y >> 1;
+             y >>= 1;
            }
        }
       XSETINT (val, acc);

=== modified file 'src/fns.c'
--- src/fns.c   2011-06-07 01:39:26 +0000
+++ src/fns.c   2011-06-14 23:18:53 +0000
@@ -99,6 +99,10 @@
   return lispy_val;
 }
 
+/* Heuristic on how many iterations of a tight loop can be safely done
+   before it's time to do a QUIT.  This must be a power of 2.  */
+enum { QUIT_COUNT_HEURISTIC = 1 << 16 };
+
 /* Random data-structure functions */
 
 DEFUN ("length", Flength, Slength, 1, 1, 0,
@@ -110,7 +114,6 @@
   (register Lisp_Object sequence)
 {
   register Lisp_Object val;
-  register int i;
 
   if (STRINGP (sequence))
     XSETFASTINT (val, SCHARS (sequence));
@@ -124,19 +127,20 @@
     XSETFASTINT (val, ASIZE (sequence) & PSEUDOVECTOR_SIZE_MASK);
   else if (CONSP (sequence))
     {
-      i = 0;
-      while (CONSP (sequence))
+      EMACS_INT i = 0;
+
+      do
        {
-         sequence = XCDR (sequence);
-         ++i;
-
-         if (!CONSP (sequence))
-           break;
-
-         sequence = XCDR (sequence);
-         ++i;
-         QUIT;
+         ++i;
+         if ((i & (QUIT_COUNT_HEURISTIC - 1)) == 0)
+           {
+             if (MOST_POSITIVE_FIXNUM < i)
+               error ("List too long");
+             QUIT;
+           }
+         sequence = XCDR (sequence);
        }
+      while (CONSP (sequence));
 
       CHECK_LIST_END (sequence, sequence);
 
@@ -159,22 +163,38 @@
 which is at least the number of distinct elements.  */)
   (Lisp_Object list)
 {
-  Lisp_Object tail, halftail, length;
-  int len = 0;
+  Lisp_Object tail, halftail;
+  double hilen = 0;
+  uintmax_t lolen = 1;
+
+  if (! CONSP (list))
+    return 0;
 
   /* halftail is used to detect circular lists.  */
-  halftail = list;
-  for (tail = list; CONSP (tail); tail = XCDR (tail))
+  for (tail = halftail = list; ; )
     {
-      if (EQ (tail, halftail) && len != 0)
-       break;
-      len++;
-      if ((len & 1) == 0)
-       halftail = XCDR (halftail);
+      tail = XCDR (tail);
+      if (! CONSP (tail))
+       break;
+      if (EQ (tail, halftail))
+       break;
+      lolen++;
+      if ((lolen & 1) == 0)
+       {
+         halftail = XCDR (halftail);
+         if ((lolen & (QUIT_COUNT_HEURISTIC - 1)) == 0)
+           {
+             QUIT;
+             if (lolen == 0)
+               hilen += UINTMAX_MAX + 1.0;
+           }
+       }
     }
 
-  XSETINT (length, len);
-  return length;
+  /* If the length does not fit into a fixnum, return a float.
+     On all known practical machines this returns an upper bound on
+     the true length.  */
+  return hilen ? make_float (hilen + lolen) : make_fixnum_or_float (lolen);
 }
 
 DEFUN ("string-bytes", Fstring_bytes, Sstring_bytes, 1, 1, 0,
@@ -344,7 +364,7 @@
   return i1 < SCHARS (s2) ? Qt : Qnil;
 }
 
-static Lisp_Object concat (size_t nargs, Lisp_Object *args,
+static Lisp_Object concat (ptrdiff_t nargs, Lisp_Object *args,
                           enum Lisp_Type target_type, int last_special);
 
 /* ARGSUSED */
@@ -374,7 +394,7 @@
 Each argument may be a list, vector or string.
 The last argument is not copied, just used as the tail of the new list.
 usage: (append &rest SEQUENCES)  */)
-  (size_t nargs, Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   return concat (nargs, args, Lisp_Cons, 1);
 }
@@ -384,7 +404,7 @@
 The result is a string whose elements are the elements of all the arguments.
 Each argument may be a string or a list or vector of characters (integers).
 usage: (concat &rest SEQUENCES)  */)
-  (size_t nargs, Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   return concat (nargs, args, Lisp_String, 0);
 }
@@ -394,7 +414,7 @@
 The result is a vector whose elements are the elements of all the arguments.
 Each argument may be a list, vector or string.
 usage: (vconcat &rest SEQUENCES)   */)
-  (size_t nargs, Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   return concat (nargs, args, Lisp_Vectorlike, 0);
 }
@@ -416,7 +436,7 @@
   if (BOOL_VECTOR_P (arg))
     {
       Lisp_Object val;
-      int size_in_chars
+      ptrdiff_t size_in_chars
        = ((XBOOL_VECTOR (arg)->size + BOOL_VECTOR_BITS_PER_CHAR - 1)
           / BOOL_VECTOR_BITS_PER_CHAR);
 
@@ -436,13 +456,13 @@
    a string and has text properties to be copied.  */
 struct textprop_rec
 {
-  int argnum;                  /* refer to ARGS (arguments of `concat') */
+  ptrdiff_t argnum;            /* refer to ARGS (arguments of `concat') */
   EMACS_INT from;              /* refer to ARGS[argnum] (argument string) */
   EMACS_INT to;                        /* refer to VAL (the target string) */
 };
 
 static Lisp_Object
-concat (size_t nargs, Lisp_Object *args,
+concat (ptrdiff_t nargs, Lisp_Object *args,
        enum Lisp_Type target_type, int last_special)
 {
   Lisp_Object val;
@@ -452,7 +472,7 @@
   EMACS_INT toindex_byte = 0;
   register EMACS_INT result_len;
   register EMACS_INT result_len_byte;
-  register size_t argnum;
+  ptrdiff_t argnum;
   Lisp_Object last_tail;
   Lisp_Object prev;
   int some_multibyte;
@@ -463,7 +483,7 @@
      here, and copy the text properties after the concatenation.  */
   struct textprop_rec  *textprops = NULL;
   /* Number of elements in textprops.  */
-  int num_textprops = 0;
+  ptrdiff_t num_textprops = 0;
   USE_SAFE_ALLOCA;
 
   tail = Qnil;
@@ -504,6 +524,7 @@
             as well as the number of characters.  */
          EMACS_INT i;
          Lisp_Object ch;
+         int c;
          EMACS_INT this_len_byte;
 
          if (VECTORP (this) || COMPILEDP (this))
@@ -511,9 +532,10 @@
              {
                ch = AREF (this, i);
                CHECK_CHARACTER (ch);
-               this_len_byte = CHAR_BYTES (XINT (ch));
+               c = XFASTINT (ch);
+               this_len_byte = CHAR_BYTES (c);
                result_len_byte += this_len_byte;
-               if (! ASCII_CHAR_P (XINT (ch)) && ! CHAR_BYTE8_P (XINT (ch)))
+               if (! ASCII_CHAR_P (c) && ! CHAR_BYTE8_P (c))
                  some_multibyte = 1;
              }
          else if (BOOL_VECTOR_P (this) && XBOOL_VECTOR (this)->size > 0)
@@ -523,9 +545,10 @@
              {
                ch = XCAR (this);
                CHECK_CHARACTER (ch);
-               this_len_byte = CHAR_BYTES (XINT (ch));
+               c = XFASTINT (ch);
+               this_len_byte = CHAR_BYTES (c);
                result_len_byte += this_len_byte;
-               if (! ASCII_CHAR_P (XINT (ch)) && ! CHAR_BYTE8_P (XINT (ch)))
+               if (! ASCII_CHAR_P (c) && ! CHAR_BYTE8_P (c))
                  some_multibyte = 1;
              }
          else if (STRINGP (this))
@@ -631,23 +654,16 @@
              {
                int c;
                if (STRING_MULTIBYTE (this))
-                 {
-                   FETCH_STRING_CHAR_ADVANCE_NO_CHECK (c, this,
-                                                       thisindex,
-                                                       thisindex_byte);
-                   XSETFASTINT (elt, c);
-                 }
+                 FETCH_STRING_CHAR_ADVANCE_NO_CHECK (c, this,
+                                                     thisindex,
+                                                     thisindex_byte);
                else
                  {
-                   XSETFASTINT (elt, SREF (this, thisindex)); thisindex++;
-                   if (some_multibyte
-                       && !ASCII_CHAR_P (XINT (elt))
-                       && XINT (elt) < 0400)
-                     {
-                       c = BYTE8_TO_CHAR (XINT (elt));
-                       XSETINT (elt, c);
-                     }
+                   c = SREF (this, thisindex); thisindex++;
+                   if (some_multibyte && !ASCII_CHAR_P (c))
+                     c = BYTE8_TO_CHAR (c);
                  }
+               XSETFASTINT (elt, c);
              }
            else if (BOOL_VECTOR_P (this))
              {
@@ -679,12 +695,13 @@
              }
            else
              {
-               CHECK_NUMBER (elt);
+               int c;
+               CHECK_CHARACTER (elt);
+               c = XFASTINT (elt);
                if (some_multibyte)
-                 toindex_byte += CHAR_STRING (XINT (elt),
-                                              SDATA (val) + toindex_byte);
+                 toindex_byte += CHAR_STRING (c, SDATA (val) + toindex_byte);
                else
-                 SSET (val, toindex_byte++, XINT (elt));
+                 SSET (val, toindex_byte++, c);
                toindex++;
              }
          }
@@ -1269,7 +1286,7 @@
        doc: /* Take cdr N times on LIST, return the result.  */)
   (Lisp_Object n, Lisp_Object list)
 {
-  register int i, num;
+  EMACS_INT i, num;
   CHECK_NUMBER (n);
   num = XINT (n);
   for (i = 0; i < num && !NILP (list); i++)
@@ -1734,7 +1751,7 @@
   Lisp_Object front, back;
   register Lisp_Object len, tem;
   struct gcpro gcpro1, gcpro2;
-  register int length;
+  EMACS_INT length;
 
   front = list;
   len = Flength (list);
@@ -2220,9 +2237,9 @@
        doc: /* Concatenate any number of lists by altering them.
 Only the last argument is not altered, and need not be a list.
 usage: (nconc &rest LISTS)  */)
-  (size_t nargs, Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
-  register size_t argnum;
+  ptrdiff_t argnum;
   register Lisp_Object tail, tem, val;
 
   val = tail = Qnil;
@@ -2345,9 +2362,8 @@
 {
   Lisp_Object len;
   register EMACS_INT leni;
-  int nargs;
+  ptrdiff_t i, nargs;
   register Lisp_Object *args;
-  register EMACS_INT i;
   struct gcpro gcpro1;
   Lisp_Object ret;
   USE_SAFE_ALLOCA;
@@ -2526,8 +2542,8 @@
 
   while (loads-- > 0)
     {
-      Lisp_Object load = (NILP (use_floats) ?
-                         make_number ((int) (100.0 * load_ave[loads]))
+      Lisp_Object load = (NILP (use_floats)
+                         ? make_number (100.0 * load_ave[loads])
                          : make_float (load_ave[loads]));
       ret = Fcons (load, ret);
     }
@@ -2751,7 +2767,7 @@
        doc: /* Apply the value of WIDGET's PROPERTY to the widget itself.
 ARGS are passed as extra arguments to the function.
 usage: (widget-apply WIDGET PROPERTY &rest ARGS)  */)
-  (size_t nargs, Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   /* This function can GC. */
   Lisp_Object newargs[3];
@@ -3356,7 +3372,7 @@
 /* Function prototypes.  */
 
 static struct Lisp_Hash_Table *check_hash_table (Lisp_Object);
-static size_t get_key_arg (Lisp_Object, size_t, Lisp_Object *, char *);
+static ptrdiff_t get_key_arg (Lisp_Object, ptrdiff_t, Lisp_Object *, char *);
 static void maybe_resize_hash_table (struct Lisp_Hash_Table *);
 static int sweep_weak_table (struct Lisp_Hash_Table *, int);
 
@@ -3383,13 +3399,9 @@
 EMACS_INT
 next_almost_prime (EMACS_INT n)
 {
-  if (n % 2 == 0)
-    n += 1;
-  if (n % 3 == 0)
-    n += 2;
-  if (n % 7 == 0)
-    n += 4;
-  return n;
+  for (n |= 1; ; n += 2)
+    if (n % 3 != 0 && n % 5 != 0 && n % 7 != 0)
+      return n;
 }
 
 
@@ -3399,10 +3411,10 @@
    0.  This function is used to extract a keyword/argument pair from
    a DEFUN parameter list.  */
 
-static size_t
-get_key_arg (Lisp_Object key, size_t nargs, Lisp_Object *args, char *used)
+static ptrdiff_t
+get_key_arg (Lisp_Object key, ptrdiff_t nargs, Lisp_Object *args, char *used)
 {
-  size_t i;
+  ptrdiff_t i;
 
   for (i = 1; i < nargs; i++)
     if (!used[i - 1] && EQ (args[i - 1], key))
@@ -4300,12 +4312,12 @@
 is nil.
 
 usage: (make-hash-table &rest KEYWORD-ARGS)  */)
-  (size_t nargs, Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   Lisp_Object test, size, rehash_size, rehash_threshold, weak;
   Lisp_Object user_test, user_hash;
   char *used;
-  size_t i;
+  ptrdiff_t i;
 
   /* The vector `used' is used to keep track of arguments that
      have been consumed.  */

=== modified file 'src/font.c'
--- src/font.c  2011-06-06 19:43:39 +0000
+++ src/font.c  2011-06-14 18:57:19 +0000
@@ -3829,10 +3829,10 @@
 language system must contain `mark' feature.
 
 usage: (font-spec ARGS...)  */)
-  (size_t nargs, Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   Lisp_Object spec = font_make_spec ();
-  size_t i;
+  ptrdiff_t i;
 
   for (i = 0; i < nargs; i += 2)
     {

=== modified file 'src/fontset.c'
--- src/fontset.c       2011-06-06 19:43:39 +0000
+++ src/fontset.c       2011-06-13 04:55:03 +0000
@@ -1851,7 +1851,7 @@
       face_id = face_at_buffer_position (w, pos, -1, -1, &dummy,
                                         pos + 100, 0, -1);
     }
-  if (! CHAR_VALID_P (c, 0))
+  if (! CHAR_VALID_P (c))
     return Qnil;
   face_id = FACE_FOR_CHAR (f, FACE_FROM_ID (f, face_id), c, pos, Qnil);
   face = FACE_FROM_ID (f, face_id);

=== modified file 'src/frame.c'
--- src/frame.c 2011-06-12 10:16:46 +0000
+++ src/frame.c 2011-06-14 18:57:19 +0000
@@ -2807,7 +2807,7 @@
   /* Record in these vectors all the parms specified.  */
   Lisp_Object *parms;
   Lisp_Object *values;
-  size_t i, p;
+  ptrdiff_t i, p;
   int left_no_change = 0, top_no_change = 0;
   int icon_left_no_change = 0, icon_top_no_change = 0;
   int size_changed = 0;

=== modified file 'src/keyboard.c'
--- src/keyboard.c      2011-06-06 05:48:28 +0000
+++ src/keyboard.c      2011-06-14 18:57:19 +0000
@@ -448,7 +448,7 @@
 #endif
 static Lisp_Object modify_event_symbol (EMACS_INT, unsigned, Lisp_Object,
                                         Lisp_Object, const char *const *,
-                                        Lisp_Object *, unsigned);
+                                        Lisp_Object *, EMACS_INT);
 static Lisp_Object make_lispy_switch_frame (Lisp_Object);
 static int help_char_p (Lisp_Object);
 static void save_getcjmp (jmp_buf);
@@ -1901,7 +1901,7 @@
 }
 
 static Lisp_Object
-safe_run_hook_funcall (size_t nargs, Lisp_Object *args)
+safe_run_hook_funcall (ptrdiff_t nargs, Lisp_Object *args)
 {
   eassert (nargs == 1);
   if (CONSP (Vinhibit_quit))
@@ -2906,9 +2906,13 @@
        goto exit;
 
       if ((STRINGP (KVAR (current_kboard, Vkeyboard_translate_table))
-          && SCHARS (KVAR (current_kboard, Vkeyboard_translate_table)) > 
(unsigned) XFASTINT (c))
+          && UNSIGNED_CMP (XFASTINT (c), <,
+                           SCHARS (KVAR (current_kboard,
+                                         Vkeyboard_translate_table))))
          || (VECTORP (KVAR (current_kboard, Vkeyboard_translate_table))
-             && ASIZE (KVAR (current_kboard, Vkeyboard_translate_table)) > 
(unsigned) XFASTINT (c))
+             && UNSIGNED_CMP (XFASTINT (c), <,
+                              ASIZE (KVAR (current_kboard,
+                                           Vkeyboard_translate_table))))
          || (CHAR_TABLE_P (KVAR (current_kboard, Vkeyboard_translate_table))
              && CHARACTERP (c)))
        {
@@ -2955,9 +2959,7 @@
      save the echo area contents for it to refer to.  */
   if (INTEGERP (c)
       && ! NILP (Vinput_method_function)
-      && (unsigned) XINT (c) >= ' '
-      && (unsigned) XINT (c) != 127
-      && (unsigned) XINT (c) < 256)
+      && ' ' <= XINT (c) && XINT (c) < 256 && XINT (c) != 127)
     {
       previous_echo_area_message = Fcurrent_message ();
       Vinput_method_previous_message = previous_echo_area_message;
@@ -2982,9 +2984,7 @@
       /* Don't run the input method within a key sequence,
         after the first event of the key sequence.  */
       && NILP (prev_event)
-      && (unsigned) XINT (c) >= ' '
-      && (unsigned) XINT (c) != 127
-      && (unsigned) XINT (c) < 256)
+      && ' ' <= XINT (c) && XINT (c) < 256 && XINT (c) != 127)
     {
       Lisp_Object keys;
       int key_count, key_count_reset;
@@ -5391,7 +5391,7 @@
                                      Qfunction_key,
                                      KVAR (current_kboard, Vsystem_key_alist),
                                      0, &KVAR (current_kboard, 
system_key_syms),
-                                     (unsigned) -1);
+                                     TYPE_MAXIMUM (EMACS_INT));
        }
 
       return modify_event_symbol (event->code - FUNCTION_KEY_OFFSET,
@@ -6410,7 +6410,7 @@
 static Lisp_Object
 modify_event_symbol (EMACS_INT symbol_num, unsigned int modifiers, Lisp_Object 
symbol_kind,
                     Lisp_Object name_alist_or_stem, const char *const 
*name_table,
-                    Lisp_Object *symbol_table, unsigned int table_size)
+                    Lisp_Object *symbol_table, EMACS_INT table_size)
 {
   Lisp_Object value;
   Lisp_Object symbol_int;

=== modified file 'src/lisp.h'
--- src/lisp.h  2011-06-11 21:31:32 +0000
+++ src/lisp.h  2011-06-14 18:57:19 +0000
@@ -60,6 +60,21 @@
 # define EMACS_UINT unsigned EMACS_INT
 #endif
 
+/* Use pD to format ptrdiff_t values, which suffice for indexes into
+   buffers and strings.  Emacs never allocates objects larger than
+   PTRDIFF_MAX bytes, as they cause problems with pointer subtraction.
+   In C99, pD can always be "t"; configure it here for the sake of
+   pre-C99 libraries such as glibc 2.0 and Solaris 8.  */
+#if PTRDIFF_MAX == INT_MAX
+# define pD ""
+#elif PTRDIFF_MAX == LONG_MAX
+# define pD "l"
+#elif PTRDIFF_MAX == LLONG_MAX
+# define pD "ll"
+#else
+# define pD "t"
+#endif
+
 /* Extra internal type checking?  */
 
 #ifdef ENABLE_CHECKING
@@ -765,11 +780,19 @@
 
 #endif /* not GC_CHECK_STRING_BYTES */
 
-/* A string cannot contain more bytes than a fixnum can represent,
-   nor can it be so long that C pointer arithmetic stops working on
-   the string plus a terminating null.  */
-#define STRING_BYTES_MAX  \
-  min (MOST_POSITIVE_FIXNUM, min (SIZE_MAX, PTRDIFF_MAX) - 1)
+/* An upper bound on the number of bytes in a Lisp string, not
+   counting the terminating null.  This a tight enough bound to
+   prevent integer overflow errors that would otherwise occur during
+   string size calculations.  A string cannot contain more bytes than
+   a fixnum can represent, nor can it be so long that C pointer
+   arithmetic stops working on the string plus its terminating null.
+   Although the actual size limit (see STRING_BYTES_MAX in alloc.c)
+   may be a bit smaller than STRING_BYTES_BOUND, calculating it here
+   would expose alloc.c internal details that we'd rather keep
+   private.  The cast to ptrdiff_t ensures that STRING_BYTES_BOUND is
+   signed.  */
+#define STRING_BYTES_BOUND  \
+  min (MOST_POSITIVE_FIXNUM, (ptrdiff_t) min (SIZE_MAX, PTRDIFF_MAX) - 1)
 
 /* Mark STR as a unibyte string.  */
 #define STRING_SET_UNIBYTE(STR)  \
@@ -888,8 +911,18 @@
 
 #endif /* not __GNUC__ */
 
+/* Compute A OP B, using the unsigned comparison operator OP.  A and B
+   should be integer expressions.  This is not the same as
+   mathemeatical comparison; for example, UNSIGNED_CMP (0, <, -1)
+   returns 1.  For efficiency, prefer plain unsigned comparison if A
+   and B's sizes both fit (after integer promotion).  */
+#define UNSIGNED_CMP(a, op, b)                                         \
+  (max (sizeof ((a) + 0), sizeof ((b) + 0)) <= sizeof (unsigned)       \
+   ? ((a) + (unsigned) 0) op ((b) + (unsigned) 0)                      \
+   : ((a) + (uintmax_t) 0) op ((b) + (uintmax_t) 0))
+
 /* Nonzero iff C is an ASCII character.  */
-#define ASCII_CHAR_P(c) ((unsigned) (c) < 0x80)
+#define ASCII_CHAR_P(c) UNSIGNED_CMP (c, <, 0x80)
 
 /* Almost equivalent to Faref (CT, IDX) with optimization for ASCII
    characters.  Do not check validity of CT.  */
@@ -908,8 +941,7 @@
 /* Equivalent to Faset (CT, IDX, VAL) with optimization for ASCII and
    8-bit European characters.  Do not check validity of CT.  */
 #define CHAR_TABLE_SET(CT, IDX, VAL)                                   \
-  (((IDX) >= 0 && ASCII_CHAR_P (IDX)                                   \
-    && SUB_CHAR_TABLE_P (XCHAR_TABLE (CT)->ascii))                     \
+  (ASCII_CHAR_P (IDX) && SUB_CHAR_TABLE_P (XCHAR_TABLE (CT)->ascii)    \
    ? XSUB_CHAR_TABLE (XCHAR_TABLE (CT)->ascii)->contents[IDX] = VAL    \
    : char_table_set (CT, IDX, VAL))
 
@@ -1007,7 +1039,7 @@
       Lisp_Object (*a7) (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, 
Lisp_Object, Lisp_Object, Lisp_Object);
       Lisp_Object (*a8) (Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, 
Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object);
       Lisp_Object (*aUNEVALLED) (Lisp_Object args);
-      Lisp_Object (*aMANY) (size_t, Lisp_Object *);
+      Lisp_Object (*aMANY) (ptrdiff_t, Lisp_Object *);
     } function;
     short min_args, max_args;
     const char *symbol_name;
@@ -1447,7 +1479,7 @@
        area containing INTEGER potential Lisp_Objects.  */
     unsigned int dogc : 1;
     void *pointer;
-    int integer;
+    ptrdiff_t integer;
   };
 
 
@@ -1576,7 +1608,7 @@
 #define SET_GLYPH(glyph, char, face) ((glyph).ch = (char), (glyph).face_id = 
(face))
 
 /* Return 1 if GLYPH contains valid character code.  */
-#define GLYPH_CHAR_VALID_P(glyph) CHAR_VALID_P (GLYPH_CHAR (glyph), 1)
+#define GLYPH_CHAR_VALID_P(glyph) CHAR_VALID_P (GLYPH_CHAR (glyph))
 
 
 /* Glyph Code from a display vector may either be an integer which
@@ -1590,7 +1622,7 @@
   (CONSP (gc) ? XINT (XCDR (gc)) : INTEGERP (gc) ? (XINT (gc) >> 
CHARACTERBITS) : DEFAULT_FACE_ID)
 
 /* Return 1 if glyph code from display vector contains valid character code.  
*/
-#define GLYPH_CODE_CHAR_VALID_P(gc) CHAR_VALID_P (GLYPH_CODE_CHAR (gc), 1)
+#define GLYPH_CODE_CHAR_VALID_P(gc) CHAR_VALID_P (GLYPH_CODE_CHAR (gc))
 
 #define GLYPH_CODE_P(gc) ((CONSP (gc) && INTEGERP (XCAR (gc)) && INTEGERP 
(XCDR (gc))) || INTEGERP (gc))
 
@@ -1864,7 +1896,7 @@
 
 /* Note that the weird token-substitution semantics of ANSI C makes
    this work for MANY and UNEVALLED.  */
-#define DEFUN_ARGS_MANY                (size_t, Lisp_Object *)
+#define DEFUN_ARGS_MANY                (ptrdiff_t, Lisp_Object *)
 #define DEFUN_ARGS_UNEVALLED   (Lisp_Object)
 #define DEFUN_ARGS_0   (void)
 #define DEFUN_ARGS_1   (Lisp_Object)
@@ -2129,7 +2161,7 @@
   volatile Lisp_Object *var;
 
   /* Number of consecutive protected variables.  */
-  size_t nvars;
+  ptrdiff_t nvars;
 
 #ifdef DEBUG_GCPRO
   int level;
@@ -2778,7 +2810,7 @@
 extern Lisp_Object make_float (double);
 extern void display_malloc_warning (void);
 extern int inhibit_garbage_collection (void);
-extern Lisp_Object make_save_value (void *, int);
+extern Lisp_Object make_save_value (void *, ptrdiff_t);
 extern void free_marker (Lisp_Object);
 extern void free_cons (struct Lisp_Cons *);
 extern void init_alloc_once (void);
@@ -2890,9 +2922,9 @@
 EXFUN (Frun_hook_with_args, MANY);
 EXFUN (Frun_hook_with_args_until_failure, MANY);
 extern void run_hook_with_args_2 (Lisp_Object, Lisp_Object, Lisp_Object);
-extern Lisp_Object run_hook_with_args (size_t nargs, Lisp_Object *args,
+extern Lisp_Object run_hook_with_args (ptrdiff_t nargs, Lisp_Object *args,
                                       Lisp_Object (*funcall)
-                                      (size_t nargs, Lisp_Object *args));
+                                      (ptrdiff_t nargs, Lisp_Object *args));
 EXFUN (Fprogn, UNEVALLED);
 EXFUN (Finteractive_p, 0);
 EXFUN (Fthrow, 2) NO_RETURN;
@@ -2924,7 +2956,7 @@
 extern Lisp_Object internal_condition_case (Lisp_Object (*) (void), 
Lisp_Object, Lisp_Object (*) (Lisp_Object));
 extern Lisp_Object internal_condition_case_1 (Lisp_Object (*) (Lisp_Object), 
Lisp_Object, Lisp_Object, Lisp_Object (*) (Lisp_Object));
 extern Lisp_Object internal_condition_case_2 (Lisp_Object (*) (Lisp_Object, 
Lisp_Object), Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object (*) 
(Lisp_Object));
-extern Lisp_Object internal_condition_case_n (Lisp_Object (*) (size_t, 
Lisp_Object *), size_t, Lisp_Object *, Lisp_Object, Lisp_Object (*) 
(Lisp_Object));
+extern Lisp_Object internal_condition_case_n (Lisp_Object (*) (ptrdiff_t, 
Lisp_Object *), ptrdiff_t, Lisp_Object *, Lisp_Object, Lisp_Object (*) 
(Lisp_Object));
 extern void specbind (Lisp_Object, Lisp_Object);
 extern void record_unwind_protect (Lisp_Object (*) (Lisp_Object), Lisp_Object);
 extern Lisp_Object unbind_to (int, Lisp_Object);
@@ -2934,7 +2966,7 @@
 extern void do_autoload (Lisp_Object, Lisp_Object);
 extern Lisp_Object un_autoload (Lisp_Object);
 extern void init_eval_once (void);
-extern Lisp_Object safe_call (size_t, Lisp_Object *);
+extern Lisp_Object safe_call (ptrdiff_t, Lisp_Object *);
 extern Lisp_Object safe_call1 (Lisp_Object, Lisp_Object);
 extern Lisp_Object safe_call2 (Lisp_Object, Lisp_Object, Lisp_Object);
 extern void init_eval (void);
@@ -3316,7 +3348,7 @@
 #endif
 extern void unmark_byte_stack (void);
 extern Lisp_Object exec_byte_code (Lisp_Object, Lisp_Object, Lisp_Object,
-                                  Lisp_Object, int, Lisp_Object *);
+                                  Lisp_Object, ptrdiff_t, Lisp_Object *);
 
 /* Defined in macros.c */
 extern Lisp_Object Qexecute_kbd_macro;
@@ -3671,18 +3703,19 @@
 
 #define SAFE_ALLOCA_LISP(buf, nelt)                      \
   do {                                                   \
-    int size_ = (nelt) * sizeof (Lisp_Object);           \
-    if (size_ < MAX_ALLOCA)                              \
-      buf = (Lisp_Object *) alloca (size_);              \
-    else                                                 \
+    if ((nelt) < MAX_ALLOCA / sizeof (Lisp_Object))      \
+      buf = (Lisp_Object *) alloca ((nelt) * sizeof (Lisp_Object));    \
+    else if ((nelt) < min (PTRDIFF_MAX, SIZE_MAX) / sizeof (Lisp_Object)) \
       {                                                          \
        Lisp_Object arg_;                                 \
-       buf = (Lisp_Object *) xmalloc (size_);            \
+       buf = (Lisp_Object *) xmalloc ((nelt) * sizeof (Lisp_Object));  \
        arg_ = make_save_value (buf, nelt);               \
        XSAVE_VALUE (arg_)->dogc = 1;                     \
        sa_must_free = 1;                                 \
        record_unwind_protect (safe_alloca_unwind, arg_); \
       }                                                          \
+    else                                                 \
+      memory_full (SIZE_MAX);                            \
   } while (0)
 
 

=== modified file 'src/lread.c'
--- src/lread.c 2011-05-12 07:07:06 +0000
+++ src/lread.c 2011-06-13 05:18:27 +0000
@@ -1203,12 +1203,15 @@
 #ifdef DOS_NT
          fmode = "rb";
 #endif /* DOS_NT */
-         stat (SSDATA (efound), &s1);
-         SSET (efound, SBYTES (efound) - 1, 0);
-         result = stat (SSDATA (efound), &s2);
-         SSET (efound, SBYTES (efound) - 1, 'c');
+         result = stat (SSDATA (efound), &s1);
+         if (result == 0)
+           {
+             SSET (efound, SBYTES (efound) - 1, 0);
+             result = stat (SSDATA (efound), &s2);
+             SSET (efound, SBYTES (efound) - 1, 'c');
+           }
 
-         if (result >= 0 && (unsigned) s1.st_mtime < (unsigned) s2.st_mtime)
+         if (result == 0 && s1.st_mtime < s2.st_mtime)
            {
              /* Make the progress messages mention that source is newer.  */
              newer = 1;

=== modified file 'src/mem-limits.h'
--- src/mem-limits.h    2011-05-23 00:22:43 +0000
+++ src/mem-limits.h    2011-06-14 04:49:24 +0000
@@ -33,8 +33,6 @@
 # endif
 #endif
 
-typedef unsigned long SIZE;
-
 extern char *start_of_data (void);
 #if defined USE_LSB_TAG
 #define EXCEEDS_LISP_PTR(ptr) 0

=== modified file 'src/print.c'
--- src/print.c 2011-05-31 06:05:00 +0000
+++ src/print.c 2011-06-08 21:43:46 +0000
@@ -2004,7 +2004,7 @@
 
        case Lisp_Misc_Save_Value:
          strout ("#<save_value ", -1, -1, printcharfun);
-         sprintf(buf, "ptr=%p int=%d",
+         sprintf(buf, "ptr=%p int=%"pD"d",
                  XSAVE_VALUE (obj)->pointer,
                  XSAVE_VALUE (obj)->integer);
          strout (buf, -1, -1, printcharfun);

=== modified file 'src/process.c'
--- src/process.c       2011-06-11 21:31:32 +0000
+++ src/process.c       2011-06-14 18:57:19 +0000
@@ -1272,11 +1272,11 @@
 syntax.
 
 usage: (start-process NAME BUFFER PROGRAM &rest PROGRAM-ARGS)  */)
-  (size_t nargs, register Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   Lisp_Object buffer, name, program, proc, current_dir, tem;
   register unsigned char **new_argv;
-  register size_t i;
+  ptrdiff_t i;
   int count = SPECPDL_INDEX ();
 
   buffer = args[1];
@@ -2436,7 +2436,7 @@
 \(serial-process-configure :port "\\\\.\\COM13" :bytesize 7)
 
 usage: (serial-process-configure &rest ARGS)  */)
-  (size_t nargs, Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   struct Lisp_Process *p;
   Lisp_Object contact = Qnil;
@@ -2554,7 +2554,7 @@
 \(make-serial-process :port "/dev/tty.BlueConsole-SPP-1" :speed nil)
 
 usage:  (make-serial-process &rest ARGS)  */)
-  (size_t nargs, Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   int fd = -1;
   Lisp_Object proc, contact, port;
@@ -2832,7 +2832,7 @@
 information, is available via the `process-contact' function.
 
 usage: (make-network-process &rest ARGS)  */)
-  (size_t nargs, Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   Lisp_Object proc;
   Lisp_Object contact;
@@ -3148,7 +3148,7 @@
 
   for (lres = res; lres; lres = lres->ai_next)
     {
-      size_t optn;
+      ptrdiff_t optn;
       int optbits;
 
 #ifdef WINDOWSNT

=== modified file 'src/puresize.h'
--- src/puresize.h      2011-01-25 04:08:28 +0000
+++ src/puresize.h      2011-06-09 19:08:29 +0000
@@ -86,7 +86,6 @@
   && (PNTR_COMPARISON_TYPE) XPNTR (obj) >= (PNTR_COMPARISON_TYPE) pure)
 
 #else /* not VIRT_ADDR_VARIES */
-/* When PNTR_COMPARISON_TYPE is not the default (unsigned int).  */
 
 extern char my_edata[];
 
@@ -94,4 +93,3 @@
   ((PNTR_COMPARISON_TYPE) XPNTR (obj) < (PNTR_COMPARISON_TYPE) my_edata)
 
 #endif /* VIRT_ADDRESS_VARIES */
-

=== modified file 'src/sound.c'
--- src/sound.c 2011-04-15 08:47:25 +0000
+++ src/sound.c 2011-06-13 06:49:00 +0000
@@ -1447,7 +1447,7 @@
     }
   else if (FLOATP (attrs[SOUND_VOLUME]))
     {
-      ui_volume_tmp = (unsigned long) XFLOAT_DATA (attrs[SOUND_VOLUME]) * 100;
+      ui_volume_tmp = XFLOAT_DATA (attrs[SOUND_VOLUME]) * 100;
     }
   /*
     Based on some experiments I have conducted, a value of 100 or less

=== modified file 'src/unexelf.c'
--- src/unexelf.c       2011-03-30 00:19:27 +0000
+++ src/unexelf.c       2011-06-13 05:55:57 +0000
@@ -391,6 +391,7 @@
 extern void fatal (const char *msgid, ...);
 
 #include <sys/types.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <sys/stat.h>
 #include <memory.h>
@@ -784,7 +785,7 @@
   fprintf (stderr, "new_data2_incr %x\n", new_data2_incr);
 #endif
 
-  if ((unsigned) new_bss_addr < (unsigned) old_bss_addr + old_bss_size)
+  if ((uintptr_t) new_bss_addr < (uintptr_t) old_bss_addr + old_bss_size)
     fatal (".bss shrank when undumping???\n", 0, 0);
 
   /* Set the output file to the right size.  Allocate a buffer to hold

=== modified file 'src/vm-limit.c'
--- src/vm-limit.c      2011-01-25 04:08:28 +0000
+++ src/vm-limit.c      2011-06-14 04:49:24 +0000
@@ -166,9 +166,9 @@
 check_memory_limits (void)
 {
 #ifdef REL_ALLOC
-  extern POINTER (*real_morecore) (SIZE);
+  extern POINTER (*real_morecore) (long);
 #endif
-  extern POINTER (*__morecore) (SIZE);
+  extern POINTER (*__morecore) (long);
 
   register POINTER cp;
   unsigned long five_percent;
@@ -297,4 +297,3 @@
   /* Force data limit to be recalculated on each run.  */
   lim_data = 0;
 }
-

=== modified file 'src/widget.c'
--- src/widget.c        2011-06-11 21:31:32 +0000
+++ src/widget.c        2011-06-13 08:00:15 +0000
@@ -516,14 +516,11 @@
   struct frame *s = ew->emacs_frame.frame;
 
   s->output_data.x->normal_gc
-    = XCreateGC (XtDisplay (ew), RootWindowOfScreen (XtScreen (ew)),
-                (unsigned long)0, (XGCValues *)0);
+    = XCreateGC (XtDisplay (ew), RootWindowOfScreen (XtScreen (ew)), 0, 0);
   s->output_data.x->reverse_gc
-    = XCreateGC (XtDisplay (ew), RootWindowOfScreen (XtScreen (ew)),
-                (unsigned long)0, (XGCValues *)0);
+    = XCreateGC (XtDisplay (ew), RootWindowOfScreen (XtScreen (ew)), 0, 0);
   s->output_data.x->cursor_gc
-    = XCreateGC (XtDisplay (ew), RootWindowOfScreen (XtScreen (ew)),
-                (unsigned long)0, (XGCValues *)0);
+    = XCreateGC (XtDisplay (ew), RootWindowOfScreen (XtScreen (ew)), 0, 0);
   s->output_data.x->black_relief.gc = 0;
   s->output_data.x->white_relief.gc = 0;
 }
@@ -582,8 +579,7 @@
     = XCreatePixmapFromBitmapData (XtDisplay(ew),
                                   RootWindowOfScreen (XtScreen (ew)),
                                   setup_frame_cursor_bits, 2, 2,
-                                  (unsigned long)0, (unsigned long)1,
-                                  ew->core.depth);
+                                  0, 1, ew->core.depth);
 
   /* Normal video */
   gc_values.foreground = ew->emacs_frame.foreground_pixel;

=== modified file 'src/xdisp.c'
--- src/xdisp.c 2011-06-10 06:55:18 +0000
+++ src/xdisp.c 2011-06-14 18:57:19 +0000
@@ -1335,7 +1335,7 @@
   int c;
 
   c = STRING_CHAR_AND_LENGTH (str, *len);
-  if (!CHAR_VALID_P (c, 1))
+  if (!CHAR_VALID_P (c))
     /* We may not change the length here because other places in Emacs
        don't use this function, i.e. they silently accept invalid
        characters.  */
@@ -2138,7 +2138,7 @@
    redisplay during the evaluation.  */
 
 Lisp_Object
-safe_call (size_t nargs, Lisp_Object *args)
+safe_call (ptrdiff_t nargs, Lisp_Object *args)
 {
   Lisp_Object val;
 
@@ -5819,7 +5819,8 @@
                 display.  Then, set IT->dpvec to these glyphs.  */
              Lisp_Object gc;
              int ctl_len;
-             int face_id, lface_id = 0 ;
+             int face_id;
+             EMACS_INT lface_id = 0;
              int escape_glyph;
 
              /* Handle control characters with ^.  */
@@ -6374,7 +6375,7 @@
        it->face_id = it->dpvec_face_id;
       else
        {
-         int lface_id = GLYPH_CODE_FACE (gc);
+         EMACS_INT lface_id = GLYPH_CODE_FACE (gc);
          if (lface_id > 0)
            it->face_id = merge_faces (it->f, Qt, lface_id,
                                       it->saved_face_id);
@@ -16570,7 +16571,7 @@
 DEFUN ("trace-to-stderr", Ftrace_to_stderr, Strace_to_stderr, 1, MANY, "",
        doc: /* Like `format', but print result to stderr.
 usage: (trace-to-stderr STRING &rest OBJECTS)  */)
-  (size_t nargs, Lisp_Object *args)
+  (ptrdiff_t nargs, Lisp_Object *args)
 {
   Lisp_Object s = Fformat (nargs, args);
   fprintf (stderr, "%s", SDATA (s));
@@ -19379,7 +19380,8 @@
       else if (CHARACTERP (eoltype))
        {
          unsigned char *tmp = (unsigned char *) alloca (MAX_MULTIBYTE_LENGTH);
-         eol_str_len = CHAR_STRING (XINT (eoltype), tmp);
+         int c = XFASTINT (eoltype);
+         eol_str_len = CHAR_STRING (c, tmp);
          eol_str = tmp;
        }
       else

=== modified file 'src/xfaces.c'
--- src/xfaces.c        2011-05-28 22:39:39 +0000
+++ src/xfaces.c        2011-06-13 05:15:27 +0000
@@ -6223,7 +6223,8 @@
 */
 
 int
-merge_faces (struct frame *f, Lisp_Object face_name, int face_id, int 
base_face_id)
+merge_faces (struct frame *f, Lisp_Object face_name, EMACS_INT face_id,
+            int base_face_id)
 {
   Lisp_Object attrs[LFACE_VECTOR_SIZE];
   struct face *base_face;

=== modified file 'src/xfns.c'
--- src/xfns.c  2011-06-14 21:08:20 +0000
+++ src/xfns.c  2011-06-15 18:07:38 +0000
@@ -1074,8 +1074,7 @@
   if (FRAME_X_WINDOW (f) != 0 && f->border_width > 0)
     {
       BLOCK_INPUT;
-      XSetWindowBorder (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
-                       (unsigned long)pix);
+      XSetWindowBorder (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), pix);
       UNBLOCK_INPUT;
 
       if (FRAME_VISIBLE_P (f))

=== modified file 'src/xterm.c'
--- src/xterm.c 2011-06-11 21:31:32 +0000
+++ src/xterm.c 2011-06-13 16:08:46 +0000
@@ -1697,16 +1697,18 @@
         a least-squares matching, which is what X uses for closest
         color matching with StaticColor visuals.  */
       int nearest, i;
-      unsigned long nearest_delta = ~ (unsigned long) 0;
+      int max_color_delta = 255;
+      int max_delta = 3 * max_color_delta;
+      int nearest_delta = max_delta + 1;
       int ncells;
       const XColor *cells = x_color_cells (dpy, &ncells);
 
       for (nearest = i = 0; i < ncells; ++i)
        {
-         long dred   = (color->red   >> 8) - (cells[i].red   >> 8);
-         long dgreen = (color->green >> 8) - (cells[i].green >> 8);
-         long dblue  = (color->blue  >> 8) - (cells[i].blue  >> 8);
-         unsigned long delta = dred * dred + dgreen * dgreen + dblue * dblue;
+         int dred   = (color->red   >> 8) - (cells[i].red   >> 8);
+         int dgreen = (color->green >> 8) - (cells[i].green >> 8);
+         int dblue  = (color->blue  >> 8) - (cells[i].blue  >> 8);
+         int delta = dred * dred + dgreen * dgreen + dblue * dblue;
 
          if (delta < nearest_delta)
            {
@@ -6442,8 +6444,7 @@
                            keys".  It seems there's no cleaner way.
                            Test IsModifierKey to avoid handling
                            mode_switch incorrectly.  */
-                        || ((unsigned) (keysym) >= XK_Select
-                            && (unsigned)(keysym) < XK_KP_Space)
+                        || (XK_Select <= keysym && keysym < XK_KP_Space)
 #endif
 #ifdef XK_dead_circumflex
                         || orig_keysym == XK_dead_circumflex
@@ -6496,10 +6497,8 @@
                                 should be treated similarly to
                                 Mode_switch by Emacs. */
 #if defined XK_ISO_Lock && defined XK_ISO_Last_Group_Lock
-                             || ((unsigned)(orig_keysym)
-                                 >=  XK_ISO_Lock
-                                 && (unsigned)(orig_keysym)
-                                 <= XK_ISO_Last_Group_Lock)
+                             || (XK_ISO_Lock <= orig_keysym
+                                && orig_keysym <= XK_ISO_Last_Group_Lock)
 #endif
                              ))
            {
@@ -10275,7 +10274,7 @@
       = XCreatePixmapFromBitmapData (dpyinfo->display, dpyinfo->root_window,
                                     gray_bitmap_bits,
                                     gray_bitmap_width, gray_bitmap_height,
-                                    (unsigned long) 1, (unsigned long) 0, 1);
+                                    1, 0, 1);
   }
 
 #ifdef HAVE_X_I18N

# Begin bundle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reply via email to

[Prev in Thread] Current Thread [Next in Thread]