f4b58302fe154447753f399bf81e80d86ce091cd
[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 leading_zeroes = 0;
261         unsigned point = 1;
262         bool showexp = false;
263         if(mode==Fmt::FIXED)
264         {
265                 point = exp+1;
266                 digits = point+f.get_precision();
267         }
268         else if(mode==Fmt::SCI)
269         {
270                 digits = f.get_precision()+1;
271                 showexp = true;
272         }
273         else
274         {
275                 digits = max(f.get_precision(), 1U);
276                 if(exp<-4 || exp>=static_cast<int>(digits))
277                 {
278                         point = 1;
279                         showexp = true;
280                 }
281                 else
282                 {
283                         if(exp<0)
284                                 leading_zeroes = -exp;
285                         else
286                                 point = exp+1;
287                 }
288         }
289
290         // Apply rounding
291         w += 5.0l/pow(10.0l, static_cast<long double>(digits));
292         if(w>=10)
293         {
294                 // Rounding bumped us to the next exponent, deal with it
295                 w /= 10;
296                 if(mode==Fmt::AUTOFLT && exp+1==static_cast<int>(digits))
297                 {
298                         point = 1;
299                         showexp = true;
300                 }
301                 if(!showexp)
302                 {
303                         if(mode==Fmt::FIXED)
304                                 ++digits;
305                         if(leading_zeroes)
306                                 --leading_zeroes;
307                         else
308                                 ++point;
309                 }
310                 else
311                         ++exp;
312         }
313
314         digits += leading_zeroes;
315
316         // Create a buffer and start from the end
317         unsigned size = max(f.get_width(), digits+8);
318         char *buf = new char[size];
319         char *end = buf+size;
320         char *ptr = end;
321
322         // Format exponent
323         if(showexp)
324         {
325                 ptr = int_to_str(exp, Fmt().showpos().fill('0').width(3), ptr);
326                 *--ptr = (f.get_uppercase() ? 'E' : 'e');
327         }
328
329         // Format mantissa left-to-right
330         char *eptr = ptr;
331         ptr -= digits+(point<digits || f.get_showpoint());
332         char *mptr = ptr;
333         for(unsigned i=0; i<digits; ++i)
334         {
335                 if(i==point)
336                         *mptr++ = '.';
337                 if(!leading_zeroes)
338                 {
339                         int digit = static_cast<int>(w);
340                         *mptr++ = '0'+digit;
341                         w = (w-digit)*10;
342                 }
343                 else
344                 {
345                         *mptr++ = '0';
346                         --leading_zeroes;
347                 }
348         }
349
350         if(f.get_showpoint())
351         {
352                 // Radix point requested but not displayed yet, add it
353                 if(digits<=point)
354                         *mptr++ = '.';
355         }
356         else if(mode==Fmt::AUTOFLT && digits>point)
357         {
358                 // Remove trailing zeroes from fraction and a lone radix point
359                 while(mptr[-1]=='0')
360                         --mptr;
361                 if(mptr[-1]=='.')
362                         --mptr;
363                 if(mptr!=eptr)
364                 {
365                         while(mptr!=ptr)
366                                 *--eptr = *--mptr;
367                         ptr = eptr;
368                 }
369         }
370
371         // Add filling and sign
372         if(f.get_fill()=='0')
373         {
374                 unsigned pfxlen = (sign!=0);
375                 while(end-ptr+pfxlen<f.get_width())
376                         *--ptr = '0';
377         }
378         if(sign)
379                 *--ptr = sign;
380
381         string result(ptr, end);
382         delete[] buf;
383         return result;
384 }
385
386 template<typename T>
387 T str_to_flt(const string &s, const Fmt &)
388 {
389         if(s.empty())
390                 throw lexical_error("conversion of '' to floating-point");
391
392         std::string::const_iterator i = s.begin();
393
394         // See if the input starts with a sign
395         bool neg = false;
396         if(*i=='-')
397         {
398                 neg = true;
399                 ++i;
400         }
401         else if(*i=='+')
402                 ++i;
403
404         // Must have some digits to convert
405         if(i==s.end())
406                 throw lexical_error(format("conversion of '%s' to floating-point", s));
407
408         long double v = 0;
409         int exp = 0;
410
411         // Parse mantissa
412         bool point_seen = false;
413         for(; i!=s.end(); ++i)
414         {
415                 if(*i=='.')
416                 {
417                         if(point_seen)
418                                 throw lexical_error(format("conversion of '%s' to floating-point", s));
419                         point_seen = true;
420                 }
421                 else if(*i>='0' && *i<='9')
422                 {
423                         v = v*10+(*i-'0');
424                         if(point_seen)
425                                 --exp;
426                 }
427                 else if(*i=='e' || *i=='E')
428                 {
429                         // We have an exponent
430                         ++i;
431
432                         exp += str_to_int<int>(string(i, s.end()), Fmt());
433                         // str_to_int has eaten the rest of the input or thrown
434                         break;
435                 }
436                 else
437                         throw lexical_error(format("conversion of '%s' to floating-point", s));
438         }
439
440         // Scale and negate the result as needed
441         while(exp>0)
442         {
443                 v *= 10;
444                 --exp;
445         }
446         while(exp<0)
447         {
448                 v /= 10;
449                 ++exp;
450         }
451
452         if(neg)
453                 v = -v;
454
455         return v;
456 }
457
458
459 /*** String conversions ***/
460
461 string str_to_str(const string &s, const Fmt &f)
462 {
463         if(f.get_type()==Fmt::NUM)
464                 throw format_mismatch("string conversion with numeric format");
465         return s;
466 }
467
468 }
469
470 namespace Msp {
471
472 void LexicalConverter::result(const string &s)
473 {
474         filled = true;
475         if(s.size()<fmt.get_width())
476         {
477                 if(fmt.get_align()==Fmt::RIGHT)
478                         buf = string(fmt.get_width()-s.size(), fmt.get_fill())+s;
479                 else
480                         buf = s+string(fmt.get_width()-s.size(), fmt.get_fill());
481         }
482         else
483                 buf = s;
484 }
485
486 const string &LexicalConverter::get() const
487 {
488         if(!filled)
489                 throw lexical_error("conversion not performed");
490         return buf;
491 }
492
493
494 /*** operator<< ***/
495
496 void operator<<(LexicalConverter &c, char v)
497 {
498         Fmt::Type type = c.get_fmt().get_type();
499         if(type==Fmt::NUM)
500                 c.result(int_to_str(v, c.get_fmt()));
501         else
502                 c.result(string(1, v));
503 }
504
505 void operator<<(LexicalConverter &c, signed char v)
506 { c.result(int_to_str(v, c.get_fmt())); }
507
508 void operator<<(LexicalConverter &c, short v)
509 { c.result(int_to_str(v, c.get_fmt())); }
510
511 void operator<<(LexicalConverter &c, int v)
512 { c.result(int_to_str(v, c.get_fmt())); }
513
514 void operator<<(LexicalConverter &c, long v)
515 { c.result(int_to_str(v, c.get_fmt())); }
516
517 void operator<<(LexicalConverter &c, unsigned char v)
518 { c.result(int_to_str(v, c.get_fmt())); }
519
520 void operator<<(LexicalConverter &c, unsigned short v)
521 { c.result(int_to_str(v, c.get_fmt())); }
522
523 void operator<<(LexicalConverter &c, unsigned v)
524 { c.result(int_to_str(v, c.get_fmt())); }
525
526 void operator<<(LexicalConverter &c, unsigned long v)
527 { c.result(int_to_str(v, c.get_fmt())); }
528
529 #ifdef __GNUC__
530 void operator<<(LexicalConverter &c, long long v)
531 { c.result(int_to_str(v, c.get_fmt())); }
532
533 void operator<<(LexicalConverter &c, unsigned long long v)
534 { c.result(int_to_str(v, c.get_fmt())); }
535 #endif
536
537 void operator<<(LexicalConverter &c, bool v)
538 { c.result(bool_to_str(v, c.get_fmt())); }
539
540 void operator<<(LexicalConverter &c, float v)
541 { c.result(flt_to_str(v, c.get_fmt())); }
542
543 void operator<<(LexicalConverter &c, double v)
544 { c.result(flt_to_str(v, c.get_fmt())); }
545
546 void operator<<(LexicalConverter &c, long double v)
547 { c.result(flt_to_str(v, c.get_fmt())); }
548
549 void operator<<(LexicalConverter &c, const string &s)
550 { c.result(str_to_str(s, c.get_fmt())); }
551
552 void operator<<(LexicalConverter &c, const char *s)
553 { c.result(str_to_str(s, c.get_fmt())); }
554
555 void operator<<(LexicalConverter &c, const void *p)
556 { c.result(int_to_str(reinterpret_cast<IntPtr>(p), c.get_fmt())); }
557
558
559 /*** operator>> ***/
560
561 void operator>>(const LexicalConverter &c, char &v)
562 {
563         if(c.get_fmt().get_type()==Fmt::NUM)
564                 v = str_to_int<char>(c.get(), c.get_fmt());
565         else
566         {
567                 const std::string &s = c.get();
568                 if(s.empty())
569                         throw lexical_error("conversion of '' to character");
570                 if(s.size()>1)
571                         throw lexical_error(format("conversion of '%s' to character", s));
572                 v = s[0];
573         }
574 }
575
576 void operator>>(const LexicalConverter &c, signed char &v)
577 { v = str_to_int<signed char>(c.get(), c.get_fmt()); }
578
579 void operator>>(const LexicalConverter &c, short &v)
580 { v = str_to_int<short>(c.get(), c.get_fmt()); }
581
582 void operator>>(const LexicalConverter &c, int &v)
583 { v = str_to_int<int>(c.get(), c.get_fmt()); }
584
585 void operator>>(const LexicalConverter &c, long &v)
586 { v = str_to_int<long>(c.get(), c.get_fmt()); }
587
588 void operator>>(const LexicalConverter &c, unsigned char &v)
589 { v = str_to_int<unsigned char>(c.get(), c.get_fmt()); }
590
591 void operator>>(const LexicalConverter &c, unsigned short &v)
592 { v = str_to_int<unsigned short>(c.get(), c.get_fmt()); }
593
594 void operator>>(const LexicalConverter &c, unsigned int &v)
595 { v = str_to_int<unsigned int>(c.get(), c.get_fmt()); }
596
597 void operator>>(const LexicalConverter &c, unsigned long &v)
598 { v = str_to_int<unsigned long>(c.get(), c.get_fmt()); }
599
600 #ifdef __GNUC__
601 void operator>>(const LexicalConverter &c, long long &v)
602 { v = str_to_int<long long>(c.get(), c.get_fmt()); }
603
604 void operator>>(const LexicalConverter &c, unsigned long long &v)
605 { v = str_to_int<unsigned long long>(c.get(), c.get_fmt()); }
606 #endif
607
608 void operator>>(const LexicalConverter &c, bool &v)
609 { v = str_to_bool(c.get()); }
610
611 void operator>>(const LexicalConverter &c, float &v)
612 { v = str_to_flt<float>(c.get(), c.get_fmt()); }
613
614 void operator>>(const LexicalConverter &c, double &v)
615 { v = str_to_flt<double>(c.get(), c.get_fmt()); }
616
617 void operator>>(const LexicalConverter &c, long double &v)
618 { v = str_to_flt<long double>(c.get(), c.get_fmt()); }
619
620 void operator>>(const LexicalConverter &c, string &s)
621 { s = str_to_str(c.get(), c.get_fmt()); }
622
623 } // namespace Msp