--- /dev/null
+/* ET-trees datastructure implementation.
+ Contributed by Pavel Nejedly
+ Copyright (C) 2002 Free Software Foundation, Inc.
+
+This file is part of the libiberty library.
+Libiberty is free software; you can redistribute it and/or
+modify it under the terms of the GNU Library General Public
+License as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later version.
+
+Libiberty is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public
+License along with libiberty; see the file COPYING.LIB. If
+not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.
+
+ The ET-forest structure is described in:
+ D. D. Sleator and R. E. Tarjan. A data structure for dynamic trees.
+ J. G'omput. System Sci., 26(3):362 381, 1983.
+*/
+
+#include "config.h"
+#include "system.h"
+#include "et-forest.h"
+
+struct et_forest_occurrence;
+typedef struct et_forest_occurrence* et_forest_occurrence_t;
+
+/* The ET-forest type. */
+struct et_forest
+{
+ /* Linked list of nodes is used to destroy the structure. */
+ int nnodes;
+};
+
+/* Single occurrence of node in ET-forest.
+ A single node may have multiple occurrences.
+ */
+struct et_forest_occurrence
+{
+ /* Parent in the splay-tree. */
+ et_forest_occurrence_t parent;
+
+ /* Children in the splay-tree. */
+ et_forest_occurrence_t left, right;
+
+ /* Counts of vertices in the two splay-subtrees. */
+ int count_left, count_right;
+
+ /* Next occurrence of this node in the sequence. */
+ et_forest_occurrence_t next;
+
+ /* The node, which this occurrence is of. */
+ et_forest_node_t node;
+};
+
+
+/* ET-forest node. */
+struct et_forest_node
+{
+ et_forest_t forest;
+ void *value;
+
+ /* First and last occurrence of this node in the sequence. */
+ et_forest_occurrence_t first, last;
+};
+
+
+static et_forest_occurrence_t splay PARAMS ((et_forest_occurrence_t));
+static void remove_all_occurrences PARAMS ((et_forest_node_t));
+static inline et_forest_occurrence_t find_leftmost_node
+ PARAMS ((et_forest_occurrence_t));
+static inline et_forest_occurrence_t find_rightmost_node
+ PARAMS ((et_forest_occurrence_t));
+static int calculate_value PARAMS ((et_forest_occurrence_t));
+
+/* Return leftmost node present in the tree roted by OCC. */
+static inline et_forest_occurrence_t
+find_leftmost_node (occ)
+ et_forest_occurrence_t occ;
+{
+ while (occ->left)
+ occ = occ->left;
+
+ return occ;
+}
+
+/* Return rightmost node present in the tree roted by OCC. */
+static inline et_forest_occurrence_t
+find_rightmost_node (occ)
+ et_forest_occurrence_t occ;
+{
+ while (occ->right)
+ occ = occ->right;
+ return occ;
+}
+
+
+/* Operation splay for splay tree structure representing ocuurences. */
+static et_forest_occurrence_t
+splay (node)
+ et_forest_occurrence_t node;
+{
+ et_forest_occurrence_t parent;
+ et_forest_occurrence_t grandparent;
+
+ while (1)
+ {
+ parent = node->parent;
+
+ if (! parent)
+ return node; /* node == root. */
+
+ grandparent = parent->parent;
+
+ if (! grandparent)
+ break;
+
+ /* Now there are four possible combinations: */
+
+ if (node == parent->left)
+ {
+ if (parent == grandparent->left)
+ {
+ et_forest_occurrence_t node1, node2;
+ int count1, count2;
+
+ node1 = node->right;
+ count1 = node->count_right;
+ node2 = parent->right;
+ count2 = parent->count_right;
+
+ grandparent->left = node2;
+ grandparent->count_left = count2;
+ if (node2)
+ node2->parent = grandparent;
+ parent->left = node1;
+ parent->count_left = count1;
+ if (node1)
+ node1->parent = parent;
+ parent->right = grandparent;
+ parent->count_right = count2 + grandparent->count_right + 1;
+ node->right = parent;
+ node->count_right = count1 + parent->count_right + 1;
+
+ node->parent = grandparent->parent;
+ parent->parent = node;
+ grandparent->parent = parent;
+
+ if (node->parent)
+ {
+ if (node->parent->left == grandparent)
+ node->parent->left = node;
+ else
+ node->parent->right = node;
+ }
+ }
+ else
+ {
+ /* parent == grandparent->right && node == parent->left*/
+ et_forest_occurrence_t node1, node2;
+ int count1, count2;
+
+ node1 = node->left;
+ count1 = node->count_left;
+ node2 = node->right;
+ count2 = node->count_right;
+
+ grandparent->right = node1;
+ grandparent->count_right = count1;
+ if (node1)
+ node1->parent = grandparent;
+ parent->left = node2;
+ parent->count_left = count2;
+ if (node2)
+ node2->parent = parent;
+ node->left = grandparent;
+ node->count_left = grandparent->count_left + count1 + 1;
+ node->right = parent;
+ node->count_right = parent->count_right + count2 + 1;
+
+ node->parent = grandparent->parent;
+ parent->parent = node;
+ grandparent->parent = node;
+
+ if (node->parent)
+ {
+ if (node->parent->left == grandparent)
+ node->parent->left = node;
+ else
+ node->parent->right = node;
+ }
+ }
+ }
+ else
+ {
+ /* node == parent->right. */
+ if (parent == grandparent->left)
+ {
+ et_forest_occurrence_t node1, node2;
+ int count1, count2;
+
+ node1 = node->left;
+ count1 = node->count_left;
+ node2 = node->right;
+ count2 = node->count_right;
+
+ parent->right = node1;
+ parent->count_right = count1;
+ if (node1)
+ node1->parent = parent;
+ grandparent->left = node2;
+ grandparent->count_left = count2;
+ if (node2)
+ node2->parent = grandparent;
+ node->left = parent;
+ node->count_left = parent->count_left + count1 + 1;
+ node->right = grandparent;
+ node->count_right = grandparent->count_right + count2 + 1;
+
+ node->parent = grandparent->parent;
+ parent->parent = node;
+ grandparent->parent = node;
+
+ if (node->parent)
+ {
+ if (node->parent->left == grandparent)
+ node->parent->left = node;
+ else
+ node->parent->right = node;
+ }
+ }
+ else
+ {
+ /* parent == grandparent->right && node == parent->right*/
+ et_forest_occurrence_t node1, node2;
+ int count1, count2;
+
+ node1 = node->left;
+ count1 = node->count_left;
+ node2 = parent->left;
+ count2 = parent->count_left;
+
+ grandparent->right = node2;
+ grandparent->count_right = count2;
+ if (node2)
+ node2->parent = grandparent;
+ parent->right = node1;
+ parent->count_right = count1;
+ if (node1)
+ node1->parent = parent;
+ parent->left = grandparent;
+ parent->count_left = count2 + grandparent->count_left + 1;
+ node->left = parent;
+ node->count_left = count1 + parent->count_left + 1;
+
+ node->parent = grandparent->parent;
+ parent->parent = node;
+ grandparent->parent = parent;
+
+ if (node->parent)
+ {
+ if (node->parent->left == grandparent)
+ node->parent->left = node;
+ else
+ node->parent->right = node;
+ }
+ }
+ }
+
+ }
+
+ /* parent == root. */
+ /* There are two possible combinations: */
+
+ if (node == parent->left)
+ {
+ et_forest_occurrence_t node1;
+ int count1;
+
+ node1 = node->right;
+ count1 = node->count_right;
+
+ parent->left = node1;
+ parent->count_left = count1;
+ if (node1)
+ node1->parent = parent;
+ node->right = parent;
+ node->count_right = parent->count_right + 1 + count1;
+ node->parent = parent->parent; /* the same as = 0; */
+ parent->parent = node;
+
+ if (node->parent)
+ {
+ if (node->parent->left == parent)
+ node->parent->left = node;
+ else
+ node->parent->right = node;
+ }
+ }
+ else
+ {
+ /* node == parent->right. */
+ et_forest_occurrence_t node1;
+ int count1;
+
+ node1 = node->left;
+ count1 = node->count_left;
+
+ parent->right = node1;
+ parent->count_right = count1;
+ if (node1)
+ node1->parent = parent;
+ node->left = parent;
+ node->count_left = parent->count_left + 1 + count1;
+ node->parent = parent->parent; /* the same as = 0; */
+ parent->parent = node;
+
+ if (node->parent)
+ {
+ if (node->parent->left == parent)
+ node->parent->left = node;
+ else
+ node->parent->right = node;
+ }
+ }
+
+ return node;
+}
+
+/* Remove all occurences of the given node before destroying the node. */
+static void
+remove_all_occurrences (forest_node)
+ et_forest_node_t forest_node;
+{
+ et_forest_occurrence_t first = forest_node->first;
+ et_forest_occurrence_t last = forest_node->last;
+ et_forest_occurrence_t node;
+
+ splay (first);
+
+ if (first->left)
+ first->left->parent = 0;
+ if (first->right)
+ first->right->parent = 0;
+
+ if (last != first)
+ {
+ splay (last);
+
+ if (last->left)
+ last->left->parent = 0;
+ if (last->right)
+ last->right->parent = 0;
+ }
+
+ if (last->right && first->left) /* actually, first->left would suffice. */
+ {
+ /* Need to join them. */
+ et_forest_occurrence_t prev_node, next_node;
+
+ prev_node = splay (find_rightmost_node (first->left));
+ next_node = splay (find_leftmost_node (last->right));
+ /* prev_node and next_node are consecutive occurencies
+ of the same node. */
+ if (prev_node->next != next_node)
+ abort ();
+
+ prev_node->right = next_node->right;
+ prev_node->count_right = next_node->count_right;
+ prev_node->next = next_node->next;
+ if (prev_node->right)
+ prev_node->right->parent = prev_node;
+
+ if (prev_node->node->last == next_node)
+ prev_node->node->last = prev_node;
+
+ free (next_node);
+ }
+
+ if (first != last)
+ {
+ node = first->next;
+
+ while (node != last)
+ {
+ et_forest_occurrence_t next_node;
+
+ splay (node);
+
+ if (node->left)
+ node->left->parent = 0;
+ if (node->right)
+ node->right->parent = 0;
+
+ next_node = node->next;
+ free (node);
+ node = next_node;
+ }
+ }
+
+ free (first);
+ if (first != last)
+ free (last);
+}
+
+/* Calculate ET value of the given node. */
+static inline int
+calculate_value (node)
+ et_forest_occurrence_t node;
+{
+ int value = node->count_left;
+
+ while (node->parent)
+ {
+ if (node == node->parent->right)
+ value += node->parent->count_left + 1;
+
+ node = node->parent;
+ }
+
+ return value;
+}
+
+
+
+
+/* Create ET-forest structure. */
+et_forest_t
+et_forest_create ()
+{
+
+ et_forest_t forest = xmalloc (sizeof (struct et_forest));
+
+ forest->nnodes = 0;
+ return forest;
+}
+
+
+
+/* Deallocate the structure. */
+void
+et_forest_delete (forest)
+ et_forest_t forest;
+{
+ if (forest->nnodes)
+ abort ();
+
+ free (forest);
+}
+
+/* Create new node with VALUE and return the edge.
+ Return NULL when memory allocation failed. */
+et_forest_node_t
+et_forest_add_node (forest, value)
+ et_forest_t forest;
+ void *value;
+{
+ /* Create node with one occurrence. */
+ et_forest_node_t node;
+ et_forest_occurrence_t occ;
+
+ node = xmalloc (sizeof (struct et_forest_node));
+ occ = xmalloc (sizeof (struct et_forest_occurrence));
+
+ node->first = node->last = occ;
+ node->value = value;
+ forest->nnodes++;
+
+ occ->node = node;
+ occ->left = occ->right = occ->parent = 0;
+ occ->next = 0;
+ occ->count_left = occ->count_right = 0;
+ return node;
+}
+
+/* Add new edge to the tree, return 1 if succesfull.
+ 0 indicates that creation of the edge will close the cycle in graph. */
+int
+et_forest_add_edge (forest, parent_node, child_node)
+ et_forest_t forest ATTRIBUTE_UNUSED;
+ et_forest_node_t parent_node;
+ et_forest_node_t child_node;
+{
+ et_forest_occurrence_t new_occ, parent_occ, child_occ;
+
+ if (! parent_node || ! child_node)
+ abort ();
+
+ parent_occ = parent_node->first;
+ child_occ = child_node->first;
+
+ splay (parent_occ);
+ splay (child_occ);
+
+ if (parent_occ->parent)
+ return 0; /* Both child and parent are in the same tree. */
+
+ if (child_occ->left)
+ abort (); /* child must be root of its containing tree. */
+
+ new_occ = xmalloc (sizeof (struct et_forest_occurrence));
+
+ new_occ->node = parent_node;
+ new_occ->left = child_occ;
+ new_occ->count_left = child_occ->count_right + 1; /* count_left is 0. */
+ new_occ->right = parent_occ->right;
+ new_occ->count_right = parent_occ->count_right;
+ new_occ->parent = parent_occ;
+ new_occ->next = parent_occ->next;
+ child_occ->parent = new_occ;
+ parent_occ->right = new_occ;
+ parent_occ->count_right = new_occ->count_left + new_occ->count_right + 1;
+ parent_occ->next = new_occ;
+ if (new_occ->right)
+ new_occ->right->parent = new_occ;
+
+ if (parent_node->last == parent_occ)
+ parent_node->last = new_occ;
+ return 1;
+}
+
+/* Remove NODE from the tree and all connected edges. */
+void
+et_forest_remove_node (forest, node)
+ et_forest_t forest;
+ et_forest_node_t node;
+{
+ remove_all_occurrences (node);
+ forest->nnodes--;
+
+ free (node);
+}
+
+/* Remove edge from the tree, return 1 if sucesfull,
+ 0 indicates nonexisting edge. */
+int
+et_forest_remove_edge (forest, parent_node, child_node)
+ et_forest_t forest ATTRIBUTE_UNUSED;
+ et_forest_node_t parent_node;
+ et_forest_node_t child_node;
+{
+ et_forest_occurrence_t parent_pre_occ, parent_post_occ;
+
+ splay (child_node->first);
+
+ if (! child_node->first->left)
+ return 0;
+
+ parent_pre_occ = find_rightmost_node (child_node->first->left);
+ if (parent_pre_occ->node != parent_node)
+ abort ();
+
+ splay (parent_pre_occ);
+ parent_pre_occ->right->parent = 0;
+
+ parent_post_occ = parent_pre_occ->next;
+ splay (parent_post_occ);
+
+ parent_post_occ->left->parent = 0;
+
+ parent_pre_occ->right = parent_post_occ->right;
+ parent_pre_occ->count_right = parent_post_occ->count_right;
+ if (parent_post_occ->right)
+ parent_post_occ->right->parent = parent_pre_occ;
+
+ parent_pre_occ->next = parent_post_occ->next;
+
+ if (parent_post_occ == parent_node->last)
+ parent_node->last = parent_pre_occ;
+
+ free (parent_post_occ);
+ return 1;
+}
+
+/* Return the parent of the NODE if any, NULL otherwise. */
+et_forest_node_t
+et_forest_parent (forest, node)
+ et_forest_t forest ATTRIBUTE_UNUSED;
+ et_forest_node_t node;
+{
+ splay (node->first);
+
+ if (node->first->left)
+ return find_rightmost_node (node->first->left)->node;
+ else
+ return 0;
+}
+
+
+/* Return nearest common ancestor of NODE1 and NODE2.
+ Return NULL of they are in different trees. */
+et_forest_node_t
+et_forest_common_ancestor (forest, node1, node2)
+ et_forest_t forest ATTRIBUTE_UNUSED;
+ et_forest_node_t node1;
+ et_forest_node_t node2;
+{
+ int value1, value2, max_value;
+ et_forest_node_t ancestor;
+
+ if (node1 == node2)
+ return node1;
+
+ if (! node1 || ! node2)
+ abort ();
+
+ splay (node1->first);
+ splay (node2->first);
+
+ if (! node1->first->parent) /* The two vertices are in different trees. */
+ return 0;
+
+ value2 = calculate_value (node2->first);
+ value1 = calculate_value (node1->first);
+
+ if (value1 < value2)
+ {
+ ancestor = node1;
+ max_value = value2;
+ }
+ else
+ {
+ ancestor = node2;
+ max_value = value1;
+ }
+
+ while (calculate_value (ancestor->last) < max_value)
+ {
+ /* Find parent node. */
+ splay (ancestor->first);
+ ancestor = find_rightmost_node (ancestor->first->left) ->node;
+ }
+
+ return ancestor;
+}
+
+/* Return the value pointer of node set during it's creation. */
+void *
+et_forest_node_value (forest, node)
+ et_forest_t forest ATTRIBUTE_UNUSED;
+ et_forest_node_t node;
+{
+ /* Alloc threading NULL as a special node of the forest. */
+ if (!node)
+ return NULL;
+ return node->value;
+}
+
+/* Find all sons of NODE and store them into ARRAY allocated by the caller.
+ Return number of nodes found. */
+int
+et_forest_enumerate_sons (forest, node, array)
+ et_forest_t forest ATTRIBUTE_UNUSED;
+ et_forest_node_t node;
+ et_forest_node_t *array;
+{
+ int n = 0;
+ et_forest_occurrence_t occ = node->first, stop = node->last, occ1;
+
+ /* Parent is the rightmost node of the left successor.
+ Look for all occurences having no right succesor
+ and lookup the sons. */
+ while (occ != stop)
+ {
+ splay (occ);
+ if (occ->right)
+ {
+ occ1 = find_leftmost_node (occ->right);
+ if (occ1->node->first == occ1)
+ array[n++] = occ1->node;
+ }
+ occ = occ->next;
+ }
+ return n;
+}
projects / platform / upstream / gcc.git / commitdiff