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 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: %d", c
);
165 /* Return a character whose multibyte form is at P. Set 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, is
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 C is
210 negative, translate a character specified by CHARSET and CODE. If
211 no translation is found in TABLE, return the untranslated
212 character. If TABLE is a list, elements are char tables. In this
213 case, translace C by all tables. */
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 (Lisp_Object object
, Lisp_Object ignore
)
264 return (CHARACTERP (object
) ? Qt
: Qnil
);
267 DEFUN ("max-char", Fmax_char
, Smax_char
, 0, 0, 0,
268 doc
: /* Return the character of the maximum code. */)
271 return make_number (MAX_CHAR
);
274 DEFUN ("unibyte-char-to-multibyte", Funibyte_char_to_multibyte
,
275 Sunibyte_char_to_multibyte
, 1, 1, 0,
276 doc
: /* Convert the byte CH to multibyte character. */)
281 CHECK_CHARACTER (ch
);
284 error ("Not a unibyte character: %d", c
);
285 MAKE_CHAR_MULTIBYTE (c
);
286 return make_number (c
);
289 DEFUN ("multibyte-char-to-unibyte", Fmultibyte_char_to_unibyte
,
290 Smultibyte_char_to_unibyte
, 1, 1, 0,
291 doc
: /* Convert the multibyte character CH to a byte.
292 If the multibyte character does not represent a byte, return -1. */)
297 CHECK_CHARACTER (ch
);
300 /* Can't distinguish a byte read from a unibyte buffer from
301 a latin1 char, so let's let it slide. */
305 int cu
= CHAR_TO_BYTE_SAFE (cm
);
306 return make_number (cu
);
310 DEFUN ("char-width", Fchar_width
, Schar_width
, 1, 1, 0,
311 doc
: /* Return width of CHAR when displayed in the current buffer.
312 The width is measured by how many columns it occupies on the screen.
313 Tab is taken to occupy `tab-width' columns.
314 usage: (char-width CHAR) */)
319 struct Lisp_Char_Table
*dp
= buffer_display_table ();
321 CHECK_CHARACTER (ch
);
324 /* Get the way the display table would display it. */
325 disp
= dp
? DISP_CHAR_VECTOR (dp
, c
) : Qnil
;
328 width
= ASIZE (disp
);
330 width
= CHAR_WIDTH (c
);
332 return make_number (width
);
335 /* Return width of string STR of length LEN when displayed in the
336 current buffer. The width is measured by how many columns it
337 occupies on the screen. If PRECISION > 0, return the width of
338 longest substring that doesn't exceed PRECISION, and set number of
339 characters and bytes of the substring in *NCHARS and *NBYTES
343 c_string_width (const unsigned char *str
, EMACS_INT len
, int precision
,
344 EMACS_INT
*nchars
, EMACS_INT
*nbytes
)
346 EMACS_INT i
= 0, i_byte
= 0;
348 struct Lisp_Char_Table
*dp
= buffer_display_table ();
352 int bytes
, thiswidth
;
354 int c
= STRING_CHAR_AND_LENGTH (str
+ i_byte
, bytes
);
358 val
= DISP_CHAR_VECTOR (dp
, c
);
360 thiswidth
= XVECTOR (val
)->size
;
362 thiswidth
= CHAR_WIDTH (c
);
366 thiswidth
= CHAR_WIDTH (c
);
370 && (width
+ thiswidth
> precision
))
390 /* Return width of string STR of length LEN when displayed in the
391 current buffer. The width is measured by how many columns it
392 occupies on the screen. */
395 strwidth (const char *str
, EMACS_INT len
)
397 return c_string_width ((const unsigned char *) str
, len
, -1, NULL
, NULL
);
400 /* Return width of Lisp string STRING when displayed in the current
401 buffer. The width is measured by how many columns it occupies on
402 the screen while paying attention to compositions. If PRECISION >
403 0, return the width of longest substring that doesn't exceed
404 PRECISION, and set number of characters and bytes of the substring
405 in *NCHARS and *NBYTES respectively. */
408 lisp_string_width (Lisp_Object string
, int precision
,
409 EMACS_INT
*nchars
, EMACS_INT
*nbytes
)
411 EMACS_INT len
= SCHARS (string
);
412 /* This set multibyte to 0 even if STRING is multibyte when it
413 contains only ascii and eight-bit-graphic, but that's
415 int multibyte
= len
< SBYTES (string
);
416 unsigned char *str
= SDATA (string
);
417 EMACS_INT i
= 0, i_byte
= 0;
419 struct Lisp_Char_Table
*dp
= buffer_display_table ();
423 int chars
, bytes
, thiswidth
;
426 EMACS_INT ignore
, end
;
428 if (find_composition (i
, -1, &ignore
, &end
, &val
, string
)
429 && ((cmp_id
= get_composition_id (i
, i_byte
, end
- i
, val
, string
))
432 thiswidth
= composition_table
[cmp_id
]->width
;
434 bytes
= string_char_to_byte (string
, end
) - i_byte
;
441 c
= STRING_CHAR_AND_LENGTH (str
+ i_byte
, bytes
);
443 c
= str
[i_byte
], bytes
= 1;
447 val
= DISP_CHAR_VECTOR (dp
, c
);
449 thiswidth
= XVECTOR (val
)->size
;
451 thiswidth
= CHAR_WIDTH (c
);
455 thiswidth
= CHAR_WIDTH (c
);
460 && (width
+ thiswidth
> precision
))
480 DEFUN ("string-width", Fstring_width
, Sstring_width
, 1, 1, 0,
481 doc
: /* Return width of STRING when displayed in the current buffer.
482 Width is measured by how many columns it occupies on the screen.
483 When calculating width of a multibyte character in STRING,
484 only the base leading-code is considered; the validity of
485 the following bytes is not checked. Tabs in STRING are always
486 taken to occupy `tab-width' columns.
487 usage: (string-width STRING) */)
493 XSETFASTINT (val
, lisp_string_width (str
, -1, NULL
, NULL
));
497 DEFUN ("char-direction", Fchar_direction
, Schar_direction
, 1, 1, 0,
498 doc
: /* Return the direction of CHAR.
499 The returned value is 0 for left-to-right and 1 for right-to-left.
500 usage: (char-direction CHAR) */)
505 CHECK_CHARACTER (ch
);
507 return CHAR_TABLE_REF (Vchar_direction_table
, c
);
510 /* Return the number of characters in the NBYTES bytes at PTR.
511 This works by looking at the contents and checking for multibyte
512 sequences while assuming that there's no invalid sequence.
513 However, if the current buffer has enable-multibyte-characters =
514 nil, we treat each byte as a character. */
517 chars_in_text (const unsigned char *ptr
, EMACS_INT nbytes
)
519 /* current_buffer is null at early stages of Emacs initialization. */
520 if (current_buffer
== 0
521 || NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
524 return multibyte_chars_in_text (ptr
, nbytes
);
527 /* Return the number of characters in the NBYTES bytes at PTR.
528 This works by looking at the contents and checking for multibyte
529 sequences while assuming that there's no invalid sequence. It
530 ignores enable-multibyte-characters. */
533 multibyte_chars_in_text (const unsigned char *ptr
, EMACS_INT nbytes
)
535 const unsigned char *endp
= ptr
+ nbytes
;
540 EMACS_INT len
= MULTIBYTE_LENGTH (ptr
, endp
);
551 /* Parse unibyte text at STR of LEN bytes as a multibyte text, count
552 characters and bytes in it, and store them in *NCHARS and *NBYTES
553 respectively. On counting bytes, pay attention to that 8-bit
554 characters not constructing a valid multibyte sequence are
555 represented by 2-byte in a multibyte text. */
558 parse_str_as_multibyte (const unsigned char *str
, EMACS_INT len
,
559 EMACS_INT
*nchars
, EMACS_INT
*nbytes
)
561 const unsigned char *endp
= str
+ len
;
562 EMACS_INT n
, chars
= 0, bytes
= 0;
564 if (len
>= MAX_MULTIBYTE_LENGTH
)
566 const unsigned char *adjusted_endp
= endp
- MAX_MULTIBYTE_LENGTH
;
567 while (str
< adjusted_endp
)
569 if (! CHAR_BYTE8_HEAD_P (*str
)
570 && (n
= MULTIBYTE_LENGTH_NO_CHECK (str
)) > 0)
571 str
+= n
, bytes
+= n
;
579 if (! CHAR_BYTE8_HEAD_P (*str
)
580 && (n
= MULTIBYTE_LENGTH (str
, endp
)) > 0)
581 str
+= n
, bytes
+= n
;
592 /* Arrange unibyte text at STR of NBYTES bytes as a multibyte text.
593 It actually converts only such 8-bit characters that don't contruct
594 a multibyte sequence to multibyte forms of Latin-1 characters. If
595 NCHARS is nonzero, set *NCHARS to the number of characters in the
596 text. It is assured that we can use LEN bytes at STR as a work
597 area and that is enough. Return the number of bytes of the
601 str_as_multibyte (unsigned char *str
, EMACS_INT len
, EMACS_INT nbytes
,
604 unsigned char *p
= str
, *endp
= str
+ nbytes
;
609 if (nbytes
>= MAX_MULTIBYTE_LENGTH
)
611 unsigned char *adjusted_endp
= endp
- MAX_MULTIBYTE_LENGTH
;
612 while (p
< adjusted_endp
613 && ! CHAR_BYTE8_HEAD_P (*p
)
614 && (n
= MULTIBYTE_LENGTH_NO_CHECK (p
)) > 0)
618 && ! CHAR_BYTE8_HEAD_P (*p
)
619 && (n
= MULTIBYTE_LENGTH (p
, endp
)) > 0)
629 memmove (endp
- nbytes
, p
, nbytes
);
632 if (nbytes
>= MAX_MULTIBYTE_LENGTH
)
634 unsigned char *adjusted_endp
= endp
- MAX_MULTIBYTE_LENGTH
;
635 while (p
< adjusted_endp
)
637 if (! CHAR_BYTE8_HEAD_P (*p
)
638 && (n
= MULTIBYTE_LENGTH_NO_CHECK (p
)) > 0)
646 c
= BYTE8_TO_CHAR (c
);
647 to
+= CHAR_STRING (c
, to
);
654 if (! CHAR_BYTE8_HEAD_P (*p
)
655 && (n
= MULTIBYTE_LENGTH (p
, endp
)) > 0)
663 c
= BYTE8_TO_CHAR (c
);
664 to
+= CHAR_STRING (c
, to
);
673 /* Parse unibyte string at STR of LEN bytes, and return the number of
674 bytes it may ocupy when converted to multibyte string by
675 `str_to_multibyte'. */
678 parse_str_to_multibyte (const unsigned char *str
, EMACS_INT len
)
680 const unsigned char *endp
= str
+ len
;
683 for (bytes
= 0; str
< endp
; str
++)
684 bytes
+= (*str
< 0x80) ? 1 : 2;
689 /* Convert unibyte text at STR of NBYTES bytes to a multibyte text
690 that contains the same single-byte characters. It actually
691 converts all 8-bit characters to multibyte forms. It is assured
692 that we can use LEN bytes at STR as a work area and that is
696 str_to_multibyte (unsigned char *str
, EMACS_INT len
, EMACS_INT bytes
)
698 unsigned char *p
= str
, *endp
= str
+ bytes
;
701 while (p
< endp
&& *p
< 0x80) p
++;
707 memmove (endp
- bytes
, p
, bytes
);
714 c
= BYTE8_TO_CHAR (c
);
715 to
+= CHAR_STRING (c
, to
);
720 /* Arrange multibyte text at STR of LEN bytes as a unibyte text. It
721 actually converts characters in the range 0x80..0xFF to
725 str_as_unibyte (unsigned char *str
, EMACS_INT bytes
)
727 const unsigned char *p
= str
, *endp
= str
+ bytes
;
734 len
= BYTES_BY_CHAR_HEAD (c
);
735 if (CHAR_BYTE8_HEAD_P (c
))
739 to
= str
+ (p
- str
);
743 len
= BYTES_BY_CHAR_HEAD (c
);
744 if (CHAR_BYTE8_HEAD_P (c
))
746 c
= STRING_CHAR_ADVANCE (p
);
747 *to
++ = CHAR_TO_BYTE8 (c
);
751 while (len
--) *to
++ = *p
++;
757 /* Convert eight-bit chars in SRC (in multibyte form) to the
758 corresponding byte and store in DST. CHARS is the number of
759 characters in SRC. The value is the number of bytes stored in DST.
760 Usually, the value is the same as CHARS, but is less than it if SRC
761 contains a non-ASCII, non-eight-bit character. If ACCEPT_LATIN_1
762 is nonzero, a Latin-1 character is accepted and converted to a byte
763 of that character code.
764 Note: Currently the arg ACCEPT_LATIN_1 is not used. */
767 str_to_unibyte (const unsigned char *src
, unsigned char *dst
, EMACS_INT chars
, int accept_latin_1
)
771 for (i
= 0; i
< chars
; i
++)
773 int c
= STRING_CHAR_ADVANCE (src
);
775 if (CHAR_BYTE8_P (c
))
776 c
= CHAR_TO_BYTE8 (c
);
777 else if (! ASCII_CHAR_P (c
)
778 && (! accept_latin_1
|| c
>= 0x100))
787 string_count_byte8 (Lisp_Object string
)
789 int multibyte
= STRING_MULTIBYTE (string
);
790 EMACS_INT nbytes
= SBYTES (string
);
791 unsigned char *p
= SDATA (string
);
792 unsigned char *pend
= p
+ nbytes
;
800 len
= BYTES_BY_CHAR_HEAD (c
);
802 if (CHAR_BYTE8_HEAD_P (c
))
817 string_escape_byte8 (Lisp_Object string
)
819 EMACS_INT nchars
= SCHARS (string
);
820 EMACS_INT nbytes
= SBYTES (string
);
821 int multibyte
= STRING_MULTIBYTE (string
);
822 EMACS_INT byte8_count
;
823 const unsigned char *src
, *src_end
;
828 if (multibyte
&& nchars
== nbytes
)
831 byte8_count
= string_count_byte8 (string
);
833 if (byte8_count
== 0)
838 if ((MOST_POSITIVE_FIXNUM
- nchars
) / 3 < byte8_count
839 || (MOST_POSITIVE_FIXNUM
- nbytes
) / 2 < byte8_count
)
840 error ("Maximum string size exceeded");
842 /* Convert 2-byte sequence of byte8 chars to 4-byte octal. */
843 val
= make_uninit_multibyte_string (nchars
+ byte8_count
* 3,
844 nbytes
+ byte8_count
* 2);
848 if ((MOST_POSITIVE_FIXNUM
- nchars
) / 3 < byte8_count
)
849 error ("Maximum string size exceeded");
850 /* Convert 1-byte sequence of byte8 chars to 4-byte octal. */
851 val
= make_uninit_string (nbytes
+ byte8_count
* 3);
854 src
= SDATA (string
);
855 src_end
= src
+ nbytes
;
858 while (src
< src_end
)
861 len
= BYTES_BY_CHAR_HEAD (c
);
863 if (CHAR_BYTE8_HEAD_P (c
))
865 c
= STRING_CHAR_ADVANCE (src
);
866 c
= CHAR_TO_BYTE8 (c
);
867 sprintf ((char *) dst
, "\\%03o", c
);
871 while (len
--) *dst
++ = *src
++;
874 while (src
< src_end
)
879 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 (size_t n
, Lisp_Object
*args
)
897 unsigned char *buf
, *p
;
901 SAFE_ALLOCA (buf
, unsigned char *, 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 (size_t n
, Lisp_Object
*args
)
923 unsigned char *buf
, *p
;
927 SAFE_ALLOCA (buf
, unsigned char *, n
);
930 for (i
= 0; i
< n
; i
++)
932 CHECK_NATNUM (args
[i
]);
933 c
= XFASTINT (args
[i
]);
935 args_out_of_range_3 (args
[i
], make_number (0), make_number (255));
939 str
= make_string_from_bytes ((char *) buf
, n
, p
- buf
);
944 DEFUN ("char-resolve-modifiers", Fchar_resolve_modifiers
,
945 Schar_resolve_modifiers
, 1, 1, 0,
946 doc
: /* Resolve modifiers in the character CHAR.
947 The value is a character with modifiers resolved into the character
948 code. Unresolved modifiers are kept in the value.
949 usage: (char-resolve-modifiers CHAR) */)
950 (Lisp_Object character
)
954 CHECK_NUMBER (character
);
955 c
= XINT (character
);
956 return make_number (char_resolve_modifier_mask (c
));
959 DEFUN ("get-byte", Fget_byte
, Sget_byte
, 0, 2, 0,
960 doc
: /* Return a byte value of a character at point.
961 Optional 1st arg POSITION, if non-nil, is a position of a character to get
963 Optional 2nd arg STRING, if non-nil, is a string of which first
964 character is a target to get a byte value. In this case, POSITION, if
965 non-nil, is an index of a target character in the string.
967 If the current buffer (or STRING) is multibyte, and the target
968 character is not ASCII nor 8-bit character, an error is signalled. */)
969 (Lisp_Object position
, Lisp_Object string
)
983 CHECK_NUMBER_COERCE_MARKER (position
);
984 if (XINT (position
) < BEGV
|| XINT (position
) >= ZV
)
985 args_out_of_range_3 (position
, make_number (BEGV
), make_number (ZV
));
986 pos
= XFASTINT (position
);
987 p
= CHAR_POS_ADDR (pos
);
989 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
990 return make_number (*p
);
994 CHECK_STRING (string
);
1001 CHECK_NATNUM (position
);
1002 if (XINT (position
) >= SCHARS (string
))
1003 args_out_of_range (string
, position
);
1004 pos
= XFASTINT (position
);
1005 p
= SDATA (string
) + string_char_to_byte (string
, pos
);
1007 if (! STRING_MULTIBYTE (string
))
1008 return make_number (*p
);
1010 c
= STRING_CHAR (p
);
1011 if (CHAR_BYTE8_P (c
))
1012 c
= CHAR_TO_BYTE8 (c
);
1013 else if (! ASCII_CHAR_P (c
))
1014 error ("Not an ASCII nor an 8-bit character: %d", c
);
1015 return make_number (c
);
1020 init_character_once (void)
1027 syms_of_character (void)
1029 DEFSYM (Qcharacterp
, "characterp");
1030 DEFSYM (Qauto_fill_chars
, "auto-fill-chars");
1032 staticpro (&Vchar_unify_table
);
1033 Vchar_unify_table
= Qnil
;
1035 defsubr (&Smax_char
);
1036 defsubr (&Scharacterp
);
1037 defsubr (&Sunibyte_char_to_multibyte
);
1038 defsubr (&Smultibyte_char_to_unibyte
);
1039 defsubr (&Schar_width
);
1040 defsubr (&Sstring_width
);
1041 defsubr (&Schar_direction
);
1043 defsubr (&Sunibyte_string
);
1044 defsubr (&Schar_resolve_modifiers
);
1045 defsubr (&Sget_byte
);
1047 DEFVAR_LISP ("translation-table-vector", Vtranslation_table_vector
,
1049 Vector recording all translation tables ever defined.
1050 Each element is a pair (SYMBOL . TABLE) relating the table to the
1051 symbol naming it. The ID of a translation table is an index into this vector. */);
1052 Vtranslation_table_vector
= Fmake_vector (make_number (16), Qnil
);
1054 DEFVAR_LISP ("auto-fill-chars", Vauto_fill_chars
,
1056 A char-table for characters which invoke auto-filling.
1057 Such characters have value t in this table. */);
1058 Vauto_fill_chars
= Fmake_char_table (Qauto_fill_chars
, Qnil
);
1059 CHAR_TABLE_SET (Vauto_fill_chars
, ' ', Qt
);
1060 CHAR_TABLE_SET (Vauto_fill_chars
, '\n', Qt
);
1062 DEFVAR_LISP ("char-width-table", Vchar_width_table
,
1064 A char-table for width (columns) of each character. */);
1065 Vchar_width_table
= Fmake_char_table (Qnil
, make_number (1));
1066 char_table_set_range (Vchar_width_table
, 0x80, 0x9F, make_number (4));
1067 char_table_set_range (Vchar_width_table
, MAX_5_BYTE_CHAR
+ 1, MAX_CHAR
,
1070 DEFVAR_LISP ("char-direction-table", Vchar_direction_table
,
1071 doc
: /* A char-table for direction of each character. */);
1072 Vchar_direction_table
= Fmake_char_table (Qnil
, make_number (1));
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
;