• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
3  *
4  *  Use of this source code is governed by a BSD-style license
5  *  that can be found in the LICENSE file in the root of the source
6  *  tree. An additional intellectual property rights grant can be found
7  *  in the file PATENTS.  All contributing project authors may
8  *  be found in the AUTHORS file in the root of the source tree.
9  */
10 
11 #ifndef WEBRTC_BASE_STRINGUTILS_H__
12 #define WEBRTC_BASE_STRINGUTILS_H__
13 
14 #include <ctype.h>
15 #include <stdarg.h>
16 #include <stdio.h>
17 #include <string.h>
18 
19 #if defined(WEBRTC_WIN)
20 #include <malloc.h>
21 #include <wchar.h>
22 #define alloca _alloca
23 #endif  // WEBRTC_WIN
24 
25 #if defined(WEBRTC_POSIX)
26 #ifdef BSD
27 #include <stdlib.h>
28 #else  // BSD
29 #include <alloca.h>
30 #endif  // !BSD
31 #endif  // WEBRTC_POSIX
32 
33 #include <string>
34 
35 #include "webrtc/base/basictypes.h"
36 
37 ///////////////////////////////////////////////////////////////////////////////
38 // Generic string/memory utilities
39 ///////////////////////////////////////////////////////////////////////////////
40 
41 #define STACK_ARRAY(TYPE, LEN) static_cast<TYPE*>(::alloca((LEN)*sizeof(TYPE)))
42 
43 namespace rtc {
44 
45 // Complement to memset.  Verifies memory consists of count bytes of value c.
46 bool memory_check(const void* memory, int c, size_t count);
47 
48 // Determines whether the simple wildcard pattern matches target.
49 // Alpha characters in pattern match case-insensitively.
50 // Asterisks in pattern match 0 or more characters.
51 // Ex: string_match("www.TEST.GOOGLE.COM", "www.*.com") -> true
52 bool string_match(const char* target, const char* pattern);
53 
54 }  // namespace rtc
55 
56 ///////////////////////////////////////////////////////////////////////////////
57 // Rename a bunch of common string functions so they are consistent across
58 // platforms and between char and wchar_t variants.
59 // Here is the full list of functions that are unified:
60 //  strlen, strcmp, stricmp, strncmp, strnicmp
61 //  strchr, vsnprintf, strtoul, tolowercase
62 // tolowercase is like tolower, but not compatible with end-of-file value
63 //
64 // It's not clear if we will ever use wchar_t strings on unix.  In theory,
65 // all strings should be Utf8 all the time, except when interfacing with Win32
66 // APIs that require Utf16.
67 ///////////////////////////////////////////////////////////////////////////////
68 
tolowercase(char c)69 inline char tolowercase(char c) {
70   return static_cast<char>(tolower(c));
71 }
72 
73 #if defined(WEBRTC_WIN)
74 
strlen(const wchar_t * s)75 inline size_t strlen(const wchar_t* s) {
76   return wcslen(s);
77 }
strcmp(const wchar_t * s1,const wchar_t * s2)78 inline int strcmp(const wchar_t* s1, const wchar_t* s2) {
79   return wcscmp(s1, s2);
80 }
stricmp(const wchar_t * s1,const wchar_t * s2)81 inline int stricmp(const wchar_t* s1, const wchar_t* s2) {
82   return _wcsicmp(s1, s2);
83 }
strncmp(const wchar_t * s1,const wchar_t * s2,size_t n)84 inline int strncmp(const wchar_t* s1, const wchar_t* s2, size_t n) {
85   return wcsncmp(s1, s2, n);
86 }
strnicmp(const wchar_t * s1,const wchar_t * s2,size_t n)87 inline int strnicmp(const wchar_t* s1, const wchar_t* s2, size_t n) {
88   return _wcsnicmp(s1, s2, n);
89 }
strchr(const wchar_t * s,wchar_t c)90 inline const wchar_t* strchr(const wchar_t* s, wchar_t c) {
91   return wcschr(s, c);
92 }
strstr(const wchar_t * haystack,const wchar_t * needle)93 inline const wchar_t* strstr(const wchar_t* haystack, const wchar_t* needle) {
94   return wcsstr(haystack, needle);
95 }
96 #ifndef vsnprintf
vsnprintf(wchar_t * buf,size_t n,const wchar_t * fmt,va_list args)97 inline int vsnprintf(wchar_t* buf, size_t n, const wchar_t* fmt, va_list args) {
98   return _vsnwprintf(buf, n, fmt, args);
99 }
100 #endif // !vsnprintf
strtoul(const wchar_t * snum,wchar_t ** end,int base)101 inline unsigned long strtoul(const wchar_t* snum, wchar_t** end, int base) {
102   return wcstoul(snum, end, base);
103 }
tolowercase(wchar_t c)104 inline wchar_t tolowercase(wchar_t c) {
105   return static_cast<wchar_t>(towlower(c));
106 }
107 
108 #endif  // WEBRTC_WIN
109 
110 #if defined(WEBRTC_POSIX)
111 
_stricmp(const char * s1,const char * s2)112 inline int _stricmp(const char* s1, const char* s2) {
113   return strcasecmp(s1, s2);
114 }
_strnicmp(const char * s1,const char * s2,size_t n)115 inline int _strnicmp(const char* s1, const char* s2, size_t n) {
116   return strncasecmp(s1, s2, n);
117 }
118 
119 #endif // WEBRTC_POSIX
120 
121 ///////////////////////////////////////////////////////////////////////////////
122 // Traits simplifies porting string functions to be CTYPE-agnostic
123 ///////////////////////////////////////////////////////////////////////////////
124 
125 namespace rtc {
126 
127 const size_t SIZE_UNKNOWN = static_cast<size_t>(-1);
128 
129 template<class CTYPE>
130 struct Traits {
131   // STL string type
132   //typedef XXX string;
133   // Null-terminated string
134   //inline static const CTYPE* empty_str();
135 };
136 
137 ///////////////////////////////////////////////////////////////////////////////
138 // String utilities which work with char or wchar_t
139 ///////////////////////////////////////////////////////////////////////////////
140 
141 template<class CTYPE>
142 inline const CTYPE* nonnull(const CTYPE* str, const CTYPE* def_str = NULL) {
143   return str ? str : (def_str ? def_str : Traits<CTYPE>::empty_str());
144 }
145 
146 template<class CTYPE>
strchr(const CTYPE * str,const CTYPE * chs)147 const CTYPE* strchr(const CTYPE* str, const CTYPE* chs) {
148   for (size_t i=0; str[i]; ++i) {
149     for (size_t j=0; chs[j]; ++j) {
150       if (str[i] == chs[j]) {
151         return str + i;
152       }
153     }
154   }
155   return 0;
156 }
157 
158 template<class CTYPE>
strchrn(const CTYPE * str,size_t slen,CTYPE ch)159 const CTYPE* strchrn(const CTYPE* str, size_t slen, CTYPE ch) {
160   for (size_t i=0; i<slen && str[i]; ++i) {
161     if (str[i] == ch) {
162       return str + i;
163     }
164   }
165   return 0;
166 }
167 
168 template<class CTYPE>
strlenn(const CTYPE * buffer,size_t buflen)169 size_t strlenn(const CTYPE* buffer, size_t buflen) {
170   size_t bufpos = 0;
171   while (buffer[bufpos] && (bufpos < buflen)) {
172     ++bufpos;
173   }
174   return bufpos;
175 }
176 
177 // Safe versions of strncpy, strncat, snprintf and vsnprintf that always
178 // null-terminate.
179 
180 template<class CTYPE>
181 size_t strcpyn(CTYPE* buffer, size_t buflen,
182                const CTYPE* source, size_t srclen = SIZE_UNKNOWN) {
183   if (buflen <= 0)
184     return 0;
185 
186   if (srclen == SIZE_UNKNOWN) {
187     srclen = strlenn(source, buflen - 1);
188   } else if (srclen >= buflen) {
189     srclen = buflen - 1;
190   }
191   memcpy(buffer, source, srclen * sizeof(CTYPE));
192   buffer[srclen] = 0;
193   return srclen;
194 }
195 
196 template<class CTYPE>
197 size_t strcatn(CTYPE* buffer, size_t buflen,
198                const CTYPE* source, size_t srclen = SIZE_UNKNOWN) {
199   if (buflen <= 0)
200     return 0;
201 
202   size_t bufpos = strlenn(buffer, buflen - 1);
203   return bufpos + strcpyn(buffer + bufpos, buflen - bufpos, source, srclen);
204 }
205 
206 // Some compilers (clang specifically) require vsprintfn be defined before
207 // sprintfn.
208 template<class CTYPE>
vsprintfn(CTYPE * buffer,size_t buflen,const CTYPE * format,va_list args)209 size_t vsprintfn(CTYPE* buffer, size_t buflen, const CTYPE* format,
210                  va_list args) {
211   int len = vsnprintf(buffer, buflen, format, args);
212   if ((len < 0) || (static_cast<size_t>(len) >= buflen)) {
213     len = static_cast<int>(buflen - 1);
214     buffer[len] = 0;
215   }
216   return len;
217 }
218 
219 template<class CTYPE>
220 size_t sprintfn(CTYPE* buffer, size_t buflen, const CTYPE* format, ...);
221 template<class CTYPE>
sprintfn(CTYPE * buffer,size_t buflen,const CTYPE * format,...)222 size_t sprintfn(CTYPE* buffer, size_t buflen, const CTYPE* format, ...) {
223   va_list args;
224   va_start(args, format);
225   size_t len = vsprintfn(buffer, buflen, format, args);
226   va_end(args);
227   return len;
228 }
229 
230 ///////////////////////////////////////////////////////////////////////////////
231 // Allow safe comparing and copying ascii (not UTF-8) with both wide and
232 // non-wide character strings.
233 ///////////////////////////////////////////////////////////////////////////////
234 
asccmp(const char * s1,const char * s2)235 inline int asccmp(const char* s1, const char* s2) {
236   return strcmp(s1, s2);
237 }
ascicmp(const char * s1,const char * s2)238 inline int ascicmp(const char* s1, const char* s2) {
239   return _stricmp(s1, s2);
240 }
ascncmp(const char * s1,const char * s2,size_t n)241 inline int ascncmp(const char* s1, const char* s2, size_t n) {
242   return strncmp(s1, s2, n);
243 }
ascnicmp(const char * s1,const char * s2,size_t n)244 inline int ascnicmp(const char* s1, const char* s2, size_t n) {
245   return _strnicmp(s1, s2, n);
246 }
247 inline size_t asccpyn(char* buffer, size_t buflen,
248                       const char* source, size_t srclen = SIZE_UNKNOWN) {
249   return strcpyn(buffer, buflen, source, srclen);
250 }
251 
252 #if defined(WEBRTC_WIN)
253 
254 typedef wchar_t(*CharacterTransformation)(wchar_t);
identity(wchar_t c)255 inline wchar_t identity(wchar_t c) { return c; }
256 int ascii_string_compare(const wchar_t* s1, const char* s2, size_t n,
257                          CharacterTransformation transformation);
258 
asccmp(const wchar_t * s1,const char * s2)259 inline int asccmp(const wchar_t* s1, const char* s2) {
260   return ascii_string_compare(s1, s2, static_cast<size_t>(-1), identity);
261 }
ascicmp(const wchar_t * s1,const char * s2)262 inline int ascicmp(const wchar_t* s1, const char* s2) {
263   return ascii_string_compare(s1, s2, static_cast<size_t>(-1), tolowercase);
264 }
ascncmp(const wchar_t * s1,const char * s2,size_t n)265 inline int ascncmp(const wchar_t* s1, const char* s2, size_t n) {
266   return ascii_string_compare(s1, s2, n, identity);
267 }
ascnicmp(const wchar_t * s1,const char * s2,size_t n)268 inline int ascnicmp(const wchar_t* s1, const char* s2, size_t n) {
269   return ascii_string_compare(s1, s2, n, tolowercase);
270 }
271 size_t asccpyn(wchar_t* buffer, size_t buflen,
272                const char* source, size_t srclen = SIZE_UNKNOWN);
273 
274 #endif  // WEBRTC_WIN
275 
276 ///////////////////////////////////////////////////////////////////////////////
277 // Traits<char> specializations
278 ///////////////////////////////////////////////////////////////////////////////
279 
280 template<>
281 struct Traits<char> {
282   typedef std::string string;
283   inline static const char* empty_str() { return ""; }
284 };
285 
286 ///////////////////////////////////////////////////////////////////////////////
287 // Traits<wchar_t> specializations (Windows only, currently)
288 ///////////////////////////////////////////////////////////////////////////////
289 
290 #if defined(WEBRTC_WIN)
291 
292 template<>
293 struct Traits<wchar_t> {
294   typedef std::wstring string;
295   inline static const wchar_t* empty_str() { return L""; }
296 };
297 
298 #endif  // WEBRTC_WIN
299 
300 // Replaces all occurrences of "search" with "replace".
301 void replace_substrs(const char *search,
302                      size_t search_len,
303                      const char *replace,
304                      size_t replace_len,
305                      std::string *s);
306 
307 // True iff s1 starts with s2.
308 bool starts_with(const char *s1, const char *s2);
309 
310 // True iff s1 ends with s2.
311 bool ends_with(const char *s1, const char *s2);
312 
313 // Remove leading and trailing whitespaces.
314 std::string string_trim(const std::string& s);
315 
316 }  // namespace rtc
317 
318 #endif // WEBRTC_BASE_STRINGUTILS_H__
319