static int evaluate_long(grib_expression *g,grib_handle* h,long* lres) { long v1=0; long v2=0; int ret; grib_expression_binop* e = (grib_expression_binop*)g; #if 0 /* DEBUGGING */ { int typeLeft, typeRight; const char* nameLeft; const char* nameRight; typeLeft = grib_expression_native_type(h, e->left); typeRight = grib_expression_native_type(h, e->right); nameLeft = grib_expression_get_name(e->left); nameRight= grib_expression_get_name(e->right); printf("eval_long nameLeft=%s (type=%d), nameRight=%s (type=%d)\n",nameLeft,typeLeft, nameRight,typeRight); grib_expression_print(h->context, g, h); printf("\n"); } #endif ret = grib_expression_evaluate_long(h,e->left,&v1); if (ret != GRIB_SUCCESS) return ret; ret = grib_expression_evaluate_long(h,e->right,&v2); if (ret != GRIB_SUCCESS) return ret; *lres=e->long_func(v1,v2); return GRIB_SUCCESS; }
static size_t preferred_size(grib_accessor* a,int from_handle) { grib_accessor_padtomultiple* self = (grib_accessor_padtomultiple*)a; long padding=0; long begin = 0; long multiple = 0; grib_expression_evaluate_long(a->parent->h,self->begin,&begin); grib_expression_evaluate_long(a->parent->h,self->multiple,&multiple); padding = a->offset - begin; padding = ((padding + multiple - 1)/multiple)*multiple - padding; return padding == 0 ? multiple : padding; }
static size_t preferred_size(grib_accessor* a,int from_handle) { grib_accessor_pad* self = (grib_accessor_pad*)a; long length = 0; grib_expression_evaluate_long(a->parent->h,self->expression,&length); return length > 0 ? length : 0; }
static int evaluate_long(grib_expression* g,grib_handle* h,long* lres) { int ret; long v=0; grib_expression_unop* e = (grib_expression_unop*)g; ret = grib_expression_evaluate_long(h,e->exp,&v); if (ret != GRIB_SUCCESS) return ret; *lres=e->long_func(v); 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 int unpack_string(grib_accessor*a , char* v, size_t *len){ grib_accessor_md5* self = (grib_accessor_md5*)a; unsigned mess_len; unsigned char* mess; unsigned char* p; long offset,length; grib_string_list* blacklist=NULL; grib_accessor* b=NULL; int ret=0; int i=0; struct grib_md5_state md5c; if (*len <32 ) { grib_context_log(a->context,GRIB_LOG_ERROR,"md5: array too small"); return GRIB_ARRAY_TOO_SMALL; } if((ret = grib_get_long_internal(grib_handle_of_accessor(a),self->offset,&offset)) != GRIB_SUCCESS) return ret; if((ret = grib_expression_evaluate_long(grib_handle_of_accessor(a),self->length,&length)) != GRIB_SUCCESS) return ret; mess=(unsigned char*)grib_context_malloc(a->context,length); memcpy(mess,grib_handle_of_accessor(a)->buffer->data+offset,length); mess_len=length; blacklist=a->context->blacklist; /* passed blacklist overrides context blacklist. Consider to modify following line to extend context blacklist. */ if (self->blacklist) blacklist=self->blacklist; while (blacklist && blacklist->value) { b=grib_find_accessor(grib_handle_of_accessor(a),blacklist->value); if (!b) { grib_context_free(a->context,mess); return GRIB_NOT_FOUND; } p=mess+b->offset-offset; for (i=0;i<b->length;i++) *(p++)=0; blacklist=blacklist->next; } grib_md5_init(&md5c); grib_md5_add(&md5c,mess,mess_len); grib_md5_end(&md5c,v); grib_context_free(a->context,mess); return ret; }
static int unpack_long(grib_accessor* a, long* val, size_t *len) { int ret=0; grib_accessor_evaluate* self = (grib_accessor_evaluate*)a; grib_expression* e = grib_arguments_get_expression(a->parent->h,self->arg,0); ret = grib_expression_evaluate_long(a->parent->h,e,val); *len = 1; return ret; }
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 create_accessor( grib_section* p, grib_action* act, grib_loader *h) { grib_action_if* a = (grib_action_if*)act; grib_action* next = NULL; int ret = 0; long lres=0; grib_accessor* as = NULL; grib_section* gs = NULL; as = grib_accessor_factory(p, act,0,NULL); if(!as)return GRIB_INTERNAL_ERROR; gs = as->sub_section; grib_push_accessor(as,p->block); if ((ret=grib_expression_evaluate_long(p->h,a->expression,&lres)) != GRIB_SUCCESS) return ret; if(lres) next = a->block_true; else next = a->block_false; if(p->h->context->debug > 1) { printf("EVALUATE create_accessor_handle "); grib_expression_print(p->h->context,a->expression,p->h); printf(" [%s][_if%p]\n", (next == a->block_true ? "true":"false"), (void*)a); /*grib_dump_action_branch(stdout,next,5);*/ } gs->branch = next; grib_dependency_observe_expression(as,a->expression); while(next){ ret = grib_create_accessor(gs, next, h); if(ret != GRIB_SUCCESS) return ret; next= next->next; } return GRIB_SUCCESS; }
static grib_action* reparse(grib_action* a,grib_accessor* acc,int* doit) { int ret=0; long lres=0; grib_action_if* self = (grib_action_if*)a; /* printf("reparse %s %s\n",a->name,acc->name); */ if((ret=grib_expression_evaluate_long(acc->parent->h,self->expression,&lres)) != GRIB_SUCCESS) grib_context_log(acc->parent->h->context, GRIB_LOG_ERROR,"if reparse grib_expression_evaluate_long %s", grib_get_error_message(ret)); if(lres) return self->block_true; else return self->block_false; }
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 execute(grib_action* act, grib_handle *h) { grib_action_if* a = (grib_action_if*)act; grib_action* next = NULL; int ret = 0; long lres=0; /* See GRIB-394 */ int type = grib_expression_native_type(h, a->expression); if (type != GRIB_TYPE_DOUBLE) { if ((ret=grib_expression_evaluate_long(h,a->expression,&lres)) != GRIB_SUCCESS) { if (ret == GRIB_NOT_FOUND) lres=0; else return ret; } } else { double dres = 0.0; ret = grib_expression_evaluate_double(h, a->expression, &dres); lres = (long)dres; if ( ret != GRIB_SUCCESS ) { if (ret == GRIB_NOT_FOUND) lres=0; else return ret; } } if(lres) next = a->block_true; else next = a->block_false; while(next){ ret = grib_action_execute(next, h); if(ret != GRIB_SUCCESS) return ret; next= next->next; } return GRIB_SUCCESS; }
int grib_tool_new_handle_action(grib_runtime_options* options, grib_handle* h) { grib_rule* r = options->rules; int i; int err=0; double scale = 1; double offset = 0; int set = options->set_values_count; while(r) { if(r->condition) { long ok = 0; GRIB_CHECK_NOLINE(grib_expression_evaluate_long(h,r->condition,&ok),NULL); if(ok) { grib_rule_entry* e = r->entries; while(e) { if (!strcmp(e->name,"skip")) return 0; Assert(set < (sizeof(options->set_values)/sizeof(options->set_values[0]))); options->set_values[set].name = e->name; options->set_values[set].error=grib_expression_set_value(h, e->value,&(options->set_values[set])); set++; e = e->next; } } } r = r->next; } if(options->verbose) { printf("Applying %d:\n",options->infile->handle_count); grib_print_values(options->set_values, set); printf("\n"); } err=grib_set_values(h,options->set_values, set); if( err != GRIB_SUCCESS) { for(i = 0; i < options->set_values_count ; i++) { if(options->set_values[i].error != GRIB_SUCCESS && options->set_values[i].error != GRIB_CONCEPT_NO_MATCH && options->fail) grib_context_log(h->context,GRIB_LOG_ERROR,"unable to set key \"%s\" (%s)", options->set_values[i].name,grib_get_error_message( options->set_values[i].error)); } } grib_get_double(h,"scaleValuesBy",&scale); grib_get_double(h,"offsetValuesBy",&offset); if(scale != 1 || offset != 0) { double *v; size_t size; int i; GRIB_CHECK_NOLINE(grib_get_size(h,"values",&size),0); v = (double*)calloc(size,sizeof(double)); if(!v) { fprintf(stderr,"failed to allocate %ld bytes\n",(long)(size*sizeof(double))); exit(1); } GRIB_CHECK_NOLINE(grib_get_double_array(h,"values",v,&size),0); if(options->verbose) { printf("Applying scale=%g/offset=%g\n",scale,offset); } for(i = 0; i< size; i++) v[i] = v[i] * scale + offset; GRIB_CHECK_NOLINE(grib_set_double_array(h,"values",v,size),0); free(v); } grib_tools_write_message(options,h); return 0; }
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; }