home *** CD-ROM | disk | FTP | other *** search
/ Frostbyte's 1980s DOS Shareware Collection / floppyshareware.zip / floppyshareware / DOOG / CBASE09.ZIP / CBASE.ZIP / CBCMP.C < prev    next >
Text File  |  1989-08-31  |  10KB  |  538 lines
  1. /*    Copyright (c) 1989 Citadel    */
  2. /*       All Rights Reserved        */
  3.  
  4. /* #ident    "cbcmp.c    1.1 - 89/08/31" */
  5.  
  6. #include <blkio.h>
  7. #include <errno.h>
  8. /* #include <string.h> */
  9. #include "cbase_.h"
  10.  
  11. /*man---------------------------------------------------------------------------
  12. NAME
  13.  
  14. SYNOPSIS
  15.  
  16. DESCRIPTION
  17.  
  18. SEE ALSO
  19.  
  20. DIAGNOSTICS
  21.  
  22. ------------------------------------------------------------------------------*/
  23. static int charcmp(s1, s2, n)
  24. void * s1;
  25. void * s2;
  26. size_t n;
  27. {
  28.     int        rt    = 0;
  29.     /*signed*/char    n1    = 0;
  30.     /*signed*/char    n2    = 0;
  31.     cbrpos_t    b1    = 0;
  32.     cbrpos_t    b2    = 0;
  33.  
  34.     memcpy((void *)&n1, s1, sizeof(n1));
  35.     memcpy((void *)&n2, s2, sizeof(n2));
  36.     if (n1 < n2) {
  37.         rt = -1;
  38.     } else if (n1 > n2) {
  39.         rt = 1;
  40.     } else {
  41.         rt = 0;
  42.     }
  43.     if (rt != 0) {
  44.         return rt;
  45.     }
  46.  
  47.     memcpy((void *)&b1, (void *)((char *)s1 + n - sizeof(cbrpos_t)), sizeof(b1));
  48.     memcpy((void *)&b2, (void *)((char *)s2 + n - sizeof(cbrpos_t)), sizeof(b2));
  49.     if (b1 < b2) {
  50.         rt = -1;
  51.     } else if (b1 > b2) {
  52.         rt = 1;
  53.     } else {
  54.         rt = 0;
  55.     }
  56.  
  57.     return rt;
  58. }
  59.  
  60. static int ucharcmp(s1, s2, n)
  61. void * s1;
  62. void * s2;
  63. size_t n;
  64. {
  65.     int        rt    = 0;
  66.     unsigned char    n1    = 0;
  67.     unsigned char    n2    = 0;
  68.     cbrpos_t    b1    = 0;
  69.     cbrpos_t    b2    = 0;
  70.  
  71.     memcpy((void *)&n1, s1, sizeof(n1));
  72.     memcpy((void *)&n2, s2, sizeof(n2));
  73.     if (n1 < n2) {
  74.         rt = -1;
  75.     } else if (n1 > n2) {
  76.         rt = 1;
  77.     } else {
  78.         rt = 0;
  79.     }
  80.     if (rt != 0) {
  81.         return rt;
  82.     }
  83.  
  84.     memcpy((void *)&b1, (void *)((char *)s1 + n - sizeof(cbrpos_t)), sizeof(b1));
  85.     memcpy((void *)&b2, (void *)((char *)s2 + n - sizeof(cbrpos_t)), sizeof(b2));
  86.     if (b1 < b2) {
  87.         rt = -1;
  88.     } else if (b1 > b2) {
  89.         rt = 1;
  90.     } else {
  91.         rt = 0;
  92.     }
  93.  
  94.     return rt;
  95. }
  96.  
  97. static int shortcmp(s1, s2, n)
  98. void * s1;
  99. void * s2;
  100. size_t n;
  101. {
  102.     int        rt    = 0;
  103.     /*signed*/short    n1    = 0;
  104.     /*signed*/short    n2    = 0;
  105.     cbrpos_t    b1    = 0;
  106.     cbrpos_t    b2    = 0;
  107.  
  108.     memcpy((void *)&n1, s1, sizeof(n1));
  109.     memcpy((void *)&n2, s2, sizeof(n2));
  110.     if (n1 < n2) {
  111.         rt = -1;
  112.     } else if (n1 > n2) {
  113.         rt = 1;
  114.     } else {
  115.         rt = 0;
  116.     }
  117.     if (rt != 0) {
  118.         return rt;
  119.     }
  120.  
  121.     memcpy((void *)&b1, (void *)((char *)s1 + n - sizeof(cbrpos_t)), sizeof(b1));
  122.     memcpy((void *)&b2, (void *)((char *)s2 + n - sizeof(cbrpos_t)), sizeof(b2));
  123.     if (b1 < b2) {
  124.         rt = -1;
  125.     } else if (b1 > b2) {
  126.         rt = 1;
  127.     } else {
  128.         rt = 0;
  129.     }
  130.  
  131.     return rt;
  132. }
  133.  
  134. static int ushortcmp(s1, s2, n)
  135. void * s1;
  136. void * s2;
  137. size_t n;
  138. {
  139.     int        rt    = 0;
  140.     unsigned short    n1    = 0;
  141.     unsigned short    n2    = 0;
  142.     cbrpos_t    b1    = 0;
  143.     cbrpos_t    b2    = 0;
  144.  
  145.     memcpy((void *)&n1, s1, sizeof(n1));
  146.     memcpy((void *)&n2, s2, sizeof(n2));
  147.     if (n1 < n2) {
  148.         rt = -1;
  149.     } else if (n1 > n2) {
  150.         rt = 1;
  151.     } else {
  152.         rt = 0;
  153.     }
  154.     if (rt != 0) {
  155.         return rt;
  156.     }
  157.  
  158.     memcpy((void *)&b1, (void *)((char *)s1 + n - sizeof(cbrpos_t)), sizeof(b1));
  159.     memcpy((void *)&b2, (void *)((char *)s2 + n - sizeof(cbrpos_t)), sizeof(b2));
  160.     if (b1 < b2) {
  161.         rt = -1;
  162.     } else if (b1 > b2) {
  163.         rt = 1;
  164.     } else {
  165.         rt = 0;
  166.     }
  167.  
  168.     return rt;
  169. }
  170.  
  171. static int intcmp(s1, s2, n)
  172. void * s1;
  173. void * s2;
  174. size_t n;
  175. {
  176.     int        rt    = 0;
  177.     /*signed*/int    n1    = 0;
  178.     /*signed*/int    n2    = 0;
  179.     cbrpos_t    b1    = 0;
  180.     cbrpos_t    b2    = 0;
  181.  
  182.     memcpy((void *)&n1, s1, sizeof(n1));
  183.     memcpy((void *)&n2, s2, sizeof(n2));
  184.     if (n1 < n2) {
  185.         rt = -1;
  186.     } else if (n1 > n2) {
  187.         rt = 1;
  188.     } else {
  189.         rt = 0;
  190.     }
  191.     if (rt != 0) {
  192.         return rt;
  193.     }
  194.  
  195.     memcpy((void *)&b1, (void *)((char *)s1 + n - sizeof(cbrpos_t)), sizeof(b1));
  196.     memcpy((void *)&b2, (void *)((char *)s2 + n - sizeof(cbrpos_t)), sizeof(b2));
  197.     if (b1 < b2) {
  198.         rt = -1;
  199.     } else if (b1 > b2) {
  200.         rt = 1;
  201.     } else {
  202.         rt = 0;
  203.     }
  204.  
  205.     return rt;
  206. }
  207.  
  208. static int uintcmp(s1, s2, n)
  209. void * s1;
  210. void * s2;
  211. size_t n;
  212. {
  213.     int        rt    = 0;
  214.     unsigned int    n1    = 0;
  215.     unsigned int    n2    = 0;
  216.     cbrpos_t    b1    = 0;
  217.     cbrpos_t    b2    = 0;
  218.  
  219.     memcpy((void *)&n1, s1, sizeof(n1));
  220.     memcpy((void *)&n2, s2, sizeof(n2));
  221.     if (n1 < n2) {
  222.         rt = -1;
  223.     } else if (n1 > n2) {
  224.         rt = 1;
  225.     } else {
  226.         rt = 0;
  227.     }
  228.     if (rt != 0) {
  229.         return rt;
  230.     }
  231.  
  232.     memcpy((void *)&b1, (void *)((char *)s1 + n - sizeof(cbrpos_t)), sizeof(b1));
  233.     memcpy((void *)&b2, (void *)((char *)s2 + n - sizeof(cbrpos_t)), sizeof(b2));
  234.     if (b1 < b2) {
  235.         rt = -1;
  236.     } else if (b1 > b2) {
  237.         rt = 1;
  238.     } else {
  239.         rt = 0;
  240.     }
  241.  
  242.     return rt;
  243. }
  244.  
  245. static int longcmp(s1, s2, n)
  246. void * s1;
  247. void * s2;
  248. size_t n;
  249. {
  250.     int        rt    = 0;
  251.     /*signed*/long    n1    = 0;
  252.     /*signed*/long    n2    = 0;
  253.     cbrpos_t    b1    = 0;
  254.     cbrpos_t    b2    = 0;
  255.  
  256.     memcpy((void *)&n1, s1, sizeof(n1));
  257.     memcpy((void *)&n2, s2, sizeof(n2));
  258.     if (n1 < n2) {
  259.         rt = -1;
  260.     } else if (n1 > n2) {
  261.         rt = 1;
  262.     } else {
  263.         rt = 0;
  264.     }
  265.     if (rt != 0) {
  266.         return rt;
  267.     }
  268.  
  269.     memcpy((void *)&b1, (void *)((char *)s1 + n - sizeof(cbrpos_t)), sizeof(b1));
  270.     memcpy((void *)&b2, (void *)((char *)s2 + n - sizeof(cbrpos_t)), sizeof(b2));
  271.     if (b1 < b2) {
  272.         rt = -1;
  273.     } else if (b1 > b2) {
  274.         rt = 1;
  275.     } else {
  276.         rt = 0;
  277.     }
  278.  
  279.     return rt;
  280. }
  281.  
  282. static int ulongcmp(s1, s2, n)
  283. void * s1;
  284. void * s2;
  285. size_t n;
  286. {
  287.     int        rt    = 0;
  288.     unsigned long    n1    = 0;
  289.     unsigned long    n2    = 0;
  290.     cbrpos_t    b1    = 0;
  291.     cbrpos_t    b2    = 0;
  292.  
  293.     memcpy((void *)&n1, s1, sizeof(n1));
  294.     memcpy((void *)&n2, s2, sizeof(n2));
  295.     if (n1 < n2) {
  296.         rt = -1;
  297.     } else if (n1 > n2) {
  298.         rt = 1;
  299.     } else {
  300.         rt = 0;
  301.     }
  302.     if (rt != 0) {
  303.         return rt;
  304.     }
  305.  
  306.     memcpy((void *)&b1, (void *)((char *)s1 + n - sizeof(cbrpos_t)), sizeof(b1));
  307.     memcpy((void *)&b2, (void *)((char *)s2 + n - sizeof(cbrpos_t)), sizeof(b2));
  308.     if (b1 < b2) {
  309.         rt = -1;
  310.     } else if (b1 > b2) {
  311.         rt = 1;
  312.     } else {
  313.         rt = 0;
  314.     }
  315.  
  316.     return rt;
  317. }
  318.  
  319. static int floatcmp(s1, s2, n)
  320. void * s1;
  321. void * s2;
  322. size_t n;
  323. {
  324.     int        rt    = 0;
  325.     float        n1    = 0;
  326.     float        n2    = 0;
  327.     cbrpos_t    b1    = 0;
  328.     cbrpos_t    b2    = 0;
  329.  
  330.     memcpy((void *)&n1, s1, sizeof(n1));
  331.     memcpy((void *)&n2, s2, sizeof(n2));
  332.     if (n1 < n2) {
  333.         rt = -1;
  334.     } else if (n1 > n2) {
  335.         rt = 1;
  336.     } else {
  337.         rt = 0;
  338.     }
  339.     if (rt != 0) {
  340.         return rt;
  341.     }
  342.  
  343.     memcpy((void *)&b1, (void *)((char *)s1 + n - sizeof(cbrpos_t)), sizeof(b1));
  344.     memcpy((void *)&b2, (void *)((char *)s2 + n - sizeof(cbrpos_t)), sizeof(b2));
  345.     if (b1 < b2) {
  346.         rt = -1;
  347.     } else if (b1 > b2) {
  348.         rt = 1;
  349.     } else {
  350.         rt = 0;
  351.     }
  352.  
  353.     return rt;
  354. }
  355.  
  356. static int doublecmp(s1, s2, n)
  357. void * s1;
  358. void * s2;
  359. size_t n;
  360. {
  361.     int        rt    = 0;
  362.     double        n1    = 0;
  363.     double        n2    = 0;
  364.     cbrpos_t    b1    = 0;
  365.     cbrpos_t    b2    = 0;
  366.  
  367.     memcpy((void *)&n1, s1, sizeof(n1));
  368.     memcpy((void *)&n2, s2, sizeof(n2));
  369.     if (n1 < n2) {
  370.         rt = -1;
  371.     } else if (n1 > n2) {
  372.         rt = 1;
  373.     } else {
  374.         rt = 0;
  375.     }
  376.     if (rt != 0) {
  377.         return rt;
  378.     }
  379.  
  380.     memcpy((void *)&b1, (void *)((char *)s1 + n - sizeof(cbrpos_t)), sizeof(b1));
  381.     memcpy((void *)&b2, (void *)((char *)s2 + n - sizeof(cbrpos_t)), sizeof(b2));
  382.     if (b1 < b2) {
  383.         rt = -1;
  384.     } else if (b1 > b2) {
  385.         rt = 1;
  386.     } else {
  387.         rt = 0;
  388.     }
  389.  
  390.     return rt;
  391. }
  392.  
  393. static int ldoublecmp(s1, s2, n)
  394. void * s1;
  395. void * s2;
  396. size_t n;
  397. {
  398.     int        rt    = 0;
  399.     /*long*/double    n1    = 0;
  400.     /*long*/double    n2    = 0;
  401.     cbrpos_t    b1    = 0;
  402.     cbrpos_t    b2    = 0;
  403.  
  404.     memcpy((void *)&n1, s1, sizeof(n1));
  405.     memcpy((void *)&n2, s2, sizeof(n2));
  406.     if (n1 < n2) {
  407.         rt = -1;
  408.     } else if (n1 > n2) {
  409.         rt = 1;
  410.     } else {
  411.         rt = 0;
  412.     }
  413.     if (rt != 0) {
  414.         return rt;
  415.     }
  416.  
  417.     memcpy((void *)&b1, (void *)((char *)s1 + n - sizeof(cbrpos_t)), sizeof(b1));
  418.     memcpy((void *)&b2, (void *)((char *)s2 + n - sizeof(cbrpos_t)), sizeof(b2));
  419.     if (b1 < b2) {
  420.         rt = -1;
  421.     } else if (b1 > b2) {
  422.         rt = 1;
  423.     } else {
  424.         rt = 0;
  425.     }
  426.  
  427.     return rt;
  428. }
  429.  
  430. static int pointercmp(s1, s2, n)
  431. void * s1;
  432. void * s2;
  433. size_t n;
  434. {
  435.     int        rt    = 0;
  436.     void *         n1    = 0;
  437.     void *        n2    = 0;
  438.     cbrpos_t    b1    = 0;
  439.     cbrpos_t    b2    = 0;
  440.  
  441.     memcpy((void *)&n1, s1, sizeof(n1));
  442.     memcpy((void *)&n2, s2, sizeof(n2));
  443.     if (n1 < n2) {
  444.         rt = -1;
  445.     } else if (n1 > n2) {
  446.         rt = 1;
  447.     } else {
  448.         rt = 0;
  449.     }
  450.     if (rt != 0) {
  451.         return rt;
  452.     }
  453.  
  454.     memcpy((void *)&b1, (void *)((char *)s1 + n - sizeof(cbrpos_t)), sizeof(b1));
  455.     memcpy((void *)&b2, (void *)((char *)s2 + n - sizeof(cbrpos_t)), sizeof(b2));
  456.     if (b1 < b2) {
  457.         rt = -1;
  458.     } else if (b1 > b2) {
  459.         rt = 1;
  460.     } else {
  461.         rt = 0;
  462.     }
  463.  
  464.     return rt;
  465. }
  466.  
  467. static int stringcmp(s1, s2, n)
  468. void * s1;
  469. void * s2;
  470. size_t n;
  471. {
  472.     int        rt    = 0;
  473.     cbrpos_t    b1    = 0;
  474.     cbrpos_t    b2    = 0;
  475.  
  476.     rt = strncmp((char *)s1, (char *)s2, n - sizeof(cbrpos_t));
  477.     if (rt != 0) {
  478.         return rt;
  479.     }
  480.  
  481.     memcpy((void *)&b1, (void *)((char *)s1 + n - sizeof(cbrpos_t)), sizeof(b1));
  482.     memcpy((void *)&b2, (void *)((char *)s2 + n - sizeof(cbrpos_t)), sizeof(b2));
  483.     if (b1 < b2) {
  484.         rt = -1;
  485.     } else if (b1 > b2) {
  486.         rt = 1;
  487.     } else {
  488.         rt = 0;
  489.     }
  490.  
  491.     return rt;
  492. }
  493.  
  494. static int binarycmp(s1, s2, n)
  495. void * s1;
  496. void * s2;
  497. size_t n;
  498. {
  499.     int        rt    = 0;
  500.     cbrpos_t    b1    = 0;
  501.     cbrpos_t    b2    = 0;
  502.  
  503.     rt = memcmp((char *)s1, (char *)s2, n - sizeof(cbrpos_t));
  504.     if (rt != 0) {
  505.         return rt;
  506.     }
  507.  
  508.     memcpy((void *)&b1, (void *)((char *)s1 + n - sizeof(cbrpos_t)), sizeof(b1));
  509.     memcpy((void *)&b2, (void *)((char *)s2 + n - sizeof(cbrpos_t)), sizeof(b2));
  510.     if (b1 < b2) {
  511.         rt = -1;
  512.     } else if (b1 > b2) {
  513.         rt = 1;
  514.     } else {
  515.         rt = 0;
  516.     }
  517.  
  518.     return rt;
  519. }
  520.  
  521. /* cbase comparison function array definition */
  522. pfcbcmp_t cbcmp_p[] = {
  523.     charcmp,    /* t_char    = 1 */
  524.     ucharcmp,    /* t_uchar    = 2 */
  525.     shortcmp,    /* t_short    = 3 */
  526.     ushortcmp,    /* t_ushort    = 4 */
  527.     intcmp,        /* t_int    = 5 */
  528.     uintcmp,    /* t_uint    = 6 */
  529.     longcmp,    /* t_long    = 7 */
  530.     ulongcmp,    /* t_ulong    = 8 */
  531.     floatcmp,    /* t_float    = 9 */
  532.     doublecmp,    /* t_double    = 10 */
  533.     ldoublecmp,    /* t_ldouble    = 11 */
  534.     pointercmp,    /* t_pointer    = 12 */
  535.     stringcmp,    /* t_string    = 13 */
  536.     binarycmp    /* t_binary    = 14 */
  537. };
  538.