Subversion Repositories openrisc

/*

    string.h -- String manipulation

    Implements (some) of the standard string routines

    Copyright (C) 2002 Richard Herveille, rherveille@opencores.org

    This file is part of OpenRISC 1000 Reference Platform Monitor (ORPmon)

    This program is free software; you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation; either version 2 of the License, or

    (at your option) any later version

    This program is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License

    along with this program; if not, write to the Free Software

    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/

#include <stddef.h>

#include "string.h"

/* Basic string functions */

/*

  s t r l e n

  returns number of characters in s (not including terminating null character)

*/

size_t strlen(const char *s)

{

  size_t cnt = 0;

  /* count the length of string s, not including the \0 character */

  while (*s++)

    cnt++;

  return cnt;

}

/*

  s t r c p y

  Copy 'src' to 'dest'. Strings may not overlap.

*/

char *strcpy(char *dest, const char *src)

{

  char *d = dest;

  /* copy src to dest */

  while ( (*dest++ = *src++) )

  ;

  return d;

}

char *strncpy(char *dest, const char *src, size_t n)

{

  char *d = dest;

  /* copy src to dest */

  while ( *src && n ) {

    *dest++ = *src++;

    n--;

  }

  /* fill the remainder of d with nulls */

  while (n--)

    *dest++ = '\0';

  return d;

}

char *strcat(char *dest, const char *src)

{

  char *d = dest;

  /* find the end of the destination string */

  while (*dest++)

  ;

  /* append the source string to the destination string */

  while ( (*dest++ = *src++) )

  ;

  return d;

}

char *strncat(char *dest, const char *src, size_t n)

{

  char *d = dest;

  /* find the end of the destination string */

  while (*dest++)

  ;

  /* copy src to dest */

  while ( (*dest = *src) && n-- ) {

    dest++;

    src++;

  }

  /* add terminating '\0' character */

  *dest = '\0';

  return d;

}

int strcmp(const char *s1, const char *s2)

{

  while ( *s1 && (*s1 == *s2) ) {

    s1++;

    s2++;

  }

  return *s1 - *s2;

}

int strncmp(const char *s1, const char *s2, size_t n)

{

  while ( *s1 && (*s1 == *s2) && n-- ) {

    s1++;

    s2++;

  }

  return *s1 - *s2;

}

char *strchr(const char *s, int c)

{

  /* search for the character c */

  while (*s && (*s != c) )

    s++;

  return (char *)s;

}

char *strrchr(const char *s, int c)

{

  char *fnd = NULL;

  /* search for the character c */

  while (*s) {

    if (*s == c)

      fnd = (char *)s;

    s++;

  }

  return fnd;

}

/* Basic mem functions */

void *memcpy(void *dest, const void *src, size_t n)

{

  /* check if 'src' and 'dest' are on LONG boundaries */

  if ( (sizeof(unsigned long) -1) & ((unsigned long)dest | (unsigned long)src) )

  {

      /* no, do a byte-wide copy */

      char *cs = (char *) src;

      char *cd = (char *) dest;

      while (n--)

          *cd++ = *cs++;

  }

  else

  {

      /* yes, speed up copy process */

      /* copy as many LONGs as possible */

      long *ls = (long *)src;

      long *ld = (long *)dest;

      size_t cnt = n >> 2;

      while (cnt--)

        *ld++ = *ls++;

      /* finally copy the remaining bytes */

      char *cs = (char *) (src + (n & ~0x03));

      char *cd = (char *) (dest + (n & ~0x03));

      cnt = n & 0x3;

      while (cnt--)

        *cd++ = *cs++;

  }

  return dest;

}

void *memmove(void *dest, void *src, size_t n)

{

  char *d = dest;

  char *s = src;

  while (n--)

    *d++ = *s++;

  return dest;

}

int memcmp(const void *s1, const void *s2, size_t n)

{

  char *p1 = (void *)s1;

  char *p2 = (void *)s2;

  while ( (*p1 == *p2) && n-- ) {

    p1++;

    p2++;

  }

  return *p1 - *p2;

}

void *memchr(const void *s, int c, size_t n)

{

  char *p = (void *)s;

  /* search for the character c */

  while ( (*p != c) && n-- )

    p++;

  return (*p == c) ? p : NULL;

}

void *memset(void *s, int c, size_t n)

{

  char *p = s;

  while (n--)

    *p++ = c;

  return s;

}