xemacs-beta: lisp/leim/quail.el comparison

comparison lisp/leim/quail.el @ 165:5a88923fcbfe r20-3b9

Import from CVS: tag r20-3b9

author	cvs
date	Mon, 13 Aug 2007 09:44:42 +0200
parents	43dd3413c7c7
children	15872534500d

comparison

equal deleted inserted replaced

-:4e0740e5aab2
+:5a88923fcbfe
-;;; quail.el -- provides simple input method for multilingual text
+;;; quail.el --- Provides simple input method for multilingual text
 ;; Copyright (C) 1995 Free Software Foundation, Inc.
 ;; Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
 ;; Copyright (C) 1997 MORIOKA Tomohiko
 (defvar quail-current-str nil
 "Currently selected translation of the current key.")
 (defvar quail-current-translations nil
 "Cons of indices and vector of possible translations of the current key.")
+(defvar quail-current-data nil
+"Any Lisp object holding information of current translation status.
+When a key sequence is mapped to TRANS and TRANS is a cons
+of actual translation and some Lisp object to be refered
+for translating the longer key sequence, this variable is set
+to that Lisp object.")
 ;; A flag to control conversion region.  Normally nil, but if set to
 ;; t, it means we must start the new conversion region if new key to
 ;; be translated is input.
 (defvar quail-reset-conversion-region nil)
 ;; Let's go back to Quail mode.
 (setq quail-mode t)
 (setq overriding-local-map quail-saved-overriding-local-map)
 ;; If whole text in conversion area was deleted, exit from the
 ;; recursive edit.
-(let ((start (overlay-start quail-conv-overlay)))
+;;    1997/6/24 modified by MORIOKA Tomohiko <morioka@jaist.ac.jp>
+;;	for XEmacs
+(let ((start (and quail-conv-overlay
+			(overlay-start quail-conv-overlay))))
 	(if (and start (= start (overlay-end quail-conv-overlay)))
 	    (throw 'quail-tag nil)))
 )))
 (defun quail-execute-non-quail-command ()
 vector.  Then each element of the string or vector is a candidate for
 the translation.  These objects are transformed to cons cells in the
 format \(INDEX . VECTOR), as described above."
 (and (consp object)
 (let ((translation (car object)))
-	 (or (integerp translation) (consp translation) (null translation)
+	 (or (characterp translation) (null translation)
 	     (vectorp translation) (stringp translation)
-	     (symbolp translation)))
+	     (symbolp translation)
+	     (and (consp translation) (not (vectorp (cdr translation))))))
 (let ((alist (cdr object)))
-	 (or (listp alist) (symbolp alist)))))
+	 (or (and (listp alist) (consp (car alist)))
+	     (symbolp alist)))))
 (defmacro quail-define-rules (&rest rules)
 "Define translation rules of the current Quail package.
 Each argument is a list of KEY and TRANSLATION.
 KEY is a string meaning a sequence of keystrokes to be translated.
 (setcar (cdr (cdr quail-current-package)) map))
 (defun quail-defrule (key translation &optional name)
 "Add one translation rule, KEY to TRANSLATION, in the current Quail package.
 KEY is a string meaning a sequence of keystrokes to be translated.
-TRANSLATION is a character, a string, a vector, a Quail map, or a function.
+TRANSLATION is a character, a string, a vector, a Quail map,
+a function, or a cons.
 It it is a character, it is the sole translation of KEY.
 If it is a string, each character is a candidate for the translation.
 If it is a vector, each element (string or character) is a candidate
 for the translation.
+If it is a cons, the car is one of the above and the cdr is a function
+to call when translating KEY.
 In these cases, a key specific Quail map is generated and assigned to KEY.
 If TRANSLATION is a Quail map or a function symbol which returns a Quail map,
 it is used to handle KEY.
 Optional argument NAME, if specified, says which Quail package
 (if (null (stringp key))
 "Invalid Quail key `%s'" key)
 ;; 1997/5/26 by MORIOKA Tomohiko
 ;;	modified for XEmacs
 (if (not (or (characterp trans) (stringp trans) (vectorp trans)
+	       (consp trans)
 	       (symbolp trans)
 	       (quail-map-p trans)))
 (error "Invalid Quail translation `%s'" trans))
 (if (null (quail-map-p map))
 (error "Invalid Quail map `%s'" map))
 (let ((len (length key))
 	(idx 0)
 	ch entry)
+;; Make a map for registering TRANS if necessary.
 (while (< idx len)
 (if (null (consp map))
 	  ;; We come here, for example, when we try to define a rule
 	  ;; for "ABC" but a rule for "AB" is already defined as a
 	  ;; symbol.
 		    (error "Quail key %s is too short" key)
 		  (setcdr entry trans))
 	      (setcdr entry (append trans (cdr map)))))
 	(setcar map trans)))))
-(defun quail-get-translation (map key len)
+(defun quail-get-translation (def key len)
-"Return the translation specified in Quail map MAP for KEY of length LEN.
+"Return the translation specified as DEF for KEY of length LEN.
 The translation is either a character or a cons of the form (INDEX . VECTOR),
 where VECTOR is a vector of candidates (character or string) for
 the translation, and INDEX points into VECTOR to specify the currently
 selected translation."
-(let ((def (car map)))
+(if (and def (symbolp def))
-(if (and def (symbolp def))
+;; DEF is a symbol of a function which returns valid translation.
-	;; DEF is a symbol of a function which returns valid translation.
+(setq def (funcall def key len)))
-	(setq def (funcall def key len)))
+(if (and (consp def) (not (vectorp (cdr def))))
-(cond
+(setq def (car def)))
-((or (characterp def) (consp def))
-def)
+(cond
+((or (characterp def) (consp def))
-((null def)
+def)
-;; No translation.
-nil)
+((null def)
+;; No translation.
-((stringp def)
+nil)
-;; Each character in DEF is a candidate of translation.  Reform
-;; it as (INDEX . VECTOR).
+((stringp def)
-(setq def (string-to-vector def))
+;; Each character in DEF is a candidate of translation.  Reform
-;; But if the length is 1, we don't need vector but a single
+;; it as (INDEX . VECTOR).
-;; character as the translation.
+(setq def (string-to-vector def))
-(if (= (length def) 1)
+;; But if the length is 1, we don't need vector but a single
-	  (aref def 0)
+;; candidate as the translation.
-	(cons 0 def)))
+(if (= (length def) 1)
+	(aref def 0)
-((vectorp def)
+(cons 0 def)))
-;; Each element (string or character) in DEF is a candidate of
-;; translation.  Reform it as (INDEX . VECTOR).
+((vectorp def)
-(cons 0 def))
+;; Each element (string or character) in DEF is a candidate of
+;; translation.  Reform it as (INDEX . VECTOR).
-(t
+(cons 0 def))
-(error "Invalid object in Quail map: %s" def)))))
+(t
+(error "Invalid object in Quail map: %s" def))))
 (defun quail-lookup-key (key len)
 "Lookup KEY of length LEN in the current Quail map and return the definition.
 The returned value is a Quail map specific to KEY."
 (let ((idx 0)
 	(map (quail-map))
 	(kbd-translate (quail-kbd-translate))
-	slot ch translation)
+	slot ch translation def)
 (while (and map (< idx len))
 (setq ch (if kbd-translate (quail-keyboard-translate (aref key idx))
 		 (aref key idx)))
 (setq idx (1+ idx))
 (if (and (cdr map) (symbolp (cdr map)))
 	  (setcdr map (funcall (cdr map) key idx)))
 (setq slot (assq ch (cdr map)))
 (if (and (cdr slot) (symbolp (cdr slot)))
 	  (setcdr slot (funcall (cdr slot) key idx)))
 (setq map (cdr slot)))
-(if (and map (setq translation (quail-get-translation map key len)))
+(setq def (car map))
+(if (and map (setq translation (quail-get-translation def key len)))
 	(progn
-	  ;; We may have to reform car part of MAP.
+	  (if (and (consp def) (not (vectorp (cdr def))))
-	  (if (not (equal (car map) translation))
+	      (progn
-	      (setcar map translation))
+		(if (not (equal (car def) translation))
-	  (if (consp translation)
+		    ;; We must reflect TRANSLATION to car part of DEF.
+		    (setcar def translation))
+		(setq quail-current-data
+		      (if (functionp (cdr def))
+			  (funcall (cdr def))
+			(cdr def))))
+	    (if (not (equal def translation))
+		;; We must reflect TRANSLATION to car part of MAP.
+		(setcar map translation)))
+	  (if (and (consp translation) (vectorp (cdr translation)))
 	      (progn
 		(setq quail-current-translations translation)
 		(if (quail-forget-last-selection)
 		    (setcar quail-current-translations 0))))
 	  ;; We may have to reform cdr part of MAP.
 (let* ((len (length quail-current-key))
 	 (map (quail-lookup-key quail-current-key len))
 	 def ch)
 (if map
 	(let ((def (car map)))
+	  (if (and (consp def) (not (vectorp (cdr def))))
+	      (setq def (car def)))
 	  (setq quail-current-str
 		(if (consp def) (aref (cdr def) (car def)) def))
 	  ;; Return t only if we can terminate the current translation.
 	  (and
 	   ;; No alternative translations.
 ;; giving up, we must check two possibilities.
 (cond ((and
 	      (quail-maximum-shortest)
 	      (>= len 4)
 	      (setq def (car (quail-lookup-key quail-current-key (- len 2))))
+	      (if (and (consp def) (not (vectorp (cdr def))))
+		  (setq def (car def)))
 	      (quail-lookup-key (substring quail-current-key -2) 2))
 	     ;; Now the sequence is "...ABCD", which can be split into
 	     ;; "...AB" and "CD..." to get valid translation.
 	     ;; At first, get translation of "...AB".
 	     (setq quail-current-str
 		  (set-window-start win pos))
 	      ))))))
 (defun quail-show-translations ()
 "Show the current possible translations."
-(let ((key quail-current-key)
+(let* ((key quail-current-key)
-	(map (quail-lookup-key quail-current-key (length quail-current-key))))
+	 (map (quail-lookup-key quail-current-key (length quail-current-key)))
+	 (def (car map)))
+(if (and (consp def) (not (vectorp (cdr def))))
+	(setq def (car def)))
 (save-excursion
 (set-buffer quail-guidance-buf)
 (erase-buffer)
 ;; Show the current key.
 	      (insert (car (car l)))
 	      (setq l (cdr l)))
 	    (insert "]")))
 ;; Show list of translations.
-(if (consp (car map))
+(if (and (not (quail-deterministic)) (consp def))
-	  (let* ((idx (car (car map)))
+	  (let* ((idx (car def))
-		 (translations (cdr (car map)))
+		 (translations (cdr def))
 		 (from (* (/ idx 10) 10))
 		 (to (min (+ from 10) (length translations))))
 	    (indent-to 10)
 	    (insert (format "(%d/%d)"
 			    (1+ (/ from 10))
 	    (aset newkey len (car (car l)))
 	    (quail-completion-1 newkey (cdr (car l)) indent)
 	    (setq l (cdr l)))))))
 ;; List all possible translations of KEY in Quail map MAP with
-;; indentation INDENT."
+;; indentation INDENT.
 (defun quail-completion-list-translations (map key indent)
 (let ((translations
-	 (quail-get-translation map key (length key))))
+	 (quail-get-translation (car map) key (length key))))
 (if (integerp translations)
 	(insert "(1/1) 1." translations "\n")
 ;; We need only vector part.
 (setq translations (cdr translations))
 ;; Insert every 10 elements with indices in a line.
 (setq ch (aref quail-keyboard-layout i))
 (if (= ch ?\ )
 	  (insert ch)
 	(let* ((map (cdr (assq ch (cdr (quail-map)))))
 	       (translation (and map (quail-get-translation
-				      map (char-to-string ch) 1))))
+				      (car map) (char-to-string ch) 1))))
 	  (if (integerp translation)
 	      (insert translation)
 	    (if (consp translation)
 		(insert (aref (cdr translation) (car translation)))
 	      (insert ch)))))

Mercurial > hg > xemacs-beta

comparison lisp/leim/quail.el @ 165:5a88923fcbfe r20-3b9