core
/
eccodes
mirror of https://github.com/ecmwf/eccodes.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

bufr_dump -Efilter working for some data and added test ECC-285

This commit is contained in:
Enrico Fucile 2016-07-01 15:46:07 +01:00
parent 61b6f343da
commit 89b6ae850e
20 changed files with 693 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
definitions/bufr/rdb_key.def
View File

@ -14,8 +14,6 @@ meta localMinute bits(keyData,27,6) : long_type,no_copy;
meta localSecond bits(keyData,33,6) : long_type,no_copy;
meta spare bits(keyData,39,1) : no_copy; # 40 bits = 10 bytes
meta ls.typicalDate sprintf("%.4d%.2d%.2d",localYear,localMonth,localDay) : dump,no_copy;
meta ls.typicalTime sprintf("%.2d%.2d%.2d",localHour,localMinute,localSecond) :dump,no_copy;
# isSatellite and other stuff moved to section 3
ascii[8] keyMore : hidden;

5
definitions/bufr/section.1.3.def
View File

@ -35,6 +35,11 @@ unsigned[1] typicalDay : dump;
unsigned[1] typicalHour : dump;
unsigned[1] typicalMinute : dump;
unsigned[1] spare; # ???
transient typicalSecond=0;
meta ls.typicalDate sprintf("%.4d%.2d%.2d",typicalYear,typicalMonth,typicalDay) : dump,no_copy,read_only;
meta ls.typicalTime sprintf("%.2d%.2d%.2d",typicalHour,typicalMinute,typicalSecond) :dump,no_copy,read_only;
alias ls.centre=bufrHeaderCentre;
alias ls.masterTablesVersionNumber=masterTablesVersionNumber;

3
definitions/bufr/section.1.4.def
View File

@ -37,6 +37,9 @@ unsigned[1] typicalHour : dump;
unsigned[1] typicalMinute : dump;
unsigned[1] typicalSecond : dump;
meta ls.typicalDate sprintf("%.4d%.2d%.2d",typicalYear,typicalMonth,typicalDay) : dump,no_copy,read_only;
meta ls.typicalTime sprintf("%.2d%.2d%.2d",typicalHour,typicalMinute,typicalSecond) :dump,no_copy,read_only;
alias ls.masterTablesVersionNumber=masterTablesVersionNumber;
alias ls.localTablesVersionNumber=localTablesVersionNumber;

12
definitions/metar/cccc.def
View File

@ -1,15 +1,15 @@
rename(g,CCCC);
modify CCCC : dump,json,xml;
modify CCCC : dump;
group g : dump ; non_alpha na;
if (is_in_dict(CCCC,"metar/nsd_cccc.txt")) {
constant coordinatesPresent=one : dump;
latitudeSexagesimal=dict_search("metar/nsd_cccc.txt",CCCC,7) : string_type,hidden ;
longitudeSexagesimal=dict_search("metar/nsd_cccc.txt",CCCC,8) : string_type,hidden ;
latitude = sexagesimal2decimal(latitudeSexagesimal) : dump,json;
longitude = sexagesimal2decimal(longitudeSexagesimal) : dump,json;
elevation=dict_search("metar/nsd_cccc.txt",CCCC,11) : dump,json ;
name=dict_search("metar/nsd_cccc.txt",CCCC,3) : string_type,dump,json ;
country=dict_search("metar/nsd_cccc.txt",CCCC,5) : string_type,dump,json ;
latitude = sexagesimal2decimal(latitudeSexagesimal) : dump;
longitude = sexagesimal2decimal(longitudeSexagesimal) : dump;
elevation=dict_search("metar/nsd_cccc.txt",CCCC,11) : dump ;
name=dict_search("metar/nsd_cccc.txt",CCCC,3) : string_type,dump ;
country=dict_search("metar/nsd_cccc.txt",CCCC,5) : string_type,dump ;
} else {
constant coordinatesPresent=zero : dump;
}

12
definitions/taf/cccc.def
View File

@ -1,15 +1,15 @@
rename(g,CCCC);
modify CCCC : dump,json,xml;
modify CCCC : dump;
group g : dump ; non_alpha na;
if (is_in_dict(CCCC,"metar/nsd_cccc.txt")) {
constant coordinatesPresent=one : dump;
latitudeSexagesimal=dict_search("metar/nsd_cccc.txt",CCCC,7) : string_type,hidden ;
longitudeSexagesimal=dict_search("metar/nsd_cccc.txt",CCCC,8) : string_type,hidden ;
latitude = sexagesimal2decimal(latitudeSexagesimal) : dump,json;
longitude = sexagesimal2decimal(longitudeSexagesimal) : dump,json;
elevation=dict_search("metar/nsd_cccc.txt",CCCC,11) : dump,json ;
name=dict_search("metar/nsd_cccc.txt",CCCC,3) : string_type,dump,json ;
country=dict_search("metar/nsd_cccc.txt",CCCC,5) : string_type,dump,json ;
latitude = sexagesimal2decimal(latitudeSexagesimal) : dump;
longitude = sexagesimal2decimal(longitudeSexagesimal) : dump;
elevation=dict_search("metar/nsd_cccc.txt",CCCC,11) : dump ;
name=dict_search("metar/nsd_cccc.txt",CCCC,3) : string_type,dump ;
country=dict_search("metar/nsd_cccc.txt",CCCC,5) : string_type,dump ;
} else {
constant coordinatesPresent=zero : dump;
}

1
src/CMakeLists.txt
View File

@ -272,6 +272,7 @@ list( APPEND grib_api_srcs
grib_dumper_class_debug.c
grib_dumper_class_default.c
grib_dumper_class_keys.c
grib_dumper_class_filter.c
grib_dumper_class_json.c
grib_dumper_class_xml.c
grib_dumper_class_c_code.c

2
src/grib_accessor_class_bufr_data_array.c
View File

@ -1378,7 +1378,7 @@ static grib_accessor* create_accessor_from_descriptor(grib_accessor* a,grib_acce
creator.name=grib_context_strdup(a->context,self->expanded->v[idx]->shortName);
elementAccessor = grib_accessor_factory(section, &creator, 0, NULL);
if (self->canBeMissing[idx]) elementAccessor->flags |= GRIB_ACCESSOR_FLAG_CAN_BE_MISSING;
if (self->expanded->v[idx]->code == 31000 || self->expanded->v[idx]->code == 31001 || self->expanded->v[idx]->code == 31002)
if (self->expanded->v[idx]->code == 31000 || self->expanded->v[idx]->code == 31001 || self->expanded->v[idx]->code == 31002 || self->expanded->v[idx]->code == 31031)
elementAccessor->flags |= GRIB_ACCESSOR_FLAG_READ_ONLY;
accessor_bufr_data_element_set_index(elementAccessor,ide);
accessor_bufr_data_element_set_descriptors(elementAccessor,self->expanded);

1
src/grib_api.h
View File

@ -422,6 +422,7 @@ int grib_write_message(grib_handle* h,const char* file,const char* mode);
typedef struct grib_string_list grib_string_list;
struct grib_string_list {
char* value;
int count;
grib_string_list* next;
};

1
src/grib_api_prototypes.h
View File

@ -1185,6 +1185,7 @@ int grib_set_missing_internal(grib_handle *h, const char *name);
int grib_set_missing(grib_handle *h, const char *name);
int grib_is_missing_long(grib_accessor *a, long x);
int grib_is_missing_double(grib_accessor *a, double x);
int grib_is_missing_string(grib_accessor* a,char* x,size_t len);
int grib_accessor_is_missing(grib_accessor *a, int *err);
int grib_is_missing(grib_handle *h, const char *name, int *err);
int grib_is_defined(grib_handle *h, const char *name);

1
src/grib_dumper_class.h
View File

@ -4,6 +4,7 @@ extern grib_dumper_class* grib_dumper_class_compare;
extern grib_dumper_class* grib_dumper_class_debug;
extern grib_dumper_class* grib_dumper_class_default;
extern grib_dumper_class* grib_dumper_class_file;
extern grib_dumper_class* grib_dumper_class_filter;
extern grib_dumper_class* grib_dumper_class_json;
extern grib_dumper_class* grib_dumper_class_keys;
extern grib_dumper_class* grib_dumper_class_serialize;

574
src/grib_dumper_class_filter.c Normal file
View File

@ -0,0 +1,574 @@
/*
* Copyright 2005-2016 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"
#include <ctype.h>
/*
This is used by make_class.pl
START_CLASS_DEF
CLASS = dumper
IMPLEMENTS = dump_long;dump_bits
IMPLEMENTS = dump_double;dump_string;dump_string_array
IMPLEMENTS = dump_bytes;dump_values
IMPLEMENTS = dump_label;dump_section
IMPLEMENTS = init;destroy
MEMBERS = long section_offset
MEMBERS = long begin
MEMBERS = long empty
MEMBERS = long end
MEMBERS = long isLeaf
MEMBERS = long isAttribute
MEMBERS = grib_string_list* keys
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 "dumper.class" and rerun ./make_class.pl
*/
static void init_class (grib_dumper_class*);
static int init (grib_dumper* d);
static int destroy (grib_dumper*);
static void dump_long (grib_dumper* d, grib_accessor* a,const char* comment);
static void dump_bits (grib_dumper* d, grib_accessor* a,const char* comment);
static void dump_double (grib_dumper* d, grib_accessor* a,const char* comment);
static void dump_string (grib_dumper* d, grib_accessor* a,const char* comment);
static void dump_string_array (grib_dumper* d, grib_accessor* a,const char* comment);
static void dump_bytes (grib_dumper* d, grib_accessor* a,const char* comment);
static void dump_values (grib_dumper* d, grib_accessor* a);
static void dump_label (grib_dumper* d, grib_accessor* a,const char* comment);
static void dump_section (grib_dumper* d, grib_accessor* a,grib_block_of_accessors* block);
typedef struct grib_dumper_filter {
grib_dumper dumper;
/* Members defined in filter */
long section_offset;
long begin;
long empty;
long end;
long isLeaf;
long isAttribute;
grib_string_list* keys;
} grib_dumper_filter;
static grib_dumper_class _grib_dumper_class_filter = {
0, /* super */
"filter", /* name */
sizeof(grib_dumper_filter), /* size */
0, /* inited */
&init_class, /* init_class */
&init, /* init */
&destroy, /* free mem */
&dump_long, /* dump long */
&dump_double, /* dump double */
&dump_string, /* dump string */
&dump_string_array, /* dump string array */
&dump_label, /* dump labels */
&dump_bytes, /* dump bytes */
&dump_bits, /* dump bits */
&dump_section, /* dump section */
&dump_values, /* dump values */
0, /* header */
0, /* footer */
};
grib_dumper_class* grib_dumper_class_filter = &_grib_dumper_class_filter;
/* END_CLASS_IMP */
static void dump_attributes(grib_dumper* d,grib_accessor* a);
GRIB_INLINE static int grib_inline_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;
}
typedef struct string_count string_count;
struct string_count {
char* value;
int count;
string_count* next;
};
static int get_key_rank(grib_handle* h,grib_string_list* keys,const char* key) {
grib_string_list* next=keys;
grib_string_list* prev=keys;
int ret=0;
size_t size=0;
grib_context* c=h->context;
while (next && next->value && grib_inline_strcmp(next->value,key)) {
prev=next;
next=next->next;
}
if (!next) {
prev->next=(grib_string_list*)grib_context_malloc_clear(c,sizeof(grib_string_list));
next=prev->next;
}
if (!next->value) {
next->value=strdup(key);
next->count=0;
}
next->count++;
ret=next->count;
if (ret==1) {
char* s=grib_context_malloc_clear(c,strlen(key)+5);
sprintf(s,"#2#%s",key);
if (grib_get_size(h,s,&size)==GRIB_NOT_FOUND) ret=0;
}
return ret;
}
static int depth=0;
static void init_class (grib_dumper_class* c){}
static int init(grib_dumper* d)
{
grib_dumper_filter *self = (grib_dumper_filter*)d;
grib_context* c=d->handle->context;
self->section_offset=0;
self->empty=1;
self->isLeaf=0;
self->isAttribute=0;
self->keys=grib_context_malloc_clear(c,sizeof(grib_string_list));
return GRIB_SUCCESS;
}
static int destroy(grib_dumper* d)
{
grib_dumper_filter *self = (grib_dumper_filter*)d;
grib_string_list* next=self->keys;
grib_string_list* cur=self->keys;
grib_context* c=d->handle->context;
while(next) {
cur=next;
next=next->next;
grib_context_free(c,cur->value);
grib_context_free(c,cur);
}
return GRIB_SUCCESS;
}
static void dump_values(grib_dumper* d,grib_accessor* a)
{
grib_dumper_filter *self = (grib_dumper_filter*)d;
double value; size_t size = 1;
double *values=NULL;
int err = 0;
int i,r;
int cols=9;
long count=0;
double missing_value = GRIB_MISSING_DOUBLE;
grib_context* c=a->context;
grib_handle* h=grib_handle_of_accessor(a);
grib_value_count(a,&count);
size=count;
if ( (a->flags & GRIB_ACCESSOR_FLAG_DUMP) == 0 || (a->flags & GRIB_ACCESSOR_FLAG_READ_ONLY) !=0)
return;
if (size>1) {
values=(double*)grib_context_malloc_clear(a->context,sizeof(double)*size);
err=grib_unpack_double(a,values,&size);
} else {
err=grib_unpack_double(a,&value,&size);
}
self->begin=0;
self->empty=0;
err = grib_set_double(h, "missingValue", missing_value);
if (size>1) {
int icount=0;
if ((r=get_key_rank(h,self->keys,a->name))!=0)
fprintf(self->dumper.out,"set #%d#%s=",r,a->name);
else
fprintf(self->dumper.out,"set %s=",a->name);
fprintf(self->dumper.out,"{");
for (i=0; i<size-1; ++i) {
if (icount>cols || i==0) {fprintf(self->dumper.out,"\n ");icount=0;}
if (values[i] == missing_value)
fprintf(self->dumper.out,"missing, \n");
else
fprintf(self->dumper.out,"%g, ", values[i]);
icount++;
}
if (icount>cols || i==0) {fprintf(self->dumper.out,"\n ");icount=0;}
if (grib_is_missing_double(a,values[i]))
fprintf(self->dumper.out, "%s","missing");
else
fprintf(self->dumper.out, "%g",values[i]);
depth-=2;
fprintf(self->dumper.out,"};\n");
grib_context_free(a->context,values);
} else {
r=get_key_rank(h,self->keys,a->name);
if( !grib_is_missing_double(a,value) ) {
if (r!=0)
fprintf(self->dumper.out,"set #%d#%s=",r,a->name);
else
fprintf(self->dumper.out,"set %s=",a->name);
fprintf(self->dumper.out,"%g;\n",value);
}
}
if (self->isLeaf==0) {
dump_attributes(d,a);
depth-=2;
}
(void)err; /* TODO */
}
static void dump_long(grib_dumper* d,grib_accessor* a,const char* comment)
{
grib_dumper_filter *self = (grib_dumper_filter*)d;
long value; size_t size = 1;
long *values=NULL;
int err = 0;
int i,r;
int cols=9;
long count=0;
grib_handle* h=grib_handle_of_accessor(a);
grib_value_count(a,&count);
size=count;
if ( (a->flags & GRIB_ACCESSOR_FLAG_DUMP) == 0 || (a->flags & GRIB_ACCESSOR_FLAG_READ_ONLY) != 0)
return;
if (size>1) {
values=(long*)grib_context_malloc_clear(a->context,sizeof(long)*size);
err=grib_unpack_long(a,values,&size);
} else {
err=grib_unpack_long(a,&value,&size);
}
self->begin=0;
self->empty=0;
if (size>1) {
int icount=0;
if ((r=get_key_rank(h,self->keys,a->name))!=0)
fprintf(self->dumper.out,"set #%d#%s=",r,a->name);
else
fprintf(self->dumper.out,"set %s=",a->name);
fprintf(self->dumper.out,"{");
for (i=0;i<size-1;i++) {
if (icount>cols || i==0) {fprintf(self->dumper.out,"\n ");icount=0;}
if (grib_is_missing_long(a,values[i])) {
fprintf(self->dumper.out,"missing, ");
} else {
fprintf(self->dumper.out,"%ld, ",values[i]);
}
icount++;
}
if (icount>cols || i==0) {fprintf(self->dumper.out,"\n ");icount=0;}
if (grib_is_missing_long(a,values[i])) {
fprintf(self->dumper.out,"missing ");
} else {
fprintf(self->dumper.out,"%ld ",values[i]);
}
depth-=2;
fprintf(self->dumper.out,"};\n");
grib_context_free(a->context,values);
} else {
r=get_key_rank(h,self->keys,a->name);
if( !grib_is_missing_long(a,value) ) {
if (r!=0)
fprintf(self->dumper.out,"set #%d#%s=",r,a->name);
else
fprintf(self->dumper.out,"set %s=",a->name);
fprintf(self->dumper.out,"%ld;\n",value);
}
}
if (self->isLeaf==0) {
dump_attributes(d,a);
depth-=2;
}
(void)err; /* TODO */
}
static void dump_bits(grib_dumper* d,grib_accessor* a,const char* comment)
{
}
static void dump_double(grib_dumper* d,grib_accessor* a,const char* comment)
{
grib_dumper_filter *self = (grib_dumper_filter*)d;
double value; size_t size = 1;
int r;
grib_handle* h=grib_handle_of_accessor(a);
grib_unpack_double(a,&value,&size);
if ( (a->flags & GRIB_ACCESSOR_FLAG_DUMP) == 0 || (a->flags & GRIB_ACCESSOR_FLAG_READ_ONLY) != 0)
return;
self->begin=0;
self->empty=0;
r=get_key_rank(h,self->keys,a->name);
if( !grib_is_missing_double(a,value) ) {
if (r!=0)
fprintf(self->dumper.out,"set #%d#%s=",r,a->name);
else
fprintf(self->dumper.out,"set %s=",a->name);
fprintf(self->dumper.out,"%g;\n",value);
}
if (self->isLeaf==0) {
dump_attributes(d,a);
}
}
static void dump_string_array(grib_dumper* d,grib_accessor* a,const char* comment)
{
grib_dumper_filter *self = (grib_dumper_filter*)d;
char **values;
size_t size = 0,i=0;
grib_context* c=NULL;
int err = 0;
long count=0;
int r;
grib_handle* h=grib_handle_of_accessor(a);
c=a->context;
if ( (a->flags & GRIB_ACCESSOR_FLAG_DUMP) == 0 || (a->flags & GRIB_ACCESSOR_FLAG_READ_ONLY) != 0)
return;
grib_value_count(a,&count);
size=count;
if (size==1) {
dump_string(d,a,comment);
return;
}
self->begin=0;
if (self->isLeaf==0) {
depth+=2;
if ((r=get_key_rank(h,self->keys,a->name))!=0)
fprintf(self->dumper.out,"set #%d#%s=",r,a->name);
else
fprintf(self->dumper.out,"set %s=",a->name);
}
self->empty=0;
values=(char**)grib_context_malloc_clear(c,size*sizeof(char*));
if (!values) {
grib_context_log(c,GRIB_LOG_FATAL,"unable to allocate %d bytes",(int)size);
return;
}
err = grib_unpack_string_array(a,values,&size);
fprintf(self->dumper.out,"{",depth," ");
depth+=2;
for (i=0;i<size-1;i++) {
fprintf(self->dumper.out,"\"%s\",\n",depth," ",values[i]);
}
fprintf(self->dumper.out,"\"%s\"\n",depth," ",values[i]);
depth-=2;
fprintf(self->dumper.out,"};",depth," ");
if (self->isLeaf==0) {
dump_attributes(d,a);
depth-=2;
}
grib_context_free(c,values);
(void)err; /* TODO */
}
static void dump_string(grib_dumper* d,grib_accessor* a,const char* comment)
{
grib_dumper_filter *self = (grib_dumper_filter*)d;
char *value=NULL;
char *p = NULL;
size_t size = 0;
grib_context* c=NULL;
int r;
int err = _grib_get_string_length(a,&size);
grib_handle* h=grib_handle_of_accessor(a);
c=a->context;
if (size==0) return;
if ( (a->flags & GRIB_ACCESSOR_FLAG_DUMP) == 0 || (a->flags & GRIB_ACCESSOR_FLAG_READ_ONLY) != 0)
return;
value=(char*)grib_context_malloc_clear(c,size);
if (!value) {
grib_context_log(c,GRIB_LOG_FATAL,"unable to allocate %d bytes",(int)size);
return;
}
else self->begin=0;
self->empty=0;
err = grib_unpack_string(a,value,&size);
p=value;
r=get_key_rank(h,self->keys,a->name);
if (grib_is_missing_string(a,value,size))
return;
while(*p) { if(!isprint(*p)) *p = '.'; p++; }
if (self->isLeaf==0) {
depth+=2;
if (r!=0)
fprintf(self->dumper.out,"set #%d#%s=",r,a->name);
else
fprintf(self->dumper.out,"set %s=",a->name);
}
fprintf(self->dumper.out,"\"%s\";\n",value);
if (self->isLeaf==0) {
dump_attributes(d,a);
depth-=2;
}
grib_context_free(c,value);
(void)err; /* TODO */
}
static void dump_bytes(grib_dumper* d,grib_accessor* a,const char* comment)
{
}
static void dump_label(grib_dumper* d,grib_accessor* a,const char* comment)
{
}
static void _dump_long_array(grib_handle* h,FILE* f,const char* key,const char* print_key) {
long* val;
size_t size=0,i;
int cols=9,icount=0;
if (grib_get_size(h,key,&size)==GRIB_NOT_FOUND) return;
val=grib_context_malloc_clear(h->context,sizeof(long)*size);
grib_get_long_array(h,key,val,&size);
fprintf(f,"set %s= {",print_key);
for (i=0;i<size-1;i++) {
if (icount>cols || i==0) {fprintf(f,"\n ");icount=0;}
fprintf(f,"%ld, ",val[i]);
icount++;
}
if (icount>cols) {fprintf(f,"\n ");}
fprintf(f,"%ld};\n",val[size-1]);
grib_context_free(h->context,val);
}
static void dump_section(grib_dumper* d,grib_accessor* a,grib_block_of_accessors* block)
{
grib_dumper_filter *self = (grib_dumper_filter*)d;
if (!grib_inline_strcmp(a->name,"BUFR") ||
!grib_inline_strcmp(a->name,"GRIB") ||
!grib_inline_strcmp(a->name,"META")
) {
grib_handle* h=grib_handle_of_accessor(a);
depth=2;
self->begin=1;
self->empty=1;
depth+=2;
_dump_long_array(h,self->dumper.out,"dataPresentIndicator","inputDataPresentIndicator");
_dump_long_array(h,self->dumper.out,"delayedDescriptorReplicationFactor","inputDelayedDescriptorReplicationFactor");
_dump_long_array(h,self->dumper.out,"shortDelayedDescriptorReplicationFactor","inputShortDelayedDescriptorReplicationFactor");
_dump_long_array(h,self->dumper.out,"extendedDelayedDescriptorReplicationFactor","inputExtendedDelayedDescriptorReplicationFactor");
grib_dump_accessors_block(d,block);
depth-=2;
} else if (!grib_inline_strcmp(a->name,"groupNumber")) {
if ( (a->flags & GRIB_ACCESSOR_FLAG_DUMP) == 0)
return;
self->begin=1;
self->empty=1;
depth+=2;
grib_dump_accessors_block(d,block);
depth-=2;
} else {
grib_dump_accessors_block(d,block);
}
}
static void dump_attributes(grib_dumper* d,grib_accessor* a)
{
int i=0;
grib_dumper_filter *self = (grib_dumper_filter*)d;
FILE* out=self->dumper.out;
unsigned long flags;
while (a->attributes[i] && i < MAX_ACCESSOR_ATTRIBUTES) {
self->isAttribute=1;
if ( (d->option_flags & GRIB_DUMP_FLAG_ALL_ATTRIBUTES ) == 0
&& (a->attributes[i]->flags & GRIB_ACCESSOR_FLAG_DUMP)== 0 )
{
i++;
continue;
}
self->isLeaf=a->attributes[i]->attributes[0]==NULL ? 1 : 0;
/* fprintf(self->dumper.out,","); */
/* fprintf(self->dumper.out,"\n%-*s",depth," "); */
/* fprintf(out,"\"%s\" : ",a->attributes[i]->name); */
flags=a->attributes[i]->flags;
a->attributes[i]->flags |= GRIB_ACCESSOR_FLAG_DUMP;
/* switch (grib_accessor_get_native_type(a->attributes[i])) { */
/* case GRIB_TYPE_LONG: */
/* dump_long(d,a->attributes[i],0); */
/* break; */
/* case GRIB_TYPE_DOUBLE: */
/* dump_values(d,a->attributes[i]); */
/* break; */
/* case GRIB_TYPE_STRING: */
/* dump_string_array(d,a->attributes[i],0); */
/* break; */
/* } */
a->attributes[i]->flags=flags;
i++;
}
self->isLeaf=0;
self->isAttribute=0;
}

1
src/grib_dumper_factory.h
View File

@ -2,6 +2,7 @@
{ "c_code", &grib_dumper_class_c_code, },
{ "debug", &grib_dumper_class_debug, },
{ "default", &grib_dumper_class_default, },
{ "filter", &grib_dumper_class_filter, },
{ "json", &grib_dumper_class_json, },
{ "keys", &grib_dumper_class_keys, },
{ "serialize", &grib_dumper_class_serialize, },

17
src/grib_value.c
View File

@ -541,6 +541,23 @@ int grib_is_missing_double(grib_accessor* a,double x)
return ret;
}
int grib_is_missing_string(grib_accessor* a,char* x,size_t len)
{
int ret;
size_t i=0;
ret=1;
for (i=0;i<len;i++) {
if (x[i] != 0xFF) {
ret=0;
break;
}
}
ret = ( a==NULL || (a->flags & GRIB_ACCESSOR_FLAG_CAN_BE_MISSING)) && (ret=1) ? 1 : 0;
return ret;
}
int grib_accessor_is_missing(grib_accessor* a,int* err)
{
*err=GRIB_SUCCESS;

2
src/gribl.l
View File

@ -165,8 +165,6 @@ IDENT {IDENT1}|{IDENT2}|{IDENT3}
"no_copy" return NO_COPY;
"edition_specific" return EDITION_SPECIFIC;
"dump" return DUMP;
"json" return JSON;
"xml" return XML;
"no_fail" return NO_FAIL;
"hidden" return HIDDEN;
"can_be_missing" return CAN_BE_MISSING;

4
src/griby.y
View File

@ -670,15 +670,13 @@ flag_list : flag
flag: READ_ONLY { $$ = GRIB_ACCESSOR_FLAG_READ_ONLY; }
| LOWERCASE { $$ = GRIB_ACCESSOR_FLAG_LOWERCASE; }
| DUMP { $$ = GRIB_ACCESSOR_FLAG_DUMP; }
| JSON { $$ = GRIB_ACCESSOR_FLAG_JSON; }
| XML { $$ = GRIB_ACCESSOR_FLAG_XML; }
| ENCODE { $$ = GRIB_ACCESSOR_FLAG_ENCODE; }
| NO_COPY { $$ = GRIB_ACCESSOR_FLAG_NO_COPY; }
| NO_FAIL { $$ = GRIB_ACCESSOR_FLAG_NO_FAIL; }
| HIDDEN { $$ = GRIB_ACCESSOR_FLAG_HIDDEN; }
| EDITION_SPECIFIC { $$ = GRIB_ACCESSOR_FLAG_EDITION_SPECIFIC; }
| CAN_BE_MISSING { $$ = GRIB_ACCESSOR_FLAG_CAN_BE_MISSING; }
| CONSTRAINT { $$ = GRIB_ACCESSOR_FLAG_CONSTRAINT; }
| OVERRIDE { $$ = GRIB_ACCESSOR_FLAG_OVERRIDE; }
| COPY_OK { $$ = GRIB_ACCESSOR_FLAG_COPY_OK; }
| TRANS { $$ = GRIB_ACCESSOR_FLAG_TRANSIENT; }
| STRING_TYPE { $$ = GRIB_ACCESSOR_FLAG_STRING_TYPE; }

37
tests/bufr_dump.sh
View File

@ -36,36 +36,37 @@ done
#==============================================
# Testing a malformed bufr file (see ECC-110)
#==============================================
# find another way to test malformed bufr
#echo "Test: malformed bufr file " >> $fLog
echo "Test: malformed bufr file " >> $fLog
rm -f $fJsonTmp | true
#rm -f $fJsonTmp | true
fBufr=${data_dir}/bufr/"bad.bufr"
#fBufr=${data_dir}/bufr/"bad.bufr"
# See ECC-276
# In v0.16.0 we changed the shortNames so we use a newer ref file
fJsonRef=${data_dir}/bufr/"bad.bufr.json.v0.16.0.ref"
#fJsonRef=${data_dir}/bufr/"bad.bufr.json.v0.16.0.ref"
${tools_dir}bufr_dump -js $fBufr > $fJsonTmp
#${tools_dir}bufr_dump -js $fBufr > $fJsonTmp
diff $fJsonTmp $fJsonRef
#diff $fJsonTmp $fJsonRef
#==============================================
# Testing change of scale (see ECC-111)
#==============================================
# FIND another way to test this operator
#echo "Test: operator 207003 " >> $fLog
echo "Test: operator 207003 " >> $fLog
rm -f $fJsonTmp | true
fBufr=${data_dir}/bufr/"207003.bufr"
fJsonRef=${data_dir}/bufr/"207003.bufr.json.ref"
${tools_dir}bufr_dump -ja $fBufr > $fJsonTmp
diff $fJsonTmp $fJsonRef
#rm -f $fJsonTmp | true
#fBufr=${data_dir}/bufr/"207003.bufr"
#fJsonRef=${data_dir}/bufr/"207003.bufr.json.ref"
#
#${tools_dir}bufr_dump -ja $fBufr > $fJsonTmp
#
#diff $fJsonTmp $fJsonRef
#
#Clean up
rm -f $fLog
rm -f $fJsonTmp | true
#rm -f $fLog
#rm -f $fJsonTmp | true

20
tests/bufr_filter.sh
View File

@ -905,8 +905,8 @@ if [ -f "$f" ]; then
cat > ${fOut}.log.ref <<EOF
vos308014_v3_26_sec_2.bufr
centre masterTablesVersionNumber localTablesVersionNumber rdbType rdbSubtype rdbtimeYear rdbtimeMonth typicalDate typicalTime numberOfSubsets numberOfObservations satelliteID
ecmf 26 0 0 0 0 0 00000000 000000 40 0 0
centre masterTablesVersionNumber localTablesVersionNumber typicalDate typicalTime rdbType rdbSubtype rdbtimeYear rdbtimeMonth numberOfSubsets numberOfObservations satelliteID
ecmf 26 0 20150107 142500 0 0 0 0 40 0 0
1 of 1 messages in vos308014_v3_26_sec_2.bufr
1 of 1 total messages in 1 files
@ -1393,3 +1393,19 @@ diff ${f}.log.ref ${f}.log
rm -f ${f}.log ${f}.log.ref $fLog $fRules
#-----------------------------------------------------------
# Test: bufr_dump -Efilter
#-----------------------------------------------------------
f="syno_1.bufr"
g="btem_109.bufr"
o="out.bufr"
echo "Test: bufr_dump -Efilter " >> $fLog
echo "file: $f" >> $fLog
${tools_dir}bufr_dump -Efilter $g > $fRules
${tools_dir}bufr_filter -o $o $fRules $f
${tools_dir}bufr_compare $o $g
rm -f $o $fRules

40
tools/bufr_dump.c
View File

@ -21,6 +21,12 @@ grib_option grib_options[]={
"\n\t\tOptions: s->structure, f->flat (only data), a->all attributes"
"\n\t\tDefault mode is structure.\n",
1,1,"s"},
{"E:","filter/Fortran/python","\n\t\tEncoding dump. Provides instructions to create the input message."
"\n\t\tOptions: filter -> filter instructions file to encode input BUFR"
"\n\t\t fortran -> fortran program to encode the input BUFR"
"\n\t\t python -> python script to encode the input BUFR"
"\n\t\tDefault mode is filter.\n",
0,1,"filter"},
{"S",0,0,1,0,0},
{"O",0,"Octet mode. WMO documentation style dump.\n",0,1,0},
/* {"D",0,0,0,1,0}, */ /* See ECC-215 */
@ -86,14 +92,6 @@ int grib_tool_init(grib_runtime_options* options)
json=1;
}
if (grib_options_on("C")) {
options->dump_mode = "c_code";
if (grib_options_on("d"))
options->dump_flags = 0;
else
options->dump_flags = GRIB_DUMP_FLAG_NO_DATA;
}
if (grib_options_on("O")) {
options->dump_mode = "wmo";
json=0;
@ -103,6 +101,11 @@ int grib_tool_init(grib_runtime_options* options)
| GRIB_DUMP_FLAG_READ_ONLY;
}
if (grib_options_on("E:")) {
options->dump_mode = grib_options_get_option("E:");
json=0;
}
/* See ECC-215
if (grib_options_on("D")) {
options->dump_mode = "debug";
@ -136,9 +139,12 @@ int grib_tool_new_file_action(grib_runtime_options* options,grib_tools_file* fil
if (!options->current_infile->name) return 0;
if (json) return 0;
if (grib_options_on("E:")) {
} else {
sprintf(tmp,"FILE: %s ",options->current_infile->name);
if (!grib_options_on("C"))
fprintf(stdout,"***** %s\n",tmp);
}
return 0;
}
@ -207,7 +213,9 @@ int grib_tool_new_handle_action(grib_runtime_options* options, grib_handle* h)
printf("unknown json option %s\n",json_option);
exit(1);
}
} else {
if (!strcmp(options->dump_mode,"default"))
printf("}\n");
} else if (grib_options_on("O")) {
sprintf(tmp,"MESSAGE %d ( length=%ld )",options->handle_count,length);
if (!grib_options_on("C"))
fprintf(stdout,"#============== %-38s ==============\n",tmp);
@ -218,10 +226,16 @@ int grib_tool_new_handle_action(grib_runtime_options* options, grib_handle* h)
return err;
}
grib_dump_content(h,stdout,options->dump_mode,options->dump_flags,0);
} else {
err=grib_set_long(h,"unpack",1);
if (err) {
fprintf(stdout,"\"ERROR: unable to unpack data section\"");
options->error=err;
return err;
}
grib_dump_content(h,stdout,options->dump_mode,options->dump_flags,0);
}
if (!strcmp(options->dump_mode,"default"))
printf("}\n");
return 0;
}
@ -239,6 +253,10 @@ void grib_tool_print_key_values(grib_runtime_options* options,grib_handle* h)
int grib_tool_finalise_action(grib_runtime_options* options)
{
if (json) fprintf(stdout,"\n]}\n");
if (!strcmp(options->dump_mode,"filter")) {
fprintf(stdout,"set pack=1;\nwrite;\n");
}
return 0;
}