From 192b437aaab8262e28c5a3a950391c47a356c70a Mon Sep 17 00:00:00 2001 From: Enrico Fucile Date: Tue, 30 May 2017 14:55:43 +0100 Subject: [PATCH] ECC-484 --- definitions/metar/boot.def | 1 + definitions/metar/present_weather.def | 26 ++- definitions/metar/present_weather_Trend1.def | 36 ++-- definitions/metar/qnh.def | 2 +- src/CMakeLists.txt | 1 + src/Makefile.am | 1 + src/grib_api_prototypes.h | 3 + src/grib_expression_class.h | 1 + src/grib_expression_class_is_in_dict.c | 8 +- src/grib_expression_class_is_integer.c | 21 ++- src/grib_expression_class_length.c | 8 +- src/grib_expression_class_logical_and.c | 186 +++++++++++++++++++ src/grib_expression_factory.h | 1 + src/grib_lex.c | 32 ++-- src/grib_yacc.c | 2 +- src/griby.y | 2 +- 16 files changed, 264 insertions(+), 67 deletions(-) create mode 100644 src/grib_expression_class_logical_and.c diff --git a/definitions/metar/boot.def b/definitions/metar/boot.def index 6764577e8..3e0852b00 100644 --- a/definitions/metar/boot.def +++ b/definitions/metar/boot.def @@ -97,6 +97,7 @@ if ( g is "NIL" ) { include "metar/missing_field.def"; include "metar/temperature.def"; + include "metar/qnh.def"; include "metar/colour.def"; include "metar/recent_weather.def"; diff --git a/definitions/metar/present_weather.def b/definitions/metar/present_weather.def index b87c120a2..28126d483 100644 --- a/definitions/metar/present_weather.def +++ b/definitions/metar/present_weather.def @@ -20,19 +20,25 @@ if (substr(g,0,1) is "-" || substr(g,0,1) is "+" || substr(g,0,2) is "FZ" || g i rename(g,wrongPresentWeather); group g : dump; non_alpha na; } -if (! presentWeather1Present && is_in_list(g,"metar/present_weather.list")) { +if (! presentWeather1Present ) { + if (is_in_list(g,"metar/present_weather.list")) { rename(g,presentWeather1); group g : dump; non_alpha na; - alias presentWeather1Present=one; + alias presentWeather1Present=one; + } } -if (!presentWeather2Present && is_in_list(g,"metar/present_weather.list")) { - rename(g,presentWeather2); - group g : dump; non_alpha na; - alias presentWeather2Present=one; +if (! presentWeather2Present ) { + if ( is_in_list(g,"metar/present_weather.list")) { + rename(g,presentWeather2); + group g : dump; non_alpha na; + alias presentWeather2Present=one; + } } -if (!presentWeather3Present && is_in_list(g,"metar/present_weather.list")) { - rename(g,presentWeather3); - group g : dump; non_alpha na; - alias presentWeather3Present=one; +if (! presentWeather3Present ) { + if (is_in_list(g,"metar/present_weather.list")) { + rename(g,presentWeather3); + group g : dump; non_alpha na; + alias presentWeather3Present=one; + } } diff --git a/definitions/metar/present_weather_Trend1.def b/definitions/metar/present_weather_Trend1.def index f31c3611a..41392a8f4 100644 --- a/definitions/metar/present_weather_Trend1.def +++ b/definitions/metar/present_weather_Trend1.def @@ -26,20 +26,26 @@ if (g is "NSW") { rename(g,wrongPresentWeatherTrend1); group g : dump; non_alpha na; } - if (! presentWeather1PresentTrend1 && is_in_list(g,"metar/present_weather.list")) { - rename(g,presentWeather1Trend1); - group g : dump; non_alpha na; - alias presentWeather1PresentTrend1=one; - } - if (!presentWeather2PresentTrend1 && is_in_list(g,"metar/present_weather.list")) { - rename(g,presentWeather2Trend1); - group g : dump; non_alpha na; - alias presentWeather2PresentTrend1=one; - } - if (!presentWeather3PresentTrend1 && is_in_list(g,"metar/present_weather.list")) { - rename(g,presentWeather3TrendTrend11); - group g : dump; non_alpha na; - alias presentWeather3PresentTrend1=one; - } + if (! presentWeather1PresentTrend1 ) { + if (is_in_list(g,"metar/present_weather.list")) { + rename(g,presentWeather1Trend1); + group g : dump; non_alpha na; + alias presentWeather1PresentTrend1=one; + } + } + if (!presentWeather2PresentTrend1) { + if ( is_in_list(g,"metar/present_weather.list")) { + rename(g,presentWeather2Trend1); + group g : dump; non_alpha na; + alias presentWeather2PresentTrend1=one; + } + } + if (!presentWeather3PresentTrend1 ) { + if ( is_in_list(g,"metar/present_weather.list")) { + rename(g,presentWeather3TrendTrend11); + group g : dump; non_alpha na; + alias presentWeather3PresentTrend1=one; + } + } } diff --git a/definitions/metar/qnh.def b/definitions/metar/qnh.def index 725b70eae..07ec43cfe 100644 --- a/definitions/metar/qnh.def +++ b/definitions/metar/qnh.def @@ -5,7 +5,7 @@ if ( ! qfePresent && substr(g,0,3) is "QFE" ) { group g : dump; non_alpha na; alias qfePresent=one; } -if (! qnhPresent && substr(g,0,1) is "Q" ) { +if ( ! qnhPresent && substr(g,0,1) is "Q" ) { rename(g,qnhInHectoPascal); if (is_integer(qnhInHectoPascal,1,4)) { qnh=to_string(qnhInHectoPascal,1,4) : dump; diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 973f1db86..18616382d 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -311,6 +311,7 @@ list( APPEND grib_api_srcs grib_value.c grib_errors.c grib_expression_class_binop.c + grib_expression_class_logical_and.c grib_expression_class_is_in_dict.c grib_expression_class_true.c grib_expression_class_string_compare.c diff --git a/src/Makefile.am b/src/Makefile.am index 155446c36..266482b15 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -326,6 +326,7 @@ libeccodes_la_prototypes= \ grib_value.c \ grib_errors.c \ grib_expression_class_binop.c \ + grib_expression_class_logical_and.c \ grib_expression_class_is_in_dict.c \ grib_expression_class_true.c \ grib_expression_class_string_compare.c \ diff --git a/src/grib_api_prototypes.h b/src/grib_api_prototypes.h index 64548e0e2..a57221f7f 100644 --- a/src/grib_api_prototypes.h +++ b/src/grib_api_prototypes.h @@ -1275,6 +1275,9 @@ void grib_check(const char *call, const char *file, int line, int e, const char /* grib_expression_class_binop.c */ 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_class_logical_and.c */ +grib_expression *new_logical_and_expression(grib_context *c, grib_expression *left, grib_expression *right); + /* grib_expression_class_is_in_dict.c */ grib_expression *new_is_in_dict_expression(grib_context *c, const char *name, const char *list); diff --git a/src/grib_expression_class.h b/src/grib_expression_class.h index 3e1d6c16b..8dc9ef5d8 100644 --- a/src/grib_expression_class.h +++ b/src/grib_expression_class.h @@ -9,6 +9,7 @@ extern grib_expression_class* grib_expression_class_is_in_dict; extern grib_expression_class* grib_expression_class_is_in_list; extern grib_expression_class* grib_expression_class_is_integer; extern grib_expression_class* grib_expression_class_length; +extern grib_expression_class* grib_expression_class_logical_and; extern grib_expression_class* grib_expression_class_long; extern grib_expression_class* grib_expression_class_string; extern grib_expression_class* grib_expression_class_string_compare; diff --git a/src/grib_expression_class_is_in_dict.c b/src/grib_expression_class_is_in_dict.c index 0d79ad263..df4ca7b77 100644 --- a/src/grib_expression_class_is_in_dict.c +++ b/src/grib_expression_class_is_in_dict.c @@ -233,13 +233,7 @@ grib_expression* new_is_in_dict_expression(grib_context* c,const char* name,cons static int native_type(grib_expression* g,grib_handle *h) { - grib_expression_is_in_dict* e = (grib_expression_is_in_dict*)g; - int type = 0; - int err; - if((err=grib_get_native_type(h,e->key,&type)) != GRIB_SUCCESS) - grib_context_log(h->context, GRIB_LOG_ERROR, - "Error in native_type %s : %s", e->key,grib_get_error_message(err)); - return type; + return GRIB_TYPE_LONG; } static void add_dependency(grib_expression* g, grib_accessor* observer){ diff --git a/src/grib_expression_class_is_integer.c b/src/grib_expression_class_is_integer.c index a2fa1a1c2..8446d1dae 100644 --- a/src/grib_expression_class_is_integer.c +++ b/src/grib_expression_class_is_integer.c @@ -140,9 +140,18 @@ static int evaluate_double(grib_expression *g,grib_handle *h,double* result) static string evaluate_string(grib_expression* g,grib_handle* h,char* buf,size_t* size,int* err) { long lresult=0; + double dresult=0.0; - *err=evaluate_long(g,h,&lresult); - sprintf(buf,"%ld",lresult); + switch (grib_expression_native_type(h, g)) { + case GRIB_TYPE_LONG: + *err=evaluate_long(g,h,&lresult); + sprintf(buf,"%ld",lresult); + break; + case GRIB_TYPE_DOUBLE: + *err=evaluate_double(g,h,&dresult); + sprintf(buf,"%g",dresult); + break; + } return buf; } @@ -193,12 +202,6 @@ grib_expression* new_is_integer_expression(grib_context* c,const char *name,int static int native_type(grib_expression* g,grib_handle *h) { - grib_expression_is_integer* e = (grib_expression_is_integer*)g; - int type = 0; - int err; - if((err=grib_get_native_type(h,e->name,&type)) != GRIB_SUCCESS) - grib_context_log(h->context, GRIB_LOG_ERROR, - "Error in native_type %s : %s", e->name,grib_get_error_message(err)); - return type; + return GRIB_TYPE_LONG; } diff --git a/src/grib_expression_class_length.c b/src/grib_expression_class_length.c index 2f858133b..84e7eff7c 100644 --- a/src/grib_expression_class_length.c +++ b/src/grib_expression_class_length.c @@ -182,11 +182,5 @@ grib_expression* new_length_expression(grib_context* c,const char *name) static int native_type(grib_expression* g,grib_handle *h) { - grib_expression_length* e = (grib_expression_length*)g; - int type = 0; - int err; - if((err=grib_get_native_type(h,e->name,&type)) != GRIB_SUCCESS) - grib_context_log(h->context, GRIB_LOG_ERROR, - "Error in native_type %s : %s", e->name,grib_get_error_message(err)); - return type; + return GRIB_TYPE_LONG; } diff --git a/src/grib_expression_class_logical_and.c b/src/grib_expression_class_logical_and.c new file mode 100644 index 000000000..727f80db8 --- /dev/null +++ b/src/grib_expression_class_logical_and.c @@ -0,0 +1,186 @@ +/* + * Copyright 2005-2017 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. + */ + +#include "grib_api_internal.h" + +/* + This is used by make_class.pl + + START_CLASS_DEF + CLASS = expression + IMPLEMENTS = init_class + IMPLEMENTS = destroy + IMPLEMENTS = native_type + IMPLEMENTS = evaluate_long + IMPLEMENTS = evaluate_double + IMPLEMENTS = print + IMPLEMENTS = add_dependency + MEMBERS = grib_expression *left + MEMBERS = grib_expression *right + END_CLASS_DEF + + */ +/* START_CLASS_IMP */ + +/* + +Don't edit anything between START_CLASS_IMP and END_CLASS_IMP +Instead edit values between START_CLASS_DEF and END_CLASS_DEF +or edit "expression.class" and rerun ./make_class.pl + +*/ + +typedef const char* string; /* to keep make_class.pl happy */ + + +static void init_class (grib_expression_class*); + +static void destroy(grib_context*,grib_expression* e); + +static void print(grib_context*,grib_expression*,grib_handle*); +static void add_dependency(grib_expression* e, grib_accessor* observer); + +static int native_type(grib_expression*,grib_handle*); + +static int evaluate_long(grib_expression*,grib_handle*,long*); +static int evaluate_double(grib_expression*,grib_handle*,double*); + +typedef struct grib_expression_logical_and{ + grib_expression base; +/* Members defined in logical_and */ + grib_expression *left; + grib_expression *right; +} grib_expression_logical_and; + + +static grib_expression_class _grib_expression_class_logical_and = { + 0, /* super */ + "logical_and", /* name */ + sizeof(grib_expression_logical_and),/* size of instance */ + 0, /* inited */ + &init_class, /* init_class */ + 0, /* constructor */ + &destroy, /* destructor */ + &print, + &add_dependency, + + &native_type, + 0, + + &evaluate_long, + &evaluate_double, + 0, +}; + +grib_expression_class* grib_expression_class_logical_and = &_grib_expression_class_logical_and; + + +static void init_class(grib_expression_class* c) +{ +} +/* END_CLASS_IMP */ + +static int evaluate_long(grib_expression *g,grib_handle* h,long* lres) +{ + long v1=0; + long v2=0; + double dv1=0; + double dv2=0; + int ret; + grib_expression_logical_and* e = (grib_expression_logical_and*)g; + + + switch (grib_expression_native_type(h, e->left)) { + case GRIB_TYPE_LONG: + ret = grib_expression_evaluate_long(h,e->left,&v1); + if (ret != GRIB_SUCCESS) return ret; + if (v1 == 0) { + *lres=0; + return ret; + } + break; + case GRIB_TYPE_DOUBLE: + ret = grib_expression_evaluate_double(h,e->left,&dv1); + if (ret != GRIB_SUCCESS) return ret; + if (dv1 == 0) { + *lres=0; + return ret; + } + break; + default : + return GRIB_INVALID_TYPE; + } + + switch (grib_expression_native_type(h, e->right)) { + case GRIB_TYPE_LONG: + ret = grib_expression_evaluate_long(h,e->right,&v2); + if (ret != GRIB_SUCCESS) return ret; + *lres = v2 ? 1 : 0; + break; + case GRIB_TYPE_DOUBLE: + ret = grib_expression_evaluate_double(h,e->right,&dv2); + if (ret != GRIB_SUCCESS) return ret; + *lres = dv2 ? 1 : 0; + break; + default : + return GRIB_INVALID_TYPE; + } + + return GRIB_SUCCESS; +} + +static int evaluate_double(grib_expression *g,grib_handle* h,double* dres) +{ + long lres=0; + int ret=0; + + ret=evaluate_long(g,h,&lres); + *dres=(double)lres; + + return ret; +} + +static void print(grib_context* c,grib_expression* g,grib_handle* f) +{ + grib_expression_logical_and* e = (grib_expression_logical_and*)g; + printf("("); + grib_expression_print(c,e->left,f); + printf(" && "); + grib_expression_print(c,e->right,f); + printf(")"); +} + +static void destroy(grib_context* c,grib_expression* g) +{ + grib_expression_logical_and* e = (grib_expression_logical_and*)g; + grib_expression_free(c,e->left); + grib_expression_free(c,e->right); +} + +static void add_dependency(grib_expression* g, grib_accessor* observer) +{ + grib_expression_logical_and* e = (grib_expression_logical_and*)g; + grib_dependency_observe_expression(observer,e->left); + grib_dependency_observe_expression(observer,e->right); +} + +grib_expression* new_logical_and_expression(grib_context* c, grib_expression* left,grib_expression* right) +{ + grib_expression_logical_and* e = (grib_expression_logical_and*)grib_context_malloc_clear_persistent(c,sizeof(grib_expression_logical_and)); + e->base.cclass = grib_expression_class_logical_and; + e->left = left; + e->right = right; + return (grib_expression*)e; +} + +static int native_type(grib_expression* g,grib_handle *h) +{ + return GRIB_TYPE_LONG; +} diff --git a/src/grib_expression_factory.h b/src/grib_expression_factory.h index a30663ee8..1988b7e77 100644 --- a/src/grib_expression_factory.h +++ b/src/grib_expression_factory.h @@ -9,6 +9,7 @@ { "is_in_list", &grib_expression_class_is_in_list, }, { "is_integer", &grib_expression_class_is_integer, }, { "length", &grib_expression_class_length, }, +{ "logical_and", &grib_expression_class_logical_and, }, { "long", &grib_expression_class_long, }, { "string", &grib_expression_class_string, }, { "string_compare", &grib_expression_class_string_compare, }, diff --git a/src/grib_lex.c b/src/grib_lex.c index 2f6b9a15b..00e15265d 100644 --- a/src/grib_lex.c +++ b/src/grib_lex.c @@ -197,12 +197,12 @@ struct grib_yy_buffer_state /* Size of input buffer in bytes, not including room for EOB * characters. */ - grib_yy_size_t grib_yy_buf_size; + int grib_yy_buf_size; /* Number of characters read into grib_yy_ch_buf, not including EOB * characters. */ - grib_yy_size_t grib_yy_n_chars; + int grib_yy_n_chars; /* Whether we "own" the buffer - i.e., we know we created it, * and can realloc() it to grow it, and should free() it to @@ -272,7 +272,7 @@ static YY_BUFFER_STATE * grib_yy_buffer_stack = 0; /**< Stack as an array. */ /* grib_yy_hold_char holds the character lost when grib_yytext is formed. */ static char grib_yy_hold_char; -static grib_yy_size_t grib_yy_n_chars; /* number of characters read into grib_yy_ch_buf */ +static int grib_yy_n_chars; /* number of characters read into grib_yy_ch_buf */ grib_yy_size_t grib_yyleng; /* Points to current character in buffer. */ @@ -356,7 +356,7 @@ static void grib_yy_fatal_error (grib_yyconst char msg[] ); */ #define YY_DO_BEFORE_ACTION \ (grib_yytext_ptr) = grib_yy_bp; \ - grib_yyleng = (size_t) (grib_yy_cp - grib_yy_bp); \ + grib_yyleng = (int) (grib_yy_cp - grib_yy_bp); \ (grib_yy_hold_char) = *grib_yy_cp; \ *grib_yy_cp = '\0'; \ (grib_yy_c_buf_p) = grib_yy_cp; @@ -1320,7 +1320,7 @@ static int input (void ); else \ { \ errno=0; \ - while ( (result = fread(buf, 1, max_size, grib_yyin))==0 && ferror(grib_yyin)) \ + while ( (result = (int) fread(buf, 1, max_size, grib_yyin))==0 && ferror(grib_yyin)) \ { \ if( errno != EINTR) \ { \ @@ -1449,7 +1449,7 @@ grib_yy_match: if ( grib_yy_current_state >= 798 ) grib_yy_c = grib_yy_meta[(unsigned int) grib_yy_c]; } - grib_yy_current_state = grib_yy_nxt[grib_yy_base[grib_yy_current_state] + (unsigned int) grib_yy_c]; + grib_yy_current_state = grib_yy_nxt[grib_yy_base[grib_yy_current_state] + (flex_int16_t) grib_yy_c]; ++grib_yy_cp; } while ( grib_yy_base[grib_yy_current_state] != 1945 ); @@ -2401,7 +2401,7 @@ static int grib_yy_get_next_buffer (void) else { - grib_yy_size_t num_to_read = + int num_to_read = YY_CURRENT_BUFFER_LVALUE->grib_yy_buf_size - number_to_move - 1; while ( num_to_read <= 0 ) @@ -2436,7 +2436,7 @@ static int grib_yy_get_next_buffer (void) (grib_yy_c_buf_p) = &b->grib_yy_ch_buf[grib_yy_c_buf_p_offset]; - num_to_read = YY_CURRENT_BUFFER_LVALUE->grib_yy_buf_size - + num_to_read = (int) YY_CURRENT_BUFFER_LVALUE->grib_yy_buf_size - number_to_move - 1; } @@ -2470,9 +2470,9 @@ static int grib_yy_get_next_buffer (void) else ret_val = EOB_ACT_CONTINUE_SCAN; - if ((grib_yy_size_t) ((grib_yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->grib_yy_buf_size) { + if ((int) ((grib_yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->grib_yy_buf_size) { /* Extend the array by 50%, plus the number we really need. */ - grib_yy_size_t new_size = (grib_yy_n_chars) + number_to_move + ((grib_yy_n_chars) >> 1); + int new_size = (grib_yy_n_chars) + number_to_move + ((grib_yy_n_chars) >> 1); YY_CURRENT_BUFFER_LVALUE->grib_yy_ch_buf = (char *) grib_yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->grib_yy_ch_buf,new_size ); if ( ! YY_CURRENT_BUFFER_LVALUE->grib_yy_ch_buf ) YY_FATAL_ERROR( "out of dynamic memory in grib_yy_get_next_buffer()" ); @@ -2510,7 +2510,7 @@ static int grib_yy_get_next_buffer (void) if ( grib_yy_current_state >= 798 ) grib_yy_c = grib_yy_meta[(unsigned int) grib_yy_c]; } - grib_yy_current_state = grib_yy_nxt[grib_yy_base[grib_yy_current_state] + (unsigned int) grib_yy_c]; + grib_yy_current_state = grib_yy_nxt[grib_yy_base[grib_yy_current_state] + (flex_int16_t) grib_yy_c]; } return grib_yy_current_state; @@ -2538,7 +2538,7 @@ static int grib_yy_get_next_buffer (void) if ( grib_yy_current_state >= 798 ) grib_yy_c = grib_yy_meta[(unsigned int) grib_yy_c]; } - grib_yy_current_state = grib_yy_nxt[grib_yy_base[grib_yy_current_state] + (unsigned int) grib_yy_c]; + grib_yy_current_state = grib_yy_nxt[grib_yy_base[grib_yy_current_state] + (flex_int16_t) grib_yy_c]; grib_yy_is_jam = (grib_yy_current_state == 797); return grib_yy_is_jam ? 0 : grib_yy_current_state; @@ -2556,7 +2556,7 @@ static int grib_yy_get_next_buffer (void) if ( grib_yy_cp < YY_CURRENT_BUFFER_LVALUE->grib_yy_ch_buf + 2 ) { /* need to shift things up to make room */ /* +2 for EOB chars. */ - register grib_yy_size_t number_to_move = (grib_yy_n_chars) + 2; + register int number_to_move = (grib_yy_n_chars) + 2; register char *dest = &YY_CURRENT_BUFFER_LVALUE->grib_yy_ch_buf[ YY_CURRENT_BUFFER_LVALUE->grib_yy_buf_size + 2]; register char *source = @@ -2568,7 +2568,7 @@ static int grib_yy_get_next_buffer (void) grib_yy_cp += (int) (dest - source); grib_yy_bp += (int) (dest - source); YY_CURRENT_BUFFER_LVALUE->grib_yy_n_chars = - (grib_yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->grib_yy_buf_size; + (grib_yy_n_chars) = (int) YY_CURRENT_BUFFER_LVALUE->grib_yy_buf_size; if ( grib_yy_cp < YY_CURRENT_BUFFER_LVALUE->grib_yy_ch_buf + 2 ) YY_FATAL_ERROR( "flex scanner push-back overflow" ); @@ -2964,7 +2964,7 @@ YY_BUFFER_STATE grib_yy_scan_buffer (char * base, grib_yy_size_t size ) YY_BUFFER_STATE grib_yy_scan_string (grib_yyconst char * grib_yystr ) { - return grib_yy_scan_bytes(grib_yystr,strlen(grib_yystr) ); + return grib_yy_scan_bytes(grib_yystr,(int) strlen(grib_yystr) ); } /** Setup the input buffer state to scan the given bytes. The next call to grib_yylex() will @@ -2982,7 +2982,7 @@ YY_BUFFER_STATE grib_yy_scan_bytes (grib_yyconst char * grib_yybytes, grib_yy_s int i; /* Get memory for full buffer, including space for trailing EOB's. */ - n = _grib_yybytes_len + 2; + n = (grib_yy_size_t) _grib_yybytes_len + 2; buf = (char *) grib_yyalloc(n ); if ( ! buf ) YY_FATAL_ERROR( "out of dynamic memory in grib_yy_scan_bytes()" ); diff --git a/src/grib_yacc.c b/src/grib_yacc.c index 266554a6f..bb9c00c9d 100644 --- a/src/grib_yacc.c +++ b/src/grib_yacc.c @@ -3911,7 +3911,7 @@ grib_yyreduce: case 252: /* Line 1792 of yacc.c */ #line 820 "griby.y" - { (grib_yyval.exp) = new_binop_expression(grib_parser_context,&grib_op_and,NULL,(grib_yyvsp[(1) - (3)].exp),(grib_yyvsp[(3) - (3)].exp)); } + { (grib_yyval.exp) = new_logical_and_expression(grib_parser_context,(grib_yyvsp[(1) - (3)].exp),(grib_yyvsp[(3) - (3)].exp)); } break; case 254: diff --git a/src/griby.y b/src/griby.y index 61262e37f..6132fb676 100644 --- a/src/griby.y +++ b/src/griby.y @@ -817,7 +817,7 @@ condition : condition GT term { $$ = new_binop_expression(grib_parser_con | term ; -conjonction : conjonction AND condition { $$ = new_binop_expression(grib_parser_context,&grib_op_and,NULL,$1,$3); } +conjonction : conjonction AND condition { $$ = new_logical_and_expression(grib_parser_context,$1,$3); } | condition ;