[COMMIT] Provide some more input methods; ensure every specified langenv IM exists

APPROVE COMMIT NOTE: This patch has been committed. There's more to come, but that'll be committed to the trunk. leim/ChangeLog addition: 2007-05-20 Aidan Kehoe <kehoea(a)parhasard.net&gt; * quail/latin-pre.el: Require latin-euro-standards. * quail/latin-pre.el ("latin-10-prefix"): * quail/latin-pre.el ("latin-4-prefix"): * quail/latin-pre.el ("latin-5-prefix"): * quail/latin-pre.el ("latin-7-prefix"): * quail/latin-pre.el ("latin-8-prefix"): * quail/latin-pre.el ("latin-9-prefix"): * quail/latin-pre.el ("latin-prefix"): * quail/latin-pre.el ("polish-slash"): Import these input methods from GNU, add latin-4-prefix independently. Change to make-char instead of providing character literals; otherwise byte-compile under 21.4 throws an error in the Lisp reader. 2007-05-20 Aidan Kehoe <kehoea(a)parhasard.net&gt; * Makefile (REQUIRES): Require latin-euro-standards, to allow us to provide latin-{7,8,9,10} input methods. * leim-list.el: Register the new input methods on startup. * quail.el (quail-lookup-key): Accept one more argument in quail-lookup-key, as GNU does. * quail.el (quail-map-from-table): New. * quail.el (quail-map-from-table-1): New. * quail.el (quail-map-from-table-2): New. * quail.el (quail-lookup-map-and-concat): New. Import all four functions from GNU. mule-base/ChangeLog addition: 2007-05-20 Aidan Kehoe <kehoea(a)parhasard.net&gt; * mule-util.el (nested-alist-p): Escape a parenthesis at the start of the line, for the sake of fontification. * mule-util.el (set-nested-alist): Merge a change that Handa made to the function back in 1999. XEmacs Mule Packages source patch: Diff command: cvs -q diff -Nu Files affected: mule-base/mule-util.el =================================================================== RCS leim/quail/latin-pre.el =================================================================== RCS leim/quail.el =================================================================== RCS leim/leim-list.el =================================================================== RCS leim/Makefile =================================================================== RCS Index: leim/Makefile =================================================================== RCS file: /pack/xemacscvs/XEmacs/packages/mule-packages/leim/Makefile,v retrieving revision 1.34 diff -u -u -r1.34 Makefile --- leim/Makefile 2006/08/14 08:31:26 1.34 +++ leim/Makefile 2007/05/20 19:13:49 ＠＠ -22,7 +22,7 ＠＠ MAINTAINER = XEmacs Development Team <xemacs-beta(a)xemacs.org&gt; PACKAGE = leim PKG_TYPE = regular -REQUIRES = leim mule-base fsf-compat xemacs-base +REQUIRES = leim mule-base fsf-compat xemacs-base latin-euro-standards CATEGORY = mule ELCS = quail.elc leim-list.elc Index: leim/leim-list.el =================================================================== RCS file: /pack/xemacscvs/XEmacs/packages/mule-packages/leim/leim-list.el,v retrieving revision 1.5 diff -u -u -r1.5 leim-list.el --- leim/leim-list.el 2002/07/24 16:43:09 1.5 +++ leim/leim-list.el 2007/05/20 19:13:49 ＠＠ -99,6 +99,39 ＠＠ "3>" "Latin-3 characters input method with prefix modifiers" "quail/latin-pre") (register-input-method + "polish-slash" "Polish" 'quail-use-package + "PL>" "Polish diacritics and slash character are input as `/[acelnosxzACELNOSXZ/]'." + "quail/latin-pre") +(register-input-method + "latin-9-prefix" "Latin-9" 'quail-use-package + "0>" "Latin-9 characters input method with prefix modifiers" + "quail/latin-pre") +(register-input-method + "latin-8-prefix" "Latin-8" 'quail-use-package + "8>" "Latin-8 characters input method with prefix modifiers" + "quail/latin-pre") +(register-input-method + "latin-prefix" "Latin" 'quail-use-package + "L>" "Latin characters input method with prefix modifiers." + "quail/latin-pre") +(register-input-method + "latin-10-prefix" "Latin-10" 'quail-use-package + "10>" "Latin-10 characters input method with prefix modifiers" + "quail/latin-pre") +(register-input-method + "latin-7-prefix" "Latin-7" 'quail-use-package + "7>" "Latin-7 characters input method with prefix modifiers" + "quail/latin-pre") +(register-input-method + "latin-5-prefix" "Latin-5" 'quail-use-package + "5>" "Latin-5 characters input method with prefix modifiers" + "quail/latin-pre") +(register-input-method + "latin-4-prefix" "Latin-4" 'quail-use-package + "4>" "Latin-4 characters input method with prefix modifiers" + "quail/latin-pre") + +(register-input-method "latin-1-postfix" "Latin-1" 'quail-use-package "1<" "Latin-1 character input method with postfix modifiers" "quail/latin-post") ＠＠ -279,6 +312,10 ＠＠ "DA<" "Danish input method (rule: AE -> ,AF(B, OE -> ,AX(B, AA -> ,AE(B, E' -> ,AI(B)" "quail/latin-alt") (register-input-method + "lao" "Lao" 'quail-use-package + "(1E(B" "Lao input method simulating Lao keyboard layout based on Thai TIS620" + "quail/lao") +(register-input-method "esperanto-alt-postfix" "Latin-3" 'quail-use-package "EO<" "Esperanto input method with postfix modifiers" "quail/latin-alt") ＠＠ -322,10 +359,31 ＠＠ "turkish-alt-postfix" "Latin-3" 'quail-use-package "TR<" "Turkish (T,C|(Brk,Cg(Be) input method with postfix modifiers" "quail/latin-alt") -(register-input-method - "ipa" "IPA" 'quail-use-package - "IPA" "International Phonetic Alphabet for English, French, German and Italian" - "quail/ipa") + +(if (not (and (fboundp 'decode-char) (decode-char 'ucs #x31C) + (eq #x31C (encode-char (decode-char 'ucs #x31C) 'ucs)))) + (register-input-method + "ipa" "IPA" 'quail-use-package + "IPA" + "International Phonetic Alphabet for English, French, German and Italian" + "quail/ipa") + + (register-input-method + "kirshenbaum-ipa" "IPA" 'quail-use-package + "IPA-K" + "International Phonetic Alphabet, Kirshenbaum ASCII transliteration." + "quail/ipa-21.5") + (register-input-method + "x-sampa-ipa" "IPA" 'quail-use-package + "IPA-S" + "International Phonetic Alphabet, X-SAMPA ASCII transliteration." + "quail/ipa-21.5") + (register-input-method + "ipa" "IPA" 'quail-use-package + "IPA" + "International Phonetic Alphabet for English, French, German and Italian" + "quail/ipa-21.5")) + (register-input-method "korean-hanja" "Korean" 'quail-use-package "$(C9zyS(B" "2$(C9z=D(BKSC$(CySm.(B: $(Cz1SWGO4B(B $(CySm.＠G(B $(Cj$＠;(B $(CGQ1[(B2$(C9zcR＠87N(B $(C{<usGO?)(B $(C`TwI(B" ＠＠ -398,6 +456,14 ＠＠ "chinese-tonepy" "Chinese-GB" 'quail-use-package "$A5wF4(B" "$A::WVJdHk!K4x5wF4Rt!K!!(B" "quail/TONEPY") +(register-input-method + "tibetan-wylie" "Tibetan" 'quail-use-package + "TIBw" "Tibetan character input by Extended Wylie key assignment." + "quail/tibetan") +(register-input-method + "tibetan-tibkey" "Tibetan" 'quail-use-package + "TIBt" "Tibetan character input by TibKey key assignment." + "quail/tibetan") (register-input-method "chinese-sw" "Chinese-GB" 'quail-use-package "$AJWN2(B" "$A::WVJdHk!KJWN2!K!!(B" Index: leim/quail.el =================================================================== RCS file: /pack/xemacscvs/XEmacs/packages/mule-packages/leim/quail.el,v retrieving revision 1.7 diff -u -u -r1.7 quail.el --- leim/quail.el 2006/06/03 06:58:18 1.7 +++ leim/quail.el 2007/05/20 19:13:50 ＠＠ -965,7 +965,7 ＠＠ (t (error "Invalid object in Quail map: %s" def)))) -(defun quail-lookup-key (key &optional len) +(defun quail-lookup-key (key &optional len not-reset-indices) "Lookup KEY of length LEN in the current Quail map and return the definition. The returned value is a Quail map specific to KEY." (or len ＠＠ -1003,7 +1003,7 ＠＠ (if (and (consp translation) (vectorp (cdr translation))) (progn (setq quail-current-translations translation) - (if (quail-forget-last-selection) + (if (and (not not-reset-indices) (quail-forget-last-selection)) (setcar (car quail-current-translations) 0)))) ;; We may have to reform cdr part of MAP. (if (and (cdr map) (symbolp (cdr map))) ＠＠ -1853,6 +1853,123 ＠＠ key binding --- -------\n")) (help-mode))))) + + +;; Quail map generator from state transition table. + +(defun quail-map-from-table (table) + "Make quail map from state transition table TABLE. + +TABLE is an alist, the form is: + ((STATE-0 TRANSITION-0-1 TRANSITION-0-2 ...) (STATE-1 ...) ...) + +STATE-n are symbols to denote state. STATE-0 is the initial state. + +TRANSITION-n-m are transition rules from STATE-n, and have the form +\(RULES . STATE-x) or RULES, where STATE-x is one of STATE-n above, +RULES is a symbol whose value is an alist of keys \(string) vs the +correponding characters or strings. The format of the symbol value of +RULES is the same as arguments to `quail-define-rules'. + +If TRANSITION-n-m has the form (RULES . STATE-x), it means that +STATE-n transits to STATE-x when keys in RULES are input. Recursive +transition is allowed, i.e. STATE-x may be STATE-n. + +If TRANSITION-n-m has the form RULES, the transition terminates +when keys in RULES are input. + +The generated map can be set for the current Quail package by the +function `quail-install-map' (which see)." + (let ((state-alist (mapcar (lambda (x) (list (car x))) table)) + tail elt) + ;; STATE-ALIST is an alist of states vs the correponding sub Quail + ;; map. It is now initialized to ((STATE-0) (STATE-1) ...). + ;; Set key sequence mapping rules in cdr part of each element. + (while table + (quail-map-from-table-1 state-alist (car table)) + (setq table (cdr table))) + + ;; Now STATE-ALIST has the form ((STATE-0 MAPPING-RULES) ...). + ;; Elements of MAPPING-RULES may have the form (STATE-x). Replace + ;; them with MAPPING-RULES of STATE-x to make elements of + ;; STATE-ALIST valid Quail maps. + (setq tail state-alist) + (while tail + (setq elt (car tail) tail (cdr tail)) + (quail-map-from-table-2 state-alist elt)) + + ;; Return the Quail map for the initial state. + (car state-alist))) + +;; STATE-INFO has the form (STATE TRANSITION ...). Set key sequence +;; mapping rules in the element of STATE-ALIST that corresponds to +;; STATE according to TRANSITION ... +(defun quail-map-from-table-1 (state-alist state-info) + (let* ((state (car state-info)) + (map (assq state state-alist)) + (transitions (cdr state-info)) + elt) + (while transitions + (setq elt (car transitions) transitions (cdr transitions)) + (let (rules dst-state key trans) + ;; ELT has the form (RULES-SYMBOL . STATE-x) or RULES-SYMBOL. + ;; STATE-x is one of car parts of STATE-ALIST's elements. + (if (consp elt) + (setq rules (symbol-value (car elt)) + ;; Set (STATE-x) as branches for all keys in RULES. + ;; It is replaced with actual branches for STATE-x + ;; later in `quail-map-from-table-2'. + dst-state (list (cdr elt))) + (setq rules (symbol-value elt))) + (while rules + (setq key (car (car rules)) trans (cdr (car rules)) + rules (cdr rules)) + (if (stringp trans) + (if (= (length trans) 1) + (setq trans (aref trans 0)) + (setq trans (string-to-vector trans)))) + (set-nested-alist key trans map nil dst-state)))))) + +;; ELEMENT is one element of STATE-ALIST. ELEMENT is a nested alist; +;; the form is: +;; (STATE (CHAR NESTED-ALIST) ...) +;; NESTED-ALIST is a nested alist; the form is: +;; (TRANS (CHAR NESTED-ALIST) ...) +;; or +;; (TRANS (CHAR NESTED-ALIST) ... . (STATE-x)) +;; Here, the task is to replace all occurrences of (STATE-x) with: +;; (cdr (assq STATE-x STATE-ALIST)) + +(defun quail-map-from-table-2 (state-alist element) + (let ((prev element) + (tail (cdr element)) + elt) + (while (cdr tail) + (setq elt (car tail) prev tail tail (cdr tail)) + (quail-map-from-table-2 state-alist (cdr elt))) + (setq elt (car tail)) + (if (consp elt) + (quail-map-from-table-2 state-alist (cdr elt)) + (setcdr prev (cdr (assq elt state-alist)))))) + +;; Concatenate translations for all heading substrings of KEY in the +;; current Quail map. Here, `heading substring' means (substring KEY +;; 0 LEN), where LEN is 1, 2, ... (length KEY). +(defun quail-lookup-map-and-concat (key) + (let* ((len (length key)) + (translation-list nil) + map) + (while (> len 0) + (setq map (quail-lookup-key key len t) + len (1- len)) + (if map + (let* ((def (quail-map-definition map)) + (trans (if (consp def) (aref (cdr def) (car (car def))) + def))) + (if (integerp trans) + (setq trans (char-to-string trans))) + (setq translation-list (cons trans translation-list))))) + (apply 'concat translation-list)))  (defvar quail-directory-name "quail" Index: leim/quail/latin-pre.el =================================================================== RCS file: /pack/xemacscvs/XEmacs/packages/mule-packages/leim/quail/latin-pre.el,v retrieving revision 1.1.1.1 diff -u -u -r1.1.1.1 latin-pre.el --- leim/quail/latin-pre.el 1998/01/14 06:34:57 1.1.1.1 +++ leim/quail/latin-pre.el 2007/05/20 19:14:28 ＠＠ -30,6 +30,13 ＠＠ (require 'quail) +;; If things were nice and serial in 21.4 we could use literals for +;; latin-iso8859-{14,15,16} after this require, as GNU does. But they're +;; not, so we call make-char below, to prevent an invalid read syntax error +;; on byte-compile. + +(require 'latin-euro-standards) + (quail-define-package "latin-1-prefix" "Latin-1" "1>" t "Latin-1 characters input method with prefix modifiers ＠＠ -624,3 +631,955 ＠＠ (".g" ?,Cu(B) (".z" ?,C?(B) ) + +(quail-define-package + "polish-slash" "Polish" "PL>" nil + "Polish diacritics and slash character are input as `/[acelnosxzACELNOSXZ/]'. +For example, the character named `aogonek' is obtained by `/a'." + nil t t t nil nil nil nil nil nil t) + +(quail-define-rules + ("//" ?/) + ("/a" ?,B1(B) + ("/c" ?,Bf(B) + ("/e" ?,Bj(B) + ("/l" ?,B3(B) + ("/n" ?,Bq(B) + ("/o" ?,Bs(B) + ("/s" ?,B6(B) + ("/x" ?,B<(B) + ("/z" ?,B?(B) + ("/A" ?,B!(B) + ("/C" ?,BF(B) + ("/E" ?,BJ(B) + ("/L" ?,B#(B) + ("/N" ?,BQ(B) + ("/O" ?,BS(B) + ("/S" ?,B&(B) + ("/X" ?,B,(B) + ("/Z" ?,B/(B)) + +(quail-define-package + "latin-9-prefix" "Latin-9" "0>" t + (apply 'format + "Latin-9 (ISO-8859-15) characters input method with prefix modifiers + + effect | prefix | examples + ------------+--------+---------- + acute | ' | 'a -> %c + grave | ` | `a -> %c + circumflex | ^ | ^a -> %c + diaeresis | \" | \"a -> %c, \"Y -> %c + tilde | ~ | ~a -> %c + caron | ~ | ~z -> %c + cedilla | ~ | ~c -> %c + misc | \" ~ / | \"s -> %c ~d -> %c ~t -> %c /a -> %c /e -> %c /o -> %c + | \" ~ / | /o -> %c + symbol | ~ | ~> -> %c ~< -> %c ~! -> %c ~? -> %c ~~ -> %c + | ~ | ~s -> %c ~e -> %c ~. -> %c ~$ -> %c ~u -> %c + | ~ | ~- -> %c ~= -> %c + symbol | _ / | _o -> %c _a -> %c // -> %c /\\ -> %c _y -> %c + | _ / | _: -> %c /c -> %c ~p -> %c + | _ / | /= -> %c + symbol | ^ | ^r -> %c ^c -> %c ^1 -> %c ^2 -> %c ^3 -> %c _a -> %c +" (mapcar (lambda (code) (make-char 'latin-iso8859-15 code)) + + '(97 96 98 100 62 99 56 103 95 112 126 101 102 120 61 59 43 33 63 + 56 39 36 55 35 53 45 47 58 42 48 87 37 119 34 54 44 46 41 57 50 + 51 42))) + nil t nil nil nil nil nil nil nil nil t) + +(loop + for (string code) + in '(("'A" #x41) + ("'E" #x49) + ("'I" #x4d) + ("'O" #x53) + ("'U" #x5a) + ("'Y" #x5d) + ("'a" #x61) + ("'e" #x69) + ("'i" #x6d) + ("'o" #x73) + ("'u" #x7a) + ("'y" #x7d) + ("' " #x27) + ("`A" #x40) + ("`E" #x48) + ("`I" #x4c) + ("`O" #x52) + ("`U" #x59) + ("`a" #x60) + ("`e" #x68) + ("`i" #x6c) + ("`o" #x72) + ("`u" #x79) + ("``" #x60) + ("` " #x60) + ("^A" #x42) + ("^E" #x4a) + ("^I" #x4e) + ("^O" #x54) + ("^U" #x5b) + ("^a" #x62) + ("^e" #x6a) + ("^i" #x6e) + ("^o" #x74) + ("^u" #x7b) + ("^^" #x5e) + ("^ " #x5e) + ("\"A" #x44) + ("\"E" #x4b) + ("\"I" #x4f) + ("\"O" #x56) + ("\"U" #x5c) + ("\"a" #x64) + ("\"e" #x6b) + ("\"i" #x6f) + ("\"o" #x76) + ("\"s" #x5f) + ("\"u" #x7c) + ("\"y" #x7f) + ("\" " #x22) + ("~A" #x43) + ("~C" #x47) + ("~D" #x50) + ("~N" #x51) + ("~O" #x55) + ("~S" #x26) + ("~T" #x5e) + ("~Z" #x34) + ("~a" #x63) + ("~c" #x67) + ("~d" #x70) + ("~n" #x71) + ("~o" #x75) + ("~s" #x28) + ("~t" #x7e) + ("~z" #x38) + ("~>" #x3b) + ("~<" #x2b) + ("~!" #x21) + ("~?" #x3f) + ("~ " #x7e) + ("/A" #x45) + ("/E" #x46) + ("/O" #x58) + ("/a" #x65) + ("/e" #x66) + ("/o" #x78) + ("//" #x30) + ("/ " #x2f) + ("_o" #x3a) + ("_a" #x2a) + ("_+" #x31) + ("_y" #x25) + ("_:" #x77) + ("_ " #x20) + ("__" #x5f) + ("/c" #x22) + ("/\\" #x57) + ("/o" #x3d) + ("/O" #x3c) + ("\"Y" #x3e) + ("~s" #x27) + ("~p" #x36) + ("~e" #x24) + ("~." #x37) + ("~$" #x23) + ("~u" #x35) + ("^r" #x2e) + ("^c" #x29) + ("^1" #x39) + ("^2" #x32) + ("^3" #x33) + ("~-" #x2d) + ("~=" #x2f) + ("/=" #x2c)) + do (quail-defrule string (make-char 'latin-iso8859-15 code))) + +;; Latin-8 was done by an Englishman -- Johnny Celt should take a +;; squint at it. +;; +;; "Johnny" Celt here; it's fine. Aidan Kehoe, So Mai 20 15:58:45 CEST +;; 2007 + +(quail-define-package + "latin-8-prefix" "Latin-8" "8>" t + (apply 'format + "Latin-8 (ISO 8859-14) characters input method with prefix modifiers + + effect | prefix | examples + ------------+--------+---------- + acute | ' | 'a -> %c + grave | ` | `a -> %c + circumflex | ^ | ^w -> %c + diaeresis | \" | \"a -> %c + dot above | . | .b -> %c + tilde | ~ | ~a -> %c + cedilla | ~ | ~c -> %c + misc | \" ~ / | \"s -> %c /a -> %c /e -> %c /o -> %c + | ~ | ~s -> %c ~$ -> %c ~p -> %c + symbol | ^ | ^r -> %c ^c -> %c +" + (mapcar (lambda (code) (make-char 'latin-iso8859-14 code)) + '(97 96 112 100 34 99 103 95 101 102 120 39 35 54 46 41))) + nil t nil nil nil nil nil nil nil nil t) + +;; Basically following Latin-1, plus dottiness from Latin-3. +(loop + for (string code) + in '((".B" #x21) + (".b" #x22) + (".c" #x25) + (".C" #x24) + (".D" #x26) + (".d" #x2b) + (".f" #x31) + (".F" #x30) + (".g" #x33) + (".G" #x32) + (".m" #x35) + (".M" #x34) + (".p" #x39) + (".P" #x37) + (".s" #x3f) + (".S" #x3b) + (".t" #x77) + (".T" #x57) + ("'A" #x41) + ("'E" #x49) + ("'I" #x4d) + ("'O" #x53) + ("'U" #x5a) + ("'Y" #x5d) + ("'W" #x2a) + ("'a" #x61) + ("'e" #x69) + ("'i" #x6d) + ("'o" #x73) + ("'u" #x7a) + ("'w" #x3a) + ("'y" #x7d) + ("' " #x27) + ("`A" #x40) + ("`E" #x48) + ("`I" #x4c) + ("`O" #x52) + ("`U" #x59) + ("`W" #x28) + ("`Y" #x2c) + ("`a" #x60) + ("`e" #x68) + ("`i" #x6c) + ("`o" #x72) + ("`u" #x79) + ("`w" #x38) + ("`y" #x3c) + ("``" #x60) + ("` " #x60) + ("^A" #x42) + ("^E" #x4a) + ("^I" #x4e) + ("^O" #x54) + ("^U" #x5b) + ("^a" #x62) + ("^e" #x6a) + ("^i" #x6e) + ("^o" #x74) + ("^u" #x7b) + ("^w" #x70) + ("^W" #x50) + ("^y" #x7e) + ("^Y" #x5e) + ("^^" #x5e) + ("^ " #x5e) + ("\"A" #x44) + ("\"E" #x4b) + ("\"I" #x4f) + ("\"O" #x56) + ("\"U" #x5c) + ("\"a" #x64) + ("\"e" #x6b) + ("\"i" #x6f) + ("\"o" #x76) + ("\"s" #x5f) + ("\"u" #x7c) + ("\"w" #x3e) + ("\"W" #x3d) + ("\"y" #x7f) + ("\"Y" #x2f) + ("\" " #x22) + ("~A" #x43) + ("~C" #x47) + ("~N" #x51) + ("~O" #x55) + ("~a" #x63) + ("~c" #x67) + ("~n" #x71) + ("~o" #x75) + ("~ " #x7e) + ("/A" #x45) + ("/E" #x46) + ("/O" #x58) + ("/a" #x65) + ("/e" #x66) + ("/o" #x78) + ("/ " #x2f) + ("~p" #x36) + ("~s" #x27) + ("~$" #x23) + ("^r" #x2e) + ("^c" #x29)) + do (quail-defrule string (make-char 'latin-iso8859-14 code))) + +;; XEmacs change; breves removed from the docstring since we don't actually +;; support them. Also, encode characters using the standard ISO-2022-7 +;; escapes instead of GNU's mule-unicode-XXXX-XXXX character sets. +(quail-define-package + "latin-prefix" "Latin" "L>" t + (format "Latin characters input method with prefix modifiers. +This is the union of various input methods originally made for input +of characters from a single Latin-N charset. + + effect | prefix | examples + ------------+--------+---------- + acute | ' | 'a -> ,Aa(B, '' -> ,A4(B + grave | ` | `a -> ,A`(B + circumflex | ^ | ^a -> ,Ab(B + diaeresis | \" | \"a -> ,Ad(B \"\" -> ,A((B + tilde | ~ | ~a -> ,Ac(B + cedilla | ~ | ~c -> ,Ag(B + dot above | . | .g -> %c .B -> %c + misc | \" ~ / | \"s -> ,A_(B ~d -> ,Ap(B ~t -> ,A~(B /a -> ,Ae(B /e -> ,Af(B /o -> ,Ax(B + symbol | ~ | ~> -> ,A;(B ~< -> ,A+(B ~! -> ,A!(B ~? -> ,A?(B ~~ -> ,A8(B + symbol | _ / | _o -> ,A:(B _a -> ,A*(B // -> ,A0(B /\\ -> ,AW(B _y -> ,A%(B + symbol | ^ | ^r -> ,A.(B ^c -> ,A)(B ^1 -> ,A9(B ^2 -> ,A2(B ^3 -> ,A3(B +" (make-char 'latin-iso8859-3 117) (make-char 'latin-iso8859-14 33)) + nil t nil nil nil nil nil nil nil nil t) + +(loop for (string charset code) + in '(("' " ascii #x27) + ("''" latin-iso8859-1 #x34) + ("'A" latin-iso8859-1 #x41) + ("'E" latin-iso8859-1 #x49) + ("'I" latin-iso8859-1 #x4d) + ("'O" latin-iso8859-1 #x53) + ("'U" latin-iso8859-1 #x5a) + ("'W" latin-iso8859-14 #x2a) + ("'Y" latin-iso8859-1 #x5d) + ("'a" latin-iso8859-1 #x61) + ("'e" latin-iso8859-1 #x69) + ("'i" latin-iso8859-1 #x6d) + ("'o" latin-iso8859-1 #x73) + ("'u" latin-iso8859-1 #x7a) + ("'w" latin-iso8859-14 #x3a) + ("'y" latin-iso8859-1 #x7d) + (".B" latin-iso8859-14 #x21) + (".C" latin-iso8859-14 #x24) + (".D" latin-iso8859-14 #x26) + (".F" latin-iso8859-14 #x30) + (".G" latin-iso8859-14 #x32) + (".I" latin-iso8859-3 #x29) + (".M" latin-iso8859-14 #x34) + (".P" latin-iso8859-14 #x37) + (".S" latin-iso8859-14 #x3b) + (".T" latin-iso8859-14 #x57) + (".Z" latin-iso8859-3 #x2f) + (".b" latin-iso8859-14 #x22) + (".c" latin-iso8859-14 #x25) + (".d" latin-iso8859-14 #x2b) + (".f" latin-iso8859-14 #x31) + (".g" latin-iso8859-3 #x75) + (".m" latin-iso8859-14 #x35) + (".p" latin-iso8859-14 #x39) + (".s" latin-iso8859-14 #x3f) + (".t" latin-iso8859-14 #x77) + (".z" latin-iso8859-3 #x3f) + ("/ " ascii #x2f) + ("/#" latin-iso8859-1 #x23) + ("/$" latin-iso8859-1 #x24) + ("/." latin-iso8859-3 #x7f) + ("//" latin-iso8859-1 #x30) + ("/2" latin-iso8859-1 #x3d) + ("/3" latin-iso8859-1 #x3e) + ("/4" latin-iso8859-1 #x3c) + ("/=" latin-iso8859-1 #x2c) + ("/A" latin-iso8859-1 #x45) + ("/C" latin-iso8859-3 #x45) + ("/E" latin-iso8859-1 #x46) + ("/G" latin-iso8859-3 #x55) + ("/H" latin-iso8859-3 #x21) + ("/I" latin-iso8859-3 #x29) + ("/O" latin-iso8859-1 #x58) + ("/Z" latin-iso8859-3 #x2f) + ("/\\" latin-iso8859-1 #x57) + ("/a" latin-iso8859-1 #x65) + ("/c" latin-iso8859-1 #x22) + ("/c" latin-iso8859-3 #x65) + ("/e" latin-iso8859-1 #x66) + ("/g" latin-iso8859-3 #x75) + ("/h" latin-iso8859-3 #x31) + ("/i" latin-iso8859-3 #x39) + ("/o" latin-iso8859-1 #x78) + ("/o" latin-iso8859-15 #x3d) + ("/z" latin-iso8859-2 #x3f) + ("\" " ascii #x22) + ("\"A" latin-iso8859-1 #x44) + ("\"E" latin-iso8859-1 #x4b) + ("\"I" latin-iso8859-1 #x4f) + ("\"O" latin-iso8859-1 #x56) + ("\"U" latin-iso8859-1 #x5c) + ("\"W" latin-iso8859-14 #x3d) + ("\"Y" latin-iso8859-14 #x2f) + ("\"\"" latin-iso8859-1 #x28) + ("\"a" latin-iso8859-1 #x64) + ("\"e" latin-iso8859-1 #x6b) + ("\"i" latin-iso8859-1 #x6f) + ("\"o" latin-iso8859-1 #x76) + ("\"s" latin-iso8859-1 #x5f) + ("\"u" latin-iso8859-1 #x7c) + ("\"w" latin-iso8859-14 #x3e) + ("\"y" latin-iso8859-1 #x7f) + ("^ " ascii #x5e) + ("^1" latin-iso8859-1 #x39) + ("^2" latin-iso8859-1 #x32) + ("^3" latin-iso8859-1 #x33) + ("^A" latin-iso8859-1 #x42) + ("^C" latin-iso8859-3 #x46) + ("^E" latin-iso8859-1 #x4a) + ("^G" latin-iso8859-3 #x58) + ("^H" latin-iso8859-3 #x26) + ("^I" latin-iso8859-1 #x4e) + ("^J" latin-iso8859-3 #x2c) + ("^O" latin-iso8859-1 #x54) + ("^S" latin-iso8859-3 #x5e) + ("^U" latin-iso8859-1 #x5b) + ("^W" latin-iso8859-14 #x50) + ("^Y" latin-iso8859-14 #x5e) + ("^^" ascii #x5e) + ("^a" latin-iso8859-1 #x62) + ("^c" latin-iso8859-1 #x29) + ("^c" latin-iso8859-3 #x66) + ("^e" latin-iso8859-1 #x6a) + ("^g" latin-iso8859-3 #x78) + ("^h" latin-iso8859-3 #x36) + ("^i" latin-iso8859-1 #x6e) + ("^j" latin-iso8859-3 #x3c) + ("^o" latin-iso8859-1 #x74) + ("^r" latin-iso8859-1 #x2e) + ("^s" latin-iso8859-3 #x7e) + ("^u" latin-iso8859-1 #x7b) + ("^w" latin-iso8859-14 #x70) + ("^y" latin-iso8859-14 #x7e) + ("_+" latin-iso8859-1 #x31) + ("_:" latin-iso8859-1 #x77) + ("_a" latin-iso8859-1 #x2a) + ("_o" latin-iso8859-1 #x3a) + ("_y" latin-iso8859-1 #x25) + ("_ " latin-iso8859-1 #x20) + ("` " ascii #x60) + ("`A" latin-iso8859-1 #x40) + ("`E" latin-iso8859-1 #x48) + ("`I" latin-iso8859-1 #x4c) + ("`O" latin-iso8859-1 #x52) + ("`U" latin-iso8859-1 #x59) + ("`W" latin-iso8859-14 #x28) + ("`Y" latin-iso8859-14 #x2c) + ("``" ascii #x60) + ("`a" latin-iso8859-1 #x60) + ("`e" latin-iso8859-1 #x68) + ("`i" latin-iso8859-1 #x6c) + ("`o" latin-iso8859-1 #x72) + ("`u" latin-iso8859-1 #x79) + ("`w" latin-iso8859-14 #x38) + ("`y" latin-iso8859-14 #x3c) + ("~ " ascii #x7e) + ("~!" latin-iso8859-1 #x21) + ("~$" latin-iso8859-1 #x23) + ("~-" latin-iso8859-1 #x2d) + ("~." latin-iso8859-1 #x37) + ("~<" latin-iso8859-1 #x2b) + ("~=" latin-iso8859-1 #x2f) + ("~>" latin-iso8859-1 #x3b) + ("~?" latin-iso8859-1 #x3f) + ("~A" latin-iso8859-1 #x43) + ("~C" latin-iso8859-1 #x47) + ("~D" latin-iso8859-1 #x50) + ("~G" latin-iso8859-3 #x2b) + ("~N" latin-iso8859-1 #x51) + ("~O" latin-iso8859-1 #x55) + ("~O" latin-iso8859-2 #x55) + ("~S" latin-iso8859-3 #x2a) + ("~S" latin-iso8859-2 #x29) + ("~T" latin-iso8859-1 #x5e) + ("~U" latin-iso8859-3 #x5d) + ("~Z" latin-iso8859-2 #x2e) + ("~`" latin-iso8859-3 #x22) + ("~a" latin-iso8859-1 #x63) + ("~c" latin-iso8859-1 #x67) + ("~d" latin-iso8859-1 #x70) + ("~e" latin-iso8859-15 #x24) + ("~g" latin-iso8859-3 #x3b) + ("~n" latin-iso8859-1 #x71) + ("~o" latin-iso8859-1 #x75) + ("~p" latin-iso8859-1 #x36) + ("~s" latin-iso8859-1 #x27) + ("~S" latin-iso8859-3 #x2a) + ("~s" latin-iso8859-2 #x39) + ("~t" latin-iso8859-1 #x7e) + ("~u" latin-iso8859-1 #x35) + ("~u" latin-iso8859-3 #x7d) + ("~x" latin-iso8859-1 #x24) + ("~z" latin-iso8859-15 #x38) + ("~|" latin-iso8859-1 #x26) + ("~~" latin-iso8859-1 #x38)) + do (quail-defrule string (make-char charset code))) + +;; XEmacs change; added. +(quail-define-package + "latin-10-prefix" "Latin-10" "10>" t + (apply 'format + "Latin-10 (ISO 8859-16) characters input method with prefix modifiers + + effect | prefix | examples + ------------+--------+---------- + acute | ' | 'a -> %c + grave | ` | `a -> %c + circumflex | ^ | ^a -> %c + diaeresis | \" | \"a -> %c + breve | ~ | ~a -> %c + cedilla | , | ~c -> %c + ogonek | , | ,a -> %c + dbl. acute | : | :o -> %c + misc | ' , ~ | '' -> %c ,, -> %c ~< -> %c, ~D -> %c + | | ~s -> %c ~p -> %c +" + (mapcar (lambda (code) (make-char 'latin-iso8859-16 code)) + '(97 96 98 100 99 103 34 117 53 37 43 80 39 54))) + nil t nil nil nil nil nil nil nil nil t) + +(loop + for (string code) + in '((",A" #x21) + (",a" #x22) + ("/L" #x23) + ("~e" #x24) + (",," #x25) + ("~S" #x26) + ("/S" #x27) + ("~s" #x28) + (",S" #x2a) + ("~<" #x2b) + ("'Z" #x2c) + ("'z" #x2e) + (".Z" #x2f) + ("~C" #x32) + ("/l" #x33) + ("~Z" #x34) + ("''" #x35) + ("~p" #x36) + ("~." #x37) + ("~z" #x38) + ("~c" #x39) + (",s" #x3a) + ("~>" #x3b) + ("/O" #x3c) + ("/o" #x3d) + ("\"y" #x3e) + (".z" #x3f) + ("`A" #x40) + ("'A" #x41) + ("^A" #x42) + ("~A" #x43) + ("\"A" #x44) + ("'C" #x45) + ("/E" #x46) + (",C" #x47) + ("`E" #x48) + ("'E" #x49) + ("^E" #x4a) + ("\"E" #x4b) + ("`I" #x4c) + ("'I" #x4d) + ("^I" #x4e) + ("\"I" #x4f) + ("~D" #x50) + ("'N" #x51) + ("`O" #x52) + ("'O" #x53) + ("^O" #x54) + (":O" #x55) + ("\"O" #x56) + ("'S" #x57) + (":U" #x58) + ("`U" #x59) + ("'U" #x5a) + ("^U" #x5b) + ("\"U" #x5c) + (",E" #x5d) + (",T" #x5e) + ("/s" #x5f) + ("`a" #x60) + ("'a" #x61) + ("^a" #x62) + ("~a" #x63) + ("\"a" #x64) + ("'c" #x65) + ("/e" #x66) + (",c" #x67) + ("`e" #x68) + ("'e" #x69) + ("^e" #x6a) + ("\"e" #x6b) + ("`i" #x6c) + ("'i" #x6d) + ("^i" #x6e) + ("\"i" #x6f) + ("~d" #x70) + ("'n" #x71) + ("`o" #x72) + ("'o" #x73) + ("^o" #x74) + (":o" #x75) + ("\"o" #x76) + ("'s" #x77) + (":u" #x78) + ("`u" #x79) + ("'u" #x7a) + ("^u" #x7b) + ("\"u" #x7c) + (",e" #x7d) + (",t" #x7e) + ("\"y" #x7f)) + do (quail-defrule string (make-char 'latin-iso8859-16 code))) + +;; XEmacs change; added. +(quail-define-package + "latin-7-prefix" "Latin-7" "7>" t + (apply 'format + "Latin-7 (ISO 8859-13) characters input method with prefix modifiers + + effect | prefix | examples + ------------+--------+---------- + acute | ' | 'c -> %c, 'o -> %c + ogonek | , | ,a -> %c, ,u -> %c + macron | - | -o -> %c, -A -> %c + diaeresis | \" | \"u -> %c, \"o -> %c + h,Aa(B%cek | ~ | ~c -> %c, ~s -> %c + cedilla | , | ,k -> %c + misc | ~ ' , | ~+ -> %c, ~' -> %c [others] +" (mapcar (lambda (code) (make-char 'latin-iso8859-13 code)) + '(99 115 96 120 116 66 124 118 104 104 112 109 49 127))) + nil t nil nil nil nil nil nil nil nil t) + +(loop + for (string code) + in '(("''" #x21) + ("|c" #x22) + ("~L" #x23) + (",," #x25) + ("||" #x26) + ("/S" #x27) + ("/O" #x28) + ("~c" #x29) + ("~r" #x2a) + ("~<" #x2b) + ("~-" #x2c) + ("~-" #x2d) + ("~r" #x2e) + ("/E" #x2f) + ("_o" #x30) + ("~+" #x31) + ("^2" #x32) + ("^3" #x33) + ("``" #x34) + (",u" #x35) + ("~p" #x36) + ("~." #x37) + ("/o" #x38) + ("^1" #x39) + (",r" #x3a) + ("~>" #x3b) + ("/14" #x3c) + ("/12" #x3d) + ("/34" #x3e) + ("/e" #x3f) + (",A" #x40) + (",I" #x41) + ("-A" #x42) + ("'C" #x43) + ("\"A" #x44) + ("/A" #x45) + (",E" #x46) + ("-E" #x47) + ("~C" #x48) + ("'E" #x49) + ("'Z" #x4a) + (".E" #x4b) + (",G" #x4c) + (",K" #x4d) + ("-I" #x4e) + (",L" #x4f) + ("~S" #x50) + ("'N" #x51) + (",N" #x52) + ("'O" #x53) + ("-O" #x54) + ("~O" #x55) + ("\"O" #x56) + ("~x" #x57) + (",U" #x58) + ("/L" #x59) + ("'S" #x5a) + ("-U" #x5b) + ("\"U" #x5c) + (".Z" #x5d) + ("~Z" #x5e) + ("\"s" #x5f) + (",a" #x60) + (",i" #x61) + ("-a" #x62) + ("'c" #x63) + ("\"a" #x64) + ("/a" #x65) + (",e" #x66) + ("-e" #x67) + ("~c" #x68) + ("'e" #x69) + ("'z" #x6a) + (".e" #x6b) + ("'g" #x6c) + (",k" #x6d) + ("-i" #x6e) + (",l" #x6f) + ("~s" #x70) + ("'n" #x71) + (",n" #x72) + ("'o" #x73) + ("-o" #x74) + ("~o" #x75) + ("\"o" #x76) + ("/+" #x77) + (",u" #x78) + ("/l" #x79) + ("'s" #x7a) + ("-u" #x7b) + ("\"u" #x7c) + (".z" #x7d) + ("~z" #x7e) + ("~'" #x7f)) + do + (quail-defrule string (make-char 'latin-iso8859-13 code))) + +;; XEmacs change; added. +(quail-define-package + "latin-5-prefix" "Latin-5" "1>" t + "Latin-5 (ISO 8859-9) characters input method with prefix modifiers. + + effect | prefix | examples + ------------+--------+---------- + acute | ' | 'a -> ,Ma(B, '' -> ,M4(B + grave | ` | `a -> ,M`(B + circumflex | ^ | ^a -> ,Mb(B + diaeresis | \" | \"a -> ,Md(B, \"\" -> ,M((B + tilde | ~ | ~a -> ,Mc(B + cedilla | ~ | ~c -> ,Mg(B + misc | ---- | \"s -> ,M_(B, ~g -> ,Mp(B, ~s -> ,M~(B, /a -> ,Me(B, /e -> ,Mf(B, /o -> ,Mx(B + symbol | ~ | ~> -> ,M;(B, ~< -> ,M+(B, ~! -> ,M!(B, ~? -> ,M?(B, ~~ -> ,M8(B +" nil t nil nil nil nil nil nil nil nil t) + +(quail-define-rules + ("'A" ?,MA(B) + ("'E" ?,MI(B) + ("'I" ?,MM(B) + ("'O" ?,MS(B) + ("'U" ?,MZ(B) + ("'Y" ?,M](B) + ("'a" ?,Ma(B) + ("'e" ?,Mi(B) + ("'i" ?,Mm(B) + ("'o" ?,Ms(B) + ("'u" ?,Mz(B) + ("'y" ?,M}(B) + ("''" ?,M4(B) + ("' " ?') + ("`A" ?,M＠(B) + ("`E" ?,MH(B) + ("`I" ?,ML(B) + ("`O" ?,MR(B) + ("`U" ?,MY(B) + ("`a" ?,M`(B) + ("`e" ?,Mh(B) + ("`i" ?,Ml(B) + ("`o" ?,Mr(B) + ("`u" ?,My(B) + ("``" ?`) + ("` " ?`) + ("^A" ?,MB(B) + ("^E" ?,MJ(B) + ("^I" ?,MN(B) + ("^O" ?,MT(B) + ("^U" ?,M[(B) + ("^a" ?,Mb(B) + ("^e" ?,Mj(B) + ("^i" ?,Mn(B) + ("^o" ?,Mt(B) + ("^u" ?,M{(B) + ("^^" ?^) + ("^ " ?^) + ("\"A" ?,MD(B) + ("\"E" ?,MK(B) + ("\"I" ?,MO(B) + ("\"O" ?,MV(B) + ("\"U" ?,M\(B) + ("\"a" ?,Md(B) + ("\"e" ?,Mk(B) + ("\"i" ?,Mo(B) + ("\"o" ?,Mv(B) + ("\"s" ?,M_(B) + ("\"u" ?,M|(B) + ("\"y" ?,M(B) + ("\"\"" ?,M((B) + ("\" " ?\") + ("~A" ?,MC(B) + ("~C" ?,MG(B) + ("~G" ?,MP(B) + ("~N" ?,MQ(B) + ("~O" ?,MU(B) + ("~S" ?,M^(B) + ("~a" ?,Mc(B) + ("~c" ?,Mg(B) + ("~d" ?,Mp(B) + ("~n" ?,Mq(B) + ("~o" ?,Mu(B) + ("~s" ?,M~(B) + ("~>" ?\,M;(B) + ("~<" ?\,M+(B) + ("~!" ?,M!(B) + ("~?" ?,M?(B) + ("~~" ?,M8(B) + ("~ " ?~) + ("/A" ?,ME(B) + ("/E" ?,MF(B) + ("/O" ?,MX(B) + ("/a" ?,Me(B) + ("/e" ?,Mf(B) + ("/o" ?,Mx(B) + ("//" ?,M0(B) + ("/ " ? )) + +;; XEmacs change; added. +(quail-define-package + "latin-4-prefix" "Latin-4" "4>" t + "Latin-4 (ISO 8859-4) characters input method with prefix modifiers + + effect | prefix | examples + ------------+--------+---------- + acute | ' | 'a -> ,Da(B + macron | - | -a -> ,D`(B + circumflex | ^ | ^a -> ,Db(B + diaeresis | \" | \"a -> ,Dd(B + tilde | ~ | ~a -> ,Dc(B + cedilla | , | ~k -> ,Ds(B + ogonek | , | ,i -> ,Dg(B + Nordic | / | /a -> ,De(B, /e -> ,Df(B, /o -> ,Dx(B + misc | ' , ~ | '' -> ,D4(B ,. -> ,D2(B ,, -> ,D8(B + | | /S -> ,D'(B, ~x -> ,DW(B +" nil t nil nil nil nil nil nil nil nil t) + +(quail-define-rules + (",A" ?,D!(B) + ("~k" ?,D"(B) + (",R" ?,D#(B) + ("~I" ?,D%(B) + (",L" ?,D&(B) + ("/S" ?,D'(B) + ("\"\"" ?,D((B) + ("-E" ?,D*(B) + (",G" ?,D+(B) + ("-T" ?,D,(B) + ("~Z" ?,D.(B) + ("--" ?,D/(B) + (",." ?,D2(B) + (",r" ?,D3(B) + ("''" ?,D4(B) + ("~i" ?,D5(B) + (",l" ?,D6(B) + ("~~" ?,D7(B) + (",," ?,D8(B) + ("~s" ?,D9(B) + ("-e" ?,D:(B) + ("'g" ?,D;(B) + ("-t" ?,D<(B) + (",N" ?,D=(B) + ("~z" ?,D>(B) + (".n" ?,D?(B) + ("-A" ?,D＠(B) + ("'A" ?,DA(B) + ("^A" ?,DB(B) + ("~A" ?,DC(B) + ("\"A" ?,DD(B) + ("/A" ?,DE(B) + ("/E" ?,DF(B) + (",I" ?,DG(B) + ("~C" ?,DH(B) + ("'E" ?,DI(B) + (",E" ?,DJ(B) + ("\"E" ?,DK(B) + (".E" ?,DL(B) + ("'I" ?,DM(B) + ("^I" ?,DN(B) + ("-I" ?,DO(B) + ("~D" ?,DP(B) + (",N" ?,DQ(B) + ("-O" ?,DR(B) + (",K" ?,DS(B) + ("^O" ?,DT(B) + ("~O" ?,DU(B) + ("\"O" ?,DV(B) + ("~x" ?,DW(B) + ("/O" ?,DX(B) + (",U" ?,DY(B) + ("'U" ?,DZ(B) + ("^U" ?,D[(B) + ("\"U" ?,D\(B) + ("~U" ?,D](B) + ("-U" ?,D^(B) + ("/s" ?,D_(B) + ("-a" ?,D`(B) + ("'a" ?,Da(B) + ("^a" ?,Db(B) + ("~a" ?,Dc(B) + ("\"a" ?,Dd(B) + ("/a" ?,De(B) + ("/e" ?,Df(B) + (",i" ?,Dg(B) + ("~c" ?,Dh(B) + ("'e" ?,Di(B) + (",e" ?,Dj(B) + ("\"e" ?,Dk(B) + (".e" ?,Dl(B) + ("'i" ?,Dm(B) + ("^i" ?,Dn(B) + ("-i" ?,Do(B) + ("~d" ?,Dp(B) + (",n" ?,Dq(B) + ("-o" ?,Dr(B) + (",k" ?,Ds(B) + ("^o" ?,Dt(B) + ("~o" ?,Du(B) + ("\"o" ?,Dv(B) + ("~-" ?,Dw(B) + ("/o" ?,Dx(B) + (",u" ?,Dy(B) + ("'u" ?,Dz(B) + ("^u" ?,D{(B) + ("\"u" ?,D|(B) + ("~u" ?,D}(B) + ("-u" ?,D~(B) + (".." ?,D(B)) + + +;;; arch-tag: 83017837-6b84-4366-b183-e0577e3ed838 +;;; latin-pre.el ends here \ No newline at end of file Index: mule-base/mule-util.el =================================================================== RCS file: /pack/xemacscvs/XEmacs/packages/mule-packages/mule-base/mule-util.el,v retrieving revision 1.2 diff -u -u -r1.2 mule-util.el --- mule-base/mule-util.el 1999/07/23 06:55:11 1.2 +++ mule-base/mule-util.el 2007/05/20 19:15:00 ＠＠ -148,7 +148,7 ＠＠ Nested alist is a list of the form (ENTRY . BRANCHES), where ENTRY is any Lisp object, and BRANCHES is a list of cons cells of the form -(KEY-ELEMENT . NESTED-ALIST). +\(KEY-ELEMENT . NESTED-ALIST). You can use a nested alist to store any Lisp object (ENTRY) for a key sequence KEYSEQ, where KEYSEQ is a sequence of KEY-ELEMENT. KEYSEQ ＠＠ -182,9 +182,7 ＠＠ (setq i (1+ i))) (setcar alist entry) (if branches - (if (cdr alist) - (error "Can't set branches for keyseq %s" keyseq) - (setcdr alist branches))))) + (setcdr (last alist) branches)))) ;;;###autoload (defun lookup-nested-alist (keyseq alist &optional len start nil-for-too-long) -- On the quay of the little Black Sea port, where the rescued pair came once more into contact with civilization, Dobrinton was bitten by a dog which was assumed to be mad, though it may only have been indiscriminating. (Saki) _______________________________________________ XEmacs-Patches mailing list XEmacs-Patches(a)xemacs.org http://calypso.tux.org/cgi-bin/mailman/listinfo/xemacs-patches