Initial revision

10 files changed, 9038 insertions, 0 deletions

diff --git a/src/category.c b/src/category.c
new file mode 100644
index 00000000000..8bdaee9e5af
--- /dev/null
+++ b/src/category.c
@@ -0,0 +1,665 @@
+/* GNU Emacs routines to deal with category tables.
+   Ver.1.0
+
+   Copyright (C) 1995 Free Software Foundation, Inc.
+   Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+
+/* Here we handle three objects: category, category set, and category
+   table.  Read comments in the file category.h to understand them.  */
+
+#include <config.h>
+#include <ctype.h>
+#include "lisp.h"
+#include "buffer.h"
+#include "charset.h"
+#include "category.h"
+
+/* The version number of the latest category table.  Each category
+   table has a unique version number.  It is assigned a new number
+   also when it is modified.  When a regular expression is compiled
+   into the struct re_pattern_buffer, the version number of the
+   category table (of the current buffer) at that moment is also
+   embedded in the structure.
+
+   For the moment, we are not using this feature.  */
+static int category_table_version;
+
+Lisp_Object Qcategory_table, Qcategoryp, Qcategorysetp, Qcategory_table_p;
+
+/* Variables to determine word boundary.  */
+Lisp_Object Vword_combining_categories, Vword_separating_categories;
+
+/* Temporary internal variable used in macro CHAR_HAS_CATEGORY.  */
+Lisp_Object _temp_category_set;
+
+
+/* Category set staff.  */
+
+DEFUN ("make-category-set", Fmake_category_set, Smake_category_set, 1, 1, 0,
+  "Return a newly created category-set which contains CATEGORIES.\n\
+CATEGORIES is a string of category mnemonics.")
+  (categories)
+     Lisp_Object categories;
+{
+  Lisp_Object val;
+  int len;
+
+  CHECK_STRING (categories, 0);
+  val = MAKE_CATEGORY_SET;
+
+  len = XSTRING (categories)->size;
+  while (--len >= 0)
+    {
+      Lisp_Object category = make_number (XSTRING (categories)->data[len]);
+
+      CHECK_CATEGORY (category, 0);
+      SET_CATEGORY_SET (val, category, Qt);
+    }
+  return val;
+}
+
+
+/* Category staff.  */
+
+Lisp_Object check_category_table ();
+
+DEFUN ("define-category", Fdefine_category, Sdefine_category, 2, 3, 0,
+  "Define CHAR as a category which is described by DOCSTRING.\n\
+CHAR should be a visible letter of ` ' thru `~'.\n\
+DOCSTRING is a documentation string of the category.\n\
+The category is defined only in category table TABLE, which defaults to\n\
+ the current buffer's category table.")
+  (category, docstring, table)
+     Lisp_Object category, docstring, table;
+{
+  CHECK_CATEGORY (category, 0);
+  CHECK_STRING (docstring, 1);
+  table = check_category_table (table);
+
+  if (!NILP (CATEGORY_DOCSTRING (table, XFASTINT (category))))
+    error ("Category `%c' is already defined", XFASTINT (category));
+  CATEGORY_DOCSTRING (table, XFASTINT (category)) = docstring;
+
+  return Qnil;
+}
+
+DEFUN ("category-docstring", Fcategory_docstring, Scategory_docstring, 1, 2, 0,
+  "Return a documentation string of CATEGORY.\n\
+Optional second arg specifies CATEGORY-TABLE,\n\
+ which defaults to the current buffer's category table.")
+  (category, table)
+     Lisp_Object category, table;
+{
+  Lisp_Object doc;
+
+  CHECK_CATEGORY (category, 0);
+  table = check_category_table (table);
+
+  return CATEGORY_DOCSTRING (table, XFASTINT (category));
+}
+
+DEFUN ("get-unused-category", Fget_unused_category, Sget_unused_category,
+       0, 1, 0,
+  "Return a category which is not yet defined.\n\
+If total number of categories has reached the limit (95), return nil.\n\
+Optional argument specifies CATEGORY-TABLE,\n\
+ which defaults to the current buffer's category table.")
+  (table)
+     Lisp_Object table;
+{
+  int i;
+  Lisp_Object docstring_vector;
+
+  table = check_category_table (table);
+
+  for (i = ' '; i <= '~'; i++)
+    if (NILP (CATEGORY_DOCSTRING (table, i)))
+      return make_number (i);
+
+  return Qnil;
+}
+
+
+/* Category-table staff.  */
+
+DEFUN ("category-table-p", Fcategory_table_p, Scategory_table_p, 1, 1, 0,
+  "Return t if ARG is a category table.")
+  (arg)
+     Lisp_Object arg;
+{
+  if (CHAR_TABLE_P (arg)
+      && EQ (XCHAR_TABLE (arg)->purpose, Qcategory_table)
+      && CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (arg)) == 2)
+    return Qt;
+  return Qnil;
+}
+
+/* If TABLE is nil, return the current category table.  If TABLE is
+   not nil, check the validity of TABLE as a category table.  If
+   valid, return TABLE itself, but if not valid, signal an error of
+   wrong-type-argument.  */
+
+Lisp_Object
+check_category_table (table)
+     Lisp_Object table;
+{
+  register Lisp_Object tem;
+  if (NILP (table))
+    return current_buffer->category_table;
+  while (tem = Fcategory_table_p (table), NILP (tem))
+    table = wrong_type_argument (Qcategory_table_p, table);
+  return table;
+}   
+
+DEFUN ("category-table", Fcategory_table, Scategory_table, 0, 0, 0,
+  "Return the current category table.\n\
+This is the one specified by the current buffer.")
+  ()
+{
+  return current_buffer->category_table;
+}
+
+DEFUN ("standard-category-table", Fstandard_category_table,
+   Sstandard_category_table, 0, 0, 0,
+  "Return the standard category table.\n\
+This is the one used for new buffers.")
+  ()
+{
+  return Vstandard_category_table;
+}
+
+/* Return a copy of category table TABLE.  We can't simply use the
+   function copy-sequence because no contents should be shared between
+   the original and the copy.
+
+   If TOP is 1, we at first copy the tree structure of the table.  */
+
+Lisp_Object
+copy_category_table (table, top)
+     Lisp_Object table;
+{
+  int i;
+
+  if (top)
+    table = Fcopy_sequence (table);
+  else if (!NILP (XCHAR_TABLE (table)->defalt))
+    XCHAR_TABLE (table)->defalt
+      = Fcopy_sequence (XCHAR_TABLE (table)->defalt);
+
+  for (i = 0; i < CHAR_TABLE_ORDINARY_SLOTS; i++)
+    {
+      Lisp_Object idx = make_number (i);
+      Lisp_Object val = Faref (table, idx);
+
+      if (NILP (val))           /* Do nothing because we can share nil.  */
+        ;
+      else if (CATEGORY_SET_P (val))
+        Faset (table, idx, Fcopy_sequence (val));
+      else if (CHAR_TABLE_P (val))
+        Faset (table, idx, copy_category_table (val, 0));
+      else                      /* Invalid contents.  */
+        Faset (table, idx, Qnil);
+    }
+
+  return table;
+}
+
+DEFUN ("copy-category-table", Fcopy_category_table, Scopy_category_table,
+       0, 1, 0,
+  "Construct a new category table and return it.\n\
+It is a copy of the TABLE, which defaults to the standard category table.")
+  (table)
+     Lisp_Object table;
+{
+  if (!NILP (table))
+    check_category_table (table);
+  else
+    table = Vstandard_category_table;
+
+  return copy_category_table (table, 1);
+}
+
+DEFUN ("set-category-table", Fset_category_table, Sset_category_table, 1, 1, 0,
+  "Select a new category table for the current buffer.\n\
+One argument, a category table.")
+  (table)
+     Lisp_Object table;
+{
+  table = check_category_table (table);
+  current_buffer->category_table = table;
+  /* Indicate that this buffer now has a specified category table.  */
+  current_buffer->local_var_flags
+    |= XFASTINT (buffer_local_flags.category_table);
+  return table;
+}
+
+
+DEFUN ("char-category-set", Fchar_category_set, Schar_category_set, 1, 1, 0,
+  "Return a category set of CHAR.")
+  (ch)
+     Lisp_Object ch;
+{
+  Lisp_Object val;
+  int charset;
+  unsigned char c1, c2;
+
+  CHECK_NUMBER (ch, 0);
+  return CATEGORY_SET (XFASTINT (ch));
+}
+
+DEFUN ("category-set-mnemonics", Fcategory_set_mnemonics,
+       Scategory_set_mnemonics, 1, 1, 0,
+  "Return a string of mnemonics of all categories in CATEGORY-SET.")
+  (category_set)
+     Lisp_Object category_set;
+{
+  int i, j;
+  char str[96];
+
+  CHECK_CATEGORY_SET (category_set, 0);
+
+  j = 0;
+  for (i = 32; i < 127; i++)
+    if (CATEGORY_MEMBER (i, category_set))
+      str[j++] = i;
+  str[j] = '\0';
+
+  return build_string (str);
+}
+
+/* Modify all category sets stored under category table TABLE so that
+   they contain (SET_VALUE is t) or don't contain (SET_VALUE is nil)
+   CATEGORY.  */
+
+void
+modify_lower_category_set (table, category, set_value)
+     Lisp_Object table, category, set_value;
+{
+  Lisp_Object val;
+  int i;
+
+  if (NILP (XCHAR_TABLE (table)->defalt))
+    {
+      val = MAKE_CATEGORY_SET;
+      SET_CATEGORY_SET (val, category, set_value);
+      XCHAR_TABLE (table)->defalt = val;
+    }
+
+  for (i = 32; i < CHAR_TABLE_ORDINARY_SLOTS; i++)
+    {
+      val = XCHAR_TABLE (table)->contents[i];
+
+      if (CATEGORY_SET_P (val))
+        SET_CATEGORY_SET (val, category, set_value);
+      else if (CHAR_TABLE_P (val))
+        modify_lower_category_set (val, category, set_value);
+    }
+}
+
+void
+set_category_set (category_set, category, val)
+     Lisp_Object category_set, category, val;
+{
+  do {
+    int idx = XINT (category) / 8;
+    unsigned char bits = 1 << (XINT (category) % 8);
+
+    if (NILP (val))
+      XCATEGORY_SET (category_set)->data[idx] &= ~bits;
+    else
+      XCATEGORY_SET (category_set)->data[idx] |= bits;
+  } while (0);
+}
+
+DEFUN ("modify-category-entry", Fmodify_category_entry,
+       Smodify_category_entry, 2, 4, 0,
+  "Modify the category set of CHAR by adding CATEGORY to it.\n\
+The category is changed only for table TABLE, which defaults to\n\
+ the current buffer's category table.\n\
+If optional forth argument RESET is non NIL,\n\
+ CATEGORY is deleted from the category set instead of being added.")
+  (ch, category, table, reset)
+     Lisp_Object ch, category, table, reset;
+{
+  int c, charset, c1, c2;
+  Lisp_Object set_value;        /* Actual value to be set in category sets.  */
+  Lisp_Object val, category_set;
+
+  CHECK_NUMBER (ch, 0);
+  c = XINT (ch);
+  CHECK_CATEGORY (category, 1);
+  table = check_category_table (table);
+
+  if (NILP (CATEGORY_DOCSTRING (table, XFASTINT (category))))
+    error ("Undefined category: %c", XFASTINT (category));
+  
+  set_value = NILP (reset) ? Qt : Qnil;
+
+  if (SINGLE_BYTE_CHAR_P (c))
+    {
+      val = XCHAR_TABLE (table)->contents[c];
+      if (!CATEGORY_SET_P (val))
+        XCHAR_TABLE (table)->contents[c] = (val = MAKE_CATEGORY_SET);
+      SET_CATEGORY_SET (val, category, set_value);
+      return Qnil;
+    }
+
+  if (COMPOSITE_CHAR_P (c))
+    c = cmpchar_component (c, 0);
+  SPLIT_NON_ASCII_CHAR (c, charset, c1, c2);
+
+  /* The top level table.  */
+  val = XCHAR_TABLE (table)->contents[charset];
+  if (NILP (val))
+    {
+      category_set = MAKE_CATEGORY_SET;
+      XCHAR_TABLE (table)->contents[charset] = category_set;
+    }
+  else if (CATEGORY_SET_P (val))
+    category_set = val;
+
+  if (!c1)
+    {
+      /* Only a charset is specified.  */
+      if (CHAR_TABLE_P (val))
+        /* All characters in CHARSET should be the same as for CATEGORY.  */
+        modify_lower_category_set (val, category, set_value);
+      else
+        SET_CATEGORY_SET (category_set, category, set_value);
+      return Qnil;
+    }
+
+  /* The second level table.  */
+  if (!CHAR_TABLE_P (val))
+    {
+      val = Fmake_char_table (Qnil, Qnil);
+      XCHAR_TABLE (table)->contents[charset] = val;
+      /* We must set default category set of CHARSET in `defalt' slot.  */
+      XCHAR_TABLE (val)->defalt = category_set;
+    }
+  table = val;
+
+  val = XCHAR_TABLE (table)->contents[c1];
+  if (NILP (val))
+    {
+      category_set = Fcopy_sequence (XCHAR_TABLE (table)->defalt);
+      XCHAR_TABLE (table)->contents[c1] = category_set;
+    }
+  else if (CATEGORY_SET_P (val))
+    category_set = val;
+
+  if (!c2)
+    {
+      if (CHAR_TABLE_P (val))
+        /* All characters in C1 group of CHARSET should be the same as
+           for CATEGORY.  */
+        modify_lower_category_set (val, category, set_value);
+      else
+        SET_CATEGORY_SET (category_set, category, set_value);
+      return Qnil;
+    }
+
+  /* The third (bottom) level table.  */
+  if (!CHAR_TABLE_P (val))
+    {
+      val = Fmake_char_table (Qnil, Qnil);
+      XCHAR_TABLE (table)->contents[c1] = val;
+      /* We must set default category set of CHARSET and C1 in
+         `defalt' slot.  */
+      XCHAR_TABLE (val)->defalt = category_set;
+    }
+  table = val;
+
+  val = XCHAR_TABLE (table)->contents[c2];
+  if (NILP (val))
+    {
+      category_set = Fcopy_sequence (XCHAR_TABLE (table)->defalt);
+      XCHAR_TABLE (table)->contents[c2] = category_set;
+    }
+  else if (CATEGORY_SET_P (val))
+    category_set = val;
+  else
+    /* This should never happen.  */
+    error ("Invalid category table");
+
+  SET_CATEGORY_SET (category_set, category, set_value);
+
+  return Qnil;
+}
+
+/* Dump category table to buffer in human-readable format */
+
+static void
+describe_category (value)
+    Lisp_Object value;
+{
+  Lisp_Object mnemonics;
+
+  Findent_to (make_number (16), make_number (1));
+
+  if (NILP (value))
+    {
+      insert_string ("default\n");
+      return;
+    }
+
+  if (!CATEGORY_SET_P (value))
+    {
+      insert_string ("invalid\n");
+      return;
+    }
+
+  mnemonics = Fcategory_set_mnemonics (value);
+  insert_from_string (mnemonics, 0, XSTRING (mnemonics)->size, 0);
+  insert_string ("\n");
+  return;
+}
+
+static Lisp_Object
+describe_category_1 (vector)
+     Lisp_Object vector;
+{
+  struct buffer *old = current_buffer;
+  set_buffer_internal (XBUFFER (Vstandard_output));
+  describe_vector (vector, Qnil, describe_category, 0, Qnil, Qnil);
+  {
+    int i;
+    Lisp_Object docs = XCHAR_TABLE (vector)->extras[0];
+    Lisp_Object elt;
+
+    if (!VECTORP (docs) || XVECTOR (docs)->size != 95)
+      {
+        insert_string ("Invalid first extra slot in this char table\n");
+        return Qnil;
+      }
+      
+    insert_string ("Meanings of mnemonice characters are:\n");
+    for (i = 0; i < 95; i++)
+      {
+        elt = XVECTOR (docs)->contents[i];
+        if (NILP (elt))
+          continue;
+
+        insert_char (i + 32);
+        insert (": ", 2);
+        insert_from_string (elt, 0, XSTRING (elt)->size, 0);
+        insert ("\n", 1);
+      }
+  }
+
+  while (! NILP (XCHAR_TABLE (vector)->parent))
+    {
+      vector = XCHAR_TABLE (vector)->parent;
+      insert_string ("\nThe parent category table is:");
+      describe_vector (vector, Qnil, describe_category, 0, Qnil, Qnil);
+    }
+
+  call0 (intern ("help-mode"));
+  set_buffer_internal (old);
+  return Qnil;
+}
+
+DEFUN ("describe-category", Fdescribe_category, Sdescribe_category, 0, 0, "",
+  "Describe the category specifications in the category table.\n\
+The descriptions are inserted in a buffer, which is then displayed.")
+  ()
+{
+  internal_with_output_to_temp_buffer
+     ("*Help*", describe_category_1, current_buffer->category_table);
+
+  return Qnil;
+}
+
+/* Return 1 if there is a word boundary between two word-constituent
+   characters C1 and C2 if they appear in this order, else return 0.
+   Use the macro WORD_BOUNDARY_P instead of calling this function
+   directly.  */
+
+int
+word_boundary_p (c1, c2)
+     int c1, c2;
+{
+  Lisp_Object category_set1, category_set2;
+  Lisp_Object tail;
+  int default_result;
+
+  if (CHAR_CHARSET (c1) == CHAR_CHARSET (c2))
+    {
+      tail = Vword_separating_categories;
+      default_result = 0;
+    }
+  else
+    {
+      tail = Vword_combining_categories;
+      default_result = 1;
+    }
+
+  category_set1 = CATEGORY_SET (c1);
+  if (NILP (category_set1))
+    return default_result;
+  category_set2 = CATEGORY_SET (c2);
+  if (NILP (category_set2))
+    return default_result;
+
+  for (; CONSP (tail); tail = XCONS (tail)->cdr)
+    {
+      Lisp_Object elt = XCONS(tail)->car;
+
+      if (CONSP (elt)
+          && CATEGORYP (XCONS (elt)->car)
+          && CATEGORYP (XCONS (elt)->cdr)
+          && CATEGORY_MEMBER (XCONS (elt)->car, category_set1)
+          && CATEGORY_MEMBER (XCONS (elt)->cdr, category_set2))
+        return !default_result;
+    }
+  return default_result;
+}
+
+
+init_category_once ()
+{
+  /* This has to be done here, before we call Fmake_char_table.  */
+  Qcategory_table = intern ("category-table");
+  staticpro (&Qcategory_table);
+
+  /* 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");
+
+  /* Now we are ready to set up this property, so we can
+     create category tables.  */
+  Fput (Qcategory_table, Qchar_table_extra_slots, make_number (2));
+
+  Vstandard_category_table = Fmake_char_table (Qcategory_table, Qnil);
+  /* Set a category set which contains nothing to the default.  */ 
+  XCHAR_TABLE (Vstandard_category_table)->defalt = MAKE_CATEGORY_SET;
+  Fset_char_table_extra_slot (Vstandard_category_table, 0,
+                              Fmake_vector (make_number (95), Qnil));
+}
+
+syms_of_category ()
+{
+  Qcategoryp = intern ("categoryp");
+  staticpro (&Qcategoryp);
+  Qcategorysetp = intern ("categorysetp");
+  staticpro (&Qcategorysetp);
+  Qcategory_table_p = intern ("category-table-p");
+  staticpro (&Qcategory_table_p);
+
+  DEFVAR_LISP ("word-combining-categories", &Vword_combining_categories,
+    "List of pair (cons) of categories to determine word boundary.\n\
+\n\
+Emacs treats a sequence of word constituent characters as a single\n\
+word (i.e. finds no word boundary between them) iff they belongs to\n\
+the same charset.  But, exceptions are allowed in the following cases.\n\
+\n\
+(1) The case that characters are in different charsets is controlled\n\
+by the variable `word-combining-categories'.\n\
+\n\
+Emacs finds no word boundary between characters of different charsets\n\
+if they have categories matching some element of this list.\n\
+\n\
+More precisely, if an element of this list is a cons of category CAT1\n\
+and CAT2, and a multibyte character C1 which has CAT1 is followed by\n\
+C2 which has CAT2, there's no word boundary between C1 and C2.\n\
+\n\
+For instance, to tell that ASCII characters and Latin-1 characters can\n\
+form a single word, the element `(?l . ?l)' should be in this list\n\
+because both characters have the category `l' (Latin characters).\n\
+\n\
+(2) The case that character are in the same charset is controlled by\n\
+the variable `word-separating-categories'.\n\
+\n\
+Emacs find a word boundary between characters of the same charset\n\
+if they have categories matching some element of this list.\n\
+\n\
+More precisely, if an element of this list is a cons of category CAT1\n\
+and CAT2, and a multibyte character C1 which has CAT1 is followed by\n\
+C2 which has CAT2, there's a word boundary between C1 and C2.\n\
+\n\
+For instance, to tell that there's a word boundary between Japanese\n\
+Hiragana and Japanese Kanji (both are in the same charset), the\n\
+element `(?H . ?C) should be in this list.");
+
+  Vword_combining_categories = Qnil;
+
+  DEFVAR_LISP ("word-separating-categories", &Vword_separating_categories,
+    "List of pair (cons) of categories to determine word boundary.\n\
+See the documentation of the variable `word-combining-categories'.");
+
+  Vword_separating_categories = Qnil;
+
+  defsubr (&Smake_category_set);
+  defsubr (&Sdefine_category);
+  defsubr (&Scategory_docstring);
+  defsubr (&Sget_unused_category);
+  defsubr (&Scategory_table_p);
+  defsubr (&Scategory_table);
+  defsubr (&Sstandard_category_table);
+  defsubr (&Scopy_category_table);
+  defsubr (&Sset_category_table);
+  defsubr (&Schar_category_set);
+  defsubr (&Scategory_set_mnemonics);
+  defsubr (&Smodify_category_entry);
+  defsubr (&Sdescribe_category);
+
+  category_table_version = 0;
+}
diff --git a/src/category.h b/src/category.h
new file mode 100644
index 00000000000..975e82b52f2
--- /dev/null
+++ b/src/category.h
@@ -0,0 +1,130 @@
+/* Declarations having to do with Emacs category tables.
+   Ver.1.0
+
+   Copyright (C) 1995 Free Software Foundation, Inc.
+   Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs; see the file COPYING.  If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+
+/* We introduce here three types of object: category, category set,
+   and category table.
+
+   A category is like syntax but differs in the following points:
+
+   o A category is represented by a mnemonic character of the range
+   ` '(32)..`~'(126) (printable ASCII characters).
+
+   o A category is not exclusive, i.e. a character has multiple
+   categories (category set).  Of course, there's a case that a
+   category set is empty, i.e. the character has no category.
+
+   o In addition to the predefined categories, a user can define new
+   categories.  Total number of categories is limited to 95.
+
+   A category set is a set of categories represented by Lisp
+   bool-vector of length 128 (only elements of 31th through 125th
+   are used).
+
+   A category table is like syntax-table, represented by a Lisp
+   char-table.  The contents are category sets or nil.  It has two
+   extra slots. for a vector of doc string of each category and a
+   version number.
+
+   The first extra slot is a vector of doc strings of categories, the
+   length is 95.  The Nth element corresponding to the category N+32.
+
+   The second extra slot is a version number of the category table.
+   But, for the moment, we are not using this slot.  */
+
+#define CATEGORYP(x) \
+  (INTEGERP ((x)) && XFASTINT ((x)) >= 0x20 && XFASTINT ((x)) <= 0x7E)
+
+#define CHECK_CATEGORY(x, i)                                            \
+  do {                                                                  \
+    if (!CATEGORYP ((x))) x = wrong_type_argument (Qcategoryp, (x));    \
+  } while (0)
+
+#define XCATEGORY_SET XBOOL_VECTOR
+
+#define CATEGORY_SET_P(x) \
+  (BOOL_VECTOR_P ((x)) && (EMACS_INT) (XBOOL_VECTOR ((x))->size) == 128)
+
+/* Return a new empty category set.  */
+#define MAKE_CATEGORY_SET (Fmake_bool_vector (make_number (128), Qnil))
+
+/* Make CATEGORY_SET includes (if VAL is t) or excludes (if VAL is
+   nil) CATEGORY.  */
+#define SET_CATEGORY_SET(category_set, category, val) \
+  (Faset (category_set, category, val))
+
+#define CHECK_CATEGORY_SET(x, i)                                           \
+  do {                                                                     \
+    if (!CATEGORY_SET_P ((x))) x = wrong_type_argument (Qcategorysetp, (x)); \
+  } while (0)
+
+/* Return 1 if CATEGORY_SET contains CATEGORY, else return 0.
+   The faster version of `!NILP (Faref (category_set, category))'.  */
+#define CATEGORY_MEMBER(category, category_set)                         \
+  (!NILP (category_set)                                                 \
+   && (XCATEGORY_SET (category_set)->data[XFASTINT (category) / 8]      \
+       & (1 << (XFASTINT (category) % 8))))
+
+/* Temporary internal variable used in macro CHAR_HAS_CATEGORY.  */
+extern Lisp_Object _temp_category_set;
+
+/* Return 1 if category set of CH contains CATEGORY, elt return 0.  */
+#define CHAR_HAS_CATEGORY(ch, category) \
+  (_temp_category_set = CATEGORY_SET (ch),      \
+   CATEGORY_MEMBER (category, _temp_category_set))
+
+/* The standard category table is stored where it will automatically
+   be used in all new buffers.  */
+#define Vstandard_category_table buffer_defaults.category_table
+
+/* Return the category set of character C in the current category table.  */
+#ifdef __GNUC__
+#define CATEGORY_SET(c)                                         \
+  ({ Lisp_Object table = current_buffer->category_table;        \
+     Lisp_Object temp;                                          \
+     if (c < CHAR_TABLE_ORDINARY_SLOTS)                         \
+       while (NILP (temp = XCHAR_TABLE (table)->contents[c])    \
+              && NILP (temp = XCHAR_TABLE (table)->defalt))     \
+         table = XCHAR_TABLE (table)->parent;                   \
+     else                                                       \
+       temp = Faref (table, c);                                 \
+     temp; })
+#else
+#define CATEGORY_SET(c) Faref (current_buffer->category_table, c)
+#endif   
+
+/* Return the doc string of CATEGORY in category table TABLE.  */
+#define CATEGORY_DOCSTRING(table, category) \
+  XVECTOR (Fchar_table_extra_slot (table, 0))->contents[(category) - ' ']
+
+/* Return the version number of category table TABLE.  Not used for
+   the moment.  */
+#define CATEGORY_TABLE_VERSION (table) \
+  Fchar_table_extra_slot (table, 1)
+
+/* Return 1 if there is a word boundary between two word-constituent
+   characters C1 and C2 if they appear in this order, else return 0.
+   There is no word boundary between two word-constituent ASCII
+   characters.  */
+#define WORD_BOUNDARY_P(c1, c2)                                 \
+  (!(SINGLE_BYTE_CHAR_P (c1) && SINGLE_BYTE_CHAR_P (c2))        \
+   && word_boundary_p (c1, c2))
diff --git a/src/ccl.c b/src/ccl.c
new file mode 100644
index 00000000000..11c1ae500d6
--- /dev/null
+++ b/src/ccl.c
@@ -0,0 +1,1140 @@
+/* CCL (Code Conversion Language) interpreter.
+   Ver.1.0
+
+   Copyright (C) 1995 Free Software Foundation, Inc.
+   Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#include <stdio.h>
+
+#ifdef emacs
+
+#include <config.h>
+#include "lisp.h"
+#include "charset.h"
+#include "ccl.h"
+#include "coding.h"
+
+#else  /* not emacs */
+
+#include "mulelib.h"
+
+#endif /* not emacs */
+
+/* Alist of fontname patterns vs corresponding CCL program.  */
+Lisp_Object Vfont_ccl_encoder_alist;
+
+/* Vector of CCL program names vs corresponding program data.  */
+Lisp_Object Vccl_program_table;
+
+/* CCL (Code Conversion Language) is a simple language which has
+   operations on one input buffer, one output buffer, and 7 registers.
+   The syntax of CCL is described in `ccl.el'.  Emacs Lisp function
+   `ccl-compile' compiles a CCL program and produces a CCL code which
+   is a vector of integers.  The structure of this vector is as
+   follows: The 1st element: buffer-magnification, a factor for the
+   size of output buffer compared with the size of input buffer.  The
+   2nd element: address of CCL code to be executed when encountered
+   with end of input stream.  The 3rd and the remaining elements: CCL
+   codes.  */
+
+/* Header of CCL compiled code */
+#define CCL_HEADER_BUF_MAG      0
+#define CCL_HEADER_EOF          1
+#define CCL_HEADER_MAIN         2
+
+/* CCL code is a sequence of 28-bit non-negative integers (i.e. the
+   MSB is always 0), each contains CCL command and/or arguments in the
+   following format:
+
+        |----------------- integer (28-bit) ------------------|
+        |------- 17-bit ------|- 3-bit --|- 3-bit --|- 5-bit -|
+        |--constant argument--|-register-|-register-|-command-|
+           ccccccccccccccccc      RRR        rrr       XXXXX
+  or
+        |------- relative address -------|-register-|-command-|
+               cccccccccccccccccccc          rrr       XXXXX
+  or
+        |------------- constant or other args ----------------|
+                     cccccccccccccccccccccccccccc
+
+   where, `cc...c' is a non-negative integer indicating constant value
+   (the left most `c' is always 0) or an absolute jump address, `RRR'
+   and `rrr' are CCL register number, `XXXXX' is one of the following
+   CCL commands.  */
+
+/* CCL commands
+
+   Each comment fields shows one or more lines for command syntax and
+   the following lines for semantics of the command.  In semantics, IC
+   stands for Instruction Counter.  */
+
+#define CCL_SetRegister         0x00 /* Set register a register value:
+                                        1:00000000000000000RRRrrrXXXXX
+                                        ------------------------------
+                                        reg[rrr] = reg[RRR];
+                                        */
+
+#define CCL_SetShortConst       0x01 /* Set register a short constant value:
+                                        1:CCCCCCCCCCCCCCCCCCCCrrrXXXXX
+                                        ------------------------------
+                                        reg[rrr] = CCCCCCCCCCCCCCCCCCC;
+                                        */
+
+#define CCL_SetConst            0x02 /* Set register a constant value:
+                                        1:00000000000000000000rrrXXXXX
+                                        2:CONSTANT
+                                        ------------------------------
+                                        reg[rrr] = CONSTANT;
+                                        IC++;
+                                        */
+
+#define CCL_SetArray            0x03 /* Set register an element of array:
+                                        1:CCCCCCCCCCCCCCCCCRRRrrrXXXXX
+                                        2:ELEMENT[0]
+                                        3:ELEMENT[1]
+                                        ...
+                                        ------------------------------
+                                        if (0 <= reg[RRR] < CC..C)
+                                          reg[rrr] = ELEMENT[reg[RRR]];
+                                        IC += CC..C;
+                                        */
+
+#define CCL_Jump                0x04 /* Jump:
+                                        1:A--D--D--R--E--S--S-000XXXXX
+                                        ------------------------------
+                                        IC += ADDRESS;
+                                        */
+
+/* Note: If CC..C is greater than 0, the second code is omitted.  */
+
+#define CCL_JumpCond            0x05 /* Jump conditional:
+                                        1:A--D--D--R--E--S--S-rrrXXXXX
+                                        ------------------------------
+                                        if (!reg[rrr])
+                                          IC += ADDRESS;
+                                        */
+
+
+#define CCL_WriteRegisterJump   0x06 /* Write register and jump:
+                                        1:A--D--D--R--E--S--S-rrrXXXXX
+                                        ------------------------------
+                                        write (reg[rrr]);
+                                        IC += ADDRESS;
+                                        */
+
+#define CCL_WriteRegisterReadJump 0x07 /* Write register, read, and jump:
+                                        1:A--D--D--R--E--S--S-rrrXXXXX
+                                        2:A--D--D--R--E--S--S-rrrYYYYY
+                                        -----------------------------
+                                        write (reg[rrr]);
+                                        IC++;
+                                        read (reg[rrr]);
+                                        IC += ADDRESS;
+                                        */
+/* Note: If read is suspended, the resumed execution starts from the
+   second code (YYYYY == CCL_ReadJump).  */
+
+#define CCL_WriteConstJump      0x08 /* Write constant and jump:
+                                        1:A--D--D--R--E--S--S-000XXXXX
+                                        2:CONST
+                                        ------------------------------
+                                        write (CONST);
+                                        IC += ADDRESS;
+                                        */
+
+#define CCL_WriteConstReadJump  0x09 /* Write constant, read, and jump:
+                                        1:A--D--D--R--E--S--S-rrrXXXXX
+                                        2:CONST
+                                        3:A--D--D--R--E--S--S-rrrYYYYY
+                                        -----------------------------
+                                        write (CONST);
+                                        IC += 2;
+                                        read (reg[rrr]);
+                                        IC += ADDRESS;
+                                        */
+/* Note: If read is suspended, the resumed execution starts from the
+   second code (YYYYY == CCL_ReadJump).  */
+
+#define CCL_WriteStringJump     0x0A /* Write string and jump:
+                                        1:A--D--D--R--E--S--S-000XXXXX
+                                        2:LENGTH
+                                        3:0000STRIN[0]STRIN[1]STRIN[2]
+                                        ...
+                                        ------------------------------
+                                        write_string (STRING, LENGTH);
+                                        IC += ADDRESS;
+                                        */
+
+#define CCL_WriteArrayReadJump  0x0B /* Write an array element, read, and jump:
+                                        1:A--D--D--R--E--S--S-rrrXXXXX
+                                        2:LENGTH
+                                        3:ELEMENET[0]
+                                        4:ELEMENET[1]
+                                        ...
+                                        N:A--D--D--R--E--S--S-rrrYYYYY
+                                        ------------------------------
+                                        if (0 <= reg[rrr] < LENGTH)
+                                          write (ELEMENT[reg[rrr]]);
+                                        IC += LENGTH + 2; (... pointing at N+1)
+                                        read (reg[rrr]);
+                                        IC += ADDRESS;
+                                        */
+/* Note: If read is suspended, the resumed execution starts from the
+   Mth code (YYYYY == CCL_ReadJump).  */
+
+#define CCL_ReadJump            0x0C /* Read and jump:
+                                        1:A--D--D--R--E--S--S-rrrYYYYY
+                                        -----------------------------
+                                        read (reg[rrr]);
+                                        IC += ADDRESS;
+                                        */
+
+#define CCL_Branch              0x0D /* Jump by branch table:
+                                        1:CCCCCCCCCCCCCCCCCCCCrrrXXXXX
+                                        2:A--D--D--R--E-S-S[0]000XXXXX
+                                        3:A--D--D--R--E-S-S[1]000XXXXX
+                                        ...
+                                        ------------------------------
+                                        if (0 <= reg[rrr] < CC..C)
+                                          IC += ADDRESS[reg[rrr]];
+                                        else
+                                          IC += ADDRESS[CC..C];
+                                        */
+
+#define CCL_ReadRegister        0x0E /* Read bytes into registers:
+                                        1:CCCCCCCCCCCCCCCCCCCCrrrXXXXX
+                                        2:CCCCCCCCCCCCCCCCCCCCrrrXXXXX
+                                        ...
+                                        ------------------------------
+                                        while (CCC--)
+                                          read (reg[rrr]);
+                                        */
+
+#define CCL_WriteExprConst      0x0F  /* write result of expression:
+                                        1:00000OPERATION000RRR000XXXXX
+                                        2:CONSTANT
+                                        ------------------------------
+                                        write (reg[RRR] OPERATION CONSTANT);
+                                        IC++;
+                                        */
+
+/* Note: If the Nth read is suspended, the resumed execution starts
+   from the Nth code.  */
+
+#define CCL_ReadBranch          0x10 /* Read one byte into a register,
+                                        and jump by branch table:
+                                        1:CCCCCCCCCCCCCCCCCCCCrrrXXXXX
+                                        2:A--D--D--R--E-S-S[0]000XXXXX
+                                        3:A--D--D--R--E-S-S[1]000XXXXX
+                                        ...
+                                        ------------------------------
+                                        read (read[rrr]);
+                                        if (0 <= reg[rrr] < CC..C)
+                                          IC += ADDRESS[reg[rrr]];
+                                        else
+                                          IC += ADDRESS[CC..C];
+                                        */
+
+#define CCL_WriteRegister       0x11 /* Write registers:
+                                        1:CCCCCCCCCCCCCCCCCCCrrrXXXXX
+                                        2:CCCCCCCCCCCCCCCCCCCrrrXXXXX
+                                        ...
+                                        ------------------------------
+                                        while (CCC--)
+                                          write (reg[rrr]);
+                                        ...
+                                        */
+
+/* Note: If the Nth write is suspended, the resumed execution
+   starts from the Nth code.  */
+
+#define CCL_WriteExprRegister   0x12 /* Write result of expression
+                                        1:00000OPERATIONRrrRRR000XXXXX
+                                        ------------------------------
+                                        write (reg[RRR] OPERATION reg[Rrr]);
+                                        */
+
+#define CCL_Call                0x13 /* Write a constant:
+                                        1:CCCCCCCCCCCCCCCCCCCC000XXXXX
+                                        ------------------------------
+                                        call (CC..C)
+                                        */
+
+#define CCL_WriteConstString    0x14 /* Write a constant or a string:
+                                        1:CCCCCCCCCCCCCCCCCCCCrrrXXXXX
+                                        [2:0000STRIN[0]STRIN[1]STRIN[2]]
+                                        [...]
+                                        -----------------------------
+                                        if (!rrr)
+                                          write (CC..C)
+                                        else
+                                          write_string (STRING, CC..C);
+                                          IC += (CC..C + 2) / 3;
+                                        */
+
+#define CCL_WriteArray          0x15 /* Write an element of array:
+                                        1:CCCCCCCCCCCCCCCCCCCCrrrXXXXX
+                                        2:ELEMENT[0]
+                                        3:ELEMENT[1]
+                                        ...
+                                        ------------------------------
+                                        if (0 <= reg[rrr] < CC..C)
+                                          write (ELEMENT[reg[rrr]]);
+                                        IC += CC..C;
+                                        */
+
+#define CCL_End                 0x16 /* Terminate:
+                                        1:00000000000000000000000XXXXX
+                                        ------------------------------
+                                        terminate ();
+                                        */
+
+/* The following two codes execute an assignment arithmetic/logical
+   operation.  The form of the operation is like REG OP= OPERAND.  */
+
+#define CCL_ExprSelfConst       0x17 /* REG OP= constant:
+                                        1:00000OPERATION000000rrrXXXXX
+                                        2:CONSTANT
+                                        ------------------------------
+                                        reg[rrr] OPERATION= CONSTANT;
+                                        */
+
+#define CCL_ExprSelfReg         0x18 /* REG1 OP= REG2:
+                                        1:00000OPERATION000RRRrrrXXXXX
+                                        ------------------------------
+                                        reg[rrr] OPERATION= reg[RRR];
+                                        */
+
+/* The following codes execute an arithmetic/logical operation.  The
+   form of the operation is like REG_X = REG_Y OP OPERAND2.  */
+
+#define CCL_SetExprConst        0x19 /* REG_X = REG_Y OP constant:
+                                        1:00000OPERATION000RRRrrrXXXXX
+                                        2:CONSTANT
+                                        ------------------------------
+                                        reg[rrr] = reg[RRR] OPERATION CONSTANT;
+                                        IC++;
+                                        */
+
+#define CCL_SetExprReg          0x1A /* REG1 = REG2 OP REG3:
+                                        1:00000OPERATIONRrrRRRrrrXXXXX
+                                        ------------------------------
+                                        reg[rrr] = reg[RRR] OPERATION reg[Rrr];
+                                        */
+
+#define CCL_JumpCondExprConst   0x1B /* Jump conditional according to
+                                        an operation on constant:
+                                        1:A--D--D--R--E--S--S-rrrXXXXX
+                                        2:OPERATION
+                                        3:CONSTANT
+                                        -----------------------------
+                                        reg[7] = reg[rrr] OPERATION CONSTANT;
+                                        if (!(reg[7]))
+                                          IC += ADDRESS;
+                                        else
+                                          IC += 2
+                                        */
+
+#define CCL_JumpCondExprReg     0x1C /* Jump conditional according to
+                                        an operation on register:
+                                        1:A--D--D--R--E--S--S-rrrXXXXX
+                                        2:OPERATION
+                                        3:RRR
+                                        -----------------------------
+                                        reg[7] = reg[rrr] OPERATION reg[RRR];
+                                        if (!reg[7])
+                                          IC += ADDRESS;
+                                        else
+                                          IC += 2;
+                                        */
+
+#define CCL_ReadJumpCondExprConst 0x1D /* Read and jump conditional according
+                                          to an operation on constant:
+                                        1:A--D--D--R--E--S--S-rrrXXXXX
+                                        2:OPERATION
+                                        3:CONSTANT
+                                        -----------------------------
+                                        read (reg[rrr]);
+                                        reg[7] = reg[rrr] OPERATION CONSTANT;
+                                        if (!reg[7])
+                                          IC += ADDRESS;
+                                        else
+                                          IC += 2;
+                                        */
+
+#define CCL_ReadJumpCondExprReg 0x1E /* Read and jump conditional according
+                                        to an operation on register:
+                                        1:A--D--D--R--E--S--S-rrrXXXXX
+                                        2:OPERATION
+                                        3:RRR
+                                        -----------------------------
+                                        read (reg[rrr]);
+                                        reg[7] = reg[rrr] OPERATION reg[RRR];
+                                        if (!reg[7])
+                                          IC += ADDRESS;
+                                        else
+                                          IC += 2;
+                                        */
+
+#define CCL_Extention           0x1F /* Extended CCL code
+                                        1:ExtendedCOMMNDRrrRRRrrrXXXXX
+                                        2:ARGUEMENT
+                                        3:...
+                                        ------------------------------
+                                        extended_command (rrr,RRR,Rrr,ARGS)
+                                      */
+
+
+/* CCL arithmetic/logical operators. */
+#define CCL_PLUS        0x00    /* X = Y + Z */
+#define CCL_MINUS       0x01    /* X = Y - Z */
+#define CCL_MUL         0x02    /* X = Y * Z */
+#define CCL_DIV         0x03    /* X = Y / Z */
+#define CCL_MOD         0x04    /* X = Y % Z */
+#define CCL_AND         0x05    /* X = Y & Z */
+#define CCL_OR          0x06    /* X = Y | Z */
+#define CCL_XOR         0x07    /* X = Y ^ Z */
+#define CCL_LSH         0x08    /* X = Y << Z */
+#define CCL_RSH         0x09    /* X = Y >> Z */
+#define CCL_LSH8        0x0A    /* X = (Y << 8) | Z */
+#define CCL_RSH8        0x0B    /* X = Y >> 8, r[7] = Y & 0xFF  */
+#define CCL_DIVMOD      0x0C    /* X = Y / Z, r[7] = Y % Z */
+#define CCL_LS          0x10    /* X = (X < Y) */
+#define CCL_GT          0x11    /* X = (X > Y) */
+#define CCL_EQ          0x12    /* X = (X == Y) */
+#define CCL_LE          0x13    /* X = (X <= Y) */
+#define CCL_GE          0x14    /* X = (X >= Y) */
+#define CCL_NE          0x15    /* X = (X != Y) */
+
+#define CCL_ENCODE_SJIS 0x16    /* X = HIGHER_BYTE (SJIS (Y, Z))
+                                   r[7] = LOWER_BYTE (SJIS (Y, Z) */
+#define CCL_DECODE_SJIS 0x17    /* X = HIGHER_BYTE (DE-SJIS (Y, Z))
+                                   r[7] = LOWER_BYTE (DE-SJIS (Y, Z)) */
+
+/* Macros for exit status of CCL program.  */
+#define CCL_STAT_SUCCESS        0 /* Terminated successfully.  */
+#define CCL_STAT_SUSPEND        1 /* Terminated because of empty input
+                                     buffer or full output buffer.  */
+#define CCL_STAT_INVALID_CMD    2 /* Terminated because of invalid
+                                     command.  */
+#define CCL_STAT_QUIT           3 /* Terminated because of quit.  */
+
+/* Terminate CCL program successfully.  */
+#define CCL_SUCCESS                     \
+  do {                                  \
+    ccl->status = CCL_STAT_SUCCESS;     \
+    ccl->ic = CCL_HEADER_MAIN;          \
+    goto ccl_finish;                    \
+  } while (0)
+
+/* Suspend CCL program because of reading from empty input buffer or
+   writing to full output buffer.  When this program is resumed, the
+   same I/O command is executed.  */
+#define CCL_SUSPEND                     \
+  do {                                  \
+    ic--;                               \
+    ccl->status = CCL_STAT_SUSPEND;     \
+    goto ccl_finish;                    \
+  } while (0)
+
+/* Terminate CCL program because of invalid command.  Should not occur
+   in the normal case.  */
+#define CCL_INVALID_CMD                 \
+  do {                                  \
+    ccl->status = CCL_STAT_INVALID_CMD; \
+    goto ccl_error_handler;             \
+  } while (0)
+
+/* Encode one character CH to multibyte form and write to the current
+   output buffer.  If CH is negative, write one byte -CH.  */
+#define CCL_WRITE_CHAR(ch)                      \
+  do {                                          \
+    if (!dst)                                   \
+      CCL_INVALID_CMD;                          \
+    else                                        \
+      {                                         \
+        unsigned char work[4], *str;            \
+        int len = CHAR_STRING (ch, work, str);  \
+        if (dst + len <= dst_end)               \
+          {                                     \
+            bcopy (str, dst, len);              \
+            dst += len;                         \
+          }                                     \
+        else                                    \
+          CCL_SUSPEND;                          \
+      }                                         \
+  } while (0)
+
+/* Write a string at ccl_prog[IC] of length LEN to the current output
+   buffer.  */
+#define CCL_WRITE_STRING(len)                           \
+  do {                                                  \
+    if (!dst)                                           \
+      CCL_INVALID_CMD;                                  \
+    else if (dst + len <= dst_end)                      \
+      for (i = 0; i < len; i++)                         \
+        *dst++ = ((XFASTINT (ccl_prog[ic + (i / 3)]))   \
+                  >> ((2 - (i % 3)) * 8)) & 0xFF;       \
+    else                                                \
+      CCL_SUSPEND;                                      \
+  } while (0)
+
+/* Read one byte from the current input buffer into Rth register.  */
+#define CCL_READ_CHAR(r)        \
+  do {                          \
+    if (!src)                   \
+      CCL_INVALID_CMD;          \
+    else if (src < src_end)     \
+      r = *src++;               \
+    else if (ccl->last_block)   \
+      {                         \
+        ic = ccl->eof_ic;       \
+        goto ccl_finish;        \
+      }                         \
+    else                        \
+      CCL_SUSPEND;              \
+  } while (0)
+
+
+/* Execute CCL code on SRC_BYTES length text at SOURCE.  The resulting
+   text goes to a place pointed by DESTINATION, the length of which
+   should not exceed DST_BYTES.  The bytes actually processed is
+   returned as *CONSUMED.  The return value is the length of the
+   resulting text.  As a side effect, the contents of CCL registers
+   are updated.  If SOURCE or DESTINATION is NULL, only operations on
+   registers are permitted.  */
+
+#ifdef CCL_DEBUG
+#define CCL_DEBUG_BACKTRACE_LEN 256
+int ccl_backtrace_table[CCL_BACKTRACE_TABLE];
+int ccl_backtrace_idx;
+#endif
+
+struct ccl_prog_stack
+  {
+    int *ccl_prog;              /* Pointer to an array of CCL code.  */
+    int ic;                     /* Instruction Counter.  */
+  };
+
+ccl_driver (ccl, source, destination, src_bytes, dst_bytes, consumed)
+     struct ccl_program *ccl;
+     unsigned char *source, *destination;
+     int src_bytes, dst_bytes;
+     int *consumed;
+{
+  register int *reg = ccl->reg;
+  register int ic = ccl->ic;
+  register int code, field1, field2;
+  register int *ccl_prog = ccl->prog;
+  unsigned char *src = source, *src_end = src + src_bytes;
+  unsigned char *dst = destination, *dst_end = dst + dst_bytes;
+  int jump_address;
+  int i, j, op;
+  int stack_idx = 0;
+  /* For the moment, we only support depth 256 of stack.  */ 
+  struct ccl_prog_stack ccl_prog_stack_struct[256];
+
+  if (ic >= ccl->eof_ic)
+    ic = CCL_HEADER_MAIN;
+
+#ifdef CCL_DEBUG
+  ccl_backtrace_idx = 0;
+#endif
+
+  for (;;)
+    {
+#ifdef CCL_DEBUG
+      ccl_backtrace_table[ccl_backtrace_idx++] = ic;
+      if (ccl_backtrace_idx >= CCL_DEBUG_BACKTRACE_LEN)
+        ccl_backtrace_idx = 0;
+      ccl_backtrace_table[ccl_backtrace_idx] = 0;
+#endif
+
+      if (!NILP (Vquit_flag) && NILP (Vinhibit_quit))
+        {
+          /* We can't just signal Qquit, instead break the loop as if
+             the whole data is processed.  Don't reset Vquit_flag, it
+             must be handled later at a safer place.  */
+          if (consumed)
+            src = source + src_bytes;
+          ccl->status = CCL_STAT_QUIT;
+          break;
+        }
+
+      code = XINT (ccl_prog[ic]); ic++;
+      field1 = code >> 8;
+      field2 = (code & 0xFF) >> 5;
+
+#define rrr field2
+#define RRR (field1 & 7)
+#define Rrr ((field1 >> 3) & 7)
+#define ADDR field1
+
+      switch (code & 0x1F)
+        {
+        case CCL_SetRegister:   /* 00000000000000000RRRrrrXXXXX */
+          reg[rrr] = reg[RRR];
+          break;
+
+        case CCL_SetShortConst: /* CCCCCCCCCCCCCCCCCCCCrrrXXXXX */
+          reg[rrr] = field1;
+          break;
+
+        case CCL_SetConst:      /* 00000000000000000000rrrXXXXX */
+          reg[rrr] = XINT (ccl_prog[ic]);
+          ic++;
+          break;
+
+        case CCL_SetArray:      /* CCCCCCCCCCCCCCCCCCCCRRRrrrXXXXX */
+          i = reg[RRR];
+          j = field1 >> 3;
+          if ((unsigned int) i < j)
+            reg[rrr] = XINT (ccl_prog[ic + i]);
+          ic += j;
+          break;
+
+        case CCL_Jump:          /* A--D--D--R--E--S--S-000XXXXX */
+          ic += ADDR;
+          break;
+
+        case CCL_JumpCond:      /* A--D--D--R--E--S--S-rrrXXXXX */
+          if (!reg[rrr])
+            ic += ADDR;
+          break;
+
+        case CCL_WriteRegisterJump: /* A--D--D--R--E--S--S-rrrXXXXX */
+          i = reg[rrr];
+          CCL_WRITE_CHAR (i);
+          ic += ADDR;
+          break;
+
+        case CCL_WriteRegisterReadJump: /* A--D--D--R--E--S--S-rrrXXXXX */
+          i = reg[rrr];
+          CCL_WRITE_CHAR (i);
+          ic++;
+          CCL_READ_CHAR (reg[rrr]);
+          ic += ADDR - 1;
+          break;
+
+        case CCL_WriteConstJump: /* A--D--D--R--E--S--S-000XXXXX */
+          i = XINT (ccl_prog[ic]);
+          CCL_WRITE_CHAR (i);
+          ic += ADDR;
+          break;
+
+        case CCL_WriteConstReadJump: /* A--D--D--R--E--S--S-rrrXXXXX */
+          i = XINT (ccl_prog[ic]);
+          CCL_WRITE_CHAR (i);
+          ic++;
+          CCL_READ_CHAR (reg[rrr]);
+          ic += ADDR - 1;
+          break;
+
+        case CCL_WriteStringJump: /* A--D--D--R--E--S--S-000XXXXX */
+          j = XINT (ccl_prog[ic]);
+          ic++;
+          CCL_WRITE_STRING (j);
+          ic += ADDR - 1;
+          break;
+
+        case CCL_WriteArrayReadJump: /* A--D--D--R--E--S--S-rrrXXXXX */
+          i = reg[rrr];
+          j = ccl_prog[ic++];
+          if ((unsigned int) i < j)
+            {
+              i = XINT (ccl_prog[ic + i]);
+              CCL_WRITE_CHAR (i);
+            }
+          ic += j + 1;
+          CCL_READ_CHAR (reg[rrr]);
+          ic += ADDR - (j + 2);
+          break;
+
+        case CCL_ReadJump:      /* A--D--D--R--E--S--S-rrrYYYYY */
+          CCL_READ_CHAR (reg[rrr]);
+          ic += ADDR;
+          break;
+
+        case CCL_ReadBranch:    /* CCCCCCCCCCCCCCCCCCCCrrrXXXXX */
+          CCL_READ_CHAR (reg[rrr]);
+          /* fall through ... */
+        case CCL_Branch:        /* CCCCCCCCCCCCCCCCCCCCrrrXXXXX */
+          if ((unsigned int) reg[rrr] < field1)
+            ic += XINT (ccl_prog[ic + reg[rrr]]);
+          else
+            ic += XINT (ccl_prog[ic + field1]);
+          break;
+
+        case CCL_ReadRegister:  /* CCCCCCCCCCCCCCCCCCCCrrXXXXX */
+          while (1)
+            {
+              CCL_READ_CHAR (reg[rrr]);
+              if (!field1) break;
+              code = XINT (ccl_prog[ic]); ic++;
+              field1 = code >> 8;
+              field2 = (code & 0xFF) >> 5;
+            }
+          break;
+
+        case CCL_WriteExprConst:  /* 1:00000OPERATION000RRR000XXXXX */
+          rrr = 7;
+          i = reg[RRR];
+          j = XINT (ccl_prog[ic]);
+          op = field1 >> 6;
+          ic++;
+          goto ccl_set_expr;
+
+        case CCL_WriteRegister: /* CCCCCCCCCCCCCCCCCCCrrrXXXXX */
+          while (1)
+            {
+              i = reg[rrr];
+              CCL_WRITE_CHAR (i);
+              if (!field1) break;
+              code = XINT (ccl_prog[ic]); ic++;
+              field1 = code >> 8;
+              field2 = (code & 0xFF) >> 5;
+            }
+          break;
+
+        case CCL_WriteExprRegister: /* 1:00000OPERATIONRrrRRR000XXXXX */
+          rrr = 7;
+          i = reg[RRR];
+          j = reg[Rrr];
+          op = field1 >> 6;
+          goto ccl_set_expr;
+
+        case CCL_Call:          /* CCCCCCCCCCCCCCCCCCCC000XXXXX */
+          {
+            Lisp_Object slot;
+
+            if (stack_idx >= 256
+                || field1 < 0
+                || field1 >= XVECTOR (Vccl_program_table)->size
+                || (slot = XVECTOR (Vccl_program_table)->contents[field1],
+                    !CONSP (slot))
+                || !VECTORP (XCONS (slot)->cdr))
+              {
+                if (stack_idx > 0)
+                  {
+                    ccl_prog = ccl_prog_stack_struct[0].ccl_prog;
+                    ic = ccl_prog_stack_struct[0].ic;
+                  }
+                CCL_INVALID_CMD;
+              }
+            
+            ccl_prog_stack_struct[stack_idx].ccl_prog = ccl_prog;
+            ccl_prog_stack_struct[stack_idx].ic = ic;
+            stack_idx++;
+            ccl_prog = XVECTOR (XCONS (slot)->cdr)->contents;
+            ic = CCL_HEADER_MAIN;
+          }
+          break;
+
+        case CCL_WriteConstString: /* CCCCCCCCCCCCCCCCCCCCrrrXXXXX */
+          if (!rrr)
+            CCL_WRITE_CHAR (field1);
+          else
+            {
+              CCL_WRITE_STRING (field1);
+              ic += (field1 + 2) / 3;
+            }
+          break;
+
+        case CCL_WriteArray:    /* CCCCCCCCCCCCCCCCCCCCrrrXXXXX */
+          i = reg[rrr];
+          if ((unsigned int) i < field1)
+            {
+              j = XINT (ccl_prog[ic + i]);
+              CCL_WRITE_CHAR (j);
+            }
+          ic += field1;
+          break;
+
+        case CCL_End:           /* 0000000000000000000000XXXXX */
+          if (stack_idx-- > 0)
+            {
+              ccl_prog = ccl_prog_stack_struct[stack_idx].ccl_prog;
+              ic = ccl_prog_stack_struct[stack_idx].ic;
+              break;
+            }
+          CCL_SUCCESS;
+
+        case CCL_ExprSelfConst: /* 00000OPERATION000000rrrXXXXX */
+          i = XINT (ccl_prog[ic]);
+          ic++;
+          op = field1 >> 6;
+          goto ccl_expr_self;
+
+        case CCL_ExprSelfReg:   /* 00000OPERATION000RRRrrrXXXXX */
+          i = reg[RRR];
+          op = field1 >> 6;
+
+        ccl_expr_self:
+          switch (op)
+            {
+            case CCL_PLUS: reg[rrr] += i; break;
+            case CCL_MINUS: reg[rrr] -= i; break;
+            case CCL_MUL: reg[rrr] *= i; break;
+            case CCL_DIV: reg[rrr] /= i; break;
+            case CCL_MOD: reg[rrr] %= i; break;
+            case CCL_AND: reg[rrr] &= i; break;
+            case CCL_OR: reg[rrr] |= i; break;
+            case CCL_XOR: reg[rrr] ^= i; break;
+            case CCL_LSH: reg[rrr] <<= i; break;
+            case CCL_RSH: reg[rrr] >>= i; break;
+            case CCL_LSH8: reg[rrr] <<= 8; reg[rrr] |= i; break;
+            case CCL_RSH8: reg[7] = reg[rrr] & 0xFF; reg[rrr] >>= 8; break;
+            case CCL_DIVMOD: reg[7] = reg[rrr] % i; reg[rrr] /= i; break;
+            case CCL_LS: reg[rrr] = reg[rrr] < i; break;
+            case CCL_GT: reg[rrr] = reg[rrr] > i; break;
+            case CCL_EQ: reg[rrr] = reg[rrr] == i; break;
+            case CCL_LE: reg[rrr] = reg[rrr] <= i; break;
+            case CCL_GE: reg[rrr] = reg[rrr] >= i; break;
+            case CCL_NE: reg[rrr] = reg[rrr] != i; break;
+            default: CCL_INVALID_CMD;
+            }
+          break;
+
+        case CCL_SetExprConst:  /* 00000OPERATION000RRRrrrXXXXX */
+          i = reg[RRR];
+          j = XINT (ccl_prog[ic]);
+          op = field1 >> 6;
+          jump_address = ++ic;
+          goto ccl_set_expr;
+
+        case CCL_SetExprReg:    /* 00000OPERATIONRrrRRRrrrXXXXX */
+          i = reg[RRR];
+          j = reg[Rrr];
+          op = field1 >> 6;
+          jump_address = ic;
+          goto ccl_set_expr;
+
+        case CCL_ReadJumpCondExprConst: /* A--D--D--R--E--S--S-rrrXXXXX */
+          CCL_READ_CHAR (reg[rrr]);
+        case CCL_JumpCondExprConst: /* A--D--D--R--E--S--S-rrrXXXXX */
+          i = reg[rrr];
+          op = XINT (ccl_prog[ic]);
+          jump_address = ic++ + ADDR;
+          j = XINT (ccl_prog[ic]);
+          ic++;
+          rrr = 7;
+          goto ccl_set_expr;
+
+        case CCL_ReadJumpCondExprReg: /* A--D--D--R--E--S--S-rrrXXXXX */
+          CCL_READ_CHAR (reg[rrr]);
+        case CCL_JumpCondExprReg:
+          i = reg[rrr];
+          op = XINT (ccl_prog[ic]);
+          jump_address = ic++ + ADDR;
+          j = reg[XINT (ccl_prog[ic])];
+          ic++;
+          rrr = 7;
+
+        ccl_set_expr:
+          switch (op)
+            {
+            case CCL_PLUS: reg[rrr] = i + j; break;
+            case CCL_MINUS: reg[rrr] = i - j; break;
+            case CCL_MUL: reg[rrr] = i * j; break;
+            case CCL_DIV: reg[rrr] = i / j; break;
+            case CCL_MOD: reg[rrr] = i % j; break;
+            case CCL_AND: reg[rrr] = i & j; break;
+            case CCL_OR: reg[rrr] = i | j; break;
+            case CCL_XOR: reg[rrr] = i ^ j;; break;
+            case CCL_LSH: reg[rrr] = i << j; break;
+            case CCL_RSH: reg[rrr] = i >> j; break;
+            case CCL_LSH8: reg[rrr] = (i << 8) | j; break;
+            case CCL_RSH8: reg[rrr] = i >> 8; reg[7] = i & 0xFF; break;
+            case CCL_DIVMOD: reg[rrr] = i / j; reg[7] = i % j; break;
+            case CCL_LS: reg[rrr] = i < j; break;
+            case CCL_GT: reg[rrr] = i > j; break;
+            case CCL_EQ: reg[rrr] = i == j; break;
+            case CCL_LE: reg[rrr] = i <= j; break;
+            case CCL_GE: reg[rrr] = i >= j; break;
+            case CCL_NE: reg[rrr] = i != j; break;
+            case CCL_ENCODE_SJIS: ENCODE_SJIS (i, j, reg[rrr], reg[7]); break;
+            case CCL_DECODE_SJIS: DECODE_SJIS (i, j, reg[rrr], reg[7]); break;
+            default: CCL_INVALID_CMD;
+            }
+          code &= 0x1F;
+          if (code == CCL_WriteExprConst || code == CCL_WriteExprRegister)
+            {
+              i = reg[rrr];
+              CCL_WRITE_CHAR (i);
+            }
+          else if (!reg[rrr])
+            ic = jump_address;
+          break;
+
+        default:
+          CCL_INVALID_CMD;
+        }
+    }
+
+ ccl_error_handler:
+  if (destination)
+    {
+      /* We can insert an error message only if DESTINATION is
+         specified and we still have a room to store the message
+         there.  */
+      char msg[256];
+      int msglen;
+
+      switch (ccl->status)
+        {
+        case CCL_STAT_INVALID_CMD:
+          sprintf(msg, "\nCCL: Invalid command %x (ccl_code = %x) at %d.",
+                  code & 0x1F, code, ic);
+#ifdef CCL_DEBUG
+          {
+            int i = ccl_backtrace_idx - 1;
+            int j;
+
+            msglen = strlen (msg);
+            if (dst + msglen <= dst_end)
+              {
+                bcopy (msg, dst, msglen);
+                dst += msglen;
+              }
+
+            for (j = 0; j < CCL_DEBUG_BACKTRACE_LEN; j++, i--)
+              {
+                if (i < 0) i = CCL_DEBUG_BACKTRACE_LEN - 1;
+                if (ccl_backtrace_table[i] == 0)
+                  break;
+                sprintf(msg, " %d", ccl_backtrace_table[i]);
+                msglen = strlen (msg);
+                if (dst + msglen > dst_end)
+                  break;
+                bcopy (msg, dst, msglen);
+                dst += msglen;
+              }
+          }
+          goto ccl_finish;
+#endif
+
+        case CCL_STAT_QUIT:
+          sprintf(msg, "\nCCL: Quited.");
+          break;
+
+        default:
+          sprintf(msg, "\nCCL: Unknown error type (%d).", ccl->status);
+        }
+
+      msglen = strlen (msg);
+      if (dst + msglen <= dst_end)
+        {
+          bcopy (msg, dst, msglen);
+          dst += msglen;
+        }
+    }
+
+ ccl_finish:
+  ccl->ic = ic;
+  if (consumed) *consumed = src - source;
+  return dst - destination;
+}
+
+/* Setup fields of the structure pointed by CCL appropriately for the
+   execution of compiled CCL code in VEC (vector of integer).  */
+setup_ccl_program (ccl, vec)
+     struct ccl_program *ccl;
+     Lisp_Object vec;
+{
+  int i;
+
+  ccl->size = XVECTOR (vec)->size;
+  ccl->prog = XVECTOR (vec)->contents;
+  ccl->ic = CCL_HEADER_MAIN;
+  ccl->eof_ic = XINT (XVECTOR (vec)->contents[CCL_HEADER_EOF]);
+  ccl->buf_magnification = XINT (XVECTOR (vec)->contents[CCL_HEADER_BUF_MAG]);
+  for (i = 0; i < 8; i++)
+    ccl->reg[i] = 0;
+  ccl->last_block = 0;
+  ccl->status = 0;
+}
+
+#ifdef emacs
+
+DEFUN ("ccl-execute", Fccl_execute, Sccl_execute, 2, 2, 0,
+  "Execute CCL-PROGRAM with registers initialized by REGISTERS.\n\
+CCL-PROGRAM is a compiled code generated by `ccl-compile',\n\
+ no I/O commands should appear in the CCL program.\n\
+REGISTERS is a vector of [R0 R1 ... R7] where RN is an initial value\n\
+ of Nth register.\n\
+As side effect, each element of REGISTER holds the value of\n\
+ corresponding register after the execution.")
+  (ccl_prog, reg)
+     Lisp_Object ccl_prog, reg;
+{
+  struct ccl_program ccl;
+  int i;
+
+  CHECK_VECTOR (ccl_prog, 0);
+  CHECK_VECTOR (reg, 1);
+  if (XVECTOR (reg)->size != 8)
+    error ("Invalid length of vector REGISTERS");
+
+  setup_ccl_program (&ccl, ccl_prog);
+  for (i = 0; i < 8; i++)
+    ccl.reg[i] = (INTEGERP (XVECTOR (reg)->contents[i])
+                  ? XINT (XVECTOR (reg)->contents[i])
+                  : 0);
+
+  ccl_driver (&ccl, (char *)0, (char *)0, 0, 0, (int *)0);
+  QUIT;
+  if (ccl.status != CCL_STAT_SUCCESS)
+    error ("Error in CCL program at %dth code", ccl.ic);
+
+  for (i = 0; i < 8; i++)
+    XSETINT (XVECTOR (reg)->contents[i], ccl.reg[i]);
+  return Qnil;
+}
+
+DEFUN ("ccl-execute-on-string", Fccl_execute_on_string, Sccl_execute_on_string,
+       3, 3, 0,
+  "Execute CCL-PROGRAM with initial STATUS on STRING.\n\
+CCL-PROGRAM is a compiled code generated by `ccl-compile'.\n\
+Read buffer is set to STRING, and write buffer is allocated automatically.\n\
+STATUS is a vector of [R0 R1 ... R7 IC], where\n\
+ R0..R7 are initial values of corresponding registers,\n\
+ IC is the instruction counter specifying from where to start the program.\n\
+If R0..R7 are nil, they are initialized to 0.\n\
+If IC is nil, it is initialized to head of the CCL program.\n\
+Returns the contents of write buffer as a string,\n\
+ and as side effect, STATUS is updated.")
+  (ccl_prog, status, str)
+     Lisp_Object ccl_prog, status, str;
+{
+  Lisp_Object val;
+  struct ccl_program ccl;
+  int i, produced;
+  int outbufsize;
+  char *outbuf;
+  struct gcpro gcpro1, gcpro2, gcpro3;
+
+  CHECK_VECTOR (ccl_prog, 0);
+  CHECK_VECTOR (status, 1);
+  if (XVECTOR (status)->size != 9)
+    error ("Invalid length of vector STATUS");
+  CHECK_STRING (str, 2);
+  GCPRO3 (ccl_prog, status, str);
+
+  setup_ccl_program (&ccl, ccl_prog);
+  for (i = 0; i < 8; i++)
+    {
+      if (NILP (XVECTOR (status)->contents[i]))
+        XSETINT (XVECTOR (status)->contents[i], 0);
+      if (INTEGERP (XVECTOR (status)->contents[i]))
+        ccl.reg[i] = XINT (XVECTOR (status)->contents[i]);
+    }
+  if (INTEGERP (XVECTOR (status)->contents[i]))
+    {
+      i = XFASTINT (XVECTOR (status)->contents[8]);
+      if (ccl.ic < i && i < ccl.size)
+        ccl.ic = i;
+    }
+  outbufsize = XSTRING (str)->size * ccl.buf_magnification + 256;
+  outbuf = (char *) xmalloc (outbufsize);
+  if (!outbuf)
+    error ("Not enough memory");
+  ccl.last_block = 1;
+  produced = ccl_driver (&ccl, XSTRING (str)->data, outbuf,
+                         XSTRING (str)->size, outbufsize, (int *)0);
+  for (i = 0; i < 8; i++)
+    XSET (XVECTOR (status)->contents[i], Lisp_Int, ccl.reg[i]);
+  XSETINT (XVECTOR (status)->contents[8], ccl.ic);
+  UNGCPRO;
+
+  val = make_string (outbuf, produced);
+  free (outbuf);
+  QUIT;
+  if (ccl.status != CCL_STAT_SUCCESS
+      && ccl.status != CCL_STAT_SUSPEND)
+    error ("Error in CCL program at %dth code", ccl.ic);
+
+  return val;
+}
+
+DEFUN ("register-ccl-program", Fregister_ccl_program, Sregister_ccl_program,
+       2, 2, 0,
+  "Register CCL program PROGRAM of NAME in `ccl-program-table'.
+PROGRAM should be a compiled code of CCL program, or nil.
+Return index number of the registered CCL program.")
+  (name, ccl_prog)
+     Lisp_Object name, ccl_prog;
+{
+  int len = XVECTOR (Vccl_program_table)->size;
+  int i, idx;
+
+  CHECK_SYMBOL (name, 0);
+  if (!NILP (ccl_prog))
+    CHECK_VECTOR (ccl_prog, 1);
+  
+  for (i = 0; i < len; i++)
+    {
+      Lisp_Object slot = XVECTOR (Vccl_program_table)->contents[i];
+
+      if (!CONSP (slot))
+        break;
+
+      if (EQ (name, XCONS (slot)->car))
+        {
+          XCONS (slot)->cdr = ccl_prog;
+          return make_number (i);
+        }
+    }
+
+  if (i == len)
+    {
+      Lisp_Object new_table = Fmake_vector (len * 2, Qnil);
+      int j;
+
+      for (j = 0; j < len; j++)
+        XVECTOR (new_table)->contents[j]
+          = XVECTOR (Vccl_program_table)->contents[j];
+      Vccl_program_table = new_table;
+    }
+
+  XVECTOR (Vccl_program_table)->contents[i] = Fcons (name, ccl_prog);
+  return make_number (i);
+}
+
+syms_of_ccl ()
+{
+  staticpro (&Vccl_program_table);
+  Vccl_program_table = Fmake_vector (32, Qnil);
+
+  DEFVAR_LISP ("font-ccl-encoder-alist", &Vfont_ccl_encoder_alist,
+    "Alist of fontname patterns vs corresponding CCL program.\n\
+Each element looks like (REGEXP . CCL-CODE),\n\
+ where CCL-CODE is a compiled CCL program.\n\
+When a font whose name matches REGEXP is used for displaying a character,\n\
+ CCL-CODE is executed to calculate the code point in the font\n\
+ from the charset number and position code(s) of the character which are set\n\
+ in CCL registers R0, R1, and R2 before the execution.\n\
+The code point in the font is set in CCL registers R1 and R2\n\
+ when the execution terminated.\n\
+If the font is single-byte font, the register R2 is not used.");
+  Vfont_ccl_encoder_alist = Qnil;
+
+  defsubr (&Sccl_execute);
+  defsubr (&Sccl_execute_on_string);
+  defsubr (&Sregister_ccl_program);
+}
+
+#endif  /* emacs */
diff --git a/src/ccl.h b/src/ccl.h
new file mode 100644
index 00000000000..ebda0cc1595
--- /dev/null
+++ b/src/ccl.h
@@ -0,0 +1,53 @@
+/* Header for CCL (Code Conversion Language) interpreter.
+
+   Copyright (C) 1995 Free Software Foundation, Inc.
+   Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#ifndef _CCL_H
+#define _CCL_H
+
+/* Structure to hold information about running CCL code.  Read
+   comments in the file ccl.c for the detail of each field.  */
+struct ccl_program {
+  int size;                     /* Size of the compiled code.  */
+  Lisp_Object *prog;            /* Pointer into the compiled code.  */
+  int ic;                       /* Instruction Counter (index for PROG).  */
+  int eof_ic;                   /* Instruction Counter for end-of-file
+                                   processing code.  */
+  int reg[8];                   /* CCL registers, reg[7] is used for
+                                   condition flag of relational
+                                   operations.  */
+  int last_block;               /* Set to 1 while processing the last
+                                   block. */
+  int status;                   /* Exit status of the CCL program.  */
+  int buf_magnification;        /* Output buffer magnification.  How
+                                   many times bigger the output buffer
+                                   should be than the input buffer.  */
+};
+
+/* This data type is used for the spec field of the structure
+   coding_system.  */
+
+struct ccl_spec {
+  struct ccl_program decoder;
+  struct ccl_program encoder;
+};
+
+/* Alist of fontname patterns vs corresponding CCL program.  */
+extern Lisp_Object Vfont_ccl_encoder_alist;
+
+#endif /* _CCL_H */
diff --git a/src/charset.c b/src/charset.c
new file mode 100644
index 00000000000..b962f346f22
--- /dev/null
+++ b/src/charset.c
@@ -0,0 +1,1452 @@
+/* Multilingual characters handler.
+   Ver.1.0
+
+   Copyright (C) 1995 Free Software Foundation, Inc.
+   Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/* At first, see the document in `charset.h' to understand the code in
+   this file.  */
+
+#include <stdio.h>
+
+#ifdef emacs
+
+#include <sys/types.h>
+#include <config.h>
+#include "lisp.h"
+#include "buffer.h"
+#include "charset.h"
+#include "coding.h"
+
+#else  /* not emacs */
+
+#include "mulelib.h"
+
+#endif /* emacs */
+
+Lisp_Object Qcharset, Qascii, Qcomposition;
+
+/* Declaration of special leading-codes.  */
+int leading_code_composition;   /* for composite characters */
+int leading_code_private_11;    /* for private DIMENSION1 of 1-column */
+int leading_code_private_12;    /* for private DIMENSION1 of 2-column */
+int leading_code_private_21;    /* for private DIMENSION2 of 1-column */
+int leading_code_private_22;    /* for private DIMENSION2 of 2-column */
+
+/* Declaration of special charsets.  */
+int charset_ascii;              /* ASCII */
+int charset_composition;        /* for a composite character */
+int charset_latin_iso8859_1;    /* ISO8859-1 (Latin-1) */
+int charset_jisx0208_1978;      /* JISX0208.1978 (Japanese Kanji old set) */
+int charset_jisx0208;           /* JISX0208.1983 (Japanese Kanji) */
+int charset_katakana_jisx0201;  /* JISX0201.Kana (Japanese Katakana) */
+int charset_latin_jisx0201;     /* JISX0201.Roman (Japanese Roman) */
+int charset_big5_1;             /* Big5 Level 1 (Chinese Traditional) */
+int charset_big5_2;             /* Big5 Level 2 (Chinese Traditional) */
+
+Lisp_Object Qcharset_table;
+
+/* A char-table containing information of each character set.  */
+Lisp_Object Vcharset_table;
+
+/* A vector of charset symbol indexed by charset-id.  This is used
+   only for returning charset symbol from C functions.  */
+Lisp_Object Vcharset_symbol_table;
+
+/* A list of charset symbols ever defined.  */
+Lisp_Object Vcharset_list;
+
+/* Tables used by macros BYTES_BY_CHAR_HEAD and WIDTH_BY_CHAR_HEAD.  */
+int bytes_by_char_head[256];
+int width_by_char_head[256];
+
+/* Mapping table from ISO2022's charset (specified by DIMENSION,
+   CHARS, and FINAL-CHAR) to Emacs' charset.  */
+int iso_charset_table[2][2][128];
+
+/* Variables used locally in the macro FETCH_MULTIBYTE_CHAR.  */
+unsigned char *_fetch_multibyte_char_p;
+int _fetch_multibyte_char_len;
+
+/* Set STR a pointer to the multi-byte form of the character C.  If C
+   is not a composite character, the multi-byte form is set in WORKBUF
+   and STR points WORKBUF.  The caller should allocate at least 4-byte
+   area at WORKBUF in advance.  Returns the length of the multi-byte
+   form.
+
+   Use macro `CHAR_STRING (C, WORKBUF, STR)' instead of calling this
+   function directly if C can be an ASCII character.  */
+
+int
+non_ascii_char_to_string (c, workbuf, str)
+     int c;
+     unsigned char *workbuf, **str;
+{
+  int charset;
+  unsigned char c1, c2;
+
+  if (COMPOSITE_CHAR_P (c))
+    {
+      int cmpchar_id = COMPOSITE_CHAR_ID (c);
+
+      if (cmpchar_id < n_cmpchars)
+        {
+          *str = cmpchar_table[cmpchar_id]->data;
+          return cmpchar_table[cmpchar_id]->len;
+        }
+      else
+        {
+          *str = workbuf;
+          return 0;
+        }
+    }
+
+  SPLIT_NON_ASCII_CHAR (c, charset, c1, c2);
+
+  *str = workbuf;
+  *workbuf++ = CHARSET_LEADING_CODE_BASE (charset);
+  if (*workbuf = CHARSET_LEADING_CODE_EXT (charset))
+    workbuf++;
+  *workbuf++ = c1 | 0x80;
+  if (c2)
+    *workbuf++ = c2 | 0x80;
+
+  return (workbuf - *str);
+}
+
+/* Return a non-ASCII character of which multi-byte form is at STR of
+   length LEN.  If ACTUAL_LEN is not NULL, the actual length of the
+   character is set to the address ACTUAL_LEN.
+
+   Use macro `STRING_CHAR (STR, LEN)' instead of calling this function
+   directly if STR can hold an ASCII character.  */
+
+string_to_non_ascii_char (str, len, actual_len)
+     unsigned char *str;
+     int len, *actual_len;
+{
+  int charset;
+  unsigned char c1, c2;
+  register int c;
+
+  if (SPLIT_STRING (str, len, charset, c1, c2) == CHARSET_ASCII)
+    {
+      if (actual_len)
+        *actual_len = 1;
+      return (int) *str;
+    }
+
+  c = MAKE_NON_ASCII_CHAR (charset, c1, c2);
+
+  if (actual_len)
+    *actual_len = (charset == CHARSET_COMPOSITION
+                   ? cmpchar_table[COMPOSITE_CHAR_ID (c)]->len
+                   : BYTES_BY_CHAR_HEAD (*str));
+  return c;
+}
+
+/* Return the length of the multi-byte form at string STR of length LEN.  */
+int
+multibyte_form_length (str, len)
+     unsigned char *str;
+     int len;
+{
+  int charset;
+  unsigned char c1, c2;
+  register int c;
+
+  if (SPLIT_STRING (str, len, charset, c1, c2) == CHARSET_ASCII)
+    return 1;
+
+  return (charset == CHARSET_COMPOSITION
+          ? cmpchar_table[(c1 << 7) | c2]->len
+          : BYTES_BY_CHAR_HEAD (*str));
+}
+
+/* Check if string STR of length LEN contains valid multi-byte form of
+   a character.  If valid, charset and position codes of the character
+   is set at *CHARSET, *C1, and *C2, and return 0.  If not valid,
+   return -1.  This should be used only in the macro SPLIT_STRING
+   which checks range of STR in advance.  */
+
+split_non_ascii_string (str, len, charset, c1, c2)
+     register unsigned char *str, *c1, *c2;
+     register int len, *charset;
+{
+  register unsigned int cs = *str++;
+
+  if (cs == LEADING_CODE_COMPOSITION)
+    {
+      int cmpchar_id = str_cmpchar_id (str - 1, len);
+
+      if (cmpchar_id < 0)
+        return -1;
+      *charset = cs, *c1 = cmpchar_id >> 7, *c2 = cmpchar_id & 0x7F;
+    }
+  else if ((cs < LEADING_CODE_PRIVATE_11 || (cs = *str++) >= 0xA0)
+           && CHARSET_DEFINED_P (cs))
+    {
+      *charset = cs;
+      if (*str < 0xA0)
+        return -1;
+      *c1 = (*str++) & 0x7F;
+      if (CHARSET_DIMENSION (cs) == 2)
+        {
+          if (*str < 0xA0)
+            return -1;
+          *c2 = (*str++) & 0x7F;
+        }
+    }
+  else
+    return -1;
+  return 0;
+}
+
+/* Update the table Vcharset_table with the given arguments (see the
+   document of `define-charset' for the meaning of each argument).
+   Several other table contents are also updated.  The caller should
+   check the validity of CHARSET-ID and the remaining arguments in
+   advance.  */
+
+void
+update_charset_table (charset_id, dimension, chars, width, direction,
+                      iso_final_char, iso_graphic_plane,
+                      short_name, long_name, description)
+     Lisp_Object charset_id, dimension, chars, width, direction;
+     Lisp_Object iso_final_char, iso_graphic_plane;
+     Lisp_Object short_name, long_name, description;
+{
+  int charset = XINT (charset_id);
+  int bytes;
+  unsigned char leading_code_base, leading_code_ext;
+
+  if (NILP (Faref (Vcharset_table, charset_id)))
+    Faset (Vcharset_table, charset_id,
+           Fmake_vector (make_number (CHARSET_MAX_IDX), Qnil));
+
+  /* Get byte length of multibyte form, base leading-code, and
+     extended leading-code of the charset.  See the comment under the
+     title "GENERAL NOTE on CHARACTER SET (CHARSET)" in charset.h.  */
+  bytes = XINT (dimension);
+  if (charset < MIN_CHARSET_PRIVATE_DIMENSION1)
+    {
+      /* Official charset, it doesn't have an extended leading-code.  */
+      if (charset != CHARSET_ASCII)
+        bytes += 1; /* For a base leading-code.  */
+      leading_code_base = charset;
+      leading_code_ext = 0;
+    }
+  else
+    {
+      /* Private charset.  */
+      bytes += 2; /* For base and extended leading-codes.  */
+      leading_code_base
+        = (charset < LEADING_CODE_EXT_12
+           ? LEADING_CODE_PRIVATE_11
+           : (charset < LEADING_CODE_EXT_21
+              ? LEADING_CODE_PRIVATE_12
+              : (charset < LEADING_CODE_EXT_22
+                 ? LEADING_CODE_PRIVATE_21
+                 : LEADING_CODE_PRIVATE_22)));
+      leading_code_ext = charset;
+    } 
+
+  CHARSET_TABLE_INFO (charset, CHARSET_ID_IDX) = charset_id;
+  CHARSET_TABLE_INFO (charset, CHARSET_BYTES_IDX) = make_number (bytes);
+  CHARSET_TABLE_INFO (charset, CHARSET_DIMENSION_IDX) = dimension;
+  CHARSET_TABLE_INFO (charset, CHARSET_CHARS_IDX) = chars;
+  CHARSET_TABLE_INFO (charset, CHARSET_WIDTH_IDX) = width;
+  CHARSET_TABLE_INFO (charset, CHARSET_DIRECTION_IDX) = direction;
+  CHARSET_TABLE_INFO (charset, CHARSET_LEADING_CODE_BASE_IDX)
+    = make_number (leading_code_base);
+  CHARSET_TABLE_INFO (charset, CHARSET_LEADING_CODE_EXT_IDX)
+    = make_number (leading_code_ext);
+  CHARSET_TABLE_INFO (charset, CHARSET_ISO_FINAL_CHAR_IDX) = iso_final_char;
+  CHARSET_TABLE_INFO (charset, CHARSET_ISO_GRAPHIC_PLANE_IDX)
+    = iso_graphic_plane;
+  CHARSET_TABLE_INFO (charset, CHARSET_SHORT_NAME_IDX) = short_name;
+  CHARSET_TABLE_INFO (charset, CHARSET_LONG_NAME_IDX) = long_name;
+  CHARSET_TABLE_INFO (charset, CHARSET_DESCRIPTION_IDX) = description;
+  CHARSET_TABLE_INFO (charset, CHARSET_PLIST_IDX) = Qnil;
+
+  {
+    /* If we have already defined a charset which has the same
+       DIMENSION, CHARS and ISO-FINAL-CHAR but the different
+       DIRECTION, we must update the entry REVERSE-CHARSET of both
+       charsets.  If there's no such charset, the value of the entry
+       is set to nil.  */
+    int i;
+
+    for (i = 0; i < MAX_CHARSET; i++)
+      if (!NILP (CHARSET_TABLE_ENTRY (i)))
+        {
+          if (CHARSET_DIMENSION (i) == XINT (dimension)
+              && CHARSET_CHARS (i) == XINT (chars)
+              && CHARSET_ISO_FINAL_CHAR (i) == XINT (iso_final_char)
+              && CHARSET_DIRECTION (i) != XINT (direction))
+            {
+              CHARSET_TABLE_INFO (charset, CHARSET_REVERSE_CHARSET_IDX)
+                = make_number (i);
+              CHARSET_TABLE_INFO (i, CHARSET_REVERSE_CHARSET_IDX) = charset_id;
+              break;
+            }
+        }
+    if (i >= MAX_CHARSET)
+      /* No such a charset.  */
+      CHARSET_TABLE_INFO (charset, CHARSET_REVERSE_CHARSET_IDX)
+        = make_number (-1);
+  }
+
+  if (charset != CHARSET_ASCII
+      && charset < MIN_CHARSET_PRIVATE_DIMENSION1)
+    {
+      /* Update tables bytes_by_char_head and width_by_char_head.  */
+      bytes_by_char_head[leading_code_base] = bytes;
+      width_by_char_head[leading_code_base] = XINT (width);
+
+      /* Update table emacs_code_class.  */
+      emacs_code_class[charset] = (bytes == 2
+                                   ? EMACS_leading_code_2
+                                   : (bytes == 3
+                                      ? EMACS_leading_code_3
+                                      : EMACS_leading_code_4));
+    }
+
+  /* Update table iso_charset_table.  */
+  if (ISO_CHARSET_TABLE (dimension, chars, iso_final_char) < 0)
+    ISO_CHARSET_TABLE (dimension, chars, iso_final_char) = charset;
+}
+
+#ifdef emacs
+
+/* Return charset id of CHARSET_SYMBOL, or return -1 if CHARSET_SYMBOL
+   is invalid.  */
+int
+get_charset_id (charset_symbol)
+     Lisp_Object charset_symbol;
+{
+  Lisp_Object val;
+  int charset;
+
+  return ((SYMBOLP (charset_symbol)
+           && (val = Fget (charset_symbol, Qcharset), VECTORP (val))
+           && (charset = XINT (XVECTOR (val)->contents[CHARSET_ID_IDX]),
+               CHARSET_VALID_P (charset)))
+          ? charset : -1);
+}
+
+/* Return an identification number for a new private charset of
+   DIMENSION and WIDTH.  If there's no more room for the new charset,
+   return 0.  */
+Lisp_Object
+get_new_private_charset_id (dimension, width)
+     int dimension, width;
+{
+  int charset, from, to;
+
+  if (dimension == 1)
+    {
+      if (width == 1)
+        from = LEADING_CODE_EXT_11, to = LEADING_CODE_EXT_12;
+      else
+        from = LEADING_CODE_EXT_12, to = LEADING_CODE_EXT_21;
+    }
+  else
+    {
+      if (width == 1)
+        from = LEADING_CODE_EXT_21, to = LEADING_CODE_EXT_22;
+      else
+        from = LEADING_CODE_EXT_22, to = LEADING_CODE_EXT_MAX - 1;
+    }
+
+  for (charset = from; charset < to; charset++)
+    if (!CHARSET_DEFINED_P (charset)) break;
+
+  return make_number (charset < to ? charset : 0);
+}
+
+DEFUN ("define-charset", Fdefine_charset, Sdefine_charset, 3, 3, 0,
+  "Define CHARSET-ID as the identification number of CHARSET with INFO-VECTOR.\n\
+If CHARSET-ID is nil, it is set automatically, which means CHARSET is\n\
+ treated as a private charset.\n\
+INFO-VECTOR is a vector of the format:\n\
+   [DIMENSION CHARS WIDTH DIRECTION ISO-FINAL-CHAR ISO-GRAPHIC-PLANE\n\
+    SHORT-NAME LONG-NAME DESCRIPTION]\n\
+The meanings of each elements is as follows:\n\
+DIMENSION (integer) is the number of bytes to represent a character: 1 or 2.\n\
+CHARS (integer) is the number of characters in a dimension: 94 or 96.\n\
+WIDTH (integer) is the number of columns a character in the charset\n\
+occupies on the screen: one of 0, 1, and 2.\n\
+\n\
+DIRECTION (integer) is the rendering direction of characters in the\n\
+charset when rendering.  If 0, render from right to left, else\n\
+render from left to right.\n\
+\n\
+ISO-FINAL-CHAR (character) is the final character of the\n\
+corresponding ISO 2022 charset.\n\
+\n\
+ISO-GRAPHIC-PLANE (integer) is the graphic plane to be invoked\n\
+while encoding to variants of ISO 2022 coding system, one of the\n\
+following: 0/graphic-plane-left(GL), 1/graphic-plane-right(GR).\n\
+\n\
+SHORT-NAME (string) is the short name to refer to the charset.\n\
+\n\
+LONG-NAME (string) is the long name to refer to the charset.\n\
+\n\
+DESCRIPTION (string) is the description string of the charset.")
+  (charset_id, charset_symbol, info_vector)
+     Lisp_Object charset_id, charset_symbol, info_vector;
+{
+  Lisp_Object *vec;
+
+  if (!NILP (charset_id))
+    CHECK_NUMBER (charset_id, 0);
+  CHECK_SYMBOL (charset_symbol, 1);
+  CHECK_VECTOR (info_vector, 2);
+
+  if (! NILP (charset_id))
+    {
+      if (! CHARSET_VALID_P (XINT (charset_id)))
+        error ("Invalid CHARSET: %d", XINT (charset_id));
+      else if (CHARSET_DEFINED_P (XINT (charset_id)))
+        error ("Already defined charset: %d", XINT (charset_id));
+    }
+
+  vec = XVECTOR (info_vector)->contents;
+  if (XVECTOR (info_vector)->size != 9
+      || !INTEGERP (vec[0]) || !(XINT (vec[0]) == 1 || XINT (vec[0]) == 2)
+      || !INTEGERP (vec[1]) || !(XINT (vec[1]) == 94 || XINT (vec[1]) == 96)
+      || !INTEGERP (vec[2]) || !(XINT (vec[2]) == 1 || XINT (vec[2]) == 2)
+      || !INTEGERP (vec[3]) || !(XINT (vec[3]) == 0 || XINT (vec[3]) == 1)
+      || !INTEGERP (vec[4]) || !(XINT (vec[4]) >= '0' && XINT (vec[4]) <= '~')
+      || !INTEGERP (vec[5]) || !(XINT (vec[5]) == 0 || XINT (vec[5]) == 1)
+      || !STRINGP (vec[6])
+      || !STRINGP (vec[7])
+      || !STRINGP (vec[8]))
+    error ("Invalid info-vector argument for defining charset %s",
+           XSYMBOL (charset_symbol)->name->data);
+
+  if (NILP (charset_id))
+    {
+      charset_id = get_new_private_charset_id (XINT (vec[0]), XINT (vec[2]));
+      if (XINT (charset_id) == 0)
+        error ("There's no room for a new private charset %s",
+               XSYMBOL (charset_symbol)->name->data);
+    }
+
+  update_charset_table (charset_id, vec[0], vec[1], vec[2], vec[3],
+                        vec[4], vec[5], vec[6], vec[7], vec[8]);
+  Fput (charset_symbol, Qcharset, Faref (Vcharset_table, charset_id));
+  CHARSET_SYMBOL (XINT (charset_id)) = charset_symbol;
+  Vcharset_list = Fcons (charset_symbol, Vcharset_list);
+  return Qnil;
+}
+
+DEFUN ("declare-equiv-charset", Fdeclare_equiv_charset, Sdeclare_equiv_charset,
+       4, 4, 0,
+  "Declare a charset of DIMENSION, CHARS, FINAL-CHAR is the same as CHARSET.\n\
+CHARSET should be defined by `defined-charset' in advance.")
+  (dimension, chars, final_char, charset_symbol)
+     Lisp_Object dimension, chars, final_char, charset_symbol;
+{
+  int charset;
+
+  CHECK_NUMBER (dimension, 0);
+  CHECK_NUMBER (chars, 1);
+  CHECK_NUMBER (final_char, 2);
+  CHECK_SYMBOL (charset_symbol, 3);
+
+  if (XINT (dimension) != 1 && XINT (dimension) != 2)
+    error ("Invalid DIMENSION %d, it should be 1 or 2", XINT (dimension));
+  if (XINT (chars) != 94 && XINT (chars) != 96)
+    error ("Invalid CHARS %d, it should be 94 or 96", XINT (chars));
+  if (XINT (final_char) < '0' || XFASTINT (final_char) > '~')
+    error ("Invalid FINAL-CHAR %c, it should be `0'..`~'", XINT (chars));
+  if ((charset = get_charset_id (charset_symbol)) < 0)
+    error ("Invalid charset %s", XSYMBOL (charset_symbol)->name->data);
+
+  ISO_CHARSET_TABLE (dimension, chars, final_char) = charset;
+  return Qnil;
+}
+
+/* Return number of different charsets in STR of length LEN.  In
+   addition, for each found charset N, CHARSETS[N] is set 1.  The
+   caller should allocate CHARSETS (MAX_CHARSET bytes) in advance.  */
+
+int
+find_charset_in_str (str, len, charsets)
+     unsigned char *str, *charsets;
+     int len;
+{
+  int num = 0;
+
+  while (len > 0)
+    {
+      int bytes = BYTES_BY_CHAR_HEAD (*str);
+      int charset = CHARSET_AT (str);
+
+      if (!charsets[charset])
+        {
+          charsets[charset] = 1;
+          num += 1;
+        }
+      str += bytes;
+      len -= bytes;
+    }
+  return num;
+}
+
+DEFUN ("find-charset-region", Ffind_charset_region, Sfind_charset_region,
+       2, 2, 0,
+  "Return a list of charsets in the region between BEG and END.\n\
+BEG and END are buffer positions.")
+  (beg, end)
+     Lisp_Object beg, end;
+{
+  char charsets[MAX_CHARSET];
+  int from, to, stop, i;
+  Lisp_Object val;
+
+  validate_region (&beg, &end);
+  from = XFASTINT (beg);
+  stop = to = XFASTINT (end);
+  if (from < GPT && GPT < to)
+    stop = GPT;
+  bzero (charsets, MAX_CHARSET);
+  while (1)
+    {
+      find_charset_in_str (POS_ADDR (from), stop - from, charsets);
+      if (stop < to)
+        from = stop, stop = to;
+      else
+        break;
+    }
+  val = Qnil;
+  for (i = MAX_CHARSET - 1; i >= 0; i--)
+    if (charsets[i])
+      val = Fcons (CHARSET_SYMBOL (i), val);
+  return val;
+}
+
+DEFUN ("find-charset-string", Ffind_charset_string, Sfind_charset_string,
+       1, 1, 0,
+  "Return a list of charsets in STR.")
+  (str)
+     Lisp_Object str;
+{
+  char charsets[MAX_CHARSET];
+  int i;
+  Lisp_Object val;
+
+  CHECK_STRING (str, 0);
+  bzero (charsets, MAX_CHARSET);
+  find_charset_in_str (XSTRING (str)->data, XSTRING (str)->size, charsets);
+  val = Qnil;
+  for (i = MAX_CHARSET - 1; i >= 0; i--)
+    if (charsets[i])
+      val = Fcons (CHARSET_SYMBOL (i), val);
+  return val;
+}
+
+DEFUN ("make-char-internal", Fmake_char_internal, Smake_char_internal, 1, 3, 0,
+  "Return a character of CHARSET and position-codes CODE1 and CODE2.\n\
+CODE1 and CODE2 are optional, but if you don't supply\n\
+ sufficient position-codes, return a generic character which stands for\n\
+all characters or group of characters in the character sets.\n\
+A generic character can be an argument of `modify-syntax-entry' and\n\
+`modify-category-entry'.")
+  (charset, code1, code2)
+     Lisp_Object charset, code1, code2;
+{
+  CHECK_NUMBER (charset, 0);
+
+  if (NILP (code1))
+    XSETFASTINT (code1, 0);
+  else
+    CHECK_NUMBER (code1, 1);
+  if (NILP (code2))
+    XSETFASTINT (code2, 0);
+  else
+    CHECK_NUMBER (code2, 2);
+
+  if (!CHARSET_DEFINED_P (XINT (charset)))
+    error ("Invalid charset: %d", XINT (charset));
+
+  return make_number (MAKE_CHAR (XINT (charset), XINT (code1), XINT (code2)));
+}
+
+DEFUN ("split-char", Fsplit_char, Ssplit_char, 1, 1, 0,
+  "Return list of charset and one or two position-codes of CHAR.")
+  (ch)
+     Lisp_Object ch;
+{
+  Lisp_Object val;
+  int charset;
+  unsigned char c1, c2;
+
+  CHECK_NUMBER (ch, 0);
+  SPLIT_CHAR (XFASTINT (ch), charset, c1, c2);
+  return ((charset == CHARSET_COMPOSITION || CHARSET_DIMENSION (charset) == 2)
+          ? Fcons (CHARSET_SYMBOL (charset),
+                   Fcons (make_number (c1), Fcons (make_number (c2), Qnil)))
+          : Fcons (CHARSET_SYMBOL (charset), Fcons (make_number (c1), Qnil)));
+}
+
+DEFUN ("char-charset", Fchar_charset, Schar_charset, 1, 1, 0,
+  "Return charset of CHAR.")
+  (ch)
+     Lisp_Object ch;
+{
+  CHECK_NUMBER (ch, 0);
+
+  return CHARSET_SYMBOL (CHAR_CHARSET (XINT (ch)));
+}
+
+DEFUN ("iso-charset", Fiso_charset, Siso_charset, 3, 3, 0,
+  "Return charset of ISO's specification DIMENSION, CHARS, and FINAL-CHAR.")
+  (dimension, chars, final_char)
+     Lisp_Object dimension, chars, final_char;
+{
+  int charset;
+
+  CHECK_NUMBER (dimension, 0);
+  CHECK_NUMBER (chars, 1);
+  CHECK_NUMBER (final_char, 2);
+
+  if ((charset = ISO_CHARSET_TABLE (dimension, chars, final_char)) < 0)
+    return Qnil;
+  return CHARSET_SYMBOL (charset);
+}
+
+DEFUN ("char-bytes", Fchar_bytes, Schar_bytes, 1, 1, 0,
+  "Return byte length of multi-byte form of CHAR.")
+  (ch)
+     Lisp_Object ch;
+{
+  Lisp_Object val;
+  int bytes;
+
+  CHECK_NUMBER (ch, 0);
+  if (COMPOSITE_CHAR_P (XFASTINT (ch)))
+    {
+      unsigned int id = COMPOSITE_CHAR_ID (XFASTINT (ch));
+
+      bytes = (id < n_cmpchars ? cmpchar_table[id]->len : 1);
+    }
+  else
+    {
+      int charset = CHAR_CHARSET (XFASTINT (ch));
+
+      bytes = CHARSET_DEFINED_P (charset) ? CHARSET_BYTES (charset) : 1;
+    }
+
+  XSETFASTINT (val, bytes);
+  return val;
+}
+
+/* Return the width of character of which multi-byte form starts with
+   C.  The width is measured by how many columns occupied on the
+   screen when displayed in the current buffer.  */
+
+#define ONE_BYTE_CHAR_WIDTH(c)                                          \
+  (c < 0x20                                                             \
+   ? (c == '\t'                                                         \
+      ? current_buffer->tab_width                                       \
+      : (c == '\n' ? 0 : (NILP (current_buffer->ctl_arrow) ? 4 : 2)))   \
+   : (c < 0x7f                                                          \
+      ? 1                                                               \
+      : (c == 0x7F                                                      \
+         ? (NILP (current_buffer->ctl_arrow) ? 4 : 2)                   \
+         : ((! NILP (current_buffer->enable_multibyte_characters)       \
+             && BASE_LEADING_CODE_P (c))                                \
+            ? WIDTH_BY_CHAR_HEAD (c)                                    \
+            : 4))))                                                     \
+
+
+DEFUN ("char-width", Fchar_width, Schar_width, 1, 1, 0,
+  "Return width of CHAR when displayed in the current buffer.\n\
+The width is measured by how many columns it occupies on the screen.")
+  (ch)
+       Lisp_Object ch;
+{
+  Lisp_Object val;
+  int c;
+
+  CHECK_NUMBER (ch, 0);
+
+  c = XFASTINT (ch);
+  if (SINGLE_BYTE_CHAR_P (c))
+    XSETFASTINT (val, ONE_BYTE_CHAR_WIDTH (c));
+  else if (COMPOSITE_CHAR_P (c))
+    {
+      int id = COMPOSITE_CHAR_ID (XFASTINT (ch));
+      XSETFASTINT (val, (id < n_cmpchars ? cmpchar_table[id]->width : 0));
+    }
+  else
+    {
+      int charset = CHAR_CHARSET (c);
+
+      XSETFASTINT (val, CHARSET_WIDTH (charset));
+    }
+  return val;
+}
+
+/* Return width of string STR of length LEN when displayed in the
+   current buffer.  The width is measured by how many columns it
+   occupies on the screen.  */
+int
+strwidth (str, len)
+     unsigned char *str;
+     int len;
+{
+  unsigned char *endp = str + len;
+  int width = 0;
+
+  while (str < endp) {
+    if (*str == LEADING_CODE_COMPOSITION)
+      {
+        int id = str_cmpchar_id (str, endp - str);
+
+        if (id < 0)
+          {
+            width += 4;
+            str++;
+          }
+        else
+          {
+            width += cmpchar_table[id]->width;
+            str += cmpchar_table[id]->len;
+          }
+      }
+    else
+      {
+        width += ONE_BYTE_CHAR_WIDTH (*str);
+        str += BYTES_BY_CHAR_HEAD (*str);
+      }
+  }
+  return width;
+}
+
+DEFUN ("string-width", Fstring_width, Sstring_width, 1, 1, 0,
+  "Return width of STRING when displayed in the current buffer.\n\
+Width is measured by how many columns it occupies on the screen.\n\
+When calculating width of a multi-byte character in STRING,\n\
+ only the base leading-code is considered and the validity of\n\
+ the following bytes are not checked.")
+  (str)
+     Lisp_Object str;
+{
+  Lisp_Object val;
+
+  CHECK_STRING (str, 0);
+  XSETFASTINT (val, strwidth (XSTRING (str)->data, XSTRING (str)->size));
+  return val;
+}
+
+DEFUN ("char-direction", Fchar_direction, Schar_direction, 1, 1, 0,
+  "Return the direction of CHAR.\n\
+The returned value is 0 for left-to-right and 1 for right-to-left.")
+  (ch)
+     Lisp_Object ch;
+{
+  int charset;
+
+  CHECK_NUMBER (ch, 0);
+  charset = CHAR_CHARSET (XFASTINT (ch));
+  if (!CHARSET_DEFINED_P (charset))
+    error ("Invalid character: %d", XINT (ch));
+  return CHARSET_TABLE_INFO (charset, CHARSET_DIRECTION_IDX);
+}
+
+DEFUN ("chars-in-string", Fchars_in_string, Schars_in_string, 1, 1, 0,
+  "Return number of characters in STRING.")
+  (str)
+     Lisp_Object str;
+{
+  Lisp_Object val;
+  unsigned char *p, *endp;
+  int chars;
+
+  CHECK_STRING (str, 0);
+
+  p = XSTRING (str)->data; endp = p + XSTRING (str)->size;
+  chars = 0;
+  while (p < endp)
+    {
+      if (*p == LEADING_CODE_COMPOSITION)
+        {
+          p++;
+          while (p < endp && ! CHAR_HEAD_P (p)) p++;
+        }
+      else
+        p += BYTES_BY_CHAR_HEAD (*p);
+      chars++;
+    }
+
+  XSETFASTINT (val, chars);
+  return val;
+}
+
+DEFUN ("char-boundary-p", Fchar_boundary_p, Schar_boundary_p, 1, 1, 0,
+  "Return non-nil value if POS is at character boundary of multibyte form.\n\
+The return value is:\n\
+ 0 if POS is at an ASCII character or at the end of range,\n\
+ 1 if POS is at a head of 2-byte length multi-byte form,\n\
+ 2 if POS is at a head of 3-byte length multi-byte form,\n\
+ 3 if POS is at a head of 4-byte length multi-byte form,\n\
+ 4 if POS is at a head of multi-byte form of a composite character.\n\
+If POS is out of range or not at character boundary, return NIL.")
+  (pos)
+     Lisp_Object pos;
+{
+  Lisp_Object val;
+  int n;
+
+  CHECK_NUMBER_COERCE_MARKER (pos, 0);
+
+  n = XINT (pos);
+  if (n < BEGV || n > ZV)
+    return Qnil;
+
+  if (n == ZV || NILP (current_buffer->enable_multibyte_characters))
+    XSETFASTINT (val, 0);
+  else
+    {
+      unsigned char *p = POS_ADDR (n);
+
+      if (SINGLE_BYTE_CHAR_P (*p))
+        XSETFASTINT (val, 0);
+      else if (*p == LEADING_CODE_COMPOSITION)
+        XSETFASTINT (val, 4);
+      else if (BYTES_BY_CHAR_HEAD (*p) > 1)
+        XSETFASTINT (val, BYTES_BY_CHAR_HEAD (*p) - 1);
+      else
+        val = Qnil;
+    }
+  return val;
+}
+
+DEFUN ("concat-chars", Fconcat_chars, Sconcat_chars, 1, MANY, 0,
+  "Concatenate all the argument characters and make the result a string.")
+  (nargs, args)
+     int nargs;
+     Lisp_Object *args;
+{
+  int i, n = XINT (nargs);
+  unsigned char *buf
+    = (unsigned char *) malloc (MAX_LENGTH_OF_MULTI_BYTE_FORM * n);
+  unsigned char *p = buf;
+  Lisp_Object val;
+
+  for (i = 0; i < n; i++)
+    {
+      int c, len;
+      unsigned char *str;
+
+      if (!INTEGERP (args[i]))
+        {
+          free (buf);
+          CHECK_NUMBER (args[i], 0);
+        }
+      c = XINT (args[i]);
+      len = CHAR_STRING (c, p, str);
+      if (p != str)
+        /* C is a composite character.  */
+        bcopy (str, p, len);
+      p += len;
+    }
+
+  val = make_string (buf, p - buf);
+  free (buf);
+  return val;
+}
+
+#endif /* emacs */
+
+/*** Composite characters staffs ***/
+
+/* Each composite character is identified by CMPCHAR-ID which is
+   assigned when Emacs needs the character code of the composite
+   character (e.g. when displaying it on the screen).  See the
+   document "GENERAL NOTE on COMPOSITE CHARACTER" in `charset.h' how a
+   composite character is represented in Emacs.  */
+
+/* If `static' is defined, it means that it is defined to null string. */
+#ifndef static
+/* The following function is copied from lread.c.  */
+static int
+hash_string (ptr, len)
+     unsigned char *ptr;
+     int len;
+{
+  register unsigned char *p = ptr;
+  register unsigned char *end = p + len;
+  register unsigned char c;
+  register int hash = 0;
+
+  while (p != end)
+    {
+      c = *p++;
+      if (c >= 0140) c -= 40;
+      hash = ((hash<<3) + (hash>>28) + c);
+    }
+  return hash & 07777777777;
+}
+#endif
+
+/* Table of pointers to the structure `cmpchar_info' indexed by
+   CMPCHAR-ID.  */
+struct cmpchar_info **cmpchar_table;
+/* The current size of `cmpchar_table'.  */
+static int cmpchar_table_size;
+/* Number of the current composite characters.  */
+int n_cmpchars;
+
+#define CMPCHAR_HASH_TABLE_SIZE 0xFFF
+
+static int *cmpchar_hash_table[CMPCHAR_HASH_TABLE_SIZE];
+
+/* Each element of `cmpchar_hash_table' is a pointer to an array of
+   integer, where the 1st element is the size of the array, the 2nd
+   element is how many elements are actually used in the array, and
+   the remaining elements are CMPCHAR-IDs of composite characters of
+   the same hash value.  */
+#define CMPCHAR_HASH_SIZE(table) table[0]
+#define CMPCHAR_HASH_USED(table) table[1]
+#define CMPCHAR_HASH_CMPCHAR_ID(table, i) table[i]
+
+/* Return CMPCHAR-ID of the composite character in STR of the length
+   LEN.  If the composite character has not yet been registered,
+   register it in `cmpchar_table' and assign new CMPCHAR-ID.  This
+   is the sole function for assigning CMPCHAR-ID.  */
+int
+str_cmpchar_id (str, len)
+     unsigned char *str;
+     int len;
+{
+  int hash_idx, *hashp;
+  unsigned char *buf;
+  int embedded_rule;            /* 1 if composition rule is embedded.  */
+  int chars;                    /* number of components.  */
+  int i;
+  struct cmpchar_info *cmpcharp;
+
+  if (len < 5)
+    /* Any composite char have at least 3-byte length.  */
+    return -1;
+
+  /* The second byte 0xFF means compostion rule is embedded.  */
+  embedded_rule = (str[1] == 0xFF);
+
+  /* At first, get the actual length of the composite character.  */
+  {
+    unsigned char *p, *endp = str + 1, *lastp = str + len;
+    int bytes;
+
+    while (endp < lastp && ! CHAR_HEAD_P (endp)) endp++;
+    chars = 0;
+    p = str + 1 + embedded_rule;
+    while (p < endp)
+      {
+        /* No need of checking if *P is 0xA0 because
+         BYTES_BY_CHAR_HEAD (0x80) surely returns 2.  */
+        p += (bytes = BYTES_BY_CHAR_HEAD (*p - 0x20) + embedded_rule);
+        chars++;
+      }
+    len = (p -= embedded_rule) - str;
+    if (p > endp)
+      len -= - bytes, chars--;
+
+    if (chars < 2 || chars > MAX_COMPONENT_COUNT)
+      /* Invalid number of components.  */
+      return -1;
+  }
+  hash_idx = hash_string (str, len) % CMPCHAR_HASH_TABLE_SIZE;
+  hashp = cmpchar_hash_table[hash_idx];
+
+  /* Then, look into the hash table.  */
+  if (hashp != NULL)
+    /* Find the correct one among composite characters of the same
+       hash value.  */
+    for (i = 2; i < CMPCHAR_HASH_USED (hashp); i++)
+      {
+        cmpcharp = cmpchar_table[CMPCHAR_HASH_CMPCHAR_ID (hashp, i)];
+        if (len == cmpcharp->len
+            && ! bcmp (str, cmpcharp->data, len))
+          return CMPCHAR_HASH_CMPCHAR_ID (hashp, i);
+      }
+
+  /* We have to register the composite character in cmpchar_table.  */
+  /* Make the entry in hash table.  */
+  if (hashp == NULL)
+    {
+      /* Make a table for 8 composite characters initially.  */
+      hashp = (cmpchar_hash_table[hash_idx]
+               = (int *) xmalloc (sizeof (int) * (2 + 8)));
+      CMPCHAR_HASH_SIZE (hashp) = 10;
+      CMPCHAR_HASH_USED (hashp) = 2;
+    }
+  else if (CMPCHAR_HASH_USED (hashp) >= CMPCHAR_HASH_SIZE (hashp))
+    {
+      CMPCHAR_HASH_SIZE (hashp) += 8;
+      hashp = (cmpchar_hash_table[hash_idx]
+               = (int *) xrealloc (hashp, 
+                                   sizeof (int) * CMPCHAR_HASH_SIZE (hashp)));
+    }
+  CMPCHAR_HASH_CMPCHAR_ID (hashp, CMPCHAR_HASH_USED (hashp)) = n_cmpchars;
+  CMPCHAR_HASH_USED (hashp)++;
+
+  /* Set information of the composite character in cmpchar_table.  */
+  if (cmpchar_table_size == 0)
+    {
+      /* This is the first composite character to be registered.  */
+      cmpchar_table_size = 256;
+      cmpchar_table
+        = (struct cmpchar_info **) xmalloc (sizeof (cmpchar_table[0])
+                                            * cmpchar_table_size);
+    }
+  else if (cmpchar_table_size <= n_cmpchars)
+    {
+      cmpchar_table_size += 256;
+      cmpchar_table
+        = (struct cmpchar_info **) xrealloc (cmpchar_table,
+                                             sizeof (cmpchar_table[0])
+                                             * cmpchar_table_size);
+    }
+
+  cmpcharp = (struct cmpchar_info *) xmalloc (sizeof (struct cmpchar_info));
+
+  cmpcharp->len = len;
+  cmpcharp->data = (unsigned char *) xmalloc (len + 1);
+  bcopy (str, cmpcharp->data, len);
+  cmpcharp->data[len] = 0;
+  cmpcharp->glyph_len = chars;
+  cmpcharp->glyph = (GLYPH *) xmalloc (sizeof (GLYPH) * chars);
+  if (embedded_rule)
+    {
+      cmpcharp->cmp_rule = (unsigned char *) xmalloc (chars);
+      cmpcharp->col_offset = (float *) xmalloc (sizeof (float) * chars);
+    }
+  else
+    {
+      cmpcharp->cmp_rule = NULL;
+      cmpcharp->col_offset = NULL;
+    }
+
+  /* Setup GLYPH data and composition rules (if any) so as not to make
+     them every time on displaying.  */
+  {
+    unsigned char *bufp;
+    int width;
+    float leftmost = 0.0, rightmost = 1.0;
+
+    if (embedded_rule)
+      /* At first, col_offset[N] is set to relative to col_offset[0].  */
+      cmpcharp->col_offset[0] = 0;
+
+    for (i = 0, bufp = cmpcharp->data + 1; i < chars; i++)
+      {
+        if (embedded_rule)
+          cmpcharp->cmp_rule[i] = *bufp++;
+
+        if (*bufp == 0xA0)      /* This is an ASCII character.  */
+          {
+            cmpcharp->glyph[i] = FAST_MAKE_GLYPH ((*++bufp & 0x7F), 0);
+            width = 1;
+            bufp++;
+          }
+        else                    /* Multibyte character.  */
+          {
+            /* Make `bufp' point normal multi-byte form temporally.  */
+            *bufp -= 0x20;
+            cmpcharp->glyph[i]
+              = FAST_MAKE_GLYPH (string_to_non_ascii_char (bufp, 4, 0), 0);
+            width = WIDTH_BY_CHAR_HEAD (*bufp);
+            *bufp += 0x20;
+            bufp += BYTES_BY_CHAR_HEAD (*bufp - 0x20);
+          }
+
+        if (embedded_rule && i > 0)
+          {
+            /* Reference points (global_ref and new_ref) are
+               encoded as below:
+               
+               0--1--2 -- ascent
+               |     |
+               |     |
+               |  4 -+--- center
+            -- 3     5 -- baseline
+               |     |
+               6--7--8 -- descent
+
+               Now, we calculate the column offset of the new glyph
+               from the left edge of the first glyph.  This can avoid
+               the same calculation everytime displaying this
+               composite character.  */
+
+            /* Reference points of global glyph and new glyph.  */
+            int global_ref = (cmpcharp->cmp_rule[i] - 0xA0) / 9;
+            int new_ref = (cmpcharp->cmp_rule[i] - 0xA0) % 9;
+            /* Column offset relative to the first glyph.  */
+            float left = (leftmost
+                          + (global_ref % 3) * (rightmost - leftmost) / 2.0
+                          - (new_ref % 3) * width / 2.0);
+
+            cmpcharp->col_offset[i] = left;
+            if (left < leftmost)
+              leftmost = left;
+            if (left + width > rightmost)
+              rightmost = left + width;
+          }
+        else
+          {
+            if (width > rightmost)
+              rightmost = width;
+          }
+      }
+    if (embedded_rule)
+      {
+        /* Now col_offset[N] are relative to the left edge of the
+           first component.  Make them relative to the left edge of
+           overall glyph.  */
+        for (i = 0; i < chars; i++)
+          cmpcharp->col_offset[i] -= leftmost;
+        /* Make rightmost holds width of overall glyph.  */
+        rightmost -= leftmost;
+      }
+
+    cmpcharp->width = rightmost;
+    if (cmpcharp->width < rightmost)
+      /* To get a ceiling integer value.  */
+      cmpcharp->width++;
+  }
+
+  cmpchar_table[n_cmpchars] = cmpcharp;
+
+  return n_cmpchars++;
+}
+
+/* Return the Nth element of the composite character C.  */
+int
+cmpchar_component (c, n)
+     unsigned int c, n;
+{
+  int id = COMPOSITE_CHAR_ID (c);
+
+  if (id >= n_cmpchars          /* C is not a valid composite character.  */
+      || n >= cmpchar_table[id]->glyph_len) /* No such component.  */
+    return -1;
+  /* No face data is stored in glyph code.  */
+  return ((int) (cmpchar_table[id]->glyph[n]));
+}
+
+DEFUN ("cmpcharp", Fcmpcharp, Scmpcharp, 1, 1, 0,
+  "T if CHAR is a composite character.")
+  (ch)
+     Lisp_Object ch;
+{
+  CHECK_NUMBER (ch, 0);
+  return (COMPOSITE_CHAR_P (XINT (ch)) ? Qt : Qnil);
+}
+
+DEFUN ("composite-char-component", Fcmpchar_component, Scmpchar_component,
+       2, 2, 0,
+  "Return the IDXth component character of composite character CHARACTER.")
+  (character, idx)
+     Lisp_Object character, idx;
+{
+  int c;
+
+  CHECK_NUMBER (character, 0);
+  CHECK_NUMBER (idx, 1);
+
+  if ((c = cmpchar_component (XINT (character), XINT (idx))) < 0)
+    args_out_of_range (character, idx);
+
+  return make_number (c);
+}
+
+DEFUN ("composite-char-composition-rule", Fcmpchar_cmp_rule, Scmpchar_cmp_rule,
+       2, 2, 0,
+  "Return the IDXth composition rule embedded in composite character CHARACTER.
+The returned rule is for composing the IDXth component
+on the (IDX-1)th component.  If IDX is 0, the returned value is always 255.")
+  (character, idx)
+     Lisp_Object character, idx;
+{
+  int id, i;
+
+  CHECK_NUMBER (character, 0);
+  CHECK_NUMBER (idx, 1);
+
+  id = COMPOSITE_CHAR_ID (XINT (character));
+  if (id < 0 || id >= n_cmpchars)
+    error ("Invalid composite character: %d", XINT (character));
+  i = XINT (idx);
+  if (i > cmpchar_table[id]->glyph_len)
+    args_out_of_range (character, idx);
+
+  return make_number (cmpchar_table[id]->cmp_rule[i]);
+}
+
+DEFUN ("composite-char-composition-rule-p", Fcmpchar_cmp_rule_p,
+       Scmpchar_cmp_rule_p, 1, 1, 0,
+  "Return non-nil if composite character CHARACTER contains a embedded rule.")
+  (character)
+     Lisp_Object character;
+{
+  int id;
+
+  CHECK_NUMBER (character, 0);
+  id = COMPOSITE_CHAR_ID (XINT (character));
+  if (id < 0 || id >= n_cmpchars)
+    error ("Invalid composite character: %d", XINT (character));
+
+  return (cmpchar_table[id]->cmp_rule ? Qt : Qnil);
+}
+
+DEFUN ("composite-char-component-count", Fcmpchar_cmp_count,
+       Scmpchar_cmp_count, 1, 1, 0,
+  "Return number of compoents of composite character CHARACTER.")
+  (character)
+     Lisp_Object character;
+{
+  int id;
+
+  CHECK_NUMBER (character, 0);
+  id = COMPOSITE_CHAR_ID (XINT (character));
+  if (id < 0 || id >= n_cmpchars)
+    error ("Invalid composite character: %d", XINT (character));
+
+  return (make_number (cmpchar_table[id]->glyph_len));
+}
+
+DEFUN ("compose-string", Fcompose_string, Scompose_string,
+       1, 1, 0,
+  "Return one char string composed from all characters in STRING.")
+  (str)
+     Lisp_Object str;
+{
+  unsigned char buf[MAX_LENGTH_OF_MULTI_BYTE_FORM], *p, *pend, *ptemp;
+  int len, i;
+
+  CHECK_STRING (str, 0);
+
+  buf[0] = LEADING_CODE_COMPOSITION;
+  p = XSTRING (str)->data;
+  pend = p + XSTRING (str)->size;
+  i = 1;
+  while (p < pend)
+    {
+      if (*p < 0x20 || *p == 127) /* control code */
+        error ("Invalid component character: %d", *p);
+      else if (*p < 0x80)       /* ASCII */
+        {
+          if (i + 2 >= MAX_LENGTH_OF_MULTI_BYTE_FORM)
+            error ("Too long string to be composed: %s", XSTRING (str)->data);
+          /* Prepend an ASCII charset indicator 0xA0, set MSB of the
+             code itself.  */
+          buf[i++] = 0xA0;
+          buf[i++] = *p++ + 0x80;
+        }
+      else if (*p == LEADING_CODE_COMPOSITION) /* composite char */
+        {
+          /* Already composed.  Eliminate the heading
+             LEADING_CODE_COMPOSITION, keep the remaining bytes
+             unchanged.  */
+          p++;
+          ptemp = p;
+          while (! CHAR_HEAD_P (p)) p++;
+          if (i + (p - ptemp) >= MAX_LENGTH_OF_MULTI_BYTE_FORM)
+            error ("Too long string to be composed: %s", XSTRING (str)->data);
+          bcopy (ptemp, buf + i, p - ptemp);
+          i += p - ptemp;
+        }
+      else                      /* multibyte char */
+        {
+          /* Add 0x20 to the base leading-code, keep the remaining
+             bytes unchanged.  */
+          len = BYTES_BY_CHAR_HEAD (*p);
+          if (i + len >= MAX_LENGTH_OF_MULTI_BYTE_FORM)
+            error ("Too long string to be composed: %s", XSTRING (str)->data);
+          bcopy (p, buf + i, len);
+          buf[i] += 0x20;
+          p += len, i += len;
+        }
+    }
+
+  if (i < 5)
+    /* STR contains only one character, which can't be composed.  */
+    error ("Too short string to be composed: %s", XSTRING (str)->data);
+
+  return make_string (buf, i);
+}
+
+
+charset_id_internal (charset_name)
+     char *charset_name;
+{
+  Lisp_Object val = Fget (intern (charset_name), Qcharset);
+
+  if (!VECTORP (val))
+    error ("Charset %s is not defined", charset_name);
+
+  return (XINT (XVECTOR (val)->contents[0]));
+}
+
+DEFUN ("setup-special-charsets", Fsetup_special_charsets,
+       Ssetup_special_charsets, 0, 0, 0, "Internal use only.")
+   ()
+{
+  charset_latin_iso8859_1 = charset_id_internal ("latin-iso8859-1");
+  charset_jisx0208_1978 = charset_id_internal ("japanese-jisx0208-1978");
+  charset_jisx0208 = charset_id_internal ("japanese-jisx0208");
+  charset_katakana_jisx0201 = charset_id_internal ("katakana-jisx0201");
+  charset_latin_jisx0201 = charset_id_internal ("latin-jisx0201");
+  charset_big5_1 = charset_id_internal ("chinese-big5-1");
+  charset_big5_2 = charset_id_internal ("chinese-big5-2");
+  return Qnil;
+}
+
+init_charset_once ()
+{
+  int i, j, k;
+
+  staticpro (&Vcharset_table);
+  staticpro (&Vcharset_symbol_table);
+
+  /* This has to be done here, before we call Fmake_char_table.  */
+  Qcharset_table = intern ("charset-table");
+  staticpro (&Qcharset_table);
+
+  /* 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");
+
+  /* Now we are ready to set up this property, so we can
+     create the charset table.  */
+  Fput (Qcharset_table, Qchar_table_extra_slots, make_number (0));
+  Vcharset_table = Fmake_char_table (Qcharset_table, Qnil);
+
+  Vcharset_symbol_table = Fmake_vector (make_number (MAX_CHARSET), Qnil);
+
+  /* Setup tables.  */
+  for (i = 0; i < 2; i++)
+    for (j = 0; j < 2; j++)
+      for (k = 0; k < 128; k++)
+        iso_charset_table [i][j][k] = -1;
+
+  bzero (cmpchar_hash_table, sizeof cmpchar_hash_table);
+  cmpchar_table_size = n_cmpchars = 0;
+
+  for (i = 0; i < 256; i++)
+    BYTES_BY_CHAR_HEAD (i) = 1;
+  BYTES_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_11) = 3;
+  BYTES_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_12) = 3;
+  BYTES_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_21) = 4;
+  BYTES_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_22) = 4;
+  /* The following doesn't reflect the actual bytes, but just to tell
+     that it is a start of a multibyte character.  */
+  BYTES_BY_CHAR_HEAD (LEADING_CODE_COMPOSITION) = 2;
+
+  for (i = 0; i < 128; i++)
+    WIDTH_BY_CHAR_HEAD (i) = 1;
+  for (; i < 256; i++)
+    WIDTH_BY_CHAR_HEAD (i) = 4;
+  WIDTH_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_11) = 1;
+  WIDTH_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_12) = 2;
+  WIDTH_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_21) = 1;
+  WIDTH_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_22) = 2;
+}
+
+#ifdef emacs
+
+syms_of_charset ()
+{
+  Qascii = intern ("ascii");
+  staticpro (&Qascii);
+
+  Qcharset = intern ("charset");
+  staticpro (&Qcharset);
+
+  /* Define ASCII charset now.  */
+  update_charset_table (make_number (CHARSET_ASCII),
+                        make_number (1), make_number (94),
+                        make_number (1),
+                        make_number (0),
+                        make_number ('B'),
+                        make_number (0),
+                        build_string ("ASCII"),
+                        build_string ("ASCII"),
+                        build_string ("ASCII (ISO646 IRV)"));
+  CHARSET_SYMBOL (CHARSET_ASCII) = Qascii;
+  Fput (Qascii, Qcharset, CHARSET_TABLE_ENTRY (CHARSET_ASCII));
+
+  Qcomposition = intern ("composition");
+  staticpro (&Qcomposition);
+  CHARSET_SYMBOL (CHARSET_COMPOSITION) = Qcomposition;
+
+  defsubr (&Sdefine_charset);
+  defsubr (&Sdeclare_equiv_charset);
+  defsubr (&Sfind_charset_region);
+  defsubr (&Sfind_charset_string);
+  defsubr (&Smake_char_internal);
+  defsubr (&Ssplit_char);
+  defsubr (&Schar_charset);
+  defsubr (&Siso_charset);
+  defsubr (&Schar_bytes);
+  defsubr (&Schar_width);
+  defsubr (&Sstring_width);
+  defsubr (&Schar_direction);
+  defsubr (&Schars_in_string);
+  defsubr (&Schar_boundary_p);
+  defsubr (&Sconcat_chars);
+  defsubr (&Scmpcharp);
+  defsubr (&Scmpchar_component);
+  defsubr (&Scmpchar_cmp_rule);
+  defsubr (&Scmpchar_cmp_rule_p);
+  defsubr (&Scmpchar_cmp_count);
+  defsubr (&Scompose_string);
+  defsubr (&Ssetup_special_charsets);
+
+  DEFVAR_LISP ("charset-list", &Vcharset_list,
+    "List of charsets ever defined.");
+  Vcharset_list = Fcons (Qascii, Qnil);
+
+  DEFVAR_INT ("leading-code-composition", &leading_code_composition,
+    "Leading-code of composite characters.");
+  leading_code_composition = LEADING_CODE_COMPOSITION;
+
+  DEFVAR_INT ("leading-code-private-11", &leading_code_private_11,
+    "Leading-code of private TYPE9N charset of column-width 1.");
+  leading_code_private_11 = LEADING_CODE_PRIVATE_11;
+
+  DEFVAR_INT ("leading-code-private-12", &leading_code_private_12,
+    "Leading-code of private TYPE9N charset of column-width 2.");
+  leading_code_private_12 = LEADING_CODE_PRIVATE_12;
+
+  DEFVAR_INT ("leading-code-private-21", &leading_code_private_21,
+    "Leading-code of private TYPE9Nx9N charset of column-width 1.");
+  leading_code_private_21 = LEADING_CODE_PRIVATE_21;
+
+  DEFVAR_INT ("leading-code-private-22", &leading_code_private_22,
+    "Leading-code of private TYPE9Nx9N charset of column-width 2.");
+  leading_code_private_22 = LEADING_CODE_PRIVATE_22;
+}
+
+#endif /* emacs */
diff --git a/src/charset.h b/src/charset.h
new file mode 100644
index 00000000000..677a5755adf
--- /dev/null
+++ b/src/charset.h
@@ -0,0 +1,649 @@
+/* Header for multilingual character handler.
+   Ver.1.0
+
+   Copyright (C) 1995 Free Software Foundation, Inc.
+   Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#ifndef _CHARSET_H
+#define _CHARSET_H
+
+/*** GENERAL NOTE on CHARACTER SET (CHARSET) ***
+
+  A character set ("charset" hereafter) is a meaningful collection
+  (i.e. language, culture, functionality, etc) of characters.  Emacs
+  handles multiple charsets at once.  Each charset corresponds to one
+  of ISO charsets (except for a special charset for composition
+  characters).  Emacs identifies a charset by a unique identification
+  number, whereas ISO identifies a charset by a triplet of DIMENSION,
+  CHARS and FINAL-CHAR.  So, hereafter, just saying "charset" means an
+  identification number (integer value).
+
+  The value range of charset is 0x00, 0x80..0xFE.  There are four
+  kinds of charset depending on DIMENSION (1 or 2) and CHARS (94 or
+  96).  For instance, a charset of DIMENSION2_CHARS94 contains 94x94
+
+
+  Within Emacs Lisp, a charset is treated as a symbol which has a
+  property `charset'.  The property value is a vector containing
+  various information about the charset.  For readability of C codes,
+  we use the following convention on C variable names:
+        charset_symbol: Emacs Lisp symbol of a charset
+        charset_id: Emacs Lisp integer of an identification number of a charset
+        charset: C integer of an identification number of a charset
+
+  Each charset (except for ASCII) is assigned a base leading-code
+  (range 0x80..0x9D).  In addition, a charset of greater than 0xA0
+  (whose base leading-code is 0x9A..0x9D) is assigned an extended
+  leading-code (range 0xA0..0xFE).  In this case, each base
+  leading-code specify the allowable range of extended leading-code as
+  shown in the table below.  A leading-code is used to represent a
+  character in Emacs' buffer and string.
+
+  We call a charset which has extended leading-code as "private
+  charset" because those are mainly for a charset which is not
+  registered by ISO.  On the contrary, we call a charset which does
+  not have extended leading-code as "official charset".
+
+  ---------------------------------------------------------------------------
+  charset       dimension        base leading-code      extended leading-code
+  ---------------------------------------------------------------------------
+  0x00          official dim1    -- none --             -- none --
+                (ASCII)
+  0x01..0x7F    --never used--
+  0x80          COMPOSITION      same as charset        -- none --
+  0x81..0x8F    official dim1    same as charset        -- none --
+  0x90..0x99    official dim2    same as charset        -- none --
+  0x9A..0x9F    --never used--
+  0xA0..0xDF    private dim1        0x9A                same as charset
+                of 1-column width
+  0xE0..0xEF    private dim1        0x9B                same as charset
+                of 2-column width
+  0xF0..0xF4    private dim2        0x9C                same as charset
+                of 1-column width
+  0xF5..0xFE    private dim2        0x9D                same as charset
+                of 2-column width
+  0xFF          --never used--
+  ---------------------------------------------------------------------------
+
+  In the table, "COMPOSITION" means a charset for a composite
+  character which is a character composed from several (up to 16)
+  non-composite characters (components).  Although a composite
+  character can contain components of many charsets, a composite
+  character itself belongs to the charset CHARSET-COMPOSITION.  See
+  the document "GENERAL NOTE on COMPOSITE CHARACTER" below for more
+  detail.
+
+*/
+
+/* Definition of special leading-codes.  */
+/* Base leading-code.  */
+/* Special leading-code followed by components of a composite character.  */
+#define LEADING_CODE_COMPOSITION        0x80
+/* Leading-code followed by extended leading-code.  */
+#define LEADING_CODE_PRIVATE_11 0x9A /* for private DIMENSION1 of 1-column */
+#define LEADING_CODE_PRIVATE_12 0x9B /* for private DIMENSION1 of 2-column */
+#define LEADING_CODE_PRIVATE_21 0x9C /* for private DIMENSION2 of 1-column */
+#define LEADING_CODE_PRIVATE_22 0x9D /* for private DIMENSION2o f 2-column */
+
+/* Extended leading-code.  */
+/* Start of each extended leading-codes.  */
+#define LEADING_CODE_EXT_11 0xA0 /* follows LEADING_CODE_PRIVATE_11 */
+#define LEADING_CODE_EXT_12 0xE0 /* follows LEADING_CODE_PRIVATE_12 */
+#define LEADING_CODE_EXT_21 0xF0 /* follows LEADING_CODE_PRIVATE_21 */
+#define LEADING_CODE_EXT_22 0xF5 /* follows LEADING_CODE_PRIVATE_22 */
+/* Maximum value of extended leading-codes.  */
+#define LEADING_CODE_EXT_MAX 0xFE
+
+/* Definition of minimum/maximum charset of each DIMENSION.  */
+#define MIN_CHARSET_OFFICIAL_DIMENSION1 0x81
+#define MAX_CHARSET_OFFICIAL_DIMENSION1 0x8F
+#define MIN_CHARSET_OFFICIAL_DIMENSION2 0x90
+#define MAX_CHARSET_OFFICIAL_DIMENSION2 0x99
+#define MIN_CHARSET_PRIVATE_DIMENSION1  LEADING_CODE_EXT_11
+#define MIN_CHARSET_PRIVATE_DIMENSION2  LEADING_CODE_EXT_21
+
+/* Definition of special charsets.  */
+#define CHARSET_ASCII           0
+#define CHARSET_COMPOSITION     0x80
+
+extern int charset_ascii;       /* ASCII */
+extern int charset_composition; /* for a composite character */
+extern int charset_latin_iso8859_1; /* ISO8859-1 (Latin-1) */
+extern int charset_jisx0208_1978; /* JISX0208.1978 (Japanese Kanji old set) */
+extern int charset_jisx0208;    /* JISX0208.1983 (Japanese Kanji) */
+extern int charset_katakana_jisx0201; /* JISX0201.Kana (Japanese Katakana) */
+extern int charset_latin_jisx0201; /* JISX0201.Roman (Japanese Roman) */
+extern int charset_big5_1;      /* Big5 Level 1 (Chinese Traditional) */
+extern int charset_big5_2;      /* Big5 Level 2 (Chinese Traditional) */
+
+/* Check if STR points the head of multi-byte form, i.e. *STR is an
+   ASCII character or a base leading-code.  */
+#define CHAR_HEAD_P(str) ((unsigned char) *(str) < 0xA0)
+
+/*** GENERAL NOTE on CHARACTER REPRESENTATION ***
+
+  At first, the term "character" or "char" is used for a multilingual
+  character (of course, including ASCII character), not for a byte in
+  computer memory.  We use the term "code" or "byte" for the latter
+  case.
+
+  A character is identified by charset and one or two POSITION-CODEs.
+  POSITION-CODE is the position of the character in the charset.  A
+  character of DIMENSION1 charset has one POSITION-CODE: POSITION-CODE-1.
+  A character of DIMENSION2 charset has two POSITION-CODE:
+  POSITION-CODE-1 and POSITION-CODE-2.  The code range of
+  POSITION-CODE is 0x20..0x7F.
+
+  Emacs has two kinds of representation of a character: multi-byte
+  form (for buffer and string) and single-word form (for character
+  object in Emacs Lisp).  The latter is called "character code" here
+  after.  Both representation encode the information of charset and
+  POSITION-CODE but in a different way (for instance, MSB of
+  POSITION-CODE is set in multi-byte form).
+
+  For details of multi-byte form, see the section "2. Emacs internal
+  format handlers" of `coding.c'.
+
+  Emacs uses 19 bits for a character code.  The bits are divided into
+  3 fields: FIELD1(5bits):FIELD2(7bits):FIELD3(7bits).
+
+  A character code of DIMENSION1 character uses FIELD2 to hold charset
+  and FIELD3 to hold POSITION-CODE-1.  A character code of DIMENSION2
+  character uses FIELD1 to hold charset, FIELD2 and FIELD3 to hold
+  POSITION-CODE-1 and POSITION-CODE-2 respectively.
+
+  More precisely...
+
+  FIELD2 of DIMENSION1 character (except for ASCII) is "charset - 0x70".
+  This is to make all character codes except for ASCII greater than
+  256 (ASCII's FIELD2 is 0).  So, the range of FIELD2 of DIMENSION1
+  character is 0 or 0x11..0x7F.
+
+  FIELD1 of DIMENSION2 character is "charset - 0x8F" for official
+  charset and "charset - 0xE0" for private charset.  So, the range of
+  FIELD1 of DIMENSION2 character is 0x01..0x1E.
+
+  -----------------------------------------------------------------------
+  charset       FIELD1 (5-bit)      FIELD2 (7-bit)      FIELD3 (7-bit)
+  -----------------------------------------------------------------------
+  ASCII         0                   0                   POSITION-CODE-1
+  DIMENSION1    0                   charset - 0x70      POSITION-CODE-1
+  DIMENSION2(o) charset - 0x8F      POSITION-CODE-1     POSITION-CODE-2
+  DIMENSION2(p) charset - 0xE0      POSITION-CODE-1     POSITION-CODE-2
+  -----------------------------------------------------------------------
+  "(o)": official, "(p)": private
+  -----------------------------------------------------------------------
+
+*/
+
+/*** GENERAL NOTE on COMPOSITE CHARACTER ***
+
+  A composite character is a character composed from several (up to
+  16) non-composite characters (components).  Although each components
+  can belong to any charset, a composite character itself belongs to
+  the charset `charset-composition' and is assigned a special
+  leading-code `LEADING_CODE_COMPOSITION' for multi-byte form.  See
+  the document "2. Emacs internal format handlers" in `coding.c' for
+  more detail about multi-byte form.
+
+  A character code of composite character has special format.  In the
+  above document, FIELD1 of a composite character is 0x1F.  Each
+  composite character is assigned a sequential number CMPCHAR-ID.
+  FIELD2 and FIELD3 are combined to make 14bits field for holding
+  CMPCHAR-ID, which means that Emacs can handle at most 2^14 (= 16384)
+  composite characters at once.
+
+  -----------------------------------------------------------------------
+  charset               FIELD1 (5-bit)      FIELD2&3 (14-bit)
+  -----------------------------------------------------------------------
+  CHARSET-COMPOSITION   0x1F                CMPCHAR-ID
+  -----------------------------------------------------------------------  
+
+  Emacs assigns CMPCHAR-ID to a composite character only when it
+  requires the character code of the composite character (e.g. while
+  displaying the composite character).
+
+*/
+
+/* Masks of each field of character code.  */
+#define CHAR_FIELD1_MASK (0x1F << 14)
+#define CHAR_FIELD2_MASK (0x7F << 7)
+#define CHAR_FIELD3_MASK 0x7F
+
+/* Macros to access each field of character C.  */
+#define CHAR_FIELD1(c) (((c) & CHAR_FIELD1_MASK) >> 14)
+#define CHAR_FIELD2(c) (((c) & CHAR_FIELD2_MASK) >> 7)
+#define CHAR_FIELD3(c) ((c) & CHAR_FIELD3_MASK)
+
+/* Minimum character code of character of each DIMENSION.  */
+#define MIN_CHAR_OFFICIAL_DIMENSION1 \
+  ((MIN_CHARSET_OFFICIAL_DIMENSION1 - 0x70) << 7)
+#define MIN_CHAR_PRIVATE_DIMENSION1 \
+  ((MIN_CHARSET_PRIVATE_DIMENSION1 - 0x70) << 7)
+#define MIN_CHAR_OFFICIAL_DIMENSION2 \
+  ((MIN_CHARSET_OFFICIAL_DIMENSION2 - 0x8F) << 14)
+#define MIN_CHAR_PRIVATE_DIMENSION2 \
+  ((MIN_CHARSET_PRIVATE_DIMENSION2 - 0xE0) << 14)
+#define MIN_CHAR_COMPOSITION \
+  (0x1F << 14)
+
+/* 1 if C is an ASCII character, else 0.  */
+#define SINGLE_BYTE_CHAR_P(c) ((c) < 0x100)
+/* 1 if C is an composite character, else 0.  */
+#define COMPOSITE_CHAR_P(c) ((c) >= MIN_CHAR_COMPOSITION)
+
+/* A char-table containing information of each character set.
+
+   Unlike ordinary char-tables, this doesn't contain any nested table.
+   Only the top level elements are used.  Each element is a vector of
+   the following information:
+        CHARSET-ID, BYTES, DIMENSION, CHARS, WIDTH, DIRECTION,
+        LEADING-CODE-BASE, LEADING-CODE-EXT,
+        ISO-FINAL-CHAR, ISO-GRAPHIC-PLANE,
+        REVERSE-CHARSET, SHORT-NAME, LONG-NAME, DESCRIPTION,
+        PLIST.
+
+   CHARSET-ID (integer) is the identification number of the charset.
+
+   BYTE (integer) is the length of multi-byte form of a character in
+   the charset: one of 1, 2, 3, and 4.
+
+   DIMENSION (integer) is the number of bytes to represent a character: 1 or 2.
+
+   CHARS (integer) is the number of characters in a dimension: 94 or 96.
+
+   WIDTH (integer) is the number of columns a character in the charset
+   occupies on the screen: one of 0, 1, and 2.
+
+   DIRECTION (integer) is the rendering direction of characters in the
+   charset when rendering.  If 0, render from right to left, else
+   render from left to right.
+
+   LEADING-CODE-BASE (integer) is the base leading-code for the
+   charset.
+
+   LEADING-CODE-EXT (integer) is the extended leading-code for the
+   charset.  All charsets of less than 0xA0 has the value 0.
+
+   ISO-FINAL-CHAR (character) is the final character of the
+   corresponding ISO 2022 charset.
+
+   ISO-GRAPHIC-PLANE (integer) is the graphic plane to be invoked
+   while encoding to variants of ISO 2022 coding system, one of the
+   following: 0/graphic-plane-left(GL), 1/graphic-plane-right(GR).
+
+   REVERSE-CHARSET (integer) is the charset which differs only in
+   LEFT-TO-RIGHT value from the charset.  If there's no such a
+   charset, the value is -1.
+   
+   SHORT-NAME (string) is the short name to refer to the charset.
+
+   LONG-NAME (string) is the long name to refer to the charset.
+
+   DESCRIPTION (string) is the description string of the charset.
+
+   PLIST (property list) may contain any type of information a user
+   want to put and get by functions `put-charset-property' and
+   `get-charset-property' respectively.  */
+extern Lisp_Object Vcharset_table;
+
+/* Macros to access various information of CHARSET in Vcharset_table.
+   We provide these macros for efficiency.  No range check of CHARSET.  */
+
+/* Return entry of CHARSET (lisp integer) in Vcharset_table.  */
+#define CHARSET_TABLE_ENTRY(charset) \
+  XCHAR_TABLE (Vcharset_table)->contents[charset]
+
+/* Return information INFO-IDX of CHARSET.  */
+#define CHARSET_TABLE_INFO(charset, info_idx) \
+  XVECTOR (CHARSET_TABLE_ENTRY (charset))->contents[info_idx]
+
+#define CHARSET_ID_IDX (0)
+#define CHARSET_BYTES_IDX (1)
+#define CHARSET_DIMENSION_IDX (2)
+#define CHARSET_CHARS_IDX (3)
+#define CHARSET_WIDTH_IDX (4)
+#define CHARSET_DIRECTION_IDX (5)
+#define CHARSET_LEADING_CODE_BASE_IDX (6)
+#define CHARSET_LEADING_CODE_EXT_IDX (7)
+#define CHARSET_ISO_FINAL_CHAR_IDX (8)
+#define CHARSET_ISO_GRAPHIC_PLANE_IDX (9)
+#define CHARSET_REVERSE_CHARSET_IDX (10)
+#define CHARSET_SHORT_NAME_IDX (11)
+#define CHARSET_LONG_NAME_IDX (12)
+#define CHARSET_DESCRIPTION_IDX (13)
+#define CHARSET_PLIST_IDX (14)
+/* Size of a vector of each entry of Vcharset_table.  */
+#define CHARSET_MAX_IDX (15)
+
+/* And several more macros to be used frequently.  */
+#define CHARSET_BYTES(charset) \
+  XFASTINT (CHARSET_TABLE_INFO (charset, CHARSET_BYTES_IDX))
+#define CHARSET_DIMENSION(charset) \
+  XFASTINT (CHARSET_TABLE_INFO (charset, CHARSET_DIMENSION_IDX))
+#define CHARSET_CHARS(charset) \
+  XFASTINT (CHARSET_TABLE_INFO (charset, CHARSET_CHARS_IDX))
+#define CHARSET_WIDTH(charset) \
+  XFASTINT (CHARSET_TABLE_INFO (charset, CHARSET_WIDTH_IDX))
+#define CHARSET_DIRECTION(charset) \
+  XFASTINT (CHARSET_TABLE_INFO (charset, CHARSET_DIRECTION_IDX))
+#define CHARSET_LEADING_CODE_BASE(charset) \
+  XFASTINT (CHARSET_TABLE_INFO (charset, CHARSET_LEADING_CODE_BASE_IDX))
+#define CHARSET_LEADING_CODE_EXT(charset) \
+  XFASTINT (CHARSET_TABLE_INFO (charset, CHARSET_LEADING_CODE_EXT_IDX))
+#define CHARSET_ISO_FINAL_CHAR(charset) \
+  XFASTINT (CHARSET_TABLE_INFO (charset, CHARSET_ISO_FINAL_CHAR_IDX))
+#define CHARSET_ISO_GRAPHIC_PLANE(charset) \
+  XFASTINT (CHARSET_TABLE_INFO (charset, CHARSET_ISO_GRAPHIC_PLANE_IDX))
+#define CHARSET_REVERSE_CHARSET(charset) \
+  XINT (CHARSET_TABLE_INFO (charset, CHARSET_REVERSE_CHARSET_IDX))
+
+/* Macros to specify direction of a charset.  */
+#define CHARSET_DIRECTION_LEFT_TO_RIGHT 0
+#define CHARSET_DIRECTION_RIGHT_TO_LEFT 1
+
+/* A vector of charset symbol indexed by charset-id.  This is used
+   only for returning charset symbol from C functions.  */
+extern Lisp_Object Vcharset_symbol_table;
+
+/* Return symbol of CHARSET.  */
+#define CHARSET_SYMBOL(charset) \
+  XVECTOR (Vcharset_symbol_table)->contents[charset]
+
+/* 1 if CHARSET is valid, else 0.  */
+#define CHARSET_VALID_P(charset)                                         \
+  ((charset) == 0                                                        \
+   || ((charset) >= 0x80 && (charset) <= MAX_CHARSET_OFFICIAL_DIMENSION2) \
+   || ((charset) >= MIN_CHARSET_PRIVATE_DIMENSION1 && (charset) < MAX_CHARSET))
+
+/* 1 if CHARSET is already defined, else 0.  */
+#define CHARSET_DEFINED_P(charset)                      \
+  (((charset) >= 0) && ((charset) < MAX_CHARSET)        \
+   && !NILP (CHARSET_TABLE_ENTRY (charset)))
+
+/* Since the information CHARSET-BYTES and CHARSET-WIDTH of
+   Vcharset_table can be retrieved only from the first byte of
+   multi-byte form (an ASCII code or a base leading-code), we provide
+   here tables to be used by macros BYTES_BY_CHAR_HEAD and
+   WIDTH_BY_CHAR_HEAD for faster information retrieval.  */
+extern int bytes_by_char_head[256];
+extern int width_by_char_head[256];
+
+#define BYTES_BY_CHAR_HEAD(char_head) bytes_by_char_head[char_head]
+#define WIDTH_BY_CHAR_HEAD(char_head) width_by_char_head[char_head]
+
+/* Charset of the character C.  */
+#define CHAR_CHARSET(c)                         \
+  (SINGLE_BYTE_CHAR_P (c)                       \
+   ? CHARSET_ASCII                              \
+   : ((c) < MIN_CHAR_OFFICIAL_DIMENSION2        \
+      ? CHAR_FIELD2 (c) + 0x70                  \
+      : ((c) < MIN_CHAR_PRIVATE_DIMENSION2      \
+         ? CHAR_FIELD1 (c) + 0x8F               \
+         : ((c) < MIN_CHAR_COMPOSITION          \
+            ? CHAR_FIELD1 (c) + 0xE0            \
+            : CHARSET_COMPOSITION))))
+
+/* Return charset at the place pointed by P.  */
+#define CHARSET_AT(p)                           \
+  (*(p) < 0x80                                  \
+   ? CHARSET_ASCII                              \
+   : (*(p) == LEADING_CODE_COMPOSITION          \
+      ? CHARSET_COMPOSITION                     \
+      : (*(p) < LEADING_CODE_PRIVATE_11         \
+         ? (int)*(p)                            \
+         : (*(p) <= LEADING_CODE_PRIVATE_22     \
+            ? (int)*((p) + 1)                   \
+            : -1))))
+
+/* Same as `CHARSET_AT ()' but perhaps runs faster because of an
+   additional argument C which is the code (byte) at P.  */
+#define FIRST_CHARSET_AT(p, c)                  \
+  ((c) < 0x80                                   \
+   ? CHARSET_ASCII                              \
+   : ((c) == LEADING_CODE_COMPOSITION           \
+      ? CHARSET_COMPOSITION                     \
+      : ((c) < LEADING_CODE_PRIVATE_11          \
+         ? (int)(c)                             \
+         : ((c) <= LEADING_CODE_PRIVATE_22      \
+            ? (int)*((p) + 1)                   \
+            : -1))))
+
+/* Check if two characters C1 and C2 belong to the same charset.
+   Always return 0 for composite characters.  */
+#define SAME_CHARSET_P(c1, c2)                                  \
+  (c1 < MIN_CHAR_COMPOSITION                                    \
+   && (SINGLE_BYTE_CHAR_P (c1)                                  \
+       ? SINGLE_BYTE_CHAR_P (c2)                                \
+       : (c1 < MIN_CHAR_OFFICIAL_DIMENSION2                     \
+          ? (c1 & CHAR_FIELD2_MASK) == (c2 & CHAR_FIELD2_MASK)  \
+          : (c1 & CHAR_FIELD1_MASK) == (c2 & CHAR_FIELD1_MASK))))
+
+/* Return a non-ASCII character of which charset is CHARSET and
+   position-codes are C1 and C2.  DIMENSION1 character ignores C2.  */
+#define MAKE_NON_ASCII_CHAR(charset, c1, c2)                    \
+  ((charset) == CHARSET_COMPOSITION                             \
+   ? MAKE_COMPOSITE_CHAR (((c1) << 7) + (c2))                   \
+   : (CHARSET_DIMENSION (charset) == 1                          \
+      ? (((charset) - 0x70) << 7) | (c1)                        \
+      : ((charset) < MIN_CHARSET_PRIVATE_DIMENSION2             \
+         ? (((charset) - 0x8F) << 14) | ((c1) << 7) | (c2)      \
+         : (((charset) - 0xE0) << 14) | ((c1) << 7) | (c2))))
+
+/* Return a composite character of which CMPCHAR-ID is ID.  */
+#define MAKE_COMPOSITE_CHAR(id) (MIN_CHAR_COMPOSITION + (id))
+
+/* Return CMPCHAR-ID of a composite character C.  */
+#define COMPOSITE_CHAR_ID(c) ((c) - MIN_CHAR_COMPOSITION)
+
+/* Return a character of which charset is CHARSET and position-codes
+   are C1 and C2.  DIMENSION1 character ignores C2.  */
+#define MAKE_CHAR(charset, c1, c2)                      \
+  ((charset) == CHARSET_ASCII                           \
+   ? (c1)                                               \
+   : MAKE_NON_ASCII_CHAR ((charset), (c1) & 0x7F, (c2) & 0x7F))
+
+/* The charset of non-ASCII character C is set to CHARSET, and the
+   position-codes of C are set to C1 and C2.  C2 of DIMENSION1 character
+   is 0.  */
+#define SPLIT_NON_ASCII_CHAR(c, charset, c1, c2)                         \
+  ((c) < MIN_CHAR_OFFICIAL_DIMENSION2                                    \
+   ? (charset = CHAR_FIELD2 (c) + 0x70,                                  \
+      c1 = CHAR_FIELD3 (c),                                              \
+      c2 = 0)                                                            \
+   : (charset = ((c) < MIN_CHAR_COMPOSITION                              \
+                 ? (CHAR_FIELD1 (c)                                      \
+                    + ((c) < MIN_CHAR_PRIVATE_DIMENSION2 ? 0x8F : 0xE0)) \
+                 : CHARSET_COMPOSITION),                                 \
+      c1 = CHAR_FIELD2 (c),                                              \
+      c2 = CHAR_FIELD3 (c)))
+
+/* The charset of character C is set to CHARSET, and the
+   position-codes of C are set to C1 and C2.  C2 of DIMENSION1 character
+   is 0.  */
+#define SPLIT_CHAR(c, charset, c1, c2)                  \
+  (SINGLE_BYTE_CHAR_P (c)                               \
+   ? charset = CHARSET_ASCII, c1 = (c), c2 = 0          \
+   : SPLIT_NON_ASCII_CHAR (c, charset, c1, c2))
+
+/* The charset of the character at STR is set to CHARSET, and the
+   position-codes are set to C1 and C2.  C2 of DIMENSION1 character is 0.
+   If the character is a composite character, the upper 7-bit and
+   lower 7-bit of CMPCHAR-ID are set in C1 and C2 respectively.  No
+   range checking.  */
+#define SPLIT_STRING(str, len, charset, c1, c2)                         \
+  ((BYTES_BY_CHAR_HEAD ((unsigned char) *(str)) < 2                     \
+    || BYTES_BY_CHAR_HEAD ((unsigned char) *(str)) > len                \
+    || split_non_ascii_string (str, len, &charset, &c1, &c2, 0) < 0)    \
+   ? c1 = *(str), charset = CHARSET_ASCII                               \
+   : charset)
+
+#define MAX_CHARSET 0xFF
+
+/* Mapping table from ISO2022's charset (specified by DIMENSION,
+   CHARS, and FINAL_CHAR) to Emacs' charset.  Should be accessed by
+   macro ISO_CHARSET_TABLE (DIMENSION, CHARS, FINAL_CHAR).  */
+extern int iso_charset_table[2][2][128];
+
+#define ISO_CHARSET_TABLE(dimension, chars, final_char) \
+  iso_charset_table[XINT (dimension) - 1][XINT (chars) > 94][XINT (final_char)]
+
+#define BASE_LEADING_CODE_P(c) (BYTES_BY_CHAR_HEAD ((unsigned char) (c)) > 1)
+
+/* The following two macros CHAR_STRING and STRING_CHAR are the main
+   entry points to convert between Emacs two types of character
+   representations: multi-byte form and single-word form (character
+   code).  */
+
+/* Set STR a pointer to the multi-byte form of the character C.  If C
+   is not a composite character, the multi-byte form is set in WORKBUF
+   and STR points WORKBUF.  The caller should allocate at least 4-byte
+   area at WORKBUF in advance.  Returns the length of the multi-byte
+   form.  */
+
+#define CHAR_STRING(c, workbuf, str)                    \
+  (SINGLE_BYTE_CHAR_P (c)                               \
+   ? *(str = workbuf) = (unsigned char)(c), 1           \
+   : non_ascii_char_to_string (c, workbuf, &str))
+
+/* Return a character code of the character of which multi-byte form
+   is at STR and the length is LEN.  If STR doesn't contain valid
+   multi-byte form, only the first byte in STR is returned.  */
+
+#define STRING_CHAR(str, len)                                   \
+  ((BYTES_BY_CHAR_HEAD ((unsigned char) *(str)) == 1            \
+    || BYTES_BY_CHAR_HEAD ((unsigned char) *(str)) > (len))     \
+   ? (unsigned char) *(str)                                     \
+   : string_to_non_ascii_char (str, len, 0))
+
+/* This is like STRING_CHAR but the third arg ACTUAL_LEN is set to
+   the length of the multi-byte form.  Just to know the length, use
+   MULTIBYTE_FORM_LENGTH.  */
+
+#define STRING_CHAR_AND_LENGTH(str, len, actual_len)            \
+  ((BYTES_BY_CHAR_HEAD ((unsigned char) *(str)) == 1            \
+    || BYTES_BY_CHAR_HEAD ((unsigned char) *(str)) > (len))     \
+   ? (actual_len = 1), (unsigned char) *(str)                   \
+   : string_to_non_ascii_char (str, len, &actual_len))
+
+/* Return the length of the multi-byte form at string STR of length LEN.  */
+
+#define MULTIBYTE_FORM_LENGTH(str, len)                         \
+  ((BYTES_BY_CHAR_HEAD (*(unsigned char *)(str)) == 1           \
+    || BYTES_BY_CHAR_HEAD (*(unsigned char *)(str)) > (len))    \
+   ? 1                                                          \
+   : multibyte_form_length (str, len))
+
+/* Set C a (possibly multibyte) character at P.  P points into a
+   string which is the virtual concatenation of STR1 (which ends at
+   END1) or STR2 (which ends at END2).  */
+
+#define GET_CHAR_AFTER_2(c, p, str1, end1, str2, end2)                      \
+  do {                                                                      \
+    const char *dtemp = (p) == (end1) ? (str2) : (p);                       \
+    const char *dlimit = ((p) >= (str1) && (p) < (end1)) ? (end1) : (end2); \
+    c = STRING_CHAR (dtemp, dlimit - dtemp);                                \
+  } while (0)
+
+/* Set C a (possibly multibyte) character before P.  P points into a
+   string which is the virtual concatenation of STR1 (which ends at
+   END1) or STR2 (which ends at END2).  */
+
+#define GET_CHAR_BEFORE_2(c, p, str1, end1, str2, end2)                     \
+  do {                                                                      \
+    const char *dtemp = (p);                                                \
+    const char *dlimit = ((p) > (str2) && (p) <= (end2)) ? (str2) : (str1); \
+    while (dtemp-- > dlimit && (unsigned char) *dtemp >= 0xA0);             \
+    c = STRING_CHAR (dtemp, p - dtemp);                                     \
+  } while (0)
+
+#ifdef emacs
+
+/* Increase the buffer point POS of the current buffer to the next
+   character boundary.  This macro relies on the fact that *GPT_ADDR
+   and *Z_ADDR are always accessible and the values are '\0'.  No
+   range checking of POS.  */
+#define INC_POS(pos)                            \
+  do {                                          \
+    unsigned char *p = POS_ADDR (pos) + 1;      \
+    pos++;                                      \
+    while (!CHAR_HEAD_P (p)) p++, pos++;        \
+  } while (0)
+
+/* Decrease the buffer point POS of the current buffer to the previous
+   character boundary.  No range checking of POS.  */
+#define DEC_POS(pos)                                            \
+  do {                                                          \
+    unsigned char *p, *p_min;                                   \
+    if (--pos < GPT)                                            \
+      p = BEG_ADDR + pos - 1, p_min = BEG_ADDR;                 \
+    else                                                        \
+      p = BEG_ADDR + GAP_SIZE + pos - 1, p_min = GAP_END_ADDR;  \
+    while (p > p_min && !CHAR_HEAD_P (p)) p--, pos--;           \
+  } while (0)
+
+#endif /* emacs */
+
+/* Maximum counts of components in one composite character.  */
+#define MAX_COMPONENT_COUNT 16
+
+/* Structure to hold information of a composite character.  */
+struct cmpchar_info {
+  /* Byte length of the composite character.  */
+  int len;
+
+  /* Multi-byte form of the composite character.  */
+  unsigned char *data;
+
+  /* Length of glyph codes.  */
+  int glyph_len;
+
+  /* Width of the overall glyph of the composite character.  */
+  int width;
+
+  /* Pointer to an array of glyph codes of the composite character.
+     This actually contains only character code, no face.  */
+  GLYPH *glyph;
+
+  /* Pointer to an array of composition rules.  The value has the form:
+        (0xA0 + ((GLOBAL-REF-POINT << 2) | NEW-REF-POINT))
+     where each XXX-REF-POINT is 0..8.  */
+  unsigned char *cmp_rule;
+
+  /* Pointer to an array of x-axis offset of left edge of glyphs
+     relative to the left of of glyph[0] except for the first element
+     which is the absolute offset from the left edge of overall glyph.
+     The actual pixel offset should be calculated by multiplying each
+     frame's one column width by this value:
+        (i.e. FONT_WIDTH (f->output_data.x->font) * col_offset[N]).  */
+  float *col_offset;
+
+  /* Work slot used by `dumpglyphs' (xterm.c).  */
+  int face_work;
+};
+
+/* Table of pointers to the structure `cmpchar_info' indexed by
+   CMPCHAR-ID.  */
+extern struct cmpchar_info **cmpchar_table;
+/* Number of the current composite characters.  */
+extern int n_cmpchars;
+
+/* This is the maximum length of multi-byte form.  */
+#define MAX_LENGTH_OF_MULTI_BYTE_FORM (MAX_COMPONENT_COUNT * 6)
+
+#endif /* _CHARSET_H */
+
diff --git a/src/coding.c b/src/coding.c
new file mode 100644
index 00000000000..95bbd26fef9
--- /dev/null
+++ b/src/coding.c
@@ -0,0 +1,3520 @@
+/* Coding system handler (conversion, detection, and etc).
+   Ver.1.0.
+
+   Copyright (C) 1995 Free Software Foundation, Inc.
+   Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+/*** TABLE OF CONTENTS ***
+
+  1. Preamble
+  2. Emacs' internal format handlers
+  3. ISO2022 handlers
+  4. Shift-JIS and BIG5 handlers
+  5. End-of-line handlers
+  6. C library functions
+  7. Emacs Lisp library functions
+  8. Post-amble
+
+*/
+
+/*** GENERAL NOTE on CODING SYSTEM ***
+
+  Coding system is an encoding mechanism of one or more character
+  sets.  Here's a list of coding systems which Emacs can handle.  When
+  we say "decode", it means converting some other coding system to
+  Emacs' internal format, and when we say "encode", it means
+  converting Emacs' internal format to some other coding system.
+
+  0. Emacs' internal format
+
+  Emacs itself holds a multi-lingual character in a buffer and a string
+  in a special format.  Details are described in the section 2.
+
+  1. ISO2022
+
+  The most famous coding system for multiple character sets.  X's
+  Compound Text, various EUCs (Extended Unix Code), and such coding
+  systems used in Internet communication as ISO-2022-JP are all
+  variants of ISO2022.  Details are described in the section 3.
+
+  2. SJIS (or Shift-JIS or MS-Kanji-Code)
+   
+  A coding system to encode character sets: ASCII, JISX0201, and
+  JISX0208.  Widely used for PC's in Japan.  Details are described in
+  the section 4.
+
+  3. BIG5
+
+  A coding system to encode character sets: ASCII and Big5.  Widely
+  used by Chinese (mainly in Taiwan and Hong Kong).  Details are
+  described in the section 4.  In this file, when written as "BIG5"
+  (all uppercase), it means the coding system, and when written as
+  "Big5" (capitalized), it means the character set.
+
+  4. Else
+
+  If a user want to read/write a text encoded in a coding system not
+  listed above, he can supply a decoder and an encoder for it in CCL
+  (Code Conversion Language) programs.  Emacs executes the CCL program
+  while reading/writing.
+
+  Emacs represent a coding-system by a Lisp symbol that has a property
+  `coding-system'.  But, before actually using the coding-system, the
+  information about it is set in a structure of type `struct
+  coding_system' for rapid processing.  See the section 6 for more
+  detail.
+
+*/
+
+/*** GENERAL NOTES on END-OF-LINE FORMAT ***
+
+  How end-of-line of a text is encoded depends on a system.  For
+  instance, Unix's format is just one byte of `line-feed' code,
+  whereas DOS's format is two bytes sequence of `carriage-return' and
+  `line-feed' codes.  MacOS's format is one byte of `carriage-return'.
+
+  Since how characters in a text is encoded and how end-of-line is
+  encoded is independent, any coding system described above can take
+  any format of end-of-line.  So, Emacs has information of format of
+  end-of-line in each coding-system.  See the section 6 for more
+  detail.
+
+*/
+
+/*** GENERAL NOTES on `detect_coding_XXX ()' functions ***
+
+  These functions check if a text between SRC and SRC_END is encoded
+  in the coding system category XXX.  Each returns an integer value in
+  which appropriate flag bits for the category XXX is set.  The flag
+  bits are defined in macros CODING_CATEGORY_MASK_XXX.  Below is the
+  template of these functions.  */
+#if 0
+int
+detect_coding_internal (src, src_end)
+     unsigned char *src, *src_end;
+{
+  ...
+}
+#endif
+
+/*** GENERAL NOTES on `decode_coding_XXX ()' functions ***
+
+  These functions decode SRC_BYTES length text at SOURCE encoded in
+  CODING to Emacs' internal format.  The resulting text goes to a
+  place pointed by DESTINATION, the length of which should not exceed
+  DST_BYTES.  The bytes actually processed is returned as *CONSUMED.
+  The return value is the length of the decoded text.  Below is a
+  template of these functions.  */
+#if 0
+decode_coding_XXX (coding, source, destination, src_bytes, dst_bytes, consumed)
+     struct coding_system *coding;
+     unsigned char *source, *destination;
+     int src_bytes, dst_bytes;
+     int *consumed;
+{
+  ...
+}
+#endif
+
+/*** GENERAL NOTES on `encode_coding_XXX ()' functions ***
+
+  These functions encode SRC_BYTES length text at SOURCE of Emacs
+  internal format to CODING.  The resulting text goes to a place
+  pointed by DESTINATION, the length of which should not exceed
+  DST_BYTES.  The bytes actually processed is returned as *CONSUMED.
+  The return value is the length of the encoded text.  Below is a
+  template of these functions.  */
+#if 0
+encode_coding_XXX (coding, source, destination, src_bytes, dst_bytes, consumed)
+     struct coding_system *coding;
+     unsigned char *source, *destination;
+     int src_bytes, dst_bytes;
+     int *consumed;
+{
+  ...
+}
+#endif
+
+/*** COMMONLY USED MACROS ***/
+
+/* The following three macros ONE_MORE_BYTE, TWO_MORE_BYTES, and
+   THREE_MORE_BYTES safely get one, two, and three bytes from the
+   source text respectively.  If there are not enough bytes in the
+   source, they jump to `label_end_of_loop'.  The caller should set
+   variables `src' and `src_end' to appropriate areas in advance.  */
+
+#define ONE_MORE_BYTE(c1)       \
+  do {                          \
+    if (src < src_end)          \
+      c1 = *src++;              \
+    else                        \
+      goto label_end_of_loop;   \
+  } while (0)
+
+#define TWO_MORE_BYTES(c1, c2)  \
+  do {                          \
+    if (src + 1 < src_end)      \
+      c1 = *src++, c2 = *src++; \
+    else                        \
+      goto label_end_of_loop;   \
+  } while (0)
+
+#define THREE_MORE_BYTES(c1, c2, c3)            \
+  do {                                          \
+    if (src + 2 < src_end)                      \
+      c1 = *src++, c2 = *src++, c3 = *src++;    \
+    else                                        \
+      goto label_end_of_loop;                   \
+  } while (0)
+
+/* The following three macros DECODE_CHARACTER_ASCII,
+   DECODE_CHARACTER_DIMENSION1, and DECODE_CHARACTER_DIMENSION2 put
+   the multi-byte form of a character of each class at the place
+   pointed by `dst'.  The caller should set the variable `dst' to
+   point to an appropriate area and the variable `coding' to point to
+   the coding-system of the currently decoding text in advance.  */
+
+/* Decode one ASCII character C.  */
+
+#define DECODE_CHARACTER_ASCII(c)                               \
+  do {                                                          \
+    if (COMPOSING_P (coding->composing))                        \
+      *dst++ = 0xA0, *dst++ = (c) | 0x80;                       \
+    else                                                        \
+      *dst++ = (c);                                             \
+  } while (0)
+
+/* Decode one DIMENSION1 character of which charset is CHARSET and
+   position-code is C.  */
+
+#define DECODE_CHARACTER_DIMENSION1(charset, c)                         \
+  do {                                                                  \
+    unsigned char leading_code = CHARSET_LEADING_CODE_BASE (charset);   \
+    if (COMPOSING_P (coding->composing))                                \
+      *dst++ = leading_code + 0x20;                                     \
+    else                                                                \
+      *dst++ = leading_code;                                            \
+    if (leading_code = CHARSET_LEADING_CODE_EXT (charset))              \
+      *dst++ = leading_code;                                            \
+    *dst++ = (c) | 0x80;                                                \
+  } while (0)
+
+/* Decode one DIMENSION2 character of which charset is CHARSET and
+   position-codes are C1 and C2.  */
+
+#define DECODE_CHARACTER_DIMENSION2(charset, c1, c2)    \
+  do {                                                  \
+    DECODE_CHARACTER_DIMENSION1 (charset, c1);          \
+    *dst++ = (c2) | 0x80;                               \
+  } while (0)
+
+
+/*** 1. Preamble ***/
+
+#include <stdio.h>
+
+#ifdef emacs
+
+#include <config.h>
+#include "lisp.h"
+#include "buffer.h"
+#include "charset.h"
+#include "ccl.h"
+#include "coding.h"
+#include "window.h"
+
+#else  /* not emacs */
+
+#include "mulelib.h"
+
+#endif /* not emacs */
+
+Lisp_Object Qcoding_system, Qeol_type;
+Lisp_Object Qbuffer_file_coding_system;
+Lisp_Object Qpost_read_conversion, Qpre_write_conversion;
+
+extern Lisp_Object Qinsert_file_contents, Qwrite_region;
+Lisp_Object Qcall_process, Qcall_process_region, Qprocess_argument;
+Lisp_Object Qstart_process, Qopen_network_stream;
+Lisp_Object Qtarget_idx;
+
+/* Mnemonic character of each format of end-of-line.  */
+int eol_mnemonic_unix, eol_mnemonic_dos, eol_mnemonic_mac;
+/* Mnemonic character to indicate format of end-of-line is not yet
+   decided.  */
+int eol_mnemonic_undecided;
+
+#ifdef emacs
+
+Lisp_Object Qcoding_system_vector, Qcoding_system_p, Qcoding_system_error;
+
+/* Coding-systems are handed between Emacs Lisp programs and C internal
+   routines by the following three variables.  */
+/* Coding-system for reading files and receiving data from process.  */
+Lisp_Object Vcoding_system_for_read;
+/* Coding-system for writing files and sending data to process.  */
+Lisp_Object Vcoding_system_for_write;
+/* Coding-system actually used in the latest I/O.  */
+Lisp_Object Vlast_coding_system_used;
+
+/* Coding-system of what terminal accept for displaying.  */
+struct coding_system terminal_coding;
+
+/* Coding-system of what is sent from terminal keyboard.  */
+struct coding_system keyboard_coding;
+
+Lisp_Object Vcoding_system_alist;
+
+#endif /* emacs */
+
+Lisp_Object Qcoding_category_index;
+
+/* List of symbols `coding-category-xxx' ordered by priority.  */
+Lisp_Object Vcoding_category_list;
+
+/* Table of coding-systems currently assigned to each coding-category.  */
+Lisp_Object coding_category_table[CODING_CATEGORY_IDX_MAX];
+
+/* Table of names of symbol for each coding-category.  */
+char *coding_category_name[CODING_CATEGORY_IDX_MAX] = {
+  "coding-category-internal",
+  "coding-category-sjis",
+  "coding-category-iso-7",
+  "coding-category-iso-8-1",
+  "coding-category-iso-8-2",
+  "coding-category-iso-else",
+  "coding-category-big5",
+  "coding-category-binary"
+};
+
+/* Alist of charsets vs the alternate charsets.  */
+Lisp_Object Valternate_charset_table;
+
+/* Alist of charsets vs revision number.  */
+Lisp_Object Vcharset_revision_alist;
+
+
+/*** 2. Emacs internal format handlers ***/
+
+/* Emacs' internal format for encoding multiple character sets is a
+   kind of multi-byte encoding, i.e. encoding a character by a sequence
+   of one-byte codes of variable length.  ASCII characters and control
+   characters (e.g. `tab', `newline') are represented by one-byte as
+   is.  It takes the range 0x00 through 0x7F.  The other characters
+   are represented by a sequence of `base leading-code', optional
+   `extended leading-code', and one or two `position-code's.  Length
+   of the sequence is decided by the base leading-code.  Leading-code
+   takes the range 0x80 through 0x9F, whereas extended leading-code
+   and position-code take the range 0xA0 through 0xFF.  See the
+   document of `charset.h' for more detail about leading-code and
+   position-code.
+
+   There's one exception in this rule.  Special leading-code
+   `leading-code-composition' denotes that the following several
+   characters should be composed into one character.  Leading-codes of
+   components (except for ASCII) are added 0x20.  An ASCII character
+   component is represented by a 2-byte sequence of `0xA0' and
+   `ASCII-code + 0x80'.  See also the document in `charset.h' for the
+   detail of composite character.  Hence, we can summarize the code
+   range as follows:
+
+   --- CODE RANGE of Emacs' internal format ---
+   (character set)      (range)
+   ASCII                0x00 .. 0x7F
+   ELSE (1st byte)      0x80 .. 0x9F
+        (rest bytes)    0xA0 .. 0xFF
+   ---------------------------------------------
+
+  */
+
+enum emacs_code_class_type emacs_code_class[256];
+
+/* Go to the next statement only if *SRC is accessible and the code is
+   greater than 0xA0.  */
+#define CHECK_CODE_RANGE_A0_FF  \
+  do {                          \
+    if (src >= src_end)         \
+      goto label_end_of_switch; \
+    else if (*src++ < 0xA0)     \
+      return 0;                 \
+  } while (0)
+
+/* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
+   Check if a text is encoded in Emacs' internal format.  If it is,
+   return CODING_CATEGORY_MASK_INTERNAL, else return 0.  */
+
+int
+detect_coding_internal (src, src_end)
+     unsigned char *src, *src_end;
+{
+  unsigned char c;
+  int composing = 0;
+
+  while (src < src_end)
+    {
+      c = *src++;
+
+      if (composing)
+        {
+          if (c < 0xA0)
+            composing = 0;
+          else
+            c -= 0x20;
+        }
+
+      switch (emacs_code_class[c])
+        {
+        case EMACS_ascii_code:
+        case EMACS_linefeed_code:
+          break;
+
+        case EMACS_control_code:
+          if (c == ISO_CODE_ESC || c == ISO_CODE_SI || c == ISO_CODE_SO)
+            return 0;
+          break;
+
+        case EMACS_invalid_code:
+          return 0;
+
+        case EMACS_leading_code_composition: /* c == 0x80 */
+          if (composing)
+            CHECK_CODE_RANGE_A0_FF;
+          else
+            composing = 1;
+          break;
+
+        case EMACS_leading_code_4:
+          CHECK_CODE_RANGE_A0_FF;
+          /* fall down to check it two more times ...  */
+
+        case EMACS_leading_code_3:
+          CHECK_CODE_RANGE_A0_FF;
+          /* fall down to check it one more time ...  */
+
+        case EMACS_leading_code_2:
+          CHECK_CODE_RANGE_A0_FF;
+          break;
+
+        default:
+        label_end_of_switch:
+          break;
+        }
+    }
+  return CODING_CATEGORY_MASK_INTERNAL;
+}
+
+
+/*** 3. ISO2022 handlers ***/
+
+/* The following note describes the coding system ISO2022 briefly.
+   Since the intension of this note is to help understanding of the
+   programs in this file, some parts are NOT ACCURATE or OVERLY
+   SIMPLIFIED.  For the thorough understanding, please refer to the
+   original document of ISO2022.
+
+   ISO2022 provides many mechanisms to encode several character sets
+   in 7-bit and 8-bit environment.  If one choose 7-bite environment,
+   all text is encoded by codes of less than 128.  This may make the
+   encoded text a little bit longer, but the text get more stability
+   to pass through several gateways (some of them split MSB off).
+
+   There are two kind of character set: control character set and
+   graphic character set.  The former contains control characters such
+   as `newline' and `escape' to provide control functions (control
+   functions are provided also by escape sequence).  The latter
+   contains graphic characters such as ' A' and '-'.  Emacs recognizes
+   two control character sets and many graphic character sets.
+
+   Graphic character sets are classified into one of the following
+   four classes, DIMENSION1_CHARS94, DIMENSION1_CHARS96,
+   DIMENSION2_CHARS94, DIMENSION2_CHARS96 according to the number of
+   bytes (DIMENSION) and the number of characters in one dimension
+   (CHARS) of the set.  In addition, each character set is assigned an
+   identification tag (called "final character" and denoted as <F>
+   here after) which is unique in each class.  <F> of each character
+   set is decided by ECMA(*) when it is registered in ISO.  Code range
+   of <F> is 0x30..0x7F (0x30..0x3F are for private use only).
+
+   Note (*): ECMA = European Computer Manufacturers Association
+
+   Here are examples of graphic character set [NAME(<F>)]:
+        o DIMENSION1_CHARS94 -- ASCII('B'), right-half-of-JISX0201('I'), ...
+        o DIMENSION1_CHARS96 -- right-half-of-ISO8859-1('A'), ...
+        o DIMENSION2_CHARS94 -- GB2312('A'), JISX0208('B'), ...
+        o DIMENSION2_CHARS96 -- none for the moment
+
+   A code area (1byte=8bits) is divided into 4 areas, C0, GL, C1, and GR.
+        C0 [0x00..0x1F] -- control character plane 0
+        GL [0x20..0x7F] -- graphic character plane 0
+        C1 [0x80..0x9F] -- control character plane 1
+        GR [0xA0..0xFF] -- graphic character plane 1
+
+   A control character set is directly designated and invoked to C0 or
+   C1 by an escape sequence.  The most common case is that ISO646's
+   control character set is designated/invoked to C0 and ISO6429's
+   control character set is designated/invoked to C1, and usually
+   these designations/invocations are omitted in a coded text.  With
+   7-bit environment, only C0 can be used, and a control character for
+   C1 is encoded by an appropriate escape sequence to fit in the
+   environment.  All control characters for C1 are defined the
+   corresponding escape sequences.
+
+   A graphic character set is at first designated to one of four
+   graphic registers (G0 through G3), then these graphic registers are
+   invoked to GL or GR.  These designations and invocations can be
+   done independently.  The most common case is that G0 is invoked to
+   GL, G1 is invoked to GR, and ASCII is designated to G0, and usually
+   these invocations and designations are omitted in a coded text.
+   With 7-bit environment, only GL can be used.
+
+   When a graphic character set of CHARS94 is invoked to GL, code 0x20
+   and 0x7F of GL area work as control characters SPACE and DEL
+   respectively, and code 0xA0 and 0xFF of GR area should not be used.
+
+   There are two ways of invocation: locking-shift and single-shift.
+   With locking-shift, the invocation lasts until the next different
+   invocation, whereas with single-shift, the invocation works only
+   for the following character and doesn't affect locking-shift.
+   Invocations are done by the following control characters or escape
+   sequences.
+
+   ----------------------------------------------------------------------
+   function             control char    escape sequence description
+   ----------------------------------------------------------------------
+   SI  (shift-in)               0x0F    none            invoke G0 to GL
+   SI  (shift-out)              0x0E    none            invoke G1 to GL
+   LS2 (locking-shift-2)        none    ESC 'n'         invoke G2 into GL
+   LS3 (locking-shift-3)        none    ESC 'o'         invoke G3 into GL
+   SS2 (single-shift-2)         0x8E    ESC 'N'         invoke G2 into GL
+   SS3 (single-shift-3)         0x8F    ESC 'O'         invoke G3 into GL
+   ----------------------------------------------------------------------
+   The first four are for locking-shift.  Control characters for these
+   functions are defined by macros ISO_CODE_XXX in `coding.h'.
+
+   Designations are done by the following escape sequences.
+   ----------------------------------------------------------------------
+   escape sequence      description
+   ----------------------------------------------------------------------
+   ESC '(' <F>          designate DIMENSION1_CHARS94<F> to G0
+   ESC ')' <F>          designate DIMENSION1_CHARS94<F> to G1
+   ESC '*' <F>          designate DIMENSION1_CHARS94<F> to G2
+   ESC '+' <F>          designate DIMENSION1_CHARS94<F> to G3
+   ESC ',' <F>          designate DIMENSION1_CHARS96<F> to G0 (*)
+   ESC '-' <F>          designate DIMENSION1_CHARS96<F> to G1
+   ESC '.' <F>          designate DIMENSION1_CHARS96<F> to G2
+   ESC '/' <F>          designate DIMENSION1_CHARS96<F> to G3
+   ESC '$' '(' <F>      designate DIMENSION2_CHARS94<F> to G0 (**)
+   ESC '$' ')' <F>      designate DIMENSION2_CHARS94<F> to G1
+   ESC '$' '*' <F>      designate DIMENSION2_CHARS94<F> to G2
+   ESC '$' '+' <F>      designate DIMENSION2_CHARS94<F> to G3
+   ESC '$' ',' <F>      designate DIMENSION2_CHARS96<F> to G0 (*)
+   ESC '$' '-' <F>      designate DIMENSION2_CHARS96<F> to G1
+   ESC '$' '.' <F>      designate DIMENSION2_CHARS96<F> to G2
+   ESC '$' '/' <F>      designate DIMENSION2_CHARS96<F> to G3
+   ----------------------------------------------------------------------
+
+   In this list, "DIMENSION1_CHARS94<F>" means a graphic character set
+   of dimension 1, chars 94, and final character <F>, and etc.
+
+   Note (*): Although these designations are not allowed in ISO2022,
+   Emacs accepts them on decoding, and produces them on encoding
+   CHARS96 character set in a coding system which is characterized as
+   7-bit environment, non-locking-shift, and non-single-shift.
+
+   Note (**): If <F> is '@', 'A', or 'B', the intermediate character
+   '(' can be omitted.  We call this as "short-form" here after.
+
+   Now you may notice that there are a lot of ways for encoding the
+   same multilingual text in ISO2022.  Actually, there exist many
+   coding systems such as Compound Text (used in X's inter client
+   communication, ISO-2022-JP (used in Japanese Internet), ISO-2022-KR
+   (used in Korean Internet), EUC (Extended UNIX Code, used in Asian
+   localized platforms), and all of these are variants of ISO2022.
+
+   In addition to the above, Emacs handles two more kinds of escape
+   sequences: ISO6429's direction specification and Emacs' private
+   sequence for specifying character composition.
+
+   ISO6429's direction specification takes the following format:
+        o CSI ']'      -- end of the current direction
+        o CSI '0' ']'  -- end of the current direction
+        o CSI '1' ']'  -- start of left-to-right text
+        o CSI '2' ']'  -- start of right-to-left text
+   The control character CSI (0x9B: control sequence introducer) is
+   abbreviated to the escape sequence ESC '[' in 7-bit environment.
+   
+   Character composition specification takes the following format:
+        o ESC '0' -- start character composition
+        o ESC '1' -- end character composition
+   Since these are not standard escape sequences of any ISO, the use
+   of them for these meaning is restricted to Emacs only.  */
+
+enum iso_code_class_type iso_code_class[256];
+
+/* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
+   Check if a text is encoded in ISO2022.  If it is, returns an
+   integer in which appropriate flag bits any of:
+        CODING_CATEGORY_MASK_ISO_7
+        CODING_CATEGORY_MASK_ISO_8_1
+        CODING_CATEGORY_MASK_ISO_8_2
+        CODING_CATEGORY_MASK_ISO_ELSE
+   are set.  If a code which should never appear in ISO2022 is found,
+   returns 0.  */
+
+int
+detect_coding_iso2022 (src, src_end)
+     unsigned char *src, *src_end;
+{
+  unsigned char graphic_register[4];
+  unsigned char c, esc_cntl;
+  int mask = (CODING_CATEGORY_MASK_ISO_7
+              | CODING_CATEGORY_MASK_ISO_8_1
+              | CODING_CATEGORY_MASK_ISO_8_2);
+  /* We may look ahead maximum 3 bytes.  */
+  unsigned char *adjusted_src_end = src_end - 3;
+  int i;
+
+  for (i = 0; i < 4; i++)
+    graphic_register[i] = CHARSET_ASCII;
+
+  while (src < adjusted_src_end)
+    {
+      c = *src++;
+      switch (c)
+        {
+        case ISO_CODE_ESC:
+          if (src >= adjusted_src_end)
+            break;
+          c = *src++;
+          if (c == '$')
+            {
+              /* Designation of 2-byte character set.  */
+              if (src >= adjusted_src_end)
+                break;
+              c = *src++;
+            }
+          if ((c >= ')' && c <= '+') || (c >= '-' && c <= '/'))
+            /* Designation to graphic register 1, 2, or 3.  */
+            mask &= ~CODING_CATEGORY_MASK_ISO_7;
+          else if (c == 'N' || c == 'O' || c == 'n' || c == 'o')
+            return CODING_CATEGORY_MASK_ISO_ELSE;
+          break;
+
+        case ISO_CODE_SI:
+        case ISO_CODE_SO:
+          return CODING_CATEGORY_MASK_ISO_ELSE;
+
+        case ISO_CODE_CSI:
+        case ISO_CODE_SS2:
+        case ISO_CODE_SS3:
+          mask &= ~CODING_CATEGORY_MASK_ISO_7;
+          break;
+
+        default:
+          if (c < 0x80)
+            break;
+          else if (c < 0xA0)
+            return 0;
+          else
+            {
+              int count = 1;
+
+              mask &= ~CODING_CATEGORY_MASK_ISO_7;
+              while (src < adjusted_src_end && *src >= 0xA0)
+                count++, src++;
+              if (count & 1 && src < adjusted_src_end)
+                mask &= ~CODING_CATEGORY_MASK_ISO_8_2;
+            }
+          break;
+        }
+    }
+
+  return mask;
+}
+
+/* Decode a character of which charset is CHARSET and the 1st position
+   code is C1.  If dimension of CHARSET 2, the 2nd position code is
+   fetched from SRC and set to C2.  If CHARSET is negative, it means
+   that we are decoding ill formed text, and what we can do is just to
+   read C1 as is.  */
+
+#define DECODE_ISO_CHARACTER(charset, c1)                       \
+  do {                                                          \
+    if ((charset) >= 0 && CHARSET_DIMENSION (charset) == 2)     \
+      ONE_MORE_BYTE (c2);                                       \
+    if (COMPOSING_HEAD_P (coding->composing))                   \
+      {                                                         \
+        *dst++ = LEADING_CODE_COMPOSITION;                      \
+        if (COMPOSING_WITH_RULE_P (coding->composing))          \
+          /* To tell composition rules are embeded.  */         \
+          *dst++ = 0xFF;                                        \
+        coding->composing += 2;                                 \
+      }                                                         \
+    if ((charset) < 0)                                          \
+      *dst++ = c1;                                              \
+    else if ((charset) == CHARSET_ASCII)                        \
+      DECODE_CHARACTER_ASCII (c1);                              \
+    else if (CHARSET_DIMENSION (charset) == 1)                  \
+      DECODE_CHARACTER_DIMENSION1 (charset, c1);                \
+    else                                                        \
+      DECODE_CHARACTER_DIMENSION2 (charset, c1, c2);            \
+    if (COMPOSING_WITH_RULE_P (coding->composing))              \
+      /* To tell a composition rule follows.  */                \
+      coding->composing = COMPOSING_WITH_RULE_RULE;             \
+  } while (0)
+
+/* Set designation state into CODING.  */
+#define DECODE_DESIGNATION(reg, dimension, chars, final_char)           \
+  do {                                                                  \
+    int charset = ISO_CHARSET_TABLE (dimension, chars, final_char);     \
+    Lisp_Object temp                                                    \
+      = Fassq (CHARSET_SYMBOL (charset), Valternate_charset_table);     \
+    if (! NILP (temp))                                                  \
+      charset = get_charset_id (XCONS (temp)->cdr);                     \
+    if (charset >= 0)                                                   \
+      {                                                                 \
+        if (coding->direction == 1                                      \
+            && CHARSET_REVERSE_CHARSET (charset) >= 0)                  \
+          charset = CHARSET_REVERSE_CHARSET (charset);                  \
+        CODING_SPEC_ISO_DESIGNATION (coding, reg) = charset;            \
+      }                                                                 \
+  } while (0)
+
+/* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions".  */
+
+int
+decode_coding_iso2022 (coding, source, destination,
+                       src_bytes, dst_bytes, consumed)
+     struct coding_system *coding;
+     unsigned char *source, *destination;
+     int src_bytes, dst_bytes;
+     int *consumed;
+{
+  unsigned char *src = source;
+  unsigned char *src_end = source + src_bytes;
+  unsigned char *dst = destination;
+  unsigned char *dst_end = destination + dst_bytes;
+  /* Since the maximum bytes produced by each loop is 7, we subtract 6
+     from DST_END to assure that overflow checking is necessary only
+     at the head of loop.  */
+  unsigned char *adjusted_dst_end = dst_end - 6;
+  int charset;
+  /* Charsets invoked to graphic plane 0 and 1 respectively.  */
+  int charset0 = CODING_SPEC_ISO_PLANE_CHARSET (coding, 0);
+  int charset1 = CODING_SPEC_ISO_PLANE_CHARSET (coding, 1);
+
+  while (src < src_end && dst < adjusted_dst_end)
+    {
+      /* SRC_BASE remembers the start position in source in each loop.
+         The loop will be exited when there's not enough source text
+         to analyze long escape sequence or 2-byte code (within macros
+         ONE_MORE_BYTE or TWO_MORE_BYTES).  In that case, SRC is reset
+         to SRC_BASE before exiting.  */
+      unsigned char *src_base = src;
+      unsigned char c1 = *src++, c2, cmprule;
+
+      switch (iso_code_class [c1])
+        {
+        case ISO_0x20_or_0x7F:
+          if (!coding->composing
+              && (charset0 < 0 || CHARSET_CHARS (charset0) == 94))
+            {
+              /* This is SPACE or DEL.  */
+              *dst++ = c1;
+              break;
+            }
+          /* This is a graphic character, we fall down ...  */
+
+        case ISO_graphic_plane_0:
+          if (coding->composing == COMPOSING_WITH_RULE_RULE)
+            {
+              /* This is a composition rule.  */
+              *dst++ = c1 | 0x80;
+              coding->composing = COMPOSING_WITH_RULE_TAIL;
+            }
+          else
+            DECODE_ISO_CHARACTER (charset0, c1);
+          break;
+
+        case ISO_0xA0_or_0xFF:
+          if (charset1 < 0 || CHARSET_CHARS (charset1) == 94)
+            {
+              /* Invalid code.  */
+              *dst++ = c1;
+              break;
+            }
+          /* This is a graphic character, we fall down ... */
+
+        case ISO_graphic_plane_1:
+          DECODE_ISO_CHARACTER (charset1, c1);
+          break;
+
+        case ISO_control_code:
+          /* All ISO2022 control characters in this class have the
+             same representation in Emacs internal format.  */
+          *dst++ = c1;
+          break;
+
+        case ISO_carriage_return:
+          if (coding->eol_type == CODING_EOL_CR)
+            {
+              *dst++ = '\n';
+            }
+          else if (coding->eol_type == CODING_EOL_CRLF)
+            {
+              ONE_MORE_BYTE (c1);
+              if (c1 == ISO_CODE_LF)
+                *dst++ = '\n';
+              else
+                {
+                  src--;
+                  *dst++ = c1;
+                }
+            }
+          else
+            {
+              *dst++ = c1;
+            }
+          break;
+
+        case ISO_shift_out:
+          CODING_SPEC_ISO_INVOCATION (coding, 0) = 1;
+          charset0 = CODING_SPEC_ISO_PLANE_CHARSET (coding, 0);
+          break;
+
+        case ISO_shift_in:
+          CODING_SPEC_ISO_INVOCATION (coding, 0) = 0;
+          charset0 = CODING_SPEC_ISO_PLANE_CHARSET (coding, 0);
+          break;
+
+        case ISO_single_shift_2_7:
+        case ISO_single_shift_2:
+          /* SS2 is handled as an escape sequence of ESC 'N' */
+          c1 = 'N';
+          goto label_escape_sequence;
+
+        case ISO_single_shift_3:
+          /* SS2 is handled as an escape sequence of ESC 'O' */
+          c1 = 'O';
+          goto label_escape_sequence;
+
+        case ISO_control_sequence_introducer:
+          /* CSI is handled as an escape sequence of ESC '[' ...  */
+          c1 = '[';
+          goto label_escape_sequence;
+
+        case ISO_escape:
+          ONE_MORE_BYTE (c1);
+        label_escape_sequence:
+          /* Escape sequences handled by Emacs are invocation,
+             designation, direction specification, and character
+             composition specification.  */
+          switch (c1)
+            {
+            case '&':           /* revision of following character set */
+              ONE_MORE_BYTE (c1);
+              if (!(c1 >= '@' && c1 <= '~'))
+                {
+                  goto label_invalid_escape_sequence;
+                }
+              ONE_MORE_BYTE (c1);
+              if (c1 != ISO_CODE_ESC)
+                {
+                  goto label_invalid_escape_sequence;
+                }
+              ONE_MORE_BYTE (c1);
+              goto label_escape_sequence;
+
+            case '$':           /* designation of 2-byte character set */
+              ONE_MORE_BYTE (c1);
+              if (c1 >= '@' && c1 <= 'B')
+                {       /* designation of JISX0208.1978, GB2312.1980,
+                                   or JISX0208.1980 */
+                  DECODE_DESIGNATION (0, 2, 94, c1);
+                }
+              else if (c1 >= 0x28 && c1 <= 0x2B)
+                {       /* designation of DIMENSION2_CHARS94 character set */
+                  ONE_MORE_BYTE (c2);
+                  DECODE_DESIGNATION (c1 - 0x28, 2, 94, c2);
+                }
+              else if (c1 >= 0x2C && c1 <= 0x2F)
+                {       /* designation of DIMENSION2_CHARS96 character set */
+                  ONE_MORE_BYTE (c2);
+                  DECODE_DESIGNATION (c1 - 0x2C, 2, 96, c2);
+                }
+              else
+                {
+                  goto label_invalid_escape_sequence;
+                }
+              break;
+
+            case 'n':           /* invocation of locking-shift-2 */
+              CODING_SPEC_ISO_INVOCATION (coding, 0) = 2;
+              break;
+
+            case 'o':           /* invocation of locking-shift-3 */
+              CODING_SPEC_ISO_INVOCATION (coding, 0) = 3;
+              break;
+
+            case 'N':           /* invocation of single-shift-2 */
+              ONE_MORE_BYTE (c1);
+              charset = CODING_SPEC_ISO_DESIGNATION (coding, 2);
+              DECODE_ISO_CHARACTER (charset, c1);
+              break;
+
+            case 'O':           /* invocation of single-shift-3 */
+              ONE_MORE_BYTE (c1);
+              charset = CODING_SPEC_ISO_DESIGNATION (coding, 3);
+              DECODE_ISO_CHARACTER (charset, c1);
+              break;
+
+            case '0':           /* start composing without embeded rules */
+              coding->composing = COMPOSING_NO_RULE_HEAD;
+              break;
+
+            case '1':           /* end composing */
+              coding->composing = COMPOSING_NO;
+              break;
+
+            case '2':           /* start composing with embeded rules */
+              coding->composing = COMPOSING_WITH_RULE_HEAD;
+              break;
+
+            case '[':           /* specification of direction */
+              /* For the moment, nested direction is not supported.
+                 So, the value of `coding->direction' is 0 or 1: 0
+                 means left-to-right, 1 means right-to-left.  */
+              ONE_MORE_BYTE (c1);
+              switch (c1)
+                {
+                case ']':       /* end of the current direction */
+                  coding->direction = 0;
+
+                case '0':       /* end of the current direction */
+                case '1':       /* start of left-to-right direction */
+                  ONE_MORE_BYTE (c1);
+                  if (c1 == ']')
+                    coding->direction = 0;
+                  else
+                    goto label_invalid_escape_sequence;
+                  break;
+
+                case '2':       /* start of right-to-left direction */
+                  ONE_MORE_BYTE (c1);
+                  if (c1 == ']')
+                    coding->direction= 1;
+                  else
+                    goto label_invalid_escape_sequence;
+                  break;
+
+                default:
+                  goto label_invalid_escape_sequence;
+                }
+              break;
+
+            default:
+              if (c1 >= 0x28 && c1 <= 0x2B)
+                {       /* designation of DIMENSION1_CHARS94 character set */
+                  ONE_MORE_BYTE (c2);
+                  DECODE_DESIGNATION (c1 - 0x28, 1, 94, c2);
+                }
+              else if (c1 >= 0x2C && c1 <= 0x2F)
+                {       /* designation of DIMENSION1_CHARS96 character set */
+                  ONE_MORE_BYTE (c2);
+                  DECODE_DESIGNATION (c1 - 0x2C, 1, 96, c2);
+                }
+              else
+                {
+                  goto label_invalid_escape_sequence;
+                }
+            }
+          /* We must update these variables now.  */
+          charset0 = CODING_SPEC_ISO_PLANE_CHARSET (coding, 0);
+          charset1 = CODING_SPEC_ISO_PLANE_CHARSET (coding, 1);
+          break;
+
+        label_invalid_escape_sequence:
+          {
+            int length = src - src_base;
+
+            bcopy (src_base, dst, length);
+            dst += length;
+          }
+        }
+      continue;
+
+    label_end_of_loop:
+      coding->carryover_size = src - src_base;
+      bcopy (src_base, coding->carryover, coding->carryover_size);
+      src = src_base;
+      break;
+    }
+
+  /* If this is the last block of the text to be decoded, we had
+     better just flush out all remaining codes in the text although
+     they are not valid characters.  */
+  if (coding->last_block)
+    {
+      bcopy (src, dst, src_end - src);
+      dst += (src_end - src);
+      src = src_end;
+    }
+  *consumed = src - source;
+  return dst - destination;
+}
+
+/* ISO2022 encoding staffs.  */
+
+/*
+   It is not enough to say just "ISO2022" on encoding, but we have to
+   specify more details.  In Emacs, each coding-system of ISO2022
+   variant has the following specifications:
+        1. Initial designation to G0 thru G3.
+        2. Allows short-form designation?
+        3. ASCII should be designated to G0 before control characters?
+        4. ASCII should be designated to G0 at end of line?
+        5. 7-bit environment or 8-bit environment?
+        6. Use locking-shift?
+        7. Use Single-shift?
+   And the following two are only for Japanese:
+        8. Use ASCII in place of JIS0201-1976-Roman?
+        9. Use JISX0208-1983 in place of JISX0208-1978?
+   These specifications are encoded in `coding->flags' as flag bits
+   defined by macros CODING_FLAG_ISO_XXX.  See `coding.h' for more
+   detail.
+*/
+
+/* Produce codes (escape sequence) for designating CHARSET to graphic
+   register REG.  If <final-char> of CHARSET is '@', 'A', or 'B' and
+   the coding system CODING allows, produce designation sequence of
+   short-form.  */
+
+#define ENCODE_DESIGNATION(charset, reg, coding)                        \
+  do {                                                                  \
+    unsigned char final_char = CHARSET_ISO_FINAL_CHAR (charset);        \
+    char *intermediate_char_94 = "()*+";                                \
+    char *intermediate_char_96 = ",-./";                                \
+    Lisp_Object temp                                                    \
+      = Fassq (make_number (charset), Vcharset_revision_alist);         \
+    if (! NILP (temp))                                                  \
+        {                                                               \
+        *dst++ = ISO_CODE_ESC;                                          \
+        *dst++ = '&';                                                   \
+        *dst++ = XINT (XCONS (temp)->cdr) + '@';                        \
+      }                                                                 \
+    *dst++ = ISO_CODE_ESC;                                              \
+    if (CHARSET_DIMENSION (charset) == 1)                               \
+      {                                                                 \
+        if (CHARSET_CHARS (charset) == 94)                              \
+          *dst++ = (unsigned char) (intermediate_char_94[reg]);         \
+        else                                                            \
+          *dst++ = (unsigned char) (intermediate_char_96[reg]);         \
+      }                                                                 \
+    else                                                                \
+      {                                                                 \
+        *dst++ = '$';                                                   \
+        if (CHARSET_CHARS (charset) == 94)                              \
+          {                                                             \
+            if (! (coding->flags & CODING_FLAG_ISO_SHORT_FORM)          \
+                || reg != 0                                             \
+                || final_char < '@' || final_char > 'B')                \
+              *dst++ = (unsigned char) (intermediate_char_94[reg]);     \
+          }                                                             \
+        else                                                            \
+          *dst++ = (unsigned char) (intermediate_char_96[reg]);         \
+      }                                                                 \
+    *dst++ = final_char;                                                \
+    CODING_SPEC_ISO_DESIGNATION (coding, reg) = charset;                \
+  } while (0)
+
+/* The following two macros produce codes (control character or escape
+   sequence) for ISO2022 single-shift functions (single-shift-2 and
+   single-shift-3).  */
+
+#define ENCODE_SINGLE_SHIFT_2                           \
+  do {                                                  \
+    if (coding->flags & CODING_FLAG_ISO_SEVEN_BITS)     \
+      *dst++ = ISO_CODE_ESC, *dst++ = 'N';              \
+    else                                                \
+      *dst++ = ISO_CODE_SS2;                            \
+    CODING_SPEC_ISO_SINGLE_SHIFTING (coding) = 1;       \
+  } while (0)
+
+#define ENCODE_SINGLE_SHIFT_3                           \
+  do {                                                  \
+    if (coding->flags & CODING_FLAG_ISO_SEVEN_BITS)     \
+      *dst++ = ISO_CODE_ESC, *dst++ = 'O';              \
+    else                                                \
+      *dst++ = ISO_CODE_SS3;                            \
+    CODING_SPEC_ISO_SINGLE_SHIFTING (coding) = 1;       \
+  } while (0)
+
+/* The following four macros produce codes (control character or
+   escape sequence) for ISO2022 locking-shift functions (shift-in,
+   shift-out, locking-shift-2, and locking-shift-3).  */
+
+#define ENCODE_SHIFT_IN                         \
+  do {                                          \
+    *dst++ = ISO_CODE_SI;                       \
+    CODING_SPEC_ISO_INVOCATION (coding, 0) = 0; \
+  } while (0)
+
+#define ENCODE_SHIFT_OUT                        \
+  do {                                          \
+    *dst++ = ISO_CODE_SO;                       \
+    CODING_SPEC_ISO_INVOCATION (coding, 0) = 1; \
+  } while (0)
+
+#define ENCODE_LOCKING_SHIFT_2                  \
+  do {                                          \
+    *dst++ = ISO_CODE_ESC, *dst++ = 'n';        \
+    CODING_SPEC_ISO_INVOCATION (coding, 0) = 2; \
+  } while (0)
+
+#define ENCODE_LOCKING_SHIFT_3                  \
+  do {                                          \
+    *dst++ = ISO_CODE_ESC, *dst++ = 'o';        \
+    CODING_SPEC_ISO_INVOCATION (coding, 0) = 3; \
+  } while (0)
+
+/* Produce codes for a DIMENSION1 character of which character set is
+   CHARSET and position-code is C1.  Designation and invocation
+   sequences are also produced in advance if necessary.  */
+
+
+#define ENCODE_ISO_CHARACTER_DIMENSION1(charset, c1)                    \
+  do {                                                                  \
+    if (CODING_SPEC_ISO_SINGLE_SHIFTING (coding))                       \
+      {                                                                 \
+        if (coding->flags & CODING_FLAG_ISO_SEVEN_BITS)                 \
+          *dst++ = c1 & 0x7F;                                           \
+        else                                                            \
+          *dst++ = c1 | 0x80;                                           \
+        CODING_SPEC_ISO_SINGLE_SHIFTING (coding) = 0;                   \
+        break;                                                          \
+      }                                                                 \
+    else if (charset == CODING_SPEC_ISO_PLANE_CHARSET (coding, 0))      \
+      {                                                                 \
+        *dst++ = c1 & 0x7F;                                             \
+        break;                                                          \
+      }                                                                 \
+    else if (charset == CODING_SPEC_ISO_PLANE_CHARSET (coding, 1))      \
+      {                                                                 \
+        *dst++ = c1 | 0x80;                                             \
+        break;                                                          \
+      }                                                                 \
+    else                                                                \
+      /* Since CHARSET is not yet invoked to any graphic planes, we     \
+         must invoke it, or, at first, designate it to some graphic     \
+         register.  Then repeat the loop to actually produce the        \
+         character.  */                                                 \
+      dst = encode_invocation_designation (charset, coding, dst);       \
+  } while (1)
+
+/* Produce codes for a DIMENSION2 character of which character set is
+   CHARSET and position-codes are C1 and C2.  Designation and
+   invocation codes are also produced in advance if necessary.  */
+
+#define ENCODE_ISO_CHARACTER_DIMENSION2(charset, c1, c2)                \
+  do {                                                                  \
+    if (CODING_SPEC_ISO_SINGLE_SHIFTING (coding))                       \
+      {                                                                 \
+        if (coding->flags & CODING_FLAG_ISO_SEVEN_BITS)                 \
+          *dst++ = c1 & 0x7F, *dst++ = c2 & 0x7F;                       \
+        else                                                            \
+          *dst++ = c1 | 0x80, *dst++ = c2 | 0x80;                       \
+        CODING_SPEC_ISO_SINGLE_SHIFTING (coding) = 0;                   \
+        break;                                                          \
+      }                                                                 \
+    else if (charset == CODING_SPEC_ISO_PLANE_CHARSET (coding, 0))      \
+      {                                                                 \
+        *dst++ = c1 & 0x7F, *dst++= c2 & 0x7F;                          \
+        break;                                                          \
+      }                                                                 \
+    else if (charset == CODING_SPEC_ISO_PLANE_CHARSET (coding, 1))      \
+      {                                                                 \
+        *dst++ = c1 | 0x80, *dst++= c2 | 0x80;                          \
+        break;                                                          \
+      }                                                                 \
+    else                                                                \
+      /* Since CHARSET is not yet invoked to any graphic planes, we     \
+         must invoke it, or, at first, designate it to some graphic     \
+         register.  Then repeat the loop to actually produce the        \
+         character.  */                                                 \
+      dst = encode_invocation_designation (charset, coding, dst);       \
+  } while (1)
+
+/* 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.  */
+
+unsigned char *
+encode_invocation_designation (charset, coding, dst)
+     int charset;
+     struct coding_system *coding;
+     unsigned char *dst;
+{
+  int reg;                      /* graphic register number */
+
+  /* At first, check designations.  */
+  for (reg = 0; reg < 4; reg++)
+    if (charset == CODING_SPEC_ISO_DESIGNATION (coding, reg))
+      break;
+
+  if (reg >= 4)
+    {
+      /* CHARSET is not yet designated to any graphic registers.  */
+      /* At first check the requested designation.  */
+      reg = CODING_SPEC_ISO_REQUESTED_DESIGNATION (coding, charset);
+      if (reg < 0)
+        /* Since CHARSET requests no special designation, designate to
+           graphic register 0.  */
+        reg = 0;
+
+      ENCODE_DESIGNATION (charset, reg, coding);
+    }
+
+  if (CODING_SPEC_ISO_INVOCATION (coding, 0) != reg
+      && CODING_SPEC_ISO_INVOCATION (coding, 1) != reg)
+    {
+      /* Since the graphic register REG is not invoked to any graphic
+         planes, invoke it to graphic plane 0.  */
+      switch (reg)
+        {
+        case 0:                 /* graphic register 0 */
+          ENCODE_SHIFT_IN;
+          break;
+
+        case 1:                 /* graphic register 1 */
+          ENCODE_SHIFT_OUT;
+          break;
+
+        case 2:                 /* graphic register 2 */
+          if (coding->flags & CODING_FLAG_ISO_SINGLE_SHIFT)
+            ENCODE_SINGLE_SHIFT_2;
+          else
+            ENCODE_LOCKING_SHIFT_2;
+          break;
+
+        case 3:                 /* graphic register 3 */
+          if (coding->flags & CODING_FLAG_ISO_SINGLE_SHIFT)
+            ENCODE_SINGLE_SHIFT_3;
+          else
+            ENCODE_LOCKING_SHIFT_3;
+          break;
+        }
+    }
+  return dst;
+}
+
+/* The following two macros produce codes for indicating composition.  */
+#define ENCODE_COMPOSITION_NO_RULE_START  *dst++ = ISO_CODE_ESC, *dst++ = '0'
+#define ENCODE_COMPOSITION_WITH_RULE_START  *dst++ = ISO_CODE_ESC, *dst++ = '2'
+#define ENCODE_COMPOSITION_END    *dst++ = ISO_CODE_ESC, *dst++ = '1'
+
+/* The following three macros produce codes for indicating direction
+   of text.  */
+#define ENCODE_CONTROL_SEQUENCE_INTRODUCER              \
+  do {                                                  \
+    if (coding->flags == CODING_FLAG_ISO_SEVEN_BITS)    \
+      *dst++ = ISO_CODE_ESC, *dst++ = '[';              \
+    else                                                \
+      *dst++ = ISO_CODE_CSI;                            \
+  } while (0)
+
+#define ENCODE_DIRECTION_R2L    \
+  ENCODE_CONTROL_SEQUENCE_INTRODUCER, *dst++ = '2', *dst++ = ']'
+
+#define ENCODE_DIRECTION_L2R    \
+  ENCODE_CONTROL_SEQUENCE_INTRODUCER, *dst++ = '0', *dst++ = ']'
+
+/* Produce codes for designation and invocation to reset the graphic
+   planes and registers to initial state.  */
+#define ENCODE_RESET_PLANE_AND_REGISTER(eol)                                  \
+  do {                                                                        \
+    int reg;                                                                  \
+    if (CODING_SPEC_ISO_INVOCATION (coding, 0) != 0)                          \
+      ENCODE_SHIFT_IN;                                                        \
+    for (reg = 0; reg < 4; reg++)                                             \
+      {                                                                       \
+        if (CODING_SPEC_ISO_INITIAL_DESIGNATION (coding, reg) < 0)            \
+          {                                                                   \
+            if (eol) CODING_SPEC_ISO_DESIGNATION (coding, reg) = -1;          \
+          }                                                                   \
+        else if (CODING_SPEC_ISO_DESIGNATION (coding, reg)                    \
+                 != CODING_SPEC_ISO_INITIAL_DESIGNATION (coding, reg))        \
+          ENCODE_DESIGNATION                                                  \
+            (CODING_SPEC_ISO_INITIAL_DESIGNATION (coding, reg), reg, coding); \
+      }                                                                       \
+  } while (0)
+
+/* See the above "GENERAL NOTES on `encode_coding_XXX ()' functions".  */
+
+int
+encode_coding_iso2022 (coding, source, destination,
+                       src_bytes, dst_bytes, consumed)
+     struct coding_system *coding;
+     unsigned char *source, *destination;
+     int src_bytes, dst_bytes;
+     int *consumed;
+{
+  unsigned char *src = source;
+  unsigned char *src_end = source + src_bytes;
+  unsigned char *dst = destination;
+  unsigned char *dst_end = destination + dst_bytes;
+  /* Since the maximum bytes produced by each loop is 6, we subtract 5
+     from DST_END to assure overflow checking is necessary only at the
+     head of loop.  */
+  unsigned char *adjusted_dst_end = dst_end - 5;
+
+  while (src < src_end && dst < adjusted_dst_end)
+    {
+      /* SRC_BASE remembers the start position in source in each loop.
+         The loop will be exited when there's not enough source text
+         to analyze multi-byte codes (within macros ONE_MORE_BYTE,
+         TWO_MORE_BYTES, and THREE_MORE_BYTES).  In that case, SRC is
+         reset to SRC_BASE before exiting.  */
+      unsigned char *src_base = src;
+      unsigned char c1 = *src++, c2, c3, c4;
+      int charset;
+
+      /* If we are seeing a component of a composite character, we are
+         seeing a leading-code specially encoded for composition, or a
+         composition rule if composing with rule.  We must set C1
+         to a normal leading-code or an ASCII code.  If we are not at
+         a composed character, we must reset the composition state.  */
+      if (COMPOSING_P (coding->composing))
+        {
+          if (c1 < 0xA0)
+            {
+              /* We are not in a composite character any longer.  */
+              coding->composing = COMPOSING_NO;
+              ENCODE_COMPOSITION_END;
+            }
+          else
+            {
+              if (coding->composing == COMPOSING_WITH_RULE_RULE)
+                {
+                  *dst++ = c1 & 0x7F;
+                  coding->composing = COMPOSING_WITH_RULE_HEAD;
+                  continue;
+                }
+              else if (coding->composing == COMPOSING_WITH_RULE_HEAD)
+                coding->composing = COMPOSING_WITH_RULE_RULE;
+              if (c1 == 0xA0)
+                {
+                  /* This is an ASCII component.  */
+                  ONE_MORE_BYTE (c1);
+                  c1 &= 0x7F;
+                }
+              else
+                /* This is a leading-code of non ASCII component.  */
+                c1 -= 0x20;
+            }
+        }
+        
+      /* Now encode one character.  C1 is a control character, an
+         ASCII character, or a leading-code of multi-byte character.  */
+      switch (emacs_code_class[c1])
+        {
+        case EMACS_ascii_code:
+          ENCODE_ISO_CHARACTER_DIMENSION1 (CHARSET_ASCII, c1);
+          break;
+
+        case EMACS_control_code:
+          if (coding->flags & CODING_FLAG_ISO_RESET_AT_CNTL)
+            ENCODE_RESET_PLANE_AND_REGISTER (0);
+          *dst++ = c1;
+          break;
+
+        case EMACS_carriage_return_code:
+          if (!coding->selective)
+            {
+              if (coding->flags & CODING_FLAG_ISO_RESET_AT_CNTL)
+                ENCODE_RESET_PLANE_AND_REGISTER (0);
+              *dst++ = c1;
+              break;
+            }
+          /* fall down to treat '\r' as '\n' ...  */
+
+        case EMACS_linefeed_code:
+          if (coding->flags & CODING_FLAG_ISO_RESET_AT_EOL)
+            ENCODE_RESET_PLANE_AND_REGISTER (1);
+          if (coding->eol_type == CODING_EOL_LF
+              || coding->eol_type == CODING_EOL_AUTOMATIC)
+            *dst++ = ISO_CODE_LF;
+          else if (coding->eol_type == CODING_EOL_CRLF)
+            *dst++ = ISO_CODE_CR, *dst++ = ISO_CODE_LF;
+          else
+            *dst++ = ISO_CODE_CR;
+          break;
+
+        case EMACS_leading_code_2:
+          ONE_MORE_BYTE (c2);
+          ENCODE_ISO_CHARACTER_DIMENSION1 (c1, c2);
+          break;
+
+        case EMACS_leading_code_3:
+          TWO_MORE_BYTES (c2, c3);
+          if (c1 < LEADING_CODE_PRIVATE_11)
+            ENCODE_ISO_CHARACTER_DIMENSION2 (c1, c2, c3);
+          else
+            ENCODE_ISO_CHARACTER_DIMENSION1 (c2, c3);
+          break;
+
+        case EMACS_leading_code_4:
+          THREE_MORE_BYTES (c2, c3, c4);
+          ENCODE_ISO_CHARACTER_DIMENSION2 (c2, c3, c4);
+          break;
+
+        case EMACS_leading_code_composition:
+          ONE_MORE_BYTE (c1);
+          if (c1 == 0xFF)
+            {
+              coding->composing = COMPOSING_WITH_RULE_HEAD;
+              ENCODE_COMPOSITION_WITH_RULE_START;
+            }
+          else
+            {
+              /* Rewind one byte because it is a character code of
+                 composition elements.  */
+              src--;
+              coding->composing = COMPOSING_NO_RULE_HEAD;
+              ENCODE_COMPOSITION_NO_RULE_START;
+            }
+          break;
+
+        case EMACS_invalid_code:
+          *dst++ = c1;
+          break;
+        }
+      continue;
+    label_end_of_loop:
+      coding->carryover_size = src - src_base;
+      bcopy (src_base, coding->carryover, coding->carryover_size);
+      src = src_base;
+      break;
+    }
+
+  /* If this is the last block of the text to be encoded, we must
+     reset the state of graphic planes and registers to initial one.
+     In addition, we had better just flush out all remaining codes in
+     the text although they are not valid characters.  */
+  if (coding->last_block)
+    {
+      ENCODE_RESET_PLANE_AND_REGISTER (1);
+      bcopy(src, dst, src_end - src);
+      dst += (src_end - src);
+      src = src_end;
+    }
+  *consumed = src - source;
+  return dst - destination;
+}
+
+
+/*** 4. SJIS and BIG5 handlers ***/
+
+/* Although SJIS and BIG5 are not ISO's coding system, They are used
+   quite widely.  So, for the moment, Emacs supports them in the bare
+   C code.  But, in the future, they may be supported only by CCL.  */
+
+/* SJIS is a coding system encoding three character sets: ASCII, right
+   half of JISX0201-Kana, and JISX0208.  An ASCII character is encoded
+   as is.  A character of charset katakana-jisx0201 is encoded by
+   "position-code + 0x80".  A character of charset japanese-jisx0208
+   is encoded in 2-byte but two position-codes are divided and shifted
+   so that it fit in the range below.
+
+   --- CODE RANGE of SJIS ---
+   (character set)      (range)
+   ASCII                0x00 .. 0x7F
+   KATAKANA-JISX0201    0xA0 .. 0xDF
+   JISX0208 (1st byte)  0x80 .. 0x9F and 0xE0 .. 0xFF
+            (2nd byte)  0x40 .. 0xFF
+   -------------------------------
+
+*/
+
+/* BIG5 is a coding system encoding two character sets: ASCII and
+   Big5.  An ASCII character is encoded as is.  Big5 is a two-byte
+   character set and is encoded in two-byte.
+
+   --- CODE RANGE of BIG5 ---
+   (character set)      (range)
+   ASCII                0x00 .. 0x7F
+   Big5 (1st byte)      0xA1 .. 0xFE
+        (2nd byte)      0x40 .. 0x7E and 0xA1 .. 0xFE
+   --------------------------
+
+   Since the number of characters in Big5 is larger than maximum
+   characters in Emacs' charset (96x96), it can't be handled as one
+   charset.  So, in Emacs, Big5 is divided into two: `charset-big5-1'
+   and `charset-big5-2'.  Both are DIMENSION2 and CHARS94.  The former
+   contains frequently used characters and the latter contains less
+   frequently used characters.  */
+
+/* Macros to decode or encode a character of Big5 in BIG5.  B1 and B2
+   are the 1st and 2nd position-codes of Big5 in BIG5 coding system.
+   C1 and C2 are the 1st and 2nd position-codes of of Emacs' internal
+   format.  CHARSET is `charset_big5_1' or `charset_big5_2'.  */
+
+/* Number of Big5 characters which have the same code in 1st byte.  */
+#define BIG5_SAME_ROW (0xFF - 0xA1 + 0x7F - 0x40)
+
+#define DECODE_BIG5(b1, b2, charset, c1, c2)                            \
+  do {                                                                  \
+    unsigned int temp                                                   \
+      = (b1 - 0xA1) * BIG5_SAME_ROW + b2 - (b2 < 0x7F ? 0x40 : 0x62);   \
+    if (b1 < 0xC9)                                                      \
+      charset = charset_big5_1;                                         \
+    else                                                                \
+      {                                                                 \
+        charset = charset_big5_2;                                       \
+        temp -= (0xC9 - 0xA1) * BIG5_SAME_ROW;                          \
+      }                                                                 \
+    c1 = temp / (0xFF - 0xA1) + 0x21;                                   \
+    c2 = temp % (0xFF - 0xA1) + 0x21;                                   \
+  } while (0)
+
+#define ENCODE_BIG5(charset, c1, c2, b1, b2)                            \
+  do {                                                                  \
+    unsigned int temp = (c1 - 0x21) * (0xFF - 0xA1) + (c2 - 0x21);      \
+    if (charset == charset_big5_2)                                      \
+      temp += BIG5_SAME_ROW * (0xC9 - 0xA1);                            \
+    b1 = temp / BIG5_SAME_ROW + 0xA1;                                   \
+    b2 = temp % BIG5_SAME_ROW;                                          \
+    b2 += b2 < 0x3F ? 0x40 : 0x62;                                      \
+  } while (0)
+
+/* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
+   Check if a text is encoded in SJIS.  If it is, return
+   CODING_CATEGORY_MASK_SJIS, else return 0.  */
+
+int
+detect_coding_sjis (src, src_end)
+     unsigned char *src, *src_end;
+{
+  unsigned char c;
+
+  while (src < src_end)
+    {
+      c = *src++;
+      if (c == ISO_CODE_ESC || c == ISO_CODE_SI || c == ISO_CODE_SO)
+        return 0;
+      if ((c >= 0x80 && c < 0xA0) || c >= 0xE0)
+        {
+          if (src < src_end && *src++ < 0x40)
+            return 0;
+        }
+    }
+  return CODING_CATEGORY_MASK_SJIS;
+}
+
+/* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions".
+   Check if a text is encoded in BIG5.  If it is, return
+   CODING_CATEGORY_MASK_BIG5, else return 0.  */
+
+int
+detect_coding_big5 (src, src_end)
+     unsigned char *src, *src_end;
+{
+  unsigned char c;
+
+  while (src < src_end)
+    {
+      c = *src++;
+      if (c == ISO_CODE_ESC || c == ISO_CODE_SI || c == ISO_CODE_SO)
+        return 0;
+      if (c >= 0xA1)
+        {
+          if (src >= src_end)
+            break;
+          c = *src++;
+          if (c < 0x40 || (c >= 0x7F && c <= 0xA0))
+            return 0;
+        }
+    }
+  return CODING_CATEGORY_MASK_BIG5;
+}
+
+/* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions".
+   If SJIS_P is 1, decode SJIS text, else decode BIG5 test.  */
+
+int
+decode_coding_sjis_big5 (coding, source, destination,
+                         src_bytes, dst_bytes, consumed, sjis_p)
+     struct coding_system *coding;
+     unsigned char *source, *destination;
+     int src_bytes, dst_bytes;
+     int *consumed;
+     int sjis_p;
+{
+  unsigned char *src = source;
+  unsigned char *src_end = source + src_bytes;
+  unsigned char *dst = destination;
+  unsigned char *dst_end = destination + dst_bytes;
+  /* Since the maximum bytes produced by each loop is 4, we subtract 3
+     from DST_END to assure overflow checking is necessary only at the
+     head of loop.  */
+  unsigned char *adjusted_dst_end = dst_end - 3;
+
+  while (src < src_end && dst < adjusted_dst_end)
+    {
+      /* SRC_BASE remembers the start position in source in each loop.
+         The loop will be exited when there's not enough source text
+         to analyze two-byte character (within macro ONE_MORE_BYTE).
+         In that case, SRC is reset to SRC_BASE before exiting.  */
+      unsigned char *src_base = src;
+      unsigned char c1 = *src++, c2, c3, c4;
+
+      if (c1 == '\r')
+        {
+          if (coding->eol_type == CODING_EOL_CRLF)
+            {
+              ONE_MORE_BYTE (c2);
+              if (c2 == '\n')
+                *dst++ = c2;
+              else
+                /* To process C2 again, SRC is subtracted by 1.  */
+                *dst++ = c1, src--;
+            }
+          else
+            *dst++ = c1;
+        }
+      else if (c1 < 0x80)
+        *dst++ = c1;
+      else if (c1 < 0xA0 || c1 >= 0xE0)
+        {
+          /* SJIS -> JISX0208, BIG5 -> Big5 (only if 0xE0 <= c1 < 0xFF) */
+          if (sjis_p)
+            {
+              ONE_MORE_BYTE (c2);
+              DECODE_SJIS (c1, c2, c3, c4);
+              DECODE_CHARACTER_DIMENSION2 (charset_jisx0208, c3, c4);
+            }
+          else if (c1 >= 0xE0 && c1 < 0xFF)
+            {
+              int charset;
+
+              ONE_MORE_BYTE (c2);
+              DECODE_BIG5 (c1, c2, charset, c3, c4);
+              DECODE_CHARACTER_DIMENSION2 (charset, c3, c4);
+            }
+          else                  /* Invalid code */
+            *dst++ = c1;
+        }
+      else
+        {
+          /* SJIS -> JISX0201-Kana, BIG5 -> Big5 */
+          if (sjis_p)
+            DECODE_CHARACTER_DIMENSION1 (charset_katakana_jisx0201, c1);
+          else
+            {
+              int charset;
+
+              ONE_MORE_BYTE (c2);
+              DECODE_BIG5 (c1, c2, charset, c3, c4);
+              DECODE_CHARACTER_DIMENSION2 (charset, c3, c4);
+            }
+        }
+      continue;
+
+    label_end_of_loop:
+      coding->carryover_size = src - src_base;
+      bcopy (src_base, coding->carryover, coding->carryover_size);
+      src = src_base;
+      break;
+    }
+
+  *consumed = src - source;
+  return dst - destination;
+}
+
+/* See the above "GENERAL NOTES on `encode_coding_XXX ()' functions".
+   This function can encode `charset_ascii', `charset_katakana_jisx0201',
+   `charset_jisx0208', `charset_big5_1', and `charset_big5-2'.  We are
+   sure that all these charsets are registered as official charset
+   (i.e. do not have extended leading-codes).  Characters of other
+   charsets are produced without any encoding.  If SJIS_P is 1, encode
+   SJIS text, else encode BIG5 text.  */
+
+int
+encode_coding_sjis_big5 (coding, source, destination,
+                         src_bytes, dst_bytes, consumed, sjis_p)
+     struct coding_system *coding;
+     unsigned char *source, *destination;
+     int src_bytes, dst_bytes;
+     int *consumed;
+     int sjis_p;
+{
+  unsigned char *src = source;
+  unsigned char *src_end = source + src_bytes;
+  unsigned char *dst = destination;
+  unsigned char *dst_end = destination + dst_bytes;
+  /* Since the maximum bytes produced by each loop is 2, we subtract 1
+     from DST_END to assure overflow checking is necessary only at the
+     head of loop.  */
+  unsigned char *adjusted_dst_end = dst_end - 1;
+
+  while (src < src_end && dst < adjusted_dst_end)
+    {
+      /* SRC_BASE remembers the start position in source in each loop.
+         The loop will be exited when there's not enough source text
+         to analyze multi-byte codes (within macros ONE_MORE_BYTE and
+         TWO_MORE_BYTES).  In that case, SRC is reset to SRC_BASE
+         before exiting.  */
+      unsigned char *src_base = src;
+      unsigned char c1 = *src++, c2, c3, c4;
+
+      if (coding->composing)
+        {
+          if (c1 == 0xA0)
+            {
+              ONE_MORE_BYTE (c1);
+              c1 &= 0x7F;
+            }
+          else if (c1 >= 0xA0)
+            c1 -= 0x20;
+          else
+            coding->composing = 0;
+        }
+
+      switch (emacs_code_class[c1])
+        {
+        case EMACS_ascii_code:
+        case EMACS_control_code:
+          *dst++ = c1;
+          break;
+
+        case EMACS_carriage_return_code:
+          if (!coding->selective)
+            {
+              *dst++ = c1;
+              break;
+            }
+          /* fall down to treat '\r' as '\n' ...  */
+
+        case EMACS_linefeed_code:
+          if (coding->eol_type == CODING_EOL_LF
+              || coding->eol_type == CODING_EOL_AUTOMATIC)
+            *dst++ = '\n';
+          else if (coding->eol_type == CODING_EOL_CRLF)
+            *dst++ = '\r', *dst++ = '\n';
+          else
+            *dst++ = '\r';
+          break;
+
+        case EMACS_leading_code_2:
+          ONE_MORE_BYTE (c2);
+          if (sjis_p && c1 == charset_katakana_jisx0201)
+            *dst++ = c2;
+          else
+            *dst++ = c1, *dst++ = c2;
+          break;
+
+        case EMACS_leading_code_3:
+          TWO_MORE_BYTES (c2, c3);
+          c2 &= 0x7F, c3 &= 0x7F;
+          if (sjis_p && c1 == charset_jisx0208)
+            {
+              unsigned char s1, s2;
+
+              ENCODE_SJIS (c2, c3, s1, s2);
+              *dst++ = s1, *dst++ = s2;
+            }
+          else if (!sjis_p && (c1 == charset_big5_1 || c1 == charset_big5_2))
+            {
+              unsigned char b1, b2;
+
+              ENCODE_BIG5 (c1, c2, c3, b1, b2);
+              *dst++ = b1, *dst++ = b2;
+            }
+          else
+            *dst++ = c1, *dst++ = c2, *dst++ = c3;
+          break;
+
+        case EMACS_leading_code_4:
+          THREE_MORE_BYTES (c2, c3, c4);
+          *dst++ = c1, *dst++ = c2, *dst++ = c3, *dst++ = c4;
+          break;
+
+        case EMACS_leading_code_composition:
+          coding->composing = 1;
+          break;
+
+        default:                /* i.e. case EMACS_invalid_code: */
+          *dst++ = c1;
+        }
+      continue;
+
+    label_end_of_loop:
+      coding->carryover_size = src - src_base;
+      bcopy (src_base, coding->carryover, coding->carryover_size);
+      src = src_base;
+      break;
+    }
+
+  *consumed = src - source;
+  return dst - destination;
+}
+
+
+/*** 5. End-of-line handlers ***/
+
+/* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions".
+   This function is called only when `coding->eol_type' is
+   CODING_EOL_CRLF or CODING_EOL_CR.  */
+
+decode_eol (coding, source, destination, src_bytes, dst_bytes, consumed)
+     struct coding_system *coding;
+     unsigned char *source, *destination;
+     int src_bytes, dst_bytes;
+     int *consumed;
+{
+  unsigned char *src = source;
+  unsigned char *src_end = source + src_bytes;
+  unsigned char *dst = destination;
+  unsigned char *dst_end = destination + dst_bytes;
+  int produced;
+
+  switch (coding->eol_type)
+    {
+    case CODING_EOL_CRLF:
+      {
+        /* Since the maximum bytes produced by each loop is 2, we
+           subtract 1 from DST_END to assure overflow checking is
+           necessary only at the head of loop.  */
+        unsigned char *adjusted_dst_end = dst_end - 1;
+
+        while (src < src_end && dst < adjusted_dst_end)
+          {
+            unsigned char *src_base = src;
+            unsigned char c = *src++;
+            if (c == '\r')
+              {
+                ONE_MORE_BYTE (c);
+                if (c != '\n')
+                  *dst++ = '\r';
+
+              }
+            else
+              *dst++ = c;
+            continue;
+
+          label_end_of_loop:
+            coding->carryover_size = src - src_base;
+            bcopy (src_base, coding->carryover, coding->carryover_size);
+            src = src_base;
+            break;
+          }
+        *consumed = src - source;
+        produced = dst - destination;
+        break;
+      }
+
+    case CODING_EOL_CR:
+      produced = (src_bytes > dst_bytes) ? dst_bytes : src_bytes;
+      bcopy (source, destination, produced);
+      dst_end = destination + produced;
+      while (dst < dst_end)
+        if (*dst++ == '\r') dst[-1] = '\n';
+      *consumed = produced;
+      break;
+
+    default:                    /* i.e. case: CODING_EOL_LF */
+      produced = (src_bytes > dst_bytes) ? dst_bytes : src_bytes;
+      bcopy (source, destination, produced);
+      *consumed = produced;
+      break;
+    }
+
+  return produced;
+}
+
+/* See "GENERAL NOTES about `encode_coding_XXX ()' functions".  Encode
+   format of end-of-line according to `coding->eol_type'.  If
+   `coding->selective' is 1, code '\r' in source text also means
+   end-of-line.  */
+
+encode_eol (coding, source, destination, src_bytes, dst_bytes, consumed)
+     struct coding_system *coding;
+     unsigned char *source, *destination;
+     int src_bytes, dst_bytes;
+     int *consumed;
+{
+  unsigned char *src = source;
+  unsigned char *dst = destination;
+  int produced;
+
+  if (src_bytes <= 0)
+    return 0;
+
+  switch (coding->eol_type)
+    {
+    case CODING_EOL_LF:
+    case CODING_EOL_AUTOMATIC:
+      produced = (src_bytes > dst_bytes) ? dst_bytes : src_bytes;
+      bcopy (source, destination, produced);
+      if (coding->selective)
+        {
+          int i = produced;
+          while (i--)
+            if (*dst++ == '\r') dst[-1] = '\n';
+        }
+      *consumed = produced;
+      
+    case CODING_EOL_CRLF:
+      {
+        unsigned char c;
+        unsigned char *src_end = source + src_bytes;
+        unsigned char *dst_end = destination + dst_bytes;
+        /* Since the maximum bytes produced by each loop is 2, we
+           subtract 1 from DST_END to assure overflow checking is
+           necessary only at the head of loop.  */
+        unsigned char *adjusted_dst_end = dst_end - 1;
+
+        while (src < src_end && dst < adjusted_dst_end)
+          {
+            c = *src++;
+            if (c == '\n' || (c == '\r' && coding->selective))
+              *dst++ = '\r', *dst++ = '\n';
+            else
+              *dst++ = c;
+          }
+        produced = dst - destination;
+        *consumed = src - source;
+        break;
+      }
+
+    default:                    /* i.e. case CODING_EOL_CR: */
+      produced = (src_bytes > dst_bytes) ? dst_bytes : src_bytes;
+      bcopy (source, destination, produced);
+      {
+        int i = produced;
+        while (i--)
+          if (*dst++ == '\n') dst[-1] = '\r';
+      }
+      *consumed = produced;
+    }
+
+  return produced;
+}
+
+
+/*** 6. C library functions ***/
+
+/* In Emacs Lisp, coding system is represented by a Lisp symbol which
+   has a property `coding-system'.  The value of this property is a
+   vector of length 5 (called as coding-vector).  Among elements of
+   this vector, the first (element[0]) and the fifth (element[4])
+   carry important information for decoding/encoding.  Before
+   decoding/encoding, this information should be set in fields of a
+   structure of type `coding_system'.
+
+   A value of property `coding-system' can be a symbol of another
+   subsidiary coding-system.  In that case, Emacs gets coding-vector
+   from that symbol.
+
+   `element[0]' contains information to be set in `coding->type'.  The
+   value and its meaning is as follows:
+
+   0 -- coding_system_internal
+   1 -- coding_system_sjis
+   2 -- coding_system_iso2022
+   3 -- coding_system_big5
+   4 -- coding_system_ccl
+   nil -- coding_system_no_conversion
+   t -- coding_system_automatic
+
+   `element[4]' contains information to be set in `coding->flags' and
+   `coding->spec'.  The meaning varies by `coding->type'.
+
+   If `coding->type' is `coding_type_iso2022', element[4] is a vector
+   of length 32 (of which the first 13 sub-elements are used now).
+   Meanings of these sub-elements are:
+
+   sub-element[N] where N is 0 through 3: to be set in `coding->spec.iso2022'
+        If the value is an integer of valid charset, the charset is
+        assumed to be designated to graphic register N initially.
+
+        If the value is minus, it is a minus value of charset which
+        reserves graphic register N, which means that the charset is
+        not designated initially but should be designated to graphic
+        register N just before encoding a character in that charset.
+
+        If the value is nil, graphic register N is never used on
+        encoding.
+   
+   sub-element[N] where N is 4 through 11: to be set in `coding->flags'
+        Each value takes t or nil.  See the section ISO2022 of
+        `coding.h' for more information.
+
+   If `coding->type' is `coding_type_big5', element[4] is t to denote
+   BIG5-ETen or nil to denote BIG5-HKU.
+
+   If `coding->type' takes the other value, element[4] is ignored.
+
+   Emacs Lisp's coding system also carries information about format of
+   end-of-line in a value of property `eol-type'.  If the value is
+   integer, 0 means CODING_EOL_LF, 1 means CODING_EOL_CRLF, and 2
+   means CODING_EOL_CR.  If it is not integer, it should be a vector
+   of subsidiary coding systems of which property `eol-type' has one
+   of above values.
+
+*/
+
+/* Extract information for decoding/encoding from CODING_SYSTEM_SYMBOL
+   and set it in CODING.  If CODING_SYSTEM_SYMBOL is invalid, CODING
+   is setup so that no conversion is necessary and return -1, else
+   return 0.  */
+
+int
+setup_coding_system (coding_system_symbol, coding)
+     Lisp_Object coding_system_symbol;
+     struct coding_system *coding;
+{
+  Lisp_Object coding_system_vector = Qnil;
+  Lisp_Object type, eol_type;
+
+  /* At first, set several fields default values.  */
+  coding->require_flushing = 0;
+  coding->last_block = 0;
+  coding->selective = 0;
+  coding->composing = 0;
+  coding->direction = 0;
+  coding->carryover_size = 0;
+  coding->symbol = Qnil;
+  coding->post_read_conversion = coding->pre_write_conversion = Qnil;
+
+  /* Get value of property `coding-system'.  If it is a Lisp symbol
+     pointing another coding system, fetch its property until we get a
+     vector.  */
+  while (!NILP (coding_system_symbol))
+    {
+      coding->symbol = coding_system_symbol;
+      if (NILP (coding->post_read_conversion))
+        coding->post_read_conversion = Fget (coding_system_symbol,
+                                             Qpost_read_conversion);
+      if (NILP (coding->pre_write_conversion))
+        coding->pre_write_conversion = Fget (coding_system_symbol,
+                                             Qpre_write_conversion);
+
+      coding_system_vector = Fget (coding_system_symbol, Qcoding_system);
+      if (VECTORP (coding_system_vector))
+        break;
+      coding_system_symbol = coding_system_vector;
+    }
+  Vlast_coding_system_used = coding->symbol;
+
+  if (!VECTORP (coding_system_vector)
+      || XVECTOR (coding_system_vector)->size != 5)
+    goto label_invalid_coding_system;
+
+  /* Get value of property `eol-type' by searching from the root
+     coding-system.  */
+  coding_system_symbol = coding->symbol;
+  eol_type = Qnil;
+  while (SYMBOLP (coding_system_symbol) && !NILP (coding_system_symbol))
+    {
+      eol_type = Fget (coding_system_symbol, Qeol_type);
+      if (!NILP (eol_type))
+        break;
+      coding_system_symbol = Fget (coding_system_symbol, Qcoding_system);
+    }
+
+  if (VECTORP (eol_type))
+    coding->eol_type = CODING_EOL_AUTOMATIC;
+  else if (XFASTINT (eol_type) == 1)
+    coding->eol_type = CODING_EOL_CRLF;
+  else if (XFASTINT (eol_type) == 2)
+    coding->eol_type = CODING_EOL_CR;
+  else
+    coding->eol_type = CODING_EOL_LF;
+
+  type = XVECTOR (coding_system_vector)->contents[0];
+  switch (XFASTINT (type))
+    {
+    case 0:
+      coding->type = coding_type_internal;
+      break;
+
+    case 1:
+      coding->type = coding_type_sjis;
+      break;
+
+    case 2:
+      coding->type = coding_type_iso2022;
+      {
+        Lisp_Object val = XVECTOR (coding_system_vector)->contents[4];
+        Lisp_Object *flags;
+        int i, charset, default_reg_bits = 0;
+
+        if (!VECTORP (val) || XVECTOR (val)->size != 32)
+          goto label_invalid_coding_system;
+
+        flags = XVECTOR (val)->contents;
+        coding->flags
+          = ((NILP (flags[4]) ? 0 : CODING_FLAG_ISO_SHORT_FORM)
+             | (NILP (flags[5]) ? 0 : CODING_FLAG_ISO_RESET_AT_EOL)
+             | (NILP (flags[6]) ? 0 : CODING_FLAG_ISO_RESET_AT_CNTL)
+             | (NILP (flags[7]) ? 0 : CODING_FLAG_ISO_SEVEN_BITS)
+             | (NILP (flags[8]) ? 0 : CODING_FLAG_ISO_LOCKING_SHIFT)
+             | (NILP (flags[9]) ? 0 : CODING_FLAG_ISO_SINGLE_SHIFT)
+             | (NILP (flags[10]) ? 0 : CODING_FLAG_ISO_USE_ROMAN)
+             | (NILP (flags[11]) ? 0 : CODING_FLAG_ISO_USE_OLDJIS)
+             | (NILP (flags[12]) ? 0 : CODING_FLAG_ISO_NO_DIRECTION));
+
+        /* Invoke graphic register 0 to plane 0.  */
+        CODING_SPEC_ISO_INVOCATION (coding, 0) = 0;
+        /* Invoke graphic register 1 to plane 1 if we can use full 8-bit.  */
+        CODING_SPEC_ISO_INVOCATION (coding, 1)
+          = (coding->flags & CODING_FLAG_ISO_SEVEN_BITS ? -1 : 1);
+        /* Not single shifting at first.  */
+        CODING_SPEC_ISO_SINGLE_SHIFTING(coding) = 0;
+
+        /* Checks FLAGS[REG] (REG = 0, 1, 2 3) and decide designations.
+           FLAGS[REG] can be one of below:
+                integer CHARSET: CHARSET occupies register I,
+                t: designate nothing to REG initially, but can be used
+                  by any charsets,
+                list of integer, nil, or t: designate the first
+                  element (if integer) to REG initially, the remaining
+                  elements (if integer) is designated to REG on request,
+                  if an element is t, REG can be used by any charset,
+                nil: REG is never used.  */
+        for (charset = 0; charset < MAX_CHARSET; charset++)
+          CODING_SPEC_ISO_REQUESTED_DESIGNATION (coding, charset) = -1;
+        for (i = 0; i < 4; i++)
+          {
+            if (INTEGERP (flags[i])
+                && (charset = XINT (flags[i]), CHARSET_VALID_P (charset)))
+              {
+                CODING_SPEC_ISO_INITIAL_DESIGNATION (coding, i) = charset;
+                CODING_SPEC_ISO_REQUESTED_DESIGNATION (coding, charset) = i;
+              }
+            else if (EQ (flags[i], Qt))
+              {
+                CODING_SPEC_ISO_INITIAL_DESIGNATION (coding, i) = -1;
+                default_reg_bits |= 1 << i;
+              }
+            else if (CONSP (flags[i]))
+              {
+                Lisp_Object tail = flags[i];
+
+                if (INTEGERP (XCONS (tail)->car)
+                    && (charset = XINT (XCONS (tail)->car),
+                        CHARSET_VALID_P (charset)))
+                  {
+                    CODING_SPEC_ISO_INITIAL_DESIGNATION (coding, i) = charset;
+                    CODING_SPEC_ISO_REQUESTED_DESIGNATION (coding, charset) =i;
+                  }
+                else
+                  CODING_SPEC_ISO_INITIAL_DESIGNATION (coding, i) = -1;
+                tail = XCONS (tail)->cdr;
+                while (CONSP (tail))
+                  {
+                    if (INTEGERP (XCONS (tail)->car)
+                        && (charset = XINT (XCONS (tail)->car),
+                            CHARSET_VALID_P (charset)))
+                      CODING_SPEC_ISO_REQUESTED_DESIGNATION (coding, charset)
+                        = i;
+                    else if (EQ (XCONS (tail)->car, Qt))
+                      default_reg_bits |= 1 << i;
+                    tail = XCONS (tail)->cdr;
+                  }
+              }
+            else
+              CODING_SPEC_ISO_INITIAL_DESIGNATION (coding, i) = -1;
+            
+            CODING_SPEC_ISO_DESIGNATION (coding, i)
+              = CODING_SPEC_ISO_INITIAL_DESIGNATION (coding, i);
+          }
+
+        if (! (coding->flags & CODING_FLAG_ISO_LOCKING_SHIFT))
+          {
+            /* REG 1 can be used only by locking shift in 7-bit env.  */
+            if (coding->flags & CODING_FLAG_ISO_SEVEN_BITS)
+              default_reg_bits &= ~2;
+            if (! (coding->flags & CODING_FLAG_ISO_SINGLE_SHIFT))
+              /* Without any shifting, only REG 0 and 1 can be used.  */
+              default_reg_bits &= 3;
+          }
+
+        for (charset = 0; charset < MAX_CHARSET; charset++)
+          if (CHARSET_VALID_P (charset)
+              && CODING_SPEC_ISO_REQUESTED_DESIGNATION (coding, charset) < 0)
+            {
+              /* We have not yet decided where to designate CHARSET.  */
+              int reg_bits = default_reg_bits;
+
+              if (CHARSET_CHARS (charset) == 96)
+                /* A charset of CHARS96 can't be designated to REG 0.  */
+                reg_bits &= ~1;
+
+              if (reg_bits)
+                /* There exist some default graphic register.  */
+                CODING_SPEC_ISO_REQUESTED_DESIGNATION (coding, charset)
+                  = (reg_bits & 1
+                     ? 0 : (reg_bits & 2 ? 1 : (reg_bits & 4 ? 2 : 3)));
+              else
+                /* We anyway have to designate CHARSET to somewhere.  */
+                CODING_SPEC_ISO_REQUESTED_DESIGNATION (coding, charset)
+                  = (CHARSET_CHARS (charset) == 94
+                     ? 0
+                     : ((coding->flags & CODING_FLAG_ISO_LOCKING_SHIFT
+                         || ! coding->flags & CODING_FLAG_ISO_SEVEN_BITS)
+                        ? 1
+                        : (coding->flags & CODING_FLAG_ISO_SINGLE_SHIFT
+                           ? 2 : 0)));
+            }
+      }
+      coding->require_flushing = 1;
+      break;
+
+    case 3:
+      coding->type = coding_type_big5;
+      coding->flags
+        = (NILP (XVECTOR (coding_system_vector)->contents[4])
+           ? CODING_FLAG_BIG5_HKU
+           : CODING_FLAG_BIG5_ETEN);
+      break;
+
+    case 4:
+      coding->type = coding_type_ccl;
+      {
+        Lisp_Object val = XVECTOR (coding_system_vector)->contents[4];
+        if (CONSP  (val)
+            && VECTORP (XCONS (val)->car)
+            && VECTORP (XCONS (val)->cdr))
+          {
+            setup_ccl_program (&(coding->spec.ccl.decoder), XCONS (val)->car);
+            setup_ccl_program (&(coding->spec.ccl.encoder), XCONS (val)->cdr);
+          }
+        else
+          goto label_invalid_coding_system;
+      }
+      coding->require_flushing = 1;
+      break;
+
+    default:
+      if (EQ (type, Qt))
+        coding->type = coding_type_automatic;
+      else
+        coding->type = coding_type_no_conversion;
+      break;
+    }
+  return 0;
+
+ label_invalid_coding_system:
+  coding->type = coding_type_no_conversion;
+  return -1;
+}
+
+/* Emacs has a mechanism to automatically detect a coding system if it
+   is one of Emacs' internal format, ISO2022, SJIS, and BIG5.  But,
+   it's impossible to distinguish some coding systems accurately
+   because they use the same range of codes.  So, at first, coding
+   systems are categorized into 7, those are:
+
+   o coding-category-internal
+
+        The category for a coding system which has the same code range
+        as Emacs' internal format.  Assigned the coding-system (Lisp
+        symbol) `coding-system-internal' by default.
+
+   o coding-category-sjis
+
+        The category for a coding system which has the same code range
+        as SJIS.  Assigned the coding-system (Lisp
+        symbol) `coding-system-sjis' by default.
+
+   o coding-category-iso-7
+
+        The category for a coding system which has the same code range
+        as ISO2022 of 7-bit environment.  Assigned the coding-system
+        (Lisp symbol) `coding-system-junet' by default.
+
+   o coding-category-iso-8-1
+
+        The category for a coding system which has the same code range
+        as ISO2022 of 8-bit environment and graphic plane 1 used only
+        for DIMENSION1 charset.  Assigned the coding-system (Lisp
+        symbol) `coding-system-ctext' by default.
+
+   o coding-category-iso-8-2
+
+        The category for a coding system which has the same code range
+        as ISO2022 of 8-bit environment and graphic plane 1 used only
+        for DIMENSION2 charset.  Assigned the coding-system (Lisp
+        symbol) `coding-system-euc-japan' by default.
+
+   o coding-category-iso-else
+
+        The category for a coding system which has the same code range
+        as ISO2022 but not belongs to any of the above three
+        categories.  Assigned the coding-system (Lisp symbol)
+        `coding-system-iso-2022-ss2-7' by default.
+
+   o coding-category-big5
+
+        The category for a coding system which has the same code range
+        as BIG5.  Assigned the coding-system (Lisp symbol)
+        `coding-system-big5' by default.
+
+   o coding-category-binary
+
+        The category for a coding system not categorized in any of the
+        above.  Assigned the coding-system (Lisp symbol)
+        `coding-system-noconv' by default.
+
+   Each of them is a Lisp symbol and the value is an actual
+   `coding-system's (this is also a Lisp symbol) assigned by a user.
+   What Emacs does actually is to detect a category of coding system.
+   Then, it uses a `coding-system' assigned to it.  If Emacs can't
+   decide only one possible category, it selects a category of the
+   highest priority.  Priorities of categories are also specified by a
+   user in a Lisp variable `coding-category-list'.
+
+*/
+
+/* Detect how a text of length SRC_BYTES pointed by SRC is encoded.
+   If it detects possible coding systems, return an integer in which
+   appropriate flag bits are set.  Flag bits are defined by macros
+   CODING_CATEGORY_MASK_XXX in `coding.h'.  */
+
+int
+detect_coding_mask (src, src_bytes)
+     unsigned char *src;
+     int src_bytes;
+{
+  register unsigned char c;
+  unsigned char *src_end = src + src_bytes;
+  int mask;
+
+  /* At first, skip all ASCII characters and control characters except
+     for three ISO2022 specific control characters.  */
+  while (src < src_end)
+    {
+      c = *src;
+      if (c >= 0x80
+          || (c == ISO_CODE_ESC || c == ISO_CODE_SI || c == ISO_CODE_SO))
+        break;
+      src++;
+    }
+
+  if (src >= src_end)
+    /* We found nothing other than ASCII.  There's nothing to do.  */
+    return CODING_CATEGORY_MASK_ANY;
+
+  /* The text seems to be encoded in some multilingual coding system.
+     Now, try to find in which coding system the text is encoded.  */
+  if (c < 0x80)
+    /* i.e. (c == ISO_CODE_ESC || c == ISO_CODE_SI || c == ISO_CODE_SO) */
+    /* C is an ISO2022 specific control code of C0.  */
+    mask = detect_coding_iso2022 (src, src_end);
+
+  else if (c == ISO_CODE_SS2 || c == ISO_CODE_SS3 || c == ISO_CODE_CSI)
+    /* C is an ISO2022 specific control code of C1,
+       or the first byte of SJIS's 2-byte character code,
+       or a leading code of Emacs.  */
+    mask = (detect_coding_iso2022 (src, src_end)
+            | detect_coding_sjis (src, src_end)
+            | detect_coding_internal (src, src_end));
+
+  else if (c < 0xA0)
+    /* C is the first byte of SJIS character code,
+       or a leading-code of Emacs.  */
+    mask = (detect_coding_sjis (src, src_end)
+            | detect_coding_internal (src, src_end));
+
+  else
+    /* C is a character of ISO2022 in graphic plane right,
+       or a SJIS's 1-byte character code (i.e. JISX0201),
+       or the first byte of BIG5's 2-byte code.  */
+    mask = (detect_coding_iso2022 (src, src_end)
+            | detect_coding_sjis (src, src_end)
+            | detect_coding_big5 (src, src_end));
+
+  return mask;
+}
+
+/* Detect how a text of length SRC_BYTES pointed by SRC is encoded.
+   The information of the detected coding system is set in CODING.  */
+
+void
+detect_coding (coding, src, src_bytes)
+     struct coding_system *coding;
+     unsigned char *src;
+     int src_bytes;
+{
+  int mask = detect_coding_mask (src, src_bytes);
+  int idx;
+
+  if (mask == CODING_CATEGORY_MASK_ANY)
+    /* We found nothing other than ASCII.  There's nothing to do.  */
+    return;
+
+  if (!mask)
+    /* The source text seems to be encoded in unknown coding system.
+       Emacs regards the category of such a kind of coding system as
+       `coding-category-binary'.  We assume that a user has assigned
+       an appropriate coding system for a `coding-category-binary'.  */
+    idx = CODING_CATEGORY_IDX_BINARY;
+  else
+    {
+      /* We found some plausible coding systems.  Let's use a coding
+         system of the highest priority.  */
+      Lisp_Object val = Vcoding_category_list;
+
+      if (CONSP (val))
+        while (!NILP (val))
+          {
+            idx = XFASTINT (Fget (XCONS (val)->car, Qcoding_category_index));
+            if ((idx < CODING_CATEGORY_IDX_MAX) && (mask & (1 << idx)))
+              break;
+            val = XCONS (val)->cdr;
+          }
+      else
+        val = Qnil;
+
+      if (NILP (val))
+        {
+          /* For unknown reason, `Vcoding_category_list' contains none
+             of found categories.  Let's use any of them.  */
+          for (idx = 0; idx < CODING_CATEGORY_IDX_MAX; idx++)
+            if (mask & (1 << idx))
+              break;
+        }
+    }
+  setup_coding_system (XSYMBOL (coding_category_table[idx])->value, coding);
+}
+
+/* Detect how end-of-line of a text of length SRC_BYTES pointed by SRC
+   is encoded.  Return one of CODING_EOL_LF, CODING_EOL_CRLF,
+   CODING_EOL_CR, and CODING_EOL_AUTOMATIC.  */
+
+int
+detect_eol_type (src, src_bytes)
+     unsigned char *src;
+     int src_bytes;
+{
+  unsigned char *src_end = src + src_bytes;
+  unsigned char c;
+
+  while (src < src_end)
+    {
+      c = *src++;
+      if (c == '\n')
+        return CODING_EOL_LF;
+      else if (c == '\r')
+        {
+          if (src < src_end && *src == '\n')
+            return CODING_EOL_CRLF;
+          else
+            return CODING_EOL_CR;
+        }
+    }
+  return CODING_EOL_AUTOMATIC;
+}
+
+/* Detect how end-of-line of a text of length SRC_BYTES pointed by SRC
+   is encoded.  If it detects an appropriate format of end-of-line, it
+   sets the information in *CODING.  */
+
+void
+detect_eol (coding, src, src_bytes)
+     struct coding_system *coding;
+     unsigned char *src;
+     int src_bytes;
+{
+  Lisp_Object val;
+  int eol_type = detect_eol_type (src, src_bytes);
+
+  if (eol_type == CODING_EOL_AUTOMATIC)
+    /*  We found no end-of-line in the source text.  */
+    return;
+
+  val = Fget (coding->symbol, Qeol_type);
+  if (VECTORP (val) && XVECTOR (val)->size == 3)
+    setup_coding_system (XVECTOR (val)->contents[eol_type], coding);
+}
+
+/* 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.  */
+
+int
+decode_coding (coding, source, destination, src_bytes, dst_bytes, consumed)
+     struct coding_system *coding;
+     unsigned char *source, *destination;
+     int src_bytes, dst_bytes;
+     int *consumed;
+{
+  int produced;
+
+  if (src_bytes <= 0)
+    {
+      *consumed = 0;
+      return 0;
+    }
+
+  if (coding->type == coding_type_automatic)
+    detect_coding (coding, source, src_bytes);
+
+  if (coding->eol_type == CODING_EOL_AUTOMATIC)
+    detect_eol (coding, source, src_bytes);
+
+  coding->carryover_size = 0;
+  switch (coding->type)
+    {
+    case coding_type_no_conversion:
+    label_no_conversion:
+      produced = (src_bytes > dst_bytes) ? dst_bytes : src_bytes;
+      bcopy (source, destination, produced);
+      *consumed = produced;
+      break;
+
+    case coding_type_internal:
+    case coding_type_automatic:
+      if (coding->eol_type == CODING_EOL_LF
+          ||  coding->eol_type == CODING_EOL_AUTOMATIC)
+        goto label_no_conversion;
+      produced = decode_eol (coding, source, destination,
+                             src_bytes, dst_bytes, consumed);
+      break;
+
+    case coding_type_sjis:
+      produced = decode_coding_sjis_big5 (coding, source, destination,
+                                          src_bytes, dst_bytes, consumed,
+                                          1);
+      break;
+
+    case coding_type_iso2022:
+      produced = decode_coding_iso2022 (coding, source, destination,
+                                        src_bytes, dst_bytes, consumed);
+      break;
+
+    case coding_type_big5:
+      produced = decode_coding_sjis_big5 (coding, source, destination,
+                                          src_bytes, dst_bytes, consumed,
+                                          0);
+      break;
+
+    case coding_type_ccl:
+      produced = ccl_driver (&coding->spec.ccl.decoder, source, destination,
+                             src_bytes, dst_bytes, consumed);
+      break;
+    }
+
+  return produced;
+}
+
+/* See "GENERAL NOTES about `encode_coding_XXX ()' functions".  */
+
+int
+encode_coding (coding, source, destination, src_bytes, dst_bytes, consumed)
+     struct coding_system *coding;
+     unsigned char *source, *destination;
+     int src_bytes, dst_bytes;
+     int *consumed;
+{
+  int produced;
+
+  coding->carryover_size = 0;
+  switch (coding->type)
+    {
+    case coding_type_no_conversion:
+    label_no_conversion:
+      produced = (src_bytes > dst_bytes) ? dst_bytes : src_bytes;
+      if (produced > 0)
+        {
+          bcopy (source, destination, produced);
+          if (coding->selective)
+            {
+              unsigned char *p = destination, *pend = destination + produced;
+              while (p < pend)
+                if (*p++ = '\015') p[-1] = '\n';
+            }
+        }
+      *consumed = produced;
+      break;
+
+    case coding_type_internal:
+    case coding_type_automatic:
+      if (coding->eol_type == CODING_EOL_LF
+          ||  coding->eol_type == CODING_EOL_AUTOMATIC)
+        goto label_no_conversion;
+      produced = encode_eol (coding, source, destination,
+                             src_bytes, dst_bytes, consumed);
+      break;
+
+    case coding_type_sjis:
+      produced = encode_coding_sjis_big5 (coding, source, destination,
+                                          src_bytes, dst_bytes, consumed,
+                                          1);
+      break;
+
+    case coding_type_iso2022:
+      produced = encode_coding_iso2022 (coding, source, destination,
+                                        src_bytes, dst_bytes, consumed);
+      break;
+
+    case coding_type_big5:
+      produced = encode_coding_sjis_big5 (coding, source, destination,
+                                          src_bytes, dst_bytes, consumed,
+                                          0);
+      break;
+
+    case coding_type_ccl:
+      produced = ccl_driver (&coding->spec.ccl.encoder, source, destination,
+                             src_bytes, dst_bytes, consumed);
+      break;
+    }
+
+  return produced;
+}
+
+#define CONVERSION_BUFFER_EXTRA_ROOM 256
+
+/* Return maximum size (bytes) of a buffer enough for decoding
+   SRC_BYTES of text encoded in CODING.  */
+
+int
+decoding_buffer_size (coding, src_bytes)
+     struct coding_system *coding;
+     int src_bytes;
+{
+  int magnification;
+
+  if (coding->type == coding_type_iso2022)
+    magnification = 3;
+  else if (coding->type == coding_type_ccl)
+    magnification = coding->spec.ccl.decoder.buf_magnification;
+  else
+    magnification = 2;
+
+  return (src_bytes * magnification + CONVERSION_BUFFER_EXTRA_ROOM);
+}
+
+/* Return maximum size (bytes) of a buffer enough for encoding
+   SRC_BYTES of text to CODING.  */
+
+int
+encoding_buffer_size (coding, src_bytes)
+     struct coding_system *coding;
+     int src_bytes;
+{
+  int magnification;
+
+  if (coding->type == coding_type_ccl)
+    magnification = coding->spec.ccl.encoder.buf_magnification;
+  else
+    magnification = 3;
+
+  return (src_bytes * magnification + CONVERSION_BUFFER_EXTRA_ROOM);
+}
+
+#ifndef MINIMUM_CONVERSION_BUFFER_SIZE
+#define MINIMUM_CONVERSION_BUFFER_SIZE 1024
+#endif
+
+char *conversion_buffer;
+int conversion_buffer_size;
+
+/* Return a pointer to a SIZE bytes of buffer to be used for encoding
+   or decoding.  Sufficient memory is allocated automatically.  If we
+   run out of memory, return NULL.  */
+
+char *
+get_conversion_buffer (size)
+     int size;
+{
+  if (size > conversion_buffer_size)
+    {
+      char *buf;
+      int real_size = conversion_buffer_size * 2;
+
+      while (real_size < size) real_size *= 2;
+      buf = (char *) xmalloc (real_size);
+      xfree (conversion_buffer);
+      conversion_buffer = buf;
+      conversion_buffer_size = real_size;
+    }
+  return conversion_buffer;
+}
+
+
+#ifdef emacs
+/*** 7. Emacs Lisp library functions ***/
+
+DEFUN ("coding-system-vector", Fcoding_system_vector, Scoding_system_vector,
+       1, 1, 0,
+  "Return coding-vector of CODING-SYSTEM.\n\
+If CODING-SYSTEM is not a valid coding-system, return nil.")
+  (obj)
+     Lisp_Object obj;
+{
+  while (SYMBOLP (obj) && !NILP (obj))
+    obj = Fget (obj, Qcoding_system);
+  return ((NILP (obj) || !VECTORP (obj) || XVECTOR (obj)->size != 5)
+          ? Qnil : obj);
+}
+
+DEFUN ("coding-system-p", Fcoding_system_p, Scoding_system_p, 1, 1, 0,
+  "Return t if OBJECT is nil or a coding-system.\n\
+See document of make-coding-system for coding-system object.")
+  (obj)
+     Lisp_Object obj;
+{
+  return ((NILP (obj) || !NILP (Fcoding_system_vector (obj))) ? Qt : Qnil);
+}
+
+DEFUN ("read-non-nil-coding-system",
+       Fread_non_nil_coding_system, Sread_non_nil_coding_system, 1, 1, 0,
+  "Read a coding-system from the minibuffer, prompting with string PROMPT.")
+  (prompt)
+     Lisp_Object prompt;
+{
+  return Fintern (Fcompleting_read (prompt, Vobarray, Qcoding_system_vector,
+                                    Qt, Qnil, Qnil),
+                  Qnil);
+}
+
+DEFUN ("read-coding-system", Fread_coding_system, Sread_coding_system, 1, 1, 0,
+  "Read a coding-system or nil from the minibuffer, prompting with string PROMPT.")
+  (prompt)
+     Lisp_Object prompt;
+{
+  return Fintern (Fcompleting_read (prompt, Vobarray, Qcoding_system_p,
+                                    Qt, Qnil, Qnil),
+                  Qnil);
+}
+
+DEFUN ("check-coding-system", Fcheck_coding_system, Scheck_coding_system,
+       1, 1, 0,
+  "Check validity of CODING-SYSTEM.\n\
+If valid, return CODING-SYSTEM, else `coding-system-error' is signaled.\n\
+CODING-SYSTEM is valid if it is a symbol and has \"coding-system\" property.\n\
+The value of property should be a vector of length 5.")
+  (coding_system)
+     Lisp_Object coding_system;
+{
+  CHECK_SYMBOL (coding_system, 0);
+  if (!NILP (Fcoding_system_p (coding_system)))
+    return coding_system;
+  while (1)
+    Fsignal (Qcoding_system_error, coding_system);
+}
+
+DEFUN ("detect-coding-region", Fdetect_coding_region, Sdetect_coding_region,
+       2, 2, 0,
+  "Detect coding-system of the text in the region between START and END.\n\
+Return a list of possible coding-systems ordered by priority.\n\
+If only ASCII characters are found, it returns `coding-system-automatic'\n\
+ or its subsidiary coding-system according to a detected end-of-line format.")
+  (b, e)
+     Lisp_Object b, e;
+{
+  int coding_mask, eol_type;
+  Lisp_Object val;
+  int beg, end;
+
+  validate_region (&b, &e);
+  beg = XINT (b), end = XINT (e);
+  if (beg < GPT && end >= GPT) move_gap (end);
+
+  coding_mask = detect_coding_mask (POS_ADDR (beg), end - beg);
+  eol_type  = detect_eol_type (POS_ADDR (beg), end - beg);
+
+  if (coding_mask == CODING_CATEGORY_MASK_ANY)
+    {
+      val = intern ("coding-system-automatic");
+      if (eol_type != CODING_EOL_AUTOMATIC)
+        {
+          Lisp_Object val2 = Fget (val, Qeol_type);
+          if (VECTORP (val2))
+            val = XVECTOR (val2)->contents[eol_type];
+        }
+    }
+  else
+    {
+      Lisp_Object val2;
+
+      /* At first, gather possible coding-systems in VAL in a reverse
+         order.  */
+      val = Qnil;
+      for (val2 = Vcoding_category_list;
+           !NILP (val2);
+           val2 = XCONS (val2)->cdr)
+        {
+          int idx
+            = XFASTINT (Fget (XCONS (val2)->car, Qcoding_category_index));
+          if (coding_mask & (1 << idx))
+            val = Fcons (Fsymbol_value (XCONS (val2)->car), val);
+        }
+
+      /* Then, change the order of the list, while getting subsidiary
+         coding-systems.  */
+      val2 = val;
+      val = Qnil;
+      for (; !NILP (val2); val2 = XCONS (val2)->cdr)
+        {
+          if (eol_type == CODING_EOL_AUTOMATIC)
+            val = Fcons (XCONS (val2)->car, val);
+          else
+            {
+              Lisp_Object val3 = Fget (XCONS (val2)->car, Qeol_type);
+              if (VECTORP (val3))
+                val = Fcons (XVECTOR (val3)->contents[eol_type], val);
+              else
+                val = Fcons (XCONS (val2)->car, val);
+            }
+        }
+    }
+
+  return val;
+}
+
+/* Scan text in the region between *BEGP and *ENDP, skip characters
+   which we never have to encode to (iff ENCODEP is 1) or decode from
+   coding system CODING at the head and tail, then set BEGP and ENDP
+   to the addresses of start and end of the text we actually convert.  */
+
+void
+shrink_conversion_area (begp, endp, coding, encodep)
+     unsigned char **begp, **endp;
+     struct coding_system *coding;
+     int encodep;
+{
+  register unsigned char *beg_addr = *begp, *end_addr = *endp;
+
+  if (coding->eol_type != CODING_EOL_LF
+      && coding->eol_type != CODING_EOL_AUTOMATIC)
+    /* Since we anyway have to convert end-of-line format, it is not
+       worth skipping at most 100 bytes or so.  */
+    return;
+
+  if (encodep)                  /* for encoding */
+    {
+      switch (coding->type)
+        {
+        case coding_type_no_conversion:
+        case coding_type_internal:
+        case coding_type_automatic:
+          /* We need no conversion.  */
+          *begp = *endp;
+          return;
+        case coding_type_ccl:
+          /* We can't skip any data.  */
+          return;
+        default:
+          /* We can skip all ASCII characters at the head and tail.  */
+          while (beg_addr < end_addr && *beg_addr < 0x80) beg_addr++;
+          while (beg_addr < end_addr && *(end_addr - 1) < 0x80) end_addr--;
+          break;
+        }
+    }
+  else                          /* for decoding */
+    {
+      switch (coding->type)
+        {
+        case coding_type_no_conversion:
+          /* We need no conversion.  */
+          *begp = *endp;
+          return;
+        case coding_type_internal:
+          if (coding->eol_type == CODING_EOL_LF)
+            {
+              /* We need no conversion.  */
+              *begp = *endp;
+              return;
+            }
+          /* We can skip all but carriage-return.  */
+          while (beg_addr < end_addr && *beg_addr != '\r') beg_addr++;
+          while (beg_addr < end_addr && *(end_addr - 1) != '\r') end_addr--;
+          break;
+        case coding_type_sjis:
+        case coding_type_big5:
+          /* We can skip all ASCII characters at the head.  */
+          while (beg_addr < end_addr && *beg_addr < 0x80) beg_addr++;
+          /* We can skip all ASCII characters at the tail except for
+             the second byte of SJIS or BIG5 code.  */
+          while (beg_addr < end_addr && *(end_addr - 1) < 0x80) end_addr--;
+          if (end_addr != *endp)
+            end_addr++;
+          break;
+        case coding_type_ccl:
+          /* We can't skip any data.  */
+          return;
+        default:                /* i.e. case coding_type_iso2022: */
+          {
+            unsigned char c;
+
+            /* We can skip all ASCII characters except for a few
+               control codes at the head.  */
+            while (beg_addr < end_addr && (c = *beg_addr) < 0x80
+                   && c != ISO_CODE_CR && c != ISO_CODE_SO
+                   && c != ISO_CODE_SI && c != ISO_CODE_ESC)
+              beg_addr++;
+          }
+          break;
+        }
+    }
+  *begp = beg_addr;
+  *endp = end_addr;
+  return;
+}
+
+/* Encode to (iff ENCODEP is 1) or decode form coding system CODING a
+   text between B and E.  B and E are buffer position.  */
+
+Lisp_Object
+code_convert_region (b, e, coding, encodep)
+     Lisp_Object b, e;
+     struct coding_system *coding;
+     int encodep;
+{
+  int beg, end, len, consumed, produced;
+  char *buf;
+  unsigned char *begp, *endp;
+  int pos = PT;
+
+  validate_region (&b, &e);
+  beg = XINT (b), end = XINT (e);
+  if (beg < GPT && end >= GPT)
+    move_gap (end);
+
+  if (encodep && !NILP (coding->pre_write_conversion))
+    {
+      /* We must call a pre-conversion function which may put a new
+         text to be converted in a new buffer.  */
+      struct buffer *old = current_buffer, *new;
+
+      TEMP_SET_PT (beg);
+      call2 (coding->pre_write_conversion, b, e);
+      if (old != current_buffer)
+        {
+          /* Replace the original text by the text just generated.  */
+          len = ZV - BEGV;
+          new = current_buffer;
+          set_buffer_internal (old);
+          del_range (beg, end);
+          insert_from_buffer (new, 1, len, 0);
+          end = beg + len;
+        }
+    }
+
+  /* We may be able to shrink the conversion region.  */
+  begp = POS_ADDR (beg); endp = begp + (end - beg);
+  shrink_conversion_area (&begp, &endp, coding, encodep);
+
+  if (begp == endp)
+    /* We need no conversion.  */
+    len = end - beg;
+  else
+    {
+      beg += begp - POS_ADDR (beg);
+      end =  beg + (endp - begp);
+
+      if (encodep)
+        len = encoding_buffer_size (coding, end - beg);
+      else
+        len = decoding_buffer_size (coding, end - beg);
+      buf = get_conversion_buffer (len);
+
+      coding->last_block = 1;
+      produced = (encodep
+                  ? encode_coding (coding, POS_ADDR (beg), buf, end - beg, len,
+                                   &consumed)
+                  : decode_coding (coding, POS_ADDR (beg), buf, end - beg, len,
+                                   &consumed));
+
+      len = produced + (beg - XINT (b)) + (XINT (e) - end);
+
+      TEMP_SET_PT (beg);
+      insert (buf, produced);
+      del_range (PT, PT + end - beg);
+      if (pos >= end)
+        pos = PT + (pos - end);
+      else if (pos > beg)
+        pos = beg;
+      TEMP_SET_PT (pos);
+  }
+
+  if (!encodep && !NILP (coding->post_read_conversion))
+    {
+      /* We must call a post-conversion function which may alter
+         the text just converted.  */
+      Lisp_Object insval;
+
+      beg = XINT (b);
+      TEMP_SET_PT (beg);
+      insval = call1 (coding->post_read_conversion, make_number (len));
+      CHECK_NUMBER (insval, 0);
+      len = XINT (insval);
+    }
+
+  return make_number (len);
+}
+
+Lisp_Object
+code_convert_string (str, coding, encodep)
+     Lisp_Object str;
+     struct coding_system *coding;
+     int encodep;
+{
+  int len, consumed, produced;
+  char *buf;
+  unsigned char *begp, *endp;
+  int head_skip, tail_skip;
+  struct gcpro gcpro1;
+
+  if (encodep && !NILP (coding->pre_write_conversion)
+      || !encodep && !NILP (coding->post_read_conversion))
+    {
+      /* Since we have to call Lisp functions which assume target text
+         is in a buffer, after setting a temporary buffer, call
+         code_convert_region.  */
+      int count = specpdl_ptr - specpdl;
+      int len = XSTRING (str)->size;
+      Lisp_Object result;
+      struct buffer *old = current_buffer;
+
+      record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
+      temp_output_buffer_setup (" *code-converting-work*");
+      set_buffer_internal (XBUFFER (Vstandard_output));
+      insert_from_string (str, 0, len, 0);
+      code_convert_region (make_number (BEGV), make_number (ZV),
+                           coding, encodep);
+      result = make_buffer_string (BEGV, ZV, 0);
+      set_buffer_internal (old);
+      return unbind_to (count, result);
+    }
+
+  /* We may be able to shrink the conversion region.  */
+  begp = XSTRING (str)->data;
+  endp = begp + XSTRING (str)->size;
+  shrink_conversion_area (&begp, &endp, coding, encodep);
+
+  if (begp == endp)
+    /* We need no conversion.  */
+    return str;
+
+  head_skip = begp - XSTRING (str)->data;
+  tail_skip = XSTRING (str)->size - head_skip - (endp - begp);
+
+  GCPRO1 (str);
+
+  if (encodep)
+    len = encoding_buffer_size (coding, endp - begp);
+  else
+    len = decoding_buffer_size (coding, endp - begp);
+  buf = get_conversion_buffer (len + head_skip + tail_skip);
+
+  bcopy (XSTRING (str)->data, buf, head_skip);
+  coding->last_block = 1;
+  produced = (encodep
+              ? encode_coding (coding, XSTRING (str)->data + head_skip,
+                               buf + head_skip, endp - begp, len, &consumed)
+              : decode_coding (coding, XSTRING (str)->data + head_skip,
+                               buf + head_skip, endp - begp, len, &consumed));
+  bcopy (XSTRING (str)->data + head_skip + (endp - begp),
+         buf + head_skip + produced,
+         tail_skip);
+
+  UNGCPRO;
+
+  return make_string (buf, head_skip + produced + tail_skip);
+}
+
+DEFUN ("decode-coding-region", Fdecode_coding_region, Sdecode_coding_region,
+       3, 3, 0,
+  "Decode the text between START and END which is encoded in CODING-SYSTEM.\n\
+Return length of decoded text.")
+  (b, e, coding_system)
+     Lisp_Object b, e, coding_system;
+{
+  struct coding_system coding;
+
+  CHECK_NUMBER_COERCE_MARKER (b, 0);
+  CHECK_NUMBER_COERCE_MARKER (e, 1);
+  CHECK_SYMBOL (coding_system, 2);
+
+  if (setup_coding_system (Fcheck_coding_system (coding_system), &coding) < 0)
+    error ("Invalid coding-system: %s", XSYMBOL (coding_system)->name->data);
+
+  return code_convert_region (b, e, &coding, 0);
+}
+
+DEFUN ("encode-coding-region", Fencode_coding_region, Sencode_coding_region,
+       3, 3, 0,
+  "Encode the text between START and END to CODING-SYSTEM.\n\
+Return length of encoded text.")
+  (b, e, coding_system)
+     Lisp_Object b, e, coding_system;
+{
+  struct coding_system coding;
+
+  CHECK_NUMBER_COERCE_MARKER (b, 0);
+  CHECK_NUMBER_COERCE_MARKER (e, 1);
+  CHECK_SYMBOL (coding_system, 2);
+
+  if (setup_coding_system (Fcheck_coding_system (coding_system), &coding) < 0)
+    error ("Invalid coding-system: %s", XSYMBOL (coding_system)->name->data);
+
+  return code_convert_region (b, e, &coding, 1);
+}
+
+DEFUN ("decode-coding-string", Fdecode_coding_string, Sdecode_coding_string,
+       2, 2, 0,
+  "Decode STRING which is encoded in CODING-SYSTEM, and return the result.")
+  (string, coding_system)
+     Lisp_Object string, coding_system;
+{
+  struct coding_system coding;
+
+  CHECK_STRING (string, 0);
+  CHECK_SYMBOL (coding_system, 1);
+
+  if (setup_coding_system (Fcheck_coding_system (coding_system), &coding) < 0)
+    error ("Invalid coding-system: %s", XSYMBOL (coding_system)->name->data);
+
+  return code_convert_string (string, &coding, 0);
+}
+
+DEFUN ("encode-coding-string", Fencode_coding_string, Sencode_coding_string,
+       2, 2, 0,
+  "Encode STRING to CODING-SYSTEM, and return the result.")
+  (string, coding_system)
+     Lisp_Object string, coding_system;
+{
+  struct coding_system coding;
+
+  CHECK_STRING (string, 0);
+  CHECK_SYMBOL (coding_system, 1);
+
+  if (setup_coding_system (Fcheck_coding_system (coding_system), &coding) < 0)
+    error ("Invalid coding-system: %s", XSYMBOL (coding_system)->name->data);
+
+  return code_convert_string (string, &coding, 1);
+}
+
+DEFUN ("decode-sjis-char", Fdecode_sjis_char, Sdecode_sjis_char, 1, 1, 0,
+  "Decode a JISX0208 character of SJIS coding-system-sjis.\n\
+CODE is the character code in SJIS.\n\
+Return the corresponding character.")
+  (code)
+     Lisp_Object code;
+{
+  unsigned char c1, c2, s1, s2;
+  Lisp_Object val;
+
+  CHECK_NUMBER (code, 0);
+  s1 = (XFASTINT (code)) >> 8, s2 = (XFASTINT (code)) & 0xFF;
+  DECODE_SJIS (s1, s2, c1, c2);
+  XSETFASTINT (val, MAKE_NON_ASCII_CHAR (charset_jisx0208, c1, c2));
+  return val;
+}
+
+DEFUN ("encode-sjis-char", Fencode_sjis_char, Sencode_sjis_char, 1, 1, 0,
+  "Encode a JISX0208 character CHAR to SJIS coding-system.\n\
+Return the corresponding character code in SJIS.")
+  (ch)
+     Lisp_Object ch;
+{
+  int charset;
+  unsigned char c1, c2, s1, s2;
+  Lisp_Object val;
+
+  CHECK_NUMBER (ch, 0);
+  SPLIT_CHAR (XFASTINT (ch), charset, c1, c2);
+  if (charset == charset_jisx0208)
+    {
+      ENCODE_SJIS (c1, c2, s1, s2);
+      XSETFASTINT (val, ((int)s1 << 8) | s2);
+    }
+  else
+    XSETFASTINT (val, 0);
+  return val;
+}
+
+DEFUN ("decode-big5-char", Fdecode_big5_char, Sdecode_big5_char, 1, 1, 0,
+  "Decode a Big5 character CODE of BIG5 coding-system.\n\
+CODE is the character code in BIG5.\n\
+Return the corresponding character.")
+  (code)
+     Lisp_Object code;
+{
+  int charset;
+  unsigned char b1, b2, c1, c2;
+  Lisp_Object val;
+
+  CHECK_NUMBER (code, 0);
+  b1 = (XFASTINT (code)) >> 8, b2 = (XFASTINT (code)) & 0xFF;
+  DECODE_BIG5 (b1, b2, charset, c1, c2);
+  XSETFASTINT (val, MAKE_NON_ASCII_CHAR (charset, c1, c2));
+  return val;
+}
+
+DEFUN ("encode-big5-char", Fencode_big5_char, Sencode_big5_char, 1, 1, 0,
+  "Encode the Big5 character CHAR to BIG5 coding-system.\n\
+Return the corresponding character code in Big5.")
+  (ch)
+     Lisp_Object ch;
+{
+  int charset;
+  unsigned char c1, c2, b1, b2;
+  Lisp_Object val;
+
+  CHECK_NUMBER (ch, 0);
+  SPLIT_CHAR (XFASTINT (ch), charset, c1, c2);
+  if (charset == charset_big5_1 || charset == charset_big5_2)
+    {
+      ENCODE_BIG5 (charset, c1, c2, b1, b2);
+      XSETFASTINT (val, ((int)b1 << 8) | b2);
+    }
+  else
+    XSETFASTINT (val, 0);
+  return val;
+}
+
+DEFUN ("set-terminal-coding-system",
+       Fset_terminal_coding_system, Sset_terminal_coding_system, 1, 1,
+       "zCoding-system for terminal display: ",
+  "Set coding-system of your terminal to CODING-SYSTEM.\n\
+All outputs to terminal are encoded to this coding-system.")
+  (coding_system)
+     Lisp_Object coding_system;
+{
+  CHECK_SYMBOL (coding_system, 0);
+  setup_coding_system (Fcheck_coding_system (coding_system), &terminal_coding);
+  update_mode_lines++;
+  if (!NILP (Finteractive_p ()))
+    Fredraw_display ();
+  return Qnil;
+}
+
+DEFUN ("terminal-coding-system",
+       Fterminal_coding_system, Sterminal_coding_system, 0, 0, 0,
+  "Return coding-system of your terminal.")
+  ()
+{
+  return terminal_coding.symbol;
+}
+
+DEFUN ("set-keyboard-coding-system",
+       Fset_keyboard_coding_system, Sset_keyboard_coding_system, 1, 1,
+       "zCoding-system for keyboard input: ",
+  "Set coding-system of what is sent from terminal keyboard to CODING-SYSTEM.\n\
+All inputs from terminal are decoded from this coding-system.")
+  (coding_system)
+     Lisp_Object coding_system;
+{
+  CHECK_SYMBOL (coding_system, 0);
+  setup_coding_system (Fcheck_coding_system (coding_system), &keyboard_coding);
+  return Qnil;
+}
+
+DEFUN ("keyboard-coding-system",
+       Fkeyboard_coding_system, Skeyboard_coding_system, 0, 0, 0,
+  "Return coding-system of what is sent from terminal keyboard.")
+  ()
+{
+  return keyboard_coding.symbol;
+}
+
+
+DEFUN ("find-coding-system", Ffind_coding_system, Sfind_coding_system,
+       1, MANY, 0,
+  "Return a cons of coding systems for I/O primitive OPERATION.\n\
+Remaining arguments are for OPERATION.\n\
+OPERATION is one of the following Emacs I/O primitives:\n\
+  For file I/O, insert-file-contents or write-region.\n\
+  For process I/O, call-process, call-process-region, or start-process.\n\
+  For network I/O, open-network-stream.\n\
+For each OPERATION, TARGET is selected from the arguments as below:\n\
+  For file I/O, TARGET is a file name.\n\
+  For process I/O, TARGET is a process name.\n\
+  For network I/O, TARGET is a service name or a port number\n\
+\n\
+The return value is a cons of coding systems for decoding and encoding\n\
+registered in nested alist `coding-system-alist' (which see) at a slot\n\
+corresponding to OPERATION and TARGET.
+If a function symbol is at the slot, return a result of the function call.\n\
+The function is called with one argument, a list of all the arguments.")
+  (nargs, args)
+     int nargs;
+     Lisp_Object *args;
+{
+  Lisp_Object operation, target_idx, target, val;
+  register Lisp_Object chain;
+
+  if (nargs < 2)
+    error ("Too few arguments");
+  operation = args[0];
+  if (!SYMBOLP (operation)
+      || !INTEGERP (target_idx = Fget (operation, Qtarget_idx)))
+    error ("Invalid first arguement");
+  if (nargs < 1 + XINT (target_idx))
+    error ("Too few arguments for operation: %s",
+           XSYMBOL (operation)->name->data);
+  target = args[XINT (target_idx) + 1];
+  if (!(STRINGP (target)
+        || (EQ (operation, Qopen_network_stream) && INTEGERP (target))))
+    error ("Invalid %dth argument", XINT (target_idx) + 1);
+
+  chain = Fassq (operation, Vcoding_system_alist);
+  if (NILP (chain))
+    return Qnil;
+
+  for (chain = XCONS (chain)->cdr; CONSP (chain); chain = XCONS (chain)->cdr)
+    {
+      Lisp_Object elt = XCONS (chain)->car;
+
+      if (CONSP (elt)
+          && ((STRINGP (target)
+               && STRINGP (XCONS (elt)->car)
+               && fast_string_match (XCONS (elt)->car, target) >= 0)
+              || (INTEGERP (target) && EQ (target, XCONS (elt)->car))))
+        return (CONSP (val = XCONS (elt)->cdr)
+                ? val
+                : ((SYMBOLP (val) && Fboundp (val)
+                    ? call2 (val, Flist (nargs, args))
+                    : Qnil)));
+    }
+  return Qnil;
+}
+
+#endif /* emacs */
+
+
+/*** 8. Post-amble ***/
+
+init_coding_once ()
+{
+  int i;
+
+  /* Emacs internal format specific initialize routine.  */ 
+  for (i = 0; i <= 0x20; i++)
+    emacs_code_class[i] = EMACS_control_code;
+  emacs_code_class[0x0A] = EMACS_linefeed_code;
+  emacs_code_class[0x0D] = EMACS_carriage_return_code;
+  for (i = 0x21 ; i < 0x7F; i++)
+    emacs_code_class[i] = EMACS_ascii_code;
+  emacs_code_class[0x7F] = EMACS_control_code;
+  emacs_code_class[0x80] = EMACS_leading_code_composition;
+  for (i = 0x81; i < 0xFF; i++)
+    emacs_code_class[i] = EMACS_invalid_code;
+  emacs_code_class[LEADING_CODE_PRIVATE_11] = EMACS_leading_code_3;
+  emacs_code_class[LEADING_CODE_PRIVATE_12] = EMACS_leading_code_3;
+  emacs_code_class[LEADING_CODE_PRIVATE_21] = EMACS_leading_code_4;
+  emacs_code_class[LEADING_CODE_PRIVATE_22] = EMACS_leading_code_4;
+
+  /* ISO2022 specific initialize routine.  */
+  for (i = 0; i < 0x20; i++)
+    iso_code_class[i] = ISO_control_code;
+  for (i = 0x21; i < 0x7F; i++)
+    iso_code_class[i] = ISO_graphic_plane_0;
+  for (i = 0x80; i < 0xA0; i++)
+    iso_code_class[i] = ISO_control_code;
+  for (i = 0xA1; i < 0xFF; i++)
+    iso_code_class[i] = ISO_graphic_plane_1;
+  iso_code_class[0x20] = iso_code_class[0x7F] = ISO_0x20_or_0x7F;
+  iso_code_class[0xA0] = iso_code_class[0xFF] = ISO_0xA0_or_0xFF;
+  iso_code_class[ISO_CODE_CR] = ISO_carriage_return;
+  iso_code_class[ISO_CODE_SO] = ISO_shift_out;
+  iso_code_class[ISO_CODE_SI] = ISO_shift_in;
+  iso_code_class[ISO_CODE_SS2_7] = ISO_single_shift_2_7;
+  iso_code_class[ISO_CODE_ESC] = ISO_escape;
+  iso_code_class[ISO_CODE_SS2] = ISO_single_shift_2;
+  iso_code_class[ISO_CODE_SS3] = ISO_single_shift_3;
+  iso_code_class[ISO_CODE_CSI] = ISO_control_sequence_introducer;
+
+  Qcoding_system = intern ("coding-system");
+  staticpro (&Qcoding_system);
+
+  Qeol_type = intern ("eol-type");
+  staticpro (&Qeol_type);
+
+  Qbuffer_file_coding_system = intern ("buffer-file-coding-system");
+  staticpro (&Qbuffer_file_coding_system);
+
+  Qpost_read_conversion = intern ("post-read-conversion");
+  staticpro (&Qpost_read_conversion);
+
+  Qpre_write_conversion = intern ("pre-write-conversion");
+  staticpro (&Qpre_write_conversion);
+
+  Qcoding_system_vector = intern ("coding-system-vector");
+  staticpro (&Qcoding_system_vector);
+
+  Qcoding_system_p = intern ("coding-system-p");
+  staticpro (&Qcoding_system_p);
+
+  Qcoding_system_error = intern ("coding-system-error");
+  staticpro (&Qcoding_system_error);
+
+  Fput (Qcoding_system_error, Qerror_conditions,
+        Fcons (Qcoding_system_error, Fcons (Qerror, Qnil)));
+  Fput (Qcoding_system_error, Qerror_message,
+        build_string ("Coding-system error"));
+
+  Qcoding_category_index = intern ("coding-category-index");
+  staticpro (&Qcoding_category_index);
+
+  {
+    int i;
+    for (i = 0; i < CODING_CATEGORY_IDX_MAX; i++)
+      {
+        coding_category_table[i] = intern (coding_category_name[i]);
+        staticpro (&coding_category_table[i]);
+        Fput (coding_category_table[i], Qcoding_category_index,
+              make_number (i));
+      }
+  }
+
+  conversion_buffer_size = MINIMUM_CONVERSION_BUFFER_SIZE;
+  conversion_buffer = (char *) xmalloc (MINIMUM_CONVERSION_BUFFER_SIZE);
+
+  setup_coding_system (Qnil, &keyboard_coding);
+  setup_coding_system (Qnil, &terminal_coding);
+}
+
+#ifdef emacs
+
+syms_of_coding ()
+{
+  Qtarget_idx = intern ("target-idx");
+  staticpro (&Qtarget_idx);
+
+  Fput (Qinsert_file_contents, Qtarget_idx, make_number (0));
+  Fput (Qwrite_region, Qtarget_idx, make_number (2));
+
+  Qcall_process = intern ("call-process");
+  staticpro (&Qcall_process);
+  Fput (Qcall_process, Qtarget_idx, make_number (0));
+
+  Qcall_process_region = intern ("call-process-region");
+  staticpro (&Qcall_process_region);
+  Fput (Qcall_process_region, Qtarget_idx, make_number (2));
+
+  Qstart_process = intern ("start-process");
+  staticpro (&Qstart_process);
+  Fput (Qstart_process, Qtarget_idx, make_number (2));
+
+  Qopen_network_stream = intern ("open-network-stream");
+  staticpro (&Qopen_network_stream);
+  Fput (Qopen_network_stream, Qtarget_idx, make_number (3));
+
+  defsubr (&Scoding_system_vector);
+  defsubr (&Scoding_system_p);
+  defsubr (&Sread_coding_system);
+  defsubr (&Sread_non_nil_coding_system);
+  defsubr (&Scheck_coding_system);
+  defsubr (&Sdetect_coding_region);
+  defsubr (&Sdecode_coding_region);
+  defsubr (&Sencode_coding_region);
+  defsubr (&Sdecode_coding_string);
+  defsubr (&Sencode_coding_string);
+  defsubr (&Sdecode_sjis_char);
+  defsubr (&Sencode_sjis_char);
+  defsubr (&Sdecode_big5_char);
+  defsubr (&Sencode_big5_char);
+  defsubr (&Sset_terminal_coding_system);
+  defsubr (&Sterminal_coding_system);
+  defsubr (&Sset_keyboard_coding_system);
+  defsubr (&Skeyboard_coding_system);
+  defsubr (&Sfind_coding_system);
+
+  DEFVAR_LISP ("coding-category-list", &Vcoding_category_list,
+    "List of coding-categories (symbols) ordered by priority.");
+  {
+    int i;
+
+    Vcoding_category_list = Qnil;
+    for (i = CODING_CATEGORY_IDX_MAX - 1; i >= 0; i--)
+      Vcoding_category_list
+        = Fcons (coding_category_table[i], Vcoding_category_list);
+  }
+
+  DEFVAR_LISP ("coding-system-for-read", &Vcoding_system_for_read,
+    "A variable of internal use only.\n\
+If the value is a coding system, it is used for decoding on read operation.\n\
+If not, an appropriate element in `coding-system-alist' (which see) is used.");
+  Vcoding_system_for_read = Qnil;
+
+  DEFVAR_LISP ("coding-system-for-write", &Vcoding_system_for_write,
+    "A variable of internal use only.\n\
+If the value is a coding system, it is used for encoding on write operation.\n\
+If not, an appropriate element in `coding-system-alist' (which see) is used.");
+  Vcoding_system_for_write = Qnil;
+
+  DEFVAR_LISP ("last-coding-system-used", &Vlast_coding_system_used,
+    "Coding-system used in the latest file or process I/O.");
+  Vlast_coding_system_used = Qnil;
+
+  DEFVAR_LISP ("coding-system-alist", &Vcoding_system_alist,
+    "Nested alist to decide a coding system for a specific I/O operation.\n\
+The format is ((OPERATION . ((REGEXP . CODING-SYSTEMS) ...)) ...).\n\
+
+OPERATION is one of the following Emacs I/O primitives:\n\
+  For file I/O, insert-file-contents and write-region.\n\
+  For process I/O, call-process, call-process-region, and start-process.\n\
+  For network I/O, open-network-stream.\n\
+In addition, for process I/O, `process-argument' can be specified for\n\
+encoding arguments of the process.\n\
+\n\
+REGEXP is a regular expression matching a target of OPERATION, where\n\
+target is a file name for file I/O operations, a process name for\n\
+process I/O operations, or a service name for network I/O\n\
+operations.  REGEXP might be a port number for network I/O operation.\n\
+\n\
+CODING-SYSTEMS is a cons of coding systems to encode and decode\n\
+character code on OPERATION, or a function symbol returning the cons.\n\
+See the documentation of `find-coding-system' for more detail.");
+  Vcoding_system_alist = Qnil;
+
+  DEFVAR_INT ("eol-mnemonic-unix", &eol_mnemonic_unix,
+    "Mnemonic character indicating UNIX-like end-of-line format (i.e. LF) .");
+  eol_mnemonic_unix = '.';
+
+  DEFVAR_INT ("eol-mnemonic-dos", &eol_mnemonic_dos,
+    "Mnemonic character indicating DOS-like end-of-line format (i.e. CRLF).");
+  eol_mnemonic_dos = ':';
+
+  DEFVAR_INT ("eol-mnemonic-mac", &eol_mnemonic_mac,
+    "Mnemonic character indicating MAC-like end-of-line format (i.e. CR).");
+  eol_mnemonic_mac = '\'';
+
+  DEFVAR_INT ("eol-mnemonic-undecided", &eol_mnemonic_undecided,
+    "Mnemonic character indicating end-of-line format is not yet decided.");
+  eol_mnemonic_undecided = '-';
+
+  DEFVAR_LISP ("alternate-charset-table", &Valternate_charset_table,
+    "Alist of charsets vs the alternate charsets.\n\
+While decoding, if a charset (car part of an element) is found,\n\
+decode it as the alternate charset (cdr part of the element).");
+  Valternate_charset_table = Qnil;
+
+  DEFVAR_LISP ("charset-revision-table", &Vcharset_revision_alist,
+    "Alist of charsets vs revision numbers.\n\
+While encoding, if a charset (car part of an element) is found,\n\
+designate it with the escape sequence identifing revision (cdr part of the element).");
+  Vcharset_revision_alist = Qnil;
+}
+
+#endif /* emacs */
diff --git a/src/coding.h b/src/coding.h
new file mode 100644
index 00000000000..3ec2fcc32f3
--- /dev/null
+++ b/src/coding.h
@@ -0,0 +1,409 @@
+/* Header for coding system handler.
+   Ver.1.0
+
+   Copyright (C) 1995 Free Software Foundation, Inc.
+   Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#ifndef _CODING_H
+#define _CODING_H
+
+#ifndef _CCL_H
+#include "../src/ccl.h"
+#endif
+
+/*** EMACS' INTERNAL FORMAT section ***/
+
+/* All code (1-byte) of Emacs' internal format is classified into one
+   of the followings.  See also `charset.h'.  */
+enum emacs_code_class_type
+  {
+    EMACS_control_code,         /* Control codes in the range
+                                   0x00..0x1F and 0x7F except for the
+                                   following two codes.  */
+    EMACS_linefeed_code,        /* 0x0A (linefeed) to denote
+                                   end-of-line.  */
+    EMACS_carriage_return_code, /* 0x0D (carriage-return) to be used
+                                   in selective display mode.  */
+    EMACS_ascii_code,           /* ASCII characters.  */
+    EMACS_leading_code_composition, /* Leading code of a composite
+                                       character.  */
+    EMACS_leading_code_2,       /* Base leading code of official
+                                   TYPE9N character.  */
+    EMACS_leading_code_3,       /* Base leading code of private TYPE9N
+                                   or official TYPE9Nx9N character.  */
+    EMACS_leading_code_4,       /* Base leading code of private
+                                   TYPE9Nx9N character.  */
+    EMACS_invalid_code          /* Invalid code, i.e. a base leading
+                                   code not yet assigned to any
+                                   charset, or a code of the range
+                                   0xA0..0xFF.  */
+  };
+
+extern enum emacs_code_class_type emacs_code_class[256];
+
+/*** ISO2022 section ***/
+
+/* Macros to define code of control characters for ISO2022's functions.  */
+                        /* code */      /* function */
+#define ISO_CODE_LF     0x0A            /* line-feed */
+#define ISO_CODE_CR     0x0D            /* carriage-return */
+#define ISO_CODE_SO     0x0E            /* shift-out */
+#define ISO_CODE_SI     0x0F            /* shift-in */
+#define ISO_CODE_SS2_7  0x19            /* single-shift-2 for 7-bit code */
+#define ISO_CODE_ESC    0x1B            /* escape */
+#define ISO_CODE_SS2    0x8E            /* single-shift-2 */
+#define ISO_CODE_SS3    0x8F            /* single-shift-3 */
+#define ISO_CODE_CSI    0x9B            /* control-sequence-introduce */
+
+/* All code (1-byte) of ISO2022 is classified into one of the
+   followings.  */
+enum iso_code_class_type
+  {
+    ISO_control_code,           /* Control codes in the range
+                                   0x00..0x1F, 0x7F, and 0x80..0x9F,
+                                   except for the following seven
+                                   codes.  */
+    ISO_carriage_return,        /* ISO_CODE_CR (0x0D) */
+    ISO_shift_out,              /* ISO_CODE_SO (0x0E) */
+    ISO_shift_in,               /* ISO_CODE_SI (0x0F) */
+    ISO_single_shift_2_7,       /* ISO_CODE_SS2_7 (0x19) */
+    ISO_escape,                 /* ISO_CODE_SO (0x1B) */
+    ISO_single_shift_2,         /* ISO_CODE_SS2 (0x8E) */
+    ISO_single_shift_3,         /* ISO_CODE_SS3 (0x8F) */
+    ISO_control_sequence_introducer, /* ISO_CODE_CSI (0x9B) */
+    ISO_0x20_or_0x7F,           /* Codes of the values 0x20 or 0x7F.  */
+    ISO_graphic_plane_0,        /* Graphic codes in the range 0x21..0x7E.  */
+    ISO_0xA0_or_0xFF,           /* Codes of the values 0xA0 or 0xFF.  */
+    ISO_graphic_plane_1         /* Graphic codes in the range 0xA1..0xFE.  */
+  };
+
+/** The macros CODING_FLAG_ISO_XXX defines a flag bit of the `flags'
+  element in the structure `coding_system'.  This information is used
+  while encoding a text to ISO2022.  **/
+
+/* If set, produce short-form designation sequence (e.g. ESC $ A)
+   instead of long-form sequence (e.g. ESC $ ( A).  */
+#define CODING_FLAG_ISO_SHORT_FORM      0x0001
+
+/* If set, reset graphic planes and registers at end-of-line to the
+   initial state.  */
+#define CODING_FLAG_ISO_RESET_AT_EOL    0x0002
+
+/* If set, reset graphic planes and registers before any control
+   characters to the initial state.  */
+#define CODING_FLAG_ISO_RESET_AT_CNTL   0x0004
+
+/* If set, encode by 7-bit environment.  */
+#define CODING_FLAG_ISO_SEVEN_BITS      0x0008
+
+/* If set, use locking-shift function.  */
+#define CODING_FLAG_ISO_LOCKING_SHIFT   0x0010
+
+/* If set, use single-shift function.  Overwrite
+   CODING_FLAG_ISO_LOCKING_SHIFT.  */
+#define CODING_FLAG_ISO_SINGLE_SHIFT    0x0020
+
+/* If set, designate JISX0201-Roman instead of ASCII.  */
+#define CODING_FLAG_ISO_USE_ROMAN       0x0040
+
+/* If set, designate JISX0208-1978 instead of JISX0208-1983.  */
+#define CODING_FLAG_ISO_USE_OLDJIS      0x0080
+
+/* If set, do not produce ISO6429's direction specifying sequence.  */
+#define CODING_FLAG_ISO_NO_DIRECTION    0x0100
+
+/* Structure of the field `spec.iso2022' in the structure `coding_system'.  */
+struct iso2022_spec
+{
+  /* The current graphic register invoked to each graphic plane.  */
+  int current_invocation[2];
+
+  /* The current charset designated to each graphic register.  */
+  int current_designation[4];
+
+  /* A charset initially designated to each graphic register.  */
+  int initial_designation[4];
+
+  /* A graphic register to which each charset should be designated.  */
+  int requested_designation[MAX_CHARSET];
+
+  /* Set to 1 temporarily only when graphic register 2 or 3 is invoked
+     by single-shift while encoding.  */
+  int single_shifting;
+};
+
+/* Macros to access each field in the structure `spec.iso2022'.  */
+#define CODING_SPEC_ISO_INVOCATION(coding, plane) \
+  coding->spec.iso2022.current_invocation[plane]
+#define CODING_SPEC_ISO_DESIGNATION(coding, reg) \
+  coding->spec.iso2022.current_designation[reg]
+#define CODING_SPEC_ISO_INITIAL_DESIGNATION(coding, reg) \
+  coding->spec.iso2022.initial_designation[reg]
+#define CODING_SPEC_ISO_REQUESTED_DESIGNATION(coding, charset) \
+  coding->spec.iso2022.requested_designation[charset]
+
+/* Set to 1 temporarily only when encoding a character with
+   single-shift function.  */
+#define CODING_SPEC_ISO_SINGLE_SHIFTING(coding) \
+  coding->spec.iso2022.single_shifting
+
+/* Return a charset which is currently designated to the graphic plane
+   PLANE in the coding-system CODING.  */
+#define CODING_SPEC_ISO_PLANE_CHARSET(coding, plane) \
+  CODING_SPEC_ISO_DESIGNATION            \
+  (coding, CODING_SPEC_ISO_INVOCATION (coding, plane))
+
+/*** BIG5 section ***/
+
+/* Macros to denote each type of BIG5 coding system.  */
+#define CODING_FLAG_BIG5_HKU    0x00 /* BIG5-HKU is one of variants of
+                                        BIG5 developed by Hong Kong
+                                        University.  */
+#define CODING_FLAG_BIG5_ETEN   0x01 /* BIG5_ETen is one of variants
+                                        of BIG5 developed by the
+                                        company ETen in Taiwan.  */
+
+/*** GENERAL section ***/
+
+/* Types of coding system.  */
+enum coding_type
+  {
+    coding_type_no_conversion,  /* A coding system which requires no
+                                   conversion for reading and writing
+                                   including end-of-line format.  */
+    coding_type_internal,       /* A coding system used in Emacs'
+                                   buffer and string.  Requires no
+                                   conversion for reading and writing
+                                   except for end-of-line format.  */
+    coding_type_automatic,      /* A coding system which requires
+                                   automatic detection of a real
+                                   coding system.  */
+    coding_type_sjis,           /* SJIS coding system for Japanese.  */
+    coding_type_iso2022,        /* Any coding system of ISO2022
+                                   variants.  */
+    coding_type_big5,           /* BIG5 coding system for Chinese.  */
+    coding_type_ccl             /* The coding system of which decoder
+                                   and encoder are written in CCL.  */
+  };
+
+/* Formats of end-of-line.  */
+#define CODING_EOL_LF   0       /* Line-feed only, same as Emacs'
+                                   internal format.  */
+#define CODING_EOL_CRLF 1       /* Sequence of carriage-return and
+                                   line-feed.  */
+#define CODING_EOL_CR   2       /* Carriage-return only.  */
+#define CODING_EOL_AUTOMATIC 3  /* This value is used to denote the
+                                   eol-type is not yet decided.  */
+
+/* Character composition status while encoding/decoding.  */
+#define COMPOSING_NO             0 /* not composing */
+#define COMPOSING_WITH_RULE_HEAD 1 /* 1st char of with-rule composing follow */
+#define COMPOSING_NO_RULE_HEAD   2 /* 1st char of no-rule composing follow */
+#define COMPOSING_WITH_RULE_TAIL 3 /* Nth char of with-rule composing follow */
+#define COMPOSING_NO_RULE_TAIL   4 /* Nth char of no-rule composing follow */
+#define COMPOSING_WITH_RULE_RULE 5 /* composition rule follow */
+
+/* 1 iff composing.  */
+#define COMPOSING_P(composing) (composing)
+/* 1 iff 1st char of composing element follows.  */
+#define COMPOSING_HEAD_P(composing) \
+  ((composing) && (composing) <= COMPOSING_NO_RULE_HEAD)
+/* 1 iff composing with embeded composition rule.  */
+#define COMPOSING_WITH_RULE_P(composing) ((composing) & 1)
+
+struct coding_system
+{
+  /* Type of the coding system.  */
+  enum coding_type type;
+
+  /* If the coding system requires specific code to be attached at the
+     tail of converted text, this value should be set to `1'.  */
+  int require_flushing;
+
+  /* Flag bits of the coding system.  The meaning of each bit depends
+     on the type of the coding system.  */
+  unsigned int flags;
+
+  /* Type of end-of-line format (LF, CRLF, or CR) of the coding system.  */
+  int eol_type;
+
+  /* Non-zero means that the current source text is the last block of the
+     whole text to be converted.  */
+  int last_block;
+
+  /* Non-zero means that characters are being composed currently while
+     decoding or encoding.  See macros COMPOSING_XXXX above for the
+     meaing of each non-zero value.  */
+  int composing;
+
+  /* 0 (left-to-right) or 1 (right-to-left): the direction of the text
+     being processed currently.  */
+  int direction;
+
+  /* Non-zero means that the current source text is in a buffer which
+     enables selective display.  */
+  int selective;
+
+  /* Detailed information specific to each type of coding system.  */
+  union spec
+    {
+      struct iso2022_spec iso2022;
+      struct ccl_spec ccl;      /* Defined in ccl.h.  */
+    } spec;
+
+  /* Backward pointer to the Lisp symbol of the coding system.  */
+  Lisp_Object symbol;
+
+  /* Lisp function (symbol) to be called after decoding to do
+     additional conversion. */
+  Lisp_Object post_read_conversion;
+
+  /* Lisp function (symbol) to be called before encoding to do
+     additional conversion. */
+  Lisp_Object pre_write_conversion;
+
+  /* Carryover yielded by decoding/encoding incomplete source.  No
+     coding-system yields more than 7-byte of carryover.  This does
+     not include a text which is not processed because of short of
+     output buffer.  */
+  char carryover[8];
+
+  /* Actual data length in the above array.  */
+  int carryover_size;
+};
+
+/* Return 1 if the coding-system CODING requires conversion of
+   representation of a visible character (text).  */
+#define CODING_REQUIRE_TEXT_CONVERSION(coding)  \
+  ((coding)->type != coding_type_no_conversion          \
+   && (coding)->type != coding_type_internal)
+
+/* Return 1 if the coding-system CODING requires conversion of the
+   format of end-of-line.  */
+#define CODING_REQUIRE_EOL_CONVERSION(coding)   \
+  ((coding)->eol_type != CODING_EOL_AUTOMATIC   \
+   && (coding)->eol_type != CODING_EOL_LF)
+
+/* Return 1 if the coding-system CODING requires some conversion.  */
+#define CODING_REQUIRE_CONVERSION(coding)       \
+  (CODING_REQUIRE_TEXT_CONVERSION (coding)      \
+   || CODING_REQUIRE_EOL_CONVERSION (coding))
+
+/* Index for each coding category in `coding_category_table' */
+#define CODING_CATEGORY_IDX_INTERNAL    0
+#define CODING_CATEGORY_IDX_SJIS        1
+#define CODING_CATEGORY_IDX_ISO_7       2
+#define CODING_CATEGORY_IDX_ISO_8_1     3
+#define CODING_CATEGORY_IDX_ISO_8_2     4
+#define CODING_CATEGORY_IDX_ISO_ELSE    5
+#define CODING_CATEGORY_IDX_BIG5        6
+#define CODING_CATEGORY_IDX_BINARY      7
+#define CODING_CATEGORY_IDX_MAX         8
+
+/* Definitions of flag bits returned by the function
+   detect_coding_mask ().  */
+#define CODING_CATEGORY_MASK_INTERNAL   (1 << CODING_CATEGORY_IDX_INTERNAL)
+#define CODING_CATEGORY_MASK_SJIS       (1 << CODING_CATEGORY_IDX_SJIS)
+#define CODING_CATEGORY_MASK_ISO_7      (1 << CODING_CATEGORY_IDX_ISO_7)
+#define CODING_CATEGORY_MASK_ISO_8_1    (1 << CODING_CATEGORY_IDX_ISO_8_1)
+#define CODING_CATEGORY_MASK_ISO_8_2    (1 << CODING_CATEGORY_IDX_ISO_8_2)
+#define CODING_CATEGORY_MASK_ISO_ELSE   (1 << CODING_CATEGORY_IDX_ISO_ELSE)
+#define CODING_CATEGORY_MASK_BIG5       (1 << CODING_CATEGORY_IDX_BIG5)
+
+/* This value is returned if detect_coding_mask () find nothing other
+   than ASCII characters.  */
+#define CODING_CATEGORY_MASK_ANY        \
+  (  CODING_CATEGORY_MASK_INTERNAL      \
+   | CODING_CATEGORY_MASK_SJIS          \
+   | CODING_CATEGORY_MASK_ISO_7         \
+   | CODING_CATEGORY_MASK_ISO_8_1       \
+   | CODING_CATEGORY_MASK_ISO_8_2       \
+   | CODING_CATEGORY_MASK_ISO_ELSE      \
+   | CODING_CATEGORY_MASK_BIG5)
+
+/* Macros to decode or encode a character of JISX0208 in SJIS.  S1 and
+   S2 are the 1st and 2nd position-codes of JISX0208 in SJIS coding
+   system.  C1 and C2 are the 1st and 2nd position codes of Emacs'
+   internal format.  */
+
+#define DECODE_SJIS(s1, s2, c1, c2)                     \
+  do {                                                  \
+    if (s2 >= 0x9F)                                     \
+      c1 = s1 * 2 - (s1 >= 0xE0 ? 0x160 : 0xE0),        \
+      c2 = s2 - 0x7E;                                   \
+    else                                                \
+      c1 = s1 * 2 - ((s1 >= 0xE0) ? 0x161 : 0xE1),      \
+      c2 = s2 - ((s2 >= 0x7F) ? 0x20 : 0x1F);           \
+  } while (0)
+
+#define ENCODE_SJIS(c1, c2, s1, s2)                     \
+  do {                                                  \
+    if (c1 & 1)                                         \
+      s1 = c1 / 2 + ((c1 < 0x5F) ? 0x71 : 0xB1),        \
+      s2 = c2 + ((c2 >= 0x60) ? 0x20 : 0x1F);           \
+    else                                                \
+      s1 = c1 / 2 + ((c1 < 0x5F) ? 0x70 : 0xB0),        \
+      s2 = c2 + 0x7E;                                   \
+  } while (0)
+
+/* Extern declarations.  */
+extern int decode_coding (), encode_coding ();
+extern int decoding_buffer_size (), encoding_buffer_size ();
+extern int conversion_buffer_size;
+extern char *conversion_buffer, *get_conversion_buffer ();
+extern Lisp_Object Fcheck_coding_system ();
+extern Lisp_Object Qcoding_system, Qeol_type, Qcoding_category_index;
+extern Lisp_Object Qbuffer_file_coding_system;
+extern Lisp_Object Vcoding_category_list;
+
+/* Mnemonic character to indicate each type of end-of-line.  */
+extern int eol_mnemonic_unix, eol_mnemonic_dos, eol_mnemonic_mac;
+/* Mnemonic character to indicate type of end-of-line is not yet decided.  */
+extern int eol_mnemonic_undecided;
+
+/* Table of coding-systems currently assigned to each coding-category.  */
+extern Lisp_Object coding_category_table[CODING_CATEGORY_IDX_MAX];
+/* Table of names of symbol for each coding-category.  */
+extern char *coding_category_name[CODING_CATEGORY_IDX_MAX];
+
+#ifdef emacs
+extern Lisp_Object Qfile_coding_system;
+extern Lisp_Object Qcall_process, Qcall_process_region, Qprocess_argument;
+extern Lisp_Object Qstart_process, Qopen_network_stream;
+
+/* Coding-system for reading files and receiving data from process.  */
+extern Lisp_Object Vcoding_system_for_read;
+/* Coding-system for writing files and sending data to process.  */
+extern Lisp_Object Vcoding_system_for_write;
+/* Coding-system actually used in the latest I/O.  */
+extern Lisp_Object Vlast_coding_system_used;
+
+/* Coding-system to be used for encoding terminal output.  This
+   structure contains information of a coding-system specified by the
+   function `set-terminal-coding-system'.  */
+extern struct coding_system terminal_coding;
+
+/* Coding-system of what is sent from terminal keyboard.  This
+   structure contains information of a coding-system specified by the
+   function `set-keyboard-coding-system'.  */
+extern struct coding_system keyboard_coding;
+
+extern Lisp_Object Vcoding_system_alist;
+
+#endif
+
+#endif /* _CODING_H */
diff --git a/src/fontset.c b/src/fontset.c
new file mode 100644
index 00000000000..7d88e90ae89
--- /dev/null
+++ b/src/fontset.c
@@ -0,0 +1,819 @@
+/* Fontset handler.
+   Ver.1.0
+
+   Copyright (C) 1995 Free Software Foundation, Inc.
+   Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#include <config.h>
+#if HAVE_ALLOCA_H
+#include <alloca.h>
+#endif /* HAVE_ALLOCA_H */ 
+#include "lisp.h"
+#include "charset.h"
+#include "ccl.h"
+#include "fontset.h"
+#include "frame.h"
+
+Lisp_Object Vglobal_fontset_alist;
+
+Lisp_Object Vfont_encoding_alist;
+
+/* We had better have our own strcasecmp function because some system
+   doesn't have it.  */
+static char my_strcasetbl[256];
+
+/* Compare two strings S0 and S1 while ignoring differences in case.
+   Return 1 if they differ, else return 0.  */
+static int
+my_strcasecmp (s0, s1)
+     unsigned char *s0, *s1;
+{
+  while (*s0)
+    if (my_strcasetbl[*s0++] != my_strcasetbl[*s1++]) return 1;
+  return (int) *s1;
+}
+
+/* The following six are window system dependent functions.  See
+   the comments in src/fontset.h for more detail.  */
+
+/* Return a pointer to struct font_info of font FONT_IDX of frame F.  */
+struct font_info *(*get_font_info_func) (/* FRAME_PTR f; int font_idx */);
+
+/* Return a list of font names which matches PATTERN.  See the document of
+   `x-list-fonts' for more detail.  */
+Lisp_Object (*list_fonts_func) (/* Lisp_Object pattern, face, frame, width */);
+
+/* Load a font named NAME for frame F and return a pointer to the
+   information of the loaded font.  If loading is failed, return 0.  */
+struct font_info *(*load_font_func) (/* FRAME_PTR f; char *name */);
+
+/* Return a pointer to struct font_info of a font named NAME for frame F.  */
+struct font_info *(*query_font_func) (/* FRAME_PTR f; char *name */);
+
+/* Additional function for setting fontset or changing fontset
+   contents of frame F.  */
+void (*set_frame_fontset_func) (/* FRAME_PTR f; Lisp_Object arg, oldval */);
+
+/* Check if any window system is used now.  */
+void (*check_window_system_func) ();
+
+struct fontset_data *
+alloc_fontset_data ()
+{
+  struct fontset_data *fontset_data
+    = (struct fontset_data *) xmalloc (sizeof (struct fontset_data));
+
+  bzero (fontset_data, sizeof (struct fontset_data));
+
+  return fontset_data;
+}
+
+void
+free_fontset_data (fontset_data)
+     struct fontset_data *fontset_data;
+{
+  int i;
+
+  for (i = 0; i < fontset_data->n_fontsets; i++)
+    {
+      int j;
+
+      xfree (fontset_data->fontset_table[i]->name);
+      for (j = 0; j < MAX_CHARSET; j++)
+        if (fontset_data->fontset_table[i]->fontname[j])
+          xfree (fontset_data->fontset_table[i]->fontname[j]);
+      xfree (fontset_data->fontset_table[i]);
+    }
+  xfree (fontset_data->fontset_table);
+
+  xfree (fontset_data);
+}
+
+/* Load a font named FONTNAME for displaying CHARSET on frame F.
+   All fonts for frame F is stored in a table pointed by FONT_TABLE.
+   Return a pointer to the struct font_info of the loaded font.
+   If loading fails, return 0;
+   If FONTNAME is NULL, the name is taken from the information of FONTSET.
+   If FONTSET is given, try to load a font whose size matches that of
+   FONTSET, and, the font index is stored in the table for FONTSET.  */
+
+struct font_info *
+fs_load_font (f, font_table, charset, fontname, fontset)
+     FRAME_PTR f;
+     struct font_info *font_table;
+     int charset, fontset;
+     char *fontname;
+{
+  Lisp_Object font_list;
+  Lisp_Object list, elt;
+  int font_idx;
+  int size = 0;
+  struct fontset_info *fontsetp = 0;
+  struct font_info *fontp;
+
+  if (fontset >= 0 && fontset < FRAME_FONTSET_DATA (f)->n_fontsets)
+    {
+      fontsetp = FRAME_FONTSET_DATA (f)->fontset_table[fontset];
+      font_idx = fontsetp->font_indexes[charset];
+      if (font_idx >= 0)
+        /* We have already loaded a font.  */
+        return font_table + font_idx;
+      else if (font_idx == FONT_NOT_FOUND)
+        /* We have already tried loading a font and failed.  */
+        return 0;
+      if (!fontname)
+        fontname = fontsetp->fontname[charset];
+    }
+
+  if (!fontname)
+    /* No way to get fontname.  */
+    return 0;
+
+  /* If a fontset is specified and we have already loaded some fonts
+     in the fontset, we need a font of appropriate size to be used
+     with the fonts.  */
+  if (fontsetp && fontsetp->size)
+    size = fontsetp->size * CHARSET_WIDTH (charset);
+
+  fontp = (*load_font_func) (f, fontname, size);
+
+  if (!fontp)
+    {
+      if (fontsetp)
+        fontsetp->font_indexes[charset] = FONT_NOT_FOUND;
+      return 0;
+    }
+
+  /* Fill in fields (CHARSET, ENCODING, and FONT_ENCODER) which are
+     not set by (*load_font_func).  */
+  fontp->charset = charset;
+
+  if (fontp->encoding[1] >= 0)
+    {
+      /* The font itself tells which code points to be used.  Use this
+         encoding for all other charsets.  */
+      int i;
+
+      fontp->encoding[0] = fontp->encoding[1];
+      for (i = MIN_CHARSET_OFFICIAL_DIMENSION1; i < MAX_CHARSET; i++)
+        fontp->encoding[i] = fontp->encoding[1];
+    }
+  else
+    {
+      /* The font itself doesn't tell which code points to be used.  */
+      int i;
+
+      /* At first, set 1 (means 0xA0..0xFF) as the default.  */
+      fontp->encoding[0] = 1;
+      for (i = MIN_CHARSET_OFFICIAL_DIMENSION1; i < MAX_CHARSET; i++)
+        fontp->encoding[i] = 1;
+      /* Then override them by a specification in Vfont_encoding_alist.  */
+      for (list = Vfont_encoding_alist; CONSP (list); list = XCONS (list)->cdr)
+        {
+          elt = XCONS (list)->car;
+          if (CONSP (elt)
+              && STRINGP (XCONS (elt)->car) && CONSP (XCONS (elt)->cdr)
+              && (fast_string_match_ignore_case (XCONS (elt)->car, fontname)
+                  >= 0))
+            {
+              Lisp_Object tmp;
+
+              for (tmp = XCONS (elt)->cdr; CONSP (tmp); tmp = XCONS (tmp)->cdr)
+                if (CONSP (XCONS (tmp)->car)
+                    && INTEGERP (XCONS (XCONS (tmp)->car)->car)
+                    && ((i = get_charset_id (XCONS (XCONS (tmp)->car)->car))
+                        >= 0)
+                    && INTEGERP (XCONS (XCONS (tmp)->car)->cdr)
+                    && XFASTINT (XCONS (XCONS (tmp)->car)->cdr) < 4)
+                  fontp->encoding[i]
+                    = XFASTINT (XCONS (XCONS (tmp)->car)->cdr);
+            }
+        }
+    }
+
+  fontp->font_encoder = (struct ccl_program *) 0;
+  for (list = Vfont_ccl_encoder_alist; CONSP (list); list = XCONS (list)->cdr)
+    {
+      elt = XCONS (list)->car;
+      if (CONSP (elt)
+          && STRINGP (XCONS (elt)->car) && VECTORP (XCONS (elt)->cdr)
+          && fast_string_match_ignore_case (XCONS (elt)->car, fontname) >= 0)
+        {
+          fontp->font_encoder
+            = (struct ccl_program *) xmalloc (sizeof (struct ccl_program));
+          setup_ccl_program (fontp->font_encoder, XCONS (elt)->cdr);
+          break;
+        }
+    }
+
+  if (fontsetp)
+    {
+      fontsetp->font_indexes[charset] = fontp->font_idx;
+      if (fontsetp->size == 0)
+        fontsetp->size = fontp->size / CHARSET_WIDTH (charset);
+
+      if (charset == CHARSET_ASCII
+          && fontsetp->size != fontp->size)
+        {
+          /* When loading ASCII font of the different size from the
+             size of FONTSET, we have to update the size of FONTSET.
+             Since changing the size of FONTSET may make some fonts
+             already loaded inappropriate to be used in FONTSET, we
+             must delete the record of such fonts.  In that case, we
+             also have to calculate the height of FONTSET from the
+             remaining fonts.  */
+          int i;
+
+          fontsetp->size = fontp->size;
+          fontsetp->height = fontp->height;
+          for (i = CHARSET_ASCII + 1; i < MAX_CHARSET; i++)
+            {
+              font_idx = fontsetp->font_indexes[i];
+              if (font_idx >= 0)
+                {
+                  struct font_info *fontp2 = font_table + font_idx;
+
+                  if (fontp2->size != fontp->size * CHARSET_WIDTH (i))
+                    fontsetp->font_indexes[i] = FONT_NOT_OPENED;
+                  else if (fontsetp->height < fontp->height)
+                    fontsetp->height = fontp->height;
+                }
+            }
+        }
+      else if (fontsetp->height < fontp->height)
+        fontsetp->height = fontp->height;
+    }
+
+  return fontp;
+}
+
+/* Return ID of the fontset named NAME on frame F.  */
+
+int
+fs_query_fontset (f, name)
+     FRAME_PTR f;
+     char *name;
+{
+  struct fontset_data *fontset_data = FRAME_FONTSET_DATA (f);
+  int i;
+
+  for (i = 0; i < fontset_data->n_fontsets; i++)
+    if (!my_strcasecmp(name, fontset_data->fontset_table[i]->name))
+      return i;
+  return -1;
+}
+
+/* Register a fontset specified by FONTSET_INFO for frame FRAME.
+   Return the fontset ID if successfully registered, else return -1.
+   FONTSET_INFO is a cons of name of the fontset and FONTLIST, where
+   FONTLIST is an alist of charsets vs fontnames.  */
+
+int
+fs_register_fontset (f, fontset_info)
+     FRAME_PTR f;
+     Lisp_Object fontset_info;
+{
+  struct fontset_data *fontset_data = FRAME_FONTSET_DATA (f);
+  Lisp_Object name, fontlist;
+  int fontset;
+  struct fontset_info *fontsetp;
+  int i;
+
+  if (!CONSP (fontset_info)
+      || !STRINGP (XCONS (fontset_info)->car)
+      || !CONSP (XCONS (fontset_info)->cdr))
+    /* Invalid data in FONTSET_INFO.  */
+    return -1;
+
+  name = XCONS (fontset_info)->car;
+  if ((fontset = fs_query_fontset (f, XSTRING (name)->data)) >= 0)
+    /* This fontset already exists on frame F.  */
+    return fontset;
+
+  fontsetp = (struct fontset_info *) xmalloc (sizeof (struct fontset_info));
+
+  fontsetp->name = (char *) xmalloc (XSTRING (name)->size + 1);
+  bcopy(XSTRING (name)->data, fontsetp->name, XSTRING (name)->size + 1);
+
+  fontsetp->size = fontsetp->height = 0;
+
+  for (i = 0; i < MAX_CHARSET; i++)
+    {
+      fontsetp->fontname[i] = (char *) 0;
+      fontsetp->font_indexes[i] = FONT_NOT_OPENED;
+    }
+
+  for (fontlist = XCONS (fontset_info)->cdr; CONSP (fontlist);
+       fontlist = XCONS (fontlist)->cdr)
+    {
+      Lisp_Object tem = Fcar (fontlist);
+      int charset;
+
+      if (CONSP (tem)
+          && (charset = get_charset_id (XCONS (tem)->car)) >= 0
+          && STRINGP (XCONS (tem)->cdr))
+        {
+          fontsetp->fontname[charset]
+             = (char *) xmalloc (XSTRING (XCONS (tem)->cdr)->size + 1);
+          bcopy (XSTRING (XCONS (tem)->cdr)->data,
+                 fontsetp->fontname[charset],
+                 XSTRING (XCONS (tem)->cdr)->size + 1);
+        }
+      else
+        /* Broken or invalid data structure.  */
+        return -1;
+    }
+
+  /* Do we need to create the table?  */
+  if (fontset_data->fontset_table_size == 0)
+    {
+      fontset_data->fontset_table_size = 8;
+      fontset_data->fontset_table
+        = (struct fontset_info **) xmalloc (fontset_data->fontset_table_size
+                                            * sizeof (struct fontset_info *));
+    }
+  /* Do we need to grow the table?  */
+  else if (fontset_data->n_fontsets >= fontset_data->fontset_table_size)
+    {
+      fontset_data->fontset_table_size += 8;
+      fontset_data->fontset_table
+        = (struct fontset_info **) xrealloc (fontset_data->fontset_table,
+                                             fontset_data->fontset_table_size
+                                             * sizeof (struct fontset_info *));
+    }
+  fontset = fontset_data->n_fontsets++;
+  fontset_data->fontset_table[fontset] = fontsetp;
+
+  return fontset;
+}
+
+/* Cache data used by fontset_pattern_regexp.  The car part is a
+   pattern string containing at least one wild card, the cdr part is
+   the corresponding regular expression.  */
+static Lisp_Object Vcached_fontset_data;
+
+#define CACHED_FONTSET_NAME (XSTRING (XCONS (Vcached_fontset_data)->car)->data)
+#define CACHED_FONTSET_REGEX (XCONS (Vcached_fontset_data)->cdr)
+
+/* If fontset name PATTERN contains any wild card, return regular
+   expression corresponding to PATTERN.  */
+
+Lisp_Object
+fontset_pattern_regexp (pattern)
+     Lisp_Object pattern;
+{
+  int nickname = 0;
+
+  if (!index (XSTRING (pattern)->data, '*')
+      && !index (XSTRING (pattern)->data, '?'))
+    /* PATTERN does not contain any wild cards.  */
+    {
+      if (XSTRING (pattern)->size > 8
+          && ! bcmp (XSTRING (pattern)->data, "fontset-", 8))
+        /* Just a nickname of a fontset is specified.  */
+        nickname = 1;
+      else
+        return Qnil;
+    }
+
+  if (!CONSP (Vcached_fontset_data)
+      || strcmp (XSTRING (pattern)->data, CACHED_FONTSET_NAME))
+    {
+      /* We must at first update the cached data.  */
+      char *regex = (char *) alloca (XSTRING (pattern)->size * 2 + 3);
+      char *p0, *p1 = regex;
+
+      if (nickname)
+        {
+          /* Just prepend ".*-" to PATTERN.  */
+          *p1++= '.'; *p1++= '*', *p1++= '-';
+          bcopy (XSTRING (pattern)->data, p1, XSTRING (pattern)->size);
+          p1 += XSTRING (pattern)->size;
+        }
+      else
+        {
+          /* Convert "*" to ".*", "?" to ".".  */
+          *p1++ = '^';
+          for (p0 = XSTRING (pattern)->data; *p0; p0++)
+            {
+              if (*p0 == '*')
+                {
+                  *p1++ = '.';
+                  *p1++ = '*';
+                }
+              else if (*p0 == '?')
+                *p1++ == '.';
+              else
+                *p1++ = *p0;
+            }
+        }
+      *p1++ = '$';
+      *p1++ = 0;
+
+      Vcached_fontset_data = Fcons (build_string (XSTRING (pattern)->data),
+                                    build_string (regex));
+    }
+
+  return CACHED_FONTSET_REGEX;
+}
+
+DEFUN ("query-fontset", Fquery_fontset, Squery_fontset, 1, 1, 0,
+  "Return a fontset name which matches PATTERN, nil if no matching fontset.\n\
+PATTERN can contain `*' or `?' as a wild card\n\
+just like X's font name matching algorithm allows.")
+  (pattern)
+     Lisp_Object pattern;
+{
+  Lisp_Object regexp, tem;
+
+  (*check_window_system_func) ();
+
+  CHECK_STRING (pattern, 0);
+
+  if (XSTRING (pattern)->size == 0)
+    return Qnil;
+
+  regexp = fontset_pattern_regexp (pattern);
+
+  for (tem = Vglobal_fontset_alist; CONSP (tem); tem = XCONS (tem)->cdr)
+    {
+      Lisp_Object fontset_name = XCONS (XCONS (tem)->car)->car;
+      if (!NILP (regexp))
+        {
+          if (fast_string_match_ignore_case (regexp,
+                                             XSTRING (fontset_name)->data)
+              >= 0)
+            return fontset_name;
+        }
+      else
+        {
+          if (!my_strcasecmp (XSTRING (pattern)->data,
+                              XSTRING (fontset_name)->data))
+            return fontset_name;
+        }
+    }
+
+  return Qnil;
+}
+
+Lisp_Object Fframe_char_width ();
+
+/* Return a list of names of available fontsets matching PATTERN on
+   frame F.  If SIZE is not 0, it is the size (maximum bound width) of
+   fontsets to be listed. */
+
+Lisp_Object
+list_fontsets (f, pattern, size)
+     FRAME_PTR f;
+     Lisp_Object pattern;
+     int size;
+{
+  int i;
+  Lisp_Object regexp, val;
+
+  regexp = fontset_pattern_regexp (pattern);
+
+  val = Qnil;
+  for (i = 0; i < FRAME_FONTSET_DATA (f)->n_fontsets; i++)
+    {
+      struct fontset_info *fontsetp = FRAME_FONTSET_DATA (f)->fontset_table[i];
+      int name_matched = 0;
+      int size_matched = 0;
+
+      if (!NILP (regexp))
+        {
+          if (fast_string_match_ignore_case (regexp, fontsetp->name) >= 0)
+            name_matched = 1;
+        }
+      else
+        {
+          if (!my_strcasecmp (XSTRING (pattern)->data, fontsetp->name))
+            name_matched = 1;     
+        }
+
+      if (name_matched)
+        {
+          if (!size || fontsetp->size == size)
+            size_matched = 1;
+          else if (fontsetp->size == 0)
+            {
+              /* No font of this fontset has loaded yet.  Try loading
+                 one with SIZE.  */
+              int j;
+
+              for (j = 0; j < MAX_CHARSET; j++)
+                if (fontsetp->fontname[j])
+                  {
+                    if ((*load_font_func) (f, fontsetp->fontname[j], size))
+                      size_matched = 1;
+                    break;
+                  }
+            }
+
+          if (size_matched)
+            val = Fcons (build_string (fontsetp->name), val);
+        }
+    }
+
+  return val;
+}
+
+DEFUN ("new-fontset", Fnew_fontset, Snew_fontset, 2, 2, 0,
+  "Create a new fontset NAME which contains fonts in FONTLIST.\n\
+FONTLIST is an alist of charsets vs corresponding font names.")
+  (name, fontlist)
+     Lisp_Object name, fontlist;
+{
+  Lisp_Object fullname, fontset_info;
+  Lisp_Object tail;
+
+  (*check_window_system_func) ();
+
+  CHECK_STRING (name, 0);
+  CHECK_LIST (fontlist, 1);
+
+  fullname = Fquery_fontset (name);
+  if (!NILP (fullname))
+    error ("Fontset \"%s\" matches the existing fontset \"%s\"",
+           XSTRING (name)->data, XSTRING (fullname)->data);
+
+  /* Check the validity of FONTLIST.  */
+  for (tail = fontlist; CONSP (tail); tail = XCONS (tail)->cdr)
+    {
+      Lisp_Object tem = XCONS (tail)->car;
+      int charset;
+
+      if (!CONSP (tem)
+          || (charset = get_charset_id (XCONS (tem)->car)) < 0
+          || !STRINGP (XCONS (tem)->cdr))
+        error ("Elements of fontlist must be a cons of charset and font name");
+    }
+
+  fontset_info = Fcons (name, fontlist);
+  Vglobal_fontset_alist  = Fcons (fontset_info, Vglobal_fontset_alist);
+
+  /* Register this fontset for all existing frames.  */
+  {
+    Lisp_Object framelist, frame;
+    
+    FOR_EACH_FRAME (framelist, frame)
+      if (!FRAME_TERMCAP_P (XFRAME (frame)))
+        fs_register_fontset (XFRAME (frame), fontset_info);
+  }
+
+  return Qnil;
+}
+
+extern Lisp_Object Fframe_parameters ();
+extern Lisp_Object Qfont;
+Lisp_Object Qfontset;
+
+DEFUN ("set-fontset-font", Fset_fontset_font, Sset_fontset_font, 3, 4, 0,
+  "Set FONTNAME for a font of CHARSET in fontset NAME on frame FRAME.\n\
+If FRAME is omitted or nil, all frames are affected.")
+  (name, charset_symbol, fontname, frame)
+     Lisp_Object name, charset_symbol, fontname, frame;
+{
+  int charset;
+  Lisp_Object fullname, fontlist;
+
+  (*check_window_system_func) ();
+
+  CHECK_STRING (name, 0);
+  CHECK_SYMBOL (charset_symbol, 1);
+  CHECK_STRING (fontname, 2);
+  if (!NILP (frame))
+    CHECK_LIVE_FRAME (frame, 3);
+
+  if ((charset = get_charset_id (charset_symbol)) < 0)
+    error ("Invalid charset: %s", XSYMBOL (charset_symbol)->name->data);
+
+  fullname = Fquery_fontset (name);
+  if (NILP (fullname))
+    error ("Fontset \"%s\" does not exist", XSTRING (name)->data);
+
+  /* If FRAME is not specified, we must, at first, update contents of
+     `global-fontset-alist' for a frame created in the future.  */
+  if (NILP (frame))
+    {
+      Lisp_Object fontset_info = Fassoc (fullname, Vglobal_fontset_alist);
+      Lisp_Object tem = Fassq (charset, XCONS (fontset_info)->cdr);
+
+      if (NILP (tem))
+        XCONS (fontset_info)->cdr
+          = Fcons (Fcons (charset, fontname), XCONS (fontset_info)->cdr);
+      else
+        XCONS (tem)->cdr = fontname;
+    }
+
+  /* Then, update information in the specified frame or all existing
+     frames.  */
+  {
+    Lisp_Object framelist, tem;
+
+    FOR_EACH_FRAME (framelist, tem)
+      if (!FRAME_TERMCAP_P (XFRAME (tem))
+          && (NILP (frame) || EQ (frame, tem)))
+        {
+          FRAME_PTR f = XFRAME (tem);
+          int fontset = fs_query_fontset (f, XSTRING (fullname)->data);
+          struct fontset_info *fontsetp
+            = FRAME_FONTSET_DATA (f)->fontset_table[fontset];
+
+          if (fontsetp->fontname[XINT (charset)])
+            xfree (fontsetp->fontname[XINT (charset)]);
+          fontsetp->fontname[XINT (charset)]
+            = (char *) xmalloc (XSTRING (fontname)->size + 1);
+          bcopy (XSTRING (fontname)->data, fontsetp->fontname[XINT (charset)],
+                 XSTRING (fontname)->size + 1);
+          fontsetp->font_indexes[XINT (charset)] = FONT_NOT_OPENED;
+
+          if (charset == CHARSET_ASCII)
+            {
+              Lisp_Object font_param = Fassq (Qfont, Fframe_parameters (tem));
+
+              if (set_frame_fontset_func
+                  && !NILP (font_param)
+                  && !strcmp (XSTRING (fullname)->data,
+                              XSTRING (XCONS (font_param)->cdr)->data))
+                /* This fontset is the default fontset on frame TEM.
+                   We may have to resize this frame because of new
+                   ASCII font.  */
+                (*set_frame_fontset_func) (f, fullname, Qnil);
+            }
+        }
+  }
+
+  return Qnil;
+}
+
+DEFUN ("font-info", Ffont_info, Sfont_info, 1, 2, 0,
+  "Return information about a font named NAME on frame FRAME.\n\
+If FRAME is omitted or nil, use the selected frame.\n\
+The returned value is a vector of OPENED-NAME, FULL-NAME, CHARSET, SIZE,\n\
+  HEIGHT, BASELINE-OFFSET, and RELATIVE-COMPOSE,\n\
+where\n\
+  OPENED-NAME is the name used for opening the font,\n\
+  FULL-NAME is the full name of the font,\n\
+  CHARSET is the charset displayed by the font,\n\
+  SIZE is the minimum bound width of the font,\n\
+  HEIGHT is the height of the font,\n\
+  BASELINE-OFFSET is the upward offset pixels from ASCII baseline,\n\
+  RELATIVE-COMPOSE is the number controlling how to compose characters.\n\
+If the named font is not yet loaded, return nil.")
+  (name, frame)
+     Lisp_Object name, frame;
+{
+  FRAME_PTR f;
+  struct font_info *fontp;
+  Lisp_Object info;
+
+  (*check_window_system_func) ();
+
+  CHECK_STRING (name, 0);
+  if (NILP (frame))
+    f = selected_frame;
+  else
+    {
+      CHECK_LIVE_FRAME (frame, 1);
+      f = XFRAME (frame);
+    }
+
+  if (!query_font_func)
+    error ("Font query function is not supported");
+
+  fontp = (*query_font_func) (f, XSTRING (name)->data);
+  if (!fontp)
+    return Qnil;
+
+  info = Fmake_vector (make_number (6), Qnil);
+
+  XVECTOR (info)->contents[0] = build_string (fontp->name);
+  XVECTOR (info)->contents[1] = build_string (fontp->full_name);
+  XVECTOR (info)->contents[2] = CHARSET_SYMBOL (fontp->charset);
+  XVECTOR (info)->contents[3] = make_number (fontp->size);
+  XVECTOR (info)->contents[4] = make_number (fontp->height);
+  XVECTOR (info)->contents[5] = make_number (fontp->baseline_offset);
+  XVECTOR (info)->contents[6] = make_number (fontp->relative_compose);
+
+  return info;
+}
+
+DEFUN ("fontset-info", Ffontset_info, Sfontset_info, 1, 2, 0,
+  "Return information about a fontset named NAME on frame FRAME.\n\
+If FRAME is omitted or nil, use the selected frame.\n\
+The returned value is a vector of SIZE, HEIGHT, and FONT-LIST,\n\
+where\n\
+  SIZE is the minimum bound width of ASCII font of the fontset,\n\
+  HEIGHT is the height of the tallest font in the fontset, and\n\
+  FONT-LIST is an alist of the format:\n\
+    (CHARSET REQUESTED-FONT-NAME LOADED-FONT-NAME).\n\
+LOADED-FONT-NAME t means the font is not yet loaded, nil means the\n\
+loading failed.")
+  (name, frame)
+     Lisp_Object name, frame;
+{
+  FRAME_PTR f;
+  int fontset;
+  struct fontset_info *fontsetp;
+  Lisp_Object info, val;
+  int i;
+  
+  (*check_window_system_func) ();
+
+  CHECK_STRING(name, 0);
+  if (NILP (frame))
+    f = selected_frame;
+  else
+    {
+      CHECK_LIVE_FRAME (frame, 1);
+      f = XFRAME (frame);
+    }
+
+  fontset = fs_query_fontset (f, XSTRING (name)->data);
+  if (fontset < 0)
+    error ("Fontset \"%s\" does not exist", XSTRING (name)->data);
+
+  info = Fmake_vector (make_number (3), Qnil);
+
+  fontsetp = FRAME_FONTSET_DATA (f)->fontset_table[fontset];
+
+  XVECTOR (info)->contents[0] = make_number (fontsetp->size);
+  XVECTOR (info)->contents[1] = make_number (fontsetp->height);
+  val = Qnil;
+  for (i = 0; i < MAX_CHARSET; i++)
+    if (fontsetp->fontname[i])
+      {
+        int font_idx = fontsetp->font_indexes[i];
+        Lisp_Object loaded;
+
+        if (font_idx == FONT_NOT_OPENED)
+          loaded = Qt;
+        else if (font_idx == FONT_NOT_FOUND)
+          loaded = Qnil;
+        else
+          loaded
+            = build_string ((*get_font_info_func) (f, font_idx)->full_name);
+        val = Fcons (Fcons (CHARSET_SYMBOL (i),
+                            Fcons (build_string (fontsetp->fontname[i]),
+                                   Fcons (loaded, Qnil))),
+                     val);
+      }
+  XVECTOR (info)->contents[2] = val;
+  return info;
+}
+
+syms_of_fontset ()
+{
+  int i;
+
+  for (i = 0; i < 256; i++)
+    my_strcasetbl[i] = (i >= 'A' && i <= 'Z') ? i + 'a' - 'A' : i;
+
+  if (!load_font_func)
+    /* Window system initializer should have set proper functions.  */
+    abort ();
+
+  staticpro (&Qfontset);
+
+  Vcached_fontset_data = Qnil;
+  staticpro (&Vcached_fontset_data);
+
+  DEFVAR_LISP ("global-fontset-alist", &Vglobal_fontset_alist,
+    "Internal data for fontset.  Not for external use.\n\
+This is an alist associating fontset names with the lists of fonts\n\
+ contained in them.\n\
+Newly created frames make their own fontset database from here.");
+  Vglobal_fontset_alist = Qnil;
+
+  DEFVAR_LISP ("font-encoding-alist", &Vfont_encoding_alist,
+    "Alist of fontname patterns vs corresponding encoding info.\n\
+Each element looks like (REGEXP . ENCODING-INFO),\n\
+ where ENCODING-INFO is an alist of CHARSET vs ENCODING.\n\
+ENCODING is one of the following integer values:\n\
+        0: code points 0x20..0x7F or 0x2020..0x7F7F are used,\n\
+        1: code points 0xA0..0xFF or 0xA0A0..0xFFFF are used,\n\
+        2: code points 0x20A0..0x7FFF are used,\n\
+        3: code points 0xA020..0xFF7F are used.");
+  Vfont_encoding_alist = Qnil;
+
+  defsubr (&Squery_fontset);
+  defsubr (&Snew_fontset);
+  defsubr (&Sset_fontset_font);
+  defsubr (&Sfont_info);
+  defsubr (&Sfontset_info);
+}
diff --git a/src/fontset.h b/src/fontset.h
new file mode 100644
index 00000000000..902f1691d6f
--- /dev/null
+++ b/src/fontset.h
@@ -0,0 +1,201 @@
+/* Header for fontset handler.
+   Ver.1.0
+
+   Copyright (C) 1995 Free Software Foundation, Inc.
+   Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#ifndef _FONTSET_H
+#define _FONTSET_H
+
+/* 
+
+#define GENERIC_FONT_PTR void
+
+/* This data type is used for the font_table field of window system
+   depending data area (e.g. struct x_display_info on X window).  */
+
+struct font_info
+{
+  /* Pointer to window system dependent font structure.  On X window,
+     this value should be coerced to (XFontStruct *).  */
+  void *font;
+
+  /* Index number of the font.  */
+  int font_idx;
+
+  /* Name to be used to find the font.  */
+  char *name;
+
+  /* Full name of the font given by a window system.  */
+  char *full_name;
+
+  /* Charset of characters displayed by the font.  */
+  int charset;
+
+  /* Maximum bound width over all existing characters of the font.  On
+     X window, this is same as (font->max_bounds.width) */
+  int size;
+
+  /* Height of the font.  On X window, this is same as (font->ascent
+     + font->descent).  */
+  int height;
+
+  /* Encodings of the font indexed by CHARSET.  The value an integer
+     0, 1, 2, or 3:
+        0: code points 0x20..0x7F or 0x2020..0x7F7F are used
+        1: code points 0xA0..0xFF or 0xA0A0..0xFFFF are used
+        2: code points 0x20A0..0x7FFF are used
+        3: code points 0xA020..0xFF7F are used
+     For instance, ASCII and Latin-1 characters may use the same font
+     but different code points (ASCII uses 0x20..0x7F and Latin-1 uses
+     0xA0..0xFF).
+
+     If the value can't be decided from information of the font, we
+     consult `font-encoding-alist' to get of the corresponding charset
+     whose default value is defined in lisp/fontset.el.  Since there's
+     no charset whose id is 1, we use encoding[1] to store the
+     encoding information decided by the font itself.  */
+  char encoding[MAX_CHARSET];
+
+  /* The baseline position of a font is normally `ascent' value of the
+     font.  However, there exists many fonts which don't set `ascent'
+     an appropriate value to be used as baseline position.  This is
+     typical in such ASCII fonts which are designed to be used with
+     Chinese, Japanese, Korean characters.  When we use mixture of
+     such fonts and normal fonts (having correct `ascent' value), a
+     display line gets very ugly.  Since we have no way to fix it
+     automatically, it is users responsibility to supply well designed
+     fonts or correct `ascent' value of fonts.  But, the latter
+     requires heavy work (modifying all bitmap data in BDF files).
+     So, Emacs accepts a private font property
+     `_MULE_BASELINE_OFFSET'.  If a font has this property, we
+     calculate the baseline position by subtracting the value from
+     `ascent'.  In other words, the value indicates how many bits
+     higher we should draw a character of the font than normal ASCII
+     text for a better looking.
+       
+     We also have to consider the fact that the concept of `baseline'
+     differs among languages to which each character belongs.  For
+     instance, baseline should be at the bottom most position of all
+     glyphs for Chinese, Japanese, and Korean.  But, many of existing
+     fonts for those characters doesn't have correct `ascent' values
+     because they are designed to be used with ASCII fonts.  To
+     display characters of different language on the same line, the
+     best way will be to arrange them in the middle of the line.  So,
+     in such a case, again, we utilize the font property
+     `_MULE_BASELINE_OFFSET'.  If the value is larger than `ascent' we
+     calculate baseline so that a character is arranged in the middle
+     of a line.  */
+
+  int baseline_offset;
+
+  /* Non zero means a character should be composed at a position
+     relative to the height (or depth) of previous glyphs in the
+     following cases:
+        (1) The bottom of the character is higher than this value.  In
+        this case, the character is drawn above the previous glyphs.
+        (2) The top of the character is lower than 0 (i.e. baseline
+        height).  In this case, the character is drawn beneath the
+        previous glyphs.
+
+     This value is take from a private font property
+     `_MULE_RELATIVE_COMPOSE' which is introduced by Emacs.  */
+  int relative_compose;
+
+  /* CCL program to calculate code points of the font.  */
+  struct ccl_program *font_encoder;
+};
+
+#define FONT_NOT_OPENED -1
+#define FONT_NOT_FOUND  -2
+
+struct fontset_info
+{
+  /* Name of the fontset.  */
+  char *name;
+
+  /* Size of the fontset.  This is the same as the size of ASCII font
+     of this fontset.  */
+  int size;
+
+  /* Height of the tallest font in the fontset.  */
+  int height;
+
+  /* Table of font name for each character set.  */
+  char *fontname[MAX_CHARSET];
+
+  /* Table of index numbers of fonts indexed by charset.  If a font is
+     not yet loaded, the value is -1 (FONT_NOT_OPENED).  If font
+     loading is failed, the value is -2 (FONT_NOT_FOUND).  */
+  int font_indexes[MAX_CHARSET];
+};
+
+/* This data type is used for the fontset_data field of struct frame.  */
+
+struct fontset_data
+{
+  /* A table of pointers to all the fontsets.  */
+  struct fontset_info **fontset_table;
+
+  /* The current capacity of fontset_table.  */
+  int fontset_table_size;
+
+  /* The number of fontsets actually stored in fontset_table.
+     fontset_table[n] is used and valid iff 0 <= n < n_fontsets.
+     0 <= n_fontsets <= fontset_table_size.  */
+  int n_fontsets;
+};
+
+/* The following six are window system dependent functions.
+   Initialization routine of each window system should set appropriate
+   functions to these variables.  For instance, in case of X window,
+   x_term_init does this.  */
+
+/* Return a pointer to struct font_info of font FONT_IDX of frame F.  */
+extern struct font_info *(*get_font_info_func) (/* FRAME_PTR f;
+                                                    int font_idx */);
+
+/* Return a list of font names which matches PATTERN.  See the document of
+   `x-list-fonts' for more detail.  */
+extern Lisp_Object (*list_fonts_func) (/* Lisp_Object pattern, face, frame,
+                                          width */);
+
+/* Load a font named NAME for frame F and return a pointer to the
+   information of the loaded font.  If loading is failed, return -1.  */
+extern struct font_info *(*load_font_func) (/* FRAME_PTR f; char *name */);
+
+/* Return a pointer to struct font_info of a font named NAME for frame F.
+   If no such font is loaded, return NULL.  */
+extern struct font_info *(*query_font_func) (/* FRAME_PTR f; char *name */);
+
+/* Additional function for setting fontset or changing fontset
+   contents of frame F.  This function may change the coordinate of
+   the frame.  */
+extern void (*set_frame_fontset_func) (/* FRAME_PTR f; Lisp_Object arg, oldval */);
+
+/* Check if any window system is used now.  */
+extern void (*check_window_system_func) ();
+
+extern struct fontset_data *alloc_fontset_data ();
+extern void free_fontset_data ();
+extern struct font_info *fs_load_font ();
+extern Lisp_Object list_fontsets ();
+extern Lisp_Object Vglobal_fontset_alist;
+
+extern Lisp_Object Qfontset;
+
+#endif /* _FONTSET_H */