Initial revision

35 files changed, 12893 insertions, 0 deletions

diff --git a/lisp/gnus/gnus-mule.el b/lisp/gnus/gnus-mule.el
new file mode 100644
index 00000000000..b7abab722d3
--- /dev/null
+++ b/lisp/gnus/gnus-mule.el
@@ -0,0 +1,179 @@
+;; gnus-mule.el -- Provide multilingual environment to GNUS
+
+;; Copyright (C) 1995 Free Software Foundation, Inc.
+;; Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+;; Keywords: gnus, mule
+
+;; 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.
+
+;;; Commentary:
+
+;; This package enables GNUS to code convert automatically
+;; accoding to a coding system specified for each news group.
+;; Please put the following line in your .emacs:
+;;      (add-hook 'gnus-startup-hook 'gnus-mule-initialize)
+;; If you want to specify some coding system for a specific news
+;; group, add the fllowing line in your .emacs:
+;;      (gnus-mule-add-group "xxx.yyy.zzz" 'some-coding-system)
+;;
+;; Decoding of summary buffer is not yet implemented.
+
+(require 'gnus)
+
+(defvar gnus-newsgroup-coding-systems nil
+  "Assoc list of news groups vs corresponding coding systems.
+Each element is a list of news group name and cons of coding systems
+for reading and posting.")
+
+;;;###autoload
+(defun gnus-mule-add-group (name coding-system)
+  "Specify that articles of news group NAME are encoded in CODING-SYSTEM.
+All news groups deeper than NAME are also the target.
+If CODING-SYSTEM is a cons, the car and cdr part are regarded as
+coding-system for reading and writing respectively."
+  (if (not (consp coding-system))
+      (setq coding-system (cons coding-system coding-system)))
+  (setq name (concat "^" (regexp-quote name)))
+  (let ((group (assoc name gnus-newsgroup-coding-systems)))
+    (if group
+        (setcdr group coding-system)
+      (setq gnus-newsgroup-coding-systems
+            (cons (cons name coding-system) gnus-newsgroup-coding-systems)))))
+
+(defun gnus-mule-get-coding-system (group)
+  "Return the coding system for news group GROUP."
+  (let ((groups gnus-newsgroup-coding-systems)
+        (len -1)
+        coding-system)
+    ;; Find an entry which matches GROUP the best (i.e. longest).
+    (while groups
+      (if (and (string-match (car (car groups)) group)
+               (> (match-end 0) len))
+          (setq len (match-end 0)
+                coding-system (cdr (car groups))))
+      (setq groups (cdr groups)))
+    coding-system))
+
+;; Flag to indicate if article buffer is already decoded or not.")
+(defvar gnus-mule-article-decoded nil)
+;; Codingsystem for reading articles of the current news group.
+(defvar gnus-mule-coding-system nil)
+(defvar gnus-mule-subject nil)
+(defvar gnus-mule-decoded-subject nil)
+(defvar gnus-mule-original-subject nil)
+
+;; Encode (if ENCODING is t) or decode (if ENCODING is nil)  the
+;; region from START to END by CODING-SYSTEM.
+(defun gnus-mule-code-convert1 (start end coding-system encoding)
+  (if (< start end)
+      (save-excursion
+       (if encoding
+           (encode-coding-region start end coding-system)
+         (decode-coding-region start end coding-system)))))
+
+;; Encode (if ENCODING is t) or decode (if ENCODING is nil) the
+;; current buffer by CODING-SYSTEM.  Try not to move positions of
+;; (window-start) and (point).
+(defun gnus-mule-code-convert (coding-system encoding)
+  (if coding-system
+      (let ((win (get-buffer-window (current-buffer))))
+        (if win
+            ;; We should keep (point) and (window-start).
+            (save-window-excursion
+              (select-window win)
+              (if encoding
+                  ;; Simple way to assure point is on valid character boundary.
+                  (beginning-of-line))
+              (gnus-mule-code-convert1 (point-min) (window-start)
+                                       coding-system encoding)
+              (gnus-mule-code-convert1 (window-start) (point)
+                                       coding-system encoding)
+              (gnus-mule-code-convert1 (point) (point-max)
+                                       coding-system encoding)
+              (if (not (pos-visible-in-window-p))
+                  ;; point went out of window, move to the bottom of window.
+                  (move-to-window-line -1)))
+          ;; No window for the buffer, no need to worry about (point)
+          ;; and (windos-start).
+          (gnus-mule-code-convert1 (point-min) (point-max)
+                                   coding-system encoding))
+        )))
+
+;; Set `gnus-mule-coding-system' to the coding system articles of the
+;; current news group is encoded.   This function is set in
+;; `gnus-select-group-hook'.
+(defun gnus-mule-select-coding-system ()
+  (let ((coding-system (gnus-mule-get-coding-system gnus-newsgroup-name)))
+    (setq gnus-mule-coding-system
+          (if (and coding-system (coding-system-p (car coding-system)))
+              (car coding-system)))))
+
+;; Decode the current article.  This function is set in
+;; `gnus-article-prepare-hook'.
+(defun gnus-mule-decode-article ()
+  (gnus-mule-code-convert gnus-mule-coding-system nil)
+  (setq gnus-mule-article-decoded t))
+
+;; Decode the current summary buffer.  This function is set in
+;; `gnus-summary-prepare-hook'. 
+(defun gnus-mule-decode-summary ()
+  ;; I have not yet implemented this function because I'm not yet
+  ;; familiar with the new Gnus codes, especialy how to extract only
+  ;; subjects from a summary buffer.
+  nil)
+
+(defun gnus-mule-toggle-article-format ()
+  "Toggle decoding/encoding of the current article buffer."
+  (interactive)
+  (let ((buf (get-buffer gnus-article-buffer)))
+    (if (and gnus-mule-coding-system buf)
+        (save-excursion
+          (set-buffer buf)
+          (let ((modif (buffer-modified-p))
+                buffer-read-only)
+            (gnus-mule-code-convert gnus-mule-coding-system
+                                   gnus-mule-article-decoded)
+            (setq gnus-mule-article-decoded (not gnus-mule-article-decoded))
+            (set-buffer-modified-p modif))))))
+
+;;;###autoload
+(defun gnus-mule-initialize ()
+  "Do several settings for GNUS to enable automatic code conversion."
+  ;; Convenient key definitions
+  (define-key gnus-article-mode-map "z" 'gnus-mule-toggle-article-format)
+  (define-key gnus-summary-mode-map "z" 'gnus-mule-toggle-article-format)
+  ;; Hook definition
+  (add-hook 'gnus-select-group-hook 'gnus-mule-select-coding-system)
+  (add-hook 'gnus-summary-prepare-hook 'gnus-mule-decode-summary)
+  (add-hook 'gnus-article-prepare-hook 'gnus-mule-decode-article))
+
+(gnus-mule-add-group "" 'coding-system-iso-2022-7) ;; default coding system
+(gnus-mule-add-group "alt" 'no-conversion)
+(gnus-mule-add-group "comp" 'no-conversion)
+(gnus-mule-add-group "gnu" 'no-conversion)
+(gnus-mule-add-group "rec" 'no-conversion)
+(gnus-mule-add-group "sci" 'no-conversion)
+(gnus-mule-add-group "soc" 'no-conversion)
+(gnus-mule-add-group "alt.chinese.text" 'coding-system-hz)
+(gnus-mule-add-group "alt.hk" 'coding-system-hz)
+(gnus-mule-add-group "alt.chinese.text.big5" 'coding-system-big5)
+(gnus-mule-add-group "soc.culture.vietnamese" '(nil . coding-system-viqr))
+
+(add-hook 'gnus-startup-hook 'gnus-mule-initialize)
+
+;; gnus-mule.el ends here
diff --git a/lisp/international/ccl.el b/lisp/international/ccl.el
new file mode 100644
index 00000000000..da2f1585d87
--- /dev/null
+++ b/lisp/international/ccl.el
@@ -0,0 +1,1106 @@
+;; ccl.el -- CCL (Code Conversion Language) compiler
+
+;; Copyright (C) 1995 Free Software Foundation, Inc.
+;; Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+;; Keywords: CCL, mule, multilingual, character set, coding-system
+
+;; 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.
+
+;;; Commentary:
+
+;; CCL (Code Conversion Language) is a simple programming language to
+;; be used for various kind of code conversion.  CCL program is
+;; compiled to CCL code (vector of integers) and executed by CCL
+;; interpreter of Emacs.
+;;
+;; CCL is used for code conversion at process I/O and file I/O for
+;; non-standard coding-system.  In addition, it is used for
+;; calculating a code point of X's font from a character code.
+;; However, since CCL is designed as a powerful programming language,
+;; it can be used for more generic calculation.  For instance,
+;; combination of three or more arithmetic operations can be
+;; calculated faster than Emacs Lisp.
+;;
+;; Here's the syntax of CCL program in BNF notation.
+;;
+;; CCL_PROGRAM :=
+;;      (BUFFER_MAGNIFICATION
+;;       CCL_MAIN_BLOCK
+;;       [ CCL_EOF_BLOCK ])
+;;
+;; BUFFER_MAGNIFICATION := integer
+;; CCL_MAIN_BLOCK := CCL_BLOCK
+;; CCL_EOF_BLOCK := CCL_BLOCK
+;;
+;; CCL_BLOCK :=
+;;      STATEMENT | (STATEMENT [STATEMENT ...])
+;; STATEMENT :=
+;;      SET | IF | BRANCH | LOOP | REPEAT | BREAK | READ | WRITE | CALL
+;;
+;; SET :=
+;;      (REG = EXPRESSION)
+;;      | (REG ASSIGNMENT_OPERATOR EXPRESSION)
+;;      | integer
+;;
+;; EXPRESSION := ARG | (EXPRESSION OPERATOR ARG)
+;;
+;; IF := (if EXPRESSION CCL_BLOCK CCL_BLOCK)
+;; BRANCH := (branch EXPRESSION CCL_BLOCK [CCL_BLOCK ...])
+;; LOOP := (loop STATEMENT [STATEMENT ...])
+;; BREAK := (break)
+;; REPEAT :=
+;;      (repeat)
+;;      | (write-repeat [REG | integer | string])
+;;      | (write-read-repeat REG [integer | ARRAY])
+;; READ :=
+;;      (read REG ...)
+;;      | (read-if (REG OPERATOR ARG) CCL_BLOCK CCL_BLOCK)
+;;      | (read-branch REG CCL_BLOCK [CCL_BLOCK ...])
+;; WRITE :=
+;;      (write REG ...)
+;;      | (write EXPRESSION)
+;;      | (write integer) | (write string) | (write REG ARRAY)
+;;      | string
+;; CALL := (call ccl-program-name)
+;; END := (end)
+;;
+;; REG := r0 | r1 | r2 | r3 | r4 | r5 | r6 | r7
+;; ARG := REG | integer
+;; OPERATOR :=
+;;      + | - | * | / | % | & | '|' | ^ | << | >> | <8 | >8 | //
+;;      | < | > | == | <= | >= | != | de-sjis | en-sjis
+;; ASSIGNMENT_OPERATOR :=
+;;      += | -= | *= | /= | %= | &= | '|=' | ^= | <<= | >>=
+;; ARRAY := '[' interger ... ']'
+
+;;; Code:
+
+(defconst ccl-command-table
+  [if branch loop break repeat write-repeat write-read-repeat
+      read read-if read-branch write call end]
+  "*Vector of CCL commands (symbols).")
+
+;; Put a property to each symbol of CCL commands for the compiler.
+(let (op (i 0) (len (length ccl-command-table)))
+  (while (< i len)
+    (setq op (aref ccl-command-table i))
+    (put op 'ccl-compile-function (intern (format "ccl-compile-%s" op)))
+    (setq i (1+ i))))
+
+(defconst ccl-code-table
+  [set-register
+   set-short-const
+   set-const
+   set-array
+   jump
+   jump-cond
+   write-register-jump
+   write-register-read-jump
+   write-const-jump
+   write-const-read-jump
+   write-string-jump
+   write-array-read-jump
+   read-jump
+   branch
+   read-register
+   write-expr-const
+   read-branch
+   write-register
+   write-expr-register
+   call
+   write-const-string
+   write-array
+   end
+   set-assign-expr-const
+   set-assign-expr-register
+   set-expr-const
+   set-expr-register
+   jump-cond-expr-const
+   jump-cond-expr-register
+   read-jump-cond-expr-const
+   read-jump-cond-expr-register
+   ]
+  "*Vector of CCL compiled codes (symbols).")
+
+;; Put a property to each symbol of CCL codes for the disassembler.
+(let (code (i 0) (len (length ccl-code-table)))
+  (while (< i len)
+    (setq code (aref ccl-code-table i))
+    (put code 'ccl-code i)
+    (put code 'ccl-dump-function (intern (format "ccl-dump-%s" code)))
+    (setq i (1+ i))))
+
+(defconst ccl-jump-code-list
+  '(jump jump-cond write-register-jump write-register-read-jump
+    write-const-jump write-const-read-jump write-string-jump
+    write-array-read-jump read-jump))
+
+;; Put a property `jump-flag' to each CCL code which execute jump in
+;; some way.
+(let ((l ccl-jump-code-list))
+  (while l
+    (put (car l) 'jump-flag t)
+    (setq l (cdr l))))
+
+(defconst ccl-register-table
+  [r0 r1 r2 r3 r4 r5 r6 r7]
+  "*Vector of CCL registers (symbols).")
+
+;; Put a property to indicate register number to each symbol of CCL.
+;; registers.
+(let (reg (i 0) (len (length ccl-register-table)))
+  (while (< i len)
+    (setq reg (aref ccl-register-table i))
+    (put reg 'ccl-register-number i)
+    (setq i (1+ i))))
+
+(defconst ccl-arith-table
+  [+ - * / % & | ^ << >> <8 >8 // nil nil nil
+   < > == <= >= != de-sjis en-sjis]
+  "*Vector of CCL arithmetic/logical operators (symbols).")
+
+;; Put a property to each symbol of CCL operators for the compiler.
+(let (arith (i 0) (len (length ccl-arith-table)))
+  (while (< i len)
+    (setq arith (aref ccl-arith-table i))
+    (if arith (put arith 'ccl-arith-code i))
+    (setq i (1+ i))))
+
+(defconst ccl-assign-arith-table
+  [+= -= *= /= %= &= |= ^= <<= >>= <8= >8= //=]
+  "*Vector of CCL assignment operators (symbols).")
+
+;; Put a property to each symbol of CCL assignment operators for the compiler.
+(let (arith (i 0) (len (length ccl-assign-arith-table)))
+  (while (< i len)
+    (setq arith (aref ccl-assign-arith-table i))
+    (put arith 'ccl-self-arith-code i)
+    (setq i (1+ i))))
+
+(defvar ccl-program-vector nil
+  "Working vector of CCL codes produced by CCL compiler.")
+(defvar ccl-current-ic 0
+  "The current index for `ccl-program-vector'.")
+
+;; Embed integer DATA in `ccl-program-vector' at `ccl-current-ic' and
+;; increment it.  If IC is specified, embed DATA at IC.
+(defun ccl-embed-data (data &optional ic)
+  (if ic
+      (aset ccl-program-vector ic data)
+    (aset ccl-program-vector ccl-current-ic data)
+    (setq ccl-current-ic (1+ ccl-current-ic))))
+
+;; Embed string STR of length LEN in `ccl-program-vector' at
+;; `ccl-current-ic'.
+(defun ccl-embed-string (len str)
+  (let ((i 0))
+    (while (< i len)
+      (ccl-embed-data (logior (ash (aref str i) 16)
+                               (if (< (1+ i) len)
+                                   (ash (aref str (1+ i)) 8)
+                                 0)
+                               (if (< (+ i 2) len)
+                                   (aref str (+ i 2))
+                                 0)))
+      (setq i (+ i 3)))))
+
+;; Embed a relative jump address to `ccl-current-ic' in
+;; `ccl-program-vector' at IC without altering the other bit field.
+(defun ccl-embed-current-address (ic)
+  (let ((relative (- ccl-current-ic (1+ ic))))
+    (aset ccl-program-vector ic
+          (logior (aref ccl-program-vector ic) (ash relative 8)))))
+
+;; Embed CCL code for the operation OP and arguments REG and DATA in
+;; `ccl-program-vector' at `ccl-current-ic' in the following format.
+;;      |----------------- integer (28-bit) ------------------|
+;;      |------------ 20-bit ------------|- 3-bit --|- 5-bit -|
+;;      |------------- DATA -------------|-- REG ---|-- OP ---|
+;; If REG2 is specified, embed a code in the following format.
+;;      |------- 17-bit ------|- 3-bit --|- 3-bit --|- 5-bit -|
+;;      |-------- DATA -------|-- REG2 --|-- REG ---|-- OP ---|
+
+;; If REG is a CCL register symbol (e.g. r0, r1...), the register
+;; number is embedded.  If OP is one of unconditional jumps, DATA is
+;; changed to an absolute jump address.
+
+(defun ccl-embed-code (op reg data &optional reg2)
+  (if (and (> data 0) (get op 'jump-flag))
+      ;; DATA is an absolute jump address.  Make it relative to the
+      ;; next of jump code.
+      (setq data (- data (1+ ccl-current-ic))))
+  (let ((code (logior (get op 'ccl-code)
+                      (ash
+                       (if (symbolp reg) (get reg 'ccl-register-number) reg) 5)
+                      (if reg2
+                          (logior (ash (get reg2 'ccl-register-number) 8)
+                                  (ash data 11))
+                        (ash data 8)))))
+    (aset ccl-program-vector ccl-current-ic code)
+    (setq ccl-current-ic (1+ ccl-current-ic))))
+
+;; Just advance `ccl-current-ic' by INC.
+(defun ccl-increment-ic (inc)
+  (setq ccl-current-ic (+ ccl-current-ic inc)))
+
+;;;###autoload
+(defun ccl-program-p (obj)
+  "T if OBJECT is a valid CCL compiled code."
+  (and (vectorp obj)
+       (let ((i 0) (len (length obj)) (flag t))
+         (if (> len 1)
+             (progn
+               (while (and flag (< i len))
+                 (setq flag (integerp (aref obj i)))
+                 (setq i (1+ i)))
+               flag)))))
+
+;; If non-nil, index of the start of the current loop.
+(defvar ccl-loop-head nil)
+;; If non-nil, list of absolute addresses of the breaking points of
+;; the current loop.
+(defvar ccl-breaks nil)
+
+;;;###autoload
+(defun ccl-compile (ccl-program)
+  "Return a comiled code of CCL-PROGRAM as a vector of integer."
+  (if (or (null (consp ccl-program))
+          (null (integerp (car ccl-program)))
+          (null (listp (car (cdr ccl-program)))))
+      (error "CCL: Invalid CCL program: %s" ccl-program))
+  (if (null (vectorp ccl-program-vector))
+      (setq ccl-program-vector (make-vector 8192 0)))
+  (setq ccl-loop-head nil ccl-breaks nil)
+  (setq ccl-current-ic 0)
+
+  ;; The first element is the buffer magnification.
+  (ccl-embed-data (car ccl-program))
+
+  ;; The second element is the address of the start CCL code for
+  ;; processing end of input buffer (we call it eof-processor).  We
+  ;; set it later.
+  (ccl-increment-ic 1)
+
+  ;; Compile the main body of the CCL program.
+  (ccl-compile-1 (car (cdr ccl-program)))
+
+  ;; Embed the address of eof-processor.
+  (ccl-embed-data ccl-current-ic 1)
+
+  ;; Then compile eof-processor.
+  (if (nth 2 ccl-program)
+      (ccl-compile-1 (nth 2 ccl-program)))
+
+  ;; At last, embed termination code.
+  (ccl-embed-code 'end 0 0)
+
+  (let ((vec (make-vector ccl-current-ic 0))
+        (i 0))
+    (while (< i ccl-current-ic)
+      (aset vec i (aref ccl-program-vector i))
+      (setq i (1+ i)))
+    vec))
+
+;; Signal syntax error.
+(defun ccl-syntax-error (cmd)
+  (error "CCL: Syntax error: %s" cmd))
+
+;; Check if ARG is a valid CCL register.
+(defun ccl-check-register (arg cmd)
+  (if (get arg 'ccl-register-number)
+      arg
+    (error "CCL: Invalid register %s in %s." arg cmd)))
+
+;; Check if ARG is a valid CCL command.
+(defun ccl-check-compile-function (arg cmd)
+  (or (get arg 'ccl-compile-function)
+      (error "CCL: Invalid command: %s" cmd)))
+
+;; In the following code, most ccl-compile-XXXX functions return t if
+;; they end with unconditional jump, else return nil.
+
+;; Compile CCL-BLOCK (see the syntax above).
+(defun ccl-compile-1 (ccl-block)
+  (let (unconditional-jump
+        cmd)
+    (if (or (integerp ccl-block)
+            (stringp ccl-block)
+            (and ccl-block (symbolp (car ccl-block))))
+        ;; This block consists of single statement.
+        (setq ccl-block (list ccl-block)))
+
+    ;; Now CCL-BLOCK is a list of statements.  Compile them one by
+    ;; one.
+    (while ccl-block
+      (setq cmd (car ccl-block))
+      (setq unconditional-jump
+            (cond ((integerp cmd)
+                   ;; SET statement for the register 0.
+                   (ccl-compile-set (list 'r0 '= cmd)))
+
+                  ((stringp cmd)
+                   ;; WRITE statement of string argument.
+                   (ccl-compile-write-string cmd))
+
+                  ((listp cmd)
+                   ;; The other statements.
+                   (cond ((eq (nth 1 cmd) '=)
+                          ;; SET statement of the form `(REG = EXPRESSION)'.
+                          (ccl-compile-set cmd))
+
+                         ((and (symbolp (nth 1 cmd))
+                               (get (nth 1 cmd) 'ccl-self-arith-code))
+                          ;; SET statement with an assignment operation.
+                          (ccl-compile-self-set cmd))
+
+                         (t
+                          (funcall (ccl-check-compile-function (car cmd) cmd)
+                                   cmd))))
+
+                  (t
+                   (ccl-syntax-error cmd))))
+      (setq ccl-block (cdr ccl-block)))
+    unconditional-jump))
+
+(defconst ccl-max-short-const (ash 1 19))
+(defconst ccl-min-short-const (ash -1 19))
+
+;; Compile SET statement.
+(defun ccl-compile-set (cmd)
+  (let ((rrr (ccl-check-register (car cmd) cmd))
+        (right (nth 2 cmd)))
+    (cond ((listp right)
+           ;; CMD has the form `(RRR = (XXX OP YYY))'.
+           (ccl-compile-expression rrr right))
+
+          ((integerp right)
+           ;; CMD has the form `(RRR = integer)'.
+           (if (and (<= right ccl-max-short-const)
+                    (>= right ccl-min-short-const))
+               (ccl-embed-code 'set-short-const rrr right)
+             (ccl-embed-code 'set-const rrr 0)
+             (ccl-embed-data right)))
+
+          (t
+           ;; CMD has the form `(RRR = rrr [ array ])'.
+           (ccl-check-register right cmd)
+           (let ((ary (nth 3 cmd)))
+             (if (vectorp ary)
+                 (let ((i 0) (len (length ary)))
+                   (ccl-embed-code 'set-array rrr len right)
+                   (while (< i len)
+                     (ccl-embed-data (aref ary i))
+                     (setq i (1+ i))))
+               (ccl-embed-code 'set-register rrr 0 right))))))
+  nil)
+
+;; Compile SET statement with ASSIGNMENT_OPERATOR.
+(defun ccl-compile-self-set (cmd)
+  (let ((rrr (ccl-check-register (car cmd) cmd))
+        (right (nth 2 cmd)))
+    (if (listp right)
+        ;; CMD has the form `(RRR ASSIGN_OP (XXX OP YYY))', compile
+        ;; the right hand part as `(r7 = (XXX OP YYY))' (note: the
+        ;; register 7 can be used for storing temporary value).
+        (progn
+          (ccl-compile-expression 'r7 right)
+          (setq right 'r7)))
+    ;; Now CMD has the form `(RRR ASSIGN_OP ARG)'.  Compile it as
+    ;; `(RRR = (RRR OP ARG))'.
+    (ccl-compile-expression
+     rrr
+     (list rrr (intern (substring (symbol-name (nth 1 cmd)) 0 -1)) right)))
+  nil)
+
+;; Compile SET statement of the form `(RRR = EXPR)'.
+(defun ccl-compile-expression (rrr expr)
+  (let ((left (car expr))
+        (op (get (nth 1 expr) 'ccl-arith-code))
+        (right (nth 2 expr)))
+    (if (listp left)
+        (progn
+          ;; EXPR has the form `((EXPR2 OP2 ARG) OP RIGHT)'.  Compile
+          ;; the first term as `(r7 = (EXPR2 OP2 ARG)).'
+          (ccl-compile-expression 'r7 left)
+          (setq left 'r7)))
+
+    ;; Now EXPR has the form (LEFT OP RIGHT).
+    (if (eq rrr left)
+        ;; Compile this SET statement as `(RRR OP= RIGHT)'.
+        (if (integerp right)
+            (progn
+              (ccl-embed-code 'set-assign-expr-const rrr (ash op 3) 'r0)
+              (ccl-embed-data right))
+          (ccl-check-register right expr)
+          (ccl-embed-code 'set-assign-expr-register rrr (ash op 3) right))
+
+      ;; Compile this SET statement as `(RRR = (LEFT OP RIGHT))'.
+      (if (integerp right)
+          (progn
+            (ccl-embed-code 'set-expr-const rrr (ash op 3) left)
+            (ccl-embed-data right))
+        (ccl-check-register right expr)
+        (ccl-embed-code 'set-expr-register
+                        rrr
+                        (logior (ash op 3) (get right 'ccl-register-number))
+                        left)))))
+
+;; Compile WRITE statement with string argument.
+(defun ccl-compile-write-string (str)
+  (let ((len (length str)))
+    (ccl-embed-code 'write-const-string 1 len)
+    (ccl-embed-string len str))
+  nil)
+
+;; Compile IF statement of the form `(if CONDITION TRUE-PART FALSE-PART)'.
+;; If READ-FLAG is non-nil, this statement has the form
+;; `(read-if (REG OPERATOR ARG) TRUE-PART FALSE-PART)'.
+(defun ccl-compile-if (cmd &optional read-flag)
+  (if (and (/= (length cmd) 3) (/= (length cmd) 4))
+      (error "CCL: Invalid number of arguments: %s" cmd))
+  (let ((condition (nth 1 cmd))
+        (true-cmds (nth 2 cmd))
+        (false-cmds (nth 3 cmd))
+        jump-cond-address
+        false-ic)
+    (if (and (listp condition)
+             (listp (car condition)))
+        ;; If CONDITION is a nested expression, the inner expression
+        ;; should be compiled at first as SET statement, i.e.:
+        ;; `(if ((X OP2 Y) OP Z) ...)' is compiled into two statements:
+        ;; `(r7 = (X OP2 Y)) (if (r7 OP Z) ...)'.
+        (progn
+          (ccl-compile-expression 'r7 (car condition))
+          (setq condition (cons 'r7 (cdr condition)))
+          (setq cmd (cons (car cmd)
+                          (cons condition (cdr (cdr cmd)))))))
+
+    (setq jump-cond-address ccl-current-ic)
+    ;; Compile CONDITION.
+    (if (symbolp condition)
+        ;; CONDITION is a register.
+        (progn
+          (ccl-check-register condition cmd)
+          (ccl-embed-code 'jump-cond condition 0))
+      ;; CONDITION is a simple expression of the form (RRR OP ARG).
+      (let ((rrr (car condition))
+            (op (get (nth 1 condition) 'ccl-arith-code))
+            (arg (nth 2 condition)))
+        (ccl-check-register rrr cmd)
+        (if (integerp arg)
+            (progn
+              (ccl-embed-code (if read-flag 'read-jump-cond-expr-const
+                                'jump-cond-expr-const)
+                              rrr 0)
+              (ccl-embed-data op)
+              (ccl-embed-data arg))
+          (ccl-check-register arg cmd)
+          (ccl-embed-code (if read-flag 'read-jump-cond-expr-register 
+                            'jump-cond-expr-register)
+                          rrr 0)
+          (ccl-embed-data op)
+          (ccl-embed-data (get arg 'ccl-register-number)))))
+
+    ;; Compile TRUE-PART.
+    (let ((unconditional-jump (ccl-compile-1 true-cmds)))
+      (if (null false-cmds)
+          ;; This is the place to jump to if condition is false.
+          (ccl-embed-current-address jump-cond-address)
+        (let (end-true-part-address)
+          (if (not unconditional-jump)
+              (progn
+                ;; If TRUE-PART does not end with unconditional jump, we
+                ;; have to jump to the end of FALSE-PART from here.
+                (setq end-true-part-address ccl-current-ic)
+                (ccl-embed-code 'jump 0 0)))
+          ;; This is the place to jump to if CONDITION is false.
+          (ccl-embed-current-address jump-cond-address)
+          ;; Compile FALSE-PART.
+          (setq unconditional-jump
+                (and (ccl-compile-1 false-cmds) unconditional-jump))
+          (if end-true-part-address
+              ;; This is the place to jump to after the end of TRUE-PART.
+              (ccl-embed-current-address end-true-part-address))))
+      unconditional-jump)))
+
+;; Compile BRANCH statement.
+(defun ccl-compile-branch (cmd)
+  (if (< (length cmd) 3)
+      (error "CCL: Invalid number of arguments: %s" cmd))
+  (ccl-compile-branch-blocks 'branch
+                             (ccl-compile-branch-expression (nth 1 cmd) cmd)
+                             (cdr (cdr cmd))))
+
+;; Compile READ statement of the form `(read-branch EXPR BLOCK0 BLOCK1 ...)'.
+(defun ccl-compile-read-branch (cmd)
+  (if (< (length cmd) 3)
+      (error "CCL: Invalid number of arguments: %s" cmd))
+  (ccl-compile-branch-blocks 'read-branch
+                             (ccl-compile-branch-expression (nth 1 cmd) cmd)
+                             (cdr (cdr cmd))))
+
+;; Compile EXPRESSION part of BRANCH statement and return register
+;; which holds a value of the expression.
+(defun ccl-compile-branch-expression (expr cmd)
+  (if (listp expr)
+      ;; EXPR has the form `(EXPR2 OP ARG)'.  Compile it as SET
+      ;; statement of the form `(r7 = (EXPR2 OP ARG))'.
+      (progn
+        (ccl-compile-expression 'r7 expr)
+        'r7)
+    (ccl-check-register expr cmd)))
+
+;; Compile BLOCKs of BRANCH statement.  CODE is 'branch or 'read-branch.
+;; REG is a register which holds a value of EXPRESSION part.  BLOCKs
+;; is a list of CCL-BLOCKs.
+(defun ccl-compile-branch-blocks (code rrr blocks)
+  (let ((branches (length blocks))
+        branch-idx
+        jump-table-head-address
+        empty-block-indexes
+        block-tail-addresses
+        block-unconditional-jump)
+    (ccl-embed-code code rrr branches)
+    (setq jump-table-head-address ccl-current-ic)
+    ;; The size of jump table is the number of blocks plus 1 (for the
+    ;; case RRR is out of range).
+    (ccl-increment-ic (1+ branches))
+    (setq empty-block-indexes (list branches))
+    ;; Compile each block.
+    (setq branch-idx 0)
+    (while blocks
+      (if (null (car blocks))
+          ;; This block is empty.
+          (setq empty-block-indexes (cons branch-idx empty-block-indexes)
+                block-unconditional-jump t)
+        ;; This block is not empty.
+        (ccl-embed-data (- ccl-current-ic jump-table-head-address)
+                        (+ jump-table-head-address branch-idx))
+        (setq block-unconditional-jump (ccl-compile-1 (car blocks)))
+        (if (not block-unconditional-jump)
+            (progn
+              ;; Jump address of the end of branches are embedded later.
+              ;; For the moment, just remember where to embed them.
+              (setq block-tail-addresses
+                    (cons ccl-current-ic block-tail-addresses))
+              (ccl-embed-code 'jump 0 0))))
+      (setq branch-idx (1+ branch-idx))
+      (setq blocks (cdr blocks)))
+    (if (not block-unconditional-jump)
+        ;; We don't need jump code at the end of the last block.
+        (setq block-tail-addresses (cdr block-tail-addresses)
+              ccl-current-ic (1- ccl-current-ic)))
+    ;; Embed jump address at the tailing jump commands of blocks.
+    (while block-tail-addresses
+      (ccl-embed-current-address (car block-tail-addresses))
+      (setq block-tail-addresses (cdr block-tail-addresses)))
+    ;; For empty blocks, make entries in the jump table point directly here.
+    (while empty-block-indexes
+      (ccl-embed-data (- ccl-current-ic jump-table-head-address)
+                      (+ jump-table-head-address (car empty-block-indexes)))
+      (setq empty-block-indexes (cdr empty-block-indexes))))
+  ;; Branch command ends by unconditional jump if RRR is out of range.
+  nil)
+
+;; Compile LOOP statement.
+(defun ccl-compile-loop (cmd)
+  (if (< (length cmd) 2)
+      (error "CCL: Invalid number of arguments: %s" cmd))
+  (let* ((ccl-loop-head ccl-current-ic)
+         (ccl-breaks nil)
+         unconditional-jump)
+    (setq cmd (cdr cmd))
+    (if cmd
+        (progn
+          (setq unconditional-jump t)
+          (while cmd
+            (setq unconditional-jump
+                  (and (ccl-compile-1 (car cmd)) unconditional-jump))
+            (setq cmd (cdr cmd)))
+          (if (not ccl-breaks)
+              unconditional-jump
+            ;; Embed jump address for break statements encountered in
+            ;; this loop.
+            (while ccl-breaks
+              (ccl-embed-current-address (car ccl-breaks))
+              (setq ccl-breaks (cdr ccl-breaks))))
+          nil))))
+
+;; Compile BREAK statement.
+(defun ccl-compile-break (cmd)
+  (if (/= (length cmd) 1)
+      (error "CCL: Invalid number of arguments: %s" cmd))
+  (if (null ccl-loop-head)
+      (error "CCL: No outer loop: %s" cmd))
+  (setq ccl-breaks (cons ccl-current-ic ccl-breaks))
+  (ccl-embed-code 'jump 0 0)
+  t)
+
+;; Compile REPEAT statement.
+(defun ccl-compile-repeat (cmd)
+  (if (/= (length cmd) 1)
+      (error "CCL: Invalid number of arguments: %s" cmd))
+  (if (null ccl-loop-head)
+      (error "CCL: No outer loop: %s" cmd))
+  (ccl-embed-code 'jump 0 ccl-loop-head)
+  t)
+
+;; Compile WRITE-REPEAT statement.
+(defun ccl-compile-write-repeat (cmd)
+  (if (/= (length cmd) 2)
+      (error "CCL: Invalid number of arguments: %s" cmd))
+  (if (null ccl-loop-head)
+      (error "CCL: No outer loop: %s" cmd))
+  (let ((arg (nth 1 cmd)))
+    (cond ((integerp arg)
+           (ccl-embed-code 'write-const-jump 0 ccl-loop-head)
+           (ccl-embed-data arg))
+          ((stringp arg)
+           (let ((len (length arg))
+                 (i 0))
+             (ccl-embed-code 'write-string-jump 0 ccl-loop-head)
+             (ccl-embed-data len)
+             (ccl-embed-string len arg)))
+          (t
+           (ccl-check-register arg cmd)
+           (ccl-embed-code 'write-register-jump arg ccl-loop-head))))
+  t)
+
+;; Compile WRITE-READ-REPEAT statement.
+(defun ccl-compile-write-read-repeat (cmd)
+  (if (or (< (length cmd) 2) (> (length cmd) 3))
+      (error "CCL: Invalid number of arguments: %s" cmd))
+  (if (null ccl-loop-head)
+      (error "CCL: No outer loop: %s" cmd))
+  (let ((rrr (ccl-check-register (nth 1 cmd) cmd))
+        (arg (nth 2 cmd)))
+    (cond ((null arg)
+           (ccl-embed-code 'write-register-read-jump rrr ccl-loop-head))
+          ((integerp arg)
+           (ccl-embed-code 'write-const-read-jump rrr arg ccl-loop-head))
+          ((vectorp arg)
+           (let ((len (length arg))
+                 (i 0))
+             (ccl-embed-code 'write-array-read-jump rrr ccl-loop-head)
+             (ccl-embed-data len)
+             (while (< i len)
+               (ccl-embed-data (aref arg i))
+               (setq i (1+ i)))))
+          (t
+           (error "CCL: Invalid argument %s: %s" arg cmd)))
+    (ccl-embed-code 'read-jump rrr ccl-loop-head))
+  t)
+                            
+;; Compile READ statement.
+(defun ccl-compile-read (cmd)
+  (if (< (length cmd) 2)
+      (error "CCL: Invalid number of arguments: %s" cmd))
+  (let* ((args (cdr cmd))
+         (i (1- (length args))))
+    (while args
+      (let ((rrr (ccl-check-register (car args) cmd)))
+        (ccl-embed-code 'read-register rrr i)
+        (setq args (cdr args) i (1- i)))))
+  nil)
+
+;; Compile READ-IF statement.
+(defun ccl-compile-read-if (cmd)
+  (ccl-compile-if cmd 'read))
+
+;; Compile WRITE statement.
+(defun ccl-compile-write (cmd)
+  (if (< (length cmd) 2)
+      (error "CCL: Invalid number of arguments: %s" cmd))
+  (let ((rrr (nth 1 cmd)))
+    (cond ((integerp rrr)
+           (ccl-embed-code 'write-const-string 0 rrr))
+          ((stringp rrr)
+           (ccl-compile-write-string rrr))
+          ((and (symbolp rrr) (vectorp (nth 2 cmd)))
+           (ccl-check-register rrr cmd)
+           ;; CMD has the form `(write REG ARRAY)'.
+           (let* ((arg (nth 2 cmd))
+                  (len (length arg))
+                  (i 0))
+             (ccl-embed-code 'write-array rrr len)
+             (while (< i len)
+               (if (not (integerp (aref arg i)))
+                   (error "CCL: Invalid argument %s: %s" arg cmd))
+               (ccl-embed-data (aref arg i))
+               (setq i (1+ i)))))
+
+          ((symbolp rrr)
+           ;; CMD has the form `(write REG ...)'.
+           (let* ((args (cdr cmd))
+                  (i (1- (length args))))
+             (while args
+               (setq rrr (ccl-check-register (car args) cmd))
+               (ccl-embed-code 'write-register rrr i)
+               (setq args (cdr args) i (1- i)))))
+
+          ((listp rrr)
+           ;; CMD has the form `(write (LEFT OP RIGHT))'.
+           (let ((left (car rrr))
+                 (op (get (nth 1 rrr) 'ccl-arith-code))
+                 (right (nth 2 rrr)))
+             (if (listp left)
+                 (progn
+                   ;; RRR has the form `((EXPR OP2 ARG) OP RIGHT)'.
+                   ;; Compile the first term as `(r7 = (EXPR OP2 ARG))'.
+                   (ccl-compile-expression 'r7 left)
+                   (setq left 'r7)))
+             ;; Now RRR has the form `(ARG OP RIGHT)'.
+             (if (integerp right)
+                 (progn
+                   (ccl-embed-code 'write-expr-const 0 (ash op 3) left)
+                   (ccl-embed-data right))
+               (ccl-check-register right rrr)
+               (ccl-embed-code 'write-expr-register 0
+                               (logior (ash op 3)
+                                       (get right 'ccl-register-number))))))
+
+          (t
+           (error "CCL: Invalid argument: %s" cmd))))
+  nil)
+
+;; Compile CALL statement.
+(defun ccl-compile-call (cmd)
+  (if (/= (length cmd) 2)
+      (error "CCL: Invalid number of arguments: %s" cmd))
+  (if (not (symbolp (nth 1 cmd)))
+      (error "CCL: Subroutine should be a symbol: %s" cmd))
+  (let* ((name (nth 1 cmd))
+         (idx (get name 'ccl-program-idx)))
+    (if (not idx)
+        (error "CCL: Unknown subroutine name: %s" name))
+    (ccl-embed-code 'call 0 idx))
+  nil)
+
+;; Compile END statement.
+(defun ccl-compile-end (cmd)
+  (if (/= (length cmd) 1)
+      (error "CCL: Invalid number of arguments: %s" cmd))
+  (ccl-embed-code 'end 0 0)
+  t)
+
+;;; CCL dump staffs
+
+;; To avoid byte-compiler warning.
+(defvar ccl-code)
+
+;;;###autoload
+(defun ccl-dump (ccl-code)
+  "Disassemble compiled CCL-CODE."
+  (let ((len (length ccl-code))
+        (buffer-mag (aref ccl-code 0)))
+    (cond ((= buffer-mag 0)
+           (insert "Don't output anything.\n"))
+          ((= buffer-mag 1)
+           (insert "Out-buffer must be as large as in-buffer.\n"))
+          (t
+           (insert
+            (format "Out-buffer must be %d times bigger than in-buffer.\n"
+                    buffer-mag))))
+    (insert "Main-body:\n")
+    (setq ccl-current-ic 2)
+    (if (> (aref ccl-code 1) 0)
+        (progn
+          (while (< ccl-current-ic (aref ccl-code 1))
+            (ccl-dump-1))
+          (insert "At EOF:\n")))
+    (while (< ccl-current-ic len)
+      (ccl-dump-1))
+    ))
+
+;; Return a CCL code in `ccl-code' at `ccl-current-ic'.
+(defun ccl-get-next-code ()
+  (prog1
+      (aref ccl-code ccl-current-ic)
+    (setq ccl-current-ic (1+ ccl-current-ic))))
+
+(defun ccl-dump-1 ()
+  (let* ((code (ccl-get-next-code))
+         (cmd (aref ccl-code-table (logand code 31)))
+         (rrr (ash (logand code 255) -5))
+         (cc (ash code -8)))
+    (insert (format "%5d:[%s] " (1- ccl-current-ic) cmd))
+    (funcall (get cmd 'ccl-dump-function) rrr cc))) 
+
+(defun ccl-dump-set-register (rrr cc)
+  (insert (format "r%d = r%d\n" rrr cc)))
+
+(defun ccl-dump-set-short-const (rrr cc)
+  (insert (format "r%d = %d\n" rrr cc)))
+
+(defun ccl-dump-set-const (rrr ignore)
+  (insert (format "r%d = %d\n" rrr (ccl-get-next-code))))
+
+(defun ccl-dump-set-array (rrr cc)
+  (let ((rrr2 (logand cc 7))
+        (len (ash cc -3))
+        (i 0))
+    (insert (format "r%d = array[r%d] of length %d\n\t"
+                    rrr rrr2 len))
+    (while (< i len)
+      (insert (format "%d " (ccl-get-next-code)))
+      (setq i (1+ i)))
+    (insert "\n")))
+
+(defun ccl-dump-jump (ignore cc &optional address)
+  (insert (format "jump to %d(" (+ (or address ccl-current-ic) cc)))
+  (if (>= cc 0)
+      (insert "+"))
+  (insert (format "%d)\n" (1+ cc))))
+
+(defun ccl-dump-jump-cond (rrr cc)
+  (insert (format "if (r%d == 0), " rrr))
+  (ccl-dump-jump nil cc))
+
+(defun ccl-dump-write-register-jump (rrr cc)
+  (insert (format "write r%d, " rrr))
+  (ccl-dump-jump nil cc))
+
+(defun ccl-dump-write-register-read-jump (rrr cc)
+  (insert (format "write r%d, read r%d, " rrr rrr))
+  (ccl-dump-jump nil cc)
+  (ccl-get-next-code)                   ; Skip dummy READ-JUMP
+  )
+
+(defun ccl-extract-arith-op (cc)
+  (aref ccl-arith-table (ash cc -6)))
+
+(defun ccl-dump-write-expr-const (ignore cc)
+  (insert (format "write (r%d %s %d)\n"
+                  (logand cc 7)
+                  (ccl-extract-arith-op cc)
+                  (ccl-get-next-code))))
+
+(defun ccl-dump-write-expr-register (ignore cc)
+  (insert (format "write (r%d %s r%d)\n"
+                  (logand cc 7)
+                  (ccl-extract-arith-op cc)
+                  (logand (ash cc -3) 7))))
+
+(defun ccl-dump-insert-char (cc)
+  (cond ((= cc ?\t) (insert " \"^I\""))
+        ((= cc ?\n) (insert " \"^J\""))
+        (t (insert (format " \"%c\"" cc)))))
+
+(defun ccl-dump-write-const-jump (ignore cc)
+  (let ((address ccl-current-ic))
+    (insert "write char")
+    (ccl-dump-insert-char (ccl-get-next-code))
+    (insert ", ")
+    (ccl-dump-jump nil cc address)))
+
+(defun ccl-dump-write-const-read-jump (rrr cc)
+  (let ((address ccl-current-ic))
+    (insert "write char")
+    (ccl-dump-insert-char (ccl-get-next-code))
+    (insert (format ", read r%d, " rrr))
+    (ccl-dump-jump cc address)
+    (ccl-get-next-code)                 ; Skip dummy READ-JUMP
+    ))
+
+(defun ccl-dump-write-string-jump (ignore cc)
+  (let ((address ccl-current-ic)
+        (len (ccl-get-next-code))
+        (i 0))
+    (insert "write \"")
+    (while (< i len)
+      (let ((code (ccl-get-next-code)))
+        (insert (ash code -16))
+        (if (< (1+ i) len) (insert (logand (ash code -8) 255)))
+        (if (< (+ i 2) len) (insert (logand code 255))))
+      (setq i (+ i 3)))
+    (insert "\", ")
+    (ccl-dump-jump nil cc address)))
+
+(defun ccl-dump-write-array-read-jump (rrr cc)
+  (let ((address ccl-current-ic)
+        (len (ccl-get-next-code))
+        (i 0))
+    (insert (format "write array[r%d] of length %d,\n\t" rrr len))
+    (while (< i len)
+      (ccl-dump-insert-char (ccl-get-next-code))
+      (setq i (1+ i)))
+    (insert (format "\n\tthen read r%d, " rrr))
+    (ccl-dump-jump nil cc address)
+    (ccl-get-next-code)                 ; Skip dummy READ-JUMP.
+    ))
+
+(defun ccl-dump-read-jump (rrr cc)
+  (insert (format "read r%d, " rrr))
+  (ccl-dump-jump nil cc))
+
+(defun ccl-dump-branch (rrr len)
+  (let ((jump-table-head ccl-current-ic)
+        (i 0))
+    (insert (format "jump to array[r%d] of length %d\n\t" rrr len))
+    (while (<= i len)
+      (insert (format "%d " (+ jump-table-head (ccl-get-next-code))))
+      (setq i (1+ i)))
+    (insert "\n")))
+
+(defun ccl-dump-read-register (rrr cc)
+  (insert (format "read r%d (%d remaining)\n" rrr cc)))
+
+(defun ccl-dump-read-branch (rrr len)
+  (insert (format "read r%d, " rrr))
+  (ccl-dump-branch rrr len))
+
+(defun ccl-dump-write-register (rrr cc)
+  (insert (format "write r%d (%d remaining)\n" rrr cc)))
+
+(defun ccl-dump-call (ignore cc)
+  (insert (format "call subroutine #%d\n" cc)))
+
+(defun ccl-dump-write-const-string (rrr cc)
+  (if (= rrr 0)
+      (progn
+        (insert "write char")
+        (ccl-dump-insert-char cc)
+        (newline))
+    (let ((len cc)
+          (i 0))
+      (insert "write \"")
+      (while (< i len)
+        (let ((code (ccl-get-next-code)))
+          (insert (format "%c" (lsh code -16)))
+          (if (< (1+ i) len)
+              (insert (format "%c" (logand (lsh code -8) 255))))
+          (if (< (+ i 2) len)
+              (insert (format "%c" (logand code 255))))
+          (setq i (+ i 3))))
+      (insert "\"\n"))))
+
+(defun ccl-dump-write-array (rrr cc)
+  (let ((i 0))
+    (insert (format "write array[r%d] of length %d\n\t" rrr cc))
+    (while (< i cc)
+      (ccl-dump-insert-char (ccl-get-next-code))
+      (setq i (1+ i)))
+    (insert "\n")))
+
+(defun ccl-dump-end (&rest ignore)
+  (insert "end\n"))
+
+(defun ccl-dump-set-assign-expr-const (rrr cc)
+  (insert (format "r%d %s= %d\n"
+                  rrr
+                  (ccl-extract-arith-op cc)
+                  (ccl-get-next-code))))
+
+(defun ccl-dump-set-assign-expr-register (rrr cc)
+  (insert (format "r%d %s= r%d\n"
+                  rrr
+                  (ccl-extract-arith-op cc)
+                  (logand cc 7))))
+
+(defun ccl-dump-set-expr-const (rrr cc)
+  (insert (format "r%d = r%d %s %d\n"
+                  rrr
+                  (logand cc 7)
+                  (ccl-extract-arith-op cc)
+                  (ccl-get-next-code))))
+
+(defun ccl-dump-set-expr-register (rrr cc)
+  (insert (format "r%d = r%d %s r%d\n"
+                  rrr
+                  (logand cc 7)
+                  (ccl-extract-arith-op cc)
+                  (logand (ash cc -3) 7))))
+
+(defun ccl-dump-jump-cond-expr-const (rrr cc)
+  (let ((address ccl-current-ic))
+    (insert (format "if !(r%d %s %d), "
+                    rrr
+                    (aref ccl-arith-table (ccl-get-next-code))
+                    (ccl-get-next-code)))
+    (ccl-dump-jump nil cc address)))
+
+(defun ccl-dump-jump-cond-expr-register (rrr cc)
+  (let ((address ccl-current-ic))
+    (insert (format "if !(r%d %s r%d), "
+                    rrr
+                    (aref ccl-arith-table (ccl-get-next-code))
+                    (ccl-get-next-code)))
+    (ccl-dump-jump nil cc address)))
+
+(defun ccl-dump-read-jump-cond-expr-const (rrr cc)
+  (insert (format "read r%d, " rrr))
+  (ccl-dump-jump-cond-expr-const rrr cc))
+
+(defun ccl-dump-read-jump-cond-expr-register (rrr cc)
+  (insert (format "read r%d, " rrr))
+  (ccl-dump-jump-cond-expr-register rrr cc))
+
+(defun ccl-dump-binary (ccl-code)
+  (let ((len (length ccl-code))
+        (i 2))
+    (while (< i len)
+      (let ((code (aref ccl-code i))
+            (j 27))
+        (while (>= j 0)
+          (insert (if (= (logand code (ash 1 j)) 0) ?0 ?1))
+          (setq j (1- j)))
+        (setq code (logand code 31))
+        (if (< code (length ccl-code-table))
+            (insert (format ":%s" (aref ccl-code-table code))))
+        (insert "\n"))
+      (setq i (1+ i)))))
+
+;; CCL emulation staffs 
+
+;; Not yet implemented.
+
+;;;###autoload
+(defmacro declare-ccl-program (name)
+  "Declare NAME as a name of CCL program.
+
+To compile a CCL program which calls another CCL program not yet
+defined, it must be declared as a CCL program in advance."
+  `(put ',name 'ccl-program-idx (register-ccl-program ',name nil)))
+
+;;;###autoload
+(defmacro define-ccl-program (name ccl-program &optional doc)
+  "Set NAME the compiled code of CCL-PROGRAM.
+CCL-PROGRAM is `eval'ed before being handed to the CCL compiler `ccl-compile'.
+The compiled code is a vector of integers."
+  `(let ((prog ,(ccl-compile (eval ccl-program))))
+     (defconst ,name prog ,doc)
+     (put ',name 'ccl-program-idx (register-ccl-program ',name prog))
+     nil))
+
+;;;###autoload
+(defun ccl-execute-with-args (ccl-prog &rest args)
+  "Execute CCL-PROGRAM with registers initialized by the remaining args.
+The return value is a vector of resulting CCL registeres."
+  (let ((reg (make-vector 8 0))
+        (i 0))
+    (while (and args (< i 8))
+      (if (not (integerp (car args)))
+          (error "Arguments should be integer"))
+      (aset reg i (car args))
+      (setq args (cdr args) i (1+ i)))
+    (ccl-execute ccl-prog reg)
+    reg))
+
+(provide 'ccl)
+
+;; ccl.el ends here
diff --git a/lisp/international/characters.el b/lisp/international/characters.el
new file mode 100644
index 00000000000..8ce6e4b5638
--- /dev/null
+++ b/lisp/international/characters.el
@@ -0,0 +1,388 @@
+;;; characters.el --- set syntax and category for multibyte characters
+
+;; Copyright (C) 1995 Free Software Foundation, Inc.
+;; Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+;; Keywords: multibyte character, character set, syntax, category
+
+;; 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.
+
+;;; Commentary:
+
+;; This file contains multibyte characters.  Save this file always in
+;; `coding-system-iso-2022-7'.
+
+;;; Predefined categories.
+
+;; For each character set.
+
+(define-category ?a "ASCII")
+(define-category ?l "Latin")
+(define-category ?t "Thai")
+(define-category ?g "Greek")
+(define-category ?b "Arabic")
+(define-category ?w "Hebrew")
+(define-category ?y "Cyrillic")
+(define-category ?k "Japanese katakana")
+(define-category ?r "Japanese roman")
+(define-category ?c "Chinese")
+(define-category ?j "Japanese")
+(define-category ?h "Korean")
+(define-category ?e "Ethiopic (Ge'ez)")
+(define-category ?v "Vietnamese")
+(define-category ?i "Indian")
+
+;; For each group (row) of 2-byte character sets.
+
+(define-category ?A "Alpha numeric characters of 2-byte character sets")
+(define-category ?C "Chinese (Han) characters of 2-byte character sets")
+(define-category ?G "Greek characters of 2-byte characters sets")
+(define-category ?H "Japanese Hiragana characters of 2-byte character sets")
+(define-category ?K "Japanese Katakana characters of 2-byte character sets")
+(define-category ?N "Korean Hangul characters of 2-byte character sets")
+(define-category ?Y "Cyrillic character of 2-byte character sets")
+(define-category ?I "Indian Glyphs")
+
+;; For phonetic classifications.
+
+(define-category ?0 "consonant")
+(define-category ?1 "base vowel")
+(define-category ?2 "upper diacritical mark (including upper vowel)")
+(define-category ?3 "lower diacritical mark (including lower vowel)")
+(define-category ?4 "tone mark")
+(define-category ?5 "vowel")
+(define-category ?6 "digit")
+(define-category ?7 "vowel-modifying diacritical mark")
+(define-category ?8 "vowel-signs.")
+
+;; For filling.
+(define-category ?| "While filling, we can break a line at this character.")
+
+;; Keep the followings for `kinsoku' processing.  See comments in
+;; kinsoku.el.
+(define-category ?> "A character which can't be placed at beginning of line.")
+(define-category ?< "A character which can't be placed at end of line.")
+
+
+;;; Setting syntax and category.
+
+;; ASCII
+
+(let ((ch 32))
+  (while (< ch 127)                     ; All ASCII characters have
+    (modify-category-entry ch ?a)       ; the category `a' (ASCII)
+    (modify-category-entry ch ?l)       ; and `l' (Latin).
+    (setq ch (1+ ch))))
+
+;; Arabic character set
+
+(let ((charsets '(arabic-iso8859-6
+                  arabic-digit
+                  arabic-1-column
+                  arabic-2-column)))
+  (while charsets
+    (modify-syntax-entry (make-char (car charsets)) "w")
+    (modify-category-entry (make-char (car charsets)) ?b)
+    (setq charsets (cdr charsets))))
+
+;; Chinese character set (GB2312)
+
+(modify-syntax-entry (make-char 'chinese-gb2312) "w")
+(modify-syntax-entry (make-char 'chinese-gb2312 33) "_")
+(modify-syntax-entry (make-char 'chinese-gb2312 34) "_")
+(modify-syntax-entry (make-char 'chinese-gb2312 41) "_")
+(modify-syntax-entry ?\$A!2(B "($A!3(B")
+(modify-syntax-entry ?\$A!4(B "($A!5(B")
+(modify-syntax-entry ?\$A!6(B "($A!7(B")
+(modify-syntax-entry ?\$A!8(B "($A!9(B")
+(modify-syntax-entry ?\$A!:(B "($A!;(B")
+(modify-syntax-entry ?\$A!<(B "($A!=(B")
+(modify-syntax-entry ?\$A!>(B "($A!?(B")
+(modify-syntax-entry ?\$A!3(B ")$A!2(B")
+(modify-syntax-entry ?\$A!5(B ")$A!4(B")
+(modify-syntax-entry ?\$A!7(B ")$A!6(B")
+(modify-syntax-entry ?\$A!9(B ")$A!8(B")
+(modify-syntax-entry ?\$A!;(B ")$A!:(B")
+(modify-syntax-entry ?\$A!=(B ")$A!<(B")
+(modify-syntax-entry ?\$A!?(B ")$A!>(B")
+
+(modify-category-entry (make-char 'chinese-gb2312) ?c)
+(modify-category-entry (make-char 'chinese-gb2312) ?\|)
+(modify-category-entry (make-char 'chinese-gb2312 35) ?A)
+(modify-category-entry (make-char 'chinese-gb2312 36) ?H)
+(modify-category-entry (make-char 'chinese-gb2312 37) ?K)
+(modify-category-entry (make-char 'chinese-gb2312 38) ?G)
+(modify-category-entry (make-char 'chinese-gb2312 39) ?Y)
+(modify-category-entry (make-char 'chinese-gb2312 35) ?A)
+(let ((row 48))
+  (while (< row 127)
+    (modify-category-entry (make-char 'chinese-gb2312 row) ?C)
+    (setq row (1+ row))))
+
+;; Chinese character set (BIG5)
+
+(let ((generic-big5-1-char (make-char 'chinese-big5-1))
+      (generic-big5-2-char (make-char 'chinese-big5-2)))
+  (modify-syntax-entry generic-big5-1-char "w")
+  (modify-syntax-entry generic-big5-2-char "w")
+
+  (modify-category-entry generic-big5-1-char ?c)
+  (modify-category-entry generic-big5-2-char ?c)
+
+  (modify-category-entry generic-big5-1-char ?C)
+  (modify-category-entry generic-big5-2-char ?C)
+
+  (modify-category-entry generic-big5-1-char ?\|)
+  (modify-category-entry generic-big5-2-char ?\|))
+
+
+;; Chinese character set (CNS11643)
+
+(let ((cns-list '(chinese-cns11643-1
+                  chinese-cns11643-2
+                  chinese-cns11643-3
+                  chinese-cns11643-4
+                  chinese-cns11643-5
+                  chinese-cns11643-6
+                  chinese-cns11643-7))
+      generic-char)
+  (while cns-list
+    (setq generic-char (make-char (car cns-list)))
+    (modify-syntax-entry generic-char "w")
+    (modify-category-entry generic-char ?c)
+    (modify-category-entry generic-char ?C)
+    (modify-category-entry generic-char ?|)
+    (setq cns-list (cdr cns-list))))
+
+;; Cyrillic character set (ISO-8859-5)
+
+(modify-category-entry (make-char 'cyrillic-iso8859-5) ?y)
+
+(let ((c 160))
+  (while (< c 256)
+    (modify-syntax-entry (make-char 'cyrillic-iso8859-5 c) "w")
+    (setq c (1+ c))))
+(modify-syntax-entry ?,L-(B ".")
+(modify-syntax-entry ?,Lp(B ".")
+(modify-syntax-entry ?,L}(B ".")
+
+;; Ethiopic character set
+
+(modify-category-entry (make-char 'ethiopic) ?e)
+
+;; European character set (Latin-1,2,3,4,5)
+
+(modify-category-entry (make-char 'latin-iso8859-1) ?l)
+(modify-category-entry (make-char 'latin-iso8859-2) ?l)
+(modify-category-entry (make-char 'latin-iso8859-3) ?l)
+(modify-category-entry (make-char 'latin-iso8859-4) ?l)
+(modify-category-entry (make-char 'latin-iso8859-9) ?l)
+
+;; ISO-8859-1 (Latin-1)
+(let ((c 64))
+  (while (< c 128)                      ; from ',A@(B' to ',A(B'
+    (modify-syntax-entry (make-char 'latin-iso8859-1 c) "w")
+    (setq c (1+ c)))
+  (modify-syntax-entry (make-char 'latin-iso8859-1 32) "w") ; NBSP
+  (modify-syntax-entry ?,AW(B "_")
+  (modify-syntax-entry ?,Aw(B "_")
+  )
+
+;; ISO-8859-2 (Latin-2)
+(let ((c 190))
+  (while (< c 255)
+    (modify-syntax-entry (make-char 'latin-iso8859-2 c) "w")
+    (setq c (1+ c))))
+(let ((chars '(?,B!(B ?,B#(B ?,B%(B ?,B&(B ?,B)(B ?,B*(B ?,B+(B ?,B,(B ?,B.(B ?,B/(B ?,B1(B ?,B3(B ?,B5(B ?,B6(B ?,B9(B ?,B:(B ?,B;(B ?,B<(B)))
+  (while chars
+    (modify-syntax-entry (car chars) "w")
+    (setq chars (cdr chars))))
+(modify-syntax-entry (make-char 'latin-iso8859-2 160) "w") ; NBSP
+(modify-syntax-entry ?,BW(B ".")
+(modify-syntax-entry ?,Bw(B ".")
+
+;; Greek character set (ISO-8859-7)
+
+(modify-category-entry (make-char 'greek-iso8859-7) ?g)
+
+(let ((c 182))
+  (while (< c 255)
+    (modify-syntax-entry (make-char 'greek-iso8859-7 c) "w")
+    (setq c (1+ c))))
+(modify-syntax-entry (make-char 'greek-iso8859-7 160) "w") ; NBSP
+(modify-syntax-entry ?,F7(B ".")
+(modify-syntax-entry ?,F;(B ".")
+(modify-syntax-entry ?,F=(B ".")
+
+;; Hebrew character set (ISO-8859-8)
+
+(modify-category-entry (make-char 'hebrew-iso8859-8) ?w)
+
+(let ((c 224))
+  (while (< c 251)
+    (modify-syntax-entry (make-char 'hebrew-iso8859-8 c) "w")
+    (setq c (1+ c))))
+(modify-syntax-entry (make-char 'hebrew-iso8859-8 160) "w") ; NBSP
+
+;; Indian character set (IS 13194 and other Emacs original Indian charsets)
+
+(modify-category-entry (make-char 'indian-is13194) ?i)
+(modify-category-entry (make-char 'indian-2-column) ?I)
+(modify-category-entry (make-char 'indian-1-column) ?I)
+
+;; Japanese character set (JISX0201-kana, JISX0201-roman, JISX0208, JISX0212)
+
+(modify-category-entry (make-char 'katakana-jisx0201) ?k)
+(modify-category-entry (make-char 'latin-jisx0201) ?r)
+(modify-category-entry (make-char 'japanese-jisx0208) ?j)
+(modify-category-entry (make-char 'japanese-jisx0212) ?j)
+(modify-category-entry (make-char 'japanese-jisx0208) ?\|)
+
+;; JISX0208
+(modify-syntax-entry (make-char 'japanese-jisx0208) "w")
+(modify-syntax-entry (make-char 'japanese-jisx0208 33) "_")
+(modify-syntax-entry (make-char 'japanese-jisx0208 34) "_")
+(modify-syntax-entry (make-char 'japanese-jisx0208 40) "_")
+(let ((chars '(?$B!<(B ?$B!+(B ?$B!,(B ?$B!3(B ?$B!4(B ?$B!5(B ?$B!6(B ?$B!7(B ?$B!8(B ?$B!9(B ?$B!:(B ?$B!;(B)))
+  (while chars
+    (modify-syntax-entry (car chars) "w")
+    (setq chars (cdr chars))))
+(modify-syntax-entry ?\$B!J(B "($B!K(B")
+(modify-syntax-entry ?\$B!N(B "($B!O(B")
+(modify-syntax-entry ?\$B!P(B "($B!Q(B")
+(modify-syntax-entry ?\$B!V(B "($B!W(B")
+(modify-syntax-entry ?\$B!X(B "($B!Y(B")
+(modify-syntax-entry ?\$B!K(B ")$B!J(B")
+(modify-syntax-entry ?\$B!O(B ")$B!N(B")
+(modify-syntax-entry ?\$B!Q(B ")$B!P(B")
+(modify-syntax-entry ?\$B!W(B ")$B!V(B")
+(modify-syntax-entry ?\$B!Y(B ")$B!X(B")
+
+(modify-category-entry (make-char 'japanese-jisx0208 35) ?A)
+(modify-category-entry (make-char 'japanese-jisx0208 36) ?H)
+(modify-category-entry (make-char 'japanese-jisx0208 37) ?K)
+(modify-category-entry (make-char 'japanese-jisx0208 38) ?G)
+(modify-category-entry (make-char 'japanese-jisx0208 39) ?Y)
+(let ((row 48))
+  (while (< row 127)
+    (modify-category-entry (make-char 'japanese-jisx0208 row) ?C)
+    (setq row (1+ row))))
+(let ((chars '(?$B!<(B ?$B!+(B ?$B!,(B)))
+  (while chars
+    (modify-category-entry (car chars) ?K)
+    (modify-category-entry (car chars) ?H)
+    (setq chars (cdr chars))))
+(let ((chars '(?$B!3(B ?$B!4(B ?$B!5(B ?$B!6(B ?$B!7(B ?$B!8(B ?$B!9(B ?$B!:(B ?$B!;(B)))
+  (while chars
+    (modify-category-entry (car chars) ?C)
+    (setq chars (cdr chars))))
+
+;; JISX0212
+(modify-syntax-entry (make-char 'japanese-jisx0212) "w")
+(modify-syntax-entry (make-char 'japanese-jisx0212 33) "_")
+(modify-syntax-entry (make-char 'japanese-jisx0212 34) "_")
+(modify-syntax-entry (make-char 'japanese-jisx0212 35) "_")
+
+(modify-category-entry (make-char 'japanese-jisx0212 ) ?C)
+
+;; JISX0201-Kana
+(modify-syntax-entry (make-char 'katakana-jisx0201) "w")
+(let ((chars '(?(I!(B ?(I"(B ?(I#(B ?(I$(B ?(I%(B)))
+  (while chars
+    (modify-syntax-entry (car chars) ".")
+    (setq chars (cdr chars))))
+
+;; Korean character set (KSC5601)
+
+(modify-syntax-entry (make-char 'korean-ksc5601) "w")
+(modify-syntax-entry (make-char 'korean-ksc5601 33) "_")
+(modify-syntax-entry (make-char 'korean-ksc5601 34) "_")
+(modify-syntax-entry (make-char 'korean-ksc5601 38) "_")
+(modify-syntax-entry (make-char 'korean-ksc5601 39) "_")
+(modify-syntax-entry (make-char 'korean-ksc5601 40) "_")
+(modify-syntax-entry (make-char 'korean-ksc5601 41) "_")
+
+(modify-category-entry (make-char 'korean-ksc5601) ?h)
+(modify-category-entry (make-char 'korean-ksc5601 35) ?A)
+(modify-category-entry (make-char 'korean-ksc5601 37) ?G)
+(modify-category-entry (make-char 'korean-ksc5601 42) ?H)
+(modify-category-entry (make-char 'korean-ksc5601 43) ?K)
+(modify-category-entry (make-char 'korean-ksc5601 44) ?Y)
+
+;; Thai character set (TIS620)
+
+(modify-category-entry (make-char 'thai-tis620) ?t)
+
+(let ((deflist  '(;; chars      syntax  category
+                  (",T!(B-,TCEG(B-,TN(B"  "w"     ?0) ; consonant
+                  (",TDFPRS`(B-,Te(B"       "w"     ?1) ; vowel base
+                  (",TQT(B-,TWgn(B" "w"     ?2) ; vowel upper
+                  (",TX(B-,TZ(B"    "w"     ?3) ; vowel lower
+                  (",Th(B-,Tm(B"    "w"     ?4) ; tone mark 
+                  (",TOfp(B-,Ty(B"  "w"     ?0) ; digit and misc
+                  (",T_oz{(B" "_"     ?0) ; symbol
+                  ))
+      elm chars len syntax category to ch i)
+  (while deflist
+    (setq elm (car deflist))
+    (setq chars (car elm)
+          len (length chars)
+          syntax (nth 1 elm)
+          category (nth 2 elm)
+          i 0)
+    (while (< i len)
+      (if (= (aref chars i) ?-)
+          (setq i (1+ i)
+                to (sref chars i))
+        (setq ch (sref chars i)
+              to ch))
+      (while (<= ch to)
+        (modify-syntax-entry ch syntax)
+        (modify-category-entry ch category)
+        (setq ch (1+ ch)))
+      (setq i (+ i (char-bytes to))))
+    (setq deflist (cdr deflist))))
+
+;; Vietnamese character set
+
+(let ((lower (make-char 'vietnamese-viscii-lower))
+      (upper (make-char 'vietnamese-viscii-upper)))
+  (modify-syntax-entry lower "w")
+  (modify-syntax-entry upper "w")
+  (modify-category-entry lower ?v)
+  (modify-category-entry upper ?v)
+  (modify-category-entry lower ?l)      ; To make a word with
+  (modify-category-entry upper ?l)      ; latin characters.
+  )
+
+
+;;; Setting word boundary.
+
+(setq word-combining-categories
+      '((?l . ?l)))
+
+(setq word-separating-categories        ;  (2-byte character sets)
+      '((?A . ?K)                       ; Alpha numeric - Katakana
+        (?A . ?C)                       ; Alpha numeric - Chinese
+        (?H . ?A)                       ; Hiragana - Alpha numeric
+        (?H . ?K)                       ; Hiragana - Katakana
+        (?H . ?C)                       ; Hiragana - Chinese
+        (?K . ?A)                       ; Katakana - Alpha numeric
+        (?K . ?C)                       ; Katakana - Chinese
+        (?C . ?A)                       ; Chinese - Alpha numeric
+        (?C . ?K)                       ; Chinese - Katakana
+        ))
diff --git a/lisp/international/encoded-kb.el b/lisp/international/encoded-kb.el
new file mode 100644
index 00000000000..2861fc45148
--- /dev/null
+++ b/lisp/international/encoded-kb.el
@@ -0,0 +1,285 @@
+;; encoded-kb.el -- handler for inputting multibyte characters encoded somehow
+
+;; 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.
+
+(defvar encoded-kbd-mode nil
+  "Non-nil if in Encoded-kbd minor mode.")
+(put 'encoded-kbd-mode 'permanent-local t)
+
+(or (assq 'encoded-kbd-mode minor-mode-alist)
+    (setq minor-mode-alist
+          (cons '(encoded-kbd-mode " Encoded-kbd") minor-mode-alist)))
+
+(defvar encoded-kbd-mode-map
+  (let ((map (make-sparse-keymap))
+        (i 128))
+    (define-key map "\e" 'encoded-kbd-handle-iso2022-esc)
+    (while (< i 256)
+      (define-key map (vector i) 'encoded-kbd-handle-8bit)
+      (setq i (1+ i)))
+    map)
+  "Keymap for Encoded-kbd minor mode.")
+
+(or (assq 'encoded-kbd-mode minor-mode-map-alist)
+    (setq minor-mode-map-alist
+          (cons (cons 'encoded-kbd-mode encoded-kbd-mode-map)
+                minor-mode-map-alist)))
+
+;; Subsidiary keymaps for handling ISO2022 escape sequences.
+
+(defvar encoded-kbd-iso2022-esc-map
+  (let ((map (make-sparse-keymap)))
+    (define-key map "$" 'encoded-kbd-iso2022-esc-dollar-prefix)
+    (define-key map "(" 'encoded-kbd-iso2022-designation-prefix)
+    (define-key map ")" 'encoded-kbd-iso2022-designation-prefix)
+    (define-key map "," 'encoded-kbd-iso2022-designation-prefix)
+    (define-key map "-" 'encoded-kbd-iso2022-designation-prefix)
+    (append map '((t . encoded-kbd-outernal-command)))
+    map)
+  "Keymap for handling ESC code in Encoded-kbd mode.")
+
+(defvar encoded-kbd-iso2022-esc-dollar-map
+  (let ((map (make-sparse-keymap)))
+    (define-key map "(" 'encoded-kbd-iso2022-designation-prefix)
+    (define-key map ")" 'encoded-kbd-iso2022-designation-prefix)
+    (define-key map "," 'encoded-kbd-iso2022-designation-prefix)
+    (define-key map "-" 'encoded-kbd-iso2022-designation-prefix)
+    (define-key map "@" 'encoded-kbd-iso2022-designation)
+    (define-key map "A" 'encoded-kbd-iso2022-designation)
+    (define-key map "B" 'encoded-kbd-iso2022-designation)
+    (append map '((t . encoded-kbd-outernal-command)))
+    map)
+  "Keymap for handling ESC $ sequence handling in Encoded-kbd mode.")
+(fset 'encoded-kbd-iso2022-esc-dollar-prefix
+      encoded-kbd-iso2022-esc-dollar-map)
+
+(defvar encoded-kbd-iso2022-designation-map
+  (let ((map (make-sparse-keymap))
+        (i 48))
+    (while (< i 128)
+      (define-key map (char-to-string i) 'encoded-kbd-iso2022-designation)
+      (setq i (1+ i)))
+    (append map '((t . encoded-kbd-outernal-command)))
+    map)
+  "Keymap for handling ISO2022 designation sequence in Encoded-kbd mode.")
+(fset 'encoded-kbd-iso2022-designation-prefix
+      encoded-kbd-iso2022-designation-map)
+
+(defvar encoded-kbd-iso2022-non-ascii-map
+  (let ((map (make-keymap))
+        (i 32))
+    (while (< i 128)
+      (define-key map (char-to-string i) 'encoded-kbd-self-insert-iso2022-7bit)
+      (setq i (1+ i)))
+    map)
+  "Keymap for handling non-ASCII character set in Encoded-kbd mode.")
+
+;; One of the symbols `sjis', `iso2022-7', `iso2022-8', or `big5' to
+;; denote what kind of coding-system we are now handling in
+;; Encoded-kbd mode.
+(defvar encoded-kbd-coding nil)
+
+;; Keep information of designation state of ISO2022 encoding.  This is
+;; a vector of character sets currently designated to each graphic
+;; registers (0..3).
+
+(defvar encoded-kbd-iso2022-designations nil)
+(make-variable-buffer-local 'encoded-kbd-iso2022-designations)
+(put 'encoded-kbd-iso2022-designations 'permanent-local t)
+
+;; Keep information of invocation state of ISO2022 encoding.  This is
+;; a vector of graphic register numbers currently invoked to each
+;; graphic plane (0..1), the third element is a single shifted graphic
+;; register number.
+
+(defvar encoded-kbd-iso2022-invocations nil)
+(make-variable-buffer-local 'encoded-kbd-iso2022-invocations)
+(put 'encoded-kbd-iso2022-invocations 'permanent-local t)
+
+(defun encoded-kbd-iso2022-designation ()
+  "Do ISO2022 designation according to the curren key in Encoded-kbd mode.
+The following key sequence may cause multilingual text insertion."
+  (interactive)
+  (let ((key-seq (this-command-keys))
+        intermediate-char final-char
+        reg dimension chars charset)
+    (if (= (length key-seq) 3)
+        ;; (ESC) $ <intermediate-char> <final-char>
+        (setq intermediate-char (aref key-seq 1)
+              dimension 2
+              chars (if (< intermediate-char ?,) 94 96)
+              final-char (aref key-seq 2)
+              reg (mod intermediate-char 4))
+      (if (= (aref key-seq 1) ?$)
+          ;; (ESC) $ <final-char>
+          (setq dimension 2
+                chars 94
+                final-char (aref key-seq 1)
+                reg 0)
+        ;; (ESC) <intermediate-char> <final-char>
+        (setq intermediate-char (aref key-seq 0)
+              dimension 1
+              chars (if (< intermediate-char ?,) 94 96)
+              final-char (aref key-seq 1)
+              reg (mod intermediate-char 4))))
+    (if (setq charset (iso-charset dimension chars final-char))
+        (aset encoded-kbd-iso2022-designations reg charset)
+      (error "Character set of DIMENSION %s, CHARS %s, FINAL-CHAR `%c' is not supported"
+             dimension chars final-char))
+
+    (if (eq (aref encoded-kbd-iso2022-designations
+                 (aref encoded-kbd-iso2022-invocations 0))
+            'ascii)
+        ;; Graphic plane 0 (0x20..0x7f) is for ASCII.  We don't have
+        ;; to handle characters in this range specially.
+        (throw 'exit nil)
+      ;; Graphic plane 0 is for non-ASCII.
+      (setq overriding-local-map encoded-kbd-iso2022-non-ascii-map))))
+
+(defun encoded-kbd-handle-iso2022-esc ()
+  (interactive)
+  (let ((overriding-local-map encoded-kbd-iso2022-esc-map))
+    (recursive-edit)))
+
+(defun encoded-kbd-handle-8bit ()
+  "Handle an 8-bit character enterned in Encoded-kbd mode."
+  (interactive)
+  (cond ((eq encoded-kbd-coding 'iso2022-7)
+         (error "Can't handle the character code %d" last-command-char))
+
+        ((eq encoded-kbd-coding 'iso2022-8)
+         (cond ((= last-command-char ?\216)
+                (aset encoded-kbd-iso2022-invocations 2 2))
+
+               ((= last-command-char ?\217)
+                (aset encoded-kbd-iso2022-invocations 2 3))
+
+               ((> last-command-char ?\240)
+                (encoded-kbd-self-insert-iso2022-8bit))
+
+               (t
+                (error "Can't handle the character code %d"
+                       last-command-char))))
+
+        ((eq encoded-kbd-coding 'sjis)
+         (encoded-kbd-self-insert-sjis))
+
+        (t
+         (encoded-kbd-self-insert-big5))))
+
+(defun encoded-kbd-self-insert-iso2022-7bit ()
+  (interactive)
+  (let* ((charset (aref encoded-kbd-iso2022-designations
+                        (or (aref encoded-kbd-iso2022-invocations 2)
+                            (aref encoded-kbd-iso2022-invocations 0))))
+         (last-command-char
+          (if (= (charset-bytes charset) 1)
+              (make-char charset last-command-char)
+            (make-char charset last-command-char (read-char-exclusive)))))
+    (self-insert-command 1)
+    (aset encoded-kbd-iso2022-invocations 2 nil)
+    ))
+
+(defun encoded-kbd-self-insert-iso2022-8bit ()
+  (interactive)
+  (let* ((charset (aref encoded-kbd-iso2022-designations
+                        (or (aref encoded-kbd-iso2022-invocations 2)
+                            (aref encoded-kbd-iso2022-invocations 1))))
+         (last-command-char
+          (if (= (charset-bytes charset) 1)
+              (make-char charset last-command-char)
+            (make-char charset last-command-char (read-char-exclusive)))))
+    (self-insert-command 1)
+    (aset encoded-kbd-iso2022-invocations 2 nil)
+    ))
+
+(defun encoded-kbd-self-insert-sjis ()
+  (interactive)
+  (let ((last-command-char
+         (if (or (< last-command-char ?\xA0) (>= last-command-char ?\xE0))
+             (decode-sjis-char (+ (ash last-command-char 8)
+                                  (read-char-exclusive)))
+           (make-char 'latin-jisx0201 last-command-char))))
+    (self-insert-command 1)))
+
+(defun encoded-kbd-self-insert-big5 ()
+  (interactive)
+  (let ((last-command-char
+         (decode-big5-char (+ (ash last-command-char 8)
+                              (read-char-exclusive)))))
+    (self-insert-command 1)))
+
+(defun encoded-kbd-mode (&optional arg)
+  "Toggle Encoded-kbd minor mode.
+With arg, turn Keyboard-kbd mode on in and only if arg is positive.
+
+When in Encoded-kbd mode, a text sent from a terminal keyboard
+is accepted as a multilingual text encoded in a coding-system
+set by the command `set-keyboard-coding-system'"
+  (interactive "P")
+  (setq encoded-kbd-mode
+        (if (null arg) (null encoded-kbd-mode)
+          (> (prefix-numeric-value arg) 0)))
+  (if encoded-kbd-mode
+      (let* ((coding (coding-system-vector (keyboard-coding-system)))
+             (input-mode (current-input-mode)))
+        (cond ((null coding)
+               (setq encoded-kbd-mode nil) 
+               (error "No coding-system for terminal keyboard is set"))
+
+              ((= (coding-vector-type coding) 1) ; SJIS
+               (set-input-mode (nth 0 input-mode) (nth 1 input-mode)
+                               'use-8th-bit (nth 3 input-mode)) 
+               (setq encoded-kbd-coding 'sjis))
+
+              ((= (coding-vector-type coding) 2) ; ISO2022
+               (if (aref (coding-vector-flags coding) 7) ; 7-bit only
+                   (setq encoded-kbd-coding 'iso2022-7)
+                 (set-input-mode (nth 0 input-mode) (nth 1 input-mode)
+                                 'use-8th-bit (nth 3 input-mode))       
+                 (setq encoded-kbd-coding 'iso2022-8))
+               (make-variable-buffer-local 'encoded-kbd-iso2022-designations)
+               (setq encoded-kbd-iso2022-designations (make-vector 4 nil))
+               (let ((flags (coding-vector-flags coding))
+                     (i 0))
+                 (while (< i 4)
+                   (if (and (aref flags i)
+                            (> (aref flags i) 0))
+                       (aset encoded-kbd-iso2022-designations i
+                             (aref flags i)))
+                   (setq i (1+ i))))
+               (make-variable-buffer-local 'encoded-kbd-iso2022-invocations)
+               (setq encoded-kbd-iso2022-invocations (make-vector 3 0))
+               (aset encoded-kbd-iso2022-invocations 1 1))
+
+              ((= (coding-vector-type coding) 3) ; BIG5
+               (set-input-mode (nth 0 input-mode) (nth 1 input-mode)
+                               'use-8th-bit (nth 3 input-mode)) 
+               (setq encoded-kbd-coding 'big5))
+
+              (t
+               (setq encoded-kbd-mode nil)
+               (error "Coding-system `%s' is not supported in Encoded-kbd mode"
+                      (keyboard-coding-system))))
+
+        (run-hooks 'encoded-kbd-mode-hook)))
+  (force-mode-line-update))
+
+;;; encoded-kb.el ends here
diff --git a/lisp/international/fontset.el b/lisp/international/fontset.el
new file mode 100644
index 00000000000..65519590cc3
--- /dev/null
+++ b/lisp/international/fontset.el
@@ -0,0 +1,336 @@
+;;; fontset.el --- Commands for handling fontset.
+
+;; Copyright (C) 1995 Free Software Foundation, Inc.
+;; Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+;; Keywords: mule, multilingual, fontset
+
+;; 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.
+
+;;; Code:
+
+;; Set default REGISTRY property of charset to find an appropriate
+;; font for each charset.  This is used to generate a font name in a
+;; fontset.  If the value contains a character `-', the string before
+;; that is embeded in `CHARSET_REGISTRY' field, and the string after
+;; that is embeded in `CHARSET_ENCODING' field.  If the value does not
+;; contain `-', the whole string is embeded in `CHARSET_REGISTRY'
+;; field, and a wild card character `*' is embeded in
+;; `CHARSET_ENCODING' field.
+
+(defvar x-charset-registries
+  '((ascii . "ISO8859-1")
+    (latin-iso8859-1 . "ISO8859-1")
+    (latin-iso8859-2 . "ISO8859-2")
+    (latin-iso8859-3 . "ISO8859-3")
+    (latin-iso8859-4 . "ISO8859-4")
+    (thai-tis620 . "TIS620")
+    (greek-iso8859-7 . "ISO8859-7")
+    (arabic-iso8859-6 . "ISO8859-6")
+    (hebrew-iso8859-8 . "ISO8859-8")
+    (katakana-jisx0201 . "JISX0201")
+    (latin-jisx0201 . "JISX0201")
+    (cyrillic-iso8859-5 . "ISO8859-5")
+    (latin-iso8859-9 . "ISO8859-9")
+    (japanese-jisx0208-1978 . "JISX0208.1978")
+    (chinese-gb2312 . "GB2312")
+    (japanese-jisx0208 . "JISX0208.1983")
+    (korean-ksc5601 . "KSC5601")
+    (japanese-jisx0212 . "JISX0212")
+    (chinese-cns11643-1 . "CNS11643.1992-1")
+    (chinese-cns11643-2 . "CNS11643.1992-2")
+    (chinese-cns11643-3 . "CNS11643.1992-3")
+    (chinese-cns11643-4 . "CNS11643.1992-4")
+    (chinese-cns11643-5 . "CNS11643.1992-5")
+    (chinese-cns11643-6 . "CNS11643.1992-6")
+    (chinese-cns11643-7 . "CNS11643.1992-7")
+    (chinese-big5-1 . "Big5")
+    (chinese-big5-2 . "Big5")
+    (chinese-sisheng . "sisheng_cwnn")
+    (vietnamese-viscii-lower . "VISCII1.1")
+    (vietnamese-viscii-upper . "VISCII1.1")
+    (arabic-digit . "MuleArabic-0")
+    (arabic-1-column . "MuleArabic-1")
+    (arabic-2-column . "MuleArabic-2")
+    (ipa . "MuleIPA")
+    (ethiopic . "Ethio")
+    (ascii-right-to-left . "ISO8859-1")
+    (indian-is13194 . "IS13194-Devanagari")
+    (indian-2-column . "MuleIndian-2")
+    (indian-1-column . "MuleIndian-1")
+    (lao . "lao.mule-1")))
+
+(let ((l x-charset-registries))
+  (while l
+    (put-charset-property (car (car l)) 'x-charset-registry (cdr (car l)))
+    (setq l (cdr l))))
+
+;; Set arguments in `font-encoding-alist' (which see).
+(defun set-font-encoding (pattern charset encoding)
+  (let ((slot (assoc pattern font-encoding-alist)))
+    (if slot
+        (let ((place (assq charset (cdr slot))))
+          (if place
+              (setcdr place encoding)
+            (setcdr slot (cons (cons charset encoding) (cdr slot)))))
+      (setq font-encoding-alist
+            (cons (list pattern (cons charset encoding)) font-encoding-alist)))
+    ))
+
+(set-font-encoding "ISO8859-1" 'ascii 0)
+(set-font-encoding "JISX0201" 'latin-jisx0201 0)
+
+;; Setting for suppressing XLoadQueryFont on big fonts.
+(setq x-pixel-size-width-font-regexp
+      "gb2312\\|jisx0208\\|ksc5601\\|cns11643\\|big5")
+
+;;; XLFD (X Logical Font Description) format handler.
+
+;; Define XLFD's field index numbers.           ; field name
+(defconst xlfd-regexp-foundry-subnum 0)         ; FOUNDRY
+(defconst xlfd-regexp-family-subnum 1)          ; FAMILY_NAME
+(defconst xlfd-regexp-weight-subnum 2)          ; WEIGHT_NAME
+(defconst xlfd-regexp-slant-subnum 3)           ; SLANT
+(defconst xlfd-regexp-swidth-subnum 4)          ; SETWIDTH_NAME
+(defconst xlfd-regexp-adstyle-subnum 5)         ; ADD_STYLE_NAME
+(defconst xlfd-regexp-pixelsize-subnum 6)       ; PIXEL_SIZE
+(defconst xlfd-regexp-pointsize-subnum 7)       ; POINT_SIZE
+(defconst xlfd-regexp-resx-subnum 8)            ; RESOLUTION_X
+(defconst xlfd-regexp-resy-subnum 9)            ; RESOLUTION_Y
+(defconst xlfd-regexp-spacing-subnum 10)        ; SPACING
+(defconst xlfd-regexp-avgwidth-subnum 11)       ; AVERAGE_WIDTH
+(defconst xlfd-regexp-registry-subnum 12)       ; CHARSET_REGISTRY
+(defconst xlfd-regexp-encoding-subnum 13)       ; CHARSET_ENCODING
+
+;; Regular expression matching against a fontname which conforms to
+;; XLFD (X Logical Font Description).  All fields in XLFD should be
+;; not be omitted (but can be a wild card) to be matched.
+(defconst xlfd-tight-regexp
+  "^\
+-\\([^-]*\\)-\\([^-]*\\)-\\([^-]*\\)-\\([^-]*\\)-\\([^-]*\\)\
+-\\([^-]*\\)-\\([^-]*\\)-\\([^-]*\\)-\\([^-]*\\)-\\([^-]*\\)\
+-\\([^-]*\\)-\\([^-]*\\)-\\([^-]*\\)-\\([^-]*\\)$")
+
+;; List of field numbers of XLFD whose values are numeric.
+(defconst xlfd-regexp-numeric-subnums
+  (list xlfd-regexp-pixelsize-subnum    ;6
+        xlfd-regexp-pointsize-subnum    ;7
+        xlfd-regexp-resx-subnum         ;8
+        xlfd-regexp-resy-subnum         ;9
+        xlfd-regexp-avgwidth-subnum     ;11
+        ))
+
+(defun x-decompose-font-name (pattern)
+  "Decompose PATTERN into XLFD's fields and return vector of the fields.
+The length of the vector is 14.
+
+If PATTERN doesn't conform to XLFD, try to get a full XLFD name from
+X server and use the information of the full name to decompose
+PATTERN.  If no full XLFD name is gotten, return nil."
+  (let (xlfd-fields fontname)
+    (if (string-match xlfd-tight-regexp pattern)
+        (let ((i 0))
+          (setq xlfd-fields (make-vector 14 nil))
+          (while (< i 14)
+            (aset xlfd-fields i (match-string (1+ i) pattern))
+            (setq i (1+ i)))
+          xlfd-fields)
+      (setq fontname (condition-case nil
+                         (x-resolve-font-name pattern)
+                       (error)))
+      (if (and fontname
+               (string-match xlfd-tight-regexp fontname))
+          (let ((len (length pattern))
+                (i 0)
+                l)
+            (setq xlfd-fields (make-vector 14 nil))
+            (while (< i 14)
+              (aset xlfd-fields i
+                    (cons (match-beginning (1+ i))
+                          (match-string (1+ i) fontname)))
+              (setq i (1+ i)))
+            (setq i 0)
+            (while (< i len)
+              (let ((ch (aref pattern i)))
+                (if (= ch ??)
+                    (setq pattern (concat (substring pattern 0 i)
+                                          "\\(.\\)"
+                                          (substring pattern (1+ i)))
+                          len (+ len 4)
+                          i (+ i 4))
+                  (if (= ch ?*)
+                      (setq pattern (concat (substring pattern 0 i)
+                                            "\\(.*\\)"
+                                            (substring pattern (1+ i)))
+                            len (+ len 5)
+                            i (+ i 5))
+                    (setq i (1+ i))))))
+            (string-match pattern fontname)
+            (setq l (cdr (cdr (match-data))))
+            (setq i 0)
+            (while (< i 14)
+              (if (or (null l) (< (car (aref xlfd-fields i)) (car l)))
+                  (progn
+                    (aset xlfd-fields i (cdr (aref xlfd-fields i)))
+                    (setq i (1+ i)))
+                (if (< (car (aref xlfd-fields i)) (car (cdr l)))
+                    (progn
+                      (aset xlfd-fields i nil)
+                      (setq i (1+ i)))
+                  (setq l (cdr (cdr l))))))
+            xlfd-fields)))))
+
+(defsubst x-compose-font-name (xlfd-fields)
+  "Compose X's fontname from FIELDS.
+FIELDS is a vector of XLFD fields.
+If a field is nil, wild-card character `*' is embedded."
+  (concat "-" (mapconcat (lambda (x) (or x "*")) xlfd-fields "-")))
+
+(defun x-complement-fontset-spec (xlfd-fields fontlist)
+  "Complement FONTLIST for all charsets based on XLFD-FIELDS and return it.
+XLFD-FIELDS is a vector of XLFD (X Logical Font Description) fields.
+FONTLIST is an alist of cons of charset and fontname.
+
+Fontnames for charsets not listed in FONTLIST are generated from
+XLFD-FIELDS and a property of x-charset-register of each charset
+automatically."
+  (let ((charsets charset-list))
+    (while charsets
+      (let ((charset (car charsets)))
+        (if (null (assq charset fontlist))
+            (let ((registry (get-charset-property charset
+                                                  'x-charset-registry)))
+              (if (string-match "-" registry)
+                  ;; REGISTRY contains `CHARSET_ENCODING' field.
+                  (progn
+                    (aset xlfd-fields xlfd-regexp-registry-subnum
+                          (substring registry 0 (match-beginning 0)))
+                    (aset xlfd-fields xlfd-regexp-encoding-subnum
+                          (substring registry (match-end 0))))
+                (aset xlfd-fields xlfd-regexp-registry-subnum
+                      (concat registry "*"))
+                (aset xlfd-fields xlfd-regexp-encoding-subnum "*"))
+              (setq fontlist
+                    (cons (cons charset (x-compose-font-name xlfd-fields))
+                          fontlist)))))
+      (setq charsets (cdr charsets))))
+  fontlist)
+
+;; Return a list to be appended to `x-fixed-font-alist' when
+;; `mouse-set-font' is called.
+(defun generate-fontset-menu ()
+  (let ((fontsets global-fontset-alist)
+        fontset-name
+        l)
+    (while fontsets
+      (setq fontset-name (car (car fontsets)) fontsets (cdr fontsets))
+      (if (string-match "fontset-\\([^-]+\\)" fontset-name)
+          ;; This fontset has a nickname.  Just show it.
+          (let ((nickname (match-string 1 fontset-name)))
+            (setq l (cons (list (concat ".." nickname) fontset-name) l)))
+        (setq l (cons (list fontset-name fontset-name) l))))
+    (cons "Fontset" l)))
+
+(defun fontset-plain-name (fontset)
+  "Return a plain and descriptive name of FONTSET."
+  (let ((xlfd-fields (x-decompose-font-name fontset)))
+    (if xlfd-fields
+        (let ((weight (aref xlfd-fields xlfd-regexp-weight-subnum))
+              (slant  (aref xlfd-fields xlfd-regexp-slant-subnum))
+              (swidth (aref xlfd-fields xlfd-regexp-swidth-subnum))
+              (size   (aref xlfd-fields xlfd-regexp-pixelsize-subnum))
+              name)
+          (if (integerp size)
+              (setq name (format "%d " size))
+            (setq name ""))
+          (if (string-match "bold\\|demibold" weight)
+              (setq name (concat name weight " ")))
+          (cond ((string= slant "i")
+                 (setq name (concat name "italic ")))
+                ((string= slant "o")
+                 (setq name (concat name "slant ")))
+                ((string= slant "ri")
+                 (setq name (concat name "reverse italic ")))
+                ((string= slant "ro")
+                 (setq name (concat name "reverse slant "))))
+          (if (= (length name) 0)
+              ;; No descriptive fields found.
+              fontset
+            name))
+      fontset)))
+
+(defun create-fontset-from-fontset-spec (fontset-spec)
+  "Create a fontset from fontset specification string FONTSET-SPEC.
+FONTSET-SPEC is a string of the format:
+        FONTSET-NAME,CHARSET-NAME0:FONT-NAME0,CHARSET-NAME1:FONT-NAME1, ...
+Any number of SPACE, TAB, and NEWLINE can be put before and after commas."
+  (if (string-match "[^,]+" fontset-spec)
+      (let* ((idx2 (match-end 0))
+             (name (match-string 0 fontset-spec))
+             fontlist charset xlfd-fields)
+        (while (string-match "[, \t\n]*\\([^:]+\\):\\([^,]+\\)"
+                             fontset-spec idx2)
+          (setq idx2 (match-end 0))
+          (setq charset (intern (match-string 1 fontset-spec)))
+          (if (charsetp charset)
+              (setq fontlist (cons (cons charset (match-string 2 fontset-spec))
+                                   fontlist))))
+        (if (setq xlfd-fields (x-decompose-font-name name))
+            ;; If NAME conforms to XLFD, complement FONTLIST for
+            ;; charsets not specified in FONTSET-SPEC.
+            (setq fontlist
+                  (x-complement-fontset-spec xlfd-fields fontlist)))
+        (new-fontset name fontlist))))
+
+
+;; Create default fontset from 16 dots fonts which are the most widely
+;; installed fonts.
+(defvar default-fontset-spec
+  "-*-fixed-medium-r-normal-*-16-*-*-*-*-*-fontset-default,
+        chinese-gb2312:-*-medium-r-normal-*-16-*-gb2312*-*,
+        korean-ksc5601:-*-medium-r-normal-*-16-*-ksc5601*-*,
+        chinese-cns11643-1:-*-medium-r-normal-*-16-*-cns11643*-1,
+        chinese-cns11643-2:-*-medium-r-normal-*-16-*-cns11643*-2,
+        chinese-cns11643-3:-*-medium-r-normal-*-16-*-cns11643*-3,
+        chinese-cns11643-4:-*-medium-r-normal-*-16-*-cns11643*-4,
+        chinese-cns11643-5:-*-medium-r-normal-*-16-*-cns11643*-5,
+        chinese-cns11643-6:-*-medium-r-normal-*-16-*-cns11643*-6,
+        chinese-cns11643-7:-*-medium-r-normal-*-16-*-cns11643*-7"
+  "String of fontset spec of a default fontset.
+See the documentation of `create-fontset-from-fontset-spec' for the format.")
+
+;; Create fontsets from X resources of the name `fontset-N (class
+;; Fontset-N)' where N is integer 0, 1, ...
+;; The values of the resources the string of the same format as
+;; `default-fontset-spec'.
+
+(defun create-fontset-from-x-resource ()
+  (let ((idx 0)
+        fontset-spec)
+    (while (setq fontset-spec (x-get-resource (concat "fontset-" idx)
+                                              (concat "Fontset-" idx)))
+      (create-fontset-from-fontset-spec fontset-spec)
+      (setq idx (1+ idx)))))
+
+(defsubst fontset-list ()
+  "Returns a list of all defined fontset names."
+  (mapcar 'car global-fontset-alist))
+
+;;
+(provide 'fontset)
+
+;;; fontset.el ends here
diff --git a/lisp/international/isearch-x.el b/lisp/international/isearch-x.el
new file mode 100644
index 00000000000..fb288d16d9c
--- /dev/null
+++ b/lisp/international/isearch-x.el
@@ -0,0 +1,76 @@
+;;; isearch-x.el --- extended isearch handling commands
+
+;; Copyright (C) 1995 Free Software Foundation, Inc.
+;; Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+;; Keywords: multilingual, isearch
+
+;; Author: Kenichi HANDA <handa@etl.go.jp>
+;; Maintainer: Kenichi HANDA <handa@etl.go.jp>
+
+;; 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.
+
+;;; Code:
+
+;;;###autoload
+(defun isearch-toggle-specified-input-method ()
+  "Select and toggle specified input method in interactive search."
+  (interactive)
+  ;; Let the command `toggle-input-method' ask users to select input
+  ;; method interactively.
+  (setq default-input-method nil)
+  (isearch-toggle-input-method))
+
+;;;###autoload
+(defun isearch-toggle-input-method ()
+  "Toggle input method in interactive search."
+  (interactive)
+  (if isearch-multibyte-characters-flag
+      (setq isearch-multibyte-characters-flag nil)
+    (condition-case nil
+        (progn
+          (if (null default-input-method)
+              (let ((overriding-terminal-local-map nil))
+                ;; No input method has ever been selected.  Select one
+                ;; interactively now.  This also sets
+                ;; `default-input-method-title' to the title of the
+                ;; selected input method.
+                (toggle-input-method)
+                ;; And, inactivate it for the moment.
+                (toggle-input-method)))
+          (setq isearch-multibyte-characters-flag t))
+      (error (ding))))
+  (isearch-update))
+
+(defun isearch-input-method-after-insert-chunk-function ()
+  (funcall inactivate-current-input-method-function))
+
+(defun isearch-process-search-multibyte-characters (last-char)
+  (let* ((overriding-terminal-local-map nil)
+         ;; Let input method exit when a chunk is inserted.
+         (input-method-after-insert-chunk-hook
+          '(isearch-input-method-after-insert-chunk-function))
+         (input-method-inactivate-hook '(exit-minibuffer))
+         ;; Let input method work rather tersely.
+         (input-method-tersely-flag t)
+         str)
+    (setq unread-command-events (cons last-char unread-command-events))
+    (setq str (read-multilingual-string (concat (isearch-message-prefix)
+                                                isearch-message)))
+    (isearch-process-search-string str str)))
+
+;;; isearch-x.el ends here
diff --git a/lisp/international/kinsoku.el b/lisp/international/kinsoku.el
new file mode 100644
index 00000000000..a26f61c997a
--- /dev/null
+++ b/lisp/international/kinsoku.el
@@ -0,0 +1,141 @@
+;;; kinsoku.el --- `Kinsoku' processing functions.
+
+;; Copyright (C) 1995 Free Software Foundation, Inc.
+;; Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+;; Keywords: kinsoku
+
+;; 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.
+
+;;; Commentary:
+
+;; `Kinsoku' processing is to prohibit specific characters to be
+;; placed at beginning of line or at end of line.  Characters not to
+;; be placed at beginning and end of line have character category `>'
+;; and `<' respectively.   This restriction is dissolved by making a
+;; line longer or shorter.
+;;
+;; `Kinsoku' is a Japanese word which originally means ordering to
+;; stay in one place, and is used for the text processing described
+;; above in the context of text formatting.
+
+;;; Code:
+
+(defvar kinsoku-limit 4
+  "How many more columns we can make lines longer by `kinsoku' processing.
+The value 0 means there's no limitation.")
+
+;; Setting character category `>' for characters which should not be
+;; placed at beginning of line.
+(let* ((kinsoku-bol
+        (concat
+         ;; ASCII
+         "!)-_~}]:;',.?"
+         ;; Japanese JISX0208
+         "$B!"!#!$!%!&!'!(!)!*!+!,!-!.!/!0!1!2!3!4!5!6!7!8!9!:!;!<!=!>(B\
+$B!?!@!A!B!C!D!E!G!I!K!M!O!Q!S!U!W!Y![!k!l!m!n(B\
+$B$!$#$%$'$)$C$c$e$g$n%!%#%%%'%)%C%c%e%g%n%u%v(B"
+         ;; Chinese GB2312
+         "$A!"!##.#,!$!%!&!'!(!)!*!+!,!-!/!1#)!3!5!7!9!;!=(B\
+$A!?#;#:#?#!!@!A!B!C!c!d!e!f#/#\#"#_#~#|(e(B"
+         ;; Chinese BIG5
+         "$(0!"!#!$!%!&!'!(!)!*!+!,!-!.!/!0!1!2(B\
+$(0!3!4!5!6!7!8!9!:!;!<!=!?!A!C!E!G!I!K(B\
+$(0!M!O!Q(B   $(0!S!U!W!Y![!]!_!a!c!e!g!i!k!q(B\
+$(0"#"$"%"&"'"(")"*"+","2"3"4"j"k"l"x%7(B"))
+       (len (length kinsoku-bol))
+       (idx 0)
+       ch)
+  (while (< idx len)
+    (setq ch (sref kinsoku-bol idx)
+          idx (+ idx (char-bytes ch)))
+    (modify-category-entry ch ?>)))
+
+;; Setting character category `<' for characters which should not be
+;; placed at end of line.
+(let* ((kinsoku-eol
+        (concat
+         ;; ASCII
+         "({[`"
+         ;; Japanese JISX0208
+         "$B!F!H!J!L!N!P!R!T!V!X!Z!k!l!m!n!w!x(B\
+$A!.!0#"#(!2!4!6!8!:!<!>!c!d!e#@!f!l(B"
+         ;; Chinese GB2312
+         "$A(E(F(G(H(I(J(K(L(M(N(O(P(Q(R(S(T(U(V(W(X(Y(h(B\
+$(0!>!@!B!D!F!H!J!L!N!P!R!T!V!X!Z!\!^!`!b(B"
+         ;; Chinese BIG5
+         "$(0!d!f!h!j!k!q!p"i"j"k"n"x$u$v$w$x$y$z${(B\
+$(0$|$}$~%!%"%#%$%%%&%'%(%)%*%+%:(B"))
+       (len (length kinsoku-eol))
+       (idx 0)
+       ch)
+  (while (< idx len)
+    (setq ch (sref kinsoku-eol idx)
+          idx (+ idx (char-bytes ch)))
+    (modify-category-entry ch ?<)))
+
+;; Try to resolve `kinsoku' restriction by making the current line longer.
+(defun kinsoku-longer ()
+  (let ((pos-and-column (save-excursion
+                          (forward-char 1)
+                          (while (aref (char-category-set (following-char)) ?>)
+                            (forward-char 1))
+                          (cons (point) (current-column)))))
+    (if (or (<= kinsoku-limit 0)
+            (< (cdr pos-and-column) (+ (current-fill-column) kinsoku-limit)))
+        (goto-char (car pos-and-column)))))
+
+;; Try to resolve `kinsoku' restriction by making the current line shorter.
+;; The line can't be broken before the buffer position LINEBEG."
+(defun kinsoku-shorter (linebeg)
+  (let ((pos (save-excursion
+               (forward-char -1)
+               (while (and (< linebeg (point))
+                           (or (aref (char-category-set (preceding-char)) ?<)
+                               (aref (char-category-set (following-char)) ?>)))
+                 (forward-char -1))
+               (point))))
+    (if (< linebeg pos)
+        (goto-char pos))))
+
+;;;###autoload
+(defun kinsoku (linebeg)
+  "Go to a line breaking position near point by doing `kinsoku' processing.
+LINEBEG is a buffer position we can't break a line before.
+
+`Kinsoku' processing is to prohibit specific characters to be placed
+at beginning of line or at end of line.  Characters not to be placed
+at beginning and end of line have character category `>' and `<'
+respectively.  This restriction is dissolved by making a line longer or
+shorter.
+
+`Kinsoku' is a Japanese word which originally means ordering to stay
+in one place, and is used for the text processing described above in
+the context of text formatting."
+  (if (or (and
+           ;; The character after point can't be placed at beginning
+           ;; of line.  
+           (aref (char-category-set (following-char)) ?>)
+           ;; We at first try to dissolve this situation by making a
+           ;; line longer.  If it fails, then try making a line
+           ;; shorter.
+           (not (kinsoku-longer)))
+          ;; The character before point can't be placed at end of line.
+          (aref (char-category-set (preceding-char)) ?<))
+      (kinsoku-shorter linebeg)))
+
+;; kinsoku.el ends here
diff --git a/lisp/international/kkc.el b/lisp/international/kkc.el
new file mode 100644
index 00000000000..d004b88e58a
--- /dev/null
+++ b/lisp/international/kkc.el
@@ -0,0 +1,586 @@
+;; kkc.el -- Kana Kanji converter
+
+;; Copyright (C) 1995 Free Software Foundation, Inc.
+;; Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+;; Keywords: mule, multilingual, Japanese, SKK
+
+;; 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.
+
+;;; Commentary:
+
+;; These routines provide a simple and easy-to-use converter from
+;; Kana-string to Kana-Kanji-mixed-string.  This converter (here after
+;; KKC) uses a SKK dictionary to get information how to convert
+;; Kana-string.  Since KKC can't be fully automated, we need an
+;; interaction with a user to decide the correct conversion.   For
+;; that, we provide KKC major mode.
+
+;;; Code:
+
+(require 'skkdic-utl)
+
+(defvar kkc-input-method-title "$B4A(B"
+  "String denoting KKC input method.
+This string is shown at mode line when users are in KKC mode.")
+
+(defvar kkc-init-file-name "~/.kkcrc"
+  "Name of a file which contains user's initial setup code for KKC.")
+
+;; A flag to control a file specified by `kkc-init-file-name'.
+;; The value nil means the file is not yet consulted.
+;; The value t means the file has already been consulted but there's
+;; no need of updating it yet.
+;; Any other value means that we must update the file before exiting Emacs.
+(defvar kkc-init-file-flag nil)
+
+;; Cash data for `kkc-lookup-key'.  This may be initialized by loading
+;; a file specified by `kkc-init-file-name'.  If any elements are
+;; modified, the data is written out to the file when exiting Emacs.
+(defvar kkc-lookup-cache '(kkc-lookup-cache))
+
+(defun kkc-save-init-file ()
+  "Save initial setup code for KKC to a file specified by `kkc-init-file-name'"
+  (if (and kkc-init-file-flag
+           (not (eq kkc-init-file-flag t)))
+      (let ((coding-system-for-write 'coding-system-iso-2022-7))
+        (write-region (format "(setq kkc-lookup-cache '%S)\n" kkc-lookup-cache)
+                      nil
+                      kkc-init-file-name))))
+
+;; Sequence of characters to be used for indexes for shown list.  The
+;; Nth character is for the Nth conversion in the list currently shown.
+(defvar kkc-show-conversion-list-index-chars
+  "1234567890abcdefghijklmnopqrsuvwxyz")
+
+(defvar kkc-mode-map
+  (let ((map (make-keymap))
+        (i 0))
+    (while (< i ? )
+      (define-key map (char-to-string i) 'undefined)
+      (setq i (1+ i)))
+    (while (< i 128)
+      (define-key map (char-to-string i) 'kkc-non-kkc-command)
+      (setq i (1+ i)))
+    (setq i 0)
+    (let ((len (length kkc-show-conversion-list-index-chars)))
+      (while (< i len)
+        (define-key map
+          (char-to-string (aref kkc-show-conversion-list-index-chars i))
+          'kkc-select-from-list)
+        (setq i (1+ i))))
+    (define-key map " " 'kkc-next)
+    (define-key map (char-to-string help-char) 'help-command)
+    (define-key map "\r" 'kkc-terminate)
+    (define-key map "\C-@" 'kkc-first-char-only)
+    (define-key map "\C-n" 'kkc-next)
+    (define-key map "\C-p" 'kkc-prev)
+    (define-key map "\C-i" 'kkc-shorter)
+    (define-key map "\C-o" 'kkc-longer)
+    (define-key map "\C-c" 'kkc-cancel)
+    (define-key map "\C-?" 'kkc-cancel)
+    (define-key map "\C-f" 'kkc-next-phrase)
+    (define-key map "K" 'kkc-katakana)
+    (define-key map "H" 'kkc-hiragana)
+    (define-key map "l" 'kkc-show-conversion-list-or-next-group)
+    (define-key map "L" 'kkc-show-conversion-list-or-prev-group)
+    (define-key map [?\C-\ ] 'kkc-first-char-only)
+    (define-key map [delete] 'kkc-cancel)
+    (define-key map [return] 'kkc-terminate)
+    (append map '((t . kkc-non-kkc-command))))
+  "Keymap for KKC (Kana Kanji Conversion) mode.")
+
+(defun kkc-mode ()
+  "Major mode for converting Kana string to Kanji-Kana mixed string.
+Commands:
+\\{kkc-mode-map}"
+  (setq major-mode 'kkc-mode)
+  (setq mode-name "KKC")
+  (use-local-map kkc-mode-map)
+  (run-hooks 'kkc-mode-hook))
+
+;;; Internal variables used in KKC.
+
+;; The current Kana string to be converted.
+(defvar kkc-original-kana nil)
+
+;; The current key sequence (vector of Kana characters) generated from
+;; `kkc-original-kana'.
+(defvar kkc-current-key nil)
+
+;; List of the current conversions for `kkc-current-key'.
+(defvar kkc-current-conversions nil)
+
+;; Vector of the same length as `kkc-current-conversion'.  The first
+;; element is a vector of:
+;;      o index number of the first conversion shown previously,
+;;      o index number of a conversion next of the last one shown previously,
+;;      o the shown string itself.
+;; The remaining elements are widths (including columns for index
+;; numbers) of conversions stored in the same order as in
+;; `kkc-current-conversion'.
+(defvar kkc-current-conversions-width nil)
+
+(defvar kkc-show-conversion-list-count 4
+  "Count of successive `kkc-next' or `kkc-prev' to show conversion list.")
+
+;; Provided that `kkc-current-key' is [A B C D E F G H I], the current
+;; conversion target is [A B C D E F], the sequence of which
+;; conversion is found is [A B C D]:
+;;
+;;                                A B C D E F G H I
+;; kkc-overlay-head (black):     |<--------->|
+;; kkc-overlay-tail (underline):         |<------->|
+;; kkc-length-head:              |<--------->|
+;; kkc-length-converted:         |<----->|
+;;
+(defvar kkc-overlay-head nil)
+(defvar kkc-overlay-tail nil)
+(defvar kkc-length-head nil)
+(defvar kkc-length-converted nil)
+
+;; Cursor type (`box' or `bar') of the current frame.
+(defvar kkc-cursor-type nil)
+
+;; Flag to tell if the current conversion is canceled.  If non-nil,
+;; the value is a buffer position of the head of currently active
+;; conversion region.
+(defvar kkc-canceled nil)
+
+;; Lookup SKK dictionary to set list of conversions in
+;; kkc-current-conversions for key sequence kkc-current-key of length
+;; LEN.  If no conversion is found in the dictionary, don't change
+;; kkc-current-conversions and return nil.
+;; Postfixes are handled only if POSTFIX is non-nil. 
+(defun kkc-lookup-key (len &optional postfix)
+  ;; At first, prepare cache data if any.
+  (if (not kkc-init-file-flag)
+      (progn
+        (setq kkc-init-file-flag t)
+        (add-hook 'kill-emacs-hook 'kkc-save-init-file)
+        (if (file-readable-p kkc-init-file-name)
+            (condition-case nil
+                (load-file "~/.kkcrc")
+              (error (message "Invalid data in %s" kkc-init-file-name)
+                     (ding))))))
+  (let ((entry (lookup-nested-alist kkc-current-key kkc-lookup-cache len 0 t)))
+    (if (consp (car entry))
+        (setq kkc-length-converted len
+              kkc-current-conversions-width nil
+              kkc-current-conversions (car entry))
+      (setq entry (skkdic-lookup-key kkc-current-key len postfix))
+      (if entry
+          (progn
+            (setq kkc-length-converted len
+                  kkc-current-conversions-width nil
+                  kkc-current-conversions (cons 1 entry))
+            (if postfix
+                ;; Store this conversions in the cache.
+                (progn
+                  (set-nested-alist kkc-current-key kkc-current-conversions
+                                    kkc-lookup-cache kkc-length-converted)
+                  (setq kkc-init-file-flag 'kkc-lookup-cache)))
+            t)
+        (if (= len 1)
+            (setq kkc-length-converted 1
+                  kkc-current-conversions-width nil
+                  kkc-current-conversions (cons 0 nil)))))))
+
+;;;###autoload
+(defun kkc-region (from to)
+  "Convert Kana string in the current region to Kanji-Kana mixed string.
+After one candidate of conversion is shown in the region, users are
+put in KKC major mode to select a desirable conversion."
+  (interactive "r")
+  (setq kkc-original-kana (buffer-substring from to))
+  (goto-char from)
+
+  ;; Setup overlays.
+  (if (overlayp kkc-overlay-head)
+      (move-overlay kkc-overlay-head from to)
+    (setq kkc-overlay-head (make-overlay from to nil nil t))
+    (overlay-put kkc-overlay-head 'face 'highlight))
+  (if (overlayp kkc-overlay-tail)
+      (move-overlay kkc-overlay-tail to to)
+    (setq kkc-overlay-tail (make-overlay to to nil nil t))
+    (overlay-put kkc-overlay-tail 'face 'underline))
+
+  ;; After updating the conversion region with the first candidate of
+  ;; conversion, jump into a recursive editing environment with KKC
+  ;; mode .
+  (let ((overriding-local-map nil)
+        (previous-local-map (current-local-map))
+        (minor-mode-alist nil)
+        (minor-mode-map-alist nil)
+        (current-input-method-title kkc-input-method-title)
+        major-mode mode-name)
+    (unwind-protect
+        (progn
+          (setq kkc-canceled nil)
+          (setq kkc-current-key (string-to-vector kkc-original-kana))
+          (setq kkc-length-head (length kkc-current-key))
+          (setq kkc-length-converted 0)
+          (while (not (kkc-lookup-key kkc-length-head))
+            (setq kkc-length-head (1- kkc-length-head)))
+          (goto-char to)
+          (kkc-update-conversion 'all)
+          (kkc-mode)
+          (recursive-edit))
+      (goto-char (overlay-end kkc-overlay-tail))
+      (delete-overlay kkc-overlay-head)
+      (delete-overlay kkc-overlay-tail)
+      (use-local-map previous-local-map)))
+  kkc-canceled)
+
+(defun kkc-terminate ()
+  "Exit from KKC mode by fixing the current conversion."
+  (interactive)
+  (throw 'exit nil))
+
+(defun kkc-non-kkc-command ()
+  "Exit from KKC mode by fixing the current conversion.
+After that, handle the event which invoked this command."
+  (interactive)
+  (setq unread-command-events (list last-input-event))
+  (kkc-terminate))
+
+(defun kkc-cancel ()
+  "Exit from KKC mode by canceling any conversions."
+  (interactive)
+  (setq kkc-canceled (overlay-start kkc-overlay-head))
+  (goto-char kkc-canceled)
+  (delete-region (overlay-start kkc-overlay-head)
+                 (overlay-end kkc-overlay-tail))
+  (insert kkc-original-kana)
+  (kkc-terminate))
+
+(defun kkc-first-char-only ()
+  "Select only the first character currently converted."
+  (interactive)
+  (goto-char (overlay-start kkc-overlay-head))
+  (forward-char 1)
+  (delete-region (point) (overlay-end kkc-overlay-tail))
+  (kkc-terminate))
+
+;; Count of successive invocations of `kkc-next'.
+(defvar kkc-next-count nil)
+
+(defun kkc-next ()
+  "Select the next candidate of conversion."
+  (interactive)
+  (if (eq this-command last-command)
+      (setq kkc-next-count (1+ kkc-next-count))
+    (setq kkc-next-count 1))
+  (let ((idx (1+ (car kkc-current-conversions))))
+    (if (< idx 0)
+        (setq idx 1))
+    (if (>= idx (length kkc-current-conversions))
+        (setq idx 0))
+    (setcar kkc-current-conversions idx)
+    (if (> idx 1)
+        (progn
+          (set-nested-alist kkc-current-key kkc-current-conversions
+                            kkc-lookup-cache kkc-length-converted)
+          (setq kkc-init-file-flag 'kkc-lookup-cache)))
+    (if (or kkc-current-conversions-width
+            (>= kkc-next-count kkc-show-conversion-list-count))
+        (kkc-show-conversion-list-update))
+    (kkc-update-conversion)))
+
+;; Count of successive invocations of `kkc-next'.
+(defvar kkc-prev-count nil)
+
+(defun kkc-prev ()
+  "Select the previous candidate of conversion."
+  (interactive)
+  (if (eq this-command last-command)
+      (setq kkc-prev-count (1+ kkc-prev-count))
+    (setq kkc-prev-count 1))
+  (let ((idx (1- (car kkc-current-conversions))))
+    (if (< idx 0)
+        (setq idx (1- (length kkc-current-conversions))))
+    (setcar kkc-current-conversions idx)
+    (if (> idx 1)
+        (progn
+          (set-nested-alist kkc-current-key kkc-current-conversions
+                            kkc-lookup-cache kkc-length-converted)
+          (setq kkc-init-file-flag 'kkc-lookup-cache)))
+    (if (or kkc-current-conversions-width
+            (>= kkc-prev-count kkc-show-conversion-list-count))
+        (kkc-show-conversion-list-update))
+    (kkc-update-conversion)))
+
+(defun kkc-select-from-list ()
+  "Select one candidate from the list currently shown in echo area."
+  (interactive)
+  (let (idx)
+    (if kkc-current-conversions-width
+        (let ((len (length kkc-show-conversion-list-index-chars))
+              (maxlen (- (aref (aref kkc-current-conversions-width 0) 1)
+                         (aref (aref kkc-current-conversions-width 0) 0)))
+              (i 0))
+          (if (> len maxlen)
+              (setq len maxlen))
+          (while (< i len)
+            (if (= (aref kkc-show-conversion-list-index-chars i)
+                   last-input-char)
+                (setq idx i i len)
+              (setq i (1+ i))))))
+    (if idx
+        (progn
+          (setcar kkc-current-conversions
+                  (+ (aref (aref kkc-current-conversions-width 0) 0) idx))
+          (kkc-show-conversion-list-update)
+          (kkc-update-conversion))
+      (setq unread-command-events (list last-input-event))
+      (kkc-terminate))))
+
+(defun kkc-katakana ()
+  "Convert to Katakana."
+  (interactive)
+  (setcar kkc-current-conversions -1)
+  (kkc-update-conversion 'all))
+
+(defun kkc-hiragana ()
+  "Convert to hiragana."
+  (interactive)
+  (setcar kkc-current-conversions 0)
+  (kkc-update-conversion))
+
+(defun kkc-shorter ()
+  "Make the Kana string to be converted shorter."
+  (interactive)
+  (if (<= kkc-length-head 1)
+      (error "Can't be shorter")
+    (setq kkc-length-head (1- kkc-length-head))
+    (if (> kkc-length-converted kkc-length-head)
+        (let ((len kkc-length-head))
+          (setq kkc-length-converted 0)
+          (while (not (kkc-lookup-key len))
+            (setq len (1- len)))))
+    (kkc-update-conversion 'all)))
+
+(defun kkc-longer ()
+  "Make the Kana string to be converted longer."
+  (interactive)
+  (if (>= kkc-length-head (length kkc-current-key))
+      (error "Can't be longer")
+    (setq kkc-length-head (1+ kkc-length-head))
+    ;; This time, try also entries with postfixes.
+    (kkc-lookup-key kkc-length-head 'postfix)
+    (kkc-update-conversion 'all)))
+
+(defun kkc-next-phrase ()
+  "Fix the currently converted string and try to convert the remaining string."
+  (interactive)
+  (if (>= kkc-length-head (length kkc-current-key))
+      (kkc-terminate)
+    (setq kkc-length-head (- (length kkc-current-key) kkc-length-head))
+    (goto-char (overlay-end kkc-overlay-head))
+    (while (and (< (point) (overlay-end kkc-overlay-tail))
+                (looking-at "\\CH"))
+      (goto-char (match-end 0))
+      (setq kkc-length-head (1- kkc-length-head)))
+    (if (= kkc-length-head 0)
+        (kkc-terminate)
+      (let ((newkey (make-vector kkc-length-head 0))
+            (idx (- (length kkc-current-key) kkc-length-head))
+            (i 0))
+        ;; For the moment, (setq kkc-original-kana (concat newkey))
+        ;; doesn't work.
+        (setq kkc-original-kana "")
+        (while (< i kkc-length-head)
+          (aset newkey i (aref kkc-current-key (+ idx i)))
+          (setq kkc-original-kana
+                (concat kkc-original-kana (char-to-string (aref newkey i))))
+          (setq i (1+ i)))
+        (setq kkc-current-key newkey)
+        (setq kkc-length-converted 0)
+        (while (and (not (kkc-lookup-key kkc-length-head))
+                    (> kkc-length-head 1))
+          (setq kkc-length-head (1- kkc-length-head)))
+        (let ((pos (point))
+              (tail (overlay-end kkc-overlay-tail)))
+          (move-overlay kkc-overlay-head pos tail)
+          (move-overlay kkc-overlay-tail tail tail))
+        (kkc-update-conversion 'all)))))
+
+;; We'll show users a list of available conversions in echo area with
+;; index numbers so that users can select one conversion with the
+;; number.
+
+;; Set `kkc-current-conversions-width'.
+(defun kkc-setup-current-conversions-width ()
+  (let ((convs (cdr kkc-current-conversions))
+        (len (length kkc-current-conversions))
+        (idx 1))
+    (setq kkc-current-conversions-width (make-vector len nil))
+    ;; To tell `kkc-show-conversion-list-update' to generate
+    ;; message from scratch.
+    (aset kkc-current-conversions-width 0 (vector len -2 nil))
+    ;; Fill the remaining slots.
+    (while convs
+      (aset kkc-current-conversions-width idx
+            (+ (string-width (car convs)) 4))
+      (setq convs (cdr convs)
+            idx (1+ idx)))))
+
+(defun kkc-show-conversion-list-or-next-group ()
+  "Show list of available conversions in echo area with index numbers.
+If the list is already shown, show the next group of conversions,
+and change the current conversion to the first one in the group."
+  (interactive)
+  (if (< (length kkc-current-conversions) 3)
+      (error "No alternative"))
+  (if kkc-current-conversions-width
+      (let ((next-idx (aref (aref kkc-current-conversions-width 0) 1)))
+        (if (< next-idx (length kkc-current-conversions-width))
+            (setcar kkc-current-conversions next-idx)
+          (setcar kkc-current-conversions 1))
+        (kkc-show-conversion-list-update)
+        (kkc-update-conversion))
+    (kkc-setup-current-conversions-width)
+    (kkc-show-conversion-list-update)))
+
+(defun kkc-show-conversion-list-or-prev-group ()
+  "Show list of available conversions in echo area with index numbers.
+If the list is already shown, show the previous group of conversions,
+and change the current conversion to the last one in the group."
+  (interactive)
+  (if (< (length kkc-current-conversions) 3)
+      (error "No alternative"))
+  (if kkc-current-conversions-width
+      (let ((this-idx (aref (aref kkc-current-conversions-width 0) 0)))
+        (if (> this-idx 1)
+            (setcar kkc-current-conversions (1- this-idx))
+          (setcar kkc-current-conversions
+                  (1- (length kkc-current-conversions-width))))
+        (kkc-show-conversion-list-update)
+        (kkc-update-conversion))
+    (kkc-setup-current-conversions-width)
+    (kkc-show-conversion-list-update)))
+
+;; Update the conversion list shown in echo area.
+(defun kkc-show-conversion-list-update ()
+  (or kkc-current-conversions-width
+      (kkc-setup-current-conversions-width))
+  (let* ((current-idx (car kkc-current-conversions))
+         (first-slot (aref kkc-current-conversions-width 0))
+         (this-idx (aref first-slot 0))
+         (next-idx (aref first-slot 1))
+         (msg (aref first-slot 2)))
+    (if (< current-idx this-idx)
+        ;; The currently selected conversion is before the list shown
+        ;; previously.  We must start calculation of message width
+        ;; from the start again.
+        (setq this-idx 1 msg nil)
+      (if (>= current-idx next-idx)
+          ;; The currently selected conversion is after the list shown
+          ;; previously.  We start calculation of message width from
+          ;; the conversion next of TO.
+          (setq this-idx next-idx msg nil)
+        ;; The current conversion is in MSG.  Just clear brackets
+        ;; around index number.
+        (if (string-match "<.>" msg)
+            (progn
+              (aset msg (match-beginning 0) ?\ )
+              (aset msg (1- (match-end 0)) ?\ )))))
+    (if (not msg)
+        (let ((len (length kkc-current-conversions))
+              (max-width (window-width (minibuffer-window)))
+              (width-table kkc-current-conversions-width)
+              (width 0)
+              (idx this-idx)
+              l)
+          (while (< idx current-idx)
+            (if (<= (+ width (aref width-table idx)) max-width)
+                (setq width (+ width (aref width-table idx)))
+              (setq this-idx idx width (aref width-table idx)))
+            (setq idx (1+ idx)
+                  l (cdr l)))
+          (aset first-slot 0 this-idx)
+          (while (and (< idx len)
+                      (<= (+ width (aref width-table idx)) max-width))
+            (setq width (+ width (aref width-table idx))
+                  idx (1+ idx)
+                  l (cdr l)))
+          (aset first-slot 1 (setq next-idx idx))
+          (setq l (nthcdr this-idx kkc-current-conversions))
+          (setq msg "")
+          (setq idx this-idx)
+          (while (< idx next-idx)
+            (setq msg (format "%s %c %s "
+                              msg
+                              (aref kkc-show-conversion-list-index-chars
+                                    (- idx this-idx))
+                              (car l)))
+            (setq idx (1+ idx)
+                  l (cdr l)))
+          (aset first-slot 2 msg)))
+    (if (> current-idx 0)
+        (progn
+          ;; Highlight the current conversion by brackets.
+          (string-match (format " \\(%c\\) "
+                                (aref kkc-show-conversion-list-index-chars
+                                      (- current-idx this-idx)))
+                        msg)
+          (aset msg (match-beginning 0) ?<)
+          (aset msg (1- (match-end 0)) ?>)))
+    (message "%s" msg)))
+
+;; Update the conversion area with the latest conversion selected.
+;; ALL if non nil means to update the whole area, else update only
+;; inside quail-overlay-head.
+
+(defun kkc-update-conversion (&optional all)
+  (goto-char (overlay-start kkc-overlay-head))
+  (cond ((= (car kkc-current-conversions) 0) ; Hiragana
+         (let ((i 0))
+           (while (< i kkc-length-converted)
+             (insert (aref kkc-current-key i))
+             (setq i (1+ i)))))
+        ((= (car kkc-current-conversions) -1) ; Katakana
+         (let ((i 0))
+           (while (< i kkc-length-converted)
+             (insert (japanese-katakana (aref kkc-current-key i)))
+             (setq i (1+ i)))))
+        (t
+         (insert (nth (car kkc-current-conversions) kkc-current-conversions))))
+  (delete-region (point) (overlay-start kkc-overlay-tail))
+  (if all
+      (let ((len (length kkc-current-key))
+            (i kkc-length-converted))
+        (delete-region (overlay-start kkc-overlay-tail)
+                       (overlay-end kkc-overlay-head))
+        (while (< i kkc-length-head)
+          (if (= (car kkc-current-conversions) -1)
+              (insert (japanese-katakana (aref kkc-current-key i)))
+            (insert (aref kkc-current-key i)))
+          (setq i (1+ i)))
+        (let ((pos (point)))
+          (while (< i len)
+            (insert (aref kkc-current-key i))
+            (setq i (1+ i)))
+          (move-overlay kkc-overlay-head
+                        (overlay-start kkc-overlay-head) pos)
+          (delete-region (point) (overlay-end kkc-overlay-tail)))))
+  (goto-char (overlay-end kkc-overlay-tail)))
+
+;;
+(provide 'kkc)
+
+;; kkc.el ends here
diff --git a/lisp/international/mule-cmds.el b/lisp/international/mule-cmds.el
new file mode 100644
index 00000000000..ebc9663dcb0
--- /dev/null
+++ b/lisp/international/mule-cmds.el
@@ -0,0 +1,494 @@
+;;; mule-cmds.el --- Commands for mulitilingual environment
+
+;; Copyright (C) 1995 Free Software Foundation, Inc.
+;; Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+;; Keywords: mule, multilingual
+
+;; 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.
+
+;;; Code:
+
+;;; MULE related key bindings and menus.
+
+(defvar mule-keymap (make-sparse-keymap "MULE")
+  "Keymap for MULE (Multilingual environment) specific commands.")
+(fset 'mule-prefix mule-keymap)
+
+;; Keep "C-x C-k ..." for mule specific commands.
+(define-key ctl-x-map "\C-k" 'mule-prefix)
+
+(define-key global-map [menu-bar mule] (cons "Mule" mule-keymap))
+
+(setq menu-bar-final-items (cons 'mule menu-bar-final-items))
+
+(defvar mule-describe-language-support-map
+  (make-sparse-keymap "Describe Language Support"))
+(fset 'mule-describe-language-support-prefix
+      mule-describe-language-support-map)
+
+(define-key mule-keymap "m" 'toggle-enable-multibyte-characters)
+(define-key mule-keymap "f" 'set-buffer-file-coding-system)
+(define-key mule-keymap "t" 'set-terminal-coding-system)
+(define-key mule-keymap "k" 'set-keyboard-coding-system)
+(define-key mule-keymap "p" 'set-current-process-coding-system)
+(define-key mule-keymap "i" 'select-input-method)
+
+(define-key help-map "\C-L" 'describe-language-support)
+(define-key help-map "\C-\\" 'describe-input-method)
+(define-key help-map "C" 'describe-current-coding-system)
+(define-key help-map "h" 'view-hello-file)
+
+(define-key mule-keymap [set-process-coding-system]
+  '(" ... of process" . set-current-process-coding-system))
+(define-key mule-keymap [set-keyboard-coding-system]
+  '(" ... of keyboard" . set-keyboard-coding-system))
+(define-key mule-keymap [set-terminal-coding-system]
+  '(" ... of terminal" . set-terminal-coding-system))
+(define-key mule-keymap [set-buffer-file-coding-system]
+  '(" ... of visiting file" . set-buffer-file-coding-system))
+(define-key mule-keymap [separator-mule]
+  '("Setting coding systems"))
+(define-key mule-keymap [describe-current-coding-system]
+  '("Describe current coding systems" . describe-current-coding-system))
+(define-key mule-keymap [describe-language-support]
+  '("Describe language support" . mule-describe-language-support-prefix))
+(define-key mule-keymap [view-hello-file]
+  '("Show many languages" . view-hello-file))
+(define-key mule-keymap [describe-input-method]
+  '("Describe input method" . describe-input-method))
+(define-key mule-keymap [select-input-method]
+  '("Select input method" . select-input-method))
+(define-key mule-keymap [toggle-input-method]
+  '("Toggle input method" . toggle-input-method))
+(define-key mule-keymap [toggle-mule]
+  '("Toggle MULE" . toggle-enable-multibyte-characters))
+
+;; These are meaningless when running under X.
+(put 'set-keyboard-coding-system 'menu-enable
+     '(null window-system))
+(put 'set-terminal-coding-system 'menu-enable
+     '(null window-system))
+
+
+;; This should be a single character key binding because users use it
+;; very frequently while editing multilingual text.  Now we can use
+;; only two such keys: "\C-\\" and "\C-^", but the latter is not
+;; convenient because it requires shifting on most keyboards.  An
+;; alternative is "\C-\]" which is now bound to `abort-recursive-edit'
+;; but it won't be used that frequently.
+(define-key global-map "\C-\\" 'toggle-input-method)
+
+(defun toggle-enable-multibyte-characters (&optional arg)
+  "Change whether this buffer enables multibyte characters.
+With arg, make them enable iff arg is positive."
+  (interactive "P")
+  (setq enable-multibyte-characters
+        (if (null arg) (null enable-multibyte-characters)
+          (> (prefix-numeric-value arg) 0)))
+  (force-mode-line-update))
+
+(defun view-hello-file ()
+  "Display the HELLO file which list up many languages and characters."
+  (interactive)
+  (find-file-read-only (expand-file-name "HELLO" data-directory)))
+
+
+;;; Language support staffs.
+
+(defvar primary-language "English"
+  "Name of a user's primary language.
+Emacs provide various language supports based on this variable.")
+
+(defvar language-info-alist nil
+  "Alist of language names vs the corresponding information of various kind.
+Each element looks like:
+        (LANGUAGE-NAME . ((KEY . INFO) ...))
+where LANGUAGE-NAME is a string,
+KEY is a symbol denoting the kind of information,
+INFO is any Lisp object which contains the actual information related
+to KEY.")
+
+(defun get-language-info (language-name key)
+  "Return the information for LANGUAGE-NAME of the kind KEY.
+LANGUAGE-NAME is a string.
+KEY is a symbol denoting the kind of required information."
+  (let ((lang-slot (assoc language-name language-info-alist)))
+    (if lang-slot
+        (cdr (assq key (cdr lang-slot))))))
+
+;; Return a lambda form which calls `describe-language-support' with
+;; argument LANG.
+(defun build-describe-language-support-function (lang)
+  `(lambda ()
+     (interactive)
+     (describe-language-support ,lang)))
+
+(defun set-language-info (language-name key info)
+  "Set for LANGUAGE-NAME the information INFO under KEY.
+LANGUAGE-NAME is a string
+KEY is a symbol denoting the kind of information.
+INFO is any Lisp object which contains the actual information.
+
+Currently, the following KEYs are used by Emacs:
+charset: list of symbols whose values are charsets specific to the language.
+coding-system: list of coding systems specific to the langauge.
+setup-function: see the documentation of `set-language-envrionment'.
+tutorial: a tutorial file name written in the language.
+sample-text: one line short text containing characters of the language.
+documentation: a docstring describing how the language is supported,
+  or a fuction to call to describe it,
+  or t which means call `describe-language-support' to describe it.
+input-method: alist of input method names for the language vs information
+  for activating them.  Use `register-input-method' (which see)
+  to add a new input method to the alist.
+
+Emacs will use more KEYs in the future.  To avoid the conflition, users
+should use prefix \"user-\" in the name of KEY."
+  (let (lang-slot key-slot)
+    (setq lang-slot (assoc language-name language-info-alist))
+    (if (null lang-slot)                ; If no slot for the language, add it.
+        (setq lang-slot (list language-name)
+              language-info-alist (cons lang-slot language-info-alist)))
+    (setq key-slot (assq key lang-slot))
+    (if (null key-slot)                 ; If no slot for the key, add it.
+        (progn
+          (setq key-slot (list key))
+          (setcdr lang-slot (cons key-slot (cdr lang-slot)))))
+    (setcdr key-slot info)
+    ;; Setup menu.
+    (if (eq key 'documentation)
+        (define-key mule-describe-language-support-map
+          (vector (intern language-name))
+          (cons language-name
+                (build-describe-language-support-function language-name))))
+    ))
+
+(defun set-language-info-alist (language-name alist)
+  "Set for LANGUAGE-NAME the information in ALIST.
+ALIST is an alist of KEY and INFO.  See the documentation of
+`set-langauge-info' for the meanings of KEY and INFO."
+  (while alist
+    (set-language-info language-name (car (car alist)) (cdr (car alist)))
+    (setq alist (cdr alist))))
+
+(defun read-language-name (key prompt &optional initial-input)
+  "Read language name which has information for KEY, prompting with PROMPT."
+  (let* ((completion-ignore-case t)
+         (name (completing-read prompt
+                                language-info-alist
+                                (function (lambda (elm) (assq key elm)))
+                                t
+                                initial-input)))
+    ;; In spite of the documentation, completing-read returns null
+    ;; string instead of nil if input is null.
+    (and (> (length name) 0) name)))
+
+;;; Multilingual input methods.
+
+(defvar current-input-method nil
+  "The current input method for multilingual text.
+The value is a cons of language name and input method name.
+If nil, it means no input method is activated now.")
+(make-variable-buffer-local 'current-input-method)
+(put 'current-input-method 'permanent-local t)
+
+(defvar current-input-method-title nil
+  "Title string of the current input method shown in mode line.
+Every input method should set this an appropriate value when activated.")
+(make-variable-buffer-local 'current-input-method-title)
+(put 'current-input-method-title 'permanent-local t)
+
+(defvar default-input-method nil
+  "Default input method.
+The default input method is the one activated automatically by the command
+`toggle-input-method' (\\[toggle-input-method]).
+The value is a cons of language name and input method name.")
+
+(defvar default-input-method-title nil
+  "Title string of the default input method.")
+
+(defvar previous-input-method nil
+  "Input method selected previously.
+This is the one selected before the current input method is selected.
+See also the documentation of `default-input-method'.")
+
+(defvar inactivate-current-input-method-function nil
+  "Function to call for inactivating the current input method.
+Every input method should set this to an appropriate value when activated.
+This function is called with no argument.")
+(make-variable-buffer-local 'inactivate-current-input-method-function)
+(put 'inactivate-current-input-method-function 'permanent-local t)
+
+(defvar describe-current-input-method-function nil
+  "Function to call for describing the current input method.
+This function is called with no argument.")
+(make-variable-buffer-local 'describe-current-input-method-function)
+(put 'describe-current-input-method-function 'permanent-local t)
+
+(defun register-input-method (language-name input-method)
+  "Register INPUT-METHOD as an input method of LANGUAGE-NAME.
+LANGUAGE-NAME is a string.
+INPUT-METHOD is a list of the form:
+        (METHOD-NAME ACTIVATE-FUNC ARG ...)
+where METHOD-NAME is the name of this method,
+ACTIVATE-FUNC is the function to call for activating this method.
+Arguments for the function are METHOD-NAME and ARGs."
+  (let ((slot (get-language-info language-name 'input-method))
+        method-slot)
+    (if (null slot)
+        (set-language-info language-name 'input-method (list input-method))
+      (setq method-slot (assoc (car input-method) slot))
+      (if method-slot
+          (setcdr method-slot (cdr input-method))
+        (set-language-info language-name 'input-method
+                           (cons input-method slot))))))
+
+(defun read-language-and-input-method-name ()
+  "Read a language names and the corresponding input method from a minibuffer.
+Return a cons of those names."
+  (let ((language-name (read-language-name
+                        'input-method
+                        "Language: "
+                        (if previous-input-method
+                            (cons (car previous-input-method) 0)))))
+    (if (null language-name)
+        (error "No input method for the specified language"))
+    (let* ((completion-ignore-case t)
+           (key-slot
+            (assq 'input-method
+                  (cdr (assoc language-name language-info-alist))))
+           (method-name
+            (completing-read "Input method: " (cdr key-slot) nil t
+                             (if (and previous-input-method
+                                      (string= language-name
+                                               (car previous-input-method)))
+                                 (cons (cdr previous-input-method) 0)))))
+      ;; In spite of the documentation, completing-read returns
+      ;; null string instead of nil if input is null.
+      (if (= (length method-name) 0)
+          (error "No input method specified"))
+      (list language-name method-name))))
+
+(defun set-default-input-method (language-name method-name)
+  "Set the default input method to METHOD-NAME for inputting LANGUAGE-NAME.
+The default input method is the one activated automatically by the command
+`toggle-input-method' (\\[toggle-input-method]).
+This doesn't affect the currently activated input method."
+  (interactive (read-language-and-input-method-name))
+  (let* ((key-slot (get-language-info language-name 'input-method))
+         (method-slot (assoc method-name key-slot)))
+    (if (null method-slot)
+        (error "No input method `%s' for %s" method-name language-name))
+    (setq default-input-method (cons language-name method-name))))
+
+(defun select-input-method (language-name method-name)
+  "Select and activate input method METHOD-NAME for inputting LANGUAGE-NAME.
+The information for activating METHOD-NAME is stored
+in `language-info-alist' under the key 'input-method.
+The format of the information has the form:
+        ((METHOD-NAME ACTIVATE-FUNC ARG ...) ...)
+where ACTIVATE-FUNC is a function to call for activating this method.
+Arguments for the function are METHOD-NAME and ARGs."
+  (interactive (read-language-and-input-method-name))
+  (let* ((key-slot (get-language-info language-name 'input-method))
+         (method-slot (assoc method-name key-slot)))
+    (if (null method-slot)
+        (error "No input method `%s' for %s" method-name language-name))
+    (if current-input-method
+        (progn
+          (if (not (equal previous-input-method current-input-method))
+              (setq previous-input-method current-input-method))
+          (funcall inactivate-current-input-method-function)))
+    (setq method-slot (cdr method-slot))
+    (apply (car method-slot) method-name (cdr method-slot))
+    (setq default-input-method
+          (setq current-input-method (cons language-name method-name)))
+    (setq default-input-method-title current-input-method-title)
+    (setq current-input-method default-input-method)))
+
+(defun toggle-input-method (&optional arg)
+  "Toggle whether a multilingual input method is activated in this buffer.
+With arg, activate an input method specified interactively.
+Without arg, the method being activated is the one selected most recently,
+ but if no input method has ever been selected, select one interactively."
+  (interactive "P")
+  (if arg
+      (call-interactively 'select-input-method)
+    (if (null current-input-method)
+        (if default-input-method
+            (select-input-method (car default-input-method)
+                                 (cdr default-input-method))
+          (call-interactively 'select-input-method))
+      (funcall inactivate-current-input-method-function)
+      (setq current-input-method nil))))
+
+(defun describe-input-method ()
+  "Describe the current input method."
+  (interactive)
+  (if current-input-method
+      (if (and (symbolp describe-current-input-method-function)
+               (fboundp describe-current-input-method-function))
+          (funcall describe-current-input-method-function)
+        (message "No way to describe the current input method `%s'"
+                 (cdr current-input-method))
+        (ding))
+    (message "No input method is activated now")
+    (ding)))
+
+(defun read-multilingual-string (prompt &optional initial-input
+                                        language-name method-name)
+  "Read a multilingual string from minibuffer, prompting with string PROMPT.
+The input method selected last time is activated in minibuffer.
+If non-nil, second arg INITIAL-INPUT is a string to insert before reading.
+Optional 3rd and 4th arguments LANGUAGE-NAME and METHOD-NAME specify
+ the input method to be activated instead of the one selected last time."
+  (let ((minibuffer-setup-hook '(toggle-input-method))
+        (default-input-method default-input-method))
+    (if (and language-name method-name)
+        (set-default-input-method language-name method-name))
+    (read-string prompt initial-input)))
+
+;; Variables to control behavior of input methods.  All input methods
+;; should react to these variables.
+
+(defvar input-method-tersely-flag nil
+  "*If this flag is non-nil, input method works rather tersely.
+
+For instance, Quail input method does not show guidance buffer while
+inputting at minibuffer if this flag is t.")
+
+(defvar input-method-activate-hook nil
+  "Normal hook run just after an input method is activated.")
+
+(defvar input-method-inactivate-hook nil
+  "Normal hook run just after an input method is inactivated.")
+
+(defvar input-method-after-insert-chunk-hook nil
+  "Normal hook run just after an input method insert some chunk of text.")
+
+
+;;; Language specific setup functions.
+(defun set-language-environment (language-name)
+  "Setup a user's environment for LANGUAGE-NAME.
+
+To setup, a fucntion returned by:
+  (get-language-info LANGUAGE-NAME 'setup-function)
+is called."
+  (interactive (list (read-language-name 'setup-function "Language: ")))
+  (let (func)
+    (if (or (null language-name)
+            (null (setq func
+                        (get-language-info language-name 'setup-function))))
+        (error "No way to setup environment for the specified language"))
+    (funcall func)))
+
+;; Print all arguments with `princ', then print "\n".
+(defsubst princ-list (&rest args)
+  (while args (princ (car args)) (setq args (cdr args)))
+  (princ "\n"))
+
+(defun describe-language-support (language-name)
+  "Show documentation about how Emacs supports LANGUAGE-NAME."
+  (interactive (list (read-language-name 'documentation "Language: ")))
+  (let (doc)
+    (if (or (null language-name)
+            (null (setq doc
+                        (get-language-info language-name 'documentation))))
+        (error "No documentation for the specified language"))
+    (with-output-to-temp-buffer "*Help*"
+      (if (not (eq doc t))
+          (cond ((stringp doc)
+                 (princ doc))
+                ((and (symbolp doc) (fboundp doc))
+                 (funcall doc))
+                (t
+                 (error "Invalid documentation data for %s" language-name)))
+        (princ-list "List of items specific to "
+                    language-name
+                    " environment")
+        (princ "-----------------------------------------------------------\n")
+        (let ((str (get-language-info language-name 'sample-text)))
+          (if (stringp str)
+              (progn
+                (princ "<sample text>\n")
+                (princ-list "  " str))))
+        (princ "<input methods>\n")
+        (let ((l (get-language-info language-name 'input-method)))
+          (while l
+            (princ-list "  " (car (car l)))
+            (setq l (cdr l))))
+        (princ "<character sets>\n")
+        (let ((l (get-language-info language-name 'charset)))
+          (if (null l)
+              (princ-list "  nothing specific to " language-name)
+            (while l
+              (princ-list "  " (car l)
+                          (format ":%3d:\n\t" (charset-id (car l)))
+                          (charset-description (car l)))
+              (setq l (cdr l)))))
+        (princ "<coding systems>\n")
+        (let ((l (get-language-info language-name 'coding-system)))
+          (if (null l)
+              (princ-list "  nothing specific to " language-name)
+            (while l
+              (princ-list "  " (car l) ":\n\t"
+                          (coding-system-docstring (car l)))
+              (setq l (cdr l)))))))))
+
+;;; Charset property
+
+(defsubst get-charset-property (charset propname)
+  "Return the value of CHARSET's PROPNAME property.
+This is the last value stored with
+`(put-charset-property CHARSET PROPNAME VALUE)'."
+  (plist-get (charset-plist charset) propname))
+
+(defsubst put-charset-property (charset propname value)
+  "Store CHARSETS's PROPNAME property with value VALUE.
+It can be retrieved with `(get-charset-property CHARSET PROPNAME)'."
+  (set-charset-plist charset
+                     (plist-put (charset-plist charset) propname value)))
+
+;;; Character code property
+(put 'char-code-property-table 'char-table-extra-slots 0)
+
+(defvar char-code-property-table
+  (make-char-table 'char-code-property-table)
+  "Char-table containing a property list of each character code.
+
+See also the documentation of `get-char-code-property' and
+`put-char-code-property'")
+
+(defun get-char-code-property (char propname)
+  "Return the value of CHAR's PROPNAME property in `char-code-property-table'."
+  (let ((plist (aref char-code-property-table char)))
+    (if (listp plist)
+        (car (cdr (memq propname plist))))))
+
+(defun put-char-code-property (char propname value)
+  "Store CHAR's PROPNAME property with VALUE in `char-code-property-table'.
+It can be retrieved with `(get-char-code-property CHAR PROPNAME)'."
+  (let ((plist (aref char-code-property-table char)))
+    (if plist
+        (let ((slot (memq propname plist)))
+          (if slot
+              (setcar (cdr slot) value)
+            (nconc plist (list propname value))))
+      (aset char-code-property-table char (list propname value)))))
+
+;;; mule-cmds.el ends here
diff --git a/lisp/international/mule-diag.el b/lisp/international/mule-diag.el
new file mode 100644
index 00000000000..ecee2b4615e
--- /dev/null
+++ b/lisp/international/mule-diag.el
@@ -0,0 +1,565 @@
+;; mule-diag.el -- show diagnosis of multilingual environment (MULE)
+
+;; Copyright (C) 1995 Free Software Foundation, Inc.
+;; Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+;; Keywords: multilingual, charset, coding system, fontset, diagnosis
+
+;; 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.
+
+;;; General utility function
+
+;; Print all arguments with single space separator in one line.
+(defun print-list (&rest args)
+  (while (cdr args)
+    (if (car args)
+        (progn (princ (car args)) (princ " ")))
+    (setq args (cdr args)))
+  (princ (car args))
+  (princ "\n"))
+
+;;; CHARSET
+
+;;;###autoload
+(defun list-character-sets ()
+  "Display a list of all charsets."
+  (interactive)
+  (with-output-to-temp-buffer "*Help*"
+    (print-character-sets)))
+
+(defvar charset-other-info-func nil)
+  
+(defun print-character-sets ()
+  "Print information on all charsets in a machine readable format."
+  (princ "\
+#########################
+## LIST OF CHARSETS
+## Each line corresponds to one charset.
+## The following attributes are listed in this order
+## separated by a colon `:' in one line.
+##      CHARSET-SYMBOL-NAME,
+##      CHARSET-ID,
+##      DIMENSION (1 or 2)
+##      CHARS (94 or 96)
+##      BYTES (of multibyte form: 1, 2, 3, or 4),
+##      WIDTH (occupied column numbers: 1 or 2),
+##      DIRECTION (0:left-to-right, 1:right-to-left),
+##      ISO-FINAL-CHAR (character code of ISO-2022's final character)
+##      ISO-GRAPHIC-PLANE (ISO-2022's graphic plane, 0:GL, 1:GR)
+##      DESCRIPTION (describing string of the charset)
+")
+  (let ((charsets charset-list)
+        charset)
+    (while charsets
+      (setq charset (car charsets))
+      (princ (format "%s:%03d:%d:%d:%d:%d:%d:%d:%d:%s\n" 
+                     charset
+                     (charset-id charset)
+                     (charset-dimension charset)
+                     (charset-chars charset)
+                     (charset-bytes charset)
+                     (charset-width charset)
+                     (charset-direction charset)
+                     (charset-iso-final-char charset)
+                     (charset-iso-graphic-plane charset)
+                     (charset-description charset)))
+      (setq charsets (cdr charsets)))))
+
+
+;;; CODING-SYSTEM
+
+;; Print information of designation of each graphic register in FLAGS
+;; in human readable format.  See the documentation of
+;; `make-coding-system' for the meaning of FLAGS.
+(defun print-designation (flags)
+  (let ((graphic-register 0)
+        charset)
+    (while (< graphic-register 4)
+      (setq charset (aref flags graphic-register))
+      (princ (format
+              "  G%d -- %s\n"
+              graphic-register
+              (cond ((null charset)
+                     "never used")
+                    ((eq charset t)
+                     "no initial designation, and used by any charsets")
+                    ((symbolp charset)
+                     (format "%s:%s"
+                             charset (charset-description charset)))
+                    ((listp charset)
+                     (if (charsetp (car charset))
+                         (format "%s:%s, and also used by the followings:"
+                                 (car charset)
+                                 (charset-description (car charset)))
+                       "no initial designation, and used by the followings:"))
+                    (t
+                     "invalid designation information"))))
+      (if (listp charset)
+          (progn
+            (setq charset (cdr charset))
+            (while charset
+              (cond ((eq (car charset) t)
+                     (princ "\tany other charsets\n"))
+                    ((charsetp (car charset))
+                     (princ (format "\t%s:%s\n"
+                                    (car charset)
+                                    (charset-description (car charset)))))
+                    (t
+                     "invalid designation information"))                   
+              (setq charset (cdr charset)))))
+      (setq graphic-register (1+ graphic-register)))))
+
+;;;###autoload
+(defun describe-coding-system (coding-system)
+  "Display information of CODING-SYSTEM."
+  (interactive "zCoding-system: ")
+  (check-coding-system coding-system)
+  (with-output-to-temp-buffer "*Help*"
+    (let ((coding-vector (coding-system-vector coding-system)))
+      (princ "Coding-system ")
+      (princ coding-system)
+      (princ " [")
+      (princ (char-to-string (coding-vector-mnemonic coding-vector)))
+      (princ "]: \n")
+      (princ "  ")
+      (princ (coding-vector-docstring coding-vector))
+      (princ "\nType: ")
+      (let ((type (coding-vector-type coding-vector))
+            (flags (coding-vector-flags coding-vector)))
+        (princ type)
+        (princ ", which means ")
+        (cond ((eq type nil)
+               (princ "do no conversion."))
+              ((eq type t)
+               (princ "do automatic conversion."))
+              ((eq type 0)
+               (princ "Emacs internal multibyte form."))
+              ((eq type 1)
+               (princ "Shift-JIS (MS-KANJI)."))
+              ((eq type 2)
+               (princ "a variant of ISO-2022.\n")
+               (princ "Initial designations:\n")
+               (print-designation flags)
+               (princ "Other Form: \n")
+               (princ (if (aref flags 4) "short-form" "long-form"))
+               (if (aref flags 5) (princ ", ASCII@EOL"))
+               (if (aref flags 6) (princ ", ASCII@CNTL"))
+               (princ (if (aref flags 7) ", 7-bit" ", 8-bit"))
+               (if (aref flags 8) (princ ", use-locking-shift"))
+               (if (aref flags 9) (princ ", use-single-shift"))
+               (if (aref flags 10) (princ ", use-roman"))
+               (if (aref flags 10) (princ ", use-old-jis"))
+               (if (aref flags 11) (princ ", no-ISO6429"))
+               (princ "."))
+              ((eq type 3)
+               (princ "Big5."))
+              ((eq type 4)
+               (princ "do conversion by CCL program."))
+              (t (princ "invalid coding-system."))))
+      (princ "\nEOL-Type: ")
+      (let ((eol-type (coding-system-eoltype coding-system)))
+        (cond ((vectorp eol-type)
+               (princ "Automatic selection from ")
+               (princ eol-type)
+               (princ "\n"))
+              ((or (null eol-type) (eq eol-type 0)) (princ "LF\n"))
+              ((eq eol-type 1) (princ "CRLF\n"))
+              ((eq eol-type 2) (princ "CR\n"))
+              (t (princ "invalid\n"))))
+      )))
+
+;;;###autoload
+(defun describe-current-coding-system-briefly ()
+  "Display coding systems currently used in a brief format in mini-buffer.
+
+The format is \"current: [FKTPp=........] default: [FPp=......]\",
+where mnemonics of the following coding systems come in this order
+at the place of `...':
+  buffer-file-coding-system (of the current buffer)
+  eol-type of buffer-file-coding-system (of the current buffer)
+  keyboard-coding-system
+  terminal-coding-system
+  process-coding-system for read (of the current buffer, if any)
+  eol-type of process-coding-system for read (of the current buffer, if any)
+  process-coding-system for write (of the current buffer, if any)
+  eol-type of process-coding-system for write (of the current buffer, if any)
+  default buffer-file-coding-system
+  eol-type of default buffer-file-coding-system
+  default process-coding-system for read
+  default eol-type of process-coding-system for read
+  default process-coding-system for write
+  default eol-type of process-coding-system"
+  (interactive)
+  (let* ((proc (get-buffer-process (current-buffer)))
+         (process-coding-systems (if proc (process-coding-system proc))))
+    (message
+     "current: [FKTPp=%c%c%c%c%c%c%c%c] default: [FPp=%c%c%c%c%c%c]"
+     (coding-system-mnemonic buffer-file-coding-system)
+     (coding-system-eoltype-mnemonic buffer-file-coding-system)
+     (coding-system-mnemonic (keyboard-coding-system))
+     (coding-system-mnemonic (terminal-coding-system))
+     (coding-system-mnemonic (car process-coding-systems))
+     (coding-system-eoltype-mnemonic (car process-coding-systems))
+     (coding-system-mnemonic (cdr process-coding-systems))
+     (coding-system-eoltype-mnemonic (cdr process-coding-systems))
+     (coding-system-mnemonic (default-value 'buffer-file-coding-system))
+     (coding-system-eoltype-mnemonic (default-value 'buffer-file-coding-system))
+     (coding-system-mnemonic (car default-process-coding-system))
+     (coding-system-eoltype-mnemonic (car default-process-coding-system))
+     (coding-system-mnemonic (cdr default-process-coding-system))
+     (coding-system-eoltype-mnemonic (cdr default-process-coding-system))
+     )))
+
+;; Print symbol name and mnemonics of CODING-SYSTEM by `princ'.
+(defsubst print-coding-system-briefly (coding-system)
+  (print-list ":"
+              coding-system
+              (format "[%c%c]"
+                      (coding-system-mnemonic coding-system)
+                      (coding-system-eoltype-mnemonic coding-system))))
+
+;;;###autoload
+(defun describe-current-coding-system ()
+  "Display coding systems currently used in a detailed format."
+  (interactive)
+  (with-output-to-temp-buffer "*Help*"
+    (let* ((proc (get-buffer-process (current-buffer)))
+           (process-coding-systems (if proc (process-coding-system proc))))
+      (princ "Current:\n  buffer-file-coding-system")
+      (print-coding-system-briefly buffer-file-coding-system)
+      (princ "  keyboard-coding-system")
+      (print-coding-system-briefly (keyboard-coding-system))
+      (princ "  terminal-coding-system")
+      (print-coding-system-briefly (terminal-coding-system))
+      (if process-coding-systems
+          (progn (princ "  process-coding-system (read)")
+                 (print-coding-system-briefly (car process-coding-systems))
+                 (princ "  process-coding-system (write)")
+                 (print-coding-system-briefly (cdr process-coding-systems))))
+      (princ "Default:\n  buffer-file-coding-system")
+      (print-coding-system-briefly (default-value 'buffer-file-coding-system))
+      (princ "  process-coding-system (read)")
+      (print-coding-system-briefly (car default-process-coding-system))
+      (princ "  process-coding-system (write)")
+      (print-coding-system-briefly (cdr default-process-coding-system))
+      (princ "coding-system-alist:\n")
+      (pp coding-system-alist))
+    (let ((l coding-category-list))
+      (princ "\nCoding categories (in the order of priority):\n")
+      (while l
+        (princ (format "%s -> %s\n" (car l) (symbol-value (car l))))
+        (setq l (cdr l))))))
+
+;; Print detailed information on CODING-SYSTEM.
+(defun print-coding-system (coding-system)
+  (let ((type (coding-system-type coding-system))
+        (eol-type (coding-system-eoltype coding-system))
+        (flags (coding-system-flags coding-system)))
+    (princ (format "%s:%s:%c:%d:"
+                   coding-system
+                   type
+                   (coding-system-mnemonic coding-system)
+                   (if (integerp eol-type) eol-type 3)))
+    (cond ((eq type 2)                  ; ISO-2022
+           (let ((idx 0)
+                 charset)
+             (while (< idx 4)
+               (setq charset (aref flags idx))
+               (cond ((null charset)
+                      (princ -1))
+                     ((eq charset t)
+                      (princ -2))
+                     ((charsetp charset)
+                      (princ charset))
+                     ((listp charset)
+                      (princ "(")
+                      (princ (car charset))
+                      (setq charset (cdr charset))
+                      (while charset
+                        (princ ",")
+                        (princ (car charset))
+                        (setq charset (cdr charset)))
+                      (princ ")")))
+               (princ ",")
+               (setq idx (1+ idx)))
+             (while (< idx 12)
+               (princ (if (aref flags idx) 1 0))
+               (princ ",")
+               (setq idx (1+ idx)))
+             (princ (if (aref flags idx) 1 0))))
+          ((eq type 4)                  ; CCL
+           (let (i len)
+             (setq i 0 len (length (car flags)))
+             (while (< i len)
+               (princ (format " %x" (aref (car flags) i)))
+               (setq i (1+ i)))
+             (princ ",")
+             (setq i 0 len (length (cdr flags)))
+             (while (< i len)
+               (princ (format " %x" (aref (cdr flags) i)))
+               (setq i (1+ i)))))
+          (t (princ 0)))
+    (princ ":")
+    (princ (coding-system-docstring coding-system))
+    (princ "\n")))
+
+(defun list-coding-systems ()
+  "Print information on all coding systems in a machine readable format."
+  (with-output-to-temp-buffer "*Help*"
+    (princ "\
+#########################
+## LIST OF CODING SYSTEMS
+## Each line corresponds to one coding system
+## Format of a line is:
+##   NAME:TYPE:MNEMONIC:EOL:FLAGS:DOCSTRING,
+## where
+##  TYPE = nil (no conversion), t (auto conversion),
+##         0 (Mule internal), 1 (SJIS), 2 (ISO2022), 3 (BIG5), or 4 (CCL)
+##  EOL = 0 (LF), 1 (CRLF), 2 (CR), or 3 (Automatic detection)
+##  FLAGS =
+##    if TYPE = 2 then
+##      comma (`,') separated data of the followings:
+##        G0, G1, G2, G3, SHORT-FORM, ASCII-EOL, ASCII-CNTL, SEVEN,
+##        LOCKING-SHIFT, SINGLE-SHIFT, USE-ROMAN, USE-OLDJIS, NO-ISO6429
+##    else if TYPE = 4 then
+##      comma (`,') separated CCL programs for read and write
+##    else
+##      0
+##
+")
+    (let ((codings (make-vector 7 nil)))
+      (mapatoms
+       (function
+        (lambda (arg)
+          (if (and arg
+                   (coding-system-p arg)
+                   (null (get arg 'pre-write-conversion))
+                   (null (get arg 'post-read-conversion)))
+              (let* ((type (coding-system-type arg))
+                     (idx (if (null type) 0 (if (eq type t) 1 (+ type 2)))))
+                (if (or (= idx 0)
+                        (vectorp (coding-system-eoltype arg)))
+                    (aset codings idx (cons arg (aref codings idx)))))))))
+      (let ((idx 0) elt)
+        (while (< idx 7)
+          (setq elt (aref codings idx))
+          (while elt
+            (print-coding-system (car elt))
+            (setq elt (cdr elt)))
+          (setq idx (1+ idx)))))
+    (princ "\
+############################
+## LIST OF CODING CATEGORIES (ordered by priority)
+## CATEGORY:CODING-SYSTEM
+##
+")
+    (let ((l coding-category-list))
+      (while l
+        (princ (format "%s:%s\n" (car l) (symbol-value (car l))))
+        (setq l (cdr l))))
+    ))
+
+;;; FONT
+
+;; Print information of a font in FONTINFO.
+(defun describe-font-internal (font-info &optional verbose)
+  (print-list "name (opened by):" (aref font-info 0))
+  (print-list "       full name:" (aref font-info 1))
+  (let ((charset (aref font-info 2)))
+    (print-list "   charset:"
+                (format "%s (%s)" charset (charset-description charset))))
+  (print-list "            size:" (format "%d" (aref font-info 3)))
+  (print-list "          height:" (format "%d" (aref font-info 4)))
+  (print-list " baseline-offset:" (format "%d" (aref font-info 5)))
+  (print-list "relative-compose:" (format "%d" (aref font-info 6))))
+
+;;;###autoload
+(defun describe-font (fontname)
+  "Display information about fonts which partially match FONTNAME."
+  (interactive "sFontname: ")
+  (or window-system
+      (error "No window system being used"))
+  (let ((font-info (font-info fontname)))
+    (if (null font-info)
+        (message "No matching font")
+      (with-output-to-temp-buffer "*Help*"
+        (describe-font-internal font-info 'verbose)))))
+
+;; Print information in FONTINFO of a fontset named FONTSET.
+(defun describe-fontset-internal (fontset fontset-info)
+  (print-list "Fontset:" fontset)
+  (let ((size (aref fontset-info 0)))
+    (print-list "  size:" (format "%d" size)
+                (if (= size 0) "... which means not yet used" "")))
+  (print-list "  height:" (format "%d" (aref fontset-info 1)))
+  (print-list "  fonts: (charset : font name)")
+  (let* ((fonts (aref fontset-info 2))
+         elt charset requested opened)
+    (while fonts
+      (setq elt (car fonts)
+            charset (car elt)
+            requested (nth 1 elt)
+            opened (nth 2 elt))
+      (print-list "   " charset ":" requested)
+      (if (stringp opened)
+          (print-list "      Opened as: " opened)
+        (if (null opened) "      -- open failed --"))
+      (setq fonts (cdr fonts)))))
+
+;;;###autoload
+(defun describe-fontset (fontset)
+  "Display information about FONTSET."
+  (interactive
+   (if (not window-system)
+       (error "No window system being used")
+     (let ((fontset-list (mapcar '(lambda (x) (list x)) (fontset-list))))
+       (list (completing-read "Fontset: " fontset-list)))))
+  (setq fontset (query-fontset fontset))
+  (if (null fontset)
+      (error "No matching fontset")
+    (let ((fontset-info (fontset-info fontset)))
+      (with-output-to-temp-buffer "*Help*"
+        (describe-fontset-internal fontset fontset-info)))))
+
+
+;;; DIAGNOSIS
+
+(defun insert-list (args)
+  (while (cdr args)
+    (insert (or (car args) "nil") " ")
+    (setq args (cdr args)))
+  (if args (insert (or (car args) "nil")))
+  (insert "\n"))
+
+(defun insert-section (sec title)
+  (insert "########################################\n"
+          "# Section " (format "%d" sec) ".  " title "\n"
+          "########################################\n\n"))
+
+;;;###autoload
+(defun mule-diag ()
+  "Show diagnosis of the running Mule."
+  (interactive)
+  (let ((buf (get-buffer-create "*Diagnosis*")))
+    (save-excursion
+      (set-buffer buf)
+      (erase-buffer)
+      (insert "\t###############################\n"
+              "\t### Diagnosis of your Emacs ###\n"
+              "\t###############################\n\n"
+              "CONTENTS: Section 1.  General Information\n"
+              "          Section 2.  Display\n"
+              "          Section 3.  Input methods\n"
+              "          Section 4.  Coding systems\n"
+              "          Section 5.  Charsets\n")
+      (if window-system
+          (insert "          Section 6.  Fontset list\n"))
+      (insert "\n")
+
+      (insert-section 1 "General Information")
+      (insert "Version of this emacs:\n  " (emacs-version) "\n"
+              "Primary language:\n  " primary-language "\n\n")
+
+      (insert-section 2 "Display")
+      (if window-system
+          (insert "Window-system: "
+                  (symbol-name window-system)
+                  (format "%s" window-system-version))
+        (insert "Terminal: " (getenv "TERM")))
+      (insert "\n\n")
+
+      (if (eq window-system 'x)
+          (let ((font (cdr (assq 'font (frame-parameters)))))
+            (insert "The selected frame is using the "
+                    (if (query-fontset font) "fontset" "font")
+                    ":\n\t" font))
+        (insert "Coding system of the terminal: "
+                (symbol-name (terminal-coding-system))))
+      (insert "\n\n")
+
+      (insert-section 3 "Input methods")
+      (insert "language\tinput-method\n"
+              "--------\t------------\n")
+      (let ((alist language-info-alist))
+        (while alist
+          (insert (car (car alist)))
+          (indent-to 16)
+          (let ((methods (get-language-info (car (car alist)) 'input-method)))
+            (if methods
+                (insert-list (mapcar 'car methods))
+              (insert "none\n")))
+          (setq alist (cdr alist))))
+      (insert "\n")
+      (if default-input-method
+          (insert "The input method used last time is: "
+                  (cdr default-input-method)
+                  "\n"
+                  "        for inputting the language: "
+                  (car default-input-method)
+                  "\n")
+        (insert "No input method has ever been selected.\n"))
+      
+      (insert "\n")
+
+      (insert-section 4 "Coding systems")
+      (save-excursion (list-coding-systems))
+      (insert-buffer "*Help*")
+      (goto-char (point-max))
+      (insert "\n")
+
+      (insert-section 5 "Charsets")
+      (save-excursion (list-character-sets))
+      (insert-buffer "*Help*")
+      (goto-char (point-max))
+      (insert "\n")
+
+      (if window-system
+          (let ((fontsets (fontset-list)))
+            (insert-section 6 "Fontset list")
+            (while fontsets
+              (describe-fontset (car fontsets))
+              (insert-buffer "*Help*")
+              (setq fontsets (cdr fontsets)))))
+
+      (set-buffer-modified-p nil)
+      )
+    (let ((win (display-buffer buf)))
+      (set-window-point win 1)
+      (set-window-start win 1))
+    ))
+
+
+;;; DUMP DATA FILE
+
+;;;###autoload
+(defun dump-charsets ()
+  "Dump information of all charsets into the file \"charsets.dat\"."
+  (list-character-sets)
+  (set-buffer (get-buffer "*Help*"))
+  (let (make-backup-files)
+    (write-region (point-min) (point-max) "charsets.dat"))
+  (kill-emacs))
+
+;;;###autoload
+(defun dump-codings ()
+  "Dump information of all coding systems into the file \"codings.dat\"."
+  (list-coding-systems)
+  (set-buffer (get-buffer "*Help*"))
+  (let (make-backup-files)
+    (write-region (point-min) (point-max) "codings.dat"))
+  (kill-emacs))
+
diff --git a/lisp/international/mule-util.el b/lisp/international/mule-util.el
new file mode 100644
index 00000000000..27c64aa3a2b
--- /dev/null
+++ b/lisp/international/mule-util.el
@@ -0,0 +1,419 @@
+;;; mule-util.el --- Utility functions for mulitilingual environment (mule)
+
+;; Copyright (C) 1995 Free Software Foundation, Inc.
+;; Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+;; Keywords: mule, multilingual
+
+;; 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.
+
+;;; Code:
+
+;;; String manipulations while paying attention to multibyte
+;;; characters.
+
+;;;###autoload
+(defun string-to-sequence (string type)
+  "Convert STRING to a sequence of TYPE which contains characters in STRING.
+TYPE should be `list' or `vector'.
+Multibyte characters are conserned."
+  (or (eq type 'list) (eq type 'vector)
+      (error "Invalid type: %s" type))
+  (let* ((len (length string))
+         (i 0)
+         l ch)
+    (while (< i len)
+      (setq ch (sref string i))
+      (setq l (cons ch l))
+      (setq i (+ i (char-bytes ch))))
+    (setq l (nreverse l))
+    (if (eq type 'list)
+        l
+      (vconcat l))))
+
+;;;###autoload
+(defsubst string-to-list (string)
+  "Return a list of characters in STRING."
+  (string-to-sequence string 'list))
+
+;;;###autoload
+(defsubst string-to-vector (string)
+  "Return a vector of characters in STRING."
+  (string-to-sequence string 'vector))
+
+;;;###autoload
+(defun store-substring (string idx obj)
+  "Embed OBJ (string or character) at index IDX of STRING."
+  (let* ((str (cond ((stringp obj) obj)
+                    ((integerp obj) (char-to-string obj))
+                    (t (error
+                        "Invalid argument (should be string or character): %s"
+                        obj))))
+         (string-len (length string))
+         (len (length str))
+         (i 0))
+    (while (and (< i len) (< idx string-len))
+      (aset string idx (aref str i))
+      (setq idx (1+ idx) i (1+ i)))
+    string))
+
+;;;###autoload
+(defun truncate-string-to-width (str width &optional start-column padding)
+  "Truncate string STR to fit in WIDTH columns.
+Optional 1st arg START-COLUMN if non-nil specifies the starting column.
+Optional 2nd arg PADDING if non-nil, space characters are padded at
+the head and tail of the resulting string to fit in WIDTH if necessary.
+If PADDING is nil, the resulting string may be narrower than WIDTH."
+  (or start-column
+      (setq start-column 0))
+  (let ((len (length str))
+        (idx 0)
+        (column 0)
+        (head-padding "") (tail-padding "")
+        ch last-column last-idx from-idx)
+    (condition-case nil
+        (while (< column start-column)
+          (setq ch (sref str idx)
+                column (+ column (char-width ch))
+                idx (+ idx (char-bytes ch))))
+      (args-out-of-range (setq idx len)))
+    (if (< column start-column)
+        (if padding (make-string width ?\ ) "")
+      (if (and padding (> column start-column))
+          (setq head-padding (make-string (- column start-column) ?\ )))
+      (setq from-idx idx)
+      (condition-case nil
+          (while (< column width)
+            (setq last-column column
+                  last-idx idx
+                  ch (sref str idx)
+                  column (+ column (char-width ch))
+                  idx (+ idx (char-bytes ch))))
+        (args-out-of-range (setq idx len)))
+      (if (> column width)
+          (setq column last-column idx last-idx))
+      (if (and padding (< column width))
+          (setq tail-padding (make-string (- width column) ?\ )))
+      (setq str (substring str from-idx idx))
+      (if padding
+          (concat head-padding str tail-padding)
+        str))))
+
+;;; For backward compatiblity ...
+;;;###autoload
+(defalias 'truncate-string 'truncate-string-to-width)
+(make-obsolete 'truncate-string 'truncate-string-to-width)
+
+;;; Nested alist handler.  Nested alist is alist whose elements are
+;;; also nested alist.
+
+;;;###autoload
+(defsubst nested-alist-p (obj)
+  "Return t if OBJ is a nesetd alist.
+
+Nested alist is a list of the form (ENTRY . BRANCHES), where ENTRY is
+any Lisp object, and BRANCHES is a list of cons cells of the form
+(KEY-ELEMENT . NESTED-ALIST).
+
+You can use a nested alist to store any Lisp object (ENTRY) for a key
+sequence KEYSEQ, where KEYSEQ is a sequence of KEY-ELEMENT.  KEYSEQ
+can be a string, a vector, or a list."
+  (and obj (listp obj) (listp (cdr obj))))
+
+;;;###autoload
+(defun set-nested-alist (keyseq entry alist &optional len branches)
+  "Set ENTRY for KEYSEQ in a nested alist ALIST.
+Optional 4th arg LEN non-nil means the firlst LEN elements in KEYSEQ
+ is considered.
+Optional argument BRANCHES if non-nil is branches for a keyseq
+longer than KEYSEQ.
+See the documentation of `nested-alist-p' for more detail."
+  (or (nested-alist-p alist)
+      (error "Invalid arguement %s" alist))
+  (let ((islist (listp keyseq))
+        (len (or len (length keyseq)))
+        (i 0)
+        key-elt slot)
+    (while (< i len)
+      (if (null (nested-alist-p alist))
+          (error "Keyseq %s is too long for this nested alist" keyseq))
+      (setq key-elt (if islist (nth i keyseq) (aref keyseq i)))
+      (setq slot (assoc key-elt (cdr alist)))
+      (if (null slot)
+          (progn
+            (setq slot (cons key-elt (list t)))
+            (setcdr alist (cons slot (cdr alist)))))
+      (setq alist (cdr slot))
+      (setq i (1+ i)))
+    (setcar alist entry)
+    (if branches
+        (if (cdr alist)
+            (error "Can't set branches for keyseq %s" keyseq)
+          (setcdr alist branches)))))
+
+;;;###autoload
+(defun lookup-nested-alist (keyseq alist &optional len start nil-for-too-long)
+  "Look up key sequence KEYSEQ in nested alist ALIST.  Return the definition.
+Optional 1st argument LEN specifies the length of KEYSEQ.
+Optional 2nd argument START specifies index of the starting key.
+The returned value is normally a nested alist of which
+car part is the entry for KEYSEQ.
+If ALIST is not deep enough for KEYSEQ, return number which is
+ how many key elements at the front of KEYSEQ it takes
+ to reach a leaf in ALIST.
+Optional 3rd argument NIL-FOR-TOO-LONG non-nil means return nil
+ even if ALIST is not deep enough."
+  (or (nested-alist-p alist)
+      (error "invalid arguement %s" alist))
+  (or len
+      (setq len (length keyseq)))
+  (let ((i (or start 0)))
+    (if (catch 'lookup-nested-alist-tag
+          (if (listp keyseq)
+              (while (< i len)
+                (if (setq alist (cdr (assoc (nth i keyseq) (cdr alist))))
+                    (setq i (1+ i))
+                  (throw 'lookup-nested-alist-tag t))))
+          (while (< i len)
+            (if (setq alist (cdr (assoc (aref keyseq i) (cdr alist))))
+                (setq i (1+ i))
+              (throw 'lookup-nested-alist-tag t))))
+        ;; KEYSEQ is too long.
+        (if nil-for-too-long nil i)
+      alist)))
+
+;; Coding system related functions.
+
+;;;###autoload
+(defun set-coding-system-alist (target-type regexp coding-system
+                                            &optional operation)
+  "Update `coding-system-alist' according to the arguments.
+TARGET-TYPE specifies a type of the target: `file', `process', or `network'.
+  TARGET-TYPE tells which slots of coding-system-alist should be affected.
+  If `file', it affects slots for insert-file-contents and write-region.
+  If `process', it affects slots for call-process, call-process-region, and
+    start-process.
+  If `network', it affects a slot for open-network-process.
+REGEXP is a regular expression matching a target of I/O operation.
+CODING-SYSTEM is a coding system to perform code conversion
+  on the I/O operation, or a cons of coding systems for decoding and
+  encoding respectively, or a function symbol which returns the cons.
+Optional arg OPERATION if non-nil specifies directly one of slots above.
+  The valid value is: insert-file-contents, write-region,
+  call-process, call-process-region, start-process, or open-network-stream.
+If OPERATION is specified, TARGET-TYPE is ignored.
+See the documentation of `coding-system-alist' for more detail."
+  (or (stringp regexp)
+      (error "Invalid regular expression: %s" regexp))
+  (or (memq target-type '(file process network))
+      (error "Invalid target type: %s" target-type))
+  (if (symbolp coding-system)
+      (if (not (fboundp coding-system))
+          (progn
+            (check-coding-system coding-system)
+            (setq coding-system (cons coding-system coding-system))))
+    (check-coding-system (car coding-system))
+    (check-coding-system (cdr coding-system)))
+  (let ((op-list (if operation (list operation)
+                   (cond ((eq target-type 'file)
+                          '(insert-file-contents write-region))
+                         ((eq target-type 'process)
+                          '(call-process call-process-region start-process))
+                         (t             ; i.e. (eq target-type network)
+                          '(open-network-stream)))))
+        slot)
+    (while op-list
+      (setq slot (assq (car op-list) coding-system-alist))
+      (if slot
+          (let ((chain (cdr slot)))
+            (if (catch 'tag
+                  (while chain
+                    (if (string= regexp (car (car chain)))
+                        (progn
+                          (setcdr (car chain) coding-system)
+                          (throw 'tag nil)))
+                    (setq chain (cdr chain)))
+                  t)
+              (setcdr slot (cons (cons regexp coding-system) (cdr slot)))))
+        (setq coding-system-alist
+              (cons (cons (car op-list) (list (cons regexp coding-system)))
+                    coding-system-alist)))
+      (setq op-list (cdr op-list)))))
+
+;;;###autoload
+(defun coding-system-list ()
+  "Return a list of all existing coding systems."
+  (let (l)
+    (mapatoms (lambda (x) (if (get x 'coding-system) (setq l (cons x l)))))
+    l))
+
+
+;;; Composite charcater manipulations.
+
+;;;###autoload
+(defun compose-region (start end)
+  "Compose all characters in the current region into one composite character.
+When called from a program, expects two arguments,
+positions (integers or markers) specifying the region."
+  (interactive "r")
+  (save-excursion
+    (let ((str (buffer-substring start end)))
+      (goto-char start)
+      (delete-region start end)
+      (insert (compose-string str)))))
+
+;;;###autoload
+(defun decompose-region (start end)
+  "Decompose all composite characters in the current region.
+Composite characters are broken up into individual components.
+When called from a program, expects two arguments,
+positions (integers or markers) specifying the region."
+  (interactive "r")
+  (save-restriction
+    (narrow-to-region start end)
+    (goto-char (point-min))
+    (let ((enable-multibyte-characters nil)
+          ;; This matches the whole bytes of single composite character.
+          (re-cmpchar "\200[\240-\377]+")
+          p ch str)
+      (while (re-search-forward re-cmpchar nil t)
+        (setq str (buffer-substring (match-beginning 0) (match-end 0)))
+        (delete-region (match-beginning 0) (match-end 0))
+        (insert (decompose-composite-char (string-to-char str)))))))
+
+;;;###autoload
+(defconst reference-point-alist
+  '((tl . 0) (tc . 1) (tr . 2)
+    (ml . 3) (mc . 4) (mr . 5)
+    (bl . 6) (bc . 7) (br . 8)
+    (top-left . 0) (top-center . 1) (top-right . 2)
+    (mid-left . 3) (mid-center . 4) (mid-right . 5)
+    (bottom-left . 6) (bottom-center . 7) (bottom-right . 8)
+    (0 . 0) (1 . 1) (2 . 2)
+    (3 . 3) (4 . 4) (5 . 5)
+    (6 . 6) (7 . 7) (8 . 8))
+  "Alist of reference point symbols vs reference point codes.
+Meanings of reference point codes are as follows:
+
+    0----1----2 <-- ascent      0:tl or top-left
+    |         |                 1:tc or top-center
+    |         |                 2:tr or top-right
+    |         |                 3:ml or mid-left
+    |    4 <--+---- center      4:mc or mid-center
+    |         |                 5:mr or mid-right
+--- 3         5 <-- baseline    6:bl or bottom-left
+    |         |                 7:bc or bottom-center
+    6----7----8 <-- descent     8:br or bottom-right
+
+Reference point symbols are to be used to specify composition rule of
+the form \(GLOBAL-REF-POINT . NEW-REF-POINT), where GLOBAL-REF-POINT
+is a reference point in the overall glyphs already composed, and
+NEW-REF-POINT is a reference point in the new glyph to be added.
+
+For instance, if GLOBAL-REF-POINT is 8 and NEW-REF-POINT is 1, the
+overall glyph is updated as follows:
+
+    +-------+--+ <--- new ascent
+    |       |  |
+    | global|  |
+    | glyph |  |
+--- |       |  | <--- baseline (doesn't change)
+    +----+--+--+
+    |    | new |
+    |    |glyph|
+    +----+-----+ <--- new descent
+")
+
+;; Return a string for char CH to be embedded in multibyte form of
+;; composite character.
+(defun compose-chars-component (ch)
+  (if (< ch 128)
+      (format "\240%c" (+ ch 128))
+    (let ((str (char-to-string ch)))
+      (if (cmpcharp ch)
+          (if (/= (aref str 1) ?\xFF)
+              (error "Char %c can't be composed" ch)
+            (substring str 2))
+        (aset str 0 (+ (aref str 0) ?\x20))
+        str))))
+
+;; Return a string for composition rule RULE to be embedded in
+;; multibyte form of composite character.
+(defsubst compose-chars-rule (rule)
+  (char-to-string (+ ?\xA0
+                     (* (cdr (assq (car rule) reference-point-alist)) 9)
+                     (cdr (assq (cdr rule) reference-point-alist)))))
+
+;;;###autoload
+(defun compose-chars (first-component &rest args)
+  "Return one char string composed from the arguments.
+Each argument is a character (including a composite chararacter)
+or a composition rule.
+A composition rule has the form \(GLOBAL-REF-POINT . NEW-REF-POINT).
+See the documentation of `reference-point-alist' for more detail."
+  (if (= (length args) 0)
+      (char-to-string first-component)
+    (let* ((with-rule (consp (car args)))
+           (str (if with-rule (concat (vector leading-code-composition ?\xFF))
+                  (char-to-string leading-code-composition))))
+      (setq str (concat str (compose-chars-component first-component)))
+      (while args
+        (if with-rule
+            (progn
+              (if (not (consp (car args)))
+                  (error "Invalid composition rule: %s" (car args)))
+              (setq str (concat str (compose-chars-rule (car args))
+                                (compose-chars-component (car (cdr args))))
+                    args (cdr (cdr args))))
+          (setq str (concat str (compose-chars-component (car args)))
+                args (cdr args))))
+      str)))
+
+;;;###autoload
+(defun decompose-composite-char (char &optional type with-composition-rule)
+  "Convert composite character CHAR to a string containing components of CHAR.
+Optional 1st arg TYPE specifies the type of sequence returned.
+It should be `string' (default), `list', or `vector'.
+Optional 2nd arg WITH-COMPOSITION-RULE non-nil means the returned
+sequence contains embedded composition rules if any.  In this case, the
+order of elements in the sequence is the same as arguments for
+`compose-chars' to create CHAR.
+If TYPE is omitted or is `string', composition rules are omitted
+even if WITH-COMPOSITION-RULE is t."
+  (or type
+      (setq type 'string))
+  (let* ((len (composite-char-component-count char))
+         (i (1- len))
+         l)
+    (setq with-composition-rule (and with-composition-rule
+                                    (not (eq type 'string))
+                                    (composite-char-composition-rule-p char)))
+    (while (> i 0)
+      (setq l (cons (composite-char-component char i) l))
+      (if  with-composition-rule
+          (let ((rule (- (composite-char-composition-rule char i) ?\xA0)))
+            (setq l (cons (cons (/ rule 9) (% rule 9)) l))))
+      (setq i (1- i)))
+    (setq l (cons (composite-char-component char 0) l))
+    (cond ((eq type 'string)
+           (apply 'concat-chars l))
+          ((eq type 'list)
+           l)
+          (t                            ; i.e. TYPE is vector
+           (vconcat l)))))
+
+;;; mule-util.el ends here
diff --git a/lisp/international/mule.el b/lisp/international/mule.el
new file mode 100644
index 00000000000..82c2679455a
--- /dev/null
+++ b/lisp/international/mule.el
@@ -0,0 +1,529 @@
+;;; mule.el --- basic commands for mulitilingual environment
+
+;; Copyright (C) 1995 Free Software Foundation, Inc.
+;; Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+;; Keywords: mule, multilingual, character set, coding system
+
+;; 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.
+
+;;; Code:
+
+(defconst mule-version "3.0 (MOMIJINOGA)" "\
+Version number and name of this version of MULE (multilingual environment).")
+
+(defconst mule-version-date "1998.1.1" "\
+Distribution date of this version of MULE (multilingual environment).")
+
+(defun load-with-code-conversion (fullname file &optional noerror nomessage)
+  "Execute a file of Lisp code named FILE whose absolute path is FULLNAME.
+The FILE is decoded before evaluation if necessary.
+If optional second arg NOERROR is non-nil,
+ report no error if FILE doesn't exist.
+Print messages at start and end of loading unless
+ optional third arg NOMESSAGE is non-nil.
+Return t if file exists."
+  (if (null (file-readable-p fullname))
+      (and (null noerror)
+           (signal 'file-error (list "Cannot open load file" file)))
+    ;; Read file with code conversion, and then eval.
+    (let* ((buffer
+            ;; To avoid any autoloading, set default-major-mode to
+            ;; fundamental-mode.
+            (let ((default-major-mode 'fundamental-mode))
+              ;; We can't use `generate-new-buffer' because files.el
+              ;; is not yet loaded.
+              (get-buffer-create (generate-new-buffer-name " *load*"))))
+           (load-in-progress t))
+      (or nomessage (message "Loading %s..." file))
+      (unwind-protect
+          (progn
+            (save-excursion
+              (set-buffer buffer)
+              (insert-file-contents fullname)
+              ;; We must set `buffer-file-name' for `eval-buffer' and
+              ;; `load-history'.
+              (setq buffer-file-name file)
+              ;; Make `kill-buffer' quiet.
+              (set-buffer-modified-p nil))
+            ;; Eval in the original buffer.
+            (eval-buffer buffer))
+        (kill-buffer buffer))
+      (let ((hook (assoc file after-load-alist)))
+              (if hook
+                  (mapcar (function eval) (cdr hook))))
+      (or nomessage noninteractive
+          (message "Loading %s...done" file))
+      t)))
+
+;; API (Application Program Interface) for charsets.
+
+;; Return t if OBJ is a quoted symbol.
+(defsubst quoted-symbol-p (obj)
+  (and (listp obj) (eq (car obj) 'quote)))
+
+(defsubst charsetp (object)
+  "T is OBJECT is a charset."
+  (and (symbolp object) (vectorp (get object 'charset))))
+
+(defsubst charset-info (charset)
+  "Return a vector of information of CHARSET.
+The elements of the vector are:
+        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,
+where
+CHARSET-ID (integer) is the identification number of the charset.
+DIMENSION (integer) is the number of bytes to represent a character of
+the charset: 1 or 2.
+CHARS (integer) is the number of characters in a dimension: 94 or 96.
+BYTE (integer) is the length of multi-byte form of a character in
+  the charset: one of 1, 2, 3, and 4.
+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."
+  (get charset 'charset))
+
+(defmacro charset-id (charset)
+  "Return charset identification number of CHARSET."
+  (if (and (listp charset) (eq (car charset) 'quote))
+      (aref (charset-info (nth 1 charset)) 0)
+    `(aref (charset-info ,charset) 0)))
+
+(defmacro charset-bytes (charset)
+  (if (quoted-symbol-p charset)
+      (aref (charset-info (nth 1 charset)) 1)
+    `(aref (charset-info ,charset) 1)))
+
+(defmacro charset-dimension (charset)
+  (if (quoted-symbol-p charset)
+      (aref (charset-info (nth 1 charset)) 2)
+    `(aref (charset-info ,charset) 2)))
+
+(defmacro charset-chars (charset)
+  (if (quoted-symbol-p charset)
+      (aref (charset-info (nth 1 charset)) 3)
+    `(aref (charset-info ,charset) 3)))
+
+(defmacro charset-width (charset)
+  (if (quoted-symbol-p charset)
+      (aref (charset-info (nth 1 charset)) 4)
+    `(aref (charset-info ,charset) 4)))
+
+(defmacro charset-direction (charset)
+  (if (quoted-symbol-p charset)
+      (aref (charset-info (nth 1 charset)) 5)
+    `(aref (charset-info ,charset) 5)))
+
+(defmacro charset-iso-final-char (charset)
+  (if (quoted-symbol-p charset)
+      (aref (charset-info (nth 1 charset)) 8)
+    `(aref (charset-info ,charset) 8)))
+
+(defmacro charset-iso-graphic-plane (charset)
+  (if (quoted-symbol-p charset)
+      (aref (charset-info (nth 1 charset)) 9)
+    `(aref (charset-info ,charset) 9)))
+
+(defmacro charset-reverse-charset (charset)
+  (if (quoted-symbol-p charset)
+      (aref (charset-info (nth 1 charset)) 10)
+    `(aref (charset-info ,charset) 10)))
+
+(defmacro charset-short-name (charset)
+  (if (quoted-symbol-p charset)
+      (aref (charset-info (nth 1 charset)) 11)
+    `(aref (charset-info ,charset) 11)))
+
+(defmacro charset-long-name (charset)
+  (if (quoted-symbol-p charset)
+      (aref (charset-info (nth 1 charset)) 12)
+    `(aref (charset-info ,charset) 12)))
+
+(defmacro charset-description (charset)
+  (if (quoted-symbol-p charset)
+      (aref (charset-info (nth 1 charset)) 13)
+    `(aref (charset-info ,charset) 13)))
+
+(defmacro charset-plist (charset)
+  (if (quoted-symbol-p charset)
+      (aref (charset-info (nth 1 charset)) 14)
+    `(aref (charset-info ,charset) 14)))
+
+(defun set-charset-plist (charset plist)
+  (aset (charset-info  charset) 14 plist))
+
+(defmacro make-char (charset &optional c1 c2)
+  (if (quoted-symbol-p charset)
+      `(make-char-internal ,(charset-id (nth 1 charset)) ,c1 ,c2)
+    `(make-char-internal (charset-id ,charset) ,c1 ,c2)))
+
+;; Coding-system staffs
+
+;; Coding-system object is a symbol that has the property
+;; `coding-system' and `eol-type'.
+;;
+;; The value of the property `coding-system' is a coding-vector of the
+;; format: [TYPE MNEMONIC DOCSTRING NOT-USED-NOW FLAGS].
+;; See comments in src/coding.c for more detail.  The property value
+;; may be another coding-system, in which case, the coding-vector
+;; should be taken from that coding-system.
+;;
+;; The value of the property `eol-type' is integer 0..2 or a vector of
+;; length 3.  The integer value 0, 1, and 2 indicate the format of
+;; end-of-line LF, CRLF, and CR respectively.  The vector value
+;; indicates that the format of end-of-line should be detected
+;; automatically.  Nth element of the vector is the subsidiary
+;; coding-system whose `eol-type' property is integer value.
+;;
+;; Coding-system may also have properties `post-read-conversion' and
+;; `pre-write-conversion and the values are functions.
+;;
+;; The function in `post-read-conversion' is called after some text is
+;; inserted and decoded along the coding-system and before any
+;; functions in `after-insert-functions' are called.  The arguments to
+;; this function is the same as those of a function in
+;; `after-insert-functions', i.e. LENGTH of a text while putting point
+;; at the head of the text to be decoded
+;;
+;; The function in `pre-write-conversion' is called after all
+;; functions in `write-region-annotate-functions' and
+;; `buffer-file-format' are called, and before the text is encoded by
+;; the coding-system.  The arguments to this function is the same as
+;; those of a function in `write-region-annotate-functions', i.e. FROM
+;; and TO specifying region of a text.
+
+(defsubst coding-vector-type (vec) (aref vec 0))
+(defsubst coding-vector-mnemonic (vec) (aref vec 1))
+(defsubst coding-vector-docstring (vec) (aref vec 2))
+(defsubst coding-vector-flags (vec) (aref vec 4))
+
+;; Return type of CODING-SYSTEM.
+(defun coding-system-type (coding-system)
+  (let ((vec (coding-system-vector coding-system)))
+    (if vec (coding-vector-type vec))))
+
+;; Return mnemonic character of CODING-SYSTEM.
+(defun coding-system-mnemonic (coding-system)
+  (let ((vec (coding-system-vector coding-system)))
+    (if vec (coding-vector-mnemonic vec)
+      ?-)))
+
+;; Return docstring of CODING-SYSTEM.
+(defun coding-system-docstring (coding-system)
+  (let ((vec (coding-system-vector coding-system)))
+    (if vec (coding-vector-docstring vec))))
+
+;; Return flags of CODING-SYSTEM.
+(defun coding-system-flags (coding-system)
+  (let ((vec (coding-system-vector coding-system)))
+    (if vec (coding-vector-flags vec))))
+
+;; Return eol-type of CODING-SYSTEM.
+(defun coding-system-eoltype (coding-system)
+  (and coding-system
+       (or (get coding-system 'eol-type)
+           (coding-system-eoltype (get coding-system 'coding-system)))))
+
+;; Return mnemonic character of eol-type of CODING-SYSTEM.
+(defun coding-system-eoltype-mnemonic (coding-system)
+  (let ((eol-type (coding-system-eoltype coding-system)))
+    (cond ((vectorp eol-type) eol-mnemonic-undecided)
+          ((eq eol-type 0) eol-mnemonic-unix)
+          ((eq eol-type 1) eol-mnemonic-unix)
+          ((eq eol-type 2) eol-mnemonic-unix)
+          (t ?-))))
+
+;; Return function for post-read-conversion of CODING-SYSTEM.
+(defun coding-system-post-read-conversion (coding-system)
+  (and coding-system
+       (symbolp coding-system)
+       (or (get coding-system 'post-read-conversion)
+           (coding-system-post-read-conversion
+            (get coding-system 'coding-system)))))
+
+;; Return function for pre-write-conversion of CODING-SYSTEM.
+(defun coding-system-pre-write-conversion (coding-system)
+  (and coding-system
+       (symbolp coding-system)
+       (or (get coding-system 'pre-write-conversion)
+           (coding-system-pre-write-conversion
+            (get coding-system 'coding-system)))))
+
+(defun make-coding-system (coding-system type mnemonic docstring
+                                            &optional flags)
+  "Define a new CODING-SYSTEM (symbol).
+Remaining arguments are TYPE, MNEMONIC, DOCSTRING, and FLAGS (optional).
+TYPE is an integer value indicating the type of coding-system as follows:
+  0: Emacs internal format,
+  1: Shift-JIS (or MS-Kanji) used mainly on Japanese PC,
+  2: ISO-2022 including many variants,
+  3: Big5 used mainly on Chinese PC,
+  4: private, CCL programs provide encoding/decoding algorithm.
+MNEMONIC is a character to be displayed on mode line for the coding-system.
+DOCSTRING is a documentation string for the coding-system.
+FLAGS specifies more precise information of each TYPE.
+  If TYPE is 2 (ISO-2022), FLAGS should be a list of:
+      CHARSET0, CHARSET1, CHARSET2, CHARSET3, SHORT-FORM,
+      ASCII-EOL, ASCII-CNTL, SEVEN, LOCKING-SHIFT, SINGLE-SHIFT,
+      USE-ROMAN, USE-OLDJIS, NO-ISO6429.
+    CHARSETn are character sets initially designated to Gn graphic registers.
+      If CHARSETn is nil, Gn is never used.
+      If CHARSETn is t, Gn can be used but nothing designated initially.
+      If CHARSETn is a list of character sets, those character sets are
+        designated to Gn on output, but nothing designated to Gn initially.
+    SHORT-FORM non-nil means use short designation sequence on output.
+    ASCII-EOL non-nil means designate ASCII to g0 at end of line on output.
+    ASCII-CNTL non-nil means designate ASCII to g0 before control codes and
+      SPACE on output.
+    SEVEN non-nil means use 7-bit code only on output.
+    LOCKING-SHIFT non-nil means use locking-shift.
+    SINGLE-SHIFT non-nil means use single-shift.
+    USE-ROMAN non-nil means designate JIS0201-1976-Roman instead of ASCII.
+    USE-OLDJIS non-nil means designate JIS0208-1976 instead of JIS0208-1983.
+    NO-ISO6429 non-nil means not use ISO6429's direction specification.
+  If TYPE is 4 (private), FLAGS should be a cons of CCL programs,
+    for encoding and decoding.  See the documentation of CCL for more detail."
+
+  ;; At first, set a value of `coding-system' property.
+  (let ((coding-vector (make-vector 5 nil)))
+    (aset coding-vector 0 type)
+    (aset coding-vector 1
+          ;; MNEMONIC must be a printable character.
+          (if (and (> mnemonic ? ) (< mnemonic 127)) mnemonic ? ))
+    (aset coding-vector 2 (if (stringp docstring) docstring ""))
+    (aset coding-vector 3 nil)          ; obsolete element
+    (cond ((eq type 2)                  ; ISO2022
+           (let ((i 0)
+                 (vec (make-vector 32 nil)))
+             (while (< i 4)
+               (let ((charset (car flags)))
+                 (if (and charset (not (eq charset t)))
+                     (if (symbolp charset)
+                         (setq charset (charset-id charset))
+                       (let (elt l)
+                         (while charset
+                           (setq elt (car charset))
+                           (if (and elt (not (eq elt t)))
+                               (setq elt (charset-id elt)))
+                           (setq l (cons elt l))
+                           (setq charset (cdr charset)))
+                         (setq charset (nreverse l)))))
+                 (aset vec i charset))
+               (setq flags (cdr flags) i (1+ i)))
+             (while (and (< i 32) flags)
+               (aset vec i (car flags))
+               (setq flags (cdr flags) i (1+ i)))
+             (aset coding-vector 4 vec)))
+          ((eq type 4)                  ; private
+           (if (and (consp flags)
+                    (vectorp (car flags))
+                    (vectorp (cdr flags)))
+               (aset coding-vector 4 flags)
+             (error "Invalid FLAGS argument for TYPE 4 (CCL)")))
+          (t (aset coding-vector 4 flags)))
+    (put coding-system 'coding-system coding-vector))
+
+  ;; Next, set a value of `eol-type' property.  The value is a vector
+  ;; of subsidiary coding-systems, each corresponds to a coding-system
+  ;; for the detected end-of-line format.
+  (let ((codings (vector (intern (format "%s-unix" coding-system))
+                         (intern (format "%s-dos" coding-system))
+                         (intern (format "%s-mac" coding-system))))
+        (i 0))
+    (while (< i 3)
+      (put (aref codings i) 'coding-system coding-system)
+      (put (aref codings i) 'eol-type i)
+      (setq i (1+ i)))
+    (put coding-system 'eol-type codings))
+  )
+
+(defun define-coding-system-alias (symbol new-symbol)
+  "Define NEW-SYMBOL as the same coding system as SYMBOL."
+  (check-coding-system symbol)
+  (put new-symbol 'coding-system (get symbol 'coding-system))
+  (let ((eol-type (get symbol 'eol-type)))
+    (if (vectorp eol-type)
+        (let* ((name (symbol-name new-symbol))
+               (new (vector (intern (concat name "-unix"))
+                            (intern (concat name "-dos"))
+                            (intern (concat name "-mac"))))
+               (i 0))
+          (while (< i 3)
+            (define-coding-system-alias (aref eol-type i) (aref new i))
+            (setq i (1+ i)))
+          (setq eol-type new)))
+    (put new-symbol 'eol-type eol-type)))
+
+(defvar buffer-file-coding-system nil
+  "Coding-system of the file which the current-buffer is visiting.")
+(make-variable-buffer-local 'buffer-file-coding-system)
+;; This value should not be reset by changing major mode.
+(put 'buffer-file-coding-system 'permanent-local t)
+
+(defun set-buffer-file-coding-system (coding-system &optional force)
+  "Set buffer-file-coding-system of the current buffer to CODING-SYSTEM.
+If eol-type of the current buffer-file-coding-system is an integer value N, and
+ eol-type of CODING-SYSTEM is a vector, the Nth element of the vector is set 
+ instead of CODING-SYSTEM itself.
+Optional prefix argument FORCE non-nil means CODING-SYSTEM is set
+ regardless of eol-type of the current buffer-file-coding-system."
+  (interactive "zBuffer-file-coding-system: \nP")
+  (check-coding-system coding-system)
+  (if (null force)
+      (let ((x (coding-system-eoltype buffer-file-coding-system))
+            (y (coding-system-eoltype coding-system)))
+        (if (and (numberp x) (>= x 0) (<= x 2) (vectorp y))
+            (setq coding-system (aref y x)))))
+  (setq buffer-file-coding-system coding-system)
+  (set-buffer-modified-p t)
+  (force-mode-line-update))
+
+(defun set-current-process-coding-system (input output)
+  (interactive
+   "zCoding-system for process input: \nzCoding-system for process output: ")
+  (let ((proc (get-buffer-process (current-buffer))))
+    (if (null proc)
+        (error "no process")
+      (check-coding-system input)
+      (check-coding-system output)
+      (set-process-coding-system proc input output)))
+  (force-mode-line-update))
+
+(defvar default-process-coding-system (cons nil nil)
+  "Cons of default values used to read from and write to process.")
+
+(defun set-coding-priority (arg)
+  "Set priority of coding-category according to LIST.
+LIST is a list of coding-categories ordered by priority."
+  (let (l)
+    ;; Put coding-categories listed in ARG to L while checking the
+    ;; validity.  We assume that `coding-category-list' contains whole
+    ;; coding-categories.
+    (while arg
+      (if (null (memq (car arg) coding-category-list))
+          (error "Invalid element in argument: %s" (car arg)))
+      (setq l (cons (car arg) l))
+      (setq arg (cdr arg)))
+    ;; Put coding-category not listed in ARG to L.
+    (while coding-category-list
+      (if (null (memq (car coding-category-list) l))
+          (setq l (cons (car coding-category-list) l)))
+      (setq coding-category-list (cdr coding-category-list)))
+    ;; Update `coding-category-list' and return it.
+    (setq coding-category-list (nreverse l))))
+
+;;; FILE I/O
+
+;; Set buffer-file-coding-system of the current buffer after some text
+;; is inserted.
+(defun after-insert-file-set-buffer-file-coding-system (inserted)
+  (if last-coding-system-used
+      (let ((coding-system
+             (find-new-buffer-file-coding-system last-coding-system-used))
+            (modified-p (buffer-modified-p)))
+        (if coding-system
+            (set-buffer-file-coding-system coding-system))
+        (set-buffer-modified-p modified-p)))
+  nil)
+
+(setq after-insert-file-functions
+      (cons 'after-insert-file-set-buffer-file-coding-system
+            after-insert-file-functions))
+
+;; The coding-vector and eol-type of coding-system returned is decided
+;; independently in the following order.
+;;      1. That of buffer-file-coding-system locally bound.
+;;      2. That of CODING.
+
+(defun find-new-buffer-file-coding-system (coding)
+  "Return a coding system for a buffer when a file of CODING is inserted.
+The returned value is set to `buffer-file-coding-system' of the
+current buffer.  Return nil if there's no need of setting new
+buffer-file-coding-system."
+  (let (local-coding local-eol
+        found-eol
+        new-coding new-eol)
+    (if (null coding)
+        ;; Nothing found about coding.
+        nil
+
+      ;; Get information of the current local value of
+      ;; `buffer-file-coding-system' in LOCAL-EOL and LOCAL-CODING.
+      (if (local-variable-p 'buffer-file-coding-system)
+          ;; Something already set locally.
+          (progn
+            (setq local-eol (coding-system-eoltype buffer-file-coding-system))
+            (if (null (numberp local-eol))
+                ;; But eol-type is not yet set.
+                (setq local-eol nil))
+            (if (null (eq (coding-system-type buffer-file-coding-system) t))
+                ;; This is not automatic-conversion.
+                (progn
+                  (setq local-coding buffer-file-coding-system)
+                  (while (symbolp (get local-coding 'coding-system))
+                    (setq local-coding (get local-coding 'coding-system))))
+              )))
+
+      (if (and local-eol local-coding)
+          ;; The current buffer has already set full coding-system, we
+          ;; had better not change it.
+          nil
+
+        (setq found-eol (coding-system-eoltype coding))
+        (if (null (numberp found-eol))
+            ;; But eol-type is not found.
+            (setq found-eol nil))
+        (if (eq (coding-system-type coding) t)
+            ;; This is automatic-conversion, which means nothing found
+            ;; except for eol-type.
+            (setq coding nil))
+
+        ;; The local setting takes precedence over the found one.
+        (setq new-coding (or local-coding coding))
+        (setq new-eol (or local-eol found-eol))
+        (if (and (numberp new-eol)
+                 (vectorp (coding-system-eoltype new-coding)))
+            (setq new-coding
+                  (aref (coding-system-eoltype new-coding) new-eol)))
+        new-coding))))
+
+(provide 'mule)
+
+;;; mule.el ends here
diff --git a/lisp/international/quail.el b/lisp/international/quail.el
new file mode 100644
index 00000000000..e44767a7e4d
--- /dev/null
+++ b/lisp/international/quail.el
@@ -0,0 +1,1522 @@
+;;; quail.el -- provides simple input method for multilingual text
+
+;; Copyright (C) 1995 Free Software Foundation, Inc.
+;; Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+;; Author: Kenichi HANDA <handa@etl.go.jp>
+;;         Naoto TAKAHASHI <ntakahas@etl.go.jp>
+;; Maintainer: Kenichi HANDA <handa@etl.go.jp>
+;; Keywords: mule, multilingual, input method
+
+;; 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.
+
+;;; Commentary:
+
+;; In Quail minor mode, you can input multilingual text easily.  By
+;; defining a translation table (named Quail map) which maps ASCII key
+;; string to multilingual character or string, you can input any text
+;; from ASCII keyboard.
+;;
+;; We use words "translation" and "conversion" differently.  The
+;; former is done by Quail package itself, the latter is the further
+;; process of converting a translated text to some more desirable
+;; text.  For instance, Quail package for Japanese (`quail-jp')
+;; translates Roman text (transliteration of Japanese in Latin
+;; alphabets) to Hiragana text, which is then converted to
+;; Kanji-and-Kana mixed text or Katakana text by commands specified in
+;; CONVERSION-KEYS argument of the Quail package.
+
+;;; Code:
+
+(require 'faces)
+
+;; Buffer local variables
+
+(defvar quail-current-package nil
+  "The current Quail package to input multilingual text in Quail minor mode.
+See the documentation of `quail-package-alist' for the format.")
+(make-variable-buffer-local 'quail-current-package)
+(put 'quail-current-package 'permanent-local t)
+
+;; Quail uses the following two buffers to assist users.
+;; A buffer to show available key sequence or translation list.
+(defvar quail-guidance-buf nil)
+;; A buffer to show completion list of the current key sequence.
+(defvar quail-completion-buf nil)
+
+(defvar quail-mode nil
+  "Non-nil if in Quail minor mode.")
+(make-variable-buffer-local 'quail-mode)
+(put 'quail-mode 'permanent-local t)
+
+(defvar quail-overlay nil
+  "Overlay which covers the current translation region of Quail.")
+(make-variable-buffer-local 'quail-overlay)
+
+(defvar quail-conv-overlay nil
+  "Overlay which covers the text to be converted in Quail mode.")
+(make-variable-buffer-local 'quail-conv-overlay)
+
+(defvar quail-current-key nil
+  "Current key for translation in Quail mode.")
+
+(defvar quail-current-str nil
+  "Currently selected translation of the current key.")
+
+(defvar quail-current-translations nil
+  "Cons of indices and vector of possible translations of the current key.")
+
+;; A flag to control conversion region.  Normally nil, but if set to
+;; t, it means we must start the new conversion region if new key to
+;; be translated is input.
+(defvar quail-reset-conversion-region nil)
+
+;; Quail package handlers.
+
+(defvar quail-package-alist nil
+  "List of Quail packages.
+A Quail package is a list of these elements:
+  NAME, TITLE, QUAIL-MAP, GUIDANCE, DOCSTRING, TRANSLATION-KEYS,
+  FORGET-LAST-SELECTION, DETERMINISTIC, KBD-TRANSLATE, SHOW-LAYOUT,
+  DECODE-MAP, MAXIMUM-SHORTEST, OVERLAY-PLIST, UPDATE-TRANSLATION-FUNCTION,
+  CONVERSION-KEYS.
+
+QUAIL-MAP is a data structure to map key strings to translations.  For
+the format, see the documentation of `quail-map-p'.
+
+DECODE-MAP is an alist of translations and corresponding keys.
+
+See the documentation of `quail-define-package' for the other elements.")
+
+;; Return various slots in the current quail-package.
+
+(defsubst quail-name ()
+  "Return the name of the current Quail package."
+  (nth 0 quail-current-package))
+(defsubst quail-title ()
+  "Return the title of the current Quail package."
+  (nth 1 quail-current-package))
+(defsubst quail-map ()
+  "Return the translation map of the current Quail package."
+  (nth 2 quail-current-package))
+(defsubst quail-guidance ()
+  "Return an object used for `guidance' feature of the current Quail package.
+See also the documentation of `quail-define-package'."
+  (nth 3 quail-current-package))
+(defsubst quail-docstring ()
+  "Return the documentation string of the current Quail package."
+  (nth 4 quail-current-package))
+(defsubst quail-translation-keymap ()
+  "Return translation keymap in the current Quail package.
+Translation keymap is a keymap used while translation region is active."
+  (nth 5 quail-current-package))
+(defsubst quail-forget-last-selection ()
+  "Return `forget-last-selection' flag of the current Quail package.
+See also the documentation of `quail-define-package'."
+  (nth 6 quail-current-package))
+(defsubst quail-deterministic ()
+  "Return `deterministic' flag of the current Quail package.
+See also the documentation of `quail-define-package'."
+  (nth 7 quail-current-package))
+(defsubst quail-kbd-translate ()
+  "Return `kbd-translate' flag of the current Quail package.
+See also the documentation of `quail-define-package'."
+  (nth 8 quail-current-package))
+(defsubst quail-show-layout ()
+  "Return `show-layout' flag of the current Quail package.
+See also the documentation of `quail-define-package'."
+  (nth 9 quail-current-package))
+(defsubst quail-decode-map ()
+  "Return decode map of the current Quail package.
+It is an alist of translations and corresponding keys."
+  (nth 10 quail-current-package))
+(defsubst quail-maximum-shortest ()
+  "Return `maximum-shortest' flag of the current Quail package.
+See also the documentation of `quail-define-package'."
+  (nth 11 quail-current-package))
+(defsubst quail-overlay-plist ()
+  "Return property list of an overly used in the current Quail package."
+  (nth 12 quail-current-package))
+(defsubst quail-update-translation-function ()
+  "Return a function for updating translation in the current Quail package."
+  (nth 13 quail-current-package))
+(defsubst quail-conversion-keymap ()
+  "Return conversion keymap in the current Quail package.
+Conversion keymap is a keymap used while conversion region is active
+ but translation region is not active."
+  (nth 14 quail-current-package))
+
+(defsubst quail-package (name)
+  "Return Quail package named NAME."
+  (assoc name quail-package-alist))
+
+(defun quail-add-package (package)
+  "Add Quail package PACKAGE to `quail-package-alist'."
+  (let ((pac (quail-package (car package))))
+    (if pac
+        (setcdr pac (cdr package))
+      (setq quail-package-alist (cons package quail-package-alist)))))
+
+(defun quail-select-package (name)
+  "Select Quail package named NAME as the current Quail package."
+  (let ((package (quail-package name)))
+    (if (null package)
+        (error "No Quail package `%s'" name))
+    (setq quail-current-package package)
+    (setq-default quail-current-package package)
+    name))
+
+;;;###autoload
+(defun quail-use-package (package-name &rest libraries)
+  "Start using Quail package PACKAGE-NAME.
+The remaining arguments are libraries to be loaded before using the package."
+  (while libraries
+    (if (not (load (car libraries) t))
+        (progn
+          (with-output-to-temp-buffer "*Help*"
+            (princ "Quail package \"")
+            (princ package-name)
+            (princ "\" can't be activated\n  because library \"")
+            (princ (car libraries))
+            (princ "\" is not in `load-path'.
+
+The most common case is that you have not yet installed appropriate
+libraries in LEIM (Libraries of Emacs Input Method) which is
+distributed separately from Emacs.
+
+Installation of LEIM for Quail is very simple, just copy Quail
+packages (byte-compiled Emacs Lisp files) to somewhere in your
+`load-path'.
+
+LEIM is available from the same ftp directory as Emacs."))
+          (error ""))
+      (setq libraries (cdr libraries))))
+  (quail-select-package package-name)
+  (setq current-input-method-title (quail-title))
+  (quail-mode 1))
+
+(defun quail-inactivate ()
+  "Turn off Quail input method."
+  (interactive)
+  (throw 'quail-tag t))
+
+(or (assq 'quail-mode minor-mode-alist)
+    (setq minor-mode-alist
+          (cons '(quail-mode " Quail") minor-mode-alist)))
+
+(defvar quail-mode-map 
+  (let ((map (make-keymap))
+        (i ? ))
+    (while (< i 127)
+      (define-key map (char-to-string i) 'quail-start-translation)
+      (setq i (1+ i)))
+    map)
+  "Keymap for Quail mode.")
+
+(or (assq 'quail-mode minor-mode-map-alist)
+    (setq minor-mode-map-alist
+          (cons (cons 'quail-mode quail-mode-map) minor-mode-map-alist)))
+
+(defvar quail-translation-keymap
+  (let ((map (make-keymap))
+        (i 0))
+    (while (< i ?\ )
+      (define-key map (char-to-string i) 'quail-execute-non-quail-command)
+      (setq i (1+ i)))
+    (while (< i 127)
+      (define-key map (char-to-string i) 'quail-self-insert-command)
+      (setq i (1+ i)))
+    (define-key map "\177" 'quail-delete-last-char)
+    (define-key map "\C-\\" 'quail-inactivate)
+    (define-key map "\C-f" 'quail-next-translation)
+    (define-key map "\C-b" 'quail-prev-translation)
+    (define-key map "\C-n" 'quail-next-translation-block)
+    (define-key map "\C-p" 'quail-prev-translation-block)
+    (define-key map "\C-i" 'quail-completion)
+    (define-key map "\C-@" 'quail-select-current)
+    (define-key map "\C-c" 'quail-abort-translation)
+    (define-key map "\C-h" 'quail-translation-help)
+    (define-key map [tab] 'quail-completion)
+    (define-key map [delete] 'quail-delete-last-char)
+    (define-key map [backspace] 'quail-delete-last-char)
+    ;; At last, define default key binding.
+    (append map '((t . quail-execute-non-quail-command))))
+  "Keymap used processing translation in Quail mode.
+This map is activated while translation region is active.")
+
+(defvar quail-conversion-keymap
+  (let ((map (make-keymap))
+        (i 0))
+    (while (< i ?\ )
+      (define-key map (char-to-string i) 'quail-execute-non-quail-command)
+      (setq i (1+ i)))
+    (while (< i 127)
+      (define-key map (char-to-string i)
+        'quail-start-translation-in-conversion-mode)
+      (setq i (1+ i)))
+    (define-key map "\C-b" 'quail-conversion-backward-char)
+    (define-key map "\C-f" 'quail-conversion-forward-char)
+    (define-key map "\C-a" 'quail-conversion-beginning-of-region)
+    (define-key map "\C-e" 'quail-conversion-end-of-region)
+    (define-key map "\C-d" 'quail-conversion-delete-char)
+    (define-key map "\C-h" 'quail-conversion-help)
+    (define-key map "\C-\\" 'quail-inactivate)
+    (define-key map "\177" 'quail-conversion-backward-delete-char)
+    (define-key map [delete] 'quail-conversion-backward-delete-char)
+    (define-key map [backspace] 'quail-conversion-backward-delete-char)
+    ;; At last, define default key binding.
+    (append map '((t . quail-execute-non-quail-command))))
+  "Keymap used for processing conversion in Quail mode.
+This map is activated while convesion region is active but translation
+region is not active.")
+
+(defun quail-define-package (name language title
+                                  &optional guidance docstring translation-keys
+                                  forget-last-selection deterministic
+                                  kbd-translate show-layout create-decode-map
+                                  maximum-shortest overlay-plist
+                                  update-translation-function
+                                  conversion-keys)
+  "Define NAME as a new Quail package for input LANGUAGE.
+TITLE is a string to be displayed at mode-line to indicate this package.
+Optional arguments are GUIDANCE, DOCSTRING, TRANLSATION-KEYS,
+ FORGET-LAST-SELECTION, DETERMINISTIC, KBD-TRANSLATE, SHOW-LAYOUT,
+ CREATE-DECODE-MAP, MAXIMUM-SHORTEST, OVERLAY-PLIST,
+ UPDATE-TRANSLATION-FUNCTION, and CONVERSION-KEYS.
+
+GUIDANCE specifies how a guidance string is shown in echo area.
+If it is t, list of all possible translations for the current key is shown
+ with the currently selected translation being highlighted.
+If it is an alist, the element has the form (CHAR . STRING).  Each character
+ in the current key is searched in the list and the corresponding string is
+ shown.
+If it is nil, the current key is shown.
+
+DOCSTRING is the documentation string of this package.
+
+TRANSLATION-KEYS specifies additional key bindings used while translation
+region is active.  It is an alist of single key character vs. corresponding
+command to be called.
+
+FORGET-LAST-SELECTION non-nil means a selected translation is not kept
+for the future to translate the same key.  If this flag is nil, a
+translation selected for a key is remembered so that it can be the
+first candidate when the same key is entered later.
+
+DETERMINISTIC non-nil means the first candidate of translation is
+selected automatically without allowing users to select another
+translation for a key.  In this case, unselected translations are of
+no use for an interactive use of Quail but can be used by some other
+programs.  If this flag is non-nil, FORGET-LAST-SELECTION is also set
+to t.
+
+KBD-TRANSLATE non-nil means input characters are translated from a
+user's keyboard layout to the standard keyboard layout.  See the
+documentation of `quail-keyboard-layout' and
+`quail-keyboard-layout-standard' for more detail.
+
+SHOW-LAYOUT non-nil means the `quail-help' command should show
+the user's keyboard layout visually with translated characters.
+If KBD-TRANSLATE is set, it is desirable to set also this flag unless
+this package defines no translations for single character keys.
+
+CREATE-DECODE-MAP non-nil means decode map is also created.  A decode
+map is an alist of translations and corresponding original keys.
+Although this map is not used by Quail itself, it can be used by some
+other programs.  For instance, Vietnamese supporting needs this map to
+convert Vietnamese text to VIQR format which uses only ASCII
+characters to represent Vietnamese characters.
+
+MAXIMUM-SHORTEST non-nil means break key sequence to get maximum
+length of the shortest sequence.  When we don't have a translation of
+key \"..ABCD\" but have translations of \"..AB\" and \"CD..\", break
+the key at \"..AB\" and start translation of \"CD..\".  Hangul
+packages, for instance, use this facility.  If this flag is nil, we
+break the key just at \"..ABC\" and start translation of \"D..\".
+
+OVERLAY-PLIST if non-nil is a property list put on an overlay which
+covers Quail translation region.
+
+UPDATE-TRANSLATION-FUNCTION if non-nil is a function to call to update
+the current translation region accoding to a new translation data.  By
+default, a tranlated text or a user's key sequence (if no transltion
+for it) is inserted.
+
+CONVERSION-KEYS specifies additional key bindings used while
+conversion region is active.  It is an alist of single key character
+vs. corresponding command to be called."
+  (let (translation-keymap conversion-keymap)
+    (if deterministic (setq forget-last-selection t))
+    (if translation-keys
+      (progn
+        (setq translation-keymap (copy-keymap quail-translation-keymap))
+        (while translation-keys
+          (define-key translation-keymap
+            (car (car translation-keys)) (cdr (car translation-keys)))
+          (setq translation-keys (cdr translation-keys))))
+      (setq translation-keymap quail-translation-keymap))
+    (if conversion-keys
+      (progn
+        (setq conversion-keymap (copy-keymap quail-conversion-keymap))
+        (while conversion-keys
+          (define-key conversion-keymap
+            (car (car conversion-keys)) (cdr (car conversion-keys)))
+          (setq conversion-keys (cdr conversion-keys)))))
+    (quail-add-package
+     (list name title (list nil) guidance (or docstring "")
+           translation-keymap
+           forget-last-selection deterministic kbd-translate show-layout
+           (if create-decode-map (list 'decode-map) nil)
+           maximum-shortest overlay-plist update-translation-function
+           conversion-keymap)))
+  (register-input-method language (list name 'quail-use-package))
+  (quail-select-package name))
+
+;; Quail minor mode handlers.
+
+;; Setup overlays used in Quail mode.
+(defun quail-setup-overlays ()
+  (let ((pos (point)))
+    (if (overlayp quail-overlay)
+        (move-overlay quail-overlay pos pos)
+      (setq quail-overlay (make-overlay pos pos nil nil t))
+      (overlay-put quail-overlay 'face 'underline)
+      (let ((l (quail-overlay-plist)))
+        (while l
+          (overlay-put quail-overlay (car l) (car (cdr l)))
+          (setq l (cdr (cdr l))))))
+    (if (overlayp quail-conv-overlay)
+        (move-overlay quail-conv-overlay pos pos)
+      (setq quail-conv-overlay (make-overlay pos pos nil nil t))
+      (overlay-put quail-conv-overlay 'face 'underline)
+      ;;(overlay-put quail-conv-overlay 'modification-hooks
+      ;;'(quail-conv-overlay-modification-hook))
+      )))
+
+;; Delete overlays used in Quail mode.
+(defun quail-delete-overlays ()
+  (if (overlayp quail-overlay)
+      (delete-overlay quail-overlay))
+  (if (overlayp quail-conv-overlay)
+      (delete-overlay quail-conv-overlay)))
+
+;; While translating and converting, we enter the recursive edit and
+;; exit it frequently, which results in frequent and annoying change
+;; of and annoying in mode line.   To avoid it, we use a modified
+;; mode-line-format.
+(defvar quail-mode-line-format nil)
+
+;; Return a modified mode-line-format which doesn't show the recursive
+;; editing level.  But, we only pay attention to the top level
+;; elements of the current mode-line-format.
+(defun quail-generate-mode-line-format ()
+  (if (listp mode-line-format)
+      (let ((new (copy-sequence mode-line-format))
+            l elt idx)
+        (setq l new)
+        (while l
+          (setq elt (car l))
+          (if (and (stringp elt)
+                   (or (setq idx (string-match "%\\[" elt))
+                       (setq idx (string-match "%\\]" elt))))
+              (setcar l (concat (substring elt 0 idx)
+                                (substring elt (+ idx 2)))))
+          (setq l (cdr l)))
+        new)
+    mode-line-format))
+
+(defun quail-mode (&optional arg)
+  "Toggle Quail minor mode.
+With arg, turn Quail mode on if and only if arg is positive.
+Try \\[describe-bindings] in Quail mode to see the available key binding.
+The command \\[describe-input-method] describes the current Quail package."
+  (interactive "P")
+  (setq quail-mode
+        (if (null arg) (null quail-mode)
+          (> (prefix-numeric-value arg) 0)))
+  (if (null quail-mode)
+      ;; Let's turn off Quail mode.
+      (progn
+        (quail-hide-guidance-buf)
+        (quail-delete-overlays)
+        (setq describe-current-input-method-function nil)
+        (setq current-input-method nil)
+        (run-hooks 'quail-mode-exit-hook)
+        (run-hooks 'input-method-inactivate-hook))
+    ;; Let's turn on Quail mode.
+    (if (null quail-current-package)
+        ;; Quail package is not yet selected.  Select one now.
+        (let (name)
+          (if quail-package-alist
+              (setq name (car (car quail-package-alist)))
+            (setq quail-mode nil)
+            (error "No Quail package loaded"))
+          (quail-select-package name)))
+    (setq inactivate-current-input-method-function 'quail-mode)
+    (setq describe-current-input-method-function 'quail-help)
+    (setq quail-mode-line-format (quail-generate-mode-line-format))
+    (quail-delete-overlays)
+    (quail-show-guidance-buf)
+    ;; If we are in minibuffer, turn off Quail mode before exiting.
+    (if (eq (selected-window) (minibuffer-window))
+        (add-hook 'minibuffer-exit-hook 'quail-exit-from-minibuffer))
+    (make-local-hook 'post-command-hook)
+    (run-hooks 'quail-mode-hook)
+    (run-hooks 'input-method-activate-hook))
+  (force-mode-line-update))
+
+(defun quail-exit-from-minibuffer ()
+  (if quail-mode (quail-mode -1))
+  (if (<= (minibuffer-depth) 1)
+      (remove-hook 'minibuffer-exit-hook 'quail-exit-from-minibuffer)))
+
+(defvar quail-saved-overriding-local-map nil)
+(defvar quail-saved-current-buffer nil)
+
+;; Toggle `quail-mode'.  This function is added to `post-command-hook'
+;; in Quail mode, to turn Quail mode temporarily off, or back on
+;; after one non-Quail command.
+(defun quail-toggle-mode-temporarily ()
+  (if quail-mode
+      ;; We are going to handle following events out of Quail mode.
+      (setq quail-mode nil
+            quail-saved-overriding-local-map overriding-local-map
+            quail-saved-current-buffer (current-buffer)
+            overriding-local-map nil)
+    ;; We have just executed one non-Quail command.  We don't need
+    ;; this hook any more.
+    (remove-hook 'post-command-hook 'quail-toggle-mode-temporarily t)
+    ;; If the command changed the current buffer, we should not go
+    ;; back to Quail mode.
+    (if (not (eq (current-buffer) quail-saved-current-buffer))
+        (throw 'quail-tag nil)
+      ;; Let's go back to Quail mode.
+      (setq quail-mode t)
+      (setq overriding-local-map quail-saved-overriding-local-map)
+      ;; If whole text in conversion area was deleted, exit from the
+      ;; recursive edit.
+      (let ((start (overlay-start quail-conv-overlay)))
+        (if (and start (= start (overlay-end quail-conv-overlay)))
+            (throw 'quail-tag nil)))
+      )))
+
+(defun quail-execute-non-quail-command ()
+  "Execute one non-Quail command in Quail mode.
+The current translation and conversion are terminated."
+  (interactive)
+  (setq unread-command-events (cons last-input-event unread-command-events))
+  (quail-delete-overlays)
+  (if (buffer-live-p quail-guidance-buf)
+      (save-excursion
+        (set-buffer quail-guidance-buf)
+        (erase-buffer)))
+  (throw 'quail-tag nil))
+
+;; Keyboard layout translation handlers.
+
+;; Some Quail packages provide localized keyboard simulation which
+;; requires a particular keyboard layout.  In this case, what we need
+;; is locations of keys the user entered, not character codes
+;; generated by those keys.  However, for the moment, there's no
+;; common way to get such information.  So, we ask a user to give
+;; information of his own keyboard layout, then translate it to the
+;; standard layout which we defined so that all Quail packages depend
+;; just on it.
+
+(defconst quail-keyboard-layout-standard
+  "\
+  1!2@3#4$5%6^7&8*9(0)-_=+`~  \
+  qQwWeErRtTyYuUiIoOpP[{]}    \
+  aAsSdDfFgGhHjJkKlL;:'\"\\|    \
+  zZxXcCvVbBnNmM,<.>/?        "
+  "Standard keyboard layout of printable characters Quail assumes.
+See the documentation of `quail-keyboard-layout' for this format.
+This layout is almost the same as that of VT100,
+ but the location of key \\ (backslash) is just right of key ' (single-quote),
+ not right of RETURN key.")
+
+(defvar quail-keyboard-layout quail-keyboard-layout-standard
+  "A string which represents physical key layout of a particular keyboard.
+We assume there are four rows and each row has 15 keys (columns),
+        the first column of the first row is left of key '1',
+        the first column of the second row is left of key `q',
+        the first column of the third row is left of key `a',
+        the first column of the fourth row is left of key `z'.
+Nth (N is even) and (N+1)th characters in the string are non-shifted
+ and shifted characters respectively at the same location.
+The location of Nth character is row (N / 30) and column ((N mod 30) / 2).")
+
+(defconst quail-keyboard-layout-len 120)
+
+;; Here we provide several examples of famous keyboard layouts.
+
+(defvar quail-keyboard-layout-alist
+  (list
+   '("sun-type3" . "\
+  1!2@3#4$5%6^7&8*9(0)-_=+\\|`~\
+  qQwWeErRtTyYuUiIoOpP[{]}    \
+  aAsSdDfFgGhHjJkKlL;:'\"      \
+  zZxXcCvVbBnNmM,<.>/?        ")
+   (cons "standard" quail-keyboard-layout-standard))
+  "Alist of keyboard names and corresponding layout strings.
+See the documentation of `quail-keyboard-layout' for the format of
+ the layout string.")
+
+(defun quail-set-keyboard-layout (kbd-type)
+  "Set the current keyboard layout to the same as keyboard KBD-TYPE.
+
+Since some Quail packages depends on a physical layout of keys (not
+characters generated by them), those are created by assuming the
+standard layout defined in `quail-keyboard-layout-standard'.  This
+function tells Quail system the layout of your keyboard so that what
+you type is correctly handled."
+  (interactive
+   (let* ((completing-ignore-case t)
+          (type (completing-read "Keyboard type: "
+                                 quail-keyboard-layout-alist)))
+     (list type)))
+  (let ((layout (assoc kbd-type quail-keyboard-layout-alist)))
+    (if (null layout)
+        ;; Here, we had better ask a user to define his own keyboard
+        ;; layout interactively.
+        (error "Unknown keyboard type `%s'" kbd-type))
+    (setq quail-keyboard-layout (cdr layout))))
+
+(defun quail-keyboard-translate (ch)
+  "Translate CHAR according to `quail-keyboard-layout' and return the result."
+  (if (eq quail-keyboard-layout quail-keyboard-layout-standard)
+      ch
+    (let ((i 0))
+      (while (and (< i quail-keyboard-layout-len)
+                  (/= ch (aref quail-keyboard-layout i)))
+        (setq i (1+ i)))
+      (if (= i quail-keyboard-layout-len)
+          (error "Character `%c' not found in your keyboard layout" ch))
+      (aref quail-keyboard-layout-standard i))))
+
+;; Quail map
+
+(defsubst quail-map-p (object)
+  "Return t if OBJECT is a Quail map.
+
+A Quail map holds information how a particular key should be translated.
+Its format is (TRANSLATION . ALIST).
+TRANSLATION is either a character, or a cons (INDEX . VECTOR).
+In the latter case, each element of VECTOR is a candidate for the translation,
+and INDEX points the currently selected translation.
+
+ALIST is normally a list of elements that look like (CHAR . DEFN),
+where DEFN is another Quail map for a longer key (CHAR added to the
+current key).  It may also be a symbol of a function which returns an
+alist of the above format.
+
+Just after a Quail package is read, TRANSLATION may be a string or a
+vector.  Then each element of the string or vector is a candidate for
+the translation.  These objects are transformed to cons cells in the
+format \(INDEX . VECTOR), as described above."
+  (and (consp object)
+       (let ((translation (car object)))
+         (or (integerp translation) (consp translation) (null translation)
+             (vectorp translation) (stringp translation)
+             (symbolp translation)))
+       (let ((alist (cdr object)))
+         (or (listp alist) (symbolp alist)))))
+
+(defmacro quail-define-rules (&rest rules)
+  "Define translation rules of the current Quail package.
+Each argument is a list of KEY and TRANSLATION.
+KEY is a string meaning a sequence of keystrokes to be translated.
+TRANSLATION is a character, a string, a vector, a Quail map, or a function.
+It it is a character, it is the sole translation of KEY.
+If it is a string, each character is a candidate for the translation.
+If it is a vector, each element (string or character) is a candidate
+  for the translation.
+In these cases, a key specific Quail map is generated and assigned to KEY.
+
+If TRANSLATION is a Quail map or a function symbol which returns a Quail map,
+ it is used to handle KEY."
+  `(quail-install-map
+    ',(let ((l rules)
+            (map (list nil)))
+        (while l
+          (quail-defrule-internal (car (car l)) (car (cdr (car l))) map)
+          (setq l (cdr l)))
+        map)))
+
+(defun quail-install-map (map)
+  "Install the Quail map MAP in the current Quail package.
+The installed map can be referred by the function `quail-map'."
+  (if (null quail-current-package)
+      (error "No current Quail package"))
+  (if (null (quail-map-p map))
+      (error "Invalid Quail map `%s'" map))
+  (setcar (cdr (cdr quail-current-package)) map))
+
+(defun quail-defrule (key translation &optional name)
+  "Add one translation rule, KEY to TRANSLATION, in the current Quail package.
+KEY is a string meaning a sequence of keystrokes to be translated.
+TRANSLATION is a character, a string, a vector, a Quail map, or a function.
+It it is a character, it is the sole translation of KEY.
+If it is a string, each character is a candidate for the translation.
+If it is a vector, each element (string or character) is a candidate
+  for the translation.
+In these cases, a key specific Quail map is generated and assigned to KEY.
+
+If TRANSLATION is a Quail map or a function symbol which returns a Quail map,
+ it is used to handle KEY.
+Optional argument NAME, if specified, says which Quail package
+to define this translation rule in.  The default is to define it in the
+current Quail package."
+  (if name
+      (let ((package (quail-package name)))
+        (if (null package)
+            (error "No Quail package `%s'" name))
+        (setq quail-current-package package)))
+  (quail-defrule-internal key translation (quail-map)))
+
+;; Define KEY as TRANS in a Quail map MAP.
+(defun quail-defrule-internal (key trans map)
+  (if (null (stringp key))
+      "Invalid Quail key `%s'" key)
+  (if (not (or (numberp trans) (stringp trans) (vectorp trans)
+               (symbolp trans)
+               (quail-map-p trans)))
+      (error "Invalid Quail translation `%s'" trans))
+  (if (null (quail-map-p map))
+      (error "Invalid Quail map `%s'" map))
+  (let ((len (length key))
+        (idx 0)
+        ch entry)
+    (while (< idx len)
+      (if (null (consp map))
+          ;; We come here, for example, when we try to define a rule
+          ;; for "ABC" but a rule for "AB" is already defined as a
+          ;; symbol.
+          (error "Quail key %s is too long" key))
+      (setq ch (aref key idx)
+            entry (assq ch (cdr map)))
+      (if (null entry)
+          (progn
+            (setq entry (cons ch (list nil)))
+            (setcdr map (cons entry (cdr map)))))
+      (setq map (cdr entry))
+      (setq idx (1+ idx)))
+    (if (symbolp trans)
+        (if (cdr map)
+            ;; We come here, for example, when we try to define a rule
+            ;; for "AB" as a symbol but a rule for "ABC" is already
+            ;; defined.
+            (error "Quail key %s is too short" key)
+          (setcdr entry trans))
+      (if (quail-map-p trans)
+          (if (not (listp (cdr map)))
+              ;; We come here, for example, when we try to define a rule
+              ;; for "AB" as a symbol but a rule for "ABC" is already
+              ;; defined.
+              (error "Quail key %s is too short" key)
+            (if (not (listp (cdr trans)))
+                (if (cdr map)
+                    ;; We come here, for example, when we try to
+                    ;; define a rule for "AB" as a symbol but a rule
+                    ;; for "ABC" is already defined.
+                    (error "Quail key %s is too short" key)
+                  (setcdr entry trans))
+              (setcdr entry (append trans (cdr map)))))
+        (setcar map trans)))))
+
+(defun quail-get-translation (map key len)
+  "Return the translation specified in Quail map MAP for KEY of length LEN.
+The translation is either a character or a cons of the form (INDEX . VECTOR),
+where VECTOR is a vector of candidates (character or string) for
+the translation, and INDEX points into VECTOR to specify the currently
+selected translation."
+  (let ((def (car map)))
+    (if (and def (symbolp def))
+        ;; DEF is a symbol of a function which returns valid translation.
+        (setq def (funcall def key len)))
+    (cond
+     ((or (integerp def) (consp def))
+      def)
+
+     ((null def)
+      ;; No translation.
+      nil)
+
+     ((stringp def)
+      ;; Each character in DEF is a candidate of translation.  Reform
+      ;; it as (INDEX . VECTOR).
+      (setq def (string-to-vector def))
+      ;; But if the length is 1, we don't need vector but a single
+      ;; character as the translation.
+      (if (= (length def) 1)
+          (aref def 0)
+        (cons 0 def)))
+
+     ((vectorp def)
+      ;; Each element (string or character) in DEF is a candidate of
+      ;; translation.  Reform it as (INDEX . VECTOR).
+      (cons 0 def))
+
+     (t
+      (error "Invalid object in Quail map: %s" def)))))
+
+(defun quail-lookup-key (key len)
+  "Lookup KEY of length LEN in the current Quail map and return the definition.
+The returned value is a Quail map specific to KEY."
+  (let ((idx 0)
+        (map (quail-map))
+        (kbd-translate (quail-kbd-translate))
+        slot ch translation)
+    (while (and map (< idx len))
+      (setq ch (if kbd-translate (quail-keyboard-translate (aref key idx))
+                 (aref key idx)))
+      (setq idx (1+ idx))
+      (if (and (cdr map) (symbolp (cdr map)))
+          (setcdr map (funcall (cdr map) key idx)))
+      (setq slot (assq ch (cdr map)))
+      (if (and (cdr slot) (symbolp (cdr slot)))
+          (setcdr slot (funcall (cdr slot) key idx)))
+      (setq map (cdr slot)))
+    (if (and map (setq translation (quail-get-translation map key len)))
+        (progn
+          ;; We may have to reform car part of MAP.
+          (if (not (equal (car map) translation))
+              (setcar map translation))
+          (if (consp translation) 
+              (progn
+                (setq quail-current-translations translation)
+                (if (quail-forget-last-selection)
+                    (setcar quail-current-translations 0))))
+          ;; We may have to reform cdr part of MAP.
+          (if (and (cdr map) (symbolp (cdr map)))
+              (progn
+                (setcdr map (funcall (cdr map) key len))))
+          ))
+    map))
+
+(defun quail-conv-overlay-modification-hook (overlay after &rest ignore)
+  (if (and after
+           (= (overlay-start overlay) (overlay-end overlay)))
+      ;; Whole text in conversion area was deleted.  Let's exit from
+      ;; the recursive edit.
+      (throw 'exit nil)))
+
+(defvar quail-suppress-conversion nil
+  "If non-nil, suppress converting facility of the current Quail package.")
+
+;; If set to non-nil, exit conversion mode before starting new translation.
+(defvar quail-exit-conversion-mode nil)
+
+(defun quail-start-translation ()
+  "Start translating the typed character in Quail mode."
+  (interactive "*")
+  (setq unread-command-events
+        (cons last-command-event unread-command-events))
+  ;; Check the possibility of translating the last key.
+  (if (assq last-command-event (cdr (quail-map)))
+      ;; Ok, we can start translation.
+      (let ((mode-line-format quail-mode-line-format))
+        (quail-setup-overlays)
+        (if (catch 'quail-tag
+              (if (and (not quail-suppress-conversion)
+                       (quail-conversion-keymap))
+                  ;; We must start translation in conversion mode.
+                  (let ((overriding-local-map (quail-conversion-keymap)))
+                    (setq quail-exit-conversion-mode nil)
+                    (recursive-edit)
+                    (if (and auto-fill-function
+                             (> (current-column) (current-fill-column)))
+                        (run-hooks 'auto-fill-function)))
+                (let ((overriding-local-map (quail-translation-keymap)))
+                  (setq quail-current-key "")
+                  (recursive-edit)))
+              (if (prog1 (< (overlay-start quail-conv-overlay)
+                            (overlay-end quail-conv-overlay))
+                    (delete-overlay quail-conv-overlay))
+                  (run-hooks 'input-method-after-insert-chunk-hook))
+              nil)
+            ;; Someone has thrown a tag with value t, which means
+            ;; we should turn Quail mode off.
+            (quail-mode -1)))
+    ;; Since the typed character doesn't start any translation, handle
+    ;; it out of Quail mode.  We come back to Quail mode later because
+    ;; function `quail-toggle-mode-temporarily' is in
+    ;; `post-command-hook'.
+    (add-hook 'post-command-hook 'quail-toggle-mode-temporarily nil t)))
+
+(defsubst quail-point-in-conversion-region ()
+  "Return non-nil value if the point is in conversion region of Quail mode."
+  (let (start pos)
+    (and (setq start (overlay-start quail-conv-overlay))
+         (>= (setq pos (point)) start)
+         (<= pos (overlay-end quail-conv-overlay)))))
+
+(defun quail-start-translation-in-conversion-mode ()
+  "Start translating the typed character in conversion mode of Quail mode."
+  (interactive "*")
+  (setq unread-command-events
+        (cons last-command-event unread-command-events))
+  (if (or quail-exit-conversion-mode
+          (not (quail-point-in-conversion-region)))
+      (progn
+        ;; We must start translation with new conversion region.
+        (setq quail-exit-conversion-mode nil)
+        (throw 'exit nil)))
+  ;; Check the possibility of translating the last key.
+  (if (assq last-command-event (cdr (quail-map)))
+      ;; Ok, we can start translation.
+      (let ((overriding-local-map (quail-translation-keymap)))
+        (setq quail-current-key "")
+        (move-overlay quail-overlay (point) (point))
+        (recursive-edit))
+    ;; Since the typed character doesn't start any translation, handle
+    ;; it out of Quail mode.  We come back to Quail mode later because
+    ;; function `quail-toggle-mode-temporarily' is in
+    ;; `post-command-hook'.
+    (add-hook 'post-command-hook 'quail-toggle-mode-temporarily nil t)))
+
+(defun quail-terminate-translation ()
+  "Terminate the translation of the current key."
+  (let ((start (overlay-start quail-overlay)))
+    (if (and start
+             (< start (overlay-end quail-overlay)))
+        ;; Here we simulate self-insert-command.
+        (let (last-command-char)
+          (goto-char start)
+          ;; The first one might want to expand an abbrev.
+          (setq last-command-char (following-char))
+          (delete-char 1)
+          (self-insert-command 1)
+          (if (< (point) (overlay-end quail-overlay))
+              (if overwrite-mode
+                  (while (< (point) (overlay-end quail-overlay))
+                    (setq last-command-char (following-char))
+                    (delete-char 1)
+                    (self-insert-command 1))
+                ;; The last one might still want to auto-fill.
+                (goto-char (overlay-end quail-overlay))
+                (let ((last-command-char (preceding-char)))
+                  (delete-char -1)
+                  (self-insert-command 1)))))))
+  (delete-overlay quail-overlay)
+  (if (buffer-live-p quail-guidance-buf)
+      (save-excursion
+        (set-buffer quail-guidance-buf)
+        (erase-buffer)))
+  (throw 'exit nil))
+
+(defsubst quail-delete-region ()
+  "Delete the text in the current translation region of Quail."
+  (delete-region (overlay-start quail-overlay) (overlay-end quail-overlay)))
+
+(defun quail-select-current ()
+  "Select the current text shown in Quail translation region."
+  (interactive)
+  (quail-terminate-translation))
+
+;; Update the current translation status according to CONTROL-FLAG.
+;; If CONTROL-FLAG is integer value, it is the number of keys in the
+;; head quail-current-key which can be translated.  The remaining keys
+;; are put back to unread-command-events to be handled again.
+;; If CONTROL-FLAG is t, terminate the translation for the whole keys
+;; in quail-current-key.
+;; If CONTROL-FLAG is nil, proceed the translation with more keys.
+
+(defun quail-update-translation (control-flag)
+  (quail-delete-region)
+  (let ((func (quail-update-translation-function)))
+    (if func
+        (funcall func control-flag)
+      (if (numberp control-flag)
+          (let ((len (length quail-current-key)))
+            (while (> len control-flag)
+              (setq len (1- len))
+              (setq unread-command-events
+                    (cons (aref quail-current-key len)
+                          unread-command-events)))
+            (insert (or quail-current-str
+                        (substring quail-current-key 0 len))))
+        (insert (or quail-current-str quail-current-key)))))
+  (quail-update-guidance)
+  (if control-flag
+      (quail-terminate-translation)))
+
+(defun quail-self-insert-command ()
+  "Add the typed character to the key for translation."
+  (interactive "*")
+  (setq quail-current-key
+        (concat quail-current-key (char-to-string last-command-event)))
+  (quail-update-translation (quail-translate-key)))
+
+(defun quail-translate-key ()
+  "Translate the current key sequence according to the current Quail map.
+Return t if we can terminate the translation.
+Return nil if the current key sequence may be followed by more keys.
+Return number if we can't find any translation for the current key
+sequence.  The number is the count of valid keys in the current
+sequence counting from the head."
+  (let* ((len (length quail-current-key))
+         (map (quail-lookup-key quail-current-key len))
+         def ch)
+    (if map
+        (let ((def (car map)))
+          (setq quail-current-str
+                (if (consp def) (aref (cdr def) (car def)) def))
+          ;; Return t only if we can terminate the current translation.
+          (and
+           ;; No alternative translations.
+           (or (null (consp def)) (= (length (cdr def)) 1))
+           ;; No translation for the longer key.
+           (null (cdr map))
+           ;; No shorter breaking point.
+           (or (null (quail-maximum-shortest))
+               (< len 3)
+               (null (quail-lookup-key quail-current-key (1- len)))
+               (null (quail-lookup-key
+                      (substring quail-current-key -2 -1) 1)))))
+
+      ;; There's no translation for the current key sequence.  Before
+      ;; giving up, we must check two possibilities.
+      (cond ((and
+              (quail-maximum-shortest)
+              (>= len 4)
+              (setq def (car (quail-lookup-key quail-current-key (- len 2))))
+              (quail-lookup-key (substring quail-current-key -2) 2))
+             ;; Now the sequence is "...ABCD", which can be split into
+             ;; "...AB" and "CD..." to get valid translation.
+             ;; At first, get translation of "...AB".
+             (setq quail-current-str
+                   (if (consp def) (aref (cdr def) (car def)) def))
+             ;; Then, return the length of "...AB".
+             (- len 2))
+
+            ((and quail-current-translations
+                  (not (quail-deterministic))
+                  (setq ch (aref quail-current-key (1- len)))
+                  (>= ch ?0) (<= ch ?9))
+             ;; A numeric key is entered to select a desirable translation.
+             (setq quail-current-key (substring quail-current-key 0 -1))
+             (quail-select-translation
+              (+ (* (/ (car quail-current-translations) 10) 10)
+                 ;; We treat key 1,2..,9,0 as specifying 0,1,..8,9.
+                 (if (= ch ?0) 9 (- ch ?1))))
+             ;; And, we can terminate the current translation.
+             t)
+
+            (t
+             ;; No way to handle the last character in this context.
+             (1- len))))))
+
+(defun quail-next-translation ()
+  "Select next translation in the current batch of candidates."
+  (interactive)
+  (if quail-current-translations
+      (progn
+        (quail-select-translation (1+ (car quail-current-translations)))
+        (quail-update-translation nil))
+    (beep)))
+
+(defun quail-prev-translation ()
+  "Select previous translation in the current batch of candidates."
+  (interactive)
+  (if quail-current-translations
+      (progn
+        (quail-select-translation (1- (car quail-current-translations)))
+        (quail-update-translation nil))
+    (beep)))
+
+(defun quail-next-translation-block ()
+  "Select the next batch of 10 translation candidates."
+  (interactive)
+  (if quail-current-translations
+      (let ((limit (1- (length (cdr quail-current-translations))))
+            (n (car quail-current-translations)))
+        (if (< (/ n 10) (/ limit 10))
+            (progn
+              (quail-select-translation (min (+ n 10) limit))
+              (quail-update-translation nil))
+          ;; We are already at the last block.
+          (beep)))
+    (beep)))
+
+(defun quail-prev-translation-block ()
+  "Select the previous batch of 10 translation candidates."
+  (interactive)
+  (if (and quail-current-translations
+           (>= (car quail-current-translations) 10))
+      (progn
+        (quail-select-translation (- (car quail-current-translations) 10))
+        (quail-update-translation nil))
+    (beep)))
+
+(defun quail-select-translation (n)
+  "Select Nth translation in the current batch of translation candidates."
+  (if (or (< n 0) (>= n (length (cdr quail-current-translations))))
+      (beep)
+    (setcar quail-current-translations n)
+    (setq quail-current-str (aref (cdr quail-current-translations) n))))
+
+(defun quail-abort-translation ()
+  "Abort translation and delete the current Quail key sequence."
+  (interactive)
+  (quail-delete-region)
+  (quail-terminate-translation))
+
+(defun quail-delete-last-char ()
+  "Delete the last input character from the current Quail key sequence."
+  (interactive)
+  (if (= (length quail-current-key) 1)
+      (quail-abort-translation)
+    (setq quail-current-key (substring quail-current-key 0 -1))
+    (quail-update-translation (quail-translate-key))))
+
+;; For conversion mode.
+
+(defun quail-conversion-backward-char ()
+  (interactive)
+  (if (<= (point) (overlay-start quail-conv-overlay))
+      (error "Beginning of conversion region"))
+  (forward-char -1))
+
+(defun quail-conversion-forward-char ()
+  (interactive)
+  (if (>= (point) (overlay-end quail-conv-overlay))
+      (error "End of conversion region"))
+  (forward-char 1))
+
+(defun quail-conversion-beginning-of-region ()
+  (interactive)
+  (goto-char (overlay-start quail-conv-overlay)))
+
+(defun quail-conversion-end-of-region ()
+  (interactive)
+  (goto-char (overlay-end quail-conv-overlay)))
+
+(defun quail-conversion-delete-char ()
+  (interactive)
+  (if (>= (point) (overlay-end quail-conv-overlay))
+      (error "End of conversion region"))
+  (delete-char 1)
+  (if (= (overlay-start quail-conv-overlay)
+         (overlay-end quail-conv-overlay))
+      (throw 'quail-tag nil)))
+
+(defun quail-conversion-backward-delete-char ()
+  (interactive)
+  (if (<= (point) (overlay-start quail-conv-overlay))
+      (error "Beginning of conversion region"))
+  (delete-char -1)
+  (if (= (overlay-start quail-conv-overlay)
+         (overlay-end quail-conv-overlay))
+      (throw 'quail-tag nil)))
+
+(defun quail-do-conversion (func &rest args)
+  "Call FUNC to convert text in the current conversion region of Quail.
+Remaining args are for FUNC."
+  (delete-overlay quail-overlay)
+  (apply func args))
+
+(defun quail-no-conversion ()
+  "Do no conversion of the current conversion region of Quail."
+  (interactive)
+  (throw 'exit nil))
+
+;; Guidance, Completion, and Help buffer handlers.
+
+(defun quail-show-guidance-buf ()
+  "Display a Quail guidance buffer in some window.
+Create the buffer if it does not exist yet.
+The window is normally shown in a minibuffer,
+but if the selected window is a minibuffer, it is shown in
+the bottommost ordinary window."
+
+  (if (or (null input-method-tersely-flag)
+          (not (eq (selected-window) (minibuffer-window))))
+      (progn
+        ;; At first, setup a guidance buffer.
+        (or (buffer-live-p quail-guidance-buf)
+            (setq quail-guidance-buf
+                  (get-buffer-create " *Quail-guidance*")))
+        (save-excursion
+          (let ((title (quail-title)))
+            (set-buffer quail-guidance-buf)
+            ;; Show the title of Quail package in the left of mode-line.
+            (setq current-input-method nil)
+            (setq current-input-method-title title)
+            (setq mode-line-format (cons '("[" current-input-method-title "]")
+                                         default-mode-line-format))
+            (erase-buffer)
+            (or (overlayp quail-overlay)
+                (progn
+                  (setq quail-overlay (make-overlay 1 1))
+                  (overlay-put quail-overlay 'face 'highlight)))
+            (delete-overlay quail-overlay)
+            (set-buffer-modified-p nil)))
+        (bury-buffer quail-guidance-buf)
+
+        ;; Then, display it in an appropriate window.
+        (if (not (get-buffer-window quail-guidance-buf))
+            ;; Guidance buffer is not yet shown in any window.
+            (let ((win (minibuffer-window)))
+              (if (eq (selected-window) win)
+                  ;; Since we are in minibuffer, we can't use it for guidance.
+                  ;; Let's find the bottom window.
+                  (let (height)
+                    (setq win (window-at 0 (- (frame-height) 2)))
+                    (setq height (window-height win))
+                    ;; If WIN is too tall, split it vertically and use
+                    ;; the lower one.
+                    (if (>= height 4)
+                        (let ((window-min-height 2))
+                          ;; Here, `split-window' returns a lower window
+                          ;; which is what we wanted.
+                          (setq win (split-window win (- height 2)))))
+                    (set-window-buffer win quail-guidance-buf)
+                    (set-window-dedicated-p win t))
+                (set-window-buffer win quail-guidance-buf))))))
+
+  ;; And, create a buffer for completion.
+  (or (buffer-live-p quail-completion-buf)
+      (progn
+        (setq quail-completion-buf (get-buffer-create "*Quail Completions*"))
+        (save-excursion
+          (set-buffer quail-completion-buf)
+          (setq quail-overlay (make-overlay 1 1))
+          (overlay-put quail-overlay 'face 'highlight))))
+  (bury-buffer quail-completion-buf))
+
+(defun quail-hide-guidance-buf ()
+  "Hide the Quail guidance buffer."
+  (let* ((win (minibuffer-window))
+         (buf (window-buffer win)))
+    (if (eq buf quail-guidance-buf)
+        ;; Quail guidance buffer is at echo area.  Vacate it to the
+        ;; deepest minibuffer.
+        (set-window-buffer win (format " *Minibuf-%d*" (minibuffer-depth)))
+      ;; Delete the window for guidance buffer.
+      (if (or (null input-method-tersely-flag)
+              (not (eq (selected-window) (minibuffer-window))))
+          (progn
+            (setq win (get-buffer-window quail-guidance-buf))
+            (set-window-dedicated-p win nil)
+            (delete-window win))))))
+
+(defun quail-update-guidance ()
+  "Update the Quail guidance buffer and completion buffer (if displayed now)."
+  ;; Update guidance buffer.
+  (if (or (null input-method-tersely-flag)
+          (not (eq (selected-window) (minibuffer-window))))
+      (let ((guidance (quail-guidance)))
+        (cond ((eq guidance t)
+               ;; Show the current possible translations.
+               (quail-show-translations))
+              ((null guidance)
+               ;; Show the current input keys.
+               (let ((key quail-current-key))
+                 (save-excursion
+                   (set-buffer quail-guidance-buf)
+                   (erase-buffer)
+                   (insert key))))
+              ((listp guidance)
+               ;; Show alternative characters specified in this alist.
+               (let* ((key quail-current-key)
+                      (len (length key))
+                      (i 0)
+                      ch alternative)
+                 (save-excursion
+                   (set-buffer quail-guidance-buf)
+                   (erase-buffer)
+                   (while (< i len)
+                     (setq ch (aref key i))
+                     (setq alternative (cdr (assoc ch guidance)))
+                     (insert (or alternative ch))
+                     (setq i (1+ i)))))))))
+
+  ;; Update completion buffer if displayed now.  We highlight the
+  ;; selected candidate string in *Completion* buffer if any.
+  (let ((win (get-buffer-window quail-completion-buf))
+        key str pos)
+    (if win
+        (save-excursion
+          (setq str (if (stringp quail-current-str)
+                        quail-current-str
+                      (if (numberp quail-current-str)
+                          (char-to-string quail-current-str)))
+                key quail-current-key)
+          (set-buffer quail-completion-buf)
+          (goto-char (point-min))
+          (if (null (search-forward (concat " " key ":") nil t))
+              (delete-overlay quail-overlay)
+            (setq pos (point))
+            (if (and str (search-forward (concat "." str) nil t))
+                  (move-overlay quail-overlay (1+ (match-beginning 0)) (point))
+                (move-overlay quail-overlay (match-beginning 0) (point)))
+            ;; Now POS points end of KEY and (point) points end of STR.
+            (if (pos-visible-in-window-p (point) win)
+                ;; STR is already visible.
+                nil
+              ;; We want to make both KEY and STR visible, but if the
+              ;; window is too short, make at least STR visible.
+              (setq pos (progn (point) (goto-char pos)))
+              (beginning-of-line)
+              (set-window-start win (point))
+              (if (not (pos-visible-in-window-p pos win))
+                  (set-window-start win pos))
+              ))))))
+
+(defun quail-show-translations ()
+  "Show the current possible translations."
+  (let ((key quail-current-key)
+        (map (quail-lookup-key quail-current-key (length quail-current-key))))
+    (save-excursion
+      (set-buffer quail-guidance-buf)
+      (erase-buffer)
+
+      ;; Show the current key.
+      (insert key)
+
+      ;; Show possible following keys.
+      (if (cdr map)
+          (let ((l (cdr map)))
+            (insert "[")
+            (while l
+              (insert (car (car l)))
+              (setq l (cdr l)))
+            (insert "]")))
+
+      ;; Show list of translations.
+      (if (consp (car map))
+          (let* ((idx (car (car map)))
+                 (translations (cdr (car map)))
+                 (from (* (/ idx 10) 10))
+                 (to (min (+ from 10) (length translations))))
+            (indent-to 10)
+            (insert (format "(%d/%d)"
+                            (1+ (/ from 10))
+                            (1+ (/ (length translations) 10))))
+            (while (< from to)
+              ;; We show the last digit of FROM, but by changing
+              ;; 0,1,..,9 to 1,2,..,0.
+              (insert (format " %d."
+                              (if (= (% from 10) 9) 0 (1+ (% from 10)))))
+              (let ((pos (point)))
+                (insert (aref translations from))
+                (if (= idx from)
+                    (move-overlay quail-overlay pos (point))))
+              (setq from (1+ from)))))
+      )))
+
+(defun quail-completion ()
+  "List all completions for the current key.
+All possible translations of the current key and whole possible longer keys
+ are shown."
+  (interactive)
+  (let ((key quail-current-key)
+        (map (quail-lookup-key quail-current-key (length quail-current-key))))
+    (save-excursion
+      (set-buffer quail-completion-buf)
+      (erase-buffer)
+      (insert "Possible completion and corresponding translations are:\n")
+      (quail-completion-1 key map 1)
+      (goto-char (point-min))
+      (display-buffer (current-buffer)))
+      (quail-update-guidance)))
+
+;; List all completions of KEY in MAP with indentation INDENT.
+(defun quail-completion-1 (key map indent)
+  (let ((len (length key)))
+    (indent-to indent)
+    (insert key ":")
+    (if (and (symbolp map) (fboundp map))
+        (setq map (funcall map key len)))
+    (if (car map)
+        (quail-completion-list-translations map key (+ indent len 1))
+      (insert " -\n"))
+    (setq indent (+ indent 2))
+    (if (cdr map)
+        (let ((l (cdr map))
+              (newkey (make-string (1+ len) 0))
+              (i 0))
+          ;; Set KEY in the first LEN characters of NEWKEY.
+          (while (< i len)
+            (aset newkey i (aref key i))
+            (setq i (1+ i)))
+          (while l                      ; L = ((CHAR . DEFN) ....) ;
+            (aset newkey len (car (car l)))
+            (quail-completion-1 newkey (cdr (car l)) indent)
+            (setq l (cdr l)))))))
+
+;; List all possible translations of KEY in Quail map MAP with
+;; indentation INDENT."
+(defun quail-completion-list-translations (map key indent)
+  (let ((translations
+         (quail-get-translation map key (length key))))
+    (if (integerp translations)
+        (insert "(1/1) 1." translations "\n")
+      ;; We need only vector part.
+      (setq translations (cdr translations))
+      ;; Insert every 10 elements with indices in a line.
+      (let ((len (length translations))
+            (i 0)
+            (first t)
+            num)
+        (while (< i len)
+          (if first
+              (progn
+                (insert "(1/1)")
+                (setq first nil))
+            (if (= (% i 10) 0)
+                (progn
+                  (newline)
+                  (indent-to indent)
+                  (insert (format "(%d/%d)" (1+ (/ i 10)) (1+ (/ len 10)))))))
+          ;; We show the last digit of FROM while converting
+          ;; 0,1,..,9 to 1,2,..,0.
+          (insert (format " %d." (if (= (% i 10) 9) 0 (1+ (% i 10)))))
+          (insert (aref translations i))
+          (setq i (1+ i)))
+        (newline)))))
+
+(defun quail-help ()
+  "Show brief description of the current Quail package."
+  (interactive)
+  (let ((package quail-current-package)
+        (buf (get-buffer-create "*Quail-help*")))
+    (save-excursion
+      (set-buffer buf)
+      (erase-buffer)
+      (setq quail-current-package package)
+      (insert "Quail input method (name:"
+              (quail-name)
+              ", mode line indicator:["
+              (quail-title)
+              "])\n---- Documentation ----\n"
+              (quail-docstring))
+      (newline)
+      (if (quail-show-layout) (quail-show-kbd-layout))
+      (insert )
+      (quail-help-insert-keymap-description
+       quail-mode-map
+       "---- Key bindings (before starting translation) ----
+key             binding
+---             -------\n")
+      (quail-help-insert-keymap-description
+       (quail-translation-keymap)
+       "--- Key bindings (while translating) ---
+key             binding
+---             -------\n")
+      (if (quail-conversion-keymap)
+          (quail-help-insert-keymap-description
+           (quail-conversion-keymap)
+       "--- Key bindings (while converting) ---
+key             binding
+---             -------\n"))
+      (goto-char (point-min))
+      (set-buffer-modified-p nil)
+      (help-mode))
+    (display-buffer buf)))
+
+(defun quail-help-insert-keymap-description (keymap &optional header)
+  (let (from to)
+    (if header
+        (insert header))
+    (save-excursion
+      (save-window-excursion
+        (let ((overriding-local-map keymap))
+          (describe-bindings))
+        (set-buffer "*Help*")
+        (goto-char (point-min))
+        (forward-line 4)
+        (setq from (point))
+        (search-forward "Global Bindings:" nil 'move)
+        (beginning-of-line)
+        (setq to (point))))
+    (insert-buffer-substring "*Help*" from to)))
+
+(defun quail-show-kbd-layout ()
+  "Show keyboard layout with key tops of multilingual characters."
+  (insert "--- Keyboard layout ---\n")
+  (let* ((i 0) ch)
+    (while (< i quail-keyboard-layout-len)
+      (if (= (% i 30) 0)
+          (progn
+            (newline)
+            (indent-to (/ i 30)))
+        (if (= (% i 2) 0)
+            (insert "   ")))
+      (setq ch (aref quail-keyboard-layout i))
+      (if (= ch ?\ )
+          (insert ch)
+        (let ((map (cdr (assq ch (cdr (quail-map))))))
+          (if map
+              (let ((translation
+                     (quail-get-translation map (char-to-string ch) 1)))
+                (if (integerp translation)
+                    (insert translation)
+                  (insert (aref (cdr translation) (car translation)))))
+            (insert ch))))
+      (setq i (1+ i))))
+  (newline))
+
+(defun quail-translation-help ()
+  "Show help message while translating in Quail mode."
+  (interactive)
+  (let ((package quail-current-package)
+        (current-key quail-current-key)
+        (buf (get-buffer-create "*Quail-Help*")))
+    (save-excursion
+      (set-buffer buf)
+      (erase-buffer)
+      (setq quail-current-package package)
+      (insert
+       (format "You are translating the key sequence \"%s\" in Quail mode.\n"
+               quail-current-key))
+      (quail-help-insert-keymap-description
+       (quail-translation-keymap)
+       "-----------------------
+key             binding
+---             -------\n")
+      (goto-char (point-min))
+      (set-buffer-modified-p nil))
+    (display-buffer buf)))
+  
+(defun quail-conversion-help ()
+  "Show help message while converting in Quail mode."
+  (interactive)
+  (let ((package quail-current-package)
+        (str (buffer-substring (overlay-start quail-conv-overlay)
+                                 (overlay-end quail-conv-overlay)))
+        (buf (get-buffer-create "*Quail-Help*")))
+    (save-excursion
+      (set-buffer buf)
+      (erase-buffer)
+      (setq quail-current-package package)
+      (insert
+       (format "You are converting the string \"%s\" in Quail mode.\n" str))
+      (quail-help-insert-keymap-description
+       (quail-conversion-keymap)
+       "-----------------------
+key             binding
+---             -------\n")
+      (goto-char (point-min))
+      (set-buffer-modified-p nil))
+    (display-buffer buf)))
+
+;;
+(provide 'quail)
+
+;;; quail.el ends here
diff --git a/lisp/international/skkdic-cnv.el b/lisp/international/skkdic-cnv.el
new file mode 100644
index 00000000000..4f227204bdc
--- /dev/null
+++ b/lisp/international/skkdic-cnv.el
@@ -0,0 +1,561 @@
+;; skkdic-cnv.el -- convert a SKK dictionary for `skkdic-utl'
+
+;; Copyright (C) 1995 Free Software Foundation, Inc.
+;; Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+;; Keywords: mule, multilingual, Japanese, SKK
+
+;; 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.
+
+;;; Commentary:
+
+;; SKK is a Japanese input method running on Mule created by Masahiko
+;; Sato <masahiko@sato.riec.tohoku.ac.jp>.  Here we provide utilities
+;; to handle a dictionary distributed with SKK so that a different
+;; input method (e.g. quail-japanese) can utilize the dictionary.
+
+;; The format of SKK dictionary is quite simple.  Each line has the
+;; form "KANASTRING /CONV1/CONV2/.../" which means KANASTRING ($B2>L>J8(B
+;; $B;zNs(B) can be converted to one of CONVi.  CONVi is a Kanji ($B4A;z(B)
+;; and Kana ($B2>L>(B) mixed string.
+;;
+;; KANASTRING may have a trailing ASCII letter for Okurigana ($BAw$j2>L>(B)
+;; information.  For instance, the trailing letter `k' means that one
+;; of the following Okurigana is allowed: $B$+$-$/$1$3(B.  So, in that
+;; case, the string "KANASTRING$B$/(B" can be converted to one of "CONV1$B$/(B",
+;; CONV2$B$/(B, ...
+
+;;; Code:
+
+;; Name of a file to generate from SKK dictionary.
+(defvar skkdic-filename "skkdic.el")
+
+;; To make a generated skkdic.el smaller.
+(make-coding-system
+ 'coding-system-iso-2022-7-short
+ 2 ?J
+ "Like `coding-system-iso-2022' but no ASCII designation before SPC."
+ '(ascii nil nil nil t t nil t))
+
+(defconst skkdic-jbytes
+  (charset-bytes 'japanese-jisx0208))
+
+(defun skkdic-convert-okuri-ari (skkbuf buf)
+  (message "Processing OKURI-ARI entries ...")
+  (goto-char (point-min))
+  (save-excursion
+    (set-buffer buf)
+    (insert ";; Setting okuri-ari entries.\n"
+            "(skkdic-set-okuri-ari\n"))
+  (while (not (eobp))
+    (let ((from (point))
+          to)
+      (end-of-line)
+      (setq to (point))
+
+      (save-excursion
+        (set-buffer buf)
+        (insert-buffer-substring skkbuf from to)
+        (beginning-of-line)
+        (insert "\"")
+        (search-forward " ")
+        (delete-char 1)                 ; delete the first '/'
+        (let ((p (point)))
+          (end-of-line)
+          (delete-char -1)              ; delete the last '/'
+          (subst-char-in-region p (point) ?/ ? 'noundo))
+        (insert "\"\n"))
+
+      (forward-line 1)))
+  (save-excursion
+    (set-buffer buf)
+    (insert ")\n\n")))
+
+(defconst skkdic-postfix-list '(skkdic-postfix-list))
+
+(defconst skkdic-postfix-data
+  '(("$B$$$-(B" "$B9T(B")
+    ("$B$,$+$j(B" "$B78(B")
+    ("$B$,$/(B" "$B3X(B")
+    ("$B$,$o(B" "$B@n(B")
+    ("$B$7$c(B" "$B<R(B")
+    ("$B$7$e$&(B" "$B=8(B")
+    ("$B$7$g$&(B" "$B>^(B" "$B>k(B")
+    ("$B$8$g$&(B" "$B>k(B")
+    ("$B$;$s(B" "$B@~(B")
+    ("$B$@$1(B" "$B3Y(B")
+    ("$B$A$c$/(B" "$BCe(B")
+    ("$B$F$s(B" "$BE9(B")
+    ("$B$H$&$2(B" "$BF=(B")
+    ("$B$I$*$j(B" "$BDL$j(B")
+    ("$B$d$^(B" "$B;3(B")
+    ("$B$P$7(B" "$B66(B")
+    ("$B$O$D(B" "$BH/(B")
+    ("$B$b$/(B" "$BL\(B")
+    ("$B$f$-(B" "$B9T(B")))
+
+(defun skkdic-convert-postfix (skkbuf buf)
+  (message "Processing POSTFIX entries ...")
+  (goto-char (point-min))
+  (save-excursion
+    (set-buffer buf)
+    (insert ";; Setting postfix entries.\n"
+            "(skkdic-set-postfix\n"))
+
+  ;; Initialize SKKDIC-POSTFIX-LIST by predefined data
+  ;; SKKDIC-POSTFIX-DATA.
+  (save-excursion
+    (set-buffer buf)
+    (let ((l skkdic-postfix-data)
+          kana candidates entry)
+      (while l
+        (setq kana (car (car l)) candidates (cdr (car l)))
+        (insert "\"" kana)
+        (while candidates
+          (insert " " (car candidates))
+          (setq entry (lookup-nested-alist (car candidates)
+                                           skkdic-postfix-list nil nil t))
+          (if (consp (car entry))
+              (setcar entry (cons kana (car entry)))
+            (set-nested-alist (car candidates) (list kana)
+                              skkdic-postfix-list))
+          (setq candidates (cdr candidates)))
+        (insert "\"\n")
+        (setq l (cdr l)))))
+
+  ;; Search postfix entries.
+  (while (re-search-forward "^[#<>?]\\(\\cH+\\) " nil t)
+    (let ((kana (match-string 1))
+          str candidates)
+      (while (looking-at "/[#0-9 ]*\\([^/\n]*\\)/")
+        (setq str (match-string 1))
+        (if (not (member str candidates))
+            (setq candidates (cons str candidates)))
+        (goto-char (match-end 1)))
+      (save-excursion
+        (set-buffer buf)
+        (insert "\"" kana)
+        (while candidates
+          (insert " " (car candidates))
+          (let ((entry (lookup-nested-alist (car candidates)
+                                            skkdic-postfix-list nil nil t)))
+            (if (consp (car entry))
+                (if (not (member kana (car entry)))
+                    (setcar entry (cons kana (car entry))))
+              (set-nested-alist (car candidates) (list kana)
+                                skkdic-postfix-list)))
+          (setq candidates (cdr candidates)))
+        (insert "\"\n"))))
+  (save-excursion
+    (set-buffer buf)
+    (insert ")\n\n")))
+          
+(defconst skkdic-prefix-list '(skkdic-prefix-list))
+
+(defun skkdic-convert-prefix (skkbuf buf)
+  (message "Processing PREFIX entries ...")
+  (goto-char (point-min))
+  (save-excursion
+    (set-buffer buf)
+    (insert ";; Setting prefix entries.\n"
+            "(skkdic-set-prefix\n"))
+  (save-excursion
+    (while (re-search-forward "^\\(\\cH+\\)[<>?] " nil t)
+      (let ((kana (match-string 1))
+            str candidates)
+        (while (looking-at "/\\([^/\n]+\\)/")
+          (setq str (match-string 1))
+          (if (not (member str candidates))
+              (setq candidates (cons str candidates)))
+          (goto-char (match-end 1)))
+        (save-excursion
+          (set-buffer buf)
+          (insert "\"" kana)
+          (while candidates
+            (insert " " (car candidates))
+            (set-nested-alist (car candidates) kana skkdic-prefix-list)
+            (setq candidates (cdr candidates)))
+          (insert "\"\n")))))
+  (save-excursion
+    (set-buffer buf)
+    (insert ")\n\n")))
+          
+;; FROM and TO point the head and tail of "/J../J../.../".
+(defun skkdic-get-candidate-list (from to)
+  (let (candidates)
+    (goto-char from)
+    (while (re-search-forward "/\\cj+" to t)
+      (setq candidates (cons (buffer-substring (1+ (match-beginning 0))
+                                               (match-end 0))
+                             candidates)))
+    candidates))
+
+;; Return entry for STR from nested alist ALIST.
+(defsubst skkdic-get-entry (str alist)
+  (car (lookup-nested-alist str alist nil nil t)))
+
+
+(defconst skkdic-word-list '(skkdic-word-list))
+
+;; Return t if substring of STR (between FROM and TO) can be broken up
+;; to chunks all of which can be derived from another entry in SKK
+;; dictionary.  SKKBUF is the buffer where the original SKK dictionary
+;; is visited, KANA is the current entry for STR.  FIRST is t iff this
+;; is called at top level.
+
+(defun skkdic-breakup-string (skkbuf kana str from to &optional first)
+  (let ((len (- to from)))
+    (or (and (>= len (* skkdic-jbytes 2))
+             (let ((min-idx (+ from (* skkdic-jbytes 2)))
+                   (idx (if first (- to skkdic-jbytes) to))
+                   (found nil))
+               (while (and (not found) (>= idx min-idx))
+                 (let ((kana2-list (skkdic-get-entry
+                                    (substring str from idx)
+                                    skkdic-word-list)))
+                   (if (or (and (consp kana2-list)
+                                (let ((kana-len (length kana))
+                                      kana2)
+                                  (catch 'skkdic-tag
+                                    (while kana2-list
+                                      (setq kana2 (car kana2-list))
+                                      (if (string-match kana2 kana)
+                                          (throw 'skkdic-tag t))
+                                      (setq kana2-list (cdr kana2-list)))))
+                                (or (= idx to)
+                                    (skkdic-breakup-string skkbuf kana str
+                                                           idx to)))
+                           (and (stringp kana2-list)
+                                (string-match kana2-list kana)))
+                       (setq found t)
+                     (setq idx (- idx skkdic-jbytes)))))
+               found))
+        (and first
+             (> len (* skkdic-jbytes 2))
+             (let ((kana2 (skkdic-get-entry
+                           (substring str from (+ from skkdic-jbytes))
+                           skkdic-prefix-list)))
+               (and (stringp kana2)
+                    (eq (string-match kana2 kana) 0)))
+             (skkdic-breakup-string skkbuf kana str (+ from skkdic-jbytes) to))
+        (and (not first)
+             (>= len skkdic-jbytes)
+             (let ((kana2-list (skkdic-get-entry
+                                (substring str from to)
+                                skkdic-postfix-list)))
+               (and (consp kana2-list)
+                    (let (kana2)
+                      (catch 'skkdic-tag
+                        (while kana2-list
+                          (setq kana2 (car kana2-list))
+                          (if (string= kana2
+                                       (substring kana (- (length kana2))))
+                              (throw 'skkdic-tag t))
+                          (setq kana2-list (cdr kana2-list)))))))))))
+
+;; Return list of candidates which excludes some from CANDIDATES.
+;; Excluded candidates can be derived from another entry.
+
+(defun skkdic-reduced-candidates (skkbuf kana candidates)
+  (let (elt l)
+    (while candidates
+      (setq elt (car candidates))
+      (if (or (= (length elt) skkdic-jbytes)
+              (and (string-match "^\\cj" elt)
+                   (not (skkdic-breakup-string skkbuf kana elt 0 (length elt)
+                                               'first))))
+          (setq l (cons elt l)))
+      (setq candidates (cdr candidates)))
+    (nreverse l)))
+
+(defconst skkdic-okuri-nasi-entries (list nil))
+(defconst skkdic-okuri-nasi-entries-count 0)
+
+(defun skkdic-collect-okuri-nasi ()
+  (message "Collecting OKURI-NASI entries ...")
+  (save-excursion
+    (let ((prev-ratio 0)
+          ratio)
+      (while (re-search-forward "^\\(\\cH+\\) \\(/\\cj.*\\)/$" nil t)
+        (let ((kana (match-string 1))
+              (candidates (skkdic-get-candidate-list (match-beginning 2)
+                                                     (match-end 2))))
+          (setq skkdic-okuri-nasi-entries
+                (cons (cons kana candidates) skkdic-okuri-nasi-entries)
+                skkdic-okuri-nasi-entries-count
+                (1+ skkdic-okuri-nasi-entries-count))
+          (setq ratio (floor (/ (* (point) 100.0) (point-max))))
+          (if (/= ratio prev-ratio)
+              (progn
+                (message "collected %2d%% %s ..." ratio kana)
+                (setq prev-ratio ratio)))
+          (while candidates
+            (let ((entry (lookup-nested-alist (car candidates)
+                                              skkdic-word-list nil nil t)))
+              (if (consp (car entry))
+                  (setcar entry (cons kana (car entry)))
+                (set-nested-alist (car candidates) (list kana)
+                                  skkdic-word-list)))
+            (setq candidates (cdr candidates))))))))
+
+(defun skkdic-convert-okuri-nasi (skkbuf buf)
+  (message "Processing OKURI-NASI entries ...")
+  (save-excursion
+    (set-buffer buf)
+    (insert ";; Setting okuri-nasi entries.\n"
+            "(skkdic-set-okuri-nasi\n")
+    (let ((l (nreverse skkdic-okuri-nasi-entries))
+          (count 0)
+          (prev-ratio 0)
+          ratio)
+      (while l
+        (let ((kana (car (car l)))
+              (candidates (cdr (car l))))
+          (setq ratio (/ (* count 1000) skkdic-okuri-nasi-entries-count)
+                count (1+ count))
+          (if (/= prev-ratio (/ ratio 10))
+              (progn
+                (message "processed %2d%% %s ..." (/ ratio 10) kana)
+                (setq prev-ratio (/ ratio 10))))
+          (if (setq candidates
+                    (skkdic-reduced-candidates skkbuf kana candidates))
+              (progn
+                (insert "\"" kana)
+                (while candidates
+                  (insert " " (car candidates))
+                  (setq candidates (cdr candidates)))
+                (insert "\"\n"))))
+        (setq l (cdr l))))
+    (insert ")\n\n")))
+
+(defun skkdic-convert (filename &optional dirname)
+  "Convert SKK dictionary of FILENAME into the file \"skkdic.el\".
+Optional argument DIRNAME if specified is the directory name under which
+the generated \"skkdic.el\" is saved."
+  (interactive "FSKK dictionary file: ")
+  (message "Reading file \"%s\" ..." filename)
+  (let ((skkbuf(find-file-noselect (expand-file-name filename)))
+        (buf (get-buffer-create "*skkdic-work*")))
+    (save-excursion
+      ;; Setup and generate the header part of working buffer.
+      (set-buffer buf)
+      (erase-buffer)
+      (buffer-disable-undo)
+      (insert ";; skkdic.el -- dictionary for Japanese input method\n"
+              ";;\tGenerated by the command `skkdic-convert'\n"
+              ";;\tDate: " (current-time-string) "\n"
+              ";;\tOriginal SKK dictionary file: "
+              (file-name-nondirectory filename)
+              "\n\n"
+              ";;; Comment:\n\n"
+              ";; Do byte-compile this file again after any modification.\n\n"
+              ";;; Start of the header of the original TIT dictionary.\n\n")
+      (set-buffer skkbuf)
+      (widen)
+      (goto-char 1)
+      (let (pos)
+        (search-forward ";; okuri-ari")
+        (forward-line 1)
+        (setq pos (point))
+        (set-buffer buf)
+        (insert-buffer-substring skkbuf 1 pos))
+      (insert "\n"
+              ";;; Code:\n\n")
+
+      ;; Generate the body part of working buffer.
+      (set-buffer skkbuf)
+      (let ((from (point))
+            to)
+        ;; Convert okuri-ari entries.
+        (search-forward ";; okuri-nasi")
+        (beginning-of-line)
+        (setq to (point))
+        (narrow-to-region from to)
+        (skkdic-convert-okuri-ari skkbuf buf)
+        (widen)
+
+        ;; Convert okuri-nasi postfix entries.
+        (goto-char to)
+        (forward-line 1)
+        (setq from (point))
+        (re-search-forward "^\\cH")
+        (setq to (match-beginning 0))
+        (narrow-to-region from to)
+        (skkdic-convert-postfix skkbuf buf)
+        (widen)
+
+        ;; Convert okuri-nasi prefix entries.
+        (goto-char to)
+        (skkdic-convert-prefix skkbuf buf)
+
+        ;; 
+        (skkdic-collect-okuri-nasi)
+
+        ;; Convert okuri-nasi general entries.
+        (skkdic-convert-okuri-nasi skkbuf buf)
+
+        ;; Postfix
+        (save-excursion
+          (set-buffer buf)
+          (goto-char (point-max))
+          (insert ";;\n(provide 'skkdic)\n\n;; skkdic.el ends here\n")))
+
+      ;; Save the working buffer.
+      (set-buffer buf)
+      (set-visited-file-name (expand-file-name skkdic-filename dirname) t)
+      (set-buffer-file-coding-system 'coding-system-iso-2022-7-short)
+      (save-buffer 0))
+    (kill-buffer skkbuf)
+    (switch-to-buffer buf)))
+
+(defun batch-skkdic-convert ()
+  "Run `skkdic-convert' on the files remaining on the command line.
+Use this from the command line, with `-batch';
+it won't work in an interactive Emacs.
+For example, invoke:
+  % emacs -batch -l skkconv -f batch-skkdic-convert SKK-JISYO.L
+to generate  \"skkdic.el\" from SKK dictionary file \"SKK-JISYO.L\".
+To get complete usage, invoke:
+ % emacs -batch -l skkconv -f batch-skkdic-convert -h"
+  (defvar command-line-args-left)       ; Avoid compiler warning.
+  (if (not noninteractive)
+      (error "`batch-skkdic-convert' should be used only with -batch"))
+  (if (string= (car command-line-args-left) "-h")
+      (progn
+        (message "To convert SKK-JISYO.L into skkdic.el:")
+        (message "  %% emacs -batch -l skkdic-conv -f batch-skkdic-convert SKK-JISYO.L")
+        (message "To convert SKK-JISYO.L into DIR/skkdic.el:")
+        (message "  %% emacs -batch -l skkdic-conv -f batch-skkdic-convert -dir DIR SKK-JISYO.L"))
+    (let (targetdir filename)
+      (if (string= (car command-line-args-left) "-dir")
+          (progn
+            (setq command-line-args-left (cdr command-line-args-left))
+            (setq targetdir (expand-file-name (car command-line-args-left)))
+            (setq command-line-args-left (cdr command-line-args-left))))
+      (setq filename (expand-file-name (car command-line-args-left)))
+      (message "Converting %s to skkdic.el ..." filename)
+      (message "It takes around 10 minutes even on Sun SS20.")
+      (skkdic-convert filename targetdir)
+      (message "Do byte-compile the created file by:")
+      (message "  %% emacs -batch -l skkdic-cnv -f batch-byte-compile skkdic.el")
+      (message  "                 ^^^^^^^^^^^^^ -- Don't forget this option!")
+      ))
+  (kill-emacs 0))
+
+
+;; The following macros are expanded at byte-compiling time so that
+;; compiled code can be loaded quickly.
+
+(defun skkdic-get-kana-compact-codes (kana)
+  (let* ((len (length kana))
+         (vec (make-vector (/ (+ len (1- skkdic-jbytes)) skkdic-jbytes) 0))
+         (i 0)
+         ch)
+    (while (< i len)
+      (setq ch (sref kana i))
+      (aset vec (/ i 3)
+            (if (< ch 128)              ; CH is an ASCII letter for OKURIGANA,
+                (- ch)                  ;  represented by a negative code.
+              (if (= ch ?$B!<(B)              ; `$B!<(B' is represented by 0.
+                  0
+                (- (nth 2 (split-char ch)) 32))))
+      (setq i (+ i 3)))
+    vec))
+
+(defun skkdic-extract-conversion-data (entry)
+  (string-match "^\\cH+[a-z]* " entry)
+  (let ((kana (substring entry (match-beginning 0) (1- (match-end 0))))
+        (i (match-end 0))
+        candidates)
+    (while (string-match "[^ ]+" entry i)
+      (setq candidates (cons (match-string 0 entry) candidates))
+      (setq i (match-end 0)))
+    (cons (skkdic-get-kana-compact-codes kana) candidates)))
+
+(defmacro skkdic-set-okuri-ari (&rest entries)
+  `(defconst skkdic-okuri-ari
+     ',(let ((l entries)
+             (map '(skkdic-okuri-ari))
+             entry)
+         (while l
+           (setq entry (skkdic-extract-conversion-data (car l)))
+           (set-nested-alist (car entry) (cdr entry) map)
+           (setq l (cdr l)))
+         map)))
+
+(defmacro skkdic-set-postfix (&rest entries)
+  `(defconst skkdic-postfix
+     ',(let ((l entries)
+             (map '(nil))
+             (longest 1)
+             len entry)
+         (while l
+           (setq entry (skkdic-extract-conversion-data (car l)))
+           (setq len (length (car entry)))
+           (if (> len longest)
+               (setq longest len))
+           (let ((entry2 (lookup-nested-alist (car entry) map nil nil t)))
+             (if (consp (car entry2))
+                 (let ((conversions (cdr entry)))
+                   (while conversions
+                     (if (not (member (car conversions) (car entry2)))
+                         (setcar entry2 (cons (car conversions) (car entry2))))
+                     (setq conversions (cdr conversions))))
+               (set-nested-alist (car entry) (cdr entry) map)))
+           (setq l (cdr l)))
+         (setcar map longest)
+         map)))
+
+(defmacro skkdic-set-prefix (&rest entries)
+  `(defconst skkdic-prefix
+     ',(let ((l entries)
+             (map '(nil))
+             (longest 1)
+             len entry)
+         (while l
+           (setq entry (skkdic-extract-conversion-data (car l)))
+           (setq len (length (car entry)))
+           (if (> len longest)
+               (setq longest len))
+           (let ((entry2 (lookup-nested-alist (car entry) map len nil t)))
+             (if (consp (car entry2))
+                 (let ((conversions (cdr entry)))
+                   (while conversions
+                     (if (not (member (car conversions) (car entry2)))
+                         (setcar entry2 (cons (car conversions) (car entry2))))
+                     (setq conversions (cdr conversions))))
+               (set-nested-alist (car entry) (cdr entry) map len)))
+           (setq l (cdr l)))
+         (setcar map longest)
+         map)))
+
+(defmacro skkdic-set-okuri-nasi (&rest entries)
+  `(defconst skkdic-okuri-nasi
+     ',(let ((l entries)
+             (map '(skdic-okuri-nasi))
+             (count 0)
+             entry)
+         (while l
+           (setq count (1+ count))
+           (if (= (% count 10) 0)
+               (message (format "%d entries" count)))
+           (setq entry (skkdic-extract-conversion-data (car l)))
+           (set-nested-alist (car entry) (cdr entry) map)
+           (setq l (cdr l)))
+         map)))
+
+;; skkdic-cnv.el ends here
diff --git a/lisp/international/skkdic-utl.el b/lisp/international/skkdic-utl.el
new file mode 100644
index 00000000000..d5b0c1e6149
--- /dev/null
+++ b/lisp/international/skkdic-utl.el
@@ -0,0 +1,198 @@
+;; skkdic-utl.el -- utility functions for handling skkdic.el
+
+;; Copyright (C) 1995 Free Software Foundation, Inc.
+;; Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+;; Keywords: mule, multilingual, Japanese, SKK
+
+;; 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.
+
+;;; Commentary:
+
+;; SKK is a free Japanese input method running on Mule created by
+;; Masahiko Sato <masahiko@sato.riec.tohoku.ac.jp>.  A dictionary of
+;; SKK can be converted by `skkdic-convert' (skkdic-conv.el) to a file
+;; "skkdic.el" in which the dictionary entries are defined in the
+;; format which can be handled by the following functions.
+
+;;; Code:
+
+(defvar skkdic-okuri-ari nil
+  "OKURI-ARI entries of SKK dictionary.")
+(defvar skkdic-postfix nil
+  "POSTFIX entries of SKK dictionary.")
+(defvar skkdic-prefix nil
+  "PREFIX entries of SKK dictionary.")
+(defvar skkdic-okuri-nasi nil
+  "OKURI-NASI entries of SKK dictionary.")
+
+;; Alist of Okuriganas vs trailing ASCII letters in OKURI-ARI entry.
+(defconst skkdic-okurigana-table
+  '((?$B$!(B . ?a) (?$B$"(B . ?a) (?$B$#(B . ?i) (?$B$$(B . ?i) (?$B$%(B . ?u)
+    (?$B$&(B . ?u) (?$B$'(B . ?e) (?$B$((B . ?e) (?$B$)(B . ?o) (?$B$*(B . ?o)
+    (?$B$+(B . ?k) (?$B$,(B . ?g) (?$B$-(B . ?k) (?$B$.(B . ?g) (?$B$/(B . ?k)
+    (?$B$0(B . ?g) (?$B$1(B . ?k) (?$B$2(B . ?g) (?$B$3(B . ?k) (?$B$4(B . ?g)
+    (?$B$5(B . ?s) (?$B$6(B . ?z) (?$B$7(B . ?s) (?$B$8(B . ?j) (?$B$9(B . ?s)
+    (?$B$:(B . ?z) (?$B$;(B . ?s) (?$B$<(B . ?z) (?$B$=(B . ?s) (?$B$>(B . ?z)
+    (?$B$?(B . ?t) (?$B$@(B . ?d) (?$B$A(B . ?t) (?$B$B(B . ?d) (?$B$C(B . ?t)
+    (?$B$D(B . ?t) (?$B$E(B . ?d) (?$B$F(B . ?t) (?$B$G(B . ?d) (?$B$H(B . ?t) (?$B$I(B . ?d)
+    (?$B$J(B . ?n) (?$B$K(B . ?n) (?$B$L(B . ?n) (?$B$M(B . ?n) (?$B$N(B . ?n)
+    (?$B$O(B . ?h) (?$B$P(B . ?b) (?$B$Q(B . ?p) (?$B$R(B . ?h) (?$B$S(B . ?b)
+    (?$B$T(B . ?p) (?$B$U(B . ?h) (?$B$V(B . ?b) (?$B$W(B . ?p) (?$B$X(B . ?h)
+    (?$B$Y(B . ?b) (?$B$Z(B . ?p) (?$B$[(B . ?h) (?$B$\(B . ?b) (?$B$](B . ?p)
+    (?$B$^(B . ?m) (?$B$_(B . ?m) (?$B$`(B . ?m) (?$B$a(B . ?m) (?$B$b(B . ?m)
+    (?$B$c(B . ?y) (?$B$d(B . ?y) (?$B$e(B . ?y) (?$B$f(B . ?y) (?$B$g(B . ?y) (?$B$h(B . ?y)
+    (?$B$i(B . ?r) (?$B$j(B . ?r) (?$B$k(B . ?r) (?$B$l(B . ?r) (?$B$m(B . ?r)
+    (?$B$o(B . ?w) (?$B$p(B . ?w) (?$B$q(B . ?w) (?$B$r(B . ?w)
+    (?$B$s(B . ?n)
+    ))
+
+(defconst skkdic-jbytes
+  (charset-bytes 'japanese-jisx0208))
+
+(defun skkdic-merge-head-and-tail (heads tails postfix)
+  (let ((min-len (* skkdic-jbytes 2))
+        l)
+    (while heads
+      (if (or (not postfix)
+              (>= (length (car heads)) min-len))
+          (let ((tail tails))
+            (while tail
+              (if (or postfix
+                      (>= (length (car tail)) min-len))
+                  (setq l (cons (concat (car heads) (car tail)) l)))
+              (setq tail (cdr tail)))))
+      (setq heads (cdr heads)))
+    l))
+
+(defconst skkdic-jisx0208-hiragana-block (nth 1 (split-char ?$B$"(B)))
+
+(defun skkdic-lookup-key (seq len &optional postfix)
+  "Return a list of conversion string for sequence SEQ of length LEN.
+
+SEQ is a vector of Kana characters to be converted by SKK dictionary.
+If LEN is shorter than the length of KEYSEQ, the first LEN keys in SEQ
+are took into account.
+
+Postfixes are handled only if the optional argument POSTFIX is non-nil."
+  (or skkdic-okuri-nasi
+      (condition-case err
+          (load-library "skk/skkdic")
+        (error (ding)
+               (with-output-to-temp-buffer "*Help*"
+                 (princ "The library `skkdic' can't be loaded.
+
+The most common case is that you have not yet installed the library
+included in LEIM (Libraries of Emacs Input Method) which is
+distributed separately from Emacs.
+
+LEIM is available from the same ftp directory as Emacs."))
+               (signal (car err) (cdr err)))))
+
+  (let ((vec (make-vector len 0))
+        (i 0)
+        entry)
+    ;; At first, generate vector VEC from SEQ for looking up SKK
+    ;; alists.  Nth element in VEC corresponds to Nth element in SEQ.
+    ;; The values are decided as follows.
+    ;;   If SEQ[N] is `$B!<(B', VEC[N] is 0,
+    ;;   Else if SEQ[N] is a Hiragana character, VEC[N] is:
+    ;;     ((The 2nd position code o SEQ[N]) - 32),
+    ;;   ELse VEC[N] is 128.
+    (while (< i len)
+      (let ((ch (aref seq i))
+            elts)
+        (if (= ch ?$B!<(B)
+            (aset vec i 0)
+          (setq elts (split-char ch))
+          (if (and (eq (car elts) 'japanese-jisx0208)
+                   (= (nth 1 elts) skkdic-jisx0208-hiragana-block))
+              (aset vec i (- (nth 2 elts) 32))
+            (aset vec i 128))))
+      (setq i (1+ i)))
+
+    ;; Search OKURI-NASI entries.
+    (setq entry (lookup-nested-alist vec skkdic-okuri-nasi len 0 t))
+    (if (consp (car entry))
+        (setq entry (copy-sequence (car entry)))
+      (setq entry nil))
+
+    (if postfix
+        ;; Search OKURI-NASI entries with postfixes.
+        (let ((break (max (- len (car skkdic-postfix)) 1))
+              entry-head entry-postfix entry2)
+          (while (< break len)
+            (if (and (setq entry-head
+                           (lookup-nested-alist vec skkdic-okuri-nasi
+                                                break 0 t))
+                     (consp (car entry-head))
+                     (setq entry-postfix
+                           (lookup-nested-alist vec skkdic-postfix
+                                                len break t))
+                     (consp (car entry-postfix))
+                     (setq entry2 (skkdic-merge-head-and-tail
+                                   (car entry-head) (car entry-postfix) t)))
+                (if entry
+                    (nconc entry entry2)
+                  (setq entry entry2)))
+            (setq break (1+ break)))))
+
+    ;; Search OKURI-NASI entries with prefixes.
+    (let ((break (min (car skkdic-prefix) (- len 2)))
+          entry-prefix entry-tail entry2)
+      (while (> break 0)
+        (if (and (setq entry-prefix
+                       (lookup-nested-alist vec skkdic-prefix break 0 t))
+                 (consp (car entry-prefix))
+                 (setq entry-tail
+                       (lookup-nested-alist vec skkdic-okuri-nasi len break t))
+                 (consp (car entry-tail))
+                 (setq entry2 (skkdic-merge-head-and-tail
+                               (car entry-prefix) (car entry-tail) nil)))
+            (if entry
+                (nconc entry entry2)
+              (setq entry entry2)))
+        (setq break (1- break))))
+
+    ;; Search OKURI-ARI entries.
+    (let ((okurigana (assq (aref seq (1- len)) skkdic-okurigana-table))
+          orig-element entry2)
+      (if okurigana
+          (progn
+            (setq orig-element (aref vec (1- len)))
+            (aset vec (1- len) (- (cdr okurigana)))
+            (if (and (setq entry2 (lookup-nested-alist vec skkdic-okuri-ari
+                                                       len 0 t))
+                     (consp (car entry2)))
+                (progn
+                  (setq entry2 (copy-sequence (car entry2)))
+                  (let ((l entry2)
+                        (okuri (char-to-string (aref seq (1- len)))))
+                    (while l
+                      (setcar l (concat (car l) okuri))
+                      (setq l (cdr l)))
+                    (if entry
+                        (nconc entry entry2)
+                      (setq entry entry2)))))
+            (aset vec (1- len) orig-element))))
+
+    entry))
+
+;;
+(provide 'skkdic-utl)
+
+;; skkdic-utl.el ends here
diff --git a/lisp/international/titdic-cnv.el b/lisp/international/titdic-cnv.el
new file mode 100644
index 00000000000..382a666735f
--- /dev/null
+++ b/lisp/international/titdic-cnv.el
@@ -0,0 +1,403 @@
+;;; titdic-cnv.el --- convert TIT dictionary to Quail package
+
+;; Copyright (C) 1995 Free Software Foundation, Inc.
+;; Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+;; Keywords: Quail, TIT, cxterm
+
+;; 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.
+
+;;; Comments:
+
+;; Convert TIT format dictionary (of cxterm) to quail-package.
+;;
+;; Usage (within Emacs):
+;;      M-x titdic-convert<CR>TIT-FILE-NAME<CR>
+;; Usage (from shell):
+;;      % emacs -batch -l titdic-convert -f batch-titdic-convert\
+;;              [-dir DIR] [DIR | FILE] ...
+;;
+;; When you run titdic-convert within Emacs, you have a chance to
+;; modify arguments of `quail-define-package' before saving the
+;; converted file.  For instance, you are likely to modify TITLE,
+;; DOCSTRING, and KEY-BINDINGS.
+
+;; TIT dictionary file (*.tit) is a line-oriented text (English,
+;; Chinese, Japanese, and Korean) file.  The whole file contains of
+;; two parts, the definition part (`header' here after) followed by
+;; the dictionary part (`body' here after).  All lines begin with
+;; leading '#' are ignored.
+;;
+;; Each line in the header part has two fields, KEY and VALUE.  These
+;; fields are separated by one or more white characters.
+;;
+;; Each line in the body part has two fields, KEYSEQ and TRANSLATIONS.
+;; These fields are separated by one or more white characters.
+;;
+;; See the manual page of `tit2cit' of cxterm distribution for more
+;; detail.
+
+;;; Code:
+
+(require 'quail)
+
+;; List of values of key "ENCODE:" and the corresponding Emacs'
+;; coding-system and language environment name.
+(defvar tit-encode-list
+  '(("GB" coding-system-euc-china "Chinese-GB")
+    ("BIG5" coding-system-big5 "Chinese-BIG5")
+    ("JIS" coding-system-euc-japan "Japanese")
+    ("KS" coding-system-euc-korea "Korean")))
+
+;; Return a value of the key in the current line.
+(defsubst tit-read-key-value ()
+  (if (looking-at "[^ \t\n]+")
+      (car (read-from-string (concat "\"" (match-string 0) "\"")))))
+
+;; Return an appropriate quail-package filename from FILENAME (TIT
+;; dictionary filename).  For instance, ".../ZOZY.tit" -> "zozy.el".
+(defun tit-make-quail-package-name (filename &optional dirname)
+  (expand-file-name
+   (concat (downcase (file-name-nondirectory (substring filename 0 -4))) ".el")
+   dirname))
+
+;; This value is t if we are processing phrase dictionary.
+(defvar tit-phrase nil)
+(defvar tit-encode nil)
+(defvar tit-default-encode "GB")
+
+;; Generate elements of KEY-BINDINGS arg for `quail-define-package' so
+;; that each characters in KEYS invokes FUNCTION-SYMBOL.
+(defun tit-generate-key-bindings (keys function-symbol)
+  (let ((len (length keys))
+        (i 0)
+        key)
+    (while (< i len)
+      (setq key (aref keys i))
+      (indent-to 3)
+      (if (< key ?\ )
+          (if (eq (lookup-key quail-translation-keymap (char-to-string key))
+                  'quail-execute-non-quail-command)
+              (insert (format "(\"\\C-%c\" . %s)\n"
+                              (+ key ?@) function-symbol)))
+        (if (< key 127)
+            (insert (format "(\"%c\" . %s)\n" key function-symbol))
+          (insert (format "(\"\\C-?\" . %s)\n" function-symbol))))
+      (setq i (1+ i)))))
+
+;; Analyze header part of TIT dictionary and generate an appropriate
+;; `quail-define-package' function call.
+(defun tit-process-header (filename)
+  (message "Processing header part...")
+  (goto-char (point-min))
+
+  (let (;; TIT keywords and the corresponding default values.
+        (tit-multichoice t)
+        (tit-prompt "")
+        (tit-comments nil)
+        (tit-backspace "\010\177")
+        (tit-deleteall "\015\025")
+        (tit-moveright ".>")
+        (tit-moveleft ",<")
+        (tit-keyprompt nil))
+    ;; At first, collect information from the header.
+    (while (not (eobp))
+      (insert ";; ")
+      (let ((ch (following-char)))
+        (cond ((= ch ?C)                ; COMMENT
+               (cond ((looking-at "COMMENT")
+                      (let ((pos (match-end 0)))
+                        (end-of-line)
+                        (while (re-search-backward "[\"\\]" pos t)
+                          (insert "\\")
+                          (forward-char -1))
+                        (end-of-line)
+                        (setq tit-comments (cons (buffer-substring pos (point))
+                                                 tit-comments))))))
+              ((= ch ?M)                ; MULTICHOICE, MOVERIGHT, MOVELEFT
+               (cond ((looking-at "MULTICHOICE:[ \t]*")
+                      (goto-char (match-end 0))
+                      (setq tit-multichoice (looking-at "YES")))
+                     ((looking-at "MOVERIGHT:[ \t]*")
+                      (goto-char (match-end 0))
+                      (setq tit-moveright (tit-read-key-value)))
+                     ((looking-at "MOVELEFT:[ \t]*")
+                      (goto-char (match-end 0))
+                      (setq tit-moveleft (tit-read-key-value)))))
+              ((= ch ?P)                ; PROMPT
+               (cond ((looking-at "PROMPT:[ \t]*")
+                      (goto-char (match-end 0))
+                      (setq tit-prompt (tit-read-key-value)))))
+              ((= ch ?B)                ; BACKSPACE, BEGINDICTIONARY,
+                                        ; BEGINPHRASE
+               (cond ((looking-at "BACKSPACE:[ \t]*")
+                      (goto-char (match-end 0))
+                      (setq tit-backspace (tit-read-key-value)))
+                     ((looking-at "BEGINDICTIONARY")
+                      (setq tit-phrase nil))
+                     ((looking-at "BEGINPHRASE")
+                      (setq tit-phrase t))))
+              ((= ch ?K)                ; KEYPROMPT
+               (cond ((looking-at "KEYPROMPT(\\(.*\\)):[ \t]*")
+                      (let ((key-char (match-string 1)))
+                        (goto-char (match-end 0))
+                        (setq tit-keyprompt
+                              (cons (cons key-char (tit-read-key-value))
+                                    tit-keyprompt))))))))
+      (forward-line 1))
+  
+    ;; Then, generate header part of the Quail package.
+    (goto-char (point-min))
+    (insert ";; Quail package `"
+            (substring (file-name-nondirectory buffer-file-name) 0 -3)
+            "' generated by the command `titdic-convert'\n"
+            ";;\tDate: " (current-time-string) "\n"
+            ";;\tOriginal TIT dictionary file: "
+            (file-name-nondirectory filename)
+            "\n\n"
+            ";;; Comment:\n\n"
+            ";; Do byte-compile this file again after any modification.\n\n"
+            ";;; Start of the header of original TIT dictionary.\n\n")
+
+    (goto-char (point-max))
+    (insert "\n"
+            ";;; End of the header of original TIT dictionary.\n\n"
+            ";;; Code:\n\n"
+            "(require 'quail)\n\n")
+
+    (insert "(quail-define-package ")
+    ;; Args NAME, LANGUAGE, TITLE
+    (insert
+     "\""
+     (concat "quail-"
+             (substring (file-name-nondirectory buffer-file-name) 0 -3))
+     "\" \"" (nth 2 (assoc tit-encode tit-encode-list))
+     "\" \""
+     (if (string-match "[:$A!K$(0!(!J(B]+\\([^:$A!K$(0!(!K(B]+\\)" tit-prompt)
+         (substring tit-prompt (match-beginning 1) (match-end 1))
+       tit-prompt)
+     "\"\n")
+
+    ;; Arg GUIDANCE
+    (if tit-keyprompt
+        (progn
+          (insert " '(")
+          (while tit-keyprompt
+            (indent-to 3)
+            (insert (format "(%d . \"%s\")\n"
+                            (string-to-char (car (car tit-keyprompt)))
+                            (cdr (car tit-keyprompt))))
+            (setq tit-keyprompt (cdr tit-keyprompt)))
+          (forward-char -1)
+          (insert ")")
+          (forward-char 1))
+      (insert " t\n"))
+
+    ;; Arg DOCSTRING
+    (insert "\"" tit-prompt "\n")
+    (let ((l (nreverse tit-comments)))
+      (while l
+        (insert (format "%s\n" (car l)))
+        (setq l (cdr l))))
+    (insert "\"\n")
+
+    ;; Arg KEY-BINDINGS
+    (insert " '(")
+    (tit-generate-key-bindings tit-backspace 'quail-delete-last-char)
+    (tit-generate-key-bindings tit-deleteall 'quail-abort-translation)
+    (tit-generate-key-bindings tit-moveright 'quail-next-translation)
+    (tit-generate-key-bindings tit-moveleft 'quail-prev-translation)
+    (forward-char -1)
+    (insert ")")
+    (forward-char 1)
+
+    ;; Args FORGET-TRANSLATION, DETERMINISTIC, KBD-TRANSLATE, SHOW-LAYOUT.
+    ;; The remaining args are all nil.
+    (insert " nil"
+            (if tit-multichoice " nil" " t")
+            (if tit-keyprompt " t t)\n\n" " nil nil)\n\n")))
+
+  ;; Return the position of end of the header.
+  (point-max))
+
+;; Convert body part of TIT dictionary into `quail-define-rules'
+;; function call.
+(defun tit-process-body ()
+  (message "Formatting translation rules...")
+  (let ((enable-multibyte-characters nil)
+        (keyseq "\000")
+        pos)
+    (insert "(quail-define-rules\n")
+    (while (null (eobp))
+      (if (or (= (following-char) ?#) (= (following-char) ?\n))
+          (insert ";; ")
+        (insert "(\"")
+        (setq pos (point))
+        (skip-chars-forward "^ \t")
+        (setq keyseq
+              (concat (regexp-quote (buffer-substring pos (point))) "[ \t]+"))
+        (save-excursion
+          (while (re-search-backward "[\\\"]" pos t)
+            (insert "\\")
+            (forward-char -1)))
+        (insert "\"")
+        (skip-chars-forward " \t")
+
+        ;; Now point is at the start of translations.  Remember it in
+        ;; POS and combine lines of the same key sequence while
+        ;; deleting trailing white spaces and  comments (start with
+        ;; '#').  POS doesn't has to be a marker because we never
+        ;; modify region before POS.
+        (setq pos (point))
+        (if (looking-at "[^ \t]*\\([ \t]*#.*\\)")
+            (delete-region (match-beginning 1) (match-end 1)))
+        (while (and (= (forward-line 1) 0)
+                    (looking-at keyseq))
+          (let ((p (match-end 0)))
+            (skip-chars-backward " \t\n")
+            (delete-region (point) p)
+            (if tit-phrase (insert " "))
+            (if (looking-at "[^ \t]*\\([ \t]*#.*\\)")
+                (delete-region (match-beginning 1) (match-end 1)))
+            ))
+
+        ;; Modify the current line to meet the syntax of Quail package.
+        (goto-char pos)
+        (if tit-phrase
+            (progn
+              ;; PHRASE1 PHRASE2 ... => ["PHRASE1" "PHRASE2" ...]
+              (insert "[\"")
+              (skip-chars-forward "^ \t\n")
+              (while (not (eolp))
+                (insert "\"")
+                (forward-char 1)
+                (insert "\"")
+                (skip-chars-forward "^ \t\n"))
+              (insert "\"])"))
+          ;; TRANSLATIONS => "TRANSLATIONS"
+          (insert "\"")
+          (end-of-line)
+          (insert "\")")))
+      (forward-line 1))
+    (insert ")\n")))
+
+;;;###autoload
+(defun titdic-convert (filename &optional dirname)
+  "Convert a TIT dictionary of FILENAME into a Quail package.
+Optional argument DIRNAME if specified is the directory name under which
+the generated Quail package is saved."
+  (interactive "FTIT dictionary file: ")
+  (let ((buf (get-buffer-create "*tit-work*")))
+    (save-excursion
+      ;; Setup the buffer.
+      (set-buffer buf)
+      (erase-buffer)
+      (let ((coding-system-for-read 'no-conversion))
+        (insert-file-contents (expand-file-name filename)))
+      (set-visited-file-name (tit-make-quail-package-name filename dirname) t)
+      (set-buffer-file-coding-system 'coding-system-iso-2022-7)
+
+      ;; Decode the buffer contents from the encoding specified by a
+      ;; value of the key "ENCODE:".
+      (let (coding-system)
+        (save-excursion
+          (if (search-forward "\nBEGIN" nil t)
+              (let ((limit (point))
+                    slot)
+                (goto-char 1)
+                (if (re-search-forward "^ENCODE:[ \t]*" limit t)
+                    (progn
+                      (goto-char (match-end 0))
+                      (setq tit-encode (tit-read-key-value)))
+                  (setq tit-encode tit-default-encode))
+                (setq slot (assoc tit-encode tit-encode-list))
+                (if slot
+                    (setq coding-system (nth 1 slot))
+                  (error "Invalid ENCODE: value in TIT dictionary")))
+            (error "TIT dictionary doesn't have body part")))
+        (message "Decoding %s..." coding-system)
+        (goto-char 1)
+        (decode-coding-region 1 (point-max) coding-system))
+
+      ;; Set point the starting position of the body part.
+      (goto-char 1)
+      (if (search-forward "\nBEGIN" nil t)
+          (forward-line 1)
+        (error "TIT dictionary can't be decoded correctly"))
+
+      ;; Now process the header and body parts.
+      (goto-char
+       (save-excursion
+         (save-restriction
+           (narrow-to-region 1 (point))
+           (tit-process-header filename))))
+      (tit-process-body))
+
+    (if noninteractive
+        ;; Save the Quail package file.
+        (save-excursion
+          (set-buffer buf)
+          (save-buffer 0))
+      ;; Show the Quail package just generated.
+      (switch-to-buffer buf)
+      (goto-char 1)
+      (message "Save this buffer after you make any modification"))))
+
+;;;###autoload
+(defun batch-titdic-convert ()
+  "Run `titdic-convert' on the files remaining on the command line.
+Use this from the command line, with `-batch';
+it won't work in an interactive Emacs.
+For example, invoke \"emacs -batch -f batch-titdic-convert XXX.tit\" to
+ generate Quail package file \"xxx.el\" from TIT dictionary file \"XXX.tit\".
+To get complete usage, invoke \"emacs -batch -f batch-titdic-convert -h\"."
+  (defvar command-line-args-left)       ; Avoid compiler warning.
+  (if (not noninteractive)
+      (error "`batch-titdic-convert' should be used only with -batch"))
+  (if (string= (car command-line-args-left) "-h")
+      (progn
+        (message "To convert XXX.tit and YYY.tit into xxx.el and yyy.el:")
+        (message "  %% emacs -batch -l titdic-cnv -f batch-titdic-convert XXX.tit YYY.tit")
+        (message "To convert XXX.tit into DIR/xxx.el:")
+        (message "  %% emacs -batch -l titdic-cnv -f batch-titdic-convert -dir DIR XXX.tit"))
+    (let (targetdir filename files file)
+      (if (string= (car command-line-args-left) "-dir")
+          (progn
+            (setq command-line-args-left (cdr command-line-args-left))
+            (setq targetdir (car command-line-args-left))
+            (setq command-line-args-left (cdr command-line-args-left))))
+      (while command-line-args-left
+        (setq filename (expand-file-name (car command-line-args-left)))
+        (if (file-directory-p filename)
+            (progn
+              (message "Converting all tit files in the directory %s" filename)
+              (setq files (directory-files filename t "\\.tit$")))
+          (setq files (list filename)))
+        (while files
+          (setq file (expand-file-name (car files)))
+          (if (file-newer-than-file-p
+               file (tit-make-quail-package-name file targetdir))
+              (progn
+                (message "Converting %s to quail-package..." file)
+                (titdic-convert file targetdir)))
+          (setq files (cdr files)))
+        (setq command-line-args-left (cdr command-line-args-left)))
+      (message "Do byte-compile the created files by:")
+      (message "  %% emacs -batch -f batch-byte-compile XXX.el")))
+  (kill-emacs 0))
+
+;;; titdic-cnv.el ends here
diff --git a/lisp/language/china-util.el b/lisp/language/china-util.el
new file mode 100644
index 00000000000..902919db440
--- /dev/null
+++ b/lisp/language/china-util.el
@@ -0,0 +1,155 @@
+;; china-util.el -- utilities for Chinese
+
+;; Copyright (C) 1995 Free Software Foundation, Inc.
+;; Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+;; Keywords: mule, multilingual, Chinese
+
+;; 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.
+
+;;; Code:
+
+;; Hz/ZW encoding stuffs
+
+;; HZ is an encoding method for Chinese character set GB2312 used
+;; widely in Internet.  It is very similar to 7-bit environment of
+;; ISO-2022.  The difference is that HZ uses the sequence "~{" and
+;; "~}" for designating GB2312 and ASCII respectively, hence, it
+;; doesn't uses ESC (0x1B) code.
+
+;; ZW is another encoding method for Chinese character set GB2312.  It
+;; encodes Chinese characters line by line by starting each line with
+;; the sequence "zW".  It also uses only 7-bit as HZ.
+
+;; ISO-2022 escape sequence to designate GB2312.
+(defvar iso2022-gb-designation "\e$A")
+;; HZ escape sequence to designate GB2312.
+(defvar hz-gb-designnation "~{")
+;; ISO-2022 escape sequence to designate ASCII.
+(defvar iso2022-ascii-designation "\e(B")
+;; HZ escape sequence to designate ASCII.
+(defvar hz-ascii-designnation "~}")
+;; Regexp of ZW sequence to start GB2312.
+(defvar zw-start-gb "^zW")
+;; Regexp for start of GB2312 in an encoding mixture of HZ and ZW.
+(defvar hz/zw-start-gb (concat hz-gb-designnation "\\|" zw-start-gb))
+
+(defvar decode-hz-line-continuation nil
+  "Flag to tell if we should care line continuation convention of Hz.")
+
+;;;###autoload
+(defun decode-hz-region (beg end)
+  "Decode HZ/ZW encoded text in the current region.
+Return the length of resulting text."
+  (interactive "r")
+  (save-excursion
+    (save-restriction
+      (narrow-to-region beg end)
+
+      ;; We, at first, convert HZ/ZW to `coding-system-iso-2022-7',
+      ;; then decode it.
+
+      ;; "~\n" -> "\n"
+      (goto-char (point-min))
+      (while (search-forward "~" nil t)
+        (if (= (following-char) ?\n) (delete-char -1))
+        (if (not (eobp)) (forward-char 1)))
+
+      ;; "^zW...\n" -> Chinese GB2312
+      ;; "~{...~}"  -> Chinese GB2312
+      (goto-char (point-min))
+      (let ((chinese-found nil))
+        (while (re-search-forward hz/zw-start-gb nil t)
+          (if (= (char-after (match-beginning 0)) ?z)
+              ;; ZW -> coding-system-iso-20227-7
+              (progn
+                (delete-char -2)
+                (insert iso2022-gb-designation)
+                (end-of-line)
+                (insert iso2022-ascii-designation))
+            ;; HZ -> coding-system-iso-20227-7
+            (delete-char -2)
+            (insert iso2022-gb-designation)
+            (let ((pos (save-excursion (end-of-line) (point))))
+              (if (search-forward hz-ascii-designnation pos t)
+                  (replace-match iso2022-ascii-designation)
+                (if (not decode-hz-line-continuation)
+                    (insert iso2022-ascii-designation)))))
+          (setq chinese-found t))
+        (if (or chinese-found
+                (let ((enable-multibyte-characters nil))
+                  ;; Here we check if the text contains EUC (China) codes.
+                  ;; If any, we had better decode them also.
+                  (goto-char (point-min))
+                  (re-search-forward "[\240-\377]" nil t))) 
+            (decode-coding-region (point-min) (point-max)
+                                  'coding-system-euc-china)))
+
+      ;; "~~" -> "~"
+      (goto-char (point-min))
+      (while (search-forward "~~" nil t) (delete-char -1))
+      (- (point-max) (point-min)))))
+
+;;;###autoload
+(defun decode-hz-buffer ()
+  "Decode HZ/ZW encoded text in the current buffer."
+  (interactive)
+  (decode-hz-region (point-min) (point-max)))
+
+;;;###autoload
+(defun encode-hz-region (beg end)
+  "Encode the text in the current region to HZ.
+Return the length of resulting text."
+  (interactive "r")
+  (save-excursion
+    (save-restriction
+      (narrow-to-region beg end)
+
+      ;; "~" -> "~~"
+      (goto-char (point-min))
+      (while (search-forward "~" nil t) (insert ?~))
+
+      ;; Chinese GB2312 -> "~{...~}"
+      (goto-char (point-min))
+      (if (re-search-forward "\\cc" nil t)
+          (let ((enable-multibyte-characters nil)
+                pos)
+            (goto-char (setq pos (match-beginning 0)))
+            (encode-coding-region pos (point-max) 'coding-system-iso-2022-7)
+            (goto-char pos)
+            (while (search-forward iso2022-gb-designation nil t)
+              (delete-char -3)
+              (insert hz-gb-designnation))
+            (goto-char pos)
+            (while (search-forward iso2022-ascii-designation nil t)
+              (delete-char -3)
+              (insert hz-ascii-designnation))))
+      (- (point-max) (point-min)))))
+
+;;;###autoload
+(defun encode-hz-buffer ()
+  "Encode the text in the current buffer to HZ."
+  (interactive)
+  (encode-hz-region (point-min) (point-max)))
+
+;;
+(provide 'language/china-util)
+
+;;; Local Variables:
+;;; generated-autoload-file: "../loaddefs.el"
+;;; End:
+;;; china-util.el ends here
diff --git a/lisp/language/chinese.el b/lisp/language/chinese.el
new file mode 100644
index 00000000000..5e90963d11b
--- /dev/null
+++ b/lisp/language/chinese.el
@@ -0,0 +1,236 @@
+;;; chinese.el --- Support for Chinese
+
+;; Copyright (C) 1995 Free Software Foundation, Inc.
+;; Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+;; Keywords: multilingual, Chinese
+
+;; 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.
+
+;;; Commentary:
+
+;; For Chinese, three character sets GB2312, BIG5, and CNS11643 are
+;; supported.
+
+;;; Code:
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; Chinese (general)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(make-coding-system
+ 'coding-system-iso-2022-cn 2 ?C
+ "Coding system ISO-2022-CN for Chinese (GB and CNS character sets)."
+ '(ascii
+   (nil chinese-gb2312 chinese-cns11643-1)
+   (nil chinese-cns11643-2)
+   (nil chinese-cns11643-3 chinese-cns11643-4 chinese-cns11643-5
+        chinese-cns11643-6 chinese-cns11643-7)
+   nil ascii-eol ascii-cntl seven locking-shift single-shift))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; Chinese GB2312 (simplified) 
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(make-coding-system
+ 'coding-system-euc-china 2 ?C
+ "Coding-system of Chinese EUC (so called GB Encoding)."
+ '((ascii t) chinese-gb2312 chinese-sisheng nil
+   nil ascii-eol ascii-cntl nil nil single-shift nil))
+
+(make-coding-system
+ 'coding-system-hz 0 ?z
+ "Codins-system of Hz/ZW used for Chinese (GB)."
+ nil)
+(put 'coding-system-hz 'post-read-conversion 'post-read-decode-hz)
+(put 'coding-system-hz 'pre-write-conversion 'pre-write-encode-hz)
+
+(defun post-read-decode-hz (len)
+  (let ((pos (point)))
+    (decode-hz-region pos (+ pos len))))
+
+(defun pre-write-encode-hz (from to)
+  (let ((buf (current-buffer))
+        (work (get-buffer-create " *pre-write-encoding-work*")))
+    (set-buffer work)
+    (widen)
+    (erase-buffer)
+    (insert-buffer-substring buf from to)
+    (encode-hz-region 1 (point-max))
+    nil))
+
+(register-input-method
+ "Chinese-GB" '("quail-ccdospy" quail-use-package "quail/ccdospy"))
+(register-input-method
+ "Chinese-GB" '("quail-ctlau" quail-use-package "quail/ctlau"))
+(register-input-method
+ "Chinese-GB" '("quail-punct" quail-use-package "quail/punct"))
+(register-input-method
+ "Chinese-GB" '("quail-qj" quail-use-package "quail/qj"))
+(register-input-method
+ "Chinese-GB" '("quail-sw" quail-use-package "quail/sw"))
+(register-input-method
+ "Chinese-GB" '("quail-ziranma" quail-use-package "quail/ziranma"))
+(register-input-method
+ "Chinese-GB" '("quail-tonepy" quail-use-package "quail/tonepy"))
+(register-input-method
+ "Chinese-GB" '("quail-py" quail-use-package "quail/py"))
+
+(defun setup-chinese-gb-environment ()
+  (setq primary-language "Chinese-GB")
+
+  (setq coding-category-iso-8-2 'coding-system-euc-china)
+  (setq coding-category-iso-else 'coding-system-iso-2022-cn)
+
+  (set-coding-priority
+   '(coding-category-iso-7
+     coding-category-iso-else
+     coding-category-iso-8-2
+     coding-category-big5
+     coding-category-iso-8-1
+     coding-category-internal
+     ))
+
+  (setq-default buffer-file-coding-system 'coding-system-euc-china)
+  (set-terminal-coding-system 'coding-system-euc-china)
+  (set-keyboard-coding-system 'coding-system-euc-china)
+
+  (setq default-input-method '("Chinese-GB" . "quail-py"))
+  )
+
+(set-language-info-alist
+ "Chinese" '((documentation . 
+"Emacs provides three kinds of Chinese support: Chinese-GB,
+Chinese-BIG5, and Chinese-CNS.  Please specify one of them to get more
+information.")
+             (setup-function . setup-chinese-gb-environment)
+             (charset . (chinese-gb2312 chinese-sisheng))
+             (coding-system . (coding-system-euc-china
+                               coding-system-hz
+                               coding-system-iso-2022-cn))
+             (documentation . t)
+             (sample-text . "Chinese ($AVPND(B,$AFUM(;0(B,$A::So(B)       $ADc:C(B")))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Chinese BIG5 (traditional)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(make-coding-system
+ 'coding-system-big5 3 ?B
+ "Coding-system of BIG5.")
+
+;; Big5 font requires special encoding.
+(define-ccl-program ccl-encode-big5-font
+  `(0
+    ;; In:  R0:chinese-big5-1 or chinese-big5-2
+    ;;      R1:position code 1
+    ;;      R2:position code 2
+    ;; Out: R1:font code point 1
+    ;;      R2:font code point 2
+    ((r2 = ((((r1 - ?\x21) * 94) + r2) - ?\x21))
+     (if (r0 == ,(charset-id 'chinese-big5-2)) (r2 += 6280))
+     (r1 = ((r2 / 157) + ?\xA1))
+     (r2 %= 157)
+     (if (r2 < ?\x3F) (r2 += ?\x40) (r2 += ?\x62))))
+  "CCL program to encode a Big5 code to code point of Big5 font.")
+
+(setq font-ccl-encoder-alist
+      (cons (cons "big5" ccl-encode-big5-font) font-ccl-encoder-alist))
+
+(register-input-method
+ "Chinese-BIG5" '("quail-qj-b5" quail-use-package "quail/qj-b5"))
+(register-input-method
+ "Chinese-BIG5" '("quail-zozy" quail-use-package "quail/zozy"))
+(register-input-method
+ "Chinese-BIG5" '("quail-tsangchi-b5" quail-use-package "quail/tsangchi-b5"))
+(register-input-method
+ "Chinese-BIG5" '("quail-py-b5" quail-use-package "quail/py-b5"))
+(register-input-method
+ "Chinese-BIG5" '("quail-quick-b5" quail-use-package "quail/quick-bt"))
+(register-input-method
+ "Chinese-BIG5" '("quail-etzy" quail-use-package "quail/etzy"))
+(register-input-method
+ "Chinese-BIG5" '("quail-ecdict" quail-use-package "quail/ecdict"))
+(register-input-method
+ "Chinese-BIG5" '("quail-ctlaub" quail-use-package "quail/ctlaub"))
+(register-input-method
+ "Chinese-BIG5" '("quail-array30" quail-use-package "quail/array30"))
+(register-input-method
+ "Chinese-BIG5" '("quail-4corner" quail-use-package "quail/4corner"))
+
+(defun setup-chinese-big5-environment ()
+  (setq primary-language "Chinese-BIG5")
+
+  (setq coding-category-big5 'coding-system-big5)
+  (setq coding-category-iso-else 'coding-system-iso-2022-cn)
+
+  (set-coding-priority
+   '(coding-category-iso-7
+     coding-category-iso-else
+     coding-category-big5))
+
+  (setq-default buffer-file-coding-system 'coding-system-big5)
+  (set-terminal-coding-system 'coding-system-big5)
+  (set-keyboard-coding-system 'coding-system-big5)
+
+  (setq default-input-method '("Chinese-BIG5" . "quail-py-b5"))
+  )
+
+(set-language-info-alist
+ "Chinese-BIG5" '((setup-function . setup-chinese-big5-environment)
+                  (charset . (chinese-big5-1 chinese-big5-2))
+                  (coding-system . (coding-system-big5
+                                    coding-system-iso-2022-cn))
+                  (documentation . t)
+                  (sample-text . "Cantonese ($(0GnM$(B,$(0N]0*Hd(B) $(0*/=((B, $(0+$)p(B")))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Chinese CNS11643 (traditional)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(register-input-method
+ "Chinese-CNS" '("quail-quick-cns" quail-use-package "quail/quick-cns"))
+(register-input-method
+ "Chinese-CNS" '("quail-tsangchi-cns" quail-use-package "quail/tsangchi-cns"))
+
+(defun setup-chinese-cns-environment ()
+  (setq primary-language "Chinese-CNS")
+
+  (setq coding-category-iso-else 'coding-system-iso-2022-cn)
+
+  (set-coding-priority
+   '(coding-category-iso-7
+     coding-category-iso-else
+     coding-category-big5))
+
+  (setq-default buffer-file-coding-system 'coding-system-iso-2022-7)
+  (set-terminal-coding-system 'coding-system-iso-2022-7)
+  (set-keyboard-coding-system 'coding-system-iso-2022-7)
+
+  (setq default-input-method '("Chinese-CNS" . "quail-py-cns"))
+  )
+
+(set-language-info-alist
+ "Chinese-CNS" '((setup-function . setup-chinese-cns-environment)
+                 (charset . (chinese-cns11643-1 chinese-cns11643-2
+                             chinese-cns11643-3 chinese-cns11643-4
+                             chinese-cns11643-5 chinese-cns11643-6
+                             chinese-cns11643-7))
+                 (coding-system . (coding-system-iso-2022-cn))
+                 (documentation . t)))
+
+;;; chinese.el ends here
diff --git a/lisp/language/cyrillic.el b/lisp/language/cyrillic.el
new file mode 100644
index 00000000000..1ff084a5362
--- /dev/null
+++ b/lisp/language/cyrillic.el
@@ -0,0 +1,71 @@
+;;; cyrillic.el --- Support for languages which use Cyrillic characters
+
+;; Copyright (C) 1995 Free Software Foundation, Inc.
+;; Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+;; Keywords: multilingual, Cyrillic
+
+;; 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.
+
+;;; Commentary:
+
+;; The character set ISO8859-5 is supported.
+
+;;; Code:
+
+(make-coding-system
+ 'coding-system-iso-8859-5 2 ?5 "MIME ISO-8859-5"
+ '((ascii t) (cyrillic-iso8859-5 t) nil nil
+   nil ascii-eol ascii-cntl nil nil nil nil))
+
+(register-input-method
+ "Cyrillic" '("quail-jcuken" quail-use-package "quail/cyrillic"))
+(register-input-method
+ "Cyrillic" '("quail-macedonian" quail-use-package "quail/cyrillic"))
+(register-input-method
+ "Cyrillic" '("quail-serbian" quail-use-package "quail/cyrillic"))
+(register-input-method
+ "Cyrillic" '("quail-beylorussian" quail-use-package "quail/cyrillic"))
+(register-input-method
+ "Cyrillic" '("quail-ukrainian" quail-use-package "quail/cyrillic"))
+(register-input-method
+ "Cyrillic" '("quail-yawerty" quail-use-package "quail/cyrillic"))
+
+(defun setup-cyrillic-environment ()
+  (setq primary-language "Cyrillic")
+
+  (setq coding-category-iso-8-1 'coding-system-iso-8859-5)
+
+  (set-coding-priority
+   '(coding-category-iso-7
+     coding-category-iso-8-1))
+
+  (setq-default buffer-file-coding-system 'coding-system-iso-8859-5)
+  (set-terminal-coding-system 'coding-system-iso-8859-5)
+  (set-keyboard-coding-system 'coding-system-iso-8859-5)
+
+  (setq default-input-method '("Cyrillic" . "quail-yawerty"))
+  )
+
+(set-language-info-alist
+ "Cyrillic" '((setup-function . setup-cyrillic-environment)
+              (charset . (cyrillic-iso8859-5))
+              (coding-system . (coding-system-iso-8859-5))
+              (documentation . t)
+              (sample-text . "Russian (,L@caaZXY(B)   ,L7T`PRabRcYbU(B!")))
+
+;;; cyrillic.el ends here
diff --git a/lisp/language/devan-util.el b/lisp/language/devan-util.el
new file mode 100644
index 00000000000..9bdffa4586e
--- /dev/null
+++ b/lisp/language/devan-util.el
@@ -0,0 +1,1160 @@
+;;; devan-util.el --- Support for Devanagari Script Composition
+
+;; Copyright (C) 1996 Free Software Foundation, Inc.
+
+;; Author: KAWABATA, Taichi <kawabata@is.s.u-tokyo.ac.jp>
+
+;; Keywords: multilingual, Indian, Devanagari
+
+;; 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.
+
+;;; Commentary:
+
+;; History:
+;; 1996.10.18 written by KAWABATA, Taichi <kawabata@is.s.u-tokyo.ac.jp>
+
+;; Devanagari script composition rules and related programs.
+
+;;; Code:
+
+;;;
+;;;   Steps toward composition of Devanagari Characters.
+;;;
+
+;;; Basic functions.
+
+;;;###autoload
+(defun indian-to-devanagari (ch)
+  "Convert IS 13194 characters to Devanagari basic characters."
+  (let ((charcodes (split-char ch)))
+    (if (eq (car charcodes) 'indian-is13194)
+        (make-char 'indian-2-column ?\x21 (nth 1 charcodes))
+      ch)))
+
+;;;###autoload
+(defun devanagari-to-indian (ch)
+  "Convert Devanagari basic characters to IS 13194 characters."
+  (let* ((charcodes (split-char ch))
+         (charset (car charcodes))
+         (code-h  (car (cdr charcodes))))
+    (if (and (eq (car charcodes) 'indian-2-column)
+             (= (nth 1 charcodes) ?\x21))
+        (make-char 'indian-is13194 (nth 2 charcodes))
+      ch)))
+
+;;;###autoload
+(defun indian-to-devanagari-region (from to)
+  "Convert IS 13194 characters in region to Devanagari basic characters."
+  (interactive "r")
+  (save-restriction 
+    (narrow-to-region from to)
+    (goto-char (point-min))
+    (while (re-search-forward "\\cd" nil t)
+      (let* ((devanagari-char (indian-to-devanagari (preceding-char))))
+        (delete-char -1)
+        (insert devanagari-char)))))
+
+;;;###autoload
+(defun devanagari-to-indian-region (from to)
+  "Convert Devanagari basic characters in region to Indian characters."
+  (interactive "r")
+  (save-restriction
+    (narrow-to-region from to)
+    (goto-char (point-min))
+    (while (re-search-forward "\\cD" nil t) ; Devanagari Character Code.
+      (let* ((indian-char (devanagari-to-indian (preceding-char))))
+        (delete-char -1)
+        (insert indian-char)))))
+
+;;;###autoload
+(defun indian-to-devanagari-string (str)
+  "Convert Indian String to Devanagari Basic Character String."
+  (let ((pos 0) (dst "") (src str) char)
+    (while (not (equal src ""))
+      (setq char (string-to-char src))
+      (setq src (substring src (char-bytes char)))
+      (setq dst (concat dst (char-to-string (indian-to-devanagari char)))))
+    dst))
+
+;; Phase 0 - Determine whether the characters can be composed.
+;;
+;;;
+;;; Regular expressions to split characters for composition.
+;;;
+;;
+;; Indian script word contains one or more syllables.
+;; In BNF, it can be expressed as follows:
+;;
+;; Word ::= {Syllable} [Cons-Syllable]
+;; Syllable ::= Cons-Vowel-Syllable | Vowel-Syllable
+;; Vowel-Syllable ::= V[D]
+;; Cons-Vowel-Syllable ::= [Cons-Syllable] Full-Cons [M] [D]
+;; Cons-Syllable ::= [Pure-Cons] [Pure-Cons] Pure-Cons
+;; Pure-Cons ::= Full-Cons H
+;; Full-Cons ::= C [N]
+;;
+;; {} repeat, [] optional
+;;
+;; C - Consonant ($(5!3!4!5!6!7!8!9!:!;!<!=!>!?!@!A!B!C!D!E(B
+;;                $(5!F!G!H!I!J!K!L!M!N!O!P!Q!R!S!T!U!V!W!X(B)
+;; N - Nukta ($(5!i(B)
+;; H - Halant($(5!h(B)
+;; V - Vowel ($(5!$!%!&!'!(!)!*!+!,!-!.!/!0!1!2(B)
+;; D - Vowel Modifiers, i.e. Anuswar, Chandrabindu, Visarg  ($(5!!!"(B)
+;; M - Matra ($(5!Z![!\!]!^!_!`!a!b!c!d!e!f!g(B)
+;;
+;; In Emacs, one syllable of Indian language is considered to be one 
+;; composite glyph.  If we expand the above expression, it would be:
+;;
+;; [[C [N] H] [C [N] H] C [N] H] C [N] [M] [D] | V [D]
+;; 
+;; Therefore, in worst case, the consonant syllabe will consist of
+;; following characters.
+;;
+;; C N H C N H C N H C N M D
+;;
+;; On the other hand, incomplete consonant syllable before inputting
+;; base consonant must satisfy the following condition:
+;;
+;; [C [N] H] [C [N] H] C [N] H
+;;
+;; This is acceptable BEFORE proper consonant-syllable is input.  The
+;; string which doesn't match with the above expression is invalid and
+;; thus must be fixed.
+;;
+;; Note:
+;; Third case can be considered, which is acceptable syllable and can
+;; not add any code more.
+;;
+;; [[C [N] H] [C [N] H] C [N] H] C [N] [M] D
+;;
+;; However, to make editing possible even in this condition, we will
+;; not consider about this case.
+
+(defconst devanagari-cons-syllable-examine
+  "\\(\\([$(5!3(B-$(5!X(B]$(5!i(B?$(5!h(B\\)?\\([$(5!3(B-$(5!X(B]$(5!i(B?$(5!h(B\\)?[$(5!3(B-$(5!X(B]$(5!i(B?$(5!h(B\\)?[$(5!3(B-$(5!X(B]$(5!i(B?[$(5!Z(B-$(5!g(B]?[$(5!!!"(B]?"
+  "Regexp matching to one Devanagari consonant syllable.")
+
+(defconst devanagari-cons-syllable-incomplete-examine
+  "\\([$(5!3(B-$(5!X(B]$(5!i(B?$(5!h(B\\)?\\([$(5!3(B-$(5!X(B]$(5!i(B?$(5!h(B\\)?[$(5!3(B-$(5!X(B]$(5!i(B?$(5!h(B$"
+  "Regexp matching to one Devanagari incomplete consonant syllable.")
+
+(defconst devanagari-vowel-syllable-examine
+  "[$(5!$(B-$(5!2(B][$(5!!!"!#(B]?"
+  "Regexp matching to one Devanagari vowel syllable.")
+
+;;
+;; Also, digits and virams should be processed other than syllables.
+;;
+;; In IS 13194, Avagrah is obtained by Nukta after Viram, and
+;; OM is obtained by Nukta after Chandrabindu
+;;
+(defconst devanagari-digit-viram-examine 
+  "[$(5!q(B-$(5!z!j(B]")
+(defconst devanagari-other-sign-examine
+  "[$(5!!!j(B]$(5!i(B")
+
+(defconst devanagari-composite-glyph-unit-examine
+  (concat "\\(" devanagari-cons-syllable-incomplete-examine 
+          "\\)\\|\\(" devanagari-vowel-syllable-examine 
+          "\\)\\|\\(" devanagari-digit-viram-examine
+          "\\)\\|\\(" devanagari-cons-syllable-examine
+          "\\)\\|\\(" devanagari-other-sign-examine"\\)")
+  "Regexp matching to Devanagari string to be composed form one glyph.")
+
+;;(put-charset-property charset-devanagari-1-column
+;;                    'char-to-glyph 'devanagari-compose-string)
+;;(put-charset-property charset-devanagari-2-column
+;;                    'char-to-glyph 'devanagari-compose-string)
+
+;; Sample
+;;
+;;(string-match devanagari-cons-syllable-examine "$(5!X![(B") => 0
+;;(string-match devanagari-cons-syllable-examine "$(5!F!h!D!\(B") => 0
+;;(string-match devanagari-cons-syllable-examine "$(5!X![!F!h!D!\(B") => 0
+
+;;
+;; Steps toward the composition
+;;  Converting Character Code to Composite Glyph.
+;;
+;; Example : $(5!X![(B/$(5!F!h!D!\(B
+;; 
+;; First, convert Characters to appropriate glyphs.
+;;
+;; => $(5!X![(B/$(5"F!D!\(B
+;;
+;; Then, determine the base glyph, apply-orders and apply-rules.
+;;
+;; => $(5!X(B (ml.mr) $(5![(B / $(5!D(B (ml.mr) $(5"F(B (mr ml) $(5!\(B
+;;
+;; Finally, convert 2-column glyphs to 1-column glyph
+;; if such a glyph exist.
+;;
+;; => $(6![(B (ml.mr) $(6!X(B / $(6!D(B (ml.mr) $(6"F(B (mr ml) $(6!\(B
+;;
+;; Compose the glyph.
+;;
+;; => 2$(6!X@![1(B/2$(6!D@"FP!\1(B
+;; => 2$(6!X@![12!D@"FP!\1(B
+;;
+
+;;
+;; Phase 1: Converting Character Code to Glyph Code.
+;; 
+;;
+;; IMPORTANT:  
+;;        There may be many rules which you many want to be suppressed.
+;;        In that case, please comment out that rule.
+;;
+;;        RULES WILL BE EVALUATED FROM FIRST TO LAST.
+;;        PUT MORE SPECIFIC RULES FIRST.
+;;
+;; TO DO: 
+;;        Prepare multiple specific list of rules for each languages
+;;        which adopts Devanagari script.
+;;
+
+
+(defconst devanagari-char-to-glyph-rules
+  '(
+    ;; special form for "ru".
+    ("\\($(5!O!](B\\)" . "$(5",(B")
+    ("\\($(5!O!^(B\\)" . "$(5"-(B")
+    ("\\($(5!P!](B\\)" . "$(5".(B")
+    ("\\($(5!P!^(B\\)" . "$(5"/(B")
+
+    ;; `r' at the top of syllable and followed by other consonants.
+    ;; ("[^$(5!h(B]\\($(5!O!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"p(B")
+    ("^\\($(5!O!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"p(B")
+
+    ;; If "r" is preceded by the vowel-suppressed consonant
+    ;; (especially those with vertical line), it will be written as
+    ;; slanted line below the preceding consonant character.  Some of
+    ;; them are pre-composed as one glyph.
+
+    ("\\($(5!:!i!h!O(B\\)" . "$(5"!(B")
+    ("\\($(5!I!i!h!O(B\\)" . "$(5""(B")
+    ("\\($(5!3!h!O(B\\)" . "$(5"#(B")
+    ("\\($(5!:!h!O(B\\)" . "$(5"$(B")
+    ("\\($(5!B!h!O(B\\)" . "$(5"%(B")
+    ("\\($(5!H!h!O(B\\)" . "$(5"&(B")
+    ("\\($(5!I!h!O(B\\)" . "$(5"'(B")
+    ("\\($(5!U!h!O(B\\)" . "$(5"((B")
+    ("\\($(5!W!h!O(B\\)" . "$(5")(B")
+
+    ;; Ligature Rules 
+    ("\\($(5!3!h!B!h!O!h!M(B\\)" . "$(5$!(B")
+    ("\\($(5!3!h!B!h!T(B\\)" . "$(5$"(B")
+    ("\\($(5!3!h!B!h!M(B\\)" . "$(5$#(B")
+    ("\\($(5!3!h!F!h!M(B\\)" . "$(5$$(B")
+    ("\\($(5!3!h!O!h!M(B\\)" . "$(5$%(B")
+    ("\\($(5!3!h!T!h!M(B\\)" . "$(5$&(B")
+    ("\\($(5!3!h!3(B\\)" . "$(5$'(B")
+    ("\\($(5!3!h!B(B\\)" . "$(5$((B")
+    ("\\($(5!3!h!F(B\\)" . "$(5$)(B")
+    ("\\($(5!3!h!L(B\\)" . "$(5$*(B")
+    ("\\($(5!3!h!M(B\\)" . "$(5$+(B")
+    ("\\($(5!3!h!Q(B\\)" . "$(5$,(B")
+    ("\\($(5!3!h!T(B\\)" . "$(5$-(B")
+    ("\\($(5!3!h!V(B\\)" . "$(5$.(B")
+    ("\\($(5!6!h!F(B\\)" . "$(5$/(B")
+    ("\\($(5!7!h!3!h!B!h!M(B\\)" . "$(5$0(B")
+    ("\\($(5!7!h!3!h!V!h!T(B\\)" . "$(5$1(B")
+    ("\\($(5!7!h!3!h!B(B\\)" . "$(5$2(B")
+    ("\\($(5!7!h!3!h!V(B\\)" . "$(5$3(B")
+    ("\\($(5!7!h!6!h!O(B\\)" . "$(5$4(B")
+    ("\\($(5!7!h!3!h!M(B\\)" . "$(5$5(B")
+    ("\\($(5!7!h!4!h!M(B\\)" . "$(5$6(B")
+    ("\\($(5!7!h!5!h!M(B\\)" . "$(5$7(B")
+    ("\\($(5!7!h!6!h!M(B\\)" . "$(5$8(B")
+    ("\\($(5!7!h!3(B\\)" . "$(5$9(B")
+    ("\\($(5!7!h!4(B\\)" . "$(5$:(B")
+    ("\\($(5!7!h!5(B\\)" . "$(5$;(B")
+    ("\\($(5!7!h!6(B\\)" . "$(5$<(B")
+    ("\\($(5!7!h!7(B\\)" . "$(5$=(B")
+    ("\\($(5!7!h!F(B\\)" . "$(5$>(B")
+    ("\\($(5!7!h!L(B\\)" . "$(5$?(B")
+    ("\\($(5!7!h!M(B\\)" . "$(5$@(B")
+    ("\\($(5!8!h!8(B\\)" . "$(5$A(B")
+    ("\\($(5!8!h!<(B\\)" . "$(5$B(B")
+    ("\\($(5!9!h!M(B\\)" . "$(5$C(B")
+    ("\\($(5!:!h!O(B\\)" . "$(5$D(B")
+    ("\\($(5!:!h!h(B\\)" . "$(5$E(B")
+    ("\\($(5!<!h!8(B\\)" . "$(5$F(B")
+    ("\\($(5!<!h!:(B\\)" . "$(5$G(B")
+    ("\\($(5!=!h!3(B\\)" . "$(5$H(B")
+    ("\\($(5!=!h!=(B\\)" . "$(5$I(B")
+    ("\\($(5!=!h!>(B\\)" . "$(5$J(B")
+    ("\\($(5!=!h!M(B\\)" . "$(5$K(B")
+    ("\\($(5!>!h!M(B\\)" . "$(5$L(B")
+    ("\\($(5!?!h!5!h!M(B\\)" . "$(5$M(B")
+    ("\\($(5!?!h!6!h!O(B\\)" . "$(5$N(B")
+    ("\\($(5!?!h!O!h!M(B\\)" . "$(5$O(B")
+    ("\\($(5!?!h!5(B\\)" . "$(5$P(B")
+    ("\\($(5!?!h!6(B\\)" . "$(5$Q(B")
+    ("\\($(5!?!h!?(B\\)" . "$(5$R(B")
+    ("\\($(5!?!h!L(B\\)" . "$(5$S(B")
+    ("\\($(5!?!h!M(B\\)" . "$(5$T(B")
+    ("\\($(5!@!h!M(B\\)" . "$(5$`(B")
+    ("\\($(5!B!h!B(B\\)" . "$(5$a(B")
+    ("\\($(5!B!h!F(B\\)" . "$(5$b(B")
+    ("\\($(5!D!h!D!h!M(B\\)" . "$(5$c(B")
+    ("\\($(5!D!h!E!h!M(B\\)" . "$(5$d(B")
+    ("\\($(5!D!h!K!h!M(B\\)" . "$(5$e(B")
+    ("\\($(5!D!h!O!h!M(B\\)" . "$(5$f(B")
+    ("\\($(5!D!h!T!h!M(B\\)" . "$(5$g(B")
+    ("\\($(5!D!h!5!h!O(B\\)" . "$(5$h(B")
+    ("\\($(5!D!h!6!h!O(B\\)" . "$(5$i(B")
+    ("\\($(5!D!h!D!h!T(B\\)" . "$(5$j(B")
+    ("\\($(5!D!h!E!h!T(B\\)" . "$(5$k(B")
+    ("\\($(5!D!h!5(B\\)" . "$(5$l(B")
+    ("\\($(5!D!h!6(B\\)" . "$(5$m(B")
+    ("\\($(5!D!h!D(B\\)" . "$(5$n(B")
+    ("\\($(5!D!h!E(B\\)" . "$(5$o(B")
+    ("\\($(5!D!h!F(B\\)" . "$(5$p(B")
+    ("\\($(5!D!h!J(B\\)" . "$(5$q(B")
+    ("\\($(5!D!h!K(B\\)" . "$(5$r(B")
+    ("\\($(5!D!h!L(B\\)" . "$(5$s(B")
+    ("\\($(5!D!h!M(B\\)" . "$(5$t(B")
+    ("\\($(5!D!h!T(B\\)" . "$(5$u(B")
+    ("\\($(5!E!h!F(B\\)" . "$(5$v(B")
+    ("\\($(5!F!h!F(B\\)" . "$(5$w(B")
+    ("\\($(5!H!h!B(B\\)" . "$(5$x(B")
+    ("\\($(5!H!h!F(B\\)" . "$(5$y(B")
+    ("\\($(5!H!h!Q(B\\)" . "$(5$z(B")
+    ("\\($(5!J!h!F(B\\)" . "$(5${(B")
+    ("\\($(5!J!h!J(B\\)" . "$(5$|(B")
+    ("\\($(5!J!h!T(B\\)" . "$(5$}(B")
+    ("\\($(5!K!h!F(B\\)" . "$(5$~(B")
+    ("\\($(5!L!h!F(B\\)" . "$(5#P(B")
+    ("\\($(5!L!h!Q(B\\)" . "$(5#Q(B")
+    ("\\($(5!Q!h!Q(B\\)" . "$(5#`(B")
+    ("\\($(5!T!h!F(B\\)" . "$(5#a(B")
+    ("\\($(5!T!h!T(B\\)" . "$(5#b(B")
+    ("\\($(5!U!h!8(B\\)" . "$(5#c(B")
+    ("\\($(5!U!h!F(B\\)" . "$(5#d(B")
+    ("\\($(5!U!h!J(B\\)" . "$(5#e(B")
+    ("\\($(5!U!h!Q(B\\)" . "$(5#f(B")
+    ("\\($(5!U!h!T(B\\)" . "$(5#g(B")
+    ("\\($(5!V!h!=!h!O!h!M(B\\)" . "$(5#h(B")
+    ("\\($(5!V!h!=!h!M(B\\)" . "$(5#i(B")
+    ("\\($(5!V!h!=!h!T(B\\)" . "$(5#j(B")
+    ("\\($(5!V!h!=(B\\)" . "$(5#k(B")
+    ("\\($(5!V!h!>(B\\)" . "$(5#l(B")
+    ("\\($(5!W!h!F(B\\)" . "$(5#m(B")
+    ("\\($(5!W!h!O(B\\)" . "$(5#n(B")
+    ("\\($(5!X!h!A(B\\)" . "$(5#p(B")
+    ("\\($(5!X!h!F(B\\)" . "$(5#q(B")
+    ("\\($(5!X!h!L(B\\)" . "$(5#r(B")
+    ("\\($(5!X!h!M(B\\)" . "$(5#s(B")
+    ("\\($(5!X!h!O(B\\)" . "$(5#t(B")
+    ("\\($(5!X!h!Q(B\\)" . "$(5#u(B")
+    ("\\($(5!X!h!T(B\\)" . "$(5#v(B")
+    ;; Special Ligature Rules 
+    ("\\($(5!X!_(B\\)" . "$(5#R(B")
+
+    ;; Half form with ligature.  Special "r" case is included.  "r"
+    ;; connection which is not listed here has not been examined yet.
+    ;; I don't know what to do with them.
+    ;;
+    ;; special forms 
+    ("\\($(5!3!h!V!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"l(B")
+    ("\\($(5!:!h!<!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"m(B")
+    ;; ordinary forms 
+    ("\\($(5!5!h!O!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"`(B")
+    ("\\($(5!6!h!F!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"a(B")
+    ;; ("\\($(5!<!h!8!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"c(B") ; Mistake, must check later.
+    ("\\($(5!B!h!B!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"c(B")
+    ("\\($(5!B!h!O!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"d(B")
+    ("\\($(5!E!h!F!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"e(B")
+    ("\\($(5!E!h!O!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"f(B")
+    ("\\($(5!H!h!B!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"g(B")
+    ("\\($(5!U!h!8!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"h(B")
+    ("\\($(5!U!h!O!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"i(B")
+    ("\\($(5!U!h!T!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"j(B")
+    ;; ("\\($(5!U!h!T!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"k(B") ; must check later.
+    ;; Conjunction form associated with Nukta sign.
+    ("\\($(5!3!i!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"s(B")
+    ("\\($(5!4!i!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"t(B")
+    ("\\($(5!5!i!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"u(B")
+    ("\\($(5!:!i!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"z(B")
+    ("\\($(5!I!i!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"y(B")
+
+    ;; For consonants other than listed above, glyph-composition will
+    ;; be applied.  If the consonant which is preceding "$(5!O(B" does not
+    ;; have the vertical line (such as "$(5!?(B"), "$(5"r(B" is put beneath the
+    ;; consonant.
+    ;;
+    ;; ("cons-not-yet-listed-up\\($(5!h!O(B\\)" . "$(5"q(B")
+    ("[$(5!7!9!=!>!?!@!D!O!P!R!S!X(B]\\($(5!h!O(B\\)" . "$(5"r(B")
+    ("$(5!?!i(B\\($(5!h!O(B\\)" . "$(5"r(B")
+    ("$(5!@!i(B\\($(5!h!O(B\\)" . "$(5"r(B")
+
+    ;; Nukta 
+    ("\\($(5!!!i(B\\)" . "$(5#!(B")
+    ("\\($(5!&!i(B\\)" . "$(5#&(B")
+    ("\\($(5!'!i(B\\)" . "$(5#'(B")
+    ("\\($(5!*!i(B\\)" . "$(5#*(B")
+    ("\\($(5!3!i(B\\)" . "$(5#3(B")
+    ("\\($(5!4!i(B\\)" . "$(5#4(B")
+    ("\\($(5!5!i(B\\)" . "$(5#5(B")
+    ("\\($(5!:!i(B\\)" . "$(5#:(B")
+    ("\\($(5!?!i(B\\)" . "$(5#?(B")
+    ("\\($(5!@!i(B\\)" . "$(5#@(B")
+    ("\\($(5!I!i(B\\)" . "$(5#I(B")
+    ("\\($(5!j!i(B\\)" . "$(5#J(B")
+
+    ;; Half forms.
+    ("\\($(5!3!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"3(B")
+    ("\\($(5!4!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"4(B")
+    ("\\($(5!5!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"5(B")
+    ("\\($(5!6!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"6(B")
+    ("\\($(5!8!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"8(B")
+    ("\\($(5!:!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5":(B")
+    ("\\($(5!;!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5";(B")
+    ("\\($(5!<!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"<(B")
+    ("\\($(5!A!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"A(B")
+    ("\\($(5!B!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"B(B")
+    ("\\($(5!C!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"C(B")
+    ("\\($(5!E!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"E(B")
+    ("\\($(5!F!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"F(B")
+    ("\\($(5!G!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"G(B")
+    ("\\($(5!H!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"H(B")
+    ("\\($(5!I!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"I(B")
+    ("\\($(5!J!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"J(B")
+    ("\\($(5!K!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"K(B")
+    ("\\($(5!L!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"L(B")
+    ("\\($(5!M!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"M(B")
+    ("\\($(5!N!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"N(B")
+    ("\\($(5!Q!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"Q(B")
+    ("\\($(5!R!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"R(B")
+    ("\\($(5!S!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"S(B")
+    ("\\($(5!T!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"T(B")
+    ("\\($(5!U!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"U(B")
+    ("\\($(5!V!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"V(B")
+    ("\\($(5!W!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"W(B")
+    )
+  "Alist of regexps of Devanagari character sequences vs composed characters.")
+
+;; Example:
+;;("\\($(5!F!h(B\\)[$(5!3(B-$(5!X(B]" . "$(5"F(B")
+;;(string-match "\\($(5!F!h(B\\)[$(5!3(B-$(5!X(B]" "$(5!X![!F!h!D!\(B") => 8
+;;(match-end 1) => 16
+
+;;
+;; Defining character properties : char-to-glyph, glyph-to-char
+;;
+;; *  If char-to-glyph is non-nil, it would be one of the following forms.
+;;
+;;  (("character-regexp" . "glyphs")
+;;   .....) or
+;;  (("character-regexp" . ?glyph)
+;;   .....) or
+;;  ("characters-regexp" . "glyphs")
+;;  or
+;;  ?glyph
+;;
+;; *  If glyph-to-char is non-nil, it would be one of the following forms.
+;;
+;;  (("glyph-regexp" . "characters")  ;; This is the only case in Devanagari
+;;   ....) or
+;;  (("glyph-regexp" . ?character)
+;;   ....) or
+;;  ("glyph-regexp" . "characters")
+;;    or
+;;  "characters"
+;;    or
+;;  ?character  
+;;
+
+(let ((rules devanagari-char-to-glyph-rules))
+  (while rules
+    (let ((rule (car rules)) 
+          (chars) (char) (glyph))
+      (setq rules (cdr rules))
+      (string-match "\\\\(\\(.+\\)\\\\)" (car rule))
+      (setq chars (substring (car rule) (match-beginning 1) (match-end 1)))
+      (setq char (string-to-char chars))
+      (setq glyph (string-to-char (cdr rule))) ; assume one glyph in devan.
+      (put-char-code-property 
+         char 'char-to-glyph 
+         (append (get-char-code-property char 'char-to-glyph) (list rule)))
+      (put-char-code-property glyph 'glyph-to-char chars))))
+
+;;
+;; Convert Character Code to Glyph Code
+;;
+
+;;;###autoload
+(defun char-to-glyph-devanagari (src-str)
+  "Convert Devanagari characters in the string to Devanagari glyphs.  
+Ligatures and special rules are processed."
+  (let ((pos 0) 
+        (dst-str ""))
+    (while (< pos (length src-str))
+      (let ((found nil)
+            (rules (get-char-code-property 
+                    (string-to-char 
+                     ;; caution. other forms not supported for now.
+                     (substring src-str pos)) 'char-to-glyph)))
+        (while rules
+          (let* ((rule (car rules))
+                 (regexp (car rule)))
+            (if (string-match regexp src-str)
+                (if (= (match-beginning 1) pos)
+                    (progn
+                      (setq dst-str (concat dst-str (cdr rule)))
+                      (setq rules nil) ; Get out of the loop.
+                      (setq found t)
+                      ;; proceed `pos' for replaced characters.
+                      (setq pos (match-end 1)))
+                  (setq rules (cdr rules)))
+              (setq rules (cdr rules)))))
+        ;; proceed to next position
+        (if (not found)
+            (let ((nextchar (string-to-char (substring src-str pos))))
+              (setq pos (+ pos 
+                           (char-bytes (string-to-char (substring src-str pos)))))
+              (setq dst-str (concat dst-str (char-to-string nextchar)))))))
+    dst-str))
+
+;; Example:
+;;(char-to-glyph-devanagari "$(5!X![!F!h!D!\(B") => "$(5!X!["F!D!\(B"
+;;(char-to-glyph-devanagari "$(5!O!Z!V!h!=!h!O![!M(B") => ???
+
+;;
+;; Phase 2: Compose Glyphs to form One Glyph.
+;;
+
+;; Each list consist of glyph, application-priority and application-direction.
+;;
+;; Glyphs will be ordered from low priority number to high priority number.
+;; If application-priority is omitted, it is assumed to be 0.
+;; If application-direction is omitted, it is asumbed to be '(mr . ml).
+
+(defconst devanagari-composition-rules
+  '((?$(5!!(B 60 (tr . br))
+    (?$(5!"(B 60 (tr . br))
+    (?$(5!#(B 60)
+    (?$(5!$(B 0)
+    (?$(5!%(B 0)
+    (?$(5!&(B 0)
+    (?$(5!'(B 0)
+    (?$(5!((B 0)
+    (?$(5!)(B 0)
+    (?$(5!*(B 0)
+    (?$(5!+(B 0)
+    (?$(5!,(B 0)
+    (?$(5!-(B 0)
+    (?$(5!.(B 0)
+    (?$(5!/(B 0)
+    (?$(5!0(B 0)
+    (?$(5!1(B 0)
+    (?$(5!2(B 0)
+    (?$(5!3(B 0)
+    (?$(5!4(B 0)
+    (?$(5!5(B 0)
+    (?$(5!6(B 0)
+    (?$(5!7(B 0)
+    (?$(5!8(B 0)
+    (?$(5!9(B 0)
+    (?$(5!:(B 0)
+    (?$(5!;(B 0)
+    (?$(5!<(B 0)
+    (?$(5!=(B 0)
+    (?$(5!>(B 0)
+    (?$(5!?(B 0)
+    (?$(5!@(B 0)
+    (?$(5!A(B 0)
+    (?$(5!B(B 0)
+    (?$(5!C(B 0)
+    (?$(5!D(B 0)
+    (?$(5!E(B 0)
+    (?$(5!F(B 0)
+    (?$(5!G(B 0)
+    (?$(5!H(B 0)
+    (?$(5!I(B 0)
+    (?$(5!J(B 0)
+    (?$(5!K(B 0)
+    (?$(5!L(B 0)
+    (?$(5!M(B 0)
+    (?$(5!N(B 0)
+    (?$(5!O(B 0)
+    (?$(5!P(B 0)
+    (?$(5!Q(B 0)
+    (?$(5!R(B 0)
+    (?$(5!S(B 0)
+    (?$(5!T(B 0)
+    (?$(5!U(B 0)
+    (?$(5!V(B 0)
+    (?$(5!W(B 0)
+    (?$(5!X(B 0)
+    (?$(5!Y(B 0)
+    (?$(5!Z(B 40)
+    (?$(5![(B 40 (ml . mr))
+    (?$(5!\(B 40)
+    (?$(5!](B 40 (bc . tc))
+    (?$(5!^(B 40 (bc . tc))
+    (?$(5!_(B 40 (bc . tc))
+    (?$(5!`(B 40 (tc . bc))
+    (?$(5!a(B 40 (tc . bc))
+    (?$(5!b(B 40 (tc . bc))
+    (?$(5!c(B 40 (tc . bc))
+    (?$(5!d(B 40)
+    (?$(5!e(B 40)
+    (?$(5!f(B 40)
+    (?$(5!g(B 40)
+    (?$(5!h(B 0 (br . tr))                    ; Halant's special treatment.
+    (?$(5!i(B 0 (br . tr))                    ; Nukta's special treatment.
+    (?$(5!j(B 0)
+    (nil 0)
+    (nil 0)
+    (nil 0)
+    (nil 0)
+    (nil 0)
+    (nil 0)
+    (?$(5!q(B 0)
+    (?$(5!r(B 0)
+    (?$(5!s(B 0)
+    (?$(5!t(B 0)
+    (?$(5!u(B 0)
+    (?$(5!v(B 0)
+    (?$(5!w(B 0)
+    (?$(5!x(B 0)
+    (?$(5!y(B 0)
+    (?$(5!z(B 0)
+    (nil 0)
+    (nil 0)
+    (nil 0)
+    (nil 0)
+    (?$(5"!(B 0)
+    (?$(5""(B 0)
+    (?$(5"#(B 0)
+    (?$(5"$(B 0)
+    (?$(5"%(B 0)
+    (?$(5"&(B 0)
+    (?$(5"'(B 0)
+    (?$(5"((B 0)
+    (?$(5")(B 0)
+    (?$(5"*(B 0)
+    (?$(5"+(B 0)
+    (?$(5",(B 0)
+    (?$(5"-(B 0)
+    (?$(5".(B 0)
+    (?$(5"/(B 0)
+    (?$(5"0(B 0)
+    (?$(5"1(B 0)
+    (?$(5"2(B 0)
+    (?$(5"3(B 0)
+    (?$(5"4(B 0)
+    (?$(5"5(B 0)
+    (?$(5"6(B 0)
+    (?$(5"7(B 0)
+    (?$(5"8(B 0)
+    (?$(5"9(B 0)
+    (?$(5":(B 0)
+    (?$(5";(B 0)
+    (?$(5"<(B 0)
+    (?$(5"=(B 0)
+    (?$(5">(B 0)
+    (?$(5"?(B 0)
+    (?$(5"@(B 0)
+    (?$(5"A(B 0)
+    (?$(5"B(B 0)
+    (?$(5"C(B 0)
+    (?$(5"D(B 0)
+    (?$(5"E(B 0)
+    (?$(5"F(B 0)
+    (?$(5"G(B 0)
+    (?$(5"H(B 0)
+    (?$(5"I(B 0)
+    (?$(5"J(B 0)
+    (?$(5"K(B 0)
+    (?$(5"L(B 0)
+    (?$(5"M(B 0)
+    (?$(5"N(B 0)
+    (?$(5"O(B 0)
+    (?$(5"P(B 0)
+    (?$(5"Q(B 0)
+    (?$(5"R(B 0)
+    (?$(5"S(B 0)
+    (?$(5"T(B 0)
+    (?$(5"U(B 0)
+    (?$(5"V(B 0)
+    (?$(5"W(B 0)
+    (?$(5"X(B 0)
+    (?$(5"Y(B 0)
+    (?$(5"Z(B 0)
+    (?$(5"[(B 0)
+    (?$(5"\(B 0)
+    (?$(5"](B 0)
+    (?$(5"^(B 0)
+    (?$(5"_(B 0)
+    (?$(5"`(B 0)
+    (?$(5"a(B 0)
+    (?$(5"b(B 0)
+    (?$(5"c(B 0)
+    (?$(5"d(B 0)
+    (?$(5"e(B 0)
+    (?$(5"f(B 0)
+    (?$(5"g(B 0)
+    (?$(5"h(B 0)
+    (?$(5"i(B 0)
+    (?$(5"j(B 0)
+    (?$(5"k(B 0)
+    (?$(5"l(B 0)
+    (?$(5"m(B 0)
+    (?$(5"n(B 0)
+    (?$(5"o(B 0)
+    (?$(5"p(B 20 (tr . br))
+    (?$(5"q(B 20 (br . tr))
+    (?$(5"r(B 20 (br . tr))
+    (?$(5"s(B 0)
+    (?$(5"t(B 0)
+    (?$(5"u(B 0)
+    (?$(5"v(B 0)
+    (?$(5"w(B 0)
+    (?$(5"x(B 0)
+    (?$(5"y(B 0)
+    (?$(5"z(B 0)
+    (?$(5"{(B 0)
+    (?$(5"|(B 0)
+    (?$(5"}(B 0)
+    (?$(5"~(B 0)
+    (?$(5#!(B 0)
+    (?$(5#"(B 0)
+    (?$(5##(B 0)
+    (?$(5#$(B 0)
+    (?$(5#%(B 0)
+    (?$(5#&(B 0)
+    (?$(5#'(B 0)
+    (?$(5#((B 0)
+    (?$(5#)(B 0)
+    (?$(5#*(B 0)
+    (?$(5#+(B 0)
+    (?$(5#,(B 0)
+    (?$(5#-(B 0)
+    (?$(5#.(B 0)
+    (?$(5#/(B 0)
+    (?$(5#0(B 0)
+    (?$(5#1(B 0)
+    (?$(5#2(B 0)
+    (?$(5#3(B 0)
+    (?$(5#4(B 0)
+    (?$(5#5(B 0)
+    (?$(5#6(B 0)
+    (?$(5#7(B 0)
+    (?$(5#8(B 0)
+    (?$(5#9(B 0)
+    (?$(5#:(B 0)
+    (?$(5#;(B 0)
+    (?$(5#<(B 0)
+    (?$(5#=(B 0)
+    (?$(5#>(B 0)
+    (?$(5#?(B 0)
+    (?$(5#@(B 0)
+    (?$(5#A(B 0)
+    (?$(5#B(B 0)
+    (?$(5#C(B 0)
+    (?$(5#D(B 0)
+    (?$(5#E(B 0)
+    (?$(5#F(B 0)
+    (?$(5#G(B 0)
+    (?$(5#H(B 0)
+    (?$(5#I(B 0)
+    (?$(5#J(B 0)
+    (?$(5#K(B 0)
+    (?$(5#L(B 0)
+    (?$(5#M(B 0)
+    (?$(5#N(B 0)
+    (?$(5#O(B 0)
+    (?$(5#P(B 0)
+    (?$(5#Q(B 0)
+    (?$(5#R(B 0)
+    (?$(5#S(B 0)
+    (?$(5#T(B 0)
+    (?$(5#U(B 0)
+    (?$(5#V(B 0)
+    (?$(5#W(B 0)
+    (?$(5#X(B 0)
+    (?$(5#Y(B 0)
+    (?$(5#Z(B 0)
+    (?$(5#[(B 0)
+    (?$(5#\(B 0)
+    (?$(5#](B 0)
+    (?$(5#^(B 0)
+    (?$(5#_(B 0)
+    (?$(5#`(B 0)
+    (?$(5#a(B 0)
+    (?$(5#b(B 0)
+    (?$(5#c(B 0)
+    (?$(5#d(B 0)
+    (?$(5#e(B 0)
+    (?$(5#f(B 0)
+    (?$(5#g(B 0)
+    (?$(5#h(B 0)
+    (?$(5#i(B 0)
+    (?$(5#j(B 0)
+    (?$(5#k(B 0)
+    (?$(5#l(B 0)
+    (?$(5#m(B 0)
+    (?$(5#n(B 0)
+    (?$(5#o(B 0)
+    (?$(5#p(B 0)
+    (?$(5#q(B 0)
+    (?$(5#r(B 0)
+    (?$(5#s(B 0)
+    (?$(5#t(B 0)
+    (?$(5#u(B 0)
+    (?$(5#v(B 0)
+    (?$(5#w(B 0)
+    (?$(5#x(B 0)
+    (?$(5#y(B 0)
+    (?$(5#z(B 0)
+    (?$(5#{(B 0)
+    (?$(5#|(B 0)
+    (?$(5#}(B 0)
+    (?$(5#~(B 0)
+    (?$(5$!(B 0)
+    (?$(5$"(B 0)
+    (?$(5$#(B 0)
+    (?$(5$$(B 0)
+    (?$(5$%(B 0)
+    (?$(5$&(B 0)
+    (?$(5$'(B 0)
+    (?$(5$((B 0)
+    (?$(5$)(B 0)
+    (?$(5$*(B 0)
+    (?$(5$+(B 0)
+    (?$(5$,(B 0)
+    (?$(5$-(B 0)
+    (?$(5$.(B 0)
+    (?$(5$/(B 0)
+    (?$(5$0(B 0)
+    (?$(5$1(B 0)
+    (?$(5$2(B 0)
+    (?$(5$3(B 0)
+    (?$(5$4(B 0)
+    (?$(5$5(B 0)
+    (?$(5$6(B 0)
+    (?$(5$7(B 0)
+    (?$(5$8(B 0)
+    (?$(5$9(B 0)
+    (?$(5$:(B 0)
+    (?$(5$;(B 0)
+    (?$(5$<(B 0)
+    (?$(5$=(B 0)
+    (?$(5$>(B 0)
+    (?$(5$?(B 0)
+    (?$(5$@(B 0)
+    (?$(5$A(B 0)
+    (?$(5$B(B 0)
+    (?$(5$C(B 0)
+    (?$(5$D(B 0)
+    (?$(5$E(B 0)
+    (?$(5$F(B 0)
+    (?$(5$G(B 0)
+    (?$(5$H(B 0)
+    (?$(5$I(B 0)
+    (?$(5$J(B 0)
+    (?$(5$K(B 0)
+    (?$(5$L(B 0)
+    (?$(5$M(B 0)
+    (?$(5$N(B 0)
+    (?$(5$O(B 0)
+    (?$(5$P(B 0)
+    (?$(5$Q(B 0)
+    (?$(5$R(B 0)
+    (?$(5$S(B 0)
+    (?$(5$T(B 0)
+    (?$(5$U(B 0)
+    (?$(5$V(B 0)
+    (?$(5$W(B 0)
+    (?$(5$X(B 0)
+    (?$(5$Y(B 0)
+    (?$(5$Z(B 0)
+    (?$(5$[(B 0)
+    (?$(5$\(B 0)
+    (?$(5$](B 0)
+    (?$(5$^(B 0)
+    (?$(5$_(B 0)
+    (?$(5$`(B 0)
+    (?$(5$a(B 0)
+    (?$(5$b(B 0)
+    (?$(5$c(B 0)
+    (?$(5$d(B 0)
+    (?$(5$e(B 0)
+    (?$(5$f(B 0)
+    (?$(5$g(B 0)
+    (?$(5$h(B 0)
+    (?$(5$i(B 0)
+    (?$(5$j(B 0)
+    (?$(5$k(B 0)
+    (?$(5$l(B 0)
+    (?$(5$m(B 0)
+    (?$(5$n(B 0)
+    (?$(5$o(B 0)
+    (?$(5$p(B 0)
+    (?$(5$q(B 0)
+    (?$(5$r(B 0)
+    (?$(5$s(B 0)
+    (?$(5$t(B 0)
+    (?$(5$u(B 0)
+    (?$(5$v(B 0)
+    (?$(5$w(B 0)
+    (?$(5$x(B 0)
+    (?$(5$y(B 0)
+    (?$(5$z(B 0)
+    (?$(5${(B 0)
+    (?$(5$|(B 0)
+    (?$(5$}(B 0)
+    (?$(5$~(B 0)
+    ))
+
+;; Determine composition priority and rule of the array of Glyphs.
+;; Sort the glyphs with their priority.
+
+;; Example:
+;;(devanagari-reorder-glyph-for-composition '[?$(5"5(B ?$(5!X(B ?$(5![(B])
+;;      => ((446680 0) (446773 0) (446683 50 (ml . mr)))
+
+(defun devanagari-reorder-glyph-for-composition (glyph-alist)
+  (let* ((pos 0)
+         (ordered-glyphs '()))
+    (while (< pos (length glyph-alist))
+      (let* ((glyph (aref glyph-alist pos)))
+        (setq pos (1+ pos))
+        (setq ordered-glyphs 
+              (append ordered-glyphs (list (assq glyph devanagari-composition-rules))))))
+    (sort ordered-glyphs '(lambda (x y) (< (car (cdr x)) (car (cdr y)))))))
+
+;;(devanagari-compose-to-one-glyph "$(5"5!X![(B") => "2$(6!XP"5@![1(B"
+
+(defun devanagari-compose-to-one-glyph (devanagari-string)
+  (let* ((o-glyph-list (devanagari-reorder-glyph-for-composition
+                        (string-to-vector devanagari-string)))
+         ;; List of glyphs to be composed.
+         (cmp-glyph-list (list (car (car o-glyph-list)))) 
+         (o-glyph-list (cdr o-glyph-list)))
+    (while o-glyph-list
+      (let* ((o-glyph (car o-glyph-list))
+             (glyph (if (< 2 (length o-glyph))
+                        ;; default composition
+                        (list (car (cdr (cdr o-glyph))) (car o-glyph))
+                      ;; composition with a specified rule
+                      (list '(mr . ml) (car o-glyph)))))
+        (setq o-glyph-list (cdr o-glyph-list))
+        (setq cmp-glyph-list (append cmp-glyph-list glyph))))
+    ;; Before applying compose-chars, convert glyphs to
+    ;; 1-column width if possible.
+    (setq cmp-glyph-list (devanagari-wide-to-narrow cmp-glyph-list))
+    (if (= (length cmp-glyph-list) 1) (char-to-string (car cmp-glyph-list))
+      (apply 'compose-chars cmp-glyph-list))))
+
+
+;;
+;;    Phase 2.5  Convert Appropriate Character to 1-column shape.
+;;
+;; This is temporary and should be removed out when Emacs supports 
+;; variable width characters.
+;;
+;; This will convert the composing glyphs (2 column glyphs) 
+;; to narrow (1 column) glyphs if they exist.
+;;
+;; devanagari-wide-to-narrow-old converts glyphs simply.
+;; devanagari-wide-to-narrow takes care of upper/lower apply-glyphs 
+;;   with 2 column base-glyph.
+;;
+;; Execution Examples
+;;(devanagari-wide-to-narrow '(446680 446773 (ml . mr) 446683))
+;;(devanagari-wide-to-narrow '(?$(5!6(B (ml . ml) 446773 (tc . mr) 446683))
+
+(defun devanagari-wide-to-narrow (src-list)
+  (if (null src-list) '()
+    (cons 
+     (if (and (numberp (car src-list))
+              (cdr (assq (car src-list) devanagari-1-column-char)))
+         (cdr (assq (car src-list) devanagari-1-column-char))
+       (car src-list))
+     (devanagari-wide-to-narrow (cdr src-list)))))
+
+;; Make this function obsolete temporary Because now Emacs supports
+;; attaching 1 column character at the center 2 column char.  However,
+;; there are still problems attempting to attach Halant or Nukta sign
+;; at the non-vowel consonant.  This problem can not be solved until
+;; Emacs supports attaching the glyph at `temporary-preserved metric'.
+
+(defun devanagari-wide-to-narrow-old (src-list)
+  (if (null src-list) (progn (error "devanagari-wide-to-narrow error") nil)
+    (let* ((base-glyph (cdr (assq (car src-list) devanagari-1-column-char)))
+           (wide-base-glyph nil)
+           (apply-glyph-list (cdr src-list)))
+      (if (null base-glyph)
+          (progn 
+            (setq wide-base-glyph t)
+            (setq base-glyph (car src-list))))
+      (cons base-glyph
+            (devanagari-wide-to-narrow-iter apply-glyph-list wide-base-glyph))
+      )))
+
+;; Convert apply-glyph-list from 2-column to 1-column.
+;;   wide-base-glyph is t when base-glyph is 2-column.
+;;   When apply-glyph is put at the top or bottom of 2-column base-glyph,
+;;   they must be 2-column glyph, too.  Otherwise, they will be 
+;;   converted to 1-column glyph if possible.
+
+(defun devanagari-wide-to-narrow-iter (apply-glyph-list wide-base-glyph)
+  (if (< (length apply-glyph-list) 2) '()
+    (let* ((apply-dir    (car apply-glyph-list))
+           (apply-glyph  (car (cdr apply-glyph-list)))
+           (apply-rest   (cdr (cdr apply-glyph-list)))
+           (put-t-or-b   (member (car apply-dir) '(tl tc tr bl bc br)))
+           (narrow-glyph (cdr (assq apply-glyph devanagari-1-column-char))))
+      (append 
+       (list apply-dir
+             (if (or (and wide-base-glyph put-t-or-b)
+                     (null narrow-glyph))
+                 apply-glyph narrow-glyph))
+       (devanagari-wide-to-narrow-iter apply-rest wide-base-glyph)))))
+
+;;
+;; Summary
+;; 
+
+;;;###autoload
+(defun devanagari-compose-string (str)
+  (let ((len (length str))
+        (src str) (dst "") rest match-b match-e)
+    (while (string-match devanagari-composite-glyph-unit-examine src)
+      (setq match-b (match-beginning 0) match-e (match-end 0))
+      (setq dst 
+            (concat dst 
+                    (substring src 0 match-b)
+                    (devanagari-compose-to-one-glyph 
+                     (char-to-glyph-devanagari
+                      (substring src match-b match-e)))))
+      (setq src (substring src match-e)))
+    (setq dst (concat dst src))
+    dst))
+
+;;;###autoload
+(defun devanagari-compose-region (from to)
+  (interactive "r")
+  (save-restriction
+    (narrow-to-region from to)
+    (goto-char (point-min))
+    (while (re-search-forward devanagari-composite-glyph-unit-examine nil t)
+      (let* ((match-b (match-beginning 0)) (match-e (match-end 0))
+             (cmps (devanagari-compose-to-one-glyph
+                    (char-to-glyph-devanagari
+                     (buffer-substring match-b match-e)))))
+        (delete-region match-b match-e)
+        (insert cmps)))))
+
+;;
+;; Decomposition of composite font.
+;;
+
+(defun devanagari-normalize-narrow-glyph (charlist)
+  (let ((wide-char (car (rassoc (car charlist) devanagari-1-column-char))))
+    (if (null charlist) nil
+      (cons (if (null wide-char) (car charlist) wide-char)
+            (devanagari-normalize-narrow-glyph (cdr charlist))))))
+
+(defvar devanagari-decomposition-rules
+  '(
+    (?$(5"p(B -20)
+    )
+  )
+
+(defun devanagari-reorder-glyph-for-decomposition (glyphlist)
+  "This function re-orders glyph list."
+  (sort glyphlist 
+        '(lambda (x y) 
+           (let ((xx (assoc x devanagari-decomposition-rules))
+                 (yy (assoc y devanagari-decomposition-rules)))
+             (if (null xx) (setq xx 0))
+             (if (null yy) (setq yy 0))
+             (< xx yy)))))
+
+(defun devanagari-decompose-char (char)
+  "This function decomposes one Devanagari composite character to 
+   basic Devanagari character."
+  (let ((glyphlist (decompose-composite-char char)))
+    (if (not (listp glyphlist)) 
+        (setq glyphlist (list glyphlist)))
+    (setq glyphlist (devanagari-normalize-narrow-glyph glyphlist))
+    (mapconcat '(lambda (x) (let ((char (get-char-code-property 
+                                         x 'glyph-to-char)))
+                           (if (null char) (char-to-string x) char)))
+               (devanagari-reorder-glyph-for-decomposition glyphlist)
+               "")))
+
+;;;###autoload
+(defun devanagari-decompose-string (str)
+  "This function Decomposes Devanagari glyph string to 
+basic Devanagari character string."
+  (let ((src str) (dst ""))
+    (while (not (equal src ""))
+      (let* ((char (string-to-char src))
+             (clen (char-bytes char)))
+        (setq src (substring src clen))
+        (setq dst (concat dst
+                          (devanagari-decompose-char char)))))
+    dst))
+
+;;;###autoload
+(defun devanagari-decompose-region (from to)
+  (interactive "r")
+  (save-restriction
+    (narrow-to-region from to)
+    (goto-char (point-min))
+    (while (re-search-forward "." nil t)
+      (let* ((match-b (match-beginning 0)) (match-e (match-end 0))
+             (decmps (devanagari-decompose-string (buffer-substring match-b match-e))))
+        (delete-char -1)
+        (insert decmps)))))
+
+
+
+;; For pre-write and post-read conversion
+
+;;;###autoload
+(defun devanagari-compose-from-is13194-region (from to)
+  "Compose IS 13194 characters in the region to Devanagari characters."
+  (interactive "r")
+  (save-restriction
+    (narrow-to-region from to)
+    (indian-to-devanagari-region (point-min) (point-max))
+    (devanagari-compose-region (point-min) (point-max))))
+
+;;;###autoload
+(defun devanagari-decompose-to-is13194-region (from to)
+  "Decompose Devanagari characters in the region to IS 13194 characters."
+  (interactive "r")
+  (save-restriction
+    (narrow-to-region from to)
+    (devanagari-decompose-region (point-min) (point-max))
+    (devanagari-to-indian-region (point-min) (point-max))))
+
+;;
+(provide 'language/devan-util)
+
+;;; Local Variables:
+;;; generated-autoload-file: "../loaddefs.el"
+;;; End:
+;;; devan-util.el ends here
diff --git a/lisp/language/devanagari.el b/lisp/language/devanagari.el
new file mode 100644
index 00000000000..2f2ab1160aa
--- /dev/null
+++ b/lisp/language/devanagari.el
@@ -0,0 +1,541 @@
+;;; devanagari.el --- Support for Devanagari Languages
+
+;; Copyright (C) 1996 Free Software Foundation, Inc.
+
+;; Author: KAWABATA, Taichi <kawabata@is.s.u-tokyo.ac.jp>
+
+;; Keywords: multilingual, Indian, Devanagari
+
+;; 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.
+
+;;; Commentary:
+
+;; History:
+;; 1996.9.18 written by KAWABATA, Taichi <kawabata@is.s.u-tokyo.ac.jp>
+
+;;; Code:
+
+(make-coding-system
+ 'coding-system-is13194-devanagari 2 ?D
+ "Coding-system used for ASCII(MSB=0) & IS13194-Devanagari(MSB=1)."
+ '((ascii t) (indian-is13194 t) nil nil
+   nil ascii-eol))
+(put 'coding-system-is13194-devanagari
+     'post-read-conversion 'devanagari-compose-from-is13194-region)
+(put 'coding-system-is13194-devanagari
+     'pre-write-conversion 'devanagari-decompose-to-is13194-region)
+
+(register-input-method
+ "Devanagari" '("quail-devanagari-transliteration" quail-use-package
+                "quail/devanagari"))
+
+(register-input-method
+ "Devanagari" '("quail-devanagari-keyboard-a" quail-use-package
+                "quail/devanagari"))
+
+(register-input-method
+ "Devanagari" '("quail-devanagari-itrans" quail-use-package
+                "quail/devanagari"))
+
+(defun setup-devanagari-environment ()
+  (setq coding-category-iso-8-1 'coding-system-is13194-devanagari)
+
+  (set-coding-priority
+   '(coding-category-iso-7
+     coding-category-iso-8-1))
+
+  (setq-default buffer-file-coding-system 'coding-system-is13194-devanagari)
+
+  (setq default-input-method '("Devanagari" . "quail-devanagari-itrans"))
+  )
+
+(set-language-info-alist
+ "Devanagari" '((setup-function . setup-devanagari-environment)
+                (charset . (indian-is13194 indian-2-column indian-1-column))
+                (coding-system . (coding-system-is13194-devanagari))
+                (documentation . t)))
+
+(let ((deflist  '(;; chars      syntax  category
+                  ("$(5!!!"!#(B"      "w"     ?7) ; vowel-modifying diacritical mark
+                                            ; chandrabindu, anuswar, visarga
+                  ("$(5!$(B-$(5!2(B"        "w"     ?5) ; independent vowel
+                  ("$(5!3(B-$(5!X(B"        "w"     ?0) ; consonant
+                  ("$(5!Z(B-$(5!g(B"        "w"     ?8) ; matra
+                  ("$(5!q(B-$(5!z(B"        "w"     ?6) ; digit
+                  ))
+      elm chars len syntax category to ch i)
+  (while deflist
+    (setq elm (car deflist))
+    (setq chars (car elm)
+          len (length chars)
+          syntax (nth 1 elm)
+          category (nth 2 elm)
+          i 0)
+    (while (< i len)
+      (if (= (aref chars i) ?-)
+          (setq i (1+ i)
+                to (sref chars i))
+        (setq ch (sref chars i)
+              to ch))
+      (while (<= ch to)
+        (modify-syntax-entry ch syntax)
+        (modify-category-entry ch category)
+        (setq ch (1+ ch)))
+      (setq i (+ i (char-bytes to))))
+    (setq deflist (cdr deflist))))
+
+;;
+;; Devanagari Glyph List
+;;
+;;2120   $(5!!!"!#!$!%!&!'!(!)!*!+!,!-!.!/(B
+;;2130 $(5!0!1!2!3!4!5!6!7!8!9!:!;!<!=!>!?(B
+;;2140 $(5!@!A!B!C!D!E!F!G!H!I!J!K!L!M!N!O(B
+;;2150 $(5!P!Q!R!S!T!U!V!W!X!Y!Z![!\!]!^!_(B
+;;2160 $(5!`!a!b!c!d!e!f!g!h!i!j!k!l!m!n!o(B
+;;2170 $(5!p!q!r!s!t!u!v!w!x!y!z!{!|!}!~(B
+;;
+;;2220 $(5"!"""#"$"%"&"'"(")"*"+","-"."/(B
+;;2230 $(5"0"1"2"3"4"5"6"7"8"9":";"<"=">"?(B
+;;2240 $(5"@"A"B"C"D"E"F"G"H"I"J"K"L"M"N"O(B
+;;2250 $(5"P"Q"R"S"T"U"V"W"X"Y"Z"["\"]"^"_(B
+;;2260 $(5"`"a"b"c"d"e"f"g"h"i"j"k"l"m"n"o(B
+;;2270 $(5"p"q"r"s"t"u"v"w"x"y"z"{"|"}"~(B
+;;
+;;2320 $(5#!#"###$#%#&#'#(#)#*#+#,#-#.#/(B
+;;2330 $(5#0#1#2#3#4#5#6#7#8#9#:#;#<#=#>#?(B
+;;2340 $(5#@#A#B#C#D#E#F#G#H#I#J#K#L#M#N#O(B
+;;2350 $(5#P#Q#R#S#T#U#V#W#X#Y#Z#[#\#]#^#_(B
+;;2360 $(5#`#a#b#c#d#e#f#g#h#i#j#k#l#m#n#o(B
+;;2370 $(5#p#q#r#s#t#u#v#w#x#y#z#{#|#}#~(B
+;;
+;;2420 $(5$!$"$#$$$%$&$'$($)$*$+$,$-$.$/(B
+;;2430 $(5$0$1$2$3$4$5$6$7$8$9$:$;$<$=$>$?(B
+;;2440 $(5$@$A$B$C$D$E$F$G$H$I$J$K$L$M$N$O(B
+;;2450 $(5$P$Q$R$S$T$U$V$W$X$Y$Z$[$\$]$^$_(B
+;;2460 $(5$`$a$b$c$d$e$f$g$h$i$j$k$l$m$n$o(B
+;;2470 $(5$p$q$r$s$t$u$v$w$x$y$z${$|$}$~(B
+;;
+;;2120  $(6!!!"!#!$!%!&!'!(!)!*!+!,!-!.!/(B
+;;2130 $(6!0!1!2!3!4!5!6!7!8!9!:!;!<!=!>!?(B
+;;2140 $(6!@!A!B!C!D!E!F!G!H!I!J!K!L!M!N!O(B
+;;2150 $(6!P!Q!R!S!T!U!V!W!X!Y!Z![!\!]!^!_(B
+;;2160 $(6!`!a!b!c!d!e!f!g!h!i!j!k!l!m!n!o(B
+;;2170 $(6!p!q!r!s!t!u!v!w!x!y!z!{!|!}!~(B
+;;
+;;2220  $(6"!"""#"$"%"&"'"(")"*"+","-"."/(B
+;;2230 $(6"0"1"2"3"4"5"6"7"8"9":";"<"=">"?(B
+;;2240 $(6"@"A"B"C"D"E"F"G"H"I"J"K"L"M"N"O(B
+;;2250 $(6"P"Q"R"S"T"U"V"W"X"Y"Z"["\"]"^"_(B
+;;2260 $(6"`"a"b"c"d"e"f"g"h"i"j"k"l"m"n"o(B
+;;2270 $(6"p"q"r"s"t"u"v"w"x"y"z"{"|"}"~(B
+;;2320  $(6#!#"###$#%#&#'#(#)#*#+#,#-#.#/(B
+;;2330 $(6#0#1#2#3#4#5#6#7#8#9#:#;#<#=#>#?(B
+;;2340 $(6#@#A#B#C#D#E#F#G#H#I#J#K#L#M#N#O(B
+;;2350 $(6#P#Q#R#S#T#U#V#W#X#Y#Z#[#\#]#^#_(B
+;;2360 $(6#`#a#b#c#d#e#f#g#h#i#j#k#l#m#n#o(B
+;;2370 $(6#p#q#r#s#t#u#v#w#x#y#z#{#|#}#~(B
+;;
+;;2320  $(6$!$"$#$$$%$&$'$($)$*$+$,$-$.$/(B
+;;2430 $(6$0$1$2$3$4$5$6$7$8$9$:$;$<$=$>$?(B
+;;2440 $(6$@$A$B$C$D$E$F$G$H$I$J$K$L$M$N$O(B
+;;2450 $(6$P$Q$R$S$T$U$V$W$X$Y$Z$[$\$]$^$_(B
+;;2460 $(6$`$a$b$c$d$e$f$g$h$i$j$k$l$m$n$o(B
+;;2470 $(6$p$q$r$s$t$u$v$w$x$y$z${$|$}$~(B
+;;
+;;
+;; Modify the following table if you change the set of 1-column font.
+;;
+(defconst devanagari-1-column-char 
+  '((?$(5!!(B . ?$(6!!(B)
+    (?$(5!"(B . ?$(6!"(B)
+    (?$(5!#(B . ?$(6!#(B)
+    (?$(5!$(B . nil)
+    (?$(5!%(B . nil)
+    (?$(5!&(B . ?$(6!&(B)
+    (?$(5!'(B . ?$(6!'(B)
+    (?$(5!((B . ?$(6!((B)
+    (?$(5!)(B . nil)
+    (?$(5!*(B . nil)
+    (?$(5!+(B . nil)
+    (?$(5!,(B . nil)
+    (?$(5!-(B . nil)
+    (?$(5!.(B . nil)
+    (?$(5!/(B . nil)
+    (?$(5!0(B . nil)
+    (?$(5!1(B . nil)
+    (?$(5!2(B . nil)
+    (?$(5!3(B . nil)
+    (?$(5!4(B . nil)
+    (?$(5!5(B . ?$(6!5(B)
+    (?$(5!6(B . nil)
+    (?$(5!7(B . nil)
+    (?$(5!8(B . nil)
+    (?$(5!9(B . nil)
+    (?$(5!:(B . nil)
+    (?$(5!;(B . nil)
+    (?$(5!<(B . nil)
+    (?$(5!=(B . ?$(6!=(B)
+    (?$(5!>(B . ?$(6!>(B)
+    (?$(5!?(B . ?$(6!?(B)
+    (?$(5!@(B . ?$(6!@(B)
+    (?$(5!A(B . nil)
+    (?$(5!B(B . ?$(6!B(B)
+    (?$(5!C(B . ?$(6!C(B)
+    (?$(5!D(B . ?$(6!D(B)
+    (?$(5!E(B . ?$(6!E(B)
+    (?$(5!F(B . ?$(6!F(B)
+    (?$(5!G(B . ?$(6!G(B)
+    (?$(5!H(B . ?$(6!H(B)
+    (?$(5!I(B . nil)
+    (?$(5!J(B . ?$(6!J(B)
+    (?$(5!K(B . ?$(6!K(B)
+    (?$(5!L(B . ?$(6!L(B)
+    (?$(5!M(B . ?$(6!M(B)
+    (?$(5!N(B . ?$(6!N(B)
+    (?$(5!O(B . ?$(6!O(B)
+    (?$(5!P(B . ?$(6!P(B)
+    (?$(5!Q(B . nil)
+    (?$(5!R(B . nil)
+    (?$(5!S(B . nil)
+    (?$(5!T(B . ?$(6!T(B)
+    (?$(5!U(B . nil)
+    (?$(5!V(B . ?$(6!V(B)
+    (?$(5!W(B . ?$(6!W(B)
+    (?$(5!X(B . ?$(6!X(B)
+    (?$(5!Y(B . nil)
+    (?$(5!Z(B . ?$(6!Z(B)
+    (?$(5![(B . ?$(6![(B)
+    (?$(5!\(B . ?$(6!\(B)
+    (?$(5!](B . ?$(6!](B)
+    (?$(5!^(B . ?$(6!^(B)
+    (?$(5!_(B . ?$(6!_(B)
+    (?$(5!`(B . ?$(6!`(B)
+    (?$(5!a(B . ?$(6!a(B)
+    (?$(5!b(B . ?$(6!b(B)
+    (?$(5!c(B . ?$(6!c(B)
+    (?$(5!d(B . ?$(6!d(B)
+    (?$(5!e(B . ?$(6!e(B)
+    (?$(5!f(B . ?$(6!f(B)
+    (?$(5!g(B . ?$(6!g(B)
+    (?$(5!h(B . ?$(6!h(B)
+    (?$(5!i(B . ?$(6!i(B)
+    (?$(5!j(B . ?$(6!j(B)
+    (nil . nil)
+    (nil . nil)
+    (nil . nil)
+    (nil . nil)
+    (nil . nil)
+    (nil . nil)
+    (?$(5!q(B . ?$(6!q(B)
+    (?$(5!r(B . ?$(6!r(B)
+    (?$(5!s(B . ?$(6!s(B)
+    (?$(5!t(B . ?$(6!t(B)
+    (?$(5!u(B . ?$(6!u(B)
+    (?$(5!v(B . ?$(6!v(B)
+    (?$(5!w(B . ?$(6!w(B)
+    (?$(5!x(B . ?$(6!x(B)
+    (?$(5!y(B . ?$(6!y(B)
+    (?$(5!z(B . ?$(6!z(B)
+    (nil . nil)
+    (nil . nil)
+    (nil . nil)
+    (nil . nil)
+    (?$(5"!(B . nil)
+    (?$(5""(B . nil)
+    (?$(5"#(B . nil)
+    (?$(5"$(B . nil)
+    (?$(5"%(B . ?$(6"%(B)
+    (?$(5"&(B . ?$(6"&(B)
+    (?$(5"'(B . nil)
+    (?$(5"((B . nil)
+    (?$(5")(B . nil)
+    (?$(5"*(B . nil)
+    (?$(5"+(B . nil)
+    (?$(5",(B . ?$(6",(B)
+    (?$(5"-(B . nil)
+    (?$(5".(B . ?$(6".(B)
+    (?$(5"/(B . nil)
+    (?$(5"0(B . nil)
+    (?$(5"1(B . nil)
+    (?$(5"2(B . nil)
+    (?$(5"3(B . ?$(6"3(B)
+    (?$(5"4(B . ?$(6"4(B)
+    (?$(5"5(B . ?$(6"5(B)
+    (?$(5"6(B . ?$(6"6(B)
+    (?$(5"7(B . nil)
+    (?$(5"8(B . ?$(6"8(B)
+    (?$(5"9(B . nil)
+    (?$(5":(B . ?$(6":(B)
+    (?$(5";(B . ?$(6";(B)
+    (?$(5"<(B . ?$(6"<(B)
+    (?$(5"=(B . nil)
+    (?$(5">(B . nil)
+    (?$(5"?(B . nil)
+    (?$(5"@(B . nil)
+    (?$(5"A(B . ?$(6"A(B)
+    (?$(5"B(B . ?$(6"B(B)
+    (?$(5"C(B . ?$(6"C(B)
+    (?$(5"D(B . nil)
+    (?$(5"E(B . ?$(6"E(B)
+    (?$(5"F(B . ?$(6"F(B)
+    (?$(5"G(B . ?$(6"G(B)
+    (?$(5"H(B . ?$(6"H(B)
+    (?$(5"I(B . ?$(6"I(B)
+    (?$(5"J(B . ?$(6"J(B)
+    (?$(5"K(B . ?$(6"K(B)
+    (?$(5"L(B . ?$(6"L(B)
+    (?$(5"M(B . ?$(6"M(B)
+    (?$(5"N(B . ?$(6"N(B)
+    (?$(5"O(B . nil)
+    (?$(5"P(B . nil)
+    (?$(5"Q(B . ?$(6"Q(B)
+    (?$(5"R(B . nil)
+    (?$(5"S(B . nil)
+    (?$(5"T(B . ?$(6"T(B)
+    (?$(5"U(B . ?$(6"U(B)
+    (?$(5"V(B . ?$(6"V(B)
+    (?$(5"W(B . ?$(6"W(B)
+    (?$(5"X(B . nil)
+    (?$(5"Y(B . nil)
+    (?$(5"Z(B . nil)
+    (?$(5"[(B . nil)
+    (?$(5"\(B . nil)
+    (?$(5"](B . nil)
+    (?$(5"^(B . nil)
+    (?$(5"_(B . nil)
+    (?$(5"`(B . ?$(6"`(B)
+    (?$(5"a(B . ?$(6"a(B)
+    (?$(5"b(B . ?$(6"b(B)
+    (?$(5"c(B . ?$(6"c(B)
+    (?$(5"d(B . ?$(6"d(B)
+    (?$(5"e(B . ?$(6"e(B)
+    (?$(5"f(B . ?$(6"f(B)
+    (?$(5"g(B . ?$(6"g(B)
+    (?$(5"h(B . ?$(6"h(B)
+    (?$(5"i(B . ?$(6"i(B)
+    (?$(5"j(B . ?$(6"j(B)
+    (?$(5"k(B . nil)
+    (?$(5"l(B . ?$(6"l(B)
+    (?$(5"m(B . ?$(6"m(B)
+    (?$(5"n(B . nil)
+    (?$(5"o(B . nil)
+    (?$(5"p(B . ?$(6"p(B)
+    (?$(5"q(B . ?$(6"q(B)
+    (?$(5"r(B . ?$(6"r(B)
+    (?$(5"s(B . ?$(6"s(B)
+    (?$(5"t(B . ?$(6"t(B)
+    (?$(5"u(B . ?$(6"u(B)
+    (?$(5"v(B . nil)
+    (?$(5"w(B . nil)
+    (?$(5"x(B . nil)
+    (?$(5"y(B . ?$(6"y(B)
+    (?$(5"z(B . ?$(6"z(B)
+    (?$(5"{(B . nil)
+    (?$(5"|(B . nil)
+    (?$(5"}(B . nil)
+    (?$(5"~(B . nil)
+    (?$(5#!(B . nil)
+    (?$(5#"(B . nil)
+    (?$(5##(B . nil)
+    (?$(5#$(B . nil)
+    (?$(5#%(B . nil)
+    (?$(5#&(B . ?$(6#&(B)
+    (?$(5#'(B . ?$(6#'(B)
+    (?$(5#((B . nil)
+    (?$(5#)(B . nil)
+    (?$(5#*(B . ?$(6#*(B)
+    (?$(5#+(B . nil)
+    (?$(5#,(B . nil)
+    (?$(5#-(B . nil)
+    (?$(5#.(B . nil)
+    (?$(5#/(B . nil)
+    (?$(5#0(B . nil)
+    (?$(5#1(B . nil)
+    (?$(5#2(B . nil)
+    (?$(5#3(B . nil)
+    (?$(5#4(B . nil)
+    (?$(5#5(B . ?$(6#5(B)
+    (?$(5#6(B . nil)
+    (?$(5#7(B . nil)
+    (?$(5#8(B . nil)
+    (?$(5#9(B . nil)
+    (?$(5#:(B . nil)
+    (?$(5#;(B . nil)
+    (?$(5#<(B . nil)
+    (?$(5#=(B . nil)
+    (?$(5#>(B . nil)
+    (?$(5#?(B . ?$(6#?(B)
+    (?$(5#@(B . ?$(6#@(B)
+    (?$(5#A(B . nil)
+    (?$(5#B(B . nil)
+    (?$(5#C(B . nil)
+    (?$(5#D(B . nil)
+    (?$(5#E(B . nil)
+    (?$(5#F(B . nil)
+    (?$(5#G(B . nil)
+    (?$(5#H(B . nil)
+    (?$(5#I(B . nil)
+    (?$(5#J(B . ?$(6#J(B)
+    (?$(5#K(B . nil)
+    (?$(5#L(B . nil)
+    (?$(5#M(B . nil)
+    (?$(5#N(B . nil)
+    (?$(5#O(B . nil)
+    (?$(5#P(B . nil)
+    (?$(5#Q(B . nil)
+    (?$(5#R(B . ?$(6#R(B)
+    (?$(5#S(B . nil)
+    (?$(5#T(B . nil)
+    (?$(5#U(B . nil)
+    (?$(5#V(B . nil)
+    (?$(5#W(B . nil)
+    (?$(5#X(B . nil)
+    (?$(5#Y(B . nil)
+    (?$(5#Z(B . nil)
+    (?$(5#[(B . nil)
+    (?$(5#\(B . nil)
+    (?$(5#](B . nil)
+    (?$(5#^(B . nil)
+    (?$(5#_(B . nil)
+    (?$(5#`(B . nil)
+    (?$(5#a(B . ?$(6#a(B)
+    (?$(5#b(B . ?$(6#b(B)
+    (?$(5#c(B . nil)
+    (?$(5#d(B . nil)
+    (?$(5#e(B . nil)
+    (?$(5#f(B . nil)
+    (?$(5#g(B . nil)
+    (?$(5#h(B . nil)
+    (?$(5#i(B . nil)
+    (?$(5#j(B . ?$(6#j(B)
+    (?$(5#k(B . ?$(6#k(B)
+    (?$(5#l(B . ?$(6#l(B)
+    (?$(5#m(B . nil)
+    (?$(5#n(B . nil)
+    (?$(5#o(B . nil)
+    (?$(5#p(B . nil)
+    (?$(5#q(B . nil)
+    (?$(5#r(B . nil)
+    (?$(5#s(B . nil)
+    (?$(5#t(B . nil)
+    (?$(5#u(B . nil)
+    (?$(5#v(B . nil)
+    (?$(5#w(B . nil)
+    (?$(5#x(B . nil)
+    (?$(5#y(B . nil)
+    (?$(5#z(B . nil)
+    (?$(5#{(B . nil)
+    (?$(5#|(B . nil)
+    (?$(5#}(B . nil)
+    (?$(5#~(B . nil)
+    (?$(5$!(B . nil)
+    (?$(5$"(B . nil)
+    (?$(5$#(B . nil)
+    (?$(5$$(B . nil)
+    (?$(5$%(B . nil)
+    (?$(5$&(B . nil)
+    (?$(5$'(B . nil)
+    (?$(5$((B . nil)
+    (?$(5$)(B . nil)
+    (?$(5$*(B . nil)
+    (?$(5$+(B . nil)
+    (?$(5$,(B . nil)
+    (?$(5$-(B . nil)
+    (?$(5$.(B . nil)
+    (?$(5$/(B . nil)
+    (?$(5$0(B . nil)
+    (?$(5$1(B . nil)
+    (?$(5$2(B . nil)
+    (?$(5$3(B . nil)
+    (?$(5$4(B . nil)
+    (?$(5$5(B . nil)
+    (?$(5$6(B . nil)
+    (?$(5$7(B . nil)
+    (?$(5$8(B . nil)
+    (?$(5$9(B . nil)
+    (?$(5$:(B . nil)
+    (?$(5$;(B . nil)
+    (?$(5$<(B . nil)
+    (?$(5$=(B . nil)
+    (?$(5$>(B . nil)
+    (?$(5$?(B . nil)
+    (?$(5$@(B . nil)
+    (?$(5$A(B . ?$(6$A(B)
+    (?$(5$B(B . nil)
+    (?$(5$C(B . nil)
+    (?$(5$D(B . nil)
+    (?$(5$E(B . ?$(6$E(B)
+    (?$(5$F(B . nil)
+    (?$(5$G(B . nil)
+    (?$(5$H(B . ?$(6$H(B)
+    (?$(5$I(B . ?$(6$I(B)
+    (?$(5$J(B . ?$(6$J(B)
+    (?$(5$K(B . nil)
+    (?$(5$L(B . nil)
+    (?$(5$M(B . nil)
+    (?$(5$N(B . ?$(6$N(B)
+    (?$(5$O(B . nil)
+    (?$(5$P(B . ?$(6$P(B)
+    (?$(5$Q(B . ?$(6$Q(B)
+    (?$(5$R(B . ?$(6$R(B)
+    (?$(5$S(B . nil)
+    (?$(5$T(B . nil)
+    (?$(5$U(B . nil)
+    (?$(5$V(B . nil)
+    (?$(5$W(B . nil)
+    (?$(5$X(B . nil)
+    (?$(5$Y(B . nil)
+    (?$(5$Z(B . nil)
+    (?$(5$[(B . nil)
+    (?$(5$\(B . nil)
+    (?$(5$](B . nil)
+    (?$(5$^(B . nil)
+    (?$(5$_(B . nil)
+    (?$(5$`(B . nil)
+    (?$(5$a(B . nil)
+    (?$(5$b(B . nil)
+    (?$(5$c(B . nil)
+    (?$(5$d(B . nil)
+    (?$(5$e(B . nil)
+    (?$(5$f(B . nil)
+    (?$(5$g(B . nil)
+    (?$(5$h(B . ?$(6$h(B)
+    (?$(5$i(B . ?$(6$i(B)
+    (?$(5$j(B . ?$(6$j(B)
+    (?$(5$k(B . nil)
+    (?$(5$l(B . ?$(6$l(B)
+    (?$(5$m(B . ?$(6$m(B)
+    (?$(5$n(B . ?$(6$n(B)
+    (?$(5$o(B . nil)
+    (?$(5$p(B . ?$(6$p(B)
+    (?$(5$q(B . ?$(6$q(B)
+    (?$(5$r(B . ?$(6$r(B)
+    (?$(5$s(B . nil)
+    (?$(5$t(B . nil)
+    (?$(5$u(B . ?$(6$u(B)
+    (?$(5$v(B . ?$(6$v(B)
+    (?$(5$w(B . nil)
+    (?$(5$x(B . ?$(6$x(B)
+    (?$(5$y(B . ?$(6$y(B)
+    (?$(5$z(B . nil)
+    (?$(5${(B . nil)
+    (?$(5$|(B . nil)
+    (?$(5$}(B . nil)
+    (?$(5$~(B . nil)
+    ))
+
+;;; devanagari.el ends here
diff --git a/lisp/language/ethio-util.el b/lisp/language/ethio-util.el
new file mode 100644
index 00000000000..7fa0a4d7c04
--- /dev/null
+++ b/lisp/language/ethio-util.el
@@ -0,0 +1,1068 @@
+;; ethio-util.el -- utilities for Ethiopic
+
+;; Copyright (C) 1995 Free Software Foundation, Inc.
+;; Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+;; Keywords: mule, multilingual, Chinese
+
+;; 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.
+
+;;; Code:
+
+;;
+;; ETHIOPIC UTILITY FUNCTIONS
+;;
+
+;; To automatically convert Ethiopic text to SERA format when sending mail,
+;;   (add-hook 'mail-send-hook 'fidel-to-sera-mail)
+;;
+;; To automatically convert SERA format to Ethiopic when receiving mail,
+;;   (add-hook 'rmail-show-message-hook 'sera-to-fidel-mail)
+;;
+;; To automatically convert Ethiopic text to SERA format when posting news,
+;;   (add-hook 'news-inews-hook 'fidel-to-sera-mail)
+;;
+;; If the filename ends in ".sera", editing will be done in fidel
+;; while file I/O will be done in sera.
+
+;;
+;; SERA to FIDEL
+;;
+   
+(defconst sera-to-fidel-table
+  [
+   nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil
+   nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil
+;;; SP  !   "   #   $   %   &   '    (   )   *   +    ,     -    .     /
+   nil nil nil nil nil nil nil ("") nil nil nil nil ("$(2$Q(B") nil ("$(2$P(B") nil
+;;; 0   1   2   3   4   5   6   7   8   9    :      ;     <   =   >   ?   @
+   nil nil nil nil nil nil nil nil nil nil ("$(2$S(B") ("$(2$R(B") nil nil nil nil nil
+;;; A
+   ("$(2"V(B" (?2 "$(2#b(B"))
+;;; B
+   ("$(2!F(B" (?e "$(2!A(B") (?u "$(2!B(B") (?i "$(2!C(B") (?a "$(2!D(B") (?E "$(2!E(B") (?o "$(2!G(B") (?| "$(2!F(B")
+         (?W "$(2!H(B" (?a "$(2!H(B")
+                  (?e "$(2!F#L(B") (?u "$(2!F#M(B") (?i "$(2!F#N(B") (?E "$(2!F#P(B") (?' "$(2!F#M(B")))
+;;; C
+   ("$(2"8(B" (?e "$(2"3(B") (?u "$(2"4(B") (?i "$(2"5(B") (?a "$(2"6(B") (?E "$(2"7(B") (?o "$(2"9(B") (?| "$(2"8(B")
+         (?W "$(2":(B" (?a "$(2":(B")
+                  (?e "$(2"8#L(B") (?u "$(2"8#M(B") (?i "$(2"8#N(B") (?E "$(2"8#P(B") (?' "$(2"8#M(B")))
+;;; D
+   ("$(2$0(B" (?e "$(2$+(B") (?u "$(2$,(B") (?i "$(2$-(B") (?a "$(2$.(B") (?E "$(2$/(B") (?o "$(2$1(B") (?| "$(2$0(B"))
+;;; E
+   ("$(2"W(B" (?2 "$(2#c(B"))
+;;; F
+   ("$(2"@(B" (?e "$(2";(B") (?u "$(2"<(B") (?i "$(2"=(B") (?a "$(2">(B") (?E "$(2"?(B") (?o "$(2"A(B") (?| "$(2"@(B")
+         (?W "$(2"B(B" (?a "$(2"B(B")
+                  (?e "$(2"@#L(B") (?u "$(2"@#M(B") (?i "$(2"@#N(B") (?E "$(2"@#P(B") (?' "$(2"@#M(B")))
+;;; G
+   ("$(2$>(B" (?e "$(2$9(B") (?u "$(2$:(B") (?i "$(2$;(B") (?a "$(2$<(B") (?E "$(2$=(B") (?o "$(2$?(B") (?| "$(2$>(B"))
+;;; H
+   ("$(2$"(B" (?e "$(2#{(B") (?u "$(2#|(B") (?i "$(2#}(B") (?a "$(2#~(B") (?E "$(2$!(B") (?o "$(2$#(B") (?| "$(2$"(B"))
+;;; I
+   ("$(2"X(B" (?2 "$(2#d(B"))
+;;; J
+   ("$(2$7(B" (?e "$(2$2(B") (?u "$(2$3(B") (?i "$(2$4(B") (?a "$(2$5(B") (?E "$(2$6(B") (?o "$(2$8(B") (?| "$(2$7(B"))
+;;; K
+   ("$(2"x(B" (?e "$(2"s(B") (?u "$(2"t(B") (?i "$(2"u(B") (?a "$(2"v(B") (?E "$(2"w(B") (?o "$(2"y(B") (?| "$(2"x(B")
+         (?W "$(2"{(B" (?e "$(2"z(B") (?u "$(2"{(B") (?i "$(2"|(B") (?a "$(2"}(B") (?E "$(2"~(B")))
+;;; L
+   ("$(2!&(B" (?e "$(2!!(B") (?u "$(2!"(B") (?i "$(2!#(B") (?a "$(2!$(B") (?E "$(2!%(B") (?o "$(2!'(B") (?| "$(2!&(B")
+         (?W "$(2!((B" (?a "$(2!((B")
+                  (?e "$(2!&#L(B") (?u "$(2!&#M(B") (?i "$(2!&#N(B") (?E "$(2!&#P(B") (?' "$(2!&#M(B")))
+;;; M
+   ("$(2!.(B" (?e "$(2!)(B") (?u "$(2!*(B") (?i "$(2!+(B") (?a "$(2!,(B") (?E "$(2!-(B") (?o "$(2!/(B") (?| "$(2!.(B")
+         (?W "$(2!0(B" (?a "$(2!0(B")
+                  (?e "$(2!.#L(B") (?u "$(2!.#M(B") (?i "$(2!.#N(B") (?E "$(2!.#P(B") (?' "$(2!.#M(B")))
+;;; N
+   ("$(2!n(B" (?e "$(2!i(B") (?u "$(2!j(B") (?i "$(2!k(B") (?a "$(2!l(B") (?E "$(2!m(B") (?o "$(2!o(B") (?| "$(2!n(B")
+         (?W "$(2!p(B" (?a "$(2!p(B")
+                  (?e "$(2!n#L(B") (?u "$(2!n#M(B") (?i "$(2!n#N(B") (?E "$(2!n#P(B") (?' "$(2!n#M(B")))
+;;; O
+   ("$(2"Y(B" (?2 "$(2#e(B"))
+;;; P
+   ("$(2$E(B" (?e "$(2$@(B") (?u "$(2$A(B") (?i "$(2$B(B") (?a "$(2$C(B") (?E "$(2$D(B") (?o "$(2$F(B") (?| "$(2$E(B"))
+;;; Q
+   ("$(2#2(B" (?e "$(2#-(B") (?u "$(2#.(B") (?i "$(2#/(B") (?a "$(2#0(B") (?E "$(2#1(B") (?o "$(2#3(B") (?| "$(2#2(B")
+         (?W "$(2#5(B" (?e "$(2#4(B") (?u "$(2#5(B") (?i "$(2#6(B") (?a "$(2#7(B") (?E "$(2#8(B")))
+;;; R
+   ("$(2!6(B" (?e "$(2!1(B") (?u "$(2!2(B") (?i "$(2!3(B") (?a "$(2!4(B") (?E "$(2!5(B") (?o "$(2!7(B") (?| "$(2!6(B")
+         (?W "$(2!8(B" (?a "$(2!8(B")
+                  (?e "$(2!6#L(B") (?u "$(2!6#M(B") (?i "$(2!6#N(B") (?E "$(2!6#P(B") (?' "$(2!6#M(B")))
+;;; S
+   ("$(2"P(B" (?e "$(2"K(B") (?u "$(2"L(B") (?i "$(2"M(B") (?a "$(2"N(B") (?E "$(2"O(B") (?o "$(2"Q(B") (?| "$(2"P(B")
+         (?W "$(2"R(B" (?a "$(2"R(B")
+                  (?e "$(2"P#L(B") (?u "$(2"P#M(B") (?i "$(2"P#N(B") (?E "$(2"P#P(B") (?' "$(2"P#M(B"))
+         (?2 "$(2#](B" (?| "$(2#](B")
+             (?e "$(2#X(B") (?u "$(2#Y(B") (?i "$(2#Z(B") (?a "$(2#[(B") (?E "$(2#\(B") (?o "$(2#^(B")
+             (?W "$(2"R(B"
+                 (?a "$(2"R(B")
+                 (?e "$(2#]#L(B") (?u "$(2#]#M(B") (?i "$(2#]#N(B") (?E "$(2#]#P(B") (?' "$(2#]#M(B"))))
+                
+;;; T
+   ("$(2"0(B" (?e "$(2"+(B") (?u "$(2",(B") (?i "$(2"-(B") (?a "$(2".(B") (?E "$(2"/(B") (?o "$(2"1(B") (?| "$(2"0(B")
+         (?W "$(2"2(B" (?a "$(2"2(B")
+                  (?e "$(2"0#L(B") (?u "$(2"0#M(B") (?i "$(2"0#N(B") (?E "$(2"0#P(B") (?' "$(2"0#M(B")))
+;;; U
+   ("$(2"T(B" (?2 "$(2#`(B"))
+;;; V
+   ("$(2!N(B" (?e "$(2!I(B") (?u "$(2!J(B") (?i "$(2!K(B") (?a "$(2!L(B") (?E "$(2!M(B") (?o "$(2!O(B") (?| "$(2!N(B")
+         (?W "$(2!P(B" (?a "$(2!P(B")
+                  (?e "$(2!N#L(B") (?u "$(2!N#M(B") (?i "$(2!N#N(B") (?E "$(2!N#P(B") (?' "$(2!N#M(B")))
+;;; W
+   ("$(2#M(B" (?e "$(2#L(B") (?u "$(2#M(B") (?i "$(2#N(B") (?a "$(2#O(B") (?E "$(2#P(B"))
+;;; X
+   ("$(2#y(B" (?e "$(2#t(B") (?u "$(2#u(B") (?i "$(2#v(B") (?a "$(2#w(B") (?E "$(2#x(B") (?o "$(2#z(B") (?| "$(2#y(B"))
+;;; Y
+   ("$(2$)(B" (?e "$(2$$(B") (?u "$(2$%(B") (?i "$(2$&(B") (?a "$(2$'(B") (?E "$(2$((B") (?o "$(2$*(B") (?| "$(2$)(B"))
+;;; Z
+   ("$(2!~(B" (?e "$(2!y(B") (?u "$(2!z(B") (?i "$(2!{(B") (?a "$(2!|(B") (?E "$(2!}(B") (?o "$(2"!(B") (?| "$(2!~(B")
+         (?W "$(2""(B" (?a "$(2""(B")
+                  (?e "$(2!~#L(B") (?u "$(2!~#M(B") (?i "$(2!~#N(B") (?E "$(2!~#P(B") (?' "$(2!~#M(B")))
+;;; [   \   ]   ^   _
+   nil nil nil nil nil
+;;; `
+   ("`"
+    (?e "$(2#_(B") (?u "$(2#`(B") (?U "$(2#`(B") (?i "$(2#a(B") (?a "$(2#b(B") (?A "$(2#b(B")
+    (?E "$(2#c(B") (?I "$(2#d(B") (?o "$(2#e(B") (?O "$(2#e(B")
+    (?s "$(2#V(B"
+        (?e "$(2#Q(B") (?u "$(2#R(B") (?i "$(2#S(B") (?a "$(2#T(B") (?E "$(2#U(B") (?o "$(2#W(B") (?| "$(2#V(B")
+        (?W "$(2"J(B" (?a "$(2"J(B")
+                 (?e "$(2#V#L(B") (?u "$(2#V#M(B") (?i "$(2#V#N(B") (?E "$(2#V#P(B") (?' "$(2#V#M(B")))
+    (?S "$(2#](B"
+        (?e "$(2#X(B") (?u "$(2#Y(B") (?i "$(2#Z(B") (?a "$(2#[(B") (?E "$(2#\(B") (?o "$(2#^(B") (?| "$(2#](B")
+        (?W "$(2"R(B" (?a "$(2"R(B")
+                 (?e "$(2#]#L(B") (?u "$(2#]#M(B") (?i "$(2#]#N(B") (?E "$(2#]#P(B") (?' "$(2#]#M(B")))
+    (?h "$(2#k(B"
+        (?e "$(2#f(B") (?u "$(2#g(B") (?i "$(2#h(B") (?a "$(2#i(B") (?E "$(2#j(B") (?o "$(2#l(B") (?| "$(2#k(B")
+        (?W "$(2"c(B" (?e "$(2"b(B") (?u "$(2"c(B") (?i "$(2"d(B") (?a "$(2"e(B") (?E "$(2"f(B")))
+    (?k "$(2#r(B"
+        (?e "$(2#m(B") (?u "$(2#n(B") (?i "$(2#o(B") (?a "$(2#p(B") (?E "$(2#q(B") (?o "$(2#s(B") (?| "$(2#r(B")))
+;;; a
+   ("$(2"S(B" (?2 "$(2#b(B"))
+
+;;; b
+   ("$(2!F(B" (?e "$(2!A(B") (?u "$(2!B(B") (?i "$(2!C(B") (?a "$(2!D(B") (?E "$(2!E(B") (?o "$(2!G(B") (?| "$(2!F(B")
+         (?W "$(2!H(B" (?a "$(2!H(B")
+                  (?e "$(2!F#L(B") (?u "$(2!F#M(B") (?i "$(2!F#N(B") (?E "$(2!F#P(B") (?' "$(2!F#M(B")))
+;;; c
+   ("$(2!^(B" (?e "$(2!Y(B") (?u "$(2!Z(B") (?i "$(2![(B") (?a "$(2!\(B") (?E "$(2!](B") (?o "$(2!_(B") (?| "$(2!^(B")
+         (?W "$(2!`(B" (?a "$(2!`(B")
+                  (?e "$(2!^#L(B") (?u "$(2!^#M(B") (?i "$(2!^#N(B") (?E "$(2!^#P(B") (?' "$(2!^#M(B")))
+;;; d
+   ("$(2"((B" (?e "$(2"#(B") (?u "$(2"$(B") (?i "$(2"%(B") (?a "$(2"&(B") (?E "$(2"'(B") (?o "$(2")(B") (?| "$(2"((B")
+         (?W "$(2"*(B" (?a "$(2"*(B")
+                  (?e "$(2"(#L(B") (?u "$(2"(#M(B") (?i "$(2"(#N(B") (?E "$(2"(#P(B") (?' "$(2"(#M(B")))
+;;; e
+   ("$(2"S(B" (?2 "$(2#_(B") (?3 "$(2"Z(B"))
+;;; f
+   ("$(2"@(B" (?e "$(2";(B") (?u "$(2"<(B") (?i "$(2"=(B") (?a "$(2">(B") (?E "$(2"?(B") (?o "$(2"A(B") (?| "$(2"@(B")
+         (?W "$(2"B(B" (?a "$(2"B(B")
+                  (?e "$(2"@#L(B") (?u "$(2"@#M(B") (?i "$(2"@#N(B") (?E "$(2"@#P(B") (?' "$(2"@#M(B")))
+;;; g
+   ("$(2#>(B" (?e "$(2#9(B") (?u "$(2#:(B") (?i "$(2#;(B") (?a "$(2#<(B") (?E "$(2#=(B") (?o "$(2#?(B") (?| "$(2#>(B")
+         (?W "$(2#A(B" (?e "$(2#@(B") (?u "$(2#A(B") (?i "$(2#B(B") (?a "$(2#C(B") (?E "$(2#D(B")))
+;;; h
+   ("$(2"`(B" (?e "$(2"[(B") (?u "$(2"\(B") (?i "$(2"](B") (?a "$(2"^(B") (?E "$(2"_(B") (?o "$(2"a(B") (?| "$(2"`(B")
+         (?W "$(2"c(B" (?e "$(2"b(B") (?u "$(2"c(B") (?i "$(2"d(B") (?a "$(2"e(B") (?E "$(2"f(B"))
+         (?2 "$(2#k(B" (?e "$(2#f(B") (?u "$(2#g(B") (?i "$(2#h(B") (?a "$(2#i(B") (?E "$(2#j(B") (?o "$(2#l(B")
+                  (?| "$(2#k(B")
+                  (?W "$(2"c(B" (?e "$(2"b(B") (?u "$(2"c(B") (?i "$(2"d(B") (?a "$(2"e(B") (?E "$(2"f(B"))))
+;;; i
+   ("$(2"U(B" (?2 "$(2#a(B"))
+;;; j
+   ("$(2$7(B" (?e "$(2$2(B") (?u "$(2$3(B") (?i "$(2$4(B") (?a "$(2$5(B") (?E "$(2$6(B") (?o "$(2$8(B") (?| "$(2$7(B"))
+;;; k
+   ("$(2"l(B" (?e "$(2"g(B") (?u "$(2"h(B") (?i "$(2"i(B") (?a "$(2"j(B") (?E "$(2"k(B") (?o "$(2"m(B") (?| "$(2"l(B")
+         (?W "$(2"o(B" (?e "$(2"n(B") (?u "$(2"o(B") (?i "$(2"p(B") (?a "$(2"q(B") (?E "$(2"r(B"))
+         (?2 "$(2#r(B" (?e "$(2#m(B") (?u "$(2#n(B") (?i "$(2#o(B") (?a "$(2#p(B") (?E "$(2#q(B") (?o "$(2#s(B")
+                  (?| "$(2#r(B")))
+;;; l
+   ("$(2!&(B" (?e "$(2!!(B") (?u "$(2!"(B") (?i "$(2!#(B") (?a "$(2!$(B") (?E "$(2!%(B") (?o "$(2!'(B") (?| "$(2!&(B")
+         (?W "$(2!((B" (?a "$(2!((B")
+                  (?e "$(2!&#L(B") (?u "$(2!&#M(B") (?i "$(2!&#N(B") (?E "$(2!&#P(B") (?' "$(2!&#M(B")))
+;;; m
+   ("$(2!.(B" (?e "$(2!)(B") (?u "$(2!*(B") (?i "$(2!+(B") (?a "$(2!,(B") (?E "$(2!-(B") (?o "$(2!/(B") (?| "$(2!.(B")
+         (?W "$(2!0(B" (?a "$(2!0(B")
+                  (?e "$(2!.#L(B") (?u "$(2!.#M(B") (?i "$(2!.#N(B") (?E "$(2!.#P(B") (?' "$(2!.#M(B")))
+;;; n
+   ("$(2!f(B" (?e "$(2!a(B") (?u "$(2!b(B") (?i "$(2!c(B") (?a "$(2!d(B") (?E "$(2!e(B") (?o "$(2!g(B") (?| "$(2!f(B")
+         (?W "$(2!h(B" (?a "$(2!h(B")
+                  (?e "$(2!f#L(B") (?u "$(2!f#M(B") (?i "$(2!f#N(B") (?E "$(2!f#P(B") (?' "$(2!f#M(B")))
+;;; o
+   ("$(2"Y(B" (?2 "$(2#e(B"))
+;;; p
+   ("$(2$L(B" (?e "$(2$G(B") (?u "$(2$H(B") (?i "$(2$I(B") (?a "$(2$J(B") (?E "$(2$K(B") (?o "$(2$M(B") (?| "$(2$L(B"))
+;;; q
+   ("$(2#&(B" (?e "$(2#!(B") (?u "$(2#"(B") (?i "$(2##(B") (?a "$(2#$(B") (?E "$(2#%(B") (?o "$(2#'(B") (?| "$(2#&(B")
+         (?W "$(2#)(B" (?e "$(2#((B") (?u "$(2#)(B") (?i "$(2#*(B") (?a "$(2#+(B") (?E "$(2#,(B")))
+;;; r
+   ("$(2!6(B" (?e "$(2!1(B") (?u "$(2!2(B") (?i "$(2!3(B") (?a "$(2!4(B") (?E "$(2!5(B") (?o "$(2!7(B") (?| "$(2!6(B")
+         (?W "$(2!8(B" (?a "$(2!8(B")
+                  (?e "$(2!6#L(B") (?u "$(2!6#M(B") (?i "$(2!6#N(B") (?E "$(2!6#P(B") (?' "$(2!6#M(B")))
+;;; s
+   ("$(2"H(B" (?e "$(2"C(B") (?u "$(2"D(B") (?i "$(2"E(B") (?a "$(2"F(B") (?E "$(2"G(B") (?o "$(2"I(B") (?| "$(2"H(B")
+         (?W "$(2"J(B" (?a "$(2"J(B")
+                  (?e "$(2"H#L(B") (?u "$(2"H#M(B") (?i "$(2"H#N(B") (?E "$(2"H#P(B") (?' "$(2"H#M(B"))
+         (?2 "$(2#V(B" (?e "$(2#Q(B") (?u "$(2#R(B") (?i "$(2#S(B") (?a "$(2#T(B") (?E "$(2#U(B") (?o "$(2#W(B")
+                  (?| "$(2#V(B")
+                  (?W "$(2"J(B" (?a "$(2"J(B")
+                           (?e "$(2#V#L(B") (?u "$(2#V#M(B") (?i "$(2#V#N(B") (?E "$(2#V#P(B")
+                           (?' "$(2#V#M(B"))))
+;;; t
+   ("$(2!V(B" (?e "$(2!Q(B") (?u "$(2!R(B") (?i "$(2!S(B") (?a "$(2!T(B") (?E "$(2!U(B") (?o "$(2!W(B") (?| "$(2!V(B")
+         (?W "$(2!X(B" (?a "$(2!X(B")
+                  (?e "$(2!V#L(B") (?u "$(2!V#M(B") (?i "$(2!V#N(B") (?E "$(2!V#P(B") (?' "$(2!V#M(B")))
+;;; u
+   ("$(2"T(B" (?2 "$(2#`(B"))
+;;; v
+   ("$(2!N(B" (?e "$(2!I(B") (?u "$(2!J(B") (?i "$(2!K(B") (?a "$(2!L(B") (?E "$(2!M(B") (?o "$(2!O(B") (?| "$(2!N(B")
+         (?W "$(2!P(B" (?a "$(2!P(B")
+                  (?e "$(2!N#L(B") (?u "$(2!N#M(B") (?i "$(2!N#N(B") (?E "$(2!N#P(B") (?' "$(2!N#M(B")))
+;;; w
+   ("$(2#J(B" (?e "$(2#E(B") (?u "$(2#F(B") (?i "$(2#G(B") (?a "$(2#H(B") (?E "$(2#I(B") (?o "$(2#K(B") (?| "$(2#J(B")
+         (?W "$(2#M(B" (?e "$(2#L(B") (?u "$(2#M(B") (?i "$(2#N(B") (?a "$(2#O(B") (?E "$(2#P(B")))
+;;; x
+   ("$(2!>(B" (?e "$(2!9(B") (?u "$(2!:(B") (?i "$(2!;(B") (?a "$(2!<(B") (?E "$(2!=(B") (?o "$(2!?(B") (?| "$(2!>(B")
+         (?W "$(2!@(B" (?a "$(2!@(B")
+                  (?e "$(2!>#L(B") (?u "$(2!>#M(B") (?i "$(2!>#N(B") (?E "$(2!>#P(B") (?' "$(2!>#M(B")))
+;;; y
+   ("$(2$)(B" (?e "$(2$$(B") (?u "$(2$%(B") (?i "$(2$&(B") (?a "$(2$'(B") (?E "$(2$((B") (?o "$(2$*(B") (?| "$(2$)(B"))
+;;; z
+   ("$(2!v(B" (?e "$(2!q(B") (?u "$(2!r(B") (?i "$(2!s(B") (?a "$(2!t(B") (?E "$(2!u(B") (?o "$(2!w(B") (?| "$(2!v(B")
+         (?W "$(2!x(B" (?a "$(2!x(B")
+                  (?e "$(2!v#L(B") (?u "$(2!v#M(B") (?i "$(2!v#N(B") (?E "$(2!v#P(B") (?' "$(2!v#M(B")))
+   ])
+
+;;;###autoload
+(defun sera-to-fidel-region (beg end &optional ascii-mode force)
+  "Translates the characters in region from SERA to FIDEL.
+
+If the 1st optional parameter ASCII-MODE is non-NIL, assumes that the
+region begins in ASCII script.
+
+If the 2nd optional parametr FORCE is non-NIL, translates even if the
+buffer is read-only."
+
+  (interactive "r\nP")
+  (save-excursion
+    (save-restriction
+      (narrow-to-region beg end)
+      (sera-to-fidel-buffer ascii-mode force))))
+
+;;;###autoload
+(defun sera-to-fidel-buffer (&optional ascii-mode force)
+  "Translates the current buffer from SERA to FIDEL.
+
+If the 1st optional parameter ASCII-MODE is non-NIL, assumes that the
+current buffer begins in ASCII script.
+
+If the 2nd optional panametr FORCE is non-NIL, translates even if the
+buffer is read-only."
+
+  (interactive "P")
+  (if (and buffer-read-only
+           (not force)
+           (not (y-or-n-p "Buffer is read-only.  Force to convert? ")))
+      (error ""))
+  (let (start pre fol hard table table2 (buffer-read-only nil))
+    (goto-char (point-min))
+    (while (not (eobp))
+      (setq start (point))
+      (forward-char 1)
+      (setq pre (preceding-char)
+            fol (following-char))
+
+      (if ascii-mode
+          (cond
+
+           ;; ascii mode, pre != \ 
+           ((/= pre ?\\ ))
+
+           ;; ascii mode, pre = \, fol = !
+           ((= fol ?!)
+            (backward-delete-char 1)
+            (delete-char 1)
+            (setq ascii-mode nil
+                  hard (not hard)))
+
+           ;; hard ascii mode, pre = \, fol != !
+           (hard)
+
+           ;; soft ascii mode, pre = \, fol = {\ _ * < > 0..9 ~}
+           ((or (backward-delete-char 1) ; always nil
+                (eobp)
+                (sera-to-fidel-backslash)))
+
+           ;; soft ascii mode, pre = \, fol = SPC
+           ((= fol 32)
+            (delete-char 1)
+            (setq ascii-mode nil))
+
+           ;; soft ascii mode, pre = \, fol = .
+           ((= fol ?.)
+            (delete-char 1)
+            (insert ?$(2$P(B))
+
+           ;; soft ascii mode, pre = \, fol = ,
+           ((= fol ?,)
+            (delete-char 1)
+            (insert ?$(2$Q(B))
+
+           ;; soft ascii mode, pre = \, fol = ;
+           ((= fol ?\;)
+            (delete-char 1)
+            (insert ?$(2$R(B))
+
+           ;; soft ascii mode, pre = \, fol = :
+           ((= fol ?:)
+            (delete-char 1)
+            (insert ?$(2$S(B))
+
+           ;; soft ascii mode, pre = \, fol = others
+           (t
+            (setq ascii-mode nil)))
+
+        (cond
+
+         ;; very special: skip "<" to ">" (or "&" to ";") if in w3-mode
+         ((and (boundp 'sera-being-called-by-w3)
+               sera-being-called-by-w3
+               (or (= pre ?<) (= pre ?&)))
+          (search-forward (if (= pre ?<) ">" ";")
+                          nil 0))
+
+         ;; ethio mode, pre != sera
+         ((or (< pre ?') (> pre ?z)))
+
+         ;; ethio mode, pre != \ 
+         ((/= pre ?\\ )
+          (setq table (aref sera-to-fidel-table pre))
+          (while (setq table2 (cdr (assoc (following-char) table)))
+            (setq table table2)
+            (forward-char 1))
+          (if (car table)
+              (progn
+                (delete-region start (point))
+                (insert (car table)))))
+
+         ;; ethio mode, pre = \, fol = !
+         ((= fol ?!)
+          (backward-delete-char 1)
+          (delete-char 1)
+          (setq ascii-mode t
+                hard (not hard)))
+
+         ;; hard ethio mode, pre = \, fol != !
+         (hard)
+
+         ;; soft ethio mode, pre = \, fol = {\ _ * < > 0..9 ~}
+         ((or (backward-delete-char 1)  ; always nil
+              (eobp)
+              (sera-to-fidel-backslash)))
+
+         ;; soft ethio mode, pre = \, fol = SPC
+         ((= fol 32)
+          (delete-char 1)
+          (setq ascii-mode t))
+
+         ;; soft ethio mode, pre = \, fol = {. , ; : | ' `}
+         ((memq fol '(?. ?, ?\; ?: ?| ?' ?`))
+          (forward-char 1))
+
+         ;; soft ethio mode, pre = \, fol = others
+         (t
+          (setq ascii-mode t))))))
+  (goto-char (point-min)))
+
+(defun sera-to-fidel-backslash ()
+  "Handle SERA backslash escapes common to ethio- and ascii-mode.
+Returns t if something has been processed."
+  (let ((ch (following-char))
+        (converted t))
+    (if (and (>= ch ?1) (<= ch ?9))
+        (ethio-convert-digit)
+      (delete-char 1)
+      (cond
+       ((= ch ?\\ )
+        (insert ?\\ ))
+       ((= ch ?_)
+        (insert ?$(2$O(B))
+       ((= ch ?*)
+        (insert ?$(2$T(B))
+       ((= ch ?<)
+        (insert ?$(2$U(B))
+       ((= ch ?>)
+        (insert ?$(2$V(B))
+       ((= ch ?~)
+        (setq ch (following-char))
+        (delete-char 1)
+        (cond
+         ((= ch ?e)
+          (insert "$(2$k(B"))
+         ((= ch ?E)
+          (insert "$(2$l(B"))
+         ((= ch ?a)
+          (insert "$(2$m(B"))
+         ((= ch ?A)
+          (insert "$(2$n(B"))))
+       (t
+        (insert ch)
+        (backward-char 1)
+        (setq converted nil))))
+    converted))
+
+(defun ethio-convert-digit ()
+  "Convert Arabic digits to Ethiopic digits."
+  (let (ch z)
+    (while (and (>= (setq ch (following-char)) ?1)
+                (<= ch ?9))
+      (delete-char 1)
+
+      ;; count up following zeros
+      (setq z 0)
+      (while (= (following-char) ?0)
+        (delete-char 1)
+        (setq z (1+ z)))
+
+      (cond
+
+       ;; first digit is 10, 20, ..., or 90
+       ((= (mod z 2) 1)
+        ;; (- ch 40) means ?1 -> 9, ?2 -> 10, etc.
+        (insert (aref [?$(2$`(B ?$(2$a(B ?$(2$b(B ?$(2$c(B ?$(2$d(B ?$(2$e(B ?$(2$f(B ?$(2$g(B ?$(2$h(B] (- ch ?1)))
+        (setq z (1- z)))
+
+       ;; first digit is 2, 3, ..., or 9
+       ((/= ch ?1)
+        (insert (aref [?$(2$X(B ?$(2$Y(B ?$(2$Z(B ?$(2$[(B ?$(2$\(B ?$(2$](B ?$(2$^(B ?$(2$_(B] (- ch ?2))))
+
+       ;; single 1
+       ((= z 0)
+        (insert "$(2$W(B")))
+
+      ;; 100
+      (if (= (mod z 4) 2)
+          (insert"$(2$i(B"))
+
+      ;; 10000
+      (insert-char ?$(2$j(B (/ z 4)))))
+
+;;;###autoload
+(defun sera-to-fidel-mail (&optional arg)
+  "Does SERA to FIDEL conversion for reading/writing mail and news.
+
+If the buffer contains the markers \"<sera>\" and \"</sera>\",
+converts the segment between the two markers in Ethio start mode and
+the subject field in ASCII start mode.
+
+If invoked interactively and there is no marker, converts both the
+whole body and the subject field in Ethio start mode.
+
+For backward compatibility, \"<ethiopic>\" and \"<>\" can be used instead of
+\"<sera>\" and \"</sera>\"."
+
+  (interactive "p")
+  (let* ((buffer-read-only nil) border)
+
+    (save-excursion
+      (goto-char (point-min))
+      (setq border
+            (search-forward
+             (if (eq major-mode 'rmail-mode)
+                 "\n\n"
+               (concat "\n" mail-header-separator "\n"))))
+
+      (cond
+
+       ;; with markers
+       ((re-search-forward "^<sera>\n" nil t)
+        (goto-char (match-beginning 0))
+        (while (re-search-forward "^<sera>\n" nil t)
+          (replace-match "" nil t)
+          (sera-to-fidel-region
+           (point)
+           (progn
+             (if (re-search-forward "^</sera>\n" nil 0)
+                 (replace-match "" nil t))
+             (point))))
+
+        (goto-char (point-min))
+        (if (re-search-forward "^Subject: " border t)
+            (sera-to-fidel-region
+             (point)
+             (progn (end-of-line) (point))
+             'ascii-start)))
+
+       ;; backward compatibility
+       ((re-search-forward "^<ethiopic>\n" nil t)
+        (goto-char (match-beginning 0))
+        (while (re-search-forward "^<ethiopic>\n" nil t)
+          (replace-match "" nil t)
+          (sera-to-fidel-region
+           (setq border (point))
+           (progn
+             (if (re-search-forward "^<>\n" nil 0)
+                 (replace-match "" nil t))
+             (point))))
+
+        (goto-char (point-min))
+        (if (re-search-forward "^Subject: " border t)
+            (sera-to-fidel-region
+             (point)
+             (progn (end-of-line) (point))
+             'ascii-start)))
+
+       ;; interactive & no markers
+       (arg
+        (sera-to-fidel-region border (point-max))
+        (goto-char (point-min))
+        (if (re-search-forward "^Subject: " border t)
+            (sera-to-fidel-region
+             (point)
+             (progn (end-of-line) (point))))))
+
+      ;; adjust the rmail marker
+      (if (eq major-mode 'rmail-mode)
+          (set-marker
+           (aref rmail-message-vector (1+ rmail-current-message))
+           (point-max))))))
+
+;;;###autoload
+(defun sera-to-fidel-marker ()
+  "If the buffer contains the markers \"<sera>\" and \"</sera>\",
+converts the segment between the two markers from SERA to Fidel
+in Ethio start mode.  The markers will not be removed."
+
+  (interactive)
+  (if (and buffer-read-only
+           (not (y-or-n-p "Buffer is read-only.  Force to convert? ")))
+      (error ""))
+  (save-excursion
+    (goto-char (point-min))
+    (while (re-search-forward "<sera>" nil t)
+      (sera-to-fidel-region
+       (point)
+       (if (re-search-forward "</sera>" nil t)
+           (match-beginning 0)
+         (point-max))
+       nil
+       'force))))
+
+;;
+;; FIDEL to SERA
+;;
+
+(defconst fidel-to-sera-map
+  ["le" "lu" "li" "la" "lE" "l" "lo" "lWa"
+   "me" "mu" "mi" "ma" "mE" "m" "mo" "mWa"
+   "re" "ru" "ri" "ra" "rE" "r" "ro" "rWa"
+   "xe" "xu" "xi" "xa" "xE" "x" "xo" "xWa"
+   "be" "bu" "bi" "ba" "bE" "b" "bo" "bWa"
+   "ve" "vu" "vi" "va" "vE" "v" "vo" "vWa"
+   "te" "tu" "ti" "ta" "tE" "t" "to" "tWa"
+   "ce" "cu" "ci" "ca" "cE" "c" "co" "cWa"
+   "ne" "nu" "ni" "na" "nE" "n" "no" "nWa"
+   "Ne" "Nu" "Ni" "Na" "NE" "N" "No" "NWa"
+   "ze" "zu" "zi" "za" "zE" "z" "zo" "zWa"
+   "Ze" "Zu" "Zi" "Za" "ZE" "Z" "Zo" "ZWa"
+   "de" "du" "di" "da" "dE" "d" "do" "dWa"
+   "Te" "Tu" "Ti" "Ta" "TE" "T" "To" "TWa"
+   "Ce" "Cu" "Ci" "Ca" "CE" "C" "Co" "CWa"
+   "fe" "fu" "fi" "fa" "fE" "f" "fo" "fWa"
+   "se" "su" "si" "sa" "sE" "s" "so" "sWa"
+   "Se" "Su" "Si" "Sa" "SE" "S" "So" "SWa"
+   "a"  "u"  "i"  "A"  "E"  "I" "o"  "e3"
+   "he" "hu" "hi" "ha" "hE" "h" "ho" "hWe" "hWu" "hWi" "hWa" "hWE"
+   "ke" "ku" "ki" "ka" "kE" "k" "ko" "kWe" "kWu" "kWi" "kWa" "kWE"
+   "Ke" "Ku" "Ki" "Ka" "KE" "K" "Ko" "KWe" "KWu" "KWi" "KWa" "KWE"
+   "qe" "qu" "qi" "qa" "qE" "q" "qo" "qWe" "qWu" "qWi" "qWa" "qWE"
+   "Qe" "Qu" "Qi" "Qa" "QE" "Q" "Qo" "QWe" "QWu" "QWi" "QWa" "QWE"
+   "ge" "gu" "gi" "ga" "gE" "g" "go" "gWe" "gWu" "gWi" "gWa" "gWE"
+   "we" "wu" "wi" "wa" "wE" "w" "wo" "wWe" "wWu" "wWi" "wWa" "wWE"
+   "`se" "`su" "`si" "`sa" "`sE" "`s" "`so"
+   "`Se" "`Su" "`Si" "`Sa" "`SE" "`S" "`So"
+   "`e"  "`u"  "`i"  "`a"  "`E"  "`I" "`o"
+   "`he" "`hu" "`hi" "`ha" "`hE" "`h" "`ho"
+   "`ke" "`ku" "`ki" "`ka" "`kE" "`k" "`ko"
+   "Xe" "Xu" "Xi" "Xa" "XE" "X" "Xo"
+   "He" "Hu" "Hi" "Ha" "HE" "H" "Ho"
+   "ye" "yu" "yi" "ya" "yE" "y" "yo"
+   "De" "Du" "Di" "Da" "DE" "D" "Do"
+   "je" "ju" "ji" "ja" "jE" "j" "jo"
+   "Ge" "Gu" "Gi" "Ga" "GE" "G" "Go"
+   "Pe" "Pu" "Pi" "Pa" "PE" "P" "Po"
+   "pe" "pu" "pi" "pa" "pE" "p" "po"
+   " " "\\_" "." "," ";" ":" "\\*" "\\<" "\\>"
+   "1" "2" "3" "4" "5" "6" "7" "8" "9"
+   "10" "20" "30" "40" "50" "60" "70" "80" "90"
+   "100" "10000"
+   "\\~e" "\\~E" "\\~a" "\\~A"])
+
+(defvar ethio-use-tigrigna-style nil
+  "*If non-NIL, use \"e\" instead of \"a\" for the first lone vowel
+translation in sera-to-fidel and fidel-to-sera conversions.")
+
+(defvar ethio-quote-vowel-always nil
+  "*If non-NIL, lone vowels are always transcribed by \"an apostrophe
++ the vowel\" except at word initial.  Otherwise, they are quoted by
+an apostrophe only if the preceding Ethiopic character is a lone
+consonant.")
+
+(defvar ethio-W-sixth-always nil
+  "*If non-NIL, the Wu-form of a 12-form consonant is transcribed by
+\"W'\" instead of \"Wu\".")
+
+(defvar ethio-numeric-reduction 0
+  "*Degree of reduction in transcribing Ethiopic digits by Arabic
+digits.  For example, $(2$`$_$i$g$](B ({10}{9}{100}{80}{7}) will be
+transcribed by:
+    \10\9\100\80\7      if ETHIO-NUMERIC-REDUCTION is 0,
+    \109100807                                     is 1,
+    \10900807                                      is 2.")
+
+;;;###autoload
+(defun fidel-to-sera-region (begin end &optional ascii-mode force)
+  "Replaces all the FIDEL characters in the region to sera format.
+
+If the 1st optional parameter ASCII-MODE is non-NIL, converts the
+region so that it begins in ASCII script.
+
+If the 2nd optional parameter FORCE is non-NIL, converts even if the
+buffer is read-only."
+
+  (interactive "r\nP")
+  (save-excursion
+    (save-restriction
+      (narrow-to-region begin end)
+      (fidel-to-sera-buffer ascii-mode force))))
+
+;;;###autoload
+(defun fidel-to-sera-buffer (&optional ascii-mode force)
+  "Replace all the FIDEL characters in the current buffer to sera format.
+
+If the 1st optional parameter ASCII-MODE is non-NIL,
+convert the current buffer so that it begins in ASCII script.
+
+If the 2nd optional parameter FORCE is non-NIL, converts even if the
+buffer is read-only.
+
+See also the description of the variables ethio-use-tigrigna-style,
+ethio-quote-vowel-on-demand and ethio-numeric-reduction."
+
+  (interactive "P")
+  (if (and buffer-read-only
+           (not force)
+           (not (y-or-n-p "Buffer is read-only.  Force to convert? ")))
+      (error ""))
+
+  ;; user's preference in transcription
+  (aset fidel-to-sera-map 144 (if ethio-use-tigrigna-style "e" "a"))
+  (let ((i 160)
+        (x (if ethio-W-sixth-always
+               '("hW'" "kW'" "KW'" "qW'" "QW'" "gW'" "wW'")
+             '("hWu" "kWu" "KWu" "qWu" "QWu" "gWu" "wWu"))))
+    (while x
+      (aset fidel-to-sera-map i (car x))
+      (setq i (+ i 12)
+            x (cdr x))))
+
+  ;; main conversion routine
+  (let ((lonec nil) ; if lonec = t, previous char was a lone consonant.
+        (fidel nil) ; if fidel = t, previous char was a fidel.
+        (digit nil) ; if digit = t, previous char was an Ethiopic digit.
+        (buffer-read-only nil)
+        ch)
+    (goto-char (point-min))
+    (while (not (eobp))
+      (setq ch (following-char))
+
+      ;; ethiopic charactes
+      (if (eq (char-charset ch) 'ethiopic)
+          (progn
+            (setq ch (char-to-ethiocode ch))
+            (delete-char 1)
+
+            (cond
+
+             ;; fidels
+             ((<= ch 326)
+              (if ascii-mode
+                  (insert "\\ "))
+              (if (and (memq ch '(144 145 146 147 148 150 151)) ; (auiAEoe3)
+                       (or lonec
+                           (and ethio-quote-vowel-always
+                                fidel)))
+                  (insert "'"))
+              (insert (aref fidel-to-sera-map ch))
+              (setq ascii-mode nil
+                    lonec (ethio-lone-consonant-p ch)
+                    fidel t
+                    digit nil))
+
+             ;; punctuations and symbols
+             ((or (< ch 336) (> ch 355))
+              (if (and ascii-mode
+                       (memq ch '(329 330 331 332))) ; (.,;:)
+                  (insert "\\"))
+              (insert (aref fidel-to-sera-map ch))
+              (setq lonec nil
+                    fidel nil
+                    digit nil))
+
+             ;; now CH must be an ethiopic digit
+
+             ;; reduction = 0 or leading digit
+             ((or (= ethio-numeric-reduction 0)
+                  (not digit))
+              (insert "\\" (aref fidel-to-sera-map ch))
+              (setq lonec nil
+                    fidel nil
+                    digit t))
+
+             ;; reduction = 2 and following 10s, 100s, 10000s 
+             ((and (= ethio-numeric-reduction 2)
+                   (memq ch '(345 354 355)))
+              (insert (substring (aref fidel-to-sera-map ch) 1))
+              (setq lonec nil
+                    fidel nil
+                    digit t))
+
+             ;; ordinary following digits
+             (t
+              (insert (aref fidel-to-sera-map ch))
+              (setq lonec nil
+                    fidel nil
+                    digit t))))
+
+        ;; non-ethiopic characters
+        (cond
+
+         ;; backslash is always quoted
+         ((= ch ?\\ )
+          (insert "\\"))
+
+         ;; nothing to do if in ascii-mode
+         (ascii-mode)
+
+         ;; ethio-mode -> ascii-mode
+         ((or (and (>= ch ?a) (<= ch ?z))
+              (and (>= ch ?A) (<= ch ?Z))
+              (memq ch '(?| ?' ?`)))
+          (insert "\\ ")
+          (setq ascii-mode t))
+
+         ;; ascii punctuations in ethio-mode
+         ((memq ch '(?. ?, ?\; ?:))
+          (insert "\\")))
+
+        (forward-char 1)
+        (setq lonec nil
+              fidel nil
+              digit nil)))
+
+    ;; a few modifications for readability
+    (goto-char (point-min))
+    (while (re-search-forward "\\([]!\"#$%&()*+/<=>?@[^_-]+\\)\\\\ " nil t)
+      (replace-match "\\\\ \\1"))
+
+    (goto-char (point-min))
+    (while (re-search-forward "\n\\([ \t]*\\)\\\\ " nil t)
+      (replace-match "\\\\\n\\1")))
+
+  (goto-char (point-min)))
+
+(defun ethio-lone-consonant-p (code)
+  "If the ethiocode CODE is an Ethiopic lone consonant, return t."
+  (cond
+   ((< code 144)
+    (= (mod code 8) 5))
+   ((< code 153)
+    nil)
+   ((< code 236)
+    (= (mod code 12) 1))
+   ((< code 327)
+    (= (mod code 7) 3))))
+
+;;;###autoload
+(defun fidel-to-sera-mail ()
+  "Does FIDEL to SERA conversion for reading/writing mail and news.
+
+If the buffer contains at least one Ethiopic character,
+ 1) inserts the string \"<sera>\" right after the header-body separator,
+ 2) inserts \"</sera>\" at the end of the buffer,
+ 3) converts the body into SERA in Ethiopic start mode, and
+ 4) converts the subject field in ASCII start mode."
+
+  (interactive)
+  (save-excursion
+    (goto-char (point-min))
+    (if (re-search-forward "\\cE" nil t)
+        (let ((buffer-read-only nil) border)
+
+          (goto-char (point-min))
+          (setq border
+                (search-forward
+                 (if (eq major-mode 'rmail-mode)
+                     "\n\n"
+                   (concat "\n" mail-header-separator "\n"))))
+          (insert "<sera>\n")
+
+          (fidel-to-sera-region (point) (point-max))
+
+          (goto-char (point-max))
+          (if (/= (preceding-char) ?\n)
+              (insert "\n"))
+          (insert "</sera>\n")
+
+          (goto-char (point-min))
+          (if (re-search-forward "^Subject: " border t)
+              (fidel-to-sera-region
+               (point)
+               (progn (end-of-line) (point))
+               'ascii-start))
+
+          ;; adjust the rmail marker
+          (if (eq major-mode 'rmail-mode)
+              (set-marker
+               (aref rmail-message-vector (1+ rmail-current-message))
+               (point-max))))
+
+      (message "No Ethiopic characters in this buffer."))))
+
+;;;###autoload
+(defun fidel-to-sera-marker ()
+  "If the buffer contains the markers \"<sera>\" and \"</sera>\",
+converts the segment between the two markers from Fidel to SERA
+in Ethio start mode.  The markers will not be removed."
+
+  (interactive)
+  (if (and buffer-read-only
+           (not (y-or-n-p "Buffer is read-only.  Force to convert? ")))
+      (error ""))
+  (save-excursion
+    (goto-char (point-min))
+    (while (re-search-forward "^<sera>\n" nil t)
+      (fidel-to-sera-region
+       (point)
+       (if (re-search-forward "^</sera>\n" nil t)
+           (match-beginning 0)
+         (point-max))
+       nil
+       'force))))
+
+;;
+;; file I/O hooks
+;;
+
+(if (not (assoc "\\.sera$" auto-mode-alist))
+    (setq auto-mode-alist
+          (cons '("\\.sera$" . sera-to-fidel-find-file) auto-mode-alist)))
+(add-hook 'write-file-hooks 'fidel-to-sera-write-file)
+(add-hook 'after-save-hook 'sera-to-fidel-after-save)
+
+;;;###autoload
+(defun sera-to-fidel-find-file ()
+  "Intended to be called when a file whose name ends in \".sera\" is read in."
+  (sera-to-fidel-buffer nil 'force)
+  (set-buffer-modified-p nil)
+  nil)
+
+;;;###autoload
+(defun fidel-to-sera-write-file ()
+  "Intended to be used as write-file-hooks for the files
+whose name ends in \".sera\"."
+  (if (string-match "\\.sera$" (buffer-file-name))
+      (save-excursion
+        (fidel-to-sera-buffer nil 'force)
+        (set-buffer-modified-p nil)))
+  nil)
+
+;;;###autoload
+(defun sera-to-fidel-after-save ()
+  "Intended to be used as after-save-hook for the files
+whose name ends in \".sera\"."
+  (if (string-match "\\.sera$" (buffer-file-name))
+      (save-excursion
+        (sera-to-fidel-buffer nil 'force)
+        (set-buffer-modified-p nil)))
+  nil)
+
+;;
+;; vowel modification
+;;
+
+;;;###autoload
+(defun ethio-modify-vowel ()
+  "Modify the vowel of the FIDEL that is under the cursor."
+  (interactive)
+  (let ((ch (following-char)) newch base vowel)
+    (if (eq (char-charset ch) 'ethiopic)
+        (setq ch (char-to-ethiocode ch))
+      (error "Not a valid character."))
+    (if (or (and (>= ch 144) (<= ch 151)) ; lone vowels
+            (and (>= ch 250) (<= ch 256)) ; secondary lone vowels
+            (>= ch 327))                  ; not FIDEL
+        (error "Not a valid character."))
+    (message "Modify vowel to: ")
+    (if (null (setq vowel (memq (read-char) '(?e ?u ?i ?a ?E ?' ?o))))
+        (error "Not a valid vowel.")
+      ;; ?e -> 0, ?u -> 1, ?i -> 2, ?a -> 3, ?E -> 4, ?' -> 5, ?o -> 6
+      (setq vowel (- 7 (length vowel))))
+
+    (cond
+
+     ;; 8-form consonant
+     ((<= ch 143)
+      (setq base (* (/ ch 8) 8))
+      (cond
+       ((< (mod ch 8) 7)                ; e-form <= ch <= o-form
+        (setq newch (+ base vowel)))
+       ((= vowel 3)                     ; 3 = a
+        (setq newch (+ base 7)))        ; (+ base 7) = Wa-form
+       ((= vowel 5)                     ; 5 = '
+        (setq newch
+              (cons (+ base 5)          ; (+ base 5) = lone consonant
+                    232)))              ; 232 = Wu
+       (t
+        (setq newch
+              (cons (+ base 5)          ; (+ base 5) = lone consonant
+                    (+ 231 vowel))))))  ; 231 = We
+
+     ;; 12-form consonant
+     ((<= ch 235)
+      (setq ch (- ch 152)               ; 152 = 12-form consonant offset
+            base (* (/ ch 12) 12))
+      (cond
+       ((< (mod ch 12) 7)               ; e-form <= ch <= o-form
+        (setq newch (+ base vowel 152)))
+       ((< vowel 5)                     ; We-form <= ch <= WE-form
+        (setq newch (+ base vowel 159))) ; 159 = 152 (offset) + 7 (We-form)
+       ((= vowel 5)                     ; 5 = ' (= u in this case)
+        (setq newch (+ base 160)))      ; 160 = 152 (offset) + 8 (Wu-form)
+       (t
+        (error "Not a valid vowel."))))
+
+     ;; 7-form consonant
+     (t                                 ; 236 = 7-form consonant offset
+      (setq newch (+ (* (/ (- ch 236) 7) 7) vowel 236))))
+
+    (delete-char 1)
+
+    (cond
+     ((consp newch)
+      (insert (ethiocode-to-char (car newch))
+              (ethiocode-to-char (cdr newch)))
+      (backward-char 2))
+     (t
+      (insert (ethiocode-to-char newch))
+      (backward-char 1)))))
+
+(defun ethiocode-to-char (code)
+  (make-char 'ethiopic (/ code 94) (mod code 94)))
+
+(defun char-to-ethiocode (ch)
+  (and (eq (char-charset ch) 'ethiopic)
+       (let ((char-components (split-char ch)))
+         (+ (* (- (nth char-components 1) 161) 94)
+            (- (nth char-components 2) 161)))))
+
+;;
+;; space replacement
+;;
+
+;;;###autoload
+(defun ethio-replace-space (ch begin end)
+  "In the specified region, replace spaces between two Ethiopic characters."
+  (interactive "*cReplace spaces to: 1 (sg col), 2 (dbl col), 3 (Ethiopic)\nr")
+  (if (not (memq ch '(?1 ?2 ?3)))
+      (error ""))
+  (save-excursion
+    (save-restriction
+      (narrow-to-region begin end)
+      (goto-char (point-min))
+
+      (cond
+
+       ((= ch ?1)
+
+        ;; A double column space or an Ethiopic word separator is always
+        ;; converted to an ASCII space.
+        (while (re-search-forward "[$(2$N$O(B]" nil t)
+          (replace-match " " nil nil)))
+
+       ((= ch ?2)
+
+        ;; An Ethiopic word separator is always converted to
+        ;; a double column space.
+        (while (search-forward "$(2$O(B" nil t)
+          (replace-match "$(2$N(B"))
+
+        (goto-char (point-min))
+
+        ;; ASCII spaces are converted only if they are placed
+        ;; between two Ethiopic characters.
+        (while (re-search-forward "\\(\\cE\\)\\( \\)\\( *\\cE\\)" nil t)
+
+          ;; Converting the first ASCII space
+          (replace-match "\\1$(2$N(B\\3")
+
+          ;; A double column space is \cE, so going back to the just
+          ;; converted double column space makes it possible to find
+          ;; the following ASCII spaces.
+          (goto-char (match-beginning 2))))
+
+       ((= ch ?3)
+
+        ;; If more than one consecutive space (either ASCII or double
+        ;; width) is found between two Ethiopic characters, the first
+        ;; space will be converted to an Ethiopic word separator.
+        (let (pred succ)
+          (while (re-search-forward "[ $(2$N(B]\\([ $(2$N(B]*\\)" nil t)
+            (and (setq pred (char-before (match-beginning 0)))
+                 (eq (char-charset pred) 'ethiopic)
+                 (setq succ (char-after (match-end 0)))
+                 (eq (char-charset succ) 'ethiopic)
+                 (replace-match "$(2$O(B\\1" nil nil)))))))))
+
+;;
+;; special characters
+;;
+
+;;;###autoload
+(defun ethio-input-special-character (arg)
+  "Allow the user to input special characters."
+  (interactive "*cInput number: 1.$(2$k(B  2.$(2$l(B  3.$(2$m(B  4.$(2$n(B")
+  (cond
+   ((= arg ?1)
+    (insert ?$(2$k(B))
+   ((= arg ?2)
+    (insert ?$(2$l(B))
+   ((= arg ?3)
+    (insert ?$(2$m(B))
+   ((= arg ?4)
+    (insert ?$(2$n(B))
+   (t
+    (error ""))))
+
+;;
+(provide 'language/ethio-util)
+
+;;; Local Variables:
+;;; generated-autoload-file: "../loaddefs.el"
+;;; End:
+;;; ethio-util.el ends here
diff --git a/lisp/language/ethiopic.el b/lisp/language/ethiopic.el
new file mode 100644
index 00000000000..d08ca5b1a43
--- /dev/null
+++ b/lisp/language/ethiopic.el
@@ -0,0 +1,85 @@
+;;; ethiopic.el --- Support for Ethiopic
+
+;; Copyright (C) 1995 Free Software Foundation, Inc.
+;; Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+;; Keywords: multilingual, Ethiopic
+
+;; 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.
+
+;;; Code:
+
+(define-ccl-program ccl-encode-ethio-font
+  '(0
+    ;; In:  R0:ethio (not checked)
+    ;;      R1:position code 1
+    ;;      R2:position code 2
+    ;; Out: R1:font code point 1
+    ;;      R2:font code point 2
+    ((r1 -= 33)
+     (r2 -= 33)
+     (r1 *= 94)
+     (r2 += r1)
+     (if (r2 < 256) (r1 = 0) ((r2 -= 256) (r1 = 1)))))
+  "CCL program to encode an Ehitopic code to code point of Ehitopic font.")
+
+(setq font-ccl-encoder-alist
+      (cons (cons "ethio" ccl-encode-ethio-font) font-ccl-encoder-alist))
+
+(register-input-method
+ "Ethiopic" '("quail-ethio" quail-use-package "quail/ethio"))
+
+(defun setup-ethio-environment ()
+  (setq primary-language "Ethiopic")
+
+  (setq default-input-method '("Ethiopic" . "quail-ethio"))
+
+  ;;
+  ;;  key bindings
+  ;;
+  (define-key global-map [f4] 'sera-to-fidel-buffer)
+  (define-key global-map [S-f4] 'sera-to-fidel-region)
+  (define-key global-map [C-f4] 'sera-to-fidel-marker)
+  (define-key global-map [f5] 'fidel-to-sera-buffer)
+  (define-key global-map [S-f5] 'fidel-to-sera-region)
+  (define-key global-map [C-f5] 'fidel-to-sera-marker)
+  (define-key global-map [f6] 'ethio-modify-vowel)
+  (define-key global-map [f7] 'ethio-replace-space)
+  (define-key global-map [S-f2] 'ethio-replace-space) ; as requested
+  (define-key global-map [f8] 'ethio-input-special-character)
+
+  (add-hook
+   'rmail-mode-hook
+   '(lambda ()
+      (define-key rmail-mode-map [C-f4] 'sera-to-fidel-mail)
+      (define-key rmail-mode-map [C-f5] 'fidel-to-sera-mail)))
+
+  (add-hook
+   'mail-mode-hook
+   '(lambda ()
+      (define-key mail-mode-map [C-f4] 'sera-to-fidel-mail)
+      (define-key mail-mode-map [C-f5] 'fidel-to-sera-mail)))
+  )
+
+(set-language-info-alist
+ "Ethiopic" '((setup-function . setup-ethio-environment)
+              (charset . (ethiopic))
+              (documentation . t)
+              (sample-text
+               . "Amharic ($(2"S!,!6!l(B) $(2#Q!$!.(B, Tigrigna ($(2!V#>!6!l(B) $(2"C!$!,!V(B")))
+
+;;; ethiopic.el ends here
diff --git a/lisp/language/european.el b/lisp/language/european.el
new file mode 100644
index 00000000000..e10169d24a7
--- /dev/null
+++ b/lisp/language/european.el
@@ -0,0 +1,105 @@
+;;; european.el --- Support for European languages
+
+;; Copyright (C) 1995 Free Software Foundation, Inc.
+;; Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+;; Keywords: multilingual, European
+
+;; 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.
+
+;;; Commentary:
+
+;; For Europeans, five character sets ISO8859-1,2,3,4,9 are supported.
+
+;;; Code:
+
+(make-coding-system
+ 'coding-system-iso-8859-1 2 ?X
+ "Coding-system used in X as Compound Text Encoding."
+ '((ascii t) (latin-iso8859-1 t) nil nil
+   nil ascii-eol ascii-cntl))
+
+;; CTEXT is an alias for ISO-8859-1
+(put 'coding-system-ctext 'coding-system 'coding-system-iso-8859-1)
+
+(make-coding-system
+ 'coding-system-iso-8859-2 2 ?2 "MIME ISO-8859-2"
+ '((ascii t) (latin-iso8859-2 t) nil nil
+   nil ascii-eol ascii-cntl nil nil nil nil))
+
+(make-coding-system
+ 'coding-system-iso-8859-3 2 ?3 "MIME ISO-8859-3"
+ '((ascii t) (latin-iso8859-3 t) nil nil
+   nil ascii-eol ascii-cntl nil nil nil nil))
+
+(make-coding-system
+ 'coding-system-iso-8859-4 2 ?4 "MIME ISO-8859-4"
+ '((ascii t) (latin-iso8859-4 t) nil nil
+   nil ascii-eol ascii-cntl nil nil nil nil))
+
+(make-coding-system
+ 'coding-system-iso-8859-9 2 ?9 "MIME ISO-8859-9"
+ '((ascii t) (latin-iso8859-9 t) nil nil
+   nil ascii-eol ascii-cntl nil nil nil nil))
+
+(register-input-method "European"
+                       '("quail-latin-1" quail-use-package "quail/latin"))
+(register-input-method "European"
+                       '("quail-latin-2" quail-use-package "quail/latin"))
+(register-input-method "European"
+                       '("quail-latin-3" quail-use-package "quail/latin"))
+(register-input-method "European"
+                       '("quail-latin-4" quail-use-package "quail/latin"))
+(register-input-method "European"
+                       '("quail-latin-5" quail-use-package "quail/latin"))
+
+(defun setup-european-environment ()
+  (setq coding-category-iso-8-1 'coding-system-iso-8859-1)
+
+  (set-coding-priority
+   '(coding-category-iso-7
+     coding-category-iso-8-1
+     coding-category-iso-8-2))
+
+  (setq-default buffer-file-coding-system 'coding-system-iso-8859-1)
+  (set-terminal-coding-system 'coding-system-iso-8859-1)
+  (set-keyboard-coding-system 'coding-system-iso-8859-1)
+
+  (setq default-input-method '("European" . "quail-latin-1"))
+  )
+
+(set-language-info "English" 'tutorial "TUTORIAL")
+
+(register-input-method "French"
+                       '("quail-latin-1" quail-use-package "quail/latin"))
+(register-input-method "French"
+                       '("quail-latin-1" quail-use-package "quail/latin"))
+
+(set-language-info-alist
+ "European" '((setup-function . setup-european-environment)
+              (charset . (ascii latin-iso8859-1 latin-iso8859-2
+                           latin-iso8859-3 latin-iso8859-4 latin-iso8859-9))
+              (coding-system . (coding-system-iso-8859-1
+                                coding-system-iso-8859-2
+                                coding-system-iso-8859-3
+                                coding-system-iso-8859-4
+                                coding-system-iso-8859-9))
+              (documentation . t)
+              (sample-text
+               . "Hello, Hej, Tere, Hei, Bonjour, Gr,A|_(B Gott, Ciao, ,A!(BHola!")))
+
+;;; european.el ends here
diff --git a/lisp/language/greek.el b/lisp/language/greek.el
new file mode 100644
index 00000000000..114dc5b7fdc
--- /dev/null
+++ b/lisp/language/greek.el
@@ -0,0 +1,59 @@
+;;; greek.el --- Support for Greek
+
+;; Copyright (C) 1995 Free Software Foundation, Inc.
+;; Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+;; Keywords: multilingual, Greek
+
+;; 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.
+
+;;; Commentary:
+
+;; For Greek, the character set ISO8859-7 is supported.
+
+;;; Code:
+
+(make-coding-system
+ 'coding-system-iso-8859-7 2 ?7 "MIME ISO-8859-7"
+ '((ascii t) (greek-iso8859-7 t) nil nil
+   nil ascii-eol ascii-cntl nil nil nil nil))
+
+(register-input-method
+ "Greek" '("quail-greek" quail-use-package "quail/greek"))
+
+(defun setup-greek-environment ()
+  (setq coding-category-iso-8-1 'coding-system-iso-8859-7)
+
+  (set-coding-priority
+   '(coding-category-iso-7
+     coding-category-iso-8-1))
+
+  (setq-default buffer-file-coding-system 'coding-system-iso-8859-7)
+  (set-terminal-coding-system 'coding-system-iso-8859-7)
+  (set-keyboard-coding-system 'coding-system-iso-8859-7)
+
+  (setq default-input-method '("Greek" . "quail-greek"))
+  )
+
+(set-language-info-alist
+ "Greek" '((setup-function . setup-greek-environment)
+           (charset . (greek-iso8859-7))
+           (coding-system . (coding-system-iso-8859-7))
+           (documentation . t)
+           (sample-text . "Greek (,FGkk]mija(B)       ,FCei\(B ,Fsar(B")))
+
+;;; greek.el ends here
diff --git a/lisp/language/hebrew.el b/lisp/language/hebrew.el
new file mode 100644
index 00000000000..bece50500e2
--- /dev/null
+++ b/lisp/language/hebrew.el
@@ -0,0 +1,60 @@
+;;; hebrew.el --- Support for Hebrew
+
+;; Copyright (C) 1995 Free Software Foundation, Inc.
+;; Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+;; Keywords: multilingual, Hebrew
+
+;; 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.
+
+;;; Commentary:
+
+;; For Hebrew, the character sets ISO8859-8 is supported.
+
+;;; Code:
+
+(make-coding-system
+ 'coding-system-iso-8859-8 2 ?8 "MIME ISO-8859-8"
+ '((ascii t) (hebrew-iso8859-8 t) nil nil
+   nil ascii-eol ascii-cntl nil nil nil nil nil t))
+
+(register-input-method
+ "Hebrew" '("quail-hebrew" quail-use-package "quail/hebrew"))
+
+(defun setup-hebrew-environment ()
+  (setq coding-category-iso-8-1 'coding-system-iso-8859-8)
+
+  (set-coding-priority
+   '(coding-category-iso-7
+     coding-category-iso-8-1
+     coding-category-iso-8-2))
+
+  (setq-default buffer-file-coding-system 'coding-category-iso-8-2)
+  (set-terminal-coding-system 'coding-category-iso-8-2)
+  (set-keyboard-coding-system 'coding-category-iso-8-2)
+
+  (setq default-input-method '("Hebrew" . "quail-hebrew"))
+  )
+
+(set-language-info-alist
+ "Hebrew" '((setup-function . setup-hebrew-environment)
+            (charset . (hebrew-iso8859-8))
+            (coding-system . (coding-system-iso-8859-8))
+            (documentation . "Right-to-left writing is Not yet supported")
+            (sample-text . "Hebrew      ,Hylem(B")))
+
+;;; hebew.el ends here
diff --git a/lisp/language/indian.el b/lisp/language/indian.el
new file mode 100644
index 00000000000..75ef6ffe55b
--- /dev/null
+++ b/lisp/language/indian.el
@@ -0,0 +1,328 @@
+;;; indian.el --- Support for Indian Languages
+
+;; Copyright (C) 1995 Free Software Foundation, Inc.
+
+;; Author: KAWABATA, Taichi <kawabata@is.s.u-tokyo.ac.jp>
+
+;; Keywords: multilingual, Indian
+
+;; 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.
+
+;;; Commentary:
+
+;; History:
+;; 1996.10.18 written by KAWABATA, Taichi <kawabata@is.s.u-tokyo.ac.jp>
+
+;; For Indian, the character set IS 13194 is supported.
+;;
+;; IS 13194 does not specifically assign glyphs for each characters.
+;; Following code is not specific to each Indian language.
+;;
+;; Eventually, this code will support generic information about
+;; following scripts.
+;;
+;;    Devanagari
+;;    Bengali
+;;    Gurmukhi
+;;    Gujarati
+;;    Oriya
+;;    Tamil
+;;    Telgu
+;;    Kannada
+;;    Malayalam
+;;
+;; In this file, charsets other than charset-ascii and charset-indian-is13194
+;; should not be used except in the comment.
+
+;;; Code:
+
+;;  Followings are what you see when you refer to the Emacs
+;;  representations of IS 13194 charcters.  However, this is merely
+;;  tentative apperance, and you must convert them by
+;;  indian-to-xxxxxx(specific script) function to use them.
+;;  Devanagari is not an exception of this rule.
+
+;;     0xa0 //(5!"#$%&'()*+,-./(B
+;;     0xb0 (50123456789:;<=>?(B
+;;     0xc0 (5@ABCDEFGHIJKLMNO(B
+;;     0xd0 (5PQRSTUVWXYZ[\]^_(B
+;;     0xe0 (5`abcdefghijklmno(B
+;;     0xf0 (5pqrstuvwxyz{|}~(B//
+
+;; Note - In IS 13194, several symbols are obtained by special
+;; combination of several characters and Nukta sign.
+;;
+;;   Sanskrit Vowel R  -> (5*(B + (5i(B
+;;   Sanskrit Vowel L  -> (5&(B + (5i(B
+;;   Sanskrit Vowel LL -> (5'(B + (5i(B
+;;   Sanskrit Avagrah  -> (5j(B + (5i(B
+;;   OM                -> (5!(B + (5i(B
+;;
+;; Note - IS 13194 defines ATR(0xEF) and EXT(0xF0), but they are
+;; not used in Emacs.
+;;
+;; Note - the above characters DO NOT represent any script.  For
+;; example, if you want to obtain Devanagari character, you must do
+;; something like the following.
+;;
+;;   (char-to-string (indian-to-devanagari ?(5$(B))
+;;   "$(5!$(B"
+
+(let ((deflist  
+        '(;; chars      syntax  category
+          ("(5!"#(B"  "w"     ?7) ; vowel-modifying diacritical mark
+                                    ; chandrabindu, anuswar, visarga
+          ("(5$(B-(52(B"    "w"     ?5) ; independent vowel
+          ("(53(B-(5X(B"    "w"     ?0) ; consonant
+          ("(5Z(B-(5g(B"    "w"     ?8) ; matra
+          ("(5q(B-(5z(B"    "w"     ?6) ; digit
+          ))
+      elm chars len syntax category to ch i)
+  (while deflist
+    (setq elm (car deflist))
+    (setq chars (car elm)
+          len (length chars)
+          syntax (nth 1 elm)
+          category (nth 2 elm)
+          i 0)
+    (while (< i len)
+      (if (= (aref chars i) ?-)
+          (setq i (1+ i)
+                to (sref chars i))
+        (setq ch (sref chars i)
+              to ch))
+      (while (<= ch to)
+        (modify-syntax-entry ch syntax)
+        (modify-category-entry ch category)
+        (setq ch (1+ ch)))
+      (setq i (+ i (char-bytes to))))
+    (setq deflist (cdr deflist))))
+
+
+;;; ITRANS
+;;
+;; ITRANS is one of the most popular method to exchange indian scripts
+;; electronically.  Here is the table to convert between ITRANS code and
+;; IS 13194 code.
+
+(defvar indian-itrans-consonant-alist
+  '(
+    ("k" . "(53(B")
+    ("kh" . "(54(B")
+    ("g" . "(55(B")
+    ("gh" . "(56(B")
+    ("N^" . "(57(B")
+    ("ch" . "(58(B")
+    ("chh" . "(59(B")
+    ("j" . "(5:(B")
+    ("jh" . "(5;(B")
+    ("JN" . "(5<(B")
+    ("T" . "(5=(B")
+    ("Th" . "(5>(B")
+    ("D" . "(5?(B")
+    ("Dh" . "(5@(B")
+    ("N" . "(5A(B")
+    ("t" . "(5B(B")
+    ("th" . "(5C(B")
+    ("d" . "(5D(B")
+    ("dh" . "(5E(B")
+    ("n" . "(5F(B")
+    ("nh" . "(5G(B")     ; For transcription of non-Devanagari Languages.
+    ("p" . "(5H(B")
+    ("ph" . "(5I(B")
+    ("b" . "(5J(B")
+    ("bh" . "(5K(B")
+    ("m" . "(5L(B")
+    ("y" . "(5M(B")
+    ("yh" . "(5N(B")      ; For transcription of non-Devanagari Languages.
+    ("r" . "(5O(B")
+    ("rh" . "(5P(B")      ; For transcription of non-Devanagari Languages.
+    ("l" . "(5Q(B")
+    ("v" . "(5T(B")
+    ("sh" . "(5U(B")
+    ("shh" . "(5V(B")
+    ("s" . "(5W(B")
+    ("h" . "(5X(B")
+    ("ld" . "(5R(B")
+    ("L" . "(5R(B")
+    ("ksh" . "$(5!3!h!V(B")
+    ("GY" . "***GY***")  ; Must check out later.
+    ;; special consonants
+    ("q" . "(53i(B")
+    ("K" . "(54i(B")
+    ("G" . "(55i(B")
+    ("z" . "(5:i(B")
+    ("f" . "(5Ii(B")
+    (".D" . "(5?i(B")
+    (".Dh" . "(5@i(B")
+  ))
+
+(defvar indian-itrans-vowel-sign-alist
+  '(
+    ;; Special treatment unique to IS 13194 Transliteration
+    ("" . "(5h(B")
+    ("a" . "")
+    ;; Matra (Vowel Sign)
+    ("aa" . "(5Z(B")
+    ("A" . "(5Z(B")
+    ("i" . "(5[(B")
+    ("ii" . "(5\(B")
+    ("I" . "(5\(B")
+    ("u" . "(5](B")
+    ("uu" . "(5^(B")
+    ("U" . "(5^(B")
+    ("R^i" . "(5_(B")     ; These must be checked out later.
+    ("R^I" . "(5_i(B")
+    ("L^i" . "(5[i(B")
+    ("L^I" . "(5\i(B")
+    ("E" . "(5`(B")       ; For transcription of non-Devanangri Languages.
+    ("e" . "(5a(B")
+    ("ai" . "(5b(B") 
+    ;; ("e.c" . "(5c(B")     ; Tentatively suppressed.
+    ("O" . "(5d(B")       ; For transcription of non-Devanagari Languages.
+    ("o" . "(5e(B")
+    ("au" . "(5f(B")
+    ;; ("o.c" . "(5g(B")     ; Tentatively suppressed.
+    ))
+
+;;
+;; Independent vowels and other signs.
+;;
+
+(defvar indian-itrans-other-letters-alist
+  '(
+    ("a" . "(5$(B")
+    ("aa" . "(5%(B")
+    ("A" . "(5%(B")
+    ("i" . "(5&(B")
+    ("ii" . "(5'(B")
+    ("I" . "(5'(B")
+    ("u" . "(5((B")
+    ("uu" . "(5)(B")
+    ("U" . "(5)(B")
+    ("R^i" . "(5*(B")
+    ("R^I" . "(5*i(B")
+    ("L^i" . "(5&i(B")
+    ("L^I" . "(5'i(B")
+    ("E" . "(5+(B")   ; For transcription of non-Devanagari Languages.
+    ("e" . "(5,(B")
+    ("ai" . "(5-(B")
+    ;; ("e.c" . "(5.(B")      ; Candra E
+    ("O" . "(5/(B")   ; For transcription of non-Devanagari Languages.
+    ("o" . "(50(B")
+    ("au" . "(51(B")
+    ;; ("o.c" . "(52(B")      ; Candra O
+    ("M" . "(5$(B")
+    ("H" . "(5#(B")
+    ("AUM" . "(5!i(B")
+    ("OM" . "(5!i(B")
+    (".r" . "(5Oh(B")
+    (".n" . "(5"(B")
+    (".N" . "(5!(B")
+    (".h" . "(5h(B")        ; Halant
+    (".." . "(5j(B")
+    (".a" . "(5ji(B")      ; Avagrah
+    ("0" . "(5q(B")
+    ("1" . "(5r(B")
+    ("2" . "(5s(B")
+    ("3" . "(5t(B")
+    ("4" . "(5u(B")
+    ("5" . "(5v(B")
+    ("6" . "(5w(B")
+    ("7" . "(5x(B")
+    ("8" . "(5y(B")
+    ("9" . "(5z(B")
+    ))
+
+;; Regular expression matching single Indian character represented
+;; by ITRANS.
+
+(defvar indian-itrans-regexp
+  (let ((consonant "\\([cs]hh?\\)\\|[kgjTDnpbyr]h?\\|\\(N\\^?\\)\\|\\(jN\\)\\|[mvqKGzfs]\\|\\(ld?\\)\\|\\(ksh\\)\\|\\(GY\\)\\|\\(\\.Dh?\\)")
+        (vowel "\\(a[aiu]\\)\\|\\(ii\\)\\|\\(uu\\)\\|\\([RL]\\^[iI]\\)\\|[AIEOeoaiu]")
+        (misc "[MH0-9]\\|\\(AUM\\)\\|\\(OM\\)\\|\\(\\.[rnNh\\.a]\\)")
+        (lpre "\\(") (rpre "\\)") (orre "\\|"))
+    (concat lpre misc rpre orre
+            lpre lpre consonant rpre "?" lpre vowel rpre rpre orre
+            lpre consonant rpre )))
+
+;;
+;; Regular expression matching single ITRANS unit for IS 13194 characters.
+;;
+
+(defvar itrans-indian-regexp
+  (let ((vowel "[(5$(B-(52(B]")
+        (consonant "[(53(B-(5X(B]")
+        (vowel-sign "[(5Z(B-(5g(B]")
+        (misc "[(5q(B-(5z(B]")
+        (lpre "\\(") (rpre "\\)") (orre "\\|"))
+    nil)) ; not yet prepared.
+
+
+;;
+;; IS13194 - ITRANS conversion table for string matching above regexp.
+;;
+
+(defvar indian-itrans-alist
+  (let ((cl indian-itrans-consonant-alist)
+        (ml indian-itrans-other-letters-alist) rules)
+          (while cl
+            (let ((vl indian-itrans-vowel-sign-alist))
+              (while vl
+                (setq rules 
+                      (cons (cons (concat (car (car cl)) (car (car vl)))
+                                  (concat (cdr (car cl)) (cdr (car vl))))
+                            rules))
+                (setq vl (cdr vl))))
+            (setq cl (cdr cl)))
+          (while ml
+            (setq rules (cons (cons (car (car ml)) 
+                                    (cdr (car ml)))
+                              rules))
+            (setq ml (cdr ml)))
+          rules))
+
+;;
+;; Utility program to convert from ITRANS to IS 13194 in specified region.
+;;
+
+(defun indian-decode-itrans-region (from to)
+  "Convert `ITRANS' mnemonics of the current region to Indian characters.
+When called from a program, expects two arguments,
+positions (integers or markers) specifying the stretch of the region."
+  (interactive "r")
+  (save-restriction
+    (narrow-to-region from to)
+    (goto-char (point-min))
+    (while (re-search-forward indian-itrans-regexp nil t)
+      (let* ((itrans (buffer-substring (match-beginning 0) (match-end 0)))
+             (ch (cdr (assoc itrans indian-itrans-alist))))
+        (if ch
+            (progn
+              (delete-region (match-beginning 0) (match-end 0))
+              (insert ch)))))
+    (goto-char (point-min))
+    (while (re-search-forward "\\((5h(B\\)[^\\c0]" nil t)
+      (delete-region (match-beginning 1) (match-end 1)))))
+
+;;
+;; Utility program to convert from IS 13194 to ITRANS in specified region.
+;;
+
+;;;;;;  not yet prepared.
+
+;;; indian.el ends here
diff --git a/lisp/language/japan-util.el b/lisp/language/japan-util.el
new file mode 100644
index 00000000000..2dab876fd51
--- /dev/null
+++ b/lisp/language/japan-util.el
@@ -0,0 +1,272 @@
+;; japan-util.el --  utilities for Japanese
+
+;; Copyright (C) 1995 Free Software Foundation, Inc.
+;; Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+;; Keywords: mule, multilingual, Japanese
+
+;; 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.
+
+;;; Code:
+
+(defconst japanese-kana-table
+  '((?$B$"(B ?$B%"(B ?(I1(B) (?$B$$(B ?$B%$(B ?(I2(B) (?$B$&(B ?$B%&(B ?(I3(B) (?$B$((B ?$B%((B ?(I4(B) (?$B$*(B ?$B%*(B ?(I5(B)
+    (?$B$+(B ?$B%+(B ?(I6(B) (?$B$-(B ?$B%-(B ?(I7(B) (?$B$/(B ?$B%/(B ?(I8(B) (?$B$1(B ?$B%1(B ?(I9(B) (?$B$3(B ?$B%3(B ?(I:(B)
+    (?$B$5(B ?$B%5(B ?(I;(B) (?$B$7(B ?$B%7(B ?(I<(B) (?$B$9(B ?$B%9(B ?(I=(B) (?$B$;(B ?$B%;(B ?(I>(B) (?$B$=(B ?$B%=(B ?(I?(B)
+    (?$B$?(B ?$B%?(B ?(I@(B) (?$B$A(B ?$B%A(B ?(IA(B) (?$B$D(B ?$B%D(B ?(IB(B) (?$B$F(B ?$B%F(B ?(IC(B) (?$B$H(B ?$B%H(B ?(ID(B)
+    (?$B$J(B ?$B%J(B ?(IE(B) (?$B$K(B ?$B%K(B ?(IF(B) (?$B$L(B ?$B%L(B ?(IG(B) (?$B$M(B ?$B%M(B ?(IH(B) (?$B$N(B ?$B%N(B ?(II(B)
+    (?$B$O(B ?$B%O(B ?(IJ(B) (?$B$R(B ?$B%R(B ?(IK(B) (?$B$U(B ?$B%U(B ?(IL(B) (?$B$X(B ?$B%X(B ?(IM(B) (?$B$[(B ?$B%[(B ?(IN(B)
+    (?$B$^(B ?$B%^(B ?(IO(B) (?$B$_(B ?$B%_(B ?(IP(B) (?$B$`(B ?$B%`(B ?(IQ(B) (?$B$a(B ?$B%a(B ?(IR(B) (?$B$b(B ?$B%b(B ?(IS(B)
+    (?$B$d(B ?$B%d(B ?(IT(B) (?$B$f(B ?$B%f(B ?(IU(B) (?$B$h(B ?$B%h(B ?(IV(B)
+    (?$B$i(B ?$B%i(B ?(IW(B) (?$B$j(B ?$B%j(B ?(IX(B) (?$B$k(B ?$B%k(B ?(IY(B) (?$B$l(B ?$B%l(B ?(IZ(B) (?$B$m(B ?$B%m(B ?(I[(B)
+    (?$B$o(B ?$B%o(B ?(I\(B) (?$B$p(B ?$B%p(B nil) (?$B$q(B ?$B%q(B nil) (?$B$r(B ?$B%r(B ?(I&(B)
+    (?$B$s(B ?$B%s(B ?(I](B)
+    (?$B$,(B ?$B%,(B "(I6^(B") (?$B$.(B ?$B%.(B "(I7^(B") (?$B$0(B ?$B%0(B "(I8^(B") (?$B$2(B ?$B%2(B "(I9^(B") (?$B$4(B ?$B%4(B "(I:^(B")
+    (?$B$6(B ?$B%6(B "(I;^(B") (?$B$8(B ?$B%8(B "(I<^(B") (?$B$:(B ?$B%:(B "(I=^(B") (?$B$<(B ?$B%<(B "(I>^(B") (?$B$>(B ?$B%>(B "(I?^(B")
+    (?$B$@(B ?$B%@(B "(I@^(B") (?$B$B(B ?$B%B(B "(IA^(B") (?$B$E(B ?$B%E(B "(IB^(B") (?$B$G(B ?$B%G(B "(IC^(B") (?$B$I(B ?$B%I(B "(ID^(B")
+    (?$B$P(B ?$B%P(B "(IJ^(B") (?$B$S(B ?$B%S(B "(IK^(B") (?$B$V(B ?$B%V(B "(IL^(B") (?$B$Y(B ?$B%Y(B "(IM^(B") (?$B$\(B ?$B%\(B "(IN^(B")
+    (?$B$Q(B ?$B%Q(B "(IJ_(B") (?$B$T(B ?$B%T(B "(IK_(B") (?$B$W(B ?$B%W(B "(IL_(B") (?$B$Z(B ?$B%Z(B "(IM_(B") (?$B$](B ?$B%](B "(IN_(B")
+    (?$B$!(B ?$B%!(B ?(I'(B) (?$B$#(B ?$B%#(B ?(I((B) (?$B$%(B ?$B%%(B ?(I)(B) (?$B$'(B ?$B%'(B ?(I*(B) (?$B$)(B ?$B%)(B ?(I+(B)
+    (?$B$C(B ?$B%C(B ?(I/(B)
+    (?$B$c(B ?$B%c(B ?(I,(B) (?$B$e(B ?$B%e(B ?(I-(B) (?$B$g(B ?$B%g(B ?(I.(B)
+    (?$B$n(B ?$B%n(B nil)
+    (nil ?$B%t(B "(I3^(B") (nil ?$B%u(B nil) (nil ?$B%v(B nil))
+  "Japanese JISX0208 Kana character table.
+Each element is of the form (HIRAGANA KATAKANA HANKAKU-KATAKANA), where
+HIRAGANA and KATAKANA belong to `japanese-jisx0208',
+HANKAKU-KATAKANA belongs to `japanese-jisx0201-kana'.")
+
+;; Put properties 'katakana, 'hiragana, and 'jix0201 to each Japanese
+;; kana characters for conversion among them.
+(let ((l japanese-kana-table)
+      slot hiragana katakana jisx0201)
+  (while l
+    (setq slot (car l)
+          hiragana (car slot) katakana (nth 1 slot) jisx0201 (nth 2 slot)
+          l (cdr l))
+    (if hiragana
+        (progn
+          (put-char-code-property hiragana 'katakana katakana)
+          (put-char-code-property katakana 'hiragana hiragana)
+          (if jisx0201
+              (progn
+                (put-char-code-property hiragana 'jisx0201 jisx0201)
+                (if (integerp jisx0201)
+                    (put-char-code-property jisx0201 'hiragana hiragana))))))
+    (if jisx0201
+        (progn
+          (put-char-code-property katakana 'jisx0201 jisx0201)
+          (if (integerp jisx0201)
+              (put-char-code-property jisx0201 'katakana katakana))))))
+
+(defconst japanese-symbol-table
+  '((?\$B!!(B ?\ ) (?$B!"(B ?, ?(I$(B) (?$B!#(B ?. ?(I!(B) (?$B!$(B ?, ?(I$(B) (?$B!%(B ?. ?(I!(B) (?$B!&(B nil ?(I%(B)
+    (?$B!'(B ?:) (?$B!((B ?\;) (?$B!)(B ??) (?$B!*(B ?!) (?$B!+(B nil ?(I^(B) (?$B!,(B nil ?(I_(B)
+    (?$B!-(B ?') (?$B!.(B ?`) (?$B!0(B ?^) (?$B!2(B ?_) (?$B!<(B ?-) (?$B!=(B ?-) (?$B!>(B ?-)
+    (?$B!?(B ?/) (?$B!@(B ?\\) (?$B!A(B ?~)  (?$B!C(B ?|) (?$B!F(B ?`) (?$B!G(B ?') (?$B!H(B ?\") (?$B!I(B ?\")
+    (?\$B!J(B ?\() (?\$B!K(B ?\)) (?\$B!N(B ?[) (?\$B!O(B ?]) (?\$B!P(B ?{) (?\$B!Q(B ?})
+    (?$B!R(B ?<) (?$B!S(B ?>) (?$B!\(B ?+) (?$B!](B ?-) (?$B!a(B ?=) (?$B!c(B ?<) (?$B!d(B ?>)
+    (?$B!l(B ?') (?$B!m(B ?\") (?$B!o(B ?\\) (?$B!p(B ?$) (?$B!s(B ?%) (?$B!t(B ?#) (?$B!u(B ?&) (?$B!v(B ?*)
+    (?$B!w(B ?@))
+  "Japanese JISX0208 symbol character table.
+  Each element is of the form (SYMBOL ASCII HANKAKU), where SYMBOL
+belongs to `japanese-jisx0208', ASCII belongs to `ascii', and HANKAKU
+belongs to `japanese-jisx0201-kana'.")
+
+;; Put properties 'jisx0208, 'jisx0201, and 'ascii to each Japanese
+;; symbol and ASCII characters for conversion among them.
+(let ((l japanese-symbol-table)
+      slot jisx0208 ascii jisx0201)
+  (while l
+    (setq slot (car l)
+          jisx0208 (car slot) ascii (nth 1 slot) jisx0201 (nth 2 slot)
+          l (cdr l))
+    (if ascii
+        (progn
+          (put-char-code-property jisx0208 'ascii ascii)
+          (put-char-code-property ascii 'jisx0208 jisx0208)))
+    (if jisx0201
+        (progn
+          (put-char-code-property jisx0208 'jisx0201 jisx0201)
+          (put-char-code-property jisx0201 'jisx0208 jisx0208)))))
+
+(defconst japanese-alpha-numeric-table
+  '((?$B#0(B . ?0) (?$B#1(B . ?1) (?$B#2(B . ?2) (?$B#3(B . ?3) (?$B#4(B . ?4)
+    (?$B#5(B . ?5) (?$B#6(B . ?6) (?$B#7(B . ?7) (?$B#8(B . ?8) (?$B#9(B . ?9)
+    (?$B#A(B . ?A) (?$B#B(B . ?B) (?$B#C(B . ?C) (?$B#D(B . ?D) (?$B#E(B . ?E) 
+    (?$B#F(B . ?F) (?$B#G(B . ?G) (?$B#H(B . ?H) (?$B#I(B . ?I) (?$B#J(B . ?J)
+    (?$B#K(B . ?K) (?$B#L(B . ?L) (?$B#M(B . ?M) (?$B#N(B . ?N) (?$B#O(B . ?O)
+    (?$B#P(B . ?P) (?$B#Q(B . ?Q) (?$B#R(B . ?R) (?$B#S(B . ?S) (?$B#T(B . ?T)
+    (?$B#U(B . ?U) (?$B#V(B . ?V) (?$B#W(B . ?W) (?$B#X(B . ?X) (?$B#Y(B . ?Y) (?$B#Z(B . ?Z)
+    (?$B#a(B . ?a) (?$B#b(B . ?b) (?$B#c(B . ?c) (?$B#d(B . ?d) (?$B#e(B . ?e)
+    (?$B#f(B . ?f) (?$B#g(B . ?g) (?$B#h(B . ?h) (?$B#i(B . ?i) (?$B#j(B . ?j)
+    (?$B#k(B . ?k) (?$B#l(B . ?l) (?$B#m(B . ?m) (?$B#n(B . ?n) (?$B#o(B . ?o)
+    (?$B#p(B . ?p) (?$B#q(B . ?q) (?$B#r(B . ?r) (?$B#s(B . ?s) (?$B#t(B . ?t)
+    (?$B#u(B . ?u) (?$B#v(B . ?v) (?$B#w(B . ?w) (?$B#x(B . ?x) (?$B#y(B . ?y) (?$B#z(B . ?z))
+  "Japanese JISX0208 alpha numeric character table.
+Each element is of the form (ALPHA-NUMERIC ASCII), where ALPHA-NUMERIC
+belongs to `japanese-jisx0208', ASCII belongs to `ascii'.")
+
+;; Put properties 'jisx0208 and 'ascii to each Japanese alpha numeric
+;; and ASCII characters for conversion between them.
+(let ((l japanese-alpha-numeric-table)
+      slot jisx0208 ascii)
+  (while l
+    (setq slot (car l)
+          jisx0208 (car slot) ascii (cdr slot)
+          l (cdr l))
+    (put-char-code-property jisx0208 'ascii ascii)
+    (put-char-code-property ascii 'jisx0208 jisx0208)))
+
+;; Convert string STR by FUNC and return a resulting string.
+(defun japanese-string-conversion (str func &rest args)
+  (let ((buf (get-buffer-create " *Japanese work*")))
+    (save-excursion
+      (set-buffer buf)
+      (erase-buffer)
+      (insert str)
+      (apply func 1 (point) args)
+      (buffer-string))))
+
+;;;###autoload
+(defun japanese-katakana (obj &optional hankaku)
+  "Convert argument to Katakana and return that.
+The argument may be a character or string.  The result has the same type.
+The argument object is not altered--the value is a copy.
+Optional argument HANKAKU t means to convert to `hankaku' Katakana
+ \(`japanese-jisx0201-kana'), in which case return value
+ may be a string even if OBJ is a character if two Katakanas are
+ necessary to represent OBJ."
+  (if (stringp obj)
+      (japanese-string-conversion obj 'japanese-katakana-region hankaku)
+    (or (get-char-code-property obj (if hankaku 'jisx0201 'katakana))
+        obj)))
+
+;;;###autoload
+(defun japanese-hiragana (obj)
+  "Convert argument to Hiragana and return that.
+The argument may be a character or string.  The result has the same type.
+The argument object is not altered--the value is a copy."
+  (if (stringp obj)
+      (japanese-string-conversion obj 'japanese-hiragana-region)
+    (or (get-char-code-property obj 'hiragana)
+        obj)))
+
+;;;###autoload
+(defun japanese-hankaku (obj &optional ascii-only)
+  "Convert argument to `hankaku' and return that.
+The argument may be a character or string.  The result has the same type.
+The argument object is not altered--the value is a copy.
+Optional argument ASCII-ONLY non-nil means to return only ASCII character."
+  (if (stringp obj)
+      (japanese-string-conversion obj 'japanese-hankaku-region ascii-only)
+    (or (get-char-code-property obj 'ascii)
+        (and (not ascii-only)
+             (get-char-code-property obj 'jisx0201))
+        obj)))
+
+;;;###autoload
+(defun japanese-zenkaku (obj)
+  "Convert argument to `zenkaku' and return that.
+The argument may be a character or string.  The result has the same type.
+The argument object is not altered--the value is a copy."
+  (if (stringp obj)
+      (japanese-string-conversion obj 'japanese-zenkaku-region)
+    (or (get-char-code-property obj 'jisx0208)
+        obj)))
+
+;;;###autoload
+(defun japanese-katakana-region (from to &optional hankaku)
+  "Convert Japanese `hiragana' chars in the region to `katakana' chars.
+Optional argument HANKAKU t means to convert to `hankaku katakana' character
+of which charset is `japanese-jisx0201-kana'."
+  (interactive "r\nP")
+  (save-restriction
+    (narrow-to-region from to)
+    (goto-char (point-min))
+    (while (re-search-forward "\\cH\\|\\cK" nil t)
+      (let* ((hira (preceding-char))
+             (kata (japanese-katakana hira hankaku)))
+        (if kata
+            (progn
+              (delete-region (match-beginning 0) (match-end 0))
+              (insert kata)))))))
+
+;;;###autoload
+(defun japanese-hiragana-region (from to)
+  "Convert Japanese `katakana' chars in the region to `hiragana'  chars."
+  (interactive "r")
+  (save-restriction
+    (narrow-to-region from to)
+    (goto-char (point-min))
+    (while (re-search-forward "\\cK\\|\\ck" nil t)
+      (let* ((kata (preceding-char))
+             (hira (japanese-hiragana kata)))
+        (if hira
+            (progn
+              (delete-region (match-beginning 0) (match-end 0))
+              (insert hira)))))))
+
+;;;###autoload
+(defun japanese-hankaku-region (from to &optional ascii-only)
+  "Convert Japanese `zenkaku' chars in the region to `hankaku' chars.
+`Zenkaku' chars belong to `japanese-jisx0208'
+`Hankaku' chars belong to `ascii' or `japanese-jisx0201-kana'.
+Optional argument ASCII-ONLY non-nil means to convert only to ASCII char."
+  (interactive "r\nP")
+  (save-restriction
+    (narrow-to-region from to)
+    (goto-char (point-min))
+    (while (re-search-forward "\\cj" nil t)
+      (let* ((zenkaku (preceding-char))
+             (hankaku (japanese-hankaku zenkaku ascii-only)))
+        (if hankaku
+            (progn
+              (delete-region (match-beginning 0) (match-end 0))
+              (insert hankaku)))))))
+
+;;;###autoload
+(defun japanese-zenkaku-region (from to)
+  "Convert hankaku' chars in the region to Japanese `zenkaku' chars.
+`Zenkaku' chars belong to `japanese-jisx0208'
+`Hankaku' chars belong to `ascii' or `japanese-jisx0201-kana'."
+  (interactive "r")
+  (save-restriction
+    (narrow-to-region from to)
+    (goto-char (point-min))
+    (while (re-search-forward "\\ca\\|\\ck" nil t)
+      (let* ((hankaku (preceding-char))
+             (zenkaku (japanese-zenkaku hankaku)))
+        (if zenkaku
+            (progn
+              (delete-region (match-beginning 0) (match-end 0))
+              (insert zenkaku)))))))
+
+;;;###autoload
+(defun read-hiragana-string (prompt &optional initial-input)
+  "Read a Hiragana string from the minibuffer, prompting with string PROMPT.
+If non-nil, second arg INITIAL-INPUT is a string to insert before reading."
+  (read-multilingual-string prompt initial-input
+                            "Japanese" "quail-ja-hiragana"))
+
+;;
+(provide 'language/japan-util)
+
+;;; Local Variables:
+;;; generated-autoload-file: "../loaddefs.el"
+;;; End:
+;;; japan-util.el ends here
diff --git a/lisp/language/japanese.el b/lisp/language/japanese.el
new file mode 100644
index 00000000000..f0dd5eb7be8
--- /dev/null
+++ b/lisp/language/japanese.el
@@ -0,0 +1,96 @@
+;;; japanese.el --- Japanese support
+
+;; Copyright (C) 1995 Free Software Foundation, Inc.
+;; Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+;; Keywords: multilingual, Japanese
+
+;; 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.
+
+;;; Commentary:
+
+;; For Japanese, character sets JISX0201, JISX0208, JISX0212 are
+;; supported.
+
+;;; Code:
+
+(make-coding-system
+ 'coding-system-sjis 1 ?S
+ "Coding-system of Shift-JIS used in Japan." t)
+
+;; ISO-2022-JP and JUNET are aliases for ISO-2022-7.
+(put 'coding-system-iso-2022-jp 'coding-system 'coding-system-iso-2022-7)
+(put 'coding-system-junet 'coding-system 'coding-system-iso-2022-7)
+
+(make-coding-system
+ 'coding-system-old-jis 2 ?J
+ "Coding-system used for old jis terminal."
+ '((ascii t) nil nil nil
+   short ascii-eol ascii-cntl seven nil nil use-roman use-oldjis))
+
+(make-coding-system
+ 'coding-system-euc-japan 2 ?E
+ "Coding-system of Japanese EUC (Extended Unix Code)."
+ '(ascii japanese-jisx0208 katakana-jisx0201 japanese-jisx0212
+         short ascii-eol ascii-cntl nil nil single-shift))
+
+(register-input-method
+ "Japanese" '("quail-ja" quail-use-package "quail/japanese"))
+
+(register-input-method
+ "Japanese" '("quail-ja-hiragana" quail-use-package "quail/japanese"))
+
+(defun setup-japanese-environment ()
+  (interactive)
+  (setq coding-category-iso-8-2 'coding-system-euc-japan)
+
+  (set-coding-priority
+   '(coding-category-iso-7
+     coding-category-iso-8-2
+     coding-category-sjis
+     coding-category-iso-8-1
+     coding-category-iso-else
+     coding-category-internal))
+
+  (if (eq system-type 'ms-dos)
+      (progn
+        (setq-default buffer-file-coding-system 'coding-system-sjis)
+        (set-terminal-coding-system 'coding-system-sjis)
+        (set-keyboard-coding-system 'coding-system-sjis)
+        (setq default-process-coding-system
+              '(coding-system-sjis-dos . coding-system-sjis-dos)))
+    (setq-default buffer-file-coding-system 'coding-system-iso-2022-jp)
+    (set-terminal-coding-system 'coding-system-iso-2022-jp)
+    (set-keyboard-coding-system 'coding-system-iso-2022-jp))
+
+  (set-default-input-method "Japanese" "quail-ja")
+  )
+
+(set-language-info-alist
+ "Japanese" '((setup-function . setup-japanese-environment)
+              (tutorial . "TUTORIAL.jp")
+              (charset . (japanese-jisx0208 japanese-jisx0208-1978
+                          japanese-jisx0212 latin-jisx0201
+                          katakana-jisx0201))
+              (coding-system . (coding-system-euc-japan
+                                coding-system-sjis
+                                coding-system-old-jis
+                                coding-system-iso-2022-jp))
+              (documentation . t)
+              (sample-text . "Japanese ($BF|K\8l(B)           $B$3$s$K$A$O(B, (I:]FAJ(B")))
+
+;;; japanese.el ends here
diff --git a/lisp/language/korean.el b/lisp/language/korean.el
new file mode 100644
index 00000000000..4fda60ac830
--- /dev/null
+++ b/lisp/language/korean.el
@@ -0,0 +1,78 @@
+;;; korean.el --- Support for Korean
+
+;; Copyright (C) 1995 Free Software Foundation, Inc.
+;; Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+;; Keywords: multilingual, Korean
+
+;; 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.
+
+;;; Commentary:
+
+;; For Korean, the character set KSC5601 is supported.
+
+;;; Code:
+
+(make-coding-system
+ 'coding-system-euc-korea 2 ?K
+ "Coding-system of Korean EUC (Extended Unix Code)."
+ '((ascii t) korean-ksc5601 nil nil
+   nil ascii-eol ascii-cntl))
+
+;; EUC-KR is an alias for EUC-KOREA.
+(put 'coding-system-euc-kr 'coding-system 'coding-system-euc-korea)
+
+(make-coding-system
+ 'coding-system-iso-2022-kr 2 ?k
+ "Coding-System used for communication with mail in Korea."
+ '(ascii (nil korean-ksc5601) nil nil
+         nil ascii-eol ascii-cntl seven locking-shift))
+
+(register-input-method
+ "Korean" '("quail-hangul" quail-use-package "quail/hangul"))
+(register-input-method
+ "Korean" '("quail-hangul3" quail-use-package "quail/hangul3"))
+(register-input-method
+ "Korean" '("quail-hanja" quail-use-package "quail/hanja"))
+(register-input-method
+ "Korean" '("quail-symbol-ksc" quail-use-package "quail/symbol-ksc"))
+(register-input-method
+ "Korean" '("quail-hanja-jis" quail-use-package "quail/hanja-jis"))
+
+(defun setup-korean-environment ()
+  (setq coding-category-iso-8-2 'coding-system-euc-korea)
+
+  (set-coding-priority
+   '(coding-category-iso-7
+     coding-category-iso-8-2
+     coding-category-iso-8-1))
+
+  (setq-default buffer-file-coding-system 'coding-system-euc-korea)
+
+  (setq default-input-method '("Korean" . "quail-hangul"))
+  )
+
+(set-language-info-alist
+ "Korean" '((setup-function . setup-korean-environment)
+            (tutorial . "TUTORIAL.kr")
+            (charset . (korean-ksc5601))
+            (coding-system . (coding-system-euc-korea
+                              coding-system-iso-2022-kr))
+            (documentation . t)
+            (sample-text . "Hangul ($(CGQ1[(B)        $(C>H3gGO<<?d(B, $(C>H3gGO=J4O1n(B")))
+
+;;; korean.el ends here
diff --git a/lisp/language/misc-lang.el b/lisp/language/misc-lang.el
new file mode 100644
index 00000000000..e0f6a969b4d
--- /dev/null
+++ b/lisp/language/misc-lang.el
@@ -0,0 +1,31 @@
+;;; misc-lang.el --- support for miscellaneous languages (characters)
+
+;; Copyright (C) 1995 Free Software Foundation, Inc.
+;; Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+;; Keywords: multilingual, character set, coding system
+
+;; 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.
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; IPA (International Phonetic Alphabet)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(register-input-method
+ "IPA" '("quail-ipa" quail-use-package "quail/ipa"))
+
+;;; misc-lang.el ends here
diff --git a/lisp/language/thai-util.el b/lisp/language/thai-util.el
new file mode 100644
index 00000000000..04685bf7553
--- /dev/null
+++ b/lisp/language/thai-util.el
@@ -0,0 +1,176 @@
+;; thai-util.el -- utilities for Thai
+
+;; Copyright (C) 1995 Free Software Foundation, Inc.
+;; Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+;; Keywords: mule, multilingual, thai
+
+;; 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.
+
+;;; Code:
+
+;; Setting information of Thai characters.
+
+(let ((l '((?,T!(B consonant "LETTER KO KAI")                         ; 0xA1
+           (?,T"(B consonant "LETTER KHO KHAI")                               ; 0xA2
+           (?,T#(B consonant "LETTER KHO KHUAT")                              ; 0xA3
+           (?,T$(B consonant "LETTER KHO KHWAI")                              ; 0xA4
+           (?,T%(B consonant "LETTER KHO KHON")                               ; 0xA5
+           (?,T&(B consonant "LETTER KHO RAKHANG")                            ; 0xA6
+           (?,T'(B consonant "LETTER NGO NGU")                                ; 0xA7
+           (?,T((B consonant "LETTER CHO CHAN")                               ; 0xA8
+           (?,T)(B consonant "LETTER CHO CHING")                              ; 0xA9
+           (?,T*(B consonant "LETTER CHO CHANG")                              ; 0xAA
+           (?,T+(B consonant "LETTER SO SO")                          ; 0xAB
+           (?,T,(B consonant "LETTER CHO CHOE")                               ; 0xAC
+           (?,T-(B consonant "LETTER YO YING")                                ; 0xAD
+           (?,T.(B consonant "LETTER DO CHADA")                               ; 0xAE
+           (?,T/(B consonant "LETTER TO PATAK")                               ; 0xAF
+           (?,T0(B consonant "LETTER THO THAN")                               ; 0xB0
+           (?,T1(B consonant "LETTER THO NANGMONTHO")                 ; 0xB1
+           (?,T2(B consonant "LETTER THO PHUTHAO")                            ; 0xB2
+           (?,T3(B consonant "LETTER NO NEN")                         ; 0xB3
+           (?,T4(B consonant "LETTER DO DEK")                         ; 0xB4
+           (?,T5(B consonant "LETTER TO TAO")                         ; 0xB5
+           (?,T6(B consonant "LETTER THO THUNG")                              ; 0xB6
+           (?,T7(B consonant "LETTER THO THAHAN")                             ; 0xB7
+           (?,T8(B consonant "LETTER THO THONG")                              ; 0xB8
+           (?,T9(B consonant "LETTER NO NU")                          ; 0xB9
+           (?,T:(B consonant "LETTER BO BAIMAI")                              ; 0xBA
+           (?,T;(B consonant "LETTER PO PLA")                         ; 0xBB
+           (?,T<(B consonant "LETTER PHO PHUNG")                              ; 0xBC
+           (?,T=(B consonant "LETTER FO FA")                          ; 0xBD
+           (?,T>(B consonant "LETTER PHO PHAN")                               ; 0xBE
+           (?,T?(B consonant "LETTER FO FAN")                         ; 0xBF
+           (?,T@(B consonant "LETTER PHO SAMPHAO")                            ; 0xC0
+           (?,TA(B consonant "LETTER MO MA")                          ; 0xC1
+           (?,TB(B consonant "LETTER YO YAK")                         ; 0xC2
+           (?,TC(B consonant "LETTER RO RUA")                         ; 0xC3
+           (?,TD(B vowel-base "LETTER RU (Pali vowel letter)")                ; 0xC4
+           (?,TE(B consonant "LETTER LO LING")                                ; 0xC5
+           (?,TF(B vowel-base "LETTER LU (Pali vowel letter)")                ; 0xC6
+           (?,TG(B consonant "LETTER WO WAEN")                                ; 0xC7
+           (?,TH(B consonant "LETTER SO SALA")                                ; 0xC8
+           (?,TI(B consonant "LETTER SO RUSI")                                ; 0xC9
+           (?,TJ(B consonant "LETTER SO SUA")                         ; 0xCA
+           (?,TK(B consonant "LETTER HO HIP")                         ; 0xCB
+           (?,TL(B consonant "LETTER LO CHULA")                               ; 0xCC
+           (?,TM(B consonant "LETTER O ANG")                          ; 0xCD
+           (?,TN(B consonant "LETTER HO NOK HUK")                             ; 0xCE
+           (?,TO(B special "PAI YAN NOI (abbreviation)")                      ; 0xCF
+           (?,TP(B vowel-base "VOWEL SIGN SARA A")                            ; 0xD0
+           (?,TQ(B vowel-upper "VOWEL SIGN MAI HAN-AKAT N/S-T")               ; 0xD1
+           (?,TR(B vowel-base "VOWEL SIGN SARA AA")                           ; 0xD2
+           (?,TS(B vowel-base "VOWEL SIGN SARA AM")                           ; 0xD3
+           (?,TT(B vowel-upper "VOWEL SIGN SARA I N/S-T")                     ; 0xD4
+           (?,TU(B vowel-upper "VOWEL SIGN SARA II N/S-T")                    ; 0xD5
+           (?,TV(B vowel-upper "VOWEL SIGN SARA UE N/S-T")                    ; 0xD6
+           (?,TW(B vowel-upper "VOWEL SIGN SARA UEE N/S-T")                   ; 0xD7
+           (?,TX(B vowel-lower "VOWEL SIGN SARA U N/S-B")                     ; 0xD8
+           (?,TY(B vowel-lower "VOWEL SIGN SARA UU N/S-B")                    ; 0xD9
+           (?,TZ(B vowel-lower "VOWEL SIGN PHINTHU N/S-B (Pali virama)")      ; 0xDA
+           (?,T[(B invalid nil)                                               ; 0xDA
+           (?,T\(B invalid nil)                                               ; 0xDC
+           (?,T](B invalid nil)                                               ; 0xDC
+           (?,T^(B invalid nil)                                               ; 0xDC
+           (?,T_(B special "BAHT SIGN (currency symbol)")                     ; 0xDF
+           (?,T`(B vowel-base "VOWEL SIGN SARA E")                            ; 0xE0
+           (?,Ta(B vowel-base "VOWEL SIGN SARA AE")                           ; 0xE1
+           (?,Tb(B vowel-base "VOWEL SIGN SARA O")                            ; 0xE2
+           (?,Tc(B vowel-base "VOWEL SIGN SARA MAI MUAN")                     ; 0xE3
+           (?,Td(B vowel-base "VOWEL SIGN SARA MAI MALAI")                    ; 0xE4
+           (?,Te(B vowel-base "LAK KHANG YAO")                                ; 0xE5
+           (?,Tf(B special "MAI YAMOK (repetion)")                            ; 0xE6
+           (?,Tg(B vowel-upper "VOWEL SIGN MAI TAI KHU N/S-T")                ; 0xE7
+           (?,Th(B tone "TONE MAI EK N/S-T")                          ; 0xE8
+           (?,Ti(B tone "TONE MAI THO N/S-T")                         ; 0xE9
+           (?,Tj(B tone "TONE MAI TRI N/S-T")                         ; 0xEA
+           (?,Tk(B tone "TONE MAI CHATTAWA N/S-T")                            ; 0xEB
+           (?,Tl(B tone "THANTHAKHAT N/S-T (cancellation mark)")              ; 0xEC
+           (?,Tm(B tone "NIKKHAHIT N/S-T (final nasal)")                      ; 0xED
+           (?,Tn(B vowel-upper "YAMAKKAN N/S-T")                              ; 0xEE
+           (?,To(B special "FONRMAN")                                 ; 0xEF
+           (?,Tp(B special "DIGIT ZERO")                                      ; 0xF0
+           (?,Tq(B special "DIGIT ONE")                                       ; 0xF1
+           (?,Tr(B special "DIGIT TWO")                                       ; 0xF2
+           (?,Ts(B special "DIGIT THREE")                                     ; 0xF3
+           (?,Tt(B special "DIGIT FOUR")                                      ; 0xF4
+           (?,Tu(B special "DIGIT FIVE")                                      ; 0xF5
+           (?,Tv(B special "DIGIT SIX")                                       ; 0xF6
+           (?,Tw(B special "DIGIT SEVEN")                                     ; 0xF7
+           (?,Tx(B special "DIGIT EIGHT")                                     ; 0xF8
+           (?,Ty(B special "DIGIT NINE")                                      ; 0xF9
+           (?,Tz(B special "ANGKHANKHU (ellipsis)")                           ; 0xFA
+           (?,T{(B special "KHOMUT (beginning of religious texts)")           ; 0xFB
+           (?,T|(B invalid nil)                                               ; 0xFC
+           (?,T}(B invalid nil)                                               ; 0xFD
+           (?,T~(B invalid nil)                                               ; 0xFE
+           ))
+      elm)
+  (while l
+    (setq elm (car l))
+    (put-char-code-property (car elm) 'phonetic-type (car (cdr elm)))
+    (put-char-code-property (car elm) 'name (nth 2 elm))
+    (setq l (cdr l))))
+
+;;;###autoload
+(defun thai-compose-region (beg end)
+  "Compose Thai characters in the region.
+When called from a program, expects two arguments,
+positions (integers or markers) specifying the region."
+  (interactive "r")
+  (save-restriction
+    (narrow-to-region beg end)
+    (decompose-region (point-min) (point-max))
+    (goto-char (point-min))
+    (while (re-search-forward "\\c0\\(\\c2\\|\\c3\\|\\c4\\)+" nil t)
+      (if (aref (char-category-set (char-after (match-beginning 0))) ?t)
+          (compose-region (match-beginning 0) (match-end 0))))))
+
+;;;###autoload
+(defun thai-compose-buffer ()
+  "Compose Thai characters in the current buffer."
+  (interactive)
+  (thai-compose-region (point-min) (point-max)))
+
+;;;###autoload
+(defun thai-post-read-conversion (len)
+  (save-excursion
+    (save-restriction
+      (let ((buffer-modified-p (buffer-modified-p)))
+        (narrow-to-region (point) (+ (point) len))
+        (thai-compose-region (point-min) (point-max))
+        (set-buffer-modified-p buffer-modified-p)
+        (point-max)))))
+
+;;;###autoload
+(defun thai-pre-write-conversion (from to)
+  (let ((old-buf (current-buffer))
+        (work-buf (get-buffer-create " *thai-work*")))
+    (set-buffer work-buf)
+    (erase-buffer)
+    (insert-buffer-substring old-buf from to)
+    (decompose-region (point-min) (point-max))))
+
+;;
+(provide 'language/thai-util)
+
+;;; Local Variables:
+;;; generated-autoload-file: "../loaddefs.el"
+;;; End:
+;;; thai-util.el ends here
+
diff --git a/lisp/language/thai.el b/lisp/language/thai.el
new file mode 100644
index 00000000000..848959674f1
--- /dev/null
+++ b/lisp/language/thai.el
@@ -0,0 +1,63 @@
+;;; thai.el --- Support for Thai
+
+;; Copyright (C) 1995 Free Software Foundation, Inc.
+;; Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+;; Keywords: multilingual, Thai
+
+;; 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.
+
+;;; Commentary:
+
+;; For Thai, the character set TIS620 is supported.
+
+;;; Code:
+
+(make-coding-system
+ 'coding-system-tis620 2 ?T
+ "Coding-system used for ASCII(MSB=0) & TIS620(MSB=1)."
+ '((ascii t) (thai-tis620 t) nil nil
+   nil ascii-eol))
+(put 'coding-system-tis620 'post-read-conversion
+     'thai-post-read-conversion)
+(put 'coding-system-tis620 'pre-write-conversion
+     'thai-pre-write-conversion)
+
+(register-input-method
+ "Thai" '("quail-thai" quail-use-package "quail/thai"))
+
+(defun setup-thai-environment ()
+  (setq coding-category-iso-8-1 'coding-system-tis620)
+
+  (set-coding-priority
+   '(coding-category-iso-7
+     coding-category-iso-8-1))
+
+  (setq-default buffer-file-coding-system 'coding-system-tis620)
+
+  (setq default-input-method '("Thai" . "quail-thai"))
+  )
+
+(set-language-info-alist
+ "Thai" '((tutorial . "TUTORIAL.th")
+          (setup-function . setup-thai-environment)
+          (charset . (thai-tis620))
+          (coding-systemm . (coding-system-tis620))
+          (documentation . t)
+          (sample-text . "Thai (,T@RIRd7B(B)          ,TJ0GQ1J04U1$0CQ1:(B, ,TJ0GQ1J04U10$h1P(B")))
+
+;;; thai.el ends here
diff --git a/lisp/language/viet-util.el b/lisp/language/viet-util.el
new file mode 100644
index 00000000000..6303f34dc9b
--- /dev/null
+++ b/lisp/language/viet-util.el
@@ -0,0 +1,267 @@
+;; viet-util.el --  utilities for Vietnamese
+
+;; Copyright (C) 1995 Free Software Foundation, Inc.
+;; Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+;; Keywords: mule, multilingual, Vietnamese
+
+;; 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.
+
+;;; Commentary:
+
+;; Vietnamese uses ASCII characters and additional 134 unique
+;; characters (these are Latin alphabets with various diacritical and
+;; tone marks).  As far as I know, Vietnamese now has 4 different ways
+;; for representing these characters: VISCII, VSCII, VIQR, and
+;; Unicode.  VISCII and VSCII are simple 1-byte code which assigns 134
+;; unique characters in control-code area (0x00..0x1F) and right half
+;; area (0x80..0xFF).  VIQR is a menmonic encoding specification
+;; representing diacritical marks by following ASCII characters.
+
+;;; Code:
+
+;; VIQR is a menmonic encoding specification for Vietnamese.
+;; It represents diacritical marks by ASCII characters as follows:
+;; ------------+----------+--------
+;;     mark    | mnemonic | example
+;; ------------+----------+---------
+;;    breve    |    (     | a( -> ,1e(B
+;;  circumflex |    ^     | a^ -> ,1b(B
+;;    horn     |    +     | o+ -> ,1=(B
+;; ------------+----------+---------
+;;    acute    |    '     | a' -> ,1a(B
+;;    grave    |    `     | a` -> ,1`(B
+;;  hook above |    ?     | a? -> ,1d(B
+;;    tilde    |    ~     | a~ -> ,1c(B
+;;   dot below |    .     | a. -> ,1U(B
+;; ------------+----------+---------
+;;    d bar    |   dd     | dd -> ,1p(B
+;; ------------+----------+---------
+
+(defvar viet-viqr-alist
+  '(;; lowercase
+    (?,1!(B . "a('")                  ; 161
+    (?,1"(B . "a(`")                  ; 162
+    (?,1#(B . "a(.")                  ; 163
+    (?,1$(B . "a^'")                  ; 164
+    (?,1%(B . "a^`")                  ; 165
+    (?,1&(B . "a^?")                  ; 166
+    (?,1'(B . "a^.")                  ; 167
+    (?,1((B . "e~")                           ; 168
+    (?,1)(B . "e.")                           ; 169
+    (?,1*(B . "e^'")                  ; 170
+    (?,1+(B . "e^`")                  ; 171
+    (?,1,(B . "e^?")                  ; 172
+    (?,1-(B . "e^~")                  ; 173
+    (?,1.(B . "e^.")                  ; 174
+    (?,1/(B . "o^'")                  ; 175
+    (?,10(B . "o^`")                  ; 176
+    (?,11(B . "o^?")                  ; 177
+    (?,12(B . "o^~")                  ; 178
+    (?,15(B . "o^.")                  ; 181
+    (?,16(B . "o+`")                  ; 182
+    (?,17(B . "o+?")                  ; 183
+    (?,18(B . "i.")                           ; 184
+    (?,1=(B . "o+")                           ; 189
+    (?,1>(B . "o+'")                  ; 190
+    (?,1F(B . "a(?")                  ; 198
+    (?,1G(B . "a(~")                  ; 199
+    (?,1O(B . "y`")                           ; 207
+    (?,1Q(B . "u+'")                  ; 209
+    (?,1U(B . "a.")                           ; 213
+    (?,1V(B . "y?")                           ; 214
+    (?,1W(B . "u+`")                  ; 215
+    (?,1X(B . "u+?")                  ; 216
+    (?,1[(B . "y~")                           ; 219
+    (?,1\(B . "y.")                           ; 220
+    (?,1^(B . "o+~")                  ; 222
+    (?,1_(B . "u+")                           ; 223
+    (?,1`(B . "a`")                           ; 224
+    (?,1a(B . "a'")                           ; 225
+    (?,1b(B . "a^")                           ; 226
+    (?,1c(B . "a~")                           ; 227
+    (?,1d(B . "a?")                           ; 228
+    (?,1e(B . "a(")                           ; 229
+    (?,1f(B . "u+~")                  ; 230
+    (?,1g(B . "a^~")                  ; 231
+    (?,1h(B . "e`")                           ; 232
+    (?,1i(B . "e'")                           ; 233
+    (?,1j(B . "e^")                           ; 234
+    (?,1k(B . "e?")                           ; 235
+    (?,1l(B . "i`")                           ; 236
+    (?,1m(B . "i'")                           ; 237
+    (?,1n(B . "i~")                           ; 238
+    (?,1o(B . "i?")                           ; 239
+    (?,1p(B . "dd")                           ; 240
+    (?,1q(B . "u+.")                  ; 241
+    (?,1r(B . "o`")                           ; 242
+    (?,1s(B . "o'")                           ; 243
+    (?,1t(B . "o^")                           ; 244
+    (?,1u(B . "o~")                           ; 245
+    (?,1v(B . "o?")                           ; 246
+    (?,1w(B . "o.")                           ; 247
+    (?,1x(B . "u.")                           ; 248
+    (?,1y(B . "u`")                           ; 249
+    (?,1z(B . "u'")                           ; 250
+    (?,1{(B . "u~")                           ; 251
+    (?,1|(B . "u?")                           ; 252
+    (?,1}(B . "y'")                           ; 253
+    (?,1~(B . "o+.")                  ; 254
+
+    ;; upper case
+    (?,2!(B . "A('")                  ; 161
+    (?,2"(B . "A(`")                  ; 162
+    (?,2#(B . "A(.")                  ; 163
+    (?,2$(B . "A^'")                  ; 164
+    (?,2%(B . "A^`")                  ; 165
+    (?,2&(B . "A^?")                  ; 166
+    (?,2'(B . "A^.")                  ; 167
+    (?,2((B . "E~")                           ; 168
+    (?,2)(B . "E.")                           ; 169
+    (?,2*(B . "E^'")                  ; 170
+    (?,2+(B . "E^`")                  ; 171
+    (?,2,(B . "E^?")                  ; 172
+    (?,2-(B . "E^~")                  ; 173
+    (?,2.(B . "E^.")                  ; 174
+    (?,2/(B . "O^'")                  ; 175
+    (?,20(B . "O^`")                  ; 176
+    (?,21(B . "O^?")                  ; 177
+    (?,22(B . "O^~")                  ; 178
+    (?,25(B . "O^.")                  ; 181
+    (?,26(B . "O+`")                  ; 182
+    (?,27(B . "O+?")                  ; 183
+    (?,28(B . "I.")                           ; 184
+    (?,2=(B . "O+")                           ; 189
+    (?,2>(B . "O+'")                  ; 190
+    (?,2F(B . "A(?")                  ; 198
+    (?,2G(B . "A(~")                  ; 199
+    (?,2O(B . "Y`")                           ; 207
+    (?,2Q(B . "U+'")                  ; 209
+    (?,2U(B . "A.")                           ; 213
+    (?,2V(B . "Y?")                           ; 214
+    (?,2W(B . "U+`")                  ; 215
+    (?,2X(B . "U+?")                  ; 216
+    (?,2[(B . "Y~")                           ; 219
+    (?,2\(B . "Y.")                           ; 220
+    (?,2^(B . "O+~")                  ; 222
+    (?,2_(B . "U+")                           ; 223
+    (?,2`(B . "A`")                           ; 224
+    (?,2a(B . "A'")                           ; 225
+    (?,2b(B . "A^")                           ; 226
+    (?,2c(B . "A~")                           ; 227
+    (?,2d(B . "A?")                           ; 228
+    (?,2e(B . "A(")                           ; 229
+    (?,2f(B . "U+~")                  ; 230
+    (?,2g(B . "A^~")                  ; 231
+    (?,2h(B . "E`")                           ; 232
+    (?,2i(B . "E'")                           ; 233
+    (?,2j(B . "E^")                           ; 234
+    (?,2k(B . "E?")                           ; 235
+    (?,2l(B . "I`")                           ; 236
+    (?,2m(B . "I'")                           ; 237
+    (?,2n(B . "I~")                           ; 238
+    (?,2o(B . "I?")                           ; 239
+    (?,2p(B . "DD")                           ; 240
+    (?,2p(B . "dD")                           ; 240
+    (?,2p(B . "Dd")                           ; 240
+    (?,2q(B . "U+.")                  ; 241
+    (?,2r(B . "O`")                           ; 242
+    (?,2s(B . "O'")                           ; 243
+    (?,2t(B . "O^")                           ; 244
+    (?,2u(B . "O~")                           ; 245
+    (?,2v(B . "O?")                           ; 246
+    (?,2w(B . "O.")                           ; 247
+    (?,2x(B . "U.")                           ; 248
+    (?,2y(B . "U`")                           ; 249
+    (?,2z(B . "U'")                           ; 250
+    (?,2{(B . "U~")                           ; 251
+    (?,2|(B . "U?")                           ; 252
+    (?,2}(B . "Y'")                           ; 253
+    (?,2~(B . "O+.")                  ; 254
+
+    ;; escape from composition
+    (?\( . "\\(")                       ; breve (left parenthesis)
+    (?^ . "\\^")                        ; circumflex (caret)
+    (?+ . "\\+")                        ; horn (plus sign)
+    (?' . "\\'")                        ; acute (apostrophe)
+    (?` . "\\`")                        ; grave (backquote)
+    (?? . "\\?")                        ; hook above (question mark)
+    (?~ . "\\~")                        ; tilde (tilde)
+    (?. . "\\.")                        ; dot below (period)
+    (?d . "\\d")                        ; d-bar (d)
+    (?\\ . "\\\\")                      ; literal backslash
+    )
+  "Alist of Vietnamese characters vs corresponding `VIQR' string.")
+
+;; Regular expression matching single Vietnamese character represented
+;; by VIQR.
+(defconst viqr-regexp
+  "[aeiouyAEIOUY]\\([(^+]?['`?~.]\\|[(^+]\\)\\|[Dd][Dd]")
+
+;;;###autoload
+(defun viet-decode-viqr-region (from to)
+  "Convert `VIQR' mnemonics of the current region to Vietnamese characaters.
+When called from a program, expects two arguments,
+positions (integers or markers) specifying the stretch of the region."
+  (interactive "r")
+  (save-restriction
+    (narrow-to-region from to)
+    (goto-char (point-min))
+    (while (re-search-forward viqr-regexp nil t)
+      (let* ((viqr (buffer-substring (match-beginning 0) (match-end 0)))
+             (ch (car (rassoc viet-viqr-alist viqr))))
+        (if ch
+            (progn
+              (delete-region (match-beginning 0) (match-end 0))
+              (insert ch)))))))
+
+;;;###autoload
+(defun viet-decode-viqr-buffer ()
+  "Convert `VIQR' mnemonics of the current buffer to Vietnamese characaters."
+  (interactive)
+  (viet-decode-viqr-region (point-min) (point-max)))
+
+;;;###autoload
+(defun viet-encode-viqr-region (from to)
+  "Convert Vietnamese characaters of the current region to `VIQR' mnemonics.
+When called from a program, expects two arguments,
+positions (integers or markers) specifying the stretch of the region."
+  (interactive "r")
+  (save-restriction
+    (narrow-to-region from to)
+    (goto-char (point-min))
+    (while (re-search-forward "\\cv" nil t)
+      (let* ((ch (preceding-char))
+             (viqr (cdr (assoc viet-viqr-alist ch))))
+        (if viqr
+            (progn
+              (delete-char -1)
+              (insert viqr)))))))
+
+;;;###autoload
+(defun viet-encode-viqr-buffer ()
+  "Convert Vietnamese characaters of the current buffer to `VIQR' mnemonics."
+  (interactive)
+  (viet-encode-viqr-region (point-min) (point-max)))
+
+;;;
+(provide 'language/viet-util)
+
+;;; Local Variables:
+;;; generated-autoload-file: "../loaddefs.el"
+;;; End:
+;;; viet-util.el ends here
diff --git a/lisp/language/vietnamese.el b/lisp/language/vietnamese.el
new file mode 100644
index 00000000000..bb14a4f580c
--- /dev/null
+++ b/lisp/language/vietnamese.el
@@ -0,0 +1,254 @@
+;;; vietnamese.el --- Support for Vietnamese
+
+;; Copyright (C) 1995 Free Software Foundation, Inc.
+;; Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+
+;; Keywords: multilingual, Vietnamese
+
+;; 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.
+
+;;; Commentary:
+
+;; For Vietnames, the character sets VISCII and VSCII are supported.
+
+;;; Code:
+
+(eval-when-compile
+
+(defvar viet-viscii-decode-table
+  [;; VISCII is a full 8-bit code.
+   0 1 ?,2F(B 3 4 ?,2G(B ?,2g(B 7 8 9 10 11 12 13 14 15
+   16 17 18 19 ?,2V(B 21 22 23 24 ?,2[(B 26 27 28 29 ?,2\(B 31
+   32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
+   48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
+   64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79
+   80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
+   96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111
+   112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 
+   ?,2U(B ?,2!(B ?,2"(B ?,2#(B ?,2$(B ?,2%(B ?,2&(B ?,2'(B ?,2((B ?,2)(B ?,2*(B ?,2+(B ?,2,(B ?,2-(B ?,2.(B ?,2/(B
+   ?,20(B ?,21(B ?,22(B ?,25(B ?,2~(B ?,2>(B ?,26(B ?,27(B ?,28(B ?,2v(B ?,2w(B ?,2o(B ?,2|(B ?,2{(B ?,2x(B ?,2O(B
+   ?,2u(B ?,1!(B ?,1"(B ?,1#(B ?,1$(B ?,1%(B ?,1&(B ?,1'(B ?,1((B ?,1)(B ?,1*(B ?,1+(B ?,1,(B ?,1-(B ?,1.(B ?,1/(B
+   ?,10(B ?,11(B ?,12(B ?,2^(B ?,2=(B ?,15(B ?,16(B ?,17(B ?,18(B ?,2q(B ?,2Q(B ?,2W(B ?,2X(B ?,1=(B ?,1>(B ?,2_(B
+   ?,2`(B ?,2a(B ?,2b(B ?,2c(B ?,2d(B ?,2e(B ?,1F(B ?,1G(B ?,2h(B ?,2i(B ?,2j(B ?,2k(B ?,2l(B ?,2m(B ?,2n(B ?,1O(B
+   ?,2p(B ?,1Q(B ?,2r(B ?,2s(B ?,2t(B ?,1U(B ?,1V(B ?,1W(B ?,1X(B ?,2y(B ?,2z(B ?,1[(B ?,1\(B ?,2}(B ?,1^(B ?,1_(B
+   ?,1`(B ?,1a(B ?,1b(B ?,1c(B ?,1d(B ?,1e(B ?,1f(B ?,1g(B ?,1h(B ?,1i(B ?,1j(B ?,1k(B ?,1l(B ?,1m(B ?,1n(B ?,1o(B
+   ?,1p(B ?,1q(B ?,1r(B ?,1s(B ?,1t(B ?,1u(B ?,1v(B ?,1w(B ?,1x(B ?,1y(B ?,1z(B ?,1{(B ?,1|(B ?,1}(B ?,1~(B ?,2f(B ]
+  "Vietnamese VISCII encoding table.")
+
+(defvar viet-viscii-encode-table
+  (let ((table-lower (make-vector 128 0))
+        (table-upper (make-vector 128 0))
+        (i 0)
+        char-component)
+    (while (< i 256)
+      (setq char-component (split-char (aref viet-viscii-decode-table i)))
+      (cond ((eq (car char-component) 'vietnamese-viscii-lower)
+             (aset table-lower (nth 1 char-component) i))
+            ((eq (car char-component) 'vietnamese-viscii-upper)
+             (aset table-upper (nth 1 char-component) i)))
+      (setq i (1+ i)))
+    (cons table-lower table-upper))
+  "Vietnamese VISCII decoding table.
+Cons of tables for decoding lower-case chars and upper-case characterss.
+Both tables are indexed by the position code of Vietnamese characters.")
+
+(defvar viet-vscii-decode-table
+  [;; VSCII is a full 8-bit code.
+   0 ?,2z(B ?,2x(B 3 ?,2W(B ?,2X(B ?,2f(B 7 8 9 10 11 12 13 14 15
+   16 ?,2Q(B ?,2_(B ?,2O(B ?,2V(B ?,2[(B ?,2}(B ?,2\(B 24 25 26 27 28 29 30 31
+   32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
+   48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
+   64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79
+   80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
+   96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111
+   112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 
+   ?,2`(B ?,2d(B ?,2c(B ?,2a(B ?,2U(B ?,2#(B ?,2'(B ?,2h(B ?,2k(B ?,2((B ?,2i(B ?,2)(B ?,2.(B ?,2l(B ?,2o(B ?,2n(B
+   ?,2m(B ?,28(B ?,2r(B ?,2v(B ?,2u(B ?,2s(B ?,2w(B ?,25(B ?,26(B ?,27(B ?,2^(B ?,2>(B ?,2~(B ?,2y(B ?,2|(B ?,2{(B
+   160 ?,2e(B ?,2b(B ?,2j(B ?,2t(B ?,2=(B ?,2_(B ?,2p(B ?,1e(B ?,1b(B ?,1j(B ?,1t(B ?,1>(B ?,1y(B ?,1p(B ?,2"(B
+   192 193 194 195 196 ?,1`(B ?,1d(B ?,1c(B ?,1a(B ?,1U(B ?,2F(B ?,1"(B ?,1F(B ?,1G(B ?,1!(B ?,2G(B
+   ?,2!(B ?,2%(B ?,2&(B ?,2g(B ?,2%(B ?,2+(B ?,1#(B ?,1%(B ?,1&(B ?,1g(B ?,1$(B ?,1'(B ?,1h(B ?,2,(B ?,1k(B ?,1((B
+   ?,1i(B ?,1)(B ?,1+(B ?,1,(B ?,1-(B ?,1*(B ?,1.(B ?,1l(B ?,1o(B ?,2-(B ?,2*(B ?,20(B ?,1n(B ?,1m(B ?,18(B ?,1r(B
+   ?,21(B ?,1v(B ?,1u(B ?,1s(B ?,1w(B ?,10(B ?,11(B ?,12(B ?,1/(B ?,15(B ?,16(B ?,17(B ?,1^(B ?,1>(B ?,1~(B ?,1y(B
+   ?,22(B ?,1|(B ?,1{(B ?,1z(B ?,1x(B ?,1W(B ?,1X(B ?,1f(B ?,1Q(B ?,1q(B ?,1O(B ?,1V(B ?,1[(B ?,1}(B ?,1\(B ?,2/(B]
+  "Vietnamese VSCII code table.")
+
+(defvar viet-vscii-encode-table
+  (let ((table-lower (make-vector 128 0))
+        (table-upper (make-vector 128 0))
+        (i 0)
+        char-component)
+    (while (< i 256)
+      (setq char-component (split-char (aref viet-vscii-decode-table i)))
+      (cond ((eq (car char-component) 'vietnamese-viscii-lower)
+             (aset table-lower (nth 1 char-component) i))
+            ((eq (car char-component) 'vietnamese-viscii-upper)
+             (aset table-upper (nth 1 char-component) i)))
+      (setq i (1+ i)))
+    (cons table-lower table-upper))
+  "Vietnamese VSCII decoding table.
+Cons of tables for decoding lower-case chars and upper-case characterss.
+Both tables are indexed by the position code of Vietnamese characters.")
+
+)
+
+(define-ccl-program ccl-decode-viscii
+  `(3
+    ((read r0)
+     (loop
+      (write-read-repeat r0 ,viet-viscii-decode-table))
+     ))
+  "CCL program to decode VISCII 1.1")
+
+;; Multibyte form of a Vietnamese character is as follows (3-byte):
+;;   LEADING-CODE-PRIVATE-11 LEADING-CODE-EXTENDED-11 POSITION-CODE
+;; where LEADING-CODE-EXTENDED-11 for Vietnamese is
+;; `vietnamese-viscii-lower' or `vietnamese-viscii-upper'.
+
+(define-ccl-program ccl-encode-viscii
+  `(1
+     ((read r0)
+      (loop
+       (if (r0 < 128)
+           ;; ASCII
+           (write-read-repeat r0)
+         ;; not ASCII
+         (if (r0 != ,leading-code-private-11)
+             ;; not Vietnamese
+             (write-read-repeat r0)
+           ((read-if (r0 == ,(charset-id 'vietnamese-viscii-lower))
+             (;; Vietnamese lower
+              (read r0)
+              (r0 -= 128)
+              (write-read-repeat r0 ,(car viet-viscii-encode-table)))
+             (if (r0 == ,(charset-id 'vietnamese-viscii-upper))
+                 (;; Vietnamese upper
+                  (read r0)
+                  (r0 -= 128)
+                  (write-read-repeat r0 ,(cdr viet-viscii-encode-table)))
+               ;; not Vietnamese
+               (write-read-repeat r0)))))))))
+  "CCL program to encode VISCII 1.1")
+
+(define-ccl-program ccl-encode-viscii-font
+  `(0
+    ;; In:  R0:vietnamese-viscii-lower/vietnamese-viscii-upper
+    ;;      R1:position code
+    ;; Out: R1:font code point
+    (if (r0 == ,(charset-id 'vietnamese-viscii-lower))
+        (r1 = r1 ,(car viet-viscii-encode-table))
+      (r1 = r1 ,(cdr viet-viscii-encode-table)))
+    )
+  "CCL program to encode Vietnamese chars to VISCII 1.1 font")
+
+(define-ccl-program ccl-decode-vscii
+  `(3
+    ((read r0)
+     (loop
+      (write-read-repeat r0 ,viet-vscii-decode-table))
+     ))
+  "CCL program to decode VSCII-1.")
+
+(define-ccl-program ccl-encode-vscii
+  `(1
+    ((read r0)
+     (loop
+      (if (r0 < 128)
+          ;; ASCII
+          (write-read-repeat r0)
+        ;; not ASCII 
+        (if (r0 != ,leading-code-private-11)
+            ;; not Vietnamese
+            (write-read-repeat r0)
+          (read-if (r0 == ,(charset-id 'vietnamese-viscii-lower))
+                   (;; Vietnamese lower
+                    (read r0)
+                    (r0 -= 128)
+                    (write-read-repeat r0 ,(car viet-vscii-encode-table)))
+                   (if (r0 == ,(charset-id 'vietnamese-viscii-upper))
+                       (;; Vietnamese upper
+                        (read r0)
+                        (r0 -= 128)
+                        (write-read-repeat r0 ,(cdr viet-viscii-encode-table)))
+                     ;; not Vietnamese
+                     (write-read-repeat r0))))))))
+  "CCL program to encode VSCII-1.")
+
+(define-ccl-program ccl-encode-vscii-font
+  `(0
+    ;; In:  R0:vietnamese-viscii-lower/vietnamese-viscii-upper
+    ;;      R1:position code
+    ;; Out: R1:font code point
+    (if (r0 == ,(charset-id 'vietnamese-viscii-lower))
+        (r1 = r1 ,(car viet-vscii-encode-table))
+      (r1 = r1 ,(cdr viet-vscii-encode-table)))
+    )
+  "CCL program to encode Vietnamese chars to VSCII-1 font.")
+
+
+(make-coding-system
+ 'coding-system-viscii 4 ?V
+ "Coding-system used for VISCII 1.1."
+ (cons ccl-decode-viscii ccl-encode-viscii))
+
+(make-coding-system
+ 'coding-system-vscii 4 ?V
+ "Coding-system used for VSCII-1."
+ (cons ccl-decode-vscii ccl-encode-vscii))
+
+(make-coding-system
+ 'coding-system-viqr 0 ?v
+ "Codins-system used for VIQR."
+ nil)
+(put 'coding-system-viqr 'post-read-conversion 'viet-decode-viqr-region)
+(put 'coding-system-viqr 'pre-write-conversion 'viet-encode-viqr-region)
+
+(setq font-ccl-encoder-alist
+      (cons (cons "viscii" ccl-encode-viscii-font) font-ccl-encoder-alist))
+
+(setq font-ccl-encoder-alist
+      (cons (cons "vscii" ccl-encode-vscii-font) font-ccl-encoder-alist))
+
+(register-input-method
+ "Vietnamese" '("quail-viqr" quail-use-package "quail/viqr"))
+
+(defun setup-viet-environment ()
+  ;; for VISCII users
+  (setq coding-category-binary 'coding-system-viscii)
+
+  ;; for VSCII users
+  ;; (setq coding-category-binary 'coding-system-vscii)
+
+  (set-coding-priority
+   '(coding-category-iso-7
+     coding-category-binary))
+
+  (setq-default buffer-file-coding-system 'coding-system-viscii)
+
+  (setq default-input-method '("Vietnamese" . "quail-viqr"))
+  )
+
+(set-language-info-alist
+ "Vietnamese" '((setup-function . setup-viet-environment)
+                (charset . (vietnamese-viscii-lower
+                            vietnamese-viscii-upper))
+                (coding-system . (coding-system-viscii
+                                  coding-system-vscii
+                                  coding-system-viqr))
+                (documentation . t)
+                (sample-text . "Vietnamese (Ti,1*(Bng Vi,1.(Bt)     Ch,1`(Bo b,1U(Bn")))
+
+;;; vietnamese.el ends here