/* GNU Emacs routines to deal with category tables.
- Ver.1.0
- Copyright (C) 1995 Free Software Foundation, Inc.
- Copyright (C) 1995 Electrotechnical Laboratory, JAPAN.
+ Copyright (C) 1995, 1997 Electrotechnical Laboratory, JAPAN.
+ Licensed to the Free Software Foundation.
This file is part of GNU Emacs.
#include "buffer.h"
#include "charset.h"
#include "category.h"
+#include "keymap.h"
/* The version number of the latest category table. Each category
table has a unique version number. It is assigned a new number
/* Category set staff. */
DEFUN ("make-category-set", Fmake_category_set, Smake_category_set, 1, 1, 0,
- "Return a newly created category-set which contains CATEGORIES.\n\
-CATEGORIES is a string of category mnemonics.")
- (categories)
+ doc: /* Return a newly created category-set which contains CATEGORIES.
+CATEGORIES is a string of category mnemonics.
+The value is a bool-vector which has t at the indices corresponding to
+those categories. */)
+ (categories)
Lisp_Object categories;
{
Lisp_Object val;
int len;
- CHECK_STRING (categories, 0);
+ CHECK_STRING (categories);
val = MAKE_CATEGORY_SET;
- len = XSTRING (categories)->size;
+ if (STRING_MULTIBYTE (categories))
+ error ("Multibyte string in make-category-set");
+
+ len = SCHARS (categories);
while (--len >= 0)
{
- Lisp_Object category = make_number (XSTRING (categories)->data[len]);
+ Lisp_Object category;
- CHECK_CATEGORY (category, 0);
+ XSETFASTINT (category, SREF (categories, len));
+ CHECK_CATEGORY (category);
SET_CATEGORY_SET (val, category, Qt);
}
return val;
Lisp_Object check_category_table ();
DEFUN ("define-category", Fdefine_category, Sdefine_category, 2, 3, 0,
- "Define CHAR as a category which is described by DOCSTRING.\n\
-CHAR should be a visible letter of ` ' thru `~'.\n\
-DOCSTRING is a documentation string of the category.\n\
-The category is defined only in category table TABLE, which defaults to\n\
- the current buffer's category table.")
- (category, docstring, table)
+ doc: /* Define CHAR as a category which is described by DOCSTRING.
+CHAR should be an ASCII printing character in the range ` ' to `~'.
+DOCSTRING is a documentation string of the category.
+The category is defined only in category table TABLE, which defaults to
+ the current buffer's category table. */)
+ (category, docstring, table)
Lisp_Object category, docstring, table;
{
- CHECK_CATEGORY (category, 0);
- CHECK_STRING (docstring, 1);
+ CHECK_CATEGORY (category);
+ CHECK_STRING (docstring);
table = check_category_table (table);
if (!NILP (CATEGORY_DOCSTRING (table, XFASTINT (category))))
}
DEFUN ("category-docstring", Fcategory_docstring, Scategory_docstring, 1, 2, 0,
- "Return a documentation string of CATEGORY.\n\
-Optional second arg specifies CATEGORY-TABLE,\n\
- which defaults to the current buffer's category table.")
- (category, table)
+ doc: /* Return the documentation string of CATEGORY, as defined in CATEGORY-TABLE. */)
+ (category, table)
Lisp_Object category, table;
{
- Lisp_Object doc;
-
- CHECK_CATEGORY (category, 0);
+ CHECK_CATEGORY (category);
table = check_category_table (table);
return CATEGORY_DOCSTRING (table, XFASTINT (category));
DEFUN ("get-unused-category", Fget_unused_category, Sget_unused_category,
0, 1, 0,
- "Return a category which is not yet defined.\n\
-If total number of categories has reached the limit (95), return nil.\n\
-Optional argument specifies CATEGORY-TABLE,\n\
- which defaults to the current buffer's category table.")
- (table)
+ doc: /* Return a category which is not yet defined in CATEGORY-TABLE.
+If no category remains available, return nil.
+The optional argument CATEGORY-TABLE
+specifies which category table to modify;
+it defaults to the current buffer's category table. */)
+ (table)
Lisp_Object table;
{
int i;
- Lisp_Object docstring_vector;
table = check_category_table (table);
/* Category-table staff. */
DEFUN ("category-table-p", Fcategory_table_p, Scategory_table_p, 1, 1, 0,
- "Return t if ARG is a category table.")
- (arg)
+ doc: /* Return t if ARG is a category table. */)
+ (arg)
Lisp_Object arg;
{
if (CHAR_TABLE_P (arg)
- && EQ (XCHAR_TABLE (arg)->purpose, Qcategory_table)
- && CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (arg)) == 2)
+ && EQ (XCHAR_TABLE (arg)->purpose, Qcategory_table))
return Qt;
return Qnil;
}
while (tem = Fcategory_table_p (table), NILP (tem))
table = wrong_type_argument (Qcategory_table_p, table);
return table;
-}
+}
DEFUN ("category-table", Fcategory_table, Scategory_table, 0, 0, 0,
- "Return the current category table.\n\
-This is the one specified by the current buffer.")
- ()
+ doc: /* Return the current category table.
+This is the one specified by the current buffer. */)
+ ()
{
return current_buffer->category_table;
}
DEFUN ("standard-category-table", Fstandard_category_table,
Sstandard_category_table, 0, 0, 0,
- "Return the standard category table.\n\
-This is the one used for new buffers.")
- ()
+ doc: /* Return the standard category table.
+This is the one used for new buffers. */)
+ ()
{
return Vstandard_category_table;
}
/* Return a copy of category table TABLE. We can't simply use the
function copy-sequence because no contents should be shared between
- the original and the copy.
-
- If TOP is 1, we at first copy the tree structure of the table. */
+ the original and the copy. This function is called recursively by
+ binding TABLE to a sub char table. */
Lisp_Object
-copy_category_table (table, top)
+copy_category_table (table)
Lisp_Object table;
{
- int i;
+ Lisp_Object tmp;
+ int i, to;
- if (top)
- table = Fcopy_sequence (table);
- else if (!NILP (XCHAR_TABLE (table)->defalt))
- XCHAR_TABLE (table)->defalt
- = Fcopy_sequence (XCHAR_TABLE (table)->defalt);
-
- for (i = 0; i < CHAR_TABLE_ORDINARY_SLOTS; i++)
+ if (!NILP (XCHAR_TABLE (table)->top))
+ {
+ /* TABLE is a top level char table.
+ At first, make a copy of tree structure of the table. */
+ table = Fcopy_sequence (table);
+
+ /* Then, copy elements for single byte characters one by one. */
+ for (i = 0; i < CHAR_TABLE_SINGLE_BYTE_SLOTS; i++)
+ if (!NILP (tmp = XCHAR_TABLE (table)->contents[i]))
+ XCHAR_TABLE (table)->contents[i] = Fcopy_sequence (tmp);
+ to = CHAR_TABLE_ORDINARY_SLOTS;
+
+ /* Also copy the first (and sole) extra slot. It is a vector
+ containing docstring of each category. */
+ Fset_char_table_extra_slot
+ (table, make_number (0),
+ Fcopy_sequence (Fchar_table_extra_slot (table, make_number (0))));
+ }
+ else
{
- Lisp_Object idx = make_number (i);
- Lisp_Object val = Faref (table, idx);
-
- if (NILP (val)) /* Do nothing because we can share nil. */
- ;
- else if (CATEGORY_SET_P (val))
- Faset (table, idx, Fcopy_sequence (val));
- else if (CHAR_TABLE_P (val))
- Faset (table, idx, copy_category_table (val, 0));
- else /* Invalid contents. */
- Faset (table, idx, Qnil);
+ i = 32;
+ to = SUB_CHAR_TABLE_ORDINARY_SLOTS;
}
+ /* If the table has non-nil default value, copy it. */
+ if (!NILP (tmp = XCHAR_TABLE (table)->defalt))
+ XCHAR_TABLE (table)->defalt = Fcopy_sequence (tmp);
+
+ /* At last, copy the remaining elements while paying attention to a
+ sub char table. */
+ for (; i < to; i++)
+ if (!NILP (tmp = XCHAR_TABLE (table)->contents[i]))
+ XCHAR_TABLE (table)->contents[i]
+ = (SUB_CHAR_TABLE_P (tmp)
+ ? copy_category_table (tmp) : Fcopy_sequence (tmp));
+
return table;
}
DEFUN ("copy-category-table", Fcopy_category_table, Scopy_category_table,
0, 1, 0,
- "Construct a new category table and return it.\n\
-It is a copy of the TABLE, which defaults to the standard category table.")
- (table)
+ doc: /* Construct a new category table and return it.
+It is a copy of the TABLE, which defaults to the standard category table. */)
+ (table)
Lisp_Object table;
{
if (!NILP (table))
else
table = Vstandard_category_table;
- return copy_category_table (table, 1);
+ return copy_category_table (table);
+}
+
+DEFUN ("make-category-table", Fmake_category_table, Smake_category_table,
+ 0, 0, 0,
+ doc: /* Construct a new and empty category table and return it. */)
+ ()
+{
+ Lisp_Object val;
+
+ val = Fmake_char_table (Qcategory_table, Qnil);
+ XCHAR_TABLE (val)->defalt = MAKE_CATEGORY_SET;
+ Fset_char_table_extra_slot (val, make_number (0),
+ Fmake_vector (make_number (95), Qnil));
+ return val;
}
DEFUN ("set-category-table", Fset_category_table, Sset_category_table, 1, 1, 0,
- "Select a new category table for the current buffer.\n\
-One argument, a category table.")
- (table)
+ doc: /* Specify TABLE as the category table for the current buffer. */)
+ (table)
Lisp_Object table;
{
+ int idx;
table = check_category_table (table);
current_buffer->category_table = table;
/* Indicate that this buffer now has a specified category table. */
- current_buffer->local_var_flags
- |= XFASTINT (buffer_local_flags.category_table);
+ idx = PER_BUFFER_VAR_IDX (category_table);
+ SET_PER_BUFFER_VALUE_P (current_buffer, idx, 1);
return table;
}
\f
DEFUN ("char-category-set", Fchar_category_set, Schar_category_set, 1, 1, 0,
- "Return a category set of CHAR.")
- (ch)
+ doc: /* Return the category set of CHAR. */)
+ (ch)
Lisp_Object ch;
{
- Lisp_Object val;
- int charset;
- unsigned char c1, c2;
-
- CHECK_NUMBER (ch, 0);
+ CHECK_NUMBER (ch);
return CATEGORY_SET (XFASTINT (ch));
}
DEFUN ("category-set-mnemonics", Fcategory_set_mnemonics,
Scategory_set_mnemonics, 1, 1, 0,
- "Return a string of mnemonics of all categories in CATEGORY-SET.")
- (category_set)
+ doc: /* Return a string containing mnemonics of the categories in CATEGORY-SET.
+CATEGORY-SET is a bool-vector, and the categories \"in\" it are those
+that are indexes where t occurs the bool-vector.
+The return value is a string containing those same categories. */)
+ (category_set)
Lisp_Object category_set;
{
int i, j;
char str[96];
- CHECK_CATEGORY_SET (category_set, 0);
+ CHECK_CATEGORY_SET (category_set);
j = 0;
for (i = 32; i < 127; i++)
return build_string (str);
}
-/* Modify all category sets stored under category table TABLE so that
+/* Modify all category sets stored under sub char-table TABLE so that
they contain (SET_VALUE is t) or don't contain (SET_VALUE is nil)
CATEGORY. */
Lisp_Object val;
int i;
- if (NILP (XCHAR_TABLE (table)->defalt))
- {
- val = MAKE_CATEGORY_SET;
- SET_CATEGORY_SET (val, category, set_value);
- XCHAR_TABLE (table)->defalt = val;
- }
+ val = XCHAR_TABLE (table)->defalt;
+ if (!CATEGORY_SET_P (val))
+ val = MAKE_CATEGORY_SET;
+ SET_CATEGORY_SET (val, category, set_value);
+ XCHAR_TABLE (table)->defalt = val;
- for (i = 32; i < CHAR_TABLE_ORDINARY_SLOTS; i++)
+ for (i = 32; i < SUB_CHAR_TABLE_ORDINARY_SLOTS; i++)
{
val = XCHAR_TABLE (table)->contents[i];
if (CATEGORY_SET_P (val))
SET_CATEGORY_SET (val, category, set_value);
- else if (CHAR_TABLE_P (val))
+ else if (SUB_CHAR_TABLE_P (val))
modify_lower_category_set (val, category, set_value);
}
}
DEFUN ("modify-category-entry", Fmodify_category_entry,
Smodify_category_entry, 2, 4, 0,
- "Modify the category set of CHAR by adding CATEGORY to it.\n\
-The category is changed only for table TABLE, which defaults to\n\
- the current buffer's category table.\n\
-If optional forth argument RESET is non NIL,\n\
- CATEGORY is deleted from the category set instead of being added.")
- (ch, category, table, reset)
- Lisp_Object ch, category, table, reset;
+ doc: /* Modify the category set of CHARACTER by adding CATEGORY to it.
+The category is changed only for table TABLE, which defaults to
+ the current buffer's category table.
+If optional fourth argument RESET is non-nil,
+then delete CATEGORY from the category set instead of adding it. */)
+ (character, category, table, reset)
+ Lisp_Object character, category, table, reset;
{
int c, charset, c1, c2;
Lisp_Object set_value; /* Actual value to be set in category sets. */
Lisp_Object val, category_set;
- CHECK_NUMBER (ch, 0);
- c = XINT (ch);
- CHECK_CATEGORY (category, 1);
+ CHECK_NUMBER (character);
+ c = XINT (character);
+ CHECK_CATEGORY (category);
table = check_category_table (table);
if (NILP (CATEGORY_DOCSTRING (table, XFASTINT (category))))
error ("Undefined category: %c", XFASTINT (category));
-
+
set_value = NILP (reset) ? Qt : Qnil;
- if ((c) < CHAR_TABLE_SINGLE_BYTE_SLOTS)
+ if (c < CHAR_TABLE_SINGLE_BYTE_SLOTS)
{
val = XCHAR_TABLE (table)->contents[c];
if (!CATEGORY_SET_P (val))
return Qnil;
}
- if (COMPOSITE_CHAR_P (c))
- c = cmpchar_component (c, 0);
- SPLIT_NON_ASCII_CHAR (c, charset, c1, c2);
+ SPLIT_CHAR (c, charset, c1, c2);
/* The top level table. */
val = XCHAR_TABLE (table)->contents[charset + 128];
- if (NILP (val))
+ if (CATEGORY_SET_P (val))
+ category_set = val;
+ else if (!SUB_CHAR_TABLE_P (val))
{
- category_set = MAKE_CATEGORY_SET;
+ category_set = val = MAKE_CATEGORY_SET;
XCHAR_TABLE (table)->contents[charset + 128] = category_set;
}
- else if (CATEGORY_SET_P (val))
- category_set = val;
- if (!c1)
+ if (c1 <= 0)
{
/* Only a charset is specified. */
- if (CHAR_TABLE_P (val))
- /* All characters in CHARSET should be the same as for CATEGORY. */
+ if (SUB_CHAR_TABLE_P (val))
+ /* All characters in CHARSET should be the same as for having
+ CATEGORY or not. */
modify_lower_category_set (val, category, set_value);
else
SET_CATEGORY_SET (category_set, category, set_value);
}
/* The second level table. */
- if (!CHAR_TABLE_P (val))
+ if (!SUB_CHAR_TABLE_P (val))
{
- val = Fmake_char_table (Qnil, Qnil);
+ val = make_sub_char_table (Qnil);
XCHAR_TABLE (table)->contents[charset + 128] = val;
/* We must set default category set of CHARSET in `defalt' slot. */
XCHAR_TABLE (val)->defalt = category_set;
table = val;
val = XCHAR_TABLE (table)->contents[c1];
- if (NILP (val))
+ if (CATEGORY_SET_P (val))
+ category_set = val;
+ else if (!SUB_CHAR_TABLE_P (val))
{
- category_set = Fcopy_sequence (XCHAR_TABLE (table)->defalt);
+ category_set = val = Fcopy_sequence (XCHAR_TABLE (table)->defalt);
XCHAR_TABLE (table)->contents[c1] = category_set;
}
- else if (CATEGORY_SET_P (val))
- category_set = val;
- if (!c2)
+ if (c2 <= 0)
{
- if (CHAR_TABLE_P (val))
+ if (SUB_CHAR_TABLE_P (val))
/* All characters in C1 group of CHARSET should be the same as
for CATEGORY. */
modify_lower_category_set (val, category, set_value);
}
/* The third (bottom) level table. */
- if (!CHAR_TABLE_P (val))
+ if (!SUB_CHAR_TABLE_P (val))
{
- val = Fmake_char_table (Qnil, Qnil);
+ val = make_sub_char_table (Qnil);
XCHAR_TABLE (table)->contents[c1] = val;
/* We must set default category set of CHARSET and C1 in
`defalt' slot. */
table = val;
val = XCHAR_TABLE (table)->contents[c2];
- if (NILP (val))
+ if (CATEGORY_SET_P (val))
+ category_set = val;
+ else if (!SUB_CHAR_TABLE_P (val))
{
category_set = Fcopy_sequence (XCHAR_TABLE (table)->defalt);
XCHAR_TABLE (table)->contents[c2] = category_set;
}
- else if (CATEGORY_SET_P (val))
- category_set = val;
else
/* This should never happen. */
error ("Invalid category table");
return Qnil;
}
\f
-/* Dump category table to buffer in human-readable format */
-
-static void
-describe_category (value)
- Lisp_Object value;
-{
- Lisp_Object mnemonics;
-
- Findent_to (make_number (16), make_number (1));
-
- if (NILP (value))
- {
- insert_string ("default\n");
- return;
- }
-
- if (!CATEGORY_SET_P (value))
- {
- insert_string ("invalid\n");
- return;
- }
-
- mnemonics = Fcategory_set_mnemonics (value);
- insert_from_string (mnemonics, 0, XSTRING (mnemonics)->size, 0);
- insert_string ("\n");
- return;
-}
-
-static Lisp_Object
-describe_category_1 (vector)
- Lisp_Object vector;
-{
- struct buffer *old = current_buffer;
- set_buffer_internal (XBUFFER (Vstandard_output));
- describe_vector (vector, Qnil, describe_category, 0, Qnil, Qnil);
- {
- int i;
- Lisp_Object docs = XCHAR_TABLE (vector)->extras[0];
- Lisp_Object elt;
-
- if (!VECTORP (docs) || XVECTOR (docs)->size != 95)
- {
- insert_string ("Invalid first extra slot in this char table\n");
- return Qnil;
- }
-
- insert_string ("Meanings of mnemonice characters are:\n");
- for (i = 0; i < 95; i++)
- {
- elt = XVECTOR (docs)->contents[i];
- if (NILP (elt))
- continue;
-
- insert_char (i + 32);
- insert (": ", 2);
- insert_from_string (elt, 0, XSTRING (elt)->size, 0);
- insert ("\n", 1);
- }
- }
-
- while (! NILP (XCHAR_TABLE (vector)->parent))
- {
- vector = XCHAR_TABLE (vector)->parent;
- insert_string ("\nThe parent category table is:");
- describe_vector (vector, Qnil, describe_category, 0, Qnil, Qnil);
- }
-
- call0 (intern ("help-mode"));
- set_buffer_internal (old);
- return Qnil;
-}
-
-DEFUN ("describe-category", Fdescribe_category, Sdescribe_category, 0, 0, "",
- "Describe the category specifications in the category table.\n\
-The descriptions are inserted in a buffer, which is then displayed.")
- ()
-{
- internal_with_output_to_temp_buffer
- ("*Help*", describe_category_1, current_buffer->category_table);
-
- return Qnil;
-}
-\f
/* Return 1 if there is a word boundary between two word-constituent
characters C1 and C2 if they appear in this order, else return 0.
Use the macro WORD_BOUNDARY_P instead of calling this function
if (NILP (category_set2))
return default_result;
- for (; CONSP (tail); tail = XCONS (tail)->cdr)
+ for (; CONSP (tail); tail = XCDR (tail))
{
- Lisp_Object elt = XCONS(tail)->car;
+ Lisp_Object elt = XCAR (tail);
if (CONSP (elt)
- && CATEGORYP (XCONS (elt)->car)
- && CATEGORYP (XCONS (elt)->cdr)
- && CATEGORY_MEMBER (XCONS (elt)->car, category_set1)
- && CATEGORY_MEMBER (XCONS (elt)->cdr, category_set2))
+ && CATEGORYP (XCAR (elt))
+ && CATEGORYP (XCDR (elt))
+ && CATEGORY_MEMBER (XFASTINT (XCAR (elt)), category_set1)
+ && CATEGORY_MEMBER (XFASTINT (XCDR (elt)), category_set2))
return !default_result;
}
return default_result;
}
\f
+void
init_category_once ()
{
/* This has to be done here, before we call Fmake_char_table. */
Fput (Qcategory_table, Qchar_table_extra_slots, make_number (2));
Vstandard_category_table = Fmake_char_table (Qcategory_table, Qnil);
- /* Set a category set which contains nothing to the default. */
+ /* Set a category set which contains nothing to the default. */
XCHAR_TABLE (Vstandard_category_table)->defalt = MAKE_CATEGORY_SET;
- Fset_char_table_extra_slot (Vstandard_category_table, 0,
+ Fset_char_table_extra_slot (Vstandard_category_table, make_number (0),
Fmake_vector (make_number (95), Qnil));
}
+void
syms_of_category ()
{
Qcategoryp = intern ("categoryp");
staticpro (&Qcategory_table_p);
DEFVAR_LISP ("word-combining-categories", &Vword_combining_categories,
- "List of pair (cons) of categories to determine word boundary.\n\
-\n\
-Emacs treats a sequence of word constituent characters as a single\n\
-word (i.e. finds no word boundary between them) iff they belongs to\n\
-the same charset. But, exceptions are allowed in the following cases.\n\
-\n\
-(1) The case that characters are in different charsets is controlled\n\
-by the variable `word-combining-categories'.\n\
-\n\
-Emacs finds no word boundary between characters of different charsets\n\
-if they have categories matching some element of this list.\n\
-\n\
-More precisely, if an element of this list is a cons of category CAT1\n\
-and CAT2, and a multibyte character C1 which has CAT1 is followed by\n\
-C2 which has CAT2, there's no word boundary between C1 and C2.\n\
-\n\
-For instance, to tell that ASCII characters and Latin-1 characters can\n\
-form a single word, the element `(?l . ?l)' should be in this list\n\
-because both characters have the category `l' (Latin characters).\n\
-\n\
-(2) The case that character are in the same charset is controlled by\n\
-the variable `word-separating-categories'.\n\
-\n\
-Emacs find a word boundary between characters of the same charset\n\
-if they have categories matching some element of this list.\n\
-\n\
-More precisely, if an element of this list is a cons of category CAT1\n\
-and CAT2, and a multibyte character C1 which has CAT1 is followed by\n\
-C2 which has CAT2, there's a word boundary between C1 and C2.\n\
-\n\
-For instance, to tell that there's a word boundary between Japanese\n\
-Hiragana and Japanese Kanji (both are in the same charset), the\n\
-element `(?H . ?C) should be in this list.");
+ doc: /* List of pair (cons) of categories to determine word boundary.
+
+Emacs treats a sequence of word constituent characters as a single
+word (i.e. finds no word boundary between them) iff they belongs to
+the same charset. But, exceptions are allowed in the following cases.
+
+\(1) The case that characters are in different charsets is controlled
+by the variable `word-combining-categories'.
+
+Emacs finds no word boundary between characters of different charsets
+if they have categories matching some element of this list.
+
+More precisely, if an element of this list is a cons of category CAT1
+and CAT2, and a multibyte character C1 which has CAT1 is followed by
+C2 which has CAT2, there's no word boundary between C1 and C2.
+
+For instance, to tell that ASCII characters and Latin-1 characters can
+form a single word, the element `(?l . ?l)' should be in this list
+because both characters have the category `l' (Latin characters).
+
+\(2) The case that character are in the same charset is controlled by
+the variable `word-separating-categories'.
+
+Emacs find a word boundary between characters of the same charset
+if they have categories matching some element of this list.
+
+More precisely, if an element of this list is a cons of category CAT1
+and CAT2, and a multibyte character C1 which has CAT1 is followed by
+C2 which has CAT2, there's a word boundary between C1 and C2.
+
+For instance, to tell that there's a word boundary between Japanese
+Hiragana and Japanese Kanji (both are in the same charset), the
+element `(?H . ?C) should be in this list. */);
Vword_combining_categories = Qnil;
DEFVAR_LISP ("word-separating-categories", &Vword_separating_categories,
- "List of pair (cons) of categories to determine word boundary.\n\
-See the documentation of the variable `word-combining-categories'.");
+ doc: /* List of pair (cons) of categories to determine word boundary.
+See the documentation of the variable `word-combining-categories'. */);
Vword_separating_categories = Qnil;
defsubr (&Scategory_table);
defsubr (&Sstandard_category_table);
defsubr (&Scopy_category_table);
+ defsubr (&Smake_category_table);
defsubr (&Sset_category_table);
defsubr (&Schar_category_set);
defsubr (&Scategory_set_mnemonics);
defsubr (&Smodify_category_entry);
- defsubr (&Sdescribe_category);
category_table_version = 0;
}