Mercurial > hg > xemacs-beta
annotate src/mule-charset.c @ 4844:91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
dynarr.c: Add comment explaining Dynarr_largest() use.
dynarr.c: In Dynarr_insert_many(), don't call Dynarr_resize() unless we
actually need to resize, and note that an assert() that we are
inserting at or below the current end could be wrong if code
wants to access stuff between `len' and `largest'.
dynarr.c: Don't just Dynarr_resize() to the right size; instead use
Dynarr_reset() then Dynarr_add_many(), so that the 'len' and
'largest' and such get set properly.
dynarr.c, faces.c, gutter.c, lisp.h, lread.c, lrecord.h, redisplay-output.c, redisplay.c: Rename Dynarr member 'cur' to 'len' since it's the length of
the dynarr, not really a pointer to a "current insertion point".
Use type_checking_assert() instead of just assert() in some places.
Add additional assertions (Dynarr_verify*()) to check that we're
being given positions within range. Use them in Dynarr_at,
Dynarr_atp, etc. New Dynarr_atp_allow_end() for retrieving a
pointer to a position that might be the element past the last one.
New Dynarr_past_lastp() to retrieve a pointer to the position
past the last one, using Dynarr_atp_allow_end(). Change code
appropriately to use it.
Rename Dynarr_end() to Dynarr_lastp() (pointer to the last
element) for clarity, and change code appropriately to use it.
Change code appropriately to use Dynarr_begin().
Rewrite Dynarr_add_many(). New version can accept a NULL pointer
to mean "reserve space but don't put anything in it". Used by
stack_like_malloc().
author | Ben Wing <ben@xemacs.org> |
---|---|
date | Wed, 13 Jan 2010 04:07:42 -0600 |
parents | 4dd2389173fc |
children | a98ca4640147 |
rev | line source |
---|---|
428 | 1 /* Functions to handle multilingual characters. |
2 Copyright (C) 1992, 1995 Free Software Foundation, Inc. | |
3 Copyright (C) 1995 Sun Microsystems, Inc. | |
3025 | 4 Copyright (C) 2001, 2002, 2004, 2005 Ben Wing. |
428 | 5 |
6 This file is part of XEmacs. | |
7 | |
8 XEmacs is free software; you can redistribute it and/or modify it | |
9 under the terms of the GNU General Public License as published by the | |
10 Free Software Foundation; either version 2, or (at your option) any | |
11 later version. | |
12 | |
13 XEmacs is distributed in the hope that it will be useful, but WITHOUT | |
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
16 for more details. | |
17 | |
18 You should have received a copy of the GNU General Public License | |
19 along with XEmacs; see the file COPYING. If not, write to | |
20 the Free Software Foundation, Inc., 59 Temple Place - Suite 330, | |
21 Boston, MA 02111-1307, USA. */ | |
22 | |
23 /* Synched up with: FSF 20.3. Not in FSF. */ | |
24 | |
25 /* Rewritten by Ben Wing <ben@xemacs.org>. */ | |
26 | |
27 #include <config.h> | |
28 #include "lisp.h" | |
29 | |
30 #include "buffer.h" | |
31 #include "chartab.h" | |
32 #include "elhash.h" | |
33 #include "device.h" | |
34 #include "faces.h" | |
771 | 35 #include "lstream.h" |
428 | 36 #include "mule-ccl.h" |
872 | 37 #include "objects.h" |
3659 | 38 #include "specifier.h" |
428 | 39 |
40 /* The various pre-defined charsets. */ | |
41 | |
42 Lisp_Object Vcharset_ascii; | |
43 Lisp_Object Vcharset_control_1; | |
44 Lisp_Object Vcharset_latin_iso8859_1; | |
45 Lisp_Object Vcharset_latin_iso8859_2; | |
46 Lisp_Object Vcharset_latin_iso8859_3; | |
47 Lisp_Object Vcharset_latin_iso8859_4; | |
48 Lisp_Object Vcharset_thai_tis620; | |
49 Lisp_Object Vcharset_greek_iso8859_7; | |
4805
980575c76541
Move the arabic-iso8859-6 character set back to C, otherwise X11 lookup fails.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4745
diff
changeset
|
50 Lisp_Object Vcharset_arabic_iso8859_6; |
428 | 51 Lisp_Object Vcharset_hebrew_iso8859_8; |
52 Lisp_Object Vcharset_katakana_jisx0201; | |
53 Lisp_Object Vcharset_latin_jisx0201; | |
54 Lisp_Object Vcharset_cyrillic_iso8859_5; | |
55 Lisp_Object Vcharset_latin_iso8859_9; | |
728 | 56 Lisp_Object Vcharset_latin_iso8859_15; |
428 | 57 Lisp_Object Vcharset_japanese_jisx0208_1978; |
58 Lisp_Object Vcharset_chinese_gb2312; | |
59 Lisp_Object Vcharset_japanese_jisx0208; | |
60 Lisp_Object Vcharset_korean_ksc5601; | |
61 Lisp_Object Vcharset_japanese_jisx0212; | |
62 Lisp_Object Vcharset_chinese_cns11643_1; | |
63 Lisp_Object Vcharset_chinese_cns11643_2; | |
64 Lisp_Object Vcharset_chinese_big5_1; | |
65 Lisp_Object Vcharset_chinese_big5_2; | |
66 Lisp_Object Vcharset_composite; | |
67 | |
68 struct charset_lookup *chlook; | |
69 | |
1204 | 70 static const struct memory_description charset_lookup_description_1[] = { |
771 | 71 { XD_LISP_OBJECT_ARRAY, offsetof (struct charset_lookup, charset_by_leading_byte), NUM_LEADING_BYTES+4*128*2 }, |
428 | 72 { XD_END } |
73 }; | |
74 | |
1204 | 75 static const struct sized_memory_description charset_lookup_description = { |
440 | 76 sizeof (struct charset_lookup), |
428 | 77 charset_lookup_description_1 |
78 }; | |
79 | |
80 Lisp_Object Qcharsetp; | |
81 | |
3664 | 82 /* Qdoc_string, Qdimension, Qchars, Qfinal defined in general.c */ |
83 Lisp_Object Qregistries, Qgraphic, Qregistry; | |
428 | 84 Lisp_Object Qdirection; |
85 Lisp_Object Qreverse_direction_charset; | |
86 Lisp_Object Qshort_name, Qlong_name; | |
87 | |
4691
3ba90c659d01
Move Qfrom_unicode to general-slots.h, fix the native Win32 build.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4491
diff
changeset
|
88 Lisp_Object Qto_unicode; |
771 | 89 |
90 Lisp_Object | |
428 | 91 Qlatin_iso8859_1, |
92 Qlatin_iso8859_2, | |
93 Qlatin_iso8859_3, | |
94 Qlatin_iso8859_4, | |
95 Qthai_tis620, | |
96 Qgreek_iso8859_7, | |
4805
980575c76541
Move the arabic-iso8859-6 character set back to C, otherwise X11 lookup fails.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4745
diff
changeset
|
97 Qarabic_iso8859_6, |
428 | 98 Qhebrew_iso8859_8, |
99 Qkatakana_jisx0201, | |
100 Qlatin_jisx0201, | |
101 Qcyrillic_iso8859_5, | |
102 Qlatin_iso8859_9, | |
728 | 103 Qlatin_iso8859_15, |
428 | 104 Qjapanese_jisx0208_1978, |
105 Qchinese_gb2312, | |
106 Qjapanese_jisx0208, | |
107 Qkorean_ksc5601, | |
108 Qjapanese_jisx0212, | |
109 Qchinese_cns11643_1, | |
110 Qchinese_cns11643_2, | |
111 Qchinese_big5_1, | |
112 Qchinese_big5_2, | |
113 Qcomposite; | |
114 | |
115 Lisp_Object Ql2r, Qr2l; | |
116 | |
117 Lisp_Object Vcharset_hash_table; | |
118 | |
119 | |
120 /************************************************************************/ | |
121 /* charset object */ | |
122 /************************************************************************/ | |
123 | |
124 static Lisp_Object | |
125 mark_charset (Lisp_Object obj) | |
126 { | |
440 | 127 Lisp_Charset *cs = XCHARSET (obj); |
428 | 128 |
129 mark_object (cs->short_name); | |
130 mark_object (cs->long_name); | |
131 mark_object (cs->doc_string); | |
3659 | 132 mark_object (cs->registries); |
428 | 133 mark_object (cs->ccl_program); |
134 return cs->name; | |
135 } | |
136 | |
137 static void | |
2286 | 138 print_charset (Lisp_Object obj, Lisp_Object printcharfun, |
139 int UNUSED (escapeflag)) | |
428 | 140 { |
440 | 141 Lisp_Charset *cs = XCHARSET (obj); |
428 | 142 |
143 if (print_readably) | |
563 | 144 printing_unreadable_object ("#<charset %s 0x%x>", |
793 | 145 XSTRING_DATA (XSYMBOL (CHARSET_NAME (cs))-> |
563 | 146 name), |
147 cs->header.uid); | |
428 | 148 |
771 | 149 write_fmt_string_lisp (printcharfun, "#<charset %s %S %S %S", 4, |
150 CHARSET_NAME (cs), CHARSET_SHORT_NAME (cs), | |
151 CHARSET_LONG_NAME (cs), CHARSET_DOC_STRING (cs)); | |
152 write_fmt_string (printcharfun, " %s %s cols=%d g%d final='%c' reg=", | |
153 CHARSET_TYPE (cs) == CHARSET_TYPE_94 ? "94" : | |
154 CHARSET_TYPE (cs) == CHARSET_TYPE_96 ? "96" : | |
155 CHARSET_TYPE (cs) == CHARSET_TYPE_94X94 ? "94x94" : | |
156 "96x96", | |
157 CHARSET_DIRECTION (cs) == CHARSET_LEFT_TO_RIGHT ? "l2r" : | |
158 "r2l", | |
159 CHARSET_COLUMNS (cs), | |
160 CHARSET_GRAPHIC (cs), | |
161 CHARSET_FINAL (cs)); | |
3659 | 162 print_internal (CHARSET_REGISTRIES (cs), printcharfun, 0); |
771 | 163 write_fmt_string (printcharfun, " 0x%x>", cs->header.uid); |
164 } | |
165 | |
1204 | 166 static const struct memory_description charset_description[] = { |
167 { XD_INT, offsetof (Lisp_Charset, dimension) }, | |
168 { XD_INT, offsetof (Lisp_Charset, from_unicode_levels) }, | |
440 | 169 { XD_LISP_OBJECT, offsetof (Lisp_Charset, name) }, |
170 { XD_LISP_OBJECT, offsetof (Lisp_Charset, doc_string) }, | |
3659 | 171 { XD_LISP_OBJECT, offsetof (Lisp_Charset, registries) }, |
440 | 172 { XD_LISP_OBJECT, offsetof (Lisp_Charset, short_name) }, |
173 { XD_LISP_OBJECT, offsetof (Lisp_Charset, long_name) }, | |
174 { XD_LISP_OBJECT, offsetof (Lisp_Charset, reverse_direction_charset) }, | |
175 { XD_LISP_OBJECT, offsetof (Lisp_Charset, ccl_program) }, | |
771 | 176 { XD_UNION, offsetof (Lisp_Charset, to_unicode_table), |
2775 | 177 XD_INDIRECT (0, 0), { &to_unicode_description }, XD_FLAG_NO_KKCC }, |
771 | 178 { XD_UNION, offsetof (Lisp_Charset, from_unicode_table), |
2775 | 179 XD_INDIRECT (1, 0), { &from_unicode_description }, XD_FLAG_NO_KKCC }, |
428 | 180 { XD_END } |
181 }; | |
182 | |
934 | 183 DEFINE_LRECORD_IMPLEMENTATION ("charset", charset, |
184 1, /* dumpable flag */ | |
2367 | 185 mark_charset, print_charset, 0, |
934 | 186 0, 0, charset_description, Lisp_Charset); |
428 | 187 /* Make a new charset. */ |
446 | 188 /* #### SJT Should generic properties be allowed? */ |
428 | 189 static Lisp_Object |
771 | 190 make_charset (int id, Lisp_Object name, int rep_bytes, |
191 int type, int columns, int graphic, | |
867 | 192 Ibyte final, int direction, Lisp_Object short_name, |
428 | 193 Lisp_Object long_name, Lisp_Object doc, |
3439 | 194 Lisp_Object reg, int overwrite, int encode_as_utf_8) |
428 | 195 { |
196 Lisp_Object obj; | |
771 | 197 Lisp_Charset *cs; |
198 | |
199 if (!overwrite) | |
200 { | |
3017 | 201 cs = ALLOC_LCRECORD_TYPE (Lisp_Charset, &lrecord_charset); |
793 | 202 obj = wrap_charset (cs); |
771 | 203 |
204 if (final) | |
205 { | |
206 /* some charsets do not have final characters. This includes | |
207 ASCII, Control-1, Composite, and the two faux private | |
208 charsets. */ | |
209 assert (NILP (chlook-> | |
210 charset_by_attributes[type][final][direction])); | |
211 chlook->charset_by_attributes[type][final][direction] = obj; | |
212 } | |
440 | 213 |
771 | 214 assert (NILP (chlook->charset_by_leading_byte[id - MIN_LEADING_BYTE])); |
215 chlook->charset_by_leading_byte[id - MIN_LEADING_BYTE] = obj; | |
216 } | |
217 else | |
218 { | |
219 Lisp_Object ret; | |
220 /* Actually overwrite the properties of the existing charset. | |
221 We do this because until now charsets could never be "deleted", | |
222 so parts of the code don't bother to GC charsets. */ | |
223 obj = chlook->charset_by_leading_byte[id - MIN_LEADING_BYTE]; | |
224 cs = XCHARSET (obj); | |
225 assert (EQ (chlook->charset_by_attributes[type][final][direction], | |
226 obj)); | |
227 | |
228 ret = Fremhash (XCHARSET_NAME (obj), Vcharset_hash_table); | |
229 assert (!NILP (ret)); | |
230 } | |
428 | 231 |
232 CHARSET_ID (cs) = id; | |
233 CHARSET_NAME (cs) = name; | |
234 CHARSET_SHORT_NAME (cs) = short_name; | |
235 CHARSET_LONG_NAME (cs) = long_name; | |
236 CHARSET_REP_BYTES (cs) = rep_bytes; | |
237 CHARSET_DIRECTION (cs) = direction; | |
238 CHARSET_TYPE (cs) = type; | |
239 CHARSET_COLUMNS (cs) = columns; | |
240 CHARSET_GRAPHIC (cs) = graphic; | |
241 CHARSET_FINAL (cs) = final; | |
242 CHARSET_DOC_STRING (cs) = doc; | |
3659 | 243 CHECK_VECTOR(reg); |
244 CHARSET_REGISTRIES (cs) = reg; | |
3439 | 245 CHARSET_ENCODE_AS_UTF_8 (cs) = encode_as_utf_8 ? 1 : 0; |
428 | 246 CHARSET_CCL_PROGRAM (cs) = Qnil; |
247 CHARSET_REVERSE_DIRECTION_CHARSET (cs) = Qnil; | |
248 | |
771 | 249 CHARSET_DIMENSION (cs) = (CHARSET_TYPE (cs) == CHARSET_TYPE_94 || |
250 CHARSET_TYPE (cs) == CHARSET_TYPE_96) ? 1 : 2; | |
251 CHARSET_CHARS (cs) = (CHARSET_TYPE (cs) == CHARSET_TYPE_94 || | |
252 CHARSET_TYPE (cs) == CHARSET_TYPE_94X94) ? 94 : 96; | |
428 | 253 |
771 | 254 if (id == LEADING_BYTE_ASCII || id == LEADING_BYTE_CONTROL_1 |
255 #ifdef ENABLE_COMPOSITE_CHARS | |
256 || id == LEADING_BYTE_COMPOSITE | |
257 #endif | |
258 ) | |
259 assert (!overwrite); | |
260 else | |
428 | 261 { |
771 | 262 if (overwrite) |
263 free_charset_unicode_tables (obj); | |
264 init_charset_unicode_tables (obj); | |
428 | 265 } |
266 | |
267 /* Some charsets are "faux" and don't have names or really exist at | |
268 all except in the leading-byte table. */ | |
269 if (!NILP (name)) | |
771 | 270 { |
271 assert (NILP (Fgethash (name, Vcharset_hash_table, Qnil))); | |
272 Fputhash (name, obj, Vcharset_hash_table); | |
273 } | |
274 | |
275 recalculate_unicode_precedence (); | |
3659 | 276 setup_charset_initial_specifier_tags (obj); |
277 | |
428 | 278 return obj; |
279 } | |
280 | |
281 static int | |
282 get_unallocated_leading_byte (int dimension) | |
283 { | |
284 int lb; | |
285 | |
286 if (dimension == 1) | |
287 { | |
771 | 288 if (chlook->next_allocated_1_byte_leading_byte > |
289 MAX_LEADING_BYTE_PRIVATE_1) | |
428 | 290 lb = 0; |
291 else | |
442 | 292 lb = chlook->next_allocated_1_byte_leading_byte++; |
428 | 293 } |
294 else | |
295 { | |
1747 | 296 /* awfully fragile, but correct */ |
297 #if MAX_LEADING_BYTE_PRIVATE_2 == 255 | |
298 if (chlook->next_allocated_2_byte_leading_byte == 0) | |
1749 | 299 #else |
771 | 300 if (chlook->next_allocated_2_byte_leading_byte > |
301 MAX_LEADING_BYTE_PRIVATE_2) | |
1747 | 302 #endif |
428 | 303 lb = 0; |
304 else | |
442 | 305 lb = chlook->next_allocated_2_byte_leading_byte++; |
428 | 306 } |
307 | |
308 if (!lb) | |
563 | 309 invalid_operation |
771 | 310 ("No more character sets free for this dimension", make_int (dimension)); |
428 | 311 |
312 return lb; | |
313 } | |
314 | |
315 | |
316 /************************************************************************/ | |
317 /* Basic charset Lisp functions */ | |
318 /************************************************************************/ | |
319 | |
788 | 320 void |
321 get_charset_limits (Lisp_Object charset, int *low, int *high) | |
322 { | |
323 Lisp_Charset *cs = XCHARSET (charset); | |
324 | |
325 if (EQ (charset, Vcharset_ascii)) *low = 0, *high = 127; | |
326 else if (EQ (charset, Vcharset_control_1)) *low = 0, *high = 31; | |
327 else if (CHARSET_CHARS (cs) == 94) *low = 33, *high = 126; | |
328 else /* CHARSET_CHARS (cs) == 96) */ *low = 32, *high = 127; | |
329 } | |
330 | |
428 | 331 DEFUN ("charsetp", Fcharsetp, 1, 1, 0, /* |
332 Return non-nil if OBJECT is a charset. | |
333 */ | |
334 (object)) | |
335 { | |
336 return CHARSETP (object) ? Qt : Qnil; | |
337 } | |
338 | |
339 DEFUN ("find-charset", Ffind_charset, 1, 1, 0, /* | |
340 Retrieve the charset of the given name. | |
341 If CHARSET-OR-NAME is a charset object, it is simply returned. | |
342 Otherwise, CHARSET-OR-NAME should be a symbol. If there is no such charset, | |
343 nil is returned. Otherwise the associated charset object is returned. | |
344 */ | |
345 (charset_or_name)) | |
346 { | |
347 if (CHARSETP (charset_or_name)) | |
348 return charset_or_name; | |
349 | |
350 CHECK_SYMBOL (charset_or_name); | |
351 return Fgethash (charset_or_name, Vcharset_hash_table, Qnil); | |
352 } | |
353 | |
354 DEFUN ("get-charset", Fget_charset, 1, 1, 0, /* | |
355 Retrieve the charset of the given name. | |
356 Same as `find-charset' except an error is signalled if there is no such | |
357 charset instead of returning nil. | |
358 */ | |
359 (name)) | |
360 { | |
361 Lisp_Object charset = Ffind_charset (name); | |
362 | |
363 if (NILP (charset)) | |
563 | 364 invalid_argument ("No such charset", name); |
428 | 365 return charset; |
366 } | |
367 | |
368 /* We store the charsets in hash tables with the names as the key and the | |
369 actual charset object as the value. Occasionally we need to use them | |
370 in a list format. These routines provide us with that. */ | |
371 struct charset_list_closure | |
372 { | |
373 Lisp_Object *charset_list; | |
374 }; | |
375 | |
376 static int | |
2286 | 377 add_charset_to_list_mapper (Lisp_Object UNUSED (key), Lisp_Object value, |
428 | 378 void *charset_list_closure) |
379 { | |
380 /* This function can GC */ | |
381 struct charset_list_closure *chcl = | |
382 (struct charset_list_closure*) charset_list_closure; | |
383 Lisp_Object *charset_list = chcl->charset_list; | |
384 | |
385 *charset_list = Fcons (XCHARSET_NAME (value), *charset_list); | |
386 return 0; | |
387 } | |
388 | |
389 DEFUN ("charset-list", Fcharset_list, 0, 0, 0, /* | |
390 Return a list of the names of all defined charsets. | |
391 */ | |
392 ()) | |
393 { | |
394 Lisp_Object charset_list = Qnil; | |
395 struct gcpro gcpro1; | |
396 struct charset_list_closure charset_list_closure; | |
397 | |
398 GCPRO1 (charset_list); | |
399 charset_list_closure.charset_list = &charset_list; | |
400 elisp_maphash (add_charset_to_list_mapper, Vcharset_hash_table, | |
401 &charset_list_closure); | |
402 UNGCPRO; | |
403 | |
404 return charset_list; | |
405 } | |
406 | |
407 DEFUN ("charset-name", Fcharset_name, 1, 1, 0, /* | |
444 | 408 Return the name of charset CHARSET. |
428 | 409 */ |
410 (charset)) | |
411 { | |
412 return XCHARSET_NAME (Fget_charset (charset)); | |
413 } | |
414 | |
446 | 415 /* #### SJT Should generic properties be allowed? */ |
428 | 416 DEFUN ("make-charset", Fmake_charset, 3, 3, 0, /* |
417 Define a new character set. | |
418 This function is for use with Mule support. | |
419 NAME is a symbol, the name by which the character set is normally referred. | |
420 DOC-STRING is a string describing the character set. | |
421 PROPS is a property list, describing the specific nature of the | |
422 character set. Recognized properties are: | |
423 | |
3025 | 424 `short-name' Short version of the charset name (ex: Latin-1) |
425 `long-name' Long version of the charset name (ex: ISO8859-1 (Latin-1)) | |
3659 | 426 `registries' A vector of possible XLFD REGISTRY-ENCODING combinations for |
427 this character set. Note that this is not a regular expression. | |
3025 | 428 `dimension' Number of octets used to index a character in this charset. |
428 | 429 Either 1 or 2. Defaults to 1. |
3025 | 430 `columns' Number of columns used to display a character in this charset. |
428 | 431 Only used in TTY mode. (Under X, the actual width of a |
432 character can be derived from the font used to display the | |
433 characters.) If unspecified, defaults to the dimension | |
434 (this is almost always the correct value). | |
3025 | 435 `chars' Number of characters in each dimension (94 or 96). |
428 | 436 Defaults to 94. Note that if the dimension is 2, the |
437 character set thus described is 94x94 or 96x96. | |
3025 | 438 `final' Final byte of ISO 2022 escape sequence. Must be |
428 | 439 supplied. Each combination of (DIMENSION, CHARS) defines a |
440 separate namespace for final bytes. Note that ISO | |
441 2022 restricts the final byte to the range | |
442 0x30 - 0x7E if dimension == 1, and 0x30 - 0x5F if | |
443 dimension == 2. Note also that final bytes in the range | |
444 0x30 - 0x3F are reserved for user-defined (not official) | |
445 character sets. | |
3025 | 446 `graphic' 0 (use left half of font on output) or 1 (use right half |
428 | 447 of font on output). Defaults to 0. For example, for |
448 a font whose registry is ISO8859-1, the left half | |
449 (octets 0x20 - 0x7F) is the `ascii' character set, while | |
450 the right half (octets 0xA0 - 0xFF) is the `latin-1' | |
3025 | 451 character set. With `graphic' set to 0, the octets |
428 | 452 will have their high bit cleared; with it set to 1, |
453 the octets will have their high bit set. | |
3025 | 454 `direction' `l2r' (left-to-right) or `r2l' (right-to-left). |
455 Defaults to `l2r'. | |
456 `ccl-program' A compiled CCL program used to convert a character in | |
428 | 457 this charset into an index into the font. This is in |
3025 | 458 addition to the `graphic' property. The CCL program |
428 | 459 is passed the octets of the character, with the high |
460 bit cleared and set depending upon whether the value | |
3025 | 461 of the `graphic' property is 0 or 1. |
3439 | 462 `encode-as-utf-8' |
463 If non-nil, the charset will be written out using the UTF-8 | |
464 escape syntax in ISO 2022-oriented coding systems. Used for | |
465 supporting characters we know are part of Unicode but not of | |
466 any other known character set in escape-quoted and compound | |
467 text. | |
428 | 468 */ |
469 (name, doc_string, props)) | |
470 { | |
771 | 471 int id, dimension = 1, chars = 94, graphic = 0, columns = -1; |
867 | 472 Ibyte final = 0; |
428 | 473 int direction = CHARSET_LEFT_TO_RIGHT; |
474 int type; | |
3659 | 475 Lisp_Object registries = Qnil; |
771 | 476 Lisp_Object charset = Qnil; |
428 | 477 Lisp_Object ccl_program = Qnil; |
478 Lisp_Object short_name = Qnil, long_name = Qnil; | |
3439 | 479 int encode_as_utf_8 = 0; |
771 | 480 Lisp_Object existing_charset; |
481 int temporary = UNBOUNDP (name); | |
428 | 482 |
771 | 483 /* NOTE: name == Qunbound is a directive from the iso2022 code to |
484 create a temporary charset for an unknown final. We allow the final | |
485 to be overwritten with a real charset later on. */ | |
486 | |
428 | 487 if (!NILP (doc_string)) |
488 CHECK_STRING (doc_string); | |
771 | 489 if (!UNBOUNDP (name)) |
490 { | |
491 CHECK_SYMBOL (name); | |
428 | 492 |
771 | 493 charset = Ffind_charset (name); |
494 if (!NILP (charset)) | |
495 invalid_operation ("Cannot redefine existing charset", name); | |
496 } | |
428 | 497 |
442 | 498 { |
499 EXTERNAL_PROPERTY_LIST_LOOP_3 (keyword, value, props) | |
500 { | |
501 if (EQ (keyword, Qshort_name)) | |
502 { | |
503 CHECK_STRING (value); | |
504 short_name = value; | |
505 } | |
428 | 506 |
519 | 507 else if (EQ (keyword, Qlong_name)) |
442 | 508 { |
509 CHECK_STRING (value); | |
510 long_name = value; | |
511 } | |
428 | 512 |
442 | 513 else if (EQ (keyword, Qdimension)) |
514 { | |
515 CHECK_INT (value); | |
516 dimension = XINT (value); | |
517 if (dimension < 1 || dimension > 2) | |
3025 | 518 invalid_constant ("Invalid value for `dimension'", value); |
442 | 519 } |
428 | 520 |
442 | 521 else if (EQ (keyword, Qchars)) |
522 { | |
523 CHECK_INT (value); | |
524 chars = XINT (value); | |
525 if (chars != 94 && chars != 96) | |
3025 | 526 invalid_constant ("Invalid value for `chars'", value); |
442 | 527 } |
428 | 528 |
442 | 529 else if (EQ (keyword, Qcolumns)) |
530 { | |
531 CHECK_INT (value); | |
532 columns = XINT (value); | |
533 if (columns != 1 && columns != 2) | |
3025 | 534 invalid_constant ("Invalid value for `columns'", value); |
442 | 535 } |
428 | 536 |
442 | 537 else if (EQ (keyword, Qgraphic)) |
538 { | |
539 CHECK_INT (value); | |
540 graphic = XINT (value); | |
541 if (graphic < 0 || graphic > 1) | |
3025 | 542 invalid_constant ("Invalid value for `graphic'", value); |
442 | 543 } |
428 | 544 |
3659 | 545 else if (EQ (keyword, Qregistries)) |
546 { | |
547 CHECK_VECTOR (value); | |
548 registries = value; | |
549 } | |
550 | |
442 | 551 else if (EQ (keyword, Qregistry)) |
552 { | |
3659 | 553 Lisp_Object quoted_registry; |
554 | |
442 | 555 CHECK_STRING (value); |
3659 | 556 quoted_registry = Fregexp_quote(value); |
3662 | 557 if (qxestrcmp(XSTRING_DATA(quoted_registry), |
3659 | 558 XSTRING_DATA(value))) |
559 { | |
560 warn_when_safe | |
561 (Qregistry, Qwarning, | |
562 "Regexps no longer allowed for charset-registry. " | |
563 "Treating %s as string", XSTRING_DATA(value)); | |
564 } | |
565 registries = vector1(value); | |
442 | 566 } |
428 | 567 |
442 | 568 else if (EQ (keyword, Qdirection)) |
569 { | |
570 if (EQ (value, Ql2r)) | |
571 direction = CHARSET_LEFT_TO_RIGHT; | |
572 else if (EQ (value, Qr2l)) | |
573 direction = CHARSET_RIGHT_TO_LEFT; | |
574 else | |
3025 | 575 invalid_constant ("Invalid value for `direction'", value); |
442 | 576 } |
428 | 577 |
3439 | 578 else if (EQ (keyword, Qencode_as_utf_8)) |
579 { | |
580 encode_as_utf_8 = NILP (value) ? 0 : 1; | |
581 } | |
582 | |
442 | 583 else if (EQ (keyword, Qfinal)) |
584 { | |
585 CHECK_CHAR_COERCE_INT (value); | |
586 final = XCHAR (value); | |
587 if (final < '0' || final > '~') | |
3025 | 588 invalid_constant ("Invalid value for `final'", value); |
442 | 589 } |
590 else if (EQ (keyword, Qccl_program)) | |
591 { | |
4745
0c54de4c4b9d
Resolve the unregistered-CCL-programs-get-garbage-collected problem correctly
Aidan Kehoe <kehoea@parhasard.net>
parents:
4691
diff
changeset
|
592 /* This errors if VALUE is not a valid CCL program. */ |
0c54de4c4b9d
Resolve the unregistered-CCL-programs-get-garbage-collected problem correctly
Aidan Kehoe <kehoea@parhasard.net>
parents:
4691
diff
changeset
|
593 ccl_program = get_ccl_program (value); |
442 | 594 } |
595 else | |
563 | 596 invalid_constant ("Unrecognized property", keyword); |
442 | 597 } |
598 } | |
428 | 599 |
600 if (!final) | |
3025 | 601 invalid_argument ("`final' must be specified", Qunbound); |
428 | 602 if (dimension == 2 && final > 0x5F) |
563 | 603 invalid_constant |
428 | 604 ("Final must be in the range 0x30 - 0x5F for dimension == 2", |
605 make_char (final)); | |
606 | |
607 if (dimension == 1) | |
608 type = (chars == 94) ? CHARSET_TYPE_94 : CHARSET_TYPE_96; | |
609 else | |
610 type = (chars == 94) ? CHARSET_TYPE_94X94 : CHARSET_TYPE_96X96; | |
611 | |
826 | 612 existing_charset = charset_by_attributes (type, final, direction); |
771 | 613 |
614 if (!NILP (existing_charset) && !XCHARSET (existing_charset)->temporary) | |
578 | 615 invalid_argument |
793 | 616 ("Character set already defined for this DIMENSION/CHARS/FINAL/DIRECTION combo", |
771 | 617 existing_charset); |
618 | |
619 if (!NILP (existing_charset)) | |
620 /* Reuse same leading byte */ | |
621 id = XCHARSET_ID (existing_charset); | |
622 else | |
623 id = get_unallocated_leading_byte (dimension); | |
428 | 624 |
771 | 625 if (temporary) |
626 { | |
867 | 627 Ibyte tempname[80]; |
428 | 628 |
771 | 629 qxesprintf (tempname, "___temporary___%d__", id); |
4813
6f84332672fb
Change build_string to build_intstring, fixing the Visual C++ build.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4807
diff
changeset
|
630 name = Fmake_symbol (build_intstring (tempname)); /* Uninterned. */ |
771 | 631 } |
428 | 632 if (NILP (doc_string)) |
633 doc_string = build_string (""); | |
3659 | 634 if (NILP (registries)) |
635 registries = make_vector(0, Qnil); | |
428 | 636 if (NILP (short_name)) |
793 | 637 short_name = XSYMBOL (name)->name; |
428 | 638 if (NILP (long_name)) |
639 long_name = doc_string; | |
640 if (columns == -1) | |
641 columns = dimension; | |
771 | 642 |
428 | 643 charset = make_charset (id, name, dimension + 2, type, columns, graphic, |
771 | 644 final, direction, short_name, long_name, |
3659 | 645 doc_string, registries, !NILP (existing_charset), |
3439 | 646 encode_as_utf_8); |
771 | 647 |
648 XCHARSET (charset)->temporary = temporary; | |
428 | 649 if (!NILP (ccl_program)) |
650 XCHARSET_CCL_PROGRAM (charset) = ccl_program; | |
771 | 651 |
793 | 652 { |
653 Lisp_Object revdircs = | |
826 | 654 charset_by_attributes (type, final, |
793 | 655 direction == CHARSET_LEFT_TO_RIGHT ? |
656 CHARSET_RIGHT_TO_LEFT : CHARSET_LEFT_TO_RIGHT); | |
657 if (!NILP (revdircs)) | |
658 { | |
659 XCHARSET_REVERSE_DIRECTION_CHARSET (revdircs) = charset; | |
660 XCHARSET_REVERSE_DIRECTION_CHARSET (charset) = revdircs; | |
661 } | |
662 } | |
663 | |
428 | 664 return charset; |
665 } | |
666 | |
667 DEFUN ("make-reverse-direction-charset", Fmake_reverse_direction_charset, | |
668 2, 2, 0, /* | |
669 Make a charset equivalent to CHARSET but which goes in the opposite direction. | |
670 NEW-NAME is the name of the new charset. Return the new charset. | |
671 */ | |
672 (charset, new_name)) | |
673 { | |
674 Lisp_Object new_charset = Qnil; | |
3439 | 675 int id, dimension, columns, graphic, encode_as_utf_8; |
867 | 676 Ibyte final; |
428 | 677 int direction, type; |
3659 | 678 Lisp_Object registries, doc_string, short_name, long_name; |
440 | 679 Lisp_Charset *cs; |
428 | 680 |
681 charset = Fget_charset (charset); | |
682 if (!NILP (XCHARSET_REVERSE_DIRECTION_CHARSET (charset))) | |
563 | 683 invalid_operation ("Charset already has reverse-direction charset", |
793 | 684 charset); |
428 | 685 |
686 CHECK_SYMBOL (new_name); | |
687 if (!NILP (Ffind_charset (new_name))) | |
563 | 688 invalid_operation ("Cannot redefine existing charset", new_name); |
428 | 689 |
690 cs = XCHARSET (charset); | |
691 | |
692 type = CHARSET_TYPE (cs); | |
693 columns = CHARSET_COLUMNS (cs); | |
694 dimension = CHARSET_DIMENSION (cs); | |
695 id = get_unallocated_leading_byte (dimension); | |
696 | |
697 graphic = CHARSET_GRAPHIC (cs); | |
698 final = CHARSET_FINAL (cs); | |
699 direction = CHARSET_RIGHT_TO_LEFT; | |
700 if (CHARSET_DIRECTION (cs) == CHARSET_RIGHT_TO_LEFT) | |
701 direction = CHARSET_LEFT_TO_RIGHT; | |
702 doc_string = CHARSET_DOC_STRING (cs); | |
703 short_name = CHARSET_SHORT_NAME (cs); | |
704 long_name = CHARSET_LONG_NAME (cs); | |
3659 | 705 registries = CHARSET_REGISTRIES (cs); |
3439 | 706 encode_as_utf_8 = CHARSET_ENCODE_AS_UTF_8 (cs); |
428 | 707 |
708 new_charset = make_charset (id, new_name, dimension + 2, type, columns, | |
709 graphic, final, direction, short_name, long_name, | |
3659 | 710 doc_string, registries, 0, encode_as_utf_8); |
428 | 711 |
712 CHARSET_REVERSE_DIRECTION_CHARSET (cs) = new_charset; | |
713 XCHARSET_REVERSE_DIRECTION_CHARSET (new_charset) = charset; | |
714 | |
715 return new_charset; | |
716 } | |
717 | |
718 DEFUN ("charset-reverse-direction-charset", Fcharset_reverse_direction_charset, | |
719 1, 1, 0, /* | |
720 Return the reverse-direction charset parallel to CHARSET, if any. | |
721 This is the charset with the same properties (in particular, the same | |
722 dimension, number of characters per dimension, and final byte) as | |
723 CHARSET but whose characters are displayed in the opposite direction. | |
724 */ | |
725 (charset)) | |
726 { | |
727 charset = Fget_charset (charset); | |
728 return XCHARSET_REVERSE_DIRECTION_CHARSET (charset); | |
729 } | |
730 | |
731 DEFUN ("charset-from-attributes", Fcharset_from_attributes, 3, 4, 0, /* | |
732 Return a charset with the given DIMENSION, CHARS, FINAL, and DIRECTION. | |
733 If DIRECTION is omitted, both directions will be checked (left-to-right | |
734 will be returned if character sets exist for both directions). | |
735 */ | |
736 (dimension, chars, final, direction)) | |
737 { | |
738 int dm, ch, fi, di = -1; | |
739 int type; | |
740 Lisp_Object obj = Qnil; | |
741 | |
742 CHECK_INT (dimension); | |
743 dm = XINT (dimension); | |
744 if (dm < 1 || dm > 2) | |
563 | 745 invalid_constant ("Invalid value for DIMENSION", dimension); |
428 | 746 |
747 CHECK_INT (chars); | |
748 ch = XINT (chars); | |
749 if (ch != 94 && ch != 96) | |
563 | 750 invalid_constant ("Invalid value for CHARS", chars); |
428 | 751 |
752 CHECK_CHAR_COERCE_INT (final); | |
753 fi = XCHAR (final); | |
754 if (fi < '0' || fi > '~') | |
563 | 755 invalid_constant ("Invalid value for FINAL", final); |
428 | 756 |
757 if (EQ (direction, Ql2r)) | |
758 di = CHARSET_LEFT_TO_RIGHT; | |
759 else if (EQ (direction, Qr2l)) | |
760 di = CHARSET_RIGHT_TO_LEFT; | |
761 else if (!NILP (direction)) | |
563 | 762 invalid_constant ("Invalid value for DIRECTION", direction); |
428 | 763 |
764 if (dm == 2 && fi > 0x5F) | |
563 | 765 invalid_constant |
428 | 766 ("Final must be in the range 0x30 - 0x5F for dimension == 2", final); |
767 | |
768 if (dm == 1) | |
769 type = (ch == 94) ? CHARSET_TYPE_94 : CHARSET_TYPE_96; | |
770 else | |
771 type = (ch == 94) ? CHARSET_TYPE_94X94 : CHARSET_TYPE_96X96; | |
772 | |
773 if (di == -1) | |
774 { | |
826 | 775 obj = charset_by_attributes (type, fi, CHARSET_LEFT_TO_RIGHT); |
428 | 776 if (NILP (obj)) |
826 | 777 obj = charset_by_attributes (type, fi, CHARSET_RIGHT_TO_LEFT); |
428 | 778 } |
779 else | |
826 | 780 obj = charset_by_attributes (type, fi, di); |
428 | 781 |
782 if (CHARSETP (obj)) | |
783 return XCHARSET_NAME (obj); | |
784 return obj; | |
785 } | |
786 | |
787 DEFUN ("charset-short-name", Fcharset_short_name, 1, 1, 0, /* | |
788 Return short name of CHARSET. | |
789 */ | |
790 (charset)) | |
791 { | |
792 return XCHARSET_SHORT_NAME (Fget_charset (charset)); | |
793 } | |
794 | |
795 DEFUN ("charset-long-name", Fcharset_long_name, 1, 1, 0, /* | |
796 Return long name of CHARSET. | |
797 */ | |
798 (charset)) | |
799 { | |
800 return XCHARSET_LONG_NAME (Fget_charset (charset)); | |
801 } | |
802 | |
803 DEFUN ("charset-description", Fcharset_description, 1, 1, 0, /* | |
804 Return description of CHARSET. | |
805 */ | |
806 (charset)) | |
807 { | |
808 return XCHARSET_DOC_STRING (Fget_charset (charset)); | |
809 } | |
810 | |
811 DEFUN ("charset-dimension", Fcharset_dimension, 1, 1, 0, /* | |
812 Return dimension of CHARSET. | |
813 */ | |
814 (charset)) | |
815 { | |
816 return make_int (XCHARSET_DIMENSION (Fget_charset (charset))); | |
817 } | |
818 | |
819 DEFUN ("charset-property", Fcharset_property, 2, 2, 0, /* | |
446 | 820 Return property PROP of CHARSET, a charset object or symbol naming a charset. |
428 | 821 Recognized properties are those listed in `make-charset', as well as |
3025 | 822 `name' and `doc-string'. |
428 | 823 */ |
824 (charset, prop)) | |
825 { | |
440 | 826 Lisp_Charset *cs; |
428 | 827 |
828 charset = Fget_charset (charset); | |
829 cs = XCHARSET (charset); | |
830 | |
831 CHECK_SYMBOL (prop); | |
832 if (EQ (prop, Qname)) return CHARSET_NAME (cs); | |
833 if (EQ (prop, Qshort_name)) return CHARSET_SHORT_NAME (cs); | |
834 if (EQ (prop, Qlong_name)) return CHARSET_LONG_NAME (cs); | |
835 if (EQ (prop, Qdoc_string)) return CHARSET_DOC_STRING (cs); | |
836 if (EQ (prop, Qdimension)) return make_int (CHARSET_DIMENSION (cs)); | |
837 if (EQ (prop, Qcolumns)) return make_int (CHARSET_COLUMNS (cs)); | |
838 if (EQ (prop, Qgraphic)) return make_int (CHARSET_GRAPHIC (cs)); | |
839 if (EQ (prop, Qfinal)) return make_char (CHARSET_FINAL (cs)); | |
840 if (EQ (prop, Qchars)) return make_int (CHARSET_CHARS (cs)); | |
3659 | 841 if (EQ (prop, Qregistries)) return CHARSET_REGISTRIES (cs); |
3439 | 842 if (EQ (prop, Qencode_as_utf_8)) |
843 return CHARSET_ENCODE_AS_UTF_8 (cs) ? Qt : Qnil; | |
428 | 844 if (EQ (prop, Qccl_program)) return CHARSET_CCL_PROGRAM (cs); |
845 if (EQ (prop, Qdirection)) | |
846 return CHARSET_DIRECTION (cs) == CHARSET_LEFT_TO_RIGHT ? Ql2r : Qr2l; | |
847 if (EQ (prop, Qreverse_direction_charset)) | |
848 { | |
849 Lisp_Object obj = CHARSET_REVERSE_DIRECTION_CHARSET (cs); | |
446 | 850 /* #### Is this translation OK? If so, error checking sufficient? */ |
851 return CHARSETP (obj) ? XCHARSET_NAME (obj) : obj; | |
428 | 852 } |
563 | 853 invalid_constant ("Unrecognized charset property name", prop); |
1204 | 854 RETURN_NOT_REACHED (Qnil); |
428 | 855 } |
856 | |
857 DEFUN ("charset-id", Fcharset_id, 1, 1, 0, /* | |
858 Return charset identification number of CHARSET. | |
859 */ | |
860 (charset)) | |
861 { | |
793 | 862 return make_int (XCHARSET_LEADING_BYTE (Fget_charset (charset))); |
428 | 863 } |
864 | |
865 /* #### We need to figure out which properties we really want to | |
866 allow to be set. */ | |
867 | |
868 DEFUN ("set-charset-ccl-program", Fset_charset_ccl_program, 2, 2, 0, /* | |
3025 | 869 Set the `ccl-program' property of CHARSET to CCL-PROGRAM. |
428 | 870 */ |
871 (charset, ccl_program)) | |
872 { | |
873 charset = Fget_charset (charset); | |
4745
0c54de4c4b9d
Resolve the unregistered-CCL-programs-get-garbage-collected problem correctly
Aidan Kehoe <kehoea@parhasard.net>
parents:
4691
diff
changeset
|
874 XCHARSET_CCL_PROGRAM (charset) = get_ccl_program (ccl_program); |
0c54de4c4b9d
Resolve the unregistered-CCL-programs-get-garbage-collected problem correctly
Aidan Kehoe <kehoea@parhasard.net>
parents:
4691
diff
changeset
|
875 |
510 | 876 face_property_was_changed (Vdefault_face, Qfont, Qglobal); |
428 | 877 return Qnil; |
878 } | |
879 | |
3676 | 880 void |
881 set_charset_registries(Lisp_Object charset, Lisp_Object registries) | |
882 { | |
883 XCHARSET_REGISTRIES (charset) = registries; | |
884 invalidate_charset_font_caches (charset); | |
885 face_property_was_changed (Vdefault_face, Qfont, Qglobal); | |
886 } | |
887 | |
3711 | 888 DEFUN ("set-charset-registries", Fset_charset_registries, 2, 3, 0, /* |
3659 | 889 Set the `registries' property of CHARSET to REGISTRIES. |
890 | |
891 REGISTRIES is an ordered vector of strings that describe the X11 | |
892 CHARSET_REGISTRY and the CHARSET_ENCODINGs appropriate for this charset. | |
893 Separate each registry from the corresponding encoding with a dash. The | |
894 strings are not regular expressions, in contrast to the old behavior of | |
895 the `charset-registry' property. | |
896 | |
897 One reason to call this function might be if you're in Japan and you'd | |
898 prefer the backslash to display as a Yen sign; the corresponding syntax | |
899 would be: | |
900 | |
901 (set-charset-registries 'ascii ["jisx0201.1976-0"]) | |
902 | |
3711 | 903 If optional argument FORCE is non-nil, avoid sanity-checking the elements of |
904 REGISTRIES. Normally the strings are checked to make sure they contain no | |
905 XLFD wild cards and that they contain at least one hyphen; the only context | |
906 in which one might want not to do this is in order to use a font which | |
907 doesn't have a full XLFD--and thus, an effective | |
908 CHARSET_REGISTRY-CHARSET_ENCODING of ""--to display ASCII. | |
909 | |
910 We recommend strongly that you specify a full XLFD, since this makes | |
911 multilingual and variant font handling work much better. To get the full | |
912 XLFD of any font, start xfd with the short name as the pattern argument: | |
913 | |
914 xfd -fn 8x16kana | |
915 | |
916 and use the text that appears at the top of the window. | |
428 | 917 */ |
3711 | 918 (charset, registries, force)) |
428 | 919 { |
3659 | 920 int i; |
428 | 921 charset = Fget_charset (charset); |
3659 | 922 CHECK_VECTOR (registries); |
923 | |
924 for (i = 0; i < XVECTOR_LENGTH(registries); ++i) | |
925 { | |
926 CHECK_STRING (XVECTOR_DATA(registries)[i]); | |
3711 | 927 |
928 if (!NILP(force)) | |
929 { | |
930 continue; | |
931 } | |
932 | |
3659 | 933 if (NULL == qxestrchr(XSTRING_DATA(XVECTOR_DATA(registries)[i]), '-')) |
934 { | |
935 invalid_argument("Not an X11 REGISTRY-ENCODING combination", | |
936 XVECTOR_DATA(registries)[i]); | |
937 } | |
3676 | 938 |
939 if (qxestrchr(XSTRING_DATA(XVECTOR_DATA(registries)[i]), '*') || | |
940 qxestrchr(XSTRING_DATA(XVECTOR_DATA(registries)[i]), '?')) | |
941 { | |
942 invalid_argument | |
943 ("XLFD wildcards not allowed in charset-registries", | |
944 XVECTOR_DATA(registries)[i]); | |
945 | |
946 } | |
3659 | 947 } |
948 | |
3676 | 949 set_charset_registries(charset, registries); |
950 | |
428 | 951 return Qnil; |
952 } | |
953 | |
3681 | 954 DEFUN ("charsets-in-region", Fcharsets_in_region, 2, 3, 0, /* |
955 Return a list of the charsets in the region between START and END. | |
956 BUFFER defaults to the current buffer if omitted. | |
957 */ | |
958 (start, end, buffer)) | |
959 { | |
960 /* This function can GC */ | |
961 struct buffer *buf = decode_buffer (buffer, 1); | |
962 Charbpos pos, stop; /* Limits of the region. */ | |
963 Lisp_Object res = Qnil; | |
964 int charsets[NUM_LEADING_BYTES]; | |
965 Ibyte lb; | |
966 struct gcpro gcpro1; | |
967 | |
968 memset(charsets, 0, sizeof(charsets)); | |
969 get_buffer_range_char (buf, start, end, &pos, &stop, 0); | |
970 | |
971 GCPRO1 (res); | |
972 while (pos < stop) | |
973 { | |
974 lb = ichar_leading_byte(BUF_FETCH_CHAR (buf, pos)); | |
975 if (0 == charsets[lb - MIN_LEADING_BYTE]) | |
976 { | |
977 charsets[lb - MIN_LEADING_BYTE] = 1; | |
978 res = Fcons (XCHARSET_NAME(charset_by_leading_byte(lb)), res); | |
979 } | |
980 ++pos; | |
981 } | |
982 UNGCPRO; | |
983 | |
984 return res; | |
985 } | |
986 | |
428 | 987 |
988 /************************************************************************/ | |
771 | 989 /* memory usage */ |
428 | 990 /************************************************************************/ |
991 | |
771 | 992 #ifdef MEMORY_USAGE_STATS |
428 | 993 |
771 | 994 struct charset_stats |
995 { | |
996 int from_unicode; | |
997 int to_unicode; | |
998 int other; | |
999 }; | |
428 | 1000 |
771 | 1001 static void |
1002 compute_charset_usage (Lisp_Object charset, struct charset_stats *stats, | |
1003 struct overhead_stats *ovstats) | |
428 | 1004 { |
771 | 1005 struct Lisp_Charset *c = XCHARSET (charset); |
1006 xzero (*stats); | |
3024 | 1007 stats->other += LISPOBJ_STORAGE_SIZE (c, sizeof (*c), ovstats); |
771 | 1008 stats->from_unicode += compute_from_unicode_table_size (charset, ovstats); |
1009 stats->to_unicode += compute_to_unicode_table_size (charset, ovstats); | |
438 | 1010 } |
1011 | |
771 | 1012 DEFUN ("charset-memory-usage", Fcharset_memory_usage, 1, 1, 0, /* |
1013 Return stats about the memory usage of charset CHARSET. | |
1014 The values returned are in the form of an alist of usage types and | |
1015 byte counts. The byte counts attempt to encompass all the memory used | |
1016 by the charset (separate from the memory logically associated with a | |
1017 charset or frame), including internal structures and any malloc() | |
1018 overhead associated with them. In practice, the byte counts are | |
1019 underestimated for various reasons, e.g. because certain memory usage | |
1020 is very hard to determine \(e.g. the amount of memory used inside the | |
1021 Xt library or inside the X server). | |
428 | 1022 |
771 | 1023 Multiple slices of the total memory usage may be returned, separated |
1024 by a nil. Each slice represents a particular view of the memory, a | |
1025 particular way of partitioning it into groups. Within a slice, there | |
1026 is no overlap between the groups of memory, and each slice collectively | |
1027 represents all the memory concerned. | |
1028 */ | |
1029 (charset)) | |
1030 { | |
1031 struct charset_stats stats; | |
1032 struct overhead_stats ovstats; | |
1033 Lisp_Object val = Qnil; | |
428 | 1034 |
771 | 1035 charset = Fget_charset (charset); |
1036 xzero (ovstats); | |
1037 compute_charset_usage (charset, &stats, &ovstats); | |
428 | 1038 |
771 | 1039 val = acons (Qfrom_unicode, make_int (stats.from_unicode), val); |
1040 val = acons (Qto_unicode, make_int (stats.to_unicode), val); | |
1041 val = Fcons (Qnil, val); | |
1042 val = acons (Qactually_requested, make_int (ovstats.was_requested), val); | |
1043 val = acons (Qmalloc_overhead, make_int (ovstats.malloc_overhead), val); | |
1044 val = acons (Qgap_overhead, make_int (ovstats.gap_overhead), val); | |
1045 val = acons (Qdynarr_overhead, make_int (ovstats.dynarr_overhead), val); | |
1046 | |
1047 return Fnreverse (val); | |
428 | 1048 } |
1049 | |
771 | 1050 #endif /* MEMORY_USAGE_STATS */ |
428 | 1051 |
1052 | |
1053 /************************************************************************/ | |
1054 /* initialization */ | |
1055 /************************************************************************/ | |
1056 | |
1057 void | |
1058 syms_of_mule_charset (void) | |
1059 { | |
442 | 1060 INIT_LRECORD_IMPLEMENTATION (charset); |
1061 | |
428 | 1062 DEFSUBR (Fcharsetp); |
1063 DEFSUBR (Ffind_charset); | |
1064 DEFSUBR (Fget_charset); | |
1065 DEFSUBR (Fcharset_list); | |
1066 DEFSUBR (Fcharset_name); | |
1067 DEFSUBR (Fmake_charset); | |
1068 DEFSUBR (Fmake_reverse_direction_charset); | |
793 | 1069 DEFSUBR (Fcharset_reverse_direction_charset); |
428 | 1070 DEFSUBR (Fcharset_from_attributes); |
1071 DEFSUBR (Fcharset_short_name); | |
1072 DEFSUBR (Fcharset_long_name); | |
1073 DEFSUBR (Fcharset_description); | |
1074 DEFSUBR (Fcharset_dimension); | |
1075 DEFSUBR (Fcharset_property); | |
1076 DEFSUBR (Fcharset_id); | |
1077 DEFSUBR (Fset_charset_ccl_program); | |
3659 | 1078 DEFSUBR (Fset_charset_registries); |
3681 | 1079 DEFSUBR (Fcharsets_in_region); |
428 | 1080 |
771 | 1081 #ifdef MEMORY_USAGE_STATS |
1082 DEFSUBR (Fcharset_memory_usage); | |
428 | 1083 #endif |
1084 | |
563 | 1085 DEFSYMBOL (Qcharsetp); |
3659 | 1086 DEFSYMBOL (Qregistries); |
563 | 1087 DEFSYMBOL (Qfinal); |
1088 DEFSYMBOL (Qgraphic); | |
3659 | 1089 DEFSYMBOL (Qregistry); |
563 | 1090 DEFSYMBOL (Qdirection); |
1091 DEFSYMBOL (Qreverse_direction_charset); | |
1092 DEFSYMBOL (Qshort_name); | |
1093 DEFSYMBOL (Qlong_name); | |
428 | 1094 |
771 | 1095 DEFSYMBOL (Qto_unicode); |
1096 | |
563 | 1097 DEFSYMBOL (Ql2r); |
1098 DEFSYMBOL (Qr2l); | |
428 | 1099 |
1100 /* Charsets, compatible with FSF 20.3 | |
1101 Naming convention is Script-Charset[-Edition] */ | |
563 | 1102 DEFSYMBOL (Qlatin_iso8859_1); |
1103 DEFSYMBOL (Qlatin_iso8859_2); | |
1104 DEFSYMBOL (Qlatin_iso8859_3); | |
1105 DEFSYMBOL (Qlatin_iso8859_4); | |
1106 DEFSYMBOL (Qthai_tis620); | |
1107 DEFSYMBOL (Qgreek_iso8859_7); | |
4805
980575c76541
Move the arabic-iso8859-6 character set back to C, otherwise X11 lookup fails.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4745
diff
changeset
|
1108 DEFSYMBOL (Qarabic_iso8859_6); |
563 | 1109 DEFSYMBOL (Qhebrew_iso8859_8); |
1110 DEFSYMBOL (Qkatakana_jisx0201); | |
1111 DEFSYMBOL (Qlatin_jisx0201); | |
1112 DEFSYMBOL (Qcyrillic_iso8859_5); | |
1113 DEFSYMBOL (Qlatin_iso8859_9); | |
728 | 1114 DEFSYMBOL (Qlatin_iso8859_15); |
563 | 1115 DEFSYMBOL (Qjapanese_jisx0208_1978); |
1116 DEFSYMBOL (Qchinese_gb2312); | |
1117 DEFSYMBOL (Qjapanese_jisx0208); | |
1118 DEFSYMBOL (Qkorean_ksc5601); | |
1119 DEFSYMBOL (Qjapanese_jisx0212); | |
1120 DEFSYMBOL (Qchinese_cns11643_1); | |
1121 DEFSYMBOL (Qchinese_cns11643_2); | |
1122 DEFSYMBOL (Qchinese_big5_1); | |
1123 DEFSYMBOL (Qchinese_big5_2); | |
428 | 1124 |
563 | 1125 DEFSYMBOL (Qcomposite); |
428 | 1126 } |
1127 | |
1128 void | |
1129 vars_of_mule_charset (void) | |
1130 { | |
1131 int i, j, k; | |
1132 | |
452 | 1133 chlook = xnew_and_zero (struct charset_lookup); /* zero for Purify. */ |
2367 | 1134 dump_add_root_block_ptr (&chlook, &charset_lookup_description); |
428 | 1135 |
1136 /* Table of charsets indexed by leading byte. */ | |
1137 for (i = 0; i < countof (chlook->charset_by_leading_byte); i++) | |
1138 chlook->charset_by_leading_byte[i] = Qnil; | |
1139 | |
1140 /* Table of charsets indexed by type/final-byte/direction. */ | |
1141 for (i = 0; i < countof (chlook->charset_by_attributes); i++) | |
1142 for (j = 0; j < countof (chlook->charset_by_attributes[0]); j++) | |
1143 for (k = 0; k < countof (chlook->charset_by_attributes[0][0]); k++) | |
1144 chlook->charset_by_attributes[i][j][k] = Qnil; | |
1145 | |
442 | 1146 chlook->next_allocated_1_byte_leading_byte = MIN_LEADING_BYTE_PRIVATE_1; |
1147 chlook->next_allocated_2_byte_leading_byte = MIN_LEADING_BYTE_PRIVATE_2; | |
771 | 1148 |
1149 staticpro (&Vcharset_hash_table); | |
1150 Vcharset_hash_table = | |
1151 make_lisp_hash_table (50, HASH_TABLE_NON_WEAK, HASH_TABLE_EQ); | |
428 | 1152 } |
1153 | |
1154 void | |
1155 complex_vars_of_mule_charset (void) | |
1156 { | |
1157 /* Predefined character sets. We store them into variables for | |
1158 ease of access. */ | |
1159 | |
1160 staticpro (&Vcharset_ascii); | |
1161 Vcharset_ascii = | |
1162 make_charset (LEADING_BYTE_ASCII, Qascii, 1, | |
1163 CHARSET_TYPE_94, 1, 0, 'B', | |
1164 CHARSET_LEFT_TO_RIGHT, | |
1165 build_string ("ASCII"), | |
771 | 1166 build_msg_string ("ASCII"), |
1167 build_msg_string ("ASCII (ISO646 IRV)"), | |
3659 | 1168 vector1(build_string("iso8859-1")), 0, 0); |
428 | 1169 staticpro (&Vcharset_control_1); |
1170 Vcharset_control_1 = | |
1171 make_charset (LEADING_BYTE_CONTROL_1, Qcontrol_1, 2, | |
1172 CHARSET_TYPE_94, 1, 1, 0, | |
1173 CHARSET_LEFT_TO_RIGHT, | |
1174 build_string ("C1"), | |
771 | 1175 build_msg_string ("Control characters"), |
1176 build_msg_string ("Control characters 128-191"), | |
3659 | 1177 vector1(build_string("iso8859-1")), 0, 0); |
428 | 1178 staticpro (&Vcharset_latin_iso8859_1); |
1179 Vcharset_latin_iso8859_1 = | |
1180 make_charset (LEADING_BYTE_LATIN_ISO8859_1, Qlatin_iso8859_1, 2, | |
1181 CHARSET_TYPE_96, 1, 1, 'A', | |
1182 CHARSET_LEFT_TO_RIGHT, | |
1183 build_string ("Latin-1"), | |
771 | 1184 build_msg_string ("ISO8859-1 (Latin-1)"), |
1185 build_msg_string ("ISO8859-1 (Latin-1)"), | |
3659 | 1186 vector1(build_string("iso8859-1")), 0, 0); |
428 | 1187 staticpro (&Vcharset_latin_iso8859_2); |
1188 Vcharset_latin_iso8859_2 = | |
1189 make_charset (LEADING_BYTE_LATIN_ISO8859_2, Qlatin_iso8859_2, 2, | |
1190 CHARSET_TYPE_96, 1, 1, 'B', | |
1191 CHARSET_LEFT_TO_RIGHT, | |
1192 build_string ("Latin-2"), | |
771 | 1193 build_msg_string ("ISO8859-2 (Latin-2)"), |
1194 build_msg_string ("ISO8859-2 (Latin-2)"), | |
3659 | 1195 vector1(build_string("iso8859-2")), 0, 0); |
428 | 1196 staticpro (&Vcharset_latin_iso8859_3); |
1197 Vcharset_latin_iso8859_3 = | |
1198 make_charset (LEADING_BYTE_LATIN_ISO8859_3, Qlatin_iso8859_3, 2, | |
1199 CHARSET_TYPE_96, 1, 1, 'C', | |
1200 CHARSET_LEFT_TO_RIGHT, | |
1201 build_string ("Latin-3"), | |
771 | 1202 build_msg_string ("ISO8859-3 (Latin-3)"), |
1203 build_msg_string ("ISO8859-3 (Latin-3)"), | |
3659 | 1204 vector1(build_string("iso8859-3")), 0, 0); |
428 | 1205 staticpro (&Vcharset_latin_iso8859_4); |
1206 Vcharset_latin_iso8859_4 = | |
1207 make_charset (LEADING_BYTE_LATIN_ISO8859_4, Qlatin_iso8859_4, 2, | |
1208 CHARSET_TYPE_96, 1, 1, 'D', | |
1209 CHARSET_LEFT_TO_RIGHT, | |
1210 build_string ("Latin-4"), | |
771 | 1211 build_msg_string ("ISO8859-4 (Latin-4)"), |
1212 build_msg_string ("ISO8859-4 (Latin-4)"), | |
3816 | 1213 vector1(build_string("iso8859-4")), 0, 0); |
428 | 1214 staticpro (&Vcharset_thai_tis620); |
1215 Vcharset_thai_tis620 = | |
1216 make_charset (LEADING_BYTE_THAI_TIS620, Qthai_tis620, 2, | |
1217 CHARSET_TYPE_96, 1, 1, 'T', | |
1218 CHARSET_LEFT_TO_RIGHT, | |
1219 build_string ("TIS620"), | |
771 | 1220 build_msg_string ("TIS620 (Thai)"), |
1221 build_msg_string ("TIS620.2529 (Thai)"), | |
3659 | 1222 vector1(build_string("tis620.2529-1")), 0, 0); |
428 | 1223 staticpro (&Vcharset_greek_iso8859_7); |
1224 Vcharset_greek_iso8859_7 = | |
1225 make_charset (LEADING_BYTE_GREEK_ISO8859_7, Qgreek_iso8859_7, 2, | |
1226 CHARSET_TYPE_96, 1, 1, 'F', | |
1227 CHARSET_LEFT_TO_RIGHT, | |
1228 build_string ("ISO8859-7"), | |
771 | 1229 build_msg_string ("ISO8859-7 (Greek)"), |
1230 build_msg_string ("ISO8859-7 (Greek)"), | |
3659 | 1231 vector1(build_string("iso8859-7")), 0, 0); |
4805
980575c76541
Move the arabic-iso8859-6 character set back to C, otherwise X11 lookup fails.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4745
diff
changeset
|
1232 staticpro (&Vcharset_arabic_iso8859_6); |
980575c76541
Move the arabic-iso8859-6 character set back to C, otherwise X11 lookup fails.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4745
diff
changeset
|
1233 Vcharset_arabic_iso8859_6 = |
980575c76541
Move the arabic-iso8859-6 character set back to C, otherwise X11 lookup fails.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4745
diff
changeset
|
1234 make_charset (LEADING_BYTE_ARABIC_ISO8859_6, Qarabic_iso8859_6, 2, |
980575c76541
Move the arabic-iso8859-6 character set back to C, otherwise X11 lookup fails.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4745
diff
changeset
|
1235 CHARSET_TYPE_96, 1, 1, 'G', |
980575c76541
Move the arabic-iso8859-6 character set back to C, otherwise X11 lookup fails.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4745
diff
changeset
|
1236 CHARSET_RIGHT_TO_LEFT, |
980575c76541
Move the arabic-iso8859-6 character set back to C, otherwise X11 lookup fails.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4745
diff
changeset
|
1237 build_string ("ISO8859-6"), |
980575c76541
Move the arabic-iso8859-6 character set back to C, otherwise X11 lookup fails.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4745
diff
changeset
|
1238 build_msg_string ("ISO8859-6 (Arabic)"), |
980575c76541
Move the arabic-iso8859-6 character set back to C, otherwise X11 lookup fails.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4745
diff
changeset
|
1239 build_msg_string ("ISO8859-6 (Arabic)"), |
980575c76541
Move the arabic-iso8859-6 character set back to C, otherwise X11 lookup fails.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4745
diff
changeset
|
1240 vector1(build_string ("iso8859-6")), 0, 0); |
428 | 1241 staticpro (&Vcharset_hebrew_iso8859_8); |
1242 Vcharset_hebrew_iso8859_8 = | |
1243 make_charset (LEADING_BYTE_HEBREW_ISO8859_8, Qhebrew_iso8859_8, 2, | |
1244 CHARSET_TYPE_96, 1, 1, 'H', | |
1245 CHARSET_RIGHT_TO_LEFT, | |
1246 build_string ("ISO8859-8"), | |
771 | 1247 build_msg_string ("ISO8859-8 (Hebrew)"), |
1248 build_msg_string ("ISO8859-8 (Hebrew)"), | |
3659 | 1249 vector1(build_string ("iso8859-8")), 0, 0); |
428 | 1250 staticpro (&Vcharset_katakana_jisx0201); |
1251 Vcharset_katakana_jisx0201 = | |
1252 make_charset (LEADING_BYTE_KATAKANA_JISX0201, Qkatakana_jisx0201, 2, | |
1253 CHARSET_TYPE_94, 1, 1, 'I', | |
1254 CHARSET_LEFT_TO_RIGHT, | |
1255 build_string ("JISX0201 Kana"), | |
771 | 1256 build_msg_string ("JISX0201.1976 (Japanese Kana)"), |
1257 build_msg_string ("JISX0201.1976 Japanese Kana"), | |
3659 | 1258 vector1(build_string ("jisx0201.1976-0")), 0, 0); |
428 | 1259 staticpro (&Vcharset_latin_jisx0201); |
1260 Vcharset_latin_jisx0201 = | |
1261 make_charset (LEADING_BYTE_LATIN_JISX0201, Qlatin_jisx0201, 2, | |
1262 CHARSET_TYPE_94, 1, 0, 'J', | |
1263 CHARSET_LEFT_TO_RIGHT, | |
1264 build_string ("JISX0201 Roman"), | |
771 | 1265 build_msg_string ("JISX0201.1976 (Japanese Roman)"), |
1266 build_msg_string ("JISX0201.1976 Japanese Roman"), | |
3659 | 1267 vector1(build_string ("jisx0201.1976-0")), 0, 0); |
428 | 1268 staticpro (&Vcharset_cyrillic_iso8859_5); |
1269 Vcharset_cyrillic_iso8859_5 = | |
1270 make_charset (LEADING_BYTE_CYRILLIC_ISO8859_5, Qcyrillic_iso8859_5, 2, | |
1271 CHARSET_TYPE_96, 1, 1, 'L', | |
1272 CHARSET_LEFT_TO_RIGHT, | |
1273 build_string ("ISO8859-5"), | |
771 | 1274 build_msg_string ("ISO8859-5 (Cyrillic)"), |
1275 build_msg_string ("ISO8859-5 (Cyrillic)"), | |
3659 | 1276 vector1(build_string ("iso8859-5")), 0, 0); |
428 | 1277 staticpro (&Vcharset_latin_iso8859_9); |
1278 Vcharset_latin_iso8859_9 = | |
1279 make_charset (LEADING_BYTE_LATIN_ISO8859_9, Qlatin_iso8859_9, 2, | |
1280 CHARSET_TYPE_96, 1, 1, 'M', | |
1281 CHARSET_LEFT_TO_RIGHT, | |
1282 build_string ("Latin-5"), | |
771 | 1283 build_msg_string ("ISO8859-9 (Latin-5)"), |
1284 build_msg_string ("ISO8859-9 (Latin-5)"), | |
3659 | 1285 vector1(build_string ("iso8859-9")), 0, 0); |
728 | 1286 staticpro (&Vcharset_latin_iso8859_15); |
1287 Vcharset_latin_iso8859_15 = | |
1288 make_charset (LEADING_BYTE_LATIN_ISO8859_15, Qlatin_iso8859_15, 2, | |
1289 CHARSET_TYPE_96, 1, 1, 'b', | |
1290 CHARSET_LEFT_TO_RIGHT, | |
1291 build_string ("Latin-9"), | |
771 | 1292 build_msg_string ("ISO8859-15 (Latin-9)"), |
1293 build_msg_string ("ISO8859-15 (Latin-9)"), | |
3659 | 1294 vector1(build_string ("iso8859-15")), 0, 0); |
428 | 1295 staticpro (&Vcharset_japanese_jisx0208_1978); |
1296 Vcharset_japanese_jisx0208_1978 = | |
1297 make_charset (LEADING_BYTE_JAPANESE_JISX0208_1978, Qjapanese_jisx0208_1978, 3, | |
1298 CHARSET_TYPE_94X94, 2, 0, '@', | |
1299 CHARSET_LEFT_TO_RIGHT, | |
1300 build_string ("JISX0208.1978"), | |
771 | 1301 build_msg_string ("JISX0208.1978 (Japanese)"), |
1302 build_msg_string | |
428 | 1303 ("JISX0208.1978 Japanese Kanji (so called \"old JIS\")"), |
3659 | 1304 vector2(build_string("jisx0208.1978-0"), |
1305 build_string("jisc6226.1978-0")), 0, 0); | |
428 | 1306 staticpro (&Vcharset_chinese_gb2312); |
1307 Vcharset_chinese_gb2312 = | |
1308 make_charset (LEADING_BYTE_CHINESE_GB2312, Qchinese_gb2312, 3, | |
1309 CHARSET_TYPE_94X94, 2, 0, 'A', | |
1310 CHARSET_LEFT_TO_RIGHT, | |
1311 build_string ("GB2312"), | |
771 | 1312 build_msg_string ("GB2312)"), |
1313 build_msg_string ("GB2312 Chinese simplified"), | |
3659 | 1314 vector2(build_string("gb2312.1980-0"), |
1315 build_string("gb2312.80&gb8565.88-0")), 0, 0); | |
428 | 1316 staticpro (&Vcharset_japanese_jisx0208); |
1317 Vcharset_japanese_jisx0208 = | |
1318 make_charset (LEADING_BYTE_JAPANESE_JISX0208, Qjapanese_jisx0208, 3, | |
1319 CHARSET_TYPE_94X94, 2, 0, 'B', | |
1320 CHARSET_LEFT_TO_RIGHT, | |
1321 build_string ("JISX0208"), | |
771 | 1322 build_msg_string ("JISX0208.1983/1990 (Japanese)"), |
1323 build_msg_string ("JISX0208.1983/1990 Japanese Kanji"), | |
3659 | 1324 vector2(build_string("jisx0208.1983-0"), |
1325 build_string("jisx0208.1990-0")), 0, 0); | |
428 | 1326 staticpro (&Vcharset_korean_ksc5601); |
1327 Vcharset_korean_ksc5601 = | |
1328 make_charset (LEADING_BYTE_KOREAN_KSC5601, Qkorean_ksc5601, 3, | |
1329 CHARSET_TYPE_94X94, 2, 0, 'C', | |
1330 CHARSET_LEFT_TO_RIGHT, | |
1331 build_string ("KSC5601"), | |
771 | 1332 build_msg_string ("KSC5601 (Korean"), |
1333 build_msg_string ("KSC5601 Korean Hangul and Hanja"), | |
3659 | 1334 vector1(build_string("ksc5601.1987-0")), 0, 0); |
428 | 1335 staticpro (&Vcharset_japanese_jisx0212); |
1336 Vcharset_japanese_jisx0212 = | |
1337 make_charset (LEADING_BYTE_JAPANESE_JISX0212, Qjapanese_jisx0212, 3, | |
1338 CHARSET_TYPE_94X94, 2, 0, 'D', | |
1339 CHARSET_LEFT_TO_RIGHT, | |
1340 build_string ("JISX0212"), | |
771 | 1341 build_msg_string ("JISX0212 (Japanese)"), |
1342 build_msg_string ("JISX0212 Japanese Supplement"), | |
3659 | 1343 vector1(build_string("jisx0212.1990-0")), 0, 0); |
428 | 1344 |
3659 | 1345 #define CHINESE_CNS_PLANE(n) "cns11643.1992-" n |
428 | 1346 staticpro (&Vcharset_chinese_cns11643_1); |
1347 Vcharset_chinese_cns11643_1 = | |
1348 make_charset (LEADING_BYTE_CHINESE_CNS11643_1, Qchinese_cns11643_1, 3, | |
1349 CHARSET_TYPE_94X94, 2, 0, 'G', | |
1350 CHARSET_LEFT_TO_RIGHT, | |
1351 build_string ("CNS11643-1"), | |
771 | 1352 build_msg_string ("CNS11643-1 (Chinese traditional)"), |
1353 build_msg_string | |
428 | 1354 ("CNS 11643 Plane 1 Chinese traditional"), |
3659 | 1355 vector1(build_string (CHINESE_CNS_PLANE("1"))), 0, 0); |
428 | 1356 staticpro (&Vcharset_chinese_cns11643_2); |
1357 Vcharset_chinese_cns11643_2 = | |
1358 make_charset (LEADING_BYTE_CHINESE_CNS11643_2, Qchinese_cns11643_2, 3, | |
1359 CHARSET_TYPE_94X94, 2, 0, 'H', | |
1360 CHARSET_LEFT_TO_RIGHT, | |
1361 build_string ("CNS11643-2"), | |
771 | 1362 build_msg_string ("CNS11643-2 (Chinese traditional)"), |
1363 build_msg_string | |
428 | 1364 ("CNS 11643 Plane 2 Chinese traditional"), |
3659 | 1365 vector1(build_string (CHINESE_CNS_PLANE("2"))), 0, 0); |
428 | 1366 staticpro (&Vcharset_chinese_big5_1); |
1367 Vcharset_chinese_big5_1 = | |
1368 make_charset (LEADING_BYTE_CHINESE_BIG5_1, Qchinese_big5_1, 3, | |
1369 CHARSET_TYPE_94X94, 2, 0, '0', | |
1370 CHARSET_LEFT_TO_RIGHT, | |
1371 build_string ("Big5"), | |
771 | 1372 build_msg_string ("Big5 (Level-1)"), |
1373 build_msg_string | |
428 | 1374 ("Big5 Level-1 Chinese traditional"), |
3659 | 1375 vector1(build_string ("big5.eten-0")), 0, 0); |
428 | 1376 staticpro (&Vcharset_chinese_big5_2); |
1377 Vcharset_chinese_big5_2 = | |
1378 make_charset (LEADING_BYTE_CHINESE_BIG5_2, Qchinese_big5_2, 3, | |
1379 CHARSET_TYPE_94X94, 2, 0, '1', | |
1380 CHARSET_LEFT_TO_RIGHT, | |
1381 build_string ("Big5"), | |
771 | 1382 build_msg_string ("Big5 (Level-2)"), |
1383 build_msg_string | |
428 | 1384 ("Big5 Level-2 Chinese traditional"), |
3659 | 1385 vector1(build_string ("big5.eten-0")), 0, 0); |
428 | 1386 |
1387 | |
1388 #ifdef ENABLE_COMPOSITE_CHARS | |
1389 /* #### For simplicity, we put composite chars into a 96x96 charset. | |
1390 This is going to lead to problems because you can run out of | |
1391 room, esp. as we don't yet recycle numbers. */ | |
1392 staticpro (&Vcharset_composite); | |
1393 Vcharset_composite = | |
1394 make_charset (LEADING_BYTE_COMPOSITE, Qcomposite, 3, | |
1395 CHARSET_TYPE_96X96, 2, 0, 0, | |
1396 CHARSET_LEFT_TO_RIGHT, | |
1397 build_string ("Composite"), | |
771 | 1398 build_msg_string ("Composite characters"), |
1399 build_msg_string ("Composite characters"), | |
3659 | 1400 vector1(build_string ("")), 0, 0); |
771 | 1401 #else |
1402 /* We create a hack so that we have a way of storing ESC 0 and ESC 1 | |
1403 sequences as "characters", so that they will be output correctly. */ | |
1404 staticpro (&Vcharset_composite); | |
1405 Vcharset_composite = | |
1406 make_charset (LEADING_BYTE_COMPOSITE_REPLACEMENT, Qcomposite, 2, | |
1407 CHARSET_TYPE_96, 1, 1, '|', | |
1408 CHARSET_LEFT_TO_RIGHT, | |
1409 build_string ("Composite hack"), | |
1410 build_msg_string ("Composite characters hack"), | |
1411 build_msg_string ("Composite characters hack"), | |
3659 | 1412 vector1(build_string ("")), 0, 0); |
428 | 1413 #endif /* ENABLE_COMPOSITE_CHARS */ |
1414 } |