|
155
|
1 ;;; mule-cmds.el --- Commands for mulitilingual environment
|
|
|
2
|
|
|
3 ;; Copyright (C) 1995 Free Software Foundation, Inc.
|
|
|
4 ;; Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
|
|
|
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 ;;; Code:
|
|
|
27
|
|
|
28 ;;; MULE related key bindings and menus.
|
|
|
29
|
|
|
30 (defvar mule-keymap (make-sparse-keymap "MULE")
|
|
|
31 "Keymap for MULE (Multilingual environment) specific commands.")
|
|
|
32 (fset 'mule-prefix mule-keymap)
|
|
|
33
|
|
165
|
34 ;; Keep "C-x C-m ..." for mule specific commands.
|
|
|
35 (define-key ctl-x-map "\C-m" 'mule-prefix)
|
|
155
|
36
|
|
165
|
37 ;; (defvar mule-describe-language-support-map
|
|
|
38 ;; (make-sparse-keymap "Describe Language Support"))
|
|
|
39 ;; (fset 'mule-describe-language-support-prefix
|
|
|
40 ;; mule-describe-language-support-map)
|
|
155
|
41
|
|
165
|
42 ;; (defvar mule-set-language-environment-map
|
|
|
43 ;; (make-sparse-keymap "Set Language Environment"))
|
|
|
44 ;; (fset 'mule-set-language-environment-prefix
|
|
|
45 ;; mule-set-language-environment-map)
|
|
155
|
46
|
|
|
47 (define-key mule-keymap "f" 'set-buffer-file-coding-system)
|
|
|
48 (define-key mule-keymap "F" 'set-default-buffer-file-coding-system) ; XEmacs
|
|
|
49 (define-key mule-keymap "t" 'set-terminal-coding-system)
|
|
|
50 (define-key mule-keymap "k" 'set-keyboard-coding-system)
|
|
|
51 (define-key mule-keymap "p" 'set-current-process-coding-system)
|
|
|
52 (define-key mule-keymap "P" 'set-default-process-coding-system) ; XEmacs
|
|
|
53 (define-key mule-keymap "i" 'select-input-method)
|
|
|
54 (define-key mule-keymap "c" 'list-coding-system-briefly) ; XEmacs
|
|
|
55 (define-key mule-keymap "C" 'list-coding-system) ; XEmacs
|
|
|
56 (define-key mule-keymap "r" 'toggle-display-direction) ; XEmacs
|
|
|
57
|
|
|
58 (define-key help-map "\C-L" 'describe-language-support)
|
|
|
59 (define-key help-map "\C-\\" 'describe-input-method)
|
|
|
60 (define-key help-map "C" 'describe-current-coding-system)
|
|
|
61 (define-key help-map "h" 'view-hello-file)
|
|
|
62
|
|
|
63 ;; Menu for XEmacs were moved to x11/x-menubar.el.
|
|
|
64
|
|
|
65
|
|
|
66 ;; This should be a single character key binding because users use it
|
|
|
67 ;; very frequently while editing multilingual text. Now we can use
|
|
|
68 ;; only two such keys: "\C-\\" and "\C-^", but the latter is not
|
|
|
69 ;; convenient because it requires shifting on most keyboards. An
|
|
|
70 ;; alternative is "\C-\]" which is now bound to `abort-recursive-edit'
|
|
|
71 ;; but it won't be used that frequently.
|
|
|
72 (define-key global-map "\C-\\" 'toggle-input-method)
|
|
|
73
|
|
|
74 (defun view-hello-file ()
|
|
|
75 "Display the HELLO file which list up many languages and characters."
|
|
|
76 (interactive)
|
|
165
|
77 ;; We have to decode the file in any environment.
|
|
|
78 (let ((coding-system-for-read 'iso-2022-7))
|
|
|
79 (find-file-read-only (expand-file-name "HELLO" data-directory))))
|
|
155
|
80
|
|
|
81
|
|
|
82 ;;; Language support staffs.
|
|
|
83
|
|
|
84 (defvar primary-language "English"
|
|
|
85 "Name of a user's primary language.
|
|
|
86 Emacs provide various language supports based on this variable.")
|
|
|
87
|
|
|
88 (defvar language-info-alist nil
|
|
|
89 "Alist of language names vs the corresponding information of various kind.
|
|
|
90 Each element looks like:
|
|
165
|
91 (LANGUAGE-NAME . ((KEY . INFO) ...))
|
|
155
|
92 where LANGUAGE-NAME is a string,
|
|
|
93 KEY is a symbol denoting the kind of information,
|
|
|
94 INFO is any Lisp object which contains the actual information related
|
|
|
95 to KEY.")
|
|
|
96
|
|
|
97 (defun get-language-info (language-name key)
|
|
|
98 "Return the information for LANGUAGE-NAME of the kind KEY.
|
|
|
99 LANGUAGE-NAME is a string.
|
|
|
100 KEY is a symbol denoting the kind of required information."
|
|
|
101 (let ((lang-slot (assoc language-name language-info-alist)))
|
|
|
102 (if lang-slot
|
|
165
|
103 (cdr (assq key (cdr lang-slot))))))
|
|
155
|
104
|
|
|
105 (defun set-language-info (language-name key info)
|
|
|
106 "Set for LANGUAGE-NAME the information INFO under KEY.
|
|
|
107 LANGUAGE-NAME is a string
|
|
|
108 KEY is a symbol denoting the kind of information.
|
|
|
109 INFO is any Lisp object which contains the actual information.
|
|
|
110
|
|
|
111 Currently, the following KEYs are used by Emacs:
|
|
|
112 charset: list of symbols whose values are charsets specific to the language.
|
|
|
113 coding-system: list of coding systems specific to the langauge.
|
|
|
114 tutorial: a tutorial file name written in the language.
|
|
|
115 sample-text: one line short text containing characters of the language.
|
|
|
116 input-method: alist of input method names for the language vs information
|
|
|
117 for activating them. Use `register-input-method' (which see)
|
|
|
118 to add a new input method to the alist.
|
|
165
|
119 documentation: a string describing how Emacs supports the langauge.
|
|
|
120 describe-function: a function to call for descriebing how Emacs supports
|
|
|
121 the language. The function uses information listed abobe.
|
|
|
122 setup-function: a function to call for setting up environment
|
|
|
123 convenient for the language.
|
|
155
|
124
|
|
165
|
125 Emacs will use more KEYs in the future. To avoid conflict, users
|
|
|
126 should use prefix \"user-\" in the name of KEY if he wants to set
|
|
|
127 different kind of information."
|
|
155
|
128 (let (lang-slot key-slot)
|
|
|
129 (setq lang-slot (assoc language-name language-info-alist))
|
|
165
|
130 (if (null lang-slot) ; If no slot for the language, add it.
|
|
|
131 (setq lang-slot (list language-name)
|
|
|
132 language-info-alist (cons lang-slot language-info-alist)))
|
|
155
|
133 (setq key-slot (assq key lang-slot))
|
|
165
|
134 (if (null key-slot) ; If no slot for the key, add it.
|
|
|
135 (progn
|
|
|
136 (setq key-slot (list key))
|
|
|
137 (setcdr lang-slot (cons key-slot (cdr lang-slot)))))
|
|
155
|
138 (setcdr key-slot info)
|
|
|
139 ;; Setup menu.
|
|
165
|
140 (cond ((eq key 'describe-function)
|
|
|
141 ;; (define-key-after mule-describe-language-support-map
|
|
|
142 ;; (vector (intern language-name))
|
|
|
143 ;; (cons language-name info)
|
|
|
144 ;; t)
|
|
|
145 (eval-after-load "x-menubar"
|
|
|
146 `(add-menu-button '("Mule" "Describe Language Support")
|
|
|
147 (vector ,language-name ',info t)))
|
|
|
148 )
|
|
|
149 ((eq key 'setup-function)
|
|
|
150 ;; (define-key-after mule-set-language-environment-map
|
|
|
151 ;; (vector (intern language-name))
|
|
|
152 ;; (cons language-name info)
|
|
|
153 ;; t)
|
|
|
154 (eval-after-load "x-menubar"
|
|
|
155 `(add-menu-button '("Mule" "Set Language Environment")
|
|
|
156 (vector ,language-name ',info t)))
|
|
|
157 ))
|
|
155
|
158 ))
|
|
|
159
|
|
|
160 (defun set-language-info-alist (language-name alist)
|
|
|
161 "Set for LANGUAGE-NAME the information in ALIST.
|
|
|
162 ALIST is an alist of KEY and INFO. See the documentation of
|
|
|
163 `set-langauge-info' for the meanings of KEY and INFO."
|
|
|
164 (while alist
|
|
|
165 (set-language-info language-name (car (car alist)) (cdr (car alist)))
|
|
|
166 (setq alist (cdr alist))))
|
|
|
167
|
|
|
168 (defun read-language-name (key prompt &optional initial-input)
|
|
|
169 "Read language name which has information for KEY, prompting with PROMPT."
|
|
|
170 (let* ((completion-ignore-case t)
|
|
165
|
171 (name (completing-read prompt
|
|
|
172 language-info-alist
|
|
|
173 (function (lambda (elm) (assq key elm)))
|
|
|
174 t
|
|
|
175 initial-input)))
|
|
155
|
176 (and (> (length name) 0)
|
|
165
|
177 (car (assoc-ignore-case (downcase name) language-info-alist)))))
|
|
155
|
178
|
|
|
179 ;;; Multilingual input methods.
|
|
|
180
|
|
|
181 (defvar current-input-method nil
|
|
|
182 "The current input method for multilingual text.
|
|
|
183 The value is a cons of language name and input method name.
|
|
|
184 If nil, it means no input method is activated now.")
|
|
|
185 (make-variable-buffer-local 'current-input-method)
|
|
|
186 (put 'current-input-method 'permanent-local t)
|
|
|
187
|
|
|
188 (defvar current-input-method-title nil
|
|
|
189 "Title string of the current input method shown in mode line.
|
|
165
|
190 Every input method should set this to an appropriate value when activated.")
|
|
155
|
191 (make-variable-buffer-local 'current-input-method-title)
|
|
|
192 (put 'current-input-method-title 'permanent-local t)
|
|
|
193
|
|
|
194 (defvar default-input-method nil
|
|
|
195 "Default input method.
|
|
|
196 The default input method is the one activated automatically by the command
|
|
|
197 `toggle-input-method' (\\[toggle-input-method]).
|
|
|
198 The value is a cons of language name and input method name.")
|
|
|
199
|
|
|
200 (defvar default-input-method-title nil
|
|
|
201 "Title string of the default input method.")
|
|
|
202
|
|
|
203 (defvar previous-input-method nil
|
|
|
204 "Input method selected previously.
|
|
|
205 This is the one selected before the current input method is selected.
|
|
|
206 See also the documentation of `default-input-method'.")
|
|
|
207
|
|
|
208 (defvar inactivate-current-input-method-function nil
|
|
|
209 "Function to call for inactivating the current input method.
|
|
|
210 Every input method should set this to an appropriate value when activated.
|
|
|
211 This function is called with no argument.")
|
|
|
212 (make-variable-buffer-local 'inactivate-current-input-method-function)
|
|
|
213 (put 'inactivate-current-input-method-function 'permanent-local t)
|
|
|
214
|
|
|
215 (defvar describe-current-input-method-function nil
|
|
|
216 "Function to call for describing the current input method.
|
|
|
217 This function is called with no argument.")
|
|
|
218 (make-variable-buffer-local 'describe-current-input-method-function)
|
|
|
219 (put 'describe-current-input-method-function 'permanent-local t)
|
|
|
220
|
|
|
221 (defun register-input-method (language-name input-method)
|
|
|
222 "Register INPUT-METHOD as an input method of LANGUAGE-NAME.
|
|
|
223 LANGUAGE-NAME is a string.
|
|
|
224 INPUT-METHOD is a list of the form:
|
|
165
|
225 (METHOD-NAME ACTIVATE-FUNC ARG ...)
|
|
155
|
226 where METHOD-NAME is the name of this method,
|
|
|
227 ACTIVATE-FUNC is the function to call for activating this method.
|
|
|
228 Arguments for the function are METHOD-NAME and ARGs."
|
|
|
229 (let ((slot (get-language-info language-name 'input-method))
|
|
|
230 method-slot)
|
|
|
231 (if (null slot)
|
|
|
232 (set-language-info language-name 'input-method (list input-method))
|
|
|
233 (setq method-slot (assoc (car input-method) slot))
|
|
|
234 (if method-slot
|
|
|
235 (setcdr method-slot (cdr input-method))
|
|
|
236 (set-language-info language-name 'input-method
|
|
|
237 (cons input-method slot))))))
|
|
|
238
|
|
|
239 (defun read-language-and-input-method-name ()
|
|
|
240 "Read a language names and the corresponding input method from a minibuffer.
|
|
|
241 Return a cons of those names."
|
|
|
242 (let ((language-name (read-language-name
|
|
165
|
243 'input-method
|
|
|
244 "Language: "
|
|
|
245 (if previous-input-method
|
|
|
246 (cons (car previous-input-method) 0)))))
|
|
155
|
247 (if (null language-name)
|
|
165
|
248 (error "No input method for the specified language"))
|
|
155
|
249 (let* ((completion-ignore-case t)
|
|
165
|
250 (key-slot (cdr (assq 'input-method
|
|
|
251 (assoc language-name language-info-alist))))
|
|
|
252 (method-name
|
|
|
253 (completing-read "Input method: " key-slot nil t
|
|
|
254 (if (and previous-input-method
|
|
|
255 (string= language-name
|
|
|
256 (car previous-input-method)))
|
|
|
257 (cons (cdr previous-input-method) 0)))))
|
|
155
|
258 (if (= (length method-name) 0)
|
|
165
|
259 (error "No input method specified"))
|
|
155
|
260 (list language-name
|
|
165
|
261 (car (assoc-ignore-case (downcase method-name) key-slot))))))
|
|
155
|
262
|
|
|
263 (defun set-default-input-method (language-name method-name)
|
|
|
264 "Set the default input method to METHOD-NAME for inputting LANGUAGE-NAME.
|
|
|
265 The default input method is the one activated automatically by the command
|
|
|
266 `toggle-input-method' (\\[toggle-input-method]).
|
|
|
267 This doesn't affect the currently activated input method."
|
|
|
268 (interactive (read-language-and-input-method-name))
|
|
|
269 (let* ((key-slot (get-language-info language-name 'input-method))
|
|
|
270 (method-slot (assoc method-name key-slot)))
|
|
|
271 (if (null method-slot)
|
|
|
272 (error "No input method `%s' for %s" method-name language-name))
|
|
|
273 (setq default-input-method (cons language-name method-name))))
|
|
|
274
|
|
|
275 (defun select-input-method (language-name method-name)
|
|
|
276 "Select and activate input method METHOD-NAME for inputting LANGUAGE-NAME.
|
|
|
277 The information for activating METHOD-NAME is stored
|
|
|
278 in `language-info-alist' under the key 'input-method.
|
|
|
279 The format of the information has the form:
|
|
165
|
280 ((METHOD-NAME ACTIVATE-FUNC ARG ...) ...)
|
|
155
|
281 where ACTIVATE-FUNC is a function to call for activating this method.
|
|
|
282 Arguments for the function are METHOD-NAME and ARGs."
|
|
|
283 (interactive (read-language-and-input-method-name))
|
|
|
284 (let* ((key-slot (get-language-info language-name 'input-method))
|
|
165
|
285 (method-slot (assoc method-name key-slot)))
|
|
155
|
286 (if (null method-slot)
|
|
165
|
287 (error "No input method `%s' for %s" method-name language-name))
|
|
155
|
288 (if current-input-method
|
|
165
|
289 (progn
|
|
|
290 (if (not (equal previous-input-method current-input-method))
|
|
|
291 (setq previous-input-method current-input-method))
|
|
|
292 (funcall inactivate-current-input-method-function)))
|
|
155
|
293 (setq method-slot (cdr method-slot))
|
|
|
294 (apply (car method-slot) method-name (cdr method-slot))
|
|
|
295 (setq default-input-method
|
|
165
|
296 (setq current-input-method (cons language-name method-name)))
|
|
155
|
297 (setq default-input-method-title current-input-method-title)
|
|
|
298 (setq current-input-method default-input-method)))
|
|
|
299
|
|
|
300 (defun toggle-input-method (&optional arg)
|
|
|
301 "Toggle whether a multilingual input method is activated in this buffer.
|
|
|
302 With arg, activate an input method specified interactively.
|
|
|
303 Without arg, the method being activated is the one selected most recently,
|
|
|
304 but if no input method has ever been selected, select one interactively."
|
|
|
305 (interactive "P")
|
|
|
306 (if arg
|
|
|
307 (call-interactively 'select-input-method)
|
|
|
308 (if (null current-input-method)
|
|
|
309 (if default-input-method
|
|
|
310 (select-input-method (car default-input-method)
|
|
|
311 (cdr default-input-method))
|
|
|
312 (call-interactively 'select-input-method))
|
|
|
313 (funcall inactivate-current-input-method-function)
|
|
|
314 (setq current-input-method nil))))
|
|
|
315
|
|
|
316 (defun describe-input-method ()
|
|
|
317 "Describe the current input method."
|
|
|
318 (interactive)
|
|
|
319 (if current-input-method
|
|
|
320 (if (and (symbolp describe-current-input-method-function)
|
|
165
|
321 (fboundp describe-current-input-method-function))
|
|
155
|
322 (funcall describe-current-input-method-function)
|
|
|
323 (message "No way to describe the current input method `%s'"
|
|
|
324 (cdr current-input-method))
|
|
|
325 (ding))
|
|
|
326 (message "No input method is activated now")
|
|
|
327 (ding)))
|
|
|
328
|
|
165
|
329 (defun read-multilingual-string (prompt &optional initial-input
|
|
|
330 language-name method-name)
|
|
|
331 "Read a multilingual string from minibuffer, prompting with string PROMPT.
|
|
|
332 The input method selected last time is activated in minibuffer.
|
|
|
333 If non-nil, second arg INITIAL-INPUT is a string to insert before reading.
|
|
|
334 Optional 3rd and 4th arguments LANGUAGE-NAME and METHOD-NAME specify
|
|
|
335 the input method to be activated instead of the one selected last time."
|
|
|
336 (let ((minibuffer-setup-hook '(toggle-input-method))
|
|
|
337 (default-input-method default-input-method))
|
|
|
338 (if (and language-name method-name)
|
|
|
339 (set-default-input-method language-name method-name))
|
|
|
340 (read-string prompt initial-input)))
|
|
155
|
341
|
|
|
342 ;; Variables to control behavior of input methods. All input methods
|
|
|
343 ;; should react to these variables.
|
|
|
344
|
|
|
345 (defvar input-method-tersely-flag nil
|
|
|
346 "*If this flag is non-nil, input method works rather tersely.
|
|
|
347
|
|
|
348 For instance, Quail input method does not show guidance buffer while
|
|
|
349 inputting at minibuffer if this flag is t.")
|
|
|
350
|
|
165
|
351 (defvar input-method-activate-hook nil
|
|
|
352 "Normal hook run just after an input method is activated.")
|
|
155
|
353
|
|
165
|
354 (defvar input-method-inactivate-hook nil
|
|
|
355 "Normal hook run just after an input method is inactivated.")
|
|
155
|
356
|
|
165
|
357 (defvar input-method-after-insert-chunk-hook nil
|
|
|
358 "Normal hook run just after an input method insert some chunk of text.")
|
|
155
|
359
|
|
|
360
|
|
|
361 ;;; Language specific setup functions.
|
|
|
362 ;; (defun set-language-environment (language-name)
|
|
|
363 ;; "Setup a user's environment for LANGUAGE-NAME.
|
|
|
364 ;;
|
|
|
365 ;; To setup, a fucntion returned by:
|
|
|
366 ;; (get-language-info LANGUAGE-NAME 'setup-function)
|
|
|
367 ;; is called."
|
|
|
368 ;; (interactive (list (read-language-name 'setup-function "Language: ")))
|
|
|
369 ;; (let (func)
|
|
|
370 ;; (if (or (null language-name)
|
|
|
371 ;; (null (setq func
|
|
|
372 ;; (get-language-info language-name 'setup-function))))
|
|
|
373 ;; (error "No way to setup environment for the specified language"))
|
|
|
374 ;; (funcall func)))
|
|
|
375
|
|
|
376 ;; Print all arguments with `princ', then print "\n".
|
|
|
377 (defsubst princ-list (&rest args)
|
|
|
378 (while args (princ (car args)) (setq args (cdr args)))
|
|
|
379 (princ "\n"))
|
|
|
380
|
|
|
381 (defun describe-language-support (language-name)
|
|
165
|
382 "Describe how Emacs supports LANGUAGE-NAME.
|
|
|
383
|
|
|
384 For that, a function returned by:
|
|
|
385 (get-language-info LANGUAGE-NAME 'describe-function)
|
|
|
386 is called."
|
|
155
|
387 (interactive (list (read-language-name 'documentation "Language: ")))
|
|
165
|
388 (let (func)
|
|
155
|
389 (if (or (null language-name)
|
|
165
|
390 (null (setq func
|
|
|
391 (get-language-info language-name 'describe-function))))
|
|
155
|
392 (error "No documentation for the specified language"))
|
|
165
|
393 (funcall func)))
|
|
|
394
|
|
|
395 ;; Print LANGUAGE-NAME specific information such as input methods,
|
|
|
396 ;; charsets, and coding systems. This function is intended to be
|
|
|
397 ;; called from various describe-LANGUAGE-support functions defined in
|
|
|
398 ;; lisp/language/LANGUAGE.el.
|
|
|
399 (defun describe-language-support-internal (language-name)
|
|
|
400 (with-output-to-temp-buffer "*Help*"
|
|
|
401 (let ((doc (get-language-info language-name 'documentation)))
|
|
|
402 (if (stringp doc)
|
|
|
403 (princ-list doc)))
|
|
|
404 (princ "-----------------------------------------------------------\n")
|
|
|
405 (princ-list "List of items specific to "
|
|
|
406 language-name
|
|
|
407 " support")
|
|
|
408 (princ "-----------------------------------------------------------\n")
|
|
|
409 (let ((str (get-language-info language-name 'sample-text)))
|
|
|
410 (if (stringp str)
|
|
|
411 (progn
|
|
|
412 (princ "<sample text>\n")
|
|
|
413 (princ-list " " str))))
|
|
|
414 (princ "<input methods>\n")
|
|
|
415 (let ((l (get-language-info language-name 'input-method)))
|
|
|
416 (while l
|
|
|
417 (princ-list " " (car (car l)))
|
|
|
418 (setq l (cdr l))))
|
|
|
419 (princ "<character sets>\n")
|
|
|
420 (let ((l (get-language-info language-name 'charset)))
|
|
|
421 (if (null l)
|
|
|
422 (princ-list " nothing specific to " language-name)
|
|
|
423 (while l
|
|
|
424 (princ-list " " (car l) ": "
|
|
|
425 (charset-description (car l)))
|
|
|
426 (setq l (cdr l)))))
|
|
|
427 (princ "<coding systems>\n")
|
|
|
428 (let ((l (get-language-info language-name 'coding-system)))
|
|
|
429 (if (null l)
|
|
|
430 (princ-list " nothing specific to " language-name)
|
|
|
431 (while l
|
|
|
432 (princ-list " " (car l) ":\n\t"
|
|
|
433 (coding-system-docstring (car l)))
|
|
|
434 (setq l (cdr l)))))))
|
|
155
|
435
|
|
|
436 ;;; Charset property
|
|
|
437
|
|
|
438 ;; (defsubst get-charset-property (charset propname)
|
|
|
439 ;; "Return the value of CHARSET's PROPNAME property.
|
|
|
440 ;; This is the last value stored with
|
|
|
441 ;; `(put-charset-property CHARSET PROPNAME VALUE)'."
|
|
|
442 ;; (plist-get (charset-plist charset) propname))
|
|
|
443
|
|
|
444 ;; (defsubst put-charset-property (charset propname value)
|
|
|
445 ;; "Store CHARSETS's PROPNAME property with value VALUE.
|
|
|
446 ;; It can be retrieved with `(get-charset-property CHARSET PROPNAME)'."
|
|
|
447 ;; (set-charset-plist charset
|
|
|
448 ;; (plist-put (charset-plist charset) propname value)))
|
|
|
449
|
|
|
450 ;;; Character code property
|
|
|
451 ;; (put 'char-code-property-table 'char-table-extra-slots 0)
|
|
|
452
|
|
|
453 ;; (defvar char-code-property-table
|
|
|
454 ;; (make-char-table 'char-code-property-table)
|
|
|
455 ;; "Char-table containing a property list of each character code.
|
|
|
456 ;;
|
|
|
457 ;; See also the documentation of `get-char-code-property' and
|
|
|
458 ;; `put-char-code-property'")
|
|
|
459
|
|
|
460 ;; (defun get-char-code-property (char propname)
|
|
|
461 ;; "Return the value of CHAR's PROPNAME property in `char-code-property-table'."
|
|
|
462 ;; (let ((plist (aref char-code-property-table char)))
|
|
|
463 ;; (if (listp plist)
|
|
|
464 ;; (car (cdr (memq propname plist))))))
|
|
|
465
|
|
|
466 ;; (defun put-char-code-property (char propname value)
|
|
|
467 ;; "Store CHAR's PROPNAME property with VALUE in `char-code-property-table'.
|
|
|
468 ;; It can be retrieved with `(get-char-code-property CHAR PROPNAME)'."
|
|
|
469 ;; (let ((plist (aref char-code-property-table char)))
|
|
|
470 ;; (if plist
|
|
|
471 ;; (let ((slot (memq propname plist)))
|
|
|
472 ;; (if slot
|
|
|
473 ;; (setcar (cdr slot) value)
|
|
|
474 ;; (nconc plist (list propname value))))
|
|
|
475 ;; (aset char-code-property-table char (list propname value)))))
|
|
|
476
|
|
|
477 ;;; mule-cmds.el ends here
|
