code.delx.au - gnu-emacs/blob - src/category.c

   1 /* GNU Emacs routines to deal with category tables.
   2    Copyright (C) 1995, 1997 Electrotechnical Laboratory, JAPAN.
   3    Licensed to the Free Software Foundation.
   4
   5 This file is part of GNU Emacs.
   6
   7 GNU Emacs is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU Emacs is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU Emacs; see the file COPYING.  If not, write to
  19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  21
  22
  23 /* Here we handle three objects: category, category set, and category
  24    table.  Read comments in the file category.h to understand them.  */
  25
  26 #include <config.h>
  27 #include <ctype.h>
  28 #include "lisp.h"
  29 #include "buffer.h"
  30 #include "charset.h"
  31 #include "category.h"
  32
  33 /* The version number of the latest category table.  Each category
  34    table has a unique version number.  It is assigned a new number
  35    also when it is modified.  When a regular expression is compiled
  36    into the struct re_pattern_buffer, the version number of the
  37    category table (of the current buffer) at that moment is also
  38    embedded in the structure.
  39
  40    For the moment, we are not using this feature.  */
  41 static int category_table_version;
  42
  43 Lisp_Object Qcategory_table, Qcategoryp, Qcategorysetp, Qcategory_table_p;
  44
  45 /* Variables to determine word boundary.  */
  46 Lisp_Object Vword_combining_categories, Vword_separating_categories;
  47
  48 /* Temporary internal variable used in macro CHAR_HAS_CATEGORY.  */
  49 Lisp_Object _temp_category_set;
  50
  51 \f
  52 /* Category set staff.  */
  53
  54 DEFUN ("make-category-set", Fmake_category_set, Smake_category_set, 1, 1, 0,
  55   "Return a newly created category-set which contains CATEGORIES.\n\
  56 CATEGORIES is a string of category mnemonics.")
  57   (categories)
  58      Lisp_Object categories;
  59 {
  60   Lisp_Object val;
  61   int len;
  62
  63   CHECK_STRING (categories, 0);
  64   val = MAKE_CATEGORY_SET;
  65
  66   len = XSTRING (categories)->size;
  67   while (--len >= 0)
  68     {
  69       Lisp_Object category;
  70
  71       XSETFASTINT (category, XSTRING (categories)->data[len]);
  72       CHECK_CATEGORY (category, 0);
  73       SET_CATEGORY_SET (val, category, Qt);
  74     }
  75   return val;
  76 }
  77
  78 \f
  79 /* Category staff.  */
  80
  81 Lisp_Object check_category_table ();
  82
  83 DEFUN ("define-category", Fdefine_category, Sdefine_category, 2, 3, 0,
  84   "Define CHAR as a category which is described by DOCSTRING.\n\
  85 CHAR should be a visible letter of ` ' thru `~'.\n\
  86 DOCSTRING is a documentation string of the category.\n\
  87 The category is defined only in category table TABLE, which defaults to\n\
  88  the current buffer's category table.")
  89   (category, docstring, table)
  90      Lisp_Object category, docstring, table;
  91 {
  92   CHECK_CATEGORY (category, 0);
  93   CHECK_STRING (docstring, 1);
  94   table = check_category_table (table);
  95
  96   if (!NILP (CATEGORY_DOCSTRING (table, XFASTINT (category))))
  97     error ("Category `%c' is already defined", XFASTINT (category));
  98   CATEGORY_DOCSTRING (table, XFASTINT (category)) = docstring;
  99
 100   return Qnil;
 101 }
 102
 103 DEFUN ("category-docstring", Fcategory_docstring, Scategory_docstring, 1, 2, 0,
 104   "Return a documentation string of CATEGORY.\n\
 105 Optional second arg specifies CATEGORY-TABLE,\n\
 106  which defaults to the current buffer's category table.")
 107   (category, table)
 108      Lisp_Object category, table;
 109 {
 110   Lisp_Object doc;
 111
 112   CHECK_CATEGORY (category, 0);
 113   table = check_category_table (table);
 114
 115   return CATEGORY_DOCSTRING (table, XFASTINT (category));
 116 }
 117
 118 DEFUN ("get-unused-category", Fget_unused_category, Sget_unused_category,
 119        0, 1, 0,
 120   "Return a category which is not yet defined.\n\
 121 If total number of categories has reached the limit (95), return nil.\n\
 122 Optional argument specifies CATEGORY-TABLE,\n\
 123  which defaults to the current buffer's category table.")
 124   (table)
 125      Lisp_Object table;
 126 {
 127   int i;
 128   Lisp_Object docstring_vector;
 129
 130   table = check_category_table (table);
 131
 132   for (i = ' '; i <= '~'; i++)
 133     if (NILP (CATEGORY_DOCSTRING (table, i)))
 134       return make_number (i);
 135
 136   return Qnil;
 137 }
 138
 139 \f
 140 /* Category-table staff.  */
 141
 142 DEFUN ("category-table-p", Fcategory_table_p, Scategory_table_p, 1, 1, 0,
 143   "Return t if ARG is a category table.")
 144   (arg)
 145      Lisp_Object arg;
 146 {
 147   if (CHAR_TABLE_P (arg)
 148       && EQ (XCHAR_TABLE (arg)->purpose, Qcategory_table))
 149     return Qt;
 150   return Qnil;
 151 }
 152
 153 /* If TABLE is nil, return the current category table.  If TABLE is
 154    not nil, check the validity of TABLE as a category table.  If
 155    valid, return TABLE itself, but if not valid, signal an error of
 156    wrong-type-argument.  */
 157
 158 Lisp_Object
 159 check_category_table (table)
 160      Lisp_Object table;
 161 {
 162   register Lisp_Object tem;
 163   if (NILP (table))
 164     return current_buffer->category_table;
 165   while (tem = Fcategory_table_p (table), NILP (tem))
 166     table = wrong_type_argument (Qcategory_table_p, table);
 167   return table;
 168 }
 169
 170 DEFUN ("category-table", Fcategory_table, Scategory_table, 0, 0, 0,
 171   "Return the current category table.\n\
 172 This is the one specified by the current buffer.")
 173   ()
 174 {
 175   return current_buffer->category_table;
 176 }
 177
 178 DEFUN ("standard-category-table", Fstandard_category_table,
 179    Sstandard_category_table, 0, 0, 0,
 180   "Return the standard category table.\n\
 181 This is the one used for new buffers.")
 182   ()
 183 {
 184   return Vstandard_category_table;
 185 }
 186
 187 /* Return a copy of category table TABLE.  We can't simply use the
 188    function copy-sequence because no contents should be shared between
 189    the original and the copy.  This function is called recursively by
 190    biding TABLE to a sub char table.  */
 191
 192 Lisp_Object
 193 copy_category_table (table)
 194      Lisp_Object table;
 195 {
 196   Lisp_Object tmp;
 197   int i, to;
 198
 199   if (!NILP (XCHAR_TABLE (table)->top))
 200     {
 201       /* TABLE is a top level char table.
 202          At first, make a copy of tree structure of the table.  */
 203       table = Fcopy_sequence (table);
 204
 205       /* Then, copy elements for single byte characters one by one.  */
 206       for (i = 0; i < CHAR_TABLE_SINGLE_BYTE_SLOTS; i++)
 207         if (!NILP (tmp = XCHAR_TABLE (table)->contents[i]))
 208           XCHAR_TABLE (table)->contents[i] = Fcopy_sequence (tmp);
 209       to = CHAR_TABLE_ORDINARY_SLOTS;
 210     }
 211   else
 212     {
 213       i  = 32;
 214       to = SUB_CHAR_TABLE_ORDINARY_SLOTS;
 215     }
 216
 217   /* If the table has non-nil default value, copy it.  */
 218   if (!NILP (tmp = XCHAR_TABLE (table)->defalt))
 219     XCHAR_TABLE (table)->defalt = Fcopy_sequence (tmp);
 220
 221   /* At last, copy the remaining elements while paying attention to a
 222      sub char table.  */
 223   for (; i < to; i++)
 224     if (!NILP (tmp = XCHAR_TABLE (table)->contents[i]))
 225       XCHAR_TABLE (table)->contents[i]
 226         = (SUB_CHAR_TABLE_P (tmp)
 227            ? copy_category_table (tmp) : Fcopy_sequence (tmp));
 228
 229   return table;
 230 }
 231
 232 DEFUN ("copy-category-table", Fcopy_category_table, Scopy_category_table,
 233        0, 1, 0,
 234   "Construct a new category table and return it.\n\
 235 It is a copy of the TABLE, which defaults to the standard category table.")
 236   (table)
 237      Lisp_Object table;
 238 {
 239   if (!NILP (table))
 240     check_category_table (table);
 241   else
 242     table = Vstandard_category_table;
 243
 244   return copy_category_table (table, 1);
 245 }
 246
 247 DEFUN ("set-category-table", Fset_category_table, Sset_category_table, 1, 1, 0,
 248   "Select a new category table for the current buffer.\n\
 249 One argument, a category table.")
 250   (table)
 251      Lisp_Object table;
 252 {
 253   table = check_category_table (table);
 254   current_buffer->category_table = table;
 255   /* Indicate that this buffer now has a specified category table.  */
 256   current_buffer->local_var_flags
 257     |= XFASTINT (buffer_local_flags.category_table);
 258   return table;
 259 }
 260
 261 \f
 262 DEFUN ("char-category-set", Fchar_category_set, Schar_category_set, 1, 1, 0,
 263   "Return a category set of CHAR.")
 264   (ch)
 265      Lisp_Object ch;
 266 {
 267   Lisp_Object val;
 268   int charset;
 269   unsigned char c1, c2;
 270
 271   CHECK_NUMBER (ch, 0);
 272   return CATEGORY_SET (XFASTINT (ch));
 273 }
 274
 275 DEFUN ("category-set-mnemonics", Fcategory_set_mnemonics,
 276        Scategory_set_mnemonics, 1, 1, 0,
 277   "Return a string of mnemonics of all categories in CATEGORY-SET.")
 278   (category_set)
 279      Lisp_Object category_set;
 280 {
 281   int i, j;
 282   char str[96];
 283
 284   CHECK_CATEGORY_SET (category_set, 0);
 285
 286   j = 0;
 287   for (i = 32; i < 127; i++)
 288     if (CATEGORY_MEMBER (i, category_set))
 289       str[j++] = i;
 290   str[j] = '\0';
 291
 292   return build_string (str);
 293 }
 294
 295 /* Modify all category sets stored under sub char-table TABLE so that
 296    they contain (SET_VALUE is t) or don't contain (SET_VALUE is nil)
 297    CATEGORY.  */
 298
 299 void
 300 modify_lower_category_set (table, category, set_value)
 301      Lisp_Object table, category, set_value;
 302 {
 303   Lisp_Object val;
 304   int i;
 305
 306   if (NILP (XCHAR_TABLE (table)->defalt))
 307     {
 308       val = MAKE_CATEGORY_SET;
 309       SET_CATEGORY_SET (val, category, set_value);
 310       XCHAR_TABLE (table)->defalt = val;
 311     }
 312
 313   for (i = 32; i < SUB_CHAR_TABLE_ORDINARY_SLOTS; i++)
 314     {
 315       val = XCHAR_TABLE (table)->contents[i];
 316
 317       if (CATEGORY_SET_P (val))
 318         SET_CATEGORY_SET (val, category, set_value);
 319       else if (SUB_CHAR_TABLE_P (val))
 320         modify_lower_category_set (val, category, set_value);
 321     }
 322 }
 323
 324 void
 325 set_category_set (category_set, category, val)
 326      Lisp_Object category_set, category, val;
 327 {
 328   do {
 329     int idx = XINT (category) / 8;
 330     unsigned char bits = 1 << (XINT (category) % 8);
 331
 332     if (NILP (val))
 333       XCATEGORY_SET (category_set)->data[idx] &= ~bits;
 334     else
 335       XCATEGORY_SET (category_set)->data[idx] |= bits;
 336   } while (0);
 337 }
 338
 339 DEFUN ("modify-category-entry", Fmodify_category_entry,
 340        Smodify_category_entry, 2, 4, 0,
 341   "Modify the category set of CHAR by adding CATEGORY to it.\n\
 342 The category is changed only for table TABLE, which defaults to\n\
 343  the current buffer's category table.\n\
 344 If optional forth argument RESET is non NIL,\n\
 345  CATEGORY is deleted from the category set instead of being added.")
 346   (ch, category, table, reset)
 347      Lisp_Object ch, category, table, reset;
 348 {
 349   int c, charset, c1, c2;
 350   Lisp_Object set_value;        /* Actual value to be set in category sets.  */
 351   Lisp_Object val, category_set;
 352
 353   CHECK_NUMBER (ch, 0);
 354   c = XINT (ch);
 355   CHECK_CATEGORY (category, 1);
 356   table = check_category_table (table);
 357
 358   if (NILP (CATEGORY_DOCSTRING (table, XFASTINT (category))))
 359     error ("Undefined category: %c", XFASTINT (category));
 360
 361   set_value = NILP (reset) ? Qt : Qnil;
 362
 363   if (c < CHAR_TABLE_SINGLE_BYTE_SLOTS)
 364     {
 365       val = XCHAR_TABLE (table)->contents[c];
 366       if (!CATEGORY_SET_P (val))
 367         XCHAR_TABLE (table)->contents[c] = (val = MAKE_CATEGORY_SET);
 368       SET_CATEGORY_SET (val, category, set_value);
 369       return Qnil;
 370     }
 371
 372   SPLIT_NON_ASCII_CHAR (c, charset, c1, c2);
 373
 374   /* The top level table.  */
 375   val = XCHAR_TABLE (table)->contents[charset + 128];
 376   if (CATEGORY_SET_P (val))
 377     category_set = val;
 378   else if (!SUB_CHAR_TABLE_P (val))
 379     {
 380       category_set = val = MAKE_CATEGORY_SET;
 381       XCHAR_TABLE (table)->contents[charset + 128] = category_set;
 382     }
 383
 384   if (c1 <= 0)
 385     {
 386       /* Only a charset is specified.  */
 387       if (SUB_CHAR_TABLE_P (val))
 388         /* All characters in CHARSET should be the same as for having
 389            CATEGORY or not.  */
 390         modify_lower_category_set (val, category, set_value);
 391       else
 392         SET_CATEGORY_SET (category_set, category, set_value);
 393       return Qnil;
 394     }
 395
 396   /* The second level table.  */
 397   if (!SUB_CHAR_TABLE_P (val))
 398     {
 399       val = make_sub_char_table (Qnil);
 400       XCHAR_TABLE (table)->contents[charset + 128] = val;
 401       /* We must set default category set of CHARSET in `defalt' slot.  */
 402       XCHAR_TABLE (val)->defalt = category_set;
 403     }
 404   table = val;
 405
 406   val = XCHAR_TABLE (table)->contents[c1];
 407   if (CATEGORY_SET_P (val))
 408     category_set = val;
 409   else if (!SUB_CHAR_TABLE_P (val))
 410     {
 411       category_set = val = Fcopy_sequence (XCHAR_TABLE (table)->defalt);
 412       XCHAR_TABLE (table)->contents[c1] = category_set;
 413     }
 414
 415   if (c2 <= 0)
 416     {
 417       if (SUB_CHAR_TABLE_P (val))
 418         /* All characters in C1 group of CHARSET should be the same as
 419            for CATEGORY.  */
 420         modify_lower_category_set (val, category, set_value);
 421       else
 422         SET_CATEGORY_SET (category_set, category, set_value);
 423       return Qnil;
 424     }
 425
 426   /* The third (bottom) level table.  */
 427   if (!SUB_CHAR_TABLE_P (val))
 428     {
 429       val = make_sub_char_table (Qnil);
 430       XCHAR_TABLE (table)->contents[c1] = val;
 431       /* We must set default category set of CHARSET and C1 in
 432          `defalt' slot.  */
 433       XCHAR_TABLE (val)->defalt = category_set;
 434     }
 435   table = val;
 436
 437   val = XCHAR_TABLE (table)->contents[c2];
 438   if (CATEGORY_SET_P (val))
 439     category_set = val;
 440   else if (!SUB_CHAR_TABLE_P (val))
 441     {
 442       category_set = Fcopy_sequence (XCHAR_TABLE (table)->defalt);
 443       XCHAR_TABLE (table)->contents[c2] = category_set;
 444     }
 445   else
 446     /* This should never happen.  */
 447     error ("Invalid category table");
 448
 449   SET_CATEGORY_SET (category_set, category, set_value);
 450
 451   return Qnil;
 452 }
 453 \f
 454 /* Dump category table to buffer in human-readable format */
 455
 456 static void
 457 describe_category (value)
 458     Lisp_Object value;
 459 {
 460   Lisp_Object mnemonics;
 461
 462   Findent_to (make_number (16), make_number (1));
 463
 464   if (NILP (value))
 465     {
 466       insert_string ("default\n");
 467       return;
 468     }
 469
 470   if (CHAR_TABLE_P (value))
 471     {
 472       insert_string ("deeper char-table ...\n");
 473       return;
 474     }
 475
 476   if (!CATEGORY_SET_P (value))
 477     {
 478       insert_string ("invalid\n");
 479       return;
 480     }
 481
 482   mnemonics = Fcategory_set_mnemonics (value);
 483   insert_from_string (mnemonics, 0, XSTRING (mnemonics)->size, 0);
 484   insert_string ("\n");
 485   return;
 486 }
 487
 488 static Lisp_Object
 489 describe_category_1 (vector)
 490      Lisp_Object vector;
 491 {
 492   struct buffer *old = current_buffer;
 493   set_buffer_internal (XBUFFER (Vstandard_output));
 494   describe_vector (vector, Qnil, describe_category, 0, Qnil, Qnil,
 495                    (int *)0, 0);
 496   {
 497     int i;
 498     Lisp_Object docs = XCHAR_TABLE (vector)->extras[0];
 499     Lisp_Object elt;
 500
 501     if (!VECTORP (docs) || XVECTOR (docs)->size != 95)
 502       {
 503         insert_string ("Invalid first extra slot in this char table\n");
 504         return Qnil;
 505       }
 506
 507     insert_string ("Meanings of mnemonice characters are:\n");
 508     for (i = 0; i < 95; i++)
 509       {
 510         elt = XVECTOR (docs)->contents[i];
 511         if (NILP (elt))
 512           continue;
 513
 514         insert_char (i + 32);
 515         insert (": ", 2);
 516         insert_from_string (elt, 0, XSTRING (elt)->size, 0);
 517         insert ("\n", 1);
 518       }
 519   }
 520
 521   while (! NILP (XCHAR_TABLE (vector)->parent))
 522     {
 523       vector = XCHAR_TABLE (vector)->parent;
 524       insert_string ("\nThe parent category table is:");
 525       describe_vector (vector, Qnil, describe_category, 0, Qnil, Qnil,
 526                        (int *) 0, 0);
 527     }
 528
 529   call0 (intern ("help-mode"));
 530   set_buffer_internal (old);
 531   return Qnil;
 532 }
 533
 534 DEFUN ("describe-category", Fdescribe_category, Sdescribe_category, 0, 0, "",
 535   "Describe the category specifications in the category table.\n\
 536 The descriptions are inserted in a buffer, which is then displayed.")
 537   ()
 538 {
 539   internal_with_output_to_temp_buffer
 540      ("*Help*", describe_category_1, current_buffer->category_table);
 541
 542   return Qnil;
 543 }
 544 \f
 545 /* Return 1 if there is a word boundary between two word-constituent
 546    characters C1 and C2 if they appear in this order, else return 0.
 547    Use the macro WORD_BOUNDARY_P instead of calling this function
 548    directly.  */
 549
 550 int
 551 word_boundary_p (c1, c2)
 552      int c1, c2;
 553 {
 554   Lisp_Object category_set1, category_set2;
 555   Lisp_Object tail;
 556   int default_result;
 557
 558   if (CHAR_CHARSET (c1) == CHAR_CHARSET (c2))
 559     {
 560       tail = Vword_separating_categories;
 561       default_result = 0;
 562     }
 563   else
 564     {
 565       tail = Vword_combining_categories;
 566       default_result = 1;
 567     }
 568
 569   category_set1 = CATEGORY_SET (c1);
 570   if (NILP (category_set1))
 571     return default_result;
 572   category_set2 = CATEGORY_SET (c2);
 573   if (NILP (category_set2))
 574     return default_result;
 575
 576   for (; CONSP (tail); tail = XCONS (tail)->cdr)
 577     {
 578       Lisp_Object elt = XCONS(tail)->car;
 579
 580       if (CONSP (elt)
 581           && CATEGORYP (XCONS (elt)->car)
 582           && CATEGORYP (XCONS (elt)->cdr)
 583           && CATEGORY_MEMBER (XFASTINT (XCONS (elt)->car), category_set1)
 584           && CATEGORY_MEMBER (XFASTINT (XCONS (elt)->cdr), category_set2))
 585         return !default_result;
 586     }
 587   return default_result;
 588 }
 589
 590 \f
 591 init_category_once ()
 592 {
 593   /* This has to be done here, before we call Fmake_char_table.  */
 594   Qcategory_table = intern ("category-table");
 595   staticpro (&Qcategory_table);
 596
 597   /* Intern this now in case it isn't already done.
 598      Setting this variable twice is harmless.
 599      But don't staticpro it here--that is done in alloc.c.  */
 600   Qchar_table_extra_slots = intern ("char-table-extra-slots");
 601
 602   /* Now we are ready to set up this property, so we can
 603      create category tables.  */
 604   Fput (Qcategory_table, Qchar_table_extra_slots, make_number (2));
 605
 606   Vstandard_category_table = Fmake_char_table (Qcategory_table, Qnil);
 607   /* Set a category set which contains nothing to the default.  */
 608   XCHAR_TABLE (Vstandard_category_table)->defalt = MAKE_CATEGORY_SET;
 609   Fset_char_table_extra_slot (Vstandard_category_table, 0,
 610                               Fmake_vector (make_number (95), Qnil));
 611 }
 612
 613 syms_of_category ()
 614 {
 615   Qcategoryp = intern ("categoryp");
 616   staticpro (&Qcategoryp);
 617   Qcategorysetp = intern ("categorysetp");
 618   staticpro (&Qcategorysetp);
 619   Qcategory_table_p = intern ("category-table-p");
 620   staticpro (&Qcategory_table_p);
 621
 622   DEFVAR_LISP ("word-combining-categories", &Vword_combining_categories,
 623     "List of pair (cons) of categories to determine word boundary.\n\
 624 \n\
 625 Emacs treats a sequence of word constituent characters as a single\n\
 626 word (i.e. finds no word boundary between them) iff they belongs to\n\
 627 the same charset.  But, exceptions are allowed in the following cases.\n\
 628 \n\
 629 (1) The case that characters are in different charsets is controlled\n\
 630 by the variable `word-combining-categories'.\n\
 631 \n\
 632 Emacs finds no word boundary between characters of different charsets\n\
 633 if they have categories matching some element of this list.\n\
 634 \n\
 635 More precisely, if an element of this list is a cons of category CAT1\n\
 636 and CAT2, and a multibyte character C1 which has CAT1 is followed by\n\
 637 C2 which has CAT2, there's no word boundary between C1 and C2.\n\
 638 \n\
 639 For instance, to tell that ASCII characters and Latin-1 characters can\n\
 640 form a single word, the element `(?l . ?l)' should be in this list\n\
 641 because both characters have the category `l' (Latin characters).\n\
 642 \n\
 643 (2) The case that character are in the same charset is controlled by\n\
 644 the variable `word-separating-categories'.\n\
 645 \n\
 646 Emacs find a word boundary between characters of the same charset\n\
 647 if they have categories matching some element of this list.\n\
 648 \n\
 649 More precisely, if an element of this list is a cons of category CAT1\n\
 650 and CAT2, and a multibyte character C1 which has CAT1 is followed by\n\
 651 C2 which has CAT2, there's a word boundary between C1 and C2.\n\
 652 \n\
 653 For instance, to tell that there's a word boundary between Japanese\n\
 654 Hiragana and Japanese Kanji (both are in the same charset), the\n\
 655 element `(?H . ?C) should be in this list.");
 656
 657   Vword_combining_categories = Qnil;
 658
 659   DEFVAR_LISP ("word-separating-categories", &Vword_separating_categories,
 660     "List of pair (cons) of categories to determine word boundary.\n\
 661 See the documentation of the variable `word-combining-categories'.");
 662
 663   Vword_separating_categories = Qnil;
 664
 665   defsubr (&Smake_category_set);
 666   defsubr (&Sdefine_category);
 667   defsubr (&Scategory_docstring);
 668   defsubr (&Sget_unused_category);
 669   defsubr (&Scategory_table_p);
 670   defsubr (&Scategory_table);
 671   defsubr (&Sstandard_category_table);
 672   defsubr (&Scopy_category_table);
 673   defsubr (&Sset_category_table);
 674   defsubr (&Schar_category_set);
 675   defsubr (&Scategory_set_mnemonics);
 676   defsubr (&Smodify_category_entry);
 677   defsubr (&Sdescribe_category);
 678
 679   category_table_version = 0;
 680 }