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
5 Free Software Foundation, Inc.
6 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008
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, or (at your option)
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; see the file COPYING. If not, write to the
24 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
25 Boston, MA 02110-1301, USA. */
27 /* At first, see the document in `character.h' to understand the code
38 #include <sys/types.h>
40 #include "character.h"
43 #include "composite.h"
52 Lisp_Object Qcharacterp
;
54 /* Vector of translation table ever defined.
55 ID of a translation table is used to index this vector. */
56 Lisp_Object Vtranslation_table_vector
;
58 /* A char-table for characters which may invoke auto-filling. */
59 Lisp_Object Vauto_fill_chars
;
61 Lisp_Object Qauto_fill_chars
;
63 /* Char-table of information about which character to unify to which
65 Lisp_Object Vchar_unify_table
;
67 /* A char-table. An element is non-nil iff the corresponding
68 character has a printable glyph. */
69 Lisp_Object Vprintable_chars
;
71 /* A char-table. An elemnent is a column-width of the corresponding
73 Lisp_Object Vchar_width_table
;
75 /* A char-table. An element is a symbol indicating the direction
76 property of corresponding character. */
77 Lisp_Object Vchar_direction_table
;
79 /* Variable used locally in the macro FETCH_MULTIBYTE_CHAR. */
80 unsigned char *_fetch_multibyte_char_p
;
82 /* Char table of scripts. */
83 Lisp_Object Vchar_script_table
;
85 /* Alist of scripts vs representative characters. */
86 Lisp_Object Vscript_representative_chars
;
88 static Lisp_Object Qchar_script_table
;
90 /* Mapping table from unibyte chars to multibyte chars. */
91 int unibyte_to_multibyte_table
[256];
93 /* Nth element is 1 iff unibyte char N can be mapped to a multibyte
95 char unibyte_has_multibyte_table
[256];
99 /* If character code C has modifier masks, reflect them to the
100 character code if possible. Return the resulting code. */
103 char_resolve_modifier_mask (c
)
106 /* An non-ASCII character can't reflect modifier bits to the code. */
107 if (! ASCII_CHAR_P ((c
& ~CHAR_MODIFIER_MASK
)))
110 /* For Meta, Shift, and Control modifiers, we need special care. */
113 /* Move the meta bit to the right place for a string. */
114 c
= (c
& ~CHAR_META
) | 0x80;
118 /* Shift modifier is valid only with [A-Za-z]. */
119 if ((c
& 0377) >= 'A' && (c
& 0377) <= 'Z')
121 else if ((c
& 0377) >= 'a' && (c
& 0377) <= 'z')
122 c
= (c
& ~CHAR_SHIFT
) - ('a' - 'A');
126 /* Simulate the code in lread.c. */
127 /* Allow `\C- ' and `\C-?'. */
128 if ((c
& ~CHAR_CTL
) == ' ')
130 else if ((c
& ~CHAR_CTL
) == '?')
132 /* ASCII control chars are made from letters (both cases),
133 as well as the non-letters within 0100...0137. */
134 else if ((c
& 0137) >= 0101 && (c
& 0137) <= 0132)
135 c
&= (037 | (~0177 & ~CHAR_CTL
));
136 else if ((c
& 0177) >= 0100 && (c
& 0177) <= 0137)
137 c
&= (037 | (~0177 & ~CHAR_CTL
));
144 /* Store multibyte form of character C at P. If C has modifier bits,
145 handle them appropriately. */
154 if (c
& CHAR_MODIFIER_MASK
)
156 c
= (unsigned) char_resolve_modifier_mask ((int) c
);
157 /* If C still has any modifier bits, just ignore it. */
158 c
&= ~CHAR_MODIFIER_MASK
;
161 MAYBE_UNIFY_CHAR (c
);
163 if (c
<= MAX_3_BYTE_CHAR
)
165 bytes
= CHAR_STRING (c
, p
);
167 else if (c
<= MAX_4_BYTE_CHAR
)
169 p
[0] = (0xF0 | (c
>> 18));
170 p
[1] = (0x80 | ((c
>> 12) & 0x3F));
171 p
[2] = (0x80 | ((c
>> 6) & 0x3F));
172 p
[3] = (0x80 | (c
& 0x3F));
175 else if (c
<= MAX_5_BYTE_CHAR
)
178 p
[1] = (0x80 | ((c
>> 18) & 0x0F));
179 p
[2] = (0x80 | ((c
>> 12) & 0x3F));
180 p
[3] = (0x80 | ((c
>> 6) & 0x3F));
181 p
[4] = (0x80 | (c
& 0x3F));
184 else if (c
<= MAX_CHAR
)
186 c
= CHAR_TO_BYTE8 (c
);
187 bytes
= BYTE8_STRING (c
, p
);
190 error ("Invalid character: %d", c
);
196 /* Return a character whose multibyte form is at P. Set LEN is not
197 NULL, it must be a pointer to integer. In that case, set *LEN to
198 the byte length of the multibyte form. If ADVANCED is not NULL, is
199 must be a pointer to unsigned char. In that case, set *ADVANCED to
200 the ending address (i.e. the starting address of the next
201 character) of the multibyte form. */
204 string_char (p
, advanced
, len
)
205 const unsigned char *p
;
206 const unsigned char **advanced
;
210 const unsigned char *saved_p
= p
;
212 if (*p
< 0x80 || ! (*p
& 0x20) || ! (*p
& 0x10))
214 c
= STRING_CHAR_ADVANCE (p
);
216 else if (! (*p
& 0x08))
218 c
= ((((p
)[0] & 0xF) << 18)
219 | (((p
)[1] & 0x3F) << 12)
220 | (((p
)[2] & 0x3F) << 6)
226 c
= ((((p
)[1] & 0x3F) << 18)
227 | (((p
)[2] & 0x3F) << 12)
228 | (((p
)[3] & 0x3F) << 6)
233 MAYBE_UNIFY_CHAR (c
);
243 /* Translate character C by translation table TABLE. If C is
244 negative, translate a character specified by CHARSET and CODE. If
245 no translation is found in TABLE, return the untranslated
246 character. If TABLE is a list, elements are char tables. In this
247 case, translace C by all tables. */
250 translate_char (table
, c
)
254 if (CHAR_TABLE_P (table
))
258 ch
= CHAR_TABLE_REF (table
, c
);
264 for (; CONSP (table
); table
= XCDR (table
))
265 c
= translate_char (XCAR (table
), c
);
270 /* Convert the multibyte character C to unibyte 8-bit character based
271 on the current value of charset_unibyte. If dimension of
272 charset_unibyte is more than one, return (C & 0xFF).
274 The argument REV_TBL is now ignored. It will be removed in the
278 multibyte_char_to_unibyte (c
, rev_tbl
)
282 struct charset
*charset
;
285 if (CHAR_BYTE8_P (c
))
286 return CHAR_TO_BYTE8 (c
);
287 charset
= CHARSET_FROM_ID (charset_unibyte
);
288 c1
= ENCODE_CHAR (charset
, c
);
289 return ((c1
!= CHARSET_INVALID_CODE (charset
)) ? c1
: c
& 0xFF);
292 /* Like multibyte_char_to_unibyte, but return -1 if C is not supported
293 by charset_unibyte. */
296 multibyte_char_to_unibyte_safe (c
)
299 struct charset
*charset
;
302 if (CHAR_BYTE8_P (c
))
303 return CHAR_TO_BYTE8 (c
);
304 charset
= CHARSET_FROM_ID (charset_unibyte
);
305 c1
= ENCODE_CHAR (charset
, c
);
306 return ((c1
!= CHARSET_INVALID_CODE (charset
)) ? c1
: -1);
309 DEFUN ("characterp", Fcharacterp
, Scharacterp
, 1, 2, 0,
310 doc
: /* Return non-nil if OBJECT is a character. */)
312 Lisp_Object object
, ignore
;
314 return (CHARACTERP (object
) ? Qt
: Qnil
);
317 DEFUN ("max-char", Fmax_char
, Smax_char
, 0, 0, 0,
318 doc
: /* Return the character of the maximum code. */)
321 return make_number (MAX_CHAR
);
324 DEFUN ("unibyte-char-to-multibyte", Funibyte_char_to_multibyte
,
325 Sunibyte_char_to_multibyte
, 1, 1, 0,
326 doc
: /* Convert the unibyte character CH to multibyte character.
327 The multibyte character is a result of decoding CH by
328 the current unibyte charset (see `unibyte-charset'). */)
333 struct charset
*charset
;
335 CHECK_CHARACTER (ch
);
338 error ("Invalid unibyte character: %d", c
);
339 charset
= CHARSET_FROM_ID (charset_unibyte
);
340 c
= DECODE_CHAR (charset
, c
);
342 c
= BYTE8_TO_CHAR (XFASTINT (ch
));
343 return make_number (c
);
346 DEFUN ("multibyte-char-to-unibyte", Fmultibyte_char_to_unibyte
,
347 Smultibyte_char_to_unibyte
, 1, 1, 0,
348 doc
: /* Convert the multibyte character CH to unibyte character.\n\
349 The unibyte character is a result of encoding CH by
350 the current primary charset (value of `charset-primary'). */)
356 CHECK_CHARACTER (ch
);
358 c
= CHAR_TO_BYTE8 (c
);
359 return make_number (c
);
362 DEFUN ("char-bytes", Fchar_bytes
, Schar_bytes
, 1, 1, 0,
363 doc
: /* Return 1 regardless of the argument CHAR.
364 This is now an obsolete function. We keep it just for backward compatibility. */)
368 CHECK_CHARACTER (ch
);
369 return make_number (1);
372 DEFUN ("char-width", Fchar_width
, Schar_width
, 1, 1, 0,
373 doc
: /* Return width of CHAR when displayed in the current buffer.
374 The width is measured by how many columns it occupies on the screen.
375 Tab is taken to occupy `tab-width' columns. */)
381 struct Lisp_Char_Table
*dp
= buffer_display_table ();
383 CHECK_CHARACTER (ch
);
386 /* Get the way the display table would display it. */
387 disp
= dp
? DISP_CHAR_VECTOR (dp
, c
) : Qnil
;
390 width
= ASIZE (disp
);
392 width
= CHAR_WIDTH (c
);
394 return make_number (width
);
397 /* Return width of string STR of length LEN when displayed in the
398 current buffer. The width is measured by how many columns it
399 occupies on the screen. If PRECISION > 0, return the width of
400 longest substring that doesn't exceed PRECISION, and set number of
401 characters and bytes of the substring in *NCHARS and *NBYTES
405 c_string_width (str
, len
, precision
, nchars
, nbytes
)
406 const unsigned char *str
;
407 int precision
, *nchars
, *nbytes
;
409 int i
= 0, i_byte
= 0;
411 struct Lisp_Char_Table
*dp
= buffer_display_table ();
415 int bytes
, thiswidth
;
417 int c
= STRING_CHAR_AND_LENGTH (str
+ i_byte
, len
- i_byte
, bytes
);
421 val
= DISP_CHAR_VECTOR (dp
, c
);
423 thiswidth
= XVECTOR (val
)->size
;
425 thiswidth
= CHAR_WIDTH (c
);
429 thiswidth
= CHAR_WIDTH (c
);
433 && (width
+ thiswidth
> precision
))
453 /* Return width of string STR of length LEN when displayed in the
454 current buffer. The width is measured by how many columns it
455 occupies on the screen. */
462 return c_string_width (str
, len
, -1, NULL
, NULL
);
465 /* Return width of Lisp string STRING when displayed in the current
466 buffer. The width is measured by how many columns it occupies on
467 the screen while paying attention to compositions. If PRECISION >
468 0, return the width of longest substring that doesn't exceed
469 PRECISION, and set number of characters and bytes of the substring
470 in *NCHARS and *NBYTES respectively. */
473 lisp_string_width (string
, precision
, nchars
, nbytes
)
475 int precision
, *nchars
, *nbytes
;
477 int len
= SCHARS (string
);
478 /* This set multibyte to 0 even if STRING is multibyte when it
479 contains only ascii and eight-bit-graphic, but that's
481 int multibyte
= len
< SBYTES (string
);
482 unsigned char *str
= SDATA (string
);
483 int i
= 0, i_byte
= 0;
485 struct Lisp_Char_Table
*dp
= buffer_display_table ();
489 int chars
, bytes
, thiswidth
;
492 EMACS_INT ignore
, end
;
494 if (find_composition (i
, -1, &ignore
, &end
, &val
, string
)
495 && ((cmp_id
= get_composition_id (i
, i_byte
, end
- i
, val
, string
))
498 thiswidth
= composition_table
[cmp_id
]->width
;
500 bytes
= string_char_to_byte (string
, end
) - i_byte
;
507 c
= STRING_CHAR_AND_LENGTH (str
+ i_byte
, len
- i_byte
, bytes
);
509 c
= str
[i_byte
], bytes
= 1;
513 val
= DISP_CHAR_VECTOR (dp
, c
);
515 thiswidth
= XVECTOR (val
)->size
;
517 thiswidth
= CHAR_WIDTH (c
);
521 thiswidth
= CHAR_WIDTH (c
);
526 && (width
+ thiswidth
> precision
))
546 DEFUN ("string-width", Fstring_width
, Sstring_width
, 1, 1, 0,
547 doc
: /* Return width of STRING when displayed in the current buffer.
548 Width is measured by how many columns it occupies on the screen.
549 When calculating width of a multibyte character in STRING,
550 only the base leading-code is considered; the validity of
551 the following bytes is not checked. Tabs in STRING are always
552 taken to occupy `tab-width' columns. */)
559 XSETFASTINT (val
, lisp_string_width (str
, -1, NULL
, NULL
));
563 DEFUN ("char-direction", Fchar_direction
, Schar_direction
, 1, 1, 0,
564 doc
: /* Return the direction of CHAR.
565 The returned value is 0 for left-to-right and 1 for right-to-left. */)
571 CHECK_CHARACTER (ch
);
573 return CHAR_TABLE_REF (Vchar_direction_table
, c
);
576 /* Return the number of characters in the NBYTES bytes at PTR.
577 This works by looking at the contents and checking for multibyte
578 sequences while assuming that there's no invalid sequence.
579 However, if the current buffer has enable-multibyte-characters =
580 nil, we treat each byte as a character. */
583 chars_in_text (ptr
, nbytes
)
584 const unsigned char *ptr
;
587 /* current_buffer is null at early stages of Emacs initialization. */
588 if (current_buffer
== 0
589 || NILP (current_buffer
->enable_multibyte_characters
))
592 return multibyte_chars_in_text (ptr
, nbytes
);
595 /* Return the number of characters in the NBYTES bytes at PTR.
596 This works by looking at the contents and checking for multibyte
597 sequences while assuming that there's no invalid sequence. It
598 ignores enable-multibyte-characters. */
601 multibyte_chars_in_text (ptr
, nbytes
)
602 const unsigned char *ptr
;
605 const unsigned char *endp
= ptr
+ nbytes
;
610 int len
= MULTIBYTE_LENGTH (ptr
, endp
);
621 /* Parse unibyte text at STR of LEN bytes as a multibyte text, count
622 characters and bytes in it, and store them in *NCHARS and *NBYTES
623 respectively. On counting bytes, pay attention to that 8-bit
624 characters not constructing a valid multibyte sequence are
625 represented by 2-byte in a multibyte text. */
628 parse_str_as_multibyte (str
, len
, nchars
, nbytes
)
629 const unsigned char *str
;
630 int len
, *nchars
, *nbytes
;
632 const unsigned char *endp
= str
+ len
;
633 int n
, chars
= 0, bytes
= 0;
635 if (len
>= MAX_MULTIBYTE_LENGTH
)
637 const unsigned char *adjusted_endp
= endp
- MAX_MULTIBYTE_LENGTH
;
638 while (str
< adjusted_endp
)
640 if ((n
= MULTIBYTE_LENGTH_NO_CHECK (str
)) > 0)
641 str
+= n
, bytes
+= n
;
649 if ((n
= MULTIBYTE_LENGTH (str
, endp
)) > 0)
650 str
+= n
, bytes
+= n
;
661 /* Arrange unibyte text at STR of NBYTES bytes as a multibyte text.
662 It actually converts only such 8-bit characters that don't contruct
663 a multibyte sequence to multibyte forms of Latin-1 characters. If
664 NCHARS is nonzero, set *NCHARS to the number of characters in the
665 text. It is assured that we can use LEN bytes at STR as a work
666 area and that is enough. Return the number of bytes of the
670 str_as_multibyte (str
, len
, nbytes
, nchars
)
672 int len
, nbytes
, *nchars
;
674 unsigned char *p
= str
, *endp
= str
+ nbytes
;
679 if (nbytes
>= MAX_MULTIBYTE_LENGTH
)
681 unsigned char *adjusted_endp
= endp
- MAX_MULTIBYTE_LENGTH
;
682 while (p
< adjusted_endp
683 && (n
= MULTIBYTE_LENGTH_NO_CHECK (p
)) > 0)
686 while ((n
= MULTIBYTE_LENGTH (p
, endp
)) > 0)
696 safe_bcopy ((char *) p
, (char *) (endp
- nbytes
), nbytes
);
699 if (nbytes
>= MAX_MULTIBYTE_LENGTH
)
701 unsigned char *adjusted_endp
= endp
- MAX_MULTIBYTE_LENGTH
;
702 while (p
< adjusted_endp
)
704 if ((n
= MULTIBYTE_LENGTH_NO_CHECK (p
)) > 0)
712 c
= BYTE8_TO_CHAR (c
);
713 to
+= CHAR_STRING (c
, to
);
720 if ((n
= MULTIBYTE_LENGTH (p
, endp
)) > 0)
728 c
= BYTE8_TO_CHAR (c
);
729 to
+= CHAR_STRING (c
, to
);
738 /* Parse unibyte string at STR of LEN bytes, and return the number of
739 bytes it may ocupy when converted to multibyte string by
740 `str_to_multibyte'. */
743 parse_str_to_multibyte (str
, len
)
747 unsigned char *endp
= str
+ len
;
750 for (bytes
= 0; str
< endp
; str
++)
751 bytes
+= (*str
< 0x80) ? 1 : 2;
756 /* Convert unibyte text at STR of NBYTES bytes to a multibyte text
757 that contains the same single-byte characters. It actually
758 converts all 8-bit characters to multibyte forms. It is assured
759 that we can use LEN bytes at STR as a work area and that is
763 str_to_multibyte (str
, len
, bytes
)
767 unsigned char *p
= str
, *endp
= str
+ bytes
;
770 while (p
< endp
&& *p
< 0x80) p
++;
776 safe_bcopy ((char *) p
, (char *) (endp
- bytes
), bytes
);
783 c
= BYTE8_TO_CHAR (c
);
784 to
+= CHAR_STRING (c
, to
);
789 /* Arrange multibyte text at STR of LEN bytes as a unibyte text. It
790 actually converts characters in the range 0x80..0xFF to
794 str_as_unibyte (str
, bytes
)
798 const unsigned char *p
= str
, *endp
= str
+ bytes
;
805 len
= BYTES_BY_CHAR_HEAD (c
);
806 if (CHAR_BYTE8_HEAD_P (c
))
810 to
= str
+ (p
- str
);
814 len
= BYTES_BY_CHAR_HEAD (c
);
815 if (CHAR_BYTE8_HEAD_P (c
))
817 c
= STRING_CHAR_ADVANCE (p
);
818 *to
++ = CHAR_TO_BYTE8 (c
);
822 while (len
--) *to
++ = *p
++;
829 string_count_byte8 (string
)
832 int multibyte
= STRING_MULTIBYTE (string
);
833 int nbytes
= SBYTES (string
);
834 unsigned char *p
= SDATA (string
);
835 unsigned char *pend
= p
+ nbytes
;
843 len
= BYTES_BY_CHAR_HEAD (c
);
845 if (CHAR_BYTE8_HEAD_P (c
))
860 string_escape_byte8 (string
)
863 int nchars
= SCHARS (string
);
864 int nbytes
= SBYTES (string
);
865 int multibyte
= STRING_MULTIBYTE (string
);
867 const unsigned char *src
, *src_end
;
872 if (multibyte
&& nchars
== nbytes
)
875 byte8_count
= string_count_byte8 (string
);
877 if (byte8_count
== 0)
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);
885 /* Convert 1-byte sequence of byte8 chars to 4-byte octal. */
886 val
= make_uninit_string (nbytes
+ byte8_count
* 3);
888 src
= SDATA (string
);
889 src_end
= src
+ nbytes
;
892 while (src
< src_end
)
895 len
= BYTES_BY_CHAR_HEAD (c
);
897 if (CHAR_BYTE8_HEAD_P (c
))
899 c
= STRING_CHAR_ADVANCE (src
);
900 c
= CHAR_TO_BYTE8 (c
);
901 sprintf ((char *) dst
, "\\%03o", c
);
905 while (len
--) *dst
++ = *src
++;
908 while (src
< src_end
)
913 sprintf ((char *) dst
, "\\%03o", c
);
923 DEFUN ("string", Fstring
, Sstring
, 0, MANY
, 0,
925 Concatenate all the argument characters and make the result a string.
926 usage: (string &rest CHARACTERS) */)
932 unsigned char *buf
= (unsigned char *) alloca (MAX_MULTIBYTE_LENGTH
* n
);
933 unsigned char *p
= buf
;
936 for (i
= 0; i
< n
; i
++)
938 CHECK_CHARACTER (args
[i
]);
940 p
+= CHAR_STRING (c
, p
);
943 return make_string_from_bytes ((char *) buf
, n
, p
- buf
);
946 DEFUN ("unibyte-string", Funibyte_string
, Sunibyte_string
, 0, MANY
, 0,
947 doc
: /* Concatenate all the argument bytes and make the result a unibyte string.
948 usage: (unibyte-string &rest BYTES) */)
954 unsigned char *buf
= (unsigned char *) alloca (n
);
955 unsigned char *p
= buf
;
958 for (i
= 0; i
< n
; i
++)
960 CHECK_NATNUM (args
[i
]);
961 c
= XFASTINT (args
[i
]);
963 args_out_of_range_3 (args
[i
], make_number (0), make_number (255));
967 return make_string_from_bytes ((char *) buf
, n
, p
- buf
);
971 init_character_once ()
980 DEFSYM (Qcharacterp
, "characterp");
981 DEFSYM (Qauto_fill_chars
, "auto-fill-chars");
983 staticpro (&Vchar_unify_table
);
984 Vchar_unify_table
= Qnil
;
986 defsubr (&Smax_char
);
987 defsubr (&Scharacterp
);
988 defsubr (&Sunibyte_char_to_multibyte
);
989 defsubr (&Smultibyte_char_to_unibyte
);
990 defsubr (&Schar_bytes
);
991 defsubr (&Schar_width
);
992 defsubr (&Sstring_width
);
993 defsubr (&Schar_direction
);
995 defsubr (&Sunibyte_string
);
997 DEFVAR_LISP ("translation-table-vector", &Vtranslation_table_vector
,
999 Vector recording all translation tables ever defined.
1000 Each element is a pair (SYMBOL . TABLE) relating the table to the
1001 symbol naming it. The ID of a translation table is an index into this vector. */);
1002 Vtranslation_table_vector
= Fmake_vector (make_number (16), Qnil
);
1004 DEFVAR_LISP ("auto-fill-chars", &Vauto_fill_chars
,
1006 A char-table for characters which invoke auto-filling.
1007 Such characters have value t in this table. */);
1008 Vauto_fill_chars
= Fmake_char_table (Qauto_fill_chars
, Qnil
);
1009 CHAR_TABLE_SET (Vauto_fill_chars
, ' ', Qt
);
1010 CHAR_TABLE_SET (Vauto_fill_chars
, '\n', Qt
);
1012 DEFVAR_LISP ("char-width-table", &Vchar_width_table
,
1014 A char-table for width (columns) of each character. */);
1015 Vchar_width_table
= Fmake_char_table (Qnil
, make_number (1));
1016 char_table_set_range (Vchar_width_table
, 0x80, 0x9F, make_number (4));
1017 char_table_set_range (Vchar_width_table
, MAX_5_BYTE_CHAR
+ 1, MAX_CHAR
,
1020 DEFVAR_LISP ("char-direction-table", &Vchar_direction_table
,
1021 doc
: /* A char-table for direction of each character. */);
1022 Vchar_direction_table
= Fmake_char_table (Qnil
, make_number (1));
1024 DEFVAR_LISP ("printable-chars", &Vprintable_chars
,
1025 doc
: /* A char-table for each printable character. */);
1026 Vprintable_chars
= Fmake_char_table (Qnil
, Qnil
);
1027 Fset_char_table_range (Vprintable_chars
,
1028 Fcons (make_number (32), make_number (126)), Qt
);
1029 Fset_char_table_range (Vprintable_chars
,
1030 Fcons (make_number (160),
1031 make_number (MAX_5_BYTE_CHAR
)), Qt
);
1033 DEFVAR_LISP ("char-script-table", &Vchar_script_table
,
1034 doc
: /* Char table of script symbols.
1035 It has one extra slot whose value is a list of script symbols. */);
1037 /* Intern this now in case it isn't already done.
1038 Setting this variable twice is harmless.
1039 But don't staticpro it here--that is done in alloc.c. */
1040 Qchar_table_extra_slots
= intern ("char-table-extra-slots");
1041 DEFSYM (Qchar_script_table
, "char-script-table");
1042 Fput (Qchar_script_table
, Qchar_table_extra_slots
, make_number (1));
1043 Vchar_script_table
= Fmake_char_table (Qchar_script_table
, Qnil
);
1045 DEFVAR_LISP ("script-representative-chars", &Vscript_representative_chars
,
1046 doc
: /* Alist of scripts vs the representative characters. */);
1047 Vscript_representative_chars
= Qnil
;
1052 /* arch-tag: b6665960-3c3d-4184-85cd-af4318197999
1053 (do not change this comment) */