1 files changed, 71 insertions, 64 deletions

diff --git a/src/fileio.c b/src/fileio.c
index 08be41f9fe4..486c3d4c175 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -145,9 +145,9 @@ Lisp_Object Qfile_name_history;
 static Lisp_Object Qcar_less_than_car;
 
 static Lisp_Object Fmake_symbolic_link (Lisp_Object, Lisp_Object, Lisp_Object);
-static int a_write (int, Lisp_Object, EMACS_INT, EMACS_INT,
+static int a_write (int, Lisp_Object, ptrdiff_t, ptrdiff_t,
                     Lisp_Object *, struct coding_system *);
-static int e_write (int, Lisp_Object, EMACS_INT, EMACS_INT,
+static int e_write (int, Lisp_Object, ptrdiff_t, ptrdiff_t,
                     struct coding_system *);
 
 
@@ -257,7 +257,7 @@ use the standard functions without calling themselves recursively.  */)
 {
   /* This function must not munge the match data.  */
   Lisp_Object chain, inhibited_handlers, result;
-  int pos = -1;
+  ptrdiff_t pos = -1;
 
   result = Qnil;
   CHECK_STRING (filename);
@@ -275,7 +275,7 @@ use the standard functions without calling themselves recursively.  */)
       if (CONSP (elt))
         {
           Lisp_Object string = XCAR (elt);
-          EMACS_INT match_pos;
+          ptrdiff_t match_pos;
           Lisp_Object handler = XCDR (elt);
           Lisp_Object operations = Qnil;
 
@@ -1813,12 +1813,12 @@ on the system, we copy the SELinux context of FILE to NEWNAME.  */)
   (Lisp_Object file, Lisp_Object newname, Lisp_Object ok_if_already_exists, Lisp_Object keep_time, Lisp_Object preserve_uid_gid, Lisp_Object preserve_selinux_context)
 {
   int ifd, ofd;
-  EMACS_INT n;
+  int n;
   char buf[16 * 1024];
   struct stat st, out_st;
   Lisp_Object handler;
   struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
-  int count = SPECPDL_INDEX ();
+  ptrdiff_t count = SPECPDL_INDEX ();
   int input_file_statable_p;
   Lisp_Object encoded_file, encoded_newname;
 #if HAVE_LIBSELINUX
@@ -2210,7 +2210,7 @@ This is what happens in interactive use with M-x.  */)
     {
       if (errno == EXDEV)
         {
-          int count;
+          ptrdiff_t count;
           symlink_target = Ffile_symlink_p (file);
           if (! NILP (symlink_target))
             Fmake_symbolic_link (symlink_target, newname,
@@ -3055,6 +3055,8 @@ otherwise, if FILE2 does not exist, the answer is t.  */)
 #ifndef READ_BUF_SIZE
 #define READ_BUF_SIZE (64 << 10)
 #endif
+/* Some buffer offsets are stored in 'int' variables.  */
+verify (READ_BUF_SIZE <= INT_MAX);
 
 /* This function is called after Lisp functions to decide a coding
    system are called, or when they cause an error.  Before they are
@@ -3099,8 +3101,8 @@ decide_coding_unwind (Lisp_Object unwind_data)
 /* Used to pass values from insert-file-contents to read_non_regular.  */
 
 static int non_regular_fd;
-static EMACS_INT non_regular_inserted;
-static EMACS_INT non_regular_nbytes;
+static ptrdiff_t non_regular_inserted;
+static int non_regular_nbytes;
 
 
 /* Read from a non-regular file.
@@ -3111,7 +3113,7 @@ static EMACS_INT non_regular_nbytes;
 static Lisp_Object
 read_non_regular (Lisp_Object ignore)
 {
-  EMACS_INT nbytes;
+  int nbytes;
 
   immediate_quit = 1;
   QUIT;
@@ -3176,16 +3178,16 @@ variable `last-coding-system-used' to the coding system actually used.  */)
 {
   struct stat st;
   register int fd;
-  EMACS_INT inserted = 0;
+  ptrdiff_t inserted = 0;
   int nochange = 0;
-  register EMACS_INT how_much;
+  register ptrdiff_t how_much;
   off_t beg_offset, end_offset;
-  register EMACS_INT unprocessed;
-  int count = SPECPDL_INDEX ();
+  register int unprocessed;
+  ptrdiff_t count = SPECPDL_INDEX ();
   struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
   Lisp_Object handler, val, insval, orig_filename, old_undo;
   Lisp_Object p;
-  EMACS_INT total = 0;
+  ptrdiff_t total = 0;
   int not_regular = 0;
   char read_buf[READ_BUF_SIZE];
   struct coding_system coding;
@@ -3225,7 +3227,8 @@ variable `last-coding-system-used' to the coding system actually used.  */)
     {
       val = call6 (handler, Qinsert_file_contents, filename,
                    visit, beg, end, replace);
-      if (CONSP (val) && CONSP (XCDR (val)))
+      if (CONSP (val) && CONSP (XCDR (val))
+          && RANGED_INTEGERP (0, XCAR (XCDR (val)), ZV - PT))
         inserted = XINT (XCAR (XCDR (val)));
       goto handled;
     }
@@ -3378,7 +3381,7 @@ variable `last-coding-system-used' to the coding system actually used.  */)
                  We assume that the 1K-byte and 3K-byte for heading
                  and tailing respectively are sufficient for this
                  purpose.  */
-              EMACS_INT nread;
+              int nread;
 
               if (st.st_size <= (1024 * 4))
                 nread = emacs_read (fd, read_buf, 1024 * 4);
@@ -3488,9 +3491,9 @@ variable `last-coding-system-used' to the coding system actually used.  */)
       /* same_at_start and same_at_end count bytes,
          because file access counts bytes
          and BEG and END count bytes.  */
-      EMACS_INT same_at_start = BEGV_BYTE;
-      EMACS_INT same_at_end = ZV_BYTE;
-      EMACS_INT overlap;
+      ptrdiff_t same_at_start = BEGV_BYTE;
+      ptrdiff_t same_at_end = ZV_BYTE;
+      ptrdiff_t overlap;
       /* There is still a possibility we will find the need to do code
          conversion.  If that happens, we set this variable to 1 to
          give up on handling REPLACE in the optimized way.  */
@@ -3509,7 +3512,7 @@ variable `last-coding-system-used' to the coding system actually used.  */)
          match the text at the beginning of the buffer.  */
       while (1)
         {
-          EMACS_INT nread, bufpos;
+          int nread, bufpos;
 
           nread = emacs_read (fd, buffer, sizeof buffer);
           if (nread < 0)
@@ -3618,7 +3621,7 @@ variable `last-coding-system-used' to the coding system actually used.  */)
 
       if (! giveup_match_end)
         {
-          EMACS_INT temp;
+          ptrdiff_t temp;
 
           /* We win!  We can handle REPLACE the optimized way.  */
 
@@ -3672,16 +3675,16 @@ variable `last-coding-system-used' to the coding system actually used.  */)
      in a more optimized way.  */
   if (!NILP (replace) && ! replace_handled && BEGV < ZV)
     {
-      EMACS_INT same_at_start = BEGV_BYTE;
-      EMACS_INT same_at_end = ZV_BYTE;
-      EMACS_INT same_at_start_charpos;
-      EMACS_INT inserted_chars;
-      EMACS_INT overlap;
-      EMACS_INT bufpos;
+      ptrdiff_t same_at_start = BEGV_BYTE;
+      ptrdiff_t same_at_end = ZV_BYTE;
+      ptrdiff_t same_at_start_charpos;
+      ptrdiff_t inserted_chars;
+      ptrdiff_t overlap;
+      ptrdiff_t bufpos;
       unsigned char *decoded;
-      EMACS_INT temp;
-      EMACS_INT this = 0;
-      int this_count = SPECPDL_INDEX ();
+      ptrdiff_t temp;
+      ptrdiff_t this = 0;
+      ptrdiff_t this_count = SPECPDL_INDEX ();
       int multibyte = ! NILP (BVAR (current_buffer, enable_multibyte_characters));
       Lisp_Object conversion_buffer;
 
@@ -3705,8 +3708,7 @@ variable `last-coding-system-used' to the coding system actually used.  */)
           /* We read one bunch by one (READ_BUF_SIZE bytes) to allow
              quitting while reading a huge while.  */
           /* try is reserved in some compilers (Microsoft C) */
-          EMACS_INT trytry = min (total - how_much,
-                                  READ_BUF_SIZE - unprocessed);
+          int trytry = min (total - how_much, READ_BUF_SIZE - unprocessed);
 
           /* Allow quitting out of the actual I/O.  */
           immediate_quit = 1;
@@ -3897,13 +3899,13 @@ variable `last-coding-system-used' to the coding system actually used.  */)
   /* Here, we don't do code conversion in the loop.  It is done by
      decode_coding_gap after all data are read into the buffer.  */
   {
-    EMACS_INT gap_size = GAP_SIZE;
+    ptrdiff_t gap_size = GAP_SIZE;
 
     while (how_much < total)
       {
         /* try is reserved in some compilers (Microsoft C) */
-        EMACS_INT trytry = min (total - how_much, READ_BUF_SIZE);
-        EMACS_INT this;
+        int trytry = min (total - how_much, READ_BUF_SIZE);
+        ptrdiff_t this;
 
         if (not_regular)
           {
@@ -4022,7 +4024,7 @@ variable `last-coding-system-used' to the coding system actually used.  */)
              care of marker adjustment.  By this way, we can run Lisp
              program safely before decoding the inserted text.  */
           Lisp_Object unwind_data;
-          int count1 = SPECPDL_INDEX ();
+          ptrdiff_t count1 = SPECPDL_INDEX ();
 
           unwind_data = Fcons (BVAR (current_buffer, enable_multibyte_characters),
                                Fcons (BVAR (current_buffer, undo_list),
@@ -4143,7 +4145,8 @@ variable `last-coding-system-used' to the coding system actually used.  */)
                       visit);
       if (! NILP (insval))
         {
-          CHECK_NUMBER (insval);
+          if (! RANGED_INTEGERP (0, insval, ZV - PT))
+            wrong_type_argument (intern ("inserted-chars"), insval);
           inserted = XFASTINT (insval);
         }
     }
@@ -4152,8 +4155,8 @@ variable `last-coding-system-used' to the coding system actually used.  */)
   if (inserted > 0)
     {
       /* Don't run point motion or modification hooks when decoding.  */
-      int count1 = SPECPDL_INDEX ();
-      EMACS_INT old_inserted = inserted;
+      ptrdiff_t count1 = SPECPDL_INDEX ();
+      ptrdiff_t old_inserted = inserted;
       specbind (Qinhibit_point_motion_hooks, Qt);
       specbind (Qinhibit_modification_hooks, Qt);
 
@@ -4165,7 +4168,8 @@ variable `last-coding-system-used' to the coding system actually used.  */)
         {
           insval = call3 (Qformat_decode,
                           Qnil, make_number (inserted), visit);
-          CHECK_NUMBER (insval);
+          if (! RANGED_INTEGERP (0, insval, ZV - PT))
+            wrong_type_argument (intern ("inserted-chars"), insval);
           inserted = XFASTINT (insval);
         }
       else
@@ -4179,15 +4183,16 @@ variable `last-coding-system-used' to the coding system actually used.  */)
              Hence we temporarily save `point' and `inserted' here and
              restore `point' iff format-decode did not insert or delete
              any text.  Otherwise we leave `point' at point-min.  */
-          EMACS_INT opoint = PT;
-          EMACS_INT opoint_byte = PT_BYTE;
-          EMACS_INT oinserted = ZV - BEGV;
-          int ochars_modiff = CHARS_MODIFF;
+          ptrdiff_t opoint = PT;
+          ptrdiff_t opoint_byte = PT_BYTE;
+          ptrdiff_t oinserted = ZV - BEGV;
+          EMACS_INT ochars_modiff = CHARS_MODIFF;
 
           TEMP_SET_PT_BOTH (BEGV, BEGV_BYTE);
           insval = call3 (Qformat_decode,
                           Qnil, make_number (oinserted), visit);
-          CHECK_NUMBER (insval);
+          if (! RANGED_INTEGERP (0, insval, ZV - PT))
+            wrong_type_argument (intern ("inserted-chars"), insval);
           if (ochars_modiff == CHARS_MODIFF)
             /* format_decode didn't modify buffer's characters => move
                point back to position before inserted text and leave
@@ -4209,7 +4214,8 @@ variable `last-coding-system-used' to the coding system actually used.  */)
               insval = call1 (XCAR (p), make_number (inserted));
               if (!NILP (insval))
                 {
-                  CHECK_NUMBER (insval);
+                  if (! RANGED_INTEGERP (0, insval, ZV - PT))
+                    wrong_type_argument (intern ("inserted-chars"), insval);
                   inserted = XFASTINT (insval);
                 }
             }
@@ -4217,16 +4223,17 @@ variable `last-coding-system-used' to the coding system actually used.  */)
             {
               /* For the rationale of this see the comment on
                  format-decode above.  */
-              EMACS_INT opoint = PT;
-              EMACS_INT opoint_byte = PT_BYTE;
-              EMACS_INT oinserted = ZV - BEGV;
-              int ochars_modiff = CHARS_MODIFF;
+              ptrdiff_t opoint = PT;
+              ptrdiff_t opoint_byte = PT_BYTE;
+              ptrdiff_t oinserted = ZV - BEGV;
+              EMACS_INT ochars_modiff = CHARS_MODIFF;
 
               TEMP_SET_PT_BOTH (BEGV, BEGV_BYTE);
               insval = call1 (XCAR (p), make_number (oinserted));
               if (!NILP (insval))
                 {
-                  CHECK_NUMBER (insval);
+                  if (! RANGED_INTEGERP (0, insval, ZV - PT))
+                    wrong_type_argument (intern ("inserted-chars"), insval);
                   if (ochars_modiff == CHARS_MODIFF)
                     /* after_insert_file_functions didn't modify
                        buffer's characters => move point back to
@@ -4458,7 +4465,7 @@ This calls `write-region-annotate-functions' at the start, and
   int save_errno = 0;
   const char *fn;
   struct stat st;
-  int count = SPECPDL_INDEX ();
+  ptrdiff_t count = SPECPDL_INDEX ();
   int count1;
   Lisp_Object handler;
   Lisp_Object visit_file;
@@ -4856,13 +4863,13 @@ build_annotations (Lisp_Object start, Lisp_Object end)
    The return value is negative in case of system call failure.  */
 
 static int
-a_write (int desc, Lisp_Object string, EMACS_INT pos,
-         register EMACS_INT nchars, Lisp_Object *annot,
+a_write (int desc, Lisp_Object string, ptrdiff_t pos,
+         register ptrdiff_t nchars, Lisp_Object *annot,
          struct coding_system *coding)
 {
   Lisp_Object tem;
-  EMACS_INT nextpos;
-  EMACS_INT lastpos = pos + nchars;
+  ptrdiff_t nextpos;
+  ptrdiff_t lastpos = pos + nchars;
 
   while (NILP (*annot) || CONSP (*annot))
     {
@@ -4902,7 +4909,7 @@ a_write (int desc, Lisp_Object string, EMACS_INT pos,
    are indexes to the string STRING.  */
 
 static int
-e_write (int desc, Lisp_Object string, EMACS_INT start, EMACS_INT end,
+e_write (int desc, Lisp_Object string, ptrdiff_t start, ptrdiff_t end,
          struct coding_system *coding)
 {
   if (STRINGP (string))
@@ -4934,8 +4941,8 @@ e_write (int desc, Lisp_Object string, EMACS_INT start, EMACS_INT end,
         }
       else
         {
-          EMACS_INT start_byte = CHAR_TO_BYTE (start);
-          EMACS_INT end_byte = CHAR_TO_BYTE (end);
+          ptrdiff_t start_byte = CHAR_TO_BYTE (start);
+          ptrdiff_t end_byte = CHAR_TO_BYTE (end);
 
           coding->src_multibyte = (end - start) < (end_byte - start_byte);
           if (CODING_REQUIRE_ENCODING (coding))
@@ -5219,7 +5226,7 @@ A non-nil CURRENT-ONLY argument means save only current buffer.  */)
   int do_handled_files;
   Lisp_Object oquit;
   FILE *stream = NULL;
-  int count = SPECPDL_INDEX ();
+  ptrdiff_t count = SPECPDL_INDEX ();
   int orig_minibuffer_auto_raise = minibuffer_auto_raise;
   int old_message_p = 0;
   struct gcpro gcpro1, gcpro2;
@@ -5339,7 +5346,7 @@ A non-nil CURRENT-ONLY argument means save only current buffer.  */)
             EMACS_GET_TIME (before_time);
 
             /* If we had a failure, don't try again for 20 minutes.  */
-            if (b->auto_save_failure_time >= 0
+            if (b->auto_save_failure_time > 0
                 && EMACS_SECS (before_time) - b->auto_save_failure_time < 1200)
               continue;
 
@@ -5418,7 +5425,7 @@ No auto-save file will be written until the buffer changes again.  */)
      they're not autosaved.  */
   BUF_AUTOSAVE_MODIFF (current_buffer) = MODIFF;
   XSETFASTINT (BVAR (current_buffer, save_length), Z - BEG);
-  current_buffer->auto_save_failure_time = -1;
+  current_buffer->auto_save_failure_time = 0;
   return Qnil;
 }
 
@@ -5427,7 +5434,7 @@ DEFUN ("clear-buffer-auto-save-failure", Fclear_buffer_auto_save_failure,
        doc: /* Clear any record of a recent auto-save failure in the current buffer.  */)
   (void)
 {
-  current_buffer->auto_save_failure_time = -1;
+  current_buffer->auto_save_failure_time = 0;
   return Qnil;
 }