Subversion Repositories HelenOS

Rev

Rev 2072 | Details | Compare with Previous | Last modification | View Log | RSS feed

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