static int set_sample_pairs(char **samples, int nsamples, kstring_t *hdr, int idx) { int i, j, n; // Are these samples "old-name new-name" pairs? void *hash = khash_str2str_init(); for (i=0; i<nsamples; i++) { char *key, *value; key = value = samples[i]; while ( *value && !isspace(*value) ) value++; if ( !*value ) break; *value = 0; value++; while ( isspace(*value) ) value++; khash_str2str_set(hash,key,value); } if ( i!=nsamples ) // not "old-name new-name" pairs { khash_str2str_destroy(hash); return 0; } while ( hdr->l>0 && isspace(hdr->s[hdr->l-1]) ) hdr->l--; // remove trailing newlines hdr->s[hdr->l] = 0; kstring_t tmp = {0,0,0}; i = j = n = 0; while ( hdr->s[idx+i] && hdr->s[idx+i]) { if ( hdr->s[idx+i]=='\t' ) { hdr->s[idx+i] = 0; if ( ++n>9 ) { char *ori = khash_str2str_get(hash,hdr->s+idx+j); kputs(ori ? ori : hdr->s+idx+j, &tmp); } else kputs(hdr->s+idx+j, &tmp); kputc('\t',&tmp); j = ++i; continue; } i++; } char *ori = khash_str2str_get(hash,hdr->s+idx+j); kputs(ori ? ori : hdr->s+idx+j, &tmp); if ( hash ) khash_str2str_destroy(hash); hdr->l = idx; kputs(tmp.s, hdr); kputc('\n', hdr); free(tmp.s); return 1; }
void keystroke(int c) { static Rune k[10]; static int alting, nk; int i; if(c == Kalt){ alting = !alting; return; } if(!alting){ kputc(c); return; } if(nk >= nelem(k)) // should not happen nk = 0; k[nk++] = c; c = _latin1(k, nk); if(c > 0){ alting = 0; kputc(c); nk = 0; return; } if(c == -1){ alting = 0; for(i=0; i<nk; i++) kputc(k[i]); nk = 0; return; } // need more input return; }
static void set_samples(char **samples, int nsamples, kstring_t *hdr) { // Find the beginning of the #CHROM line int i = hdr->l - 2, ncols = 0; while ( i>=0 && hdr->s[i]!='\n' ) { if ( hdr->s[i]=='\t' ) ncols++; i--; } if ( i<0 || strncmp(hdr->s+i+1,"#CHROM\tPOS\tID\tREF\tALT\tQUAL\tFILTER\tINFO\tFORMAT",45) ) error("Could not parse the header: %s\n", hdr->s); // Are the samples "old-sample new-sample" pairs? if ( set_sample_pairs(samples,nsamples,hdr, i+1) ) return; // Replace all samples if ( ncols!=nsamples+8 ) fprintf(stderr, "Warning: different number of samples: %d vs %d\n", nsamples,ncols-8); ncols = 0; while ( ncols!=9 ) { i++; if ( hdr->s[i]=='\t' ) ncols++; } hdr->l = i; for (i=0; i<nsamples; i++) { kputc('\t', hdr); kputs(samples[i], hdr); } kputc('\n', hdr); }
/* * Print a hexdecimal value to the standard output of the kernel */ int kprintf_hexdecimal(unsigned long long int val, int zero, int pad, int prec, int cap) { unsigned long long int q; unsigned long long int r; int ptr; int sz; int i; char *buf; /* Calculate the maximum buffer size */ sz = 2 * sizeof(unsigned long long int); buf = alloca(sz); ptr = 0; q = val; while ( q ) { r = q & 0xf; q = q >> 4; if ( r < 10 ) { buf[ptr] = r + '0'; } else if ( cap ) { buf[ptr] = r - 10 + 'A'; } else { buf[ptr] = r - 10 + 'a'; } ptr++; } if ( !ptr ) { buf[ptr] = '0'; ptr++; } /* Padding */ if ( pad > prec && pad > ptr ) { for ( i = 0; i < pad - prec && i < pad - ptr ; i++ ) { if ( zero ) { kputc('0'); } else { kputc(' '); } } } /* Precision */ if ( prec > ptr ) { for ( i = 0; i < prec - ptr; i++ ) { kputc('0'); } } /* Value */ for ( i = 0; i < ptr; i++ ) { kputc(buf[ptr - i - 1]); } return 0; }
/** * Gets a sorted string representation of the alleles of a variant. */ void bcf_alleles2string_sorted(bcf_hdr_t *h, bcf1_t *v, kstring_t *var) { bcf_unpack(v, BCF_UN_STR); var->l = 0; if (v->n_allele==2) { kputs(bcf_get_alt(v, 0), var); kputc(',', var); kputs(bcf_get_alt(v, 1), var); } else { char** allele = bcf_get_allele(v); char** temp = (char**) malloc((bcf_get_n_allele(v)-1)*sizeof(char*)); for (int32_t i=1; i<v->n_allele; ++i) { temp[i-1] = allele[i]; } std::qsort(temp, bcf_get_n_allele(v)-1, sizeof(char*), cmpstr); kputs(bcf_get_alt(v, 0), var); for (int32_t i=0; i<v->n_allele-1; ++i) { kputc(',', var); kputs(temp[i], var); } free(temp); } }
char *bwa_cal_md1(int n_cigar, jigsaw_cigar_t *cigar, int len, bwtint_t pos, ubyte_t *seq, bwtint_t l_pac, const ubyte_t *pacseq, kstring_t *str, int *_nm) { bwtint_t x, y; int z, u, c, nm = 0; str->l = 0; // reset x = pos; y = 0; if (cigar) { int k, l; for (k = u = 0; k < n_cigar; ++k) { l = __cigar_len(cigar[k]); uint8_t op = __cigar_op(cigar[k]); if (op == CIGAR_OP_M) { for (z = 0; z < l && x+z < l_pac; ++z) { c = get_pacseq_base (pacseq, x+z); //c = pacseq[(x+z)>>2] >> ((~(x+z)&3)<<1) & 3; if (c > 3 || seq[y+z] > 3 || c != seq[y+z]) {//mismatch ksprintf(str, "%d", u); kputc("ACGTN"[c], str); ++nm; u = 0; } else ++u; } x += l; y += l; /* } else if (cigar[k]>>14 == FROM_I || cigar[k]>>14 == 3) { */ } else if (op == CIGAR_OP_I || op == CIGAR_OP_S) { y += l; if (op == FROM_I) nm += l; } else if (op == CIGAR_OP_D) { ksprintf(str, "%d", u); kputc('^', str); for (z = 0; z < l && x+z < l_pac; ++z) kputc("ACGT"[get_pacseq_base (pacseq, x+z)], str); //kputc("ACGT"[pacseq[(x+z)>>2] >> ((~(x+z)&3)<<1) & 3], str); u = 0; x += l; nm += l; } else if (op == CIGAR_OP_N) { //intron ksprintf(str, "%d", u); kputc(',', str); u = 0; x += l; } } } else { // no gaps for (z = u = 0; z < len; ++z) { c = get_pacseq_base (pacseq, x+z); //c = pacseq[(x+z)>>2] >> ((~(x+z)&3)<<1) & 3; if (c > 3 || seq[y+z] > 3 || c != seq[y+z]) { ksprintf(str, "%d", u); kputc("ACGTN"[c], str); ++nm; u = 0; } else ++u; } } ksprintf(str, "%d", u); *_nm = nm; return strdup(str->s); }
void kputi(int i) { if (i < 10) { kputc('0' + i); return; } kputi(i / 10); kputc('0' + (i % 10)); }
/** * Gets the cigar string from a bam record */ void bam_get_cigar_expanded_string(bam1_t *s, kstring_t *cigar_expanded_string) { kstring_t cigar_string = {0,0,0}; bam_get_cigar_string(s, &cigar_string); cigar_expanded_string->l = 0; int32_t lastIndex = cigar_string.l; int32_t i = 0; kstring_t token = {0,0,0}; if (lastIndex<0) { return; } char c; bool seenM = false; while (i<=lastIndex) { c = cigar_string.s[i]; //captures the numeric count if (c<'A') { kputc(c, &token); } if (c>'A' || i==lastIndex) { //it is possible for I's to be observed before the first M's in the cigar string //in this case, we treat them as 'S' if (!seenM) { if (c=='I') { c = 'S'; } else if (c=='M') { seenM = true; } } int32_t count = atoi(token.s); for (uint32_t j=0; j<count; ++j) kputc(c, cigar_expanded_string); token.l = 0;; } ++i; } if (cigar_string.m) free(cigar_string.s); if (token.m) free(token.s); }
/* * Print a decimal value to the standard output of the kernel */ int kprintf_decimal(long long int val, int zero, int pad, int prec) { long long int q; long long int r; int ptr; int sz; int i; char *buf; /* FIXME: Support "signed" integer */ /* Calculate the maximum buffer size */ sz = 3 * sizeof(long long int); buf = alloca(sz); ptr = 0; q = val; while ( q ) { r = q % 10; q = q / 10; buf[ptr] = r + '0'; ptr++; } if ( !ptr ) { buf[ptr] = '0'; ptr++; } /* Padding */ if ( pad > prec && pad > ptr ) { for ( i = 0; i < pad - prec && i < pad - ptr ; i++ ) { if ( zero ) { kputc('0'); } else { kputc(' '); } } } /* Precision */ if ( prec > ptr ) { for ( i = 0; i < prec - ptr; i++ ) { kputc('0'); } } /* Value */ for ( i = 0; i < ptr; i++ ) { kputc(buf[ptr - i - 1]); } return 0; }
__unused static void print_tcp_payload(unsigned char * buf, int len) { int i; printf("LWIP tcp payload (%d) :\n", len); for (i = 0; i < len; i++, buf++) { printf("%02x ", buf[0]); if (i % 8 == 7) kputc('\n'); } kputc('\n'); }
/** * Returns a string representation of this Genome Interval. */ void GenomeInterval::to_string(kstring_t *interval) { interval->l = 0; kputs(seq.c_str(), interval); if (start1!=1 || end1!=((1<<29)-1)) { kputc(':', interval); kputw(start1, interval); kputc('-', interval); kputw(end1, interval); } };
/* * Put a % character with paddings to the standard output of the kernel */ int kprintf_percent(int pad) { int i; for ( i = 0; i < pad; i++ ) { kputc(' '); } kputc('%'); return 0; }
/** * Gets a string representation of the underlying VNTR by fuzzy alignment. */ void Variant::get_fuzzy_vntr_string(kstring_t* s) { s->l = 0; kputs(chrom.c_str(), s); kputc(':', s); kputw(vntr.fuzzy_beg1, s); kputc(':', s); kputs(vntr.fuzzy_repeat_tract.c_str(), s); kputc(':', s); kputs("<VNTR>", s); kputc(':', s); kputs(vntr.motif.c_str(), s); };
int kprintf(const char* fmt, ...) { va_list ap; kprintf_res = 0; unsigned long n = 0; va_start(ap, fmt); while(*fmt) { if(*fmt == '%') { switch(*++fmt) { case 's': kputs(va_arg(ap, char*)); break; case 'd': n = va_arg(ap, unsigned long int); kputn(n, 10); break; case 'o': n = va_arg(ap, unsigned long int); kputn(n, 8); break; case 'x': n = va_arg(ap, unsigned long int); kputn(n, 16); break; case '%': kputc('%'); break; case '\0': goto out; break; default: kputc('%'); kputc(*fmt); break; } } else kputc(*fmt); fmt++; }
/** * Gets a string representation of a variant. */ void bcf_variant2string(bcf_hdr_t *h, bcf1_t *v, kstring_t *var) { bcf_unpack(v, BCF_UN_STR); var->l = 0; kputs(bcf_get_chrom(h, v), var); kputc(':', var); kputw(bcf_get_pos1(v), var); kputc(':', var); for (int32_t i=0; i<v->n_allele; ++i) { if (i) kputc(',', var); kputs(bcf_get_alt(v, i), var); } }
char *bam_format1_core(const bam_header_t *header, const bam1_t *b, int of) { uint8_t *s = bam1_seq(b), *t = bam1_qual(b); int i; const bam1_core_t *c = &b->core; kstring_t str; str.l = str.m = 0; str.s = 0; ksprintf(&str, "%s\t", bam1_qname(b)); if (of == BAM_OFDEC) ksprintf(&str, "%d\t", c->flag); else if (of == BAM_OFHEX) ksprintf(&str, "0x%x\t", c->flag); else { // BAM_OFSTR for (i = 0; i < 16; ++i) if ((c->flag & 1<<i) && bam_flag2char_table[i]) kputc(bam_flag2char_table[i], &str); kputc('\t', &str); } if (c->tid < 0) kputs("*\t", &str); else ksprintf(&str, "%s\t", header->target_name[c->tid]); ksprintf(&str, "%d\t%d\t", c->pos + 1, c->qual); if (c->n_cigar == 0) kputc('*', &str); else { for (i = 0; i < c->n_cigar; ++i) ksprintf(&str, "%d%c", bam1_cigar(b)[i]>>BAM_CIGAR_SHIFT, "MIDNSHP"[bam1_cigar(b)[i]&BAM_CIGAR_MASK]); } kputc('\t', &str); if (c->mtid < 0) kputs("*\t", &str); else if (c->mtid == c->tid) kputs("=\t", &str); else ksprintf(&str, "%s\t", header->target_name[c->mtid]); ksprintf(&str, "%d\t%d\t", c->mpos + 1, c->isize); if (c->l_qseq) { for (i = 0; i < c->l_qseq; ++i) kputc(bam_nt16_rev_table[bam1_seqi(s, i)], &str); kputc('\t', &str); if (t[0] == 0xff) kputc('*', &str); else for (i = 0; i < c->l_qseq; ++i) kputc(t[i] + 33, &str); } else ksprintf(&str, "*\t*"); s = bam1_aux(b); while (s < b->data + b->data_len) { uint8_t type, key[2]; key[0] = s[0]; key[1] = s[1]; s += 2; type = *s; ++s; ksprintf(&str, "\t%c%c:", key[0], key[1]); if (type == 'A') { ksprintf(&str, "A:%c", *s); ++s; } else if (type == 'C') { ksprintf(&str, "i:%u", *s); ++s; } else if (type == 'c') { ksprintf(&str, "i:%d", *(int8_t*)s); ++s; } else if (type == 'S') { ksprintf(&str, "i:%u", *(uint16_t*)s); s += 2; } else if (type == 's') { ksprintf(&str, "i:%d", *(int16_t*)s); s += 2; } else if (type == 'I') { ksprintf(&str, "i:%u", *(uint32_t*)s); s += 4; } else if (type == 'i') { ksprintf(&str, "i:%d", *(int32_t*)s); s += 4; } else if (type == 'f') { ksprintf(&str, "f:%g", *(float*)s); s += 4; } else if (type == 'd') { ksprintf(&str, "d:%lg", *(double*)s); s += 8; } else if (type == 'Z' || type == 'H') { ksprintf(&str, "%c:", type); while (*s) kputc(*s++, &str); ++s; } } return str.s; }
/** * String version of BED record. */ std::string BEDRecord::to_string() { kstring_t s = {0,0,0}; kputs(this->chrom.c_str(), &s); kputc(':', &s); kputw(this->beg1, &s); kputc('-', &s); kputw(this->end1, &s); std::string str(s.s); if (s.m) free(s.s); return str; };
static void urldecode_kput(const char *s, int len, kstring_t *str) { char buf[3]; int i = 0; while (i < len) if (s[i] == '%' && i+2 < len) { buf[0] = s[i+1], buf[1] = s[i+2], buf[2] = '\0'; kputc(strtol(buf, NULL, 16), str); i += 3; } else kputc(s[i++], str); }
/** * Returns a string representation of this Genome Interval. */ std::string GenomeInterval::to_string() { kstring_t s = {0,0,0}; kputs(seq.c_str(), &s); if (start1!=1 || end1!=((1<<29)-1)) { kputc(':', &s); kputw(start1, &s); kputc('-', &s); kputw(end1, &s); } std::string interval(s.s); if (s.m) free(s.s); return interval; };
main() { char name[64]; int pid, cmd; char c; while(1){ color = 0x0C; printf("----------------------------------------------\n"); pid = getpid(); printf("I am proc %d in U mode: running segment=%x\n", pid, getcs()); show_menu(); printf("Command ? "); gets(name); if (name[0]==0) continue; cmd = find_cmd(name); switch(cmd){ case 0 : getpid(); break; case 1 : ps(); break; case 2 : chname(); break; case 3 : kfork(); break; case 4 : kswitch(); break; case 5 : wait(); break; case 6 : exit(); break; case 7 : c = kgetc(); putc(c); putc('\n'); putc('\r'); break; case 8 : kputc(); break; default: invalid(name); break; } } }
void print_uart0(const char *s) { while(*s != '\0') { /* Loop until end of string */ kputc( NULL, *s ); //*UART0DR = (unsigned int)(*s); /* Transmit char */ s++; /* Next char */ } }
uint64_t fm6_retrieve(const rld_t *e, uint64_t x, kstring_t *s, rldintv_t *k2, int *contained) { uint64_t k = x, ok[6]; rldintv_t ok2[6]; s->l = 0; *contained = 0; while (1) { int c = rld_rank1a(e, k + 1, ok); k = e->cnt[c] + ok[c] - 1; if (c == 0) break; if (s->l > 0) { if (k2->x[2] == 1) k2->x[0] = k; else { rld_extend(e, k2, ok2, 1); *k2 = ok2[c]; } } else fm6_set_intv(e, c, *k2); kputc(c, s); } if (k2->x[2] != 1) { rld_extend(e, k2, ok2, 1); if (ok2[0].x[2] != k2->x[2]) *contained |= 1; // left contained *k2 = ok2[0]; } else k2->x[0] = k; rld_extend(e, k2, ok2, 0); if (ok2[0].x[2] != k2->x[2]) *contained |= 2; // right contained *k2 = ok2[0]; return k; }
static char *drop_rg(char *hdtxt, rghash_t h, int *len) { char *p = hdtxt, *q, *r, *s; kstring_t str; memset(&str, 0, sizeof(kstring_t)); while (1) { int toprint = 0; q = strchr(p, '\n'); if (q == 0) q = p + strlen(p); if (q - p < 3) break; // the line is too short; then stop if (strncmp(p, "@RG\t", 4) == 0) { int c; khint_t k; if ((r = strstr(p, "\tID:")) != 0) { r += 4; for (s = r; *s != '\0' && *s != '\n' && *s != '\t'; ++s); c = *s; *s = '\0'; k = kh_get(rg, h, r); *s = c; if (k != kh_end(h)) toprint = 1; } } else toprint = 1; if (toprint) { kputsn(p, q - p, &str); kputc('\n', &str); } p = q + 1; } *len = str.l; return str.s; }
void hts_path_itr_setup(struct hts_path_itr *itr, const char *path, const char *builtin_path, const char *prefix, size_t prefix_len, const char *suffix, size_t suffix_len) { itr->prefix = prefix; itr->prefix_len = prefix_len; if (suffix) itr->suffix = suffix, itr->suffix_len = suffix_len; else itr->suffix = PLUGIN_EXT, itr->suffix_len = strlen(PLUGIN_EXT); itr->path.l = itr->path.m = 0; itr->path.s = NULL; itr->entry.l = itr->entry.m = 0; itr->entry.s = NULL; if (! builtin_path) builtin_path = PLUGINPATH; if (! path) { path = getenv("HTS_PATH"); if (! path) path = ""; } while (1) { size_t len = strcspn(path, ":"); if (len == 0) kputs(builtin_path, &itr->path); else kputsn(path, len, &itr->path); kputc(':', &itr->path); path += len; if (*path == ':') path++; else break; } // Note that ':' now terminates entries rather than separates them itr->pathdir = itr->path.s; itr->dirv = open_nextdir(itr); }
void printCounts(char *chr,int *posi,suint **counts,int nSites,size_t nInd,kstring_t &bpos,kstring_t &bbin,int dumpType,int *keepSites){ bpos.l=bbin.l=0; for(int s=0;s<nSites;s++){ if(keepSites[s]==0) continue; ksprintf(&bpos, "%s\t%d\t%d\n",chr,posi[s]+1,calcSum(counts[s],4*nInd)); //if we need per sample info if(dumpType>1) { if(dumpType==4)//count A,C,G,T for(int i=0;i<4*nInd;i++) ksprintf(&bbin,"%u\t",counts[s][i]); else if(dumpType==2){//print A+C+G+T for(int n=0;n<nInd;n++) ksprintf(&bbin,"%u\t",counts[s][n*4]+counts[s][n*4+1]+counts[s][n*4+2]+counts[s][n*4+3]); }else{//overall sum of A,C,G,T size_t tsum[4]={0,0,0,0}; for(int i=0;i<4*nInd;i++) tsum[i%4] +=counts[s][i]; ksprintf(&bbin,"%zu\t%zu\t%zu\t%zu",tsum[0],tsum[1],tsum[2],tsum[3]); } kputc('\n',&bbin); } } }
void bcf_enc_vint(kstring_t *s, int n, int32_t *a, int wsize) { int32_t max = INT32_MIN + 1, min = INT32_MAX; int i; if (n == 0) bcf_enc_size(s, 0, BCF_BT_NULL); else if (n == 1) bcf_enc_int1(s, a[0]); else { if (wsize <= 0) wsize = n; for (i = 0; i < n; ++i) { if (a[i] == INT32_MIN) continue; if (max < a[i]) max = a[i]; if (min > a[i]) min = a[i]; } if (max <= INT8_MAX && min > INT8_MIN) { bcf_enc_size(s, wsize, BCF_BT_INT8); for (i = 0; i < n; ++i) kputc(a[i] == INT32_MIN? INT8_MIN : a[i], s); } else if (max <= INT16_MAX && min > INT16_MIN) { bcf_enc_size(s, wsize, BCF_BT_INT16); for (i = 0; i < n; ++i) { int16_t x = a[i] == INT32_MIN? INT16_MIN : a[i]; kputsn((char*)&x, 2, s); } } else { bcf_enc_size(s, wsize, BCF_BT_INT32); for (i = 0; i < n; ++i) { int32_t x = a[i] == INT32_MIN? INT32_MIN : a[i]; kputsn((char*)&x, 4, s); } } } }
// Expands a output filename format string static char* expand_format_string(const char* format_string, const char* basename, const char* rg_id, const int rg_idx) { kstring_t str = { 0, 0, NULL }; const char* pointer = format_string; const char* next; while ((next = strchr(pointer, '%')) != NULL) { kputsn(pointer, next-pointer, &str); ++next; switch (*next) { case '%': kputc('%', &str); break; case '*': kputs(basename, &str); break; case '#': kputl(rg_idx, &str); break; case '!': kputs(rg_id, &str); break; case '\0': // Error is: fprintf(pysamerr, "bad format string, trailing %%\n"); free(str.s); return NULL; default: // Error is: fprintf(pysamerr, "bad format string, unknown format specifier\n"); free(str.s); return NULL; } pointer = next + 1; } kputs(pointer, &str); return ks_release(&str); }
int vcf_dictread(bcf_t *bp, bcf_hdr_t *h, const char *fn) { vcf_t *v; gzFile fp; kstream_t *ks; kstring_t s, rn; int dret; if (bp == 0) return -1; if (!bp->is_vcf) return 0; s.l = s.m = 0; s.s = 0; rn.m = rn.l = h->l_nm; rn.s = h->name; v = (vcf_t*)bp->v; fp = gzopen(fn, "r"); ks = ks_init(fp); while (ks_getuntil(ks, 0, &s, &dret) >= 0) { bcf_str2id_add(v->refhash, strdup(s.s)); kputs(s.s, &rn); kputc('\0', &rn); if (dret != '\n') ks_getuntil(ks, '\n', &s, &dret); } ks_destroy(ks); gzclose(fp); h->l_nm = rn.l; h->name = rn.s; bcf_hdr_sync(h); free(s.s); return 0; }
static void write_seq(const kseq_t *seq, kstring_t *out) { kputc(seq->qual.l? '@' : '>', out); kputsn(seq->name.s, seq->name.l, out); if (seq->comment.l) { kputc(' ', out); kputsn(seq->comment.s, seq->comment.l, out); } kputc('\n', out); kputsn(seq->seq.s, seq->seq.l, out); if (seq->qual.l) { kputsn("\n+\n", 3, out); kputsn(seq->qual.s, seq->qual.l, out); } kputc('\n', out); }
void kprintf(char* format, ...) { register char* f = format; register char** varg = (&format) + 7; // Why 7? I don't know, it just works while (*f) { if (*f == '%') { char buf[64]; f++; if (*f == 's') { kprint(*varg); varg += 1; } else if (*f == 'd') { itoa(*((int*) varg), buf, 10); kprint(buf); varg += sizeof(int); } else if (*f == 'x') { itoa(*((int*) varg), buf, 16); kprint(buf); varg += sizeof(int); } } else { kputc(*f); } f++; } }