WebSVN – HelenOS – Diff – /tags/0.3.0/uspace/lib/libc/generic/string.c


/*
 * Copyright (c) 2005 Martin Decky
 * 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>
 
 
/* 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 *) src;
}
 
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 *) src;
}
 
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 *) src;
}
 
/** 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);
   
}
 
/** 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 its 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;
}
 
/** @}
 */
 

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

Subversion Repositories HelenOS

(root)/tags/0.3.0/uspace/lib/libc/generic/string.c – Rev 2754 → 2782