From 356277ea54d4b1adbc0f5512cdd980d1f1636ac4 Mon Sep 17 00:00:00 2001 From: Dana Jansens Date: Thu, 12 Nov 2009 09:47:44 -0500 Subject: [PATCH] Remove macros for accessing the GTree's roots, and shorten the variable names (to match the GTreeNode's similar variables) --- glib/gtree.c | 121 ++++++++++++++++++++++++--------------------------- 1 file changed, 58 insertions(+), 63 deletions(-) diff --git a/glib/gtree.c b/glib/gtree.c index 5ea56fde..4cfe121c 100644 --- 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); } /** -- 2.34.1