int load_seqs(const char *path, char ***seqs_ptr, int *cap_ptr)
{
int cap = 1024;
char **seqs = my_malloc(sizeof(char*) * cap,__FILE__,__LINE__);
read_t read;
seq_read_alloc(&read);
seq_file_t *file = seq_open(path);
if(file == NULL) die("Cannot open file: %s.", path);
int num = 0;
while(seq_read(file, &read))
{
if(num == cap) {
cap *= 2;
seqs = realloc(seqs, sizeof(char*) * cap);
}
seqs[num++] = strdup(read.seq.b);
}
seq_read_dealloc(&read);
seq_close(file);
*seqs_ptr = seqs;
*cap_ptr = cap;
return num;
}
uint8_t read_vga_register(register_set_t target, uint8_t index)
{
switch(target)
{
case GRAPHIC_CTRL:
return gctrl_read(index);
break;
case SEQUENCER:
return seq_read(index);
break;
case ATTRIBUTE_CTRL:
return attr_read(index);
break;
case CRT_CTRL:
return crtc_read(index);
break;
case EXTERNAL_REGISTERS:
switch(index)
{
case MISC_OUTPUT_REGISTER:
return misc_output_read();
break;
case FEATURE_CONTROL_REGISTER:
return feature_control_read();
break;
}
break;
default:
break;
}
return 0;
}
LVAL xlc_seq_read(void)
{
seq_type arg1 = getseq(xlgaseq());
FILE * arg2 = getfile(xlgastream());
xllastarg();
seq_read(arg1, arg2);
return NIL;
}
/* Makes threads wait on timewarp_seq and be waken up when time is warped.
* This function will be no-op unless timeval_dummy_register() is called. */
void
timewarp_wait(void)
{
if (timewarp_enabled) {
uint64_t *last_seq = last_seq_get();
*last_seq = seq_read(timewarp_seq);
seq_wait(timewarp_seq, *last_seq);
}
}
int main(int argc, char **argv)
{
if(argc != 2) exit(EXIT_FAILURE);
seq_file_t *f = seq_open(argv[1]);
read_t *r = seq_read_alloc();
if(f == NULL) exit(EXIT_FAILURE);
while(seq_read(f,r) > 0)
printf("%s\t[%lu,%lu,%lu]\n", r->name.b, r->name.end, r->seq.end, r->qual.end);
seq_close(f);
seq_read_destroy(r);
return EXIT_SUCCESS;
}
SEQ *seq_get(const char *fname)
{
SEQ *s = seq_open(fname);
int r = seq_read(s);
if (r < 0)
Fatalfr("could not read from %s", fname);
else if (r == 0)
return 0;
else
return s;
/*NOTREACHED*/
return 0;
}
/*
* Take a local copy of a policy.
*
* The destination policy isn't write-barriered; this is used
* for doing local copies into something that isn't shared.
*/
void
vm_domain_policy_localcopy(struct vm_domain_policy *dst,
const struct vm_domain_policy *src)
{
seq_t seq;
for (;;) {
seq = seq_read(&src->seq);
*dst = *src;
if (seq_consistent(&src->seq, seq))
return;
cpu_spinwait();
}
}
void
vm_domain_iterator_set_policy(struct vm_domain_iterator *vi,
const struct vm_domain_policy *vt)
{
seq_t seq;
struct vm_domain_policy vt_lcl;
for (;;) {
seq = seq_read(&vt->seq);
vt_lcl = *vt;
if (seq_consistent(&vt->seq, seq)) {
_vm_domain_iterator_set_policy(vi, &vt_lcl);
return;
}
cpu_spinwait();
}
}
int main()
{
struct list *data = NULL;
seq_read(&data);
seq_write(data);
__VERIFIER_plot(NULL);
// NOTE: you may mix seq_insert/seq_sort as you like, we'll take care of it
seq_sort(&data);
seq_write(data);
__VERIFIER_plot(NULL);
seq_destroy(data);
__VERIFIER_plot(NULL);
return 0;
}
// Load reads from a file, apply sequence error, dump
// Return total number of bases
size_t mutate_reads(seq_file_t *sfile, gzFile gzout, FileList *flist, float err)
{
printf(" reading: %s\n", sfile->path);
read_t r;
seq_read_alloc(&r);
size_t num_bases = 0;
while(seq_read(sfile, &r) > 0) {
if(err > 0) add_seq_error_rate(r.seq.b, r.seq.end, err);
else add_seq_error_profile(r.seq.b, r.seq.end, flist);
gzprintf(gzout, "@%s\n%s\n+\n%s\n", r.name.b, r.seq.b, r.qual.b);
num_bases += r.seq.end;
}
seq_read_dealloc(&r);
return num_bases;
}
read_t* filelist_read(FileList *flist)
{
read_t *r = &flist->read;
size_t i; // i is number of file changes
for(i = 0; seq_read(flist->files[flist->curr], r) <= 0 && i <= flist->num_files; i++)
{
flist->curr++;
if(flist->curr == flist->num_files) { flist->curr = flist->filesready = 0; }
if(!flist->filesready) {
char path[PATH_MAX+1];
assert(strlen(flist->files[flist->curr]->path) <= PATH_MAX);
strcpy(path, flist->files[flist->curr]->path);
seq_close(flist->files[flist->curr]);
flist->files[flist->curr] = seq_open(path);
}
}
if(i > flist->num_files) die("All seq files empty");
return r;
}
/*
* Take a write-barrier copy of a policy.
*
* The destination policy is write -barriered; this is used
* for doing copies into policies that may be read by other
* threads.
*/
void
vm_domain_policy_copy(struct vm_domain_policy *dst,
const struct vm_domain_policy *src)
{
seq_t seq;
struct vm_domain_policy d;
for (;;) {
seq = seq_read(&src->seq);
d = *src;
if (seq_consistent(&src->seq, seq)) {
seq_write_begin(&dst->seq);
dst->p.domain = d.p.domain;
dst->p.policy = d.p.policy;
seq_write_end(&dst->seq);
return;
}
cpu_spinwait();
}
}
void filelist_mean_err(FileList *flist)
{
size_t i, f, maxread = 0, readcap = 512, newcap, carry;
long double *sumprob = malloc(readcap * sizeof(long double));
size_t *counts = malloc(readcap * sizeof(size_t));
for(i = 0; i < readcap; i++) { sumprob[i] = 0; counts[i] = 0; }
read_t *r = &flist->read;
int fmt, fqoffset = 33, minq, maxq;
for(f = flist->curr; f < flist->num_files; f++) {
fmt = seq_guess_fastq_format(flist->files[f], &minq, &maxq);
fqoffset = (fmt == -1 ? 33 : FASTQ_OFFSET[fmt]);
while(seq_read(flist->files[f], r) > 0) {
if(r->qual.end > readcap) {
newcap = ROUNDUP2POW(r->qual.end);
sumprob = realloc(sumprob, newcap * sizeof(long double));
counts = realloc(counts, newcap * sizeof(size_t));
for(i = readcap; i < newcap; i++) { sumprob[i] = 0; counts[i] = 0; }
readcap = newcap;
}
counts[r->qual.end-1]++;
for(i = 0; i < r->qual.end; i++)
sumprob[i] += qual_prob[r->qual.b[i] - fqoffset];
maxread = MAX2(maxread, r->qual.end);
}
}
// Convert counts to cummulative (reverse)
for(i = maxread-1, carry = 0; i != SIZE_MAX; i--) {
carry += counts[i];
counts[i] = carry;
}
for(i = 0; i < maxread; i++) {
// printf(" %.8Lf/%zu", sumprob[i], counts[i]);
printf(" %.2Lf", 100.0 * sumprob[i] / counts[i]);
} printf("\n");
free(counts);
free(sumprob);
}
// If seq2 is NULL, read pair of entries from first file
// Otherwise read an entry from each
void align_from_file(const char *path1, const char *path2,
void (align)(read_t *r1, read_t *r2),
bool use_zlib)
{
seq_file_t *sf1, *sf2;
if((sf1 = open_seq_file(path1, use_zlib)) == NULL)
{
fprintf(stderr, "Alignment Error: couldn't open file %s\n", path1);
fflush(stderr);
return;
}
if(path2 == NULL)
{
sf2 = sf1;
}
else if((sf2 = open_seq_file(path2, use_zlib)) == NULL)
{
fprintf(stderr, "Alignment Error: couldn't open file %s\n", path1);
fflush(stderr);
return;
}
// fprintf(stderr, "File buffer %zu zlib: %i\n", sf1->in.size, seq_use_gzip(sf1));
read_t read1, read2;
seq_read_alloc(&read1);
seq_read_alloc(&read2);
// Loop while we can read a sequence from the first file
unsigned long alignments;
for(alignments = 0; seq_read(sf1, &read1) > 0; alignments++)
{
if(seq_read(sf2, &read2) <= 0)
{
fprintf(stderr, "Alignment Error: Odd number of sequences - "
"I read in pairs!\n");
fflush(stderr);
break;
}
(align)(&read1, &read2);
}
// warn if no bases read
if(alignments == 0)
{
fprintf(stderr, "Alignment Warning: empty input\n");
fflush(stderr);
}
// Close files
seq_close(sf1);
if(path2 != NULL)
seq_close(sf2);
// Free memory
seq_read_dealloc(&read1);
seq_read_dealloc(&read2);
}
int main(int argc, char ** argv)
{
const char *progname = "sand_compress_reads";
FILE * infile;
FILE * outfile;
int quiet_mode = 0;
struct seq *s;
struct cseq *c;
signed char d;
int clip = 0;
int internal = 0;
char tmp_id[128];
int count = 0;
while((d=getopt(argc,argv,"cvqhi")) > -1) {
switch(d) {
case 'c':
clip = 1;
break;
case 'i':
internal = 1;
break;
case 'q':
quiet_mode = 1;
break;
case 'v':
cctools_version_print(stdout, progname);
exit(0);
break;
case 'h':
default:
show_help(progname);
exit(0);
break;
}
}
cctools_version_debug(D_DEBUG, argv[0]);
if( optind<argc ) {
infile = fopen(argv[optind], "r");
if(!infile) {
fprintf(stderr,"%s: couldn't open %s: %s\n",progname,argv[optind],strerror(errno));
return 1;
}
optind++;
} else {
infile = stdin;
}
if( optind<argc ) {
outfile = fopen(argv[optind],"w");
if(!outfile) {
fprintf(stderr,"%s: couldn't open %s: %s\n",progname,argv[optind],strerror(errno));
return 1;
}
optind++;
} else {
outfile = stdout;
}
while((s = seq_read(infile))) {
if(clip != 0 || internal != 0){
strcpy(tmp_id, s->name);
strcpy(s->name, strtok(tmp_id,","));
if(internal != 0){
strcpy(s->name, strtok(NULL,","));
}
}
c = seq_compress(s);
cseq_write(outfile,c);
cseq_free(c);
seq_free(s);
count++;
}
if(!quiet_mode) {
fprintf(stderr,"%d sequences compressed.\n",count);
}
fclose(infile);
fclose(outfile);
return 0;
}
// Returns num of bases printed
size_t sim_reads(seq_file_t *reffile, gzFile out0, gzFile out1,
FileList *flist, float err_rate,
size_t insert, double insert_stddev, size_t rlen, double depth)
{
size_t i, chromcap = 16, nchroms, glen = 0, nreads, chr, pos0, pos1, tlen;
read_t *chroms;
tlen = rlen + (out1 == NULL ? 0 : insert + rlen);
chroms = malloc(chromcap * sizeof(read_t));
nchroms = 0;
// Load genome
printf(" Loaded contigs:");
while(1)
{
if(nchroms == chromcap) chroms = realloc(chroms, (chromcap*=2)*sizeof(read_t));
seq_read_alloc(&chroms[nchroms]);
if(seq_read(reffile, &chroms[nchroms]) <= 0)
{ seq_read_dealloc(&chroms[nchroms]); break; }
if(chroms[nchroms].seq.end < tlen) { seq_read_dealloc(&chroms[nchroms]); }
else {
seq_read_truncate_name(&chroms[nchroms]);
printf(" %s[%zu]", chroms[nchroms].name.b, chroms[nchroms].seq.end);
glen += chroms[nchroms].seq.end;
nchroms++;
}
}
printf("\n Genome size: %zu\n", glen);
if(nchroms == 0) {
die("No sequences long enough in ref genome file [min len: %zu]: %s",
tlen, reffile->path);
}
// Sample
nreads = (glen * depth) / (out1 == NULL ? rlen : (2 * rlen));
char read0[rlen+1], read1[rlen+1];
read0[rlen] = read1[rlen] = '\0';
printf("Sampling %zu %sreads...\n", nreads,
out1 == NULL ? "single " : "paired-end ");
// Sample paired-end if out1 != NULL
for(i = 0; i < nreads; i++)
{
chr = (nchroms == 1) ? 0 : rand_chrom(chroms, nchroms, glen);
pos0 = random_uniform(chroms[chr].seq.end - (out1 == NULL ? rlen : tlen));
pos1 = pos0;
memcpy(read0, chroms[chr].seq.b+pos0, rlen);
if(out1 != NULL) {
pos1 = pos0 + rlen + insert + ran_normal()*insert_stddev;
if(pos1 + rlen > chroms[chr].seq.end) pos1 = chroms[chr].seq.end-rlen;
memcpy(read1, chroms[chr].seq.b+pos1, rlen);
}
if(flist != NULL) {
add_seq_error_profile(read0, rlen, flist);
if(out1 != NULL)
add_seq_error_profile(read1, rlen, flist);
}
else if(err_rate >= 0) {
add_seq_error_rate(read0, rlen, err_rate);
}
gzprintf(out0, ">r%zu:%s:%zu:%zu%s\n%.*s\n", i, chroms[chr].name.b,
pos0, pos1, (out1 != NULL ? "/1" : ""), (int)rlen, read0);
if(out1 != NULL) {
dna_revcmp(read1, rlen);
gzprintf(out1, ">r%zu:%s:%zu:%zu/2\n%.*s\n", i, chroms[chr].name.b,
pos0, pos1, (int)rlen, read1);
}
}
for(i = 0; i < nchroms; i++) seq_read_dealloc(&chroms[i]);
free(chroms);
size_t num_bases = nreads * rlen;
if(out1 != NULL) num_bases *= 2;
return num_bases;
}
