process_4dot2.c

Go to the documentation of this file.

 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
 
#define MXG2MNEM 16
 
#define MXG2MNEMP4 ( MXG2MNEM + 4)
 
#define NUMALLOC 2500
 
#define MXFNLEN 120
 
#ifdef UNDERSCORE
#define open_and_read_4dot2 open_and_read_4dot2_
#define sort_and_write_4dot2 sort_and_write_4dot2_
#define search_for_4dot2_entry search_for_4dot2_entry_
#define close_4dot2 close_4dot2_
#endif
 
#ifdef F77_INTSIZE_8
typedef long f77int;
#else
typedef int f77int;
#endif
 
struct TableEntry {
    char mnemonic[MXG2MNEMP4];
    int discipline;
    int category;
    int parameter;
};
 
struct TableEntry *pe0 = NULL;
 
size_t nentry = 0;
 
/* Prototypes. */
void open_and_read_4dot2(char *, f77int *);
void sort_and_write_4dot2(char *, f77int *);
/* void search_for_4dot2_entry(char *, f77int *, f77int *, f77int *, f77int *, f77int *); */
int compar(const struct TableEntry *, const struct TableEntry *);
void close_4dot2(f77int *);
 
int
compar(const struct TableEntry *pte1, const struct TableEntry *pte2)
{
    return strcmp(pte1->mnemonic, pte2->mnemonic);
}
 
/*
**  Define the remaining subprograms which will be called by user applications.
*/
 
void
open_and_read_4dot2(char *filename, f77int *iret)
{
 
    struct TableEntry *pra;
 
    char lfn[MXFNLEN+1], str[81], cflag, cub = '_';
 
    size_t i;
 
    FILE *pfn;
 
/*
**  Copy the input filename into a local variable and check it for validity.
**  This is especially important in case the filename was passed in as a
**  string literal by the calling program or else doesn't have a trailing
**  NULL character.
*/
    for (i = 0; (! isspace(filename[i]) && ! iscntrl(filename[i])); i++) {
        if (i == MXFNLEN) {
            *iret = (f77int) -1;
            return;
        }
        lfn[i] = filename[i];
    }
    lfn[i] = '\0';
 
/*
**  Open the file.
*/
    if ((pfn = fopen(lfn, "r")) == NULL) {
        *iret = (f77int) -2;
        printf("Can't open input file %s\n",lfn);
        return;
    }
 
/*
**  Read the file contents into an internal memory structure.  Memory will be
**  allocated as needed for NUMALLOC entries at a time.
*/
    while (fgets(str, 80, pfn) != NULL) {
        if (str[0] != '!') {    /* ignore comment lines */
            if ((nentry % NUMALLOC) == 0) {
/*
**              Allocate additional memory.
*/
                pra = realloc(pe0, (NUMALLOC * sizeof(struct TableEntry)));
                if (pra == NULL) {
                    *iret = (f77int) -3;
                    return;
                }
                pe0 = pra;
            }
            sscanf(str, "%d%d%d%*3c%c%*c%s",
                   &pe0[nentry].discipline, &pe0[nentry].category,
                   &pe0[nentry].parameter, &cflag,
                   pe0[nentry].mnemonic);
            strncat(pe0[nentry].mnemonic, &cub, 1);
            strncat(pe0[nentry].mnemonic, &cflag, 1);
            nentry++;
        }
    }
 
/*
**  Close the file.
*/
    fclose (pfn);
 
    *iret = (f77int) 0;
}
 
void
sort_and_write_4dot2(char *filename, f77int *iret)
{
#define MXFNLEN 120
 
    char lfn[MXFNLEN+1], str[MXG2MNEMP4], cflag;
 
    size_t i;
 
    FILE *pfn;
 
/*
**  Copy the filename into a local variable and check it for validity.
**  This is especially important in case the filename was passed in as a
**  string literal by the calling program or else doesn't have a trailing
**  NULL character.
*/
    for (i = 0; (! isspace(filename[i]) && ! iscntrl(filename[i])); i++) {
        if (i == MXFNLEN) {
            *iret = (f77int) -1;
            return;
        }
        lfn[i] = filename[i];
    }
    lfn[i] = '\0';
 
/*
**  Open the output file.
*/
    if ((pfn = fopen(lfn, "w")) == NULL) {
        *iret = (f77int) -2;
        printf("Can't open output file %s\n",lfn);
        return;
    }
 
/*
**  Sort the entries within the internal memory structure.
*/
    qsort(pe0, nentry, sizeof(struct TableEntry),
          (int (*) (const void *, const void *)) compar);
 
/*
**  Write the sorted entries to the output file.
*/
    for (i = 0; i < nentry; i++) {
        strcpy(str, pe0[i].mnemonic);
        cflag = str[strlen(str)-1];
        str[strlen(str)-2] = '\0';
        fprintf(pfn, "%4d%4d%6d   %c %s\n",
                pe0[i].discipline, pe0[i].category,
                pe0[i].parameter, cflag, str);
    }
/*
**  Close the file.
*/
    fclose (pfn);
 
    *iret = (f77int) 0;
}
 
void
search_for_4dot2_entry(char nemo[MXG2MNEM], f77int *locflg,
                       f77int *disc, f77int *catg, f77int *parm,
                       f77int *iret)
{
    unsigned short n = 0, n2 = 0;
 
    long llf;
 
    struct TableEntry key, *pbs;
 
    size_t ipt;
 
/*
**  Make a local copy of nemo.  Mnemonics may consist of any combination of
**  alphanumeric, underscore and dash characters.
*/
    while ( (n < MXG2MNEM) &&
            ((isalnum((int) nemo[n]) ||
              (nemo[n] == '_') || (nemo[n] == '-'))) ) {
        key.mnemonic[n2++] = nemo[n++];
    }
 
/*
**  Append an underscore followed by the locflg in order to generate the
**  mnemonic to search for.
*/
    key.mnemonic[n2++] = '_';
    llf = (long) *locflg;
    if (llf != 1) llf = 0;   /* default to using international entry unless
                                local is specified */
    sprintf(&key.mnemonic[n2], "%ld", llf);  /* trailing null will be automatically
                                                appended by sprintf */
 
/*
**  Search for the mnemonic in the Code Table and return appropriate output values.
*/
    pbs = bsearch(&key, pe0, nentry, sizeof(struct TableEntry),
                  (int (*) (const void *, const void *)) compar);
    if (pbs == NULL) {
        *iret = (f77int) -1;
    }
    else {
        *iret = (f77int) 0;
        ipt = pbs - pe0;
        *disc = (f77int) pe0[ipt].discipline;
        *catg = (f77int) pe0[ipt].category;
        *parm = (f77int) pe0[ipt].parameter;
    }
 
}
 
void
close_4dot2(f77int *iret)
{
    free (pe0);
    *iret = (f77int) 0;
}