1 /* Basic character support.
2 Copyright (C) 1995, 1997, 1998, 2001 Electrotechnical Laboratory, JAPAN.
3 Licensed to the Free Software Foundation.
4 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
5 Free Software Foundation, Inc.
6 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
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 /* Vector of translation table ever defined.
54 ID of a translation table is used to index this vector. */
55 Lisp_Object Vtranslation_table_vector
;
57 /* A char-table for characters which may invoke auto-filling. */
58 Lisp_Object Vauto_fill_chars
;
60 Lisp_Object Qauto_fill_chars
;
62 /* Char-table of information about which character to unify to which
63 Unicode character. Mainly used by the macro MAYBE_UNIFY_CHAR. */
64 Lisp_Object Vchar_unify_table
;
66 /* A char-table. An element is non-nil iff the corresponding
67 character has a printable glyph. */
68 Lisp_Object Vprintable_chars
;
70 /* A char-table. An elemnent is a column-width of the corresponding
72 Lisp_Object Vchar_width_table
;
74 /* A char-table. An element is a symbol indicating the direction
75 property of corresponding character. */
76 Lisp_Object Vchar_direction_table
;
78 /* Variable used locally in the macro FETCH_MULTIBYTE_CHAR. */
79 unsigned char *_fetch_multibyte_char_p
;
81 /* Char table of scripts. */
82 Lisp_Object Vchar_script_table
;
84 /* Alist of scripts vs representative characters. */
85 Lisp_Object Vscript_representative_chars
;
87 static Lisp_Object Qchar_script_table
;
89 Lisp_Object Vunicode_category_table
;
92 /* If character code C has modifier masks, reflect them to the
93 character code if possible. Return the resulting code. */
96 char_resolve_modifier_mask (int c
)
98 /* A non-ASCII character can't reflect modifier bits to the code. */
99 if (! ASCII_CHAR_P ((c
& ~CHAR_MODIFIER_MASK
)))
102 /* For Meta, Shift, and Control modifiers, we need special care. */
105 /* Shift modifier is valid only with [A-Za-z]. */
106 if ((c
& 0377) >= 'A' && (c
& 0377) <= 'Z')
108 else if ((c
& 0377) >= 'a' && (c
& 0377) <= 'z')
109 c
= (c
& ~CHAR_SHIFT
) - ('a' - 'A');
110 /* Shift modifier for control characters and SPC is ignored. */
111 else if ((c
& ~CHAR_MODIFIER_MASK
) <= 0x20)
116 /* Simulate the code in lread.c. */
117 /* Allow `\C- ' and `\C-?'. */
118 if ((c
& 0377) == ' ')
119 c
&= ~0177 & ~ CHAR_CTL
;
120 else if ((c
& 0377) == '?')
121 c
= 0177 | (c
& ~0177 & ~CHAR_CTL
);
122 /* ASCII control chars are made from letters (both cases),
123 as well as the non-letters within 0100...0137. */
124 else if ((c
& 0137) >= 0101 && (c
& 0137) <= 0132)
125 c
&= (037 | (~0177 & ~CHAR_CTL
));
126 else if ((c
& 0177) >= 0100 && (c
& 0177) <= 0137)
127 c
&= (037 | (~0177 & ~CHAR_CTL
));
129 #if 0 /* This is outside the scope of this function. (bug#4751) */
132 /* Move the meta bit to the right place for a string. */
133 c
= (c
& ~CHAR_META
) | 0x80;
141 /* Store multibyte form of character C at P. If C has modifier bits,
142 handle them appropriately. */
145 char_string (unsigned int c
, unsigned char *p
)
149 if (c
& CHAR_MODIFIER_MASK
)
151 c
= (unsigned) char_resolve_modifier_mask ((int) c
);
152 /* If C still has any modifier bits, just ignore it. */
153 c
&= ~CHAR_MODIFIER_MASK
;
156 MAYBE_UNIFY_CHAR (c
);
158 if (c
<= MAX_3_BYTE_CHAR
)
160 bytes
= CHAR_STRING (c
, p
);
162 else if (c
<= MAX_4_BYTE_CHAR
)
164 p
[0] = (0xF0 | (c
>> 18));
165 p
[1] = (0x80 | ((c
>> 12) & 0x3F));
166 p
[2] = (0x80 | ((c
>> 6) & 0x3F));
167 p
[3] = (0x80 | (c
& 0x3F));
170 else if (c
<= MAX_5_BYTE_CHAR
)
173 p
[1] = (0x80 | ((c
>> 18) & 0x0F));
174 p
[2] = (0x80 | ((c
>> 12) & 0x3F));
175 p
[3] = (0x80 | ((c
>> 6) & 0x3F));
176 p
[4] = (0x80 | (c
& 0x3F));
179 else if (c
<= MAX_CHAR
)
181 c
= CHAR_TO_BYTE8 (c
);
182 bytes
= BYTE8_STRING (c
, p
);
185 error ("Invalid character: %d", c
);
191 /* Return a character whose multibyte form is at P. Set LEN is not
192 NULL, it must be a pointer to integer. In that case, set *LEN to
193 the byte length of the multibyte form. If ADVANCED is not NULL, is
194 must be a pointer to unsigned char. In that case, set *ADVANCED to
195 the ending address (i.e. the starting address of the next
196 character) of the multibyte form. */
199 string_char (const unsigned char *p
, const unsigned char **advanced
, int *len
)
202 const unsigned char *saved_p
= p
;
204 if (*p
< 0x80 || ! (*p
& 0x20) || ! (*p
& 0x10))
206 c
= STRING_CHAR_ADVANCE (p
);
208 else if (! (*p
& 0x08))
210 c
= ((((p
)[0] & 0xF) << 18)
211 | (((p
)[1] & 0x3F) << 12)
212 | (((p
)[2] & 0x3F) << 6)
218 c
= ((((p
)[1] & 0x3F) << 18)
219 | (((p
)[2] & 0x3F) << 12)
220 | (((p
)[3] & 0x3F) << 6)
225 MAYBE_UNIFY_CHAR (c
);
235 /* Translate character C by translation table TABLE. If C is
236 negative, translate a character specified by CHARSET and CODE. If
237 no translation is found in TABLE, return the untranslated
238 character. If TABLE is a list, elements are char tables. In this
239 case, translace C by all tables. */
242 translate_char (Lisp_Object table
, int c
)
244 if (CHAR_TABLE_P (table
))
248 ch
= CHAR_TABLE_REF (table
, c
);
254 for (; CONSP (table
); table
= XCDR (table
))
255 c
= translate_char (XCAR (table
), c
);
260 /* Convert ASCII or 8-bit character C to unibyte. If C is none of
261 them, return (C & 0xFF).
263 The argument REV_TBL is now ignored. It will be removed in the
267 multibyte_char_to_unibyte (int c
, Lisp_Object rev_tbl
)
271 if (CHAR_BYTE8_P (c
))
272 return CHAR_TO_BYTE8 (c
);
276 /* Like multibyte_char_to_unibyte, but return -1 if C is not supported
277 by charset_unibyte. */
280 multibyte_char_to_unibyte_safe (int c
)
284 if (CHAR_BYTE8_P (c
))
285 return CHAR_TO_BYTE8 (c
);
289 DEFUN ("characterp", Fcharacterp
, Scharacterp
, 1, 2, 0,
290 doc
: /* Return non-nil if OBJECT is a character. */)
292 Lisp_Object object
, ignore
;
294 return (CHARACTERP (object
) ? Qt
: Qnil
);
297 DEFUN ("max-char", Fmax_char
, Smax_char
, 0, 0, 0,
298 doc
: /* Return the character of the maximum code. */)
301 return make_number (MAX_CHAR
);
304 DEFUN ("unibyte-char-to-multibyte", Funibyte_char_to_multibyte
,
305 Sunibyte_char_to_multibyte
, 1, 1, 0,
306 doc
: /* Convert the byte CH to multibyte character. */)
312 CHECK_CHARACTER (ch
);
315 error ("Not a unibyte character: %d", c
);
316 MAKE_CHAR_MULTIBYTE (c
);
317 return make_number (c
);
320 DEFUN ("multibyte-char-to-unibyte", Fmultibyte_char_to_unibyte
,
321 Smultibyte_char_to_unibyte
, 1, 1, 0,
322 doc
: /* Convert the multibyte character CH to a byte.
323 If the multibyte character does not represent a byte, return -1. */)
329 CHECK_CHARACTER (ch
);
332 /* Can't distinguish a byte read from a unibyte buffer from
333 a latin1 char, so let's let it slide. */
337 int cu
= CHAR_TO_BYTE_SAFE (cm
);
338 return make_number (cu
);
342 DEFUN ("char-bytes", Fchar_bytes
, Schar_bytes
, 1, 1, 0,
343 doc
: /* Return 1 regardless of the argument CHAR.
344 This is now an obsolete function. We keep it just for backward compatibility.
345 usage: (char-bytes CHAR) */)
349 CHECK_CHARACTER (ch
);
350 return make_number (1);
353 DEFUN ("char-width", Fchar_width
, Schar_width
, 1, 1, 0,
354 doc
: /* Return width of CHAR when displayed in the current buffer.
355 The width is measured by how many columns it occupies on the screen.
356 Tab is taken to occupy `tab-width' columns.
357 usage: (char-width CHAR) */)
363 struct Lisp_Char_Table
*dp
= buffer_display_table ();
365 CHECK_CHARACTER (ch
);
368 /* Get the way the display table would display it. */
369 disp
= dp
? DISP_CHAR_VECTOR (dp
, c
) : Qnil
;
372 width
= ASIZE (disp
);
374 width
= CHAR_WIDTH (c
);
376 return make_number (width
);
379 /* Return width of string STR of length LEN when displayed in the
380 current buffer. The width is measured by how many columns it
381 occupies on the screen. If PRECISION > 0, return the width of
382 longest substring that doesn't exceed PRECISION, and set number of
383 characters and bytes of the substring in *NCHARS and *NBYTES
387 c_string_width (const unsigned char *str
, int len
, int precision
, int *nchars
, int *nbytes
)
389 int i
= 0, i_byte
= 0;
391 struct Lisp_Char_Table
*dp
= buffer_display_table ();
395 int bytes
, thiswidth
;
397 int c
= STRING_CHAR_AND_LENGTH (str
+ i_byte
, bytes
);
401 val
= DISP_CHAR_VECTOR (dp
, c
);
403 thiswidth
= XVECTOR (val
)->size
;
405 thiswidth
= CHAR_WIDTH (c
);
409 thiswidth
= CHAR_WIDTH (c
);
413 && (width
+ thiswidth
> precision
))
433 /* Return width of string STR of length LEN when displayed in the
434 current buffer. The width is measured by how many columns it
435 occupies on the screen. */
438 strwidth (unsigned char *str
, int len
)
440 return c_string_width (str
, len
, -1, NULL
, NULL
);
443 /* Return width of Lisp string STRING when displayed in the current
444 buffer. The width is measured by how many columns it occupies on
445 the screen while paying attention to compositions. If PRECISION >
446 0, return the width of longest substring that doesn't exceed
447 PRECISION, and set number of characters and bytes of the substring
448 in *NCHARS and *NBYTES respectively. */
451 lisp_string_width (Lisp_Object string
, int precision
, int *nchars
, int *nbytes
)
453 int len
= SCHARS (string
);
454 /* This set multibyte to 0 even if STRING is multibyte when it
455 contains only ascii and eight-bit-graphic, but that's
457 int multibyte
= len
< SBYTES (string
);
458 unsigned char *str
= SDATA (string
);
459 int i
= 0, i_byte
= 0;
461 struct Lisp_Char_Table
*dp
= buffer_display_table ();
465 int chars
, bytes
, thiswidth
;
468 EMACS_INT ignore
, end
;
470 if (find_composition (i
, -1, &ignore
, &end
, &val
, string
)
471 && ((cmp_id
= get_composition_id (i
, i_byte
, end
- i
, val
, string
))
474 thiswidth
= composition_table
[cmp_id
]->width
;
476 bytes
= string_char_to_byte (string
, end
) - i_byte
;
483 c
= STRING_CHAR_AND_LENGTH (str
+ i_byte
, bytes
);
485 c
= str
[i_byte
], bytes
= 1;
489 val
= DISP_CHAR_VECTOR (dp
, c
);
491 thiswidth
= XVECTOR (val
)->size
;
493 thiswidth
= CHAR_WIDTH (c
);
497 thiswidth
= CHAR_WIDTH (c
);
502 && (width
+ thiswidth
> precision
))
522 DEFUN ("string-width", Fstring_width
, Sstring_width
, 1, 1, 0,
523 doc
: /* Return width of STRING when displayed in the current buffer.
524 Width is measured by how many columns it occupies on the screen.
525 When calculating width of a multibyte character in STRING,
526 only the base leading-code is considered; the validity of
527 the following bytes is not checked. Tabs in STRING are always
528 taken to occupy `tab-width' columns.
529 usage: (string-width STRING) */)
536 XSETFASTINT (val
, lisp_string_width (str
, -1, NULL
, NULL
));
540 DEFUN ("char-direction", Fchar_direction
, Schar_direction
, 1, 1, 0,
541 doc
: /* Return the direction of CHAR.
542 The returned value is 0 for left-to-right and 1 for right-to-left.
543 usage: (char-direction CHAR) */)
549 CHECK_CHARACTER (ch
);
551 return CHAR_TABLE_REF (Vchar_direction_table
, c
);
554 /* Return the number of characters in the NBYTES bytes at PTR.
555 This works by looking at the contents and checking for multibyte
556 sequences while assuming that there's no invalid sequence.
557 However, if the current buffer has enable-multibyte-characters =
558 nil, we treat each byte as a character. */
561 chars_in_text (const unsigned char *ptr
, EMACS_INT nbytes
)
563 /* current_buffer is null at early stages of Emacs initialization. */
564 if (current_buffer
== 0
565 || NILP (current_buffer
->enable_multibyte_characters
))
568 return multibyte_chars_in_text (ptr
, nbytes
);
571 /* Return the number of characters in the NBYTES bytes at PTR.
572 This works by looking at the contents and checking for multibyte
573 sequences while assuming that there's no invalid sequence. It
574 ignores enable-multibyte-characters. */
577 multibyte_chars_in_text (const unsigned char *ptr
, EMACS_INT nbytes
)
579 const unsigned char *endp
= ptr
+ nbytes
;
584 int len
= MULTIBYTE_LENGTH (ptr
, endp
);
595 /* Parse unibyte text at STR of LEN bytes as a multibyte text, count
596 characters and bytes in it, and store them in *NCHARS and *NBYTES
597 respectively. On counting bytes, pay attention to that 8-bit
598 characters not constructing a valid multibyte sequence are
599 represented by 2-byte in a multibyte text. */
602 parse_str_as_multibyte (const unsigned char *str
, int len
, int *nchars
, int *nbytes
)
604 const unsigned char *endp
= str
+ len
;
605 int n
, chars
= 0, bytes
= 0;
607 if (len
>= MAX_MULTIBYTE_LENGTH
)
609 const unsigned char *adjusted_endp
= endp
- MAX_MULTIBYTE_LENGTH
;
610 while (str
< adjusted_endp
)
612 if (! CHAR_BYTE8_HEAD_P (*str
)
613 && (n
= MULTIBYTE_LENGTH_NO_CHECK (str
)) > 0)
614 str
+= n
, bytes
+= n
;
622 if (! CHAR_BYTE8_HEAD_P (*str
)
623 && (n
= MULTIBYTE_LENGTH (str
, endp
)) > 0)
624 str
+= n
, bytes
+= n
;
635 /* Arrange unibyte text at STR of NBYTES bytes as a multibyte text.
636 It actually converts only such 8-bit characters that don't contruct
637 a multibyte sequence to multibyte forms of Latin-1 characters. If
638 NCHARS is nonzero, set *NCHARS to the number of characters in the
639 text. It is assured that we can use LEN bytes at STR as a work
640 area and that is enough. Return the number of bytes of the
644 str_as_multibyte (unsigned char *str
, int len
, int nbytes
, int *nchars
)
646 unsigned char *p
= str
, *endp
= str
+ nbytes
;
651 if (nbytes
>= MAX_MULTIBYTE_LENGTH
)
653 unsigned char *adjusted_endp
= endp
- MAX_MULTIBYTE_LENGTH
;
654 while (p
< adjusted_endp
655 && ! CHAR_BYTE8_HEAD_P (*p
)
656 && (n
= MULTIBYTE_LENGTH_NO_CHECK (p
)) > 0)
660 && ! CHAR_BYTE8_HEAD_P (*p
)
661 && (n
= MULTIBYTE_LENGTH (p
, endp
)) > 0)
671 memmove (endp
- nbytes
, p
, nbytes
);
674 if (nbytes
>= MAX_MULTIBYTE_LENGTH
)
676 unsigned char *adjusted_endp
= endp
- MAX_MULTIBYTE_LENGTH
;
677 while (p
< adjusted_endp
)
679 if (! CHAR_BYTE8_HEAD_P (*p
)
680 && (n
= MULTIBYTE_LENGTH_NO_CHECK (p
)) > 0)
688 c
= BYTE8_TO_CHAR (c
);
689 to
+= CHAR_STRING (c
, to
);
696 if (! CHAR_BYTE8_HEAD_P (*p
)
697 && (n
= MULTIBYTE_LENGTH (p
, endp
)) > 0)
705 c
= BYTE8_TO_CHAR (c
);
706 to
+= CHAR_STRING (c
, to
);
715 /* Parse unibyte string at STR of LEN bytes, and return the number of
716 bytes it may ocupy when converted to multibyte string by
717 `str_to_multibyte'. */
720 parse_str_to_multibyte (unsigned char *str
, int len
)
722 unsigned char *endp
= str
+ len
;
725 for (bytes
= 0; str
< endp
; str
++)
726 bytes
+= (*str
< 0x80) ? 1 : 2;
731 /* Convert unibyte text at STR of NBYTES bytes to a multibyte text
732 that contains the same single-byte characters. It actually
733 converts all 8-bit characters to multibyte forms. It is assured
734 that we can use LEN bytes at STR as a work area and that is
738 str_to_multibyte (unsigned char *str
, int len
, int bytes
)
740 unsigned char *p
= str
, *endp
= str
+ bytes
;
743 while (p
< endp
&& *p
< 0x80) p
++;
749 memmove (endp
- bytes
, p
, bytes
);
756 c
= BYTE8_TO_CHAR (c
);
757 to
+= CHAR_STRING (c
, to
);
762 /* Arrange multibyte text at STR of LEN bytes as a unibyte text. It
763 actually converts characters in the range 0x80..0xFF to
767 str_as_unibyte (unsigned char *str
, int bytes
)
769 const unsigned char *p
= str
, *endp
= str
+ bytes
;
776 len
= BYTES_BY_CHAR_HEAD (c
);
777 if (CHAR_BYTE8_HEAD_P (c
))
781 to
= str
+ (p
- str
);
785 len
= BYTES_BY_CHAR_HEAD (c
);
786 if (CHAR_BYTE8_HEAD_P (c
))
788 c
= STRING_CHAR_ADVANCE (p
);
789 *to
++ = CHAR_TO_BYTE8 (c
);
793 while (len
--) *to
++ = *p
++;
799 /* Convert eight-bit chars in SRC (in multibyte form) to the
800 corresponding byte and store in DST. CHARS is the number of
801 characters in SRC. The value is the number of bytes stored in DST.
802 Usually, the value is the same as CHARS, but is less than it if SRC
803 contains a non-ASCII, non-eight-bit characater. If ACCEPT_LATIN_1
804 is nonzero, a Latin-1 character is accepted and converted to a byte
805 of that character code.
806 Note: Currently the arg ACCEPT_LATIN_1 is not used. */
809 str_to_unibyte (const unsigned char *src
, unsigned char *dst
, EMACS_INT chars
, int accept_latin_1
)
813 for (i
= 0; i
< chars
; i
++)
815 int c
= STRING_CHAR_ADVANCE (src
);
817 if (CHAR_BYTE8_P (c
))
818 c
= CHAR_TO_BYTE8 (c
);
819 else if (! ASCII_CHAR_P (c
)
820 && (! accept_latin_1
|| c
>= 0x100))
829 string_count_byte8 (Lisp_Object string
)
831 int multibyte
= STRING_MULTIBYTE (string
);
832 int nbytes
= SBYTES (string
);
833 unsigned char *p
= SDATA (string
);
834 unsigned char *pend
= p
+ nbytes
;
842 len
= BYTES_BY_CHAR_HEAD (c
);
844 if (CHAR_BYTE8_HEAD_P (c
))
859 string_escape_byte8 (Lisp_Object string
)
861 int nchars
= SCHARS (string
);
862 int nbytes
= SBYTES (string
);
863 int multibyte
= STRING_MULTIBYTE (string
);
865 const unsigned char *src
, *src_end
;
870 if (multibyte
&& nchars
== nbytes
)
873 byte8_count
= string_count_byte8 (string
);
875 if (byte8_count
== 0)
879 /* Convert 2-byte sequence of byte8 chars to 4-byte octal. */
880 val
= make_uninit_multibyte_string (nchars
+ byte8_count
* 3,
881 nbytes
+ byte8_count
* 2);
883 /* Convert 1-byte sequence of byte8 chars to 4-byte octal. */
884 val
= make_uninit_string (nbytes
+ byte8_count
* 3);
886 src
= SDATA (string
);
887 src_end
= src
+ nbytes
;
890 while (src
< src_end
)
893 len
= BYTES_BY_CHAR_HEAD (c
);
895 if (CHAR_BYTE8_HEAD_P (c
))
897 c
= STRING_CHAR_ADVANCE (src
);
898 c
= CHAR_TO_BYTE8 (c
);
899 sprintf ((char *) dst
, "\\%03o", c
);
903 while (len
--) *dst
++ = *src
++;
906 while (src
< src_end
)
911 sprintf ((char *) dst
, "\\%03o", c
);
921 DEFUN ("string", Fstring
, Sstring
, 0, MANY
, 0,
923 Concatenate all the argument characters and make the result a string.
924 usage: (string &rest CHARACTERS) */)
930 unsigned char *buf
, *p
;
934 SAFE_ALLOCA (buf
, unsigned char *, MAX_MULTIBYTE_LENGTH
* n
);
937 for (i
= 0; i
< n
; i
++)
939 CHECK_CHARACTER (args
[i
]);
941 p
+= CHAR_STRING (c
, p
);
944 str
= make_string_from_bytes ((char *) buf
, n
, p
- buf
);
949 DEFUN ("unibyte-string", Funibyte_string
, Sunibyte_string
, 0, MANY
, 0,
950 doc
: /* Concatenate all the argument bytes and make the result a unibyte string.
951 usage: (unibyte-string &rest BYTES) */)
957 unsigned char *buf
, *p
;
961 SAFE_ALLOCA (buf
, unsigned char *, n
);
964 for (i
= 0; i
< n
; i
++)
966 CHECK_NATNUM (args
[i
]);
967 c
= XFASTINT (args
[i
]);
969 args_out_of_range_3 (args
[i
], make_number (0), make_number (255));
973 str
= make_string_from_bytes ((char *) buf
, n
, p
- buf
);
978 DEFUN ("char-resolve-modifiers", Fchar_resolve_modifiers
,
979 Schar_resolve_modifiers
, 1, 1, 0,
980 doc
: /* Resolve modifiers in the character CHAR.
981 The value is a character with modifiers resolved into the character
982 code. Unresolved modifiers are kept in the value.
983 usage: (char-resolve-modifiers CHAR) */)
985 Lisp_Object character
;
989 CHECK_NUMBER (character
);
990 c
= XINT (character
);
991 return make_number (char_resolve_modifier_mask (c
));
994 DEFUN ("get-byte", Fget_byte
, Sget_byte
, 0, 2, 0,
995 doc
: /* Return a byte value of a character at point.
996 Optional 1st arg POSITION, if non-nil, is a position of a character to get
998 Optional 2nd arg STRING, if non-nil, is a string of which first
999 character is a target to get a byte value. In this case, POSITION, if
1000 non-nil, is an index of a target character in the string.
1002 If the current buffer (or STRING) is multibyte, and the target
1003 character is not ASCII nor 8-bit character, an error is signalled. */)
1005 Lisp_Object position
, string
;
1013 if (NILP (position
))
1019 CHECK_NUMBER_COERCE_MARKER (position
);
1020 if (XINT (position
) < BEGV
|| XINT (position
) >= ZV
)
1021 args_out_of_range_3 (position
, make_number (BEGV
), make_number (ZV
));
1022 pos
= XFASTINT (position
);
1023 p
= CHAR_POS_ADDR (pos
);
1025 if (NILP (current_buffer
->enable_multibyte_characters
))
1026 return make_number (*p
);
1030 CHECK_STRING (string
);
1031 if (NILP (position
))
1037 CHECK_NATNUM (position
);
1038 if (XINT (position
) >= SCHARS (string
))
1039 args_out_of_range (string
, position
);
1040 pos
= XFASTINT (position
);
1041 p
= SDATA (string
) + string_char_to_byte (string
, pos
);
1043 if (! STRING_MULTIBYTE (string
))
1044 return make_number (*p
);
1046 c
= STRING_CHAR (p
);
1047 if (CHAR_BYTE8_P (c
))
1048 c
= CHAR_TO_BYTE8 (c
);
1049 else if (! ASCII_CHAR_P (c
))
1050 error ("Not an ASCII nor an 8-bit character: %d", c
);
1051 return make_number (c
);
1056 init_character_once (void)
1063 syms_of_character (void)
1065 DEFSYM (Qcharacterp
, "characterp");
1066 DEFSYM (Qauto_fill_chars
, "auto-fill-chars");
1068 staticpro (&Vchar_unify_table
);
1069 Vchar_unify_table
= Qnil
;
1071 defsubr (&Smax_char
);
1072 defsubr (&Scharacterp
);
1073 defsubr (&Sunibyte_char_to_multibyte
);
1074 defsubr (&Smultibyte_char_to_unibyte
);
1075 defsubr (&Schar_bytes
);
1076 defsubr (&Schar_width
);
1077 defsubr (&Sstring_width
);
1078 defsubr (&Schar_direction
);
1080 defsubr (&Sunibyte_string
);
1081 defsubr (&Schar_resolve_modifiers
);
1082 defsubr (&Sget_byte
);
1084 DEFVAR_LISP ("translation-table-vector", &Vtranslation_table_vector
,
1086 Vector recording all translation tables ever defined.
1087 Each element is a pair (SYMBOL . TABLE) relating the table to the
1088 symbol naming it. The ID of a translation table is an index into this vector. */);
1089 Vtranslation_table_vector
= Fmake_vector (make_number (16), Qnil
);
1091 DEFVAR_LISP ("auto-fill-chars", &Vauto_fill_chars
,
1093 A char-table for characters which invoke auto-filling.
1094 Such characters have value t in this table. */);
1095 Vauto_fill_chars
= Fmake_char_table (Qauto_fill_chars
, Qnil
);
1096 CHAR_TABLE_SET (Vauto_fill_chars
, ' ', Qt
);
1097 CHAR_TABLE_SET (Vauto_fill_chars
, '\n', Qt
);
1099 DEFVAR_LISP ("char-width-table", &Vchar_width_table
,
1101 A char-table for width (columns) of each character. */);
1102 Vchar_width_table
= Fmake_char_table (Qnil
, make_number (1));
1103 char_table_set_range (Vchar_width_table
, 0x80, 0x9F, make_number (4));
1104 char_table_set_range (Vchar_width_table
, MAX_5_BYTE_CHAR
+ 1, MAX_CHAR
,
1107 DEFVAR_LISP ("char-direction-table", &Vchar_direction_table
,
1108 doc
: /* A char-table for direction of each character. */);
1109 Vchar_direction_table
= Fmake_char_table (Qnil
, make_number (1));
1111 DEFVAR_LISP ("printable-chars", &Vprintable_chars
,
1112 doc
: /* A char-table for each printable character. */);
1113 Vprintable_chars
= Fmake_char_table (Qnil
, Qnil
);
1114 Fset_char_table_range (Vprintable_chars
,
1115 Fcons (make_number (32), make_number (126)), Qt
);
1116 Fset_char_table_range (Vprintable_chars
,
1117 Fcons (make_number (160),
1118 make_number (MAX_5_BYTE_CHAR
)), Qt
);
1120 DEFVAR_LISP ("char-script-table", &Vchar_script_table
,
1121 doc
: /* Char table of script symbols.
1122 It has one extra slot whose value is a list of script symbols. */);
1124 /* Intern this now in case it isn't already done.
1125 Setting this variable twice is harmless.
1126 But don't staticpro it here--that is done in alloc.c. */
1127 Qchar_table_extra_slots
= intern_c_string ("char-table-extra-slots");
1128 DEFSYM (Qchar_script_table
, "char-script-table");
1129 Fput (Qchar_script_table
, Qchar_table_extra_slots
, make_number (1));
1130 Vchar_script_table
= Fmake_char_table (Qchar_script_table
, Qnil
);
1132 DEFVAR_LISP ("script-representative-chars", &Vscript_representative_chars
,
1133 doc
: /* Alist of scripts vs the representative characters.
1134 Each element is a cons (SCRIPT . CHARS).
1135 SCRIPT is a symbol representing a script or a subgroup of a script.
1136 CHARS is a list or a vector of characters.
1137 If it is a list, all characters in the list are necessary for supporting SCRIPT.
1138 If it is a vector, one of the characters in the vector is necessary.
1139 This variable is used to find a font for a specific script. */);
1140 Vscript_representative_chars
= Qnil
;
1142 DEFVAR_LISP ("unicode-category-table", &Vunicode_category_table
,
1143 doc
: /* Char table of Unicode's "General Category".
1144 All Unicode characters have one of the following values (symbol):
1145 Lu, Ll, Lt, Lm, Lo, Mn, Mc, Me, Nd, Nl, No, Pc, Pd, Ps, Pe, Pi, Pf, Po,
1146 Sm, Sc, Sk, So, Zs, Zl, Zp, Cc, Cf, Cs, Co, Cn
1147 See The Unicode Standard for the meaning of those values. */);
1148 /* The correct char-table is setup in characters.el. */
1149 Vunicode_category_table
= Qnil
;
1154 /* arch-tag: b6665960-3c3d-4184-85cd-af4318197999
1155 (do not change this comment) */