Subversion Repositories openrisc_2011-10-31

/*

    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;

}

/* memcpy, return  checksum of bytes copied instead of pointer to dest */

unsigned char memcpy_crc(void *dest, const void *src, size_t n)

{

        unsigned char sum = 0;

        unsigned char tmp;

        char *cs = (char *)src;

        char *cd = (char *)dest;

        while (n--) {

                tmp = *cs++;

                sum += tmp;

                *cd++ = tmp;

        }

        return sum;

}

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, char 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;

}