- Merge Big5 code points.

[chise/xemacs-chise.git-] / src / chartab.c

diff --git a/src/chartab.c b/src/chartab.c
index 43f7849..e90bb3d 100644 (file)
--- a/src/chartab.c
+++ b/src/chartab.c
@@ -37,7 +37,6 @@ Boston, MA 02111-1307, USA.  */
 
 #include <config.h>
 #include "lisp.h"
 
 #include <config.h>
 #include "lisp.h"

-#include <stddef.h>

 
 #include "buffer.h"
 #include "chartab.h"
 
 #include "buffer.h"
 #include "chartab.h"

@@ -96,14 +95,14 @@ Lisp_Object Vword_combining_categories, Vword_separating_categories;
 #ifdef MULE
 
 static Lisp_Object
 #ifdef MULE
 
 static Lisp_Object

-mark_char_table_entry (Lisp_Object obj, void (*markobj) (Lisp_Object))
+mark_char_table_entry (Lisp_Object obj)

 {
 {

-  struct Lisp_Char_Table_Entry *cte = XCHAR_TABLE_ENTRY (obj);
+  Lisp_Char_Table_Entry *cte = XCHAR_TABLE_ENTRY (obj);

   int i;
 
   for (i = 0; i < 96; i++)
     {
   int i;
 
   for (i = 0; i < 96; i++)
     {

-      markobj (cte->level2[i]);
+      mark_object (cte->level2[i]);

     }
   return Qnil;
 }
     }
   return Qnil;
 }

@@ -111,8 +110,8 @@ mark_char_table_entry (Lisp_Object obj, void (*markobj) (Lisp_Object))
 static int
 char_table_entry_equal (Lisp_Object obj1, Lisp_Object obj2, int depth)
 {
 static int
 char_table_entry_equal (Lisp_Object obj1, Lisp_Object obj2, int depth)
 {

-  struct Lisp_Char_Table_Entry *cte1 = XCHAR_TABLE_ENTRY (obj1);
-  struct Lisp_Char_Table_Entry *cte2 = XCHAR_TABLE_ENTRY (obj2);
+  Lisp_Char_Table_Entry *cte1 = XCHAR_TABLE_ENTRY (obj1);
+  Lisp_Char_Table_Entry *cte2 = XCHAR_TABLE_ENTRY (obj2);

   int i;
 
   for (i = 0; i < 96; i++)
   int i;
 
   for (i = 0; i < 96; i++)

@@ -125,13 +124,13 @@ char_table_entry_equal (Lisp_Object obj1, Lisp_Object obj2, int depth)
 static unsigned long
 char_table_entry_hash (Lisp_Object obj, int depth)
 {
 static unsigned long
 char_table_entry_hash (Lisp_Object obj, int depth)
 {

-  struct Lisp_Char_Table_Entry *cte = XCHAR_TABLE_ENTRY (obj);
+  Lisp_Char_Table_Entry *cte = XCHAR_TABLE_ENTRY (obj);

 
   return internal_array_hash (cte->level2, 96, depth);
 }
 
 static const struct lrecord_description char_table_entry_description[] = {
 
   return internal_array_hash (cte->level2, 96, depth);
 }
 
 static const struct lrecord_description char_table_entry_description[] = {

-  { XD_LISP_OBJECT, offsetof(struct Lisp_Char_Table_Entry, level2), 96 },
+  { XD_LISP_OBJECT_ARRAY, offsetof (Lisp_Char_Table_Entry, level2), 96 },

   { XD_END }
 };
 
   { XD_END }
 };
 

@@ -140,20 +139,20 @@ DEFINE_LRECORD_IMPLEMENTATION ("char-table-entry", char_table_entry,
                               0, char_table_entry_equal,
                               char_table_entry_hash,
                               char_table_entry_description,
                               0, char_table_entry_equal,
                               char_table_entry_hash,
                               char_table_entry_description,

-                              struct Lisp_Char_Table_Entry);
+                              Lisp_Char_Table_Entry);

 #endif /* MULE */
 
 static Lisp_Object
 #endif /* MULE */
 
 static Lisp_Object

-mark_char_table (Lisp_Object obj, void (*markobj) (Lisp_Object))
+mark_char_table (Lisp_Object obj)

 {
 {

-  struct Lisp_Char_Table *ct = XCHAR_TABLE (obj);
+  Lisp_Char_Table *ct = XCHAR_TABLE (obj);

   int i;
 
   for (i = 0; i < NUM_ASCII_CHARS; i++)
   int i;
 
   for (i = 0; i < NUM_ASCII_CHARS; i++)

-    markobj (ct->ascii[i]);
+    mark_object (ct->ascii[i]);

 #ifdef MULE
   for (i = 0; i < NUM_LEADING_BYTES; i++)
 #ifdef MULE
   for (i = 0; i < NUM_LEADING_BYTES; i++)

-    markobj (ct->level1[i]);
+    mark_object (ct->level1[i]);

 #endif
   return ct->mirror_table;
 }
 #endif
   return ct->mirror_table;
 }

@@ -163,18 +162,18 @@ mark_char_table (Lisp_Object obj, void (*markobj) (Lisp_Object))
    and prune_weak_hash_tables(). */
 
 void
    and prune_weak_hash_tables(). */
 
 void

-prune_syntax_tables (int (*obj_marked_p) (Lisp_Object))
+prune_syntax_tables (void)

 {
   Lisp_Object rest, prev = Qnil;
 
   for (rest = Vall_syntax_tables;
 {
   Lisp_Object rest, prev = Qnil;
 
   for (rest = Vall_syntax_tables;

-       !GC_NILP (rest);
+       !NILP (rest);

        rest = XCHAR_TABLE (rest)->next_table)
     {
        rest = XCHAR_TABLE (rest)->next_table)
     {

-      if (! obj_marked_p (rest))
+      if (! marked_p (rest))

        {
          /* This table is garbage.  Remove it from the list. */
        {
          /* This table is garbage.  Remove it from the list. */

-         if (GC_NILP (prev))
+         if (NILP (prev))

            Vall_syntax_tables = XCHAR_TABLE (rest)->next_table;
          else
            XCHAR_TABLE (prev)->next_table =
            Vall_syntax_tables = XCHAR_TABLE (rest)->next_table;
          else
            XCHAR_TABLE (prev)->next_table =

@@ -242,7 +241,7 @@ print_chartab_range (Emchar first, Emchar last, Lisp_Object val,
 static void
 print_chartab_charset_row (Lisp_Object charset,
                           int row,
 static void
 print_chartab_charset_row (Lisp_Object charset,
                           int row,

-                          struct Lisp_Char_Table_Entry *cte,
+                          Lisp_Char_Table_Entry *cte,

                           Lisp_Object printcharfun)
 {
   int i;
                           Lisp_Object printcharfun)
 {
   int i;

@@ -290,7 +289,7 @@ print_chartab_charset_row (Lisp_Object charset,
 
 static void
 print_chartab_two_byte_charset (Lisp_Object charset,
 
 static void
 print_chartab_two_byte_charset (Lisp_Object charset,

-                               struct Lisp_Char_Table_Entry *cte,
+                               Lisp_Char_Table_Entry *cte,

                                Lisp_Object printcharfun)
 {
   int i;
                                Lisp_Object printcharfun)
 {
   int i;

@@ -320,7 +319,7 @@ print_chartab_two_byte_charset (Lisp_Object charset,
 static void
 print_char_table (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
 {
 static void
 print_char_table (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
 {

-  struct Lisp_Char_Table *ct = XCHAR_TABLE (obj);
+  Lisp_Char_Table *ct = XCHAR_TABLE (obj);

   char buf[200];
 
   sprintf (buf, "#s(char-table type %s data (",
   char buf[200];
 
   sprintf (buf, "#s(char-table type %s data (",

@@ -357,7 +356,7 @@ print_char_table (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
 
 #ifdef MULE
   {
 
 #ifdef MULE
   {

-    int i;
+    Charset_ID i;

 
     for (i = MIN_LEADING_BYTE; i < MIN_LEADING_BYTE + NUM_LEADING_BYTES;
         i++)
 
     for (i = MIN_LEADING_BYTE; i < MIN_LEADING_BYTE + NUM_LEADING_BYTES;
         i++)

@@ -378,7 +377,7 @@ print_char_table (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
          }
        else
          {
          }
        else
          {

-           struct Lisp_Char_Table_Entry *cte = XCHAR_TABLE_ENTRY (ann);
+           Lisp_Char_Table_Entry *cte = XCHAR_TABLE_ENTRY (ann);

            if (XCHARSET_DIMENSION (charset) == 1)
              print_chartab_charset_row (charset, -1, cte, printcharfun);
            else
            if (XCHARSET_DIMENSION (charset) == 1)
              print_chartab_charset_row (charset, -1, cte, printcharfun);
            else

@@ -394,8 +393,8 @@ print_char_table (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
 static int
 char_table_equal (Lisp_Object obj1, Lisp_Object obj2, int depth)
 {
 static int
 char_table_equal (Lisp_Object obj1, Lisp_Object obj2, int depth)
 {

-  struct Lisp_Char_Table *ct1 = XCHAR_TABLE (obj1);
-  struct Lisp_Char_Table *ct2 = XCHAR_TABLE (obj2);
+  Lisp_Char_Table *ct1 = XCHAR_TABLE (obj1);
+  Lisp_Char_Table *ct2 = XCHAR_TABLE (obj2);

   int i;
 
   if (CHAR_TABLE_TYPE (ct1) != CHAR_TABLE_TYPE (ct2))
   int i;
 
   if (CHAR_TABLE_TYPE (ct1) != CHAR_TABLE_TYPE (ct2))

@@ -417,7 +416,7 @@ char_table_equal (Lisp_Object obj1, Lisp_Object obj2, int depth)
 static unsigned long
 char_table_hash (Lisp_Object obj, int depth)
 {
 static unsigned long
 char_table_hash (Lisp_Object obj, int depth)
 {

-  struct Lisp_Char_Table *ct = XCHAR_TABLE (obj);
+  Lisp_Char_Table *ct = XCHAR_TABLE (obj);

   unsigned long hashval = internal_array_hash (ct->ascii, NUM_ASCII_CHARS,
                                               depth);
 #ifdef MULE
   unsigned long hashval = internal_array_hash (ct->ascii, NUM_ASCII_CHARS,
                                               depth);
 #ifdef MULE

@@ -428,10 +427,12 @@ char_table_hash (Lisp_Object obj, int depth)
 }
 
 static const struct lrecord_description char_table_description[] = {
 }
 
 static const struct lrecord_description char_table_description[] = {

-  { XD_LISP_OBJECT, offsetof(struct Lisp_Char_Table, ascii), NUM_ASCII_CHARS },
+  { XD_LISP_OBJECT_ARRAY, offsetof (Lisp_Char_Table, ascii), NUM_ASCII_CHARS },

 #ifdef MULE
 #ifdef MULE

-  { XD_LISP_OBJECT, offsetof(struct Lisp_Char_Table, level1), NUM_LEADING_BYTES },
+  { XD_LISP_OBJECT_ARRAY, offsetof (Lisp_Char_Table, level1), NUM_LEADING_BYTES },

 #endif
 #endif

+  { XD_LISP_OBJECT, offsetof (Lisp_Char_Table, mirror_table) },
+  { XD_LO_LINK,     offsetof (Lisp_Char_Table, next_table) },

   { XD_END }
 };
 
   { XD_END }
 };
 

@@ -439,7 +440,7 @@ DEFINE_LRECORD_IMPLEMENTATION ("char-table", char_table,
                                mark_char_table, print_char_table, 0,
                               char_table_equal, char_table_hash,
                               char_table_description,
                                mark_char_table, print_char_table, 0,
                               char_table_equal, char_table_hash,
                               char_table_description,

-                              struct Lisp_Char_Table);
+                              Lisp_Char_Table);

 
 DEFUN ("char-table-p", Fchar_table_p, 1, 1, 0, /*
 Return non-nil if OBJECT is a char table.
 
 DEFUN ("char-table-p", Fchar_table_p, 1, 1, 0, /*
 Return non-nil if OBJECT is a char table.

@@ -467,12 +468,12 @@ assigned values are
 -- all characters
 -- a single character
 
 -- all characters
 -- a single character
 

-To create a char table, use `make-char-table'.  To modify a char
-table, use `put-char-table' or `remove-char-table'.  To retrieve the
-value for a particular character, use `get-char-table'.  See also
-`map-char-table', `clear-char-table', `copy-char-table',
-`valid-char-table-type-p', `char-table-type-list', `valid-char-table-value-p',
-and `check-char-table-value'.
+To create a char table, use `make-char-table'.
+To modify a char table, use `put-char-table' or `remove-char-table'.
+To retrieve the value for a particular character, use `get-char-table'.
+See also `map-char-table', `clear-char-table', `copy-char-table',
+`valid-char-table-type-p', `char-table-type-list',
+`valid-char-table-value-p', and `check-char-table-value'.

 */
        (object))
 {
 */
        (object))
 {

@@ -532,17 +533,17 @@ sorts of values.  The different char table types are
 }
 
 DEFUN ("char-table-type", Fchar_table_type, 1, 1, 0, /*
 }
 
 DEFUN ("char-table-type", Fchar_table_type, 1, 1, 0, /*

-Return the type of char table TABLE.
+Return the type of CHAR-TABLE.

 See `valid-char-table-type-p'.
 */
 See `valid-char-table-type-p'.
 */

-       (table))
+       (char_table))

 {
 {

-  CHECK_CHAR_TABLE (table);
-  return char_table_type_to_symbol (XCHAR_TABLE (table)->type);
+  CHECK_CHAR_TABLE (char_table);
+  return char_table_type_to_symbol (XCHAR_TABLE (char_table)->type);

 }
 
 void
 }
 
 void

-fill_char_table (struct Lisp_Char_Table *ct, Lisp_Object value)
+fill_char_table (Lisp_Char_Table *ct, Lisp_Object value)

 {
   int i;
 
 {
   int i;
 

@@ -558,14 +559,14 @@ fill_char_table (struct Lisp_Char_Table *ct, Lisp_Object value)
 }
 
 DEFUN ("reset-char-table", Freset_char_table, 1, 1, 0, /*
 }
 
 DEFUN ("reset-char-table", Freset_char_table, 1, 1, 0, /*

-Reset a char table to its default state.
+Reset CHAR-TABLE to its default state.

 */
 */

-       (table))
+       (char_table))

 {
 {

-  struct Lisp_Char_Table *ct;
+  Lisp_Char_Table *ct;

 
 

-  CHECK_CHAR_TABLE (table);
-  ct = XCHAR_TABLE (table);
+  CHECK_CHAR_TABLE (char_table);
+  ct = XCHAR_TABLE (char_table);

 
   switch (ct->type)
     {
 
   switch (ct->type)
     {

@@ -598,11 +599,11 @@ and 'syntax.  See `valid-char-table-type-p'.
 */
        (type))
 {
 */
        (type))
 {

-  struct Lisp_Char_Table *ct;
+  Lisp_Char_Table *ct;

   Lisp_Object obj;
   enum char_table_type ty = symbol_to_char_table_type (type);
 
   Lisp_Object obj;
   enum char_table_type ty = symbol_to_char_table_type (type);
 

-  ct = alloc_lcrecord_type (struct Lisp_Char_Table, &lrecord_char_table);
+  ct = alloc_lcrecord_type (Lisp_Char_Table, &lrecord_char_table);

   ct->type = ty;
   if (ty == CHAR_TABLE_TYPE_SYNTAX)
     {
   ct->type = ty;
   if (ty == CHAR_TABLE_TYPE_SYNTAX)
     {

@@ -630,9 +631,8 @@ make_char_table_entry (Lisp_Object initval)
 {
   Lisp_Object obj;
   int i;
 {
   Lisp_Object obj;
   int i;

-  struct Lisp_Char_Table_Entry *cte =
-    alloc_lcrecord_type (struct Lisp_Char_Table_Entry,
-                        &lrecord_char_table_entry);
+  Lisp_Char_Table_Entry *cte =
+    alloc_lcrecord_type (Lisp_Char_Table_Entry, &lrecord_char_table_entry);

 
   for (i = 0; i < 96; i++)
     cte->level2[i] = initval;
 
   for (i = 0; i < 96; i++)
     cte->level2[i] = initval;

@@ -644,12 +644,11 @@ make_char_table_entry (Lisp_Object initval)
 static Lisp_Object
 copy_char_table_entry (Lisp_Object entry)
 {
 static Lisp_Object
 copy_char_table_entry (Lisp_Object entry)
 {

-  struct Lisp_Char_Table_Entry *cte = XCHAR_TABLE_ENTRY (entry);
+  Lisp_Char_Table_Entry *cte = XCHAR_TABLE_ENTRY (entry);

   Lisp_Object obj;
   int i;
   Lisp_Object obj;
   int i;

-  struct Lisp_Char_Table_Entry *ctenew =
-    alloc_lcrecord_type (struct Lisp_Char_Table_Entry,
-                        &lrecord_char_table_entry);
+  Lisp_Char_Table_Entry *ctenew =
+    alloc_lcrecord_type (Lisp_Char_Table_Entry, &lrecord_char_table_entry);

 
   for (i = 0; i < 96; i++)
     {
 
   for (i = 0; i < 96; i++)
     {

@@ -667,19 +666,19 @@ copy_char_table_entry (Lisp_Object entry)
 #endif /* MULE */
 
 DEFUN ("copy-char-table", Fcopy_char_table, 1, 1, 0, /*
 #endif /* MULE */
 
 DEFUN ("copy-char-table", Fcopy_char_table, 1, 1, 0, /*

-Make a new char table which is a copy of OLD-TABLE.
+Return a new char table which is a copy of CHAR-TABLE.

 It will contain the same values for the same characters and ranges
 It will contain the same values for the same characters and ranges

-as OLD-TABLE.  The values will not themselves be copied.
+as CHAR-TABLE.  The values will not themselves be copied.

 */
 */

-       (old_table))
+       (char_table))

 {
 {

-  struct Lisp_Char_Table *ct, *ctnew;
+  Lisp_Char_Table *ct, *ctnew;

   Lisp_Object obj;
   int i;
 
   Lisp_Object obj;
   int i;
 

-  CHECK_CHAR_TABLE (old_table);
-  ct = XCHAR_TABLE (old_table);
-  ctnew = alloc_lcrecord_type (struct Lisp_Char_Table, &lrecord_char_table);
+  CHECK_CHAR_TABLE (char_table);
+  ct = XCHAR_TABLE (char_table);
+  ctnew = alloc_lcrecord_type (Lisp_Char_Table, &lrecord_char_table);

   ctnew->type = ct->type;
 
   for (i = 0; i < NUM_ASCII_CHARS; i++)
   ctnew->type = ct->type;
 
   for (i = 0; i < NUM_ASCII_CHARS; i++)

@@ -708,7 +707,13 @@ as OLD-TABLE.  The values will not themselves be copied.
     ctnew->mirror_table = Fcopy_char_table (ct->mirror_table);
   else
     ctnew->mirror_table = ct->mirror_table;
     ctnew->mirror_table = Fcopy_char_table (ct->mirror_table);
   else
     ctnew->mirror_table = ct->mirror_table;

+  ctnew->next_table = Qnil;

   XSETCHAR_TABLE (obj, ctnew);
   XSETCHAR_TABLE (obj, ctnew);

+  if (ctnew->type == CHAR_TABLE_TYPE_SYNTAX)
+    {
+      ctnew->next_table = Vall_syntax_tables;
+      Vall_syntax_tables = obj;
+    }

   return obj;
 }
 
   return obj;
 }
 

@@ -728,7 +733,7 @@ decode_char_table_range (Lisp_Object range, struct chartab_range *outrange)
 #else /* MULE */
   else if (VECTORP (range))
     {
 #else /* MULE */
   else if (VECTORP (range))
     {

-      struct Lisp_Vector *vec = XVECTOR (range);
+      Lisp_Vector *vec = XVECTOR (range);

       Lisp_Object *elts = vector_data (vec);
       if (vector_length (vec) != 2)
        signal_simple_error ("Length of charset row vector must be 2",
       Lisp_Object *elts = vector_data (vec);
       if (vector_length (vec) != 2)
        signal_simple_error ("Length of charset row vector must be 2",

@@ -737,21 +742,23 @@ decode_char_table_range (Lisp_Object range, struct chartab_range *outrange)
       outrange->charset = Fget_charset (elts[0]);
       CHECK_INT (elts[1]);
       outrange->row = XINT (elts[1]);
       outrange->charset = Fget_charset (elts[0]);
       CHECK_INT (elts[1]);
       outrange->row = XINT (elts[1]);

-      switch (XCHARSET_TYPE (outrange->charset))
+      if (XCHARSET_DIMENSION (outrange->charset) >= 2)

        {
        {

-       case CHARSET_TYPE_94:
-       case CHARSET_TYPE_96:
-         signal_simple_error ("Charset in row vector must be multi-byte",
-                              outrange->charset);
-       case CHARSET_TYPE_94X94:
-         check_int_range (outrange->row, 33, 126);
-         break;
-       case CHARSET_TYPE_96X96:
-         check_int_range (outrange->row, 32, 127);
-         break;
-       default:
-         abort ();
+         switch (XCHARSET_CHARS (outrange->charset))
+           {
+           case 94:
+             check_int_range (outrange->row, 33, 126);
+             break;
+           case 96:
+             check_int_range (outrange->row, 32, 127);
+             break;
+           default:
+             abort ();
+           }

        }
        }

+      else
+       signal_simple_error ("Charset in row vector must be multi-byte",
+                            outrange->charset);  

     }
   else
     {
     }
   else
     {

@@ -768,18 +775,26 @@ decode_char_table_range (Lisp_Object range, struct chartab_range *outrange)
 
 /* called from CHAR_TABLE_VALUE(). */
 Lisp_Object
 
 /* called from CHAR_TABLE_VALUE(). */
 Lisp_Object

-get_non_ascii_char_table_value (struct Lisp_Char_Table *ct, int leading_byte,
+get_non_ascii_char_table_value (Lisp_Char_Table *ct, Charset_ID leading_byte,

                               Emchar c)
 {
   Lisp_Object val;
                               Emchar c)
 {
   Lisp_Object val;

+#ifdef UTF2000
+  Lisp_Object charset;
+#else

   Lisp_Object charset = CHARSET_BY_LEADING_BYTE (leading_byte);
   Lisp_Object charset = CHARSET_BY_LEADING_BYTE (leading_byte);

+#endif

   int byte1, byte2;
 
   int byte1, byte2;
 

+#ifdef UTF2000
+  BREAKUP_CHAR (c, charset, byte1, byte2);
+#else

   BREAKUP_CHAR_1_UNSAFE (c, charset, byte1, byte2);
   BREAKUP_CHAR_1_UNSAFE (c, charset, byte1, byte2);

+#endif

   val = ct->level1[leading_byte - MIN_LEADING_BYTE];
   if (CHAR_TABLE_ENTRYP (val))
     {
   val = ct->level1[leading_byte - MIN_LEADING_BYTE];
   if (CHAR_TABLE_ENTRYP (val))
     {

-      struct Lisp_Char_Table_Entry *cte = XCHAR_TABLE_ENTRY (val);
+      Lisp_Char_Table_Entry *cte = XCHAR_TABLE_ENTRY (val);

       val = cte->level2[byte1 - 32];
       if (CHAR_TABLE_ENTRYP (val))
        {
       val = cte->level2[byte1 - 32];
       if (CHAR_TABLE_ENTRYP (val))
        {

@@ -796,7 +811,7 @@ get_non_ascii_char_table_value (struct Lisp_Char_Table *ct, int leading_byte,
 #endif /* MULE */
 
 Lisp_Object
 #endif /* MULE */
 
 Lisp_Object

-get_char_table (Emchar ch, struct Lisp_Char_Table *ct)
+get_char_table (Emchar ch, Lisp_Char_Table *ct)

 {
 #ifdef MULE
   {
 {
 #ifdef MULE
   {

@@ -816,7 +831,7 @@ get_char_table (Emchar ch, struct Lisp_Char_Table *ct)
        val = ct->level1[lb];
        if (CHAR_TABLE_ENTRYP (val))
          {
        val = ct->level1[lb];
        if (CHAR_TABLE_ENTRYP (val))
          {

-           struct Lisp_Char_Table_Entry *cte = XCHAR_TABLE_ENTRY (val);
+           Lisp_Char_Table_Entry *cte = XCHAR_TABLE_ENTRY (val);

            val = cte->level2[byte1 - 32];
            if (CHAR_TABLE_ENTRYP (val))
              {
            val = cte->level2[byte1 - 32];
            if (CHAR_TABLE_ENTRYP (val))
              {

@@ -837,32 +852,29 @@ get_char_table (Emchar ch, struct Lisp_Char_Table *ct)
 
 
 DEFUN ("get-char-table", Fget_char_table, 2, 2, 0, /*
 
 
 DEFUN ("get-char-table", Fget_char_table, 2, 2, 0, /*

-Find value for char CH in TABLE.
+Find value for CHARACTER in CHAR-TABLE.

 */
 */

-       (ch, table))
+       (character, char_table))

 {
 {

-  struct Lisp_Char_Table *ct;
-
-  CHECK_CHAR_TABLE (table);
-  ct = XCHAR_TABLE (table);
-  CHECK_CHAR_COERCE_INT (ch);
+  CHECK_CHAR_TABLE (char_table);
+  CHECK_CHAR_COERCE_INT (character);

 
 

-  return get_char_table (XCHAR (ch), ct);
+  return get_char_table (XCHAR (character), XCHAR_TABLE (char_table));

 }
 
 DEFUN ("get-range-char-table", Fget_range_char_table, 2, 3, 0, /*
 }
 
 DEFUN ("get-range-char-table", Fget_range_char_table, 2, 3, 0, /*

-Find value for a range in TABLE.
+Find value for a range in CHAR-TABLE.

 If there is more than one value, return MULTI (defaults to nil).
 */
 If there is more than one value, return MULTI (defaults to nil).
 */

-       (range, table, multi))
+       (range, char_table, multi))

 {
 {

-  struct Lisp_Char_Table *ct;
+  Lisp_Char_Table *ct;

   struct chartab_range rainj;
 
   if (CHAR_OR_CHAR_INTP (range))
   struct chartab_range rainj;
 
   if (CHAR_OR_CHAR_INTP (range))

-    return Fget_char_table (range, table);
-  CHECK_CHAR_TABLE (table);
-  ct = XCHAR_TABLE (table);
+    return Fget_char_table (range, char_table);
+  CHECK_CHAR_TABLE (char_table);
+  ct = XCHAR_TABLE (char_table);

 
   decode_char_table_range (range, &rainj);
   switch (rainj.type)
 
   decode_char_table_range (range, &rainj);
   switch (rainj.type)

@@ -1041,7 +1053,7 @@ Signal an error if VALUE is not a valid value for CHAR-TABLE-TYPE.
 /* Assign VAL to all characters in RANGE in char table CT. */
 
 void
 /* Assign VAL to all characters in RANGE in char table CT. */
 
 void

-put_char_table (struct Lisp_Char_Table *ct, struct chartab_range *range,
+put_char_table (Lisp_Char_Table *ct, struct chartab_range *range,

                Lisp_Object val)
 {
   switch (range->type)
                Lisp_Object val)
 {
   switch (range->type)

@@ -1074,7 +1086,7 @@ put_char_table (struct Lisp_Char_Table *ct, struct chartab_range *range,
 
     case CHARTAB_RANGE_ROW:
       {
 
     case CHARTAB_RANGE_ROW:
       {

-       struct Lisp_Char_Table_Entry *cte;
+       Lisp_Char_Table_Entry *cte;

        int lb = XCHARSET_LEADING_BYTE (range->charset) - MIN_LEADING_BYTE;
        /* make sure that there is a separate entry for the row. */
        if (!CHAR_TABLE_ENTRYP (ct->level1[lb]))
        int lb = XCHARSET_LEADING_BYTE (range->charset) - MIN_LEADING_BYTE;
        /* make sure that there is a separate entry for the row. */
        if (!CHAR_TABLE_ENTRYP (ct->level1[lb]))

@@ -1098,7 +1110,7 @@ put_char_table (struct Lisp_Char_Table *ct, struct chartab_range *range,
          ct->ascii[byte1 + 128] = val;
        else
          {
          ct->ascii[byte1 + 128] = val;
        else
          {

-           struct Lisp_Char_Table_Entry *cte;
+           Lisp_Char_Table_Entry *cte;

            int lb = XCHARSET_LEADING_BYTE (charset) - MIN_LEADING_BYTE;
            /* make sure that there is a separate entry for the row. */
            if (!CHAR_TABLE_ENTRYP (ct->level1[lb]))
            int lb = XCHARSET_LEADING_BYTE (charset) - MIN_LEADING_BYTE;
            /* make sure that there is a separate entry for the row. */
            if (!CHAR_TABLE_ENTRYP (ct->level1[lb]))

@@ -1133,7 +1145,7 @@ put_char_table (struct Lisp_Char_Table *ct, struct chartab_range *range,
 }
 
 DEFUN ("put-char-table", Fput_char_table, 3, 3, 0, /*
 }
 
 DEFUN ("put-char-table", Fput_char_table, 3, 3, 0, /*

-Set the value for chars in RANGE to be VAL in TABLE.
+Set the value for chars in RANGE to be VALUE in CHAR-TABLE.

 
 RANGE specifies one or more characters to be affected and should be
 one of the following:
 
 RANGE specifies one or more characters to be affected and should be
 one of the following:

@@ -1144,27 +1156,27 @@ one of the following:
    (only allowed when Mule support is present)
 -- A single character
 
    (only allowed when Mule support is present)
 -- A single character
 

-VAL must be a value appropriate for the type of TABLE.
+VALUE must be a value appropriate for the type of CHAR-TABLE.

 See `valid-char-table-type-p'.
 */
 See `valid-char-table-type-p'.
 */

-       (range, val, table))
+       (range, value, char_table))

 {
 {

-  struct Lisp_Char_Table *ct;
+  Lisp_Char_Table *ct;

   struct chartab_range rainj;
 
   struct chartab_range rainj;
 

-  CHECK_CHAR_TABLE (table);
-  ct = XCHAR_TABLE (table);
-  check_valid_char_table_value (val, ct->type, ERROR_ME);
+  CHECK_CHAR_TABLE (char_table);
+  ct = XCHAR_TABLE (char_table);
+  check_valid_char_table_value (value, ct->type, ERROR_ME);

   decode_char_table_range (range, &rainj);
   decode_char_table_range (range, &rainj);

-  val = canonicalize_char_table_value (val, ct->type);
-  put_char_table (ct, &rainj, val);
+  value = canonicalize_char_table_value (value, ct->type);
+  put_char_table (ct, &rainj, value);

   return Qnil;
 }
 
 /* Map FN over the ASCII chars in CT. */
 
 static int
   return Qnil;
 }
 
 /* Map FN over the ASCII chars in CT. */
 
 static int

-map_over_charset_ascii (struct Lisp_Char_Table *ct,
+map_over_charset_ascii (Lisp_Char_Table *ct,

                        int (*fn) (struct chartab_range *range,
                                   Lisp_Object val, void *arg),
                        void *arg)
                        int (*fn) (struct chartab_range *range,
                                   Lisp_Object val, void *arg),
                        void *arg)

@@ -1194,7 +1206,7 @@ map_over_charset_ascii (struct Lisp_Char_Table *ct,
 /* Map FN over the Control-1 chars in CT. */
 
 static int
 /* Map FN over the Control-1 chars in CT. */
 
 static int

-map_over_charset_control_1 (struct Lisp_Char_Table *ct,
+map_over_charset_control_1 (Lisp_Char_Table *ct,

                            int (*fn) (struct chartab_range *range,
                                       Lisp_Object val, void *arg),
                            void *arg)
                            int (*fn) (struct chartab_range *range,
                                       Lisp_Object val, void *arg),
                            void *arg)

@@ -1220,7 +1232,7 @@ map_over_charset_control_1 (struct Lisp_Char_Table *ct,
    CTE specifies the char table entry for CHARSET. */
 
 static int
    CTE specifies the char table entry for CHARSET. */
 
 static int

-map_over_charset_row (struct Lisp_Char_Table_Entry *cte,
+map_over_charset_row (Lisp_Char_Table_Entry *cte,

                      Lisp_Object charset, int row,
                      int (*fn) (struct chartab_range *range,
                                 Lisp_Object val, void *arg),
                      Lisp_Object charset, int row,
                      int (*fn) (struct chartab_range *range,
                                 Lisp_Object val, void *arg),

@@ -1260,7 +1272,7 @@ map_over_charset_row (struct Lisp_Char_Table_Entry *cte,
 
 
 static int
 
 
 static int

-map_over_other_charset (struct Lisp_Char_Table *ct, int lb,
+map_over_other_charset (Lisp_Char_Table *ct, Charset_ID lb,

                        int (*fn) (struct chartab_range *range,
                                   Lisp_Object val, void *arg),
                        void *arg)
                        int (*fn) (struct chartab_range *range,
                                   Lisp_Object val, void *arg),
                        void *arg)

@@ -1283,7 +1295,7 @@ map_over_other_charset (struct Lisp_Char_Table *ct, int lb,
     }
 
   {
     }
 
   {

-    struct Lisp_Char_Table_Entry *cte = XCHAR_TABLE_ENTRY (val);
+    Lisp_Char_Table_Entry *cte = XCHAR_TABLE_ENTRY (val);

     int charset94_p = (XCHARSET_CHARS (charset) == 94);
     int start = charset94_p ?  33 :  32;
     int stop  = charset94_p ? 127 : 128;
     int charset94_p = (XCHARSET_CHARS (charset) == 94);
     int start = charset94_p ?  33 :  32;
     int stop  = charset94_p ? 127 : 128;

@@ -1317,7 +1329,7 @@ map_over_other_charset (struct Lisp_Char_Table *ct, int lb,
    becomes the return value of map_char_table(). */
 
 int
    becomes the return value of map_char_table(). */
 
 int

-map_char_table (struct Lisp_Char_Table *ct,
+map_char_table (Lisp_Char_Table *ct,

                struct chartab_range *range,
                int (*fn) (struct chartab_range *range,
                           Lisp_Object val, void *arg),
                struct chartab_range *range,
                int (*fn) (struct chartab_range *range,
                           Lisp_Object val, void *arg),

@@ -1337,9 +1349,9 @@ map_char_table (struct Lisp_Char_Table *ct,
        if (retval)
          return retval;
        {
        if (retval)
          return retval;
        {

-         int i;
-         int start = MIN_LEADING_BYTE;
-         int stop  = start + NUM_LEADING_BYTES;
+         Charset_ID i;
+         Charset_ID start = MIN_LEADING_BYTE;
+         Charset_ID stop  = start + NUM_LEADING_BYTES;

 
          for (i = start, retval = 0; i < stop && retval == 0; i++)
            {
 
          for (i = start, retval = 0; i < stop && retval == 0; i++)
            {

@@ -1358,7 +1370,8 @@ map_char_table (struct Lisp_Char_Table *ct,
 
     case CHARTAB_RANGE_ROW:
       {
 
     case CHARTAB_RANGE_ROW:
       {

-       Lisp_Object val = ct->level1[XCHARSET_LEADING_BYTE (range->charset) - MIN_LEADING_BYTE];
+       Lisp_Object val = ct->level1[XCHARSET_LEADING_BYTE (range->charset)
+                                   - MIN_LEADING_BYTE];

        if (!CHAR_TABLE_ENTRYP (val))
          {
            struct chartab_range rainj;
        if (!CHAR_TABLE_ENTRYP (val))
          {
            struct chartab_range rainj;

@@ -1435,22 +1448,22 @@ slow_map_char_table_fun (struct chartab_range *range,
 }
 
 DEFUN ("map-char-table", Fmap_char_table, 2, 3, 0, /*
 }
 
 DEFUN ("map-char-table", Fmap_char_table, 2, 3, 0, /*

-Map FUNCTION over entries in TABLE, calling it with two args,
+Map FUNCTION over entries in CHAR-TABLE, calling it with two args,

 each key and value in the table.
 
 RANGE specifies a subrange to map over and is in the same format as
 the RANGE argument to `put-range-table'.  If omitted or t, it defaults to
 the entire table.
 */
 each key and value in the table.
 
 RANGE specifies a subrange to map over and is in the same format as
 the RANGE argument to `put-range-table'.  If omitted or t, it defaults to
 the entire table.
 */

-       (function, table, range))
+       (function, char_table, range))

 {
 {

-  struct Lisp_Char_Table *ct;
+  Lisp_Char_Table *ct;

   struct slow_map_char_table_arg slarg;
   struct gcpro gcpro1, gcpro2;
   struct chartab_range rainj;
 
   struct slow_map_char_table_arg slarg;
   struct gcpro gcpro1, gcpro2;
   struct chartab_range rainj;
 

-  CHECK_CHAR_TABLE (table);
-  ct = XCHAR_TABLE (table);
+  CHECK_CHAR_TABLE (char_table);
+  ct = XCHAR_TABLE (char_table);

   if (NILP (range))
     range = Qt;
   decode_char_table_range (range, &rainj);
   if (NILP (range))
     range = Qt;
   decode_char_table_range (range, &rainj);

@@ -1567,7 +1580,7 @@ chartab_instantiate (Lisp_Object data)
 /************************************************************************/
 
 DEFUN ("category-table-p", Fcategory_table_p, 1, 1, 0, /*
 /************************************************************************/
 
 DEFUN ("category-table-p", Fcategory_table_p, 1, 1, 0, /*

-Return t if ARG is a category table.
+Return t if OBJECT is a category table.

 A category table is a type of char table used for keeping track of
 categories.  Categories are used for classifying characters for use
 in regexps -- you can refer to a category rather than having to use
 A category table is a type of char table used for keeping track of
 categories.  Categories are used for classifying characters for use
 in regexps -- you can refer to a category rather than having to use

@@ -1590,21 +1603,21 @@ whether the character is in that category.
 Special Lisp functions are provided that abstract this, so you do not
 have to directly manipulate bit vectors.
 */
 Special Lisp functions are provided that abstract this, so you do not
 have to directly manipulate bit vectors.
 */

-       (obj))
+       (object))

 {
 {

-  return (CHAR_TABLEP (obj) &&
-         XCHAR_TABLE_TYPE (obj) == CHAR_TABLE_TYPE_CATEGORY) ?
+  return (CHAR_TABLEP (object) &&
+         XCHAR_TABLE_TYPE (object) == CHAR_TABLE_TYPE_CATEGORY) ?

     Qt : Qnil;
 }
 
 static Lisp_Object
     Qt : Qnil;
 }
 
 static Lisp_Object

-check_category_table (Lisp_Object obj, Lisp_Object def)
+check_category_table (Lisp_Object object, Lisp_Object default_)

 {
 {

-  if (NILP (obj))
-    obj = def;
-  while (NILP (Fcategory_table_p (obj)))
-    obj = wrong_type_argument (Qcategory_table_p, obj);
-  return obj;
+  if (NILP (object))
+    object = default_;
+  while (NILP (Fcategory_table_p (object)))
+    object = wrong_type_argument (Qcategory_table_p, object);
+  return object;

 }
 
 int
 }
 
 int

@@ -1612,7 +1625,7 @@ check_category_char (Emchar ch, Lisp_Object table,
                     unsigned int designator, unsigned int not)
 {
   REGISTER Lisp_Object temp;
                     unsigned int designator, unsigned int not)
 {
   REGISTER Lisp_Object temp;

-  struct Lisp_Char_Table *ctbl;
+  Lisp_Char_Table *ctbl;

 #ifdef ERROR_CHECK_TYPECHECK
   if (NILP (Fcategory_table_p (table)))
     signal_simple_error ("Expected category table", table);
 #ifdef ERROR_CHECK_TYPECHECK
   if (NILP (Fcategory_table_p (table)))
     signal_simple_error ("Expected category table", table);

@@ -1627,32 +1640,33 @@ check_category_char (Emchar ch, Lisp_Object table,
 }
 
 DEFUN ("check-category-at", Fcheck_category_at, 2, 4, 0, /*
 }
 
 DEFUN ("check-category-at", Fcheck_category_at, 2, 4, 0, /*

-Return t if category of a character at POS includes DESIGNATOR,
-else return nil. Optional third arg specifies which buffer
-\(defaulting to current), and fourth specifies the CATEGORY-TABLE,
-\(defaulting to the buffer's category table).
+Return t if category of the character at POSITION includes DESIGNATOR.
+Optional third arg BUFFER specifies which buffer to use, and defaults
+to the current buffer.
+Optional fourth arg CATEGORY-TABLE specifies the category table to
+use, and defaults to BUFFER's category table.

 */
 */

-       (pos, designator, buffer, category_table))
+       (position, designator, buffer, category_table))

 {
   Lisp_Object ctbl;
   Emchar ch;
   unsigned int des;
   struct buffer *buf = decode_buffer (buffer, 0);
 
 {
   Lisp_Object ctbl;
   Emchar ch;
   unsigned int des;
   struct buffer *buf = decode_buffer (buffer, 0);
 

-  CHECK_INT (pos);
+  CHECK_INT (position);

   CHECK_CATEGORY_DESIGNATOR (designator);
   des = XCHAR (designator);
   ctbl = check_category_table (category_table, Vstandard_category_table);
   CHECK_CATEGORY_DESIGNATOR (designator);
   des = XCHAR (designator);
   ctbl = check_category_table (category_table, Vstandard_category_table);

-  ch = BUF_FETCH_CHAR (buf, XINT (pos));
+  ch = BUF_FETCH_CHAR (buf, XINT (position));

   return check_category_char (ch, ctbl, des, 0) ? Qt : Qnil;
 }
 
 DEFUN ("char-in-category-p", Fchar_in_category_p, 2, 3, 0, /*
   return check_category_char (ch, ctbl, des, 0) ? Qt : Qnil;
 }
 
 DEFUN ("char-in-category-p", Fchar_in_category_p, 2, 3, 0, /*

-Return t if category of character CHR includes DESIGNATOR, else nil.
-Optional third arg specifies the CATEGORY-TABLE to use,
-which defaults to the system default table.
+Return t if category of CHARACTER includes DESIGNATOR, else nil.
+Optional third arg CATEGORY-TABLE specifies the category table to use,
+and defaults to the standard category table.

 */
 */

-       (chr, designator, category_table))
+       (character, designator, category_table))

 {
   Lisp_Object ctbl;
   Emchar ch;
 {
   Lisp_Object ctbl;
   Emchar ch;

@@ -1660,16 +1674,15 @@ which defaults to the system default table.
 
   CHECK_CATEGORY_DESIGNATOR (designator);
   des = XCHAR (designator);
 
   CHECK_CATEGORY_DESIGNATOR (designator);
   des = XCHAR (designator);

-  CHECK_CHAR (chr);
-  ch = XCHAR (chr);
+  CHECK_CHAR (character);
+  ch = XCHAR (character);

   ctbl = check_category_table (category_table, Vstandard_category_table);
   return check_category_char (ch, ctbl, des, 0) ? Qt : Qnil;
 }
 
 DEFUN ("category-table", Fcategory_table, 0, 1, 0, /*
   ctbl = check_category_table (category_table, Vstandard_category_table);
   return check_category_char (ch, ctbl, des, 0) ? Qt : Qnil;
 }
 
 DEFUN ("category-table", Fcategory_table, 0, 1, 0, /*

-Return the current category table.
-This is the one specified by the current buffer, or by BUFFER if it
-is non-nil.
+Return BUFFER's current category table.
+BUFFER defaults to the current buffer.

 */
        (buffer))
 {
 */
        (buffer))
 {

@@ -1686,53 +1699,53 @@ This is the one used for new buffers.
 }
 
 DEFUN ("copy-category-table", Fcopy_category_table, 0, 1, 0, /*
 }
 
 DEFUN ("copy-category-table", Fcopy_category_table, 0, 1, 0, /*

-Construct a new category table and return it.
-It is a copy of the TABLE, which defaults to the standard category table.
+Return a new category table which is a copy of CATEGORY-TABLE.
+CATEGORY-TABLE defaults to the standard category table.

 */
 */

-       (table))
+       (category_table))

 {
   if (NILP (Vstandard_category_table))
     return Fmake_char_table (Qcategory);
 
 {
   if (NILP (Vstandard_category_table))
     return Fmake_char_table (Qcategory);
 

-  table = check_category_table (table, Vstandard_category_table);
-  return Fcopy_char_table (table);
+  category_table =
+    check_category_table (category_table, Vstandard_category_table);
+  return Fcopy_char_table (category_table);

 }
 
 DEFUN ("set-category-table", Fset_category_table, 1, 2, 0, /*
 }
 
 DEFUN ("set-category-table", Fset_category_table, 1, 2, 0, /*

-Select a new category table for BUFFER.
-One argument, a category table.
+Select CATEGORY-TABLE as the new category table for BUFFER.

 BUFFER defaults to the current buffer if omitted.
 */
 BUFFER defaults to the current buffer if omitted.
 */

-       (table, buffer))
+       (category_table, buffer))

 {
   struct buffer *buf = decode_buffer (buffer, 0);
 {
   struct buffer *buf = decode_buffer (buffer, 0);

-  table = check_category_table (table, Qnil);
-  buf->category_table = table;
+  category_table = check_category_table (category_table, Qnil);
+  buf->category_table = category_table;

   /* Indicate that this buffer now has a specified category table.  */
   buf->local_var_flags |= XINT (buffer_local_flags.category_table);
   /* Indicate that this buffer now has a specified category table.  */
   buf->local_var_flags |= XINT (buffer_local_flags.category_table);

-  return table;
+  return category_table;

 }
 
 DEFUN ("category-designator-p", Fcategory_designator_p, 1, 1, 0, /*
 }
 
 DEFUN ("category-designator-p", Fcategory_designator_p, 1, 1, 0, /*

-Return t if ARG is a category designator (a char in the range ' ' to '~').
+Return t if OBJECT is a category designator (a char in the range ' ' to '~').

 */
 */

-       (obj))
+       (object))

 {
 {

-  return CATEGORY_DESIGNATORP (obj) ? Qt : Qnil;
+  return CATEGORY_DESIGNATORP (object) ? Qt : Qnil;

 }
 
 DEFUN ("category-table-value-p", Fcategory_table_value_p, 1, 1, 0, /*
 }
 
 DEFUN ("category-table-value-p", Fcategory_table_value_p, 1, 1, 0, /*

-Return t if ARG is a category table value.
+Return t if OBJECT is a category table value.

 Valid values are nil or a bit vector of size 95.
 */
 Valid values are nil or a bit vector of size 95.
 */

-       (obj))
+       (object))

 {
 {

-  return CATEGORY_TABLE_VALUEP (obj) ? Qt : Qnil;
+  return CATEGORY_TABLE_VALUEP (object) ? Qt : Qnil;

 }
 
 
 #define CATEGORYP(x) \
 }
 
 
 #define CATEGORYP(x) \

-  (CHARP ((x)) && XCHAR ((x)) >= 0x20 && XCHAR ((x)) <= 0x7E)
+  (CHARP (x) && XCHAR (x) >= 0x20 && XCHAR (x) <= 0x7E)

 
 #define CATEGORY_SET(c)                                                \
   (get_char_table(c, XCHAR_TABLE(current_buffer->category_table)))
 
 #define CATEGORY_SET(c)                                                \
   (get_char_table(c, XCHAR_TABLE(current_buffer->category_table)))

@@ -1747,6 +1760,7 @@ Valid values are nil or a bit vector of size 95.
    Use the macro WORD_BOUNDARY_P instead of calling this function
    directly.  */
 
    Use the macro WORD_BOUNDARY_P instead of calling this function
    directly.  */
 

+int word_boundary_p (Emchar c1, Emchar c2);

 int
 word_boundary_p (Emchar c1, Emchar c2)
 {
 int
 word_boundary_p (Emchar c1, Emchar c2)
 {

@@ -1798,7 +1812,11 @@ word_boundary_p (Emchar c1, Emchar c2)
 void
 syms_of_chartab (void)
 {
 void
 syms_of_chartab (void)
 {

+  INIT_LRECORD_IMPLEMENTATION (char_table);
+

 #ifdef MULE
 #ifdef MULE

+  INIT_LRECORD_IMPLEMENTATION (char_table_entry);
+

   defsymbol (&Qcategory_table_p, "category-table-p");
   defsymbol (&Qcategory_designator_p, "category-designator-p");
   defsymbol (&Qcategory_table_value_p, "category-table-value-p");
   defsymbol (&Qcategory_table_p, "category-table-p");
   defsymbol (&Qcategory_designator_p, "category-designator-p");
   defsymbol (&Qcategory_table_value_p, "category-table-value-p");

@@ -1840,6 +1858,7 @@ vars_of_chartab (void)
 {
   /* DO NOT staticpro this.  It works just like Vweak_hash_tables. */
   Vall_syntax_tables = Qnil;
 {
   /* DO NOT staticpro this.  It works just like Vweak_hash_tables. */
   Vall_syntax_tables = Qnil;

+  pdump_wire_list (&Vall_syntax_tables);

 }
 
 void
 }
 
 void

@@ -1871,7 +1890,7 @@ 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.
 
 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
+\(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
 by the variable `word-combining-categories'.
 
 Emacs finds no word boundary between characters of different charsets

@@ -1885,7 +1904,7 @@ 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).
 
 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
+\(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
 the variable `word-separating-categories'.
 
 Emacs find a word boundary between characters of the same charset