shared/string.c

   1 /*
   2 Copyright (C) 2008  Mathias Gottschlag
   3
   4 Permission is hereby granted, free of charge, to any person obtaining a copy of
   5 this software and associated documentation files (the "Software"), to deal in the
   6 Software without restriction, including without limitation the rights to use,
   7 copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
   8 Software, and to permit persons to whom the Software is furnished to do so,
   9 subject to the following conditions:
  10
  11 The above copyright notice and this permission notice shall be included in all
  12 copies or substantial portions of the Software.
  13
  14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
  15 INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  16 PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  17 HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  18 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  19 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  20 */
  21
  22
  23 #include <string.h>
  24 #include <stdlib.h>
  25
  26 void *memcpy(void *dest, const void *src, size_t n)
  27 {
  28         size_t i;
  29         for (i = 0; i < n; i++)
  30         {
  31                 ((char*)dest)[i] = ((const char*)src)[i];
  32         }
  33         return dest;
  34 }
  35 void *memccpy(void *dest, const void *src, int c, size_t n)
  36 {
  37         size_t i;
  38         for (i = 0; i < n; i++)
  39         {
  40                 ((char*)dest)[i] = ((const char*)src)[i];
  41                 if (((const char*)src)[i] == c)
  42                         return &((char*)dest)[i + 1];
  43         }
  44         return NULL;
  45 }
  46 void *memmove(void *dest, const void *src, size_t n)
  47 {
  48         size_t i;
  49         if (src == dest) return dest;
  50         if (dest < src)
  51         {
  52                 for (i = 0; i < n; i++)
  53                 {
  54                         ((char*)dest)[i] = ((const char*)src)[i];
  55                 }
  56         }
  57         else
  58         {
  59                 for (i = n - 1; i <= 0; i--)
  60                 {
  61                         ((char*)dest)[i] = ((const char*)src)[i];
  62                 }
  63         }
  64         return dest;
  65 }
  66 void *memchr(const void *s, int c, size_t n)
  67 {
  68         size_t i;
  69         for (i = 0; i < n; i++)
  70         {
  71                 if (((char*)s)[i] == c) return &((char*)s)[i];
  72         }
  73         return NULL;
  74 }
  75 int memcmp(const void *s1, const void *s2, size_t n)
  76 {
  77         size_t i;
  78         for (i = 0; i < n; i++)
  79         {
  80                 if (((char*)s1)[i] != ((char*)s2)[i])
  81                 {
  82                         return ((char*)s1)[i] - ((char*)s2)[i];
  83                 }
  84         }
  85         return 0;
  86 }
  87 void *memset(void *dest, int c, size_t n)
  88 {
  89         size_t i;
  90         for (i = 0; i < n; i++)
  91         {
  92                 ((char*)dest)[i] = c;
  93         }
  94         return dest;
  95 }
  96
  97 char *strcat(char *dest, const char *src)
  98 {
  99         int destlen = strlen(dest);
 100         int srclen = strlen(dest);
 101         int i;
 102         for (i = 0; i <= srclen; i++)
 103         {
 104                 dest[destlen + i] = src[i];
 105         }
 106         return dest;
 107 }
 108 char *strchr(const char *s, int c)
 109 {
 110         while (*s)
 111         {
 112                 if (*s == c) return (char*)s;
 113                 s++;
 114         }
 115         return NULL;
 116 }
 117 int strcmp(const char *s1, const char *s2)
 118 {
 119         for ( ; *s1 == *s2; s1++, s2++)
 120                 if (*s1 == '\0')
 121                         return 0;
 122
 123         return *s1 - *s2;
 124 }
 125 /*int strcoll(const char *s1, const char *s2)
 126 {
 127         // TODO
 128         return 0;
 129 }*/
 130 char *strcpy(char *dest, const char *src)
 131 {
 132         while((*dest++ = *src++));
 133         return dest;
 134 }
 135 size_t strcspn(const char *s, const char *reject)
 136 {
 137         int count = 0;
 138         while (*s && !strchr(reject, s[count]))
 139         {
 140                 count++;
 141                 s++;
 142
 143         }
 144         return count;
 145
 146 }
 147 char *strdup(const char *s)
 148 {
 149         char *newstr = malloc(strlen(s) + 1);
 150         if (newstr) strcpy(newstr, s);
 151         return newstr;
 152 }
 153 /*char *strerror(int e)
 154 {
 155         // TODO
 156         return 0;
 157 }
 158 int *strerror_r(int e, char *s, size_t n)
 159 {
 160         // TODO
 161         return 0;
 162 }*/
 163 size_t strlen(const char *s)
 164 {
 165         const char *p = s;
 166         while( *p != '\0')
 167                 p++;
 168         return p - s;
 169 }
 170 char *strncat(char *dest, const char *src, size_t n)
 171 {
 172         size_t destlen = strlen(dest);
 173         size_t srclen = strlen(dest);
 174         if (srclen > n) srclen = n;
 175         size_t i;
 176         for (i = 0; i < srclen; i++)
 177         {
 178                 dest[destlen + i] = src[i];
 179         }
 180         dest[destlen + srclen] = 0;
 181         return dest;
 182 }
 183 int strncmp(const char *s1, const char *s2, size_t n)
 184 {
 185         size_t i;
 186         for (i = 0 ; (*s1 == *s2) && (i < n); s1++, s2++, i++)
 187                 if (*s1 == '\0')
 188                         return 0;
 189
 190         if (i == n) return 0;
 191         return *s1 - *s2;
 192 }
 193 char *strncpy(char *dest, const char *src, size_t n)
 194 {
 195         size_t i;
 196         for (i = 0; i < n; i++)
 197         {
 198                 ((char*)dest)[i] = ((const char*)src)[i];
 199                 if (((const char*)src)[i] == 0) return dest;
 200         }
 201         return dest;
 202 }
 203 char *strpbrk(const char *s, const char *accept)
 204 {
 205         int acclen = strlen(s);
 206         int i;
 207         while (*s)
 208         {
 209                 for (i = 0; i < acclen; i++)
 210                 {
 211                         if (strchr(s, accept[i]))
 212                                 return (char*)s;
 213                 }
 214                 s++;
 215         }
 216         return 0;
 217 }
 218 char *strrchr(const char *s, int c)
 219 {
 220         int len = strlen(s);
 221         int i;
 222         for (i = len; i >= 0; i--)
 223         {
 224                 if (s[i] == c) return (char*)&s[i];
 225         }
 226         return 0;
 227 }
 228 size_t strspn(const char *s, const char *accept)
 229 {
 230         int count = 0;
 231         while (strchr(accept, s[count]))
 232         {
 233                 count++;
 234                 s++;
 235         }
 236         return count;
 237 }
 238 char *strstr(const char *s1, const char *s2)
 239 {
 240         int len1 = strlen(s1);
 241         int len2 = strlen(s2);
 242         if (len2 > len1) return NULL;
 243         int i;
 244         for (i = 0; i < len1 - len2; i++)
 245         {
 246                 if (!memcmp(&s1[i], s2, len2))
 247                         return (char*)&s1[i];
 248         }
 249         return NULL;
 250 }
 251 static char *splitted = NULL;
 252 char *strtok(char *str, const char *delimiters)
 253 {
 254         if (str)
 255         {
 256                 splitted = str;
 257         }
 258         if (!splitted) return NULL;
 259
 260         size_t count = strcspn(splitted, delimiters);
 261         char *token = splitted;
 262         if (count == strlen(splitted)) splitted = NULL;
 263         else
 264         {
 265                 char *tmp = splitted;
 266                 tmp += strspn(tmp, delimiters);
 267                 splitted[count] = 0;
 268                 splitted = tmp;
 269         }
 270         return token;
 271 }
 272 //char *strtok_r(char *, const char *, char **);
 273 /*size_t strxfrm(char *dest, const char *src, size_t n)
 274 {
 275         // TODO
 276         return 0;
 277 }*/