SEXP rph_tree_rename(SEXP treeVec, SEXP oldNamesP, SEXP newNamesP) {
int i, numtree = LENGTH(treeVec), treeIdx;
TreeNode *tr, *n;
SEXP result;
Hashtable *hash = hsh_new(20);
char *str;
for (i=0; i<LENGTH(oldNamesP); i++) {
str = smalloc((strlen(CHAR(STRING_ELT(newNamesP, i)))+1)*sizeof(char));
strcpy(str, CHAR(STRING_ELT(newNamesP, i)));
hsh_put(hash, CHAR(STRING_ELT(oldNamesP, i)), str);
}
PROTECT(result = NEW_CHARACTER(numtree));
for (treeIdx=0; treeIdx < numtree; treeIdx++) {
tr = rph_tree_new(STRING_ELT(treeVec, treeIdx));
// tr = tr_new_from_string(CHAR(STRING_ELT(treeVec, treeIdx)));
for (i=0; i<tr->nnodes; i++) {
n = lst_get_ptr(tr->nodes, i);
if (n->name[0] != '\0' &&
(str = hsh_get(hash, n->name)) != (char*)-1)
strcpy(n->name, str);
}
str = tr_to_string(tr, 1);
SET_STRING_ELT(result, treeIdx, mkChar(str));
}
UNPROTECT(1);
return result;
}
/* Create a category map with a category for each feature type in a
GFF_Set. Category numbers are assigned in order of appearance of
types */
CategoryMap* cm_new_from_features(GFF_Set *feats) {
int i;
CategoryMap *retval;
Hashtable *hash;
List *types;
/* first scan features for all types */
hash = hsh_new(10);
types = lst_new_ptr(10);
for (i = 0; i < lst_size(feats->features); i++) {
GFF_Feature *f = lst_get_ptr(feats->features, i);
checkInterruptN(i, 10000);
if (hsh_get(hash, f->feature->chars) == (void*)-1) {
lst_push_ptr(types, f->feature);
hsh_put_int(hash, f->feature->chars, 1);
}
}
hsh_free(hash);
/* now create a simple category map */
retval = cm_new(lst_size(types));
for (i = 0; i <= retval->ncats; i++) {
String *type = i == 0 ? str_new_charstr(BACKGD_CAT_NAME) :
str_dup(lst_get_ptr(types, i-1));
retval->ranges[i] = cm_new_category_range(type, i, i);
}
lst_free(types);
return retval;
}
/*
open a file with name out_root.name.maf, or returns it if already open.
This is a bit messy because in some cases (splitting by feature) there may
be more output files than the OS can handle. But it would be computationally
expensive to check and see which files are finished, assuming that the MAF is
sorted.
So, if it tries to open a file and fails, it the goes through the list of
filehandles, finds an open one, closes it, and tries to open the new one
again. Repeat until successful.
Then, if a filehandle needs to be re-opened, it is opened with append. Again,
if this is not successful, it looks for another file to close. If it can't
find one the program reports an error and dies.
Finally, close_outfiles below checks and makes sure that all files
are closed with mafBlock_close_file in the end, so that they get the #eof
closer.
*/
FILE *get_outfile(List *outfileList, Hashtable *outfileHash, String *name, char *out_root,
int argc, char *argv[]) {
int idx, i;
FILE *outfile;
char *fname = smalloc((strlen(out_root)+name->length+7)*sizeof(char));
sprintf(fname, "%s.%s.maf", out_root, name->chars);
idx = ptr_to_int(hsh_get(outfileHash, fname));
if (idx == -1) {
hsh_put(outfileHash, fname, int_to_ptr(lst_size(outfileList)));
outfile = mafBlock_open_outfile(fname, argc, argv);
while (outfile==NULL) { //too many files are open, close one first
for (i=0; i<lst_size(outfileList); i++) {
outfile = (FILE*)lst_get_ptr(outfileList, i);
if (outfile != NULL) break;
}
if (i == lst_size(outfileList)) {
die("ERROR: too many files open in maf_parse\n");
} else {
phast_fclose(outfile);
lst_set_ptr(outfileList, i, NULL);
}
outfile = mafBlock_open_outfile(fname, argc, argv);
}
lst_push_ptr(outfileList, (void*)outfile);
sfree(fname);
return outfile;
}
outfile = (FILE*)lst_get_ptr(outfileList, idx);
if (outfile == NULL) { //has already been opened but then closed.
outfile = phast_fopen_no_exit(fname, "a");
while (outfile == NULL) {
for (i=0; i<lst_size(outfileList); i++) {
outfile = (FILE*)lst_get_ptr(outfileList, i);
if (outfile != NULL) break;
}
if (i == lst_size(outfileList)) {
die("ERROR: too many files open in maf_parse\n");
} else {
phast_fclose(outfile);
lst_set_ptr(outfileList, i, NULL);
}
outfile = phast_fopen_no_exit(fname, "a");
}
lst_set_ptr(outfileList, idx, (void*)outfile);
}
sfree(fname);
return outfile;
}
static void
config_done(config_ctx* ctx)
{
char key[MAXPATHLEN];
rb_item* it;
rb_poller* poll;
char *t;
/* No polling specified */
if(ctx->items)
{
/* Make sure we found an interval */
if(ctx->interval == 0)
errx(2, "%s: no interval specified", ctx->confname);
if(ctx->timeout == 0)
ctx->timeout = g_state.timeout;
/* And a nice key for lookups
* The key uses the configuration file name if 1 or more rrd files
* are specified.
* Otherwise we're using default rrd file path, so we can point to
* our file_path->path to it with worrying about memory management.
*
* These changes mean that configuration files using the same
* rrd files are no longer merged into a single poll.
*/
if(ctx->rrdlist)
snprintf(key, sizeof(key), "%d-%d:%s", ctx->timeout, ctx->interval,
ctx->confname);
else
snprintf(key, sizeof(key), "%d-%d:%s/%s.rrd", ctx->timeout,
ctx->interval, g_state.rrddir, ctx->confname);
key[sizeof(key) - 1] = 0;
/* See if we have one of these pollers already */
poll = (rb_poller*)hsh_get(g_state.poll_by_key, key, -1);
if(!poll)
{
poll = (rb_poller*)xcalloc(sizeof(*poll));
strcpy(poll->key, key);
if(!ctx->rrdlist)
{
/* Use default location */
/* Point path into the key */
t = strchr(poll->key, ':');
ASSERT(t);
ctx->rrdlist = (file_path*)xcalloc(sizeof(*ctx->rrdlist));
/* Skip the ':' */
ctx->rrdlist->path = t + 1;
ctx->rrdlist->next = NULL;
}
poll->rawlist = ctx->rawlist;
poll->rrdlist = ctx->rrdlist;
poll->interval = ctx->interval * 1000;
poll->timeout = ctx->timeout * 1000;
/* Add it to the main lists */
poll->next = g_state.polls;
g_state.polls = poll;
/* And into the hashtable */
if(!hsh_set(g_state.poll_by_key, poll->key, -1, poll))
errx(1, "out of memory");
}
/* Get the last item and add to the list */
for(it = ctx->items; it->next; it = it->next)
it->poller = poll;
ASSERT(it);
it->poller = poll;
/* Add the items to this poller */
it->next = poll->items;
poll->items = ctx->items;
}
/*
* This remains allocated for the life of the program as
* All the configuration strings are in this memory.
* This allows all the users of these strings not to worry
* about reallocating or freeing them
*/
/* Clear current config and get ready for next */
ctx->items = NULL;
ctx->rrdlist = NULL;
ctx->rawlist = NULL;
ctx->interval = 0;
ctx->timeout = 0;
}
int main(int argc, char *argv[]) {
/* variables for options, with defaults */
TreeNode *tree = NULL, *merge_tree = NULL, *extrapolate_tree = NULL;
Hashtable *rename_hash = NULL;
double scale_factor = 1;
List *prune_names = NULL, *label = NULL, *labelType = NULL;
int prune_all_but = FALSE, tree_only = FALSE, dissect = FALSE,
name_ancestors = FALSE, with_branch = FALSE, print_branchlen=FALSE,
inNewick=FALSE, no_branchlen = FALSE, print_distance_to_root = FALSE;
TreeModel *mod = NULL, *merge_mod = NULL;
char *reroot_name = NULL, *subtree_name =NULL, *get_subtree_name = NULL,
*node_distance_name = NULL;
/* other variables */
String *suffix, *optstr;
char c;
int i, opt_idx;
TreeNode *n;
struct option long_opts[] = {
{"scale", 1, 0, 's'},
{"extrapolate", 1, 0, 'e'},
{"prune", 1, 0, 'p'},
{"prune-all-but", 1, 0, 'P'},
{"get-subtree", 1, 0, 'g'},
{"merge", 1, 0, 'm'},
{"rename", 1, 0, 'r'},
{"tree-only", 0, 0, 't'},
{"no-branchlen", 0, 0, 'N'},
{"dissect", 0, 0, 'd'},
{"name-ancestors", 0, 0, 'a'},
{"reroot", 1, 0, 'R'},
{"with-branch", 1, 0, 'B'},
{"subtree", 1, 0, 'S'},
{"branchlen", 0, 0, 'b'},
{"newick", 0, 0, 'n'},
{"label-subtree", 1, 0, 'L'},
{"label-branches", 1, 0, 'l'},
{"help", 0, 0, 'h'},
{0, 0, 0, 0}
};
while ((c = getopt_long(argc, argv, "s:p:P:g:m:r:R:B:S:D:l:L:adtNbnh",
long_opts, &opt_idx)) != -1) {
switch (c) {
case 's':
scale_factor = get_arg_dbl_bounds(optarg, 0, INFTY);
break;
case 'e':
if (!strcmp(optarg, "default")) {
optarg = smalloc(1000 * sizeof(char));
#if defined(__MINGW32__)
sprintf(optarg, "%s\\data\\exoniphy\\mammals\\cftr25_hybrid.nh",
PHAST_HOME);
#else
sprintf(optarg, "%s/data/exoniphy/mammals/cftr25_hybrid.nh",
PHAST_HOME);
#endif
}
extrapolate_tree = tr_new_from_file(phast_fopen(optarg, "r"));
break;
case 'p':
prune_names = get_arg_list(optarg);
break;
case 'P':
prune_names = get_arg_list(optarg);
prune_all_but = TRUE;
break;
case 'g':
get_subtree_name = optarg;
break;
case 'm':
suffix = str_new_charstr(optarg);
str_suffix(suffix, '.');
if (str_equals_charstr(suffix, "nh"))
merge_tree = tr_new_from_file(phast_fopen(optarg, "r"));
else {
merge_mod = tm_new_from_file(phast_fopen(optarg, "r"), 1);
merge_tree = merge_mod->tree;
}
break;
case 'r':
rename_hash = make_name_hash(optarg);
break;
case 't':
tree_only = TRUE;
break;
case 'N':
no_branchlen = TRUE;
tree_only = TRUE;
break;
case 'd':
dissect = TRUE;
break;
case 'b':
print_branchlen = TRUE;
break;
case 'D':
print_distance_to_root = TRUE;
node_distance_name = optarg;
break;
case 'R':
reroot_name = optarg;
break;
case 'B':
with_branch = TRUE;
break;
case 'a':
name_ancestors = TRUE;
break;
case 'S':
subtree_name = optarg;
break;
case 'n':
inNewick=TRUE;
break;
case 'L': //do the same for --label--subtree and --label-branches
case 'l':
if (label == NULL) {
label = lst_new_ptr(1);
labelType = lst_new_int(1);
}
optstr = str_new_charstr(optarg);
lst_push_ptr(label, optstr);
lst_push_int(labelType, (int)c);
break;
case 'h':
usage(argv[0]);
case '?':
die("Bad argument. Try '%s -h'.\n", argv[0]);
}
}
if (optind != argc - 1)
die("Input filename required. Try '%s -h'.\n", argv[0]);
if (merge_tree != NULL && extrapolate_tree != NULL)
die("ERROR: Can't use --merge and --extrapolate together");
set_seed(-1);
suffix = str_new_charstr(argv[optind]);
str_suffix(suffix, '.');
if (inNewick || str_equals_charstr(suffix, "nh")) {
tree = tr_new_from_file(phast_fopen(argv[optind], "r"));
tree_only = TRUE; /* can't output tree model in this case */
}
else {
mod = tm_new_from_file(phast_fopen(argv[optind], "r"), 1);
tree = mod->tree;
}
if (prune_names != NULL) {
tr_prune(&tree, prune_names, prune_all_but, NULL);
if (mod != NULL) mod->tree = tree; /* root may have changed */
}
if (get_subtree_name != NULL) {
n = tr_get_node(tree, get_subtree_name);
if (n == NULL) {
tr_name_ancestors(tree);
n = tr_get_node(tree, get_subtree_name);
if (n == NULL) {
die("ERROR: no node named '%s'.\n", subtree_name);
}
}
tr_prune_supertree(&tree, n);
if (mod != NULL) mod->tree = tree;
}
if (merge_tree != NULL) {
tree = tr_hybrid(tree, merge_tree);
if (mod != NULL) mod->tree = tree;
}
else if (extrapolate_tree != NULL) {
tr_scale_by_subtree(extrapolate_tree, tree);
tree = extrapolate_tree;
if (mod != NULL) mod->tree = tree;
}
if (scale_factor != 1) {
if (subtree_name == NULL)
tr_scale(tree, scale_factor);
else {
n = tr_get_node(tree, subtree_name);
if (n == NULL) die("ERROR: no node named '%s'.\n", subtree_name);
tr_scale_subtree(tree, n, scale_factor, with_branch);
}
}
if (name_ancestors)
tr_name_ancestors(tree);
if (rename_hash != NULL) {
char *newname;
for (i = 0; i < tree->nnodes; i++) {
n = lst_get_ptr(tree->nodes, i);
if (n->name != NULL && n->name[0] != '\0' &&
(newname = hsh_get(rename_hash, n->name)) != (char*)-1) {
strcpy(n->name, newname);
}
}
}
if (reroot_name != NULL) {
n = tr_get_node(tree, reroot_name);
if (n == NULL) die("ERROR: no node named '%s'.\n", reroot_name);
tr_reroot(tree, n, with_branch);
if (mod != NULL) mod->tree = with_branch ? n->parent : n;
tree = with_branch ? n->parent : n;
}
if (label != NULL) {
for (i=0; i < lst_size(label); i++) {
String *currstr = (String*)lst_get_ptr(label, i), *arg1, *labelVal;
List *tmplst = lst_new_ptr(10);
String *nodename;
int j;
str_split(currstr, ":", tmplst);
if (lst_size(tmplst) != 2)
die("ERROR: bad argument to --label-branches or --label-subtree.\n");
arg1 = lst_get_ptr(tmplst, 0);
labelVal = lst_get_ptr(tmplst, 1);
lst_clear(tmplst);
if (lst_get_int(labelType, i) == (int)'l') {
str_split(arg1, ",", tmplst);
for (j=0; j < lst_size(tmplst); j++) {
nodename = (String*)lst_get_ptr(tmplst, j);
tr_label_node(tree, nodename->chars, labelVal->chars);
}
lst_free_strings(tmplst);
} else if (lst_get_int(labelType, i) == (int)'L') {
int include_leading_branch = FALSE;
TreeNode *node;
nodename = arg1;
node = tr_get_node(tree, nodename->chars);
if (node == NULL && nodename->chars[nodename->length-1] == '+') {
nodename->chars[--nodename->length] = '\0';
node = tr_get_node(tree, nodename->chars);
include_leading_branch = TRUE;
}
tr_label_subtree(tree, nodename->chars, include_leading_branch,
labelVal->chars);
} else die("ERROR got label_type %c\n", lst_get_int(labelType, (char)i));
str_free(arg1);
str_free(labelVal);
lst_free(tmplst);
str_free(currstr);
}
lst_free(label);
lst_free(labelType);
}
if (dissect)
tr_print_nodes(stdout, tree);
if (print_branchlen)
printf("TOTAL_TREE_LEN: %f\n", tr_total_len(tree));
if (print_distance_to_root) {
TreeNode *node = tr_get_node(tree, node_distance_name);
if (node == NULL)
die("ERROR: no node named '%s'.\n", node_distance_name);
printf("length(root-%s): %f\n", node_distance_name,
tr_distance_to_root(node));
}
if (dissect==0 && print_branchlen==0 && print_distance_to_root==0) {
if (tree_only)
tr_print(stdout, tree, no_branchlen==FALSE);
else
tm_print(stdout, mod);
}
return 0;
}
