cfe.c

Go to the documentation of this file.

 
#include "bufrlib.h"
 
#define MAX_MEANING_LEN 150
 
struct code_flag_entry {
    int iffxyn;
    int ifval;
    char ifmeaning[MAX_MEANING_LEN+1];
    int iffxynd;
    int ifvald;
};
 
struct code_flag_entry *cfe;  /* will automatically initialize to NULL */
 
int mxmtbf;
 
int nmtf;
 
void
inittbf(void)
{
    char brtstr[50] = "BUFRLIB: INITTBF FAILED ALLOCATING CFE";
 
    /*
    **  Has array space for the internal memory structure been
    **  allocated yet?
    */
    if ( cfe == NULL ) {
 
        mxmtbf = igetprm_f("MXMTBF");
 
        if ( ( cfe = malloc(mxmtbf * sizeof(struct code_flag_entry)) ) == NULL ) {
            bort_f(brtstr);
        }
    }
 
    nmtf = 0;
}
 
void
dlloctbf(void)
{
    free(cfe);
 
    cfe = NULL;
}
 
int
cmpstia1(const void *pe1, const void *pe2)
{
    struct code_flag_entry *mype1 = ( struct code_flag_entry * ) pe1;
    struct code_flag_entry *mype2 = ( struct code_flag_entry * ) pe2;
 
    if ( mype1->iffxyn == mype2->iffxyn ) {
        if ( mype1->ifval == mype2->ifval ) {
            if ( mype1->iffxynd == mype2->iffxynd ) {
                if ( mype1->ifvald == mype2->ifvald ) return 0;
                return ( mype1->ifvald < mype2->ifvald ? -1 : 1 );
            }
            else {
                return ( mype1->iffxynd < mype2->iffxynd ? -1 : 1 );
            }
        }
        else {
            return ( mype1->ifval < mype2->ifval ? -1 : 1 );
        }
    }
    else {
        return ( mype1->iffxyn < mype2->iffxyn ? -1 : 1 );
    }
}
 
int
cmpstia2(const void *pe1, const void *pe2)
{
    struct code_flag_entry *mype1 = ( struct code_flag_entry * ) pe1;
    struct code_flag_entry *mype2 = ( struct code_flag_entry * ) pe2;
 
    if ( mype1->iffxyn == mype2->iffxyn ) {
        if ( mype1->ifval == mype2->ifval ) return 0;
        return ( mype1->ifval < mype2->ifval ? -1 : 1 );
    }
    else {
        return ( mype1->iffxyn < mype2->iffxyn ? -1 : 1 );
    }
}
 
void
strtbfe(int ifxyn, int ival, char *meaning, int lmeaning, int idfxy, int idval)
{
    unsigned int mnlen;
 
    static char brtstr[50] = "BUFRLIB: STRTBFE - MXMTBF OVERFLOW";
 
    /*
    **  Confirm that there's room for another entry in the structure.
    */
    if ( nmtf >= mxmtbf ) bort_f(brtstr);
 
    /*
    **  Store the new entry.
    */
    cfe[nmtf].iffxyn = ifxyn;
    cfe[nmtf].ifval = ival;
    mnlen = ( lmeaning > MAX_MEANING_LEN ? MAX_MEANING_LEN : lmeaning );
    strncpy(&cfe[nmtf].ifmeaning[0], meaning, mnlen);
    cfe[nmtf].ifmeaning[mnlen] = '\0';
    cfe[nmtf].iffxynd = idfxy;
    cfe[nmtf].ifvald  = idval;
    nmtf++;
}
 
void
sorttbf(void)
{
    qsort(&cfe[0], (size_t) nmtf, sizeof(struct code_flag_entry),
        (int (*) (const void *, const void *)) cmpstia1);
}
 
void
srchtbf(int ifxyi, int ivali, int *ifxyd, int mxfxyd, int ivald,
        char *meaning, int mxmng, int *lnmng, int *iret)
{
    struct code_flag_entry key, *pkey, *pcfe, *pbs;
 
    int ipt, ii, slmng;
 
    *iret = -1;
 
    /*
    **  Initialize some values for searching the internal table.
    */
    key.iffxyn = ifxyi;
    key.ifval = ivali;
    key.iffxynd = ifxyd[0];
    key.ifvald = ivald;
 
    pkey = &key;
    pcfe = &cfe[0];
 
    /*
    **  Search for a matching entry.
    */
    pbs = (struct code_flag_entry *) bsearch(pkey, pcfe, (size_t) nmtf,
                sizeof(struct code_flag_entry),
                (int (*) (const void *, const void *)) cmpstia1);
    if ( pbs != NULL ) {
        /*
        **  A matching entry was found, so set the appropriate output
        **  values and return.
        */
        ipt = pbs - pcfe;
        slmng = strlen(cfe[ipt].ifmeaning);
        *lnmng = ( mxmng > slmng ? slmng : mxmng );
        strncpy(meaning, &cfe[ipt].ifmeaning[0], *lnmng);
        *iret = 0;
        return;
    }
 
    /*
    **  Was a particular dependency specified in the input?
    */
    if ( key.iffxynd != -1 ) {
        /*
        **  YES, so there's nothing else to do.
        */
        return;
    }
 
    /*
    **  NO, so check whether the given Table B descriptor and value have any
    **  dependencies, and if so then return a list of those dependencies.
    */
    pbs = (struct code_flag_entry *) bsearch(pkey, pcfe, (size_t) nmtf,
                sizeof(struct code_flag_entry),
                (int (*) (const void *, const void *)) cmpstia2);
    if ( pbs == NULL ) {
        /*
        **  There are no dependencies.
        */
        return;
    }
 
    /*
    **  Store the dependency that was returned by the secondary search.
    **  However, there may be others within the internal table, so we'll
    **  also need to check for those.
    */
    ipt = pbs - pcfe;
    *iret = 0;
    ifxyd[(*iret)++] = cfe[ipt].iffxynd;
 
    /*
    **  Since the internal table is sorted, check immediately before and
    **  after the returned dependency for any additional table entries which
    **  correspond to the same Table B descriptor and value, but for which the
    **  dependency is different.  If any such additional dependencies are
    **  found, return those as well.
    */
    ii = ipt - 1;
    while ( ( ii >= 0 ) &&
            ( *iret < mxfxyd ) &&
            ( cfe[ii].iffxyn == key.iffxyn ) &&
            ( cfe[ii].ifval == key.ifval ) ) {
        if ( cfe[ii].iffxynd < ifxyd[(*iret)-1] )
                ifxyd[(*iret)++] = cfe[ii].iffxynd;
        ii--;
    }
    ii = ipt + 1;
    while ( ( ii < nmtf ) &&
            ( *iret < mxfxyd ) &&
            ( cfe[ii].iffxyn == key.iffxyn ) &&
            ( cfe[ii].ifval == key.ifval ) ) {
        if ( ( cfe[ii].iffxynd > ifxyd[(*iret)-1] ) &&
             ( cfe[ii].iffxynd > cfe[ipt].iffxynd ) )
                ifxyd[(*iret)++] = cfe[ii].iffxynd;
        ii++;
    }
 
    return;
}