/* * Returns true if any node in tree1 intersects with any node from tree2. */ int mm_trees_intersect(char *tree1, char *tree2) { char *node_a, *node_b; node_a = rbtree_first(tree1); while (node_a) { node_b = rbtree_first(tree2); while (node_b) { /* Don't compare nodes to themselves */ if (node_a == node_b) { node_b = rbtree_next(node_b); continue; } /* If the runs are equal they intersect */ if (rbtree_compare_runs(node_b, node_a) == 0 || rbtree_compare_runs(node_a, node_b) == 0) { fprintf(stderr, "(%p, %p) ", node_a, node_b); return !0; } node_b = rbtree_next(node_b); } node_a = rbtree_next(node_a); } return 0; }
/* * Destroy the specified tree, calling the destructor destroy * for each node and then freeing the tree itself. */ void rbtree_destroy(struct rbtree *tree, void (*destroy)(void *)) { if (!tree) return; if (rbtree_first(tree)) _rbdestroy(tree, rbtree_first(tree), destroy); free(tree); }
/** call timeouts handlers, and return how long to wait for next one or -1 */ static void handle_timeouts(struct event_base* base, struct timeval* now, struct timeval* wait) { struct event* p; #ifndef S_SPLINT_S wait->tv_sec = (time_t)-1; #endif while((rbnode_t*)(p = (struct event*)rbtree_first(base->times)) !=RBTREE_NULL) { #ifndef S_SPLINT_S if(p->ev_timeout.tv_sec > now->tv_sec || (p->ev_timeout.tv_sec==now->tv_sec && p->ev_timeout.tv_usec > now->tv_usec)) { /* there is a next larger timeout. wait for it */ wait->tv_sec = p->ev_timeout.tv_sec - now->tv_sec; if(now->tv_usec > p->ev_timeout.tv_usec) { wait->tv_sec--; wait->tv_usec = 1000000 - (now->tv_usec - p->ev_timeout.tv_usec); } else { wait->tv_usec = p->ev_timeout.tv_usec - now->tv_usec; } return; } #endif /* event times out, remove it */ (void)rbtree_delete(base->times, p); p->ev_events &= ~EV_TIMEOUT; fptr_ok(fptr_whitelist_event(p->ev_callback)); (*p->ev_callback)(p->ev_fd, EV_TIMEOUT, p->ev_arg); } }
/* * Tries to allocate a suitably sized run from the free list. * * Returns the size of the allocated run and a pointer to it. * Returns 0 and NULL if no suitably sized run can be found. */ static size_t mmrun_allocate_freerun(size_t size, char **allocated) { /* Nothing to do if the free list is empty */ if (free_runs) { /* * Scan the free list linearly for a run that is of * the correct size (address ordered first-fit) */ int run_size; char *run = rbtree_first(free_runs); while (run && mmrun_get_largesize(run) < size) { run = rbtree_next(run); } /* If no run is found return NULL */ if (!run) { *allocated = NULL; return 0; } /* Remove the run from the free list */ rbtree_remove(run, &free_runs); run_size = mmrun_get_largesize(run); run_size = mmrun_split(size, run); *allocated = run; return run_size; } *allocated = NULL; return 0; }
static void rbtree_1(CuTest *tc) { /* tree should be empty on start. */ CuAssert(tc, "empty tree?", (rbtree_first((rbtree_t*)tree) == &rbtree_null_node)); CuAssert(tc, "empty tree?", (rbtree_last((rbtree_t*)tree) == &rbtree_null_node)); test_tree_integrity(tc, tree); }
/** * Assemble the rrsets in the anchors, ready for use by validator. * @param anchors: trust anchor storage. * @return: false on error. */ static int anchors_assemble_rrsets(struct val_anchors* anchors) { struct trust_anchor* ta; struct trust_anchor* next; size_t nods, nokey; lock_basic_lock(&anchors->lock); ta=(struct trust_anchor*)rbtree_first(anchors->tree); while((rbnode_type*)ta != RBTREE_NULL) { next = (struct trust_anchor*)rbtree_next(&ta->node); lock_basic_lock(&ta->lock); if(ta->autr || (ta->numDS == 0 && ta->numDNSKEY == 0)) { lock_basic_unlock(&ta->lock); ta = next; /* skip */ continue; } if(!anchors_assemble(ta)) { log_err("out of memory"); lock_basic_unlock(&ta->lock); lock_basic_unlock(&anchors->lock); return 0; } nods = anchors_ds_unsupported(ta); nokey = anchors_dnskey_unsupported(ta); if(nods) { log_nametypeclass(0, "warning: unsupported " "algorithm for trust anchor", ta->name, LDNS_RR_TYPE_DS, ta->dclass); } if(nokey) { log_nametypeclass(0, "warning: unsupported " "algorithm for trust anchor", ta->name, LDNS_RR_TYPE_DNSKEY, ta->dclass); } if(nods == ta->numDS && nokey == ta->numDNSKEY) { char b[257]; dname_str(ta->name, b); log_warn("trust anchor %s has no supported algorithms," " the anchor is ignored (check if you need to" " upgrade unbound and " #ifdef HAVE_LIBRESSL "libressl" #else "openssl" #endif ")", b); (void)rbtree_delete(anchors->tree, &ta->node); lock_basic_unlock(&ta->lock); if(anchors->dlv_anchor == ta) anchors->dlv_anchor = NULL; anchors_delfunc(&ta->node, NULL); ta = next; continue; } lock_basic_unlock(&ta->lock); ta = next; } lock_basic_unlock(&anchors->lock); return 1; }
net_interface_t *net_interface_first() { rbtree_node_t *retval; retval = rbtree_first(interface_tree); return ((retval) ? (((tree_node_t *) retval)->ni) : NULL); }
/***************************************************************************** * Reads frequency attributes into the pre-allocated freqs array. ****************************************************************************/ static void parse_freq_attrs(PS_T *ps, const char* tag, const xmlChar **attrs) { int i, ncore, seen, *idx; char *end_ptr; double value, sum; RBNODE_T *node; bool seen_bad; ncore = rbtree_size(ps->alph_ids); // initilize the freqs array if (ps->freqs == NULL) ps->freqs = mm_malloc(sizeof(double) * ncore); // reset freqs array; for (i = 0; i < ncore; i++) ps->freqs[i] = -1; seen = 0; seen_bad = false; sum = 0.0; // iterate over attributes for (i = 0; attrs[i] != NULL; i += 2) { idx = (int*)rbtree_get(ps->alph_ids, attrs[i]); if (idx != NULL) { assert(*idx < ncore); if (ps->freqs[*idx] != -1) { dreme_attr_parse_error(ps, PARSE_ATTR_DUPLICATE, tag, (const char*)attrs[i], NULL); continue; } seen++; errno = 0; // reset because we're about to check it value = strtod((const char*)attrs[i+1], &end_ptr); // allow out of range values, mainly because freqs can be very close to zero if (end_ptr == (const char*)attrs[i+1] || (errno && errno != ERANGE) || value < 0 || value > 1) { dreme_attr_parse_error(ps, PARSE_ATTR_BAD_VALUE, tag, (const char*)attrs[i], (const char*)attrs[i+1]); ps->freqs[*idx] = 0; // mark frequence as seen, even though it's bad seen_bad = true; continue; } ps->freqs[*idx] = value; sum += value; } } // check we got everthing if (seen < ncore) { // identify what we're missing for (node = rbtree_first(ps->alph_ids); node != NULL; node = rbtree_next(node)) { idx = (int*)rbtree_value(node); if (ps->freqs[*idx] == -1) { dreme_attr_parse_error(ps, PARSE_ATTR_MISSING, tag, (char*)rbtree_key(node), NULL); } } } else if (!seen_bad) { // check the frequencies sum to 1 double delta = sum - 1; delta = (delta < 0 ? -delta : delta); if (delta > (0.001 * ncore)) { // dreme writes background probabilities to 3 decimal places so assuming // the error on each is at maximum 0.001 then the total error for the // sum must be less than or equal to 0.004 error(ps, "Probabilities of %s do not sum to 1, got %g .\n", tag, sum); } } }
static bool _predicate (void) { int i; KeyValuePair_t n; struct rbtree tree; KeyValuePair_t *node; struct rbtree_node *result; rbtree_init (&tree, _compareFn, 0); for (i = 0; i < TreeSize; i++) { node = malloc (sizeof (KeyValuePair_t)); node->key = i; node->val = TreeSize + i; rbtree_insert ((struct rbtree_node *) &node->node, &tree); } // Lookup the nodes. for (i = 0; i < TreeSize; i++) { KeyValuePair_t *kvResult; n.key = i; kvResult = rbtree_container_of (rbtree_lookup ((struct rbtree_node *) &n.node, &tree), KeyValuePair_t, node); if (kvResult->key != i || kvResult->val != TreeSize + i) { return false; } } // This lookup should fail. n.key = TreeSize; result = rbtree_lookup ((struct rbtree_node *) &n.node, &tree); if (result != NULL) { return false; } //iterate (rbtree_first(&tree), iterateFn); result = rbtree_first(&tree); while (result) { KeyValuePair_t *kvResult = rbtree_container_of (result, KeyValuePair_t, node); struct rbtree_node *n = result; result = rbtree_next (result); rbtree_remove (n, &tree); free (kvResult); } // This lookup should fail because we just cleared the tree. n.key = TreeSize; n.key = 0; result = rbtree_lookup ((struct rbtree_node *) &n.node, &tree); if (result != NULL) { return false; } return true; }
/************************************************************************** * Puts counts into the spacing bins. **************************************************************************/ void bin_matches(int margin, int bin_size, RBTREE_T *sequences, MOTIF_T *primary_motif, SECONDARY_MOTIF_T *secondary_motif, int *matches) { int primary_len, secondary_len, secondary, secondary_pos, primary_rc, secondary_rc, quad, distance, max_distance; RBNODE_T *node; SECONDARY_MOTIF_T *smotif; SEQUENCE_T *sequence; SPACING_T *spacing; primary_len = get_motif_trimmed_length(primary_motif); smotif = secondary_motif; secondary_len = get_motif_trimmed_length(smotif->motif); // Note that distance counts from zero max_distance = margin - secondary_len; // for each sequence for (node = rbtree_first(sequences); node != NULL; node = rbtree_next(node)) { sequence = (SEQUENCE_T*)rbtree_value(node); secondary = matches[sequence->index]; // check for a match if (!secondary) continue; // convert the encoded form into easier to use form primary_rc = sequence->primary_match < 0; secondary_rc = secondary < 0; secondary_pos = (secondary_rc ? -secondary : secondary); // calculate the distance (counts from zero) and side if (secondary_pos <= margin) { distance = margin - secondary_pos - secondary_len + 1; if (primary_rc) {//rotate reference direction quad = RIGHT; } else { quad = LEFT; } } else { distance = secondary_pos - margin - primary_len - 1; if (primary_rc) {//rotate reference direction quad = LEFT; } else { quad = RIGHT; } } // check that we're within the acceptable range if (distance < 0 || distance > max_distance) { die("Secondary motif match not within margin as it should be due to prior checks!"); } // calculate the strand if (secondary_rc == primary_rc) { quad |= SAME; } else { quad |= OPPO; } // add a count to the frequencies spacing = smotif->spacings+(quad); spacing->bins[(int)(distance / bin_size)] += 1; smotif->total_spacings += 1; } }
static char *rbtree_next(char *node) { char *parent; if (rbtree_get_right(node)) return rbtree_first(rbtree_get_right(node)); while ((parent = rb_get_parent(node)) && rbtree_get_right(parent) == node) node = parent; return parent; }
static void _freeTree (struct rbtree *tree) { struct rbtree_node *node = rbtree_first(tree); while (node) { AddrToIndex *aiNode = rbtree_container_of (node, AddrToIndex, node); node = rbtree_next (node); free (aiNode); } }
static inline char *mmbin_get_available(char *bin) { char *run = rbtree_first(bin); /* Bitmap will be zero for any full run */ while (run && !mmrun_get_bitmap(run)) { run = rbtree_next(run); } return run; }
/** sum up the zone trees, in_use only */ static size_t sumtrees_inuse(struct val_neg_cache* neg) { size_t res = 0; struct val_neg_zone* z; struct val_neg_data* d; RBTREE_FOR(z, struct val_neg_zone*, &neg->tree) { /* get count of highest parent for num in use */ d = (struct val_neg_data*)rbtree_first(&z->tree); if(d && (rbnode_t*)d!=RBTREE_NULL) res += d->count; } return res; }
/*********************************************************************** * Convert a tree of motifs into an array of motifs with a count. * This is intended to allow backwards compatibility with the older * version. ***********************************************************************/ void motif_tree_to_array(RBTREE_T *motif_tree, MOTIF_T **motif_array, int *num) { int count, i; MOTIF_T *motifs; RBNODE_T *node; count = rbtree_size(motif_tree); motifs = mm_malloc(sizeof(MOTIF_T) * count); for (i = 0, node = rbtree_first(motif_tree); node != NULL; i++, node = rbtree_next(node)) { copy_motif((MOTIF_T*)rbtree_value(node), motifs+i); } *motif_array = motifs; *num = count; }
/* * Look for a node matching key in tree. * Returns a pointer to the node if found, else NULL. */ struct rbnode *rbtree_find_node(struct rbtree *tree, void *key) { struct rbnode *node = rbtree_first(tree); int res; while (node != rbnil(tree)) { if ((res = tree->compar(key, node->data)) == 0) { return (node); } node = res < 0 ? node->left : node->right; } return (NULL); }
/***************************************************************************** * MEME > training_set > /alphabet * Read in the number of symbols in the alphabet and if it is nucleotide or * amino-acid (RNA is apparently classed as nucleotide). ****************************************************************************/ void mxml_end_alphabet(void *ctx) { PARMSG_T *message; CTX_T *data; RBNODE_T *node; char *id, symbol; bool *exists; int i; data = (CTX_T*)ctx; if (data->alph == NULL) { // Custom alphabet alph_reader_done(data->alph_rdr); // report any errors that the alphabet reader found while (alph_reader_has_message(data->alph_rdr)) { message = alph_reader_next_message(data->alph_rdr); if (message->severity == SEVERITY_ERROR) { local_error(data, "Alphabet error: %s.\n", message->message); } else { local_warning(data, "Alphabet warning: %s.\n", message->message); } parmsg_destroy(message); } // try to get an alphabet data->alph = alph_reader_alphabet(data->alph_rdr); alph_reader_destroy(data->alph_rdr); data->alph_rdr = NULL; } else { // legacy alphabet exists = mm_malloc(sizeof(bool) * alph_size_core(data->alph)); // set list to false for (i = 0; i < alph_size_core(data->alph); i++) exists[i] = false; // check that id's were defined for all the core alphabet symbols for (node = rbtree_first(data->letter_lookup); node != NULL; node = rbtree_next(node)) { id = (char*)rbtree_key(node); symbol = ((char*)rbtree_value(node))[0]; if (exists[alph_indexc(data->alph, symbol)]) { // duplicate! local_error(data, "The letter identifier %s is not the first to refer to symbol %c.\n", id, symbol); } exists[alph_indexc(data->alph, symbol)] = true; } // now check for missing identifiers for (i = 0; i < alph_size_core(data->alph); i++) { if (!exists[i]) { // missing id for symbol local_error(data, "The symbol %c does not have an assigned identifier.\n", alph_char(data->alph, i)); } } free(exists); } }
int forwards_next_root(struct iter_forwards* fwd, uint16_t* dclass) { struct iter_forward_zone key; rbnode_t* n; struct iter_forward_zone* p; if(*dclass == 0) { /* first root item is first item in tree */ n = rbtree_first(fwd->tree); if(n == RBTREE_NULL) return 0; p = (struct iter_forward_zone*)n; if(dname_is_root(p->name)) { *dclass = p->dclass; return 1; } /* root not first item? search for higher items */ *dclass = p->dclass + 1; return forwards_next_root(fwd, dclass); } /* find class n in tree, we may get a direct hit, or if we don't * this is the last item of the previous class so rbtree_next() takes * us to the next root (if any) */ key.node.key = &key; key.name = (uint8_t*)"\000"; key.namelen = 1; key.namelabs = 0; key.dclass = *dclass; n = NULL; if(rbtree_find_less_equal(fwd->tree, &key, &n)) { /* exact */ return 1; } else { /* smaller element */ if(!n || n == RBTREE_NULL) return 0; /* nothing found */ n = rbtree_next(n); if(n == RBTREE_NULL) return 0; /* no higher */ p = (struct iter_forward_zone*)n; if(dname_is_root(p->name)) { *dclass = p->dclass; return 1; } /* not a root node, return next higher item */ *dclass = p->dclass+1; return forwards_next_root(fwd, dclass); } }
/* * Utility function for tree visualisation. * Use gdb to call it. */ void mm_print_tree(char *tree) { if (!tree) { printf("Empty\n"); return; } char *node = rbtree_first(tree); while (node) { printf("%p ", node); node = rbtree_next(node); } printf("\n"); }
/************************************************************************** * Calculate the total number of pvalue calculations that will be done * by the program. This number is used to correct the pvalues for multiple * tests using a bonferoni correction. **************************************************************************/ int calculate_test_count(int margin, int bin, int test_max, RBTREE_T *secondary_motifs) { int total_tests, quad_opt_count, quad_bin_count; SECONDARY_MOTIF_T *smotif; RBNODE_T *node; total_tests = 0; for (node = rbtree_first(secondary_motifs); node != NULL; node = rbtree_next(node)) { smotif = (SECONDARY_MOTIF_T*)rbtree_value(node); //the number of possible values for spacings in one quadrant quad_opt_count = margin - get_motif_trimmed_length(smotif->motif) + 1; //the number of bins in one quadrant (excluding a possible leftover bin) quad_bin_count = (int)(quad_opt_count / bin) + (quad_opt_count % bin ? 1 : 0); //add the number of tested bins total_tests += (test_max < quad_bin_count ? test_max : quad_bin_count) * 4; } return total_tests; }
int router_list(struct router_t* router, int (*func)(void* param, struct node_t* node), void* param) { int r = 0; struct rbitem_t* item; const struct rbtree_node_t* node; locker_lock(&router->locker); node = rbtree_first(&router->rbtree); while (node && 0 == r) { item = rbtree_entry(node, struct rbitem_t, link); r = func(param, item->node); node = rbtree_next(node); } locker_unlock(&router->locker); return r; }
void start_net_interfaces_lib(void) { tree_node_t *ptr = (tree_node_t *) rbtree_first(interface_tree); /* * Now loop and start drivers. */ while (ptr) { if (ptr->ni && ptr->ni->drv && ptr->ni->drv->start_fn(ptr->ni->unit)) { kerrprintf("Failed starting %s\n", ptr->ni->name); } else { kmsgprintf("Interface %s started, MTU %u\n", ptr->ni->name, ptr->ni->mtu); } ptr = (tree_node_t *) rbtree_next(interface_tree, &ptr->header, cmpfn); } }
/************************************************************************** * compute the list of ids for the most significant spacing **************************************************************************/ void compute_idset(int margin, int bin_size, RBTREE_T *sequences, MOTIF_T *primary_motif, SECONDARY_MOTIF_T *secondary_motif, int *matches) { int primary_len, secondary_len, secondary, secondary_pos, primary_rc, secondary_rc, quad, distance; RBNODE_T *node; SEQUENCE_T *sequence; if (secondary_motif->sig_count == 0) return; primary_len = get_motif_trimmed_length(primary_motif); secondary_len = get_motif_trimmed_length(secondary_motif->motif); // for each sequence for (node = rbtree_first(sequences); node != NULL; node = rbtree_next(node)) { sequence = (SEQUENCE_T*)rbtree_value(node); secondary = matches[sequence->index]; // check for a match if (!secondary) continue; // convert the encoded form into easier to use form primary_rc = sequence->primary_match < 0; secondary_rc = secondary < 0; secondary_pos = (secondary_rc ? -secondary : secondary); // calculate the distance and side // note that distance can be zero meaning the primary is next to the secondary if (secondary_pos <= margin) { distance = margin - secondary_pos - secondary_len + 1; quad = LEFT; } else { distance = secondary_pos - margin - primary_len; quad = RIGHT; } // calculate the strand if (secondary_rc == primary_rc) { quad |= SAME; } else { quad |= OPPO; } // add the sequence id to the set if the bin matches if (quad == secondary_motif->sigs->quad && (distance / bin_size) == secondary_motif->sigs->bin) { secondary_motif->seq_count += 1; secondary_motif->seqs = (int*)mm_realloc(secondary_motif->seqs, sizeof(int) * secondary_motif->seq_count); secondary_motif->seqs[secondary_motif->seq_count-1] = sequence->index; } } }
/* * Delete node 'z' from the tree and return its data pointer. */ void *rbtree_delete(struct rbtree *tree, struct rbnode *z) { struct rbnode *x, *y; void *data = z->data; if (z->left == rbnil(tree) || z->right == rbnil(tree)) { y = z; } else { y = rbsuccessor(tree, z); } x = (y->left == rbnil(tree)) ? y->right : y->left; if ((x->parent = y->parent) == rbtree_root(tree)) { rbtree_first(tree) = x; } else { if (y == y->parent->left) { y->parent->left = x; } else { y->parent->right = x; } } if (y->color == black) { rbrepair(tree, x); } if (y != z) { y->left = z->left; y->right = z->right; y->parent = z->parent; y->color = z->color; z->left->parent = z->right->parent = y; if (z == z->parent->left) { z->parent->left = y; } else { z->parent->right = y; } } free(z); tree->num_nodes--; return (data); }
void xfrd_write_state(struct xfrd_state* xfrd) { rbnode_t* p; const char* statefile = xfrd->nsd->options->xfrdfile; FILE *out; time_t now = xfrd_time(); DEBUG(DEBUG_XFRD,1, (LOG_INFO, "xfrd: write file %s", statefile)); out = fopen(statefile, "w"); if(!out) { log_msg(LOG_ERR, "xfrd: Could not open file %s for writing: %s", statefile, strerror(errno)); return; } fprintf(out, "%s\n", XFRD_FILE_MAGIC); fprintf(out, "# This file is written on exit by nsd xfr daemon.\n"); fprintf(out, "# This file contains slave zone information:\n"); fprintf(out, "# * timeouts (when was zone data acquired)\n"); fprintf(out, "# * state (OK, refreshing, expired)\n"); fprintf(out, "# * which master transfer to attempt next\n"); fprintf(out, "# The file is read on start (but not on reload) by nsd xfr daemon.\n"); fprintf(out, "# You can edit; but do not change statement order\n"); fprintf(out, "# and no fancy stuff (like quoted \"strings\").\n"); fprintf(out, "#\n"); fprintf(out, "# If you remove a zone entry, it will be refreshed.\n"); fprintf(out, "# This can be useful for an expired zone; it revives\n"); fprintf(out, "# the zone temporarily, from refresh-expiry time.\n"); fprintf(out, "# If you delete the file all slave zones are updated.\n"); fprintf(out, "#\n"); fprintf(out, "# Note: if you edit this file while nsd is running,\n"); fprintf(out, "# it will be overwritten on exit by nsd.\n"); fprintf(out, "\n"); fprintf(out, "filetime: %lld\t# %s\n", (long long)now, ctime(&now)); fprintf(out, "# The number of zone entries in this file\n"); fprintf(out, "numzones: %d\n", (int)xfrd->zones->count); fprintf(out, "\n"); for(p = rbtree_first(xfrd->zones); p && p!=RBTREE_NULL; p=rbtree_next(p)) { xfrd_zone_t* zone = (xfrd_zone_t*)p; fprintf(out, "zone: \tname: %s\n", zone->apex_str); fprintf(out, "\tstate: %d", (int)zone->state); fprintf(out, " # %s", zone->state==xfrd_zone_ok?"OK":( zone->state==xfrd_zone_refreshing?"refreshing":"expired")); fprintf(out, "\n"); fprintf(out, "\tmaster: %d\n", zone->master_num); fprintf(out, "\tnext_master: %d\n", zone->next_master); fprintf(out, "\tround_num: %d\n", zone->round_num); fprintf(out, "\tnext_timeout: %d", (zone->zone_handler_flags&EV_TIMEOUT)?(int)zone->timeout.tv_sec:0); if((zone->zone_handler_flags&EV_TIMEOUT)) { neato_timeout(out, "\t# =", zone->timeout.tv_sec); } fprintf(out, "\n"); xfrd_write_state_soa(out, "soa_nsd", &zone->soa_nsd, zone->soa_nsd_acquired, zone->apex); xfrd_write_state_soa(out, "soa_disk", &zone->soa_disk, zone->soa_disk_acquired, zone->apex); xfrd_write_state_soa(out, "soa_notify", &zone->soa_notified, zone->soa_notified_acquired, zone->apex); fprintf(out, "\n"); } fprintf(out, "%s\n", XFRD_FILE_MAGIC); DEBUG(DEBUG_XFRD,1, (LOG_INFO, "xfrd: written %d zones to state file", (int)xfrd->zones->count)); fclose(out); }
/************************************************************************** * Dump sequence matches sorted by the name of the sequence. * * Outputs Columns: * 1) Trimmed lowercase sequence with uppercase matches. * 2) Position of the secondary match within the whole sequence. * 3) Sequence fragment that the primary matched. * 4) Strand of the primary match (+|-) * 5) Sequence fragment that the secondary matched. * 6) Strand of the secondary match (+|-) * 7) Is the primary match on the same strand as the secondary (s|o) * 8) Is the secondary match downstream or upstream (d|u) * 9) The gap between the primary and secondary matches * 10) The name of the sequence * 11) The p-value of the bin containing the match (adjusted for # of bins) * ---if the FASTA input file sequence names are in Genome Browser format: * 12-14) Position of primary match in BED coordinates * 15) Position of primary match in Genome Browser coordinates * 16-18) Position of secondary match in BED coordinates * 19) Position of secondary match in Genome Browser coordinates * * If you wish to sort based on the gap column: * Sort individual output: * sort -n -k 9,9 -o seqs_primary_secondary.txt seqs_primary_secondary.txt * Or sort all outputs: * for f in seqs_*.txt; do sort -n -k 9,9 -o $f $f; done * Or to get just locations of primary motif in BED coordinates * where the secondary is on the opposite strand, upstream with a gap of 118bp: * awk '$7=="o" && $8=="u" && $9==118 {print $12"\t"$13"\t"$14;}' seqs_primary_secondary.txt * **************************************************************************/ static void dump_sequence_matches(FILE *out, int margin, int bin, double sigthresh, BOOLEAN_T sig_only, RBTREE_T *sequences, MOTIF_T *primary_motif, SECONDARY_MOTIF_T *secondary_motif, ARRAY_T **matches) { RBNODE_T *node; SEQUENCE_T *sequence; int idx, seqlen, i, j, start, end, secondary, secondary_pos, primary_len, secondary_len, distance; BOOLEAN_T primary_rc, secondary_rc, downstream; char *buffer, *seq, *primary_match, *secondary_match; ARRAY_T *secondary_array; ALPH_T *alph; // get the alphabet alph = get_motif_alph(primary_motif); // allocate a buffer for copying the trimmed sequence into and modify it seqlen = margin * 2 + get_motif_trimmed_length(primary_motif); buffer = (char*)mm_malloc(sizeof(char) * (seqlen + 1)); // get the lengths of the motifs primary_len = get_motif_trimmed_length(primary_motif); secondary_len = get_motif_trimmed_length(secondary_motif->motif); // allocate some strings for storing the matches primary_match = (char*)mm_malloc(sizeof(char) * (primary_len + 1)); secondary_match = (char*)mm_malloc(sizeof(char) * (secondary_len + 1)); // add null byte at the end of the match strings primary_match[primary_len] = '\0'; secondary_match[secondary_len] = '\0'; // iterate over all the sequences for (node = rbtree_first(sequences); node != NULL; node = rbtree_next(node)) { sequence = (SEQUENCE_T*)rbtree_value(node); primary_rc = get_array_item(0, sequence->primary_matches) < 0; //secondary = matches[sequence->index]; secondary_array = matches[sequence->index]; if (! secondary_array) continue; int n_secondary_matches = get_array_length(secondary_array); for (idx=0; idx<n_secondary_matches; idx++) { secondary = get_array_item(idx, secondary_array); secondary_rc = secondary < 0; secondary_pos = abs(secondary); // calculate the distance if (secondary_pos <= margin) { distance = margin - secondary_pos - secondary_len + 1; downstream = primary_rc; } else { distance = secondary_pos - margin - primary_len - 1; downstream = !primary_rc; } // copy the trimmed sequence seq = sequence->data; for (i = 0; i < seqlen; ++i) { buffer[i] = (alph_is_case_insensitive(alph) ? tolower(seq[i]) : seq[i]); } buffer[seqlen] = '\0'; // uppercase primary start = margin; end = margin + primary_len; for (i = start, j = 0; i < end; ++i, ++j) { buffer[i] = (alph_is_case_insensitive(alph) ? toupper(buffer[i]) : buffer[i]); primary_match[j] = buffer[i]; } // uppercase secondary // note orign was one, subtract 1 to make origin zero as required for arrays start = secondary_pos -1; end = start + secondary_len; for (i = start, j = 0; i < end; ++i, ++j) { buffer[i] = (alph_is_case_insensitive(alph) ? toupper(buffer[i]) : buffer[i]); secondary_match[j] = buffer[i]; } // get the p-value of the seconndary match SPACING_T *spacings; if (secondary_rc == primary_rc) { spacings = downstream ? secondary_motif->spacings+(SAME+RIGHT) : secondary_motif->spacings+(SAME+LEFT); } else { spacings = downstream ? secondary_motif->spacings+(OPPO+RIGHT) : secondary_motif->spacings+(OPPO+LEFT); } double p_value = spacings->pvalue[distance/bin]; // skip match if not significant and only reporting significant matches if (sig_only && (p_value > sigthresh)) continue; // output line to file fprintf(out, "%s %3d %s %s %s %s %s %s %3d %s %.1e", buffer, secondary_pos, primary_match, (primary_rc ? "-" : "+"), secondary_match, (secondary_rc ? "-" : "+"), (secondary_rc == primary_rc ? "s" : "o"), (downstream ? "d" : "u"), distance, sequence->name, p_value ); // Parse the sequence name to see if we can get genomic coordinates // and print additional columns with primary and secondary matches // in both BED and Genome Browser coordinates. char *chr_name; size_t chr_name_len; int start_pos, end_pos; if (parse_genomic_coordinates_helper( sequence->name, &chr_name, &chr_name_len, &start_pos, &end_pos)) { // Get the start and end of the primary match in // 0-relative, half-open genomic coordinates. int p_start = start_pos + fabs(get_array_item(0, sequence->primary_matches)) - 1; int p_end = p_start + primary_len; // Get the start and end of the secondary match in // 0-relative, half-open genomic coordinates. int s_start, s_end; if ( (!primary_rc && downstream) || (primary_rc && !downstream) ) { s_start = p_end + distance; s_end = s_start + secondary_len; } else { s_end = p_start - distance; s_start = s_end - secondary_len; } fprintf(out, " %s %d %d %s:%d-%d", chr_name, p_start, p_end, chr_name, p_start+1, p_end); fprintf(out, " %s %d %d %s:%d-%d\n", chr_name, s_start, s_end, chr_name, s_start+1, s_end); } else { fprintf(out, "\n"); } } // secondary match } // primary match free(buffer); free(primary_match); free(secondary_match); }
/* * If a node matching "data" already exists, a pointer to * the existant node is returned. Otherwise we return NULL. */ struct rbnode *rbtree_insert(struct rbtree *tree, void *data) { struct rbnode *node = rbtree_first(tree); struct rbnode *parent = rbtree_root(tree); int res; /* Find correct insertion point. */ while (node != rbnil(tree)) { parent = node; if ((res = tree->compar(data, node->data)) == 0) { return (node); } node = res < 0 ? node->left : node->right; } node = (struct rbnode *) malloc(sizeof(*node)); node->data = data; node->left = node->right = rbnil(tree); node->parent = parent; if (parent == rbtree_root(tree) || tree->compar(data, parent->data) < 0) { parent->left = node; } else { parent->right = node; } node->color = red; /* * If the parent node is black we are all set, if it is red we have * the following possible cases to deal with. We iterate through * the rest of the tree to make sure none of the required properties * is violated. * * 1) The uncle is red. We repaint both the parent and uncle black * and repaint the grandparent node red. * * 2) The uncle is black and the new node is the right child of its * parent, and the parent in turn is the left child of its parent. * We do a left rotation to switch the roles of the parent and * child, relying on further iterations to fixup the old parent. * * 3) The uncle is black and the new node is the left child of its * parent, and the parent in turn is the left child of its parent. * We switch the colors of the parent and grandparent and perform * a right rotation around the grandparent. This makes the former * parent the parent of the new node and the former grandparent. * * Note that because we use a sentinel for the root node we never * need to worry about replacing the root. */ while (node->parent->color == red) { struct rbnode *uncle; if (node->parent == node->parent->parent->left) { uncle = node->parent->parent->right; if (uncle->color == red) { node->parent->color = black; uncle->color = black; node->parent->parent->color = red; node = node->parent->parent; } else { /* if (uncle->color == black) */ if (node == node->parent->right) { node = node->parent; rotate_left(tree, node); } node->parent->color = black; node->parent->parent->color = red; rotate_right(tree, node->parent->parent); } } else { /* if (node->parent == node->parent->parent->right) */ uncle = node->parent->parent->left; if (uncle->color == red) { node->parent->color = black; uncle->color = black; node->parent->parent->color = red; node = node->parent->parent; } else { /* if (uncle->color == black) */ if (node == node->parent->left) { node = node->parent; rotate_right(tree, node); } node->parent->color = black; node->parent->parent->color = red; rotate_left(tree, node->parent->parent); } } } tree->num_nodes++; rbtree_first(tree)->color = black; /* first node is always black */ return (NULL); }
static void rbtree_7(CuTest *tc) { CuAssert(tc, "rbtree_first(tree) == findsmallest(tree->root)", rbtree_first(tree) == findsmallest(tree->root)); CuAssert(tc, "rbtree_last(tree) == findlargest(tree->root)", rbtree_last(tree) == findlargest(tree->root)); }
int main() { int i, count = 30; key_t key; RBTreeNodeHandle root = NULL; int test_addr = 0; key_t search_key = -1; key_t delete_key = -1; srand(1103515245); for (i = 1; i < count; ++i) { key = rand() % count; test_addr = key; AGILE_LOGI("key = %d", key); root = rbtree_insert(root, key, (void *)&test_addr); if (!(i % 188)){ AGILE_LOGI("[i = %d] set search key %d", i, key); search_key = key; } if (!(i % 373)){ AGILE_LOGI("[i = %d] set delete key %d", i, key); delete_key = key; } if (search_key > 0){ if (rbtree_get(root, search_key)) { AGILE_LOGI("[i = %d] search key %d success!", i, search_key); search_key = -1; } else { AGILE_LOGI("[i = %d] search key %d error!", i, search_key); return (-1); } } if (delete_key > 0) { AGILE_LOGI("****** Before delete: node number: %d, repeatKeyNum: %d", rbtree_dump(root, 0), rbtree_debug_getRepeatNum()); if (rbtree_delete(&root, delete_key) == 0) { AGILE_LOGI("[i = %d] delete key %d success (%d)", i, delete_key, ++deleteNum); delete_key = -1; } else { AGILE_LOGI("[i = %d] delete key %d error", i, delete_key); return -1; } AGILE_LOGI("****** After delete: node number: %d", rbtree_dump(root, 0)); /*return 0;*/ } /*rbtree_dump(root, 1);*/ } { RBTreeNodeHandle n; i = 0; for (n = rbtree_first(root); n; n = rbtree_next(n)) { AGILE_LOGI("index %d: key - %lld", i, n->key); i++; } } return 0; }
static void rbtree_remove(char *node, char **tree) { char *parent = rb_get_parent(node); char *left = rbtree_get_left(node); char *right = rbtree_get_right(node); char *next; int color; if (!left) next = right; else if (!right) next = left; else next = rbtree_first(right); if (parent) rb_set_child(next, parent, rbtree_get_left(parent) == node); else *tree = next; if (left && right) { color = rb_get_color(next); rb_set_color(rb_get_color(node), next); rb_set_left(left, next); rb_set_parent(next, left); if (next != right) { parent = rb_get_parent(next); rb_set_parent(rb_get_parent(node), next); node = rbtree_get_right(next); rb_set_left(node, parent); rb_set_right(right, next); rb_set_parent(next, right); } else { rb_set_parent(parent, next); parent = next; node = rbtree_get_right(next); } } else { color = rb_get_color(node); node = next; } /* * 'node' is now the sole successor's child and 'parent' its * new parent (since the successor can have been moved). */ if (node) rb_set_parent(parent, node); /* * The 'easy' cases. */ if (color == RB_RED) return; if (node && rb_is_red(node)) { rb_set_color(RB_BLACK, node); return; } do { if (node == *tree) break; if (node == rbtree_get_left(parent)) { char *sibling = rbtree_get_right(parent); if (rb_is_red(sibling)) { rb_set_color(RB_BLACK, sibling); rb_set_color(RB_RED, parent); rb_rotate_left(parent, tree); sibling = rbtree_get_right(parent); } if ((!rbtree_get_left(sibling) || rb_is_black(rbtree_get_left(sibling))) && (!rbtree_get_right(sibling) || rb_is_black(rbtree_get_right(sibling)))) { rb_set_color(RB_RED, sibling); node = parent; parent = rb_get_parent(parent); continue; } if (!rbtree_get_right(sibling) || rb_is_black(rbtree_get_right(sibling))) { rb_set_color(RB_BLACK, rbtree_get_left(sibling)); rb_set_color(RB_RED, sibling); rb_rotate_right(sibling, tree); sibling = rbtree_get_right(parent); } rb_set_color(rb_get_color(parent), sibling); rb_set_color(RB_BLACK, parent); rb_set_color(RB_BLACK, rbtree_get_right(sibling)); rb_rotate_left(parent, tree); node = *tree; break; } else { char *sibling = rbtree_get_left(parent); if (rb_is_red(sibling)) { rb_set_color(RB_BLACK, sibling); rb_set_color(RB_RED, parent); rb_rotate_right(parent, tree); sibling = rbtree_get_left(parent); } if ((!rbtree_get_left(sibling) || rb_is_black(rbtree_get_left(sibling))) && (!rbtree_get_right(sibling) || rb_is_black(rbtree_get_right(sibling)))) { rb_set_color(RB_RED, sibling); node = parent; parent = rb_get_parent(parent); continue; } if (!rbtree_get_left(sibling) || rb_is_black(rbtree_get_left(sibling))) { rb_set_color(RB_BLACK, rbtree_get_right(sibling)); rb_set_color(RB_RED, sibling); rb_rotate_left(sibling, tree); sibling = rbtree_get_left(parent); } rb_set_color(rb_get_color(parent), sibling); rb_set_color(RB_BLACK, parent); rb_set_color(RB_BLACK, rbtree_get_left(sibling)); rb_rotate_right(parent, tree); node = *tree; break; } } while (rb_is_black(node)); if (node) rb_set_color(RB_BLACK, node); }