lisp/mule/mule-cmds.el

   1 ;;; mule-cmds.el --- Commands for multilingual environment
   2
   3 ;; Copyright (C) 1995,1999 Electrotechnical Laboratory, JAPAN.
   4 ;; Licensed to the Free Software Foundation.
   5 ;; Copyright (C) 1997 MORIOKA Tomohiko
   6
   7 ;; Keywords: mule, multilingual
   8
   9 ;; This file is part of XEmacs.
  10
  11 ;; XEmacs is free software; you can redistribute it and/or modify it
  12 ;; under the terms of the GNU General Public License as published by
  13 ;; the Free Software Foundation; either version 2, or (at your option)
  14 ;; any later version.
  15
  16 ;; XEmacs is distributed in the hope that it will be useful, but
  17 ;; WITHOUT ANY WARRANTY; without even the implied warranty of
  18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19 ;; General Public License for more details.
  20
  21 ;; You should have received a copy of the GNU General Public License
  22 ;; along with XEmacs; see the file COPYING.  If not, write to the Free
  23 ;; Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  24 ;; 02111-1307, USA.
  25
  26 ;; Note: Some of the code here is now in code-cmds.el
  27
  28 ;;; Code:
  29
  30 ;;; MULE related key bindings and menus.
  31
  32 (require 'code-cmds)
  33
  34 ;; Preserve the old name
  35 (defvaralias 'mule-keymap 'coding-keymap)
  36
  37 (define-key mule-keymap "x" 'set-selection-coding-system)
  38 (define-key mule-keymap "X" 'set-next-selection-coding-system)
  39 (define-key mule-keymap "\C-\\" 'set-input-method)
  40 ;;(define-key mule-keymap "c" 'list-coding-system-briefly) ; XEmacs
  41 (define-key mule-keymap "C" 'describe-coding-system)     ; XEmacs
  42 (define-key mule-keymap "r" 'toggle-display-direction)   ; XEmacs
  43 (define-key mule-keymap "l" 'set-language-environment)
  44
  45 (define-key help-map "L" 'describe-language-environment)
  46 (define-key help-map "\C-\\" 'describe-input-method)
  47 (define-key help-map "I" 'describe-input-method)
  48 (define-key help-map "h" 'view-hello-file)
  49
  50 ;; Menu for XEmacs were moved to menubar-items.el.
  51
  52
  53 ;; This should be a single character key binding because users use it
  54 ;; very frequently while editing multilingual text.  Now we can use
  55 ;; only two such keys: "\C-\\" and "\C-^", but the latter is not
  56 ;; convenient because it requires shifting on most keyboards.  An
  57 ;; alternative is "\C-\]" which is now bound to `abort-recursive-edit'
  58 ;; but it won't be used that frequently.
  59 (define-key global-map "\C-\\" 'toggle-input-method)
  60
  61 ;;; This is no good because people often type Shift-SPC
  62 ;;; meaning to type SPC.  -- rms.
  63 ;;; ;; Here's an alternative key binding for X users (Shift-SPACE).
  64 ;;; (define-key global-map [?\S- ] 'toggle-input-method)
  65
  66 (defun coding-system-change-eol-conversion (coding-system eol-type)
  67   "Return a coding system which differs from CODING-SYSTEM in eol conversion.
  68 The returned coding system converts end-of-line by EOL-TYPE
  69 but text as the same way as CODING-SYSTEM.
  70 EOL-TYPE should be `lf', `crlf', `cr' or nil.
  71 If EOL-TYPE is nil, the returned coding system detects
  72 how end-of-line is formatted automatically while decoding.
  73
  74 EOL-TYPE can be specified by an symbol `unix', `dos' or `mac'.
  75 They means `lf', `crlf', and `cr' respectively."
  76   (if (symbolp eol-type)
  77       (setq eol-type (cond ((or (eq eol-type 'unix)
  78                                 (eq eol-type 'lf))
  79                             'eol-lf)
  80                            ((or (eq eol-type 'dos)
  81                                 (eq eol-type 'crlf))
  82                             'eol-crlf)
  83                            ((or (eq eol-type 'mac)
  84                                 (eq eol-type 'cr))
  85                             'eol-cr)
  86                            (t eol-type))))
  87   (let ((orig-eol-type (coding-system-eol-type coding-system)))
  88     (if (null orig-eol-type)
  89         (if (not eol-type)
  90             coding-system
  91           (coding-system-property coding-system eol-type))
  92       (let ((base (coding-system-base coding-system)))
  93         (if (not eol-type)
  94             base
  95           (if (eq eol-type orig-eol-type)
  96               coding-system
  97             (setq orig-eol-type (coding-system-eol-type base))
  98             (if (null orig-eol-type)
  99                 (coding-system-property base eol-type))))))))
 100
 101 ;; (defun coding-system-change-text-conversion (coding-system coding)
 102 ;;   "Return a coding system which differs from CODING-SYSTEM in text conversion.
 103 ;; The returned coding system converts text by CODING
 104 ;; but end-of-line as the same way as CODING-SYSTEM.
 105 ;; If CODING is nil, the returned coding system detects
 106 ;; how text is formatted automatically while decoding."
 107 ;;   (if (not coding)
 108 ;;       (coding-system-base coding-system)
 109 ;;     (let ((eol-type (coding-system-eol-type coding-system)))
 110 ;;       (coding-system-change-eol-conversion
 111 ;;        coding
 112 ;;        (if (numberp eol-type) (aref [unix dos mac] eol-type))))))
 113
 114 (defun view-hello-file ()
 115   "Display the HELLO file which list up many languages and characters."
 116   (interactive)
 117   ;; We have to decode the file in any environment.
 118   (let ((coding-system-for-read 'iso-2022-7bit))
 119     (find-file-read-only (expand-file-name "HELLO" data-directory))))
 120
 121 \f
 122 ;;; Language support stuff.
 123
 124 (defvar language-info-alist nil
 125   "Alist of language environment definitions.
 126 Each element looks like:
 127         (LANGUAGE-NAME . ((KEY . INFO) ...))
 128 where LANGUAGE-NAME is a string, the name of the language environment,
 129 KEY is a symbol denoting the kind of information, and
 130 INFO is the data associated with KEY.
 131 Meaningful values for KEY include
 132
 133   documentation      value is documentation of what this language environment
 134                         is meant for, and how to use it.
 135   charset            value is a list of the character sets used by this
 136                         language environment.
 137   sample-text        value is one line of text,
 138                         written using those character sets,
 139                         appropriate for this language environment.
 140   setup-function     value is a function to call to switch to this
 141                         language environment.
 142   exit-function      value is a function to call to leave this
 143                         language environment.
 144   coding-system      value is a list of coding systems that are good
 145                         for saving text written in this language environment.
 146                         This list serves as suggestions to the user;
 147                         in effect, as a kind of documentation.
 148   coding-priority    value is a list of coding systems for this language
 149                         environment, in order of decreasing priority.
 150                         This is used to set up the coding system priority
 151                         list when you switch to this language environment.
 152   input-method       value is a default input method for this language
 153                         environment.
 154   features           value is a list of features requested in this
 155                         language environment.
 156   tutorial           value is a tutorial file name written in the language.")
 157
 158 (defun get-language-info (lang-env key)
 159   "Return information listed under KEY for language environment LANG-ENV.
 160 KEY is a symbol denoting the kind of information.
 161 For a list of useful values for KEY and their meanings,
 162 see `language-info-alist'."
 163   (if (symbolp lang-env)
 164       (setq lang-env (symbol-name lang-env)))
 165   (let ((lang-slot (assoc-ignore-case lang-env language-info-alist)))
 166     (if lang-slot
 167         (cdr (assq key (cdr lang-slot))))))
 168
 169 (defun set-language-info (lang-env key info)
 170   "Modify part of the definition of language environment LANG-ENV.
 171 Specifically, this stores the information INFO under KEY
 172 in the definition of this language environment.
 173 KEY is a symbol denoting the kind of information.
 174 INFO is the value for that information.
 175
 176 For a list of useful values for KEY and their meanings,
 177 see `language-info-alist'."
 178   (if (symbolp lang-env)
 179       (setq lang-env (symbol-name lang-env)))
 180   (let (lang-slot key-slot)
 181     (setq lang-slot (assoc lang-env language-info-alist))
 182     (if (null lang-slot)                ; If no slot for the language, add it.
 183         (setq lang-slot (list lang-env)
 184               language-info-alist (cons lang-slot language-info-alist)))
 185     (setq key-slot (assq key lang-slot))
 186     (if (null key-slot)                 ; If no slot for the key, add it.
 187         (progn
 188           (setq key-slot (list key))
 189           (setcdr lang-slot (cons key-slot (cdr lang-slot)))))
 190     (setcdr key-slot info)))
 191
 192 (defun set-language-info-alist (lang-env alist &optional parents)
 193   "Store ALIST as the definition of language environment LANG-ENV.
 194 ALIST is an alist of KEY and INFO values.  See the documentation of
 195 `set-language-info' for the meanings of KEY and INFO."
 196   (if (symbolp lang-env)
 197       (setq lang-env (symbol-name lang-env)))
 198   (let (; (describe-map describe-language-environment-map)
 199         ; (setup-map setup-language-environment-map)
 200         )
 201     ;; (if parents
 202     ;;     (let ((l parents)
 203     ;;           map parent-symbol parent)
 204     ;;       (while l
 205     ;;         (if (symbolp (setq parent-symbol (car l)))
 206     ;;             (setq parent (symbol-name parent))
 207     ;;           (setq parent parent-symbol parent-symbol (intern parent)))
 208     ;;         (setq map (lookup-key describe-map (vector parent-symbol)))
 209     ;;         (if (not map)
 210     ;;             (progn
 211     ;;               (setq map (intern (format "describe-%s-environment-map"
 212     ;;                                         (downcase parent))))
 213     ;;               (define-prefix-command map)
 214     ;;               (define-key-after describe-map (vector parent-symbol)
 215     ;;                 (cons parent map) t)))
 216     ;;         (setq describe-map (symbol-value map))
 217     ;;         (setq map (lookup-key setup-map (vector parent-symbol)))
 218     ;;         (if (not map)
 219     ;;             (progn
 220     ;;               (setq map (intern (format "setup-%s-environment-map"
 221     ;;                                         (downcase parent))))
 222     ;;               (define-prefix-command map)
 223     ;;               (define-key-after setup-map (vector parent-symbol)
 224     ;;                 (cons parent map) t)))
 225     ;;         (setq setup-map (symbol-value map))
 226     ;;         (setq l (cdr l)))))
 227
 228     ;; Set up menu items for this language env.
 229     (let ((doc (assq 'documentation alist)))
 230       (when doc
 231         ;; (define-key-after describe-map (vector (intern lang-env))
 232         ;;   (cons lang-env 'describe-specified-language-support) t)
 233         (when (featurep 'menubar)
 234           (eval-after-load
 235               "menubar-items.elc"
 236             `(add-menu-button
 237               '("%_Edit" "%_Multilingual (\"Mule\")"
 238                 "%_Describe Language Support")
 239               (vector ,lang-env
 240                       '(describe-language-environment ,lang-env)
 241                       t))))
 242         ))
 243     ;; (define-key-after setup-map (vector (intern lang-env))
 244     ;;   (cons lang-env 'setup-specified-language-environment) t)
 245     (when (featurep 'menubar)
 246       (eval-after-load
 247           "menubar-items.elc"
 248         `(add-menu-button
 249           '("%_Edit" "%_Multilingual (\"Mule\")"
 250             "%_Set Language Environment")
 251           (vector ,lang-env
 252                   '(set-language-environment ,lang-env)
 253                   t))))
 254
 255     (while alist
 256       (set-language-info lang-env (car (car alist)) (cdr (car alist)))
 257       (setq alist (cdr alist)))))
 258
 259 (defun read-language-name (key prompt &optional default)
 260   "Read a language environment name which has information for KEY.
 261 If KEY is nil, read any language environment.
 262 Prompt with PROMPT.  DEFAULT is the default choice of language environment.
 263 This returns a language environment name as a string."
 264   (let* ((completion-ignore-case t)
 265          (name (completing-read prompt
 266                                 language-info-alist
 267                                 (and key
 268                                      (function (lambda (elm) (assq key elm))))
 269                                 t nil nil default)))
 270     (if (and (> (length name) 0)
 271              (or (not key)
 272                  (get-language-info name key)))
 273         name)))
 274 \f
 275 ;;; Multilingual input methods.
 276
 277 (defconst leim-list-file-name "leim-list.el"
 278   "Name of LEIM list file.
 279 This file contains a list of libraries of Emacs input methods (LEIM)
 280 in the format of Lisp expression for registering each input method.
 281 Emacs loads this file at startup time.")
 282
 283 (defvar leim-list-header (format
 284 ";;; %s -- list of LEIM (Library of Emacs Input Method)
 285 ;;
 286 ;; This file contains a list of LEIM (Library of Emacs Input Method)
 287 ;; in the same directory as this file.  Loading this file registers
 288 ;; the whole input methods in Emacs.
 289 ;;
 290 ;; Each entry has the form:
 291 ;;   (register-input-method
 292 ;;    INPUT-METHOD LANGUAGE-NAME ACTIVATE-FUNC
 293 ;;    TITLE DESCRIPTION
 294 ;;    ARG ...)
 295 ;; See the function `register-input-method' for the meanings of arguments.
 296 ;;
 297 ;; If this directory is included in load-path, Emacs automatically
 298 ;; loads this file at startup time.
 299
 300 "
 301                                  leim-list-file-name)
 302   "Header to be inserted in LEIM list file.")
 303
 304 (defvar leim-list-entry-regexp "^(register-input-method"
 305   "Regexp matching head of each entry in LEIM list file.
 306 See also the variable `leim-list-header'")
 307
 308 (defvar update-leim-list-functions
 309   '(quail-update-leim-list-file)
 310   "List of functions to call to update LEIM list file.
 311 Each function is called with one arg, LEIM directory name.")
 312
 313 (defun update-leim-list-file (&rest dirs)
 314   "Update LEIM list file in directories DIRS."
 315   (let ((functions update-leim-list-functions))
 316     (while functions
 317       (apply (car functions) dirs)
 318       (setq functions (cdr functions)))))
 319
 320 (defvar current-input-method nil
 321   "The current input method for multilingual text.
 322 If nil, that means no input method is activated now.")
 323 (make-variable-buffer-local 'current-input-method)
 324 (put 'current-input-method 'permanent-local t)
 325
 326 (defvar current-input-method-title nil
 327   "Title string of the current input method shown in mode line.")
 328 (make-variable-buffer-local 'current-input-method-title)
 329 (put 'current-input-method-title 'permanent-local t)
 330
 331 (defcustom default-input-method nil
 332   "*Default input method for multilingual text (a string).
 333 This is the input method activated automatically by the command
 334 `toggle-input-method' (\\[toggle-input-method])."
 335   :group 'mule
 336   :type '(choice (const nil) string))
 337
 338 (put 'input-method-function 'permanent-local t)
 339
 340 (defvar input-method-history nil
 341   "History list for some commands that read input methods.")
 342 (make-variable-buffer-local 'input-method-history)
 343 (put 'input-method-history 'permanent-local t)
 344
 345 (defvar inactivate-current-input-method-function nil
 346   "Function to call for inactivating the current input method.
 347 Every input method should set this to an appropriate value when activated.
 348 This function is called with no argument.
 349
 350 This function should never change the value of `current-input-method'.
 351 It is set to nil by the function `inactivate-input-method'.")
 352 (make-variable-buffer-local 'inactivate-current-input-method-function)
 353 (put 'inactivate-current-input-method-function 'permanent-local t)
 354
 355 (defvar describe-current-input-method-function nil
 356   "Function to call for describing the current input method.
 357 This function is called with no argument.")
 358 (make-variable-buffer-local 'describe-current-input-method-function)
 359 (put 'describe-current-input-method-function 'permanent-local t)
 360
 361 (defvar input-method-alist nil
 362   "Alist of input method names vs how to use them.
 363 Each element has the form:
 364    (INPUT-METHOD LANGUAGE-ENV ACTIVATE-FUNC TITLE DESCRIPTION ARGS...)
 365 See the function `register-input-method' for the meanings of the elements.")
 366
 367 (defun register-input-method (input-method lang-env &rest args)
 368   "Register INPUT-METHOD as an input method for language environment ENV.
 369 INPUT-METHOD and LANG-ENV are symbols or strings.
 370
 371 The remaining arguments are:
 372         ACTIVATE-FUNC, TITLE, DESCRIPTION, and ARGS...
 373 ACTIVATE-FUNC is a function to call to activate this method.
 374 TITLE is a string to show in the mode line when this method is active.
 375 DESCRIPTION is a string describing this method and what it is good for.
 376 The ARGS, if any, are passed as arguments to ACTIVATE-FUNC.
 377 All told, the arguments to ACTIVATE-FUNC are INPUT-METHOD and the ARGS.
 378
 379 This function is mainly used in the file \"leim-list.el\" which is
 380 created at building time of emacs, registering all quail input methods
 381 contained in the emacs distribution.
 382
 383 In case you want to register a new quail input method by yourself, be
 384 careful to use the same input method title as given in the third
 385 parameter of `quail-define-package' (if the values are different, the
 386 string specified in this function takes precedence).
 387
 388 The commands `describe-input-method' and `list-input-methods' need
 389 this duplicated values to show some information about input methods
 390 without loading the affected quail packages."
 391   (if (symbolp lang-env)
 392       (setq lang-env (symbol-name lang-env)))
 393   (if (symbolp input-method)
 394       (setq input-method (symbol-name input-method)))
 395   (let ((info (cons lang-env args))
 396         (slot (assoc input-method input-method-alist)))
 397     (if slot
 398         (setcdr slot info)
 399       (setq slot (cons input-method info))
 400       (setq input-method-alist (cons slot input-method-alist)))))
 401
 402 (defun read-input-method-name (prompt &optional default inhibit-null)
 403   "Read a name of input method from a minibuffer prompting with PROMPT.
 404 If DEFAULT is non-nil, use that as the default,
 405   and substitute it into PROMPT at the first `%s'.
 406 If INHIBIT-NULL is non-nil, null input signals an error.
 407
 408 The return value is a string."
 409   (if default
 410       (setq prompt (format prompt default)))
 411   (let* ((completion-ignore-case t)
 412          ;; This binding is necessary because input-method-history is
 413          ;; buffer local.
 414          (input-method (completing-read prompt input-method-alist
 415                                         nil t nil 'input-method-history
 416                                         default)))
 417     (if (and input-method (symbolp input-method))
 418         (setq input-method (symbol-name input-method)))
 419     (if (> (length input-method) 0)
 420         input-method
 421       (if inhibit-null
 422           (error "No valid input method is specified")))))
 423
 424 (defun activate-input-method (input-method)
 425   "Switch to input method INPUT-METHOD for the current buffer.
 426 If some other input method is already active, turn it off first.
 427 If INPUT-METHOD is nil, deactivate any current input method."
 428   (if (and input-method (symbolp input-method))
 429       (setq input-method (symbol-name input-method)))
 430   (if (and current-input-method
 431            (not (string= current-input-method input-method)))
 432       (inactivate-input-method))
 433   (unless (or current-input-method (null input-method))
 434     (let ((slot (assoc input-method input-method-alist)))
 435       (if (null slot)
 436           (error "Can't activate input method `%s'" input-method))
 437       (let ((func (nth 2 slot)))
 438         (if (functionp func)
 439             (apply (nth 2 slot) input-method (nthcdr 5 slot))
 440           (if (and (consp func) (symbolp (car func)) (symbolp (cdr func)))
 441               (progn
 442                 (require (cdr func))
 443                 (apply (car func) input-method (nthcdr 5 slot)))
 444             (error "Can't activate input method `%s'" input-method))))
 445       (setq current-input-method input-method)
 446       (setq current-input-method-title (nth 3 slot))
 447       (unwind-protect
 448           (run-hooks 'input-method-activate-hook)
 449         (force-mode-line-update)))))
 450
 451 (defun inactivate-input-method ()
 452   "Turn off the current input method."
 453   (when current-input-method
 454     (if input-method-history
 455         (unless (string= current-input-method (car input-method-history))
 456           (setq input-method-history
 457                 (cons current-input-method
 458                       (delete current-input-method input-method-history))))
 459       (setq input-method-history (list current-input-method)))
 460     (unwind-protect
 461         (funcall inactivate-current-input-method-function)
 462       (unwind-protect
 463           (run-hooks 'input-method-inactivate-hook)
 464         (setq current-input-method nil
 465               current-input-method-title nil)
 466         (force-mode-line-update)))))
 467
 468 (defun set-input-method (input-method)
 469   "Select and activate input method INPUT-METHOD for the current buffer.
 470 This also sets the default input method to the one you specify."
 471   (interactive
 472    (let* ((default (or (car input-method-history) default-input-method)))
 473      (list (read-input-method-name
 474             (if default "Select input method (default %s): " "Select input method: ")
 475             default t))))
 476   (activate-input-method input-method)
 477   (setq default-input-method input-method))
 478
 479 (defun toggle-input-method (&optional arg)
 480   "Turn on or off a multilingual text input method for the current buffer.
 481
 482 With no prefix argument, if an input method is currently activated,
 483 turn it off.  Otherwise, activate an input method -- the one most
 484 recently used, or the one specified in `default-input-method', or
 485 the one read from the minibuffer.
 486
 487 With a prefix argument, read an input method from the minibuffer and
 488 turn it on.
 489
 490 The default is to use the most recent input method specified
 491 \(not including the currently active input method, if any)."
 492   (interactive "P")
 493   (if (and current-input-method (not arg))
 494       (inactivate-input-method)
 495     (let ((default (or (car input-method-history) default-input-method)))
 496       (if (and arg default (equal current-input-method default)
 497                (> (length input-method-history) 1))
 498           (setq default (nth 1 input-method-history)))
 499       (activate-input-method
 500        (if (or arg (not default))
 501            (progn
 502              (read-input-method-name
 503               (if default "Input method (default %s): " "Input method: " )
 504               default t))
 505          default))
 506       (or default-input-method
 507           (setq default-input-method current-input-method)))))
 508
 509 (defun describe-input-method (input-method)
 510   "Describe input method INPUT-METHOD."
 511   (interactive
 512    (list (read-input-method-name
 513           "Describe input method (default, current choice): ")))
 514   (if (and input-method (symbolp input-method))
 515       (setq input-method (symbol-name input-method)))
 516   (if (null input-method)
 517       (describe-current-input-method)
 518     (with-output-to-temp-buffer "*Help*"
 519       (let ((elt (assoc input-method input-method-alist)))
 520         (princ (format "Input method: %s (`%s' in mode line) for %s\n  %s\n"
 521                        input-method (nth 3 elt) (nth 1 elt) (nth 4 elt)))))))
 522
 523 (defun describe-current-input-method ()
 524   "Describe the input method currently in use."
 525   (if current-input-method
 526       (if (and (symbolp describe-current-input-method-function)
 527                (fboundp describe-current-input-method-function))
 528           (funcall describe-current-input-method-function)
 529         (message "No way to describe the current input method `%s'"
 530                  current-input-method)
 531         (ding))
 532     (error "No input method is activated now")))
 533
 534 (defun read-multilingual-string (prompt &optional initial-input input-method)
 535   "Read a multilingual string from minibuffer, prompting with string PROMPT.
 536 The input method selected last time is activated in minibuffer.
 537 If optional second arg INITIAL-INPUT is non-nil, insert it in the minibuffer
 538 initially.
 539 Optional 3rd argument INPUT-METHOD specifies the input method
 540 to be activated instead of the one selected last time.  It is a symbol
 541 or a string."
 542   (setq input-method
 543         (or input-method
 544             current-input-method
 545             default-input-method
 546             (read-input-method-name "Input method: " nil t)))
 547   (if (and input-method (symbolp input-method))
 548       (setq input-method (symbol-name input-method)))
 549   (let ((prev-input-method current-input-method))
 550     (unwind-protect
 551         (progn
 552           (activate-input-method input-method)
 553           ;; FSF Emacs
 554           ;; (read-string prompt initial-input nil nil t)
 555           (read-string prompt initial-input nil))
 556       (activate-input-method prev-input-method))))
 557
 558 ;; Variables to control behavior of input methods.  All input methods
 559 ;; should react to these variables.
 560
 561 (defcustom input-method-verbose-flag 'default
 562   "*A flag to control extra guidance given by input methods.
 563 The value should be nil, t, `complex-only', or `default'.
 564
 565 The extra guidance is done by showing list of available keys in echo
 566 area.  When you use the input method in the minibuffer, the guidance
 567 is shown at the bottom short window (split from the existing window).
 568
 569 If the value is t, extra guidance is always given, if the value is
 570 nil, extra guidance is always suppressed.
 571
 572 If the value is `complex-only', only complex input methods such as
 573 `chinese-py' and `japanese' give extra guidance.
 574
 575 If the value is `default', complex input methods always give extra
 576 guidance, but simple input methods give it only when you are not in
 577 the minibuffer.
 578
 579 See also the variable `input-method-highlight-flag'."
 580   :type '(choice (const t) (const nil) (const complex-only) (const default))
 581   :group 'mule)
 582
 583 (defcustom input-method-highlight-flag t
 584   "*If this flag is non-nil, input methods highlight partially-entered text.
 585 For instance, while you are in the middle of a Quail input method sequence,
 586 the text inserted so far is temporarily underlined.
 587 The underlining goes away when you finish or abort the input method sequence.
 588 See also the variable `input-method-verbose-flag'."
 589   :type 'boolean
 590   :group 'mule)
 591
 592 (defvar input-method-activate-hook nil
 593   "Normal hook run just after an input method is activated.
 594
 595 The variable `current-input-method' keeps the input method name
 596 just activated.")
 597
 598 (defvar input-method-inactivate-hook nil
 599   "Normal hook run just after an input method is inactivated.
 600
 601 The variable `current-input-method' still keeps the input method name
 602 just inactivated.")
 603
 604 (defvar input-method-after-insert-chunk-hook nil
 605   "Normal hook run just after an input method insert some chunk of text.")
 606
 607 (defvar input-method-exit-on-first-char nil
 608   "This flag controls a timing when an input method returns.
 609 Usually, the input method does not return while there's a possibility
 610 that it may find a different translation if a user types another key.
 611 But, it this flag is non-nil, the input method returns as soon as
 612 the current key sequence gets long enough to have some valid translation.")
 613
 614 (defvar input-method-use-echo-area nil
 615   "This flag controls how an input method shows an intermediate key sequence.
 616 Usually, the input method inserts the intermediate key sequence,
 617 or candidate translations corresponding to the sequence,
 618 at point in the current buffer.
 619 But, if this flag is non-nil, it displays them in echo area instead.")
 620
 621 (defvar input-method-exit-on-invalid-key nil
 622   "This flag controls the behavior of an input method on invalid key input.
 623 Usually, when a user types a key which doesn't start any character
 624 handled by the input method, the key is handled by turning off the
 625 input method temporarily.  After that key, the input method is re-enabled.
 626 But, if this flag is non-nil, the input method is never back on.")
 627
 628 \f
 629 (defvar set-language-environment-hook nil
 630   "Normal hook run after some language environment is set.
 631
 632 When you set some hook function here, that effect usually should not
 633 be inherited to another language environment.  So, you had better set
 634 another function in `exit-language-environment-hook' (which see) to
 635 cancel the effect.")
 636
 637 (defvar exit-language-environment-hook nil
 638   "Normal hook run after exiting from some language environment.
 639 When this hook is run, the variable `current-language-environment'
 640 is still bound to the language environment being exited.
 641
 642 This hook is mainly used for canceling the effect of
 643 `set-language-environment-hook' (which-see).")
 644
 645 (put 'setup-specified-language-environment 'apropos-inhibit t)
 646
 647 (defun setup-specified-language-environment ()
 648   "Switch to a specified language environment."
 649   (interactive)
 650   (let (language-name)
 651     (if (and (symbolp last-command-event)
 652              (or (not (eq last-command-event 'Default))
 653                  (setq last-command-event 'English))
 654              (setq language-name (symbol-name last-command-event)))
 655         (set-language-environment language-name)
 656       (error "Bogus calling sequence"))))
 657
 658 (defcustom current-language-environment "English"
 659   "The last language environment specified with `set-language-environment'.
 660 This variable should be set only with \\[customize], which is equivalent
 661 to using the function `set-language-environment'."
 662   :link '(custom-manual "(emacs)Language Environments")
 663   :set (lambda (symbol value) (set-language-environment value))
 664   :get (lambda (x)
 665          (or (car-safe (assoc-ignore-case
 666                         (if (symbolp current-language-environment)
 667                             (symbol-name current-language-environment)
 668                           current-language-environment)
 669                         language-info-alist))
 670              "English"))
 671   :type (cons 'choice (mapcar (lambda (lang)
 672                                 (list 'const (car lang)))
 673                               language-info-alist))
 674   :initialize 'custom-initialize-default
 675   :group 'mule
 676   :type 'string)
 677
 678 (defun reset-language-environment ()
 679   "Reset multilingual environment of Emacs to the default status.
 680
 681 The default status is as follows:
 682
 683   The default value of `buffer-file-coding-system' is nil.
 684   The default coding system for process I/O is nil.
 685   The default value for the command `set-terminal-coding-system' is nil.
 686   The default value for the command `set-keyboard-coding-system' is nil.
 687
 688   The order of priorities of coding categories and the coding system
 689   bound to each category are as follows
 690         coding category         coding system
 691         --------------------------------------------------
 692         iso-7                   iso-2022-7bit
 693         no-conversion           raw-text
 694         utf-8                   utf-8
 695         iso-8-1                 iso-8859-1
 696         iso-8-2                 ctext (iso-8859-1 alias)
 697         iso-8-designate         ctext (iso-8859-1 alias)
 698         iso-lock-shift          iso-2022-lock
 699         shift-jis               shift_jis
 700         big5                    big5
 701         ucs-4                   iso-10646-ucs-4
 702 "
 703 ;; The old table (from FSF synch?) was not what we use (cf mule-coding.el),
 704 ;; and as documented iso-8-designate is inconsistent with iso-2022-8bit-ss2.
 705 ;;  The order of priorities of coding categories and the coding system
 706 ;;  bound to each category are as follows
 707 ;;      coding category         coding system
 708 ;;      --------------------------------------------------
 709 ;;      iso-8-2                 iso-8859-1
 710 ;;      iso-8-1                 iso-8859-1
 711 ;;      iso-7                   iso-2022-7bit
 712 ;;      iso-lock-shift          iso-2022-lock
 713 ;;      iso-8-designate         iso-2022-8bit-ss2
 714 ;;      no-conversion           raw-text
 715 ;;      shift-jis               shift_jis
 716 ;;      big5                    big5
 717 ;;      ucs-4                   ----
 718 ;;      utf-8                   ----
 719   (interactive)
 720
 721   (set-coding-category-system 'iso-7            'iso-2022-7)
 722   (set-coding-category-system 'iso-8-1          'iso-8859-1)
 723   (set-coding-category-system 'iso-8-2          'ctext)
 724   (set-coding-category-system 'iso-lock-shift   'iso-2022-lock)
 725   (set-coding-category-system 'iso-8-designate  'ctext)
 726   (set-coding-category-system 'no-conversion    'raw-text)
 727   (set-coding-category-system 'shift-jis        'shift_jis)
 728   (set-coding-category-system 'big5             'big5)
 729   ;; #### Can we now assume the existence of the 10646 coding systems?
 730   ;; #### These lists need to be synched with the ones in mule-coding.el.
 731   (cond ((eq (coding-system-type (coding-category-system 'utf-8)) 'utf-8)
 732          (set-coding-category-system 'utf-8 'utf-8)
 733          (cond ((eq (coding-system-type (coding-category-system 'ucs-4))
 734                     'iso-10646-ucs-4)
 735                 (set-coding-category-system 'ucs-4 'iso-10646-ucs-4)
 736                 (set-coding-priority-list
 737                  '(iso-7
 738                    no-conversion
 739                    utf-8
 740                    iso-8-1
 741                    iso-8-2
 742                    iso-8-designate
 743                    iso-lock-shift
 744                    shift-jis
 745                    big5
 746                    ucs-4))
 747                 )
 748                (t
 749                 (set-coding-priority-list
 750                  '(iso-7
 751                    no-conversion
 752                    utf-8
 753                    iso-8-1
 754                    iso-8-2
 755                    iso-8-designate
 756                    iso-lock-shift
 757                    shift-jis
 758                    big5))
 759                 ))
 760          )
 761         (t
 762          (set-coding-priority-list
 763           '(iso-7
 764             no-conversion
 765             iso-8-1
 766             iso-8-2
 767             iso-8-designate
 768             iso-lock-shift
 769             shift-jis
 770             big5))
 771          ))
 772
 773   ;; (update-coding-systems-internal)
 774
 775   (set-default-coding-systems nil)
 776   ;; Don't alter the terminal and keyboard coding systems here.
 777   ;; The terminal still supports the same coding system
 778   ;; that it supported a minute ago.
 779 ;;;  (set-terminal-coding-system-internal nil)
 780 ;;;  (set-keyboard-coding-system-internal nil)
 781
 782   ;; (setq nonascii-translation-table nil
 783   ;;       nonascii-insert-offset 0)
 784   )
 785
 786 (defun set-language-environment (language-name)
 787   "Set up multi-lingual environment for using LANGUAGE-NAME.
 788 This sets the coding system priority and the default input method
 789 and sometimes other things.  LANGUAGE-NAME should be a string
 790 which is the name of a language environment.  For example, \"Latin-1\"
 791 specifies the character set for the major languages of Western Europe."
 792   (interactive (list (read-language-name
 793                       nil
 794                       "Set language environment (default, English): ")))
 795   (if language-name
 796       (if (symbolp language-name)
 797           (setq language-name (symbol-name language-name)))
 798     (setq language-name "English"))
 799   (or (assoc-ignore-case language-name language-info-alist)
 800       (error "Language environment not defined: %S" language-name))
 801   (if current-language-environment
 802       (let ((func (get-language-info current-language-environment
 803                                      'exit-function)))
 804         (run-hooks 'exit-language-environment-hook)
 805         (if (fboundp func) (funcall func))))
 806   (let ((default-eol-type (coding-system-eol-type
 807                            default-buffer-file-coding-system)))
 808     (reset-language-environment)
 809
 810     (setq current-language-environment language-name)
 811     (set-language-environment-coding-systems language-name default-eol-type))
 812   (let ((input-method (get-language-info language-name 'input-method)))
 813     (when input-method
 814       (setq default-input-method input-method)
 815       (if input-method-history
 816           (setq input-method-history
 817                 (cons input-method
 818                       (delete input-method input-method-history))))))
 819   ;; (let ((nonascii (get-language-info language-name 'nonascii-translation))
 820   ;;       (dos-table
 821   ;;        (if (eq window-system 'pc)
 822   ;;            (intern
 823   ;;             (concat "cp" dos-codepage "-nonascii-translation-table")))))
 824   ;;   (cond
 825   ;;    ((char-table-p nonascii)
 826   ;;     (setq nonascii-translation-table nonascii))
 827   ;;    ((and (eq window-system 'pc) (boundp dos-table))
 828   ;;     ;; DOS terminals' default is to use a special non-ASCII translation
 829   ;;     ;; table as appropriate for the installed codepage.
 830   ;;     (setq nonascii-translation-table (symbol-value dos-table)))
 831   ;;    ((charsetp nonascii)
 832   ;;     (setq nonascii-insert-offset (- (make-char nonascii) 128)))))
 833
 834   ;; (setq charset-origin-alist
 835   ;;       (get-language-info language-name 'charset-origin-alist))
 836
 837   ;; Unibyte setups if necessary.
 838   ;; (unless default-enable-multibyte-characters
 839   ;;   ;; Syntax and case table.
 840   ;;   (let ((syntax (get-language-info language-name 'unibyte-syntax)))
 841   ;;     (if syntax
 842   ;;         (let ((set-case-syntax-set-multibyte nil))
 843   ;;           (load syntax nil t))
 844   ;;       ;; No information for syntax and case.  Reset to the defaults.
 845   ;;       (let ((syntax-table (standard-syntax-table))
 846   ;;             (case-table (standard-case-table))
 847   ;;             (ch (if (eq window-system 'pc) 128 160)))
 848   ;;         (while (< ch 256)
 849   ;;           (modify-syntax-entry ch " " syntax-table)
 850   ;;           (aset case-table ch ch)
 851   ;;           (setq ch (1+ ch)))
 852   ;;         (set-char-table-extra-slot case-table 0 nil)
 853   ;;         (set-char-table-extra-slot case-table 1 nil)
 854   ;;         (set-char-table-extra-slot case-table 2 nil))
 855   ;;       (set-standard-case-table (standard-case-table))
 856   ;;       (let ((list (buffer-list)))
 857   ;;         (while list
 858   ;;           (with-current-buffer (car list)
 859   ;;             (set-case-table (standard-case-table)))
 860   ;;           (setq list (cdr list))))))
 861   ;;   ;; Display table and coding system for terminal.
 862   ;;   (let ((coding (get-language-info language-name 'unibyte-display)))
 863   ;;     (if coding
 864   ;;         (standard-display-european-internal)
 865   ;;       (standard-display-default (if (eq window-system 'pc) 128 160) 255)
 866   ;;       (aset standard-display-table 146 nil))
 867   ;;     (or (eq window-system 'pc)
 868   ;;         (set-terminal-coding-system coding))))
 869
 870   (let ((required-features (get-language-info language-name 'features)))
 871     (while required-features
 872       (require (car required-features))
 873       (setq required-features (cdr required-features))))
 874   (let ((func (get-language-info language-name 'setup-function)))
 875     (if (fboundp func)
 876         (funcall func)))
 877   (run-hooks 'set-language-environment-hook)
 878   (force-mode-line-update t))
 879
 880 ;; (defun standard-display-european-internal ()
 881 ;;   ;; Actually set up direct output of non-ASCII characters.
 882 ;;   (standard-display-8bit (if (eq window-system 'pc) 128 160) 255)
 883 ;;   ;; Unibyte Emacs on MS-DOS wants to display all 8-bit characters with
 884 ;;   ;; the native font, and codes 160 and 146 stand for something very
 885 ;;   ;; different there.
 886 ;;   (or (and (eq window-system 'pc) (not default-enable-multibyte-characters))
 887 ;;       (progn
 888 ;;         ;; Make non-line-break space display as a plain space.
 889 ;;         ;; Most X fonts do the wrong thing for code 160.
 890 ;;         (aset standard-display-table 160 [32])
 891 ;;         ;; Most Windows programs send out apostrophe's as \222.  Most X fonts
 892 ;;         ;; don't contain a character at that position.  Map it to the ASCII
 893 ;;         ;; apostrophe.
 894 ;;         (aset standard-display-table 146 [39]))))
 895
 896 (defun set-language-environment-coding-systems (language-name
 897                                                 &optional eol-type)
 898   "Do various coding system setups for language environment LANGUAGE-NAME.
 899
 900 The optional arg EOL-TYPE specifies the eol-type of the default value
 901 of buffer-file-coding-system set by this function.
 902
 903 Note that `coding-priority-list' is not reset first; thus changing language
 904 environment allows recognition of coding systems from previously set language
 905 environments.  (This will not work if the desired coding systems are from the
 906 same category.  E.g., starting with a Hebrew language environment, ISO 8859-8
 907 will be recognized.  If you shift to Russian, ISO 8859-8 will be shadowed by
 908 ISO 8859-5, and cannot be automatically recognized without resetting the
 909 language environment to Hebrew.  However, if you shift from Japanese to
 910 Russian, ISO-2022-JP will continue to be automatically recognized, since
 911 ISO-8859-5 and ISO-2022-JP are different coding categories.)"
 912   (let* ((priority (get-language-info language-name 'coding-priority))
 913          (default-coding (car priority)))
 914     (if priority
 915         (let ((categories (mapcar 'coding-system-category priority))
 916               category checked-categories)
 917           (set-default-coding-systems
 918            (if (memq eol-type '(lf crlf cr unix dos mac))
 919                (coding-system-change-eol-conversion default-coding eol-type)
 920              default-coding))
 921           ;; (setq default-sendmail-coding-system default-coding)
 922           (while priority
 923             (unless (memq (setq category (car categories)) checked-categories)
 924               (set-coding-category-system category (car priority))
 925               (setq checked-categories (cons category checked-categories)))
 926             (setq priority (cdr priority)
 927                   categories (cdr categories)))
 928           (set-coding-priority-list (nreverse checked-categories))
 929           ;; (update-coding-systems-internal)
 930           ))))
 931
 932 ;; Print all arguments with `princ', then print "\n".
 933 (defsubst princ-list (&rest args)
 934   (while args (princ (car args)) (setq args (cdr args)))
 935   (princ "\n"))
 936
 937 (put 'describe-specified-language-support 'apropos-inhibit t)
 938
 939 ;; Print a language specific information such as input methods,
 940 ;; charsets, and coding systems.  This function is intended to be
 941 ;; called from the menu:
 942 ;;   [menu-bar mule describe-language-environment LANGUAGE]
 943 ;; and should not run it by `M-x describe-current-input-method-function'.
 944 (defun describe-specified-language-support ()
 945   "Describe how Emacs supports the specified language environment."
 946   (interactive)
 947   (let (language-name)
 948     (if (not (and (symbolp last-command-event)
 949                   (setq language-name (symbol-name last-command-event))))
 950         (error "Bogus calling sequence"))
 951     (describe-language-environment language-name)))
 952
 953 (defun describe-language-environment (language-name)
 954   "Describe how Emacs supports language environment LANGUAGE-NAME."
 955   (interactive
 956    (list (read-language-name
 957           'documentation
 958           "Describe language environment (default, current choice): ")))
 959   (if (null language-name)
 960       (setq language-name current-language-environment))
 961   (if (or (null language-name)
 962           (null (get-language-info language-name 'documentation)))
 963       (error "No documentation for the specified language"))
 964   (if (symbolp language-name)
 965       (setq language-name (symbol-name language-name)))
 966   (let ((doc (get-language-info language-name 'documentation)))
 967     (with-output-to-temp-buffer "*Help*"
 968       (princ-list language-name " language environment" "\n")
 969       (if (stringp doc)
 970           (progn
 971             (princ-list doc)
 972             (terpri)))
 973       (let ((str (get-language-info language-name 'sample-text)))
 974         (if (stringp str)
 975             (progn
 976               (princ "Sample text:\n")
 977               (princ-list "  " str)
 978               (terpri))))
 979       (let ((input-method (get-language-info language-name 'input-method))
 980             (l (copy-sequence input-method-alist)))
 981         (princ "Input methods")
 982         (when input-method
 983           (princ (format " (default, %s)" input-method))
 984           (setq input-method (assoc input-method input-method-alist))
 985           (setq l (cons input-method (delete input-method l))))
 986         (princ ":\n")
 987         (while l
 988           (if (string= language-name (nth 1 (car l)))
 989               (princ-list "  " (car (car l))
 990                           (format " (`%s' in mode line)" (nth 3 (car l)))))
 991           (setq l (cdr l))))
 992       (terpri)
 993       (princ "Character sets:\n")
 994       (let ((l (get-language-info language-name 'charset)))
 995         (if (null l)
 996             (princ-list "  nothing specific to " language-name)
 997           (while l
 998             (princ-list "  " (car l) ": "
 999                         (charset-description (car l)))
1000             (setq l (cdr l)))))
1001       (terpri)
1002       (princ "Coding systems:\n")
1003       (let ((l (get-language-info language-name 'coding-system)))
1004         (if (null l)
1005             (princ-list "  nothing specific to " language-name)
1006           (while l
1007             (princ ; (format "  %s (`%c' in mode line):\n\t%s\n"
1008              ;; In XEmacs, `coding-system-mnemonic' returns string.
1009              (format "  %s (`%s' in mode line):\n\t%s\n"
1010                            (car l)
1011                            (coding-system-mnemonic (car l))
1012                            (coding-system-doc-string (car l))))
1013             ;; (let ((aliases (coding-system-get (car l) 'alias-coding-systems)))
1014             ;;   (when aliases
1015             ;;     (princ "\t")
1016             ;;     (princ (cons 'alias: (cdr aliases)))
1017             ;;     (terpri)))
1018             (setq l (cdr l))))))))
1019 \f
1020 ;;; Charset property
1021
1022 ;; (defsubst get-charset-property (charset propname)
1023 ;;   "Return the value of CHARSET's PROPNAME property.
1024 ;; This is the last value stored with
1025 ;; `(put-charset-property CHARSET PROPNAME VALUE)'."
1026 ;;   (plist-get (charset-plist charset) propname))
1027
1028 ;; (defsubst put-charset-property (charset propname value)
1029 ;;   "Store CHARSETS's PROPNAME property with value VALUE.
1030 ;; It can be retrieved with `(get-charset-property CHARSET PROPNAME)'."
1031 ;;   (set-charset-plist charset
1032 ;;                      (plist-put (charset-plist charset) propname value)))
1033
1034 (defvar char-code-property-table
1035   (make-char-table 'generic)
1036   "Char-table containing a property list of each character code.
1037
1038 See also the documentation of `get-char-code-property' and
1039 `put-char-code-property'")
1040 ;;   (let ((plist (aref char-code-property-table char)))
1041 (defun get-char-code-property (char propname)
1042   "Return the value of CHAR's PROPNAME property in `char-code-property-table'."
1043   (let ((plist (get-char-table char char-code-property-table)))
1044     (if (listp plist)
1045         (car (cdr (memq propname plist))))))
1046
1047 (defun put-char-code-property (char propname value)
1048   "Store CHAR's PROPNAME property with VALUE in `char-code-property-table'.
1049 It can be retrieved with `(get-char-code-property CHAR PROPNAME)'."
1050   (let ((plist (get-char-table char char-code-property-table)))
1051     (if plist
1052         (let ((slot (memq propname plist)))
1053           (if slot
1054               (setcar (cdr slot) value)
1055             (nconc plist (list propname value))))
1056       (put-char-table char (list propname value) char-code-property-table)
1057       )))
1058
1059 \f
1060 ;; Pretty description of encoded string
1061
1062 ;; Alist of ISO 2022 control code vs the corresponding mnemonic string.
1063 ;; (defvar iso-2022-control-alist
1064 ;;   '((?\x1b . "ESC")
1065 ;;     (?\x0e . "SO")
1066 ;;     (?\x0f . "SI")
1067 ;;     (?\x8e . "SS2")
1068 ;;     (?\x8f . "SS3")
1069 ;;     (?\x9b . "CSI")))
1070
1071 ;; (defun encoded-string-description (str coding-system)
1072 ;;   "Return a pretty description of STR that is encoded by CODING-SYSTEM."
1073 ;;   (setq str (string-as-unibyte str))
1074 ;;   (let ((char (aref str 0))
1075 ;;         desc)
1076 ;;     (when (< char 128)
1077 ;;       (setq desc (or (cdr (assq char iso-2022-control-alist))
1078 ;;                      (char-to-string char)))
1079 ;;       (let ((i 1)
1080 ;;             (len (length str)))
1081 ;;         (while (< i len)
1082 ;;           (setq char (aref str i))
1083 ;;           (if (>= char 128)
1084 ;;               (setq desc nil i len)
1085 ;;             (setq desc (concat desc " "
1086 ;;                                (or (cdr (assq char iso-2022-control-alist))
1087 ;;                                    (char-to-string char)))
1088 ;;                   i (1+ i))))))
1089 ;;     (or desc
1090 ;;         (mapconcat (function (lambda (x) (format "0x%02x" x))) str " "))))
1091
1092 ;; (defun encode-coding-char (char coding-system)
1093 ;;   "Encode CHAR by CODING-SYSTEM and return the resulting string.
1094 ;; If CODING-SYSTEM can't safely encode CHAR, return nil."
1095 ;;   (if (cmpcharp char)
1096 ;;       (setq char (car (decompose-composite-char char 'list))))
1097 ;;   (let ((str1 (char-to-string char))
1098 ;;         (str2 (make-string 2 char))
1099 ;;         (safe-charsets (and coding-system
1100 ;;                             (coding-system-get coding-system 'safe-charsets)))
1101 ;;         enc1 enc2 i1 i2)
1102 ;;     (when (or (eq safe-charsets t)
1103 ;;               (memq (char-charset char) safe-charsets))
1104 ;;       ;; We must find the encoded string of CHAR.  But, just encoding
1105 ;;       ;; CHAR will put extra control sequences (usually to designate
1106 ;;       ;; ASCII charset) at the tail if type of CODING is ISO 2022.
1107 ;;       ;; To exclude such tailing bytes, we at first encode one-char
1108 ;;       ;; string and two-char string, then check how many bytes at the
1109 ;;       ;; tail of both encoded strings are the same.
1110 ;;
1111 ;;       (setq enc1 (string-as-unibyte (encode-coding-string str1 coding-system))
1112 ;;             i1 (length enc1)
1113 ;;             enc2 (string-as-unibyte (encode-coding-string str2 coding-system))
1114 ;;             i2 (length enc2))
1115 ;;       (while (and (> i1 0) (= (aref enc1 (1- i1)) (aref enc2 (1- i2))))
1116 ;;         (setq i1 (1- i1) i2 (1- i2)))
1117 ;;
1118 ;;       ;; Now (substring enc1 i1) and (substring enc2 i2) are the same,
1119 ;;       ;; and they are the extra control sequences at the tail to
1120 ;;       ;; exclude.
1121 ;;       (substring enc2 0 i2))))
1122
1123
1124 ;;; mule-cmds.el ends here