static int evaluate_long(grib_expression *g,grib_handle* h,long* lres) { int ret=0; char b1[1024]; size_t l1 = sizeof(b1); char b2[1024]; size_t l2 = sizeof(b2); const char *v1; const char *v2; grib_expression_string_compare* e = (grib_expression_string_compare*)g; v1 = grib_expression_evaluate_string(h,e->left,b1,&l1,&ret); if(!v1) {*lres=0;return ret;} v2 = grib_expression_evaluate_string(h,e->right,b2,&l2,&ret); if(!v2) {*lres=0;return ret;} *lres = (grib_inline_strcmp(v1,v2) == 0); return GRIB_SUCCESS; }
static void init(grib_accessor* a, const long len, grib_arguments* params) { int n=0; grib_accessor_codetable* self = (grib_accessor_codetable*)a; grib_action* act=(grib_action*)(a->creator); self->tablename = grib_arguments_get_string(a->parent->h,params,n++); self->masterDir = grib_arguments_get_name(a->parent->h,params,n++); self->localDir = grib_arguments_get_name(a->parent->h,params,n++); /*if (a->flags & GRIB_ACCESSOR_FLAG_STRING_TYPE) printf("-------- %s type string (%ld)\n",a->name,a->flags);*/ if (a->flags & GRIB_ACCESSOR_FLAG_TRANSIENT) { a->length = 0; if (!a->vvalue) a->vvalue = grib_context_malloc_clear(a->parent->h->context,sizeof(grib_virtual_value)); a->vvalue->type=grib_accessor_get_native_type(a); a->vvalue->length=len; if (act->default_value!=NULL) { const char* p = 0; size_t len = 1; long l; int ret=0; double d; char tmp[1024]; grib_expression* expression=grib_arguments_get_expression(a->parent->h,act->default_value,0); int type = grib_expression_native_type(a->parent->h,expression); switch(type) { case GRIB_TYPE_DOUBLE: grib_expression_evaluate_double(a->parent->h,expression,&d); grib_pack_double(a,&d,&len); break; case GRIB_TYPE_LONG: grib_expression_evaluate_long(a->parent->h,expression,&l); grib_pack_long(a,&l,&len); break; default: len = sizeof(tmp); p = grib_expression_evaluate_string(a->parent->h,expression,tmp,&len,&ret); if (ret != GRIB_SUCCESS) { grib_context_log(a->parent->h->context,GRIB_LOG_FATAL, "unable to evaluate %s as string",a->name); } len = strlen(p)+1; pack_string(a,p,&len); break; } } } else a->length = len; }
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); }
static int pack_expression(grib_accessor* a, grib_expression *e){ const char* cval; int ret=0; long lval=0; size_t len = 1; char tmp[1024]; if (strcmp(e->cclass->name,"long")==0) { ret=grib_expression_evaluate_long(a->parent->h,e,&lval); ret = grib_pack_long(a,&lval,&len); } else { len = sizeof(tmp); cval = grib_expression_evaluate_string(a->parent->h,e,tmp,&len,&ret); if (ret!=GRIB_SUCCESS) { grib_context_log(a->parent->h->context,GRIB_LOG_ERROR,"grib_accessor_codetable.pack_expression: unable to evaluate string %s to be set in %s\n",grib_expression_get_name(e),a->name); return ret; } len = strlen(cval) + 1; ret = grib_pack_string(a,cval,&len); } return ret; }
static int pack_string(grib_accessor* a, const char* buffer, size_t *len) { grib_accessor_codetable* self = (grib_accessor_codetable*)a; grib_codetable* table ; long i; size_t size = 1; typedef int (*cmpproc)(const char*, const char*); cmpproc cmp = a->flags | GRIB_ACCESSOR_FLAG_LOWERCASE ? strcasecmp : strcmp; if(!self->table) self->table = load_table(self); table=self->table; if(!table) return GRIB_ENCODING_ERROR; if (a->set) { int err=grib_set_string(a->parent->h,a->set,buffer,len); if (err!=0) return err; } for(i = 0 ; i < table->size; i++) if(table->entries[i].abbreviation) if(cmp(table->entries[i].abbreviation,buffer) == 0) return grib_pack_long(a,&i,&size); if (a->flags & GRIB_ACCESSOR_FLAG_NO_FAIL) { grib_action* act=(grib_action*)(a->creator); if (act->default_value!=NULL) { const char* p = 0; size_t len = 1; long l; int ret=0; double d; char tmp[1024]; grib_expression* expression=grib_arguments_get_expression(a->parent->h,act->default_value,0); int type = grib_expression_native_type(a->parent->h,expression); switch(type) { case GRIB_TYPE_DOUBLE: grib_expression_evaluate_double(a->parent->h,expression,&d); grib_pack_double(a,&d,&len); break; case GRIB_TYPE_LONG: grib_expression_evaluate_long(a->parent->h,expression,&l); grib_pack_long(a,&l,&len); break; default: len = sizeof(tmp); p = grib_expression_evaluate_string(a->parent->h,expression,tmp,&len,&ret); if (ret != GRIB_SUCCESS) { grib_context_log(a->parent->h->context,GRIB_LOG_FATAL, "unable to evaluate %s as string",a->name); return ret; } len = strlen(p)+1; pack_string(a,p,&len); break; } return GRIB_SUCCESS; } } return GRIB_ENCODING_ERROR; }
static int execute(grib_action* act, grib_handle *h) { grib_action_switch* a = (grib_action_switch*)act; grib_case* c=a->Case; grib_action* next = a->Default; grib_arguments* args=a->args; grib_arguments* values; grib_expression* e; grib_expression* value; int ret = 0; long lres=0; double dres=0; long lval=0; double dval=0; int type=0; int ok=0; const char *cval; const char *cres; char buf[80]; char tmp[80]; size_t len = sizeof(buf); size_t size=sizeof(tmp); int err=0; Assert(args); while (c) { e=args->expression; values=c->values; value=values->expression; ok=0; while (e && value) { if (!strcmp(value->cclass->name,"true")) ok=1; else { type=grib_expression_native_type(h,value); switch(type) { case GRIB_TYPE_LONG: ok= ( grib_expression_evaluate_long(h,value,&lres) == GRIB_SUCCESS) && ( grib_expression_evaluate_long(h,e,&lval) == GRIB_SUCCESS) && (lval == lres); break; case GRIB_TYPE_DOUBLE: ok = ( grib_expression_evaluate_double(h,value,&dres) == GRIB_SUCCESS) && ( grib_expression_evaluate_double(h,e,&dval) == GRIB_SUCCESS) && (dval == dres); break; case GRIB_TYPE_STRING: len = sizeof(buf); size=sizeof(tmp); ok = ((cres=grib_expression_evaluate_string(h,e,buf,&len,&err)) != NULL ) && (err==0) && ((cval = grib_expression_evaluate_string(h,value,tmp,&size,&err)) != NULL) && (err==0) && ((strcmp(buf,cval) == 0) || (strcmp(cval,"*")==0)); break; default: /* TODO: */ break; } } if (!ok) break; args=args->next; if (args) e=args->expression; else e=NULL; values=values->next; if (values) value=values->expression; else value=NULL; } if(ok) { next=c->action; break; } c=c->next; } if (!next) return GRIB_SWITCH_NO_MATCH; while(next){ ret = grib_action_execute(next, h); if(ret != GRIB_SUCCESS) return ret; next= next->next; } return GRIB_SUCCESS; }