mirror of https://github.com/ecmwf/eccodes.git
464 lines
11 KiB
C
464 lines
11 KiB
C
/*
|
|
* Copyright 2005-2013 ECMWF.
|
|
*
|
|
* This software is licensed under the terms of the Apache Licence Version 2.0
|
|
* which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
|
|
*
|
|
* In applying this licence, ECMWF does not waive the privileges and immunities granted to it by
|
|
* virtue of its status as an intergovernmental organisation nor does it submit to any jurisdiction.
|
|
*/
|
|
|
|
|
|
/*
|
|
|
|
Author: B.Raoult
|
|
Modified by Enrico Fucile
|
|
|
|
*/
|
|
|
|
|
|
#include "grib_api_internal.h"
|
|
#include <math.h>
|
|
#include <errno.h>
|
|
#include <signal.h>
|
|
#include <ctype.h>
|
|
#include <stdlib.h>
|
|
|
|
#if 0
|
|
GRIB_INLINE static int strcmp(const char* a,const char* b) {
|
|
if (*a != *b) return 1;
|
|
while((*a!=0 && *b!=0) && *(a) == *(b) ) {a++;b++;}
|
|
return (*a==0 && *b==0) ? 0 : 1;
|
|
}
|
|
#endif
|
|
|
|
#define SIZE ((int)4097)
|
|
#ifndef NUMBER
|
|
#define NUMBER(a) (sizeof(a)/sizeof(a[0])) /* number of elem. of an array */
|
|
#endif
|
|
#ifndef MAX
|
|
#define MAX(a,b) (((a)>(b))?(a):(b))
|
|
#endif
|
|
#ifndef MIN
|
|
#define MIN(a,b) (((a)<(b))?(a):(b))
|
|
#endif
|
|
#define ABS(a) ((a)<0?-(a):(a))
|
|
#define ROUND(a) ((long)((a)+0.5))
|
|
#define EQ(a,b) ((*(a) == *(b)) && (strcmp(a,b) == 0))
|
|
#define LT(a,b) ((*(a) < *(b)) || (strcmp(a,b) < 0))
|
|
|
|
|
|
static grib_math *readpower(grib_context* c,char** form,int *err);
|
|
static grib_math *readatom(grib_context* c,char** form,int *err);
|
|
static grib_math *readfactor(grib_context* c,char** form,int *err);
|
|
static grib_math *readterm(grib_context* c,char** form,int *err);
|
|
static grib_math *readtest(grib_context* c,char** form,int *err);
|
|
static grib_math *readlist(grib_context* c,char** form,int* n,int *err);
|
|
static grib_math *readand(grib_context* c,char** form,int* err);
|
|
static grib_math *reador(grib_context* c,char** form,int* err);
|
|
static void advance(char** form);
|
|
static char *opname(char *p,int n);
|
|
/*
|
|
static long op_eq(long a, long b) {return a == b;}
|
|
static long op_ne(long a, long b) {return a != b;}
|
|
static long op_lt(long a, long b) {return a < b;}
|
|
static long op_gt(long a, long b) {return a > b;}
|
|
static long op_and(long a, long b) {return a && b;}
|
|
static long op_or(long a, long b) {return a || b;}
|
|
static long op_ge(long a, long b) {return a >= b;}
|
|
static long op_le(long a, long b) {return a <= b;}
|
|
|
|
static long op_bit(long a, long b) {return a&(1<<b);}
|
|
static long op_bitoff(long a, long b) {return !op_bit(a,b);}
|
|
|
|
static long op_not(long a) {return !a;}
|
|
static long op_neg(long a) {return -a;}
|
|
|
|
static double op_neg_d(double a) {return -a;}
|
|
|
|
static long op_pow(long a, long b) {return grib_power(a,b);}
|
|
static long op_add(long a, long b) {return a+b;}
|
|
static long op_sub(long a, long b) {return a-b;}
|
|
static long op_div(long a, long b) {return a/b;}
|
|
static long op_mul(long a, long b) {return a*b;}
|
|
static long op_modulo(long a, long b) {return a%b;}
|
|
|
|
static double op_mul_d(double a, double b) {return a*b;}
|
|
static double op_div_d(double a, double b) {return a/b;}
|
|
static double op_add_d(double a, double b) {return a+b;}
|
|
static double op_sub_d(double a, double b) {return a-b;}
|
|
|
|
static double op_eq_d(double a, double b) {return a == b;}
|
|
static double op_ne_d(double a, double b) {return a != b;}
|
|
static double op_lt_d(double a, double b) {return a < b;}
|
|
static double op_gt_d(double a, double b) {return a > b;}
|
|
static double op_ge_d(double a, double b) {return a >= b;}
|
|
static double op_le_d(double a, double b) {return a <= b;}
|
|
|
|
static int op_eq_string(char* a,char* b) {
|
|
if (a && b) return strcmp(a,b) == 0 ? 1 : 0;
|
|
return 0;
|
|
}
|
|
static int op_ne_string(char* a,char* b) {
|
|
if (a && b) return strcmp(a,b) == 0 ? 0 : 1;
|
|
return 0;
|
|
}
|
|
static int op_lt_string(char* a,char* b) {
|
|
if (a && b) return strcmp(a,b) < 0 ? 1 : 0;
|
|
return 0;
|
|
}
|
|
static int op_gt_string(char* a,char* b) {
|
|
if (a && b) return strcmp(a,b) > 0 ? 1 : 0;
|
|
return 0;
|
|
}
|
|
static int op_ge_string(char* a,char* b) {
|
|
if (a && b) return strcmp(a,b) >= 0 ? 1 : 0;
|
|
return 0;
|
|
}
|
|
static int op_le_string(char* a,char* b) {
|
|
if (a && b) return strcmp(a,b) <= 0 ? 1 : 0;
|
|
return 0;
|
|
}
|
|
*/
|
|
|
|
typedef double real;
|
|
typedef int boolean;
|
|
typedef int err;
|
|
typedef real (*fop1)(real);
|
|
typedef real (*fop2)(real,real);
|
|
|
|
|
|
static void advance(char** form) {
|
|
(*form)++;
|
|
while(isspace(**form)) (*form)++;
|
|
}
|
|
|
|
static grib_math *readatom(grib_context* c,char** form,int *err) {
|
|
grib_math *p;
|
|
int i;
|
|
char buf[1024];
|
|
|
|
switch(**form)
|
|
{
|
|
case '(':
|
|
advance(form);
|
|
p = reador(c,form,err);
|
|
if(**form != ')') {
|
|
grib_context_log(c, GRIB_LOG_ERROR,"Formula: missing )");
|
|
*err = GRIB_INTERNAL_ERROR;
|
|
}
|
|
advance(form);
|
|
break;
|
|
|
|
case '-':
|
|
p = (grib_math*)grib_context_malloc(c,sizeof(grib_math));
|
|
p->arity = 1;
|
|
p->name = strdup("neg");
|
|
advance(form);
|
|
p->left = readatom(c,form,err);
|
|
break;
|
|
|
|
case '!':
|
|
p = (grib_math*)grib_context_malloc(c,sizeof(grib_math));
|
|
p->arity = 1;
|
|
p->name = strdup("neg");
|
|
advance(form);
|
|
p->left = readatom(c,form,err);
|
|
break;
|
|
|
|
case '\0':
|
|
grib_context_log(c, GRIB_LOG_ERROR,"Formula: syntax error");
|
|
*err = GRIB_INTERNAL_ERROR;
|
|
return NULL;
|
|
/*NOTREACHED*/
|
|
break;
|
|
|
|
default:
|
|
i = 0;
|
|
|
|
if(**form == '\'' || **form == '"')
|
|
{
|
|
char c = *((*form)++);
|
|
while(**form && **form != c)
|
|
buf[i++] = *((*form)++);
|
|
if(**form) (*form)++;
|
|
} else
|
|
while(isalpha(**form)||isdigit(**form)
|
|
|| **form =='.' || **form == '_')
|
|
buf[i++] = *((*form)++);
|
|
|
|
buf[i] = 0;
|
|
if(isspace(**form)) advance(form);
|
|
|
|
p = (grib_math*)grib_context_malloc(c,sizeof(grib_math));
|
|
p->name = strdup(buf);
|
|
p->left=0;
|
|
|
|
switch(**form)
|
|
{
|
|
case '(':
|
|
advance(form);
|
|
p->arity = 0;
|
|
p->left = readlist(c,form,&p->arity,err);
|
|
if(**form != ')')
|
|
{
|
|
grib_context_log(c, GRIB_LOG_ERROR,"Formula: missing )");
|
|
*err = GRIB_INTERNAL_ERROR;
|
|
}
|
|
advance(form);
|
|
break;
|
|
|
|
case '[':
|
|
advance(form);
|
|
p->arity = 0;
|
|
p->left = readlist(c,form,&p->arity,err);
|
|
if(**form != ']') {
|
|
grib_context_log(c, GRIB_LOG_ERROR,"Formula: missing ]");
|
|
*err = GRIB_INTERNAL_ERROR;
|
|
}
|
|
p->arity = -p->arity;
|
|
advance(form);
|
|
break;
|
|
|
|
default:
|
|
p->arity = 0;
|
|
break;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
return p;
|
|
}
|
|
|
|
static char *opname(char *p,int n)
|
|
{
|
|
char buf[5];
|
|
strncpy(buf,p,n);
|
|
buf[n] = 0;
|
|
return strdup(buf);
|
|
}
|
|
|
|
void print_math(grib_math *m)
|
|
{
|
|
if(m)
|
|
{
|
|
putchar('(');
|
|
print_math(m->left);
|
|
printf("%s",m->name);
|
|
print_math(m->right);
|
|
putchar(')');
|
|
}
|
|
}
|
|
|
|
static grib_math *readpower(grib_context* c,char** form,int *err)
|
|
{
|
|
grib_math *p = readatom(c,form,err);
|
|
|
|
|
|
while(**form == '^' || (**form == '*' && *(*form + 1) == '*') )
|
|
{
|
|
grib_math *q = (grib_math*)grib_context_malloc(c,sizeof(grib_math));
|
|
q->left = p;
|
|
q->arity = 2;
|
|
|
|
if(**form == '*') { advance(form); **form = '^'; }
|
|
|
|
q->name = opname(*form,1);
|
|
advance(form);
|
|
q->right = readatom(c,form,err);
|
|
p = q;
|
|
}
|
|
return p;
|
|
}
|
|
|
|
static grib_math *readlist(grib_context* c,char** form,int *n,int * err)
|
|
{
|
|
grib_math *p;
|
|
|
|
if(**form == ')') return NULL;
|
|
|
|
p = readtest(c,form,err);
|
|
*n = 1;
|
|
|
|
while(**form == ',') {
|
|
grib_math *q = (grib_math*)grib_context_malloc(c,sizeof(grib_math));
|
|
|
|
(*n)++;
|
|
|
|
q->left = p;
|
|
|
|
advance(form);
|
|
|
|
q->right = readtest(c,form,err);
|
|
|
|
p = q;
|
|
}
|
|
return p;
|
|
}
|
|
|
|
static grib_math *readfactor(grib_context* c,char** form,int* err) {
|
|
grib_math *p = readpower(c,form,err);
|
|
|
|
while(**form == '*' || **form == '/') {
|
|
grib_math *q = (grib_math*)grib_context_malloc(c,sizeof(grib_math));
|
|
|
|
q->arity = 2;
|
|
q->left = p;
|
|
q->name = opname(*form,1);
|
|
|
|
advance(form);
|
|
|
|
q->right = readpower(c,form,err);
|
|
|
|
p = q;
|
|
}
|
|
return p;
|
|
}
|
|
|
|
static grib_math *readterm(grib_context* c,char** form,int* err) {
|
|
grib_math *p = readfactor(c,form,err);
|
|
while(**form == '+' || **form == '-' ) {
|
|
grib_math *q = (grib_math*)grib_context_malloc(c,sizeof(grib_math));
|
|
|
|
q->arity = 2;
|
|
q->left = p;
|
|
q->name = opname(*form,1);
|
|
|
|
advance(form);
|
|
|
|
q->right = readfactor(c,form,err);
|
|
|
|
p = q;
|
|
|
|
}
|
|
return p;
|
|
}
|
|
|
|
static grib_math *readtest(grib_context* c,char** form,int* err) {
|
|
grib_math *p = readterm(c,form,err);
|
|
while(**form == '<' || **form == '>' || **form == '=') {
|
|
grib_math *q = (grib_math*)grib_context_malloc(c,sizeof(grib_math));
|
|
char *x = *form;
|
|
int n = 1;
|
|
|
|
q->arity = 2;
|
|
q->left = p;
|
|
|
|
advance(form);
|
|
if(**form == '=' || **form == '>') {
|
|
n = 2;
|
|
advance(form);
|
|
}
|
|
|
|
q->name = opname(x,n);
|
|
|
|
q->right = readterm(c,form,err);
|
|
|
|
p = q;
|
|
|
|
}
|
|
return p;
|
|
}
|
|
|
|
static grib_math *readand(grib_context* c,char** form,int* err) {
|
|
grib_math *p = readtest(c,form,err);
|
|
while(**form == '&' ) {
|
|
grib_math *q = (grib_math*)grib_context_malloc(c,sizeof(grib_math));
|
|
char *x = *form;
|
|
int n = 1;
|
|
|
|
q->arity = 2;
|
|
q->left = p;
|
|
|
|
advance(form);
|
|
if(**form == '&') {
|
|
n = 2;
|
|
advance(form);
|
|
}
|
|
|
|
q->name = opname(x,n);
|
|
|
|
q->right = readtest(c,form,err);
|
|
|
|
p = q;
|
|
|
|
}
|
|
return p;
|
|
}
|
|
|
|
static grib_math *reador(grib_context* c,char** form,int* err) {
|
|
grib_math *p = readand(c,form,err);
|
|
while(**form == '|' ) {
|
|
grib_math *q = (grib_math*)grib_context_malloc(c,sizeof(grib_math));
|
|
char *x = *form;
|
|
int n = 1;
|
|
|
|
q->arity = 2;
|
|
q->left = p;
|
|
|
|
advance(form);
|
|
if(**form == '|' ) {
|
|
n = 2;
|
|
advance(form);
|
|
}
|
|
|
|
q->name = opname(x,n);
|
|
|
|
q->right = readand(c,form,err);
|
|
|
|
p = q;
|
|
|
|
}
|
|
return p;
|
|
}
|
|
|
|
grib_math *grib_math_clone(grib_context* c,grib_math *m) {
|
|
grib_math *n = NULL;
|
|
if(m) {
|
|
n = (grib_math*)grib_context_malloc(c,sizeof(grib_math));
|
|
n->arity = m->arity;
|
|
n->name = strdup(m->name);
|
|
n->left = grib_math_clone(c,m->left);
|
|
n->right = grib_math_clone(c,m->right);
|
|
}
|
|
return n;
|
|
}
|
|
|
|
void grib_math_delete (grib_context* c,grib_math* m) {
|
|
grib_math *left=0,*right=0;
|
|
left=m->left;
|
|
right=m->right;
|
|
if (m->name) free(m->name);
|
|
grib_context_free(c,m);
|
|
if (left) grib_math_delete(c,left);
|
|
if (right) grib_math_delete(c,right);
|
|
}
|
|
|
|
grib_math *grib_math_new(grib_context* c,const char* formula,int *err) {
|
|
grib_math *x;
|
|
char* f=0;
|
|
char* fsave=0;
|
|
|
|
*err=0;
|
|
|
|
if (!formula) {*err=GRIB_INVALID_ARGUMENT;return NULL;}
|
|
|
|
f=strdup(formula);
|
|
fsave=f;
|
|
|
|
x = reador(c,&f,err);
|
|
if(*err!=GRIB_SUCCESS) return NULL;
|
|
|
|
if(*f) {
|
|
grib_context_log(c, GRIB_LOG_ERROR,
|
|
"grib_math_new : Part of the formula was not processed: '%s'",f);
|
|
return NULL;
|
|
}
|
|
|
|
free(fsave);
|
|
|
|
return x;
|
|
}
|
|
|