(Finsert_file_contents): Even if

enable-multibyte-characters is nil, we must check `coding:' tag
and `file-coding-system-alist' to handle eol-conversion.

(Finsert_file_contents): Adjusted for the change of
struct coding_system and function decode_coding.  For normail file
reading, use code_convert_region.
(Fwrite_region): Adjusted for the change of struct coding_system.
(e_write): Adjusted for the change of encode_coding.

1 files changed, 105 insertions, 137 deletions

diff --git a/src/fileio.c b/src/fileio.c
index 102573baf83..5bde062e0ab 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -3143,7 +3143,6 @@ This does code conversion according to the value of\n\
   struct stat st;
   register int fd;
   int inserted = 0;
-  int inserted_chars = 0;
   register int how_much;
   register int unprocessed;
   int count = specpdl_ptr - specpdl;
@@ -3265,8 +3264,6 @@ This does code conversion according to the value of\n\
 
     if (!NILP (Vcoding_system_for_read))
       val = Vcoding_system_for_read;
-    else if (NILP (current_buffer->enable_multibyte_characters))
-      val = Qemacs_mule;
     else
       {
 	if (! NILP (Vset_auto_coding_function))
@@ -3317,7 +3314,20 @@ This does code conversion according to the value of\n\
 	    if (CONSP (coding_systems)) val = XCONS (coding_systems)->car;
 	  }
       }
-    setup_coding_system (Fcheck_coding_system (val), &coding);
+
+    if (NILP (Vcoding_system_for_read)
+	&& NILP (current_buffer->enable_multibyte_characters))
+      {
+	/* We must suppress all text conversion except for end-of-line
+	   conversion.  */
+	struct coding_system coding_temp;
+
+	setup_coding_system (Fcheck_coding_system (val), &coding_temp);
+	setup_coding_system (Qraw_text, &coding);
+	coding.eol_type = coding_temp.eol_type;
+      }
+    else
+      setup_coding_system (Fcheck_coding_system (val), &coding);
   }
 
   /* If requested, replace the accessible part of the buffer
@@ -3458,8 +3468,7 @@ This does code conversion according to the value of\n\
 	      if (same_at_end > same_at_start
 		  && FETCH_BYTE (same_at_end - 1) >= 0200
 		  && ! NILP (current_buffer->enable_multibyte_characters)
-		  && (CODING_REQUIRE_DECODING (&coding)
-		      || CODING_REQUIRE_DETECTION (&coding)))
+		  && (CODING_MAY_REQUIRE_DECODING (&coding)))
 		giveup_match_end = 1;
 	      break;
 	    }
@@ -3559,10 +3568,9 @@ This does code conversion according to the value of\n\
 
 	  how_much += this;
 
-	  if (CODING_REQUIRE_DECODING (&coding)
-	      || CODING_REQUIRE_DETECTION (&coding))
+	  if (CODING_MAY_REQUIRE_DECODING (&coding))
 	    {
-	      int require, produced, consumed;
+	      int require, result;
 
 	      this += unprocessed;
 
@@ -3577,22 +3585,21 @@ This does code conversion according to the value of\n\
 
 	      /* Convert this batch with results in CONVERSION_BUFFER.  */
 	      if (how_much >= total)  /* This is the last block.  */
-		coding.last_block = 1;
-	      produced = decode_coding (&coding, read_buf,
-					conversion_buffer + inserted,
-					this, bufsize - inserted,
-					&consumed);
+		coding.mode |= CODING_MODE_LAST_BLOCK;
+	      result = decode_coding (&coding, read_buf,
+				      conversion_buffer + inserted,
+				      this, bufsize - inserted);
 
 	      /* Save for next iteration whatever we didn't convert.  */
-	      unprocessed = this - consumed;
-	      bcopy (read_buf + consumed, read_buf, unprocessed);
-	      this = produced;
+	      unprocessed = this - coding.consumed;
+	      bcopy (read_buf + coding.consumed, read_buf, unprocessed);
+	      this = coding.produced;
 	    }
 
 	  inserted += this;
 	}
 
-      /* At this point, INSERTED is how many characters
+      /* At this point, INSERTED is how many characters (i.e. bytes)
 	 are present in CONVERSION_BUFFER.
 	 HOW_MUCH should equal TOTAL,
 	 or should be <= 0 if we couldn't read the file.  */
@@ -3696,35 +3703,44 @@ This does code conversion according to the value of\n\
     }
 
   /* In the following loop, HOW_MUCH contains the total bytes read so
-     far.  Before exiting the loop, it is set to -1 if I/O error
-     occurs, set to -2 if the maximum buffer size is exceeded.  */
+     far for a regular file, and not changed for a special file.  But,
+     before exiting the loop, it is set to a negative value if I/O
+     error occurs.  */
   how_much = 0;
   /* Total bytes inserted.  */
   inserted = 0;
-  /* Bytes not processed in the previous loop because short gap size.  */
-  unprocessed = 0;
+  /* Here, we don't do code conversion in the loop.  It is done by
+     code_convert_region after all data are read into the buffer.  */
   while (how_much < total)
     {
 	/* try is reserved in some compilers (Microsoft C) */
-      int trytry = min (total - how_much, READ_BUF_SIZE - unprocessed);
-      char *destination = (! (CODING_REQUIRE_DECODING (&coding)
-			      || CODING_REQUIRE_DETECTION (&coding))
-			   ? (char *) (BYTE_POS_ADDR (PT_BYTE + inserted - 1) + 1)
-			   : read_buf + unprocessed);
-      int this, this_chars;
+      int trytry = min (total - how_much, READ_BUF_SIZE);
+      int this;
+
+      /* For a special file, GAP_SIZE should be checked every time.  */
+      if (not_regular && GAP_SIZE < trytry)
+	make_gap (total - GAP_SIZE);
 
       /* Allow quitting out of the actual I/O.  */
       immediate_quit = 1;
       QUIT;
-      this = read (fd, destination, trytry);
+      this = read (fd, BYTE_POS_ADDR (PT + inserted - 1) + 1, trytry);
       immediate_quit = 0;
 
-      if (this < 0 || this + unprocessed == 0)
+      if (this <= 0)
 	{
 	  how_much = this;
 	  break;
 	}
 
+      GAP_SIZE -= this;
+      GPT_BYTE += this;
+      ZV_BYTE += this;
+      Z_BYTE += this;
+      GPT += this;
+      ZV += this;
+      Z += this;
+
       /* For a regular file, where TOTAL is the real size,
 	 count HOW_MUCH to compare with it.
 	 For a special file, where TOTAL is just a buffer size,
@@ -3732,103 +3748,56 @@ This does code conversion according to the value of\n\
 	 (INSERTED is where we count the number of characters inserted.)  */
       if (! not_regular)
 	how_much += this;
+      inserted += this;
+    }
 
-      if (CODING_REQUIRE_DECODING (&coding)
-	  || CODING_REQUIRE_DETECTION (&coding))
-	{
-	  int require, produced, consumed;
-
-	  this += unprocessed;
-	  /* Make sure that the gap is large enough.  */
-	  require = decoding_buffer_size (&coding, this);
-	  if (GAP_SIZE < require)
-	    make_gap (require - GAP_SIZE);
-
-	  if (! not_regular)
-	    {
-	      if (how_much >= total)  /* This is the last block.  */
-		coding.last_block = 1;
-	    }
-	  else
-	    {
-	      /* If we encounter EOF, say it is the last block.  (The
-		 data this will apply to is the UNPROCESSED characters
-		 carried over from the last batch.)  */
-	      if (this == 0)
-		coding.last_block = 1;
-	    }
+  if (GAP_SIZE > 0)
+    /* Put an anchor to ensure multi-byte form ends at gap.  */
+    *GPT_ADDR = 0;
 
-	  produced = decode_coding (&coding, read_buf,
-				    BYTE_POS_ADDR (PT_BYTE + inserted - 1) + 1,
-				    this, GAP_SIZE, &consumed);
-	  if (produced > 0) 
-	    {
-	      Lisp_Object temp;
+  close (fd);
 
-	      XSET (temp, Lisp_Int, Z_BYTE + produced);
-	      if (Z_BYTE + produced != XINT (temp))
-		{
-		  how_much = -2;
-		  break;
-		}
-	    }
-	  unprocessed = this - consumed;
-	  bcopy (read_buf + consumed, read_buf, unprocessed);
-	  this = produced;
-	  this_chars = chars_in_text (BYTE_POS_ADDR (PT_BYTE + inserted - 1) + 1,
-				      produced);
-	}
-      else if (! NILP (current_buffer->enable_multibyte_characters))
-	this_chars = chars_in_text (BYTE_POS_ADDR (PT_BYTE + inserted - 1) + 1,
-				    this);
-      else
-	this_chars = this;
+  /* Discard the unwind protect for closing the file.  */
+  specpdl_ptr--;
 
-      GAP_SIZE -= this;
-      GPT_BYTE += this;
-      ZV_BYTE += this;
-      Z_BYTE += this;
-      GPT += this_chars;
-      ZV += this_chars;
-      Z += this_chars;
+  if (how_much < 0)
+    error ("IO error reading %s: %s",
+	   XSTRING (orig_filename)->data, strerror (errno));
 
-      if (GAP_SIZE > 0)
-	/* Put an anchor to ensure multi-byte form ends at gap.  */
-	*GPT_ADDR = 0;
-      inserted += this;
-      inserted_chars += this_chars;
-    }
+  if (inserted > 0)
+    {
+      if (CODING_MAY_REQUIRE_DECODING (&coding))
+	inserted = code_convert_region (PT, PT + inserted, &coding, 0, 0);
 
 #ifdef DOS_NT
-  /* Use the conversion type to determine buffer-file-type
-     (find-buffer-file-type is now used to help determine the
-     conversion).  */
-  if (coding.eol_type != CODING_EOL_UNDECIDED 
-      && coding.eol_type != CODING_EOL_LF)
-    current_buffer->buffer_file_type = Qnil;
-  else
-    current_buffer->buffer_file_type = Qt;
+      /* Use the conversion type to determine buffer-file-type
+	 (find-buffer-file-type is now used to help determine the
+	 conversion).  */
+      if (coding.eol_type != CODING_EOL_UNDECIDED 
+	  && coding.eol_type != CODING_EOL_LF)
+	current_buffer->buffer_file_type = Qnil;
+      else
+	current_buffer->buffer_file_type = Qt;
 #endif
 
-  if (inserted > 0)
-    {
       record_insert (PT, inserted_chars);
 
       /* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES */
       offset_intervals (current_buffer, PT, inserted_chars);
       MODIFF++;
-    }
-
-  close (fd);
 
-  /* Discard the unwind protect for closing the file.  */
-  specpdl_ptr--;
+      if (! NILP (coding.post_read_conversion))
+	{
+	  Lisp_Object val;
 
-  if (how_much == -1)
-    error ("IO error reading %s: %s",
-	   XSTRING (orig_filename)->data, strerror (errno));
-  else if (how_much == -2)
-    error ("Maximum buffer size exceeded");
+	  val = call1 (coding.post_read_conversion, make_number (inserted));
+	  if (!NILP (val))
+	    {
+	      CHECK_NUMBER (val, 0);
+	      inserted = XFASTINT (val);
+	    }
+	}
+    }
 
   set_coding_system = 1;
 
@@ -3871,20 +3840,20 @@ This does code conversion according to the value of\n\
     }
 
   /* Decode file format */
-  if (inserted_chars > 0)
+  if (inserted > 0)
     {
       insval = call3 (Qformat_decode,
-		      Qnil, make_number (inserted_chars), visit);
+		      Qnil, make_number (inserted), visit);
       CHECK_NUMBER (insval, 0);
-      inserted_chars = XFASTINT (insval);
+      inserted = XFASTINT (insval);
     }
 
   /* Call after-change hooks for the inserted text, aside from the case
      of normal visiting (not with REPLACE), which is done in a new buffer
      "before" the buffer is changed.  */
-  if (inserted_chars > 0 && total > 0
+  if (inserted > 0 && total > 0
       && (NILP (visit) || !NILP (replace)))
-    signal_after_change (PT, 0, inserted_chars);
+    signal_after_change (PT, 0, inserted);
 
   if (set_coding_system)
     Vlast_coding_system_used = coding.symbol;
@@ -3892,16 +3861,13 @@ This does code conversion according to the value of\n\
   if (inserted > 0)
     {
       p = Vafter_insert_file_functions;
-      if (!NILP (coding.post_read_conversion))
-	p = Fcons (coding.post_read_conversion, p);
-
       while (!NILP (p))
 	{
-	  insval = call1 (Fcar (p), make_number (inserted_chars));
+	  insval = call1 (Fcar (p), make_number (inserted));
 	  if (!NILP (insval))
 	    {
 	      CHECK_NUMBER (insval, 0);
-	      inserted_chars = XFASTINT (insval);
+	      inserted = XFASTINT (insval);
 	    }
 	  QUIT;
 	  p = Fcdr (p);
@@ -4010,7 +3976,7 @@ to the file, instead of any buffer contents, and END is ignored.")
 	   had better write it out with the same coding system even if
 	   `enable-multibyte-characters' is nil.
 
-	   If is is not set locally, we anyway have to convert EOL
+	   If it is not set locally, we anyway have to convert EOL
 	   format if the default value of `buffer-file-coding-system'
 	   tells that it is not Unix-like (LF only) format.  */
 	val = current_buffer->buffer_file_coding_system;
@@ -4022,7 +3988,7 @@ to the file, instead of any buffer contents, and END is ignored.")
 	    if (coding_temp.eol_type == CODING_EOL_CRLF
 		|| coding_temp.eol_type == CODING_EOL_CR)
 	      {
-		setup_coding_system (Qemacs_mule, &coding);
+		setup_coding_system (Qraw_text, &coding);
 		coding.eol_type = coding_temp.eol_type;
 		goto done_setup_coding;
 	      }
@@ -4033,19 +3999,22 @@ to the file, instead of any buffer contents, and END is ignored.")
       {
 	Lisp_Object args[7], coding_systems;
 
-	args[0] = Qwrite_region, args[1] = start, args[2] = end,
-	  args[3] = filename, args[4] = append, args[5] = visit,
-	  args[6] = lockname;
+	args[0] = Qwrite_region; args[1] = start; args[2] = end;
+	args[3] = filename; args[4] = append; args[5] = visit;
+	args[6] = lockname;
 	coding_systems = Ffind_operation_coding_system (7, args);
 	val = (CONSP (coding_systems) && !NILP (XCONS (coding_systems)->cdr)
 	       ? XCONS (coding_systems)->cdr
 	       : current_buffer->buffer_file_coding_system);
+	/* Confirm that VAL can surely encode the current region.  */
+	if (Ffboundp (Vselect_safe_coding_system_function))
+	  val = call3 (Vselect_safe_coding_system_function, start, end, val);
       }
     setup_coding_system (Fcheck_coding_system (val), &coding); 
 
   done_setup_coding:
     if (!STRINGP (start) && !NILP (current_buffer->selective_display))
-      coding.selective = 1;
+      coding.mode |= CODING_MODE_SELECTIVE_DISPLAY;
   }
 
   Vlast_coding_system_used = coding.symbol;
@@ -4279,16 +4248,17 @@ to the file, instead of any buffer contents, and END is ignored.")
   else
     {
       /* If file was empty, still need to write the annotations */
-      coding.last_block = 1;
+      coding.mode |= CODING_MODE_LAST_BLOCK;
       failure = 0 > a_write (desc, "", 0, XINT (start), &annotations, &coding);
       save_errno = errno;
     }
 
-  if (CODING_REQUIRE_FLUSHING (&coding) && !coding.last_block
+  if (CODING_REQUIRE_FLUSHING (&coding)
+      && !(coding.mode & CODING_MODE_LAST_BLOCK)
       && ! failure)
     {
       /* We have to flush out a data. */
-      coding.last_block = 1;
+      coding.mode |= CODING_MODE_LAST_BLOCK;
       failure = 0 > e_write (desc, "", 0, &coding);
       save_errno = errno;
     }
@@ -4542,19 +4512,17 @@ e_write (desc, addr, nbytes, coding)
      struct coding_system *coding;
 {
   char buf[WRITE_BUF_SIZE];
-  int produced, consumed;
 
   /* We used to have a code for handling selective display here.  But,
      now it is handled within encode_coding.  */
   while (1)
     {
-      produced = encode_coding (coding, addr, buf, nbytes, WRITE_BUF_SIZE,
-				&consumed);
-      nbytes -= consumed, addr += consumed;
-      if (produced > 0)
+      encode_coding (coding, addr, buf, nbytes, WRITE_BUF_SIZE);
+      nbytes -= coding->consumed, addr += coding->consumed;
+      if (coding->produced > 0)
 	{
-	  produced -= write (desc, buf, produced);
-	  if (produced) return -1;
+	  coding->produced -= write (desc, buf, coding->produced);
+	  if (coding->produced) return -1;
 	}
       if (nbytes <= 0)
 	break;