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
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 (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
);
312 /* Return width (columns) of C considering the buffer display table DP. */
315 char_width (int c
, struct Lisp_Char_Table
*dp
)
317 int width
= CHAR_WIDTH (c
);
321 Lisp_Object disp
= DISP_CHAR_VECTOR (dp
, c
), ch
;
325 for (i
= 0, width
= 0; i
< ASIZE (disp
); i
++)
329 width
+= CHAR_WIDTH (XFASTINT (ch
));
336 DEFUN ("char-width", Fchar_width
, Schar_width
, 1, 1, 0,
337 doc
: /* Return width of CHAR when displayed in the current buffer.
338 The width is measured by how many columns it occupies on the screen.
339 Tab is taken to occupy `tab-width' columns.
340 usage: (char-width CHAR) */)
345 CHECK_CHARACTER (ch
);
347 width
= char_width (c
, buffer_display_table ());
348 return make_number (width
);
351 /* Return width of string STR of length LEN when displayed in the
352 current buffer. The width is measured by how many columns it
353 occupies on the screen. If PRECISION > 0, return the width of
354 longest substring that doesn't exceed PRECISION, and set number of
355 characters and bytes of the substring in *NCHARS and *NBYTES
359 c_string_width (const unsigned char *str
, EMACS_INT len
, int precision
,
360 EMACS_INT
*nchars
, EMACS_INT
*nbytes
)
362 EMACS_INT i
= 0, i_byte
= 0;
364 struct Lisp_Char_Table
*dp
= buffer_display_table ();
369 int c
= STRING_CHAR_AND_LENGTH (str
+ i_byte
, bytes
);
370 int thiswidth
= char_width (c
, dp
);
373 && (width
+ thiswidth
> precision
))
393 /* Return width of string STR of length LEN when displayed in the
394 current buffer. The width is measured by how many columns it
395 occupies on the screen. */
398 strwidth (const char *str
, EMACS_INT len
)
400 return c_string_width ((const unsigned char *) str
, len
, -1, NULL
, NULL
);
403 /* Return width of Lisp string STRING when displayed in the current
404 buffer. The width is measured by how many columns it occupies on
405 the screen while paying attention to compositions. If PRECISION >
406 0, return the width of longest substring that doesn't exceed
407 PRECISION, and set number of characters and bytes of the substring
408 in *NCHARS and *NBYTES respectively. */
411 lisp_string_width (Lisp_Object string
, EMACS_INT precision
,
412 EMACS_INT
*nchars
, EMACS_INT
*nbytes
)
414 EMACS_INT len
= SCHARS (string
);
415 /* This set multibyte to 0 even if STRING is multibyte when it
416 contains only ascii and eight-bit-graphic, but that's
418 int multibyte
= len
< SBYTES (string
);
419 unsigned char *str
= SDATA (string
);
420 EMACS_INT i
= 0, i_byte
= 0;
422 struct Lisp_Char_Table
*dp
= buffer_display_table ();
426 EMACS_INT chars
, bytes
, thiswidth
;
429 EMACS_INT ignore
, end
;
431 if (find_composition (i
, -1, &ignore
, &end
, &val
, string
)
432 && ((cmp_id
= get_composition_id (i
, i_byte
, end
- i
, val
, string
))
435 thiswidth
= composition_table
[cmp_id
]->width
;
437 bytes
= string_char_to_byte (string
, end
) - i_byte
;
446 c
= STRING_CHAR_AND_LENGTH (str
+ i_byte
, cbytes
);
450 c
= str
[i_byte
], bytes
= 1;
452 thiswidth
= char_width (c
, dp
);
458 if (INT_ADD_OVERFLOW (width
, thiswidth
))
462 else if (precision
- width
< thiswidth
)
482 DEFUN ("string-width", Fstring_width
, Sstring_width
, 1, 1, 0,
483 doc
: /* Return width of STRING when displayed in the current buffer.
484 Width is measured by how many columns it occupies on the screen.
485 When calculating width of a multibyte character in STRING,
486 only the base leading-code is considered; the validity of
487 the following bytes is not checked. Tabs in STRING are always
488 taken to occupy `tab-width' columns.
489 usage: (string-width STRING) */)
495 XSETFASTINT (val
, lisp_string_width (str
, -1, NULL
, NULL
));
499 /* Return the number of characters in the NBYTES bytes at PTR.
500 This works by looking at the contents and checking for multibyte
501 sequences while assuming that there's no invalid sequence.
502 However, if the current buffer has enable-multibyte-characters =
503 nil, we treat each byte as a character. */
506 chars_in_text (const unsigned char *ptr
, EMACS_INT nbytes
)
508 /* current_buffer is null at early stages of Emacs initialization. */
509 if (current_buffer
== 0
510 || NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
513 return multibyte_chars_in_text (ptr
, nbytes
);
516 /* Return the number of characters in the NBYTES bytes at PTR.
517 This works by looking at the contents and checking for multibyte
518 sequences while assuming that there's no invalid sequence. It
519 ignores enable-multibyte-characters. */
522 multibyte_chars_in_text (const unsigned char *ptr
, EMACS_INT nbytes
)
524 const unsigned char *endp
= ptr
+ nbytes
;
529 EMACS_INT len
= MULTIBYTE_LENGTH (ptr
, endp
);
540 /* Parse unibyte text at STR of LEN bytes as a multibyte text, count
541 characters and bytes in it, and store them in *NCHARS and *NBYTES
542 respectively. On counting bytes, pay attention to that 8-bit
543 characters not constructing a valid multibyte sequence are
544 represented by 2-byte in a multibyte text. */
547 parse_str_as_multibyte (const unsigned char *str
, EMACS_INT len
,
548 EMACS_INT
*nchars
, EMACS_INT
*nbytes
)
550 const unsigned char *endp
= str
+ len
;
551 EMACS_INT n
, chars
= 0, bytes
= 0;
553 if (len
>= MAX_MULTIBYTE_LENGTH
)
555 const unsigned char *adjusted_endp
= endp
- MAX_MULTIBYTE_LENGTH
;
556 while (str
< adjusted_endp
)
558 if (! CHAR_BYTE8_HEAD_P (*str
)
559 && (n
= MULTIBYTE_LENGTH_NO_CHECK (str
)) > 0)
560 str
+= n
, bytes
+= n
;
568 if (! CHAR_BYTE8_HEAD_P (*str
)
569 && (n
= MULTIBYTE_LENGTH (str
, endp
)) > 0)
570 str
+= n
, bytes
+= n
;
581 /* Arrange unibyte text at STR of NBYTES bytes as a multibyte text.
582 It actually converts only such 8-bit characters that don't construct
583 a multibyte sequence to multibyte forms of Latin-1 characters. If
584 NCHARS is nonzero, set *NCHARS to the number of characters in the
585 text. It is assured that we can use LEN bytes at STR as a work
586 area and that is enough. Return the number of bytes of the
590 str_as_multibyte (unsigned char *str
, EMACS_INT len
, EMACS_INT nbytes
,
593 unsigned char *p
= str
, *endp
= str
+ nbytes
;
598 if (nbytes
>= MAX_MULTIBYTE_LENGTH
)
600 unsigned char *adjusted_endp
= endp
- MAX_MULTIBYTE_LENGTH
;
601 while (p
< adjusted_endp
602 && ! CHAR_BYTE8_HEAD_P (*p
)
603 && (n
= MULTIBYTE_LENGTH_NO_CHECK (p
)) > 0)
607 && ! CHAR_BYTE8_HEAD_P (*p
)
608 && (n
= MULTIBYTE_LENGTH (p
, endp
)) > 0)
618 memmove (endp
- nbytes
, p
, nbytes
);
621 if (nbytes
>= MAX_MULTIBYTE_LENGTH
)
623 unsigned char *adjusted_endp
= endp
- MAX_MULTIBYTE_LENGTH
;
624 while (p
< adjusted_endp
)
626 if (! CHAR_BYTE8_HEAD_P (*p
)
627 && (n
= MULTIBYTE_LENGTH_NO_CHECK (p
)) > 0)
635 c
= BYTE8_TO_CHAR (c
);
636 to
+= CHAR_STRING (c
, to
);
643 if (! CHAR_BYTE8_HEAD_P (*p
)
644 && (n
= MULTIBYTE_LENGTH (p
, endp
)) > 0)
652 c
= BYTE8_TO_CHAR (c
);
653 to
+= CHAR_STRING (c
, to
);
662 /* Parse unibyte string at STR of LEN bytes, and return the number of
663 bytes it may occupy when converted to multibyte string by
664 `str_to_multibyte'. */
667 count_size_as_multibyte (const unsigned char *str
, EMACS_INT len
)
669 const unsigned char *endp
= str
+ len
;
672 for (bytes
= 0; str
< endp
; str
++)
674 int n
= *str
< 0x80 ? 1 : 2;
675 if (INT_ADD_OVERFLOW (bytes
, n
))
683 /* Convert unibyte text at STR of BYTES bytes to a multibyte text
684 that contains the same single-byte characters. It actually
685 converts all 8-bit characters to multibyte forms. It is assured
686 that we can use LEN bytes at STR as a work area and that is
690 str_to_multibyte (unsigned char *str
, EMACS_INT len
, EMACS_INT bytes
)
692 unsigned char *p
= str
, *endp
= str
+ bytes
;
695 while (p
< endp
&& *p
< 0x80) p
++;
701 memmove (endp
- bytes
, p
, bytes
);
708 c
= BYTE8_TO_CHAR (c
);
709 to
+= CHAR_STRING (c
, to
);
714 /* Arrange multibyte text at STR of LEN bytes as a unibyte text. It
715 actually converts characters in the range 0x80..0xFF to
719 str_as_unibyte (unsigned char *str
, EMACS_INT bytes
)
721 const unsigned char *p
= str
, *endp
= str
+ bytes
;
728 len
= BYTES_BY_CHAR_HEAD (c
);
729 if (CHAR_BYTE8_HEAD_P (c
))
733 to
= str
+ (p
- str
);
737 len
= BYTES_BY_CHAR_HEAD (c
);
738 if (CHAR_BYTE8_HEAD_P (c
))
740 c
= STRING_CHAR_ADVANCE (p
);
741 *to
++ = CHAR_TO_BYTE8 (c
);
745 while (len
--) *to
++ = *p
++;
751 /* Convert eight-bit chars in SRC (in multibyte form) to the
752 corresponding byte and store in DST. CHARS is the number of
753 characters in SRC. The value is the number of bytes stored in DST.
754 Usually, the value is the same as CHARS, but is less than it if SRC
755 contains a non-ASCII, non-eight-bit character. If ACCEPT_LATIN_1
756 is nonzero, a Latin-1 character is accepted and converted to a byte
757 of that character code.
758 Note: Currently the arg ACCEPT_LATIN_1 is not used. */
761 str_to_unibyte (const unsigned char *src
, unsigned char *dst
, EMACS_INT chars
, int accept_latin_1
)
765 for (i
= 0; i
< chars
; i
++)
767 int c
= STRING_CHAR_ADVANCE (src
);
769 if (CHAR_BYTE8_P (c
))
770 c
= CHAR_TO_BYTE8 (c
);
771 else if (! ASCII_CHAR_P (c
)
772 && (! accept_latin_1
|| c
>= 0x100))
781 string_count_byte8 (Lisp_Object string
)
783 int multibyte
= STRING_MULTIBYTE (string
);
784 EMACS_INT nbytes
= SBYTES (string
);
785 unsigned char *p
= SDATA (string
);
786 unsigned char *pend
= p
+ nbytes
;
794 len
= BYTES_BY_CHAR_HEAD (c
);
796 if (CHAR_BYTE8_HEAD_P (c
))
811 string_escape_byte8 (Lisp_Object string
)
813 EMACS_INT nchars
= SCHARS (string
);
814 EMACS_INT nbytes
= SBYTES (string
);
815 int multibyte
= STRING_MULTIBYTE (string
);
816 EMACS_INT byte8_count
;
817 const unsigned char *src
, *src_end
;
822 if (multibyte
&& nchars
== nbytes
)
825 byte8_count
= string_count_byte8 (string
);
827 if (byte8_count
== 0)
832 if ((MOST_POSITIVE_FIXNUM
- nchars
) / 3 < byte8_count
833 || (STRING_BYTES_BOUND
- nbytes
) / 2 < byte8_count
)
836 /* Convert 2-byte sequence of byte8 chars to 4-byte octal. */
837 val
= make_uninit_multibyte_string (nchars
+ byte8_count
* 3,
838 nbytes
+ byte8_count
* 2);
842 if ((STRING_BYTES_BOUND
- nbytes
) / 3 < byte8_count
)
845 /* Convert 1-byte sequence of byte8 chars to 4-byte octal. */
846 val
= make_uninit_string (nbytes
+ byte8_count
* 3);
849 src
= SDATA (string
);
850 src_end
= src
+ nbytes
;
853 while (src
< src_end
)
856 len
= BYTES_BY_CHAR_HEAD (c
);
858 if (CHAR_BYTE8_HEAD_P (c
))
860 c
= STRING_CHAR_ADVANCE (src
);
861 c
= CHAR_TO_BYTE8 (c
);
862 sprintf ((char *) dst
, "\\%03o", c
);
866 while (len
--) *dst
++ = *src
++;
869 while (src
< src_end
)
874 sprintf ((char *) dst
, "\\%03o", c
);
884 DEFUN ("string", Fstring
, Sstring
, 0, MANY
, 0,
886 Concatenate all the argument characters and make the result a string.
887 usage: (string &rest CHARACTERS) */)
888 (ptrdiff_t n
, Lisp_Object
*args
)
892 unsigned char *buf
, *p
;
896 SAFE_NALLOCA (buf
, MAX_MULTIBYTE_LENGTH
, n
);
899 for (i
= 0; i
< n
; i
++)
901 CHECK_CHARACTER (args
[i
]);
903 p
+= CHAR_STRING (c
, p
);
906 str
= make_string_from_bytes ((char *) buf
, n
, p
- buf
);
911 DEFUN ("unibyte-string", Funibyte_string
, Sunibyte_string
, 0, MANY
, 0,
912 doc
: /* Concatenate all the argument bytes and make the result a unibyte string.
913 usage: (unibyte-string &rest BYTES) */)
914 (ptrdiff_t n
, Lisp_Object
*args
)
918 unsigned char *buf
, *p
;
922 SAFE_ALLOCA (buf
, unsigned char *, n
);
925 for (i
= 0; i
< n
; i
++)
927 CHECK_NATNUM (args
[i
]);
928 c
= XFASTINT (args
[i
]);
930 args_out_of_range_3 (args
[i
], make_number (0), make_number (255));
934 str
= make_string_from_bytes ((char *) buf
, n
, p
- buf
);
939 DEFUN ("char-resolve-modifiers", Fchar_resolve_modifiers
,
940 Schar_resolve_modifiers
, 1, 1, 0,
941 doc
: /* Resolve modifiers in the character CHAR.
942 The value is a character with modifiers resolved into the character
943 code. Unresolved modifiers are kept in the value.
944 usage: (char-resolve-modifiers CHAR) */)
945 (Lisp_Object character
)
949 CHECK_NUMBER (character
);
950 c
= XINT (character
);
951 return make_number (char_resolve_modifier_mask (c
));
954 DEFUN ("get-byte", Fget_byte
, Sget_byte
, 0, 2, 0,
955 doc
: /* Return a byte value of a character at point.
956 Optional 1st arg POSITION, if non-nil, is a position of a character to get
958 Optional 2nd arg STRING, if non-nil, is a string of which first
959 character is a target to get a byte value. In this case, POSITION, if
960 non-nil, is an index of a target character in the string.
962 If the current buffer (or STRING) is multibyte, and the target
963 character is not ASCII nor 8-bit character, an error is signaled. */)
964 (Lisp_Object position
, Lisp_Object string
)
978 CHECK_NUMBER_COERCE_MARKER (position
);
979 if (XINT (position
) < BEGV
|| XINT (position
) >= ZV
)
980 args_out_of_range_3 (position
, make_number (BEGV
), make_number (ZV
));
981 pos
= XFASTINT (position
);
982 p
= CHAR_POS_ADDR (pos
);
984 if (NILP (BVAR (current_buffer
, enable_multibyte_characters
)))
985 return make_number (*p
);
989 CHECK_STRING (string
);
996 CHECK_NATNUM (position
);
997 if (XINT (position
) >= SCHARS (string
))
998 args_out_of_range (string
, position
);
999 pos
= XFASTINT (position
);
1000 p
= SDATA (string
) + string_char_to_byte (string
, pos
);
1002 if (! STRING_MULTIBYTE (string
))
1003 return make_number (*p
);
1005 c
= STRING_CHAR (p
);
1006 if (CHAR_BYTE8_P (c
))
1007 c
= CHAR_TO_BYTE8 (c
);
1008 else if (! ASCII_CHAR_P (c
))
1009 error ("Not an ASCII nor an 8-bit character: %d", c
);
1010 return make_number (c
);
1015 init_character_once (void)
1022 syms_of_character (void)
1024 DEFSYM (Qcharacterp
, "characterp");
1025 DEFSYM (Qauto_fill_chars
, "auto-fill-chars");
1027 staticpro (&Vchar_unify_table
);
1028 Vchar_unify_table
= Qnil
;
1030 defsubr (&Smax_char
);
1031 defsubr (&Scharacterp
);
1032 defsubr (&Sunibyte_char_to_multibyte
);
1033 defsubr (&Smultibyte_char_to_unibyte
);
1034 defsubr (&Schar_width
);
1035 defsubr (&Sstring_width
);
1037 defsubr (&Sunibyte_string
);
1038 defsubr (&Schar_resolve_modifiers
);
1039 defsubr (&Sget_byte
);
1041 DEFVAR_LISP ("translation-table-vector", Vtranslation_table_vector
,
1043 Vector recording all translation tables ever defined.
1044 Each element is a pair (SYMBOL . TABLE) relating the table to the
1045 symbol naming it. The ID of a translation table is an index into this vector. */);
1046 Vtranslation_table_vector
= Fmake_vector (make_number (16), Qnil
);
1048 DEFVAR_LISP ("auto-fill-chars", Vauto_fill_chars
,
1050 A char-table for characters which invoke auto-filling.
1051 Such characters have value t in this table. */);
1052 Vauto_fill_chars
= Fmake_char_table (Qauto_fill_chars
, Qnil
);
1053 CHAR_TABLE_SET (Vauto_fill_chars
, ' ', Qt
);
1054 CHAR_TABLE_SET (Vauto_fill_chars
, '\n', Qt
);
1056 DEFVAR_LISP ("char-width-table", Vchar_width_table
,
1058 A char-table for width (columns) of each character. */);
1059 Vchar_width_table
= Fmake_char_table (Qnil
, make_number (1));
1060 char_table_set_range (Vchar_width_table
, 0x80, 0x9F, make_number (4));
1061 char_table_set_range (Vchar_width_table
, MAX_5_BYTE_CHAR
+ 1, MAX_CHAR
,
1064 DEFVAR_LISP ("printable-chars", Vprintable_chars
,
1065 doc
: /* A char-table for each printable character. */);
1066 Vprintable_chars
= Fmake_char_table (Qnil
, Qnil
);
1067 Fset_char_table_range (Vprintable_chars
,
1068 Fcons (make_number (32), make_number (126)), Qt
);
1069 Fset_char_table_range (Vprintable_chars
,
1070 Fcons (make_number (160),
1071 make_number (MAX_5_BYTE_CHAR
)), Qt
);
1073 DEFVAR_LISP ("char-script-table", Vchar_script_table
,
1074 doc
: /* Char table of script symbols.
1075 It has one extra slot whose value is a list of script symbols. */);
1077 /* Intern this now in case it isn't already done.
1078 Setting this variable twice is harmless.
1079 But don't staticpro it here--that is done in alloc.c. */
1080 Qchar_table_extra_slots
= intern_c_string ("char-table-extra-slots");
1081 DEFSYM (Qchar_script_table
, "char-script-table");
1082 Fput (Qchar_script_table
, Qchar_table_extra_slots
, make_number (1));
1083 Vchar_script_table
= Fmake_char_table (Qchar_script_table
, Qnil
);
1085 DEFVAR_LISP ("script-representative-chars", Vscript_representative_chars
,
1086 doc
: /* Alist of scripts vs the representative characters.
1087 Each element is a cons (SCRIPT . CHARS).
1088 SCRIPT is a symbol representing a script or a subgroup of a script.
1089 CHARS is a list or a vector of characters.
1090 If it is a list, all characters in the list are necessary for supporting SCRIPT.
1091 If it is a vector, one of the characters in the vector is necessary.
1092 This variable is used to find a font for a specific script. */);
1093 Vscript_representative_chars
= Qnil
;
1095 DEFVAR_LISP ("unicode-category-table", Vunicode_category_table
,
1096 doc
: /* Char table of Unicode's "General Category".
1097 All Unicode characters have one of the following values (symbol):
1098 Lu, Ll, Lt, Lm, Lo, Mn, Mc, Me, Nd, Nl, No, Pc, Pd, Ps, Pe, Pi, Pf, Po,
1099 Sm, Sc, Sk, So, Zs, Zl, Zp, Cc, Cf, Cs, Co, Cn
1100 See The Unicode Standard for the meaning of those values. */);
1101 /* The correct char-table is setup in characters.el. */
1102 Vunicode_category_table
= Qnil
;