Remove macros for accessing the GTree's roots, and shorten the variable names (to...

diff --git a/glib/gtree.c b/glib/gtree.c
index 5ea56fde9dc54d9987dd1f274033681d5449b2d3..4cfe121c427340ce675a77646f4ce8750b12e28d 100644 (file)
--- a/glib/gtree.c
+++ b/glib/gtree.c
@@ -55,11 +55,11 @@ struct _GTreeRootVersion
 
 struct _GTree
 {
-  GTreeRootVersion *roots; /* versioned root nodes of the tree.  roots[0] is
-                              the highest (latest) version.  then
-                              roots[1]..roots[nroots-1] are
-                              older versions in ascending order */
-  guint             nroots;
+  GTreeRootVersion *r; /* versioned root nodes of the tree.  roots[0] is
+                          the highest (latest) version.  then
+                          roots[1]..roots[nroots-1] are
+                          older versions in ascending order */
+  guint             nr;
   GCompareDataFunc  key_compare;
   GDestroyNotify    key_destroy_func;
   GDestroyNotify    value_destroy_func;
@@ -69,9 +69,6 @@ struct _GTree
   guint             version;
 };
 
-#define root(i)         roots[i].root
-#define rootversion(i)  roots[i].version
-
 struct _GTreeNodeVersion
 {
   guint      version;
@@ -272,8 +269,8 @@ g_tree_new_full (GCompareDataFunc key_compare_func,
   g_return_val_if_fail (key_compare_func != NULL, NULL);
   
   tree = g_slice_new (GTree);
-  tree->roots              = g_new(GTreeRootVersion, 1);
-  tree->nroots             = 1;
+  tree->r                  = g_new(GTreeRootVersion, 1);
+  tree->nr                 = 1;
   tree->key_compare        = key_compare_func;
   tree->key_destroy_func   = key_destroy_func;
   tree->value_destroy_func = value_destroy_func;
@@ -282,8 +279,8 @@ g_tree_new_full (GCompareDataFunc key_compare_func,
   tree->ref_count          = 1;
   tree->version            = 0;
 
-  tree->roots[0].root      = NULL;
-  tree->roots[0].version   = 0;
+  tree->r[0].root          = NULL;
+  tree->r[0].version       = 0;
   
   return tree;
 }
@@ -293,8 +290,8 @@ static inline GTreeRootVersion *
 g_tree_root_find_version (GTree *tree,
                           guint  version)
 {
-  GTreeRootVersion *const v = tree->roots;
-  const guint nv = tree->nroots;
+  GTreeRootVersion *const v = tree->r;
+  const guint nv = tree->nr;
   GTreeRootVersion *l, *r;
   static GTreeRootVersion none = {
     .root = NULL,
@@ -449,10 +446,10 @@ g_tree_remove_all (GTree *tree)
   if (tree->version > 0)
     g_tree_delete_versions (tree, tree->version-1);
 
-  g_tree_node_free_all (tree, tree->root(NOW));
+  g_tree_node_free_all (tree, tree->r[0].root);
 
-  tree->roots[0].root = NULL;
-  tree->roots[0].version = tree->version = 0;
+  tree->r[0].root = NULL;
+  tree->r[0].version = tree->version = 0;
   tree->nnodes = 0;
 }
 
@@ -498,7 +495,7 @@ g_tree_unref (GTree *tree)
   if (g_atomic_int_dec_and_test (&tree->ref_count))
     {
       g_tree_remove_all (tree);
-      g_free (tree->roots);
+      g_free (tree->r);
       g_slice_free (GTree, tree);
     }
 }
@@ -691,35 +688,33 @@ g_tree_delete_versions (GTree *tree,
   g_return_if_fail (tree != NULL);
   g_return_if_fail (version < tree->version);
 
-  if (version < tree->roots[tree->nroots > 1 ? 1 : 0].version)
+  if (version < tree->r[tree->nr > 1 ? 1 : 0].version)
     return;
 
   rm = 0;
-  i = tree->nroots > 1 ? 1 : 0;
-  next = next_version (i, tree->nroots);
-  while (i < tree->nroots && tree->roots[i].version < version + 1)
+  i = tree->nr > 1 ? 1 : 0;
+  next = next_version (i, tree->nr);
+  while (i < tree->nr && tree->r[i].version < version + 1)
     {
       guint nextv, v;
 
-      if (next == tree->nroots ||
-          tree->roots[next].version > version + 1)
+      if (next == tree->nr || tree->r[next].version > version + 1)
         nextv = version + 1;
-      else if (next < tree->nroots &&
-               tree->roots[next].root == tree->roots[i].root)
-        nextv = tree->roots[next].version;
+      else if (next < tree->nr && tree->r[next].root == tree->r[i].root)
+        nextv = tree->r[next].version;
       else
         nextv = 0;
 
-      if (next < tree->nroots && tree->roots[next].version <= version)
-        v = tree->roots[next].version - 1;
+      if (next < tree->nr && tree->r[next].version <= version)
+        v = tree->r[next].version - 1;
       else
         v = version;
 
-      l = g_tree_node_delete_versions (tree, tree->root(i), nextv, v);
+      l = g_tree_node_delete_versions (tree, tree->r[i].root, nextv, v);
       g_assert (l == 0 || l > v);
 
       if (l > v)
-        tree->roots[i].version = l;
+        tree->r[i].version = l;
       else
         {
           ++rm;
@@ -727,23 +722,23 @@ g_tree_delete_versions (GTree *tree,
         }
 
       i = next;
-      next = next_version (i, tree->nroots);
+      next = next_version (i, tree->nr);
     }
 
   if (rm)
     {
       guint j;
-      for (j = tree->nroots-rm > 1 ? 1 : 0;
-           j < tree->nroots-rm;
-           j = next_version (j, tree->nroots-rm),
-             keep = next_version (keep, tree->nroots))
+      for (j = tree->nr - rm > 1 ? 1 : 0;
+           j < tree->nr - rm;
+           j = next_version (j, tree->nr - rm),
+             keep = next_version (keep, tree->nr))
         {
-          tree->roots[j] = tree->roots[keep];
+          tree->r[j] = tree->r[keep];
         }
     }
 
-  tree->nroots -= rm;
-  tree->roots = g_renew(GTreeRootVersion, tree->roots, tree->nroots);
+  tree->nr -= rm;
+  tree->r = g_renew(GTreeRootVersion, tree->r, tree->nr);
 
 #ifdef G_TREE_DEBUG
   {
@@ -759,16 +754,16 @@ g_tree_delete_versions (GTree *tree,
 static void
 g_tree_root_next_version (GTree *tree)
 {
-  g_assert(tree->rootversion(NOW) <= tree->version);
+  g_assert(tree->r[0].version <= tree->version);
 
-  if (tree->rootversion(NOW) < tree->version)
+  if (tree->r[0].version < tree->version)
     {
       /* add a new version of the root */
-      tree->nroots++;
-      tree->roots = g_renew(GTreeRootVersion, tree->roots, tree->nroots);
+      tree->nr++;
+      tree->r = g_renew(GTreeRootVersion, tree->r, tree->nr);
       /* copy the latest version from roots[0] */
-      tree->roots[tree->nroots-1] = tree->roots[0];
-      tree->roots[0].version = tree->version;
+      tree->r[tree->nr-1] = tree->r[0];
+      tree->r[0].version = tree->version;
     }
 }
 
@@ -873,10 +868,10 @@ g_tree_node_fix_incoming (GTree     *tree,
 
   /* 4. if this was the root node, then the root pointer into the tree needs 
      be updated */
-  if (tree->root(NOW) == oldnode)
+  if (tree->r[0].root == oldnode)
     {
       g_tree_root_next_version (tree);
-      tree->roots[0].root = newnode;
+      tree->r[0].root = newnode;
     }
 }
 
@@ -1004,15 +999,15 @@ g_tree_insert_internal (GTree    *tree,
 
   g_return_if_fail (tree != NULL);
 
-  if (!tree->root(NOW))
+  if (!tree->r[0].root)
     {
       g_tree_root_next_version (tree);
-      tree->roots[0].root = g_tree_node_new (tree, key, value);
+      tree->r[0].root = g_tree_node_new (tree, key, value);
       tree->nnodes++;
       return;
     }
 
-  node = tree->root(NOW);
+  node = tree->r[0].root;
 
   while (1)
     {
@@ -1097,7 +1092,7 @@ g_tree_insert_internal (GTree    *tree,
       if (!sp)
         {
           g_tree_root_next_version (tree);
-          tree->roots[0].root = node;
+          tree->r[0].root = node;
         }
       else if (sp->left(NOW) == p)
         sp->v[0].left = node;
@@ -1197,10 +1192,10 @@ g_tree_remove_internal (GTree         *tree,
 
   g_return_val_if_fail (tree != NULL, FALSE);
 
-  if (!tree->root(NOW))
+  if (!tree->r[0].root)
     return FALSE;
 
-  node = tree->root(NOW);
+  node = tree->r[0].root;
   parent = NULL;
   is_leftchild = FALSE;
 
@@ -1250,7 +1245,7 @@ g_tree_remove_internal (GTree         *tree,
           if (!parent)
             {
               g_tree_root_next_version(tree);
-              parent = tree->roots[0].root =
+              parent = tree->r[0].root =
                 g_tree_node_rotate_left (tree, node);
             }
           else
@@ -1271,7 +1266,7 @@ g_tree_remove_internal (GTree         *tree,
           if (!parent)
             {
               g_tree_root_next_version(tree);
-              parent = tree->roots[0].root =
+              parent = tree->r[0].root =
                 g_tree_node_rotate_right (tree, node);
             }
           else
@@ -1292,7 +1287,7 @@ g_tree_remove_internal (GTree         *tree,
   if (!parent)
     {
       g_tree_root_next_version (tree);
-      tree->roots[0].root = NULL;
+      tree->r[0].root = NULL;
     }
   else
     {
@@ -1460,7 +1455,7 @@ g_tree_foreach (GTree         *tree,
 
   g_return_if_fail (tree != NULL);
   
-  if (!tree->root(NOW))
+  if (!tree->r[0].root)
     return;
 
   node = g_tree_first_node (tree, tree->version);
@@ -1498,21 +1493,21 @@ g_tree_traverse (GTree         *tree,
 {
   g_return_if_fail (tree != NULL);
 
-  if (!tree->root(NOW))
+  if (!tree->r[0].root)
     return;
 
   switch (traverse_type)
     {
     case G_PRE_ORDER:
-      g_tree_node_pre_order (tree->root(NOW), traverse_func, user_data);
+      g_tree_node_pre_order (tree->r[0].root, traverse_func, user_data);
       break;
 
     case G_IN_ORDER:
-      g_tree_node_in_order (tree->root(NOW), traverse_func, user_data);
+      g_tree_node_in_order (tree->r[0].root, traverse_func, user_data);
       break;
 
     case G_POST_ORDER:
-      g_tree_node_post_order (tree->root(NOW), traverse_func, user_data);
+      g_tree_node_post_order (tree->r[0].root, traverse_func, user_data);
       break;
     
     case G_LEVEL_ORDER:
@@ -1588,7 +1583,7 @@ g_tree_search_related (GTree          *tree,
 {
   g_return_val_if_fail (tree != NULL, NULL);
 
-  return g_tree_node_search (tree->root(NOW),
+  return g_tree_node_search (tree->r[0].root,
                              search_func, user_data, search_type,
                              tree->version);
 }
@@ -1620,7 +1615,7 @@ g_tree_height (GTree *tree)
 {
   g_return_val_if_fail (tree != NULL, 0);
 
-  return g_tree_node_height (tree->root(NOW));
+  return g_tree_node_height (tree->r[0].root);
 }
 
 /**