armsrc/string.c

   1 //-----------------------------------------------------------------------------
   2 // Jonathan Westhues, Sept 2005
   3 //
   4 // This code is licensed to you under the terms of the GNU GPL, version 2 or,
   5 // at your option, any later version. See the LICENSE.txt file for the text of
   6 // the license.
   7 //-----------------------------------------------------------------------------
   8 // Common string.h functions
   9 //-----------------------------------------------------------------------------
  10 #include "string.h"
  11
  12 void *memcpy(void *dest, const void *src, int len) {
  13     uint8_t *d = dest;
  14     const uint8_t *s = src;
  15     while ((len--) > 0) {
  16         *d = *s;
  17         d++;
  18         s++;
  19     }
  20     return dest;
  21 }
  22
  23 void *memmove(void *dest, const void *src, size_t len) {
  24     char *d = dest;
  25     const char *s = src;
  26     if (d < s)
  27         while (len--)
  28             *d++ = *s++;
  29     else {
  30         char *lasts = (char *)s + (len - 1);
  31         char *lastd = d + (len - 1);
  32         while (len--)
  33             *lastd-- = *lasts--;
  34     }
  35     return dest;
  36 }
  37
  38 void *memset(void *dest, uint8_t c, int len) {
  39     uint8_t *d = dest;
  40     while ((len--) > 0) {
  41         *d = c;
  42         d++;
  43     }
  44     return dest;
  45 }
  46
  47 int memcmp(const void *av, const void *bv, int len) {
  48     const uint8_t *a = av;
  49     const uint8_t *b = bv;
  50
  51     while ((len--) > 0) {
  52         if (*a != *b) {
  53             return *a - *b;
  54         }
  55         a++;
  56         b++;
  57     }
  58     return 0;
  59 }
  60
  61 void memxor(uint8_t *dest, uint8_t *src, size_t len) {
  62     for (; len > 0; len--, dest++, src++)
  63         *dest ^= *src;
  64 }
  65
  66 int strlen(const char *str) {
  67     const char *p;
  68     for (p = str; *p != '\0'; ++p) {};
  69     return p - str;
  70 }
  71
  72 char *strncat(char *dest, const char *src, unsigned int n) {
  73     int dest_len = strlen(dest);
  74     unsigned int i;
  75
  76     for (i = 0 ; i < n && src[i] != '\0' ; i++)
  77         dest[dest_len + i] = src[i];
  78
  79     dest[dest_len + i] = '\0';
  80
  81     return dest;
  82 }
  83
  84 char *strcat(char *dest, const char *src) {
  85     int dest_len = strlen(dest);
  86     unsigned int i;
  87
  88     for (i = 0 ; src[i] != '\0' ; i++)
  89         dest[dest_len + i] = src[i];
  90     dest[dest_len + i] = '\0';
  91
  92     return dest;
  93 }
  94 ////////////////////////////////////////// code to do 'itoa'
  95
  96 /* reverse:  reverse string s in place */
  97 void strreverse(char s[]) {
  98     int j = strlen(s) - 1;
  99
 100     for (int i = 0; i < j; i++, j--) {
 101         char c = s[i];
 102         s[i] = s[j];
 103         s[j] = c;
 104     }
 105 }
 106
 107 /* itoa:  convert n to characters in s */
 108 void itoa(int n, char s[]) {
 109     int sign;
 110     if ((sign = n) < 0)  /* record sign */
 111         n = -n;          /* make n positive */
 112
 113     int i = 0;
 114     do {       /* generate digits in reverse order */
 115         s[i++] = n % 10 + '0';   /* get next digit */
 116     } while ((n /= 10) > 0);     /* delete it */
 117     if (sign < 0)
 118         s[i++] = '-';
 119     s[i] = '\0';
 120     strreverse(s);
 121 }
 122
 123 //////////////////////////////////////// END 'itoa' CODE
 124
 125
 126
 127 char *strcpy(char *dst, const char *src) {
 128     char *save = dst;
 129
 130     for (; (*dst = *src) != '\0'; ++src, ++dst);
 131     return save;
 132 }
 133
 134 char *strncpy(char *dst, const char *src, size_t n) {
 135     if (n != 0) {
 136         char *d = dst;
 137         const char *s = src;
 138
 139         do {
 140             if ((*d++ = *s++) == 0) {
 141                 /* NUL pad the remaining n-1 bytes */
 142                 while (--n) {
 143                     *d++ = 0;
 144                 }
 145                 break;
 146             }
 147         } while (--n);
 148     }
 149     return dst;
 150 }
 151
 152 int strcmp(const char *s1, const char *s2) {
 153     while (*s1 == *s2++) {
 154         if (*s1++ == 0) {
 155             return (0);
 156         }
 157     }
 158     return (*(unsigned char *) s1 - * (unsigned char *) --s2);
 159 }
 160
 161 char *__strtok_r(char *, const char *, char **);
 162
 163 char *__strtok_r(char *s, const char *delim, char **last) {
 164     char *spanp, *tok;
 165     int c, sc;
 166
 167     if (s == NULL && (s = *last) == NULL)
 168         return (NULL);
 169
 170     /*
 171      * Skip (span) leading delimiters (s += strspn(s, delim), sort of).
 172      */
 173 cont:
 174     c = *s++;
 175     for (spanp = (char *)delim; (sc = *spanp++) != 0;) {
 176         if (c == sc)
 177             goto cont;
 178     }
 179
 180     if (c == 0) {
 181         /* no non-delimiter characters */
 182         *last = NULL;
 183         return (NULL);
 184     }
 185     tok = s - 1;
 186
 187     /*
 188      * Scan token (scan for delimiters: s += strcspn(s, delim), sort of).
 189      * Note that delim must have one NUL; we stop if we see that, too.
 190      */
 191     for (;;) {
 192         c = *s++;
 193         spanp = (char *)delim;
 194         do {
 195             if ((sc = *spanp++) == c) {
 196                 if (c == 0)
 197                     s = NULL;
 198                 else
 199                     s[-1] = '\0';
 200                 *last = s;
 201                 return (tok);
 202             }
 203         } while (sc != 0);
 204     }
 205     /* NOTREACHED */
 206 }
 207
 208 char *strtok(char *s, const char *delim) {
 209     static char *last;
 210
 211     return (__strtok_r(s, delim, &last));
 212 }
 213
 214
 215 char *strchr(const char *s, int c) {
 216     while (*s != (char)c)
 217         if (!*s++)
 218             return 0;
 219     return (char *)s;
 220 }
 221
 222 size_t strspn(const char *s1, const char *s2) {
 223     size_t ret = 0;
 224     while (*s1 && strchr(s2, *s1++))
 225         ret++;
 226     return ret;
 227 }
 228
 229 char *strrchr(const char *s, int c) {
 230     const char *ret = 0;
 231     do {
 232         if (*s == (char)c)
 233             ret = s;
 234     } while (*s++);
 235     return (char *)ret;
 236 }
 237
 238 size_t strcspn(const char *s1, const char *s2) {
 239     size_t ret = 0;
 240     while (*s1)
 241         if (strchr(s2, *s1))
 242             return ret;
 243         else
 244             s1++, ret++;
 245     return ret;
 246 }
 247
 248 char *strpbrk(const char *s1, const char *s2) {
 249     while (*s1)
 250         if (strchr(s2, *s1++))
 251             return (char *)--s1;
 252     return 0;
 253 }
 254
 255 int strncmp(const char *s1, const char *s2, size_t n) {
 256     while (n--)
 257         if (*s1++ != *s2++)
 258             return *(unsigned char *)(s1 - 1) - *(unsigned char *)(s2 - 1);
 259     return 0;
 260 }
 261
 262
 263
 264
 265 #define isspace(a) __extension__ ({ unsigned char bb__isspace = (a) - 9; bb__isspace == (' ' - 9) || bb__isspace <= (13 - 9); })
 266
 267 unsigned long strtoul(const char *p, char **out_p, int base) {
 268     unsigned long v = 0;
 269
 270     while (isspace(*p))
 271         p++;
 272     if (((base == 16) || (base == 0)) &&
 273             ((*p == '0') && ((p[1] == 'x') || (p[1] == 'X')))) {
 274         p += 2;
 275         base = 16;
 276     }
 277     if (base == 0) {
 278         if (*p == '0')
 279             base = 8;
 280         else
 281             base = 10;
 282     }
 283     while (1) {
 284         char c = *p;
 285         if ((c >= '0') && (c <= '9') && (c - '0' < base))
 286             v = (v * base) + (c - '0');
 287         else if ((c >= 'a') && (c <= 'z') && (c - 'a' + 10 < base))
 288             v = (v * base) + (c - 'a' + 10);
 289         else if ((c >= 'A') && (c <= 'Z') && (c - 'A' + 10 < base))
 290             v = (v * base) + (c - 'A' + 10);
 291         else
 292             break;
 293         p++;
 294     }
 295
 296     if (out_p) *out_p = (char *)p;
 297     return v;
 298 }
 299
 300 long strtol(const char *p, char **out_p, int base) {
 301     long v = 0;
 302     int is_neg = 0;
 303
 304     while (isspace(*p))
 305         p++;
 306     if (*p == '-')
 307         is_neg = 1, p++;
 308     else if (*p == '+')
 309         is_neg = 0;
 310     if (((base == 16) || (base == 0)) &&
 311             ((*p == '0') && ((p[1] == 'x') || (p[1] == 'X')))) {
 312         p += 2;
 313         base = 16;
 314     }
 315     if (base == 0) {
 316         if (*p == '0')
 317             base = 8;
 318         else
 319             base = 10;
 320     }
 321     while (1) {
 322         char c = *p;
 323         if ((c >= '0') && (c <= '9') && (c - '0' < base))
 324             v = (v * base) + (c - '0');
 325         else if ((c >= 'a') && (c <= 'z') && (c - 'a' + 10 < base))
 326             v = (v * base) + (c - 'a' + 10);
 327         else if ((c >= 'A') && (c <= 'Z') && (c - 'A' + 10 < base))
 328             v = (v * base) + (c - 'A' + 10);
 329         else
 330             break;
 331         p++;
 332     }
 333     if (is_neg)
 334         v = -v;
 335     if (out_p) *out_p = (char *)p;
 336     return v;
 337 }
 338
 339 char c_tolower(int c) {
 340     // (int)a = 97, (int)A = 65
 341     // (a)97 - (A)65 = 32
 342     // therefore 32 + 65 = a
 343     return c > 64 && c < 91 ? c + 32 : c;
 344 }
 345
 346 char c_isprint(unsigned char c) {
 347     if (c >= 0x20 && c <= 0x7e)
 348         return 1;
 349     return 0;
 350 }