Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1. /*
  2. FUNCTION
  3.         <<memcmp>>---compare two memory areas
  4.  
  5. INDEX
  6.         memcmp
  7.  
  8. ANSI_SYNOPSIS
  9.         #include <string.h>
  10.         int memcmp(const void *<[s1]>, const void *<[s2]>, size_t <[n]>);
  11.  
  12. TRAD_SYNOPSIS
  13.         #include <string.h>
  14.         int memcmp(<[s1]>, <[s2]>, <[n]>)
  15.         void *<[s1]>;
  16.         void *<[s2]>;
  17.         size_t <[n]>;
  18.  
  19. DESCRIPTION
  20.         This function compares not more than <[n]> characters of the
  21.         object pointed to by <[s1]> with the object pointed to by <[s2]>.
  22.  
  23.  
  24. RETURNS
  25.         The function returns an integer greater than, equal to or
  26.         less than zero  according to whether the object pointed to by
  27.         <[s1]> is greater than, equal to or less than the object
  28.         pointed to by <[s2]>.
  29.  
  30. PORTABILITY
  31. <<memcmp>> is ANSI C.
  32.  
  33. <<memcmp>> requires no supporting OS subroutines.
  34.  
  35. QUICKREF
  36.         memcmp ansi pure
  37. */
  38.  
  39. #include <string.h>
  40.  
  41.  
  42. /* Nonzero if either X or Y is not aligned on a "long" boundary.  */
  43. #define UNALIGNED(X, Y) \
  44.   (((long)X & (sizeof (long) - 1)) | ((long)Y & (sizeof (long) - 1)))
  45.  
  46. /* How many bytes are copied each iteration of the word copy loop.  */
  47. #define LBLOCKSIZE (sizeof (long))
  48.  
  49. /* Threshhold for punting to the byte copier.  */
  50. #define TOO_SMALL(LEN)  ((LEN) < LBLOCKSIZE)
  51.  
  52. int
  53. _DEFUN (memcmp, (m1, m2, n),
  54.         _CONST _PTR m1 _AND
  55.         _CONST _PTR m2 _AND
  56.         size_t n)
  57. {
  58. #if defined(PREFER_SIZE_OVER_SPEED) || defined(__OPTIMIZE_SIZE__)
  59.   unsigned char *s1 = (unsigned char *) m1;
  60.   unsigned char *s2 = (unsigned char *) m2;
  61.  
  62.   while (n--)
  63.     {
  64.       if (*s1 != *s2)
  65.         {
  66.           return *s1 - *s2;
  67.         }
  68.       s1++;
  69.       s2++;
  70.     }
  71.   return 0;
  72. #else  
  73.   unsigned char *s1 = (unsigned char *) m1;
  74.   unsigned char *s2 = (unsigned char *) m2;
  75.   unsigned long *a1;
  76.   unsigned long *a2;
  77.  
  78.   /* If the size is too small, or either pointer is unaligned,
  79.      then we punt to the byte compare loop.  Hopefully this will
  80.      not turn up in inner loops.  */
  81.   if (!TOO_SMALL(n) && !UNALIGNED(s1,s2))
  82.     {
  83.       /* Otherwise, load and compare the blocks of memory one
  84.          word at a time.  */
  85.       a1 = (unsigned long*) s1;
  86.       a2 = (unsigned long*) s2;
  87.       while (n >= LBLOCKSIZE)
  88.         {
  89.           if (*a1 != *a2)
  90.             break;
  91.           a1++;
  92.           a2++;
  93.           n -= LBLOCKSIZE;
  94.         }
  95.  
  96.       /* check m mod LBLOCKSIZE remaining characters */
  97.  
  98.       s1 = (unsigned char*)a1;
  99.       s2 = (unsigned char*)a2;
  100.     }
  101.  
  102.   while (n--)
  103.     {
  104.       if (*s1 != *s2)
  105.         return *s1 - *s2;
  106.       s1++;
  107.       s2++;
  108.     }
  109.  
  110.   return 0;
  111. #endif /* not PREFER_SIZE_OVER_SPEED */
  112. }
  113.  
  114.