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 (NILP (current_buffer
->enable_multibyte_characters
))
804 : Fcons (Qascii
, Qnil
));
806 if (from
< GPT
&& GPT
< to
)
809 stop_byte
= GPT_BYTE
;
812 stop_byte
= CHAR_TO_BYTE (stop
);
814 from_byte
= CHAR_TO_BYTE (from
);
816 bzero (charsets
, (MAX_CHARSET
+ 1) * sizeof (int));
819 find_charset_in_str (BYTE_POS_ADDR (from_byte
), stop_byte
- from_byte
,
823 from
= stop
, from_byte
= stop_byte
;
824 stop
= to
, stop_byte
= CHAR_TO_BYTE (stop
);
831 for (i
= MAX_CHARSET
; i
>= 0; i
--)
833 val
= Fcons (CHARSET_SYMBOL (i
), val
);
837 DEFUN ("find-charset-string", Ffind_charset_string
, Sfind_charset_string
,
839 "Return a list of charsets in STR.\n\
840 Optional arg TABLE if non-nil is a translation table to look up.")
842 Lisp_Object str
, table
;
844 int charsets
[MAX_CHARSET
+ 1];
848 CHECK_STRING (str
, 0);
850 if (! STRING_MULTIBYTE (str
))
851 return (XSTRING (str
)->size
== 0
853 : Fcons (Qascii
, Qnil
));
855 bzero (charsets
, (MAX_CHARSET
+ 1) * sizeof (int));
856 find_charset_in_str (XSTRING (str
)->data
, STRING_BYTES (XSTRING (str
)),
859 for (i
= MAX_CHARSET
; i
>= 0; i
--)
861 val
= Fcons (CHARSET_SYMBOL (i
), val
);
865 DEFUN ("make-char-internal", Fmake_char_internal
, Smake_char_internal
, 1, 3, 0,
867 (charset
, code1
, code2
)
868 Lisp_Object charset
, code1
, code2
;
870 CHECK_NUMBER (charset
, 0);
873 XSETFASTINT (code1
, 0);
875 CHECK_NUMBER (code1
, 1);
877 XSETFASTINT (code2
, 0);
879 CHECK_NUMBER (code2
, 2);
881 if (!CHARSET_DEFINED_P (XINT (charset
)))
882 error ("Invalid charset: %d", XINT (charset
));
884 return make_number (MAKE_CHAR (XINT (charset
), XINT (code1
), XINT (code2
)));
887 DEFUN ("split-char", Fsplit_char
, Ssplit_char
, 1, 1, 0,
888 "Return list of charset and one or two position-codes of CHAR.")
895 CHECK_NUMBER (ch
, 0);
896 SPLIT_CHAR (XFASTINT (ch
), charset
, c1
, c2
);
898 ? Fcons (CHARSET_SYMBOL (charset
),
899 Fcons (make_number (c1
), Fcons (make_number (c2
), Qnil
)))
900 : Fcons (CHARSET_SYMBOL (charset
), Fcons (make_number (c1
), Qnil
)));
903 DEFUN ("char-charset", Fchar_charset
, Schar_charset
, 1, 1, 0,
904 "Return charset of CHAR.")
908 CHECK_NUMBER (ch
, 0);
910 return CHARSET_SYMBOL (CHAR_CHARSET (XINT (ch
)));
913 DEFUN ("charset-after", Fcharset_after
, Scharset_after
, 0, 1, 0,
914 "Return charset of a character in current buffer at position POS.\n\
915 If POS is nil, it defauls to the current point.")
919 register int pos_byte
, c
, charset
;
920 register unsigned char *p
;
924 else if (MARKERP (pos
))
925 pos_byte
= marker_byte_position (pos
);
928 CHECK_NUMBER (pos
, 0);
929 pos_byte
= CHAR_TO_BYTE (XINT (pos
));
931 p
= BYTE_POS_ADDR (pos_byte
);
932 c
= STRING_CHAR (p
, Z_BYTE
- pos_byte
);
933 charset
= CHAR_CHARSET (c
);
934 return CHARSET_SYMBOL (charset
);
937 DEFUN ("iso-charset", Fiso_charset
, Siso_charset
, 3, 3, 0,
938 "Return charset of ISO's specification DIMENSION, CHARS, and FINAL-CHAR.\n\
940 ISO 2022's designation sequence (escape sequence) distinguishes charsets\n\
941 by their DIMENSION, CHARS, and FINAL-CHAR,\n\
942 where as Emacs distinguishes them by charset symbol.\n\
943 See the documentation of the function `charset-info' for the meanings of\n\
944 DIMENSION, CHARS, and FINAL-CHAR.")
945 (dimension
, chars
, final_char
)
946 Lisp_Object dimension
, chars
, final_char
;
950 CHECK_NUMBER (dimension
, 0);
951 CHECK_NUMBER (chars
, 1);
952 CHECK_NUMBER (final_char
, 2);
954 if ((charset
= ISO_CHARSET_TABLE (dimension
, chars
, final_char
)) < 0)
956 return CHARSET_SYMBOL (charset
);
959 /* If GENERICP is nonzero, return nonzero iff C is a valid normal or
960 generic character. If GENERICP is zero, return nonzero iff C is a
961 valid normal character. Do not call this function directly,
962 instead use macro CHAR_VALID_P. */
964 char_valid_p (c
, genericp
)
971 if (SINGLE_BYTE_CHAR_P (c
))
973 SPLIT_NON_ASCII_CHAR (c
, charset
, c1
, c2
);
974 if (!CHARSET_VALID_P (charset
))
976 return (c
< MIN_CHAR_COMPOSITION
977 ? ((c
& CHAR_FIELD1_MASK
) /* i.e. dimension of C is two. */
978 ? (genericp
&& c1
== 0 && c2
== 0
979 || c1
>= 32 && c2
>= 32)
980 : (genericp
&& c1
== 0
982 : c
< MIN_CHAR_COMPOSITION
+ n_cmpchars
);
985 DEFUN ("char-valid-p", Fchar_valid_p
, Schar_valid_p
, 1, 2, 0,
986 "Return t if OBJECT is a valid normal character.\n\
987 If optional arg GENERICP is non-nil, also return t if OBJECT is\n\
988 a valid generic character.")
990 Lisp_Object object
, genericp
;
992 if (! NATNUMP (object
))
994 return (CHAR_VALID_P (XFASTINT (object
), !NILP (genericp
)) ? Qt
: Qnil
);
997 DEFUN ("unibyte-char-to-multibyte", Funibyte_char_to_multibyte
,
998 Sunibyte_char_to_multibyte
, 1, 1, 0,
999 "Convert the unibyte character CH to multibyte character.\n\
1000 The conversion is done based on `nonascii-translation-table' (which see)\n\
1001 or `nonascii-insert-offset' (which see).")
1007 CHECK_NUMBER (ch
, 0);
1009 if (c
< 0 || c
>= 0400)
1010 error ("Invalid unibyte character: %d", c
);
1011 c
= unibyte_char_to_multibyte (c
);
1013 error ("Can't convert to multibyte character: %d", XINT (ch
));
1014 return make_number (c
);
1017 DEFUN ("multibyte-char-to-unibyte", Fmultibyte_char_to_unibyte
,
1018 Smultibyte_char_to_unibyte
, 1, 1, 0,
1019 "Convert the multibyte character CH to unibyte character.\n\
1020 The conversion is done based on `nonascii-translation-table' (which see)\n\
1021 or `nonascii-insert-offset' (which see).")
1027 CHECK_NUMBER (ch
, 0);
1030 error ("Invalid multibyte character: %d", c
);
1031 c
= multibyte_char_to_unibyte (c
, Qnil
);
1033 error ("Can't convert to unibyte character: %d", XINT (ch
));
1034 return make_number (c
);
1037 DEFUN ("char-bytes", Fchar_bytes
, Schar_bytes
, 1, 1, 0,
1038 "Return 1 regardless of the argument CHAR.\n\
1039 This is now an obsolte function. We keep is just for backward compatibility.")
1045 CHECK_NUMBER (ch
, 0);
1046 return make_number (1);
1049 /* Return how many bytes C will occupy in a multibyte buffer.
1050 Don't call this function directly, instead use macro CHAR_BYTES. */
1057 if (COMPOSITE_CHAR_P (c
))
1059 unsigned int id
= COMPOSITE_CHAR_ID (c
);
1061 bytes
= (id
< n_cmpchars
? cmpchar_table
[id
]->len
: 1);
1065 int charset
= CHAR_CHARSET (c
);
1067 bytes
= CHARSET_DEFINED_P (charset
) ? CHARSET_BYTES (charset
) : 1;
1070 return make_number (bytes
);
1073 /* Return the width of character of which multi-byte form starts with
1074 C. The width is measured by how many columns occupied on the
1075 screen when displayed in the current buffer. */
1077 #define ONE_BYTE_CHAR_WIDTH(c) \
1080 ? XFASTINT (current_buffer->tab_width) \
1081 : (c == '\n' ? 0 : (NILP (current_buffer->ctl_arrow) ? 4 : 2))) \
1085 ? (NILP (current_buffer->ctl_arrow) ? 4 : 2) \
1086 : ((! NILP (current_buffer->enable_multibyte_characters) \
1087 && BASE_LEADING_CODE_P (c)) \
1088 ? WIDTH_BY_CHAR_HEAD (c) \
1091 DEFUN ("char-width", Fchar_width
, Schar_width
, 1, 1, 0,
1092 "Return width of CHAR when displayed in the current buffer.\n\
1093 The width is measured by how many columns it occupies on the screen.")
1097 Lisp_Object val
, disp
;
1099 struct Lisp_Char_Table
*dp
= buffer_display_table ();
1101 CHECK_NUMBER (ch
, 0);
1105 /* Get the way the display table would display it. */
1106 disp
= dp
? DISP_CHAR_VECTOR (dp
, c
) : Qnil
;
1109 XSETINT (val
, XVECTOR (disp
)->size
);
1110 else if (SINGLE_BYTE_CHAR_P (c
))
1111 XSETINT (val
, ONE_BYTE_CHAR_WIDTH (c
));
1112 else if (COMPOSITE_CHAR_P (c
))
1114 int id
= COMPOSITE_CHAR_ID (XFASTINT (ch
));
1115 XSETFASTINT (val
, (id
< n_cmpchars
? cmpchar_table
[id
]->width
: 0));
1119 int charset
= CHAR_CHARSET (c
);
1121 XSETFASTINT (val
, CHARSET_WIDTH (charset
));
1126 /* Return width of string STR of length LEN when displayed in the
1127 current buffer. The width is measured by how many columns it
1128 occupies on the screen. */
1135 unsigned char *endp
= str
+ len
;
1137 struct Lisp_Char_Table
*dp
= buffer_display_table ();
1141 if (*str
== LEADING_CODE_COMPOSITION
)
1143 int id
= str_cmpchar_id (str
, endp
- str
);
1152 width
+= cmpchar_table
[id
]->width
;
1153 str
+= cmpchar_table
[id
]->len
;
1160 int c
= STRING_CHAR_AND_LENGTH (str
, endp
- str
, thislen
);
1162 /* Get the way the display table would display it. */
1164 disp
= DISP_CHAR_VECTOR (dp
, c
);
1169 width
+= XVECTOR (disp
)->size
;
1171 width
+= ONE_BYTE_CHAR_WIDTH (*str
);
1179 DEFUN ("string-width", Fstring_width
, Sstring_width
, 1, 1, 0,
1180 "Return width of STRING when displayed in the current buffer.\n\
1181 Width is measured by how many columns it occupies on the screen.\n\
1182 When calculating width of a multibyte character in STRING,\n\
1183 only the base leading-code is considered; the validity of\n\
1184 the following bytes is not checked.")
1190 CHECK_STRING (str
, 0);
1191 XSETFASTINT (val
, strwidth (XSTRING (str
)->data
,
1192 STRING_BYTES (XSTRING (str
))));
1196 DEFUN ("char-direction", Fchar_direction
, Schar_direction
, 1, 1, 0,
1197 "Return the direction of CHAR.\n\
1198 The returned value is 0 for left-to-right and 1 for right-to-left.")
1204 CHECK_NUMBER (ch
, 0);
1205 charset
= CHAR_CHARSET (XFASTINT (ch
));
1206 if (!CHARSET_DEFINED_P (charset
))
1207 invalid_character (XINT (ch
));
1208 return CHARSET_TABLE_INFO (charset
, CHARSET_DIRECTION_IDX
);
1211 DEFUN ("chars-in-region", Fchars_in_region
, Schars_in_region
, 2, 2, 0,
1212 "Return number of characters between BEG and END.")
1214 Lisp_Object beg
, end
;
1218 CHECK_NUMBER_COERCE_MARKER (beg
, 0);
1219 CHECK_NUMBER_COERCE_MARKER (end
, 1);
1221 from
= min (XFASTINT (beg
), XFASTINT (end
));
1222 to
= max (XFASTINT (beg
), XFASTINT (end
));
1224 return make_number (to
- from
);
1227 /* Return the number of characters in the NBYTES bytes at PTR.
1228 This works by looking at the contents and checking for multibyte sequences.
1229 However, if the current buffer has enable-multibyte-characters = nil,
1230 we treat each byte as a character. */
1233 chars_in_text (ptr
, nbytes
)
1237 unsigned char *endp
, c
;
1240 /* current_buffer is null at early stages of Emacs initialization. */
1241 if (current_buffer
== 0
1242 || NILP (current_buffer
->enable_multibyte_characters
))
1245 endp
= ptr
+ nbytes
;
1252 if (BASE_LEADING_CODE_P (c
))
1253 while (ptr
< endp
&& ! CHAR_HEAD_P (*ptr
)) ptr
++;
1260 /* Return the number of characters in the NBYTES bytes at PTR.
1261 This works by looking at the contents and checking for multibyte sequences.
1262 It ignores enable-multibyte-characters. */
1265 multibyte_chars_in_text (ptr
, nbytes
)
1269 unsigned char *endp
, c
;
1272 endp
= ptr
+ nbytes
;
1279 if (BASE_LEADING_CODE_P (c
))
1280 while (ptr
< endp
&& ! CHAR_HEAD_P (*ptr
)) ptr
++;
1287 DEFUN ("string", Fstring
, Sstring
, 1, MANY
, 0,
1288 "Concatenate all the argument characters and make the result a string.")
1295 = (unsigned char *) alloca (MAX_LENGTH_OF_MULTI_BYTE_FORM
* n
);
1296 unsigned char *p
= buf
;
1299 for (i
= 0; i
< n
; i
++)
1304 if (!INTEGERP (args
[i
]))
1305 CHECK_NUMBER (args
[i
], 0);
1307 len
= CHAR_STRING (c
, p
, str
);
1309 /* C is a composite character. */
1310 bcopy (str
, p
, len
);
1314 val
= make_string_from_bytes (buf
, n
, p
- buf
);
1320 /*** Composite characters staffs ***/
1322 /* Each composite character is identified by CMPCHAR-ID which is
1323 assigned when Emacs needs the character code of the composite
1324 character (e.g. when displaying it on the screen). See the
1325 document "GENERAL NOTE on COMPOSITE CHARACTER" in `charset.h' how a
1326 composite character is represented in Emacs. */
1328 /* If `static' is defined, it means that it is defined to null string. */
1330 /* The following function is copied from lread.c. */
1332 hash_string (ptr
, len
)
1336 register unsigned char *p
= ptr
;
1337 register unsigned char *end
= p
+ len
;
1338 register unsigned char c
;
1339 register int hash
= 0;
1344 if (c
>= 0140) c
-= 40;
1345 hash
= ((hash
<<3) + (hash
>>28) + c
);
1347 return hash
& 07777777777;
1351 #define CMPCHAR_HASH_TABLE_SIZE 0xFFF
1353 static int *cmpchar_hash_table
[CMPCHAR_HASH_TABLE_SIZE
];
1355 /* Each element of `cmpchar_hash_table' is a pointer to an array of
1356 integer, where the 1st element is the size of the array, the 2nd
1357 element is how many elements are actually used in the array, and
1358 the remaining elements are CMPCHAR-IDs of composite characters of
1359 the same hash value. */
1360 #define CMPCHAR_HASH_SIZE(table) table[0]
1361 #define CMPCHAR_HASH_USED(table) table[1]
1362 #define CMPCHAR_HASH_CMPCHAR_ID(table, i) table[i]
1364 /* Return CMPCHAR-ID of the composite character in STR of the length
1365 LEN. If the composite character has not yet been registered,
1366 register it in `cmpchar_table' and assign new CMPCHAR-ID. This
1367 is the sole function for assigning CMPCHAR-ID. */
1369 str_cmpchar_id (str
, len
)
1370 const unsigned char *str
;
1373 int hash_idx
, *hashp
;
1375 int embedded_rule
; /* 1 if composition rule is embedded. */
1376 int chars
; /* number of components. */
1378 struct cmpchar_info
*cmpcharp
;
1380 /* The second byte 0xFF means compostion rule is embedded. */
1381 embedded_rule
= (str
[1] == 0xFF);
1383 /* At first, get the actual length of the composite character. */
1385 const unsigned char *p
, *endp
= str
+ 1, *lastp
= str
+ len
;
1388 while (endp
< lastp
&& ! CHAR_HEAD_P (*endp
)) endp
++;
1390 /* Any composite char have at least 5-byte length. */
1397 if (embedded_rule
) p
++;
1398 /* No need of checking if *P is 0xA0 because
1399 BYTES_BY_CHAR_HEAD (0x80) surely returns 2. */
1400 p
+= BYTES_BY_CHAR_HEAD (*p
- 0x20);
1403 if (p
> endp
|| chars
< 2 || chars
> MAX_COMPONENT_COUNT
)
1404 /* Invalid components. */
1408 hash_idx
= hash_string (str
, len
) % CMPCHAR_HASH_TABLE_SIZE
;
1409 hashp
= cmpchar_hash_table
[hash_idx
];
1411 /* Then, look into the hash table. */
1413 /* Find the correct one among composite characters of the same
1415 for (i
= 2; i
< CMPCHAR_HASH_USED (hashp
); i
++)
1417 cmpcharp
= cmpchar_table
[CMPCHAR_HASH_CMPCHAR_ID (hashp
, i
)];
1418 if (len
== cmpcharp
->len
1419 && ! bcmp (str
, cmpcharp
->data
, len
))
1420 return CMPCHAR_HASH_CMPCHAR_ID (hashp
, i
);
1423 /* We have to register the composite character in cmpchar_table. */
1424 if (n_cmpchars
> (CHAR_FIELD2_MASK
| CHAR_FIELD3_MASK
))
1425 /* No, we have no more room for a new composite character. */
1428 /* Make the entry in hash table. */
1431 /* Make a table for 8 composite characters initially. */
1432 hashp
= (cmpchar_hash_table
[hash_idx
]
1433 = (int *) xmalloc (sizeof (int) * (2 + 8)));
1434 CMPCHAR_HASH_SIZE (hashp
) = 10;
1435 CMPCHAR_HASH_USED (hashp
) = 2;
1437 else if (CMPCHAR_HASH_USED (hashp
) >= CMPCHAR_HASH_SIZE (hashp
))
1439 CMPCHAR_HASH_SIZE (hashp
) += 8;
1440 hashp
= (cmpchar_hash_table
[hash_idx
]
1441 = (int *) xrealloc (hashp
,
1442 sizeof (int) * CMPCHAR_HASH_SIZE (hashp
)));
1444 CMPCHAR_HASH_CMPCHAR_ID (hashp
, CMPCHAR_HASH_USED (hashp
)) = n_cmpchars
;
1445 CMPCHAR_HASH_USED (hashp
)++;
1447 /* Set information of the composite character in cmpchar_table. */
1448 if (cmpchar_table_size
== 0)
1450 /* This is the first composite character to be registered. */
1451 cmpchar_table_size
= 256;
1453 = (struct cmpchar_info
**) xmalloc (sizeof (cmpchar_table
[0])
1454 * cmpchar_table_size
);
1456 else if (cmpchar_table_size
<= n_cmpchars
)
1458 cmpchar_table_size
+= 256;
1460 = (struct cmpchar_info
**) xrealloc (cmpchar_table
,
1461 sizeof (cmpchar_table
[0])
1462 * cmpchar_table_size
);
1465 cmpcharp
= (struct cmpchar_info
*) xmalloc (sizeof (struct cmpchar_info
));
1467 cmpcharp
->len
= len
;
1468 cmpcharp
->data
= (unsigned char *) xmalloc (len
+ 1);
1469 bcopy (str
, cmpcharp
->data
, len
);
1470 cmpcharp
->data
[len
] = 0;
1471 cmpcharp
->glyph_len
= chars
;
1472 cmpcharp
->glyph
= (GLYPH
*) xmalloc (sizeof (GLYPH
) * chars
);
1475 cmpcharp
->cmp_rule
= (unsigned char *) xmalloc (chars
);
1476 cmpcharp
->col_offset
= (float *) xmalloc (sizeof (float) * chars
);
1480 cmpcharp
->cmp_rule
= NULL
;
1481 cmpcharp
->col_offset
= NULL
;
1484 /* Setup GLYPH data and composition rules (if any) so as not to make
1485 them every time on displaying. */
1487 unsigned char *bufp
;
1489 float leftmost
= 0.0, rightmost
= 1.0;
1492 /* At first, col_offset[N] is set to relative to col_offset[0]. */
1493 cmpcharp
->col_offset
[0] = 0;
1495 for (i
= 0, bufp
= cmpcharp
->data
+ 1; i
< chars
; i
++)
1498 cmpcharp
->cmp_rule
[i
] = *bufp
++;
1500 if (*bufp
== 0xA0) /* This is an ASCII character. */
1502 cmpcharp
->glyph
[i
] = FAST_MAKE_GLYPH ((*++bufp
& 0x7F), 0);
1506 else /* Multibyte character. */
1508 /* Make `bufp' point normal multi-byte form temporally. */
1511 = FAST_MAKE_GLYPH (string_to_non_ascii_char (bufp
, 4, 0, 0), 0);
1512 width
= WIDTH_BY_CHAR_HEAD (*bufp
);
1514 bufp
+= BYTES_BY_CHAR_HEAD (*bufp
- 0x20);
1517 if (embedded_rule
&& i
> 0)
1519 /* Reference points (global_ref and new_ref) are
1530 Now, we calculate the column offset of the new glyph
1531 from the left edge of the first glyph. This can avoid
1532 the same calculation everytime displaying this
1533 composite character. */
1535 /* Reference points of global glyph and new glyph. */
1536 int global_ref
= (cmpcharp
->cmp_rule
[i
] - 0xA0) / 9;
1537 int new_ref
= (cmpcharp
->cmp_rule
[i
] - 0xA0) % 9;
1538 /* Column offset relative to the first glyph. */
1539 float left
= (leftmost
1540 + (global_ref
% 3) * (rightmost
- leftmost
) / 2.0
1541 - (new_ref
% 3) * width
/ 2.0);
1543 cmpcharp
->col_offset
[i
] = left
;
1544 if (left
< leftmost
)
1546 if (left
+ width
> rightmost
)
1547 rightmost
= left
+ width
;
1551 if (width
> rightmost
)
1557 /* Now col_offset[N] are relative to the left edge of the
1558 first component. Make them relative to the left edge of
1560 for (i
= 0; i
< chars
; i
++)
1561 cmpcharp
->col_offset
[i
] -= leftmost
;
1562 /* Make rightmost holds width of overall glyph. */
1563 rightmost
-= leftmost
;
1566 cmpcharp
->width
= rightmost
;
1567 if (cmpcharp
->width
< rightmost
)
1568 /* To get a ceiling integer value. */
1572 cmpchar_table
[n_cmpchars
] = cmpcharp
;
1574 return n_cmpchars
++;
1577 /* Return the Nth element of the composite character C. */
1579 cmpchar_component (c
, n
)
1582 int id
= COMPOSITE_CHAR_ID (c
);
1584 if (id
>= n_cmpchars
/* C is not a valid composite character. */
1585 || n
>= cmpchar_table
[id
]->glyph_len
) /* No such component. */
1587 /* No face data is stored in glyph code. */
1588 return ((int) (cmpchar_table
[id
]->glyph
[n
]));
1591 DEFUN ("cmpcharp", Fcmpcharp
, Scmpcharp
, 1, 1, 0,
1592 "T if CHAR is a composite character.")
1596 CHECK_NUMBER (ch
, 0);
1597 return (COMPOSITE_CHAR_P (XINT (ch
)) ? Qt
: Qnil
);
1600 DEFUN ("composite-char-component", Fcmpchar_component
, Scmpchar_component
,
1602 "Return the IDXth component character of composite character CHARACTER.")
1604 Lisp_Object character
, idx
;
1608 CHECK_NUMBER (character
, 0);
1609 CHECK_NUMBER (idx
, 1);
1611 if ((c
= cmpchar_component (XINT (character
), XINT (idx
))) < 0)
1612 args_out_of_range (character
, idx
);
1614 return make_number (c
);
1617 DEFUN ("composite-char-composition-rule", Fcmpchar_cmp_rule
, Scmpchar_cmp_rule
,
1619 "Return the Nth composition rule embedded in composite character CHARACTER.\n\
1620 The returned rule is for composing the Nth component\n\
1621 on the (N-1)th component. If N is 0, the returned value is always 255.")
1623 Lisp_Object character
, n
;
1627 CHECK_NUMBER (character
, 0);
1628 CHECK_NUMBER (n
, 1);
1630 id
= COMPOSITE_CHAR_ID (XINT (character
));
1631 if (id
< 0 || id
>= n_cmpchars
)
1632 error ("Invalid composite character: %d", XINT (character
));
1634 if (i
> cmpchar_table
[id
]->glyph_len
)
1635 args_out_of_range (character
, n
);
1637 return make_number (cmpchar_table
[id
]->cmp_rule
[i
]);
1640 DEFUN ("composite-char-composition-rule-p", Fcmpchar_cmp_rule_p
,
1641 Scmpchar_cmp_rule_p
, 1, 1, 0,
1642 "Return non-nil if composite character CHARACTER contains a embedded rule.")
1644 Lisp_Object character
;
1648 CHECK_NUMBER (character
, 0);
1649 id
= COMPOSITE_CHAR_ID (XINT (character
));
1650 if (id
< 0 || id
>= n_cmpchars
)
1651 error ("Invalid composite character: %d", XINT (character
));
1653 return (cmpchar_table
[id
]->cmp_rule
? Qt
: Qnil
);
1656 DEFUN ("composite-char-component-count", Fcmpchar_cmp_count
,
1657 Scmpchar_cmp_count
, 1, 1, 0,
1658 "Return number of compoents of composite character CHARACTER.")
1660 Lisp_Object character
;
1664 CHECK_NUMBER (character
, 0);
1665 id
= COMPOSITE_CHAR_ID (XINT (character
));
1666 if (id
< 0 || id
>= n_cmpchars
)
1667 error ("Invalid composite character: %d", XINT (character
));
1669 return (make_number (cmpchar_table
[id
]->glyph_len
));
1672 DEFUN ("compose-string", Fcompose_string
, Scompose_string
,
1674 "Return one char string composed from all characters in STRING.")
1678 unsigned char buf
[MAX_LENGTH_OF_MULTI_BYTE_FORM
], *p
, *pend
, *ptemp
;
1681 CHECK_STRING (str
, 0);
1683 buf
[0] = LEADING_CODE_COMPOSITION
;
1684 p
= XSTRING (str
)->data
;
1685 pend
= p
+ STRING_BYTES (XSTRING (str
));
1689 if (*p
< 0x20 || *p
== 127) /* control code */
1690 error ("Invalid component character: %d", *p
);
1691 else if (*p
< 0x80) /* ASCII */
1693 if (i
+ 2 >= MAX_LENGTH_OF_MULTI_BYTE_FORM
)
1694 error ("Too long string to be composed: %s", XSTRING (str
)->data
);
1695 /* Prepend an ASCII charset indicator 0xA0, set MSB of the
1698 buf
[i
++] = *p
++ + 0x80;
1700 else if (*p
== LEADING_CODE_COMPOSITION
) /* composite char */
1702 /* Already composed. Eliminate the heading
1703 LEADING_CODE_COMPOSITION, keep the remaining bytes
1707 while (! CHAR_HEAD_P (*p
)) p
++;
1708 if (i
+ (p
- ptemp
) >= MAX_LENGTH_OF_MULTI_BYTE_FORM
)
1709 error ("Too long string to be composed: %s", XSTRING (str
)->data
);
1710 bcopy (ptemp
, buf
+ i
, p
- ptemp
);
1713 else /* multibyte char */
1715 /* Add 0x20 to the base leading-code, keep the remaining
1717 len
= BYTES_BY_CHAR_HEAD (*p
);
1718 if (i
+ len
>= MAX_LENGTH_OF_MULTI_BYTE_FORM
)
1719 error ("Too long string to be composed: %s", XSTRING (str
)->data
);
1720 bcopy (p
, buf
+ i
, len
);
1727 /* STR contains only one character, which can't be composed. */
1728 error ("Too short string to be composed: %s", XSTRING (str
)->data
);
1730 return make_string_from_bytes (buf
, 1, i
);
1735 charset_id_internal (charset_name
)
1740 val
= Fget (intern (charset_name
), Qcharset
);
1742 error ("Charset %s is not defined", charset_name
);
1744 return (XINT (XVECTOR (val
)->contents
[0]));
1747 DEFUN ("setup-special-charsets", Fsetup_special_charsets
,
1748 Ssetup_special_charsets
, 0, 0, 0, "Internal use only.")
1751 charset_latin_iso8859_1
= charset_id_internal ("latin-iso8859-1");
1752 charset_jisx0208_1978
= charset_id_internal ("japanese-jisx0208-1978");
1753 charset_jisx0208
= charset_id_internal ("japanese-jisx0208");
1754 charset_katakana_jisx0201
= charset_id_internal ("katakana-jisx0201");
1755 charset_latin_jisx0201
= charset_id_internal ("latin-jisx0201");
1756 charset_big5_1
= charset_id_internal ("chinese-big5-1");
1757 charset_big5_2
= charset_id_internal ("chinese-big5-2");
1762 init_charset_once ()
1766 staticpro (&Vcharset_table
);
1767 staticpro (&Vcharset_symbol_table
);
1768 staticpro (&Vgeneric_character_list
);
1770 /* This has to be done here, before we call Fmake_char_table. */
1771 Qcharset_table
= intern ("charset-table");
1772 staticpro (&Qcharset_table
);
1774 /* Intern this now in case it isn't already done.
1775 Setting this variable twice is harmless.
1776 But don't staticpro it here--that is done in alloc.c. */
1777 Qchar_table_extra_slots
= intern ("char-table-extra-slots");
1779 /* Now we are ready to set up this property, so we can
1780 create the charset table. */
1781 Fput (Qcharset_table
, Qchar_table_extra_slots
, make_number (0));
1782 Vcharset_table
= Fmake_char_table (Qcharset_table
, Qnil
);
1784 Vcharset_symbol_table
= Fmake_vector (make_number (MAX_CHARSET
+ 1), Qnil
);
1787 for (i
= 0; i
< 2; i
++)
1788 for (j
= 0; j
< 2; j
++)
1789 for (k
= 0; k
< 128; k
++)
1790 iso_charset_table
[i
][j
][k
] = -1;
1792 bzero (cmpchar_hash_table
, sizeof cmpchar_hash_table
);
1793 cmpchar_table_size
= n_cmpchars
= 0;
1795 for (i
= 0; i
< 256; i
++)
1796 BYTES_BY_CHAR_HEAD (i
) = 1;
1797 BYTES_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_11
) = 3;
1798 BYTES_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_12
) = 3;
1799 BYTES_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_21
) = 4;
1800 BYTES_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_22
) = 4;
1801 /* The following doesn't reflect the actual bytes, but just to tell
1802 that it is a start of a multibyte character. */
1803 BYTES_BY_CHAR_HEAD (LEADING_CODE_COMPOSITION
) = 2;
1805 for (i
= 0; i
< 128; i
++)
1806 WIDTH_BY_CHAR_HEAD (i
) = 1;
1807 for (; i
< 256; i
++)
1808 WIDTH_BY_CHAR_HEAD (i
) = 4;
1809 WIDTH_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_11
) = 1;
1810 WIDTH_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_12
) = 2;
1811 WIDTH_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_21
) = 1;
1812 WIDTH_BY_CHAR_HEAD (LEADING_CODE_PRIVATE_22
) = 2;
1818 for (i
= 0x81; i
< 0x90; i
++)
1819 val
= Fcons (make_number ((i
- 0x70) << 7), val
);
1820 for (; i
< 0x9A; i
++)
1821 val
= Fcons (make_number ((i
- 0x8F) << 14), val
);
1822 for (i
= 0xA0; i
< 0xF0; i
++)
1823 val
= Fcons (make_number ((i
- 0x70) << 7), val
);
1824 for (; i
< 0xFF; i
++)
1825 val
= Fcons (make_number ((i
- 0xE0) << 14), val
);
1826 val
= Fcons (make_number (GENERIC_COMPOSITION_CHAR
), val
);
1827 Vgeneric_character_list
= Fnreverse (val
);
1830 nonascii_insert_offset
= 0;
1831 Vnonascii_translation_table
= Qnil
;
1839 Qascii
= intern ("ascii");
1840 staticpro (&Qascii
);
1842 Qcharset
= intern ("charset");
1843 staticpro (&Qcharset
);
1845 /* Define ASCII charset now. */
1846 update_charset_table (make_number (CHARSET_ASCII
),
1847 make_number (1), make_number (94),
1852 build_string ("ASCII"),
1853 build_string ("ASCII"),
1854 build_string ("ASCII (ISO646 IRV)"));
1855 CHARSET_SYMBOL (CHARSET_ASCII
) = Qascii
;
1856 Fput (Qascii
, Qcharset
, CHARSET_TABLE_ENTRY (CHARSET_ASCII
));
1858 Qcomposition
= intern ("composition");
1859 staticpro (&Qcomposition
);
1860 CHARSET_SYMBOL (CHARSET_COMPOSITION
) = Qcomposition
;
1862 defsubr (&Sdefine_charset
);
1863 defsubr (&Sgeneric_character_list
);
1864 defsubr (&Sget_unused_iso_final_char
);
1865 defsubr (&Sdeclare_equiv_charset
);
1866 defsubr (&Sfind_charset_region
);
1867 defsubr (&Sfind_charset_string
);
1868 defsubr (&Smake_char_internal
);
1869 defsubr (&Ssplit_char
);
1870 defsubr (&Schar_charset
);
1871 defsubr (&Scharset_after
);
1872 defsubr (&Siso_charset
);
1873 defsubr (&Schar_valid_p
);
1874 defsubr (&Sunibyte_char_to_multibyte
);
1875 defsubr (&Smultibyte_char_to_unibyte
);
1876 defsubr (&Schar_bytes
);
1877 defsubr (&Schar_width
);
1878 defsubr (&Sstring_width
);
1879 defsubr (&Schar_direction
);
1880 defsubr (&Schars_in_region
);
1882 defsubr (&Scmpcharp
);
1883 defsubr (&Scmpchar_component
);
1884 defsubr (&Scmpchar_cmp_rule
);
1885 defsubr (&Scmpchar_cmp_rule_p
);
1886 defsubr (&Scmpchar_cmp_count
);
1887 defsubr (&Scompose_string
);
1888 defsubr (&Ssetup_special_charsets
);
1890 DEFVAR_LISP ("charset-list", &Vcharset_list
,
1891 "List of charsets ever defined.");
1892 Vcharset_list
= Fcons (Qascii
, Qnil
);
1894 DEFVAR_LISP ("translation-table-vector", &Vtranslation_table_vector
,
1895 "Vector of cons cell of a symbol and translation table ever defined.\n\
1896 An ID of a translation table is an index of this vector.");
1897 Vtranslation_table_vector
= Fmake_vector (make_number (16), Qnil
);
1899 DEFVAR_INT ("leading-code-composition", &leading_code_composition
,
1900 "Leading-code of composite characters.");
1901 leading_code_composition
= LEADING_CODE_COMPOSITION
;
1903 DEFVAR_INT ("leading-code-private-11", &leading_code_private_11
,
1904 "Leading-code of private TYPE9N charset of column-width 1.");
1905 leading_code_private_11
= LEADING_CODE_PRIVATE_11
;
1907 DEFVAR_INT ("leading-code-private-12", &leading_code_private_12
,
1908 "Leading-code of private TYPE9N charset of column-width 2.");
1909 leading_code_private_12
= LEADING_CODE_PRIVATE_12
;
1911 DEFVAR_INT ("leading-code-private-21", &leading_code_private_21
,
1912 "Leading-code of private TYPE9Nx9N charset of column-width 1.");
1913 leading_code_private_21
= LEADING_CODE_PRIVATE_21
;
1915 DEFVAR_INT ("leading-code-private-22", &leading_code_private_22
,
1916 "Leading-code of private TYPE9Nx9N charset of column-width 2.");
1917 leading_code_private_22
= LEADING_CODE_PRIVATE_22
;
1919 DEFVAR_INT ("nonascii-insert-offset", &nonascii_insert_offset
,
1920 "Offset for converting non-ASCII unibyte codes 0240...0377 to multibyte.\n\
1921 This is used for converting unibyte text to multibyte,\n\
1922 and for inserting character codes specified by number.\n\n\
1923 This serves to convert a Latin-1 or similar 8-bit character code\n\
1924 to the corresponding Emacs multibyte character code.\n\
1925 Typically the value should be (- (make-char CHARSET 0) 128),\n\
1926 for your choice of character set.\n\
1927 If `nonascii-translation-table' is non-nil, it overrides this variable.");
1928 nonascii_insert_offset
= 0;
1930 DEFVAR_LISP ("nonascii-translation-table", &Vnonascii_translation_table
,
1931 "Translation table to convert non-ASCII unibyte codes to multibyte.\n\
1932 This is used for converting unibyte text to multibyte,\n\
1933 and for inserting character codes specified by number.\n\n\
1934 Conversion is performed only when multibyte characters are enabled,\n\
1935 and it serves to convert a Latin-1 or similar 8-bit character code\n\
1936 to the corresponding Emacs character code.\n\n\
1937 If this is nil, `nonascii-insert-offset' is used instead.\n\
1938 See also the docstring of `make-translation-table'.");
1939 Vnonascii_translation_table
= Qnil
;
1941 DEFVAR_INT ("min-composite-char", &min_composite_char
,
1942 "Minimum character code of a composite character.");
1943 min_composite_char
= MIN_CHAR_COMPOSITION
;