1/*
2 * libjingle
3 * Copyright 2004--2005, Google Inc.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 *  1. Redistributions of source code must retain the above copyright notice,
9 *     this list of conditions and the following disclaimer.
10 *  2. Redistributions in binary form must reproduce the above copyright notice,
11 *     this list of conditions and the following disclaimer in the documentation
12 *     and/or other materials provided with the distribution.
13 *  3. The name of the author may not be used to endorse or promote products
14 *     derived from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
19 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28#ifndef TALK_BASE_STRINGUTILS_H__
29#define TALK_BASE_STRINGUTILS_H__
30
31#include <ctype.h>
32#include <stdarg.h>
33#include <stdio.h>
34
35#ifdef WIN32
36#include <malloc.h>
37#include <wchar.h>
38#define alloca _alloca
39#endif  // WIN32
40
41#ifdef POSIX
42#ifdef BSD
43#include <stdlib.h>
44#else  // BSD
45#include <alloca.h>
46#endif  // !BSD
47#endif  // POSIX
48
49#include <cstring>
50#include <string>
51
52#include "talk/base/basictypes.h"
53
54///////////////////////////////////////////////////////////////////////////////
55// Generic string/memory utilities
56///////////////////////////////////////////////////////////////////////////////
57
58#define STACK_ARRAY(TYPE, LEN) static_cast<TYPE*>(::alloca((LEN)*sizeof(TYPE)))
59
60namespace talk_base {
61
62// Complement to memset.  Verifies memory consists of count bytes of value c.
63bool memory_check(const void* memory, int c, size_t count);
64
65// Determines whether the simple wildcard pattern matches target.
66// Alpha characters in pattern match case-insensitively.
67// Asterisks in pattern match 0 or more characters.
68// Ex: string_match("www.TEST.GOOGLE.COM", "www.*.com") -> true
69bool string_match(const char* target, const char* pattern);
70
71}  // namespace talk_base
72
73///////////////////////////////////////////////////////////////////////////////
74// Rename a bunch of common string functions so they are consistent across
75// platforms and between char and wchar_t variants.
76// Here is the full list of functions that are unified:
77//  strlen, strcmp, stricmp, strncmp, strnicmp
78//  strchr, vsnprintf, strtoul, tolowercase
79// tolowercase is like tolower, but not compatible with end-of-file value
80//
81// It's not clear if we will ever use wchar_t strings on unix.  In theory,
82// all strings should be Utf8 all the time, except when interfacing with Win32
83// APIs that require Utf16.
84///////////////////////////////////////////////////////////////////////////////
85
86inline char tolowercase(char c) {
87  return static_cast<char>(tolower(c));
88}
89
90#ifdef WIN32
91
92inline size_t strlen(const wchar_t* s) {
93  return wcslen(s);
94}
95inline int strcmp(const wchar_t* s1, const wchar_t* s2) {
96  return wcscmp(s1, s2);
97}
98inline int stricmp(const wchar_t* s1, const wchar_t* s2) {
99  return _wcsicmp(s1, s2);
100}
101inline int strncmp(const wchar_t* s1, const wchar_t* s2, size_t n) {
102  return wcsncmp(s1, s2, n);
103}
104inline int strnicmp(const wchar_t* s1, const wchar_t* s2, size_t n) {
105  return _wcsnicmp(s1, s2, n);
106}
107inline const wchar_t* strchr(const wchar_t* s, wchar_t c) {
108  return wcschr(s, c);
109}
110inline const wchar_t* strstr(const wchar_t* haystack, const wchar_t* needle) {
111  return wcsstr(haystack, needle);
112}
113#ifndef vsnprintf
114inline int vsnprintf(char* buf, size_t n, const char* fmt, va_list args) {
115  return _vsnprintf(buf, n, fmt, args);
116}
117inline int vsnprintf(wchar_t* buf, size_t n, const wchar_t* fmt, va_list args) {
118  return _vsnwprintf(buf, n, fmt, args);
119}
120#endif // !vsnprintf
121inline unsigned long strtoul(const wchar_t* snum, wchar_t** end, int base) {
122  return wcstoul(snum, end, base);
123}
124inline wchar_t tolowercase(wchar_t c) {
125  return static_cast<wchar_t>(towlower(c));
126}
127
128#endif  // WIN32
129
130#ifdef POSIX
131
132inline int _stricmp(const char* s1, const char* s2) {
133  return strcasecmp(s1, s2);
134}
135inline int _strnicmp(const char* s1, const char* s2, size_t n) {
136  return strncasecmp(s1, s2, n);
137}
138
139#endif // POSIX
140
141///////////////////////////////////////////////////////////////////////////////
142// Traits simplifies porting string functions to be CTYPE-agnostic
143///////////////////////////////////////////////////////////////////////////////
144
145namespace talk_base {
146
147const size_t SIZE_UNKNOWN = static_cast<size_t>(-1);
148
149template<class CTYPE>
150struct Traits {
151  // STL string type
152  //typedef XXX string;
153  // Null-terminated string
154  //inline static const CTYPE* empty_str();
155};
156
157///////////////////////////////////////////////////////////////////////////////
158// String utilities which work with char or wchar_t
159///////////////////////////////////////////////////////////////////////////////
160
161template<class CTYPE>
162inline const CTYPE* nonnull(const CTYPE* str, const CTYPE* def_str = NULL) {
163  return str ? str : (def_str ? def_str : Traits<CTYPE>::empty_str());
164}
165
166template<class CTYPE>
167const CTYPE* strchr(const CTYPE* str, const CTYPE* chs) {
168  for (size_t i=0; str[i]; ++i) {
169    for (size_t j=0; chs[j]; ++j) {
170      if (str[i] == chs[j]) {
171        return str + i;
172      }
173    }
174  }
175  return 0;
176}
177
178template<class CTYPE>
179const CTYPE* strchrn(const CTYPE* str, size_t slen, CTYPE ch) {
180  for (size_t i=0; i<slen && str[i]; ++i) {
181    if (str[i] == ch) {
182      return str + i;
183    }
184  }
185  return 0;
186}
187
188template<class CTYPE>
189size_t strlenn(const CTYPE* buffer, size_t buflen) {
190  size_t bufpos = 0;
191  while (buffer[bufpos] && (bufpos < buflen)) {
192    ++bufpos;
193  }
194  return bufpos;
195}
196
197// Safe versions of strncpy, strncat, snprintf and vsnprintf that always
198// null-terminate.
199
200template<class CTYPE>
201size_t strcpyn(CTYPE* buffer, size_t buflen,
202               const CTYPE* source, size_t srclen = SIZE_UNKNOWN) {
203  if (buflen <= 0)
204    return 0;
205
206  if (srclen == SIZE_UNKNOWN) {
207    srclen = strlenn(source, buflen - 1);
208  } else if (srclen >= buflen) {
209    srclen = buflen - 1;
210  }
211  memcpy(buffer, source, srclen * sizeof(CTYPE));
212  buffer[srclen] = 0;
213  return srclen;
214}
215
216template<class CTYPE>
217size_t strcatn(CTYPE* buffer, size_t buflen,
218               const CTYPE* source, size_t srclen = SIZE_UNKNOWN) {
219  if (buflen <= 0)
220    return 0;
221
222  size_t bufpos = strlenn(buffer, buflen - 1);
223  return bufpos + strcpyn(buffer + bufpos, buflen - bufpos, source, srclen);
224}
225
226// Some compilers (clang specifically) require vsprintfn be defined before
227// sprintfn.
228template<class CTYPE>
229size_t vsprintfn(CTYPE* buffer, size_t buflen, const CTYPE* format,
230                 va_list args) {
231  int len = vsnprintf(buffer, buflen, format, args);
232  if ((len < 0) || (static_cast<size_t>(len) >= buflen)) {
233    len = static_cast<int>(buflen - 1);
234    buffer[len] = 0;
235  }
236  return len;
237}
238
239template<class CTYPE>
240size_t sprintfn(CTYPE* buffer, size_t buflen, const CTYPE* format, ...);
241/* This works to get GCC to notice printf argument mismatches, but then complains of missing implementation of sprintfn<char>
242template<>
243size_t sprintfn(char* buffer, size_t buflen, const char* format, ...)
244GCC_ATTR(format(printf,3,4));
245*/
246template<class CTYPE>
247size_t sprintfn(CTYPE* buffer, size_t buflen, const CTYPE* format, ...) {
248  va_list args;
249  va_start(args, format);
250  size_t len = vsprintfn(buffer, buflen, format, args);
251  va_end(args);
252  return len;
253}
254
255///////////////////////////////////////////////////////////////////////////////
256// Allow safe comparing and copying ascii (not UTF-8) with both wide and
257// non-wide character strings.
258///////////////////////////////////////////////////////////////////////////////
259
260inline int asccmp(const char* s1, const char* s2) {
261  return strcmp(s1, s2);
262}
263inline int ascicmp(const char* s1, const char* s2) {
264  return _stricmp(s1, s2);
265}
266inline int ascncmp(const char* s1, const char* s2, size_t n) {
267  return strncmp(s1, s2, n);
268}
269inline int ascnicmp(const char* s1, const char* s2, size_t n) {
270  return _strnicmp(s1, s2, n);
271}
272inline size_t asccpyn(char* buffer, size_t buflen,
273                      const char* source, size_t srclen = SIZE_UNKNOWN) {
274  return strcpyn(buffer, buflen, source, srclen);
275}
276
277#ifdef WIN32
278
279typedef wchar_t(*CharacterTransformation)(wchar_t);
280inline wchar_t identity(wchar_t c) { return c; }
281int ascii_string_compare(const wchar_t* s1, const char* s2, size_t n,
282                         CharacterTransformation transformation);
283
284inline int asccmp(const wchar_t* s1, const char* s2) {
285  return ascii_string_compare(s1, s2, static_cast<size_t>(-1), identity);
286}
287inline int ascicmp(const wchar_t* s1, const char* s2) {
288  return ascii_string_compare(s1, s2, static_cast<size_t>(-1), tolowercase);
289}
290inline int ascncmp(const wchar_t* s1, const char* s2, size_t n) {
291  return ascii_string_compare(s1, s2, n, identity);
292}
293inline int ascnicmp(const wchar_t* s1, const char* s2, size_t n) {
294  return ascii_string_compare(s1, s2, n, tolowercase);
295}
296size_t asccpyn(wchar_t* buffer, size_t buflen,
297               const char* source, size_t srclen = SIZE_UNKNOWN);
298
299#endif  // WIN32
300
301///////////////////////////////////////////////////////////////////////////////
302// Traits<char> specializations
303///////////////////////////////////////////////////////////////////////////////
304
305template<>
306struct Traits<char> {
307  typedef std::string string;
308  inline static const char* empty_str() { return ""; }
309};
310
311///////////////////////////////////////////////////////////////////////////////
312// Traits<wchar_t> specializations (Windows only, currently)
313///////////////////////////////////////////////////////////////////////////////
314
315#ifdef WIN32
316
317template<>
318struct Traits<wchar_t> {
319  typedef std::wstring string;
320  inline static const wchar_t* Traits<wchar_t>::empty_str() { return L""; }
321};
322
323#endif  // WIN32
324
325// Replaces all occurrences of "search" with "replace".
326void replace_substrs(const char *search,
327                     size_t search_len,
328                     const char *replace,
329                     size_t replace_len,
330                     std::string *s);
331
332// True iff s1 starts with s2.
333bool starts_with(const char *s1, const char *s2);
334
335// Remove leading and trailing whitespaces.
336std::string string_trim(const std::string& s);
337
338}  // namespace talk_base
339
340#endif // TALK_BASE_STRINGUTILS_H__
341