Fix more problems found by GCC 4.6.0's static checks.

30 files changed, 450 insertions, 354 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 1e77a6439e1..973b7712e53 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,76 @@
+2011-03-30  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Fix more problems found by GCC 4.6.0's static checks.
+
+        * unexelf.c (unexec) [! (defined _SYSTYPE_SYSV || defined __sgi)]:
+        Remove unused local var.
+
+        * editfns.c (Fmessage_box): Remove unused local var.
+
+        * xdisp.c (try_window_reusing_current_matrix, x_produce_glyphs):
+        (note_mode_line_or_margin_highlight, note_mouse_highlight):
+        Omit unused local vars.
+        * window.c (shrink_windows): Omit unused local var.
+        * menu.c (digest_single_submenu): Omit unused local var.
+        * dispnew.c (update_window) [PERIODIC_PREEMPTION_CHECKING]:
+        Omit unused local var.
+
+        * keyboard.c (parse_modifiers_uncached, parse_modifiers):
+        Don't assume string length fits in int.
+        (keyremap_step, read_key_sequence): Use size_t for sizes.
+        (read_key_sequence): Don't check last_real_key_start redundantly.
+
+        * callproc.c (Fcall_process, Fcall_process_region): Use SAFE_ALLOCA
+        instead of alloca (Bug#8344).
+
+        * eval.c (Fbacktrace): Don't assume nargs fits in int.
+        (Fbacktrace_frame): Don't assume nframes fits in int.
+
+        * syntax.c (scan_sexps_forward): Avoid pointer wraparound.
+
+        * xterm.c (x_make_frame_visible, same_x_server): Redo to avoid overflow
+        concerns.
+
+        * term.c (produce_glyphless_glyph): Remove unnecessary test.
+
+        * cm.c (calccost): Turn while-do into do-while, for clarity.
+
+        * keyboard.c (syms_of_keyboard): Use the same style as later
+        in this function when indexing through an array.  This also
+        works around GCC bug 48267.
+
+        * image.c (tiff_load): Fix off-by-one image count (Bug#8336).
+
+        * xselect.c (x_check_property_data): Return correct size (Bug#8335).
+
+        * chartab.c (sub_char_table_ref_and_range): Redo for slight
+        efficiency gain, and to bypass a gcc -Wstrict-overflow warning.
+
+        * keyboard.c, keyboard.h (num_input_events): Now size_t.
+        This avoids undefined behavior on integer overflow, and is a bit
+        more convenient anyway since it is compared to a size_t variable.
+
+        Variadic C functions now count arguments with size_t, not int.
+        This avoids an unnecessary limitation on 64-bit machines, which
+        caused (substring ...) to crash on large vectors (Bug#8344).
+        * lisp.h (struct Lisp_Subr.function.aMANY): Now takes size_t, not int.
+        (DEFUN_ARGS_MANY, internal_condition_case_n, safe_call): Likewise.
+        All variadic functions and their callers changed accordingly.
+        (struct gcpro.nvars): Now size_t, not int.  All uses changed.
+        * data.c (arith_driver, float_arith_driver): Likewise.
+        * editfns.c (general_insert_function): Likewise.
+        * eval.c (struct backtrace.nargs, interactive_p)
+        (internal_condition_case_n, run_hook_with_args, apply_lambda)
+        (funcall_lambda, mark_backtrace): Likewise.
+        * fns.c (concat): Likewise.
+        * frame.c (x_set_frame_parameters): Likewise.
+        * fns.c (get_key_arg): Now accepts and returns size_t, and returns
+        0 if not found, not -1.  All callers changed.
+
+        * alloc.c (garbage_collect): Don't assume stack size fits in int.
+        (stack_copy_size): Now size_t, not int.
+        (stack_copy, stack_copy_size): Define only if MAX_SAVE_STACK > 0.
+
 2011-03-28  Juanma Barranquero  <lekktu@gmail.com>
 
         * coding.c (encode_designation_at_bol): Remove parameter `charbuf_end',
diff --git a/src/alloc.c b/src/alloc.c
index 66695e7a9bc..177a2266fb6 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -254,8 +254,10 @@ const char *pending_malloc_warning;
 
 /* Buffer in which we save a copy of the C stack at each GC.  */
 
+#if MAX_SAVE_STACK > 0
 static char *stack_copy;
-static int stack_copy_size;
+static size_t stack_copy_size;
+#endif
 
 /* Non-zero means ignore malloc warnings.  Set during initialization.
    Currently not used.  */
@@ -2705,7 +2707,7 @@ DEFUN ("list", Flist, Slist, 0, MANY, 0,
        doc: /* Return a newly created list with specified arguments as elements.
 Any number of arguments, even zero arguments, are allowed.
 usage: (list &rest OBJECTS)  */)
-  (int nargs, register Lisp_Object *args)
+  (size_t nargs, register Lisp_Object *args)
 {
   register Lisp_Object val;
   val = Qnil;
@@ -2921,10 +2923,10 @@ DEFUN ("vector", Fvector, Svector, 0, MANY, 0,
        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 int nargs, Lisp_Object *args)
+  (register size_t nargs, Lisp_Object *args)
 {
   register Lisp_Object len, val;
-  register int i;
+  register size_t i;
   register struct Lisp_Vector *p;
 
   XSETFASTINT (len, nargs);
@@ -2943,10 +2945,10 @@ stack size, (optional) doc string, and (optional) interactive spec.
 The first four arguments are required; at most six have any
 significance.
 usage: (make-byte-code ARGLIST BYTE-CODE CONSTANTS DEPTH &optional DOCSTRING INTERACTIVE-SPEC &rest ELEMENTS)  */)
-  (register int nargs, Lisp_Object *args)
+  (register size_t nargs, Lisp_Object *args)
 {
   register Lisp_Object len, val;
-  register int i;
+  register size_t i;
   register struct Lisp_Vector *p;
 
   XSETFASTINT (len, nargs);
@@ -4228,7 +4230,7 @@ static void
 check_gcpros (void)
 {
   struct gcpro *p;
-  int i;
+  size_t i;
 
   for (p = gcprolist; p; p = p->next)
     for (i = 0; i < p->nvars; ++i)
@@ -4837,7 +4839,7 @@ returns nil, because real GC can't be done.  */)
 {
   register struct specbinding *bind;
   char stack_top_variable;
-  register int i;
+  register size_t i;
   int message_p;
   Lisp_Object total[8];
   int count = SPECPDL_INDEX ();
@@ -4903,21 +4905,26 @@ returns nil, because real GC can't be done.  */)
 #if MAX_SAVE_STACK > 0
   if (NILP (Vpurify_flag))
     {
-      i = &stack_top_variable - stack_bottom;
-      if (i < 0) i = -i;
-      if (i < MAX_SAVE_STACK)
+      char *stack;
+      size_t stack_size;
+      if (&stack_top_variable < stack_bottom)
         {
-          if (stack_copy == 0)
-            stack_copy = (char *) xmalloc (stack_copy_size = i);
-          else if (stack_copy_size < i)
-            stack_copy = (char *) xrealloc (stack_copy, (stack_copy_size = i));
-          if (stack_copy)
+          stack = &stack_top_variable;
+          stack_size = stack_bottom - &stack_top_variable;
+        }
+      else
+        {
+          stack = stack_bottom;
+          stack_size = &stack_top_variable - stack_bottom;
+        }
+      if (stack_size <= MAX_SAVE_STACK)
+        {
+          if (stack_copy_size < stack_size)
             {
-              if ((EMACS_INT) (&stack_top_variable - stack_bottom) > 0)
-                memcpy (stack_copy, stack_bottom, i);
-              else
-                memcpy (stack_copy, &stack_top_variable, i);
+              stack_copy = (char *) xrealloc (stack_copy, stack_size);
+              stack_copy_size = stack_size;
             }
+          memcpy (stack_copy, stack, stack_size);
         }
     }
 #endif /* MAX_SAVE_STACK > 0 */
diff --git a/src/callint.c b/src/callint.c
index bb815a5bd01..40d89acd16c 100644
--- a/src/callint.c
+++ b/src/callint.c
@@ -265,8 +265,9 @@ invoke it.  If KEYS is omitted or nil, the return value of
      recorded as a call to the function named callint_argfuns[varies[i]].  */
   int *varies;
 
-  register int i, j;
-  int count, foo;
+  register size_t i, j;
+  size_t count;
+  int foo;
   char prompt1[100];
   char *tem1;
   int arg_from_tty = 0;
diff --git a/src/callproc.c b/src/callproc.c
index 75f239d1be2..eb2a2268fe1 100644
--- a/src/callproc.c
+++ b/src/callproc.c
@@ -177,7 +177,7 @@ and returns a numeric exit status or a signal description string.
 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)  */)
-  (int nargs, register Lisp_Object *args)
+  (size_t nargs, register Lisp_Object *args)
 {
   Lisp_Object infile, buffer, current_dir, path;
   volatile int display_p_volatile;
@@ -189,6 +189,7 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
   char buf[CALLPROC_BUFFER_SIZE_MAX];
   int bufsize = CALLPROC_BUFFER_SIZE_MIN;
   int count = SPECPDL_INDEX ();
+  volatile USE_SAFE_ALLOCA;
 
   const unsigned char **volatile new_argv_volatile;
   register const unsigned char **new_argv;
@@ -221,7 +222,7 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
   /* Decide the coding-system for giving arguments.  */
   {
     Lisp_Object val, *args2;
-    int i;
+    size_t i;
 
     /* If arguments are supplied, we may have to encode them.  */
     if (nargs >= 5)
@@ -242,7 +243,7 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
           val = Qraw_text;
         else
           {
-            args2 = (Lisp_Object *) alloca ((nargs + 1) * sizeof *args2);
+            SAFE_ALLOCA (args2, Lisp_Object *, (nargs + 1) * sizeof *args2);
             args2[0] = Qcall_process;
             for (i = 0; i < nargs; i++) args2[i + 1] = args[i];
             coding_systems = Ffind_operation_coding_system (nargs + 1, args2);
@@ -372,11 +373,12 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
       && SREF (path, 1) == ':')
     path = Fsubstring (path, make_number (2), Qnil);
 
-  new_argv_volatile = new_argv = (const unsigned char **)
-    alloca (max (2, nargs - 2) * sizeof (char *));
+  SAFE_ALLOCA (new_argv, const unsigned char **,
+               (nargs > 4 ? nargs - 2 : 2) * sizeof *new_argv);
+  new_argv_volatile = new_argv;
   if (nargs > 4)
     {
-      register int i;
+      register size_t i;
       struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
 
       GCPRO5 (infile, buffer, current_dir, path, error_file);
@@ -643,9 +645,9 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
         {
           if (EQ (coding_systems, Qt))
             {
-              int i;
+              size_t i;
 
-              args2 = (Lisp_Object *) alloca ((nargs + 1) * sizeof *args2);
+              SAFE_ALLOCA (args2, Lisp_Object *, (nargs + 1) * sizeof *args2);
               args2[0] = Qcall_process;
               for (i = 0; i < nargs; i++) args2[i + 1] = args[i];
               coding_systems
@@ -809,6 +811,7 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
      when exiting.  */
   call_process_exited = 1;
 
+  SAFE_FREE ();
   unbind_to (count, Qnil);
 
   if (synch_process_termsig)
@@ -864,7 +867,7 @@ and returns a numeric exit status or a signal description string.
 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)  */)
-  (int nargs, register Lisp_Object *args)
+  (size_t nargs, register Lisp_Object *args)
 {
   struct gcpro gcpro1;
   Lisp_Object filename_string;
@@ -873,7 +876,7 @@ usage: (call-process-region START END PROGRAM &optional DELETE BUFFER DISPLAY &r
   /* Qt denotes we have not yet called Ffind_operation_coding_system.  */
   Lisp_Object coding_systems;
   Lisp_Object val, *args2;
-  int i;
+  size_t i;
   char *tempfile;
   Lisp_Object tmpdir, pattern;
 
@@ -897,30 +900,35 @@ usage: (call-process-region START END PROGRAM &optional DELETE BUFFER DISPLAY &r
 #endif
     }
 
-  pattern = Fexpand_file_name (Vtemp_file_name_pattern, tmpdir);
-  tempfile = (char *) alloca (SBYTES (pattern) + 1);
-  memcpy (tempfile, SDATA (pattern), SBYTES (pattern) + 1);
-  coding_systems = Qt;
+  {
+    USE_SAFE_ALLOCA;
+    pattern = Fexpand_file_name (Vtemp_file_name_pattern, tmpdir);
+    SAFE_ALLOCA (tempfile, char *, SBYTES (pattern) + 1);
+    memcpy (tempfile, SDATA (pattern), SBYTES (pattern) + 1);
+    coding_systems = Qt;
 
 #ifdef HAVE_MKSTEMP
- {
-   int fd;
-
-   BLOCK_INPUT;
-   fd = mkstemp (tempfile);
-   UNBLOCK_INPUT;
-   if (fd == -1)
-     report_file_error ("Failed to open temporary file",
-                        Fcons (Vtemp_file_name_pattern, Qnil));
-   else
-     close (fd);
- }
+    {
+      int fd;
+
+      BLOCK_INPUT;
+      fd = mkstemp (tempfile);
+      UNBLOCK_INPUT;
+      if (fd == -1)
+        report_file_error ("Failed to open temporary file",
+                           Fcons (Vtemp_file_name_pattern, Qnil));
+      else
+        close (fd);
+    }
 #else
-  mktemp (tempfile);
+    mktemp (tempfile);
 #endif
 
-  filename_string = build_string (tempfile);
-  GCPRO1 (filename_string);
+    filename_string = build_string (tempfile);
+    GCPRO1 (filename_string);
+    SAFE_FREE ();
+  }
+
   start = args[0];
   end = args[1];
   /* Decide coding-system of the contents of the temporary file.  */
@@ -930,11 +938,13 @@ usage: (call-process-region START END PROGRAM &optional DELETE BUFFER DISPLAY &r
     val = Qraw_text;
   else
     {
-      args2 = (Lisp_Object *) alloca ((nargs + 1) * sizeof *args2);
+      USE_SAFE_ALLOCA;
+      SAFE_ALLOCA (args2, Lisp_Object *, (nargs + 1) * sizeof *args2);
       args2[0] = Qcall_process_region;
       for (i = 0; i < nargs; i++) args2[i + 1] = args[i];
       coding_systems = Ffind_operation_coding_system (nargs + 1, args2);
       val = CONSP (coding_systems) ? XCDR (coding_systems) : Qnil;
+      SAFE_FREE ();
     }
   val = complement_process_encoding_system (val);
 
diff --git a/src/character.c b/src/character.c
index 41c692e7483..bac9f6af81e 100644
--- a/src/character.c
+++ b/src/character.c
@@ -890,9 +890,10 @@ DEFUN ("string", Fstring, Sstring, 0, MANY, 0,
        doc: /*
 Concatenate all the argument characters and make the result a string.
 usage: (string &rest CHARACTERS)  */)
-  (int n, Lisp_Object *args)
+  (size_t n, Lisp_Object *args)
 {
-  int i, c;
+  size_t i;
+  int c;
   unsigned char *buf, *p;
   Lisp_Object str;
   USE_SAFE_ALLOCA;
@@ -915,9 +916,10 @@ usage: (string &rest CHARACTERS)  */)
 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)  */)
-  (int n, Lisp_Object *args)
+  (size_t n, Lisp_Object *args)
 {
-  int i, c;
+  size_t i;
+  int c;
   unsigned char *buf, *p;
   Lisp_Object str;
   USE_SAFE_ALLOCA;
diff --git a/src/charset.c b/src/charset.c
index d82b29ae44b..32836d459f3 100644
--- a/src/charset.c
+++ b/src/charset.c
@@ -845,7 +845,7 @@ DEFUN ("define-charset-internal", Fdefine_charset_internal,
        Sdefine_charset_internal, charset_arg_max, MANY, 0,
        doc: /* For internal use only.
 usage: (define-charset-internal ...)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   /* Charset attr vector.  */
   Lisp_Object attrs;
@@ -2171,11 +2171,12 @@ DEFUN ("set-charset-priority", Fset_charset_priority, Sset_charset_priority,
        1, MANY, 0,
        doc: /* Assign higher priority to the charsets given as arguments.
 usage: (set-charset-priority &rest charsets)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   Lisp_Object new_head, old_list, arglist[2];
   Lisp_Object list_2022, list_emacs_mule;
-  int i, id;
+  size_t i;
+  int id;
 
   old_list = Fcopy_sequence (Vcharset_ordered_list);
   new_head = Qnil;
diff --git a/src/chartab.c b/src/chartab.c
index 85aa5932ac3..9ad182131e9 100644
--- a/src/chartab.c
+++ b/src/chartab.c
@@ -215,7 +215,6 @@ sub_char_table_ref_and_range (Lisp_Object table, int c, int *from, int *to, Lisp
   struct Lisp_Sub_Char_Table *tbl = XSUB_CHAR_TABLE (table);
   int depth = XINT (tbl->depth);
   int min_char = XINT (tbl->min_char);
-  int max_char = min_char + chartab_chars[depth - 1] - 1;
   int chartab_idx = CHARTAB_IDX (c, depth, min_char), idx;
   Lisp_Object val;
 
@@ -244,8 +243,9 @@ sub_char_table_ref_and_range (Lisp_Object table, int c, int *from, int *to, Lisp
           break;
         }
     }
-  while ((c = min_char + (chartab_idx + 1) * chartab_chars[depth]) <= max_char
-         && *to >= c)
+  while (((c = (chartab_idx + 1) * chartab_chars[depth])
+          < chartab_chars[depth - 1])
+         && (c += min_char) <= *to)
     {
       Lisp_Object this_val;
 
diff --git a/src/cm.c b/src/cm.c
index 6379955b48c..42f855f1694 100644
--- a/src/cm.c
+++ b/src/cm.c
@@ -214,8 +214,9 @@ calccost (struct tty_display_info *tty,
     }
     totalcost = c * deltay;
     if (doit)
-        while (--deltay >= 0)
+      do
           emacs_tputs (tty, p, 1, cmputc);
+      while (0 < --deltay);
 x:
     if ((deltax = dstx - srcx) == 0)
         goto done;
@@ -296,8 +297,9 @@ fail:
     }
     totalcost += c * deltax;
     if (doit)
-        while (--deltax >= 0)
+      do
           emacs_tputs (tty, p, 1, cmputc);
+      while (0 < --deltax);
 done:
     return totalcost;
 }
diff --git a/src/coding.c b/src/coding.c
index fd812148a26..9e28a1c9f9b 100644
--- a/src/coding.c
+++ b/src/coding.c
@@ -9299,7 +9299,7 @@ function to call for FILENAME, that function should examine the
 contents of BUFFER instead of reading the file.
 
 usage: (find-operation-coding-system OPERATION ARGUMENTS...)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   Lisp_Object operation, target_idx, target, val;
   register Lisp_Object chain;
@@ -9308,17 +9308,17 @@ usage: (find-operation-coding-system OPERATION ARGUMENTS...)  */)
     error ("Too few arguments");
   operation = args[0];
   if (!SYMBOLP (operation)
-      || !INTEGERP (target_idx = Fget (operation, Qtarget_idx)))
+      || !NATNUMP (target_idx = Fget (operation, Qtarget_idx)))
     error ("Invalid first argument");
-  if (nargs < 1 + XINT (target_idx))
+  if (nargs < 1 + XFASTINT (target_idx))
     error ("Too few arguments for operation: %s",
            SDATA (SYMBOL_NAME (operation)));
-  target = args[XINT (target_idx) + 1];
+  target = args[XFASTINT (target_idx) + 1];
   if (!(STRINGP (target)
         || (EQ (operation, Qinsert_file_contents) && CONSP (target)
             && STRINGP (XCAR (target)) && BUFFERP (XCDR (target)))
         || (EQ (operation, Qopen_network_stream) && INTEGERP (target))))
-    error ("Invalid %dth argument", XINT (target_idx) + 1);
+    error ("Invalid %dth argument", XFASTINT (target_idx) + 1);
   if (CONSP (target))
     target = XCAR (target);
 
@@ -9375,9 +9375,9 @@ If multiple coding systems belong to the same category,
 all but the first one are ignored.
 
 usage: (set-coding-system-priority &rest coding-systems)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
-  int i, j;
+  size_t i, j;
   int changed[coding_category_max];
   enum coding_category priorities[coding_category_max];
 
@@ -9420,7 +9420,7 @@ usage: (set-coding-system-priority &rest coding-systems)  */)
 
   /* Update `coding-category-list'.  */
   Vcoding_category_list = Qnil;
-  for (i = coding_category_max - 1; i >= 0; i--)
+  for (i = coding_category_max; i-- > 0; )
     Vcoding_category_list
       = Fcons (AREF (Vcoding_category_table, priorities[i]),
                Vcoding_category_list);
@@ -9481,7 +9481,7 @@ DEFUN ("define-coding-system-internal", Fdefine_coding_system_internal,
        Sdefine_coding_system_internal, coding_arg_max, MANY, 0,
        doc: /* For internal use only.
 usage: (define-coding-system-internal ...)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   Lisp_Object name;
   Lisp_Object spec_vec;         /* [ ATTRS ALIASE EOL_TYPE ] */
diff --git a/src/data.c b/src/data.c
index 36a64d888de..ba7ae58d7b2 100644
--- a/src/data.c
+++ b/src/data.c
@@ -2474,13 +2474,13 @@ enum arithop
     Amin
   };
 
-static Lisp_Object float_arith_driver (double, int, enum arithop,
-                                       int, Lisp_Object *);
+static Lisp_Object float_arith_driver (double, size_t, enum arithop,
+                                       size_t, Lisp_Object *);
 static Lisp_Object
-arith_driver (enum arithop code, int nargs, register Lisp_Object *args)
+arith_driver (enum arithop code, size_t nargs, register Lisp_Object *args)
 {
   register Lisp_Object val;
-  register int argnum;
+  register size_t argnum;
   register EMACS_INT accum = 0;
   register EMACS_INT next;
 
@@ -2562,7 +2562,8 @@ arith_driver (enum arithop code, int nargs, register Lisp_Object *args)
 #define isnan(x) ((x) != (x))
 
 static Lisp_Object
-float_arith_driver (double accum, register int argnum, enum arithop code, int nargs, register Lisp_Object *args)
+float_arith_driver (double accum, register size_t argnum, enum arithop code,
+                    size_t nargs, register Lisp_Object *args)
 {
   register Lisp_Object val;
   double next;
@@ -2624,7 +2625,7 @@ float_arith_driver (double accum, register int argnum, enum arithop code, int na
 DEFUN ("+", Fplus, Splus, 0, MANY, 0,
        doc: /* Return sum of any number of arguments, which are numbers or markers.
 usage: (+ &rest NUMBERS-OR-MARKERS)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   return arith_driver (Aadd, nargs, args);
 }
@@ -2634,7 +2635,7 @@ DEFUN ("-", Fminus, Sminus, 0, MANY, 0,
 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)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   return arith_driver (Asub, nargs, args);
 }
@@ -2642,7 +2643,7 @@ usage: (- &optional NUMBER-OR-MARKER &rest MORE-NUMBERS-OR-MARKERS)  */)
 DEFUN ("*", Ftimes, Stimes, 0, MANY, 0,
        doc: /* Return product of any number of arguments, which are numbers or markers.
 usage: (* &rest NUMBERS-OR-MARKERS)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   return arith_driver (Amult, nargs, args);
 }
@@ -2651,9 +2652,9 @@ DEFUN ("/", Fquo, Squo, 2, MANY, 0,
        doc: /* Return first argument divided by all the remaining arguments.
 The arguments must be numbers or markers.
 usage: (/ DIVIDEND DIVISOR &rest DIVISORS)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
-  int argnum;
+  size_t argnum;
   for (argnum = 2; argnum < nargs; argnum++)
     if (FLOATP (args[argnum]))
       return float_arith_driver (0, 0, Adiv, nargs, args);
@@ -2735,7 +2736,7 @@ DEFUN ("max", Fmax, Smax, 1, MANY, 0,
        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)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   return arith_driver (Amax, nargs, args);
 }
@@ -2744,7 +2745,7 @@ DEFUN ("min", Fmin, Smin, 1, MANY, 0,
        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)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   return arith_driver (Amin, nargs, args);
 }
@@ -2753,7 +2754,7 @@ DEFUN ("logand", Flogand, Slogand, 0, MANY, 0,
        doc: /* Return bitwise-and of all the arguments.
 Arguments may be integers, or markers converted to integers.
 usage: (logand &rest INTS-OR-MARKERS)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   return arith_driver (Alogand, nargs, args);
 }
@@ -2762,7 +2763,7 @@ DEFUN ("logior", Flogior, Slogior, 0, MANY, 0,
        doc: /* Return bitwise-or of all the arguments.
 Arguments may be integers, or markers converted to integers.
 usage: (logior &rest INTS-OR-MARKERS)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   return arith_driver (Alogior, nargs, args);
 }
@@ -2771,7 +2772,7 @@ DEFUN ("logxor", Flogxor, Slogxor, 0, MANY, 0,
        doc: /* Return bitwise-exclusive-or of all the arguments.
 Arguments may be integers, or markers converted to integers.
 usage: (logxor &rest INTS-OR-MARKERS)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   return arith_driver (Alogxor, nargs, args);
 }
diff --git a/src/dbusbind.c b/src/dbusbind.c
index 2c8de20a4d4..8a6870555d0 100644
--- a/src/dbusbind.c
+++ b/src/dbusbind.c
@@ -1051,7 +1051,7 @@ object is returned instead of a list containing this single Lisp object.
   => "i686"
 
 usage: (dbus-call-method BUS SERVICE PATH INTERFACE METHOD &optional :timeout TIMEOUT &rest ARGS)  */)
-  (int nargs, register Lisp_Object *args)
+  (size_t nargs, register Lisp_Object *args)
 {
   Lisp_Object bus, service, path, interface, method;
   Lisp_Object result;
@@ -1063,7 +1063,7 @@ usage: (dbus-call-method BUS SERVICE PATH INTERFACE METHOD &optional :timeout TI
   DBusError derror;
   unsigned int dtype;
   int timeout = -1;
-  int i = 5;
+  size_t i = 5;
   char signature[DBUS_MAXIMUM_SIGNATURE_LENGTH];
 
   /* Check parameters.  */
@@ -1116,7 +1116,7 @@ usage: (dbus-call-method BUS SERVICE PATH INTERFACE METHOD &optional :timeout TI
         {
           XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
           XD_DEBUG_VALID_LISP_OBJECT_P (args[i+1]);
-          XD_DEBUG_MESSAGE ("Parameter%d %s %s", i-4,
+          XD_DEBUG_MESSAGE ("Parameter%lu %s %s", (unsigned long) (i-4),
                             SDATA (format2 ("%s", args[i], Qnil)),
                             SDATA (format2 ("%s", args[i+1], Qnil)));
           ++i;
@@ -1124,7 +1124,7 @@ usage: (dbus-call-method BUS SERVICE PATH INTERFACE METHOD &optional :timeout TI
       else
         {
           XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
-          XD_DEBUG_MESSAGE ("Parameter%d %s", i-4,
+          XD_DEBUG_MESSAGE ("Parameter%lu %s", (unsigned long) (i-4),
                             SDATA (format2 ("%s", args[i], Qnil)));
         }
 
@@ -1233,7 +1233,7 @@ Example:
   -| i686
 
 usage: (dbus-call-method-asynchronously BUS SERVICE PATH INTERFACE METHOD HANDLER &optional :timeout TIMEOUT &rest ARGS)  */)
-  (int nargs, register Lisp_Object *args)
+  (size_t nargs, register Lisp_Object *args)
 {
   Lisp_Object bus, service, path, interface, method, handler;
   Lisp_Object result;
@@ -1243,7 +1243,7 @@ usage: (dbus-call-method-asynchronously BUS SERVICE PATH INTERFACE METHOD HANDLE
   DBusMessageIter iter;
   unsigned int dtype;
   int timeout = -1;
-  int i = 6;
+  size_t i = 6;
   char signature[DBUS_MAXIMUM_SIGNATURE_LENGTH];
 
   /* Check parameters.  */
@@ -1298,7 +1298,7 @@ usage: (dbus-call-method-asynchronously BUS SERVICE PATH INTERFACE METHOD HANDLE
         {
           XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
           XD_DEBUG_VALID_LISP_OBJECT_P (args[i+1]);
-          XD_DEBUG_MESSAGE ("Parameter%d %s %s", i-4,
+          XD_DEBUG_MESSAGE ("Parameter%lu %s %s", (unsigned long) (i-4),
                             SDATA (format2 ("%s", args[i], Qnil)),
                             SDATA (format2 ("%s", args[i+1], Qnil)));
           ++i;
@@ -1306,7 +1306,7 @@ usage: (dbus-call-method-asynchronously BUS SERVICE PATH INTERFACE METHOD HANDLE
       else
         {
           XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
-          XD_DEBUG_MESSAGE ("Parameter%d %s", i-4,
+          XD_DEBUG_MESSAGE ("Parameter%lu %s", (unsigned long) (i - 4),
                             SDATA (format2 ("%s", args[i], Qnil)));
         }
 
@@ -1357,7 +1357,7 @@ DEFUN ("dbus-method-return-internal", Fdbus_method_return_internal,
 This is an internal function, it shall not be used outside dbus.el.
 
 usage: (dbus-method-return-internal BUS SERIAL SERVICE &rest ARGS)  */)
-  (int nargs, register Lisp_Object *args)
+  (size_t nargs, register Lisp_Object *args)
 {
   Lisp_Object bus, serial, service;
   struct gcpro gcpro1, gcpro2, gcpro3;
@@ -1365,7 +1365,7 @@ usage: (dbus-method-return-internal BUS SERIAL SERVICE &rest ARGS)  */)
   DBusMessage *dmessage;
   DBusMessageIter iter;
   unsigned int dtype;
-  int i;
+  size_t i;
   char signature[DBUS_MAXIMUM_SIGNATURE_LENGTH];
 
   /* Check parameters.  */
@@ -1405,7 +1405,7 @@ usage: (dbus-method-return-internal BUS SERIAL SERVICE &rest ARGS)  */)
         {
           XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
           XD_DEBUG_VALID_LISP_OBJECT_P (args[i+1]);
-          XD_DEBUG_MESSAGE ("Parameter%d %s %s", i-2,
+          XD_DEBUG_MESSAGE ("Parameter%lu %s %s", (unsigned long) (i-2),
                             SDATA (format2 ("%s", args[i], Qnil)),
                             SDATA (format2 ("%s", args[i+1], Qnil)));
           ++i;
@@ -1413,7 +1413,7 @@ usage: (dbus-method-return-internal BUS SERIAL SERVICE &rest ARGS)  */)
       else
         {
           XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
-          XD_DEBUG_MESSAGE ("Parameter%d %s", i-2,
+          XD_DEBUG_MESSAGE ("Parameter%lu %s", (unsigned long) (i-2),
                             SDATA (format2 ("%s", args[i], Qnil)));
         }
 
@@ -1445,7 +1445,7 @@ DEFUN ("dbus-method-error-internal", Fdbus_method_error_internal,
 This is an internal function, it shall not be used outside dbus.el.
 
 usage: (dbus-method-error-internal BUS SERIAL SERVICE &rest ARGS)  */)
-  (int nargs, register Lisp_Object *args)
+  (size_t nargs, register Lisp_Object *args)
 {
   Lisp_Object bus, serial, service;
   struct gcpro gcpro1, gcpro2, gcpro3;
@@ -1453,7 +1453,7 @@ usage: (dbus-method-error-internal BUS SERIAL SERVICE &rest ARGS)  */)
   DBusMessage *dmessage;
   DBusMessageIter iter;
   unsigned int dtype;
-  int i;
+  size_t i;
   char signature[DBUS_MAXIMUM_SIGNATURE_LENGTH];
 
   /* Check parameters.  */
@@ -1494,7 +1494,7 @@ usage: (dbus-method-error-internal BUS SERIAL SERVICE &rest ARGS)  */)
         {
           XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
           XD_DEBUG_VALID_LISP_OBJECT_P (args[i+1]);
-          XD_DEBUG_MESSAGE ("Parameter%d %s %s", i-2,
+          XD_DEBUG_MESSAGE ("Parameter%lu %s %s", (unsigned long) (i-2),
                             SDATA (format2 ("%s", args[i], Qnil)),
                             SDATA (format2 ("%s", args[i+1], Qnil)));
           ++i;
@@ -1502,7 +1502,7 @@ usage: (dbus-method-error-internal BUS SERIAL SERVICE &rest ARGS)  */)
       else
         {
           XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
-          XD_DEBUG_MESSAGE ("Parameter%d %s", i-2,
+          XD_DEBUG_MESSAGE ("Parameter%lu %s", (unsigned long) (i-2),
                             SDATA (format2 ("%s", args[i], Qnil)));
         }
 
@@ -1557,7 +1557,7 @@ Example:
   "org.gnu.Emacs.FileManager" "FileModified" "/home/albinus/.emacs")
 
 usage: (dbus-send-signal BUS SERVICE PATH INTERFACE SIGNAL &rest ARGS)  */)
-  (int nargs, register Lisp_Object *args)
+  (size_t nargs, register Lisp_Object *args)
 {
   Lisp_Object bus, service, path, interface, signal;
   struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
@@ -1565,7 +1565,7 @@ usage: (dbus-send-signal BUS SERVICE PATH INTERFACE SIGNAL &rest ARGS)  */)
   DBusMessage *dmessage;
   DBusMessageIter iter;
   unsigned int dtype;
-  int i;
+  size_t i;
   char signature[DBUS_MAXIMUM_SIGNATURE_LENGTH];
 
   /* Check parameters.  */
@@ -1609,7 +1609,7 @@ usage: (dbus-send-signal BUS SERVICE PATH INTERFACE SIGNAL &rest ARGS)  */)
         {
           XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
           XD_DEBUG_VALID_LISP_OBJECT_P (args[i+1]);
-          XD_DEBUG_MESSAGE ("Parameter%d %s %s", i-4,
+          XD_DEBUG_MESSAGE ("Parameter%lu %s %s", (unsigned long) (i-4),
                             SDATA (format2 ("%s", args[i], Qnil)),
                             SDATA (format2 ("%s", args[i+1], Qnil)));
           ++i;
@@ -1617,7 +1617,7 @@ usage: (dbus-send-signal BUS SERVICE PATH INTERFACE SIGNAL &rest ARGS)  */)
       else
         {
           XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
-          XD_DEBUG_MESSAGE ("Parameter%d %s", i-4,
+          XD_DEBUG_MESSAGE ("Parameter%lu %s", (unsigned long) (i-4),
                             SDATA (format2 ("%s", args[i], Qnil)));
         }
 
@@ -1885,11 +1885,11 @@ Example:
   => :already-owner.
 
 usage: (dbus-register-service BUS SERVICE &rest FLAGS)  */)
-  (int nargs, register Lisp_Object *args)
+  (size_t nargs, register Lisp_Object *args)
 {
   Lisp_Object bus, service;
   DBusConnection *connection;
-  unsigned int i;
+  size_t i;
   unsigned int value;
   unsigned int flags = 0;
   int result;
@@ -1985,13 +1985,13 @@ INTERFACE, SIGNAL and HANDLER must not be nil.  Example:
 `dbus-unregister-object' for removing the registration.
 
 usage: (dbus-register-signal BUS SERVICE PATH INTERFACE SIGNAL HANDLER &rest ARGS) */)
-  (int nargs, register Lisp_Object *args)
+  (size_t nargs, register 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;
-  int i;
+  size_t i;
   char rule[DBUS_MAXIMUM_MATCH_RULE_LENGTH];
   char x[DBUS_MAXIMUM_MATCH_RULE_LENGTH];
   DBusError derror;
@@ -2061,7 +2061,8 @@ usage: (dbus-register-signal BUS SERVICE PATH INTERFACE SIGNAL HANDLER &rest ARG
         if (!NILP (args[i]))
           {
             CHECK_STRING (args[i]);
-            sprintf (x, ",arg%d='%s'", i-6, SDATA (args[i]));
+            sprintf (x, ",arg%lu='%s'", (unsigned long) (i-6),
+                     SDATA (args[i]));
             strcat (rule, x);
           }
 
diff --git a/src/dispnew.c b/src/dispnew.c
index a15b5f45e60..3a78845fa56 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -3590,7 +3590,10 @@ update_window (struct window *w, int force_p)
       struct glyph_row *row, *end;
       struct glyph_row *mode_line_row;
       struct glyph_row *header_line_row;
-      int yb, changed_p = 0, mouse_face_overwritten_p = 0, n_updated;
+      int yb, changed_p = 0, mouse_face_overwritten_p = 0;
+#if ! PERIODIC_PREEMPTION_CHECKING
+      int n_updated = 0;
+#endif
 
       rif->update_window_begin_hook (w);
       yb = window_text_bottom_y (w);
@@ -3643,7 +3646,7 @@ update_window (struct window *w, int force_p)
         }
 
       /* Update the rest of the lines.  */
-      for (n_updated = 0; row < end && (force_p || !input_pending); ++row)
+      for (; row < end && (force_p || !input_pending); ++row)
         if (row->enabled_p)
           {
             int vpos = MATRIX_ROW_VPOS (row, desired_matrix);
diff --git a/src/editfns.c b/src/editfns.c
index b04414e1ae6..d0f1df694d5 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -101,7 +101,7 @@ static void general_insert_function (void (*) (const char *, EMACS_INT),
                                      void (*) (Lisp_Object, EMACS_INT,
                                                EMACS_INT, EMACS_INT,
                                                EMACS_INT, int),
-                                     int, int, Lisp_Object *);
+                                     int, size_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,
@@ -1871,7 +1871,7 @@ Years before 1970 are not guaranteed to work.  On some systems,
 year values as low as 1901 do work.
 
 usage: (encode-time SECOND MINUTE HOUR DAY MONTH YEAR &optional ZONE)  */)
-  (int nargs, register Lisp_Object *args)
+  (size_t nargs, register Lisp_Object *args)
 {
   time_t value;
   struct tm tm;
@@ -2207,9 +2207,9 @@ general_insert_function (void (*insert_func)
                          void (*insert_from_string_func)
                               (Lisp_Object, EMACS_INT, EMACS_INT,
                                EMACS_INT, EMACS_INT, int),
-                         int inherit, int nargs, Lisp_Object *args)
+                         int inherit, size_t nargs, Lisp_Object *args)
 {
-  register int argnum;
+  register size_t argnum;
   register Lisp_Object val;
 
   for (argnum = 0; argnum < nargs; argnum++)
@@ -2272,7 +2272,7 @@ buffer; to accomplish this, apply `string-as-multibyte' to the string
 and insert the result.
 
 usage: (insert &rest ARGS)  */)
-  (int nargs, register Lisp_Object *args)
+  (size_t nargs, register Lisp_Object *args)
 {
   general_insert_function (insert, insert_from_string, 0, nargs, args);
   return Qnil;
@@ -2291,7 +2291,7 @@ If the current buffer is unibyte, multibyte strings are converted
 to unibyte for insertion.
 
 usage: (insert-and-inherit &rest ARGS)  */)
-  (int nargs, register Lisp_Object *args)
+  (size_t nargs, register Lisp_Object *args)
 {
   general_insert_function (insert_and_inherit, insert_from_string, 1,
                            nargs, args);
@@ -2308,7 +2308,7 @@ If the current buffer is unibyte, multibyte strings are converted
 to unibyte for insertion.
 
 usage: (insert-before-markers &rest ARGS)  */)
-  (int nargs, register Lisp_Object *args)
+  (size_t nargs, register Lisp_Object *args)
 {
   general_insert_function (insert_before_markers,
                            insert_from_string_before_markers, 0,
@@ -2327,7 +2327,7 @@ If the current buffer is unibyte, multibyte strings are converted
 to unibyte for insertion.
 
 usage: (insert-before-markers-and-inherit &rest ARGS)  */)
-  (int nargs, register Lisp_Object *args)
+  (size_t nargs, register Lisp_Object *args)
 {
   general_insert_function (insert_before_markers_and_inherit,
                            insert_from_string_before_markers, 1,
@@ -3399,7 +3399,7 @@ any existing message; this lets the minibuffer contents show.  See
 also `current-message'.
 
 usage: (message FORMAT-STRING &rest ARGS)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   if (NILP (args[0])
       || (STRINGP (args[0])
@@ -3427,7 +3427,7 @@ If the first argument is nil or the empty string, clear any existing
 message; let the minibuffer contents show.
 
 usage: (message-box FORMAT-STRING &rest ARGS)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   if (NILP (args[0]))
     {
@@ -3444,12 +3444,12 @@ usage: (message-box FORMAT-STRING &rest ARGS)  */)
       if (FRAME_WINDOW_P (XFRAME (selected_frame))
           || FRAME_MSDOS_P (XFRAME (selected_frame)))
       {
-        Lisp_Object pane, menu, obj;
+        Lisp_Object pane, menu;
         struct gcpro gcpro1;
         pane = Fcons (Fcons (build_string ("OK"), Qt), Qnil);
         GCPRO1 (pane);
         menu = Fcons (val, pane);
-        obj = Fx_popup_dialog (Qt, menu, Qt);
+        Fx_popup_dialog (Qt, menu, Qt);
         UNGCPRO;
         return val;
       }
@@ -3484,7 +3484,7 @@ If the first argument is nil or the empty string, clear any existing
 message; let the minibuffer contents show.
 
 usage: (message-or-box FORMAT-STRING &rest ARGS)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
 #ifdef HAVE_MENUS
   if ((NILP (last_nonmenu_event) || CONSP (last_nonmenu_event))
@@ -3508,14 +3508,14 @@ First argument is the string to copy.
 Remaining arguments form a sequence of PROPERTY VALUE pairs for text
 properties to add to the result.
 usage: (propertize STRING &rest PROPERTIES)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   Lisp_Object properties, string;
   struct gcpro gcpro1, gcpro2;
-  int i;
+  size_t i;
 
   /* Number of args must be odd.  */
-  if ((nargs & 1) == 0 || nargs < 1)
+  if ((nargs & 1) == 0)
     error ("Wrong number of arguments");
 
   properties = string = Qnil;
@@ -3590,10 +3590,10 @@ decimal point itself is omitted.  For %s and %S, the precision
 specifier truncates the string to the given width.
 
 usage: (format STRING &rest OBJECTS)  */)
-  (int nargs, register Lisp_Object *args)
+  (size_t nargs, register Lisp_Object *args)
 {
-  register int n;               /* The number of the next arg to substitute */
-  register EMACS_INT total;     /* An estimate of the final length */
+  register size_t n;            /* The number of the next arg to substitute */
+  register size_t total;        /* An estimate of the final length */
   char *buf, *p;
   register char *format, *end, *format_start;
   int nchars;
@@ -3669,8 +3669,8 @@ usage: (format STRING &rest OBJECTS)  */)
 
   /* Allocate the info and discarded tables.  */
   {
-    int nbytes = (nargs+1) * sizeof *info;
-    int i;
+    size_t nbytes = (nargs+1) * sizeof *info;
+    size_t i;
     if (!info)
       info = (struct info *) alloca (nbytes);
     memset (info, 0, nbytes);
diff --git a/src/eval.c b/src/eval.c
index 75874367f2c..26aea3df5df 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -38,9 +38,9 @@ struct backtrace
   struct backtrace *next;
   Lisp_Object *function;
   Lisp_Object *args;    /* Points to vector of args.  */
-  int nargs;            /* Length of vector.
-                           If nargs is UNEVALLED, args points to slot holding
-                           list of unevalled args.  */
+  size_t nargs;         /* Length of vector.
+                           If nargs is (size_t) UNEVALLED, args points
+                           to slot holding list of unevalled args.  */
   char evalargs;
   /* Nonzero means call value of debugger when done with this operation.  */
   char debug_on_exit;
@@ -111,7 +111,7 @@ Lisp_Object Vsignaling_function;
 
 int handling_signal;
 
-static Lisp_Object funcall_lambda (Lisp_Object, int, Lisp_Object*);
+static Lisp_Object funcall_lambda (Lisp_Object, size_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, Lisp_Object, int);
@@ -553,7 +553,7 @@ interactive_p (int exclude_subrs_p)
      looking at several frames for special forms.  Skip past them.  */
   while (btp
          && (EQ (*btp->function, Qbytecode)
-             || btp->nargs == UNEVALLED))
+             || btp->nargs == (size_t) UNEVALLED))
     btp = btp->next;
 
   /* `btp' now points at the frame of the innermost function that isn't
@@ -959,7 +959,7 @@ usage: (let VARLIST BODY...)  */)
   Lisp_Object *temps, tem;
   register Lisp_Object elt, varlist;
   int count = SPECPDL_INDEX ();
-  register int argnum;
+  register size_t argnum;
   struct gcpro gcpro1, gcpro2;
   USE_SAFE_ALLOCA;
 
@@ -1508,8 +1508,8 @@ internal_condition_case_2 (Lisp_Object (*bfun) (Lisp_Object, Lisp_Object),
    and ARGS as second argument.  */
 
 Lisp_Object
-internal_condition_case_n (Lisp_Object (*bfun) (int, Lisp_Object*),
-                           int nargs,
+internal_condition_case_n (Lisp_Object (*bfun) (size_t, Lisp_Object *),
+                           size_t nargs,
                            Lisp_Object *args,
                            Lisp_Object handlers,
                            Lisp_Object (*hfun) (Lisp_Object))
@@ -2201,7 +2201,7 @@ DEFUN ("eval", Feval, Seval, 1, 1, 0,
         {
           /* Pass a vector of evaluated arguments.  */
           Lisp_Object *vals;
-          register int argnum = 0;
+          register size_t argnum = 0;
           USE_SAFE_ALLOCA;
 
           SAFE_ALLOCA_LISP (vals, XINT (numargs));
@@ -2330,9 +2330,9 @@ DEFUN ("apply", Fapply, Sapply, 2, MANY, 0,
 Then return the value FUNCTION returns.
 Thus, (apply '+ 1 2 '(3 4)) returns 10.
 usage: (apply FUNCTION &rest ARGUMENTS)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
-  register int i, numargs;
+  register size_t i, numargs;
   register Lisp_Object spread_arg;
   register Lisp_Object *funcall_args;
   Lisp_Object fun, retval;
@@ -2372,7 +2372,7 @@ usage: (apply FUNCTION &rest ARGUMENTS)  */)
       if (numargs < XSUBR (fun)->min_args
           || (XSUBR (fun)->max_args >= 0 && XSUBR (fun)->max_args < numargs))
         goto funcall;           /* Let funcall get the error.  */
-      else if (XSUBR (fun)->max_args > numargs)
+      else if (XSUBR (fun)->max_args >= 0 && XSUBR (fun)->max_args > numargs)
         {
           /* Avoid making funcall cons up a yet another new vector of arguments
              by explicitly supplying nil's for optional values.  */
@@ -2413,12 +2413,8 @@ usage: (apply FUNCTION &rest ARGUMENTS)  */)
 
 /* Run hook variables in various ways.  */
 
-Lisp_Object run_hook_with_args (int, Lisp_Object *,
-                                Lisp_Object (*funcall)
-                                (int nargs, Lisp_Object *args));
-
 static Lisp_Object
-funcall_nil (int nargs, Lisp_Object *args)
+funcall_nil (size_t nargs, Lisp_Object *args)
 {
   Ffuncall (nargs, args);
   return Qnil;
@@ -2439,10 +2435,10 @@ hook; they should use `run-mode-hooks' instead.
 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)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   Lisp_Object hook[1];
-  register int i;
+  register size_t i;
 
   for (i = 0; i < nargs; i++)
     {
@@ -2468,7 +2464,7 @@ as that may change.
 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)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   return run_hook_with_args (nargs, args, funcall_nil);
 }
@@ -2488,13 +2484,13 @@ However, if they all return nil, we return nil.
 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)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   return run_hook_with_args (nargs, args, Ffuncall);
 }
 
 static Lisp_Object
-funcall_not (int nargs, Lisp_Object *args)
+funcall_not (size_t nargs, Lisp_Object *args)
 {
   return NILP (Ffuncall (nargs, args)) ? Qt : Qnil;
 }
@@ -2513,13 +2509,13 @@ Then we return nil.  However, if they all return non-nil, we return non-nil.
 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)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   return NILP (run_hook_with_args (nargs, args, funcall_not)) ? Qt : Qnil;
 }
 
 static Lisp_Object
-run_hook_wrapped_funcall (int nargs, Lisp_Object *args)
+run_hook_wrapped_funcall (size_t nargs, Lisp_Object *args)
 {
   Lisp_Object tmp = args[0], ret;
   args[0] = args[1];
@@ -2537,11 +2533,11 @@ it calls WRAP-FUNCTION with arguments FUN and ARGS.
 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)  */)
-     (int nargs, Lisp_Object *args)
+     (size_t nargs, Lisp_Object *args)
 {
   return run_hook_with_args (nargs, args, run_hook_wrapped_funcall);
 }
-     
+
 /* ARGS[0] should be a hook symbol.
    Call each of the functions in the hook value, passing each of them
    as arguments all the rest of ARGS (all NARGS - 1 elements).
@@ -2550,8 +2546,8 @@ usage: (run-hook-wrapped HOOK WRAP-FUNCTION &rest ARGS)  */)
    except that it isn't necessary to gcpro ARGS[0].  */
 
 Lisp_Object
-run_hook_with_args (int nargs, Lisp_Object *args,
-                    Lisp_Object (*funcall) (int nargs, Lisp_Object *args))
+run_hook_with_args (size_t nargs, Lisp_Object *args,
+                    Lisp_Object (*funcall) (size_t nargs, Lisp_Object *args))
 {
   Lisp_Object sym, val, ret = Qnil;
   struct gcpro gcpro1, gcpro2, gcpro3;
@@ -2791,16 +2787,16 @@ DEFUN ("funcall", Ffuncall, Sfuncall, 1, MANY, 0,
 Return the value that function returns.
 Thus, (funcall 'cons 'x 'y) returns (x . y).
 usage: (funcall FUNCTION &rest ARGUMENTS)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   Lisp_Object fun, original_fun;
   Lisp_Object funcar;
-  int numargs = nargs - 1;
+  size_t numargs = nargs - 1;
   Lisp_Object lisp_numargs;
   Lisp_Object val;
   struct backtrace backtrace;
   register Lisp_Object *internal_args;
-  register int i;
+  register size_t i;
 
   QUIT;
   if ((consing_since_gc > gc_cons_threshold
@@ -2953,21 +2949,21 @@ static Lisp_Object
 apply_lambda (Lisp_Object fun, Lisp_Object args, int eval_flag)
 {
   Lisp_Object args_left;
-  Lisp_Object numargs;
+  size_t numargs;
   register Lisp_Object *arg_vector;
   struct gcpro gcpro1, gcpro2, gcpro3;
-  register int i;
+  register size_t i;
   register Lisp_Object tem;
   USE_SAFE_ALLOCA;
 
-  numargs = Flength (args);
-  SAFE_ALLOCA_LISP (arg_vector, XINT (numargs));
+  numargs = XINT (Flength (args));
+  SAFE_ALLOCA_LISP (arg_vector, numargs);
   args_left = args;
 
   GCPRO3 (*arg_vector, args_left, fun);
   gcpro1.nvars = 0;
 
-  for (i = 0; i < XINT (numargs);)
+  for (i = 0; i < numargs; )
     {
       tem = Fcar (args_left), args_left = Fcdr (args_left);
       if (eval_flag) tem = Feval (tem);
@@ -2983,7 +2979,7 @@ apply_lambda (Lisp_Object fun, Lisp_Object args, int eval_flag)
       backtrace_list->nargs = i;
     }
   backtrace_list->evalargs = 0;
-  tem = funcall_lambda (fun, XINT (numargs), arg_vector);
+  tem = funcall_lambda (fun, numargs, arg_vector);
 
   /* Do the debug-on-exit now, while arg_vector still exists.  */
   if (backtrace_list->debug_on_exit)
@@ -2999,11 +2995,13 @@ apply_lambda (Lisp_Object fun, Lisp_Object args, int eval_flag)
    FUN must be either a lambda-expression or a compiled-code object.  */
 
 static Lisp_Object
-funcall_lambda (Lisp_Object fun, int nargs, register Lisp_Object *arg_vector)
+funcall_lambda (Lisp_Object fun, size_t nargs,
+                register Lisp_Object *arg_vector)
 {
   Lisp_Object val, syms_left, next;
   int count = SPECPDL_INDEX ();
-  int i, optional, rest;
+  size_t i;
+  int optional, rest;
 
   if (CONSP (fun))
     {
@@ -3323,7 +3321,6 @@ Output stream used is value of `standard-output'.  */)
   (void)
 {
   register struct backtrace *backlist = backtrace_list;
-  register int i;
   Lisp_Object tail;
   Lisp_Object tem;
   struct gcpro gcpro1;
@@ -3338,7 +3335,7 @@ Output stream used is value of `standard-output'.  */)
   while (backlist)
     {
       write_string (backlist->debug_on_exit ? "* " : "  ", 2);
-      if (backlist->nargs == UNEVALLED)
+      if (backlist->nargs == (size_t) UNEVALLED)
         {
           Fprin1 (Fcons (*backlist->function, *backlist->args), Qnil);
           write_string ("\n", -1);
@@ -3348,11 +3345,12 @@ Output stream used is value of `standard-output'.  */)
           tem = *backlist->function;
           Fprin1 (tem, Qnil);   /* This can QUIT.  */
           write_string ("(", -1);
-          if (backlist->nargs == MANY)
+          if (backlist->nargs == (size_t) MANY)
             {
+              int i;
               for (tail = *backlist->args, i = 0;
                    !NILP (tail);
-                   tail = Fcdr (tail), i++)
+                   tail = Fcdr (tail), i = 1)
                 {
                   if (i) write_string (" ", -1);
                   Fprin1 (Fcar (tail), Qnil);
@@ -3360,6 +3358,7 @@ Output stream used is value of `standard-output'.  */)
             }
           else
             {
+              size_t i;
               for (i = 0; i < backlist->nargs; i++)
                 {
                   if (i) write_string (" ", -1);
@@ -3389,7 +3388,7 @@ If NFRAMES is more than the number of frames, the value is nil.  */)
   (Lisp_Object nframes)
 {
   register struct backtrace *backlist = backtrace_list;
-  register int i;
+  register EMACS_INT i;
   Lisp_Object tem;
 
   CHECK_NATNUM (nframes);
@@ -3400,11 +3399,11 @@ If NFRAMES is more than the number of frames, the value is nil.  */)
 
   if (!backlist)
     return Qnil;
-  if (backlist->nargs == UNEVALLED)
+  if (backlist->nargs == (size_t) UNEVALLED)
     return Fcons (Qnil, Fcons (*backlist->function, *backlist->args));
   else
     {
-      if (backlist->nargs == MANY)
+      if (backlist->nargs == (size_t) MANY)
         tem = *backlist->args;
       else
         tem = Flist (backlist->nargs, backlist->args);
@@ -3418,17 +3417,18 @@ void
 mark_backtrace (void)
 {
   register struct backtrace *backlist;
-  register int i;
+  register size_t i;
 
   for (backlist = backtrace_list; backlist; backlist = backlist->next)
     {
       mark_object (*backlist->function);
 
-      if (backlist->nargs == UNEVALLED || backlist->nargs == MANY)
-        i = 0;
+      if (backlist->nargs == (size_t) UNEVALLED
+          || backlist->nargs == (size_t) MANY)
+        i = 1;
       else
-        i = backlist->nargs - 1;
-      for (; i >= 0; i--)
+        i = backlist->nargs;
+      while (i--)
         mark_object (backlist->args[i]);
     }
 }
diff --git a/src/fns.c b/src/fns.c
index 71f49b9cdae..95e8badbaa5 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -348,7 +348,7 @@ Symbols are also allowed; their print names are used instead.  */)
   return i1 < SCHARS (s2) ? Qt : Qnil;
 }
 
-static Lisp_Object concat (int nargs, Lisp_Object *args,
+static Lisp_Object concat (size_t nargs, Lisp_Object *args,
                            enum Lisp_Type target_type, int last_special);
 
 /* ARGSUSED */
@@ -378,7 +378,7 @@ The result is a list whose elements are the elements of all the arguments.
 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)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   return concat (nargs, args, Lisp_Cons, 1);
 }
@@ -388,7 +388,7 @@ DEFUN ("concat", Fconcat, Sconcat, 0, MANY, 0,
 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)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   return concat (nargs, args, Lisp_String, 0);
 }
@@ -398,7 +398,7 @@ DEFUN ("vconcat", Fvconcat, Svconcat, 0, MANY, 0,
 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)   */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   return concat (nargs, args, Lisp_Vectorlike, 0);
 }
@@ -446,7 +446,8 @@ struct textprop_rec
 };
 
 static Lisp_Object
-concat (int nargs, Lisp_Object *args, enum Lisp_Type target_type, int last_special)
+concat (size_t nargs, Lisp_Object *args,
+        enum Lisp_Type target_type, int last_special)
 {
   Lisp_Object val;
   register Lisp_Object tail;
@@ -455,7 +456,7 @@ concat (int nargs, Lisp_Object *args, enum Lisp_Type target_type, int last_speci
   EMACS_INT toindex_byte = 0;
   register EMACS_INT result_len;
   register EMACS_INT result_len_byte;
-  register int argnum;
+  register size_t argnum;
   Lisp_Object last_tail;
   Lisp_Object prev;
   int some_multibyte;
@@ -2232,9 +2233,9 @@ DEFUN ("nconc", Fnconc, Snconc, 0, MANY, 0,
        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)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
-  register int argnum;
+  register size_t argnum;
   register Lisp_Object tail, tem, val;
 
   val = tail = Qnil;
@@ -2763,7 +2764,7 @@ DEFUN ("widget-apply", Fwidget_apply, Swidget_apply, 2, MANY, 0,
        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)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   /* This function can GC. */
   Lisp_Object newargs[3];
@@ -3367,7 +3368,7 @@ Lisp_Object Qhash_table_test, Qkey_or_value, Qkey_and_value;
 /* Function prototypes.  */
 
 static struct Lisp_Hash_Table *check_hash_table (Lisp_Object);
-static int get_key_arg (Lisp_Object, int, Lisp_Object *, char *);
+static size_t get_key_arg (Lisp_Object, size_t, Lisp_Object *, char *);
 static void maybe_resize_hash_table (struct Lisp_Hash_Table *);
 static int cmpfn_eql (struct Lisp_Hash_Table *, Lisp_Object, unsigned,
                       Lisp_Object, unsigned);
@@ -3422,27 +3423,23 @@ next_almost_prime (int n)
 /* Find KEY in ARGS which has size NARGS.  Don't consider indices for
    which USED[I] is non-zero.  If found at index I in ARGS, set
    USED[I] and USED[I + 1] to 1, and return I + 1.  Otherwise return
-   -1.  This function is used to extract a keyword/argument pair from
+   0.  This function is used to extract a keyword/argument pair from
    a DEFUN parameter list.  */
 
-static int
-get_key_arg (Lisp_Object key, int nargs, Lisp_Object *args, char *used)
+static size_t
+get_key_arg (Lisp_Object key, size_t nargs, Lisp_Object *args, char *used)
 {
-  int i;
-
-  for (i = 0; i < nargs - 1; ++i)
-    if (!used[i] && EQ (args[i], key))
-      break;
+  size_t i;
 
-  if (i >= nargs - 1)
-    i = -1;
-  else
-    {
-      used[i++] = 1;
-      used[i] = 1;
-    }
+  for (i = 1; i < nargs; i++)
+    if (!used[i - 1] && EQ (args[i - 1], key))
+      {
+        used[i - 1] = 1;
+        used[i] = 1;
+        return i;
+      }
 
-  return i;
+  return 0;
 }
 
 
@@ -4290,12 +4287,12 @@ WEAK.  WEAK t is equivalent to `key-and-value'.  Default value of WEAK
 is nil.
 
 usage: (make-hash-table &rest KEYWORD-ARGS)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   Lisp_Object test, size, rehash_size, rehash_threshold, weak;
   Lisp_Object user_test, user_hash;
   char *used;
-  int i;
+  size_t i;
 
   /* The vector `used' is used to keep track of arguments that
      have been consumed.  */
@@ -4304,7 +4301,7 @@ usage: (make-hash-table &rest KEYWORD-ARGS)  */)
 
   /* See if there's a `:test TEST' among the arguments.  */
   i = get_key_arg (QCtest, nargs, args, used);
-  test = i < 0 ? Qeql : args[i];
+  test = i ? args[i] : Qeql;
   if (!EQ (test, Qeq) && !EQ (test, Qeql) && !EQ (test, Qequal))
     {
       /* See if it is a user-defined test.  */
@@ -4321,7 +4318,7 @@ usage: (make-hash-table &rest KEYWORD-ARGS)  */)
 
   /* See if there's a `:size SIZE' argument.  */
   i = get_key_arg (QCsize, nargs, args, used);
-  size = i < 0 ? Qnil : args[i];
+  size = i ? args[i] : Qnil;
   if (NILP (size))
     size = make_number (DEFAULT_HASH_SIZE);
   else if (!INTEGERP (size) || XINT (size) < 0)
@@ -4329,7 +4326,7 @@ usage: (make-hash-table &rest KEYWORD-ARGS)  */)
 
   /* Look for `:rehash-size SIZE'.  */
   i = get_key_arg (QCrehash_size, nargs, args, used);
-  rehash_size = i < 0 ? make_float (DEFAULT_REHASH_SIZE) : args[i];
+  rehash_size = i ? args[i] : make_float (DEFAULT_REHASH_SIZE);
   if (!NUMBERP (rehash_size)
       || (INTEGERP (rehash_size) && XINT (rehash_size) <= 0)
       || XFLOATINT (rehash_size) <= 1.0)
@@ -4337,7 +4334,7 @@ usage: (make-hash-table &rest KEYWORD-ARGS)  */)
 
   /* Look for `:rehash-threshold THRESHOLD'.  */
   i = get_key_arg (QCrehash_threshold, nargs, args, used);
-  rehash_threshold = i < 0 ? make_float (DEFAULT_REHASH_THRESHOLD) : args[i];
+  rehash_threshold = i ? args[i] : make_float (DEFAULT_REHASH_THRESHOLD);
   if (!FLOATP (rehash_threshold)
       || XFLOATINT (rehash_threshold) <= 0.0
       || XFLOATINT (rehash_threshold) > 1.0)
@@ -4345,7 +4342,7 @@ usage: (make-hash-table &rest KEYWORD-ARGS)  */)
 
   /* Look for `:weakness WEAK'.  */
   i = get_key_arg (QCweakness, nargs, args, used);
-  weak = i < 0 ? Qnil : args[i];
+  weak = i ? args[i] : Qnil;
   if (EQ (weak, Qt))
     weak = Qkey_and_value;
   if (!NILP (weak)
diff --git a/src/font.c b/src/font.c
index 9e8b7029c22..6b2e2f2712d 100644
--- a/src/font.c
+++ b/src/font.c
@@ -3831,10 +3831,10 @@ be an OpenType font, and whose GPOS table of `thai' script's default
 language system must contain `mark' feature.
 
 usage: (font-spec ARGS...)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   Lisp_Object spec = font_make_spec ();
-  int i;
+  size_t i;
 
   for (i = 0; i < nargs; i += 2)
     {
diff --git a/src/frame.c b/src/frame.c
index cdcb313280b..1b6d36092ae 100644
--- a/src/frame.c
+++ b/src/frame.c
@@ -2902,7 +2902,7 @@ x_set_frame_parameters (FRAME_PTR f, Lisp_Object alist)
   /* Record in these vectors all the parms specified.  */
   Lisp_Object *parms;
   Lisp_Object *values;
-  int i, p;
+  size_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;
@@ -2975,7 +2975,7 @@ x_set_frame_parameters (FRAME_PTR f, Lisp_Object alist)
     }
 
   /* Now process them in reverse of specified order.  */
-  for (i--; i >= 0; i--)
+  while (i-- != 0)
     {
       Lisp_Object prop, val;
 
diff --git a/src/image.c b/src/image.c
index 04c6b1a2ad5..25929d1004c 100644
--- a/src/image.c
+++ b/src/image.c
@@ -6753,7 +6753,7 @@ tiff_load (struct frame *f, struct image *img)
   TIFF *tiff;
   int width, height, x, y, count;
   uint32 *buf;
-  int rc, rc2;
+  int rc;
   XImagePtr ximg;
   tiff_memory_source memsrc;
   Lisp_Object image;
@@ -6841,8 +6841,8 @@ tiff_load (struct frame *f, struct image *img)
   rc = fn_TIFFReadRGBAImage (tiff, width, height, buf, 0);
 
   /* Count the number of images in the file.  */
-  for (count = 1, rc2 = 1; rc2; count++)
-    rc2 = fn_TIFFSetDirectory (tiff, count);
+  for (count = 1; fn_TIFFSetDirectory (tiff, count); count++)
+    continue;
 
   if (count > 1)
     img->data.lisp_val = Fcons (Qcount,
diff --git a/src/keyboard.c b/src/keyboard.c
index 3fea3df07d5..86a2b3e8abd 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -201,8 +201,8 @@ Lisp_Object unread_switch_frame;
 /* Last size recorded for a current buffer which is not a minibuffer.  */
 static EMACS_INT last_non_minibuf_size;
 
-/* Total number of times read_char has returned.  */
-int num_input_events;
+/* Total number of times read_char has returned, modulo SIZE_MAX + 1.  */
+size_t num_input_events;
 
 /* Value of num_nonmacro_input_events as of last auto save.  */
 
@@ -1269,7 +1269,7 @@ some_mouse_moved (void)
 /* This is the actual command reading loop,
    sans error-handling encapsulation.  */
 
-static int read_key_sequence (Lisp_Object *, int, Lisp_Object,
+static int read_key_sequence (Lisp_Object *, size_t, Lisp_Object,
                               int, int, int);
 void safe_run_hooks (Lisp_Object);
 static void adjust_point_for_property (EMACS_INT, int);
@@ -1862,7 +1862,7 @@ safe_run_hooks_error (Lisp_Object error_data)
 }
 
 static Lisp_Object
-safe_run_hook_funcall (int nargs, Lisp_Object *args)
+safe_run_hook_funcall (size_t nargs, Lisp_Object *args)
 {
   eassert (nargs == 1);
   if (CONSP (Vinhibit_quit))
@@ -6004,10 +6004,10 @@ make_lispy_switch_frame (Lisp_Object frame)
    This doesn't use any caches.  */
 
 static int
-parse_modifiers_uncached (Lisp_Object symbol, int *modifier_end)
+parse_modifiers_uncached (Lisp_Object symbol, EMACS_INT *modifier_end)
 {
   Lisp_Object name;
-  int i;
+  EMACS_INT i;
   int modifiers;
 
   CHECK_SYMBOL (symbol);
@@ -6017,7 +6017,7 @@ parse_modifiers_uncached (Lisp_Object symbol, int *modifier_end)
 
   for (i = 0; i+2 <= SBYTES (name); )
     {
-      int this_mod_end = 0;
+      EMACS_INT this_mod_end = 0;
       int this_mod = 0;
 
       /* See if the name continues with a modifier word.
@@ -6214,7 +6214,7 @@ parse_modifiers (Lisp_Object symbol)
     return elements;
   else
     {
-      int end;
+      EMACS_INT end;
       int modifiers = parse_modifiers_uncached (symbol, &end);
       Lisp_Object unmodified;
       Lisp_Object mask;
@@ -8793,7 +8793,7 @@ access_keymap_keyremap (Lisp_Object map, Lisp_Object key, Lisp_Object prompt,
    The return value is non-zero if the remapping actually took place.  */
 
 static int
-keyremap_step (Lisp_Object *keybuf, int bufsize, volatile keyremap *fkey,
+keyremap_step (Lisp_Object *keybuf, size_t bufsize, volatile keyremap *fkey,
                int input, int doit, int *diff, Lisp_Object prompt)
 {
   Lisp_Object next, key;
@@ -8886,7 +8886,7 @@ keyremap_step (Lisp_Object *keybuf, int bufsize, volatile keyremap *fkey,
    from the selected window's buffer.  */
 
 static int
-read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
+read_key_sequence (Lisp_Object *keybuf, size_t bufsize, Lisp_Object prompt,
                    int dont_downcase_last, int can_return_switch_frame,
                    int fix_current_buffer)
 {
@@ -9404,80 +9404,84 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
                     last_real_key_start = t - 1;
                 }
 
-              /* Key sequences beginning with mouse clicks are
-                 read using the keymaps in the buffer clicked on,
-                 not the current buffer.  If we're at the
-                 beginning of a key sequence, switch buffers.  */
-              if (last_real_key_start == 0
-                  && WINDOWP (window)
-                  && BUFFERP (XWINDOW (window)->buffer)
-                  && XBUFFER (XWINDOW (window)->buffer) != current_buffer)
+              if (last_real_key_start == 0)
                 {
-                  XVECTOR (raw_keybuf)->contents[raw_keybuf_count++] = key;
-                  keybuf[t] = key;
-                  mock_input = t + 1;
-
-                  /* Arrange to go back to the original buffer once we're
-                     done reading the key sequence.  Note that we can't
-                     use save_excursion_{save,restore} here, because they
-                     save point as well as the current buffer; we don't
-                     want to save point, because redisplay may change it,
-                     to accommodate a Fset_window_start or something.  We
-                     don't want to do this at the top of the function,
-                     because we may get input from a subprocess which
-                     wants to change the selected window and stuff (say,
-                     emacsclient).  */
-                  record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
-
-                  if (! FRAME_LIVE_P (XFRAME (selected_frame)))
-                    Fkill_emacs (Qnil);
-                  set_buffer_internal (XBUFFER (XWINDOW (window)->buffer));
-                  orig_local_map = get_local_map (PT, current_buffer,
-                                                  Qlocal_map);
-                  orig_keymap = get_local_map (PT, current_buffer, Qkeymap);
-                  goto replay_sequence;
-                }
+                  /* Key sequences beginning with mouse clicks are
+                     read using the keymaps in the buffer clicked on,
+                     not the current buffer.  If we're at the
+                     beginning of a key sequence, switch buffers.  */
+                  if (WINDOWP (window)
+                      && BUFFERP (XWINDOW (window)->buffer)
+                      && XBUFFER (XWINDOW (window)->buffer) != current_buffer)
+                    {
+                      XVECTOR (raw_keybuf)->contents[raw_keybuf_count++] = key;
+                      keybuf[t] = key;
+                      mock_input = t + 1;
+
+                      /* Arrange to go back to the original buffer once we're
+                         done reading the key sequence.  Note that we can't
+                         use save_excursion_{save,restore} here, because they
+                         save point as well as the current buffer; we don't
+                         want to save point, because redisplay may change it,
+                         to accommodate a Fset_window_start or something.  We
+                         don't want to do this at the top of the function,
+                         because we may get input from a subprocess which
+                         wants to change the selected window and stuff (say,
+                         emacsclient).  */
+                      record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
+
+                      if (! FRAME_LIVE_P (XFRAME (selected_frame)))
+                        Fkill_emacs (Qnil);
+                      set_buffer_internal (XBUFFER (XWINDOW (window)->buffer));
+                      orig_local_map = get_local_map (PT, current_buffer,
+                                                      Qlocal_map);
+                      orig_keymap = get_local_map (PT, current_buffer,
+                                                   Qkeymap);
+                      goto replay_sequence;
+                    }
 
-              /* For a mouse click, get the local text-property keymap
-                 of the place clicked on, rather than point.  */
-              if (last_real_key_start == 0
-                  && CONSP (XCDR (key))
-                  && ! localized_local_map)
-                {
-                  Lisp_Object map_here, start, pos;
+                  /* For a mouse click, get the local text-property keymap
+                     of the place clicked on, rather than point.  */
+                  if (CONSP (XCDR (key))
+                      && ! localized_local_map)
+                    {
+                      Lisp_Object map_here, start, pos;
 
-                  localized_local_map = 1;
-                  start = EVENT_START (key);
+                      localized_local_map = 1;
+                      start = EVENT_START (key);
 
-                  if (CONSP (start) && POSN_INBUFFER_P (start))
-                    {
-                      pos = POSN_BUFFER_POSN (start);
-                      if (INTEGERP (pos)
-                          && XINT (pos) >= BEGV
-                          && XINT (pos) <= ZV)
+                      if (CONSP (start) && POSN_INBUFFER_P (start))
                         {
-                          map_here = get_local_map (XINT (pos),
-                                                    current_buffer, Qlocal_map);
-                          if (!EQ (map_here, orig_local_map))
+                          pos = POSN_BUFFER_POSN (start);
+                          if (INTEGERP (pos)
+                              && XINT (pos) >= BEGV
+                              && XINT (pos) <= ZV)
                             {
-                              orig_local_map = map_here;
-                              ++localized_local_map;
-                            }
+                              map_here = get_local_map (XINT (pos),
+                                                        current_buffer,
+                                                        Qlocal_map);
+                              if (!EQ (map_here, orig_local_map))
+                                {
+                                  orig_local_map = map_here;
+                                  ++localized_local_map;
+                                }
 
-                          map_here = get_local_map (XINT (pos),
-                                                     current_buffer, Qkeymap);
-                          if (!EQ (map_here, orig_keymap))
-                            {
-                              orig_keymap = map_here;
-                              ++localized_local_map;
-                            }
+                              map_here = get_local_map (XINT (pos),
+                                                        current_buffer,
+                                                        Qkeymap);
+                              if (!EQ (map_here, orig_keymap))
+                                {
+                                  orig_keymap = map_here;
+                                  ++localized_local_map;
+                                }
 
-                          if (localized_local_map > 1)
-                            {
-                              keybuf[t] = key;
-                              mock_input = t + 1;
+                              if (localized_local_map > 1)
+                                {
+                                  keybuf[t] = key;
+                                  mock_input = t + 1;
 
-                              goto replay_sequence;
+                                  goto replay_sequence;
+                                }
                             }
                         }
                     }
@@ -11602,12 +11606,12 @@ syms_of_keyboard (void)
   last_point_position_window = Qnil;
 
   {
-    const struct event_head *p;
+    int i;
+    int len = sizeof (head_table) / sizeof (head_table[0]);
 
-    for (p = head_table;
-         p < head_table + (sizeof (head_table) / sizeof (head_table[0]));
-         p++)
+    for (i = 0; i < len; i++)
       {
+        const struct event_head *p = &head_table[i];
         *p->var = intern_c_string (p->name);
         staticpro (p->var);
         Fput (*p->var, Qevent_kind, *p->kind);
diff --git a/src/keyboard.h b/src/keyboard.h
index 2ff370306b6..72bb821b2eb 100644
--- a/src/keyboard.h
+++ b/src/keyboard.h
@@ -194,8 +194,8 @@ extern KBOARD *all_kboards;
 /* Nonzero in the single-kboard state, 0 in the any-kboard state.  */
 extern int single_kboard;
 
-/* Total number of times read_char has returned.  */
-extern int num_input_events;
+/* Total number of times read_char has returned, modulo SIZE_MAX + 1.  */
+extern size_t num_input_events;
 
 /* Nonzero means polling for input is temporarily suppressed.  */
 extern int poll_suppress_count;
diff --git a/src/lisp.h b/src/lisp.h
index a3c4d48b49c..85838d111db 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -964,7 +964,7 @@ struct Lisp_Subr
       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) (int, Lisp_Object *);
+      Lisp_Object (*aMANY) (size_t, Lisp_Object *);
     } function;
     short min_args, max_args;
     const char *symbol_name;
@@ -1809,7 +1809,7 @@ typedef struct {
 
 /* Note that the weird token-substitution semantics of ANSI C makes
    this work for MANY and UNEVALLED.  */
-#define DEFUN_ARGS_MANY         (int, Lisp_Object *)
+#define DEFUN_ARGS_MANY         (size_t, Lisp_Object *)
 #define DEFUN_ARGS_UNEVALLED    (Lisp_Object)
 #define DEFUN_ARGS_0    (void)
 #define DEFUN_ARGS_1    (Lisp_Object)
@@ -2079,7 +2079,7 @@ struct gcpro
   volatile Lisp_Object *var;
 
   /* Number of consecutive protected variables.  */
-  int nvars;
+  size_t nvars;
 
 #ifdef DEBUG_GCPRO
   int level;
@@ -2830,9 +2830,9 @@ EXFUN (Frun_hooks, MANY);
 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 (int nargs, Lisp_Object *args,
+extern Lisp_Object run_hook_with_args (size_t nargs, Lisp_Object *args,
                                        Lisp_Object (*funcall)
-                                       (int nargs, Lisp_Object *args));
+                                       (size_t nargs, Lisp_Object *args));
 EXFUN (Fprogn, UNEVALLED);
 EXFUN (Finteractive_p, 0);
 EXFUN (Fthrow, 2) NO_RETURN;
@@ -2863,7 +2863,7 @@ extern Lisp_Object internal_lisp_condition_case (Lisp_Object, Lisp_Object, Lisp_
 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 (*) (int, Lisp_Object *), int, 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 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);
@@ -2873,7 +2873,7 @@ extern void do_autoload (Lisp_Object, Lisp_Object);
 extern Lisp_Object un_autoload (Lisp_Object);
 EXFUN (Ffetch_bytecode, 1);
 extern void init_eval_once (void);
-extern Lisp_Object safe_call (int, Lisp_Object *);
+extern Lisp_Object safe_call (size_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);
diff --git a/src/menu.c b/src/menu.c
index 851f1ac804b..a9098deed7e 100644
--- a/src/menu.c
+++ b/src/menu.c
@@ -662,13 +662,12 @@ digest_single_submenu (int start, int end, int top_level_items)
       else if (EQ (XVECTOR (menu_items)->contents[i], Qt))
         {
           /* Create a new pane.  */
-          Lisp_Object pane_name, prefix;
+          Lisp_Object pane_name;
           const char *pane_string;
 
           panes_seen++;
 
           pane_name = XVECTOR (menu_items)->contents[i + MENU_ITEMS_PANE_NAME];
-          prefix = XVECTOR (menu_items)->contents[i + MENU_ITEMS_PANE_PREFIX];
 
 #ifdef HAVE_NTGUI
           if (STRINGP (pane_name))
diff --git a/src/process.c b/src/process.c
index 148f5b59f8a..1abfbd3f2a4 100644
--- a/src/process.c
+++ b/src/process.c
@@ -1512,11 +1512,11 @@ the command through a shell and redirect one of them using the shell
 syntax.
 
 usage: (start-process NAME BUFFER PROGRAM &rest PROGRAM-ARGS)  */)
-  (int nargs, register Lisp_Object *args)
+  (size_t nargs, register Lisp_Object *args)
 {
   Lisp_Object buffer, name, program, proc, current_dir, tem;
   register unsigned char **new_argv;
-  register int i;
+  register size_t i;
   int count = SPECPDL_INDEX ();
 
   buffer = args[1];
@@ -1722,7 +1722,7 @@ usage: (start-process NAME BUFFER PROGRAM &rest PROGRAM-ARGS)  */)
       new_argv = (unsigned char **) alloca ((nargs - 1) * sizeof (char *));
       new_argv[nargs - 2] = 0;
 
-      for (i = nargs - 3; i >= 0; i--)
+      for (i = nargs - 2; i-- != 0; )
         {
           new_argv[i] = SDATA (XCAR (tem));
           tem = XCDR (tem);
@@ -2681,7 +2681,7 @@ Examples:
 \(serial-process-configure :port "\\\\.\\COM13" :bytesize 7)
 
 usage: (serial-process-configure &rest ARGS)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   struct Lisp_Process *p;
   Lisp_Object contact = Qnil;
@@ -2799,7 +2799,7 @@ Examples:
 \(make-serial-process :port "/dev/tty.BlueConsole-SPP-1" :speed nil)
 
 usage:  (make-serial-process &rest ARGS)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   int fd = -1;
   Lisp_Object proc, contact, port;
@@ -3077,7 +3077,7 @@ The original argument list, modified with the actual connection
 information, is available via the `process-contact' function.
 
 usage: (make-network-process &rest ARGS)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   Lisp_Object proc;
   Lisp_Object contact;
@@ -3393,7 +3393,8 @@ usage: (make-network-process &rest ARGS)  */)
 
   for (lres = res; lres; lres = lres->ai_next)
     {
-      int optn, optbits;
+      size_t optn;
+      int optbits;
 
 #ifdef WINDOWSNT
     retry_connect:
diff --git a/src/syntax.c b/src/syntax.c
index c1442c396c1..0a1525b54ea 100644
--- a/src/syntax.c
+++ b/src/syntax.c
@@ -3265,9 +3265,9 @@ do { prev_from = from;				\
     = (curlevel == levelstart) ? -1 : (curlevel - 1)->last;
   state.location = from;
   state.levelstarts = Qnil;
-  while (--curlevel >= levelstart)
-      state.levelstarts = Fcons (make_number (curlevel->last),
-                                 state.levelstarts);
+  while (curlevel > levelstart)
+    state.levelstarts = Fcons (make_number ((--curlevel)->last),
+                               state.levelstarts);
   immediate_quit = 0;
 
   *stateptr = state;
diff --git a/src/term.c b/src/term.c
index b3392df76fd..fc7726298c5 100644
--- a/src/term.c
+++ b/src/term.c
@@ -1952,7 +1952,7 @@ produce_glyphless_glyph (struct it *it, int for_no_font, Lisp_Object acronym)
 
   it->pixel_width = len;
   it->nglyphs = len;
-  if (len > 0 && it->glyph_row)
+  if (it->glyph_row)
     append_glyphless_glyph (it, face_id, str);
 }
 
diff --git a/src/unexelf.c b/src/unexelf.c
index b58c78501b8..8b45894f853 100644
--- a/src/unexelf.c
+++ b/src/unexelf.c
@@ -651,7 +651,9 @@ unexec (const char *new_name, const char *old_name)
   int n, nn;
   int old_bss_index, old_sbss_index, old_plt_index;
   int old_data_index, new_data2_index;
+#if defined _SYSTYPE_SYSV || defined __sgi
   int old_mdebug_index;
+#endif
   struct stat stat_buf;
   int old_file_size;
 
@@ -695,8 +697,10 @@ unexec (const char *new_name, const char *old_name)
 
   /* Find the mdebug section, if any.  */
 
+#if defined _SYSTYPE_SYSV || defined __sgi
   old_mdebug_index = find_section (".mdebug", old_section_names,
                                    old_name, old_file_h, old_section_h, 1);
+#endif
 
   /* Find the old .bss section.  Figure out parameters of the new
      data2 and bss sections.  */
diff --git a/src/window.c b/src/window.c
index 9ab9fab2c13..b7747b5ad79 100644
--- a/src/window.c
+++ b/src/window.c
@@ -2978,14 +2978,10 @@ shrink_windows (int total, int size, int nchildren, int shrinkable,
   while (total_shrink > total_removed)
     {
       int nonzero_sizes = 0;
-      int nonzero_idx = -1;
 
       for (i = 0; i < nchildren; ++i)
         if (new_sizes[i] > 0)
-          {
-            ++nonzero_sizes;
-            nonzero_idx = i;
-          }
+          ++nonzero_sizes;
 
       for (i = 0; i < nchildren; ++i)
         if (new_sizes[i] > min_sizes[i])
diff --git a/src/xdisp.c b/src/xdisp.c
index 308588101e2..bbbf37b68ac 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -2180,7 +2180,7 @@ safe_eval_handler (Lisp_Object arg)
    redisplay during the evaluation.  */
 
 Lisp_Object
-safe_call (int nargs, Lisp_Object *args)
+safe_call (size_t nargs, Lisp_Object *args)
 {
   Lisp_Object val;
 
@@ -14638,8 +14638,6 @@ try_window_reusing_current_matrix (struct window *w)
 
   if (CHARPOS (new_start) <= CHARPOS (start))
     {
-      int first_row_y;
-
       /* Don't use this method if the display starts with an ellipsis
          displayed for invisible text.  It's not easy to handle that case
          below, and it's certainly not worth the effort since this is
@@ -14654,7 +14652,6 @@ try_window_reusing_current_matrix (struct window *w)
          text.  Note that it.vpos == 0 if or if not there is a
          header-line; it's not the same as the MATRIX_ROW_VPOS!  */
       start_display (&it, w, new_start);
-      first_row_y = it.current_y;
       w->cursor.vpos = -1;
       last_text_row = last_reused_text_row = NULL;
 
@@ -16383,7 +16380,7 @@ With ARG, turn tracing on if and only if ARG is positive.  */)
 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)  */)
-  (int nargs, Lisp_Object *args)
+  (size_t nargs, Lisp_Object *args)
 {
   Lisp_Object s = Fformat (nargs, args);
   fprintf (stderr, "%s", SDATA (s));
@@ -22751,7 +22748,6 @@ x_produce_glyphs (struct it *it)
               int ch = COMPOSITION_GLYPH (cmp, i);
               int face_id;
               struct face *this_face;
-              int this_boff;
 
               if (ch == '\t')
                 ch = ' ';
@@ -22763,9 +22759,6 @@ x_produce_glyphs (struct it *it)
                 pcm = NULL;
               else
                 {
-                  this_boff = font->baseline_offset;
-                  if (font->vertical_centering)
-                    this_boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
                   get_char_face_and_encoding (it->f, ch, face_id,
                                               &char2b, it->multibyte_p, 0);
                   pcm = get_per_char_metric (it->f, font, &char2b);
@@ -24968,10 +24961,9 @@ note_mode_line_or_margin_highlight (Lisp_Object window, int x, int y,
               CONSP (hotspot))
           && (hotspot = XCDR (hotspot), CONSP (hotspot)))
         {
-          Lisp_Object area_id, plist;
+          Lisp_Object plist;
 
-          area_id = XCAR (hotspot);
-          /* Could check AREA_ID to see if we enter/leave this hot-spot.
+          /* Could check XCAR (hotspot) to see if we enter/leave this hot-spot.
              If so, we could look for mouse-enter, mouse-leave
              properties in PLIST (and do something...).  */
           hotspot = XCDR (hotspot);
@@ -25306,10 +25298,10 @@ note_mouse_highlight (struct frame *f, int x, int y)
                       CONSP (hotspot))
                   && (hotspot = XCDR (hotspot), CONSP (hotspot)))
                 {
-                  Lisp_Object area_id, plist;
+                  Lisp_Object plist;
 
-                  area_id = XCAR (hotspot);
-                  /* Could check AREA_ID to see if we enter/leave this hot-spot.
+                  /* Could check XCAR (hotspot) to see if we enter/leave
+                     this hot-spot.
                      If so, we could look for mouse-enter, mouse-leave
                      properties in PLIST (and do something...).  */
                   hotspot = XCDR (hotspot);
diff --git a/src/xselect.c b/src/xselect.c
index 5254fa96838..451b2a0b13f 100644
--- a/src/xselect.c
+++ b/src/xselect.c
@@ -2190,7 +2190,8 @@ and t is the same as `SECONDARY'.  */)
 ***********************************************************************/
 /* Check that lisp values are of correct type for x_fill_property_data.
    That is, number, string or a cons with two numbers (low and high 16
-   bit parts of a 32 bit number).  */
+   bit parts of a 32 bit number).  Return the number of items in DATA,
+   or -1 if there is an error.  */
 
 int
 x_check_property_data (Lisp_Object data)
@@ -2198,15 +2199,16 @@ x_check_property_data (Lisp_Object data)
   Lisp_Object iter;
   int size = 0;
 
-  for (iter = data; CONSP (iter) && size != -1; iter = XCDR (iter), ++size)
+  for (iter = data; CONSP (iter); iter = XCDR (iter))
     {
       Lisp_Object o = XCAR (iter);
 
       if (! NUMBERP (o) && ! STRINGP (o) && ! CONSP (o))
-        size = -1;
+        return -1;
       else if (CONSP (o) &&
                (! NUMBERP (XCAR (o)) || ! NUMBERP (XCDR (o))))
-        size = -1;
+        return -1;
+      size++;
     }
 
   return size;
diff --git a/src/xterm.c b/src/xterm.c
index 0b18356b0a3..dc1fd3cbbd1 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -9121,7 +9121,7 @@ x_make_frame_visible (struct frame *f)
        unknown reason, the call to XtMapWidget is completely ignored.
        Mapping the widget a second time works.  */
 
-    if (!FRAME_VISIBLE_P (f) && --retry_count > 0)
+    if (!FRAME_VISIBLE_P (f) && --retry_count != 0)
       goto retry;
   }
 }
@@ -9726,7 +9726,7 @@ same_x_server (const char *name1, const char *name2)
   for (; *name1 != '\0' && *name1 == *name2; name1++, name2++)
     {
       if (*name1 == ':')
-        seen_colon++;
+        seen_colon = 1;
       if (seen_colon && *name1 == '.')
         return 1;
     }