code.delx.au - gnu-emacs/blob - lisp/international/kkc.el

   1 ;;; kkc.el --- Kana Kanji converter
   2
   3 ;; Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
   4 ;; Licensed to the Free Software Foundation.
   5
   6 ;; Keywords: mule, multilingual, Japanese, SKK
   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 ;; These routines provide a simple and easy-to-use converter from
  28 ;; Kana-string to Kana-Kanji-mixed-string.  This converter (here after
  29 ;; KKC) uses a SKK dictionary to get information how to convert
  30 ;; Kana-string.  Since KKC can't be fully automated, we need an
  31 ;; interaction with a user to decide the correct conversion.   For
  32 ;; that, we provide KKC major mode.
  33
  34 ;;; Code:
  35
  36 (require 'skkdic-utl)
  37
  38 (defvar kkc-input-method-title "\e$B4A\e(B"
  39   "String denoting KKC input method.
  40 This string is shown at mode line when users are in KKC mode.")
  41
  42 (defvar kkc-init-file-name "~/.kkcrc"
  43   "Name of a file which contains user's initial setup code for KKC.")
  44
  45 ;; A flag to control a file specified by `kkc-init-file-name'.
  46 ;; The value nil means the file is not yet consulted.
  47 ;; The value t means the file has already been consulted but there's
  48 ;; no need of updating it yet.
  49 ;; Any other value means that we must update the file before exiting Emacs.
  50 (defvar kkc-init-file-flag nil)
  51
  52 ;; Cash data for `kkc-lookup-key'.  This may be initialized by loading
  53 ;; a file specified by `kkc-init-file-name'.  If any elements are
  54 ;; modified, the data is written out to the file when exiting Emacs.
  55 (defvar kkc-lookup-cache '(kkc-lookup-cache))
  56
  57 (defun kkc-save-init-file ()
  58   "Save initial setup code for KKC to a file specified by `kkc-init-file-name'"
  59   (if (and kkc-init-file-flag
  60            (not (eq kkc-init-file-flag t)))
  61       (let ((coding-system-for-write 'iso-2022-7bit))
  62         (write-region (format "(setq kkc-lookup-cache '%S)\n" kkc-lookup-cache)
  63                       nil
  64                       kkc-init-file-name))))
  65
  66 ;; Sequence of characters to be used for indexes for shown list.  The
  67 ;; Nth character is for the Nth conversion in the list currently shown.
  68 (defvar kkc-show-conversion-list-index-chars
  69   "1234567890abcdefghijklmnopqrsuvwxyz")
  70
  71 (defvar kkc-mode-map
  72   (let ((map (make-keymap))
  73         (i 0))
  74     (while (< i ? )
  75       (define-key map (char-to-string i) 'undefined)
  76       (setq i (1+ i)))
  77     (while (< i 128)
  78       (define-key map (char-to-string i) 'kkc-non-kkc-command)
  79       (setq i (1+ i)))
  80     (setq i 0)
  81     (let ((len (length kkc-show-conversion-list-index-chars)))
  82       (while (< i len)
  83         (define-key map
  84           (char-to-string (aref kkc-show-conversion-list-index-chars i))
  85           'kkc-select-from-list)
  86         (setq i (1+ i))))
  87     (define-key map " " 'kkc-next)
  88     (define-key map (char-to-string help-char) 'help-command)
  89     (define-key map "\r" 'kkc-terminate)
  90     (define-key map "\C-@" 'kkc-first-char-only)
  91     (define-key map "\C-n" 'kkc-next)
  92     (define-key map "\C-p" 'kkc-prev)
  93     (define-key map "\C-i" 'kkc-shorter)
  94     (define-key map "\C-o" 'kkc-longer)
  95     (define-key map "\C-c" 'kkc-cancel)
  96     (define-key map "\C-?" 'kkc-cancel)
  97     (define-key map "\C-f" 'kkc-next-phrase)
  98     (define-key map "K" 'kkc-katakana)
  99     (define-key map "H" 'kkc-hiragana)
 100     (define-key map "l" 'kkc-show-conversion-list-or-next-group)
 101     (define-key map "L" 'kkc-show-conversion-list-or-prev-group)
 102     (define-key map [?\C-\ ] 'kkc-first-char-only)
 103     (define-key map [delete] 'kkc-cancel)
 104     (define-key map [return] 'kkc-terminate)
 105     (append map '((t . kkc-non-kkc-command))))
 106   "Keymap for KKC (Kana Kanji Conversion) mode.")
 107
 108 (defun kkc-mode ()
 109   "Major mode for converting Kana string to Kanji-Kana mixed string.
 110 Commands:
 111 \\{kkc-mode-map}"
 112   (setq major-mode 'kkc-mode)
 113   (setq mode-name "KKC")
 114   (use-local-map kkc-mode-map)
 115   (run-hooks 'kkc-mode-hook))
 116
 117 ;;; Internal variables used in KKC.
 118
 119 ;; The current Kana string to be converted.
 120 (defvar kkc-original-kana nil)
 121
 122 ;; The current key sequence (vector of Kana characters) generated from
 123 ;; `kkc-original-kana'.
 124 (defvar kkc-current-key nil)
 125
 126 ;; List of the current conversions for `kkc-current-key'.
 127 (defvar kkc-current-conversions nil)
 128
 129 ;; Vector of the same length as `kkc-current-conversion'.  The first
 130 ;; element is a vector of:
 131 ;;      o index number of the first conversion shown previously,
 132 ;;      o index number of a conversion next of the last one shown previously,
 133 ;;      o the shown string itself.
 134 ;; The remaining elements are widths (including columns for index
 135 ;; numbers) of conversions stored in the same order as in
 136 ;; `kkc-current-conversion'.
 137 (defvar kkc-current-conversions-width nil)
 138
 139 (defvar kkc-show-conversion-list-count 4
 140   "Count of successive `kkc-next' or `kkc-prev' to show conversion list.")
 141
 142 ;; Provided that `kkc-current-key' is [A B C D E F G H I], the current
 143 ;; conversion target is [A B C D E F], the sequence of which
 144 ;; conversion is found is [A B C D]:
 145 ;;
 146 ;;                                A B C D E F G H I
 147 ;; kkc-overlay-head (black):     |<--------->|
 148 ;; kkc-overlay-tail (underline):         |<------->|
 149 ;; kkc-length-head:              |<--------->|
 150 ;; kkc-length-converted:         |<----->|
 151 ;;
 152 (defvar kkc-overlay-head nil)
 153 (defvar kkc-overlay-tail nil)
 154 (defvar kkc-length-head nil)
 155 (defvar kkc-length-converted nil)
 156
 157 ;; Cursor type (`box' or `bar') of the current frame.
 158 (defvar kkc-cursor-type nil)
 159
 160 ;; Flag to tell if the current conversion is canceled.  If non-nil,
 161 ;; the value is a buffer position of the head of currently active
 162 ;; conversion region.
 163 (defvar kkc-canceled nil)
 164
 165 ;; Lookup SKK dictionary to set list of conversions in
 166 ;; kkc-current-conversions for key sequence kkc-current-key of length
 167 ;; LEN.  If no conversion is found in the dictionary, don't change
 168 ;; kkc-current-conversions and return nil.
 169 ;; Postfixes are handled only if POSTFIX is non-nil.
 170 (defun kkc-lookup-key (len &optional postfix prefer-noun)
 171   ;; At first, prepare cache data if any.
 172   (if (not kkc-init-file-flag)
 173       (progn
 174         (setq kkc-init-file-flag t)
 175         (add-hook 'kill-emacs-hook 'kkc-save-init-file)
 176         (if (file-readable-p kkc-init-file-name)
 177             (condition-case nil
 178                 (load-file "~/.kkcrc")
 179               (error (message "Invalid data in %s" kkc-init-file-name)
 180                      (ding))))))
 181   (let ((entry (lookup-nested-alist kkc-current-key kkc-lookup-cache len 0 t)))
 182     (if (consp (car entry))
 183         (setq kkc-length-converted len
 184               kkc-current-conversions-width nil
 185               kkc-current-conversions (car entry))
 186       (setq entry (skkdic-lookup-key kkc-current-key len postfix prefer-noun))
 187       (if entry
 188           (progn
 189             (setq kkc-length-converted len
 190                   kkc-current-conversions-width nil
 191                   kkc-current-conversions (cons 1 entry))
 192             (if postfix
 193                 ;; Store this conversions in the cache.
 194                 (progn
 195                   (set-nested-alist kkc-current-key kkc-current-conversions
 196                                     kkc-lookup-cache kkc-length-converted)
 197                   (setq kkc-init-file-flag 'kkc-lookup-cache)))
 198             t)
 199         (if (= len 1)
 200             (setq kkc-length-converted 1
 201                   kkc-current-conversions-width nil
 202                   kkc-current-conversions (cons 0 nil)))))))
 203
 204 ;;;###autoload
 205 (defun kkc-region (from to)
 206   "Convert Kana string in the current region to Kanji-Kana mixed string.
 207 After one candidate of conversion is shown in the region, users are
 208 put in KKC major mode to select a desirable conversion."
 209   (interactive "r")
 210   (setq kkc-original-kana (buffer-substring from to))
 211   (goto-char from)
 212
 213   ;; Setup overlays.
 214   (if (overlayp kkc-overlay-head)
 215       (move-overlay kkc-overlay-head from to)
 216     (setq kkc-overlay-head (make-overlay from to nil nil t))
 217     (overlay-put kkc-overlay-head 'face 'highlight))
 218   (if (overlayp kkc-overlay-tail)
 219       (move-overlay kkc-overlay-tail to to)
 220     (setq kkc-overlay-tail (make-overlay to to nil nil t))
 221     (overlay-put kkc-overlay-tail 'face 'underline))
 222
 223   ;; After updating the conversion region with the first candidate of
 224   ;; conversion, jump into a recursive editing environment with KKC
 225   ;; mode.
 226   (let ((overriding-local-map nil)
 227         (previous-local-map (current-local-map))
 228         (minor-mode-alist nil)
 229         (minor-mode-map-alist nil)
 230         (current-input-method-title kkc-input-method-title)
 231         major-mode mode-name)
 232     (unwind-protect
 233         (let (len)
 234           (setq kkc-canceled nil)
 235           (setq kkc-current-key (string-to-vector kkc-original-kana))
 236           (setq kkc-length-head (length kkc-current-key))
 237           (setq len kkc-length-head)
 238           (setq kkc-length-converted 0)
 239           (while (not (kkc-lookup-key kkc-length-head nil
 240                                       (< kkc-length-head len)))
 241             (setq kkc-length-head (1- kkc-length-head)))
 242           (goto-char to)
 243           (kkc-update-conversion 'all)
 244           (kkc-mode)
 245           (recursive-edit))
 246       (goto-char (overlay-end kkc-overlay-tail))
 247       (delete-overlay kkc-overlay-head)
 248       (delete-overlay kkc-overlay-tail)
 249       (use-local-map previous-local-map)))
 250   kkc-canceled)
 251
 252 (defun kkc-terminate ()
 253   "Exit from KKC mode by fixing the current conversion."
 254   (interactive)
 255   (throw 'exit nil))
 256
 257 (defun kkc-non-kkc-command ()
 258   "Exit from KKC mode by fixing the current conversion.
 259 After that, handle the event which invoked this command."
 260   (interactive)
 261   (setq unread-command-events (list last-input-event))
 262   (kkc-terminate))
 263
 264 (defun kkc-cancel ()
 265   "Exit from KKC mode by canceling any conversions."
 266   (interactive)
 267   (setq kkc-canceled (overlay-start kkc-overlay-head))
 268   (goto-char kkc-canceled)
 269   (delete-region (overlay-start kkc-overlay-head)
 270                  (overlay-end kkc-overlay-tail))
 271   (insert kkc-original-kana)
 272   (kkc-terminate))
 273
 274 (defun kkc-first-char-only ()
 275   "Select only the first character currently converted."
 276   (interactive)
 277   (goto-char (overlay-start kkc-overlay-head))
 278   (forward-char 1)
 279   (delete-region (point) (overlay-end kkc-overlay-tail))
 280   (kkc-terminate))
 281
 282 ;; Count of successive invocations of `kkc-next'.
 283 (defvar kkc-next-count nil)
 284
 285 (defun kkc-next ()
 286   "Select the next candidate of conversion."
 287   (interactive)
 288   (if (eq this-command last-command)
 289       (setq kkc-next-count (1+ kkc-next-count))
 290     (setq kkc-next-count 1))
 291   (let ((idx (1+ (car kkc-current-conversions))))
 292     (if (< idx 0)
 293         (setq idx 1))
 294     (if (>= idx (length kkc-current-conversions))
 295         (setq idx 0))
 296     (setcar kkc-current-conversions idx)
 297     (if (> idx 1)
 298         (progn
 299           (set-nested-alist kkc-current-key kkc-current-conversions
 300                             kkc-lookup-cache kkc-length-converted)
 301           (setq kkc-init-file-flag 'kkc-lookup-cache)))
 302     (if (or kkc-current-conversions-width
 303             (>= kkc-next-count kkc-show-conversion-list-count))
 304         (kkc-show-conversion-list-update))
 305     (kkc-update-conversion)))
 306
 307 ;; Count of successive invocations of `kkc-next'.
 308 (defvar kkc-prev-count nil)
 309
 310 (defun kkc-prev ()
 311   "Select the previous candidate of conversion."
 312   (interactive)
 313   (if (eq this-command last-command)
 314       (setq kkc-prev-count (1+ kkc-prev-count))
 315     (setq kkc-prev-count 1))
 316   (let ((idx (1- (car kkc-current-conversions))))
 317     (if (< idx 0)
 318         (setq idx (1- (length kkc-current-conversions))))
 319     (setcar kkc-current-conversions idx)
 320     (if (> idx 1)
 321         (progn
 322           (set-nested-alist kkc-current-key kkc-current-conversions
 323                             kkc-lookup-cache kkc-length-converted)
 324           (setq kkc-init-file-flag 'kkc-lookup-cache)))
 325     (if (or kkc-current-conversions-width
 326             (>= kkc-prev-count kkc-show-conversion-list-count))
 327         (kkc-show-conversion-list-update))
 328     (kkc-update-conversion)))
 329
 330 (defun kkc-select-from-list ()
 331   "Select one candidate from the list currently shown in echo area."
 332   (interactive)
 333   (let (idx)
 334     (if kkc-current-conversions-width
 335         (let ((len (length kkc-show-conversion-list-index-chars))
 336               (maxlen (- (aref (aref kkc-current-conversions-width 0) 1)
 337                          (aref (aref kkc-current-conversions-width 0) 0)))
 338               (i 0))
 339           (if (> len maxlen)
 340               (setq len maxlen))
 341           (while (< i len)
 342             (if (= (aref kkc-show-conversion-list-index-chars i)
 343                    last-input-char)
 344                 (setq idx i i len)
 345               (setq i (1+ i))))))
 346     (if idx
 347         (progn
 348           (setcar kkc-current-conversions
 349                   (+ (aref (aref kkc-current-conversions-width 0) 0) idx))
 350           (kkc-show-conversion-list-update)
 351           (kkc-update-conversion))
 352       (setq unread-command-events (list last-input-event))
 353       (kkc-terminate))))
 354
 355 (defun kkc-katakana ()
 356   "Convert to Katakana."
 357   (interactive)
 358   (setcar kkc-current-conversions -1)
 359   (kkc-update-conversion 'all))
 360
 361 (defun kkc-hiragana ()
 362   "Convert to hiragana."
 363   (interactive)
 364   (setcar kkc-current-conversions 0)
 365   (kkc-update-conversion))
 366
 367 (defun kkc-shorter ()
 368   "Make the Kana string to be converted shorter."
 369   (interactive)
 370   (if (<= kkc-length-head 1)
 371       (error "Can't be shorter")
 372     (setq kkc-length-head (1- kkc-length-head))
 373     (if (> kkc-length-converted kkc-length-head)
 374         (let ((len kkc-length-head))
 375           (setq kkc-length-converted 0)
 376           (while (not (kkc-lookup-key len))
 377             (setq len (1- len)))))
 378     (kkc-update-conversion 'all)))
 379
 380 (defun kkc-longer ()
 381   "Make the Kana string to be converted longer."
 382   (interactive)
 383   (if (>= kkc-length-head (length kkc-current-key))
 384       (error "Can't be longer")
 385     (setq kkc-length-head (1+ kkc-length-head))
 386     ;; This time, try also entries with postfixes.
 387     (kkc-lookup-key kkc-length-head 'postfix)
 388     (kkc-update-conversion 'all)))
 389
 390 (defun kkc-next-phrase ()
 391   "Fix the currently converted string and try to convert the remaining string."
 392   (interactive)
 393   (if (>= kkc-length-head (length kkc-current-key))
 394       (kkc-terminate)
 395     (setq kkc-length-head (- (length kkc-current-key) kkc-length-head))
 396     (goto-char (overlay-end kkc-overlay-head))
 397     (while (and (< (point) (overlay-end kkc-overlay-tail))
 398                 (looking-at "\\CH"))
 399       (goto-char (match-end 0))
 400       (setq kkc-length-head (1- kkc-length-head)))
 401     (if (= kkc-length-head 0)
 402         (kkc-terminate)
 403       (let ((newkey (make-vector kkc-length-head 0))
 404             (idx (- (length kkc-current-key) kkc-length-head))
 405             (len kkc-length-head)
 406             (i 0))
 407         ;; For the moment, (setq kkc-original-kana (concat newkey))
 408         ;; doesn't work.
 409         (setq kkc-original-kana "")
 410         (while (< i kkc-length-head)
 411           (aset newkey i (aref kkc-current-key (+ idx i)))
 412           (setq kkc-original-kana
 413                 (concat kkc-original-kana (char-to-string (aref newkey i))))
 414           (setq i (1+ i)))
 415         (setq kkc-current-key newkey)
 416         (setq kkc-length-converted 0)
 417         (while (and (not (kkc-lookup-key kkc-length-head nil
 418                                          (< kkc-length-head len)))
 419                     (> kkc-length-head 1))
 420           (setq kkc-length-head (1- kkc-length-head)))
 421         (let ((pos (point))
 422               (tail (overlay-end kkc-overlay-tail)))
 423           (move-overlay kkc-overlay-head pos tail)
 424           (move-overlay kkc-overlay-tail tail tail))
 425         (kkc-update-conversion 'all)))))
 426
 427 ;; We'll show users a list of available conversions in echo area with
 428 ;; index numbers so that users can select one conversion with the
 429 ;; number.
 430
 431 ;; Set `kkc-current-conversions-width'.
 432 (defun kkc-setup-current-conversions-width ()
 433   (let ((convs (cdr kkc-current-conversions))
 434         (len (length kkc-current-conversions))
 435         (idx 1))
 436     (setq kkc-current-conversions-width (make-vector len nil))
 437     ;; To tell `kkc-show-conversion-list-update' to generate
 438     ;; message from scratch.
 439     (aset kkc-current-conversions-width 0 (vector len -2 nil))
 440     ;; Fill the remaining slots.
 441     (while convs
 442       (aset kkc-current-conversions-width idx
 443             (+ (string-width (car convs)) 4))
 444       (setq convs (cdr convs)
 445             idx (1+ idx)))))
 446
 447 (defun kkc-show-conversion-list-or-next-group ()
 448   "Show list of available conversions in echo area with index numbers.
 449 If the list is already shown, show the next group of conversions,
 450 and change the current conversion to the first one in the group."
 451   (interactive)
 452   (if (< (length kkc-current-conversions) 3)
 453       (error "No alternative"))
 454   (if kkc-current-conversions-width
 455       (let ((next-idx (aref (aref kkc-current-conversions-width 0) 1)))
 456         (if (< next-idx (length kkc-current-conversions-width))
 457             (setcar kkc-current-conversions next-idx)
 458           (setcar kkc-current-conversions 1))
 459         (kkc-show-conversion-list-update)
 460         (kkc-update-conversion))
 461     (kkc-setup-current-conversions-width)
 462     (kkc-show-conversion-list-update)))
 463
 464 (defun kkc-show-conversion-list-or-prev-group ()
 465   "Show list of available conversions in echo area with index numbers.
 466 If the list is already shown, show the previous group of conversions,
 467 and change the current conversion to the last one in the group."
 468   (interactive)
 469   (if (< (length kkc-current-conversions) 3)
 470       (error "No alternative"))
 471   (if kkc-current-conversions-width
 472       (let ((this-idx (aref (aref kkc-current-conversions-width 0) 0)))
 473         (if (> this-idx 1)
 474             (setcar kkc-current-conversions (1- this-idx))
 475           (setcar kkc-current-conversions
 476                   (1- (length kkc-current-conversions-width))))
 477         (kkc-show-conversion-list-update)
 478         (kkc-update-conversion))
 479     (kkc-setup-current-conversions-width)
 480     (kkc-show-conversion-list-update)))
 481
 482 ;; Update the conversion list shown in echo area.
 483 (defun kkc-show-conversion-list-update ()
 484   (or kkc-current-conversions-width
 485       (kkc-setup-current-conversions-width))
 486   (let* ((current-idx (car kkc-current-conversions))
 487          (first-slot (aref kkc-current-conversions-width 0))
 488          (this-idx (aref first-slot 0))
 489          (next-idx (aref first-slot 1))
 490          (msg (aref first-slot 2)))
 491     (if (< current-idx this-idx)
 492         ;; The currently selected conversion is before the list shown
 493         ;; previously.  We must start calculation of message width
 494         ;; from the start again.
 495         (setq this-idx 1 msg nil)
 496       (if (>= current-idx next-idx)
 497           ;; The currently selected conversion is after the list shown
 498           ;; previously.  We start calculation of message width from
 499           ;; the conversion next of TO.
 500           (setq this-idx next-idx msg nil)
 501         ;; The current conversion is in MSG.  Just clear brackets
 502         ;; around index number.
 503         (if (string-match "<.>" msg)
 504             (progn
 505               (aset msg (match-beginning 0) ?\ )
 506               (aset msg (1- (match-end 0)) ?\ )))))
 507     (if (not msg)
 508         (let ((len (length kkc-current-conversions))
 509               (max-width (window-width (minibuffer-window)))
 510               (width-table kkc-current-conversions-width)
 511               (width 0)
 512               (idx this-idx)
 513               l)
 514           (while (< idx current-idx)
 515             (if (<= (+ width (aref width-table idx)) max-width)
 516                 (setq width (+ width (aref width-table idx)))
 517               (setq this-idx idx width (aref width-table idx)))
 518             (setq idx (1+ idx)
 519                   l (cdr l)))
 520           (aset first-slot 0 this-idx)
 521           (while (and (< idx len)
 522                       (<= (+ width (aref width-table idx)) max-width))
 523             (setq width (+ width (aref width-table idx))
 524                   idx (1+ idx)
 525                   l (cdr l)))
 526           (aset first-slot 1 (setq next-idx idx))
 527           (setq l (nthcdr this-idx kkc-current-conversions))
 528           (setq msg "")
 529           (setq idx this-idx)
 530           (while (< idx next-idx)
 531             (setq msg (format "%s %c %s "
 532                               msg
 533                               (aref kkc-show-conversion-list-index-chars
 534                                     (- idx this-idx))
 535                               (car l)))
 536             (setq idx (1+ idx)
 537                   l (cdr l)))
 538           (aset first-slot 2 msg)))
 539     (if (> current-idx 0)
 540         (progn
 541           ;; Highlight the current conversion by brackets.
 542           (string-match (format " \\(%c\\) "
 543                                 (aref kkc-show-conversion-list-index-chars
 544                                       (- current-idx this-idx)))
 545                         msg)
 546           (aset msg (match-beginning 0) ?<)
 547           (aset msg (1- (match-end 0)) ?>)))
 548     (message "%s" msg)))
 549
 550 ;; Update the conversion area with the latest conversion selected.
 551 ;; ALL if non nil means to update the whole area, else update only
 552 ;; inside quail-overlay-head.
 553
 554 (defun kkc-update-conversion (&optional all)
 555   (goto-char (overlay-start kkc-overlay-head))
 556   (cond ((= (car kkc-current-conversions) 0) ; Hiragana
 557          (let ((i 0))
 558            (while (< i kkc-length-converted)
 559              (insert (aref kkc-current-key i))
 560              (setq i (1+ i)))))
 561         ((= (car kkc-current-conversions) -1) ; Katakana
 562          (let ((i 0))
 563            (while (< i kkc-length-converted)
 564              (insert (japanese-katakana (aref kkc-current-key i)))
 565              (setq i (1+ i)))))
 566         (t
 567          (insert (nth (car kkc-current-conversions) kkc-current-conversions))))
 568   (delete-region (point) (overlay-start kkc-overlay-tail))
 569   (if all
 570       (let ((len (length kkc-current-key))
 571             (i kkc-length-converted))
 572         (delete-region (overlay-start kkc-overlay-tail)
 573                        (overlay-end kkc-overlay-head))
 574         (while (< i kkc-length-head)
 575           (if (= (car kkc-current-conversions) -1)
 576               (insert (japanese-katakana (aref kkc-current-key i)))
 577             (insert (aref kkc-current-key i)))
 578           (setq i (1+ i)))
 579         (let ((pos (point)))
 580           (while (< i len)
 581             (insert (aref kkc-current-key i))
 582             (setq i (1+ i)))
 583           (move-overlay kkc-overlay-head
 584                         (overlay-start kkc-overlay-head) pos)
 585           (delete-region (point) (overlay-end kkc-overlay-tail)))))
 586   (goto-char (overlay-end kkc-overlay-tail)))
 587
 588 ;;
 589 (provide 'kkc)
 590
 591 ;; kkc.el ends here