desc.c

Go to the documentation of this file.

/*-------------------------------------------------------------------------

    BUFR encoding and decoding software and library
    Copyright (c) 2007,  Institute of Broadband Communication, TU-Graz
    on behalf of EUMETNET OPERA, http://www.knmi.nl/opera

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; version 2.1 
    of the License.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 

----------------------------------------------------------------------------

FILE:          READDESC.C
IDENT:         $Id: desc.c,v 1.14 2007/12/18 14:40:13 fuxi Exp $

AUTHOR:        Konrad Koeck
               Institute of Communication and Wave Propagation, 
               Technical University Graz, Austria

VERSION NUMBER:3.0

DATE CREATED:  18-DEC-2001

STATUS:        DEVELOPMENT FINISHED


FUNCTIONAL DESCRIPTION:
-----------------------
Function(s) for reading the descriptor-file.

AMENDMENT RECORD:

ISSUE       DATE            SCNREF      CHANGE DETAILS
-----       ----            ------      --------------
V2.0        18-DEC-2001     Koeck       Initial Issue

$Log: desc.c,v $
Revision 1.14  2007/12/18 14:40:13  fuxi
added licence header

Revision 1.13  2007/12/07 08:39:15  fuxi
update to version 3.0

Revision 1.12  2005/04/04 15:31:35  helmutp
update to version 2.3

Revision 1.11  2004/09/28 12:14:00  helmutp
fixed fclose and free

Revision 1.10  2003/09/04 08:07:19  helmutp
add / or \ to directory name

Revision 1.9  2003/06/11 09:33:19  helmutp
changed key calculation

Revision 1.8  2003/06/11 09:02:57  helmutp
remove duplicate entries from desc table (local table overruling)
fixed read_tab_d EOF handling, changed name of master table

Revision 1.7  2003/06/06 11:59:32  helmutp
changed read_tables to support table versions

Revision 1.6  2003/03/27 17:17:39  helmutp
update to version 2.2

Revision 1.5  2003/03/13 17:17:48  helmutp
fixed argc and indentation

Revision 1.4  2003/03/13 17:08:47  helmutp
added search key, use sorted descriptors and bsearch instead of linear search
allow tables to be specified on commndline

Revision 1.3  2003/03/11 10:30:42  helmutp
fixed memory leaks

Revision 1.2  2003/03/06 17:12:32  helmutp
update to version 2.1

Revision 1.1  2003/02/28 13:41:12  helmutp
Initial revision

--------------------------------------------------------------------------- */

#define READDESC_MAIN

#define DESC_SORT

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
#include "desc.h"

/*===========================================================================*/
/* internal functions                                                        */
/*===========================================================================*/

static del *decode_tabb_line (char *line);
static char *get_val (char *line, int num);
static dseq *decode_tabd_line (char *line);
static void replace_chars (char *line, char oldc, char newc);
static int key (int typ, dd* d);
static void build_keys();
static void print_desc(int i);
static void free_one_desc(int i);
static char *str_lower(char *str);


/*===========================================================================*/

int read_tables (char *dir, int vmtab, int vltab, int subcent, int gencent)
{
    char fn[1024];
#if defined(_WIN32)
    char *sep = "\\";
#else
    char *sep = "/";
#endif

    if (dir == NULL)
        dir = "";

    if (strlen(dir) == 0 || dir[strlen(dir) -1] == '/' || 
        dir[strlen(dir) -1] == '\\')
        sep = "";

    sprintf (fn, "%s%sbufrtabb_%d.csv", dir, sep, vmtab);
    if (!read_tab_b (fn)) 
    {
        fprintf (stderr, "Error: unable to read master BUFR Table B !\n");
        return -1;
    }
    
    sprintf (fn, "%s%sbufrtabd_%d.csv", dir, sep, vmtab);
    if (!read_tab_d (fn)) 
    {
        fprintf (stderr, "Error: unable to read master BUFR Table D !\n");
        return -1;
    }
    
    sprintf (fn, "%s%slocaltabb_%d_%d.csv", dir, sep, 
             subcent * 256 + gencent, vltab);
    if (!read_tab_b (fn)) 
        fprintf (stderr, "Warning: unable to read local BUFR Table B !\n");
    
    sprintf (fn, "%s%slocaltabd_%d_%d.csv", dir, sep, 
             subcent * 256 + gencent, vltab);
    if (!read_tab_d (fn)) 
        fprintf (stderr, "Warning: unable to read local BUFR Table D !\n");

    return 0;
}

/*===========================================================================*/

void show_desc (int f, int x, int y)
{
    if (f == 999)
    {
        for (f = 0; f < ndes; f++)
            print_desc (f);
    }
    else if (f >= 0 && x >= 0 && y >= 0)
    {
        int i;
        dd d;
        d.f = f;
        d.x = x;
        d.y = y;
        if ((i = get_index (SEQDESC, &d)) >= 0)
            print_desc (i);
        else if ((i = get_index (ELDESC, &d)) >= 0)
            print_desc (i);
        else
            fprintf (stderr, "Descriptor %d %d %d not found !\n", f, x, y);
    }
}

/*===========================================================================*/

/* Print the descriptor at index i */

static void print_desc(int i)
{
    if (i < 0 || i >= ndes) return;

    if (des[i]->id == ELDESC)
    {
        del *d = des[i]->el;
        printf ("%d %02d %03d %2d %2d  %s  %s   [%d, %d]\n", d->d.f, d->d.x, d->d.y,
                d->scale, d->dw, d->unit, d->elname, i, des[i]->nr);
    }
    else
    {
        int j;
        dseq *d = des[i]->seq;
        printf ("%d %02d %03d  %d %02d %03d   [%d, %d]\n", d->d.f, d->d.x, d->d.y,
                d->del[0].f, d->del[0].x, d->del[0].y, i, des[i]->nr);
        for (j = 1; j < d->nel; j++)
            printf ("          %d %02d %03d\n", d->del[j].f, d->del[j].x, d->del[j].y);
    }
}

/*===========================================================================*/

/* Compare key calculation */

static int key (int typ, dd* d)
{
    return (typ << 24) + (d->f << 16) + (d->x << 8) + d->y;
}

/* Descriptor compare function (for qsort) */ 

#ifdef DESC_SORT
static int dcmp (const void *p1, const void *p2)
{
    desc *d1 = *(desc **) p1;
    desc *d2 = *(desc **) p2;
    
    return d1->key - d2->key;
}
#endif

/* Create sort keys and sort the descriptor table, 
   remove duplicate entries (local table overruling) */

static void build_keys()
{
    int i, n;
    if (ndes == 0)
        return;

    for (i = 0; i < ndes; i++)
    {
        if (des[i]->id == ELDESC)
            des[i]->key = key (des[i]->id, &des[i]->el->d);
        if (des[i]->id == SEQDESC)
            des[i]->key = key (des[i]->id, &des[i]->seq->d);
    }

#ifdef DESC_SORT

    /* sort descriptors and remove duplicates */
    /* keep decsriptor with higher serial number */
    
    qsort (des, ndes, sizeof (desc *), dcmp);

    for (i = 1, n = 0; i < ndes; i++)
    {
        if (des[n]->key == des[i]->key)
        {
            if (des[i]->nr > des[n]->nr)
            {
                free_one_desc (n);
                des[n] = des[i];
            }
            else
                free_one_desc (i);
        }
        else
            des[++n] = des[i];
    }
    ndes = n + 1;

#endif
}

/*===========================================================================*/

int get_index (int typ, dd* descr)
{
#ifdef DESC_SORT

    int i1 = 0;
    int i2 = ndes -1;
    int k = key (typ, descr);

    while (i2 >= i1)
    {
        int i = (i2 + i1) / 2;
            int diff = des[i]->key - k;
        if (diff == 0)
            return i;
        if (diff < 0)
            i1 = i + 1;
        else
            i2 = i - 1;
    }
    return -1;

#else

  int i;
  int k = key (typ, descr);
  for (i = 0; i < ndes; i ++) 
  {
      if (des[i]->key == k)
        return i;
  }
  return -1;

#endif
}

/*===========================================================================*/
int read_tab_d (char *fname)

{
    FILE *fp;
    char line[1000], *l;
    dseq *sdesc;
    int end;

    /* Open input file */

    fp = fopen (fname, "r");
    if (fp == NULL) {
        fprintf (stderr, "unable to open '%s'\n", fname);
        return 0;
    }

/* Run through all lines and decode the ones that contain reasonable data */

    end = 0;
    do {
        if ((l = fgets (line, 1000, fp)) != NULL)
        {
            /* For some reasons the '-' is not correct stored in the csv file */
            replace_chars (l, -105, 45); 
            replace_chars (l, -106, 45);
        }

        sdesc = decode_tabd_line (l);
        if (sdesc != NULL) {
            des[ndes] = malloc (sizeof (desc));
            if (des[ndes] == NULL) {
                fprintf (stderr, "Memory allocation error.\n");
                fclose (fp);
                return 0;
            }
            des[ndes]->id = SEQDESC;
            des[ndes]->nr = ndes;
            des[ndes]->seq = sdesc;
            des[ndes]->el = NULL;
            ndes ++;
            if (ndes >= MAXDESC) {
                fprintf (stderr, "Parameter MAXDESC exceeded.\n");
                fclose (fp);
                return 0;
            }
        }
    } while (l != NULL);

    fclose (fp);

    build_keys();
    return 1;
}

/*===========================================================================*/
static dseq *decode_tabd_line (char *line)

/* Decodes a single Table D Line and returns a pointer to a dseq-structure
         holding the data that has been decoded. The memory area must be
         freed by the calling function
*/

{
/* Get the first 6 strings of the line, each of them separated by a ';'
*/

    char *sf, *sx, *sy, *dx, *dy, *df;
    int isf, isx, isy, idx, idy, idf;
    static dseq *seq = NULL;           /* Holds the current Sequence Descriptor */
    dseq *ret = NULL;
    dd *ddp;
    char tmp[1000];

    if (line == NULL)
    {
        ret = seq;
        seq = NULL;
        return ret;
    }

    strcpy (tmp, line);

    dy = get_val (line, 5);
    dx = get_val (line, 4);
    df = get_val (line, 3);
    sy = get_val (line, 2);
    sx = get_val (line, 1);
    sf = get_val (line, 0);

/* CHeck for valid values */

    if (dy == NULL ||
        dx == NULL ||
        df == NULL ||
        sy == NULL ||
        sx == NULL ||
        sf == NULL) return NULL;

    if (sscanf (sf, "%d", &isf) != 1) isf = 0;
    if (sscanf (sx, "%d", &isx) != 1) isx = 0;
    if (sscanf (sy, "%d", &isy) != 1) isy = 0;
    if (sscanf (df, "%d", &idf) != 1) idf = 0;
    if (sscanf (dx, "%d", &idx) != 1) idx = 0;
    if (sscanf (dy, "%d", &idy) != 1) idy = 0;

/* Check if there is a new seqence descriptor */

    if (isf == 3 || isx != 0 || isy != 0) {
        if (seq != NULL) {
            ret = seq;       /* This is what we return */
        }
        seq = malloc (sizeof (dseq));
        if (seq == NULL) {
            fprintf (stderr, "Memory allocation error !\n");
            return NULL;
        }
        seq->d.f = isf;
        seq->d.x = isx;
        seq->d.y = isy;
        seq->nel = 0;
        seq->del = malloc (sizeof (dd));
        if (seq->del == NULL) {
            fprintf (stderr, "Memory allocation error !\n");
            return NULL;
        }
    }

/* Get the new entry for the sequence */

    if ((idf != 0 || idx != 0 || idy != 0) && seq != NULL) {
        seq->del = realloc (seq->del, (seq->nel + 1) * sizeof (dd));
        if (seq->del == NULL) {
            fprintf (stderr, "Memory allocation error !\n");
            return NULL;
        }
        ddp = seq->del + seq->nel;
        ddp->f = idf;
        ddp->x = idx;
        ddp->y = idy;
        seq->nel += 1;
    }

    return ret;
}

/*===========================================================================*/
int read_tab_b (char *fname)

{
    FILE *fp;
    char line[1000];
    del *descr;

    /* Open input file */

    fp = fopen (fname, "r");
    if (fp == NULL) {
        fprintf (stderr, "unable to open '%s'\n", fname);
        return 0;
    }

    /* Run through all lines and decode the ones that contain reasonable data*/

    while (fgets (line, 1000, fp) != NULL) {
        replace_chars (line, -106, 45); /* For some reasons the '-' is not correct stored in the csv file */
        replace_chars (line, -105, 45); /* For some reasons the '-' is not correct stored in the csv file */
        descr = decode_tabb_line (line);
        if (descr != NULL) {
            des[ndes] = malloc (sizeof (desc));
            if (des[ndes] == NULL) {
                fprintf (stderr, "Memory allocation error.\n");
                fclose (fp);
                return 0;
            }
            des[ndes]->id = ELDESC;
            des[ndes]->nr = ndes;
            des[ndes]->el = descr;
            des[ndes]->seq = NULL;
            ndes ++;
            if (ndes >= MAXDESC) {
                fprintf (stderr, "Parameter MAXDESC exceeded.\n");
                fclose (fp);
                return 0;
            }
        }
    }

    fclose (fp);

    /* Finally we add a dummy descriptor describing a single character 
       in a CCITT IA5 character string */

    if (ccitt_special == 0) {
        ccitt_special = MAXDESC + 1;
        descr = decode_tabb_line ("9999;9999;9999;tmp;value;0;0;8;tmp;0;3");
        if (descr != NULL) {
            des[ccitt_special] = malloc (sizeof (desc));
            if (des[ccitt_special] == NULL) {
                fprintf (stderr, "Memory allocation error.\n");
                return 0;
            }
            des[ccitt_special]->id = ELDESC;
            des[ccitt_special]->nr = ccitt_special;
            des[ccitt_special]->el = descr;
            des[ccitt_special]->seq = NULL;
        }
    }

    /* The same we need for a dummy for saving a change in the 
       reference value */

    if (cf_special == 0) {
        cf_special = MAXDESC + 2;
        descr = decode_tabb_line ("9999;9999;9998;tmp;value;0;0;8;tmp;0;3");
        if (descr != NULL) {
            des[cf_special] = malloc (sizeof (desc));
            if (des[cf_special] == NULL) {
                fprintf (stderr, "Memory allocation error.\n");
                return 0;
            }
            des[cf_special]->id = ELDESC;
            des[cf_special]->nr = cf_special;
            des[cf_special]->el = descr;
            des[cf_special]->seq = NULL;
        }
    }

    /* dummy descriptor for the associated field */

    if (add_f_special == 0) {
        add_f_special = MAXDESC + 3;
        descr = decode_tabb_line ("0;0;0;Associated Field;value;0;0;0;tmp;0;0");
        if (descr != NULL) {
            des[add_f_special] = malloc (sizeof (desc));
            if (des[add_f_special] == NULL) {
                fprintf (stderr, "Memory allocation error.\n");
                return 0;
            }
            des[add_f_special]->id = ELDESC;
            des[add_f_special]->nr = add_f_special;
            des[add_f_special]->el = descr;
            des[add_f_special]->seq = NULL;
        }
    }

    /* dummy descriptor for no data output */
    
    if (_desc_special == 0) {
        _desc_special = MAXDESC + OPTDESC - 1;
        descr = decode_tabb_line ("0;0;0;Desc;value;0;0;0;tmp;0;0");
        if (descr != NULL) {
            des[_desc_special] = malloc (sizeof (desc));
            if (des[_desc_special] == NULL) {
                fprintf (stderr, "Memory allocation error.\n");
                return 0;
            }
            des[_desc_special]->id = ELDESC;
            des[_desc_special]->nr = _desc_special;
            des[_desc_special]->el = descr;
            des[_desc_special]->seq = NULL;
        }
    }

    build_keys();
    return 1;
}

/*===========================================================================*/
void free_descs (void)


{
    int i;

    for (i = 0; i < ndes; i ++) {
        free_one_desc (i);
    }
    ndes = 0;

    free_one_desc (ccitt_special);
    free_one_desc (cf_special);
    free_one_desc (add_f_special);
    free_one_desc (_desc_special);
    ccitt_special = 0;
    cf_special = 0;
    add_f_special = 0;
    _desc_special = 0;
}

static void free_one_desc (int i)
{
    if (i < 0 || i >= MAXDESC + OPTDESC|| des[i] == NULL) 
       return;

    if (des[i]->id == ELDESC) {
        free (des[i]->el->unit);
        free (des[i]->el->elname);
        free (des[i]->el);
    }
    else if (des[i]->id == SEQDESC) {
        free (des[i]->seq->del);
        free (des[i]->seq);
    }
    free (des[i]);
    des[i] = NULL;
}

/*===========================================================================*/
static del *decode_tabb_line (char *line)

/* Decodes a single Table B Line and returns a pointer to a del-structure
         holding the data that has been decoded. The memory area must be
         freed by the calling function
*/

{
/* Get the first 8 strings of the line, each of them separated by a ';'
*/

    char *data_width, *refval, *scale, *unit, *name, *x, *y, *f;
    del desc, *ret;
    float tmp;
    char tmpline[1000];

    memset (&desc, 0, sizeof (del));
    strcpy (tmpline, line);
 
    data_width = get_val (tmpline, 7);
    refval     = get_val (tmpline, 6);
    scale      = get_val (tmpline, 5);
    unit       = get_val (tmpline, 4);
    name       = get_val (tmpline, 3);
    y          = get_val (tmpline, 2);
    x          = get_val (tmpline, 1);
    f          = get_val (tmpline, 0);

    if (data_width == NULL ||
        refval     == NULL ||
        scale      == NULL ||
        unit       == NULL ||
        name       == NULL ||
        x          == NULL ||
        y          == NULL ||
        f          == NULL) return NULL;


/* A correct line has been found decode data from strings */

    if (sscanf (f,          "%d", &desc.d.f)   != 1) return NULL;
    if (sscanf (x,          "%d", &desc.d.x)   != 1) return NULL;
    if (sscanf (y,          "%d", &desc.d.y)   != 1) return NULL;
    if (sscanf (scale,      "%d", &desc.scale) != 1) return NULL;
    if (sscanf (data_width, "%d", &desc.dw)    != 1) return NULL;
    if (sscanf (refval,     "%f", &tmp)        != 1) return NULL;
    desc.refval = tmp;

    desc.unit = malloc (strlen (unit) + 1);
    if (desc.unit == NULL) {
        fprintf (stderr, "Memory allocation error !\n");
        return NULL;
    }
    strcpy (desc.unit, unit);

    desc.elname = malloc (strlen (name) + 1);
    if (desc.elname == NULL) {
        fprintf (stderr, "Memory allocation error !\n");
        return NULL;
    }
    strcpy (desc.elname, name);

    ret = malloc (sizeof (del));
    if (ret == NULL) {
        fprintf (stderr, "Memory allocation error !\n");
        return NULL;
    }

    memcpy (ret, &desc, sizeof (del));
    return ret;
}
/*===========================================================================*/
int desc_is_flagtable (int ind) {

    char unit[20];

    strncpy (unit, des[ind]->el->unit, 20);
    unit[19] = '\0';

    str_lower (unit);

    return (strcmp (unit, "flag table") == 0 ||
            strcmp (unit, "flag-table") == 0);
}

/*===========================================================================*/
int desc_is_codetable (int ind) {

    char unit[20];
    
    strncpy (unit, des[ind]->el->unit, 20);
    unit[19] = '\0';

    str_lower (unit);

    return (strcmp (unit, "code table") == 0 ||
            strcmp (unit, "code-table") == 0);
}

/*===========================================================================*/
static char *get_val (char *line, int num)

/* Gets a single value (character string) from a LINE licated at position
         NUM
*/

{
    char *p;
    int i;

/* seek to the end of the desired value and set it to 0 to identify the
         end of the string. */

    p = line;
    for (i = 0; i < num + 1 && p != NULL; i ++) {
        if (i == 0) p = strchr (p, ';');
        else p = strchr (p + 1, ';');
    }
    if (p != NULL) *p = 0;

/* Now seek to the beginning of the desired value */

    p = line;
    for (i = 0; i < num && p != NULL; i ++) {
        if (i == 0) p = strchr (p, ';');
        else p = strchr (p + 1, ';');
    }
    if (p == NULL) return NULL;
    if (num != 0) p ++;
    return p;
}

/*===========================================================================*/
void trim (char *buf)

{
  int i, len;

  len = strlen (buf);
  for (i = len - 1; i >= 0; i --) {
    if (*(buf + i) == ' ') *(buf + i) = 0;
    else break;
  }
}

/*===========================================================================*/
char *get_unit (dd* d)

{
  int i;

  for (i = 0; i < ndes; i ++) {
    if (des[i]->id == ELDESC &&
        memcmp (d, &(des[i]->el->d), sizeof (dd)) == 0)
        return des[i]->el->unit;
  }
  return NULL;
}

/*===========================================================================*/
static void replace_chars (char *line, char oldc, char newc)

/* replaces one character of a string against another.
*/

{
    for (;*line != 0; line ++) {
         if (*line == oldc) 
             *line = newc;
    }
}

/*===========================================================================*/
static char *str_lower(char *str)
{
    register char *p = str;
    while (*p != '\0') {
        *p = (char) tolower((int) *p);
        p++;
    }
    return str;
}


/* end of file */

---