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 (!CATEGORY_SET_P (value))
 471     {
 472       insert_string ("invalid\n");
 473       return;
 474     }
 475
 476   mnemonics = Fcategory_set_mnemonics (value);
 477   insert_from_string (mnemonics, 0, XSTRING (mnemonics)->size, 0);
 478   insert_string ("\n");
 479   return;
 480 }
 481
 482 static Lisp_Object
 483 describe_category_1 (vector)
 484      Lisp_Object vector;
 485 {
 486   struct buffer *old = current_buffer;
 487   set_buffer_internal (XBUFFER (Vstandard_output));
 488   describe_vector (vector, Qnil, describe_category, 0, Qnil, Qnil,
 489                    (int *)0, 0);
 490   {
 491     int i;
 492     Lisp_Object docs = XCHAR_TABLE (vector)->extras[0];
 493     Lisp_Object elt;
 494
 495     if (!VECTORP (docs) || XVECTOR (docs)->size != 95)
 496       {
 497         insert_string ("Invalid first extra slot in this char table\n");
 498         return Qnil;
 499       }
 500
 501     insert_string ("Meanings of mnemonice characters are:\n");
 502     for (i = 0; i < 95; i++)
 503       {
 504         elt = XVECTOR (docs)->contents[i];
 505         if (NILP (elt))
 506           continue;
 507
 508         insert_char (i + 32);
 509         insert (": ", 2);
 510         insert_from_string (elt, 0, XSTRING (elt)->size, 0);
 511         insert ("\n", 1);
 512       }
 513   }
 514
 515   while (! NILP (XCHAR_TABLE (vector)->parent))
 516     {
 517       vector = XCHAR_TABLE (vector)->parent;
 518       insert_string ("\nThe parent category table is:");
 519       describe_vector (vector, Qnil, describe_category, 0, Qnil, Qnil,
 520                        (int *) 0, 0);
 521     }
 522
 523   call0 (intern ("help-mode"));
 524   set_buffer_internal (old);
 525   return Qnil;
 526 }
 527
 528 DEFUN ("describe-category", Fdescribe_category, Sdescribe_category, 0, 0, "",
 529   "Describe the category specifications in the category table.\n\
 530 The descriptions are inserted in a buffer, which is then displayed.")
 531   ()
 532 {
 533   internal_with_output_to_temp_buffer
 534      ("*Help*", describe_category_1, current_buffer->category_table);
 535
 536   return Qnil;
 537 }
 538 \f
 539 /* Return 1 if there is a word boundary between two word-constituent
 540    characters C1 and C2 if they appear in this order, else return 0.
 541    Use the macro WORD_BOUNDARY_P instead of calling this function
 542    directly.  */
 543
 544 int
 545 word_boundary_p (c1, c2)
 546      int c1, c2;
 547 {
 548   Lisp_Object category_set1, category_set2;
 549   Lisp_Object tail;
 550   int default_result;
 551
 552   if (CHAR_CHARSET (c1) == CHAR_CHARSET (c2))
 553     {
 554       tail = Vword_separating_categories;
 555       default_result = 0;
 556     }
 557   else
 558     {
 559       tail = Vword_combining_categories;
 560       default_result = 1;
 561     }
 562
 563   category_set1 = CATEGORY_SET (c1);
 564   if (NILP (category_set1))
 565     return default_result;
 566   category_set2 = CATEGORY_SET (c2);
 567   if (NILP (category_set2))
 568     return default_result;
 569
 570   for (; CONSP (tail); tail = XCONS (tail)->cdr)
 571     {
 572       Lisp_Object elt = XCONS(tail)->car;
 573
 574       if (CONSP (elt)
 575           && CATEGORYP (XCONS (elt)->car)
 576           && CATEGORYP (XCONS (elt)->cdr)
 577           && CATEGORY_MEMBER (XFASTINT (XCONS (elt)->car), category_set1)
 578           && CATEGORY_MEMBER (XFASTINT (XCONS (elt)->cdr), category_set2))
 579         return !default_result;
 580     }
 581   return default_result;
 582 }
 583
 584 \f
 585 init_category_once ()
 586 {
 587   /* This has to be done here, before we call Fmake_char_table.  */
 588   Qcategory_table = intern ("category-table");
 589   staticpro (&Qcategory_table);
 590
 591   /* Intern this now in case it isn't already done.
 592      Setting this variable twice is harmless.
 593      But don't staticpro it here--that is done in alloc.c.  */
 594   Qchar_table_extra_slots = intern ("char-table-extra-slots");
 595
 596   /* Now we are ready to set up this property, so we can
 597      create category tables.  */
 598   Fput (Qcategory_table, Qchar_table_extra_slots, make_number (2));
 599
 600   Vstandard_category_table = Fmake_char_table (Qcategory_table, Qnil);
 601   /* Set a category set which contains nothing to the default.  */
 602   XCHAR_TABLE (Vstandard_category_table)->defalt = MAKE_CATEGORY_SET;
 603   Fset_char_table_extra_slot (Vstandard_category_table, 0,
 604                               Fmake_vector (make_number (95), Qnil));
 605 }
 606
 607 syms_of_category ()
 608 {
 609   Qcategoryp = intern ("categoryp");
 610   staticpro (&Qcategoryp);
 611   Qcategorysetp = intern ("categorysetp");
 612   staticpro (&Qcategorysetp);
 613   Qcategory_table_p = intern ("category-table-p");
 614   staticpro (&Qcategory_table_p);
 615
 616   DEFVAR_LISP ("word-combining-categories", &Vword_combining_categories,
 617     "List of pair (cons) of categories to determine word boundary.\n\
 618 \n\
 619 Emacs treats a sequence of word constituent characters as a single\n\
 620 word (i.e. finds no word boundary between them) iff they belongs to\n\
 621 the same charset.  But, exceptions are allowed in the following cases.\n\
 622 \n\
 623 (1) The case that characters are in different charsets is controlled\n\
 624 by the variable `word-combining-categories'.\n\
 625 \n\
 626 Emacs finds no word boundary between characters of different charsets\n\
 627 if they have categories matching some element of this list.\n\
 628 \n\
 629 More precisely, if an element of this list is a cons of category CAT1\n\
 630 and CAT2, and a multibyte character C1 which has CAT1 is followed by\n\
 631 C2 which has CAT2, there's no word boundary between C1 and C2.\n\
 632 \n\
 633 For instance, to tell that ASCII characters and Latin-1 characters can\n\
 634 form a single word, the element `(?l . ?l)' should be in this list\n\
 635 because both characters have the category `l' (Latin characters).\n\
 636 \n\
 637 (2) The case that character are in the same charset is controlled by\n\
 638 the variable `word-separating-categories'.\n\
 639 \n\
 640 Emacs find a word boundary between characters of the same charset\n\
 641 if they have categories matching some element of this list.\n\
 642 \n\
 643 More precisely, if an element of this list is a cons of category CAT1\n\
 644 and CAT2, and a multibyte character C1 which has CAT1 is followed by\n\
 645 C2 which has CAT2, there's a word boundary between C1 and C2.\n\
 646 \n\
 647 For instance, to tell that there's a word boundary between Japanese\n\
 648 Hiragana and Japanese Kanji (both are in the same charset), the\n\
 649 element `(?H . ?C) should be in this list.");
 650
 651   Vword_combining_categories = Qnil;
 652
 653   DEFVAR_LISP ("word-separating-categories", &Vword_separating_categories,
 654     "List of pair (cons) of categories to determine word boundary.\n\
 655 See the documentation of the variable `word-combining-categories'.");
 656
 657   Vword_separating_categories = Qnil;
 658
 659   defsubr (&Smake_category_set);
 660   defsubr (&Sdefine_category);
 661   defsubr (&Scategory_docstring);
 662   defsubr (&Sget_unused_category);
 663   defsubr (&Scategory_table_p);
 664   defsubr (&Scategory_table);
 665   defsubr (&Sstandard_category_table);
 666   defsubr (&Scopy_category_table);
 667   defsubr (&Sset_category_table);
 668   defsubr (&Schar_category_set);
 669   defsubr (&Scategory_set_mnemonics);
 670   defsubr (&Smodify_category_entry);
 671   defsubr (&Sdescribe_category);
 672
 673   category_table_version = 0;
 674 }