Merge from mainline.

17 files changed, 367 insertions, 148 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 9f3c8e6c498..da2995840da 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -228,7 +228,7 @@
 2011-04-06  Juanma Barranquero  <lekktu@gmail.com>
 
         * files.el (after-find-file-from-revert-buffer): Remove variable.
-        (after-find-file): Dont' bind it.
+        (after-find-file): Don't bind it.
         (revert-buffer-in-progress-p): New variable.
         (revert-buffer): Bind it.
         Pass nil for `after-find-file-from-revert-buffer'.
diff --git a/lisp/gnus/ChangeLog b/lisp/gnus/ChangeLog
index be6f3737ae1..eac53d413cc 100644
--- a/lisp/gnus/ChangeLog
+++ b/lisp/gnus/ChangeLog
@@ -1,3 +1,23 @@
+2011-04-16  Teodor Zlatanov  <tzz@lifelogs.com>
+
+        * registry.el (registry-reindex): New method to recreate the secondary
+        registry indices.
+
+        * gnus-registry.el (gnus-registry-fixup-registry): Use it if the
+        tracked field changes.
+        (gnus-registry-unfollowed-addresses, gnus-registry-track-extra)
+        (gnus-registry-action, gnus-registry-spool-action)
+        (gnus-registry-handle-action)
+        (gnus-registry--split-fancy-with-parent-internal)
+        (gnus-registry-split-fancy-with-parent)
+        (gnus-registry-register-message-ids): Add recipient tracking on spool,
+        move, and delete actions, and for fancy splitting with parent.
+        (gnus-registry-extract-addresses)
+        (gnus-registry-fetch-recipients-fast)
+        (gnus-registry-fetch-header-fast): Convenience functions.
+        (gnus-registry-misc-test): ERT test of
+        `gnus-registry-extract-addresses'.
+
 2011-04-15  Teodor Zlatanov  <tzz@lifelogs.com>
 
         * gnus-registry.el (gnus-registry--split-fancy-with-parent-internal):
diff --git a/lisp/gnus/gnus-registry.el b/lisp/gnus/gnus-registry.el
index 77ed5a55aed..eab4403c34b 100644
--- a/lisp/gnus/gnus-registry.el
+++ b/lisp/gnus/gnus-registry.el
@@ -36,7 +36,7 @@
 ;; Put this in your startup file (~/.gnus.el for instance) or use Customize:
 
 ;; (setq gnus-registry-max-entries 2500
-;;       gnus-registry-track-extra '(sender subject))
+;;       gnus-registry-track-extra '(sender subject recipient))
 
 ;; (gnus-registry-initialize)
 
@@ -119,7 +119,9 @@ display.")
 (defcustom gnus-registry-unfollowed-addresses
   (list (regexp-quote user-mail-address))
   "List of addresses that gnus-registry-split-fancy-with-parent won't trace.
-The addresses are matched, they don't have to be fully qualified."
+The addresses are matched, they don't have to be fully qualified.
+In the messages, these addresses can be the sender or the
+recipients."
   :group 'gnus-registry
   :type '(repeat regexp))
 
@@ -152,14 +154,15 @@ nnmairix groups are specifically excluded because they are ephemeral."
 (make-obsolete-variable 'gnus-registry-entry-caching nil "23.4")
 (make-obsolete-variable 'gnus-registry-trim-articles-without-groups nil "23.4")
 
-(defcustom gnus-registry-track-extra '(subject sender)
+(defcustom gnus-registry-track-extra '(subject sender recipient)
   "Whether the registry should track extra data about a message.
-The Subject and Sender (From:) headers are tracked this way by
-default."
+The subject, recipients (To: and Cc:), and Sender (From:) headers
+are tracked this way by default."
   :group 'gnus-registry
   :type
   '(set :tag "Tracking choices"
     (const :tag "Track by subject (Subject: header)" subject)
+    (const :tag "Track by recipient (To: and Cc: headers)" recipient)
     (const :tag "Track by sender (From: header)"  sender)))
 
 (defcustom gnus-registry-split-strategy nil
@@ -224,18 +227,22 @@ the Bit Bucket."
 
 (defun gnus-registry-fixup-registry (db)
   (when db
-    (oset db :precious
-          (append gnus-registry-extra-entries-precious
-                  '()))
-    (oset db :max-hard
-          (or gnus-registry-max-entries
-              most-positive-fixnum))
-    (oset db :max-soft
-          (or gnus-registry-max-pruned-entries
-              most-positive-fixnum))
-    (oset db :tracked
-          (append gnus-registry-track-extra
-                  '(mark group keyword))))
+    (let ((old (oref db :tracked)))
+      (oset db :precious
+            (append gnus-registry-extra-entries-precious
+                    '()))
+      (oset db :max-hard
+            (or gnus-registry-max-entries
+                most-positive-fixnum))
+      (oset db :max-soft
+            (or gnus-registry-max-pruned-entries
+                most-positive-fixnum))
+      (oset db :tracked
+            (append gnus-registry-track-extra
+                    '(mark group keyword)))
+      (when (not (equal old (oref db :tracked)))
+        (gnus-message 4 "Reindexing the Gnus registry (tracked change)")
+        (registry-reindex db))))
   db)
 
 (defun gnus-registry-make-db (&optional file)
@@ -296,7 +303,17 @@ This is not required after changing `gnus-registry-cache-file'."
 (defun gnus-registry-action (action data-header from &optional to method)
   (let* ((id (mail-header-id data-header))
          (subject (mail-header-subject data-header))
-         (sender (mail-header-from data-header))
+         (recipients (sort (mapcan 'gnus-registry-extract-addresses
+                                   (list
+                                    (or (ignore-errors
+                                          (mail-header "Cc" data-header))
+                                        "")
+                                    (or (ignore-errors
+                                          (mail-header "To" data-header))
+                                        "")))
+                           'string-lessp))
+         (sender (nth 0 (gnus-registry-extract-addresses
+                         (mail-header-from data-header))))
          (from (gnus-group-guess-full-name-from-command-method from))
          (to (if to (gnus-group-guess-full-name-from-command-method to) nil))
          (to-name (if to to "the Bit Bucket")))
@@ -307,10 +324,16 @@ This is not required after changing `gnus-registry-cache-file'."
      id
      ;; unless copying, remove the old "from" group
      (if (not (equal 'copy action)) from nil)
-     to subject sender)))
+     to subject sender recipients)))
 
-(defun gnus-registry-spool-action (id group &optional subject sender)
+(defun gnus-registry-spool-action (id group &optional subject sender recipients)
   (let ((to (gnus-group-guess-full-name-from-command-method group))
+        (recipients (or recipients
+                        (sort (mapcan 'gnus-registry-extract-addresses
+                                      (list
+                                       (or (message-fetch-field "cc") "")
+                                       (or (message-fetch-field "to") "")))
+                              'string-lessp)))
         (subject (or subject (message-fetch-field "subject")))
         (sender (or sender (message-fetch-field "from"))))
     (when (and (stringp id) (string-match "\r$" id))
@@ -318,12 +341,13 @@ This is not required after changing `gnus-registry-cache-file'."
     (gnus-message 7 "Gnus registry: article %s spooled to %s"
                   id
                   to)
-    (gnus-registry-handle-action id nil to subject sender)))
+    (gnus-registry-handle-action id nil to subject sender recipients)))
 
-(defun gnus-registry-handle-action (id from to subject sender)
+(defun gnus-registry-handle-action (id from to subject sender
+                                       &optional recipients)
   (gnus-message
    10
-   "gnus-registry-handle-action %S" (list id from to subject sender))
+   "gnus-registry-handle-action %S" (list id from to subject sender recipients))
   (let ((db gnus-registry-db)
         ;; safe if not found
         (entry (gnus-registry-get-or-make-entry id))
@@ -340,11 +364,15 @@ This is not required after changing `gnus-registry-cache-file'."
       (setq entry (cons (delete from (assoc 'group entry))
                         (assq-delete-all 'group entry))))
 
-    (dolist (kv `((group ,to) (sender ,sender) (subject ,subject)))
+    (dolist (kv `((group ,to)
+                  (sender ,sender)
+                  (recipient ,@recipients)
+                  (subject ,subject)))
       (when (second kv)
         (let ((new (or (assq (first kv) entry)
                        (list (first kv)))))
-          (add-to-list 'new (second kv) t)
+          (dolist (toadd (cdr kv))
+            (add-to-list 'new toadd t))
           (setq entry (cons new
                             (assq-delete-all (first kv) entry))))))
     (gnus-message 10 "Gnus registry: new entry for %s is %S"
@@ -381,6 +409,11 @@ See the Info node `(gnus)Fancy Mail Splitting' for more details."
          ;; these may not be used, but the code is cleaner having them up here
          (sender (gnus-string-remove-all-properties
                   (message-fetch-field "from")))
+         (recipients (sort (mapcan 'gnus-registry-extract-addresses
+                                   (list
+                                    (or (message-fetch-field "cc") "")
+                                    (or (message-fetch-field "to") "")))
+                           'string-lessp))
          (subject (gnus-string-remove-all-properties
                    (gnus-registry-simplify-subject
                     (message-fetch-field "subject"))))
@@ -393,12 +426,13 @@ See the Info node `(gnus)Fancy Mail Splitting' for more details."
      :references references
      :refstr refstr
      :sender sender
+     :recipients recipients
      :subject subject
      :log-agent "Gnus registry fancy splitting with parent")))
 
 (defun* gnus-registry--split-fancy-with-parent-internal
     (&rest spec
-           &key references refstr sender subject log-agent
+           &key references refstr sender subject recipients log-agent
            &allow-other-keys)
   (gnus-message
    10
@@ -478,6 +512,36 @@ See the Info node `(gnus)Fancy Mail Splitting' for more details."
        (setq found (gnus-registry-post-process-groups
                     "sender" sender found)))
 
+     ;; else: there were no matches, try the extra tracking by recipient
+     (when (and (null found)
+                (memq 'recipient gnus-registry-track-extra)
+                recipients)
+       (dolist (recp recipients)
+         (when (and (null found)
+                    (not (gnus-grep-in-list
+                          recp
+                          gnus-registry-unfollowed-addresses)))
+           (let ((groups (apply 'append
+                                (mapcar
+                                 (lambda (reference)
+                                   (gnus-registry-get-id-key reference 'group))
+                                 (registry-lookup-secondary-value
+                                  db 'recipient recp)))))
+             (setq found
+                   (loop for group in groups
+                         when (gnus-registry-follow-group-p group)
+                         do (gnus-message
+                             ;; warn more if gnus-registry-track-extra
+                             (if gnus-registry-track-extra 7 9)
+                             "%s (extra tracking) traced recipient '%s' to %s"
+                             log-agent recp group)
+                         collect group)))))
+
+       ;; filter the found groups and return them
+       ;; the found groups are NOT the full groups
+       (setq found (gnus-registry-post-process-groups
+                    "recipients" (mapconcat 'identity recipients ", ") found)))
+
      ;; after the (cond) we extract the actual value safely
      (car-safe found)))
 
@@ -629,7 +693,8 @@ Overrides existing keywords with FORCE set non-nil."
                         article gnus-newsgroup-name)
           (gnus-registry-handle-action id nil gnus-newsgroup-name
            (gnus-registry-fetch-simplified-message-subject-fast article)
-           (gnus-registry-fetch-sender-fast article)))))))
+           (gnus-registry-fetch-sender-fast article)
+           (gnus-registry-fetch-recipients-fast article)))))))
 
 ;; message field fetchers
 (defun gnus-registry-fetch-message-id-fast (article)
@@ -639,6 +704,21 @@ Overrides existing keywords with FORCE set non-nil."
       (mail-header-id (gnus-data-header (assoc article (gnus-data-list nil))))
     nil))
 
+(defun gnus-registry-extract-addresses (text)
+  "Extract all the addresses in a normalized way from TEXT.
+Returns an unsorted list of strings in the name <address> format.
+Addresses without a name will say \"noname\"."
+  (mapcar (lambda (add)
+            (gnus-string-remove-all-properties
+             (let* ((name (or (nth 0 add) "noname"))
+                    (addr (nth 1 add))
+                    (addr (if (bufferp addr)
+                              (with-current-buffer addr
+                                (buffer-string))
+                            addr)))
+               (format "%s <%s>" name addr))))
+          (mail-extract-address-components text t)))
+
 (defun gnus-registry-simplify-subject (subject)
   (if (stringp subject)
       (gnus-simplify-subject subject)
@@ -655,12 +735,26 @@ Overrides existing keywords with FORCE set non-nil."
     nil))
 
 (defun gnus-registry-fetch-sender-fast (article)
-  "Fetch the Sender quickly, using the internal gnus-data-list function"
+  (gnus-registry-fetch-header-fast "from" article))
+
+(defun gnus-registry-fetch-recipients-fast (article)
+  (sort (mapcan 'gnus-registry-extract-addresses
+                (list
+                 (or (ignore-errors
+                       (gnus-registry-fetch-header-fast "Cc" article))
+                     "")
+                 (or (ignore-errors
+                       (gnus-registry-fetch-header-fast "To" article))
+                     "")))
+        'string-lessp))
+
+(defun gnus-registry-fetch-header-fast (article header)
+  "Fetch the HEADER quickly, using the internal gnus-data-list function"
   (if (and (numberp article)
            (assoc article (gnus-data-list nil)))
       (gnus-string-remove-all-properties
-       (mail-header-from (gnus-data-header
-                          (assoc article (gnus-data-list nil)))))
+       (mail-header header (gnus-data-header
+                            (assoc article (gnus-data-list nil)))))
     nil))
 
 ;; registry marks glue
@@ -902,6 +996,19 @@ only the last one's marks are returned."
             (gnus-registry-set-id-key id key val))))
       (message "Import done, collected %d entries" count))))
 
+(ert-deftest gnus-registry-misc-test ()
+  (should-error (gnus-registry-extract-addresses '("" "")))
+
+  (should (equal '("Ted Zlatanov <tzz@lifelogs.com>"
+                   "noname <ed@you.me>"
+                   "noname <cyd@stupidchicken.com>"
+                   "noname <tzz@lifelogs.com>")
+                 (gnus-registry-extract-addresses
+                  (concat "Ted Zlatanov <tzz@lifelogs.com>, "
+                          "ed <ed@you.me>, " ; "ed" is not a valid name here
+                          "cyd@stupidchicken.com, "
+                          "tzz@lifelogs.com")))))
+
 (ert-deftest gnus-registry-usage-test ()
   (let* ((n 100)
          (tempfile (make-temp-file "gnus-registry-persist"))
diff --git a/lisp/gnus/registry.el b/lisp/gnus/registry.el
index 23e75815979..3e638427897 100644
--- a/lisp/gnus/registry.el
+++ b/lisp/gnus/registry.el
@@ -281,6 +281,25 @@ Errors out if the key exists already."
         (registry-lookup-secondary-value db tr val value-keys))))
   entry)
 
+(defmethod registry-reindex ((db registry-db))
+  "Rebuild the secondary indices of registry-db THIS."
+  (let ((count 0)
+        (expected (* (length (oref db :tracked)) (registry-size db))))
+    (dolist (tr (oref db :tracked))
+      (let (values)
+        (maphash
+         (lambda (key v)
+           (incf count)
+           (when (and (< 0 expected)
+                      (= 0 (mod count 1000)))
+             (message "reindexing: %d of %d (%.2f%%)"
+                      count expected (/ (* 1000 count) expected)))
+           (dolist (val (cdr-safe (assq tr v)))
+             (let* ((value-keys (registry-lookup-secondary-value db tr val)))
+               (push key value-keys)
+               (registry-lookup-secondary-value db tr val value-keys))))
+         (oref db :data))))))
+
 (defmethod registry-size ((db registry-db))
   "Returns the size of the registry-db object THIS.
 This is the key count of the :data slot."
@@ -360,10 +379,11 @@ Removes only entries without the :precious keys."
     (when (boundp 'lexical-binding)
       (message "Individual lookup (breaks before lexbind)")
       (should (= 58
-                 (caadr (registry-lookup-breaks-before-lexbind db '(1 58 99)))))
+                 (caadr (registry-lookup-breaks-before-lexbind db '(1 58 99)))))
       (message "Grouped individual lookup (breaks before lexbind)")
       (should (= 3
-                 (length (registry-lookup-breaks-before-lexbind db '(1 58 99))))))
+                 (length (registry-lookup-breaks-before-lexbind db
+                                                                '(1 58 99))))))
     (message "Search")
     (should (= n (length (registry-search db :all t))))
     (should (= n (length (registry-search db :member '((sender "me"))))))
diff --git a/lisp/url/ChangeLog b/lisp/url/ChangeLog
index f75a3444e0c..528b63a6448 100644
--- a/lisp/url/ChangeLog
+++ b/lisp/url/ChangeLog
@@ -1,3 +1,8 @@
+2011-04-16  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * url-http.el (url-http-wait-for-headers-change-function): Protect
+        against malformed headerless responses from servers.
+
 2011-04-02  Chong Yidong  <cyd@stupidchicken.com>
 
         * url-gw.el (url-open-stream): Use new open-network-stream
diff --git a/lisp/url/url-http.el b/lisp/url/url-http.el
index 07e57cf3301..28071e7165a 100644
--- a/lisp/url/url-http.el
+++ b/lisp/url/url-http.el
@@ -1077,6 +1077,10 @@ the end of the document."
                 (downcase url-http-transfer-encoding)))
 
         (cond
+         ((null url-http-response-status)
+          ;; We got back a headerless malformed response from the
+          ;; server.
+          (url-http-activate-callback))
          ((or (= url-http-response-status 204)
               (= url-http-response-status 205))
           (url-http-debug "%d response must have headers only (%s)."
diff --git a/src/ChangeLog b/src/ChangeLog
index 61509caf744..52a48a87e80 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -101,6 +101,52 @@
         * xdisp.c, dispextern.h (set_vertical_scroll_bar): Now extern if
         USE_TOOLKIT_SCROLL_BARS && !USE_GTK, as xterm.c needs it then.
 
+2011-04-16  Eli Zaretskii  <eliz@gnu.org>
+
+        * gnutls.c (Fgnutls_boot): Don't pass Lisp_Object to `error'.
+
+        Fix regex.c, syntax.c and friends for buffers > 2GB.
+        * syntax.h (struct gl_state_s): Declare character position members
+        EMACS_INT.
+
+        * syntax.c (update_syntax_table): Declare 2nd argument EMACS_INT.
+
+        * textprop.c (verify_interval_modification, interval_of): Declare
+        arguments EMACS_INT.
+
+        * intervals.c (adjust_intervals_for_insertion): Declare arguments
+        EMACS_INT.
+
+        * intervals.h (CHECK_TOTAL_LENGTH): Cast to EMACS_INT, not `int'.
+
+        * indent.c (Fvertical_motion): Local variable it_start is now
+        EMACS_INT.
+
+        * regex.c (re_match, re_match_2, re_match_2_internal)
+        (bcmp_translate, regcomp, regexec, print_double_string)
+        (group_in_compile_stack, re_search, re_search_2, regex_compile)
+        (re_compile_pattern, re_exec): Declare arguments and local
+        variables `size_t' and `ssize_t' and return values `regoff_t', as
+        appropriate.
+        (POP_FAILURE_REG_OR_COUNT) <pfreg>: Declare `long'.
+        (CHECK_INFINITE_LOOP) <failure>: Declare `ssize_t'.
+        <compile_stack_type>: `size' and `avail' are now `size_t'.
+
+        * regex.h <regoff_t>: Use ssize_t, not int.
+        (re_search, re_search_2, re_match, re_match_2): Arguments that
+        specify buffer/string position and length are now ssize_t and
+        size_t.  Return type is regoff_t.
+
+2011-04-16  Ben Key  <bkey76@gmail.com>
+
+        * nsfont.m: Fixed bugs in ns_get_family and
+        ns_descriptor_to_entity that were caused by using free to
+        deallocate memory blocks that were allocated by xmalloc (via
+        xstrdup).  This caused Emacs to crash when compiled with
+        XMALLOC_OVERRUN_CHECK defined (when Emacs was configured with
+        --enable-checking=xmallocoverrun).  xfree is now used to
+        deallocate these memory blocks.
+
 2011-04-15  Paul Eggert  <eggert@cs.ucla.edu>
 
         * sysdep.c (emacs_read): Remove unnecessary check vs MAX_RW_COUNT.
@@ -132,10 +178,10 @@
 
 2011-04-15  Ben Key  <bkey76@gmail.com>
 
-        * keyboard.c (Qundefined):  Don't declare static since it is
-        used in nsfns.m.
-        * xfaces.c (Qbold, Qexpanded, Qitalic, Qcondensed):  Don't
-        declare static since they are used in nsfont.m.
+        * keyboard.c (Qundefined): Don't declare static since it is used
+        in nsfns.m.
+        * xfaces.c (Qbold, Qexpanded, Qitalic, Qcondensed): Don't declare
+        static since they are used in nsfont.m.
 
 2011-04-15  Stefan Monnier  <monnier@iro.umontreal.ca>
 
diff --git a/src/gnutls.c b/src/gnutls.c
index d7328e114c7..f4f2b9bbd35 100644
--- a/src/gnutls.c
+++ b/src/gnutls.c
@@ -456,7 +456,7 @@ one trustfile (usually a CA bundle).  */)
           else
             {
               error ("Sorry, GnuTLS can't use non-string trustfile %s",
-                     trustfile);
+                     SDATA (trustfile));
             }
         }
 
@@ -478,7 +478,7 @@ one trustfile (usually a CA bundle).  */)
           else
             {
               error ("Sorry, GnuTLS can't use non-string keyfile %s",
-                     keyfile);
+                     SDATA (keyfile));
             }
         }
     }
diff --git a/src/indent.c b/src/indent.c
index 0bfe2e61ca6..094f6dabd55 100644
--- a/src/indent.c
+++ b/src/indent.c
@@ -2026,7 +2026,8 @@ whether or not it is currently displayed in some window.  */)
     }
   else
     {
-      int it_start, first_x, it_overshoot_expected IF_LINT (= 0);
+      EMACS_INT it_start;
+      int first_x, it_overshoot_expected IF_LINT (= 0);
 
       SET_TEXT_POS (pt, PT, PT_BYTE);
       start_display (&it, w, pt);
diff --git a/src/intervals.c b/src/intervals.c
index 3be6e2d1ffa..7ce1796d8eb 100644
--- a/src/intervals.c
+++ b/src/intervals.c
@@ -805,9 +805,9 @@ update_interval (register INTERVAL i, EMACS_INT pos)
 static INTERVAL
 adjust_intervals_for_insertion (tree, position, length)
      INTERVAL tree;
-     int position, length;
+     EMACS_INT position, length;
 {
-  register int relative_position;
+  register EMACS_INT relative_position;
   register INTERVAL this;
 
   if (TOTAL_LENGTH (tree) == 0) /* Paranoia */
diff --git a/src/intervals.h b/src/intervals.h
index f1679eb8b40..6cf5c89374b 100644
--- a/src/intervals.h
+++ b/src/intervals.h
@@ -161,12 +161,12 @@ struct interval
    (INTERVAL_HAS_PARENT (i) ? INTERVAL_PARENT (i) : 0)
 
 /* Abort if interval I's size is negative.  */
-#define CHECK_TOTAL_LENGTH(i)          \
-  do                                   \
-    {                                  \
-      if ((int) (i)->total_length < 0) \
-        abort ();                      \
-    }                                  \
+#define CHECK_TOTAL_LENGTH(i)                \
+  do                                         \
+    {                                        \
+      if ((EMACS_INT) (i)->total_length < 0) \
+        abort ();                            \
+    }                                        \
   while (0)
 
 /* Reset this interval to its vanilla, or no-property state. */
@@ -269,7 +269,8 @@ extern INTERVAL merge_interval_left (INTERVAL);
 extern void offset_intervals (struct buffer *, EMACS_INT, EMACS_INT);
 extern void graft_intervals_into_buffer (INTERVAL, EMACS_INT, EMACS_INT,
                                          struct buffer *, int);
-extern void verify_interval_modification (struct buffer *, int, int);
+extern void verify_interval_modification (struct buffer *,
+                                          EMACS_INT, EMACS_INT);
 extern INTERVAL balance_intervals (INTERVAL);
 extern void copy_intervals_to_string (Lisp_Object, struct buffer *,
                                              EMACS_INT, EMACS_INT);
@@ -285,7 +286,7 @@ extern INTERVAL update_interval (INTERVAL, EMACS_INT);
 extern void set_intervals_multibyte (int);
 extern INTERVAL validate_interval_range (Lisp_Object, Lisp_Object *,
                                          Lisp_Object *, int);
-extern INTERVAL interval_of (int, Lisp_Object);
+extern INTERVAL interval_of (EMACS_INT, Lisp_Object);
 
 /* Defined in xdisp.c */
 extern int invisible_p (Lisp_Object, Lisp_Object);
diff --git a/src/nsfont.m b/src/nsfont.m
index 48d40223553..76c70aadf9f 100644
--- a/src/nsfont.m
+++ b/src/nsfont.m
@@ -104,7 +104,7 @@ ns_get_family (Lisp_Object font_spec)
       NSString *family;
       ns_unescape_name (tmp);
       family = [NSString stringWithUTF8String: tmp];
-      free (tmp);
+      xfree (tmp);
       return family;
     }
 }
@@ -217,7 +217,7 @@ ns_descriptor_to_entity (NSFontDescriptor *desc,
         debug_print (font_entity);
       }
 
-    free (escapedFamily);
+    xfree (escapedFamily);
     return font_entity;
 }
 
diff --git a/src/regex.c b/src/regex.c
index a60ff0ce35c..479239897bc 100644
--- a/src/regex.c
+++ b/src/regex.c
@@ -569,12 +569,12 @@ typedef char boolean;
 #define false 0
 #define true 1
 
-static int re_match_2_internal _RE_ARGS ((struct re_pattern_buffer *bufp,
-                                        re_char *string1, int size1,
-                                        re_char *string2, int size2,
-                                        int pos,
-                                        struct re_registers *regs,
-                                        int stop));
+static regoff_t re_match_2_internal _RE_ARGS ((struct re_pattern_buffer *bufp,
+                                               re_char *string1, size_t size1,
+                                               re_char *string2, size_t size2,
+                                               ssize_t pos,
+                                               struct re_registers *regs,
+                                               ssize_t stop));
 
 /* These are the command codes that appear in compiled regular
    expressions.  Some opcodes are followed by argument bytes.  A
@@ -1230,10 +1230,10 @@ print_double_string (where, string1, size1, string2, size2)
     re_char *where;
     re_char *string1;
     re_char *string2;
-    int size1;
-    int size2;
+    ssize_t size1;
+    ssize_t size2;
 {
-  int this_char;
+  ssize_t this_char;
 
   if (where == NULL)
     printf ("(null)");
@@ -1546,7 +1546,7 @@ do {									\
 /* Pop a saved register off the stack.  */
 #define POP_FAILURE_REG_OR_COUNT()                                      \
 do {                                                                    \
-  int pfreg = POP_FAILURE_INT ();                                       \
+  long pfreg = POP_FAILURE_INT ();                                      \
   if (pfreg == -1)                                                      \
     {                                                                   \
       /* It's a counter.  */                                            \
@@ -1568,7 +1568,7 @@ do {									\
 /* Check that we are not stuck in an infinite loop.  */
 #define CHECK_INFINITE_LOOP(pat_cur, string_place)                      \
 do {                                                                    \
-  int failure = TOP_FAILURE_HANDLE ();                                  \
+  ssize_t failure = TOP_FAILURE_HANDLE ();                              \
   /* Check for infinite matching loops */                               \
   while (failure > 0                                                    \
          && (FAILURE_STR (failure) == string_place                      \
@@ -1876,8 +1876,8 @@ typedef struct
 typedef struct
 {
   compile_stack_elt_t *stack;
-  unsigned size;
-  unsigned avail;                       /* Offset of next open position.  */
+  size_t size;
+  size_t avail;                 /* Offset of next open position.  */
 } compile_stack_type;
 
 
@@ -2779,7 +2779,7 @@ regex_compile (const re_char *pattern, size_t size, reg_syntax_t syntax, struct
                 if (many_times_ok)
                   {
                     boolean simple = skip_one_char (laststart) == b;
-                    unsigned int startoffset = 0;
+                    size_t startoffset = 0;
                     re_opcode_t ofj =
                       /* Check if the loop can match the empty string.  */
                       (simple || !analyse_first (laststart, b, NULL, 0))
@@ -3361,7 +3361,7 @@ regex_compile (const re_char *pattern, size_t size, reg_syntax_t syntax, struct
                           _____ _____
                           |   | |   |
                           |   v |   v
-                         a | b   | c
+                        a | b   | c
 
                  If we are at `b', then fixup_alt_jump right now points to a
                  three-byte space after `a'.  We'll put in the jump, set
@@ -3905,7 +3905,7 @@ at_endline_loc_p (const re_char *p, const re_char *pend, reg_syntax_t syntax)
 static boolean
 group_in_compile_stack (compile_stack_type compile_stack, regnum_t regnum)
 {
-  int this_element;
+  ssize_t this_element;
 
   for (this_element = compile_stack.avail - 1;
        this_element >= 0;
@@ -4291,8 +4291,9 @@ WEAK_ALIAS (__re_set_registers, re_set_registers)
 /* Like re_search_2, below, but only one string is specified, and
    doesn't let you say where to stop matching. */
 
-int
-re_search (struct re_pattern_buffer *bufp, const char *string, int size, int startpos, int range, struct re_registers *regs)
+regoff_t
+re_search (struct re_pattern_buffer *bufp, const char *string, size_t size,
+           ssize_t startpos, ssize_t range, struct re_registers *regs)
 {
   return re_search_2 (bufp, NULL, 0, string, size, startpos, range,
                       regs, size);
@@ -4328,16 +4329,18 @@ WEAK_ALIAS (__re_search, re_search)
    found, -1 if no match, or -2 if error (such as failure
    stack overflow).  */
 
-int
-re_search_2 (struct re_pattern_buffer *bufp, const char *str1, int size1, const char *str2, int size2, int startpos, int range, struct re_registers *regs, int stop)
+regoff_t
+re_search_2 (struct re_pattern_buffer *bufp, const char *str1, size_t size1,
+             const char *str2, size_t size2, ssize_t startpos, ssize_t range,
+             struct re_registers *regs, ssize_t stop)
 {
-  int val;
+  regoff_t val;
   re_char *string1 = (re_char*) str1;
   re_char *string2 = (re_char*) str2;
   register char *fastmap = bufp->fastmap;
   register RE_TRANSLATE_TYPE translate = bufp->translate;
-  int total_size = size1 + size2;
-  int endpos = startpos + range;
+  size_t total_size = size1 + size2;
+  ssize_t endpos = startpos + range;
   boolean anchored_start;
   /* Nonzero if we are searching multibyte string.  */
   const boolean multibyte = RE_TARGET_MULTIBYTE_P (bufp);
@@ -4385,7 +4388,7 @@ re_search_2 (struct re_pattern_buffer *bufp, const char *str1, int size1, const
 #ifdef emacs
   gl_state.object = re_match_object; /* Used by SYNTAX_TABLE_BYTE_TO_CHAR. */
   {
-    int charpos = SYNTAX_TABLE_BYTE_TO_CHAR (POS_AS_IN_BUFFER (startpos));
+    ssize_t charpos = SYNTAX_TABLE_BYTE_TO_CHAR (POS_AS_IN_BUFFER (startpos));
 
     SETUP_SYNTAX_TABLE_FOR_OBJECT (re_match_object, charpos, 1);
   }
@@ -4420,7 +4423,7 @@ re_search_2 (struct re_pattern_buffer *bufp, const char *str1, int size1, const
           if (range > 0)        /* Searching forwards.  */
             {
               register int lim = 0;
-              int irange = range;
+              ssize_t irange = range;
 
               if (startpos < size1 && startpos + range >= size1)
                 lim = range - (size1 - startpos);
@@ -4571,7 +4574,7 @@ WEAK_ALIAS (__re_search_2, re_search_2)
 /* Declarations and macros for re_match_2.  */
 
 static int bcmp_translate _RE_ARGS((re_char *s1, re_char *s2,
-                                    register int len,
+                                    register ssize_t len,
                                     RE_TRANSLATE_TYPE translate,
                                     const int multibyte));
 
@@ -4873,11 +4876,11 @@ mutually_exclusive_p (struct re_pattern_buffer *bufp, const re_char *p1, const r
                            && ((p2[2 + idx] & ~ p1[2 + idx]) == 0))))
                   break;
 
-                if (idx == p2[1])
-                  {
-                    DEBUG_PRINT1 ("      No match => fast loop.\n");
-                    return 1;
-                  }
+              if (idx == p2[1])
+                {
+                  DEBUG_PRINT1 ("        No match => fast loop.\n");
+                  return 1;
+                }
               }
           }
       }
@@ -4941,12 +4944,12 @@ mutually_exclusive_p (struct re_pattern_buffer *bufp, const re_char *p1, const r
 #ifndef emacs   /* Emacs never uses this.  */
 /* re_match is like re_match_2 except it takes only a single string.  */
 
-int
+regoff_t
 re_match (struct re_pattern_buffer *bufp, const char *string,
-          int size, int pos, struct re_registers *regs)
+          size_t size, ssize_t pos, struct re_registers *regs)
 {
-  int result = re_match_2_internal (bufp, NULL, 0, (re_char*) string, size,
-                                    pos, regs, size);
+  regoff_t result = re_match_2_internal (bufp, NULL, 0, (re_char*) string,
+                                         size, pos, regs, size);
   return result;
 }
 WEAK_ALIAS (__re_match, re_match)
@@ -4971,13 +4974,15 @@ Lisp_Object re_match_object;
    failure stack overflowing).  Otherwise, we return the length of the
    matched substring.  */
 
-int
-re_match_2 (struct re_pattern_buffer *bufp, const char *string1, int size1, const char *string2, int size2, int pos, struct re_registers *regs, int stop)
+regoff_t
+re_match_2 (struct re_pattern_buffer *bufp, const char *string1,
+            size_t size1, const char *string2, size_t size2, ssize_t pos,
+            struct re_registers *regs, ssize_t stop)
 {
-  int result;
+  regoff_t result;
 
 #ifdef emacs
-  int charpos;
+  ssize_t charpos;
   gl_state.object = re_match_object; /* Used by SYNTAX_TABLE_BYTE_TO_CHAR. */
   charpos = SYNTAX_TABLE_BYTE_TO_CHAR (POS_AS_IN_BUFFER (pos));
   SETUP_SYNTAX_TABLE_FOR_OBJECT (re_match_object, charpos, 1);
@@ -4993,11 +4998,13 @@ WEAK_ALIAS (__re_match_2, re_match_2)
 
 /* This is a separate function so that we can force an alloca cleanup
    afterwards.  */
-static int
-re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1, int size1, const re_char *string2, int size2, int pos, struct re_registers *regs, int stop)
+static regoff_t
+re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1,
+                     size_t size1, const re_char *string2, size_t size2,
+                     ssize_t pos, struct re_registers *regs, ssize_t stop)
 {
   /* General temporaries.  */
-  int mcnt;
+  ssize_t mcnt;
   size_t reg;
 
   /* Just past the end of the corresponding string.  */
@@ -5996,8 +6003,8 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1, int
                 int s1, s2;
                 int dummy;
 #ifdef emacs
-                int offset = PTR_TO_OFFSET (d - 1);
-                int charpos = SYNTAX_TABLE_BYTE_TO_CHAR (offset);
+                ssize_t offset = PTR_TO_OFFSET (d - 1);
+                ssize_t charpos = SYNTAX_TABLE_BYTE_TO_CHAR (offset);
                 UPDATE_SYNTAX_TABLE (charpos);
 #endif
                 GET_CHAR_BEFORE_2 (c1, d, string1, end1, string2, end2);
@@ -6038,8 +6045,8 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1, int
               int s1, s2;
               int dummy;
 #ifdef emacs
-              int offset = PTR_TO_OFFSET (d);
-              int charpos = SYNTAX_TABLE_BYTE_TO_CHAR (offset);
+              ssize_t offset = PTR_TO_OFFSET (d);
+              ssize_t charpos = SYNTAX_TABLE_BYTE_TO_CHAR (offset);
               UPDATE_SYNTAX_TABLE (charpos);
 #endif
               PREFETCH ();
@@ -6083,8 +6090,8 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1, int
               int s1, s2;
               int dummy;
 #ifdef emacs
-              int offset = PTR_TO_OFFSET (d) - 1;
-              int charpos = SYNTAX_TABLE_BYTE_TO_CHAR (offset);
+              ssize_t offset = PTR_TO_OFFSET (d) - 1;
+              ssize_t charpos = SYNTAX_TABLE_BYTE_TO_CHAR (offset);
               UPDATE_SYNTAX_TABLE (charpos);
 #endif
               GET_CHAR_BEFORE_2 (c1, d, string1, end1, string2, end2);
@@ -6127,8 +6134,8 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1, int
               re_wchar_t c1, c2;
               int s1, s2;
 #ifdef emacs
-              int offset = PTR_TO_OFFSET (d);
-              int charpos = SYNTAX_TABLE_BYTE_TO_CHAR (offset);
+              ssize_t offset = PTR_TO_OFFSET (d);
+              ssize_t charpos = SYNTAX_TABLE_BYTE_TO_CHAR (offset);
               UPDATE_SYNTAX_TABLE (charpos);
 #endif
               PREFETCH ();
@@ -6170,8 +6177,8 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1, int
               re_wchar_t c1, c2;
               int s1, s2;
 #ifdef emacs
-              int offset = PTR_TO_OFFSET (d) - 1;
-              int charpos = SYNTAX_TABLE_BYTE_TO_CHAR (offset);
+              ssize_t offset = PTR_TO_OFFSET (d) - 1;
+              ssize_t charpos = SYNTAX_TABLE_BYTE_TO_CHAR (offset);
               UPDATE_SYNTAX_TABLE (charpos);
 #endif
               GET_CHAR_BEFORE_2 (c1, d, string1, end1, string2, end2);
@@ -6207,8 +6214,8 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1, int
             PREFETCH ();
 #ifdef emacs
             {
-              int offset = PTR_TO_OFFSET (d);
-              int pos1 = SYNTAX_TABLE_BYTE_TO_CHAR (offset);
+              ssize_t offset = PTR_TO_OFFSET (d);
+              ssize_t pos1 = SYNTAX_TABLE_BYTE_TO_CHAR (offset);
               UPDATE_SYNTAX_TABLE (pos1);
             }
 #endif
@@ -6331,7 +6338,7 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const re_char *string1, int
    bytes; nonzero otherwise.  */
 
 static int
-bcmp_translate (const re_char *s1, const re_char *s2, register int len,
+bcmp_translate (const re_char *s1, const re_char *s2, register ssize_t len,
                 RE_TRANSLATE_TYPE translate, const int target_multibyte)
 {
   register re_char *p1 = s1, *p2 = s2;
@@ -6373,7 +6380,8 @@ bcmp_translate (const re_char *s1, const re_char *s2, register int len,
    We call regex_compile to do the actual compilation.  */
 
 const char *
-re_compile_pattern (const char *pattern, size_t length, struct re_pattern_buffer *bufp)
+re_compile_pattern (const char *pattern, size_t length,
+                    struct re_pattern_buffer *bufp)
 {
   reg_errcode_t ret;
 
@@ -6449,14 +6457,13 @@ re_comp (s)
 }
 
 
-int
+regoff_t
 # ifdef _LIBC
 weak_function
 # endif
-re_exec (s)
-    const char *s;
+re_exec (const char *s)
 {
-  const int len = strlen (s);
+  const size_t len = strlen (s);
   return
     0 <= re_search (&re_comp_buf, s, len, 0, len, (struct re_registers *) 0);
 }
@@ -6500,7 +6507,7 @@ re_exec (s)
    It returns 0 if it succeeds, nonzero if it doesn't.  (See regex.h for
    the return codes and their meanings.)  */
 
-int
+reg_errcode_t
 regcomp (regex_t *__restrict preg, const char *__restrict pattern,
          int cflags)
 {
@@ -6564,7 +6571,7 @@ regcomp (regex_t *__restrict preg, const char *__restrict pattern,
           preg->fastmap = NULL;
         }
     }
-  return (int) ret;
+  return ret;
 }
 WEAK_ALIAS (__regcomp, regcomp)
 
@@ -6583,14 +6590,14 @@ WEAK_ALIAS (__regcomp, regcomp)
 
    We return 0 if we find a match and REG_NOMATCH if not.  */
 
-int
+reg_errcode_t
 regexec (const regex_t *__restrict preg, const char *__restrict string,
          size_t nmatch, regmatch_t pmatch[__restrict_arr], int eflags)
 {
-  int ret;
+  reg_errcode_t ret;
   struct re_registers regs;
   regex_t private_preg;
-  int len = strlen (string);
+  size_t len = strlen (string);
   boolean want_reg_info = !preg->no_sub && nmatch > 0 && pmatch;
 
   private_preg = *preg;
@@ -6608,7 +6615,7 @@ regexec (const regex_t *__restrict preg, const char *__restrict string,
       regs.num_regs = nmatch;
       regs.start = TALLOC (nmatch * 2, regoff_t);
       if (regs.start == NULL)
-        return (int) REG_NOMATCH;
+        return REG_NOMATCH;
       regs.end = regs.start + nmatch;
     }
 
@@ -6645,7 +6652,7 @@ regexec (const regex_t *__restrict preg, const char *__restrict string,
     }
 
   /* We want zero return to mean success, unlike `re_search'.  */
-  return ret >= 0 ? (int) REG_NOERROR : (int) REG_NOMATCH;
+  return ret >= 0 ? REG_NOERROR : REG_NOMATCH;
 }
 WEAK_ALIAS (__regexec, regexec)
 
diff --git a/src/regex.h b/src/regex.h
index 990606da4cc..7747ec57629 100644
--- a/src/regex.h
+++ b/src/regex.h
@@ -414,8 +414,12 @@ struct re_pattern_buffer
 
 typedef struct re_pattern_buffer regex_t;
 
-/* Type for byte offsets within the string.  POSIX mandates this.  */
-typedef int regoff_t;
+/* Type for byte offsets within the string.  POSIX mandates this to be an int,
+   but the Open Group has signalled its intention to change the requirement to
+   be that regoff_t be at least as wide as ptrdiff_t and ssize_t.  Current
+   gnulib sources also use ssize_t, and we need this for supporting buffers and
+   strings > 2GB on 64-bit hosts.  */
+typedef ssize_t regoff_t;
 
 
 /* This is the structure we store register match data in.  See
@@ -486,31 +490,33 @@ extern int re_compile_fastmap _RE_ARGS ((struct re_pattern_buffer *buffer));
    characters.  Return the starting position of the match, -1 for no
    match, or -2 for an internal error.  Also return register
    information in REGS (if REGS and BUFFER->no_sub are nonzero).  */
-extern int re_search
+extern regoff_t re_search
   _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string,
-            int length, int start, int range, struct re_registers *regs));
+             size_t length, ssize_t start, ssize_t range,
+             struct re_registers *regs));
 
 
 /* Like `re_search', but search in the concatenation of STRING1 and
    STRING2.  Also, stop searching at index START + STOP.  */
-extern int re_search_2
+extern regoff_t re_search_2
   _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1,
-             int length1, const char *string2, int length2,
-             int start, int range, struct re_registers *regs, int stop));
+             size_t length1, const char *string2, size_t length2,
+             ssize_t start, ssize_t range, struct re_registers *regs,
+             ssize_t stop));
 
 
 /* Like `re_search', but return how many characters in STRING the regexp
    in BUFFER matched, starting at position START.  */
-extern int re_match
+extern regoff_t re_match
   _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string,
-             int length, int start, struct re_registers *regs));
+             size_t length, ssize_t start, struct re_registers *regs));
 
 
 /* Relates to `re_match' as `re_search_2' relates to `re_search'.  */
-extern int re_match_2
+extern regoff_t re_match_2
   _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1,
-             int length1, const char *string2, int length2,
-             int start, struct re_registers *regs, int stop));
+             size_t length1, const char *string2, size_t length2,
+             ssize_t start, struct re_registers *regs, ssize_t stop));
 
 
 /* Set REGS to hold NUM_REGS registers, storing them in STARTS and
@@ -556,14 +562,15 @@ extern int re_exec _RE_ARGS ((const char *));
 #endif
 
 /* POSIX compatibility.  */
-extern int regcomp _RE_ARGS ((regex_t *__restrict __preg,
-                              const char *__restrict __pattern,
-                              int __cflags));
-
-extern int regexec _RE_ARGS ((const regex_t *__restrict __preg,
-                              const char *__restrict __string, size_t __nmatch,
-                              regmatch_t __pmatch[__restrict_arr],
-                              int __eflags));
+extern reg_errcode_t regcomp _RE_ARGS ((regex_t *__restrict __preg,
+                                        const char *__restrict __pattern,
+                                        int __cflags));
+
+extern reg_errcode_t regexec _RE_ARGS ((const regex_t *__restrict __preg,
+                                        const char *__restrict __string,
+                                        size_t __nmatch,
+                                        regmatch_t __pmatch[__restrict_arr],
+                                        int __eflags));
 
 extern size_t regerror _RE_ARGS ((int __errcode, const regex_t *__preg,
                                   char *__errbuf, size_t __errbuf_size));
diff --git a/src/syntax.c b/src/syntax.c
index 031409144b1..4be6b8db140 100644
--- a/src/syntax.c
+++ b/src/syntax.c
@@ -175,7 +175,7 @@ struct gl_state_s gl_state;		/* Global state of syntax parser.  */
    start/end of OBJECT.  */
 
 void
-update_syntax_table (EMACS_INT charpos, int count, int init,
+update_syntax_table (EMACS_INT charpos, EMACS_INT count, int init,
                      Lisp_Object object)
 {
   Lisp_Object tmp_table;
diff --git a/src/syntax.h b/src/syntax.h
index 2b052715dac..9f328f568c7 100644
--- a/src/syntax.h
+++ b/src/syntax.h
@@ -19,7 +19,7 @@ You should have received a copy of the GNU General Public License
 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 
-extern void update_syntax_table (EMACS_INT, int, int, Lisp_Object);
+extern void update_syntax_table (EMACS_INT, EMACS_INT, int, Lisp_Object);
 
 /* The standard syntax table is stored where it will automatically
    be used in all new buffers.  */
@@ -276,15 +276,15 @@ while (0)
 struct gl_state_s
 {
   Lisp_Object object;                   /* The object we are scanning. */
-  int start;                            /* Where to stop. */
-  int stop;                             /* Where to stop. */
+  EMACS_INT start;                      /* Where to stop. */
+  EMACS_INT stop;                       /* Where to stop. */
   int use_global;                       /* Whether to use global_code
                                            or c_s_t. */
   Lisp_Object global_code;              /* Syntax code of current char. */
   Lisp_Object current_syntax_table;     /* Syntax table for current pos. */
   Lisp_Object old_prop;                 /* Syntax-table prop at prev pos. */
-  int b_property;                       /* First index where c_s_t is valid. */
-  int e_property;                       /* First index where c_s_t is
+  EMACS_INT b_property;                 /* First index where c_s_t is valid. */
+  EMACS_INT e_property;                 /* First index where c_s_t is
                                            not valid. */
   INTERVAL forward_i;                   /* Where to start lookup on forward */
   INTERVAL backward_i;                  /* or backward movement.  The
@@ -294,7 +294,7 @@ struct gl_state_s
                                            intervals too, depending
                                            on: */
   /* Offset for positions specified to UPDATE_SYNTAX_TABLE.  */
-  int offset;
+  EMACS_INT offset;
 };
 
 extern struct gl_state_s gl_state;
diff --git a/src/textprop.c b/src/textprop.c
index a0d7d2689c4..d9da36bf36b 100644
--- a/src/textprop.c
+++ b/src/textprop.c
@@ -514,7 +514,7 @@ erase_properties (INTERVAL i)
    POSITION is BEG-based.  */
 
 INTERVAL
-interval_of (int position, Lisp_Object object)
+interval_of (EMACS_INT position, Lisp_Object object)
 {
   register INTERVAL i;
   EMACS_INT beg, end;
@@ -2012,7 +2012,8 @@ call_mod_hooks (Lisp_Object list, Lisp_Object start, Lisp_Object end)
    those hooks in order, with START and END - 1 as arguments.  */
 
 void
-verify_interval_modification (struct buffer *buf, int start, int end)
+verify_interval_modification (struct buffer *buf,
+                              EMACS_INT start, EMACS_INT end)
 {
   register INTERVAL intervals = BUF_INTERVALS (buf);
   register INTERVAL i;