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 char *strdup(const char *s);
  27 char *strconcat(const char *s1, const char *s2);
  28
  29 // simple string functions
  30
  31 static inline size_t strnlen(const char *src, size_t max)
  32 {
  33         size_t i = 0;
  34         while ((*src++) && (i < max))
  35                 i++;
  36         return i;
  37 }
  38
  39 static inline size_t strlen(const char *src)
  40 {
  41         size_t i = 0;
  42         while (*src++)
  43                 i++;
  44         return i;
  45 }
  46
  47 static inline char *strchr(const char *s, int c)
  48 {
  49         for (; *s; s++) {
  50                 if (*s == c)
  51                         return (char *) s;
  52         }
  53         return 0;
  54 }
  55
  56 /**
  57  * Find a character in a string.
  58  *
  59  * @param s The string.
  60  * @param c The character.
  61  * @return A pointer to the last occurrence of the character in the
  62  * string, or NULL if the character was not encountered within the string.
  63  */
  64 static inline char *strrchr(const char *s, int c)
  65 {
  66         char *p = (char *)s + strlen(s);
  67
  68         for (; p >= s; p--) {
  69                 if (*p == c)
  70                         return p;
  71         }
  72
  73         return NULL;
  74 }
  75
  76 static inline char *strncpy(char *to, const char *from, int count)
  77 {
  78         register char *ret = to;
  79         register char data;
  80
  81         while (count > 0) {
  82                 count--;
  83                 data = *from++;
  84                 *to++  = data;
  85                 if (data == '\0')
  86                         break;
  87         }
  88
  89         while (count > 0) {
  90                 count--;
  91                 *to++ = '\0';
  92         }
  93         return ret;
  94 }
  95
  96 static inline char *strcpy(char *dst, const char *src)
  97 {
  98         char *ptr = dst;
  99
 100         while (*src)
 101                 *dst++ = *src++;
 102         *dst = '\0';
 103
 104         return ptr;
 105 }
 106
 107 static inline int strcmp(const char *s1, const char *s2)
 108 {
 109         int r;
 110
 111         while ((r = (*s1 - *s2)) == 0 && *s1) {
 112                 s1++;
 113                 s2++;
 114         }
 115         return r;
 116 }
 117
 118 static inline int strncmp(const char *s1, const char *s2, int maxlen)
 119 {
 120         int i;
 121
 122         for (i = 0; i < maxlen; i++) {
 123                 if ((s1[i] != s2[i]) || (s1[i] == '\0'))
 124                         return s1[i] - s2[i];
 125         }
 126
 127         return 0;
 128 }
 129
 130 static inline int isspace(int c)
 131 {
 132         switch (c) {
 133         case ' ': case '\f': case '\n':
 134         case '\r': case '\t': case '\v':
 135                 return 1;
 136         default:
 137                 return 0;
 138         }
 139 }
 140
 141 static inline int isprint(int c)
 142 {
 143         return c >= ' ' && c <= '~';
 144 }
 145
 146 static inline int isdigit(int c)
 147 {
 148         return (c >= '0' && c <= '9');
 149 }
 150
 151 static inline int isxdigit(int c)
 152 {
 153         return ((c >= '0' && c <= '9') ||
 154                 (c >= 'a' && c <= 'f') ||
 155                 (c >= 'A' && c <= 'F'));
 156 }
 157
 158 static inline int isupper(int c)
 159 {
 160         return (c >= 'A' && c <= 'Z');
 161 }
 162
 163 static inline int islower(int c)
 164 {
 165         return (c >= 'a' && c <= 'z');
 166 }
 167
 168 static inline int toupper(int c)
 169 {
 170         if (islower(c))
 171                 c -= 'a'-'A';
 172         return c;
 173 }
 174
 175 static inline int tolower(int c)
 176 {
 177         if (isupper(c))
 178                 c -= 'A'-'a';
 179         return c;
 180 }
 181
 182 /*
 183  * Parses an unsigned integer and moves the input pointer forward to the first
 184  * character that's not a valid digit. s and *s must not be NULL. Result
 185  * undefined if it overruns the return type size.
 186  */
 187 static inline unsigned int skip_atoi(char **s)
 188 {
 189         unsigned int i = 0;
 190
 191         while (isdigit(**s))
 192                 i = i*10 + *((*s)++) - '0';
 193         return i;
 194 }
 195
 196 #endif /* STRING_H */