void split_args(char *s)
{
int i = 0;
char *cp = cmd_buf;
if(strlen(s) > MAXCMD)
err_fatal("Command too long");
cmd[i] = cp;
while(*s){
if(*s == ' '){
*cp++ = '\0';
if(i == MAXARG)
err_fatal("Command has too many arguments");
i++;
cmd[i] = cp;
} else
*cp++ = *s;
s++;
}
*cp = '\0';
cmd[i+1] = NULL;
}
int TBconnect(char *tname, char *host, int port,
TBcallbackTerm fun, term *(*check_in_sign)(term *), int *tid)
{
int to_tb, from_tb;
int old_port;
term *tool_in_sign, *trm;
/* Fool mkports into assuming a different WellKnown port */
old_port = WellKnownSocketPort;
WellKnownSocketPort = port;
if(mkports(TBfalse, tname, host, tid, &from_tb, &to_tb) == TB_ERROR)
err_fatal("TBconnect -- can't connect to ToolBus");
/* Restore the old WellKnown port */
WellKnownSocketPort = old_port;
TBaddTermPort(from_tb, fun);
trm = TBread(from_tb); /* obtain the tool signature from the ToolBus */
if(TBmatch(trm, "rec-do(signature(%t,%t))", &tool_in_sign, &tool_out_sign)){
TBwrite(to_tb, Snd_Void);
if(check_in_sign){
trm = (*check_in_sign)(tool_in_sign);
if(trm)
err_fatal("TBconnect -- NOT IN INPUT SIGNATURE: %t", trm);
}
} else
err_fatal("signature information garbled: %t", trm);
return to_tb;
}
int TB_handle_one(int cid)
{
term *trm, *result;
TBbool sndvoid = TBfalse;
assert_valid_cid(cid);
trm = TB_receive(cid);
if(!trm) {
err_fatal("contact with ToolBus lost.\n");
}
if(streq(get_txt(fun_sym(trm)), "rec-do")) {
sndvoid = TBtrue;
}
result = connections[cid]->handler(cid, trm);
if(result) {
return TB_send(cid, result);
}
else if(sndvoid) {
return TB_send(cid, TBmake("snd-void()"));
}
err_fatal("Unhandled case in TB_handle_one!\n");
return -1;
}
gzFile err_xzopen_core(const char *func, const char *fn, const char *mode)
{
gzFile fp;
if (strcmp(fn, "-") == 0) {
fp = gzdopen(fileno((strstr(mode, "r"))? stdin : stdout), mode);
/* According to zlib.h, this is the only reason gzdopen can fail */
if (!fp) err_fatal(func, "Out of memory");
return fp;
}
if ((fp = gzopen(fn, mode)) == 0) {
err_fatal(func, "fail to open file '%s' : %s", fn, errno ? strerror(errno) : "Out of memory");
}
return fp;
}
bwa_seq_t *load_reads(const char *fa_fn, uint32_t *n_seqs) {
bwa_seq_t *seqs, *part_seqs;
bwa_seqio_t *ks;
int n_part_seqs = 0, n_seqs_full = 0, n_seqs_loaded = 0;
clock_t t = clock();
ks = bwa_open_reads(BWA_MODE, fa_fn);
n_seqs_full = N_CHUNK_SEQS;
show_msg(__func__, "Loading reads from library %s...\n", fa_fn);
seqs = (bwa_seq_t*) calloc (N_DF_MAX_SEQS, sizeof(bwa_seq_t));
while ((part_seqs = bwa_read_seq(ks, N_CHUNK_SEQS, &n_part_seqs, BWA_MODE, 0))
!= 0) {
show_msg(__func__, "%d sequences loaded: %.2f sec... \n",
n_seqs_loaded + n_part_seqs, fa_fn, (float) (clock() - t) / CLOCKS_PER_SEC);
pe_reverse_seqs(part_seqs, n_part_seqs);
if ((n_seqs_loaded + n_part_seqs) > n_seqs_full) {
n_seqs_full += n_part_seqs + 2;
kroundup32(n_seqs_full);
seqs = (bwa_seq_t*) realloc(seqs, sizeof(bwa_seq_t) * n_seqs_full);
}
memmove(&seqs[n_seqs_loaded], part_seqs, sizeof(bwa_seq_t) * n_part_seqs);
free(part_seqs);
n_seqs_loaded += n_part_seqs;
}
bwa_seq_close(ks);
if (n_seqs_loaded < 1) {
err_fatal(__func__,
"No sequence in file %s, make sure the format is correct! \n",
fa_fn);
}
*n_seqs = n_seqs_loaded;
return seqs;
}
void *
mem_alloc (int length)
{
register void *ptr;
if (mem->next + length > mem->lim)
{
register struct block *block;
register long new_size;
mem->size *= 2;
new_size = length + sizeof (struct block *);
new_size += mem->size - (new_size % mem->size);
block = malloc (new_size);
if (!block)
err_fatal ("memory exhausted");
block->prev = mem->block;
mem->block = block;
mem->next = block->contents;
mem->lim = (char *) block + new_size;
}
ptr = mem->next;
mem->next = (char *)ALIGN (mem->next + length);
return ptr;
}
FILE *err_xreopen_core(const char *func, const char *fn, const char *mode, FILE *fp)
{
if (freopen(fn, mode, fp) == 0) {
err_fatal(func, "fail to open file '%s' : %s", fn, strerror(errno));
}
return fp;
}
int TB_connect(int cid)
{
int r, dummy;
term *trm, *in_sign, *out_sign;
assert_valid_cid(cid);
WellKnownSocketPort = connections[cid]->port;
r = mkports(TBfalse, connections[cid]->tool_name, connections[cid]->host,
&connections[cid]->tid, &connections[cid]->socket, &dummy);
if(r == TB_ERROR) {
if(connections[cid]->verbose)
TBmsg("TB_connect: failed to connect to ToolBus port %d\n",
connections[cid]->port);
return -1;
}
if(connections[cid]->verbose)
TBmsg("TB_connect: connected to ToolBus port %d, tid = %d\n",
connections[cid]->port, connections[cid]->tid);
trm = TBread(connections[cid]->socket); /* obtain the tool signature from the ToolBus */
if(TBmatch(trm, "rec-do(signature(%t,%t))", &in_sign, &out_sign)){
TBwrite(connections[cid]->socket, TBmake("snd-void()"));
if(connections[cid]->sigchecker){
trm = (*connections[cid]->sigchecker)(cid, in_sign);
if(trm)
err_warn("TBconnect -- NOT IN INPUT SIGNATURE: %t", trm);
}
} else
err_fatal("signature information garbled: %t", trm);
return 0;
}
int
main (int argc, char** argv)
{
bool pass = false;
list *cache = NULL;
SANE_Status status = SANE_STATUS_GOOD;
/* Log at least broken promises and unmet requirements.
*/
setenv ("SANE_DEBUG_EPKOWA", "FATAL", false);
msg_init ();
cache = (list *) model_info_cache_init (getenv ("srcdir"), &status);
if (!cache)
{
err_fatal ("cannot initialise model info cache (%s)",
sane_strstatus (status));
return EXIT_FAILURE;
}
while (--argc && ++argv)
{
const void *info = model_info_cache_get_info (*argv, &status);
if (!info)
{
err_major ("cannot get info for '%s' (%s)", *argv,
sane_strstatus (status));
}
}
pass = check_cache_content (cache);
cache = model_info_cache_exit (cache);
return (pass ? EXIT_SUCCESS : EXIT_FAILURE);
}
int bns_coor_pac2real(const bntseq_t *bns, int64_t pac_coor, int len, int32_t *real_seq)
{
int left, mid, right, nn;
if (pac_coor >= bns->l_pac)
err_fatal("bns_coor_pac2real", "bug! Coordinate is longer than sequence (%lld>=%lld).", pac_coor, bns->l_pac);
// binary search for the sequence ID. Note that this is a bit different from the following one...
left = 0; mid = 0; right = bns->n_seqs;
while (left < right) {
mid = (left + right) >> 1;
if (pac_coor >= bns->anns[mid].offset) {
if (mid == bns->n_seqs - 1) break;
if (pac_coor < bns->anns[mid+1].offset) break;
left = mid + 1;
} else right = mid;
}
*real_seq = mid;
// binary search for holes
left = 0; right = bns->n_holes; nn = 0;
while (left < right) {
int64_t mid = (left + right) >> 1;
if (pac_coor >= bns->ambs[mid].offset + bns->ambs[mid].len) left = mid + 1;
else if (pac_coor + len <= bns->ambs[mid].offset) right = mid;
else { // overlap
if (pac_coor >= bns->ambs[mid].offset) {
nn += bns->ambs[mid].offset + bns->ambs[mid].len < pac_coor + len?
bns->ambs[mid].offset + bns->ambs[mid].len - pac_coor : len;
} else {
nn += bns->ambs[mid].offset + bns->ambs[mid].len < pac_coor + len?
bns->ambs[mid].len : len - (bns->ambs[mid].offset - pac_coor);
}
break;
}
}
return nn;
}
void src_create( void )
{
if (Lines)
err_fatal( __func__, "Source manager already created\n" );
Lines = xmalloc( (Count = INCREMENT) * sizeof( char * ) );
StringHeap = mem_create_strings();
InfoHeap = mem_create_objects( sizeof( struct source ) );
}
FILE *err_xopen_core(const char *func, const char *fn, const char *mode)
{
FILE *fp = 0;
if (strcmp(fn, "-") == 0)
return (strstr(mode, "r"))? stdin : stdout;
if ((fp = fopen(fn, mode)) == 0) {
err_fatal(func, "fail to open file '%s' : %s", fn, strerror(errno));
}
return fp;
}
void str_pool_destroy( str_Pool pool )
{
poolInfo p = (poolInfo)pool;
if (!p || !p->string || !p->hash)
err_fatal( __FUNCTION__, "String pool improperly initialized\n" );
mem_destroy_strings( p->string );
hsh_destroy( p->hash );
xfree( p ); /* terminal */
}
void prs_file_nocpp( const char *filename )
{
if (!filename)
err_fatal( "%s No filename specified\n", __func__ );
if (!(yyin = fopen( filename, "r" )))
err_fatal_errno( "%s Cannot open \"%s\" for read\n", __func__, filename );
src_new_file( filename );
yydebug = _prs_debug_flag;
yyparse();
fclose( yyin );
}
int net_open_tcp (
const char *address,
const char *service,
int queueLength)
{
struct servent *serviceEntry;
struct protoent *protocolEntry;
struct sockaddr_in ssin;
int s;
const int one = 1;
memset( &ssin, 0, sizeof(ssin) );
ssin.sin_family = AF_INET;
ssin.sin_addr.s_addr = address ? inet_addr(address) : htonl(INADDR_ANY);
if ((serviceEntry = getservbyname(service, "tcp"))) {
ssin.sin_port = serviceEntry->s_port;
} else if (!(ssin.sin_port = htons(atoi(service))))
err_fatal( __func__, "Can't get \"%s\" service entry\n", service );
if (!(protocolEntry = getprotobyname("tcp")))
err_fatal( __func__, "Can't get \"tcp\" protocol entry\n" );
if ((s = socket(PF_INET, SOCK_STREAM, protocolEntry->p_proto)) < 0)
err_fatal_errno( __func__, "Can't open socket on port %d\n",
ntohs(ssin.sin_port) );
setsockopt( s, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one) );
if (bind(s, (struct sockaddr *)&ssin, sizeof(ssin)) < 0)
err_fatal_errno( __func__, "Can't bind %s/tcp to port %d\n",
service, ntohs(ssin.sin_port) );
if (listen( s, queueLength ) < 0)
err_fatal_errno( __func__, "Can't listen to %s/tcp on port %d\n",
service, ntohs(ssin.sin_port) );
return s;
}
void
mem_init (void)
{
register struct block *block;
size_t page_size;
page_size = getpagesize ();
mem = malloc (page_size);
if (!mem)
err_fatal ("memory exhausted");
block = mem->block = (struct block *)
((char *)mem + ALIGN (sizeof (struct mem)));
mem->next = block->contents;
mem->lim = (char *) mem + page_size;
mem->size = page_size;
block->prev = NULL;
}
void dict_data_close( dictData *header )
{
int i;
if (!header)
return;
if (header->fd >= 0) {
if (mmap_mode){
#ifdef HAVE_MMAP
munmap( (void *)header->start, header->size );
close( header->fd );
header->fd = 0;
header->start = header->end = NULL;
#else
err_fatal (__func__, "This should not happen");
#endif
}else{
if (header -> start)
xfree ((char *) header -> start);
}
}
if (header->chunks) xfree( header->chunks );
if (header->offsets) xfree( header->offsets );
if (header->initialized) {
if (inflateEnd( &header->zStream ))
err_internal( __func__,
"Cannot shut down inflation engine: %s\n",
header->zStream.msg );
}
for (i = 0; i < DICT_CACHE_SIZE; ++i){
if (header -> cache [i].inBuffer)
xfree (header -> cache [i].inBuffer);
}
memset( header, 0, sizeof( struct dictData ) );
xfree( header );
}
int TBaddCharPort(int in, TBcallbackChar fun)
{
int i;
/* First, try to reuse a freed inport */
for(i=0; i<ninports; i++) {
if(inportset[i].in == -1) {
/* Reuse this inport */
inportset[i].in = in;
inportset[i].term_port = TBfalse;
inportset[i].callbackChar = fun;
return TB_OK;
}
}
if(ninports == TB_MAX_INPORT)
err_fatal("TBaddCharPort -- too many inports");
inportset[ninports].in = in;
inportset[ninports].term_port = TBfalse;
inportset[ninports].callbackChar = fun;
ninports++;
return TB_OK;
}
int dict_data_filter( char *buffer, int *len, int maxLength,
const char *filter )
{
char *outBuffer;
int outLen;
if (!filter) return 0;
outBuffer = xmalloc( maxLength + 2 );
outLen = pr_filter( filter, buffer, *len, outBuffer, maxLength + 1 );
if (outLen > maxLength )
err_fatal( __func__,
"Filter grew buffer from %d past limit of %d\n",
*len, maxLength );
memcpy( buffer, outBuffer, outLen );
xfree( outBuffer );
PRINTF(DBG_UNZIP|DBG_ZIP,("Length was %d, now is %d\n",*len,outLen));
*len = outLen;
return 0;
}
int TBaddTermPort(int in, TBcallbackTerm fun)
{
int i;
/* TBmsg("TBaddTermPort(%d,%d), ninports=%d\n", in, fun, ninports); */
/* First, try to reuse a freed inport */
for(i=0; i<ninports; i++) {
if(inportset[i].in == -1) {
/* Reuse this inport */
inportset[i].in = in;
inportset[i].term_port = TBtrue;
inportset[i].suspended = TBfalse;
inportset[i].callbackTerm = fun;
return TB_OK;
}
}
if(ninports == TB_MAX_INPORT)
err_fatal("TBaddTermPort -- too many inports");
inportset[ninports].in = in;
inportset[ninports].term_port = TBtrue;
inportset[ninports].callbackTerm = fun;
ninports++;
return TB_OK;
}
term *handle_input_from_toolbus(term *e)
{
char *txt, *cmd_txt, output[MAXOUTPUT], *outp;
int n, len, r, status;
FILE *from_cmd;
term *arg;
outp = output;
if(TBmatch(e, "rec-terminate(%t)", &arg)){
unlink(tmp_in);
unlink(tmp_out);
exit(0);
} else if(TBmatch(e, "rec-eval(cmd(%s,input(%s)))", &cmd_txt, &txt)){
split_args(cmd_txt);
the_cmd = cmd;
len = strlen(txt);
goto exec_cmd;
} else if(TBmatch(e, "rec-eval(input(%s))", &txt)){
the_cmd = def_cmd;
len = strlen(txt);
goto exec_cmd;
} else if(TBmatch(e, "rec-eval(input-term(%t))", &arg)) {
the_cmd = def_cmd;
txt = TBsprintf("%t", arg);
len = strlen(txt);
goto exec_cmd;
} else if(TBmatch(e, "rec-eval(cmd(%s,input-term(%t)))", &cmd_txt, &arg)){
split_args(cmd_txt);
the_cmd = cmd;
txt = TBsprintf("%t", arg);
len = strlen(txt);
goto exec_cmd;
} else if(TBmatch(e, "rec-eval(input(%b))", &txt, &len)){
the_cmd = def_cmd;
exec_cmd:
if(addnewline)
txt[len++] = '\n';
exec_cmd(txt, len);
while ((r = wait(&status)) != cmd_pid && r != -1)
fprintf(stderr, "wait = %d\n", r);
if((from_cmd = fopen(tmp_out, "rb")) == NULL)
err_sys_fatal("Can't open tmp output file");
/* Mon May 3 17:36:12 MET DST 1999 mdejonge
*
* When output type != tb_term, we read the output of the command that
* we executed (stored in the file tmp_out) as string. When output type
* equals tb_term, we use TBreadTerm to read (and parse) the contents of
* that file to obtain an term.
*
* NOTE: With the new aterm library we would probably have used the function
* ATparse to obtain an aterm from a string.
*
*/
if( output_type != tb_term )
{
while((n=fread(outp, 1, 512, from_cmd)) > 0){
if(outp + n > &output[MAXOUTPUT])
err_fatal("Executed command produces too long output");
outp += n;
}
if(*(outp-1) == '\n' && !keepnewline) {
if(output_type == tb_bstring)
outp--;
else
*(outp-1) = '\0';
} else {
if(output_type != tb_bstring)
*outp++ = '\0';
}
fclose(from_cmd);
switch( output_type )
{
case tb_bstring:
return TBmake(TBfalse, "snd-value(output(%b))", output, outp-output);
case tb_string:
return TBmake(TBfalse, "snd-value(output(%s))", output);
case tb_term:
return NULL;
}
}
else
{
/* Mon May 3 17:36:12 MET DST 1999 mdejonge
*
* Construct a term from the contents of the file tmp_out by using
* the function TBreadTerm.
*/
term *t;
t = TBreadTerm( from_cmd );
fclose(from_cmd );
return TBmake(TBfalse, "snd-value(output(%t))", t );
}
}
TBmsg("Ignore: %t\n", e);
return NULL;
}
dictData *dict_data_open( const char *filename, int computeCRC )
{
dictData *h = NULL;
struct stat sb;
int j;
if (!filename)
return NULL;
h = xmalloc( sizeof( struct dictData ) );
memset( h, 0, sizeof( struct dictData ) );
h->initialized = 0;
if (stat( filename, &sb ) || !S_ISREG(sb.st_mode)) {
err_warning( __func__,
"%s is not a regular file -- ignoring\n", filename );
return h;
}
if (dict_read_header( filename, h, computeCRC )) {
err_fatal( __func__,
"\"%s\" not in text or dzip format\n", filename );
}
if ((h->fd = open( filename, O_RDONLY )) < 0)
err_fatal_errno( __func__,
"Cannot open data file \"%s\"\n", filename );
if (fstat( h->fd, &sb ))
err_fatal_errno( __func__,
"Cannot stat data file \"%s\"\n", filename );
h->size = sb.st_size;
if (mmap_mode){
#ifdef HAVE_MMAP
h->start = mmap( NULL, h->size, PROT_READ, MAP_SHARED, h->fd, 0 );
if ((void *)h->start == (void *)(-1))
err_fatal_errno(
__func__,
"Cannot mmap data file \"%s\"\n", filename );
#else
err_fatal (__func__, "This should not happen");
#endif
}else{
h->start = xmalloc (h->size);
if (-1 == read (h->fd, (char *) h->start, h->size))
err_fatal_errno (
__func__,
"Cannot read data file \"%s\"\n", filename );
close (h -> fd);
h -> fd = 0;
}
h->end = h->start + h->size;
for (j = 0; j < DICT_CACHE_SIZE; j++) {
h->cache[j].chunk = -1;
h->cache[j].stamp = -1;
h->cache[j].inBuffer = NULL;
h->cache[j].count = 0;
}
return h;
}
char *dict_data_read_ (
dictData *h, unsigned long start, unsigned long size,
const char *preFilter, const char *postFilter )
{
(void) preFilter;
(void) postFilter;
char *buffer, *pt;
unsigned long end;
int count;
char *inBuffer;
char outBuffer[OUT_BUFFER_SIZE];
int firstChunk, lastChunk;
int firstOffset, lastOffset;
int i, j;
int found, target, lastStamp;
static int stamp = 0;
end = start + size;
buffer = xmalloc( size + 1 );
if ( !size )
{
*buffer = 0;
return buffer;
}
PRINTF(DBG_UNZIP,
("dict_data_read( %p, %lu, %lu, %s, %s )\n",
h, start, size, preFilter, postFilter ));
assert( h != NULL);
switch (h->type) {
case DICT_GZIP:
err_fatal( __func__,
"Cannot seek on pure gzip format files.\n"
"Use plain text (for performance)"
" or dzip format (for space savings).\n" );
break;
case DICT_TEXT:
{
if ( fseek( h->fd, start, SEEK_SET ) != 0 ||
fread( buffer, size, 1, h->fd ) != 1 )
{
xfree( buffer );
return 0;
}
buffer[size] = '\0';
}
break;
case DICT_DZIP:
if (!h->initialized) {
++h->initialized;
h->zStream.zalloc = NULL;
h->zStream.zfree = NULL;
h->zStream.opaque = NULL;
h->zStream.next_in = 0;
h->zStream.avail_in = 0;
h->zStream.next_out = NULL;
h->zStream.avail_out = 0;
if (inflateInit2( &h->zStream, -15 ) != Z_OK)
err_internal( __func__,
"Cannot initialize inflation engine: %s\n",
h->zStream.msg );
}
firstChunk = start / h->chunkLength;
firstOffset = start - firstChunk * h->chunkLength;
lastChunk = end / h->chunkLength;
lastOffset = end - lastChunk * h->chunkLength;
PRINTF(DBG_UNZIP,
(" start = %lu, end = %lu\n"
"firstChunk = %d, firstOffset = %d,"
" lastChunk = %d, lastOffset = %d\n",
start, end, firstChunk, firstOffset, lastChunk, lastOffset ));
for (pt = buffer, i = firstChunk; i <= lastChunk; i++) {
/* Access cache */
found = 0;
target = 0;
lastStamp = INT_MAX;
for (j = 0; j < DICT_CACHE_SIZE; j++) {
#if USE_CACHE
if (h->cache[j].chunk == i) {
found = 1;
target = j;
break;
}
#endif
if (h->cache[j].stamp < lastStamp) {
lastStamp = h->cache[j].stamp;
target = j;
}
}
h->cache[target].stamp = ++stamp;
if (found) {
count = h->cache[target].count;
inBuffer = h->cache[target].inBuffer;
} else {
h->cache[target].chunk = i;
if (!h->cache[target].inBuffer)
h->cache[target].inBuffer = xmalloc( IN_BUFFER_SIZE );
inBuffer = h->cache[target].inBuffer;
if (h->chunks[i] >= OUT_BUFFER_SIZE ) {
err_internal( __func__,
"h->chunks[%d] = %d >= %ld (OUT_BUFFER_SIZE)\n",
i, h->chunks[i], OUT_BUFFER_SIZE );
}
if ( fseek( h->fd, h->offsets[ i ], SEEK_SET ) != 0 ||
fread( outBuffer, h->chunks[ i ], 1, h->fd ) != 1 )
{
xfree( buffer );
return 0;
}
dict_data_filter( outBuffer, &count, OUT_BUFFER_SIZE, preFilter );
h->zStream.next_in = outBuffer;
h->zStream.avail_in = h->chunks[i];
h->zStream.next_out = inBuffer;
h->zStream.avail_out = IN_BUFFER_SIZE;
if (inflate( &h->zStream, Z_PARTIAL_FLUSH ) != Z_OK)
err_fatal( __func__, "inflate: %s\n", h->zStream.msg );
if (h->zStream.avail_in)
err_internal( __func__,
"inflate did not flush (%d pending, %d avail)\n",
h->zStream.avail_in, h->zStream.avail_out );
count = IN_BUFFER_SIZE - h->zStream.avail_out;
dict_data_filter( inBuffer, &count, IN_BUFFER_SIZE, postFilter );
h->cache[target].count = count;
}
if (i == firstChunk) {
if (i == lastChunk) {
memcpy( pt, inBuffer + firstOffset, lastOffset-firstOffset);
pt += lastOffset - firstOffset;
} else {
if (count != h->chunkLength )
err_internal( __func__,
"Length = %d instead of %d\n",
count, h->chunkLength );
memcpy( pt, inBuffer + firstOffset,
h->chunkLength - firstOffset );
pt += h->chunkLength - firstOffset;
}
} else if (i == lastChunk) {
memcpy( pt, inBuffer, lastOffset );
pt += lastOffset;
} else {
assert( count == h->chunkLength );
memcpy( pt, inBuffer, h->chunkLength );
pt += h->chunkLength;
}
}
*pt = '\0';
break;
case DICT_UNKNOWN:
err_fatal( __func__, "Cannot read unknown file type\n" );
break;
}
return buffer;
}
static int dict_read_header( const char *filename,
dictData *header, int computeCRC )
{
FILE *str;
int id1, id2, si1, si2;
char buffer[BUFFERSIZE];
int extraLength, subLength;
int i;
char *pt;
int c;
struct stat sb;
unsigned long crc = crc32( 0L, Z_NULL, 0 );
int count;
unsigned long offset;
if (!(str = gd_fopen( filename, "rb" )))
err_fatal_errno( __func__,
"Cannot open data file \"%s\" for read\n", filename );
header->filename = NULL;//str_find( filename );
header->headerLength = GZ_XLEN - 1;
header->type = DICT_UNKNOWN;
id1 = getc( str );
id2 = getc( str );
if (id1 != GZ_MAGIC1 || id2 != GZ_MAGIC2) {
header->type = DICT_TEXT;
fstat( fileno( str ), &sb );
header->compressedLength = header->length = sb.st_size;
header->origFilename = NULL;//str_find( filename );
header->mtime = sb.st_mtime;
if (computeCRC) {
rewind( str );
while (!feof( str )) {
if ((count = fread( buffer, 1, BUFFERSIZE, str ))) {
crc = crc32( crc, buffer, count );
}
}
}
header->crc = crc;
fclose( str );
return 0;
}
header->type = DICT_GZIP;
header->method = getc( str );
header->flags = getc( str );
header->mtime = getc( str ) << 0;
header->mtime |= getc( str ) << 8;
header->mtime |= getc( str ) << 16;
header->mtime |= getc( str ) << 24;
header->extraFlags = getc( str );
header->os = getc( str );
if (header->flags & GZ_FEXTRA) {
extraLength = getc( str ) << 0;
extraLength |= getc( str ) << 8;
header->headerLength += extraLength + 2;
si1 = getc( str );
si2 = getc( str );
if (si1 == GZ_RND_S1 && si2 == GZ_RND_S2) {
subLength = getc( str ) << 0;
subLength |= getc( str ) << 8;
header->version = getc( str ) << 0;
header->version |= getc( str ) << 8;
if (header->version != 1)
err_internal( __func__,
"dzip header version %d not supported\n",
header->version );
header->chunkLength = getc( str ) << 0;
header->chunkLength |= getc( str ) << 8;
header->chunkCount = getc( str ) << 0;
header->chunkCount |= getc( str ) << 8;
if (header->chunkCount <= 0) {
fclose( str );
return 5;
}
header->chunks = xmalloc( sizeof( header->chunks[0] )
* header->chunkCount );
for (i = 0; i < header->chunkCount; i++) {
header->chunks[i] = getc( str ) << 0;
header->chunks[i] |= getc( str ) << 8;
}
header->type = DICT_DZIP;
} else {
fseek( str, header->headerLength, SEEK_SET );
}
}
if (header->flags & GZ_FNAME) { /* FIXME! Add checking against header len */
pt = buffer;
while ((c = getc( str )) && c != EOF){
*pt++ = c;
if (pt == buffer + sizeof (buffer)){
err_fatal (
__func__,
"too long FNAME field in dzip file \"%s\"\n", filename);
}
}
*pt = '\0';
header->origFilename = NULL;//str_find( buffer );
header->headerLength += strlen( buffer ) + 1;
} else {
header->origFilename = NULL;
}
if (header->flags & GZ_COMMENT) { /* FIXME! Add checking for header len */
pt = buffer;
while ((c = getc( str )) && c != EOF){
*pt++ = c;
if (pt == buffer + sizeof (buffer)){
err_fatal (
__func__,
"too long COMMENT field in dzip file \"%s\"\n", filename);
}
}
*pt = '\0';
header->comment = NULL;//str_find( buffer );
header->headerLength += strlen( header->comment ) + 1;
} else {
header->comment = NULL;
}
if (header->flags & GZ_FHCRC) {
getc( str );
getc( str );
header->headerLength += 2;
}
if (ftell( str ) != header->headerLength + 1)
err_internal( __func__,
"File position (%lu) != header length + 1 (%d)\n",
ftell( str ), header->headerLength + 1 );
fseek( str, -8, SEEK_END );
header->crc = getc( str ) << 0;
header->crc |= getc( str ) << 8;
header->crc |= getc( str ) << 16;
header->crc |= getc( str ) << 24;
header->length = getc( str ) << 0;
header->length |= getc( str ) << 8;
header->length |= getc( str ) << 16;
header->length |= getc( str ) << 24;
header->compressedLength = ftell( str );
/* Compute offsets */
header->offsets = xmalloc( sizeof( header->offsets[0] )
* header->chunkCount );
for (offset = header->headerLength + 1, i = 0;
i < header->chunkCount;
i++)
{
header->offsets[i] = offset;
offset += header->chunks[i];
}
fclose( str );
return 0;
}
void prs_file( const char *filename )
{
char *buffer;
const char **pt;
static const char *cpp = NULL;
static const char *cpps[] = { "/lib/cpp",
"/usr/lib/cpp",
"/usr/ccs/lib/cpp", /* Solaris */
"/usr/lang/cpp",
0 };
static const char *extra_options = "";
FILE *tmp;
if (!filename)
err_fatal( __FUNCTION__, "No filename specified\n" );
if (!cpp) {
if ((cpp = getenv( "KHEPERA_CPP" ))) {
PRINTF(MAA_PARSE,("%s: Using KHEPERA_CPP from %s\n",__func__,cpp));
}
/* Always look for gcc's cpp first, since
we know it is ANSI C compliant. */
if (!cpp && (tmp = popen( "gcc -print-file-name=cpp", "r" ))) {
char buf[1024];
char *t;
if (fread( buf, 1, 1023, tmp ) > 0) {
if ((t = strchr( buf, '\n' ))) *t = '\0';
PRINTF(MAA_PARSE,("%s: Using GNU cpp from %s\n",__func__,buf));
cpp = str_find( buf );
extra_options = "-nostdinc -nostdinc++";
}
pclose( tmp );
}
/* Then look for the vendor's cpp, which
may or may not be useful (e.g., on SunOS
4.x machines, it isn't ANSI C
compatible. Considering ANSI C is C89,
and this is 1996, one might think that
Sun would have fixed this... */
if (!cpp) {
for (pt = cpps; **pt; pt++) {
if (!access( *pt, X_OK )) {
PRINTF(MAA_PARSE,
("%s: Using system cpp from %s\n",__func__,*pt));
cpp = *pt;
break;
}
}
}
if (!cpp)
err_fatal("%s:Cannot locate cpp -- set KHEPERA_CPP to cpp's path\n",
__func__ );
}
buffer = alloca( strlen( cpp )
+ sizeof( filename )
+ (_prs_cpp_options ? strlen( _prs_cpp_options ) : 0)
+ 100 );
sprintf( buffer, "%s -I. %s %s 2>/dev/null", cpp,
_prs_cpp_options ? _prs_cpp_options : "", filename );
PRINTF(MAA_PARSE,("%s: %s\n",__func__,buffer));
if (!(yyin = popen( buffer, "r" )))
err_fatal_errno("%s Cannot open \"%s\" for read\n", __func__, filename );
src_new_file( filename );
yydebug = _prs_debug_flag;
yyparse();
pclose( yyin );
}
static void
scanargs(int argc,
char **argv)
{
int c;
#if defined(DEBUG) || defined(lint)
char *optstr = "l:o:p:s:tkv:"; /* debugging options */
#else
char *optstr = "l:o:p:s:tk"; /* production options */
#endif
/* set up some defaults */
g_targetpid = 0;
g_cmdname = NULL;
g_cmdargs = NULL;
g_preload = NULL;
g_outname = NULL;
g_outsize = -1;
while ((c = getopt(argc, argv, optstr)) != EOF) {
switch (c) {
case 'l': /* preload objects */
g_preload = optarg;
break;
case 'o': /* tracefile name */
g_outname = optarg;
break;
case 'p': /* target pid (attach case) */
g_targetpid = atoi(optarg);
break;
case 's': /* tracefile size */
g_outsize = atoi(optarg) * 1024;
break;
case 't': /* test flag */
g_testflag = B_TRUE;
(void) setvbuf(stdout, NULL, _IOLBF, 0);
break;
case 'k': /* kernel mode */
g_kernelmode = B_TRUE;
break;
#if defined(DEBUG) || defined(lint)
case 'v': /* verbose flag */
g_verbose = atoi(optarg);
break;
#endif
case '?': /* error case */
usage(argv, gettext("unrecognized argument"));
}
}
if (optind < argc) {
g_cmdname = strdup(argv[optind]);
g_cmdargs = &argv[optind];
}
/* sanity clause */
if (!g_kernelmode && (g_cmdname == NULL && g_targetpid == 0))
usage(argv, gettext("need to specify cmd or pid"));
if (g_cmdname != NULL && g_targetpid != 0)
usage(argv, gettext("can't specify both cmd and pid"));
if (g_targetpid && g_preload)
usage(argv, gettext("can't use preload option with attach"));
if (g_kernelmode) {
if (g_outname)
usage(argv, "can't specify a filename in kernel mode");
if (g_cmdname)
usage(argv, "can't specify a command in kernel mode");
if (g_targetpid)
usage(argv, "can't specify pid in kernel mode");
if (g_preload)
usage(argv, "can't use preload option in kernel mode");
}
/* default output size */
if (g_outsize == -1)
g_outsize = g_kernelmode ? KERNEL_OUTSIZE : USER_OUTSIZE;
#ifdef OLD
int i;
for (i = 1; i < argc; i++) {
if (strneq(argv[i], "-v", 2)) {
int vlevel;
vlevel = (strlen(argv[i]) > 2)? atoi(&argv[i][2]) : 1;
g_verbose = B_TRUE;
prb_verbose_set(vlevel);
} else if (strneq(argv[i], "-pid", 2)) {
if (++i >= argc)
usage(argv, gettext("missing pid argument"));
g_targetpid = atoi(argv[i]);
} else if (strneq(argv[i], "-t", 2)) {
g_testflag = B_TRUE;
(void) setvbuf(stdout, NULL, _IOLBF, 0);
} else if (argv[i][0] != '-') {
g_cmdname = strdup(argv[i]);
if (!g_cmdname) {
err_fatal(gettext(
"%s: out of memory"), argv[0]);
}
if (g_verbose >= 2) {
(void) fprintf(stderr,
"cmdname=%s\n", g_cmdname);
}
/*
* rest of arguments are the args to the executable -
* by convention argv[0] should be name of
* executable, so we don't increment i
*/
g_cmdargs = &argv[i];
break;
} else {
usage(argv, gettext("unrecognized argument"));
}
}
#endif
} /* end scanargs */
bntseq_t *bns_restore_core(const char *ann_filename, const char* amb_filename, const char* pac_filename)
{
char str[8192];
FILE *fp;
const char *fname;
bntseq_t *bns;
long long xx;
int i;
int scanres;
bns = (bntseq_t*)calloc(1, sizeof(bntseq_t));
{ // read .ann
fp = xopen(fname = ann_filename, "r");
scanres = fscanf(fp, "%lld%d%u", &xx, &bns->n_seqs, &bns->seed);
if (scanres != 3) goto badread;
bns->l_pac = xx;
bns->anns = (bntann1_t*)calloc(bns->n_seqs, sizeof(bntann1_t));
for (i = 0; i < bns->n_seqs; ++i) {
bntann1_t *p = bns->anns + i;
char *q = str;
int c;
// read gi and sequence name
scanres = fscanf(fp, "%u%s", &p->gi, str);
if (scanres != 2) goto badread;
p->name = strdup(str);
// read fasta comments
while (q - str < sizeof(str) - 1 && (c = fgetc(fp)) != '\n' && c != EOF) *q++ = c;
while (c != '\n' && c != EOF) c = fgetc(fp);
if (c == EOF) {
scanres = EOF;
goto badread;
}
*q = 0;
if (q - str > 1 && strcmp(str, " (null)") != 0) p->anno = strdup(str + 1); // skip leading space
else p->anno = strdup("");
// read the rest
scanres = fscanf(fp, "%lld%d%d", &xx, &p->len, &p->n_ambs);
if (scanres != 3) goto badread;
p->offset = xx;
}
err_fclose(fp);
}
{ // read .amb
int64_t l_pac;
int32_t n_seqs;
fp = xopen(fname = amb_filename, "r");
scanres = fscanf(fp, "%lld%d%d", &xx, &n_seqs, &bns->n_holes);
if (scanres != 3) goto badread;
l_pac = xx;
xassert(l_pac == bns->l_pac && n_seqs == bns->n_seqs, "inconsistent .ann and .amb files.");
bns->ambs = bns->n_holes? (bntamb1_t*)calloc(bns->n_holes, sizeof(bntamb1_t)) : 0;
for (i = 0; i < bns->n_holes; ++i) {
bntamb1_t *p = bns->ambs + i;
scanres = fscanf(fp, "%lld%d%s", &xx, &p->len, str);
if (scanres != 3) goto badread;
p->offset = xx;
p->amb = str[0];
}
err_fclose(fp);
}
{ // open .pac
bns->fp_pac = xopen(pac_filename, "rb");
}
return bns;
badread:
if (EOF == scanres) {
err_fatal(__func__, "Error reading %s : %s\n", fname, ferror(fp) ? strerror(errno) : "Unexpected end of file");
}
err_fatal(__func__, "Parse error reading %s\n", fname);
}
int TBinit(char *tname, int argc, char *argv[],
TBcallbackTerm fun, term * (check_in_sign)(term *))
{
char *s;
char host_toolbus[MAXHOSTNAMELEN];
int fromToolBus, i = 1;
TBbool local_ports = TBfalse;
term *trm;
tool_name = (tname) ? tname : "anonymous_tool";
ToolBus = TBfalse;
init_terms();
init_utils();
if(gethostname(this_host, MAXHOSTNAMELEN) < 0)
err_sys_fatal("TBinit -- can't get host name");
strcpy(host_toolbus, this_host);
WellKnownSocketPort = TB_PORT;
while(i < argc){
if(streq(argv[i], "-help")){
help(); exit(0);
} else if(streq(argv[i], "-verbose")){
TBverbose = TBtrue;
} else if(streq(argv[i], "-TB_HOST")){
i++;
if(strlen(argv[i]) > MAXHOSTNAMELEN)
err_fatal("TBinit -- name of ToolBus host too long");
strcpy(host_toolbus, argv[i]);
i++;
} else if(streq(argv[i],"-TB_PORT")){
i++;
WellKnownSocketPort = atoi(argv[i++]);
} else if(streq(argv[i],"-TB_TOOL_ID")){
i++;
this_tool_id = atoi(argv[i++]);
} else if(streq(argv[i], "-TB_TOOL_NAME")){
tool_name = argv[i+1];
i += 2;
} else if(streq(argv[i], "-TB_SINGLE")){
i++;
stand_alone = TBtrue;
} else if(streq(argv[i],"-TB_LOCAL_PORTS")){
i++;
local_ports = TBtrue;
} else
i++;
}
if((s = getenv("TB_VERBOSE")) &&
streq(s ,"true"))
TBverbose = TBtrue;
if((s = getenv("TB_LOCAL_PORTS")) &&
streq(s ,"true"))
local_ports = TBtrue;
if(stand_alone || !fun){ /* execute stand alone */
/* TBaddTermPort(0, fun); */
return TB_OK;
}
if(mkports(local_ports, tool_name, host_toolbus, &this_tool_id, &fromToolBus,
&toToolBus) == TB_ERROR)
err_fatal("TBinit -- can't connect to ToolBus");
TBaddTermPort(fromToolBus, fun);
Snd_Void = TBmake("snd-void()");
TBprotect(&Snd_Void);
trm = TBread(fromToolBus); /* obtain the tool signature from the ToolBus */
if(TBmatch(trm, "rec-do(signature(%t,%t))", &tool_in_sign, &tool_out_sign)){
TBsend(Snd_Void);
if(check_in_sign){
trm = (*check_in_sign)(tool_in_sign);
if(trm)
err_fatal("TBinit -- NOT IN INPUT SIGNATURE: %t", trm);
}
} else
err_fatal("signature information garbled: %t", trm);
return TB_OK;
}
int bwa_index(int argc, char *argv[])
{
char *prefix = 0, *str, *str2, *str3;
int c, algo_type = 0, is_color = 0, is_64 = 0;
clock_t t;
int64_t l_pac;
while ((c = getopt(argc, argv, "6ca:p:")) >= 0) {
switch (c) {
case 'a': // if -a is not set, algo_type will be determined later
if (strcmp(optarg, "div") == 0) algo_type = 1;
else if (strcmp(optarg, "bwtsw") == 0) algo_type = 2;
else if (strcmp(optarg, "is") == 0) algo_type = 3;
else err_fatal(__func__, "unknown algorithm: '%s'.", optarg);
break;
case 'p': prefix = strdup(optarg); break;
case 'c': is_color = 1; break;
case '6': is_64 = 1; break;
default: return 1;
}
}
if (optind + 1 > argc) {
fprintf(stderr, "\n");
fprintf(stderr, "Usage: bwa index [-a bwtsw|is] [-c] <in.fasta>\n\n");
fprintf(stderr, "Options: -a STR BWT construction algorithm: bwtsw or is [auto]\n");
fprintf(stderr, " -p STR prefix of the index [same as fasta name]\n");
fprintf(stderr, " -6 index files named as <in.fasta>.64.* instead of <in.fasta>.* \n");
// fprintf(stderr, " -c build color-space index\n");
fprintf(stderr, "\n");
fprintf(stderr, "Warning: `-a bwtsw' does not work for short genomes, while `-a is' and\n");
fprintf(stderr, " `-a div' do not work not for long genomes. Please choose `-a'\n");
fprintf(stderr, " according to the length of the genome.\n\n");
return 1;
}
if (prefix == 0) {
prefix = malloc(strlen(argv[optind]) + 4);
strcpy(prefix, argv[optind]);
if (is_64) strcat(prefix, ".64");
}
str = (char*)calloc(strlen(prefix) + 10, 1);
str2 = (char*)calloc(strlen(prefix) + 10, 1);
str3 = (char*)calloc(strlen(prefix) + 10, 1);
if (is_color == 0) { // nucleotide indexing
gzFile fp = xzopen(argv[optind], "r");
t = clock();
fprintf(stderr, "[bwa_index] Pack FASTA... ");
l_pac = bns_fasta2bntseq(fp, prefix, 0);
fprintf(stderr, "%.2f sec\n", (float)(clock() - t) / CLOCKS_PER_SEC);
gzclose(fp);
} else { // color indexing
gzFile fp = xzopen(argv[optind], "r");
strcat(strcpy(str, prefix), ".nt");
t = clock();
fprintf(stderr, "[bwa_index] Pack nucleotide FASTA... ");
l_pac = bns_fasta2bntseq(fp, str, 0);
fprintf(stderr, "%.2f sec\n", (float)(clock() - t) / CLOCKS_PER_SEC);
gzclose(fp);
{
char *tmp_argv[3];
tmp_argv[0] = argv[0]; tmp_argv[1] = str; tmp_argv[2] = prefix;
t = clock();
fprintf(stderr, "[bwa_index] Convert nucleotide PAC to color PAC... ");
bwa_pac2cspac(3, tmp_argv);
fprintf(stderr, "%.2f sec\n", (float)(clock() - t) / CLOCKS_PER_SEC);
}
}
if (algo_type == 0) algo_type = l_pac > 50000000? 2 : 3; // set the algorithm for generating BWT
{
strcpy(str, prefix); strcat(str, ".pac");
strcpy(str2, prefix); strcat(str2, ".bwt");
t = clock();
fprintf(stderr, "[bwa_index] Construct BWT for the packed sequence...\n");
if (algo_type == 2) bwt_bwtgen(str, str2);
else if (algo_type == 1 || algo_type == 3) {
bwt_t *bwt;
bwt = bwt_pac2bwt(str, algo_type == 3);
bwt_dump_bwt(str2, bwt);
bwt_destroy(bwt);
}
fprintf(stderr, "[bwa_index] %.2f seconds elapse.\n", (float)(clock() - t) / CLOCKS_PER_SEC);
}
{
bwt_t *bwt;
strcpy(str, prefix); strcat(str, ".bwt");
t = clock();
fprintf(stderr, "[bwa_index] Update BWT... ");
bwt = bwt_restore_bwt(str);
bwt_bwtupdate_core(bwt);
bwt_dump_bwt(str, bwt);
bwt_destroy(bwt);
fprintf(stderr, "%.2f sec\n", (float)(clock() - t) / CLOCKS_PER_SEC);
}
{
gzFile fp = xzopen(argv[optind], "r");
t = clock();
fprintf(stderr, "[bwa_index] Pack forward-only FASTA... ");
l_pac = bns_fasta2bntseq(fp, prefix, 1);
fprintf(stderr, "%.2f sec\n", (float)(clock() - t) / CLOCKS_PER_SEC);
gzclose(fp);
}
{
bwt_t *bwt;
strcpy(str, prefix); strcat(str, ".bwt");
strcpy(str3, prefix); strcat(str3, ".sa");
t = clock();
fprintf(stderr, "[bwa_index] Construct SA from BWT and Occ... ");
bwt = bwt_restore_bwt(str);
bwt_cal_sa(bwt, 32);
bwt_dump_sa(str3, bwt);
bwt_destroy(bwt);
fprintf(stderr, "%.2f sec\n", (float)(clock() - t) / CLOCKS_PER_SEC);
}
free(str3); free(str2); free(str); free(prefix);
return 0;
}
int dict_data_zip( const char *inFilename, const char *outFilename,
const char *preFilter, const char *postFilter )
{
char inBuffer[IN_BUFFER_SIZE];
char outBuffer[OUT_BUFFER_SIZE];
int count;
unsigned long inputCRC = crc32( 0L, Z_NULL, 0 );
z_stream zStream;
FILE *outStr;
FILE *inStr;
int len;
struct stat st;
char *header;
int headerLength;
int dataLength;
int extraLength;
int chunkLength;
#if HEADER_CRC
int headerCRC;
#endif
unsigned long chunks;
unsigned long chunk = 0;
unsigned long total = 0;
int i;
char tail[8];
char *pt, *origFilename;
/* Open files */
if (!(inStr = fopen( inFilename, "r" )))
err_fatal_errno( __func__,
"Cannot open \"%s\" for read\n", inFilename );
if (!(outStr = fopen( outFilename, "w" )))
err_fatal_errno( __func__,
"Cannot open \"%s\"for write\n", outFilename );
origFilename = xmalloc( strlen( inFilename ) + 1 );
if ((pt = strrchr( inFilename, '/' )))
strcpy( origFilename, pt + 1 );
else
strcpy( origFilename, inFilename );
/* Initialize compression engine */
zStream.zalloc = NULL;
zStream.zfree = NULL;
zStream.opaque = NULL;
zStream.next_in = NULL;
zStream.avail_in = 0;
zStream.next_out = NULL;
zStream.avail_out = 0;
if (deflateInit2( &zStream,
Z_BEST_COMPRESSION,
Z_DEFLATED,
-15, /* Suppress zlib header */
Z_BEST_COMPRESSION,
Z_DEFAULT_STRATEGY ) != Z_OK)
err_internal( __func__,
"Cannot initialize deflation engine: %s\n", zStream.msg );
/* Write initial header information */
chunkLength = (preFilter ? PREFILTER_IN_BUFFER_SIZE : IN_BUFFER_SIZE );
fstat( fileno( inStr ), &st );
chunks = st.st_size / chunkLength;
if (st.st_size % chunkLength) ++chunks;
PRINTF(DBG_VERBOSE,("%lu chunks * %u per chunk = %lu (filesize = %lu)\n",
chunks, chunkLength, chunks * chunkLength,
(unsigned long) st.st_size ));
dataLength = chunks * 2;
extraLength = 10 + dataLength;
headerLength = GZ_FEXTRA_START
+ extraLength /* FEXTRA */
+ strlen( origFilename ) + 1 /* FNAME */
+ (HEADER_CRC ? 2 : 0); /* FHCRC */
PRINTF(DBG_VERBOSE,("(data = %d, extra = %d, header = %d)\n",
dataLength, extraLength, headerLength ));
header = xmalloc( headerLength );
for (i = 0; i < headerLength; i++) header[i] = 0;
header[GZ_ID1] = GZ_MAGIC1;
header[GZ_ID2] = GZ_MAGIC2;
header[GZ_CM] = Z_DEFLATED;
header[GZ_FLG] = GZ_FEXTRA | GZ_FNAME;
#if HEADER_CRC
header[GZ_FLG] |= GZ_FHCRC;
#endif
header[GZ_MTIME+3] = (st.st_mtime & 0xff000000) >> 24;
header[GZ_MTIME+2] = (st.st_mtime & 0x00ff0000) >> 16;
header[GZ_MTIME+1] = (st.st_mtime & 0x0000ff00) >> 8;
header[GZ_MTIME+0] = (st.st_mtime & 0x000000ff) >> 0;
header[GZ_XFL] = GZ_MAX;
header[GZ_OS] = GZ_OS_UNIX;
header[GZ_XLEN+1] = (extraLength & 0xff00) >> 8;
header[GZ_XLEN+0] = (extraLength & 0x00ff) >> 0;
header[GZ_SI1] = GZ_RND_S1;
header[GZ_SI2] = GZ_RND_S2;
header[GZ_SUBLEN+1] = ((extraLength - 4) & 0xff00) >> 8;
header[GZ_SUBLEN+0] = ((extraLength - 4) & 0x00ff) >> 0;
header[GZ_VERSION+1] = 0;
header[GZ_VERSION+0] = 1;
header[GZ_CHUNKLEN+1] = (chunkLength & 0xff00) >> 8;
header[GZ_CHUNKLEN+0] = (chunkLength & 0x00ff) >> 0;
header[GZ_CHUNKCNT+1] = (chunks & 0xff00) >> 8;
header[GZ_CHUNKCNT+0] = (chunks & 0x00ff) >> 0;
strcpy( &header[GZ_FEXTRA_START + extraLength], origFilename );
xfwrite( header, 1, headerLength, outStr );
/* Read, compress, write */
while (!feof( inStr )) {
if ((count = fread( inBuffer, 1, chunkLength, inStr ))) {
dict_data_filter( inBuffer, &count, IN_BUFFER_SIZE, preFilter );
inputCRC = crc32( inputCRC, (const Bytef *) inBuffer, count );
zStream.next_in = (Bytef *) inBuffer;
zStream.avail_in = count;
zStream.next_out = (Bytef *) outBuffer;
zStream.avail_out = OUT_BUFFER_SIZE;
if (deflate( &zStream, Z_FULL_FLUSH ) != Z_OK)
err_fatal( __func__, "deflate: %s\n", zStream.msg );
assert( zStream.avail_in == 0 );
len = OUT_BUFFER_SIZE - zStream.avail_out;
assert( len <= 0xffff );
dict_data_filter( outBuffer, &len, OUT_BUFFER_SIZE, postFilter );
assert( len <= 0xffff );
header[GZ_RNDDATA + chunk*2 + 1] = (len & 0xff00) >> 8;
header[GZ_RNDDATA + chunk*2 + 0] = (len & 0x00ff) >> 0;
xfwrite( outBuffer, 1, len, outStr );
++chunk;
total += count;
if (dbg_test( DBG_VERBOSE )) {
printf( "chunk %5lu: %lu of %lu total\r",
chunk, total, (unsigned long) st.st_size );
xfflush( stdout );
}
}
}
