u_string.h 4.91 KB
Newer Older
1 2
/**************************************************************************
 *
3
 * Copyright 2008 VMware, Inc.
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
 * All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sub license, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice (including the
 * next paragraph) shall be included in all copies or substantial portions
 * of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21
 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
22 23 24 25 26 27 28 29 30
 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 **************************************************************************/

/**
 * @file
 * Platform independent functions for string manipulation.
31
 *
32
 * @author Jose Fonseca <jfonseca@vmware.com>
33 34 35 36 37
 */

#ifndef U_STRING_H_
#define U_STRING_H_

38
#if !defined(XF86_LIBC_H)
39 40
#include <stdio.h>
#endif
41
#include <stdlib.h>
42 43
#include <stddef.h>
#include <stdarg.h>
44
#include <string.h>
45

46
#include "util/macros.h" // PRINTFLIKE
47

48 49 50 51 52

#ifdef __cplusplus
extern "C" {
#endif

53 54 55 56 57 58
#ifdef _GNU_SOURCE

#define util_strchrnul strchrnul

#else

59
static inline char *
60 61 62 63 64 65 66 67
util_strchrnul(const char *s, char c)
{
   for (; *s && *s != c; ++s);

   return (char *)s;
}

#endif
68

69
#ifdef _WIN32
70

71 72 73 74 75 76 77 78 79 80 81 82 83
static inline int
util_vsnprintf(char *str, size_t size, const char *format, va_list ap)
{
   /* We need to use _vscprintf to calculate the length as vsnprintf returns -1
    * if the number of characters to write is greater than count.
    */
   va_list ap_copy;
   int ret;
   va_copy(ap_copy, ap);
   ret = _vsnprintf(str, size, format, ap);
   if (ret < 0) {
      ret = _vscprintf(format, ap_copy);
   }
84
   va_end(ap_copy);
85 86 87 88 89 90 91 92 93 94 95 96 97 98
   return ret;
}

static inline int
   PRINTFLIKE(3, 4)
util_snprintf(char *str, size_t size, const char *format, ...)
{
   va_list ap;
   int ret;
   va_start(ap, format);
   ret = util_vsnprintf(str, size, format, ap);
   va_end(ap);
   return ret;
}
99

100
static inline void
101 102 103 104 105
util_vsprintf(char *str, const char *format, va_list ap)
{
   util_vsnprintf(str, (size_t)-1, format, ap);
}

106
static inline void
107
   PRINTFLIKE(2, 3)
108 109 110 111 112 113 114 115
util_sprintf(char *str, const char *format, ...)
{
   va_list ap;
   va_start(ap, format);
   util_vsnprintf(str, (size_t)-1, format, ap);
   va_end(ap);
}

116 117 118 119 120 121 122
static inline int
util_vasprintf(char **ret, const char *format, va_list ap)
{
   va_list ap_copy;

   /* Compute length of output string first */
   va_copy(ap_copy, ap);
123
   int r = util_vsnprintf(NULL, 0, format, ap_copy);
124 125 126 127 128 129
   va_end(ap_copy);

   if (r < 0)
      return -1;

   *ret = (char *) malloc(r + 1);
130
   if (!*ret)
131 132 133 134 135 136
      return -1;

   /* Print to buffer */
   return util_vsnprintf(*ret, r + 1, format, ap);
}

137
static inline char *
138 139
util_strchr(const char *s, char c)
{
140 141 142
   char *p = util_strchrnul(s, c);

   return *p ? p : NULL;
143 144
}

145
static inline char*
146 147 148 149 150 151 152 153 154 155 156 157 158
util_strncat(char *dst, const char *src, size_t n)
{
   char *p = dst + strlen(dst);
   const char *q = src;
   size_t i;

   for (i = 0; i < n && *q != '\0'; ++i)
       *p++ = *q++;
   *p = '\0';

   return dst;
}

159
static inline int
160 161 162 163 164 165 166 167 168 169 170 171 172 173 174
util_strcmp(const char *s1, const char *s2)
{
   unsigned char u1, u2;

   while (1) {
      u1 = (unsigned char) *s1++;
      u2 = (unsigned char) *s2++;
      if (u1 != u2)
	 return u1 - u2;
      if (u1 == '\0')
	 return 0;
   }
   return 0;
}

175
static inline int
176 177 178 179 180 181 182 183 184 185 186 187 188 189 190
util_strncmp(const char *s1, const char *s2, size_t n)
{
   unsigned char u1, u2;

   while (n-- > 0) {
      u1 = (unsigned char) *s1++;
      u2 = (unsigned char) *s2++;
      if (u1 != u2)
	 return u1 - u2;
      if (u1 == '\0')
	 return 0;
   }
   return 0;
}

191
static inline char *
192 193 194
util_strstr(const char *haystack, const char *needle)
{
   const char *p = haystack;
195
   size_t len = strlen(needle);
196 197 198 199 200 201 202 203 204 205

   for (; (p = util_strchr(p, *needle)) != 0; p++) {
      if (util_strncmp(p, needle, len) == 0) {
	 return (char *)p;
      }
   }
   return NULL;
}


206
#define util_strcasecmp stricmp
207
#define util_strdup _strdup
208

209
#else
210

211 212
#define util_vsnprintf vsnprintf
#define util_snprintf snprintf
213
#define util_vsprintf vsprintf
214
#define util_vasprintf vasprintf
215
#define util_sprintf sprintf
216 217 218 219 220
#define util_strchr strchr
#define util_strcmp strcmp
#define util_strncmp strncmp
#define util_strncat strncat
#define util_strstr strstr
221
#define util_strcasecmp strcasecmp
222
#define util_strdup strdup
223

224 225 226 227 228 229 230 231
#endif


#ifdef __cplusplus
}
#endif

#endif /* U_STRING_H_ */