category.c 18.7 KB
Newer Older
Karl Heuer's avatar
Karl Heuer committed
1
/* GNU Emacs routines to deal with category tables.
2 3
   Copyright (C) 1998, 2001, 2002, 2003, 2004, 2005, 2006, 2007
     Free Software Foundation, Inc.
Kenichi Handa's avatar
Kenichi Handa committed
4
   Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
5
     2005, 2006, 2007
Kenichi Handa's avatar
Kenichi Handa committed
6 7
     National Institute of Advanced Industrial Science and Technology (AIST)
     Registration Number H14PRO021
Karl Heuer's avatar
Karl Heuer committed
8 9 10 11 12

This file is part of GNU Emacs.

GNU Emacs is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
13
the Free Software Foundation; either version 3, or (at your option)
Karl Heuer's avatar
Karl Heuer committed
14 15 16 17 18 19 20 21 22
any later version.

GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Emacs; see the file COPYING.  If not, write to
Lute Kamstra's avatar
Lute Kamstra committed
23 24
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.  */
Karl Heuer's avatar
Karl Heuer committed
25 26 27 28 29 30 31 32 33 34 35


/* Here we handle three objects: category, category set, and category
   table.  Read comments in the file category.h to understand them.  */

#include <config.h>
#include <ctype.h>
#include "lisp.h"
#include "buffer.h"
#include "charset.h"
#include "category.h"
Stefan Monnier's avatar
Stefan Monnier committed
36
#include "keymap.h"
Karl Heuer's avatar
Karl Heuer committed
37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59

/* The version number of the latest category table.  Each category
   table has a unique version number.  It is assigned a new number
   also when it is modified.  When a regular expression is compiled
   into the struct re_pattern_buffer, the version number of the
   category table (of the current buffer) at that moment is also
   embedded in the structure.

   For the moment, we are not using this feature.  */
static int category_table_version;

Lisp_Object Qcategory_table, Qcategoryp, Qcategorysetp, Qcategory_table_p;

/* Variables to determine word boundary.  */
Lisp_Object Vword_combining_categories, Vword_separating_categories;

/* Temporary internal variable used in macro CHAR_HAS_CATEGORY.  */
Lisp_Object _temp_category_set;


/* Category set staff.  */

DEFUN ("make-category-set", Fmake_category_set, Smake_category_set, 1, 1, 0,
60 61 62 63 64
       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)
Karl Heuer's avatar
Karl Heuer committed
65 66 67 68 69
     Lisp_Object categories;
{
  Lisp_Object val;
  int len;

70
  CHECK_STRING (categories);
Karl Heuer's avatar
Karl Heuer committed
71 72
  val = MAKE_CATEGORY_SET;

73
  if (STRING_MULTIBYTE (categories))
74
    error ("Multibyte string in `make-category-set'");
75

76
  len = SCHARS (categories);
Karl Heuer's avatar
Karl Heuer committed
77 78
  while (--len >= 0)
    {
79
      Lisp_Object category;
Karl Heuer's avatar
Karl Heuer committed
80

81
      XSETFASTINT (category, SREF (categories, len));
82
      CHECK_CATEGORY (category);
Karl Heuer's avatar
Karl Heuer committed
83 84 85 86 87 88 89 90 91 92 93
      SET_CATEGORY_SET (val, category, Qt);
    }
  return val;
}


/* Category staff.  */

Lisp_Object check_category_table ();

DEFUN ("define-category", Fdefine_category, Sdefine_category, 2, 3, 0,
94 95 96
       doc: /* Define CATEGORY as a category which is described by DOCSTRING.
CATEGORY should be an ASCII printing character in the range ` ' to `~'.
DOCSTRING is the documentation string of the category.
97
The category is defined only in category table TABLE, which defaults to
98
the current buffer's category table.  */)
99
     (category, docstring, table)
Karl Heuer's avatar
Karl Heuer committed
100 101
     Lisp_Object category, docstring, table;
{
102 103
  CHECK_CATEGORY (category);
  CHECK_STRING (docstring);
Karl Heuer's avatar
Karl Heuer committed
104 105 106 107 108 109 110 111 112 113
  table = check_category_table (table);

  if (!NILP (CATEGORY_DOCSTRING (table, XFASTINT (category))))
    error ("Category `%c' is already defined", XFASTINT (category));
  CATEGORY_DOCSTRING (table, XFASTINT (category)) = docstring;

  return Qnil;
}

DEFUN ("category-docstring", Fcategory_docstring, Scategory_docstring, 1, 2, 0,
114 115 116
       doc: /* Return the documentation string of CATEGORY, as defined in TABLE.
TABLE should be a category table and defaults to the current buffer's
category table.  */)
117
     (category, table)
Karl Heuer's avatar
Karl Heuer committed
118 119
     Lisp_Object category, table;
{
120
  CHECK_CATEGORY (category);
Karl Heuer's avatar
Karl Heuer committed
121 122 123 124 125 126 127
  table = check_category_table (table);

  return CATEGORY_DOCSTRING (table, XFASTINT (category));
}

DEFUN ("get-unused-category", Fget_unused_category, Sget_unused_category,
       0, 1, 0,
128
       doc: /* Return a category which is not yet defined in TABLE.
129
If no category remains available, return nil.
130
The optional argument TABLE specifies which category table to modify;
131
it defaults to the current buffer's category table.  */)
132
     (table)
Karl Heuer's avatar
Karl Heuer committed
133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149
     Lisp_Object table;
{
  int i;

  table = check_category_table (table);

  for (i = ' '; i <= '~'; i++)
    if (NILP (CATEGORY_DOCSTRING (table, i)))
      return make_number (i);

  return Qnil;
}


/* Category-table staff.  */

DEFUN ("category-table-p", Fcategory_table_p, Scategory_table_p, 1, 1, 0,
150 151
       doc: /* Return t if ARG is a category table.  */)
     (arg)
Karl Heuer's avatar
Karl Heuer committed
152 153 154
     Lisp_Object arg;
{
  if (CHAR_TABLE_P (arg)
155
      && EQ (XCHAR_TABLE (arg)->purpose, Qcategory_table))
Karl Heuer's avatar
Karl Heuer committed
156 157 158 159 160 161 162 163 164 165 166 167 168 169 170
    return Qt;
  return Qnil;
}

/* If TABLE is nil, return the current category table.  If TABLE is
   not nil, check the validity of TABLE as a category table.  If
   valid, return TABLE itself, but if not valid, signal an error of
   wrong-type-argument.  */

Lisp_Object
check_category_table (table)
     Lisp_Object table;
{
  if (NILP (table))
    return current_buffer->category_table;
171
  CHECK_TYPE (!NILP (Fcategory_table_p (table)), Qcategory_table_p, table);
Karl Heuer's avatar
Karl Heuer committed
172
  return table;
173
}
Karl Heuer's avatar
Karl Heuer committed
174 175

DEFUN ("category-table", Fcategory_table, Scategory_table, 0, 0, 0,
176 177 178
       doc: /* Return the current category table.
This is the one specified by the current buffer.  */)
     ()
Karl Heuer's avatar
Karl Heuer committed
179 180 181 182 183 184
{
  return current_buffer->category_table;
}

DEFUN ("standard-category-table", Fstandard_category_table,
   Sstandard_category_table, 0, 0, 0,
185 186 187
       doc: /* Return the standard category table.
This is the one used for new buffers.  */)
     ()
Karl Heuer's avatar
Karl Heuer committed
188 189 190 191 192 193
{
  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
194
   the original and the copy.  This function is called recursively by
195
   binding TABLE to a sub char table.  */
Karl Heuer's avatar
Karl Heuer committed
196 197

Lisp_Object
198
copy_category_table (table)
Karl Heuer's avatar
Karl Heuer committed
199 200
     Lisp_Object table;
{
201 202
  Lisp_Object tmp;
  int i, to;
Karl Heuer's avatar
Karl Heuer committed
203

204 205 206 207 208 209 210 211 212 213 214
  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;
215 216 217 218 219 220

      /* 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))));
221 222
    }
  else
Karl Heuer's avatar
Karl Heuer committed
223
    {
224 225
      i  = 32;
      to = SUB_CHAR_TABLE_ORDINARY_SLOTS;
Karl Heuer's avatar
Karl Heuer committed
226 227
    }

228 229 230 231 232 233 234 235 236 237 238 239
  /* 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));

Karl Heuer's avatar
Karl Heuer committed
240 241 242 243 244
  return table;
}

DEFUN ("copy-category-table", Fcopy_category_table, Scopy_category_table,
       0, 1, 0,
245 246 247
       doc: /* Construct a new category table and return it.
It is a copy of the TABLE, which defaults to the standard category table.  */)
     (table)
Karl Heuer's avatar
Karl Heuer committed
248 249 250 251 252 253 254
     Lisp_Object table;
{
  if (!NILP (table))
    check_category_table (table);
  else
    table = Vstandard_category_table;

255
  return copy_category_table (table);
Karl Heuer's avatar
Karl Heuer committed
256 257
}

258 259
DEFUN ("make-category-table", Fmake_category_table, Smake_category_table,
       0, 0, 0,
260 261
       doc: /* Construct a new and empty category table and return it.  */)
     ()
262 263 264 265 266 267 268 269 270 271
{
  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;
}

Karl Heuer's avatar
Karl Heuer committed
272
DEFUN ("set-category-table", Fset_category_table, Sset_category_table, 1, 1, 0,
273 274
       doc: /* Specify TABLE as the category table for the current buffer.
Return TABLE.  */)
275
     (table)
Karl Heuer's avatar
Karl Heuer committed
276 277
     Lisp_Object table;
{
278
  int idx;
Karl Heuer's avatar
Karl Heuer committed
279 280 281
  table = check_category_table (table);
  current_buffer->category_table = table;
  /* Indicate that this buffer now has a specified category table.  */
Gerd Moellmann's avatar
Gerd Moellmann committed
282 283
  idx = PER_BUFFER_VAR_IDX (category_table);
  SET_PER_BUFFER_VALUE_P (current_buffer, idx, 1);
Karl Heuer's avatar
Karl Heuer committed
284 285 286 287 288
  return table;
}


DEFUN ("char-category-set", Fchar_category_set, Schar_category_set, 1, 1, 0,
289 290
       doc: /* Return the category set of CHAR.
usage: (char-category-set CHAR)  */)
291
     (ch)
Karl Heuer's avatar
Karl Heuer committed
292 293
     Lisp_Object ch;
{
294
  CHECK_NUMBER (ch);
Karl Heuer's avatar
Karl Heuer committed
295 296 297 298 299
  return CATEGORY_SET (XFASTINT (ch));
}

DEFUN ("category-set-mnemonics", Fcategory_set_mnemonics,
       Scategory_set_mnemonics, 1, 1, 0,
300 301
       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
302
that are indexes where t occurs in the bool-vector.
303 304
The return value is a string containing those same categories.  */)
     (category_set)
Karl Heuer's avatar
Karl Heuer committed
305 306 307 308 309
     Lisp_Object category_set;
{
  int i, j;
  char str[96];

310
  CHECK_CATEGORY_SET (category_set);
Karl Heuer's avatar
Karl Heuer committed
311 312 313 314 315 316 317 318 319 320

  j = 0;
  for (i = 32; i < 127; i++)
    if (CATEGORY_MEMBER (i, category_set))
      str[j++] = i;
  str[j] = '\0';

  return build_string (str);
}

321
/* Modify all category sets stored under sub char-table TABLE so that
Karl Heuer's avatar
Karl Heuer committed
322 323 324 325 326 327 328 329 330 331
   they contain (SET_VALUE is t) or don't contain (SET_VALUE is nil)
   CATEGORY.  */

void
modify_lower_category_set (table, category, set_value)
     Lisp_Object table, category, set_value;
{
  Lisp_Object val;
  int i;

332 333 334 335 336
  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;
Karl Heuer's avatar
Karl Heuer committed
337

338
  for (i = 32; i < SUB_CHAR_TABLE_ORDINARY_SLOTS; i++)
Karl Heuer's avatar
Karl Heuer committed
339 340 341 342 343
    {
      val = XCHAR_TABLE (table)->contents[i];

      if (CATEGORY_SET_P (val))
	SET_CATEGORY_SET (val, category, set_value);
344
      else if (SUB_CHAR_TABLE_P (val))
Karl Heuer's avatar
Karl Heuer committed
345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365
	modify_lower_category_set (val, category, set_value);
    }
}

void
set_category_set (category_set, category, val)
     Lisp_Object category_set, category, val;
{
  do {
    int idx = XINT (category) / 8;
    unsigned char bits = 1 << (XINT (category) % 8);

    if (NILP (val))
      XCATEGORY_SET (category_set)->data[idx] &= ~bits;
    else
      XCATEGORY_SET (category_set)->data[idx] |= bits;
  } while (0);
}

DEFUN ("modify-category-entry", Fmodify_category_entry,
       Smodify_category_entry, 2, 4, 0,
366 367 368 369 370 371
       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)
372
     Lisp_Object character, category, table, reset;
Karl Heuer's avatar
Karl Heuer committed
373 374 375 376 377
{
  int c, charset, c1, c2;
  Lisp_Object set_value;	/* Actual value to be set in category sets.  */
  Lisp_Object val, category_set;

378
  CHECK_NUMBER (character);
379
  c = XINT (character);
380
  CHECK_CATEGORY (category);
Karl Heuer's avatar
Karl Heuer committed
381 382 383 384
  table = check_category_table (table);

  if (NILP (CATEGORY_DOCSTRING (table, XFASTINT (category))))
    error ("Undefined category: %c", XFASTINT (category));
385

Karl Heuer's avatar
Karl Heuer committed
386 387
  set_value = NILP (reset) ? Qt : Qnil;

388
  if (c < CHAR_TABLE_SINGLE_BYTE_SLOTS)
Karl Heuer's avatar
Karl Heuer committed
389 390 391 392 393 394 395 396
    {
      val = XCHAR_TABLE (table)->contents[c];
      if (!CATEGORY_SET_P (val))
	XCHAR_TABLE (table)->contents[c] = (val = MAKE_CATEGORY_SET);
      SET_CATEGORY_SET (val, category, set_value);
      return Qnil;
    }

397
  SPLIT_CHAR (c, charset, c1, c2);
Karl Heuer's avatar
Karl Heuer committed
398 399

  /* The top level table.  */
400
  val = XCHAR_TABLE (table)->contents[charset + 128];
401 402 403
  if (CATEGORY_SET_P (val))
    category_set = val;
  else if (!SUB_CHAR_TABLE_P (val))
Karl Heuer's avatar
Karl Heuer committed
404
    {
405
      category_set = val = MAKE_CATEGORY_SET;
406
      XCHAR_TABLE (table)->contents[charset + 128] = category_set;
Karl Heuer's avatar
Karl Heuer committed
407 408
    }

409
  if (c1 <= 0)
Karl Heuer's avatar
Karl Heuer committed
410 411
    {
      /* Only a charset is specified.  */
412 413 414
      if (SUB_CHAR_TABLE_P (val))
	/* All characters in CHARSET should be the same as for having
           CATEGORY or not.  */
Karl Heuer's avatar
Karl Heuer committed
415 416 417 418 419 420 421
	modify_lower_category_set (val, category, set_value);
      else
	SET_CATEGORY_SET (category_set, category, set_value);
      return Qnil;
    }

  /* The second level table.  */
422
  if (!SUB_CHAR_TABLE_P (val))
Karl Heuer's avatar
Karl Heuer committed
423
    {
424
      val = make_sub_char_table (Qnil);
425
      XCHAR_TABLE (table)->contents[charset + 128] = val;
Karl Heuer's avatar
Karl Heuer committed
426 427 428 429 430 431
      /* 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];
432 433 434
  if (CATEGORY_SET_P (val))
    category_set = val;
  else if (!SUB_CHAR_TABLE_P (val))
Karl Heuer's avatar
Karl Heuer committed
435
    {
436
      category_set = val = Fcopy_sequence (XCHAR_TABLE (table)->defalt);
Karl Heuer's avatar
Karl Heuer committed
437 438 439
      XCHAR_TABLE (table)->contents[c1] = category_set;
    }

440
  if (c2 <= 0)
Karl Heuer's avatar
Karl Heuer committed
441
    {
442
      if (SUB_CHAR_TABLE_P (val))
Karl Heuer's avatar
Karl Heuer committed
443 444 445 446 447 448 449 450 451
	/* All characters in C1 group of CHARSET should be the same as
           for CATEGORY.  */
	modify_lower_category_set (val, category, set_value);
      else
	SET_CATEGORY_SET (category_set, category, set_value);
      return Qnil;
    }

  /* The third (bottom) level table.  */
452
  if (!SUB_CHAR_TABLE_P (val))
Karl Heuer's avatar
Karl Heuer committed
453
    {
454
      val = make_sub_char_table (Qnil);
Karl Heuer's avatar
Karl Heuer committed
455 456 457 458 459 460 461 462
      XCHAR_TABLE (table)->contents[c1] = val;
      /* We must set default category set of CHARSET and C1 in
         `defalt' slot.  */
      XCHAR_TABLE (val)->defalt = category_set;
    }
  table = val;

  val = XCHAR_TABLE (table)->contents[c2];
463 464 465
  if (CATEGORY_SET_P (val))
    category_set = val;
  else if (!SUB_CHAR_TABLE_P (val))
Karl Heuer's avatar
Karl Heuer committed
466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509
    {
      category_set = Fcopy_sequence (XCHAR_TABLE (table)->defalt);
      XCHAR_TABLE (table)->contents[c2] = category_set;
    }
  else
    /* This should never happen.  */
    error ("Invalid category table");

  SET_CATEGORY_SET (category_set, category, set_value);

  return Qnil;
}

/* 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
   directly.  */

int
word_boundary_p (c1, c2)
     int c1, c2;
{
  Lisp_Object category_set1, category_set2;
  Lisp_Object tail;
  int default_result;

  if (CHAR_CHARSET (c1) == CHAR_CHARSET (c2))
    {
      tail = Vword_separating_categories;
      default_result = 0;
    }
  else
    {
      tail = Vword_combining_categories;
      default_result = 1;
    }

  category_set1 = CATEGORY_SET (c1);
  if (NILP (category_set1))
    return default_result;
  category_set2 = CATEGORY_SET (c2);
  if (NILP (category_set2))
    return default_result;

510
  for (; CONSP (tail); tail = XCDR (tail))
Karl Heuer's avatar
Karl Heuer committed
511
    {
512
      Lisp_Object elt = XCAR (tail);
Karl Heuer's avatar
Karl Heuer committed
513 514

      if (CONSP (elt)
515 516 517 518
	  && CATEGORYP (XCAR (elt))
	  && CATEGORYP (XCDR (elt))
	  && CATEGORY_MEMBER (XFASTINT (XCAR (elt)), category_set1)
	  && CATEGORY_MEMBER (XFASTINT (XCDR (elt)), category_set2))
Karl Heuer's avatar
Karl Heuer committed
519 520 521 522 523 524
	return !default_result;
    }
  return default_result;
}


Andreas Schwab's avatar
Andreas Schwab committed
525
void
Karl Heuer's avatar
Karl Heuer committed
526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541
init_category_once ()
{
  /* This has to be done here, before we call Fmake_char_table.  */
  Qcategory_table = intern ("category-table");
  staticpro (&Qcategory_table);

  /* Intern this now in case it isn't already done.
     Setting this variable twice is harmless.
     But don't staticpro it here--that is done in alloc.c.  */
  Qchar_table_extra_slots = intern ("char-table-extra-slots");

  /* Now we are ready to set up this property, so we can
     create category tables.  */
  Fput (Qcategory_table, Qchar_table_extra_slots, make_number (2));

  Vstandard_category_table = Fmake_char_table (Qcategory_table, Qnil);
542
  /* Set a category set which contains nothing to the default.  */
Karl Heuer's avatar
Karl Heuer committed
543
  XCHAR_TABLE (Vstandard_category_table)->defalt = MAKE_CATEGORY_SET;
544
  Fset_char_table_extra_slot (Vstandard_category_table, make_number (0),
Karl Heuer's avatar
Karl Heuer committed
545 546 547
			      Fmake_vector (make_number (95), Qnil));
}

Andreas Schwab's avatar
Andreas Schwab committed
548
void
Karl Heuer's avatar
Karl Heuer committed
549 550 551 552 553 554 555 556 557 558
syms_of_category ()
{
  Qcategoryp = intern ("categoryp");
  staticpro (&Qcategoryp);
  Qcategorysetp = intern ("categorysetp");
  staticpro (&Qcategorysetp);
  Qcategory_table_p = intern ("category-table-p");
  staticpro (&Qcategory_table_p);

  DEFVAR_LISP ("word-combining-categories", &Vword_combining_categories,
559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591
	       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.  */);
Karl Heuer's avatar
Karl Heuer committed
592 593 594 595

  Vword_combining_categories = Qnil;

  DEFVAR_LISP ("word-separating-categories", &Vword_separating_categories,
596 597
	       doc: /* List of pair (cons) of categories to determine word boundary.
See the documentation of the variable `word-combining-categories'.  */);
Karl Heuer's avatar
Karl Heuer committed
598 599 600 601 602 603 604 605 606 607 608

  Vword_separating_categories = Qnil;

  defsubr (&Smake_category_set);
  defsubr (&Sdefine_category);
  defsubr (&Scategory_docstring);
  defsubr (&Sget_unused_category);
  defsubr (&Scategory_table_p);
  defsubr (&Scategory_table);
  defsubr (&Sstandard_category_table);
  defsubr (&Scopy_category_table);
609
  defsubr (&Smake_category_table);
Karl Heuer's avatar
Karl Heuer committed
610 611 612 613 614 615 616
  defsubr (&Sset_category_table);
  defsubr (&Schar_category_set);
  defsubr (&Scategory_set_mnemonics);
  defsubr (&Smodify_category_entry);

  category_table_version = 0;
}
Miles Bader's avatar
Miles Bader committed
617 618 619

/* arch-tag: 74ebf524-121b-4d9c-bd68-07f8d708b211
   (do not change this comment) */