void ipset_assignment_set(struct ipset_assignment *assignment, ipset_variable var, enum ipset_tribool value) { /* Ensure that the vector is big enough to hold this variable * assignment, inserting new EITHERs if needed. */ if (var >= cork_array_size(&assignment->values)) { unsigned int old_len = cork_array_size(&assignment->values); /* Expand the array. */ cork_array_ensure_size(&assignment->values, var+1); assignment->values.size = var+1; /* Fill in EITHERs in the newly allocated elements. */ if (var != old_len) { unsigned int i; for (i = old_len; i < var; i++) { cork_array_at(&assignment->values, i) = IPSET_EITHER; } } } /* Assign the desired value. */ cork_array_at(&assignment->values, var) = value; }
static int vrt_queue_add_producer(struct vrt_queue *q, struct vrt_producer *p) { clog_debug("[%s] Add producer %s", q->name, p->name); /* Add the producer to the queue's array and assign its index. */ cork_array_append(&q->producers, p); p->queue = q; p->index = cork_array_size(&q->producers) - 1; /* Choose the right claim and publish implementations for this * producer. */ if (p->index == 0) { /* If this is the first producer, use faster claim and publish * methods that are optimized for the single-producer case. */ p->claim = vrt_claim_single_threaded; p->publish = vrt_publish_single_threaded; } else { /* Otherwise we need to use slower, but multiple-producer- * capable, implementations of claim and publish. */ p->claim = vrt_claim_multi_threaded; p->publish = vrt_publish_multi_threaded; /* If this is the second producer, then we need to update the * first producer to also use the slower implementations. */ if (p->index == 1) { struct vrt_producer *first = cork_array_at(&q->producers, 0); first->claim = vrt_claim_multi_threaded; first->publish = vrt_publish_multi_threaded; } } return 0; }
static vrt_value_id vrt_minimum_cursor(vrt_consumer_array *cs) { /* We know there's always at least one consumer */ unsigned int i; vrt_value_id minimum = vrt_consumer_get_cursor(cork_array_at(cs, 0)); for (i = 1; i < cork_array_size(cs); i++) { vrt_value_id id = vrt_consumer_get_cursor(cork_array_at(cs, i)); if (vrt_mod_lt(id, minimum)) { minimum = id; } } return minimum; }
size_t ipset_node_reachable_count(const struct ipset_node_cache *cache, ipset_node_id node) { /* Create a set to track when we've visited a given node. */ struct cork_hash_table *visited = cork_pointer_hash_table_new(0, 0); /* And a queue of nodes to check. */ cork_array(ipset_node_id) queue; cork_array_init(&queue); if (ipset_node_get_type(node) == IPSET_NONTERMINAL_NODE) { DEBUG("Adding node %u to queue", node); cork_array_append(&queue, node); } /* And somewhere to store the result. */ size_t node_count = 0; /* Check each node in turn. */ while (!cork_array_is_empty(&queue)) { ipset_node_id curr = cork_array_at(&queue, --queue.size); /* We don't have to do anything if this node is already in the * visited set. */ if (cork_hash_table_get(visited, (void *) (uintptr_t) curr) == NULL) { DEBUG("Visiting node %u for the first time", curr); /* Add the node to the visited set. */ cork_hash_table_put (visited, (void *) (uintptr_t) curr, (void *) (uintptr_t) true, NULL, NULL, NULL); /* Increase the node count. */ node_count++; /* And add the node's nonterminal children to the visit * queue. */ struct ipset_node *node = ipset_node_cache_get_nonterminal(cache, curr); if (ipset_node_get_type(node->low) == IPSET_NONTERMINAL_NODE) { DEBUG("Adding node %u to queue", node->low); cork_array_append(&queue, node->low); } if (ipset_node_get_type(node->high) == IPSET_NONTERMINAL_NODE) { DEBUG("Adding node %u to queue", node->high); cork_array_append(&queue, node->high); } } } /* Return the result, freeing everything before we go. */ cork_hash_table_free(visited); cork_array_done(&queue); return node_count; }
bool ipset_assignment_equal(const struct ipset_assignment *assignment1, const struct ipset_assignment *assignment2) { /* Identical pointers are trivially equal. */ if (assignment1 == assignment2) { return true; } /* Otherwise we compare the assignments piecewise up through the end * of the smaller vector. */ unsigned int size1 = cork_array_size(&assignment1->values); unsigned int size2 = cork_array_size(&assignment2->values); unsigned int smaller_size = (size1 < size2)? size1: size2; unsigned int i; for (i = 0; i < smaller_size; i++) { if (cork_array_at(&assignment1->values, i) != cork_array_at(&assignment2->values, i)) { return false; } } /* If one of the assignment vectors is longer, any remaining * elements must be indeterminate. */ if (size1 > smaller_size) { for (i = smaller_size; i < size1; i++) { if (cork_array_at(&assignment1->values, i) != IPSET_EITHER) { return false; } } } if (size2 > smaller_size) { for (i = smaller_size; i < size2; i++) { if (cork_array_at(&assignment2->values, i) != IPSET_EITHER) { return false; } } } /* If we make it through all of that, the two assignments are equal. */ return true; }
void ipset_node_cache_free(struct ipset_node_cache *cache) { size_t i; for (i = 0; i < cork_array_size(&cache->chunks); i++) { free(cork_array_at(&cache->chunks, i)); } cork_array_done(&cache->chunks); cork_hash_table_free(cache->node_cache); free(cache); }
void ipset_bdd_iterator_advance(struct ipset_bdd_iterator *iterator) { /* If we're already at the end of the iterator, don't do anything. */ if (CORK_UNLIKELY(iterator->finished)) { return; } /* We look at the last node in the stack. If it's currently * assigned a false value, then we track down its true branch. If * it's got a true branch, then we pop it off and check the next to * last node. */ DEBUG("Advancing BDD iterator"); while (cork_array_size(&iterator->stack) > 0) { ipset_node_id last_node_id = cork_array_at (&iterator->stack, cork_array_size(&iterator->stack) - 1); struct ipset_node *last_node = ipset_node_cache_get_nonterminal(iterator->cache, last_node_id); enum ipset_tribool current_value = ipset_assignment_get(iterator->assignment, last_node->variable); /* The current value can't be EITHER, because we definitely * assign a TRUE or FALSE to the variables of the nodes that we * encounter. */ if (current_value == IPSET_TRUE) { /* We've checked both outgoing edges for this node, so pop * it off and look at its parent. */ iterator->stack.size--; /* Before continuing, reset this node's variable to * indeterminate in the assignment. */ ipset_assignment_set (iterator->assignment, last_node->variable, IPSET_EITHER); } else { /* We've checked this node's low edge, but not its high * edge. Set the variable to TRUE in the assignment, and * add the high edge's node to the node stack. */ ipset_assignment_set (iterator->assignment, last_node->variable, IPSET_TRUE); add_node(iterator, last_node->high); return; } } /* If we fall through then we ran out of nodes to check. That means * the iterator is done! */ iterator->finished = true; }
enum ipset_tribool ipset_assignment_get(struct ipset_assignment *assignment, ipset_variable var) { if (var < cork_array_size(&assignment->values)) { /* If the requested variable is in the range of the values * array, return whatever is stored there. */ return cork_array_at(&assignment->values, var); } else { /* Variables htat aren't in the values array are always EITHER. */ return IPSET_EITHER; } }
static void execute(int argc, char **argv) { size_t i; bz_load_repositories(); satisfy_dependencies(&buzzy_install, argc, argv); for (i = 0; i < cork_array_size(&dep_packages); i++) { struct bz_package *package = cork_array_at(&dep_packages, i); ri_check_error(bz_package_install(package)); } free_dependencies(); bz_finalize_actions(); exit(EXIT_SUCCESS); }