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; }