grib_rule* grib_new_rule(grib_context* c,grib_expression* condition,grib_rule_entry* entries) { grib_rule* r = (grib_rule*)grib_context_malloc_clear_persistent(c,sizeof(grib_rule)); r->condition = condition; r->entries = entries; return r; }
grib_action* grib_action_create_set_darray( grib_context* context, const char* name, grib_darray* darray) { char buf[1024]; grib_action_set_darray* a ; grib_action_class* c = grib_action_class_set_darray; grib_action* act = (grib_action*)grib_context_malloc_clear_persistent(context,c->size); act->op = grib_context_strdup_persistent(context,"section"); act->cclass = c; a = (grib_action_set_darray*)act; act->context = context; a->darray = darray; a->name = grib_context_strdup_persistent(context,name); sprintf(buf,"set_darray%p",(void*)darray); act->name = grib_context_strdup_persistent(context,buf); return act; }
grib_expression* new_string_expression(grib_context* c,const char* value) { grib_expression_string* e = grib_context_malloc_clear_persistent(c,sizeof(grib_expression_string)); e->base.cclass = grib_expression_class_string; e->value = grib_context_strdup_persistent(c,value); return (grib_expression*)e; }
grib_rule_entry *grib_new_rule_entry(grib_context* c,const char* name,grib_expression* expression) { grib_rule_entry* e = (grib_rule_entry*)grib_context_malloc_clear_persistent(c,sizeof(grib_rule_entry)); e->name = grib_context_strdup_persistent(c,name); e->value = expression; return e; }
grib_expression* new_accessor_expression(grib_context* c,const char *name) { grib_expression_accessor* e = grib_context_malloc_clear_persistent(c,sizeof(grib_expression_accessor)); e->base.cclass = grib_expression_class_accessor; e->name = grib_context_strdup_persistent(c,name); return (grib_expression*)e; }
grib_expression* new_double_expression(grib_context* c,double value) { grib_expression_double* e = grib_context_malloc_clear_persistent(c,sizeof(grib_expression_double)); e->base.cclass = grib_expression_class_double; e->value = value; return (grib_expression*)e; }
grib_action* grib_action_create_if( grib_context* context, grib_expression* expression, grib_action* block_true,grib_action* block_false,int transient) { char name[1024]; grib_action_if* a ; grib_action_class* c = grib_action_class_if; grib_action* act = (grib_action*)grib_context_malloc_clear_persistent(context,c->size); act->op = grib_context_strdup_persistent(context,"section"); act->cclass = c; a = (grib_action_if*)act; act->context = context; a->expression = expression; a->block_true = block_true; a->block_false = block_false; a->transient = transient; if (transient) sprintf(name,"__if%p",(void*)a); else sprintf(name,"_if%p",(void*)a); act->name = grib_context_strdup_persistent(context,name); return act; }
grib_action* grib_action_create_print( grib_context* context, const char* name,char* outname) { char buf[1024]; grib_action_print* a ; grib_action_class* c = grib_action_class_print; grib_action* act = (grib_action*)grib_context_malloc_clear_persistent(context,c->size); act->op = grib_context_strdup_persistent(context,"section"); act->cclass = c; a = (grib_action_print*)act; act->context = context; a->name = grib_context_strdup_persistent(context,name); if (outname) { FILE* out=NULL; int ioerr=0; a->outname = grib_context_strdup_persistent(context,outname); out=fopen(outname,"w"); ioerr=errno; if (!out) { grib_context_log(act->context,(GRIB_LOG_ERROR)|(GRIB_LOG_PERROR), "IO ERROR: %s: %s",strerror(ioerr),outname); } if (out) fclose(out); } sprintf(buf,"print%p",(void*)a->name); act->name = grib_context_strdup_persistent(context,buf); return act; }
grib_action* grib_action_create_gen(grib_context* context, const char* name, const char* op, const long len, grib_arguments* params, grib_arguments* default_value,int flags,const char* name_space,const char* set) { grib_action_gen* a = NULL; grib_action_class* c = grib_action_class_gen; grib_action* act = (grib_action*)grib_context_malloc_clear_persistent(context,c->size); act->next = NULL; act->name = grib_context_strdup_persistent(context, name); act->op = grib_context_strdup_persistent(context, op); if(name_space) act->name_space = grib_context_strdup_persistent(context, name_space); act->cclass = c; act->context = context; act->flags = flags; a = (grib_action_gen*)act; a->len = len; a->params = params; if (set) act->set = grib_context_strdup_persistent(context, set); act->default_value = default_value; return act; }
grib_action* grib_action_create_set( grib_context* context, const char* name, grib_expression* expression,int nofail) { char buf[1024]; grib_action_set* a ; grib_action_class* c = grib_action_class_set; grib_action* act = (grib_action*)grib_context_malloc_clear_persistent(context,c->size); act->op = grib_context_strdup_persistent(context,"section"); act->cclass = c; a = (grib_action_set*)act; act->context = context; a->expression = expression; a->name = grib_context_strdup_persistent(context,name); a->nofail = nofail; sprintf(buf,"set%p",(void*)expression); act->name = grib_context_strdup_persistent(context,buf); return act; }
grib_expression* new_is_in_list_expression(grib_context* c,const char* name,const char* list) { grib_expression_is_in_list* e = (grib_expression_is_in_list*)grib_context_malloc_clear_persistent(c,sizeof(grib_expression_is_in_list)); e->base.cclass = grib_expression_class_is_in_list; e->name = grib_context_strdup_persistent(c,name); e->list = grib_context_strdup_persistent(c,list); return (grib_expression*)e; }
grib_expression* new_string_compare_expression(grib_context* c, grib_expression* left,grib_expression* right) { grib_expression_string_compare* e = grib_context_malloc_clear_persistent(c,sizeof(grib_expression_string_compare)); e->base.cclass = grib_expression_class_string_compare; e->left = left; e->right = right; return (grib_expression*)e; }
grib_concept_index* grib_concept_index_new_from_concept(grib_context* c,grib_concept_value* concept,int *err) { grib_concept_index* index; if (!c) c=grib_context_get_default(); index=grib_context_malloc_clear_persistent(c,sizeof(grib_concept_index)); index->keys=grib_context_malloc_clear_persistent(c,sizeof(grib_concept_index_key)); index->conditions=grib_context_malloc_clear_persistent(c,sizeof(grib_conditions_tree)); index->conditions=grib_context_malloc_clear_persistent(c,sizeof(grib_conditions_tree)); index->context=c; while (concept) { index_add_conditions(index,concept->conditions,err); concept=concept->next; } return index; }
grib_case* grib_case_new(grib_context* c,grib_arguments* values,grib_action* action) { grib_case* Case = (grib_case*)grib_context_malloc_clear_persistent(c,sizeof(grib_case)); Case->values=values; Case->action=action; return Case; }
static int init_definition_files_dir(grib_context* c) { int err=0; char* path=NULL; char* p=NULL; char* dir=NULL; grib_string_list* next=NULL; if (!c) c=grib_context_get_default(); if (c->grib_definition_files_dir) return 0; if (!c->grib_definition_files_path) return GRIB_NO_DEFINITIONS; path=c->grib_definition_files_path; GRIB_PTHREAD_ONCE(&once,&init); GRIB_MUTEX_LOCK(&mutex_c); p=path; while(*p!=':' && *p!='\0') p++; if (*p != ':') { c->grib_definition_files_dir=(grib_string_list*)grib_context_malloc_clear_persistent(c,sizeof(grib_string_list)); c->grib_definition_files_dir->value=grib_context_strdup(c,path); } else { dir=strtok(path,":"); while (dir != NULL) { if (next) { next->next=(grib_string_list*)grib_context_malloc_clear_persistent(c,sizeof(grib_string_list)); next=next->next; } else { c->grib_definition_files_dir=(grib_string_list*)grib_context_malloc_clear_persistent(c,sizeof(grib_string_list)); next=c->grib_definition_files_dir; } next->value=grib_context_strdup(c,dir); dir=strtok(NULL,":"); } } GRIB_MUTEX_UNLOCK(&mutex_c); return err; }
static int index_insert_entry(grib_concept_index* index,grib_concept_index_entry* entry,void* object) { int err=0; int found=0; grib_conditions_tree* cur=index->conditions; grib_conditions_tree* prev=index->conditions; grib_concept_index_keys* keys=index->keys; while (keys->name) { if (!cur) { cur=grib_context_malloc_clear_persistent(index->context,sizeof(grib_conditions_tree)); if (!cur) grib_context_log(index->context,GRIB_LOG_FATAL,"index_insert_entry unable to allocate"); prev->next=cur; } value = entry->value ? entry->value : "*"; while (cur && (!cur->value || (found=!strcmp(cur->value,value))==0) ) cur=cur->next; if (!found) { cur->next=grib_context_malloc_clear_persistent(index->context,sizeof(grib_conditions_tree)); if (!cur->next) grib_context_log(index->context,GRIB_LOG_FATAL,"index_insert_entry unable to allocate"); cur=cur->next; } cur->value=grib_context_strdup(index->context,value); entry=entry->next; keys=keys->next; prev=cur; cur=cur->next_key; } while (cur) { prev=cur; cur=cur->next_key; } prev->object=object; return err; }
char *grib_context_full_path(grib_context* c,const char* basename) { int err=0; char full[1024]={0,}; grib_string_list* dir=NULL; grib_string_list* fullpath=0; if (!c) c=grib_context_get_default(); GRIB_PTHREAD_ONCE(&once,&init); GRIB_MUTEX_LOCK(&mutex_c); if(*basename == '/' || *basename == '.') { GRIB_MUTEX_UNLOCK(&mutex_c); return (char*)basename; } else { if ((fullpath=grib_trie_get(c->def_files,basename))!=NULL) { GRIB_MUTEX_UNLOCK(&mutex_c); return fullpath->value; } if (!c->grib_definition_files_dir) err=init_definition_files_dir(c); if (err != GRIB_SUCCESS) { grib_context_log(c,GRIB_LOG_ERROR, "Unable to find definition files directory"); GRIB_MUTEX_UNLOCK(&mutex_c); return NULL; } dir=c->grib_definition_files_dir; while (dir) { sprintf(full,"%s/%s",dir->value,basename); if (!access(full,F_OK)) { fullpath=grib_context_malloc_clear_persistent(c,sizeof(grib_string_list)); Assert(fullpath); fullpath->value=grib_context_strdup(c,full); grib_trie_insert(c->def_files,basename,fullpath); grib_context_log(c,GRIB_LOG_DEBUG,"Found def file %s",full); GRIB_MUTEX_UNLOCK(&mutex_c); return fullpath->value; } dir=dir->next; } } /* Store missing files so we don't check for them again and again */ grib_trie_insert(c->def_files,basename,&grib_file_not_found); /*grib_context_log(c,GRIB_LOG_ERROR,"Def file \"%s\" not found",basename);*/ GRIB_MUTEX_UNLOCK(&mutex_c); full[0]=0; return NULL; }
grib_expression* new_unop_expression(grib_context* c, grib_unop_long_proc long_func, grib_unop_double_proc double_func, grib_expression* exp) { grib_expression_unop* e = grib_context_malloc_clear_persistent(c,sizeof(grib_expression_unop)); e->base.cclass = grib_expression_class_unop; e->exp = exp; e->long_func = long_func; e->double_func = double_func; return (grib_expression*)e; }
grib_expression* new_binop_expression(grib_context* c, grib_binop_long_proc long_func, grib_binop_double_proc double_func, grib_expression* left,grib_expression* right) { grib_expression_binop* e = (grib_expression_binop*)grib_context_malloc_clear_persistent(c,sizeof(grib_expression_binop)); e->base.cclass = grib_expression_class_binop; e->left = left; e->right = right; e->long_func = long_func; e->double_func = double_func; return (grib_expression*)e; }
static void index_add_conditions(grib_concept_index* index,grib_concept_condition* condition) { grib_concept_condition* c=condition; char s[512]={0,}; grib_concept_index_entry* e;; grib_concept_index_entry* entry=index_entry_new(index->context,index->keys);; while (c) { size_t size=512; int type; e=entry; type = grib_expression_native_type(0,c->expression); switch(type) { case GRIB_TYPE_LONG: grib_expression_evaluate_long(0,c->expression,&lres); sprintf(s,"%ld",lres); break; case GRIB_TYPE_DOUBLE: grib_expression_evaluate_double(0,c->expression,&dres); sprintf(s,"%g",dres); break; case GRIB_TYPE_STRING: grib_expression_evaluate_string(0,c->expression,s,&size,&err); break; default: Assert(0); break; } while (e->name && strcmp(e->name,c->name)) e=e->next; e->type=type; e->value=grib_context_strdup(index->context,s); if (!e->name) { e->name=grib_context_strdup(index->context,c->name); e->next=grib_context_malloc_clear_persistent(index->context,sizeof(grib_concept_index_entry)); if (!e->next) grib_context_log(index->context,GRIB_LOG_FATAL,"index_add_conditions unable to allocate"); } c=c->next; } index_insert_entry(index,entry,condition->name); index_entry_delete(index->context,entry); }
grib_action* grib_action_create_put( grib_context* context, const char* name ,grib_arguments *args ) { grib_action_put* a = NULL; grib_action_class* c = grib_action_class_put; grib_action* act = (grib_action*)grib_context_malloc_clear_persistent(context,c->size); act->next = NULL; act->name = grib_context_strdup_persistent(context,name); act->op = grib_context_strdup_persistent(context,"forward"); act->cclass = c; act->context = context; a = (grib_action_put*)act; a->args = args; return act; }
grib_action* grib_action_create_template( grib_context* context,int nofail,const char* name , const char* arg1) { grib_action_template* a ; grib_action_class* c = grib_action_class_template; grib_action* act = (grib_action*)grib_context_malloc_clear_persistent(context,c->size); act-> name = grib_context_strdup_persistent(context,name); act-> op = grib_context_strdup_persistent(context,"section"); act-> cclass = c; act-> next = NULL; act->context = context; a = (grib_action_template*)act; a->nofail=nofail; if (arg1) a->arg = grib_context_strdup_persistent(context,arg1); else a->arg = NULL; return act; }
grib_action* grib_action_create_noop( grib_context* context,const char* fname) { char buf[1024]; grib_action_noop* a ; grib_action_class* c = grib_action_class_noop; grib_action* act = (grib_action*)grib_context_malloc_clear_persistent(context,c->size); act->op = grib_context_strdup_persistent(context,"section"); act->cclass = c; a = (grib_action_noop*)act; act->context = context; sprintf(buf,"_noop%p",(void*)a); act->name = grib_context_strdup_persistent(context,buf); return act; }
grib_context* grib_context_new(grib_context* parent) { grib_context* c; #if GRIB_PTHREADS pthread_mutexattr_t attr; #endif if (!parent) parent=grib_context_get_default(); GRIB_PTHREAD_ONCE(&once,&init); GRIB_MUTEX_LOCK(&(parent->mutex)); c = (grib_context*)grib_context_malloc_clear_persistent(&default_grib_context,sizeof(grib_context)); c->inited = default_grib_context.inited; c->debug = default_grib_context.debug; c->real_mode = default_grib_context.real_mode; c->free_mem = default_grib_context.free_mem; c->alloc_mem = default_grib_context.alloc_mem; c->free_persistent_mem = default_grib_context.free_persistent_mem; c->alloc_persistent_mem= default_grib_context.alloc_persistent_mem; c->read = default_grib_context.read; c->write = default_grib_context.write; c->tell = default_grib_context.tell; c->output_log = default_grib_context.output_log; c->print = default_grib_context.print ; c->user_data = default_grib_context.user_data; c->def_files = default_grib_context.def_files; #if GRIB_PTHREADS pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_RECURSIVE); pthread_mutex_init(&mutex_c,&attr); pthread_mutexattr_destroy(&attr); #endif GRIB_MUTEX_UNLOCK(&(parent->mutex)); return c; }
grib_action* grib_action_create_alias(grib_context* context, const char* name, const char* arg1,const char* name_space,int flags) { grib_action_alias* a ; grib_action_class* c = grib_action_class_alias; grib_action* act = (grib_action*)grib_context_malloc_clear_persistent(context,c->size); act->context = context; act->op = NULL; act->name = grib_context_strdup_persistent(context, name); if(name_space) act->name_space = grib_context_strdup_persistent(context, name_space); act->cclass = c; act->flags = flags; a = (grib_action_alias*)act; a->target = arg1 ? grib_context_strdup_persistent(context, arg1) : NULL; return act; }
grib_action *grib_action_create_trigger(grib_context *context, grib_arguments *args, grib_action *block) { char name[1024]; grib_action_trigger* a = 0; grib_action_class* c = grib_action_class_trigger; grib_action* act = (grib_action*)grib_context_malloc_clear_persistent(context,c->size); sprintf(name,"_trigger%p",(void*)act); act-> name = grib_context_strdup_persistent(context,name); act-> op = grib_context_strdup_persistent(context,"section"); act-> cclass = c; act-> next = NULL; act->context = context; a = ( grib_action_trigger*)act; a->trigger_on = args; a->block = block; return act; }
grib_action* grib_action_create_modify( grib_context* context, const char* name, long flags) { grib_action_modify* a ; grib_action_class* c = grib_action_class_modify; grib_action* act = (grib_action*)grib_context_malloc_clear_persistent(context,c->size); act->op = grib_context_strdup_persistent(context,"section"); act->cclass = c; a = (grib_action_modify*)act; act->context = context; a->flags = flags; a->name = grib_context_strdup_persistent(context,name); act->name = grib_context_strdup_persistent(context,"flags"); return act; }
grib_action* grib_action_create_variable( grib_context* context, const char* name, const char* op, const long len, grib_arguments* params, grib_arguments* default_value,int flags,const char* name_space) { grib_action_variable* a = NULL; grib_action_class* c = grib_action_class_variable; grib_action* act = (grib_action*)grib_context_malloc_clear_persistent(context,c->size); act->next = NULL; act->name = grib_context_strdup_persistent(context, name); if(name_space) act->name_space = grib_context_strdup_persistent(context, name_space); act->op = grib_context_strdup_persistent(context, op); act->cclass = c; act->context = context; act->flags = flags; a = (grib_action_variable*)act; a->len = len; a->params = params; act->default_value = default_value; /* printf("CREATE %s\n",name); */ return act; }
grib_action* grib_action_create_meta( grib_context* context, const char* name, const char* op, grib_arguments* params, grib_arguments* default_value,unsigned long flags,const char* name_space) { grib_action_meta* a = (grib_action_meta*)grib_context_malloc_clear_persistent(context,sizeof(grib_action_meta)); grib_action* act = (grib_action*)a; act->next = NULL; act->name = grib_context_strdup_persistent(context, name); act->op = grib_context_strdup_persistent(context, op); if(name_space) act->name_space = grib_context_strdup_persistent(context, name_space); act->cclass = grib_action_class_meta; act->context = context; act->flags = flags; a->params = params; act->default_value = default_value; a->len = 0; /* grib_arguments_print(context,a->params,0); printf("\n"); */ return act; }
grib_action* grib_action_create_write( grib_context* context, const char* name,int append,int padtomultiple) { char buf[1024]; grib_action_write* a =NULL; grib_action_class* c = grib_action_class_write; grib_action* act = (grib_action*)grib_context_malloc_clear_persistent(context,c->size); act->op = grib_context_strdup_persistent(context,"section"); act->cclass = c; a = (grib_action_write*)act; act->context = context; a->name = grib_context_strdup_persistent(context,name); sprintf(buf,"write%p",(void*)a->name); act->name = grib_context_strdup_persistent(context,buf); a->append=append; a->padtomultiple=padtomultiple; return act; }