2 files changed, 59 insertions, 46 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 773a09121fd..6889fa9b4e6 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,13 @@
+2014-04-01  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * fns.c (validate_subarray): Rename from validate_substring,
+        since it works for vectors too.  New arg ARRAY.  Optimize for the
+        non-nil case.  Instead of returning bool, throw an error if out of
+        range, so that the caller needn't do that.  All uses changed.
+        Report original values if out of range.
+        (Fsubstring, Fsubstring_no_properties, secure_hash):
+        Also optimize the case where FROM is 0 or TO is the size.
+
 2014-03-31  Dmitry Antipov  <dmantipov@yandex.ru>
 
         * search.c (Freplace_match): Use make_specified_string.
diff --git a/src/fns.c b/src/fns.c
index b0aafc40dd0..53819ed23aa 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -1127,36 +1127,45 @@ Elements of ALIST that are not conses are also shared.  */)
   return alist;
 }
 
-/* True if [FROM..TO) specifies a valid substring of SIZE-characters string.
-   If FROM is nil, 0 assumed.  If TO is nil, SIZE assumed.  Negative
-   values are counted from the end.  *FROM_CHAR and *TO_CHAR are updated
-   with corresponding C values of TO and FROM.  */
+/* Check that ARRAY can have a valid subarray [FROM..TO),
+   given that its size is SIZE.
+   If FROM is nil, use 0; if TO is nil, use SIZE.
+   Count negative values backwards from the end.
+   Set *IFROM and *ITO to the two indexes used.  */
 
-static bool
-validate_substring (Lisp_Object from, Lisp_Object to, ptrdiff_t size,
-                    EMACS_INT *from_char, EMACS_INT *to_char)
+static void
+validate_subarray (Lisp_Object array, Lisp_Object from, Lisp_Object to,
+                   ptrdiff_t size, EMACS_INT *ifrom, EMACS_INT *ito)
 {
-  if (NILP (from))
-    *from_char = 0;
-  else
+  EMACS_INT f, t;
+
+  if (INTEGERP (from))
     {
-      CHECK_NUMBER (from);
-      *from_char = XINT (from);
-      if (*from_char < 0)
-        *from_char += size;
+      f = XINT (from);
+      if (f < 0)
+        f += size;
     }
-
-  if (NILP (to))
-    *to_char = size;
+  else if (NILP (from))
+    f = 0;
   else
+    wrong_type_argument (Qintegerp, from);
+
+  if (INTEGERP (to))
     {
-      CHECK_NUMBER (to);
-      *to_char = XINT (to);
-      if (*to_char < 0)
-        *to_char += size;
+      t = XINT (to);
+      if (t < 0)
+        t += size;
     }
+  else if (NILP (to))
+    t = size;
+  else
+    wrong_type_argument (Qintegerp, to);
+
+  if (! (0 <= f && f <= t && t <= size))
+    args_out_of_range_3 (array, from, to);
 
-  return (0 <= *from_char && *from_char <= *to_char && *to_char <= size);
+  *ifrom = f;
+  *ito = t;
 }
 
 DEFUN ("substring", Fsubstring, Ssubstring, 1, 3, 0,
@@ -1176,7 +1185,7 @@ With one argument, just copy STRING (with properties, if any).  */)
 {
   Lisp_Object res;
   ptrdiff_t size;
-  EMACS_INT from_char, to_char;
+  EMACS_INT ifrom, ito;
 
   if (STRINGP (string))
     size = SCHARS (string);
@@ -1184,24 +1193,23 @@ With one argument, just copy STRING (with properties, if any).  */)
     size = ASIZE (string);
   else
     wrong_type_argument (Qarrayp, string);
-  
-  if (!validate_substring (from, to, size, &from_char, &to_char))
-    args_out_of_range_3 (string, make_number (from_char),
-                         make_number (to_char));
+
+  validate_subarray (string, from, to, size, &ifrom, &ito);
 
   if (STRINGP (string))
     {
-      ptrdiff_t to_byte =
-        (NILP (to) ? SBYTES (string) : string_char_to_byte (string, to_char));
-      ptrdiff_t from_byte = string_char_to_byte (string, from_char);
+      ptrdiff_t from_byte
+        = !ifrom ? 0 : string_char_to_byte (string, ifrom);
+      ptrdiff_t to_byte
+        = ito == size ? SBYTES (string) : string_char_to_byte (string, ito);
       res = make_specified_string (SSDATA (string) + from_byte,
-                                   to_char - from_char, to_byte - from_byte,
+                                   ito - ifrom, to_byte - from_byte,
                                    STRING_MULTIBYTE (string));
-      copy_text_properties (make_number (from_char), make_number (to_char),
+      copy_text_properties (make_number (ifrom), make_number (ito),
                             string, make_number (0), res, Qnil);
     }
   else
-    res = Fvector (to_char - from_char, aref_addr (string, from_char));
+    res = Fvector (ito - ifrom, aref_addr (string, ifrom));
 
   return res;
 }
@@ -1224,14 +1232,11 @@ With one argument, just copy STRING without its properties.  */)
   CHECK_STRING (string);
 
   size = SCHARS (string);
+  validate_subarray (string, from, to, size, &from_char, &to_char);
 
-  if (!validate_substring (from, to, size, &from_char, &to_char))
-    args_out_of_range_3 (string, make_number (from_char),
-                         make_number (to_char));
-
-  from_byte = NILP (from) ? 0 : string_char_to_byte (string, from_char);
+  from_byte = !from_char ? 0 : string_char_to_byte (string, from_char);
   to_byte =
-    NILP (to) ? SBYTES (string) : string_char_to_byte (string, to_char);
+    to_char == size ? SBYTES (string) : string_char_to_byte (string, to_char);
   return make_specified_string (SSDATA (string) + from_byte,
                                 to_char - from_char, to_byte - from_byte,
                                 STRING_MULTIBYTE (string));
@@ -4612,14 +4617,12 @@ secure_hash (Lisp_Object algorithm, Lisp_Object object, Lisp_Object start, Lisp_
         object = code_convert_string (object, coding_system, Qnil, 1, 0, 1);
 
       size = SCHARS (object);
+      validate_subarray (object, start, end, size, &start_char, &end_char);
 
-      if (!validate_substring (start, end, size, &start_char, &end_char))
-        args_out_of_range_3 (object, make_number (start_char),
-                             make_number (end_char));
-
-      start_byte = NILP (start) ? 0 : string_char_to_byte (object, start_char);
-      end_byte =
-        NILP (end) ? SBYTES (object) : string_char_to_byte (object, end_char);
+      start_byte = !start_char ? 0 : string_char_to_byte (object, start_char);
+      end_byte = (end_char == size
+                  ? SBYTES (object)
+                  : string_char_to_byte (object, end_char));
     }
   else
     {