1 /* Basic character support.
3 Copyright (C) 2001-2012 Free Software Foundation, Inc.
4 Copyright (C) 1995, 1997, 1998, 2001 Electrotechnical Laboratory, JAPAN.
5 Licensed to the Free Software Foundation.
6 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
7 National Institute of Advanced Industrial Science and Technology (AIST)
8 Registration Number H13PRO009
10 This file is part of GNU Emacs.
12 GNU Emacs is free software: you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation, either version 3 of the License, or
15 (at your option) any later version.
17 GNU Emacs is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
22 You should have received a copy of the GNU General Public License
23 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
25 /* At first, see the document in `character.h' to understand the code
32 #define CHARACTER_INLINE EXTERN_INLINE
38 #include <sys/types.h>
42 #include "character.h"
45 #include "composite.h"
54 Lisp_Object Qcharacterp
;
56 static Lisp_Object Qauto_fill_chars
;
58 /* Char-table of information about which character to unify to which
59 Unicode character. Mainly used by the macro MAYBE_UNIFY_CHAR. */
60 Lisp_Object Vchar_unify_table
;
62 static Lisp_Object Qchar_script_table
;
66 /* If character code C has modifier masks, reflect them to the
67 character code if possible. Return the resulting code. */
70 char_resolve_modifier_mask (EMACS_INT c
)
72 /* A non-ASCII character can't reflect modifier bits to the code. */
73 if (! ASCII_CHAR_P ((c
& ~CHAR_MODIFIER_MASK
)))
76 /* For Meta, Shift, and Control modifiers, we need special care. */
79 /* Shift modifier is valid only with [A-Za-z]. */
80 if ((c
& 0377) >= 'A' && (c
& 0377) <= 'Z')
82 else if ((c
& 0377) >= 'a' && (c
& 0377) <= 'z')
83 c
= (c
& ~CHAR_SHIFT
) - ('a' - 'A');
84 /* Shift modifier for control characters and SPC is ignored. */
85 else if ((c
& ~CHAR_MODIFIER_MASK
) <= 0x20)
90 /* Simulate the code in lread.c. */
91 /* Allow `\C- ' and `\C-?'. */
92 if ((c
& 0377) == ' ')
93 c
&= ~0177 & ~ CHAR_CTL
;
94 else if ((c
& 0377) == '?')
95 c
= 0177 | (c
& ~0177 & ~CHAR_CTL
);
96 /* ASCII control chars are made from letters (both cases),
97 as well as the non-letters within 0100...0137. */
98 else if ((c
& 0137) >= 0101 && (c
& 0137) <= 0132)
99 c
&= (037 | (~0177 & ~CHAR_CTL
));
100 else if ((c
& 0177) >= 0100 && (c
& 0177) <= 0137)
101 c
&= (037 | (~0177 & ~CHAR_CTL
));
103 #if 0 /* This is outside the scope of this function. (bug#4751) */
106 /* Move the meta bit to the right place for a string. */
107 c
= (c
& ~CHAR_META
) | 0x80;
115 /* Store multibyte form of character C at P. If C has modifier bits,
116 handle them appropriately. */
119 char_string (unsigned int c
, unsigned char *p
)
123 if (c
& CHAR_MODIFIER_MASK
)
125 c
= char_resolve_modifier_mask (c
);
126 /* If C still has any modifier bits, just ignore it. */
127 c
&= ~CHAR_MODIFIER_MASK
;
130 MAYBE_UNIFY_CHAR (c
);
132 if (c
<= MAX_3_BYTE_CHAR
)
134 bytes
= CHAR_STRING (c
, p
);
136 else if (c
<= MAX_4_BYTE_CHAR
)
138 p
[0] = (0xF0 | (c
>> 18));
139 p
[1] = (0x80 | ((c
>> 12) & 0x3F));
140 p
[2] = (0x80 | ((c
>> 6) & 0x3F));
141 p
[3] = (0x80 | (c
& 0x3F));
144 else if (c
<= MAX_5_BYTE_CHAR
)
147 p
[1] = (0x80 | ((c
>> 18) & 0x0F));
148 p
[2] = (0x80 | ((c
>> 12) & 0x3F));
149 p
[3] = (0x80 | ((c
>> 6) & 0x3F));
150 p
[4] = (0x80 | (c
& 0x3F));
153 else if (c
<= MAX_CHAR
)
155 c
= CHAR_TO_BYTE8 (c
);
156 bytes
= BYTE8_STRING (c
, p
);
159 error ("Invalid character: %x", c
);
165 /* Return a character whose multibyte form is at P. If LEN is not
166 NULL, it must be a pointer to integer. In that case, set *LEN to
167 the byte length of the multibyte form. If ADVANCED is not NULL, it
168 must be a pointer to unsigned char. In that case, set *ADVANCED to
169 the ending address (i.e., the starting address of the next
170 character) of the multibyte form. */
173 string_char (const unsigned char *p
, const unsigned char **advanced
, int *len
)
176 const unsigned char *saved_p
= p
;
178 if (*p
< 0x80 || ! (*p
& 0x20) || ! (*p
& 0x10))
180 c
= STRING_CHAR_ADVANCE (p
);
182 else if (! (*p
& 0x08))
184 c
= ((((p
)[0] & 0xF) << 18)
185 | (((p
)[1] & 0x3F) << 12)
186 | (((p
)[2] & 0x3F) << 6)
192 c
= ((((p
)[1] & 0x3F) << 18)
193 | (((p
)[2] & 0x3F) << 12)
194 | (((p
)[3] & 0x3F) << 6)
199 MAYBE_UNIFY_CHAR (c
);
209 /* Translate character C by translation table TABLE. If no translation is
210 found in TABLE, return the untranslated character. If TABLE is a list,
211 elements are char tables. In that case, recursively translate C by all the
212 tables in the list. */
215 translate_char (Lisp_Object table
, int c
)
217 if (CHAR_TABLE_P (table
))
221 ch
= CHAR_TABLE_REF (table
, c
);
227 for (; CONSP (table
); table
= XCDR (table
))
228 c
= translate_char (XCAR (table
), c
);
233 /* Convert ASCII or 8-bit character C to unibyte. If C is none of
234 them, return (C & 0xFF). */
237 multibyte_char_to_unibyte (int c
)
241 if (CHAR_BYTE8_P (c
))
242 return CHAR_TO_BYTE8 (c
);
246 /* Like multibyte_char_to_unibyte, but return -1 if C is not supported
247 by charset_unibyte. */
250 multibyte_char_to_unibyte_safe (int c
)
254 if (CHAR_BYTE8_P (c
))
255 return CHAR_TO_BYTE8 (c
);
259 DEFUN ("characterp", Fcharacterp
, Scharacterp
, 1, 2, 0,
260 doc
: /* Return non-nil if OBJECT is a character.
261 In Emacs Lisp, characters are represented by character codes, which
262 are non-negative integers. The function `max-char' returns the
263 maximum character code.
264 usage: (characterp OBJECT) */)
265 (Lisp_Object object
, Lisp_Object ignore
)
267 return (CHARACTERP (object
) ? Qt
: Qnil
);
270 DEFUN ("max-char", Fmax_char
, Smax_char
, 0, 0, 0,
271 doc
: /* Return the character of the maximum code. */)
274 return make_number (MAX_CHAR
);
277 DEFUN ("unibyte-char-to-multibyte", Funibyte_char_to_multibyte
,
278 Sunibyte_char_to_multibyte
, 1, 1, 0,
279 doc
: /* Convert the byte CH to multibyte character. */)
284 CHECK_CHARACTER (ch
);
287 error ("Not a unibyte character: %d", c
);
288 MAKE_CHAR_MULTIBYTE (c
);
289 return make_number (c
);
292 DEFUN ("multibyte-char-to-unibyte", Fmultibyte_char_to_unibyte
,
293 Smultibyte_char_to_unibyte
, 1, 1, 0,
294 doc
: /* Convert the multibyte character CH to a byte.
295 If the multibyte character does not represent a byte, return -1. */)
300 CHECK_CHARACTER (ch
);
303 /* Can't distinguish a byte read from a unibyte buffer from
304 a latin1 char, so let's let it slide. */
308 int cu
= CHAR_TO_BYTE_SAFE (cm
);
309 return make_number (cu
);
314 /* Return width (columns) of C considering the buffer display table DP. */
317 char_width (int c
, struct Lisp_Char_Table
*dp
)
319 ptrdiff_t width
= CHAR_WIDTH (c
);
323 Lisp_Object disp
= DISP_CHAR_VECTOR (dp
, c
), ch
;
327 for (i
= 0, width
= 0; i
< ASIZE (disp
); i
++)
332 int w
= CHAR_WIDTH (XFASTINT (ch
));
333 if (INT_ADD_OVERFLOW (width
, w
))
343 DEFUN ("char-width", Fchar_width
, Schar_width
, 1, 1, 0,
344 doc
: /* Return width of CHAR when displayed in the current buffer.
345 The width is measured by how many columns it occupies on the screen.
346 Tab is taken to occupy `tab-width' columns.
347 usage: (char-width CHAR) */)
353 CHECK_CHARACTER (ch
);
355 width
= char_width (c
, buffer_display_table ());
356 return make_number (width
);
359 /* Return width of string STR of length LEN when displayed in the
360 current buffer. The width is measured by how many columns it
361 occupies on the screen. If PRECISION > 0, return the width of
362 longest substring that doesn't exceed PRECISION, and set number of
363 characters and bytes of the substring in *NCHARS and *NBYTES
367 c_string_width (const unsigned char *str
, ptrdiff_t len
, int precision
,
368 ptrdiff_t *nchars
, ptrdiff_t *nbytes
)
370 ptrdiff_t i
= 0, i_byte
= 0;
372 struct Lisp_Char_Table
*dp
= buffer_display_table ();
377 int c
= STRING_CHAR_AND_LENGTH (str
+ i_byte
, bytes
);
378 ptrdiff_t thiswidth
= char_width (c
, dp
);
382 if (INT_ADD_OVERFLOW (width
, thiswidth
))
385 else if (precision
- width
< thiswidth
)
405 /* Return width of string STR of length LEN when displayed in the
406 current buffer. The width is measured by how many columns it
407 occupies on the screen. */
410 strwidth (const char *str
, ptrdiff_t len
)
412 return c_string_width ((const unsigned char *) str
, len
, -1, NULL
, NULL
);
415 /* Return width of Lisp string STRING when displayed in the current
416 buffer. The width is measured by how many columns it occupies on
417 the screen while paying attention to compositions. If PRECISION >
418 0, return the width of longest substring that doesn't exceed
419 PRECISION, and set number of characters and bytes of the substring
420 in *NCHARS and *NBYTES respectively. */
423 lisp_string_width (Lisp_Object string
, ptrdiff_t precision
,
424 ptrdiff_t *nchars
, ptrdiff_t *nbytes
)
426 ptrdiff_t len
= SCHARS (string
);
427 /* This set multibyte to 0 even if STRING is multibyte when it
428 contains only ascii and eight-bit-graphic, but that's
430 bool multibyte
= len
< SBYTES (string
);
431 unsigned char *str
= SDATA (string
);
432 ptrdiff_t i
= 0, i_byte
= 0;
434 struct Lisp_Char_Table
*dp
= buffer_display_table ();
438 ptrdiff_t chars
, bytes
, thiswidth
;
441 ptrdiff_t ignore
, end
;
443 if (find_composition (i
, -1, &ignore
, &end
, &val
, string
)
444 && ((cmp_id
= get_composition_id (i
, i_byte
, end
- i
, val
, string
))
447 thiswidth
= composition_table
[cmp_id
]->width
;
449 bytes
= string_char_to_byte (string
, end
) - i_byte
;
458 c
= STRING_CHAR_AND_LENGTH (str
+ i_byte
, cbytes
);
462 c
= str
[i_byte
], bytes
= 1;
464 thiswidth
= char_width (c
, dp
);
470 if (INT_ADD_OVERFLOW (width
, thiswidth
))
474 else if (precision
- width
< thiswidth
)
494 DEFUN ("string-width", Fstring_width
, Sstring_width
, 1, 1, 0,
495 doc
: /* Return width of STRING when displayed in the current buffer.
496 Width is measured by how many columns it occupies on the screen.
497 When calculating width of a multibyte character in STRING,
498 only the base leading-code is considered; the validity of
499 the following bytes is not checked. Tabs in STRING are always
500 taken to occupy `tab-width' columns.
501 usage: (string-width STRING) */)
507 XSETFASTINT (val
, lisp_string_width (str
, -1, NULL
, NULL
));
511 /* Return the number of characters in the NBYTES bytes at PTR.
512 This works by looking at the contents and checking for multibyte
513 sequences while assuming that there's no invalid sequence.
514 However, if the current buffer has enable-multibyte-characters =
515 nil, we treat each byte as a character. */
518 chars_in_text (const unsigned char *ptr
, ptrdiff_t nbytes
)
520 /* current_buffer is null at early stages of Emacs initialization. */
521 if (current_buffer
== 0
522 || NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
525 return multibyte_chars_in_text (ptr
, nbytes
);
528 /* Return the number of characters in the NBYTES bytes at PTR.
529 This works by looking at the contents and checking for multibyte
530 sequences while assuming that there's no invalid sequence. It
531 ignores enable-multibyte-characters. */
534 multibyte_chars_in_text (const unsigned char *ptr
, ptrdiff_t nbytes
)
536 const unsigned char *endp
= ptr
+ nbytes
;
541 int len
= MULTIBYTE_LENGTH (ptr
, endp
);
552 /* Parse unibyte text at STR of LEN bytes as a multibyte text, count
553 characters and bytes in it, and store them in *NCHARS and *NBYTES
554 respectively. On counting bytes, pay attention to that 8-bit
555 characters not constructing a valid multibyte sequence are
556 represented by 2-byte in a multibyte text. */
559 parse_str_as_multibyte (const unsigned char *str
, ptrdiff_t len
,
560 ptrdiff_t *nchars
, ptrdiff_t *nbytes
)
562 const unsigned char *endp
= str
+ len
;
564 ptrdiff_t chars
= 0, bytes
= 0;
566 if (len
>= MAX_MULTIBYTE_LENGTH
)
568 const unsigned char *adjusted_endp
= endp
- MAX_MULTIBYTE_LENGTH
;
569 while (str
< adjusted_endp
)
571 if (! CHAR_BYTE8_HEAD_P (*str
)
572 && (n
= MULTIBYTE_LENGTH_NO_CHECK (str
)) > 0)
573 str
+= n
, bytes
+= n
;
581 if (! CHAR_BYTE8_HEAD_P (*str
)
582 && (n
= MULTIBYTE_LENGTH (str
, endp
)) > 0)
583 str
+= n
, bytes
+= n
;
594 /* Arrange unibyte text at STR of NBYTES bytes as a multibyte text.
595 It actually converts only such 8-bit characters that don't construct
596 a multibyte sequence to multibyte forms of Latin-1 characters. If
597 NCHARS is nonzero, set *NCHARS to the number of characters in the
598 text. It is assured that we can use LEN bytes at STR as a work
599 area and that is enough. Return the number of bytes of the
603 str_as_multibyte (unsigned char *str
, ptrdiff_t len
, ptrdiff_t nbytes
,
606 unsigned char *p
= str
, *endp
= str
+ nbytes
;
611 if (nbytes
>= MAX_MULTIBYTE_LENGTH
)
613 unsigned char *adjusted_endp
= endp
- MAX_MULTIBYTE_LENGTH
;
614 while (p
< adjusted_endp
615 && ! CHAR_BYTE8_HEAD_P (*p
)
616 && (n
= MULTIBYTE_LENGTH_NO_CHECK (p
)) > 0)
620 && ! CHAR_BYTE8_HEAD_P (*p
)
621 && (n
= MULTIBYTE_LENGTH (p
, endp
)) > 0)
631 memmove (endp
- nbytes
, p
, nbytes
);
634 if (nbytes
>= MAX_MULTIBYTE_LENGTH
)
636 unsigned char *adjusted_endp
= endp
- MAX_MULTIBYTE_LENGTH
;
637 while (p
< adjusted_endp
)
639 if (! CHAR_BYTE8_HEAD_P (*p
)
640 && (n
= MULTIBYTE_LENGTH_NO_CHECK (p
)) > 0)
648 c
= BYTE8_TO_CHAR (c
);
649 to
+= CHAR_STRING (c
, to
);
656 if (! CHAR_BYTE8_HEAD_P (*p
)
657 && (n
= MULTIBYTE_LENGTH (p
, endp
)) > 0)
665 c
= BYTE8_TO_CHAR (c
);
666 to
+= CHAR_STRING (c
, to
);
675 /* Parse unibyte string at STR of LEN bytes, and return the number of
676 bytes it may occupy when converted to multibyte string by
677 `str_to_multibyte'. */
680 count_size_as_multibyte (const unsigned char *str
, ptrdiff_t len
)
682 const unsigned char *endp
= str
+ len
;
685 for (bytes
= 0; str
< endp
; str
++)
687 int n
= *str
< 0x80 ? 1 : 2;
688 if (INT_ADD_OVERFLOW (bytes
, n
))
696 /* Convert unibyte text at STR of BYTES bytes to a multibyte text
697 that contains the same single-byte characters. It actually
698 converts all 8-bit characters to multibyte forms. It is assured
699 that we can use LEN bytes at STR as a work area and that is
703 str_to_multibyte (unsigned char *str
, ptrdiff_t len
, ptrdiff_t bytes
)
705 unsigned char *p
= str
, *endp
= str
+ bytes
;
708 while (p
< endp
&& *p
< 0x80) p
++;
714 memmove (endp
- bytes
, p
, bytes
);
721 c
= BYTE8_TO_CHAR (c
);
722 to
+= CHAR_STRING (c
, to
);
727 /* Arrange multibyte text at STR of LEN bytes as a unibyte text. It
728 actually converts characters in the range 0x80..0xFF to
732 str_as_unibyte (unsigned char *str
, ptrdiff_t bytes
)
734 const unsigned char *p
= str
, *endp
= str
+ bytes
;
741 len
= BYTES_BY_CHAR_HEAD (c
);
742 if (CHAR_BYTE8_HEAD_P (c
))
746 to
= str
+ (p
- str
);
750 len
= BYTES_BY_CHAR_HEAD (c
);
751 if (CHAR_BYTE8_HEAD_P (c
))
753 c
= STRING_CHAR_ADVANCE (p
);
754 *to
++ = CHAR_TO_BYTE8 (c
);
758 while (len
--) *to
++ = *p
++;
764 /* Convert eight-bit chars in SRC (in multibyte form) to the
765 corresponding byte and store in DST. CHARS is the number of
766 characters in SRC. The value is the number of bytes stored in DST.
767 Usually, the value is the same as CHARS, but is less than it if SRC
768 contains a non-ASCII, non-eight-bit character. */
771 str_to_unibyte (const unsigned char *src
, unsigned char *dst
, ptrdiff_t chars
)
775 for (i
= 0; i
< chars
; i
++)
777 int c
= STRING_CHAR_ADVANCE (src
);
779 if (CHAR_BYTE8_P (c
))
780 c
= CHAR_TO_BYTE8 (c
);
781 else if (! ASCII_CHAR_P (c
))
790 string_count_byte8 (Lisp_Object string
)
792 bool multibyte
= STRING_MULTIBYTE (string
);
793 ptrdiff_t nbytes
= SBYTES (string
);
794 unsigned char *p
= SDATA (string
);
795 unsigned char *pend
= p
+ nbytes
;
803 len
= BYTES_BY_CHAR_HEAD (c
);
805 if (CHAR_BYTE8_HEAD_P (c
))
820 string_escape_byte8 (Lisp_Object string
)
822 ptrdiff_t nchars
= SCHARS (string
);
823 ptrdiff_t nbytes
= SBYTES (string
);
824 bool multibyte
= STRING_MULTIBYTE (string
);
825 ptrdiff_t byte8_count
;
826 const unsigned char *src
, *src_end
;
831 if (multibyte
&& nchars
== nbytes
)
834 byte8_count
= string_count_byte8 (string
);
836 if (byte8_count
== 0)
841 if ((MOST_POSITIVE_FIXNUM
- nchars
) / 3 < byte8_count
842 || (STRING_BYTES_BOUND
- nbytes
) / 2 < byte8_count
)
845 /* Convert 2-byte sequence of byte8 chars to 4-byte octal. */
846 val
= make_uninit_multibyte_string (nchars
+ byte8_count
* 3,
847 nbytes
+ byte8_count
* 2);
851 if ((STRING_BYTES_BOUND
- nbytes
) / 3 < byte8_count
)
854 /* Convert 1-byte sequence of byte8 chars to 4-byte octal. */
855 val
= make_uninit_string (nbytes
+ byte8_count
* 3);
858 src
= SDATA (string
);
859 src_end
= src
+ nbytes
;
862 while (src
< src_end
)
865 len
= BYTES_BY_CHAR_HEAD (c
);
867 if (CHAR_BYTE8_HEAD_P (c
))
869 c
= STRING_CHAR_ADVANCE (src
);
870 c
= CHAR_TO_BYTE8 (c
);
871 dst
+= sprintf ((char *) dst
, "\\%03o", c
);
874 while (len
--) *dst
++ = *src
++;
877 while (src
< src_end
)
881 dst
+= sprintf ((char *) dst
, "\\%03o", c
);
889 DEFUN ("string", Fstring
, Sstring
, 0, MANY
, 0,
891 Concatenate all the argument characters and make the result a string.
892 usage: (string &rest CHARACTERS) */)
893 (ptrdiff_t n
, Lisp_Object
*args
)
897 unsigned char *buf
, *p
;
901 SAFE_NALLOCA (buf
, MAX_MULTIBYTE_LENGTH
, n
);
904 for (i
= 0; i
< n
; i
++)
906 CHECK_CHARACTER (args
[i
]);
908 p
+= CHAR_STRING (c
, p
);
911 str
= make_string_from_bytes ((char *) buf
, n
, p
- buf
);
916 DEFUN ("unibyte-string", Funibyte_string
, Sunibyte_string
, 0, MANY
, 0,
917 doc
: /* Concatenate all the argument bytes and make the result a unibyte string.
918 usage: (unibyte-string &rest BYTES) */)
919 (ptrdiff_t n
, Lisp_Object
*args
)
924 unsigned char *buf
= SAFE_ALLOCA (n
);
925 unsigned char *p
= buf
;
927 for (i
= 0; i
< n
; i
++)
929 CHECK_RANGED_INTEGER (args
[i
], 0, 255);
930 *p
++ = XINT (args
[i
]);
933 str
= make_string_from_bytes ((char *) buf
, n
, p
- buf
);
938 DEFUN ("char-resolve-modifiers", Fchar_resolve_modifiers
,
939 Schar_resolve_modifiers
, 1, 1, 0,
940 doc
: /* Resolve modifiers in the character CHAR.
941 The value is a character with modifiers resolved into the character
942 code. Unresolved modifiers are kept in the value.
943 usage: (char-resolve-modifiers CHAR) */)
944 (Lisp_Object character
)
948 CHECK_NUMBER (character
);
949 c
= XINT (character
);
950 return make_number (char_resolve_modifier_mask (c
));
953 DEFUN ("get-byte", Fget_byte
, Sget_byte
, 0, 2, 0,
954 doc
: /* Return a byte value of a character at point.
955 Optional 1st arg POSITION, if non-nil, is a position of a character to get
957 Optional 2nd arg STRING, if non-nil, is a string of which first
958 character is a target to get a byte value. In this case, POSITION, if
959 non-nil, is an index of a target character in the string.
961 If the current buffer (or STRING) is multibyte, and the target
962 character is not ASCII nor 8-bit character, an error is signaled. */)
963 (Lisp_Object position
, Lisp_Object string
)
977 CHECK_NUMBER_COERCE_MARKER (position
);
978 if (XINT (position
) < BEGV
|| XINT (position
) >= ZV
)
979 args_out_of_range_3 (position
, make_number (BEGV
), make_number (ZV
));
980 pos
= XFASTINT (position
);
981 p
= CHAR_POS_ADDR (pos
);
983 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
984 return make_number (*p
);
988 CHECK_STRING (string
);
995 CHECK_NATNUM (position
);
996 if (XINT (position
) >= SCHARS (string
))
997 args_out_of_range (string
, position
);
998 pos
= XFASTINT (position
);
999 p
= SDATA (string
) + string_char_to_byte (string
, pos
);
1001 if (! STRING_MULTIBYTE (string
))
1002 return make_number (*p
);
1004 c
= STRING_CHAR (p
);
1005 if (CHAR_BYTE8_P (c
))
1006 c
= CHAR_TO_BYTE8 (c
);
1007 else if (! ASCII_CHAR_P (c
))
1008 error ("Not an ASCII nor an 8-bit character: %d", c
);
1009 return make_number (c
);
1015 syms_of_character (void)
1017 DEFSYM (Qcharacterp
, "characterp");
1018 DEFSYM (Qauto_fill_chars
, "auto-fill-chars");
1020 staticpro (&Vchar_unify_table
);
1021 Vchar_unify_table
= Qnil
;
1023 defsubr (&Smax_char
);
1024 defsubr (&Scharacterp
);
1025 defsubr (&Sunibyte_char_to_multibyte
);
1026 defsubr (&Smultibyte_char_to_unibyte
);
1027 defsubr (&Schar_width
);
1028 defsubr (&Sstring_width
);
1030 defsubr (&Sunibyte_string
);
1031 defsubr (&Schar_resolve_modifiers
);
1032 defsubr (&Sget_byte
);
1034 DEFVAR_LISP ("translation-table-vector", Vtranslation_table_vector
,
1036 Vector recording all translation tables ever defined.
1037 Each element is a pair (SYMBOL . TABLE) relating the table to the
1038 symbol naming it. The ID of a translation table is an index into this vector. */);
1039 Vtranslation_table_vector
= Fmake_vector (make_number (16), Qnil
);
1041 DEFVAR_LISP ("auto-fill-chars", Vauto_fill_chars
,
1043 A char-table for characters which invoke auto-filling.
1044 Such characters have value t in this table. */);
1045 Vauto_fill_chars
= Fmake_char_table (Qauto_fill_chars
, Qnil
);
1046 CHAR_TABLE_SET (Vauto_fill_chars
, ' ', Qt
);
1047 CHAR_TABLE_SET (Vauto_fill_chars
, '\n', Qt
);
1049 DEFVAR_LISP ("char-width-table", Vchar_width_table
,
1051 A char-table for width (columns) of each character. */);
1052 Vchar_width_table
= Fmake_char_table (Qnil
, make_number (1));
1053 char_table_set_range (Vchar_width_table
, 0x80, 0x9F, make_number (4));
1054 char_table_set_range (Vchar_width_table
, MAX_5_BYTE_CHAR
+ 1, MAX_CHAR
,
1057 DEFVAR_LISP ("printable-chars", Vprintable_chars
,
1058 doc
: /* A char-table for each printable character. */);
1059 Vprintable_chars
= Fmake_char_table (Qnil
, Qnil
);
1060 Fset_char_table_range (Vprintable_chars
,
1061 Fcons (make_number (32), make_number (126)), Qt
);
1062 Fset_char_table_range (Vprintable_chars
,
1063 Fcons (make_number (160),
1064 make_number (MAX_5_BYTE_CHAR
)), Qt
);
1066 DEFVAR_LISP ("char-script-table", Vchar_script_table
,
1067 doc
: /* Char table of script symbols.
1068 It has one extra slot whose value is a list of script symbols. */);
1070 /* Intern this now in case it isn't already done.
1071 Setting this variable twice is harmless.
1072 But don't staticpro it here--that is done in alloc.c. */
1073 Qchar_table_extra_slots
= intern_c_string ("char-table-extra-slots");
1074 DEFSYM (Qchar_script_table
, "char-script-table");
1075 Fput (Qchar_script_table
, Qchar_table_extra_slots
, make_number (1));
1076 Vchar_script_table
= Fmake_char_table (Qchar_script_table
, Qnil
);
1078 DEFVAR_LISP ("script-representative-chars", Vscript_representative_chars
,
1079 doc
: /* Alist of scripts vs the representative characters.
1080 Each element is a cons (SCRIPT . CHARS).
1081 SCRIPT is a symbol representing a script or a subgroup of a script.
1082 CHARS is a list or a vector of characters.
1083 If it is a list, all characters in the list are necessary for supporting SCRIPT.
1084 If it is a vector, one of the characters in the vector is necessary.
1085 This variable is used to find a font for a specific script. */);
1086 Vscript_representative_chars
= Qnil
;
1088 DEFVAR_LISP ("unicode-category-table", Vunicode_category_table
,
1089 doc
: /* Char table of Unicode's "General Category".
1090 All Unicode characters have one of the following values (symbol):
1091 Lu, Ll, Lt, Lm, Lo, Mn, Mc, Me, Nd, Nl, No, Pc, Pd, Ps, Pe, Pi, Pf, Po,
1092 Sm, Sc, Sk, So, Zs, Zl, Zp, Cc, Cf, Cs, Co, Cn
1093 See The Unicode Standard for the meaning of those values. */);
1094 /* The correct char-table is setup in characters.el. */
1095 Vunicode_category_table
= Qnil
;