1 /* Basic character support.
3 Copyright (C) 2001-2011 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
36 #include <sys/types.h>
40 #include "character.h"
43 #include "composite.h"
52 Lisp_Object Qcharacterp
;
54 static Lisp_Object Qauto_fill_chars
;
56 /* Char-table of information about which character to unify to which
57 Unicode character. Mainly used by the macro MAYBE_UNIFY_CHAR. */
58 Lisp_Object Vchar_unify_table
;
60 /* Variable used locally in the macro FETCH_MULTIBYTE_CHAR. */
61 unsigned char *_fetch_multibyte_char_p
;
63 static Lisp_Object Qchar_script_table
;
67 /* If character code C has modifier masks, reflect them to the
68 character code if possible. Return the resulting code. */
71 char_resolve_modifier_mask (EMACS_INT c
)
73 /* A non-ASCII character can't reflect modifier bits to the code. */
74 if (! ASCII_CHAR_P ((c
& ~CHAR_MODIFIER_MASK
)))
77 /* For Meta, Shift, and Control modifiers, we need special care. */
80 /* Shift modifier is valid only with [A-Za-z]. */
81 if ((c
& 0377) >= 'A' && (c
& 0377) <= 'Z')
83 else if ((c
& 0377) >= 'a' && (c
& 0377) <= 'z')
84 c
= (c
& ~CHAR_SHIFT
) - ('a' - 'A');
85 /* Shift modifier for control characters and SPC is ignored. */
86 else if ((c
& ~CHAR_MODIFIER_MASK
) <= 0x20)
91 /* Simulate the code in lread.c. */
92 /* Allow `\C- ' and `\C-?'. */
93 if ((c
& 0377) == ' ')
94 c
&= ~0177 & ~ CHAR_CTL
;
95 else if ((c
& 0377) == '?')
96 c
= 0177 | (c
& ~0177 & ~CHAR_CTL
);
97 /* ASCII control chars are made from letters (both cases),
98 as well as the non-letters within 0100...0137. */
99 else if ((c
& 0137) >= 0101 && (c
& 0137) <= 0132)
100 c
&= (037 | (~0177 & ~CHAR_CTL
));
101 else if ((c
& 0177) >= 0100 && (c
& 0177) <= 0137)
102 c
&= (037 | (~0177 & ~CHAR_CTL
));
104 #if 0 /* This is outside the scope of this function. (bug#4751) */
107 /* Move the meta bit to the right place for a string. */
108 c
= (c
& ~CHAR_META
) | 0x80;
116 /* Store multibyte form of character C at P. If C has modifier bits,
117 handle them appropriately. */
120 char_string (unsigned int c
, unsigned char *p
)
124 if (c
& CHAR_MODIFIER_MASK
)
126 c
= char_resolve_modifier_mask (c
);
127 /* If C still has any modifier bits, just ignore it. */
128 c
&= ~CHAR_MODIFIER_MASK
;
131 MAYBE_UNIFY_CHAR (c
);
133 if (c
<= MAX_3_BYTE_CHAR
)
135 bytes
= CHAR_STRING (c
, p
);
137 else if (c
<= MAX_4_BYTE_CHAR
)
139 p
[0] = (0xF0 | (c
>> 18));
140 p
[1] = (0x80 | ((c
>> 12) & 0x3F));
141 p
[2] = (0x80 | ((c
>> 6) & 0x3F));
142 p
[3] = (0x80 | (c
& 0x3F));
145 else if (c
<= MAX_5_BYTE_CHAR
)
148 p
[1] = (0x80 | ((c
>> 18) & 0x0F));
149 p
[2] = (0x80 | ((c
>> 12) & 0x3F));
150 p
[3] = (0x80 | ((c
>> 6) & 0x3F));
151 p
[4] = (0x80 | (c
& 0x3F));
154 else if (c
<= MAX_CHAR
)
156 c
= CHAR_TO_BYTE8 (c
);
157 bytes
= BYTE8_STRING (c
, p
);
160 error ("Invalid character: %x", c
);
166 /* Return a character whose multibyte form is at P. If LEN is not
167 NULL, it must be a pointer to integer. In that case, set *LEN to
168 the byte length of the multibyte form. If ADVANCED is not NULL, it
169 must be a pointer to unsigned char. In that case, set *ADVANCED to
170 the ending address (i.e., the starting address of the next
171 character) of the multibyte form. */
174 string_char (const unsigned char *p
, const unsigned char **advanced
, int *len
)
177 const unsigned char *saved_p
= p
;
179 if (*p
< 0x80 || ! (*p
& 0x20) || ! (*p
& 0x10))
181 c
= STRING_CHAR_ADVANCE (p
);
183 else if (! (*p
& 0x08))
185 c
= ((((p
)[0] & 0xF) << 18)
186 | (((p
)[1] & 0x3F) << 12)
187 | (((p
)[2] & 0x3F) << 6)
193 c
= ((((p
)[1] & 0x3F) << 18)
194 | (((p
)[2] & 0x3F) << 12)
195 | (((p
)[3] & 0x3F) << 6)
200 MAYBE_UNIFY_CHAR (c
);
210 /* Translate character C by translation table TABLE. If no translation is
211 found in TABLE, return the untranslated character. If TABLE is a list,
212 elements are char tables. In that case, recursively translate C by all the
213 tables in the list. */
216 translate_char (Lisp_Object table
, int c
)
218 if (CHAR_TABLE_P (table
))
222 ch
= CHAR_TABLE_REF (table
, c
);
228 for (; CONSP (table
); table
= XCDR (table
))
229 c
= translate_char (XCAR (table
), c
);
234 /* Convert ASCII or 8-bit character C to unibyte. If C is none of
235 them, return (C & 0xFF). */
238 multibyte_char_to_unibyte (int c
)
242 if (CHAR_BYTE8_P (c
))
243 return CHAR_TO_BYTE8 (c
);
247 /* Like multibyte_char_to_unibyte, but return -1 if C is not supported
248 by charset_unibyte. */
251 multibyte_char_to_unibyte_safe (int c
)
255 if (CHAR_BYTE8_P (c
))
256 return CHAR_TO_BYTE8 (c
);
260 DEFUN ("characterp", Fcharacterp
, Scharacterp
, 1, 2, 0,
261 doc
: /* Return non-nil if OBJECT is a character.
262 usage: (characterp OBJECT) */)
263 (Lisp_Object object
, Lisp_Object ignore
)
265 return (CHARACTERP (object
) ? Qt
: Qnil
);
268 DEFUN ("max-char", Fmax_char
, Smax_char
, 0, 0, 0,
269 doc
: /* Return the character of the maximum code. */)
272 return make_number (MAX_CHAR
);
275 DEFUN ("unibyte-char-to-multibyte", Funibyte_char_to_multibyte
,
276 Sunibyte_char_to_multibyte
, 1, 1, 0,
277 doc
: /* Convert the byte CH to multibyte character. */)
282 CHECK_CHARACTER (ch
);
285 error ("Not a unibyte character: %d", c
);
286 MAKE_CHAR_MULTIBYTE (c
);
287 return make_number (c
);
290 DEFUN ("multibyte-char-to-unibyte", Fmultibyte_char_to_unibyte
,
291 Smultibyte_char_to_unibyte
, 1, 1, 0,
292 doc
: /* Convert the multibyte character CH to a byte.
293 If the multibyte character does not represent a byte, return -1. */)
298 CHECK_CHARACTER (ch
);
301 /* Can't distinguish a byte read from a unibyte buffer from
302 a latin1 char, so let's let it slide. */
306 int cu
= CHAR_TO_BYTE_SAFE (cm
);
307 return make_number (cu
);
311 DEFUN ("char-width", Fchar_width
, Schar_width
, 1, 1, 0,
312 doc
: /* Return width of CHAR when displayed in the current buffer.
313 The width is measured by how many columns it occupies on the screen.
314 Tab is taken to occupy `tab-width' columns.
315 usage: (char-width CHAR) */)
320 struct Lisp_Char_Table
*dp
= buffer_display_table ();
322 CHECK_CHARACTER (ch
);
325 /* Get the way the display table would display it. */
326 disp
= dp
? DISP_CHAR_VECTOR (dp
, c
) : Qnil
;
329 width
= sanitize_char_width (ASIZE (disp
));
331 width
= CHAR_WIDTH (c
);
333 return make_number (width
);
336 /* Return width of string STR of length LEN when displayed in the
337 current buffer. The width is measured by how many columns it
338 occupies on the screen. If PRECISION > 0, return the width of
339 longest substring that doesn't exceed PRECISION, and set number of
340 characters and bytes of the substring in *NCHARS and *NBYTES
344 c_string_width (const unsigned char *str
, ptrdiff_t len
, int precision
,
345 ptrdiff_t *nchars
, ptrdiff_t *nbytes
)
347 ptrdiff_t i
= 0, i_byte
= 0;
349 struct Lisp_Char_Table
*dp
= buffer_display_table ();
353 int bytes
, thiswidth
;
355 int c
= STRING_CHAR_AND_LENGTH (str
+ i_byte
, bytes
);
359 val
= DISP_CHAR_VECTOR (dp
, c
);
361 thiswidth
= sanitize_char_width (ASIZE (val
));
363 thiswidth
= CHAR_WIDTH (c
);
367 thiswidth
= CHAR_WIDTH (c
);
371 && (width
+ thiswidth
> precision
))
391 /* Return width of string STR of length LEN when displayed in the
392 current buffer. The width is measured by how many columns it
393 occupies on the screen. */
396 strwidth (const char *str
, ptrdiff_t len
)
398 return c_string_width ((const unsigned char *) str
, len
, -1, NULL
, NULL
);
401 /* Return width of Lisp string STRING when displayed in the current
402 buffer. The width is measured by how many columns it occupies on
403 the screen while paying attention to compositions. If PRECISION >
404 0, return the width of longest substring that doesn't exceed
405 PRECISION, and set number of characters and bytes of the substring
406 in *NCHARS and *NBYTES respectively. */
409 lisp_string_width (Lisp_Object string
, ptrdiff_t precision
,
410 ptrdiff_t *nchars
, ptrdiff_t *nbytes
)
412 ptrdiff_t len
= SCHARS (string
);
413 /* This set multibyte to 0 even if STRING is multibyte when it
414 contains only ascii and eight-bit-graphic, but that's
416 int multibyte
= len
< SBYTES (string
);
417 unsigned char *str
= SDATA (string
);
418 ptrdiff_t i
= 0, i_byte
= 0;
420 struct Lisp_Char_Table
*dp
= buffer_display_table ();
424 ptrdiff_t chars
, bytes
, thiswidth
;
427 ptrdiff_t ignore
, end
;
429 if (find_composition (i
, -1, &ignore
, &end
, &val
, string
)
430 && ((cmp_id
= get_composition_id (i
, i_byte
, end
- i
, val
, string
))
433 thiswidth
= composition_table
[cmp_id
]->width
;
435 bytes
= string_char_to_byte (string
, end
) - i_byte
;
444 c
= STRING_CHAR_AND_LENGTH (str
+ i_byte
, cbytes
);
448 c
= str
[i_byte
], bytes
= 1;
452 val
= DISP_CHAR_VECTOR (dp
, c
);
454 thiswidth
= sanitize_char_width (ASIZE (val
));
456 thiswidth
= CHAR_WIDTH (c
);
460 thiswidth
= CHAR_WIDTH (c
);
467 if (INT_ADD_OVERFLOW (width
, thiswidth
))
471 else if (precision
- width
< thiswidth
)
491 DEFUN ("string-width", Fstring_width
, Sstring_width
, 1, 1, 0,
492 doc
: /* Return width of STRING when displayed in the current buffer.
493 Width is measured by how many columns it occupies on the screen.
494 When calculating width of a multibyte character in STRING,
495 only the base leading-code is considered; the validity of
496 the following bytes is not checked. Tabs in STRING are always
497 taken to occupy `tab-width' columns.
498 usage: (string-width STRING) */)
504 XSETFASTINT (val
, lisp_string_width (str
, -1, NULL
, NULL
));
508 /* Return the number of characters in the NBYTES bytes at PTR.
509 This works by looking at the contents and checking for multibyte
510 sequences while assuming that there's no invalid sequence.
511 However, if the current buffer has enable-multibyte-characters =
512 nil, we treat each byte as a character. */
515 chars_in_text (const unsigned char *ptr
, ptrdiff_t nbytes
)
517 /* current_buffer is null at early stages of Emacs initialization. */
518 if (current_buffer
== 0
519 || NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
522 return multibyte_chars_in_text (ptr
, nbytes
);
525 /* Return the number of characters in the NBYTES bytes at PTR.
526 This works by looking at the contents and checking for multibyte
527 sequences while assuming that there's no invalid sequence. It
528 ignores enable-multibyte-characters. */
531 multibyte_chars_in_text (const unsigned char *ptr
, ptrdiff_t nbytes
)
533 const unsigned char *endp
= ptr
+ nbytes
;
538 int len
= MULTIBYTE_LENGTH (ptr
, endp
);
549 /* Parse unibyte text at STR of LEN bytes as a multibyte text, count
550 characters and bytes in it, and store them in *NCHARS and *NBYTES
551 respectively. On counting bytes, pay attention to that 8-bit
552 characters not constructing a valid multibyte sequence are
553 represented by 2-byte in a multibyte text. */
556 parse_str_as_multibyte (const unsigned char *str
, ptrdiff_t len
,
557 ptrdiff_t *nchars
, ptrdiff_t *nbytes
)
559 const unsigned char *endp
= str
+ len
;
561 ptrdiff_t chars
= 0, bytes
= 0;
563 if (len
>= MAX_MULTIBYTE_LENGTH
)
565 const unsigned char *adjusted_endp
= endp
- MAX_MULTIBYTE_LENGTH
;
566 while (str
< adjusted_endp
)
568 if (! CHAR_BYTE8_HEAD_P (*str
)
569 && (n
= MULTIBYTE_LENGTH_NO_CHECK (str
)) > 0)
570 str
+= n
, bytes
+= n
;
578 if (! CHAR_BYTE8_HEAD_P (*str
)
579 && (n
= MULTIBYTE_LENGTH (str
, endp
)) > 0)
580 str
+= n
, bytes
+= n
;
591 /* Arrange unibyte text at STR of NBYTES bytes as a multibyte text.
592 It actually converts only such 8-bit characters that don't contruct
593 a multibyte sequence to multibyte forms of Latin-1 characters. If
594 NCHARS is nonzero, set *NCHARS to the number of characters in the
595 text. It is assured that we can use LEN bytes at STR as a work
596 area and that is enough. Return the number of bytes of the
600 str_as_multibyte (unsigned char *str
, ptrdiff_t len
, ptrdiff_t nbytes
,
603 unsigned char *p
= str
, *endp
= str
+ nbytes
;
608 if (nbytes
>= MAX_MULTIBYTE_LENGTH
)
610 unsigned char *adjusted_endp
= endp
- MAX_MULTIBYTE_LENGTH
;
611 while (p
< adjusted_endp
612 && ! CHAR_BYTE8_HEAD_P (*p
)
613 && (n
= MULTIBYTE_LENGTH_NO_CHECK (p
)) > 0)
617 && ! CHAR_BYTE8_HEAD_P (*p
)
618 && (n
= MULTIBYTE_LENGTH (p
, endp
)) > 0)
628 memmove (endp
- nbytes
, p
, nbytes
);
631 if (nbytes
>= MAX_MULTIBYTE_LENGTH
)
633 unsigned char *adjusted_endp
= endp
- MAX_MULTIBYTE_LENGTH
;
634 while (p
< adjusted_endp
)
636 if (! CHAR_BYTE8_HEAD_P (*p
)
637 && (n
= MULTIBYTE_LENGTH_NO_CHECK (p
)) > 0)
645 c
= BYTE8_TO_CHAR (c
);
646 to
+= CHAR_STRING (c
, to
);
653 if (! CHAR_BYTE8_HEAD_P (*p
)
654 && (n
= MULTIBYTE_LENGTH (p
, endp
)) > 0)
662 c
= BYTE8_TO_CHAR (c
);
663 to
+= CHAR_STRING (c
, to
);
672 /* Parse unibyte string at STR of LEN bytes, and return the number of
673 bytes it may ocupy when converted to multibyte string by
674 `str_to_multibyte'. */
677 count_size_as_multibyte (const unsigned char *str
, ptrdiff_t len
)
679 const unsigned char *endp
= str
+ len
;
682 for (bytes
= 0; str
< endp
; str
++)
684 int n
= *str
< 0x80 ? 1 : 2;
685 if (INT_ADD_OVERFLOW (bytes
, n
))
693 /* Convert unibyte text at STR of BYTES bytes to a multibyte text
694 that contains the same single-byte characters. It actually
695 converts all 8-bit characters to multibyte forms. It is assured
696 that we can use LEN bytes at STR as a work area and that is
700 str_to_multibyte (unsigned char *str
, ptrdiff_t len
, ptrdiff_t bytes
)
702 unsigned char *p
= str
, *endp
= str
+ bytes
;
705 while (p
< endp
&& *p
< 0x80) p
++;
711 memmove (endp
- bytes
, p
, bytes
);
718 c
= BYTE8_TO_CHAR (c
);
719 to
+= CHAR_STRING (c
, to
);
724 /* Arrange multibyte text at STR of LEN bytes as a unibyte text. It
725 actually converts characters in the range 0x80..0xFF to
729 str_as_unibyte (unsigned char *str
, ptrdiff_t bytes
)
731 const unsigned char *p
= str
, *endp
= str
+ bytes
;
738 len
= BYTES_BY_CHAR_HEAD (c
);
739 if (CHAR_BYTE8_HEAD_P (c
))
743 to
= str
+ (p
- str
);
747 len
= BYTES_BY_CHAR_HEAD (c
);
748 if (CHAR_BYTE8_HEAD_P (c
))
750 c
= STRING_CHAR_ADVANCE (p
);
751 *to
++ = CHAR_TO_BYTE8 (c
);
755 while (len
--) *to
++ = *p
++;
761 /* Convert eight-bit chars in SRC (in multibyte form) to the
762 corresponding byte and store in DST. CHARS is the number of
763 characters in SRC. The value is the number of bytes stored in DST.
764 Usually, the value is the same as CHARS, but is less than it if SRC
765 contains a non-ASCII, non-eight-bit character. If ACCEPT_LATIN_1
766 is nonzero, a Latin-1 character is accepted and converted to a byte
767 of that character code.
768 Note: Currently the arg ACCEPT_LATIN_1 is not used. */
771 str_to_unibyte (const unsigned char *src
, unsigned char *dst
, ptrdiff_t chars
, int accept_latin_1
)
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
)
782 && (! accept_latin_1
|| c
>= 0x100))
791 string_count_byte8 (Lisp_Object string
)
793 int multibyte
= STRING_MULTIBYTE (string
);
794 ptrdiff_t nbytes
= SBYTES (string
);
795 unsigned char *p
= SDATA (string
);
796 unsigned char *pend
= p
+ nbytes
;
804 len
= BYTES_BY_CHAR_HEAD (c
);
806 if (CHAR_BYTE8_HEAD_P (c
))
821 string_escape_byte8 (Lisp_Object string
)
823 ptrdiff_t nchars
= SCHARS (string
);
824 ptrdiff_t nbytes
= SBYTES (string
);
825 int multibyte
= STRING_MULTIBYTE (string
);
826 ptrdiff_t byte8_count
;
827 const unsigned char *src
, *src_end
;
832 if (multibyte
&& nchars
== nbytes
)
835 byte8_count
= string_count_byte8 (string
);
837 if (byte8_count
== 0)
842 if ((MOST_POSITIVE_FIXNUM
- nchars
) / 3 < byte8_count
843 || (STRING_BYTES_BOUND
- nbytes
) / 2 < byte8_count
)
846 /* Convert 2-byte sequence of byte8 chars to 4-byte octal. */
847 val
= make_uninit_multibyte_string (nchars
+ byte8_count
* 3,
848 nbytes
+ byte8_count
* 2);
852 if ((STRING_BYTES_BOUND
- nbytes
) / 3 < byte8_count
)
855 /* Convert 1-byte sequence of byte8 chars to 4-byte octal. */
856 val
= make_uninit_string (nbytes
+ byte8_count
* 3);
859 src
= SDATA (string
);
860 src_end
= src
+ nbytes
;
863 while (src
< src_end
)
866 len
= BYTES_BY_CHAR_HEAD (c
);
868 if (CHAR_BYTE8_HEAD_P (c
))
870 c
= STRING_CHAR_ADVANCE (src
);
871 c
= CHAR_TO_BYTE8 (c
);
872 sprintf ((char *) dst
, "\\%03o", c
);
876 while (len
--) *dst
++ = *src
++;
879 while (src
< src_end
)
884 sprintf ((char *) dst
, "\\%03o", c
);
894 DEFUN ("string", Fstring
, Sstring
, 0, MANY
, 0,
896 Concatenate all the argument characters and make the result a string.
897 usage: (string &rest CHARACTERS) */)
898 (ptrdiff_t n
, Lisp_Object
*args
)
902 unsigned char *buf
, *p
;
906 SAFE_NALLOCA (buf
, MAX_MULTIBYTE_LENGTH
, n
);
909 for (i
= 0; i
< n
; i
++)
911 CHECK_CHARACTER (args
[i
]);
913 p
+= CHAR_STRING (c
, p
);
916 str
= make_string_from_bytes ((char *) buf
, n
, p
- buf
);
921 DEFUN ("unibyte-string", Funibyte_string
, Sunibyte_string
, 0, MANY
, 0,
922 doc
: /* Concatenate all the argument bytes and make the result a unibyte string.
923 usage: (unibyte-string &rest BYTES) */)
924 (ptrdiff_t n
, Lisp_Object
*args
)
928 unsigned char *buf
, *p
;
932 SAFE_ALLOCA (buf
, unsigned char *, n
);
935 for (i
= 0; i
< n
; i
++)
937 CHECK_CHARACTER (args
[i
]);
938 c
= XFASTINT (args
[i
]);
940 args_out_of_range_3 (args
[i
], make_number (0), make_number (255));
944 str
= make_string_from_bytes ((char *) buf
, n
, p
- buf
);
949 DEFUN ("char-resolve-modifiers", Fchar_resolve_modifiers
,
950 Schar_resolve_modifiers
, 1, 1, 0,
951 doc
: /* Resolve modifiers in the character CHAR.
952 The value is a character with modifiers resolved into the character
953 code. Unresolved modifiers are kept in the value.
954 usage: (char-resolve-modifiers CHAR) */)
955 (Lisp_Object character
)
959 CHECK_NUMBER (character
);
960 c
= XINT (character
);
961 return make_number (char_resolve_modifier_mask (c
));
964 DEFUN ("get-byte", Fget_byte
, Sget_byte
, 0, 2, 0,
965 doc
: /* Return a byte value of a character at point.
966 Optional 1st arg POSITION, if non-nil, is a position of a character to get
968 Optional 2nd arg STRING, if non-nil, is a string of which first
969 character is a target to get a byte value. In this case, POSITION, if
970 non-nil, is an index of a target character in the string.
972 If the current buffer (or STRING) is multibyte, and the target
973 character is not ASCII nor 8-bit character, an error is signalled. */)
974 (Lisp_Object position
, Lisp_Object string
)
988 CHECK_NUMBER_COERCE_MARKER (position
);
989 if (XINT (position
) < BEGV
|| XINT (position
) >= ZV
)
990 args_out_of_range_3 (position
, make_number (BEGV
), make_number (ZV
));
991 pos
= XFASTINT (position
);
992 p
= CHAR_POS_ADDR (pos
);
994 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
995 return make_number (*p
);
999 CHECK_STRING (string
);
1000 if (NILP (position
))
1006 CHECK_NATNUM (position
);
1007 if (XINT (position
) >= SCHARS (string
))
1008 args_out_of_range (string
, position
);
1009 pos
= XFASTINT (position
);
1010 p
= SDATA (string
) + string_char_to_byte (string
, pos
);
1012 if (! STRING_MULTIBYTE (string
))
1013 return make_number (*p
);
1015 c
= STRING_CHAR (p
);
1016 if (CHAR_BYTE8_P (c
))
1017 c
= CHAR_TO_BYTE8 (c
);
1018 else if (! ASCII_CHAR_P (c
))
1019 error ("Not an ASCII nor an 8-bit character: %d", c
);
1020 return make_number (c
);
1025 init_character_once (void)
1032 syms_of_character (void)
1034 DEFSYM (Qcharacterp
, "characterp");
1035 DEFSYM (Qauto_fill_chars
, "auto-fill-chars");
1037 staticpro (&Vchar_unify_table
);
1038 Vchar_unify_table
= Qnil
;
1040 defsubr (&Smax_char
);
1041 defsubr (&Scharacterp
);
1042 defsubr (&Sunibyte_char_to_multibyte
);
1043 defsubr (&Smultibyte_char_to_unibyte
);
1044 defsubr (&Schar_width
);
1045 defsubr (&Sstring_width
);
1047 defsubr (&Sunibyte_string
);
1048 defsubr (&Schar_resolve_modifiers
);
1049 defsubr (&Sget_byte
);
1051 DEFVAR_LISP ("translation-table-vector", Vtranslation_table_vector
,
1053 Vector recording all translation tables ever defined.
1054 Each element is a pair (SYMBOL . TABLE) relating the table to the
1055 symbol naming it. The ID of a translation table is an index into this vector. */);
1056 Vtranslation_table_vector
= Fmake_vector (make_number (16), Qnil
);
1058 DEFVAR_LISP ("auto-fill-chars", Vauto_fill_chars
,
1060 A char-table for characters which invoke auto-filling.
1061 Such characters have value t in this table. */);
1062 Vauto_fill_chars
= Fmake_char_table (Qauto_fill_chars
, Qnil
);
1063 CHAR_TABLE_SET (Vauto_fill_chars
, ' ', Qt
);
1064 CHAR_TABLE_SET (Vauto_fill_chars
, '\n', Qt
);
1066 DEFVAR_LISP ("char-width-table", Vchar_width_table
,
1068 A char-table for width (columns) of each character. */);
1069 Vchar_width_table
= Fmake_char_table (Qnil
, make_number (1));
1070 char_table_set_range (Vchar_width_table
, 0x80, 0x9F, make_number (4));
1071 char_table_set_range (Vchar_width_table
, MAX_5_BYTE_CHAR
+ 1, MAX_CHAR
,
1074 DEFVAR_LISP ("printable-chars", Vprintable_chars
,
1075 doc
: /* A char-table for each printable character. */);
1076 Vprintable_chars
= Fmake_char_table (Qnil
, Qnil
);
1077 Fset_char_table_range (Vprintable_chars
,
1078 Fcons (make_number (32), make_number (126)), Qt
);
1079 Fset_char_table_range (Vprintable_chars
,
1080 Fcons (make_number (160),
1081 make_number (MAX_5_BYTE_CHAR
)), Qt
);
1083 DEFVAR_LISP ("char-script-table", Vchar_script_table
,
1084 doc
: /* Char table of script symbols.
1085 It has one extra slot whose value is a list of script symbols. */);
1087 /* Intern this now in case it isn't already done.
1088 Setting this variable twice is harmless.
1089 But don't staticpro it here--that is done in alloc.c. */
1090 Qchar_table_extra_slots
= intern_c_string ("char-table-extra-slots");
1091 DEFSYM (Qchar_script_table
, "char-script-table");
1092 Fput (Qchar_script_table
, Qchar_table_extra_slots
, make_number (1));
1093 Vchar_script_table
= Fmake_char_table (Qchar_script_table
, Qnil
);
1095 DEFVAR_LISP ("script-representative-chars", Vscript_representative_chars
,
1096 doc
: /* Alist of scripts vs the representative characters.
1097 Each element is a cons (SCRIPT . CHARS).
1098 SCRIPT is a symbol representing a script or a subgroup of a script.
1099 CHARS is a list or a vector of characters.
1100 If it is a list, all characters in the list are necessary for supporting SCRIPT.
1101 If it is a vector, one of the characters in the vector is necessary.
1102 This variable is used to find a font for a specific script. */);
1103 Vscript_representative_chars
= Qnil
;
1105 DEFVAR_LISP ("unicode-category-table", Vunicode_category_table
,
1106 doc
: /* Char table of Unicode's "General Category".
1107 All Unicode characters have one of the following values (symbol):
1108 Lu, Ll, Lt, Lm, Lo, Mn, Mc, Me, Nd, Nl, No, Pc, Pd, Ps, Pe, Pi, Pf, Po,
1109 Sm, Sc, Sk, So, Zs, Zl, Zp, Cc, Cf, Cs, Co, Cn
1110 See The Unicode Standard for the meaning of those values. */);
1111 /* The correct char-table is setup in characters.el. */
1112 Vunicode_category_table
= Qnil
;