(Qsafe_charsets): This variable deleted.

(Qsafe_chars, Vchar_coding_system_table, Qchar_coding_system): New
variables.
(coding_safe_chars): New function.
(CODING_SAFE_CHAR_P): New macro.
(CHARSET_OK): New arg C.  Call CODING_SAFE_CHAR_P instead of
checking safe_charsets member of the coding system.  Caller
changed.
(detect_coding_iso2022): New local variable safe_chars.
(DECODE_DESIGNATION): Call CODING_SAFE_CHAR_P instead of checking
safe_charsets member of the coding system.
(decode_coding_iso2022): New local variable safe_chars.
(ENCODE_ISO_CHARACTER_DIMENSION1): Don't check unsafe chars here.
(ENCODE_ISO_CHARACTER_DIMENSION2): Likewise.
(ENCODE_ISO_CHARACTER): Arguments changed.  Caller changed.
(ENCODE_UNSAFE_CHARACTER): New macro.
(encode_coding_iso2022): New local variable safe_chars.  Check
unsafe chars.
(setup_coding_system): Delete the code to initialize
coding->safe_charses
(intersection, find_safe_codings): New functions.
(Ffind_coding_systems_region_internal): New function.
(syms_of_coding): Defsubr it.  Initialize Qsafe_chars,
Qsafe_cding_system.  Make Vchar_coding_system_table a Lisp
variable and initialize it.

src/coding.c

@@ -337,7 +337,7 @@ Lisp_Object Qbuffer_file_coding_system;
 Lisp_Object Qpost_read_conversion, Qpre_write_conversion;
 Lisp_Object Qno_conversion, Qundecided;
 Lisp_Object Qcoding_system_history;
-Lisp_Object Qsafe_charsets;
+Lisp_Object Qsafe_chars;
 Lisp_Object Qvalid_codes;
 
 extern Lisp_Object Qinsert_file_contents, Qwrite_region;
@@ -471,6 +471,28 @@ Lisp_Object Vdefault_process_coding_system;
    to avoid infinite recursive call.  */
 static int inhibit_pre_post_conversion;
 
+/* Char-table containing safe coding systems of each character.  */
+Lisp_Object Vchar_coding_system_table;
+Lisp_Object Qchar_coding_system;
+
+/* Return `safe-chars' property of coding system CODING.  Don't check
+   validity of CODING.  */
+
+Lisp_Object
+coding_safe_chars (coding)
+     struct coding_system *coding;
+{
+  Lisp_Object coding_spec, plist, safe_chars;
+  
+  coding_spec = Fget (coding->symbol, Qcoding_system);
+  plist = XVECTOR (coding_spec)->contents[3];
+  safe_chars = Fplist_get (XVECTOR (coding_spec)->contents[3], Qsafe_chars);
+  return (CHAR_TABLE_P (safe_chars) ? safe_chars : Qt);
+}
+
+#define CODING_SAFE_CHAR_P(safe_chars, c) \
+  (EQ (safe_chars, Qt) || !NILP (CHAR_TABLE_REF (safe_chars, c)))
+
 
 /*** 2. Emacs internal format (emacs-mule) handlers ***/
 
@@ -797,12 +819,14 @@ decode_coding_emacs_mule (coding, source, destination, src_bytes, dst_bytes)
 
 enum iso_code_class_type iso_code_class[256];
 
-#define CHARSET_OK(idx, charset)				\
-  (coding_system_table[idx]					\
-   && (coding_system_table[idx]->safe_charsets[charset]		\
-       || (CODING_SPEC_ISO_REQUESTED_DESIGNATION		\
-            (coding_system_table[idx], charset)			\
-           != CODING_SPEC_ISO_NO_REQUESTED_DESIGNATION)))
+#define CHARSET_OK(idx, charset, c)					\
+  (coding_system_table[idx]						\
+   && (charset == CHARSET_ASCII						\
+       || (safe_chars = coding_safe_chars (coding_system_table[idx]),	\
+	   CODING_SAFE_CHAR_P (safe_chars, c)))				\
+   && (CODING_SPEC_ISO_REQUESTED_DESIGNATION (coding_system_table[idx],	\
+					      charset)			\
+       != CODING_SPEC_ISO_NO_REQUESTED_DESIGNATION))
 
 #define SHIFT_OUT_OK(idx) \
   (CODING_SPEC_ISO_INITIAL_DESIGNATION (coding_system_table[idx], 1) >= 0)
@@ -830,6 +854,7 @@ detect_coding_iso2022 (src, src_end)
   /* Dummy for ONE_MORE_BYTE.  */
   struct coding_system dummy_coding;
   struct coding_system *coding = &dummy_coding;
+  Lisp_Object safe_chars;
 
   reg[0] = CHARSET_ASCII, reg[1] = reg[2] = reg[3] = -1;
   while (mask && src < src_end)
@@ -890,19 +915,20 @@ detect_coding_iso2022 (src, src_end)
 
 	  /* We found a valid designation sequence for CHARSET.  */
 	  mask &= ~CODING_CATEGORY_MASK_ISO_8BIT;
-	  if (CHARSET_OK (CODING_CATEGORY_IDX_ISO_7, charset))
+	  c = MAKE_CHAR (charset, 0, 0);
+	  if (CHARSET_OK (CODING_CATEGORY_IDX_ISO_7, charset, c))
 	    mask_found |= CODING_CATEGORY_MASK_ISO_7;
 	  else
 	    mask &= ~CODING_CATEGORY_MASK_ISO_7;
-	  if (CHARSET_OK (CODING_CATEGORY_IDX_ISO_7_TIGHT, charset))
+	  if (CHARSET_OK (CODING_CATEGORY_IDX_ISO_7_TIGHT, charset, c))
 	    mask_found |= CODING_CATEGORY_MASK_ISO_7_TIGHT;
 	  else
 	    mask &= ~CODING_CATEGORY_MASK_ISO_7_TIGHT;
-	  if (CHARSET_OK (CODING_CATEGORY_IDX_ISO_7_ELSE, charset))
+	  if (CHARSET_OK (CODING_CATEGORY_IDX_ISO_7_ELSE, charset, c))
 	    mask_found |= CODING_CATEGORY_MASK_ISO_7_ELSE;
 	  else
 	    mask &= ~CODING_CATEGORY_MASK_ISO_7_ELSE;
-	  if (CHARSET_OK (CODING_CATEGORY_IDX_ISO_8_ELSE, charset))
+	  if (CHARSET_OK (CODING_CATEGORY_IDX_ISO_8_ELSE, charset, c))
 	    mask_found |= CODING_CATEGORY_MASK_ISO_8_ELSE;
 	  else
 	    mask &= ~CODING_CATEGORY_MASK_ISO_8_ELSE;
@@ -1042,16 +1068,17 @@ detect_coding_iso2022 (src, src_end)
 /* Set designation state into CODING.  */
 #define DECODE_DESIGNATION(reg, dimension, chars, final_char)		   \
   do {									   \
-    int charset;							   \
+    int charset, c;							   \
     									   \
     if (final_char < '0' || final_char >= 128)				   \
       goto label_invalid_code;						   \
     charset = ISO_CHARSET_TABLE (make_number (dimension),		   \
 				 make_number (chars),			   \
 				 make_number (final_char));		   \
+    c = MAKE_CHAR (charset, 0, 0);					   \
     if (charset >= 0							   \
 	&& (CODING_SPEC_ISO_REQUESTED_DESIGNATION (coding, charset) == reg \
-	    || coding->safe_charsets[charset]))				   \
+	    || CODING_SAFE_CHAR_P (safe_chars, c)))			   \
       {									   \
 	if (coding->spec.iso2022.last_invalid_designation_register == 0	   \
 	    && reg == 0							   \
@@ -1238,6 +1265,9 @@ decode_coding_iso2022 (coding, source, destination, src_bytes, dst_bytes)
   unsigned char *src_base;
   int c, charset;
   Lisp_Object translation_table;
+  Lisp_Object safe_chars;
+
+  safe_chars = coding_safe_chars (coding);
 
   if (NILP (Venable_character_translation))
     translation_table = Qnil;
@@ -1684,16 +1714,6 @@ decode_coding_iso2022 (coding, source, destination, src_bytes, dst_bytes)
 	*dst++ = c1 | 0x80;						\
 	break;								\
       }									\
-    else if (coding->flags & CODING_FLAG_ISO_SAFE			\
-	     && !coding->safe_charsets[charset])			\
-      {									\
-	/* We should not encode this character, instead produce one or	\
-	   two `?'s.  */						\
-	*dst++ = CODING_INHIBIT_CHARACTER_SUBSTITUTION;			\
-	if (CHARSET_WIDTH (charset) == 2)				\
-	  *dst++ = CODING_INHIBIT_CHARACTER_SUBSTITUTION;		\
-	break;								\
-      }									\
     else								\
       /* Since CHARSET is not yet invoked to any graphic planes, we	\
 	 must invoke it, or, at first, designate it to some graphic	\
@@ -1727,16 +1747,6 @@ decode_coding_iso2022 (coding, source, destination, src_bytes, dst_bytes)
 	*dst++ = c1 | 0x80, *dst++= c2 | 0x80;				\
 	break;								\
       }									\
-    else if (coding->flags & CODING_FLAG_ISO_SAFE			\
-	     && !coding->safe_charsets[charset])			\
-      {									\
-	/* We should not encode this character, instead produce one or	\
-	   two `?'s.  */						\
-	*dst++ = CODING_INHIBIT_CHARACTER_SUBSTITUTION;			\
-	if (CHARSET_WIDTH (charset) == 2)				\
-	  *dst++ = CODING_INHIBIT_CHARACTER_SUBSTITUTION;		\
-	break;								\
-      }									\
     else								\
       /* Since CHARSET is not yet invoked to any graphic planes, we	\
 	 must invoke it, or, at first, designate it to some graphic	\
@@ -1745,35 +1755,47 @@ decode_coding_iso2022 (coding, source, destination, src_bytes, dst_bytes)
       dst = encode_invocation_designation (charset, coding, dst);	\
   } while (1)
 
-#define ENCODE_ISO_CHARACTER(charset, c1, c2)				\
+#define ENCODE_ISO_CHARACTER(c)					\
+  do {								\
+    int charset, c1, c2;					\
+    								\
+    SPLIT_CHAR (c, charset, c1, c2);				\
+    if (CHARSET_DEFINED_P (charset))				\
+      {								\
+	if (CHARSET_DIMENSION (charset) == 1)			\
+	  {							\
+	    if (charset == CHARSET_ASCII			\
+		&& coding->flags & CODING_FLAG_ISO_USE_ROMAN)	\
+	      charset = charset_latin_jisx0201;			\
+	    ENCODE_ISO_CHARACTER_DIMENSION1 (charset, c1);	\
+	  }							\
+	else							\
+	  {							\
+	    if (charset == charset_jisx0208			\
+		&& coding->flags & CODING_FLAG_ISO_USE_OLDJIS)	\
+	      charset = charset_jisx0208_1978;			\
+	    ENCODE_ISO_CHARACTER_DIMENSION2 (charset, c1, c2);	\
+	  }							\
+      }								\
+    else							\
+      {								\
+	*dst++ = c1;						\
+	if (c2 >= 0)						\
+	  *dst++ = c2;						\
+      }								\
+  } while (0)
+
+
+/* Instead of encoding character C, produce one or two `?'s.  */
+
+#define ENCODE_UNSAFE_CHARACTER(c)					\
   do {									\
-    int alt_charset = charset;						\
-    									\
-    if (CHARSET_DEFINED_P (charset))					\
-      {									\
-	if (CHARSET_DIMENSION (charset) == 1)				\
-	  {								\
-	    if (charset == CHARSET_ASCII				\
-		&& coding->flags & CODING_FLAG_ISO_USE_ROMAN)		\
-	      alt_charset = charset_latin_jisx0201;			\
-	    ENCODE_ISO_CHARACTER_DIMENSION1 (alt_charset, c1);		\
-	  }								\
-	else								\
-	  {								\
-	    if (charset == charset_jisx0208				\
-		&& coding->flags & CODING_FLAG_ISO_USE_OLDJIS)		\
-	      alt_charset = charset_jisx0208_1978;			\
-	    ENCODE_ISO_CHARACTER_DIMENSION2 (alt_charset, c1, c2);	\
-	  }								\
-      }									\
-    else								\
-      {									\
-	*dst++ = c1;							\
-	if (c2 >= 0)							\
-	  *dst++ = c2;							\
-      }									\
+    ENCODE_ISO_CHARACTER (CODING_INHIBIT_CHARACTER_SUBSTITUTION);	\
+    if (CHARSET_WIDTH (CHAR_CHARSET (c)) > 1)				\
+      ENCODE_ISO_CHARACTER (CODING_INHIBIT_CHARACTER_SUBSTITUTION);	\
   } while (0)
 
+
 /* Produce designation and invocation codes at a place pointed by DST
    to use CHARSET.  The element `spec.iso2022' of *CODING is updated.
    Return new DST.  */
@@ -1997,6 +2019,9 @@ encode_coding_iso2022 (coding, source, destination, src_bytes, dst_bytes)
   unsigned char *src_base;
   int c;
   Lisp_Object translation_table;
+  Lisp_Object safe_chars;
+
+  safe_chars = coding_safe_chars (coding);
 
   if (NILP (Venable_character_translation))
     translation_table = Qnil;
@@ -2011,8 +2036,6 @@ encode_coding_iso2022 (coding, source, destination, src_bytes, dst_bytes)
   coding->errors = 0;
   while (1)
     {
-      int charset, c1, c2;
-
       src_base = src;
 
       if (dst >= (dst_bytes ? adjusted_dst_end : (src - 19)))
@@ -2065,8 +2088,11 @@ encode_coding_iso2022 (coding, source, destination, src_bytes, dst_bytes)
 		    }
 		  else
 		    {
-		      SPLIT_CHAR (c, charset, c1, c2);
-		      ENCODE_ISO_CHARACTER (charset, c1, c2);
+		      if (coding->flags & CODING_FLAG_ISO_SAFE
+			  && ! CODING_SAFE_CHAR_P (safe_chars, c))
+			ENCODE_UNSAFE_CHARACTER (c);
+		      else
+			ENCODE_ISO_CHARACTER (c);
 		      if (coding->composing == COMPOSITION_WITH_RULE_ALTCHARS)
 			coding->composition_rule_follows = 1;
 		    }
@@ -2125,17 +2151,17 @@ encode_coding_iso2022 (coding, source, destination, src_bytes, dst_bytes)
 	    }
 	}
       else if (ASCII_BYTE_P (c))
-	ENCODE_ISO_CHARACTER (CHARSET_ASCII, c, /* dummy */ c1);
+	ENCODE_ISO_CHARACTER (c);
       else if (SINGLE_BYTE_CHAR_P (c))
 	{
 	  *dst++ = c;
 	  coding->errors++;
 	}
+      else if (coding->flags & CODING_FLAG_ISO_SAFE
+	       && ! CODING_SAFE_CHAR_P (safe_chars, c))
+	ENCODE_UNSAFE_CHARACTER (c);
       else
-	{
-	  SPLIT_CHAR (c, charset, c1, c2);
-	  ENCODE_ISO_CHARACTER (charset, c1, c2);
-	}
+	ENCODE_ISO_CHARACTER (c);
 
       coding->consumed_char++;
     }
@@ -2970,23 +2996,6 @@ setup_coding_system (coding_system, coding)
   else
     goto label_invalid_coding_system;
   
-  val = Fplist_get (plist, Qsafe_charsets);
-  if (EQ (val, Qt))
-    {
-      for (i = 0; i <= MAX_CHARSET; i++)
-	coding->safe_charsets[i] = 1;
-    }
-  else
-    {
-      bzero (coding->safe_charsets, MAX_CHARSET + 1);
-      while (CONSP (val))
-	{
-	  if ((i = get_charset_id (XCAR (val))) >= 0)
-	    coding->safe_charsets[i] = 1;
-	  val = XCDR (val);
-	}
-    }
-
   /* If the coding system has non-nil `composition' property, enable
      composition handling.  */
   val = Fplist_get (plist, Qcomposition);
@@ -5542,6 +5551,160 @@ highest priority.")
 			       !NILP (highest));
 }
 
+/* Return an intersection of lists L1 and L2.  */
+
+static Lisp_Object
+intersection (l1, l2)
+     Lisp_Object l1, l2;
+{
+  Lisp_Object val;
+
+  for (val = Qnil; CONSP (l1); l1 = XCDR (l1))
+    {
+      if (!NILP (Fmemq (XCAR (l1), l2)))
+	val = Fcons (XCAR (l1), val);
+    }
+  return val;
+}
+
+
+/*  Subroutine for Fsafe_coding_systems_region_internal.
+
+    Return a list of coding systems that safely encode the multibyte
+    text between P and PEND.  SAFE_CODINGS, if non-nil, is a list of
+    possible coding systems.  If it is nil, it means that we have not
+    yet found any coding systems.
+
+    WORK_TABLE is a copy of the char-table Vchar_coding_system_table.  An
+    element of WORK_TABLE is set to t once the element is looked up.
+
+    If a non-ASCII single byte char is found, set
+    *single_byte_char_found to 1.  */
+
+static Lisp_Object
+find_safe_codings (p, pend, safe_codings, work_table, single_byte_char_found)
+     unsigned char *p, *pend;
+     Lisp_Object safe_codings, work_table;
+     int *single_byte_char_found;
+{
+  int c, len, idx;
+  Lisp_Object val;
+
+  while (p < pend)
+    {
+      c = STRING_CHAR_AND_LENGTH (p, pend - p, len);
+      p += len;
+      if (ASCII_BYTE_P (c))
+	/* We can ignore ASCII characters here.  */
+	continue;
+      if (SINGLE_BYTE_CHAR_P (c))
+	*single_byte_char_found = 1;
+      if (NILP (safe_codings))
+	continue;
+      /* Check the safe coding systems for C.  */
+      val = char_table_ref_and_index (work_table, c, &idx);
+      if (EQ (val, Qt))
+	/* This element was already checked.  Ignore it.  */
+	continue;
+      /* Remember that we checked this element.  */
+      CHAR_TABLE_SET (work_table, idx, Qt);
+
+      /* If there are some safe coding systems for C and we have
+	 already found the other set of coding systems for the
+	 different characters, get the intersection of them.  */
+      if (!EQ (safe_codings, Qt) && !NILP (val))
+	val = intersection (safe_codings, val);
+      safe_codings = val;
+    }
+  return safe_codings;
+}
+
+
+/* Return a list of coding systems that safely encode the text between
+   START and END.  If the text contains only ASCII or is unibyte,
+   return t.  */
+
+DEFUN ("find-coding-systems-region-internal",
+       Ffind_coding_systems_region_internal,
+       Sfind_coding_systems_region_internal, 2, 2, 0,
+  "Internal use only.")
+  (start, end)
+     Lisp_Object start, end;
+{
+  Lisp_Object work_table, safe_codings;
+  int non_ascii_p = 0;
+  int single_byte_char_found = 0;
+  unsigned char *p1, *p1end, *p2, *p2end, *p;
+  Lisp_Object args[2];
+
+  if (STRINGP (start))
+    {
+      if (!STRING_MULTIBYTE (start))
+	return Qt;
+      p1 = XSTRING (start)->data, p1end = p1 + STRING_BYTES (XSTRING (start));
+      p2 = p2end = p1end;
+      if (XSTRING (start)->size != STRING_BYTES (XSTRING (start)))
+	non_ascii_p = 1;
+    }
+  else
+    {
+      int from, to, stop;
+
+      CHECK_NUMBER_COERCE_MARKER (start, 0);
+      CHECK_NUMBER_COERCE_MARKER (end, 1);
+      if (XINT (start) < BEG || XINT (end) > Z || XINT (start) > XINT (end))
+	args_out_of_range (start, end);
+      if (NILP (current_buffer->enable_multibyte_characters))
+	return Qt;
+      from = CHAR_TO_BYTE (XINT (start));
+      to = CHAR_TO_BYTE (XINT (end));
+      stop = from < GPT_BYTE && GPT_BYTE < to ? GPT_BYTE : to;
+      p1 = BYTE_POS_ADDR (from), p1end = p1 + (stop - from);
+      if (stop == to)
+	p2 = p2end = p1end;
+      else
+	p2 = BYTE_POS_ADDR (stop), p2end = p2 + (to - stop);
+      if (XINT (end) - XINT (start) != to - from)
+	non_ascii_p = 1;
+    }
+
+  if (!non_ascii_p)
+    {
+      /* We are sure that the text contains no multibyte character.
+	 Check if it contains eight-bit-graphic.  */
+      p = p1;
+      for (p = p1; p < p1end && ASCII_BYTE_P (*p); p++);
+      if (p == p1end)
+	{
+	  for (p = p2; p < p2end && ASCII_BYTE_P (*p); p++);	  
+	  if (p == p2end)
+	    return Qt;
+	}
+    }
+
+  /* The text contains non-ASCII characters.  */
+  work_table = Fcopy_sequence (Vchar_coding_system_table);
+  safe_codings = find_safe_codings (p1, p1end, Qt, work_table,
+				    &single_byte_char_found);
+  if (p2 < p2end)
+    safe_codings = find_safe_codings (p2, p2end, safe_codings, work_table,
+				      &single_byte_char_found);
+
+  if (!single_byte_char_found)
+    {
+      /* Append generic coding systems.  */
+      Lisp_Object args[2];
+      args[0] = safe_codings;
+      args[1] = Fchar_table_extra_slot (Vchar_coding_system_table,
+					make_number (0));
+      safe_codings = Fappend (make_number (2), args);
+    }
+  else
+    safe_codings = Fcons (Qraw_text, Fcons (Qemacs_mule, safe_codings));
+  return safe_codings;
+}
+
+
 Lisp_Object
 code_convert_region1 (start, end, coding_system, encodep)
      Lisp_Object start, end, coding_system;
@@ -6196,8 +6359,18 @@ syms_of_coding ()
   Qtranslation_table_for_encode = intern ("translation-table-for-encode");
   staticpro (&Qtranslation_table_for_encode);
 
-  Qsafe_charsets = intern ("safe-charsets");
-  staticpro (&Qsafe_charsets);
+  Qsafe_chars = intern ("safe-chars");
+  staticpro (&Qsafe_chars);
+
+  Qchar_coding_system = intern ("char-coding-system");
+  staticpro (&Qchar_coding_system);
+
+  /* Intern this now in case it isn't already done.
+     Setting this variable twice is harmless.
+     But don't staticpro it here--that is done in alloc.c.  */
+  Qchar_table_extra_slots = intern ("char-table-extra-slots");
+  Fput (Qsafe_chars, Qchar_table_extra_slots, make_number (0));
+  Fput (Qchar_coding_system, Qchar_table_extra_slots, make_number (1));
 
   Qvalid_codes = intern ("valid-codes");
   staticpro (&Qvalid_codes);
@@ -6214,6 +6387,7 @@ syms_of_coding ()
   defsubr (&Scheck_coding_system);
   defsubr (&Sdetect_coding_region);
   defsubr (&Sdetect_coding_string);
+  defsubr (&Sfind_coding_systems_region_internal);
   defsubr (&Sdecode_coding_region);
   defsubr (&Sencode_coding_region);
   defsubr (&Sdecode_coding_string);
@@ -6417,6 +6591,12 @@ coding system used in each operation can't encode the text.\n\
 The default value is `select-safe-coding-system' (which see).");
   Vselect_safe_coding_system_function = Qnil;
 
+  DEFVAR_LISP ("char-coding-system-table", &Vchar_coding_system_table,
+    "Char-table containing safe coding systems of each characters.\n\
+Each element doesn't include such generic coding systems that can\n\
+encode any characters.   They are in the first extra slot.");
+  Vchar_coding_system_table = Fmake_char_table (Qchar_coding_system, Qnil);
+
   DEFVAR_BOOL ("inhibit-iso-escape-detection",
 	       &inhibit_iso_escape_detection,
     "If non-nil, Emacs ignores ISO2022's escape sequence on code detection.\n\