root/tags/5.4.pre05/ciapi.h @ 1

#ifndef __CIAPI_H
#define __CIAPI_H

/*
        Uso de las funciones de ciapi desde programas en c.
        tratando de modificar los programas existes lo menos posibles.
 */

/*
        En los programas en C usar RECSTRU*, TRMSTR0U* y DBXSTRU* como void*
 */

#if WIN32
#define THREADDEC  __declspec(thread)
#endif /* WIN32 */

#include "cisis.h"
#include "cirun.h"

//nrecs, vrecp, ntrms, vtrmp

#define nrecs                   *(cisisnrecs( ciapip ))
#define vrecp                   cisisvrecp( ciapip )

#define ntrms                   *(cisisntrms( ciapip ))
#define vtrmp                   cisisvtrmp( ciapip )

#define ndbxs                   *(cisisndbxs( ciapip ))

#define maxnrec         cisismaxnrec( ciapip )
#define maxntrm         cisismaxntrm( ciapip )

// Uso de las variables TRMxxx
#define TRMrc                   *(cisisTermTRMrc( trmp ))
#define TRMkey                  cisisTermTRMkey( trmp )
#define TRMpmfn         *(cisisTermTRMpmfn( trmp ))
#define TRMptag         *(cisisTermTRMptag( trmp ))
#define TRMpocc         *(cisisTermTRMpocc( trmp ))
#define TRMpcnt         *(cisisTermTRMpcnt( trmp ))
#define TRMpost         *(cisisTermTRMpost( trmp ))
#define TRMlcase                *(cisisTermTRMlcase( trmp ))
#define TRMxytotp               *(cisisTermTRMxytotp( trmp ))
#define TDBname         *(cisisTermTDBname( trmp ))

#define VTRMrc(r)                       *(cisisTermVTRMrc( ciapip, r ))
#define VTRMkey(r)              cisisTermVTRMkey( ciapip, r )
#define VTRMxytotp(r)   *(cisisTermVTRMxytotp( ciapip, r ))

#define VTRMpmfn(r)             *(cisisTermVTRMpmfn( ciapip, r ))
#define VTRMptag(r)             *(cisisTermVTRMptag( ciapip, r ))
#define VTRMpocc(r)             *(cisisTermVTRMpocc( ciapip, r ))
#define VTRMpcnt(r)             *(cisisTermVTRMpcnt( ciapip, r ))

#define VTDBname(r)             *(cisisTermVTDBname( ciapip, r ))

// Uso de las variables XXXyyy asociadas a RECSTRU
#define MF0nxtmfn               *(cisisRecordMF0nxtmfn( recp ))
#define RECrc                   *(cisisRecordRECrc( recp ))
#define RECtype         *(cisisRecordRECtype( recp ))
#define RECnbytes               *(cisisRecordRECnbytes( recp ))
#define RECdbxp         *(cisisRecordRECdbxp( recp ))
#define RDBmsmfn                *(cisisRecordRDBmsmfn( recp ))
#define RDBvderp                *(cisisRecordRDBvderp( recp ))
#define RDBname         cisisRecordRDBname( recp )
#define RDBvgzrp                *(cisisRecordRDBvgzrp( recp ))
#define MFRmfn                  *(cisisRecordMFRmfn( recp ))
#define MFRmfrl         *(cisisRecordMFRmfrl( recp ))
#define MFRmfbwb                *(cisisRecordMFRmfbwb( recp ))
#define MFRmfbwp                *(cisisRecordMFRmfbwp( recp ))
#define MFRnvf                  *(cisisRecordMFRnvf( recp ))
#define MFRbase         *(cisisRecordMFRbase( recp ))
#define MFRstatus               *(cisisRecordMFRstatus( recp ))

// Uso de las variables Vxxx
#define VRECdbxp( r )   *(cisisRecordVRECdbxp( ciapip, r ))
#define VRECrc( r )             *(cisisRecordVRECrc( ciapip, r ))
#define VRECtype( r )   *(cisisRecordVRECtype( ciapip, r ))
#define VREClock( r )   *(cisisRecordVREClock( ciapip, r ))
#define VRECwlock( r )  *(cisisRecordVRECwlock( ciapip, r ))
#define VRECgdbl( r )           *(cisisRecordVRECgdbl( ciapip, r ))
#define VRECgdbw( r )           *(cisisRecordVRECgdbw( ciapip, r ))


#define VMFRmfn( r )            *(cisisRecordVMFRmfn( ciapip, r ))
#define VMFRstatus( r ) *(cisisRecordVMFRstatus( ciapip, r ))
#define VMFRnvf( r)             *(cisisRecordVMFRnvf( ciapip, r ))
#define VMFRmfrl( r )   *(cisisRecordVMFRmfrl( ciapip, r ))
#define VMFRbase( r )   *(cisisRecordVMFRbase( ciapip, r ))


#define VDIRtag( r, x ) cisisRecordVDIRtag( ciapip, r, x )
#define VDIRlen( r, x ) cisisRecordVDIRlen( ciapip, r, x )
#define VFIELDP( irec, xdir ) cisisRecordVFIELDP( ciapip, irec, xdir )

#define VMF0nxtmfn( r ) *(cisisRecordVMF0nxtmfn( ciapip, r ))

#define VMF0mfcxx1( r ) *(cisisRecordVMF0mfcxx1( ciapip, r ))
#define VMF0mfcxx2( r ) *(cisisRecordVMF0mfcxx2( ciapip, r ))
#define VMF0mfcxx3( r ) *(cisisRecordVMF0mfcxx3( ciapip, r ))

#define VMFX( r )                       cisisVMFX( ciapip, r )

#define VRDBname( r )   cisisRecordVRDBname( ciapip, r )
#define VRDBnetws( r )  *(cisisRecordVRDBnetws( ciapip, r ))
#define VRDBdelxx( r )  *(cisisRecordVRDBdelxx( ciapip, r ))
#define VRDBewlxx( r )  *(cisisRecordVRDBewlxx( ciapip, r ))
#define VRDBmsopw(r)    *(cisisRecordVRDBmsopw( ciapip, r ))
#define VRDBmsopn(r)            *(cisisRecordVRDBmsopn( ciapip, r ))


//uso de registro ...
#define DIRtag(x)       cisisRecordDIRtag( recp, x )
#define DIRlen(x)       cisisRecordDIRlen( recp, x )
#define FIELDP(xdir)            cisisRecordFIELDP( recp, xdir )

//equivalente a las funciones de CISIS para creacion de RECSTRU
#define record(x,dbn,mfn)                       cisisRecord( ciapip, x, dbn, mfn )
#define RECORD(irec,dbn,mfn)            recp=vrecp[record(irec,dbn,mfn)]
#define recallok(irec, nbytes)  cisisRecordAlloc( ciapip, irec, nbytes )
#define RECFREE(x)                                      cisisRecordDelete( x )
#define recmfp()                                                cisisRecordrecmfp( recp )

#define recwmast(crecp,recp,comb,comp,newblk,wlen)  cisisrecwmast(crecp,recp,comb,comp,newblk,wlen)
#define recxref(recp,mfn,comb,comp) cisisrecxref(recp,mfn,comb,comp)


//equivalente a las funciones de CISIS para creacion de TRMSTRU
#define term(itrm,dbn,key)                      cisisTerm( ciapip,itrm,dbn,key )
#define TERM(itrm,dbn,key)                      trmp = vtrmp[cisisTerm( ciapip,itrm,dbn,key )]
#define NXTERM(itrm)                                    trmp = cisisTermNext( ciapip, itrm )
#define nxterm(itrm)                                    cisisTermNext( ciapip, itrm )
#define posting(itrm,n)                         cisisTermPosting( ciapip, itrm, n)

#define trmalloc( itrm, nbytes)                 cisisTermAlloc( ciapip, itrm, nbytes )
#define TRMALLOC( itrm, nbytes)                 trmp = cisisTermAlloc( ciapip, itrm, nbytes )

//trace

#define dbxtrace                                                                *(cisisdbxtrace( ciapip ))
#define rectrace                                                                *(cisisrectrace( ciapip ))
#define dectrace                                                                *(cisisdectrace( ciapip ))
#define trmtrace                                                                *(cisistrmtrace( ciapip ))
#define multrace                                                                *(cisismultrace( ciapip ))
#define b70trace                                                                *(cisisb70trace( ciapip ))
#define b40trace                                                                *(cisisb40trace( ciapip ))
#define b50trace                                                                *(cisisb50trace( ciapip ))
#define fmttrace                                                                *(cisisfmttrace( ciapip ))
#define fsttrace                                                                *(cisisfsttrace( ciapip ))
#define cgitrace                                                                *(cisiscgitrace( ciapip ))

// FMT

#define fmt_gener( pgmpp, fmtp )                                                        cisisfmt_gener( ciapip, pgmpp, fmtp )
#define fmt_inter( pgmp, irec, lw, areap, asize )       cisisfmt_inter( ciapip, pgmp,irec, lw, areap, asize)
#define fmt_free( pgmp )                                                                        cisisfmt_free( ciapip, pgmp )

#define fmterrxy( pgmp )                                                                        cisisfmterrxy( ciapip, pgmp )

#define recfmt(idx,lw,fmt,area,asize)   cisisrecfmt(ciapip,vrecp[idx],lw,fmt,area,asize)
#define recread(recp, mfn)                                      cisisrecread(ciapip, recp, mfn)
#define recreset(dbnamp, mfn1, mfn2, xrec, parmtell)    cisisrecreset(ciapip, dbnamp, mfn1, mfn2, vrecp[xrec], parmtell)
#define recunlck(irec, option)                  cisisrecunlck(ciapip, vrecp[irec], option)



#define recreadl                                                                *(cisisrecreadl( ciapip ))
#define recreadb                                                                *(cisisrecreadb( ciapip ))
#define recreadp                                                                *(cisisrecreadp( ciapip ))

#define fmt_fsiz                                                                *(cisisfmt_fsiz( ciapip ))
#define fmt_errof                                                               *(cisisfmt_errof( ciapip ))
#define fmt_error                                                               *(cisisfmt_error( ciapip ))

//FST

#define fst_gener(pgmpp, fstspecp)                                              cisisfst_gener( ciapip, (void**)pgmpp, fstspecp )
#define fst_inter(pgmp, irec, stwp,area1pp, max1,area2pp, max2, qty1p, qty2p)           cisisfst_inter( ciapip,pgmp, vrecp[irec], stwp,area1pp, max1,area2pp, max2,qty1p, qty2p )
#define fst_open(gidbnp, filnamp, treecase)                     cisisfst_open( ciapip,gidbnp, filnamp, treecase)
#define fst_clos(treecase)                                                                      cisisfst_clos( ciapip, treecase )
#define fst_free(pgmp)                                                                          cisisfst_free( ciapip, pgmp )

#define fst_fd                                                                  cisisfst_fd( ciapip )
#define fst_fx                                                                  cisisfst_fx( ciapip )
#define fst_hdrx                                                                *(cisisfst_hdrx( ciapip ))
#define fst_hdru                                                                *(cisisfst_hdru( ciapip ))
#define fst_hdrt                                                                *(cisisfst_hdrt( ciapip ))
#define fst_hdrp                                                                *(cisisfst_hdrp( ciapip ))
#define fst_errl                                                                *(cisisfst_errl( ciapip ))
#define fst_errp                                                                *(cisisfst_errp( ciapip ))
#define fst_error                                                               *(cisisfst_error( ciapip ))

#define fst_batchup                                                     *(cisisfst_batchup( ciapip ))
#define fst_batchp                                                      *(cisisfst_batchp( ciapip ))
#define fst_batch0                                                      *(cisisfst_batch0( ciapip ))

#define fst_wlupifnp                   *(cisisfst_wlupifnp( ciapip ))
#define fst_wluptrmp                   *(cisisfst_wluptrmp( ciapip ))
#define fst_wlupitrm                   *(cisisfst_wlupitrm( ciapip ))

#define cifstfix                                                                *(cisiscifstfix( ciapip ))
#define cifstfim                                                                *(cisiscifstfix( ciapip ))

//IFL

#define ciiflfix                                                                *(cisisciiflfix( ciapip ))
#define ciiflfim                                                                *(cisisciiflfix( ciapip ))

#define ifl_balan                                                               *(cisisifl_balan( ciapip ))

//ISO

#define iso_open(gidbnp, filnam, lrecb, lrfix, isfix)           cisisiso_open( ciapip, gidbnp, filnam, lrecb, lrfix, isfix)
#define iso_read(crec, irec, ldrtag)                                                    cisisiso_read( ciapip, vrecp[irec], ldrtag)
#define iso_creat(gidbnp, filnam, lrecb, lrfox, isfox)  cisisiso_creat( ciapip, gidbnp, filnam, lrecb, lrfox, isfox)
#define iso_write(recp, isoxfs, isoxgs, ldrtag)                         cisisiso_write( ciapip, recp, isoxfs, isoxgs, ldrtag)
#define iso_close()                                                                                                     cisisiso_close( ciapip )
// miscelaneas ...

#define DBXmsmfn                                                                        *(cisisDbxDBXmsmfn( dbxp ))
#define DBXirecs                                                                        *(cisisDbxDBXirecs( dbxp ))
#define DBXipadd                                                                        cisisDbxDBXipadd( dbxp )
#define DBXipdel                                                                        cisisDbxDBXipdel( dbxp )
#define DBXvgzrp                                                                        *(cisisDbxDBXvgzrp( dbxp ))
#define DBXxryyp                                                                        *(cisisDbxDBXxryyp( dbxp ))
#define DBXxropw                                                                        *(cisisDbxDBXxropw( dbxp ))
#define DBXxropn                                                                        *(cisisDbxDBXxropn( dbxp ))
#define DBXmsopn                                                                        *(cisisDbxDBXmsopn( dbxp ))

#define VDBXvgzrp( r )                                                  *(cisisDbxVDBXvgzrp( ciapip, r ))
#define VDBXname( r )                                                   cisisDbxVDBXname( ciapip, r )

#define dbnp_dbxnetws(p)                                                *(cisisDbnpdbxnetws( ciapip, p ))
#define dbnp_dbxitrac(p)                                                *(cisisDbnpdbxitrac( ciapip, p ))
#define dbnp_dbxirecs(p)                                                *(cisisDbnpdbxirecs( ciapip, p ))
#define dbnp_dbxipadd(p)                                                cisisDbnpdbxipadd( ciapip, p )

#define DBXxribpxrmfptr                                                 cisisDBXxribpxrmfptr( dbxp )
#define DBXxribpxrxrpos                                                 *(cisisDBXxribpxrxrpos( dbxp ))

#define dbxopt_fatal                                                            *(cisisdbxopt_fatal( ciapip ))
#define dbxopt_ordwr                                                            *(cisisdbxopt_ordwr( ciapip ))

#define dbxsleep                                                                        *(cisisdbxsleep( ciapip ))
#define dbxewlrc                                                                        *(cisisdbxewlrc( ciapip ))
#define dbxfloop                                                                        *(cisisdbxfloop( ciapip ))
#define dbxwloop                                                                        *(cisisdbxwloop( ciapip ))
#define dbxiloop                                                                        *(cisisdbxiloop( ciapip ))

#define dbxcdcip                                                                        *(cisisdbxcdcip( ciapip ))


#define cicopyr(namep) cisiscicopyr(namep)

#define dbxopen(gidbnp, dbnamp, extp )          cisisdbxopen( ciapip,gidbnp, dbnamp, extp )
#define dbxopenc(gidbnp, filnamp,opnp,opwp,errmsgp, xcreate, xappend)   cisisdbxopenc(ciapip, gidbnp, filnamp,opnp,opwp,errmsgp, xcreate, xappend)
#define dbxopenw(gidbnp, dbnamp,extp,opnp,opwp,errmsgp) cisisdbxopenw( ciapip,gidbnp, dbnamp,extp,opnp,opwp,errmsgp )

#define dbxcipar(gidbnp, argkey, argchar)       cisisdbxcipar( ciapip,gidbnp, argkey, argchar)
#define subfldp(fldp, dlm, lenp)                                cisissubfldp( fldp, dlm, lenp )
#define subfldn(sfldp, len)                                     cisissubfldn( sfldp, len )
#define recisis0( x )                                                   cisisrecisis0( ciapip, x )
#define trmisis0( x )                                                   cisistrmisis0( ciapip, x )
#define dbxstorp(x)                                                             cisisdbxstorp( ciapip, x )
#define fldupdat(irec, batchp)                          cisisfldupdat( vrecp[irec], batchp )
#define recupdat(crec,irec)                                                     cisisrecupdat( vrecp[irec] )
#define nocc(irec, tag)                                                 cisisnocc( vrecp[irec], tag )
#define fieldx(irec, tag, occ)                          cisisfieldx( vrecp[irec], tag, occ )
#define fldocc(irec, diridx)                                    cisisfldocc( ciapip, vrecp[irec], diridx )

#define fatal(x)                                                                        cisisfatal( ciapip, x )

//#define b70trace    *( cisisb70trace( ciapip ))

#define MFX     cisisMFX( recp )

#define loaductb(gidbnp,uctbp,ucfilp) cisisloaductb(ciapip, gidbnp, uctbp, ucfilp)
#define loadactb(gidbnp,actbp,acfilp) cisisloadactb(ciapip, gidbnp, actbp, acfilp)

//variables de cirun.h
#define bitmask cisisbitmask( ciapip )
#define xx1extp cisisxx1extp( ciapip )

#define loadfile(gidbnp,at,atp,areap,asize,lf2x)        cisisloadfile( ciapip, gidbnp, at, atp, areap, asize, lf2x )

#define showcore(msg)                           cisisshowcore(ciapip,msg)
#define prtfields(recp,mfn)             cisisprtfields(recp, mfn)

#define gizmread(gizdbnp, vgizpp, irec )        cisisgizmread(ciapip, gizdbnp, (void*)vgizpp)

#define loadstw(gidbnp, atp,areap,asize,nstws)          cisisloadstw(ciapip, gidbnp, atp,areap,asize,nstws)

#define dbxcinet(dbnamp)                   cisisdbxcinet(ciapip, dbnamp)

#define prtcontrol(recp, dbname)        cisisprtcontrol(recp, dbname)
#define prtxref(recp, mfn)                      cisisprtxref(ciapip, recp, mfn)
#define prtleader(recp, mfn)            cisisprtleader(recp, mfn)
#define prtdir(recp, mfn)                       cisisprtdir(recp, mfn);


#define recfgets(crec, irec, line, linsiz, fpconv)              cisisrecfgets(ciapip, vrecp[crec], vrecp[irec], line, linsiz, fpconv)

#define recgizmo(irec, vgizmap) cisisrecgizmo(ciapip, vrecp[irec], vgizmap)


#define reccopy(upirec, upcrec, recp, mfn) cisisreccopy(ciapip, vrecp[upirec],vrecp[upcrec],recp,mfn)

#define invflush(dbnamp)        cisisinvflush(ciapip, dbnamp);

#define invsetup(dbnamp, loadn0x,loadl0x,loadpst)       cisisinvsetup(ciapip, dbnamp, loadn0x,loadl0x,loadpst)

#define dbxflush(dbnamp)        cisisdbxflush(ciapip, dbnamp)

#define dbxtmpnm(dirtmp, strip, filnamp)                                cisisdbxtmpnm(ciapip, dirtmp, strip, filnamp)
#define dbxcipfp                        *(cisisdbxcipfp(ciapip))
#define dbxcipok                        *(cisisdbxcipok(ciapip))

#define rec_maxmfrl                             *(cisisrec_maxmfrl( ciapip ))

#define highv                                           cisishighv( ciapip )

#define cipnetws                                        *(cisiscipnetws( ciapip ))

#define mx1extp                                 *(cisismx1extp( ciapip ))

#define cicgi0(argc, argv, wwwp, taghxsub, taghpfxp)            cisiscicgi0(ciapip, argc, argv, wwwp, taghxsub, taghpfxp)
//#define cicgi1(argc, argv, entries, nentries, cicgi_p)        cisiscicgi1(ciapip, argc, argv, entries, nentries, cicgi_p)

#define upif_end(dbnp, pstflag)                 cisisupif_end(ciapip, dbnp, pstflag)
#define upif_init(dbnp)                                         cisisupif_init(ciapip, dbnp)

#define mstsetup(dbnamp, loadxrf, loadmst)              cisismstsetup(ciapip, dbnamp, loadxrf, loadmst)
#define mstflush(dbnamp)                                                                cisismstflush(ciapip, dbnamp)


#define ifupdat(mdbnp,mfn1,mfn2,idbnp,fstp,stwp,maxlk1,maxlk2,pstflag,endup)    cisisifupdat(ciapip,mdbnp,mfn1,mfn2,idbnp,fstp,pstflag,endup)

#define ifupd_reset                     *(cisisifupd_reset(ciapip))
#define ifupd_wrnmsg                    *(cisisifupd_wrnmsg(ciapip))

#define svdifupd(lnk1p,qtylk1,lnk2p,qtylk2,olnk1p,oqtylk1,olnk2p,oqtylk2,pstflag,tell)  cisisvdifupd(ciapip,lnk1p,qtylk1,lnk2p,qtylk2,olnk1p,oqtylk1,olnk2p,oqtylk2,pstflag,tell)

#define svdifload(dbnp,filekeys_1,filekeys_2,pstflag,tell)              cisissvdifload(ciapip,dbnp,filekeys_1,filekeys_2,pstflag,tell)

#define fatal_errcod                    cisisfatal_errcod(ciapip)

#define recinit()                               cisisrecinit( ciapip )
#define trminit()                               cisistrminit( ciapip )
#define dbxinit()                               cisisdbxinit( ciapip )

// Funciones implementadas en CIAPI

#ifdef __WIN32__
#include <windows.h>
#define THREADDEC __declspec(thread)
#else
#define CALLBACK
#define THREADDEC
#endif

#ifdef __cplusplus
extern "C" {
#endif

void* CALLBACK cisisApplication(LONGX xmaxnrec, LONGX xmaxntrm);
void CALLBACK cisisApplicationDelete(void *ciapip);

LONGX* CALLBACK cisisnrecs(void *xciapip);
void** CALLBACK cisisvrecp( void *xciapip );

LONGX* CALLBACK cisisntrms(void *xciapip);
void** CALLBACK cisisvtrmp( void *xciapip );

LONGX* CALLBACK cisisndbxs(void *xciapip);

LONGX CALLBACK cisismaxnrec(void *xciapip);
LONGX CALLBACK cisismaxntrm(void *xciapip);

LONGX CALLBACK cisisRecord(void *ciapip, LONGX irec, char *dbnp, LONGX mfn);
LONGX CALLBACK cisisRecordAlloc(void *xciapip, LONGX irec, LONGX nbytes);
void CALLBACK cisisRecordDelete( void *xrecp );
int* CALLBACK cisisRecordRECrc(void *xrecp);
int* CALLBACK cisisRecordRECtype( void *xrecp );
LONGX* CALLBACK cisisRecordRECnbytes( void *xrecp );
void** CALLBACK cisisRecordRECdbxp( void *xrecp );
LONGX* CALLBACK cisisRecordMF0nxtmfn( void *xrecp );
char* CALLBACK cisisRecordRDBname( void *xrecp );
LONGX* CALLBACK cisisRecordRDBmsmfn( void *xrecp );
void** CALLBACK cisisRecordRDBvgzrp( void *xrecp );
void** CALLBACK cisisRecordRDBvderp( void *xrecp );
LONGX* CALLBACK cisisRecordMFRmfn( void *xrecp );
FFI* CALLBACK cisisRecordMFRmfrl( void *xrecp );
LONGX* CALLBACK cisisRecordMFRmfbwb( void *xrecp );
UWORD* CALLBACK cisisRecordMFRmfbwp( void *xrecp );
FFI* CALLBACK cisisRecordMFRbase( void *xrecp );
UWORD* CALLBACK cisisRecordMFRnvf( void *xrecp );
UWORD* CALLBACK cisisRecordMFRstatus( void *xrecp );

void* CALLBACK cisisRecordrecmfp( void *xrecp );

int CALLBACK cisisrecwmast(void *xcrecp, void *xrecp, LONGX b, int p, int nblk, FFI wlen);
int CALLBACK cisisrecxref(void *xrecp, LONGX mfn, LONGX *comb, int *comp);

UWORD CALLBACK cisisRecordDIRtag( void *xrecp, int x );
FFI CALLBACK cisisRecordDIRlen( void *xrecp, int x );
char* CALLBACK cisisRecordFIELDP( void *xrecp, int x );

void** CALLBACK cisisRecordVRECdbxp( void *xciapip, LONGX irec );
int* CALLBACK cisisRecordVRECrc( void *xciapip, LONGX irec );
int* CALLBACK cisisRecordVRECtype( void *xciapip, LONGX irec );
int *CALLBACK cisisRecordVREClock( void *xciapip, LONGX irec );
int *CALLBACK cisisRecordVRECwlock( void *xciapip, LONGX irec );
int* CALLBACK cisisRecordVRECgdbl( void *xciapip, LONGX irec );
int* CALLBACK cisisRecordVRECgdbw( void *xciapip, LONGX irec );

LONGX* CALLBACK cisisRecordVMFRmfn( void *xciapip, LONGX irec );
UWORD* CALLBACK cisisRecordVMFRstatus( void *xciapip, LONGX irec );
UWORD* CALLBACK cisisRecordVMFRnvf( void *xciapip, LONGX irec );
FFI *CALLBACK cisisRecordVMFRmfrl( void *xciapip, LONGX irec );
LONGX* CALLBACK cisisRecordVMF0nxtmfn( void *xciapip, LONGX irec );
LONGX* CALLBACK cisisRecordVMF0mfcxx1( void *xciapip, LONGX irec );
LONGX* CALLBACK cisisRecordVMF0mfcxx2( void *xciapip, LONGX irec );
LONGX* CALLBACK cisisRecordVMF0mfcxx3( void *xciapip, LONGX irec );
FFI* CALLBACK cisisRecordVMFRbase(  void *xciapip, LONGX irec );

char* CALLBACK cisisVMFX( void *xciapip, LONGX irec );

char* CALLBACK cisisRecordVRDBname( void *xciapip, LONGX irec );
int* CALLBACK cisisRecordVRDBnetws( void *xciapip, LONGX irec );
int* CALLBACK cisisRecordVRDBdelxx( void *xciapip, LONGX irec );
int* CALLBACK cisisRecordVRDBewlxx( void *xciapip, LONGX irec );
int* CALLBACK cisisRecordVRDBmsopw( void *xciapip, LONGX irec );
int* CALLBACK cisisRecordVRDBmsopn( void *xciapip, LONGX irec );

UWORD CALLBACK cisisRecordVDIRtag( void *xciapip, LONGX irec, int x );
FFI CALLBACK cisisRecordVDIRlen( void *xciapip, LONGX irec, int x );
char* CALLBACK cisisRecordVFIELDP( void *xciapip, LONGX irec, int x );


LONGX CALLBACK cisisTerm(void *xciapip, LONGX itrm, UCHR *dbnp, UCHR *keyp);
void* CALLBACK cisisTermAlloc(void *xciapip, LONGX itrm, LONGX nbytes );
void* CALLBACK cisisTermNext(void *xciapip, LONGX itrm);
LONGX* CALLBACK cisisTermTRMrc(void *xtrmp);
LONGX* CALLBACK cisisTermTRMpost(void *xtrmp);
int * CALLBACK cisisTermTRMlcase( void *xtrmp);
LONGX* CALLBACK cisisTermTRMpmfn(void *xtrmp);
UWORD* CALLBACK cisisTermTRMptag(void *xtrmp);
UWORD* CALLBACK cisisTermTRMpocc(void *xtrmp);
UWORD* CALLBACK cisisTermTRMpcnt(void *xtrmp);
UCHR* CALLBACK cisisTermTRMkey(void *xtrmp);
LONGX* CALLBACK cisisTermTRMxytotp(void *xtrmp);
LONGX CALLBACK cisisTermPosting(void *xciapip, LONGX itrm, LONGX nord);

char** CALLBACK cisisTermTDBname(void *xtrmp);

LONGX* CALLBACK cisisTermVTRMrc( void *xciapip, LONGX itrm );
UCHR* CALLBACK cisisTermVTRMkey( void *xciapip, LONGX itrm );
LONGX* CALLBACK cisisTermVTRMxytotp( void *xciapip, LONGX itrm );

LONGX* CALLBACK cisisTermVTRMpmfn( void *xciapip, LONGX itrm );
UWORD* CALLBACK cisisTermVTRMptag( void *xciapip, LONGX itrm );
UWORD* CALLBACK cisisTermVTRMpocc( void *xciapip, LONGX itrm );
UWORD* CALLBACK cisisTermVTRMpcnt( void *xciapip, LONGX itrm );

char** CALLBACK cisisTermVTDBname( void *xciapip, LONGX itrm );

LONGX* CALLBACK cisisDbxDBXmsmfn( void *xdbxp );
LONGX* CALLBACK cisisDbxDBXirecs( void *xdbxp );
LONGX* CALLBACK cisisDbxDBXipadd( void *xdbxp );
LONGX* CALLBACK cisisDbxDBXipdel( void *xdbxp );
void ** CALLBACK cisisDbxDBXvgzrp( void *xdbxp );

char** CALLBACK cisisDbxDBXxryyp( void *xdbxp );
int* CALLBACK cisisDbxDBXxropw( void *xdbxp );
int* CALLBACK cisisDbxDBXxropn( void *xdbxp );
int* CALLBACK cisisDbxDBXmsopn( void *xdbxp );


void** CALLBACK cisisDbxVDBXvgzrp( void *xciapip, LONGX idbx );
char *CALLBACK cisisDbxVDBXname( void *xciapip, LONGX idbx );

int* CALLBACK cisisDbnpdbxnetws( void *xciapip, char *dbnp );
int* CALLBACK cisisDbnpdbxitrac( void *xciapip, char *dbnp );
LONGX* CALLBACK cisisDbnpdbxirecs( void *xciapip, char *dbnp );
LONGX* CALLBACK cisisDbnpdbxipadd( void *xciapip, char *dbnp );

XRPTR* CALLBACK cisisDBXxribpxrmfptr( void *xdbxp );
XRPTR* CALLBACK cisisDBXxribpxrxrpos( void *xdbxp );

int* CALLBACK cisisdbxtrace( void *xciapip );
int* CALLBACK cisisrectrace( void *xciapip );
int* CALLBACK cisisdectrace( void *xciapip );
int* CALLBACK cisistrmtrace( void *xciapip );
int* CALLBACK cisismultrace( void *xciapip );
int* CALLBACK cisisb70trace( void *xciapip );
int* CALLBACK cisisb40trace( void *xciapip );
int* CALLBACK cisisb50trace( void *xciapip );
int* CALLBACK cisisfmttrace( void *xciapip );
int* CALLBACK cisisfsttrace( void *xciapip );
int* CALLBACK cisiscgitrace( void *xciapip );


LONGX CALLBACK cisisfmt_gener( void *xciapip, void **pgmpp, char *fmtp );
LONGX CALLBACK cisisfmt_inter( void *xciapip, void *xpgmp, LONGX irec, LONGX lw, char *areap, LONGX asize);
void CALLBACK cisisfmt_free( void *xciapip, void *xpgmp);

char* CALLBACK cisisfmterrxy( void *xciapip, void *xpgmp);

LONGX CALLBACK cisisrecfmt(void *xciapip, void *recp,LONGX lw,char *fmt,char *area,LONGX asize);
int CALLBACK cisisrecread(void *xciapip, void* xrecp, LONGX mfn);
void CALLBACK cisisrecreset(void *xciapip, char *dbnamp, LONGX mfn1, LONGX mfn2, void* xrecp, LONGX parmtell);
int CALLBACK cisisrecunlck(void *xciapip, void *xrecp, int option);


FFI* CALLBACK cisisrecreadl( void* xciapip );
LONGX* CALLBACK cisisrecreadb( void* xciapip );
int* CALLBACK cisisrecreadp( void* xciapip );

LONGX* CALLBACK cisisfmt_fsiz( void *xciapip );
LONGX* CALLBACK cisisfmt_errof( void *xciapip );
LONGX* CALLBACK cisisfmt_error( void *xciapip );

LONGX CALLBACK cisisfst_gener( void *xciapip, void **pgmpp, char *fstspecp );
LONGX CALLBACK cisisfst_inter( void *xciapip, void *pgmp, void *xrecp, char *stwp,char **area1pp, LONGX max1,char **area2pp, LONGX max2,LONGX *qty1p, LONGX *qty2p );
int CALLBACK cisisfst_open( void *xciapip, char *gidbnp, char *filnamp, int treecase );
int CALLBACK cisisfst_clos( void *xciapip, int treecase );
void CALLBACK cisisfst_free( void *xciapip, void *pgmpp );

int* CALLBACK cisisfst_fd( void *xciapip );
LONGX* CALLBACK cisisfst_fx( void *xciapip );
int* CALLBACK cisisfst_hdrx( void *xciapip );
int* CALLBACK cisisfst_hdru( void *xciapip );
int* CALLBACK cisisfst_hdrt( void *xciapip );
char** CALLBACK cisisfst_hdrp( void *xciapip );
LONGX* CALLBACK cisisfst_errl( void *xciapip );
char** CALLBACK cisisfst_errp( void *xciapip );
LONGX* CALLBACK cisisfst_error( void *xciapip );

char** CALLBACK cisisfst_batchup( void* xciapip );
char** CALLBACK cisisfst_batchp( void* xciapip );
int* CALLBACK cisisfst_batch0( void* xciapip );

char** CALLBACK cisisfst_wlupifnp( void *xciapip );
TRMSTRU** CALLBACK cisisfst_wluptrmp( void *xciapip );
LONGX* CALLBACK cisisfst_wlupitrm( void *xciapip );

int* CALLBACK cisiscifstfix( void* xciapip );
int* CALLBACK cisiscifstfim( void* xciapip );

int* CALLBACK cisisciiflfix( void* xciapip );
int* CALLBACK cisisciiflfim( void* xciapip );
int* CALLBACK cisisifl_balan( void* xciapip );

int CALLBACK cisisiso_open( void* xcisisp, char *gidbnp, unsigned char filnam[], int lrecb, int lrfix, int isfix);
int CALLBACK cisisiso_read( void* xcisisp, RECSTRU* xrecp, unsigned int ldrtag);
int CALLBACK cisisiso_creat( void* xcisisp, char *gidbnp, unsigned char filnam[], int lrecb, int lrfox, int isfox);
int CALLBACK cisisiso_write( void* xcisisp, void *xrecp, unsigned char isoxfs, unsigned char isoxgs, unsigned int ldrtag);
int CALLBACK cisisiso_close( void* xciapip );

int* CALLBACK cisisdbxopt_fatal( void *xciapip );

int* CALLBACK cisisdbxopt_ordwr( void *xciapip );

int* CALLBACK cisisdbxsleep(  void *xciapip );
int* CALLBACK cisisdbxewlrc(  void *xciapip );
int* CALLBACK cisisdbxfloop(  void *xciapip );
int* CALLBACK cisisdbxwloop(  void *xciapip );
int* CALLBACK cisisdbxiloop(  void *xciapip );

char** CALLBACK cisisdbxcdcip(  void *xciapip );

char* CALLBACK cisiscicopyr(char *namep);
int CALLBACK cisisdbxopen( void *xciapip, char *gidbnp, char *dbname, char *extp);
char* CALLBACK cisisdbxopenc(void *xciapip, char *gidbnp, char *filnamp,int *opnp,int *opwp,char *errmsgp, int xcreate, int xappend);
int CALLBACK cisisdbxopenw(void *xciapip, char *gidbnp, char *dbnamp,char *extp,int *opnp,int *opwp,char *errmsgp);
char* CALLBACK cisisdbxcipar( void *xciapip, char *gidbnp,char *argkey,char  argchar);
UBYTE* CALLBACK cisissubfldp( UBYTE *fldp, UBYTE dlm, FFI *lenp );
FFI CALLBACK cisissubfldn(UBYTE *sfldp, FFI len);
int CALLBACK cisisrecisis0(void *xciapip, char *dbname );
int CALLBACK cisistrmisis0(void *xciapip, char *dbname );
void* CALLBACK cisisdbxstorp(void *ciapip, char *dbnamp);
char* CALLBACK cisisfldupdat( void *xrecp, char *batchp);
int CALLBACK cisisrecupdat( void *xrecp);
int CALLBACK cisisnocc(void* xrecp, int tag);
int CALLBACK cisisfieldx(void *xrecp, int tag, int occ);
int CALLBACK cisisfldocc( void *xciapip, void* xrecp, int diridx );

void CALLBACK cisisfatal(void *xciapip, char *msg);

unsigned char* CALLBACK cisisbitmask( void *xciapip );
char* CALLBACK cisisxx1extp( void *xciapip );

int* CALLBACK cisisb70trace( void *xciapip );

char* CALLBACK cisisMFX( void *xrecp );

/* cirun.h */
int* CALLBACK cisisNXPAGES( void *xciapip );
int* CALLBACK cisisisiswctot( void *xciapip );
unsigned char* CALLBACK cisisisiswctab( void *xciapip );
unsigned char* CALLBACK cisisisisuctab( void *xciapip );

char* CALLBACK cisisloaductb(void *xciapip, char *gidbnp,char *uctbp,char *ucfilp);
char* CALLBACK cisisloadactb(void *xciapip, char *gidbnp,char *actbp,char *acfilp);

char* CALLBACK cisisloadfile( void *xciapip, char *gidbnp, char at, char *atp, char *areap, LONGX asize, char lf2x);
unsigned LONGX CALLBACK cisisshowcore(void *xciapip, char *msg);
LONGX CALLBACK cisisprtfields(RECSTRU *recp, LONGX mfn);

int CALLBACK cisisgizmread(void *xciapip, char *gizdbnp, void **vgizpp);

char* CALLBACK cisisloadstw(void *xciapip, char *gidbnp, char *atp,char *areap,LONGX asize,int *nstws);

int CALLBACK cisisdbxcinet(void *xciapip, char *dbnamp);

LONGX CALLBACK cisisprtcontrol(void *xrecp, char dbname[]);
LONGX CALLBACK cisisprtxref(void *xciapip, RECSTRU *recp, LONGX mfn);
LONGX CALLBACK cisisprtleader(RECSTRU *recp, LONGX mfn);
LONGX CALLBACK cisisprtdir(RECSTRU *recp, LONGX mfn);

int CALLBACK cisisrecfgets(void *xciapip, RECSTRU *crec, RECSTRU *irec, char line[], FFI linsiz, FILE *fpconv);
LONGX CALLBACK cisisrecgizmo(void *xciapip, RECSTRU *recp, VGIZPSTRU *vgizmap);


int CALLBACK cisisreccopy(void *xciapip, RECSTRU *upirec,RECSTRU *upcrec,RECSTRU *recp,LONGX mfn);

void CALLBACK cisisinvflush(void *xciapip, char *dbnamp);

void CALLBACK cisisinvsetup(void *xciapip, UCHR *dbnamp, LONGX loadn0x,LONGX loadl0x,LONGX loadpst);

void CALLBACK cisisdbxflush(void *xciapip, char *dbnamp);

char* CALLBACK cisisdbxtmpnm(void *xciapip, char *dirtmp, int strip, char *filnamp);
FILE** CALLBACK cisisdbxcipfp( void* xciapip );
int* CALLBACK cisisdbxcipok( void* xciapip );

LONGX* CALLBACK cisisrec_maxmfrl(void *xciapip);

char* CALLBACK cisishighv(void *xciapip);

int* CALLBACK cisiscipnetws(void *xciapip);

char** CALLBACK cisismx1extp(void *xciapip);

int CALLBACK cisiscicgi0(void *xciapip, int *argc, char *argv[], char **wwwp, UWORD taghxsub, char *taghpfxp);
int CALLBACK cisiscicgi1(void *xciapip, int *argc, char *argv[], CICGI_ENTRY entries[], int nentries, char *cicgi_p);

void CALLBACK cisisupif_init(void *xciapip, char *dbnp );
int CALLBACK cisisupif_end(void *xciapip, char *dbnp, int pstflag);

void CALLBACK cisismstsetup(void *xciapip, char *dbnamp, LONGX loadxrf, LONGX loadmst);
void CALLBACK cisismstflush(void *xciapip, char *dbnamp);

int CALLBACK cisisifupdat(void *xciapip, char *mdbnp, LONGX mfn1, LONGX mfn2, char *idbnp, void *xfst, int pstflag, int endup);

int* CALLBACK cisisifupd_reset(void *xciapip);
int* CALLBACK cisisifupd_wrnmsg(void *xciapip);


void CALLBACK cisisvdifupd(void *xciapip,char *lnk1p,LONGX qtylk1,char *lnk2p,LONGX qtylk2,char *olnk1p,LONGX oqtylk1,char *olnk2p,LONGX oqtylk2,int pstflag,LONGX tell);

LONGX CALLBACK cisissvdifload(void *xciapip,char *dbnp,char *filekeys_1,char *filekeys_2,int pstflag,LONGX tell);

int CALLBACK cisisfatal_errcod(void *xciapip);

void CALLBACK cisisrecinit(void *xciapip);
void CALLBACK cisistrminit(void *xciapip);
void CALLBACK cisisdbxinit(void *xciapip);


#ifdef __cplusplus
}
#endif /* extern "C" */


#endif  /* __CIAPI_H */