void show_pfiles (CHAR_DATA *ch, char *x)
{
DIR *dp;
struct dirent *dentry;
char directory_name[100];
sh_int count = 0;
ch_printf( ch, "&w&W&W&CPfiles Starting With %s\n\r", capitalize(x) );
ch_printf( ch, "&B-----------------------\n\r" );
sprintf( directory_name, "%s%s", PLAYER_DIR, x );
dp = opendir( directory_name );
dentry = readdir( dp );
while ( dentry )
{
if ( dentry->d_name[0] != '.' && str_suffix(".home", dentry->d_name) && str_suffix(".clone", dentry->d_name) )
{
ch_printf(ch, "&O%s&w&W&W\n\r\n\r", dentry->d_name);
count++;
}
dentry = readdir( dp );
}
closedir( dp );
if ( count == 0 )
{
send_to_char("&RThere are no pfiles beginning with that letter!&w&W&W\n\r", ch);
}
else
{
ch_printf(ch, "&WTotal %s Pfiles: &R%d&w&W&W\n\r", capitalize(x), count);
}
ch_printf( ch, "&B-----------------------" );
return;
}
void scan_forcers( CHAR_DATA *ch )
{
DIR *dp;
struct dirent *dentry;
char directory_name[100];
sh_int alpha_loop;
ch_printf( ch, "&w&W&W&CForcers&w&W&W\n\r");
ch_printf( ch, "&B-----------------------&w&W&W\n\r" );
for ( alpha_loop = 0; alpha_loop <= 25; alpha_loop++ )
{
sprintf( directory_name, "%s%c", PLAYER_DIR, 'a' + alpha_loop );
dp = opendir( directory_name );
dentry = readdir( dp );
while ( dentry )
{
if ( dentry->d_name[0] != '.' && str_suffix(".home1", dentry->d_name) && str_suffix(".home2", dentry->d_name) && str_suffix(".home3", dentry->d_name) && str_suffix(".clone", dentry->d_name) )
{
read_fpfile( ch, directory_name, dentry->d_name);
}
dentry = readdir( dp );
}
closedir( dp );
}
ch_printf( ch, "&B-----------------------&w&W&W\n\r" );
return;
}
bool check_ban( char *site, int type )
{
BAN_DATA * pban;
char host[ MAX_STRING_LENGTH ];
strcpy( host, capitalize( site ) );
host[ 0 ] = LOWER( host[ 0 ] );
for ( pban = ban_list; pban != NULL; pban = pban->next )
{
if ( !IS_SET( pban->ban_flags, type ) )
continue;
if ( IS_SET( pban->ban_flags, BAN_PREFIX )
&& IS_SET( pban->ban_flags, BAN_SUFFIX )
&& strstr( pban->site, host ) != NULL )
return TRUE;
if ( IS_SET( pban->ban_flags, BAN_PREFIX )
&& !str_suffix( pban->site, host ) )
return TRUE;
if ( IS_SET( pban->ban_flags, BAN_SUFFIX )
&& !str_prefix( pban->site, host ) )
return TRUE;
}
return FALSE;
}
string
C_mpmOverlay::curvFileName_get(
EOVERLAY ae_overlay
)
//
// ARGS
// ae_overlay enum overlay enumeration
//
// DESC
// This method returns the filename for a given overlay, based
// on current hemisphere and env surface choice.
//
{
string str_hemi = mps_env->str_hemi;
string str_prefix("");
string str_suffix("");
string str_curvFileName("");
str_prefix = mstr_curvPrefixTemplate[ae_overlay];
str_findAndReplace(str_prefix, "HEMI.", str_hemi);
str_findAndReplace(str_prefix, "SURF.", mstr_surface);
str_suffix = mstr_curvSuffix[ae_overlay];
str_curvFileName = str_prefix + str_suffix;
return str_curvFileName;
}
bool check_ban(char *site,int type)
{
BAN_DATA *pban;
char host[MAX_STRING_LENGTH];
char *p = host;
strcpy(host,site);
while (*p != '\0')
{
*p = LOWER(*p);
p++;
}
for ( pban = ban_list; pban != NULL; pban = pban->next )
{
if(!IS_SET(pban->ban_flags,type))
continue;
if (IS_SET(pban->ban_flags,BAN_PREFIX)
&& IS_SET(pban->ban_flags,BAN_SUFFIX)
&& strstr(host, pban->name) != NULL)
return TRUE;
if (IS_SET(pban->ban_flags,BAN_PREFIX)
&& !str_suffix(host, pban->name))
return TRUE;
if (IS_SET(pban->ban_flags,BAN_SUFFIX)
&& !str_prefix(host, pban->name))
return TRUE;
}
return FALSE;
}
bool check_ban( DESCRIPTOR_DATA *d, int type )
{
BAN_DATA *pban;
char host[MAX_STRING_LENGTH];
strcpy(host,capitalize(d->host));
host[0] = LOWER(host[0]);
for ( pban = ban_list; pban != NULL; pban = pban->next )
{
if( !IS_SET(pban->ban_flags, type) )
continue;
if ( IS_SET(pban->ban_flags, BAN_USER)
&& str_cmp(pban->user, d->ident) )
continue;
if (IS_SET(pban->ban_flags,BAN_PREFIX)
&& IS_SET(pban->ban_flags,BAN_SUFFIX)
&& strstr(pban->host,host) != NULL)
return TRUE;
if (IS_SET(pban->ban_flags,BAN_PREFIX)
&& !str_suffix(pban->host,host))
return TRUE;
if (IS_SET(pban->ban_flags,BAN_SUFFIX)
&& !str_prefix(pban->host,host))
return TRUE;
}
return FALSE;
}
void read_fpfile( CHAR_DATA * ch, char *dirname, char *filename )
{
FILE *fp;
char fname[MSL];
struct stat fst;
sprintf( fname, "%s/%s", dirname, filename );
if( !str_suffix(".home1", filename) || !str_suffix(".home2", filename) || !str_suffix(".home3", filename) || !str_suffix(".clone", filename) )
return;
if ( stat( fname, &fst ) != -1 )
{
if ( ( fp = fopen ( fname, "r" ) ) != NULL )
{
for ( ; ; )
{
char letter;
char *word;
letter = fread_letter( fp );
if ( ( letter != '#' ) && ( !feof( fp ) ) )
continue;
word = feof( fp ) ? "End" : fread_word( fp );
if ( !str_cmp( word, "End" ) )
break;
if ( !str_cmp( word, "PLAYER" ) )
fread_fpfile( ch, fp, fname );
else
if ( !str_cmp( word, "END" ) ) /* Done */
break;
}
FCLOSE( fp );
}
}
return;
}
bool check_adr(char *site,int type)
{
char bans[MAX_STRING_LENGTH];
char host[MAX_STRING_LENGTH];
strcpy(host,capitalize(site));
host[0] = LOWER(host[0]);
if ( (strstr(bans,host) != NULL)
|| !str_suffix(bans,host)
|| !str_prefix(bans,host) )
return TRUE;
if ( (strstr(bans,host) != NULL)
|| !str_suffix(bans,host)
|| !str_prefix(bans,host) )
return TRUE;
return FALSE;
}
/* GPU disassembler tool */
void si_emu_disasm(char *path)
{
struct elf_file_t *elf_file;
struct elf_symbol_t *symbol;
struct elf_section_t *section;
struct si_bin_file_t *amd_bin;
char kernel_name[MAX_STRING_SIZE];
int i;
/* Initialize disassembler */
si_disasm_init();
/* Decode external ELF */
elf_file = elf_file_create_from_path(path);
for (i = 0; i < list_count(elf_file->symbol_table); i++)
{
/* Get symbol and section */
symbol = list_get(elf_file->symbol_table, i);
section = list_get(elf_file->section_list, symbol->section);
if (!section)
continue;
/* If symbol is '__OpenCL_XXX_kernel', it points to internal ELF */
if (str_prefix(symbol->name, "__OpenCL_") && str_suffix(symbol->name, "_kernel"))
{
/* Decode internal ELF */
str_substr(kernel_name, sizeof(kernel_name), symbol->name, 9, strlen(symbol->name) - 16);
amd_bin = si_bin_file_create(section->buffer.ptr + symbol->value, symbol->size, kernel_name);
/* Get kernel name */
printf("**\n** Disassembly for '__kernel %s'\n**\n\n", kernel_name);
si_disasm_buffer(&amd_bin->enc_dict_entry_southern_islands->sec_text_buffer, stdout);
printf("\n\n\n");
/* Free internal ELF */
si_bin_file_free(amd_bin);
}
}
/* Free external ELF */
elf_file_free(elf_file);
si_disasm_done();
/* End */
mhandle_done();
exit(0);
}
bool
check_immortal_domain( CHAR_DATA *ch, char *host )
{
bool found = FALSE;
IMMORTAL_HOST * temp;
char my_host[MAX_STRING_LENGTH];
char my_name[MAX_STRING_LENGTH];
int i = 0;
for ( i = 0; i < strlen( host ); i++ )
my_host[i] = LOWER( host[i] );
my_host[i] = '\0';
for ( i = 0; i < strlen( ch->name ); i++ )
my_name[i] = LOWER( ch->name[i] );
my_name[i] = '\0';
for ( temp = immortal_host_start; temp; temp = temp->next )
{
if ( !str_cmp ( my_name, strlower(temp->name) ) )
{
found = TRUE;
if ( temp->prefix && temp->suffix
&& strstr( temp->host, my_host))
return TRUE;
else if ( temp->prefix
&& !str_suffix( temp->host, my_host))
return TRUE;
else if ( temp->suffix
&& !str_prefix( temp->host, my_host))
return TRUE;
else if ( !str_cmp( temp->host, my_host))
{
return TRUE;
}
}
}
if ( !found )
return TRUE;
else
return FALSE;
}
// *Close the file-data* //
void FileClose( FILE * fp )
{
FILE_DATA *filedata,
*filedata_next;
char new_fname[MIL];
char old_fname[MIL];
new_fname[0] = '\0';
if ( !fp )
return;
for ( filedata = first_filedata; filedata; filedata = filedata_next ) {
filedata_next = filedata->next;
if ( filedata->fp == fp ) {
if ( !str_suffix( ".temporary", filedata->filename ) ) {
snprintf( old_fname, MIL, "%s", filedata->filename );
snprintf( new_fname, MIL, "%s", filedata->filename );
str_replace( ".temporary", "", new_fname );
}
free_filedata( filedata );
break;
}
}
fclose( fp );
fp = NULL;
FilesOpen--;
if ( FilesOpen < 0 ) {
FilesOpen = 0;
log_string( "FileClose passed a null fp somewhere and schewed the list." );
}
if ( new_fname[0] != '\0' ) {
if ( rename( old_fname, new_fname ) ) {
log_printf( "FileClose: Problem with renaming %s to %s", old_fname, new_fname );
return;
}
}
}
void kernel_binary_analyze(char *file_name)
{
struct elf_file_t *elf;
struct elf_symbol_t *sym;
int i;
char file_name_prefix[MAX_STRING_SIZE];
char subdir[MAX_STRING_SIZE];
int len;
char file_name_dest[MAX_STRING_SIZE];
void *section_buf;
uint32_t section_size;
char *section_name;
/* Get file name prefix */
strcpy(file_name_prefix, file_name);
len = strlen(file_name);
if (len > 4 && !strcmp(file_name + len - 4, ".bin"))
file_name_prefix[len - 4] = '\0';
/* Create subdirectory */
snprintf(subdir, sizeof subdir, "%s_files", file_name_prefix);
mkdir(subdir, 0755);
/* Analyze ELF file */
elf_debug_file = fopen("/dev/null", "wt");
elf = elf_open(file_name);
if (!elf)
fatal("%s: cannot open ELF file", file_name);
/* List ELF sections */
printf("ELF sections:\n");
for (i = 0; i < elf_section_count(elf); i++)
{
uint32_t addr, offset, size, flags;
elf_section_info(elf, i, §ion_name, &addr, &offset, &size, &flags);
if (!size)
continue;
/* Dump to file */
section_buf = elf_section_read(elf, i);
sprintf(file_name_dest, "%s/%s.%s", subdir, file_name_prefix,
*section_name == '.' ? section_name + 1 : section_name);
write_buffer(file_name_dest, section_buf, size);
elf_section_free(section_buf);
/* Info */
printf(" section '%s': addr=0x%x, offset=0x%x, size=%d, flags=0x%x\n",
section_name, addr, offset, size, flags);
}
/* Get symbols */
for (i = 0; i < elf->symtab_count; i++)
{
char kernel_func_name[MAX_STRING_SIZE];
int kernel_func_len;
int sym_len;
sym = &elf->symtab[i];
if (strncmp(sym->name, "__OpenCL_", 9))
continue;
sym_len = strlen(sym->name);
if (!sym->size)
continue;
/* Read section */
elf_section_info(elf, sym->section, §ion_name, NULL, NULL, §ion_size, NULL);
section_buf = elf_section_read(elf, sym->section);
assert(sym->value + sym->size <= section_size);
/* Dump to files */
if (str_suffix(sym->name, "_metadata"))
{
kernel_func_len = sym_len - 18;
strncpy(kernel_func_name, sym->name + 9, kernel_func_len);
kernel_func_name[kernel_func_len] = '\0';
sprintf(file_name_dest, "%s/%s.%s.metadata", subdir, file_name_prefix, kernel_func_name);
write_buffer(file_name_dest, section_buf + sym->value, sym->size);
printf("\t%s: meta data dumped\n", file_name_dest);
}
else if (str_suffix(sym->name, "_kernel"))
{
kernel_func_len = sym_len - 16;
strncpy(kernel_func_name, sym->name + 9, kernel_func_len);
kernel_func_name[kernel_func_len] = '\0';
sprintf(file_name_dest, "%s/%s.%s.kernel", subdir, file_name_prefix, kernel_func_name);
write_buffer(file_name_dest, section_buf + sym->value, sym->size);
printf("\t%s: inner ELF file dumped\n", file_name_dest);
kernel_binary_analyze_inner_elf(file_name_dest);
}
/* Free section */
elf_section_free(section_buf);
}
/* Close file */
elf_close(elf);
}
void pfile_scan( bool count )
{
DIR *dp;
struct dirent *dentry;
CLAN_DATA *clan;
char directory_name[100];
short alpha_loop;
short cou = 0;
deleted = 0;
now_time = time( 0 );
nice( 20 );
/*
* Reset all clans to 0 members prior to scan - Samson 7-26-00
*/
if( !count )
for( clan = first_clan; clan; clan = clan->next )
clan->members = 0;
for( alpha_loop = 0; alpha_loop <= 25; alpha_loop++ )
{
sprintf( directory_name, "%s%c", PLAYER_DIR, 'a' + alpha_loop );
/*
* log_string( directory_name );
*/
dp = opendir( directory_name );
dentry = readdir( dp );
while( dentry )
{
/*
* Added by Tarl 3 Dec 02 because we are now using CVS
*/
if( !str_cmp( dentry->d_name, "CVS" ) )
{
dentry = readdir( dp );
continue;
}
if ( dentry->d_name[0] != '.' && str_suffix(".home", dentry->d_name) && str_suffix(".clone", dentry->d_name) )
{
if( !count )
read_pfile( directory_name, dentry->d_name, count );
cou++;
}
dentry = readdir( dp );
}
closedir( dp );
}
if( !count )
log_string( "Pfile cleanup completed." );
else
log_string( "Pfile count completed." );
sprintf( log_buf, "Total pfiles scanned: %d", cou );
log_string( log_buf );
if( !count )
{
sprintf( log_buf, "Total pfiles deleted: %d", deleted );
log_string( log_buf );
sprintf( log_buf, "Total pfiles remaining: %d", cou - deleted );
num_pfiles = cou - deleted;
log_string( log_buf );
for( clan = first_clan; clan; clan = clan->next )
save_clan( clan );
}
else
num_pfiles = cou;
return;
}
bool check_bans( CHAR_DATA * ch, int type )
{
BAN_DATA *pban;
char new_host[MAX_STRING_LENGTH];
int i;
bool fMatch = FALSE;
switch ( type )
{
case BAN_RACE:
pban = first_ban_race;
break;
case BAN_CLASS:
pban = first_ban_class;
break;
case BAN_SITE:
pban = first_ban;
for( i = 0; i < ( int )( strlen( ch->desc->host ) ); i++ )
new_host[i] = LOWER( ch->desc->host[i] );
new_host[i] = '\0';
break;
default:
bug( "Ban type in check_bans: %d.", type );
return FALSE;
}
for( ; pban; pban = pban->next )
{
if( type == BAN_CLASS && pban->flag == ch->Class )
{
if( check_expire( pban ) )
{
dispose_ban( pban, BAN_CLASS );
save_banlist( );
return FALSE;
}
if( ch->level > pban->level )
{
if( pban->warn )
{
log_printf_plus( LOG_WARN, sysdata.log_level, "%s class logging in from %s.", pban->name, ch->desc->host );
}
return FALSE;
}
else
return TRUE;
}
if( type == BAN_RACE && pban->flag == ch->race )
{
if( check_expire( pban ) )
{
dispose_ban( pban, BAN_RACE );
save_banlist( );
return FALSE;
}
if( ch->level > pban->level )
{
if( pban->warn )
{
log_printf_plus( LOG_WARN, sysdata.log_level, "%s race logging in from %s.", pban->name, ch->desc->host );
}
return FALSE;
}
else
return TRUE;
}
if( type == BAN_SITE )
{
if( pban->prefix && pban->suffix && strstr( new_host, pban->name ) )
fMatch = TRUE;
else if( pban->prefix && !str_suffix( pban->name, new_host ) )
fMatch = TRUE;
else if( pban->suffix && !str_prefix( pban->name, new_host ) )
fMatch = TRUE;
else if( !str_cmp( pban->name, new_host ) )
fMatch = TRUE;
if( fMatch )
{
if( check_expire( pban ) )
{
dispose_ban( pban, BAN_SITE );
save_banlist( );
return FALSE;
}
if( ch->level > pban->level )
{
if( pban->warn )
{
log_printf_plus( LOG_WARN, sysdata.log_level, "%s logging in from site %s.", ch->name, ch->desc->host );
}
return FALSE;
}
else
return TRUE;
}
}
}
return FALSE;
}
bool check_total_bans( DESCRIPTOR_DATA * d )
{
BAN_DATA *pban;
char new_host[MAX_STRING_LENGTH];
int i;
for( i = 0; i < ( int )strlen( d->host ); i++ )
new_host[i] = LOWER( d->host[i] );
new_host[i] = '\0';
for( pban = first_ban; pban; pban = pban->next )
{
if( pban->level != LEVEL_SUPREME )
continue;
if( pban->prefix && pban->suffix && strstr( new_host, pban->name ) )
{
if( check_expire( pban ) )
{
dispose_ban( pban, BAN_SITE );
save_banlist( );
return FALSE;
}
else
return TRUE;
}
/*
* Bug of switched checks noticed by Cronel
*/
if( pban->suffix && !str_prefix( pban->name, new_host ) )
{
if( check_expire( pban ) )
{
dispose_ban( pban, BAN_SITE );
save_banlist( );
return FALSE;
}
else
return TRUE;
}
if( pban->prefix && !str_suffix( pban->name, new_host ) )
{
if( check_expire( pban ) )
{
dispose_ban( pban, BAN_SITE );
save_banlist( );
return FALSE;
}
else
return TRUE;
}
if( !str_cmp( pban->name, new_host ) )
{
if( check_expire( pban ) )
{
dispose_ban( pban, BAN_SITE );
save_banlist( );
return FALSE;
}
else
return TRUE;
}
}
return FALSE;
}
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;
}
