src/include/string.h

   1 #ifndef STRING_H
   2 #define STRING_H
   3
   4 #include <stddef.h>
   5 #include <stdlib.h>
   6
   7 #if !defined(__ROMCC__)
   8 #include <console/vtxprintf.h>
   9 #endif
  10
  11 /* Stringify a token */
  12 #ifndef STRINGIFY
  13 #define _STRINGIFY(x)   #x
  14 #define STRINGIFY(x)    _STRINGIFY(x)
  15 #endif
  16
  17 void *memcpy(void *dest, const void *src, size_t n);
  18 void *memmove(void *dest, const void *src, size_t n);
  19 void *memset(void *s, int c, size_t n);
  20 int memcmp(const void *s1, const void *s2, size_t n);
  21 void *memchr(const void *s, int c, size_t n);
  22 #if !defined(__ROMCC__)
  23 int snprintf(char *buf, size_t size, const char *fmt, ...);
  24 int vsnprintf(char *buf, size_t size, const char *fmt, va_list args);
  25 #endif
  26
  27 // simple string functions
  28
  29 static inline size_t strnlen(const char *src, size_t max)
  30 {
  31         size_t i = 0;
  32         while ((*src++) && (i < max))
  33                 i++;
  34         return i;
  35 }
  36
  37 static inline size_t strlen(const char *src)
  38 {
  39         size_t i = 0;
  40         while (*src++)
  41                 i++;
  42         return i;
  43 }
  44
  45 static inline char *strchr(const char *s, int c)
  46 {
  47         for (; *s; s++) {
  48                 if (*s == c)
  49                         return (char *) s;
  50         }
  51         return 0;
  52 }
  53
  54 #if !defined(__PRE_RAM__)
  55 static inline char *strdup(const char *s)
  56 {
  57         size_t sz = strlen(s) + 1;
  58         char *d = malloc(sz);
  59         memcpy(d, s, sz);
  60         return d;
  61 }
  62
  63 static inline char *strconcat(const char *s1, const char *s2)
  64 {
  65         size_t sz_1 = strlen(s1);
  66         size_t sz_2 = strlen(s2);
  67         char *d = malloc(sz_1 + sz_2 + 1);
  68         memcpy(d, s1, sz_1);
  69         memcpy(d + sz_1, s2, sz_2 + 1);
  70         return d;
  71 }
  72 #endif
  73
  74 /**
  75  * Find a character in a string.
  76  *
  77  * @param s The string.
  78  * @param c The character.
  79  * @return A pointer to the last occurrence of the character in the
  80  * string, or NULL if the character was not encountered within the string.
  81  */
  82 static inline char *strrchr(const char *s, int c)
  83 {
  84         char *p = (char *)s + strlen(s);
  85
  86         for (; p >= s; p--) {
  87                 if (*p == c)
  88                         return p;
  89         }
  90
  91         return NULL;
  92 }
  93
  94 static inline char *strncpy(char *to, const char *from, int count)
  95 {
  96         register char *ret = to;
  97         register char data;
  98
  99         while (count > 0) {
 100                 count--;
 101                 data = *from++;
 102                 *to++  = data;
 103                 if (data == '\0')
 104                         break;
 105         }
 106
 107         while (count > 0) {
 108                 count--;
 109                 *to++ = '\0';
 110         }
 111         return ret;
 112 }
 113
 114 static inline char *strcpy(char *dst, const char *src)
 115 {
 116         char *ptr = dst;
 117
 118         while (*src)
 119                 *dst++ = *src++;
 120         *dst = '\0';
 121
 122         return ptr;
 123 }
 124
 125 static inline int strcmp(const char *s1, const char *s2)
 126 {
 127         int r;
 128
 129         while ((r = (*s1 - *s2)) == 0 && *s1) {
 130                 s1++;
 131                 s2++;
 132         }
 133         return r;
 134 }
 135
 136 static inline int strncmp(const char *s1, const char *s2, int maxlen)
 137 {
 138         int i;
 139
 140         for (i = 0; i < maxlen; i++) {
 141                 if ((s1[i] != s2[i]) || (s1[i] == '\0'))
 142                         return s1[i] - s2[i];
 143         }
 144
 145         return 0;
 146 }
 147
 148 static inline int isspace(int c)
 149 {
 150         switch (c) {
 151         case ' ': case '\f': case '\n':
 152         case '\r': case '\t': case '\v':
 153                 return 1;
 154         default:
 155                 return 0;
 156         }
 157 }
 158
 159 static inline int isdigit(int c)
 160 {
 161         return (c >= '0' && c <= '9');
 162 }
 163
 164 static inline int isxdigit(int c)
 165 {
 166         return ((c >= '0' && c <= '9') ||
 167                 (c >= 'a' && c <= 'f') ||
 168                 (c >= 'A' && c <= 'F'));
 169 }
 170
 171 static inline int isupper(int c)
 172 {
 173         return (c >= 'A' && c <= 'Z');
 174 }
 175
 176 static inline int islower(int c)
 177 {
 178         return (c >= 'a' && c <= 'z');
 179 }
 180
 181 static inline int toupper(int c)
 182 {
 183         if (islower(c))
 184                 c -= 'a'-'A';
 185         return c;
 186 }
 187
 188 static inline int tolower(int c)
 189 {
 190         if (isupper(c))
 191                 c -= 'A'-'a';
 192         return c;
 193 }
 194 #endif /* STRING_H */