void addToIntTable(char *sname, int *val) {
struct intVartable *s;
HASH_FIND_STR(itable, sname, s);
if(CDG_Module==1){
if (s == NULL) {
s = (struct intVartable *)malloc(sizeof(struct intVartable));
s->sname = (char *)malloc(sizeof(char) * (strlen(sname) + 1));
strcpy(s->sname, sname);
HASH_ADD_STR(itable, sname, s);
s->value = val;
}
}
else
{
if (s == NULL) {
s = (struct intVartable *)malloc(sizeof(struct intVartable));
s->sname = (char *)malloc(sizeof(char) * (strlen(sname) + 1));
strcpy(s->sname, sname);
HASH_ADD_STR(itable, sname, s);
s->value = val;
}
if(noInsertionInTables == 0)
s->value = val;
}
//printf("Added to int table: %s val: %d\n", sname,(s->value));
}
void tree_insert_model( const char* name,
const char* prototype,
av_interface_t interface,
const char* parent_name )
{
assert(name);
if( _tree == NULL ) // i.e. nothing in the tree yet
{
// set up the root node for the sim itself
bzero(&_root,sizeof(_root));
strncpy(_root.id,"sim",strlen("sim"));
strncpy(_root.prototype, _root.id, strlen(_root.id));
_root.interface = AV_INTERFACE_SIM;
utarray_new( _root.children, &ut_str_icd ); // initialize string array
_av_node_t* rootp = &_root; // macro needs a pointer arg
HASH_ADD_STR( _tree, id, rootp );
}
assert( name && strlen(name) < NAME_LEN_MAX );
assert( parent_name == NULL || strlen(parent_name) < NAME_LEN_MAX );
// insert this new node into the tree
_av_node_t *node = malloc( sizeof(_av_node_t));
assert(node);
bzero(node,sizeof(_av_node_t));
strncpy(node->id,name,NAME_LEN_MAX);
node->interface = interface;
strncpy( node->prototype, prototype, strlen(prototype));
utarray_new( node->children, &ut_str_icd ); // initialize string array
// add the node to the tree, keyed on the name
HASH_ADD_STR( _tree, id, node );
// did something happen?
assert( _tree != NULL );
// add the child to the parent
_av_node_t *parent_node = NULL;
if( parent_name )
HASH_FIND_STR( _tree, parent_name, parent_node );
else
parent_node = &_root;
assert( parent_node );
utarray_push_back( parent_node->children, &name );
}
void InitStoplistConfig()
{
char *stoplist_path = Config("STOPLIST");
if (stoplist_path == NULL) {
return;
}
FILE *fp = fopen(stoplist_path, "rb");
if (fp == NULL) {
fprintf(stderr, "Unable to load stoplist: %s\n", stoplist_path);
return;
}
char term[TERM_MAX_LEN+1];
for (;;) {
if (fscanf(fp, "%s\n", term) < 1) break;
strToLower(term);
Stem(term);
Stopword *newStopword;
HASH_FIND_STR(stoplist, term, newStopword);
if (newStopword == NULL) {
newStopword = malloc(sizeof(Stopword));
strcpy(newStopword->t, term);
HASH_ADD_STR(stoplist, t, newStopword);
}
}
fclose(fp);
}
int tokenset_add( struct tokenset *p, char *n )
{
struct _token *s;
HASH_FIND_STR( p->tokens, n, s );
if ( !_IS_NULL( s ) )
return s->id;
s = ( struct _token * ) malloc( sizeof ( struct _token ) );
s->text = malloc( ( 1 + strlen( n ) ) * sizeof ( char ) );
strcpy( s->text, n );
s->id = p->count;
#if 0
HASH_ADD_STR( p->tokens, text, s );
#else
HASH_ADD_KEYPTR( hh, p->tokens, s->text, strlen( s->text ), s );
#endif
p->count += 1; /* ready to map next entry */
return s->id;
}
// internal function to insert a pair to the hash table
static void add_hash_entry(const char* function_name, funcPointerT fpt)
{
ns_t * s;
s =malloc (sizeof(ns_t));
if (!s)
{
printf("Fatal error: add_hash_entry() malloc() for s failed!\n");
assert(0);
}
#if 0
if ((s->func_name=malloc(strlen(function_name)+1)) == NULL)
{
printf("Fatal error: add_hash_entry() malloc() for s->func_name failed!\n");
assert(0);
}
else
#endif
{
strcpy(s->func_name, function_name);
s->fp = fpt;
// HASH_ADD_INT(entries, func_name,s);
HASH_ADD_STR(entries, func_name,s);
}
}
int fillSizes(char *sizes)
/**
* Fills the hash table of chrom sizes
*
*
*
*/
{
struct lineFile *lf;
lf = lineFileOpen(sizes,TRUE);
char *line;
struct sizes_hash *s;
while(lineFileNextReal(lf,&line)){
char *split[2];
chopByWhite(line,split,2);
s = malloc(sizeof(struct sizes_hash));
strcpy(s->name, split[0]);
s->length = atoi(split[1]);
int i;
for(i=0;i<NUMSAMPLES;i++)
s->numHets[i] = 0;
HASH_ADD_STR(chrSizes,name,s);
}
return 0;
}
/*
* indexes a word, calling other functions to check and add to hashtable
* returns 1 on success, otherwise it returns 0
*/
int indexWord( char *key, char *filename ) {
if( key == NULL || filename == NULL ) { // ya dun gooffed
return 0;
}
TokenPtr word, search;
HASH_FIND_STR(words, key, search);
// if the word exists in the hash table, check its fileNodes
if ( search ) {
// shouldn't happen in current implementation
if ( search -> fileHead == NULL ) {
addFileNode( search, filename );
} else if ( !strcmp(filename, (search->fileHead->filename)) ) { // file already exists for word
search->fileHead->tokenCount++;
} else { // file doesn't exist for word
addFileNode( search, filename );
}
} else { // word doesn't exist in the hashtable, create new word and file
if ( (word = (TokenPtr) malloc(sizeof(struct Token))) == NULL ) exit(-1);
char *newKey = (char *) malloc(sizeof(char) * strlen(key));
strcpy(newKey, key);
word -> key = newKey;
word -> fileHead = NULL;
HASH_ADD_STR( words, key, word );
addFileNode( word, filename );
}
return 1;
}
void update_timer( char *key, double value ) {
syslog(LOG_DEBUG, "update_timer ( %s, %f )\n", key, value);
statsd_timer_t *t;
syslog(LOG_DEBUG, "HASH_FIND_STR '%s'\n", key);
HASH_FIND_STR( timers, key, t );
syslog(LOG_DEBUG, "after HASH_FIND_STR '%s'\n", key);
if (t) {
syslog(LOG_DEBUG, "Updating old timer entry");
wait_for_timers_lock();
utarray_push_back(t->values, &value);
t->count++;
remove_timers_lock();
} else {
syslog(LOG_DEBUG, "Adding new timer entry");
t = malloc(sizeof(statsd_timer_t));
strcpy(t->key, key);
t->count = 0;
utarray_new(t->values, &timers_icd);
utarray_push_back(t->values, &value);
t->count++;
wait_for_timers_lock();
HASH_ADD_STR( timers, key, t );
remove_timers_lock();
}
}
int main(int argc,char *argv[])
{
name_rec *name, *names=NULL;
char linebuf[BUFLEN];
FILE *file;
file = fopen( "test11.dat", "r" );
if (file == NULL) {
perror("can't open: ");
exit(-1);
}
while (fgets(linebuf,BUFLEN,file) != NULL) {
name = (name_rec*)malloc(sizeof(name_rec));
if (name == NULL) {
exit(-1);
}
strcpy(name->boy_name, linebuf);
HASH_ADD_STR(names,boy_name,name);
}
fclose(file);
HASH_SORT(names,namecmp);
for(name=names; name!=NULL; name=(name_rec*)(name->hh.next)) {
printf("%s",name->boy_name);
}
return 0;
}
int main(int argc,char *argv[]) {
name_rec *name, *names=NULL;
char linebuf[BUFLEN];
FILE *file;
int i=0,j=0;
if ( (file = fopen( "test14.dat", "r" )) == NULL ) {
perror("can't open: ");
exit(-1);
}
while (fgets(linebuf,BUFLEN,file) != NULL) {
i++;
if ( (name = (name_rec*)malloc(sizeof(name_rec))) == NULL) exit(-1);
strncpy(name->boy_name,linebuf,BUFLEN);
HASH_ADD_STR(names,boy_name,name);
}
fseek(file,0,SEEK_SET);
while (fgets(linebuf,BUFLEN,file) != NULL) {
HASH_FIND_STR(names,linebuf,name);
if (!name) printf("failed to find: %s", linebuf);
else j++;
}
fclose(file);
printf("lookup on %d of %d names succeeded\n", j, i);
return 0;
}
int main(int argc, char*argv[]) {
person_t *people=NULL, *person;
const char **name;
const char * names[] = { "bob", "jack", "gary", "ty", "bo", "phil", "art",
"gil", "buck", "ted", NULL };
int id=0;
for(name=names; *name; name++) {
if ( (person = (person_t*)malloc(sizeof(person_t))) == NULL) exit(-1);
strncpy(person->first_name, *name,10);
person->id = id++;
HASH_ADD_STR(people,first_name,person);
printf("added %s (id %d)\n", person->first_name, person->id);
}
person=NULL;
person_t **p=&person;
for(name=names; *name; name++) {
HASH_FIND_STR(people,*name,*p);
if (person)
printf("found %s (id %d)\n", person->first_name, person->id);
else
printf("failed to find %s\n", *name);
}
return 0;
}
void del_vnameHash(char* key){
vnameHash* v;
HASH_FIND_STR(vnames, key, v);
if(v != NULL){
int occ;
char find = '_';
const char *ptr = strrchr(v->vname_occ, find);
if(ptr) {
int i = strlen(v->vname_occ);
int s = ptr - v->vname_occ + 1;
char *occStr = (char*) malloc(sizeof(char)*(i-s+1));
strncpy(occStr, v->vname_occ + s, i-s);
occ = atoi(occStr);
if(occ == 0){
HASH_DEL( vnames, v);
printf("Old Hash: %s\n", v->vname_occ);
}
else{
printf("Old Hash: %s\n", v->vname_occ);
occ--;
char* newVarname_occ = (char*) malloc(sizeof(char)*(s+5));
strncpy(newVarname_occ, v->vname_occ, s);
char tmp[5];
sprintf(tmp,"%d",occ);
strcat(newVarname_occ,tmp);
HASH_DEL( vnames, v);
vnameHash* vnew = (vnameHash*)malloc(sizeof(vnameHash));
strcpy(vnew->vname_occ,newVarname_occ);
strcpy(vnew->vname,key);
printf("New Hash: %s\n", vnew->vname_occ);
HASH_ADD_STR(vnames, vname, vnew);
}
}
}
}
int MPIR_Comm_register_hint(const char *hint_key, MPIR_Comm_hint_fn_t fn, void *state)
{
int mpi_errno = MPI_SUCCESS;
struct MPIR_Comm_hint_fn_elt *hint_elt = NULL;
MPID_MPI_STATE_DECL(MPID_STATE_MPIR_COMM_REGISTER_HINT);
MPID_MPI_FUNC_ENTER(MPID_STATE_MPIR_COMM_REGISTER_HINT);
if (MPID_hint_fns == NULL) {
MPIR_Add_finalize(free_hint_handles, NULL, MPIR_FINALIZE_CALLBACK_PRIO - 1);
}
hint_elt = MPIU_Malloc(sizeof(struct MPIR_Comm_hint_fn_elt));
strncpy(hint_elt->name, hint_key, MPI_MAX_INFO_KEY);
hint_elt->state = state;
hint_elt->fn = fn;
HASH_ADD_STR(MPID_hint_fns, name, hint_elt);
fn_exit:
MPID_MPI_FUNC_EXIT(MPID_STATE_MPIR_COMM_REGISTER_HINT);
return mpi_errno;
fn_fail:
goto fn_exit;
}
int main(int argc,char *argv[])
{
name_rec *name, *names=NULL;
char linebuf[BUFLEN];
FILE *file;
int i=0;
if (argc != 2) {
fprintf(stderr,"usage: %s file\n", argv[0]);
exit(-1);
}
if ( (file = fopen( argv[1], "r" )) == NULL ) {
perror("can't open: ");
exit(-1);
}
while (fgets(linebuf,BUFLEN,file) != NULL) {
name = (name_rec*)malloc(sizeof(name_rec));
if (name == NULL) {
exit(-1);
}
strcpy(name->boy_name, linebuf);
HASH_ADD_STR(names,boy_name,name);
i++;
}
fprintf(stderr,"%d keys emitted.\n", i);
fclose(file);
return 0;
}
void add_node(struct Node *fileNode, void *token){
struct hash *h;
int toAdd = 0;
HASH_FIND_STR(tokenHash, token, h);
if(h == NULL){
h = (struct hash*)malloc(sizeof(struct hash));
h->token = token;
h->file = fileNode;
h->file->count = 1;
HASH_ADD_STR(tokenHash, token, h); //add this hash node to the hash table
}
else{
struct Node* ptr = h->file;
while(ptr!= NULL){ //finding the file here so we can increment its count
if(fileNode->fileName == ptr->fileName){
h->file->count++;
toAdd = 1; //this file exists in the hash and we just incremented the counter
break;
}else{
ptr = ptr->next;
}
}
if(toAdd == 0){
ptr = fileNode;
ptr->count++;
ptr->next = h->file;
h->file = ptr; //making the pointer the head of the linked list
}
}
}
void update_timer(char *key, double value)
{
DPRINTF("update_timer ( %s, %f )\n", key, value);
statsd_timer_t *t;
DPRINTF("HASH_FIND_STR '%s'\n", key);
HASH_FIND_STR( timers, key, t );
DPRINTF("after HASH_FIND_STR '%s'\n", key);
if (t)
{
DPRINTF("Updating old timer entry\n");
utarray_push_back(t->values, &value);
t->count++;
}
else
{
DPRINTF("Adding new timer entry\n");
t = malloc(sizeof(statsd_timer_t));
strcpy(t->key, key);
t->count = 0;
utarray_new(t->values, &timers_icd);
utarray_push_back(t->values, &value);
t->count++;
HASH_ADD_STR( timers, key, t );
}
}
void update_counter( char *key, double value, double sample_rate ) {
syslog(LOG_DEBUG, "update_counter ( %s, %f, %f )\n", key, value, sample_rate);
statsd_counter_t *c;
HASH_FIND_STR( counters, key, c );
if (c) {
syslog(LOG_DEBUG, "Updating old counter entry");
if (sample_rate == 0) {
wait_for_counters_lock();
c->value = c->value + value;
remove_counters_lock();
} else {
wait_for_counters_lock();
c->value = c->value + ( value * ( 1 / sample_rate ) );
remove_counters_lock();
}
} else {
syslog(LOG_DEBUG, "Adding new counter entry");
c = malloc(sizeof(statsd_counter_t));
strcpy(c->key, key);
c->value = 0;
if (sample_rate == 0) {
c->value = value;
} else {
c->value = value * ( 1 / sample_rate );
}
wait_for_counters_lock();
HASH_ADD_STR( counters, key, c );
remove_counters_lock();
}
}
void add_entryToSTable(char *vname, char *sname, void *val, void *address, int type) {
if(getExecutionFlag() == 1) {
struct sym_table *s;
char* hash_vn = get_vnameHash(vname);
if(hash_vn != NULL) {
HASH_FIND_STR(stable, hash_vn, s);
}
else {
HASH_FIND_STR(stable, vname, s);
}
//HASH_FIND_STR(stable, vname, s);
if (s == NULL) {
s = (struct sym_table *)malloc(sizeof(struct sym_table));
s->vname = (char *)calloc((strlen(vname) + 1), sizeof(char));
strcpy(s->vname, vname);
HASH_ADD_STR(stable, vname, s);
}
s->fval = addNewFields(sname, val, address, type);
// printf("Added: %s for %s in symbol table\n", s->vname, sname);
}
}
/* Initialize htable with the metrics known by the system */
int init_known_metrics()
{
/* Initialize PAPI library */
int retval;
retval = PAPI_library_init(PAPI_VER_CURRENT);
if (retval != PAPI_VER_CURRENT) {
fprintf(stderr, "Error! PAPI_library_init %d\n",retval);
PAPI_shutdown();
}
/* Initialize custom metrics storage */
HASH_CLEAR(hh, callbacks_storage);
for(int i = 0; i < available_metrics_no; ++i) {
htable *new_pair = NULL;
new_pair = malloc(sizeof(htable));
if (!new_pair) {
fprintf(stderr, "can't alloc memory for the new pair\n");
exit(-1);
}
strcpy(new_pair->key, callbacks[i].alias);
new_pair->value = callbacks[i].func;
/* insert the new pair in callbacks_storage */
HASH_ADD_STR(callbacks_storage, key, new_pair);
}
return 0;
}
/*
* 函 数:hash_add_queue_kv
* 功 能:hash表中添加新的险
*/
mq_queue_t* hash_add_queue_kv(const char* qname, mq_queue_t* queue)
{
int qname_len = 0;
mq_queue_list_t* tmp_queue = NULL;
qname_len = strlen(qname);
if (qname_len < 0)
{
log_warn("Add hash fail, Invalid key");
return false;
}
tmp_queue = (mq_queue_list_t*)malloc(sizeof(mq_queue_list_t));
if (tmp_queue == NULL)
{
log_warn("Add hash fail, errno[%d], error msg[%s]", errno, strerror(errno));
return false;
}
memset(tmp_queue, '\0', sizeof(mq_queue_list_t));
/* Key setvar */
memcpy(tmp_queue->qname, qname, strlen(qname));
/* Value setvar */
memcpy(&(tmp_queue->mq_queue), queue, sizeof(mq_queue_t));
/* Qname: name of key field */
HASH_ADD_STR(g_mq_qlist, qname, tmp_queue);
return &tmp_queue->mq_queue;
}
void add_signal(struct frame_struct *db, int frameId, char *signalName, int startBit, int signalLength, int is_big_endian, int signedState, float factor, float offset, float min, float max, char *unit, char *receiverList, unsigned char isMultiplexer, unsigned char muxId)
{
struct frame_struct *frame;
struct signal_struct *newSignal;
frame = find_frame(db, frameId);
newSignal = malloc(sizeof(struct signal_struct));
strcpy(newSignal->name, signalName);
newSignal->startBit = startBit;
newSignal->signalLength = signalLength;
newSignal->is_big_endian = is_big_endian;
newSignal->is_signed = signedState;
newSignal->factor = factor;
newSignal->offset = offset;
newSignal->min = min;
newSignal->max = max;
if(isMultiplexer > 0)
{
frame->isMultiplexed = 1;
}
newSignal->isMultiplexer = isMultiplexer;
newSignal->muxId = muxId;
strcpy(newSignal->unit, unit);
strcpy(newSignal->receiverList, receiverList);
HASH_ADD_STR( frame->signals, name, newSignal );
}
Entry addToDict(Dict d, int et, char *key, ...) {
va_list ap;
va_start(ap, key);
Entry entry = (Entry)malloc(sizeof(struct entry));
strncpy(entry->key, key, sizeof(entry->key));
char *sval;
char ival;
char dval;
switch(et) {
case echar:
sval = va_arg(ap, char *);
strncpy(entry->value.str, sval, sizeof(entry->key));
break;
case eint:
ival = va_arg(ap, int);
entry->value.num = ival;
break;
case edouble:
dval = va_arg(ap, double);
entry->value.dub = dval;
break;
}
HASH_ADD_STR(d->entries, key, entry);
return entry;
}
void add_vnameHash(char* key, char* value) {
vnameHash* v;
HASH_FIND_STR(vnames, key, v);
if(v==NULL){
v = (vnameHash*)malloc(sizeof(vnameHash));
strcpy(v->vname_occ,value);
strcpy(v->vname,key);
HASH_ADD_STR(vnames, vname, v);
}
else{
HASH_DEL( vnames, v);
v = (vnameHash*)malloc(sizeof(vnameHash));
strcpy(v->vname_occ,value);
strcpy(v->vname,key);
HASH_ADD_STR(vnames, vname, v);
}
}
void augroup_add(char *key)
{
log_msg("HOOK", "GROUP ADD");
Augroup *aug = malloc(sizeof(Augroup));
aug->key = strdup(key);
augroup_remove(key);
HASH_ADD_STR(aug_tbl, key, aug);
}
void _swUnitTest_setup(swUnitTest_Func func, char *func_name, int run_times)
{
swHashTable_unitTst *u;
u = (swHashTable_unitTst *) malloc(sizeof(swHashTable_unitTst));
u->key = func_name;
u->func = func;
u->run_times = run_times;
HASH_ADD_STR(unitTest_ht, key, u);
}
/*
* This adds the URL to the RestAPI hashmap
*/
void addURL(char *url, struct Response (*restFunc)()) {
struct RestAPI *tmp = malloc(sizeof(struct RestAPI));
tmp->restUrl = url;
tmp->func = restFunc;
HASH_ADD_STR(router, restUrl, tmp);
printf("Added Route: %s\n", url);
}
int main(int argc, char **argv)
{
if (argc < 5) {
fprintf(stderr, "usage: {input sigfile} {output sigfile} {document ids to filter} {0=exclude 1=include}\n");
return 0;
}
FILE *fi;
FILE *fo;
FILE *fids;
if ((fi = fopen(argv[1], "rb"))) {
if ((fo = fopen(argv[2], "wb"))) {
fids = fopen(argv[3], "rb");
for (;;) {
char docname[256];
if (fscanf(fids, "%[^\n]\n", docname) < 1) break;
filt *f = malloc(sizeof(filt));
strcpy(f->docname, docname);
HASH_ADD_STR(filterhash, docname, f);
}
int do_filter = atoi(argv[4]);
readSigHeader(fi);
rewind(fi);
unsigned char *fileheader_buffer = malloc(cfg.headersize);
fread(fileheader_buffer, 1, cfg.headersize, fi);
fwrite(fileheader_buffer, 1, cfg.headersize, fo);
free(fileheader_buffer);
unsigned char *sigheader_buffer = malloc(cfg.sig_offset);
unsigned char *sig_buffer = malloc(cfg.sig_width / 8);
for (;;) {
if (fread(sigheader_buffer, 1, cfg.sig_offset, fi) == 0) break;
fread(sig_buffer, 1, cfg.sig_width / 8, fi);
filt *f;
HASH_FIND_STR(filterhash, (char *)sigheader_buffer, f);
int exclude = f == NULL ? 1 : 0;
int include = f == NULL ? 0 : 1;
if (do_filter ? exclude : include) {
fwrite(sigheader_buffer, 1, cfg.sig_offset, fo);
fwrite(sig_buffer, 1, cfg.sig_width / 8, fo);
}
}
free(sigheader_buffer);
free(sig_buffer);
fclose(fids);
fclose(fo);
} else {
fprintf(stderr, "Unable to open output file\n");
}
fclose(fi);
} else {
fprintf(stderr, "Unable to open input file\n");
}
return 0;
}
static void compl_add(char *fmt_compl, fn_context **parent)
{
log_msg("COMPL", "compl_add");
log_msg("COMPL", "%s", fmt_compl);
int pidx = 0;
int grpc = count_subgrps(fmt_compl, ";");
if (grpc < 1) {
log_msg("COMPL", "invalid format");
return;
}
char *line = strdup(fmt_compl);
fn_context *cx = malloc(sizeof(fn_context));
fn_context **args = malloc(grpc*sizeof(fn_context*));
char *keyptr;
char *saveptr;
char *lhs = strtok_r(line, ";", &saveptr);
fn_context *find;
keyptr = strdup(lhs);
char *param = strtok_r(NULL, ";", &saveptr);
for (pidx = 0; pidx < grpc; pidx++) {
if (compl_param(&args[pidx], param) == -1)
goto breakout;
param = strtok_r(NULL, ";", &saveptr);
}
find = NULL;
cx->key = keyptr;
cx->argc = grpc;
cx->params = args;
cx->cmpl = NULL;
HASH_FIND_STR(*parent, keyptr, find);
if (find) {
log_msg("COMPL", "ERROR: context already defined");
goto breakout;
}
else {
log_msg("*|*", "%s %s %s", cx->key, args[0]->key, keyptr);
HASH_ADD_STR(*parent, key, cx);
}
free(line);
return;
breakout:
log_msg("**", "CLEANUP");
for (pidx = pidx - 1; pidx > 0; pidx--) {
free(args[pidx]);
}
free(cx);
free(args);
free(line);
return;
}
void load_seqid_taxid_rel(char * seqid_taxid_file){
seqid_taxid_rel = NULL;
tax_to_seqs = NULL;
gzFile seq_tax = gzopen(seqid_taxid_file, "r");
kseq_t * seq_t = kseq_init(seq_tax);
struct seqid_taxid_single * tstr;
struct taxid_seqid * tts;
int l = 0;
while ((l = kseq_read(seq_t)) >= 0) {
//add taxid related to seqid
uint64_t tmp_taxid = 0;
HASH_FIND_STR(seqid_taxid_rel, seq_t->name.s, tstr);
if (tstr == NULL) {
if (seq_t->name.l > SEQID_SIZE) {
printf("seqid %s is too long, must be less than 100 characters. Exiting...", seq_t->name.s);
exit(1);
}
tstr = (struct seqid_taxid_single *)malloc(sizeof(struct seqid_taxid_single));
memset(tstr->seqid, '\0', SEQID_SIZE*sizeof(char));
strncpy(tstr->seqid, seq_t->name.s, seq_t->name.l);
tmp_taxid = strtoull(seq_t->seq.s, NULL, 10);
tstr->taxid = tmp_taxid;
HASH_ADD_STR(seqid_taxid_rel, seqid, tstr);
}
else {
printf("%s already seen in hash",seq_t->name.s);
}
//add seqid(s) related to taxid
HASH_FIND(hh, tax_to_seqs, &tmp_taxid, sizeof(uint64_t), tts);
if (tts == NULL) {
tts = (struct taxid_seqid *)malloc(sizeof(struct taxid_seqid));
tts->taxid = tmp_taxid;
tts->num_seqids = 0;
tts->max_seqs = 10;
tts->seqids = (char **)malloc(sizeof(char *)*10);
tts->seqids[tts->num_seqids] = (char *)calloc(SEQID_SIZE,sizeof(char));
strncpy(tts->seqids[tts->num_seqids], seq_t->name.s, seq_t->name.l);
tts->num_seqids++;
HASH_ADD(hh, tax_to_seqs, taxid, sizeof(uint64_t), tts);
}
else {
if (tts->num_seqids >= tts->max_seqs) {
tts->max_seqs = 2 * tts->max_seqs;
tts->seqids = (char **)realloc(tts->seqids, sizeof(char *)*tts->max_seqs);
}
tts->seqids[tts->num_seqids] = (char *)calloc(SEQID_SIZE,sizeof(char));
strncpy(tts->seqids[tts->num_seqids], seq_t->name.s, seq_t->name.l);
tts->num_seqids++;
}
}
gzclose(seq_tax);
}
void InitPYSplitData(FcitxPinyinConfig* pyconfig)
{
size_t size = sizeof(pySplitData) / sizeof(pySplitData[0]);
int i = 0;
for (i = 0; i < size; i ++) {
PYMappedSplitData* data = fcitx_utils_malloc0(sizeof(PYMappedSplitData));
sprintf(data->py, "%s %s", pySplitData[i].py1, pySplitData[i].py2);
data->freq = pySplitData[i].freq;
HASH_ADD_STR(pyconfig->splitData, py, data);
}
}
