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. */)
291 (Lisp_Object object
, Lisp_Object ignore
)
293 return (CHARACTERP (object
) ? Qt
: Qnil
);
296 DEFUN ("max-char", Fmax_char
, Smax_char
, 0, 0, 0,
297 doc
: /* Return the character of the maximum code. */)
300 return make_number (MAX_CHAR
);
303 DEFUN ("unibyte-char-to-multibyte", Funibyte_char_to_multibyte
,
304 Sunibyte_char_to_multibyte
, 1, 1, 0,
305 doc
: /* Convert the byte CH to multibyte character. */)
310 CHECK_CHARACTER (ch
);
313 error ("Not a unibyte character: %d", c
);
314 MAKE_CHAR_MULTIBYTE (c
);
315 return make_number (c
);
318 DEFUN ("multibyte-char-to-unibyte", Fmultibyte_char_to_unibyte
,
319 Smultibyte_char_to_unibyte
, 1, 1, 0,
320 doc
: /* Convert the multibyte character CH to a byte.
321 If the multibyte character does not represent a byte, return -1. */)
326 CHECK_CHARACTER (ch
);
329 /* Can't distinguish a byte read from a unibyte buffer from
330 a latin1 char, so let's let it slide. */
334 int cu
= CHAR_TO_BYTE_SAFE (cm
);
335 return make_number (cu
);
339 DEFUN ("char-bytes", Fchar_bytes
, Schar_bytes
, 1, 1, 0,
340 doc
: /* Return 1 regardless of the argument CHAR.
341 This is now an obsolete function. We keep it just for backward compatibility.
342 usage: (char-bytes CHAR) */)
345 CHECK_CHARACTER (ch
);
346 return make_number (1);
349 DEFUN ("char-width", Fchar_width
, Schar_width
, 1, 1, 0,
350 doc
: /* Return width of CHAR when displayed in the current buffer.
351 The width is measured by how many columns it occupies on the screen.
352 Tab is taken to occupy `tab-width' columns.
353 usage: (char-width CHAR) */)
358 struct Lisp_Char_Table
*dp
= buffer_display_table ();
360 CHECK_CHARACTER (ch
);
363 /* Get the way the display table would display it. */
364 disp
= dp
? DISP_CHAR_VECTOR (dp
, c
) : Qnil
;
367 width
= ASIZE (disp
);
369 width
= CHAR_WIDTH (c
);
371 return make_number (width
);
374 /* Return width of string STR of length LEN when displayed in the
375 current buffer. The width is measured by how many columns it
376 occupies on the screen. If PRECISION > 0, return the width of
377 longest substring that doesn't exceed PRECISION, and set number of
378 characters and bytes of the substring in *NCHARS and *NBYTES
382 c_string_width (const unsigned char *str
, EMACS_INT len
, int precision
,
383 EMACS_INT
*nchars
, EMACS_INT
*nbytes
)
385 EMACS_INT i
= 0, i_byte
= 0;
387 struct Lisp_Char_Table
*dp
= buffer_display_table ();
391 int bytes
, thiswidth
;
393 int c
= STRING_CHAR_AND_LENGTH (str
+ i_byte
, bytes
);
397 val
= DISP_CHAR_VECTOR (dp
, c
);
399 thiswidth
= XVECTOR (val
)->size
;
401 thiswidth
= CHAR_WIDTH (c
);
405 thiswidth
= CHAR_WIDTH (c
);
409 && (width
+ thiswidth
> precision
))
429 /* Return width of string STR of length LEN when displayed in the
430 current buffer. The width is measured by how many columns it
431 occupies on the screen. */
434 strwidth (const unsigned char *str
, EMACS_INT len
)
436 return c_string_width (str
, len
, -1, NULL
, NULL
);
439 /* Return width of Lisp string STRING when displayed in the current
440 buffer. The width is measured by how many columns it occupies on
441 the screen while paying attention to compositions. If PRECISION >
442 0, return the width of longest substring that doesn't exceed
443 PRECISION, and set number of characters and bytes of the substring
444 in *NCHARS and *NBYTES respectively. */
447 lisp_string_width (Lisp_Object string
, int precision
,
448 EMACS_INT
*nchars
, EMACS_INT
*nbytes
)
450 EMACS_INT len
= SCHARS (string
);
451 /* This set multibyte to 0 even if STRING is multibyte when it
452 contains only ascii and eight-bit-graphic, but that's
454 int multibyte
= len
< SBYTES (string
);
455 unsigned char *str
= SDATA (string
);
456 EMACS_INT i
= 0, i_byte
= 0;
458 struct Lisp_Char_Table
*dp
= buffer_display_table ();
462 int chars
, bytes
, thiswidth
;
465 EMACS_INT ignore
, end
;
467 if (find_composition (i
, -1, &ignore
, &end
, &val
, string
)
468 && ((cmp_id
= get_composition_id (i
, i_byte
, end
- i
, val
, string
))
471 thiswidth
= composition_table
[cmp_id
]->width
;
473 bytes
= string_char_to_byte (string
, end
) - i_byte
;
480 c
= STRING_CHAR_AND_LENGTH (str
+ i_byte
, bytes
);
482 c
= str
[i_byte
], bytes
= 1;
486 val
= DISP_CHAR_VECTOR (dp
, c
);
488 thiswidth
= XVECTOR (val
)->size
;
490 thiswidth
= CHAR_WIDTH (c
);
494 thiswidth
= CHAR_WIDTH (c
);
499 && (width
+ thiswidth
> precision
))
519 DEFUN ("string-width", Fstring_width
, Sstring_width
, 1, 1, 0,
520 doc
: /* Return width of STRING when displayed in the current buffer.
521 Width is measured by how many columns it occupies on the screen.
522 When calculating width of a multibyte character in STRING,
523 only the base leading-code is considered; the validity of
524 the following bytes is not checked. Tabs in STRING are always
525 taken to occupy `tab-width' columns.
526 usage: (string-width STRING) */)
532 XSETFASTINT (val
, lisp_string_width (str
, -1, NULL
, NULL
));
536 DEFUN ("char-direction", Fchar_direction
, Schar_direction
, 1, 1, 0,
537 doc
: /* Return the direction of CHAR.
538 The returned value is 0 for left-to-right and 1 for right-to-left.
539 usage: (char-direction CHAR) */)
544 CHECK_CHARACTER (ch
);
546 return CHAR_TABLE_REF (Vchar_direction_table
, c
);
549 /* Return the number of characters in the NBYTES bytes at PTR.
550 This works by looking at the contents and checking for multibyte
551 sequences while assuming that there's no invalid sequence.
552 However, if the current buffer has enable-multibyte-characters =
553 nil, we treat each byte as a character. */
556 chars_in_text (const unsigned char *ptr
, EMACS_INT nbytes
)
558 /* current_buffer is null at early stages of Emacs initialization. */
559 if (current_buffer
== 0
560 || NILP (current_buffer
->enable_multibyte_characters
))
563 return multibyte_chars_in_text (ptr
, nbytes
);
566 /* Return the number of characters in the NBYTES bytes at PTR.
567 This works by looking at the contents and checking for multibyte
568 sequences while assuming that there's no invalid sequence. It
569 ignores enable-multibyte-characters. */
572 multibyte_chars_in_text (const unsigned char *ptr
, EMACS_INT nbytes
)
574 const unsigned char *endp
= ptr
+ nbytes
;
579 EMACS_INT len
= MULTIBYTE_LENGTH (ptr
, endp
);
590 /* Parse unibyte text at STR of LEN bytes as a multibyte text, count
591 characters and bytes in it, and store them in *NCHARS and *NBYTES
592 respectively. On counting bytes, pay attention to that 8-bit
593 characters not constructing a valid multibyte sequence are
594 represented by 2-byte in a multibyte text. */
597 parse_str_as_multibyte (const unsigned char *str
, EMACS_INT len
,
598 EMACS_INT
*nchars
, EMACS_INT
*nbytes
)
600 const unsigned char *endp
= str
+ len
;
601 EMACS_INT n
, chars
= 0, bytes
= 0;
603 if (len
>= MAX_MULTIBYTE_LENGTH
)
605 const unsigned char *adjusted_endp
= endp
- MAX_MULTIBYTE_LENGTH
;
606 while (str
< adjusted_endp
)
608 if (! CHAR_BYTE8_HEAD_P (*str
)
609 && (n
= MULTIBYTE_LENGTH_NO_CHECK (str
)) > 0)
610 str
+= n
, bytes
+= n
;
618 if (! CHAR_BYTE8_HEAD_P (*str
)
619 && (n
= MULTIBYTE_LENGTH (str
, endp
)) > 0)
620 str
+= n
, bytes
+= n
;
631 /* Arrange unibyte text at STR of NBYTES bytes as a multibyte text.
632 It actually converts only such 8-bit characters that don't contruct
633 a multibyte sequence to multibyte forms of Latin-1 characters. If
634 NCHARS is nonzero, set *NCHARS to the number of characters in the
635 text. It is assured that we can use LEN bytes at STR as a work
636 area and that is enough. Return the number of bytes of the
640 str_as_multibyte (unsigned char *str
, EMACS_INT len
, EMACS_INT nbytes
,
643 unsigned char *p
= str
, *endp
= str
+ nbytes
;
648 if (nbytes
>= MAX_MULTIBYTE_LENGTH
)
650 unsigned char *adjusted_endp
= endp
- MAX_MULTIBYTE_LENGTH
;
651 while (p
< adjusted_endp
652 && ! CHAR_BYTE8_HEAD_P (*p
)
653 && (n
= MULTIBYTE_LENGTH_NO_CHECK (p
)) > 0)
657 && ! CHAR_BYTE8_HEAD_P (*p
)
658 && (n
= MULTIBYTE_LENGTH (p
, endp
)) > 0)
668 memmove (endp
- nbytes
, p
, nbytes
);
671 if (nbytes
>= MAX_MULTIBYTE_LENGTH
)
673 unsigned char *adjusted_endp
= endp
- MAX_MULTIBYTE_LENGTH
;
674 while (p
< adjusted_endp
)
676 if (! CHAR_BYTE8_HEAD_P (*p
)
677 && (n
= MULTIBYTE_LENGTH_NO_CHECK (p
)) > 0)
685 c
= BYTE8_TO_CHAR (c
);
686 to
+= CHAR_STRING (c
, to
);
693 if (! CHAR_BYTE8_HEAD_P (*p
)
694 && (n
= MULTIBYTE_LENGTH (p
, endp
)) > 0)
702 c
= BYTE8_TO_CHAR (c
);
703 to
+= CHAR_STRING (c
, to
);
712 /* Parse unibyte string at STR of LEN bytes, and return the number of
713 bytes it may ocupy when converted to multibyte string by
714 `str_to_multibyte'. */
717 parse_str_to_multibyte (const unsigned char *str
, EMACS_INT len
)
719 const unsigned char *endp
= str
+ len
;
722 for (bytes
= 0; str
< endp
; str
++)
723 bytes
+= (*str
< 0x80) ? 1 : 2;
728 /* Convert unibyte text at STR of NBYTES bytes to a multibyte text
729 that contains the same single-byte characters. It actually
730 converts all 8-bit characters to multibyte forms. It is assured
731 that we can use LEN bytes at STR as a work area and that is
735 str_to_multibyte (unsigned char *str
, EMACS_INT len
, EMACS_INT bytes
)
737 unsigned char *p
= str
, *endp
= str
+ bytes
;
740 while (p
< endp
&& *p
< 0x80) p
++;
746 memmove (endp
- bytes
, p
, bytes
);
753 c
= BYTE8_TO_CHAR (c
);
754 to
+= CHAR_STRING (c
, to
);
759 /* Arrange multibyte text at STR of LEN bytes as a unibyte text. It
760 actually converts characters in the range 0x80..0xFF to
764 str_as_unibyte (unsigned char *str
, EMACS_INT bytes
)
766 const unsigned char *p
= str
, *endp
= str
+ bytes
;
773 len
= BYTES_BY_CHAR_HEAD (c
);
774 if (CHAR_BYTE8_HEAD_P (c
))
778 to
= str
+ (p
- str
);
782 len
= BYTES_BY_CHAR_HEAD (c
);
783 if (CHAR_BYTE8_HEAD_P (c
))
785 c
= STRING_CHAR_ADVANCE (p
);
786 *to
++ = CHAR_TO_BYTE8 (c
);
790 while (len
--) *to
++ = *p
++;
796 /* Convert eight-bit chars in SRC (in multibyte form) to the
797 corresponding byte and store in DST. CHARS is the number of
798 characters in SRC. The value is the number of bytes stored in DST.
799 Usually, the value is the same as CHARS, but is less than it if SRC
800 contains a non-ASCII, non-eight-bit characater. If ACCEPT_LATIN_1
801 is nonzero, a Latin-1 character is accepted and converted to a byte
802 of that character code.
803 Note: Currently the arg ACCEPT_LATIN_1 is not used. */
806 str_to_unibyte (const unsigned char *src
, unsigned char *dst
, EMACS_INT chars
, int accept_latin_1
)
810 for (i
= 0; i
< chars
; i
++)
812 int c
= STRING_CHAR_ADVANCE (src
);
814 if (CHAR_BYTE8_P (c
))
815 c
= CHAR_TO_BYTE8 (c
);
816 else if (! ASCII_CHAR_P (c
)
817 && (! accept_latin_1
|| c
>= 0x100))
826 string_count_byte8 (Lisp_Object string
)
828 int multibyte
= STRING_MULTIBYTE (string
);
829 EMACS_INT nbytes
= SBYTES (string
);
830 unsigned char *p
= SDATA (string
);
831 unsigned char *pend
= p
+ nbytes
;
839 len
= BYTES_BY_CHAR_HEAD (c
);
841 if (CHAR_BYTE8_HEAD_P (c
))
856 string_escape_byte8 (Lisp_Object string
)
858 EMACS_INT nchars
= SCHARS (string
);
859 EMACS_INT nbytes
= SBYTES (string
);
860 int multibyte
= STRING_MULTIBYTE (string
);
861 EMACS_INT byte8_count
;
862 const unsigned char *src
, *src_end
;
867 if (multibyte
&& nchars
== nbytes
)
870 byte8_count
= string_count_byte8 (string
);
872 if (byte8_count
== 0)
877 if ((MOST_POSITIVE_FIXNUM
- nchars
) / 3 < byte8_count
878 || (MOST_POSITIVE_FIXNUM
- nbytes
) / 2 < byte8_count
)
879 error ("Maximum string size exceeded");
881 /* Convert 2-byte sequence of byte8 chars to 4-byte octal. */
882 val
= make_uninit_multibyte_string (nchars
+ byte8_count
* 3,
883 nbytes
+ byte8_count
* 2);
887 if ((MOST_POSITIVE_FIXNUM
- nchars
) / 3 < byte8_count
)
888 error ("Maximum string size exceeded");
889 /* Convert 1-byte sequence of byte8 chars to 4-byte octal. */
890 val
= make_uninit_string (nbytes
+ byte8_count
* 3);
893 src
= SDATA (string
);
894 src_end
= src
+ nbytes
;
897 while (src
< src_end
)
900 len
= BYTES_BY_CHAR_HEAD (c
);
902 if (CHAR_BYTE8_HEAD_P (c
))
904 c
= STRING_CHAR_ADVANCE (src
);
905 c
= CHAR_TO_BYTE8 (c
);
906 sprintf ((char *) dst
, "\\%03o", c
);
910 while (len
--) *dst
++ = *src
++;
913 while (src
< src_end
)
918 sprintf ((char *) dst
, "\\%03o", c
);
928 DEFUN ("string", Fstring
, Sstring
, 0, MANY
, 0,
930 Concatenate all the argument characters and make the result a string.
931 usage: (string &rest CHARACTERS) */)
932 (int n
, Lisp_Object
*args
)
935 unsigned char *buf
, *p
;
939 SAFE_ALLOCA (buf
, unsigned char *, MAX_MULTIBYTE_LENGTH
* n
);
942 for (i
= 0; i
< n
; i
++)
944 CHECK_CHARACTER (args
[i
]);
946 p
+= CHAR_STRING (c
, p
);
949 str
= make_string_from_bytes ((char *) buf
, n
, p
- buf
);
954 DEFUN ("unibyte-string", Funibyte_string
, Sunibyte_string
, 0, MANY
, 0,
955 doc
: /* Concatenate all the argument bytes and make the result a unibyte string.
956 usage: (unibyte-string &rest BYTES) */)
957 (int n
, Lisp_Object
*args
)
960 unsigned char *buf
, *p
;
964 SAFE_ALLOCA (buf
, unsigned char *, n
);
967 for (i
= 0; i
< n
; i
++)
969 CHECK_NATNUM (args
[i
]);
970 c
= XFASTINT (args
[i
]);
972 args_out_of_range_3 (args
[i
], make_number (0), make_number (255));
976 str
= make_string_from_bytes ((char *) buf
, n
, p
- buf
);
981 DEFUN ("char-resolve-modifiers", Fchar_resolve_modifiers
,
982 Schar_resolve_modifiers
, 1, 1, 0,
983 doc
: /* Resolve modifiers in the character CHAR.
984 The value is a character with modifiers resolved into the character
985 code. Unresolved modifiers are kept in the value.
986 usage: (char-resolve-modifiers CHAR) */)
987 (Lisp_Object character
)
991 CHECK_NUMBER (character
);
992 c
= XINT (character
);
993 return make_number (char_resolve_modifier_mask (c
));
996 DEFUN ("get-byte", Fget_byte
, Sget_byte
, 0, 2, 0,
997 doc
: /* Return a byte value of a character at point.
998 Optional 1st arg POSITION, if non-nil, is a position of a character to get
1000 Optional 2nd arg STRING, if non-nil, is a string of which first
1001 character is a target to get a byte value. In this case, POSITION, if
1002 non-nil, is an index of a target character in the string.
1004 If the current buffer (or STRING) is multibyte, and the target
1005 character is not ASCII nor 8-bit character, an error is signalled. */)
1006 (Lisp_Object position
, Lisp_Object string
)
1014 if (NILP (position
))
1020 CHECK_NUMBER_COERCE_MARKER (position
);
1021 if (XINT (position
) < BEGV
|| XINT (position
) >= ZV
)
1022 args_out_of_range_3 (position
, make_number (BEGV
), make_number (ZV
));
1023 pos
= XFASTINT (position
);
1024 p
= CHAR_POS_ADDR (pos
);
1026 if (NILP (current_buffer
->enable_multibyte_characters
))
1027 return make_number (*p
);
1031 CHECK_STRING (string
);
1032 if (NILP (position
))
1038 CHECK_NATNUM (position
);
1039 if (XINT (position
) >= SCHARS (string
))
1040 args_out_of_range (string
, position
);
1041 pos
= XFASTINT (position
);
1042 p
= SDATA (string
) + string_char_to_byte (string
, pos
);
1044 if (! STRING_MULTIBYTE (string
))
1045 return make_number (*p
);
1047 c
= STRING_CHAR (p
);
1048 if (CHAR_BYTE8_P (c
))
1049 c
= CHAR_TO_BYTE8 (c
);
1050 else if (! ASCII_CHAR_P (c
))
1051 error ("Not an ASCII nor an 8-bit character: %d", c
);
1052 return make_number (c
);
1057 init_character_once (void)
1064 syms_of_character (void)
1066 DEFSYM (Qcharacterp
, "characterp");
1067 DEFSYM (Qauto_fill_chars
, "auto-fill-chars");
1069 staticpro (&Vchar_unify_table
);
1070 Vchar_unify_table
= Qnil
;
1072 defsubr (&Smax_char
);
1073 defsubr (&Scharacterp
);
1074 defsubr (&Sunibyte_char_to_multibyte
);
1075 defsubr (&Smultibyte_char_to_unibyte
);
1076 defsubr (&Schar_bytes
);
1077 defsubr (&Schar_width
);
1078 defsubr (&Sstring_width
);
1079 defsubr (&Schar_direction
);
1081 defsubr (&Sunibyte_string
);
1082 defsubr (&Schar_resolve_modifiers
);
1083 defsubr (&Sget_byte
);
1085 DEFVAR_LISP ("translation-table-vector", &Vtranslation_table_vector
,
1087 Vector recording all translation tables ever defined.
1088 Each element is a pair (SYMBOL . TABLE) relating the table to the
1089 symbol naming it. The ID of a translation table is an index into this vector. */);
1090 Vtranslation_table_vector
= Fmake_vector (make_number (16), Qnil
);
1092 DEFVAR_LISP ("auto-fill-chars", &Vauto_fill_chars
,
1094 A char-table for characters which invoke auto-filling.
1095 Such characters have value t in this table. */);
1096 Vauto_fill_chars
= Fmake_char_table (Qauto_fill_chars
, Qnil
);
1097 CHAR_TABLE_SET (Vauto_fill_chars
, ' ', Qt
);
1098 CHAR_TABLE_SET (Vauto_fill_chars
, '\n', Qt
);
1100 DEFVAR_LISP ("char-width-table", &Vchar_width_table
,
1102 A char-table for width (columns) of each character. */);
1103 Vchar_width_table
= Fmake_char_table (Qnil
, make_number (1));
1104 char_table_set_range (Vchar_width_table
, 0x80, 0x9F, make_number (4));
1105 char_table_set_range (Vchar_width_table
, MAX_5_BYTE_CHAR
+ 1, MAX_CHAR
,
1108 DEFVAR_LISP ("char-direction-table", &Vchar_direction_table
,
1109 doc
: /* A char-table for direction of each character. */);
1110 Vchar_direction_table
= Fmake_char_table (Qnil
, make_number (1));
1112 DEFVAR_LISP ("printable-chars", &Vprintable_chars
,
1113 doc
: /* A char-table for each printable character. */);
1114 Vprintable_chars
= Fmake_char_table (Qnil
, Qnil
);
1115 Fset_char_table_range (Vprintable_chars
,
1116 Fcons (make_number (32), make_number (126)), Qt
);
1117 Fset_char_table_range (Vprintable_chars
,
1118 Fcons (make_number (160),
1119 make_number (MAX_5_BYTE_CHAR
)), Qt
);
1121 DEFVAR_LISP ("char-script-table", &Vchar_script_table
,
1122 doc
: /* Char table of script symbols.
1123 It has one extra slot whose value is a list of script symbols. */);
1125 /* Intern this now in case it isn't already done.
1126 Setting this variable twice is harmless.
1127 But don't staticpro it here--that is done in alloc.c. */
1128 Qchar_table_extra_slots
= intern_c_string ("char-table-extra-slots");
1129 DEFSYM (Qchar_script_table
, "char-script-table");
1130 Fput (Qchar_script_table
, Qchar_table_extra_slots
, make_number (1));
1131 Vchar_script_table
= Fmake_char_table (Qchar_script_table
, Qnil
);
1133 DEFVAR_LISP ("script-representative-chars", &Vscript_representative_chars
,
1134 doc
: /* Alist of scripts vs the representative characters.
1135 Each element is a cons (SCRIPT . CHARS).
1136 SCRIPT is a symbol representing a script or a subgroup of a script.
1137 CHARS is a list or a vector of characters.
1138 If it is a list, all characters in the list are necessary for supporting SCRIPT.
1139 If it is a vector, one of the characters in the vector is necessary.
1140 This variable is used to find a font for a specific script. */);
1141 Vscript_representative_chars
= Qnil
;
1143 DEFVAR_LISP ("unicode-category-table", &Vunicode_category_table
,
1144 doc
: /* Char table of Unicode's "General Category".
1145 All Unicode characters have one of the following values (symbol):
1146 Lu, Ll, Lt, Lm, Lo, Mn, Mc, Me, Nd, Nl, No, Pc, Pd, Ps, Pe, Pi, Pf, Po,
1147 Sm, Sc, Sk, So, Zs, Zl, Zp, Cc, Cf, Cs, Co, Cn
1148 See The Unicode Standard for the meaning of those values. */);
1149 /* The correct char-table is setup in characters.el. */
1150 Vunicode_category_table
= Qnil
;
1155 /* arch-tag: b6665960-3c3d-4184-85cd-af4318197999
1156 (do not change this comment) */