1 /* Multilingual characters handler.
3 Copyright (C) 1995 Free Software Foundation, Inc.
4 Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs; 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. */
23 /* At first, see the document in `charset.h' to understand the code in
30 #include <sys/types.h>
43 Lisp_Object Qcharset
, Qascii
, Qcomposition
;
45 /* Declaration of special leading-codes. */
46 int leading_code_composition
; /* for composite characters */
47 int leading_code_private_11
; /* for private DIMENSION1 of 1-column */
48 int leading_code_private_12
; /* for private DIMENSION1 of 2-column */
49 int leading_code_private_21
; /* for private DIMENSION2 of 1-column */
50 int leading_code_private_22
; /* for private DIMENSION2 of 2-column */
52 /* Declaration of special charsets. */
53 int charset_ascii
; /* ASCII */
54 int charset_composition
; /* for a composite character */
55 int charset_latin_iso8859_1
; /* ISO8859-1 (Latin-1) */
56 int charset_jisx0208_1978
; /* JISX0208.1978 (Japanese Kanji old set) */
57 int charset_jisx0208
; /* JISX0208.1983 (Japanese Kanji) */
58 int charset_katakana_jisx0201
; /* JISX0201.Kana (Japanese Katakana) */
59 int charset_latin_jisx0201
; /* JISX0201.Roman (Japanese Roman) */
60 int charset_big5_1
; /* Big5 Level 1 (Chinese Traditional) */
61 int charset_big5_2
; /* Big5 Level 2 (Chinese Traditional) */
63 Lisp_Object Qcharset_table
;
65 /* A char-table containing information of each character set. */
66 Lisp_Object Vcharset_table
;
68 /* A vector of charset symbol indexed by charset-id. This is used
69 only for returning charset symbol from C functions. */
70 Lisp_Object Vcharset_symbol_table
;
72 /* A list of charset symbols ever defined. */
73 Lisp_Object Vcharset_list
;
75 /* Tables used by macros BYTES_BY_CHAR_HEAD and WIDTH_BY_CHAR_HEAD. */
76 int bytes_by_char_head
[256];
77 int width_by_char_head
[256];
79 /* Mapping table from ISO2022's charset (specified by DIMENSION,
80 CHARS, and FINAL-CHAR) to Emacs' charset. */
81 int iso_charset_table
[2][2][128];
83 /* Table of pointers to the structure `cmpchar_info' indexed by
85 struct cmpchar_info
**cmpchar_table
;
86 /* The current size of `cmpchar_table'. */
87 static int cmpchar_table_size
;
88 /* Number of the current composite characters. */
91 /* Variables used locally in the macro FETCH_MULTIBYTE_CHAR. */
92 unsigned char *_fetch_multibyte_char_p
;
93 int _fetch_multibyte_char_len
;
95 /* Set STR a pointer to the multi-byte form of the character C. If C
96 is not a composite character, the multi-byte form is set in WORKBUF
97 and STR points WORKBUF. The caller should allocate at least 4-byte
98 area at WORKBUF in advance. Returns the length of the multi-byte
101 Use macro `CHAR_STRING (C, WORKBUF, STR)' instead of calling this
102 function directly if C can be an ASCII character. */
105 non_ascii_char_to_string (c
, workbuf
, str
)
107 unsigned char *workbuf
, **str
;
111 if (COMPOSITE_CHAR_P (c
))
113 int cmpchar_id
= COMPOSITE_CHAR_ID (c
);
115 if (cmpchar_id
< n_cmpchars
)
117 *str
= cmpchar_table
[cmpchar_id
]->data
;
118 return cmpchar_table
[cmpchar_id
]->len
;
127 SPLIT_NON_ASCII_CHAR (c
, charset
, c1
, c2
);
130 *workbuf
++ = CHARSET_LEADING_CODE_BASE (charset
);
131 if (*workbuf
= CHARSET_LEADING_CODE_EXT (charset
))
133 *workbuf
++ = c1
| 0x80;
135 *workbuf
++ = c2
| 0x80;
137 return (workbuf
- *str
);
140 /* Return a non-ASCII character of which multi-byte form is at STR of
141 length LEN. If ACTUAL_LEN is not NULL, the actual length of the
142 character is set to the address ACTUAL_LEN.
144 Use macro `STRING_CHAR (STR, LEN)' instead of calling this function
145 directly if STR can hold an ASCII character. */
147 string_to_non_ascii_char (str
, len
, actual_len
)
149 int len
, *actual_len
;
152 unsigned char c1
, c2
;
155 if (SPLIT_STRING (str
, len
, charset
, c1
, c2
) == CHARSET_ASCII
)
162 c
= MAKE_NON_ASCII_CHAR (charset
, c1
, c2
);
165 *actual_len
= (charset
== CHARSET_COMPOSITION
166 ? cmpchar_table
[COMPOSITE_CHAR_ID (c
)]->len
167 : BYTES_BY_CHAR_HEAD (*str
));
171 /* Return the length of the multi-byte form at string STR of length LEN. */
173 multibyte_form_length (str
, len
)
178 unsigned char c1
, c2
;
181 if (SPLIT_STRING (str
, len
, charset
, c1
, c2
) == CHARSET_ASCII
)
184 return (charset
== CHARSET_COMPOSITION
185 ? cmpchar_table
[(c1
<< 7) | c2
]->len
186 : BYTES_BY_CHAR_HEAD (*str
));
189 /* Check if string STR of length LEN contains valid multi-byte form of
190 a character. If valid, charset and position codes of the character
191 is set at *CHARSET, *C1, and *C2, and return 0. If not valid,
192 return -1. This should be used only in the macro SPLIT_STRING
193 which checks range of STR in advance. */
195 split_non_ascii_string (str
, len
, charset
, c1
, c2
)
196 register unsigned char *str
, *c1
, *c2
;
197 register int len
, *charset
;
199 register unsigned int cs
= *str
++;
201 if (cs
== LEADING_CODE_COMPOSITION
)
203 int cmpchar_id
= str_cmpchar_id (str
- 1, len
);
207 *charset
= cs
, *c1
= cmpchar_id
>> 7, *c2
= cmpchar_id
& 0x7F;
209 else if ((cs
< LEADING_CODE_PRIVATE_11
|| (cs
= *str
++) >= 0xA0)
210 && CHARSET_DEFINED_P (cs
))
215 *c1
= (*str
++) & 0x7F;
216 if (CHARSET_DIMENSION (cs
) == 2)
220 *c2
= (*str
++) & 0x7F;
228 /* Return a character unified with C (or a character made of CHARSET,
229 C1, and C2) in unification table TABLE. If no unification is found
230 in TABLE, return C. */
231 unify_char (table
, c
, charset
, c1
, c2
)
233 int c
, charset
, c1
, c2
;
236 int alt_charset
, alt_c1
, alt_c2
, dimension
;
238 if (c
< 0) c
= MAKE_CHAR (charset
, c1
, c2
);
239 if (!CHAR_TABLE_P (table
)
240 || (ch
= Faref (table
, make_number (c
)), !INTEGERP (ch
))
244 SPLIT_CHAR (XFASTINT (ch
), alt_charset
, alt_c1
, alt_c2
);
245 dimension
= CHARSET_DIMENSION (alt_charset
);
246 if (dimension
== 1 && alt_c1
> 0 || dimension
== 2 && alt_c2
> 0)
247 /* CH is not a generic character, just return it. */
248 return XFASTINT (ch
);
250 /* Since CH is a generic character, we must return a specific
251 charater which has the same position codes as C from CH. */
253 SPLIT_CHAR (c
, charset
, c1
, c2
);
254 if (dimension
!= CHARSET_DIMENSION (charset
))
255 /* We can't make such a character because of dimension mismatch. */
257 if (!alt_c1
) alt_c1
= c1
;
258 if (!alt_c2
) alt_c2
= c2
;
259 return MAKE_CHAR (alt_charset
, c1
, c2
);
262 /* Update the table Vcharset_table with the given arguments (see the
263 document of `define-charset' for the meaning of each argument).
264 Several other table contents are also updated. The caller should
265 check the validity of CHARSET-ID and the remaining arguments in
269 update_charset_table (charset_id
, dimension
, chars
, width
, direction
,
270 iso_final_char
, iso_graphic_plane
,
271 short_name
, long_name
, description
)
272 Lisp_Object charset_id
, dimension
, chars
, width
, direction
;
273 Lisp_Object iso_final_char
, iso_graphic_plane
;
274 Lisp_Object short_name
, long_name
, description
;
276 int charset
= XINT (charset_id
);
278 unsigned char leading_code_base
, leading_code_ext
;
280 if (NILP (CHARSET_TABLE_ENTRY (charset
)))
281 CHARSET_TABLE_ENTRY (charset
)
282 = Fmake_vector (make_number (CHARSET_MAX_IDX
), Qnil
);
284 /* Get byte length of multibyte form, base leading-code, and
285 extended leading-code of the charset. See the comment under the
286 title "GENERAL NOTE on CHARACTER SET (CHARSET)" in charset.h. */
287 bytes
= XINT (dimension
);
288 if (charset
< MIN_CHARSET_PRIVATE_DIMENSION1
)
290 /* Official charset, it doesn't have an extended leading-code. */
291 if (charset
!= CHARSET_ASCII
)
292 bytes
+= 1; /* For a base leading-code. */
293 leading_code_base
= charset
;
294 leading_code_ext
= 0;
298 /* Private charset. */
299 bytes
+= 2; /* For base and extended leading-codes. */
301 = (charset
< LEADING_CODE_EXT_12
302 ? LEADING_CODE_PRIVATE_11
303 : (charset
< LEADING_CODE_EXT_21
304 ? LEADING_CODE_PRIVATE_12
305 : (charset
< LEADING_CODE_EXT_22
306 ? LEADING_CODE_PRIVATE_21
307 : LEADING_CODE_PRIVATE_22
)));
308 leading_code_ext
= charset
;
311 CHARSET_TABLE_INFO (charset
, CHARSET_ID_IDX
) = charset_id
;
312 CHARSET_TABLE_INFO (charset
, CHARSET_BYTES_IDX
) = make_number (bytes
);
313 CHARSET_TABLE_INFO (charset
, CHARSET_DIMENSION_IDX
) = dimension
;
314 CHARSET_TABLE_INFO (charset
, CHARSET_CHARS_IDX
) = chars
;
315 CHARSET_TABLE_INFO (charset
, CHARSET_WIDTH_IDX
) = width
;
316 CHARSET_TABLE_INFO (charset
, CHARSET_DIRECTION_IDX
) = direction
;
317 CHARSET_TABLE_INFO (charset
, CHARSET_LEADING_CODE_BASE_IDX
)
318 = make_number (leading_code_base
);
319 CHARSET_TABLE_INFO (charset
, CHARSET_LEADING_CODE_EXT_IDX
)
320 = make_number (leading_code_ext
);
321 CHARSET_TABLE_INFO (charset
, CHARSET_ISO_FINAL_CHAR_IDX
) = iso_final_char
;
322 CHARSET_TABLE_INFO (charset
, CHARSET_ISO_GRAPHIC_PLANE_IDX
)
324 CHARSET_TABLE_INFO (charset
, CHARSET_SHORT_NAME_IDX
) = short_name
;
325 CHARSET_TABLE_INFO (charset
, CHARSET_LONG_NAME_IDX
) = long_name
;
326 CHARSET_TABLE_INFO (charset
, CHARSET_DESCRIPTION_IDX
) = description
;
327 CHARSET_TABLE_INFO (charset
, CHARSET_PLIST_IDX
) = Qnil
;
330 /* If we have already defined a charset which has the same
331 DIMENSION, CHARS and ISO-FINAL-CHAR but the different
332 DIRECTION, we must update the entry REVERSE-CHARSET of both
333 charsets. If there's no such charset, the value of the entry
337 for (i
= 0; i
<= MAX_CHARSET
; i
++)
338 if (!NILP (CHARSET_TABLE_ENTRY (i
)))
340 if (CHARSET_DIMENSION (i
) == XINT (dimension
)
341 && CHARSET_CHARS (i
) == XINT (chars
)
342 && CHARSET_ISO_FINAL_CHAR (i
) == XINT (iso_final_char
)
343 && CHARSET_DIRECTION (i
) != XINT (direction
))
345 CHARSET_TABLE_INFO (charset
, CHARSET_REVERSE_CHARSET_IDX
)
347 CHARSET_TABLE_INFO (i
, CHARSET_REVERSE_CHARSET_IDX
) = charset_id
;
352 /* No such a charset. */
353 CHARSET_TABLE_INFO (charset
, CHARSET_REVERSE_CHARSET_IDX
)
357 if (charset
!= CHARSET_ASCII
358 && charset
< MIN_CHARSET_PRIVATE_DIMENSION1
)
360 /* Update tables bytes_by_char_head and width_by_char_head. */
361 bytes_by_char_head
[leading_code_base
] = bytes
;
362 width_by_char_head
[leading_code_base
] = XINT (width
);
364 /* Update table emacs_code_class. */
365 emacs_code_class
[charset
] = (bytes
== 2
366 ? EMACS_leading_code_2
368 ? EMACS_leading_code_3
369 : EMACS_leading_code_4
));
372 /* Update table iso_charset_table. */
373 if (ISO_CHARSET_TABLE (dimension
, chars
, iso_final_char
) < 0)
374 ISO_CHARSET_TABLE (dimension
, chars
, iso_final_char
) = charset
;
379 /* Return charset id of CHARSET_SYMBOL, or return -1 if CHARSET_SYMBOL
382 get_charset_id (charset_symbol
)
383 Lisp_Object charset_symbol
;
388 return ((SYMBOLP (charset_symbol
)
389 && (val
= Fget (charset_symbol
, Qcharset
), VECTORP (val
))
390 && (charset
= XINT (XVECTOR (val
)->contents
[CHARSET_ID_IDX
]),
391 CHARSET_VALID_P (charset
)))
395 /* Return an identification number for a new private charset of
396 DIMENSION and WIDTH. If there's no more room for the new charset,
399 get_new_private_charset_id (dimension
, width
)
400 int dimension
, width
;
402 int charset
, from
, to
;
407 from
= LEADING_CODE_EXT_11
, to
= LEADING_CODE_EXT_12
;
409 from
= LEADING_CODE_EXT_12
, to
= LEADING_CODE_EXT_21
;
414 from
= LEADING_CODE_EXT_21
, to
= LEADING_CODE_EXT_22
;
416 from
= LEADING_CODE_EXT_22
, to
= LEADING_CODE_EXT_MAX
- 1;
419 for (charset
= from
; charset
< to
; charset
++)
420 if (!CHARSET_DEFINED_P (charset
)) break;
422 return make_number (charset
< to
? charset
: 0);
425 DEFUN ("define-charset", Fdefine_charset
, Sdefine_charset
, 3, 3, 0,
426 "Define CHARSET-ID as the identification number of CHARSET with INFO-VECTOR.\n\
427 If CHARSET-ID is nil, it is decided automatically, which means CHARSET is\n\
428 treated as a private charset.\n\
429 INFO-VECTOR is a vector of the format:\n\
430 [DIMENSION CHARS WIDTH DIRECTION ISO-FINAL-CHAR ISO-GRAPHIC-PLANE\n\
431 SHORT-NAME LONG-NAME DESCRIPTION]\n\
432 The meanings of each elements is as follows:\n\
433 DIMENSION (integer) is the number of bytes to represent a character: 1 or 2.\n\
434 CHARS (integer) is the number of characters in a dimension: 94 or 96.\n\
435 WIDTH (integer) is the number of columns a character in the charset\n\
436 occupies on the screen: one of 0, 1, and 2.\n\
438 DIRECTION (integer) is the rendering direction of characters in the\n\
439 charset when rendering. If 0, render from right to left, else\n\
440 render from left to right.\n\
442 ISO-FINAL-CHAR (character) is the final character of the\n\
443 corresponding ISO 2022 charset.\n\
445 ISO-GRAPHIC-PLANE (integer) is the graphic plane to be invoked\n\
446 while encoding to variants of ISO 2022 coding system, one of the\n\
447 following: 0/graphic-plane-left(GL), 1/graphic-plane-right(GR).\n\
449 SHORT-NAME (string) is the short name to refer to the charset.\n\
451 LONG-NAME (string) is the long name to refer to the charset.\n\
453 DESCRIPTION (string) is the description string of the charset.")
454 (charset_id
, charset_symbol
, info_vector
)
455 Lisp_Object charset_id
, charset_symbol
, info_vector
;
459 if (!NILP (charset_id
))
460 CHECK_NUMBER (charset_id
, 0);
461 CHECK_SYMBOL (charset_symbol
, 1);
462 CHECK_VECTOR (info_vector
, 2);
464 if (! NILP (charset_id
))
466 if (! CHARSET_VALID_P (XINT (charset_id
)))
467 error ("Invalid CHARSET: %d", XINT (charset_id
));
468 else if (CHARSET_DEFINED_P (XINT (charset_id
)))
469 error ("Already defined charset: %d", XINT (charset_id
));
472 vec
= XVECTOR (info_vector
)->contents
;
473 if (XVECTOR (info_vector
)->size
!= 9
474 || !INTEGERP (vec
[0]) || !(XINT (vec
[0]) == 1 || XINT (vec
[0]) == 2)
475 || !INTEGERP (vec
[1]) || !(XINT (vec
[1]) == 94 || XINT (vec
[1]) == 96)
476 || !INTEGERP (vec
[2]) || !(XINT (vec
[2]) == 1 || XINT (vec
[2]) == 2)
477 || !INTEGERP (vec
[3]) || !(XINT (vec
[3]) == 0 || XINT (vec
[3]) == 1)
478 || !INTEGERP (vec
[4]) || !(XINT (vec
[4]) >= '0' && XINT (vec
[4]) <= '~')
479 || !INTEGERP (vec
[5]) || !(XINT (vec
[5]) == 0 || XINT (vec
[5]) == 1)
482 || !STRINGP (vec
[8]))
483 error ("Invalid info-vector argument for defining charset %s",
484 XSYMBOL (charset_symbol
)->name
->data
);
486 if (NILP (charset_id
))
488 charset_id
= get_new_private_charset_id (XINT (vec
[0]), XINT (vec
[2]));
489 if (XINT (charset_id
) == 0)
490 error ("There's no room for a new private charset %s",
491 XSYMBOL (charset_symbol
)->name
->data
);
494 update_charset_table (charset_id
, vec
[0], vec
[1], vec
[2], vec
[3],
495 vec
[4], vec
[5], vec
[6], vec
[7], vec
[8]);
496 Fput (charset_symbol
, Qcharset
, CHARSET_TABLE_ENTRY (XINT (charset_id
)));
497 CHARSET_SYMBOL (XINT (charset_id
)) = charset_symbol
;
498 Vcharset_list
= Fcons (charset_symbol
, Vcharset_list
);
502 DEFUN ("declare-equiv-charset", Fdeclare_equiv_charset
, Sdeclare_equiv_charset
,
504 "Declare a charset of DIMENSION, CHARS, FINAL-CHAR is the same as CHARSET.\n\
505 CHARSET should be defined by `defined-charset' in advance.")
506 (dimension
, chars
, final_char
, charset_symbol
)
507 Lisp_Object dimension
, chars
, final_char
, charset_symbol
;
511 CHECK_NUMBER (dimension
, 0);
512 CHECK_NUMBER (chars
, 1);
513 CHECK_NUMBER (final_char
, 2);
514 CHECK_SYMBOL (charset_symbol
, 3);
516 if (XINT (dimension
) != 1 && XINT (dimension
) != 2)
517 error ("Invalid DIMENSION %d, it should be 1 or 2", XINT (dimension
));
518 if (XINT (chars
) != 94 && XINT (chars
) != 96)
519 error ("Invalid CHARS %d, it should be 94 or 96", XINT (chars
));
520 if (XINT (final_char
) < '0' || XFASTINT (final_char
) > '~')
521 error ("Invalid FINAL-CHAR %c, it should be `0'..`~'", XINT (chars
));
522 if ((charset
= get_charset_id (charset_symbol
)) < 0)
523 error ("Invalid charset %s", XSYMBOL (charset_symbol
)->name
->data
);
525 ISO_CHARSET_TABLE (dimension
, chars
, final_char
) = charset
;
529 /* Return number of different charsets in STR of length LEN. In
530 addition, for each found charset N, CHARSETS[N] is set 1. The
531 caller should allocate CHARSETS (MAX_CHARSET + 1 bytes) in advance.
532 It may lookup a unification table TABLE if supplied. */
535 find_charset_in_str (str
, len
, charsets
, table
)
536 unsigned char *str
, *charsets
;
542 if (! CHAR_TABLE_P (table
))
547 int bytes
= BYTES_BY_CHAR_HEAD (*str
);
551 charset
= CHARSET_AT (str
);
555 unsigned char c1
, c2
;
557 SPLIT_STRING(str
, bytes
, charset
, c1
, c2
);
558 if ((c
= unify_char (table
, -1, charset
, c1
, c2
)) >= 0)
559 charset
= CHAR_CHARSET (c
);
562 if (!charsets
[charset
])
564 charsets
[charset
] = 1;
573 DEFUN ("find-charset-region", Ffind_charset_region
, Sfind_charset_region
,
575 "Return a list of charsets in the region between BEG and END.\n\
576 BEG and END are buffer positions.\n\
577 Optional arg TABLE if non-nil is a unification table to look up.")
579 Lisp_Object beg
, end
, table
;
581 char charsets
[MAX_CHARSET
+ 1];
582 int from
, to
, stop
, i
;
585 validate_region (&beg
, &end
);
586 from
= XFASTINT (beg
);
587 stop
= to
= XFASTINT (end
);
588 if (from
< GPT
&& GPT
< to
)
590 bzero (charsets
, MAX_CHARSET
+ 1);
593 find_charset_in_str (POS_ADDR (from
), stop
- from
, charsets
, table
);
595 from
= stop
, stop
= to
;
600 for (i
= MAX_CHARSET
; i
>= 0; i
--)
602 val
= Fcons (CHARSET_SYMBOL (i
), val
);
606 DEFUN ("find-charset-string", Ffind_charset_string
, Sfind_charset_string
,
608 "Return a list of charsets in STR.\n\
609 Optional arg TABLE if non-nil is a unification table to look up.")
611 Lisp_Object str
, table
;
613 char charsets
[MAX_CHARSET
+ 1];
617 CHECK_STRING (str
, 0);
618 bzero (charsets
, MAX_CHARSET
+ 1);
619 find_charset_in_str (XSTRING (str
)->data
, XSTRING (str
)->size
,
622 for (i
= MAX_CHARSET
; i
>= 0; i
--)
624 val
= Fcons (CHARSET_SYMBOL (i
), val
);
628 DEFUN ("make-char-internal", Fmake_char_internal
, Smake_char_internal
, 1, 3, 0,
630 (charset
, code1
, code2
)
631 Lisp_Object charset
, code1
, code2
;
633 CHECK_NUMBER (charset
, 0);
636 XSETFASTINT (code1
, 0);
638 CHECK_NUMBER (code1
, 1);
640 XSETFASTINT (code2
, 0);
642 CHECK_NUMBER (code2
, 2);
644 if (!CHARSET_DEFINED_P (XINT (charset
)))
645 error ("Invalid charset: %d", XINT (charset
));
647 return make_number (MAKE_CHAR (XINT (charset
), XINT (code1
), XINT (code2
)));
650 DEFUN ("split-char", Fsplit_char
, Ssplit_char
, 1, 1, 0,
651 "Return list of charset and one or two position-codes of CHAR.")
658 CHECK_NUMBER (ch
, 0);
659 SPLIT_CHAR (XFASTINT (ch
), charset
, c1
, c2
);
661 ? Fcons (CHARSET_SYMBOL (charset
),
662 Fcons (make_number (c1
), Fcons (make_number (c2
), Qnil
)))
663 : Fcons (CHARSET_SYMBOL (charset
), Fcons (make_number (c1
), Qnil
)));
666 DEFUN ("char-charset", Fchar_charset
, Schar_charset
, 1, 1, 0,
667 "Return charset of CHAR.")
671 CHECK_NUMBER (ch
, 0);
673 return CHARSET_SYMBOL (CHAR_CHARSET (XINT (ch
)));
676 DEFUN ("iso-charset", Fiso_charset
, Siso_charset
, 3, 3, 0,
677 "Return charset of ISO's specification DIMENSION, CHARS, and FINAL-CHAR.")
678 (dimension
, chars
, final_char
)
679 Lisp_Object dimension
, chars
, final_char
;
683 CHECK_NUMBER (dimension
, 0);
684 CHECK_NUMBER (chars
, 1);
685 CHECK_NUMBER (final_char
, 2);
687 if ((charset
= ISO_CHARSET_TABLE (dimension
, chars
, final_char
)) < 0)
689 return CHARSET_SYMBOL (charset
);
692 DEFUN ("char-bytes", Fchar_bytes
, Schar_bytes
, 1, 1, 0,
693 "Return byte length of multi-byte form of CHAR.")
700 CHECK_NUMBER (ch
, 0);
701 if (COMPOSITE_CHAR_P (XFASTINT (ch
)))
703 unsigned int id
= COMPOSITE_CHAR_ID (XFASTINT (ch
));
705 bytes
= (id
< n_cmpchars
? cmpchar_table
[id
]->len
: 1);
709 int charset
= CHAR_CHARSET (XFASTINT (ch
));
711 bytes
= CHARSET_DEFINED_P (charset
) ? CHARSET_BYTES (charset
) : 1;
714 XSETFASTINT (val
, bytes
);
718 /* Return the width of character of which multi-byte form starts with
719 C. The width is measured by how many columns occupied on the
720 screen when displayed in the current buffer. */
722 #define ONE_BYTE_CHAR_WIDTH(c) \
725 ? XFASTINT (current_buffer->tab_width) \
726 : (c == '\n' ? 0 : (NILP (current_buffer->ctl_arrow) ? 4 : 2))) \
730 ? (NILP (current_buffer->ctl_arrow) ? 4 : 2) \
731 : ((! NILP (current_buffer->enable_multibyte_characters) \
732 && BASE_LEADING_CODE_P (c)) \
733 ? WIDTH_BY_CHAR_HEAD (c) \
737 DEFUN ("char-width", Fchar_width, Schar_width, 1, 1, 0,
738 "Return width of CHAR when displayed in the current buffer.\n\
739 The width is measured by how many columns it occupies on the screen.")
743 Lisp_Object val
, disp
;
746 CHECK_NUMBER (ch
, 0);
750 /* Get the way the display table would display it. */
751 disp
= DISP_CHAR_VECTOR (buffer_display_table (current_buffer
), (c
));
754 XSETINT (val
, XVECTOR (disp
)->size
);
755 else if (SINGLE_BYTE_CHAR_P (c
))
756 XSETINT (val
, ONE_BYTE_CHAR_WIDTH (c
));
757 else if (COMPOSITE_CHAR_P (c
))
759 int id
= COMPOSITE_CHAR_ID (XFASTINT (ch
));
760 XSETFASTINT (val
, (id
< n_cmpchars
? cmpchar_table
[id
]->width
: 0));
764 int charset
= CHAR_CHARSET (c
);
766 XSETFASTINT (val
, CHARSET_WIDTH (charset
));
771 /* Return width of string STR of length LEN when displayed in the
772 current buffer. The width is measured by how many columns it
773 occupies on the screen. */
780 unsigned char *endp
= str
+ len
;
782 struct Lisp_Char_Table
*dp
= buffer_display_table (current_buffer
);
786 if (*str
== LEADING_CODE_COMPOSITION
)
788 int id
= str_cmpchar_id (str
, endp
- str
);
797 width
+= cmpchar_table
[id
]->width
;
798 str
+= cmpchar_table
[id
]->len
;
805 int c
= STRING_CHAR (str
, endp
- str
);
807 /* Get the way the display table would display it. */
808 disp
= DISP_CHAR_VECTOR (dp
, c
);
811 thiswidth
= XVECTOR (disp
)->size
;
813 thiswidth
= ONE_BYTE_CHAR_WIDTH (*str
);
816 str
+= BYTES_BY_CHAR_HEAD (*str
);
822 DEFUN ("string-width", Fstring_width
, Sstring_width
, 1, 1, 0,
823 "Return width of STRING when displayed in the current buffer.\n\
824 Width is measured by how many columns it occupies on the screen.\n\
825 When calculating width of a multi-byte character in STRING,\n\
826 only the base leading-code is considered and the validity of\n\
827 the following bytes are not checked.")
833 CHECK_STRING (str
, 0);
834 XSETFASTINT (val
, strwidth (XSTRING (str
)->data
, XSTRING (str
)->size
));
838 DEFUN ("char-direction", Fchar_direction
, Schar_direction
, 1, 1, 0,
839 "Return the direction of CHAR.\n\
840 The returned value is 0 for left-to-right and 1 for right-to-left.")
846 CHECK_NUMBER (ch
, 0);
847 charset
= CHAR_CHARSET (XFASTINT (ch
));
848 if (!CHARSET_DEFINED_P (charset
))
849 error ("Invalid character: %d", XINT (ch
));
850 return CHARSET_TABLE_INFO (charset
, CHARSET_DIRECTION_IDX
);
853 DEFUN ("chars-in-string", Fchars_in_string
, Schars_in_string
, 1, 1, 0,
854 "Return number of characters in STRING.")
859 unsigned char *p
, *endp
;
862 CHECK_STRING (str
, 0);
864 p
= XSTRING (str
)->data
; endp
= p
+ XSTRING (str
)->size
;
868 if (*p
== LEADING_CODE_COMPOSITION
)
871 while (p
< endp
&& ! CHAR_HEAD_P (p
)) p
++;
874 p
+= BYTES_BY_CHAR_HEAD (*p
);
878 XSETFASTINT (val
, chars
);
882 DEFUN ("char-boundary-p", Fchar_boundary_p
, Schar_boundary_p
, 1, 1, 0,
883 "Return non-nil value if POS is at character boundary of multibyte form.\n\
884 The return value is:\n\
885 0 if POS is at an ASCII character or at the end of range,\n\
886 1 if POS is at a head of 2-byte length multi-byte form,\n\
887 2 if POS is at a head of 3-byte length multi-byte form,\n\
888 3 if POS is at a head of 4-byte length multi-byte form,\n\
889 4 if POS is at a head of multi-byte form of a composite character.\n\
890 If POS is out of range or not at character boundary, return NIL.")
897 CHECK_NUMBER_COERCE_MARKER (pos
, 0);
900 if (n
< BEGV
|| n
> ZV
)
903 if (n
== ZV
|| NILP (current_buffer
->enable_multibyte_characters
))
904 XSETFASTINT (val
, 0);
907 unsigned char *p
= POS_ADDR (n
);
909 if (SINGLE_BYTE_CHAR_P (*p
))
910 XSETFASTINT (val
, 0);
911 else if (*p
== LEADING_CODE_COMPOSITION
)
912 XSETFASTINT (val
, 4);
913 else if (BYTES_BY_CHAR_HEAD (*p
) > 1)
914 XSETFASTINT (val
, BYTES_BY_CHAR_HEAD (*p
) - 1);
921 DEFUN ("concat-chars", Fconcat_chars
, Sconcat_chars
, 1, MANY
, 0,
922 "Concatenate all the argument characters and make the result a string.")
929 = (unsigned char *) malloc (MAX_LENGTH_OF_MULTI_BYTE_FORM
* n
);
930 unsigned char *p
= buf
;
933 for (i
= 0; i
< n
; i
++)
938 if (!INTEGERP (args
[i
]))
941 CHECK_NUMBER (args
[i
], 0);
944 len
= CHAR_STRING (c
, p
, str
);
946 /* C is a composite character. */
951 val
= make_string (buf
, p
- buf
);
958 /*** Composite characters staffs ***/
960 /* Each composite character is identified by CMPCHAR-ID which is
961 assigned when Emacs needs the character code of the composite
962 character (e.g. when displaying it on the screen). See the
963 document "GENERAL NOTE on COMPOSITE CHARACTER" in `charset.h' how a
964 composite character is represented in Emacs. */
966 /* If `static' is defined, it means that it is defined to null string. */
968 /* The following function is copied from lread.c. */
970 hash_string (ptr
, len
)
974 register unsigned char *p
= ptr
;
975 register unsigned char *end
= p
+ len
;
976 register unsigned char c
;
977 register int hash
= 0;
982 if (c
>= 0140) c
-= 40;
983 hash
= ((hash
<<3) + (hash
>>28) + c
);
985 return hash
& 07777777777;
989 #define CMPCHAR_HASH_TABLE_SIZE 0xFFF
991 static int *cmpchar_hash_table
[CMPCHAR_HASH_TABLE_SIZE
];
993 /* Each element of `cmpchar_hash_table' is a pointer to an array of
994 integer, where the 1st element is the size of the array, the 2nd
995 element is how many elements are actually used in the array, and
996 the remaining elements are CMPCHAR-IDs of composite characters of
997 the same hash value. */
998 #define CMPCHAR_HASH_SIZE(table) table[0]
999 #define CMPCHAR_HASH_USED(table) table[1]
1000 #define CMPCHAR_HASH_CMPCHAR_ID(table, i) table[i]
1002 /* Return CMPCHAR-ID of the composite character in STR of the length
1003 LEN. If the composite character has not yet been registered,
1004 register it in `cmpchar_table' and assign new CMPCHAR-ID. This
1005 is the sole function for assigning CMPCHAR-ID. */
1007 str_cmpchar_id (str
, len
)
1011 int hash_idx
, *hashp
;
1013 int embedded_rule
; /* 1 if composition rule is embedded. */
1014 int chars
; /* number of components. */
1016 struct cmpchar_info
*cmpcharp
;
1019 /* Any composite char have at least 3-byte length. */
1022 /* The second byte 0xFF means compostion rule is embedded. */
1023 embedded_rule
= (str
[1] == 0xFF);
1025 /* At first, get the actual length of the composite character. */
1027 unsigned char *p
, *endp
= str
+ 1, *lastp
= str
+ len
;
1030 while (endp
< lastp
&& ! CHAR_HEAD_P (endp
)) endp
++;
1032 p
= str
+ 1 + embedded_rule
;
1035 /* No need of checking if *P is 0xA0 because
1036 BYTES_BY_CHAR_HEAD (0x80) surely returns 2. */
1037 p
+= (bytes
= BYTES_BY_CHAR_HEAD (*p
- 0x20) + embedded_rule
);
1040 len
= (p
-= embedded_rule
) - str
;
1042 len
-= - bytes
, chars
--;
1044 if (chars
< 2 || chars
> MAX_COMPONENT_COUNT
)
1045 /* Invalid number of components. */
1048 hash_idx
= hash_string (str
, len
) % CMPCHAR_HASH_TABLE_SIZE
;
1049 hashp
= cmpchar_hash_table
[hash_idx
];
1051 /* Then, look into the hash table. */
1053 /* Find the correct one among composite characters of the same
1055 for (i
= 2; i
< CMPCHAR_HASH_USED (hashp
); i
++)
1057 cmpcharp
= cmpchar_table
[CMPCHAR_HASH_CMPCHAR_ID (hashp
, i
)];
1058 if (len
== cmpcharp
->len
1059 && ! bcmp (str
, cmpcharp
->data
, len
))
1060 return CMPCHAR_HASH_CMPCHAR_ID (hashp
, i
);
1063 /* We have to register the composite character in cmpchar_table. */
1064 if (n_cmpchars
> (CHAR_FIELD2_MASK
| CHAR_FIELD3_MASK
))
1065 /* No, we have no more room for a new composite character. */
1068 /* Make the entry in hash table. */
1071 /* Make a table for 8 composite characters initially. */
1072 hashp
= (cmpchar_hash_table
[hash_idx
]
1073 = (int *) xmalloc (sizeof (int) * (2 + 8)));
1074 CMPCHAR_HASH_SIZE (hashp
) = 10;
1075 CMPCHAR_HASH_USED (hashp
) = 2;
1077 else if (CMPCHAR_HASH_USED (hashp
) >= CMPCHAR_HASH_SIZE (hashp
))
1079 CMPCHAR_HASH_SIZE (hashp
) += 8;
1080 hashp
= (cmpchar_hash_table
[hash_idx
]
1081 = (int *) xrealloc (hashp
,
1082 sizeof (int) * CMPCHAR_HASH_SIZE (hashp
)));
1084 CMPCHAR_HASH_CMPCHAR_ID (hashp
, CMPCHAR_HASH_USED (hashp
)) = n_cmpchars
;
1085 CMPCHAR_HASH_USED (hashp
)++;
1087 /* Set information of the composite character in cmpchar_table. */
1088 if (cmpchar_table_size
== 0)
1090 /* This is the first composite character to be registered. */
1091 cmpchar_table_size
= 256;
1093 = (struct cmpchar_info
**) xmalloc (sizeof (cmpchar_table
[0])
1094 * cmpchar_table_size
);
1096 else if (cmpchar_table_size
<= n_cmpchars
)
1098 cmpchar_table_size
+= 256;
1100 = (struct cmpchar_info
**) xrealloc (cmpchar_table
,
1101 sizeof (cmpchar_table
[0])
1102 * cmpchar_table_size
);
1105 cmpcharp
= (struct cmpchar_info
*) xmalloc (sizeof (struct cmpchar_info
));
1107 cmpcharp
->len
= len
;
1108 cmpcharp
->data
= (unsigned char *) xmalloc (len
+ 1);
1109 bcopy (str
, cmpcharp
->data
, len
);
1110 cmpcharp
->data
[len
] = 0;
1111 cmpcharp
->glyph_len
= chars
;
1112 cmpcharp
->glyph
= (GLYPH
*) xmalloc (sizeof (GLYPH
) * chars
);
1115 cmpcharp
->cmp_rule
= (unsigned char *) xmalloc (chars
);
1116 cmpcharp
->col_offset
= (float *) xmalloc (sizeof (float) * chars
);
1120 cmpcharp
->cmp_rule
= NULL
;
1121 cmpcharp
->col_offset
= NULL
;
1124 /* Setup GLYPH data and composition rules (if any) so as not to make
1125 them every time on displaying. */
1127 unsigned char *bufp
;
1129 float leftmost
= 0.0, rightmost
= 1.0;
1132 /* At first, col_offset[N] is set to relative to col_offset[0]. */
1133 cmpcharp
->col_offset
[0] = 0;
1135 for (i
= 0, bufp
= cmpcharp
->data
+ 1; i
< chars
; i
++)
1138 cmpcharp
->cmp_rule
[i
] = *bufp
++;
1140 if (*bufp
== 0xA0) /* This is an ASCII character. */
1142 cmpcharp
->glyph
[i
] = FAST_MAKE_GLYPH ((*++bufp
& 0x7F), 0);
1146 else /* Multibyte character. */
1148 /* Make `bufp' point normal multi-byte form temporally. */
1151 = FAST_MAKE_GLYPH (string_to_non_ascii_char (bufp
, 4, 0), 0);
1152 width
= WIDTH_BY_CHAR_HEAD (*bufp
);
1154 bufp
+= BYTES_BY_CHAR_HEAD (*bufp
- 0x20);
1157 if (embedded_rule
&& i
> 0)
1159 /* Reference points (global_ref and new_ref) are
1170 Now, we calculate the column offset of the new glyph
1171 from the left edge of the first glyph. This can avoid
1172 the same calculation everytime displaying this
1173 composite character. */
1175 /* Reference points of global glyph and new glyph. */
1176 int global_ref
= (cmpcharp
->cmp_rule
[i
] - 0xA0) / 9;
1177 int new_ref
= (cmpcharp
->cmp_rule
[i
] - 0xA0) % 9;
1178 /* Column offset relative to the first glyph. */
1179 float left
= (leftmost
1180 + (global_ref
% 3) * (rightmost
- leftmost
) / 2.0
1181 - (new_ref
% 3) * width
/ 2.0);
1183 cmpcharp
->col_offset
[i
] = left
;
1184 if (left
< leftmost
)
1186 if (left
+ width
> rightmost
)
1187 rightmost
= left
+ width
;
1191 if (width
> rightmost
)
1197 /* Now col_offset[N] are relative to the left edge of the
1198 first component. Make them relative to the left edge of
1200 for (i
= 0; i
< chars
; i
++)
1201 cmpcharp
->col_offset
[i
] -= leftmost
;
1202 /* Make rightmost holds width of overall glyph. */
1203 rightmost
-= leftmost
;
1206 cmpcharp
->width
= rightmost
;
1207 if (cmpcharp
->width
< rightmost
)
1208 /* To get a ceiling integer value. */
1212 cmpchar_table
[n_cmpchars
] = cmpcharp
;
1214 return n_cmpchars
++;
1217 /* Return the Nth element of the composite character C. */
1219 cmpchar_component (c
, n
)
1222 int id
= COMPOSITE_CHAR_ID (c
);
1224 if (id
>= n_cmpchars
/* C is not a valid composite character. */
1225 || n
>= cmpchar_table
[id
]->glyph_len
) /* No such component. */
1227 /* No face data is stored in glyph code. */
1228 return ((int) (cmpchar_table
[id
]->glyph
[n
]));
1231 DEFUN ("cmpcharp", Fcmpcharp
, Scmpcharp
, 1, 1, 0,
1232 "T if CHAR is a composite character.")
1236 CHECK_NUMBER (ch
, 0);
1237 return (COMPOSITE_CHAR_P (XINT (ch
)) ? Qt
: Qnil
);
1240 DEFUN ("composite-char-component", Fcmpchar_component
, Scmpchar_component
,
1242 "Return the IDXth component character of composite character CHARACTER.")
1244 Lisp_Object character
, idx
;
1248 CHECK_NUMBER (character
, 0);
1249 CHECK_NUMBER (idx
, 1);
1251 if ((c
= cmpchar_component (XINT (character
), XINT (idx
))) < 0)
1252 args_out_of_range (character
, idx
);
1254 return make_number (c
);
1257 DEFUN ("composite-char-composition-rule", Fcmpchar_cmp_rule
, Scmpchar_cmp_rule
,
1259 "Return the Nth composition rule embedded in composite character CHARACTER.\n\
1260 The returned rule is for composing the Nth component\n\
1261 on the (N-1)th component. If N is 0, the returned value is always 255.")
1263 Lisp_Object character
, n
;
1267 CHECK_NUMBER (character
, 0);
1268 CHECK_NUMBER (n
, 1);
1270 id
= COMPOSITE_CHAR_ID (XINT (character
));
1271 if (id
< 0 || id
>= n_cmpchars
)
1272 error ("Invalid composite character: %d", XINT (character
));
1274 if (i
> cmpchar_table
[id
]->glyph_len
)
1275 args_out_of_range (character
, n
);
1277 return make_number (cmpchar_table
[id
]->cmp_rule
[i
]);
1280 DEFUN ("composite-char-composition-rule-p", Fcmpchar_cmp_rule_p
,
1281 Scmpchar_cmp_rule_p
, 1, 1, 0,
1282 "Return non-nil if composite character CHARACTER contains a embedded rule.")
1284 Lisp_Object character
;
1288 CHECK_NUMBER (character
, 0);
1289 id
= COMPOSITE_CHAR_ID (XINT (character
));
1290 if (id
< 0 || id
>= n_cmpchars
)
1291 error ("Invalid composite character: %d", XINT (character
));
1293 return (cmpchar_table
[id
]->cmp_rule
? Qt
: Qnil
);
1296 DEFUN ("composite-char-component-count", Fcmpchar_cmp_count
,
1297 Scmpchar_cmp_count
, 1, 1, 0,
1298 "Return number of compoents of composite character CHARACTER.")
1300 Lisp_Object character
;
1304 CHECK_NUMBER (character
, 0);
1305 id
= COMPOSITE_CHAR_ID (XINT (character
));
1306 if (id
< 0 || id
>= n_cmpchars
)
1307 error ("Invalid composite character: %d", XINT (character
));
1309 return (make_number (cmpchar_table
[id
]->glyph_len
));
1312 DEFUN ("compose-string", Fcompose_string
, Scompose_string
,
1314 "Return one char string composed from all characters in STRING.")
1318 unsigned char buf
[MAX_LENGTH_OF_MULTI_BYTE_FORM
], *p
, *pend
, *ptemp
;
1321 CHECK_STRING (str
, 0);
1323 buf
[0] = LEADING_CODE_COMPOSITION
;
1324 p
= XSTRING (str
)->data
;
1325 pend
= p
+ XSTRING (str
)->size
;
1329 if (*p
< 0x20 || *p
== 127) /* control code */
1330 error ("Invalid component character: %d", *p
);
1331 else if (*p
< 0x80) /* ASCII */
1333 if (i
+ 2 >= MAX_LENGTH_OF_MULTI_BYTE_FORM
)
1334 error ("Too long string to be composed: %s", XSTRING (str
)->data
);
1335 /* Prepend an ASCII charset indicator 0xA0, set MSB of the
1338 buf
[i
++] = *p
++ + 0x80;
1340 else if (*p
== LEADING_CODE_COMPOSITION
) /* composite char */
1342 /* Already composed. Eliminate the heading
1343 LEADING_CODE_COMPOSITION, keep the remaining bytes
1347 while (! CHAR_HEAD_P (p
)) p
++;
1348 if (i
+ (p
- ptemp
) >= MAX_LENGTH_OF_MULTI_BYTE_FORM
)
1349 error ("Too long string to be composed: %s", XSTRING (str
)->data
);
1350 bcopy (ptemp
, buf
+ i
, p
- ptemp
);
1353 else /* multibyte char */
1355 /* Add 0x20 to the base leading-code, keep the remaining
1357 len
= BYTES_BY_CHAR_HEAD (*p
);
1358 if (i
+ len
>= MAX_LENGTH_OF_MULTI_BYTE_FORM
)
1359 error ("Too long string to be composed: %s", XSTRING (str
)->data
);
1360 bcopy (p
, buf
+ i
, len
);
1367 /* STR contains only one character, which can't be composed. */
1368 error ("Too short string to be composed: %s", XSTRING (str
)->data
);
1370 return make_string (buf
, i
);
1374 charset_id_internal (charset_name
)
1377 Lisp_Object val
= Fget (intern (charset_name
), Qcharset
);
1380 error ("Charset %s is not defined", charset_name
);
1382 return (XINT (XVECTOR (val
)->contents
[0]));
1385 DEFUN ("setup-special-charsets", Fsetup_special_charsets
,
1386 Ssetup_special_charsets
, 0, 0, 0, "Internal use only.")
1389 charset_latin_iso8859_1
= charset_id_internal ("latin-iso8859-1");
1390 charset_jisx0208_1978
= charset_id_internal ("japanese-jisx0208-1978");
1391 charset_jisx0208
= charset_id_internal ("japanese-jisx0208");
1392 charset_katakana_jisx0201
= charset_id_internal ("katakana-jisx0201");
1393 charset_latin_jisx0201
= charset_id_internal ("latin-jisx0201");
1394 charset_big5_1
= charset_id_internal ("chinese-big5-1");
1395 charset_big5_2
= charset_id_internal ("chinese-big5-2");
1399 init_charset_once ()
1403 staticpro (&Vcharset_table
);
1404 staticpro (&Vcharset_symbol_table
);
1406 /* This has to be done here, before we call Fmake_char_table. */
1407 Qcharset_table
= intern ("charset-table");
1408 staticpro (&Qcharset_table
);
1410 /* Intern this now in case it isn't already done.
1411 Setting this variable twice is harmless.
1412 But don't staticpro it here--that is done in alloc.c. */
1413 Qchar_table_extra_slots
= intern ("char-table-extra-slots");
1415 /* Now we are ready to set up this property, so we can
1416 create the charset table. */
1417 Fput (Qcharset_table
, Qchar_table_extra_slots
, make_number (0));
1418 Vcharset_table
= Fmake_char_table (Qcharset_table
, Qnil
);
1420 Vcharset_symbol_table
= Fmake_vector (make_number (MAX_CHARSET
+ 1), Qnil
);
1423 for (i
= 0; i
< 2; i
++)
1424 for (j
= 0; j
< 2; j
++)
1425 for (k
= 0; k
< 128; k
++)
1426 iso_charset_table
[i
][j
][k
] = -1;
1428 bzero (cmpchar_hash_table
, sizeof cmpchar_hash_table
);
1429 cmpchar_table_size
= n_cmpchars
= 0;
1431 for (i
= 0; i
< 256; i
++)
1432 BYTES_BY_CHAR_HEAD (i
) = 1;
1433 BYTES_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_11
) = 3;
1434 BYTES_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_12
) = 3;
1435 BYTES_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_21
) = 4;
1436 BYTES_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_22
) = 4;
1437 /* The following doesn't reflect the actual bytes, but just to tell
1438 that it is a start of a multibyte character. */
1439 BYTES_BY_CHAR_HEAD (LEADING_CODE_COMPOSITION
) = 2;
1441 for (i
= 0; i
< 128; i
++)
1442 WIDTH_BY_CHAR_HEAD (i
) = 1;
1443 for (; i
< 256; i
++)
1444 WIDTH_BY_CHAR_HEAD (i
) = 4;
1445 WIDTH_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_11
) = 1;
1446 WIDTH_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_12
) = 2;
1447 WIDTH_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_21
) = 1;
1448 WIDTH_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_22
) = 2;
1455 Qascii
= intern ("ascii");
1456 staticpro (&Qascii
);
1458 Qcharset
= intern ("charset");
1459 staticpro (&Qcharset
);
1461 /* Define ASCII charset now. */
1462 update_charset_table (make_number (CHARSET_ASCII
),
1463 make_number (1), make_number (94),
1468 build_string ("ASCII"),
1469 build_string ("ASCII"),
1470 build_string ("ASCII (ISO646 IRV)"));
1471 CHARSET_SYMBOL (CHARSET_ASCII
) = Qascii
;
1472 Fput (Qascii
, Qcharset
, CHARSET_TABLE_ENTRY (CHARSET_ASCII
));
1474 Qcomposition
= intern ("composition");
1475 staticpro (&Qcomposition
);
1476 CHARSET_SYMBOL (CHARSET_COMPOSITION
) = Qcomposition
;
1478 defsubr (&Sdefine_charset
);
1479 defsubr (&Sdeclare_equiv_charset
);
1480 defsubr (&Sfind_charset_region
);
1481 defsubr (&Sfind_charset_string
);
1482 defsubr (&Smake_char_internal
);
1483 defsubr (&Ssplit_char
);
1484 defsubr (&Schar_charset
);
1485 defsubr (&Siso_charset
);
1486 defsubr (&Schar_bytes
);
1487 defsubr (&Schar_width
);
1488 defsubr (&Sstring_width
);
1489 defsubr (&Schar_direction
);
1490 defsubr (&Schars_in_string
);
1491 defsubr (&Schar_boundary_p
);
1492 defsubr (&Sconcat_chars
);
1493 defsubr (&Scmpcharp
);
1494 defsubr (&Scmpchar_component
);
1495 defsubr (&Scmpchar_cmp_rule
);
1496 defsubr (&Scmpchar_cmp_rule_p
);
1497 defsubr (&Scmpchar_cmp_count
);
1498 defsubr (&Scompose_string
);
1499 defsubr (&Ssetup_special_charsets
);
1501 DEFVAR_LISP ("charset-list", &Vcharset_list
,
1502 "List of charsets ever defined.");
1503 Vcharset_list
= Fcons (Qascii
, Qnil
);
1505 DEFVAR_INT ("leading-code-composition", &leading_code_composition
,
1506 "Leading-code of composite characters.");
1507 leading_code_composition
= LEADING_CODE_COMPOSITION
;
1509 DEFVAR_INT ("leading-code-private-11", &leading_code_private_11
,
1510 "Leading-code of private TYPE9N charset of column-width 1.");
1511 leading_code_private_11
= LEADING_CODE_PRIVATE_11
;
1513 DEFVAR_INT ("leading-code-private-12", &leading_code_private_12
,
1514 "Leading-code of private TYPE9N charset of column-width 2.");
1515 leading_code_private_12
= LEADING_CODE_PRIVATE_12
;
1517 DEFVAR_INT ("leading-code-private-21", &leading_code_private_21
,
1518 "Leading-code of private TYPE9Nx9N charset of column-width 1.");
1519 leading_code_private_21
= LEADING_CODE_PRIVATE_21
;
1521 DEFVAR_INT ("leading-code-private-22", &leading_code_private_22
,
1522 "Leading-code of private TYPE9Nx9N charset of column-width 2.");
1523 leading_code_private_22
= LEADING_CODE_PRIVATE_22
;