int insert_position_read(char key[64], vcf_record_file_link* link, kh_pos_t* positions_read) {
int ret;
array_list_t *records_in_position;
khiter_t iter = kh_get(pos, positions_read, key);
if (iter != kh_end(positions_read)) {
records_in_position = kh_value(positions_read, iter);
ret = array_list_insert(link, records_in_position);
} else {
records_in_position = array_list_new(8, 1.5, COLLECTION_MODE_SYNCHRONIZED);
ret = array_list_insert(link, records_in_position);
iter = kh_put(pos, positions_read, strdup(key), &ret);
if (ret) {
kh_value(positions_read, iter) = records_in_position;
}
}
return ret;
}
mrb_value
mrb_hash_get(mrb_state *mrb, mrb_value hash, mrb_value key)
{
khash_t(ht) *h = RHASH_TBL(hash);
khiter_t k;
if (h) {
k = kh_get(ht, h, key);
if (k != kh_end(h))
return kh_value(h, k);
}
/* not found */
if (MRB_RHASH_PROCDEFAULT_P(hash)) {
return mrb_funcall(mrb, RHASH_PROCDEFAULT(hash), "call", 2, hash, key);
}
return RHASH_IFNONE(hash);
}
static mrb_value
mrb_hash_values(mrb_state *mrb, mrb_value hash)
{
khash_t(ht) *h = RHASH_TBL(hash);
khiter_t k;
mrb_value ary = mrb_ary_new(mrb);
if (!h) return ary;
for (k = kh_begin(h); k != kh_end(h); k++) {
if (kh_exist(h, k)){
mrb_value v = kh_value(h,k);
if ( !mrb_special_const_p(v) )
v = mrb_obj_dup(mrb, v);
mrb_ary_push(mrb, ary, v);
}
}
return ary;
}
static mrb_value
mrb_hash_has_valueWithvalue(mrb_state *mrb, mrb_value hash, mrb_value value)
{
khash_t(ht) *h = RHASH_TBL(hash);
khiter_t k;
if (h) {
for (k = kh_begin(h); k != kh_end(h); k++) {
if (!kh_exist(h, k)) continue;
if (mrb_equal(mrb, kh_value(h,k), value)) {
return mrb_true_value();
}
}
}
return mrb_false_value();
}
static int ucm_malloc_mmaped_ptr_remove_if_exists(void *ptr)
{
khiter_t hash_it;
int found;
ucs_spin_lock(&ucm_malloc_hook_state.lock);
hash_it = kh_get(mmap_ptrs, &ucm_malloc_hook_state.ptrs, ptr);
if (hash_it == kh_end(&ucm_malloc_hook_state.ptrs)) {
found = 0;
} else {
found = 1;
kh_del(mmap_ptrs, &ucm_malloc_hook_state.ptrs, hash_it);
}
ucs_spin_unlock(&ucm_malloc_hook_state.lock);
return found;
}
MRB_API mrb_value
mrb_hash_values(mrb_state *mrb, mrb_value hash)
{
khash_t(ht) *h = RHASH_TBL(hash);
khiter_t k;
mrb_value ary;
if (!h) return mrb_ary_new(mrb);
ary = mrb_ary_new_capa(mrb, kh_size(h));
for (k = kh_begin(h); k != kh_end(h); k++) {
if (kh_exist(h, k)) {
mrb_hash_value hv = kh_value(h, k);
mrb_ary_set(mrb, ary, hv.n, hv.v);
}
}
return ary;
}
SR_Status SR_LibInfoTableGetRGIndex(int32_t* pReadGrpIndex, const SR_LibInfoTable* pTable, const char* pReadGrpName)
{
*pReadGrpIndex = 0;
khash_t(name)* pRgHash = pTable->pReadGrpHash;
khiter_t khIter = kh_get(name, pRgHash, pReadGrpName);
if (khIter != kh_end(pRgHash))
{
*pReadGrpIndex = kh_value(pRgHash, khIter);
}
else
{
SR_ErrMsg("ERROR: Found a read group name that is not recorded in the library information table.\n");
return SR_ERR;
}
return SR_OK;
}
int start(int id)
{
khint_t key = kh_get(m32, states, id);
if (key != kh_end(states))
{
struct instance* inst = kh_val(states, key);
printf("Starting script: %s\n", inst->path);
if (luaL_dofile(inst->state, inst->path))
{
return 0;
}
return 1;
}
else
{
return 0;
}
}
/*
* call-seq:
* obj.instance_variable_defined?(symbol) -> true or false
*
* Returns <code>true</code> if the given instance variable is
* defined in <i>obj</i>.
*
* class Fred
* def initialize(p1, p2)
* @a, @b = p1, p2
* end
* end
* fred = Fred.new('cat', 99)
* fred.instance_variable_defined?(:@a) #=> true
* fred.instance_variable_defined?("@b") #=> true
* fred.instance_variable_defined?("@c") #=> false
*/
mrb_value
mrb_obj_ivar_defined(mrb_state *mrb, mrb_value self)
{
mrb_value arg;
khiter_t k;
kh_iv_t *h = RCLASS_IV_TBL(self);
mrb_get_args(mrb, "o", &arg);
mrb_sym mid = mrb_to_id(mrb, arg);
if (h) {
k = kh_get(iv, h, mid);
if (k != kh_end(h)) {
return mrb_true_value();
}
}
return mrb_false_value();
}
static bam_header_t *hash2header(const kh_ref_t *hash)
{
bam_header_t *header;
khiter_t k;
header = bam_header_init();
header->n_targets = kh_size(hash);
header->target_name = (char**)calloc(kh_size(hash), sizeof(char*));
header->target_len = (uint32_t*)calloc(kh_size(hash), 4);
for (k = kh_begin(hash); k != kh_end(hash); ++k) {
if (kh_exist(hash, k)) {
int i = (int)kh_value(hash, k);
header->target_name[i] = (char*)kh_key(hash, k);
header->target_len[i] = kh_value(hash, k)>>32;
}
}
bam_init_header_hash(header);
return header;
}
static void
remove_method(mrb_state *mrb, mrb_value mod, mrb_sym mid)
{
struct RClass *c = mrb_class_ptr(mod);
khash_t(mt) *h = c->mt;
khiter_t k;
if (h) {
k = kh_get(mt, h, mid);
if (k != kh_end(h)) {
kh_del(mt, h, k);
return;
}
}
mrb_name_error(mrb, mid, "method `%S' not defined in %S",
mrb_sym2str(mrb, mid), mod);
}
bntseq_t *bns_restore(const char *prefix)
{
char ann_filename[1024], amb_filename[1024], pac_filename[1024], alt_filename[1024];
FILE *fp;
bntseq_t *bns;
/**** bisulfite adaptation ****/
/* strcat(strcpy(ann_filename, prefix), ".ann"); */
/* strcat(strcpy(amb_filename, prefix), ".amb"); */
/* strcat(strcpy(pac_filename, prefix), ".pac"); */
strcat(strcpy(ann_filename, prefix), ".bis.ann");
strcat(strcpy(amb_filename, prefix), ".bis.amb");
strcat(strcpy(pac_filename, prefix), ".bis.pac");
bns = bns_restore_core(ann_filename, amb_filename, pac_filename);
if (bns == 0) return 0;
if ((fp = fopen(strcat(strcpy(alt_filename, prefix), ".alt"), "r")) != 0) { // read .alt file if present
char str[1024];
khash_t(str) *h;
int c, i, absent;
khint_t k;
h = kh_init(str);
for (i = 0; i < bns->n_seqs; ++i) {
k = kh_put(str, h, bns->anns[i].name, &absent);
kh_val(h, k) = i;
}
i = 0;
while ((c = fgetc(fp)) != EOF) {
if (c == '\t' || c == '\n' || c == '\r') {
str[i] = 0;
if (str[0] != '@') {
k = kh_get(str, h, str);
if (k != kh_end(h))
bns->anns[kh_val(h, k)].is_alt = 1;
}
while (c != '\n' && c != EOF) c = fgetc(fp);
i = 0;
} else str[i++] = c; // FIXME: potential segfault here
}
kh_destroy(str, h);
fclose(fp);
}
return bns;
}
void
mrb_hash_set(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value val) /* mrb_hash_aset */
{
khash_t(ht) *h;
khiter_t k;
mrb_hash_modify(mrb, hash);
h = RHASH_TBL(hash);
k = kh_get(ht, h, key);
if (k == kh_end(h)) {
/* expand */
k = kh_put(ht, h, KEY(key));
}
kh_value(h, k) = val;
mrb_write_barrier(mrb, (struct RBasic*)RHASH(hash));
return;
}
/* lenp must be a pointer to a size_t variable */
const char*
mrb_sym2name_len(mrb_state *mrb, mrb_sym sym, size_t *lenp)
{
khash_t(n2s) *h = mrb->name2sym;
khiter_t k;
symbol_name sname;
for (k = kh_begin(h); k != kh_end(h); k++) {
if (kh_exist(h, k)) {
if (kh_value(h, k) == sym) {
sname = kh_key(h, k);
*lenp = sname.len;
return sname.name;
}
}
}
*lenp = 0;
return NULL; /* missing */
}
void
int_htable_destroy(int_htable *ht)
{
khiter_t k;
if (!ht) {
return;
}
for (k = kh_begin(sh->htable); k != kh_end(ht->htable); ++k) {
if (kh_exist(ht->htable, k)) {
if (ht->free_value_fn) {
ht->free_value_fn(kh_value(ht->htable,k));
}
}
}
kh_destroy(int, ht->htable);
free(ht);
}
mrb_value
mrb_check_intern(mrb_state *mrb, const char *name, size_t len)
{
khash_t(n2s) *h = mrb->name2sym;
symbol_name sname;
khiter_t k;
if (len > UINT16_MAX) {
mrb_raise(mrb, E_ARGUMENT_ERROR, "symbol length too long");
}
sname.len = len;
sname.name = name;
k = kh_get(n2s, mrb, h, sname);
if (k != kh_end(h)) {
return mrb_symbol_value(kh_value(h, k));
}
return mrb_nil_value();
}
int merge_interval(kh_pos_t* positions_read, char *max_chromosome_merged, unsigned long max_position_merged,
char **chromosome_order, int num_chromosomes, vcf_file_t **files,
shared_options_data_t *shared_options_data, merge_options_data_t *options_data, list_t *output_list) {
int num_entries = 0;
#pragma omp parallel for num_threads(shared_options_data->num_threads) reduction(+:num_entries)
for (int k = kh_begin(positions_read); k < kh_end(positions_read); k++) {
if (kh_exist(positions_read, k)) {
array_list_t *records_in_position = kh_value(positions_read, k);
assert(records_in_position);
vcf_record_t *record = ((vcf_record_file_link*) array_list_get(0, records_in_position))->record;
vcf_record_file_link **links = NULL;
int num_links = 0;
// Remove positions prior to the last chromosome:position to merge
int cmp_chrom = compare_chromosomes(record->chromosome, max_chromosome_merged, chromosome_order, num_chromosomes);
if (cmp_chrom < 0 || (cmp_chrom == 0 && compare_positions(record->position, max_position_merged) <= 0)) {
links = records_in_position->items;
num_links = records_in_position->size;
}
// Launch merge
if (num_links > 0) {
// printf("links[0] = %s:%ld in file %s\n", links[0]->record->chromosome, links[0]->record->position, links[0]->file->filename);
int err_code = 0;
vcf_record_t *merged = merge_position(links, num_links, files, options_data->num_files, options_data, &err_code);
if (!err_code) {
list_item_t *item = list_item_new(k, MERGED_RECORD, merged);
list_insert_item(item, output_list);
num_entries += 1;
}
// Free empty nodes (lists of records in the same position)
array_list_free(records_in_position, vcf_record_file_link_free);
kh_del(pos, positions_read, k);
}
} // End kh_exist
}
return num_entries;
}
mrb_value
mrb_hash_delete_key(mrb_state *mrb, mrb_value hash, mrb_value key)
{
khash_t(ht) *h = RHASH_TBL(hash);
khiter_t k;
mrb_value delVal;
if (h) {
k = kh_get(ht, mrb, h, key);
if (k != kh_end(h)) {
delVal = kh_value(h, k);
kh_del(ht, mrb, h, k);
return delVal;
}
}
/* not found */
return mrb_nil_value();
}
static mrb_sym
sym_intern(mrb_state *mrb, const char *name, size_t len, mrb_bool lit)
{
khash_t(n2s) *h = mrb->name2sym;
symbol_name *sname = mrb->symtbl; /* symtbl[0] for working memory */
khiter_t k;
mrb_sym sym;
char *p;
sym_validate_len(mrb, len);
if (sname) {
sname->lit = lit;
sname->len = (uint16_t)len;
sname->name = name;
k = kh_get(n2s, mrb, h, 0);
if (k != kh_end(h))
return kh_key(h, k);
}
/* registering a new symbol */
sym = ++mrb->symidx;
if (mrb->symcapa < sym) {
if (mrb->symcapa == 0) mrb->symcapa = 100;
else mrb->symcapa = (size_t)(mrb->symcapa * 1.2);
mrb->symtbl = (symbol_name*)mrb_realloc(mrb, mrb->symtbl, sizeof(symbol_name)*(mrb->symcapa+1));
}
sname = &mrb->symtbl[sym];
sname->len = (uint16_t)len;
if (lit || mrb_ro_data_p(name)) {
sname->name = name;
sname->lit = TRUE;
}
else {
p = (char *)mrb_malloc(mrb, len+1);
memcpy(p, name, len);
p[len] = 0;
sname->name = (const char*)p;
sname->lit = FALSE;
}
kh_put(n2s, mrb, h, sym);
return sym;
}
void h2o_cache_delete(h2o_cache_t *cache, uint64_t now, h2o_iovec_t key, h2o_cache_hashcode_t keyhash)
{
h2o_cache_ref_t search_key;
khiter_t iter;
if (keyhash == 0)
keyhash = h2o_cache_calchash(key.base, key.len);
search_key.key = key;
search_key.keyhash = keyhash;
lock_cache(cache);
purge(cache, now);
if ((iter = kh_get(cache, cache->table, &search_key)) != kh_end(cache->table))
erase_ref(cache, iter, 0);
unlock_cache(cache);
}
void bcf_hdr_destroy(bcf_hdr_t *h)
{
int i;
khint_t k;
for (i = 0; i < 3; ++i) {
vdict_t *d = (vdict_t*)h->dict[i];
if (d == 0) continue;
for (k = kh_begin(d); k != kh_end(d); ++k)
if (kh_exist(d, k)) free((char*)kh_key(d, k));
kh_destroy(vdict, d);
free(h->id[i]);
}
for (i=0; i<h->nhrec; i++)
bcf_hrec_destroy(h->hrec[i]);
if (h->nhrec) free(h->hrec);
if (h->samples) free(h->samples);
free(h->mem.s); free(h->text);
free(h);
}
static int
add_to_include_set(struct bitmap *base, struct commit *commit)
{
khiter_t hash_pos;
uint32_t bitmap_pos = find_object_pos(commit->object.sha1);
if (bitmap_get(base, bitmap_pos))
return 0;
hash_pos = kh_get_sha1(writer.bitmaps, commit->object.sha1);
if (hash_pos < kh_end(writer.bitmaps)) {
struct bitmapped_commit *bc = kh_value(writer.bitmaps, hash_pos);
bitmap_or_ewah(base, bc->bitmap);
return 0;
}
bitmap_set(base, bitmap_pos);
return 1;
}
int forwardIndexTokenFunc(void *ctx, Token t) {
ForwardIndex *idx = ctx;
// we hash the string ourselves because khash suckz azz
u_int32_t hval = fnv_32a_buf((void *)t.s, t.len, 0);
ForwardIndexEntry *h = NULL;
khiter_t k = kh_get(32, idx->hits, hval); // first have to get ieter
if (k == kh_end(idx->hits)) { // k will be equal to kh_end if key not present
h = calloc(1, sizeof(ForwardIndexEntry));
h->docId = idx->docId;
h->flags = 0;
h->term = t.s;
h->len = t.len;
h->vw = NewVarintVectorWriter(4);
h->docScore = idx->docScore;
int ret;
k = kh_put(32, idx->hits, hval, &ret);
kh_value(idx->hits, k) = h;
} else {
h = kh_val(idx->hits, k);
}
h->flags |= (t.fieldId & 0xff);
float score = (float)t.score;
// stem tokens get lower score
if (t.type == DT_STEM) {
score *= STEM_TOKEN_FACTOR;
}
h->freq += score;
idx->totalFreq += (float)t.score;
idx->maxFreq = MAX(h->freq, idx->maxFreq);
VVW_Write(h->vw, t.pos);
// LG_DEBUG("%d) %s, token freq: %f total freq: %f\n", t.pos, t.s, h->freq, idx->totalFreq);
return 0;
}
static mrb_bool
iv_foreach(mrb_state *mrb, iv_tbl *t, iv_foreach_func *func, void *p)
{
khash_t(iv) *h = &t->h;
khiter_t k;
int n;
if (h) {
for (k = kh_begin(h); k != kh_end(h); k++) {
if (kh_exist(h, k)) {
n = (*func)(mrb, kh_key(h, k), kh_value(h, k), p);
if (n > 0) return FALSE;
if (n < 0) {
kh_del(iv, h, k);
}
}
}
}
return TRUE;
}
//
// Plugin Interface
//
static void* begin_call(int id, const char* name)
{
khint_t key = kh_get(m32, states, id);
if (key != kh_end(states))
{
// TODO: Keep track of which functions have been registered
struct instance* inst = kh_val(states, key);
struct call_info *info = call_info_init(inst->state, name);
// Push the function to call onto the lua stack
lua_getglobal(inst->state, name);
info->n_args++;
// Push our call_info onto our callstack
kv_push(struct call_info*, inst->callstack, info);
return inst;
}
else
{
return 0;
static pic_value
pic_dict_dictionary_for_each(pic_state *pic)
{
struct pic_proc *proc;
struct pic_dict *dict;
khiter_t it;
khash_t(dict) *kh;
pic_get_args(pic, "ld", &proc, &dict);
kh = &dict->hash;
for (it = kh_begin(kh); it != kh_end(kh); ++it) {
if (kh_exist(kh, it)) {
pic_apply1(pic, proc, pic_obj_value(kh_key(kh, it)));
}
}
return pic_undef_value();
}
MRB_API mrb_value
mrb_hash_get(mrb_state *mrb, mrb_value hash, mrb_value key)
{
khash_t(ht) *h = RHASH_TBL(hash);
khiter_t k;
mrb_sym mid;
if (h) {
k = kh_get(ht, mrb, h, key);
if (k != kh_end(h))
return kh_value(h, k).v;
}
mid = mrb_intern_lit(mrb, "default");
if (mrb_func_basic_p(mrb, hash, mid, mrb_hash_default)) {
return hash_default(mrb, hash, key);
}
/* xxx mrb_funcall_tailcall(mrb, hash, "default", 1, key); */
return mrb_funcall_argv(mrb, hash, mid, 1, &key);
}
// Returns 0 to indicate read should be output 1 otherwise
static int process_aln(const bam_hdr_t *h, bam1_t *b, samview_settings_t* settings)
{
if (settings->remove_B) bam_remove_B(b);
if (settings->min_qlen > 0) {
int k, qlen = 0;
uint32_t *cigar = bam_get_cigar(b);
for (k = 0; k < b->core.n_cigar; ++k)
if ((bam_cigar_type(bam_cigar_op(cigar[k]))&1) || bam_cigar_op(cigar[k]) == BAM_CHARD_CLIP)
qlen += bam_cigar_oplen(cigar[k]);
if (qlen < settings->min_qlen) return 1;
}
if (b->core.qual < settings->min_mapQ || ((b->core.flag & settings->flag_on) != settings->flag_on) || (b->core.flag & settings->flag_off))
return 1;
if (settings->bed && (b->core.tid < 0 || !bed_overlap(settings->bed, h->target_name[b->core.tid], b->core.pos, bam_endpos(b))))
return 1;
if (settings->subsam_frac > 0.) {
uint32_t k = __ac_Wang_hash(__ac_X31_hash_string(bam_get_qname(b)) ^ settings->subsam_seed);
if ((double)(k&0xffffff) / 0x1000000 >= settings->subsam_frac) return 1;
}
if (settings->rghash) {
uint8_t *s = bam_aux_get(b, "RG");
if (s) {
khint_t k = kh_get(rg, settings->rghash, (char*)(s + 1));
if (k == kh_end(settings->rghash)) return 1;
}
}
if (settings->library) {
const char *p = bam_get_library((bam_hdr_t*)h, b);
if (!p || strcmp(p, settings->library) != 0) return 1;
}
if (settings->remove_aux_len) {
size_t i;
for (i = 0; i < settings->remove_aux_len; ++i) {
uint8_t *s = bam_aux_get(b, settings->remove_aux[i]);
if (s) {
bam_aux_del(b, s);
}
}
}
return 0;
}
static mrb_value
mrb_hash_has_value(mrb_state *mrb, mrb_value hash)
{
mrb_value val;
khash_t(ht) *h;
khiter_t k;
mrb_get_args(mrb, "o", &val);
h = RHASH_TBL(hash);
if (h) {
for (k = kh_begin(h); k != kh_end(h); k++) {
if (!kh_exist(h, k)) continue;
if (mrb_equal(mrb, kh_value(h, k).v, val)) {
return mrb_true_value();
}
}
}
return mrb_false_value();
}
mrb_value
mrb_hash_keys(mrb_state *mrb, mrb_value hash)
{
khash_t(ht) *h = RHASH_TBL(hash);
khiter_t k;
mrb_value ary, *p;
if (!h || kh_size(h) == 0) return mrb_ary_new(mrb);
ary = mrb_ary_new_capa(mrb, kh_size(h));
mrb_ary_set(mrb, ary, kh_size(h)-1, mrb_nil_value());
p = RARRAY_PTR(ary);
for (k = kh_begin(h); k != kh_end(h); k++) {
if (kh_exist(h, k)) {
mrb_value kv = kh_key(h,k);
mrb_hash_value hv = kh_value(h,k);
p[hv.n] = kv;
}
}
return ary;
}
