Mercurial > hg > xemacs-beta

comparison lisp/mule/auto-autoloads.el @ 165:5a88923fcbfe r20-3b9

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Import from CVS: tag r20-3b9
author cvs
date Mon, 13 Aug 2007 09:44:42 +0200
parents
children 85ec50267440
comparison
equal deleted inserted replaced
164:4e0740e5aab2 165:5a88923fcbfe
1 ;;; DO NOT MODIFY THIS FILE
2 (if (not (featurep 'mule-autoloads))
3 (progn
4
5 ;;;### (autoloads (isearch-fep-quail isearch-fep-canna isearch-fep-egg isearch-fep-string) "isearch-mule" "mule/isearch-mule.el")
6
7 (defvar search-string-char-prompt "*Enter string... ")
8
9 (autoload 'isearch-fep-string "isearch-mule" "\
10 Read string from minibuffer for incremental search." t nil)
11
12 (autoload 'isearch-fep-egg "isearch-mule" "\
13 Read string for incremental search by using egg." t nil)
14
15 (autoload 'isearch-fep-canna "isearch-mule" "\
16 Read string for incremental search by using canna." t nil)
17
18 (autoload 'isearch-fep-quail "isearch-mule" "\
19 Read string for incremental search by using quail." t nil)
20
21 ;;;***
22
23 ;;;### (autoloads (define-ccl-program ccl-dump ccl-compile ccl-program-p) "mule-ccl" "mule/mule-ccl.el")
24
25 (autoload 'ccl-program-p "mule-ccl" "\
26 T if OBJECT is a valid CCL compiled code." nil nil)
27
28 (autoload 'ccl-compile "mule-ccl" "\
29 Compile a CCL source program and return the compiled equivalent.
30 The return value will be a vector of integers." nil nil)
31
32 (autoload 'ccl-dump "mule-ccl" "\
33 Disassemble compiled CCL-CODE." nil nil)
34
35 (autoload 'define-ccl-program "mule-ccl" "\
36 Does (defconst NAME (ccl-compile (eval CCL-PROGRAM)) DOC).
37 Byte-compiler expand this macro while compiling." nil 'macro)
38
39 ;;;***
40
41 ;;;### (autoloads (dump-coding-systems dump-charsets mule-diag list-fontset describe-fontset list-font describe-font list-coding-system list-coding-system-briefly describe-coding-system list-charsets) "mule-debug" "mule/mule-debug.el")
42
43 (autoload 'list-charsets "mule-debug" "\
44 Display a list of existing character sets." t nil)
45
46 (autoload 'describe-coding-system "mule-debug" "\
47 Display documentation of the coding-system CS." t nil)
48
49 (autoload 'list-coding-system-briefly "mule-debug" "\
50 Display coding-systems currently used with a brief format in mini-buffer." t nil)
51
52 (autoload 'list-coding-system "mule-debug" "\
53 Describe coding-systems currently used with a detailed format.
54 If optional arg ALL is non-nil, all coding-systems are listed in
55 machine readable simple format." t nil)
56
57 (autoload 'describe-font "mule-debug" "\
58 Display information about fonts which partially match FONTNAME." t nil)
59
60 (autoload 'list-font "mule-debug" "\
61 Display a list of fonts." t nil)
62
63 (autoload 'describe-fontset "mule-debug" "\
64 Display information about FONTSET." t nil)
65
66 (autoload 'list-fontset "mule-debug" "\
67 Display a list of fontsets." t nil)
68
69 (autoload 'mule-diag "mule-debug" "\
70 Show diagnosis of the current running Mule." t nil)
71
72 (autoload 'dump-charsets "mule-debug" nil nil nil)
73
74 (autoload 'dump-coding-systems "mule-debug" nil nil nil)
75
76 ;;;***
77
78 ;;;### (autoloads (set-keyboard-coding-system) "mule-keyboard" "mule/mule-keyboard.el")
79
80 (defvar keyboard-allow-latin-input nil "\
81 If non-nil, \"ESC , Fe\" and \"ESC - Fe\" are used for inputting
82 Latin characters.")
83
84 (autoload 'set-keyboard-coding-system "mule-keyboard" "\
85 Set variable keyboard-coding-system to CODESYS and modify keymap for it." t nil)
86
87 ;;;***
88
89 ;;;### (autoloads (define-word-regexp regexp-word-compile regexp-compile) "mule-trex" "mule/mule-trex.el")
90
91 (autoload 'regexp-compile "mule-trex" nil nil nil)
92
93 (autoload 'regexp-word-compile "mule-trex" nil nil nil)
94
95 (autoload 'define-word-regexp "mule-trex" nil nil 'macro)
96
97 ;;;***
98
99 ;;;### (autoloads (decompose-composite-char compose-chars decompose-region compose-region set-coding-system-alist lookup-nested-alist set-nested-alist truncate-string-to-width store-substring) "mule-util" "mule/mule-util.el")
100
101 (defsubst string-to-sequence (string type) "Convert STRING to a sequence of TYPE which contains characters in STRING.\nTYPE should be `list' or `vector'.\nMultibyte characters are conserned." (map type (function identity) string))
102
103 (defsubst string-to-list (string) "Return a list of characters in STRING." (mapcar (function identity) string))
104
105 (defsubst string-to-vector (string) "Return a vector of characters in STRING." (string-to-sequence string 'vector))
106
107 (autoload 'store-substring "mule-util" "\
108 Embed OBJ (string or character) at index IDX of STRING." nil nil)
109
110 (autoload 'truncate-string-to-width "mule-util" "\
111 Truncate string STR to fit in WIDTH columns.
112 Optional 1st arg START-COLUMN if non-nil specifies the starting column.
113 Optional 2nd arg PADDING if non-nil is a padding character to be padded at
114 the head and tail of the resulting string to fit in WIDTH if necessary.
115 If PADDING is nil, the resulting string may be narrower than WIDTH." nil nil)
116
117 (defalias 'truncate-string 'truncate-string-to-width)
118
119 (defsubst nested-alist-p (obj) "Return t if OBJ is a nesetd alist.\n\nNested alist is a list of the form (ENTRY . BRANCHES), where ENTRY is\nany Lisp object, and BRANCHES is a list of cons cells of the form\n(KEY-ELEMENT . NESTED-ALIST).\n\nYou can use a nested alist to store any Lisp object (ENTRY) for a key\nsequence KEYSEQ, where KEYSEQ is a sequence of KEY-ELEMENT. KEYSEQ\ncan be a string, a vector, or a list." (and obj (listp obj) (listp (cdr obj))))
120
121 (autoload 'set-nested-alist "mule-util" "\
122 Set ENTRY for KEYSEQ in a nested alist ALIST.
123 Optional 4th arg LEN non-nil means the firlst LEN elements in KEYSEQ
124 is considered.
125 Optional argument BRANCHES if non-nil is branches for a keyseq
126 longer than KEYSEQ.
127 See the documentation of `nested-alist-p' for more detail." nil nil)
128
129 (autoload 'lookup-nested-alist "mule-util" "\
130 Look up key sequence KEYSEQ in nested alist ALIST. Return the definition.
131 Optional 1st argument LEN specifies the length of KEYSEQ.
132 Optional 2nd argument START specifies index of the starting key.
133 The returned value is normally a nested alist of which
134 car part is the entry for KEYSEQ.
135 If ALIST is not deep enough for KEYSEQ, return number which is
136 how many key elements at the front of KEYSEQ it takes
137 to reach a leaf in ALIST.
138 Optional 3rd argument NIL-FOR-TOO-LONG non-nil means return nil
139 even if ALIST is not deep enough." nil nil)
140
141 (autoload 'set-coding-system-alist "mule-util" "\
142 Update `coding-system-alist' according to the arguments.
143 TARGET-TYPE specifies a type of the target: `file', `process', or `network'.
144 TARGET-TYPE tells which slots of coding-system-alist should be affected.
145 If `file', it affects slots for insert-file-contents and write-region.
146 If `process', it affects slots for call-process, call-process-region, and
147 start-process.
148 If `network', it affects a slot for open-network-process.
149 REGEXP is a regular expression matching a target of I/O operation.
150 CODING-SYSTEM is a coding system to perform code conversion
151 on the I/O operation, or a cons of coding systems for decoding and
152 encoding respectively, or a function symbol which returns the cons.
153 Optional arg OPERATION if non-nil specifies directly one of slots above.
154 The valid value is: insert-file-contents, write-region,
155 call-process, call-process-region, start-process, or open-network-stream.
156 If OPERATION is specified, TARGET-TYPE is ignored.
157 See the documentation of `coding-system-alist' for more detail." nil nil)
158
159 (autoload 'compose-region "mule-util" "\
160 Compose characters in the current region into one composite character.
161 From a Lisp program, pass two arguments, START to END.
162 The composite character replaces the composed characters.
163 BUFFER defaults to the current buffer if omitted." t nil)
164
165 (autoload 'decompose-region "mule-util" "\
166 Decompose any composite characters in the current region.
167 From a Lisp program, pass two arguments, START to END.
168 This converts each composite character into one or more characters,
169 the individual characters out of which the composite character was formed.
170 Non-composite characters are left as-is. BUFFER defaults to the current
171 buffer if omitted." t nil)
172
173 (defconst reference-point-alist '((tl . 0) (tc . 1) (tr . 2) (ml . 3) (mc . 4) (mr . 5) (bl . 6) (bc . 7) (br . 8) (top-left . 0) (top-center . 1) (top-right . 2) (mid-left . 3) (mid-center . 4) (mid-right . 5) (bottom-left . 6) (bottom-center . 7) (bottom-right . 8) (0 . 0) (1 . 1) (2 . 2) (3 . 3) (4 . 4) (5 . 5) (6 . 6) (7 . 7) (8 . 8)) "\
174 Alist of reference point symbols vs reference point codes.
175 Meanings of reference point codes are as follows:
176
177 0----1----2 <-- ascent 0:tl or top-left
178 | | 1:tc or top-center
179 | | 2:tr or top-right
180 | | 3:ml or mid-left
181 | 4 <--+---- center 4:mc or mid-center
182 | | 5:mr or mid-right
183 --- 3 5 <-- baseline 6:bl or bottom-left
184 | | 7:bc or bottom-center
185 6----7----8 <-- descent 8:br or bottom-right
186
187 Reference point symbols are to be used to specify composition rule of
188 the form (GLOBAL-REF-POINT . NEW-REF-POINT), where GLOBAL-REF-POINT
189 is a reference point in the overall glyphs already composed, and
190 NEW-REF-POINT is a reference point in the new glyph to be added.
191
192 For instance, if GLOBAL-REF-POINT is 8 and NEW-REF-POINT is 1, the
193 overall glyph is updated as follows:
194
195 +-------+--+ <--- new ascent
196 | | |
197 | global| |
198 | glyph | |
199 --- | | | <--- baseline (doesn't change)
200 +----+--+--+
201 | | new |
202 | |glyph|
203 +----+-----+ <--- new descent
204 ")
205
206 (autoload 'compose-chars "mule-util" "\
207 Return one char string composed from the arguments.
208 Each argument is a character (including a composite chararacter)
209 or a composition rule.
210 A composition rule has the form (GLOBAL-REF-POINT . NEW-REF-POINT).
211 See the documentation of `reference-point-alist' for more detail." nil nil)
212
213 (autoload 'decompose-composite-char "mule-util" "\
214 Convert composite character CHAR to a string containing components of CHAR.
215 Optional 1st arg TYPE specifies the type of sequence returned.
216 It should be `string' (default), `list', or `vector'.
217 Optional 2nd arg WITH-COMPOSITION-RULE non-nil means the returned
218 sequence contains embedded composition rules if any. In this case, the
219 order of elements in the sequence is the same as arguments for
220 `compose-chars' to create CHAR.
221 If TYPE is omitted or is `string', composition rules are omitted
222 even if WITH-COMPOSITION-RULE is t." nil nil)
223
224 ;;;***
225
226 ;;;### (autoloads (vn-decompose-viqr-buffer vn-decompose-viqr vn-compose-viqr-buffer vn-compose-viqr) "vietnamese" "mule/vietnamese.el")
227
228 (autoload 'vn-compose-viqr "vietnamese" "\
229 Convert 'VIQR' mnemonics of the current region to
230 pre-composed Vietnamese characaters." t nil)
231
232 (autoload 'vn-compose-viqr-buffer "vietnamese" nil t nil)
233
234 (autoload 'vn-decompose-viqr "vietnamese" "\
235 Convert pre-composed Vietnamese characaters of the current region to
236 'VIQR' mnemonics." t nil)
237
238 (autoload 'vn-decompose-viqr-buffer "vietnamese" nil t nil)
239
240 ;;;***
241
242 (provide 'mule-autoloads)
243 ))