home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c004 / 2.ddi / CTVREC.C < prev    next >
Encoding:
C/C++ Source or Header  |  1989-04-18  |  6.3 KB  |  298 lines
  1. /*
  2.  *    variable record length routines
  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) 1985, 1986, 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"        /* standard i/o header         */
  24. #include "ctoptn.h"        /* c-tree configuration options */
  25. #include "cterrc.h"        /* c-tree error codes        */
  26. #include "ctstrc.h"        /* c-tree data structures    */
  27. #include "ctgvar.h"        /* c-tree global variables    */
  28. #include "ctisam.h"        /* c-tree isam header        */
  29. #include "ctvrec.h"        /* var length header        */
  30.  
  31.  
  32. COUNT    ierr(),frmkey(),ADDKEY(),DELCHK();
  33. COUNT    getvhdr(),putvhdr(),compar(),frmlkey();
  34. COUNT    WRTVREC(),RETVREC(),addikey(),delikey(),rwtikey();
  35. CTFILE *tstfnm();
  36. POINTER EQLKEY(),NEWVREC();
  37. VRLEN    GTVLEN();
  38. VOID    iundo();
  39. #ifdef MUSTFRCE
  40. COUNT    DLOCK(),UDLOCK();
  41. #endif
  42.  
  43. LOCAL TEXT lenkey[VARI_LEN];
  44.  
  45. POINTER chkvsm(datno)
  46. COUNT datno;
  47.  
  48. {
  49.     VATFILE *vnum;
  50.     POINTER  pntr;
  51.  
  52.     COUNT addlok();
  53.  
  54.     isam_err = NO_ERROR;
  55.  
  56.     if ((vnum = tstfnm(datno)) == NULL)
  57.         ierr(uerr_cod,datno);
  58.     else if (vnum->clstyp != VAT_CLOSE)
  59.         ierr(FMOD_ERR,datno);
  60.     else if (!(pntr = cur_recno[datno]))
  61.         ierr(ICUR_ERR,datno);
  62.     else
  63.         addlok(pntr,datno);
  64.  
  65.     if (!isam_err)
  66.         return(pntr);
  67.     else
  68.         return(DRNZERO);
  69. }
  70.  
  71.  
  72. VRLEN GETVLEN(datno)
  73. COUNT         datno;
  74. {
  75.     VRLEN vlen;
  76.  
  77.     isam_err = 0;
  78.     if (vlen = GTVLEN(datno,cur_recno[datno]))
  79.         return(vlen);
  80.     else if (uerr_cod == ZREC_ERR)
  81.         uerr_cod = ICUR_ERR;
  82.     ierr(uerr_cod,datno);
  83.     return(0);
  84. }    
  85.     
  86. COUNT ADDVREC(datno,recptr,varlen)
  87.  
  88. PFAST COUNT datno;
  89. TEXT       *recptr;
  90. VRLEN       varlen;
  91.  
  92. {
  93.     POINTER    pntr;
  94.     VATFILE   *vnum;
  95.  
  96.     COUNT      addlok();
  97.  
  98.     isam_err = NO_ERROR;
  99.     if ((vnum = tstfnm(datno)) == NULL)
  100.         return(ierr(uerr_cod,datno));
  101.     else if (vnum->clstyp != VAT_CLOSE)
  102.         return(ierr(FMOD_ERR,datno));
  103.     else if (varlen < vnum->reclen)
  104.         return(ierr(VRLN_ERR,datno));
  105.     else if (!(pntr = NEWVREC(datno,varlen)))
  106.         return(ierr(uerr_cod,datno));
  107.     setsrlpos(datno,recptr);
  108.  
  109.     ct_nwrcfg = YES;
  110.     if (addlok(pntr,datno))
  111.         return(isam_err);
  112.  
  113.     if (WRTVREC(datno,pntr,recptr,varlen)) {
  114.         ierr(uerr_cod,datno);
  115.         iundo(ISADD,datno,0,recptr,pntr,DRNZERO);
  116.         return(isam_err);
  117.     }
  118.  
  119.     if (addikey(datno,recptr,pntr))
  120.         return(isam_err);
  121.  
  122.     cur_recno[datno] = pntr;
  123.     cur_image[datno] = recptr;
  124. #ifdef DOSFLUSH
  125.     flushdos(datno);
  126. #endif
  127.     return(NO_ERROR);
  128. }
  129.     
  130.  
  131. COUNT DELVREC(datno)
  132.  
  133. PFAST COUNT datno;
  134.  
  135. {
  136.     TEXT      *recptr;
  137.     POINTER    pntr;
  138.     COUNT       i;
  139.  
  140.     POINTER chkvsm();
  141.  
  142.     if (!(pntr = chkvsm(datno)))
  143.         return(isam_err);
  144.  
  145.     recptr = cur_image[datno];
  146.     if ((i = delikey(datno,recptr,pntr)) > 0)
  147.         return(isam_err);
  148.  
  149.     if (RETVREC(datno,pntr)) {
  150.         ierr(uerr_cod,datno);
  151.         iundo(ISDEL,datno,-i,recptr,DRNZERO,pntr);
  152.         return(isam_err);
  153.     }
  154. #ifdef DOSFLUSH
  155.     flushdos(datno);
  156. #endif
  157.     return(NO_ERROR);
  158. }
  159.  
  160. COUNT RWTVREC(datno,recptr,varlen)
  161. COUNT         datno;
  162. TEXT               *recptr;
  163. VRLEN                      varlen;
  164. {
  165.     VHDR    vrhdr,nrhdr;
  166.     CTFILE *vnum;
  167.     LONG    pntr,old_pntr,nrecbyt;
  168.     VRLEN   old_totlen,test;
  169.     COUNT   i;
  170. #ifdef MUSTFRCE
  171.     LOKS   *lp;
  172.     COUNT    tstlok;
  173. #endif    
  174.  
  175.     POINTER chkvsm();
  176.  
  177. #ifdef MUSTFRCE
  178.     tstlok = DLOK_ERR;
  179. #endif
  180.     vnum = ct_key + datno;
  181.     if (!(old_pntr = chkvsm(datno)))
  182.         return(isam_err);
  183.     else if (vnum->flmode & READFIL)
  184.         return(ierr(REDF_ERR,datno));
  185.     else if (getvhdr(vnum,old_pntr,&vrhdr))
  186.         return(ierr(uerr_cod,datno));
  187.  
  188.     old_totlen = vrhdr.trclen;
  189.  
  190.     if (varlen > old_totlen) {
  191.         if ((nrecbyt = old_pntr + old_totlen + SIZVHDR) > old_pntr &&
  192.             getvhdr(vnum,nrecbyt,&nrhdr) == NO_ERROR &&
  193.             nrhdr.recmrk == VDEL_FLAG && (test = old_totlen + SIZVHDR +
  194. #ifndef MUSTFRCE
  195.             nrhdr.trclen) >= varlen) {
  196.             frmlkey(lenkey,&nrhdr.trclen,DRNZERO);
  197. #else
  198.             nrhdr.trclen) >= varlen && (tstlok = DLOCK(nrecbyt,vnum))
  199.             == NO_ERROR && frmlkey(lenkey,&nrhdr.trclen,nrecbyt) &&
  200.             EQLKEY(datno,lenkey) != DRNZERO) {
  201. #endif
  202.             /* enlarge current space */
  203.             vrhdr.trclen = test;
  204.             if (putvhdr(vnum,old_pntr,&vrhdr) ||
  205.                 DELCHK(datno,lenkey,nrecbyt))
  206.                 /* no UDLOCK here (FPUTFGET) since VDLK_ERR *
  207.                  * should "never" arise here            */
  208.                 return(ierr(VDLK_ERR,datno));
  209.             pntr = old_pntr;
  210. #ifdef MUSTFRCE
  211.             UDLOCK(nrecbyt,vnum);
  212.         } else {
  213.             if (tstlok == NO_ERROR)
  214.                 UDLOCK(nrecbyt,vnum);
  215.             if (!(pntr = NEWVREC(datno,varlen)))
  216.                 return(ierr(uerr_cod,datno));
  217.         }
  218. #else
  219.         } else if (!(pntr = NEWVREC(datno,varlen)))
  220.             return(ierr(uerr_cod,datno));
  221. #endif
  222.     } else
  223.         pntr = old_pntr;
  224.  
  225.     if ((i = rwtikey(datno,recptr,pntr,old_pntr)) > 0)
  226.         return(isam_err);
  227.  
  228.     if (WRTVREC(datno,pntr,recptr,varlen)) {
  229.         ierr(uerr_cod,datno);
  230.         iundo(ISRWT,datno,-i,recptr,pntr,old_pntr);
  231.         return(isam_err);
  232.     }
  233.  
  234.     cur_recno[datno] = pntr;
  235.     cur_image[datno] = recptr;
  236.  
  237.     if (pntr != old_pntr) {
  238. #ifdef MUSTFRCE    
  239.         for (i = 0, lp = ct_locks; i++ < MAX_LOCKS; lp++)
  240.             if (lp->datfnm == datno && lp->recnum == old_pntr) {
  241.                 lp->recnum = pntr;
  242.                 break;
  243.             }
  244. #endif
  245.         RETVREC(datno,old_pntr);
  246. #ifdef DOSFLUSH
  247.         flushdos(datno);
  248. #endif
  249.         return(ierr(uerr_cod,datno));
  250.     } else {
  251. #ifdef DOSFLUSH
  252.         flushdos(datno);
  253. #endif
  254.         return(NO_ERROR);
  255.     }
  256. }
  257.  
  258. COUNT REDVREC(datno,recptr,bufsiz)
  259. PFAST COUNT   datno;
  260. TEXT           *recptr;
  261. VRLEN               bufsiz;
  262. {
  263.     POINTER pntr;
  264.     VRLEN    vrclen;
  265. #ifdef MUSTFRCE
  266.     COUNT    keyno;
  267.     TEXT    chkkey[MAXLEN];
  268. #endif
  269.  
  270.     VRLEN    prprdv();
  271.     COUNT    ctio(),addlok();
  272.  
  273.     isam_err = 0;
  274.     if ((vrclen = prprdv(datno,pntr = cur_recno[datno],recptr,
  275.         bufsiz)) == 0) {
  276.         if (uerr_cod == ZREC_ERR)
  277.             uerr_cod = ICUR_ERR;
  278.     } else if (addlok(pntr,datno))
  279.         uerr_cod = isam_err;
  280.     else
  281.         ctio(CTREAD,ct_key + datno,pntr,recptr,vrclen);
  282.     if (uerr_cod)
  283.         return(ierr(uerr_cod,datno));
  284.  
  285. #ifdef MUSTFRCE
  286.     if (ct_vfsg) {
  287.         frmkey(keyno = (ct_vfsg - 1),recptr,chkkey,pntr);
  288.         ct_vfsg = NO;
  289.         if (compar(chkkey,ct_fndval,ct_key + keyno))
  290.             return(ierr(ITIM_ERR,datno));
  291.     }
  292. #endif
  293.     cur_image[datno] = recptr;
  294.     return(isam_err);
  295. }
  296.  
  297. /* end of ctvrec.c */
  298.