void output_magic(void)
{
output_header(MAGIC_00);
output_header(MAGIC_01);
output_header(MAGIC_02);
output_header(MAGIC_03);
}
void
munge_file(void)
{
FILE *munge_fp = 0;
FILE *table_fp = 0;
FILE *header_fp = 0;
static char line_buf[LINEBUFFER_SIZE + 1];
if ((munge_fp = fopen(munge_filename, "r")) == NULL)
{
fprintf(stderr, "couldn't open '%s' for reading\n", munge_filename);
exit(-1);
}
if (header_munging)
if ((header_fp = fopen(header_filename, "w")) == NULL)
{
fprintf(stderr, "couldn't open '%s' for writing\n", header_filename);
exit(-1);
}
if (table_munging)
if ((table_fp = fopen(table_filename, "w")) == NULL)
{
fprintf(stderr, "couldn't open '%s' for writing\n", table_filename);
exit(-1);
}
while (fgets(line_buf, LINEBUFFER_SIZE, munge_fp))
{
if (line_buf[0] == '#') /* comment lines. */
{
continue;
}
else /* non comment lines */
{
char command[100], string[100];
command[0] = string[0] = 0;
sscanf(line_buf, " %s %s ", command, string);
if (!command[0] || !string[0])
continue;
add_command(command, string);
}
}
fclose(munge_fp);
sort_commands();
if (header_munging)
output_header(header_fp);
if (table_munging)
output_table(table_fp);
}
int login_status()
{
set_http_response_header_content_type("text/html;charset=utf-8");
output_header();
fprintf(stdout, "form_data: %s", http_post_data);
return 0;
}
void diff_formatter::output(ostream & out, diff_collection const & syms)
{
output_header(out);
diff_collection::const_iterator it = syms.begin();
diff_collection::const_iterator end = syms.end();
for (; it != end; ++it)
do_output(out, *it, it->sample, counts, it->diffs);
}
void output_until_space(const char *str, int header)
{
while(!isspace(*str) && *str != '\0') {
if(!header)
output_char(*str);
else
output_header(*str);
str++;
}
}
void opreport_formatter::
output(ostream & out, symbol_collection const & syms)
{
output_header(out);
symbol_collection::const_iterator it = syms.begin();
symbol_collection::const_iterator end = syms.end();
for (; it != end; ++it)
output(out, *it);
}
void login_page()
{
set_http_response_header_content_type("text/html;charset=utf-8");
output_header();
if(0 != init_session()){
printf("init_session ERROR !\n");
return;
}
send_redirect_to_page(PAGE_LOGIN);
}
void cg_formatter::output(ostream & out, symbol_collection const & syms)
{
// amount of spacing prefixing child and parent lines
string const child_parent_prefix(" ");
output_header(out);
out << string(79, '-') << endl;
symbol_collection::const_iterator it;
symbol_collection::const_iterator end = syms.end();
for (it = syms.begin(); it < end; ++it) {
cg_symbol const * sym = dynamic_cast<cg_symbol const *>(*it);
// To silence coverity (since dynamic cast can theoretically return NULL)
if (!sym)
continue;
cg_symbol::children::const_iterator cit;
cg_symbol::children::const_iterator cend = sym->callers.end();
counts_t c;
if (global_percent)
c.total = counts.total;
else
c.total = sym->total_caller_count;
for (cit = sym->callers.begin(); cit != cend; ++cit) {
out << child_parent_prefix;
do_output(out, *cit, cit->sample, c);
}
do_output(out, *sym, sym->sample, counts);
c = counts_t();
if (global_percent)
c.total = counts.total;
else
c.total = sym->total_callee_count;
cend = sym->callees.end();
for (cit = sym->callees.begin(); cit != cend; ++cit) {
out << child_parent_prefix;
do_output(out, *cit, cit->sample, c);
}
out << string(79, '-') << endl;
}
}
int main(int argc, char **argv){
if(argc < 3){
fprintf(stderr, "Usage: %s input_circuit input_pattern [output_pattern]\n", argv[0]);
exit(1);
}
char buffer[81];
inc = fopen(argv[1], "r");
assert(inc != NULL);
inp = fopen(argv[2], "r");
assert(inp != NULL);
if(argc == 3){
strcpy(buffer, "output_");
strncat(buffer, argv[1], 20);
strcat(buffer, "_");
strncat(buffer, argv[2], 20);
strcat(buffer, ".vcd");
fprintf(stderr, "Output filename not specified, using \"%s\" instead.\n", buffer);
out = fopen(buffer, "w");
}else{
out = fopen(argv[3], "w");
}
assert(out != NULL);
// while(getlinen(buffer, inc, 81) != EOF){}
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &start_time); //stdio scanf ended, timer starts
Circuit mainc;
// char t[50];
// fscanf(inc, "%s", t);
// printf("%s\n", t);
parse_circuit(&mainc, inc);
// circuit_print(&mainc, stderr);
Pattern_parse_data pdata_main;
load_header(&mainc, &pdata_main, inp);
output_header(&mainc, &pdata_main, out);
simulate(&mainc, &pdata_main, inp, out);
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &end_time);
//printf("sizeof(start_time.tv_sec):%d, sizeof(start_time.tv_nsec):%d\n", sizeof(start_time.tv_sec), sizeof(start_time.tv_nsec));
//printf("s_time.tv_sec:%ld, s_time.tv_nsec:%ld\n", start_time.tv_sec, start_time.tv_nsec);
//printf("e_time.tv_sec:%ld, e_time.tv_nsec:%ld\n", end_time.tv_sec, end_time.tv_nsec);
double execution_time = (double)end_time.tv_sec + (double)end_time.tv_nsec/1000000000.0 - (double)start_time.tv_sec - (double)start_time.tv_nsec/1000000000.0;
printf("\nExecution Time:%.4f(s)\n\n", execution_time);
fclose(inc);
fclose(inp);
fclose(out);
}
void cg_formatter::output(ostream & out, cg_collection const & syms)
{
// amount of spacing prefixing child and parent lines
string const child_parent_prefix(" ");
output_header(out);
out << string(79, '-') << endl;
cg_collection::const_iterator it;
cg_collection::const_iterator end = syms.end();
for (it = syms.begin(); it < end; ++it) {
cg_symbol const & sym = *it;
cg_symbol::children::const_iterator cit;
cg_symbol::children::const_iterator cend = sym.callers.end();
counts_t c;
if (global_percent)
c.total = counts.total;
else
c.total = sym.total_caller_count;
for (cit = sym.callers.begin(); cit != cend; ++cit) {
out << child_parent_prefix;
do_output(out, *cit, cit->sample, c);
}
do_output(out, sym, sym.sample, counts);
c = counts_t();
if (global_percent)
c.total = counts.total;
else
c.total = sym.total_callee_count;
cend = sym.callees.end();
for (cit = sym.callees.begin(); cit != cend; ++cit) {
out << child_parent_prefix;
do_output(out, *cit, cit->sample, c);
}
out << string(79, '-') << endl;
}
}
// this is called between passes and provides the assembler the file
// pointer to use for outputing the object file
//
// it returns the number of errors seen on pass1
//
int betweenPasses(FILE *outf)
{
#if DEBUG
fprintf(stderr, "betweenPasses called\n");
dumpSymbolTable();
dump_funcs( func_list );
//dump_handler_list( handler_list );
#endif
//verify_handler_list( handler_list );
#if PRINT_DEFINED_LABELS
printDefinedLabels();
#endif
// remember the file pointer to use
fp = outf;
// update the pass number
currentPass = 2;
// check if memory will overflow
if (currentLength > 0xFFFFF)
{
error("program consumes more than 2^20 words");
errorCount += 1;
}
// check for errors concerning addresses
checkForAddressErrors();
// check for errors concerning import and export
errorCount += checkForImportExportErrors();
// if no errors, output headers and then insymbol and outsymbol section
if (!errorCount)
{
output_header();
//outputInsymbols();
//outputOutsymbols();
}
// reset currentLength for pass2
currentLength = 0;
return errorCount;
}
void output_ascii(const stdString &archive_name,
const stdString &channel_name,
const epicsTime &start, const epicsTime &end)
{
Archive archive(new ARCHIVE_TYPE(archive_name));
ChannelIterator channel(archive);
ValueIterator value(archive);
if (! archive.findChannelByName(channel_name, channel))
{
printf("# Channel not found: %s\n", channel_name.c_str());
return;
}
printf("channel=%s\n", channel_name.c_str());
if (! channel->getValueAfterTime (start, value))
{
printf("# no values\n");
return;
}
CtrlInfo info;
double period=-1;
epicsTime last_time = nullTime;
while (value && (!isValidTime(end) || value->getTime() < end))
{
if (period != value.getPeriod())
{
period = value.getPeriod();
output_header(value);
}
if (info != *value->getCtrlInfo())
{
info = *value->getCtrlInfo();
output_info(&info);
}
if (isValidTime(last_time) && value->getTime() < last_time)
printf("Error: back in time:\n");
value->show(stdout);
fputs("\n", stdout);
last_time = value->getTime();
++value;
}
}
/* Output a stripped prx file */
int output_prx(const char *prxfile)
{
int size;
unsigned char *data;
FILE *fp;
do
{
size = calculate_outsize();
data = (unsigned char *) malloc(size);
if(data == NULL)
{
fprintf(stderr, "Error, couldn't allocate output data\n");
break;
}
memset(data, 0, size);
output_header(data);
output_ph(data + g_phbase);
output_alloc(data + g_allocbase);
output_sh(data + g_shbase);
output_relocs(data + g_relocbase);
output_shstrtab(data + g_shstrbase);
fp = fopen(prxfile, "wb");
if(fp != NULL)
{
fwrite(data, 1, size, fp);
fclose(fp);
}
else
{
fprintf(stderr, "Error, could not open output file %s\n", prxfile);
}
free(data);
}
while(0);
return 0;
}
/* init_master_cfg()
* Called by masters, mpi or serial.
* Already set:
* cfg->hmmfile - command line arg 1
* cfg->alifile - command line arg 2
* cfg->postmsafile - option -O (default NULL)
* cfg->fmt - format of alignment file
* Sets:
* cfg->afp - open alignment file
* cfg->abc - digital alphabet
* cfg->hmmfp - open HMM file
* cfg->postmsafp - open MSA resave file, or NULL
*
* Errors in the MPI master here are considered to be "recoverable",
* in the sense that we'll try to delay output of the error message
* until we've cleanly shut down the worker processes. Therefore
* errors return (code, errmsg) by the ESL_FAIL mech.
*/
static int
init_master_cfg(const ESL_GETOPTS *go, struct cfg_s *cfg, char *errmsg)
{
int status;
if (esl_opt_GetString(go, "-o") != NULL) {
if ((cfg->ofp = fopen(esl_opt_GetString(go, "-o"), "w")) == NULL)
ESL_FAIL(eslFAIL, errmsg, "Failed to open -o output file %s\n", esl_opt_GetString(go, "-o"));
} else cfg->ofp = stdout;
status = esl_msafile_Open(cfg->alifile, cfg->fmt, NULL, &(cfg->afp));
if (status == eslENOTFOUND) ESL_FAIL(status, errmsg, "Alignment file %s doesn't exist or is not readable\n", cfg->alifile);
else if (status == eslEFORMAT) ESL_FAIL(status, errmsg, "Couldn't determine format of alignment %s\n", cfg->alifile);
else if (status != eslOK) ESL_FAIL(status, errmsg, "Alignment file open failed with error %d\n", status);
if (esl_opt_GetBoolean(go, "--amino")) cfg->abc = esl_alphabet_Create(eslAMINO);
else if (esl_opt_GetBoolean(go, "--dna")) cfg->abc = esl_alphabet_Create(eslDNA);
else if (esl_opt_GetBoolean(go, "--rna")) cfg->abc = esl_alphabet_Create(eslRNA);
else {
int type;
status = esl_msafile_GuessAlphabet(cfg->afp, &type);
if (status == eslEAMBIGUOUS) ESL_FAIL(status, errmsg, "Failed to guess the bio alphabet used in %s.\nUse --dna, --rna, or --amino option to specify it.", cfg->alifile);
else if (status == eslEFORMAT) ESL_FAIL(status, errmsg, "Alignment file parse failed: %s\n", cfg->afp->errbuf);
else if (status == eslENODATA) ESL_FAIL(status, errmsg, "Alignment file %s is empty\n", cfg->alifile);
else if (status != eslOK) ESL_FAIL(status, errmsg, "Failed to read alignment file %s\n", cfg->alifile);
cfg->abc = esl_alphabet_Create(type);
}
esl_msafile_SetDigital(cfg->afp, cfg->abc);
if ((cfg->hmmfp = fopen(cfg->hmmfile, "w")) == NULL) ESL_FAIL(status, errmsg, "Failed to open HMM file %s for writing", cfg->hmmfile);
if (cfg->postmsafile != NULL) {
if ((cfg->postmsafp = fopen(cfg->postmsafile, "w")) == NULL) ESL_FAIL(status, errmsg, "Failed to MSA resave file %s for writing", cfg->postmsafile);
} else cfg->postmsafp = NULL;
output_header(go, cfg);
/* with msa == NULL, output_result() prints the tabular results header, if needed */
output_result(cfg, errmsg, 0, NULL, NULL, NULL, 0.0);
return eslOK;
}
static ThreadContext *new_context() {
ThreadContext *pctx = malloc(sizeof(ThreadContext));
if (dest_host) {
pctx->fd = sock_connect(dest_host, dest_port);
if (pctx->fd == -1) exit(1);
}
else {
char fn[256];
sprintf(fn, "%s-%s-%d-%x", basepath, hostname, getpid(), (int)pthread_self());
pctx->fd = open(fn, O_WRONLY|O_CREAT|O_TRUNC, 0644);
if (pctx->fd == -1) { perror(fn); exit(1); }
}
output_header(pctx->fd);
pctx->procfd = -1;
pctx->idpos = 0;
ID(pctx) = NULL;
IDLEN(pctx) = 0;
const char *lvl = getenv("ANNOTATE_LOG_LEVEL");
pctx->log_level = lvl ? atoi(lvl) : 255;
pthread_setspecific(ctx_key, pctx);
return pctx;
}
void
output_dic_data (void)
{
fprintf (stderr, "%d words are in this dictionary\n", jt.maxserial);
if (little_endian ())
{
rev_dic_data ();
}
jt.syurui = which_dict;
jt.gosuu = jt.maxserial;
output_header (ofpter, &jt, &file_head); /* dummy; Will be rewitten. */
output_comment (ofpter);
output_hinsi_list (ofpter);
output_hindo (ofpter);
output_hinsi (ofpter);
#ifdef CONVERT_with_SiSheng
if (which_dict == CWNN_REV_DICT)
output_sisheng (ofpter);
#endif
output_kanji (ofpter);
}
/* Function: main()
* Synopsis: Run set of queries against an FM
* Purpose: Read in a FM and a file of query sequences.
* For each query, find matching FM interval, then collect positions in
* the original text T for the corresponding occurrences. These positions
* are 0-based (so first character is position 0).
*/
int
main(int argc, char *argv[])
{
void* tmp; // used for RALLOC calls
clock_t t1, t2;
struct tms ts1, ts2;
char *fname_fm = NULL;
char *fname_queries = NULL;
FM_HIT *hits = NULL;
char *line = NULL;
int status = eslOK;
int hit_cnt = 0;
int hit_indiv_cnt = 0;
int miss_cnt = 0;
int hit_num = 0;
int hit_num2 = 0;
int hits_size = 0;
int i,j;
int count_only = 0;
FM_INTERVAL interval;
FM_DATA *fmsf = NULL;
FM_DATA *fmsb = NULL;
FILE* fp_fm = NULL;
FILE* fp = NULL;
FILE* out = NULL;
char *outname = NULL;
ESL_GETOPTS *go = NULL; /* command line processing */
FM_CFG *cfg;
FM_METADATA *meta;
ESL_SQ *tmpseq; // used for sequence validation
ESL_ALPHABET *abc = NULL;
//start timer
t1 = times(&ts1);
process_commandline(argc, argv, &go, &fname_fm, &fname_queries);
if (esl_opt_IsOn(go, "--out")) {
outname = esl_opt_GetString(go, "--out");
if ( esl_strcmp ("-", outname) == 0 ) {
out = stdout;
outname = "stdout";
} else {
out = fopen(outname,"w");
}
}
if (esl_opt_IsOn(go, "--count_only"))
count_only = 1;
if((fp_fm = fopen(fname_fm, "rb")) == NULL)
esl_fatal("Cannot open file `%s': ", fname_fm);
fm_configAlloc(&cfg);
cfg->occCallCnt = 0;
meta = cfg->meta;
meta->fp = fp_fm;
fm_readFMmeta( meta);
if (meta->alph_type == fm_DNA) abc = esl_alphabet_Create(eslDNA);
else if (meta->alph_type == fm_AMINO) abc = esl_alphabet_Create(eslAMINO);
tmpseq = esl_sq_CreateDigital(abc);
//read in FM-index blocks
ESL_ALLOC(fmsf, meta->block_count * sizeof(FM_DATA) );
if (!meta->fwd_only)
ESL_ALLOC(fmsb, meta->block_count * sizeof(FM_DATA) );
for (i=0; i<meta->block_count; i++) {
fm_FM_read( fmsf+i,meta, TRUE );
if (!meta->fwd_only) {
fm_FM_read(fmsb+i, meta, FALSE );
fmsb[i].SA = fmsf[i].SA;
fmsb[i].T = fmsf[i].T;
}
}
fclose(fp_fm);
output_header(meta, stdout, go, fname_fm, fname_queries);
/* initialize a few global variables, then call initGlobals
* to do architecture-specific initialization
*/
fm_configInit(cfg, NULL);
fm_alphabetCreate(meta, NULL); // don't override charBits
fp = fopen(fname_queries,"r");
if (fp == NULL)
esl_fatal("Unable to open file %s\n", fname_queries);
ESL_ALLOC(line, FM_MAX_LINE * sizeof(char));
hits_size = 200;
ESL_ALLOC(hits, hits_size * sizeof(FM_HIT));
while(fgets(line, FM_MAX_LINE, fp) ) {
int qlen=0;
while (line[qlen] != '\0' && line[qlen] != '\n') qlen++;
if (line[qlen] == '\n') line[qlen] = '\0';
hit_num = 0;
for (i=0; i<meta->block_count; i++) {
fm_getSARangeReverse(fmsf+i, cfg, line, meta->inv_alph, &interval);
if (interval.lower>=0 && interval.lower <= interval.upper) {
int new_hit_num = interval.upper - interval.lower + 1;
hit_num += new_hit_num;
if (!count_only) {
if (hit_num > hits_size) {
hits_size = 2*hit_num;
ESL_RALLOC(hits, tmp, hits_size * sizeof(FM_HIT));
}
getFMHits(fmsf+i, cfg, &interval, i, hit_num-new_hit_num, qlen, hits, fm_forward);
}
}
/* find reverse hits, using backward search on the forward FM*/
if (!meta->fwd_only) {
fm_getSARangeForward(fmsb+i, cfg, line, meta->inv_alph, &interval);// yes, use the backward fm to produce the equivalent of a forward search on the forward fm
if (interval.lower>=0 && interval.lower <= interval.upper) {
int new_hit_num = interval.upper - interval.lower + 1;
hit_num += new_hit_num;
if (!count_only) {
if (hit_num > hits_size) {
hits_size = 2*hit_num;
ESL_RALLOC(hits, tmp, hits_size * sizeof(FM_HIT));
}
//even though I used fmsb above, use fmsf here, since we'll now do a backward trace
//in the FM-index to find the next sampled SA position
getFMHits(fmsf+i, cfg, &interval, i, hit_num-new_hit_num, qlen, hits, fm_backward);
}
}
}
}
if (hit_num > 0) {
if (count_only) {
hit_cnt++;
hit_indiv_cnt += hit_num;
} else {
hit_num2 = 0;
//for each hit, identify the sequence id and position within that sequence
for (i = 0; i< hit_num; i++) {
status = fm_getOriginalPosition (fmsf, meta, hits[i].block, hits[i].length, fm_forward, hits[i].start, &(hits[i].block), &(hits[i].start) );
hits[i].sortkey = (status==eslERANGE ? -1 : meta->seq_data[ hits[i].block ].target_id);
//validate match - if any characters in orig sequence were ambiguities, reject
fm_convertRange2DSQ( fmsf, meta, hits[i].start, hits[i].length, p7_NOCOMPLEMENT, tmpseq, TRUE );
for (j=1; j<=hits[i].length; j++) {
if (tmpseq->dsq[j] >= abc->K) {
hits[i].sortkey = -1; //reject
j = hits[i].length+1; //quit looking
}
}
if (hits[i].sortkey != -1)
hit_num2++; // legitimate hit
}
if (hit_num2 > 0)
hit_cnt++;
//now sort according the the sequence_id corresponding to that seq_offset
qsort(hits, hit_num, sizeof(FM_HIT), hit_sorter);
//skim past the skipped entries
i = 0;
while ( i < hit_num ) {
if (hits[i].sortkey != -1 )
break; //
i++;
}
if (i < hit_num) {
if (out != NULL) {
fprintf (out, "%s\n",line);
//fprintf (out, "\t%10s (%8d %s)\n",meta->seq_data[ hits[i].block ].name, hits[i].start, (hits[i].direction==fm_forward?"+":"-"));
fprintf (out, " %8ld %s %10s\n", (long)(hits[i].start), (hits[i].direction==fm_forward?"f":"r"), meta->seq_data[ hits[i].block ].name);
}
hit_indiv_cnt++;
i++; // skip the first one, since I'll be comparing each to the previous
for ( ; i< hit_num; i++) {
if ( //meta->seq_data[ hits[i].block ].id != meta->seq_data[ hits[i-1].block ].id ||
hits[i].sortkey != hits[i-1].sortkey || //sortkey is seq_data[].id
hits[i].direction != hits[i-1].direction ||
hits[i].start != hits[i-1].start )
{
if (out != NULL)
//fprintf (out, "\t%10s (%8d %s)\n",meta->seq_data[ hits[i].block ].name, hits[i].start, (hits[i].direction==fm_forward?"+":"-"));
fprintf (out, " %8ld %s %10s\n", (long)(hits[i].start), (hits[i].direction==fm_forward?"f":"r"), meta->seq_data[ hits[i].block ].name);
hit_indiv_cnt++;
}
}
if (out != NULL)
fprintf (out, "\n");
}
}
} else {
miss_cnt++;
}
}
for (i=0; i<meta->block_count; i++) {
fm_FM_destroy( fmsf+i, 1 );
if (!meta->fwd_only)
fm_FM_destroy( fmsb+i, 0 );
}
free (hits);
free (line);
fclose(fp);
fm_configDestroy(cfg);
// compute and print the elapsed time in millisec
t2 = times(&ts2);
{
double clk_ticks = sysconf(_SC_CLK_TCK);
double elapsedTime = (t2-t1)/clk_ticks;
double throughput = cfg->occCallCnt/elapsedTime;
fprintf (stderr, "hit: %-10d (%d)\n", hit_cnt, hit_indiv_cnt);
fprintf (stderr, "miss:%-10d\n", miss_cnt);
fprintf (stderr, "run time: %.2f seconds\n", elapsedTime);
fprintf (stderr, "occ calls: %12s\n", commaprint(cfg->occCallCnt));
fprintf (stderr, "occ/sec: %12s\n", commaprint(throughput));
}
exit(eslOK);
ERROR:
printf ("failure allocating memory for hits\n");
exit(status);
}
void
fz_output_pwg_bitmap_page(fz_context *ctx, fz_output *out, const fz_bitmap *bitmap, const fz_pwg_options *pwg)
{
unsigned char *sp;
int y, x, ss;
int byte_width;
if (!out || !bitmap)
return;
output_header(ctx, out, pwg, bitmap->xres, bitmap->yres, bitmap->w, bitmap->h, 1);
/* Now output the actual bitmap, using a packbits like compression */
sp = bitmap->samples;
ss = bitmap->stride;
byte_width = (bitmap->w+7)/8;
y = 0;
while (y < bitmap->h)
{
int yrep;
assert(sp == bitmap->samples + y * ss);
/* Count the number of times this line is repeated */
for (yrep = 1; yrep < 256 && y+yrep < bitmap->h; yrep++)
{
if (memcmp(sp, sp + yrep * ss, byte_width) != 0)
break;
}
fz_write_byte(ctx, out, yrep-1);
/* Encode the line */
x = 0;
while (x < byte_width)
{
int d;
assert(sp == bitmap->samples + y * ss + x);
/* How far do we have to look to find a repeated value? */
for (d = 1; d < 128 && x+d < byte_width; d++)
{
if (sp[d-1] == sp[d])
break;
}
if (d == 1)
{
int xrep;
/* We immediately have a repeat (or we've hit
* the end of the line). Count the number of
* times this value is repeated. */
for (xrep = 1; xrep < 128 && x+xrep < byte_width; xrep++)
{
if (sp[0] != sp[xrep])
break;
}
fz_write_byte(ctx, out, xrep-1);
fz_write(ctx, out, sp, 1);
sp += xrep;
x += xrep;
}
else
{
fz_write_byte(ctx, out, 257-d);
fz_write(ctx, out, sp, d);
sp += d;
x += d;
}
}
/* Move to the next line */
sp += ss*yrep - byte_width;
y += yrep;
}
}
int main(int argc, char* argv[]) {
if (!(argc == 3 ||
(argc == 4 &&
std::string(argv[3]).compare("-s") == 0))) {
std::cerr << "Usage: " << argv[0]
<< " ScoreFile OutputFile "
<< " [-s] "
<< std::endl;
return 1;
}
std::ifstream in_str(argv[1]);
if (!in_str) {
std::cerr << "Could not open " << argv[1] << " to read.\n";
return 1;
}
std::ofstream out_str(argv[2]);
if (!out_str) {
std::cerr << "Could not open " << argv[2] << " to write.\n";
return 1;
}
// read in the file and update the data
std::string line;
std::vector<std::string> tokens;
std::vector<Player> players;
unsigned int max_name_len = std::string("player").size();
while (std::getline(in_str, line)) {
tokens = split(line, ' ');
if (tokens.size() < 5) {
std::cerr << "Wrong input format in file " << argv[1] << ".\n";
return 1;
}
int winner;
int loser;
if (!find_player(players, tokens[0], tokens[1], winner)) {
players.push_back(Player(tokens[0], tokens[1]));
winner = players.size() - 1;
}
if (!find_player(players, tokens[3], tokens[4], loser)) {
players.push_back(Player(tokens[3], tokens[4]));
loser = players.size() - 1;
}
max_name_len = std::max(std::max(max_name_len,
players[winner].name_length()),
players[loser].name_length());
// update the match win/lose information
players[winner].win_match_by(1);
players[loser].lose_match_by(1);
// handle the sets information
for (unsigned int i = 5; i < tokens.size(); i++) {
int games_won;
int games_lost;
parse_set(tokens[i], games_won, games_lost);
// update the game win/lose information
players[winner].win_game_by(games_won);
players[loser].win_game_by(games_lost);
players[winner].lose_game_by(games_lost);
players[loser].lose_game_by(games_won);
// update the surprise match where
// winner loses first set or
// loser wins first set.
if (i == 5 && games_won < games_lost) {
// a match winner loses first set
players[winner].surprise_match_by(1);
players[winner].lose_win_match_by(1);
// a match loser wins first set
players[loser].surprise_match_by(1);
players[loser].win_lose_match_by(1);
}
}
}
// output the match information
std::sort(players.begin(), players.end(), more_matches);
out_str << "MATCH STATISTICS" << std::endl;
output_header(out_str, max_name_len);
for (unsigned int i = 0; i < players.size(); i++) {
players[i].output_match(out_str,
max_name_len);
}
out_str << std::endl;
std::sort(players.begin(), players.end(), more_games);
out_str << "GAME STATISTICS" << std::endl;
output_header(out_str, max_name_len);
for (unsigned int i = 0; i < players.size(); i++) {
players[i].output_game(out_str,
max_name_len);
}
// with a 4th argument, output the surprise ranking
// of all players
if (argc == 4 && std::string(argv[3]).compare("-s") == 0) {
out_str << std::endl;
std::sort(players.begin(), players.end(), more_surprises);
out_str << "SURPRISE STATISTICS" << std::endl;
output_header(out_str, max_name_len);
for (unsigned int i = 0; i < players.size(); i++) {
players[i].output_surprise(out_str, max_name_len);
}
}
}
void
fz_output_pwg_page(fz_context *ctx, fz_output *out, const fz_pixmap *pixmap, const fz_pwg_options *pwg)
{
unsigned char *sp;
int y, x, sn, dn, ss;
if (!out || !pixmap)
return;
if (pixmap->n != 1 && pixmap->n != 2 && pixmap->n != 4 && pixmap->n != 5)
fz_throw(ctx, FZ_ERROR_GENERIC, "pixmap must be grayscale, rgb or cmyk to write as pwg");
sn = pixmap->n;
dn = pixmap->n;
if (dn > 1)
dn--;
output_header(ctx, out, pwg, pixmap->xres, pixmap->yres, pixmap->w, pixmap->h, dn*8);
/* Now output the actual bitmap, using a packbits like compression */
sp = pixmap->samples;
ss = pixmap->w * sn;
y = 0;
while (y < pixmap->h)
{
int yrep;
assert(sp == pixmap->samples + y * ss);
/* Count the number of times this line is repeated */
for (yrep = 1; yrep < 256 && y+yrep < pixmap->h; yrep++)
{
if (memcmp(sp, sp + yrep * ss, ss) != 0)
break;
}
fz_write_byte(ctx, out, yrep-1);
/* Encode the line */
x = 0;
while (x < pixmap->w)
{
int d;
assert(sp == pixmap->samples + y * ss + x * sn);
/* How far do we have to look to find a repeated value? */
for (d = 1; d < 128 && x+d < pixmap->w; d++)
{
if (memcmp(sp + (d-1)*sn, sp + d*sn, sn) == 0)
break;
}
if (d == 1)
{
int xrep;
/* We immediately have a repeat (or we've hit
* the end of the line). Count the number of
* times this value is repeated. */
for (xrep = 1; xrep < 128 && x+xrep < pixmap->w; xrep++)
{
if (memcmp(sp, sp + xrep*sn, sn) != 0)
break;
}
fz_write_byte(ctx, out, xrep-1);
fz_write(ctx, out, sp, dn);
sp += sn*xrep;
x += xrep;
}
else
{
fz_write_byte(ctx, out, 257-d);
x += d;
while (d > 0)
{
fz_write(ctx, out, sp, dn);
sp += sn;
d--;
}
}
}
/* Move to the next line */
sp += ss*(yrep-1);
y += yrep;
}
}
int main(int argc, char *argv[])
{
DIR *dir;
struct dirent *entry;
struct stat st;
FTPWhoEntry *scanned_entry;
int locked;
int delete_file;
const char *state;
time_t now;
int fodder;
#ifndef NON_ROOT_FTP
if (geteuid() != (uid_t) 0) {
puts("You must be root to run this. Sorry.");
return 1;
}
#endif
if (argc < 0) {
return -1;
}
if (closedesc_but1() < 0) {
return -2;
}
#ifdef HAVE_SETLOCALE
# ifdef LC_MESSAGES
(void) setlocale(LC_MESSAGES, "");
# endif
# ifdef LC_CTYPE
(void) setlocale(LC_CTYPE, "");
# endif
# ifdef LC_COLLATE
(void) setlocale(LC_COLLATE, "");
# endif
#endif
fixlimits();
# ifdef SIGFPE
signal(SIGFPE, sigfpe);
# endif
# ifdef SIGSEGV
signal(SIGSEGV, sigsegv);
# endif
if (getenv("GATEWAY_INTERFACE") != NULL) {
html_cgi = 1;
output_header = html_output_header;
output_line = html_output_line;
output_footer = html_output_footer;
}
while ((fodder = getopt(argc, argv, "CchHnpsvwWx")) != -1) {
switch(fodder) {
case 'h' :
help();
/* doesn't return */
case 'n' :
case 'H' :
dont_resolve_ip++;
break;
case 'C' :
case 'c' :
html_cgi++;
case 'W' :
html_raw++;
case 'w' :
output_header = html_output_header;
output_line = html_output_line;
output_footer = html_output_footer;
break;
case 'p' :
output_header = plist_output_header;
output_line = plist_output_line;
output_footer = plist_output_footer;
break;
case 's' :
output_header = shell_output_header;
output_line = shell_output_line;
output_footer = shell_output_footer;
break;
case 'x' :
output_header = xml_output_header;
output_line = xml_output_line;
output_footer = xml_output_footer;
break;
case 'v' :
verbose++;
break;
case '?' :
help();
}
}
now = time(NULL);
if (chdir(SCOREBOARD_PATH) != 0 ||
(dir = opendir(".")) == NULL) {
fprintf(stderr, "Unable to open the ftpwho scoreboard.\n"
"Make sure that the [" SCOREBOARD_PATH "/] directory exists,\n"
"Or wait until a client connects, so that it gets\n"
"automatically created. This message doesn't mean that your\n"
"server didn't start properly. It probably just means that\n"
"you are running it with ftpwho for the first time.\n");
return -1;
}
lock.l_whence = SEEK_SET;
lock.l_start = (off_t) 0;
lock.l_len = (off_t) 0;
lock.l_pid = getpid();
output_header();
while ((entry = readdir(dir)) != NULL) {
mmap_fd = -1;
locked = 0;
delete_file = 0;
scanned_entry = NULL;
if (strncmp(entry->d_name, SCOREBOARD_PREFIX,
sizeof SCOREBOARD_PREFIX - 1U) != 0) {
goto nextone;
}
if ((mmap_fd = open(entry->d_name, O_RDWR | O_NOFOLLOW)) == -1) {
goto nextone;
}
if (fstat(mmap_fd, &st) != 0 || !S_ISREG(st.st_mode) ||
(st.st_mode & 0600) != 0600 ||
st.st_size != (off_t) sizeof (FTPWhoEntry) ||
#ifdef NON_ROOT_FTP
st.st_uid != geteuid()
#else
st.st_uid != (uid_t) 0
#endif
) {
goto nextone;
}
ftpwho_lock();
locked++;
if ((scanned_entry =
(FTPWhoEntry *) mmap(NULL, sizeof (FTPWhoEntry),
PROT_READ,
MAP_SHARED | MAP_FILE,
mmap_fd, (off_t) 0)) == (void *) MAP_FAILED) {
goto nextone;
}
if (checkproc(scanned_entry->pid) == 0) {
/* still in the scoreboard, but no more process */
delete_file++;
goto nextone;
}
if (scanned_entry->state != FTPWHO_STATE_FREE) {
unsigned long since;
unsigned long xfer_since;
char local_port[NI_MAXSERV];
char local_hbuf[NI_MAXHOST];
char hbuf[NI_MAXHOST];
switch (scanned_entry->state) {
case FTPWHO_STATE_IDLE :
state = "IDLE";
break;
case FTPWHO_STATE_DOWNLOAD :
state = " DL ";
break;
case FTPWHO_STATE_UPLOAD :
state = " UL ";
break;
default :
state = "ERR!";
}
if (scanned_entry->date < now) {
since = (unsigned long) (now - scanned_entry->date);
} else {
since = 0UL;
}
if (scanned_entry->xfer_date > (time_t) 0 &&
scanned_entry->xfer_date < now) {
xfer_since = (unsigned long) (now - scanned_entry->xfer_date);
} else {
xfer_since = 0UL;
}
for (;;) {
int eai;
if ((eai = getnameinfo
((struct sockaddr *) &scanned_entry->addr,
STORAGE_LEN(scanned_entry->addr),
hbuf, sizeof hbuf, NULL, (size_t) 0U,
dont_resolve_ip != 0 ? NI_NUMERICHOST : 0)) == 0) {
break;
}
#if defined(EAI_NONAME) && defined(EAI_SYSTEM)
if ((eai == EAI_NONAME || eai == EAI_SYSTEM) &&
dont_resolve_ip == 0 &&
getnameinfo
((struct sockaddr *) &scanned_entry->addr,
STORAGE_LEN(scanned_entry->addr),
hbuf, sizeof hbuf, NULL, (size_t) 0U,
NI_NUMERICHOST) == 0) {
break;
}
#endif
goto nextone;
}
for (;;) {
int eai;
if ((eai = getnameinfo
((struct sockaddr *) &scanned_entry->local_addr,
STORAGE_LEN(scanned_entry->addr),
local_hbuf, sizeof local_hbuf,
local_port, sizeof local_port,
dont_resolve_ip != 0 ? (NI_NUMERICHOST | NI_NUMERICSERV) :
NI_NUMERICSERV)) == 0) {
break;
}
#if defined(EAI_NONAME) && defined(EAI_SYSTEM)
if ((eai == EAI_NONAME || eai == EAI_SYSTEM) &&
dont_resolve_ip == 0 &&
getnameinfo
((struct sockaddr *) &scanned_entry->local_addr,
STORAGE_LEN(scanned_entry->addr),
local_hbuf, sizeof local_hbuf,
local_port, sizeof local_port,
NI_NUMERICHOST | NI_NUMERICSERV) == 0) {
break;
}
#endif
goto nextone;
}
output_line(scanned_entry->pid, scanned_entry->account,
since, xfer_since, state, scanned_entry->filename,
hbuf, local_hbuf, local_port,
(scanned_entry->restartat <=
scanned_entry->download_current_size) ?
scanned_entry->restartat : (off_t) 0,
(scanned_entry->state == FTPWHO_STATE_DOWNLOAD) ?
scanned_entry->download_total_size : (off_t) 0,
(scanned_entry->state == FTPWHO_STATE_DOWNLOAD ||
scanned_entry->state == FTPWHO_STATE_UPLOAD) ?
scanned_entry->download_current_size : (off_t) 0);
}
nextone:
if (locked != 0 && mmap_fd != -1) {
ftpwho_unlock();
}
if (scanned_entry != NULL) {
(void) munmap((void *) scanned_entry, sizeof (FTPWhoEntry));
}
if (mmap_fd != -1) {
close(mmap_fd);
}
if (delete_file != 0) {
unlink(entry->d_name);
}
}
output_footer();
return 0;
}
int main(int argc, char **argv)
{
char buf[1024];
int fundef = 0;
interactive = argc > 1 && !strncmp(argv[1], "-i", 2);
reset_labels();
if(!interactive) {
int lib_index = 1;
output_magic();
output_version();
for(lib_index = 1; lib_index < MAX_NUM_LIBS && lib_index < argc;
lib_index++) {
output_until_space(argv[lib_index], 1);
output_header(' ');
}
output_header('\0');
}
while(1) {
int emptyline;
if(interactive) {
printf(">>> ");
fflush(stdout);
}
emptyline = (fgets(buf, 1024, stdin) == NULL);
if(!interactive && emptyline)
break;
if(buf[0] == ':') {
if(buf[1] >= 'a' && buf[1] <= 'z') {
labels[buf[1] - 'a'] = current_addr;
}
}
else if(!strncmp(buf, "ADD", 3)) {
output(OPCODE_ADD);
}
else if(!strncmp(buf, "SUB", 3)) {
output(OPCODE_SUB);
}
else if(!strncmp(buf, "MUL", 3)) {
output(OPCODE_MUL);
}
else if(!strncmp(buf, "DIV", 3)) {
output(OPCODE_DIV);
}
else if(!strncmp(buf, "LT", 2)) {
output(OPCODE_LT);
}
else if(!strncmp(buf, "LE", 2)) {
output(OPCODE_LE);
}
else if(!strncmp(buf, "EQ", 2)) {
output(OPCODE_EQ);
}
else if(!strncmp(buf, "DUP", 3)) {
output(OPCODE_DUP);
}
else if(!strncmp(buf, "DROP", 4)) {
output(OPCODE_DROP);
}
else if(!strncmp(buf, "NOP", 3)) {
output(OPCODE_NOP);
}
else if(!strncmp(buf, "SWAP", 4)) {
output(OPCODE_SWAP);
}
else if(!strncmp(buf, "NEW", 3)) {
output(OPCODE_NEW);
}
else if(!strncmp(buf, "RSTORE", 6)) {
output(OPCODE_RSTORE);
}
else if(!strncmp(buf, "RLOAD", 4)) {
output(OPCODE_RLOAD);
}
else if(!strncmp(buf, "END_THUNK", 9)) {
output(OPCODE_END_THUNK);
}
else if(output_offset(buf, "BR", OPCODE_BRANCH));
else if(output_offset(buf, "BRNZ", OPCODE_BRANCHNZ));
else if(output_offset(buf, "THUNK", OPCODE_START_THUNK));
else if(!strncmp(buf, "FUNCALL ", 8)) {
int succ;
long int parsed_num = getnum(buf + 8, &succ);
if(!succ)
fprintf(stderr, "?\n");
else {
output_num(OPCODE_CALLFUN, parsed_num);
}
}
else if(!strncmp(buf, "FUNPCALL", 8)) {
output(OPCODE_CALLPFUN);
}
else if(!strncmp(buf, "FUNDEF ", 7)) {
if(fundef) {
fprintf(stderr, "?\n");
}
else {
int parsed_funnum, parsed_params;
int succ = get_two_nums(buf + 7, &parsed_funnum, &parsed_params);
if(!succ)
fprintf(stderr, "?\n");
else {
output_nums(OPCODE_DEFUN_START, parsed_params, parsed_funnum);
fundef = 1;
reset_labels();
}
}
}
else if(!strncmp(buf, "FUNEND", 6)) {
fundef = funend(OPCODE_DEFUN_END, fundef);
}
else if(!strncmp(buf, "RET0", 4)) {
fundef = funend(OPCODE_RET0, fundef);
}
else if(!strncmp(buf, "RET1", 4)) {
fundef = funend(OPCODE_RET1, fundef);
}
else if(!strncmp(buf, "LOAD ", 5)) {
int succ;
long int parsed_num = getnum(buf + 5, &succ);
if(!succ)
fprintf(stderr, "?\n");
else
output_num(OPCODE_LOAD, parsed_num);
}
else if(!strncmp(buf, "FFIDEF ", 7)) {
if(fundef) {
fprintf(stderr, "?\n");
}
else {
int succ = handle_ffidef(buf + 7);
if(!succ) {
fprintf(stderr, "FFIDEF?\n");
}
}
}
else if(buf[0] == 'f') {
int succ;
long int parsed_num = getnum(buf + 1, &succ);
if(!succ)
fprintf(stderr, "?\n");
else
output_num(OPCODE_PFUN_ID, parsed_num);
}
else if(buf[0] == '-' || isdigit(buf[0])) {
int succ;
long int parsed_num = getnum(buf, &succ);
if(!succ)
fprintf(stderr, "?\n");
else
output_num(OPCODE_INT, parsed_num);
}
else if(interactive && !strncmp(buf, "run", 3)) {
parse_buffer(interactive_buffer,
interactive_bufferpos);
}
else if(buf[0]) {
fprintf(stderr, "?\n");
}
}
return 0;
}
void output_version(void)
{
output_header(CURRENT_VERSION);
}
void ANNOTATE_INIT(void) {
#ifdef THREADS
ThreadContext *pctx = malloc(sizeof(ThreadContext));
pthread_key_create(&ctx_key, free_ctx);
pthread_setspecific(ctx_key, pctx);
#else
ThreadContext *pctx = &ctx;
#endif
/* prepare values for the header */
gather_header();
/* open the output file */
const char *dest;
if ((dest = getenv("ANNOTATE_DEST")) == NULL) dest = BASEPATH"/trace";
if (!strncmp(dest, "tcp:", 4)) {
char *p = strchr(dest+4, ':');
assert(p);
int len = p-(dest+4);
dest_host = malloc(len+1);
memcpy(dest_host, dest+4, len);
dest_host[len] = '\0';
dest_port = atoi(p+1);
printf("connecting to \"%s\" %d\n", dest_host, dest_port);
pctx->fd = sock_connect(dest_host, dest_port);
if (pctx->fd == -1) exit(1);
}
else {
char fn[256];
basepath = dest;
sprintf(fn, "%s-%s-%d", basepath, hostname, getpid());
pctx->fd = open(fn, O_WRONLY|O_CREAT|O_TRUNC, 0644);
if (pctx->fd == -1) { perror(fn); exit(1); }
pctx->procfd = -1;
pctx->idpos = 0;
ID(pctx) = NULL;
IDLEN(pctx) = 0;
const char *lvl = getenv("ANNOTATE_LOG_LEVEL");
pctx->log_level = lvl ? atoi(lvl) : 255;
}
#if 0 /* performance test */
struct timeval tv1, tv2;
int q;
struct rusage ru;
gettimeofday(&tv1, NULL);
for (q=0; q<100000; q++)
getrusage(RUSAGE_THREAD, &ru);
gettimeofday(&tv2, NULL);
printf("getrusage syscall: %ld\n",
1000000*(tv2.tv_sec - tv1.tv_sec) + tv2.tv_usec - tv1.tv_usec);
gettimeofday(&tv1, NULL);
for (q=0; q<100000; q++)
proc_getrusage(RUSAGE_THREAD, &ru);
gettimeofday(&tv2, NULL);
printf("getrusage in proc: %ld\n",
1000000*(tv2.tv_sec - tv1.tv_sec) + tv2.tv_usec - tv1.tv_usec);
#endif
output_header(pctx->fd);
/* depending on the kernel version, set rusage_who */
struct utsname ver;
uname(&ver);
char *p = strtok(ver.release, ".");
int major = p ? atoi(p) : 0;
p = strtok(NULL, ".");
int minor = p ? atoi(p) : 0;
p = strtok(NULL, ".");
int micro = p ? atoi(p) : 0;
// kernels <= 2.6.5 -> use RUSAGE_SELF
// kernels > 2.6.5 that have been patched -> use RUSAGE_THREAD
// stock kernels > 2.6.5 -> use USE_PROC
if (major < 2) rusage_who = RUSAGE_SELF;
else if (major > 2) rusage_who = RUSAGE_THREAD;
else if (minor < 6) rusage_who = RUSAGE_SELF;
else if (minor > 6) rusage_who = RUSAGE_THREAD;
else if (micro <= 5) rusage_who = RUSAGE_SELF;
else if (micro > 5) rusage_who = RUSAGE_THREAD;
if (rusage_who == RUSAGE_THREAD) {
struct rusage ru;
if (getrusage(RUSAGE_THREAD, &ru) == -1)
rusage_who = USE_PROC;
}
fprintf(stderr, "Kernel %d.%d.%d, rusage_who=%d\n",
major, minor, micro, rusage_who);
}
int
main(int argc, char **argv)
{
int i,j;
ESL_GETOPTS *go = NULL; /* command line processing */
ESL_STOPWATCH *w = esl_stopwatch_Create();
int status;
ESL_MSA *msa = NULL;
FILE *ofp = NULL; /* output file (default is stdout) */
ESL_ALPHABET *abc = NULL; /* digital alphabet */
char *alifile; /* name of the alignment file we're building HMMs from */
ESLX_MSAFILE *afp = NULL; /* open alifile */
int infmt = eslMSAFILE_UNKNOWN; /* autodetect alignment format by default. */
int outfmt = eslMSAFILE_STOCKHOLM;
char *postmsafile; /* optional file to resave annotated, modified MSAs to */
FILE *postmsafp = NULL; /* open <postmsafile>, or NULL */
int mask_range_cnt = 0;
uint32_t mask_starts[100]; // over-the-top allocation.
uint32_t mask_ends[100];
char *rangestr;
char *range;
int *map = NULL; /* map[i]=j, means model position i comes from column j of the alignment; 1..alen */
int keep_mm;
/* Set processor specific flags */
impl_Init();
alifile = NULL;
postmsafile = NULL;
/* Parse the command line
*/
process_commandline(argc, argv, &go, &alifile, &postmsafile);
keep_mm = esl_opt_IsUsed(go, "--apendmask");
/* Initialize what we can in the config structure (without knowing the alphabet yet).
* Fields controlled by masters are set up in usual_master() or mpi_master()
* Fields used by workers are set up in mpi_worker()
*/
ofp = NULL;
infmt = eslMSAFILE_UNKNOWN;
afp = NULL;
abc = NULL;
if (esl_opt_IsOn(go, "--informat")) {
infmt = eslx_msafile_EncodeFormat(esl_opt_GetString(go, "--informat"));
if (infmt == eslMSAFILE_UNKNOWN) p7_Fail("%s is not a recognized input sequence file format\n", esl_opt_GetString(go, "--informat"));
}
/* Determine output alignment file format */
outfmt = eslx_msafile_EncodeFormat(esl_opt_GetString(go, "--outformat"));
if (outfmt == eslMSAFILE_UNKNOWN) p7_Fail(argv[0], "%s is not a recognized output MSA file format\n", esl_opt_GetString(go, "--outformat"));
/* Parse the ranges */
if (esl_opt_IsUsed(go, "--alirange")) {
esl_strdup(esl_opt_GetString(go, "--alirange"), -1, &rangestr) ;
} else if (esl_opt_IsUsed(go, "--modelrange")) {
esl_strdup(esl_opt_GetString(go, "--modelrange"), -1, &rangestr) ;
} else if (esl_opt_IsUsed(go, "--model2ali")) {
esl_strdup(esl_opt_GetString(go, "--model2ali"), -1, &rangestr) ;
} else if (esl_opt_IsUsed(go, "--ali2model")) {
esl_strdup(esl_opt_GetString(go, "--ali2model"), -1, &rangestr) ;
} else {
if (puts("Must specify mask range with --modelrange, --alirange, --model2ali, or --ali2model\n") < 0) ESL_XEXCEPTION_SYS(eslEWRITE, "write failed"); goto ERROR;
}
while ( (status = esl_strtok(&rangestr, ",", &range) ) == eslOK) {
status = esl_regexp_ParseCoordString(range, mask_starts + mask_range_cnt, mask_ends + mask_range_cnt );
if (status == eslESYNTAX) esl_fatal("range flags take coords <from>..<to>; %s not recognized", range);
if (status == eslFAIL) esl_fatal("Failed to find <from> or <to> coord in %s", range);
mask_range_cnt++;
}
/* Start timing. */
esl_stopwatch_Start(w);
/* Open files, set alphabet.
* afp - open alignment file for input
* abc - alphabet expected or guessed in ali file
* postmsafp - open MSA output file
* ofp - optional open output file, or stdout
*/
if (esl_opt_GetBoolean(go, "--amino")) abc = esl_alphabet_Create(eslAMINO);
else if (esl_opt_GetBoolean(go, "--dna")) abc = esl_alphabet_Create(eslDNA);
else if (esl_opt_GetBoolean(go, "--rna")) abc = esl_alphabet_Create(eslRNA);
else abc = NULL;
status = eslx_msafile_Open(&abc, alifile, NULL, infmt, NULL, &afp);
if (status != eslOK) eslx_msafile_OpenFailure(afp, status);
if (esl_opt_IsUsed(go, "--alirange") || esl_opt_IsUsed(go, "--modelrange") ) {
postmsafp = fopen(postmsafile, "w");
if (postmsafp == NULL) p7_Fail("Failed to MSA output file %s for writing", postmsafile);
}
if (esl_opt_IsUsed(go, "-o"))
{
ofp = fopen(esl_opt_GetString(go, "-o"), "w");
if (ofp == NULL) p7_Fail("Failed to open -o output file %s\n", esl_opt_GetString(go, "-o"));
}
else ofp = stdout;
/* Looks like the i/o is set up successfully...
* Initial output to the user
*/
output_header(go, ofp, alifile, postmsafile); /* cheery output header */
/* read the alignment */
if ((status = eslx_msafile_Read(afp, &msa)) != eslOK) eslx_msafile_ReadFailure(afp, status);
if (esl_opt_IsUsed(go, "--alirange") || esl_opt_IsUsed(go, "--modelrange") ) {
/* add/modify mmline for the mask */
if (msa->mm == NULL) {
ESL_ALLOC(msa->mm, msa->alen);
keep_mm = FALSE;
}
if (!keep_mm)
for (i=0; i<msa->alen; i++) msa->mm[i] = '.';
}
// convert model coordinates to alignment coordinates, if necessary
if (esl_opt_IsUsed(go, "--modelrange") || esl_opt_IsUsed(go, "--model2ali") || esl_opt_IsUsed(go, "--ali2model") ) {
float symfrac = esl_opt_GetReal(go, "--symfrac");
int do_hand = esl_opt_IsOn(go, "--hand");
int L;
//same as p7_builder relative_weights
if (esl_opt_IsOn(go, "--wnone") ) { esl_vec_DSet(msa->wgt, msa->nseq, 1.); }
else if (esl_opt_IsOn(go, "--wgiven") ) ;
else if (esl_opt_IsOn(go, "--wpb") ) status = esl_msaweight_PB(msa);
else if (esl_opt_IsOn(go, "--wgsc") ) status = esl_msaweight_GSC(msa);
else if (esl_opt_IsOn(go, "--wblosum")) status = esl_msaweight_BLOSUM(msa, esl_opt_GetReal(go, "--wid"));
if ((status = esl_msa_MarkFragments(msa, esl_opt_GetReal(go, "--fragthresh"))) != eslOK) goto ERROR;
//build a map of model mask coordinates to alignment coords
ESL_ALLOC(map, sizeof(int) * (msa->alen+1));
L = p7_Alimask_MakeModel2AliMap(msa, do_hand, symfrac, map );
if ( esl_opt_IsUsed(go, "--model2ali") ) {
//print mapping
printf ("model coordinates alignment coordinates\n");
for (i=0; i<mask_range_cnt; i++)
printf ("%8d..%-8d -> %8d..%-8d\n", mask_starts[i], mask_ends[i], map[mask_starts[i]-1], map[mask_ends[i]-1]);
/* If I wanted to, I could print all the map values independently:
printf("\n\n-----------\n");
printf("Map\n");
printf("---\n");
for (i=0; i<L; i++)
printf("%d -> %d\n", i+1, map[i]);
*/
} else if ( esl_opt_IsUsed(go, "--ali2model") ) {
//print mapping (requires scanning the inverted map
int alistart = 0;
int aliend = 0;
printf ("alignment coordinates model coordinates\n");
for (i=0; i<mask_range_cnt; i++) {
//find j for ali positions
while (map[alistart] < mask_starts[i] )
alistart++;
aliend = alistart;
while (map[aliend] < mask_ends[i] )
aliend++;
printf (" %8d..%-8d -> %8d..%-8d\n", map[alistart], map[aliend], alistart+1, aliend+1);
}
} else {
//convert the mask coords based on map
for (i=0; i<mask_range_cnt; i++) {
mask_starts[i] = map[mask_starts[i]-1]; //-1 because mmline is offset by one relative to the 1-base alignment
mask_ends[i] = map[mask_ends[i]-1];
}
}
}
if (esl_opt_IsUsed(go, "--alirange") || esl_opt_IsUsed(go, "--modelrange") ) {
//overwrite '.' with 'm' everywhere the range says to do it
for (i=0; i<mask_range_cnt; i++)
for (j=mask_starts[i]; j<=mask_ends[i]; j++)
msa->mm[j-1] = 'm';
if ((status = eslx_msafile_Write(postmsafp, msa, outfmt)) != eslOK) ESL_XEXCEPTION_SYS(eslEWRITE, "write failed");
}
esl_stopwatch_Stop(w);
if (esl_opt_IsOn(go, "-o")) fclose(ofp);
if (postmsafp) fclose(postmsafp);
if (afp) eslx_msafile_Close(afp);
if (abc) esl_alphabet_Destroy(abc);
esl_getopts_Destroy(go);
esl_stopwatch_Destroy(w);
return 0;
ERROR:
return eslFAIL;
}
int main(int argc, char **argv)
{
char *descriptor;
char *curpos; /* current position in input string */
struct keyval *parser_id; /* the parser we are creating output for */
FILE *outputf;
struct keyval *rkv; /* current read key:val */
struct keyval_list *curlist;
bool do_token_check = true; /* if the check for valid tokens is done */
bool only_ident = true; /* if the only token type is ident */
bool is_generic = false;
struct keyval_list base;
struct keyval_list IDENT;
struct keyval_list IDENT_LIST;
struct keyval_list LENGTH_UNIT;
struct keyval_list URI;
struct keyval_list WRAP;
struct keyval_list NUMBER;
struct keyval_list COLOR;
if (argc < 2) {
fprintf(stderr,"Usage: %s [-o <filename>] <descriptor>\n", argv[0]);
return 1;
}
if ((argv[1][0] == '-') && (argv[1][1] == 'o')) {
if (argc != 4) {
fprintf(stderr,"Usage: %s [-o <filename>] <descriptor>\n", argv[0]);
return 1;
}
outputf = fopen(argv[2], "w");
if (outputf == NULL) {
perror("unable to open file");
}
descriptor = strdup(argv[3]);
} else {
outputf = stdout;
descriptor = strdup(argv[1]);
}
curpos = descriptor;
base.count = 0;
IDENT.count = 0;
URI.count = 0;
WRAP.count = 0;
NUMBER.count = 0;
COLOR.count = 0;
LENGTH_UNIT.count = 0;
IDENT_LIST.count = 0;
curlist = &base;
while (*curpos != 0) {
rkv = get_keyval(&curpos);
if (rkv == NULL) {
fprintf(stderr,"Token error at offset %ld\n", curpos - descriptor);
fclose(outputf);
return 2;
}
if (strcmp(rkv->key, "WRAP") == 0) {
WRAP.item[WRAP.count++] = rkv;
only_ident = false;
} else if (strcmp(rkv->key, "NUMBER") == 0) {
if (rkv->val[0] == '(') {
curlist = &NUMBER;
} else if (rkv->val[0] == ')') {
curlist = &base;
} else {
NUMBER.item[NUMBER.count++] = rkv;
}
only_ident = false;
} else if (strcmp(rkv->key, "IDENT") == 0) {
if (rkv->val[0] == '(') {
curlist = &IDENT;
} else if (rkv->val[0] == ')') {
curlist = &base;
} else if (strcmp(rkv->val, str_INHERIT) == 0) {
IDENT.item[IDENT.count++] = &ident_inherit;
}
} else if (strcmp(rkv->key, "IDENT_LIST") == 0) {
if (rkv->val[0] == '(') {
curlist = &IDENT_LIST;
} else if (rkv->val[0] == ')') {
curlist = &base;
}
} else if (strcmp(rkv->key, "LENGTH_UNIT") == 0) {
if (rkv->val[0] == '(') {
curlist = &LENGTH_UNIT;
} else if (rkv->val[0] == ')') {
curlist = &base;
}
only_ident = false;
do_token_check = false;
} else if (strcmp(rkv->key, "COLOR") == 0) {
COLOR.item[COLOR.count++] = rkv;
do_token_check = false;
only_ident = false;
} else if (strcmp(rkv->key, "URI") == 0) {
URI.item[URI.count++] = rkv;
only_ident = false;
} else if (strcmp(rkv->key, "GENERIC") == 0) {
is_generic = true;
} else {
/* just append to current list */
curlist->item[curlist->count++] = rkv;
}
}
if (base.count != 1) {
fprintf(stderr,"Incorrect base element count (got %d expected 1)\n", base.count);
fclose(outputf);
return 3;
}
/* header */
output_header(outputf, descriptor, base.item[0], is_generic);
if (WRAP.count > 0) {
output_wrap(outputf, base.item[0], &WRAP);
} else {
/* check token type is correct */
output_token_type_check(outputf, do_token_check, &IDENT, &URI, &NUMBER);
if (IDENT.count > 0)
output_ident(outputf, only_ident, base.item[0], &IDENT);
if (URI.count > 0)
output_uri(outputf, base.item[0], &URI);
if (NUMBER.count > 0)
output_number(outputf, base.item[0], &NUMBER);
/* terminal blocks, these end the ladder ie no trailing else */
if (COLOR.count > 0) {
output_color(outputf, base.item[0], &COLOR);
} else if (LENGTH_UNIT.count > 0) {
output_length_unit(outputf, base.item[0], &LENGTH_UNIT);
} else if (IDENT_LIST.count > 0) {
output_ident_list(outputf, base.item[0], &IDENT_LIST);
} else {
output_invalidcss(outputf);
}
output_footer(outputf);
}
fclose(outputf);
return 0;
}
int
main (int argc, char** argv)
{
char *cswidth_name;
com_name = argv[0];
init (argc, argv);
if ((cswidth_name = get_cswidth_name (WNN_DEFAULT_LANG)) != NULL)
{
set_cswidth (create_cswidth (cswidth_name));
}
#ifdef CHINESE
ujis_header (&which_dict); /* read header of UJIS dic */
#else
ujis_header (); /* read header of UJIS dic */
#endif
/* like comment,total,hinsi */
#ifdef CHINESE
read_ujis (reverse_dict, to_esc, which_dict);
if (which_dict != CWNN_REV_DICT && which_dict != BWNN_REV_DICT)
reverse_yomi ();
#else
read_ujis (reverse_dict, to_esc, (which_dict == WNN_REV_DICT) ? 1 : 0);
#ifndef CONVERT_from_TOP
reverse_yomi ();
#endif
#endif
if ((ofpter = fopen (outfile, "w")) == NULL)
{
fprintf (stderr, "Can't open the output file %s.\n", outfile);
perror ("");
exit (1);
}
#ifdef CHINESE
if ((which_dict & 0xff) == WNN_REV_DICT)
{
#else
if (which_dict == WNN_REV_DICT)
{
#endif
create_rev_dict ();
}
else
{
alloc_area ();
if (which_dict == WNN_STATIC_DICT)
{
sdic_sort ();
uniq_je (sort_func_sdic);
output_dic_data ();
ujistosd (0, 0);
}
else
{
sort_if_not_sorted ();
uniq_je (sort_func_je);
output_dic_data ();
ujistoud ();
set_pter1 ();
}
}
output_dic_index ();
rewind (ofpter);
output_header (ofpter, &jt, &file_head);
#ifdef nodef
output_comment (ofpter); /* In order to change the byte order */
output_hinsi_list (ofpter); /* In order to change the byte order */
#endif
exit (0);
}
w_char *
addyomient (int tn, w_char* yomi)
{
int len = wnn_Strlen (yomi);
tary[tn].yomi2 = 0;
tary[tn].yomi1 = yomi[0] << 16;
uhopter->yomi[0] = len;
if (yomi[1])
{
tary[tn].yomi1 |= yomi[1];
if (yomi[2])
{
tary[tn].yomi2 = yomi[2] << 16;
if (yomi[3])
{
tary[tn].yomi2 |= yomi[3];
}
if (len > 4)
{
wnn_Strncpy (uhopter->yomi + 1, yomi + 4, len - 4);
return (uhopter->yomi + 1 + len - 4);
}
}
}
return (uhopter->yomi + 1);
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = NULL; /* command line processing */
ESL_ALPHABET *abc = NULL;
char *hmmfile = NULL;
P7_HMMFILE *hfp = NULL;
P7_HMM *hmm = NULL;
P7_BG *bg = NULL;
int nhmm;
double x;
float KL;
int status;
char errbuf[eslERRBUFSIZE];
float nseq;
int do_eval2score = 0;
int do_score2eval = 0;
int z_val;
float e_val;
float s_val;
/* Process the command line options.
*/
go = esl_getopts_Create(options);
if (esl_opt_ProcessCmdline(go, argc, argv) != eslOK ||
esl_opt_VerifyConfig(go) != eslOK)
{
printf("Failed to parse command line: %s\n", go->errbuf);
esl_usage(stdout, argv[0], usage);
printf("\nTo see more help on available options, do %s -h\n\n", argv[0]);
exit(1);
}
if (esl_opt_GetBoolean(go, "-h") == TRUE)
{
p7_banner(stdout, argv[0], banner);
esl_usage(stdout, argv[0], usage);
puts("\nOptions:");
esl_opt_DisplayHelp(stdout, go, 0, 2, 80); /* 0=docgroup, 2 = indentation; 80=textwidth*/
exit(0);
}
if (esl_opt_ArgNumber(go) != 1)
{
puts("Incorrect number of command line arguments.");
esl_usage(stdout, argv[0], usage);
printf("\nTo see more help on available options, do %s -h\n\n", argv[0]);
exit(1);
}
if ((hmmfile = esl_opt_GetArg(go, 1)) == NULL)
{
puts("Failed to read <hmmfile> argument from command line.");
esl_usage(stdout, argv[0], usage);
printf("\nTo see more help on available options, do %s -h\n\n", argv[0]);
exit(1);
}
output_header(stdout, go);
if ( esl_opt_IsOn(go, "--eval2score") ) {
do_eval2score = TRUE;
e_val = esl_opt_GetReal(go, "-E");
} else if ( esl_opt_IsOn(go, "--score2eval") ) {
do_score2eval = TRUE;
s_val = esl_opt_GetReal(go, "-S");
} else if ( esl_opt_IsUsed(go, "--baseZ") || esl_opt_IsUsed(go, "--baseZ1") || esl_opt_IsUsed(go, "-Z") ) {
puts("The flags -Z, --baseZ, and --baseZ1 are for use with --eval2score and --score2eval.");
esl_usage(stdout, argv[0], usage);
printf("\nTo see more help on available options, do %s -h\n\n", argv[0]);
exit(1);
}
if (esl_opt_IsUsed(go, "--baseZ") ) {
z_val = 1000000 * 2 * (long)(esl_opt_GetInteger(go, "--baseZ"));
} else if (esl_opt_IsUsed(go, "--baseZ1") ) {
z_val = 1000000 * (long)(esl_opt_GetInteger(go, "--baseZ1"));
} else {
z_val = esl_opt_GetInteger(go, "-Z");
}
/* Initializations: open the HMM file
*/
status = p7_hmmfile_OpenE(hmmfile, NULL, &hfp, errbuf);
if (status == eslENOTFOUND) p7_Fail("File existence/permissions problem in trying to open HMM file %s.\n%s\n", hmmfile, errbuf);
else if (status == eslEFORMAT) p7_Fail("File format problem in trying to open HMM file %s.\n%s\n", hmmfile, errbuf);
else if (status != eslOK) p7_Fail("Unexpected error %d in opening HMM file %s.\n%s\n", status, hmmfile, errbuf);
/* Main body: read HMMs one at a time, print one line of stats
*/
printf("#\n");
printf("# %-4s %-20s %-12s %8s %8s %6s %6s %6s %6s %6s", "idx", "name", "accession", "nseq", "eff_nseq", "M", "relent", "info", "p relE", "compKL");
if (do_eval2score)
printf (" %6s %6.2g", "sc for", e_val);
if (do_score2eval)
printf (" %6s %6.2f", "E-val for", s_val);
printf("\n");
printf("# %-4s %-20s %-12s %8s %8s %6s %6s %6s %6s %6s", "----", "--------------------", "------------", "--------", "--------", "------", "------", "------", "------", "------");
if (do_eval2score)
printf (" %13s", "-------------");
if (do_score2eval)
printf (" %13s", "-------------");
printf("\n");
nhmm = 0;
while ((status = p7_hmmfile_Read(hfp, &abc, &hmm)) != eslEOF)
{
if (status == eslEOD) esl_fatal("read failed, HMM file %s may be truncated?", hmmfile);
else if (status == eslEFORMAT) esl_fatal("bad file format in HMM file %s", hmmfile);
else if (status == eslEINCOMPAT) esl_fatal("HMM file %s contains different alphabets", hmmfile);
else if (status != eslOK) esl_fatal("Unexpected error in reading HMMs from %s", hmmfile);
nhmm++;
if ( esl_opt_IsOn(go, "--eval2score") || esl_opt_IsOn(go, "--score2eval") ) {
if (esl_opt_IsUsed(go, "--baseZ") || esl_opt_IsUsed(go, "--baseZ1" ) ) {
if ( hmm->abc->type != eslRNA && hmm->abc->type != eslDNA) {
puts("The flags --baseZ and --baseZ1 can't be used with non-nucleotide models.");
esl_usage(stdout, argv[0], usage);
printf("\nTo see more help on available options, do %s -h\n\n", argv[0]);
exit(1);
}
} else if ( hmm->abc->type != eslAMINO && hmm->abc->type != eslRNA && hmm->abc->type != eslDNA) {
puts("The flags --eval2score and --score2eval can't be used with non-sequence models.");
esl_usage(stdout, argv[0], usage);
printf("\nTo see more help on available options, do %s -h\n\n", argv[0]);
exit(1);
}
}
if (esl_opt_IsUsed(go, "--baseZ") ) {
nseq = (float)z_val / (float)(hmm->max_length);
} else if (esl_opt_IsUsed(go, "--baseZ1") ) {
nseq = (float)z_val / (float)(hmm->max_length);
} else {
nseq = z_val;
}
if (bg == NULL) bg = p7_bg_Create(abc);
p7_MeanPositionRelativeEntropy(hmm, bg, &x);
p7_hmm_CompositionKLDist(hmm, bg, &KL, NULL);
printf("%-6d %-20s %-12s %8d %8.2f %6d %6.2f %6.2f %6.2f %6.2f",
nhmm,
hmm->name,
hmm->acc == NULL ? "-" : hmm->acc,
hmm->nseq,
hmm->eff_nseq,
hmm->M,
p7_MeanMatchRelativeEntropy(hmm, bg),
p7_MeanMatchInfo(hmm, bg),
x,
KL);
if ( do_eval2score )
{
float sc;
sc = esl_exp_invsurv( e_val / nseq , hmm->evparam[p7_FTAU], hmm->evparam[p7_FLAMBDA]);
printf("%13.2f", sc);
}
else if ( do_score2eval)
{
float e;
e = nseq * esl_exp_surv( s_val , hmm->evparam[p7_FTAU], hmm->evparam[p7_FLAMBDA]);
printf("%13.2g", e);
}
printf("\n");
/* p7_MeanForwardScore(hmm, bg)); */
p7_hmm_Destroy(hmm);
}
p7_bg_Destroy(bg);
esl_alphabet_Destroy(abc);
p7_hmmfile_Close(hfp);
esl_getopts_Destroy(go);
exit(0);
}
/* serial_master()
* The serial version of hmmsearch.
* For each query HMM in <hmmdb> search the database for hits.
*
* A master can only return if it's successful. All errors are handled
* immediately and fatally with p7_Fail().
*/
static int
serial_master(ESL_GETOPTS *go, struct cfg_s *cfg)
{
FILE *ofp = stdout; /* output file for results (default stdout) */
FILE *tblfp = NULL; /* output stream for tabular per-seq (--tblout) */
FILE *dfamtblfp = NULL; /* output stream for tabular Dfam format (--dfamtblout) */
FILE *aliscoresfp = NULL; /* output stream for alignment scores (--aliscoresout) */
// P7_HMM *hmm = NULL; /* one HMM query */
// P7_SCOREDATA *scoredata = NULL;
int seqfmt = eslSQFILE_UNKNOWN; /* format of seqfile */
ESL_SQFILE *sqfp = NULL; /* open seqfile */
P7_HMMFILE *hfp = NULL; /* open HMM database file */
ESL_ALPHABET *abc = NULL; /* sequence alphabet */
P7_OPROFILE *om = NULL; /* target profile */
ESL_STOPWATCH *w = NULL; /* timing */
ESL_SQ *qsq = NULL; /* query sequence */
int nquery = 0;
int textw;
int status = eslOK;
int hstatus = eslOK;
int sstatus = eslOK;
int i;
int ncpus = 0;
int infocnt = 0;
WORKER_INFO *info = NULL;
#ifdef HMMER_THREADS
P7_OM_BLOCK *block = NULL;
ESL_THREADS *threadObj= NULL;
ESL_WORK_QUEUE *queue = NULL;
#endif
char errbuf[eslERRBUFSIZE];
double window_beta = -1.0 ;
int window_length = -1;
if (esl_opt_IsUsed(go, "--w_beta")) { if ( ( window_beta = esl_opt_GetReal(go, "--w_beta") ) < 0 || window_beta > 1 ) esl_fatal("Invalid window-length beta value\n"); }
if (esl_opt_IsUsed(go, "--w_length")) { if (( window_length = esl_opt_GetInteger(go, "--w_length")) < 4 ) esl_fatal("Invalid window length value\n"); }
w = esl_stopwatch_Create();
if (esl_opt_GetBoolean(go, "--notextw")) textw = 0;
else textw = esl_opt_GetInteger(go, "--textw");
/* If caller declared an input format, decode it */
if (esl_opt_IsOn(go, "--qformat")) {
seqfmt = esl_sqio_EncodeFormat(esl_opt_GetString(go, "--qformat"));
if (seqfmt == eslSQFILE_UNKNOWN) p7_Fail("%s is not a recognized input sequence file format\n", esl_opt_GetString(go, "--qformat"));
}
/* validate options if running as a daemon */
// if (esl_opt_IsOn(go, "--daemon")) {
/* running as a daemon, the input format must be type daemon */
// if (seqfmt != eslSQFILE_UNKNOWN && seqfmt != eslSQFILE_DAEMON)
// esl_fatal("Input format %s not supported. Must be daemon\n", esl_opt_GetString(go, "--qformat"));
// seqfmt = eslSQFILE_DAEMON;
// if (strcmp(cfg->seqfile, "-") != 0) esl_fatal("Query sequence file must be '-'\n");
// }
/* Open the target profile database to get the sequence alphabet */
status = p7_hmmfile_OpenE(cfg->hmmfile, p7_HMMDBENV, &hfp, errbuf);
if (status == eslENOTFOUND) p7_Fail("File existence/permissions problem in trying to open HMM file %s.\n%s\n", cfg->hmmfile, errbuf);
else if (status == eslEFORMAT) p7_Fail("File format problem, trying to open HMM file %s.\n%s\n", cfg->hmmfile, errbuf);
else if (status != eslOK) p7_Fail("Unexpected error %d in opening HMM file %s.\n%s\n", status, cfg->hmmfile, errbuf);
if (! hfp->is_pressed) p7_Fail("Failed to open binary auxfiles for %s: use hmmpress first\n", hfp->fname);
hstatus = p7_oprofile_ReadMSV(hfp, &abc, &om);
if (hstatus == eslEFORMAT) p7_Fail("bad format, binary auxfiles, %s:\n%s", cfg->hmmfile, hfp->errbuf);
else if (hstatus == eslEINCOMPAT) p7_Fail("HMM file %s contains different alphabets", cfg->hmmfile);
else if (hstatus != eslOK) p7_Fail("Unexpected error in reading HMMs from %s", cfg->hmmfile);
p7_oprofile_Destroy(om);
p7_hmmfile_Close(hfp);
/* Open the query sequence database */
status = esl_sqfile_OpenDigital(abc, cfg->seqfile, seqfmt, NULL, &sqfp);
if (status == eslENOTFOUND) p7_Fail("Failed to open sequence file %s for reading\n", cfg->seqfile);
else if (status == eslEFORMAT) p7_Fail("Sequence file %s is empty or misformatted\n", cfg->seqfile);
else if (status == eslEINVAL) p7_Fail("Can't autodetect format of a stdin or .gz seqfile");
else if (status != eslOK) p7_Fail("Unexpected error %d opening sequence file %s\n", status, cfg->seqfile);
if (sqfp->format > 100) // breaking the law! That range is reserved for msa, for aligned formats
p7_Fail("%s contains a multiple sequence alignment; expect unaligned sequences, like FASTA\n", cfg->seqfile);
qsq = esl_sq_CreateDigital(abc);
/* Open the results output files */
if (esl_opt_IsOn(go, "-o")) { if ((ofp = fopen(esl_opt_GetString(go, "-o"), "w")) == NULL) esl_fatal("Failed to open output file %s for writing\n", esl_opt_GetString(go, "-o")); }
if (esl_opt_IsOn(go, "--tblout")) { if ((tblfp = fopen(esl_opt_GetString(go, "--tblout"), "w")) == NULL) esl_fatal("Failed to open tabular per-seq output file %s for writing\n", esl_opt_GetString(go, "--tblfp")); }
if (esl_opt_IsOn(go, "--dfamtblout")) { if ((dfamtblfp = fopen(esl_opt_GetString(go, "--dfamtblout"),"w")) == NULL) esl_fatal("Failed to open tabular dfam output file %s for writing\n", esl_opt_GetString(go, "--dfamtblout")); }
if (esl_opt_IsOn(go, "--aliscoresout")) { if ((aliscoresfp = fopen(esl_opt_GetString(go, "--aliscoresout"),"w")) == NULL) esl_fatal("Failed to open alignment scores output file %s for writing\n", esl_opt_GetString(go, "--aliscoresout")); }
output_header(ofp, go, cfg->hmmfile, cfg->seqfile);
#ifdef HMMER_THREADS
/* initialize thread data */
if (esl_opt_IsOn(go, "--cpu")) ncpus = esl_opt_GetInteger(go, "--cpu");
else esl_threads_CPUCount(&ncpus);
if (ncpus > 0)
{
threadObj = esl_threads_Create(&pipeline_thread);
queue = esl_workqueue_Create(ncpus * 2);
}
#endif
infocnt = (ncpus == 0) ? 1 : ncpus;
ESL_ALLOC(info, sizeof(*info) * infocnt);
for (i = 0; i < infocnt; ++i)
{
info[i].bg = p7_bg_Create(abc);
#ifdef HMMER_THREADS
info[i].queue = queue;
#endif
}
#ifdef HMMER_THREADS
for (i = 0; i < ncpus * 2; ++i)
{
block = p7_oprofile_CreateBlock(BLOCK_SIZE);
if (block == NULL) esl_fatal("Failed to allocate sequence block");
status = esl_workqueue_Init(queue, block);
if (status != eslOK) esl_fatal("Failed to add block to work queue");
}
#endif
/* Outside loop: over each query sequence in <seqfile>. */
while ((sstatus = esl_sqio_Read(sqfp, qsq)) == eslOK)
{
if (sstatus == eslEMEM) p7_Fail("Memory allocation error reading sequence file\n", status);
if (sstatus == eslEINCONCEIVABLE) p7_Fail("Unexpected error %d reading sequence file\n", status);
// if (qsq->L > NHMMER_MAX_RESIDUE_COUNT) p7_Fail("Input sequence %s in file %s exceeds maximum length of %d bases.\n", qsq->name, cfg->seqfile, NHMMER_MAX_RESIDUE_COUNT);
nquery++;
esl_stopwatch_Start(w);
/* Open the target profile database */
status = p7_hmmfile_OpenE(cfg->hmmfile, p7_HMMDBENV, &hfp, NULL);
if (status != eslOK) p7_Fail("Unexpected error %d in opening hmm file %s.\n", status, cfg->hmmfile);
#ifdef HMMER_THREADS
/* if we are threaded, create a lock to prevent multiple readers */
if (ncpus > 0)
{
status = p7_hmmfile_CreateLock(hfp);
if (status != eslOK) p7_Fail("Unexpected error %d creating lock\n", status);
}
#endif
if (fprintf(ofp, "Query: %s [L=%ld]\n", qsq->name, (long) qsq->n) < 0) ESL_EXCEPTION_SYS(eslEWRITE, "write failed");
if (qsq->acc[0] != 0 && fprintf(ofp, "Accession: %s\n", qsq->acc) < 0) ESL_EXCEPTION_SYS(eslEWRITE, "write failed");
if (qsq->desc[0] != 0 && fprintf(ofp, "Description: %s\n", qsq->desc) < 0) ESL_EXCEPTION_SYS(eslEWRITE, "write failed");
for (i = 0; i < infocnt; ++i)
{
/* Create processing pipeline and hit list */
info[i].th = p7_tophits_Create();
info[i].pli = p7_pipeline_Create(go, 100, 100, TRUE, p7_SCAN_MODELS); /* M_hint = 100, L_hint = 100 are just dummies for now */
info[i].pli->hfp = hfp; /* for two-stage input, pipeline needs <hfp> */
p7_pli_NewSeq(info[i].pli, qsq);
info[i].qsq = qsq;
if ( esl_opt_IsUsed(go, "--toponly") )
info[i].pli->strand = p7_STRAND_TOPONLY;
else if ( esl_opt_IsUsed(go, "--bottomonly") )
info[i].pli->strand = p7_STRAND_BOTTOMONLY;
else
info[i].pli->strand = p7_STRAND_BOTH;
#ifdef HMMER_THREADS
if (ncpus > 0) esl_threads_AddThread(threadObj, &info[i]);
#endif
}
#ifdef HMMER_THREADS
if (ncpus > 0) hstatus = thread_loop(threadObj, queue, hfp);
else hstatus = serial_loop(info, hfp);
#else
hstatus = serial_loop(info, hfp);
#endif
switch(hstatus)
{
case eslEFORMAT: p7_Fail("bad file format in HMM file %s", cfg->hmmfile); break;
case eslEINCOMPAT: p7_Fail("HMM file %s contains different alphabets", cfg->hmmfile); break;
case eslEOF:
case eslOK: /* do nothing */
break;
default: p7_Fail("Unexpected error in reading HMMs from %s", cfg->hmmfile);
}
/* merge the results of the search results */
for (i = 1; i < infocnt; ++i)
{
p7_tophits_Merge(info[0].th, info[i].th);
p7_pipeline_Merge(info[0].pli, info[i].pli);
p7_pipeline_Destroy(info[i].pli);
p7_tophits_Destroy(info[i].th);
}
/* modify e-value to account for number of models */
for (i = 0; i < info->th->N ; i++)
{
info->th->unsrt[i].lnP += log((float)info->pli->nmodels);
info->th->unsrt[i].dcl[0].lnP = info->th->unsrt[i].lnP;
info->th->unsrt[i].sortkey = -1.0 * info->th->unsrt[i].lnP;
}
/* it's possible to have duplicates based on how viterbi ranges can overlap */
p7_tophits_SortByModelnameAndAlipos(info->th);
p7_tophits_RemoveDuplicates(info->th, info->pli->use_bit_cutoffs);
/* Print results */
p7_tophits_SortBySortkey(info->th);
p7_tophits_Threshold(info->th, info->pli);
//tally up total number of hits and target coverage
info->pli->n_output = info->pli->pos_output = 0;
for (i = 0; i < info->th->N; i++) {
if ( (info->th->hit[i]->flags & p7_IS_REPORTED) || info->th->hit[i]->flags & p7_IS_INCLUDED) {
info->pli->n_output++;
info->pli->pos_output += abs(info->th->hit[i]->dcl[0].jali - info->th->hit[i]->dcl[0].iali) + 1;
}
}
p7_tophits_Targets(ofp, info->th, info->pli, textw); if (fprintf(ofp, "\n\n") < 0) ESL_EXCEPTION_SYS(eslEWRITE, "write failed");
p7_tophits_Domains(ofp, info->th, info->pli, textw); if (fprintf(ofp, "\n\n") < 0) ESL_EXCEPTION_SYS(eslEWRITE, "write failed");
if (tblfp) p7_tophits_TabularTargets(tblfp, qsq->name, qsq->acc, info->th, info->pli, (nquery == 1));
if (dfamtblfp) p7_tophits_TabularXfam(dfamtblfp, qsq->name, NULL, info->th, info->pli);
if (aliscoresfp) p7_tophits_AliScores(aliscoresfp, qsq->name, info->th );
esl_stopwatch_Stop(w);
info->pli->nseqs = 1;
p7_pli_Statistics(ofp, info->pli, w);
if (fprintf(ofp, "//\n") < 0) ESL_EXCEPTION_SYS(eslEWRITE, "write failed");
fflush(ofp);
p7_hmmfile_Close(hfp);
p7_pipeline_Destroy(info->pli);
p7_tophits_Destroy(info->th);
esl_sq_Reuse(qsq);
}
if (sstatus == eslEFORMAT) esl_fatal("Parse failed (sequence file %s):\n%s\n",
sqfp->filename, esl_sqfile_GetErrorBuf(sqfp));
else if (sstatus != eslEOF) esl_fatal("Unexpected error %d reading sequence file %s",
sstatus, sqfp->filename);
/* Terminate outputs - any last words?
*/
if (tblfp) p7_tophits_TabularTail(tblfp, "hmmscan", p7_SCAN_MODELS, cfg->seqfile, cfg->hmmfile, go);
if (ofp) { if (fprintf(ofp, "[ok]\n") < 0) ESL_EXCEPTION_SYS(eslEWRITE, "write failed"); }
/* Cleanup - prepare for successful exit
*/
for (i = 0; i < infocnt; ++i)
p7_bg_Destroy(info[i].bg);
#ifdef HMMER_THREADS
if (ncpus > 0)
{
esl_workqueue_Reset(queue);
while (esl_workqueue_Remove(queue, (void **) &block) == eslOK)
p7_oprofile_DestroyBlock(block);
esl_workqueue_Destroy(queue);
esl_threads_Destroy(threadObj);
}
#endif
free(info);
esl_sq_Destroy(qsq);
esl_stopwatch_Destroy(w);
esl_alphabet_Destroy(abc);
esl_sqfile_Close(sqfp);
if (ofp != stdout) fclose(ofp);
if (tblfp) fclose(tblfp);
if (dfamtblfp) fclose(dfamtblfp);
if (aliscoresfp) fclose(aliscoresfp);
return eslOK;
ERROR:
if (ofp != stdout) fclose(ofp);
if (tblfp) fclose(tblfp);
if (dfamtblfp) fclose(dfamtblfp);
if (aliscoresfp) fclose(aliscoresfp);
return status;
}
/* Function: main()
* Synopsis: break input sequence set into chunks, for each one building the
* Burrows-Wheeler transform and corresponding FM-index. Maintain requisite
* meta data.
* Notes: Currently depends on the divsufsort-lite code of Yuta Mori, though this
* could easily be replaced.
*/
int
main(int argc, char **argv)
{
char tmp_filename[16] = "fmtmpXXXXXX";
FILE *fptmp = NULL;
FILE *fp = NULL;
uint8_t *T = NULL;
uint8_t *BWT = NULL;
int *SA = NULL; //what I write will be 32-bit ints, but I need to keep this as int so it'll work with libdivsufsort
uint32_t *SAsamp = NULL;
uint32_t *occCnts_sb = NULL; // same indexing as above
uint32_t *cnts_sb = NULL;
uint16_t *occCnts_b = NULL; // this is logically a 2D array, but will be indexed as occ_cnts[alph_size*index + char] (instead of occ_cnts[index][char])
uint16_t *cnts_b = NULL;
FM_METADATA *meta = NULL;
clock_t t1, t2;
struct tms ts1, ts2;
long i,j,c;
int status = eslOK;
int chars_per_byte;
int num_freq_cnts_sb ;
int num_freq_cnts_b ;
int num_SA_samples ;
int infmt = eslSQFILE_UNKNOWN;
int alphatype = eslUNKNOWN;
int alphaguess =eslUNKNOWN;
ESL_ALPHABET *abc = NULL;
ESL_SQ *sq = NULL;
ESL_SQFILE *sqfp = NULL;
ESL_SQ *tmpsq = NULL;
ESL_SQ_BLOCK *block = NULL;
char *fname_in = NULL;
char *fname_out= NULL;
int block_size = 50000000;
int sq_cnt = 0;
int use_tmpsq = 0;
uint64_t block_length;
uint64_t total_char_count = 0;
int max_block_size;
int numblocks = 0;
uint32_t numseqs = 0;
int allocedseqs = 1000;
uint32_t seq_offset = 0;
uint32_t ambig_offset = 0;
uint32_t overlap = 0;
uint16_t seq_cnt;
uint16_t ambig_cnt;
uint32_t prev_numseqs = 0;
int compressed_bytes;
uint32_t term_loc;
ESL_GETOPTS *go = NULL; /* command line processing */
uint8_t ambig_repl = 0;
int in_ambig_run = 0;
FM_AMBIGLIST ambig_list;
ESL_ALLOC (meta, sizeof(FM_METADATA));
if (meta == NULL)
esl_fatal("unable to allocate memory to store FM meta data\n");
ESL_ALLOC (meta->ambig_list, sizeof(FM_AMBIGLIST));
if (meta->ambig_list == NULL)
esl_fatal("unable to allocate memory to store FM ambiguity data\n");
fm_initAmbiguityList(meta->ambig_list);
meta->alph_type = fm_DNA;
meta->freq_SA = 8;
meta->freq_cnt_b = 256;
meta->freq_cnt_sb = pow(2,16); //65536 - that's the # values in a short
meta->seq_count = 0;
ESL_ALLOC (meta->seq_data, allocedseqs * sizeof(FM_SEQDATA));
if (meta->seq_data == NULL )
esl_fatal("unable to allocate memory to store FM sequence data\n");
process_commandline(argc, argv, &go, &fname_in, &fname_out);
if (esl_opt_IsOn(go, "--bin_length")) meta->freq_cnt_b = esl_opt_GetInteger(go, "--bin_length");
if ( meta->freq_cnt_b < 32 || meta->freq_cnt_b >4096 || (meta->freq_cnt_b & (meta->freq_cnt_b - 1)) ) // test power of 2
esl_fatal("bin_length must be a power of 2, at least 128, and at most 4096\n");
if (esl_opt_IsOn(go, "--sa_freq")) meta->freq_SA = esl_opt_GetInteger(go, "--sa_freq");
if ( (meta->freq_SA & (meta->freq_SA - 1)) ) // test power of 2
esl_fatal ("SA_freq must be a power of 2\n");
if (esl_opt_IsOn(go, "--block_size")) block_size = 1000000 * esl_opt_GetInteger(go, "--block_size");
if ( block_size <=0 )
esl_fatal ("block_size must be a positive number\n");
//start timer
t1 = times(&ts1);
output_header(stdout, go, fname_in, fname_out);
if (esl_opt_GetString(go, "--informat") != NULL) {
infmt = esl_sqio_EncodeFormat(esl_opt_GetString(go, "--informat"));
if (infmt == eslSQFILE_UNKNOWN) esl_fatal("%s is not a valid input sequence file format for --informat");
}
status = esl_sqfile_Open(fname_in, infmt, NULL, &sqfp);
if (status == eslENOTFOUND) esl_fatal("No such file %s", fname_in);
else if (status == eslEFORMAT) esl_fatal("Format of seqfile %s unrecognized.", fname_in);
else if (status != eslOK) esl_fatal("Open failed, code %d.", status);
meta->fwd_only = 0;
if (esl_opt_IsUsed(go, "--alph")) {
meta->alph = esl_opt_GetString(go, "--alph") ;
if ( esl_strcmp(meta->alph, "dna")==0 || esl_strcmp(meta->alph, "rna")==0) {
meta->alph_type = fm_DNA;
alphatype = eslDNA;
} else if (esl_strcmp(meta->alph, "dna_full")==0 || esl_strcmp(meta->alph, "rna_full")==0) {
meta->alph_type = fm_DNA_full;
alphatype = eslDNA;
} else if (esl_strcmp(meta->alph, "amino")==0) {
meta->alph_type = fm_AMINO;
alphatype = eslAMINO;
meta->fwd_only = 1;
} else {
esl_fatal("Unknown alphabet type. Try 'dna', 'dna_full', or 'amino'\n%s", "");
}
} else {
esl_sqfile_GuessAlphabet(sqfp, &alphaguess);
if (alphaguess == eslDNA || alphaguess == eslRNA) {
meta->alph_type = fm_DNA;
alphatype = eslDNA;
} else if (alphaguess == eslAMINO) {
meta->alph_type = fm_AMINO;
alphatype = eslAMINO;
meta->fwd_only = 1;
} else {
esl_fatal("Unknown alphabet type. Try 'dna', 'dna_full', or 'amino'\n%s", "");
}
}
if (esl_opt_IsOn(go, "--fwd_only") )
meta->fwd_only = 1;
meta->alph = NULL;
//getInverseAlphabet
fm_alphabetCreate(meta, &(meta->charBits));
chars_per_byte = 8/meta->charBits;
//shift inv_alph up one, to make space for '$' at 0
for (i=0; i<256; i++)
if ( meta->inv_alph[i] >= 0)
meta->inv_alph[i]++;
abc = esl_alphabet_Create(alphatype);
sq = esl_sq_CreateDigital(abc);
tmpsq = esl_sq_CreateDigital(abc);
esl_sqfile_SetDigital(sqfp, abc);
block = esl_sq_CreateDigitalBlock(FM_BLOCK_COUNT, abc);
block->complete = FALSE;
// max_block_size = FM_BLOCK_OVERLAP+block_size+1 + block_size*.2; // +1 for the '$'
max_block_size = FM_BLOCK_OVERLAP+block_size+1 + block_size; // temporary hack to avoid memory over-runs (see end of 1101_fmindex_benchmarking/00NOTES)
if (alphatype == fm_DNA)
fm_initAmbiguityList(&ambig_list);
/* Allocate BWT, Text, SA, and FM-index data structures, allowing storage of maximally large sequence*/
ESL_ALLOC (T, max_block_size * sizeof(uint8_t));
ESL_ALLOC (BWT, max_block_size * sizeof(uint8_t));
ESL_ALLOC (SA, max_block_size * sizeof(int));
ESL_ALLOC (SAsamp, (1+floor((double)max_block_size/meta->freq_SA) ) * sizeof(uint32_t));
ESL_ALLOC (occCnts_sb, (1+ceil((double)max_block_size/meta->freq_cnt_sb)) * meta->alph_size * sizeof(uint32_t)); // every freq_cnt_sb positions, store an array of ints
ESL_ALLOC (cnts_sb, meta->alph_size * sizeof(uint32_t));
ESL_ALLOC (occCnts_b, ( 1+ceil((double)max_block_size/meta->freq_cnt_b)) * meta->alph_size * sizeof(uint16_t)); // every freq_cnt_b positions, store an array of 8-byte ints
ESL_ALLOC (cnts_b, meta->alph_size * sizeof(uint16_t));
if((T == NULL) || (BWT == NULL) || (SA==NULL) || (SAsamp==NULL) || (BWT==NULL) || (cnts_b==NULL) || (occCnts_b==NULL) || (cnts_sb==NULL) || (occCnts_sb==NULL) ) {
esl_fatal( "%s: Cannot allocate memory.\n", argv[0]);
}
// Open a temporary file, to which FM-index data will be written
if (esl_tmpfile(tmp_filename, &fptmp) != eslOK) esl_fatal("unable to open fm-index tmpfile");
/* Main loop: */
while (status == eslOK ) {
//reset block as an empty vessel
for (i=0; i<block->count; i++)
esl_sq_Reuse(block->list + i);
if (use_tmpsq) {
esl_sq_Copy(tmpsq , block->list);
block->complete = FALSE; //this lets ReadBlock know that it needs to append to a small bit of previously-read seqeunce
block->list->C = FM_BLOCK_OVERLAP; // overload the ->C value, which ReadBlock uses to determine how much
// overlap should be retained in the ReadWindow step
} else {
block->complete = TRUE;
}
status = esl_sqio_ReadBlock(sqfp, block, block_size, -1, alphatype != eslAMINO);
if (status == eslEOF) continue;
if (status != eslOK) ESL_XEXCEPTION(status, "failure reading sequence block");
seq_offset = numseqs;
ambig_offset = meta->ambig_list->count;
if (block->complete || block->count == 0) {
use_tmpsq = FALSE;
} else {
/* The final sequence on the block was a probably-incomplete window of the active sequence.
* Grab a copy of the end for use in the next pass, to ensure we don't miss hits crossing
* the boundary between two blocks.
*/
esl_sq_Copy(block->list + (block->count - 1) , tmpsq);
use_tmpsq = TRUE;
}
block->first_seqidx = sq_cnt;
sq_cnt += block->count - (use_tmpsq ? 1 : 0);// if there's an incomplete sequence read into the block wait to count it until it's complete.
/* Read dseqs from block into text element T.
* Convert the dsq from esl-alphabet to fm-alphabet (1..k for alphabet of size k).
* (a) collapsing upper/lower case for appropriate sorting.
* (b) reserving 0 for '$', which must be lexicographically smallest
* (these will later be shifted to 0-based alphabet, once SA has been built)
*
*/
block_length = 0;
for (i=0; i<block->count; i++) {
//start a new block, with space for the name
allocateSeqdata(meta, block->list+i, numseqs, &allocedseqs);
//meta data
meta->seq_data[numseqs].target_id = block->first_seqidx + i ;
meta->seq_data[numseqs].target_start = block->list[i].start;
meta->seq_data[numseqs].fm_start = block_length;
if (block->list[i].name == NULL) meta->seq_data[numseqs].name[0] = '\0';
else strcpy(meta->seq_data[numseqs].name, block->list[i].name );
if (block->list[i].acc == NULL) meta->seq_data[numseqs].acc[0] = '\0';
else strcpy(meta->seq_data[numseqs].acc, block->list[i].acc );
if (block->list[i].source == NULL) meta->seq_data[numseqs].source[0] = '\0';
else strcpy(meta->seq_data[numseqs].source, block->list[i].source );
if (block->list[i].desc == NULL) meta->seq_data[numseqs].desc[0] = '\0';
else strcpy(meta->seq_data[numseqs].desc, block->list[i].desc );
for (j=1; j<=block->list[i].n; j++) {
c = abc->sym[block->list[i].dsq[j]];
if ( meta->alph_type == fm_DNA) {
if (meta->inv_alph[c] == -1) {
// replace ambiguity characters by rotating through A,C,G, and T.
c = meta->alph[ambig_repl];
ambig_repl = (ambig_repl+1)%4;
if (!in_ambig_run) {
fm_addAmbiguityRange(meta->ambig_list, block_length, block_length);
in_ambig_run=1;
} else {
meta->ambig_list->ranges[meta->ambig_list->count - 1].upper = block_length;
}
} else {
in_ambig_run=0;
}
} else if (meta->inv_alph[c] == -1) {
esl_fatal("requested alphabet doesn't match input text\n");
}
T[block_length] = meta->inv_alph[c];
block_length++;
if (j>block->list[i].C) total_char_count++; // add to total count, only if it's not redundant with earlier read
meta->seq_data[numseqs].length++;
}
numseqs++;
}
T[block_length] = 0; // last character 0 is effectively '$' for suffix array
block_length++;
seq_cnt = numseqs-seq_offset;
ambig_cnt = meta->ambig_list->count - ambig_offset;
//build and write FM-index for T. This will be a BWT on the reverse of the sequence, required for reverse-traversal of the BWT
buildAndWriteFMIndex(meta, seq_offset, ambig_offset, seq_cnt, ambig_cnt, (uint32_t)block->list[0].C, T, BWT, SA, SAsamp,
occCnts_sb, cnts_sb, occCnts_b, cnts_b, block_length, fptmp);
if ( ! meta->fwd_only ) {
//build and write FM-index for un-reversed T (used to find reverse hits using forward traversal of the BWT
buildAndWriteFMIndex(meta, seq_offset, ambig_offset, seq_cnt, ambig_cnt, 0, T, BWT, SA, NULL,
occCnts_sb, cnts_sb, occCnts_b, cnts_b, block_length, fptmp);
}
prev_numseqs = numseqs;
numblocks++;
}
esl_sqfile_Close(sqfp);
esl_alphabet_Destroy(abc);
esl_sq_Destroy(sq);
esl_sq_Destroy(tmpsq);
esl_sq_DestroyBlock(block);
meta->seq_count = numseqs;
meta->block_count = numblocks;
/* Finished writing the FM-index data to a temporary file. Now write
* metadata to fname_out, than append FM-index data from temp file
*/
if((fp = fopen(fname_out, "wb")) == NULL)
esl_fatal( "%s: Cannot open file `%s': ", argv[0], fname_out);
//write out meta data
if( fwrite(&(meta->fwd_only), sizeof(meta->fwd_only), 1, fp) != 1 ||
fwrite(&(meta->alph_type), sizeof(meta->alph_type), 1, fp) != 1 ||
fwrite(&(meta->alph_size), sizeof(meta->alph_size), 1, fp) != 1 ||
fwrite(&(meta->charBits), sizeof(meta->charBits), 1, fp) != 1 ||
fwrite(&(meta->freq_SA), sizeof(meta->freq_SA), 1, fp) != 1 ||
fwrite(&(meta->freq_cnt_sb), sizeof(meta->freq_cnt_sb), 1, fp) != 1 ||
fwrite(&(meta->freq_cnt_b), sizeof(meta->freq_cnt_b), 1, fp) != 1 ||
fwrite(&(meta->block_count), sizeof(meta->block_count), 1, fp) != 1 ||
fwrite(&(meta->seq_count), sizeof(meta->seq_count), 1, fp) != 1 ||
fwrite(&(meta->ambig_list->count), sizeof(meta->ambig_list->count), 1, fp) != 1 ||
fwrite(&total_char_count, sizeof(total_char_count), 1, fp) != 1
)
esl_fatal( "%s: Error writing meta data for FM index.\n", argv[0]);
for (i=0; i<meta->seq_count; i++) {
if( fwrite(&(meta->seq_data[i].target_id), sizeof(meta->seq_data[i].target_id), 1, fp) != 1 ||
fwrite(&(meta->seq_data[i].target_start), sizeof(meta->seq_data[i].target_start), 1, fp) != 1 ||
fwrite(&(meta->seq_data[i].fm_start), sizeof(meta->seq_data[i].fm_start), 1, fp) != 1 ||
fwrite(&(meta->seq_data[i].length), sizeof(meta->seq_data[i].length), 1, fp) != 1 ||
fwrite(&(meta->seq_data[i].name_length), sizeof(meta->seq_data[i].name_length), 1, fp) != 1 ||
fwrite(&(meta->seq_data[i].acc_length), sizeof(meta->seq_data[i].acc_length), 1, fp) != 1 ||
fwrite(&(meta->seq_data[i].source_length),sizeof(meta->seq_data[i].source_length), 1, fp) != 1 ||
fwrite(&(meta->seq_data[i].desc_length), sizeof(meta->seq_data[i].desc_length), 1, fp) != 1 ||
fwrite(meta->seq_data[i].name, sizeof(char), meta->seq_data[i].name_length+1 , fp) != meta->seq_data[i].name_length+1 ||
fwrite(meta->seq_data[i].acc, sizeof(char), meta->seq_data[i].acc_length+1 , fp) != meta->seq_data[i].acc_length+1 ||
fwrite(meta->seq_data[i].source, sizeof(char), meta->seq_data[i].source_length+1, fp) != meta->seq_data[i].source_length+1 ||
fwrite(meta->seq_data[i].desc, sizeof(char), meta->seq_data[i].desc_length+1 , fp) != meta->seq_data[i].desc_length+1
)
esl_fatal( "%s: Error writing meta data for FM index.\n", argv[0]);
}
for (i=0; i<meta->ambig_list->count; i++) {
if( fwrite(&(meta->ambig_list->ranges[i].lower), sizeof(meta->ambig_list->ranges[i].lower), 1, fp) != 1 ||
fwrite(&(meta->ambig_list->ranges[i].upper), sizeof(meta->ambig_list->ranges[i].upper), 1, fp) != 1
)
esl_fatal( "%s: Error writing ambiguity data for FM index.\n", argv[0]);
}
/* now append the FM-index data in fptmp to the desired output file, fp */
rewind(fptmp);
for (i=0; i<numblocks; i++) {
for(j=0; j< (meta->fwd_only?1:2); j++ ) { //do this once or twice, once for forward-T index, and possibly once for reversed
//first, read
if(fread(&block_length, sizeof(block_length), 1, fptmp) != 1)
esl_fatal( "%s: Error reading block_length in FM index.\n", argv[0]);
if(fread(&term_loc, sizeof(term_loc), 1, fptmp) != 1)
esl_fatal( "%s: Error reading terminal location in FM index.\n", argv[0]);
if(fread(&seq_offset, sizeof(seq_offset), 1, fptmp) != 1)
esl_fatal( "%s: Error reading seq_offset in FM index.\n", argv[0]);
if(fread(&ambig_offset, sizeof(ambig_offset ), 1, fptmp) != 1)
esl_fatal( "%s: Error reading ambig_offset in FM index.\n", argv[0]);
if(fread(&overlap, sizeof(overlap), 1, fptmp) != 1)
esl_fatal( "%s: Error reading overlap in FM index.\n", argv[0]);
if(fread(&seq_cnt, sizeof(seq_cnt), 1, fptmp) != 1)
esl_fatal( "%s: Error reading seq_cnt in FM index.\n", argv[0]);
if(fread(&ambig_cnt, sizeof(ambig_cnt), 1, fptmp) != 1)
esl_fatal( "%s: Error reading ambig_cnt in FM index.\n", argv[0]);
compressed_bytes = ((chars_per_byte-1+block_length)/chars_per_byte);
num_freq_cnts_b = 1+ceil((double)block_length/meta->freq_cnt_b);
num_freq_cnts_sb = 1+ceil((double)block_length/meta->freq_cnt_sb);
num_SA_samples = 1+floor((double)block_length/meta->freq_SA);
//j==0 test cause T and SA to be written only for forward sequence
if(j==0 && fread(T, sizeof(uint8_t), compressed_bytes, fptmp) != compressed_bytes)
esl_fatal( "%s: Error reading T in FM index.\n", argv[0]);
if(fread(BWT, sizeof(uint8_t), compressed_bytes, fptmp) != compressed_bytes)
esl_fatal( "%s: Error reading BWT in FM index.\n", argv[0]);
if(j==0 && fread(SAsamp, sizeof(uint32_t), (size_t)num_SA_samples, fptmp) != (size_t)num_SA_samples)
esl_fatal( "%s: Error reading SA in FM index.\n", argv[0]);
if(fread(occCnts_b, sizeof(uint16_t)*(meta->alph_size), (size_t)num_freq_cnts_b, fptmp) != (size_t)num_freq_cnts_b)
esl_fatal( "%s: Error reading occCnts_b in FM index.\n", argv[0]);
if(fread(occCnts_sb, sizeof(uint32_t)*(meta->alph_size), (size_t)num_freq_cnts_sb, fptmp) != (size_t)num_freq_cnts_sb)
esl_fatal( "%s: Error reading occCnts_sb in FM index.\n", argv[0]);
//then, write
if(fwrite(&block_length, sizeof(block_length), 1, fp) != 1)
esl_fatal( "%s: Error writing block_length in FM index.\n", argv[0]);
if(fwrite(&term_loc, sizeof(term_loc), 1, fp) != 1)
esl_fatal( "%s: Error writing terminal location in FM index.\n", argv[0]);
if(fwrite(&seq_offset, sizeof(seq_offset), 1, fp) != 1)
esl_fatal( "%s: Error writing seq_offset in FM index.\n", argv[0]);
if(fwrite(&ambig_offset, sizeof(ambig_offset), 1, fp) != 1)
esl_fatal( "%s: Error writing ambig_offset in FM index.\n", argv[0]);
if(fwrite(&overlap, sizeof(overlap), 1, fp) != 1)
esl_fatal( "%s: Error writing overlap in FM index.\n", argv[0]);
if(fwrite(&seq_cnt, sizeof(seq_cnt), 1, fp) != 1)
esl_fatal( "%s: Error writing seq_cnt in FM index.\n", argv[0]);
if(fwrite(&ambig_cnt, sizeof(ambig_cnt), 1, fp) != 1)
esl_fatal( "%s: Error writing ambig_cnt in FM index.\n", argv[0]);
if(j==0 && fwrite(T, sizeof(uint8_t), compressed_bytes, fp) != compressed_bytes)
esl_fatal( "%s: Error writing T in FM index.\n", argv[0]);
if(fwrite(BWT, sizeof(uint8_t), compressed_bytes, fp) != compressed_bytes)
esl_fatal( "%s: Error writing BWT in FM index.\n", argv[0]);
if(j==0 && fwrite(SAsamp, sizeof(uint32_t), (size_t)num_SA_samples, fp) != (size_t)num_SA_samples)
esl_fatal( "%s: Error writing SA in FM index.\n", argv[0]);
if(fwrite(occCnts_b, sizeof(uint16_t)*(meta->alph_size), (size_t)num_freq_cnts_b, fp) != (size_t)num_freq_cnts_b)
esl_fatal( "%s: Error writing occCnts_b in FM index.\n", argv[0]);
if(fwrite(occCnts_sb, sizeof(uint32_t)*(meta->alph_size), (size_t)num_freq_cnts_sb, fp) != (size_t)num_freq_cnts_sb)
esl_fatal( "%s: Error writing occCnts_sb in FM index.\n", argv[0]);
}
}
fprintf (stderr, "Number of characters in index: %ld\n", (long)total_char_count);
fprintf (stderr, "Number of FM-index blocks: %ld\n", (long)meta->block_count);
fclose(fp);
fclose(fptmp);
free(T);
free(BWT);
free(SA);
free(SAsamp);
free(occCnts_b);
free(cnts_b);
free(occCnts_sb);
free(cnts_sb);
fm_metaDestroy(meta);
esl_getopts_Destroy(go);
// compute and print the elapsed time in millisec
t2 = times(&ts2);
{
double clk_ticks = sysconf(_SC_CLK_TCK);
double elapsedTime = (t2-t1)/clk_ticks;
fprintf (stderr, "run time: %.2f seconds\n", elapsedTime);
}
return (eslOK);
ERROR:
/* Deallocate memory. */
if (fp) fclose(fp);
if (T) free(T);
if (BWT) free(BWT);
if (SA) free(SA);
if (SAsamp) free(SAsamp);
if (occCnts_b) free(occCnts_b);
if (cnts_b) free(cnts_b);
if (occCnts_sb) free(occCnts_sb);
if (cnts_sb) free(cnts_sb);
if (ambig_list.ranges) free(ambig_list.ranges);
fm_metaDestroy(meta);
esl_getopts_Destroy(go);
esl_sqfile_Close(sqfp);
esl_alphabet_Destroy(abc);
esl_sq_Destroy(sq);
if (tmpsq) esl_sq_Destroy(tmpsq);
if (block) esl_sq_DestroyBlock(block);
fprintf (stderr, "failure during memory allocation\n");
exit(status);
}
