6a226e1d27ac5ff356589c4e59f06c65085ebde4
[libs/core.git] / source / strings / lexicalcast.cpp
1 #include <cmath>
2 #include <limits>
3 #include <msp/core/inttypes.h>
4 #include "format.h"
5 #include "lexicalcast.h"
6
7 using namespace std;
8
9 namespace {
10
11 using namespace Msp;
12
13 template<typename T>
14 struct IsSigned
15 { enum { result = !(static_cast<T>(-1)>0) }; };
16
17 /* Helper to avoid warnings about an unsigned type never being < 0 */
18 template<typename T, bool f = IsSigned<T>::result>
19 struct IsNegative
20 { static bool eval(T v) { return v<0; } };
21
22 template<typename T>
23 struct IsNegative<T, false>
24 { static bool eval(T) { return false; } };
25
26 /* Helper to avoid errors about ambiguous function calls since there are no
27 overloads of abs for unsigned types */
28 template<typename T, bool f = IsSigned<T>::result>
29 struct Absolute
30 { static T eval(T v) { return v<0 ? -v : v; } };
31
32 template<typename T>
33 struct Absolute<T, false>
34 { static T eval(T v) { return v; } };
35
36
37 /*** Integer conversions ***/
38
39 const char udigits[] = "0123456789ABCDEF";
40 const char ldigits[] = "0123456789abcdef";
41
42 template<typename T>
43 char *int_to_str(T v, const Fmt &f, char *end)
44 {
45         if(f.get_type()==Fmt::CHAR)
46         {
47                 *--end = v;
48                 return end;
49         }
50
51         char *ptr = end;
52
53         // Find out the base to use
54         unsigned base = f.get_base();
55         if(!base)
56                 base = 10;
57
58         // Format the number, starting from the least significant digit
59         const char *digits = (f.get_uppercase() ? udigits : ldigits);
60         if(v)
61         {
62                 typename MatchingInt<T>::UnsignedType w = Absolute<T>::eval(v);
63                 while(w)
64                 {
65                         *--ptr = digits[w%base];
66                         w /= base;
67                 }
68         }
69         else
70                 *--ptr = digits[0];
71
72         char sign = (IsNegative<T>::eval(v) ? '-' : f.get_showpos() ? '+' : 0);
73         if(f.get_fill()=='0')
74         {
75                 /* Zero-fill, taking base/sign size into account.  The expression is a
76                 bit ugly, but saves having to write code for creating the prefix both
77                 ways. */
78                 unsigned pfxsize = ((f.get_showbase() && base!=10) ? base==8 ? 1 : 2 : 0) + (sign!=0);
79                 for(unsigned i=(end-ptr)+pfxsize; i<f.get_width(); ++i)
80                         *--ptr = '0';
81         }
82
83         if(f.get_showbase() && v!=0)
84         {
85                 // Add base indicator
86                 if(base==2)
87                         *--ptr = (f.get_uppercase() ? 'B' : 'b');
88                 else if(base==16)
89                         *--ptr = (f.get_uppercase() ? 'X' : 'x');
90                 if(base!=10)
91                         *--ptr = '0';
92         }
93
94         if(sign)
95                 *--ptr = sign;
96
97         return ptr;
98 }
99
100 template<typename T>
101 string int_to_str(T v, const Fmt &f)
102 {
103         unsigned size = max(f.get_width(), max<unsigned>(f.get_precision(), sizeof(T)*8+3));
104         char *buf = new char[size];
105         string result(int_to_str(v, f, buf+size), buf+size);
106         delete[] buf;
107         return result;
108 }
109
110 template<typename T>
111 T str_to_int(const std::string &s, const Fmt &f)
112 {
113         if(s.empty())
114                 throw lexical_error("conversion of '' to integer");
115
116         std::string::const_iterator i = s.begin();
117
118         // See if the input starts with a sign
119         bool neg = false;
120         if(*i=='-')
121         {
122                 if(!IsSigned<T>::result)
123                         throw lexical_error(format("conversion of '%s' to unsigned integer", s));
124                 neg = true;
125                 ++i;
126         }
127         else if(*i=='+')
128                 ++i;
129
130         // Must have some digits to convert
131         if(i==s.end())
132                 throw lexical_error(format("conversion of '%s' to integer", s));
133
134         T base = f.get_base();
135         if(!base && i!=s.end())
136         {
137                 // Automatic base detection requested, figure it out
138                 if(*i=='0' && ++i!=s.end())
139                 {
140                         if(*i=='x' || *i=='X')
141                         {
142                                 base = 16;
143                                 ++i;
144                         }
145                         else if(*i=='b' || *i=='B')
146                         {
147                                 base = 2;
148                                 ++i;
149                         }
150                         else
151                                 base = 8;
152                 }
153                 else
154                         base = 10;
155         }
156
157         // Parse the digits
158         T result = 0;
159         for(; i!=s.end(); ++i)
160         {
161                 T digit = base;
162                 if(*i>='0' && *i<='9')
163                         digit = *i-'0';
164                 else if(*i>='A' && *i<='F')
165                         digit = *i-'A'+10;
166                 else if(*i>='a' && *i<='f')
167                         digit = *i-'a'+10;
168                 if(digit>=base)
169                         throw lexical_error(format("conversion of '%s' to integer (base-%d)", s, base));
170                 T next = result*base+digit;
171                 if(next/base!=result)
172                         throw lexical_error(format("conversion of '%s' to %d-bit integer", s, sizeof(T)*8));
173                 result = next;
174         }
175
176         if(neg)
177                 result = -result;
178
179         return result;
180 }
181
182
183 /*** Boolean conversions ***/
184
185 string bool_to_str(bool b, const Fmt &f)
186 {
187         if(f.get_type()==Fmt::STR)
188                 return b ? "true" : "false";
189         else
190                 return b ? "1" : "0";
191 }
192
193 bool str_to_bool(const string &s)
194 {
195         if(s.empty())
196                 throw lexical_error("conversion of '' to boolean");
197
198         if(s=="1" || s=="true" || s=="yes" || s=="on")
199                 return true;
200         else if(s=="0" || s=="false" || s=="no" || s=="off")
201                 return false;
202
203         throw lexical_error(format("conversion of '%s' to boolean", s));
204 }
205
206
207 /*** Floating-point conversions ***/
208
209 template<typename T>
210 string flt_to_str(T v, const Fmt &f)
211 {
212         if(f.get_type()==Fmt::CHAR)
213                 throw format_mismatch("floating-point conversion with character format");
214
215         Fmt::FloatMode mode = f.get_floatmode();
216         long double w = abs(v);
217         char sign = (v<0 ? '-' : f.get_showpos() ? '+' : 0);
218
219         // Handle infinity and not-a-number as special cases
220         if(!(w+w>w) && w!=0)
221         {
222                 string result;
223                 if(sign)
224                         result += sign;
225                 if(!(w>=0))
226                         result += (f.get_uppercase() ? "NAN" : "nan");
227                 else
228                         result += (f.get_uppercase() ? "INF" : "inf");
229                 if(result.size()<f.get_width())
230                         result = string(f.get_width()-result.size(), ' ')+result;
231                 return result;
232         }
233
234         /* Find out the base-10 exponent.  Building up the multiplier / divisor
235         first helps with accuracy in some cases. */
236         int exp = 0;
237         if(w>=10)
238         {
239                 long double div = 1;
240                 while(div*10<w)
241                 {
242                         ++exp;
243                         div *= 10;
244                 }
245                 w /= div;
246         }
247         else if(mode!=Fmt::FIXED && w<1 && w!=0)
248         {
249                 long double mul = 1;
250                 while(w*mul<1)
251                 {
252                         --exp;
253                         mul *= 10;
254                 }
255                 w *= mul;
256         }
257
258         // Decide how to format the number
259         unsigned digits;
260         unsigned point = 1;
261         bool showexp = false;
262         if(mode==Fmt::FIXED)
263         {
264                 point = exp+1;
265                 digits = point+f.get_precision();
266         }
267         else if(mode==Fmt::SCI)
268         {
269                 digits = f.get_precision()+1;
270                 showexp = true;
271         }
272         else
273         {
274                 digits = max(f.get_precision(), 1U);
275                 if(exp<-4 || exp>=static_cast<int>(digits))
276                 {
277                         point = 1;
278                         showexp = true;
279                 }
280                 else
281                 {
282                         point = max(exp, 0)+1;
283                         if(exp<0)
284                                 digits += -exp;
285                 }
286         }
287
288         // Apply rounding
289         w += 5.0l/pow(10.0l, static_cast<long double>(digits));
290         if(w>10)
291         {
292                 // Rounding bumped us to the next exponent, deal with it
293                 w /= 10;
294                 if(mode==Fmt::AUTOFLT && exp+1==static_cast<int>(digits))
295                 {
296                         point = 1;
297                         showexp = true;
298                 }
299                 if(!showexp)
300                 {
301                         ++digits;
302                         ++point;
303                 }
304                 else
305                         ++exp;
306         }
307
308         // Create a buffer and start from the end
309         unsigned size = max(f.get_width(), digits+8);
310         char *buf = new char[size];
311         char *end = buf+size;
312         char *ptr = end;
313
314         // Format exponent
315         if(showexp)
316         {
317                 ptr = int_to_str(exp, Fmt().showpos().fill('0').width(3), ptr);
318                 *--ptr = (f.get_uppercase() ? 'E' : 'e');
319         }
320
321         // Format mantissa left-to-right
322         char *eptr = ptr;
323         ptr -= digits+(point<digits || f.get_showpoint());
324         char *mptr = ptr;
325         for(unsigned i=0; i<digits; ++i)
326         {
327                 if(i==point)
328                         *mptr++ = '.';
329                 if(showexp || static_cast<int>(i)>=-exp)
330                 {
331                         int digit = static_cast<int>(w);
332                         *mptr++ = '0'+digit;
333                         w = (w-digit)*10;
334                 }
335                 else
336                         *mptr++ = '0';
337         }
338
339         if(f.get_showpoint())
340         {
341                 // Radix point requested but not displayed yet, add it
342                 if(digits<=point)
343                         *mptr++ = '.';
344         }
345         else if(mode==Fmt::AUTOFLT && digits>point)
346         {
347                 // Remove trailing zeroes from fraction and a lone radix point
348                 while(mptr[-1]=='0')
349                         --mptr;
350                 if(mptr[-1]=='.')
351                         --mptr;
352                 if(mptr!=eptr)
353                 {
354                         while(mptr!=ptr)
355                                 *--eptr = *--mptr;
356                         ptr = eptr;
357                 }
358         }
359
360         // Add filling and sign
361         if(f.get_fill()=='0')
362         {
363                 unsigned pfxlen = (sign!=0);
364                 while(end-ptr+pfxlen<f.get_width())
365                         *--ptr = '0';
366         }
367         if(sign)
368                 *--ptr = sign;
369
370         string result(ptr, end);
371         delete[] buf;
372         return result;
373 }
374
375 template<typename T>
376 T str_to_flt(const string &s, const Fmt &)
377 {
378         if(s.empty())
379                 throw lexical_error("conversion of '' to floating-point");
380
381         std::string::const_iterator i = s.begin();
382
383         // See if the input starts with a sign
384         bool neg = false;
385         if(*i=='-')
386         {
387                 neg = true;
388                 ++i;
389         }
390         else if(*i=='+')
391                 ++i;
392
393         // Must have some digits to convert
394         if(i==s.end())
395                 throw lexical_error(format("conversion of '%s' to floating-point", s));
396
397         long double v = 0;
398         int exp = 0;
399
400         // Parse mantissa
401         bool point_seen = false;
402         for(; i!=s.end(); ++i)
403         {
404                 if(*i=='.')
405                 {
406                         if(point_seen)
407                                 throw lexical_error(format("conversion of '%s' to floating-point", s));
408                         point_seen = true;
409                 }
410                 else if(*i>='0' && *i<='9')
411                 {
412                         v = v*10+(*i-'0');
413                         if(point_seen)
414                                 --exp;
415                 }
416                 else if(*i=='e' || *i=='E')
417                 {
418                         // We have an exponent
419                         ++i;
420
421                         exp += str_to_int<int>(string(i, s.end()), Fmt());
422                         // str_to_int has eaten the rest of the input or thrown
423                         break;
424                 }
425                 else
426                         throw lexical_error(format("conversion of '%s' to floating-point", s));
427         }
428
429         // Scale and negate the result as needed
430         while(exp>0)
431         {
432                 v *= 10;
433                 --exp;
434         }
435         while(exp<0)
436         {
437                 v /= 10;
438                 ++exp;
439         }
440
441         if(neg)
442                 v = -v;
443
444         return v;
445 }
446
447
448 /*** String conversions ***/
449
450 string str_to_str(const string &s, const Fmt &f)
451 {
452         if(f.get_type()==Fmt::NUM)
453                 throw format_mismatch("string conversion with numeric format");
454         return s;
455 }
456
457 }
458
459 namespace Msp {
460
461 void LexicalConverter::result(const string &s)
462 {
463         if(s.size()<fmt.get_width())
464         {
465                 if(fmt.get_align()==Fmt::RIGHT)
466                         buf = string(fmt.get_width()-s.size(), fmt.get_fill())+s;
467                 else
468                         buf = s+string(fmt.get_width()-s.size(), fmt.get_fill());
469         }
470         else
471                 buf = s;
472 }
473
474
475 /*** operator<< ***/
476
477 void operator<<(LexicalConverter &c, char v)
478 {
479         Fmt::Type type = c.get_fmt().get_type();
480         if(type==Fmt::NUM)
481                 c.result(int_to_str(v, c.get_fmt()));
482         else
483                 c.result(string(1, v));
484 }
485
486 void operator<<(LexicalConverter &c, signed char v)
487 { c.result(int_to_str(v, c.get_fmt())); }
488
489 void operator<<(LexicalConverter &c, short v)
490 { c.result(int_to_str(v, c.get_fmt())); }
491
492 void operator<<(LexicalConverter &c, int v)
493 { c.result(int_to_str(v, c.get_fmt())); }
494
495 void operator<<(LexicalConverter &c, long v)
496 { c.result(int_to_str(v, c.get_fmt())); }
497
498 void operator<<(LexicalConverter &c, unsigned char v)
499 { c.result(int_to_str(v, c.get_fmt())); }
500
501 void operator<<(LexicalConverter &c, unsigned short v)
502 { c.result(int_to_str(v, c.get_fmt())); }
503
504 void operator<<(LexicalConverter &c, unsigned v)
505 { c.result(int_to_str(v, c.get_fmt())); }
506
507 void operator<<(LexicalConverter &c, unsigned long v)
508 { c.result(int_to_str(v, c.get_fmt())); }
509
510 #ifdef __GNUC__
511 void operator<<(LexicalConverter &c, long long v)
512 { c.result(int_to_str(v, c.get_fmt())); }
513
514 void operator<<(LexicalConverter &c, unsigned long long v)
515 { c.result(int_to_str(v, c.get_fmt())); }
516 #endif
517
518 void operator<<(LexicalConverter &c, bool v)
519 { c.result(bool_to_str(v, c.get_fmt())); }
520
521 void operator<<(LexicalConverter &c, float v)
522 { c.result(flt_to_str(v, c.get_fmt())); }
523
524 void operator<<(LexicalConverter &c, double v)
525 { c.result(flt_to_str(v, c.get_fmt())); }
526
527 void operator<<(LexicalConverter &c, long double v)
528 { c.result(flt_to_str(v, c.get_fmt())); }
529
530 void operator<<(LexicalConverter &c, const string &s)
531 { c.result(str_to_str(s, c.get_fmt())); }
532
533 void operator<<(LexicalConverter &c, const char *s)
534 { c.result(str_to_str(s, c.get_fmt())); }
535
536 void operator<<(LexicalConverter &c, const void *p)
537 { c.result(int_to_str(reinterpret_cast<IntPtr>(p), c.get_fmt())); }
538
539
540 /*** operator>> ***/
541
542 void operator>>(const LexicalConverter &c, char &v)
543 {
544         if(c.get_fmt().get_type()==Fmt::NUM)
545                 v = str_to_int<char>(c.get(), c.get_fmt());
546         else
547         {
548                 const std::string &s = c.get();
549                 if(s.empty())
550                         throw lexical_error("conversion of '' to character");
551                 if(s.size()>1)
552                         throw lexical_error(format("conversion of '%s' to character", s));
553                 v = s[0];
554         }
555 }
556
557 void operator>>(const LexicalConverter &c, signed char &v)
558 { v = str_to_int<signed char>(c.get(), c.get_fmt()); }
559
560 void operator>>(const LexicalConverter &c, short &v)
561 { v = str_to_int<short>(c.get(), c.get_fmt()); }
562
563 void operator>>(const LexicalConverter &c, int &v)
564 { v = str_to_int<int>(c.get(), c.get_fmt()); }
565
566 void operator>>(const LexicalConverter &c, long &v)
567 { v = str_to_int<long>(c.get(), c.get_fmt()); }
568
569 void operator>>(const LexicalConverter &c, unsigned char &v)
570 { v = str_to_int<unsigned char>(c.get(), c.get_fmt()); }
571
572 void operator>>(const LexicalConverter &c, unsigned short &v)
573 { v = str_to_int<unsigned short>(c.get(), c.get_fmt()); }
574
575 void operator>>(const LexicalConverter &c, unsigned int &v)
576 { v = str_to_int<unsigned int>(c.get(), c.get_fmt()); }
577
578 void operator>>(const LexicalConverter &c, unsigned long &v)
579 { v = str_to_int<unsigned long>(c.get(), c.get_fmt()); }
580
581 #ifdef __GNUC__
582 void operator>>(const LexicalConverter &c, long long &v)
583 { v = str_to_int<long long>(c.get(), c.get_fmt()); }
584
585 void operator>>(const LexicalConverter &c, unsigned long long &v)
586 { v = str_to_int<unsigned long long>(c.get(), c.get_fmt()); }
587 #endif
588
589 void operator>>(const LexicalConverter &c, bool &v)
590 { v = str_to_bool(c.get()); }
591
592 void operator>>(const LexicalConverter &c, float &v)
593 { v = str_to_flt<float>(c.get(), c.get_fmt()); }
594
595 void operator>>(const LexicalConverter &c, double &v)
596 { v = str_to_flt<double>(c.get(), c.get_fmt()); }
597
598 void operator>>(const LexicalConverter &c, long double &v)
599 { v = str_to_flt<long double>(c.get(), c.get_fmt()); }
600
601 void operator>>(const LexicalConverter &c, string &s)
602 { s = str_to_str(c.get(), c.get_fmt()); }
603
604 } // namespace Msp