Subversion Repositories HelenOS

Rev

Rev 4153 | Rev 4581 | Go to most recent revision | 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
4153 mejdrech 3
 * Copyright (c) 2008 Jiri Svoboda
999 palkovsky 4
 * All rights reserved.
5
 *
6
 * Redistribution and use in source and binary forms, with or without
7
 * modification, are permitted provided that the following conditions
8
 * are met:
9
 *
10
 * - Redistributions of source code must retain the above copyright
11
 *   notice, this list of conditions and the following disclaimer.
12
 * - Redistributions in binary form must reproduce the above copyright
13
 *   notice, this list of conditions and the following disclaimer in the
14
 *   documentation and/or other materials provided with the distribution.
15
 * - The name of the author may not be used to endorse or promote products
16
 *   derived from this software without specific prior written permission.
17
 *
18
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28
 */
29
 
1719 decky 30
/** @addtogroup libc
1653 cejka 31
 * @{
32
 */
33
/** @file
34
 */
35
 
999 palkovsky 36
#include <string.h>
4153 mejdrech 37
#include <stdlib.h>
38
#include <limits.h>
1314 cejka 39
#include <ctype.h>
3238 jermar 40
#include <malloc.h>
4263 mejdrech 41
#include <errno.h>
42
#include <align.h>
43
#include <string.h>
999 palkovsky 44
 
4263 mejdrech 45
/** Byte mask consisting of lowest @n bits (out of 8) */
46
#define LO_MASK_8(n)  ((uint8_t) ((1 << (n)) - 1))
47
 
48
/** Byte mask consisting of lowest @n bits (out of 32) */
49
#define LO_MASK_32(n)  ((uint32_t) ((1 << (n)) - 1))
50
 
51
/** Byte mask consisting of highest @n bits (out of 8) */
52
#define HI_MASK_8(n)  (~LO_MASK_8(8 - (n)))
53
 
54
/** Number of data bits in a UTF-8 continuation byte */
55
#define CONT_BITS  6
56
 
57
/** Decode a single character from a string.
58
 *
59
 * Decode a single character from a string of size @a size. Decoding starts
60
 * at @a offset and this offset is moved to the beginning of the next
61
 * character. In case of decoding error, offset generally advances at least
62
 * by one. However, offset is never moved beyond size.
63
 *
64
 * @param str    String (not necessarily NULL-terminated).
65
 * @param offset Byte offset in string where to start decoding.
66
 * @param size   Size of the string (in bytes).
67
 *
68
 * @return Value of decoded character, U_SPECIAL on decoding error or
69
 *         NULL if attempt to decode beyond @a size.
70
 *
71
 */
72
wchar_t str_decode(const char *str, size_t *offset, size_t size)
73
{
74
    if (*offset + 1 > size)
75
        return 0;
76
 
77
    /* First byte read from string */
78
    uint8_t b0 = (uint8_t) str[(*offset)++];
79
 
80
    /* Determine code length */
81
 
82
    unsigned int b0_bits;  /* Data bits in first byte */
83
    unsigned int cbytes;   /* Number of continuation bytes */
84
 
85
    if ((b0 & 0x80) == 0) {
86
        /* 0xxxxxxx (Plain ASCII) */
87
        b0_bits = 7;
88
        cbytes = 0;
89
    } else if ((b0 & 0xe0) == 0xc0) {
90
        /* 110xxxxx 10xxxxxx */
91
        b0_bits = 5;
92
        cbytes = 1;
93
    } else if ((b0 & 0xf0) == 0xe0) {
94
        /* 1110xxxx 10xxxxxx 10xxxxxx */
95
        b0_bits = 4;
96
        cbytes = 2;
97
    } else if ((b0 & 0xf8) == 0xf0) {
98
        /* 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */
99
        b0_bits = 3;
100
        cbytes = 3;
101
    } else {
102
        /* 10xxxxxx -- unexpected continuation byte */
103
        return U_SPECIAL;
104
    }
105
 
106
    if (*offset + cbytes > size)
107
        return U_SPECIAL;
108
 
109
    wchar_t ch = b0 & LO_MASK_8(b0_bits);
110
 
111
    /* Decode continuation bytes */
112
    while (cbytes > 0) {
113
        uint8_t b = (uint8_t) str[(*offset)++];
114
 
115
        /* Must be 10xxxxxx */
116
        if ((b & 0xc0) != 0x80)
117
            return U_SPECIAL;
118
 
119
        /* Shift data bits to ch */
120
        ch = (ch << CONT_BITS) | (wchar_t) (b & LO_MASK_8(CONT_BITS));
121
        cbytes--;
122
    }
123
 
124
    return ch;
125
}
126
 
127
/** Encode a single character to string representation.
128
 *
129
 * Encode a single character to string representation (i.e. UTF-8) and store
130
 * it into a buffer at @a offset. Encoding starts at @a offset and this offset
131
 * is moved to the position where the next character can be written to.
132
 *
133
 * @param ch     Input character.
134
 * @param str    Output buffer.
135
 * @param offset Byte offset where to start writing.
136
 * @param size   Size of the output buffer (in bytes).
137
 *
138
 * @return EOK if the character was encoded successfully, EOVERFLOW if there
139
 *     was not enough space in the output buffer or EINVAL if the character
140
 *     code was invalid.
141
 */
142
int chr_encode(const wchar_t ch, char *str, size_t *offset, size_t size)
143
{
144
    if (*offset >= size)
145
        return EOVERFLOW;
146
 
147
    if (!chr_check(ch))
148
        return EINVAL;
149
 
150
    /* Unsigned version of ch (bit operations should only be done
151
       on unsigned types). */
152
    uint32_t cc = (uint32_t) ch;
153
 
154
    /* Determine how many continuation bytes are needed */
155
 
156
    unsigned int b0_bits;  /* Data bits in first byte */
157
    unsigned int cbytes;   /* Number of continuation bytes */
158
 
159
    if ((cc & ~LO_MASK_32(7)) == 0) {
160
        b0_bits = 7;
161
        cbytes = 0;
162
    } else if ((cc & ~LO_MASK_32(11)) == 0) {
163
        b0_bits = 5;
164
        cbytes = 1;
165
    } else if ((cc & ~LO_MASK_32(16)) == 0) {
166
        b0_bits = 4;
167
        cbytes = 2;
168
    } else if ((cc & ~LO_MASK_32(21)) == 0) {
169
        b0_bits = 3;
170
        cbytes = 3;
171
    } else {
172
        /* Codes longer than 21 bits are not supported */
173
        return EINVAL;
174
    }
175
 
176
    /* Check for available space in buffer */
177
    if (*offset + cbytes >= size)
178
        return EOVERFLOW;
179
 
180
    /* Encode continuation bytes */
181
    unsigned int i;
182
    for (i = cbytes; i > 0; i--) {
183
        str[*offset + i] = 0x80 | (cc & LO_MASK_32(CONT_BITS));
184
        cc = cc >> CONT_BITS;
185
    }
186
 
187
    /* Encode first byte */
188
    str[*offset] = (cc & LO_MASK_32(b0_bits)) | HI_MASK_8(8 - b0_bits - 1);
189
 
190
    /* Advance offset */
191
    *offset += cbytes + 1;
192
 
193
    return EOK;
194
}
195
 
196
/** Get size of string.
197
 *
198
 * Get the number of bytes which are used by the string @a str (excluding the
199
 * NULL-terminator).
200
 *
201
 * @param str String to consider.
202
 *
203
 * @return Number of bytes used by the string
204
 *
205
 */
206
size_t str_size(const char *str)
207
{
208
    size_t size = 0;
209
 
210
    while (*str++ != 0)
211
        size++;
212
 
213
    return size;
214
}
215
 
216
/** Get size of wide string.
217
 *
218
 * Get the number of bytes which are used by the wide string @a str (excluding the
219
 * NULL-terminator).
220
 *
221
 * @param str Wide string to consider.
222
 *
223
 * @return Number of bytes used by the wide string
224
 *
225
 */
226
size_t wstr_size(const wchar_t *str)
227
{
228
    return (wstr_length(str) * sizeof(wchar_t));
229
}
230
 
231
/** Get size of string with length limit.
232
 *
233
 * Get the number of bytes which are used by up to @a max_len first
234
 * characters in the string @a str. If @a max_len is greater than
235
 * the length of @a str, the entire string is measured (excluding the
236
 * NULL-terminator).
237
 *
238
 * @param str     String to consider.
239
 * @param max_len Maximum number of characters to measure.
240
 *
241
 * @return Number of bytes used by the characters.
242
 *
243
 */
244
size_t str_lsize(const char *str, count_t max_len)
245
{
246
    count_t len = 0;
247
    size_t offset = 0;
248
 
249
    while (len < max_len) {
250
        if (str_decode(str, &offset, STR_NO_LIMIT) == 0)
251
            break;
252
 
253
        len++;
254
    }
255
 
256
    return offset;
257
}
258
 
259
/** Get size of wide string with length limit.
260
 *
261
 * Get the number of bytes which are used by up to @a max_len first
262
 * wide characters in the wide string @a str. If @a max_len is greater than
263
 * the length of @a str, the entire wide string is measured (excluding the
264
 * NULL-terminator).
265
 *
266
 * @param str     Wide string to consider.
267
 * @param max_len Maximum number of wide characters to measure.
268
 *
269
 * @return Number of bytes used by the wide characters.
270
 *
271
 */
272
size_t wstr_lsize(const wchar_t *str, count_t max_len)
273
{
274
    return (wstr_nlength(str, max_len * sizeof(wchar_t)) * sizeof(wchar_t));
275
}
276
 
277
/** Get number of characters in a string.
278
 *
279
 * @param str NULL-terminated string.
280
 *
281
 * @return Number of characters in string.
282
 *
283
 */
284
count_t str_length(const char *str)
285
{
286
    count_t len = 0;
287
    size_t offset = 0;
288
 
289
    while (str_decode(str, &offset, STR_NO_LIMIT) != 0)
290
        len++;
291
 
292
    return len;
293
}
294
 
295
/** Get number of characters in a wide string.
296
 *
297
 * @param str NULL-terminated wide string.
298
 *
299
 * @return Number of characters in @a str.
300
 *
301
 */
302
count_t wstr_length(const wchar_t *wstr)
303
{
304
    count_t len = 0;
305
 
306
    while (*wstr++ != 0)
307
        len++;
308
 
309
    return len;
310
}
311
 
312
/** Get number of characters in a string with size limit.
313
 *
314
 * @param str  NULL-terminated string.
315
 * @param size Maximum number of bytes to consider.
316
 *
317
 * @return Number of characters in string.
318
 *
319
 */
320
count_t str_nlength(const char *str, size_t size)
321
{
322
    count_t len = 0;
323
    size_t offset = 0;
324
 
325
    while (str_decode(str, &offset, size) != 0)
326
        len++;
327
 
328
    return len;
329
}
330
 
331
/** Get number of characters in a string with size limit.
332
 *
333
 * @param str  NULL-terminated string.
334
 * @param size Maximum number of bytes to consider.
335
 *
336
 * @return Number of characters in string.
337
 *
338
 */
339
count_t wstr_nlength(const wchar_t *str, size_t size)
340
{
341
    count_t len = 0;
342
    count_t limit = ALIGN_DOWN(size, sizeof(wchar_t));
343
    count_t offset = 0;
344
 
345
    while ((offset < limit) && (*str++ != 0)) {
346
        len++;
347
        offset += sizeof(wchar_t);
348
    }
349
 
350
    return len;
351
}
352
 
353
/** Check whether character is plain ASCII.
354
 *
355
 * @return True if character is plain ASCII.
356
 *
357
 */
358
bool ascii_check(wchar_t ch)
359
{
360
    if ((ch >= 0) && (ch <= 127))
361
        return true;
362
 
363
    return false;
364
}
365
 
366
/** Check whether character is valid
367
 *
368
 * @return True if character is a valid Unicode code point.
369
 *
370
 */
371
bool chr_check(wchar_t ch)
372
{
373
    if ((ch >= 0) && (ch <= 1114111))
374
        return true;
375
 
376
    return false;
377
}
378
 
379
/** Compare two NULL terminated strings.
380
 *
381
 * Do a char-by-char comparison of two NULL-terminated strings.
382
 * The strings are considered equal iff they consist of the same
383
 * characters on the minimum of their lengths.
384
 *
385
 * @param s1 First string to compare.
386
 * @param s2 Second string to compare.
387
 *
388
 * @return 0 if the strings are equal, -1 if first is smaller,
389
 *         1 if second smaller.
390
 *
391
 */
392
int str_cmp(const char *s1, const char *s2)
393
{
394
    wchar_t c1 = 0;
395
    wchar_t c2 = 0;
396
 
397
    size_t off1 = 0;
398
    size_t off2 = 0;
399
 
400
    while (true) {
401
        c1 = str_decode(s1, &off1, STR_NO_LIMIT);
402
        c2 = str_decode(s2, &off2, STR_NO_LIMIT);
403
 
404
        if (c1 < c2)
405
            return -1;
406
 
407
        if (c1 > c2)
408
            return 1;
409
 
410
        if (c1 == 0 || c2 == 0)
411
            break;     
412
    }
413
 
414
    return 0;
415
}
416
 
417
/** Compare two NULL terminated strings with length limit.
418
 *
419
 * Do a char-by-char comparison of two NULL-terminated strings.
420
 * The strings are considered equal iff they consist of the same
421
 * characters on the minimum of their lengths and the length limit.
422
 *
423
 * @param s1      First string to compare.
424
 * @param s2      Second string to compare.
425
 * @param max_len Maximum number of characters to consider.
426
 *
427
 * @return 0 if the strings are equal, -1 if first is smaller,
428
 *         1 if second smaller.
429
 *
430
 */
431
int str_lcmp(const char *s1, const char *s2, count_t max_len)
432
{
433
    wchar_t c1 = 0;
434
    wchar_t c2 = 0;
435
 
436
    size_t off1 = 0;
437
    size_t off2 = 0;
438
 
439
    count_t len = 0;
440
 
441
    while (true) {
442
        if (len >= max_len)
443
            break;
444
 
445
        c1 = str_decode(s1, &off1, STR_NO_LIMIT);
446
        c2 = str_decode(s2, &off2, STR_NO_LIMIT);
447
 
448
        if (c1 < c2)
449
            return -1;
450
 
451
        if (c1 > c2)
452
            return 1;
453
 
454
        if (c1 == 0 || c2 == 0)
455
            break;
456
 
457
        ++len; 
458
    }
459
 
460
    return 0;
461
 
462
}
463
 
464
/** Copy NULL-terminated string.
465
 *
466
 * Copy source string @a src to destination buffer @a dst.
467
 * No more than @a size bytes are written. NULL-terminator is always
468
 * written after the last succesfully copied character (i.e. if the
469
 * destination buffer is has at least 1 byte, it will be always
470
 * NULL-terminated).
471
 *
472
 * @param src   Source string.
473
 * @param dst   Destination buffer.
474
 * @param count Size of the destination buffer.
475
 *
476
 */
477
void str_ncpy(char *dst, const char *src, size_t size)
478
{
479
    /* No space for the NULL-terminator in the buffer */
480
    if (size == 0)
481
        return;
482
 
483
    wchar_t ch;
484
    size_t str_off = 0;
485
    size_t dst_off = 0;
486
 
487
    while ((ch = str_decode(src, &str_off, STR_NO_LIMIT)) != 0) {
488
        if (chr_encode(ch, dst, &dst_off, size) != EOK)
489
            break;
490
    }
491
 
492
    if (dst_off >= size)
493
        dst[size - 1] = 0;
494
    else
495
        dst[dst_off] = 0;
496
}
497
 
498
/** Copy NULL-terminated wide string to string
499
 *
500
 * Copy source wide string @a src to destination buffer @a dst.
501
 * No more than @a size bytes are written. NULL-terminator is always
502
 * written after the last succesfully copied character (i.e. if the
503
 * destination buffer is has at least 1 byte, it will be always
504
 * NULL-terminated).
505
 *
506
 * @param src   Source wide string.
507
 * @param dst   Destination buffer.
508
 * @param count Size of the destination buffer.
509
 *
510
 */
511
void wstr_nstr(char *dst, const wchar_t *src, size_t size)
512
{
513
    /* No space for the NULL-terminator in the buffer */
514
    if (size == 0)
515
        return;
516
 
517
    wchar_t ch;
518
    count_t src_idx = 0;
519
    size_t dst_off = 0;
520
 
521
    while ((ch = src[src_idx++]) != 0) {
522
        if (chr_encode(ch, dst, &dst_off, size) != EOK)
523
            break;
524
    }
525
 
526
    if (dst_off >= size)
527
        dst[size - 1] = 0;
528
    else
529
        dst[dst_off] = 0;
530
}
531
 
532
/** Find first occurence of character in string.
533
 *
534
 * @param str String to search.
535
 * @param ch  Character to look for.
536
 *
537
 * @return Pointer to character in @a str or NULL if not found.
538
 *
539
 */
540
const char *str_chr(const char *str, wchar_t ch)
541
{
542
    wchar_t acc;
543
    size_t off = 0;
544
 
545
    while ((acc = str_decode(str, &off, STR_NO_LIMIT)) != 0) {
546
        if (acc == ch)
547
            return (str + off);
548
    }
549
 
550
    return NULL;
551
}
552
 
553
/** Insert a wide character into a wide string.
554
 *
555
 * Insert a wide character into a wide string at position
556
 * @a pos. The characters after the position are shifted.
557
 *
558
 * @param str     String to insert to.
559
 * @param ch      Character to insert to.
560
 * @param pos     Character index where to insert.
561
 @ @param max_pos Characters in the buffer.
562
 *
563
 * @return True if the insertion was sucessful, false if the position
564
 *         is out of bounds.
565
 *
566
 */
567
bool wstr_linsert(wchar_t *str, wchar_t ch, count_t pos, count_t max_pos)
568
{
569
    count_t len = wstr_length(str);
570
 
571
    if ((pos > len) || (pos + 1 > max_pos))
572
        return false;
573
 
574
    count_t i;
575
    for (i = len; i + 1 > pos; i--)
576
        str[i + 1] = str[i];
577
 
578
    str[pos] = ch;
579
 
580
    return true;
581
}
582
 
583
/** Remove a wide character from a wide string.
584
 *
585
 * Remove a wide character from a wide string at position
586
 * @a pos. The characters after the position are shifted.
587
 *
588
 * @param str String to remove from.
589
 * @param pos Character index to remove.
590
 *
591
 * @return True if the removal was sucessful, false if the position
592
 *         is out of bounds.
593
 *
594
 */
595
bool wstr_remove(wchar_t *str, count_t pos)
596
{
597
    count_t len = wstr_length(str);
598
 
599
    if (pos >= len)
600
        return false;
601
 
602
    count_t i;
603
    for (i = pos + 1; i <= len; i++)
604
        str[i - 1] = str[i];
605
 
606
    return true;
607
}
608
 
1314 cejka 609
/** Count the number of characters in the string, not including terminating 0.
3261 jermar 610
 *
611
 * @param str       String.
612
 * @return      Number of characters in string.
1314 cejka 613
 */
1173 cejka 614
size_t strlen(const char *str)
615
{
1197 cejka 616
    size_t counter = 0;
1173 cejka 617
 
1719 decky 618
    while (str[counter] != 0)
1173 cejka 619
        counter++;
620
 
621
    return counter;
622
}
1314 cejka 623
 
1719 decky 624
int strcmp(const char *a, const char *b)
1319 vana 625
{
1719 decky 626
    int c = 0;
1319 vana 627
 
1719 decky 628
    while (a[c] && b[c] && (!(a[c] - b[c])))
629
        c++;
1319 vana 630
 
1719 decky 631
    return (a[c] - b[c]);
1319 vana 632
}
633
 
2640 cejka 634
int strncmp(const char *a, const char *b, size_t n)
635
{
636
    size_t c = 0;
1319 vana 637
 
2640 cejka 638
    while (c < n && a[c] && b[c] && (!(a[c] - b[c])))
639
        c++;
640
 
641
    return ( c < n ? a[c] - b[c] : 0);
642
 
643
}
644
 
3271 jermar 645
int stricmp(const char *a, const char *b)
646
{
647
    int c = 0;
648
 
649
    while (a[c] && b[c] && (!(tolower(a[c]) - tolower(b[c]))))
650
        c++;
651
 
652
    return (tolower(a[c]) - tolower(b[c]));
653
}
654
 
3261 jermar 655
/** Return pointer to the first occurence of character c in string.
656
 *
657
 * @param str       Scanned string.
658
 * @param c     Searched character (taken as one byte).
659
 * @return      Pointer to the matched character or NULL if it is not
660
 *          found in given string.
1314 cejka 661
 */
662
char *strchr(const char *str, int c)
663
{
664
    while (*str != '\0') {
1719 decky 665
        if (*str == (char) c)
666
            return (char *) str;
1314 cejka 667
        str++;
668
    }
669
 
670
    return NULL;
671
}
672
 
3261 jermar 673
/** Return pointer to the last occurence of character c in string.
674
 *
675
 * @param str       Scanned string.
676
 * @param c     Searched character (taken as one byte).
677
 * @return      Pointer to the matched character or NULL if it is not
678
 *          found in given string.
1314 cejka 679
 */
680
char *strrchr(const char *str, int c)
681
{
682
    char *retval = NULL;
683
 
684
    while (*str != '\0') {
1719 decky 685
        if (*str == (char) c)
686
            retval = (char *) str;
1314 cejka 687
        str++;
688
    }
689
 
1719 decky 690
    return (char *) retval;
1314 cejka 691
}
692
 
693
/** Convert string to a number.
694
 * Core of strtol and strtoul functions.
3261 jermar 695
 *
696
 * @param nptr      Pointer to string.
697
 * @param endptr    If not NULL, function stores here pointer to the first
698
 *          invalid character.
699
 * @param base      Zero or number between 2 and 36 inclusive.
700
 * @param sgn       It's set to 1 if minus found.
701
 * @return      Result of conversion.
1314 cejka 702
 */
3261 jermar 703
static unsigned long
704
_strtoul(const char *nptr, char **endptr, int base, char *sgn)
1314 cejka 705
{
706
    unsigned char c;
707
    unsigned long result = 0;
708
    unsigned long a, b;
709
    const char *str = nptr;
710
    const char *tmpptr;
711
 
712
    while (isspace(*str))
713
        str++;
714
 
715
    if (*str == '-') {
716
        *sgn = 1;
717
        ++str;
718
    } else if (*str == '+')
719
        ++str;
720
 
721
    if (base) {
722
        if ((base == 1) || (base > 36)) {
723
            /* FIXME: set errno to EINVAL */
724
            return 0;
725
        }
3261 jermar 726
        if ((base == 16) && (*str == '0') && ((str[1] == 'x') ||
727
            (str[1] == 'X'))) {
1314 cejka 728
            str += 2;
729
        }
730
    } else {
731
        base = 10;
732
 
733
        if (*str == '0') {
734
            base = 8;
735
            if ((str[1] == 'X') || (str[1] == 'x'))  {
736
                base = 16;
737
                str += 2;
738
            }
739
        }
740
    }
741
 
742
    tmpptr = str;
743
 
744
    while (*str) {
745
        c = *str;
3261 jermar 746
        c = (c >= 'a' ? c - 'a' + 10 : (c >= 'A' ? c - 'A' + 10 :
747
            (c <= '9' ? c - '0' : 0xff)));
1314 cejka 748
        if (c > base) {
749
            break;
750
        }
751
 
752
        a = (result & 0xff) * base + c;
753
        b = (result >> 8) * base + (a >> 8);
754
 
755
        if (b > (ULONG_MAX >> 8)) {
756
            /* overflow */
757
            /* FIXME: errno = ERANGE*/
758
            return ULONG_MAX;
759
        }
760
 
761
        result = (b << 8) + (a & 0xff);
762
        ++str;
763
    }
764
 
765
    if (str == tmpptr) {
3261 jermar 766
        /*
767
         * No number was found => first invalid character is the first
768
         * character of the string.
769
         */
1314 cejka 770
        /* FIXME: set errno to EINVAL */
771
        str = nptr;
772
        result = 0;
773
    }
774
 
775
    if (endptr)
1719 decky 776
        *endptr = (char *) str;
1314 cejka 777
 
778
    if (nptr == str) {
779
        /*FIXME: errno = EINVAL*/
780
        return 0;
781
    }
782
 
783
    return result;
784
}
785
 
786
/** Convert initial part of string to long int according to given base.
3261 jermar 787
 * The number may begin with an arbitrary number of whitespaces followed by
788
 * optional sign (`+' or `-'). If the base is 0 or 16, the prefix `0x' may be
789
 * inserted and the number will be taken as hexadecimal one. If the base is 0
790
 * and the number begin with a zero, number will be taken as octal one (as with
791
 * base 8). Otherwise the base 0 is taken as decimal.
792
 *
793
 * @param nptr      Pointer to string.
794
 * @param endptr    If not NULL, function stores here pointer to the first
795
 *          invalid character.
796
 * @param base      Zero or number between 2 and 36 inclusive.
797
 * @return      Result of conversion.
1314 cejka 798
 */
799
long int strtol(const char *nptr, char **endptr, int base)
800
{
801
    char sgn = 0;
802
    unsigned long number = 0;
803
 
804
    number = _strtoul(nptr, endptr, base, &sgn);
805
 
806
    if (number > LONG_MAX) {
1719 decky 807
        if ((sgn) && (number == (unsigned long) (LONG_MAX) + 1)) {
1314 cejka 808
            /* FIXME: set 0 to errno */
809
            return number;     
810
        }
811
        /* FIXME: set ERANGE to errno */
1719 decky 812
        return (sgn ? LONG_MIN : LONG_MAX);
1314 cejka 813
    }
814
 
1719 decky 815
    return (sgn ? -number : number);
1314 cejka 816
}
817
 
818
 
819
/** Convert initial part of string to unsigned long according to given base.
3261 jermar 820
 * The number may begin with an arbitrary number of whitespaces followed by
821
 * optional sign (`+' or `-'). If the base is 0 or 16, the prefix `0x' may be
822
 * inserted and the number will be taken as hexadecimal one. If the base is 0
823
 * and the number begin with a zero, number will be taken as octal one (as with
824
 * base 8). Otherwise the base 0 is taken as decimal.
825
 *
826
 * @param nptr      Pointer to string.
827
 * @param endptr    If not NULL, function stores here pointer to the first
828
 *          invalid character
829
 * @param base      Zero or number between 2 and 36 inclusive.
830
 * @return      Result of conversion.
1314 cejka 831
 */
832
unsigned long strtoul(const char *nptr, char **endptr, int base)
833
{
834
    char sgn = 0;
835
    unsigned long number = 0;
836
 
837
    number = _strtoul(nptr, endptr, base, &sgn);
838
 
1719 decky 839
    return (sgn ? -number : number);
1314 cejka 840
}
1472 palkovsky 841
 
842
char *strcpy(char *dest, const char *src)
843
{
1719 decky 844
    char *orig = dest;
845
 
2754 jermar 846
    while ((*(dest++) = *(src++)))
847
        ;
1719 decky 848
    return orig;
1472 palkovsky 849
}
850
 
851
char *strncpy(char *dest, const char *src, size_t n)
852
{
1719 decky 853
    char *orig = dest;
854
 
2754 jermar 855
    while ((*(dest++) = *(src++)) && --n)
856
        ;
1719 decky 857
    return orig;
1472 palkovsky 858
}
1653 cejka 859
 
2754 jermar 860
char *strcat(char *dest, const char *src)
861
{
862
    char *orig = dest;
863
    while (*dest++)
864
        ;
865
    --dest;
866
    while ((*dest++ = *src++))
867
        ;
868
    return orig;
869
}
870
 
3238 jermar 871
char * strdup(const char *s1)
872
{
873
    size_t len = strlen(s1) + 1;
874
    void *ret = malloc(len);
875
 
876
    if (ret == NULL)
877
        return (char *) NULL;
878
 
879
    return (char *) memcpy(ret, s1, len);
880
}
881
 
4153 mejdrech 882
char *strtok(char *s, const char *delim)
883
{
884
    static char *next;
885
 
886
    return strtok_r(s, delim, &next);
887
}
888
 
889
char *strtok_r(char *s, const char *delim, char **next)
890
{
891
    char *start, *end;
892
 
893
    if (s == NULL)
894
        s = *next;
895
 
896
    /* Skip over leading delimiters. */
897
    while (*s && (strchr(delim, *s) != NULL)) ++s;
898
    start = s;
899
 
900
    /* Skip over token characters. */
901
    while (*s && (strchr(delim, *s) == NULL)) ++s;
902
    end = s;
903
    *next = (*s ? s + 1 : s);
904
 
905
    if (start == end) {
906
        return NULL;    /* No more tokens. */
907
    }
908
 
909
    /* Overwrite delimiter with NULL terminator. */
910
    *end = '\0';
911
    return start;
912
}
913
 
1719 decky 914
/** @}
1653 cejka 915
 */