home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c004 / 2.ddi / CTLOAD.C < prev    next >
Encoding:
C/C++ Source or Header  |  1989-04-18  |  6.7 KB  |  291 lines
  1. /*
  2.  *    high speed load of ordered key values
  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.  
  29. COUNT      uerr(),putnod(),compar(),delexp(),tstupd();
  30. TREEBUFF *newnod(),*getnod();
  31. POINTER   LSTKEY();
  32. VOID      prpdup(),insexp();
  33. TEXT     *valpnt(),*hghpnt();
  34.  
  35. LOCAL TEXT    lastkey[MAXLEN];
  36. LOCAL LONG    begnod,curnod,prvnod,numnod;
  37. LOCAL LONG    ct_nnods[MAXLEV];
  38. LOCAL COUNT    elem;
  39. LOCAL COUNT    started = -1;
  40. LOCAL TREEBUFF *savbp;
  41.  
  42. TREEBUFF *lodins(buffer,idxval,recbyt,knum)
  43. PFAST TREEBUFF  *buffer;
  44. TEXT               *idxval;
  45. LONG                   recbyt;
  46. PFAST CTFILE                 *knum;
  47. {
  48.     FAST TREEBUFF  *lbp;
  49.     COUNT        leaflg;
  50.  
  51.     VOID        newleaf(),nonleaf();
  52.  
  53.     ct_tky = 0;
  54.     if (elem)
  55.         valpnt(buffer,elem);
  56.     insexp(buffer,idxval,recbyt);
  57.     buffer->nkv++;
  58.  
  59.     if (buffer->nkb > buffer->maxb) {
  60.         leaflg = buffer->leaf == LEAF ? YES : NO;
  61.         valpnt(buffer,buffer->nkv);
  62.         delexp(buffer);
  63.         if (leaflg)
  64.             cpybuf(hghpnt(buffer),lastkey,knum->length);
  65.         putnod(buffer,buffer->nkv);
  66.         prvnod = curnod;
  67.         if ((savbp = buffer = newnod(knum,&curnod,NO)) == NULL)
  68.             return(NULL);
  69.         if (leaflg)
  70.             newleaf(buffer,knum);
  71.         else
  72.             nonleaf(buffer,knum);
  73.         ct_tkp = elem = 0;
  74.         numnod++;
  75.         insexp(buffer,idxval,recbyt);
  76.         buffer->nkv++;
  77.         if ((lbp = getnod(prvnod,knum)) == NULL)
  78.             return(NULL);
  79.         lbp->sucesr = curnod;
  80.         putnod(lbp,lbp->nkv);
  81.         if ((buffer = getnod(curnod,knum)) == NULL)
  82.             return(NULL);
  83.     }
  84.  
  85.     putnod(buffer,buffer->nkv);
  86.     elem++;
  87.     cpybuf(lastkey,idxval,knum->length);
  88.     return(buffer);
  89. }
  90.  
  91. TREEBUFF *skim(knum)
  92. PFAST CTFILE  *knum;
  93. {
  94.     FAST TREEBUFF    *buffer;
  95.     LONG         lnods,nnods;
  96.  
  97.     LONG         nodpnt(),gtroot();
  98.  
  99.     btlev    = 0;
  100.     begnod    = curnod = gtroot(knum);
  101.     while (curnod) {
  102.         prvnod = DRNZERO;
  103.         nnods  = 0L;
  104.         do {
  105.             if ((buffer = getnod(curnod,knum)) == NULL)
  106.                 return(NULL);
  107.             nnods++;
  108.             if (nnods == 1)
  109.                 lnods = curnod;
  110.             prvnod = curnod;
  111.             curnod = buffer->sucesr;
  112.         } while (curnod);
  113.         if (buffer->leaf == LEAF)
  114.             break;
  115.         if (++btlev >= MAXLEV)
  116.             terr(247);
  117.         ct_npath[btlev] = prvnod;
  118.         ct_nnods[btlev] = nnods;
  119.         if ((buffer = getnod(lnods,knum)) == NULL)
  120.             return(NULL);
  121.         curnod = nodpnt(buffer,1);
  122.     }
  123.  
  124.     if ((begnod = curnod = prvnod) == DRNZERO)
  125.         terr(248);
  126.  
  127.     numnod = nnods;
  128.     return(getnod(curnod,knum));
  129. }
  130.  
  131. COUNT LOADKEY(keyno,target,recbyt,typadd)
  132. COUNT          keyno;
  133. TEXT           *target;
  134. POINTER               recbyt;
  135. COUNT                  typadd;
  136. {
  137.     FAST CTFILE    *knum;
  138.     FAST TREEBUFF  *buffer;
  139.     TREEBUFF       *lbp;
  140.     TEXT        idxval[MAXLEN];
  141.     TEXT           *tp;
  142.     LONG        lnod;
  143.  
  144.     VOID        newleaf(),nonleaf();
  145.     CTFILE           *tstfnm();
  146.  
  147.     uerr_cod = NO_ERROR;
  148.     if ((knum = tstfnm(keyno)) == NULL)
  149.         return(uerr_cod);
  150.     else if (knum->clstyp != IDX_CLOSE)
  151.         return(uerr(FMOD_ERR));
  152.  
  153.     if (typadd != BLDADD) {
  154.         cpybuf(idxval,target,knum->length);
  155.         if (knum->autodup == DUPKEY)
  156.             prpdup(idxval,knum,&recbyt);
  157.     }
  158.  
  159.     if (typadd == NXTADD) {
  160.     /* additional key value */
  161.         if (started != keyno)
  162.             return(uerr(KLOD_ERR));
  163.         buffer = savbp;
  164.         if ((ct_tkp = compar(idxval,valpnt(buffer,elem),knum)) <= 0)
  165.             return(uerr(KLOR_ERR));
  166.     } else if (typadd == FRSADD) {
  167.     /* first key value */
  168.         if (started != -1)
  169.         return(uerr(KLOD_ERR));
  170.         else if (LSTKEY(keyno,lastkey) == DRNZERO) {
  171.         /* start with empty tree */
  172.         if (uerr_cod)
  173.             return(uerr_cod);
  174.         elem   = ct_tkp = 0;
  175.         prvnod = DRNZERO;
  176.         if ((savbp = buffer = newnod(knum,&begnod,NO)) == NULL)
  177.             return(uerr_cod);
  178.         curnod = begnod;
  179.         numnod = 1L;
  180.         newleaf(buffer,knum);
  181.         started = keyno;
  182.         } else if (compar(idxval,lastkey,knum) > 0) {
  183.         /* adding to end of tree */
  184.         if ((savbp = buffer = skim(knum)) == NULL)
  185.             return(uerr_cod);
  186.         elem = buffer->nkv;
  187.         if (elem)
  188.             ct_tkp = compar(idxval,lastkey,knum);
  189.         else
  190.             ct_tkp = 0;
  191.         started = keyno;
  192.         if (tstupd(knum))
  193.             return(uerr_cod);
  194.         } else
  195.         return(uerr(KLOR_ERR));
  196.     } else if (typadd == BLDADD) {
  197.     /* no more key values */
  198.         if (started != keyno)
  199.         return(uerr(KLOD_ERR));
  200.         if ((buffer = getnod(curnod,knum)) == NULL)
  201.         return(uerr_cod);
  202.         for (tp = hghpnt(buffer), elem = 0; elem++ < knum->length; )
  203.         *tp++ = 0xff;
  204.         putnod(buffer,buffer->nkv);
  205.         for ( ;; ) {
  206.         if (numnod == 1) {
  207.             knum->root = begnod;
  208.             if (wrthdr(knum) || tstupd(knum))
  209.                 return(uerr_cod);
  210.             else {
  211.                 started = -1;
  212.                 return(NO_ERROR);
  213.             }
  214.         }
  215.         lnod   = begnod;
  216.         if (btlev > 0) {
  217.             numnod = ct_nnods[btlev];
  218.             begnod = ct_npath[btlev--];
  219.             if ((buffer = getnod(begnod,knum)) == NULL)
  220.                 return(uerr_cod);
  221.             if (buffer->sucesr != DRNZERO) terr(249);
  222.             valpnt(buffer,buffer->nkv);
  223.             delexp(buffer);
  224.             putnod(buffer,buffer->nkv);
  225.             cpybuf(lastkey,valpnt(buffer,elem = buffer->nkv),
  226.                 buffer->klen);
  227.         } else {
  228.             elem   = ct_tkp = 0;
  229.             numnod = 1;
  230.             if ((buffer = newnod(knum,&begnod,NO)) == NULL)
  231.                 return(uerr_cod);
  232.             nonleaf(buffer,knum);
  233.         }
  234.         curnod = begnod;
  235.         do {
  236.             if ((lbp = getnod(lnod,knum)) == NULL)
  237.                 return(uerr_cod);
  238.             if (lbp->leaf == LEAF)
  239.                 cpybuf(idxval,hghpnt(lbp),knum->length);
  240.             else
  241.                 cpybuf(idxval,valpnt(lbp,lbp->nkv),
  242.                     knum->length);
  243.             if (elem != 0)
  244.                 ct_tkp = compar(idxval,lastkey,knum);
  245.             if ((buffer = getnod(curnod,knum)) == NULL)
  246.                 return(uerr_cod);
  247.             if ((buffer = lodins(buffer,idxval,lnod,knum)) == NULL)
  248.                 return(uerr_cod);
  249.             lnod   = lbp->sucesr;
  250.         } while (lnod);
  251.         }
  252.     }
  253.  
  254.     if (lodins(buffer,idxval,recbyt,knum) == NULL || tstupd(knum))
  255.         return(uerr_cod);
  256.     knum->nument++;
  257.     return(NO_ERROR);
  258. }
  259.  
  260. VOID newleaf(bp,kp)
  261. PFAST TREEBUFF *bp;
  262. PFAST CTFILE   *kp;
  263. {
  264.     bp->leaf   = LEAF;
  265.     bp->maxkv  = kp->maxkvl;
  266.     bp->maxb   = kp->maxkbl;
  267.     bp->sucesr = DRNZERO;
  268.     bp->predsr = prvnod;
  269.     if (kp->autodup)
  270.         bp->confg = DUPLEAF;
  271.     else
  272.         bp->confg = REGULAR;
  273. }
  274.  
  275. VOID nonleaf(bp,kp)
  276. PFAST TREEBUFF *bp;
  277. PFAST CTFILE   *kp;
  278. {
  279.     bp->leaf   = NOLEAF;
  280.     bp->maxkv  = kp->maxkvn;
  281.     bp->maxb   = kp->maxkbn;
  282.     bp->sucesr = DRNZERO;
  283.     bp->predsr = DRNZERO;
  284.     if (kp->autodup)
  285.         bp->confg = DUPNONL;
  286.     else
  287.         bp->confg = REGULAR;
  288. }
  289.  
  290. /* end of ctload.c */
  291.