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 int 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. If ACCEPT_LATIN_1
769 is nonzero, a Latin-1 character is accepted and converted to a byte
770 of that character code.
771 Note: Currently the arg ACCEPT_LATIN_1 is not used. */
774 str_to_unibyte (const unsigned char *src
, unsigned char *dst
, ptrdiff_t chars
, int accept_latin_1
)
778 for (i
= 0; i
< chars
; i
++)
780 int c
= STRING_CHAR_ADVANCE (src
);
782 if (CHAR_BYTE8_P (c
))
783 c
= CHAR_TO_BYTE8 (c
);
784 else if (! ASCII_CHAR_P (c
)
785 && (! accept_latin_1
|| c
>= 0x100))
794 string_count_byte8 (Lisp_Object string
)
796 int multibyte
= STRING_MULTIBYTE (string
);
797 ptrdiff_t nbytes
= SBYTES (string
);
798 unsigned char *p
= SDATA (string
);
799 unsigned char *pend
= p
+ nbytes
;
807 len
= BYTES_BY_CHAR_HEAD (c
);
809 if (CHAR_BYTE8_HEAD_P (c
))
824 string_escape_byte8 (Lisp_Object string
)
826 ptrdiff_t nchars
= SCHARS (string
);
827 ptrdiff_t nbytes
= SBYTES (string
);
828 int multibyte
= STRING_MULTIBYTE (string
);
829 ptrdiff_t byte8_count
;
830 const unsigned char *src
, *src_end
;
835 if (multibyte
&& nchars
== nbytes
)
838 byte8_count
= string_count_byte8 (string
);
840 if (byte8_count
== 0)
845 if ((MOST_POSITIVE_FIXNUM
- nchars
) / 3 < byte8_count
846 || (STRING_BYTES_BOUND
- nbytes
) / 2 < byte8_count
)
849 /* Convert 2-byte sequence of byte8 chars to 4-byte octal. */
850 val
= make_uninit_multibyte_string (nchars
+ byte8_count
* 3,
851 nbytes
+ byte8_count
* 2);
855 if ((STRING_BYTES_BOUND
- nbytes
) / 3 < byte8_count
)
858 /* Convert 1-byte sequence of byte8 chars to 4-byte octal. */
859 val
= make_uninit_string (nbytes
+ byte8_count
* 3);
862 src
= SDATA (string
);
863 src_end
= src
+ nbytes
;
866 while (src
< src_end
)
869 len
= BYTES_BY_CHAR_HEAD (c
);
871 if (CHAR_BYTE8_HEAD_P (c
))
873 c
= STRING_CHAR_ADVANCE (src
);
874 c
= CHAR_TO_BYTE8 (c
);
875 dst
+= sprintf ((char *) dst
, "\\%03o", c
);
878 while (len
--) *dst
++ = *src
++;
881 while (src
< src_end
)
885 dst
+= sprintf ((char *) dst
, "\\%03o", c
);
893 DEFUN ("string", Fstring
, Sstring
, 0, MANY
, 0,
895 Concatenate all the argument characters and make the result a string.
896 usage: (string &rest CHARACTERS) */)
897 (ptrdiff_t n
, Lisp_Object
*args
)
901 unsigned char *buf
, *p
;
905 SAFE_NALLOCA (buf
, MAX_MULTIBYTE_LENGTH
, n
);
908 for (i
= 0; i
< n
; i
++)
910 CHECK_CHARACTER (args
[i
]);
912 p
+= CHAR_STRING (c
, p
);
915 str
= make_string_from_bytes ((char *) buf
, n
, p
- buf
);
920 DEFUN ("unibyte-string", Funibyte_string
, Sunibyte_string
, 0, MANY
, 0,
921 doc
: /* Concatenate all the argument bytes and make the result a unibyte string.
922 usage: (unibyte-string &rest BYTES) */)
923 (ptrdiff_t n
, Lisp_Object
*args
)
928 unsigned char *buf
= SAFE_ALLOCA (n
);
929 unsigned char *p
= buf
;
931 for (i
= 0; i
< n
; i
++)
933 CHECK_RANGED_INTEGER (args
[i
], 0, 255);
934 *p
++ = XINT (args
[i
]);
937 str
= make_string_from_bytes ((char *) buf
, n
, p
- buf
);
942 DEFUN ("char-resolve-modifiers", Fchar_resolve_modifiers
,
943 Schar_resolve_modifiers
, 1, 1, 0,
944 doc
: /* Resolve modifiers in the character CHAR.
945 The value is a character with modifiers resolved into the character
946 code. Unresolved modifiers are kept in the value.
947 usage: (char-resolve-modifiers CHAR) */)
948 (Lisp_Object character
)
952 CHECK_NUMBER (character
);
953 c
= XINT (character
);
954 return make_number (char_resolve_modifier_mask (c
));
957 DEFUN ("get-byte", Fget_byte
, Sget_byte
, 0, 2, 0,
958 doc
: /* Return a byte value of a character at point.
959 Optional 1st arg POSITION, if non-nil, is a position of a character to get
961 Optional 2nd arg STRING, if non-nil, is a string of which first
962 character is a target to get a byte value. In this case, POSITION, if
963 non-nil, is an index of a target character in the string.
965 If the current buffer (or STRING) is multibyte, and the target
966 character is not ASCII nor 8-bit character, an error is signaled. */)
967 (Lisp_Object position
, Lisp_Object string
)
981 CHECK_NUMBER_COERCE_MARKER (position
);
982 if (XINT (position
) < BEGV
|| XINT (position
) >= ZV
)
983 args_out_of_range_3 (position
, make_number (BEGV
), make_number (ZV
));
984 pos
= XFASTINT (position
);
985 p
= CHAR_POS_ADDR (pos
);
987 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
988 return make_number (*p
);
992 CHECK_STRING (string
);
999 CHECK_NATNUM (position
);
1000 if (XINT (position
) >= SCHARS (string
))
1001 args_out_of_range (string
, position
);
1002 pos
= XFASTINT (position
);
1003 p
= SDATA (string
) + string_char_to_byte (string
, pos
);
1005 if (! STRING_MULTIBYTE (string
))
1006 return make_number (*p
);
1008 c
= STRING_CHAR (p
);
1009 if (CHAR_BYTE8_P (c
))
1010 c
= CHAR_TO_BYTE8 (c
);
1011 else if (! ASCII_CHAR_P (c
))
1012 error ("Not an ASCII nor an 8-bit character: %d", c
);
1013 return make_number (c
);
1019 syms_of_character (void)
1021 DEFSYM (Qcharacterp
, "characterp");
1022 DEFSYM (Qauto_fill_chars
, "auto-fill-chars");
1024 staticpro (&Vchar_unify_table
);
1025 Vchar_unify_table
= Qnil
;
1027 defsubr (&Smax_char
);
1028 defsubr (&Scharacterp
);
1029 defsubr (&Sunibyte_char_to_multibyte
);
1030 defsubr (&Smultibyte_char_to_unibyte
);
1031 defsubr (&Schar_width
);
1032 defsubr (&Sstring_width
);
1034 defsubr (&Sunibyte_string
);
1035 defsubr (&Schar_resolve_modifiers
);
1036 defsubr (&Sget_byte
);
1038 DEFVAR_LISP ("translation-table-vector", Vtranslation_table_vector
,
1040 Vector recording all translation tables ever defined.
1041 Each element is a pair (SYMBOL . TABLE) relating the table to the
1042 symbol naming it. The ID of a translation table is an index into this vector. */);
1043 Vtranslation_table_vector
= Fmake_vector (make_number (16), Qnil
);
1045 DEFVAR_LISP ("auto-fill-chars", Vauto_fill_chars
,
1047 A char-table for characters which invoke auto-filling.
1048 Such characters have value t in this table. */);
1049 Vauto_fill_chars
= Fmake_char_table (Qauto_fill_chars
, Qnil
);
1050 CHAR_TABLE_SET (Vauto_fill_chars
, ' ', Qt
);
1051 CHAR_TABLE_SET (Vauto_fill_chars
, '\n', Qt
);
1053 DEFVAR_LISP ("char-width-table", Vchar_width_table
,
1055 A char-table for width (columns) of each character. */);
1056 Vchar_width_table
= Fmake_char_table (Qnil
, make_number (1));
1057 char_table_set_range (Vchar_width_table
, 0x80, 0x9F, make_number (4));
1058 char_table_set_range (Vchar_width_table
, MAX_5_BYTE_CHAR
+ 1, MAX_CHAR
,
1061 DEFVAR_LISP ("printable-chars", Vprintable_chars
,
1062 doc
: /* A char-table for each printable character. */);
1063 Vprintable_chars
= Fmake_char_table (Qnil
, Qnil
);
1064 Fset_char_table_range (Vprintable_chars
,
1065 Fcons (make_number (32), make_number (126)), Qt
);
1066 Fset_char_table_range (Vprintable_chars
,
1067 Fcons (make_number (160),
1068 make_number (MAX_5_BYTE_CHAR
)), Qt
);
1070 DEFVAR_LISP ("char-script-table", Vchar_script_table
,
1071 doc
: /* Char table of script symbols.
1072 It has one extra slot whose value is a list of script symbols. */);
1074 /* Intern this now in case it isn't already done.
1075 Setting this variable twice is harmless.
1076 But don't staticpro it here--that is done in alloc.c. */
1077 Qchar_table_extra_slots
= intern_c_string ("char-table-extra-slots");
1078 DEFSYM (Qchar_script_table
, "char-script-table");
1079 Fput (Qchar_script_table
, Qchar_table_extra_slots
, make_number (1));
1080 Vchar_script_table
= Fmake_char_table (Qchar_script_table
, Qnil
);
1082 DEFVAR_LISP ("script-representative-chars", Vscript_representative_chars
,
1083 doc
: /* Alist of scripts vs the representative characters.
1084 Each element is a cons (SCRIPT . CHARS).
1085 SCRIPT is a symbol representing a script or a subgroup of a script.
1086 CHARS is a list or a vector of characters.
1087 If it is a list, all characters in the list are necessary for supporting SCRIPT.
1088 If it is a vector, one of the characters in the vector is necessary.
1089 This variable is used to find a font for a specific script. */);
1090 Vscript_representative_chars
= Qnil
;
1092 DEFVAR_LISP ("unicode-category-table", Vunicode_category_table
,
1093 doc
: /* Char table of Unicode's "General Category".
1094 All Unicode characters have one of the following values (symbol):
1095 Lu, Ll, Lt, Lm, Lo, Mn, Mc, Me, Nd, Nl, No, Pc, Pd, Ps, Pe, Pi, Pf, Po,
1096 Sm, Sc, Sk, So, Zs, Zl, Zp, Cc, Cf, Cs, Co, Cn
1097 See The Unicode Standard for the meaning of those values. */);
1098 /* The correct char-table is setup in characters.el. */
1099 Vunicode_category_table
= Qnil
;