src/libc/src/str.c

   1 /*
   2  * <str.c>
   3  *
   4  * Open Hack'Ware BIOS: str<xxx> functions
   5  *
   6  * Copyright (c) 2004-2005 Jocelyn Mayer
   7  *
   8  *   This program is free software; you can redistribute it and/or
   9  *   modify it under the terms of the GNU General Public License V2
  10  *   as published by the Free Software Foundation
  11  *
  12  *   This program is distributed in the hope that it will be useful,
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *   GNU General Public License for more details.
  16  *
  17  *   You should have received a copy of the GNU General Public License
  18  *   along with this program; if not, write to the Free Software
  19  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 /* functions prototypes are here */
  23 #include <string.h>
  24 /* NULL is defined here */
  25 /* malloc is defined here */
  26 #include <stdlib.h>
  27 /* toupper is defined here */
  28 #include <ctype.h>
  29
  30 /* str___ functions */
  31 #if defined (__USE_strcpy__)
  32 void *strcpy (char *dest, const char *src)
  33 {
  34     char *q;
  35
  36     q = dest;
  37     for (; ; q++) {
  38         *q = *src++;
  39         if (*q == '\0')
  40             break;
  41     }
  42
  43     return dest;
  44 }
  45 #endif
  46
  47 #if defined (__USE_strncpy__)
  48 void *strncpy (char *dest, const char *src, size_t n)
  49 {
  50     char *q;
  51
  52     q = dest;
  53     for (; n != 0; n--, q++) {
  54         *q = *src++;
  55         if (*q == '\0')
  56             break;
  57     }
  58
  59     return dest;
  60 }
  61 #endif
  62
  63 #if defined (__USE_strdup__)
  64 char *strdup (const char *s)
  65 {
  66     char *dest;
  67     size_t len;
  68
  69     len = strlen(s) + 1;
  70     dest = malloc(len);
  71     if (dest != NULL)
  72         memcpy(dest, s, len);
  73
  74     return dest;
  75 }
  76 #endif
  77
  78 #if defined (__USE_strndup__)
  79 /* GNU extension */
  80 char *strndup (const char *s, size_t n)
  81 {
  82     char *dest;
  83     size_t len;
  84
  85     len = strlen(s) + 1;
  86     if (len > n)
  87         len = n;
  88     dest = malloc(len);
  89     if (dest != NULL) {
  90         memcpy(dest, s, len - 1);
  91         dest[len - 1] = '\0';
  92     }
  93
  94     return dest;
  95 }
  96 #endif
  97
  98 #if defined (__USE_stpcpy__)
  99 void *stpcpy (char *dest, const char *src)
 100 {
 101     char *q;
 102
 103     q = dest;
 104     for (; ; q++) {
 105         *q = *src++;
 106         if (*q == '\0')
 107             break;
 108     }
 109
 110     return q;
 111 }
 112 #endif
 113
 114 #if defined (__USE_stpncpy__)
 115 void *stpncpy (char *dest, const char *src, size_t n)
 116 {
 117     char *q;
 118
 119     q = dest;
 120     for (; n != 0; n--, q++) {
 121         *q = *src++;
 122         if (*q == '\0')
 123             break;
 124     }
 125
 126     return q;
 127 }
 128 #endif
 129
 130 #if defined (__USE_strcat__)
 131 char *strcat (char *dest, const char *src)
 132 {
 133     char *q;
 134
 135     for (q = dest + strlen(dest); ; q++) {
 136         *q = *src++;
 137         if (*q == '\0')
 138             break;
 139     }
 140
 141     return dest;
 142 }
 143 #endif
 144
 145 #if defined (__USE_strncat__)
 146 char *strncat (char *dest, const char *src, size_t n)
 147 {
 148     char *q;
 149
 150     for (q = dest + strlen(dest); n != 0; n--, q++) {
 151         *q = *src++;
 152         if (*q == '\0')
 153             break;
 154     }
 155
 156     return dest;
 157 }
 158 #endif
 159
 160 #if defined (__USE_strcmp__)
 161 int strcmp (const char *s1, const char *s2)
 162 {
 163     int ret;
 164
 165     for (ret = 0; ret == 0; s1++) {
 166         ret = *s1 - *s2++;
 167         if (*s1 == '\0')
 168             break;
 169     }
 170
 171     return ret;
 172 }
 173 #endif
 174
 175 #if defined (__USE_strcasecmp__)
 176 int strcasecmp (const char *s1, const char *s2)
 177 {
 178     int ret;
 179
 180     for (ret = 0; ret == 0; s1++) {
 181         ret = toupper(*s1) - toupper(*s2++);
 182         if (*s1 == '\0')
 183             break;
 184     }
 185
 186     return ret;
 187 }
 188 #endif
 189
 190 #if defined (__USE_strncmp__)
 191 int strncmp (const char *s1, const char *s2, size_t n)
 192 {
 193     int ret;
 194
 195     for (ret = 0; ret == 0 && n != 0; n--, s1++) {
 196         ret = *s1 - *s2++;
 197         if (*s1 == '\0')
 198             break;
 199     }
 200
 201     return ret;
 202 }
 203 #endif
 204
 205 #if defined (__USE_strncasecmp__)
 206 int strncasecmp (const char *s1, const char *s2, size_t n)
 207 {
 208     int ret;
 209
 210     for (ret = 0; ret == 0 && n != 0; n--, s1++) {
 211         ret = toupper(*s1) - toupper(*s2++);
 212         if (*s1 == '\0')
 213             break;
 214     }
 215
 216     return ret;
 217 }
 218 #endif
 219
 220 #if defined (__USE_strchr__)
 221 char *strchr (const char *s, int c)
 222 {
 223     const char *r;
 224
 225     for (r = NULL; *s != '\0'; s++) {
 226         if (*s == c) {
 227             r = s;
 228             break;
 229         }
 230     }
 231
 232     return (char *)r;
 233 }
 234 #endif
 235
 236 #if defined (__USE_strchrnul__)
 237 /* GNU extension */
 238 char *strchrnul (const char *s, int c)
 239 {
 240     for (; *s != '\0' && *s != c; s++)
 241         continue;
 242
 243     return (char *)s;
 244 }
 245 #endif
 246
 247 #if defined (__USE_strrchr__)
 248 char *strrchr (const char *s, int c)
 249 {
 250     const char *p, *r;
 251
 252     r = NULL;
 253     for (p = s + strlen(s); p != s; p--) {
 254         if (*p == c) {
 255             r = p;
 256             break;
 257         }
 258     }
 259
 260     return (char *)r;
 261 }
 262 #endif
 263
 264 #if defined (__USE_strstr__)
 265 char *strstr (const char *haystack, const char *needle)
 266 {
 267     const char *r;
 268     size_t hlen, nlen;
 269
 270     if (*needle == '\0')
 271         return (char *)haystack;
 272     r = NULL;
 273     hlen = strlen(haystack);
 274     nlen = strlen(needle);
 275     for (; hlen > nlen; hlen--, haystack++) {
 276         if (memcmp(haystack, needle, nlen) == 0) {
 277             r = haystack;
 278             break;
 279         }
 280     }
 281
 282     return (char *)r;
 283 }
 284 #endif
 285
 286 #if defined (__USE_strcasestr__)
 287 char *strcasestr (const char *haystack, const char *needle)
 288 {
 289     const char *p, *q, *r;
 290     size_t hlen, nlen, n;
 291
 292     if (*needle == '\0')
 293         return (char *)haystack;
 294     r = NULL;
 295     hlen = strlen(haystack);
 296     nlen = strlen(needle);
 297     for (; hlen > nlen; hlen--, haystack++) {
 298         p = haystack;
 299         q = needle;
 300         for (n = nlen; n != 0; n--) {
 301             if (toupper(*p++) != toupper(*q++))
 302                 break;
 303         }
 304         if (n == 0) {
 305             r = haystack;
 306             break;
 307         }
 308     }
 309
 310     return (char *)r;
 311 }
 312 #endif
 313
 314 #if defined (__USE_strspn__)
 315 #error "TODO"
 316 size_t strspn (const char *s, const char *accept)
 317 {
 318 }
 319 #endif
 320
 321 #if defined (__USE_strcspn__)
 322 #error "TODO"
 323 size_t strcspn (const char *s, const char *reject)
 324 {
 325 }
 326 #endif
 327
 328 #if defined (__USE_strpbrk__)
 329 #error "TODO"
 330 char *strpbrk (const char *s, const char *accept)
 331 {
 332 }
 333 #endif
 334
 335 #if defined (__USE_strtok__)
 336 #error "TODO"
 337 char *strtok (char *s, const char *delim)
 338 {
 339 }
 340 #endif
 341
 342 #if defined (__USE_strtok_r__)
 343 #error "TODO"
 344 char *strtok_r (char *s, const char *delim, char **ptrptr)
 345 {
 346 }
 347 #endif
 348
 349 #if defined (__USE_strsep__)
 350 #error "TODO"
 351 char *strsep (char **stringp, const char *delim)
 352 {
 353 }
 354 #endif
 355
 356 #if defined (__USE_basename__)
 357 char *basename (char *path)
 358 {
 359     char *sl;
 360     size_t len;
 361
 362     if (path == NULL || (len = strlen(path)) == 0)
 363         return strdup(".");
 364     sl = path + len - 1;
 365     if (*sl == '/')
 366         sl--;
 367     for (; sl != path; sl--) {
 368         if (*sl == '/')
 369             break;
 370     }
 371
 372     return strdup(sl + 1);
 373 }
 374 #endif
 375
 376 #if defined (__USE_dirname__)
 377 char *dirname (char *path)
 378 {
 379     char *sl, *ret;
 380     size_t len;
 381
 382     if (path == NULL || (len = strlen(path)) == 0) {
 383         ret = strdup(".");
 384     } else {
 385         sl = path + len - 1;
 386         if (*sl == '/')
 387             sl--;
 388         for (; sl != path; sl--) {
 389             if (*sl == '/')
 390                 break;
 391         }
 392         len = sl - path;
 393         if (len == 0) {
 394             ret = strdup(".");
 395         } else {
 396             ret = malloc(len + 1);
 397             if (ret != NULL) {
 398                 memcpy(path, ret, len);
 399                 path[len] = '\0';
 400             }
 401         }
 402     }
 403
 404     return ret;
 405 }
 406 #endif
 407
 408 #if defined (__USE_strlen__)
 409 size_t strlen (const char *s)
 410 {
 411     size_t len;
 412
 413     for (len = 0; *s != '\0'; len++)
 414         s++;
 415
 416     return len;
 417 }
 418 #endif
 419
 420 #if defined (__USE_strnlen__)
 421 size_t strnlen (const char *s, size_t maxlen)
 422 {
 423     size_t len;
 424
 425     for (len = 0; maxlen != 0 && *s != '\0'; maxlen--, len++)
 426         s++;
 427
 428     return len;
 429 }
 430 #endif