WebSVN – HelenOS – Diff – /branches/arm/uspace/lib/libc/generic/string.c


/*
 * Copyright (c) 2005 Martin Decky
 * Copyright (C) 1998 by Wes Peters <wes@softweyr.com>
 * Copyright (c) 1988, 1993 The Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
/** @addtogroup libc
 * @{
 */
/** @file
 */
 
#include <string.h>
#include <unistd.h>
#include <ctype.h>
#include <limits.h>
#include <align.h>
#include <sys/types.h>
#include <malloc.h>
 
/* Dummy implementation of mem/ functions */
 
void *memset(void *s, int c, size_t n)
{
    char *os = s;
   
    while (n--)
        *(os++) = c;
   
    return s;
}
 
struct along {
    unsigned long n;
} __attribute__ ((packed));
 
static void *unaligned_memcpy(void *dst, const void *src, size_t n)
{
    int i, j;
    struct along *adst = dst;
    const struct along *asrc = src;
 
    for (i = 0; i < n / sizeof(unsigned long); i++)
        adst[i].n = asrc[i].n;
       
    for (j = 0; j < n % sizeof(unsigned long); j++)
        ((unsigned char *) (((unsigned long *) dst) + i))[j] =
            ((unsigned char *) (((unsigned long *) src) + i))[j];
       
    return (char *) dst;
}
 
void *memcpy(void *dst, const void *src, size_t n)
{
    int i, j;
 
    if (((long) dst & (sizeof(long) - 1)) ||
        ((long) src & (sizeof(long) - 1)))
        return unaligned_memcpy(dst, src, n);
 
    for (i = 0; i < n / sizeof(unsigned long); i++)
        ((unsigned long *) dst)[i] = ((unsigned long *) src)[i];
       
    for (j = 0; j < n % sizeof(unsigned long); j++)
        ((unsigned char *) (((unsigned long *) dst) + i))[j] =
            ((unsigned char *) (((unsigned long *) src) + i))[j];
       
    return (char *) dst;
}
 
void *memmove(void *dst, const void *src, size_t n)
{
    int i, j;
   
    if (src > dst)
        return memcpy(dst, src, n);
 
    for (j = (n % sizeof(unsigned long)) - 1; j >= 0; j--)
        ((unsigned char *) ((unsigned long *) dst))[j] =
            ((unsigned char *) ((unsigned long *) src))[j];
 
    for (i = n / sizeof(unsigned long) - 1; i >=0 ; i--)
        ((unsigned long *) dst)[i] = ((unsigned long *) src)[i];
       
    return (char *) dst;
}
 
/** Compare two memory areas.
 *
 * @param s1        Pointer to the first area to compare.
 * @param s2        Pointer to the second area to compare.
 * @param len       Size of the first area in bytes. Both areas must have
 *          the same length.
 * @return      If len is 0, return zero. If the areas match, return
 *          zero. Otherwise return non-zero.
 */
int bcmp(const char *s1, const char *s2, size_t len)
{
    for (; len && *s1++ == *s2++; len--)
        ;
    return len;
}
 
/** Count the number of characters in the string, not including terminating 0.
 *
 * @param str       String.
 * @return      Number of characters in string.
 */
size_t strlen(const char *str)
{
    size_t counter = 0;
 
    while (str[counter] != 0)
        counter++;
 
    return counter;
}
 
int strcmp(const char *a, const char *b)
{
    int c = 0;
   
    while (a[c] && b[c] && (!(a[c] - b[c])))
        c++;
   
    return (a[c] - b[c]);
}
 
int strncmp(const char *a, const char *b, size_t n)
{
    size_t c = 0;
 
    while (c < n && a[c] && b[c] && (!(a[c] - b[c])))
        c++;
   
    return ( c < n ? a[c] - b[c] : 0);
   
}
 
int stricmp(const char *a, const char *b)
{
    int c = 0;
   
    while (a[c] && b[c] && (!(tolower(a[c]) - tolower(b[c]))))
        c++;
   
    return (tolower(a[c]) - tolower(b[c]));
}
 
/** Return pointer to the first occurence of character c in string.
 *
 * @param str       Scanned string.
 * @param c     Searched character (taken as one byte).
 * @return      Pointer to the matched character or NULL if it is not
 *          found in given string.
 */
char *strchr(const char *str, int c)
{
    while (*str != '\0') {
        if (*str == (char) c)
            return (char *) str;
        str++;
    }
 
    return NULL;
}
 
/** Return pointer to the last occurence of character c in string.
 *
 * @param str       Scanned string.
 * @param c     Searched character (taken as one byte).
 * @return      Pointer to the matched character or NULL if it is not
 *          found in given string.
 */
char *strrchr(const char *str, int c)
{
    char *retval = NULL;
 
    while (*str != '\0') {
        if (*str == (char) c)
            retval = (char *) str;
        str++;
    }
 
    return (char *) retval;
}
 
/** Convert string to a number.
 * Core of strtol and strtoul functions.
 *
 * @param nptr      Pointer to string.
 * @param endptr    If not NULL, function stores here pointer to the first
 *          invalid character.
 * @param base      Zero or number between 2 and 36 inclusive.
 * @param sgn       It's set to 1 if minus found.
 * @return      Result of conversion.
 */
static unsigned long
_strtoul(const char *nptr, char **endptr, int base, char *sgn)
{
    unsigned char c;
    unsigned long result = 0;
    unsigned long a, b;
    const char *str = nptr;
    const char *tmpptr;
   
    while (isspace(*str))
        str++;
   
    if (*str == '-') {
        *sgn = 1;
        ++str;
    } else if (*str == '+')
        ++str;
   
    if (base) {
        if ((base == 1) || (base > 36)) {
            /* FIXME: set errno to EINVAL */
            return 0;
        }
        if ((base == 16) && (*str == '0') && ((str[1] == 'x') ||
            (str[1] == 'X'))) {
            str += 2;
        }
    } else {
        base = 10;
       
        if (*str == '0') {
            base = 8;
            if ((str[1] == 'X') || (str[1] == 'x'))  {
                base = 16;
                str += 2;
            }
        }
    }
   
    tmpptr = str;
 
    while (*str) {
        c = *str;
        c = (c >= 'a' ? c - 'a' + 10 : (c >= 'A' ? c - 'A' + 10 :
            (c <= '9' ? c - '0' : 0xff)));
        if (c > base) {
            break;
        }
       
        a = (result & 0xff) * base + c;
        b = (result >> 8) * base + (a >> 8);
       
        if (b > (ULONG_MAX >> 8)) {
            /* overflow */
            /* FIXME: errno = ERANGE*/
            return ULONG_MAX;
        }
   
        result = (b << 8) + (a & 0xff);
        ++str;
    }
   
    if (str == tmpptr) {
        /*
         * No number was found => first invalid character is the first
         * character of the string.
         */
        /* FIXME: set errno to EINVAL */
        str = nptr;
        result = 0;
    }
   
    if (endptr)
        *endptr = (char *) str;
 
    if (nptr == str) {
        /*FIXME: errno = EINVAL*/
        return 0;
    }
 
    return result;
}
 
/** Convert initial part of string to long int according to given base.
 * The number may begin with an arbitrary number of whitespaces followed by
 * optional sign (`+' or `-'). If the base is 0 or 16, the prefix `0x' may be
 * inserted and the number will be taken as hexadecimal one. If the base is 0
 * and the number begin with a zero, number will be taken as octal one (as with
 * base 8). Otherwise the base 0 is taken as decimal.
 *
 * @param nptr      Pointer to string.
 * @param endptr    If not NULL, function stores here pointer to the first
 *          invalid character.
 * @param base      Zero or number between 2 and 36 inclusive.
 * @return      Result of conversion.
 */
long int strtol(const char *nptr, char **endptr, int base)
{
    char sgn = 0;
    unsigned long number = 0;
   
    number = _strtoul(nptr, endptr, base, &sgn);
 
    if (number > LONG_MAX) {
        if ((sgn) && (number == (unsigned long) (LONG_MAX) + 1)) {
            /* FIXME: set 0 to errno */
            return number;     
        }
        /* FIXME: set ERANGE to errno */
        return (sgn ? LONG_MIN : LONG_MAX);
    }
   
    return (sgn ? -number : number);
}
 
 
/** Convert initial part of string to unsigned long according to given base.
 * The number may begin with an arbitrary number of whitespaces followed by
 * optional sign (`+' or `-'). If the base is 0 or 16, the prefix `0x' may be
 * inserted and the number will be taken as hexadecimal one. If the base is 0
 * and the number begin with a zero, number will be taken as octal one (as with
 * base 8). Otherwise the base 0 is taken as decimal.
 *
 * @param nptr      Pointer to string.
 * @param endptr    If not NULL, function stores here pointer to the first
 *          invalid character
 * @param base      Zero or number between 2 and 36 inclusive.
 * @return      Result of conversion.
 */
unsigned long strtoul(const char *nptr, char **endptr, int base)
{
    char sgn = 0;
    unsigned long number = 0;
   
    number = _strtoul(nptr, endptr, base, &sgn);
 
    return (sgn ? -number : number);
}
 
char *strcpy(char *dest, const char *src)
{
    char *orig = dest;
   
    while ((*(dest++) = *(src++)))
        ;
    return orig;
}
 
char *strncpy(char *dest, const char *src, size_t n)
{
    char *orig = dest;
   
    while ((*(dest++) = *(src++)) && --n)
        ;
    return orig;
}
 
char *strcat(char *dest, const char *src)
{
    char *orig = dest;
    while (*dest++)
        ;
    --dest;
    while ((*dest++ = *src++))
        ;
    return orig;
}
 
char * strdup(const char *s1)
{
    size_t len = strlen(s1) + 1;
    void *ret = malloc(len);
 
    if (ret == NULL)
        return (char *) NULL;
 
    return (char *) memcpy(ret, s1, len);
}
 
/* Ported from FBSD strtok.c 8.1 (Berkeley) 6/4/93 */
char * strtok_r(char *s, const char *delim, char **last)
{
    char *spanp, *tok;
    int c, sc;
 
    if (s == NULL && (s = *last) == NULL)
        return (NULL);
 
cont:
    c = *s++;
    for (spanp = (char *)delim; (sc = *spanp++) != 0;) {
        if (c == sc)
            goto cont;
    }
 
    if (c == 0) {       /* no non-delimiter characters */
        *last = NULL;
        return (NULL);
    }
 
    tok = s - 1;
 
    for (;;) {
        c = *s++;
        spanp = (char *)delim;
        do {
            if ((sc = *spanp++) == c) {
                if (c == 0)
                    s = NULL;
                else
                    s[-1] = '\0';
                *last = s;
                return (tok);
            }
        } while (sc != 0);
    }
}
 
/* Ported from FBSD strtok.c 8.1 (Berkeley) 6/4/93 */
char * strtok(char *s, const char *delim)
{
    static char *last;
 
    return (strtok_r(s, delim, &last));
}
 
/** @}
 */
 

Rev 3427	Rev 3478
1	/*	1	/*
2	* Copyright (c) 2005 Martin Decky	2	* Copyright (c) 2005 Martin Decky
3	* Copyright (C) 1998 by Wes Peters <wes@softweyr.com>	3	* Copyright (C) 1998 by Wes Peters <wes@softweyr.com>
4	* Copyright (c) 1988, 1993 The Regents of the University of California.	4	* Copyright (c) 1988, 1993 The Regents of the University of California.
5	* All rights reserved.	5	* All rights reserved.
6	*	6	*
7	* Redistribution and use in source and binary forms, with or without	7	* Redistribution and use in source and binary forms, with or without
8	* modification, are permitted provided that the following conditions	8	* modification, are permitted provided that the following conditions
9	* are met:	9	* are met:
10	*	10	*
11	* - Redistributions of source code must retain the above copyright	11	* - Redistributions of source code must retain the above copyright
12	* notice, this list of conditions and the following disclaimer.	12	* notice, this list of conditions and the following disclaimer.
13	* - Redistributions in binary form must reproduce the above copyright	13	* - Redistributions in binary form must reproduce the above copyright
14	* notice, this list of conditions and the following disclaimer in the	14	* notice, this list of conditions and the following disclaimer in the
15	* documentation and/or other materials provided with the distribution.	15	* documentation and/or other materials provided with the distribution.
16	* - The name of the author may not be used to endorse or promote products	16	* - The name of the author may not be used to endorse or promote products
17	* derived from this software without specific prior written permission.	17	* derived from this software without specific prior written permission.
18	*	18	*
19	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	19	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
20	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	20	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
21	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	21	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
22	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	22	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
23	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	23	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
24	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	24	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	25	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	26	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	27	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
28	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	28	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29	*/	29	*/
30		30
31	/** @addtogroup libc	31	/** @addtogroup libc
32	* @{	32	* @{
33	*/	33	*/
34	/** @file	34	/** @file
35	*/	35	*/
36		36
37	#include <string.h>	37	#include <string.h>
38	#include <unistd.h>	38	#include <unistd.h>
39	#include <ctype.h>	39	#include <ctype.h>
40	#include <limits.h>	40	#include <limits.h>
41	#include <align.h>	41	#include <align.h>
42	#include <sys/types.h>	42	#include <sys/types.h>
43	#include <malloc.h>	43	#include <malloc.h>
44		44
45	/* Dummy implementation of mem/ functions */	45	/* Dummy implementation of mem/ functions */
46		46
47	void memset(void s, int c, size_t n)	47	void memset(void s, int c, size_t n)
48	{	48	{
49	char *os = s;	49	char *os = s;
50		50
51	while (n--)	51	while (n--)
52	*(os++) = c;	52	*(os++) = c;
53		53
54	return s;	54	return s;
55	}	55	}
56		56
57	struct along {	57	struct along {
58	unsigned long n;	58	unsigned long n;
59	} __attribute__ ((packed));	59	} __attribute__ ((packed));
60		60
61	static void unaligned_memcpy(void dst, const void *src, size_t n)	61	static void unaligned_memcpy(void dst, const void *src, size_t n)
62	{	62	{
63	int i, j;	63	int i, j;
64	struct along *adst = dst;	64	struct along *adst = dst;
65	const struct along *asrc = src;	65	const struct along *asrc = src;
66		66
67	for (i = 0; i < n / sizeof(unsigned long); i++)	67	for (i = 0; i < n / sizeof(unsigned long); i++)
68	adst[i].n = asrc[i].n;	68	adst[i].n = asrc[i].n;
69		69
70	for (j = 0; j < n % sizeof(unsigned long); j++)	70	for (j = 0; j < n % sizeof(unsigned long); j++)
71	((unsigned char ) (((unsigned long ) dst) + i))[j] =	71	((unsigned char ) (((unsigned long ) dst) + i))[j] =
72	((unsigned char ) (((unsigned long ) src) + i))[j];	72	((unsigned char ) (((unsigned long ) src) + i))[j];
73		73
74	return (char *) dst;	74	return (char *) dst;
75	}	75	}
76		76
77	void memcpy(void dst, const void *src, size_t n)	77	void memcpy(void dst, const void *src, size_t n)
78	{	78	{
79	int i, j;	79	int i, j;
80		80
81	if (((long) dst & (sizeof(long) - 1)) \|\|	81	if (((long) dst & (sizeof(long) - 1)) \|\|
82	((long) src & (sizeof(long) - 1)))	82	((long) src & (sizeof(long) - 1)))
83	return unaligned_memcpy(dst, src, n);	83	return unaligned_memcpy(dst, src, n);
84		84
85	for (i = 0; i < n / sizeof(unsigned long); i++)	85	for (i = 0; i < n / sizeof(unsigned long); i++)
86	((unsigned long ) dst)[i] = ((unsigned long ) src)[i];	86	((unsigned long ) dst)[i] = ((unsigned long ) src)[i];
87		87
88	for (j = 0; j < n % sizeof(unsigned long); j++)	88	for (j = 0; j < n % sizeof(unsigned long); j++)
89	((unsigned char ) (((unsigned long ) dst) + i))[j] =	89	((unsigned char ) (((unsigned long ) dst) + i))[j] =
90	((unsigned char ) (((unsigned long ) src) + i))[j];	90	((unsigned char ) (((unsigned long ) src) + i))[j];
91		91
92	return (char *) dst;	92	return (char *) dst;
93	}	93	}
94		94
95	void memmove(void dst, const void *src, size_t n)	95	void memmove(void dst, const void *src, size_t n)
96	{	96	{
97	int i, j;	97	int i, j;
98		98
99	if (src > dst)	99	if (src > dst)
100	return memcpy(dst, src, n);	100	return memcpy(dst, src, n);
101		101
102	for (j = (n % sizeof(unsigned long)) - 1; j >= 0; j--)	102	for (j = (n % sizeof(unsigned long)) - 1; j >= 0; j--)
103	((unsigned char ) ((unsigned long ) dst))[j] =	103	((unsigned char ) ((unsigned long ) dst))[j] =
104	((unsigned char ) ((unsigned long ) src))[j];	104	((unsigned char ) ((unsigned long ) src))[j];
105		105
106	for (i = n / sizeof(unsigned long) - 1; i >=0 ; i--)	106	for (i = n / sizeof(unsigned long) - 1; i >=0 ; i--)
107	((unsigned long ) dst)[i] = ((unsigned long ) src)[i];	107	((unsigned long ) dst)[i] = ((unsigned long ) src)[i];
108		108
109	return (char *) dst;	109	return (char *) dst;
110	}	110	}
111		111
112	/** Compare two memory areas.	112	/** Compare two memory areas.
113	*	113	*
114	* @param s1 Pointer to the first area to compare.	114	* @param s1 Pointer to the first area to compare.
115	* @param s2 Pointer to the second area to compare.	115	* @param s2 Pointer to the second area to compare.
116	* @param len Size of the first area in bytes. Both areas must have	116	* @param len Size of the first area in bytes. Both areas must have
117	* the same length.	117	* the same length.
118	* @return If len is 0, return zero. If the areas match, return	118	* @return If len is 0, return zero. If the areas match, return
119	* zero. Otherwise return non-zero.	119	* zero. Otherwise return non-zero.
120	*/	120	*/
121	int bcmp(const char s1, const char s2, size_t len)	121	int bcmp(const char s1, const char s2, size_t len)
122	{	122	{
123	for (; len && s1++ == s2++; len--)	123	for (; len && s1++ == s2++; len--)
124	;	124	;
125	return len;	125	return len;
126	}	126	}
127		127
128	/** Count the number of characters in the string, not including terminating 0.	128	/** Count the number of characters in the string, not including terminating 0.
129	*	129	*
130	* @param str String.	130	* @param str String.
131	* @return Number of characters in string.	131	* @return Number of characters in string.
132	*/	132	*/
133	size_t strlen(const char *str)	133	size_t strlen(const char *str)
134	{	134	{
135	size_t counter = 0;	135	size_t counter = 0;
136		136
137	while (str[counter] != 0)	137	while (str[counter] != 0)
138	counter++;	138	counter++;
139		139
140	return counter;	140	return counter;
141	}	141	}
142		142
143	int strcmp(const char a, const char b)	143	int strcmp(const char a, const char b)
144	{	144	{
145	int c = 0;	145	int c = 0;
146		146
147	while (a[c] && b[c] && (!(a[c] - b[c])))	147	while (a[c] && b[c] && (!(a[c] - b[c])))
148	c++;	148	c++;
149		149
150	return (a[c] - b[c]);	150	return (a[c] - b[c]);
151	}	151	}
152		152
153	int strncmp(const char a, const char b, size_t n)	153	int strncmp(const char a, const char b, size_t n)
154	{	154	{
155	size_t c = 0;	155	size_t c = 0;
156		156
157	while (c < n && a[c] && b[c] && (!(a[c] - b[c])))	157	while (c < n && a[c] && b[c] && (!(a[c] - b[c])))
158	c++;	158	c++;
159		159
160	return ( c < n ? a[c] - b[c] : 0);	160	return ( c < n ? a[c] - b[c] : 0);
161		161
162	}	162	}
163		163
164	int stricmp(const char a, const char b)	164	int stricmp(const char a, const char b)
165	{	165	{
166	int c = 0;	166	int c = 0;
167		167
168	while (a[c] && b[c] && (!(tolower(a[c]) - tolower(b[c]))))	168	while (a[c] && b[c] && (!(tolower(a[c]) - tolower(b[c]))))
169	c++;	169	c++;
170		170
171	return (tolower(a[c]) - tolower(b[c]));	171	return (tolower(a[c]) - tolower(b[c]));
172	}	172	}
173		173
174	/** Return pointer to the first occurence of character c in string.	174	/** Return pointer to the first occurence of character c in string.
175	*	175	*
176	* @param str Scanned string.	176	* @param str Scanned string.
177	* @param c Searched character (taken as one byte).	177	* @param c Searched character (taken as one byte).
178	* @return Pointer to the matched character or NULL if it is not	178	* @return Pointer to the matched character or NULL if it is not
179	* found in given string.	179	* found in given string.
180	*/	180	*/
181	char strchr(const char str, int c)	181	char strchr(const char str, int c)
182	{	182	{
183	while (*str != '\0') {	183	while (*str != '\0') {
184	if (*str == (char) c)	184	if (*str == (char) c)
185	return (char *) str;	185	return (char *) str;
186	str++;	186	str++;
187	}	187	}
188		188
189	return NULL;	189	return NULL;
190	}	190	}
191		191
192	/** Return pointer to the last occurence of character c in string.	192	/** Return pointer to the last occurence of character c in string.
193	*	193	*
194	* @param str Scanned string.	194	* @param str Scanned string.
195	* @param c Searched character (taken as one byte).	195	* @param c Searched character (taken as one byte).
196	* @return Pointer to the matched character or NULL if it is not	196	* @return Pointer to the matched character or NULL if it is not
197	* found in given string.	197	* found in given string.
198	*/	198	*/
199	char strrchr(const char str, int c)	199	char strrchr(const char str, int c)
200	{	200	{
201	char *retval = NULL;	201	char *retval = NULL;
202		202
203	while (*str != '\0') {	203	while (*str != '\0') {
204	if (*str == (char) c)	204	if (*str == (char) c)
205	retval = (char *) str;	205	retval = (char *) str;
206	str++;	206	str++;
207	}	207	}
208		208
209	return (char *) retval;	209	return (char *) retval;
210	}	210	}
211		211
212	/** Convert string to a number.	212	/** Convert string to a number.
213	* Core of strtol and strtoul functions.	213	* Core of strtol and strtoul functions.
214	*	214	*
215	* @param nptr Pointer to string.	215	* @param nptr Pointer to string.
216	* @param endptr If not NULL, function stores here pointer to the first	216	* @param endptr If not NULL, function stores here pointer to the first
217	* invalid character.	217	* invalid character.
218	* @param base Zero or number between 2 and 36 inclusive.	218	* @param base Zero or number between 2 and 36 inclusive.
219	* @param sgn It's set to 1 if minus found.	219	* @param sgn It's set to 1 if minus found.
220	* @return Result of conversion.	220	* @return Result of conversion.
221	*/	221	*/
222	static unsigned long	222	static unsigned long
223	_strtoul(const char nptr, char endptr, int base, char sgn)	223	_strtoul(const char nptr, char endptr, int base, char sgn)
224	{	224	{
225	unsigned char c;	225	unsigned char c;
226	unsigned long result = 0;	226	unsigned long result = 0;
227	unsigned long a, b;	227	unsigned long a, b;
228	const char *str = nptr;	228	const char *str = nptr;
229	const char *tmpptr;	229	const char *tmpptr;
230		230
231	while (isspace(*str))	231	while (isspace(*str))
232	str++;	232	str++;
233		233
234	if (*str == '-') {	234	if (*str == '-') {
235	*sgn = 1;	235	*sgn = 1;
236	++str;	236	++str;
237	} else if (*str == '+')	237	} else if (*str == '+')
238	++str;	238	++str;
239		239
240	if (base) {	240	if (base) {
241	if ((base == 1) \|\| (base > 36)) {	241	if ((base == 1) \|\| (base > 36)) {
242	/* FIXME: set errno to EINVAL */	242	/* FIXME: set errno to EINVAL */
243	return 0;	243	return 0;
244	}	244	}
245	if ((base == 16) && (*str == '0') && ((str[1] == 'x') \|\|	245	if ((base == 16) && (*str == '0') && ((str[1] == 'x') \|\|
246	(str[1] == 'X'))) {	246	(str[1] == 'X'))) {
247	str += 2;	247	str += 2;
248	}	248	}
249	} else {	249	} else {
250	base = 10;	250	base = 10;
251		251
252	if (*str == '0') {	252	if (*str == '0') {
253	base = 8;	253	base = 8;
254	if ((str[1] == 'X') \|\| (str[1] == 'x')) {	254	if ((str[1] == 'X') \|\| (str[1] == 'x')) {
255	base = 16;	255	base = 16;
256	str += 2;	256	str += 2;
257	}	257	}
258	}	258	}
259	}	259	}
260		260
261	tmpptr = str;	261	tmpptr = str;
262		262
263	while (*str) {	263	while (*str) {
264	c = *str;	264	c = *str;
265	c = (c >= 'a' ? c - 'a' + 10 : (c >= 'A' ? c - 'A' + 10 :	265	c = (c >= 'a' ? c - 'a' + 10 : (c >= 'A' ? c - 'A' + 10 :
266	(c <= '9' ? c - '0' : 0xff)));	266	(c <= '9' ? c - '0' : 0xff)));
267	if (c > base) {	267	if (c > base) {
268	break;	268	break;
269	}	269	}
270		270
271	a = (result & 0xff) * base + c;	271	a = (result & 0xff) * base + c;
272	b = (result >> 8) * base + (a >> 8);	272	b = (result >> 8) * base + (a >> 8);
273		273
274	if (b > (ULONG_MAX >> 8)) {	274	if (b > (ULONG_MAX >> 8)) {
275	/* overflow */	275	/* overflow */
276	/* FIXME: errno = ERANGE*/	276	/* FIXME: errno = ERANGE*/
277	return ULONG_MAX;	277	return ULONG_MAX;
278	}	278	}
279		279
280	result = (b << 8) + (a & 0xff);	280	result = (b << 8) + (a & 0xff);
281	++str;	281	++str;
282	}	282	}
283		283
284	if (str == tmpptr) {	284	if (str == tmpptr) {
285	/*	285	/*
286	* No number was found => first invalid character is the first	286	* No number was found => first invalid character is the first
287	* character of the string.	287	* character of the string.
288	*/	288	*/
289	/* FIXME: set errno to EINVAL */	289	/* FIXME: set errno to EINVAL */
290	str = nptr;	290	str = nptr;
291	result = 0;	291	result = 0;
292	}	292	}
293		293
294	if (endptr)	294	if (endptr)
295	endptr = (char ) str;	295	endptr = (char ) str;
296		296
297	if (nptr == str) {	297	if (nptr == str) {
298	/FIXME: errno = EINVAL/	298	/FIXME: errno = EINVAL/
299	return 0;	299	return 0;
300	}	300	}
301		301
302	return result;	302	return result;
303	}	303	}
304		304
305	/** Convert initial part of string to long int according to given base.	305	/** Convert initial part of string to long int according to given base.
306	* The number may begin with an arbitrary number of whitespaces followed by	306	* The number may begin with an arbitrary number of whitespaces followed by
307	* optional sign (`+' or `-'). If the base is 0 or 16, the prefix `0x' may be	307	* optional sign (`+' or `-'). If the base is 0 or 16, the prefix `0x' may be
308	* inserted and the number will be taken as hexadecimal one. If the base is 0	308	* inserted and the number will be taken as hexadecimal one. If the base is 0
309	* and the number begin with a zero, number will be taken as octal one (as with	309	* and the number begin with a zero, number will be taken as octal one (as with
310	* base 8). Otherwise the base 0 is taken as decimal.	310	* base 8). Otherwise the base 0 is taken as decimal.
311	*	311	*
312	* @param nptr Pointer to string.	312	* @param nptr Pointer to string.
313	* @param endptr If not NULL, function stores here pointer to the first	313	* @param endptr If not NULL, function stores here pointer to the first
314	* invalid character.	314	* invalid character.
315	* @param base Zero or number between 2 and 36 inclusive.	315	* @param base Zero or number between 2 and 36 inclusive.
316	* @return Result of conversion.	316	* @return Result of conversion.
317	*/	317	*/
318	long int strtol(const char nptr, char *endptr, int base)	318	long int strtol(const char nptr, char *endptr, int base)
319	{	319	{
320	char sgn = 0;	320	char sgn = 0;
321	unsigned long number = 0;	321	unsigned long number = 0;
322		322
323	number = _strtoul(nptr, endptr, base, &sgn);	323	number = _strtoul(nptr, endptr, base, &sgn);
324		324
325	if (number > LONG_MAX) {	325	if (number > LONG_MAX) {
326	if ((sgn) && (number == (unsigned long) (LONG_MAX) + 1)) {	326	if ((sgn) && (number == (unsigned long) (LONG_MAX) + 1)) {
327	/* FIXME: set 0 to errno */	327	/* FIXME: set 0 to errno */
328	return number;	328	return number;
329	}	329	}
330	/* FIXME: set ERANGE to errno */	330	/* FIXME: set ERANGE to errno */
331	return (sgn ? LONG_MIN : LONG_MAX);	331	return (sgn ? LONG_MIN : LONG_MAX);
332	}	332	}
333		333
334	return (sgn ? -number : number);	334	return (sgn ? -number : number);
335	}	335	}
336		336
337		337
338	/** Convert initial part of string to unsigned long according to given base.	338	/** Convert initial part of string to unsigned long according to given base.
339	* The number may begin with an arbitrary number of whitespaces followed by	339	* The number may begin with an arbitrary number of whitespaces followed by
340	* optional sign (`+' or `-'). If the base is 0 or 16, the prefix `0x' may be	340	* optional sign (`+' or `-'). If the base is 0 or 16, the prefix `0x' may be
341	* inserted and the number will be taken as hexadecimal one. If the base is 0	341	* inserted and the number will be taken as hexadecimal one. If the base is 0
342	* and the number begin with a zero, number will be taken as octal one (as with	342	* and the number begin with a zero, number will be taken as octal one (as with
343	* base 8). Otherwise the base 0 is taken as decimal.	343	* base 8). Otherwise the base 0 is taken as decimal.
344	*	344	*
345	* @param nptr Pointer to string.	345	* @param nptr Pointer to string.
346	* @param endptr If not NULL, function stores here pointer to the first	346	* @param endptr If not NULL, function stores here pointer to the first
347	* invalid character	347	* invalid character
348	* @param base Zero or number between 2 and 36 inclusive.	348	* @param base Zero or number between 2 and 36 inclusive.
349	* @return Result of conversion.	349	* @return Result of conversion.
350	*/	350	*/
351	unsigned long strtoul(const char nptr, char *endptr, int base)	351	unsigned long strtoul(const char nptr, char *endptr, int base)
352	{	352	{
353	char sgn = 0;	353	char sgn = 0;
354	unsigned long number = 0;	354	unsigned long number = 0;
355		355
356	number = _strtoul(nptr, endptr, base, &sgn);	356	number = _strtoul(nptr, endptr, base, &sgn);
357		357
358	return (sgn ? -number : number);	358	return (sgn ? -number : number);
359	}	359	}
360		360
361	char strcpy(char dest, const char *src)	361	char strcpy(char dest, const char *src)
362	{	362	{
363	char *orig = dest;	363	char *orig = dest;
364		364
365	while (((dest++) = (src++)))	365	while (((dest++) = (src++)))
366	;	366	;
367	return orig;	367	return orig;
368	}	368	}
369		369
370	char strncpy(char dest, const char *src, size_t n)	370	char strncpy(char dest, const char *src, size_t n)
371	{	371	{
372	char *orig = dest;	372	char *orig = dest;
373		373
374	while (((dest++) = (src++)) && --n)	374	while (((dest++) = (src++)) && --n)
375	;	375	;
376	return orig;	376	return orig;
377	}	377	}
378		378
379	char strcat(char dest, const char *src)	379	char strcat(char dest, const char *src)
380	{	380	{
381	char *orig = dest;	381	char *orig = dest;
382	while (*dest++)	382	while (*dest++)
383	;	383	;
384	--dest;	384	--dest;
385	while ((dest++ = src++))	385	while ((dest++ = src++))
386	;	386	;
387	return orig;	387	return orig;
388	}	388	}
389		389
390	char * strdup(const char *s1)	390	char * strdup(const char *s1)
391	{	391	{
392	size_t len = strlen(s1) + 1;	392	size_t len = strlen(s1) + 1;
393	void *ret = malloc(len);	393	void *ret = malloc(len);
394		394
395	if (ret == NULL)	395	if (ret == NULL)
396	return (char *) NULL;	396	return (char *) NULL;
397		397
398	return (char *) memcpy(ret, s1, len);	398	return (char *) memcpy(ret, s1, len);
399	}	399	}
400		400
401	/* Ported from FBSD strtok.c 8.1 (Berkeley) 6/4/93 */	401	/* Ported from FBSD strtok.c 8.1 (Berkeley) 6/4/93 */
402	char * strtok_r(char s, const char delim, char **last)	402	char * strtok_r(char s, const char delim, char **last)
403	{	403	{
404	char spanp, tok;	404	char spanp, tok;
405	int c, sc;	405	int c, sc;
406		406
407	if (s == NULL && (s = *last) == NULL)	407	if (s == NULL && (s = *last) == NULL)
408	return (NULL);	408	return (NULL);
409		409
410	cont:	410	cont:
411	c = *s++;	411	c = *s++;
412	for (spanp = (char )delim; (sc = spanp++) != 0;) {	412	for (spanp = (char )delim; (sc = spanp++) != 0;) {
413	if (c == sc)	413	if (c == sc)
414	goto cont;	414	goto cont;
415	}	415	}
416		416
417	if (c == 0) { /* no non-delimiter characters */	417	if (c == 0) { /* no non-delimiter characters */
418	*last = NULL;	418	*last = NULL;
419	return (NULL);	419	return (NULL);
420	}	420	}
421		421
422	tok = s - 1;	422	tok = s - 1;
423		423
424	for (;;) {	424	for (;;) {
425	c = *s++;	425	c = *s++;
426	spanp = (char *)delim;	426	spanp = (char *)delim;
427	do {	427	do {
428	if ((sc = *spanp++) == c) {	428	if ((sc = *spanp++) == c) {
429	if (c == 0)	429	if (c == 0)
430	s = NULL;	430	s = NULL;
431	else	431	else
432	s[-1] = '\0';	432	s[-1] = '\0';
433	*last = s;	433	*last = s;
434	return (tok);	434	return (tok);
435	}	435	}
436	} while (sc != 0);	436	} while (sc != 0);
437	}	437	}
438	}	438	}
439		439
440	/* Ported from FBSD strtok.c 8.1 (Berkeley) 6/4/93 */	440	/* Ported from FBSD strtok.c 8.1 (Berkeley) 6/4/93 */
441	char * strtok(char s, const char delim)	441	char * strtok(char s, const char delim)
442	{	442	{
443	static char *last;	443	static char *last;
444		444
445	return (strtok_r(s, delim, &last));	445	return (strtok_r(s, delim, &last));
446	}	446	}
447		447
448	/** @}	448	/** @}
449	*/	449	*/
450		450

Subversion Repositories HelenOS

(root)/branches/arm/uspace/lib/libc/generic/string.c – Rev 3427 → 3478