fixed some memory leaks

diff --git a/glib/gtree.c b/glib/gtree.c
index 26efc38f0f52be586ce5bd1846409c4f386258a7..f4e3bb6bf893d5a0e83fc5a10078ebd6519cfed9 100644 (file)
--- a/glib/gtree.c
+++ b/glib/gtree.c
@@ -576,13 +576,14 @@ g_tree_node_delete_versions (GTree     *tree,
                              guint      pnext,
                              guint      version)
 {
-  guint rm, i, nv, next, nextv, lnext, rnext;
+  guint rm, i, nv, next, nextv, lnext, rnext, ret;
 
   if (!node)
     return 0;
 
   nv = node->nv;
 
+  ret = 0;
   rm = 0;
   for (i = nv > 1 ? 1 : 0; i < nv && node->v[i].version <= version; i = next)
     {
@@ -606,7 +607,7 @@ g_tree_node_delete_versions (GTree     *tree,
 
       if (next < nv && node->v[i].right &&
           node->v[next].right == node->v[i].right &&
-          (!pnext || node->v[next].version < pnext))
+          (!pnext || node->v[next].version <= pnext))
         rnext = node->v[next].version;
       else if (next == nv || node->v[next].version > pnext)
         rnext = pnext;
@@ -615,25 +616,17 @@ g_tree_node_delete_versions (GTree     *tree,
       rnext = g_tree_node_delete_versions (tree, node->v[i].right, rnext,
                                            nextv);
 
+      /* smallest non-zero of pnext, rnext, and lnext (or zero if all 3 are) */
       nextv = MIN ((pnext ? pnext : (lnext ? lnext : rnext)),
                    MIN ((lnext ? lnext : (rnext ? rnext : pnext)),
                         (rnext ? rnext : (lnext ? lnext : pnext))));
 
       if (nextv && (next == nv || node->v[next].version > nextv))
         { /* leave this one behind as there are more pointers coming here */
-          node->v[i].version = nextv;
+          ret = node->v[i].version = nextv;
           break;
         }
 
-      /* am i a root? */
-//      if (node->v[i].parent == NULL)
-//        {
-//          GTreeRootVersion *rv;
-//
-//          rv = g_tree_root_find_version (tree, node->v[i].version);
-//          rv->root = NULL;
-//        }
-
       ++rm;
     }
 
@@ -667,15 +660,20 @@ g_tree_node_delete_versions (GTree     *tree,
       node = NULL;
     }
 
-  //nextv = (node && node->nv ?
-  //         (node->nv > 1 ? node->v[1].version : node->v[0].version) : 0);
-  //if (nextv > version)
-  //  nextv = 0;
-  //return nextv;
+  /* if we saved a version here, then it's because a child still needs it
+     or the parent still needs it.  if the child needs it, then we will
+     still have a pointer back to the parent, so it needs to also know.  so
+     either way the parent needs it.
+     if we did not save a version, but the parent needs us to stick around for
+     something, then we can let it know that we did
+  */
+  if (!ret && node && pnext)
+    {
+      g_assert (node->v[node->nv > 1 ? 1 : 0].version == pnext);
+      ret = pnext;
+    }
 
-  /* return the lowest version left in the node, or 0 if its gone */
-  return (!node || !node->nv ? 0 :
-          (node->nv > 1 ? node->v[1].version : node->v[0].version));
+  return ret;
 }
 
 void
@@ -703,7 +701,7 @@ g_tree_delete_versions (GTree *tree,
   i = tree->nroots > 1 ? 1 : 0;
   next = next_version (i, tree->nroots);
   while (i < tree->nroots &&
-         tree->roots[i].version <= tree->lowest_version)
+         tree->roots[i].version < tree->lowest_version)
     {
       guint nextv, v;
 
@@ -724,13 +722,14 @@ g_tree_delete_versions (GTree *tree,
       l = g_tree_node_delete_versions (tree, tree->root(i), nextv, v);
       g_assert (l == 0 || l > v);
 
-      if (next == tree->nroots ||
-          tree->roots[next].version > tree->lowest_version)
+      if (l > v)
         tree->roots[i].version = l;
       else
-        ++rm;
+        {
+          ++rm;
+          keep = next;
+        }
 
-      keep = i;
       i = next;
       next = next_version (i, tree->nroots);
     }