Add an EXFUN for `Ffind_char'.

[chise/xemacs-chise.git-] / src / text-coding.c

diff --git a/src/text-coding.c b/src/text-coding.c
index 0c0f694..187d2a9 100644 (file)
--- a/src/text-coding.c
+++ b/src/text-coding.c
@@ -2260,7 +2260,7 @@ struct decoding_stream
 };
 
 #ifdef UTF2000
-extern Lisp_Object Vcharacter_composition_table;
+extern Lisp_Object Qcomposition;
 
 INLINE_HEADER void
 decode_flush_er_chars (struct decoding_stream *str, unsigned_char_dynarr* dst);
@@ -2274,11 +2274,11 @@ decode_flush_er_chars (struct decoding_stream *str, unsigned_char_dynarr* dst)
     }
 }
 
-void decode_add_er_char(struct decoding_stream *str, Emchar character,
-                       unsigned_char_dynarr* dst);
+void decode_add_er_char (struct decoding_stream *str, Emchar character,
+                        unsigned_char_dynarr* dst);
 void
-decode_add_er_char(struct decoding_stream *str, Emchar c,
-                  unsigned_char_dynarr* dst)
+decode_add_er_char (struct decoding_stream *str, Emchar c,
+                   unsigned_char_dynarr* dst)
 {
   if (str->er_counter == 0)
     {
@@ -2392,27 +2392,26 @@ COMPOSE_FLUSH_CHARS (struct decoding_stream *str, unsigned_char_dynarr* dst)
   unsigned i;
 
   for (i = 0; i < str->combined_char_count; i++)
-    DECODE_ADD_UCS_CHAR (str->combined_chars[i], dst);
+    decode_add_er_char (str, str->combined_chars[i], dst);
   str->combined_char_count = 0;
   str->combining_table = Qnil;
 }
 
-void COMPOSE_ADD_CHAR(struct decoding_stream *str, Emchar character,
-                     unsigned_char_dynarr* dst);
+void COMPOSE_ADD_CHAR (struct decoding_stream *str, Emchar character,
+                      unsigned_char_dynarr* dst);
 void
-COMPOSE_ADD_CHAR(struct decoding_stream *str,
-                Emchar character, unsigned_char_dynarr* dst)
+COMPOSE_ADD_CHAR (struct decoding_stream *str,
+                 Emchar character, unsigned_char_dynarr* dst)
 {
   if (CODING_SYSTEM_DISABLE_COMPOSITION (str->codesys))
-    DECODE_ADD_UCS_CHAR (character, dst);
-  else if (!CHAR_TABLEP (str->combining_table))
+    decode_add_er_char (str, character, dst);
+  else if (!CONSP (str->combining_table))
     {
       Lisp_Object ret
-       = get_char_id_table (XCHAR_TABLE(Vcharacter_composition_table),
-                            character);
+       = Fget_char_attribute (make_char (character), Qcomposition, Qnil);
 
       if (NILP (ret))
-       DECODE_ADD_UCS_CHAR (character, dst);
+       decode_add_er_char (str, character, dst);
       else
        {
          str->combined_chars[0] = character;
@@ -2422,19 +2421,15 @@ COMPOSE_ADD_CHAR(struct decoding_stream *str,
     }
   else
     {
-      Lisp_Object ret
-       = get_char_id_table (XCHAR_TABLE(str->combining_table),
-                            character);
+      Lisp_Object ret = Fcdr (Fassq (make_char (character), str->combining_table));
 
       if (CHARP (ret))
        {
          Emchar char2 = XCHARVAL (ret);
-         ret =
-           get_char_id_table (XCHAR_TABLE(Vcharacter_composition_table),
-                              char2);
+         ret = Fget_char_attribute (make_char (character), Qcomposition, Qnil);
          if (NILP (ret))
            {
-             DECODE_ADD_UCS_CHAR (char2, dst);
+             decode_add_er_char (str, character, dst);
              str->combined_char_count = 0;
              str->combining_table = Qnil;
            }
@@ -2445,15 +2440,10 @@ COMPOSE_ADD_CHAR(struct decoding_stream *str,
              str->combining_table = ret;
            }
        }
-      else if (CHAR_TABLEP (ret))
-       {
-         str->combined_chars[str->combined_char_count++] = character;
-         str->combining_table = ret;
-       }
       else
        {
          COMPOSE_FLUSH_CHARS (str, dst);
-         DECODE_ADD_UCS_CHAR (character, dst);
+         decode_add_er_char (str, character, dst);
        }
     }
 }
@@ -4164,15 +4154,17 @@ decode_coding_utf8 (Lstream *decoding, const Extbyte *src,
        {
          if ( c < ' ' )
            {
+             COMPOSE_FLUSH_CHARS (str, dst);
              decode_flush_er_chars (str, dst);
              DECODE_HANDLE_EOL_TYPE (eol_type, c, flags, dst);
              DECODE_ADD_UCS_CHAR (c, dst);
            }
          else if ( c < 0xC0 )
-           decode_add_er_char (str, c, dst);
+           /* decode_add_er_char (str, c, dst); */
+           COMPOSE_ADD_CHAR (str, c, dst);
          else
            {
-             decode_flush_er_chars (str, dst);
+             /* decode_flush_er_chars (str, dst); */
              if ( c < 0xE0 )
                {
                  cpos = c & 0x1f;
@@ -4205,7 +4197,8 @@ decode_coding_utf8 (Lstream *decoding, const Extbyte *src,
          cpos = ( cpos << 6 ) | ( c & 0x3f );
          if (counter == 1)
            {
-             DECODE_ADD_UCS_CHAR (cpos, dst);
+             /* DECODE_ADD_UCS_CHAR (cpos, dst); */
+             COMPOSE_ADD_CHAR (str, cpos, dst);
              cpos = 0;
              counter = 0;
            }
@@ -4214,6 +4207,8 @@ decode_coding_utf8 (Lstream *decoding, const Extbyte *src,
        }
       else
        {
+         COMPOSE_FLUSH_CHARS (str, dst);
+         decode_flush_er_chars (str, dst);
          decode_output_utf8_partial_char (counter, cpos, dst);
          DECODE_ADD_BINARY_CHAR (c, dst);
          cpos = 0;
@@ -4224,6 +4219,7 @@ decode_coding_utf8 (Lstream *decoding, const Extbyte *src,
 
   if (flags & CODING_STATE_END)
     {
+      COMPOSE_FLUSH_CHARS (str, dst);
       decode_flush_er_chars (str, dst);
       if (counter > 0)
        {
@@ -5200,6 +5196,7 @@ decode_coding_iso2022 (Lstream *decoding, const Extbyte *src,
 
                case ISO_ESC_LITERAL:
                  COMPOSE_FLUSH_CHARS (str, dst);
+                 decode_flush_er_chars (str, dst);
                  DECODE_ADD_BINARY_CHAR (c, dst);
                  break;
 
@@ -5221,6 +5218,7 @@ decode_coding_iso2022 (Lstream *decoding, const Extbyte *src,
              /* Output the (possibly invalid) sequence */
              int i;
              COMPOSE_FLUSH_CHARS (str, dst);
+             decode_flush_er_chars (str, dst);
              for (i = 0; i < str->iso2022.esc_bytes_index; i++)
                DECODE_ADD_BINARY_CHAR (str->iso2022.esc_bytes[i], dst);
              flags &= CODING_STATE_ISO2022_LOCK;
@@ -5232,6 +5230,7 @@ decode_coding_iso2022 (Lstream *decoding, const Extbyte *src,
                     escape sequence; it could mess things up anyway.
                     Just add it now. */
                  COMPOSE_FLUSH_CHARS (str, dst);
+                 decode_flush_er_chars (str, dst);
                  DECODE_ADD_BINARY_CHAR (c, dst);
                }
            }
@@ -5248,6 +5247,7 @@ decode_coding_iso2022 (Lstream *decoding, const Extbyte *src,
          if (counter)
            {
              COMPOSE_FLUSH_CHARS (str, dst);
+             decode_flush_er_chars (str, dst);
              while (counter > 0)
                {
                  counter--;
@@ -5264,12 +5264,14 @@ decode_coding_iso2022 (Lstream *decoding, const Extbyte *src,
          if (flags & CODING_STATE_SS2)
            {
              COMPOSE_FLUSH_CHARS (str, dst);
+             decode_flush_er_chars (str, dst);
              DECODE_ADD_BINARY_CHAR (ISO_CODE_SS2, dst);
              flags &= ~CODING_STATE_SS2;
            }
          if (flags & CODING_STATE_SS3)
            {
              COMPOSE_FLUSH_CHARS (str, dst);
+             decode_flush_er_chars (str, dst);
              DECODE_ADD_BINARY_CHAR (ISO_CODE_SS3, dst);
              flags &= ~CODING_STATE_SS3;
            }
@@ -5281,6 +5283,7 @@ decode_coding_iso2022 (Lstream *decoding, const Extbyte *src,
          if (c == '\r')
            {
              COMPOSE_FLUSH_CHARS (str, dst);
+             decode_flush_er_chars (str, dst);
              if (eol_type == EOL_CR)
                Dynarr_add (dst, '\n');
              else if (eol_type != EOL_CRLF || flags & CODING_STATE_CR)
@@ -5304,6 +5307,7 @@ decode_coding_iso2022 (Lstream *decoding, const Extbyte *src,
          if (!parse_iso2022_esc (coding_system, &str->iso2022, c, &flags, 1))
            {
              COMPOSE_FLUSH_CHARS (str, dst);
+             decode_flush_er_chars (str, dst);
              DECODE_ADD_BINARY_CHAR (c, dst);
            }
        }
@@ -5319,6 +5323,7 @@ decode_coding_iso2022 (Lstream *decoding, const Extbyte *src,
          if (c == '\r')
            {
              COMPOSE_FLUSH_CHARS (str, dst);
+             decode_flush_er_chars (str, dst);
              if (eol_type == EOL_CR)
                Dynarr_add (dst, '\n');
              else if (eol_type != EOL_CRLF || flags & CODING_STATE_CR)
@@ -5355,6 +5360,7 @@ decode_coding_iso2022 (Lstream *decoding, const Extbyte *src,
               to preserve it for the output. */
            {
              COMPOSE_FLUSH_CHARS (str, dst);
+             decode_flush_er_chars (str, dst);
              while (counter > 0)
                {
                  counter--;
@@ -5458,6 +5464,7 @@ decode_coding_iso2022 (Lstream *decoding, const Extbyte *src,
   if (flags & CODING_STATE_END)
     {
       COMPOSE_FLUSH_CHARS (str, dst);
+      decode_flush_er_chars (str, dst);
       DECODE_OUTPUT_PARTIAL_CHAR (cpos);
     }
   str->flags   = flags;