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