lisp/international/titdic-cnv.el

   1 ;;; titdic-cnv.el --- convert cxterm dictionary (TIT format) to Quail package -*- coding:iso-2022-7bit; -*-
   2
   3 ;; Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
   4 ;; Licensed to the Free Software Foundation.
   5
   6 ;; Keywords: Quail, TIT, cxterm
   7
   8 ;; This file is part of GNU Emacs.
   9
  10 ;; GNU Emacs is free software; you can redistribute it and/or modify
  11 ;; it under the terms of the GNU General Public License as published by
  12 ;; the Free Software Foundation; either version 2, or (at your option)
  13 ;; any later version.
  14
  15 ;; GNU Emacs is distributed in the hope that it will be useful,
  16 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 ;; GNU General Public License for more details.
  19
  20 ;; You should have received a copy of the GNU General Public License
  21 ;; along with GNU Emacs; see the file COPYING.  If not, write to the
  22 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  23 ;; Boston, MA 02111-1307, USA.
  24
  25 ;;; Commentary:
  26
  27 ;; Convert cxterm dictionary (of TIT format) to quail-package.
  28 ;;
  29 ;; Usage (within Emacs):
  30 ;;      M-x titdic-convert<CR>CXTERM-DICTIONARY-NAME<CR>
  31 ;; Usage (from shell):
  32 ;;      % emacs -batch -l titdic-cnv -f batch-titdic-convert\
  33 ;;              [-dir DIR] [DIR | FILE] ...
  34 ;;
  35 ;; When you run titdic-convert within Emacs, you have a chance to
  36 ;; modify arguments of `quail-define-package' before saving the
  37 ;; converted file.  For instance, you are likely to modify TITLE,
  38 ;; DOCSTRING, and KEY-BINDINGS.
  39
  40 ;; Cxterm dictionary file (*.tit) is a line-oriented text (English,
  41 ;; Chinese, Japanese, and Korean) file.  The whole file contains of
  42 ;; two parts, the definition part (`header' here after) followed by
  43 ;; the dictionary part (`body' here after).  All lines begin with
  44 ;; leading '#' are ignored.
  45 ;;
  46 ;; Each line in the header part has two fields, KEY and VALUE.  These
  47 ;; fields are separated by one or more white characters.
  48 ;;
  49 ;; Each line in the body part has two fields, KEYSEQ and TRANSLATIONS.
  50 ;; These fields are separated by one or more white characters.
  51 ;;
  52 ;; See the manual page of `tit2cit' of cxterm distribution for more
  53 ;; detail.
  54 ;;
  55 ;; Near the end of this file, we also have a few other tools to convert
  56 ;; miscellaneous dictionaries.
  57
  58 ;;; Code:
  59
  60 (require 'quail)
  61
  62 ;; List of values of key "ENCODE:" and the corresponding Emacs
  63 ;; coding-system and language environment name.
  64 (defvar tit-encode-list
  65   '(("GB" euc-china "Chinese-GB")
  66     ("BIG5" cn-big5 "Chinese-BIG5")
  67     ("JIS" euc-japan "Japanese")
  68     ("KS" euc-kr "Korean")))
  69
  70 ;; Alist of input method names and the corresponding title and extra
  71 ;; docstring.  For each of input method generated from TIT dictionary,
  72 ;; a docstring is automatically generated from the comments in the
  73 ;; dictionary.  The extra docstring in this alist is to add more
  74 ;; information.
  75 ;; The command describe-input-method shows the automatically generated
  76 ;; docstring, then an extra docstring while replacing the form \<VAR>
  77 ;; by the value of variable VAR.  For instance, the form
  78 ;; \<quail-translation-docstring> is replaced by a description about
  79 ;; how to select a translation from a list of candidates.
  80
  81 (defvar quail-cxterm-package-ext-info
  82   '(("chinese-4corner" "\e$(0(?-F\e(B")
  83     ("chinese-array30" "\e$(0#R#O\e(B")
  84     ("chinese-ccdospy" "\e$AKuF4\e(B"
  85      "Pinyin base input method for Chinese charset GB2312 \(`chinese-gb2312').
  86
  87 Pinyin is the standard Roman transliteration method for Chinese.
  88 For the detail of Pinyin system, see the documentation of the input
  89 method `chinese-py'.
  90
  91 This input method works almost the same way as `chinese-py'.  The
  92 difference is that you type a single key for these Pinyin spelling.
  93     Pinyin:  zh  en  eng ang ch  an  ao  ai  ong sh  ing  yu(\e$A(9\e(B)
  94     keyseq:   a   f   g   h   i   j   k   l   s   u   y   v
  95 For example:
  96     Chinese:  \e$A0!\e(B    \e$A9{\e(B    \e$AVP\e(B    \e$AND\e(B    \e$A9b\e(B    \e$ASq\e(B    \e$AH+\e(B
  97     Pinyin:   a    guo   zhong  wen  guang  yu   quan
  98     Keyseq:   a1   guo4   as1   wf4  guh1  yu..6 qvj6
  99
 100 \\<quail-translation-docstring>
 101
 102 For double-width GB2312 characters correponding to ASCII, use the
 103 input method `chinese-qj'.")
 104
 105     ("chinese-ecdict" "\e$(05CKH\e(B"
 106 "In this input method, you enter a Chinese (Big5) charactere or word
 107 by typing the corresponding English word.  For example, if you type
 108 \"computer\", \"\e$(0IZH+\e(B\" is input.
 109
 110 \\<quail-translation-docstring>")
 111
 112     ("chinese-etzy" "\e$(06/0D\e(B"
 113 "Zhuyin base input method for Chinese Big5 characters (`chinese-big5-1',
 114 `chinese-big5-2').
 115
 116 Zhuyin is a kind of phonetic symbol.  One to three Zhuyin symbols
 117 compose one Chinese character.
 118
 119 In this input method, you enter a Chinese character by first typing
 120 keys corresponding to Zhuyin symbols (see the above table) followed by
 121 SPC, 1, 2, 3, or 4 specifing a tone (SPC:\e$(0?v(N\e(B, 1:\e$(0M=Vy\e(B, 2:\e$(0Dm(N\e(B, 3: \e$(0&9Vy\e(B,
 122 4:\e$(0(+Vy\e(B).
 123
 124 \\<quail-translation-docstring>")
 125
 126     ("chinese-punct-b5" "\e$(0O:\e(BB"
 127      "Input method for Chinese punctuations and symbols of Big5
 128 \(`chinese-big5-1' and `chinese-big5-2').")
 129
 130     ("chinese-punct" "\e$A1j\e(BG"
 131      "Input method for Chinese punctuations and symbols of GB2312
 132 \(`chinese-gb2312').")
 133
 134     ("chinese-py-b5" "\e$(03<\e(BB"
 135      "Pinyin base input method for Chinese Big5 characters
 136 \(`chinese-big5-1', `chinese-big5-2').
 137
 138 This input method works almost the same way as `chinese-py' (which
 139 see).
 140
 141 This input method supports only Han characters.  The more convenient
 142 method is `chinese-py-punct-b5', which is the combination of this
 143 method and `chinese-punct-b5' and which supports both Han characters
 144 and punctuation/symbols.
 145
 146 For double-width Big5 characters corresponding to ASCII, use the input
 147 method `chinese-qj-b5'.
 148
 149 The input method `chinese-py' and `chinese-tonepy' are also Pinyin
 150 based, but for the character set GB2312 (`chinese-gb2312').")
 151
 152     ("chinese-qj-b5" "\e$(0)A\e(BB")
 153
 154     ("chinese-qj" "\e$AH+\e(BG")
 155
 156     ("chinese-sw" "\e$AJWN2\e(B"
 157 "Radical base input method for Chinese charset GB2312 (`chinese-gb2312').
 158
 159 In this input method, you enter a Chinese character by typing two
 160 keys.  The first key corresponds to the first (\e$AJW\e(B) radical, the second
 161 key corresponds to the last (\e$AN2\e(B) radical.  The correspondence of keys
 162 and radicals is as below:
 163
 164  first radical:
 165  a  b  c  d  e  f  g  h  i  j  k  l  m  n  o  p  q  r  s  t  u  v  w  x  y  z
 166  \e$APD\e(B \e$AZ"\e(B \e$AJ,\e(B \e$AX<\e(B \e$A;p\e(B \e$A?Z\e(B \e$A^P\e(B \e$Ac_\e(B \e$AZ%\e(B \e$A\3\e(B \e$AXi\e(B \e$AD>\e(B \e$Alj\e(B \e$Ab;\e(B \e$ATB\e(B \e$Afy\e(B \e$AJ/\e(B \e$AMu\e(B \e$A0K\e(B \e$AX/\e(B \e$AHU\e(B \e$AeA\e(B \e$Aak\e(B \e$AVq\e(B \e$AR;\e(B \e$AHK\e(B
 167  last radical:
 168  a  b  c  d  e  f  g  h  i  j  k  l  m  n  o  p  q  r  s  t  u  v  w  x  y  z
 169  \e$ASV\e(B \e$AI=\e(B \e$AMA\e(B \e$A56\e(B \e$AZb\e(B \e$A?Z\e(B \e$ARB\e(B \e$Aqb\e(B \e$A4s\e(B \e$A6!\e(B \e$A[L\e(B \e$Ala\e(B \e$AJ.\e(B \e$A4u\e(B \e$AXg\e(B \e$ACE\e(B \e$A=q\e(B \e$AX-\e(B \e$AE.\e(B \e$ARR\e(B \e$A`m\e(B \e$AP!\e(B \e$A3'\e(B \e$A3f\e(B \e$A_.\e(B \e$A27\e(B
 170
 171 \\<quail-translation-docstring>")
 172
 173     ("chinese-tonepy" "\e$A5wF4\e(B"
 174      "Pinyin base input method for Chinese charset GB2312 (`chinese-gb2312').
 175
 176 Pinyin is the standard roman transliteration method for Chinese.
 177 For the details of Pinyin system, see the documentation of the input
 178 method `chinese-py'.
 179
 180 This input method works almost the same way as `chinese-py'.  The
 181 difference is that you must type 1..5 after each Pinyin spelling to
 182 specify a tone (1:\e$ARuF=\e(B, 2:\e$AQtF=\e(B, 3:\e$AIOIy\e(B, 4\e$AOBIy\e(B, 5:\e$AGaIy\e(B).
 183
 184 \\<quail-translation-docstring>
 185
 186 For instance, to input \e$ADc\e(B, you type \"n i 3 3\", the first \"n i\" is
 187 a Pinyin, the next \"3\" specifies tone, and the last \"3\" selects
 188 the third character from the candidate list.
 189
 190 For double-width GB2312 characters correponding to ASCII, use the
 191 input method `chinese-qj'.")
 192
 193     ("chinese-zozy" "\e$(0I\0D\e(B"
 194 "Zhuyin base input method for Chinese Big5 characters (`chinese-big5-1',
 195 `chinese-big5-2').
 196
 197 Zhuyin is a kind of a phonetic symbol.  One to three Zhuyin symbols
 198 compose a Chinese character.
 199
 200 In this input method, you enter a Chinese character by first typing
 201 keys corresponding to Zhuyin symbols (see the above table) followed by
 202 SPC, 6, 3, 4, or 7 specifing a tone (SPC:\e$(0?v(N\e(B, 6:\e$(0Dm(N\e(B, 3:\e$(0&9Vy\e(B, 4:\e$(0(+Vy\e(B,
 203 7:\e$(0M=Vy\e(B).
 204
 205 \\<quail-translation-docstring>")))
 206
 207 ;; Return a value of the key in the current line.
 208 (defsubst tit-read-key-value ()
 209   (if (looking-at "[^ \t\n]+")
 210       (car (read-from-string (concat "\"" (match-string 0) "\"")))))
 211
 212 ;; Return an appropriate quail-package filename from FILENAME (TIT
 213 ;; dictionary filename).  For instance, ".../ZOZY.tit" -> "ZOZY.el".
 214 (defun tit-make-quail-package-file-name (filename &optional dirname)
 215   (expand-file-name
 216    (concat (file-name-nondirectory (substring filename 0 -4)) ".el")
 217    dirname))
 218
 219 ;; This value is nil if we are processing phrase dictionary.
 220 (defvar tit-dictionary t)
 221 (defvar tit-encode nil)
 222 (defvar tit-default-encode "GB")
 223
 224 ;; Generate elements of KEY-BINDINGS arg for `quail-define-package' so
 225 ;; that each characters in KEYS invokes FUNCTION-SYMBOL.
 226 (defun tit-generate-key-bindings (keys function-symbol)
 227   (let ((len (length keys))
 228         (i 0)
 229         (first t)
 230         key)
 231     (while (< i len)
 232       (or first (princ "\n   "))
 233       (setq key (aref keys i))
 234       (if (if (< key ?\ )
 235               (eq (lookup-key quail-translation-keymap
 236                               (char-to-string key))
 237                   'quail-execute-non-quail-command)
 238             (<= key 127))
 239           (progn
 240             (princ (cons (cond ((< key ?\ ) (format "\"\\C-%c\"" (+ key ?@)))
 241                                ((< key 127) (format "\"%c\"" key))
 242                                (t "\"\\C-?\""))
 243                          function-symbol))
 244             (setq first nil)))
 245       (setq i (1+ i)))))
 246
 247 ;; Analyze header part of TIT dictionary and generate an appropriate
 248 ;; `quail-define-package' function call.
 249 (defun tit-process-header (filename)
 250   (message "Processing header part...")
 251   (goto-char (point-min))
 252
 253   ;; At first, generate header part of the Quail package while
 254   ;; collecting information from the original header.
 255   (let ((package (concat
 256                   "chinese-"
 257                   (substring (downcase (file-name-nondirectory filename))
 258                              0 -4)))
 259         ;; TIT keywords and the corresponding default values.
 260         (tit-multichoice t)
 261         (tit-prompt "")
 262         (tit-comments nil)
 263         (tit-backspace "\010\177")
 264         (tit-deleteall "\015\025")
 265         (tit-moveright ".>")
 266         (tit-moveleft ",<")
 267         (tit-keyprompt nil))
 268
 269     (princ ";; Quail package `")
 270     (princ package) (princ "' -*- coding:iso-2022-7bit; -*-\n")
 271     (princ ";;   Generated by the command `titdic-convert'\n;;\tDate: ")
 272     (princ (current-time-string))
 273     (princ "\n;;\tOriginal TIT dictionary file: ")
 274     (princ (file-name-nondirectory filename))
 275     (princ "\n\n;;; Comment:\n\n")
 276     (princ ";; Byte-compile this file again after any modification.\n\n")
 277     (princ ";;; Start of the header of original TIT dictionary.\n\n")
 278
 279     (while (not (eobp))
 280       (let ((ch (following-char))
 281             (pos (point)))
 282         (cond ((= ch ?C)                ; COMMENT
 283                (cond ((looking-at "COMMENT")
 284                       (let ((pos (match-end 0)))
 285                         (end-of-line)
 286                         (setq tit-comments (cons (buffer-substring pos (point))
 287                                                  tit-comments))))))
 288               ((= ch ?M)                ; MULTICHOICE, MOVERIGHT, MOVELEFT
 289                (cond ((looking-at "MULTICHOICE:[ \t]*")
 290                       (goto-char (match-end 0))
 291                       (setq tit-multichoice (looking-at "YES")))
 292                      ((looking-at "MOVERIGHT:[ \t]*")
 293                       (goto-char (match-end 0))
 294                       (setq tit-moveright (tit-read-key-value)))
 295                      ((looking-at "MOVELEFT:[ \t]*")
 296                       (goto-char (match-end 0))
 297                       (setq tit-moveleft (tit-read-key-value)))))
 298               ((= ch ?P)                ; PROMPT
 299                (cond ((looking-at "PROMPT:[ \t]*")
 300                       (goto-char (match-end 0))
 301                       (setq tit-prompt (tit-read-key-value))
 302                       ;; Some TIT dictionaies that are encoded by
 303                       ;; euc-china contains invalid character at the tail.
 304                       (let* ((last (aref tit-prompt (1- (length tit-prompt))))
 305                              (split (split-char last)))
 306                         (if (or (eq (nth 1 split) 32)
 307                                 (eq (nth 2 split) 32))
 308                             (setq tit-prompt (substring tit-prompt 0 -1)))))))
 309               ((= ch ?B)                ; BACKSPACE, BEGINDICTIONARY,
 310                                         ; BEGINPHRASE
 311                (cond ((looking-at "BACKSPACE:[ \t]*")
 312                       (goto-char (match-end 0))
 313                       (setq tit-backspace (tit-read-key-value)))
 314                      ((looking-at "BEGINDICTIONARY")
 315                       (setq tit-dictionary t))
 316                      ((looking-at "BEGINPHRASE")
 317                       (setq tit-dictionary nil))))
 318               ((= ch ?K)                ; KEYPROMPT
 319                (cond ((looking-at "KEYPROMPT(\\(.*\\)):[ \t]*")
 320                       (let ((key-char (match-string 1)))
 321                         (goto-char (match-end 0))
 322                         (if (string-match "\\\\[0-9]+" key-char)
 323                             (setq key-char
 324                                   (car (read-from-string (format "\"%s\""
 325                                                                  key-char)))))
 326                         (setq tit-keyprompt
 327                               (cons (cons key-char (tit-read-key-value))
 328                                     tit-keyprompt)))))))
 329         (end-of-line)
 330         (princ ";; ")
 331         (princ (buffer-substring pos (point)))
 332         (princ "\n")
 333         (forward-line 1)))
 334
 335     (princ "\n;;; End of the header of original TIT dictionary.\n\n")
 336     (princ ";;; Code:\n\n(require 'quail)\n\n")
 337
 338     (princ "(quail-define-package ")
 339     ;; Args NAME, LANGUAGE, TITLE
 340     (let ((title (nth 1 (assoc package quail-cxterm-package-ext-info))))
 341       (princ "\"")
 342       (princ package)
 343       (princ "\" \"")
 344       (princ (nth 2 (assoc tit-encode tit-encode-list)))
 345       (princ "\" \"")
 346       (princ (or title
 347                  (if (string-match "[:\e$A!K\e$(0!(!J\e(B]+\\([^:\e$A!K\e$(0!(!K\e(B]+\\)" tit-prompt)
 348                      (substring tit-prompt (match-beginning 1) (match-end 1))
 349                    tit-prompt)))
 350       (princ "\"\n"))
 351
 352     ;; Arg GUIDANCE
 353     (if tit-keyprompt
 354         (progn
 355           (princ " '(")
 356           (while tit-keyprompt
 357             (princ "   ")
 358             (princ (format "(%d . \"%s\")\n"
 359                            (string-to-char (car (car tit-keyprompt)))
 360                            (cdr (car tit-keyprompt))))
 361             (setq tit-keyprompt (cdr tit-keyprompt)))
 362           (princ ")"))
 363       (princ " t\n"))
 364
 365     ;; Arg DOCSTRING
 366     (let ((doc (concat tit-prompt "\n"))
 367           (comments (if tit-comments
 368                         (mapconcat 'identity (nreverse tit-comments) "\n")))
 369           (doc-ext (nth 2 (assoc package quail-cxterm-package-ext-info))))
 370       (if comments
 371           (setq doc (concat doc "\n" comments "\n")))
 372       (if doc-ext
 373           (setq doc (concat doc "\n" doc-ext "\n")))
 374       (prin1 doc)
 375       (terpri))
 376
 377     ;; Arg KEY-BINDINGS
 378     (princ " '(")
 379     (tit-generate-key-bindings tit-backspace 'quail-delete-last-char)
 380     (princ "\n   ")
 381     (tit-generate-key-bindings tit-deleteall 'quail-abort-translation)
 382     (princ "\n   ")
 383     (tit-generate-key-bindings tit-moveright 'quail-next-translation)
 384     (princ "\n   ")
 385     (tit-generate-key-bindings tit-moveleft 'quail-prev-translation)
 386     (princ ")\n")
 387
 388     ;; Args FORGET-TRANSLATION, DETERMINISTIC, KBD-TRANSLATE, SHOW-LAYOUT.
 389     ;; The remaining args are all nil.
 390     (princ " nil")
 391     (princ (if tit-multichoice " nil" " t"))
 392     (princ (if tit-keyprompt " t t)\n\n" " nil nil)\n\n"))))
 393
 394 (defsubst tit-flush-translations (key translations)
 395   (if (string-match "\\\\[0-9][0-9][0-9]" key)
 396       (let ((newkey (concat (substring key 0 (match-beginning 0))
 397                             (car (read-from-string
 398                                   (concat "\"" (match-string 0 key) "\"")))))
 399             (idx (match-end 0)))
 400         (while (string-match "\\\\[0-9][0-9][0-9]" key idx)
 401           (setq newkey (concat
 402                         newkey
 403                         (substring key idx (match-beginning 0))
 404                         (car (read-from-string
 405                               (concat "\"" (match-string 0 key) "\"")))))
 406           (setq idx (match-end 0)))
 407         (setq key (concat newkey (substring key idx)))))
 408   (prin1 (list key (if tit-dictionary translations
 409                      (vconcat (nreverse translations)))))
 410   (princ "\n"))
 411
 412 ;; Convert body part of TIT dictionary into `quail-define-rules'
 413 ;; function call.
 414 (defun tit-process-body ()
 415   (message "Formatting translation rules...")
 416   (let* ((template (list nil nil))
 417          (second (cdr template))
 418          (prev-key "")
 419          ch key translations pos)
 420     (princ "(quail-define-rules\n")
 421     (while (null (eobp))
 422       (setq ch (following-char))
 423       (if (or (= ch ?#) (= ch ?\n))
 424           (forward-line 1)
 425         (setq pos (point))
 426         (skip-chars-forward "^ \t\n")
 427         (setq key (buffer-substring pos (point)))
 428         (skip-chars-forward " \t")
 429         (setq ch (following-char))
 430         (if (or (= ch ?#) (= ch ?\n))
 431             ;; This entry contains no translations.  Let's ignore it.
 432             (forward-line 1)
 433           (or (string= key prev-key)
 434               (progn
 435                 (if translations
 436                     (tit-flush-translations prev-key translations))
 437                 (setq translations nil
 438                       prev-key key)))
 439           (if tit-dictionary
 440               (progn
 441                 (setq pos (point))
 442                 (skip-chars-forward "^ \t#\n")
 443                 (setq translations
 444                       (if translations
 445                           (concat translations
 446                                   (buffer-substring pos (point)))
 447                         (buffer-substring pos (point)))))
 448             (while (not (eolp))
 449               (setq pos (point))
 450               (skip-chars-forward "^ \t\n")
 451               (setq translations (cons (buffer-substring pos (point))
 452                                        translations))
 453               (skip-chars-forward " \t")
 454               (setq ch (following-char))
 455               (if (= ch ?#) (end-of-line))))
 456           (forward-line 1))))
 457
 458     (if translations
 459         (tit-flush-translations prev-key translations))
 460     (princ ")\n")))
 461
 462 ;;;###autoload
 463 (defun titdic-convert (filename &optional dirname)
 464   "Convert a TIT dictionary of FILENAME into a Quail package.
 465 Optional argument DIRNAME if specified is the directory name under which
 466 the generated Quail package is saved."
 467   (interactive "FTIT dictionary file: ")
 468   (let ((coding-system-for-write 'iso-2022-7bit))
 469     (with-temp-file  (tit-make-quail-package-file-name filename dirname)
 470       (set-buffer-file-coding-system 'iso-2022-7bit)
 471       (let ((standard-output (current-buffer)))
 472         (with-temp-buffer
 473           (set-buffer-multibyte nil)
 474           (let ((coding-system-for-read 'no-conversion))
 475             (insert-file-contents (expand-file-name filename)))
 476
 477           ;; Decode the buffer contents from the encoding specified by a
 478           ;; value of the key "ENCODE:".
 479           (if (not (search-forward "\nBEGIN" nil t))
 480               (error "TIT dictionary doesn't have body part"))
 481           (let ((limit (point))
 482                 coding-system slot)
 483             (goto-char (point-min))
 484             (if (re-search-forward "^ENCODE:[ \t]*" limit t)
 485                 (progn
 486                   (goto-char (match-end 0))
 487                   (setq tit-encode (tit-read-key-value)))
 488               (setq tit-encode tit-default-encode))
 489             (setq slot (assoc tit-encode tit-encode-list))
 490             (if (not slot)
 491                 (error "Invalid ENCODE: value in TIT dictionary"))
 492             (setq coding-system (nth 1 slot))
 493             (message "Decoding with coding system %s..." coding-system)
 494             (goto-char (point-min))
 495             (decode-coding-region (point-min) (point-max) coding-system))
 496
 497           ;; Set point the starting position of the body part.
 498           (goto-char (point-min))
 499           (if (not (search-forward "\nBEGIN" nil t))
 500               (error "TIT dictionary can't be decoded correctly"))
 501
 502           ;; Process the header part in multibyte mode.
 503           (with-current-buffer standard-output
 504             (set-buffer-multibyte t))
 505           (set-buffer-multibyte t)
 506           (forward-line 1)
 507           (narrow-to-region (point-min) (point))
 508           (tit-process-header filename)
 509           (widen)
 510
 511           ;; Process the body part.  For speed, we turn off multibyte facility.
 512           (with-current-buffer standard-output
 513             (set-buffer-multibyte nil))
 514           (set-buffer-multibyte nil)
 515           (tit-process-body))))))
 516
 517 ;;;###autoload
 518 (defun batch-titdic-convert (&optional force)
 519   "Run `titdic-convert' on the files remaining on the command line.
 520 Use this from the command line, with `-batch';
 521 it won't work in an interactive Emacs.
 522 For example, invoke \"emacs -batch -f batch-titdic-convert XXX.tit\" to
 523  generate Quail package file \"xxx.el\" from TIT dictionary file \"XXX.tit\".
 524 To get complete usage, invoke \"emacs -batch -f batch-titdic-convert -h\"."
 525   (defvar command-line-args-left)       ; Avoid compiler warning.
 526   (if (not noninteractive)
 527       (error "`batch-titdic-convert' should be used only with -batch"))
 528   (if (string= (car command-line-args-left) "-h")
 529       (progn
 530         (message "To convert XXX.tit and YYY.tit into xxx.el and yyy.el:")
 531         (message "  %% emacs -batch -l titdic-cnv -f batch-titdic-convert XXX.tit YYY.tit")
 532         (message "To convert XXX.tit into DIR/xxx.el:")
 533         (message "  %% emacs -batch -l titdic-cnv -f batch-titdic-convert -dir DIR XXX.tit"))
 534     (let (targetdir filename files file)
 535       (if (string= (car command-line-args-left) "-dir")
 536           (progn
 537             (setq command-line-args-left (cdr command-line-args-left))
 538             (setq targetdir (car command-line-args-left))
 539             (setq command-line-args-left (cdr command-line-args-left))))
 540       (while command-line-args-left
 541         (setq filename (expand-file-name (car command-line-args-left)))
 542         (if (file-directory-p filename)
 543             (progn
 544               (message "Converting all tit files in the directory %s" filename)
 545               (setq files (directory-files filename t "\\.tit$")))
 546           (setq files (list filename)))
 547         (while files
 548           (setq file (expand-file-name (car files)))
 549           (when (or force
 550                     (file-newer-than-file-p
 551                      file (tit-make-quail-package-file-name file targetdir)))
 552             (message "Converting %s to quail-package..." file)
 553             (titdic-convert file targetdir))
 554           (setq files (cdr files)))
 555         (setq command-line-args-left (cdr command-line-args-left)))
 556       (message "Byte-compile the created files by:")
 557       (message "  %% emacs -batch -f batch-byte-compile XXX.el")))
 558   (kill-emacs 0))
 559
 560 \f
 561 ;;; Converter of miscellaneous dictionaries other than TIT format.
 562
 563 ;; Alist of input method names and the corresponding information.
 564 ;; Each element has this form:
 565 ;;   (INPUT-METHOD-NAME         ;; Name of the input method.
 566 ;;    INPUT-METHOD-TITLE        ;; Title string of the input method
 567 ;;    DICFILE                   ;; Name of the source dictionary file.
 568 ;;    CODING                    ;; Coding system of the dictionary file.
 569 ;;    QUAILFILE                 ;; Name of the Quail package file.
 570 ;;    CONVERTER                 ;; Function to generate the Quail package.
 571 ;;    COPYRIGHT-NOTICE          ;; Copyright notice of the source dictionary.
 572 ;;    )
 573
 574 (defvar quail-misc-package-ext-info
 575   '(("chinese-b5-tsangchi" "\e$(06A\e(BB"
 576      "cangjie-table.b5" big5 "tsang-b5.el"
 577      tsang-b5-converter
 578      "\
 579 ;; # Copyright 2001 Christian Wittern <wittern@iis.sinica.edu.tw>
 580 ;; #
 581 ;; # Permission to copy and distribute both modified and
 582 ;; # unmodified versions is granted without royalty provided
 583 ;; # this notice is preserved.")
 584
 585     ("chinese-b5-quick" "\e$(0X|\e(BB"
 586      "cangjie-table.b5" big5 "quick-b5.el"
 587      quick-b5-converter
 588      "\
 589 ;; # Copyright 2001 Christian Wittern <wittern@iis.sinica.edu.tw>
 590 ;; #
 591 ;; # Permission to copy and distribute both modified and
 592 ;; # unmodified versions is granted without royalty provided
 593 ;; # this notice is preserved.")
 594
 595     ("chinese-cns-tsangchi" "\e$(GT?\e(BC"
 596      "cangjie-table.cns" iso-2022-cn-ext "tsang-cns.el"
 597      tsang-cns-converter
 598      "\
 599 ;; # Copyright 2001 Christian Wittern <wittern@iis.sinica.edu.tw>
 600 ;; #
 601 ;; # Permission to copy and distribute both modified and
 602 ;; # unmodified versions is granted without royalty provided
 603 ;; # this notice is preserved.")
 604
 605     ("chinese-cns-quick" "\e$(Gv|\e(BC"
 606      "cangjie-table.cns" iso-2022-cn-ext "quick-cns.el"
 607      quick-cns-converter
 608      "\
 609 ;; # Copyright 2001 Christian Wittern <wittern@iis.sinica.edu.tw>
 610 ;; #
 611 ;; # Permission to copy and distribute both modified and
 612 ;; # unmodified versions is granted without royalty provided
 613 ;; # this notice is preserved.")
 614
 615     ("chinese-py" "\e$AF4\e(BG"
 616      "pinyin.map" cn-gb-2312 "PY.el"
 617      py-converter
 618      "\
 619 ;; \"pinyin.map\" is included in a free package called CCE.  It is
 620 ;; available at:
 621 ;;      http://ftp.debian.org/debian/dists/potato/main
 622 ;;              /source/utils/cce_0.36.orig.tar.gz
 623 ;; This package contains the following copyright notice.
 624 ;;
 625 ;;
 626 ;;             Copyright (C) 1999, Rui He, herui@cs.duke.edu
 627 ;;
 628 ;;
 629 ;;                  CCE(Console Chinese Environment) 0.32
 630 ;;
 631 ;; CCE is free software; you can redistribute it and/or modify it under the
 632 ;; terms of the GNU General Public License as published by the Free Software
 633 ;; Foundation; either version 1, or (at your option) any later version.
 634 ;;
 635 ;; CCE is distributed in the hope that it will be useful, but WITHOUT ANY
 636 ;; WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 637 ;; FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 638 ;; details.
 639 ;;
 640 ;; You should have received a copy of the GNU General Public License along with
 641 ;; CCE; see the file COPYING.  If not, write to the Free Software Foundation,
 642 ;; 675 Mass Ave, Cambridge, MA 02139, USA.")
 643
 644     ("chinese-ziranma" "\e$AWTH;\e(B"
 645      "ziranma.cin" cn-gb-2312 "ZIRANMA.el"
 646      ziranma-converter
 647      "\
 648 ;; \"ziranma.cin\" is included in a free package called CCE.  It is
 649 ;; available at:
 650 ;;      http://ftp.debian.org/debian/dists/potato/main
 651 ;;              /source/utils/cce_0.36.orig.tar.gz
 652 ;; This package contains the following copyright notice.
 653 ;;
 654 ;;
 655 ;;             Copyright (C) 1999, Rui He, herui@cs.duke.edu
 656 ;;
 657 ;;
 658 ;;                  CCE(Console Chinese Environment) 0.32
 659 ;;
 660 ;; CCE is free software; you can redistribute it and/or modify it under the
 661 ;; terms of the GNU General Public License as published by the Free Software
 662 ;; Foundation; either version 1, or (at your option) any later version.
 663 ;;
 664 ;; CCE is distributed in the hope that it will be useful, but WITHOUT ANY
 665 ;; WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 666 ;; FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 667 ;; details.
 668 ;;
 669 ;; You should have received a copy of the GNU General Public License along with
 670 ;; CCE; see the file COPYING.  If not, write to the Free Software Foundation,
 671 ;; 675 Mass Ave, Cambridge, MA 02139, USA.")
 672
 673     ("chinese-ctlau" "\e$AAuTA\e(B"
 674      "CTLau.html" cn-gb-2312 "CTLau.el"
 675      ctlau-gb-converter
 676      "\
 677 ;; \"CTLau.html\" is available at:
 678 ;;
 679 ;;   http://umunhum.stanford.edu/~lee/chicomp/CTLau.html
 680 ;;
 681 ;; It contains the following copyright notice:
 682 ;;
 683 ;; # Copyright (C) 1988-2001  Fung Fung Lee (lee@umunhum.stanford.edu)
 684 ;; #
 685 ;; # This program is free software; you can redistribute it and/or
 686 ;; # modify it under the terms of the GNU General Public License
 687 ;; # as published by the Free Software Foundation; either version 2
 688 ;; # of the License, or any later version.
 689 ;; #
 690 ;; # This program is distributed in the hope that it will be useful,
 691 ;; # but WITHOUT ANY WARRANTY; without even the implied warranty of
 692 ;; # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 693 ;; # GNU General Public License for more details.
 694 ;; #
 695 ;; # You should have received a copy of the GNU General Public License
 696 ;; # along with this program; if not, write to the Free Software Foundation,
 697 ;; # Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.")
 698
 699     ("chinese-ctlaub" "\e$(0N,Gn\e(B"
 700      "CTLau-b5.html" big5 "CTLau-b5.el"
 701      ctlau-b5-converter
 702      "\
 703 ;; \"CTLau-b5.html\" is available at:
 704 ;;
 705 ;;   http://umunhum.stanford.edu/~lee/chicomp/CTLau-b5.html
 706 ;;
 707 ;; It contains the following copyright notice:
 708 ;;
 709 ;; # Copyright (C) 1988-2001  Fung Fung Lee (lee@umunhum.stanford.edu)
 710 ;; #
 711 ;; # This program is free software; you can redistribute it and/or
 712 ;; # modify it under the terms of the GNU General Public License
 713 ;; # as published by the Free Software Foundation; either version 2
 714 ;; # of the License, or any later version.
 715 ;; #
 716 ;; # This program is distributed in the hope that it will be useful,
 717 ;; # but WITHOUT ANY WARRANTY; without even the implied warranty of
 718 ;; # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 719 ;; # GNU General Public License for more details.
 720 ;; #
 721 ;; # You should have received a copy of the GNU General Public License
 722 ;; # along with this program; if not, write to the Free Software Foundation,
 723 ;; # Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.")
 724     ))
 725
 726 ;; Generate a code of a Quail package in the current buffer from Tsang
 727 ;; dictionary in the buffer DICBUF.  The input method name of the
 728 ;; Quail package is NAME, and the title string is TITLE.
 729
 730 ;; TSANG-P is non-nil, genereate \e$(06AQo\e(B input method.  Otherwise
 731 ;; generate \e$(0X|/y\e(B (simple version of \e$(06AQo\e(B).  If BIG5-P is non-nil, the
 732 ;; input method is for inputting Big5 characters.  Otherwise the input
 733 ;; method is for inputting CNS characters.
 734
 735 (defun tsang-quick-converter (dicbuf name title tsang-p big5-p)
 736   (let ((fulltitle (if tsang-p (if big5-p "\e$(06AQo\e(B" "\e$(GT?on\e(B")
 737                      (if big5-p "\e$(0X|/y\e(B" "\e$(Gv|Mx\e(B")))
 738         dic)
 739     (goto-char (point-max))
 740     (if big5-p
 741         (insert (format "\"\e$(0&d'GTT&,!J\e(B%s\e$(0!K\e(BBIG5
 742
 743         \e$(0KHM$\e(B%s\e$(0TT&,WoOu\e(B
 744
 745    [Q \e$(0'D\e(B] [W \e$(0(q\e(B] [E \e$(0'V\e(B] [R \e$(0&H\e(B] [T \e$(0'>\e(B] [Y \e$(0&4\e(B] [U \e$(0&U\e(B] [I \e$(0'B\e(B] [O \e$(0&*\e(B] [P \e$(0'A\e(B]
 746
 747     [A \e$(0'K\e(B] [S \e$(0&T\e(B] [D \e$(0'N\e(B] [F \e$(0'W\e(B] [G \e$(0&I\e(B] [H \e$(0*M\e(B] [J \e$(0&3\e(B] [L \e$(0&d\e(B]
 748
 749       [Z  ] [X \e$(0[E\e(B] [C \e$(01[\e(B] [V \e$(0&M\e(B] [B \e$(0'M\e(B] [N \e$(0&_\e(B] [M \e$(0&"\e(B]
 750
 751 \\\\<quail-translation-docstring>\"\n"
 752                         fulltitle fulltitle))
 753       (insert (format "\"\e$(GDcEFrSD+!J\e(B%s\e$(G!K\e(BCNS
 754
 755         \e$(GiGk#\e(B%s\e$(GrSD+uomu\e(B
 756
 757    [Q \e$(GEC\e(B] [W \e$(GFp\e(B] [E \e$(GEU\e(B] [R \e$(GDG\e(B] [T \e$(GE=\e(B] [Y \e$(GD3\e(B] [U \e$(GDT\e(B] [I \e$(GEA\e(B] [O \e$(GD)\e(B] [P \e$(GE@\e(B]
 758
 759     [A \e$(GEJ\e(B] [S \e$(GDS\e(B] [D \e$(GEM\e(B] [F \e$(GEV\e(B] [G \e$(GDH\e(B] [H \e$(GHL\e(B] [J \e$(GD2\e(B] [L \e$(GDc\e(B]
 760
 761       [Z  ] [X \e$(GyE\e(B] [C \e$(GOZ\e(B] [V \e$(GDL\e(B] [B \e$(GEL\e(B] [N \e$(GD^\e(B] [M \e$(GD!\e(B]
 762
 763 \\\\<quail-translation-docstring>\"\n"
 764                       fulltitle fulltitle)))
 765     (insert "  '((\".\" . quail-next-translation-block)
 766    (\",\" . quail-prev-translation-block))
 767   nil nil)\n\n")
 768     (insert "(quail-define-rules\n")
 769     (save-excursion
 770       (set-buffer dicbuf)
 771       (goto-char (point-min))
 772       (search-forward "A440")
 773       (beginning-of-line)
 774       (let ((table (make-hash-table :test 'equal))
 775             val)
 776         (while (not (eobp))
 777           (forward-char 5)
 778           (let ((trans (char-to-string (following-char)))
 779                 key slot)
 780             (re-search-forward "[A-Z]+$" nil t)
 781             (setq key (downcase
 782                        (if (or tsang-p
 783                                (<= (- (match-end 0) (match-beginning 0)) 1))
 784                            (match-string 0)
 785                          (string (char-after (match-beginning 0))
 786                                  (char-after (1- (match-end 0)))))))
 787             (setq val (gethash key table))
 788             (if val (setq trans (concat val trans)))
 789             (puthash key trans table)
 790             (forward-line 1)))
 791         (maphash #'(lambda (key val) (setq dic (cons (cons key val) dic)))
 792                  table)))
 793     (setq dic (sort dic (function (lambda (x y) (string< (car x ) (car y))))))
 794     (dolist (elt dic)
 795       (insert (format "(%S\t%S)\n" (car elt) (cdr elt))))
 796     (let ((punctuations '((";" "\e$(0!'!2!"!#!.!/\e(B" "\e$(G!'!2!"!#!.!/\e(B")
 797                           (":" "\e$(0!(!+!3!%!$!&!0!1\e(B" "\e$(G!(!+!3!%!$!&!0!1\e(B")
 798                           ("'" "\e$(0!e!d\e(B" "\e$(G!e!d\e(B")
 799                           ("\"" "\e$(0!g!f!h!i!q\e(B" "\e$(G!g!f!h!i!q\e(B")
 800                           ("\\" "\e$(0"`"b#M\e(B" "\e$(G"`"b#M\e(B")
 801                           ("|" "\e$(0!6!8!:"^\e(B" "\e$(G!6!8!:"^\e(B")
 802                           ("/" "\e$(0"_"a#L\e(B" "\e$(G"_"a#L\e(B")
 803                           ("?" "\e$(0!)!4\e(B" "\e$(G!)!4\e(B")
 804                           ("<" "\e$(0!R"6"A!T"H\e(B" "\e$(G!R"6"A!T"H\e(B")
 805                           (">" "\e$(0!S"7"B!U\e(B" "\e$(G!S"7"B!U\e(B")
 806                           ("[" "\e$(0!F!J!b!H!L!V!Z!X!\\e(B" "\e$(G!F!J!b!H!L!V!Z!X!\\e(B")
 807                           ("]" "\e$(0!G!K!c!I!M!W![!Y!]\e(B" "\e$(G!G!K!c!I!M!W![!Y!]\e(B")
 808                           ("{" "\e$(0!B!`!D\e(B " "\e$(G!B!`!D\e(B ")
 809                           ("}" "\e$(0!C!a!E\e(B" "\e$(G!C!a!E\e(B")
 810                           ("`" "\e$(0!j!k\e(B" "\e$(G!j!k\e(B")
 811                           ("~" "\e$(0"D"+",!<!=\e(B" "\e$(G"D"+",!<!=\e(B")
 812                           ("!" "\e$(0!*!5\e(B" "\e$(G!*!5\e(B")
 813                           ("@" "\e$(0"i"n\e(B" "\e$(G"i"n\e(B")
 814                           ("#" "\e$(0!l"-\e(B" "\e$(G!l"-\e(B")
 815                           ("$" "\e$(0"c"l\e(B" "\e$(G"c"l\e(B")
 816                           ("%" "\e$(0"h"m\e(B" "\e$(G"h"m\e(B")
 817                           ("&" "\e$(0!m".\e(B" "\e$(G!m".\e(B")
 818                           ("*" "\e$(0!n"/!o!w!x\e(B" "\e$(G!n"/!o!w!x\e(B")
 819                           ("(" "\e$(0!>!^!@\e(B" "\e$(G!>!^!@\e(B")
 820                           (")" "\e$(0!?!_!A\e(B" "\e$(G!?!_!A\e(B")
 821                           ("-" "\e$(0!7!9"#"$"1"@\e(B" "\e$(G!7!9"#"$"1"@\e(B")
 822                           ("_" "\e$(0"%"&\e(B" "\e$(G"%"&\e(B")
 823                           ("=" "\e$(0"8"C\e(B" "\e$(G"8"C\e(B")
 824                           ("+" "\e$(0"0"?\e(B" "\e$(G"0"?\e(B"))))
 825     (dolist (elt punctuations)
 826       (insert (format "(%S %S)\n" (concat "z" (car elt))
 827                       (if big5-p (nth 1 elt) (nth 2 elt))))))
 828     (insert ")\n")))
 829
 830 (defun tsang-b5-converter (dicbuf name title)
 831   (tsang-quick-converter dicbuf name title t t))
 832
 833 (defun quick-b5-converter (dicbuf name title)
 834   (tsang-quick-converter dicbuf name title nil t))
 835
 836 (defun tsang-cns-converter (dicbuf name title)
 837   (tsang-quick-converter dicbuf name title t nil))
 838
 839 (defun quick-cns-converter (dicbuf name title)
 840   (tsang-quick-converter dicbuf name title nil nil))
 841
 842 ;; Generate a code of a Quail package in the current buffer from
 843 ;; Pinyin dictionary in the buffer DICBUF.  The input method name of
 844 ;; the Quail package is NAME, and the title string is TITLE.
 845
 846 (defun py-converter (dicbuf name title)
 847   (goto-char (point-max))
 848   (insert (format "%S\n" "\e$A::WVJdHk!KF4Rt!K\e(B
 849
 850         \e$AF4Rt7=08\e(B
 851
 852  \e$AP!P4S"NDWVD84z1m!8F4Rt!97{:E#,\e(B \"u(yu) \e$ATrSC\e(B u: \e$A1mJ>!C\e(B
 853
 854 Pinyin base input method for Chinese charset GB2312 (`chinese-gb2312').
 855
 856 Pinyin is the standard roman transliteration method for Chinese.
 857 Pinyin uses a sequence of Latin alphabetic characters for each Chinese
 858 character.  The sequence is made by the combination of the initials
 859 \(the beginning sounds) and finals (the ending sounds).
 860
 861   initials: b p m f d t n l z c s zh ch sh r j q x g k h
 862   finals: a o e i er ai ei oa ou an en ang eng ong i ia iao ie iu ian in
 863           iang ing iong u ua uo uai ui uan un uan ueng yu yue yuan yun
 864
 865   (Note: In the correct Pinyin writing, the sequence \"yu\" in the last
 866    four finals should be written by the character u-umlaut `\e$A(9\e(B'.)
 867
 868 With this input method, you enter a Chinese character by first
 869 entering its pinyin spelling.
 870
 871 \\<quail-translation-docstring>
 872
 873 For instance, to input \e$ADc\e(B, you type \"n i C-n 3\".  The first \"n i\"
 874 is a Pinyin, \"C-n\" selects the next group of candidates (each group
 875 contains at most 10 characters), \"3\" select the third character in
 876 that group.
 877
 878 This input method supports only Han characters.  The related input
 879 method `chinese-py-punct' is the combination of this method and
 880 `chinese-punct'; it supports both Han characters and punctuation
 881 characters.
 882
 883 For double-width GB2312 characters corresponding to ASCII, use the
 884 input method `chinese-qj'.
 885
 886 The correct Pinyin system specifies tones by diacritical marks, but
 887 this input method doesn't use them, which results in easy (you don't
 888 have to know the exact tones), but verbose (many characters are assigned
 889 to the same key sequence) input.  You may also want to try the input
 890 method `chinese-tonepy' with which you must specify tones by digits
 891 \(1..5)."))
 892   (insert "  '((\"\C-?\" . quail-delete-last-char)
 893    (\".\" . quail-next-translation)
 894    (\">\" . quail-next-translation)
 895    (\",\" . quail-prev-translation)
 896    (\"<\" . quail-prev-translation))
 897   nil nil nil nil)\n\n")
 898   (insert "(quail-define-rules\n")
 899   (let ((pos (point)))
 900     (insert-buffer-substring dicbuf)
 901     (goto-char pos)
 902     (while (not (eobp))
 903       (insert "(\"")
 904       (skip-chars-forward "a-z")
 905       (insert "\" \"")
 906       (delete-char 1)
 907       (end-of-line)
 908       (insert "\")")
 909       (forward-line 1)))
 910   (insert ")\n"))
 911
 912 ;; Generate a code of a Quail package in the current buffer from
 913 ;; Ziranma dictionary in the buffer DICBUF.  The input method name of
 914 ;; the Quail package is NAME, and the title string is TITLE.
 915
 916 (defun ziranma-converter (dicbuf name title)
 917   (let (dic)
 918     (save-excursion
 919       (set-buffer dicbuf)
 920       (goto-char (point-min))
 921       (search-forward "%keyname end\n")
 922       (let ((table (make-hash-table :test 'equal))
 923             elt pos key trans val)
 924         (while (not (eobp))
 925           (setq pos (point))
 926           (skip-chars-forward "^ \t")
 927           (setq key (buffer-substring pos (point)))
 928           (skip-chars-forward " \t")
 929           (setq trans (vector (buffer-substring (point) (line-end-position))))
 930           (setq val (gethash key table))
 931           (if val (setq trans (vconcat val trans)))
 932           (puthash key trans table)
 933           (forward-line 1))
 934         (maphash #'(lambda (key trans)
 935                      (let ((len (length trans))
 936                            i)
 937                        (if (and (= len 1) (= (length (aref trans 0)) 1))
 938                            (setq trans (aref trans 0))
 939                          (setq i 0)
 940                          (while (and (< i len)
 941                                      (= (length (aref trans i)) 1))
 942                            (setq i (1+ i)))
 943                          (if (= i len)
 944                              (setq trans (mapconcat 'identity trans "")))))
 945                      (setq dic (cons (cons key trans) dic)))
 946                  table)))
 947     (setq dic (sort dic (function (lambda (x y) (string< (car x) (car y))))))
 948     (goto-char (point-max))
 949     (insert (format "%S\n" "\e$A::WVJdHk!K!>WTH;!?!K\e(B
 950
 951                             \e$A<|EL6TUU1m\e(B:
 952  \e$A)3)%)%)W)%)%)W)%)%)W)%)%)W)%)%)W)%)%)W)%)%)W)%)%)W)%)%)W)%)%)7\e(B
 953  \e$A)'#Q\e(B  \e$A)'#W\e(B  \e$A)'#E\e(B  \e$A)'#R\e(B  \e$A)'#T\e(B  \e$A)'#Y\e(B  \e$A)'#U\e(Bsh\e$A)'#I\e(Bch\e$A)'#O\e(B  \e$A)'#P\e(B  \e$A)'\e(B
 954  \e$A)'\e(B  iu\e$A)'\e(B  ua\e$A)'\e(B   e\e$A)'\e(B uan\e$A)'\e(B  ue\e$A)'\e(B uai\e$A)'\e(B   u\e$A)'\e(B   i\e$A)'\e(B   o\e$A)'\e(B  un\e$A)'\e(B
 955  \e$A)'\e(B    \e$A)'\e(B  ia\e$A)'\e(B    \e$A)'\e(B van\e$A)'\e(B  ve\e$A)'\e(B ing\e$A)'\e(B    \e$A)'\e(B    \e$A)'\e(B  uo\e$A)'\e(B  vn\e$A)'\e(B
 956  \e$A);)W)%)_)W)%)_)W)%)_)W)%)_)W)%)_)W)%)_)W)%)_)W)%)_)W)%)_)W)%)?\e(B
 957    \e$A)'#A\e(B  \e$A)'#S\e(B  \e$A)'#D\e(B  \e$A)'#F\e(B  \e$A)'#G\e(B  \e$A)'#H\e(B  \e$A)'#J\e(B  \e$A)'#K\e(B  \e$A)'#L\e(B  \e$A)'\e(B
 958    \e$A)'\e(B   a\e$A)'\e(Biong\e$A)'\e(Buang\e$A)'\e(B  en\e$A)'\e(B eng\e$A)'\e(B ang\e$A)'\e(B  an\e$A)'\e(B  ao\e$A)'\e(B  ai\e$A)'\e(B
 959    \e$A)'\e(B    \e$A)'\e(B ong\e$A)'\e(Biang\e$A)'\e(B    \e$A)'\e(B  ng\e$A)'\e(B    \e$A)'\e(B    \e$A)'\e(B    \e$A)'\e(B    \e$A)'\e(B
 960    \e$A);)W)%)_)W)%)_)W)%)_)W)%)_)W)%)_)W)%)_)W)%)_)W)%)_)W)%)_)W)%)%)7\e(B
 961      \e$A)'#Z\e(B  \e$A)'#X\e(B  \e$A)'#C\e(B  \e$A)'#V\e(Bzh\e$A)'#B\e(B  \e$A)'#N\e(B  \e$A)'#M\e(B  \e$A)'#,\e(B  \e$A)'#.\e(B  \e$A)'\e(B \e$A#/\e(B \e$A)'\e(B
 962      \e$A)'\e(B  ei\e$A)'\e(B  ie\e$A)'\e(B iao\e$A)'\e(B  ui\e$A)'\e(B  ou\e$A)'\e(B  in\e$A)'\e(B ian\e$A)'G0R3)':sR3)'7{:E)'\e(B
 963      \e$A)'\e(B    \e$A)'\e(B    \e$A)'\e(B    \e$A)'\e(B   v\e$A)'\e(B    \e$A)'\e(B    \e$A)'\e(B    \e$A)'\e(B    \e$A)'\e(B    \e$A)'\e(B    \e$A)'\e(B
 964      \e$A);)%)%)_)%)%)_)%)%)_)%)%)_)%)%)_)%)%)_)%)%)_)%)%)_)%)%)_)%)%)?\e(B
 965
 966
 967 Pinyin base input method for Chinese GB2312 characters (`chinese-gb2312').
 968
 969 Pinyin is the standard roman transliteration method for Chinese.
 970 For the details of Pinyin system, see the documentation of the input
 971 method `chinese-py'.
 972
 973 Unlike the standard spelling of Pinyin, in this input method all
 974 initials and finals are assigned to single keys (see the above table).
 975 For instance, the initial \"ch\" is assigned to the key `i', the final
 976 \"iu\" is assigned to the key `q', and tones 1, 2, 3, 4, and \e$AGaIy\e(B are
 977 assigned to the keys `q', `w', `e', `r', `t' respectively.
 978
 979 \\<quail-translation-docstring>
 980
 981 To input one-letter words, you type 4 keys, the first two for the
 982 Pinyin of the letter, next one for tone, and the last one is always a
 983 quote (').  For instance, \"vsq'\" input \e$AVP\e(B.  Exceptions are these
 984 letters.  You can input them just by typing a single key.
 985
 986         Character: \e$A04\e(B \e$A2;\e(B \e$A4N\e(B \e$A5D\e(B \e$A6~\e(B \e$A7"\e(B \e$A8v\e(B \e$A:M\e(B \e$A3v\e(B \e$A<0\e(B \e$A?I\e(B \e$AAK\e(B \e$AC;\e(B
 987         Key:       a  b  c  d  e  f  g  h  i  j  k  l  m
 988         Character: \e$ADc\e(B \e$AE7\e(B \e$AF,\e(B \e$AF_\e(B \e$AHK\e(B \e$AH}\e(B \e$AK{\e(B \e$AJG\e(B \e$AWE\e(B \e$ANR\e(B \e$AP!\e(B \e$AR;\e(B \e$ATZ\e(B
 989         Key:       n  o  p  q  r  s  t  u  v  w  x  y  z
 990
 991 To input two-letter words, you have two ways.  One way is to type 4
 992 keys, two for the first Pinyin, two for the second Pinyin.  For
 993 instance, \"vsgo\" inputs \e$AVP9z\e(B.  Another way is to type 3 keys: 2
 994 initials of two letters, and quote (').  For instance, \"vg'\" also
 995 inputs \e$AVP9z\e(B.
 996
 997 To input three-letter words, you type 4 keys: initials of three
 998 letters, and the last is quote (').  For instance, \"bjy'2\" inputs \e$A11\e(B
 999 \e$A>)Q<\e(B (the last `2' is to select one of the candidates).
1000
1001 To input words of more than three letters, you type 4 keys, initials
1002 of the first three letters and the last letter.  For instance,
1003 \"bjdt\" inputs \e$A11>)5gJSL(\e(B.
1004
1005 To input symbols and punctuations, type `/' followed by one of `a' to
1006 `z', then select one of the candidates."))
1007     (insert "  '((\"\C-?\" . quail-delete-last-char)
1008    (\".\" . quail-next-translation)
1009    (\"[\" . quail-next-translation)
1010    (\",\" . quail-prev-translation)
1011    (\"]\" . quail-prev-translation))
1012   nil nil nil nil)\n\n")
1013     (insert "(quail-define-rules\n")
1014     (dolist (elt dic)
1015       (insert (format "(%S %S)\n" (car elt) (cdr elt))))
1016     (insert ")\n")))
1017
1018 ;; Generate the code for a Quail package in the current buffer from a
1019 ;; CTLau or CTLau-b5 dictionary in the buffer DICBUF.  The input
1020 ;; method name of the Quail package is NAME, and the title string is
1021 ;; TITLE.  DESCRIPTION is the string shown by describe-input-method.
1022
1023 (defun ctlau-converter (dicbuf name title description)
1024   (goto-char (point-max))
1025   (insert (format "%S\n" description))
1026   (insert "  '((\"\C-?\" . quail-delete-last-char)
1027    (\".\" . quail-next-translation)
1028    (\">\" . quail-next-translation)
1029    (\",\" . quail-prev-translation)
1030    (\"<\" . quail-prev-translation))
1031   nil nil nil nil)\n\n")
1032   (insert "(quail-define-rules\n")
1033   (let (dicbuf-start dicbuf-end key-start key (pos (point)))
1034     ;; Find the dictionary, which starts below a horizontal rule and
1035     ;; ends at the second to last line in the HTML file.
1036     (save-excursion
1037       (set-buffer dicbuf)
1038       (goto-char (point-min))
1039       (search-forward "#\n#<hr>\n")
1040       (setq dicbuf-start (point))
1041       (goto-char (point-max))
1042       (forward-line -1)
1043       (setq dicbuf-end (point)))
1044     (insert-buffer-substring dicbuf dicbuf-start dicbuf-end)
1045     ;; CTLau-b5.html contains characters (0xa1 0xbc) which show up as
1046     ;; hollow boxes when the original characters in CTLau.html from
1047     ;; which the file is converted have no Big5 equivalent.  Go
1048     ;; through and delete them.
1049     (goto-char pos)
1050     (while (search-forward "\e$(0!{\e(B" nil t)
1051       (delete-char -1))
1052     ;; Uppercase keys in dictionary need to be downcased.  Backslashes
1053     ;; at the beginning of keys need to be turned into double
1054     ;; backslashes.
1055     (goto-char pos)
1056     (while (not (eobp))
1057       (insert "(\"")
1058       (if (char-equal (following-char) ?\\)
1059           (insert "\\"))
1060       (setq key-start (point))
1061       (skip-chars-forward "\\\\A-Z")
1062       (downcase-region key-start (point))
1063       (insert "\" \"")
1064       (delete-char 1)
1065       (end-of-line)
1066       (insert "\")")
1067       (forward-line 1)))
1068   (insert ")\n"))
1069
1070 (defun ctlau-gb-converter (dicbuf name title)
1071   (ctlau-converter dicbuf name title
1072 "\e$A::WVJdHk!KAuN}OiJ=TARt!K\e(B
1073
1074  \e$AAuN}OiJ=TASoW"Rt7=08\e(B
1075  Sidney Lau's Cantonese transcription scheme as described in his book
1076  \"Elementary Cantonese\", The Government Printer, Hong Kong, 1972.
1077  This file was prepared by Fung Fung Lee (\e$A@n7c7e\e(B).
1078  Originally converted from CTCPS3.tit
1079  Last modified: June 2, 1993.
1080
1081  Some infrequent GB characters are accessed by typing \\, followed by
1082  the Cantonese romanization of the respective radical (\e$A2?JW\e(B)."))
1083
1084 (defun ctlau-b5-converter (dicbuf name title)
1085   (ctlau-converter dicbuf name title
1086 "\e$(0KH)tTT&,!(N,Tg>A*#Gn5x!(\e(B
1087
1088  \e$(0N,Tg>A*#GnM$0D5x'J7{\e(B
1089  Sidney Lau's Cantonese transcription scheme as described in his book
1090  \"Elementary Cantonese\", The Government Printer, Hong Kong, 1972.
1091  This file was prepared by Fung Fung Lee (\e$(0,XFS76\e(B).
1092  Originally converted from CTCPS3.tit
1093  Last modified: June 2, 1993.
1094
1095  Some infrequent characters are accessed by typing \\, followed by
1096  the Cantonese romanization of the respective radical (\e$(0?f5}\e(B)."))
1097
1098 (defun miscdic-convert (filename &optional dirname)
1099   "Convert a dictionary file FILENAME into a Quail package.
1100 Optional argument DIRNAME if specified is the directory name under which
1101 the generated Quail package is saved."
1102   (interactive "FInput method dictionary file: ")
1103   (or (file-readable-p filename)
1104       (error "%s does not exist" filename))
1105   (let ((tail quail-misc-package-ext-info)
1106         (default-buffer-file-coding-system 'iso-2022-7bit)
1107         slot
1108         name title dicfile coding quailfile converter copyright
1109         dicbuf)
1110     (while tail
1111       (when (or (string-match (nth 2 (car tail)) filename)
1112                 ;; MS-DOS filesystem truncates file names to 8+3
1113                 ;; limits, so "cangjie-table.cns" becomes
1114                 ;; "cangjie-.cns", and the above string-match fails.
1115                 ;; Give DOS users a chance...
1116                 (and (fboundp 'msdos-long-file-names)
1117                      (not (msdos-long-file-names))
1118                      (string-match (dos-8+3-filename (nth 2 (car tail)))
1119                                    filename)))
1120         (setq slot (car tail)
1121               name (car slot)
1122               title (nth 1 slot)
1123               dicfile (nth 2 slot)
1124               coding (nth 3 slot)
1125               quailfile (nth 4 slot)
1126               converter (nth 5 slot)
1127               copyright (nth 6 slot))
1128         (message "Converting %s to %s..." dicfile quailfile)
1129         (with-temp-file (expand-file-name quailfile dirname)
1130           (set-buffer-file-coding-system 'iso-2022-7bit)
1131           (insert ";; Quail package `" name "' -*- coding:iso-2022-7bit; -*-\n")
1132           (insert ";;   Generated by the command `miscdic-convert'\n")
1133           (insert ";;   Date: " (current-time-string) "\n")
1134           (insert ";;   Source dictionary file: " dicfile "\n")
1135           (insert ";;   Copyright notice of the source file\n")
1136           (insert ";;------------------------------------------------------\n")
1137           (insert copyright "\n")
1138           (insert ";;------------------------------------------------------\n")
1139           (insert "\n")
1140           (insert ";;; Code:\n\n")
1141           (insert "(require 'quail)\n")
1142           (insert "(quail-define-package \"" name "\" \""
1143                   (if (eq coding 'big5) "Chinese-BIG5" "Chinese-CNS")
1144                   "\" \"" title "\" t\n")
1145           (let* ((coding-system-for-read coding)
1146                  (dicbuf (find-file-noselect filename)))
1147             (funcall converter dicbuf name title)
1148             (kill-buffer dicbuf)))
1149         (message "Converting %s to %s...done" dicfile quailfile))
1150       (setq tail (cdr tail)))))
1151
1152 (defun batch-miscdic-convert ()
1153   "Run `miscdic-convert' on the files remaing on the command line.
1154 Use this from the command line, with `-batch';
1155 it won't work in an interactive Emacs.
1156 If there's an argument \"-dir\", the next argument specifies a directory
1157 to store generated Quail packages."
1158   (defvar command-line-args-left)       ; Avoid compiler warning.
1159   (if (not noninteractive)
1160       (error "`batch-miscdic-convert' should be used only with -batch"))
1161   (let ((dir default-directory)
1162         filename)
1163     (while command-line-args-left
1164       (if (string= (car command-line-args-left) "-dir")
1165           (progn
1166             (setq command-line-args-left (cdr command-line-args-left))
1167             (setq dir (car command-line-args-left))
1168             (setq command-line-args-left (cdr command-line-args-left))))
1169       (setq filename (car command-line-args-left)
1170             command-line-args-left (cdr command-line-args-left))
1171       (if (file-directory-p filename)
1172           (dolist (file (directory-files filename t nil t))
1173             (miscdic-convert file dir))
1174         (miscdic-convert filename dir))))
1175   (kill-emacs 0))
1176
1177 ;; Local Variables:
1178 ;; coding: iso-2022-7bit
1179 ;; End:
1180
1181 ;;; arch-tag: 8ad478b2-a985-4da2-b47f-d8ee5d7c24a3
1182 ;;; titdic-cnv.el ends here