borts.c

Go to the documentation of this file.

 
#include "bufrlib.h"
#include <setjmp.h>
 
jmp_buf context;
 
void
bort_goto_target(void)
{
    longjmp(context, 1);
}
 
void
catch_bort_openbf(int lunit, char *cio, int lundx, int cio_str_len)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Add a trailing null to cio, for use with get_c_string_length inside of openbf_f. */
    cio[cio_str_len] = '\0';
 
    /* Recursively call the subroutine. */
    openbf_f(lunit, cio, lundx);
}
 
void
catch_bort_closbf(int lunit)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    closbf_f(lunit);
}
 
void
catch_bort_status(int lunit, int *lun, int *il, int *im)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    status_f(lunit, lun, il, im);
}
 
void
catch_bort_readmg(int lunxx, char *subset, int *jdate, int subset_str_len, int *iret)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    readmg_f(lunxx, subset, jdate, subset_str_len, iret);
}
 
void
catch_bort_openmb(int lunit, char *subset, int subset_str_len, int jdate)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Add a trailing null to subset, for use with get_c_string_length inside of openmb_f. */
    subset[subset_str_len] = '\0';
 
    /* Recursively call the subroutine. */
    openmb_f(lunit, subset, jdate);
}
 
void
catch_bort_openmg(int lunit, char *subset, int subset_str_len, int jdate)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Add a trailing null to subset, for use with get_c_string_length inside of openmg_f. */
    subset[subset_str_len] = '\0';
 
    /* Recursively call the subroutine. */
    openmg_f(lunit, subset, jdate);
}
 
void
catch_bort_closmg(int lunit)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    closmg_f(lunit);
}
 
void
catch_bort_readns(int lunit, char *subset, int *jdate, int subset_str_len, int *iret)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    readns_f(lunit, subset, jdate, subset_str_len, iret);
}
 
void
catch_bort_readsb(int lunit, int *iret)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    readsb_f(lunit, iret);
}
 
void
catch_bort_writsb(int lunit)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    writsb_f(lunit);
}
 
void
catch_bort_writsa(int lunxx, int bufr_len, int *bufr, int *nbufr)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    writsa_f(lunxx, bufr_len, bufr, nbufr);
}
 
void
catch_bort_ufbint(int lunin, double *usr, int i1, int i2, int *iret, char *cstr, int cstr_len)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Add a trailing null to cstr, for use with get_c_string_length inside of ufbint_f. */
    cstr[cstr_len] = '\0';
 
    /* Recursively call the subroutine. */
    ufbint_f(lunin, (void**) &usr, i1, i2, iret, cstr);
}
 
void
catch_bort_ufbrep(int lunin, double *usr, int i1, int i2, int *iret, char *cstr, int cstr_len)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Add a trailing null to cstr, for use with get_c_string_length inside of ufbrep_f. */
    cstr[cstr_len] = '\0';
 
    /* Recursively call the subroutine. */
    ufbrep_f(lunin, (void**) &usr, i1, i2, iret, cstr);
}
 
void
catch_bort_ufbstp(int lunin, double *usr, int i1, int i2, int *iret, char *cstr, int cstr_len)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Add a trailing null to cstr, for use with get_c_string_length inside of ufbstp_f. */
    cstr[cstr_len] = '\0';
 
    /* Recursively call the subroutine. */
    ufbstp_f(lunin, (void**) &usr, i1, i2, iret, cstr);
}
 
void
catch_bort_ufbevn(int lunit, double *usr, int i1, int i2, int i3, int *iret, char *cstr, int cstr_len)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Add a trailing null to cstr, for use with get_c_string_length inside of ufbevn_f. */
    cstr[cstr_len] = '\0';
 
    /* Recursively call the subroutine. */
    ufbevn_f(lunit, (void**) &usr, i1, i2, i3, iret, cstr);
}
 
void
catch_bort_drfini(int lunit, int *mdrf, int ndrf, char *drftag, int drftag_len)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Add a trailing null to drftag, for use with get_c_string_length inside of drfini_f. */
    drftag[drftag_len] = '\0';
 
    /* Recursively call the subroutine. */
    drfini_f(lunit, mdrf, ndrf, drftag);
}
 
void
catch_bort_ufbseq(int lunin, double *usr, int i1, int i2, int *iret, char *cstr, int cstr_len)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Add a trailing null to cstr, for use with get_c_string_length inside of ufbseq_f. */
    cstr[cstr_len] = '\0';
 
    /* Recursively call the subroutine. */
    ufbseq_f(lunin, (void**) &usr, i1, i2, iret, cstr);
}
 
void
catch_bort_readlc(int lunit, char *cstr, int cstr_len, char *chr, int chr_len, int *nchr)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) {
        *nchr = 1;
        return;
    }
 
    /* Add a trailing null to cstr, for use with get_c_string_length inside of readlc_f. */
    cstr[cstr_len] = '\0';
 
    /* Recursively call the subroutine. */
    readlc_f(lunit, cstr, chr, chr_len);
 
    *nchr = (int) strlen(chr);
}
 
void
catch_bort_writlc(int lunit, char *cstr, int cstr_len, char *cchr, int cchr_len)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Add a trailing null to cstr, for use with get_c_string_length inside of writlc_f. */
    cstr[cstr_len] = '\0';
 
    /* Add a trailing null to cchr, for use with get_c_string_length inside of writlc_f. */
    cchr[cchr_len] = '\0';
 
    /* Recursively call the subroutine. */
    writlc_f(lunit, cstr, cchr);
}
 
void
catch_bort_ufbcnt(int lunit, int *kmsg, int *ksub)
{
    /* Set the target location to which to return if a bort error is caught. */
    if (setjmp(context) == 1) return;
 
    /* Recursively call the subroutine. */
    ufbcnt_f(lunit, kmsg, ksub);
}
 
void
catch_bort_ufbqcd(int lunit, char *cnemo, int *iqcd, int cnemo_len)
{
    /* Set the target location to which to return if a bort error is caught. */
    if (setjmp(context) == 1) return;
 
    /* Add a trailing null to cnemo, for use with get_c_string_length inside of ufbqcd_f. */
    cnemo[cnemo_len] = '\0';
 
    /* Recursively call the subroutine. */
    ufbqcd_f(lunit, cnemo, iqcd);
}
 
void
catch_bort_ufbqcp(int lunit, int iqcp, char *cnemo, int cnemo_len, int *ncn)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) {
        *ncn = 1;
        return;
    }
 
    /* Recursively call the subroutine. */
    ufbqcp_f(lunit, iqcp, cnemo, cnemo_len);
 
    *ncn = (int) strlen(cnemo);
}
 
void
catch_bort_getcfmng(int lunit, char *cnemoi, int lcni, int ivali, char *cnemod, int lcnd, int ivald,
                    char *cmeang_c, int lcmgc, int *lnmng, int *iret)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) {
        *lnmng = 1;
        return;
    }
 
    /* Add trailing nulls to input strings, for use with get_c_string_length inside of getcfmng_f. */
    cnemoi[lcni] = '\0';
    cnemod[lcnd] = '\0';
 
    /* Recursively call the subroutine. */
    getcfmng_f(lunit, cnemoi, ivali, cnemod, ivald, cmeang_c, lcmgc, iret);
 
    *lnmng = (int) strlen(cmeang_c);
}
 
void
catch_bort_upftbv(int lunit, char *cnemo, int lcn, double val, int *ibit, int mxib, int *nib)
{
    /* Set the target location to which to return if a bort error is caught. */
    if (setjmp(context) == 1) return;
 
    /* Add a trailing null to cnemo, for use with get_c_string_length inside of upftbv_f. */
    cnemo[lcn] = '\0';
 
    /* Recursively call the subroutine. */
    upftbv_f(lunit, cnemo, val, ibit, mxib, nib);
}
 
void
catch_bort_cobfl(const char *bfl, char io)
{
 
    /* Set the target location to which to return if a bort error is caught. */
    if (setjmp(context) == 1) return;
 
    /* Recursively call the function. */
    cobfl(bfl, io);
}
 
void
catch_bort_crbmg(char *bmg, int mxmb, int *nmb, int *iret)
{
 
    /* Set the target location to which to return if a bort error is caught. */
    if (setjmp(context) == 1) return;
 
    /* Recursively call the function. */
    crbmg(bmg, mxmb, nmb, iret);
}
 
void
catch_bort_cwbmg(const char *bmg, int nmb, int *iret)
{
 
    /* Set the target location to which to return if a bort error is caught. */
    if (setjmp(context) == 1) return;
 
    /* Recursively call the function. */
    cwbmg(bmg, nmb, iret);
}
 
void
catch_bort_ufbtab(int lunin, double *tab, int i1, int i2, int *iret, char *cstr, int cstr_len)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Add a trailing null to cstr, for use with get_c_string_length inside of ufbtab_f. */
    cstr[cstr_len] = '\0';
 
    /* Recursively call the subroutine. */
    ufbtab_f(lunin, (void**) &tab, i1, i2, iret, cstr);
}
 
void
catch_bort_ufbpos(int lunit, int irec, int isub, char *subset, int *jdate, int subset_str_len)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    ufbpos_f(lunit, irec, isub, subset, jdate, subset_str_len);
}
 
void
catch_bort_datelen(int len)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    datelen_f(len);
}
 
void
catch_bort_iupvs01(int lunit, char *s01mnem, int s01mnem_str_len, int *iret)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Add a trailing null to s01mnem, for use with get_c_string_length inside of iupvs01_f. */
    s01mnem[s01mnem_str_len] = '\0';
 
    /* Recursively call the function. */
    *iret = iupvs01_f(lunit, s01mnem);
}
 
void
catch_bort_nmsub(int lunit, int *iret)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the function. */
    *iret = nmsub_f(lunit);
}
 
void
catch_bort_pkvs01(char *s01mnem, int s01mnem_str_len, int ival)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Add a trailing null to s01mnem, for use with get_c_string_length inside of pkvs01_f. */
    s01mnem[s01mnem_str_len] = '\0';
 
    /* Recursively call the subroutine. */
    pkvs01_f(s01mnem, ival);
}
 
void
catch_bort_datebf(int lunit, int *mear, int *mmon, int *mday, int *mour, int *idate)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    datebf_f(lunit, mear, mmon, mday, mour, idate);
}
 
void
catch_bort_dumpbf(int lunit, int *jdate, int *jdump)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    dumpbf_f(lunit, jdate, jdump);
}
 
void
catch_bort_minimg(int lunit, int mini)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    minimg_f(lunit, mini);
}
 
void
catch_bort_upds3(int *mbay, int lcds3, char (*ccds3)[6], int *nds3)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    upds3_f(mbay, lcds3, ccds3, nds3);
}
 
void
catch_bort_pkbs1(int ival, int *mbay, char *s1mnem, int s1mnem_str_len)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Add a trailing null to s1mnem, for use with get_c_string_length inside of pkbs1_f. */
    s1mnem[s1mnem_str_len] = '\0';
 
    /* Recursively call the subroutine. */
    pkbs1_f(ival, mbay, s1mnem);
}
 
void
catch_bort_strcpt(char *cf, int iyr, int imo, int idy, int ihr, int imi)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    strcpt_f(cf, iyr, imo, idy, ihr, imi);
}
 
void
catch_bort_rtrcpt(int lunit, int *iyr, int *imo, int *idy, int *ihr, int *imi, int *iret)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    rtrcpt_f(lunit, iyr, imo, idy, ihr, imi, iret);
}
 
void
catch_bort_atrcpt(int *msgin, int lmsgot, int *msgot)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    atrcpt_f(msgin, lmsgot, msgot);
}
 
void
catch_bort_dxdump(int lunit, int luprt)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    dxdump_f(lunit, luprt);
}
 
void
catch_bort_ufbdmp(int lunit, int luprt)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    ufbdmp_f(lunit, luprt);
}
 
void
catch_bort_ufdump(int lunit, int luprt)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    ufdump_f(lunit, luprt);
}
 
void
catch_bort_copybf(int lunin, int lunot)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    copybf_f(lunin, lunot);
}
 
void
catch_bort_copymg(int lunin, int lunot)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    copymg_f(lunin, lunot);
}
 
void
catch_bort_copysb(int lunin, int lunot, int *iret)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    copysb_f(lunin, lunot, iret);
}
 
void
catch_bort_ufbcpy(int lunin, int lunot)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    ufbcpy_f(lunin, lunot);
}
 
void
catch_bort_nemdefs(int lunit, char *cnemo, int lcn, char *ccelem, int ccelem_str_len,
                   char *ccunit, int ccunit_str_len, int *iret)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Add a trailing null to cnemo, for use with get_c_string_length inside of nemdefs_f. */
    cnemo[lcn] = '\0';
 
    /* Recursively call the subroutine. */
    nemdefs_f(lunit, cnemo, ccunit, ccunit_str_len, ccelem, ccelem_str_len, iret);
}
 
void
catch_bort_nemspecs(int lunit, char *cnemo, int lcn, int nnemo, int *nscl, int *nref, int *nbts, int *iret)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Add a trailing null to cnemo, for use with get_c_string_length inside of nemspecs_f. */
    cnemo[lcn] = '\0';
 
    /* Recursively call the subroutine. */
    nemspecs_f(lunit, cnemo, nnemo, nscl, nref, nbts, iret);
}
 
void
catch_bort_readerme(int *mesg, int lunit, char *subset, int *jdate, int subset_str_len, int *iret)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    readerme_f(mesg, lunit, subset, jdate, subset_str_len, iret);
}
 
void
catch_bort_rdmgsb(int lunit, int imsg, int isub)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    rdmgsb_f(lunit, imsg, isub);
}
 
void
catch_bort_ufbmem(int lunit, int inew, int *iret, int *iunit)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    ufbmem_f(lunit, inew, iret, iunit);
}
 
void
catch_bort_ufbmex(int lunit, int lundx, int inew, int *iret, int *mesg)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    ufbmex_f(lunit, lundx, inew, iret, mesg);
}
 
void
catch_bort_ufbmms(int imsg, int isub,  char *subset, int *jdate, int subset_str_len)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    ufbmms_f(imsg, isub, subset, jdate, subset_str_len);
}
 
void
catch_bort_ufbmns(int irep, char *subset, int *idate, int subset_str_len)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    ufbmns_f(irep, subset, idate, subset_str_len);
}
 
void
catch_bort_rdmemm(int imsg, char *subset, int *jdate, int subset_str_len, int *iret)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    rdmemm_f(imsg, subset, jdate, subset_str_len, iret);
}
 
void
catch_bort_rdmems(int isub, int *iret)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    rdmems_f(isub, iret);
}
 
void
catch_bort_ufbrms(int imsg, int isub, double *usr, int i1, int i2, int *iret, char *cstr, int cstr_len)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Add a trailing null to cstr, for use with get_c_string_length inside of ufbrms_f. */
    cstr[cstr_len] = '\0';
 
    /* Recursively call the subroutine. */
    ufbrms_f(imsg, isub, (void**) &usr, i1, i2, iret, cstr);
}
 
void
catch_bort_ufbtam(double *tab, int i1, int i2, int *iret, char *cstr, int cstr_len)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Add a trailing null to cstr, for use with get_c_string_length inside of ufbtam_f. */
    cstr[cstr_len] = '\0';
 
    /* Recursively call the subroutine. */
    ufbtam_f((void**) &tab, i1, i2, iret, cstr);
}
 
void
catch_bort_cpymem(int lunot)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    cpymem_f(lunot);
}
 
void
catch_bort_ufbcup(int lunin, int lunot)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    ufbcup_f(lunin, lunot);
}
 
void
catch_bort_stdmsg(char *cf)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    stdmsg_f(cf);
}
 
void
catch_bort_stndrd(int lunit, int *msgin, int lmsgot, int *msgot)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    stndrd_f(lunit, msgin, lmsgot, msgot);
}
 
void
catch_bort_cmpmsg(char *cf)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    cmpmsg_f(cf);
}
 
void
catch_bort_codflg(char *cf)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    codflg_f(cf);
}
 
void
catch_bort_bvers(char *verstr, int verstr_len)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    bvers_f(verstr, verstr_len);
}
 
void
catch_bort_gettagpr(int lunit, char *tagch, int tagch_len, int ntagch,
                    char *tagpr, int tagpr_len, int *ntpchr, int *iret)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) {
        *ntpchr = 1;
        return;
    }
 
    /* Add a trailing null to tagch, for use with get_c_string_length inside of gettagpr_f. */
    tagch[tagch_len] = '\0';
 
    /* Recursively call the subroutine. */
    gettagpr_f(lunit, tagch, ntagch, tagpr, tagpr_len, iret);
 
    *ntpchr = (int) strlen(tagpr);
}
 
void
catch_bort_gettagre(int lunit, char *tagi, int tagi_len, int ntagi,
                    char *tagre, int tagre_len, int *ntagre, int *ntrchr, int *iret)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) {
        *ntrchr = 1;
        return;
    }
 
    /* Add a trailing null to tagi, for use with get_c_string_length inside of gettagre_f. */
    tagi[tagi_len] = '\0';
 
    /* Recursively call the subroutine. */
    gettagre_f(lunit, tagi, ntagi, tagre, tagre_len, ntagre, iret);
 
    *ntrchr = (int) strlen(tagre);
}
 
void
catch_bort_cnved4(int *msgin, int lmsgot, int *msgot)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    cnved4_f(msgin, lmsgot, msgot);
}
 
void
catch_bort_lcmgdf(int lunit, char *subset, int subset_str_len, int *iret)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Add a trailing null to subset, for use with get_c_string_length inside of lcmgdf_f. */
    subset[subset_str_len] = '\0';
 
    /* Recursively call the function. */
    *iret = lcmgdf_f(lunit, subset);
}
 
void
catch_bort_setvalnb(int lunit, char *tagpv, int tagpv_len, int ntagpv,
                    char *tagnb, int tagnb_len, int ntagnb, double r8val, int *iret)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Add trailing nulls to input strings, for use with get_c_string_length inside of setvalnb_f. */
    tagpv[tagpv_len] = '\0';
    tagnb[tagnb_len] = '\0';
 
    /* Recursively call the subroutine. */
    setvalnb_f(lunit, tagpv, ntagpv, tagnb, ntagnb, r8val, iret);
}
 
void
catch_bort_getvalnb(int lunit, char *tagpv, int tagpv_len, int ntagpv,
                    char *tagnb, int tagnb_len, int ntagnb, double *r8val)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Add trailing nulls to input strings, for use with get_c_string_length inside of getvalnb_f. */
    tagpv[tagpv_len] = '\0';
    tagnb[tagnb_len] = '\0';
 
    /* Recursively call the function. */
    *r8val = getvalnb_f(lunit, tagpv, ntagpv, tagnb, ntagnb);
}
 
void
catch_bort_getabdb(int lunit, int itab, char (*ctabdb)[128], int *jtab)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    getabdb_f(lunit, itab, ctabdb, jtab);
}
 
void
catch_bort_ufbget(int lunit, double *tab, int i1, int *iret, char *cstr, int cstr_len)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Add a trailing null to cstr, for use with get_c_string_length inside of ufbget_f. */
    cstr[cstr_len] = '\0';
 
    /* Recursively call the subroutine. */
    ufbget_f(lunit, tab, i1, iret, cstr);
}
 
void
catch_bort_ufbinx(int lunit, int imsg, int isub, double *usr, int i1, int i2, int *iret, char *cstr, int cstr_len)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Add a trailing null to cstr, for use with get_c_string_length inside of ufbinx_f. */
    cstr[cstr_len] = '\0';
 
    /* Recursively call the subroutine. */
    ufbinx_f(lunit, imsg, isub, (void**) &usr, i1, i2, iret, cstr);
}
 
void
catch_bort_ufbovr(int lunit, double *usr, int i1, int i2, int *iret, char *cstr, int cstr_len)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Add a trailing null to cstr, for use with get_c_string_length inside of ufbovr_f. */
    cstr[cstr_len] = '\0';
 
    /* Recursively call the subroutine. */
    ufbovr_f(lunit, (void**) &usr, i1, i2, iret, cstr);
}
 
void
catch_bort_ifbget(int lunit, int *iret)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the function. */
    *iret = ifbget_f(lunit);
}
 
void
catch_bort_igetsc(int lunit, int *iret)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the function. */
    *iret = igetsc_f(lunit);
}
 
void
catch_bort_wrdxtb(int lundx, int lunot)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    wrdxtb_f(lundx, lunot);
}
 
void
catch_bort_mesgbf(int lunit, int *mesgtyp)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    mesgbf_f(lunit, mesgtyp);
}
 
void
catch_bort_mesgbc(int lunin, int *mesgtyp, int *icomp)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    mesgbc_f(lunin, mesgtyp, icomp);
}
 
void
catch_bort_invmrg(int lubfi, int lubfj)
{
    /* Set the target location to which to return if a bort error is caught. */
    if ( setjmp(context) == 1 ) return;
 
    /* Recursively call the subroutine. */
    invmrg_f(lubfi, lubfj);
}
 
void
catch_bort_iupm(char *cbay, int nbits, int *iret, int lcbay)
{
 
    /* Set the target location to which to return if a bort error is caught. */
    if (setjmp(context) == 1) return;
 
    /* Recursively call the function. */
    *iret = iupm_f(cbay, nbits, lcbay);
}
 
void
catch_bort_ipkm(char *cbay, int nbyt, int ival, int cbay_len)
{
 
    /* Set the target location to which to return if a bort error is caught. */
    if (setjmp(context) == 1) return;
 
    /* Recursively call the subroutine. */
    ipkm_f(cbay, nbyt, ival, cbay_len);
}