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>
44 Lisp_Object Qcharset
, Qascii
, Qcomposition
;
46 /* Declaration of special leading-codes. */
47 int leading_code_composition
; /* for composite characters */
48 int leading_code_private_11
; /* for private DIMENSION1 of 1-column */
49 int leading_code_private_12
; /* for private DIMENSION1 of 2-column */
50 int leading_code_private_21
; /* for private DIMENSION2 of 1-column */
51 int leading_code_private_22
; /* for private DIMENSION2 of 2-column */
53 /* Declaration of special charsets. */
54 int charset_ascii
; /* ASCII */
55 int charset_composition
; /* for a composite character */
56 int charset_latin_iso8859_1
; /* ISO8859-1 (Latin-1) */
57 int charset_jisx0208_1978
; /* JISX0208.1978 (Japanese Kanji old set) */
58 int charset_jisx0208
; /* JISX0208.1983 (Japanese Kanji) */
59 int charset_katakana_jisx0201
; /* JISX0201.Kana (Japanese Katakana) */
60 int charset_latin_jisx0201
; /* JISX0201.Roman (Japanese Roman) */
61 int charset_big5_1
; /* Big5 Level 1 (Chinese Traditional) */
62 int charset_big5_2
; /* Big5 Level 2 (Chinese Traditional) */
64 Lisp_Object Qcharset_table
;
66 /* A char-table containing information of each character set. */
67 Lisp_Object Vcharset_table
;
69 /* A vector of charset symbol indexed by charset-id. This is used
70 only for returning charset symbol from C functions. */
71 Lisp_Object Vcharset_symbol_table
;
73 /* A list of charset symbols ever defined. */
74 Lisp_Object Vcharset_list
;
76 /* Tables used by macros BYTES_BY_CHAR_HEAD and WIDTH_BY_CHAR_HEAD. */
77 int bytes_by_char_head
[256];
78 int width_by_char_head
[256];
80 /* Mapping table from ISO2022's charset (specified by DIMENSION,
81 CHARS, and FINAL-CHAR) to Emacs' charset. */
82 int iso_charset_table
[2][2][128];
84 /* Table of pointers to the structure `cmpchar_info' indexed by
86 struct cmpchar_info
**cmpchar_table
;
87 /* The current size of `cmpchar_table'. */
88 static int cmpchar_table_size
;
89 /* Number of the current composite characters. */
92 /* Variables used locally in the macro FETCH_MULTIBYTE_CHAR. */
93 unsigned char *_fetch_multibyte_char_p
;
94 int _fetch_multibyte_char_len
;
96 /* Set STR a pointer to the multi-byte form of the character C. If C
97 is not a composite character, the multi-byte form is set in WORKBUF
98 and STR points WORKBUF. The caller should allocate at least 4-byte
99 area at WORKBUF in advance. Returns the length of the multi-byte
100 form. If C is an invalid character to have a multi-byte form,
103 Use macro `CHAR_STRING (C, WORKBUF, STR)' instead of calling this
104 function directly if C can be an ASCII character. */
107 non_ascii_char_to_string (c
, workbuf
, str
)
109 unsigned char *workbuf
, **str
;
113 if (COMPOSITE_CHAR_P (c
))
115 int cmpchar_id
= COMPOSITE_CHAR_ID (c
);
117 if (cmpchar_id
< n_cmpchars
)
119 *str
= cmpchar_table
[cmpchar_id
]->data
;
120 return cmpchar_table
[cmpchar_id
]->len
;
124 error ("Invalid characer: %d", c
);
128 SPLIT_NON_ASCII_CHAR (c
, charset
, c1
, c2
);
130 || ! CHARSET_DEFINED_P (charset
)
131 || c1
>= 0 && c1
< 32
132 || c2
>= 0 && c2
< 32)
133 error ("Invalid characer: %d", c
);
136 *workbuf
++ = CHARSET_LEADING_CODE_BASE (charset
);
137 if (*workbuf
= CHARSET_LEADING_CODE_EXT (charset
))
139 *workbuf
++ = c1
| 0x80;
141 *workbuf
++ = c2
| 0x80;
143 return (workbuf
- *str
);
146 /* Return a non-ASCII character of which multi-byte form is at STR of
147 length LEN. If ACTUAL_LEN is not NULL, the actual length of the
148 character is set to the address ACTUAL_LEN.
150 Use macro `STRING_CHAR (STR, LEN)' instead of calling this function
151 directly if STR can hold an ASCII character. */
153 string_to_non_ascii_char (str
, len
, actual_len
)
155 int len
, *actual_len
;
158 unsigned char c1
, c2
;
161 if (SPLIT_STRING (str
, len
, charset
, c1
, c2
) == CHARSET_ASCII
)
168 c
= MAKE_NON_ASCII_CHAR (charset
, c1
, c2
);
171 *actual_len
= (charset
== CHARSET_COMPOSITION
172 ? cmpchar_table
[COMPOSITE_CHAR_ID (c
)]->len
173 : BYTES_BY_CHAR_HEAD (*str
));
177 /* Return the length of the multi-byte form at string STR of length LEN. */
179 multibyte_form_length (str
, len
)
184 unsigned char c1
, c2
;
187 if (SPLIT_STRING (str
, len
, charset
, c1
, c2
) == CHARSET_ASCII
)
190 return (charset
== CHARSET_COMPOSITION
191 ? cmpchar_table
[(c1
<< 7) | c2
]->len
192 : BYTES_BY_CHAR_HEAD (*str
));
195 /* Check if string STR of length LEN contains valid multi-byte form of
196 a character. If valid, charset and position codes of the character
197 is set at *CHARSET, *C1, and *C2, and return 0. If not valid,
198 return -1. This should be used only in the macro SPLIT_STRING
199 which checks range of STR in advance. */
201 split_non_ascii_string (str
, len
, charset
, c1
, c2
)
202 register unsigned char *str
, *c1
, *c2
;
203 register int len
, *charset
;
205 register unsigned int cs
= *str
++;
207 if (cs
== LEADING_CODE_COMPOSITION
)
209 int cmpchar_id
= str_cmpchar_id (str
- 1, len
);
213 *charset
= cs
, *c1
= cmpchar_id
>> 7, *c2
= cmpchar_id
& 0x7F;
215 else if ((cs
< LEADING_CODE_PRIVATE_11
|| (cs
= *str
++) >= 0xA0)
216 && CHARSET_DEFINED_P (cs
))
221 *c1
= (*str
++) & 0x7F;
222 if (CHARSET_DIMENSION (cs
) == 2)
226 *c2
= (*str
++) & 0x7F;
234 /* Return a character unified with C (or a character made of CHARSET,
235 C1, and C2) in unification table TABLE. If no unification is found
236 in TABLE, return C. */
237 unify_char (table
, c
, charset
, c1
, c2
)
239 int c
, charset
, c1
, c2
;
242 int alt_charset
, alt_c1
, alt_c2
, dimension
;
244 if (c
< 0) c
= MAKE_CHAR (charset
, c1
, c2
);
245 if (!CHAR_TABLE_P (table
)
246 || (ch
= Faref (table
, make_number (c
)), !INTEGERP (ch
))
250 SPLIT_CHAR (XFASTINT (ch
), alt_charset
, alt_c1
, alt_c2
);
251 dimension
= CHARSET_DIMENSION (alt_charset
);
252 if (dimension
== 1 && alt_c1
> 0 || dimension
== 2 && alt_c2
> 0)
253 /* CH is not a generic character, just return it. */
254 return XFASTINT (ch
);
256 /* Since CH is a generic character, we must return a specific
257 charater which has the same position codes as C from CH. */
259 SPLIT_CHAR (c
, charset
, c1
, c2
);
260 if (dimension
!= CHARSET_DIMENSION (charset
))
261 /* We can't make such a character because of dimension mismatch. */
263 if (!alt_c1
) alt_c1
= c1
;
264 if (!alt_c2
) alt_c2
= c2
;
265 return MAKE_CHAR (alt_charset
, c1
, c2
);
268 /* Update the table Vcharset_table with the given arguments (see the
269 document of `define-charset' for the meaning of each argument).
270 Several other table contents are also updated. The caller should
271 check the validity of CHARSET-ID and the remaining arguments in
275 update_charset_table (charset_id
, dimension
, chars
, width
, direction
,
276 iso_final_char
, iso_graphic_plane
,
277 short_name
, long_name
, description
)
278 Lisp_Object charset_id
, dimension
, chars
, width
, direction
;
279 Lisp_Object iso_final_char
, iso_graphic_plane
;
280 Lisp_Object short_name
, long_name
, description
;
282 int charset
= XINT (charset_id
);
284 unsigned char leading_code_base
, leading_code_ext
;
286 if (NILP (CHARSET_TABLE_ENTRY (charset
)))
287 CHARSET_TABLE_ENTRY (charset
)
288 = Fmake_vector (make_number (CHARSET_MAX_IDX
), Qnil
);
290 /* Get byte length of multibyte form, base leading-code, and
291 extended leading-code of the charset. See the comment under the
292 title "GENERAL NOTE on CHARACTER SET (CHARSET)" in charset.h. */
293 bytes
= XINT (dimension
);
294 if (charset
< MIN_CHARSET_PRIVATE_DIMENSION1
)
296 /* Official charset, it doesn't have an extended leading-code. */
297 if (charset
!= CHARSET_ASCII
)
298 bytes
+= 1; /* For a base leading-code. */
299 leading_code_base
= charset
;
300 leading_code_ext
= 0;
304 /* Private charset. */
305 bytes
+= 2; /* For base and extended leading-codes. */
307 = (charset
< LEADING_CODE_EXT_12
308 ? LEADING_CODE_PRIVATE_11
309 : (charset
< LEADING_CODE_EXT_21
310 ? LEADING_CODE_PRIVATE_12
311 : (charset
< LEADING_CODE_EXT_22
312 ? LEADING_CODE_PRIVATE_21
313 : LEADING_CODE_PRIVATE_22
)));
314 leading_code_ext
= charset
;
317 CHARSET_TABLE_INFO (charset
, CHARSET_ID_IDX
) = charset_id
;
318 CHARSET_TABLE_INFO (charset
, CHARSET_BYTES_IDX
) = make_number (bytes
);
319 CHARSET_TABLE_INFO (charset
, CHARSET_DIMENSION_IDX
) = dimension
;
320 CHARSET_TABLE_INFO (charset
, CHARSET_CHARS_IDX
) = chars
;
321 CHARSET_TABLE_INFO (charset
, CHARSET_WIDTH_IDX
) = width
;
322 CHARSET_TABLE_INFO (charset
, CHARSET_DIRECTION_IDX
) = direction
;
323 CHARSET_TABLE_INFO (charset
, CHARSET_LEADING_CODE_BASE_IDX
)
324 = make_number (leading_code_base
);
325 CHARSET_TABLE_INFO (charset
, CHARSET_LEADING_CODE_EXT_IDX
)
326 = make_number (leading_code_ext
);
327 CHARSET_TABLE_INFO (charset
, CHARSET_ISO_FINAL_CHAR_IDX
) = iso_final_char
;
328 CHARSET_TABLE_INFO (charset
, CHARSET_ISO_GRAPHIC_PLANE_IDX
)
330 CHARSET_TABLE_INFO (charset
, CHARSET_SHORT_NAME_IDX
) = short_name
;
331 CHARSET_TABLE_INFO (charset
, CHARSET_LONG_NAME_IDX
) = long_name
;
332 CHARSET_TABLE_INFO (charset
, CHARSET_DESCRIPTION_IDX
) = description
;
333 CHARSET_TABLE_INFO (charset
, CHARSET_PLIST_IDX
) = Qnil
;
336 /* If we have already defined a charset which has the same
337 DIMENSION, CHARS and ISO-FINAL-CHAR but the different
338 DIRECTION, we must update the entry REVERSE-CHARSET of both
339 charsets. If there's no such charset, the value of the entry
343 for (i
= 0; i
<= MAX_CHARSET
; i
++)
344 if (!NILP (CHARSET_TABLE_ENTRY (i
)))
346 if (CHARSET_DIMENSION (i
) == XINT (dimension
)
347 && CHARSET_CHARS (i
) == XINT (chars
)
348 && CHARSET_ISO_FINAL_CHAR (i
) == XINT (iso_final_char
)
349 && CHARSET_DIRECTION (i
) != XINT (direction
))
351 CHARSET_TABLE_INFO (charset
, CHARSET_REVERSE_CHARSET_IDX
)
353 CHARSET_TABLE_INFO (i
, CHARSET_REVERSE_CHARSET_IDX
) = charset_id
;
358 /* No such a charset. */
359 CHARSET_TABLE_INFO (charset
, CHARSET_REVERSE_CHARSET_IDX
)
363 if (charset
!= CHARSET_ASCII
364 && charset
< MIN_CHARSET_PRIVATE_DIMENSION1
)
366 /* Update tables bytes_by_char_head and width_by_char_head. */
367 bytes_by_char_head
[leading_code_base
] = bytes
;
368 width_by_char_head
[leading_code_base
] = XINT (width
);
370 /* Update table emacs_code_class. */
371 emacs_code_class
[charset
] = (bytes
== 2
372 ? EMACS_leading_code_2
374 ? EMACS_leading_code_3
375 : EMACS_leading_code_4
));
378 /* Update table iso_charset_table. */
379 if (ISO_CHARSET_TABLE (dimension
, chars
, iso_final_char
) < 0)
380 ISO_CHARSET_TABLE (dimension
, chars
, iso_final_char
) = charset
;
385 /* Return charset id of CHARSET_SYMBOL, or return -1 if CHARSET_SYMBOL
388 get_charset_id (charset_symbol
)
389 Lisp_Object charset_symbol
;
394 return ((SYMBOLP (charset_symbol
)
395 && (val
= Fget (charset_symbol
, Qcharset
), VECTORP (val
))
396 && (charset
= XINT (XVECTOR (val
)->contents
[CHARSET_ID_IDX
]),
397 CHARSET_VALID_P (charset
)))
401 /* Return an identification number for a new private charset of
402 DIMENSION and WIDTH. If there's no more room for the new charset,
405 get_new_private_charset_id (dimension
, width
)
406 int dimension
, width
;
408 int charset
, from
, to
;
413 from
= LEADING_CODE_EXT_11
, to
= LEADING_CODE_EXT_12
;
415 from
= LEADING_CODE_EXT_12
, to
= LEADING_CODE_EXT_21
;
420 from
= LEADING_CODE_EXT_21
, to
= LEADING_CODE_EXT_22
;
422 from
= LEADING_CODE_EXT_22
, to
= LEADING_CODE_EXT_MAX
- 1;
425 for (charset
= from
; charset
< to
; charset
++)
426 if (!CHARSET_DEFINED_P (charset
)) break;
428 return make_number (charset
< to
? charset
: 0);
431 DEFUN ("define-charset", Fdefine_charset
, Sdefine_charset
, 3, 3, 0,
432 "Define CHARSET-ID as the identification number of CHARSET with INFO-VECTOR.\n\
433 If CHARSET-ID is nil, it is decided automatically, which means CHARSET is\n\
434 treated as a private charset.\n\
435 INFO-VECTOR is a vector of the format:\n\
436 [DIMENSION CHARS WIDTH DIRECTION ISO-FINAL-CHAR ISO-GRAPHIC-PLANE\n\
437 SHORT-NAME LONG-NAME DESCRIPTION]\n\
438 The meanings of each elements is as follows:\n\
439 DIMENSION (integer) is the number of bytes to represent a character: 1 or 2.\n\
440 CHARS (integer) is the number of characters in a dimension: 94 or 96.\n\
441 WIDTH (integer) is the number of columns a character in the charset\n\
442 occupies on the screen: one of 0, 1, and 2.\n\
444 DIRECTION (integer) is the rendering direction of characters in the\n\
445 charset when rendering. If 0, render from right to left, else\n\
446 render from left to right.\n\
448 ISO-FINAL-CHAR (character) is the final character of the\n\
449 corresponding ISO 2022 charset.\n\
451 ISO-GRAPHIC-PLANE (integer) is the graphic plane to be invoked\n\
452 while encoding to variants of ISO 2022 coding system, one of the\n\
453 following: 0/graphic-plane-left(GL), 1/graphic-plane-right(GR).\n\
455 SHORT-NAME (string) is the short name to refer to the charset.\n\
457 LONG-NAME (string) is the long name to refer to the charset.\n\
459 DESCRIPTION (string) is the description string of the charset.")
460 (charset_id
, charset_symbol
, info_vector
)
461 Lisp_Object charset_id
, charset_symbol
, info_vector
;
465 if (!NILP (charset_id
))
466 CHECK_NUMBER (charset_id
, 0);
467 CHECK_SYMBOL (charset_symbol
, 1);
468 CHECK_VECTOR (info_vector
, 2);
470 if (! NILP (charset_id
))
472 if (! CHARSET_VALID_P (XINT (charset_id
)))
473 error ("Invalid CHARSET: %d", XINT (charset_id
));
474 else if (CHARSET_DEFINED_P (XINT (charset_id
)))
475 error ("Already defined charset: %d", XINT (charset_id
));
478 vec
= XVECTOR (info_vector
)->contents
;
479 if (XVECTOR (info_vector
)->size
!= 9
480 || !INTEGERP (vec
[0]) || !(XINT (vec
[0]) == 1 || XINT (vec
[0]) == 2)
481 || !INTEGERP (vec
[1]) || !(XINT (vec
[1]) == 94 || XINT (vec
[1]) == 96)
482 || !INTEGERP (vec
[2]) || !(XINT (vec
[2]) == 1 || XINT (vec
[2]) == 2)
483 || !INTEGERP (vec
[3]) || !(XINT (vec
[3]) == 0 || XINT (vec
[3]) == 1)
484 || !INTEGERP (vec
[4]) || !(XINT (vec
[4]) >= '0' && XINT (vec
[4]) <= '~')
485 || !INTEGERP (vec
[5]) || !(XINT (vec
[5]) == 0 || XINT (vec
[5]) == 1)
488 || !STRINGP (vec
[8]))
489 error ("Invalid info-vector argument for defining charset %s",
490 XSYMBOL (charset_symbol
)->name
->data
);
492 if (NILP (charset_id
))
494 charset_id
= get_new_private_charset_id (XINT (vec
[0]), XINT (vec
[2]));
495 if (XINT (charset_id
) == 0)
496 error ("There's no room for a new private charset %s",
497 XSYMBOL (charset_symbol
)->name
->data
);
500 update_charset_table (charset_id
, vec
[0], vec
[1], vec
[2], vec
[3],
501 vec
[4], vec
[5], vec
[6], vec
[7], vec
[8]);
502 Fput (charset_symbol
, Qcharset
, CHARSET_TABLE_ENTRY (XINT (charset_id
)));
503 CHARSET_SYMBOL (XINT (charset_id
)) = charset_symbol
;
504 Vcharset_list
= Fcons (charset_symbol
, Vcharset_list
);
508 DEFUN ("declare-equiv-charset", Fdeclare_equiv_charset
, Sdeclare_equiv_charset
,
510 "Declare a charset of DIMENSION, CHARS, FINAL-CHAR is the same as CHARSET.\n\
511 CHARSET should be defined by `defined-charset' in advance.")
512 (dimension
, chars
, final_char
, charset_symbol
)
513 Lisp_Object dimension
, chars
, final_char
, charset_symbol
;
517 CHECK_NUMBER (dimension
, 0);
518 CHECK_NUMBER (chars
, 1);
519 CHECK_NUMBER (final_char
, 2);
520 CHECK_SYMBOL (charset_symbol
, 3);
522 if (XINT (dimension
) != 1 && XINT (dimension
) != 2)
523 error ("Invalid DIMENSION %d, it should be 1 or 2", XINT (dimension
));
524 if (XINT (chars
) != 94 && XINT (chars
) != 96)
525 error ("Invalid CHARS %d, it should be 94 or 96", XINT (chars
));
526 if (XINT (final_char
) < '0' || XFASTINT (final_char
) > '~')
527 error ("Invalid FINAL-CHAR %c, it should be `0'..`~'", XINT (chars
));
528 if ((charset
= get_charset_id (charset_symbol
)) < 0)
529 error ("Invalid charset %s", XSYMBOL (charset_symbol
)->name
->data
);
531 ISO_CHARSET_TABLE (dimension
, chars
, final_char
) = charset
;
535 /* Return number of different charsets in STR of length LEN. In
536 addition, for each found charset N, CHARSETS[N] is set 1. The
537 caller should allocate CHARSETS (MAX_CHARSET + 1 bytes) in advance.
538 It may lookup a unification table TABLE if supplied. */
541 find_charset_in_str (str
, len
, charsets
, table
)
542 unsigned char *str
, *charsets
;
548 if (! CHAR_TABLE_P (table
))
553 int bytes
= BYTES_BY_CHAR_HEAD (*str
);
557 charset
= CHARSET_AT (str
);
561 unsigned char c1
, c2
;
563 SPLIT_STRING(str
, bytes
, charset
, c1
, c2
);
564 if ((c
= unify_char (table
, -1, charset
, c1
, c2
)) >= 0)
565 charset
= CHAR_CHARSET (c
);
568 if (!charsets
[charset
])
570 charsets
[charset
] = 1;
579 DEFUN ("find-charset-region", Ffind_charset_region
, Sfind_charset_region
,
581 "Return a list of charsets in the region between BEG and END.\n\
582 BEG and END are buffer positions.\n\
583 Optional arg TABLE if non-nil is a unification table to look up.")
585 Lisp_Object beg
, end
, table
;
587 char charsets
[MAX_CHARSET
+ 1];
588 int from
, to
, stop
, i
;
591 validate_region (&beg
, &end
);
592 from
= XFASTINT (beg
);
593 stop
= to
= XFASTINT (end
);
594 if (from
< GPT
&& GPT
< to
)
596 bzero (charsets
, MAX_CHARSET
+ 1);
599 find_charset_in_str (POS_ADDR (from
), stop
- from
, charsets
, table
);
601 from
= stop
, stop
= to
;
606 for (i
= MAX_CHARSET
; i
>= 0; i
--)
608 val
= Fcons (CHARSET_SYMBOL (i
), val
);
612 DEFUN ("find-charset-string", Ffind_charset_string
, Sfind_charset_string
,
614 "Return a list of charsets in STR.\n\
615 Optional arg TABLE if non-nil is a unification table to look up.")
617 Lisp_Object str
, table
;
619 char charsets
[MAX_CHARSET
+ 1];
623 CHECK_STRING (str
, 0);
624 bzero (charsets
, MAX_CHARSET
+ 1);
625 find_charset_in_str (XSTRING (str
)->data
, XSTRING (str
)->size
,
628 for (i
= MAX_CHARSET
; i
>= 0; i
--)
630 val
= Fcons (CHARSET_SYMBOL (i
), val
);
634 DEFUN ("make-char-internal", Fmake_char_internal
, Smake_char_internal
, 1, 3, 0,
636 (charset
, code1
, code2
)
637 Lisp_Object charset
, code1
, code2
;
639 CHECK_NUMBER (charset
, 0);
642 XSETFASTINT (code1
, 0);
644 CHECK_NUMBER (code1
, 1);
646 XSETFASTINT (code2
, 0);
648 CHECK_NUMBER (code2
, 2);
650 if (!CHARSET_DEFINED_P (XINT (charset
)))
651 error ("Invalid charset: %d", XINT (charset
));
653 return make_number (MAKE_CHAR (XINT (charset
), XINT (code1
), XINT (code2
)));
656 DEFUN ("split-char", Fsplit_char
, Ssplit_char
, 1, 1, 0,
657 "Return list of charset and one or two position-codes of CHAR.")
664 CHECK_NUMBER (ch
, 0);
665 SPLIT_CHAR (XFASTINT (ch
), charset
, c1
, c2
);
667 ? Fcons (CHARSET_SYMBOL (charset
),
668 Fcons (make_number (c1
), Fcons (make_number (c2
), Qnil
)))
669 : Fcons (CHARSET_SYMBOL (charset
), Fcons (make_number (c1
), Qnil
)));
672 DEFUN ("char-charset", Fchar_charset
, Schar_charset
, 1, 1, 0,
673 "Return charset of CHAR.")
677 CHECK_NUMBER (ch
, 0);
679 return CHARSET_SYMBOL (CHAR_CHARSET (XINT (ch
)));
682 DEFUN ("iso-charset", Fiso_charset
, Siso_charset
, 3, 3, 0,
683 "Return charset of ISO's specification DIMENSION, CHARS, and FINAL-CHAR.")
684 (dimension
, chars
, final_char
)
685 Lisp_Object dimension
, chars
, final_char
;
689 CHECK_NUMBER (dimension
, 0);
690 CHECK_NUMBER (chars
, 1);
691 CHECK_NUMBER (final_char
, 2);
693 if ((charset
= ISO_CHARSET_TABLE (dimension
, chars
, final_char
)) < 0)
695 return CHARSET_SYMBOL (charset
);
698 DEFUN ("char-bytes", Fchar_bytes
, Schar_bytes
, 1, 1, 0,
699 "Return byte length of multi-byte form of CHAR.")
706 CHECK_NUMBER (ch
, 0);
707 if (COMPOSITE_CHAR_P (XFASTINT (ch
)))
709 unsigned int id
= COMPOSITE_CHAR_ID (XFASTINT (ch
));
711 bytes
= (id
< n_cmpchars
? cmpchar_table
[id
]->len
: 1);
715 int charset
= CHAR_CHARSET (XFASTINT (ch
));
717 bytes
= CHARSET_DEFINED_P (charset
) ? CHARSET_BYTES (charset
) : 1;
720 XSETFASTINT (val
, bytes
);
724 /* Return the width of character of which multi-byte form starts with
725 C. The width is measured by how many columns occupied on the
726 screen when displayed in the current buffer. */
728 #define ONE_BYTE_CHAR_WIDTH(c) \
731 ? XFASTINT (current_buffer->tab_width) \
732 : (c == '\n' ? 0 : (NILP (current_buffer->ctl_arrow) ? 4 : 2))) \
736 ? (NILP (current_buffer->ctl_arrow) ? 4 : 2) \
737 : ((! NILP (current_buffer->enable_multibyte_characters) \
738 && BASE_LEADING_CODE_P (c)) \
739 ? WIDTH_BY_CHAR_HEAD (c) \
743 DEFUN ("char-width", Fchar_width, Schar_width, 1, 1, 0,
744 "Return width of CHAR when displayed in the current buffer.\n\
745 The width is measured by how many columns it occupies on the screen.")
749 Lisp_Object val
, disp
;
752 CHECK_NUMBER (ch
, 0);
756 /* Get the way the display table would display it. */
757 disp
= DISP_CHAR_VECTOR (buffer_display_table (current_buffer
), (c
));
760 XSETINT (val
, XVECTOR (disp
)->size
);
761 else if (SINGLE_BYTE_CHAR_P (c
))
762 XSETINT (val
, ONE_BYTE_CHAR_WIDTH (c
));
763 else if (COMPOSITE_CHAR_P (c
))
765 int id
= COMPOSITE_CHAR_ID (XFASTINT (ch
));
766 XSETFASTINT (val
, (id
< n_cmpchars
? cmpchar_table
[id
]->width
: 0));
770 int charset
= CHAR_CHARSET (c
);
772 XSETFASTINT (val
, CHARSET_WIDTH (charset
));
777 /* Return width of string STR of length LEN when displayed in the
778 current buffer. The width is measured by how many columns it
779 occupies on the screen. */
786 unsigned char *endp
= str
+ len
;
788 struct Lisp_Char_Table
*dp
= buffer_display_table (current_buffer
);
792 if (*str
== LEADING_CODE_COMPOSITION
)
794 int id
= str_cmpchar_id (str
, endp
- str
);
803 width
+= cmpchar_table
[id
]->width
;
804 str
+= cmpchar_table
[id
]->len
;
811 int c
= STRING_CHAR (str
, endp
- str
);
813 /* Get the way the display table would display it. */
814 disp
= DISP_CHAR_VECTOR (dp
, c
);
817 thiswidth
= XVECTOR (disp
)->size
;
819 thiswidth
= ONE_BYTE_CHAR_WIDTH (*str
);
822 str
+= BYTES_BY_CHAR_HEAD (*str
);
828 DEFUN ("string-width", Fstring_width
, Sstring_width
, 1, 1, 0,
829 "Return width of STRING when displayed in the current buffer.\n\
830 Width is measured by how many columns it occupies on the screen.\n\
831 When calculating width of a multi-byte character in STRING,\n\
832 only the base leading-code is considered and the validity of\n\
833 the following bytes are not checked.")
839 CHECK_STRING (str
, 0);
840 XSETFASTINT (val
, strwidth (XSTRING (str
)->data
, XSTRING (str
)->size
));
844 DEFUN ("char-direction", Fchar_direction
, Schar_direction
, 1, 1, 0,
845 "Return the direction of CHAR.\n\
846 The returned value is 0 for left-to-right and 1 for right-to-left.")
852 CHECK_NUMBER (ch
, 0);
853 charset
= CHAR_CHARSET (XFASTINT (ch
));
854 if (!CHARSET_DEFINED_P (charset
))
855 error ("Invalid character: %d", XINT (ch
));
856 return CHARSET_TABLE_INFO (charset
, CHARSET_DIRECTION_IDX
);
859 DEFUN ("chars-in-string", Fchars_in_string
, Schars_in_string
, 1, 1, 0,
860 "Return number of characters in STRING.")
865 unsigned char *p
, *endp
;
868 CHECK_STRING (str
, 0);
870 p
= XSTRING (str
)->data
; endp
= p
+ XSTRING (str
)->size
;
874 if (*p
== LEADING_CODE_COMPOSITION
)
877 while (p
< endp
&& ! CHAR_HEAD_P (p
)) p
++;
880 p
+= BYTES_BY_CHAR_HEAD (*p
);
884 XSETFASTINT (val
, chars
);
888 DEFUN ("char-boundary-p", Fchar_boundary_p
, Schar_boundary_p
, 1, 1, 0,
889 "Return non-nil value if POS is at character boundary of multibyte form.\n\
890 The return value is:\n\
891 0 if POS is at an ASCII character or at the end of range,\n\
892 1 if POS is at a head of 2-byte length multi-byte form,\n\
893 2 if POS is at a head of 3-byte length multi-byte form,\n\
894 3 if POS is at a head of 4-byte length multi-byte form,\n\
895 4 if POS is at a head of multi-byte form of a composite character.\n\
896 If POS is out of range or not at character boundary, return NIL.")
903 CHECK_NUMBER_COERCE_MARKER (pos
, 0);
906 if (n
< BEGV
|| n
> ZV
)
909 if (n
== ZV
|| NILP (current_buffer
->enable_multibyte_characters
))
910 XSETFASTINT (val
, 0);
913 unsigned char *p
= POS_ADDR (n
);
915 if (SINGLE_BYTE_CHAR_P (*p
))
916 XSETFASTINT (val
, 0);
917 else if (*p
== LEADING_CODE_COMPOSITION
)
918 XSETFASTINT (val
, 4);
919 else if (BYTES_BY_CHAR_HEAD (*p
) > 1)
920 XSETFASTINT (val
, BYTES_BY_CHAR_HEAD (*p
) - 1);
927 DEFUN ("concat-chars", Fconcat_chars
, Sconcat_chars
, 1, MANY
, 0,
928 "Concatenate all the argument characters and make the result a string.")
935 = (unsigned char *) alloca (MAX_LENGTH_OF_MULTI_BYTE_FORM
* n
);
936 unsigned char *p
= buf
;
939 for (i
= 0; i
< n
; i
++)
944 if (!INTEGERP (args
[i
]))
947 CHECK_NUMBER (args
[i
], 0);
950 len
= CHAR_STRING (c
, p
, str
);
952 /* C is a composite character. */
957 val
= make_string (buf
, p
- buf
);
963 /*** Composite characters staffs ***/
965 /* Each composite character is identified by CMPCHAR-ID which is
966 assigned when Emacs needs the character code of the composite
967 character (e.g. when displaying it on the screen). See the
968 document "GENERAL NOTE on COMPOSITE CHARACTER" in `charset.h' how a
969 composite character is represented in Emacs. */
971 /* If `static' is defined, it means that it is defined to null string. */
973 /* The following function is copied from lread.c. */
975 hash_string (ptr
, len
)
979 register unsigned char *p
= ptr
;
980 register unsigned char *end
= p
+ len
;
981 register unsigned char c
;
982 register int hash
= 0;
987 if (c
>= 0140) c
-= 40;
988 hash
= ((hash
<<3) + (hash
>>28) + c
);
990 return hash
& 07777777777;
994 #define CMPCHAR_HASH_TABLE_SIZE 0xFFF
996 static int *cmpchar_hash_table
[CMPCHAR_HASH_TABLE_SIZE
];
998 /* Each element of `cmpchar_hash_table' is a pointer to an array of
999 integer, where the 1st element is the size of the array, the 2nd
1000 element is how many elements are actually used in the array, and
1001 the remaining elements are CMPCHAR-IDs of composite characters of
1002 the same hash value. */
1003 #define CMPCHAR_HASH_SIZE(table) table[0]
1004 #define CMPCHAR_HASH_USED(table) table[1]
1005 #define CMPCHAR_HASH_CMPCHAR_ID(table, i) table[i]
1007 /* Return CMPCHAR-ID of the composite character in STR of the length
1008 LEN. If the composite character has not yet been registered,
1009 register it in `cmpchar_table' and assign new CMPCHAR-ID. This
1010 is the sole function for assigning CMPCHAR-ID. */
1012 str_cmpchar_id (str
, len
)
1016 int hash_idx
, *hashp
;
1018 int embedded_rule
; /* 1 if composition rule is embedded. */
1019 int chars
; /* number of components. */
1021 struct cmpchar_info
*cmpcharp
;
1024 /* Any composite char have at least 3-byte length. */
1027 /* The second byte 0xFF means compostion rule is embedded. */
1028 embedded_rule
= (str
[1] == 0xFF);
1030 /* At first, get the actual length of the composite character. */
1032 unsigned char *p
, *endp
= str
+ 1, *lastp
= str
+ len
;
1035 while (endp
< lastp
&& ! CHAR_HEAD_P (endp
)) endp
++;
1037 p
= str
+ 1 + embedded_rule
;
1040 /* No need of checking if *P is 0xA0 because
1041 BYTES_BY_CHAR_HEAD (0x80) surely returns 2. */
1042 p
+= (bytes
= BYTES_BY_CHAR_HEAD (*p
- 0x20) + embedded_rule
);
1045 len
= (p
-= embedded_rule
) - str
;
1047 len
-= - bytes
, chars
--;
1049 if (chars
< 2 || chars
> MAX_COMPONENT_COUNT
)
1050 /* Invalid number of components. */
1053 hash_idx
= hash_string (str
, len
) % CMPCHAR_HASH_TABLE_SIZE
;
1054 hashp
= cmpchar_hash_table
[hash_idx
];
1056 /* Then, look into the hash table. */
1058 /* Find the correct one among composite characters of the same
1060 for (i
= 2; i
< CMPCHAR_HASH_USED (hashp
); i
++)
1062 cmpcharp
= cmpchar_table
[CMPCHAR_HASH_CMPCHAR_ID (hashp
, i
)];
1063 if (len
== cmpcharp
->len
1064 && ! bcmp (str
, cmpcharp
->data
, len
))
1065 return CMPCHAR_HASH_CMPCHAR_ID (hashp
, i
);
1068 /* We have to register the composite character in cmpchar_table. */
1069 if (n_cmpchars
> (CHAR_FIELD2_MASK
| CHAR_FIELD3_MASK
))
1070 /* No, we have no more room for a new composite character. */
1073 /* Make the entry in hash table. */
1076 /* Make a table for 8 composite characters initially. */
1077 hashp
= (cmpchar_hash_table
[hash_idx
]
1078 = (int *) xmalloc (sizeof (int) * (2 + 8)));
1079 CMPCHAR_HASH_SIZE (hashp
) = 10;
1080 CMPCHAR_HASH_USED (hashp
) = 2;
1082 else if (CMPCHAR_HASH_USED (hashp
) >= CMPCHAR_HASH_SIZE (hashp
))
1084 CMPCHAR_HASH_SIZE (hashp
) += 8;
1085 hashp
= (cmpchar_hash_table
[hash_idx
]
1086 = (int *) xrealloc (hashp
,
1087 sizeof (int) * CMPCHAR_HASH_SIZE (hashp
)));
1089 CMPCHAR_HASH_CMPCHAR_ID (hashp
, CMPCHAR_HASH_USED (hashp
)) = n_cmpchars
;
1090 CMPCHAR_HASH_USED (hashp
)++;
1092 /* Set information of the composite character in cmpchar_table. */
1093 if (cmpchar_table_size
== 0)
1095 /* This is the first composite character to be registered. */
1096 cmpchar_table_size
= 256;
1098 = (struct cmpchar_info
**) xmalloc (sizeof (cmpchar_table
[0])
1099 * cmpchar_table_size
);
1101 else if (cmpchar_table_size
<= n_cmpchars
)
1103 cmpchar_table_size
+= 256;
1105 = (struct cmpchar_info
**) xrealloc (cmpchar_table
,
1106 sizeof (cmpchar_table
[0])
1107 * cmpchar_table_size
);
1110 cmpcharp
= (struct cmpchar_info
*) xmalloc (sizeof (struct cmpchar_info
));
1112 cmpcharp
->len
= len
;
1113 cmpcharp
->data
= (unsigned char *) xmalloc (len
+ 1);
1114 bcopy (str
, cmpcharp
->data
, len
);
1115 cmpcharp
->data
[len
] = 0;
1116 cmpcharp
->glyph_len
= chars
;
1117 cmpcharp
->glyph
= (GLYPH
*) xmalloc (sizeof (GLYPH
) * chars
);
1120 cmpcharp
->cmp_rule
= (unsigned char *) xmalloc (chars
);
1121 cmpcharp
->col_offset
= (float *) xmalloc (sizeof (float) * chars
);
1125 cmpcharp
->cmp_rule
= NULL
;
1126 cmpcharp
->col_offset
= NULL
;
1129 /* Setup GLYPH data and composition rules (if any) so as not to make
1130 them every time on displaying. */
1132 unsigned char *bufp
;
1134 float leftmost
= 0.0, rightmost
= 1.0;
1137 /* At first, col_offset[N] is set to relative to col_offset[0]. */
1138 cmpcharp
->col_offset
[0] = 0;
1140 for (i
= 0, bufp
= cmpcharp
->data
+ 1; i
< chars
; i
++)
1143 cmpcharp
->cmp_rule
[i
] = *bufp
++;
1145 if (*bufp
== 0xA0) /* This is an ASCII character. */
1147 cmpcharp
->glyph
[i
] = FAST_MAKE_GLYPH ((*++bufp
& 0x7F), 0);
1151 else /* Multibyte character. */
1153 /* Make `bufp' point normal multi-byte form temporally. */
1156 = FAST_MAKE_GLYPH (string_to_non_ascii_char (bufp
, 4, 0), 0);
1157 width
= WIDTH_BY_CHAR_HEAD (*bufp
);
1159 bufp
+= BYTES_BY_CHAR_HEAD (*bufp
- 0x20);
1162 if (embedded_rule
&& i
> 0)
1164 /* Reference points (global_ref and new_ref) are
1175 Now, we calculate the column offset of the new glyph
1176 from the left edge of the first glyph. This can avoid
1177 the same calculation everytime displaying this
1178 composite character. */
1180 /* Reference points of global glyph and new glyph. */
1181 int global_ref
= (cmpcharp
->cmp_rule
[i
] - 0xA0) / 9;
1182 int new_ref
= (cmpcharp
->cmp_rule
[i
] - 0xA0) % 9;
1183 /* Column offset relative to the first glyph. */
1184 float left
= (leftmost
1185 + (global_ref
% 3) * (rightmost
- leftmost
) / 2.0
1186 - (new_ref
% 3) * width
/ 2.0);
1188 cmpcharp
->col_offset
[i
] = left
;
1189 if (left
< leftmost
)
1191 if (left
+ width
> rightmost
)
1192 rightmost
= left
+ width
;
1196 if (width
> rightmost
)
1202 /* Now col_offset[N] are relative to the left edge of the
1203 first component. Make them relative to the left edge of
1205 for (i
= 0; i
< chars
; i
++)
1206 cmpcharp
->col_offset
[i
] -= leftmost
;
1207 /* Make rightmost holds width of overall glyph. */
1208 rightmost
-= leftmost
;
1211 cmpcharp
->width
= rightmost
;
1212 if (cmpcharp
->width
< rightmost
)
1213 /* To get a ceiling integer value. */
1217 cmpchar_table
[n_cmpchars
] = cmpcharp
;
1219 return n_cmpchars
++;
1222 /* Return the Nth element of the composite character C. */
1224 cmpchar_component (c
, n
)
1227 int id
= COMPOSITE_CHAR_ID (c
);
1229 if (id
>= n_cmpchars
/* C is not a valid composite character. */
1230 || n
>= cmpchar_table
[id
]->glyph_len
) /* No such component. */
1232 /* No face data is stored in glyph code. */
1233 return ((int) (cmpchar_table
[id
]->glyph
[n
]));
1236 DEFUN ("cmpcharp", Fcmpcharp
, Scmpcharp
, 1, 1, 0,
1237 "T if CHAR is a composite character.")
1241 CHECK_NUMBER (ch
, 0);
1242 return (COMPOSITE_CHAR_P (XINT (ch
)) ? Qt
: Qnil
);
1245 DEFUN ("composite-char-component", Fcmpchar_component
, Scmpchar_component
,
1247 "Return the IDXth component character of composite character CHARACTER.")
1249 Lisp_Object character
, idx
;
1253 CHECK_NUMBER (character
, 0);
1254 CHECK_NUMBER (idx
, 1);
1256 if ((c
= cmpchar_component (XINT (character
), XINT (idx
))) < 0)
1257 args_out_of_range (character
, idx
);
1259 return make_number (c
);
1262 DEFUN ("composite-char-composition-rule", Fcmpchar_cmp_rule
, Scmpchar_cmp_rule
,
1264 "Return the Nth composition rule embedded in composite character CHARACTER.\n\
1265 The returned rule is for composing the Nth component\n\
1266 on the (N-1)th component. If N is 0, the returned value is always 255.")
1268 Lisp_Object character
, n
;
1272 CHECK_NUMBER (character
, 0);
1273 CHECK_NUMBER (n
, 1);
1275 id
= COMPOSITE_CHAR_ID (XINT (character
));
1276 if (id
< 0 || id
>= n_cmpchars
)
1277 error ("Invalid composite character: %d", XINT (character
));
1279 if (i
> cmpchar_table
[id
]->glyph_len
)
1280 args_out_of_range (character
, n
);
1282 return make_number (cmpchar_table
[id
]->cmp_rule
[i
]);
1285 DEFUN ("composite-char-composition-rule-p", Fcmpchar_cmp_rule_p
,
1286 Scmpchar_cmp_rule_p
, 1, 1, 0,
1287 "Return non-nil if composite character CHARACTER contains a embedded rule.")
1289 Lisp_Object character
;
1293 CHECK_NUMBER (character
, 0);
1294 id
= COMPOSITE_CHAR_ID (XINT (character
));
1295 if (id
< 0 || id
>= n_cmpchars
)
1296 error ("Invalid composite character: %d", XINT (character
));
1298 return (cmpchar_table
[id
]->cmp_rule
? Qt
: Qnil
);
1301 DEFUN ("composite-char-component-count", Fcmpchar_cmp_count
,
1302 Scmpchar_cmp_count
, 1, 1, 0,
1303 "Return number of compoents of composite character CHARACTER.")
1305 Lisp_Object character
;
1309 CHECK_NUMBER (character
, 0);
1310 id
= COMPOSITE_CHAR_ID (XINT (character
));
1311 if (id
< 0 || id
>= n_cmpchars
)
1312 error ("Invalid composite character: %d", XINT (character
));
1314 return (make_number (cmpchar_table
[id
]->glyph_len
));
1317 DEFUN ("compose-string", Fcompose_string
, Scompose_string
,
1319 "Return one char string composed from all characters in STRING.")
1323 unsigned char buf
[MAX_LENGTH_OF_MULTI_BYTE_FORM
], *p
, *pend
, *ptemp
;
1326 CHECK_STRING (str
, 0);
1328 buf
[0] = LEADING_CODE_COMPOSITION
;
1329 p
= XSTRING (str
)->data
;
1330 pend
= p
+ XSTRING (str
)->size
;
1334 if (*p
< 0x20 || *p
== 127) /* control code */
1335 error ("Invalid component character: %d", *p
);
1336 else if (*p
< 0x80) /* ASCII */
1338 if (i
+ 2 >= MAX_LENGTH_OF_MULTI_BYTE_FORM
)
1339 error ("Too long string to be composed: %s", XSTRING (str
)->data
);
1340 /* Prepend an ASCII charset indicator 0xA0, set MSB of the
1343 buf
[i
++] = *p
++ + 0x80;
1345 else if (*p
== LEADING_CODE_COMPOSITION
) /* composite char */
1347 /* Already composed. Eliminate the heading
1348 LEADING_CODE_COMPOSITION, keep the remaining bytes
1352 while (! CHAR_HEAD_P (p
)) p
++;
1353 if (i
+ (p
- ptemp
) >= MAX_LENGTH_OF_MULTI_BYTE_FORM
)
1354 error ("Too long string to be composed: %s", XSTRING (str
)->data
);
1355 bcopy (ptemp
, buf
+ i
, p
- ptemp
);
1358 else /* multibyte char */
1360 /* Add 0x20 to the base leading-code, keep the remaining
1362 len
= BYTES_BY_CHAR_HEAD (*p
);
1363 if (i
+ len
>= MAX_LENGTH_OF_MULTI_BYTE_FORM
)
1364 error ("Too long string to be composed: %s", XSTRING (str
)->data
);
1365 bcopy (p
, buf
+ i
, len
);
1372 /* STR contains only one character, which can't be composed. */
1373 error ("Too short string to be composed: %s", XSTRING (str
)->data
);
1375 return make_string (buf
, i
);
1379 charset_id_internal (charset_name
)
1382 Lisp_Object val
= Fget (intern (charset_name
), Qcharset
);
1385 error ("Charset %s is not defined", charset_name
);
1387 return (XINT (XVECTOR (val
)->contents
[0]));
1390 DEFUN ("setup-special-charsets", Fsetup_special_charsets
,
1391 Ssetup_special_charsets
, 0, 0, 0, "Internal use only.")
1394 charset_latin_iso8859_1
= charset_id_internal ("latin-iso8859-1");
1395 charset_jisx0208_1978
= charset_id_internal ("japanese-jisx0208-1978");
1396 charset_jisx0208
= charset_id_internal ("japanese-jisx0208");
1397 charset_katakana_jisx0201
= charset_id_internal ("katakana-jisx0201");
1398 charset_latin_jisx0201
= charset_id_internal ("latin-jisx0201");
1399 charset_big5_1
= charset_id_internal ("chinese-big5-1");
1400 charset_big5_2
= charset_id_internal ("chinese-big5-2");
1404 init_charset_once ()
1408 staticpro (&Vcharset_table
);
1409 staticpro (&Vcharset_symbol_table
);
1411 /* This has to be done here, before we call Fmake_char_table. */
1412 Qcharset_table
= intern ("charset-table");
1413 staticpro (&Qcharset_table
);
1415 /* Intern this now in case it isn't already done.
1416 Setting this variable twice is harmless.
1417 But don't staticpro it here--that is done in alloc.c. */
1418 Qchar_table_extra_slots
= intern ("char-table-extra-slots");
1420 /* Now we are ready to set up this property, so we can
1421 create the charset table. */
1422 Fput (Qcharset_table
, Qchar_table_extra_slots
, make_number (0));
1423 Vcharset_table
= Fmake_char_table (Qcharset_table
, Qnil
);
1425 Vcharset_symbol_table
= Fmake_vector (make_number (MAX_CHARSET
+ 1), Qnil
);
1428 for (i
= 0; i
< 2; i
++)
1429 for (j
= 0; j
< 2; j
++)
1430 for (k
= 0; k
< 128; k
++)
1431 iso_charset_table
[i
][j
][k
] = -1;
1433 bzero (cmpchar_hash_table
, sizeof cmpchar_hash_table
);
1434 cmpchar_table_size
= n_cmpchars
= 0;
1436 for (i
= 0; i
< 256; i
++)
1437 BYTES_BY_CHAR_HEAD (i
) = 1;
1438 BYTES_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_11
) = 3;
1439 BYTES_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_12
) = 3;
1440 BYTES_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_21
) = 4;
1441 BYTES_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_22
) = 4;
1442 /* The following doesn't reflect the actual bytes, but just to tell
1443 that it is a start of a multibyte character. */
1444 BYTES_BY_CHAR_HEAD (LEADING_CODE_COMPOSITION
) = 2;
1446 for (i
= 0; i
< 128; i
++)
1447 WIDTH_BY_CHAR_HEAD (i
) = 1;
1448 for (; i
< 256; i
++)
1449 WIDTH_BY_CHAR_HEAD (i
) = 4;
1450 WIDTH_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_11
) = 1;
1451 WIDTH_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_12
) = 2;
1452 WIDTH_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_21
) = 1;
1453 WIDTH_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_22
) = 2;
1460 Qascii
= intern ("ascii");
1461 staticpro (&Qascii
);
1463 Qcharset
= intern ("charset");
1464 staticpro (&Qcharset
);
1466 /* Define ASCII charset now. */
1467 update_charset_table (make_number (CHARSET_ASCII
),
1468 make_number (1), make_number (94),
1473 build_string ("ASCII"),
1474 build_string ("ASCII"),
1475 build_string ("ASCII (ISO646 IRV)"));
1476 CHARSET_SYMBOL (CHARSET_ASCII
) = Qascii
;
1477 Fput (Qascii
, Qcharset
, CHARSET_TABLE_ENTRY (CHARSET_ASCII
));
1479 Qcomposition
= intern ("composition");
1480 staticpro (&Qcomposition
);
1481 CHARSET_SYMBOL (CHARSET_COMPOSITION
) = Qcomposition
;
1483 defsubr (&Sdefine_charset
);
1484 defsubr (&Sdeclare_equiv_charset
);
1485 defsubr (&Sfind_charset_region
);
1486 defsubr (&Sfind_charset_string
);
1487 defsubr (&Smake_char_internal
);
1488 defsubr (&Ssplit_char
);
1489 defsubr (&Schar_charset
);
1490 defsubr (&Siso_charset
);
1491 defsubr (&Schar_bytes
);
1492 defsubr (&Schar_width
);
1493 defsubr (&Sstring_width
);
1494 defsubr (&Schar_direction
);
1495 defsubr (&Schars_in_string
);
1496 defsubr (&Schar_boundary_p
);
1497 defsubr (&Sconcat_chars
);
1498 defsubr (&Scmpcharp
);
1499 defsubr (&Scmpchar_component
);
1500 defsubr (&Scmpchar_cmp_rule
);
1501 defsubr (&Scmpchar_cmp_rule_p
);
1502 defsubr (&Scmpchar_cmp_count
);
1503 defsubr (&Scompose_string
);
1504 defsubr (&Ssetup_special_charsets
);
1506 DEFVAR_LISP ("charset-list", &Vcharset_list
,
1507 "List of charsets ever defined.");
1508 Vcharset_list
= Fcons (Qascii
, Qnil
);
1510 DEFVAR_INT ("leading-code-composition", &leading_code_composition
,
1511 "Leading-code of composite characters.");
1512 leading_code_composition
= LEADING_CODE_COMPOSITION
;
1514 DEFVAR_INT ("leading-code-private-11", &leading_code_private_11
,
1515 "Leading-code of private TYPE9N charset of column-width 1.");
1516 leading_code_private_11
= LEADING_CODE_PRIVATE_11
;
1518 DEFVAR_INT ("leading-code-private-12", &leading_code_private_12
,
1519 "Leading-code of private TYPE9N charset of column-width 2.");
1520 leading_code_private_12
= LEADING_CODE_PRIVATE_12
;
1522 DEFVAR_INT ("leading-code-private-21", &leading_code_private_21
,
1523 "Leading-code of private TYPE9Nx9N charset of column-width 1.");
1524 leading_code_private_21
= LEADING_CODE_PRIVATE_21
;
1526 DEFVAR_INT ("leading-code-private-22", &leading_code_private_22
,
1527 "Leading-code of private TYPE9Nx9N charset of column-width 2.");
1528 leading_code_private_22
= LEADING_CODE_PRIVATE_22
;