1 /* Basic multilingual character support.
2 Copyright (C) 1995, 1997, 1998 Electrotechnical Laboratory, JAPAN.
3 Licensed to the Free Software Foundation.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /* At first, see the document in `charset.h' to understand the code in
29 #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 int min_composite_char
;
65 Lisp_Object Qcharset_table
;
67 /* A char-table containing information of each character set. */
68 Lisp_Object Vcharset_table
;
70 /* A vector of charset symbol indexed by charset-id. This is used
71 only for returning charset symbol from C functions. */
72 Lisp_Object Vcharset_symbol_table
;
74 /* A list of charset symbols ever defined. */
75 Lisp_Object Vcharset_list
;
77 /* Vector of translation table ever defined.
78 ID of a translation table is used to index this vector. */
79 Lisp_Object Vtranslation_table_vector
;
81 /* Tables used by macros BYTES_BY_CHAR_HEAD and WIDTH_BY_CHAR_HEAD. */
82 int bytes_by_char_head
[256];
83 int width_by_char_head
[256];
85 /* Mapping table from ISO2022's charset (specified by DIMENSION,
86 CHARS, and FINAL-CHAR) to Emacs' charset. */
87 int iso_charset_table
[2][2][128];
89 /* Table of pointers to the structure `cmpchar_info' indexed by
91 struct cmpchar_info
**cmpchar_table
;
92 /* The current size of `cmpchar_table'. */
93 static int cmpchar_table_size
;
94 /* Number of the current composite characters. */
97 /* Variables used locally in the macro FETCH_MULTIBYTE_CHAR. */
98 unsigned char *_fetch_multibyte_char_p
;
99 int _fetch_multibyte_char_len
;
101 /* Offset to add to a non-ASCII value when inserting it. */
102 int nonascii_insert_offset
;
104 /* Translation table for converting non-ASCII unibyte characters
105 to multibyte codes, or nil. */
106 Lisp_Object Vnonascii_translation_table
;
108 /* List of all possible generic characters. */
109 Lisp_Object Vgeneric_character_list
;
111 #define min(X, Y) ((X) < (Y) ? (X) : (Y))
112 #define max(X, Y) ((X) > (Y) ? (X) : (Y))
115 invalid_character (c
)
118 error ("Invalid character: %o, %d, 0x%x", c
);
122 /* Set STR a pointer to the multi-byte form of the character C. If C
123 is not a composite character, the multi-byte form is set in WORKBUF
124 and STR points WORKBUF. The caller should allocate at least 4-byte
125 area at WORKBUF in advance. Returns the length of the multi-byte
126 form. If C is an invalid character to have a multi-byte form,
129 Use macro `CHAR_STRING (C, WORKBUF, STR)' instead of calling this
130 function directly if C can be an ASCII character. */
133 non_ascii_char_to_string (c
, workbuf
, str
)
135 unsigned char *workbuf
, **str
;
139 if (COMPOSITE_CHAR_P (c
))
141 int cmpchar_id
= COMPOSITE_CHAR_ID (c
);
143 if (cmpchar_id
< n_cmpchars
)
145 *str
= cmpchar_table
[cmpchar_id
]->data
;
146 return cmpchar_table
[cmpchar_id
]->len
;
150 invalid_character (c
);
154 SPLIT_NON_ASCII_CHAR (c
, charset
, c1
, c2
);
156 || ! CHARSET_DEFINED_P (charset
)
157 || c1
>= 0 && c1
< 32
158 || c2
>= 0 && c2
< 32)
159 invalid_character (c
);
162 *workbuf
++ = CHARSET_LEADING_CODE_BASE (charset
);
163 if (*workbuf
= CHARSET_LEADING_CODE_EXT (charset
))
165 *workbuf
++ = c1
| 0x80;
167 *workbuf
++ = c2
| 0x80;
169 return (workbuf
- *str
);
172 /* Return a non-ASCII character of which multi-byte form is at STR of
173 length LEN. If ACTUAL_LEN is not NULL, the actual length of the
174 multibyte form is set to the address ACTUAL_LEN.
176 If exclude_tail_garbage is nonzero, ACTUAL_LEN excludes gabage
177 bytes following the non-ASCII character.
179 Use macro `STRING_CHAR (STR, LEN)' instead of calling this function
180 directly if STR can hold an ASCII character. */
183 string_to_non_ascii_char (str
, len
, actual_len
, exclude_tail_garbage
)
184 const unsigned char *str
;
185 int len
, *actual_len
, exclude_tail_garbage
;
188 unsigned char c1
, c2
;
189 register int c
, bytes
;
194 if (BASE_LEADING_CODE_P (c
))
196 while (bytes
< len
&& ! CHAR_HEAD_P (str
[bytes
])) bytes
++;
198 if (c
== LEADING_CODE_COMPOSITION
)
200 int cmpchar_id
= str_cmpchar_id (str
, bytes
);
204 c
= MAKE_COMPOSITE_CHAR (cmpchar_id
);
205 if (exclude_tail_garbage
)
206 bytes
= cmpchar_table
[cmpchar_id
]->len
;
211 int charset
= c
, c1
, c2
= 0;
212 int char_bytes
= BYTES_BY_CHAR_HEAD (c
);
215 if (c
>= LEADING_CODE_PRIVATE_11
)
217 if (char_bytes
<= bytes
&& CHARSET_DEFINED_P (charset
))
220 if (CHARSET_DIMENSION (charset
) == 2)
222 c
= MAKE_NON_ASCII_CHAR (charset
, c1
, c2
);
223 if (exclude_tail_garbage
)
234 /* Return the length of the multi-byte form at string STR of length LEN. */
236 multibyte_form_length (str
, len
)
237 const unsigned char *str
;
242 if (BASE_LEADING_CODE_P (*str
))
243 while (bytes
< len
&& ! CHAR_HEAD_P (str
[bytes
])) bytes
++;
248 /* Check if string STR of length LEN contains valid multi-byte form of
249 a character. If valid, charset and position codes of the character
250 is set at *CHARSET, *C1, and *C2, and return 0. If not valid,
251 return -1. This should be used only in the macro SPLIT_STRING
252 which checks range of STR in advance. */
255 split_non_ascii_string (str
, len
, charset
, c1
, c2
)
256 register const unsigned char *str
;
257 register unsigned char *c1
, *c2
;
258 register int len
, *charset
;
260 register unsigned int cs
= *str
++;
262 if (cs
== LEADING_CODE_COMPOSITION
)
264 int cmpchar_id
= str_cmpchar_id (str
- 1, len
);
268 *charset
= cs
, *c1
= cmpchar_id
>> 7, *c2
= cmpchar_id
& 0x7F;
270 else if ((cs
< LEADING_CODE_PRIVATE_11
|| (cs
= *str
++) >= 0xA0)
271 && CHARSET_DEFINED_P (cs
))
276 *c1
= (*str
++) & 0x7F;
277 if (CHARSET_DIMENSION (cs
) == 2)
281 *c2
= (*str
++) & 0x7F;
289 /* Translate character C by translation table TABLE. If C
290 is negative, translate a character specified by CHARSET, C1, and C2
291 (C1 and C2 are code points of the character). If no translation is
292 found in TABLE, return C. */
294 translate_char (table
, c
, charset
, c1
, c2
)
296 int c
, charset
, c1
, c2
;
299 int alt_charset
, alt_c1
, alt_c2
, dimension
;
301 if (c
< 0) c
= MAKE_CHAR (charset
, c1
, c2
);
302 if (!CHAR_TABLE_P (table
)
303 || (ch
= Faref (table
, make_number (c
)), !INTEGERP (ch
))
307 SPLIT_CHAR (XFASTINT (ch
), alt_charset
, alt_c1
, alt_c2
);
308 dimension
= CHARSET_DIMENSION (alt_charset
);
309 if (dimension
== 1 && alt_c1
> 0 || dimension
== 2 && alt_c2
> 0)
310 /* CH is not a generic character, just return it. */
311 return XFASTINT (ch
);
313 /* Since CH is a generic character, we must return a specific
314 charater which has the same position codes as C from CH. */
316 SPLIT_CHAR (c
, charset
, c1
, c2
);
317 if (dimension
!= CHARSET_DIMENSION (charset
))
318 /* We can't make such a character because of dimension mismatch. */
320 return MAKE_CHAR (alt_charset
, c1
, c2
);
323 /* Convert the unibyte character C to multibyte based on
324 Vnonascii_translation_table or nonascii_insert_offset. If they can't
325 convert C to a valid multibyte character, convert it based on
326 DEFAULT_NONASCII_INSERT_OFFSET which makes C a Latin-1 character. */
329 unibyte_char_to_multibyte (c
)
336 if (! NILP (Vnonascii_translation_table
))
338 c
= XINT (Faref (Vnonascii_translation_table
, make_number (c
)));
339 if (c
>= 0400 && ! VALID_MULTIBYTE_CHAR_P (c
))
340 c
= c_save
+ DEFAULT_NONASCII_INSERT_OFFSET
;
342 else if (c
>= 0240 && nonascii_insert_offset
> 0)
344 c
+= nonascii_insert_offset
;
345 if (c
< 0400 || ! VALID_MULTIBYTE_CHAR_P (c
))
346 c
= c_save
+ DEFAULT_NONASCII_INSERT_OFFSET
;
349 c
= c_save
+ DEFAULT_NONASCII_INSERT_OFFSET
;
355 /* Convert the multibyte character C to unibyte 8-bit character based
356 on Vnonascii_translation_table or nonascii_insert_offset. If
357 REV_TBL is non-nil, it should be a reverse table of
358 Vnonascii_translation_table, i.e. what given by:
359 Fchar_table_extra_slot (Vnonascii_translation_table, make_number (0)) */
362 multibyte_char_to_unibyte (c
, rev_tbl
)
366 if (!SINGLE_BYTE_CHAR_P (c
))
370 if (! CHAR_TABLE_P (rev_tbl
)
371 && CHAR_TABLE_P (Vnonascii_translation_table
))
372 rev_tbl
= Fchar_table_extra_slot (Vnonascii_translation_table
,
374 if (CHAR_TABLE_P (rev_tbl
))
377 temp
= Faref (rev_tbl
, make_number (c
));
381 c
= (c_save
& 0177) + 0200;
385 if (nonascii_insert_offset
> 0)
386 c
-= nonascii_insert_offset
;
387 if (c
< 128 || c
>= 256)
388 c
= (c_save
& 0177) + 0200;
396 /* Update the table Vcharset_table with the given arguments (see the
397 document of `define-charset' for the meaning of each argument).
398 Several other table contents are also updated. The caller should
399 check the validity of CHARSET-ID and the remaining arguments in
403 update_charset_table (charset_id
, dimension
, chars
, width
, direction
,
404 iso_final_char
, iso_graphic_plane
,
405 short_name
, long_name
, description
)
406 Lisp_Object charset_id
, dimension
, chars
, width
, direction
;
407 Lisp_Object iso_final_char
, iso_graphic_plane
;
408 Lisp_Object short_name
, long_name
, description
;
410 int charset
= XINT (charset_id
);
412 unsigned char leading_code_base
, leading_code_ext
;
414 if (NILP (CHARSET_TABLE_ENTRY (charset
)))
415 CHARSET_TABLE_ENTRY (charset
)
416 = Fmake_vector (make_number (CHARSET_MAX_IDX
), Qnil
);
418 /* Get byte length of multibyte form, base leading-code, and
419 extended leading-code of the charset. See the comment under the
420 title "GENERAL NOTE on CHARACTER SET (CHARSET)" in charset.h. */
421 bytes
= XINT (dimension
);
422 if (charset
< MIN_CHARSET_PRIVATE_DIMENSION1
)
424 /* Official charset, it doesn't have an extended leading-code. */
425 if (charset
!= CHARSET_ASCII
)
426 bytes
+= 1; /* For a base leading-code. */
427 leading_code_base
= charset
;
428 leading_code_ext
= 0;
432 /* Private charset. */
433 bytes
+= 2; /* For base and extended leading-codes. */
435 = (charset
< LEADING_CODE_EXT_12
436 ? LEADING_CODE_PRIVATE_11
437 : (charset
< LEADING_CODE_EXT_21
438 ? LEADING_CODE_PRIVATE_12
439 : (charset
< LEADING_CODE_EXT_22
440 ? LEADING_CODE_PRIVATE_21
441 : LEADING_CODE_PRIVATE_22
)));
442 leading_code_ext
= charset
;
445 CHARSET_TABLE_INFO (charset
, CHARSET_ID_IDX
) = charset_id
;
446 CHARSET_TABLE_INFO (charset
, CHARSET_BYTES_IDX
) = make_number (bytes
);
447 CHARSET_TABLE_INFO (charset
, CHARSET_DIMENSION_IDX
) = dimension
;
448 CHARSET_TABLE_INFO (charset
, CHARSET_CHARS_IDX
) = chars
;
449 CHARSET_TABLE_INFO (charset
, CHARSET_WIDTH_IDX
) = width
;
450 CHARSET_TABLE_INFO (charset
, CHARSET_DIRECTION_IDX
) = direction
;
451 CHARSET_TABLE_INFO (charset
, CHARSET_LEADING_CODE_BASE_IDX
)
452 = make_number (leading_code_base
);
453 CHARSET_TABLE_INFO (charset
, CHARSET_LEADING_CODE_EXT_IDX
)
454 = make_number (leading_code_ext
);
455 CHARSET_TABLE_INFO (charset
, CHARSET_ISO_FINAL_CHAR_IDX
) = iso_final_char
;
456 CHARSET_TABLE_INFO (charset
, CHARSET_ISO_GRAPHIC_PLANE_IDX
)
458 CHARSET_TABLE_INFO (charset
, CHARSET_SHORT_NAME_IDX
) = short_name
;
459 CHARSET_TABLE_INFO (charset
, CHARSET_LONG_NAME_IDX
) = long_name
;
460 CHARSET_TABLE_INFO (charset
, CHARSET_DESCRIPTION_IDX
) = description
;
461 CHARSET_TABLE_INFO (charset
, CHARSET_PLIST_IDX
) = Qnil
;
464 /* If we have already defined a charset which has the same
465 DIMENSION, CHARS and ISO-FINAL-CHAR but the different
466 DIRECTION, we must update the entry REVERSE-CHARSET of both
467 charsets. If there's no such charset, the value of the entry
471 for (i
= 0; i
<= MAX_CHARSET
; i
++)
472 if (!NILP (CHARSET_TABLE_ENTRY (i
)))
474 if (CHARSET_DIMENSION (i
) == XINT (dimension
)
475 && CHARSET_CHARS (i
) == XINT (chars
)
476 && CHARSET_ISO_FINAL_CHAR (i
) == XINT (iso_final_char
)
477 && CHARSET_DIRECTION (i
) != XINT (direction
))
479 CHARSET_TABLE_INFO (charset
, CHARSET_REVERSE_CHARSET_IDX
)
481 CHARSET_TABLE_INFO (i
, CHARSET_REVERSE_CHARSET_IDX
) = charset_id
;
486 /* No such a charset. */
487 CHARSET_TABLE_INFO (charset
, CHARSET_REVERSE_CHARSET_IDX
)
491 if (charset
!= CHARSET_ASCII
492 && charset
< MIN_CHARSET_PRIVATE_DIMENSION1
)
494 /* Update tables bytes_by_char_head and width_by_char_head. */
495 bytes_by_char_head
[leading_code_base
] = bytes
;
496 width_by_char_head
[leading_code_base
] = XINT (width
);
498 /* Update table emacs_code_class. */
499 emacs_code_class
[charset
] = (bytes
== 2
500 ? EMACS_leading_code_2
502 ? EMACS_leading_code_3
503 : EMACS_leading_code_4
));
506 /* Update table iso_charset_table. */
507 if (ISO_CHARSET_TABLE (dimension
, chars
, iso_final_char
) < 0)
508 ISO_CHARSET_TABLE (dimension
, chars
, iso_final_char
) = charset
;
513 /* Return charset id of CHARSET_SYMBOL, or return -1 if CHARSET_SYMBOL
516 get_charset_id (charset_symbol
)
517 Lisp_Object charset_symbol
;
522 return ((SYMBOLP (charset_symbol
)
523 && (val
= Fget (charset_symbol
, Qcharset
), VECTORP (val
))
524 && (charset
= XINT (XVECTOR (val
)->contents
[CHARSET_ID_IDX
]),
525 CHARSET_VALID_P (charset
)))
529 /* Return an identification number for a new private charset of
530 DIMENSION and WIDTH. If there's no more room for the new charset,
533 get_new_private_charset_id (dimension
, width
)
534 int dimension
, width
;
536 int charset
, from
, to
;
541 from
= LEADING_CODE_EXT_11
, to
= LEADING_CODE_EXT_12
;
543 from
= LEADING_CODE_EXT_12
, to
= LEADING_CODE_EXT_21
;
548 from
= LEADING_CODE_EXT_21
, to
= LEADING_CODE_EXT_22
;
550 from
= LEADING_CODE_EXT_22
, to
= LEADING_CODE_EXT_MAX
+ 1;
553 for (charset
= from
; charset
< to
; charset
++)
554 if (!CHARSET_DEFINED_P (charset
)) break;
556 return make_number (charset
< to
? charset
: 0);
559 DEFUN ("define-charset", Fdefine_charset
, Sdefine_charset
, 3, 3, 0,
560 "Define CHARSET-ID as the identification number of CHARSET with INFO-VECTOR.\n\
561 If CHARSET-ID is nil, it is decided automatically, which means CHARSET is\n\
562 treated as a private charset.\n\
563 INFO-VECTOR is a vector of the format:\n\
564 [DIMENSION CHARS WIDTH DIRECTION ISO-FINAL-CHAR ISO-GRAPHIC-PLANE\n\
565 SHORT-NAME LONG-NAME DESCRIPTION]\n\
566 The meanings of each elements is as follows:\n\
567 DIMENSION (integer) is the number of bytes to represent a character: 1 or 2.\n\
568 CHARS (integer) is the number of characters in a dimension: 94 or 96.\n\
569 WIDTH (integer) is the number of columns a character in the charset\n\
570 occupies on the screen: one of 0, 1, and 2.\n\
572 DIRECTION (integer) is the rendering direction of characters in the\n\
573 charset when rendering. If 0, render from left to right, else\n\
574 render from right to left.\n\
576 ISO-FINAL-CHAR (character) is the final character of the\n\
577 corresponding ISO 2022 charset.\n\
579 ISO-GRAPHIC-PLANE (integer) is the graphic plane to be invoked\n\
580 while encoding to variants of ISO 2022 coding system, one of the\n\
581 following: 0/graphic-plane-left(GL), 1/graphic-plane-right(GR).\n\
583 SHORT-NAME (string) is the short name to refer to the charset.\n\
585 LONG-NAME (string) is the long name to refer to the charset.\n\
587 DESCRIPTION (string) is the description string of the charset.")
588 (charset_id
, charset_symbol
, info_vector
)
589 Lisp_Object charset_id
, charset_symbol
, info_vector
;
593 if (!NILP (charset_id
))
594 CHECK_NUMBER (charset_id
, 0);
595 CHECK_SYMBOL (charset_symbol
, 1);
596 CHECK_VECTOR (info_vector
, 2);
598 if (! NILP (charset_id
))
600 if (! CHARSET_VALID_P (XINT (charset_id
)))
601 error ("Invalid CHARSET: %d", XINT (charset_id
));
602 else if (CHARSET_DEFINED_P (XINT (charset_id
)))
603 error ("Already defined charset: %d", XINT (charset_id
));
606 vec
= XVECTOR (info_vector
)->contents
;
607 if (XVECTOR (info_vector
)->size
!= 9
608 || !INTEGERP (vec
[0]) || !(XINT (vec
[0]) == 1 || XINT (vec
[0]) == 2)
609 || !INTEGERP (vec
[1]) || !(XINT (vec
[1]) == 94 || XINT (vec
[1]) == 96)
610 || !INTEGERP (vec
[2]) || !(XINT (vec
[2]) == 1 || XINT (vec
[2]) == 2)
611 || !INTEGERP (vec
[3]) || !(XINT (vec
[3]) == 0 || XINT (vec
[3]) == 1)
612 || !INTEGERP (vec
[4]) || !(XINT (vec
[4]) >= '0' && XINT (vec
[4]) <= '~')
613 || !INTEGERP (vec
[5]) || !(XINT (vec
[5]) == 0 || XINT (vec
[5]) == 1)
616 || !STRINGP (vec
[8]))
617 error ("Invalid info-vector argument for defining charset %s",
618 XSYMBOL (charset_symbol
)->name
->data
);
620 if (NILP (charset_id
))
622 charset_id
= get_new_private_charset_id (XINT (vec
[0]), XINT (vec
[2]));
623 if (XINT (charset_id
) == 0)
624 error ("There's no room for a new private charset %s",
625 XSYMBOL (charset_symbol
)->name
->data
);
628 update_charset_table (charset_id
, vec
[0], vec
[1], vec
[2], vec
[3],
629 vec
[4], vec
[5], vec
[6], vec
[7], vec
[8]);
630 Fput (charset_symbol
, Qcharset
, CHARSET_TABLE_ENTRY (XINT (charset_id
)));
631 CHARSET_SYMBOL (XINT (charset_id
)) = charset_symbol
;
632 Vcharset_list
= Fcons (charset_symbol
, Vcharset_list
);
636 DEFUN ("generic-character-list", Fgeneric_character_list
,
637 Sgeneric_character_list
, 0, 0, 0,
638 "Return a list of all possible generic characters.\n\
639 It includes a generic character for a charset not yet defined.")
642 return Vgeneric_character_list
;
645 DEFUN ("get-unused-iso-final-char", Fget_unused_iso_final_char
,
646 Sget_unused_iso_final_char
, 2, 2, 0,
647 "Return an unsed ISO's final char for a charset of DIMENISION and CHARS.\n\
648 DIMENSION is the number of bytes to represent a character: 1 or 2.\n\
649 CHARS is the number of characters in a dimension: 94 or 96.\n\
651 This final char is for private use, thus the range is `0' (48) .. `?' (63).\n\
652 If there's no unused final char for the specified kind of charset,\n\
655 Lisp_Object dimension
, chars
;
659 CHECK_NUMBER (dimension
, 0);
660 CHECK_NUMBER (chars
, 1);
661 if (XINT (dimension
) != 1 && XINT (dimension
) != 2)
662 error ("Invalid charset dimension %d, it should be 1 or 2",
664 if (XINT (chars
) != 94 && XINT (chars
) != 96)
665 error ("Invalid charset chars %d, it should be 94 or 96",
667 for (final_char
= '0'; final_char
<= '?'; final_char
++)
669 if (ISO_CHARSET_TABLE (dimension
, chars
, make_number (final_char
)) < 0)
672 return (final_char
<= '?' ? make_number (final_char
) : Qnil
);
675 DEFUN ("declare-equiv-charset", Fdeclare_equiv_charset
, Sdeclare_equiv_charset
,
677 "Declare a charset of DIMENSION, CHARS, FINAL-CHAR is the same as CHARSET.\n\
678 CHARSET should be defined by `defined-charset' in advance.")
679 (dimension
, chars
, final_char
, charset_symbol
)
680 Lisp_Object dimension
, chars
, final_char
, charset_symbol
;
684 CHECK_NUMBER (dimension
, 0);
685 CHECK_NUMBER (chars
, 1);
686 CHECK_NUMBER (final_char
, 2);
687 CHECK_SYMBOL (charset_symbol
, 3);
689 if (XINT (dimension
) != 1 && XINT (dimension
) != 2)
690 error ("Invalid DIMENSION %d, it should be 1 or 2", XINT (dimension
));
691 if (XINT (chars
) != 94 && XINT (chars
) != 96)
692 error ("Invalid CHARS %d, it should be 94 or 96", XINT (chars
));
693 if (XINT (final_char
) < '0' || XFASTINT (final_char
) > '~')
694 error ("Invalid FINAL-CHAR %c, it should be `0'..`~'", XINT (chars
));
695 if ((charset
= get_charset_id (charset_symbol
)) < 0)
696 error ("Invalid charset %s", XSYMBOL (charset_symbol
)->name
->data
);
698 ISO_CHARSET_TABLE (dimension
, chars
, final_char
) = charset
;
702 /* Return number of different charsets in STR of length LEN. In
703 addition, for each found charset N, CHARSETS[N] is set 1. The
704 caller should allocate CHARSETS (MAX_CHARSET + 1 elements) in advance.
705 It may lookup a translation table TABLE if supplied.
707 If CMPCHARP is nonzero and some composite character is found,
708 CHARSETS[128] is also set 1 and the returned number is incremented
712 find_charset_in_str (str
, len
, charsets
, table
, cmpcharp
)
718 register int num
= 0, c
;
720 if (! CHAR_TABLE_P (table
))
728 if (c
== LEADING_CODE_COMPOSITION
)
730 int cmpchar_id
= str_cmpchar_id (str
, len
);
735 struct cmpchar_info
*cmpcharp
= cmpchar_table
[cmpchar_id
];
738 for (i
= 0; i
< cmpcharp
->glyph_len
; i
++)
740 c
= cmpcharp
->glyph
[i
];
743 if ((c
= translate_char (table
, c
, 0, 0, 0)) < 0)
744 c
= cmpcharp
->glyph
[i
];
746 if ((charset
= CHAR_CHARSET (c
)) < 0)
747 charset
= CHARSET_ASCII
;
748 if (!charsets
[charset
])
750 charsets
[charset
] = 1;
754 str
+= cmpcharp
->len
;
755 len
-= cmpcharp
->len
;
759 charset
= CHARSET_ASCII
;
764 c
= STRING_CHAR_AND_LENGTH (str
, len
, bytes
);
767 int c1
= translate_char (table
, c
, 0, 0, 0);
771 charset
= CHAR_CHARSET (c
);
774 if (!charsets
[charset
])
776 charsets
[charset
] = 1;
785 DEFUN ("find-charset-region", Ffind_charset_region
, Sfind_charset_region
,
787 "Return a list of charsets in the region between BEG and END.\n\
788 BEG and END are buffer positions.\n\
789 Optional arg TABLE if non-nil is a translation table to look up.")
791 Lisp_Object beg
, end
, table
;
793 int charsets
[MAX_CHARSET
+ 1];
794 int from
, from_byte
, to
, stop
, stop_byte
, i
;
797 validate_region (&beg
, &end
);
798 from
= XFASTINT (beg
);
799 stop
= to
= XFASTINT (end
);
801 if (from
< GPT
&& GPT
< to
)
804 stop_byte
= GPT_BYTE
;
807 stop_byte
= CHAR_TO_BYTE (stop
);
809 from_byte
= CHAR_TO_BYTE (from
);
811 bzero (charsets
, (MAX_CHARSET
+ 1) * sizeof (int));
814 find_charset_in_str (BYTE_POS_ADDR (from_byte
), stop_byte
- from_byte
,
818 from
= stop
, from_byte
= stop_byte
;
819 stop
= to
, stop_byte
= CHAR_TO_BYTE (stop
);
826 for (i
= MAX_CHARSET
; i
>= 0; i
--)
828 val
= Fcons (CHARSET_SYMBOL (i
), val
);
832 DEFUN ("find-charset-string", Ffind_charset_string
, Sfind_charset_string
,
834 "Return a list of charsets in STR.\n\
835 Optional arg TABLE if non-nil is a translation table to look up.")
837 Lisp_Object str
, table
;
839 int charsets
[MAX_CHARSET
+ 1];
843 CHECK_STRING (str
, 0);
845 if (! STRING_MULTIBYTE (str
))
848 bzero (charsets
, (MAX_CHARSET
+ 1) * sizeof (int));
849 find_charset_in_str (XSTRING (str
)->data
, STRING_BYTES (XSTRING (str
)),
852 for (i
= MAX_CHARSET
; i
>= 0; i
--)
854 val
= Fcons (CHARSET_SYMBOL (i
), val
);
858 DEFUN ("make-char-internal", Fmake_char_internal
, Smake_char_internal
, 1, 3, 0,
860 (charset
, code1
, code2
)
861 Lisp_Object charset
, code1
, code2
;
863 CHECK_NUMBER (charset
, 0);
866 XSETFASTINT (code1
, 0);
868 CHECK_NUMBER (code1
, 1);
870 XSETFASTINT (code2
, 0);
872 CHECK_NUMBER (code2
, 2);
874 if (!CHARSET_DEFINED_P (XINT (charset
)))
875 error ("Invalid charset: %d", XINT (charset
));
877 return make_number (MAKE_CHAR (XINT (charset
), XINT (code1
), XINT (code2
)));
880 DEFUN ("split-char", Fsplit_char
, Ssplit_char
, 1, 1, 0,
881 "Return list of charset and one or two position-codes of CHAR.")
888 CHECK_NUMBER (ch
, 0);
889 SPLIT_CHAR (XFASTINT (ch
), charset
, c1
, c2
);
891 ? Fcons (CHARSET_SYMBOL (charset
),
892 Fcons (make_number (c1
), Fcons (make_number (c2
), Qnil
)))
893 : Fcons (CHARSET_SYMBOL (charset
), Fcons (make_number (c1
), Qnil
)));
896 DEFUN ("char-charset", Fchar_charset
, Schar_charset
, 1, 1, 0,
897 "Return charset of CHAR.")
901 CHECK_NUMBER (ch
, 0);
903 return CHARSET_SYMBOL (CHAR_CHARSET (XINT (ch
)));
906 DEFUN ("charset-after", Fcharset_after
, Scharset_after
, 0, 1, 0,
907 "Return charset of a character in current buffer at position POS.\n\
908 If POS is nil, it defauls to the current point.")
912 register int pos_byte
, c
, charset
;
913 register unsigned char *p
;
917 else if (MARKERP (pos
))
918 pos_byte
= marker_byte_position (pos
);
921 CHECK_NUMBER (pos
, 0);
922 pos_byte
= CHAR_TO_BYTE (XINT (pos
));
924 p
= BYTE_POS_ADDR (pos_byte
);
925 c
= STRING_CHAR (p
, Z_BYTE
- pos_byte
);
926 charset
= CHAR_CHARSET (c
);
927 return CHARSET_SYMBOL (charset
);
930 DEFUN ("iso-charset", Fiso_charset
, Siso_charset
, 3, 3, 0,
931 "Return charset of ISO's specification DIMENSION, CHARS, and FINAL-CHAR.\n\
933 ISO 2022's designation sequence (escape sequence) distinguishes charsets\n\
934 by their DIMENSION, CHARS, and FINAL-CHAR,\n\
935 where as Emacs distinguishes them by charset symbol.\n\
936 See the documentation of the function `charset-info' for the meanings of\n\
937 DIMENSION, CHARS, and FINAL-CHAR.")
938 (dimension
, chars
, final_char
)
939 Lisp_Object dimension
, chars
, final_char
;
943 CHECK_NUMBER (dimension
, 0);
944 CHECK_NUMBER (chars
, 1);
945 CHECK_NUMBER (final_char
, 2);
947 if ((charset
= ISO_CHARSET_TABLE (dimension
, chars
, final_char
)) < 0)
949 return CHARSET_SYMBOL (charset
);
952 /* If GENERICP is nonzero, return nonzero iff C is a valid normal or
953 generic character. If GENERICP is zero, return nonzero iff C is a
954 valid normal character. Do not call this function directly,
955 instead use macro CHAR_VALID_P. */
957 char_valid_p (c
, genericp
)
964 if (SINGLE_BYTE_CHAR_P (c
))
966 SPLIT_NON_ASCII_CHAR (c
, charset
, c1
, c2
);
967 if (!CHARSET_VALID_P (charset
))
969 return (c
< MIN_CHAR_COMPOSITION
970 ? ((c
& CHAR_FIELD1_MASK
) /* i.e. dimension of C is two. */
971 ? (genericp
&& c1
== 0 && c2
== 0
972 || c1
>= 32 && c2
>= 32)
973 : (genericp
&& c1
== 0
975 : c
< MIN_CHAR_COMPOSITION
+ n_cmpchars
);
978 DEFUN ("char-valid-p", Fchar_valid_p
, Schar_valid_p
, 1, 2, 0,
979 "Return t if OBJECT is a valid normal character.\n\
980 If optional arg GENERICP is non-nil, also return t if OBJECT is\n\
981 a valid generic character.")
983 Lisp_Object object
, genericp
;
985 if (! NATNUMP (object
))
987 return (CHAR_VALID_P (XFASTINT (object
), !NILP (genericp
)) ? Qt
: Qnil
);
990 DEFUN ("unibyte-char-to-multibyte", Funibyte_char_to_multibyte
,
991 Sunibyte_char_to_multibyte
, 1, 1, 0,
992 "Convert the unibyte character CH to multibyte character.\n\
993 The conversion is done based on `nonascii-translation-table' (which see)\n\
994 or `nonascii-insert-offset' (which see).")
1000 CHECK_NUMBER (ch
, 0);
1002 if (c
< 0 || c
>= 0400)
1003 error ("Invalid unibyte character: %d", c
);
1004 c
= unibyte_char_to_multibyte (c
);
1006 error ("Can't convert to multibyte character: %d", XINT (ch
));
1007 return make_number (c
);
1010 DEFUN ("multibyte-char-to-unibyte", Fmultibyte_char_to_unibyte
,
1011 Smultibyte_char_to_unibyte
, 1, 1, 0,
1012 "Convert the multibyte character CH to unibyte character.\n\
1013 The conversion is done based on `nonascii-translation-table' (which see)\n\
1014 or `nonascii-insert-offset' (which see).")
1020 CHECK_NUMBER (ch
, 0);
1023 error ("Invalid multibyte character: %d", c
);
1024 c
= multibyte_char_to_unibyte (c
, Qnil
);
1026 error ("Can't convert to unibyte character: %d", XINT (ch
));
1027 return make_number (c
);
1030 DEFUN ("char-bytes", Fchar_bytes
, Schar_bytes
, 1, 1, 0,
1031 "Return 1 regardless of the argument CHAR.\n\
1032 This is now an obsolte function. We keep is just for backward compatibility.")
1038 CHECK_NUMBER (ch
, 0);
1039 return make_number (1);
1042 /* Return how many bytes C will occupy in a multibyte buffer.
1043 Don't call this function directly, instead use macro CHAR_BYTES. */
1050 if (COMPOSITE_CHAR_P (c
))
1052 unsigned int id
= COMPOSITE_CHAR_ID (c
);
1054 bytes
= (id
< n_cmpchars
? cmpchar_table
[id
]->len
: 1);
1058 int charset
= CHAR_CHARSET (c
);
1060 bytes
= CHARSET_DEFINED_P (charset
) ? CHARSET_BYTES (charset
) : 1;
1063 return make_number (bytes
);
1066 /* Return the width of character of which multi-byte form starts with
1067 C. The width is measured by how many columns occupied on the
1068 screen when displayed in the current buffer. */
1070 #define ONE_BYTE_CHAR_WIDTH(c) \
1073 ? XFASTINT (current_buffer->tab_width) \
1074 : (c == '\n' ? 0 : (NILP (current_buffer->ctl_arrow) ? 4 : 2))) \
1078 ? (NILP (current_buffer->ctl_arrow) ? 4 : 2) \
1079 : ((! NILP (current_buffer->enable_multibyte_characters) \
1080 && BASE_LEADING_CODE_P (c)) \
1081 ? WIDTH_BY_CHAR_HEAD (c) \
1084 DEFUN ("char-width", Fchar_width
, Schar_width
, 1, 1, 0,
1085 "Return width of CHAR when displayed in the current buffer.\n\
1086 The width is measured by how many columns it occupies on the screen.")
1090 Lisp_Object val
, disp
;
1092 struct Lisp_Char_Table
*dp
= buffer_display_table ();
1094 CHECK_NUMBER (ch
, 0);
1098 /* Get the way the display table would display it. */
1099 disp
= dp
? DISP_CHAR_VECTOR (dp
, c
) : Qnil
;
1102 XSETINT (val
, XVECTOR (disp
)->size
);
1103 else if (SINGLE_BYTE_CHAR_P (c
))
1104 XSETINT (val
, ONE_BYTE_CHAR_WIDTH (c
));
1105 else if (COMPOSITE_CHAR_P (c
))
1107 int id
= COMPOSITE_CHAR_ID (XFASTINT (ch
));
1108 XSETFASTINT (val
, (id
< n_cmpchars
? cmpchar_table
[id
]->width
: 0));
1112 int charset
= CHAR_CHARSET (c
);
1114 XSETFASTINT (val
, CHARSET_WIDTH (charset
));
1119 /* Return width of string STR of length LEN when displayed in the
1120 current buffer. The width is measured by how many columns it
1121 occupies on the screen. */
1128 unsigned char *endp
= str
+ len
;
1130 struct Lisp_Char_Table
*dp
= buffer_display_table ();
1134 if (*str
== LEADING_CODE_COMPOSITION
)
1136 int id
= str_cmpchar_id (str
, endp
- str
);
1145 width
+= cmpchar_table
[id
]->width
;
1146 str
+= cmpchar_table
[id
]->len
;
1153 int c
= STRING_CHAR_AND_LENGTH (str
, endp
- str
, thislen
);
1155 /* Get the way the display table would display it. */
1157 disp
= DISP_CHAR_VECTOR (dp
, c
);
1162 width
+= XVECTOR (disp
)->size
;
1164 width
+= ONE_BYTE_CHAR_WIDTH (*str
);
1172 DEFUN ("string-width", Fstring_width
, Sstring_width
, 1, 1, 0,
1173 "Return width of STRING when displayed in the current buffer.\n\
1174 Width is measured by how many columns it occupies on the screen.\n\
1175 When calculating width of a multibyte character in STRING,\n\
1176 only the base leading-code is considered; the validity of\n\
1177 the following bytes is not checked.")
1183 CHECK_STRING (str
, 0);
1184 XSETFASTINT (val
, strwidth (XSTRING (str
)->data
,
1185 STRING_BYTES (XSTRING (str
))));
1189 DEFUN ("char-direction", Fchar_direction
, Schar_direction
, 1, 1, 0,
1190 "Return the direction of CHAR.\n\
1191 The returned value is 0 for left-to-right and 1 for right-to-left.")
1197 CHECK_NUMBER (ch
, 0);
1198 charset
= CHAR_CHARSET (XFASTINT (ch
));
1199 if (!CHARSET_DEFINED_P (charset
))
1200 invalid_character (XINT (ch
));
1201 return CHARSET_TABLE_INFO (charset
, CHARSET_DIRECTION_IDX
);
1204 DEFUN ("chars-in-region", Fchars_in_region
, Schars_in_region
, 2, 2, 0,
1205 "Return number of characters between BEG and END.")
1207 Lisp_Object beg
, end
;
1211 CHECK_NUMBER_COERCE_MARKER (beg
, 0);
1212 CHECK_NUMBER_COERCE_MARKER (end
, 1);
1214 from
= min (XFASTINT (beg
), XFASTINT (end
));
1215 to
= max (XFASTINT (beg
), XFASTINT (end
));
1217 return make_number (to
- from
);
1220 /* Return the number of characters in the NBYTES bytes at PTR.
1221 This works by looking at the contents and checking for multibyte sequences.
1222 However, if the current buffer has enable-multibyte-characters = nil,
1223 we treat each byte as a character. */
1226 chars_in_text (ptr
, nbytes
)
1230 unsigned char *endp
, c
;
1233 /* current_buffer is null at early stages of Emacs initialization. */
1234 if (current_buffer
== 0
1235 || NILP (current_buffer
->enable_multibyte_characters
))
1238 endp
= ptr
+ nbytes
;
1245 if (BASE_LEADING_CODE_P (c
))
1246 while (ptr
< endp
&& ! CHAR_HEAD_P (*ptr
)) ptr
++;
1253 /* Return the number of characters in the NBYTES bytes at PTR.
1254 This works by looking at the contents and checking for multibyte sequences.
1255 It ignores enable-multibyte-characters. */
1258 multibyte_chars_in_text (ptr
, nbytes
)
1262 unsigned char *endp
, c
;
1265 endp
= ptr
+ nbytes
;
1272 if (BASE_LEADING_CODE_P (c
))
1273 while (ptr
< endp
&& ! CHAR_HEAD_P (*ptr
)) ptr
++;
1280 DEFUN ("string", Fstring
, Sstring
, 1, MANY
, 0,
1281 "Concatenate all the argument characters and make the result a string.")
1288 = (unsigned char *) alloca (MAX_LENGTH_OF_MULTI_BYTE_FORM
* n
);
1289 unsigned char *p
= buf
;
1292 for (i
= 0; i
< n
; i
++)
1297 if (!INTEGERP (args
[i
]))
1298 CHECK_NUMBER (args
[i
], 0);
1300 len
= CHAR_STRING (c
, p
, str
);
1302 /* C is a composite character. */
1303 bcopy (str
, p
, len
);
1307 val
= make_string_from_bytes (buf
, n
, p
- buf
);
1313 /*** Composite characters staffs ***/
1315 /* Each composite character is identified by CMPCHAR-ID which is
1316 assigned when Emacs needs the character code of the composite
1317 character (e.g. when displaying it on the screen). See the
1318 document "GENERAL NOTE on COMPOSITE CHARACTER" in `charset.h' how a
1319 composite character is represented in Emacs. */
1321 /* If `static' is defined, it means that it is defined to null string. */
1323 /* The following function is copied from lread.c. */
1325 hash_string (ptr
, len
)
1329 register unsigned char *p
= ptr
;
1330 register unsigned char *end
= p
+ len
;
1331 register unsigned char c
;
1332 register int hash
= 0;
1337 if (c
>= 0140) c
-= 40;
1338 hash
= ((hash
<<3) + (hash
>>28) + c
);
1340 return hash
& 07777777777;
1344 #define CMPCHAR_HASH_TABLE_SIZE 0xFFF
1346 static int *cmpchar_hash_table
[CMPCHAR_HASH_TABLE_SIZE
];
1348 /* Each element of `cmpchar_hash_table' is a pointer to an array of
1349 integer, where the 1st element is the size of the array, the 2nd
1350 element is how many elements are actually used in the array, and
1351 the remaining elements are CMPCHAR-IDs of composite characters of
1352 the same hash value. */
1353 #define CMPCHAR_HASH_SIZE(table) table[0]
1354 #define CMPCHAR_HASH_USED(table) table[1]
1355 #define CMPCHAR_HASH_CMPCHAR_ID(table, i) table[i]
1357 /* Return CMPCHAR-ID of the composite character in STR of the length
1358 LEN. If the composite character has not yet been registered,
1359 register it in `cmpchar_table' and assign new CMPCHAR-ID. This
1360 is the sole function for assigning CMPCHAR-ID. */
1362 str_cmpchar_id (str
, len
)
1363 const unsigned char *str
;
1366 int hash_idx
, *hashp
;
1368 int embedded_rule
; /* 1 if composition rule is embedded. */
1369 int chars
; /* number of components. */
1371 struct cmpchar_info
*cmpcharp
;
1373 /* The second byte 0xFF means compostion rule is embedded. */
1374 embedded_rule
= (str
[1] == 0xFF);
1376 /* At first, get the actual length of the composite character. */
1378 const unsigned char *p
, *endp
= str
+ 1, *lastp
= str
+ len
;
1381 while (endp
< lastp
&& ! CHAR_HEAD_P (*endp
)) endp
++;
1383 /* Any composite char have at least 5-byte length. */
1390 if (embedded_rule
) p
++;
1391 /* No need of checking if *P is 0xA0 because
1392 BYTES_BY_CHAR_HEAD (0x80) surely returns 2. */
1393 p
+= BYTES_BY_CHAR_HEAD (*p
- 0x20);
1396 if (p
> endp
|| chars
< 2 || chars
> MAX_COMPONENT_COUNT
)
1397 /* Invalid components. */
1401 hash_idx
= hash_string (str
, len
) % CMPCHAR_HASH_TABLE_SIZE
;
1402 hashp
= cmpchar_hash_table
[hash_idx
];
1404 /* Then, look into the hash table. */
1406 /* Find the correct one among composite characters of the same
1408 for (i
= 2; i
< CMPCHAR_HASH_USED (hashp
); i
++)
1410 cmpcharp
= cmpchar_table
[CMPCHAR_HASH_CMPCHAR_ID (hashp
, i
)];
1411 if (len
== cmpcharp
->len
1412 && ! bcmp (str
, cmpcharp
->data
, len
))
1413 return CMPCHAR_HASH_CMPCHAR_ID (hashp
, i
);
1416 /* We have to register the composite character in cmpchar_table. */
1417 if (n_cmpchars
> (CHAR_FIELD2_MASK
| CHAR_FIELD3_MASK
))
1418 /* No, we have no more room for a new composite character. */
1421 /* Make the entry in hash table. */
1424 /* Make a table for 8 composite characters initially. */
1425 hashp
= (cmpchar_hash_table
[hash_idx
]
1426 = (int *) xmalloc (sizeof (int) * (2 + 8)));
1427 CMPCHAR_HASH_SIZE (hashp
) = 10;
1428 CMPCHAR_HASH_USED (hashp
) = 2;
1430 else if (CMPCHAR_HASH_USED (hashp
) >= CMPCHAR_HASH_SIZE (hashp
))
1432 CMPCHAR_HASH_SIZE (hashp
) += 8;
1433 hashp
= (cmpchar_hash_table
[hash_idx
]
1434 = (int *) xrealloc (hashp
,
1435 sizeof (int) * CMPCHAR_HASH_SIZE (hashp
)));
1437 CMPCHAR_HASH_CMPCHAR_ID (hashp
, CMPCHAR_HASH_USED (hashp
)) = n_cmpchars
;
1438 CMPCHAR_HASH_USED (hashp
)++;
1440 /* Set information of the composite character in cmpchar_table. */
1441 if (cmpchar_table_size
== 0)
1443 /* This is the first composite character to be registered. */
1444 cmpchar_table_size
= 256;
1446 = (struct cmpchar_info
**) xmalloc (sizeof (cmpchar_table
[0])
1447 * cmpchar_table_size
);
1449 else if (cmpchar_table_size
<= n_cmpchars
)
1451 cmpchar_table_size
+= 256;
1453 = (struct cmpchar_info
**) xrealloc (cmpchar_table
,
1454 sizeof (cmpchar_table
[0])
1455 * cmpchar_table_size
);
1458 cmpcharp
= (struct cmpchar_info
*) xmalloc (sizeof (struct cmpchar_info
));
1460 cmpcharp
->len
= len
;
1461 cmpcharp
->data
= (unsigned char *) xmalloc (len
+ 1);
1462 bcopy (str
, cmpcharp
->data
, len
);
1463 cmpcharp
->data
[len
] = 0;
1464 cmpcharp
->glyph_len
= chars
;
1465 cmpcharp
->glyph
= (GLYPH
*) xmalloc (sizeof (GLYPH
) * chars
);
1468 cmpcharp
->cmp_rule
= (unsigned char *) xmalloc (chars
);
1469 cmpcharp
->col_offset
= (float *) xmalloc (sizeof (float) * chars
);
1473 cmpcharp
->cmp_rule
= NULL
;
1474 cmpcharp
->col_offset
= NULL
;
1477 /* Setup GLYPH data and composition rules (if any) so as not to make
1478 them every time on displaying. */
1480 unsigned char *bufp
;
1482 float leftmost
= 0.0, rightmost
= 1.0;
1485 /* At first, col_offset[N] is set to relative to col_offset[0]. */
1486 cmpcharp
->col_offset
[0] = 0;
1488 for (i
= 0, bufp
= cmpcharp
->data
+ 1; i
< chars
; i
++)
1491 cmpcharp
->cmp_rule
[i
] = *bufp
++;
1493 if (*bufp
== 0xA0) /* This is an ASCII character. */
1495 cmpcharp
->glyph
[i
] = FAST_MAKE_GLYPH ((*++bufp
& 0x7F), 0);
1499 else /* Multibyte character. */
1501 /* Make `bufp' point normal multi-byte form temporally. */
1504 = FAST_MAKE_GLYPH (string_to_non_ascii_char (bufp
, 4, 0, 0), 0);
1505 width
= WIDTH_BY_CHAR_HEAD (*bufp
);
1507 bufp
+= BYTES_BY_CHAR_HEAD (*bufp
- 0x20);
1510 if (embedded_rule
&& i
> 0)
1512 /* Reference points (global_ref and new_ref) are
1523 Now, we calculate the column offset of the new glyph
1524 from the left edge of the first glyph. This can avoid
1525 the same calculation everytime displaying this
1526 composite character. */
1528 /* Reference points of global glyph and new glyph. */
1529 int global_ref
= (cmpcharp
->cmp_rule
[i
] - 0xA0) / 9;
1530 int new_ref
= (cmpcharp
->cmp_rule
[i
] - 0xA0) % 9;
1531 /* Column offset relative to the first glyph. */
1532 float left
= (leftmost
1533 + (global_ref
% 3) * (rightmost
- leftmost
) / 2.0
1534 - (new_ref
% 3) * width
/ 2.0);
1536 cmpcharp
->col_offset
[i
] = left
;
1537 if (left
< leftmost
)
1539 if (left
+ width
> rightmost
)
1540 rightmost
= left
+ width
;
1544 if (width
> rightmost
)
1550 /* Now col_offset[N] are relative to the left edge of the
1551 first component. Make them relative to the left edge of
1553 for (i
= 0; i
< chars
; i
++)
1554 cmpcharp
->col_offset
[i
] -= leftmost
;
1555 /* Make rightmost holds width of overall glyph. */
1556 rightmost
-= leftmost
;
1559 cmpcharp
->width
= rightmost
;
1560 if (cmpcharp
->width
< rightmost
)
1561 /* To get a ceiling integer value. */
1565 cmpchar_table
[n_cmpchars
] = cmpcharp
;
1567 return n_cmpchars
++;
1570 /* Return the Nth element of the composite character C. */
1572 cmpchar_component (c
, n
)
1575 int id
= COMPOSITE_CHAR_ID (c
);
1577 if (id
>= n_cmpchars
/* C is not a valid composite character. */
1578 || n
>= cmpchar_table
[id
]->glyph_len
) /* No such component. */
1580 /* No face data is stored in glyph code. */
1581 return ((int) (cmpchar_table
[id
]->glyph
[n
]));
1584 DEFUN ("cmpcharp", Fcmpcharp
, Scmpcharp
, 1, 1, 0,
1585 "T if CHAR is a composite character.")
1589 CHECK_NUMBER (ch
, 0);
1590 return (COMPOSITE_CHAR_P (XINT (ch
)) ? Qt
: Qnil
);
1593 DEFUN ("composite-char-component", Fcmpchar_component
, Scmpchar_component
,
1595 "Return the IDXth component character of composite character CHARACTER.")
1597 Lisp_Object character
, idx
;
1601 CHECK_NUMBER (character
, 0);
1602 CHECK_NUMBER (idx
, 1);
1604 if ((c
= cmpchar_component (XINT (character
), XINT (idx
))) < 0)
1605 args_out_of_range (character
, idx
);
1607 return make_number (c
);
1610 DEFUN ("composite-char-composition-rule", Fcmpchar_cmp_rule
, Scmpchar_cmp_rule
,
1612 "Return the Nth composition rule embedded in composite character CHARACTER.\n\
1613 The returned rule is for composing the Nth component\n\
1614 on the (N-1)th component. If N is 0, the returned value is always 255.")
1616 Lisp_Object character
, n
;
1620 CHECK_NUMBER (character
, 0);
1621 CHECK_NUMBER (n
, 1);
1623 id
= COMPOSITE_CHAR_ID (XINT (character
));
1624 if (id
< 0 || id
>= n_cmpchars
)
1625 error ("Invalid composite character: %d", XINT (character
));
1627 if (i
> cmpchar_table
[id
]->glyph_len
)
1628 args_out_of_range (character
, n
);
1630 return make_number (cmpchar_table
[id
]->cmp_rule
[i
]);
1633 DEFUN ("composite-char-composition-rule-p", Fcmpchar_cmp_rule_p
,
1634 Scmpchar_cmp_rule_p
, 1, 1, 0,
1635 "Return non-nil if composite character CHARACTER contains a embedded rule.")
1637 Lisp_Object character
;
1641 CHECK_NUMBER (character
, 0);
1642 id
= COMPOSITE_CHAR_ID (XINT (character
));
1643 if (id
< 0 || id
>= n_cmpchars
)
1644 error ("Invalid composite character: %d", XINT (character
));
1646 return (cmpchar_table
[id
]->cmp_rule
? Qt
: Qnil
);
1649 DEFUN ("composite-char-component-count", Fcmpchar_cmp_count
,
1650 Scmpchar_cmp_count
, 1, 1, 0,
1651 "Return number of compoents of composite character CHARACTER.")
1653 Lisp_Object character
;
1657 CHECK_NUMBER (character
, 0);
1658 id
= COMPOSITE_CHAR_ID (XINT (character
));
1659 if (id
< 0 || id
>= n_cmpchars
)
1660 error ("Invalid composite character: %d", XINT (character
));
1662 return (make_number (cmpchar_table
[id
]->glyph_len
));
1665 DEFUN ("compose-string", Fcompose_string
, Scompose_string
,
1667 "Return one char string composed from all characters in STRING.")
1671 unsigned char buf
[MAX_LENGTH_OF_MULTI_BYTE_FORM
], *p
, *pend
, *ptemp
;
1674 CHECK_STRING (str
, 0);
1676 buf
[0] = LEADING_CODE_COMPOSITION
;
1677 p
= XSTRING (str
)->data
;
1678 pend
= p
+ STRING_BYTES (XSTRING (str
));
1682 if (*p
< 0x20 || *p
== 127) /* control code */
1683 error ("Invalid component character: %d", *p
);
1684 else if (*p
< 0x80) /* ASCII */
1686 if (i
+ 2 >= MAX_LENGTH_OF_MULTI_BYTE_FORM
)
1687 error ("Too long string to be composed: %s", XSTRING (str
)->data
);
1688 /* Prepend an ASCII charset indicator 0xA0, set MSB of the
1691 buf
[i
++] = *p
++ + 0x80;
1693 else if (*p
== LEADING_CODE_COMPOSITION
) /* composite char */
1695 /* Already composed. Eliminate the heading
1696 LEADING_CODE_COMPOSITION, keep the remaining bytes
1700 while (! CHAR_HEAD_P (*p
)) p
++;
1701 if (i
+ (p
- ptemp
) >= MAX_LENGTH_OF_MULTI_BYTE_FORM
)
1702 error ("Too long string to be composed: %s", XSTRING (str
)->data
);
1703 bcopy (ptemp
, buf
+ i
, p
- ptemp
);
1706 else /* multibyte char */
1708 /* Add 0x20 to the base leading-code, keep the remaining
1710 len
= BYTES_BY_CHAR_HEAD (*p
);
1711 if (i
+ len
>= MAX_LENGTH_OF_MULTI_BYTE_FORM
)
1712 error ("Too long string to be composed: %s", XSTRING (str
)->data
);
1713 bcopy (p
, buf
+ i
, len
);
1720 /* STR contains only one character, which can't be composed. */
1721 error ("Too short string to be composed: %s", XSTRING (str
)->data
);
1723 return make_string_from_bytes (buf
, 1, i
);
1728 charset_id_internal (charset_name
)
1733 val
= Fget (intern (charset_name
), Qcharset
);
1735 error ("Charset %s is not defined", charset_name
);
1737 return (XINT (XVECTOR (val
)->contents
[0]));
1740 DEFUN ("setup-special-charsets", Fsetup_special_charsets
,
1741 Ssetup_special_charsets
, 0, 0, 0, "Internal use only.")
1744 charset_latin_iso8859_1
= charset_id_internal ("latin-iso8859-1");
1745 charset_jisx0208_1978
= charset_id_internal ("japanese-jisx0208-1978");
1746 charset_jisx0208
= charset_id_internal ("japanese-jisx0208");
1747 charset_katakana_jisx0201
= charset_id_internal ("katakana-jisx0201");
1748 charset_latin_jisx0201
= charset_id_internal ("latin-jisx0201");
1749 charset_big5_1
= charset_id_internal ("chinese-big5-1");
1750 charset_big5_2
= charset_id_internal ("chinese-big5-2");
1755 init_charset_once ()
1759 staticpro (&Vcharset_table
);
1760 staticpro (&Vcharset_symbol_table
);
1761 staticpro (&Vgeneric_character_list
);
1763 /* This has to be done here, before we call Fmake_char_table. */
1764 Qcharset_table
= intern ("charset-table");
1765 staticpro (&Qcharset_table
);
1767 /* Intern this now in case it isn't already done.
1768 Setting this variable twice is harmless.
1769 But don't staticpro it here--that is done in alloc.c. */
1770 Qchar_table_extra_slots
= intern ("char-table-extra-slots");
1772 /* Now we are ready to set up this property, so we can
1773 create the charset table. */
1774 Fput (Qcharset_table
, Qchar_table_extra_slots
, make_number (0));
1775 Vcharset_table
= Fmake_char_table (Qcharset_table
, Qnil
);
1777 Vcharset_symbol_table
= Fmake_vector (make_number (MAX_CHARSET
+ 1), Qnil
);
1780 for (i
= 0; i
< 2; i
++)
1781 for (j
= 0; j
< 2; j
++)
1782 for (k
= 0; k
< 128; k
++)
1783 iso_charset_table
[i
][j
][k
] = -1;
1785 bzero (cmpchar_hash_table
, sizeof cmpchar_hash_table
);
1786 cmpchar_table_size
= n_cmpchars
= 0;
1788 for (i
= 0; i
< 256; i
++)
1789 BYTES_BY_CHAR_HEAD (i
) = 1;
1790 BYTES_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_11
) = 3;
1791 BYTES_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_12
) = 3;
1792 BYTES_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_21
) = 4;
1793 BYTES_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_22
) = 4;
1794 /* The following doesn't reflect the actual bytes, but just to tell
1795 that it is a start of a multibyte character. */
1796 BYTES_BY_CHAR_HEAD (LEADING_CODE_COMPOSITION
) = 2;
1798 for (i
= 0; i
< 128; i
++)
1799 WIDTH_BY_CHAR_HEAD (i
) = 1;
1800 for (; i
< 256; i
++)
1801 WIDTH_BY_CHAR_HEAD (i
) = 4;
1802 WIDTH_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_11
) = 1;
1803 WIDTH_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_12
) = 2;
1804 WIDTH_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_21
) = 1;
1805 WIDTH_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_22
) = 2;
1811 for (i
= 0x81; i
< 0x90; i
++)
1812 val
= Fcons (make_number ((i
- 0x70) << 7), val
);
1813 for (; i
< 0x9A; i
++)
1814 val
= Fcons (make_number ((i
- 0x8F) << 14), val
);
1815 for (i
= 0xA0; i
< 0xF0; i
++)
1816 val
= Fcons (make_number ((i
- 0x70) << 7), val
);
1817 for (; i
< 0xFF; i
++)
1818 val
= Fcons (make_number ((i
- 0xE0) << 14), val
);
1819 val
= Fcons (make_number (GENERIC_COMPOSITION_CHAR
), val
);
1820 Vgeneric_character_list
= Fnreverse (val
);
1823 nonascii_insert_offset
= 0;
1824 Vnonascii_translation_table
= Qnil
;
1832 Qascii
= intern ("ascii");
1833 staticpro (&Qascii
);
1835 Qcharset
= intern ("charset");
1836 staticpro (&Qcharset
);
1838 /* Define ASCII charset now. */
1839 update_charset_table (make_number (CHARSET_ASCII
),
1840 make_number (1), make_number (94),
1845 build_string ("ASCII"),
1846 build_string ("ASCII"),
1847 build_string ("ASCII (ISO646 IRV)"));
1848 CHARSET_SYMBOL (CHARSET_ASCII
) = Qascii
;
1849 Fput (Qascii
, Qcharset
, CHARSET_TABLE_ENTRY (CHARSET_ASCII
));
1851 Qcomposition
= intern ("composition");
1852 staticpro (&Qcomposition
);
1853 CHARSET_SYMBOL (CHARSET_COMPOSITION
) = Qcomposition
;
1855 defsubr (&Sdefine_charset
);
1856 defsubr (&Sgeneric_character_list
);
1857 defsubr (&Sget_unused_iso_final_char
);
1858 defsubr (&Sdeclare_equiv_charset
);
1859 defsubr (&Sfind_charset_region
);
1860 defsubr (&Sfind_charset_string
);
1861 defsubr (&Smake_char_internal
);
1862 defsubr (&Ssplit_char
);
1863 defsubr (&Schar_charset
);
1864 defsubr (&Scharset_after
);
1865 defsubr (&Siso_charset
);
1866 defsubr (&Schar_valid_p
);
1867 defsubr (&Sunibyte_char_to_multibyte
);
1868 defsubr (&Smultibyte_char_to_unibyte
);
1869 defsubr (&Schar_bytes
);
1870 defsubr (&Schar_width
);
1871 defsubr (&Sstring_width
);
1872 defsubr (&Schar_direction
);
1873 defsubr (&Schars_in_region
);
1875 defsubr (&Scmpcharp
);
1876 defsubr (&Scmpchar_component
);
1877 defsubr (&Scmpchar_cmp_rule
);
1878 defsubr (&Scmpchar_cmp_rule_p
);
1879 defsubr (&Scmpchar_cmp_count
);
1880 defsubr (&Scompose_string
);
1881 defsubr (&Ssetup_special_charsets
);
1883 DEFVAR_LISP ("charset-list", &Vcharset_list
,
1884 "List of charsets ever defined.");
1885 Vcharset_list
= Fcons (Qascii
, Qnil
);
1887 DEFVAR_LISP ("translation-table-vector", &Vtranslation_table_vector
,
1888 "Vector of cons cell of a symbol and translation table ever defined.\n\
1889 An ID of a translation table is an index of this vector.");
1890 Vtranslation_table_vector
= Fmake_vector (make_number (16), Qnil
);
1892 DEFVAR_INT ("leading-code-composition", &leading_code_composition
,
1893 "Leading-code of composite characters.");
1894 leading_code_composition
= LEADING_CODE_COMPOSITION
;
1896 DEFVAR_INT ("leading-code-private-11", &leading_code_private_11
,
1897 "Leading-code of private TYPE9N charset of column-width 1.");
1898 leading_code_private_11
= LEADING_CODE_PRIVATE_11
;
1900 DEFVAR_INT ("leading-code-private-12", &leading_code_private_12
,
1901 "Leading-code of private TYPE9N charset of column-width 2.");
1902 leading_code_private_12
= LEADING_CODE_PRIVATE_12
;
1904 DEFVAR_INT ("leading-code-private-21", &leading_code_private_21
,
1905 "Leading-code of private TYPE9Nx9N charset of column-width 1.");
1906 leading_code_private_21
= LEADING_CODE_PRIVATE_21
;
1908 DEFVAR_INT ("leading-code-private-22", &leading_code_private_22
,
1909 "Leading-code of private TYPE9Nx9N charset of column-width 2.");
1910 leading_code_private_22
= LEADING_CODE_PRIVATE_22
;
1912 DEFVAR_INT ("nonascii-insert-offset", &nonascii_insert_offset
,
1913 "Offset for converting non-ASCII unibyte codes 0240...0377 to multibyte.\n\
1914 This is used for converting unibyte text to multibyte,\n\
1915 and for inserting character codes specified by number.\n\n\
1916 This serves to convert a Latin-1 or similar 8-bit character code\n\
1917 to the corresponding Emacs multibyte character code.\n\
1918 Typically the value should be (- (make-char CHARSET 0) 128),\n\
1919 for your choice of character set.\n\
1920 If `nonascii-translation-table' is non-nil, it overrides this variable.");
1921 nonascii_insert_offset
= 0;
1923 DEFVAR_LISP ("nonascii-translation-table", &Vnonascii_translation_table
,
1924 "Translation table to convert non-ASCII unibyte codes to multibyte.\n\
1925 This is used for converting unibyte text to multibyte,\n\
1926 and for inserting character codes specified by number.\n\n\
1927 Conversion is performed only when multibyte characters are enabled,\n\
1928 and it serves to convert a Latin-1 or similar 8-bit character code\n\
1929 to the corresponding Emacs character code.\n\n\
1930 If this is nil, `nonascii-insert-offset' is used instead.\n\
1931 See also the docstring of `make-translation-table'.");
1932 Vnonascii_translation_table
= Qnil
;
1934 DEFVAR_INT ("min-composite-char", &min_composite_char
,
1935 "Minimum character code of a composite character.");
1936 min_composite_char
= MIN_CHAR_COMPOSITION
;