Subversion Repositories freemyipod

Rev

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

Rev Author Line No. Line
71 theseven 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 "global.h"
113 theseven 40 
#include "include/string.h"
71 theseven 41 
 
42 
 
43 
/* Nonzero if either X or Y is not aligned on a "long" boundary.  */
44 
#define UNALIGNED(X, Y) \
45 
  (((long)X & (sizeof (long) - 1)) | ((long)Y & (sizeof (long) - 1)))
46 
 
47 
/* How many bytes are copied each iteration of the word copy loop.  */
48 
#define LBLOCKSIZE (sizeof (long))
49 
 
50 
/* Threshhold for punting to the byte copier.  */
51 
#define TOO_SMALL(LEN)  ((LEN) < LBLOCKSIZE)
52 
 
53 
int
54 
_DEFUN (memcmp, (m1, m2, n),
55 
        _CONST _PTR m1 _AND
56 
        _CONST _PTR m2 _AND
57 
        size_t n)
58 
{
59 
#if defined(PREFER_SIZE_OVER_SPEED) || defined(__OPTIMIZE_SIZE__)
60 
  unsigned char *s1 = (unsigned char *) m1;
61 
  unsigned char *s2 = (unsigned char *) m2;
62 
 
63 
  while (n--)
64 
    {
65 
      if (*s1 != *s2)
66 
        {
67 
          return *s1 - *s2;
68 
        }
69 
      s1++;
70 
      s2++;
71 
    }
72 
  return 0;
73 
#else
74 
  unsigned char *s1 = (unsigned char *) m1;
75 
  unsigned char *s2 = (unsigned char *) m2;
76 
  unsigned long *a1;
77 
  unsigned long *a2;
78 
 
79 
  /* If the size is too small, or either pointer is unaligned,
80 
     then we punt to the byte compare loop.  Hopefully this will
81 
     not turn up in inner loops.  */
82 
  if (!TOO_SMALL(n) && !UNALIGNED(s1,s2))
83 
    {
84 
      /* Otherwise, load and compare the blocks of memory one
85 
         word at a time.  */
86 
      a1 = (unsigned long*) s1;
87 
      a2 = (unsigned long*) s2;
88 
      while (n >= LBLOCKSIZE)
89 
        {
90 
          if (*a1 != *a2)
91 
            break;
92 
          a1++;
93 
          a2++;
94 
          n -= LBLOCKSIZE;
95 
        }
96 
 
97 
      /* check m mod LBLOCKSIZE remaining characters */
98 
 
99 
      s1 = (unsigned char*)a1;
100 
      s2 = (unsigned char*)a2;
101 
    }
102 
 
103 
  while (n--)
104 
    {
105 
      if (*s1 != *s2)
106 
        return *s1 - *s2;
107 
      s1++;
108 
      s2++;
109 
    }
110 
 
111 
  return 0;
112 
#endif /* not PREFER_SIZE_OVER_SPEED */
113 
}
114