include/string.h

   1 #ifndef _STRING_H
   2 #define _STRING_H    1
   3
   4 #include <types.h>
   5 #include <malloc.h>
   6
   7 #ifndef NULL
   8 #define NULL ((void *) 0)
   9 #endif
  10
  11 static int strcmp(const char *s1, const char *s2)
  12 {
  13         while ((*s1 == *s2) && *s1 != '\0') {
  14                 s1++;
  15                 s2++;
  16         }
  17
  18         return (*s1 - *s2);
  19 }
  20
  21 static int strncmp(const char *s1, const char *s2, int n)
  22 {
  23         while ((--n) && (*s1 == *s2) && *s1 != '\0') {
  24                 s1++;
  25                 s2++;
  26         }
  27
  28         return (*s1 - *s2);
  29 }
  30
  31
  32 static char *strcpy(char *dest, const char *src)
  33 {
  34         char *tmp = dest;
  35
  36         while ((*dest++ = *src++) != '\0')
  37                 /* nothing */;
  38         return tmp;
  39 }
  40
  41
  42 static char *strcat(char *dest, const char *src)
  43 {
  44         char *tmp = dest;
  45
  46         while (*dest)
  47                 dest++;
  48         while ((*dest++ = *src++) != '\0')
  49                 ;
  50         return tmp;
  51 }
  52
  53
  54 static size_t strlen(const char *s)
  55 {
  56         const char *sc;
  57
  58         for (sc = s; *sc; ++sc)
  59                 /* nothing */;
  60         return sc - s;
  61 }
  62
  63
  64 static char *strchr (const char *s, int c)
  65 {
  66         while (*s) {
  67                 if (*s == c)
  68                         return (char *) s;
  69                 s++;
  70         }
  71
  72         return (void *)0;
  73 }
  74
  75 static char *strrchr (char *s, int c)
  76 {
  77         char *end = s + strlen(s) - 1;
  78
  79         while (*end != c && end >= s)
  80                 end--;
  81         if (end < s)
  82                 return NULL;
  83         return end;
  84 }
  85
  86 static char *strdup(const char *str)
  87 {
  88         char *s = malloc(strlen(str) + 1);
  89         if (!s)
  90                 return s;
  91         strcpy(s, str);
  92         return s;
  93 }
  94
  95 static void *memset(void *s, int c, size_t count)
  96 {
  97         char *xs = s;
  98
  99         while (count--)
 100                 *xs++ = c;
 101         return s;
 102 }
 103
 104 static void *memset_word(void *s, unsigned short word, size_t count)
 105 {
 106         unsigned short *xs = (unsigned short *)s;
 107
 108         while (count--)
 109                 *xs++ = word;
 110         return s;
 111 }
 112
 113 static void *memcpy(void *dest, const void *src, size_t count)
 114 {
 115         char *tmp = dest;
 116         const char *s = src;
 117
 118         while (count--)
 119                 *tmp++ = *s++;
 120         return dest;
 121 }
 122
 123
 124 static void *memmove(void *dest, const void *src, size_t count)
 125 {
 126         char *tmp;
 127         const char *s;
 128
 129         if (dest <= src) {
 130                 tmp = dest;
 131                 s = src;
 132                 while (count--)
 133                         *tmp++ = *s++;
 134         } else {
 135                 tmp = dest;
 136                 tmp += count;
 137                 s = src;
 138                 s += count;
 139                 while (count--)
 140                         *--tmp = *--s;
 141         }
 142         return dest;
 143 }
 144
 145
 146 static int memcmp(const void *cs, const void *ct, size_t count)
 147 {
 148         const unsigned char *su1, *su2;
 149         int res = 0;
 150
 151         for (su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)
 152                 if ((res = *su1 - *su2) != 0)
 153                         break;
 154         return res;
 155 }
 156
 157
 158 #endif /* _STRING_H */