ucx: comparison src/tree.c

-:97df2e4c68fb
+:5c926801f052
 *result = (void*)root;
 return ret;
 }
 // create a working stack
-size_t work_cap = 32;
+cx_array_declare(void const*, work);
-size_t work_size = 0;
+cx_array_initialize(work, 32);
-void const **work = malloc(sizeof(void*) * work_cap);
-#define work_add(node) cx_array_add(&work, &work_size, &work_cap, \
-sizeof(void*), &(node), cx_array_default_reallocator)
 // add the children of root to the working stack
 {
 void *c = tree_children(root);
 while (c != NULL) {
-work_add(c);
+cx_array_simple_add(work, c);
 c = tree_next(c);
 }
 }
 // remember a candidate for adding the data
 break;
 } else if (ret > 0) {
 // if children might contain the data, add them to the stack
 void *c = tree_children(node);
 while (c != NULL) {
-work_add(c);
+cx_array_simple_add(work, c);
 c = tree_next(c);
 }
 // remember this node in case no child is suitable
 if (ret_candidate < 0 || ret < ret_candidate) {
 ret = ret_candidate;
 *result = candidate;
 }
 // free the working queue and return
-#undef workq_add
 free(work);
 return ret;
 }
 static bool cx_tree_iter_valid(void const *it) {
 static void *cx_tree_iter_current(void const *it) {
 struct cx_tree_iterator_s const *iter = it;
 return iter->node;
 }
-static void cx_tree_iter_stack_add(
-struct cx_tree_iterator_s *iter,
-void *node
-) {
-cx_array_add(&iter->stack, &iter->depth, &iter->stack_capacity,
-sizeof(void*), &node, cx_array_default_reallocator);
-}
 static void cx_tree_iter_next(void *it) {
 struct cx_tree_iterator_s *iter = it;
 // TODO: support mutating iterator
 // TODO: implement
 }
 CxTreeIterator cx_tree_iterator(
 void *root,
-int passes,
+bool visit_on_exit,
 ptrdiff_t loc_children,
 ptrdiff_t loc_next
 ) {
 CxTreeIterator iter;
 iter.loc_children = loc_children;
 iter.loc_next = loc_next;
-iter.requested_passes = passes;
+iter.visit_on_exit = visit_on_exit;
-// invalidate iterator immediately when passes is invalid
-if ((passes & (CX_TREE_ITERATOR_ENTER |
-CX_TREE_ITERATOR_NEXT_CHILD |
-CX_TREE_ITERATOR_EXIT)) == 0) {
-iter.stack = NULL;
-iter.node = NULL;
-return iter;
-}
 // allocate stack
 iter.stack_capacity = 16;
 iter.stack = malloc(sizeof(void *) * 16);
 iter.depth = 0;
-// determine start
+// visit the root node
-if ((passes & CX_TREE_ITERATOR_ENTER) == 0) {
+iter.node = root;
-// we have to skip the first "entering" passes
+iter.counter = 1;
-void *s = NULL;
+iter.depth = 1;
-void *n = root;
+iter.stack[0] = root;
-iter.counter = 0;
+iter.exiting = false;
-do {
-iter.counter++;
-iter.source = s;
-iter.node = n;
-cx_tree_iter_stack_add(&iter, n);
-s = n;
-n = tree_children(n);
-} while (n != NULL);
-// found a leaf node s (might be root itself if it has no children)
-// check if there is a sibling
-n = tree_next(s);
-if (n == NULL) {
-// no sibling found, exit back to parent node
-// TODO: implement
-} else {
-// there is a sibling
-if ((passes & CX_TREE_ITERATOR_EXIT) == 0) {
-// no exit requested, conclude that only next_child is requested
-iter.source = s;
-iter.node = n;
-iter.counter++;
-iter.current_pass = CX_TREE_ITERATOR_NEXT_CHILD;
-} else {
-// exit requested, so we have found our first pass
-// iter.node and iter.source are still correct
-iter.current_pass = CX_TREE_ITERATOR_EXIT;
-}
-}
-} else {
-// enter passes are requested, we can start by entering the root node
-iter.source = NULL;
-iter.node = root;
-iter.current_pass = CX_TREE_ITERATOR_ENTER;
-iter.counter = 1;
-iter.depth = 1;
-iter.stack[0] = root;
-}
 // assign base iterator functions
 iter.base.mutating = false;
 iter.base.remove = false;
 iter.base.current_impl = NULL;

Mercurial > hg > ucx / file comparison

comparison: src/tree.c

src/tree.c