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 is a string of category mnemonics.\n\
+The value is a bool-vector which has t at the indices corresponding to\n\
+those categories.")
(categories)
Lisp_Object categories;
{
CHECK_STRING (categories, 0);
val = MAKE_CATEGORY_SET;
+ if (STRING_MULTIBYTE (categories))
+ error ("Multibyte string in make-category-set");
+
len = XSTRING (categories)->size;
while (--len >= 0)
{
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\
+CHAR should be an ASCII printing character in the range ` ' to `~'.\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.")
}
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.")
+ "Return the documentation string of CATEGORY, as defined in CATEGORY-TABLE.")
(category, table)
Lisp_Object category, table;
{
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.")
+ "Return a category which is not yet defined in CATEGORY-TABLE.\n\
+If no category remains available, return nil.\n\
+The optional argument CATEGORY-TABLE specifies which category table\n\
+to modify; it defaults to the current buffer's category table.")
(table)
Lisp_Object 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. This function is called recursively by
- biding TABLE to a sub char table. */
+ binding TABLE to a sub char table. */
Lisp_Object
copy_category_table (table)
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
{
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,
+ "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.")
+ "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.")
+ "Return the category set of CHAR.")
(ch)
Lisp_Object 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.")
+ "Return a string containing mnemonics of the categories in CATEGORY-SET.\n\
+CATEGORY-SET is a bool-vector, and the categories \"in\" it are those\n\
+that are indexes where t occurs the bool-vector.\n\
+The return value is a string containing those same categories.")
(category_set)
Lisp_Object category_set;
{
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 < SUB_CHAR_TABLE_ORDINARY_SLOTS; i++)
{
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\
+ "Modify the category set of CHARACTER 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;
+If optional fourth argument RESET is non-nil,\n\
+ 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_NUMBER (character, 0);
+ c = XINT (character);
CHECK_CATEGORY (category, 1);
table = check_category_table (table);
return Qnil;
}
- 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];
}
mnemonics = Fcategory_set_mnemonics (value);
- insert_from_string (mnemonics, 0, XSTRING (mnemonics)->size, 0);
+ insert_from_string (mnemonics, 0, 0, XSTRING (mnemonics)->size,
+ STRING_BYTES (XSTRING (mnemonics)), 0);
insert_string ("\n");
return;
}
insert_char (i + 32);
insert (": ", 2);
- insert_from_string (elt, 0, XSTRING (elt)->size, 0);
+ insert_from_string (elt, 0, 0, XSTRING (elt)->size,
+ STRING_BYTES (XSTRING (elt)), 0);
insert ("\n", 1);
}
}
return Qnil;
}
-DEFUN ("describe-category", Fdescribe_category, Sdescribe_category, 0, 0, "",
- "Describe the category specifications in the category table.\n\
+DEFUN ("describe-categories", Fdescribe_categories, Sdescribe_categories, 0, 0, "",
+ "Describe the category specifications in the current category table.\n\
The descriptions are inserted in a buffer, which is then displayed.")
()
{
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 (XFASTINT (XCONS (elt)->car), category_set1)
- && CATEGORY_MEMBER (XFASTINT (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. */
Vstandard_category_table = Fmake_char_table (Qcategory_table, Qnil);
/* 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");
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\
+\(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\
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\
+\(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\
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);
+ defsubr (&Sdescribe_categories);
category_table_version = 0;
}