11 files changed, 49 insertions, 64 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index e5e4fe9edb0..8f23dd3833e 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,21 @@
+2015-01-22  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Don't downcase system diagnostics' first letters
+        * fileio.c (report_file_errno): Don't downcase, and simplify.
+        Fixes: bug#19642
+
+        Isolate NIL_IS_ZERO-assuming code better
+        Suggested by Stefan Monnier in:
+        http://lists.gnu.org/archive/html/emacs-devel/2015-01/msg00588.html
+        * alloc.c (allocate_pseudovector):
+        Use memclear, not memsetnil, to remove a 'verify'.
+        * callint.c (Fcall_interactively):
+        * dispnew.c (realloc_glyph_pool):
+        * xdisp.c (init_iterator):
+        Use memclear, not memset, to remove a 'verify'.
+        * lisp.h (memclear): Rename from memsetnil, and take a byte
+        count rather than a word count.  All callers changed.
+
 2015-01-20  Paul Eggert  <eggert@cs.ucla.edu>
 
         Undo port to hypothetical nonzero Qnil case
diff --git a/src/alloc.c b/src/alloc.c
index bf0456c6862..571b2b03a29 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -3174,11 +3174,8 @@ allocate_pseudovector (int memlen, int lisplen,
   eassert (memlen - lisplen <= (1 << PSEUDOVECTOR_REST_BITS) - 1);
   eassert (lisplen <= (1 << PSEUDOVECTOR_SIZE_BITS) - 1);
 
-  /* Only the first LISPLEN slots will be traced normally by the GC.
-     Since Qnil == 0, we can memset Lisp and non-Lisp data at one go.  */
-  verify (NIL_IS_ZERO);
-  memsetnil (v->contents, zerolen);
-
+  /* Only the first LISPLEN slots will be traced normally by the GC.  */
+  memclear (v->contents, zerolen * word_size);
   XSETPVECTYPESIZE (v, tag, lisplen, memlen - lisplen);
   return v;
 }
diff --git a/src/callint.c b/src/callint.c
index 3a595b57d77..165d374dd62 100644
--- a/src/callint.c
+++ b/src/callint.c
@@ -509,8 +509,7 @@ invoke it.  If KEYS is omitted or nil, the return value of
   visargs = args + nargs;
   varies = (signed char *) (visargs + nargs);
 
-  verify (NIL_IS_ZERO);
-  memset (args, 0, nargs * (2 * word_size + 1));
+  memclear (args, nargs * (2 * word_size + 1));
 
   GCPRO5 (prefix_arg, function, *args, *visargs, up_event);
   gcpro3.nvars = nargs;
diff --git a/src/coding.c b/src/coding.c
index b95c0a5f825..43ebbe06856 100644
--- a/src/coding.c
+++ b/src/coding.c
@@ -11273,7 +11273,7 @@ internal character representation.  */);
 
   {
     Lisp_Object args[coding_arg_undecided_max];
-    memsetnil (args, ARRAYELTS (args));
+    memclear (args, sizeof args);
 
     Lisp_Object plist[16];
     plist[0] = intern_c_string (":name");
diff --git a/src/dispnew.c b/src/dispnew.c
index 8c48ae065ac..e614ceef122 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -1343,14 +1343,8 @@ realloc_glyph_pool (struct glyph_pool *pool, struct dim matrix_dim)
       ptrdiff_t old_nglyphs = pool->nglyphs;
       pool->glyphs = xpalloc (pool->glyphs, &pool->nglyphs,
                               needed - old_nglyphs, -1, sizeof *pool->glyphs);
-
-      /* Redisplay relies on nil as the object of special glyphs
-         (truncation and continuation glyphs and also blanks used to
-         extend each line on a TTY), so verify that memset does this.  */
-      verify (NIL_IS_ZERO);
-
-      memset (pool->glyphs + old_nglyphs, 0,
-              (pool->nglyphs - old_nglyphs) * sizeof *pool->glyphs);
+      memclear (pool->glyphs + old_nglyphs,
+                (pool->nglyphs - old_nglyphs) * sizeof *pool->glyphs);
     }
 
   /* Remember the number of rows and columns because (a) we use them
diff --git a/src/eval.c b/src/eval.c
index ddf6535cabc..e649c152a5d 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -2299,7 +2299,8 @@ usage: (apply FUNCTION &rest ARGUMENTS)  */)
       /* Avoid making funcall cons up a yet another new vector of arguments
          by explicitly supplying nil's for optional values.  */
       SAFE_ALLOCA_LISP (funcall_args, 1 + XSUBR (fun)->max_args);
-      memsetnil (funcall_args + numargs + 1, XSUBR (fun)->max_args - numargs);
+      memclear (funcall_args + numargs + 1,
+                (XSUBR (fun)->max_args - numargs) * word_size);
       funcall_nargs = 1 + XSUBR (fun)->max_args;
     }
   else
@@ -2693,8 +2694,8 @@ usage: (funcall FUNCTION &rest ARGUMENTS)  */)
               eassert (XSUBR (fun)->max_args <= ARRAYELTS (internal_argbuf));
               internal_args = internal_argbuf;
               memcpy (internal_args, args + 1, numargs * word_size);
-              memsetnil (internal_args + numargs,
-                         XSUBR (fun)->max_args - numargs);
+              memclear (internal_args + numargs,
+                        (XSUBR (fun)->max_args - numargs) * word_size);
             }
           else
             internal_args = args + 1;
diff --git a/src/fileio.c b/src/fileio.c
index ff6720d4ae2..d0fd08a742e 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -186,37 +186,17 @@ void
 report_file_errno (char const *string, Lisp_Object name, int errorno)
 {
   Lisp_Object data = CONSP (name) || NILP (name) ? name : list1 (name);
-  Lisp_Object errstring;
-  char *str;
-
   synchronize_system_messages_locale ();
-  str = strerror (errorno);
-  errstring = code_convert_string_norecord (build_unibyte_string (str),
-                                            Vlocale_coding_system, 0);
-
-  while (1)
-    switch (errorno)
-      {
-      case EEXIST:
-        xsignal (Qfile_already_exists, Fcons (errstring, data));
-        break;
-      default:
-        /* System error messages are capitalized.  Downcase the initial
-           unless it is followed by a slash.  (The slash case caters to
-           error messages that begin with "I/O" or, in German, "E/A".)  */
-        if (STRING_MULTIBYTE (errstring)
-            && ! EQ (Faref (errstring, make_number (1)), make_number ('/')))
-          {
-            int c;
-
-            str = SSDATA (errstring);
-            c = STRING_CHAR ((unsigned char *) str);
-            Faset (errstring, make_number (0), make_number (downcase (c)));
-          }
-
-        xsignal (Qfile_error,
-                 Fcons (build_string (string), Fcons (errstring, data)));
-      }
+  char *str = strerror (errorno);
+  Lisp_Object errstring
+    = code_convert_string_norecord (build_unibyte_string (str),
+                                    Vlocale_coding_system, 0);
+  Lisp_Object errdata = Fcons (errstring, data);
+
+  if (errorno == EEXIST)
+    xsignal (Qfile_already_exists, errdata);
+  else
+    xsignal (Qfile_error, Fcons (build_string (string), errdata));
 }
 
 /* Signal a file-access failure that set errno.  STRING describes the
diff --git a/src/fns.c b/src/fns.c
index d177294480a..a4b2e6d8e85 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -2524,7 +2524,7 @@ mapcar1 (EMACS_INT leni, Lisp_Object *vals, Lisp_Object fn, Lisp_Object seq)
   if (vals)
     {
       /* Don't let vals contain any garbage when GC happens.  */
-      memsetnil (vals, leni);
+      memclear (vals, leni * word_size);
 
       GCPRO3 (dummy, fn, seq);
       gcpro1.var = vals;
@@ -3700,7 +3700,7 @@ larger_vector (Lisp_Object vec, ptrdiff_t incr_min, ptrdiff_t nitems_max)
   new_size = old_size + incr;
   v = allocate_vector (new_size);
   memcpy (v->contents, XVECTOR (vec)->contents, old_size * sizeof *v->contents);
-  memsetnil (v->contents + old_size, new_size - old_size);
+  memclear (v->contents + old_size, incr * word_size);
   XSETVECTOR (vec, v);
   return vec;
 }
diff --git a/src/font.c b/src/font.c
index 190b33a8ef0..d05742ce2bf 100644
--- a/src/font.c
+++ b/src/font.c
@@ -989,14 +989,14 @@ font_expand_wildcards (Lisp_Object *field, int n)
           if (i == 0 || ! NILP (tmp[i - 1]))
             /* None of TMP[X] corresponds to Jth field.  */
             return -1;
-          memsetnil (field + j, range[i].from - j);
+          memclear (field + j, (range[i].from - j) * word_size);
           j = range[i].from;
         }
       field[j++] = tmp[i];
     }
   if (! NILP (tmp[n - 1]) && j < XLFD_REGISTRY_INDEX)
     return -1;
-  memsetnil (field + j, XLFD_LAST_INDEX - j);
+  memclear (field + j, (XLFD_LAST_INDEX - j) * word_size);
   if (INTEGERP (field[XLFD_ENCODING_INDEX]))
     field[XLFD_ENCODING_INDEX]
       = Fintern (Fnumber_to_string (field[XLFD_ENCODING_INDEX]), Qnil);
diff --git a/src/lisp.h b/src/lisp.h
index f1e6945f43a..76a9ed8f159 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -1513,13 +1513,15 @@ gc_aset (Lisp_Object array, ptrdiff_t idx, Lisp_Object val)
    to find such assumptions later if we change Qnil to be nonzero.  */
 enum { NIL_IS_ZERO = XLI_BUILTIN_LISPSYM (iQnil) == 0 };
 
-/* Set a Lisp_Object array V's N entries to nil.  */
+/* Clear the object addressed by P, with size NBYTES, so that all its
+   bytes are zero and all its Lisp values are nil.  */
 INLINE void
-memsetnil (Lisp_Object *v, ptrdiff_t n)
+memclear (void *p, ptrdiff_t nbytes)
 {
-  eassert (0 <= n);
+  eassert (0 <= nbytes);
   verify (NIL_IS_ZERO);
-  memset (v, 0, n * sizeof *v);
+  /* Since Qnil is zero, memset suffices.  */
+  memset (p, 0, nbytes);
 }
 
 /* If a struct is made to look like a vector, this macro returns the length
diff --git a/src/xdisp.c b/src/xdisp.c
index 5e57e0588cf..280be6bd7a1 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -2752,13 +2752,7 @@ init_iterator (struct it *it, struct window *w,
         row = MATRIX_HEADER_LINE_ROW (w->desired_matrix);
     }
 
-  /* Clear IT.  */
-
-  /* The code assumes it->object and other Lisp_Object components are
-     set to nil, so verify that memset does this.  */
-  verify (NIL_IS_ZERO);
-  memset (it, 0, sizeof *it);
-
+  memclear (it, sizeof *it);
   it->current.overlay_string_index = -1;
   it->current.dpvec_index = -1;
   it->base_face_id = remapped_base_face_id;