/* adamo.h */
/* Burkhard Burow, burow@cernvax.cern.ch, University of Toronto, 1991. */

/* With minor modifications for standard ADAMO distribution            */

#ifndef __ADAMO_LOADED
#define __ADAMO_LOADED

#include "cfortran.h"
#include "partap.h"

/* Some definitions that are useful for managing string in the
   common block */

static char __blanks[]="                                                   \
                                                                           \
                                                                           ";
 
#ifndef MAX
#define MAX(A,B) (A>B?A:B)
#endif

#ifndef MIN
#define MIN(A,B) (A<B?A:B)
#endif

#define FFSTRCPY(out,in)  { \
     int __n; \
     __n = sizeof(out); \
     strncpy(out,__blanks,__n); \
     __n = MIN (__n,sizeof(in)); \
     strncpy(out,in,MIN(__n,strlen(in))); \
  }

#define FCSTRCPY(out,in)  { \
     int __n; \
     __n = sizeof(out); \
     strncpy(out,__blanks,__n); \
     strncpy(out,in,MIN(__n,strlen(in))); \
  }

#define FFSTRNCPY(out,in,n)  { \
     int __n; \
     __n = MIN(sizeof(out),n); \
     strncpy(out,__blanks,__n); \
     __n = MIN(__n,strlen(in)); \
     strncpy(out,in,MIN(__n,sizeof(in))); \
  }

#define FCSTRNCPY(out,in,n)  { \
     int __n; \
     __n = MIN(sizeof(out),n); \
     strncpy(out,__blanks,__n); \
     strncpy(out,in,MIN(__n,strlen(in))); \
  }

/* To pass the address of the window common block to the TAP routines,
   introduce the type PSTRUCT to cfortran.h. */

#if defined(VAXC) && defined(vms)        /* To avoid %CC-I-PARAMNOTUSED. */
#pragma nostandard
#endif

#define VPSTRUCT              VSIMPLE
#define SEP_PSTRUCT        SEP_SIMPLE
#define INT_PSTRUCT        INT_SIMPLE
#define ZPSTRUCT              ZSIMPLE
#define STR_PSTRUCT        STR_SIMPLE
#define CCPSTRUCT            CCSIMPLE
#define AAPSTRUCT( T,A,B)     BPSTRUCT(T,A)
#define UPSTRUCT(  T,A)       NPSTRUCT(T,A)

#define NPSTRUCT(  T,A)          void * (A)
#define BPSTRUCT(  T,A)       (void *) &(A)

#if defined(VAXC) && defined(vms)        /* Have avoided %CC-I-PARAMNOTUSED. */
#pragma standard
#endif

#define DTAB(t) PRITAB(t,ID,MINC,MAXC,ALLCOL)

void INITAP();
void CREOBJ();

#define ADDDFL(DFL1,DFL2) CCALLSFSUB2(ADDDFL,adddfl,INT,INT, DFL1,DFL2)

#define AKYGAF(GAF,MAXCOL,NUMCOL,COLNAM,COLTYP)                                \
     CCALLSFSUB5(AKYGAF,akygaf,PINT,INT,PINT,PSTRINGV,PSTRINGV,                \
               GAF,MAXCOL,NUMCOL,COLNAM,COLTYP)

#define ASKCOL(TAB,COLNUM,WIDTH,TABOFF,WINOFF)                                 \
     CCALLSFSUB5(ASKCOL,askcol,PSTRUCT,INT,PINT,PINT,PINT,                     \
               TAB,COLNUM,WIDTH,TABOFF,WINOFF)

#define ASKACC(TAB,ACCNAM,IORS)                                                \
     CCALLSFSUB3(ASKACC,askacc,PSTRUCT,STRING,PSTRING, TAB,ACCNAM,IORS)

#define ASKDFL(DFL,DFLNAM,MAXWOR,N,VECT)                                       \
 CCALLSFSUB5(ASKDFL,askdfl,INT,PSTRING,INT,PINT,PVOID, DFL,DFLNAM,MAXWOR,N,VECT)

#define ASKGAF(GAF,OPT,VALUE)                                                  \
     CCALLSFSUB3(ASKGAF,askgaf,PINT,STRING,PSTRING, GAF,OPT,VALUE)

#define ASKIND(TAB,IND,INDNAM,MAXCOL,NUMCOL,COLNAM,ORD)                        \
     CCALLSFSUB7(ASKIND,askind,PSTRUCT,INT,PSTRING,INT,PINT,PSTRINGV,PSTRINGV, \
               TAB,IND,INDNAM,MAXCOL,NUMCOL,COLNAM,ORD)

#define ASKTAB(TAB,TABNAM,MAXCOL,NUMCOL,COLNAM,COLTYP,COLFOR,INIROW,MAXROW)    \
 CCALLSFSUB9(ASKTAB,asktab,PSTRUCT,PSTRING,INT,PINT,PSTRINGV,PSTRINGV,PSTRINGV,\
    PINT,PINT, TAB,TABNAM,MAXCOL,NUMCOL,COLNAM,COLTYP,COLFOR,INIROW,MAXROW)

#define ASKREL(TABNAM,COLNAM,MINC1,MINC2,MAXC2,TABNM2)                        \
 CCALLSFSUB6(ASKREL,askrel,STRING,STRING,PINT,PINT,PINT,PSTRING,              \
               TABNAM,COLNAM,MINC1,MINC2,MAXC2,TABNM2)

#define ASKGEN(TABNAM,COLNAM,MINC1,MAXTAB,NUMTAB,MINC2,MAXC2,TABNM2)          \
 CCALLSFSUB8(ASKGEN,askgen,STRING,STRING,PINT,INT,PINT,INTV,INTV,PSTRINGV,    \
                 TABNAM,COLNAM,MINC1,MAXTAB,NUMTAB,MINC2,MAXC2,TABNM2)

#define ASKTDF(TDFNAM,TORD)                                                    \
 CCALLSFSUB2(ASKTDF,asktdf,STRING,PSTRING, TDFNAM,TORD)

PROTOCCALLSFFUN2(LOGICAL,BELSEL,belsel,PSTRUCT,INT)
#define BELSEL(TAB,SEL) CCALLSFFUN2(BELSEL,belsel,PSTRUCT,INT, TAB,SEL)

PROTOCCALLSFFUN1(LOGICAL,BELTAB,beltab,PSTRUCT)
#define BELTAB(TAB) CCALLSFFUN1(BELTAB,beltab,PSTRUCT, TAB)

#define BINTAB(TAB,LINK) CCALLSFSUB2(BINTAB,bintab,PSTRUCT,INT, TAB,LINK)

#define BINWIN(TAB,MAXWOR,TABNAM,NUMWOR)                                       \
 CCALLSFSUB4(BINWIN,binwin,PSTRUCT,INT,STRING,PINT, TAB,MAXWOR,TABNAM,NUMWOR)

PROTOCCALLSFFUN2(LOGICAL,CHKTAB,chktab,PSTRUCT,STRING)
#define CHKTAB(TAB,CKMODE) CCALLSFFUN2(CHKTAB,chktab,PSTRUCT,STRING, TAB,CKMODE)

PROTOCCALLSFFUN0(INT,CHKTAP,chktap)
#define CHKTAP() CCALLSFFUN0(CHKTAP,chktap)

PROTOCCALLSFFUN2(LOGICAL,CHKWIN,chkwin,PSTRUCT,STRING)
#define CHKWIN(TAB,CKMODE) CCALLSFFUN2(CHKWIN,chkwin,PSTRUCT,STRING, TAB,CKMODE)

#define CLESEL(TAB,SEL) CCALLSFSUB2(CLESEL,clesel,PSTRUCT,INT, TAB,SEL)

#define CLEDFL(DFL) CCALLSFSUB1(CLEDFL,cledfl,INT, DFL)

#define CLENXT(TDF) CCALLSFSUB1(CLENXT,clenxt,PSTRUCT, TDF)

#define CLETAB(TDF) CCALLSFSUB1(CLETAB,cletab,PSTRUCT, TDF)

#define CLOGAF(GAF,ERRCOD) CCALLSFSUB2(CLOGAF,clogaf,PINT,PINT, GAF,ERRCOD)

#define CLOIND(TAB,IND) CCALLSFSUB2(CLOIND,cloind,PSTRUCT,INT, TAB,IND)

#define CLOSEL(TAB,SEL) CCALLSFSUB2(CLOSEL,closel,PSTRUCT,INT, TAB,SEL)

#define CLOTAB(TAB) CCALLSFSUB1(CLOTAB,clotab,PSTRUCT, TAB)

#define CLOTAP() CCALLSFSUB0(CLOTAP,clotap)

#define COPSEL(TAB,ACC1,CUR1,CUR2,SEL2,CMODE)                                  \
     CCALLSFSUB6(COPSEL,copsel,PSTRUCT,INT,INT,INT,PINT,INT,                   \
               TAB,ACC1,CUR1,CUR2,SEL2,CMODE)

PROTOCCALLSFFUN2(INT,COUSEL,cousel,PSTRUCT,INT)
#define COUSEL(TAB,SEL) CCALLSFFUN2(COUSEL,cousel,PSTRUCT,INT, TAB,SEL)

PROTOCCALLSFFUN1(INT,COUTAB,coutab,PSTRUCT)
#define COUTAB(TAB) CCALLSFFUN1(COUTAB,coutab,PSTRUCT, TAB)

#define CREDFL(DFL,DFLNAM) CCALLSFSUB2(CREDFL,credfl,PINT,STRING, DFL,DFLNAM)

#define CREGAF(GAF,KEY,OPTION,ERRCOD)                                          \
     CCALLSFSUB4(CREGAF,cregaf,PINT,PSTRUCT,STRING,PINT, GAF,KEY,OPTION,ERRCOD)

#define creind_ELEMS_5   ZTRINGV_ARGS(4)
#define creind_ELEMLEN_5 ZTRINGV_NUM(16)
#define creind_ELEMS_6   ZTRINGV_ARGS(4)
#define creind_ELEMLEN_6 ZTRINGV_NUM(4)
#define CREIND(TAB,IND,INDNAM,NUMCOL,COLNAM,ORD)                               \
     CCALLSFSUB6(CREIND,creind,PSTRUCT,PINT,STRING,INT,ZTRINGV,ZTRINGV,        \
               TAB,IND,INDNAM,NUMCOL,COLNAM,ORD)

#define CREPRO(TAB,PRO,PRONAM,NUMCOL,COLNAM)                                   \
     CCALLSFSUB5(CREPRO,crepro,PSTRUCT,PINT,STRING,INT,STRINGV,                \
               TAB,PRO,PRONAM,NUMCOL,COLNAM)

#define CREREL(ENT1,A2,A3,A4,A5,A6,ENT2)                                       \
     CCALLSFSUB7(CREREL,crerel,PSTRUCT,INT,STRING,INT,INT,INT,PSTRUCT,         \
               ENT1,A2,A3,A4,A5,A6,ENT2)

#define CRESEL(TAB,SEL,SELNAM)                                                 \
     CCALLSFSUB3(CRESEL,cresel,PSTRUCT,PINT,STRING, TAB,SEL,SELNAM)

#define CRESYN(TAB,SYN) CCALLSFSUB2(CRESYN,cresyn,PSTRUCT,PSTRUCT, TAB,SYN)

#define CRETAB(TAB,TABNAM,NUMCOL,COLNAM,COLTYP,INIROW,MAXROW)                  \
     CCALLSFSUB7(CRETAB,cretab,PSTRUCT,STRING,INT,STRINGV,STRINGV,INT,INT,     \
               TAB,TABNAM,NUMCOL,COLNAM,COLTYP,INIROW,MAXROW)

#define DEDGAF(ADDSUB,DRIVER)                                                  \
 CCALLSFSUB2(DEDGAF,dedgaf,PVOID,STRING, ADDSUB,DRIVER)

#define DELDFL(DFL,TDF) CCALLSFSUB2(DELDFL,deldfl,INT,PSTRUCT, DFL,TDF)

#define DELENT(ENT) CCALLSFSUB1(DELENT,delent,PSTRUCT, ENT)

#define DELGAF(GAF,KEY,ERRCOD)                                                 \
     CCALLSFSUB3(DELGAF,delgaf,PINT,PSTRUCT,PINT, GAF,KEY,ERRCOD)

#define DELREL(ENT1,COL,ENT2)                                                  \
     CCALLSFSUB3(DELREL,delrel,PSTRUCT,PINT,PSTRUCT, ENT1,COL,ENT2)

#define DELSEL(TAB,SEL) CCALLSFSUB2(DELSEL,delsel,PSTRUCT,INT, TAB,SEL)

#define DELGEN(ENT1,COL,ENT2)                                                  \
     CCALLSFSUB3(DELGEN,delgen,PSTRUCT,PVOID,PSTRUCT, ENT1,COL,ENT2)

#define DELTAB(TAB) CCALLSFSUB1(DELTAB,deltab,PSTRUCT, TAB)

#define DEMTAB(TAB,ACC,CUR1,CUR2)                                              \
     CCALLSFSUB4(DEMTAB,demtab,PSTRUCT,INT,INT,INT, TAB,ACC,CUR1,CUR2)

#define DESTAB(TAB) CCALLSFSUB1(DESTAB,destab,PSTRUCT, TAB)

#define DRODFL(DFL) CCALLSFSUB1(DRODFL,drodfl,INT, DFL)

#define DROGAF(GAF,ERRCOD) CCALLSFSUB2(DROGAF,drogaf,PINT,PINT, GAF,ERRCOD)

#define DROIND(TAB,IND) CCALLSFSUB2(DROIND,droind,PSTRUCT,INT, TAB,IND)

#define DROPRO(TAB,PRO) CCALLSFSUB2(DROPRO,dropro,PSTRUCT,INT, TAB,PRO)

#define DROSEL(TAB,SEL) CCALLSFSUB2(DROSEL,drosel,PSTRUCT,INT, TAB,SEL)

#define DROSYN(TAB,SYN) CCALLSFSUB2(DROSYN,drosyn,PSTRUCT,PSTRUCT, TAB,SYN)

#define DROTAB(TAB) CCALLSFSUB1(DROTAB,drotab,PSTRUCT, TAB)

#define DUPTAB(TAB1,TAB2,TABNAM)                                               \
     CCALLSFSUB3(DUPTAB,duptab,PSTRUCT,PSTRUCT,STRING, TAB1,TAB2,TABNAM)

#define FETCOL(TAB,COLNAM,ACC,CUR1,CUR2,VECT)                                  \
     CCALLSFSUB6(FETCOL,fetcol,PSTRUCT,STRING,INT,INT,INT,PVOID,               \
               TAB,COLNAM,ACC,CUR1,CUR2,VECT)

#define FETGAF(GAF,KEY,TDF,ERRCOD)                                             \
     CCALLSFSUB4(FETGAF,fetgaf,PINT,PSTRUCT,PSTRUCT,PINT, GAF,KEY,TDF,ERRCOD)

#define FETTAB(TAB,ACC,CUR)                                                    \
 CCALLSFSUB3(FETTAB,fettab,PSTRUCT,INT,INT, TAB,ACC,CUR)

#define FETTDF(TDF,MAXWOR,N,VECT)                                              \
 CCALLSFSUB4(FETTDf,fettdf,INT,INT,PINT,PVOID, TDF,MAXWOR,N,VECT)

#define FRELUN(LUN) CCALLSFSUB1(FRELUN,frelun,INT, LUN)

#define FUNGAF(ADDSUB) CCALLSFSUB1(FUNGAF,fungaf,PVOID, ADDSUB)

PROTOCCALLSFFUN1(INT,GETDFL,getdfl,STRING)
#define GETDFL(DFLNAM) CCALLSFFUN1(GETDFL,getdfl,STRING, DFLNAM)

PROTOCCALLSFFUN2(INT,GETIND,getind,PSTRUCT,STRING)
#define GETIND(TAB,INDNAM) CCALLSFFUN2(GETIND,getind,PSTRUCT,STRING, TAB,INDNAM)

#define GETLUN(LUN) CCALLSFSUB1(GETLUN,getlun,PINT, LUN)

PROTOCCALLSFFUN2(INT,GETPRO,getpro,PSTRUCT,STRING)
#define GETPRO(TAB,PRONAM) CCALLSFFUN2(GETPRO,getpro,PSTRUCT,STRING, TAB,PRONAM)

PROTOCCALLSFFUN2(INT,GETSEL,getsel,PSTRUCT,STRING)
#define GETSEL(TAB,SELNAM) CCALLSFFUN2(GETSEL,getsel,PSTRUCT,STRING, TAB,SELNAM)

#define GETTAB(TAB) CCALLSFSUB1(GETTAB,gettab,PSTRUCT, TAB)

PROTOCCALLSFFUN1(INT,GETTDF,gettdf,STRING)
#define GETTDF(TDFNAM) CCALLSFFUN1(GETTDF,gettdf,STRING, TDFNAM)

#define GETVER(TAPVER,GAFVER)                                                  \
 CCALLSFSUB2(GETVER,getver,PSTRING,PSTRING, TAPVER,GAFVER)

#define IDFIND(IND,C) TAPZBK.IZ[TAPZBK.LZ[AUXTAP.INDEXM-IND-1]+C-1]

#define INSCOL(TAB,COLNAM,VECT,NV)                                             \
     CCALLSFSUB4(INSCOL,inscol,PSTRUCT,STRING,PVOID,INT, TAB,COLNAM,VECT,NV)

#define INSDFL(DFL,TDF) CCALLSFSUB2(INSDFL,insdfl,INT,PSTRUCT, DFL,TDF)

#define INSENT(ENT) CCALLSFSUB1(INSENT,insent,PSTRUCT, ENT)

#define INSGAF(GAF,KEY,ERRCOD)                                                 \
     CCALLSFSUB3(INSGAF,insgaf,PINT,PSTRUCT,PINT, GAF,KEY,ERRCOD)

#define INSGEN(ENT1,COL,ENT2)                                                  \
     CCALLSFSUB3(INSGEN,insgen,PSTRUCT,PVOID,PSTRUCT, ENT1,COL,ENT2)

#define INSREL(ENT1,COL,ENT2)                                                  \
     CCALLSFSUB3(INSREL,insrel,PSTRUCT,PINT,PSTRUCT, ENT1,COL,ENT2)

#define INSSEL(TAB,SEL) CCALLSFSUB2(INSSEL,inssel,PSTRUCT,INT, TAB,SEL)

#define INSTAB(TAB) CCALLSFSUB1(INSTAB,instab,PSTRUCT, TAB)

#define INVREL(ENT1,COL,ENT2,ACC,COLNAM)                                       \
     CCALLSFSUB5(INVREL,invrel,PSTRUCT,PINT,PSTRUCT,INT,STRING,                \
               ENT1,COL,ENT2,ACC,COLNAM)

#define LISGAF() CCALLSFSUB0(LISGAF,lisgaf)

#define LISTAB(TDF) CCALLSFSUB1(LISTAB,listab,PSTRUCT, TDF)

/* use the following with care --- Wolfgang Wander's  addition */
#define cLOCRID(Tid,R) (TABZBK.LZ[AUXTAP.TABLEM-(Tid)-1]+\
	    TAPZBK.IZ[TAPZBK.LZ[AUXTAP.RIDBSM-(Tid)-1]+(R)]-1)

#define LOCRID(T,R) cLOCRID(*(int*)&(T),R)
/* - */

#define LOKLUN(LUN) CCALLSFSUB1(LOKLUN,loklun,INT, LUN)

#define MEMGAF(VECT,MAXWOR) CCALLSFSUB2(MEMGAF,memgaf,PVOID,INT, VECT,MAXWOR)

#define METGAF(GAF,TDFNAM,ERC)                                                 \
 CCALLSFSUB3(METGAF,metgaf,INT,STRING,PINT, GAF,TDFNAM,ERC)

#define NAFGEN(ENT1,COL,ENT2,ACC,CUR1,CUR2)                                    \
     CCALLSFSUB6(NAFGEN,nafgen,PSTRUCT,PVOID,PSTRUCT,INT,PINT,PINT,            \
               ENT1,COL,ENT2,ACC,CUR1,CUR2)

#define NAFREL(ENT1,COL,ENT2,ACC,CUR1,CUR2)                                    \
     CCALLSFSUB6(NAFREL,nafrel,PSTRUCT,PINT,PSTRUCT,INT,PINT,PINT,             \
               ENT1,COL,ENT2,ACC,CUR1,CUR2)

#define NAFSEL(ENT1,ACC1,COL,EXISTS,ENT2,ACC2,SEL)                             \
     CCALLSFSUB7(NAFSEL,nafsel,PSTRUCT,INT,PINT,INT,PSTRUCT,INT,PINT,          \
               ENT1,ACC1,COL,EXISTS,ENT2,ACC2,SEL)

#define NAMTDF(TDF,TDFNAM) CCALLSFSUB2(NAMTDF,namtdf,INT,PSTRING, TDF,TDFNAM)

#define NATGEN(ENT1,COL,ENT2,OK)                                               \
     CCALLSFSUB4(NATGEN,natgen,PSTRUCT,PVOID,PSTRUCT,PINT, ENT1,COL,ENT2,OK)

#define NATREL(ENT1,COL,ENT2,OK)                                               \
     CCALLSFSUB4(NATREL,natrel,PSTRUCT,PINT,PSTRUCT,PINT, ENT1,COL,ENT2,OK)

#define NATSEL(ENT1,ACC1,COL,COMPOP,COMPVL,ENT2,ACC2,SEL)                      \
     CCALLSFSUB8(NATSEL,natsel,PSTRUCT,INT,PINT,STRING,INT,PSTRUCT,INT,PINT,   \
               ENT1,ACC1,COL,COMPOP,COMPVL,ENT2,ACC2,SEL)

#define NAVREL(ENT1,COL,REL,ENT2,SEL)                          \
     CCALLSFSUB5(NAVREL,navrel,PSTRUCT,PINT,PINT,PSTRUCT,INT,  \
                 ENT1,COL,REL,ENT2,SEL)

#define NEXGAF(GAF,KEY,ERRCOD)                                                 \
     CCALLSFSUB3(NEXGAF,nexgaf,PINT,PSTRUCT,PINT, GAF,KEY,ERRCOD)

#define NULWIN(TAB) CCALLSFSUB1(NULWIN,nulwin,PSTRUCT, TAB)

#define OPEGAF(GAF,OPTION,ERRCOD)                                              \
     CCALLSFSUB3(OPEGAF,opegaf,PINT,STRING,PINT, GAF,OPTION,ERRCOD)

#define OPESEL(TAB,SEL) CCALLSFSUB2(OPESEL,opesel,PSTRUCT,INT, TAB,SEL)

#define OPETAB(TAB) CCALLSFSUB1(OPETAB,opetab,PSTRUCT, TAB)

#define OPETAP(MAXWOR) CCALLSFSUB1(OPETAP,opetap,INT, MAXWOR)

#define ORSEL(TAB,SEL) CCALLSFSUB2(ORSEL,orsel,PSTRUCT,INT, TAB,SEL)

#define PRIDFL(DFL) CCALLSFSUB1(PRIDFL,pridfl,INT, DFL)

#define PRIGAF(GAF) CCALLSFSUB1(PRIGAF,prigaf,PINT, GAF)

#define PRIIND(TAB,IND) CCALLSFSUB2(PRIIND,priind,PSTRUCT,INT, TAB,IND)

#define PRIROW(TAB,ACC,CUR,PMODE)                                              \
     CCALLSFSUB4(PRIROW,prirow,PSTRUCT,INT,INT,INT, TAB,ACC,CUR,PMODE)

#define PRISEL(TAB,SEL) CCALLSFSUB2(PRISEL,prisel,PSTRUCT,INT, TAB,SEL)

#define PRITAB(TDF,ACC,CUR1,CUR2,PRO)                                          \
     CCALLSFSUB5(PRITAB,pritab,PSTRUCT,INT,INT,INT,INT, TDF,ACC,CUR1,CUR2,PRO)

#define RECHAC(TDF) CCALLSFSUB1(RECHAC,rechac,PSTRUCT, TDF)

#define REMDFL(DFL1,DFL2) CCALLSFSUB2(REMDFL,remdfl,INT,INT, DFL1,DFL2)

#define REPCOL(TAB,COLNAM,ACC,CUR1,CUR2,VECT)                                  \
     CCALLSFSUB6(REPCOL,repcol,PSTRUCT,STRING,INT,INT,INT,PVOID,               \
               TAB,COLNAM,ACC,CUR1,CUR2,VECT)

#define REPENT(ENT) CCALLSFSUB1(REPENT,repent,PSTRUCT, ENT)

#define REPGAF(GAF,KEY,ERRCOD)                                                 \
     CCALLSFSUB3(REPGAF,repgaf,PINT,PSTRUCT,PINT, GAF,KEY,ERRCOD)

#define REPGEN(ENT1,COL,ENT2)                                                  \
     CCALLSFSUB3(REPGEN,repgen,PSTRUCT,PVOID,PSTRUCT, ENT1,COL,ENT2)

#define REPREL(ENT1,COL,ENT2)                                                  \
     CCALLSFSUB3(REPREL,reprel,PSTRUCT,PINT,PSTRUCT, ENT1,COL,ENT2)

#define REPTAB(TAB) CCALLSFSUB1(REPTAB,reptab,PSTRUCT, TAB)

#define REWGAF(GAF,ERRCOD) CCALLSFSUB2(REWGAF,rewgaf,PINT,PINT, GAF,ERRCOD)

#define SELADD(FILNAM) CCALLSFSUB1(SELADD,seladd,STRING, FILNAM)

#define SELTAB(TAB,IND,CUR1,CUR2)                                              \
     CCALLSFSUB4(SELTAB,seltab,PSTRUCT,INT,PINT,PINT, TAB,IND,CUR1,CUR2)

#define SETAIL(WIN,MAXWOR,NUMWOR)                                              \
 CCALLSFSUB3(SETAIL,setail,PSTRUCT,INT,PINT, WIN,MAXWOR,NUMWOR)

#define SETCHK(CHECK) CCALLSFSUB1(SETCHK,setchk,STRING, CHECK)

#define ASKCHK(CHECK) CCALLSFSUB1(ASKCHK,askchk,PSTRING, CHECK)

#define SETDIV(TDF,DIV) CCALLSFSUB2(SETDIV,setdiv,INT,PINT, TDF,DIV)

#define SETFOR(TAB,COLNAM,COLFOR)                                              \
     CCALLSFSUB3(SETFOR,setfor,PSTRUCT,STRING,STRING, TAB,COLNAM,COLFOR)

#define SETGAF(GAF,TDF,OPTION)                                                 \
     CCALLSFSUB3(SETGAF,setgaf,PINT,PSTRUCT,STRING, GAF,TDF,OPTION)

#define SETGPO(OPTION) CCALLSFSUB1(SETGPO,setgpo,STRING, OPTION)

#define SETSPA(OPTS) CCALLSFSUB1(SETSPA,setspa,STRING, OPTS)

#define SETTIT(TITVER,TITLIN,TITLE)                                            \
     CCALLSFSUB3(SETTIT,settit,INT,INT,STRING, TITVER,TITLIN,TITLE)

#define SETTPO(TDF,OPTION)                                                     \
     CCALLSFSUB2(SETTPO,settpo,PSTRUCT,STRING, TDF,OPTION)

#define SNPGAF(GAF,KEY,FILTER)                                                 \
     CCALLSFSUB3(SNPGAF,snpgaf,PINT,PSTRUCT,STRING, GAF,KEY,FILTER)

#define SOPSEL(TAB,ACC1,OP,ACC2,SEL,CMODE)                                     \
     CCALLSFSUB6(SOPSEL,sopsel,PSTRUCT,INT,INT,INT,PINT,INT,                   \
               TAB,ACC1,OP,ACC2,SEL,CMODE)

PROTOCCALLSFFUN1(INT,SPATAB,spatab,INT)
#define SPATAB(TDF) CCALLSFFUN1(SPATAB,spatab,INT, TDF)

#define UNISEL(TAB,SEL,COU,UMODE)                                              \
     CCALLSFSUB4(UNISEL,unisel,PSTRUCT,INT,PINT,INT, TAB,SEL,COU,UMODE)

#define UPDIND(TAB,IND) CCALLSFSUB2(UPDIND,updind,PSTRUCT,INT, TAB,IND)

#endif                             /* __ADAMO_LOADED */