home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c004 / 1.ddi / CTCOMP.C < prev    next >
Encoding:
C/C++ Source or Header  |  1989-04-18  |  5.5 KB  |  237 lines
  1. /*
  2.  *    index file compare routine
  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. /*
  30.  * The c-tree Source Code License Agreement expressly prohibits modification
  31.  * of any and all FairCom copyright legends and statements of confidentiality,
  32.  * including the following such legend and statement, without the express
  33.  * written consent of FairCom.
  34.  */
  35.  
  36. static char *cprt[] = {
  37. "             The c-tree(R) file handler is the CONFIDENTIAL and",
  38. "      PROPRIETARY property of FairCom(R) Corporation. Any unauthorized",
  39. "       use, reproduction or transfer of c-tree is strictly prohibited.",
  40. "    Copyright (c) 1984, 1985, 1986, 1987, 1988, 1989 FairCom Corporation",
  41. "     (Subject to limited distribution and restricted disclosure only.)",
  42. "                           ALL RIGHTS RESERVED.",
  43. ""
  44.         };
  45.  
  46. #define NO_FPLIB        /* do not use floating point lib for compar */
  47.  
  48. #ifdef REVBIN
  49. #undef REVBIN
  50. #endif
  51. #ifdef LOW_HIGH
  52. #define REVBIN
  53. #endif
  54. #ifdef HIGH_LOW
  55. #ifdef UNIFRMAT
  56. #define REVBIN
  57. #endif
  58. #endif
  59.  
  60. /* --------------------------------------------------------------------
  61.    routine to compar key values
  62.  
  63.    compar returns a value < 0  for *val1 < *val2
  64.                           = 0  for *val1 = *val2
  65.                           > 0  for *val1 > *val2
  66.  */
  67.    
  68. COUNT compar(val1,val2,knum)
  69. PFAST TEXT *val1,*val2;
  70. KEYFILE              *knum;
  71. {
  72.     FAST COUNT i;
  73.     COUNT      keylen,typ;
  74. #ifdef FLOATKEY
  75. #ifdef NO_FPLIB
  76.     COUNT      sign,ms,ls;
  77.     LONG       fv1[2],fv2[2];
  78. #else
  79.     float       fv1,fv2;
  80.     double     dv1,dv2;
  81.     TEXT       *tv1,*tv2;
  82. #endif
  83. #endif
  84.  
  85.     keylen = knum->length;
  86.  
  87. #ifdef CTDEBUG    /* prints bytes in left-to-right order */
  88.     printf("\nCTDEBUG:");
  89.     for (i = 0; i < keylen; i++)
  90.         printf("   %02x %02x",CMPMSK & *(val1 + i),
  91.             CMPMSK & *(val2 + i));
  92.     printf("\n");
  93. #endif
  94.  
  95.     switch (typ = (knum->ktype & MSK_ALT)) {
  96.     /* mask the alternative collating sequence bit prior to the switch */
  97.  
  98.     case ALPHAKEY:   /* left to right ct_key comparison    */
  99. #ifdef VARLKEYS
  100.     case COL_SUFFIX: /* padding compression            */
  101.     case COL_PREFIX: /* leading character compression    */
  102.     case COL_BOTH:
  103. #endif
  104. #ifndef REVBIN
  105.     case INTKEY:     /* ignore right-to-left scan on HIGH_LOW machine */
  106. #endif
  107.         i = 0;
  108.         while (i++ < keylen && *val1++ == *val2++)
  109.             ;
  110. #ifdef DS
  111.         keylen = ((COUNT) *--val1 & CMPMSK) -
  112.             ((COUNT) *--val2 & CMPMSK);
  113. #else
  114.         keylen = (*--val1 & CMPMSK) - (*--val2 & CMPMSK);
  115. #endif
  116.  
  117.         if (keylen > 0)
  118.             return(i);
  119.         else if (keylen < 0)
  120.             return(-i);
  121.         else
  122.             return(0);
  123.  
  124. #ifdef REVBIN
  125.     case INTKEY: /* right to left ct_key comparison: no duplicate support */
  126.         val1 += (i = keylen);
  127.         val2 += i;
  128.         while (i-- > 0 && *--val1 == *--val2)
  129.             ;
  130. #ifdef DS
  131.         return(((COUNT) *val1 & CMPMSK) - ((COUNT) *val2 & CMPMSK));
  132. #else
  133.         return((*val1 & CMPMSK) - (*val2 & CMPMSK));
  134. #endif
  135. #endif
  136. #ifdef FLOATKEY
  137.     case SFLOATKEY: /* single float key comparison */
  138.     case DFLOATKEY: /* double float key comparison */
  139.  
  140. #ifdef NO_FPLIB
  141.         ls = 0;
  142.         ms = 1;
  143.         if (typ == SFLOATKEY) {
  144.             fv1[0] = 0l;
  145.             fv2[0] = 0l;
  146.             cpybuf(fv1+1,val1,sizeof(LONG));
  147.             cpybuf(fv2+1,val2,sizeof(LONG));
  148.             val1  += sizeof(float);
  149.             val2  += sizeof(float);
  150.             i      = keylen = sizeof(float);
  151.         } else {
  152. #ifdef HIGH_LOW
  153. #ifndef UNIFRMAT
  154.             ls     = 1;
  155.             ms     = 0;
  156. #endif
  157. #endif
  158.             cpybuf(fv1,val1,2 * sizeof(LONG));
  159.             cpybuf(fv2,val2,2 * sizeof(LONG));
  160.             val1  += sizeof(double);
  161.             val2  += sizeof(double);
  162.             i      = keylen = sizeof(double);
  163.         }
  164. #ifdef UNIFRMAT
  165.         revobj(fv1,sizeof(LONG));
  166.         revobj(fv2,sizeof(LONG));
  167.         revobj(fv1+1,sizeof(LONG));
  168.         revobj(fv2+1,sizeof(LONG));
  169. #endif
  170.  
  171.         if ( fv1[ms] & 0x80000000L && !(fv2[ms] & 0x80000000L) )
  172.             return (-1);
  173.         if ( fv2[ms] & 0x80000000L && !(fv1[ms] & 0x80000000L) )
  174.             return (1);
  175.         sign = 1;
  176.         if ( fv1[ms] & 0x80000000L ) {
  177.             sign = -1;
  178.             fv1[ms] &= 0x7fffffffL;
  179.             fv2[ms] &= 0x7fffffffL;
  180.         }
  181.         if ( fv1[ms] != fv2[ms] )
  182.             return ( (fv1[ms] > fv2[ms]) ? sign : -sign);
  183.         if ( fv1[ls] != fv2[ls] )
  184.             return ( (fv1[ls] > fv2[ls]) ? sign : -sign);
  185.  
  186. #else /* FPLIB */
  187.  
  188.         if (typ == SFLOATKEY) {
  189.             tv1    = (TEXT *) &fv1;
  190.             tv2    = (TEXT *) &fv2;
  191.             keylen = sizeof(float);
  192.         } else {
  193.             tv1    = (TEXT *) &dv1;
  194.             tv2    = (TEXT *) &dv2;
  195.             keylen = sizeof(double);
  196.         }
  197.         i = 0;
  198.         while (i < keylen) {
  199.             *tv1++ = *val1++;
  200.             *tv2++ = *val2++;
  201.             i++;
  202.         }
  203. #ifdef UNIFRMAT
  204.         revobj(tv1 - i,keylen);
  205.         revobj(tv2 - i,keylen);
  206. #endif
  207.  
  208.         if (typ == SFLOATKEY) {
  209.             dv1 = fv1;
  210.             dv2 = fv2;
  211.         }
  212.         dv1 -= dv2;
  213.         if (dv1 < 0.0)
  214.             return(-1);
  215.         else if (dv1 > 0.0)
  216.             return(1);
  217. #endif
  218.  
  219.         while (i++ < knum->length)
  220.             if (*val1++ != *val2++)
  221.                 return((*--val1 & CMPMSK) -
  222.                     (*--val2 & CMPMSK));
  223.         return(0);
  224. #endif        
  225.  
  226.     default:
  227.         terr(210);
  228.     }
  229. }
  230.  
  231. TEXT **chkcopy()
  232. {
  233.     return(cprt);
  234. }
  235.  
  236. /* end of ctcomp.c */
  237.