home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c004 / 1.ddi / CTSSET.C < prev    next >
Encoding:
C/C++ Source or Header  |  1989-04-18  |  5.9 KB  |  268 lines
  1. /*
  2.  *    sequence set 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) 1984, 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.  
  30. POINTER  GTEKEY(),GTKEY(),LTEKEY(),LTKEY();
  31. COUNT    ierr(),reset_cur();
  32. CTFILE  *tstfnm();
  33. TEXT    *mballc();
  34.  
  35. LOCAL TEXT    seqbuf[MAXLEN];    /* holds matching "partial" ct_key */
  36. LOCAL COUNT   seqlen;        /* significant length of ct_key    */
  37. LOCAL COUNT   seqkey = -1;    /* current keyno        */
  38. LOCAL COUNT   seqnum = -1;    /* current set number        */
  39. LOCAL COUNT   maxqset;
  40. #ifdef CTSERVER
  41. EXTERN COUNT  cts_csuc,cts_cseq;
  42. EXTERN UCOUNT cts_clen;
  43. EXTERN TEXT  *ct_apxdat;
  44. #endif
  45.  
  46. COUNT ALCSET(numset)
  47. COUNT         numset;
  48. {
  49.     isam_err = 0;
  50.     if ((TEXT *) ct_savset != NULL)
  51.         return(ierr(ISDP_ERR,0));
  52.     else if (numset == 0)
  53.         return(NO_ERROR);
  54.     else if ((ct_savset = (SAVSET *) mballc(numset,sizeof(SAVSET))) == NULL)
  55.         return(ierr(ISAL_ERR,0));
  56.     maxqset = numset;
  57.     return(NO_ERROR);
  58. }
  59.  
  60. COUNT FRESET()
  61. {
  62.     VOID mbfree();
  63.  
  64.     mbfree(ct_savset);
  65.     ct_savset  = NULL;
  66.     seqkey       = seqnum = -1;
  67.     return(isam_err = maxqset = 0);
  68. }
  69.  
  70. COUNT CHGSET(setnum)
  71. FAST COUNT   setnum;
  72. {
  73.     FAST SAVSET *ss;
  74.  
  75.     if (setnum < 0 || setnum >= maxqset || ct_savset == NULL)
  76.         return(ierr(ISNM_ERR,0));
  77.     else
  78.         isam_err = 0;
  79.  
  80.     if (setnum == seqnum)        /* no need to switch    */
  81.         return(NO_ERROR);
  82.  
  83.     if (seqnum >= 0 && seqnum < maxqset) {    /* save current set    */
  84.  
  85.         ss     = ct_savset + seqnum;
  86.         ss->qlen = seqlen;
  87.         ss->qkey = seqkey + 1;
  88.         cpybuf(ss->qbuf,seqbuf,MAXLEN);
  89.     }
  90.  
  91.     ss    = ct_savset + setnum;
  92.     seqlen    = ss->qlen;
  93.     seqkey    = ss->qkey - 1;
  94.     seqnum    = setnum;
  95.     cpybuf(seqbuf,ss->qbuf,MAXLEN);
  96.     return(NO_ERROR);
  97. }
  98.  
  99.  
  100. COUNT chkset(keyno,recpos,recptr)
  101. COUNT   keyno;
  102. POINTER recpos;
  103. TEXT   *recptr;
  104. {
  105.     FAST COUNT i;
  106.     FAST TEXT *kp;
  107.     CTFILE    *knum;
  108.  
  109.     if (recpos == DRNZERO) /* no match */ {
  110.         /* seqkey = -1; */ /* remove comments for old behavior */
  111.         return(reset_cur(keyno,DRNZERO,recptr));
  112.     }
  113.     for (i = 0, kp = ct_fndval, knum = ct_key + keyno; i < seqlen; i++)
  114.         if (seqbuf[i] != *kp++) {
  115.             /* no match */
  116.             /* seqkey = -1;*/ /* remove comments for old behavior */
  117. #ifdef CTSERVER
  118.             if (cts_csuc && (ct_ismlk == ENABLE ||
  119.                 ct_ismlk == READREC)) {
  120.                 /* lock already acquired by server */
  121.                 cts_csuc = NO;
  122.                 LOKREC(ct_rvmap[keyno],FREE,recpos);
  123.             }
  124. #endif
  125.             return(ierr(INOT_ERR,keyno));
  126.         }
  127.  
  128.     seqkey = keyno;
  129.     for ( ; i < knum->length; i++)
  130.         seqbuf[i] = *kp++;
  131. #ifdef CTSERVER
  132.     if (cts_csuc)
  133.         cpybuf(recptr,ct_apxdat + knum->length,cts_clen);
  134. #endif
  135.     return(reset_cur(keyno,recpos,recptr));
  136. }
  137.  
  138. COUNT setset(keyno,target,siglen)
  139. COUNT        keyno;
  140. TEXT          *target;
  141. PFAST COUNT               siglen;
  142. {
  143.     CTFILE    *cnum;
  144.     FAST TEXT *kp;
  145.  
  146.     seqkey = -1;
  147.     if ((cnum = tstfnm(keyno)) == NULL)
  148.         return(ierr(uerr_cod,keyno));
  149.     else if ((cnum->ktype & MSK_ALT) >= INTKEY && (cnum->ktype & MSK_ALT)
  150.         <= DFLOATKEY)
  151.         return(ierr(SKTY_ERR,keyno));
  152.  
  153.     if (siglen >= cnum->length)
  154.         seqlen = cnum->length;
  155.     else
  156.         seqlen = siglen;
  157.     for (siglen = 0,kp = seqbuf; siglen++ < seqlen; )
  158.         *kp++ = *target++;
  159.     return(NO_ERROR);
  160. }
  161.  
  162.  
  163. COUNT FRSSET(keyno,target, recptr,siglen)
  164. COUNT         keyno;
  165. TEXT          *target,*recptr;
  166. PFAST COUNT              siglen;
  167. {
  168.     FAST TEXT *kp;
  169.  
  170.     if (setset(keyno,target,siglen))
  171.         return(isam_err);
  172.  
  173.     kp = seqbuf + siglen;
  174.     while (siglen++ < (ct_key + keyno)->length)
  175.         *kp++ = '\0';
  176.  
  177. #ifdef CTSERVER
  178.     cmbchk(keyno,recptr);
  179.     cts_cseq = YES;
  180. #endif
  181.     return(chkset(keyno,GTEKEY(keyno,seqbuf,ct_fndval),recptr));
  182. }
  183.  
  184. COUNT MIDSET(keyno,recptr,siglen)
  185. COUNT         keyno;
  186. TEXT          *recptr;
  187. COUNT              siglen;
  188. {
  189.     TEXT         target[MAXLEN];
  190.     FAST COUNT   len,datno;
  191.     POINTER      pntr;
  192.     FAST CTFILE *ctnum;
  193.  
  194.     if ((ctnum = tstfnm(keyno)) == NULL)
  195.         return(ierr(uerr_cod,keyno));
  196.     if ((pntr = cur_recno[datno = ct_rvmap[keyno]]) == DRNZERO)
  197.         return(ierr(ICUR_ERR,keyno));
  198.     if (frmkey(keyno,cur_image[datno],target,pntr))
  199.         len = ctnum->length;
  200.     else
  201.         len = 0;
  202.     if (FRSSET(keyno,target,recptr,len))
  203.         return(isam_err);
  204.     if (siglen > len)
  205.         siglen = len;
  206.     seqlen = siglen;
  207.     return(NO_ERROR);
  208. }
  209.  
  210. COUNT LSTSET(keyno,target, recptr,siglen)
  211. COUNT         keyno;
  212. TEXT          *target,*recptr;
  213. PFAST COUNT              siglen;
  214. {
  215.     FAST TEXT *kp;
  216.  
  217.     if (setset(keyno,target,siglen))
  218.         return(isam_err);
  219.  
  220.     kp = seqbuf + siglen;
  221.     while (siglen++ < (ct_key + keyno)->length)
  222.         *kp++ = '\377';
  223.  
  224. #ifdef CTSERVER
  225.     cmbchk(keyno,recptr);
  226.     cts_cseq = YES;
  227. #endif
  228.     return(chkset(keyno,LTEKEY(keyno,seqbuf,ct_fndval),recptr));
  229. }
  230.  
  231.  
  232. COUNT NXTSET(keyno,recptr)
  233. COUNT keyno;
  234. TEXT *recptr;
  235. {
  236.     if (tstfnm(keyno) == NULL)
  237.         return(ierr(uerr_cod,keyno));
  238.     else if (keyno != seqkey)
  239.         return(ierr(SKEY_ERR,keyno));
  240.     else {
  241. #ifdef CTSERVER
  242.         cmbchk(keyno,recptr);
  243.         cts_cseq = YES;
  244. #endif
  245.         return(chkset(keyno,GTKEY(keyno,seqbuf,ct_fndval),recptr));
  246.     }
  247. }
  248.  
  249.  
  250. COUNT PRVSET(keyno,recptr)
  251. COUNT keyno;
  252. TEXT *recptr;
  253. {
  254.     if (tstfnm(keyno) == NULL)
  255.         return(ierr(uerr_cod,keyno));
  256.     else if (keyno != seqkey)
  257.         return(ierr(SKEY_ERR,keyno));
  258.     else {
  259. #ifdef CTSERVER
  260.         cmbchk(keyno,recptr);
  261.         cts_cseq = YES;
  262. #endif
  263.         return(chkset(keyno,LTKEY(keyno,seqbuf,ct_fndval),recptr));
  264.     }
  265. }
  266.  
  267. /* end of ctsset.c */
  268.