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