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