1 /* XEmacs routines to deal with char tables.
2 Copyright (C) 1992, 1995 Free Software Foundation, Inc.
3 Copyright (C) 1995 Sun Microsystems, Inc.
4 Copyright (C) 1995, 1996 Ben Wing.
5 Copyright (C) 1995, 1997, 1999 Electrotechnical Laboratory, JAPAN.
6 Licensed to the Free Software Foundation.
8 This file is part of XEmacs.
10 XEmacs is free software; you can redistribute it and/or modify it
11 under the terms of the GNU General Public License as published by the
12 Free Software Foundation; either version 2, or (at your option) any
15 XEmacs is distributed in the hope that it will be useful, but WITHOUT
16 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
20 You should have received a copy of the GNU General Public License
21 along with XEmacs; see the file COPYING. If not, write to
22 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, USA. */
25 /* Synched up with: Mule 2.3. Not synched with FSF.
27 This file was written independently of the FSF implementation,
28 and is not compatible. */
32 Ben Wing: wrote, for 19.13 (Mule). Some category table stuff
33 loosely based on the original Mule.
34 Jareth Hein: fixed a couple of bugs in the implementation, and
35 added regex support for categories with check_category_at
45 Lisp_Object Qchar_tablep, Qchar_table;
47 Lisp_Object Vall_syntax_tables;
50 Lisp_Object Qcategory_table_p;
51 Lisp_Object Qcategory_designator_p;
52 Lisp_Object Qcategory_table_value_p;
54 Lisp_Object Vstandard_category_table;
56 /* Variables to determine word boundary. */
57 Lisp_Object Vword_combining_categories, Vword_separating_categories;
61 /* A char table maps from ranges of characters to values.
63 Implementing a general data structure that maps from arbitrary
64 ranges of numbers to values is tricky to do efficiently. As it
65 happens, it should suffice (and is usually more convenient, anyway)
66 when dealing with characters to restrict the sorts of ranges that
67 can be assigned values, as follows:
70 2) All characters in a charset.
71 3) All characters in a particular row of a charset, where a "row"
72 means all characters with the same first byte.
73 4) A particular character in a charset.
75 We use char tables to generalize the 256-element vectors now
76 littering the Emacs code.
78 Possible uses (all should be converted at some point):
84 5) keyboard-translate-table?
87 abstract type to generalize the Emacs vectors and Mule
88 vectors-of-vectors goo.
91 /************************************************************************/
92 /* Char Table object */
93 /************************************************************************/
98 mark_char_table_entry (Lisp_Object obj)
100 struct Lisp_Char_Table_Entry *cte = XCHAR_TABLE_ENTRY (obj);
103 for (i = 0; i < 96; i++)
105 mark_object (cte->level2[i]);
111 char_table_entry_equal (Lisp_Object obj1, Lisp_Object obj2, int depth)
113 struct Lisp_Char_Table_Entry *cte1 = XCHAR_TABLE_ENTRY (obj1);
114 struct Lisp_Char_Table_Entry *cte2 = XCHAR_TABLE_ENTRY (obj2);
117 for (i = 0; i < 96; i++)
118 if (!internal_equal (cte1->level2[i], cte2->level2[i], depth + 1))
125 char_table_entry_hash (Lisp_Object obj, int depth)
127 struct Lisp_Char_Table_Entry *cte = XCHAR_TABLE_ENTRY (obj);
129 return internal_array_hash (cte->level2, 96, depth);
132 static const struct lrecord_description char_table_entry_description[] = {
133 { XD_LISP_OBJECT, offsetof(struct Lisp_Char_Table_Entry, level2), 96 },
137 DEFINE_LRECORD_IMPLEMENTATION ("char-table-entry", char_table_entry,
138 mark_char_table_entry, internal_object_printer,
139 0, char_table_entry_equal,
140 char_table_entry_hash,
141 char_table_entry_description,
142 struct Lisp_Char_Table_Entry);
146 mark_char_table (Lisp_Object obj)
148 struct Lisp_Char_Table *ct = XCHAR_TABLE (obj);
151 for (i = 0; i < NUM_ASCII_CHARS; i++)
152 mark_object (ct->ascii[i]);
154 for (i = 0; i < NUM_LEADING_BYTES; i++)
155 mark_object (ct->level1[i]);
157 return ct->mirror_table;
160 /* WARNING: All functions of this nature need to be written extremely
161 carefully to avoid crashes during GC. Cf. prune_specifiers()
162 and prune_weak_hash_tables(). */
165 prune_syntax_tables (void)
167 Lisp_Object rest, prev = Qnil;
169 for (rest = Vall_syntax_tables;
171 rest = XCHAR_TABLE (rest)->next_table)
173 if (! marked_p (rest))
175 /* This table is garbage. Remove it from the list. */
177 Vall_syntax_tables = XCHAR_TABLE (rest)->next_table;
179 XCHAR_TABLE (prev)->next_table =
180 XCHAR_TABLE (rest)->next_table;
186 char_table_type_to_symbol (enum char_table_type type)
191 case CHAR_TABLE_TYPE_GENERIC: return Qgeneric;
192 case CHAR_TABLE_TYPE_SYNTAX: return Qsyntax;
193 case CHAR_TABLE_TYPE_DISPLAY: return Qdisplay;
194 case CHAR_TABLE_TYPE_CHAR: return Qchar;
196 case CHAR_TABLE_TYPE_CATEGORY: return Qcategory;
201 static enum char_table_type
202 symbol_to_char_table_type (Lisp_Object symbol)
204 CHECK_SYMBOL (symbol);
206 if (EQ (symbol, Qgeneric)) return CHAR_TABLE_TYPE_GENERIC;
207 if (EQ (symbol, Qsyntax)) return CHAR_TABLE_TYPE_SYNTAX;
208 if (EQ (symbol, Qdisplay)) return CHAR_TABLE_TYPE_DISPLAY;
209 if (EQ (symbol, Qchar)) return CHAR_TABLE_TYPE_CHAR;
211 if (EQ (symbol, Qcategory)) return CHAR_TABLE_TYPE_CATEGORY;
214 signal_simple_error ("Unrecognized char table type", symbol);
215 return CHAR_TABLE_TYPE_GENERIC; /* not reached */
219 print_chartab_range (Emchar first, Emchar last, Lisp_Object val,
220 Lisp_Object printcharfun)
224 write_c_string (" (", printcharfun);
225 print_internal (make_char (first), printcharfun, 0);
226 write_c_string (" ", printcharfun);
227 print_internal (make_char (last), printcharfun, 0);
228 write_c_string (") ", printcharfun);
232 write_c_string (" ", printcharfun);
233 print_internal (make_char (first), printcharfun, 0);
234 write_c_string (" ", printcharfun);
236 print_internal (val, printcharfun, 1);
242 print_chartab_charset_row (Lisp_Object charset,
244 struct Lisp_Char_Table_Entry *cte,
245 Lisp_Object printcharfun)
248 Lisp_Object cat = Qunbound;
251 for (i = 32; i < 128; i++)
253 Lisp_Object pam = cte->level2[i - 32];
265 print_chartab_range (MAKE_CHAR (charset, first, 0),
266 MAKE_CHAR (charset, i - 1, 0),
269 print_chartab_range (MAKE_CHAR (charset, row, first),
270 MAKE_CHAR (charset, row, i - 1),
280 print_chartab_range (MAKE_CHAR (charset, first, 0),
281 MAKE_CHAR (charset, i - 1, 0),
284 print_chartab_range (MAKE_CHAR (charset, row, first),
285 MAKE_CHAR (charset, row, i - 1),
291 print_chartab_two_byte_charset (Lisp_Object charset,
292 struct Lisp_Char_Table_Entry *cte,
293 Lisp_Object printcharfun)
297 for (i = 32; i < 128; i++)
299 Lisp_Object jen = cte->level2[i - 32];
301 if (!CHAR_TABLE_ENTRYP (jen))
305 write_c_string (" [", printcharfun);
306 print_internal (XCHARSET_NAME (charset), printcharfun, 0);
307 sprintf (buf, " %d] ", i);
308 write_c_string (buf, printcharfun);
309 print_internal (jen, printcharfun, 0);
312 print_chartab_charset_row (charset, i, XCHAR_TABLE_ENTRY (jen),
320 print_char_table (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
322 struct Lisp_Char_Table *ct = XCHAR_TABLE (obj);
325 sprintf (buf, "#s(char-table type %s data (",
326 string_data (symbol_name (XSYMBOL
327 (char_table_type_to_symbol (ct->type)))));
328 write_c_string (buf, printcharfun);
330 /* Now write out the ASCII/Control-1 stuff. */
334 Lisp_Object val = Qunbound;
336 for (i = 0; i < NUM_ASCII_CHARS; i++)
345 if (!EQ (ct->ascii[i], val))
347 print_chartab_range (first, i - 1, val, printcharfun);
354 print_chartab_range (first, i - 1, val, printcharfun);
361 for (i = MIN_LEADING_BYTE; i < MIN_LEADING_BYTE + NUM_LEADING_BYTES;
364 Lisp_Object ann = ct->level1[i - MIN_LEADING_BYTE];
365 Lisp_Object charset = CHARSET_BY_LEADING_BYTE (i);
367 if (!CHARSETP (charset) || i == LEADING_BYTE_ASCII
368 || i == LEADING_BYTE_CONTROL_1)
370 if (!CHAR_TABLE_ENTRYP (ann))
372 write_c_string (" ", printcharfun);
373 print_internal (XCHARSET_NAME (charset),
375 write_c_string (" ", printcharfun);
376 print_internal (ann, printcharfun, 0);
380 struct Lisp_Char_Table_Entry *cte = XCHAR_TABLE_ENTRY (ann);
381 if (XCHARSET_DIMENSION (charset) == 1)
382 print_chartab_charset_row (charset, -1, cte, printcharfun);
384 print_chartab_two_byte_charset (charset, cte, printcharfun);
390 write_c_string ("))", printcharfun);
394 char_table_equal (Lisp_Object obj1, Lisp_Object obj2, int depth)
396 struct Lisp_Char_Table *ct1 = XCHAR_TABLE (obj1);
397 struct Lisp_Char_Table *ct2 = XCHAR_TABLE (obj2);
400 if (CHAR_TABLE_TYPE (ct1) != CHAR_TABLE_TYPE (ct2))
403 for (i = 0; i < NUM_ASCII_CHARS; i++)
404 if (!internal_equal (ct1->ascii[i], ct2->ascii[i], depth + 1))
408 for (i = 0; i < NUM_LEADING_BYTES; i++)
409 if (!internal_equal (ct1->level1[i], ct2->level1[i], depth + 1))
417 char_table_hash (Lisp_Object obj, int depth)
419 struct Lisp_Char_Table *ct = XCHAR_TABLE (obj);
420 unsigned long hashval = internal_array_hash (ct->ascii, NUM_ASCII_CHARS,
423 hashval = HASH2 (hashval,
424 internal_array_hash (ct->level1, NUM_LEADING_BYTES, depth));
429 static const struct lrecord_description char_table_description[] = {
430 { XD_LISP_OBJECT, offsetof(struct Lisp_Char_Table, ascii), NUM_ASCII_CHARS },
432 { XD_LISP_OBJECT, offsetof(struct Lisp_Char_Table, level1), NUM_LEADING_BYTES },
434 { XD_LISP_OBJECT, offsetof(struct Lisp_Char_Table, mirror_table), 1 },
435 { XD_LO_LINK, offsetof(struct Lisp_Char_Table, next_table) },
439 DEFINE_LRECORD_IMPLEMENTATION ("char-table", char_table,
440 mark_char_table, print_char_table, 0,
441 char_table_equal, char_table_hash,
442 char_table_description,
443 struct Lisp_Char_Table);
445 DEFUN ("char-table-p", Fchar_table_p, 1, 1, 0, /*
446 Return non-nil if OBJECT is a char table.
448 A char table is a table that maps characters (or ranges of characters)
449 to values. Char tables are specialized for characters, only allowing
450 particular sorts of ranges to be assigned values. Although this
451 loses in generality, it makes for extremely fast (constant-time)
452 lookups, and thus is feasible for applications that do an extremely
453 large number of lookups (e.g. scanning a buffer for a character in
454 a particular syntax, where a lookup in the syntax table must occur
457 When Mule support exists, the types of ranges that can be assigned
462 -- a single row in a two-octet charset
463 -- a single character
465 When Mule support is not present, the types of ranges that can be
469 -- a single character
471 To create a char table, use `make-char-table'. To modify a char
472 table, use `put-char-table' or `remove-char-table'. To retrieve the
473 value for a particular character, use `get-char-table'. See also
474 `map-char-table', `clear-char-table', `copy-char-table',
475 `valid-char-table-type-p', `char-table-type-list', `valid-char-table-value-p',
476 and `check-char-table-value'.
480 return CHAR_TABLEP (object) ? Qt : Qnil;
483 DEFUN ("char-table-type-list", Fchar_table_type_list, 0, 0, 0, /*
484 Return a list of the recognized char table types.
485 See `valid-char-table-type-p'.
490 return list5 (Qchar, Qcategory, Qdisplay, Qgeneric, Qsyntax);
492 return list4 (Qchar, Qdisplay, Qgeneric, Qsyntax);
496 DEFUN ("valid-char-table-type-p", Fvalid_char_table_type_p, 1, 1, 0, /*
497 Return t if TYPE if a recognized char table type.
499 Each char table type is used for a different purpose and allows different
500 sorts of values. The different char table types are
503 Used for category tables, which specify the regexp categories
504 that a character is in. The valid values are nil or a
505 bit vector of 95 elements. Higher-level Lisp functions are
506 provided for working with category tables. Currently categories
507 and category tables only exist when Mule support is present.
509 A generalized char table, for mapping from one character to
510 another. Used for case tables, syntax matching tables,
511 `keyboard-translate-table', etc. The valid values are characters.
513 An even more generalized char table, for mapping from a
514 character to anything.
516 Used for display tables, which specify how a particular character
517 is to appear when displayed. #### Not yet implemented.
519 Used for syntax tables, which specify the syntax of a particular
520 character. Higher-level Lisp functions are provided for
521 working with syntax tables. The valid values are integers.
526 return (EQ (type, Qchar) ||
528 EQ (type, Qcategory) ||
530 EQ (type, Qdisplay) ||
531 EQ (type, Qgeneric) ||
532 EQ (type, Qsyntax)) ? Qt : Qnil;
535 DEFUN ("char-table-type", Fchar_table_type, 1, 1, 0, /*
536 Return the type of char table TABLE.
537 See `valid-char-table-type-p'.
541 CHECK_CHAR_TABLE (table);
542 return char_table_type_to_symbol (XCHAR_TABLE (table)->type);
546 fill_char_table (struct Lisp_Char_Table *ct, Lisp_Object value)
550 for (i = 0; i < NUM_ASCII_CHARS; i++)
551 ct->ascii[i] = value;
553 for (i = 0; i < NUM_LEADING_BYTES; i++)
554 ct->level1[i] = value;
557 if (ct->type == CHAR_TABLE_TYPE_SYNTAX)
558 update_syntax_table (ct);
561 DEFUN ("reset-char-table", Freset_char_table, 1, 1, 0, /*
562 Reset a char table to its default state.
566 struct Lisp_Char_Table *ct;
568 CHECK_CHAR_TABLE (table);
569 ct = XCHAR_TABLE (table);
573 case CHAR_TABLE_TYPE_CHAR:
574 fill_char_table (ct, make_char (0));
576 case CHAR_TABLE_TYPE_DISPLAY:
577 case CHAR_TABLE_TYPE_GENERIC:
579 case CHAR_TABLE_TYPE_CATEGORY:
581 fill_char_table (ct, Qnil);
584 case CHAR_TABLE_TYPE_SYNTAX:
585 fill_char_table (ct, make_int (Sinherit));
595 DEFUN ("make-char-table", Fmake_char_table, 1, 1, 0, /*
596 Return a new, empty char table of type TYPE.
597 Currently recognized types are 'char, 'category, 'display, 'generic,
598 and 'syntax. See `valid-char-table-type-p'.
602 struct Lisp_Char_Table *ct;
604 enum char_table_type ty = symbol_to_char_table_type (type);
606 ct = alloc_lcrecord_type (struct Lisp_Char_Table, &lrecord_char_table);
608 if (ty == CHAR_TABLE_TYPE_SYNTAX)
610 ct->mirror_table = Fmake_char_table (Qgeneric);
611 fill_char_table (XCHAR_TABLE (ct->mirror_table),
615 ct->mirror_table = Qnil;
616 ct->next_table = Qnil;
617 XSETCHAR_TABLE (obj, ct);
618 if (ty == CHAR_TABLE_TYPE_SYNTAX)
620 ct->next_table = Vall_syntax_tables;
621 Vall_syntax_tables = obj;
623 Freset_char_table (obj);
630 make_char_table_entry (Lisp_Object initval)
634 struct Lisp_Char_Table_Entry *cte =
635 alloc_lcrecord_type (struct Lisp_Char_Table_Entry,
636 &lrecord_char_table_entry);
638 for (i = 0; i < 96; i++)
639 cte->level2[i] = initval;
641 XSETCHAR_TABLE_ENTRY (obj, cte);
646 copy_char_table_entry (Lisp_Object entry)
648 struct Lisp_Char_Table_Entry *cte = XCHAR_TABLE_ENTRY (entry);
651 struct Lisp_Char_Table_Entry *ctenew =
652 alloc_lcrecord_type (struct Lisp_Char_Table_Entry,
653 &lrecord_char_table_entry);
655 for (i = 0; i < 96; i++)
657 Lisp_Object new = cte->level2[i];
658 if (CHAR_TABLE_ENTRYP (new))
659 ctenew->level2[i] = copy_char_table_entry (new);
661 ctenew->level2[i] = new;
664 XSETCHAR_TABLE_ENTRY (obj, ctenew);
670 DEFUN ("copy-char-table", Fcopy_char_table, 1, 1, 0, /*
671 Make a new char table which is a copy of OLD-TABLE.
672 It will contain the same values for the same characters and ranges
673 as OLD-TABLE. The values will not themselves be copied.
677 struct Lisp_Char_Table *ct, *ctnew;
681 CHECK_CHAR_TABLE (old_table);
682 ct = XCHAR_TABLE (old_table);
683 ctnew = alloc_lcrecord_type (struct Lisp_Char_Table, &lrecord_char_table);
684 ctnew->type = ct->type;
686 for (i = 0; i < NUM_ASCII_CHARS; i++)
688 Lisp_Object new = ct->ascii[i];
690 assert (! (CHAR_TABLE_ENTRYP (new)));
692 ctnew->ascii[i] = new;
697 for (i = 0; i < NUM_LEADING_BYTES; i++)
699 Lisp_Object new = ct->level1[i];
700 if (CHAR_TABLE_ENTRYP (new))
701 ctnew->level1[i] = copy_char_table_entry (new);
703 ctnew->level1[i] = new;
708 if (CHAR_TABLEP (ct->mirror_table))
709 ctnew->mirror_table = Fcopy_char_table (ct->mirror_table);
711 ctnew->mirror_table = ct->mirror_table;
712 ctnew->next_table = Qnil;
713 XSETCHAR_TABLE (obj, ctnew);
714 if (ctnew->type == CHAR_TABLE_TYPE_SYNTAX)
716 ctnew->next_table = Vall_syntax_tables;
717 Vall_syntax_tables = obj;
723 decode_char_table_range (Lisp_Object range, struct chartab_range *outrange)
726 outrange->type = CHARTAB_RANGE_ALL;
727 else if (CHAR_OR_CHAR_INTP (range))
729 outrange->type = CHARTAB_RANGE_CHAR;
730 outrange->ch = XCHAR_OR_CHAR_INT (range);
734 signal_simple_error ("Range must be t or a character", range);
736 else if (VECTORP (range))
738 struct Lisp_Vector *vec = XVECTOR (range);
739 Lisp_Object *elts = vector_data (vec);
740 if (vector_length (vec) != 2)
741 signal_simple_error ("Length of charset row vector must be 2",
743 outrange->type = CHARTAB_RANGE_ROW;
744 outrange->charset = Fget_charset (elts[0]);
746 outrange->row = XINT (elts[1]);
747 if (XCHARSET_DIMENSION (outrange->charset) >= 2)
749 switch (XCHARSET_CHARS (outrange->charset))
752 check_int_range (outrange->row, 33, 126);
755 check_int_range (outrange->row, 32, 127);
762 signal_simple_error ("Charset in row vector must be multi-byte",
767 if (!CHARSETP (range) && !SYMBOLP (range))
769 ("Char table range must be t, charset, char, or vector", range);
770 outrange->type = CHARTAB_RANGE_CHARSET;
771 outrange->charset = Fget_charset (range);
778 /* called from CHAR_TABLE_VALUE(). */
780 get_non_ascii_char_table_value (struct Lisp_Char_Table *ct,
781 Charset_ID leading_byte, Emchar c)
787 Lisp_Object charset = CHARSET_BY_LEADING_BYTE (leading_byte);
792 BREAKUP_CHAR (c, charset, byte1, byte2);
794 BREAKUP_CHAR_1_UNSAFE (c, charset, byte1, byte2);
796 val = ct->level1[leading_byte - MIN_LEADING_BYTE];
797 if (CHAR_TABLE_ENTRYP (val))
799 struct Lisp_Char_Table_Entry *cte = XCHAR_TABLE_ENTRY (val);
800 val = cte->level2[byte1 - 32];
801 if (CHAR_TABLE_ENTRYP (val))
803 cte = XCHAR_TABLE_ENTRY (val);
804 assert (byte2 >= 32);
805 val = cte->level2[byte2 - 32];
806 assert (!CHAR_TABLE_ENTRYP (val));
816 get_char_table (Emchar ch, struct Lisp_Char_Table *ct)
824 BREAKUP_CHAR (ch, charset, byte1, byte2);
826 if (EQ (charset, Vcharset_ascii))
827 val = ct->ascii[byte1];
828 else if (EQ (charset, Vcharset_control_1))
829 val = ct->ascii[byte1 + 128];
832 int lb = XCHARSET_LEADING_BYTE (charset) - MIN_LEADING_BYTE;
833 val = ct->level1[lb];
834 if (CHAR_TABLE_ENTRYP (val))
836 struct Lisp_Char_Table_Entry *cte = XCHAR_TABLE_ENTRY (val);
837 val = cte->level2[byte1 - 32];
838 if (CHAR_TABLE_ENTRYP (val))
840 cte = XCHAR_TABLE_ENTRY (val);
841 assert (byte2 >= 32);
842 val = cte->level2[byte2 - 32];
843 assert (!CHAR_TABLE_ENTRYP (val));
851 return ct->ascii[(unsigned char)ch];
852 #endif /* not MULE */
856 DEFUN ("get-char-table", Fget_char_table, 2, 2, 0, /*
857 Find value for char CH in TABLE.
861 struct Lisp_Char_Table *ct;
863 CHECK_CHAR_TABLE (table);
864 ct = XCHAR_TABLE (table);
865 CHECK_CHAR_COERCE_INT (ch);
867 return get_char_table (XCHAR (ch), ct);
870 DEFUN ("get-range-char-table", Fget_range_char_table, 2, 3, 0, /*
871 Find value for a range in TABLE.
872 If there is more than one value, return MULTI (defaults to nil).
874 (range, table, multi))
876 struct Lisp_Char_Table *ct;
877 struct chartab_range rainj;
879 if (CHAR_OR_CHAR_INTP (range))
880 return Fget_char_table (range, table);
881 CHECK_CHAR_TABLE (table);
882 ct = XCHAR_TABLE (table);
884 decode_char_table_range (range, &rainj);
887 case CHARTAB_RANGE_ALL:
890 Lisp_Object first = ct->ascii[0];
892 for (i = 1; i < NUM_ASCII_CHARS; i++)
893 if (!EQ (first, ct->ascii[i]))
897 for (i = MIN_LEADING_BYTE; i < MIN_LEADING_BYTE + NUM_LEADING_BYTES;
900 if (!CHARSETP (CHARSET_BY_LEADING_BYTE (i))
901 || i == LEADING_BYTE_ASCII
902 || i == LEADING_BYTE_CONTROL_1)
904 if (!EQ (first, ct->level1[i - MIN_LEADING_BYTE]))
913 case CHARTAB_RANGE_CHARSET:
914 if (EQ (rainj.charset, Vcharset_ascii))
917 Lisp_Object first = ct->ascii[0];
919 for (i = 1; i < 128; i++)
920 if (!EQ (first, ct->ascii[i]))
925 if (EQ (rainj.charset, Vcharset_control_1))
928 Lisp_Object first = ct->ascii[128];
930 for (i = 129; i < 160; i++)
931 if (!EQ (first, ct->ascii[i]))
937 Lisp_Object val = ct->level1[XCHARSET_LEADING_BYTE (rainj.charset) -
939 if (CHAR_TABLE_ENTRYP (val))
944 case CHARTAB_RANGE_ROW:
946 Lisp_Object val = ct->level1[XCHARSET_LEADING_BYTE (rainj.charset) -
948 if (!CHAR_TABLE_ENTRYP (val))
950 val = XCHAR_TABLE_ENTRY (val)->level2[rainj.row - 32];
951 if (CHAR_TABLE_ENTRYP (val))
955 #endif /* not MULE */
961 return Qnil; /* not reached */
965 check_valid_char_table_value (Lisp_Object value, enum char_table_type type,
970 case CHAR_TABLE_TYPE_SYNTAX:
971 if (!ERRB_EQ (errb, ERROR_ME))
972 return INTP (value) || (CONSP (value) && INTP (XCAR (value))
973 && CHAR_OR_CHAR_INTP (XCDR (value)));
976 Lisp_Object cdr = XCDR (value);
977 CHECK_INT (XCAR (value));
978 CHECK_CHAR_COERCE_INT (cdr);
985 case CHAR_TABLE_TYPE_CATEGORY:
986 if (!ERRB_EQ (errb, ERROR_ME))
987 return CATEGORY_TABLE_VALUEP (value);
988 CHECK_CATEGORY_TABLE_VALUE (value);
992 case CHAR_TABLE_TYPE_GENERIC:
995 case CHAR_TABLE_TYPE_DISPLAY:
997 maybe_signal_simple_error ("Display char tables not yet implemented",
998 value, Qchar_table, errb);
1001 case CHAR_TABLE_TYPE_CHAR:
1002 if (!ERRB_EQ (errb, ERROR_ME))
1003 return CHAR_OR_CHAR_INTP (value);
1004 CHECK_CHAR_COERCE_INT (value);
1011 return 0; /* not reached */
1015 canonicalize_char_table_value (Lisp_Object value, enum char_table_type type)
1019 case CHAR_TABLE_TYPE_SYNTAX:
1022 Lisp_Object car = XCAR (value);
1023 Lisp_Object cdr = XCDR (value);
1024 CHECK_CHAR_COERCE_INT (cdr);
1025 return Fcons (car, cdr);
1028 case CHAR_TABLE_TYPE_CHAR:
1029 CHECK_CHAR_COERCE_INT (value);
1037 DEFUN ("valid-char-table-value-p", Fvalid_char_table_value_p, 2, 2, 0, /*
1038 Return non-nil if VALUE is a valid value for CHAR-TABLE-TYPE.
1040 (value, char_table_type))
1042 enum char_table_type type = symbol_to_char_table_type (char_table_type);
1044 return check_valid_char_table_value (value, type, ERROR_ME_NOT) ? Qt : Qnil;
1047 DEFUN ("check-valid-char-table-value", Fcheck_valid_char_table_value, 2, 2, 0, /*
1048 Signal an error if VALUE is not a valid value for CHAR-TABLE-TYPE.
1050 (value, char_table_type))
1052 enum char_table_type type = symbol_to_char_table_type (char_table_type);
1054 check_valid_char_table_value (value, type, ERROR_ME);
1058 /* Assign VAL to all characters in RANGE in char table CT. */
1061 put_char_table (struct Lisp_Char_Table *ct, struct chartab_range *range,
1064 switch (range->type)
1066 case CHARTAB_RANGE_ALL:
1067 fill_char_table (ct, val);
1068 return; /* avoid the duplicate call to update_syntax_table() below,
1069 since fill_char_table() also did that. */
1072 case CHARTAB_RANGE_CHARSET:
1073 if (EQ (range->charset, Vcharset_ascii))
1076 for (i = 0; i < 128; i++)
1079 else if (EQ (range->charset, Vcharset_control_1))
1082 for (i = 128; i < 160; i++)
1087 int lb = XCHARSET_LEADING_BYTE (range->charset) - MIN_LEADING_BYTE;
1088 ct->level1[lb] = val;
1092 case CHARTAB_RANGE_ROW:
1094 struct Lisp_Char_Table_Entry *cte;
1095 int lb = XCHARSET_LEADING_BYTE (range->charset) - MIN_LEADING_BYTE;
1096 /* make sure that there is a separate entry for the row. */
1097 if (!CHAR_TABLE_ENTRYP (ct->level1[lb]))
1098 ct->level1[lb] = make_char_table_entry (ct->level1[lb]);
1099 cte = XCHAR_TABLE_ENTRY (ct->level1[lb]);
1100 cte->level2[range->row - 32] = val;
1105 case CHARTAB_RANGE_CHAR:
1108 Lisp_Object charset;
1111 BREAKUP_CHAR (range->ch, charset, byte1, byte2);
1112 if (EQ (charset, Vcharset_ascii))
1113 ct->ascii[byte1] = val;
1114 else if (EQ (charset, Vcharset_control_1))
1115 ct->ascii[byte1 + 128] = val;
1118 struct Lisp_Char_Table_Entry *cte;
1119 int lb = XCHARSET_LEADING_BYTE (charset) - MIN_LEADING_BYTE;
1120 /* make sure that there is a separate entry for the row. */
1121 if (!CHAR_TABLE_ENTRYP (ct->level1[lb]))
1122 ct->level1[lb] = make_char_table_entry (ct->level1[lb]);
1123 cte = XCHAR_TABLE_ENTRY (ct->level1[lb]);
1124 /* now CTE is a char table entry for the charset;
1125 each entry is for a single row (or character of
1126 a one-octet charset). */
1127 if (XCHARSET_DIMENSION (charset) == 1)
1128 cte->level2[byte1 - 32] = val;
1131 /* assigning to one character in a two-octet charset. */
1132 /* make sure that the charset row contains a separate
1133 entry for each character. */
1134 if (!CHAR_TABLE_ENTRYP (cte->level2[byte1 - 32]))
1135 cte->level2[byte1 - 32] =
1136 make_char_table_entry (cte->level2[byte1 - 32]);
1137 cte = XCHAR_TABLE_ENTRY (cte->level2[byte1 - 32]);
1138 cte->level2[byte2 - 32] = val;
1142 #else /* not MULE */
1143 ct->ascii[(unsigned char) (range->ch)] = val;
1145 #endif /* not MULE */
1148 if (ct->type == CHAR_TABLE_TYPE_SYNTAX)
1149 update_syntax_table (ct);
1152 DEFUN ("put-char-table", Fput_char_table, 3, 3, 0, /*
1153 Set the value for chars in RANGE to be VAL in TABLE.
1155 RANGE specifies one or more characters to be affected and should be
1156 one of the following:
1158 -- t (all characters are affected)
1159 -- A charset (only allowed when Mule support is present)
1160 -- A vector of two elements: a two-octet charset and a row number
1161 (only allowed when Mule support is present)
1162 -- A single character
1164 VAL must be a value appropriate for the type of TABLE.
1165 See `valid-char-table-type-p'.
1167 (range, val, table))
1169 struct Lisp_Char_Table *ct;
1170 struct chartab_range rainj;
1172 CHECK_CHAR_TABLE (table);
1173 ct = XCHAR_TABLE (table);
1174 check_valid_char_table_value (val, ct->type, ERROR_ME);
1175 decode_char_table_range (range, &rainj);
1176 val = canonicalize_char_table_value (val, ct->type);
1177 put_char_table (ct, &rainj, val);
1181 /* Map FN over the ASCII chars in CT. */
1184 map_over_charset_ascii (struct Lisp_Char_Table *ct,
1185 int (*fn) (struct chartab_range *range,
1186 Lisp_Object val, void *arg),
1189 struct chartab_range rainj;
1198 rainj.type = CHARTAB_RANGE_CHAR;
1200 for (i = start, retval = 0; i < stop && retval == 0; i++)
1202 rainj.ch = (Emchar) i;
1203 retval = (fn) (&rainj, ct->ascii[i], arg);
1211 /* Map FN over the Control-1 chars in CT. */
1214 map_over_charset_control_1 (struct Lisp_Char_Table *ct,
1215 int (*fn) (struct chartab_range *range,
1216 Lisp_Object val, void *arg),
1219 struct chartab_range rainj;
1222 int stop = start + 32;
1224 rainj.type = CHARTAB_RANGE_CHAR;
1226 for (i = start, retval = 0; i < stop && retval == 0; i++)
1228 rainj.ch = (Emchar) (i);
1229 retval = (fn) (&rainj, ct->ascii[i], arg);
1235 /* Map FN over the row ROW of two-byte charset CHARSET.
1236 There must be a separate value for that row in the char table.
1237 CTE specifies the char table entry for CHARSET. */
1240 map_over_charset_row (struct Lisp_Char_Table_Entry *cte,
1241 Lisp_Object charset, int row,
1242 int (*fn) (struct chartab_range *range,
1243 Lisp_Object val, void *arg),
1246 Lisp_Object val = cte->level2[row - 32];
1248 if (!CHAR_TABLE_ENTRYP (val))
1250 struct chartab_range rainj;
1252 rainj.type = CHARTAB_RANGE_ROW;
1253 rainj.charset = charset;
1255 return (fn) (&rainj, val, arg);
1259 struct chartab_range rainj;
1261 int charset94_p = (XCHARSET_CHARS (charset) == 94);
1262 int start = charset94_p ? 33 : 32;
1263 int stop = charset94_p ? 127 : 128;
1265 cte = XCHAR_TABLE_ENTRY (val);
1267 rainj.type = CHARTAB_RANGE_CHAR;
1269 for (i = start, retval = 0; i < stop && retval == 0; i++)
1271 rainj.ch = MAKE_CHAR (charset, row, i);
1272 retval = (fn) (&rainj, cte->level2[i - 32], arg);
1280 map_over_other_charset (struct Lisp_Char_Table *ct, Charset_ID lb,
1281 int (*fn) (struct chartab_range *range,
1282 Lisp_Object val, void *arg),
1285 Lisp_Object val = ct->level1[lb - MIN_LEADING_BYTE];
1286 Lisp_Object charset = CHARSET_BY_LEADING_BYTE (lb);
1288 if (!CHARSETP (charset)
1289 || lb == LEADING_BYTE_ASCII
1290 || lb == LEADING_BYTE_CONTROL_1)
1293 if (!CHAR_TABLE_ENTRYP (val))
1295 struct chartab_range rainj;
1297 rainj.type = CHARTAB_RANGE_CHARSET;
1298 rainj.charset = charset;
1299 return (fn) (&rainj, val, arg);
1303 struct Lisp_Char_Table_Entry *cte = XCHAR_TABLE_ENTRY (val);
1304 int charset94_p = (XCHARSET_CHARS (charset) == 94);
1305 int start = charset94_p ? 33 : 32;
1306 int stop = charset94_p ? 127 : 128;
1309 if (XCHARSET_DIMENSION (charset) == 1)
1311 struct chartab_range rainj;
1312 rainj.type = CHARTAB_RANGE_CHAR;
1314 for (i = start, retval = 0; i < stop && retval == 0; i++)
1316 rainj.ch = MAKE_CHAR (charset, i, 0);
1317 retval = (fn) (&rainj, cte->level2[i - 32], arg);
1322 for (i = start, retval = 0; i < stop && retval == 0; i++)
1323 retval = map_over_charset_row (cte, charset, i, fn, arg);
1332 /* Map FN (with client data ARG) over range RANGE in char table CT.
1333 Mapping stops the first time FN returns non-zero, and that value
1334 becomes the return value of map_char_table(). */
1337 map_char_table (struct Lisp_Char_Table *ct,
1338 struct chartab_range *range,
1339 int (*fn) (struct chartab_range *range,
1340 Lisp_Object val, void *arg),
1343 switch (range->type)
1345 case CHARTAB_RANGE_ALL:
1349 retval = map_over_charset_ascii (ct, fn, arg);
1353 retval = map_over_charset_control_1 (ct, fn, arg);
1358 Charset_ID start = MIN_LEADING_BYTE;
1359 Charset_ID stop = start + NUM_LEADING_BYTES;
1361 for (i = start, retval = 0; i < stop && retval == 0; i++)
1363 retval = map_over_other_charset (ct, i, fn, arg);
1371 case CHARTAB_RANGE_CHARSET:
1372 return map_over_other_charset (ct,
1373 XCHARSET_LEADING_BYTE (range->charset),
1376 case CHARTAB_RANGE_ROW:
1378 Lisp_Object val = ct->level1[XCHARSET_LEADING_BYTE (range->charset)
1379 - MIN_LEADING_BYTE];
1380 if (!CHAR_TABLE_ENTRYP (val))
1382 struct chartab_range rainj;
1384 rainj.type = CHARTAB_RANGE_ROW;
1385 rainj.charset = range->charset;
1386 rainj.row = range->row;
1387 return (fn) (&rainj, val, arg);
1390 return map_over_charset_row (XCHAR_TABLE_ENTRY (val),
1391 range->charset, range->row,
1396 case CHARTAB_RANGE_CHAR:
1398 Emchar ch = range->ch;
1399 Lisp_Object val = CHAR_TABLE_VALUE_UNSAFE (ct, ch);
1400 struct chartab_range rainj;
1402 rainj.type = CHARTAB_RANGE_CHAR;
1404 return (fn) (&rainj, val, arg);
1414 struct slow_map_char_table_arg
1416 Lisp_Object function;
1421 slow_map_char_table_fun (struct chartab_range *range,
1422 Lisp_Object val, void *arg)
1424 Lisp_Object ranjarg = Qnil;
1425 struct slow_map_char_table_arg *closure =
1426 (struct slow_map_char_table_arg *) arg;
1428 switch (range->type)
1430 case CHARTAB_RANGE_ALL:
1435 case CHARTAB_RANGE_CHARSET:
1436 ranjarg = XCHARSET_NAME (range->charset);
1439 case CHARTAB_RANGE_ROW:
1440 ranjarg = vector2 (XCHARSET_NAME (range->charset),
1441 make_int (range->row));
1444 case CHARTAB_RANGE_CHAR:
1445 ranjarg = make_char (range->ch);
1451 closure->retval = call2 (closure->function, ranjarg, val);
1452 return !NILP (closure->retval);
1455 DEFUN ("map-char-table", Fmap_char_table, 2, 3, 0, /*
1456 Map FUNCTION over entries in TABLE, calling it with two args,
1457 each key and value in the table.
1459 RANGE specifies a subrange to map over and is in the same format as
1460 the RANGE argument to `put-range-table'. If omitted or t, it defaults to
1463 (function, table, range))
1465 struct Lisp_Char_Table *ct;
1466 struct slow_map_char_table_arg slarg;
1467 struct gcpro gcpro1, gcpro2;
1468 struct chartab_range rainj;
1470 CHECK_CHAR_TABLE (table);
1471 ct = XCHAR_TABLE (table);
1474 decode_char_table_range (range, &rainj);
1475 slarg.function = function;
1476 slarg.retval = Qnil;
1477 GCPRO2 (slarg.function, slarg.retval);
1478 map_char_table (ct, &rainj, slow_map_char_table_fun, &slarg);
1481 return slarg.retval;
1486 /************************************************************************/
1487 /* Char table read syntax */
1488 /************************************************************************/
1491 chartab_type_validate (Lisp_Object keyword, Lisp_Object value,
1492 Error_behavior errb)
1494 /* #### should deal with ERRB */
1495 symbol_to_char_table_type (value);
1500 chartab_data_validate (Lisp_Object keyword, Lisp_Object value,
1501 Error_behavior errb)
1505 /* #### should deal with ERRB */
1506 EXTERNAL_LIST_LOOP (rest, value)
1508 Lisp_Object range = XCAR (rest);
1509 struct chartab_range dummy;
1513 signal_simple_error ("Invalid list format", value);
1516 if (!CONSP (XCDR (range))
1517 || !NILP (XCDR (XCDR (range))))
1518 signal_simple_error ("Invalid range format", range);
1519 decode_char_table_range (XCAR (range), &dummy);
1520 decode_char_table_range (XCAR (XCDR (range)), &dummy);
1523 decode_char_table_range (range, &dummy);
1530 chartab_instantiate (Lisp_Object data)
1532 Lisp_Object chartab;
1533 Lisp_Object type = Qgeneric;
1534 Lisp_Object dataval = Qnil;
1536 while (!NILP (data))
1538 Lisp_Object keyw = Fcar (data);
1544 if (EQ (keyw, Qtype))
1546 else if (EQ (keyw, Qdata))
1550 chartab = Fmake_char_table (type);
1553 while (!NILP (data))
1555 Lisp_Object range = Fcar (data);
1556 Lisp_Object val = Fcar (Fcdr (data));
1558 data = Fcdr (Fcdr (data));
1561 if (CHAR_OR_CHAR_INTP (XCAR (range)))
1563 Emchar first = XCHAR_OR_CHAR_INT (Fcar (range));
1564 Emchar last = XCHAR_OR_CHAR_INT (Fcar (Fcdr (range)));
1567 for (i = first; i <= last; i++)
1568 Fput_char_table (make_char (i), val, chartab);
1574 Fput_char_table (range, val, chartab);
1583 /************************************************************************/
1584 /* Category Tables, specifically */
1585 /************************************************************************/
1587 DEFUN ("category-table-p", Fcategory_table_p, 1, 1, 0, /*
1588 Return t if ARG is a category table.
1589 A category table is a type of char table used for keeping track of
1590 categories. Categories are used for classifying characters for use
1591 in regexps -- you can refer to a category rather than having to use
1592 a complicated [] expression (and category lookups are significantly
1595 There are 95 different categories available, one for each printable
1596 character (including space) in the ASCII charset. Each category
1597 is designated by one such character, called a "category designator".
1598 They are specified in a regexp using the syntax "\\cX", where X is
1599 a category designator.
1601 A category table specifies, for each character, the categories that
1602 the character is in. Note that a character can be in more than one
1603 category. More specifically, a category table maps from a character
1604 to either the value nil (meaning the character is in no categories)
1605 or a 95-element bit vector, specifying for each of the 95 categories
1606 whether the character is in that category.
1608 Special Lisp functions are provided that abstract this, so you do not
1609 have to directly manipulate bit vectors.
1613 return (CHAR_TABLEP (obj) &&
1614 XCHAR_TABLE_TYPE (obj) == CHAR_TABLE_TYPE_CATEGORY) ?
1619 check_category_table (Lisp_Object obj, Lisp_Object def)
1623 while (NILP (Fcategory_table_p (obj)))
1624 obj = wrong_type_argument (Qcategory_table_p, obj);
1629 check_category_char (Emchar ch, Lisp_Object table,
1630 unsigned int designator, unsigned int not)
1632 REGISTER Lisp_Object temp;
1633 struct Lisp_Char_Table *ctbl;
1634 #ifdef ERROR_CHECK_TYPECHECK
1635 if (NILP (Fcategory_table_p (table)))
1636 signal_simple_error ("Expected category table", table);
1638 ctbl = XCHAR_TABLE (table);
1639 temp = get_char_table (ch, ctbl);
1644 return bit_vector_bit (XBIT_VECTOR (temp), designator) ? !not : not;
1647 DEFUN ("check-category-at", Fcheck_category_at, 2, 4, 0, /*
1648 Return t if category of a character at POS includes DESIGNATOR,
1649 else return nil. Optional third arg specifies which buffer
1650 \(defaulting to current), and fourth specifies the CATEGORY-TABLE,
1651 \(defaulting to the buffer's category table).
1653 (pos, designator, buffer, category_table))
1658 struct buffer *buf = decode_buffer (buffer, 0);
1661 CHECK_CATEGORY_DESIGNATOR (designator);
1662 des = XCHAR (designator);
1663 ctbl = check_category_table (category_table, Vstandard_category_table);
1664 ch = BUF_FETCH_CHAR (buf, XINT (pos));
1665 return check_category_char (ch, ctbl, des, 0) ? Qt : Qnil;
1668 DEFUN ("char-in-category-p", Fchar_in_category_p, 2, 3, 0, /*
1669 Return t if category of character CHR includes DESIGNATOR, else nil.
1670 Optional third arg specifies the CATEGORY-TABLE to use,
1671 which defaults to the system default table.
1673 (chr, designator, category_table))
1679 CHECK_CATEGORY_DESIGNATOR (designator);
1680 des = XCHAR (designator);
1683 ctbl = check_category_table (category_table, Vstandard_category_table);
1684 return check_category_char (ch, ctbl, des, 0) ? Qt : Qnil;
1687 DEFUN ("category-table", Fcategory_table, 0, 1, 0, /*
1688 Return the current category table.
1689 This is the one specified by the current buffer, or by BUFFER if it
1694 return decode_buffer (buffer, 0)->category_table;
1697 DEFUN ("standard-category-table", Fstandard_category_table, 0, 0, 0, /*
1698 Return the standard category table.
1699 This is the one used for new buffers.
1703 return Vstandard_category_table;
1706 DEFUN ("copy-category-table", Fcopy_category_table, 0, 1, 0, /*
1707 Construct a new category table and return it.
1708 It is a copy of the TABLE, which defaults to the standard category table.
1712 if (NILP (Vstandard_category_table))
1713 return Fmake_char_table (Qcategory);
1715 table = check_category_table (table, Vstandard_category_table);
1716 return Fcopy_char_table (table);
1719 DEFUN ("set-category-table", Fset_category_table, 1, 2, 0, /*
1720 Select a new category table for BUFFER.
1721 One argument, a category table.
1722 BUFFER defaults to the current buffer if omitted.
1726 struct buffer *buf = decode_buffer (buffer, 0);
1727 table = check_category_table (table, Qnil);
1728 buf->category_table = table;
1729 /* Indicate that this buffer now has a specified category table. */
1730 buf->local_var_flags |= XINT (buffer_local_flags.category_table);
1734 DEFUN ("category-designator-p", Fcategory_designator_p, 1, 1, 0, /*
1735 Return t if ARG is a category designator (a char in the range ' ' to '~').
1739 return CATEGORY_DESIGNATORP (obj) ? Qt : Qnil;
1742 DEFUN ("category-table-value-p", Fcategory_table_value_p, 1, 1, 0, /*
1743 Return t if ARG is a category table value.
1744 Valid values are nil or a bit vector of size 95.
1748 return CATEGORY_TABLE_VALUEP (obj) ? Qt : Qnil;
1752 #define CATEGORYP(x) \
1753 (CHARP (x) && XCHAR (x) >= 0x20 && XCHAR (x) <= 0x7E)
1755 #define CATEGORY_SET(c) \
1756 (get_char_table(c, XCHAR_TABLE(current_buffer->category_table)))
1758 /* Return 1 if CATEGORY_SET contains CATEGORY, else return 0.
1759 The faster version of `!NILP (Faref (category_set, category))'. */
1760 #define CATEGORY_MEMBER(category, category_set) \
1761 (bit_vector_bit(XBIT_VECTOR (category_set), category - 32))
1763 /* Return 1 if there is a word boundary between two word-constituent
1764 characters C1 and C2 if they appear in this order, else return 0.
1765 Use the macro WORD_BOUNDARY_P instead of calling this function
1768 int word_boundary_p (Emchar c1, Emchar c2);
1770 word_boundary_p (Emchar c1, Emchar c2)
1772 Lisp_Object category_set1, category_set2;
1777 if (COMPOSITE_CHAR_P (c1))
1778 c1 = cmpchar_component (c1, 0, 1);
1779 if (COMPOSITE_CHAR_P (c2))
1780 c2 = cmpchar_component (c2, 0, 1);
1783 if (EQ (CHAR_CHARSET (c1), CHAR_CHARSET (c2)))
1785 tail = Vword_separating_categories;
1790 tail = Vword_combining_categories;
1794 category_set1 = CATEGORY_SET (c1);
1795 if (NILP (category_set1))
1796 return default_result;
1797 category_set2 = CATEGORY_SET (c2);
1798 if (NILP (category_set2))
1799 return default_result;
1801 for (; CONSP (tail); tail = XCONS (tail)->cdr)
1803 Lisp_Object elt = XCONS(tail)->car;
1806 && CATEGORYP (XCONS (elt)->car)
1807 && CATEGORYP (XCONS (elt)->cdr)
1808 && CATEGORY_MEMBER (XCHAR (XCONS (elt)->car), category_set1)
1809 && CATEGORY_MEMBER (XCHAR (XCONS (elt)->cdr), category_set2))
1810 return !default_result;
1812 return default_result;
1818 syms_of_chartab (void)
1821 defsymbol (&Qcategory_table_p, "category-table-p");
1822 defsymbol (&Qcategory_designator_p, "category-designator-p");
1823 defsymbol (&Qcategory_table_value_p, "category-table-value-p");
1826 defsymbol (&Qchar_table, "char-table");
1827 defsymbol (&Qchar_tablep, "char-table-p");
1829 DEFSUBR (Fchar_table_p);
1830 DEFSUBR (Fchar_table_type_list);
1831 DEFSUBR (Fvalid_char_table_type_p);
1832 DEFSUBR (Fchar_table_type);
1833 DEFSUBR (Freset_char_table);
1834 DEFSUBR (Fmake_char_table);
1835 DEFSUBR (Fcopy_char_table);
1836 DEFSUBR (Fget_char_table);
1837 DEFSUBR (Fget_range_char_table);
1838 DEFSUBR (Fvalid_char_table_value_p);
1839 DEFSUBR (Fcheck_valid_char_table_value);
1840 DEFSUBR (Fput_char_table);
1841 DEFSUBR (Fmap_char_table);
1844 DEFSUBR (Fcategory_table_p);
1845 DEFSUBR (Fcategory_table);
1846 DEFSUBR (Fstandard_category_table);
1847 DEFSUBR (Fcopy_category_table);
1848 DEFSUBR (Fset_category_table);
1849 DEFSUBR (Fcheck_category_at);
1850 DEFSUBR (Fchar_in_category_p);
1851 DEFSUBR (Fcategory_designator_p);
1852 DEFSUBR (Fcategory_table_value_p);
1858 vars_of_chartab (void)
1860 /* DO NOT staticpro this. It works just like Vweak_hash_tables. */
1861 Vall_syntax_tables = Qnil;
1862 pdump_wire_list (&Vall_syntax_tables);
1866 structure_type_create_chartab (void)
1868 struct structure_type *st;
1870 st = define_structure_type (Qchar_table, 0, chartab_instantiate);
1872 define_structure_type_keyword (st, Qtype, chartab_type_validate);
1873 define_structure_type_keyword (st, Qdata, chartab_data_validate);
1877 complex_vars_of_chartab (void)
1880 /* Set this now, so first buffer creation can refer to it. */
1881 /* Make it nil before calling copy-category-table
1882 so that copy-category-table will know not to try to copy from garbage */
1883 Vstandard_category_table = Qnil;
1884 Vstandard_category_table = Fcopy_category_table (Qnil);
1885 staticpro (&Vstandard_category_table);
1887 DEFVAR_LISP ("word-combining-categories", &Vword_combining_categories /*
1888 List of pair (cons) of categories to determine word boundary.
1890 Emacs treats a sequence of word constituent characters as a single
1891 word (i.e. finds no word boundary between them) iff they belongs to
1892 the same charset. But, exceptions are allowed in the following cases.
1894 (1) The case that characters are in different charsets is controlled
1895 by the variable `word-combining-categories'.
1897 Emacs finds no word boundary between characters of different charsets
1898 if they have categories matching some element of this list.
1900 More precisely, if an element of this list is a cons of category CAT1
1901 and CAT2, and a multibyte character C1 which has CAT1 is followed by
1902 C2 which has CAT2, there's no word boundary between C1 and C2.
1904 For instance, to tell that ASCII characters and Latin-1 characters can
1905 form a single word, the element `(?l . ?l)' should be in this list
1906 because both characters have the category `l' (Latin characters).
1908 (2) The case that character are in the same charset is controlled by
1909 the variable `word-separating-categories'.
1911 Emacs find a word boundary between characters of the same charset
1912 if they have categories matching some element of this list.
1914 More precisely, if an element of this list is a cons of category CAT1
1915 and CAT2, and a multibyte character C1 which has CAT1 is followed by
1916 C2 which has CAT2, there's a word boundary between C1 and C2.
1918 For instance, to tell that there's a word boundary between Japanese
1919 Hiragana and Japanese Kanji (both are in the same charset), the
1920 element `(?H . ?C) should be in this list.
1923 Vword_combining_categories = Qnil;
1925 DEFVAR_LISP ("word-separating-categories", &Vword_separating_categories /*
1926 List of pair (cons) of categories to determine word boundary.
1927 See the documentation of the variable `word-combining-categories'.
1930 Vword_separating_categories = Qnil;