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>
39 #include "character.h"
42 #include "composite.h"
51 Lisp_Object Qcharacterp
;
53 static Lisp_Object Qauto_fill_chars
;
55 /* Char-table of information about which character to unify to which
56 Unicode character. Mainly used by the macro MAYBE_UNIFY_CHAR. */
57 Lisp_Object Vchar_unify_table
;
59 /* Variable used locally in the macro FETCH_MULTIBYTE_CHAR. */
60 unsigned char *_fetch_multibyte_char_p
;
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 (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
= (unsigned) char_resolve_modifier_mask ((int) 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 (Lisp_Object object
, Lisp_Object ignore
)
263 return (CHARACTERP (object
) ? Qt
: Qnil
);
266 DEFUN ("max-char", Fmax_char
, Smax_char
, 0, 0, 0,
267 doc
: /* Return the character of the maximum code. */)
270 return make_number (MAX_CHAR
);
273 DEFUN ("unibyte-char-to-multibyte", Funibyte_char_to_multibyte
,
274 Sunibyte_char_to_multibyte
, 1, 1, 0,
275 doc
: /* Convert the byte CH to multibyte character. */)
280 CHECK_CHARACTER (ch
);
283 error ("Not a unibyte character: %d", c
);
284 MAKE_CHAR_MULTIBYTE (c
);
285 return make_number (c
);
288 DEFUN ("multibyte-char-to-unibyte", Fmultibyte_char_to_unibyte
,
289 Smultibyte_char_to_unibyte
, 1, 1, 0,
290 doc
: /* Convert the multibyte character CH to a byte.
291 If the multibyte character does not represent a byte, return -1. */)
296 CHECK_CHARACTER (ch
);
299 /* Can't distinguish a byte read from a unibyte buffer from
300 a latin1 char, so let's let it slide. */
304 int cu
= CHAR_TO_BYTE_SAFE (cm
);
305 return make_number (cu
);
309 DEFUN ("char-width", Fchar_width
, Schar_width
, 1, 1, 0,
310 doc
: /* Return width of CHAR when displayed in the current buffer.
311 The width is measured by how many columns it occupies on the screen.
312 Tab is taken to occupy `tab-width' columns.
313 usage: (char-width CHAR) */)
318 struct Lisp_Char_Table
*dp
= buffer_display_table ();
320 CHECK_CHARACTER (ch
);
323 /* Get the way the display table would display it. */
324 disp
= dp
? DISP_CHAR_VECTOR (dp
, c
) : Qnil
;
327 width
= ASIZE (disp
);
329 width
= CHAR_WIDTH (c
);
331 return make_number (width
);
334 /* Return width of string STR of length LEN when displayed in the
335 current buffer. The width is measured by how many columns it
336 occupies on the screen. If PRECISION > 0, return the width of
337 longest substring that doesn't exceed PRECISION, and set number of
338 characters and bytes of the substring in *NCHARS and *NBYTES
342 c_string_width (const unsigned char *str
, EMACS_INT len
, int precision
,
343 EMACS_INT
*nchars
, EMACS_INT
*nbytes
)
345 EMACS_INT i
= 0, i_byte
= 0;
347 struct Lisp_Char_Table
*dp
= buffer_display_table ();
351 int bytes
, thiswidth
;
353 int c
= STRING_CHAR_AND_LENGTH (str
+ i_byte
, bytes
);
357 val
= DISP_CHAR_VECTOR (dp
, c
);
359 thiswidth
= XVECTOR (val
)->size
;
361 thiswidth
= CHAR_WIDTH (c
);
365 thiswidth
= CHAR_WIDTH (c
);
369 && (width
+ thiswidth
> precision
))
389 /* Return width of string STR of length LEN when displayed in the
390 current buffer. The width is measured by how many columns it
391 occupies on the screen. */
394 strwidth (const char *str
, EMACS_INT len
)
396 return c_string_width ((const unsigned char *) str
, len
, -1, NULL
, NULL
);
399 /* Return width of Lisp string STRING when displayed in the current
400 buffer. The width is measured by how many columns it occupies on
401 the screen while paying attention to compositions. If PRECISION >
402 0, return the width of longest substring that doesn't exceed
403 PRECISION, and set number of characters and bytes of the substring
404 in *NCHARS and *NBYTES respectively. */
407 lisp_string_width (Lisp_Object string
, int precision
,
408 EMACS_INT
*nchars
, EMACS_INT
*nbytes
)
410 EMACS_INT len
= SCHARS (string
);
411 /* This set multibyte to 0 even if STRING is multibyte when it
412 contains only ascii and eight-bit-graphic, but that's
414 int multibyte
= len
< SBYTES (string
);
415 unsigned char *str
= SDATA (string
);
416 EMACS_INT i
= 0, i_byte
= 0;
418 struct Lisp_Char_Table
*dp
= buffer_display_table ();
422 int chars
, bytes
, thiswidth
;
425 EMACS_INT ignore
, end
;
427 if (find_composition (i
, -1, &ignore
, &end
, &val
, string
)
428 && ((cmp_id
= get_composition_id (i
, i_byte
, end
- i
, val
, string
))
431 thiswidth
= composition_table
[cmp_id
]->width
;
433 bytes
= string_char_to_byte (string
, end
) - i_byte
;
440 c
= STRING_CHAR_AND_LENGTH (str
+ i_byte
, bytes
);
442 c
= str
[i_byte
], bytes
= 1;
446 val
= DISP_CHAR_VECTOR (dp
, c
);
448 thiswidth
= XVECTOR (val
)->size
;
450 thiswidth
= CHAR_WIDTH (c
);
454 thiswidth
= CHAR_WIDTH (c
);
459 && (width
+ thiswidth
> precision
))
479 DEFUN ("string-width", Fstring_width
, Sstring_width
, 1, 1, 0,
480 doc
: /* Return width of STRING when displayed in the current buffer.
481 Width is measured by how many columns it occupies on the screen.
482 When calculating width of a multibyte character in STRING,
483 only the base leading-code is considered; the validity of
484 the following bytes is not checked. Tabs in STRING are always
485 taken to occupy `tab-width' columns.
486 usage: (string-width STRING) */)
492 XSETFASTINT (val
, lisp_string_width (str
, -1, NULL
, NULL
));
496 DEFUN ("char-direction", Fchar_direction
, Schar_direction
, 1, 1, 0,
497 doc
: /* Return the direction of CHAR.
498 The returned value is 0 for left-to-right and 1 for right-to-left.
499 usage: (char-direction CHAR) */)
504 CHECK_CHARACTER (ch
);
506 return CHAR_TABLE_REF (Vchar_direction_table
, c
);
509 /* Return the number of characters in the NBYTES bytes at PTR.
510 This works by looking at the contents and checking for multibyte
511 sequences while assuming that there's no invalid sequence.
512 However, if the current buffer has enable-multibyte-characters =
513 nil, we treat each byte as a character. */
516 chars_in_text (const unsigned char *ptr
, EMACS_INT nbytes
)
518 /* current_buffer is null at early stages of Emacs initialization. */
519 if (current_buffer
== 0
520 || NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
523 return multibyte_chars_in_text (ptr
, nbytes
);
526 /* Return the number of characters in the NBYTES bytes at PTR.
527 This works by looking at the contents and checking for multibyte
528 sequences while assuming that there's no invalid sequence. It
529 ignores enable-multibyte-characters. */
532 multibyte_chars_in_text (const unsigned char *ptr
, EMACS_INT nbytes
)
534 const unsigned char *endp
= ptr
+ nbytes
;
539 EMACS_INT len
= MULTIBYTE_LENGTH (ptr
, endp
);
550 /* Parse unibyte text at STR of LEN bytes as a multibyte text, count
551 characters and bytes in it, and store them in *NCHARS and *NBYTES
552 respectively. On counting bytes, pay attention to that 8-bit
553 characters not constructing a valid multibyte sequence are
554 represented by 2-byte in a multibyte text. */
557 parse_str_as_multibyte (const unsigned char *str
, EMACS_INT len
,
558 EMACS_INT
*nchars
, EMACS_INT
*nbytes
)
560 const unsigned char *endp
= str
+ len
;
561 EMACS_INT n
, 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
, EMACS_INT len
, EMACS_INT 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 parse_str_to_multibyte (const unsigned char *str
, EMACS_INT len
)
679 const unsigned char *endp
= str
+ len
;
682 for (bytes
= 0; str
< endp
; str
++)
683 bytes
+= (*str
< 0x80) ? 1 : 2;
688 /* Convert unibyte text at STR of NBYTES bytes to a multibyte text
689 that contains the same single-byte characters. It actually
690 converts all 8-bit characters to multibyte forms. It is assured
691 that we can use LEN bytes at STR as a work area and that is
695 str_to_multibyte (unsigned char *str
, EMACS_INT len
, EMACS_INT bytes
)
697 unsigned char *p
= str
, *endp
= str
+ bytes
;
700 while (p
< endp
&& *p
< 0x80) p
++;
706 memmove (endp
- bytes
, p
, bytes
);
713 c
= BYTE8_TO_CHAR (c
);
714 to
+= CHAR_STRING (c
, to
);
719 /* Arrange multibyte text at STR of LEN bytes as a unibyte text. It
720 actually converts characters in the range 0x80..0xFF to
724 str_as_unibyte (unsigned char *str
, EMACS_INT bytes
)
726 const unsigned char *p
= str
, *endp
= str
+ bytes
;
733 len
= BYTES_BY_CHAR_HEAD (c
);
734 if (CHAR_BYTE8_HEAD_P (c
))
738 to
= str
+ (p
- str
);
742 len
= BYTES_BY_CHAR_HEAD (c
);
743 if (CHAR_BYTE8_HEAD_P (c
))
745 c
= STRING_CHAR_ADVANCE (p
);
746 *to
++ = CHAR_TO_BYTE8 (c
);
750 while (len
--) *to
++ = *p
++;
756 /* Convert eight-bit chars in SRC (in multibyte form) to the
757 corresponding byte and store in DST. CHARS is the number of
758 characters in SRC. The value is the number of bytes stored in DST.
759 Usually, the value is the same as CHARS, but is less than it if SRC
760 contains a non-ASCII, non-eight-bit character. If ACCEPT_LATIN_1
761 is nonzero, a Latin-1 character is accepted and converted to a byte
762 of that character code.
763 Note: Currently the arg ACCEPT_LATIN_1 is not used. */
766 str_to_unibyte (const unsigned char *src
, unsigned char *dst
, EMACS_INT chars
, int accept_latin_1
)
770 for (i
= 0; i
< chars
; i
++)
772 int c
= STRING_CHAR_ADVANCE (src
);
774 if (CHAR_BYTE8_P (c
))
775 c
= CHAR_TO_BYTE8 (c
);
776 else if (! ASCII_CHAR_P (c
)
777 && (! accept_latin_1
|| c
>= 0x100))
786 string_count_byte8 (Lisp_Object string
)
788 int multibyte
= STRING_MULTIBYTE (string
);
789 EMACS_INT nbytes
= SBYTES (string
);
790 unsigned char *p
= SDATA (string
);
791 unsigned char *pend
= p
+ nbytes
;
799 len
= BYTES_BY_CHAR_HEAD (c
);
801 if (CHAR_BYTE8_HEAD_P (c
))
816 string_escape_byte8 (Lisp_Object string
)
818 EMACS_INT nchars
= SCHARS (string
);
819 EMACS_INT nbytes
= SBYTES (string
);
820 int multibyte
= STRING_MULTIBYTE (string
);
821 EMACS_INT byte8_count
;
822 const unsigned char *src
, *src_end
;
827 if (multibyte
&& nchars
== nbytes
)
830 byte8_count
= string_count_byte8 (string
);
832 if (byte8_count
== 0)
837 if ((MOST_POSITIVE_FIXNUM
- nchars
) / 3 < byte8_count
838 || (MOST_POSITIVE_FIXNUM
- nbytes
) / 2 < byte8_count
)
839 error ("Maximum string size exceeded");
841 /* Convert 2-byte sequence of byte8 chars to 4-byte octal. */
842 val
= make_uninit_multibyte_string (nchars
+ byte8_count
* 3,
843 nbytes
+ byte8_count
* 2);
847 if ((MOST_POSITIVE_FIXNUM
- nchars
) / 3 < byte8_count
)
848 error ("Maximum string size exceeded");
849 /* Convert 1-byte sequence of byte8 chars to 4-byte octal. */
850 val
= make_uninit_string (nbytes
+ byte8_count
* 3);
853 src
= SDATA (string
);
854 src_end
= src
+ nbytes
;
857 while (src
< src_end
)
860 len
= BYTES_BY_CHAR_HEAD (c
);
862 if (CHAR_BYTE8_HEAD_P (c
))
864 c
= STRING_CHAR_ADVANCE (src
);
865 c
= CHAR_TO_BYTE8 (c
);
866 sprintf ((char *) dst
, "\\%03o", c
);
870 while (len
--) *dst
++ = *src
++;
873 while (src
< src_end
)
878 sprintf ((char *) dst
, "\\%03o", c
);
888 DEFUN ("string", Fstring
, Sstring
, 0, MANY
, 0,
890 Concatenate all the argument characters and make the result a string.
891 usage: (string &rest CHARACTERS) */)
892 (size_t n
, Lisp_Object
*args
)
896 unsigned char *buf
, *p
;
900 SAFE_ALLOCA (buf
, unsigned char *, MAX_MULTIBYTE_LENGTH
* n
);
903 for (i
= 0; i
< n
; i
++)
905 CHECK_CHARACTER (args
[i
]);
907 p
+= CHAR_STRING (c
, p
);
910 str
= make_string_from_bytes ((char *) buf
, n
, p
- buf
);
915 DEFUN ("unibyte-string", Funibyte_string
, Sunibyte_string
, 0, MANY
, 0,
916 doc
: /* Concatenate all the argument bytes and make the result a unibyte string.
917 usage: (unibyte-string &rest BYTES) */)
918 (size_t n
, Lisp_Object
*args
)
922 unsigned char *buf
, *p
;
926 SAFE_ALLOCA (buf
, unsigned char *, n
);
929 for (i
= 0; i
< n
; i
++)
931 CHECK_NATNUM (args
[i
]);
932 c
= XFASTINT (args
[i
]);
934 args_out_of_range_3 (args
[i
], make_number (0), make_number (255));
938 str
= make_string_from_bytes ((char *) buf
, n
, p
- buf
);
943 DEFUN ("char-resolve-modifiers", Fchar_resolve_modifiers
,
944 Schar_resolve_modifiers
, 1, 1, 0,
945 doc
: /* Resolve modifiers in the character CHAR.
946 The value is a character with modifiers resolved into the character
947 code. Unresolved modifiers are kept in the value.
948 usage: (char-resolve-modifiers CHAR) */)
949 (Lisp_Object character
)
953 CHECK_NUMBER (character
);
954 c
= XINT (character
);
955 return make_number (char_resolve_modifier_mask (c
));
958 DEFUN ("get-byte", Fget_byte
, Sget_byte
, 0, 2, 0,
959 doc
: /* Return a byte value of a character at point.
960 Optional 1st arg POSITION, if non-nil, is a position of a character to get
962 Optional 2nd arg STRING, if non-nil, is a string of which first
963 character is a target to get a byte value. In this case, POSITION, if
964 non-nil, is an index of a target character in the string.
966 If the current buffer (or STRING) is multibyte, and the target
967 character is not ASCII nor 8-bit character, an error is signalled. */)
968 (Lisp_Object position
, Lisp_Object string
)
982 CHECK_NUMBER_COERCE_MARKER (position
);
983 if (XINT (position
) < BEGV
|| XINT (position
) >= ZV
)
984 args_out_of_range_3 (position
, make_number (BEGV
), make_number (ZV
));
985 pos
= XFASTINT (position
);
986 p
= CHAR_POS_ADDR (pos
);
988 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
989 return make_number (*p
);
993 CHECK_STRING (string
);
1000 CHECK_NATNUM (position
);
1001 if (XINT (position
) >= SCHARS (string
))
1002 args_out_of_range (string
, position
);
1003 pos
= XFASTINT (position
);
1004 p
= SDATA (string
) + string_char_to_byte (string
, pos
);
1006 if (! STRING_MULTIBYTE (string
))
1007 return make_number (*p
);
1009 c
= STRING_CHAR (p
);
1010 if (CHAR_BYTE8_P (c
))
1011 c
= CHAR_TO_BYTE8 (c
);
1012 else if (! ASCII_CHAR_P (c
))
1013 error ("Not an ASCII nor an 8-bit character: %d", c
);
1014 return make_number (c
);
1019 init_character_once (void)
1026 syms_of_character (void)
1028 DEFSYM (Qcharacterp
, "characterp");
1029 DEFSYM (Qauto_fill_chars
, "auto-fill-chars");
1031 staticpro (&Vchar_unify_table
);
1032 Vchar_unify_table
= Qnil
;
1034 defsubr (&Smax_char
);
1035 defsubr (&Scharacterp
);
1036 defsubr (&Sunibyte_char_to_multibyte
);
1037 defsubr (&Smultibyte_char_to_unibyte
);
1038 defsubr (&Schar_width
);
1039 defsubr (&Sstring_width
);
1040 defsubr (&Schar_direction
);
1042 defsubr (&Sunibyte_string
);
1043 defsubr (&Schar_resolve_modifiers
);
1044 defsubr (&Sget_byte
);
1046 DEFVAR_LISP ("translation-table-vector", Vtranslation_table_vector
,
1048 Vector recording all translation tables ever defined.
1049 Each element is a pair (SYMBOL . TABLE) relating the table to the
1050 symbol naming it. The ID of a translation table is an index into this vector. */);
1051 Vtranslation_table_vector
= Fmake_vector (make_number (16), Qnil
);
1053 DEFVAR_LISP ("auto-fill-chars", Vauto_fill_chars
,
1055 A char-table for characters which invoke auto-filling.
1056 Such characters have value t in this table. */);
1057 Vauto_fill_chars
= Fmake_char_table (Qauto_fill_chars
, Qnil
);
1058 CHAR_TABLE_SET (Vauto_fill_chars
, ' ', Qt
);
1059 CHAR_TABLE_SET (Vauto_fill_chars
, '\n', Qt
);
1061 DEFVAR_LISP ("char-width-table", Vchar_width_table
,
1063 A char-table for width (columns) of each character. */);
1064 Vchar_width_table
= Fmake_char_table (Qnil
, make_number (1));
1065 char_table_set_range (Vchar_width_table
, 0x80, 0x9F, make_number (4));
1066 char_table_set_range (Vchar_width_table
, MAX_5_BYTE_CHAR
+ 1, MAX_CHAR
,
1069 DEFVAR_LISP ("char-direction-table", Vchar_direction_table
,
1070 doc
: /* A char-table for direction of each character. */);
1071 Vchar_direction_table
= Fmake_char_table (Qnil
, make_number (1));
1073 DEFVAR_LISP ("printable-chars", Vprintable_chars
,
1074 doc
: /* A char-table for each printable character. */);
1075 Vprintable_chars
= Fmake_char_table (Qnil
, Qnil
);
1076 Fset_char_table_range (Vprintable_chars
,
1077 Fcons (make_number (32), make_number (126)), Qt
);
1078 Fset_char_table_range (Vprintable_chars
,
1079 Fcons (make_number (160),
1080 make_number (MAX_5_BYTE_CHAR
)), Qt
);
1082 DEFVAR_LISP ("char-script-table", Vchar_script_table
,
1083 doc
: /* Char table of script symbols.
1084 It has one extra slot whose value is a list of script symbols. */);
1086 /* Intern this now in case it isn't already done.
1087 Setting this variable twice is harmless.
1088 But don't staticpro it here--that is done in alloc.c. */
1089 Qchar_table_extra_slots
= intern_c_string ("char-table-extra-slots");
1090 DEFSYM (Qchar_script_table
, "char-script-table");
1091 Fput (Qchar_script_table
, Qchar_table_extra_slots
, make_number (1));
1092 Vchar_script_table
= Fmake_char_table (Qchar_script_table
, Qnil
);
1094 DEFVAR_LISP ("script-representative-chars", Vscript_representative_chars
,
1095 doc
: /* Alist of scripts vs the representative characters.
1096 Each element is a cons (SCRIPT . CHARS).
1097 SCRIPT is a symbol representing a script or a subgroup of a script.
1098 CHARS is a list or a vector of characters.
1099 If it is a list, all characters in the list are necessary for supporting SCRIPT.
1100 If it is a vector, one of the characters in the vector is necessary.
1101 This variable is used to find a font for a specific script. */);
1102 Vscript_representative_chars
= Qnil
;
1104 DEFVAR_LISP ("unicode-category-table", Vunicode_category_table
,
1105 doc
: /* Char table of Unicode's "General Category".
1106 All Unicode characters have one of the following values (symbol):
1107 Lu, Ll, Lt, Lm, Lo, Mn, Mc, Me, Nd, Nl, No, Pc, Pd, Ps, Pe, Pi, Pf, Po,
1108 Sm, Sc, Sk, So, Zs, Zl, Zp, Cc, Cf, Cs, Co, Cn
1109 See The Unicode Standard for the meaning of those values. */);
1110 /* The correct char-table is setup in characters.el. */
1111 Vunicode_category_table
= Qnil
;