(setup_coding_system) <4>: Reset member `cr_carryover'.

(ccl_coding_driver): On encoding, initialize ccl->eol_type.
(decode_eol_post_ccl): New function.
(decode_coding): Don't detect EOL format here for CCL based coding
systems.
(decode_coding) <coding_type_ccl>: Handle carryovered CR.  Call
decode_eol_post_ccl after running the CCL program.
(code_convert_region): Don't detect EOL format here for CCL based
coding systems.
(decode_coding_string): Likewise.

1 files changed, 152 insertions, 5 deletions

diff --git a/src/coding.c b/src/coding.c
index 0b70480b965..d02c27dc478 100644
--- a/src/coding.c
+++ b/src/coding.c
@@ -3202,6 +3202,7 @@ setup_coding_system (coding_system, coding)
 	  }
       }
       coding->common_flags |= CODING_REQUIRE_FLUSHING_MASK;
+      coding->spec.ccl.cr_carryover = 0;
       break;
 
     case 5:
@@ -3883,7 +3884,8 @@ ccl_coding_driver (coding, source, destination, src_bytes, dst_bytes, encodep)
   int result;
 
   ccl->last_block = coding->mode & CODING_MODE_LAST_BLOCK;
-
+  if (encodep)
+    ccl->eol_type = coding->eol_type;
   coding->produced = ccl_driver (ccl, source, destination,
 				 src_bytes, dst_bytes, &(coding->consumed));
   if (encodep)
@@ -3916,6 +3918,136 @@ ccl_coding_driver (coding, source, destination, src_bytes, dst_bytes, encodep)
   return result;
 }
 
+/* Decode EOL format of the text at PTR of BYTES length destructively
+   according to CODING->eol_type.  This is called after the CCL
+   program produced a decoded text at PTR.  If we do CRLF->LF
+   conversion, update CODING->produced and CODING->produced_char.  */
+
+static void
+decode_eol_post_ccl (coding, ptr, bytes)
+     struct coding_system *coding;
+     unsigned char *ptr;
+     int bytes;
+{
+  Lisp_Object val, saved_coding_symbol;
+  unsigned char *pend = ptr + bytes;
+  int dummy;
+
+  /* Remember the current coding system symbol.  We set it back when
+     an inconsistent EOL is found so that `last-coding-system-used' is
+     set to the coding system that doesn't specify EOL conversion.  */
+  saved_coding_symbol = coding->symbol;
+
+  coding->spec.ccl.cr_carryover = 0;
+  if (coding->eol_type == CODING_EOL_UNDECIDED)
+    {
+      /* Here, to avoid the call of setup_coding_system, we directly
+	 call detect_eol_type.  */
+      coding->eol_type = detect_eol_type (ptr, bytes, &dummy);
+      val = Fget (coding->symbol, Qeol_type);
+      if (VECTORP (val) && XVECTOR (val)->size == 3)
+	coding->symbol = XVECTOR (val)->contents[coding->eol_type];
+      coding->mode |= CODING_MODE_INHIBIT_INCONSISTENT_EOL;
+    }
+
+  if (coding->eol_type == CODING_EOL_LF)
+    {
+      /* We have nothing to do.  */
+      ptr = pend;
+    }
+  else if (coding->eol_type == CODING_EOL_CRLF)
+    {
+      unsigned char *pstart = ptr, *p = ptr;
+
+      if (! (coding->mode & CODING_MODE_LAST_BLOCK)
+	  && *(pend - 1) == '\r')
+	{
+	  /* If the last character is CR, we can't handle it here
+	     because LF will be in the not-yet-decoded source text.
+	     Recorded that the CR is not yet processed.  */
+	  coding->spec.ccl.cr_carryover = 1;
+	  coding->produced--;
+	  coding->produced_char--;
+	  pend--;
+	}
+      while (ptr < pend)
+	{
+	  if (*ptr == '\r')
+	    {
+	      if (ptr + 1 < pend && *(ptr + 1) == '\n')
+		{
+		  *p++ = '\n';
+		  ptr += 2;
+		}
+	      else
+		{
+		  if (coding->mode & CODING_MODE_INHIBIT_INCONSISTENT_EOL)
+		    goto undo_eol_conversion;
+		  *p++ = *ptr++;
+		}
+	    }
+	  else if (*ptr == '\n'
+		   && coding->mode & CODING_MODE_INHIBIT_INCONSISTENT_EOL)
+	    goto undo_eol_conversion;
+	  else
+	    *p++ = *ptr++;
+	  continue;
+
+	undo_eol_conversion:
+	  /* We have faced with inconsistent EOL format at PTR.
+	     Convert all LFs before PTR back to CRLFs.  */
+	  for (p--, ptr--; p >= pstart; p--)
+	    {
+	      if (*p == '\n')
+		*ptr-- = '\n', *ptr-- = '\r';
+	      else
+		*ptr-- = *p;
+	    }
+	  /*  If carryover is recorded, cancel it because we don't
+	      convert CRLF anymore.  */
+	  if (coding->spec.ccl.cr_carryover)
+	    {
+	      coding->spec.ccl.cr_carryover = 0;
+	      coding->produced++;
+	      coding->produced_char++;
+	      pend++;
+	    }
+	  p = ptr = pend;
+	  coding->eol_type = CODING_EOL_LF;
+	  coding->symbol = saved_coding_symbol;
+	}
+      if (p < pend)
+	{
+	  /* As each two-byte sequence CRLF was converted to LF, (PEND
+	     - P) is the number of deleted characters.  */
+	  coding->produced -= pend - p;
+	  coding->produced_char -= pend - p;
+	}
+    }
+  else			/* i.e. coding->eol_type == CODING_EOL_CR */
+    {
+      unsigned char *p = ptr;
+
+      for (; ptr < pend; ptr++)
+	{
+	  if (*ptr == '\r')
+	    *ptr = '\n';
+	  else if (*ptr == '\n'
+		   && coding->mode & CODING_MODE_INHIBIT_INCONSISTENT_EOL)
+	    {
+	      for (; p < ptr; p++)
+		{
+		  if (*p == '\n')
+		    *p = '\r';
+		}
+	      ptr = pend;
+	      coding->eol_type = CODING_EOL_LF;
+	      coding->symbol = saved_coding_symbol;
+	    }
+	}
+    }
+}
+
 /* See "GENERAL NOTES about `decode_coding_XXX ()' functions".  Before
    decoding, it may detect coding system and format of end-of-line if
    those are not yet decided.  The source should be unibyte, the
@@ -3931,7 +4063,8 @@ decode_coding (coding, source, destination, src_bytes, dst_bytes)
   if (coding->type == coding_type_undecided)
     detect_coding (coding, source, src_bytes);
 
-  if (coding->eol_type == CODING_EOL_UNDECIDED)
+  if (coding->eol_type == CODING_EOL_UNDECIDED
+      && coding->type != coding_type_ccl)
     detect_eol (coding, source, src_bytes);
 
   coding->produced = coding->produced_char = 0;
@@ -3962,8 +4095,20 @@ decode_coding (coding, source, destination, src_bytes, dst_bytes)
       break;
 
     case coding_type_ccl:
-      ccl_coding_driver (coding, source, destination,
+      if (coding->spec.ccl.cr_carryover)
+	{
+	  /* Set the CR which is not processed by the previous call of
+	     decode_eol_post_ccl in DESTINATION.  */
+	  *destination = '\r';
+	  coding->produced++;
+	  coding->produced_char++;
+	  dst_bytes--;
+	}
+      ccl_coding_driver (coding, source,
+			 destination + coding->spec.ccl.cr_carryover,
 			 src_bytes, dst_bytes, 0);
+      if (coding->eol_type != CODING_EOL_LF)
+	decode_eol_post_ccl (coding, destination, coding->produced);
       break;
 
     default:
@@ -4580,7 +4725,8 @@ code_convert_region (from, from_byte, to, to_byte, coding, encodep, replace)
 	       encodings again in vain.  */
 	    coding->type = coding_type_emacs_mule;
 	}
-      if (coding->eol_type == CODING_EOL_UNDECIDED)
+      if (coding->eol_type == CODING_EOL_UNDECIDED
+	  && coding->type != coding_type_ccl)
 	{
 	  saved_coding_symbol = coding->symbol;
 	  detect_eol (coding, BYTE_POS_ADDR (from_byte), len_byte);
@@ -5038,7 +5184,8 @@ decode_coding_string (str, coding, nocopy)
 	  if (coding->type == coding_type_undecided)
 	    coding->type = coding_type_emacs_mule;
 	}
-      if (coding->eol_type == CODING_EOL_UNDECIDED)
+      if (coding->eol_type == CODING_EOL_UNDECIDED
+	  && coding->type != coding_type_ccl)
 	{
 	  saved_coding_symbol = coding->symbol;
 	  detect_eol (coding, XSTRING (str)->data, to_byte);