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, 2005, 2006 Free Software Foundation, Inc.
5 Copyright (C) 2003, 2006
6 National Institute of Advanced Industrial Science and Technology (AIST)
7 Registration Number H13PRO009
9 This file is part of GNU Emacs.
11 GNU Emacs is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 2, or (at your option)
16 GNU Emacs is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with GNU Emacs; see the file COPYING. If not, write to
23 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
24 Boston, MA 02111-1307, USA. */
26 /* At first, see the document in `character.h' to understand the code
37 #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
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 /* Mapping table from unibyte chars to multibyte chars. */
90 int unibyte_to_multibyte_table
[256];
92 /* Nth element is 1 iff unibyte char N can be mapped to a multibyte
94 char unibyte_has_multibyte_table
[256];
98 /* Store multibyte form of character C at P. If C has modifier bits,
99 handle them appropriately. */
108 if (c
& CHAR_MODIFIER_MASK
)
110 /* As an non-ASCII character can't have modifier bits, we just
112 if (ASCII_CHAR_P ((c
& ~CHAR_MODIFIER_MASK
)))
114 /* For Meta, Shift, and Control modifiers, we need special care. */
117 /* Move the meta bit to the right place for a string. */
118 c
= (c
& ~CHAR_META
) | 0x80;
122 /* Shift modifier is valid only with [A-Za-z]. */
123 if ((c
& 0377) >= 'A' && (c
& 0377) <= 'Z')
125 else if ((c
& 0377) >= 'a' && (c
& 0377) <= 'z')
126 c
= (c
& ~CHAR_SHIFT
) - ('a' - 'A');
130 /* Simulate the code in lread.c. */
131 /* Allow `\C- ' and `\C-?'. */
132 if (c
== (CHAR_CTL
| ' '))
134 else if (c
== (CHAR_CTL
| '?'))
136 /* ASCII control chars are made from letters (both cases),
137 as well as the non-letters within 0100...0137. */
138 else if ((c
& 0137) >= 0101 && (c
& 0137) <= 0132)
139 c
&= (037 | (~0177 & ~CHAR_CTL
));
140 else if ((c
& 0177) >= 0100 && (c
& 0177) <= 0137)
141 c
&= (037 | (~0177 & ~CHAR_CTL
));
145 /* If C still has any modifier bits, just ignore it. */
146 c
&= ~CHAR_MODIFIER_MASK
;
149 MAYBE_UNIFY_CHAR (c
);
151 if (c
<= MAX_3_BYTE_CHAR
)
153 bytes
= CHAR_STRING (c
, p
);
155 else if (c
<= MAX_4_BYTE_CHAR
)
157 p
[0] = (0xF0 | (c
>> 18));
158 p
[1] = (0x80 | ((c
>> 12) & 0x3F));
159 p
[2] = (0x80 | ((c
>> 6) & 0x3F));
160 p
[3] = (0x80 | (c
& 0x3F));
163 else if (c
<= MAX_5_BYTE_CHAR
)
166 p
[1] = (0x80 | ((c
>> 18) & 0x0F));
167 p
[2] = (0x80 | ((c
>> 12) & 0x3F));
168 p
[3] = (0x80 | ((c
>> 6) & 0x3F));
169 p
[4] = (0x80 | (c
& 0x3F));
172 else if (c
<= MAX_CHAR
)
174 c
= CHAR_TO_BYTE8 (c
);
175 bytes
= BYTE8_STRING (c
, p
);
178 error ("Invalid character: %d", c
);
184 /* Return a character whose multibyte form is at P. Set LEN is not
185 NULL, it must be a pointer to integer. In that case, set *LEN to
186 the byte length of the multibyte form. If ADVANCED is not NULL, is
187 must be a pointer to unsigned char. In that case, set *ADVANCED to
188 the ending address (i.e. the starting address of the next
189 character) of the multibyte form. */
192 string_char (p
, advanced
, len
)
193 const unsigned char *p
;
194 const unsigned char **advanced
;
198 const unsigned char *saved_p
= p
;
200 if (*p
< 0x80 || ! (*p
& 0x20) || ! (*p
& 0x10))
202 c
= STRING_CHAR_ADVANCE (p
);
204 else if (! (*p
& 0x08))
206 c
= ((((p
)[0] & 0xF) << 18)
207 | (((p
)[1] & 0x3F) << 12)
208 | (((p
)[2] & 0x3F) << 6)
214 c
= ((((p
)[1] & 0x3F) << 18)
215 | (((p
)[2] & 0x3F) << 12)
216 | (((p
)[3] & 0x3F) << 6)
221 MAYBE_UNIFY_CHAR (c
);
231 /* Translate character C by translation table TABLE. If C is
232 negative, translate a character specified by CHARSET and CODE. If
233 no translation is found in TABLE, return the untranslated
234 character. If TABLE is a list, elements are char tables. In this
235 case, translace C by all tables. */
238 translate_char (table
, c
)
242 if (CHAR_TABLE_P (table
))
246 ch
= CHAR_TABLE_REF (table
, c
);
252 for (; CONSP (table
); table
= XCDR (table
))
253 c
= translate_char (XCAR (table
), c
);
258 /* Convert the multibyte character C to unibyte 8-bit character based
259 on the current value of charset_unibyte. If dimension of
260 charset_unibyte is more than one, return (C & 0xFF).
262 The argument REV_TBL is now ignored. It will be removed in the
266 multibyte_char_to_unibyte (c
, rev_tbl
)
270 struct charset
*charset
;
273 if (CHAR_BYTE8_P (c
))
274 return CHAR_TO_BYTE8 (c
);
275 charset
= CHARSET_FROM_ID (charset_unibyte
);
276 c1
= ENCODE_CHAR (charset
, c
);
277 return ((c1
!= CHARSET_INVALID_CODE (charset
)) ? c1
: c
& 0xFF);
280 /* Like multibyte_char_to_unibyte, but return -1 if C is not supported
281 by charset_unibyte. */
284 multibyte_char_to_unibyte_safe (c
)
287 struct charset
*charset
;
290 if (CHAR_BYTE8_P (c
))
291 return CHAR_TO_BYTE8 (c
);
292 charset
= CHARSET_FROM_ID (charset_unibyte
);
293 c1
= ENCODE_CHAR (charset
, c
);
294 return ((c1
!= CHARSET_INVALID_CODE (charset
)) ? c1
: -1);
297 DEFUN ("characterp", Fcharacterp
, Scharacterp
, 1, 2, 0,
298 doc
: /* Return non-nil if OBJECT is a character. */)
300 Lisp_Object object
, ignore
;
302 return (CHARACTERP (object
) ? Qt
: Qnil
);
305 DEFUN ("max-char", Fmax_char
, Smax_char
, 0, 0, 0,
306 doc
: /* Return the character of the maximum code. */)
309 return make_number (MAX_CHAR
);
312 DEFUN ("unibyte-char-to-multibyte", Funibyte_char_to_multibyte
,
313 Sunibyte_char_to_multibyte
, 1, 1, 0,
314 doc
: /* Convert the unibyte character CH to multibyte character.
315 The multibyte character is a result of decoding CH by
316 the current unibyte charset (see `unibyte-charset'). */)
321 struct charset
*charset
;
323 CHECK_CHARACTER (ch
);
326 error ("Invalid unibyte character: %d", c
);
327 charset
= CHARSET_FROM_ID (charset_unibyte
);
328 c
= DECODE_CHAR (charset
, c
);
330 c
= BYTE8_TO_CHAR (XFASTINT (ch
));
331 return make_number (c
);
334 DEFUN ("multibyte-char-to-unibyte", Fmultibyte_char_to_unibyte
,
335 Smultibyte_char_to_unibyte
, 1, 1, 0,
336 doc
: /* Convert the multibyte character CH to unibyte character.\n\
337 The unibyte character is a result of encoding CH by
338 the current primary charset (value of `charset-primary'). */)
344 CHECK_CHARACTER (ch
);
346 c
= CHAR_TO_BYTE8 (c
);
347 return make_number (c
);
350 DEFUN ("char-bytes", Fchar_bytes
, Schar_bytes
, 1, 1, 0,
351 doc
: /* Return 1 regardless of the argument CHAR.
352 This is now an obsolete function. We keep it just for backward compatibility. */)
356 CHECK_CHARACTER (ch
);
357 return make_number (1);
360 DEFUN ("char-width", Fchar_width
, Schar_width
, 1, 1, 0,
361 doc
: /* Return width of CHAR when displayed in the current buffer.
362 The width is measured by how many columns it occupies on the screen.
363 Tab is taken to occupy `tab-width' columns. */)
369 struct Lisp_Char_Table
*dp
= buffer_display_table ();
371 CHECK_CHARACTER (ch
);
374 /* Get the way the display table would display it. */
375 disp
= dp
? DISP_CHAR_VECTOR (dp
, c
) : Qnil
;
378 width
= ASIZE (disp
);
380 width
= CHAR_WIDTH (c
);
382 return make_number (width
);
385 /* Return width of string STR of length LEN when displayed in the
386 current buffer. The width is measured by how many columns it
387 occupies on the screen. If PRECISION > 0, return the width of
388 longest substring that doesn't exceed PRECISION, and set number of
389 characters and bytes of the substring in *NCHARS and *NBYTES
393 c_string_width (str
, len
, precision
, nchars
, nbytes
)
394 const unsigned char *str
;
395 int precision
, *nchars
, *nbytes
;
397 int i
= 0, i_byte
= 0;
399 struct Lisp_Char_Table
*dp
= buffer_display_table ();
403 int bytes
, thiswidth
;
405 int c
= STRING_CHAR_AND_LENGTH (str
+ i_byte
, len
- i_byte
, bytes
);
409 val
= DISP_CHAR_VECTOR (dp
, c
);
411 thiswidth
= XVECTOR (val
)->size
;
413 thiswidth
= CHAR_WIDTH (c
);
417 thiswidth
= CHAR_WIDTH (c
);
421 && (width
+ thiswidth
> precision
))
441 /* Return width of string STR of length LEN when displayed in the
442 current buffer. The width is measured by how many columns it
443 occupies on the screen. */
450 return c_string_width (str
, len
, -1, NULL
, NULL
);
453 /* Return width of Lisp string STRING when displayed in the current
454 buffer. The width is measured by how many columns it occupies on
455 the screen while paying attention to compositions. If PRECISION >
456 0, return the width of longest substring that doesn't exceed
457 PRECISION, and set number of characters and bytes of the substring
458 in *NCHARS and *NBYTES respectively. */
461 lisp_string_width (string
, precision
, nchars
, nbytes
)
463 int precision
, *nchars
, *nbytes
;
465 int len
= SCHARS (string
);
466 /* This set multibyte to 0 even if STRING is multibyte when it
467 contains only ascii and eight-bit-graphic, but that's
469 int multibyte
= len
< SBYTES (string
);
470 unsigned char *str
= SDATA (string
);
471 int i
= 0, i_byte
= 0;
473 struct Lisp_Char_Table
*dp
= buffer_display_table ();
477 int chars
, bytes
, thiswidth
;
480 EMACS_INT ignore
, end
;
482 if (find_composition (i
, -1, &ignore
, &end
, &val
, string
)
483 && ((cmp_id
= get_composition_id (i
, i_byte
, end
- i
, val
, string
))
486 thiswidth
= composition_table
[cmp_id
]->width
;
488 bytes
= string_char_to_byte (string
, end
) - i_byte
;
495 c
= STRING_CHAR_AND_LENGTH (str
+ i_byte
, len
- i_byte
, bytes
);
497 c
= str
[i_byte
], bytes
= 1;
501 val
= DISP_CHAR_VECTOR (dp
, c
);
503 thiswidth
= XVECTOR (val
)->size
;
505 thiswidth
= CHAR_WIDTH (c
);
509 thiswidth
= CHAR_WIDTH (c
);
514 && (width
+ thiswidth
> precision
))
534 DEFUN ("string-width", Fstring_width
, Sstring_width
, 1, 1, 0,
535 doc
: /* Return width of STRING when displayed in the current buffer.
536 Width is measured by how many columns it occupies on the screen.
537 When calculating width of a multibyte character in STRING,
538 only the base leading-code is considered; the validity of
539 the following bytes is not checked. Tabs in STRING are always
540 taken to occupy `tab-width' columns. */)
547 XSETFASTINT (val
, lisp_string_width (str
, -1, NULL
, NULL
));
551 DEFUN ("char-direction", Fchar_direction
, Schar_direction
, 1, 1, 0,
552 doc
: /* Return the direction of CHAR.
553 The returned value is 0 for left-to-right and 1 for right-to-left. */)
559 CHECK_CHARACTER (ch
);
561 return CHAR_TABLE_REF (Vchar_direction_table
, c
);
564 /* Return the number of characters in the NBYTES bytes at PTR.
565 This works by looking at the contents and checking for multibyte
566 sequences while assuming that there's no invalid sequence.
567 However, if the current buffer has enable-multibyte-characters =
568 nil, we treat each byte as a character. */
571 chars_in_text (ptr
, nbytes
)
572 const unsigned char *ptr
;
575 /* current_buffer is null at early stages of Emacs initialization. */
576 if (current_buffer
== 0
577 || NILP (current_buffer
->enable_multibyte_characters
))
580 return multibyte_chars_in_text (ptr
, nbytes
);
583 /* Return the number of characters in the NBYTES bytes at PTR.
584 This works by looking at the contents and checking for multibyte
585 sequences while assuming that there's no invalid sequence. It
586 ignores enable-multibyte-characters. */
589 multibyte_chars_in_text (ptr
, nbytes
)
590 const unsigned char *ptr
;
593 const unsigned char *endp
= ptr
+ nbytes
;
598 int len
= MULTIBYTE_LENGTH (ptr
, endp
);
609 /* Parse unibyte text at STR of LEN bytes as a multibyte text, count
610 characters and bytes in it, and store them in *NCHARS and *NBYTES
611 respectively. On counting bytes, pay attention to that 8-bit
612 characters not constructing a valid multibyte sequence are
613 represented by 2-byte in a multibyte text. */
616 parse_str_as_multibyte (str
, len
, nchars
, nbytes
)
617 const unsigned char *str
;
618 int len
, *nchars
, *nbytes
;
620 const unsigned char *endp
= str
+ len
;
621 int n
, chars
= 0, bytes
= 0;
623 if (len
>= MAX_MULTIBYTE_LENGTH
)
625 const unsigned char *adjusted_endp
= endp
- MAX_MULTIBYTE_LENGTH
;
626 while (str
< adjusted_endp
)
628 if ((n
= MULTIBYTE_LENGTH_NO_CHECK (str
)) > 0)
629 str
+= n
, bytes
+= n
;
637 if ((n
= MULTIBYTE_LENGTH (str
, endp
)) > 0)
638 str
+= n
, bytes
+= n
;
649 /* Arrange unibyte text at STR of NBYTES bytes as a multibyte text.
650 It actually converts only such 8-bit characters that don't contruct
651 a multibyte sequence to multibyte forms of Latin-1 characters. If
652 NCHARS is nonzero, set *NCHARS to the number of characters in the
653 text. It is assured that we can use LEN bytes at STR as a work
654 area and that is enough. Return the number of bytes of the
658 str_as_multibyte (str
, len
, nbytes
, nchars
)
660 int len
, nbytes
, *nchars
;
662 unsigned char *p
= str
, *endp
= str
+ nbytes
;
667 if (nbytes
>= MAX_MULTIBYTE_LENGTH
)
669 unsigned char *adjusted_endp
= endp
- MAX_MULTIBYTE_LENGTH
;
670 while (p
< adjusted_endp
671 && (n
= MULTIBYTE_LENGTH_NO_CHECK (p
)) > 0)
674 while ((n
= MULTIBYTE_LENGTH (p
, endp
)) > 0)
684 safe_bcopy ((char *) p
, (char *) (endp
- nbytes
), nbytes
);
687 if (nbytes
>= MAX_MULTIBYTE_LENGTH
)
689 unsigned char *adjusted_endp
= endp
- MAX_MULTIBYTE_LENGTH
;
690 while (p
< adjusted_endp
)
692 if ((n
= MULTIBYTE_LENGTH_NO_CHECK (p
)) > 0)
700 c
= BYTE8_TO_CHAR (c
);
701 to
+= CHAR_STRING (c
, to
);
708 if ((n
= MULTIBYTE_LENGTH (p
, endp
)) > 0)
716 c
= BYTE8_TO_CHAR (c
);
717 to
+= CHAR_STRING (c
, to
);
726 /* Parse unibyte string at STR of LEN bytes, and return the number of
727 bytes it may ocupy when converted to multibyte string by
728 `str_to_multibyte'. */
731 parse_str_to_multibyte (str
, len
)
735 unsigned char *endp
= str
+ len
;
738 for (bytes
= 0; str
< endp
; str
++)
739 bytes
+= (*str
< 0x80) ? 1 : 2;
744 /* Convert unibyte text at STR of NBYTES bytes to a multibyte text
745 that contains the same single-byte characters. It actually
746 converts all 8-bit characters to multibyte forms. It is assured
747 that we can use LEN bytes at STR as a work area and that is
751 str_to_multibyte (str
, len
, bytes
)
755 unsigned char *p
= str
, *endp
= str
+ bytes
;
758 while (p
< endp
&& *p
< 0x80) p
++;
764 safe_bcopy ((char *) p
, (char *) (endp
- bytes
), bytes
);
771 c
= BYTE8_TO_CHAR (c
);
772 to
+= CHAR_STRING (c
, to
);
777 /* Arrange multibyte text at STR of LEN bytes as a unibyte text. It
778 actually converts characters in the range 0x80..0xFF to
782 str_as_unibyte (str
, bytes
)
786 const unsigned char *p
= str
, *endp
= str
+ bytes
;
793 len
= BYTES_BY_CHAR_HEAD (c
);
794 if (CHAR_BYTE8_HEAD_P (c
))
798 to
= str
+ (p
- str
);
802 len
= BYTES_BY_CHAR_HEAD (c
);
803 if (CHAR_BYTE8_HEAD_P (c
))
805 c
= STRING_CHAR_ADVANCE (p
);
806 *to
++ = CHAR_TO_BYTE8 (c
);
810 while (len
--) *to
++ = *p
++;
817 string_count_byte8 (string
)
820 int multibyte
= STRING_MULTIBYTE (string
);
821 int nbytes
= SBYTES (string
);
822 unsigned char *p
= SDATA (string
);
823 unsigned char *pend
= p
+ nbytes
;
831 len
= BYTES_BY_CHAR_HEAD (c
);
833 if (CHAR_BYTE8_HEAD_P (c
))
848 string_escape_byte8 (string
)
851 int nchars
= SCHARS (string
);
852 int nbytes
= SBYTES (string
);
853 int multibyte
= STRING_MULTIBYTE (string
);
855 const unsigned char *src
, *src_end
;
860 if (multibyte
&& nchars
== nbytes
)
863 byte8_count
= string_count_byte8 (string
);
865 if (byte8_count
== 0)
869 /* Convert 2-byte sequence of byte8 chars to 4-byte octal. */
870 val
= make_uninit_multibyte_string (nchars
+ byte8_count
* 3,
871 nbytes
+ byte8_count
* 2);
873 /* Convert 1-byte sequence of byte8 chars to 4-byte octal. */
874 val
= make_uninit_string (nbytes
+ byte8_count
* 3);
876 src
= SDATA (string
);
877 src_end
= src
+ nbytes
;
880 while (src
< src_end
)
883 len
= BYTES_BY_CHAR_HEAD (c
);
885 if (CHAR_BYTE8_HEAD_P (c
))
887 c
= STRING_CHAR_ADVANCE (src
);
888 c
= CHAR_TO_BYTE8 (c
);
889 sprintf ((char *) dst
, "\\%03o", c
);
893 while (len
--) *dst
++ = *src
++;
896 while (src
< src_end
)
901 sprintf ((char *) dst
, "\\%03o", c
);
911 DEFUN ("string", Fstring
, Sstring
, 0, MANY
, 0,
913 Concatenate all the argument characters and make the result a string.
914 usage: (string &rest CHARACTERS) */)
920 unsigned char *buf
= (unsigned char *) alloca (MAX_MULTIBYTE_LENGTH
* n
);
921 unsigned char *p
= buf
;
924 for (i
= 0; i
< n
; i
++)
926 CHECK_CHARACTER (args
[i
]);
928 p
+= CHAR_STRING (c
, p
);
931 return make_string_from_bytes ((char *) buf
, n
, p
- buf
);
934 DEFUN ("unibyte-string", Funibyte_string
, Sunibyte_string
, 0, MANY
, 0,
935 doc
: /* Concatenate all the argument bytes and make the result a unibyte string.
936 usage: (unibyte-string &rest BYTES) */)
942 unsigned char *buf
= (unsigned char *) alloca (n
);
943 unsigned char *p
= buf
;
946 for (i
= 0; i
< n
; i
++)
948 CHECK_NATNUM (args
[i
]);
949 c
= XFASTINT (args
[i
]);
951 args_out_of_range_3 (args
[i
], make_number (0), make_number (255));
955 return make_string_from_bytes ((char *) buf
, n
, p
- buf
);
959 init_character_once ()
968 DEFSYM (Qcharacterp
, "characterp");
969 DEFSYM (Qauto_fill_chars
, "auto-fill-chars");
971 staticpro (&Vchar_unify_table
);
972 Vchar_unify_table
= Qnil
;
974 defsubr (&Smax_char
);
975 defsubr (&Scharacterp
);
976 defsubr (&Sunibyte_char_to_multibyte
);
977 defsubr (&Smultibyte_char_to_unibyte
);
978 defsubr (&Schar_bytes
);
979 defsubr (&Schar_width
);
980 defsubr (&Sstring_width
);
981 defsubr (&Schar_direction
);
983 defsubr (&Sunibyte_string
);
985 DEFVAR_LISP ("translation-table-vector", &Vtranslation_table_vector
,
987 Vector recording all translation tables ever defined.
988 Each element is a pair (SYMBOL . TABLE) relating the table to the
989 symbol naming it. The ID of a translation table is an index into this vector. */);
990 Vtranslation_table_vector
= Fmake_vector (make_number (16), Qnil
);
992 DEFVAR_LISP ("auto-fill-chars", &Vauto_fill_chars
,
994 A char-table for characters which invoke auto-filling.
995 Such characters have value t in this table. */);
996 Vauto_fill_chars
= Fmake_char_table (Qauto_fill_chars
, Qnil
);
997 CHAR_TABLE_SET (Vauto_fill_chars
, ' ', Qt
);
998 CHAR_TABLE_SET (Vauto_fill_chars
, '\n', Qt
);
1000 DEFVAR_LISP ("char-width-table", &Vchar_width_table
,
1002 A char-table for width (columns) of each character. */);
1003 Vchar_width_table
= Fmake_char_table (Qnil
, make_number (1));
1004 char_table_set_range (Vchar_width_table
, 0x80, 0x9F, make_number (4));
1005 char_table_set_range (Vchar_width_table
, MAX_5_BYTE_CHAR
+ 1, MAX_CHAR
,
1008 DEFVAR_LISP ("char-direction-table", &Vchar_direction_table
,
1009 doc
: /* A char-table for direction of each character. */);
1010 Vchar_direction_table
= Fmake_char_table (Qnil
, make_number (1));
1012 DEFVAR_LISP ("printable-chars", &Vprintable_chars
,
1013 doc
: /* A char-table for each printable character. */);
1014 Vprintable_chars
= Fmake_char_table (Qnil
, Qnil
);
1015 Fset_char_table_range (Vprintable_chars
,
1016 Fcons (make_number (32), make_number (126)), Qt
);
1017 Fset_char_table_range (Vprintable_chars
,
1018 Fcons (make_number (160),
1019 make_number (MAX_5_BYTE_CHAR
)), Qt
);
1021 DEFVAR_LISP ("char-script-table", &Vchar_script_table
,
1022 doc
: /* Char table of script symbols.
1023 It has one extra slot whose value is a list of script symbols. */);
1025 /* Intern this now in case it isn't already done.
1026 Setting this variable twice is harmless.
1027 But don't staticpro it here--that is done in alloc.c. */
1028 Qchar_table_extra_slots
= intern ("char-table-extra-slots");
1029 DEFSYM (Qchar_script_table
, "char-script-table");
1030 Fput (Qchar_script_table
, Qchar_table_extra_slots
, make_number (1));
1031 Vchar_script_table
= Fmake_char_table (Qchar_script_table
, Qnil
);
1033 DEFVAR_LISP ("script-representative-chars", &Vscript_representative_chars
,
1034 doc
: /* Alist of scripts vs the representative characters. */);
1035 Vscript_representative_chars
= Qnil
;
1040 /* arch-tag: b6665960-3c3d-4184-85cd-af4318197999
1041 (do not change this comment) */