src/lib/string.c

   1 /* SPDX-License-Identifier: GPL-2.0-only */
   2
   3 #include <assert.h>
   4 #include <ctype.h>
   5 #include <string.h>
   6 #include <stddef.h>
   7 #include <stdlib.h>
   8
   9 char *strdup(const char *s)
  10 {
  11         if (!ENV_RAMSTAGE)
  12                 dead_code();    /* This can't be used without malloc(). */
  13
  14         size_t sz = strlen(s) + 1;
  15         char *d = malloc(sz);
  16         if (d)
  17                 memcpy(d, s, sz);
  18         return d;
  19 }
  20
  21 char *strconcat(const char *s1, const char *s2)
  22 {
  23         if (!ENV_RAMSTAGE)
  24                 dead_code();    /* This can't be used without malloc(). */
  25
  26         size_t sz_1 = strlen(s1);
  27         size_t sz_2 = strlen(s2);
  28         char *d = malloc(sz_1 + sz_2 + 1);
  29         if (d) {
  30                 memcpy(d, s1, sz_1);
  31                 memcpy(d + sz_1, s2, sz_2 + 1);
  32         }
  33         return d;
  34 }
  35
  36 size_t strnlen(const char *src, size_t max)
  37 {
  38         size_t i = 0;
  39         while ((*src++) && (i < max))
  40                 i++;
  41         return i;
  42 }
  43
  44 size_t strlen(const char *src)
  45 {
  46         size_t i = 0;
  47         while (*src++)
  48                 i++;
  49         return i;
  50 }
  51
  52 char *strchr(const char *s, int c)
  53 {
  54         do {
  55                 if (*s == c)
  56                         return (char *)s;
  57         } while (*s++);
  58
  59         return NULL;
  60 }
  61
  62 char *strrchr(const char *s, int c)
  63 {
  64         char *p = NULL;
  65
  66         do {
  67                 if (*s == c)
  68                         p = (char *)s;
  69         } while (*s++);
  70
  71         return p;
  72 }
  73
  74 char *strncpy(char *to, const char *from, size_t count)
  75 {
  76         char *ret = to;
  77         char data;
  78
  79         while (count > 0) {
  80                 count--;
  81                 data = *from++;
  82                 *to++  = data;
  83                 if (data == '\0')
  84                         break;
  85         }
  86
  87         while (count > 0) {
  88                 count--;
  89                 *to++ = '\0';
  90         }
  91         return ret;
  92 }
  93
  94 char *strcpy(char *dst, const char *src)
  95 {
  96         char *ptr = dst;
  97
  98         while (*src)
  99                 *dst++ = *src++;
 100         *dst = '\0';
 101
 102         return ptr;
 103 }
 104
 105 int strcmp(const char *s1, const char *s2)
 106 {
 107         int r;
 108
 109         while ((r = (*s1 - *s2)) == 0 && *s1) {
 110                 s1++;
 111                 s2++;
 112         }
 113         return r;
 114 }
 115
 116 int strncmp(const char *s1, const char *s2, size_t maxlen)
 117 {
 118         size_t i;
 119
 120         for (i = 0; i < maxlen; i++) {
 121                 if ((s1[i] != s2[i]) || (s1[i] == '\0'))
 122                         return s1[i] - s2[i];
 123         }
 124
 125         return 0;
 126 }
 127
 128 size_t strspn(const char *str, const char *spn)
 129 {
 130         size_t ret = 0;
 131
 132         while (*str != 0) {
 133                 const char *p;
 134                 for (p = spn; *str != *p; p++)
 135                         if (*p == '\0')
 136                                 return ret;
 137                 ret++;
 138                 str++;
 139         }
 140         return ret;
 141 }
 142
 143 size_t strcspn(const char *str, const char *spn)
 144 {
 145         size_t ret = 0;
 146
 147         while (*str != 0) {
 148                 const char *p;
 149                 for (p = spn; *p != '\0'; p++)
 150                         if (*p == *str)
 151                                 return ret;
 152                 ret++;
 153                 str++;
 154         }
 155         return ret;
 156 }
 157
 158 char *strstr(const char *haystack, const char *needle)
 159 {
 160         size_t needle_len = strlen(needle);
 161         for (; *haystack; haystack++) {
 162                 if (!strncmp(haystack, needle, needle_len))
 163                         return (char *)haystack;
 164         }
 165         return NULL;
 166 }
 167
 168 char *strtok_r(char *str, const char *delim, char **ptr)
 169 {
 170         char *start;
 171         char *end;
 172
 173         if (str == NULL)
 174                 str = *ptr;
 175         start = str + strspn(str, delim);
 176         if (start[0] == '\0')
 177                 return NULL;
 178
 179         end = start + strcspn(start, delim);
 180         *ptr = end;
 181         if (end[0] != '\0')
 182                 *(*ptr)++ = '\0';
 183         return start;
 184 }
 185
 186 char *strtok(char *str, const char *delim)
 187 {
 188         static char *strtok_ptr;
 189
 190         return strtok_r(str, delim, &strtok_ptr);
 191 }
 192
 193 long atol(const char *str)
 194 {
 195         long ret = 0;
 196         long sign = 1;
 197
 198         str += strspn(str, " \t\n\r\f\v");
 199
 200         if (*str == '+') {
 201                 sign = 1;
 202                 str++;
 203         } else if (*str == '-') {
 204                 sign = -1;
 205                 str++;
 206         }
 207
 208         while (isdigit(*str)) {
 209                 ret *= 10;
 210                 ret += *str++ - '0';
 211         }
 212         return ret * sign;
 213 }