home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c004 / 1.ddi / CTISM2.C < prev    next >
Encoding:
C/C++ Source or Header  |  1989-04-18  |  8.5 KB  |  366 lines
  1. /*
  2.  *    isam support routines: key manipulation
  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. #ifdef VARLDATA
  30. #include "ctvrec.h"
  31. #endif
  32. #ifdef CTSERVER
  33. #include "ctcomm.h"
  34. extern COUNT   cts_keyops;
  35. extern KEYOPS *cts_kops;
  36. extern COUNT  *cts_mops;
  37. COUNT           MLTKEY();
  38. #endif
  39.  
  40. COUNT    compar(),ADDKEY();
  41. COUNT    DELCHK(),RETREC(),frmkey();
  42. COUNT    ierr();
  43. #ifdef VARLDATA
  44. COUNT     RETVREC();
  45. #endif
  46.  
  47. #ifndef CTSERVER
  48. VOID setsrlpos(datno,recptr)
  49. COUNT           datno;
  50. TEXT            *recptr;
  51. {
  52.         if ((ct_key + datno)->srlpos) {
  53. #ifndef NATURAL_SERIAL
  54. #ifdef LOW_HIGH
  55.             revobj(&ct_gsrl,sizeof(ct_gsrl));
  56. #endif
  57. #endif
  58.             cpybuf(recptr + (ct_key + datno)->srlpos - 1,
  59.                 &ct_gsrl,sizeof(ct_gsrl));
  60.         }
  61. }
  62. #endif
  63.  
  64. VOID iundo(op_code,datno,i,recptr,pntr,old_pntr)
  65. COUNT      op_code;
  66. PFAST COUNT       datno,i;
  67. TEXT              *recptr;
  68. POINTER                  pntr,old_pntr;
  69. {
  70.     FAST COUNT keyno;
  71.     COUNT      old_flg,new_flg;
  72.  
  73. #ifdef CTSERVER
  74.     if (uerr_cod == ARQS_ERR || uerr_cod == ARSP_ERR)
  75.         return;
  76. #endif
  77.  
  78.     if (op_code == ISADD || (op_code == ISRWT && pntr != old_pntr))
  79. #ifdef VARLDATA
  80.         if ((ct_key + datno)->clstyp == VAT_CLOSE)
  81.             RETVREC(datno,pntr);
  82.         else
  83. #endif
  84.             RETREC(datno,pntr);
  85.  
  86.     for (i--; i >= 0 ; i--) {
  87.         keyno = ct_kymap[datno][i];
  88.         if (op_code != ISRWT) {
  89.         if (frmkey(keyno,recptr,ct_kyval,DRNZERO))
  90.             if (op_code == ISADD) {
  91.                 if (DELCHK(keyno,ct_kyval,pntr))
  92.                     isam_err = IUND_ERR;
  93.             } else {
  94.                 if (ADDKEY(keyno,ct_kyval,old_pntr,REGADD))
  95.                     isam_err = IUND_ERR;
  96.             }
  97.         } else {
  98.         old_flg = frmkey(keyno,cur_image[datno],ct_fndval,old_pntr);
  99.         new_flg = frmkey(keyno,recptr,ct_kyval,pntr);
  100.         if (old_pntr != pntr ||
  101.             compar(ct_fndval,ct_kyval,ct_key + keyno)) {
  102.             if (new_flg)
  103.                 if (DELCHK(keyno,ct_kyval,pntr))
  104.                     isam_err = IUND_ERR;
  105.             if (old_flg)
  106.                 if (ADDKEY(keyno,ct_fndval,old_pntr,REGADD))
  107.                     isam_err = IUND_ERR;
  108.         }
  109.         }
  110.     }
  111. #ifdef DOSFLUSH
  112.     flushdos(datno);
  113. #endif
  114. }
  115.  
  116. COUNT addikey(datno,recptr,pntr)
  117. COUNT          datno;
  118. TEXT           *recptr;
  119. POINTER               pntr;
  120. {
  121.     FAST COUNT   i,keyno;
  122. #ifdef CTSERVER
  123.     COUNT         j;
  124.     FAST KEYOPS *k;
  125.  
  126.     for (i = j = 0; i < MAX_DAT_KEY; i++) {
  127.         if ((keyno = ct_kymap[datno][i]) < 0 )
  128.             break;
  129.         if (frmkey(keyno,recptr,ct_kyval,DRNZERO)) {
  130.             if (cts_keyops < 2) {
  131.             if (ADDKEY(keyno,ct_kyval,pntr,REGADD)) {
  132.                 ierr(uerr_cod,keyno);
  133.                 iundo(ISADD,datno,i,recptr,pntr,DRNZERO);
  134.                 return(isam_err);
  135.             }
  136.             } else {
  137.             cts_mops[j]      = i + 1;
  138.             k      = cts_kops + j++;
  139.             k->kokeyn = keyno;
  140.             k->komode = FN_ADDKEY;
  141.             k->kopntr = pntr;
  142.             cpybuf(k->kobufr,ct_kyval,(ct_key + keyno)->length);
  143.             if (j == cts_keyops) {
  144.                 j = MLTKEY(cts_keyops);
  145.                 if (j == -2)
  146.                     return(ierr(uerr_cod,0));
  147.                 else if (j) {
  148.                     i = j;
  149.                     j = - cts_mops[j - 1];
  150.                     break;
  151.                 }
  152.             }
  153.             }
  154.         }
  155.     }
  156.     if (j > 0) {
  157.         j = MLTKEY(j);
  158.         if (j == -2)
  159.             return(ierr(uerr_cod,0));
  160.         else if (j) {
  161.             i = j;
  162.             j = - cts_mops[j - 1];
  163.         }
  164.     }
  165.     if (j < 0) {
  166.         ierr(uerr_cod,(cts_kops + i - 1)->kokeyn);
  167.         iundo(ISADD,datno,-(j + 1),recptr,pntr,DRNZERO);
  168.         return(isam_err);
  169.     }    
  170. #else
  171.     for (i = 0; i < MAX_DAT_KEY; i++) {
  172.         if ((keyno = ct_kymap[datno][i]) < 0 )
  173.             break;
  174.         if (frmkey(keyno,recptr,ct_kyval,DRNZERO))
  175.             if (ADDKEY(keyno,ct_kyval,pntr,REGADD)) {
  176.                 ierr(uerr_cod,keyno);
  177.                 iundo(ISADD,datno,i,recptr,pntr,DRNZERO);
  178.                 return(isam_err);
  179.             }
  180.     }
  181. #endif
  182.     return(NO_ERROR);
  183. }
  184.  
  185. COUNT rwtikey(datno,recptr,pntr,old_pntr)
  186. COUNT          datno;
  187. TEXT           *recptr;
  188. POINTER               pntr,old_pntr;
  189. {
  190.     FAST COUNT   i,keyno;
  191.     COUNT         old_flg,new_flg;
  192. #ifdef CTSERVER
  193.     COUNT         j,even_keyops;
  194.     FAST KEYOPS *k;
  195.  
  196.     even_keyops = cts_keyops / 2 * 2;
  197.     for (i = j = 0; i < MAX_DAT_KEY; i++) {
  198.         if ((keyno = ct_kymap[datno][i]) < 0 )
  199.             break;
  200.         old_flg = frmkey(keyno,cur_image[datno],ct_fndval,old_pntr);
  201.         new_flg = frmkey(keyno,recptr,ct_kyval,pntr);
  202.         if (old_pntr != pntr || compar(ct_fndval,ct_kyval,
  203.           ct_key + keyno))  {
  204.             /* old <> new */
  205.             if (even_keyops < 2) {
  206.             if (old_flg && DELCHK(keyno,ct_fndval,old_pntr)) {
  207.                 ierr(uerr_cod,keyno);
  208.                 iundo(ISRWT,datno,i,recptr,pntr,old_pntr);
  209.                 return(isam_err);
  210.             }
  211.             if (new_flg && ADDKEY(keyno,ct_kyval,pntr,REGADD)) {
  212.                 ierr(uerr_cod,keyno);
  213.                 if (ADDKEY(keyno,ct_fndval,old_pntr,REGADD))
  214.                     isam_err = IUND_ERR;
  215.                 iundo(ISRWT,datno,i,recptr,pntr,old_pntr);
  216.                 return(isam_err);
  217.             }
  218.             } else {
  219.               if (old_flg || new_flg) {
  220.             cts_mops[j]      = i + 1;
  221.             k      = cts_kops + j++;
  222.             k->kokeyn = keyno;
  223.             k->komode = FN_DELCHK;
  224.             k->kopntr = old_pntr;
  225.             if (old_flg)
  226.                 cpybuf(k->kobufr,ct_fndval,(ct_key + keyno)->length);
  227.             else
  228.                 k->komode = 0;
  229.             cts_mops[j]      = i + 1;
  230.             k      = cts_kops + j++;
  231.             k->kokeyn = keyno;
  232.             k->komode = FN_ADDKEY;
  233.             k->kopntr = pntr;
  234.             if (new_flg)
  235.                 cpybuf(k->kobufr,ct_kyval,(ct_key + keyno)->length);
  236.             else
  237.                 k->komode = 0;
  238.             if (j == even_keyops) {
  239.                 j = MLTKEY(even_keyops);
  240.                 if (j == -2)
  241.                     return(ierr(uerr_cod,0));
  242.                 else if (j) {
  243.                     i = j;
  244.                     j = - cts_mops[j - 1];
  245.                     break;
  246.                 }
  247.             }
  248.               }
  249.             }
  250.         }
  251.     }
  252.     if (j > 0) {
  253.         j = MLTKEY(j);
  254.         if (j == -2)
  255.             return(ierr(uerr_cod,0));
  256.         else if (j) {
  257.             i = j;
  258.             j = - cts_mops[j - 1];
  259.         }
  260.     }
  261.     if (j < 0) {
  262.         ierr(uerr_cod,(cts_kops + --i)->kokeyn);
  263.         if (i-- % 2)
  264.             if ((k = (cts_kops + i))->komode)
  265.                 if (ADDKEY(k->kokeyn,k->kobufr,old_pntr,REGADD))
  266.                 isam_err = IUND_ERR;
  267.         iundo(ISRWT,datno,-(j + 1),recptr,pntr,old_pntr);
  268.         return(isam_err);
  269.     }    
  270. #else
  271.     for (i = 0; i < MAX_DAT_KEY; i++) {
  272.         if ((keyno = ct_kymap[datno][i]) < 0 )
  273.             break;
  274.         old_flg = frmkey(keyno,cur_image[datno],ct_fndval,old_pntr);
  275.         new_flg = frmkey(keyno,recptr,ct_kyval,pntr);
  276.         if (old_pntr != pntr || compar(ct_fndval,ct_kyval,ct_key + keyno))  {
  277.             /* old <> new */
  278.             if (old_flg && DELCHK(keyno,ct_fndval,old_pntr)) {
  279.                 ierr(uerr_cod,keyno);
  280.                 iundo(ISRWT,datno,i,recptr,pntr,old_pntr);
  281.                 return(isam_err);
  282.             }
  283.             if (new_flg && ADDKEY(keyno,ct_kyval,pntr,REGADD)) {
  284.                 ierr(uerr_cod,keyno);
  285.                 if (ADDKEY(keyno,ct_fndval,old_pntr,REGADD))
  286.                     isam_err = IUND_ERR;
  287.                 iundo(ISRWT,datno,i,recptr,pntr,old_pntr);
  288.                 return(isam_err);
  289.             }
  290.         }
  291.     }
  292. #endif
  293.     return(-i);    /* NO_ERROR */
  294. }
  295.  
  296. COUNT delikey(datno,recptr,pntr)
  297. COUNT          datno;
  298. TEXT           *recptr;
  299. POINTER               pntr;
  300. {
  301.     FAST COUNT   i,keyno;
  302. #ifdef CTSERVER
  303.     COUNT         j;
  304.     FAST KEYOPS *k;
  305.  
  306.     for (i = j = 0; i < MAX_DAT_KEY; i++) {
  307.         if ((keyno = ct_kymap[datno][i]) < 0 )
  308.             break;
  309.         if (frmkey(keyno,recptr,ct_kyval,DRNZERO)) {
  310.             if (cts_keyops < 2) {
  311.             if (DELCHK(keyno,ct_kyval,pntr)) {
  312.                 ierr(uerr_cod,keyno);
  313.                 iundo(ISDEL,datno,i,recptr,DRNZERO,pntr);
  314.                 return(isam_err);
  315.             }
  316.             } else {
  317.             cts_mops[j]      = i + 1;
  318.             k      = cts_kops + j++;
  319.             k->kokeyn = keyno;
  320.             k->komode = FN_DELCHK;
  321.             k->kopntr = pntr;
  322.             cpybuf(k->kobufr,ct_kyval,(ct_key + keyno)->length);
  323.             if (j == cts_keyops) {
  324.                 j = MLTKEY(cts_keyops);
  325.                 if (j == -2)
  326.                     return(ierr(uerr_cod,0));
  327.                 else if (j) {
  328.                     i = j;
  329.                     j = - cts_mops[j - 1];
  330.                     break;
  331.                 }
  332.             }
  333.             }
  334.         }
  335.     }
  336.     if (j > 0) {
  337.         j = MLTKEY(j);
  338.         if (j == -2)
  339.             return(ierr(uerr_cod,0));
  340.         else if (j) {
  341.             i = j;
  342.             j = - cts_mops[j - 1];
  343.         }
  344.     }
  345.     if (j < 0) {
  346.         ierr(uerr_cod,(cts_kops + i - 1)->kokeyn);
  347.         iundo(ISDEL,datno,-(j + 1),recptr,DRNZERO,pntr);
  348.         return(isam_err);
  349.     }    
  350. #else
  351.     for (i = 0; i < MAX_DAT_KEY; i++) {
  352.         if ((keyno = ct_kymap[datno][i]) < 0)
  353.             break;
  354.         if (frmkey(keyno,recptr,ct_kyval,DRNZERO))
  355.             if (DELCHK(keyno,ct_kyval,pntr)) {
  356.                 ierr(uerr_cod,keyno);
  357.                 iundo(ISDEL,datno,i,recptr,DRNZERO,pntr);
  358.                 return(isam_err);
  359.             }
  360.     }
  361. #endif
  362.     return(-i);    /* NO_ERROR */
  363. }
  364.  
  365. /* end of ctism2.c */
  366.