merge trunk

1 files changed, 43 insertions, 49 deletions

diff --git a/src/chartab.c b/src/chartab.c
index 6d3f83499d8..711a49ed397 100644
--- a/src/chartab.c
+++ b/src/chartab.c
@@ -115,8 +115,8 @@ the char-table has no extra slot.  */)
   size = VECSIZE (struct Lisp_Char_Table) - 1 + n_extras;
   vector = Fmake_vector (make_number (size), init);
   XSETPVECTYPE (XVECTOR (vector), PVEC_CHAR_TABLE);
-  CSET (XCHAR_TABLE (vector), parent, Qnil);
-  CSET (XCHAR_TABLE (vector), purpose, purpose);
+  set_char_table_parent (vector, Qnil);
+  set_char_table_purpose (vector, purpose);
   XSETCHAR_TABLE (vector, XCHAR_TABLE (vector));
   return vector;
 }
@@ -155,21 +155,17 @@ char_table_ascii (Lisp_Object table)
 static Lisp_Object
 copy_sub_char_table (Lisp_Object table)
 {
-  Lisp_Object copy;
   int depth = XINT (XSUB_CHAR_TABLE (table)->depth);
   int min_char = XINT (XSUB_CHAR_TABLE (table)->min_char);
-  Lisp_Object val;
+  Lisp_Object copy = make_sub_char_table (depth, min_char, Qnil);
   int i;
 
-  copy = make_sub_char_table (depth, min_char, Qnil);
   /* Recursively copy any sub char-tables.  */
   for (i = 0; i < chartab_size[depth]; i++)
     {
-      val = XSUB_CHAR_TABLE (table)->contents[i];
-      if (SUB_CHAR_TABLE_P (val))
-        sub_char_table_set_contents (copy, i, copy_sub_char_table (val));
-      else
-        sub_char_table_set_contents (copy, i, val);
+      Lisp_Object val = XSUB_CHAR_TABLE (table)->contents[i];
+      set_sub_char_table_contents
+        (copy, i, SUB_CHAR_TABLE_P (val) ? copy_sub_char_table (val) : val);
     }
 
   return copy;
@@ -185,19 +181,19 @@ copy_char_table (Lisp_Object table)
 
   copy = Fmake_vector (make_number (size), Qnil);
   XSETPVECTYPE (XVECTOR (copy), PVEC_CHAR_TABLE);
-  CSET (XCHAR_TABLE (copy), defalt, XCHAR_TABLE (table)->defalt);
-  CSET (XCHAR_TABLE (copy), parent, XCHAR_TABLE (table)->parent);
-  CSET (XCHAR_TABLE (copy), purpose, XCHAR_TABLE (table)->purpose);
+  set_char_table_defalt (copy, XCHAR_TABLE (table)->defalt);
+  set_char_table_parent (copy, XCHAR_TABLE (table)->parent);
+  set_char_table_purpose (copy, XCHAR_TABLE (table)->purpose);
   for (i = 0; i < chartab_size[0]; i++)
-    char_table_set_contents
-      (copy, i, 
+    set_char_table_contents
+      (copy, i,
        (SUB_CHAR_TABLE_P (XCHAR_TABLE (table)->contents[i])
         ? copy_sub_char_table (XCHAR_TABLE (table)->contents[i])
         : XCHAR_TABLE (table)->contents[i]));
-  CSET (XCHAR_TABLE (copy), ascii, char_table_ascii (copy));
+  set_char_table_ascii (copy, char_table_ascii (copy));
   size -= VECSIZE (struct Lisp_Char_Table) - 1;
   for (i = 0; i < size; i++)
-    char_table_set_extras (copy, i, XCHAR_TABLE (table)->extras[i]);
+    set_char_table_extras (copy, i, XCHAR_TABLE (table)->extras[i]);
 
   XSETCHAR_TABLE (copy, XCHAR_TABLE (copy));
   return copy;
@@ -395,7 +391,7 @@ sub_char_table_set (Lisp_Object table, int c, Lisp_Object val, int is_uniprop)
   Lisp_Object sub;
 
   if (depth == 3)
-    sub_char_table_set_contents (table, i, val);
+    set_sub_char_table_contents (table, i, val);
   else
     {
       sub = tbl->contents[i];
@@ -408,21 +404,21 @@ sub_char_table_set (Lisp_Object table, int c, Lisp_Object val, int is_uniprop)
               sub = make_sub_char_table (depth + 1,
                                          min_char + i * chartab_chars[depth],
                                          sub);
-              sub_char_table_set_contents (table, i, sub);
+              set_sub_char_table_contents (table, i, sub);
             }
         }
       sub_char_table_set (sub, c, val, is_uniprop);
     }
 }
 
-Lisp_Object
+void
 char_table_set (Lisp_Object table, int c, Lisp_Object val)
 {
   struct Lisp_Char_Table *tbl = XCHAR_TABLE (table);
 
   if (ASCII_CHAR_P (c)
       && SUB_CHAR_TABLE_P (tbl->ascii))
-    sub_char_table_set_contents (tbl->ascii, c, val);
+    set_sub_char_table_contents (tbl->ascii, c, val);
   else
     {
       int i = CHARTAB_IDX (c, 0, 0);
@@ -432,13 +428,12 @@ char_table_set (Lisp_Object table, int c, Lisp_Object val)
       if (! SUB_CHAR_TABLE_P (sub))
         {
           sub = make_sub_char_table (1, i * chartab_chars[0], sub);
-          char_table_set_contents (table, i, sub);
+          set_char_table_contents (table, i, sub);
         }
       sub_char_table_set (sub, c, val, UNIPROP_TABLE_P (table));
       if (ASCII_CHAR_P (c))
-        CSET (tbl, ascii, char_table_ascii (table));
+        set_char_table_ascii (table, char_table_ascii (table));
     }
-  return val;
 }
 
 static void
@@ -460,7 +455,7 @@ sub_char_table_set_range (Lisp_Object table, int from, int to, Lisp_Object val,
       if (c > to)
         break;
       if (from <= c && c + chars_in_block - 1 <= to)
-        sub_char_table_set_contents (table, i, val);
+        set_sub_char_table_contents (table, i, val);
       else
         {
           Lisp_Object sub = tbl->contents[i];
@@ -471,7 +466,7 @@ sub_char_table_set_range (Lisp_Object table, int from, int to, Lisp_Object val,
               else
                 {
                   sub = make_sub_char_table (depth + 1, c, sub);
-                  sub_char_table_set_contents (table, i, sub);
+                  set_sub_char_table_contents (table, i, sub);
                 }
             }
           sub_char_table_set_range (sub, from, to, val, is_uniprop);
@@ -480,7 +475,7 @@ sub_char_table_set_range (Lisp_Object table, int from, int to, Lisp_Object val,
 }
 
 
-Lisp_Object
+void
 char_table_set_range (Lisp_Object table, int from, int to, Lisp_Object val)
 {
   struct Lisp_Char_Table *tbl = XCHAR_TABLE (table);
@@ -499,22 +494,21 @@ char_table_set_range (Lisp_Object table, int from, int to, Lisp_Object val)
           if (c > to)
             break;
           if (from <= c && c + chartab_chars[0] - 1 <= to)
-            char_table_set_contents (table, i, val);
+            set_char_table_contents (table, i, val);
           else
             {
               Lisp_Object sub = tbl->contents[i];
               if (! SUB_CHAR_TABLE_P (sub))
                 {
                   sub = make_sub_char_table (1, i * chartab_chars[0], sub);
-                  char_table_set_contents (table, i, sub);
+                  set_char_table_contents (table, i, sub);
                 }
               sub_char_table_set_range (sub, from, to, val, is_uniprop);
             }
         }
       if (ASCII_CHAR_P (from))
-        CSET (tbl, ascii, char_table_ascii (table));
+        set_char_table_ascii (table, char_table_ascii (table));
     }
-  return val;
 }
 
 
@@ -562,7 +556,7 @@ Return PARENT.  PARENT must be either nil or another char-table.  */)
           error ("Attempt to make a chartable be its own parent");
     }
 
-  CSET (XCHAR_TABLE (char_table), parent, parent);
+  set_char_table_parent (char_table, parent);
 
   return parent;
 }
@@ -593,7 +587,7 @@ DEFUN ("set-char-table-extra-slot", Fset_char_table_extra_slot,
       || XINT (n) >= CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (char_table)))
     args_out_of_range (char_table, n);
 
-  char_table_set_extras (char_table, XINT (n), value);
+  set_char_table_extras (char_table, XINT (n), value);
   return value;
 }
 
@@ -640,12 +634,12 @@ or a character code.  Return VALUE.  */)
     {
       int i;
 
-      CSET (XCHAR_TABLE (char_table), ascii, value);
+      set_char_table_ascii (char_table, value);
       for (i = 0; i < chartab_size[0]; i++)
-        char_table_set_contents (char_table, i, value);
+        set_char_table_contents (char_table, i, value);
     }
   else if (EQ (range, Qnil))
-    CSET (XCHAR_TABLE (char_table), defalt, value);
+    set_char_table_defalt (char_table, value);
   else if (CHARACTERP (range))
     char_table_set (char_table, XINT (range), value);
   else if (CONSP (range))
@@ -695,7 +689,7 @@ optimize_sub_char_table (Lisp_Object table, Lisp_Object test)
   if (SUB_CHAR_TABLE_P (elt))
     {
       elt = optimize_sub_char_table (elt, test);
-      sub_char_table_set_contents (table, 0, elt);
+      set_sub_char_table_contents (table, 0, elt);
     }
   optimizable = SUB_CHAR_TABLE_P (elt) ? 0 : 1;
   for (i = 1; i < chartab_size[depth]; i++)
@@ -704,7 +698,7 @@ optimize_sub_char_table (Lisp_Object table, Lisp_Object test)
       if (SUB_CHAR_TABLE_P (this))
         {
           this = optimize_sub_char_table (this, test);
-          sub_char_table_set_contents (table, i, this);
+          set_sub_char_table_contents (table, i, this);
         }
       if (optimizable
           && (NILP (test) ? NILP (Fequal (this, elt)) /* defaults to `equal'. */
@@ -732,11 +726,11 @@ equivalent and can be merged.  It defaults to `equal'.  */)
     {
       elt = XCHAR_TABLE (char_table)->contents[i];
       if (SUB_CHAR_TABLE_P (elt))
-        char_table_set_contents
+        set_char_table_contents
           (char_table, i, optimize_sub_char_table (elt, test));
     }
   /* Reset the `ascii' cache, in case it got optimized away.  */
-  CSET (XCHAR_TABLE (char_table), ascii, char_table_ascii (char_table));
+  set_char_table_ascii (char_table, char_table_ascii (char_table));
 
   return Qnil;
 }
@@ -828,9 +822,9 @@ map_sub_char_table (void (*c_function) (Lisp_Object, Lisp_Object, Lisp_Object),
 
                       /* This is to get a value of FROM in PARENT
                          without checking the parent of PARENT.  */
-                      CSET (XCHAR_TABLE (parent), parent, Qnil);
+                      set_char_table_parent (parent, Qnil);
                       val = CHAR_TABLE_REF (parent, from);
-                      CSET (XCHAR_TABLE (parent), parent, temp);
+                      set_char_table_parent (parent, temp);
                       XSETCDR (range, make_number (c - 1));
                       val = map_sub_char_table (c_function, function,
                                                 parent, arg, val, range,
@@ -910,9 +904,9 @@ map_char_table (void (*c_function) (Lisp_Object, Lisp_Object, Lisp_Object),
       temp = XCHAR_TABLE (parent)->parent;
       /* This is to get a value of FROM in PARENT without checking the
          parent of PARENT.  */
-      CSET (XCHAR_TABLE (parent), parent, Qnil);
+      set_char_table_parent (parent, Qnil);
       val = CHAR_TABLE_REF (parent, from);
-      CSET (XCHAR_TABLE (parent), parent, temp);
+      set_char_table_parent (parent, temp);
       val = map_sub_char_table (c_function, function, parent, arg, val, range,
                                 parent);
       table = parent;
@@ -1149,7 +1143,7 @@ uniprop_table_uncompress (Lisp_Object table, int idx)
   Lisp_Object sub = make_sub_char_table (3, min_char, Qnil);
   const unsigned char *p, *pend;
 
-  sub_char_table_set_contents (table, idx, sub);
+  set_sub_char_table_contents (table, idx, sub);
   p = SDATA (val), pend = p + SBYTES (val);
   if (*p == 1)
     {
@@ -1159,7 +1153,7 @@ uniprop_table_uncompress (Lisp_Object table, int idx)
       while (p < pend && idx < chartab_chars[2])
         {
           int v = STRING_CHAR_ADVANCE (p);
-          sub_char_table_set_contents
+          set_sub_char_table_contents
             (sub, idx++, v > 0 ? make_number (v) : Qnil);
         }
     }
@@ -1185,7 +1179,7 @@ uniprop_table_uncompress (Lisp_Object table, int idx)
                 }
             }
           while (count-- > 0)
-            sub_char_table_set_contents (sub, idx++, make_number (v));
+            set_sub_char_table_contents (sub, idx++, make_number (v));
         }
     }
 /* It seems that we don't need this function because C code won't need
@@ -1288,7 +1282,7 @@ uniprop_encode_value_numeric (Lisp_Object table, Lisp_Object value)
 
       args[0] = XCHAR_TABLE (table)->extras[4];
       args[1] = Fmake_vector (make_number (1), value);
-      char_table_set_extras (table, 4, Fvconcat (2, args));
+      set_char_table_extras (table, 4, Fvconcat (2, args));
     }
   return make_number (i);
 }
@@ -1350,7 +1344,7 @@ uniprop_table (Lisp_Object prop)
       : ! NILP (val))
     return Qnil;
   /* Prepare ASCII values in advance for CHAR_TABLE_REF.  */
-  CSET (XCHAR_TABLE (table), ascii, char_table_ascii (table));
+  set_char_table_ascii (table, char_table_ascii (table));
   return table;
 }