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;
}
