bufrdeco.h File Reference

Include header file for bufrdeco library. More...

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <getopt.h>
#include <time.h>
#include <math.h>
#include <sys/stat.h>

Include dependency graph for bufrdeco.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	bufr_descriptor
	BUFR descriptor. More...
struct	bufr_replicator
	store the information when parsing related to replicators More...
struct	bufr_atom_data
	Contains all the information for a single data related with a descriptor in a expanded squence. More...
struct	bufrdeco_subset_sequence_data
	Contains all the information for a subset in a expanded squence This is a version to use with bufrdeco parse library. More...
struct	bufrdeco_bitmap
	Stores all needed data for a bufr bitmap. More...
struct	bufrdeco_bitmap_array
	Stores all structs bufrdeco_bitmap for a bufr bitmap. More...
struct	bufrdeco_bitmap_related_vars
	Contains data related to a target variable with the aid of a bitmap. More...
struct	bufrdeco_decoding_data_state
	stores the state when expanding a sequence. More...
struct	bufr_sequence_index_range
	range of indexes in a struct bufr_sequence where a condition must me chequed or marked, as example no data present or event More...
struct	bufr_sequence
	Stores an unexpanded sequence of descriptors. More...
struct	bufrdeco_expanded_tree
	Array of structs bufr_sequence from which bufr expanded tree is made. More...
struct	bufrdeco_compressed_ref
	Struct to hold the needed reference bit offsets, descriptor tree and replications in a compressed BUFR. More...
struct	bufrdeco_compressed_data_references
	Manage an array of structs bufrdeco_compressed_ref. More...
struct	bufrdeco_subset_bit_offsets
	Array of offset in bits for every subset in a non-compressed bufr. Offset is counted in bits from the init of SEC4 data, usually bit 32. More...
struct	bufr_sec0
	Store de parsed section 0. More...
struct	gts_header
	stores WMO GTS header info More...
struct	bufr_sec1
	Store de parsed section 1 of a bufr file. More...
struct	bufr_sec2
	Store a parsed sec2 from a bufr file including rawdata. More...
struct	bufr_sec3
	Store a parsed sec3 from a bufr file including rawdata. More...
struct	bufr_sec4
	Store a parsed sec4 from a bufr file including rawdata. More...
struct	bufr_tableB_decoded_item
	Store parameters for a descriptor in table b, i. e. with f = 0. More...
struct	bufr_tableB
	Store a table B readed from a file formated and named as ECMWF bufrdc package. More...
struct	bufr_tableC_decoded_item
	Store parameters for a descriptor in table C, i. e. for Table code and flags Remember this is NOT the C WMO tables. More...
struct	bufr_tableC
	Store a table C readed from a file formated and named as ECMWF bufrdc package. More...
struct	bufr_tableD_decoded_item
	Store parameters for a line in table D (sequence of descritors) More...
struct	bufr_tableD
	Store a table D readed from a file formated and named as ECMWF bufrdc package. More...
struct	bufr_tables
	Contains all tables needed to parse a bufr file. More...
struct	bufr_tables_cache
	Struct to store the cache of structs bufr_tables. More...
struct	bufrdeco
	This struct contains all needed data to parse and decode a BUFR file. More...

Macros
#define	_GNU_SOURCE
#define	BUFRDECO   "bufrdeco"
	Name of this library. More...
#define	BUFR_LEN   (512000)
	Max length of a BUFR file. More...
#define	BUFR_OBS_DATA_MASK   128
	Bit mask for Observed data. More...
#define	BUFR_COMPRESSED_DATA_MASK   64
	Bit mask for compressed data. More...
#define	MISSING_REAL   (1.7e38)
	The missing default value for real values. More...
#define	MISSING_INTEGER   (2147483647)
	The missing default value for integer values. More...
#define	BUFR_MAXLINES_TABLEB   (2048)
	The maximum expected lines in a Table B file. More...
#define	BUFR_MAXLINES_TABLEC   (8192)
	The maximum expected lines in a Table C file. More...
#define	BUFR_MAXLINES_TABLED   (8192)
	The maximum expected lines in a Table D file. More...
#define	MAXLINES_TABLEC   BUFR_MAXLINES_TABLEC
	The maximum expected lines in a Table C file, legacy def used from ECMWF. More...
#define	BUFR_NMAXSEQ   (2 * 16384)
	Maximum expected descriptors in a expanded sequence for a single subset. More...
#define	BUFR_EXPLAINED_LENGTH   (512)
	Maximum length for a explained descriptor string. More...
#define	CSV_MAXL   (2048)
	Maximum length in a string to be parsed as csv. More...
#define	NMAXSEQ_DESCRIPTORS   (256)
	Maximum nuber of unexpanded descriptors in a struct bufr_sequence. More...
#define	DESCRIPTOR_VALUE_MISSING   (1)
	Bit mask for a missing value in a struct bufr_atom_data. More...
#define	DESCRIPTOR_HAVE_REAL_VALUE   (2)
	Bit mask for a real value in a struct bufr_atom_data. More...
#define	DESCRIPTOR_HAVE_STRING_VALUE   (4)
	Bit mask for a string in a struct bufr_atom_data. More...
#define	DESCRIPTOR_IS_CODE_TABLE   (8)
	Bit mask for a code table in a struct bufr_atom_data. More...
#define	DESCRIPTOR_HAVE_CODE_TABLE_STRING   (16)
	Bit mask for a code table string in a struct bufr_atom_data. More...
#define	DESCRIPTOR_HAVE_FLAG_TABLE_STRING   (32)
	Bit mask for a flag table string in a struct bufr_atom_data. More...
#define	DESCRIPTOR_IS_FLAG_TABLE   (64)
	Bit mask for a flag table in a struct bufr_atom_data. More...
#define	DESCRIPTOR_IS_A_REPLICATOR   (128)
	Bit mask for a replicator descriptor in a struct bufr_atom_data. More...
#define	DESCRIPTOR_IS_AN_OPERATOR   (256)
	Bit mask for an operator data descriptor in a struct bufr_atom_data. More...
#define	DESCRIPTOR_IS_LOCAL   (512)
	Bit mask for a flag table string in a struct bufr_atom_data. More...
#define	BUFR_LEN_SEC1   (8192)
	Max length in bytes for a sec1. More...
#define	BUFR_LEN_SEC2   (8192)
	Max length in bytes for a sec2. More...
#define	BUFR_LEN_UNEXPANDED_DESCRIPTOR   (512)
	Max amount of unexpanded descriptors in a SEC3. More...
#define	BUFR_MAX_EXPANDED_SEQUENCES   (128)
	Max amount of unexpanded sequences in a struct bufrdeco_expanded_tree. More...
#define	BUFR_MAX_QUALITY_DATA   (8)
	Max amount of quality data which is maped by a struct bufrdeco_bitmap element. More...
#define	BUFR_MAX_BITMAP_PRESENT_DATA   (4096)
	Max number of data present in a bitmap definition. More...
#define	BUFR_MAX_BITMAPS   (8)
	Max number of structs bufrdeco_bitmap that can be allocated in a struct bufrdeco_bitmap_array. More...
#define	BUFR_MAX_SUBSETS   (2048)
	Max number of subsets in the array off bitoffset subset marks the bufrdeco library can manage. More...
#define	BUFR_LEN_SEC3   (8 + 2 * BUFR_LEN_UNEXPANDED_DESCRIPTOR)
	Max length in bytes for a sec3. More...
#define	BUFRDECO_OUTPUT_HTML   (1)
	Bit mask to the member mask for struct bufrdeco to format output as html for SECs 0 to 3. More...
#define	BUFRDECO_OUTPUT_XML   (2)
	Bit mask to the member mask for struct bufrdeco to format output as xml for SECs 0 to 3. More...
#define	BUFRDECO_USE_TABLES_CACHE   (4)
	Bit mask to the member mask of struct bufrdeco to mark the use of bufr_tables cache. More...
#define	BUFRDECO_OUTPUT_JSON_SEC0   (8)
	Bit mask to the member mask of struct bufrdeco to print info for SEC 0 in json format. More...
#define	BUFRDECO_OUTPUT_JSON_SEC1   (16)
	Bit mask to the member mask of struct bufrdeco to print info for SEC 1 in json format. More...
#define	BUFRDECO_OUTPUT_JSON_SEC2   (32)
	Bit mask to the member mask of struct bufrdeco to print bufr info for SEC 2 in json format. More...
#define	BUFRDECO_OUTPUT_JSON_SEC3   (64)
	Bit mask to the member mask of struct bufrdeco to print bufr info for SEC 3 in json format. More...
#define	BUFRDECO_OUTPUT_JSON_SUBSET_DATA   (128)
	Bit mask to the member mask of struct bufrdeco to print bufr subset data in json format. More...
#define	BUFRDECO_OUTPUT_JSON_EXPANDED_TREE   (256)
	Bit mask to the member mask of struct bufrdeco to print bufr expanded tree of descriptors. More...
#define	BUFRDECO_OUTPUT_JSON   (BUFRDECO_OUTPUT_JSON_SEC0 | BUFRDECO_OUTPUT_JSON_SEC1 | BUFRDECO_OUTPUT_JSON_SEC2 | BUFRDECO_OUTPUT_JSON_SEC3 )
	Bit mask to the member mask for struct bufrdeco to format output as json for SECs 0 to 3. More...
#define	BUFR_TABLEB_NAME_LENGTH   (128)
	Max length (in chars) reserved for a name of variable in table B. More...
#define	BUFR_TABLEB_UNIT_LENGTH   (64)
#define	BUFR_CVAL_LENGTH   (128)
	Max length (in chars) of a cval in a bufr_atom_data. More...
#define	BUFRDECO_PATH_LENGTH   (256)
	Length for files/directory path strings. More...
#define	BUFRDECO_TABLES_CACHE_SIZE   (16)
	Max number of structs bufr_tables in a bufr_tables_cache. More...
#define	strcpy_safe(_target_, _src_)
	Macro to make safely a strcpy when we know in calling function the size of string target with sizeof() More...
#define	strncpy_safe(_target_, _src_, _dim_)
	Macro to make safely a strcpy when we know in calling function the size of string target directly. More...
#define	bufrdeco_assert(__my_expr__)
	Check a expression and exit if it fails. More...
#define	bufrdeco_assert_with_return_val(__my_expr__, __returnval__)
	Check a expression and returns a given value if it fails. More...
#define	BUFRDECO_COMPRESSED_REF_SEQUENCE_INIT_BITMASK   (1)
	Bitmask for struct bufrdeco_compressed_ref which marks the init of a descriptor sequence. More...
#define	BUFRDECO_COMPRESSED_REF_DATA_DESCRIPTOR_BITMASK   (2)
	Bitmask for struct bufrdeco_compressed_ref which marks a data descriptor. More...
#define	BUFRDECO_COMPRESSED_REF_OPERATOR_DESCRIPTOR   (4)
	Bitmask for struct bufrdeco_compressed_ref which marks an operator descriptor. More...
#define	BUFRDECO_COMPRESSED_REF_REPLICATOR_DESCRIPTOR   (8)
	Bitmask for struct bufrdeco_compressed_ref which marks a replicator descriptor. More...
#define	BUFRDECO_COMPRESSED_REF_SEQUENCE_FINAL_BITMASK   (16)
	Bitmask for struct bufrdeco_compressed_ref which marks the final of a descriptor sequence. More...

Typedefs
typedef uint32_t	buf_t
	Type to set offsets and dimension of arrays or counters used in bufrdeco. More...
typedef int32_t	ibuf_t
	Type to set offsets and dimension of arrays or counters used in bufrdeco. More...

Functions
char *	bufrdeco_get_version (char *version, size_t dversion, char *build, size_t dbuild, char *builder, size_t dbuilder, int *version_major, int *version_minor, int *version_patch)
int	bufrdeco_parse_tree (struct bufrdeco *b)
	Parse the tree of descriptors without expand the replicators. More...
int	bufrdeco_init (struct bufrdeco *b)
	Inits and allocate memory for a struct bufrdeco. More...
int	bufrdeco_close (struct bufrdeco *b)
	Free all allocated memory. Needed when no more task to do with bufrdeco library. More...
int	bufrdeco_reset (struct bufrdeco *b)
	Reset an struct bufrdeco. This is needed when changing to another bufr. More...
int	bufrdeco_set_tables_dir (struct bufrdeco *b, char *tables_dir)
	Sets the directory path for BUFR tables. Needed if it is not any default directories. More...
int	bufrdeco_set_out_stream (FILE *out, struct bufrdeco *b)
	Set the library normal output stream. More...
int	bufrdeco_set_err_stream (FILE *err, struct bufrdeco *b)
	Set the error stream. More...
int	bufrdeco_get_bufr (struct bufrdeco *b, char *filename)
	Read file and try to find a bufr report inserted in. Once found do the same that bufrdeco_read_bufr() More...
struct bufrdeco_subset_sequence_data *	bufrdeco_get_target_subset_sequence_data (buf_t nset, struct bufrdeco *b)
	Prepare the struct bufrdeco to get data from the solicited subset. More...
int	bufrdeco_read_subset_offset_bits (struct bufrdeco *b, char *filename)
	Write offset bit array for subsets in a non-compressed bufr. More...
int	bufrdeco_write_subset_offset_bits (struct bufrdeco *b, char *filename)
	Write offset bit array for subsets in a non-compressed bufr. More...
int	bufrdeco_init_expanded_tree (struct bufrdeco_expanded_tree **t)
	Init a struct bufrdeco_expanded_tree allocating space. More...
int	bufrdeco_free_expanded_tree (struct bufrdeco_expanded_tree **t)
	Frees the allocated space for a struct bufrdeco_expanded_tree. More...
int	bufrdeco_init_tables (struct bufr_tables **t)
	Init a struct bufr_tables allocating space. More...
int	bufrdeco_free_tables (struct bufr_tables **t)
	Frees the allocated space for a struct bufr_tables. More...
int	bufrdeco_substitute_tables (struct bufr_tables **replaced, struct bufr_tables *source, struct bufrdeco *b)
	substitute an struct bufr_tables into a struct bufrdeco More...
int	bufrdeco_init_subset_sequence_data (struct bufrdeco_subset_sequence_data *ba)
	Init a struct bufrdeco_subset_sequence_data. More...
int	bufrdeco_clean_subset_sequence_data (struct bufrdeco_subset_sequence_data *ba)
	Cleans a struct bufrdeco_subset_sequence_data. More...
int	bufrdeco_free_subset_sequence_data (struct bufrdeco_subset_sequence_data *ba)
	Free the memory for sequence array in a struct bufrdeco_subset_sequence_data. More...
int	bufrdeco_free_compressed_data_references (struct bufrdeco_compressed_data_references *rf)
	Free the memory allocated for array of references in a struct bufrdeco_compressed_data_references. More...
int	bufrdeco_init_compressed_data_references (struct bufrdeco_compressed_data_references *rf)
	Init a struct bufrdeco_compressed_data_references. More...
int	bufrdeco_increase_data_array (struct bufrdeco_subset_sequence_data *s)
	doubles the allocated space for a struct bufrdeco_subset_sequence_data whenever is posible More...
int	bufrdeco_store_tables (struct bufr_tables **t, struct bufr_tables_cache *c, uint8_t ver)
	Init an element of array c->tab[] if still not allocated. If allocated clean it and set *t pointing to this element. More...
int	bufrdeco_cache_tables_search (struct bufr_tables_cache *c, uint8_t ver)
	Search a struct bufr_tables in bufr_tables_cache. More...
int	bufrdeco_free_cache_tables (struct bufr_tables_cache *c)
	deallocate and clean a bufr_tables_cache More...
int	bufrdeco_read_bufr (struct bufrdeco *b, char *filename)
	Read bufr file and does preliminary and first decode pass. More...
int	bufrdeco_extract_bufr (struct bufrdeco *b, char *filename)
	Read file and try to find a bufr report inserted in. Once found do the same that bufrdeco_read_file() More...
int	bufrdeco_read_buffer (struct bufrdeco *b, uint8_t *bufrx, buf_t size)
int	get_wmo_tablenames (struct bufrdeco *b)
	Get the complete pathnames for WMO csv table files needed by a bufr message. More...
int	bufr_read_tableB (struct bufrdeco *b)
int	bufr_read_tableC (struct bufrdeco *b)
	Reads a file with table C content (Code table and bit flags) according with csv WMO format. More...
int	bufr_read_tableD (struct bufrdeco *b)
	Reads a file with table D content according with WMO csv format. More...
int	bufr_read_tables (struct bufrdeco *b)
	Read the tables according with bufr file data from a bufr table directory. More...
char *	csv_quoted_string (char *out, char *in)
	Transform a string to a quoted string to be inserted in a csv file. More...
int	parse_csv_line (int *nt, char *tk[], char *lin)
	Parse a csv line. More...
int	print_bufrdeco_compressed_ref (struct bufrdeco_compressed_ref *r)
	prints a struct bufrdeco_compressed_ref More...
int	fprint_bufrdeco_compressed_ref (FILE *f, struct bufrdeco_compressed_ref *r)
	prints a struct bufrdeco_compressed_ref More...
int	print_bufrdeco_compressed_data_references (struct bufrdeco_compressed_data_references *r)
	prints a struct bufrdeco_compressed_references More...
int	fprint_bufrdeco_compressed_data_references (FILE *f, struct bufrdeco_compressed_data_references *r)
int	print_sec0_info (struct bufrdeco *b)
	Prints info from sec0. More...
int	print_sec1_info (struct bufrdeco *b)
	Prints info from sec1. More...
int	print_sec3_info (struct bufrdeco *b)
	Prints info from sec3. More...
int	print_sec4_info (struct bufrdeco *b)
	Prints info from sec3. More...
int	sprint_sec0_info (char *target, size_t lmax, struct bufrdeco *b)
	Prints info from sec0. More...
int	sprint_sec1_info (char *target, size_t lmax, struct bufrdeco *b)
	Prints info from sec1. More...
int	sprint_sec3_info (char *target, size_t lmax, struct bufrdeco *b)
	Prints info from sec3. More...
int	sprint_sec4_info (char *target, size_t lmax, struct bufrdeco *b)
	Prints info from sec4. More...
int	sprint_sec0_info_html (char *target, size_t lmax, struct bufrdeco *b)
	Prints info from sec0 in html format. More...
int	sprint_sec1_info_html (char *target, size_t lmax, struct bufrdeco *b)
	Prints info from sec1. More...
int	sprint_sec3_info_html (char *target, size_t lmax, struct bufrdeco *b)
	Prints info from sec3 formatted as html. More...
int	sprint_sec4_info_html (char *target, size_t lmax, struct bufrdeco *b)
	Prints info from sec4. More...
int	bufrdeco_print_tree (struct bufrdeco *b)
	Print a tree of descriptors. More...
int	bufrdeco_fprint_tree (FILE *f, struct bufrdeco *b)
	Print a tree of descriptors. More...
int	bufrdeco_print_atom_data_stdout (struct bufr_atom_data *a)
	print the data in a struct bufr_atom_data to stdout More...
int	bufrdeco_print_atom_data_file (FILE *f, struct bufr_atom_data *a)
	print the data in a struct bufr_atom_data to a file already open by caller More...
int	bufrdeco_print_subset_sequence_data (struct bufrdeco_subset_sequence_data *s)
	Prints a struct bufrdeco_subset_sequence_data. More...
int	bufrdeco_print_subset_sequence_data_html (struct bufrdeco_subset_sequence_data *s)
int	bufrdeco_print_subset_sequence_data_tagged_html (struct bufrdeco_subset_sequence_data *s, char *id)
int	bufrdeco_fprint_subset_sequence_data_html (FILE *f, struct bufrdeco_subset_sequence_data *s)
int	bufrdeco_fprint_subset_sequence_data_tagged_html (FILE *f, struct bufrdeco_subset_sequence_data *s, char *id)
int	bufrdeco_fprint_subset_sequence_data (FILE *f, struct bufrdeco_subset_sequence_data *s)
char *	bufrdeco_print_atom_data (char *target, size_t lmax, struct bufr_atom_data *a)
	print the data in a struct bufr_atom_data to a string More...
char *	bufrdeco_print_atom_data_html (char *target, size_t lmax, struct bufr_atom_data *a, uint32_t ss)
	print the data in a struct bufr_atom_data to a string as cells of table rows More...
char *	get_formatted_value_from_escale (char *fmt, size_t dim, int32_t escale, double val)
	gets a string with formatted value depending of scale More...
char *	get_formatted_value_from_escale2 (char *fmt, size_t dim, int32_t escale, double val)
	gets a string with formatted value depending of scale More...
int	bufrdeco_parse_tree_recursive (struct bufrdeco *b, struct bufr_sequence *father, buf_t father_idesc, const char *key)
	Parse the descriptor tree in a recursive way. More...
int	bufrdeco_decode_data_subset (struct bufrdeco *b)
	User interface to decode a BUFR subset. More...
int	bufrdeco_decode_subset_data_recursive (struct bufrdeco_subset_sequence_data *d, struct bufr_sequence *l, struct bufrdeco *b)
	decode the data from a subset in a recursive way More...
int	bufrdeco_decode_replicated_subsequence (struct bufrdeco_subset_sequence_data *d, struct bufr_replicator *r, struct bufrdeco *b)
	Decodes a replicated sequence. More...
int	bufrdeco_parse_f2_descriptor (struct bufrdeco_subset_sequence_data *s, struct bufr_descriptor *d, struct bufrdeco *b)
	parse a descritor with f = 2 More...
int	bufrdeco_parse_compressed (struct bufrdeco_compressed_data_references *r, struct bufrdeco *b)
	Preliminary parse of a compressed data bufr. More...
int	bufrdeco_parse_compressed_recursive (struct bufrdeco_compressed_data_references *r, struct bufr_sequence *l, struct bufrdeco *b)
	Parse recursively the compressed data in a bufr report to get references where to get data for every descriptor in a subset. More...
int	bufr_decode_subset_data_compressed (struct bufrdeco_subset_sequence_data *s, struct bufrdeco_compressed_data_references *r, struct bufrdeco *b)
	Get data for a given subset in a compressed data bufr. More...
int	bufrdeco_decode_replicated_subsequence_compressed (struct bufrdeco_compressed_data_references *r, struct bufr_replicator *rep, struct bufrdeco *b)
	decodes a repicated subsequence More...
int	bufrdeco_parse_f2_compressed (struct bufrdeco_compressed_data_references *r, struct bufr_descriptor *d, struct bufrdeco *b)
	parse a descritor with f = 2 in case of compressed bufr More...
int	bufrdeco_tableB_compressed (struct bufrdeco_compressed_ref *r, struct bufrdeco *b, struct bufr_descriptor *d, int mode)
	get data from table B when parsing compressed data references More...
int	bufrdeco_get_atom_data_from_compressed_data_ref (struct bufr_atom_data *a, struct bufrdeco_compressed_ref *r, buf_t subset, struct bufrdeco *b)
	Get atom data from a descriptor for a given subset. More...
int	bufrdeco_increase_compressed_data_references_count (struct bufrdeco_compressed_data_references *r, struct bufrdeco *b)
	Increment the count of a struct bufrdeco_compressed_data_references. More...
struct bufrdeco_subset_sequence_data *	bufrdeco_get_subset_sequence_data (struct bufrdeco *b)
	Parse and get a struct bufrdeco_subset_sequence_data. More...
buf_t	bufrdeco_print_json_sec0 (FILE *out, struct bufrdeco *b)
buf_t	bufrdeco_print_json_sec1 (FILE *out, struct bufrdeco *b)
	Print info form sec 1 in json format. More...
buf_t	bufrdeco_print_json_sec2 (FILE *out, struct bufrdeco *b)
	Print info form optional sec 2 in json format. More...
buf_t	bufrdeco_print_json_sec3 (FILE *out, struct bufrdeco *b)
	Print info form sec 3 in json format. More...
buf_t	bufrdeco_print_json_tree (struct bufrdeco *b)
buf_t	bufrdeco_print_json_tree_recursive (FILE *out, struct bufrdeco *b, struct bufr_sequence *seq)
	Print a tree of descriptors to a file in a recursive way in json format. More...
buf_t	bufrdeco_print_json_subset_data_prologue (FILE *out, struct bufrdeco *b)
buf_t	bufrdeco_print_json_subset_data_epilogue (FILE *out)
buf_t	bufrdeco_print_json_object_atom_data (FILE *out, struct bufr_atom_data *a, char *aux)
	Print an json object with a descriptor data. More...
buf_t	bufrdeco_print_json_object_operator_descriptor (FILE *out, struct bufr_descriptor *d, char *aux)
	print an operator desciptor as a json object More...
buf_t	bufrdeco_print_json_object_replicator_descriptor (FILE *out, struct bufr_descriptor *d, char *aux)
	print an operator desciptor as a json object More...
buf_t	bufrdeco_print_json_sequence_descriptor_header (FILE *out, struct bufr_sequence *seq)
	Print the header of a sequence descriptor (f == 3) More...
buf_t	bufrdeco_print_json_sequence_descriptor_final (FILE *out)
buf_t	bufrdeco_print_json_separator (FILE *out)
	Print the comma ',' separator in an output. More...
buf_t	bufrdeco_print_json_scape_string_cvals (FILE *out, char *source)
	prints a descriptor string value scaping the '"' for a json format More...
uint32_t	two_bytes_to_uint32 (const uint8_t *source)
	returns the uint32_t value from an array of two bytes, most significant first More...
uint32_t	three_bytes_to_uint32 (const uint8_t *source)
	returns the uint32_t value from an array of three bytes, most significant first More...
uint32_t	get_bits_as_uint32_t (uint32_t *target, uint8_t *has_data, uint8_t *source, buf_t *bit0_offset, buf_t bit_length)
uint32_t	get_bits_as_char_array (char *target, uint8_t *has_data, uint8_t *source, buf_t *bit0_offset, buf_t bit_length)
char *	bufrdeco_explained_table_val (char *expl, size_t dim, struct bufr_tableC *tc, uint32_t *index, struct bufr_descriptor *d, uint32_t ival)
char *	bufrdeco_explained_flag_val (char *expl, size_t dim, struct bufr_tableC *tc, struct bufr_descriptor *d, uint64_t ival, uint8_t nbits)
char *	bufrdeco_explained_table_csv_val (char *expl, size_t dim, struct bufr_tableC *tc, uint32_t *index, struct bufr_descriptor *d, uint32_t ival)
char *	bufrdeco_explained_flag_csv_val (char *expl, size_t dim, struct bufr_tableC *tc, struct bufr_descriptor *d, uint64_t ival, uint8_t nbits)
int	bufrdeco_tableD_get_descriptors_array (struct bufr_sequence *s, struct bufrdeco *b, const char *key)
	get the descriptors array for a descriptor sequence defined in table D with F = 3 More...
int	bufrdeco_tableB_val (struct bufr_atom_data *a, struct bufrdeco *b, struct bufr_descriptor *d)
	Get data from a table B descriptor. More...
int	bufr_find_tableB_index (buf_t *index, struct bufr_tableB *tb, const char *key)
	found a descriptor index in a struct bufr_tableB More...
int	get_table_b_reference_from_uint32_t (int32_t *target, uint8_t bits, uint32_t source)
	Get an int32_t from bits according with bufr criteria to change the reference of a descritor. Most significant bit in source is sign. More...
int	bufr_find_tableC_csv_index (buf_t *index, struct bufr_tableC *tc, const char *key, uint32_t code)
char *	bufrdeco_get_f2_descriptor_explanation (char *e, size_t dim, struct bufr_descriptor *d)
int	bufrdeco_allocate_bitmap (struct bufrdeco *b)
	allocate bitmap More...
int	bufrdeco_clean_bitmaps (struct bufrdeco *b)
	Clean all allocated bitmaps, but still is in memory. More...
int	bufrdeco_free_bitmap_array (struct bufrdeco_bitmap_array *a)
	Free an allocated bitmap array. More...
int	bufrdeco_add_to_bitmap (struct bufrdeco_bitmap *bm, buf_t index_to, buf_t index_by)
	Push a bitmap element in a bufrdeco_bitmap. More...
int	two_bytes_to_descriptor (struct bufr_descriptor *d, const uint8_t *source)
	set a struct bufr_descriptor from two consecutive bytes in bufr file More...
int	uint32_t_to_descriptor (struct bufr_descriptor *d, uint32_t id)
	parse an integer with a descriptor fom bufr ECWMF libary More...
int	is_a_delayed_descriptor (struct bufr_descriptor *d)
	check if a descriptor is a delayed descriptor More...
int	is_a_local_descriptor (struct bufr_descriptor *d)
	check if a descriptor is a local descriptor More...
int	is_a_short_delayed_descriptor (struct bufr_descriptor *d)
	check if a descriptor is a short delayed descriptor More...
char *	bufr_adjust_string (char *s)
	Supress trailing blanks of a string. More...
char *	bufr_charray_to_string (char *s, char *buf, size_t size)
	get a null termitated c-string from an array of unsigned chars More...
int	bufr_read_subset_offset_bits (FILE *f, struct bufrdeco_subset_bit_offsets *off)
	Write offset bit array for subsets in a non-compressed bufr. More...
int	bufr_write_subset_offset_bits (FILE *f, struct bufrdeco_subset_bit_offsets *off)
	Write offset bit array for subsets in a non-compressed bufr. More...

Variables
const char	DEFAULT_BUFRTABLES_ECMWF_DIR1 []
const char	DEFAULT_BUFRTABLES_ECMWF_DIR2 []
const char	DEFAULT_BUFRTABLES_WMO_CSV_DIR1 []
const char	DEFAULT_BUFRTABLES_WMO_CSV_DIR2 []
const double	pow10pos [8]
const double	pow10neg [8]
const int32_t	pow10pos_int [10]

Detailed Description

Include header file for bufrdeco library.

Definition in file bufrdeco.h.

Macro Definition Documentation

_GNU_SOURCE

#define _GNU_SOURCE

Definition at line 28 of file bufrdeco.h.

BUFR_COMPRESSED_DATA_MASK

#define BUFR_COMPRESSED_DATA_MASK   64

Bit mask for compressed data.

Definition at line 72 of file bufrdeco.h.

BUFR_CVAL_LENGTH

#define BUFR_CVAL_LENGTH   (128)

Max length (in chars) of a cval in a bufr_atom_data.

Definition at line 329 of file bufrdeco.h.

BUFR_EXPLAINED_LENGTH

#define BUFR_EXPLAINED_LENGTH   (512)

Maximum length for a explained descriptor string.

Definition at line 122 of file bufrdeco.h.

BUFR_LEN

#define BUFR_LEN   (512000)

Max length of a BUFR file.

Definition at line 60 of file bufrdeco.h.

BUFR_LEN_SEC1

#define BUFR_LEN_SEC1   (8192)

Max length in bytes for a sec1.

Definition at line 200 of file bufrdeco.h.

BUFR_LEN_SEC2

#define BUFR_LEN_SEC2   (8192)

Max length in bytes for a sec2.

Definition at line 206 of file bufrdeco.h.

BUFR_LEN_SEC3

#define BUFR_LEN_SEC3   (8 + 2 * BUFR_LEN_UNEXPANDED_DESCRIPTOR)

Max length in bytes for a sec3.

Definition at line 250 of file bufrdeco.h.

BUFR_LEN_UNEXPANDED_DESCRIPTOR

#define BUFR_LEN_UNEXPANDED_DESCRIPTOR   (512)

Max amount of unexpanded descriptors in a SEC3.

Definition at line 213 of file bufrdeco.h.

BUFR_MAX_BITMAP_PRESENT_DATA

#define BUFR_MAX_BITMAP_PRESENT_DATA   (4096)

Max number of data present in a bitmap definition.

Definition at line 232 of file bufrdeco.h.

BUFR_MAX_BITMAPS

#define BUFR_MAX_BITMAPS   (8)

Max number of structs bufrdeco_bitmap that can be allocated in a struct bufrdeco_bitmap_array.

Definition at line 238 of file bufrdeco.h.

BUFR_MAX_EXPANDED_SEQUENCES

#define BUFR_MAX_EXPANDED_SEQUENCES   (128)

Max amount of unexpanded sequences in a struct bufrdeco_expanded_tree.

Definition at line 220 of file bufrdeco.h.

BUFR_MAX_QUALITY_DATA

#define BUFR_MAX_QUALITY_DATA   (8)

Max amount of quality data which is maped by a struct bufrdeco_bitmap element.

Definition at line 226 of file bufrdeco.h.

BUFR_MAX_SUBSETS

#define BUFR_MAX_SUBSETS   (2048)

Max number of subsets in the array off bitoffset subset marks the bufrdeco library can manage.

Definition at line 244 of file bufrdeco.h.

BUFR_MAXLINES_TABLEB

#define BUFR_MAXLINES_TABLEB   (2048)

The maximum expected lines in a Table B file.

Definition at line 90 of file bufrdeco.h.

BUFR_MAXLINES_TABLEC

#define BUFR_MAXLINES_TABLEC   (8192)

The maximum expected lines in a Table C file.

Definition at line 96 of file bufrdeco.h.

BUFR_MAXLINES_TABLED

#define BUFR_MAXLINES_TABLED   (8192)

The maximum expected lines in a Table D file.

Definition at line 103 of file bufrdeco.h.

BUFR_NMAXSEQ

#define BUFR_NMAXSEQ   (2 * 16384)

Maximum expected descriptors in a expanded sequence for a single subset.

Definition at line 116 of file bufrdeco.h.

BUFR_OBS_DATA_MASK

#define BUFR_OBS_DATA_MASK   128

Bit mask for Observed data.

Definition at line 66 of file bufrdeco.h.

BUFR_TABLEB_NAME_LENGTH

#define BUFR_TABLEB_NAME_LENGTH   (128)

Max length (in chars) reserved for a name of variable in table B.

Max length (in chars) reserved for the unit string in table B.

BUFR_TABLEB_UNIT_LENGTH

#define BUFR_TABLEB_UNIT_LENGTH   (64)

Definition at line 323 of file bufrdeco.h.

BUFRDECO

#define BUFRDECO   "bufrdeco"

Name of this library.

Definition at line 54 of file bufrdeco.h.

bufrdeco_assert

#define bufrdeco_assert

(

__my_expr__

)

Value:

   if ( !(__my_expr__)) {\
     fprintf(stderr, "%s: %s():%d -> ***The expression (%s) is false***\n", \
     basename(__FILE__), __func__, __LINE__, #__my_expr__) ; \
     exit (EXIT_FAILURE);\
   }

Check a expression and exit if it fails.

Definition at line 374 of file bufrdeco.h.

bufrdeco_assert_with_return_val

#define bufrdeco_assert_with_return_val	(		__my_expr__,
			__returnval__
	)

Value:

   if ( !(__my_expr__)) {\
     fprintf(stderr, "%s: %s():%d -> ***The expression (%s) is false***\n", \
     basename(__FILE__), __func__, __LINE__, #__my_expr__) ; \
     return (__returnval__);\
   }

Check a expression and returns a given value if it fails.

Definition at line 385 of file bufrdeco.h.

BUFRDECO_COMPRESSED_REF_DATA_DESCRIPTOR_BITMASK

#define BUFRDECO_COMPRESSED_REF_DATA_DESCRIPTOR_BITMASK   (2)

Bitmask for struct bufrdeco_compressed_ref which marks a data descriptor.

Definition at line 611 of file bufrdeco.h.

BUFRDECO_COMPRESSED_REF_OPERATOR_DESCRIPTOR

#define BUFRDECO_COMPRESSED_REF_OPERATOR_DESCRIPTOR   (4)

Bitmask for struct bufrdeco_compressed_ref which marks an operator descriptor.

Definition at line 617 of file bufrdeco.h.

BUFRDECO_COMPRESSED_REF_REPLICATOR_DESCRIPTOR

#define BUFRDECO_COMPRESSED_REF_REPLICATOR_DESCRIPTOR   (8)

Bitmask for struct bufrdeco_compressed_ref which marks a replicator descriptor.

Definition at line 623 of file bufrdeco.h.

BUFRDECO_COMPRESSED_REF_SEQUENCE_FINAL_BITMASK

#define BUFRDECO_COMPRESSED_REF_SEQUENCE_FINAL_BITMASK   (16)

Bitmask for struct bufrdeco_compressed_ref which marks the final of a descriptor sequence.

Definition at line 629 of file bufrdeco.h.

BUFRDECO_COMPRESSED_REF_SEQUENCE_INIT_BITMASK

#define BUFRDECO_COMPRESSED_REF_SEQUENCE_INIT_BITMASK   (1)

Bitmask for struct bufrdeco_compressed_ref which marks the init of a descriptor sequence.

Definition at line 605 of file bufrdeco.h.

BUFRDECO_OUTPUT_HTML

#define BUFRDECO_OUTPUT_HTML   (1)

Bit mask to the member mask for struct bufrdeco to format output as html for SECs 0 to 3.

Definition at line 256 of file bufrdeco.h.

BUFRDECO_OUTPUT_JSON

#define BUFRDECO_OUTPUT_JSON   (BUFRDECO_OUTPUT_JSON_SEC0 | BUFRDECO_OUTPUT_JSON_SEC1 | BUFRDECO_OUTPUT_JSON_SEC2 | BUFRDECO_OUTPUT_JSON_SEC3 )

Bit mask to the member mask for struct bufrdeco to format output as json for SECs 0 to 3.

Definition at line 311 of file bufrdeco.h.

BUFRDECO_OUTPUT_JSON_EXPANDED_TREE

#define BUFRDECO_OUTPUT_JSON_EXPANDED_TREE   (256)

Bit mask to the member mask of struct bufrdeco to print bufr expanded tree of descriptors.

Definition at line 305 of file bufrdeco.h.

BUFRDECO_OUTPUT_JSON_SEC0

#define BUFRDECO_OUTPUT_JSON_SEC0   (8)

Bit mask to the member mask of struct bufrdeco to print info for SEC 0 in json format.

Definition at line 275 of file bufrdeco.h.

BUFRDECO_OUTPUT_JSON_SEC1

#define BUFRDECO_OUTPUT_JSON_SEC1   (16)

Bit mask to the member mask of struct bufrdeco to print info for SEC 1 in json format.

Definition at line 281 of file bufrdeco.h.

BUFRDECO_OUTPUT_JSON_SEC2

#define BUFRDECO_OUTPUT_JSON_SEC2   (32)

Bit mask to the member mask of struct bufrdeco to print bufr info for SEC 2 in json format.

Definition at line 287 of file bufrdeco.h.

BUFRDECO_OUTPUT_JSON_SEC3

#define BUFRDECO_OUTPUT_JSON_SEC3   (64)

Bit mask to the member mask of struct bufrdeco to print bufr info for SEC 3 in json format.

Definition at line 293 of file bufrdeco.h.

BUFRDECO_OUTPUT_JSON_SUBSET_DATA

#define BUFRDECO_OUTPUT_JSON_SUBSET_DATA   (128)

Bit mask to the member mask of struct bufrdeco to print bufr subset data in json format.

Definition at line 299 of file bufrdeco.h.

BUFRDECO_OUTPUT_XML

#define BUFRDECO_OUTPUT_XML   (2)

Bit mask to the member mask for struct bufrdeco to format output as xml for SECs 0 to 3.

Definition at line 262 of file bufrdeco.h.

BUFRDECO_PATH_LENGTH

#define BUFRDECO_PATH_LENGTH   (256)

Length for files/directory path strings.

Definition at line 335 of file bufrdeco.h.

BUFRDECO_TABLES_CACHE_SIZE

#define BUFRDECO_TABLES_CACHE_SIZE   (16)

Max number of structs bufr_tables in a bufr_tables_cache.

Definition at line 341 of file bufrdeco.h.

BUFRDECO_USE_TABLES_CACHE

#define BUFRDECO_USE_TABLES_CACHE   (4)

Bit mask to the member mask of struct bufrdeco to mark the use of bufr_tables cache.

Definition at line 268 of file bufrdeco.h.

CSV_MAXL

#define CSV_MAXL   (2048)

Maximum length in a string to be parsed as csv.

Definition at line 128 of file bufrdeco.h.

DESCRIPTOR_HAVE_CODE_TABLE_STRING

#define DESCRIPTOR_HAVE_CODE_TABLE_STRING   (16)

Bit mask for a code table string in a struct bufr_atom_data.

Definition at line 164 of file bufrdeco.h.

DESCRIPTOR_HAVE_FLAG_TABLE_STRING

#define DESCRIPTOR_HAVE_FLAG_TABLE_STRING   (32)

Bit mask for a flag table string in a struct bufr_atom_data.

Definition at line 170 of file bufrdeco.h.

DESCRIPTOR_HAVE_REAL_VALUE

#define DESCRIPTOR_HAVE_REAL_VALUE   (2)

Bit mask for a real value in a struct bufr_atom_data.

Definition at line 146 of file bufrdeco.h.

DESCRIPTOR_HAVE_STRING_VALUE

#define DESCRIPTOR_HAVE_STRING_VALUE   (4)

Bit mask for a string in a struct bufr_atom_data.

Definition at line 152 of file bufrdeco.h.

DESCRIPTOR_IS_A_REPLICATOR

#define DESCRIPTOR_IS_A_REPLICATOR   (128)

Bit mask for a replicator descriptor in a struct bufr_atom_data.

Definition at line 182 of file bufrdeco.h.

DESCRIPTOR_IS_AN_OPERATOR

#define DESCRIPTOR_IS_AN_OPERATOR   (256)

Bit mask for an operator data descriptor in a struct bufr_atom_data.

Definition at line 188 of file bufrdeco.h.

DESCRIPTOR_IS_CODE_TABLE

#define DESCRIPTOR_IS_CODE_TABLE   (8)

Bit mask for a code table in a struct bufr_atom_data.

Definition at line 158 of file bufrdeco.h.

DESCRIPTOR_IS_FLAG_TABLE

#define DESCRIPTOR_IS_FLAG_TABLE   (64)

Bit mask for a flag table in a struct bufr_atom_data.

Definition at line 176 of file bufrdeco.h.

DESCRIPTOR_IS_LOCAL

#define DESCRIPTOR_IS_LOCAL   (512)

Bit mask for a flag table string in a struct bufr_atom_data.

Definition at line 194 of file bufrdeco.h.

DESCRIPTOR_VALUE_MISSING

#define DESCRIPTOR_VALUE_MISSING   (1)

Bit mask for a missing value in a struct bufr_atom_data.

Definition at line 140 of file bufrdeco.h.

MAXLINES_TABLEC

#define MAXLINES_TABLEC   BUFR_MAXLINES_TABLEC

The maximum expected lines in a Table C file, legacy def used from ECMWF.

Definition at line 110 of file bufrdeco.h.

MISSING_INTEGER

#define MISSING_INTEGER   (2147483647)

The missing default value for integer values.

Definition at line 84 of file bufrdeco.h.

MISSING_REAL

#define MISSING_REAL   (1.7e38)

The missing default value for real values.

Definition at line 78 of file bufrdeco.h.

NMAXSEQ_DESCRIPTORS

#define NMAXSEQ_DESCRIPTORS   (256)

Maximum nuber of unexpanded descriptors in a struct bufr_sequence.

Definition at line 134 of file bufrdeco.h.

strcpy_safe

#define strcpy_safe	(		_target_,
			_src_
	)

Value:

   {\
   strncpy(_target_,_src_,(sizeof(_target_) - 1)); \
   _target_[sizeof(_target_) - 1] = '\0';}

Macro to make safely a strcpy when we know in calling function the size of string target with sizeof()

Definition at line 358 of file bufrdeco.h.

strncpy_safe

#define strncpy_safe	(		_target_,
			_src_,
			_dim_
	)

Value:

   {\
   strncpy(_target_, _src_, _dim_ - 1); \
   _target_[_dim_ - 1] = '\0';}

Macro to make safely a strcpy when we know in calling function the size of string target directly.

Definition at line 366 of file bufrdeco.h.

Typedef Documentation

buf_t

buf_t

Type to set offsets and dimension of arrays or counters used in bufrdeco.

Definition at line 346 of file bufrdeco.h.

ibuf_t

ibuf_t

Type to set offsets and dimension of arrays or counters used in bufrdeco.

Definition at line 351 of file bufrdeco.h.

Function Documentation

bufr_adjust_string()

char * bufr_adjust_string

(

char *

s

)

Supress trailing blanks of a string.

Parameters

s	string to process

Returns

the resulting s string

Definition at line 333 of file bufrdeco_utils.c.

{
  size_t l;
 
  //bufrdeco_assert (s != NULL);
 
  l = strlen ( s );
  while ( l && s[--l] == ' ' )
    s[l] = '\0';
  return s;
}

Referenced by bufrdeco_print_json_object_atom_data(), bufrdeco_print_json_tree_recursive(), and main().

Here is the caller graph for this function:

bufr_charray_to_string()

char * bufr_charray_to_string	(	char *	s,
		char *	buf,
		size_t	size
	)

get a null termitated c-string from an array of unsigned chars

Parameters

s	resulting string
buf	pointer to first element in array
size	number of chars in array

Returns

the resulting s string

Definition at line 316 of file bufrdeco_utils.c.

{
  //bufrdeco_assert (s != NULL && buf != NULL);
  
  // copy
  memcpy ( s , buf, size );
  // add final string mark
  s[size] = '\0';
  return s;
}

Referenced by main().

Here is the caller graph for this function:

bufr_decode_subset_data_compressed()

int bufr_decode_subset_data_compressed	(	struct bufrdeco_subset_sequence_data *	s,
		struct bufrdeco_compressed_data_references *	r,
		struct bufrdeco *	b
	)

Get data for a given subset in a compressed data bufr.

Parameters

s	pointer to a struct bufrdeco_subset_sequence_data where to set the results
r	pointer to the struct bufrdeco_compressed_data_references with the info about how and where to get the data
b	basic container struct bufrdeco

Returns

Returns 0 if succeeded, 1 otherwise

Definition at line 965 of file bufrdeco_compressed.c.

{
  size_t i, j = 0; // references index
  char aux[80];
  
  if ( b == NULL )
    return 1;
 
  // Previous check
  if ( r->refs == NULL || r->nd == 0 )
    {
      snprintf ( b->error, sizeof ( b->error ), "%s(): Try to get subset data without previous references\n", __func__ );
      return 1;
    }
 
  // first some clean
  if ( s->nd )
    {
      s->nd = 0;
    }
 
  // The subset index
  s->ss = b->state.subset;
 
  if ( b->mask & BUFRDECO_OUTPUT_JSON_SUBSET_DATA )
    bufrdeco_print_json_subset_data_prologue (b->out, b );
 
  // then get sequence
  for ( i = 0; i < r->nd; i++ )
    {
      if ( (b->mask & BUFRDECO_OUTPUT_JSON_SUBSET_DATA) &&
           (r->refs[i].replicated_desc || r->refs[i].replicated_loop) )
        snprintf(aux, sizeof (aux), "\"Replicated\":\"Descriptor %u/%u of loop %u/%u\"", r->refs[i].replicated_desc, r->refs[i].replicated_ndesc,
                r->refs[i].replicated_loop, r->refs[i].replicated_nloop);
      else
        aux[0] = '\0';
      
      if ( r->refs[i].mask & BUFRDECO_COMPRESSED_REF_DATA_DESCRIPTOR_BITMASK )
        {
          if ( bufrdeco_get_atom_data_from_compressed_data_ref ( & ( s->sequence[s->nd] ), & ( r->refs[i] ), b->state.subset, b ) )
            return 1;
 
          if ( b->mask & BUFRDECO_OUTPUT_JSON_SUBSET_DATA )
            {
              if ( j )
                bufrdeco_print_json_separator(b->out );
              bufrdeco_print_json_object_atom_data (b->out, & ( s->sequence[s->nd] ), aux );
            }
          if ( r->refs[i].is_associated == 0 )
            {
              if ( s->nd < ( s->dim - 1 ) )
                ( s->nd ) ++;
              else if ( bufrdeco_increase_data_array ( s ) == 0 )
                ( s->nd ) ++;
              else
                {
                  snprintf ( b->error, sizeof ( b->error ), "%s(): No more bufr_atom_data available. Check BUFR_NMAXSEQ\n", __func__ );
                  return 1;
                }
            }
          else
            {
              if ( s->nd < ( s->dim - 1 ) )
                ( s->nd ) ++;
              else if ( bufrdeco_increase_data_array ( s ) == 0 )
                ( s->nd ) ++;
              else
                {
                  snprintf ( b->error, sizeof ( b->error ), "%s(): No more bufr_atom_data available. Check BUFR_NMAXSEQ\n", __func__ );
                  return 1;
                }
            }
          j++;
        }
      else if ( r->refs[i].mask & BUFRDECO_COMPRESSED_REF_SEQUENCE_INIT_BITMASK )
        {
          if ( b->mask & BUFRDECO_OUTPUT_JSON_SUBSET_DATA )
            {
              if ( j )
                bufrdeco_print_json_separator(b->out );
              bufrdeco_print_json_sequence_descriptor_header (b->out, r->refs[i].seq );
              j = 0;
            }
        }
      else if ( r->refs[i].mask & BUFRDECO_COMPRESSED_REF_SEQUENCE_FINAL_BITMASK )
        {
          if ( b->mask & BUFRDECO_OUTPUT_JSON_SUBSET_DATA )
            bufrdeco_print_json_sequence_descriptor_final (b->out);
        }
      else if ( r->refs[i].mask & BUFRDECO_COMPRESSED_REF_REPLICATOR_DESCRIPTOR )
        {
          if ( b->mask & BUFRDECO_OUTPUT_JSON_SUBSET_DATA )
            {
              if ( j )
                bufrdeco_print_json_separator(b->out );
              bufrdeco_print_json_object_replicator_descriptor (b->out, r->refs[i].desc, aux );
              j++;
            }
        }
      else if ( r->refs[i].mask & BUFRDECO_COMPRESSED_REF_OPERATOR_DESCRIPTOR )
        {
          if ( b->mask & BUFRDECO_OUTPUT_JSON_SUBSET_DATA )
          {
            if ( j )
               bufrdeco_print_json_separator(b->out );
            bufrdeco_print_json_object_operator_descriptor (b->out, r->refs[i].desc, aux );
          }
          j++;
        }
    }
  if ( b->mask & BUFRDECO_OUTPUT_JSON_SUBSET_DATA )
    bufrdeco_print_json_subset_data_epilogue (b->out );
 
  return 0;
}

References BUFRDECO_COMPRESSED_REF_DATA_DESCRIPTOR_BITMASK, BUFRDECO_COMPRESSED_REF_OPERATOR_DESCRIPTOR, BUFRDECO_COMPRESSED_REF_REPLICATOR_DESCRIPTOR, BUFRDECO_COMPRESSED_REF_SEQUENCE_FINAL_BITMASK, BUFRDECO_COMPRESSED_REF_SEQUENCE_INIT_BITMASK, bufrdeco_get_atom_data_from_compressed_data_ref(), bufrdeco_increase_data_array(), BUFRDECO_OUTPUT_JSON_SUBSET_DATA, bufrdeco_print_json_object_atom_data(), bufrdeco_print_json_object_operator_descriptor(), bufrdeco_print_json_object_replicator_descriptor(), bufrdeco_print_json_separator(), bufrdeco_print_json_sequence_descriptor_final(), bufrdeco_print_json_sequence_descriptor_header(), bufrdeco_print_json_subset_data_epilogue(), bufrdeco_print_json_subset_data_prologue(), bufrdeco_compressed_ref::desc, bufrdeco_subset_sequence_data::dim, bufrdeco::error, bufrdeco_compressed_ref::is_associated, bufrdeco_compressed_ref::mask, bufrdeco::mask, bufrdeco_subset_sequence_data::nd, bufrdeco_compressed_data_references::nd, bufrdeco::out, bufrdeco_compressed_data_references::refs, bufrdeco_compressed_ref::replicated_desc, bufrdeco_compressed_ref::replicated_loop, bufrdeco_compressed_ref::replicated_ndesc, bufrdeco_compressed_ref::replicated_nloop, bufrdeco_compressed_ref::seq, bufrdeco_subset_sequence_data::sequence, bufrdeco_subset_sequence_data::ss, bufrdeco::state, and bufrdeco_decoding_data_state::subset.

Referenced by bufrdeco_decode_data_subset().

Here is the call graph for this function:

Here is the caller graph for this function:

bufr_find_tableB_index()

int bufr_find_tableB_index	(	buf_t *	index,
		struct bufr_tableB *	tb,
		const char *	key
	)

found a descriptor index in a struct bufr_tableB

Parameters

index	pointer to a size_t where to set the result if success
tb	pointer to struct bufr_tableB where are stored all table B data
key	descriptor string in format FXXYYY

Returns

0 if success, 1 otherwise

Definition at line 205 of file bufrdeco_tableB.c.

{
  uint32_t ix;
  buf_t i, i0;
  char *c;
  struct bufr_descriptor desc;
 
  //bufrdeco_assert ( tb != NULL);
  
  ix = strtoul ( key, &c, 10 );
  uint32_t_to_descriptor ( &desc, ix );
 
  // first chance
  i0 = tb->x_start[desc.x] + tb->y_ref[desc.x][desc.y];
  if ( tb->item[i0].x == desc.x && tb->item[i0].y == desc.y )
    {
      *index = i0;
      return 0;
    }
  // Second chance
  i0 = tb->x_start[desc.x];
  for ( i = i0 ; i < i0 + tb->num[desc.x] ; i++ )
    {
      if ( tb->item[i].x != desc.x )
        {
          return 1; // descriptor not found
        }
      if ( tb->item[i].y == desc.y )
        {
          *index = i;
          return 0; // found
        }
    }
  return 1; // not found
}

References bufr_descriptor::c, bufr_tableB::item, bufr_tableB::num, uint32_t_to_descriptor(), bufr_descriptor::x, bufr_tableB_decoded_item::x, bufr_tableB::x_start, bufr_descriptor::y, bufr_tableB_decoded_item::y, and bufr_tableB::y_ref.

Referenced by bufr_restore_original_tableB_item(), bufrdeco_fprint_tree_recursive(), and bufrdeco_print_json_tree_recursive().

Here is the call graph for this function:

Here is the caller graph for this function:

bufr_find_tableC_csv_index()

int bufr_find_tableC_csv_index	(	buf_t *	index,
		struct bufr_tableC *	tc,
		const char *	key,
		uint32_t	code
	)

Definition at line 134 of file bufrdeco_tableC.c.

{
  uint32_t ix;
  buf_t i, i0;
  char *c;
  struct bufr_descriptor desc;
 
  bufrdeco_assert ( tc != NULL && index != NULL );
  
  ix = strtoul ( key, &c, 10 );
  uint32_t_to_descriptor ( &desc, ix );
  i0 = tc->x_start[desc.x];
  for ( i = i0 ; i < i0 + tc->num[desc.x] ; i++ )
    {
      if ( tc->item[i].y == desc.y && tc->item[i].ival == code )
        {
          *index = i;
          return 0; // found
        }
    }
  return 1; // not found
}

References bufrdeco_assert, bufr_descriptor::c, bufr_tableC::item, bufr_tableC_decoded_item::ival, bufr_tableC::num, uint32_t_to_descriptor(), bufr_descriptor::x, bufr_tableC::x_start, bufr_descriptor::y, and bufr_tableC_decoded_item::y.

Referenced by bufrdeco_explained_table_val().

Here is the call graph for this function:

Here is the caller graph for this function:

bufr_read_subset_offset_bits()

int bufr_read_subset_offset_bits	(	FILE *	f,
		struct bufrdeco_subset_bit_offsets *	off
	)

Write offset bit array for subsets in a non-compressed bufr.

Parameters

f	file pointer opened by caller
off	pointer to the struct bufrdeco_subset_bit_offsets with the data to write into file

Returns

if success return 0, otherwise 1

Definition at line 577 of file bufrdeco_utils.c.

{
  size_t readed;
  
  //bufrdeco_assert (off != NULL && f != NULL );
  
  readed = fread( &(off->nr), sizeof (buf_t ), 1, f);
  bufrdeco_assert_with_return_val (readed == 1, 1);
    
  readed = fread( &(off->ofs[0]), sizeof (buf_t ), off->nr, f);
  bufrdeco_assert_with_return_val (readed == off->nr, 1);
  
  return 0;
}

References bufrdeco_assert_with_return_val, bufrdeco_subset_bit_offsets::nr, and bufrdeco_subset_bit_offsets::ofs.

Referenced by bufrdeco_read_subset_offset_bits().

Here is the caller graph for this function:

bufr_read_tableB()

int bufr_read_tableB

(

struct bufrdeco *

b

)

Definition at line 42 of file bufrdeco_tableB.c.

{
  char *c;
  FILE *t;
  buf_t i = 0;
  int nt;
  uint32_t ix;
  char l[CSV_MAXL];
  char caux[512];
  char *tk[16];
  struct bufr_tableB *tb;
  struct bufr_descriptor desc;
 
  //bufrdeco_assert ( b != NULL );
  
  tb = &(b->tables->b);
  if ( tb->path[0] == 0 )
    {
      return 1;
    }
 
  // If we've already readed this table. We just regenerate the table with original values
  if ( strcmp ( tb->path, tb->old_path ) == 0 )
    {
#ifdef __DEBUG      
      printf ("# Reused table %s\n", tb->path);
#endif      
      for ( i = 0; i < tb->nlines ; i++ )
        {
          tb->item[i].scale = tb->item[i].scale_ori;
          tb->item[i].reference = tb->item[i].reference_ori;
          tb->item[i].nbits = tb->item[i].nbits_ori;
          tb->item[i].changed = 0;
        }
      return 0; // all done
    }
 
  strcpy ( caux, tb->path );
  memset ( tb, 0, sizeof ( struct bufr_tableB ) );
  strcpy ( tb->path, caux );
  if ( ( t = fopen ( tb->path, "r" ) ) == NULL )
    {
      snprintf ( b->error, sizeof (b->error),"Unable to open table B file '%s'\n", tb->path );
      return 1;
    }
 
  // read first line, it is ignored
  fgets ( l, CSV_MAXL, t );
 
  while ( fgets ( l, CSV_MAXL, t ) != NULL && i < BUFR_MAXLINES_TABLEB )
    {
      // Parse line
      if ( parse_csv_line ( &nt, tk, l ) < 0 || nt != 7 )
        {
          snprintf ( b->error, sizeof (b->error),"Error parsing csv line from table B file '%s'\n", tb->path );
          return 1;
        }
 
      // First we build the descriptor
      ix = strtoul ( tk[0], &c, 10 );
      uint32_t_to_descriptor ( &desc, ix );
      tb->item[i].changed = 0; // Original from table B
      tb->item[i].x = desc.x; // x
      tb->item[i].y = desc.y; // y
      strcpy ( tb->item[i].key, desc.c ); // key
      if ( tb->num[desc.x] == 0 )
        {
          tb->x_start[desc.x] = i;  // marc the start
        }
      tb->y_ref[desc.x][desc.y] = i - tb->x_start[desc.x]; // marc the position from start of first x
      ( tb->num[desc.x] )++;
 
      // detailed name
      if ( tk[2][0] )
        {
          sprintf ( caux,"%s %s", tk[1], tk[2] );
        }
      else
        {
          strcpy ( caux, tk[1] );
        }
 
      // and finally copy
      strcpy ( tb->item[i].name, caux );
 
      // unit
      strcpy ( caux, tk[3] );
      strcpy ( tb->item[i].unit, caux );
 
      // escale
      tb->item[i].scale_ori = strtol ( tk[4], &c, 10 );
      tb->item[i].scale = tb->item[i].scale_ori;
 
      // reference
      tb->item[i].reference_ori = strtol ( tk[5], &c, 10 );
      tb->item[i].reference = tb->item[i].reference_ori;
 
      // bits
      tb->item[i].nbits_ori = strtol ( tk[6], &c, 10 );
      tb->item[i].nbits = tb->item[i].nbits_ori;
 
      i++;
    }
  tb->x_start[0] = 0; // fix the start for x = 0
  fclose ( t );
  tb->nlines = i;
  tb->wmo_table = 1;
  strcpy ( tb->old_path, tb->path ); // store latest path
  return 0;
}

References bufr_tables::b, BUFR_MAXLINES_TABLEB, bufr_descriptor::c, bufr_tableB_decoded_item::changed, CSV_MAXL, bufrdeco::error, bufr_tableB::item, bufr_tableB_decoded_item::key, bufr_tableB_decoded_item::name, bufr_tableB_decoded_item::nbits, bufr_tableB_decoded_item::nbits_ori, bufr_tableB::nlines, bufr_tableB::num, bufr_tableB::old_path, parse_csv_line(), bufr_tableB::path, bufr_tableB_decoded_item::reference, bufr_tableB_decoded_item::reference_ori, bufr_tableB_decoded_item::scale, bufr_tableB_decoded_item::scale_ori, bufrdeco::tables, uint32_t_to_descriptor(), bufr_tableB_decoded_item::unit, bufr_tableB::wmo_table, bufr_descriptor::x, bufr_tableB_decoded_item::x, bufr_tableB::x_start, bufr_descriptor::y, bufr_tableB_decoded_item::y, and bufr_tableB::y_ref.

Referenced by bufr_read_tables().

Here is the call graph for this function:

Here is the caller graph for this function:

bufr_read_tableC()

int bufr_read_tableC

(

struct bufrdeco *

b

)

Reads a file with table C content (Code table and bit flags) according with csv WMO format.

Parameters

b	pointer to a target struct bufrdeco

Returns

0 if success, 1 otherwise

Definition at line 33 of file bufrdeco_tableC.c.

{
  char *c;
  //size_t  used = 0;
  FILE *t;
  int nt;
  uint32_t ix;
  buf_t i = 0;
  struct bufr_descriptor desc;
  struct bufr_tableC *tc;
  char *tk[16];
  char caux[256], l[CSV_MAXL];
 
  //bufrdeco_assert ( b != NULL );
  
  tc = & ( b->tables->c );
  
  if ( tc->path[0] == 0 )
    {
      return 1;
    }
 
  // If we've already readed this table.
  if ( strcmp ( tc->path, tc->old_path ) == 0 )
    {
#ifdef __DEBUG      
      printf ("# Reused table %s\n", tc->path);
#endif      
      return 0; // all done
    }
 
  strcpy ( caux, tc->path );
  memset ( tc, 0, sizeof ( struct bufr_tableC ) );
  strcpy ( tc->path, caux );
  if ( ( t = fopen ( tc->path, "r" ) ) == NULL )
    {
      snprintf ( b->error, sizeof ( b->error ),"Unable to open table C file '%s'\n", tc->path );
      return 1;
    }
 
  // read first line, it is ignored
  fgets ( l, CSV_MAXL, t );
 
  while ( fgets ( l, CSV_MAXL, t ) != NULL && i < BUFR_MAXLINES_TABLEC )
    {
 
      // Parse line
      if ( parse_csv_line ( &nt, tk, l ) < 0 || nt != 6 )
        {
          snprintf ( b->error, sizeof ( b->error ),"Error parsing csv line from table C file '%s'. Found %d fields in line %u \n", tc->path, nt, i );
          return 1;
        }
 
      // Check if code contains other than non-numeric i.e. 'All' or '-'
      // In this case, the line is ignored
      if ( tk[1][0] == 0 || strchr ( tk[1], '-' ) != NULL || strstr ( tk[1], "All" ) != NULL )
        continue;
 
      // Key
      // First we build the descriptor
      ix = strtoul ( tk[0], &c, 10 );
      uint32_t_to_descriptor ( &desc, ix );
      strcpy ( tc->item[i].key, tk[0] );
      tc->item[i].x = desc.x;
      tc->item[i].y = desc.y;
 
      // Integer value
      tc->item[i].ival = strtoul ( tk[1], &c, 10 );
 
      // Description
      c = & tc->item[i].description[0];
      snprintf ( c, BUFR_EXPLAINED_LENGTH, "%s %s %s %s", tk[2], tk[3], tk[4], tk[5] );
 
      if ( tc->num[desc.x] == 0 )
        {
          tc->x_start[desc.x] = i;  // marc the start
        }
      if ( tc->y_ref[desc.x][desc.y] == 0 )
        {
          tc->y_ref[desc.x][desc.y] = i - tc->x_start[desc.x]; // marc the position from start of first x
        }
      ( tc->num[desc.x] ) ++;
      i++;
    }
  fclose ( t );
  tc->nlines = i;
  tc->wmo_table = 1;
  strcpy ( tc->old_path, tc->path ); // store latest path
  return 0;
}

References BUFR_EXPLAINED_LENGTH, BUFR_MAXLINES_TABLEC, bufr_tables::c, CSV_MAXL, bufr_tableC_decoded_item::description, bufrdeco::error, bufr_tableC::item, bufr_tableC_decoded_item::ival, bufr_tableC_decoded_item::key, bufr_tableC::nlines, bufr_tableC::num, bufr_tableC::old_path, parse_csv_line(), bufr_tableC::path, bufrdeco::tables, uint32_t_to_descriptor(), bufr_tableC::wmo_table, bufr_descriptor::x, bufr_tableC_decoded_item::x, bufr_tableC::x_start, bufr_descriptor::y, bufr_tableC_decoded_item::y, and bufr_tableC::y_ref.

Referenced by bufr_read_tables().

Here is the call graph for this function:

Here is the caller graph for this function:

bufr_read_tableD()

int bufr_read_tableD

(

struct bufrdeco *

b

)

Reads a file with table D content according with WMO csv format.

Parameters

b	pointer to a target struct bufrdeco

Returns

If succeded return 0, otherwise 1

Definition at line 32 of file bufrdeco_tableD.c.

{
  char aux[32], *c;
  char *tk[16];
  int nt;
  FILE *t;
  buf_t ix = 0;
  buf_t i = 0;
  int j0, nj = 0;
  char oldkey[8];
  char caux[256];
  char laux[CSV_MAXL];
  struct bufr_descriptor desc;
  struct bufr_tableD *td;
 
  //bufrdeco_assert (b != NULL);
  
  td = &(b->tables->d);
  if ( td->path[0] == 0 )
    {
      return 1;
    }
 
  // Check if we've already readed this table.
  if ( strcmp ( td->path, td->old_path ) == 0 )
    {
#ifdef __DEBUG      
      printf ("# Reused table %s\n", td->path);
#endif      
      return 0; // all done
    }
 
  strcpy ( caux, td->path );
  memset ( td, 0, sizeof ( struct bufr_tableD ) );
  strcpy ( td->path,caux );
  if ( ( t = fopen ( td->path, "r" ) ) == NULL )
    {
      snprintf ( b->error, sizeof (b->error),"Unable to open table D file '%s'\n", td->path );
      return 1;
    }
 
  // read first line, it is ignored
  fgets ( laux, CSV_MAXL, t );
 
  oldkey[0] = 0;
  j0 = 0;
 
  while ( fgets ( laux, CSV_MAXL, t ) != NULL && i < BUFR_MAXLINES_TABLED )
    {
      // Parse line
      //printf("%s\n",laux);
      if ( parse_csv_line ( &nt, tk, laux ) < 0 || ( nt != 2 && nt != 4) )
        {
          snprintf ( b->error, sizeof (b->error),"Error parsing csv line from table D file '%s' found %d tokens in line %u\n", td->path, nt, i );
          return 1;
        }
 
      // item fields
      strcpy(td->item[i].key, tk[0]);
      strcpy(td->item[i].key2, tk[1]);
 
      if (nt == 4 && tk[2][0])
        strcpy (td->item[i].description, tk[2]);
      else
        td->item[i].description[0] = 0;
 
      if (nt == 4 && tk[3][0])
        strcpy(td->item[i].description2, tk[3]);
      else
        td->item[i].description2[0] = 0;
 
      if ( strcmp ( oldkey, tk[0] ) )
        {
          if ( oldkey[0] )
            {
              // write number of descriptors in emulated ECMWF line
              sprintf ( aux, "%s%3d", oldkey, nj );
              td->l[j0][1] = aux[0];
              td->l[j0][2] = aux[1];
              td->l[j0][3] = aux[2];
              td->l[j0][4] = aux[3];
              td->l[j0][5] = aux[4];
              td->l[j0][6] = aux[5];
              td->l[j0][7] = aux[6];
              td->l[j0][8] = aux[7];
              td->l[j0][9] = aux[8];
            }
          j0 = i;
          nj = 1;
        }
      else
        {
          nj++;
        }
      strcpy ( oldkey, tk[0] );
 
      ix = strtoul ( tk[0], &c, 10 );
      uint32_t_to_descriptor ( &desc, ix );
 
      if ( td->num[desc.x] == 0 )
        {
          td->x_start[desc.x] = i;  // marc the start
        }
      ( td->num[desc.x] ) ++;
 
      // Now emule ECMWF format
      sprintf ( td->l[i], "           %s", tk[1] );
      i++;
    }
  fclose ( t );
 
  // Last sequence
  sprintf ( aux, "%s%3d", oldkey, nj );
  td->l[j0][1] = aux[0];
  td->l[j0][2] = aux[1];
  td->l[j0][3] = aux[2];
  td->l[j0][4] = aux[3];
  td->l[j0][5] = aux[4];
  td->l[j0][6] = aux[5];
  td->l[j0][7] = aux[6];
  td->l[j0][8] = aux[7];
  td->l[j0][9] = aux[8];
 
  td->nlines = i;
  td->wmo_table = 1;
  strcpy ( td->old_path, td->path ); // store latest path
  return 0;
}

References BUFR_MAXLINES_TABLED, CSV_MAXL, bufr_tables::d, bufr_tableD_decoded_item::description, bufr_tableD_decoded_item::description2, bufrdeco::error, bufr_tableD::item, bufr_tableD_decoded_item::key, bufr_tableD_decoded_item::key2, bufr_tableD::l, bufr_tableD::nlines, bufr_tableD::num, bufr_tableD::old_path, parse_csv_line(), bufr_tableD::path, bufrdeco::tables, uint32_t_to_descriptor(), bufr_tableD::wmo_table, bufr_descriptor::x, and bufr_tableD::x_start.

Referenced by bufr_read_tables().

Here is the call graph for this function:

Here is the caller graph for this function:

bufr_read_tables()

int bufr_read_tables

(

struct bufrdeco *

b

)

Read the tables according with bufr file data from a bufr table directory.

Parameters

b	basic struct with needed data

Returns

if success return 0, otherwise 1

The default directories where to search bufr tables are stored in DEFAULT_BUFRTABLES_WMO_CSV_DIR1 and DEFAULT_BUFRTABLES_WMO_CSV_DIR2

Definition at line 162 of file bufrdeco_wmo.c.

{
  int index;
  buf_t i;
  bufrdeco_assert ( b != NULL );
  struct bufr_tableB *tb;
 
  if ( b->mask & BUFRDECO_USE_TABLES_CACHE )
    {
      // When using cache, member b->tables is actually a pointer in array b->cache.tab[]
 
      if ( ( index = bufrdeco_cache_tables_search ( & ( b->cache ), b->sec1.master_version ) ) >= 0 )
        {
#ifdef __DEBUG
          printf ( "# Found tables in cache for version %u index %d\n", b->sec1.master_version, index );
#endif
          // hit cache, then the only task is to change member b->tables, and restore original values from item im tableB
          b->tables = b->cache.tab[index];
          tb = & ( b->tables->b );
 
          for ( i = 0; i < tb->nlines ; i++ )
            {
              tb->item[i].scale = tb->item[i].scale_ori;
              tb->item[i].reference = tb->item[i].reference_ori;
              tb->item[i].nbits = tb->item[i].nbits_ori;
              tb->item[i].changed = 0;
            }
 
          // all done
          return 0;
        }
      else
        {
#ifdef __DEBUG
          printf ( "# Tables for version %u not found in cache. Stored in index %d\n", b->sec1.master_version, b->cache.next );
#endif
          // If not in cache, the new master version tables has to be stored. This implies that
          bufrdeco_store_tables ( & ( b->tables ), & ( b->cache ), b->sec1.master_version );
 
          // get tablenames
          if ( get_wmo_tablenames ( b ) )
            {
              snprintf ( b->error, sizeof ( b->error ),"%s(): Cannot find bufr tables\n", __func__ );
              return 1;
            }
 
          // Missed cache
          if ( bufr_read_tableB ( b ) )
            {
              return 1;
            }
 
          if ( bufr_read_tableC ( b ) )
            {
              return 1;
            }
 
          if ( bufr_read_tableD ( b ) )
            {
              return 1;
            }
 
        }
    }
  else
    {
      // If tables still not initialized then do it
      if ( b->tables == NULL && bufrdeco_init_tables ( & ( b->tables ) ) )
        {
          snprintf ( b->error, sizeof ( b->error ), "%s(): Cannot allocate memory for tables\n", __func__ );
          return 1;
        }
      // get tablenames
      if ( get_wmo_tablenames ( b ) )
        {
          snprintf ( b->error, sizeof ( b->error ),"%s(): Cannot find bufr tables\n", __func__ );
          return 1;
        }
 
      // And now read tables
      if ( bufr_read_tableB ( b ) )
        {
          return 1;
        }
 
      if ( bufr_read_tableC ( b ) )
        {
          return 1;
        }
 
      if ( bufr_read_tableD ( b ) )
        {
          return 1;
        }
    }
  return 0;
}

References bufr_tables::b, bufr_read_tableB(), bufr_read_tableC(), bufr_read_tableD(), bufrdeco_assert, bufrdeco_cache_tables_search(), bufrdeco_init_tables(), bufrdeco_store_tables(), BUFRDECO_USE_TABLES_CACHE, bufrdeco::cache, bufr_tableB_decoded_item::changed, bufrdeco::error, get_wmo_tablenames(), bufr_tableB::item, bufrdeco::mask, bufr_sec1::master_version, bufr_tableB_decoded_item::nbits, bufr_tableB_decoded_item::nbits_ori, bufr_tables_cache::next, bufr_tableB::nlines, bufr_tableB_decoded_item::reference, bufr_tableB_decoded_item::reference_ori, bufr_tableB_decoded_item::scale, bufr_tableB_decoded_item::scale_ori, bufrdeco::sec1, bufr_tables_cache::tab, and bufrdeco::tables.

Referenced by bufrdeco_read_buffer().

Here is the call graph for this function:

Here is the caller graph for this function:

bufr_write_subset_offset_bits()

int bufr_write_subset_offset_bits	(	FILE *	f,
		struct bufrdeco_subset_bit_offsets *	off
	)

Write offset bit array for subsets in a non-compressed bufr.

Parameters

f	file pointer opened by caller
off	pointer to the struct bufrdeco_subset_bit_offsets with the data to write into file

Returns

if success return 0, otherwise 1

Definition at line 555 of file bufrdeco_utils.c.

{
  size_t wrote;
  
  //bufrdeco_assert (off != NULL && f != NULL );
 
  wrote = fwrite( &(off->nr), sizeof (buf_t ), 1, f);
  bufrdeco_assert_with_return_val (wrote == 1, 1);
    
  wrote = fwrite( &(off->ofs[0]), sizeof (buf_t ), off->nr, f);
  bufrdeco_assert_with_return_val (wrote == off->nr, 1);
  
  return 0;
}

References bufrdeco_assert_with_return_val, bufrdeco_subset_bit_offsets::nr, and bufrdeco_subset_bit_offsets::ofs.

Referenced by bufrdeco_write_subset_offset_bits().

Here is the caller graph for this function:

bufrdeco_add_to_bitmap()

int bufrdeco_add_to_bitmap	(	struct bufrdeco_bitmap *	bm,
		buf_t	index_to,
		buf_t	index_by
	)

Push a bitmap element in a bufrdeco_bitmap.

Parameters

bm	target struct bufrdeco_bitmap where to push
index_to	index of the bufrdeco_bitmap which this is bitmapping to
index_by	index of the bufrdeco_bitmap which this is bitmapped by

Returns

If no space to push returns 1, otherwise 0

Definition at line 461 of file bufrdeco_utils.c.

{
  //bufrdeco_assert (bm != NULL);
  
  if ( bm->nb < BUFR_MAX_BITMAP_PRESENT_DATA )
    {
      bm->bitmap_to[bm->nb] = index_to;
      bm->bitmaped_by[bm->nb] = index_by;
      ( bm->nb )++;
      return 0;
    }
  return 1;
}

References bufrdeco_bitmap::bitmap_to, bufrdeco_bitmap::bitmaped_by, BUFR_MAX_BITMAP_PRESENT_DATA, and bufrdeco_bitmap::nb.

Referenced by bufrdeco_decode_replicated_subsequence(), and bufrdeco_decode_replicated_subsequence_compressed().

Here is the caller graph for this function:

bufrdeco_allocate_bitmap()

int bufrdeco_allocate_bitmap

(

struct bufrdeco *

b

)

allocate bitmap

Parameters

b	the active struct bufrdeco

Returns

If succeeded return 0, otherwise 1

Definition at line 269 of file bufrdeco_memory.c.

{
  buf_t nba;
  
  bufrdeco_assert ( b != NULL );
    
  nba = b->bitmap.nba;
 
  if ( nba < BUFR_MAX_BITMAPS )
    {
      if ( b->bitmap.bmap[nba] != NULL )
        {
          // the bitmap already is allocated
          return 0;
        }
      // let's try to allocate it!
      if ( ( b->bitmap.bmap[nba] = ( struct bufrdeco_bitmap * ) calloc ( 1, sizeof ( struct bufrdeco_bitmap ) ) ) == NULL )
        {
          snprintf ( b->error, sizeof ( b->error ),"%s(): Cannot allocate space for struct bufrdeco_bitmap\n",  __func__ );
          return 1;
        }
      // Update de counter
      ( b->bitmap.nba )++;
      return 0;
    }
  else
    {
      snprintf ( b->error, sizeof ( b->error ),"%s(): Too much bitmaps to allocate. The limit is %d\n", __func__, BUFR_MAX_BITMAPS );
      return 1;
    }
}

References bufrdeco::bitmap, bufrdeco_bitmap_array::bmap, BUFR_MAX_BITMAPS, bufrdeco_assert, bufrdeco::error, and bufrdeco_bitmap_array::nba.

Referenced by bufrdeco_parse_f2_compressed(), and bufrdeco_parse_f2_descriptor().

Here is the caller graph for this function:

bufrdeco_cache_tables_search()

int bufrdeco_cache_tables_search	(	struct bufr_tables_cache *	c,
		uint8_t	ver
	)

Search a struct bufr_tables in bufr_tables_cache.

Parameters

c	pointer to the struct bufr_tables_cache where to search
ver	small int with the master version acting as a key in the seardch

Returns

The index of found struct. If no struct found returns -1

Definition at line 304 of file bufrdeco_wmo.c.

{
  buf_t i = 0;
 
  for ( i = 0; i < BUFRDECO_TABLES_CACHE_SIZE ; i++ )
    {
      if ( c->ver[i] == ver )
        return i; // found
    }
  return -1; // Not found
}

References BUFRDECO_TABLES_CACHE_SIZE, and bufr_tables_cache::ver.

Referenced by bufr_read_tables().

Here is the caller graph for this function:

bufrdeco_clean_bitmaps()

int bufrdeco_clean_bitmaps

(

struct bufrdeco *

b

)

Clean all allocated bitmaps, but still is in memory.

Parameters

b	the active struct bufrdeco

Returns

If succeeded return 0, otherwise 1

Definition at line 308 of file bufrdeco_memory.c.

{
  buf_t i;
 
  bufrdeco_assert ( b != NULL );
  
  for ( i = 0; i < b->bitmap.nba ; i++ )
    {
      if ( b->bitmap.bmap[i] == NULL )
        continue;
      memset ( b->bitmap.bmap[i], 0, sizeof ( struct bufrdeco_bitmap ) );
    }
  b->bitmap.nba = 0;
  return 0;
}

References bufrdeco::bitmap, bufrdeco_bitmap_array::bmap, bufrdeco_assert, and bufrdeco_bitmap_array::nba.

Referenced by bufrdeco_decode_data_subset().

Here is the caller graph for this function:

bufrdeco_clean_subset_sequence_data()

int bufrdeco_clean_subset_sequence_data

(

struct bufrdeco_subset_sequence_data *

ba

)

Cleans a struct bufrdeco_subset_sequence_data.

Parameters

ba	Pointer to struct bufrdeco_subset_sequence_data to clean

Returns

0 if succeeded, 1 otherwise

For eficience, if sequence in the struct bufrdeco_subset_sequence_data is allocated, just set the used elements to zero. If is still no allocated memory for sequence inits the struct

Definition at line 164 of file bufrdeco_memory.c.

{
  bufrdeco_assert ( ba != NULL );
  
  if ( ba->sequence != NULL )
    {
      ba->nd = 0;
      return 0;
    }
  else
    return bufrdeco_init_subset_sequence_data ( ba );
}

References bufrdeco_assert, bufrdeco_init_subset_sequence_data(), bufrdeco_subset_sequence_data::nd, and bufrdeco_subset_sequence_data::sequence.

Referenced by bufrdeco_decode_data_subset().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_close()

int bufrdeco_close

(

struct bufrdeco *

b

)

Free all allocated memory. Needed when no more task to do with bufrdeco library.

Parameters

b	pointer to the target struct

Returns

If succeeded return 0, otherwise 1

This function must be called at the end when no more calls to bufrdeco library is needed

b->out and b->err must be closed by caller if are not the default stdout or stderr

Definition at line 259 of file bufrdeco.c.

{
  bufrdeco_assert ( b != NULL );
 
  // first deallocate all memory
  bufrdeco_free_subset_sequence_data ( & ( b->seq ) );
  bufrdeco_free_compressed_data_references ( & ( b->refs ) );
  bufrdeco_free_expanded_tree ( & ( b->tree ) );
  if (b->mask & BUFRDECO_USE_TABLES_CACHE)
  {
    bufrdeco_free_cache_tables(&(b->cache));
    b->tables = 0;
  }
  else
  {
    bufrdeco_free_tables ( & ( b->tables ) );
  }
  bufrdeco_free_bitmap_array ( & ( b->bitmap ) );
  
  return 0;
}

References bufrdeco::bitmap, bufrdeco_assert, bufrdeco_free_bitmap_array(), bufrdeco_free_cache_tables(), bufrdeco_free_compressed_data_references(), bufrdeco_free_expanded_tree(), bufrdeco_free_subset_sequence_data(), bufrdeco_free_tables(), BUFRDECO_USE_TABLES_CACHE, bufrdeco::cache, bufrdeco::mask, bufrdeco::refs, bufrdeco::seq, bufrdeco::tables, and bufrdeco::tree.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_decode_data_subset()

int bufrdeco_decode_data_subset

(

struct bufrdeco *

b

)

User interface to decode a BUFR subset.

Parameters

b	pointer to the base struct bufrdeco

Returns

Return 0 in case of success, 1 otherwise

Note that if succeeded the counter to current subset index is increased. Remember that in case of non compressed data we must to decode all previous subsets to get the desired one. In case of compressed we can access directly to a the desired subset

Definition at line 62 of file bufrdeco_data.c.

{
  struct bufrdeco_subset_sequence_data *s;
  struct bufrdeco_compressed_data_references *r;
 
  // check arguments
  bufrdeco_assert ( b != NULL );
 
  s = & ( b->seq );
  r = & ( b->refs );
 
  if ( s == NULL || r == NULL )
    {
      snprintf ( b->error, sizeof ( b->error ), "%s(): Unspected NULL argument(s)\n", __func__ );
      return 1;
    }
 
  // Check about parsed tree
  if ( b->tree == NULL || b->tree->nseq == 0 )
    {
      snprintf ( b->error, sizeof ( b->error ), "%s(): Try to parse compressed data without parsed tree\n", __func__ );
      return 1;
    }
 
  // First we init the subset sequence data
  if ( bufrdeco_clean_subset_sequence_data ( s ) )
    {
      return 1;
    }
 
  // also we clean the possible defined bitmaps in prior subsets
  if ( bufrdeco_clean_bitmaps ( b ) )
    {
      return 1;
    }
 
  // Then we get the data from an already parsed descriptor tree
  if ( b->sec3.compressed )
    {
      if ( r->nd == 0 )
        {
          // case of compressed data and still not parsed
          if ( bufrdeco_parse_compressed ( r, b ) )
            {
              return 1;
            }
        }
      if ( bufr_decode_subset_data_compressed ( s, r, b ) )
        {
          return 1;
        }
    }
  else
    {
      if ( bufrdeco_decode_subset_data_recursive ( s, NULL, b ) )
        {
          return 1;
        }
    }
 
  // Finally we update the subset counter
  ( b->state.subset ) ++;
  return 0;
}

References bufr_decode_subset_data_compressed(), bufrdeco_assert, bufrdeco_clean_bitmaps(), bufrdeco_clean_subset_sequence_data(), bufrdeco_decode_subset_data_recursive(), bufrdeco_parse_compressed(), bufr_sec3::compressed, bufrdeco::error, bufrdeco_compressed_data_references::nd, bufrdeco_expanded_tree::nseq, bufrdeco::refs, bufrdeco::sec3, bufrdeco::seq, bufrdeco::state, bufrdeco_decoding_data_state::subset, and bufrdeco::tree.

Referenced by bufrdeco_get_subset_sequence_data(), and bufrdeco_get_target_subset_sequence_data().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_decode_replicated_subsequence()

int bufrdeco_decode_replicated_subsequence	(	struct bufrdeco_subset_sequence_data *	d,
		struct bufr_replicator *	r,
		struct bufrdeco *	b
	)

Decodes a replicated sequence.

Parameters

d	target struct bufrdeco_subset_sequence_data
r	pointer to a struct bufr_replicator which manage the replication task
b	pointer to the base struct bufrdeco

Returns

If succeeded return 0, 1 otherwise

Definition at line 509 of file bufrdeco_data.c.

{
  buf_t i, k;
  buf_t ixloop; // Index for loop
  buf_t ixd; // Index for descriptor
  struct bufr_sequence *l = r->s; // sequence
  struct bufr_replicator replicator;
  char aux[80];
 
  bufrdeco_assert ( b != NULL );
 
  if ( d == NULL || r == NULL )
    {
      {
        snprintf ( b->error, sizeof ( b->error ), "%s(): Unspected NULL argument(s)\n", __func__ );
        return 1;
      }
    }
 
  for ( ixloop = 0; ixloop < r->nloops; ixloop++ )
    {
      for ( ixd = 0; ixd < r->ndesc ; ixd ++ )
        {
          if ( b->mask & BUFRDECO_OUTPUT_JSON_SUBSET_DATA )
            snprintf(aux, sizeof (aux), "\"Replicated\":\"Descriptor %u/%u of loop %u/%u\"", ixd + 1, ixloop + 1, r->ndesc, r->nloops);
  
          i = ixd + r->ixdel + 1;
          switch ( l->lseq[i].f )
            {
            case 0:
              // Checks if no_data_present is active for this descriptor in this sequence
              if ( l->no_data_present.active &&
                   i >= l->no_data_present.first &&
                   i <= l->no_data_present.last )
                {
                  // If here then no_data_present has been active in this sequence
                  if ( l->lseq[i].x > 9 &&
                       l->lseq[i].x != 31 )
                    {
                      snprintf ( b->error, sizeof ( b->error ), "%s(): Getting data from table b with class other than 1-9,31 and no data present activated\n", __func__ );
                      return 1;
                    }
                }
 
              // Repeat the extraction of data if b->state.data_repetition_factor != 0
              // It get data al least a time
              do
                {
                  // decrement counter if not zero
                  if ( b->state.data_repetition_factor )
                    ( b->state.data_repetition_factor )++;
 
                  // Get data from table B
                  if ( bufrdeco_tableB_val ( & ( d->sequence[d->nd] ), b, & ( l->lseq[i] ) ) )
                    {
                      return 1;
                    }
                  if ( b->mask & BUFRDECO_OUTPUT_JSON_SUBSET_DATA )
                  {
                    bufrdeco_print_json_separator ( b->out );
                    bufrdeco_print_json_object_atom_data ( b->out, & ( d->sequence[d->nd] ), aux );
                  }
                }
              while ( b->state.data_repetition_factor != 0 );
 
              // case of delayed replicator description and data
              if ( l->lseq[i].x == 31 && ( l->lseq[i].y == 11 || l->lseq[i].y == 12 ) )
                b->state.data_repetition_factor = ( buf_t ) d->sequence[d->nd].val;
 
 
              // Case of defining bitmap 0 31 031
              if ( l->lseq[i].x == 31 && l->lseq[i].y == 31 && b->state.bitmaping )
                {
                  if ( d->sequence[d->nd].val == 0.0 ) // Check if it is meaning present data
                    {
                      d->sequence[d->nd - b->state.bitmaping].is_bitmaped_by =  d->nd;
                      d->sequence[d->nd].bitmap_to =  d->nd - b->state.bitmaping;
                      // Add reference to bitmap
                      bufrdeco_add_to_bitmap ( b->bitmap.bmap[b->bitmap.nba - 1], d->nd - b->state.bitmaping, d->nd );
                    }
                }
 
              // Process quality data
              if ( b->state.quality_active &&
                   l->lseq[i].x == 33 )
                {
                  if ( ixloop == 0 )
                    {
                      k = b->bitmap.bmap[b->bitmap.nba - 1]->nq;
                      b->bitmap.bmap[b->bitmap.nba - 1]->quality[k] = d->nd;
                      if ( k < BUFR_MAX_QUALITY_DATA )
                        ( b->bitmap.bmap[b->bitmap.nba - 1]->nq )++;
                      else
                        {
                          snprintf ( b->error, sizeof ( b->error ), "%s(): No more space for quality vars in bitmap. Check BUFR_MAX_QUALITY_DATA\n", __func__ );
                          return 1;
                        }
                    }
                  d->sequence[d->nd].related_to = b->bitmap.bmap[b->bitmap.nba - 1]->bitmap_to[ixloop];
                }
 
              //case of first order statistics
              if ( b->state.stat1_active &&
                   l->lseq[i].x == 8 && l->lseq[i].y == 23 )
                {
                  if ( ixloop == 0 )
                    {
                      k = b->bitmap.bmap[b->bitmap.nba - 1]->ns1; // index un stqts
                      b->bitmap.bmap[b->bitmap.nba - 1]->stat1_desc[k] = d->nd; // Set the value of statistical parameter
                      // update the number of quality variables for the bitmap
                      if ( k < BUFR_MAX_QUALITY_DATA )
                        ( b->bitmap.bmap[b->bitmap.nba - 1]->ns1 )++;
                      else
                        {
                          snprintf ( b->error, sizeof ( b->error ), "%s(): No more space for first order statistic vars in bitmap. Check BUFR_MAX_QUALITY_DATA\n", __func__ );
                          return 1;
                        }
                    }
                  d->sequence[d->nd].related_to = b->bitmap.bmap[b->bitmap.nba - 1]->bitmap_to[ixloop];
                }
 
              //case of difference statistics
              if ( b->state.dstat_active &&
                   l->lseq[i].x == 8 && l->lseq[i].y == 24 )
                {
                  if ( ixloop == 0 )
                    {
                      k = b->bitmap.bmap[b->bitmap.nba - 1]->nds; // index in stats
                      b->bitmap.bmap[b->bitmap.nba - 1]->dstat_desc[k] = d->nd; // Set the value of statistical parameter
                      // update the number of quality variables for the bitmap
                      if ( k < BUFR_MAX_QUALITY_DATA )
                        ( b->bitmap.bmap[b->bitmap.nba - 1]->nds )++;
                      else
                        {
                          snprintf ( b->error, sizeof ( b->error ), "%s(): No more space for difference statistic vars in bitmap. Check BUFR_MAX_QUALITY_DATA\n", __func__ );
                          return 1;
                        }
                    }
                  d->sequence[d->nd].related_to = b->bitmap.bmap[b->bitmap.nba - 1]->bitmap_to[ixloop];
                }
 
              if ( d->nd < ( d->dim - 1 ) )
                {
                  ( d->nd ) ++;
                }
              else if ( bufrdeco_increase_data_array ( d ) == 0 )
                {
                  ( d->nd ) ++;
                }
              else
                {
                  snprintf ( b->error, sizeof ( b->error ), "%s(): No more bufr_atom_data available. Check BUFR_NMAXSEQ\n", __func__ );
                  return 1;
                }
              break;
 
            case 1:
              // Case of replicator descriptor
              replicator.s = l;
              replicator.ixrep = i;
              if ( b->mask & BUFRDECO_OUTPUT_JSON_SUBSET_DATA )
                {
                  bufrdeco_print_json_separator ( b->out );
                  bufrdeco_print_json_object_replicator_descriptor ( b->out, & ( l->lseq[i] ), aux );
                }
 
              if ( l->lseq[i].y != 0 )
                {
                  // no delayed
                  replicator.ixdel = i;
                  replicator.ndesc = l->lseq[i].x;
                  replicator.nloops = l->lseq[i].y;
                  bufrdeco_decode_replicated_subsequence ( d, &replicator, b );
                  ixd += replicator.ndesc; // update ixd properly
                }
              else
                {
                  // case of delayed;
                  replicator.ixdel = i + 1;
                  replicator.ndesc = l->lseq[i].x;
                  // here we read ndesc from delayed replicator descriptor
                  if ( bufrdeco_tableB_val ( & ( d->sequence[d->nd] ), b, & ( l->lseq[i + 1] ) ) )
                    {
                      return 1;
                    }
                  if ( b->mask & BUFRDECO_OUTPUT_JSON_SUBSET_DATA )
                    {
                      bufrdeco_print_json_separator ( b->out );
                      bufrdeco_print_json_object_atom_data ( b->out, & ( d->sequence[d->nd] ), aux );
                    }
                  replicator.nloops = ( size_t ) d->sequence[d->nd].val;
                  if ( d->nd < ( d->dim - 1 ) )
                    {
                      ( d->nd ) ++;
                    }
                  else if ( bufrdeco_increase_data_array ( d ) == 0 )
                    {
                      ( d->nd ) ++;
                    }
                  else
                    {
                      snprintf ( b->error, sizeof ( b->error ), "%s(): No more bufr_atom_data available. Check BUFR_NMAXSEQ\n", __func__ );
                      return 1;
                    }
                  bufrdeco_decode_replicated_subsequence ( d, &replicator, b );
                  ixd += replicator.ndesc + 1; // update ixd properly
                }
              //i = r->ixdel + r->ndesc; // update i properly
              break;
 
            case 2:
              // Case of operator descriptor
              if ( bufrdeco_parse_f2_descriptor ( d, & ( l->lseq[i] ), b ) )
                {
                  return 1;
                }
 
              if ( b->mask & BUFRDECO_OUTPUT_JSON_SUBSET_DATA )
              {
                bufrdeco_print_json_separator ( b->out );
                bufrdeco_print_json_object_operator_descriptor ( b->out, & ( l->lseq[i] ), aux );
              }
              // Case of subsituted values
              if ( b->state.subs_active && l->lseq[i].x == 23 && l->lseq[i].y == 255 )
                {
                  k = b->bitmap.bmap[b->bitmap.nba - 1]->bitmap_to[ixloop]; // ref which is bitmaped_to
                  // Get the bitmaped descriptor k
                  if ( ixloop == 0 )
                    {
                      b->bitmap.bmap[b->bitmap.nba - 1]->subs = d->nd;
                    }
                  if ( bufrdeco_tableB_val ( & ( d->sequence[d->nd] ), b, & ( l->lseq[k] ) ) )
                    {
                      return 1;
                    }
                  d->sequence[d->nd].related_to = b->bitmap.bmap[b->bitmap.nba - 1]->bitmap_to[ixloop];
 
                  if ( d->nd < ( d->dim - 1 ) )
                    {
                      d->nd += 1;
                    }
                  else
                    {
                      snprintf ( b->error, sizeof ( b->error ), "%s(): Reached limit. Consider increas BUFR_NMAXSEQ\n", __func__ );
                      return 1;
                    }
                }
 
              // Case of replaced/retained values
              if ( b->state.retained_active && l->lseq[i].x == 32 && l->lseq[i].y == 255 )
                {
                  k = b->bitmap.bmap[b->bitmap.nba - 1]->bitmap_to[ixloop];
                  // Get the bitmaped descriptor k
                  if ( ixloop == 0 )
                    {
                      b->bitmap.bmap[b->bitmap.nba - 1]->retain = d->nd;
                    }
                  if ( bufrdeco_tableB_val ( & ( d->sequence[d->nd] ), b, & ( l->lseq[k] ) ) )
                    {
                      return 1;
                    }
 
                  d->sequence[d->nd].related_to = b->bitmap.bmap[b->bitmap.nba - 1]->bitmap_to[ixloop];
                  if ( d->nd < ( d->dim - 1 ) )
                    {
                      d->nd += 1;
                    }
                  else
                    {
                      snprintf ( b->error, sizeof ( b->error ), "%s(): Reached limit. Consider increas BUFR_NMAXSEQ\n", __func__ );
                      return 1;
                    }
                }
 
              // Case of first order statistics
              //
              // This operator shall signify a data item containing a
              // first-order statistical value of the type indicated by
              // the preceding 0 08 023 element descriptor; the
              // element descriptor to which the first-order statistic
              // relates is obtained by the application of the data
              // present bit-map associated with the first-order
              // statistical values follow operator; first-order statistical
              // values shall be represented as defined by this element
              // descriptor.
              if ( b->state.stat1_active && l->lseq[i].x == 24 && l->lseq[i].y == 255 )
                {
                  k = b->bitmap.bmap[b->bitmap.nba - 1]->bitmap_to[ixloop];
 
                  // Get the bitmaped descriptor k
                  if ( ixloop == 0 )
                    {
                      b->bitmap.bmap[b->bitmap.nba - 1]->stat1[b->bitmap.bmap[b->bitmap.nba - 1]->ns1 -1] = d->nd;
                    }
 
                  if ( bufrdeco_tableB_val ( & ( d->sequence[d->nd] ), b, & ( l->lseq[k] ) ) )
                    {
                      return 1;
                    }
 
                  d->sequence[d->nd].related_to = b->bitmap.bmap[b->bitmap.nba - 1]->bitmap_to[ixloop];
                  if ( d->nd < ( d->dim - 1 ) )
                    {
                      d->nd += 1;
                    }
                  else
                    {
                      snprintf ( b->error, sizeof ( b->error ), "%s(): Reached limit. Consider increas BUFR_NMAXSEQ\n", __func__ );
                      return 1;
                    }
                }
 
              // Case of difference statistics
              //
              // This operator shall signify a data item containing a
              // difference statistical value of the type indicated by
              // the preceding 0 08 024 element descriptor; the
              // element descriptor to which the difference statistical
              // value relates is obtained by the application of the
              // data present bit-map associated with the difference
              // statistical values follow operator; difference statistical
              // values shall be represented as defined by this
              // element descriptor, but with a reference value of –2**n
              // and a data width of (n+1), where n is the data width
              // given by the original descriptor. This special reference
              // value allows the statistical difference values to
              // be centred around zero.
              if ( b->state.dstat_active && l->lseq[i].x == 25 && l->lseq[i].y == 255 )
                {
                  k = b->bitmap.bmap[b->bitmap.nba - 1]->bitmap_to[ixloop];
 
                  // Get the bitmaped descriptor k
                  if ( ixloop == 0 )
                    {
                      b->bitmap.bmap[b->bitmap.nba - 1]->stat1[b->bitmap.bmap[b->bitmap.nba - 1]->nds -1] = d->nd;
                    }
 
                  // in bufrdeco_tableB_val() is taken into acount when is difference statistics active
                  if ( bufrdeco_tableB_val ( & ( d->sequence[d->nd] ), b, & ( l->lseq[k] ) ) )
                    {
                      return 1;
                    }
 
                  /*d->sequence[d->nd].ref = - ( ( int32_t ) 1 << d->sequence[d->nd].bits );
                  d->sequence[d->nd].bits++;*/
                  d->sequence[d->nd].related_to = b->bitmap.bmap[b->bitmap.nba - 1]->bitmap_to[ixloop];
                  if ( d->nd < ( d->dim - 1 ) )
                    {
                      d->nd += 1;
                    }
                  else
                    {
                      snprintf ( b->error, sizeof ( b->error ), "%s(): Reached limit. Consider increas BUFR_NMAXSEQ\n", __func__ );
                      return 1;
                    }
                }
 
              break;
 
            case 3:
              if ( b->mask & BUFRDECO_OUTPUT_JSON_SUBSET_DATA )
                bufrdeco_print_json_separator ( b->out );
              if ( bufrdeco_decode_subset_data_recursive ( d, l->sons[i], b ) )
                {
                  return 1;
                }
              break;
 
            default:
              // this case is not possible
              snprintf ( b->error, sizeof ( b->error ), "%s(): Found bad 'f' in descriptor\n", __func__ );
              return 1;
              break;
            }
        }
    }
  return 0;
}

References bufr_sequence_index_range::active, bufrdeco::bitmap, bufr_atom_data::bitmap_to, bufrdeco_bitmap::bitmap_to, bufrdeco_decoding_data_state::bitmaping, bufrdeco_bitmap_array::bmap, BUFR_MAX_QUALITY_DATA, bufrdeco_add_to_bitmap(), bufrdeco_assert, bufrdeco_decode_replicated_subsequence(), bufrdeco_decode_subset_data_recursive(), bufrdeco_increase_data_array(), BUFRDECO_OUTPUT_JSON_SUBSET_DATA, bufrdeco_parse_f2_descriptor(), bufrdeco_print_json_object_atom_data(), bufrdeco_print_json_object_operator_descriptor(), bufrdeco_print_json_object_replicator_descriptor(), bufrdeco_print_json_separator(), bufrdeco_tableB_val(), bufrdeco_decoding_data_state::data_repetition_factor, bufrdeco_subset_sequence_data::dim, bufrdeco_decoding_data_state::dstat_active, bufrdeco_bitmap::dstat_desc, bufrdeco::error, bufr_descriptor::f, bufr_sequence_index_range::first, bufr_atom_data::is_bitmaped_by, bufr_replicator::ixdel, bufr_replicator::ixrep, bufr_sequence::lseq, bufrdeco::mask, bufrdeco_bitmap_array::nba, bufrdeco_subset_sequence_data::nd, bufr_replicator::ndesc, bufrdeco_bitmap::nds, bufr_replicator::nloops, bufr_sequence::no_data_present, bufrdeco_bitmap::nq, bufrdeco_bitmap::ns1, bufrdeco::out, bufrdeco_bitmap::quality, bufrdeco_decoding_data_state::quality_active, bufr_atom_data::related_to, bufrdeco_bitmap::retain, bufrdeco_decoding_data_state::retained_active, bufr_replicator::s, bufrdeco_subset_sequence_data::sequence, bufr_sequence::sons, bufrdeco_bitmap::stat1, bufrdeco_decoding_data_state::stat1_active, bufrdeco_bitmap::stat1_desc, bufrdeco::state, bufrdeco_bitmap::subs, bufrdeco_decoding_data_state::subs_active, bufr_atom_data::val, bufr_descriptor::x, and bufr_descriptor::y.

Referenced by bufrdeco_decode_replicated_subsequence(), and bufrdeco_decode_subset_data_recursive().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_decode_replicated_subsequence_compressed()

int bufrdeco_decode_replicated_subsequence_compressed	(	struct bufrdeco_compressed_data_references *	r,
		struct bufr_replicator *	rep,
		struct bufrdeco *	b
	)

decodes a repicated subsequence

Parameters

r	pointer to target struct bufrdeco_compressed_data_references where to set results
rep	pointer to a replicator which contains the data for replication
b	basic container struct bufrdeco

Returns

Returns 0 if succeeded, 1 otherwise

Definition at line 352 of file bufrdeco_compressed.c.

{
  int res;
  buf_t i, k;
  buf_t ixloop; // Index for loop
  buf_t ixd; // Index for descriptor
  struct bufrdeco_compressed_ref *rf;
  struct bufr_replicator replicator;
  struct bufr_sequence *l = rep->s; // sequence
 
  // check arguments
  if ( b == NULL )
    return 1;
 
  if ( r == NULL || rep == NULL )
    {
      snprintf ( b->error, sizeof ( b->error ), "%s(): Unspected NULL argument(s)\n", __func__ );
      return 1;
    }
 
  // if no loops the we save process time and space in data
  if ( rep->nloops == 0 )
    return 0;
 
 
  // The big loop
  for ( ixloop = 0; ixloop < rep->nloops; ixloop++ )
    {
      for ( ixd = 0; ixd < rep->ndesc ; ixd ++ )
        {
          i = ixd + rep->ixdel + 1;
          switch ( l->lseq[i].f )
            {
            case 0:
              // Checks if no_data_present is active for this descriptor in this sequence
              if ( l->no_data_present.active &&
                   i >= l->no_data_present.first &&
                   i <= l->no_data_present.last )
                {
                  // If here then no_data_present has been active in this sequence
                  if ( l->lseq[i].x > 9 &&
                       l->lseq[i].x != 31 )
                    {
                      snprintf ( b->error, sizeof ( b->error ), "%s(): Getting data from table b with class other than 1-9,31 and no data present activated\n", __func__ );
                      return 1;
                    }
 
                }
              // Get data from table B
              rf = & ( r->refs[r->nd] );
              rf->replicated_desc = ixd + 1;
              rf->replicated_loop = ixloop + 1;
              rf->replicated_ndesc = rep->ndesc;
              rf->replicated_nloop = rep->nloops;
              
              // First then the data itself
              if ( bufrdeco_tableB_compressed ( rf, b, & ( l->lseq[i] ), 0 ) )
                {
                  return 1;
                }
 
              // Case of defining bitmap 0 31 031
              if ( l->lseq[i].x == 31 && l->lseq[i].y == 31 && b->state.bitmaping )
                {
                  if ( rf->ref0 == 0 ) // Assume if ref0 == 0 then all subsets are present in same bits
                    {
                      r->refs[r->nd - b->state.bitmaping].is_bitmaped_by = ( uint32_t ) r->nd ;
                      rf->bitmap_to = r->nd - b->state.bitmaping;
                      bufrdeco_add_to_bitmap ( b->bitmap.bmap[b->bitmap.nba - 1], r->nd - b->state.bitmaping, r->nd );
                    }
                }
 
              // Process quality data
              if ( b->state.quality_active &&
                   l->lseq[i].x == 33 )
                {
                  if ( ixloop == 0 )
                    {
                      k = b->bitmap.bmap[b->bitmap.nba - 1]->nq; // index un quality_given_by array to set
                      b->bitmap.bmap[b->bitmap.nba - 1]->quality[k] = r->nd; // Set the value
                      // update the number of quality variables for the bitmap
                      if ( k < BUFR_MAX_QUALITY_DATA )
                        ( b->bitmap.bmap[b->bitmap.nba - 1]->nq )++;
                      else
                        {
                          snprintf ( b->error, sizeof ( b->error ), "%s(): No more space for quality vars in bitmap. Check BUFR_MAX_QUALITY_DATA\n", __func__ );
                          return 1;
                        }
                    }
                  rf->related_to = b->bitmap.bmap[b->bitmap.nba - 1]->bitmap_to[ixloop];
 
                }
 
              //case of first order statistics
              if ( b->state.stat1_active &&
                   l->lseq[i].x == 8 && l->lseq[i].y == 23 )
                {
                  if ( ixloop == 0 )
                    {
                      k = b->bitmap.bmap[b->bitmap.nba - 1]->ns1; // index un stqts
                      b->bitmap.bmap[b->bitmap.nba - 1]->stat1_desc[k] = r->nd; // Set the value of statistical parameter
                      // update the number of quality variables for the bitmap
                      if ( k < BUFR_MAX_QUALITY_DATA )
                        ( b->bitmap.bmap[b->bitmap.nba - 1]->ns1 )++;
                      else
                        {
                          snprintf ( b->error, sizeof ( b->error ), "%s(): No more space for first order statistic vars in bitmap. Check BUFR_MAX_QUALITY_DATA\n", __func__ );
                          return 1;
                        }
                    }
                  rf->related_to = b->bitmap.bmap[b->bitmap.nba - 1]->bitmap_to[ixloop];
                }
 
              //case of difference statistics
              if ( b->state.dstat_active &&
                   l->lseq[i].x == 8 && l->lseq[i].y == 24 )
                {
                  if ( ixloop == 0 )
                    {
                      k = b->bitmap.bmap[b->bitmap.nba - 1]->nds; // index un stqts
                      b->bitmap.bmap[b->bitmap.nba - 1]->dstat_desc[k] = r->nd; // Set the value of statistical parameter
                      // update the number of quality variables for the bitmap
                      if ( k < BUFR_MAX_QUALITY_DATA )
                        ( b->bitmap.bmap[b->bitmap.nba - 1]->nds )++;
                      else
                        {
                          snprintf ( b->error, sizeof ( b->error ), "%s(): No more space for difference statistic vars in bitmap. Check BUFR_MAX_QUALITY_DATA\n", __func__ );
                          return 1;
                        }
                    }
                  rf->related_to = b->bitmap.bmap[b->bitmap.nba - 1]->bitmap_to[ixloop];
                }
 
              rf->mask = BUFRDECO_COMPRESSED_REF_DATA_DESCRIPTOR_BITMASK;
              rf->seq = l;
 
              // Set the used elements of array in r
              if ( bufrdeco_increase_compressed_data_references_count ( r, b ) )
                return 1;
 
              // Then associated field
              rf = & ( r->refs[r->nd] );
              res = bufrdeco_tableB_compressed ( rf, b, & ( l->lseq[i] ), 1 );
              if ( res > 0 )
                {
                  return 1; // case of error
                }
              else if ( res == 0 )
                {
                  //print_bufrdeco_compressed_ref ( rf );
                  // associated field read with success
                  rf->mask = BUFRDECO_COMPRESSED_REF_DATA_DESCRIPTOR_BITMASK;
                  rf->seq = l;
                  // Set the used elements of array in r
                  if ( bufrdeco_increase_compressed_data_references_count ( r, b ) )
                    return 1;
                  b->state.assoc_bits = 0; // Set again the assoc_bits to 0
                }
 
              break;
 
            case 1:
              // Case of replicator descriptor
              rf = & ( r->refs[r->nd] );
              rf->mask = BUFRDECO_COMPRESSED_REF_REPLICATOR_DESCRIPTOR;
              rf->seq = l;
              rf->desc = & ( l->lseq[i] );
              rf->replicated_desc = ixd + 1;
              rf->replicated_loop = ixloop + 1;
              rf->replicated_ndesc = rep->ndesc;
              rf->replicated_nloop = rep->nloops;
 
              // Set the used elements of array in r
              if ( bufrdeco_increase_compressed_data_references_count ( r, b ) )
                return 1;
 
              replicator.s = l;
              replicator.ixrep = i;
              if ( l->lseq[i].y != 0 )
                {
                  // no delayed
                  replicator.ixdel = i;
                  replicator.ndesc = l->lseq[i].x;
                  replicator.nloops = l->lseq[i].y;
                  bufrdeco_decode_replicated_subsequence_compressed ( r, & replicator, b );
                  ixd += replicator.ndesc; // update ixd properly
                }
              else
                {
                  // case of delayed;
                  replicator.ixdel = i + 1;
                  replicator.ndesc = l->lseq[i].x;
                  rf = & ( r->refs[r->nd] );
 
                  // The data itself to get the loops
                  if ( bufrdeco_tableB_compressed ( rf, b, & ( l->lseq[replicator.ixdel] ), 0 ) )
                    {
                      return 1;
                    }
                  rf->mask = BUFRDECO_COMPRESSED_REF_DATA_DESCRIPTOR_BITMASK;
                  rf->seq = l;
 
                  // Set the used elements of bufrdeco_compressed_ref
                  if ( bufrdeco_increase_compressed_data_references_count ( r, b ) )
                    return 1;
                  replicator.nloops = ( size_t ) rf->ref0;
 
                  bufrdeco_decode_replicated_subsequence_compressed ( r, &replicator, b );
                  ixd += replicator.ndesc + 1; // update ixd properly
                }
 
              break;
 
            case 2:
              rf = & ( r->refs[r->nd] );
              rf->mask = BUFRDECO_COMPRESSED_REF_OPERATOR_DESCRIPTOR;
              rf->seq = l;
              rf->desc = & ( l->lseq[i] );
              rf->replicated_desc = ixd + 1;
              rf->replicated_loop = ixloop + 1;
              rf->replicated_ndesc = rep->ndesc;
              rf->replicated_nloop = rep->nloops;
 
              // Set the used elements of array in r
              if ( bufrdeco_increase_compressed_data_references_count ( r, b ) )
                return 1;
 
              // Case of operator descriptor
              if ( bufrdeco_parse_f2_compressed ( r, & ( l->lseq[i] ), b ) )
                {
                  return 1;
                }
 
              // Case of subsituted values
              if ( b->state.subs_active && l->lseq[i].x == 23 && l->lseq[i].y == 255 )
                {
                  k = b->bitmap.bmap[b->bitmap.nba - 1]->bitmap_to[ixloop]; // ref which is bitmaped_to
                  // Get the bitmaped descriptor k
                  rf = & ( r->refs[r->nd] );
                  if ( ixloop == 0 )
                    {
                      b->bitmap.bmap[b->bitmap.nba - 1]->subs = r->nd;
                    }
                  if ( bufrdeco_tableB_compressed ( rf, b, & ( l->lseq[k] ), 0 ) )
                    {
                      return 1;
                    }
                  rf->related_to = b->bitmap.bmap[b->bitmap.nba - 1]->bitmap_to[ixloop];
                  rf->mask = BUFRDECO_COMPRESSED_REF_DATA_DESCRIPTOR_BITMASK;
                  rf->seq = l;
                  rf->desc = & ( l->lseq[k] );
                  if ( bufrdeco_increase_compressed_data_references_count ( r, b ) )
                    return 1;
                }
 
              // Case of repaced/retained values
              if ( b->state.retained_active && l->lseq[i].x == 32 && l->lseq[i].y == 255 )
                {
                  k = b->bitmap.bmap[b->bitmap.nba - 1]->bitmap_to[ixloop];
                  // Get the bitmaped descriptor k
                  rf = & ( r->refs[r->nd] );
                  if ( ixloop == 0 )
                    {
                      b->bitmap.bmap[b->bitmap.nba - 1]->retain = r->nd;
                    }
                  if ( bufrdeco_tableB_compressed ( rf, b, & ( l->lseq[k] ), 0 ) )
                    {
                      return 1;
                    }
 
                  rf->related_to = b->bitmap.bmap[b->bitmap.nba - 1]->bitmap_to[ixloop];
                  rf->mask = BUFRDECO_COMPRESSED_REF_DATA_DESCRIPTOR_BITMASK;
                  rf->seq = l;
                  rf->desc = & ( l->lseq[k] );
                  if ( bufrdeco_increase_compressed_data_references_count ( r, b ) )
                    return 1;
                }
 
              // Case of first order statistics
              //
              // This operator shall signify a data item containing a
              // first-order statistical value of the type indicated by
              // the preceding 0 08 023 element descriptor; the
              // element descriptor to which the first-order statistic
              // relates is obtained by the application of the data
              // present bit-map associated with the first-order
              // statistical values follow operator; first-order statistical
              // values shall be represented as defined by this element
              // descriptor.
              if ( b->state.stat1_active && l->lseq[i].x == 24 && l->lseq[i].y == 255 )
                {
                  k = b->bitmap.bmap[b->bitmap.nba - 1]->bitmap_to[ixloop];
 
                  // Get the bitmaped descriptor k
                  rf = & ( r->refs[r->nd] );
                  if ( ixloop == 0 )
                    {
                      b->bitmap.bmap[b->bitmap.nba - 1]->stat1[b->bitmap.bmap[b->bitmap.nba - 1]->ns1 -1] = r->nd;
                    }
 
                  if ( bufrdeco_tableB_compressed ( rf, b, r->refs[k].desc, 0 ) )
                    {
                      return 1;
                    }
                  rf->related_to = b->bitmap.bmap[b->bitmap.nba - 1]->bitmap_to[ixloop];
                  rf->mask = BUFRDECO_COMPRESSED_REF_DATA_DESCRIPTOR_BITMASK;
                  rf->seq = l;
                  rf->desc = & ( l->lseq[k] );
                  if ( bufrdeco_increase_compressed_data_references_count ( r, b ) )
                    return 1;
                }
 
              // Case of difference statistics
              //
              // This operator shall signify a data item containing a
              // difference statistical value of the type indicated by
              // the preceding 0 08 024 element descriptor; the
              // element descriptor to which the difference statistical
              // value relates is obtained by the application of the
              // data present bit-map associated with the difference
              // statistical values follow operator; difference statistical
              // values shall be represented as defined by this
              // element descriptor, but with a reference value of –2**n
              // and a data width of (n+1), where n is the data width
              // given by the original descriptor. This special reference
              // value allows the statistical difference values to
              // be centred around zero.
              if ( b->state.dstat_active && l->lseq[i].x == 25 && l->lseq[i].y == 255 )
                {
                  k = b->bitmap.bmap[b->bitmap.nba - 1]->bitmap_to[ixloop];
 
                  // Get the bitmaped descriptor k
                  rf = & ( r->refs[r->nd] );
                  if ( ixloop == 0 )
                    {
                      b->bitmap.bmap[b->bitmap.nba - 1]->stat1[b->bitmap.bmap[b->bitmap.nba - 1]->nds -1] = r->nd;
                    }
 
                  if ( bufrdeco_tableB_compressed ( rf, b, r->refs[k].desc, 0 ) )
                    {
                      return 1;
                    }
 
                  // here is where we change ref and bits
                  rf->ref = - ( ( int32_t ) 1 << rf->bits );
                  rf->bits++;
                  rf->related_to = b->bitmap.bmap[b->bitmap.nba - 1]->bitmap_to[ixloop];
                  rf->mask = BUFRDECO_COMPRESSED_REF_DATA_DESCRIPTOR_BITMASK;
                  rf->seq = l;
                  if ( bufrdeco_increase_compressed_data_references_count ( r, b ) )
                    return 1;
                }
 
              if ( l->lseq[i].x == 5 ) // cases wich produces a new ref
                {
                  rf->mask = BUFRDECO_COMPRESSED_REF_DATA_DESCRIPTOR_BITMASK;
                  rf->seq = l;
                  if ( bufrdeco_increase_compressed_data_references_count ( r, b ) )
                    return 1;
                }
              break;
 
            case 3:
              // Case of sequence descriptor
              if ( bufrdeco_parse_compressed_recursive ( r, l->sons[i], b ) )
                return 1;
              break;
 
            default:
              // this case is not possible
              snprintf ( b->error, sizeof ( b->error ), "%s(): Found bad 'f' in descriptor\n", __func__ );
              return 1;
              break;
            }
        }
    }
  return 0;
}

References bufr_sequence_index_range::active, bufrdeco_decoding_data_state::assoc_bits, bufrdeco::bitmap, bufrdeco_bitmap::bitmap_to, bufrdeco_compressed_ref::bitmap_to, bufrdeco_decoding_data_state::bitmaping, bufrdeco_compressed_ref::bits, bufrdeco_bitmap_array::bmap, BUFR_MAX_QUALITY_DATA, bufrdeco_add_to_bitmap(), BUFRDECO_COMPRESSED_REF_DATA_DESCRIPTOR_BITMASK, BUFRDECO_COMPRESSED_REF_OPERATOR_DESCRIPTOR, BUFRDECO_COMPRESSED_REF_REPLICATOR_DESCRIPTOR, bufrdeco_decode_replicated_subsequence_compressed(), bufrdeco_increase_compressed_data_references_count(), bufrdeco_parse_compressed_recursive(), bufrdeco_parse_f2_compressed(), bufrdeco_tableB_compressed(), bufrdeco_compressed_ref::desc, bufrdeco_decoding_data_state::dstat_active, bufrdeco_bitmap::dstat_desc, bufrdeco::error, bufr_descriptor::f, bufr_sequence_index_range::first, bufrdeco_compressed_ref::is_bitmaped_by, bufr_replicator::ixdel, bufr_replicator::ixrep, bufr_sequence_index_range::last, bufr_sequence::lseq, bufrdeco_compressed_ref::mask, bufrdeco_bitmap_array::nba, bufrdeco_compressed_data_references::nd, bufr_replicator::ndesc, bufrdeco_bitmap::nds, bufr_replicator::nloops, bufr_sequence::no_data_present, bufrdeco_bitmap::nq, bufrdeco_bitmap::ns1, bufrdeco_bitmap::quality, bufrdeco_decoding_data_state::quality_active, bufrdeco_compressed_ref::ref, bufrdeco_compressed_ref::ref0, bufrdeco_compressed_data_references::refs, bufrdeco_compressed_ref::related_to, bufrdeco_compressed_ref::replicated_desc, bufrdeco_compressed_ref::replicated_loop, bufrdeco_compressed_ref::replicated_ndesc, bufrdeco_compressed_ref::replicated_nloop, bufrdeco_bitmap::retain, bufrdeco_decoding_data_state::retained_active, bufr_replicator::s, bufrdeco_compressed_ref::seq, bufr_sequence::sons, bufrdeco_bitmap::stat1, bufrdeco_decoding_data_state::stat1_active, bufrdeco_bitmap::stat1_desc, bufrdeco::state, bufrdeco_bitmap::subs, bufrdeco_decoding_data_state::subs_active, bufr_descriptor::x, and bufr_descriptor::y.

Referenced by bufrdeco_decode_replicated_subsequence_compressed(), and bufrdeco_parse_compressed_recursive().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_decode_subset_data_recursive()

int bufrdeco_decode_subset_data_recursive	(	struct bufrdeco_subset_sequence_data *	d,
		struct bufr_sequence *	l,
		struct bufrdeco *	b
	)

decode the data from a subset in a recursive way

Parameters

d	pointer to the target struct bufrdeco_subset_sequence_data
l	pointer to the source struct bufr_sequence
b	pointer to the base struct bufrdeco

Returns

0 in case of success, 1 otherwise

Definition at line 171 of file bufrdeco_data.c.

{
  size_t i, j, k;
  struct bufr_sequence *seq;
  struct bufr_replicator replicator;
 
  bufrdeco_assert ( b != NULL );
 
  if ( d == NULL )
    {
      snprintf ( b->error, sizeof ( b->error ), "%s(): Unspected NULL argument(s)\n", __func__ );
      return 1;
    }
 
 
  // clean subset data, if l == NULL we are at the begining of a subset, level 0
  if ( l == NULL )
    {
 
      //memset ( s, 0, sizeof ( struct bufr_subset_sequence_data ) );
      d->nd = 0;
      d->ss = b->state.subset;
      seq = & ( b->tree->seq[0] );
      if ( b->state.subset == 0 )
        {
          b->state.bit_offset = 0;
        }
 
      // Manage bit offset of the subset
      if ( b->state.subset < BUFR_MAX_SUBSETS )
        {
          // No bit offset still set for this subset
          if ( b->offsets.ofs[b->state.subset] == 0 )
            {
              if ( b->offsets.nr <= b->state.subset )
                b->offsets.nr = b->state.subset + 1;
              b->offsets.ofs[b->state.subset] = b->state.bit_offset;
            }
          else
            {
              // offset is already set, so we can go directly to the data
              b->state.bit_offset = b->offsets.ofs[b->state.subset];
            }
        }
      else
        {
          snprintf ( b->error, sizeof ( b->error ), "%s(): Cannot manage subset bit offset for subset %u. Consider increase BUFR_MAX_SUBSETS\n",
                     __func__, b->state.subset );
          return 1;
        }
 
      // also reset reference and bits inc
      b->state.added_bit_length = 0;
      b->state.added_scale = 0;
      b->state.added_reference = 0;
      b->state.assoc_bits = 0;
      b->state.changing_reference = 255;
      b->state.fixed_ccitt = 0;
      b->state.local_bit_reserved = 0;
      b->state.factor_reference = 1;
      b->state.quality_active = 0;
      b->state.subs_active = 0;
      b->state.retained_active = 0;
      b->state.stat1_active = 0;
      b->state.dstat_active = 0;
      b->state.bitmaping = 0;
      b->state.data_repetition_factor = 0;
      b->state.bitmap = NULL;
 
      // print prologue if needed
      if ( b->mask & BUFRDECO_OUTPUT_JSON_SUBSET_DATA )
        bufrdeco_print_json_subset_data_prologue ( b->out,  b );
 
    }
  else
    {
      seq = l;
    }
 
  // loop for a sequence
  if ( b->mask & BUFRDECO_OUTPUT_JSON_SUBSET_DATA )
    {
      //if (seq->iseq)
      //  bufrdeco_print_json_separator ( b->out ); // print json array element separator
      bufrdeco_print_json_sequence_descriptor_header ( b->out, seq );
    }
 
  for ( i = 0, j = 0 ; i < seq->ndesc ; i++ )
    {
      switch ( seq->lseq[i].f )
        {
        case 0:
 
          // Checks if no_data_present is active for this descriptor in this sequence
          if ( seq->no_data_present.active &&
               i >= seq->no_data_present.first &&
               i <= seq->no_data_present.last )
            {
              // If here then no_data_present has been active in this sequence
              if ( seq->lseq[i].x > 9 &&
                   seq->lseq[i].x != 31 )
                {
                  snprintf ( b->error, sizeof ( b->error ), "%s(): Getting data from table b with class other than 1-9,31 and no data present activated\n",
                             __func__ );
                  return 1;
                }
 
            }
 
 
          // Repeat the extraction of data if b->state.data_repetition_factor != 0
          // It get data al least a time
          // It is supossed that prior parsed descriptor was 0 31 011 or 0 31 012 which set de value of repetition data
          do
            {
              // decrement counter if not zero
              if ( b->state.data_repetition_factor )
                ( b->state.data_repetition_factor )--;
 
              // Get data from table B
              if ( bufrdeco_tableB_val ( & ( d->sequence[d->nd] ), b, & ( seq->lseq[i] ) ) )
                {
                  return 1;
                }
              if ( b->mask & BUFRDECO_OUTPUT_JSON_SUBSET_DATA )
              {
                if (j)
                  bufrdeco_print_json_separator ( b->out );
                bufrdeco_print_json_object_atom_data ( b->out, & ( d->sequence[d->nd] ), NULL );
                j++;
              }
            }
          while ( b->state.data_repetition_factor != 0 );
 
          // case of delayed replicator description and data
          if ( seq->lseq[i].x == 31 && ( seq->lseq[i].y == 11 || seq->lseq[i].y == 12 ) )
            {
              b->state.data_repetition_factor = ( buf_t ) d->sequence[d->nd].val;
            }
 
          //case of first order statistics
          if ( b->state.stat1_active &&
               seq->lseq[i].x == 8 && seq->lseq[i].y == 23 )
            {
              k = b->bitmap.bmap[b->bitmap.nba - 1]->ns1; // index un stqts
              b->bitmap.bmap[b->bitmap.nba - 1]->stat1_desc[k] = d->nd; // Set the value of statistical parameter
              // update the number of quality variables for the bitmap
              if ( k < BUFR_MAX_QUALITY_DATA )
                ( b->bitmap.bmap[b->bitmap.nba - 1]->ns1 )++;
              else
                {
                  snprintf ( b->error, sizeof ( b->error ), "%s(): No more space for first order statistic vars in bitmap. Check BUFR_MAX_QUALITY_DATA\n",
                             __func__ );
                  return 1;
                }
            }
 
          //case of difference statistics
          if ( b->state.dstat_active &&
               seq->lseq[i].x == 8 && seq->lseq[i].y == 24 )
            {
              k = b->bitmap.bmap[b->bitmap.nba - 1]->nds; // index in stats
              b->bitmap.bmap[b->bitmap.nba - 1]->dstat_desc[k] = d->nd; // Set the value of statistical parameter
              // update the number of quality variables for the bitmap
              if ( k < BUFR_MAX_QUALITY_DATA )
                ( b->bitmap.bmap[b->bitmap.nba - 1]->nds )++;
              else
                {
                  snprintf ( b->error, sizeof ( b->error ), "%s(): No more space for difference statistic vars in bitmap. Check BUFR_MAX_QUALITY_DATA\n",
                             __func__ );
                  return 1;
                }
            }
 
 
 
          // Add info about common sequence to which bufr_atom_data belongs
          d->sequence[d->nd].seq = seq;
          d->sequence[d->nd].ns = i;
 
          //bufr_print_atom_data_stdout(& ( d->sequence[d->nd] ));
          if ( d->nd < ( d->dim - 1 ) )
            {
              ( d->nd ) ++;
            }
          else if ( bufrdeco_increase_data_array ( d ) == 0 )
            {
              ( d->nd ) ++;
            }
          else
            {
              snprintf ( b->error, sizeof ( b->error ), "%s(): No more bufr_atom_data available. Check BUFR_NMAXSEQ\n", __func__ );
              return 1;
            }
          break;
 
        case 1:
          // Case of replicator descriptor
          replicator.s = seq;
          replicator.ixrep = i;
          if ( b->mask & BUFRDECO_OUTPUT_JSON_SUBSET_DATA )
            {
              if (j)
                bufrdeco_print_json_separator ( b->out );
              bufrdeco_print_json_object_replicator_descriptor ( b->out, & ( seq->lseq[i] ), NULL );
              j++;
            }
          
          if ( seq->lseq[i].y != 0 )
            {
              // no delayed
              replicator.ixdel = i;
              replicator.ndesc = seq->lseq[i].x;
              replicator.nloops = seq->lseq[i].y;
 
              // Check if this replicator is for a bit-map defining
              if ( b->state.bitmaping )
                {
                  b->state.bitmaping = replicator.nloops; // set it properly
                }
 
              bufrdeco_decode_replicated_subsequence ( d, &replicator, b );
 
              // and then set again bitamping to 0, because it is finished
              b->state.bitmaping = 0;
 
              i += replicator.ndesc;
            }
          else
            {
              // case of delayed;
              replicator.ixdel = i + 1;
              replicator.ndesc = seq->lseq[i].x;
              // here we read ndesc from delayed replicator descriptor
              if ( bufrdeco_tableB_val ( & ( d->sequence[d->nd] ), b, & ( seq->lseq[i + 1] ) ) )
                {
                  return 1;
                }
              if ( b->mask & BUFRDECO_OUTPUT_JSON_SUBSET_DATA )
                {
                  if (j)
                    bufrdeco_print_json_separator ( b->out );
                  bufrdeco_print_json_object_atom_data ( b->out, & ( d->sequence[d->nd] ), NULL );
                  j++;
                }
              // Add info about common sequence to which bufr_atom_data belongs
              d->sequence[d->nd].seq = seq;
              d->sequence[d->nd].ns = i + 1;
 
              replicator.nloops = ( size_t ) ( d->sequence[d->nd].val );
 
              // Check if this replicator is for a bit-map defining
              if ( b->state.bitmaping )
                {
                  b->state.bitmaping = replicator.nloops; // set it properly
                }
 
              if ( d->nd < ( d->dim - 1 ) )
                {
                  ( d->nd ) ++;
                }
              else if ( bufrdeco_increase_data_array ( d ) == 0 )
                {
                  ( d->nd ) ++;
                }
              else
                {
 
                  snprintf ( b->error, sizeof ( b->error ), "%s(): No more bufr_atom_data available. Check BUFR_NMAXSEQ\n", __func__ );
                  return 1;
                }
              bufrdeco_decode_replicated_subsequence ( d, &replicator, b );
 
              // and then set again bitamping to 0, because it is finished
              b->state.bitmaping = 0;
 
              i += replicator.ndesc + 1;
            }
          //i = replicator.ixdel + replicator.ndesc; // update i properly
          break;
 
        case 2:
          // Case of operator descriptor
          if ( bufrdeco_parse_f2_descriptor ( d, & ( seq->lseq[i] ), b ) )
            {
              return 1;
            }
          if ( b->mask & BUFRDECO_OUTPUT_JSON_SUBSET_DATA )
          {
            if (j)
              bufrdeco_print_json_separator ( b->out );
            bufrdeco_print_json_object_operator_descriptor ( b->out, & ( seq->lseq[i] ), NULL );
            j++;
          }
          break;
 
        case 3:
          if ( b->mask & BUFRDECO_OUTPUT_JSON_SUBSET_DATA )
          {
            if (j)
              bufrdeco_print_json_separator ( b->out ); // print json array element separator
            j++;
          }
          // Case of sequence descriptor
          if ( bufrdeco_decode_subset_data_recursive ( d, seq->sons[i], b ) )
            {
              return 1;
            }
          break;
 
        default:
          // this case is not possible
          snprintf ( b->error, sizeof ( b->error ), "%s(): Found bad 'f' in descriptor '%s' \n", seq->lseq[i].c, __func__ );
          return 1;
          break;
        }
    }
 
  // End of sequence
  if ( b->mask & BUFRDECO_OUTPUT_JSON_SUBSET_DATA )
    bufrdeco_print_json_sequence_descriptor_final ( b->out );
 
  // End of data subset
  if ( l == NULL && ( b->mask & BUFRDECO_OUTPUT_JSON_SUBSET_DATA ) )
    bufrdeco_print_json_subset_data_epilogue ( b->out );
 
  return 0;
 
};

References bufr_sequence_index_range::active, bufrdeco_decoding_data_state::added_bit_length, bufrdeco_decoding_data_state::added_reference, bufrdeco_decoding_data_state::added_scale, bufrdeco_decoding_data_state::assoc_bits, bufrdeco_decoding_data_state::bit_offset, bufrdeco_decoding_data_state::bitmap, bufrdeco::bitmap, bufrdeco_decoding_data_state::bitmaping, bufrdeco_bitmap_array::bmap, BUFR_MAX_QUALITY_DATA, BUFR_MAX_SUBSETS, bufrdeco_assert, bufrdeco_decode_replicated_subsequence(), bufrdeco_decode_subset_data_recursive(), bufrdeco_increase_data_array(), BUFRDECO_OUTPUT_JSON_SUBSET_DATA, bufrdeco_parse_f2_descriptor(), bufrdeco_print_json_object_atom_data(), bufrdeco_print_json_object_operator_descriptor(), bufrdeco_print_json_object_replicator_descriptor(), bufrdeco_print_json_separator(), bufrdeco_print_json_sequence_descriptor_final(), bufrdeco_print_json_sequence_descriptor_header(), bufrdeco_print_json_subset_data_epilogue(), bufrdeco_print_json_subset_data_prologue(), bufrdeco_tableB_val(), bufr_descriptor::c, bufrdeco_decoding_data_state::changing_reference, bufrdeco_decoding_data_state::data_repetition_factor, bufrdeco_subset_sequence_data::dim, bufrdeco_decoding_data_state::dstat_active, bufrdeco_bitmap::dstat_desc, bufrdeco::error, bufr_descriptor::f, bufrdeco_decoding_data_state::factor_reference, bufr_sequence_index_range::first, bufrdeco_decoding_data_state::fixed_ccitt, bufr_replicator::ixdel, bufr_replicator::ixrep, bufrdeco_decoding_data_state::local_bit_reserved, bufr_sequence::lseq, bufrdeco::mask, bufrdeco_bitmap_array::nba, bufrdeco_subset_sequence_data::nd, bufr_replicator::ndesc, bufr_sequence::ndesc, bufrdeco_bitmap::nds, bufr_replicator::nloops, bufr_sequence::no_data_present, bufrdeco_subset_bit_offsets::nr, bufr_atom_data::ns, bufrdeco_bitmap::ns1, bufrdeco::offsets, bufrdeco_subset_bit_offsets::ofs, bufrdeco::out, bufrdeco_decoding_data_state::quality_active, bufrdeco_decoding_data_state::retained_active, bufr_replicator::s, bufr_atom_data::seq, bufrdeco_expanded_tree::seq, bufrdeco_subset_sequence_data::sequence, bufr_sequence::sons, bufrdeco_subset_sequence_data::ss, bufrdeco_decoding_data_state::stat1_active, bufrdeco_bitmap::stat1_desc, bufrdeco::state, bufrdeco_decoding_data_state::subs_active, bufrdeco_decoding_data_state::subset, bufrdeco::tree, bufr_atom_data::val, bufr_descriptor::x, and bufr_descriptor::y.

Referenced by bufrdeco_decode_data_subset(), bufrdeco_decode_replicated_subsequence(), and bufrdeco_decode_subset_data_recursive().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_explained_flag_csv_val()

char * bufrdeco_explained_flag_csv_val	(	char *	expl,
		size_t	dim,
		struct bufr_tableC *	tc,
		struct bufr_descriptor *	d,
		uint64_t	ival,
		uint8_t	nbits
	)

bufrdeco_explained_flag_val()

char * bufrdeco_explained_flag_val	(	char *	expl,
		size_t	dim,
		struct bufr_tableC *	tc,
		struct bufr_descriptor *	d,
		uint64_t	ival,
		uint8_t	nbits
	)

Definition at line 200 of file bufrdeco_tableC.c.

{
  size_t used = 0;
  uint64_t test, test0;
  uint64_t v;
  size_t i, j;
 
  bufrdeco_assert ( tc != NULL && expl != NULL && d != NULL);
 
  if ( tc->num[d->x] == 0 )
    {
      //printf("Descriptor %s No encontrado\n", d->c);
      return NULL;
    }
 
  // First line for descriptor
  i = tc->x_start[d->x] + tc->y_ref[d->x][d->y];
 
  // init description
  expl[0] = '\0';
 
  for ( j = 0, test0 = 1 ; j < nbits && ( tc->item[i].x == d->x ) && ( tc->item[i].y == d->y ) ; i++ )
    {
      v = tc->item[i].ival; // v is the bit number
      j++;
 
      // case 0 with meaning
      if ( v == 0 )
        {
          test0 = 1;
          if ( ival == 0 )
            {
              used += snprintf ( expl + used, dim - used, "|" );
              used += snprintf ( expl + used, dim - used, "%s", tc->item[i].description );
              return expl;
            }
        }
 
      test = test0 << ( nbits - v );
 
      if ( v && ( test & ival ) != 0 )
        {
          used += snprintf ( expl + used, dim - used, "|" );
          used += snprintf ( expl + used, dim - used, "%s", tc->item[i].description );
        }
      else
        {
          continue;
        }
      //printf ( "%s\n", expl );
    }
  // if match then we have finished the search
  return expl;
}

References bufrdeco_assert, bufr_tableC_decoded_item::description, bufr_tableC::item, bufr_tableC_decoded_item::ival, bufr_tableC::num, bufr_descriptor::x, bufr_tableC_decoded_item::x, bufr_tableC::x_start, bufr_descriptor::y, bufr_tableC_decoded_item::y, and bufr_tableC::y_ref.

Referenced by bufrdeco_get_atom_data_from_compressed_data_ref(), and bufrdeco_tableB_val().

Here is the caller graph for this function:

bufrdeco_explained_table_csv_val()

char * bufrdeco_explained_table_csv_val	(	char *	expl,
		size_t	dim,
		struct bufr_tableC *	tc,
		uint32_t *	index,
		struct bufr_descriptor *	d,
		uint32_t	ival
	)

bufrdeco_explained_table_val()

char * bufrdeco_explained_table_val	(	char *	expl,
		size_t	dim,
		struct bufr_tableC *	tc,
		uint32_t *	index,
		struct bufr_descriptor *	d,
		uint32_t	ival
	)

Definition at line 168 of file bufrdeco_tableC.c.

{
  buf_t i;
 
  bufrdeco_assert ( tc != NULL && expl != NULL && index != NULL && d != NULL);
  
  if ( bufr_find_tableC_csv_index ( &i, tc, d->c, ival ) )
    {
      return NULL; // descritor not found
    }
 
  // here the calling b item learn where to find first table C struct for a given x and y.
  *index = tc->x_start[d->x] + tc->y_ref[d->x][d->y];
 
  strncpy_safe ( expl, tc->item[i].description, dim );
  return expl;
}

References bufr_find_tableC_csv_index(), bufrdeco_assert, bufr_descriptor::c, bufr_tableC_decoded_item::description, bufr_tableC::item, strncpy_safe, bufr_descriptor::x, bufr_tableC::x_start, bufr_descriptor::y, and bufr_tableC::y_ref.

Referenced by bufrdeco_get_atom_data_from_compressed_data_ref(), and bufrdeco_tableB_val().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_extract_bufr()

int bufrdeco_extract_bufr	(	struct bufrdeco *	b,
		char *	filename
	)

Read file and try to find a bufr report inserted in. Once found do the same that bufrdeco_read_file()

Parameters

b	pointer to struct bufrdeco
filename	complete path of BUFR file

Returns

0 if all is OK, 1 otherwise

This function does the folowing tasks:

• Try to find first buffer of bytes begining with 'BUFR' chars and ending with '7777'. This will be considered as a bufr file.
• Read the file and checks the marks at the begining and end to see wheter is a BUFR file
• Init the structs and allocate the needed memory if not done previously
• Splits and parse the BUFR sections (without expanding descriptors nor parsing data)
• Reads the needed Table files and store them in memory.

< pointer to a memory buffer where we write raw bufr file

Definition at line 120 of file bufrdeco_read.c.

{
  int aux, res;
  uint8_t *bufrx = NULL, *pbeg = NULL; /*!< pointer to a memory buffer where we write raw bufr file */
  buf_t n = 0, beg, end, size = 0;
  FILE *fp;
  struct stat st;
 
  bufrdeco_assert ( b != NULL );
 
  /* Stat input file */
  if ( stat ( filename, &st ) < 0 )
    {
      snprintf ( b->error, sizeof ( b->error ), "%s(): cannot stat file '%s'\n", __func__, filename );
      return 1;
    }
 
  /* Alloc nedeed memory for bufr */
  if ( S_ISREG ( st.st_mode ) || S_ISLNK ( st.st_mode ) )
    {
      if ( ( bufrx = ( uint8_t * ) calloc ( 1, st.st_size + 4 ) ) == NULL )
        {
          snprintf ( b->error, sizeof ( b->error ), "%s(): cannot alloc memory for file '%s'\n", __func__, filename );
          return 1;
        }
    }
  else
    {
      snprintf ( b->error, sizeof ( b->error ), "%s(): '%s' is not a regular file nor symbolic link\n", __func__, filename );
      return 1;
    }
 
  /* Inits bufr struct */
  if ( ( st.st_size + 4 ) >= BUFR_LEN )
    {
      snprintf ( b->error, sizeof ( b->error ), "%s(): File '%s' too large. Consider increase BUFR_LEN\n", __func__, filename );
      free ( ( void * ) bufrx );
      return 1;
    }
 
  // Open and read the file
  if ( ( fp = fopen ( filename, "r" ) ) == NULL )
    {
      snprintf ( b->error, sizeof ( b->error ), "%s(): cannot open file '%s'\n", __func__, filename );
      free ( ( void * ) bufrx );
      return 1;
    }
 
  beg = end = st.st_size;
  while ( ( aux = fgetc ( fp ) ) != EOF && ( int ) n < st.st_size )
    {
      bufrx[n++] = ( uint8_t ) aux;
 
      // check if first 'BUFR' item has been found
      if ( n >= 4 &&
           bufrx[n - 4] == 'B' &&
           bufrx[n - 3] == 'U' &&
           bufrx[n - 2] == 'F' &&
           bufrx[n - 1] == 'R' )
        {
          beg = n - 4;
          pbeg = &bufrx[ n - 4];
        }
 
      // check if first '7777' has been found after first 'BUFR'
      if ( n > 4 &&
           beg < ( ( size_t ) st.st_size - 4 ) &&
           bufrx[n - 4] == '7' &&
           bufrx[n - 3] == '7' &&
           bufrx[n - 2] == '7' &&
           bufrx[n - 1] == '7' )
        {
          end = n - 1;
          size = end - beg + 1;
        }
    }
 
 
  // close the file
  fclose ( fp );
 
  if ( size < 8 )
    {
      snprintf ( b->error, sizeof ( b->error ), "%s(): not found a '7777' item after 'BUFR'\n", __func__ );
      return 1;
    }
  res = bufrdeco_read_buffer ( b, pbeg, size );
  free ( bufrx );
  return res;
}

References BUFR_LEN, bufrdeco_assert, bufrdeco_read_buffer(), and bufrdeco::error.

Referenced by bufrdeco_get_bufr(), and main().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_fprint_subset_sequence_data()

int bufrdeco_fprint_subset_sequence_data	(	FILE *	f,
		struct bufrdeco_subset_sequence_data *	s
	)

Definition at line 520 of file bufrdeco_print.c.

{
  size_t i;
  char aux[1024];
 
  bufrdeco_assert ( f != NULL && s != NULL);
 
  for ( i = 0; i < s->nd ; i++ )
    {
      if ( i && s->sequence[i].seq != s->sequence[i - 1].seq )
        fprintf ( f, "\n" );
 
      fprintf ( f, "%5lu:  %s\n", i, bufrdeco_print_atom_data ( aux, sizeof ( aux ), &s->sequence[i] ) );
    }
  return 0;
 
}

References bufrdeco_assert, bufrdeco_print_atom_data(), bufrdeco_subset_sequence_data::nd, bufr_atom_data::seq, and bufrdeco_subset_sequence_data::sequence.

Referenced by bufrdeco_print_subset_sequence_data().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_fprint_subset_sequence_data_html()

int bufrdeco_fprint_subset_sequence_data_html	(	FILE *	f,
		struct bufrdeco_subset_sequence_data *	s
	)

Definition at line 241 of file bufrdeco_print_html.c.

{
  size_t i;
  char aux[1024];
 
  bufrdeco_assert ( f != NULL && s != NULL );  
 
  fprintf ( f, "<div class='bufr_subset'>\n" );
  fprintf ( f, "<table>\n" );
  for ( i = 0; i < s->nd ; i++ )
    {
      fprintf ( f, "<tr><td>%5lu:</td>%s</tr>\n", i, bufrdeco_print_atom_data_html ( aux, sizeof (aux), &s->sequence[i], s->ss ) );
    }
  fprintf ( f, "</table>\n" );
  fprintf ( f, "</div>\n" );
  return 0;
}

References bufrdeco_assert, bufrdeco_print_atom_data_html(), bufrdeco_subset_sequence_data::nd, bufrdeco_subset_sequence_data::sequence, and bufrdeco_subset_sequence_data::ss.

Referenced by bufrdeco_print_subset_sequence_data_html().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_fprint_subset_sequence_data_tagged_html()

int bufrdeco_fprint_subset_sequence_data_tagged_html	(	FILE *	f,
		struct bufrdeco_subset_sequence_data *	s,
		char *	id
	)

Definition at line 279 of file bufrdeco_print_html.c.

{
  size_t i;
  char aux[1024];
  
  bufrdeco_assert ( f != NULL && s != NULL && id != NULL );  
 
  fprintf ( f, "\n<div class='bufr_subset' id='%s'>\n", id );
  fprintf ( f, "<table>\n" );
  fprintf ( f, "<caption>%s</caption>\n", id );
  fprintf ( f, "<tr><th></th><th>Descriptor</th><th>Name</th><th>Unit</th><th>Value</th><th>Description</th></tr>\n" );
  for ( i = 0; i < s->nd ; i++ )
    {
      fprintf ( f, "<tr><td class='ndesc' id='d_%u_%lu' >#%lu</td>%s</tr>\n", s->ss, i, i, bufrdeco_print_atom_data_html ( aux, sizeof (aux), &s->sequence[i], s->ss ) );
    }
  fprintf ( f, "</table>\n" );
  fprintf ( f, "</div>\n" );
  return 0;
}

References bufrdeco_assert, bufrdeco_print_atom_data_html(), bufrdeco_subset_sequence_data::nd, bufrdeco_subset_sequence_data::sequence, and bufrdeco_subset_sequence_data::ss.

Referenced by bufrdeco_print_subset_sequence_data_tagged_html().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_fprint_tree()

int bufrdeco_fprint_tree	(	FILE *	f,
		struct bufrdeco *	b
	)

Print a tree of descriptors.

Parameters

f	Pointer to file opened by caller
b	pointer to a basic container struct bufrdeco

Returns

If succeeded return 0

Definition at line 360 of file bufrdeco_print.c.

{
  bufrdeco_assert ( f != NULL && b != NULL );
 
  if ( b->mask & BUFRDECO_OUTPUT_HTML )
    fprintf ( f, "<pre>\n" );
  bufrdeco_fprint_tree_recursive ( f, b, NULL );
  if ( b->mask & BUFRDECO_OUTPUT_HTML )
    fprintf ( f, "</pre>\n" );
  else
    fprintf ( f, "\n" );
  return 0;
};

References bufrdeco_assert, bufrdeco_fprint_tree_recursive(), BUFRDECO_OUTPUT_HTML, and bufrdeco::mask.

Here is the call graph for this function:

bufrdeco_free_bitmap_array()

int bufrdeco_free_bitmap_array

(

struct bufrdeco_bitmap_array *

a

)

Free an allocated bitmap array.

Parameters

a	pointer to target struct bufrdeco_bitmap_array to free

Returns

If succeeded return 0, otherwise 1

Definition at line 331 of file bufrdeco_memory.c.

{
  buf_t i;
 
  bufrdeco_assert ( a != NULL );
  
  for ( i = 0; i < a->nba ; i++ )
    {
      if ( a->bmap[i] == NULL )
        continue;
 
      free ( ( void* ) a->bmap[i] );
      a->bmap[i] = NULL;
    }
  a->nba = 0;
  return 0;
}

References bufrdeco_bitmap_array::bmap, bufrdeco_assert, and bufrdeco_bitmap_array::nba.

Referenced by bufrdeco_close(), and bufrdeco_reset().

Here is the caller graph for this function:

bufrdeco_free_cache_tables()

int bufrdeco_free_cache_tables

(

struct bufr_tables_cache *

c

)

deallocate and clean a bufr_tables_cache

Parameters

c	pointer to the struct to clean

Returns

0 if success

Definition at line 322 of file bufrdeco_wmo.c.

{
  buf_t  i;
 
  for ( i = 0; i < BUFRDECO_TABLES_CACHE_SIZE; i++ )
    {
      if ( c->tab[i] )
        {
          free ( ( void * ) c->tab[i] );
        }
    }
  // then clean
  memset ( c, 0, sizeof ( struct bufr_tables_cache ) );
  return 0;
}

References BUFRDECO_TABLES_CACHE_SIZE, and bufr_tables_cache::tab.

Referenced by bufrdeco_close().

Here is the caller graph for this function:

bufrdeco_free_compressed_data_references()

int bufrdeco_free_compressed_data_references

(

struct bufrdeco_compressed_data_references *

rf

)

Free the memory allocated for array of references in a struct bufrdeco_compressed_data_references.

Parameters

rf	pointer to the target struct bufrdeco_compressed_data_references to free

Returns

If succeeded return 0, otherwise 1

Definition at line 250 of file bufrdeco_memory.c.

{
  bufrdeco_assert ( rf != NULL );
  
  if ( rf->refs != NULL )
    {
      free ( ( void * ) rf->refs );
      rf->refs = NULL;
    }
  return 0;
}

References bufrdeco_assert, and bufrdeco_compressed_data_references::refs.

Referenced by bufrdeco_close(), and bufrdeco_reset().

Here is the caller graph for this function:

bufrdeco_free_expanded_tree()

int bufrdeco_free_expanded_tree

(

struct bufrdeco_expanded_tree **

t

)

Frees the allocated space for a struct bufrdeco_expanded_tree.

Parameters

t	pointer to the target pointer to struct bufrdeco_expanded_tree

Returns

0 and *t is set to NULL

Definition at line 89 of file bufrdeco_memory.c.

{
  bufrdeco_assert ( t != NULL );
 
  if ( *t != NULL )
    {
      free ( ( void * ) *t );
      *t = NULL;
    }
  return 0;
}

References bufrdeco_assert.

Referenced by bufrdeco_close(), and bufrdeco_reset().

Here is the caller graph for this function:

bufrdeco_free_subset_sequence_data()

int bufrdeco_free_subset_sequence_data

(

struct bufrdeco_subset_sequence_data *

ba

)

Free the memory for sequence array in a struct bufrdeco_subset_sequence_data.

Parameters

ba	pointer to the target struct to free

Returns

0 if succeeded

Definition at line 183 of file bufrdeco_memory.c.

{
  bufrdeco_assert ( ba != NULL );
  
  if ( ba->sequence != NULL )
    {
      free ( ( void * ) ba->sequence );
      ba->sequence = NULL;
    }
  return 0;
}

References bufrdeco_assert, and bufrdeco_subset_sequence_data::sequence.

Referenced by bufrdeco_close(), and bufrdeco_reset().

Here is the caller graph for this function:

bufrdeco_free_tables()

int bufrdeco_free_tables

(

struct bufr_tables **

t

)

Frees the allocated space for a struct bufr_tables.

Parameters

t	pointer to the target pointer to struct bufr_tables

Returns

0 and *t is set to NULL

Definition at line 51 of file bufrdeco_memory.c.

{
  bufrdeco_assert ( t != NULL );
 
  if ( *t != NULL )
    {
      free ( ( void * ) *t );
      *t = NULL;
    }
  return 0;
}

References bufrdeco_assert.

Referenced by bufrdeco_close().

Here is the caller graph for this function:

bufrdeco_get_atom_data_from_compressed_data_ref()

int bufrdeco_get_atom_data_from_compressed_data_ref	(	struct bufr_atom_data *	a,
		struct bufrdeco_compressed_ref *	r,
		buf_t	subset,
		struct bufrdeco *	b
	)

Get atom data from a descriptor for a given subset.

Parameters

a	pointer to the target struct bufr_atom_data where to set the results
r	pointer to the struct bufrdeco_compressed_ref with the info to know how and where get the data
subset	index for solicited subset. First subset has index 0
b	basic container struct bufrdeco

Returns

Returns 0 if succeeded, 1 otherwise

Definition at line 742 of file bufrdeco_compressed.c.

{
  buf_t i, bit_offset;
  uint8_t has_data;
  uint32_t ival, ival0;
  int32_t ivals;
  struct bufr_tableB *tb;
 
  if ( b == NULL )
    return 1;
 
  if ( a == NULL || r == NULL )
    {
      snprintf ( b->error, sizeof ( b->error ), "%s(): Unspected NULL argument(s)\n", __func__ );
      return 1;
    }
 
  if ( is_a_local_descriptor ( r->desc ) )
    {
      a->mask = DESCRIPTOR_IS_LOCAL;
      memcpy ( & ( a->desc ), r->desc, sizeof ( struct bufr_descriptor ) );
      strcpy ( a->name, "LOCAL DESCRIPTOR" );
      strcpy ( a->unit, "UNKNOWN" );
      if ( r->inc_bits )
        {
          bit_offset = r->bit0 + r->bits + 6 + r->inc_bits * subset;
          // extract inc_bits data
          if ( get_bits_as_uint32_t ( &ival, &has_data, &b->sec4.raw[4], & bit_offset, r->inc_bits ) == 0 )
            {
              snprintf ( b->error, sizeof ( b->error ), "%s(): Cannot get associated bits from '%s'\n", __func__, r->desc->c );
              return 1;
            }
          a->val = ival + r->ref0;
        }
      else
        a->val = r->ref0;
      return 0;
    }
 
  // some utils pointers
  tb = & ( b->tables->b );
  i = tb->x_start[r->desc->x] + tb->y_ref[r->desc->x][r->desc->y];
 
  a->mask = 0;
 
  // descriptor
  memcpy ( & ( a->desc ), r->desc, sizeof ( struct bufr_descriptor ) );
  // name
  //strcpy_safe ( a->name, r->name );
  strcpy ( a->name, r->name );
  //unit
  //strcpy_safe ( a->unit, r->unit );
  strcpy ( a->unit, r->unit );
  //scale
  a->escale = r->escale;
 
  // possible bitmaps
  if ( r->is_bitmaped_by )
    {
      a->is_bitmaped_by = r->is_bitmaped_by;
    }
 
  if ( r->bitmap_to )
    {
      a->bitmap_to = r->bitmap_to;
    }
 
  // Possible quality
  if ( r->related_to )
    {
      a->related_to = r->related_to;
    }
 
 
  // First we check about string fields
  if ( strstr ( a->unit, "CCITT" ) != NULL )
    {
      if ( r->has_data == 0 )
        {
          a->mask |= DESCRIPTOR_VALUE_MISSING;
          return 0;
        }
 
      if ( r->inc_bits == 0 )
        {
          // case of all data same, so copy the local ref
          strcpy ( a->cval, r->cref0 );
          a->mask |= DESCRIPTOR_HAVE_STRING_VALUE;
        }
      else
        {
          // we have to extract chars from section data
          // compute the bit_offset
          bit_offset = r->bit0 + r->bits + 6 + r->inc_bits * 8 * subset;
          if ( get_bits_as_char_array ( a->cval, &has_data, &b->sec4.raw[4], & bit_offset, r->inc_bits * 8 ) == 0 )
            {
              snprintf ( b->error, sizeof ( b->error ), "%s(): Cannot get uchars from '%s'\n", __func__, r->desc->c );
              return 1;
            }
          if ( has_data == 0 )
            {
              a->mask |= DESCRIPTOR_VALUE_MISSING;
            }
          else
            {
              a->mask |= DESCRIPTOR_HAVE_STRING_VALUE;
            }
        }
      return 0;
    }
 
  // now we check for associated data
  if ( r->is_associated )
    {
      strcpy ( a->name, "Associated value" );
      strcpy ( a->unit, "Associated unit" );
      if ( r->has_data == 0 )
        {
          a->associated = MISSING_INTEGER;
        }
      else
        {
          if ( r->inc_bits == 0 )
            {
              // case of all data same, so copy the local ref
              a->associated = r->ref0;
            }
          else
            {
              // compute the bit_offset
              bit_offset = r->bit0 + r->bits + 6 + r->inc_bits * subset;
              // extract inc_bits data
              if ( get_bits_as_uint32_t ( &ival, &has_data, &b->sec4.raw[4], & bit_offset, r->inc_bits ) == 0 )
                {
                  snprintf ( b->error, sizeof ( b->error ), "%s(): Cannot get associated bits from '%s'\n", __func__, r->desc->c );
                  return 1;
                }
              // finally get the associated data
              if ( has_data )
                {
                  a->associated = r->ref + ( int32_t ) ( r->ref0 +  ival );
                }
              else
                {
                  a->associated = MISSING_INTEGER;
                }
            }
        }
      return 0;
    }
 
  // numeric data
  if ( r->has_data == 0 ||
       r->inc_bits > r->bits ) // Here we assume no more inc_bits than bits in reference value?
    {
      a->val = MISSING_REAL;
      a->mask |= DESCRIPTOR_VALUE_MISSING;
      return 0;
    }
 
  if ( r->inc_bits == 0 )
    {
      ivals = r->ref + ( int32_t ) r->ref0;
    }
  else
    {
      // read inc_bits data
      // compute the bit_offset
      bit_offset = r->bit0 + r->bits + 6 + r->inc_bits * subset;
      // extract inc_bits data
      if ( get_bits_as_uint32_t ( &ival0, &has_data, &b->sec4.raw[4], & bit_offset, r->inc_bits ) == 0 )
        {
          snprintf ( b->error, sizeof ( b->error ), "%s(): Cannot get %d inc_bits from '%s'\n", __func__, r->inc_bits, r->desc->c );
          return 1;
        }
 
      if ( has_data )
        {
          ivals = r->ref + ( int32_t ) ( r->ref0 + ival0 );
        }
      else
        {
          a->val = MISSING_REAL;
          a->mask |= DESCRIPTOR_VALUE_MISSING;
          return 0;
        }
    }
 
  // Get a numeric number
  a->val = ( double ) ( ivals ) * exp10 ( ( double ) ( - r->escale ) );
 
  if ( strstr ( a->unit, "CODE TABLE" ) == a->unit  || strstr ( a->unit, "Code table" ) == a->unit )
    {
      ival = ( uint32_t ) ( a->val + 0.5 );
      a->mask |= DESCRIPTOR_IS_CODE_TABLE;
      if ( bufrdeco_explained_table_val ( a->ctable, 256, & ( b->tables->c ), & ( tb->item[i].tableC_ref ), & ( a->desc ), ival ) != NULL )
        {
          a->mask |= DESCRIPTOR_HAVE_CODE_TABLE_STRING;
        }
    }
  else if ( strstr ( a->unit,"FLAG" ) == a->unit || strstr ( a->unit,"Flag" ) == a->unit )
    {
      ival = ( uint32_t ) ( a->val + 0.5 );
      a->mask |= DESCRIPTOR_IS_FLAG_TABLE;
 
      if ( bufrdeco_explained_flag_val ( a->ctable, 256, & ( b->tables->c ), & ( a->desc ), ival, r->bits ) != NULL )
        {
          a->mask |= DESCRIPTOR_HAVE_FLAG_TABLE_STRING;
        }
    }
 
  return 0;
}

References bufr_atom_data::associated, bufr_tables::b, bufrdeco_compressed_ref::bit0, bufr_atom_data::bitmap_to, bufrdeco_compressed_ref::bitmap_to, bufrdeco_compressed_ref::bits, bufrdeco_explained_flag_val(), bufrdeco_explained_table_val(), bufr_descriptor::c, bufr_tables::c, bufrdeco_compressed_ref::cref0, bufr_atom_data::ctable, bufr_atom_data::cval, bufr_atom_data::desc, bufrdeco_compressed_ref::desc, DESCRIPTOR_HAVE_CODE_TABLE_STRING, DESCRIPTOR_HAVE_FLAG_TABLE_STRING, DESCRIPTOR_HAVE_STRING_VALUE, DESCRIPTOR_IS_CODE_TABLE, DESCRIPTOR_IS_FLAG_TABLE, DESCRIPTOR_IS_LOCAL, DESCRIPTOR_VALUE_MISSING, bufrdeco::error, bufr_atom_data::escale, bufrdeco_compressed_ref::escale, get_bits_as_char_array(), get_bits_as_uint32_t(), bufrdeco_compressed_ref::has_data, bufrdeco_compressed_ref::inc_bits, is_a_local_descriptor(), bufrdeco_compressed_ref::is_associated, bufr_atom_data::is_bitmaped_by, bufrdeco_compressed_ref::is_bitmaped_by, bufr_tableB::item, bufr_atom_data::mask, MISSING_INTEGER, MISSING_REAL, bufr_atom_data::name, bufrdeco_compressed_ref::name, bufr_sec4::raw, bufrdeco_compressed_ref::ref, bufrdeco_compressed_ref::ref0, bufr_atom_data::related_to, bufrdeco_compressed_ref::related_to, bufrdeco::sec4, bufr_tableB_decoded_item::tableC_ref, bufrdeco::tables, bufr_atom_data::unit, bufrdeco_compressed_ref::unit, bufr_atom_data::val, bufr_descriptor::x, bufr_tableB::x_start, bufr_descriptor::y, and bufr_tableB::y_ref.

Referenced by bufr_decode_subset_data_compressed().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_get_bufr()

int bufrdeco_get_bufr	(	struct bufrdeco *	b,
		char *	filename
	)

Read file and try to find a bufr report inserted in. Once found do the same that bufrdeco_read_bufr()

Parameters

b	pointer to struct bufrdeco
filename	complete path of BUFR file

Returns

Returns 0 if all is OK, 1 otherwise

This function does the folowing tasks:

• Try to find first buffer of bytes begining with 'BUFR' chars and ending with '7777'. This will be considered as a bufr file.
• Read the file and checks the marks at the begining and end to see wheter is a BUFR file
• Init the structs and allocate the needed memory for raw data if not done previously
• Splits and parse the BUFR sections (without expanding descriptors nor parsing data)
• Reads the needed Table files and store them in memory.

Definition at line 315 of file bufrdeco.c.

{
  bufrdeco_assert_with_return_val ( b != NULL || filename == NULL, 1 );
 
  return bufrdeco_extract_bufr ( b, filename );
}

References bufrdeco_assert_with_return_val, and bufrdeco_extract_bufr().

Here is the call graph for this function:

bufrdeco_get_f2_descriptor_explanation()

char * bufrdeco_get_f2_descriptor_explanation	(	char *	e,
		size_t	dim,
		struct bufr_descriptor *	d
	)

Definition at line 773 of file bufrdeco_f2.c.

{
  // check the input
  bufrdeco_assert ( e != NULL && d != NULL && d->f == 2 )
 
  switch ( d->x )
    {
    case 1:
      if (d->y)
        snprintf ( e, dim, "Change data width %d bits.", d->y - 128 );
      else
        snprintf ( e, dim, "Change data width 0 bits.");
      break;
 
    case 2:
      if (d->y)
        snprintf ( e, dim, "Change scale %d units.", d->y - 128 );
      else
        snprintf ( e, dim, "Change scale 0 units.");
      break;
 
    case 3:
      if ( d->y != 255 )
        snprintf ( e, dim, "Change reference values. Each new reference value has %d bits width.", d->y );
      else
        snprintf ( e, dim, "Change reference values concluded." );
      break;
 
    case 4:
      snprintf ( e, dim,"Add associated field. Precede each data element with %d bits of information.", d->y );
      break;
 
    case 5:
      snprintf ( e, dim, "Signify character. %d characters CCITT IA5 are inserted as a data field of %d x 8 bits in length.", d->y, d->y );
      break;
 
    case 6:
      snprintf ( e, dim, "Signify data width. %d bits of data are described by immediately following descsriptor", d->y );
      break;
 
    case 7:
      snprintf ( e, dim, "Increase scale, reference value and data width." );
      break;
 
    case 8:
      snprintf ( e, dim, "Change width of CCITT IA5 field to %d characters instead of the indicated in table B", d->y );
      break;
 
    case 21:
      snprintf ( e, dim, "**** Next %d descriptor(s) on this sequence level do not have data present ****", d->y );
      break;
 
    case 22:
      snprintf ( e, dim, "Quality information follows. The values of Class 33 elements which follow relate to the data defined by the data present bit-map." );
      break;
 
    case 23:
      if ( d->y == 0 )
        snprintf ( e, dim, "Substituted values operator. The substituted values which follow relate to the data defined by the data present bit-map." );
      else if ( d->y == 255 )
        snprintf ( e, dim, "Substituted values marker operator. This operator shall signify a data item containing a substituted value." );
      break;
 
    case 24:
      if ( d->y == 0 )
        snprintf ( e, dim, "First-order statistical values follow." );
      else if ( d->y == 255 )
        snprintf ( e, dim, "First-order statistical values marker operator" );
      break;
 
    case 25:
      if ( d->y == 0 )
        snprintf ( e, dim,"Replaced/retained values follow." );
      else if ( d->y == 255 )
        snprintf ( e, dim, "Replaced/retained value marker operator" );
      break;
 
    case 32:
      if ( d->y == 0 )
        snprintf ( e, dim, "Difference statistical values follow." );
      else if ( d->y == 255 )
        snprintf ( e, dim, "Difference statistical values marker operator" );
      break;
 
    case 35:
      snprintf ( e, dim, "Cancel backward data reference" );
      break;
 
    case 36:
      snprintf ( e, dim, "Define data present bit-map" );
      break;
 
    case 37:
      snprintf ( e, dim, " Use defined data present bit-map" );
      break;
 
    case 41:
      if ( d->y == 0 )
        snprintf ( e, dim, "@@@@ Event definition begins in next descriptor of this sequence level @@@@" );
      else
        snprintf ( e, dim, "@@@@ Event definition ends here @@@@" );
      break;
 
    case 42:
      if ( d->y == 0 )
        snprintf ( e, dim, "!!!! Conditioning event definition begins in next descriptor of this sequence level !!!!" );
      else
        snprintf ( e, dim, "!!!! Conditioning event definition ends here !!!!" );
      break;
 
    case 43:
      if ( d->y == 0 )
        snprintf ( e, dim, "&&&& Categorical forecast follow in next descriptor of this sequence level &&&&" );
      else
        snprintf ( e, dim, "&&&& Categorical forecast ends here &&&&" );
      break;
 
    default:
      e[0] = 0; // void string
      break;
    }
 
  return e;
}

References bufrdeco_assert, bufr_descriptor::f, bufr_descriptor::x, and bufr_descriptor::y.

Referenced by bufrdeco_fprint_tree_recursive(), bufrdeco_print_json_object_operator_descriptor(), and bufrdeco_print_json_tree_recursive().

Here is the caller graph for this function:

bufrdeco_get_subset_sequence_data()

struct bufrdeco_subset_sequence_data * bufrdeco_get_subset_sequence_data

(

struct bufrdeco *

b

)

Parse and get a struct bufrdeco_subset_sequence_data.

Parameters

b	basic container struct bufrdeco

Returns

If succeeded returns a pointer to the struct bufrdeco_subset_sequence_data with the results for a subset, otherwise returns NULL

Note that if succeeded the counter to current subset index is increased. Remember that in case of non compressed data we must to decode all previous subsets to get the desired one. In case of compressed we can access directly to a the desired subset

Definition at line 39 of file bufrdeco_data.c.

{
  bufrdeco_assert ( b != NULL );
 
  if ( bufrdeco_decode_data_subset ( b ) )
    {
      return NULL;
    }
  return & ( b->seq );
}

References bufrdeco_assert, bufrdeco_decode_data_subset(), and bufrdeco::seq.

Referenced by bufrdeco_get_target_subset_sequence_data().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_get_target_subset_sequence_data()

struct bufrdeco_subset_sequence_data * bufrdeco_get_target_subset_sequence_data	(	buf_t	nset,
		struct bufrdeco *	b
	)

Prepare the struct bufrdeco to get data from the solicited subset.

Parameters

nset	index of subset we want to parse and get data. First subset in a BUFR file has index 0.
b	pointer to the struct bufrdeco

Returns

If succeeded returns a pointer to the struct bufrdeco_subset_sequence_data with the results for the desired subset, otherwise returns NULL

Definition at line 396 of file bufrdeco.c.

{
  buf_t n = 0;
  bufrdeco_assert ( b != NULL );
  uint32_t mask0 = b->mask;
  
  if ( b->sec3.subsets <= nset )
    {
      snprintf ( b->error, sizeof ( b->error ), "%s(): The index of target subset is over the bufr subsets (%d)\n", __func__, b->sec3.subsets );
      return NULL;
    }
 
  if ( b->sec3.compressed )
    {
#ifdef __DEBUG
      printf ("# Compressed\n");
#endif      
      // case of compressed, we just need the compressed references
      if ( b->refs.nd == 0 )
        {
          // case of compressed data and still not parsed the refs
          if ( bufrdeco_parse_compressed ( & ( b->refs ), b ) )
            {
              return NULL;
            }
 
        }
    }
  else if ( nset > 0 )
    {
      // In case of not compressed bufr, to parse a subset we need to know the bit offset of the subset data in sec4
      // There are only two ways to know that offset:
      //    1) Parse the data of all prior subsets from n = 0 to (nset - 1).
      //    2) Get the subset bit offset from the struct bufrdeco_subset_bit_offset already stored.
      //       This is only possible if we already parsed this subset in this session (among two bufrdeco_reset() calls)
      //       or if readed the struct from a file
      // In any case the subset bit offset array must be poluted for all n < (nset - 1)
 
      // clear bit BUFRDECO_OUTPUT_JSON_SUBSET_DATA if actived
      b->mask &= ~((uint32_t) BUFRDECO_OUTPUT_JSON_SUBSET_DATA);
 
      if ( b->offsets.nr == 0 || b->offsets.ofs[nset] == 0 )
        {
          for ( n = b->state.subset ; n < nset ; n++ )
            {
              // In every call to bufrdeco_decode_data_subset(), b->state.subset is incremented and b->offsets is updated if needed
#ifdef __DEBUG
              printf ("# Go to parse for subset %lu waiting %lu\n", b->state.subset, nset);
#endif              
              bufrdeco_decode_data_subset ( b );
            }
        }
    }
  // Once the previous task is made, we just adjust the subset
  b->state.subset = nset;
  b->mask = mask0;
  
  // and now parse and get the desired subset data
#ifdef __DEBUG  
  printf ("# Finally going to target parse for subset %lu\n", b->state.subset);
#endif  
  return bufrdeco_get_subset_sequence_data ( b );
}

References bufrdeco_assert, bufrdeco_decode_data_subset(), bufrdeco_get_subset_sequence_data(), BUFRDECO_OUTPUT_JSON_SUBSET_DATA, bufrdeco_parse_compressed(), bufr_sec3::compressed, bufrdeco::error, bufrdeco::mask, bufrdeco_compressed_data_references::nd, bufrdeco_subset_bit_offsets::nr, bufrdeco::offsets, bufrdeco_subset_bit_offsets::ofs, bufrdeco::refs, bufrdeco::sec3, bufrdeco::state, bufrdeco_decoding_data_state::subset, and bufr_sec3::subsets.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_get_version()

char * bufrdeco_get_version	(	char *	version,
		size_t	dversion,
		char *	build,
		size_t	dbuild,
		char *	builder,
		size_t	dbuilder,
		int *	version_major,
		int *	version_minor,
		int *	version_patch
	)

Definition at line 50 of file bufrdeco.c.

{
  int major = 0, minor = 0, patch = 0;
  size_t used;
 
  // Check argument
  if ( version == NULL )
    return NULL;
 
  snprintf ( version, dversion, "%s", VERSION );
  // default
  sscanf ( version, "%d.%d.%d", &major, &minor, &patch );
 
  if ( build )
    {
      used = 0;
#if defined(__INTEL_COMPILER)
      used += snprintf ( build + used, dbuild - used, "using INTEL C compiler icc %d.%d ", __INTEL_COMPILER, __INTEL_COMPILER_UPDATE );
#elif defined(__clang_version__)
      used += snprintf ( build + used, dbuild - used, "using clang C compiler ", __clang_version__ );
#elif defined(__GNUC__)
      used += snprintf ( build + used, dbuild - used, "using GNU C compiler gcc %d.%d.%d ", __GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__ );
#elif defined(_MSC_VER)
      used += snprintf ( build + used, dbuild - used, "using MICROSOFT C compiler %d ", _MSC_VER );
#else
      used += snprintf ( build + used, dbuild - used, "using an unknown C compiler " );
#endif
      snprintf ( build + used, dbuild - used,"at %s %s",__DATE__,__TIME__ );
    }
 
  if ( builder )
#ifdef BUILD_USING_CMAKE
    strncpy_safe ( builder, "cmake", dbuilder );
#else
    strncpy_safe ( builder, "autotools", dbuilder );
#endif
  if ( version_major )
    *version_major = major;
  if ( version_minor )
    *version_minor = minor;
  if ( version_patch )
    *version_patch = patch;
  return version;
}

References strncpy_safe, and VERSION.

Referenced by bufrtotac_print_version().

Here is the caller graph for this function:

bufrdeco_increase_compressed_data_references_count()

int bufrdeco_increase_compressed_data_references_count	(	struct bufrdeco_compressed_data_references *	r,
		struct bufrdeco *	b
	)

Increment the count of a struct bufrdeco_compressed_data_references.

Parameters

r	pointer to the target struct
b	pointer to the current active struct bufrdeco

Returns

0 if succeeded, 1 otherwise

Definition at line 1089 of file bufrdeco_compressed.c.

{
  if ( r->nd < ( BUFR_NMAXSEQ - 1 ) )
    {
      r->nd += 1;
    }
  else
    {
      snprintf ( b->error, sizeof ( b->error ), "%s(): Reached limit. Consider increas BUFR_NMAXSEQ\n", __func__ );
      return 1;
    }
  return 0;
}

References BUFR_NMAXSEQ, bufrdeco::error, and bufrdeco_compressed_data_references::nd.

Referenced by bufrdeco_decode_replicated_subsequence_compressed(), and bufrdeco_parse_compressed_recursive().

Here is the caller graph for this function:

bufrdeco_increase_data_array()

int bufrdeco_increase_data_array

(

struct bufrdeco_subset_sequence_data *

d

)

doubles the allocated space for a struct bufrdeco_subset_sequence_data whenever is posible

Parameters

d	pointer to source struct bufrdeco_subset_sequence_data

Returns

0 when success, otherwise return 1 and the struct is unmodified

The amount of data in a bufr must be huge. In a first moment, the dimension of a sequence of structs bufr_atom_data is BUFR_NMAXSEQ but may be increased. This function task is try to double the allocated dimension and reallocate it.

Definition at line 139 of file bufrdeco_data.c.

{
  bufrdeco_assert ( d != NULL );
 
  if ( d->dim < ( BUFR_NMAXSEQ * 8 ) ) // check if reached the limit
    {
      if ( ( d->sequence = ( struct bufr_atom_data * ) realloc ( ( void * ) d->sequence,
                           d->dim * 2 * sizeof ( struct bufr_atom_data ) ) ) == NULL )
        {
          return 1;
        }
      else
        {
          d->dim *= 2;
          return 0;
        }
    }
  else
    {
      return 1;
    }
}

References BUFR_NMAXSEQ, bufrdeco_assert, bufrdeco_subset_sequence_data::dim, and bufrdeco_subset_sequence_data::sequence.

Referenced by bufr_decode_subset_data_compressed(), bufrdeco_decode_replicated_subsequence(), bufrdeco_decode_subset_data_recursive(), and bufrdeco_parse_f2_descriptor().

Here is the caller graph for this function:

bufrdeco_init()

int bufrdeco_init

(

struct bufrdeco *

b

)

Inits and allocate memory for a struct bufrdeco.

Parameters

b	pointer to the target struct

This function only must be called once. When finished the function bufrdeco_close must be called to free all needed memory

Returns

If succeeded return 0, otherwise 1

Definition at line 138 of file bufrdeco.c.

{
  bufrdeco_assert ( b != NULL );
 
  // First clear all
  memset ( b, 0, sizeof ( struct bufrdeco ) );
 
  // Then allocate all needed memory when starting. Further we will need to allocate some more depending on
  // data
 
  // allocate memory for Tables
  if ( bufrdeco_init_tables ( &b->tables ) )
    {
      snprintf ( b->error, sizeof ( b->error ),"%s(): Cannot allocate space for tables\n", __func__ );
      return 1;
    }
 
  // Output default streams
  b->out = stdout;
  b->err = stderr;
    
  // allocate memory for expanded tree of descriptors
  if ( bufrdeco_init_expanded_tree ( &b->tree ) )
    {
      snprintf ( b->error, sizeof ( b->error ),"%s(): Cannot allocate space for expanded tree of descriptors\n", __func__ );
      return 1;
    }
 
 
  return 0;
}

References bufrdeco_assert, bufrdeco_init_expanded_tree(), bufrdeco_init_tables(), bufrdeco::err, bufrdeco::error, bufrdeco::out, bufrdeco::tables, and bufrdeco::tree.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_init_compressed_data_references()

int bufrdeco_init_compressed_data_references

(

struct bufrdeco_compressed_data_references *

rf

)

Init a struct bufrdeco_compressed_data_references.

Parameters

rf	pointer ti the target struct

Returns

0 if succeded, otherwise 1

If already memory is allocated for array of references then just adjust the used index to zero. Otherwise it allocate the needed memory and init the struct

Definition at line 205 of file bufrdeco_memory.c.

{
  bufrdeco_assert ( rf != NULL );
  
  if ( rf->refs != NULL && rf->dim != 0 )
    {
      rf->nd = 0; // Here we set the used elements to 0 of dim
    }
  else if ( rf->refs == NULL )
    {
      // Here memory is still not allocated. Proceed to allocate with BUFR_NMAXSEQ
      if ( ( rf->refs = ( struct bufrdeco_compressed_ref * ) calloc ( 1, BUFR_NMAXSEQ * sizeof ( struct bufrdeco_compressed_ref ) ) ) == NULL )
        {
          fprintf ( stderr,"%s(): Cannot allocate memory for bufrdeco_compressed_ref array\n", __func__ );
          return 1;
        }
      rf->nd = 0; // Set de used elements (bufrdeco_compressed_ref)
      rf->dim = BUFR_NMAXSEQ; // Set de allocated bufr_compressed_rer elements
    }
  return 0;
}

References BUFR_NMAXSEQ, bufrdeco_assert, bufrdeco_compressed_data_references::dim, bufrdeco_compressed_data_references::nd, and bufrdeco_compressed_data_references::refs.

Referenced by bufrdeco_clean_compressed_data_references(), and bufrdeco_parse_compressed().

Here is the caller graph for this function:

bufrdeco_init_expanded_tree()

int bufrdeco_init_expanded_tree

(

struct bufrdeco_expanded_tree **

t

)

Init a struct bufrdeco_expanded_tree allocating space.

Parameters

t	pointer to the target pointer to struct bufrdeco_expanded_tree

Returns

0 if succeeded, 1 otherwise

Definition at line 70 of file bufrdeco_memory.c.

{
  bufrdeco_assert ( t != NULL );
 
  if ( *t != NULL )
    free ( ( void * ) *t );
 
  if ( ( *t = ( struct bufrdeco_expanded_tree * ) calloc ( 1, sizeof ( struct bufrdeco_expanded_tree ) ) ) == NULL )
    return 1;
  return 0;
}

References bufrdeco_assert.

Referenced by bufrdeco_init(), and bufrdeco_reset().

Here is the caller graph for this function:

bufrdeco_init_subset_sequence_data()

int bufrdeco_init_subset_sequence_data

(

struct bufrdeco_subset_sequence_data *

ba

)

Init a struct bufrdeco_subset_sequence_data.

Parameters

ba	pointer to the target struct

Returns

0 if succeeded, 1 otherwise

It is supossed that no memory is allocated for sequence. If we are not sure better use function bufrdeco_clean_subset_sequence_data

Definition at line 140 of file bufrdeco_memory.c.

{
  bufrdeco_assert ( ba != NULL );
  
  memset ( ba, 0, sizeof ( struct bufrdeco_subset_sequence_data ) );
  if ( ( ba->sequence = ( struct bufr_atom_data * ) calloc ( 1, BUFR_NMAXSEQ * sizeof ( struct bufr_atom_data ) ) ) == NULL )
    {
      fprintf ( stderr,"%s():Cannot allocate memory for atom data array\n", __func__ );
      return 1;
    }
  ba->dim = BUFR_NMAXSEQ;
  return 0;
}

References BUFR_NMAXSEQ, bufrdeco_assert, bufrdeco_subset_sequence_data::dim, and bufrdeco_subset_sequence_data::sequence.

Referenced by bufrdeco_clean_subset_sequence_data().

Here is the caller graph for this function:

bufrdeco_init_tables()

int bufrdeco_init_tables

(

struct bufr_tables **

t

)

Init a struct bufr_tables allocating space.

Parameters

t	pointer to the target pointer to struct bufr_tables

Returns

0 if succeeded, 1 otherwise

Definition at line 32 of file bufrdeco_memory.c.

{
  bufrdeco_assert ( t != NULL );
  
  if ( *t != NULL )
    free ( ( void * ) *t );
 
  if ( ( *t = ( struct bufr_tables * ) calloc ( 1, sizeof ( struct bufr_tables ) ) ) == NULL )
    return 1;
  return 0;
}

References bufrdeco_assert.

Referenced by bufr_read_tables(), bufrdeco_init(), bufrdeco_store_tables(), and bufrdeco_substitute_tables().

Here is the caller graph for this function:

bufrdeco_parse_compressed()

int bufrdeco_parse_compressed	(	struct bufrdeco_compressed_data_references *	r,
		struct bufrdeco *	b
	)

Preliminary parse of a compressed data bufr.

Parameters

r	pointer to a struct bufrdeco_compressed_data_references where to set the results
b	basic container struct bufrdeco

Returns

Returns 0 if succeeded, 1 otherwise

When a bufr report has compressed data, it is needed to do a first parse step to get references about where to find the data for every descriptor in subsets. This is what this function does. If succeeded the struct r will have all needed data to decode individual subsets.

Also be mind that the descriptors tree have to be already parsed when calling this function

Definition at line 40 of file bufrdeco_compressed.c.

{
 
  // Check about parsed tree
  if ( b->tree == NULL || b->tree->nseq == 0 )
    {
      snprintf ( b->error, sizeof ( b->error ),"%s(): Try to parse compressed data without parsed tree\n", __func__ );
      return 1; //fatal error, no parsed tree
    }
 
  // first we assure that needed memory is allocated and array of bufr_compressed references initizalized
  if ( bufrdeco_init_compressed_data_references ( r ) )
    {
      return 1; // Something went wrong
    }
 
  // Then we make the parsing task in a recursive way. NULL pointer says it is the begining.
  // The NULL argument is because we begin the compresed Preliminary parse tasks
  if ( bufrdeco_parse_compressed_recursive ( r, NULL, b ) )
    {
      return 1;
    }
 
  // all is OK
  return 0;
}

References bufrdeco_init_compressed_data_references(), bufrdeco_parse_compressed_recursive(), bufrdeco::error, bufrdeco_expanded_tree::nseq, and bufrdeco::tree.

Referenced by bufrdeco_decode_data_subset(), and bufrdeco_get_target_subset_sequence_data().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_parse_compressed_recursive()

int bufrdeco_parse_compressed_recursive	(	struct bufrdeco_compressed_data_references *	r,
		struct bufr_sequence *	l,
		struct bufrdeco *	b
	)

Parse recursively the compressed data in a bufr report to get references where to get data for every descriptor in a subset.

Parameters

r	pointer to target struct bufrdeco_compressed_data_references where to set results
l	pointer to a struct bufr_sequence to parse in this call. If NULL then it is first root sequence
b	basic container struct bufrdeco

Returns

Returns 0 if succeeded, 1 otherwise

Definition at line 76 of file bufrdeco_compressed.c.

{
  int res;
  buf_t i, k;
  struct bufr_sequence *seq; // auxiliar pointer
  struct bufrdeco_compressed_ref *rf;
  struct bufr_replicator replicator;
 
  // Check arguments
  if ( b == NULL )
    return 1;
 
  if ( r == NULL )
    {
      snprintf ( b->error, sizeof ( b->error ), "%s(): Unspected NULL argument\n", __func__ );
      return 1;
    }
 
  if ( l == NULL )
    {
      // inits the array. This is the begining of preliminary parse
      // At the moment there are no structs bufrdeco_compressed_ref used
      r->nd = 0;
      // set the auxiliar pointer at the begining of array of sequences of bufrdeco_expanded_tree
      seq = & ( b->tree->seq[0] );
      // Cleans the state of parsing
      memset ( & ( b->state ), 0, sizeof ( struct bufrdeco_decoding_data_state ) );
      // and set some other initial values
      b->state.bit_offset = 0;
      b->state.added_bit_length = 0;
      b->state.added_scale = 0;
      b->state.added_reference = 0;
      b->state.assoc_bits = 0;
      b->state.changing_reference = 255;
      b->state.fixed_ccitt = 0;
      b->state.local_bit_reserved = 0;
      b->state.factor_reference = 1;
      b->state.quality_active = 0;
      b->state.subs_active = 0;
      b->state.retained_active = 0;
      b->state.stat1_active = 0;
      b->state.dstat_active = 0;
      b->state.bitmaping = 0;
      b->state.bitmap = NULL;
 
    }
  else
    {
      // This is the case when layer of sequence is no 0, i.e. has been called recursively
      // We just set the auxiliar index
      seq = l;
    }
 
  // Mark the init of a sequence. It waste a  reference to mark it
  rf = & ( r->refs[r->nd] );
  rf->mask = BUFRDECO_COMPRESSED_REF_SEQUENCE_INIT_BITMASK;
  rf->seq = seq;
  // Set the used elements of array in r
  if ( bufrdeco_increase_compressed_data_references_count ( r, b ) )
    return 1;
 
 
  // loop for a sequence
  for ( i = 0; i < seq->ndesc ; i++ )
    {
      // switch according to 'f' of the descriptor of sequence
      switch ( seq->lseq[i].f )
        {
        case 0:
          // Checks if no_data_present is active for this descriptor in this sequence
          if ( seq->no_data_present.active &&
               i >= seq->no_data_present.first &&
               i <= seq->no_data_present.last )
            {
              // If here then no_data_present has been active in this sequence
              if ( seq->lseq[i].x > 9 &&
                   seq->lseq[i].x != 31 )
                {
                  snprintf ( b->error, sizeof ( b->error ), "%s(): Getting data from table b with class other than 1-9,31 and no data present activated\n", __func__ );
                  return 1;
                }
 
            }
 
          // Get data from table B
          rf = & ( r->refs[r->nd] ); // pointer to the target struct bufrdeco_compressed ref. To read/write code easily
 
          // First the the data itself
          if ( bufrdeco_tableB_compressed ( rf, b, & ( seq->lseq[i] ), 0 ) )
            {
              return 1;
            }
 
          //case of first order statistics
          if ( b->state.stat1_active &&
               seq->lseq[i].x == 8 && seq->lseq[i].y == 23 )
            {
              k = b->bitmap.bmap[b->bitmap.nba - 1]->ns1; // index un stqts
              b->bitmap.bmap[b->bitmap.nba - 1]->stat1_desc[k] = r->nd; // Set the value of statistical parameter
              // update the number of quality variables for the bitmap
              if ( k < BUFR_MAX_QUALITY_DATA )
                ( b->bitmap.bmap[b->bitmap.nba - 1]->ns1 )++;
              else
                {
                  snprintf ( b->error, sizeof ( b->error ), "%s(): No more space for first order statistic vars in bitmap. Check BUFR_MAX_QUALITY_DATA\n", __func__ );
                  return 1;
                }
            }
 
          //case of difference statistics
          if ( b->state.dstat_active &&
               seq->lseq[i].x == 8 && seq->lseq[i].y == 24 )
            {
              k = b->bitmap.bmap[b->bitmap.nba - 1]->nds; // index un stqts
              b->bitmap.bmap[b->bitmap.nba - 1]->dstat_desc[k] = r->nd; // Set the value of statistical parameter
              // update the number of quality variables for the bitmap
              if ( k < BUFR_MAX_QUALITY_DATA )
                ( b->bitmap.bmap[b->bitmap.nba - 1]->nds )++;
              else
                {
                  snprintf ( b->error, sizeof ( b->error ), "%s(): No more space for difference statistic vars in bitmap. Check BUFR_MAX_QUALITY_DATA\n", __func__ );
                  return 1;
                }
            }
 
          rf->mask = BUFRDECO_COMPRESSED_REF_DATA_DESCRIPTOR_BITMASK;
          rf->seq = seq;
          if ( bufrdeco_increase_compressed_data_references_count ( r, b ) )
            return 1;
 
          // Then we check for an associated field
          rf = & ( r->refs[r->nd] );
          // If is not an associated field returned value is -1 and no action is made
          res = bufrdeco_tableB_compressed ( rf, b, & ( seq->lseq[i] ), 1 );
          if ( res > 0 )
            {
              return 1; // case of error
            }
          else if ( res == 0 )
            {
              rf->mask = BUFRDECO_COMPRESSED_REF_DATA_DESCRIPTOR_BITMASK;
              rf->seq = seq;
              // associated field read with success, set again the used elements of r
              if ( bufrdeco_increase_compressed_data_references_count ( r, b ) )
                return 1;
 
              // Update the pointer to the target struct bufrdeco_compressed ref
              i++; // Update main loop index, note that i is also incrmented at the end of loop.
            }
 
 
          break;
 
        case 1:
          // Case of replicator descriptor. waste a reference
          rf = & ( r->refs[r->nd] );
          rf->mask = BUFRDECO_COMPRESSED_REF_REPLICATOR_DESCRIPTOR;
          rf->seq = seq;
          rf->desc = & ( seq->lseq[i] );
          // Set the used elements of array in r
          if ( bufrdeco_increase_compressed_data_references_count ( r, b ) )
            return 1;
 
          memset ( &replicator, 0, sizeof ( struct bufr_replicator ) ); // mr proper
          replicator.s = seq;
          replicator.ixrep = i; // the index of recplicator descriptor in the sequence
          if ( seq->lseq[i].y != 0 )
            {
              // no delayed
              replicator.ixdel = i; // The index of descriptor with info about actual replication factor
              replicator.ndesc = seq->lseq[i].x;
              replicator.nloops = seq->lseq[i].y;
 
              // Check if this replicator is for a bit-map defining
              if ( b->state.bitmaping )
                {
                  b->state.bitmaping = replicator.nloops; // set it properly
                }
 
              // call to decode a replicated subsequence
              bufrdeco_decode_replicated_subsequence_compressed ( r, &replicator, b );
 
              // and then set again bitamping to 0, because it is finished
              b->state.bitmaping = 0;
            }
          else
            {
              // case of delayed;
              replicator.ixdel = i + 1; // the index of descriptor in sequence with information about the actual amonut of replications
              replicator.ndesc = seq->lseq[i].x;
              rf = & ( r->refs[r->nd] );
 
              // The the data itself to get the loops
              if ( bufrdeco_tableB_compressed ( rf, b, & ( seq->lseq[ replicator.ixdel ] ), 0 ) )
                {
                  return 1;
                }
              rf->mask = BUFRDECO_COMPRESSED_REF_DATA_DESCRIPTOR_BITMASK;
              rf->seq = seq;
 
              // Set the used elements of bufrdeco_compressed_ref
              if ( bufrdeco_increase_compressed_data_references_count ( r, b ) )
                return 1;
 
              // Note that is supossed all subsets has the same nlopps,
              // so the inc_bits must be 0 and nloops = ref0
              replicator.nloops = ( size_t ) rf->ref0;
 
              // Check if this replicator is for a bit-map defining
              if ( b->state.bitmaping )
                {
                  b->state.bitmaping = replicator.nloops; // set it properly
                }
 
              // call to decode a replicated subsequence
              bufrdeco_decode_replicated_subsequence_compressed ( r, &replicator, b );
 
              // and then set again bitamping to 0, because it is finished
              b->state.bitmaping = 0;
            }
          i = replicator.ixdel + replicator.ndesc; // update i properly
          break;
 
        case 2:
          // Case of operator descriptor
          rf = & ( r->refs[r->nd] );
          rf->mask = BUFRDECO_COMPRESSED_REF_OPERATOR_DESCRIPTOR;
          rf->seq = seq;
          rf->desc = & ( seq->lseq[i] );
          // Set the used elements of array in r
          if ( bufrdeco_increase_compressed_data_references_count ( r, b ) )
            return 1;
 
          if ( bufrdeco_parse_f2_compressed ( r, & ( seq->lseq[i] ), b ) )
            {
              return 1;
            }
 
          break;
 
        case 3:
          // Case of sequence descriptor
          if ( bufrdeco_parse_compressed_recursive ( r, seq->sons[i], b ) )
            {
              return 1;
            }
          break;
 
        default:
          // this case is not possible
          snprintf ( b->error, sizeof ( b->error ), "%s(): Found bad 'f' in descriptor '%s' \n", __func__, seq->lseq[i].c );
          return 1;
          break;
        }
    }
 
  // Mark end of sequence. waste a reference
  rf = & ( r->refs[r->nd] );
  rf->mask = BUFRDECO_COMPRESSED_REF_SEQUENCE_FINAL_BITMASK;
  rf->seq = seq;
  if ( bufrdeco_increase_compressed_data_references_count ( r, b ) )
     return 1;
 
 
  return 0;
}

References bufr_sequence_index_range::active, bufrdeco_decoding_data_state::added_bit_length, bufrdeco_decoding_data_state::added_reference, bufrdeco_decoding_data_state::added_scale, bufrdeco_decoding_data_state::assoc_bits, bufrdeco_decoding_data_state::bit_offset, bufrdeco_decoding_data_state::bitmap, bufrdeco::bitmap, bufrdeco_decoding_data_state::bitmaping, bufrdeco_bitmap_array::bmap, BUFR_MAX_QUALITY_DATA, BUFRDECO_COMPRESSED_REF_DATA_DESCRIPTOR_BITMASK, BUFRDECO_COMPRESSED_REF_OPERATOR_DESCRIPTOR, BUFRDECO_COMPRESSED_REF_REPLICATOR_DESCRIPTOR, BUFRDECO_COMPRESSED_REF_SEQUENCE_FINAL_BITMASK, BUFRDECO_COMPRESSED_REF_SEQUENCE_INIT_BITMASK, bufrdeco_decode_replicated_subsequence_compressed(), bufrdeco_increase_compressed_data_references_count(), bufrdeco_parse_compressed_recursive(), bufrdeco_parse_f2_compressed(), bufrdeco_tableB_compressed(), bufr_descriptor::c, bufrdeco_decoding_data_state::changing_reference, bufrdeco_compressed_ref::desc, bufrdeco_decoding_data_state::dstat_active, bufrdeco_bitmap::dstat_desc, bufrdeco::error, bufr_descriptor::f, bufrdeco_decoding_data_state::factor_reference, bufr_sequence_index_range::first, bufrdeco_decoding_data_state::fixed_ccitt, bufr_replicator::ixdel, bufr_replicator::ixrep, bufrdeco_decoding_data_state::local_bit_reserved, bufr_sequence::lseq, bufrdeco_compressed_ref::mask, bufrdeco_bitmap_array::nba, bufrdeco_compressed_data_references::nd, bufr_replicator::ndesc, bufr_sequence::ndesc, bufrdeco_bitmap::nds, bufr_replicator::nloops, bufr_sequence::no_data_present, bufrdeco_bitmap::ns1, bufrdeco_decoding_data_state::quality_active, bufrdeco_compressed_ref::ref0, bufrdeco_compressed_data_references::refs, bufrdeco_decoding_data_state::retained_active, bufr_replicator::s, bufrdeco_expanded_tree::seq, bufrdeco_compressed_ref::seq, bufr_sequence::sons, bufrdeco_decoding_data_state::stat1_active, bufrdeco_bitmap::stat1_desc, bufrdeco::state, bufrdeco_decoding_data_state::subs_active, bufrdeco::tree, bufr_descriptor::x, and bufr_descriptor::y.

Referenced by bufrdeco_decode_replicated_subsequence_compressed(), bufrdeco_parse_compressed(), and bufrdeco_parse_compressed_recursive().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_parse_f2_compressed()

int bufrdeco_parse_f2_compressed	(	struct bufrdeco_compressed_data_references *	r,
		struct bufr_descriptor *	d,
		struct bufrdeco *	b
	)

parse a descritor with f = 2 in case of compressed bufr

Parameters

r	pointer to a struct bufrdeco_compressed_data_references where to set data references if any
d	pointer to the source descriptor
b	pointer to the base struct bufrdeco

Returns

If succeded return 0, otherwise 1

Definition at line 406 of file bufrdeco_f2.c.

{
  buf_t nbits;
  uint32_t ival;
  struct bufrdeco_compressed_ref *rf;
  uint8_t has_data;
 
  // Check args
  bufrdeco_assert ( b != NULL );
 
  if ( d == NULL || r == NULL )
    {
      snprintf ( b->error, sizeof ( b->error ), "%s(): Unspected NULL argument(s)\n", __func__ );
    }
 
  if ( d->f != 2 )
    {
      return 0;  // nothing to do here
    }
 
  switch ( d->x )
    {
    case 1:
      // Add (YYY–128) bits to the data width given for each
      // data element in Table B, other than CCITT IA5
      // (character) data, code or flag tables.
      if ( d->y )
        {
          b->state.added_bit_length = d->y - 128;
        }
      else
        {
          b->state.added_bit_length = 0;
        }
      break;
 
    case 2:
      // Add YYY–128 to the scale for each data element in
      // Table B, other than CCITT IA5 (character) data, code
      // or flag tables.
      if ( d->y )
        {
          b->state.added_scale = d->y - 128;
        }
      else
        {
          b->state.added_scale = 0;
        }
      break;
 
    case 3:
      // Subsequent element descriptors define new reference
      // values for corresponding Table B entries. Each new
      // reference value is represented by YYY bits in the Data
      // section. Definition of new reference values is concluded
      // by coding this operator with YYY = 255. Negative
      // reference values shall be represented by a positive
      // integer with the left-most bit (bit 1) set to 1.
      b->state.changing_reference = d->y;
      break;
 
    case 4:
      // Precede each data element with YYY bits of
      // information. This operation associates a data field
      // (e.g. quality control information) of YYY bits with each
      // data element.
      b->state.assoc_bits = d->y;
      break;
 
    case 5:
      // YYY characters (CCITT International Alphabet No. 5) are
      // inserted as a data field of YYY x 8 bits in length.
      nbits = 8 * d->y;
      rf = & ( r->refs[r->nd] );
      rf->mask = BUFRDECO_COMPRESSED_REF_DATA_DESCRIPTOR_BITMASK;
      rf->desc = d;
      if ( get_bits_as_char_array ( rf->cref0, &rf->has_data, &b->sec4.raw[4], & ( b->state.bit_offset ), nbits ) == 0 )
        {
          snprintf ( b->error, sizeof ( b->error ), "%s(): Cannot get %u uchars from '%s'\n", __func__, d->y, d->c );
          return 1;
        }
      //strcpy_safe ( rf->name, "SIGNIFY CHARACTER" );
      //strcpy_safe ( rf->unit, "CCITTIA5" ); // unit
      strcpy ( rf->name, "SIGNIFY CHARACTER" );
      strcpy ( rf->unit, "CCITTIA5" ); // unit
 
      // Is suppossed all data will have same length in all subsets
      // extracting inc_bits from next 6 bits
      if ( get_bits_as_uint32_t ( &ival, &has_data, &b->sec4.raw[4], & ( b->state.bit_offset ), 6 ) == 0 )
        {
          snprintf ( b->error, sizeof ( b->error ), "%s(): Cannot get 6 bits for inc_bits from '%s'\n", __func__, d->c );
          return 1;
        }
      if ( ival != d->y )
        {
          snprintf ( b->error, sizeof ( b->error ), "%s(): Bad length in inc_bits for a 2 05 YYY descriptor from '%s'\n", __func__, d->c );
          return 1;
        }
      rf->inc_bits = ival;
      b->state.bit_offset += rf->inc_bits * 8 * b->sec3.subsets;
      if ( r->nd < ( BUFR_NMAXSEQ - 1 ) )
        {
          r->nd += 1;
        }
      else
        {
          snprintf ( b->error, sizeof ( b->error ), "%s(): Reached limit. Consider increas BUFR_NMAXSEQ\n", __func__ );
          return 1;
        }
      break;
 
    case 6:
      // YYY bits of data are described by the immediately
      // following local descriptor.
      b->state.local_bit_reserved = d->y;
      break;
 
    case 7:
      // For Table B elements, which are not CCITT IA5
      // (character data), code tables, or flag tables:
      // 1. Add YYY to the existing scale factor
      //  YYY
      // 2. Multiply the existing reference value by 10
      // 3. Calculate ((10 x YYY) + 2) ÷ 3, disregard any
      // fractional remainder and add the result to the
      // existing bit width.
      if ( d->y )
        {
          b->state.added_scale = d->y;
          if ( d->y < 10 )
            b->state.factor_reference = pow10pos_int[d->y];
          else
            {
              snprintf ( b->error, sizeof ( b->error ), "%s(): Too much %u increase bits for operator '%s'", __func__, d->y,
                         d->c );
              return 1;
            }
          b->state.added_bit_length = ( int8_t ) ( ( 10.0 * d->y + 2.0 ) / 3.0 );
        }
      else
        {
          b->state.added_scale = 0;
          b->state.factor_reference = 1;
          b->state.added_bit_length = 0;
        }
      break;
 
    case 8:
      // YYY characters from CCITT International Alphabet
      // No. 5 (representing YYY x 8 bits in length) replace the
      // specified data width given for each CCITT IA5
      // element in Table B.
      b->state.fixed_ccitt = d->y;
      break;
 
    case 21:
      // Data not present
      //
      // Data values present in Section 4 (Data section)
      // corresponding to the following YYY descriptors shall
      // be limited to data from Classes 01–09, and Class 31.
      //
      // It is nor processed here, it is already processed when parsing tree of expanded descriptors
      // adjusting the proper struct \ref bufr_sequence_index_range no_data_present
      break;
 
    case 22:
      // Quality information follows
      // The values of Class 33 elements which follow relate to
      // the data defined by the data present bit-map.
      //
      // Here we jsut activate the quality_active flag
      b->state.quality_active = 1;
      b->state.subs_active = 0;
      b->state.retained_active = 0;
      b->state.stat1_active = 0;
      b->state.dstat_active = 0;
      break;
 
    case 23:
      if ( d->y == 0 )
        {
          // Substituted operator values
          //
          // The substituted values which follow relate to the data
          // defined by the data present bit-map.
          b->state.quality_active = 0;
          b->state.subs_active = 1;
          b->state.retained_active = 0;
          b->state.stat1_active = 0;
          b->state.dstat_active = 0;
        }
      break;
 
    case 24:
      if ( d->y == 0 )
        {
          // First-order statistical values follow
          //
          // The statistical values which follow relate to the data
          // defined by the data present bit-map.
          b->state.quality_active = 0;
          b->state.subs_active = 0;
          b->state.retained_active = 0;
          b->state.stat1_active = 1;
          b->state.dstat_active = 0;
        }
      break;
 
    case 25:
      if ( d->y == 0 )
        {
          // Difference statistical values follow
          //
          // The statistical values which follow relate to the data
          // defined by the data present bit-map.
          b->state.quality_active = 0;
          b->state.subs_active = 0;
          b->state.retained_active = 0;
          b->state.stat1_active = 0;
          b->state.dstat_active = 1;
        }
      break;
 
    case 32:
      if ( d->y == 0 )
        {
          // Replaced/retained values follow
          //
          // The replaced/retained values which follow relate to the
          // data defined by the data present bit-map.
          b->state.quality_active = 0;
          b->state.subs_active = 0;
          b->state.retained_active = 1;
          b->state.stat1_active = 0;
          b->state.dstat_active = 0;
        }
      break;
 
 
    case 35:
      // Cancel backward data reference
      //
      // This operator terminates all previously defined backward
      // reference and cancels any previously defined
      // data present bit-map; it causes the next data present
      // bit-map to refer to the data descriptors which
      // immediately precede the operator to which it relates.
 
      // Set the bitmap pointer to NULL.
      b->state.bitmap = NULL;
      break;
 
    case 36:
      // Define data present bit-map
      //
      // This operator defines the data present bit-map which
      // follows for possible re-use; only one data present
      // bit-map may be defined between this operator and the
      // cancel use defined data present bit-map operator.
 
      // Here we just add a bufrdeco_bitmap struct set the current bitmap
      if ( bufrdeco_allocate_bitmap ( b ) )
        {
          // Cannot allocate another bitmap
          return 1;
        }
      // Set the new current bitmap
      b->state.bitmap = b->bitmap.bmap[b->bitmap.nba - 1];
 
      // Now set the bitmaping backward count to 1 to flag that next replicator descriptor must be set it properly
      b->state.bitmaping = 1;
 
      break;
 
    case 37:
      //  if y = 0000 use defined data present bit-map
      //  This operator causes the defined data present bit-map to be used again.
      //
      //  if y = 255  Cancel use defined data present bit-map
      // This operator cancels the re-use of the defined data present bit-map.
      if ( d->y == 0 )
        {
          if ( b->bitmap.nba && b->state.bitmap == NULL )
            b->state.bitmap =  b->bitmap.bmap[b->bitmap.nba - 1];
        }
      else if ( d->y == 255 )
        {
          b->state.bitmap = NULL;
        }
      break;
 
    case 41:
      // This operator denotes the beginning of the definition of an event.
      //
      // An event, as defined for use with operators 2 41 000 and 2 42 000,
      // is a set of one or more circumstances described using appropriate
      // Table B descriptors along with their corresponding data values. The
      // grouping of such descriptors together as a single “event” allows
      // them to be collectively assigned as the target of a separate descriptor
      // such as 0 33 045 or 0 33 046. When defining a circumstance within an
      // event, descriptor 0 33 042 may be employed preceding the appropriate
      // Table B descriptor in order to indicate that the corresponding value
      // is actually a bound for a range of values.
      //
      // If y = 255 then it  denotes the conclusion of the
      // event definition that was begun via the previous 2 41 000
      // operator.
      //
      // It is nor processed here, it is already processed when parsing tree of expanded descriptors
      // adjusting the proper struct \ref bufr_sequence_index_range event
      break;
 
    case 42:
      // This operator denotes the beginning of the definition of a conditioning event.
      //
      // An event, as defined for use with operators 2 41 000 and 2 42 000,
      // is a set of one or more circumstances described using appropriate
      // Table B descriptors along with their corresponding data values. The
      // grouping of such descriptors together as a single “event” allows
      // them to be collectively assigned as the target of a separate descriptor
      // such as 0 33 045 or 0 33 046. When defining a circumstance within an
      // event, descriptor 0 33 042 may be employed preceding the appropriate
      // Table B descriptor in order to indicate that the corresponding value
      // is actually a bound for a range of values.
      //
      // If y = 255 then it denotes the conclusion of the conditioning
      // event definition that was begun via the previous 2 42 000
      // operator.
      //
      // It is nor processed here, it is already processed when parsing tree of expanded descriptors
      // adjusting the proper struct \ref bufr_sequence_index_range cond_event
      break;
 
    case 43:
      // The values which follow are categorical forecast values
      //
      // A categorical forecast value represents a “best guess” from among a set of related,
      // and often mutually exclusive, data values or categories. Operator 2 43 000 may be
      // used to designate one or more values as categorical forecast values, and descriptor
      // 0 33 042 may be employed preceding any such value in order to indicate that that value
      // is actually a bound for a range of value
      //
      // If y == 255 then it denotes the conclusion of the definition of categorical forecast
      // values that was begun via theprevious 2 43 000 operator.
      //
      // It is nor processed here, it is already processed when parsing tree of expanded descriptors
      // adjusting the proper struct \ref bufr_sequence_index_range cat_forecast
      break;
 
    default:
      // Still not processed: 21
      snprintf ( b->error, sizeof ( b->error ), "%s(): Still no proccessed descriptor '%s' in "
                 "current library version %s \n", __func__, d->c, VERSION );
      return 1;
    }
  return 0;
}

References bufrdeco_decoding_data_state::added_bit_length, bufrdeco_decoding_data_state::added_scale, bufrdeco_decoding_data_state::assoc_bits, bufrdeco_decoding_data_state::bit_offset, bufrdeco_decoding_data_state::bitmap, bufrdeco::bitmap, bufrdeco_decoding_data_state::bitmaping, bufrdeco_bitmap_array::bmap, BUFR_NMAXSEQ, bufrdeco_allocate_bitmap(), bufrdeco_assert, BUFRDECO_COMPRESSED_REF_DATA_DESCRIPTOR_BITMASK, bufr_descriptor::c, bufrdeco_decoding_data_state::changing_reference, bufrdeco_compressed_ref::cref0, bufrdeco_compressed_ref::desc, bufrdeco_decoding_data_state::dstat_active, bufrdeco::error, bufr_descriptor::f, bufrdeco_decoding_data_state::factor_reference, bufrdeco_decoding_data_state::fixed_ccitt, get_bits_as_char_array(), get_bits_as_uint32_t(), bufrdeco_compressed_ref::has_data, bufrdeco_compressed_ref::inc_bits, bufrdeco_decoding_data_state::local_bit_reserved, bufrdeco_compressed_ref::mask, bufrdeco_compressed_ref::name, bufrdeco_bitmap_array::nba, bufrdeco_compressed_data_references::nd, pow10pos_int, bufrdeco_decoding_data_state::quality_active, bufr_sec4::raw, bufrdeco_compressed_data_references::refs, bufrdeco_decoding_data_state::retained_active, bufrdeco::sec3, bufrdeco::sec4, bufrdeco_decoding_data_state::stat1_active, bufrdeco::state, bufrdeco_decoding_data_state::subs_active, bufr_sec3::subsets, bufrdeco_compressed_ref::unit, VERSION, bufr_descriptor::x, and bufr_descriptor::y.

Referenced by bufrdeco_decode_replicated_subsequence_compressed(), and bufrdeco_parse_compressed_recursive().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_parse_f2_descriptor()

int bufrdeco_parse_f2_descriptor	(	struct bufrdeco_subset_sequence_data *	s,
		struct bufr_descriptor *	d,
		struct bufrdeco *	b
	)

parse a descritor with f = 2

Parameters

s	pointer to a struct bufrdeco_subset_sequence_data where to set data if any
d	pointer to the source descriptor
b	pointer to the base struct bufrdeco

Returns

If succeded return 0, otherwise 1

Definition at line 39 of file bufrdeco_f2.c.

{
  buf_t nbits;
  struct bufr_atom_data *a;
  uint8_t has_data;
 
  // Check args
  bufrdeco_assert ( b != NULL );
 
  if ( d == NULL || s == NULL )
    {
      snprintf ( b->error, sizeof ( b->error ), "%s(): Unspected NULL argument(s)\n", __func__ );
    }
 
  if ( d->f != 2 )
    {
      return 0;  // nothing to do here
    }
 
  switch ( d->x )
    {
    case 1:
      // Add (YYY–128) bits to the data width given for each
      // data element in Table B, other than CCITT IA5
      // (character) data, code or flag tables.
      if ( d->y )
        {
          b->state.added_bit_length = d->y - 128;
        }
      else
        {
          b->state.added_bit_length = 0;
        }
      break;
 
    case 2:
      // Add YYY–128 to the scale for each data element in
      // Table B, other than CCITT IA5 (character) data, code
      // or flag tables.
      if ( d->y )
        {
          b->state.added_scale = d->y - 128;
        }
      else
        {
          b->state.added_scale = 0;
        }
      break;
 
    case 3:
      // Subsequent element descriptors define new reference
      // values for corresponding Table B entries. Each new
      // reference value is represented by YYY bits in the Data
      // section. Definition of new reference values is concluded
      // by coding this operator with YYY = 255. Negative
      // reference values shall be represented by a positive
      // integer with the left-most bit (bit 1) set to 1.
      b->state.changing_reference = d->y;
      break;
 
    case 4:
      // Precede each data element with YYY bits of
      // information. This operation associates a data field
      // (e.g. quality control information) of YYY bits with each
      // data element.
      b->state.assoc_bits = d->y;
      break;
 
    case 5:
      // YYY characters (CCITT International Alphabet No. 5) are
      // inserted as a data field of YYY x 8 bits in length.
      nbits = 8 * d->y;
      a = & ( s->sequence[s->nd] );
      memcpy ( &a->desc, d, sizeof ( struct bufr_descriptor ) );
      if ( get_bits_as_char_array ( a->cval, &has_data, &b->sec4.raw[4], & ( b->state.bit_offset ), nbits ) == 0 )
        {
          snprintf ( b->error, sizeof ( b->error ), "%s(): Cannot get %u uchars from '%s'\n", __func__, d->y, d->c );
          return 1;
        }
      if ( has_data == 0 )
        {
          a->mask |= DESCRIPTOR_VALUE_MISSING;
        }
      else
        {
          a->mask |= DESCRIPTOR_HAVE_STRING_VALUE;
        }
      //strcpy_safe ( a->name, "SIGNIFY CHARACTER" );
      //strcpy_safe ( a->unit, "CCITTIA5" ); // unit
      strcpy ( a->name, "SIGNIFY CHARACTER" );
      strcpy ( a->unit, "CCITTIA5" ); // unit
      if (b->mask & BUFRDECO_OUTPUT_JSON_SUBSET_DATA)
      {
        bufrdeco_print_json_separator( b->out );
        bufrdeco_print_json_object_atom_data (b->out, a, NULL);
      }
      
      if ( s->nd < ( s->dim - 1 ) )
        {
          ( s->nd ) ++;
        }
      else if ( bufrdeco_increase_data_array ( s ) == 0 )
        {
          ( s->nd ) ++;
        }
      else
        {
          snprintf ( b->error, sizeof ( b->error ), "%s(): No more bufr_atom_data available. Check BUFR_NMAXSEQ\n", __func__ );
          return 1;
        }
      break;
 
    case 6:
      // YYY bits of data are described by the immediately
      // following local descriptor.
      b->state.local_bit_reserved = d->y;
      break;
 
    case 7:
      // For Table B elements, which are not CCITT IA5
      // (character data), code tables, or flag tables:
      // 1. Add YYY to the existing scale factor
      //  YYY
      // 2. Multiply the existing reference value by 10
      // 3. Calculate ((10 x YYY) + 2) ÷ 3, disregard any
      // fractional remainder and add the result to the
      // existing bit width.
      if ( d->y )
        {
          b->state.added_scale = d->y;
          if ( d->y < 10 )
            b->state.factor_reference = pow10pos_int[d->y];
          else
            {
              snprintf ( b->error, sizeof ( b->error ), "%s(): Too much %u increase bits for operator '%s'", __func__, d->y,
                         d->c );
              return 1;
            }
          b->state.added_bit_length = ( int8_t ) ( ( 10.0 * d->y + 2.0 ) / 3.0 );
        }
      else
        {
          b->state.added_scale = 0;
          b->state.factor_reference = 1;
          b->state.added_bit_length = 0;
        }
      break;
 
    case 8:
      // YYY characters from CCITT International Alphabet
      // No. 5 (representing YYY x 8 bits in length) replace the
      // specified data width given for each CCITT IA5
      // element in Table B.
      b->state.fixed_ccitt = d->y;
      break;
 
    case 21:
      // Data not present
      //
      // Data values present in Section 4 (Data section)
      // corresponding to the following YYY descriptors shall
      // be limited to data from Classes 01–09, and Class 31.
 
      // It is nor processed here, it is already processed when parsing tree of expanded descriptors
      // adjusting the proper struct \ref bufr_sequence_index_range no_data_present
      break;
 
    case 22:
      // Quality information follows
      // The values of Class 33 elements which follow relate to
      // the data defined by the data present bit-map.
      //
      // Here we jsut activate the quality_active flag
      b->state.quality_active = 1;
      b->state.subs_active = 0;
      b->state.retained_active = 0;
      b->state.stat1_active = 0;
      b->state.dstat_active = 0;
      break;
 
    case 23:
      if ( d->y == 0 )
        {
          // Substituted operator values
          //
          // The substituted values which follow relate to the data
          // defined by the data present bit-map.
          b->state.quality_active = 0;
          b->state.subs_active = 1;
          b->state.retained_active = 0;
          b->state.stat1_active = 0;
          b->state.dstat_active = 0;
        }
      break;
 
    case 24:
      if ( d->y == 0 )
        {
          // First-order statistical values follow
          //
          // The statistical values which follow relate to the data
          // defined by the data present bit-map.
          b->state.quality_active = 0;
          b->state.subs_active = 0;
          b->state.retained_active = 0;
          b->state.stat1_active = 1;
          b->state.dstat_active = 0;
        }
      break;
 
    case 25:
      if ( d->y == 0 )
        {
          // Difference statistical values follow
          //
          // The statistical values which follow relate to the data
          // defined by the data present bit-map.
          b->state.quality_active = 0;
          b->state.subs_active = 0;
          b->state.retained_active = 0;
          b->state.stat1_active = 0;
          b->state.dstat_active = 1;
        }
      break;
 
    case 32:
      if ( d->y == 0 )
        {
          // Replaced/retained values follow
          //
          // The replaced/retained values which follow relate to the
          // data defined by the data present bit-map.
          b->state.quality_active = 0;
          b->state.subs_active = 0;
          b->state.retained_active = 1;
          b->state.stat1_active = 0;
          b->state.dstat_active = 0;
        }
      break;
 
    case 35:
      // Cancel backward data reference
      //
      // This operator terminates all previously defined backward
      // reference and cancels any previously defined
      // data present bit-map; it causes the next data present
      // bit-map to refer to the data descriptors which
      // immediately precede the operator to which it relates.
 
      // Set the bitmap pointer to NULL.
      b->state.bitmap = NULL;
      break;
 
    case 36:
      // Define data present bit-map
      //
      // This operator defines the data present bit-map which
      // follows for possible re-use; only one data present
      // bit-map may be defined between this operator and the
      // cancel use defined data present bit-map operator.
 
      // Here we just add a bufrdeco_bitmap struct set the current bitmap
      if ( bufrdeco_allocate_bitmap ( b ) )
        {
          // Cannot allocate another bitmap
          return 1;
        }
      // Set the new current bitmap
      b->state.bitmap = b->bitmap.bmap[b->bitmap.nba - 1];
 
      // Now set the bitmaping backward count to 1 to flag that next replicator descriptor must be set it properly
      b->state.bitmaping = 1;
 
      break;
 
    case 37:
      //  if y = 0000 use defined data present bit-map
      //  This operator causes the defined data present bit-map to be used again.
      //
      //  if y = 255  Cancel use defined data present bit-map
      // This operator cancels the re-use of the defined data present bit-map.
      if ( d->y == 0 )
        {
          if ( b->bitmap.nba && b->state.bitmap == NULL )
            b->state.bitmap =  b->bitmap.bmap[b->bitmap.nba - 1];
        }
      else if ( d->y == 255 )
        {
          b->state.bitmap = NULL;
        }
      break;
 
    case 41:
      // This operator denotes the beginning of the definition of an event.
      //
      // An event, as defined for use with operators 2 41 000 and 2 42 000,
      // is a set of one or more circumstances described using appropriate
      // Table B descriptors along with their corresponding data values. The
      // grouping of such descriptors together as a single “event” allows
      // them to be collectively assigned as the target of a separate descriptor
      // such as 0 33 045 or 0 33 046. When defining a circumstance within an
      // event, descriptor 0 33 042 may be employed preceding the appropriate
      // Table B descriptor in order to indicate that the corresponding value
      // is actually a bound for a range of values.
      //
      // If y = 255 then it  denotes the conclusion of the
      // event definition that was begun via the previous 2 41 000
      // operator.
      //
      // It is nor processed here, it is already processed when parsing tree of expanded descriptors
      // adjusting the proper struct \ref bufr_sequence_index_range event
      break;
 
    case 42:
      // This operator denotes the beginning of the definition of a conditioning event.
      //
      // An event, as defined for use with operators 2 41 000 and 2 42 000,
      // is a set of one or more circumstances described using appropriate
      // Table B descriptors along with their corresponding data values. The
      // grouping of such descriptors together as a single “event” allows
      // them to be collectively assigned as the target of a separate descriptor
      // such as 0 33 045 or 0 33 046. When defining a circumstance within an
      // event, descriptor 0 33 042 may be employed preceding the appropriate
      // Table B descriptor in order to indicate that the corresponding value
      // is actually a bound for a range of values.
      //
      // If y = 255 then it denotes the conclusion of the conditioning
      // event definition that was begun via the previous 2 42 000
      // operator.
      //
      // It is nor processed here, it is already processed when parsing tree of expanded descriptors
      // adjusting the proper struct \ref bufr_sequence_index_range cond_event
      break;
 
    case 43:
      // The values which follow are categorical forecast values
      //
      // A categorical forecast value represents a “best guess” from among a set of related,
      // and often mutually exclusive, data values or categories. Operator 2 43 000 may be
      // used to designate one or more values as categorical forecast values, and descriptor
      // 0 33 042 may be employed preceding any such value in order to indicate that that value
      // is actually a bound for a range of value
      //
      // If y == 255 then it denotes the conclusion of the definition of categorical forecast
      // values that was begun via theprevious 2 43 000 operator.
      //
      // It is nor processed here, it is already processed when parsing tree of expanded descriptors
      // adjusting the proper struct \ref bufr_sequence_index_range cat_forecast
      break;
 
    default:
      snprintf ( b->error, sizeof ( b->error ), "%s(): Still no proccessed descriptor '%s' in "
                 "current library version %s\n", __func__, d->c, VERSION );
      return 1;
    }
  return 0;
}

References bufrdeco_decoding_data_state::added_bit_length, bufrdeco_decoding_data_state::added_scale, bufrdeco_decoding_data_state::assoc_bits, bufrdeco_decoding_data_state::bit_offset, bufrdeco_decoding_data_state::bitmap, bufrdeco::bitmap, bufrdeco_decoding_data_state::bitmaping, bufrdeco_bitmap_array::bmap, bufrdeco_allocate_bitmap(), bufrdeco_assert, bufrdeco_increase_data_array(), BUFRDECO_OUTPUT_JSON_SUBSET_DATA, bufrdeco_print_json_object_atom_data(), bufrdeco_print_json_separator(), bufr_descriptor::c, bufrdeco_decoding_data_state::changing_reference, bufr_atom_data::cval, bufr_atom_data::desc, DESCRIPTOR_HAVE_STRING_VALUE, DESCRIPTOR_VALUE_MISSING, bufrdeco_subset_sequence_data::dim, bufrdeco_decoding_data_state::dstat_active, bufrdeco::error, bufr_descriptor::f, bufrdeco_decoding_data_state::factor_reference, bufrdeco_decoding_data_state::fixed_ccitt, get_bits_as_char_array(), bufrdeco_decoding_data_state::local_bit_reserved, bufr_atom_data::mask, bufrdeco::mask, bufr_atom_data::name, bufrdeco_bitmap_array::nba, bufrdeco_subset_sequence_data::nd, bufrdeco::out, pow10pos_int, bufrdeco_decoding_data_state::quality_active, bufr_sec4::raw, bufrdeco_decoding_data_state::retained_active, bufrdeco::sec4, bufrdeco_subset_sequence_data::sequence, bufrdeco_decoding_data_state::stat1_active, bufrdeco::state, bufrdeco_decoding_data_state::subs_active, bufr_atom_data::unit, VERSION, bufr_descriptor::x, and bufr_descriptor::y.

Referenced by bufrdeco_decode_replicated_subsequence(), and bufrdeco_decode_subset_data_recursive().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_parse_tree()

int bufrdeco_parse_tree

(

struct bufrdeco *

b

)

Parse the tree of descriptors without expand the replicators.

Parameters

b	Pointer to the source struct bufrdeco

This is the user function to parse the descriptor structure of a BUFR report. This is the first task we need to perform after read the bufr report with the aid of bufrdeco_read_bufr function.

At the end we will get an array of structs bufr_sequence defining the tree

A sequence layer is needed when parsing expanded descriptor sec3 and sec4

First bufr_sequence is the sequence of descriptors in sec3 after byte 8. This is a bufr_sequence in level 0.

When a sequence descriptor is found in a layer, the sequence entries found in table D form this descriptor is a son bufr_sequence. This son has then a father and also can have one or more sons. The index level is incremented by one every step it go into decendents.

And so we go in a recursive way up to the end.

Returns

If success return 0, if something went wrong return 1

Definition at line 120 of file bufrdeco.c.

{
  bufrdeco_assert ( b != NULL );
 
  // here we start the parse
  return  bufrdeco_parse_tree_recursive ( b, NULL, 0, NULL );
}

References bufrdeco_assert, and bufrdeco_parse_tree_recursive().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_parse_tree_recursive()

int bufrdeco_parse_tree_recursive	(	struct bufrdeco *	b,
		struct bufr_sequence *	father,
		buf_t	father_idesc,
		const char *	key
	)

Parse the descriptor tree in a recursive way.

Parameters

key	string with descriptor in form 'FXXYYY'
father	pointer to the father struct bufr_sequence
father_idesc	index of sequence descriptor in father bufr_sequence which this sequence derived
b	pointer to the base struct bufrdeco

Returns

0 if success, 1 otherwise

Definition at line 60 of file bufrdeco_tree.c.

{
  buf_t i, j, nl;
  struct bufr_sequence *l;
  struct bufr_descriptor *d;
 
  //bufrdeco_assert (b != NULL);
  
  if ( key == NULL )
    {
      // case first layer
      memset ( b->tree, 0, sizeof ( struct bufrdeco_expanded_tree ) ); //reset memory
      b->tree->nseq = 1; // Set current number of sequences in tree, i.e. 1
      l = & ( b->tree->seq[0] ); // This is to write easily
      strcpy ( l->key, "000000" ); // Key '000000' is the first descriptor of first sequence of level 0
      l->level = 0; // Level 0
      l->father = NULL; // This layer is God, it has not father
      l->father_idesc = father_idesc; // No meaning here
      l->iseq = 0; // first
      strcpy ( l->name, "Main sequence from SEC3" );
      // here we get l->ndesc and l->lsec[] array
      if ( get_unexpanded_descriptor_array_from_sec3 ( l, b ) )
        {
          return 1;
        }
    }
  else
    {
      // First increase nseq counter
      if ( b->tree->nseq < NMAXSEQ_DESCRIPTORS )
        {
          ( b->tree->nseq ) ++;
        }
      else
        {
          // No more bufr_sequence permitted
          snprintf ( b->error, sizeof (b->error),"%s(): Reached max number of bufr_sequence. "
                    "Use bigger NMAXSEQ_LAYER \n" , __func__);
          return 1;
        }
      nl = b->tree->nseq; // To write code easily
      l = & ( b->tree->seq[nl - 1] ); // To write code easily
      strcpy ( l->key, key ); // Set the key of sequence in table d (f == 3)
      l->level = father->level + 1; // level for sequence
      l->father = father; // set the father
      l->father_idesc = father_idesc; // Set the father idesc
      l->iseq = nl - 1; // index of sequence in tree
 
      // here we get ndesc and lsec array from table d
      if ( bufrdeco_tableD_get_descriptors_array ( l, b, key ) )
        {
          return 1; // something went wrong
        }
    }
 
  // Set init replication level values from father, copying the one in replicated[0]
  for ( i = 1 ; i < l->ndesc ; i++)
  {
    l->replicated[i] = l->replicated[0];
  }
    
  // Checks for replication levels, no data present, event or conditioning event
  for ( i = 0; i < l->ndesc ; i++ )
    {
      d = & ( l->lseq[i] ); // To write/read code easily
 
      // Case of replication
      if ( d->f == 1 )
        {
          for ( j = 0; j < d->x; j++ )
            {
              if ( d->y == 0 )
                l->replicated[j + i + 2]++; // a delayed replicator follow
              else
                l->replicated[j + i + 1]++; // No delayed descriptor
            }
        }
 
 
      if ( d->f == 2 )
        {
          // check for no data present descriptors
          if ( d->x == 21 &&
               d->y > 0 )
            {
              if ( ( d->y + i ) < l->ndesc )
                {
                  l->no_data_present.active = 1;
                  l->no_data_present.first = i + 1;
                  l->no_data_present.last = i + d->y;
 
                }
              else
                {
                  // range of no data present out of sequence
                  snprintf ( b->error, sizeof (b->error),"%s(): Range of 'no data present' out of sequence limits\n" , __func__);
                  return 1;
                }
            }
 
          // Check for event descriptors
          if ( d->x == 41 )
            {
              if ( d->y == 0 && ( i + 1 ) < l->ndesc )
                {
                  l->event.active = 1;
                  l->event.first = i + 1;
                  l->event.last = l->ndesc - 1; // at the moment mark upto final sequence
                }
              else if ( ( d->y == 255 ) &&  l->event.active )
                {
                  l->event.last = i;
                }
              else
                {
                  snprintf ( b->error, sizeof (b->error),"%s(): unexpected or wrong event descriptor\n" , __func__);
                  return 1;
                }
            }
 
          // Check for conditioning event descriptors
          if ( d->x == 42 )
            {
              if ( d->y == 0 && ( i + 1 ) < l->ndesc )
                {
                  l->cond_event.active = 1;
                  l->cond_event.first = i + 1;
                  l->cond_event.last = l->ndesc - 1; // at the moment mark upto final sequence
                }
              else if ( ( d->y == 255 ) &&  l->cond_event.active )
                {
                  l->cond_event.last = i;
                }
              else
                {
                  snprintf ( b->error, sizeof (b->error),"%s(): unexpected or wrong conditioning event event descriptor\n" , __func__);
                  return 1;
                }
            }
 
          // Check for categorical forecasts descriptors
          if ( d->x == 43 )
            {
              if ( d->y == 0 && ( i + 1 ) < l->ndesc )
                {
                  l->cat_forecast.active = 1;
                  l->cat_forecast.first = i + 1;
                  l->cat_forecast.last = l->ndesc - 1; // at the moment mark upto final sequence
                }
              else if ( ( d->y == 255 ) &&  l->cat_forecast.active )
                {
                  l->cat_forecast.last = i;
                }
              else
                {
                  snprintf ( b->error, sizeof (b->error),"%s(): unexpected or wrong categorical forecasts descriptor\n" , __func__);
                  return 1;
                }
            }
        }
    }
 
  // now we detect sons and go to parse them
  for ( i = 0; i < l->ndesc ; i++ )
    {
      // we search for descriptors with f == 3
      if ( l->lseq[i].f != 3 )
        {
          l->sons[i] = NULL;
          continue;
        }
      l->sons[i] = & ( b->tree->seq[b->tree->nseq] );
      l->sons[i]->replicated[0] = l->replicated[i]; // This is a trick to pass replication level to sons
      
      // we then recursively parse the son
      if ( bufrdeco_parse_tree_recursive ( b, l, i, l->lseq[i].c ) )
        {
          return 1;
        }
    }
 
  // if we are here all gone well
  return 0;
}

References bufr_sequence_index_range::active, bufrdeco_parse_tree_recursive(), bufrdeco_tableD_get_descriptors_array(), bufr_descriptor::c, bufr_sequence::cat_forecast, bufr_sequence::cond_event, bufrdeco::error, bufr_sequence::event, bufr_descriptor::f, bufr_sequence::father, bufr_sequence::father_idesc, bufr_sequence_index_range::first, get_unexpanded_descriptor_array_from_sec3(), bufr_sequence::iseq, bufr_sequence::key, bufr_sequence_index_range::last, bufr_sequence::level, bufr_sequence::lseq, bufr_sequence::name, bufr_sequence::ndesc, NMAXSEQ_DESCRIPTORS, bufr_sequence::no_data_present, bufrdeco_expanded_tree::nseq, bufr_sequence::replicated, bufrdeco_expanded_tree::seq, bufr_sequence::sons, bufrdeco::tree, bufr_descriptor::x, and bufr_descriptor::y.

Referenced by bufrdeco_parse_tree(), and bufrdeco_parse_tree_recursive().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_print_atom_data()

char * bufrdeco_print_atom_data	(	char *	target,
		size_t	lmax,
		struct bufr_atom_data *	a
	)

print the data in a struct bufr_atom_data to a string

Parameters

target	string where to print the result
lmax	size of allocated string target
a	pointer to struct ref bufr_atom_data with data to print

Returns

a pointer to result string

Definition at line 433 of file bufrdeco_print.c.

{
  char aux[256];
  size_t used = 0;
  size_t nlimit, climit;
  
  bufrdeco_assert ( a != NULL && target != NULL );
 
  used += snprintf ( target + used, lmax - used, "%u %02u %03u ", a->desc.f, a->desc.x, a->desc.y );
  strcpy_safe ( aux, a->name );
  aux[64] = '\0';
  used += snprintf ( target + used, lmax - used, "%-64s ", aux );
  strcpy_safe ( aux, a->unit );
  aux[20] = '\0';
  used += snprintf ( target + used, lmax - used, "%-20s", aux );
  if ( a->mask & DESCRIPTOR_VALUE_MISSING )
    {
      used += snprintf ( target + used, lmax - used, "%17s", "MISSING" );
    }
  else
    {
      if ( a->mask & DESCRIPTOR_HAVE_STRING_VALUE )
        {
          strcpy_safe ( aux, a->cval );
          aux[64] = '\0';
          used += snprintf ( target + used, lmax - used, "                  " );
          used += snprintf ( target + used, lmax - used, "%s", aux );
        }
      else if ( a->mask & DESCRIPTOR_HAVE_CODE_TABLE_STRING
                || strstr ( a->unit, "CODE TABLE" ) == a->unit
                || strstr ( a->unit, "Code table" ) == a->unit )
        {
          strcpy_safe ( aux, a->ctable );
          aux[64] = '\0';
          used += snprintf ( target + used, lmax - used, "%17u ", ( uint32_t ) a->val );
          used += snprintf ( target + used, lmax - used, "%s", aux );
        }
      else if ( a->mask & DESCRIPTOR_HAVE_FLAG_TABLE_STRING )
        {
          strcpy_safe ( aux, a->ctable );
          aux[64] = '\0';
          used += snprintf ( target + used, lmax - used, "       0x%08X ", ( uint32_t ) a->val );
          used += snprintf ( target + used, lmax - used, "%s", aux );
        }
      else
        {
          used += snprintf ( target + used, lmax - used, "%s ", get_formatted_value_from_escale ( aux, sizeof ( aux ), a->escale, a->val ) );
        }
 
    }
 
  // Now print remaining chars in a->name or a->ctable
  nlimit = 64;
  climit = 64;
  while ( ( strlen ( a->name ) > nlimit && nlimit < BUFR_TABLEB_NAME_LENGTH ) ||
          ( strlen ( a->ctable ) > climit && climit < BUFR_EXPLAINED_LENGTH ) )
    {
      aux[0] = 0;
      if ( strlen ( a->name ) > nlimit && nlimit < BUFR_TABLEB_NAME_LENGTH )
        strncpy ( aux, a->name + nlimit, 64 );
      used += snprintf ( target + used, lmax - used, "\n                 %-64s", aux );
      aux[0] = 0;
      if ( strlen ( a->ctable ) > climit && climit < BUFR_EXPLAINED_LENGTH )
        strncpy ( aux, a->ctable + climit, 64 );
      used += snprintf ( target + used, lmax - used, "                                       %s", aux );
      nlimit += 64;
      climit += 64;
    }
 
  if ( a->is_bitmaped_by != 0 )
    used += snprintf ( target + used, lmax - used, " *IS BITMAPED BY #%u*", a->is_bitmaped_by );
 
  if ( a->bitmap_to != 0 )
    used += snprintf ( target + used, lmax - used, " *BITMAP TO #%u*", a->bitmap_to );
 
  if ( a->related_to != 0 )
    used += snprintf ( target + used, lmax - used, " *RELATED TO #%u*", a->related_to );
 
  return target;
}

References bufr_atom_data::bitmap_to, BUFR_EXPLAINED_LENGTH, BUFR_TABLEB_NAME_LENGTH, bufrdeco_assert, bufr_atom_data::ctable, bufr_atom_data::cval, bufr_atom_data::desc, DESCRIPTOR_HAVE_CODE_TABLE_STRING, DESCRIPTOR_HAVE_FLAG_TABLE_STRING, DESCRIPTOR_HAVE_STRING_VALUE, DESCRIPTOR_VALUE_MISSING, bufr_atom_data::escale, bufr_descriptor::f, get_formatted_value_from_escale(), bufr_atom_data::is_bitmaped_by, bufr_atom_data::mask, bufr_atom_data::name, bufr_atom_data::related_to, strcpy_safe, bufr_atom_data::unit, bufr_atom_data::val, bufr_descriptor::x, and bufr_descriptor::y.

Referenced by bufrdeco_fprint_subset_sequence_data(), and bufrdeco_print_atom_data_file().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_print_atom_data_file()

int bufrdeco_print_atom_data_file	(	FILE *	f,
		struct bufr_atom_data *	a
	)

print the data in a struct bufr_atom_data to a file already open by caller

Parameters

f	Pointer to file opened by caller
a	pointer to struct ref bufr_atom_data with data to print

Returns

If succeeded return 0

Definition at line 403 of file bufrdeco_print.c.

{
  char aux[1024];
  bufrdeco_assert ( f != NULL && a != NULL );
 
  bufrdeco_print_atom_data ( aux, sizeof ( aux ), a );
  fprintf ( f,  "%s\n",aux );
  return 0;
}

References bufrdeco_assert, and bufrdeco_print_atom_data().

Referenced by bufrdeco_print_atom_data_stdout().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_print_atom_data_html()

char * bufrdeco_print_atom_data_html	(	char *	target,
		size_t	lmax,
		struct bufr_atom_data *	a,
		uint32_t	ss
	)

print the data in a struct bufr_atom_data to a string as cells of table rows

Parameters

target	string where to print the result
lmax	dimension of target
a	pointer to struct ref bufr_atom_data with data to print
ss	index of subset in bufr

Returns

a pointer to result string

Definition at line 160 of file bufrdeco_print_html.c.

{
  char aux[256];
  size_t used = 0;
 
  bufrdeco_assert ( a != NULL && lmax != 0 && target != NULL );
   
  used += snprintf ( target + used , lmax - used,"<td class='desc'>%u %02u %03u</td>", a->desc.f, a->desc.x, a->desc.y );
  used += snprintf ( target + used , lmax - used,"<td class='name'>%s</td>", a->name );
  used += snprintf ( target + used , lmax - used,"<td class='unit'>%s</td>", a->unit );
  if ( a->mask & DESCRIPTOR_VALUE_MISSING )
    {
      if ( a->is_bitmaped_by != 0 )
        used += snprintf ( target + used , lmax - used,"<td class='missing'>MISSING</td><td>NOTE: Bitmaped by <a href='#d%u_%u'>#%u</a></td>", ss, a->is_bitmaped_by, a->is_bitmaped_by );
      else if ( a->bitmap_to != 0 )
        used += snprintf ( target + used , lmax - used,"<td class='missing'>MISSING</td><td>NOTE: Bitmap to <a href='#d%u_%u'>#%u</a></td>", ss, a->bitmap_to, a->bitmap_to );
      else if ( a->related_to != 0 )
        used += snprintf ( target + used , lmax - used,"<td class='missing'>MISSING</td><td>NOTE: Related to <a href='#d%u_%u'>#%u</a></td>", ss, a->related_to, a->related_to );
      else
        used += snprintf ( target + used , lmax - used,"<td class='missing'>MISSING</td><td></td>" );
    }
  else
    {
      if ( a->mask & DESCRIPTOR_HAVE_STRING_VALUE )
        {
          if ( a->is_bitmaped_by != 0 )
            used += snprintf ( target + used , lmax - used,"<td></td><td class='cval'>%s<br>NOTE: Bitmaped by <a href='#d%u_%u'>#%u</a></td>\n", a->cval, ss, a->is_bitmaped_by, a->is_bitmaped_by );
          else if ( a->bitmap_to != 0 )
            used += snprintf ( target + used , lmax - used,"<td></td><td class='cval'>%s<br>NOTE: Bitmap to <a href='#d%u_%u'>#%u</a></td>\n", a->cval, ss, a->bitmap_to, a->bitmap_to );
          else if ( a->related_to != 0 )
            used += snprintf ( target + used , lmax - used,"<td></td><td class='cval'>%s<br>NOTE: Related to <a href='#d%u_%u'>#%u</a></td>\n", a->cval, ss, a->related_to, a->related_to );
          else
            used += snprintf ( target + used , lmax - used,"<td></td><td class='cval'>%s</td>\n", a->cval );
        }
      else if ( a->mask & DESCRIPTOR_HAVE_CODE_TABLE_STRING
                || strstr ( a->unit, "CODE TABLE" ) == a->unit
                || strstr ( a->unit, "Code table" ) == a->unit )
        {
          used += snprintf ( target + used , lmax - used,"<td class='ival'>%17u</td>", ( uint32_t ) a->val );
          if ( a->is_bitmaped_by != 0 )
            used += snprintf ( target + used , lmax - used,"<td class='ctable'>%s<br>NOTE: Bitmaped by <a href='#d%u_%u'>#%u</a></td>\n", a->ctable, ss, a->is_bitmaped_by, a->is_bitmaped_by );
          else if ( a->bitmap_to != 0 )
            used += snprintf ( target + used , lmax - used,"<td class='ctable'>%s<br>NOTE: Bitmap to <a href='#d%u_%u'>#%u</a></td>\n", a->ctable, ss, a->bitmap_to, a->bitmap_to  );
          else if ( a->related_to != 0 )
            used += snprintf ( target + used , lmax - used,"<td class='ctable'>%s<br>NOTE: Related to <a href='#d%u_%u'>#%u</a></td>\n", a->ctable, ss, a->related_to, a->related_to  );
          else
            used += snprintf ( target + used , lmax - used,"<td class='ctable'>%s</td>\n", a->ctable );
        }
      else if ( a->mask & DESCRIPTOR_HAVE_FLAG_TABLE_STRING )
        {
          used += snprintf ( target + used , lmax - used,"<td class='hval'>0x%08X</td>", ( uint32_t ) a->val );
          if ( a->is_bitmaped_by != 0 )
            used += snprintf ( target + used , lmax - used,"<td class='ctable'>%s<br>NOTE: Bitmaped by <a href='#%du_%u'>#%u</a></td>\n", a->ctable, ss, a->is_bitmaped_by, a->is_bitmaped_by );
          else if ( a->bitmap_to != 0 )
            used += snprintf ( target + used , lmax - used,"<td class='ctable'>%s<br>NOTE: Bitmap to <a href='#d%u_%u'>#%u</a></td>\n", a->ctable, ss, a->bitmap_to, a->bitmap_to  );
          else if ( a->related_to != 0 )
            used += snprintf ( target + used , lmax - used,"<td class='ctable'>%s<br>NOTE: Related to <a href='#d%u_%u'>#%u</a></td>\n", a->ctable, ss, a->related_to, a->related_to  );
          else
            used += snprintf ( target + used , lmax - used,"<td class='ctable'>%s</td>\n", a->ctable );
        }
      else
        {
          if ( a->is_bitmaped_by != 0 )
            used += snprintf ( target + used , lmax - used,"<td class='rval'>%s</td><td>NOTE: Bitmaped by <a href='#d%u_%u'>#%u</a></td>" , get_formatted_value_from_escale ( aux, sizeof (aux), a->escale, a->val ), ss, a->is_bitmaped_by, a->is_bitmaped_by );
          else if ( a->bitmap_to != 0 )
            used += snprintf ( target + used , lmax - used,"<td class='rval'>%s</td><td>NOTE: Bitmap to <a href='#d%u_%u'>#%u</a></td>" , get_formatted_value_from_escale ( aux, sizeof (aux), a->escale, a->val ) , ss, a->bitmap_to, a->bitmap_to );
          else if ( a->related_to != 0 )
            used += snprintf ( target + used , lmax - used,"<td class='rval'>%s</td><td>NOTE: Related to <a href='#d%u_%u'>#%u</a></td>" , get_formatted_value_from_escale ( aux, sizeof (aux), a->escale, a->val ), ss, a->related_to, a->related_to );
          else
            used += snprintf ( target + used , lmax - used,"<td class='rval'>%s</td><td></td>" , get_formatted_value_from_escale ( aux, sizeof (aux), a->escale, a->val ) );
        }
    }
  return target;
}

References bufr_atom_data::bitmap_to, bufrdeco_assert, bufr_atom_data::ctable, bufr_atom_data::cval, bufr_atom_data::desc, DESCRIPTOR_HAVE_CODE_TABLE_STRING, DESCRIPTOR_HAVE_FLAG_TABLE_STRING, DESCRIPTOR_HAVE_STRING_VALUE, DESCRIPTOR_VALUE_MISSING, bufr_atom_data::escale, bufr_descriptor::f, get_formatted_value_from_escale(), bufr_atom_data::is_bitmaped_by, bufr_atom_data::mask, bufr_atom_data::name, bufr_atom_data::related_to, bufr_atom_data::unit, bufr_atom_data::val, bufr_descriptor::x, and bufr_descriptor::y.

Referenced by bufrdeco_fprint_subset_sequence_data_html(), and bufrdeco_fprint_subset_sequence_data_tagged_html().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_print_atom_data_stdout()

int bufrdeco_print_atom_data_stdout

(

struct bufr_atom_data *

a

)

print the data in a struct bufr_atom_data to stdout

Parameters

a	pointer to struct ref bufr_atom_data with data to print

Returns

If succeeded return 0

Definition at line 419 of file bufrdeco_print.c.

{
  return bufrdeco_print_atom_data_file ( stdout, a );
}

References bufrdeco_print_atom_data_file().

Here is the call graph for this function:

bufrdeco_print_json_object_atom_data()

buf_t bufrdeco_print_json_object_atom_data	(	FILE *	out,
		struct bufr_atom_data *	a,
		char *	add
	)

Print an json object with a descriptor data.

Parameters

out	output stream opened by caller
a	pointer to target struct bufr_atom_data
add	adtional optional info

Returns

The amount of bytes sent to out

There are four cases of objects, depending of data type { "descriptor":"f xx yyy", "name":"name_of_descriptor" , "unit":"name_of_unit", "value":"string_value"} { "descriptor":"f xx yyy", "name":"name_of_descriptor" , "unit":"Code table", "value":"numeric_value", "meaning":"explanation_string} { "descriptor":"f xx yyy", "name":"name_of_descriptor" , "unit":"Flag value", "value":"numeric_value", "meaning":"explanation_string} { "descriptor":"f xx yyy", "name":"name_of_descriptor" , "unit":"name_of_unit", "value":"numeric_value"}

Definition at line 134 of file bufrdeco_json.c.

{
  char aux[256];
  buf_t used = 0;
 
  used += fprintf ( out,  "{\"Descriptor\":\"%u %02u %03u\",\"Name\":\"%s\",", a->desc.f, a->desc.x, a->desc.y, bufr_adjust_string ( a->name ) );
 
  // add aditional info keys
  if ( add != NULL && add[0] )
    used += fprintf ( out, "%s,", add );
 
  if ( a->mask & DESCRIPTOR_HAVE_STRING_VALUE )
    {
      // string data case
      if ( a->mask & DESCRIPTOR_VALUE_MISSING )
        used += fprintf ( out, "\"Unit\":\"CCITT5\",\"Value\":\"MISSING\"}" ) ;
      else
        {
          used += fprintf ( out, "\"Unit\":\"CCITT5\",\"Value\":\"" ) ;
          used += bufrdeco_print_json_scape_string_cvals ( out, a->cval );
          used += fprintf ( out, "\"}" );
        }
    }
  else if ( a->mask & DESCRIPTOR_IS_CODE_TABLE )
    {
      // code table case
      if ( a->mask & DESCRIPTOR_VALUE_MISSING )
        used += fprintf ( out, "\"Unit\":\"Code table\",\"Value\":\"MISSING\"}" ) ;
      else
        {
          used += fprintf ( out, "\"Unit\":\"Code table\",\"Value\":%u,", ( uint32_t ) ( a->val + 0.5 ) ) ;
          used += fprintf ( out, "\"Meaning\":\"%s\"}", bufr_adjust_string ( a->ctable ) );
        }
    }
  else if ( a->mask & DESCRIPTOR_IS_FLAG_TABLE )
    {
      // flag table case
      if ( a->mask & DESCRIPTOR_VALUE_MISSING )
        used += fprintf ( out, "\"Unit\":\"Flag table\",\"Value\":\"MISSING\"}" ) ;
      else
        {
          used += fprintf ( out, "\"Unit\":\"Flag table\",\"Value\":\"0x%08X\",", ( uint32_t ) ( a->val ) ) ;
          used += fprintf ( out, "\"Meaning\":\"%s\"}", bufr_adjust_string ( a->ctable ) );
        }
    }
  else
    {
      // numeric data case
      if ( a->mask & DESCRIPTOR_VALUE_MISSING )
        used += fprintf ( out, "\"Unit\":\"%s\",\"Value\":\"MISSING\"}", a->unit ) ;
      else
        {
          used += fprintf ( out, "\"Unit\":\"%s\",\"Value\":%s}", a->unit,
                            get_formatted_value_from_escale2 ( aux, sizeof ( aux ), a->escale, a->val ) );
 
        }
    }
  return used;
}

References bufr_adjust_string(), bufrdeco_print_json_scape_string_cvals(), bufr_atom_data::ctable, bufr_atom_data::cval, bufr_atom_data::desc, DESCRIPTOR_HAVE_STRING_VALUE, DESCRIPTOR_IS_CODE_TABLE, DESCRIPTOR_IS_FLAG_TABLE, DESCRIPTOR_VALUE_MISSING, bufr_atom_data::escale, bufr_descriptor::f, get_formatted_value_from_escale2(), bufr_atom_data::mask, bufr_atom_data::name, bufr_atom_data::unit, bufr_atom_data::val, bufr_descriptor::x, and bufr_descriptor::y.

Referenced by bufr_decode_subset_data_compressed(), bufrdeco_decode_replicated_subsequence(), bufrdeco_decode_subset_data_recursive(), and bufrdeco_parse_f2_descriptor().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_print_json_object_operator_descriptor()

buf_t bufrdeco_print_json_object_operator_descriptor	(	FILE *	out,
		struct bufr_descriptor *	d,
		char *	add
	)

print an operator desciptor as a json object

Parameters

out	output stream opened by caller
d	pointer to operator descriptor
add	adtional optional info

Returns

The amount of bytes sent to out

Definition at line 203 of file bufrdeco_json.c.

{
  buf_t used = 0;
  char explanation[256];
 
  if ( d->f == 2 )
    {
      // only prints if f == 2
      used += fprintf ( out, "{\"Descriptor\":\"%u %02u %03u\",", d->f, d->x, d->y );
      // add aditional info keys
      if ( add != NULL && add[0] )
        used += fprintf ( out, "%s,", add );
 
      used += fprintf ( out, "\"Operator\": \"%s\"}", bufrdeco_get_f2_descriptor_explanation ( explanation, sizeof ( explanation ), d ) );
    }
  return used;
}

References bufrdeco_get_f2_descriptor_explanation(), bufr_descriptor::f, bufr_descriptor::x, and bufr_descriptor::y.

Referenced by bufr_decode_subset_data_compressed(), bufrdeco_decode_replicated_subsequence(), and bufrdeco_decode_subset_data_recursive().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_print_json_object_replicator_descriptor()

buf_t bufrdeco_print_json_object_replicator_descriptor	(	FILE *	out,
		struct bufr_descriptor *	d,
		char *	add
	)

print an operator desciptor as a json object

Parameters

out	string where to print
d	pointer to operator descriptor
add	additional info

Returns

The amount of bytes sent to out

Definition at line 230 of file bufrdeco_json.c.

{
  buf_t used = 0;
 
  if ( d->f == 1 )
    {
      used += fprintf ( out, "{\"Descriptor\":\"%u %02u %03u\",", d->f, d->x, d->y );
      // add aditional info keys
      if ( add != NULL && add[0] )
        used += fprintf ( out, "%s,", add );
 
      if ( d->y == 0 )
        {
          if ( d->x == 1 )
            used += fprintf ( out, "\"Replicator\":\"Replicator for %d descriptor after next delayed descriptor which set the number of replications.\"}", d->x );
          else
            used += fprintf ( out, "\"Replicator\":\"Replicator for %d descriptors after next delayed descriptor which set the number of replications.\"}", d->x );
        }
      else
        {
          if ( d->x == 1 )
            used += fprintf ( out, "\"Replicator\":\"Replicator for next descriptor %d times.\"}", d->y );
          else
            used += fprintf ( out, "\"Replicator\":\"Replicator for next %d descriptors %d times\"}", d->x, d->y );
        }
 
    }
  return used;
}

References bufr_descriptor::f, bufr_descriptor::x, and bufr_descriptor::y.

Referenced by bufr_decode_subset_data_compressed(), bufrdeco_decode_replicated_subsequence(), and bufrdeco_decode_subset_data_recursive().

Here is the caller graph for this function:

bufrdeco_print_json_scape_string_cvals()

buf_t bufrdeco_print_json_scape_string_cvals	(	FILE *	out,
		char *	source
	)

prints a descriptor string value scaping the '"' for a json format

Parameters

out	output stream
source	source string

Returns

The amount of bytes sent to out

Definition at line 33 of file bufrdeco_json.c.

{
  buf_t i = 0, used = 0;
  while ( source[i] )
    {
      switch ( source[i] )
        {
        case '"':
          used += fprintf ( out, "%c%c", '\\', source[i++] );
          break;
        default:
          used += fprintf ( out, "%c", source[i++] );
          break;
        }
    }
  return used;
}

Referenced by bufrdeco_print_json_object_atom_data().

Here is the caller graph for this function:

bufrdeco_print_json_sec0()

buf_t bufrdeco_print_json_sec0	(	FILE *	out,
		struct bufrdeco *	b
	)

Definition at line 280 of file bufrdeco_json.c.

{
  size_t used = 0;
 
  bufrdeco_assert ( b != NULL );
  used += fprintf ( out, "{\"Sec 0\":{" );
  used += fprintf ( out, "\"Bufr length\":%u,", b->sec0.bufr_length );
  used += fprintf ( out, "\"Bufr edition\":%u}}", b->sec0.edition );
  return used;
}

References bufr_sec0::bufr_length, bufrdeco_assert, bufr_sec0::edition, and bufrdeco::sec0.

Referenced by bufrdeco_read_buffer().

Here is the caller graph for this function:

bufrdeco_print_json_sec1()

bufrdeco_print_json_sec1	(	FILE *	out,
		struct bufrdeco *	b
	)

Print info form sec 1 in json format.

Parameters

out	string where to print
b	actuve struct bufrdeco

Returns

The amount of bytes sent to out

Definition at line 300 of file bufrdeco_json.c.

{
  size_t used = 0;
 
  bufrdeco_assert ( b != NULL );
  used += fprintf ( out, "{\"Sec 1\":{" );
  used += fprintf ( out, "\"Length\":%u", b->sec1.length );
  used += fprintf ( out, ",\"Bufr master table\":%u", b->sec1.master );
  used += fprintf ( out, ",\"Centre\":%u", b->sec1.centre );
  used += fprintf ( out, ",\"Sub-Centre\":%u", b->sec1.subcentre );
  used += fprintf ( out, ",\"Update sequence\":%u", b->sec1.update );
  used += fprintf ( out, ",\"Options\":\"0x%x\"", b->sec1.options );
  used += fprintf ( out, ",\"Category\":%u", b->sec1.category );
  used += fprintf ( out, ",\"Subcategory\":%u", b->sec1.subcategory );
  used += fprintf ( out, ",\"Sub-category local\":%u", b->sec1.subcategory_local );
  used += fprintf ( out, ",\"Master table version\":%u", b->sec1.master_version );
  used += fprintf ( out, ",\"Master table local\":%u", b->sec1.master_local );
  used += fprintf ( out, ",\"Year\":%u", b->sec1.year );
  used += fprintf ( out, ",\"Month\":%u", b->sec1.month );
  used += fprintf ( out, ",\"Day\":%u", b->sec1.day );
  used += fprintf ( out, ",\"Hour\":%u", b->sec1.hour );
  used += fprintf ( out, ",\"Minute\":%u", b->sec1.minute );
  used += fprintf ( out, ",\"Second\":%u", b->sec1.second );
  if ( b->sec0.edition == 3 )
    used += fprintf ( out, ",\"Aditional space\":%u", b->sec1.length - 17 );
  else
    used += fprintf ( out, ",\"Aditional space\":%u", b->sec1.length - 22 );
  used += fprintf ( out, "}" );
 
  if ( b->tables->b.path[0] )
    {
      used += fprintf ( out, ",{\"Used tables\":{" );
      used += fprintf ( out, ",\"TableB file\":\"%s\"", b->tables->b.path );
      used += fprintf ( out, ",\"tableC file\":\"%s\"", b->tables->c.path );
      used += fprintf ( out, ",\"tableD file\":\"%s\"", b->tables->d.path );
      used += fprintf ( out, "}" );
    }
  used += fprintf ( out, "}" );
 
  return used;
}

References bufr_tables::b, bufrdeco_assert, bufr_tables::c, bufr_sec1::category, bufr_sec1::centre, bufr_tables::d, bufr_sec1::day, bufr_sec0::edition, bufr_sec1::hour, bufr_sec1::length, bufr_sec1::master, bufr_sec1::master_local, bufr_sec1::master_version, bufr_sec1::minute, bufr_sec1::month, bufr_sec1::options, bufr_tableB::path, bufr_tableC::path, bufr_tableD::path, bufrdeco::sec0, bufrdeco::sec1, bufr_sec1::second, bufr_sec1::subcategory, bufr_sec1::subcategory_local, bufr_sec1::subcentre, bufrdeco::tables, bufr_sec1::update, and bufr_sec1::year.

Referenced by bufrdeco_read_buffer().

Here is the caller graph for this function:

bufrdeco_print_json_sec2()

buf_t bufrdeco_print_json_sec2	(	FILE *	out,
		struct bufrdeco *	b
	)

Print info form optional sec 2 in json format.

Parameters

out	string where to print
b	actuve struct bufrdeco

Returns

The amount of bytes sent to out

Definition at line 350 of file bufrdeco_json.c.

{
  size_t used = 0;
 
  bufrdeco_assert ( b != NULL );
  used += fprintf ( out, "{\"Sec 2\":{" );
  if ( b->sec1.options & 0x80 )
    used += fprintf ( out, "\"Length\":%u}}", b->sec2.length );
  else
    used += fprintf ( out, "\"Length\":0}}" );
 
  return used;
}

References bufrdeco_assert, bufr_sec2::length, bufr_sec1::options, bufrdeco::sec1, and bufrdeco::sec2.

Referenced by bufrdeco_read_buffer().

Here is the caller graph for this function:

bufrdeco_print_json_sec3()

bufrdeco_print_json_sec3	(	FILE *	out,
		struct bufrdeco *	b
	)

Print info form sec 3 in json format.

Parameters

out	string where to print
b	actuve struct bufrdeco

Returns

The amount of bytes sent to out

Definition at line 372 of file bufrdeco_json.c.

{
  buf_t used = 0, i;
 
  bufrdeco_assert ( b != NULL );
  used += fprintf ( out, "{\"Sec 3\":{" );
  used += fprintf ( out, "\"Sec3 length\":%u", b->sec3.length );
  used += fprintf ( out, ",\"Subsets\":%u", b->sec3.subsets );
  used += fprintf ( out, ",\"Observed\":%u", b->sec3.observed );
  used += fprintf ( out, ",\"Compressed\":%u", b->sec3.compressed );
  used += fprintf ( out, ",\"Unexpanded descriptors\":%u", b->sec3.ndesc );
  used += fprintf ( out, ",\"Unexpanded array\":" );
 
  used += fprintf ( out,"[" );
  for ( i = 0; i < b->sec3.ndesc; i++ )
    {
      if ( i )
        used += fprintf ( out,"," );
      used += fprintf ( out, "{\"%u\":\"%u %02u %03u\"}", i, b->sec3.unexpanded[i].f, b->sec3.unexpanded[i].x, b->sec3.unexpanded[i].y );
    }
  used += fprintf ( out,"]}}" );
 
  return used;
}

References bufrdeco_assert, bufr_sec3::compressed, bufr_descriptor::f, bufr_sec3::length, bufr_sec3::ndesc, bufr_sec3::observed, bufrdeco::sec3, bufr_sec3::subsets, bufr_sec3::unexpanded, bufr_descriptor::x, and bufr_descriptor::y.

Referenced by bufrdeco_read_buffer().

Here is the caller graph for this function:

bufrdeco_print_json_separator()

buf_t bufrdeco_print_json_separator

(

FILE *

out

)

Print the comma ',' separator in an output.

Parameters

out	string where to print

Returns

The amount of bytes sent to out

Definition at line 267 of file bufrdeco_json.c.

{
  return fprintf ( out, "," );
}

Referenced by bufr_decode_subset_data_compressed(), bufrdeco_decode_replicated_subsequence(), bufrdeco_decode_subset_data_recursive(), and bufrdeco_parse_f2_descriptor().

Here is the caller graph for this function:

bufrdeco_print_json_sequence_descriptor_final()

buf_t bufrdeco_print_json_sequence_descriptor_final

(

FILE *

out

)

Definition at line 110 of file bufrdeco_json.c.

{
  buf_t used = 0;
  // print final
  used += fprintf ( out,  "]}" );
  return used;
}

Referenced by bufr_decode_subset_data_compressed(), and bufrdeco_decode_subset_data_recursive().

Here is the caller graph for this function:

bufrdeco_print_json_sequence_descriptor_header()

buf_t bufrdeco_print_json_sequence_descriptor_header	(	FILE *	out,
		struct bufr_sequence *	seq
	)

Print the header of a sequence descriptor (f == 3)

Parameters

out	output stream opened by caller
seq	pointer to a bufr_sequence bufr_sequence

Returns

The amount of bytes sent to out

Definition at line 94 of file bufrdeco_json.c.

{
  buf_t used = 0;
 
  used += fprintf ( out, "{\"Descriptor\":\"%c %c%c %c%c%c\",", seq->key[0], seq->key[1], seq->key[2], seq->key[3], seq->key[4], seq->key[5] );
  used += fprintf ( out, "\"Sequence description\":\"%s\",\"Expanded sequence\":[", seq->name );
  return used;
}

References bufr_sequence::key, and bufr_sequence::name.

Referenced by bufr_decode_subset_data_compressed(), and bufrdeco_decode_subset_data_recursive().

Here is the caller graph for this function:

bufrdeco_print_json_subset_data_epilogue()

buf_t bufrdeco_print_json_subset_data_epilogue

(

FILE *

out

)

Definition at line 77 of file bufrdeco_json.c.

{
  buf_t used = 0;
 
  // print prologue
  used += fprintf ( out, "}\n" );
  return used;
}

Referenced by bufr_decode_subset_data_compressed(), and bufrdeco_decode_subset_data_recursive().

Here is the caller graph for this function:

bufrdeco_print_json_subset_data_prologue()

buf_t bufrdeco_print_json_subset_data_prologue	(	FILE *	out,
		struct bufrdeco *	b
	)

Definition at line 58 of file bufrdeco_json.c.

{
  buf_t used = 0;
 
  bufrdeco_assert ( b != NULL );
 
  // print prologue
  used += fprintf ( out, "{\"BUFR File\":\"%s\",\"Subset\":%u,\"Decoded data\":",b->header.filename, b->seq.ss );
 
  return used;
}

References bufrdeco_assert, gts_header::filename, bufrdeco::header, bufrdeco::seq, and bufrdeco_subset_sequence_data::ss.

Referenced by bufr_decode_subset_data_compressed(), and bufrdeco_decode_subset_data_recursive().

Here is the caller graph for this function:

bufrdeco_print_json_tree()

buf_t bufrdeco_print_json_tree

(

struct bufrdeco *

b

)

Definition at line 508 of file bufrdeco_json.c.

{
  buf_t used = 0;
  bufrdeco_assert ( b != NULL );
 
  if ( b->mask & BUFRDECO_OUTPUT_JSON_EXPANDED_TREE )
    used += bufrdeco_print_json_tree_recursive ( b->out, b, NULL );
  return used;
};

References bufrdeco_assert, BUFRDECO_OUTPUT_JSON_EXPANDED_TREE, bufrdeco_print_json_tree_recursive(), bufrdeco::mask, and bufrdeco::out.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_print_json_tree_recursive()

int bufrdeco_print_json_tree_recursive	(	FILE *	out,
		struct bufrdeco *	b,
		struct bufr_sequence *	seq
	)

Print a tree of descriptors to a file in a recursive way in json format.

Parameters

out	stream opened by caller
b	pointer to the basic container struct bufrdeco
seq	pointer to the struct bufr_sequence to print

Returns

The amount of bytes sent to out

Definition at line 405 of file bufrdeco_json.c.

{
  buf_t i, k, used = 0;
  struct bufr_sequence *l;
  char explanation[256];
 
  bufrdeco_assert ( out != NULL && b != NULL );
 
  if ( seq == NULL )
    {
      l = & ( b->tree->seq[0] );
    }
  else
    {
      l = seq;
    }
 
  // begins the array
  for ( i = 0; i < l->ndesc; i++ )
    {
      if ( i )
        used += fprintf ( out, "," );
      fprintf ( out,  "{\"%u %02u %03u\"", l->lseq[i].f, l->lseq[i].x,l->lseq[i].y );
 
      if ( l->lseq[i].f != 3 )
        {
          if ( l->lseq[i].f == 0 )
            {
              if ( bufr_find_tableB_index ( &k, & ( b->tables->b ), l->lseq[i].c ) )
                used += fprintf ( out, "\"Not found in tables\"}" );
              else
                {
                  used += fprintf ( out, ":\"" );
                  if ( l->replicated[i] )
                    {
                      if ( l->replicated[i] )
                        {
                          if ( l->replicated[i] == 1 )
                            used += fprintf ( out, "Replicated | " );
                          else
                            used += fprintf ( out, "Replicated depth %u | ", l->replicated[i] );
                        }
                    }
                  if ( is_a_delayed_descriptor ( & l->lseq[i] ) ||
                       is_a_short_delayed_descriptor ( & l->lseq[i] ) )
                    used += fprintf ( out, "* %s\"}", b->tables->b.item[k].name );
                  else
                    used += fprintf ( out, "%s\"}", b->tables->b.item[k].name );
                }
            }
          else if ( l->lseq[i].f == 2 )
            {
              used += fprintf ( out, ":\"%s\"}", bufrdeco_get_f2_descriptor_explanation ( explanation, sizeof ( explanation ), & ( l->lseq[i] ) ) );
            }
          else if ( l->lseq[i].f == 1 )
            {
              if ( l->lseq[i].y == 0 )
                {
                  if ( l->lseq[i].x == 1 )
                    used += fprintf ( out, ":\"* Replicator for %d descriptor after next delayed descriptor which set the number of replications.\"}", l->lseq[i].x );
                  else
                    used += fprintf ( out, ":\"* Replicator for %d descriptors after next delayed descriptor which set the number of replications.\"}", l->lseq[i].x );
                }
              else
                {
                  if ( l->lseq[i].x == 1 )
                    used += fprintf ( out, ":\"* Replicator for next descriptor %d times\"}", l->lseq[i].y );
                  else
                    used += fprintf ( out, ":\"* Replicator for next %d descriptors %d times\"}", l->lseq[i].x, l->lseq[i].y );
                }
            }
          else
            used += fprintf ( out, "\n" );
          continue;
        }
      else
        {
          // f == 3
          used += fprintf ( out, ":\"" );
          if ( l->replicated[i] )
            {
              if ( l->replicated[i] == 1 )
                used += fprintf ( out, "Replicated | " );
              else
                used += fprintf ( out, "Replicated depth %u | ", l->replicated[i] );
            }
          used += fprintf ( out, "%s\"", bufr_adjust_string ( l->name ) );
          used += fprintf ( out, ",\"Expanded\":[" );
          // parse de son
          used += bufrdeco_print_json_tree_recursive ( out, b, l->sons[i] );
          used += fprintf ( out, "]}" );
          // we then recursively parse the son
        }
    }
  return used;
}

References bufr_tables::b, bufr_adjust_string(), bufr_find_tableB_index(), bufrdeco_assert, bufrdeco_get_f2_descriptor_explanation(), bufrdeco_print_json_tree_recursive(), bufr_descriptor::c, bufr_descriptor::f, is_a_delayed_descriptor(), is_a_short_delayed_descriptor(), bufr_tableB::item, bufr_sequence::lseq, bufr_sequence::name, bufr_tableB_decoded_item::name, bufr_sequence::ndesc, bufr_sequence::replicated, bufrdeco_expanded_tree::seq, bufr_sequence::sons, bufrdeco::tables, bufrdeco::tree, bufr_descriptor::x, and bufr_descriptor::y.

Referenced by bufrdeco_print_json_tree(), and bufrdeco_print_json_tree_recursive().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_print_subset_sequence_data()

int bufrdeco_print_subset_sequence_data

(

struct bufrdeco_subset_sequence_data *

s

)

Prints a struct bufrdeco_subset_sequence_data.

Parameters

s	pointer to the struct to print

Returns

If succeeded return 0

Definition at line 545 of file bufrdeco_print.c.

{
  bufrdeco_assert ( s != NULL );
  return bufrdeco_fprint_subset_sequence_data ( stdout, s );
}

References bufrdeco_assert, and bufrdeco_fprint_subset_sequence_data().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_print_subset_sequence_data_html()

int bufrdeco_print_subset_sequence_data_html

(

struct bufrdeco_subset_sequence_data *

s

)

Definition at line 265 of file bufrdeco_print_html.c.

{
  bufrdeco_assert ( s != NULL );
  
  return bufrdeco_fprint_subset_sequence_data_html ( stdout, s );
}

References bufrdeco_assert, and bufrdeco_fprint_subset_sequence_data_html().

Here is the call graph for this function:

bufrdeco_print_subset_sequence_data_tagged_html()

int bufrdeco_print_subset_sequence_data_tagged_html	(	struct bufrdeco_subset_sequence_data *	s,
		char *	id
	)

Definition at line 306 of file bufrdeco_print_html.c.

{
  bufrdeco_assert ( s != NULL );
  
  return bufrdeco_fprint_subset_sequence_data_tagged_html ( stdout, s, id );
}

References bufrdeco_assert, and bufrdeco_fprint_subset_sequence_data_tagged_html().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_print_tree()

int bufrdeco_print_tree

(

struct bufrdeco *

b

)

Print a tree of descriptors.

Parameters

b	pointer to a basic container struct bufrdeco

Returns

The amount of bytes sent to out

Parameters

b	pointer to a basic container struct bufrdeco

Returns

If succeeded return 0

Definition at line 381 of file bufrdeco_print.c.

{
  bufrdeco_assert ( b != NULL );
 
  if ( b->mask & BUFRDECO_OUTPUT_HTML )
    printf ( "<pre>\n" );
  bufrdeco_fprint_tree_recursive ( stdout, b, NULL );
  if ( b->mask & BUFRDECO_OUTPUT_HTML )
    printf ( "</pre>\n" );
  else
    printf ( "\n" );
  return 0;
};

References bufrdeco_assert, bufrdeco_fprint_tree_recursive(), BUFRDECO_OUTPUT_HTML, and bufrdeco::mask.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_read_buffer()

int bufrdeco_read_buffer	(	struct bufrdeco *	b,
		uint8_t *	bufrx,
		buf_t	size
	)

Definition at line 225 of file bufrdeco_read.c.

{
  uint8_t *c;
  buf_t ix, ud;
 
  bufrdeco_assert ( b != NULL );
 
  // Some fast checks
  if ( ( size + 4 ) >= BUFR_LEN )
    {
      snprintf ( b->error, sizeof ( b->error ), "%s(): Buffer provided too large. Consider increase BUFR_LEN\n", __func__ );
      return 1;
    }
 
  if ( size < 8 )
    {
      snprintf ( b->error, sizeof ( b->error ), "%s(): Too few bytes for a bufr\n", __func__ );
      return 1;
    }
 
  // check if begins with BUFR
  if ( bufrx[0] != 'B' || bufrx[1] != 'U' || bufrx[2] != 'F' || bufrx[3] != 'R' )
    {
      snprintf ( b->error, sizeof ( b->error ), "%s(): bufr file does not begin with 'BUFR' chars\n", __func__ );
      return 1;
    }
 
  // check if end with '7777'
  if ( bufrx[size - 4] != '7' || bufrx[size - 3] != '7' || bufrx[size - 2] != '7' || bufrx[size - 1] != '7' )
    {
      snprintf ( b->error, sizeof ( b->error ), "%s(): bufe file does not end with '7777' chars\n", __func__ );
      return 1;
    }
 
  /******************* section 0  *****************************/
 
  // we have already checked about begin and end
 
  // length of whole message
  b->sec0.bufr_length = three_bytes_to_uint32 ( &bufrx[4] );
  // check if length is correct
  if ( b->sec0.bufr_length != ( uint32_t ) size )
    {
      snprintf ( b->error, sizeof ( b->error ), "%s(): bufr file have %u bytes and it says %u\n", __func__,
                 ( uint32_t ) size, b->sec0.bufr_length );
      return 1;
    }
 
  // set bufr edition number
  b->sec0.edition = bufrx[7];
 
  if ( b->sec0.edition < 3 )
    {
      snprintf ( b->error, sizeof ( b->error ), "%s(): Bufr edition must be 3 or superior and this file is coded with version %u\n", __func__, b->sec0.edition );
      return 1;
    }
 
  // raw
  memcpy ( &b->sec0.raw[0], &bufrx[0], 8 );
 
  if (b->mask & BUFRDECO_OUTPUT_JSON_SEC0)
    bufrdeco_print_json_sec0(b->out, b);
 
  /******************* section 1 *****************************/
  c = &bufrx[8]; // pointer to begin of sec1
  switch ( b->sec0.edition )
    {
    case 3:
      b->sec1.length = three_bytes_to_uint32 ( c );
      b->sec1.master = c[3];
      b->sec1.subcentre = c[4];
      b->sec1.centre = c[5];
      b->sec1.update = c[6];
      b->sec1.options = c[7];
      b->sec1.category = c[8];
      b->sec1.subcategory = c[9];
      b->sec1.subcategory_local = 0; // not in version 3
      b->sec1.master_version = c[10];
      b->sec1.master_local = c[11];
      if ( c[12] > 80 )
        b->sec1.year = 1900 + c[12];
      else
        b->sec1.year = 2000 + c[12];
      b->sec1.month = c[13];
      b->sec1.day = c[14];
      b->sec1.hour = c[15];
      b->sec1.minute = c[16];
      b->sec1.second = 0; // not in version 3
      break;
    case 4:
      b->sec1.length = three_bytes_to_uint32 ( c );
      b->sec1.master = c[3];
      b->sec1.centre = two_bytes_to_uint32 ( &c[4] );
      b->sec1.subcentre = two_bytes_to_uint32 ( &c[6] );
      b->sec1.update = c[8];
      b->sec1.options = c[9];
      b->sec1.category = c[10];
      b->sec1.subcategory = c[11];
      b->sec1.subcategory_local = c[12];
      b->sec1.master_version = c[13];
      b->sec1.master_local = c[14];
      b->sec1.year = two_bytes_to_uint32 ( &c[15] );
      b->sec1.month = c[17];
      b->sec1.day = c[18];
      b->sec1.hour = c[19];
      b->sec1.minute = c[20];
      b->sec1.second = c[21];
      break;
    default:
      snprintf ( b->error, sizeof ( b->error ), "%s(): This file is coded with version %u and is not supported\n", __func__, b->sec0.edition );
      free ( ( void * ) bufrx );
      return 1;
    }
  memcpy ( b->sec1.raw, c, b->sec1.length ); // raw data
  c += b->sec1.length;
  
  if (b->mask & BUFRDECO_OUTPUT_JSON_SEC1)
    bufrdeco_print_json_sec1(b->out, b);
 
  /******************* section 2 (Optional) ******************/
  if ( b->sec1.options & 0x80 )
    {
      b->sec2.length = three_bytes_to_uint32 ( c );
      memcpy ( b->sec2.raw, c, b->sec2.length );
      c += b->sec2.length;
    }
  if (b->mask & BUFRDECO_OUTPUT_JSON_SEC2)
    bufrdeco_print_json_sec2(b->out, b);
 
  /******************* section 3 *****************************/
  b->sec3.length = three_bytes_to_uint32 ( c );
  b->sec3.subsets = two_bytes_to_uint32 ( &c[4] );
  if ( c[6] & 0x80 )
    b->sec3.observed = 1;
  else
    b->sec3.observed = 0;
  if ( c[6] & 0x40 )
    b->sec3.compressed = 1;
  else
    b->sec3.compressed = 0;
 
  // loop of unexpanded descriptors
  for ( ix = 7, ud = 0; ( ix + 1 ) < b->sec3.length && ud < BUFR_LEN_UNEXPANDED_DESCRIPTOR; ix += 2 )
    {
      two_bytes_to_descriptor ( &b->sec3.unexpanded[ud], &c[ix] );
      if ( b->sec3.unexpanded[ud].f || b->sec3.unexpanded[ud].x || b->sec3.unexpanded[ud].y )
        ud++;
    }
  b->sec3.ndesc = ud;
  memcpy ( b->sec3.raw, c, b->sec3.length );
  c += b->sec3.length;
 
  if (b->mask & BUFRDECO_OUTPUT_JSON_SEC3)
    bufrdeco_print_json_sec3(b->out, b);
 
  /******************* section 4 *****************************/
  b->sec4.length = three_bytes_to_uint32 ( c );
  // we copy 4 byte more without danger because of latest '7777' and to use fastest exctracting bits algorithm
  memcpy ( b->sec4.raw, c, b->sec4.length + 4 );
 
  b->sec4.bit_offset = 32; // the first bit in byte 4
 
#ifdef DEBUG_TIME
  bufrdeco_clock_start = clock();
#endif
 
  if ( bufr_read_tables ( b ) )
    {
      return 1;
    }
#ifdef DEBUG_TIME
  bufrdeco_clock_end = clock();
  print_timing ( bufrdeco_clock_start, bufrdeco_clock_end,bufr_read_tables_wmo() );
#endif
 
  return 0;
}

References bufr_sec4::bit_offset, BUFR_LEN, BUFR_LEN_UNEXPANDED_DESCRIPTOR, bufr_sec0::bufr_length, bufr_read_tables(), bufrdeco_assert, BUFRDECO_OUTPUT_JSON_SEC0, BUFRDECO_OUTPUT_JSON_SEC1, BUFRDECO_OUTPUT_JSON_SEC2, BUFRDECO_OUTPUT_JSON_SEC3, bufrdeco_print_json_sec0(), bufrdeco_print_json_sec1(), bufrdeco_print_json_sec2(), bufrdeco_print_json_sec3(), bufr_sec1::category, bufr_sec1::centre, bufr_sec3::compressed, bufr_sec1::day, bufr_sec0::edition, bufrdeco::error, bufr_descriptor::f, bufr_sec1::hour, bufr_sec1::length, bufr_sec2::length, bufr_sec3::length, bufr_sec4::length, bufrdeco::mask, bufr_sec1::master, bufr_sec1::master_local, bufr_sec1::master_version, bufr_sec1::minute, bufr_sec1::month, bufr_sec3::ndesc, bufr_sec3::observed, bufr_sec1::options, bufrdeco::out, bufr_sec0::raw, bufr_sec4::raw, bufr_sec1::raw, bufr_sec2::raw, bufr_sec3::raw, bufrdeco::sec0, bufrdeco::sec1, bufrdeco::sec2, bufrdeco::sec3, bufrdeco::sec4, bufr_sec1::second, bufr_sec1::subcategory, bufr_sec1::subcategory_local, bufr_sec1::subcentre, bufr_sec3::subsets, three_bytes_to_uint32(), two_bytes_to_descriptor(), two_bytes_to_uint32(), bufr_sec3::unexpanded, bufr_sec1::update, bufr_descriptor::x, bufr_descriptor::y, and bufr_sec1::year.

Referenced by bufrdeco_extract_bufr(), and bufrdeco_read_bufr().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_read_bufr()

int bufrdeco_read_bufr	(	struct bufrdeco *	b,
		char *	filename
	)

Read bufr file and does preliminary and first decode pass.

Parameters

b	pointer to struct bufrdeco
filename	complete path of BUFR file

Returns

0 if all is OK, 1 otherwise

This function does the folowing tasks:

• Read the file and checks the marks at the begining and end to see wheter is a BUFR file
• Init the structs and allocate the needed memory if not done previously
• Splits and parse the BUFR sections (without expanding descriptors nor parsing data)
• Reads the needed Table files and store them in memory.

< pointer to a memory buffer where we write raw bufr file

Definition at line 41 of file bufrdeco_read.c.

{
  int aux, res;
  uint8_t *bufrx = NULL; /*!< pointer to a memory buffer where we write raw bufr file */
  buf_t n = 0;
  FILE *fp;
  struct stat st;
 
  bufrdeco_assert ( b != NULL );
 
  /* Stat input file */
  if ( stat ( filename, &st ) < 0 )
    {
      snprintf ( b->error, sizeof ( b->error ), "%s(): cannot stat file '%s'\n", __func__, filename );
      return 1;
    }
 
  /* Alloc nedeed memory for bufr */
  if ( S_ISREG ( st.st_mode ) || S_ISLNK ( st.st_mode ) )
    {
      if ( ( bufrx = ( uint8_t * ) calloc ( 1, st.st_size + 4 ) ) == NULL )
        {
          snprintf ( b->error, sizeof ( b->error ), "%s(): cannot alloc memory for file '%s'\n", __func__, filename );
          return 1;
        }
    }
  else
    {
      snprintf ( b->error, sizeof ( b->error ), "%s(): '%s' is not a regular file nor symbolic link\n", __func__, filename );
      return 1;
    }
 
  /* Inits bufr struct */
  if ( ( st.st_size + 4 ) >= BUFR_LEN )
    {
      snprintf ( b->error, sizeof ( b->error ), "%s(): File '%s' too large. Consider increase BUFR_LEN\n", __func__, filename );
      free ( ( void * ) bufrx );
      return 1;
    }
 
  // Open and read the file
  if ( ( fp = fopen ( filename, "r" ) ) == NULL )
    {
      snprintf ( b->error, sizeof ( b->error ), "%s(): cannot open file '%s'\n", __func__, filename );
      free ( ( void * ) bufrx );
      return 1;
    }
 
  while ( ( aux = fgetc ( fp ) ) != EOF && ( int ) n < st.st_size )
    bufrx[n++] = ( uint8_t ) aux;
 
  //n = fread(&bufrx[0], 1, st.st_size, fp);
  //bufrdeco_assert(n == (size_t)st.st_size);
 
  // close the file
 
  fclose ( fp );
 
  res = bufrdeco_read_buffer ( b, bufrx, n );
  free ( bufrx );
  return res;
}

References BUFR_LEN, bufrdeco_assert, bufrdeco_read_buffer(), and bufrdeco::error.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_read_subset_offset_bits()

int bufrdeco_read_subset_offset_bits	(	struct bufrdeco *	b,
		char *	filename
	)

Write offset bit array for subsets in a non-compressed bufr.

Parameters

filename	complete path of input file to open
b	pointer to the struct bufrdeco

Returns

1 if problem, 0 otherwise

Definition at line 358 of file bufrdeco.c.

{
  struct stat st;
  FILE *f;
 
  // assert nice args
  bufrdeco_assert_with_return_val ( b != NULL || filename == NULL, 1 );
 
  // silently return if cannot stat the file
  if ( stat ( filename, &st ) < 0 )
    {
      return 1;
    }
 
  // open the file
  f = fopen ( filename, "r" );
  bufrdeco_assert_with_return_val ( f != NULL, 1 );
 
  // Read the offsets
  if ( bufr_read_subset_offset_bits ( f, & ( b->offsets ) ) )
    {
      fclose ( f );
      return 1;
    }
  fclose ( f );
  return 0;
}

References bufr_read_subset_offset_bits(), bufrdeco_assert_with_return_val, and bufrdeco::offsets.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_reset()

int bufrdeco_reset

(

struct bufrdeco *

b

)

Reset an struct bufrdeco. This is needed when changing to another bufr.

Parameters

b	pointer to the target struct to be resed with another bufrfile

This function must be called when parsing another BUFR report without calling bufrdeco_close and bufrdeco_init. It

Returns

If succeeded return 0, otherwise 1

Definition at line 180 of file bufrdeco.c.

{
  struct bufr_tables *tb;
  struct bufr_tables_cache ch;
  FILE *out,*err;
  uint32_t mask;
  bufrdeco_assert ( b != NULL );
 
  // save the data we do not reset
  memcpy(&ch, &b->cache, sizeof (struct bufr_tables_cache));
  tb = b->tables;
  mask = b->mask;
  out = b->out;
  err = b->err;
  bufrdeco_free_subset_sequence_data ( & ( b->seq ) );
  bufrdeco_free_compressed_data_references ( & ( b->refs ) );
  bufrdeco_free_expanded_tree ( & ( b->tree ) );
  bufrdeco_free_bitmap_array ( & ( b->bitmap ) );
 
  memset ( b, 0, sizeof ( struct bufrdeco ) );
  
  // Restore data
  b->out = out;
  b->err = err;
  b->mask = mask;
  b->tables = tb;
  memcpy(&b->cache, &ch, sizeof (struct bufr_tables_cache));
 
  // allocate memory for expanded tree of descriptors
  if ( bufrdeco_init_expanded_tree ( &b->tree ) )
    {
      snprintf ( b->error, sizeof ( b->error ),"%s(): Cannot allocate space for expanded tree of descriptors\n", __func__ );
      return 1;
    }
 
  return 0;
}

References bufrdeco::bitmap, bufrdeco_assert, bufrdeco_free_bitmap_array(), bufrdeco_free_compressed_data_references(), bufrdeco_free_expanded_tree(), bufrdeco_free_subset_sequence_data(), bufrdeco_init_expanded_tree(), bufrdeco::cache, bufrdeco::err, bufrdeco::error, bufrdeco::mask, bufrdeco::out, bufrdeco::refs, bufrdeco::seq, bufrdeco::tables, and bufrdeco::tree.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_set_err_stream()

int bufrdeco_set_err_stream	(	FILE *	err,
		struct bufrdeco *	b
	)

Set the error stream.

Parameters

err	stream opened by caller
b	pointer to current active struct bufrdeco

Returns

If succeeded return 0, otherwise 1

Without calling to this funcion, the default is stderr

Definition at line 242 of file bufrdeco.c.

{
  b->out = err;
  return 0;
}

References bufrdeco::out.

bufrdeco_set_out_stream()

int bufrdeco_set_out_stream	(	FILE *	out,
		struct bufrdeco *	b
	)

Set the library normal output stream.

Parameters

out	stream opened by caller
b	pointer to current active struct bufrdeco

Returns

If succeeded return 0, otherwise 1

Without calling to this funcion, the default is stdout

Definition at line 227 of file bufrdeco.c.

{
  b->out = out;
  return 0;
}

References bufrdeco::out.

bufrdeco_set_tables_dir()

int bufrdeco_set_tables_dir	(	struct bufrdeco *	b,
		char *	tables_dir
	)

Sets the directory path for BUFR tables. Needed if it is not any default directories.

Parameters

b	pointer to the target struct
tables_dir	Source path of tables directory

Returns

1 if problem, 0 otherwise

The default directories are '/usr/share/bufr2synop' and '/usr/local/share/bufr2synop'

Definition at line 291 of file bufrdeco.c.

{
  bufrdeco_assert_with_return_val ( b != NULL || tables_dir == NULL, 1 );
 
  strncpy_safe ( b->bufrtables_dir, tables_dir, BUFRDECO_PATH_LENGTH );
  return 0;
}

References bufrdeco_assert_with_return_val, BUFRDECO_PATH_LENGTH, bufrdeco::bufrtables_dir, and strncpy_safe.

bufrdeco_store_tables()

int bufrdeco_store_tables	(	struct bufr_tables **	t,
		struct bufr_tables_cache *	c,
		uint8_t	ver
	)

Init an element of array c->tab[] if still not allocated. If allocated clean it and set *t pointing to this element.

Parameters

t	pointer to array of struct bufr_tables
c	pointer ti struct bufr_tables_cache
ver	version of tables acting as key

Returns

if success return 0

Definition at line 269 of file bufrdeco_wmo.c.

{
  if ( c->tab[c->next] == NULL )
    {
      // Init the array element
      bufrdeco_init_tables ( & ( c->tab[c->next] ) );
 
      // increase the counter of allocated elements
      ( c->nt )++;
    }
  else
    {
      // Clean the element in array with zeroes
      memset ( c->tab[c->next], 0, sizeof ( struct bufr_tables ) );
 
      // sets the proper version as a key of element
      c->ver[c->next] = ver;
    }
 
  // t will point to array element
  *t = c->tab[c->next];
 
  // Set the member 'next'. It marks the next element in array it will be modified when failing a search in future
  c->next = ( c->next + 1 ) % BUFRDECO_TABLES_CACHE_SIZE;
  return 0;
}

References bufrdeco_init_tables(), BUFRDECO_TABLES_CACHE_SIZE, bufr_tables_cache::next, bufr_tables_cache::nt, bufr_tables_cache::tab, and bufr_tables_cache::ver.

Referenced by bufr_read_tables().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_substitute_tables()

int bufrdeco_substitute_tables	(	struct bufr_tables **	replaced,
		struct bufr_tables *	source,
		struct bufrdeco *	b
	)

substitute an struct bufr_tables into a struct bufrdeco

Parameters

replaced	Pointer where to set the replaced pointer
source	Pointer to a struct bufr_tables
b	pointer to the container basic struct bufrdeco

Returns

0 if succeeded, 1 otherwise

Remember that the struct bufr_tables used in bufrdeco library is the one which pointer is in struct bufrdeco . To avoid problems the struct must be initialized before substituted in this fucntion. Both source and replaced structs are not modified.

This is useful if we do not want to read and parse tables again if the caller has a pool of already readed tables.

Definition at line 116 of file bufrdeco_memory.c.

{
  bufrdeco_assert ( b != NULL );
  
  *replaced = b->tables;
  if ( source == NULL )
    {
      // allocate memory for table
      return bufrdeco_init_tables ( & ( b->tables ) );
    }
  else
    b->tables = source;
  return 0;
}

References bufrdeco_assert, bufrdeco_init_tables(), and bufrdeco::tables.

Here is the call graph for this function:

bufrdeco_tableB_compressed()

int bufrdeco_tableB_compressed	(	struct bufrdeco_compressed_ref *	r,
		struct bufrdeco *	b,
		struct bufr_descriptor *	d,
		int	mode
	)

get data from table B when parsing compressed data references

Parameters

r	pointer to a struct bufrdeco_compressed_ref where to set results
b	basic container struct bufrdeco
d	pointer to the reference struct bufr_descriptor
mode	If 0 then we are getting the data itself for a descriptor. If mode = 1 then we are dealing with associated bits

Returns

If succeeded returns 0. If problem returns 1. If mode = 1 and no associated bits returns -1

Definition at line 250 of file bufrdeco_tableB.c.

{
  buf_t i;
  uint32_t ival;
  uint8_t has_data;
  struct bufr_tableB *tb;
  
  bufrdeco_assert ( b != NULL && r != NULL && d != NULL );
  
  tb = & ( b->tables->b );
 
  // if mode 1 then we search for associated_bits
  if ( mode && b->state.assoc_bits == 0 )
    {
      // This is not an associated field, return -1
      return -1;
    }
 
  if ( mode )
    {
      r->is_associated = 1; // Mark this reference as asociated
    }
 
  if ( is_a_local_descriptor ( d ) )
    {
      // if is a local descriptor we just skip the needed bits signified by operator 2 06 YYY
      // we assign ref = 0 and ref0 as readed reserved bits. We also will assume escale = 0
      r->desc = d;
      r->bits = b->state.local_bit_reserved;
      r->bit0 = b->state.bit_offset; // OFFSET
      strcpy_safe ( r->name, "LOCAL DESCRIPTOR" );
      strcpy_safe ( r->unit, "UNKNOWN" );
 
      // get bits for ref0
      if ( get_bits_as_uint32_t ( &r->ref0, &r->has_data, &b->sec4.raw[4], & ( b->state.bit_offset ),
                                  b->state.local_bit_reserved ) == 0 )
        {
          snprintf (b->error, sizeof (b->error), "%s(): Cannot get bits from '%s'\n", __func__, d->c );
          return 1;
        }
 
      // and get 6 bits for inc_bits
      if ( get_bits_as_uint32_t ( &ival, &has_data, &b->sec4.raw[4], & ( b->state.bit_offset ), 6 ) == 0 )
        {
          snprintf (b->error, sizeof (b->error), "%s(): Cannot get 6 bits for inc_bits from '%s'\n", __func__, d->c );
          return 1;
        }
 
      r->escale = 0;
      r->inc_bits = ( uint8_t ) ival; // set the inc_bits
      // Update the bit offset
      b->state.bit_offset += r->inc_bits * b->sec3.subsets;
      b->state.local_bit_reserved = 0; // Clean the reserved bits
 
      // All is done for this local descriptor
      return 0;
    }
 
  // build the index for tableB
  i = tb->x_start[d->x] + tb->y_ref[d->x][d->y];
 
  // copy the descriptor to reference member desc
  r->desc = d;
  r->ref = tb->item[i].reference_ori; // copy the reference value from tableB, first from original
  r->bits = tb->item[i].nbits + b->state.added_bit_length; // copy the bits from tableB
  r->escale = tb->item[i].scale; // copy the scale from Tableb
  strcpy_safe ( r->name, tb->item[i].name ); // copy the name
  strcpy_safe ( r->unit, tb->item[i].unit ); // copy the unit name
 
  // Add the added_scaled if not flag or code table
  if ( strstr ( r->unit, "CODE TABLE" ) != r->unit &&  strstr ( r->unit,"FLAG" ) != r->unit &&
       strstr ( r->unit, "Code table" ) != r->unit &&  strstr ( r->unit,"Flag" ) != r->unit )
    {
      r->escale += b->state.added_scale;
    }
  r->bit0 = b->state.bit_offset; // Sets the reference offset to current state offset
  r->cref0[0] = '\0'; // default
  r->ref0 = 0 ; // default
 
  // check if is changing reference then we change reference value
  if ( b->state.changing_reference != 255 )
    {
      // The descriptor operator 2 03 YYY is on action
      // get the bits
      if ( get_bits_as_uint32_t ( &ival, &r->has_data, &b->sec4.raw[4], & ( b->state.bit_offset ), b->state.changing_reference ) == 0 )
        {
          snprintf (b->error, sizeof (b->error), "%s(): Cannot get bits from '%s'\n", __func__, d->c );
          return 1;
        }
 
      // Change the new reference value in tableB with value previously readed because of rules for negative numbers
      // (we still have the original value in reference_ori)
      if ( get_table_b_reference_from_uint32_t ( & ( tb->item[i].reference ), b->state.changing_reference, ival ) )
        {
          snprintf (b->error, sizeof (b->error), "%s(): Cannot change reference in 2 03 YYY operator for '%s'\n", __func__, d->c );
          return 1;
        }
        
      strcpy_safe ( r->unit, "NEW REFERENCE" );
      r->ref = tb->item[i].reference;
 
      // extracting inc_bits from next 6 bits
      if ( get_bits_as_uint32_t ( &ival, &has_data, &b->sec4.raw[4], & ( b->state.bit_offset ), 6 ) == 0 )
        {
          snprintf (b->error, sizeof (b->error), "%s(): Cannot get 6 bits for inc_bits from '%s'\n", __func__, d->c );
          return 1;
        }
      // Here is supossed that all subsets will have the same reference change,
      // so inc_bits must be 0 and no inc data should be present
      if ( ival )
        {
          snprintf (b->error, sizeof (b->error), "%s(): Bad format for compressed data when changing reference from '%s'\n", __func__, d->c );
          return 1;
        }
      r->ref0 = 0; // here we also assume that ref0 = 0
      r->inc_bits = 0;
      return 0;
    }
 
  if ( strstr ( r->unit, "CCITT" ) != NULL )
    {
      // Case of CCITT string as unit
 
      if ( b->state.fixed_ccitt != 0 ) // can be changed by 2 08 YYY operator
        r->bits = 8 * b->state.fixed_ccitt;
 
      if ( get_bits_as_char_array ( r->cref0, &r->has_data, &b->sec4.raw[4], & ( b->state.bit_offset ), r->bits ) == 0 )
        {
          snprintf (b->error, sizeof (b->error), "%s(): Cannot get uchars from '%s'\n", __func__, d->c );
          return 1;
        }
      // extracting inc_bits from next 6 bits
      if ( get_bits_as_uint32_t ( &ival, &has_data, &b->sec4.raw[4], & ( b->state.bit_offset ), 6 ) == 0 )
        {
          snprintf (b->error, sizeof (b->error), "%s(): Cannot get 6 bits for inc_bits from '%s'\n", __func__, d->c );
          return 1;
        }
      r->inc_bits = ival;
      r->ref0 = 0;
 
      // Set the bit_offset after all bits needed by this element in all subsets
      b->state.bit_offset += r->inc_bits * 8 * b->sec3.subsets;
 
      // all is done here !!
      return 0;
    }
 
  // is a numeric field, i.e, a data value, a flag code or a code
  // get reference value
  if ( mode ) // case of associated field
    {
      if ( get_bits_as_uint32_t ( &r->ref0, &r->has_data, &b->sec4.raw[4], & ( b->state.bit_offset ), b->state.assoc_bits ) == 0 )
        {
          snprintf (b->error, sizeof (b->error), "%s(): Cannot get associated bits from '%s'\n", __func__, d->c );
          return 1;
        }
      // patch for delayed descriptor: it allways have data
      if ( is_a_delayed_descriptor ( d ) || is_a_short_delayed_descriptor( d ) )
        r->has_data = 1;
    }
  else // case of data
    {
      if ( get_bits_as_uint32_t ( &r->ref0, &r->has_data, &b->sec4.raw[4], & ( b->state.bit_offset ), r->bits ) == 0 )
        {
          snprintf (b->error, sizeof (b->error), "%s(): Cannot get the data bits from '%s'\n", __func__, d->c );
          return 1;
        }
      // patch for delayed descriptor: it allways have data
      if ( is_a_delayed_descriptor ( d ) || is_a_short_delayed_descriptor ( d ) )
        r->has_data = 1;
    }
 
  // extracting inc_bits from next 6 bits for inc_bits
  if ( get_bits_as_uint32_t ( &ival, &has_data, &b->sec4.raw[4], & ( b->state.bit_offset ), 6 ) == 0 )
    {
      snprintf (b->error, sizeof (b->error), "%s(): Cannot get 6 bits for inc_bits from '%s'\n", __func__, d->c );
      return 1;
    }
  r->inc_bits = ival;
 
  // if is a delayed descriptor then inc_bits MUST be 0.
  if ( (is_a_delayed_descriptor ( d ) || is_a_short_delayed_descriptor( d ) ) && r->inc_bits )
    {
      snprintf (b->error, sizeof (b->error), "%s(): Found a delayed descriptor with inc_bits != 0\n", __func__ );
      return 1;
    }
    
  // Set the bit_offset after all bits needed by this element in all subsets
  b->state.bit_offset += r->inc_bits * b->sec3.subsets;
 
  return 0;
}

References bufrdeco_decoding_data_state::added_bit_length, bufrdeco_decoding_data_state::added_scale, bufrdeco_decoding_data_state::assoc_bits, bufr_tables::b, bufrdeco_compressed_ref::bit0, bufrdeco_decoding_data_state::bit_offset, bufrdeco_compressed_ref::bits, bufrdeco_assert, bufr_descriptor::c, bufrdeco_decoding_data_state::changing_reference, bufrdeco_compressed_ref::cref0, bufrdeco_compressed_ref::desc, bufrdeco::error, bufrdeco_compressed_ref::escale, bufrdeco_decoding_data_state::fixed_ccitt, get_bits_as_char_array(), get_bits_as_uint32_t(), get_table_b_reference_from_uint32_t(), bufrdeco_compressed_ref::has_data, bufrdeco_compressed_ref::inc_bits, is_a_delayed_descriptor(), is_a_local_descriptor(), is_a_short_delayed_descriptor(), bufrdeco_compressed_ref::is_associated, bufr_tableB::item, bufrdeco_decoding_data_state::local_bit_reserved, bufrdeco_compressed_ref::name, bufr_tableB_decoded_item::name, bufr_tableB_decoded_item::nbits, bufr_sec4::raw, bufrdeco_compressed_ref::ref, bufrdeco_compressed_ref::ref0, bufr_tableB_decoded_item::reference, bufr_tableB_decoded_item::reference_ori, bufr_tableB_decoded_item::scale, bufrdeco::sec3, bufrdeco::sec4, bufrdeco::state, strcpy_safe, bufr_sec3::subsets, bufrdeco::tables, bufrdeco_compressed_ref::unit, bufr_tableB_decoded_item::unit, bufr_descriptor::x, bufr_tableB::x_start, bufr_descriptor::y, and bufr_tableB::y_ref.

Referenced by bufrdeco_decode_replicated_subsequence_compressed(), and bufrdeco_parse_compressed_recursive().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_tableB_val()

int bufrdeco_tableB_val	(	struct bufr_atom_data *	a,
		struct bufrdeco *	b,
		struct bufr_descriptor *	d
	)

Get data from a table B descriptor.

Parameters

a	pointer to a struct bufr_atom_data where to set the results
b	pointer to the basic struct bufrdeco
d	pointer to the target descriptor

Returns

0 if success, 1 otherwise

Definition at line 451 of file bufrdeco_tableB.c.

{
  buf_t i, nbits = 0;
  uint32_t ival;
  uint8_t has_data;
  int32_t /*escale = 0,*/ reference = 0;
  struct bufr_tableB *tb;
 
  //bufrdeco_assert ( a != NULL && b != NULL && d != NULL );
  
  tb = & ( b->tables->b );
 
  if ( is_a_local_descriptor ( d ) )
    {
      // if is a local descriptor we just skip the bits signified by operator 2 06 YYY
      a->mask = DESCRIPTOR_IS_LOCAL;
      strcpy_safe ( a->name, "LOCAL DESCRIPTOR" );
      strcpy_safe ( a->unit, "UNKNOWN" );
      if ( get_bits_as_uint32_t ( &ival, &has_data, &b->sec4.raw[4], & ( b->state.bit_offset ), b->state.local_bit_reserved ) == 0 )
        {
          snprintf (b->error, sizeof (b->error), "%s(): Cannot get bits from '%s'\n", __func__, d->c );
          return 1;
        }
      a->val = ival; // we assume escale = 0 and ref = 0
      b->state.local_bit_reserved = 0; // Clean the reserved bits
      return 0;
    }
 
  i = tb->x_start[d->x] + tb->y_ref[d->x][d->y];
 
  memcpy ( & ( a->desc ), d, sizeof ( struct bufr_descriptor ) );
  a->mask = 0;
  strcpy_safe ( a->name, tb->item[i].name );
  strcpy_safe ( a->unit, tb->item[i].unit );
  a->escale = tb->item[i].scale;
 
  // Case of difference statistics active
  if ( b->state.dstat_active )
    nbits = tb->item[i].nbits + 1;
  else
    nbits = tb->item[i].nbits;
 
  if ( b->state.changing_reference != 255 )
    {
      // The descriptor operator 2 03 YYY is on action
      // Get preliminar value
      if ( get_bits_as_uint32_t ( &ival, &has_data, &b->sec4.raw[4], & ( b->state.bit_offset ), b->state.changing_reference ) == 0 )
        {
          snprintf (b->error, sizeof (b->error), "%s(): Cannot get bits from '%s'\n", __func__, d->c );
          return 1;
        }
        
      // Then change the preliminar reference value because of rules for negative numbers
      if ( get_table_b_reference_from_uint32_t ( & ( tb->item[i].reference ), b->state.changing_reference, ival ) )
        {
          snprintf (b->error, sizeof (b->error), "%s(): Cannot change reference in 2 03 YYY operator for '%s'\n", __func__, d->c );
          return 1;
        }
      strcpy_safe ( a->unit, "NEW REFERENCE" );
      a->val = ( double ) tb->item[i].reference;
      return 0;
    }
 
  // case of difference statistics active  
  if ( b->state.dstat_active )
    reference = - ( ( int32_t ) 1 << ( tb->item[i].nbits ) );
  else
    reference = tb->item[i].reference;
 
  //printf(" escale = %d  reference = %d nbits = %lu\n", escale, reference, nbits);
  if ( strstr ( a->unit, "CCITT" ) != NULL )
    {
      if ( b->state.fixed_ccitt != 0 ) // can be changed by 2 08 YYY operator
        nbits = 8 * b->state.fixed_ccitt;
 
      if ( get_bits_as_char_array ( a->cval, &has_data, &b->sec4.raw[4], & ( b->state.bit_offset ), nbits ) == 0 )
        {
          snprintf (b->error, sizeof (b->error), "%s(): Cannot get uchars from '%s'\n", __func__, d->c );
          return 1;
        }
      if ( has_data == 0 )
        {
          a->mask |= DESCRIPTOR_VALUE_MISSING;
        }
      else
        {
          a->mask |= DESCRIPTOR_HAVE_STRING_VALUE;
        }
      return 0;
    }
 
  // is a numeric field, i.e, a data value, a flag code or a code
  // Set associated bits
  if ( b->state.assoc_bits &&
       a->desc.x != 31 &&  // Data description qualifier has not associated bits itself
       get_bits_as_uint32_t ( &a->associated, &has_data, &b->sec4.raw[4], & ( b->state.bit_offset ), b->state.assoc_bits ) == 0 )
    {
      snprintf (b->error, sizeof (b->error), "%s(): Cannot get associated bits from '%s'\n", __func__, d->c );
      return 1;
    }
  else
    {
      a->associated = MISSING_INTEGER;
    }
 
  if ( strstr ( a->unit, "CODE TABLE" ) != a->unit &&  strstr ( a->unit,"FLAG" ) != a->unit &&
       strstr ( a->unit, "Code table" ) != a->unit &&  strstr ( a->unit,"Flag" ) != a->unit )
    {
      // case of numeric, no string nor code nor flag
      nbits += b->state.added_bit_length;
    }
 
  if ( get_bits_as_uint32_t ( &ival, &has_data, &b->sec4.raw[4], & ( b->state.bit_offset ), nbits ) == 0 )
    {
      snprintf (b->error, sizeof (b->error), "%s(): Cannot get bits from '%s'\n", __func__, d->c );
      return 1;
    }
 
  // patch for delayed descriptor: it allways have data
  if ( a->desc.x == 31 )
    has_data = 1;
 
  if ( has_data )
    {
      if ( strstr ( a->unit, "CODE TABLE" ) != a->unit &&  strstr ( a->unit,"FLAG" ) != a->unit &&
           strstr ( a->unit, "Code table" ) != a->unit &&  strstr ( a->unit,"Flag" ) != a->unit )
        {
          a->escale += b->state.added_scale;
          reference += b->state.added_reference;
          if ( b->state.factor_reference > 1 )
            reference *= b->state.factor_reference;
        }
      // Get a numeric number
      if ( a->escale >= 0 && a->escale < 8 )
        {
          a->val = ( double ) ( ( int32_t ) ival + reference ) * pow10neg[ ( size_t ) a->escale];
        }
      else if ( a->escale < 0 && a->escale > -8 )
        {
          a->val = ( double ) ( ( int32_t ) ival + reference ) * pow10pos[ ( size_t ) ( -a->escale )];
        }
      else
        {
          a->val = ( double ) ( ( int32_t ) ival + reference ) * exp10 ( ( double ) ( -a->escale ) );
        }
 
      if ( strstr ( a->unit, "CODE TABLE" ) == a->unit || strstr ( a->unit, "Code table" ) == a->unit )
        {
          ival = ( uint32_t ) ( a->val + 0.5 );
          a->mask |= DESCRIPTOR_IS_CODE_TABLE;
          if ( bufrdeco_explained_table_val ( a->ctable, 256, & ( b->tables->c ), & ( tb->item[i].tableC_ref ), & ( a->desc ), ival ) != NULL )
            {
              a->mask |= DESCRIPTOR_HAVE_CODE_TABLE_STRING;
            }
        }
      else if ( strstr ( a->unit,"FLAG" ) == a->unit || strstr ( a->unit,"Flag" ) == a->unit )
        {
          ival = ( uint32_t ) ( a->val + 0.5 );
          a->mask |= DESCRIPTOR_IS_FLAG_TABLE;
 
          if ( bufrdeco_explained_flag_val ( a->ctable, 256, & ( b->tables->c ), & ( a->desc ), ival, nbits ) != NULL )
            {
              a->mask |= DESCRIPTOR_HAVE_FLAG_TABLE_STRING;
            }
        }
    }
  else
    {
      a->val = MISSING_REAL;
      a->mask |= DESCRIPTOR_VALUE_MISSING;
    }
 
  return 0;
}

References bufrdeco_decoding_data_state::added_bit_length, bufrdeco_decoding_data_state::added_reference, bufrdeco_decoding_data_state::added_scale, bufrdeco_decoding_data_state::assoc_bits, bufr_atom_data::associated, bufr_tables::b, bufrdeco_decoding_data_state::bit_offset, bufrdeco_explained_flag_val(), bufrdeco_explained_table_val(), bufr_descriptor::c, bufr_tables::c, bufrdeco_decoding_data_state::changing_reference, bufr_atom_data::ctable, bufr_atom_data::cval, bufr_atom_data::desc, DESCRIPTOR_HAVE_CODE_TABLE_STRING, DESCRIPTOR_HAVE_FLAG_TABLE_STRING, DESCRIPTOR_HAVE_STRING_VALUE, DESCRIPTOR_IS_CODE_TABLE, DESCRIPTOR_IS_FLAG_TABLE, DESCRIPTOR_IS_LOCAL, DESCRIPTOR_VALUE_MISSING, bufrdeco_decoding_data_state::dstat_active, bufrdeco::error, bufr_atom_data::escale, bufrdeco_decoding_data_state::factor_reference, bufrdeco_decoding_data_state::fixed_ccitt, get_bits_as_char_array(), get_bits_as_uint32_t(), get_table_b_reference_from_uint32_t(), is_a_local_descriptor(), bufr_tableB::item, bufrdeco_decoding_data_state::local_bit_reserved, bufr_atom_data::mask, MISSING_INTEGER, MISSING_REAL, bufr_atom_data::name, bufr_tableB_decoded_item::name, bufr_tableB_decoded_item::nbits, pow10neg, pow10pos, bufr_sec4::raw, bufr_tableB_decoded_item::reference, bufr_tableB_decoded_item::scale, bufrdeco::sec4, bufrdeco::state, strcpy_safe, bufr_tableB_decoded_item::tableC_ref, bufrdeco::tables, bufr_atom_data::unit, bufr_tableB_decoded_item::unit, bufr_atom_data::val, bufr_descriptor::x, bufr_tableB::x_start, bufr_descriptor::y, and bufr_tableB::y_ref.

Referenced by bufrdeco_decode_replicated_subsequence(), and bufrdeco_decode_subset_data_recursive().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_tableD_get_descriptors_array()

int bufrdeco_tableD_get_descriptors_array	(	struct bufr_sequence *	s,
		struct bufrdeco *	b,
		const char *	key
	)

get the descriptors array for a descriptor sequence defined in table D with F = 3

Parameters

s	target struct bufr_sequence
b	pointer to the basic container struct bufrdeco
key	string in the form FXXYYY which is the key of descriptor we want to find out, F = 3

Returns

If the sequence has been filled with success then returns 0, otherwise returns 1

Definition at line 211 of file bufrdeco_tableD.c.

{
  buf_t i, j;
  uint32_t nv, v;
  char *c;
  struct bufr_tableD *td;
 
  bufrdeco_assert ( b != NULL && s != NULL && key != NULL );
  
  td = & ( b->tables->d );
 
  // Reject wrong arguments
  if ( s == NULL || b == NULL || key == NULL )
    {
      snprintf ( b->error, sizeof (b->error),"%s(): Wrong entry arguments\n", __func__ );
      return 1;
    }
 
  // here the calling b item learn where to find table C line
 
  if ( bufr_find_tableD_index ( &i, td, key ) )
    {
      snprintf ( b->error, sizeof (b->error), "%s(): descriptor '%s' not found in table D\n", __func__, key );
      return 1; // descritor not found
    }
 
  // Get the name of common sequence
  if (td->item[i].description[0])
     strcpy(s->name, td->item[i].description);
  else
     s->name[0] = 0;
  
  // reads the amount of possible values
  nv = strtoul ( &td->l[i][7], &c, 10 );
 
  // s->level must be set by caller
  // s->father must be set by caller
 
  s->ndesc = 0;
 
  // read all descriptors
  for ( j = 0; j < nv && ( i + j ) < td->nlines ; j++ )
    {
      v = strtoul ( & ( td->l[i+j][11] ), &c, 10 );
      uint32_t_to_descriptor ( & ( s->lseq[j] ), v );
      ( s->ndesc ) ++;
    }
  // s->sons are not set here
  return 0;
}

References bufr_find_tableD_index(), bufrdeco_assert, bufr_tables::d, bufr_tableD_decoded_item::description, bufrdeco::error, bufr_tableD::item, bufr_tableD::l, bufr_sequence::lseq, bufr_sequence::name, bufr_sequence::ndesc, bufr_tableD::nlines, bufrdeco::tables, and uint32_t_to_descriptor().

Referenced by bufrdeco_parse_tree_recursive().

Here is the call graph for this function:

Here is the caller graph for this function:

bufrdeco_write_subset_offset_bits()

int bufrdeco_write_subset_offset_bits	(	struct bufrdeco *	b,
		char *	filename
	)

Write offset bit array for subsets in a non-compressed bufr.

Parameters

filename	complete path of output file to open
b	pointer to the struct bufrdeco

Returns

1 if problem, 0 otherwise

Definition at line 330 of file bufrdeco.c.

{
  FILE *f;
 
  // assert nice args
  bufrdeco_assert_with_return_val ( b != NULL || filename == NULL, 1 );
 
  // open the file
  f = fopen ( filename, "w" );
  bufrdeco_assert_with_return_val ( f != NULL, 1 );
 
  // Read the offsets
  if ( bufr_write_subset_offset_bits ( f, & ( b->offsets ) ) )
    {
      fclose ( f );
      return 1;
    }
  fclose ( f );
  return 0;
}

References bufr_write_subset_offset_bits(), bufrdeco_assert_with_return_val, and bufrdeco::offsets.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

csv_quoted_string()

char * csv_quoted_string	(	char *	out,
		char *	in
	)

Transform a string to a quoted string to be inserted in a csv file.

Parameters

out	resulting string
in	input string

Returns

If problem returns NULL, otherwise out

Definition at line 48 of file bufrdeco_csv.c.

{
  size_t i = 0, j = 0;
 
  if ( in == NULL || out == NULL)
      return NULL;
 
  if ( in[0] == 0 )
    return in;
 
  out[j++] = '\"';
  while ( in[i] && j < ( CSV_MAXL - 1 )  && i < CSV_MAXL )
    {
      if ( in[i] == '\"' )
        {
          out[j++] = '\"';
          out[j++] = '\"';
          i++;
        }
      else
        out[j++] = in[i++];
    }
  out[j++] = '\"';
  out[j] = 0; // end of string
  return out;
}

References CSV_MAXL.

Referenced by main().

Here is the caller graph for this function:

fprint_bufrdeco_compressed_data_references()

int fprint_bufrdeco_compressed_data_references	(	FILE *	f,
		struct bufrdeco_compressed_data_references *	r
	)

Definition at line 619 of file bufrdeco_print.c.

{
  size_t  i;
  
  bufrdeco_assert ( f != NULL && r != NULL);
 
  for ( i = 0; i < r->nd; i++ )
    fprint_bufrdeco_compressed_ref ( f, & r->refs[i] );
 
  return 0;
}

References bufrdeco_assert, fprint_bufrdeco_compressed_ref(), bufrdeco_compressed_data_references::nd, and bufrdeco_compressed_data_references::refs.

Here is the call graph for this function:

fprint_bufrdeco_compressed_ref()

int fprint_bufrdeco_compressed_ref	(	FILE *	f,
		struct bufrdeco_compressed_ref *	r
	)

prints a struct bufrdeco_compressed_ref

Parameters

f	pointer to a file opened by caller
r	pointer to the struct to print

Returns

If succeeded return 0

Definition at line 558 of file bufrdeco_print.c.

{
  bufrdeco_assert ( f != NULL && r != NULL );
  
  if ((r->mask & BUFRDECO_COMPRESSED_REF_DATA_DESCRIPTOR_BITMASK) == 0)
    return 0;
  
  fprintf ( f, "%s -> A=%u, D=%u, ",r->desc->c,r->is_associated,r->has_data );
  if ( r->cref0[0] == '\0' )
    {
      fprintf ( f, "bits=%2u, ref=%10d, escale=%3d,",  r->bits, r->ref, r->escale );
      fprintf ( f, " bit0=%10u, ref0=%10u, inc_bits=%2u ", r->bit0, r->ref0, r->inc_bits );
      fprintf ( f, "%s %s\n",r->name, r->unit );
    }
  else
    {
      fprintf ( f, "'%s', chars=%3u\n", r->cref0, r->inc_bits );
    }
  return 0;
}

References bufrdeco_compressed_ref::bit0, bufrdeco_compressed_ref::bits, bufrdeco_assert, BUFRDECO_COMPRESSED_REF_DATA_DESCRIPTOR_BITMASK, bufr_descriptor::c, bufrdeco_compressed_ref::cref0, bufrdeco_compressed_ref::desc, bufrdeco_compressed_ref::escale, bufrdeco_compressed_ref::has_data, bufrdeco_compressed_ref::inc_bits, bufrdeco_compressed_ref::is_associated, bufrdeco_compressed_ref::mask, bufrdeco_compressed_ref::name, bufrdeco_compressed_ref::ref, bufrdeco_compressed_ref::ref0, and bufrdeco_compressed_ref::unit.

Referenced by fprint_bufrdeco_compressed_data_references(), and print_bufrdeco_compressed_ref().

Here is the caller graph for this function:

get_bits_as_char_array()

uint32_t get_bits_as_char_array	(	char *	target,
		uint8_t *	has_data,
		uint8_t *	source,
		buf_t *	bit0_offset,
		buf_t	bit_length
	)

Definition at line 86 of file bufrdeco_utils.c.

{
  buf_t i, j, k;
  buf_t nc;
  uint8_t *c;
 
  //bufrdeco_assert (has_data != NULL && source != NULL && target != NULL && bit0_offset != NULL);
 
  if ( bit_length % 8 )
    return 0; // bit_length needs to be divisible by 8
 
  //printf("bit_length=%lu\n", bit_length);
 
  nc = bit_length / 8;
  i = ( *bit0_offset ) % 8;
  k = 8 - i;
  *has_data = 0; // marc if no missing data is present
  for ( j = 0; j < nc ; j++ )
    {
      c = source + ( *bit0_offset )  / 8;
      * ( target + j ) = ( *c & biti[i] );
      if ( i )
        {
          * ( target + j ) <<= i;
          * ( target + j ) |= ( ( * ( c + 1 ) & bitk[i - 1] ) >> k );
        }
      if ( * ( target + j ) != -1 )
        *has_data = 1;
      //printf("%c", * ( target + j ) );
      *bit0_offset += 8; // update bit0_offset
    }
  * ( target + nc ) = '\0';
  return bit_length;
}

References biti, and bitk.

Referenced by bufrdeco_get_atom_data_from_compressed_data_ref(), bufrdeco_parse_f2_compressed(), bufrdeco_parse_f2_descriptor(), bufrdeco_tableB_compressed(), and bufrdeco_tableB_val().

Here is the caller graph for this function:

get_bits_as_uint32_t()

uint32_t get_bits_as_uint32_t	(	uint32_t *	target,
		uint8_t *	has_data,
		uint8_t *	source,
		buf_t *	bit0_offset,
		buf_t	bit_length
	)

Definition at line 182 of file bufrdeco_utils.c.

{
  int i;
  uint8_t *c;
  uint64_t x;
 
  //bufrdeco_assert (has_data != NULL && source != NULL && target != NULL && bit0_offset != NULL);
 
  if ( bit_length > 32 || bit_length == 0 )
    return 0;
 
  if ( bit_length < 8 )
    return get_bits_as_uint32_t2 ( target, has_data, source, bit0_offset, bit_length );
 
  *target = 0;
  *has_data = 0; // marc if no missing data is present
  c = source + ( *bit0_offset ) / 8;
  i = ( *bit0_offset ) % 8;
  x = ( ( uint64_t ) ( *c & biti[i] ) << 32 ) + ( ( uint64_t ) ( * ( c + 1 ) ) << 24 ) + ( ( uint64_t ) ( * ( c + 2 ) ) << 16 ) +
      ( ( uint64_t ) ( * ( c + 3 ) ) << 8 ) + ( uint64_t ) ( * ( c + 4 ) ); // 40 - i bits
  x >>= ( 40 - i - bit_length );
  *target = ( uint32_t ) x;
  if ( ( 1UL << bit_length ) != ( x + 1UL ) )
    *has_data = 1;
 
  *bit0_offset += bit_length; // update bit0_offset
  return bit_length;
}

References biti, and get_bits_as_uint32_t2().

Referenced by bufrdeco_get_atom_data_from_compressed_data_ref(), bufrdeco_parse_f2_compressed(), bufrdeco_tableB_compressed(), and bufrdeco_tableB_val().

Here is the call graph for this function:

Here is the caller graph for this function:

get_formatted_value_from_escale()

char * get_formatted_value_from_escale	(	char *	fmt,
		size_t	dim,
		int32_t	escale,
		double	val
	)

gets a string with formatted value depending of scale

Parameters

fmt	The output target string
dim	Size of available space (bytes) to write the result
escale	value scale in descriptor
val	double to printf

Returns

the resulting fmt string This version use 17 width for number plus a final space

Definition at line 410 of file bufrdeco_utils.c.

{
  char aux[32];
  //bufrdeco_assert (fmt != NULL);
 
  if ( escale >= 0 )
    {
      sprintf ( aux, "%%17.%dlf " , escale );
      snprintf ( fmt, dim, aux, val );
    }
  else
    snprintf ( fmt, dim, "%17.0lf " , val );
  return fmt;
}

Referenced by bufrdeco_print_atom_data(), and bufrdeco_print_atom_data_html().

Here is the caller graph for this function:

get_formatted_value_from_escale2()

char * get_formatted_value_from_escale2	(	char *	fmt,
		size_t	dim,
		int32_t	escale,
		double	val
	)

gets a string with formatted value depending of scale

Parameters

fmt	The output target string
dim	Size of available space (bytes) to write the result
escale	value scale in descriptor
val	double to printf

Returns

the resulting fmt string

Differs from get_formatted_value_from_escale that no blanks are written

Definition at line 436 of file bufrdeco_utils.c.

{
  char aux[32];
  //bufrdeco_assert (fmt != NULL);
 
  if ( escale >= 0 )
    {
      sprintf ( aux, "%%.%dlf" , escale );
      snprintf ( fmt, dim, aux, val );
    }
  else
    snprintf ( fmt, dim, "%.0lf" , val );
  return fmt;
}

Referenced by bufrdeco_print_json_object_atom_data().

Here is the caller graph for this function:

get_table_b_reference_from_uint32_t()

int get_table_b_reference_from_uint32_t	(	int32_t *	target,
		uint8_t	bits,
		uint32_t	source
	)

Get an int32_t from bits according with bufr criteria to change the reference of a descritor. Most significant bit in source is sign.

Parameters

target	int32_t as result
bits	number of bits to consider
source	uint32_T with the data to transform

Returns

If success return 0, 1 otherwise

Definition at line 221 of file bufrdeco_utils.c.

{
  uint32_t mask = 1;
 
  //bufrdeco_assert (target != NULL);
  
 
  if ( bits > 32 || bits == 0 )
    return 1;
 
  if ( bits > 1 )
    mask = ( ( uint32_t ) 1 << ( bits - 1 ) );
 
  if ( mask & source )
    {
      // case of negative number
      *target = - ( int32_t ) ( source - mask );
    }
  else
    *target = ( int32_t ) ( source );
  return 0;
}

Referenced by bufrdeco_tableB_compressed(), and bufrdeco_tableB_val().

Here is the caller graph for this function:

get_wmo_tablenames()

int get_wmo_tablenames

(

struct bufrdeco *

b

)

Get the complete pathnames for WMO csv table files needed by a bufr message.

Parameters

b	pointer for a struct bufrdeco

Returns

if success return 0, otherwise 1

For WMO files this format is adopted BUFR_XX_Y_Z_TableB_en for table B BUFR_XX_Y_Z_CodeFlag for Code table and Flag table. This is equivalent to table C in ECMWF package BUFR_XX_Y_Z_TableD_en for table D

XX is the Version number of master table used Y is the revision (currently ignored) Z is minor revision (currently ignored)

Definition at line 47 of file bufrdeco_wmo.c.

{
  struct stat st;
  char aux[BUFRDECO_PATH_LENGTH - 32];
 
  bufrdeco_assert ( b != NULL );
 
  if ( b->bufrtables_dir[0] == '\0' )
    {
      // try to guess directory
      if ( stat ( DEFAULT_BUFRTABLES_WMO_CSV_DIR1, &st ) )
        {
          if ( stat ( DEFAULT_BUFRTABLES_WMO_CSV_DIR2, &st ) )
            {
              return 1;
            }
          else
            {
              if ( S_ISDIR ( st.st_mode ) )
                {
                  strcpy ( aux, DEFAULT_BUFRTABLES_WMO_CSV_DIR2 );
                }
            }
        }
      else
        {
          if ( S_ISDIR ( st.st_mode ) )
            {
              strcpy ( aux, DEFAULT_BUFRTABLES_WMO_CSV_DIR1 );
            }
        }
    }
  else
    {
      strcpy ( aux, b->bufrtables_dir );
    }
 
  switch ( b->sec1.master_version )
    {
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
    case 11:
    case 12:
    case 13:
      snprintf ( b->tables->b.path, sizeof ( b->tables->b.path ),"%sBUFR_13_0_0_TableB_en.csv", aux );
      snprintf ( b->tables->c.path, sizeof ( b->tables->c.path ),"%sBUFR_13_0_0_TableC_en.csv", aux );
      snprintf ( b->tables->d.path, sizeof ( b->tables->d.path ),"%sBUFR_13_0_0_TableD_en.csv", aux );
      break;
    case 18:
      snprintf ( b->tables->b.path, sizeof ( b->tables->b.path ),"%sBUFR_18_1_0_TableB_en.csv", aux );
      snprintf ( b->tables->c.path, sizeof ( b->tables->c.path ),"%sBUFR_18_1_0_TableC_en.csv", aux );
      snprintf ( b->tables->d.path, sizeof ( b->tables->d.path ),"%sBUFR_18_1_0_TableD_en.csv", aux );
      break;
    case 19:
      snprintf ( b->tables->b.path, sizeof ( b->tables->b.path ),"%sBUFR_19_1_1_TableB_en.csv", aux );
      snprintf ( b->tables->c.path, sizeof ( b->tables->c.path ),"%sBUFR_19_1_1_TableC_en.csv", aux );
      snprintf ( b->tables->d.path, sizeof ( b->tables->d.path ),"%sBUFR_19_1_1_TableD_en.csv", aux );
      break;
    case 22:
      snprintf ( b->tables->b.path, sizeof ( b->tables->b.path ),"%sBUFR_22_0_1_TableB_en.csv", aux );
      snprintf ( b->tables->c.path, sizeof ( b->tables->c.path ),"%sBUFR_22_0_1_TableC_en.csv", aux );
      snprintf ( b->tables->d.path, sizeof ( b->tables->d.path ),"%sBUFR_22_0_1_TableD_en.csv", aux );
      break;
    case 14:
    case 15:
    case 16:
    case 17:
    case 20:
    case 21:
    case 23:
    case 24:
    case 25:
    case 26:
    case 27:
    case 28:
    case 29:
    case 30:
    case 31:
    case 32:
    case 33:
    case 34:
    case 35:
    case 36:
    case 37:
      snprintf ( b->tables->b.path, sizeof ( b->tables->b.path ),"%sBUFR_%d_0_0_TableB_en.csv", aux, b->sec1.master_version );
      snprintf ( b->tables->c.path, sizeof ( b->tables->c.path ),"%sBUFR_%d_0_0_TableC_en.csv", aux, b->sec1.master_version );
      snprintf ( b->tables->d.path, sizeof ( b->tables->d.path ),"%sBUFR_%d_0_0_TableD_en.csv", aux, b->sec1.master_version );
      break;
    case 38:
      snprintf ( b->tables->b.path, sizeof ( b->tables->b.path ),"%sBUFR_%d_1_0_TableB_en.csv", aux, b->sec1.master_version );
      snprintf ( b->tables->c.path, sizeof ( b->tables->c.path ),"%sBUFR_%d_1_0_TableC_en.csv", aux, b->sec1.master_version );
      snprintf ( b->tables->d.path, sizeof ( b->tables->d.path ),"%sBUFR_%d_1_0_TableD_en.csv", aux, b->sec1.master_version );
      break;
    default:
      snprintf ( b->tables->b.path, sizeof ( b->tables->b.path ),"%sBUFR_38_1_0_TableB_en.csv", aux );
      snprintf ( b->tables->c.path, sizeof ( b->tables->c.path ),"%sBUFR_38_1_0_TableC_en.csv", aux );
      snprintf ( b->tables->d.path, sizeof ( b->tables->d.path ),"%sBUFR_38_1_0_TableD_en.csv", aux );
      break;
    }
  return 0;
}

References bufr_tables::b, bufrdeco_assert, BUFRDECO_PATH_LENGTH, bufrdeco::bufrtables_dir, bufr_tables::c, bufr_tables::d, DEFAULT_BUFRTABLES_WMO_CSV_DIR1, DEFAULT_BUFRTABLES_WMO_CSV_DIR2, bufr_sec1::master_version, bufr_tableB::path, bufr_tableC::path, bufr_tableD::path, bufrdeco::sec1, and bufrdeco::tables.

Referenced by bufr_read_tables().

Here is the caller graph for this function:

is_a_delayed_descriptor()

int is_a_delayed_descriptor

(

struct bufr_descriptor *

d

)

check if a descriptor is a delayed descriptor

Parameters

d	pointer to a struct bufr_descriptor to check

Returns

If is a delayed desccriptor return 1, 0 otherwise.

Definition at line 351 of file bufrdeco_utils.c.

{
  //bufrdeco_assert (d != NULL);
  
  if ( ( d->f == 0 ) &&
       ( d->x == 31 ) &&
       ( d->y == 1 || d->y == 2 || d->y == 11 || d->y == 12 ) )
    return 1;
  else
    return 0;
}

References bufr_descriptor::f, bufr_descriptor::x, and bufr_descriptor::y.

Referenced by bufrdeco_fprint_tree_recursive(), bufrdeco_print_json_tree_recursive(), and bufrdeco_tableB_compressed().

Here is the caller graph for this function:

is_a_local_descriptor()

int is_a_local_descriptor

(

struct bufr_descriptor *

d

)

check if a descriptor is a local descriptor

Parameters

d	pointer to a struct bufr_descriptor to check

Returns

If is a local desccriptor return 1, 0 otherwise.

Definition at line 388 of file bufrdeco_utils.c.

{
  //bufrdeco_assert (d != NULL);
 
  if ( ( d->f == 0 ) &&
       ( d->x >= 48 ) &&
       ( d->x <= 63 ) )
    return 1;
  else
    return 0;
}

References bufr_descriptor::f, and bufr_descriptor::x.

Referenced by bufrdeco_get_atom_data_from_compressed_data_ref(), bufrdeco_tableB_compressed(), and bufrdeco_tableB_val().

Here is the caller graph for this function:

is_a_short_delayed_descriptor()

int is_a_short_delayed_descriptor

(

struct bufr_descriptor *

d

)

check if a descriptor is a short delayed descriptor

Parameters

d	pointer to a struct bufr_descriptor to check

Returns

If is a delayed descriptor return 1, 0 otherwise.

Definition at line 369 of file bufrdeco_utils.c.

{
  //bufrdeco_assert (d != NULL);
 
  if ( ( d->f == 0 ) &&
       ( d->x == 31 ) &&
       ( d->y == 0 ) )
    return 1;
  else
    return 0;
}

References bufr_descriptor::f, bufr_descriptor::x, and bufr_descriptor::y.

Referenced by bufrdeco_fprint_tree_recursive(), bufrdeco_print_json_tree_recursive(), and bufrdeco_tableB_compressed().

Here is the caller graph for this function:

parse_csv_line()

int parse_csv_line	(	int *	nt,
		char *	tk[],
		char *	lin
	)

Parse a csv line.

Parameters

nt	pointer to a integer. On success is the number of items found
tk	array of pointers. Every pointer is a item on success
lin	input line which is modified in this routine to be splitted into items

Returns

On success return 0, otherwise -1

This is an optimization of routine parse_csv_line2(). Here we suppose: -All no void items are closed between "" and separed by comas ',' -No " in items. -No blank spaces at the end nor begin of items

NOTE that input line is modified

Definition at line 258 of file bufrdeco_csv.c.

{
  char *cq[CSV_MAXL / 4], *cc[CSV_MAXL / 4], *c0;
  buf_t nc, nq, i, j;
 
  //bufrdeco_assert (lin != NULL && tk != NULL && nt != NULL);
  
  *nt = 0;
 
  // clean final new line)
  if ((c0 = strchr(lin, CSV_FINAL)) != NULL)
    *c0 = '\0';
 
  c0 = lin;
  nq = 0;
  while (c0 != NULL && *c0  && nq < (CSV_MAXL / 4))
  {
      if ((c0 = strchr(c0, CSV_CITE)) != NULL)
     {
       cq[nq++] = c0++;
     }
  }
 
  if (nq % 2)
    return -1; // Problem, number of quotes are non paired
 
  c0 = lin;  
  nc = 0;
  while (c0 != NULL && *c0 && nc < (CSV_MAXL / 4))
  {
     if ((c0 = strchr(c0, CSV_SEPARATOR)) != NULL)
     {
        j = 0;
        if (nq)
        {
          for (; j < nq ; j+=2)
            if ((cq[j] < c0) && (c0 < cq[j + 1]))
            {
              j = nq;// is a comma between two cites. Ignored
              c0++;
            }
        }
        if (j == nq)
        {
           // is a comma between two items.
           cc[nc++] = c0++;
        }
     }
  }
 
  // Now go to tokens, in this pass, still CSV_CITE are in items
  c0 = lin;
  if (nc == 0)
    tk[(*nt)++] = c0;
  else
  {
    for (i = 0; i < nc; i++)
    {
      if (cc[i] == c0)
      {
        tk[(*nt)++] = c0;
        *(c0) = '\0';
        c0++;
      }
      else
      {
        tk[(*nt)++] = c0;
        *(cc[i]) = '\0';
        c0 = cc[i] + 1;
      }
    }
  } 
  tk[(*nt)++] = c0;
  
  // fix the tokens supresing the first CSV_CITE if any
  for (i = 0; i < (buf_t)(*nt); i++)
  {
    if( *(tk[i]) == CSV_CITE)
      (tk[i])++;
  }
  
  // And then supress all CSV_CITE (also in the end of every item)
  for (i = 0; i < nq ; i++)
    *(cq[i]) = '\0';
  
  return 0;
}

References CSV_CITE, CSV_FINAL, CSV_MAXL, and CSV_SEPARATOR.

Referenced by bufr_read_tableB(), bufr_read_tableC(), bufr_read_tableD(), and main().

Here is the caller graph for this function:

print_bufrdeco_compressed_data_references()

int print_bufrdeco_compressed_data_references

(

struct bufrdeco_compressed_data_references *

r

)

prints a struct bufrdeco_compressed_references

Parameters

r	pointer to the struct to print

Returns

If succeeded return 0, 1 otherwise

It is used mainly in debug stage

Definition at line 600 of file bufrdeco_print.c.

{
  size_t  i;
  bufrdeco_assert ( r != NULL );
 
  for ( i = 0; i < r->nd; i++ )
    print_bufrdeco_compressed_ref ( & r->refs[i] );
 
  return 0;
}

References bufrdeco_assert, bufrdeco_compressed_data_references::nd, print_bufrdeco_compressed_ref(), and bufrdeco_compressed_data_references::refs.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

print_bufrdeco_compressed_ref()

int print_bufrdeco_compressed_ref

(

struct bufrdeco_compressed_ref *

r

)

prints a struct bufrdeco_compressed_ref

Parameters

r	pointer to the struct to print

Returns

If succeeded return 0

Definition at line 585 of file bufrdeco_print.c.

{
  bufrdeco_assert ( r != NULL );
  
  return fprint_bufrdeco_compressed_ref ( stdout, r );
}

References bufrdeco_assert, and fprint_bufrdeco_compressed_ref().

Referenced by print_bufrdeco_compressed_data_references().

Here is the call graph for this function:

Here is the caller graph for this function:

print_sec0_info()

int print_sec0_info

(

struct bufrdeco *

b

)

Prints info from sec0.

Parameters

b	pointer to the source struct bufrdeco

Returns

If succeeded return 0

Definition at line 62 of file bufrdeco_print.c.

{
  char caux[512];
 
  bufrdeco_assert ( b != NULL );
 
  caux[0] = 0;
  sprint_sec0_info ( caux, 512, b );
  printf ( "%s", caux );
  return 0;
}

References bufrdeco_assert, and sprint_sec0_info().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

print_sec1_info()

int print_sec1_info

(

struct bufrdeco *

b

)

Prints info from sec1.

Parameters

b	pointer to the source struct bufrdeco

Returns

If succeeded return 0, 1 otherwise

Definition at line 135 of file bufrdeco_print.c.

{
  char caux[2048];
 
  bufrdeco_assert ( b != NULL );
 
  caux[0] = 0;
  sprint_sec1_info ( caux, 2048, b );
  printf ( "%s", caux );
  return 0;
}

References bufrdeco_assert, and sprint_sec1_info().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

print_sec3_info()

int print_sec3_info

(

struct bufrdeco *

b

)

Prints info from sec3.

Parameters

b	pointer to the source struct bufrdeco

Returns

If succeeded return 0

Definition at line 192 of file bufrdeco_print.c.

{
  char caux[8192];
 
  bufrdeco_assert ( b != NULL );
 
  caux[0] = 0;
  sprint_sec3_info ( caux, 8192, b );
  printf ( "%s", caux );
  return 0;
}

References bufrdeco_assert, and sprint_sec3_info().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

print_sec4_info()

int print_sec4_info

(

struct bufrdeco *

b

)

Prints info from sec3.

Parameters

b	pointer to the source struct bufrdeco

Returns

If succeeded return 0

Definition at line 239 of file bufrdeco_print.c.

{
  char caux[8192];
 
  bufrdeco_assert ( b != NULL );
 
  caux[0] = 0;
  sprint_sec4_info ( caux, 8192, b );
  printf ( "%s", caux );
  return 0;
}

References bufrdeco_assert, and sprint_sec4_info().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

sprint_sec0_info()

int sprint_sec0_info	(	char *	target,
		size_t	lmax,
		struct bufrdeco *	b
	)

Prints info from sec0.

Parameters

target	string target
lmax	available size in target
b	pointer to the source struct bufrdeco

Returns

If succeeded return 0, otherwise 1

Definition at line 35 of file bufrdeco_print.c.

{
  size_t used = 0;
 
  bufrdeco_assert ( b != NULL );
 
  if ( lmax == 0 || target == NULL )
    {
      snprintf ( b->error, sizeof ( b->error ), "%s(): Unspected NULL argument(s)\n", __func__ );
      return 1;
    }
    
  if ( b->mask & BUFRDECO_OUTPUT_HTML )
    return sprint_sec0_info_html ( target, lmax, b );
 
  used += snprintf ( target + used, lmax - used, "#### SEC 0 INFO ###\n" );
  used += snprintf ( target + used, lmax - used, "Bufr length:           %5u\n", b->sec0.bufr_length );
  used += snprintf ( target + used, lmax - used, "Bufr edition:          %5u\n", b->sec0.edition );
  return 0;
}

References bufr_sec0::bufr_length, bufrdeco_assert, BUFRDECO_OUTPUT_HTML, bufr_sec0::edition, bufrdeco::error, bufrdeco::mask, bufrdeco::sec0, and sprint_sec0_info_html().

Referenced by print_sec0_info().

Here is the call graph for this function:

Here is the caller graph for this function:

sprint_sec0_info_html()

void sprint_sec0_info_html	(	char *	target,
		size_t	lmax,
		struct bufrdeco *	b
	)

Prints info from sec0 in html format.

Parameters

target	string target
lmax	available size in target
b	pointer to the source struct bufrdeco

Returns

If succeeded return 0

Definition at line 34 of file bufrdeco_print_html.c.

{
  size_t used = 0;
 
  bufrdeco_assert ( b != NULL && lmax != 0 && target != NULL );
  
  used += snprintf ( target + used, lmax - used, "<table class='bufr_sec0'>\n<caption>SEC 0 INFO</caption>\n" );
  used += snprintf ( target + used, lmax - used, "<tr><td>Bufr length</td><td>%5u</td></tr>\n", b->sec0.bufr_length );
  used += snprintf ( target + used, lmax - used, "<tr><td>Bufr edition</td><td>%5u</td></tr>\n", b->sec0.edition );
  used += snprintf ( target + used, lmax - used, "</table>\n" );
  return 0;
}

References bufr_sec0::bufr_length, bufrdeco_assert, bufr_sec0::edition, and bufrdeco::sec0.

Referenced by sprint_sec0_info().

Here is the caller graph for this function:

sprint_sec1_info()

int_bits sprint_sec1_info	(	char *	target,
		size_t	lmax,
		struct bufrdeco *	b
	)

Prints info from sec1.

Parameters

target	string target
lmax	available size in target
b	pointer to the source struct bufrdeco

Returns

If succeeded return 0, 1 otherwise

Definition at line 83 of file bufrdeco_print.c.

{
  size_t used = 0;
  
  bufrdeco_assert ( b != NULL );
 
  if ( lmax == 0 || target == NULL )
    {
      snprintf ( b->error, sizeof ( b->error ), "%s(): Unspected NULL argument(s)\n", __func__ );
      return 1;
    }
 
  if ( b->mask & BUFRDECO_OUTPUT_HTML )
    return sprint_sec1_info_html ( target, lmax, b );
 
  used += snprintf ( target + used, lmax - used, "\n#### SEC 1 INFO ###\n" );
  used += snprintf ( target + used, lmax - used, "Sec1 length:           %5u\n", b->sec1.length );
  used += snprintf ( target + used, lmax - used, "Bufr master table:     %5u\n", b->sec1.master );
  used += snprintf ( target + used, lmax - used, "Centre:                %5u\n", b->sec1.centre );
  used += snprintf ( target + used, lmax - used, "Sub-Centre:            %5u\n", b->sec1.subcentre );
  used += snprintf ( target + used, lmax - used, "Update sequence:       %5u\n", b->sec1.update );
  used += snprintf ( target + used, lmax - used, "Options:               %5x\n", b->sec1.options );
  used += snprintf ( target + used, lmax - used, "Category:              %5u\n", b->sec1.category );
  used += snprintf ( target + used, lmax - used, "Subcategory:           %5u\n", b->sec1.subcategory );
  used += snprintf ( target + used, lmax - used, "Sub-category local:    %5u\n", b->sec1.subcategory_local );
  used += snprintf ( target + used, lmax - used, "Master table version:  %5u\n", b->sec1.master_version );
  used += snprintf ( target + used, lmax - used, "Master table local:    %5u\n", b->sec1.master_local );
  used += snprintf ( target + used, lmax - used, "Year:                  %5u\n", b->sec1.year );
  used += snprintf ( target + used, lmax - used, "Month:                 %5u\n", b->sec1.month );
  used += snprintf ( target + used, lmax - used, "Day:                   %5u\n", b->sec1.day );
  used += snprintf ( target + used, lmax - used, "Hour:                  %5u\n", b->sec1.hour );
  used += snprintf ( target + used, lmax - used, "Minute:                %5u\n", b->sec1.minute );
  used += snprintf ( target + used, lmax - used, "Second:                %5u\n", b->sec1.second );
  if ( b->sec0.edition == 3 )
    used += snprintf ( target + used, lmax - used, "Aditional space:       %5u\n", b->sec1.length - 17 );
  else
    used += snprintf ( target + used, lmax - used, "Aditional space:       %5u\n", b->sec1.length - 22 );
  if ( b->tables->b.path[0] )
    {
      used += snprintf ( target + used, lmax - used, "Tables used: '%s'\n", b->tables->b.path );
      used += snprintf ( target + used, lmax - used, "             '%s'\n", b->tables->c.path );
      used += snprintf ( target + used, lmax - used, "             '%s'\n", b->tables->d.path );
    }
  return 0;
}

References bufr_tables::b, bufrdeco_assert, BUFRDECO_OUTPUT_HTML, bufr_tables::c, bufr_sec1::category, bufr_sec1::centre, bufr_tables::d, bufr_sec1::day, bufr_sec0::edition, bufrdeco::error, bufr_sec1::hour, bufr_sec1::length, bufrdeco::mask, bufr_sec1::master, bufr_sec1::master_local, bufr_sec1::master_version, bufr_sec1::minute, bufr_sec1::month, bufr_sec1::options, bufr_tableB::path, bufr_tableC::path, bufr_tableD::path, bufrdeco::sec0, bufrdeco::sec1, bufr_sec1::second, sprint_sec1_info_html(), bufr_sec1::subcategory, bufr_sec1::subcategory_local, bufr_sec1::subcentre, bufrdeco::tables, bufr_sec1::update, and bufr_sec1::year.

Referenced by print_sec1_info().

Here is the call graph for this function:

Here is the caller graph for this function:

sprint_sec1_info_html()

int sprint_sec1_info_html	(	char *	target,
		size_t	lmax,
		struct bufrdeco *	b
	)

Prints info from sec1.

Parameters

target	string target
lmax	available size in target
b	pointer to the source struct bufrdeco

Returns

If succeeded return 0

Definition at line 55 of file bufrdeco_print_html.c.

{
  size_t used = 0;
 
  bufrdeco_assert ( b != NULL && lmax != 0 && target != NULL );
 
  used += snprintf ( target + used , lmax - used,"<div class='bufr_sec1'>\n" );
  used += snprintf ( target + used , lmax - used,"<table>\n<caption>SEC 1 INFO</caption>\n" );
  used += snprintf ( target + used , lmax - used,"<tr><td>Sec1 length</td><td>%5u</td></tr>\n", b->sec1.length );
  used += snprintf ( target + used , lmax - used,"<tr><td>Bufr master table</td><td>%5u</td></tr>\n", b->sec1.master );
  used += snprintf ( target + used , lmax - used,"<tr><td>Centre</td><td>%5u</td></tr>\n", b->sec1.centre );
  used += snprintf ( target + used , lmax - used,"<tr><td>Sub-Centre</td><td>%5u</td></tr>\n", b->sec1.subcentre );
  used += snprintf ( target + used , lmax - used,"<tr><td>Update sequence</td><td>%5u</td></tr>\n", b->sec1.update );
  used += snprintf ( target + used , lmax - used,"<tr><td>Options</td><td>%5x</td></tr>\n", b->sec1.options );
  used += snprintf ( target + used , lmax - used,"<tr><td>Category</td><td>%5u</td></tr>\n", b->sec1.category );
  used += snprintf ( target + used , lmax - used,"<tr><td>Subcategory</td><td>%5u</td></tr>\n", b->sec1.subcategory );
  used += snprintf ( target + used , lmax - used,"<tr><td>Sub-category local</td><td>%5u</td></tr>\n", b->sec1.subcategory_local );
  used += snprintf ( target + used , lmax - used,"<tr><td>Master table version</td><td>%5u</td></tr>\n", b->sec1.master_version );
  used += snprintf ( target + used , lmax - used,"<tr><td>Master table local</td><td>%5u</td></tr>\n", b->sec1.master_local );
  used += snprintf ( target + used , lmax - used,"<tr><td>Year</td><td>%5u</td></tr>\n", b->sec1.year );
  used += snprintf ( target + used , lmax - used,"<tr><td>Month</td><td>%5u</td></tr>\n", b->sec1.month );
  used += snprintf ( target + used , lmax - used,"<tr><td>Day</td><td>%5u</td></tr>\n", b->sec1.day );
  used += snprintf ( target + used , lmax - used,"<tr><td>Hour</td><td>%5u</td></tr>\n", b->sec1.hour );
  used += snprintf ( target + used , lmax - used,"<tr><td>Minute</td><td>%5u</td></tr>\n", b->sec1.minute );
  used += snprintf ( target + used , lmax - used,"<tr><td>Second</td><td>%5u</td></tr>\n", b->sec1.second );
  if ( b->sec0.edition == 3 )
    used += snprintf ( target + used , lmax - used,"<tr><td>Aditional space</td><td>%5u</td></tr>\n", b->sec1.length - 17 );
  else
    used += snprintf ( target + used , lmax - used,"<tr><td>Aditional space</td><td>%5u</td></tr>\n", b->sec1.length - 22 );
 
  if ( b->tables->b.path[0] )
    {
      used += snprintf ( target + used , lmax - used,"<tr><td>Tables used</td><td>'%s'<br>\n", b->tables->b.path );
      used += snprintf ( target + used , lmax - used,"'%s'<br>\n", b->tables->c.path );
      used += snprintf ( target + used , lmax - used,"'%s'</td></tr>\n", b->tables->d.path );
    }
  used += snprintf ( target + used , lmax - used,"</table>\n" );
  used += snprintf ( target + used , lmax - used,"</div>\n" );
  return 0;
}

References bufr_tables::b, bufrdeco_assert, bufr_tables::c, bufr_sec1::category, bufr_sec1::centre, bufr_tables::d, bufr_sec1::day, bufr_sec0::edition, bufr_sec1::hour, bufr_sec1::length, bufr_sec1::master, bufr_sec1::master_local, bufr_sec1::master_version, bufr_sec1::minute, bufr_sec1::month, bufr_sec1::options, bufr_tableB::path, bufr_tableC::path, bufr_tableD::path, bufrdeco::sec0, bufrdeco::sec1, bufr_sec1::second, bufr_sec1::subcategory, bufr_sec1::subcategory_local, bufr_sec1::subcentre, bufrdeco::tables, bufr_sec1::update, and bufr_sec1::year.

Referenced by sprint_sec1_info().

Here is the caller graph for this function:

sprint_sec3_info()

int sprint_sec3_info	(	char *	target,
		size_t	lmax,
		struct bufrdeco *	b
	)

Prints info from sec3.

Parameters

target	string target
lmax	available size in target
b	pointer to the source struct bufrdeco

Returns

If succeeded return 0, 1 otherwise

Definition at line 155 of file bufrdeco_print.c.

{
  size_t i;
  size_t used = 0;
 
  bufrdeco_assert ( b != NULL );
  
  if ( lmax == 0 || target == NULL)
    {
      snprintf ( b->error, sizeof ( b->error ), "%s(): Unspected NULL argument(s)\n", __func__ );
      return 1;
    }
 
  if ( b->mask & BUFRDECO_OUTPUT_HTML )
    return sprint_sec3_info_html ( target, lmax, b );
 
  used += snprintf ( target + used, lmax - used, "\n#### SEC 3 INFO ###\n" );
  used += snprintf ( target + used, lmax - used, "Sec3 length:           %5u\n", b->sec3.length );
  used += snprintf ( target + used, lmax - used, "Subsets:               %5u\n", b->sec3.subsets );
  used += snprintf ( target + used, lmax - used, "Observed:              %5u\n", b->sec3.observed );
  used += snprintf ( target + used, lmax - used, "Compressed:            %5u\n", b->sec3.compressed );
  used += snprintf ( target + used, lmax - used, "Unexpanded descriptors %5u\n", b->sec3.ndesc );
 
  for ( i = 0; i < b->sec3.ndesc; i++ )
    {
      used += snprintf ( target + used, lmax - used, "  %3lu:                      %u %02u %03u\n", i, b->sec3.unexpanded[i].f,
                         b->sec3.unexpanded[i].x, b->sec3.unexpanded[i].y );
    }
  return 0;
}

References bufrdeco_assert, BUFRDECO_OUTPUT_HTML, bufr_sec3::compressed, bufrdeco::error, bufr_descriptor::f, bufr_sec3::length, bufrdeco::mask, bufr_sec3::ndesc, bufr_sec3::observed, bufrdeco::sec3, sprint_sec3_info_html(), bufr_sec3::subsets, bufr_sec3::unexpanded, bufr_descriptor::x, and bufr_descriptor::y.

Referenced by print_sec3_info().

Here is the call graph for this function:

Here is the caller graph for this function:

sprint_sec3_info_html()

int sprint_sec3_info_html	(	char *	target,
		size_t	lmax,
		struct bufrdeco *	b
	)

Prints info from sec3 formatted as html.

Parameters

target	string target
lmax	available size in target
b	pointer to the source struct bufrdeco

Returns

If succeeded return 0

Definition at line 104 of file bufrdeco_print_html.c.

{
  size_t i;
  size_t used = 0; 
 
  bufrdeco_assert ( b != NULL && lmax != 0 && target != NULL );
 
  used += snprintf ( target + used , lmax - used,"<div class='bufr_sec3'>\n" );
  used += snprintf ( target + used , lmax - used,"<table>\n<caption>SEC 3 INFO</caption>\n" );
  used += snprintf ( target + used , lmax - used,"<tr><td>Sec3 length</td><td>%5u\n", b->sec3.length );
  used += snprintf ( target + used , lmax - used,"<tr><td>Subsets</td><td>%5u\n", b->sec3.subsets );
  used += snprintf ( target + used , lmax - used,"<tr><td>Observed</td><td>%5u\n", b->sec3.observed );
  used += snprintf ( target + used , lmax - used,"<tr><td>Compressed</td><td>%5u\n", b->sec3.compressed );
  used += snprintf ( target + used , lmax - used,"<tr><td>Unexpanded descriptors</td><td>%5u</td></tr>\n", b->sec3.ndesc );
  for ( i = 0; i < b->sec3.ndesc; i++ )
    {
      used += snprintf ( target + used , lmax - used,"<tr><td>%3lu:</td><td>%u %02u %03u</td></tr>\n", i, b->sec3.unexpanded[i].f,
                     b->sec3.unexpanded[i].x, b->sec3.unexpanded[i].y );
    }
  used += snprintf ( target + used , lmax - used,"</table>\n" );
  used += snprintf ( target + used , lmax - used,"</div>\n" );
  return 0;
}

References bufrdeco_assert, bufr_sec3::compressed, bufr_descriptor::f, bufr_sec3::length, bufr_sec3::ndesc, bufr_sec3::observed, bufrdeco::sec3, bufr_sec3::subsets, bufr_sec3::unexpanded, bufr_descriptor::x, and bufr_descriptor::y.

Referenced by sprint_sec3_info().

Here is the caller graph for this function:

sprint_sec4_info()

int sprint_sec4_info	(	char *	target,
		size_t	lmax,
		struct bufrdeco *	b
	)

Prints info from sec4.

Parameters

target	string target
lmax	available size in target
b	pointer to the source struct bufrdeco

Returns

If succeeded return 0, 1 otherwise

Definition at line 213 of file bufrdeco_print.c.

{
  size_t used = 0;
 
  bufrdeco_assert ( b != NULL );
  
  if ( lmax == 0 || target == NULL )
    {
      snprintf ( b->error, sizeof ( b->error ), "%s(): Unspected NULL argument(s)\n", __func__ );
      return 1;
    }
 
  if ( b->mask & BUFRDECO_OUTPUT_HTML )
    return sprint_sec4_info_html ( target, lmax, b );
 
  used += snprintf ( target + used, lmax - used, "\n#### SEC 4 INFO ###\n" );
  used += snprintf ( target + used, lmax - used, "Sec4 length:           %5u\n\n", b->sec4.length );
  return 0;
}

References bufrdeco_assert, BUFRDECO_OUTPUT_HTML, bufrdeco::error, bufr_sec4::length, bufrdeco::mask, bufrdeco::sec4, and sprint_sec4_info_html().

Referenced by print_sec4_info().

Here is the call graph for this function:

Here is the caller graph for this function:

sprint_sec4_info_html()

int sprint_sec4_info_html	(	char *	target,
		size_t	lmax,
		struct bufrdeco *	b
	)

Prints info from sec4.

Parameters

target	string target
lmax	available size in target
b	pointer to the source struct bufrdeco

Returns

If succeeded return 0, 1 otherwise

Definition at line 136 of file bufrdeco_print_html.c.

{
  size_t used = 0;
 
  bufrdeco_assert ( b != NULL && lmax != 0 && target != NULL );
  
  used += snprintf ( target + used , lmax - used,"<div class='bufr_sec4'>\n" );
  used += snprintf ( target + used , lmax - used,"<table>\n<caption>SEC 4 INFO</caption>\n" );
  used += snprintf ( target + used , lmax - used,"<tr><td>Sec4 length</td><td>%5u</td></tr>\n", b->sec4.length );
  used += snprintf ( target + used , lmax - used,"</table>\n" );
  used += snprintf ( target + used , lmax - used,"</div>\n" );
  return 0;
}

References bufrdeco_assert, bufr_sec4::length, and bufrdeco::sec4.

Referenced by sprint_sec4_info().

Here is the caller graph for this function:

three_bytes_to_uint32()

uint32_t three_bytes_to_uint32

(

const uint8_t *

source

)

returns the uint32_t value from an array of three bytes, most significant first

Parameters

source

pointer to source uint8_t

Returns

the uint32_t resulting

Definition at line 265 of file bufrdeco_utils.c.

{
  //bufrdeco_assert (source != NULL);
  return ( ( uint32_t ) source[2] + ( uint32_t ) source[1] * 256 + ( uint32_t ) source[0] * 65536 );
}

Referenced by bufrdeco_read_buffer().

Here is the caller graph for this function:

two_bytes_to_descriptor()

int two_bytes_to_descriptor	(	struct bufr_descriptor *	d,
		const uint8_t *	source
	)

set a struct bufr_descriptor from two consecutive bytes in bufr file

Parameters

source	pointer to first byte (most significant)
d	pointer to the resulting descriptor

Returns

0 if all is OK. 1 otherwise

Definition at line 297 of file bufrdeco_utils.c.

{
  //bufrdeco_assert (source != NULL && d != NULL);
  
  d->y = source[1];
  d->x = source[0] & 0x3f;
  d->f = ( source[0] >> 6 ) & 0x03;
  sprintf ( d->c, "%u%02u%03u", d->f, d->x, d->y );
  return 0;
}

References bufr_descriptor::c, bufr_descriptor::f, bufr_descriptor::x, and bufr_descriptor::y.

Referenced by bufrdeco_read_buffer().

Here is the caller graph for this function:

two_bytes_to_uint32()

uint32_t two_bytes_to_uint32

(

const uint8_t *

source

)

returns the uint32_t value from an array of two bytes, most significant first

Parameters

source

pointer to source uint8_t

Returns

the uint32_t resulting

Definition at line 250 of file bufrdeco_utils.c.

{
  
  //bufrdeco_assert (source != NULL);
  
  return ( ( uint32_t ) source[1] + ( uint32_t ) source[0] * 256 );
}

Referenced by bufrdeco_read_buffer().

Here is the caller graph for this function:

uint32_t_to_descriptor()

int uint32_t_to_descriptor	(	struct bufr_descriptor *	d,
		uint32_t	id
	)

parse an integer with a descriptor fom bufr ECWMF libary

Parameters

d	pointer to a struct bufr_descriptor where to set the result on output
id	integer with the descriptor from ewcwf

Returns

the resulting uint32_t

Definition at line 278 of file bufrdeco_utils.c.

{
  //bufrdeco_assert (d != NULL);
  
  d->f = id / 100000;
  d->x = ( id % 100000 ) / 1000;
  d->y = id % 1000;
  sprintf ( d->c, "%06u", id );
  return 0;
}

References bufr_descriptor::c, bufr_descriptor::f, bufr_descriptor::x, and bufr_descriptor::y.

Referenced by bufr_find_tableB_index(), bufr_find_tableC_csv_index(), bufr_read_tableB(), bufr_read_tableC(), bufr_read_tableD(), bufrdeco_tableD_get_descriptors_array(), and main().

Here is the caller graph for this function:

Variable Documentation

DEFAULT_BUFRTABLES_ECMWF_DIR1

const char DEFAULT_BUFRTABLES_ECMWF_DIR1[]

extern

DEFAULT_BUFRTABLES_ECMWF_DIR2

const char DEFAULT_BUFRTABLES_ECMWF_DIR2[]

extern

DEFAULT_BUFRTABLES_WMO_CSV_DIR1

const char DEFAULT_BUFRTABLES_WMO_CSV_DIR1[]

extern

And these are the default directories when using WMO csv table files

Definition at line 29 of file bufrdeco_wmo.c.

Referenced by get_wmo_tablenames().

DEFAULT_BUFRTABLES_WMO_CSV_DIR2

const char DEFAULT_BUFRTABLES_WMO_CSV_DIR2[]

extern

Definition at line 30 of file bufrdeco_wmo.c.

Referenced by get_wmo_tablenames().

pow10neg

const double pow10neg[8]

extern

Definition at line 32 of file bufrdeco_tableB.c.

Referenced by bufrdeco_tableB_val().

pow10pos

const double pow10pos[8]

extern

Definition at line 31 of file bufrdeco_tableB.c.

Referenced by bufrdeco_tableB_val().

pow10pos_int

const int32_t pow10pos_int[10]

extern

Definition at line 30 of file bufrdeco_tableB.c.

Referenced by bufrdeco_parse_f2_compressed(), and bufrdeco_parse_f2_descriptor().