![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to stringconverter.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [truecrypt] / truecrypt / platform|
Return to stringconverter.cpp CVS log | Up to [truecrypt] / truecrypt / platform |
1.1 root 1: /*
2: Copyright (c) 2008 TrueCrypt Foundation. All rights reserved.
3:
4: Governed by the TrueCrypt License 2.4 the full text of which is contained
5: in the file License.txt included in TrueCrypt binary and source code
6: distribution packages.
7: */
8:
9: #ifdef __GNUC__
10: # include <cxxabi.h>
11: #endif
12: #include <typeinfo>
13: #include "Buffer.h"
14: #include "Exception.h"
15: #include "ForEach.h"
16: #include "StringConverter.h"
17: #include "SystemException.h"
18:
19: namespace TrueCrypt
20: {
21: wstring StringConverter::FromNumber (double number)
22: {
23: wstringstream s;
24: s << number;
25: return s.str();
26: }
27:
28: wstring StringConverter::FromNumber (unsigned int number)
29: {
30: wstringstream s;
31: s << number;
32: return s.str();
33: }
34:
35: wstring StringConverter::FromNumber (int64 number)
36: {
37: wstringstream s;
38: s << number;
39: return s.str();
40: }
41:
42: wstring StringConverter::FromNumber (int number)
43: {
44: wstringstream s;
45: s << number;
46: return s.str();
47: }
48:
49: wstring StringConverter::FromNumber (long number)
50: {
51: wstringstream s;
52: s << number;
53: return s.str();
54: }
55:
56: wstring StringConverter::FromNumber (unsigned long number)
57: {
58: wstringstream s;
59: s << number;
60: return s.str();
61: }
62:
63: wstring StringConverter::FromNumber (uint64 number)
64: {
65: wstringstream s;
66: s << number;
67: return s.str();
68: }
69:
70: string StringConverter::GetTrailingNumber (const string &str)
71: {
72: size_t start = str.find_last_not_of ("0123456789");
73: if (start == string::npos)
74: return str;
75:
76: string s = str.substr (start + 1);
77: if (s.empty ())
78: throw ParameterIncorrect (SRC_POS);
79:
80: return s;
81: }
82:
83: string StringConverter::GetTypeName (const type_info &typeInfo)
84: {
85: try
86: {
87: #ifdef _MSC_VER
88: // type_info::name() leaks memory as of MS VC++ 8.0
89: string rawName (typeInfo.raw_name());
90:
91: int cut1 = (rawName.find (".?A") != string::npos) ? 4 : string::npos;
92: int cut2 = rawName.find ("@");
93: int cut3 = rawName.find ("@@");
94:
95: if (cut1 == string::npos || cut2 == string::npos || cut3 == string::npos)
96: return typeInfo.name();
97:
98: return rawName.substr (cut2 + 1, cut3 - cut2 - 1) + "::" + rawName.substr (cut1, cut2 - cut1);
99:
100: #elif defined (__GNUC__)
101: int status;
102: char *name = abi::__cxa_demangle (typeInfo.name(), nullptr, nullptr, &status);
103:
104: if (name)
105: {
106: string s (name);
107: free (name);
108: return s;
109: }
110: #endif
111: }
112: catch (...) { }
113:
114: return typeInfo.name();
115: }
116:
117: wstring StringConverter::QuoteSpaces (const wstring &str)
118: {
119: if (str.find (L' ') == string::npos)
120: return str;
121:
122: wstring escaped (L"'");
123: foreach (wchar_t c, str)
124: {
125: if (c == L'\'')
126: escaped += L'\'';
127: escaped += c;
128: }
129: return escaped + L'\'';
130: }
131:
132: vector <string> StringConverter::Split (const string &str, const string &separators, bool returnEmptyFields)
133: {
134: vector <string> elements;
135:
136: if (!returnEmptyFields)
137: {
138: size_t p = 0;
139: while ((p = str.find_first_not_of (separators, p)) != string::npos)
140: {
141: size_t end = str.find_first_of (separators, p);
142: if (end == string::npos)
143: {
144: elements.push_back (str.substr (p));
145: break;
146: }
147:
148: elements.push_back (str.substr (p, end - p));
149: p = end;
150: }
151: }
152: else
153: {
154: string element;
155: elements.push_back (element);
156: foreach (char c, str)
157: {
158: if (separators.find (c) != string::npos)
159: {
160: element.erase();
161: elements.push_back (element);
162: }
163: else
164: {
165: elements.back() += c;
166: }
167: }
168: }
169:
170: return elements;
171: }
172:
173: wstring StringConverter::ToExceptionString (const exception &ex)
174: {
175: const SystemException *sysEx = dynamic_cast <const SystemException *> (&ex);
176: if (sysEx)
177: return ToWide (sysEx->what()) + L": " + sysEx->SystemText() + L": " + sysEx->GetSubject();
178:
179: if (ex.what() && !string (ex.what()).empty())
180: return ToWide (GetTypeName (typeid (ex)) + ": " + ex.what());
181:
182: return ToWide (GetTypeName (typeid (ex)));
183: }
184:
185: string StringConverter::ToSingle (const wstring &str, bool noThrow)
186: {
187: try
188: {
189: mbstate_t mbState;
190: Memory::Zero (&mbState, sizeof (mbState));
191: const wchar_t *src = str.c_str();
192:
193: size_t size = wcsrtombs (nullptr, &src, 0, &mbState);
194: if (size == -1)
195: throw StringConversionFailed (SRC_POS, str);
196:
197: vector <char> buf (size + 1);
198: Memory::Zero (&mbState, sizeof (mbState));
199:
200: if ((size = wcsrtombs (&buf[0], &src, buf.size(), &mbState)) == -1)
201: throw StringConversionFailed (SRC_POS, str);
202:
203: string s;
204: s.insert (s.begin(), buf.begin(), buf.begin() + size);
205: return s;
206: }
207: catch (...)
208: {
209: if (noThrow)
210: return "";
211: throw;
212: }
213: }
214:
215: uint32 StringConverter::ToUInt32 (const string &str)
216: {
217: uint32 n;
218: stringstream ss (str);
219:
220: ss >> n;
221: if (ss.fail() || n == 0xffffFFFFU)
222: throw ParameterIncorrect (SRC_POS);
223:
224: return n;
225: }
226:
227: uint32 StringConverter::ToUInt32 (const wstring &str)
228: {
229: uint32 n;
230: wstringstream ss (str);
231:
232: ss >> n;
233: if (ss.fail() || n == 0xffffFFFFU)
234: throw ParameterIncorrect (SRC_POS);
235:
236: return n;
237: }
238:
239: uint64 StringConverter::ToUInt64 (const string &str)
240: {
241: uint64 n;
242: stringstream ss (str);
243:
244: ss >> n;
245: if (ss.fail() || n == 0xffffFFFFffffFFFFULL)
246: throw ParameterIncorrect (SRC_POS);
247:
248: return n;
249: }
250:
251: uint64 StringConverter::ToUInt64 (const wstring &str)
252: {
253: uint64 n;
254: wstringstream ss (str);
255:
256: ss >> n;
257: if (ss.fail() || n == 0xffffFFFFffffFFFFULL)
258: throw ParameterIncorrect (SRC_POS);
259:
260: return n;
261: }
262:
263: wstring StringConverter::ToWide (const string &str, bool noThrow)
264: {
265: try
266: {
267: mbstate_t mbState;
268: Memory::Zero (&mbState, sizeof (mbState));
269: const char *src = str.c_str();
270:
271: size_t size = mbsrtowcs (nullptr, &src, 0, &mbState);
272: if (size == -1)
273: throw StringConversionFailed (SRC_POS);
274:
275: vector <wchar_t> buf (size + 1);
276: Memory::Zero (&mbState, sizeof (mbState));
277:
278: if ((size = mbsrtowcs (&buf[0], &src, buf.size(), &mbState)) == -1)
279: throw StringConversionFailed (SRC_POS);
280:
281: wstring s;
282: s.insert (s.begin(), buf.begin(), buf.begin() + size);
283: return s;
284: }
285: catch (...)
286: {
287: if (noThrow)
288: return L"";
289: throw;
290: }
291: }
292:
293: void StringConverter::ToWideBuffer (const wstring &str, wchar_t *buffer, size_t bufferSize)
294: {
295: if (str.length() < 1)
296: {
297: buffer[0] = 0;
298: return;
299: }
300:
301: BufferPtr (
302: (byte *) buffer,
303: bufferSize).CopyFrom (
304: ConstBufferPtr ((byte *) (wstring (str).c_str()),
305: (str.length() + 1) * sizeof (wchar_t)
306: )
307: );
308: }
309:
310: string StringConverter::Trim (const string &str)
311: {
312: size_t start = 0;
313: size_t end = str.size();
314: if (end < 1)
315: return str;
316:
317: foreach (char c, str)
318: {
319: if (c > ' ')
320: break;
321: ++start;
322: }
323:
324: foreach_reverse (char c, str)
325: {
326: if (c > ' ')
327: break;
328: --end;
329: }
330:
331: return str.substr (start, end - start);
332: }
333: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.