1 /* Basic multilingual character support.
2 Copyright (C) 1995, 1997, 1998 Electrotechnical Laboratory, JAPAN.
3 Licensed to the Free Software Foundation.
4 Copyright (C) 2001 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs; see the file COPYING. If not, write to
20 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
23 /* At first, see the document in `charset.h' to understand the code in
34 #include <sys/types.h>
38 #include "composite.h"
48 Lisp_Object Qcharset
, Qascii
, Qeight_bit_control
, Qeight_bit_graphic
;
51 /* Declaration of special leading-codes. */
52 EMACS_INT leading_code_private_11
; /* for private DIMENSION1 of 1-column */
53 EMACS_INT leading_code_private_12
; /* for private DIMENSION1 of 2-column */
54 EMACS_INT leading_code_private_21
; /* for private DIMENSION2 of 1-column */
55 EMACS_INT leading_code_private_22
; /* for private DIMENSION2 of 2-column */
57 /* Declaration of special charsets. The values are set by
58 Fsetup_special_charsets. */
59 int charset_latin_iso8859_1
; /* ISO8859-1 (Latin-1) */
60 int charset_jisx0208_1978
; /* JISX0208.1978 (Japanese Kanji old set) */
61 int charset_jisx0208
; /* JISX0208.1983 (Japanese Kanji) */
62 int charset_katakana_jisx0201
; /* JISX0201.Kana (Japanese Katakana) */
63 int charset_latin_jisx0201
; /* JISX0201.Roman (Japanese Roman) */
64 int charset_big5_1
; /* Big5 Level 1 (Chinese Traditional) */
65 int charset_big5_2
; /* Big5 Level 2 (Chinese Traditional) */
67 Lisp_Object Qcharset_table
;
69 /* A char-table containing information of each character set. */
70 Lisp_Object Vcharset_table
;
72 /* A vector of charset symbol indexed by charset-id. This is used
73 only for returning charset symbol from C functions. */
74 Lisp_Object Vcharset_symbol_table
;
76 /* A list of charset symbols ever defined. */
77 Lisp_Object Vcharset_list
;
79 /* Vector of translation table ever defined.
80 ID of a translation table is used to index this vector. */
81 Lisp_Object Vtranslation_table_vector
;
83 /* A char-table for characters which may invoke auto-filling. */
84 Lisp_Object Vauto_fill_chars
;
86 Lisp_Object Qauto_fill_chars
;
88 /* Tables used by macros BYTES_BY_CHAR_HEAD and WIDTH_BY_CHAR_HEAD. */
89 int bytes_by_char_head
[256];
90 int width_by_char_head
[256];
92 /* Mapping table from ISO2022's charset (specified by DIMENSION,
93 CHARS, and FINAL-CHAR) to Emacs' charset. */
94 int iso_charset_table
[2][2][128];
96 /* Variables used locally in the macro FETCH_MULTIBYTE_CHAR. */
97 unsigned char *_fetch_multibyte_char_p
;
98 int _fetch_multibyte_char_len
;
100 /* Offset to add to a non-ASCII value when inserting it. */
101 EMACS_INT nonascii_insert_offset
;
103 /* Translation table for converting non-ASCII unibyte characters
104 to multibyte codes, or nil. */
105 Lisp_Object Vnonascii_translation_table
;
107 /* List of all possible generic characters. */
108 Lisp_Object Vgeneric_character_list
;
112 invalid_character (c
)
115 error ("Invalid character: 0%o, %d, 0x%x", c
, c
, c
);
118 /* Parse string STR of length LENGTH and fetch information of a
119 character at STR. Set BYTES to the byte length the character
120 occupies, CHARSET, C1, C2 to proper values of the character. */
122 #define SPLIT_MULTIBYTE_SEQ(str, length, bytes, charset, c1, c2) \
125 (bytes) = BYTES_BY_CHAR_HEAD (c1); \
127 (charset) = ASCII_BYTE_P (c1) ? CHARSET_ASCII : CHARSET_8_BIT_GRAPHIC; \
128 else if ((bytes) == 2) \
130 if ((c1) == LEADING_CODE_8_BIT_CONTROL) \
131 (charset) = CHARSET_8_BIT_CONTROL, (c1) = (str)[1] - 0x20; \
133 (charset) = (c1), (c1) = (str)[1] & 0x7F; \
135 else if ((bytes) == 3) \
137 if ((c1) < LEADING_CODE_PRIVATE_11) \
138 (charset) = (c1), (c1) = (str)[1] & 0x7F, (c2) = (str)[2] & 0x7F; \
140 (charset) = (str)[1], (c1) = (str)[2] & 0x7F; \
143 (charset) = (str)[1], (c1) = (str)[2] & 0x7F, (c2) = (str)[3] & 0x7F; \
146 /* 1 if CHARSET, C1, and C2 compose a valid character, else 0.
147 Note that this intentionally allows invalid components, such
148 as 0xA0 0xA0, because there exist many files that contain
149 such invalid byte sequences, especially in EUC-GB. */
150 #define CHAR_COMPONENTS_VALID_P(charset, c1, c2) \
151 ((charset) == CHARSET_ASCII \
152 ? ((c1) >= 0 && (c1) <= 0x7F) \
153 : ((charset) == CHARSET_8_BIT_CONTROL \
154 ? ((c1) >= 0x80 && (c1) <= 0x9F) \
155 : ((charset) == CHARSET_8_BIT_GRAPHIC \
156 ? ((c1) >= 0x80 && (c1) <= 0xFF) \
157 : (CHARSET_DIMENSION (charset) == 1 \
158 ? ((c1) >= 0x20 && (c1) <= 0x7F) \
159 : ((c1) >= 0x20 && (c1) <= 0x7F \
160 && (c2) >= 0x20 && (c2) <= 0x7F)))))
162 /* Store multi-byte form of the character C in STR. The caller should
163 allocate at least 4-byte area at STR in advance. Returns the
164 length of the multi-byte form. If C is an invalid character code,
168 char_to_string_1 (c
, str
)
172 unsigned char *p
= str
;
174 if (c
& CHAR_MODIFIER_MASK
) /* This includes the case C is negative. */
176 /* Multibyte character can't have a modifier bit. */
177 if (! SINGLE_BYTE_CHAR_P ((c
& ~CHAR_MODIFIER_MASK
)))
180 /* For Meta, Shift, and Control modifiers, we need special care. */
183 /* Move the meta bit to the right place for a string. */
184 c
= (c
& ~CHAR_META
) | 0x80;
188 /* Shift modifier is valid only with [A-Za-z]. */
189 if ((c
& 0377) >= 'A' && (c
& 0377) <= 'Z')
191 else if ((c
& 0377) >= 'a' && (c
& 0377) <= 'z')
192 c
= (c
& ~CHAR_SHIFT
) - ('a' - 'A');
196 /* Simulate the code in lread.c. */
197 /* Allow `\C- ' and `\C-?'. */
198 if (c
== (CHAR_CTL
| ' '))
200 else if (c
== (CHAR_CTL
| '?'))
202 /* ASCII control chars are made from letters (both cases),
203 as well as the non-letters within 0100...0137. */
204 else if ((c
& 0137) >= 0101 && (c
& 0137) <= 0132)
205 c
&= (037 | (~0177 & ~CHAR_CTL
));
206 else if ((c
& 0177) >= 0100 && (c
& 0177) <= 0137)
207 c
&= (037 | (~0177 & ~CHAR_CTL
));
210 /* If C still has any modifier bits, just ignore it. */
211 c
&= ~CHAR_MODIFIER_MASK
;
214 if (SINGLE_BYTE_CHAR_P (c
))
216 if (ASCII_BYTE_P (c
) || c
>= 0xA0)
220 *p
++ = LEADING_CODE_8_BIT_CONTROL
;
224 else if (CHAR_VALID_P (c
, 0))
228 SPLIT_CHAR (c
, charset
, c1
, c2
);
230 if (charset
>= LEADING_CODE_EXT_11
)
231 *p
++ = (charset
< LEADING_CODE_EXT_12
232 ? LEADING_CODE_PRIVATE_11
233 : (charset
< LEADING_CODE_EXT_21
234 ? LEADING_CODE_PRIVATE_12
235 : (charset
< LEADING_CODE_EXT_22
236 ? LEADING_CODE_PRIVATE_21
237 : LEADING_CODE_PRIVATE_22
)));
239 if ((c1
> 0 && c1
< 32) || (c2
> 0 && c2
< 32))
255 /* Store multi-byte form of the character C in STR. The caller should
256 allocate at least 4-byte area at STR in advance. Returns the
257 length of the multi-byte form. If C is an invalid character code,
260 Use macro `CHAR_STRING (C, STR)' instead of calling this function
261 directly if C can be an ASCII character. */
264 char_to_string (c
, str
)
269 len
= char_to_string_1 (c
, str
);
271 invalid_character (c
);
276 /* Return the non-ASCII character corresponding to multi-byte form at
277 STR of length LEN. If ACTUAL_LEN is not NULL, store the byte
278 length of the multibyte form in *ACTUAL_LEN.
280 Use macros STRING_CHAR or STRING_CHAR_AND_LENGTH instead of calling
281 this function directly if you want ot handle ASCII characters as
285 string_to_char (str
, len
, actual_len
)
286 const unsigned char *str
;
287 int len
, *actual_len
;
289 int c
, bytes
, charset
, c1
, c2
;
291 SPLIT_MULTIBYTE_SEQ (str
, len
, bytes
, charset
, c1
, c2
);
292 c
= MAKE_CHAR (charset
, c1
, c2
);
298 /* Return the length of the multi-byte form at string STR of length LEN.
299 Use the macro MULTIBYTE_FORM_LENGTH instead. */
301 multibyte_form_length (str
, len
)
302 const unsigned char *str
;
307 PARSE_MULTIBYTE_SEQ (str
, len
, bytes
);
311 /* Check multibyte form at string STR of length LEN and set variables
312 pointed by CHARSET, C1, and C2 to charset and position codes of the
313 character at STR, and return 0. If there's no multibyte character,
314 return -1. This should be used only in the macro SPLIT_STRING
315 which checks range of STR in advance. */
318 split_string (str
, len
, charset
, c1
, c2
)
319 const unsigned char *str
;
320 unsigned char *c1
, *c2
;
323 register int bytes
, cs
, code1
, code2
= -1;
325 SPLIT_MULTIBYTE_SEQ (str
, len
, bytes
, cs
, code1
, code2
);
326 if (cs
== CHARSET_ASCII
)
334 /* Return 1 iff character C has valid printable glyph.
335 Use the macro CHAR_PRINTABLE_P instead. */
342 if (ASCII_BYTE_P (c
))
344 else if (SINGLE_BYTE_CHAR_P (c
))
346 else if (c
>= MAX_CHAR
)
349 SPLIT_CHAR (c
, charset
, c1
, c2
);
350 if (! CHARSET_DEFINED_P (charset
))
352 if (CHARSET_CHARS (charset
) == 94
353 ? c1
<= 32 || c1
>= 127
356 if (CHARSET_DIMENSION (charset
) == 2
357 && (CHARSET_CHARS (charset
) == 94
358 ? c2
<= 32 || c2
>= 127
364 /* Translate character C by translation table TABLE. If C
365 is negative, translate a character specified by CHARSET, C1, and C2
366 (C1 and C2 are code points of the character). If no translation is
367 found in TABLE, return C. */
369 translate_char (table
, c
, charset
, c1
, c2
)
371 int c
, charset
, c1
, c2
;
374 int alt_charset
, alt_c1
, alt_c2
, dimension
;
376 if (c
< 0) c
= MAKE_CHAR (charset
, (c1
& 0x7F) , (c2
& 0x7F));
377 if (!CHAR_TABLE_P (table
)
378 || (ch
= Faref (table
, make_number (c
)), !NATNUMP (ch
)))
381 SPLIT_CHAR (XFASTINT (ch
), alt_charset
, alt_c1
, alt_c2
);
382 dimension
= CHARSET_DIMENSION (alt_charset
);
383 if ((dimension
== 1 && alt_c1
> 0) || (dimension
== 2 && alt_c2
> 0))
384 /* CH is not a generic character, just return it. */
385 return XFASTINT (ch
);
387 /* Since CH is a generic character, we must return a specific
388 charater which has the same position codes as C from CH. */
390 SPLIT_CHAR (c
, charset
, c1
, c2
);
391 if (dimension
!= CHARSET_DIMENSION (charset
))
392 /* We can't make such a character because of dimension mismatch. */
394 return MAKE_CHAR (alt_charset
, c1
, c2
);
397 /* Convert the unibyte character C to multibyte based on
398 Vnonascii_translation_table or nonascii_insert_offset. If they can't
399 convert C to a valid multibyte character, convert it based on
400 DEFAULT_NONASCII_INSERT_OFFSET which makes C a Latin-1 character. */
403 unibyte_char_to_multibyte (c
)
406 if (c
< 0400 && c
>= 0200)
410 if (! NILP (Vnonascii_translation_table
))
412 c
= XINT (Faref (Vnonascii_translation_table
, make_number (c
)));
413 if (c
>= 0400 && ! char_valid_p (c
, 0))
414 c
= c_save
+ DEFAULT_NONASCII_INSERT_OFFSET
;
416 else if (c
>= 0240 && nonascii_insert_offset
> 0)
418 c
+= nonascii_insert_offset
;
419 if (c
< 0400 || ! char_valid_p (c
, 0))
420 c
= c_save
+ DEFAULT_NONASCII_INSERT_OFFSET
;
423 c
= c_save
+ DEFAULT_NONASCII_INSERT_OFFSET
;
429 /* Convert the multibyte character C to unibyte 8-bit character based
430 on Vnonascii_translation_table or nonascii_insert_offset. If
431 REV_TBL is non-nil, it should be a reverse table of
432 Vnonascii_translation_table, i.e. what given by:
433 Fchar_table_extra_slot (Vnonascii_translation_table, make_number (0)) */
436 multibyte_char_to_unibyte (c
, rev_tbl
)
440 if (!SINGLE_BYTE_CHAR_P (c
))
444 if (! CHAR_TABLE_P (rev_tbl
)
445 && CHAR_TABLE_P (Vnonascii_translation_table
))
446 rev_tbl
= Fchar_table_extra_slot (Vnonascii_translation_table
,
448 if (CHAR_TABLE_P (rev_tbl
))
451 temp
= Faref (rev_tbl
, make_number (c
));
455 c
= (c_save
& 0177) + 0200;
459 if (nonascii_insert_offset
> 0)
460 c
-= nonascii_insert_offset
;
461 if (c
< 128 || c
>= 256)
462 c
= (c_save
& 0177) + 0200;
470 /* Update the table Vcharset_table with the given arguments (see the
471 document of `define-charset' for the meaning of each argument).
472 Several other table contents are also updated. The caller should
473 check the validity of CHARSET-ID and the remaining arguments in
477 update_charset_table (charset_id
, dimension
, chars
, width
, direction
,
478 iso_final_char
, iso_graphic_plane
,
479 short_name
, long_name
, description
)
480 Lisp_Object charset_id
, dimension
, chars
, width
, direction
;
481 Lisp_Object iso_final_char
, iso_graphic_plane
;
482 Lisp_Object short_name
, long_name
, description
;
484 int charset
= XINT (charset_id
);
486 unsigned char leading_code_base
, leading_code_ext
;
488 if (NILP (CHARSET_TABLE_ENTRY (charset
)))
489 CHARSET_TABLE_ENTRY (charset
)
490 = Fmake_vector (make_number (CHARSET_MAX_IDX
), Qnil
);
492 if (NILP (long_name
))
493 long_name
= short_name
;
494 if (NILP (description
))
495 description
= long_name
;
497 /* Get byte length of multibyte form, base leading-code, and
498 extended leading-code of the charset. See the comment under the
499 title "GENERAL NOTE on CHARACTER SET (CHARSET)" in charset.h. */
500 bytes
= XINT (dimension
);
501 if (charset
< MIN_CHARSET_PRIVATE_DIMENSION1
)
503 /* Official charset, it doesn't have an extended leading-code. */
504 if (charset
!= CHARSET_ASCII
&& charset
!= CHARSET_8_BIT_GRAPHIC
)
505 bytes
+= 1; /* For a base leading-code. */
506 leading_code_base
= charset
;
507 leading_code_ext
= 0;
511 /* Private charset. */
512 bytes
+= 2; /* For base and extended leading-codes. */
514 = (charset
< LEADING_CODE_EXT_12
515 ? LEADING_CODE_PRIVATE_11
516 : (charset
< LEADING_CODE_EXT_21
517 ? LEADING_CODE_PRIVATE_12
518 : (charset
< LEADING_CODE_EXT_22
519 ? LEADING_CODE_PRIVATE_21
520 : LEADING_CODE_PRIVATE_22
)));
521 leading_code_ext
= charset
;
522 if (BYTES_BY_CHAR_HEAD (leading_code_base
) != bytes
)
523 error ("Invalid dimension for the charset-ID %d", charset
);
526 CHARSET_TABLE_INFO (charset
, CHARSET_ID_IDX
) = charset_id
;
527 CHARSET_TABLE_INFO (charset
, CHARSET_BYTES_IDX
) = make_number (bytes
);
528 CHARSET_TABLE_INFO (charset
, CHARSET_DIMENSION_IDX
) = dimension
;
529 CHARSET_TABLE_INFO (charset
, CHARSET_CHARS_IDX
) = chars
;
530 CHARSET_TABLE_INFO (charset
, CHARSET_WIDTH_IDX
) = width
;
531 CHARSET_TABLE_INFO (charset
, CHARSET_DIRECTION_IDX
) = direction
;
532 CHARSET_TABLE_INFO (charset
, CHARSET_LEADING_CODE_BASE_IDX
)
533 = make_number (leading_code_base
);
534 CHARSET_TABLE_INFO (charset
, CHARSET_LEADING_CODE_EXT_IDX
)
535 = make_number (leading_code_ext
);
536 CHARSET_TABLE_INFO (charset
, CHARSET_ISO_FINAL_CHAR_IDX
) = iso_final_char
;
537 CHARSET_TABLE_INFO (charset
, CHARSET_ISO_GRAPHIC_PLANE_IDX
)
539 CHARSET_TABLE_INFO (charset
, CHARSET_SHORT_NAME_IDX
) = short_name
;
540 CHARSET_TABLE_INFO (charset
, CHARSET_LONG_NAME_IDX
) = long_name
;
541 CHARSET_TABLE_INFO (charset
, CHARSET_DESCRIPTION_IDX
) = description
;
542 CHARSET_TABLE_INFO (charset
, CHARSET_PLIST_IDX
) = Qnil
;
545 /* If we have already defined a charset which has the same
546 DIMENSION, CHARS and ISO-FINAL-CHAR but the different
547 DIRECTION, we must update the entry REVERSE-CHARSET of both
548 charsets. If there's no such charset, the value of the entry
552 for (i
= 0; i
<= MAX_CHARSET
; i
++)
553 if (!NILP (CHARSET_TABLE_ENTRY (i
)))
555 if (CHARSET_DIMENSION (i
) == XINT (dimension
)
556 && CHARSET_CHARS (i
) == XINT (chars
)
557 && CHARSET_ISO_FINAL_CHAR (i
) == XINT (iso_final_char
)
558 && CHARSET_DIRECTION (i
) != XINT (direction
))
560 CHARSET_TABLE_INFO (charset
, CHARSET_REVERSE_CHARSET_IDX
)
562 CHARSET_TABLE_INFO (i
, CHARSET_REVERSE_CHARSET_IDX
) = charset_id
;
567 /* No such a charset. */
568 CHARSET_TABLE_INFO (charset
, CHARSET_REVERSE_CHARSET_IDX
)
572 if (charset
!= CHARSET_ASCII
&& charset
!= CHARSET_8_BIT_GRAPHIC
573 && charset
< MIN_CHARSET_PRIVATE_DIMENSION1
)
575 bytes_by_char_head
[leading_code_base
] = bytes
;
576 width_by_char_head
[leading_code_base
] = XINT (width
);
578 /* Update table emacs_code_class. */
579 emacs_code_class
[charset
] = (bytes
== 2
580 ? EMACS_leading_code_2
582 ? EMACS_leading_code_3
583 : EMACS_leading_code_4
));
586 /* Update table iso_charset_table. */
587 if (XINT (iso_final_char
) >= 0
588 && ISO_CHARSET_TABLE (dimension
, chars
, iso_final_char
) < 0)
589 ISO_CHARSET_TABLE (dimension
, chars
, iso_final_char
) = charset
;
594 /* Return charset id of CHARSET_SYMBOL, or return -1 if CHARSET_SYMBOL
597 get_charset_id (charset_symbol
)
598 Lisp_Object charset_symbol
;
603 /* This originally used a ?: operator, but reportedly the HP-UX
604 compiler version HP92453-01 A.10.32.22 miscompiles that. */
605 if (SYMBOLP (charset_symbol
)
606 && VECTORP (val
= Fget (charset_symbol
, Qcharset
))
607 && CHARSET_VALID_P (charset
=
608 XINT (XVECTOR (val
)->contents
[CHARSET_ID_IDX
])))
614 /* Return an identification number for a new private charset of
615 DIMENSION and WIDTH. If there's no more room for the new charset,
618 get_new_private_charset_id (dimension
, width
)
619 int dimension
, width
;
621 int charset
, from
, to
;
625 from
= LEADING_CODE_EXT_11
;
626 to
= LEADING_CODE_EXT_21
;
630 from
= LEADING_CODE_EXT_21
;
631 to
= LEADING_CODE_EXT_MAX
+ 1;
634 for (charset
= from
; charset
< to
; charset
++)
635 if (!CHARSET_DEFINED_P (charset
)) break;
637 return make_number (charset
< to
? charset
: 0);
640 DEFUN ("define-charset", Fdefine_charset
, Sdefine_charset
, 3, 3, 0,
641 doc
: /* Define CHARSET-ID as the identification number of CHARSET with INFO-VECTOR.
642 If CHARSET-ID is nil, it is decided automatically, which means CHARSET is
643 treated as a private charset.
644 INFO-VECTOR is a vector of the format:
645 [DIMENSION CHARS WIDTH DIRECTION ISO-FINAL-CHAR ISO-GRAPHIC-PLANE
646 SHORT-NAME LONG-NAME DESCRIPTION]
647 The meanings of each elements is as follows:
648 DIMENSION (integer) is the number of bytes to represent a character: 1 or 2.
649 CHARS (integer) is the number of characters in a dimension: 94 or 96.
650 WIDTH (integer) is the number of columns a character in the charset
651 occupies on the screen: one of 0, 1, and 2.
653 DIRECTION (integer) is the rendering direction of characters in the
654 charset when rendering. If 0, render from left to right, else
655 render from right to left.
657 ISO-FINAL-CHAR (character) is the final character of the
658 corresponding ISO 2022 charset.
659 It may be -1 if the charset is internal use only.
661 ISO-GRAPHIC-PLANE (integer) is the graphic plane to be invoked
662 while encoding to variants of ISO 2022 coding system, one of the
663 following: 0/graphic-plane-left(GL), 1/graphic-plane-right(GR).
664 It may be -1 if the charset is internal use only.
666 SHORT-NAME (string) is the short name to refer to the charset.
668 LONG-NAME (string) is the long name to refer to the charset.
670 DESCRIPTION (string) is the description string of the charset. */)
671 (charset_id
, charset_symbol
, info_vector
)
672 Lisp_Object charset_id
, charset_symbol
, info_vector
;
676 if (!NILP (charset_id
))
677 CHECK_NUMBER (charset_id
);
678 CHECK_SYMBOL (charset_symbol
);
679 CHECK_VECTOR (info_vector
);
681 if (! NILP (charset_id
))
683 if (! CHARSET_VALID_P (XINT (charset_id
)))
684 error ("Invalid CHARSET: %d", XINT (charset_id
));
685 else if (CHARSET_DEFINED_P (XINT (charset_id
)))
686 error ("Already defined charset: %d", XINT (charset_id
));
689 vec
= XVECTOR (info_vector
)->contents
;
690 if (XVECTOR (info_vector
)->size
!= 9
691 || !INTEGERP (vec
[0]) || !(XINT (vec
[0]) == 1 || XINT (vec
[0]) == 2)
692 || !INTEGERP (vec
[1]) || !(XINT (vec
[1]) == 94 || XINT (vec
[1]) == 96)
693 || !INTEGERP (vec
[2]) || !(XINT (vec
[2]) == 1 || XINT (vec
[2]) == 2)
694 || !INTEGERP (vec
[3]) || !(XINT (vec
[3]) == 0 || XINT (vec
[3]) == 1)
695 || !INTEGERP (vec
[4])
696 || !(XINT (vec
[4]) == -1 || (XINT (vec
[4]) >= '0' && XINT (vec
[4]) <= '~'))
697 || !INTEGERP (vec
[5])
698 || !(XINT (vec
[5]) == -1 || XINT (vec
[5]) == 0 || XINT (vec
[5]) == 1)
701 || !STRINGP (vec
[8]))
702 error ("Invalid info-vector argument for defining charset %s",
703 XSTRING (SYMBOL_NAME (charset_symbol
))->data
);
705 if (NILP (charset_id
))
707 charset_id
= get_new_private_charset_id (XINT (vec
[0]), XINT (vec
[2]));
708 if (XINT (charset_id
) == 0)
709 error ("There's no room for a new private charset %s",
710 XSTRING (SYMBOL_NAME (charset_symbol
))->data
);
713 update_charset_table (charset_id
, vec
[0], vec
[1], vec
[2], vec
[3],
714 vec
[4], vec
[5], vec
[6], vec
[7], vec
[8]);
715 Fput (charset_symbol
, Qcharset
, CHARSET_TABLE_ENTRY (XINT (charset_id
)));
716 CHARSET_SYMBOL (XINT (charset_id
)) = charset_symbol
;
717 Vcharset_list
= Fcons (charset_symbol
, Vcharset_list
);
718 Fupdate_coding_systems_internal ();
722 DEFUN ("generic-character-list", Fgeneric_character_list
,
723 Sgeneric_character_list
, 0, 0, 0,
724 doc
: /* Return a list of all possible generic characters.
725 It includes a generic character for a charset not yet defined. */)
728 return Vgeneric_character_list
;
731 DEFUN ("get-unused-iso-final-char", Fget_unused_iso_final_char
,
732 Sget_unused_iso_final_char
, 2, 2, 0,
733 doc
: /* Return an unsed ISO's final char for a charset of DIMENISION and CHARS.
734 DIMENSION is the number of bytes to represent a character: 1 or 2.
735 CHARS is the number of characters in a dimension: 94 or 96.
737 This final char is for private use, thus the range is `0' (48) .. `?' (63).
738 If there's no unused final char for the specified kind of charset,
741 Lisp_Object dimension
, chars
;
745 CHECK_NUMBER (dimension
);
746 CHECK_NUMBER (chars
);
747 if (XINT (dimension
) != 1 && XINT (dimension
) != 2)
748 error ("Invalid charset dimension %d, it should be 1 or 2",
750 if (XINT (chars
) != 94 && XINT (chars
) != 96)
751 error ("Invalid charset chars %d, it should be 94 or 96",
753 for (final_char
= '0'; final_char
<= '?'; final_char
++)
755 if (ISO_CHARSET_TABLE (dimension
, chars
, make_number (final_char
)) < 0)
758 return (final_char
<= '?' ? make_number (final_char
) : Qnil
);
761 DEFUN ("declare-equiv-charset", Fdeclare_equiv_charset
, Sdeclare_equiv_charset
,
763 doc
: /* Declare a charset of DIMENSION, CHARS, FINAL-CHAR is the same as CHARSET.
764 CHARSET should be defined by `defined-charset' in advance. */)
765 (dimension
, chars
, final_char
, charset_symbol
)
766 Lisp_Object dimension
, chars
, final_char
, charset_symbol
;
770 CHECK_NUMBER (dimension
);
771 CHECK_NUMBER (chars
);
772 CHECK_NUMBER (final_char
);
773 CHECK_SYMBOL (charset_symbol
);
775 if (XINT (dimension
) != 1 && XINT (dimension
) != 2)
776 error ("Invalid DIMENSION %d, it should be 1 or 2", XINT (dimension
));
777 if (XINT (chars
) != 94 && XINT (chars
) != 96)
778 error ("Invalid CHARS %d, it should be 94 or 96", XINT (chars
));
779 if (XINT (final_char
) < '0' || XFASTINT (final_char
) > '~')
780 error ("Invalid FINAL-CHAR %c, it should be `0'..`~'", XINT (chars
));
781 if ((charset
= get_charset_id (charset_symbol
)) < 0)
782 error ("Invalid charset %s", XSTRING (SYMBOL_NAME (charset_symbol
))->data
);
784 ISO_CHARSET_TABLE (dimension
, chars
, final_char
) = charset
;
788 /* Return information about charsets in the text at PTR of NBYTES
789 bytes, which are NCHARS characters. The value is:
791 0: Each character is represented by one byte. This is always
792 true for unibyte text.
793 1: No charsets other than ascii eight-bit-control,
794 eight-bit-graphic, and latin-1 are found.
797 In addition, if CHARSETS is nonzero, for each found charset N, set
798 CHARSETS[N] to 1. For that, callers should allocate CHARSETS
799 (MAX_CHARSET + 1 elements) in advance. It may lookup a translation
800 table TABLE if supplied. For invalid charsets, set CHARSETS[1] to
801 1 (note that there's no charset whose ID is 1). */
804 find_charset_in_text (ptr
, nchars
, nbytes
, charsets
, table
)
806 int nchars
, nbytes
, *charsets
;
809 if (nchars
== nbytes
)
811 if (charsets
&& nbytes
> 0)
813 unsigned char *endp
= ptr
+ nbytes
;
816 while (ptr
< endp
&& maskbits
!= 7)
818 maskbits
|= (*ptr
< 0x80 ? 1 : *ptr
< 0xA0 ? 2 : 4);
823 charsets
[CHARSET_ASCII
] = 1;
825 charsets
[CHARSET_8_BIT_CONTROL
] = 1;
827 charsets
[CHARSET_8_BIT_GRAPHIC
] = 1;
834 int bytes
, charset
, c1
, c2
;
836 if (! CHAR_TABLE_P (table
))
841 SPLIT_MULTIBYTE_SEQ (ptr
, len
, bytes
, charset
, c1
, c2
);
844 if (!CHARSET_DEFINED_P (charset
))
846 else if (! NILP (table
))
848 int c
= translate_char (table
, -1, charset
, c1
, c2
);
850 charset
= CHAR_CHARSET (c
);
854 && charset
!= CHARSET_ASCII
855 && charset
!= CHARSET_8_BIT_CONTROL
856 && charset
!= CHARSET_8_BIT_GRAPHIC
857 && charset
!= charset_latin_iso8859_1
)
861 charsets
[charset
] = 1;
862 else if (return_val
== 2)
869 DEFUN ("find-charset-region", Ffind_charset_region
, Sfind_charset_region
,
871 doc
: /* Return a list of charsets in the region between BEG and END.
872 BEG and END are buffer positions.
873 Optional arg TABLE if non-nil is a translation table to look up.
875 If the region contains invalid multibyte characters,
876 `unknown' is included in the returned list.
878 If the current buffer is unibyte, the returned list may contain
879 only `ascii', `eight-bit-control', and `eight-bit-graphic'. */)
881 Lisp_Object beg
, end
, table
;
883 int charsets
[MAX_CHARSET
+ 1];
884 int from
, from_byte
, to
, stop
, stop_byte
, i
;
887 validate_region (&beg
, &end
);
888 from
= XFASTINT (beg
);
889 stop
= to
= XFASTINT (end
);
891 if (from
< GPT
&& GPT
< to
)
894 stop_byte
= GPT_BYTE
;
897 stop_byte
= CHAR_TO_BYTE (stop
);
899 from_byte
= CHAR_TO_BYTE (from
);
901 bzero (charsets
, (MAX_CHARSET
+ 1) * sizeof (int));
904 find_charset_in_text (BYTE_POS_ADDR (from_byte
), stop
- from
,
905 stop_byte
- from_byte
, charsets
, table
);
908 from
= stop
, from_byte
= stop_byte
;
909 stop
= to
, stop_byte
= CHAR_TO_BYTE (stop
);
917 val
= Fcons (Qunknown
, val
);
918 for (i
= MAX_CHARSET
; i
>= MIN_CHARSET_OFFICIAL_DIMENSION1
; i
--)
920 val
= Fcons (CHARSET_SYMBOL (i
), val
);
922 val
= Fcons (Qascii
, val
);
926 DEFUN ("find-charset-string", Ffind_charset_string
, Sfind_charset_string
,
928 doc
: /* Return a list of charsets in STR.
929 Optional arg TABLE if non-nil is a translation table to look up.
931 If the string contains invalid multibyte characters,
932 `unknown' is included in the returned list.
934 If STR is unibyte, the returned list may contain
935 only `ascii', `eight-bit-control', and `eight-bit-graphic'. */)
937 Lisp_Object str
, table
;
939 int charsets
[MAX_CHARSET
+ 1];
945 bzero (charsets
, (MAX_CHARSET
+ 1) * sizeof (int));
946 find_charset_in_text (XSTRING (str
)->data
, XSTRING (str
)->size
,
947 STRING_BYTES (XSTRING (str
)), charsets
, table
);
951 val
= Fcons (Qunknown
, val
);
952 for (i
= MAX_CHARSET
; i
>= MIN_CHARSET_OFFICIAL_DIMENSION1
; i
--)
954 val
= Fcons (CHARSET_SYMBOL (i
), val
);
956 val
= Fcons (Qascii
, val
);
961 DEFUN ("make-char-internal", Fmake_char_internal
, Smake_char_internal
, 1, 3, 0,
962 doc
: /* Return a character made from arguments.
963 Internal use only. */)
964 (charset
, code1
, code2
)
965 Lisp_Object charset
, code1
, code2
;
967 int charset_id
, c1
, c2
;
969 CHECK_NUMBER (charset
);
970 charset_id
= XINT (charset
);
971 if (!CHARSET_DEFINED_P (charset_id
))
972 error ("Invalid charset ID: %d", XINT (charset
));
978 CHECK_NUMBER (code1
);
985 CHECK_NUMBER (code2
);
989 if (charset_id
== CHARSET_ASCII
)
991 if (c1
< 0 || c1
> 0x7F)
992 goto invalid_code_posints
;
993 return make_number (c1
);
995 else if (charset_id
== CHARSET_8_BIT_CONTROL
)
999 else if (c1
< 0x80 || c1
> 0x9F)
1000 goto invalid_code_posints
;
1001 return make_number (c1
);
1003 else if (charset_id
== CHARSET_8_BIT_GRAPHIC
)
1007 else if (c1
< 0xA0 || c1
> 0xFF)
1008 goto invalid_code_posints
;
1009 return make_number (c1
);
1011 else if (c1
< 0 || c1
> 0xFF || c2
< 0 || c2
> 0xFF)
1012 goto invalid_code_posints
;
1018 ? !CHAR_COMPONENTS_VALID_P (charset_id
, c1
, 0x20)
1019 : !CHAR_COMPONENTS_VALID_P (charset_id
, c1
, c2
)))
1020 goto invalid_code_posints
;
1021 return make_number (MAKE_CHAR (charset_id
, c1
, c2
));
1023 invalid_code_posints
:
1024 error ("Invalid code points for charset ID %d: %d %d", charset_id
, c1
, c2
);
1027 DEFUN ("split-char", Fsplit_char
, Ssplit_char
, 1, 1, 0,
1028 doc
: /* Return list of charset and one or two position-codes of CHAR.
1029 If CHAR is invalid as a character code,
1030 return a list of symbol `unknown' and CHAR. */)
1034 int c
, charset
, c1
, c2
;
1038 if (!CHAR_VALID_P (c
, 1))
1039 return Fcons (Qunknown
, Fcons (ch
, Qnil
));
1040 SPLIT_CHAR (XFASTINT (ch
), charset
, c1
, c2
);
1042 ? Fcons (CHARSET_SYMBOL (charset
),
1043 Fcons (make_number (c1
), Fcons (make_number (c2
), Qnil
)))
1044 : Fcons (CHARSET_SYMBOL (charset
), Fcons (make_number (c1
), Qnil
)));
1047 DEFUN ("char-charset", Fchar_charset
, Schar_charset
, 1, 1, 0,
1048 doc
: /* Return charset of CHAR. */)
1054 return CHARSET_SYMBOL (CHAR_CHARSET (XINT (ch
)));
1057 DEFUN ("charset-after", Fcharset_after
, Scharset_after
, 0, 1, 0,
1058 doc
: /* Return charset of a character in the current buffer at position POS.
1059 If POS is nil, it defauls to the current point.
1060 If POS is out of range, the value is nil. */)
1067 ch
= Fchar_after (pos
);
1068 if (! INTEGERP (ch
))
1070 charset
= CHAR_CHARSET (XINT (ch
));
1071 return CHARSET_SYMBOL (charset
);
1074 DEFUN ("iso-charset", Fiso_charset
, Siso_charset
, 3, 3, 0,
1075 doc
: /* Return charset of ISO's specification DIMENSION, CHARS, and FINAL-CHAR.
1077 ISO 2022's designation sequence (escape sequence) distinguishes charsets
1078 by their DIMENSION, CHARS, and FINAL-CHAR,
1079 where as Emacs distinguishes them by charset symbol.
1080 See the documentation of the function `charset-info' for the meanings of
1081 DIMENSION, CHARS, and FINAL-CHAR. */)
1082 (dimension
, chars
, final_char
)
1083 Lisp_Object dimension
, chars
, final_char
;
1087 CHECK_NUMBER (dimension
);
1088 CHECK_NUMBER (chars
);
1089 CHECK_NUMBER (final_char
);
1091 if ((charset
= ISO_CHARSET_TABLE (dimension
, chars
, final_char
)) < 0)
1093 return CHARSET_SYMBOL (charset
);
1096 /* If GENERICP is nonzero, return nonzero iff C is a valid normal or
1097 generic character. If GENERICP is zero, return nonzero iff C is a
1098 valid normal character. Do not call this function directly,
1099 instead use macro CHAR_VALID_P. */
1101 char_valid_p (c
, genericp
)
1104 int charset
, c1
, c2
;
1106 if (c
< 0 || c
>= MAX_CHAR
)
1108 if (SINGLE_BYTE_CHAR_P (c
))
1110 SPLIT_CHAR (c
, charset
, c1
, c2
);
1115 if (c2
<= 0) c2
= 0x20;
1119 if (c2
<= 0) c1
= c2
= 0x20;
1122 return (CHARSET_DEFINED_P (charset
)
1123 && CHAR_COMPONENTS_VALID_P (charset
, c1
, c2
));
1126 DEFUN ("char-valid-p", Fchar_valid_p
, Schar_valid_p
, 1, 2, 0,
1127 doc
: /* Return t if OBJECT is a valid normal character.
1128 If optional arg GENERICP is non-nil, also return t if OBJECT is
1129 a valid generic character. */)
1131 Lisp_Object object
, genericp
;
1133 if (! NATNUMP (object
))
1135 return (CHAR_VALID_P (XFASTINT (object
), !NILP (genericp
)) ? Qt
: Qnil
);
1138 DEFUN ("unibyte-char-to-multibyte", Funibyte_char_to_multibyte
,
1139 Sunibyte_char_to_multibyte
, 1, 1, 0,
1140 doc
: /* Convert the unibyte character CH to multibyte character.
1141 The conversion is done based on `nonascii-translation-table' (which see)
1142 or `nonascii-insert-offset' (which see). */)
1150 if (c
< 0 || c
>= 0400)
1151 error ("Invalid unibyte character: %d", c
);
1152 c
= unibyte_char_to_multibyte (c
);
1154 error ("Can't convert to multibyte character: %d", XINT (ch
));
1155 return make_number (c
);
1158 DEFUN ("multibyte-char-to-unibyte", Fmultibyte_char_to_unibyte
,
1159 Smultibyte_char_to_unibyte
, 1, 1, 0,
1160 doc
: /* Convert the multibyte character CH to unibyte character.
1161 The conversion is done based on `nonascii-translation-table' (which see)
1162 or `nonascii-insert-offset' (which see). */)
1170 if (! CHAR_VALID_P (c
, 0))
1171 error ("Invalid multibyte character: %d", c
);
1172 c
= multibyte_char_to_unibyte (c
, Qnil
);
1174 error ("Can't convert to unibyte character: %d", XINT (ch
));
1175 return make_number (c
);
1178 DEFUN ("char-bytes", Fchar_bytes
, Schar_bytes
, 1, 1, 0,
1179 doc
: /* Return 1 regardless of the argument CHAR.
1180 This is now an obsolete function. We keep it just for backward compatibility. */)
1185 return make_number (1);
1188 /* Return how many bytes C will occupy in a multibyte buffer.
1189 Don't call this function directly, instead use macro CHAR_BYTES. */
1196 if (ASCII_BYTE_P (c
) || (c
& ~((1 << CHARACTERBITS
) -1)))
1198 if (SINGLE_BYTE_CHAR_P (c
) && c
>= 0xA0)
1201 charset
= CHAR_CHARSET (c
);
1202 return (CHARSET_DEFINED_P (charset
) ? CHARSET_BYTES (charset
) : 1);
1205 /* Return the width of character of which multi-byte form starts with
1206 C. The width is measured by how many columns occupied on the
1207 screen when displayed in the current buffer. */
1209 #define ONE_BYTE_CHAR_WIDTH(c) \
1212 ? XFASTINT (current_buffer->tab_width) \
1213 : (c == '\n' ? 0 : (NILP (current_buffer->ctl_arrow) ? 4 : 2))) \
1217 ? (NILP (current_buffer->ctl_arrow) ? 4 : 2) \
1218 : ((! NILP (current_buffer->enable_multibyte_characters) \
1219 && BASE_LEADING_CODE_P (c)) \
1220 ? WIDTH_BY_CHAR_HEAD (c) \
1223 DEFUN ("char-width", Fchar_width
, Schar_width
, 1, 1, 0,
1224 doc
: /* Return width of CHAR when displayed in the current buffer.
1225 The width is measured by how many columns it occupies on the screen.
1226 Tab is taken to occupy `tab-width' columns. */)
1230 Lisp_Object val
, disp
;
1232 struct Lisp_Char_Table
*dp
= buffer_display_table ();
1238 /* Get the way the display table would display it. */
1239 disp
= dp
? DISP_CHAR_VECTOR (dp
, c
) : Qnil
;
1242 XSETINT (val
, XVECTOR (disp
)->size
);
1243 else if (SINGLE_BYTE_CHAR_P (c
))
1244 XSETINT (val
, ONE_BYTE_CHAR_WIDTH (c
));
1247 int charset
= CHAR_CHARSET (c
);
1249 XSETFASTINT (val
, CHARSET_WIDTH (charset
));
1254 /* Return width of string STR of length LEN when displayed in the
1255 current buffer. The width is measured by how many columns it
1256 occupies on the screen. */
1263 return c_string_width (str
, len
, -1, NULL
, NULL
);
1266 /* Return width of string STR of length LEN when displayed in the
1267 current buffer. The width is measured by how many columns it
1268 occupies on the screen. If PRECISION > 0, return the width of
1269 longest substring that doesn't exceed PRECISION, and set number of
1270 characters and bytes of the substring in *NCHARS and *NBYTES
1274 c_string_width (str
, len
, precision
, nchars
, nbytes
)
1276 int precision
, *nchars
, *nbytes
;
1278 int i
= 0, i_byte
= 0;
1281 struct Lisp_Char_Table
*dp
= buffer_display_table ();
1283 while (i_byte
< len
)
1285 int bytes
, thiswidth
;
1290 int c
= STRING_CHAR_AND_LENGTH (str
+ i_byte
, len
- i_byte
, bytes
);
1293 val
= DISP_CHAR_VECTOR (dp
, c
);
1295 thiswidth
= XVECTOR (val
)->size
;
1297 thiswidth
= ONE_BYTE_CHAR_WIDTH (str
[i_byte
]);
1302 PARSE_MULTIBYTE_SEQ (str
+ i_byte
, len
- i_byte
, bytes
);
1303 thiswidth
= ONE_BYTE_CHAR_WIDTH (str
[i_byte
]);
1307 && (width
+ thiswidth
> precision
))
1327 /* Return width of Lisp string STRING when displayed in the current
1328 buffer. The width is measured by how many columns it occupies on
1329 the screen while paying attention to compositions. If PRECISION >
1330 0, return the width of longest substring that doesn't exceed
1331 PRECISION, and set number of characters and bytes of the substring
1332 in *NCHARS and *NBYTES respectively. */
1335 lisp_string_width (string
, precision
, nchars
, nbytes
)
1337 int precision
, *nchars
, *nbytes
;
1339 int len
= XSTRING (string
)->size
;
1340 int len_byte
= STRING_BYTES (XSTRING (string
));
1341 unsigned char *str
= XSTRING (string
)->data
;
1342 int i
= 0, i_byte
= 0;
1344 struct Lisp_Char_Table
*dp
= buffer_display_table ();
1348 int chars
, bytes
, thiswidth
;
1353 if (find_composition (i
, -1, &ignore
, &end
, &val
, string
)
1354 && ((cmp_id
= get_composition_id (i
, i_byte
, end
- i
, val
, string
))
1357 thiswidth
= composition_table
[cmp_id
]->width
;
1359 bytes
= string_char_to_byte (string
, end
) - i_byte
;
1363 int c
= STRING_CHAR_AND_LENGTH (str
+ i_byte
, len
- i_byte
, bytes
);
1366 val
= DISP_CHAR_VECTOR (dp
, c
);
1368 thiswidth
= XVECTOR (val
)->size
;
1370 thiswidth
= ONE_BYTE_CHAR_WIDTH (str
[i_byte
]);
1375 PARSE_MULTIBYTE_SEQ (str
+ i_byte
, len_byte
- i_byte
, bytes
);
1376 thiswidth
= ONE_BYTE_CHAR_WIDTH (str
[i_byte
]);
1380 && (width
+ thiswidth
> precision
))
1400 DEFUN ("string-width", Fstring_width
, Sstring_width
, 1, 1, 0,
1401 doc
: /* Return width of STRING when displayed in the current buffer.
1402 Width is measured by how many columns it occupies on the screen.
1403 When calculating width of a multibyte character in STRING,
1404 only the base leading-code is considered; the validity of
1405 the following bytes is not checked. Tabs in STRING are always
1406 taken to occupy `tab-width' columns. */)
1413 XSETFASTINT (val
, lisp_string_width (str
, -1, NULL
, NULL
));
1417 DEFUN ("char-direction", Fchar_direction
, Schar_direction
, 1, 1, 0,
1418 doc
: /* Return the direction of CHAR.
1419 The returned value is 0 for left-to-right and 1 for right-to-left. */)
1426 charset
= CHAR_CHARSET (XFASTINT (ch
));
1427 if (!CHARSET_DEFINED_P (charset
))
1428 invalid_character (XINT (ch
));
1429 return CHARSET_TABLE_INFO (charset
, CHARSET_DIRECTION_IDX
);
1432 DEFUN ("chars-in-region", Fchars_in_region
, Schars_in_region
, 2, 2, 0,
1433 doc
: /* Return number of characters between BEG and END. */)
1435 Lisp_Object beg
, end
;
1439 CHECK_NUMBER_COERCE_MARKER (beg
);
1440 CHECK_NUMBER_COERCE_MARKER (end
);
1442 from
= min (XFASTINT (beg
), XFASTINT (end
));
1443 to
= max (XFASTINT (beg
), XFASTINT (end
));
1445 return make_number (to
- from
);
1448 /* Return the number of characters in the NBYTES bytes at PTR.
1449 This works by looking at the contents and checking for multibyte sequences.
1450 However, if the current buffer has enable-multibyte-characters = nil,
1451 we treat each byte as a character. */
1454 chars_in_text (ptr
, nbytes
)
1458 /* current_buffer is null at early stages of Emacs initialization. */
1459 if (current_buffer
== 0
1460 || NILP (current_buffer
->enable_multibyte_characters
))
1463 return multibyte_chars_in_text (ptr
, nbytes
);
1466 /* Return the number of characters in the NBYTES bytes at PTR.
1467 This works by looking at the contents and checking for multibyte sequences.
1468 It ignores enable-multibyte-characters. */
1471 multibyte_chars_in_text (ptr
, nbytes
)
1475 unsigned char *endp
;
1478 endp
= ptr
+ nbytes
;
1483 PARSE_MULTIBYTE_SEQ (ptr
, endp
- ptr
, bytes
);
1491 /* Parse unibyte text at STR of LEN bytes as multibyte text, and
1492 count the numbers of characters and bytes in it. On counting
1493 bytes, pay attention to the fact that 8-bit characters in the range
1494 0x80..0x9F are represented by 2 bytes in multibyte text. */
1496 parse_str_as_multibyte (str
, len
, nchars
, nbytes
)
1498 int len
, *nchars
, *nbytes
;
1500 unsigned char *endp
= str
+ len
;
1501 int n
, chars
= 0, bytes
= 0;
1505 if (UNIBYTE_STR_AS_MULTIBYTE_P (str
, endp
- str
, n
))
1506 str
+= n
, bytes
+= n
;
1516 /* Arrange unibyte text at STR of NBYTES bytes as multibyte text.
1517 It actually converts only 8-bit characters in the range 0x80..0x9F
1518 that don't contruct multibyte characters to multibyte forms. If
1519 NCHARS is nonzero, set *NCHARS to the number of characters in the
1520 text. It is assured that we can use LEN bytes at STR as a work
1521 area and that is enough. Return the number of bytes of the
1525 str_as_multibyte (str
, len
, nbytes
, nchars
)
1527 int len
, nbytes
, *nchars
;
1529 unsigned char *p
= str
, *endp
= str
+ nbytes
;
1534 while (p
< endp
&& UNIBYTE_STR_AS_MULTIBYTE_P (p
, endp
- p
, n
))
1544 safe_bcopy (p
, endp
- nbytes
, nbytes
);
1548 if (UNIBYTE_STR_AS_MULTIBYTE_P (p
, endp
- p
, n
))
1555 *to
++ = LEADING_CODE_8_BIT_CONTROL
;
1556 *to
++ = *p
++ + 0x20;
1565 /* Parse unibyte string at STR of LEN bytes, and return the number of
1566 bytes it may ocupy when converted to multibyte string by
1567 `str_to_multibyte'. */
1570 parse_str_to_multibyte (str
, len
)
1574 unsigned char *endp
= str
+ len
;
1577 for (bytes
= 0; str
< endp
; str
++)
1578 bytes
+= (*str
< 0x80 || *str
>= 0xA0) ? 1 : 2;
1582 /* Convert unibyte text at STR of NBYTES bytes to multibyte text
1583 that contains the same single-byte characters. It actually
1584 converts all 8-bit characters to multibyte forms. It is assured
1585 that we can use LEN bytes at STR as a work area and that is
1589 str_to_multibyte (str
, len
, bytes
)
1593 unsigned char *p
= str
, *endp
= str
+ bytes
;
1596 while (p
< endp
&& (*p
< 0x80 || *p
>= 0xA0)) p
++;
1602 safe_bcopy (p
, endp
- bytes
, bytes
);
1606 if (*p
< 0x80 || *p
>= 0xA0)
1609 *to
++ = LEADING_CODE_8_BIT_CONTROL
, *to
++ = *p
++ + 0x20;
1614 /* Arrange multibyte text at STR of LEN bytes as a unibyte text. It
1615 actually converts only 8-bit characters in the range 0x80..0x9F to
1619 str_as_unibyte (str
, bytes
)
1623 unsigned char *p
= str
, *endp
= str
+ bytes
;
1624 unsigned char *to
= str
;
1626 while (p
< endp
&& *p
!= LEADING_CODE_8_BIT_CONTROL
) p
++;
1630 if (*p
== LEADING_CODE_8_BIT_CONTROL
)
1631 *to
++ = *(p
+ 1) - 0x20, p
+= 2;
1639 DEFUN ("string", Fstring
, Sstring
, 0, MANY
, 0,
1640 doc
: /* Concatenate all the argument characters and make the result a string.
1641 usage: (string &rest CHARACTERS) */)
1647 unsigned char *buf
= (unsigned char *) alloca (MAX_MULTIBYTE_LENGTH
* n
);
1648 unsigned char *p
= buf
;
1652 for (i
= 0; i
< n
; i
++)
1654 CHECK_NUMBER (args
[i
]);
1655 if (!multibyte
&& !SINGLE_BYTE_CHAR_P (XFASTINT (args
[i
])))
1659 for (i
= 0; i
< n
; i
++)
1663 p
+= CHAR_STRING (c
, p
);
1668 return make_string_from_bytes (buf
, n
, p
- buf
);
1674 charset_id_internal (charset_name
)
1679 val
= Fget (intern (charset_name
), Qcharset
);
1681 error ("Charset %s is not defined", charset_name
);
1683 return (XINT (XVECTOR (val
)->contents
[0]));
1686 DEFUN ("setup-special-charsets", Fsetup_special_charsets
,
1687 Ssetup_special_charsets
, 0, 0, 0, doc
: /* Internal use only. */)
1690 charset_latin_iso8859_1
= charset_id_internal ("latin-iso8859-1");
1691 charset_jisx0208_1978
= charset_id_internal ("japanese-jisx0208-1978");
1692 charset_jisx0208
= charset_id_internal ("japanese-jisx0208");
1693 charset_katakana_jisx0201
= charset_id_internal ("katakana-jisx0201");
1694 charset_latin_jisx0201
= charset_id_internal ("latin-jisx0201");
1695 charset_big5_1
= charset_id_internal ("chinese-big5-1");
1696 charset_big5_2
= charset_id_internal ("chinese-big5-2");
1701 init_charset_once ()
1705 staticpro (&Vcharset_table
);
1706 staticpro (&Vcharset_symbol_table
);
1707 staticpro (&Vgeneric_character_list
);
1709 /* This has to be done here, before we call Fmake_char_table. */
1710 Qcharset_table
= intern ("charset-table");
1711 staticpro (&Qcharset_table
);
1713 /* Intern this now in case it isn't already done.
1714 Setting this variable twice is harmless.
1715 But don't staticpro it here--that is done in alloc.c. */
1716 Qchar_table_extra_slots
= intern ("char-table-extra-slots");
1718 /* Now we are ready to set up this property, so we can
1719 create the charset table. */
1720 Fput (Qcharset_table
, Qchar_table_extra_slots
, make_number (0));
1721 Vcharset_table
= Fmake_char_table (Qcharset_table
, Qnil
);
1723 Qunknown
= intern ("unknown");
1724 staticpro (&Qunknown
);
1725 Vcharset_symbol_table
= Fmake_vector (make_number (MAX_CHARSET
+ 1),
1729 for (i
= 0; i
< 2; i
++)
1730 for (j
= 0; j
< 2; j
++)
1731 for (k
= 0; k
< 128; k
++)
1732 iso_charset_table
[i
][j
][k
] = -1;
1734 for (i
= 0; i
< 256; i
++)
1735 bytes_by_char_head
[i
] = 1;
1736 bytes_by_char_head
[LEADING_CODE_PRIVATE_11
] = 3;
1737 bytes_by_char_head
[LEADING_CODE_PRIVATE_12
] = 3;
1738 bytes_by_char_head
[LEADING_CODE_PRIVATE_21
] = 4;
1739 bytes_by_char_head
[LEADING_CODE_PRIVATE_22
] = 4;
1741 for (i
= 0; i
< 128; i
++)
1742 width_by_char_head
[i
] = 1;
1743 for (; i
< 256; i
++)
1744 width_by_char_head
[i
] = 4;
1745 width_by_char_head
[LEADING_CODE_PRIVATE_11
] = 1;
1746 width_by_char_head
[LEADING_CODE_PRIVATE_12
] = 2;
1747 width_by_char_head
[LEADING_CODE_PRIVATE_21
] = 1;
1748 width_by_char_head
[LEADING_CODE_PRIVATE_22
] = 2;
1754 for (i
= 0x81; i
< 0x90; i
++)
1755 val
= Fcons (make_number ((i
- 0x70) << 7), val
);
1756 for (; i
< 0x9A; i
++)
1757 val
= Fcons (make_number ((i
- 0x8F) << 14), val
);
1758 for (i
= 0xA0; i
< 0xF0; i
++)
1759 val
= Fcons (make_number ((i
- 0x70) << 7), val
);
1760 for (; i
< 0xFF; i
++)
1761 val
= Fcons (make_number ((i
- 0xE0) << 14), val
);
1762 Vgeneric_character_list
= Fnreverse (val
);
1765 nonascii_insert_offset
= 0;
1766 Vnonascii_translation_table
= Qnil
;
1774 Qcharset
= intern ("charset");
1775 staticpro (&Qcharset
);
1777 Qascii
= intern ("ascii");
1778 staticpro (&Qascii
);
1780 Qeight_bit_control
= intern ("eight-bit-control");
1781 staticpro (&Qeight_bit_control
);
1783 Qeight_bit_graphic
= intern ("eight-bit-graphic");
1784 staticpro (&Qeight_bit_graphic
);
1786 /* Define special charsets ascii, eight-bit-control, and
1787 eight-bit-graphic. */
1788 update_charset_table (make_number (CHARSET_ASCII
),
1789 make_number (1), make_number (94),
1794 build_string ("ASCII"),
1795 Qnil
, /* same as above */
1796 build_string ("ASCII (ISO646 IRV)"));
1797 CHARSET_SYMBOL (CHARSET_ASCII
) = Qascii
;
1798 Fput (Qascii
, Qcharset
, CHARSET_TABLE_ENTRY (CHARSET_ASCII
));
1800 update_charset_table (make_number (CHARSET_8_BIT_CONTROL
),
1801 make_number (1), make_number (96),
1806 build_string ("8-bit control code (0x80..0x9F)"),
1807 Qnil
, /* same as above */
1808 Qnil
); /* same as above */
1809 CHARSET_SYMBOL (CHARSET_8_BIT_CONTROL
) = Qeight_bit_control
;
1810 Fput (Qeight_bit_control
, Qcharset
,
1811 CHARSET_TABLE_ENTRY (CHARSET_8_BIT_CONTROL
));
1813 update_charset_table (make_number (CHARSET_8_BIT_GRAPHIC
),
1814 make_number (1), make_number (96),
1819 build_string ("8-bit graphic char (0xA0..0xFF)"),
1820 Qnil
, /* same as above */
1821 Qnil
); /* same as above */
1822 CHARSET_SYMBOL (CHARSET_8_BIT_GRAPHIC
) = Qeight_bit_graphic
;
1823 Fput (Qeight_bit_graphic
, Qcharset
,
1824 CHARSET_TABLE_ENTRY (CHARSET_8_BIT_GRAPHIC
));
1826 Qauto_fill_chars
= intern ("auto-fill-chars");
1827 staticpro (&Qauto_fill_chars
);
1828 Fput (Qauto_fill_chars
, Qchar_table_extra_slots
, make_number (0));
1830 defsubr (&Sdefine_charset
);
1831 defsubr (&Sgeneric_character_list
);
1832 defsubr (&Sget_unused_iso_final_char
);
1833 defsubr (&Sdeclare_equiv_charset
);
1834 defsubr (&Sfind_charset_region
);
1835 defsubr (&Sfind_charset_string
);
1836 defsubr (&Smake_char_internal
);
1837 defsubr (&Ssplit_char
);
1838 defsubr (&Schar_charset
);
1839 defsubr (&Scharset_after
);
1840 defsubr (&Siso_charset
);
1841 defsubr (&Schar_valid_p
);
1842 defsubr (&Sunibyte_char_to_multibyte
);
1843 defsubr (&Smultibyte_char_to_unibyte
);
1844 defsubr (&Schar_bytes
);
1845 defsubr (&Schar_width
);
1846 defsubr (&Sstring_width
);
1847 defsubr (&Schar_direction
);
1848 defsubr (&Schars_in_region
);
1850 defsubr (&Ssetup_special_charsets
);
1852 DEFVAR_LISP ("charset-list", &Vcharset_list
,
1853 doc
: /* List of charsets ever defined. */);
1854 Vcharset_list
= Fcons (Qascii
, Fcons (Qeight_bit_control
,
1855 Fcons (Qeight_bit_graphic
, Qnil
)));
1857 DEFVAR_LISP ("translation-table-vector", &Vtranslation_table_vector
,
1858 doc
: /* Vector of cons cell of a symbol and translation table ever defined.
1859 An ID of a translation table is an index of this vector. */);
1860 Vtranslation_table_vector
= Fmake_vector (make_number (16), Qnil
);
1862 DEFVAR_INT ("leading-code-private-11", &leading_code_private_11
,
1863 doc
: /* Leading-code of private TYPE9N charset of column-width 1. */);
1864 leading_code_private_11
= LEADING_CODE_PRIVATE_11
;
1866 DEFVAR_INT ("leading-code-private-12", &leading_code_private_12
,
1867 doc
: /* Leading-code of private TYPE9N charset of column-width 2. */);
1868 leading_code_private_12
= LEADING_CODE_PRIVATE_12
;
1870 DEFVAR_INT ("leading-code-private-21", &leading_code_private_21
,
1871 doc
: /* Leading-code of private TYPE9Nx9N charset of column-width 1. */);
1872 leading_code_private_21
= LEADING_CODE_PRIVATE_21
;
1874 DEFVAR_INT ("leading-code-private-22", &leading_code_private_22
,
1875 doc
: /* Leading-code of private TYPE9Nx9N charset of column-width 2. */);
1876 leading_code_private_22
= LEADING_CODE_PRIVATE_22
;
1878 DEFVAR_INT ("nonascii-insert-offset", &nonascii_insert_offset
,
1879 doc
: /* Offset for converting non-ASCII unibyte codes 0240...0377 to multibyte.
1880 This is used for converting unibyte text to multibyte,
1881 and for inserting character codes specified by number.
1883 This serves to convert a Latin-1 or similar 8-bit character code
1884 to the corresponding Emacs multibyte character code.
1885 Typically the value should be (- (make-char CHARSET 0) 128),
1886 for your choice of character set.
1887 If `nonascii-translation-table' is non-nil, it overrides this variable. */);
1888 nonascii_insert_offset
= 0;
1890 DEFVAR_LISP ("nonascii-translation-table", &Vnonascii_translation_table
,
1891 doc
: /* Translation table to convert non-ASCII unibyte codes to multibyte.
1892 This is used for converting unibyte text to multibyte,
1893 and for inserting character codes specified by number.
1895 Conversion is performed only when multibyte characters are enabled,
1896 and it serves to convert a Latin-1 or similar 8-bit character code
1897 to the corresponding Emacs character code.
1899 If this is nil, `nonascii-insert-offset' is used instead.
1900 See also the docstring of `make-translation-table'. */);
1901 Vnonascii_translation_table
= Qnil
;
1903 DEFVAR_LISP ("auto-fill-chars", &Vauto_fill_chars
,
1904 doc
: /* A char-table for characters which invoke auto-filling.
1905 Such characters have value t in this table. */);
1906 Vauto_fill_chars
= Fmake_char_table (Qauto_fill_chars
, Qnil
);
1907 CHAR_TABLE_SET (Vauto_fill_chars
, make_number (' '), Qt
);
1908 CHAR_TABLE_SET (Vauto_fill_chars
, make_number ('\n'), Qt
);