]> git.cworth.org Git - apitrace/blob - common/os_string.hpp
Get DWM traces working.
[apitrace] / common / os_string.hpp
1 /**************************************************************************
2  *
3  * Copyright 2011 Jose Fonseca
4  * All Rights Reserved.
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a copy
7  * of this software and associated documentation files (the "Software"), to deal
8  * in the Software without restriction, including without limitation the rights
9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10  * copies of the Software, and to permit persons to whom the Software is
11  * furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included in
14  * all copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22  * THE SOFTWARE.
23  *
24  **************************************************************************/
25
26 /*
27  * String manipulation.
28  */
29
30 #ifndef _OS_STRING_HPP_
31 #define _OS_STRING_HPP_
32
33
34 #include <assert.h>
35 #include <stdarg.h>
36 #include <stdio.h>
37 #include <stddef.h>
38
39 #ifdef __MINGW32__
40 // Some versions of MinGW are missing _vscprintf's declaration, although they
41 // still provide the symbol in the import library.
42 extern "C" _CRTIMP int _vscprintf(const char *format, va_list argptr);
43 #endif
44
45 #ifndef va_copy
46 #ifdef __va_copy
47 #define va_copy(dest, src) __va_copy((dest), (src))
48 #else
49 #define va_copy(dest, src) (dest) = (src)
50 #endif
51 #endif
52
53 #include <vector>
54
55 #include "os.hpp"
56
57
58 #ifdef _WIN32
59 #define OS_DIR_SEP '\\'
60 #else /* !_WIN32 */
61 #define OS_DIR_SEP '/'
62 #endif /* !_WIN32 */
63
64
65 namespace os {
66
67
68 /**
69  * Vector based zero-terminate string, suitable for passing strings or paths
70  * to/from OS calls.
71  */
72 class String {
73 protected:
74     typedef std::vector<char> Buffer;
75
76     /**
77      * The buffer's last element is always the '\0' character, therefore the
78      * buffer must never be empty.
79      */
80     Buffer buffer;
81
82     Buffer::iterator find(char c) {
83         Buffer::iterator it = buffer.begin();
84         assert(it != buffer.end());
85         while (it != buffer.end()) {
86             if (*it == c) {
87                 return it;
88             }
89             ++it;
90         }
91         return buffer.end();
92     }
93
94     Buffer::iterator rfind(char c) {
95         Buffer::iterator it = buffer.end();
96
97         // Skip trailing '\0'
98         assert(it != buffer.begin());
99         --it;
100         assert(*it == '\0');
101
102         while (it != buffer.begin()) {
103             --it;
104             if (*it == c) {
105                 return it;
106             }
107         }
108
109         return buffer.end();
110     }
111
112     String(size_t size) :
113         buffer(size) {
114     }
115
116     char *buf(void) {
117         return &buffer[0];
118     }
119
120     inline bool
121     isSep(char c) {
122         if (c == '/') {
123             return true;
124         }
125 #ifdef _WIN32
126         if (c == '\\') {
127             return true;
128         }
129 #endif
130         return false;
131     }
132
133     Buffer::iterator rfindSep(void) {
134         Buffer::iterator it = buffer.end();
135
136         // Skip trailing '\0'
137         assert(it != buffer.begin());
138         --it;
139         assert(*it == '\0');
140
141         // Skip trailing separators
142         while (it != buffer.begin()) {
143             --it;
144             if (isSep(*it)) {
145                 // Halt if find the root
146                 if (it == buffer.begin()) {
147                     return it;
148                 }
149             } else {
150                 break;
151             }
152         }
153
154         // Advance to the last separator
155         while (it != buffer.begin()) {
156             --it;
157             if (isSep(*it)) {
158                 return it;
159             }
160         }
161
162         return buffer.end();
163     }
164
165
166 public:
167
168     /*
169      * Constructors
170      */
171
172     String() {
173         buffer.push_back(0);
174     }
175
176     String(const char *s) :
177         buffer(s, s + strlen(s) + 1)
178     {}
179
180     String(const String &other) :
181         buffer(other.buffer)
182     {}
183
184     template <class InputIterator>
185     String(InputIterator first, InputIterator last) :
186         buffer(first, last)
187     {
188         buffer.push_back(0);
189     }
190
191     /**
192      * From a printf-like format string
193      */
194     static String
195     format(const char *format, ...)
196 #ifdef __GNUC__
197     __attribute__ ((format (printf, 1, 2)))
198 #endif
199     {
200
201         va_list args;
202
203         va_start(args, format);
204
205         int length;
206         va_list args_copy;
207         va_copy(args_copy, args);
208 #ifdef _WIN32
209         /* We need to use _vscprintf to calculate the length as vsnprintf returns -1
210          * if the number of characters to write is greater than count.
211          */
212         length = _vscprintf(format, args_copy);
213 #else
214         char dummy;
215         length = vsnprintf(&dummy, sizeof dummy, format, args_copy);
216 #endif
217         va_end(args_copy);
218
219         assert(length >= 0);
220         size_t size = length + 1;
221
222         String path(size);
223
224         va_start(args, format);
225         vsnprintf(path.buf(), size, format, args);
226         va_end(args);
227
228         return path;
229     }
230
231     /*
232      * Conversion to ordinary C strings.
233      */
234
235     const char *str(void) const {
236         assert(buffer.back() == 0);
237         return &buffer[0];
238     }
239
240     operator const char *(void) const {
241         return str();
242     }
243
244     /*
245      * Iterators
246      */
247
248     typedef Buffer::const_iterator const_iterator;
249     typedef Buffer::iterator iterator;
250
251     const_iterator begin(void) const {
252         return buffer.begin();
253     }
254
255     iterator begin(void) {
256         return buffer.begin();
257     }
258
259     const_iterator end(void) const {
260         const_iterator it = buffer.end();
261         assert(it != buffer.begin());
262         --it; // skip null
263         return it;
264     }
265
266     iterator end(void) {
267         iterator it = buffer.end();
268         assert(it != buffer.begin());
269         --it; // skip null
270         return it;
271     }
272
273     /*
274      * Operations
275      */
276
277     void insert(iterator position, char c) {
278         buffer.insert(position, c);
279     }
280
281     template <class InputIterator>
282     void insert(iterator position, InputIterator first, InputIterator last) {
283         buffer.insert(position, first, last);
284     }
285
286     void insert(iterator position, const char *s) {
287         assert(s);
288         insert(position, s, s + strlen(s));
289     }
290
291     void insert(iterator position, const String & other) {
292         insert(position, other.begin(), other.end());
293     }
294
295     void append(char c) {
296         insert(end(), c);
297     }
298
299     template <class InputIterator>
300     void append(InputIterator first, InputIterator last) {
301         insert(end(), first, last);
302     }
303
304     void append(const char *s) {
305         insert(end(), s);
306     }
307
308     void append(const String & other) {
309         insert(end(), other);
310     }
311
312     char *buf(size_t size) {
313         buffer.resize(size);
314         return &buffer[0];
315     }
316
317     size_t length(void) const {
318         size_t size = buffer.size();
319         assert(size > 0);
320         assert(buffer[size - 1] == 0);
321         return size - 1;
322     }
323
324     void truncate(size_t length) {
325         assert(length < buffer.size());
326         buffer[length] = 0;
327         buffer.resize(length + 1);
328     }
329
330     void truncate(void) {
331         truncate(strlen(str()));
332     }
333
334
335     /*
336      * Path manipulation
337      */
338
339     bool
340     exists(void) const;
341
342     /* Trim directory (leaving base filename).
343      */
344     void trimDirectory(void) {
345         iterator sep = rfindSep();
346         if (sep != buffer.end()) {
347             buffer.erase(buffer.begin(), sep + 1);
348         }
349     }
350
351     /* Trim filename component (leaving containing directory).
352      *
353      * - trailing separators are ignored
354      * - a path with no separator at all yields "."
355      * - a path consisting of just the root directory is left unchanged
356      */
357     void trimFilename(void) {
358         iterator sep = rfindSep();
359
360         // No separator found, so return '.'
361         if (sep == buffer.end()) {
362             buffer.resize(2);
363             buffer[0] = '.';
364             buffer[1] = 0;
365             return;
366         }
367
368         // Root. Nothing to do.
369         if (sep == buffer.begin()) {
370             return;
371         }
372
373         // Trim filename
374         buffer.erase(sep, end());
375     }
376
377     void trimExtension(void) {
378         iterator dot = rfind('.');
379         if (dot != buffer.end()) {
380             buffer.erase(dot, end());
381         }
382     }
383
384     void join(const String & other) {
385         if (length() && end()[-1] != OS_DIR_SEP) {
386             append(OS_DIR_SEP);
387         }
388         append(other.begin(), other.end());
389     }
390 };
391
392
393 String getProcessName();
394 String getCurrentDir();
395
396 bool copyFile(const String &srcFileName, const String &dstFileName, bool override = true);
397
398 bool removeFile(const String &fileName);
399
400 } /* namespace os */
401
402 #endif /* _OS_STRING_HPP_ */