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 impl_Vtranslation_table_vector
;
57 /* A char-table for characters which may invoke auto-filling. */
58 Lisp_Object impl_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 impl_Vprintable_chars
;
70 /* A char-table. An elemnent is a column-width of the corresponding
72 Lisp_Object impl_Vchar_width_table
;
74 /* A char-table. An element is a symbol indicating the direction
75 property of corresponding character. */
76 Lisp_Object impl_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 impl_Vchar_script_table
;
84 /* Alist of scripts vs representative characters. */
85 Lisp_Object impl_Vscript_representative_chars
;
87 static Lisp_Object Qchar_script_table
;
89 Lisp_Object impl_Vunicode_category_table
;
93 /* If character code C has modifier masks, reflect them to the
94 character code if possible. Return the resulting code. */
97 char_resolve_modifier_mask (c
)
100 /* A non-ASCII character can't reflect modifier bits to the code. */
101 if (! ASCII_CHAR_P ((c
& ~CHAR_MODIFIER_MASK
)))
104 /* For Meta, Shift, and Control modifiers, we need special care. */
107 /* Shift modifier is valid only with [A-Za-z]. */
108 if ((c
& 0377) >= 'A' && (c
& 0377) <= 'Z')
110 else if ((c
& 0377) >= 'a' && (c
& 0377) <= 'z')
111 c
= (c
& ~CHAR_SHIFT
) - ('a' - 'A');
112 /* Shift modifier for control characters and SPC is ignored. */
113 else if ((c
& ~CHAR_MODIFIER_MASK
) <= 0x20)
118 /* Simulate the code in lread.c. */
119 /* Allow `\C- ' and `\C-?'. */
120 if ((c
& 0377) == ' ')
121 c
&= ~0177 & ~ CHAR_CTL
;
122 else if ((c
& 0377) == '?')
123 c
= 0177 | (c
& ~0177 & ~CHAR_CTL
);
124 /* ASCII control chars are made from letters (both cases),
125 as well as the non-letters within 0100...0137. */
126 else if ((c
& 0137) >= 0101 && (c
& 0137) <= 0132)
127 c
&= (037 | (~0177 & ~CHAR_CTL
));
128 else if ((c
& 0177) >= 0100 && (c
& 0177) <= 0137)
129 c
&= (037 | (~0177 & ~CHAR_CTL
));
131 #if 0 /* This is outside the scope of this function. (bug#4751) */
134 /* Move the meta bit to the right place for a string. */
135 c
= (c
& ~CHAR_META
) | 0x80;
143 /* Store multibyte form of character C at P. If C has modifier bits,
144 handle them appropriately. */
153 if (c
& CHAR_MODIFIER_MASK
)
155 c
= (unsigned) char_resolve_modifier_mask ((int) c
);
156 /* If C still has any modifier bits, just ignore it. */
157 c
&= ~CHAR_MODIFIER_MASK
;
160 MAYBE_UNIFY_CHAR (c
);
162 if (c
<= MAX_3_BYTE_CHAR
)
164 bytes
= CHAR_STRING (c
, p
);
166 else if (c
<= MAX_4_BYTE_CHAR
)
168 p
[0] = (0xF0 | (c
>> 18));
169 p
[1] = (0x80 | ((c
>> 12) & 0x3F));
170 p
[2] = (0x80 | ((c
>> 6) & 0x3F));
171 p
[3] = (0x80 | (c
& 0x3F));
174 else if (c
<= MAX_5_BYTE_CHAR
)
177 p
[1] = (0x80 | ((c
>> 18) & 0x0F));
178 p
[2] = (0x80 | ((c
>> 12) & 0x3F));
179 p
[3] = (0x80 | ((c
>> 6) & 0x3F));
180 p
[4] = (0x80 | (c
& 0x3F));
183 else if (c
<= MAX_CHAR
)
185 c
= CHAR_TO_BYTE8 (c
);
186 bytes
= BYTE8_STRING (c
, p
);
189 error ("Invalid character: %d", c
);
195 /* Return a character whose multibyte form is at P. Set LEN is not
196 NULL, it must be a pointer to integer. In that case, set *LEN to
197 the byte length of the multibyte form. If ADVANCED is not NULL, is
198 must be a pointer to unsigned char. In that case, set *ADVANCED to
199 the ending address (i.e. the starting address of the next
200 character) of the multibyte form. */
203 string_char (p
, advanced
, len
)
204 const unsigned char *p
;
205 const unsigned char **advanced
;
209 const unsigned char *saved_p
= p
;
211 if (*p
< 0x80 || ! (*p
& 0x20) || ! (*p
& 0x10))
213 c
= STRING_CHAR_ADVANCE (p
);
215 else if (! (*p
& 0x08))
217 c
= ((((p
)[0] & 0xF) << 18)
218 | (((p
)[1] & 0x3F) << 12)
219 | (((p
)[2] & 0x3F) << 6)
225 c
= ((((p
)[1] & 0x3F) << 18)
226 | (((p
)[2] & 0x3F) << 12)
227 | (((p
)[3] & 0x3F) << 6)
232 MAYBE_UNIFY_CHAR (c
);
242 /* Translate character C by translation table TABLE. If C is
243 negative, translate a character specified by CHARSET and CODE. If
244 no translation is found in TABLE, return the untranslated
245 character. If TABLE is a list, elements are char tables. In this
246 case, translace C by all tables. */
249 translate_char (table
, c
)
253 if (CHAR_TABLE_P (table
))
257 ch
= CHAR_TABLE_REF (table
, c
);
263 for (; CONSP (table
); table
= XCDR (table
))
264 c
= translate_char (XCAR (table
), c
);
269 /* Convert ASCII or 8-bit character C to unibyte. If C is none of
270 them, return (C & 0xFF).
272 The argument REV_TBL is now ignored. It will be removed in the
276 multibyte_char_to_unibyte (c
, rev_tbl
)
282 if (CHAR_BYTE8_P (c
))
283 return CHAR_TO_BYTE8 (c
);
287 /* Like multibyte_char_to_unibyte, but return -1 if C is not supported
288 by charset_unibyte. */
291 multibyte_char_to_unibyte_safe (c
)
296 if (CHAR_BYTE8_P (c
))
297 return CHAR_TO_BYTE8 (c
);
301 DEFUN ("characterp", Fcharacterp
, Scharacterp
, 1, 2, 0,
302 doc
: /* Return non-nil if OBJECT is a character. */)
304 Lisp_Object object
, ignore
;
306 return (CHARACTERP (object
) ? Qt
: Qnil
);
309 DEFUN ("max-char", Fmax_char
, Smax_char
, 0, 0, 0,
310 doc
: /* Return the character of the maximum code. */)
313 return make_number (MAX_CHAR
);
316 DEFUN ("unibyte-char-to-multibyte", Funibyte_char_to_multibyte
,
317 Sunibyte_char_to_multibyte
, 1, 1, 0,
318 doc
: /* Convert the byte CH to multibyte character. */)
324 CHECK_CHARACTER (ch
);
327 error ("Not a unibyte character: %d", c
);
328 MAKE_CHAR_MULTIBYTE (c
);
329 return make_number (c
);
332 DEFUN ("multibyte-char-to-unibyte", Fmultibyte_char_to_unibyte
,
333 Smultibyte_char_to_unibyte
, 1, 1, 0,
334 doc
: /* Convert the multibyte character CH to a byte.
335 If the multibyte character does not represent a byte, return -1. */)
341 CHECK_CHARACTER (ch
);
344 /* Can't distinguish a byte read from a unibyte buffer from
345 a latin1 char, so let's let it slide. */
349 int cu
= CHAR_TO_BYTE_SAFE (cm
);
350 return make_number (cu
);
354 DEFUN ("char-bytes", Fchar_bytes
, Schar_bytes
, 1, 1, 0,
355 doc
: /* Return 1 regardless of the argument CHAR.
356 This is now an obsolete function. We keep it just for backward compatibility.
357 usage: (char-bytes CHAR) */)
361 CHECK_CHARACTER (ch
);
362 return make_number (1);
365 DEFUN ("char-width", Fchar_width
, Schar_width
, 1, 1, 0,
366 doc
: /* Return width of CHAR when displayed in the current buffer.
367 The width is measured by how many columns it occupies on the screen.
368 Tab is taken to occupy `tab-width' columns.
369 usage: (char-width CHAR) */)
375 struct Lisp_Char_Table
*dp
= buffer_display_table ();
377 CHECK_CHARACTER (ch
);
380 /* Get the way the display table would display it. */
381 disp
= dp
? DISP_CHAR_VECTOR (dp
, c
) : Qnil
;
384 width
= ASIZE (disp
);
386 width
= CHAR_WIDTH (c
);
388 return make_number (width
);
391 /* Return width of string STR of length LEN when displayed in the
392 current buffer. The width is measured by how many columns it
393 occupies on the screen. If PRECISION > 0, return the width of
394 longest substring that doesn't exceed PRECISION, and set number of
395 characters and bytes of the substring in *NCHARS and *NBYTES
399 c_string_width (const unsigned char *str
, int len
, int precision
, int *nchars
, int *nbytes
)
401 int i
= 0, i_byte
= 0;
403 struct Lisp_Char_Table
*dp
= buffer_display_table ();
407 int bytes
, thiswidth
;
409 int c
= STRING_CHAR_AND_LENGTH (str
+ i_byte
, bytes
);
413 val
= DISP_CHAR_VECTOR (dp
, c
);
415 thiswidth
= XVECTOR (val
)->size
;
417 thiswidth
= CHAR_WIDTH (c
);
421 thiswidth
= CHAR_WIDTH (c
);
425 && (width
+ thiswidth
> precision
))
445 /* Return width of string STR of length LEN when displayed in the
446 current buffer. The width is measured by how many columns it
447 occupies on the screen. */
454 return c_string_width (str
, len
, -1, NULL
, NULL
);
457 /* Return width of Lisp string STRING when displayed in the current
458 buffer. The width is measured by how many columns it occupies on
459 the screen while paying attention to compositions. If PRECISION >
460 0, return the width of longest substring that doesn't exceed
461 PRECISION, and set number of characters and bytes of the substring
462 in *NCHARS and *NBYTES respectively. */
465 lisp_string_width (string
, precision
, nchars
, nbytes
)
467 int precision
, *nchars
, *nbytes
;
469 int len
= SCHARS (string
);
470 /* This set multibyte to 0 even if STRING is multibyte when it
471 contains only ascii and eight-bit-graphic, but that's
473 int multibyte
= len
< SBYTES (string
);
474 unsigned char *str
= SDATA (string
);
475 int i
= 0, i_byte
= 0;
477 struct Lisp_Char_Table
*dp
= buffer_display_table ();
481 int chars
, bytes
, thiswidth
;
484 EMACS_INT ignore
, end
;
486 if (find_composition (i
, -1, &ignore
, &end
, &val
, string
)
487 && ((cmp_id
= get_composition_id (i
, i_byte
, end
- i
, val
, string
))
490 thiswidth
= composition_table
[cmp_id
]->width
;
492 bytes
= string_char_to_byte (string
, end
) - i_byte
;
499 c
= STRING_CHAR_AND_LENGTH (str
+ i_byte
, bytes
);
501 c
= str
[i_byte
], bytes
= 1;
505 val
= DISP_CHAR_VECTOR (dp
, c
);
507 thiswidth
= XVECTOR (val
)->size
;
509 thiswidth
= CHAR_WIDTH (c
);
513 thiswidth
= CHAR_WIDTH (c
);
518 && (width
+ thiswidth
> precision
))
538 DEFUN ("string-width", Fstring_width
, Sstring_width
, 1, 1, 0,
539 doc
: /* Return width of STRING when displayed in the current buffer.
540 Width is measured by how many columns it occupies on the screen.
541 When calculating width of a multibyte character in STRING,
542 only the base leading-code is considered; the validity of
543 the following bytes is not checked. Tabs in STRING are always
544 taken to occupy `tab-width' columns.
545 usage: (string-width STRING) */)
552 XSETFASTINT (val
, lisp_string_width (str
, -1, NULL
, NULL
));
556 DEFUN ("char-direction", Fchar_direction
, Schar_direction
, 1, 1, 0,
557 doc
: /* Return the direction of CHAR.
558 The returned value is 0 for left-to-right and 1 for right-to-left.
559 usage: (char-direction CHAR) */)
565 CHECK_CHARACTER (ch
);
567 return CHAR_TABLE_REF (Vchar_direction_table
, c
);
570 /* Return the number of characters in the NBYTES bytes at PTR.
571 This works by looking at the contents and checking for multibyte
572 sequences while assuming that there's no invalid sequence.
573 However, if the current buffer has enable-multibyte-characters =
574 nil, we treat each byte as a character. */
577 chars_in_text (ptr
, nbytes
)
578 const unsigned char *ptr
;
581 /* current_buffer is null at early stages of Emacs initialization. */
582 if (current_buffer
== 0
583 || NILP (BUF_ENABLE_MULTIBYTE_CHARACTERS (current_buffer
)))
586 return multibyte_chars_in_text (ptr
, nbytes
);
589 /* Return the number of characters in the NBYTES bytes at PTR.
590 This works by looking at the contents and checking for multibyte
591 sequences while assuming that there's no invalid sequence. It
592 ignores enable-multibyte-characters. */
595 multibyte_chars_in_text (ptr
, nbytes
)
596 const unsigned char *ptr
;
599 const unsigned char *endp
= ptr
+ nbytes
;
604 int len
= MULTIBYTE_LENGTH (ptr
, endp
);
615 /* Parse unibyte text at STR of LEN bytes as a multibyte text, count
616 characters and bytes in it, and store them in *NCHARS and *NBYTES
617 respectively. On counting bytes, pay attention to that 8-bit
618 characters not constructing a valid multibyte sequence are
619 represented by 2-byte in a multibyte text. */
622 parse_str_as_multibyte (str
, len
, nchars
, nbytes
)
623 const unsigned char *str
;
624 int len
, *nchars
, *nbytes
;
626 const unsigned char *endp
= str
+ len
;
627 int n
, chars
= 0, bytes
= 0;
629 if (len
>= MAX_MULTIBYTE_LENGTH
)
631 const unsigned char *adjusted_endp
= endp
- MAX_MULTIBYTE_LENGTH
;
632 while (str
< adjusted_endp
)
634 if (! CHAR_BYTE8_HEAD_P (*str
)
635 && (n
= MULTIBYTE_LENGTH_NO_CHECK (str
)) > 0)
636 str
+= n
, bytes
+= n
;
644 if (! CHAR_BYTE8_HEAD_P (*str
)
645 && (n
= MULTIBYTE_LENGTH (str
, endp
)) > 0)
646 str
+= n
, bytes
+= n
;
657 /* Arrange unibyte text at STR of NBYTES bytes as a multibyte text.
658 It actually converts only such 8-bit characters that don't contruct
659 a multibyte sequence to multibyte forms of Latin-1 characters. If
660 NCHARS is nonzero, set *NCHARS to the number of characters in the
661 text. It is assured that we can use LEN bytes at STR as a work
662 area and that is enough. Return the number of bytes of the
666 str_as_multibyte (str
, len
, nbytes
, nchars
)
668 int len
, nbytes
, *nchars
;
670 unsigned char *p
= str
, *endp
= str
+ nbytes
;
675 if (nbytes
>= MAX_MULTIBYTE_LENGTH
)
677 unsigned char *adjusted_endp
= endp
- MAX_MULTIBYTE_LENGTH
;
678 while (p
< adjusted_endp
679 && ! CHAR_BYTE8_HEAD_P (*p
)
680 && (n
= MULTIBYTE_LENGTH_NO_CHECK (p
)) > 0)
684 && ! CHAR_BYTE8_HEAD_P (*p
)
685 && (n
= MULTIBYTE_LENGTH (p
, endp
)) > 0)
695 safe_bcopy ((char *) p
, (char *) (endp
- nbytes
), nbytes
);
698 if (nbytes
>= MAX_MULTIBYTE_LENGTH
)
700 unsigned char *adjusted_endp
= endp
- MAX_MULTIBYTE_LENGTH
;
701 while (p
< adjusted_endp
)
703 if (! CHAR_BYTE8_HEAD_P (*p
)
704 && (n
= MULTIBYTE_LENGTH_NO_CHECK (p
)) > 0)
712 c
= BYTE8_TO_CHAR (c
);
713 to
+= CHAR_STRING (c
, to
);
720 if (! CHAR_BYTE8_HEAD_P (*p
)
721 && (n
= MULTIBYTE_LENGTH (p
, endp
)) > 0)
729 c
= BYTE8_TO_CHAR (c
);
730 to
+= CHAR_STRING (c
, to
);
739 /* Parse unibyte string at STR of LEN bytes, and return the number of
740 bytes it may ocupy when converted to multibyte string by
741 `str_to_multibyte'. */
744 parse_str_to_multibyte (str
, len
)
748 unsigned char *endp
= str
+ len
;
751 for (bytes
= 0; str
< endp
; str
++)
752 bytes
+= (*str
< 0x80) ? 1 : 2;
757 /* Convert unibyte text at STR of NBYTES bytes to a multibyte text
758 that contains the same single-byte characters. It actually
759 converts all 8-bit characters to multibyte forms. It is assured
760 that we can use LEN bytes at STR as a work area and that is
764 str_to_multibyte (str
, len
, bytes
)
768 unsigned char *p
= str
, *endp
= str
+ bytes
;
771 while (p
< endp
&& *p
< 0x80) p
++;
777 safe_bcopy ((char *) p
, (char *) (endp
- bytes
), bytes
);
784 c
= BYTE8_TO_CHAR (c
);
785 to
+= CHAR_STRING (c
, to
);
790 /* Arrange multibyte text at STR of LEN bytes as a unibyte text. It
791 actually converts characters in the range 0x80..0xFF to
795 str_as_unibyte (str
, bytes
)
799 const unsigned char *p
= str
, *endp
= str
+ bytes
;
806 len
= BYTES_BY_CHAR_HEAD (c
);
807 if (CHAR_BYTE8_HEAD_P (c
))
811 to
= str
+ (p
- str
);
815 len
= BYTES_BY_CHAR_HEAD (c
);
816 if (CHAR_BYTE8_HEAD_P (c
))
818 c
= STRING_CHAR_ADVANCE (p
);
819 *to
++ = CHAR_TO_BYTE8 (c
);
823 while (len
--) *to
++ = *p
++;
829 /* Convert eight-bit chars in SRC (in multibyte form) to the
830 corresponding byte and store in DST. CHARS is the number of
831 characters in SRC. The value is the number of bytes stored in DST.
832 Usually, the value is the same as CHARS, but is less than it if SRC
833 contains a non-ASCII, non-eight-bit characater. If ACCEPT_LATIN_1
834 is nonzero, a Latin-1 character is accepted and converted to a byte
835 of that character code.
836 Note: Currently the arg ACCEPT_LATIN_1 is not used. */
839 str_to_unibyte (src
, dst
, chars
, accept_latin_1
)
840 const unsigned char *src
;
847 for (i
= 0; i
< chars
; i
++)
849 int c
= STRING_CHAR_ADVANCE (src
);
851 if (CHAR_BYTE8_P (c
))
852 c
= CHAR_TO_BYTE8 (c
);
853 else if (! ASCII_CHAR_P (c
)
854 && (! accept_latin_1
|| c
>= 0x100))
863 string_count_byte8 (string
)
866 int multibyte
= STRING_MULTIBYTE (string
);
867 int nbytes
= SBYTES (string
);
868 unsigned char *p
= SDATA (string
);
869 unsigned char *pend
= p
+ nbytes
;
877 len
= BYTES_BY_CHAR_HEAD (c
);
879 if (CHAR_BYTE8_HEAD_P (c
))
894 string_escape_byte8 (string
)
897 int nchars
= SCHARS (string
);
898 int nbytes
= SBYTES (string
);
899 int multibyte
= STRING_MULTIBYTE (string
);
901 const unsigned char *src
, *src_end
;
906 if (multibyte
&& nchars
== nbytes
)
909 byte8_count
= string_count_byte8 (string
);
911 if (byte8_count
== 0)
915 /* Convert 2-byte sequence of byte8 chars to 4-byte octal. */
916 val
= make_uninit_multibyte_string (nchars
+ byte8_count
* 3,
917 nbytes
+ byte8_count
* 2);
919 /* Convert 1-byte sequence of byte8 chars to 4-byte octal. */
920 val
= make_uninit_string (nbytes
+ byte8_count
* 3);
922 src
= SDATA (string
);
923 src_end
= src
+ nbytes
;
926 while (src
< src_end
)
929 len
= BYTES_BY_CHAR_HEAD (c
);
931 if (CHAR_BYTE8_HEAD_P (c
))
933 c
= STRING_CHAR_ADVANCE (src
);
934 c
= CHAR_TO_BYTE8 (c
);
935 sprintf ((char *) dst
, "\\%03o", c
);
939 while (len
--) *dst
++ = *src
++;
942 while (src
< src_end
)
947 sprintf ((char *) dst
, "\\%03o", c
);
957 DEFUN ("string", Fstring
, Sstring
, 0, MANY
, 0,
959 Concatenate all the argument characters and make the result a string.
960 usage: (string &rest CHARACTERS) */)
966 unsigned char *buf
= (unsigned char *) alloca (MAX_MULTIBYTE_LENGTH
* n
);
967 unsigned char *p
= buf
;
970 for (i
= 0; i
< n
; i
++)
972 CHECK_CHARACTER (args
[i
]);
974 p
+= CHAR_STRING (c
, p
);
977 return make_string_from_bytes ((char *) buf
, n
, p
- buf
);
980 DEFUN ("unibyte-string", Funibyte_string
, Sunibyte_string
, 0, MANY
, 0,
981 doc
: /* Concatenate all the argument bytes and make the result a unibyte string.
982 usage: (unibyte-string &rest BYTES) */)
988 unsigned char *buf
= (unsigned char *) alloca (n
);
989 unsigned char *p
= buf
;
992 for (i
= 0; i
< n
; i
++)
994 CHECK_NATNUM (args
[i
]);
995 c
= XFASTINT (args
[i
]);
997 args_out_of_range_3 (args
[i
], make_number (0), make_number (255));
1001 return make_string_from_bytes ((char *) buf
, n
, p
- buf
);
1004 DEFUN ("char-resolve-modifiers", Fchar_resolve_modifiers
,
1005 Schar_resolve_modifiers
, 1, 1, 0,
1006 doc
: /* Resolve modifiers in the character CHAR.
1007 The value is a character with modifiers resolved into the character
1008 code. Unresolved modifiers are kept in the value.
1009 usage: (char-resolve-modifiers CHAR) */)
1011 Lisp_Object character
;
1015 CHECK_NUMBER (character
);
1016 c
= XINT (character
);
1017 return make_number (char_resolve_modifier_mask (c
));
1020 DEFUN ("get-byte", Fget_byte
, Sget_byte
, 0, 2, 0,
1021 doc
: /* Return a byte value of a character at point.
1022 Optional 1st arg POSITION, if non-nil, is a position of a character to get
1024 Optional 2nd arg STRING, if non-nil, is a string of which first
1025 character is a target to get a byte value. In this case, POSITION, if
1026 non-nil, is an index of a target character in the string.
1028 If the current buffer (or STRING) is multibyte, and the target
1029 character is not ASCII nor 8-bit character, an error is signalled. */)
1031 Lisp_Object position
, string
;
1039 if (NILP (position
))
1045 CHECK_NUMBER_COERCE_MARKER (position
);
1046 if (XINT (position
) < BEGV
|| XINT (position
) >= ZV
)
1047 args_out_of_range_3 (position
, make_number (BEGV
), make_number (ZV
));
1048 pos
= XFASTINT (position
);
1049 p
= CHAR_POS_ADDR (pos
);
1051 if (NILP (BUF_ENABLE_MULTIBYTE_CHARACTERS (current_buffer
)))
1052 return make_number (*p
);
1056 CHECK_STRING (string
);
1057 if (NILP (position
))
1063 CHECK_NATNUM (position
);
1064 if (XINT (position
) >= SCHARS (string
))
1065 args_out_of_range (string
, position
);
1066 pos
= XFASTINT (position
);
1067 p
= SDATA (string
) + string_char_to_byte (string
, pos
);
1069 if (! STRING_MULTIBYTE (string
))
1070 return make_number (*p
);
1072 c
= STRING_CHAR (p
);
1073 if (CHAR_BYTE8_P (c
))
1074 c
= CHAR_TO_BYTE8 (c
);
1075 else if (! ASCII_CHAR_P (c
))
1076 error ("Not an ASCII nor an 8-bit character: %d", c
);
1077 return make_number (c
);
1082 init_character_once ()
1089 syms_of_character ()
1091 DEFSYM (Qcharacterp
, "characterp");
1092 DEFSYM (Qauto_fill_chars
, "auto-fill-chars");
1094 staticpro (&Vchar_unify_table
);
1095 Vchar_unify_table
= Qnil
;
1097 defsubr (&Smax_char
);
1098 defsubr (&Scharacterp
);
1099 defsubr (&Sunibyte_char_to_multibyte
);
1100 defsubr (&Smultibyte_char_to_unibyte
);
1101 defsubr (&Schar_bytes
);
1102 defsubr (&Schar_width
);
1103 defsubr (&Sstring_width
);
1104 defsubr (&Schar_direction
);
1106 defsubr (&Sunibyte_string
);
1107 defsubr (&Schar_resolve_modifiers
);
1108 defsubr (&Sget_byte
);
1110 DEFVAR_LISP ("translation-table-vector", &Vtranslation_table_vector
,
1112 Vector recording all translation tables ever defined.
1113 Each element is a pair (SYMBOL . TABLE) relating the table to the
1114 symbol naming it. The ID of a translation table is an index into this vector. */);
1115 Vtranslation_table_vector
= Fmake_vector (make_number (16), Qnil
);
1117 DEFVAR_LISP ("auto-fill-chars", &Vauto_fill_chars
,
1119 A char-table for characters which invoke auto-filling.
1120 Such characters have value t in this table. */);
1121 Vauto_fill_chars
= Fmake_char_table (Qauto_fill_chars
, Qnil
);
1122 CHAR_TABLE_SET (Vauto_fill_chars
, ' ', Qt
);
1123 CHAR_TABLE_SET (Vauto_fill_chars
, '\n', Qt
);
1125 DEFVAR_LISP ("char-width-table", &Vchar_width_table
,
1127 A char-table for width (columns) of each character. */);
1128 Vchar_width_table
= Fmake_char_table (Qnil
, make_number (1));
1129 char_table_set_range (Vchar_width_table
, 0x80, 0x9F, make_number (4));
1130 char_table_set_range (Vchar_width_table
, MAX_5_BYTE_CHAR
+ 1, MAX_CHAR
,
1133 DEFVAR_LISP ("char-direction-table", &Vchar_direction_table
,
1134 doc
: /* A char-table for direction of each character. */);
1135 Vchar_direction_table
= Fmake_char_table (Qnil
, make_number (1));
1137 DEFVAR_LISP ("printable-chars", &Vprintable_chars
,
1138 doc
: /* A char-table for each printable character. */);
1139 Vprintable_chars
= Fmake_char_table (Qnil
, Qnil
);
1140 Fset_char_table_range (Vprintable_chars
,
1141 Fcons (make_number (32), make_number (126)), Qt
);
1142 Fset_char_table_range (Vprintable_chars
,
1143 Fcons (make_number (160),
1144 make_number (MAX_5_BYTE_CHAR
)), Qt
);
1146 DEFVAR_LISP ("char-script-table", &Vchar_script_table
,
1147 doc
: /* Char table of script symbols.
1148 It has one extra slot whose value is a list of script symbols. */);
1150 /* Intern this now in case it isn't already done.
1151 Setting this variable twice is harmless.
1152 But don't staticpro it here--that is done in alloc.c. */
1153 Qchar_table_extra_slots
= intern_c_string ("char-table-extra-slots");
1154 DEFSYM (Qchar_script_table
, "char-script-table");
1155 Fput (Qchar_script_table
, Qchar_table_extra_slots
, make_number (1));
1156 Vchar_script_table
= Fmake_char_table (Qchar_script_table
, Qnil
);
1158 DEFVAR_LISP ("script-representative-chars", &Vscript_representative_chars
,
1159 doc
: /* Alist of scripts vs the representative characters.
1160 Each element is a cons (SCRIPT . CHARS).
1161 SCRIPT is a symbol representing a script or a subgroup of a script.
1162 CHARS is a list or a vector of characters.
1163 If it is a list, all characters in the list are necessary for supporting SCRIPT.
1164 If it is a vector, one of the characters in the vector is necessary.
1165 This variable is used to find a font for a specific script. */);
1166 Vscript_representative_chars
= Qnil
;
1168 DEFVAR_LISP ("unicode-category-table", &Vunicode_category_table
,
1169 doc
: /* Char table of Unicode's "General Category".
1170 All Unicode characters have one of the following values (symbol):
1171 Lu, Ll, Lt, Lm, Lo, Mn, Mc, Me, Nd, Nl, No, Pc, Pd, Ps, Pe, Pi, Pf, Po,
1172 Sm, Sc, Sk, So, Zs, Zl, Zp, Cc, Cf, Cs, Co, Cn
1173 See The Unicode Standard for the meaning of those values. */);
1174 /* The correct char-table is setup in characters.el. */
1175 Vunicode_category_table
= Qnil
;
1180 /* arch-tag: b6665960-3c3d-4184-85cd-af4318197999
1181 (do not change this comment) */