Subversion Repositories or1k

/*

FUNCTION

        <<memcmp>>---compare two memory areas

INDEX

        memcmp

ANSI_SYNOPSIS

        #include <string.h>

        int memcmp(const void *<[s1]>, const void *<[s2]>, size_t <[n]>);

TRAD_SYNOPSIS

        #include <string.h>

        int memcmp(<[s1]>, <[s2]>, <[n]>)

        void *<[s1]>;

        void *<[s2]>;

        size_t <[n]>;

DESCRIPTION

        This function compares not more than <[n]> characters of the

        object pointed to by <[s1]> with the object pointed to by <[s2]>.

RETURNS

        The function returns an integer greater than, equal to or

        less than zero  according to whether the object pointed to by

        <[s1]> is greater than, equal to or less than the object

        pointed to by <[s2]>.

PORTABILITY

<<memcmp>> is ANSI C.

<<memcmp>> requires no supporting OS subroutines.

QUICKREF

        memcmp ansi pure

*/

#include <string.h>

/* Nonzero if either X or Y is not aligned on a "long" boundary.  */

#define UNALIGNED(X, Y) \

  (((long)X & (sizeof (long) - 1)) | ((long)Y & (sizeof (long) - 1)))

/* How many bytes are copied each iteration of the word copy loop.  */

#define LBLOCKSIZE (sizeof (long))

/* Threshhold for punting to the byte copier.  */

#define TOO_SMALL(LEN)  ((LEN) < LBLOCKSIZE)

int

_DEFUN (memcmp, (m1, m2, n),

        _CONST _PTR m1 _AND

        _CONST _PTR m2 _AND

        size_t n)

{

#ifdef PREFER_SIZE_OVER_SPEED

  unsigned char *s1 = (unsigned char *) m1;

  unsigned char *s2 = (unsigned char *) m2;

  while (n--)

    {

      if (*s1 != *s2)

        {

          return *s1 - *s2;

        }

      s1++;

      s2++;

    }

  return 0;

#else  

  unsigned char *s1 = (unsigned char *) m1;

  unsigned char *s2 = (unsigned char *) m2;

  unsigned long *a1;

  unsigned long *a2;

  /* If the size is too small, or either pointer is unaligned,

     then we punt to the byte compare loop.  Hopefully this will

     not turn up in inner loops.  */

  if (TOO_SMALL(n) || UNALIGNED(s1,s2))

    {

      while (n--)

        {

          if (*s1 != *s2)

            return *s1 - *s2;

          s1++;

          s2++;

        }

      return 0;

    }

  /* Otherwise, load and compare the blocks of memory one

     word at a time.  */

  a1 = (unsigned long*) s1;

  a2 = (unsigned long*) s2;

  while (n > LBLOCKSIZE)

    {

      if (*a1 != *a2)

        {

          /* This block of characters has a mismatch, somewhere.

             xoring them together and then testing for null would

             be fastest, but this is clearer code.  */

          s1 = (char*)a1;

          s2 = (char*)a2;

          while (n--)

            {

              if (*s1 != *s2)

                return *s1 - *s2;

              s1++;

              s2++;

            }

          /* NOT REACHED */

        }

      a1++;

      a2++;

      n -= LBLOCKSIZE;

    }

  /* checking the last few characters */

  s1 = (char*)a1;

  s2 = (char*)a2;

  while (n--)

    {

      if (*s1 != *s2)

        return *s1 - *s2;

      s1++;

      s2++;

    }

  return 0;

#endif /* not PREFER_SIZE_OVER_SPEED */

}