WebSVN – HelenOS – Diff – /trunk/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>
#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);
}
 
/** @}
 */
 

Rev 3271	Rev 3274
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	#include <malloc.h>	41	#include <malloc.h>
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] =	69	((unsigned char ) (((unsigned long ) dst) + i))[j] =
70	((unsigned char ) (((unsigned long ) src) + i))[j];	70	((unsigned char ) (((unsigned long ) src) + i))[j];
71		71
72	return (char *) src;	72	return (char *) dst;
73	}	73	}
74		74
75	void memcpy(void dst, const void *src, size_t n)	75	void memcpy(void dst, const void *src, size_t n)
76	{	76	{
77	int i, j;	77	int i, j;
78		78
79	if (((long) dst & (sizeof(long) - 1)) \|\|	79	if (((long) dst & (sizeof(long) - 1)) \|\|
80	((long) src & (sizeof(long) - 1)))	80	((long) src & (sizeof(long) - 1)))
81	return unaligned_memcpy(dst, src, n);	81	return unaligned_memcpy(dst, src, n);
82		82
83	for (i = 0; i < n / sizeof(unsigned long); i++)	83	for (i = 0; i < n / sizeof(unsigned long); i++)
84	((unsigned long ) dst)[i] = ((unsigned long ) src)[i];	84	((unsigned long ) dst)[i] = ((unsigned long ) src)[i];
85		85
86	for (j = 0; j < n % sizeof(unsigned long); j++)	86	for (j = 0; j < n % sizeof(unsigned long); j++)
87	((unsigned char ) (((unsigned long ) dst) + i))[j] =	87	((unsigned char ) (((unsigned long ) dst) + i))[j] =
88	((unsigned char ) (((unsigned long ) src) + i))[j];	88	((unsigned char ) (((unsigned long ) src) + i))[j];
89		89
90	return (char *) src;	90	return (char *) dst;
91	}	91	}
92		92
93	void memmove(void dst, const void *src, size_t n)	93	void memmove(void dst, const void *src, size_t n)
94	{	94	{
95	int i, j;	95	int i, j;
96		96
97	if (src > dst)	97	if (src > dst)
98	return memcpy(dst, src, n);	98	return memcpy(dst, src, n);
99		99
100	for (j = (n % sizeof(unsigned long)) - 1; j >= 0; j--)	100	for (j = (n % sizeof(unsigned long)) - 1; j >= 0; j--)
101	((unsigned char ) ((unsigned long ) dst))[j] =	101	((unsigned char ) ((unsigned long ) dst))[j] =
102	((unsigned char ) ((unsigned long ) src))[j];	102	((unsigned char ) ((unsigned long ) src))[j];
103		103
104	for (i = n / sizeof(unsigned long) - 1; i >=0 ; i--)	104	for (i = n / sizeof(unsigned long) - 1; i >=0 ; i--)
105	((unsigned long ) dst)[i] = ((unsigned long ) src)[i];	105	((unsigned long ) dst)[i] = ((unsigned long ) src)[i];
106		106
107	return (char *) src;	107	return (char *) dst;
108	}	108	}
109		109
110	/** Compare two memory areas.	110	/** Compare two memory areas.
111	*	111	*
112	* @param s1 Pointer to the first area to compare.	112	* @param s1 Pointer to the first area to compare.
113	* @param s2 Pointer to the second area to compare.	113	* @param s2 Pointer to the second area to compare.
114	* @param len Size of the first area in bytes. Both areas must have	114	* @param len Size of the first area in bytes. Both areas must have
115	* the same length.	115	* the same length.
116	* @return If len is 0, return zero. If the areas match, return	116	* @return If len is 0, return zero. If the areas match, return
117	* zero. Otherwise return non-zero.	117	* zero. Otherwise return non-zero.
118	*/	118	*/
119	int bcmp(const char s1, const char s2, size_t len)	119	int bcmp(const char s1, const char s2, size_t len)
120	{	120	{
121	for (; len && s1++ == s2++; len--)	121	for (; len && s1++ == s2++; len--)
122	;	122	;
123	return len;	123	return len;
124	}	124	}
125		125
126	/** Count the number of characters in the string, not including terminating 0.	126	/** Count the number of characters in the string, not including terminating 0.
127	*	127	*
128	* @param str String.	128	* @param str String.
129	* @return Number of characters in string.	129	* @return Number of characters in string.
130	*/	130	*/
131	size_t strlen(const char *str)	131	size_t strlen(const char *str)
132	{	132	{
133	size_t counter = 0;	133	size_t counter = 0;
134		134
135	while (str[counter] != 0)	135	while (str[counter] != 0)
136	counter++;	136	counter++;
137		137
138	return counter;	138	return counter;
139	}	139	}
140		140
141	int strcmp(const char a, const char b)	141	int strcmp(const char a, const char b)
142	{	142	{
143	int c = 0;	143	int c = 0;
144		144
145	while (a[c] && b[c] && (!(a[c] - b[c])))	145	while (a[c] && b[c] && (!(a[c] - b[c])))
146	c++;	146	c++;
147		147
148	return (a[c] - b[c]);	148	return (a[c] - b[c]);
149	}	149	}
150		150
151	int strncmp(const char a, const char b, size_t n)	151	int strncmp(const char a, const char b, size_t n)
152	{	152	{
153	size_t c = 0;	153	size_t c = 0;
154		154
155	while (c < n && a[c] && b[c] && (!(a[c] - b[c])))	155	while (c < n && a[c] && b[c] && (!(a[c] - b[c])))
156	c++;	156	c++;
157		157
158	return ( c < n ? a[c] - b[c] : 0);	158	return ( c < n ? a[c] - b[c] : 0);
159		159
160	}	160	}
161		161
162	int stricmp(const char a, const char b)	162	int stricmp(const char a, const char b)
163	{	163	{
164	int c = 0;	164	int c = 0;
165		165
166	while (a[c] && b[c] && (!(tolower(a[c]) - tolower(b[c]))))	166	while (a[c] && b[c] && (!(tolower(a[c]) - tolower(b[c]))))
167	c++;	167	c++;
168		168
169	return (tolower(a[c]) - tolower(b[c]));	169	return (tolower(a[c]) - tolower(b[c]));
170	}	170	}
171		171
172	/** Return pointer to the first occurence of character c in string.	172	/** Return pointer to the first occurence of character c in string.
173	*	173	*
174	* @param str Scanned string.	174	* @param str Scanned string.
175	* @param c Searched character (taken as one byte).	175	* @param c Searched character (taken as one byte).
176	* @return Pointer to the matched character or NULL if it is not	176	* @return Pointer to the matched character or NULL if it is not
177	* found in given string.	177	* found in given string.
178	*/	178	*/
179	char strchr(const char str, int c)	179	char strchr(const char str, int c)
180	{	180	{
181	while (*str != '\0') {	181	while (*str != '\0') {
182	if (*str == (char) c)	182	if (*str == (char) c)
183	return (char *) str;	183	return (char *) str;
184	str++;	184	str++;
185	}	185	}
186		186
187	return NULL;	187	return NULL;
188	}	188	}
189		189
190	/** Return pointer to the last occurence of character c in string.	190	/** Return pointer to the last occurence of character c in string.
191	*	191	*
192	* @param str Scanned string.	192	* @param str Scanned string.
193	* @param c Searched character (taken as one byte).	193	* @param c Searched character (taken as one byte).
194	* @return Pointer to the matched character or NULL if it is not	194	* @return Pointer to the matched character or NULL if it is not
195	* found in given string.	195	* found in given string.
196	*/	196	*/
197	char strrchr(const char str, int c)	197	char strrchr(const char str, int c)
198	{	198	{
199	char *retval = NULL;	199	char *retval = NULL;
200		200
201	while (*str != '\0') {	201	while (*str != '\0') {
202	if (*str == (char) c)	202	if (*str == (char) c)
203	retval = (char *) str;	203	retval = (char *) str;
204	str++;	204	str++;
205	}	205	}
206		206
207	return (char *) retval;	207	return (char *) retval;
208	}	208	}
209		209
210	/** Convert string to a number.	210	/** Convert string to a number.
211	* Core of strtol and strtoul functions.	211	* Core of strtol and strtoul functions.
212	*	212	*
213	* @param nptr Pointer to string.	213	* @param nptr Pointer to string.
214	* @param endptr If not NULL, function stores here pointer to the first	214	* @param endptr If not NULL, function stores here pointer to the first
215	* invalid character.	215	* invalid character.
216	* @param base Zero or number between 2 and 36 inclusive.	216	* @param base Zero or number between 2 and 36 inclusive.
217	* @param sgn It's set to 1 if minus found.	217	* @param sgn It's set to 1 if minus found.
218	* @return Result of conversion.	218	* @return Result of conversion.
219	*/	219	*/
220	static unsigned long	220	static unsigned long
221	_strtoul(const char nptr, char endptr, int base, char sgn)	221	_strtoul(const char nptr, char endptr, int base, char sgn)
222	{	222	{
223	unsigned char c;	223	unsigned char c;
224	unsigned long result = 0;	224	unsigned long result = 0;
225	unsigned long a, b;	225	unsigned long a, b;
226	const char *str = nptr;	226	const char *str = nptr;
227	const char *tmpptr;	227	const char *tmpptr;
228		228
229	while (isspace(*str))	229	while (isspace(*str))
230	str++;	230	str++;
231		231
232	if (*str == '-') {	232	if (*str == '-') {
233	*sgn = 1;	233	*sgn = 1;
234	++str;	234	++str;
235	} else if (*str == '+')	235	} else if (*str == '+')
236	++str;	236	++str;
237		237
238	if (base) {	238	if (base) {
239	if ((base == 1) \|\| (base > 36)) {	239	if ((base == 1) \|\| (base > 36)) {
240	/* FIXME: set errno to EINVAL */	240	/* FIXME: set errno to EINVAL */
241	return 0;	241	return 0;
242	}	242	}
243	if ((base == 16) && (*str == '0') && ((str[1] == 'x') \|\|	243	if ((base == 16) && (*str == '0') && ((str[1] == 'x') \|\|
244	(str[1] == 'X'))) {	244	(str[1] == 'X'))) {
245	str += 2;	245	str += 2;
246	}	246	}
247	} else {	247	} else {
248	base = 10;	248	base = 10;
249		249
250	if (*str == '0') {	250	if (*str == '0') {
251	base = 8;	251	base = 8;
252	if ((str[1] == 'X') \|\| (str[1] == 'x')) {	252	if ((str[1] == 'X') \|\| (str[1] == 'x')) {
253	base = 16;	253	base = 16;
254	str += 2;	254	str += 2;
255	}	255	}
256	}	256	}
257	}	257	}
258		258
259	tmpptr = str;	259	tmpptr = str;
260		260
261	while (*str) {	261	while (*str) {
262	c = *str;	262	c = *str;
263	c = (c >= 'a' ? c - 'a' + 10 : (c >= 'A' ? c - 'A' + 10 :	263	c = (c >= 'a' ? c - 'a' + 10 : (c >= 'A' ? c - 'A' + 10 :
264	(c <= '9' ? c - '0' : 0xff)));	264	(c <= '9' ? c - '0' : 0xff)));
265	if (c > base) {	265	if (c > base) {
266	break;	266	break;
267	}	267	}
268		268
269	a = (result & 0xff) * base + c;	269	a = (result & 0xff) * base + c;
270	b = (result >> 8) * base + (a >> 8);	270	b = (result >> 8) * base + (a >> 8);
271		271
272	if (b > (ULONG_MAX >> 8)) {	272	if (b > (ULONG_MAX >> 8)) {
273	/* overflow */	273	/* overflow */
274	/* FIXME: errno = ERANGE*/	274	/* FIXME: errno = ERANGE*/
275	return ULONG_MAX;	275	return ULONG_MAX;
276	}	276	}
277		277
278	result = (b << 8) + (a & 0xff);	278	result = (b << 8) + (a & 0xff);
279	++str;	279	++str;
280	}	280	}
281		281
282	if (str == tmpptr) {	282	if (str == tmpptr) {
283	/*	283	/*
284	* No number was found => first invalid character is the first	284	* No number was found => first invalid character is the first
285	* character of the string.	285	* character of the string.
286	*/	286	*/
287	/* FIXME: set errno to EINVAL */	287	/* FIXME: set errno to EINVAL */
288	str = nptr;	288	str = nptr;
289	result = 0;	289	result = 0;
290	}	290	}
291		291
292	if (endptr)	292	if (endptr)
293	endptr = (char ) str;	293	endptr = (char ) str;
294		294
295	if (nptr == str) {	295	if (nptr == str) {
296	/FIXME: errno = EINVAL/	296	/FIXME: errno = EINVAL/
297	return 0;	297	return 0;
298	}	298	}
299		299
300	return result;	300	return result;
301	}	301	}
302		302
303	/** Convert initial part of string to long int according to given base.	303	/** Convert initial part of string to long int according to given base.
304	* The number may begin with an arbitrary number of whitespaces followed by	304	* The number may begin with an arbitrary number of whitespaces followed by
305	* optional sign (`+' or `-'). If the base is 0 or 16, the prefix `0x' may be	305	* optional sign (`+' or `-'). If the base is 0 or 16, the prefix `0x' may be
306	* inserted and the number will be taken as hexadecimal one. If the base is 0	306	* inserted and the number will be taken as hexadecimal one. If the base is 0
307	* and the number begin with a zero, number will be taken as octal one (as with	307	* and the number begin with a zero, number will be taken as octal one (as with
308	* base 8). Otherwise the base 0 is taken as decimal.	308	* base 8). Otherwise the base 0 is taken as decimal.
309	*	309	*
310	* @param nptr Pointer to string.	310	* @param nptr Pointer to string.
311	* @param endptr If not NULL, function stores here pointer to the first	311	* @param endptr If not NULL, function stores here pointer to the first
312	* invalid character.	312	* invalid character.
313	* @param base Zero or number between 2 and 36 inclusive.	313	* @param base Zero or number between 2 and 36 inclusive.
314	* @return Result of conversion.	314	* @return Result of conversion.
315	*/	315	*/
316	long int strtol(const char nptr, char *endptr, int base)	316	long int strtol(const char nptr, char *endptr, int base)
317	{	317	{
318	char sgn = 0;	318	char sgn = 0;
319	unsigned long number = 0;	319	unsigned long number = 0;
320		320
321	number = _strtoul(nptr, endptr, base, &sgn);	321	number = _strtoul(nptr, endptr, base, &sgn);
322		322
323	if (number > LONG_MAX) {	323	if (number > LONG_MAX) {
324	if ((sgn) && (number == (unsigned long) (LONG_MAX) + 1)) {	324	if ((sgn) && (number == (unsigned long) (LONG_MAX) + 1)) {
325	/* FIXME: set 0 to errno */	325	/* FIXME: set 0 to errno */
326	return number;	326	return number;
327	}	327	}
328	/* FIXME: set ERANGE to errno */	328	/* FIXME: set ERANGE to errno */
329	return (sgn ? LONG_MIN : LONG_MAX);	329	return (sgn ? LONG_MIN : LONG_MAX);
330	}	330	}
331		331
332	return (sgn ? -number : number);	332	return (sgn ? -number : number);
333	}	333	}
334		334
335		335
336	/** Convert initial part of string to unsigned long according to given base.	336	/** Convert initial part of string to unsigned long according to given base.
337	* The number may begin with an arbitrary number of whitespaces followed by	337	* The number may begin with an arbitrary number of whitespaces followed by
338	* optional sign (`+' or `-'). If the base is 0 or 16, the prefix `0x' may be	338	* optional sign (`+' or `-'). If the base is 0 or 16, the prefix `0x' may be
339	* inserted and the number will be taken as hexadecimal one. If the base is 0	339	* inserted and the number will be taken as hexadecimal one. If the base is 0
340	* and the number begin with a zero, number will be taken as octal one (as with	340	* and the number begin with a zero, number will be taken as octal one (as with
341	* base 8). Otherwise the base 0 is taken as decimal.	341	* base 8). Otherwise the base 0 is taken as decimal.
342	*	342	*
343	* @param nptr Pointer to string.	343	* @param nptr Pointer to string.
344	* @param endptr If not NULL, function stores here pointer to the first	344	* @param endptr If not NULL, function stores here pointer to the first
345	* invalid character	345	* invalid character
346	* @param base Zero or number between 2 and 36 inclusive.	346	* @param base Zero or number between 2 and 36 inclusive.
347	* @return Result of conversion.	347	* @return Result of conversion.
348	*/	348	*/
349	unsigned long strtoul(const char nptr, char *endptr, int base)	349	unsigned long strtoul(const char nptr, char *endptr, int base)
350	{	350	{
351	char sgn = 0;	351	char sgn = 0;
352	unsigned long number = 0;	352	unsigned long number = 0;
353		353
354	number = _strtoul(nptr, endptr, base, &sgn);	354	number = _strtoul(nptr, endptr, base, &sgn);
355		355
356	return (sgn ? -number : number);	356	return (sgn ? -number : number);
357	}	357	}
358		358
359	char strcpy(char dest, const char *src)	359	char strcpy(char dest, const char *src)
360	{	360	{
361	char *orig = dest;	361	char *orig = dest;
362		362
363	while (((dest++) = (src++)))	363	while (((dest++) = (src++)))
364	;	364	;
365	return orig;	365	return orig;
366	}	366	}
367		367
368	char strncpy(char dest, const char *src, size_t n)	368	char strncpy(char dest, const char *src, size_t n)
369	{	369	{
370	char *orig = dest;	370	char *orig = dest;
371		371
372	while (((dest++) = (src++)) && --n)	372	while (((dest++) = (src++)) && --n)
373	;	373	;
374	return orig;	374	return orig;
375	}	375	}
376		376
377	char strcat(char dest, const char *src)	377	char strcat(char dest, const char *src)
378	{	378	{
379	char *orig = dest;	379	char *orig = dest;
380	while (*dest++)	380	while (*dest++)
381	;	381	;
382	--dest;	382	--dest;
383	while ((dest++ = src++))	383	while ((dest++ = src++))
384	;	384	;
385	return orig;	385	return orig;
386	}	386	}
387		387
388	char * strdup(const char *s1)	388	char * strdup(const char *s1)
389	{	389	{
390	size_t len = strlen(s1) + 1;	390	size_t len = strlen(s1) + 1;
391	void *ret = malloc(len);	391	void *ret = malloc(len);
392		392
393	if (ret == NULL)	393	if (ret == NULL)
394	return (char *) NULL;	394	return (char *) NULL;
395		395
396	return (char *) memcpy(ret, s1, len);	396	return (char *) memcpy(ret, s1, len);
397	}	397	}
398		398
399	/** @}	399	/** @}
400	*/	400	*/
401		401

Subversion Repositories HelenOS

(root)/trunk/uspace/lib/libc/generic/string.c – Rev 3271 → 3274