home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c004 / 1.ddi / CTAPPX.C < prev    next >
Encoding:
C/C++ Source or Header  |  1989-04-18  |  16.7 KB  |  837 lines
  1. /*
  2.  *    System Independent Application Interface
  3.  *
  4.  *    This program is the CONFIDENTIAL and PROPRIETARY property 
  5.  *    of FairCom(R) Corporation. Any unauthorized use, reproduction or
  6.  *    transfer of this program is strictly prohibited.
  7.  *
  8.  *      Copyright (c) 1987, 1988, 1989 FairCom Corporation
  9.  *    (Subject to limited distribution and
  10.  *     restricted disclosure only.)
  11.  *    *** ALL RIGHTS RESERVED ***
  12.  *
  13.  *    4006 West Broadway
  14.  *    Columbia, MO 65203
  15.  *
  16.  *
  17.  *    c-tree(R)    Version 4.3
  18.  *            Release C 
  19.  *            February 7, 1989 17:30
  20.  *
  21.  */
  22.  
  23. #include "ctstdr.h"
  24. #include "ctoptn.h"
  25. #include "ctstrc.h"
  26. #include "cterrc.h"
  27. #include "ctcomm.h"
  28.  
  29. #define DEFASIZ 1024
  30. #define MAXASIZ    1024
  31.  
  32. LOCAL TEXT     *apxmsg;
  33. LOCAL COUNT    stpcnt;
  34. MESSAGE        cts_msg;
  35. TEXT           *ct_apxdat = NULL;
  36. COUNT        cts_usrid,uerr_cod,ct_mxfil,ct_ver,*altseq;
  37. UCOUNT        cts_mxaln,cts_apxsiz;
  38. COUNT        cts_keyops;
  39. KEYOPS           *cts_kops;
  40. COUNT           *cts_mops;
  41. COUNT        cts_ctry,cts_csuc,cts_cdat,cts_cseq;
  42. UCOUNT        cts_clen;
  43. TEXT           *cts_cptr;
  44. CTFILE         *ct_key,*ct_dat,*ct_vat;
  45. TREEBUFF       *ct_btree;
  46. TEXT           *ct_origin,ct_buf[CTBUFSIZ];
  47. LONG        ct_gsrl;
  48.  
  49. TEXT           *mballc();
  50. COUNT        ctlogin(),ctsrvr();
  51.  
  52. VOID getsrlnum(msgp)
  53. MESSAGE          *msgp;
  54. {
  55.     cpybuf(&ct_gsrl,&msgp->mfiln,sizeof(ct_gsrl));
  56. }
  57.  
  58. CTFILE *tstfnm(filno)
  59. COUNT          filno;
  60. {
  61.     FAST CTFILE *retval,*ctnum;
  62.     COUNT        nomemb;
  63.  
  64.     COUNT        uerr();
  65.     VOID         terr();
  66.  
  67.     uerr_cod = NO_ERROR;
  68.     if (ct_mxfil == 0) {
  69.         uerr(FINT_ERR);
  70.         return(NULL);
  71.     } else if (filno < 0 || ct_mxfil <= filno) { /* filno out of range */
  72.         uerr(FNUM_ERR);
  73.         return(NULL);
  74.     } else
  75.         retval = ct_key + filno;
  76.  
  77.     switch (retval->chnacs) {
  78. case 'n':
  79.         uerr_cod = FACS_ERR;
  80.         return(NULL);
  81. case 'y':
  82.         return(retval);
  83.  
  84. default:
  85.         printf("\nAPX fatal error 222\n");
  86.         exit(0);
  87.     }
  88. }
  89.  
  90. COUNT ctapxe(filno,func,pntr,ptr1)
  91. COUNT         filno,func;
  92. POINTER            pntr;
  93. TEXT                *ptr1;
  94. {
  95.     FAST CTFILE *ctnum;
  96.  
  97.     COUNT uerr();
  98.  
  99.     if (ct_apxdat == NULL)
  100.         return(uerr_cod = ALOG_ERR);
  101.  
  102.     cts_msg.musrn = cts_usrid;
  103.     cts_msg.mfiln = filno;
  104.     cts_msg.mpntr = pntr;
  105.  
  106.     if (cts_ctry) {
  107.         cts_msg.mretc = cts_ctry;
  108.         cts_msg.mseqn = cts_cdat;
  109.     } else if (cts_msg.mretc != VAR1st && func != TST_MSGSIZ)
  110.         cts_msg.mretc = 0;
  111.     cts_ctry = 0;
  112.  
  113.     switch (cts_msg.mfunc = func) {
  114.  
  115. case FN_ADDKEY:
  116. case FN_DELBLD:
  117. case FN_DELCHK:
  118.  
  119. case FN_EQLKEY:
  120. case FN_FRSKEY:
  121. case FN_GTEKEY:
  122. case FN_GTKEY:
  123. case FN_LSTKEY:
  124. case FN_LTEKEY:
  125. case FN_LTKEY:
  126. case FN_NXTKEY:
  127. case FN_PRVKEY:
  128. case FN_FRCKEY:
  129.         if ((ctnum = tstfnm(filno)) == NULL) {
  130.             cts_msg.mpntr = DRNZERO;
  131.             cts_msg.merrn = uerr_cod;
  132.             break;
  133.         }
  134.         
  135.         if (ptr1)
  136.             cpybuf(ct_apxdat,ptr1,cts_msg.mdlen = ctnum->length);
  137.         else
  138.             cts_msg.mdlen = 0;
  139.         ctsrvr(&apxmsg,&ct_apxdat,&cts_msg);
  140.         break;
  141.  
  142. case FN_OPNFIL:
  143. case FN_CREDAT:
  144. case FN_CREIDX:
  145. case FN_CREMEM:
  146.         if (ctlogin(&apxmsg,&ct_apxdat,filno,cts_apxsiz,ptr1,&cts_msg))
  147.             break;
  148.         cpybuf(ct_apxdat,ptr1,cts_msg.mdlen = sizeof(FILEPARM));
  149.         ctsrvr(&apxmsg,&ct_apxdat,&cts_msg);
  150.         break;
  151.  
  152. case FN_DATENT:
  153. case FN_SERIALNUM:
  154. case FN_GTVLEN:
  155. case FN_IDXENT:
  156. case FN_NEWREC:
  157. case FN_NEWVREC:
  158. case FN_RETREC:
  159. case FN_RETVREC:
  160. case FN_CLSFIL:
  161. case FN_DELFIL:
  162. case FN_LOKREC:
  163. case FN_DLOCK:
  164. case FN_RLOCK:
  165. case FN_UDLOCK:
  166. case FN_FLUSHDOS:
  167. case FN_TSTREC:
  168. case CNT_HDROUT:
  169. case TST_MSGSIZ:
  170. case TST_STPUSR:
  171. case TST_TRAN:
  172. case TST_SPCLOG:
  173.         cts_msg.mdlen = 0;
  174.         ctsrvr(&apxmsg,&ct_apxdat,&cts_msg);
  175.         break;
  176.  
  177. #ifdef CTS_ISAM
  178. case FN_MLTULK:
  179. case FN_MLTKEY:
  180.         ctsrvr(&apxmsg,&ct_apxdat,&cts_msg);
  181.         break;
  182.  
  183. case FN_MLTWRT:
  184. #endif
  185. case CNT_RECIN:
  186.         cpybuf(ct_apxdat,ptr1,cts_msg.mdlen);
  187.         ctsrvr(&apxmsg,&ct_apxdat,&cts_msg);
  188.         break;
  189.  
  190. case CNT_RECOUT:
  191.         cts_msg.mdlen = 0;
  192.         if (ctsrvr(&apxmsg,&ct_apxdat,&cts_msg) == NO_ERROR)
  193.             cpybuf(ptr1,ct_apxdat,cts_msg.mdlen);
  194.         break;
  195.  
  196. default:
  197.         printf("\n\nIllegal Function #%d\n\n",func);
  198.         exit(0);
  199.         
  200.     }
  201.  
  202.     if (cts_msg.mretc == CMBREDAT) {
  203.         if (cts_msg.merrn == 0) {
  204.         cts_csuc = YES;
  205.         if (!cts_cseq && cts_cptr != NULL) {
  206.             if (func != FN_EQLKEY)
  207.             cpybuf(cts_cptr,ct_apxdat + ctnum->length,cts_clen);
  208.             else
  209.             cpybuf(cts_cptr,ct_apxdat,cts_clen);
  210.         }
  211.         } else
  212.         cts_csuc  = NO;
  213.         cts_msg.mretc = 0;
  214.     } else if (cts_msg.mretc == CMBREDCN) {
  215.         cts_csuc      = NO;
  216.         cts_msg.mretc = 0;
  217.     } else
  218.         cts_csuc      = NO;
  219.         
  220.     return(uerr(cts_msg.merrn));
  221. }
  222.  
  223. #ifdef CTS_ISAM
  224. VOID intlmsg()
  225. {
  226.     cts_msg.mvlen = cts_msg.mdlen = 0;
  227. }
  228.  
  229. VOID sndlmsg()
  230. {
  231.     if (cts_msg.mvlen != 0) {
  232.         ctapxe(cts_msg.mfiln,FN_MLTULK,cts_msg.mpntr,NULL);
  233.         cts_msg.mvlen = cts_msg.mdlen = 0;
  234.     }
  235. }
  236.  
  237. VOID addlmsg(recbyt,datno)
  238. POINTER recbyt;
  239. COUNT           datno;
  240. {
  241.     FAST TEXT *tp;
  242.  
  243.     if (cts_msg.mvlen++ == 0) {
  244.         cts_msg.mfiln = datno;
  245.         cts_msg.mpntr = recbyt;
  246.     } else {
  247.         tp = ct_apxdat + cts_msg.mdlen;
  248.         cpybuf(tp,&recbyt,sizeof(POINTER));
  249.         cpybuf(tp + sizeof(POINTER),&datno,sizeof(COUNT));
  250.         cts_msg.mdlen += (sizeof(POINTER) + sizeof(COUNT));
  251.         if (cts_msg.mdlen >
  252.             (cts_mxaln - sizeof(POINTER) - sizeof(COUNT)))
  253.             sndlmsg();
  254.     }
  255. }
  256. #endif
  257.  
  258. COUNT recred(filno,recbyt,recptr,rlen,seqn)
  259. COUNT         filno;
  260. POINTER           recbyt;
  261. PFAST TEXT         *recptr;
  262. VRLEN                 rlen;
  263. COUNT                      seqn;
  264. {
  265.     cts_msg.mseqn = seqn;    /* when seqn == 0 length determined at server */
  266.     cts_msg.mvlen = rlen;
  267.     if (ctapxe(filno,CNT_RECOUT,recbyt,recptr))
  268.         return(uerr_cod);
  269.     while (cts_msg.mvlen > cts_msg.mdlen) {
  270.         recbyt          += cts_msg.mdlen;
  271.         recptr           += cts_msg.mdlen;
  272.         cts_msg.mvlen -= cts_msg.mdlen;
  273.         cts_msg.mseqn++;
  274.         if (ctapxe(filno,CNT_RECOUT,recbyt,recptr))
  275.             return(uerr_cod);
  276.     }
  277.     return(NO_ERROR);
  278. }
  279.  
  280. COUNT recwrt(filno,recbyt,recptr,rlen)
  281. COUNT         filno;
  282. POINTER           recbyt;
  283. PFAST TEXT         *recptr;
  284. VRLEN                 rlen;
  285. {
  286.     FAST COUNT i;
  287.  
  288.     cts_msg.mvlen = rlen;
  289.     /* # of msg to write */
  290.     cts_msg.mseqn = (rlen + cts_mxaln - 1) / cts_mxaln;
  291.     while (cts_msg.mseqn-- > 0) {
  292.         if (rlen > cts_mxaln) {
  293.             cts_msg.mdlen = cts_mxaln;
  294.             rlen         -= cts_mxaln;
  295.         } else
  296.             cts_msg.mdlen = rlen;
  297.         if (ctapxe(filno,CNT_RECIN,recbyt,recptr))
  298.             return(cts_msg.merrn);
  299.         /* turn off variable length 1st segment signal */
  300.         cts_msg.mretc = 0;
  301.         recptr   += cts_mxaln;
  302.         recbyt   += cts_mxaln;
  303.     }
  304.     return(NO_ERROR);
  305. }
  306.  
  307. /* --------------------------------------------------------------------
  308.    LOCK data record
  309.  */
  310.  
  311. COUNT DLOCK(recbyt,dnum)        /* recbyt == 0  => header record */
  312. POINTER        recbyt;
  313. PFAST DATFILE  *dnum;
  314. {
  315.     return(ctapxe(dnum->filnum,FN_DLOCK,recbyt,NULL));
  316. }
  317.  
  318. COUNT RLOCK(recbyt,dnum)
  319. POINTER        recbyt;
  320. PFAST DATFILE  *dnum;
  321. {
  322.     return(ctapxe(dnum->filnum,FN_RLOCK,recbyt,NULL));
  323. }
  324.  
  325. /* --------------------------------------------------------------------
  326.    UNLOCK data record
  327. */
  328.  
  329. COUNT UDLOCK(recbyt,dnum)
  330. POINTER        recbyt;
  331. PFAST DATFILE  *dnum;
  332. {
  333.     return(ctapxe(dnum->filnum,FN_UDLOCK,recbyt,NULL));
  334. }
  335.  
  336. VOID flushdos(datno)
  337. COUNT          datno;
  338. {
  339.     ctapxe(datno,FN_FLUSHDOS,0L,NULL);
  340. }
  341.  
  342. /* ------------------------------------------------------------ */
  343.  
  344. COUNT ctio(op_code,ctnum,recbyt,bufadr,iosize)
  345. COUNT    op_code;    /* CTREAD or CTWRITE */
  346. CTFILE *ctnum;
  347. LONG    recbyt;
  348. TEXT   *bufadr;
  349. unsigned int iosize;
  350. {
  351.     COUNT uerr();
  352.  
  353.     if (!iosize)
  354.         iosize = ctnum->reclen;
  355.     if (op_code == CTREAD) {
  356.         if (recred(ctnum->filnum,recbyt,bufadr,iosize,1))
  357.             return(uerr(READ_ERR));
  358.     } else {
  359.         cts_msg.mretc = 0; /* => not the 1st seg of var len record */
  360.         if (recwrt(ctnum->filnum,recbyt,bufadr,iosize))
  361.             return(uerr(WRITE_ERR));
  362.     }
  363.     return(NO_ERROR);
  364. }
  365.  
  366. POINTER ctapxv(filno,func,pntr,ptr1, ptr2)
  367. COUNT           filno,func;
  368. POINTER              pntr;
  369. TEXT                  *ptr1,*ptr2;
  370. {
  371.     ctapxe(filno,func,pntr,ptr1);
  372.     if (ptr2 != NULL && cts_msg.mpntr)
  373.         cpybuf(ptr2,ct_apxdat,(ct_key + filno)->length);
  374.     return(cts_msg.mpntr);
  375. }
  376.  
  377. COUNT tstrec( dnum,recbyt)
  378. PFAST CTFILE *dnum;
  379. POINTER           recbyt;
  380. {
  381.     POINTER temp;
  382.  
  383.     COUNT uerr();
  384.  
  385.     if (!recbyt)
  386.         return(uerr(ZREC_ERR));
  387.     if (recbyt > dnum->numrec) {
  388.         if ((temp = ctapxv(dnum->filnum,FN_TSTREC,recbyt,NULL,NULL)) ==
  389.             DRNZERO)
  390.             return(uerr_cod);
  391.         else
  392.             dnum->numrec = temp;
  393.     }
  394.     return(NO_ERROR);
  395. }
  396.  
  397. COUNT vtclose()
  398. {
  399.     return(YES);
  400. }
  401.  
  402. #ifdef UNIFRMAT
  403. #ifdef LONGVARD
  404.  
  405. VOID revwrd(tp,wrdcnt)
  406. PFAST TEXT *tp;
  407. PFAST COUNT    wrdcnt;
  408. {    /* assumes that revbyt already called */
  409.     TEXT ch1,ch2;
  410.  
  411.     while (wrdcnt-- > 0) {
  412.         ch1      = *tp++;
  413.         ch2      = *tp++;
  414.         *(tp - 2) = *tp;
  415.         *tp++      = ch1;
  416.         *(tp - 2) = *tp;
  417.         *tp++      = ch2;
  418.     }
  419. }
  420. #endif
  421. #endif
  422.  
  423.  
  424. COUNT INTREE(bufs,fils,sect)
  425. COUNT         bufs,fils,sect;
  426. {
  427.     FAST COUNT i;
  428.     TREEBUFF  *buf;
  429.     CTFILE    *ctnum;
  430.     COUNT      valsiz;
  431.     TEXT      *buforg,*valoff;
  432.  
  433.     COUNT       uerr();
  434.  
  435.     /*   
  436.      *    be sure that one and only one of each mutually 
  437.      *    exclusive choice has been selected and compose
  438.      *    version byte for header records.
  439.      */
  440.  
  441.  
  442. #ifndef LOW_HIGH
  443. #ifdef UNIFRMAT
  444.     ct_ver = (LH_VER | CT_V4E);
  445. #else
  446.     ct_ver = (HL_VER | CT_V4E);
  447. #endif
  448. #ifndef HIGH_LOW
  449.     terr(200);
  450. #endif
  451. #else
  452.     ct_ver = (LH_VER | CT_V4E);
  453. #ifdef  HIGH_LOW
  454.     terr(201);
  455. #endif
  456. #endif
  457.  
  458.     uerr_cod = stpcnt = 0;
  459.  
  460.     /* if application does not set cts_apxsiz, then default size */
  461.     if (!cts_apxsiz)
  462.         cts_apxsiz = DEFASIZ;
  463.     else if (cts_apxsiz > MAXASIZ)
  464.         cts_apxsiz = MAXASIZ;
  465.     if ((cts_apxsiz - sizeof(MESSAGE)) < MAXLEN)
  466.         cts_apxsiz = MAXLEN + sizeof(MESSAGE);
  467.     if ((cts_apxsiz - sizeof(MESSAGE)) < sizeof(FILEPARM))
  468.         cts_apxsiz = sizeof(FILEPARM) + sizeof(MESSAGE);
  469.     if (cts_apxsiz > MAXASIZ)
  470.         return(uerr(AMSG_ERR));
  471.  
  472.     if (bufs < 3 || sect < 1 || fils < 0)
  473.         return(uerr(SPRM_ERR));
  474.     if (ct_key != NULL)
  475.         return(uerr(IINT_ERR));
  476.  
  477.     if ((ct_key = (CTFILE *) mballc(fils,sizeof(CTFILE))) == NULL)
  478.         return(uerr(SPAC_ERR));
  479.     ct_dat    = ct_vat = ct_key;
  480.     ct_mxfil = fils;
  481.  
  482.     for (i = 0,ctnum = ct_key; i++ < ct_mxfil; ctnum++)
  483.         ctnum->chnacs = 'n';
  484.  
  485.     if (ctlogin(&apxmsg,&ct_apxdat,-1,cts_apxsiz,NULL,&cts_msg)) {
  486.         mbfree(ct_key);
  487.         ct_key = ct_dat = ct_vat = NULL;
  488.         return(uerr_cod);
  489.     } else
  490.         return(NO_ERROR);
  491. }
  492.  
  493. COUNT STPUSR()
  494. {
  495.     COUNT ridmids();
  496.  
  497.     if (stpcnt++ > 0)
  498.         return(NO_ERROR);
  499.  
  500.     if (cts_keyops > 1) {
  501.         mbfree(cts_kops);
  502.         mbfree(cts_mops);
  503.     }
  504.  
  505.     ctapxe(0,TST_STPUSR,0L,NULL);
  506.     return(ridmids());
  507. }
  508.  
  509. COUNT TRANSACTION(mode)
  510. COUNT          mode;
  511. {
  512.     return(ctapxe(mode,TST_TRAN,0L,NULL));
  513. }
  514.  
  515. COUNT cpyfpm(filnam,pfpm)
  516. PFAST TEXT  *filnam;
  517. FILEPARM       *pfpm;
  518. {
  519.     if (filnam == NULL)
  520.         return(uerr_cod = AFNM_ERR);
  521.     else if (strlen(filnam) > MAX_NAME)
  522.         return(uerr_cod = AFLN_ERR);
  523.     else
  524.         return(fulnam(pfpm->fpnam,filnam,MAX_NAME));
  525. }
  526.  
  527. COUNT OPNFIL(filno,filnam,filmod)
  528. COUNT         filno;
  529. TEXT          *filnam;
  530. COUNT              filmod;
  531. {
  532.     FAST CTFILE *ctnum;
  533.     FAST TEXT   *tp;
  534.     COUNT         i;
  535.     FILEPARM     fpm;
  536.  
  537.     ctnum = ct_key + filno;
  538.     if (filno < 0 || ct_mxfil <= filno)
  539.         return(uerr_cod = FNUM_ERR);
  540.     else if (ctnum->chnacs != 'n')
  541.         return(uerr_cod = FUSE_ERR);
  542.  
  543.     if (cpyfpm(filnam,&fpm))
  544.         return(uerr_cod);
  545.     fpm.fpmod = filmod;
  546.     if (ctapxe(filno,FN_OPNFIL,0L,&fpm))
  547.         return(uerr_cod);
  548.     cpybuf(ctnum,tp = ct_apxdat,HDRSIZ);
  549.     strcpy(ctnum->flname,filnam);
  550.     ctnum->filnum = filno;
  551.     ctnum->chnacs = 'y';
  552.     if (ctnum->clstyp != IDX_CLOSE)
  553.         return(uerr_cod = NO_ERROR);
  554.  
  555.     for (i = 1; i <= ctnum->nmem; i++) {
  556.         if ((cts_msg.mdlen -= HDRSIZ) < HDRSIZ) {
  557.             cts_msg.mseqn = i;
  558.             if (ctapxe(filno,CNT_HDROUT,0L,NULL))
  559.                 return(uerr_cod);
  560.             tp  = ct_apxdat;
  561.         } else
  562.             tp += HDRSIZ;
  563.         cpybuf(ctnum + i,tp,HDRSIZ);
  564.         (ctnum + i)->filnum = filno + i;
  565.         (ctnum + i)->chnacs = 'y';
  566.     }
  567.     return(uerr_cod = NO_ERROR);    
  568. }
  569.  
  570. COUNT CLSFIL(filno,filmod)
  571. COUNT         filno,filmod;
  572. {
  573.     FAST CTFILE *ctnum;
  574.     COUNT         i;
  575.  
  576.     cts_msg.mseqn = filmod;
  577.     if (ctapxe(filno,FN_CLSFIL,0L,NULL) == NO_ERROR)
  578.         for (i = 0, ctnum = ct_key + filno; i <= ctnum->nmem; i++)
  579.             (ctnum + i)->chnacs = 'n';
  580.     return(uerr_cod);
  581. }
  582.  
  583. COUNT DELFIL(filno)
  584. COUNT         filno;
  585. {
  586.     FAST CTFILE *ctnum;
  587.     COUNT         i;
  588.  
  589.     if (ctapxe(filno,FN_DELFIL,0L,NULL) == NO_ERROR)
  590.         for (i = 0, ctnum = ct_key + filno; i <= ctnum->nmem; i++)
  591.             (ctnum + i)->chnacs = 'n';
  592.     return(uerr_cod);
  593. }
  594.  
  595. COUNT WRTREC(datno,recbyt,recptr)
  596. COUNT         datno;
  597. POINTER           recbyt;
  598. TEXT             *recptr;
  599. {
  600.     FAST CTFILE *ctnum;
  601.  
  602.     if ((ctnum = tstfnm(datno)) == NULL || tstrec(ctnum,recbyt))
  603.         return(uerr_cod);
  604.     else {
  605.         cts_msg.mretc = 0;
  606.         return(recwrt(datno,recbyt,recptr,ctnum->reclen));
  607.     }
  608. }
  609.  
  610. COUNT REDREC(datno,recbyt,recptr)
  611. COUNT         datno;
  612. POINTER           recbyt;
  613. TEXT             *recptr;
  614. {
  615.     FAST CTFILE *ctnum;
  616.  
  617.     if ((ctnum = tstfnm(datno)) == NULL || tstrec(ctnum,recbyt))
  618.         return(uerr_cod);
  619.     return(recred(datno,recbyt,recptr,0,0));
  620. }
  621.  
  622. #ifdef VARLDATA
  623. COUNT RETVREC(datno,recbyt)
  624. COUNT         datno;
  625. POINTER           recbyt;
  626. {
  627.     return(ctapxe(datno,FN_RETVREC,recbyt,NULL));
  628. }
  629. #endif
  630.  
  631. POINTER EQLKEY(keyno,target)
  632. COUNT           keyno;
  633. TEXT            *target;
  634. {
  635.     return(ctapxv(keyno,FN_EQLKEY,0L,target,NULL));
  636. }
  637.  
  638. POINTER NXTKEY(keyno,idxval)
  639. COUNT           keyno;
  640. TEXT            *idxval;
  641. {
  642.     return(ctapxv(keyno,FN_NXTKEY,0L,NULL,idxval));
  643. }
  644.  
  645. POINTER PRVKEY(keyno,idxval)
  646. COUNT           keyno;
  647. TEXT            *idxval;
  648. {
  649.     return(ctapxv(keyno,FN_PRVKEY,0L,NULL,idxval));
  650. }
  651.  
  652. POINTER FRSKEY(keyno,idxval)
  653. COUNT           keyno;
  654. TEXT            *idxval;
  655. {
  656.     return(ctapxv(keyno,FN_FRSKEY,0L,NULL,idxval));
  657. }
  658.  
  659. POINTER LSTKEY(keyno,idxval)
  660. COUNT           keyno;
  661. TEXT            *idxval;
  662. {
  663.     return(ctapxv(keyno,FN_LSTKEY,0L,NULL,idxval));
  664. }
  665.  
  666. POINTER FRCKEY(keyno,idxval,fractal)
  667. COUNT           keyno;
  668. TEXT            *idxval;
  669. COUNT                fractal;
  670. {
  671.     cts_msg.mseqn = fractal;
  672.     return(ctapxv(keyno,FN_FRCKEY,0L,NULL,idxval));
  673. }
  674.  
  675. POINTER GTEKEY(keyno,target, idxval)
  676. COUNT           keyno;
  677. TEXT            *target,*idxval;
  678. {
  679.     return(ctapxv(keyno,FN_GTEKEY,0L,target,idxval));
  680. }
  681.  
  682. POINTER GTKEY(keyno,target, idxval)
  683. COUNT           keyno;
  684. TEXT            *target,*idxval;
  685. {
  686.     return(ctapxv(keyno,FN_GTKEY,0L,target,idxval));
  687. }
  688.  
  689. POINTER LTEKEY(keyno,target, idxval)
  690. COUNT           keyno;
  691. TEXT            *target,*idxval;
  692. {
  693.     return(ctapxv(keyno,FN_LTEKEY,0L,target,idxval));
  694. }
  695.  
  696. POINTER LTKEY(keyno,target, idxval)
  697. COUNT           keyno;
  698. TEXT            *target,*idxval;
  699. {
  700.     return(ctapxv(keyno,FN_LTKEY,0L,target,idxval));
  701. }
  702.  
  703. #ifdef CTS_ISAM
  704. VOID setsrlpos(datno,recptr)
  705. COUNT           datno;
  706. TEXT            *recptr;
  707. {
  708.         if ((ct_key + datno)->srlpos) {
  709. #ifndef NATURAL_SERIAL
  710. #ifdef LOW_HIGH
  711.             revobj(&ct_gsrl,sizeof(ct_gsrl));
  712. #endif
  713. #endif
  714.             cpybuf(recptr + (ct_key + datno)->srlpos - 1,
  715.                 &ct_gsrl,sizeof(ct_gsrl));
  716.         }
  717. }
  718.  
  719. COUNT MLTKEY(nops)
  720. COUNT         nops;
  721. {
  722.     FAST KEYOPS *k;
  723.     FAST TEXT   *tp;
  724.  
  725.     tp          = ct_apxdat;
  726.     cts_msg.mseqn = nops;
  727.     cts_msg.mdlen = nops * sizeof(KEYOPS);
  728.     k          = cts_kops;
  729.     while (nops-- > 0) {
  730.         cpybuf(tp,k++,sizeof(KEYOPS));
  731.         tp += sizeof(KEYOPS);
  732.     }
  733.     ctapxe(0,FN_MLTKEY,0L,NULL);
  734.     if (uerr_cod == ARQS_ERR || uerr_cod == ARSP_ERR)
  735.         return(-2);
  736.     return(cts_msg.mseqn);
  737. }
  738.  
  739. COUNT MLTWRT(datno,ppntr,recptr,rlen,sp)
  740. COUNT         datno;
  741. POINTER          *ppntr;
  742. TEXT            *recptr;
  743. UCOUNT                rlen,sp;
  744. {
  745.     POINTER NEWREC();
  746.  
  747.     if (rlen > cts_mxaln) {
  748.         if ((*ppntr = NEWREC(datno)) == DRNZERO)
  749.             return(1);
  750.         setsrlpos(datno,recptr);
  751.         if (WRTREC(datno,*ppntr,recptr))
  752.             return(2);
  753.         return(0);
  754.     } else {
  755.         cts_msg.mdlen = rlen;
  756.         cts_msg.mvlen = sp;
  757.         ctapxe(datno,FN_MLTWRT,0L,recptr);
  758.         if (uerr_cod == ARQS_ERR || uerr_cod == ARSP_ERR)
  759.             return(-2);
  760.         getsrlnum(&cts_msg);
  761.         setsrlpos(datno,recptr);
  762.         *ppntr = cts_msg.mpntr;
  763.         return(cts_msg.mseqn);
  764.     }
  765. }
  766. #endif
  767.  
  768. COUNT ADDKEY(keyno,target,recbyt,typadd)
  769. COUNT         keyno;
  770. TEXT          *target;
  771. POINTER              recbyt;
  772. COUNT                 typadd;
  773. {
  774.     cts_msg.mseqn = typadd;
  775.     return(ctapxe(keyno,FN_ADDKEY,recbyt,target));
  776. }
  777.  
  778. POINTER DATENT(datno)
  779. COUNT           datno;
  780. {
  781.     return(ctapxv(datno,FN_DATENT,0L,NULL,NULL));
  782. }
  783.  
  784. POINTER SERIALNUM(datno)
  785. COUNT           datno;
  786. {
  787.     return(ctapxv(datno,FN_SERIALNUM,0L,NULL,NULL));
  788. }
  789.  
  790. POINTER DELBLD(keyno,target)
  791. COUNT           keyno;
  792. TEXT            *target;
  793. {
  794.     return(ctapxv(keyno,FN_DELBLD,0L,target,NULL));
  795. }
  796.  
  797. COUNT DELCHK(keyno,target,recbyt)
  798. COUNT         keyno;
  799. TEXT          *target;
  800. POINTER              recbyt;
  801. {
  802.     return(ctapxe(keyno,FN_DELCHK,recbyt,target));
  803. }
  804.  
  805. POINTER IDXENT(keyno)
  806. COUNT           keyno;
  807. {
  808.     return(ctapxv(keyno,FN_IDXENT,0L,NULL,NULL));
  809. }
  810.  
  811. COUNT LOKREC(datno,lokmod,recbyt)
  812. COUNT         datno,lokmod;
  813. POINTER              recbyt;
  814. {
  815.     cts_msg.mseqn = lokmod;
  816.     return(ctapxe(datno,FN_LOKREC,recbyt,NULL));
  817. }
  818.  
  819. POINTER NEWREC(datno)
  820. COUNT           datno;
  821. {
  822.     POINTER retval;
  823.  
  824.     if ((retval = ctapxv(datno,FN_NEWREC,0L,NULL,NULL)) != DRNZERO)
  825.         getsrlnum(&cts_msg);
  826.     return(retval);
  827. }
  828.  
  829. COUNT RETREC(datno,recbyt)
  830. COUNT         datno;
  831. POINTER           recbyt;
  832. {
  833.     return(ctapxe(datno,FN_RETREC,recbyt,NULL));
  834. }
  835.  
  836. /* end of ctappx.c */
  837.