examples/reflection-demo/pico-json.h

   1 /*
   2  * Copyright 2009-2010 Cybozu Labs, Inc.
   3  * Copyright 2011-2014 Kazuho Oku
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions are met:
   8  *
   9  * 1. Redistributions of source code must retain the above copyright notice,
  10  *    this list of conditions and the following disclaimer.
  11  *
  12  * 2. Redistributions in binary form must reproduce the above copyright notice,
  13  *    this list of conditions and the following disclaimer in the documentation
  14  *    and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
  20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  26  * POSSIBILITY OF SUCH DAMAGE.
  27  */
  28 #ifndef picojson_h
  29 #define picojson_h
  30
  31 #include <algorithm>
  32 #include <cstdio>
  33 #include <cstdlib>
  34 #include <cstring>
  35 #include <cstddef>
  36 #include <iostream>
  37 #include <iterator>
  38 #include <limits>
  39 #include <map>
  40 #include <stdexcept>
  41 #include <string>
  42 #include <vector>
  43 #include <utility>
  44
  45 // for isnan/isinf
  46 #if __cplusplus>=201103L
  47 # include <cmath>
  48 #else
  49 extern "C" {
  50 # ifdef _MSC_VER
  51 #  include <float.h>
  52 # elif defined(__INTEL_COMPILER)
  53 #  include <mathimf.h>
  54 # else
  55 #  include <math.h>
  56 # endif
  57 }
  58 #endif
  59
  60 #ifndef PICOJSON_USE_RVALUE_REFERENCE
  61 # if (defined(__cpp_rvalue_references) && __cpp_rvalue_references >= 200610) || (defined(_MSC_VER) && _MSC_VER >= 1600)
  62 #  define PICOJSON_USE_RVALUE_REFERENCE 1
  63 # else
  64 #  define PICOJSON_USE_RVALUE_REFERENCE 0
  65 # endif
  66 #endif//PICOJSON_USE_RVALUE_REFERENCE
  67
  68
  69 // experimental support for int64_t (see README.mkdn for detail)
  70 #ifdef PICOJSON_USE_INT64
  71 # define __STDC_FORMAT_MACROS
  72 # include <errno.h>
  73 # include <inttypes.h>
  74 #endif
  75
  76 // to disable the use of localeconv(3), set PICOJSON_USE_LOCALE to 0
  77 #ifndef PICOJSON_USE_LOCALE
  78 # define PICOJSON_USE_LOCALE 1
  79 #endif
  80 #if PICOJSON_USE_LOCALE
  81 extern "C" {
  82 # include <locale.h>
  83 }
  84 #endif
  85
  86 #ifndef PICOJSON_ASSERT
  87 # define PICOJSON_ASSERT(e) do { if (! (e)) throw std::runtime_error(#e); } while (0)
  88 #endif
  89
  90 #ifdef _MSC_VER
  91 #define SNPRINTF _snprintf_s
  92     #pragma warning(push)
  93     #pragma warning(disable : 4244) // conversion from int to char
  94     #pragma warning(disable : 4127) // conditional expression is constant
  95     #pragma warning(disable : 4702) // unreachable code
  96 #else
  97 #define SNPRINTF snprintf
  98 #endif
  99
 100 namespace picojson {
 101
 102 enum {
 103   null_type,
 104   boolean_type,
 105   number_type,
 106   string_type,
 107   array_type,
 108   object_type
 109 #ifdef PICOJSON_USE_INT64
 110   , int64_type
 111 #endif
 112 };
 113
 114 enum {
 115   INDENT_WIDTH = 2
 116 };
 117
 118 struct null {};
 119
 120 class value {
 121 public:
 122   typedef std::vector<value> array;
 123   typedef std::map<std::string, value> object;
 124   union _storage {
 125     bool boolean_;
 126     double number_;
 127 #ifdef PICOJSON_USE_INT64
 128     int64_t int64_;
 129 #endif
 130     std::string* string_;
 131     array* array_;
 132     object* object_;
 133   };
 134 protected:
 135   int type_;
 136   _storage u_;
 137 public:
 138   value();
 139   value(int type, bool);
 140   explicit value(bool b);
 141 #ifdef PICOJSON_USE_INT64
 142   explicit value(int64_t i);
 143 #endif
 144   explicit value(double n);
 145   explicit value(const std::string& s);
 146   explicit value(const array& a);
 147   explicit value(const object& o);
 148   explicit value(const char* s);
 149   value(const char* s, size_t len);
 150   ~value();
 151   value(const value& x);
 152   value& operator=(const value& x);
 153 #if PICOJSON_USE_RVALUE_REFERENCE
 154   value(value&& x)throw();
 155   value& operator=(value&& x)throw();
 156 #endif
 157   void swap(value& x)throw();
 158   template <typename T> bool is() const;
 159   template <typename T> const T& get() const;
 160   template <typename T> T& get();
 161   template <typename T> void set(const T &);
 162 #if PICOJSON_USE_RVALUE_REFERENCE
 163   template <typename T> void set(T &&);
 164 #endif
 165   bool evaluate_as_boolean() const;
 166   const value& get(size_t idx) const;
 167   const value& get(const std::string& key) const;
 168   value& get(size_t idx);
 169   value& get(const std::string& key);
 170
 171   bool contains(size_t idx) const;
 172   bool contains(const std::string& key) const;
 173   std::string to_str() const;
 174   template <typename Iter> void serialize(Iter os, bool prettify = false) const;
 175   std::string serialize(bool prettify = false) const;
 176 private:
 177   template <typename T> value(const T*); // intentionally defined to block implicit conversion of pointer to bool
 178   template <typename Iter> static void _indent(Iter os, int indent);
 179   template <typename Iter> void _serialize(Iter os, int indent) const;
 180   std::string _serialize(int indent) const;
 181   void clear();
 182 };
 183
 184 typedef value::array array;
 185 typedef value::object object;
 186
 187 inline value::value() : type_(null_type) {}
 188
 189 inline value::value(int type, bool) : type_(type) {
 190   switch (type) {
 191 #define INIT(p, v) case p##type: u_.p = v; break
 192     INIT(boolean_, false);
 193     INIT(number_, 0.0);
 194 #ifdef PICOJSON_USE_INT64
 195     INIT(int64_, 0);
 196 #endif
 197     INIT(string_, new std::string());
 198     INIT(array_, new array());
 199     INIT(object_, new object());
 200 #undef INIT
 201     default: break;
 202   }
 203 }
 204
 205 inline value::value(bool b) : type_(boolean_type) {
 206   u_.boolean_ = b;
 207 }
 208
 209 #ifdef PICOJSON_USE_INT64
 210 inline value::value(int64_t i) : type_(int64_type) {
 211     u_.int64_ = i;
 212   }
 213 #endif
 214
 215 inline value::value(double n) : type_(number_type) {
 216   if (
 217 #ifdef _MSC_VER
 218 ! _finite(n)
 219 #elif __cplusplus>=201103L || !(defined(isnan) && defined(isinf))
 220 std::isnan(n) || std::isinf(n)
 221 #else
 222     isnan(n) || isinf(n)
 223 #endif
 224     ) {
 225     throw std::overflow_error("");
 226   }
 227   u_.number_ = n;
 228 }
 229
 230 inline value::value(const std::string& s) : type_(string_type) {
 231   u_.string_ = new std::string(s);
 232 }
 233
 234 inline value::value(const array& a) : type_(array_type) {
 235   u_.array_ = new array(a);
 236 }
 237
 238 inline value::value(const object& o) : type_(object_type) {
 239   u_.object_ = new object(o);
 240 }
 241
 242 inline value::value(const char* s) : type_(string_type) {
 243   u_.string_ = new std::string(s);
 244 }
 245
 246 inline value::value(const char* s, size_t len) : type_(string_type) {
 247   u_.string_ = new std::string(s, len);
 248 }
 249
 250 inline void value::clear() {
 251   switch (type_) {
 252 #define DEINIT(p) case p##type: delete u_.p; break
 253     DEINIT(string_);
 254     DEINIT(array_);
 255     DEINIT(object_);
 256 #undef DEINIT
 257     default: break;
 258   }
 259 }
 260
 261 inline value::~value() {
 262   clear();
 263 }
 264
 265 inline value::value(const value& x) : type_(x.type_) {
 266   switch (type_) {
 267 #define INIT(p, v) case p##type: u_.p = v; break
 268     INIT(string_, new std::string(*x.u_.string_));
 269     INIT(array_, new array(*x.u_.array_));
 270     INIT(object_, new object(*x.u_.object_));
 271 #undef INIT
 272     default:
 273       u_ = x.u_;
 274       break;
 275   }
 276 }
 277
 278 inline value& value::operator=(const value& x) {
 279   if (this != &x) {
 280     value t(x);
 281     swap(t);
 282   }
 283   return *this;
 284 }
 285
 286 #if PICOJSON_USE_RVALUE_REFERENCE
 287 inline value::value(value&& x)throw() : type_(null_type) {
 288   swap(x);
 289 }
 290 inline value& value::operator=(value&& x)throw() {
 291   swap(x);
 292   return *this;
 293 }
 294 #endif
 295 inline void value::swap(value& x)throw() {
 296   std::swap(type_, x.type_);
 297   std::swap(u_, x.u_);
 298 }
 299
 300 #define IS(ctype, jtype)                             \
 301   template <> inline bool value::is<ctype>() const { \
 302     return type_ == jtype##_type;                    \
 303   }
 304 IS(null, null)
 305 IS(bool, boolean)
 306 #ifdef PICOJSON_USE_INT64
 307 IS(int64_t, int64)
 308 #endif
 309 IS(std::string, string)
 310 IS(array, array)
 311 IS(object, object)
 312 #undef IS
 313 template <> inline bool value::is<double>() const {
 314   return type_ == number_type
 315 #ifdef PICOJSON_USE_INT64
 316     || type_ == int64_type
 317 #endif
 318     ;
 319 }
 320
 321 #define GET(ctype, var)                                         \
 322   template <> inline const ctype& value::get<ctype>() const {   \
 323     PICOJSON_ASSERT("type mismatch! call is<type>() before get<type>()" \
 324            && is<ctype>());                                     \
 325     return var;                                                 \
 326   }                                                             \
 327   template <> inline ctype& value::get<ctype>() {               \
 328     PICOJSON_ASSERT("type mismatch! call is<type>() before get<type>()" \
 329            && is<ctype>());                                     \
 330     return var;                                                 \
 331   }
 332 GET(bool, u_.boolean_)
 333 GET(std::string, *u_.string_)
 334 GET(array, *u_.array_)
 335 GET(object, *u_.object_)
 336 #ifdef PICOJSON_USE_INT64
 337 GET(double, (type_ == int64_type && (const_cast<value*>(this)->type_ = number_type, const_cast<value*>(this)->u_.number_ = u_.int64_), u_.number_))
 338   GET(int64_t, u_.int64_)
 339 #else
 340 GET(double, u_.number_)
 341 #endif
 342 #undef GET
 343
 344 #define SET(ctype, jtype, setter)           \
 345   template <> inline void value::set<ctype>(const ctype &_val) {  \
 346     clear();                      \
 347     type_ = jtype##_type;         \
 348     setter                        \
 349   }
 350 SET(bool, boolean, u_.boolean_ = _val;)
 351 SET(std::string, string, u_.string_ = new std::string(_val);)
 352 SET(array, array, u_.array_ = new array(_val);)
 353 SET(object, object, u_.object_ = new object(_val);)
 354 SET(double, number, u_.number_ = _val;)
 355 #ifdef PICOJSON_USE_INT64
 356 SET(int64_t, int64, u_.int64_ = _val;)
 357 #endif
 358 #undef SET
 359
 360 #if PICOJSON_USE_RVALUE_REFERENCE
 361 #define MOVESET(ctype, jtype, setter)       \
 362   template <> inline void value::set<ctype>(ctype &&_val) {     \
 363     clear();                      \
 364     type_ = jtype##_type;         \
 365     setter                        \
 366   }
 367 MOVESET(std::string, string, u_.string_ = new std::string(std::move(_val));)
 368 MOVESET(array, array, u_.array_ = new array(std::move(_val));)
 369 MOVESET(object, object, u_.object_ = new object(std::move(_val));)
 370 #undef MOVESET
 371 #endif
 372
 373 inline bool value::evaluate_as_boolean() const {
 374   switch (type_) {
 375     case null_type:
 376       return false;
 377     case boolean_type:
 378       return u_.boolean_;
 379     case number_type:
 380       return u_.number_ != 0;
 381 #ifdef PICOJSON_USE_INT64
 382     case int64_type:
 383       return u_.int64_ != 0;
 384 #endif
 385     case string_type:
 386       return ! u_.string_->empty();
 387     default:
 388       return true;
 389   }
 390 }
 391
 392 inline const value& value::get(size_t idx) const {
 393   static value s_null;
 394   PICOJSON_ASSERT(is<array>());
 395   return idx < u_.array_->size() ? (*u_.array_)[idx] : s_null;
 396 }
 397
 398 inline value& value::get(size_t idx) {
 399   static value s_null;
 400   PICOJSON_ASSERT(is<array>());
 401   return idx < u_.array_->size() ? (*u_.array_)[idx] : s_null;
 402 }
 403
 404 inline const value& value::get(const std::string& key) const {
 405   static value s_null;
 406   PICOJSON_ASSERT(is<object>());
 407   object::const_iterator i = u_.object_->find(key);
 408   return i != u_.object_->end() ? i->second : s_null;
 409 }
 410
 411 inline value& value::get(const std::string& key) {
 412   static value s_null;
 413   PICOJSON_ASSERT(is<object>());
 414   object::iterator i = u_.object_->find(key);
 415   return i != u_.object_->end() ? i->second : s_null;
 416 }
 417
 418 inline bool value::contains(size_t idx) const {
 419   PICOJSON_ASSERT(is<array>());
 420   return idx < u_.array_->size();
 421 }
 422
 423 inline bool value::contains(const std::string& key) const {
 424   PICOJSON_ASSERT(is<object>());
 425   object::const_iterator i = u_.object_->find(key);
 426   return i != u_.object_->end();
 427 }
 428
 429 inline std::string value::to_str() const {
 430   switch (type_) {
 431     case null_type:      return "null";
 432     case boolean_type:   return u_.boolean_ ? "true" : "false";
 433 #ifdef PICOJSON_USE_INT64
 434     case int64_type: {
 435       char buf[sizeof("-9223372036854775808")];
 436       SNPRINTF(buf, sizeof(buf), "%" PRId64, u_.int64_);
 437       return buf;
 438     }
 439 #endif
 440     case number_type:    {
 441       char buf[256];
 442       double tmp;
 443       SNPRINTF(buf, sizeof(buf), fabs(u_.number_) < (1ULL << 53) && modf(u_.number_, &tmp) == 0 ? "%.f" : "%.17g", u_.number_);
 444 #if PICOJSON_USE_LOCALE
 445       char *decimal_point = localeconv()->decimal_point;
 446       if (strcmp(decimal_point, ".") != 0) {
 447         size_t decimal_point_len = strlen(decimal_point);
 448         for (char *p = buf; *p != '\0'; ++p) {
 449           if (strncmp(p, decimal_point, decimal_point_len) == 0) {
 450             return std::string(buf, p) + "." + (p + decimal_point_len);
 451           }
 452         }
 453       }
 454 #endif
 455       return buf;
 456     }
 457     case string_type:    return *u_.string_;
 458     case array_type:     return "array";
 459     case object_type:    return "object";
 460     default:             PICOJSON_ASSERT(0);
 461 #ifdef _MSC_VER
 462       __assume(0);
 463 #endif
 464   }
 465   return std::string();
 466 }
 467
 468 template <typename Iter> void copy(const std::string& s, Iter oi) {
 469   std::copy(s.begin(), s.end(), oi);
 470 }
 471
 472 template <typename Iter>
 473 struct serialize_str_char {
 474   Iter oi;
 475   void operator()(char c) {
 476     switch (c) {
 477 #define MAP(val, sym) case val: copy(sym, oi); break
 478       MAP('"', "\\\"");
 479       MAP('\\', "\\\\");
 480       MAP('/', "\\/");
 481       MAP('\b', "\\b");
 482       MAP('\f', "\\f");
 483       MAP('\n', "\\n");
 484       MAP('\r', "\\r");
 485       MAP('\t', "\\t");
 486 #undef MAP
 487       default:
 488         if (static_cast<unsigned char>(c) < 0x20 || c == 0x7f) {
 489           char buf[7];
 490           SNPRINTF(buf, sizeof(buf), "\\u%04x", c & 0xff);
 491           copy(buf, buf + 6, oi);
 492         } else {
 493           *oi++ = c;
 494         }
 495         break;
 496     }
 497   }
 498 };
 499
 500 template <typename Iter> void serialize_str(const std::string& s, Iter oi) {
 501   *oi++ = '"';
 502   serialize_str_char<Iter> process_char = { oi };
 503   std::for_each(s.begin(), s.end(), process_char);
 504   *oi++ = '"';
 505 }
 506
 507 template <typename Iter> void value::serialize(Iter oi, bool prettify) const {
 508   return _serialize(oi, prettify ? 0 : -1);
 509 }
 510
 511 inline std::string value::serialize(bool prettify) const {
 512   return _serialize(prettify ? 0 : -1);
 513 }
 514
 515 template <typename Iter> void value::_indent(Iter oi, int indent) {
 516   *oi++ = '\n';
 517   for (int i = 0; i < indent * INDENT_WIDTH; ++i) {
 518     *oi++ = ' ';
 519   }
 520 }
 521
 522 template <typename Iter> void value::_serialize(Iter oi, int indent) const {
 523   switch (type_) {
 524     case string_type:
 525       serialize_str(*u_.string_, oi);
 526       break;
 527     case array_type: {
 528       *oi++ = '[';
 529       if (indent != -1) {
 530         ++indent;
 531       }
 532       for (array::const_iterator i = u_.array_->begin();
 533            i != u_.array_->end();
 534            ++i) {
 535         if (i != u_.array_->begin()) {
 536           *oi++ = ',';
 537         }
 538         if (indent != -1) {
 539           _indent(oi, indent);
 540         }
 541         i->_serialize(oi, indent);
 542       }
 543       if (indent != -1) {
 544         --indent;
 545         if (! u_.array_->empty()) {
 546           _indent(oi, indent);
 547         }
 548       }
 549       *oi++ = ']';
 550       break;
 551     }
 552     case object_type: {
 553       *oi++ = '{';
 554       if (indent != -1) {
 555         ++indent;
 556       }
 557       for (object::const_iterator i = u_.object_->begin();
 558            i != u_.object_->end();
 559            ++i) {
 560         if (i != u_.object_->begin()) {
 561           *oi++ = ',';
 562         }
 563         if (indent != -1) {
 564           _indent(oi, indent);
 565         }
 566         serialize_str(i->first, oi);
 567         *oi++ = ':';
 568         if (indent != -1) {
 569           *oi++ = ' ';
 570         }
 571         i->second._serialize(oi, indent);
 572       }
 573       if (indent != -1) {
 574         --indent;
 575         if (! u_.object_->empty()) {
 576           _indent(oi, indent);
 577         }
 578       }
 579       *oi++ = '}';
 580       break;
 581     }
 582     default:
 583       copy(to_str(), oi);
 584       break;
 585   }
 586   if (indent == 0) {
 587     *oi++ = '\n';
 588   }
 589 }
 590
 591 inline std::string value::_serialize(int indent) const {
 592   std::string s;
 593   _serialize(std::back_inserter(s), indent);
 594   return s;
 595 }
 596
 597 template <typename Iter> class input {
 598 protected:
 599   Iter cur_, end_;
 600   bool consumed_;
 601   int line_;
 602 public:
 603   input(const Iter& first, const Iter& last) : cur_(first), end_(last), consumed_(false), line_(1) {}
 604   int getc() {
 605     if (consumed_) {
 606       if (*cur_ == '\n') {
 607         ++line_;
 608       }
 609       ++cur_;
 610     }
 611     if (cur_ == end_) {
 612       consumed_ = false;
 613       return -1;
 614     }
 615     consumed_ = true;
 616     return *cur_ & 0xff;
 617   }
 618   void ungetc() {
 619     consumed_ = false;
 620   }
 621   Iter cur() const {
 622     if (consumed_) {
 623       input<Iter> *self = const_cast<input<Iter>*>(this);
 624       self->consumed_ = false;
 625       ++self->cur_;
 626     }
 627     return cur_;
 628   }
 629   int line() const { return line_; }
 630   void skip_ws() {
 631     while (1) {
 632       int ch = getc();
 633       if (! (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r')) {
 634         ungetc();
 635         break;
 636       }
 637     }
 638   }
 639   bool expect(int expect) {
 640     skip_ws();
 641     if (getc() != expect) {
 642       ungetc();
 643       return false;
 644     }
 645     return true;
 646   }
 647   bool match(const std::string& pattern) {
 648     for (std::string::const_iterator pi(pattern.begin());
 649          pi != pattern.end();
 650          ++pi) {
 651       if (getc() != *pi) {
 652         ungetc();
 653         return false;
 654       }
 655     }
 656     return true;
 657   }
 658 };
 659
 660 template<typename Iter> inline int _parse_quadhex(input<Iter> &in) {
 661   int uni_ch = 0, hex;
 662   for (int i = 0; i < 4; i++) {
 663     if ((hex = in.getc()) == -1) {
 664       return -1;
 665     }
 666     if ('0' <= hex && hex <= '9') {
 667       hex -= '0';
 668     } else if ('A' <= hex && hex <= 'F') {
 669       hex -= 'A' - 0xa;
 670     } else if ('a' <= hex && hex <= 'f') {
 671       hex -= 'a' - 0xa;
 672     } else {
 673       in.ungetc();
 674       return -1;
 675     }
 676     uni_ch = uni_ch * 16 + hex;
 677   }
 678   return uni_ch;
 679 }
 680
 681 template<typename String, typename Iter> inline bool _parse_codepoint(String& out, input<Iter>& in) {
 682   int uni_ch;
 683   if ((uni_ch = _parse_quadhex(in)) == -1) {
 684     return false;
 685   }
 686   if (0xd800 <= uni_ch && uni_ch <= 0xdfff) {
 687     if (0xdc00 <= uni_ch) {
 688       // a second 16-bit of a surrogate pair appeared
 689       return false;
 690     }
 691     // first 16-bit of surrogate pair, get the next one
 692     if (in.getc() != '\\' || in.getc() != 'u') {
 693       in.ungetc();
 694       return false;
 695     }
 696     int second = _parse_quadhex(in);
 697     if (! (0xdc00 <= second && second <= 0xdfff)) {
 698       return false;
 699     }
 700     uni_ch = ((uni_ch - 0xd800) << 10) | ((second - 0xdc00) & 0x3ff);
 701     uni_ch += 0x10000;
 702   }
 703   if (uni_ch < 0x80) {
 704     out.push_back(uni_ch);
 705   } else {
 706     if (uni_ch < 0x800) {
 707       out.push_back(0xc0 | (uni_ch >> 6));
 708     } else {
 709       if (uni_ch < 0x10000) {
 710         out.push_back(0xe0 | (uni_ch >> 12));
 711       } else {
 712         out.push_back(0xf0 | (uni_ch >> 18));
 713         out.push_back(0x80 | ((uni_ch >> 12) & 0x3f));
 714       }
 715       out.push_back(0x80 | ((uni_ch >> 6) & 0x3f));
 716     }
 717     out.push_back(0x80 | (uni_ch & 0x3f));
 718   }
 719   return true;
 720 }
 721
 722 template<typename String, typename Iter> inline bool _parse_string(String& out, input<Iter>& in) {
 723   while (1) {
 724     int ch = in.getc();
 725     if (ch < ' ') {
 726       in.ungetc();
 727       return false;
 728     } else if (ch == '"') {
 729       return true;
 730     } else if (ch == '\\') {
 731       if ((ch = in.getc()) == -1) {
 732         return false;
 733       }
 734       switch (ch) {
 735 #define MAP(sym, val) case sym: out.push_back(val); break
 736         MAP('"', '\"');
 737         MAP('\\', '\\');
 738         MAP('/', '/');
 739         MAP('b', '\b');
 740         MAP('f', '\f');
 741         MAP('n', '\n');
 742         MAP('r', '\r');
 743         MAP('t', '\t');
 744 #undef MAP
 745         case 'u':
 746           if (! _parse_codepoint(out, in)) {
 747             return false;
 748           }
 749           break;
 750         default:
 751           return false;
 752       }
 753     } else {
 754       out.push_back(ch);
 755     }
 756   }
 757   return false;
 758 }
 759
 760 template <typename Context, typename Iter> inline bool _parse_array(Context& ctx, input<Iter>& in) {
 761   if (! ctx.parse_array_start()) {
 762     return false;
 763   }
 764   size_t idx = 0;
 765   if (in.expect(']')) {
 766     return ctx.parse_array_stop(idx);
 767   }
 768   do {
 769     if (! ctx.parse_array_item(in, idx)) {
 770       return false;
 771     }
 772     idx++;
 773   } while (in.expect(','));
 774   return in.expect(']') && ctx.parse_array_stop(idx);
 775 }
 776
 777 template <typename Context, typename Iter> inline bool _parse_object(Context& ctx, input<Iter>& in) {
 778   if (! ctx.parse_object_start()) {
 779     return false;
 780   }
 781   if (in.expect('}')) {
 782     return true;
 783   }
 784   do {
 785     std::string key;
 786     if (! in.expect('"')
 787         || ! _parse_string(key, in)
 788         || ! in.expect(':')) {
 789       return false;
 790     }
 791     if (! ctx.parse_object_item(in, key)) {
 792       return false;
 793     }
 794   } while (in.expect(','));
 795   return in.expect('}');
 796 }
 797
 798 template <typename Iter> inline std::string _parse_number(input<Iter>& in) {
 799   std::string num_str;
 800   while (1) {
 801     int ch = in.getc();
 802     if (('0' <= ch && ch <= '9') || ch == '+' || ch == '-'
 803         || ch == 'e' || ch == 'E') {
 804       num_str.push_back(ch);
 805     } else if (ch == '.') {
 806 #if PICOJSON_USE_LOCALE
 807       num_str += localeconv()->decimal_point;
 808 #else
 809       num_str.push_back('.');
 810 #endif
 811     } else {
 812       in.ungetc();
 813       break;
 814     }
 815   }
 816   return num_str;
 817 }
 818
 819 template <typename Context, typename Iter> inline bool _parse(Context& ctx, input<Iter>& in) {
 820   in.skip_ws();
 821   int ch = in.getc();
 822   switch (ch) {
 823 #define IS(ch, text, op) case ch: \
 824       if (in.match(text) && op) { \
 825         return true; \
 826       } else { \
 827         return false; \
 828       }
 829     IS('n', "ull", ctx.set_null());
 830     IS('f', "alse", ctx.set_bool(false));
 831     IS('t', "rue", ctx.set_bool(true));
 832 #undef IS
 833     case '"':
 834       return ctx.parse_string(in);
 835     case '[':
 836       return _parse_array(ctx, in);
 837     case '{':
 838       return _parse_object(ctx, in);
 839     default:
 840       if (('0' <= ch && ch <= '9') || ch == '-') {
 841         double f;
 842         char *endp;
 843         in.ungetc();
 844         std::string num_str = _parse_number(in);
 845         if (num_str.empty()) {
 846           return false;
 847         }
 848 #ifdef PICOJSON_USE_INT64
 849         {
 850           errno = 0;
 851           intmax_t ival = strtoimax(num_str.c_str(), &endp, 10);
 852           if (errno == 0
 853               && std::numeric_limits<int64_t>::min() <= ival
 854               && ival <= std::numeric_limits<int64_t>::max()
 855               && endp == num_str.c_str() + num_str.size()) {
 856             ctx.set_int64(ival);
 857             return true;
 858           }
 859         }
 860 #endif
 861         f = strtod(num_str.c_str(), &endp);
 862         if (endp == num_str.c_str() + num_str.size()) {
 863           ctx.set_number(f);
 864           return true;
 865         }
 866         return false;
 867       }
 868       break;
 869   }
 870   in.ungetc();
 871   return false;
 872 }
 873
 874 class deny_parse_context {
 875 public:
 876   bool set_null() { return false; }
 877   bool set_bool(bool) { return false; }
 878 #ifdef PICOJSON_USE_INT64
 879   bool set_int64(int64_t) { return false; }
 880 #endif
 881   bool set_number(double) { return false; }
 882   template <typename Iter> bool parse_string(input<Iter>&) { return false; }
 883   bool parse_array_start() { return false; }
 884   template <typename Iter> bool parse_array_item(input<Iter>&, size_t) {
 885     return false;
 886   }
 887   bool parse_array_stop(size_t) { return false; }
 888   bool parse_object_start() { return false; }
 889   template <typename Iter> bool parse_object_item(input<Iter>&, const std::string&) {
 890     return false;
 891   }
 892 };
 893
 894 class default_parse_context {
 895 protected:
 896   value* out_;
 897 public:
 898   default_parse_context(value* out) : out_(out) {}
 899   bool set_null() {
 900     *out_ = value();
 901     return true;
 902   }
 903   bool set_bool(bool b) {
 904     *out_ = value(b);
 905     return true;
 906   }
 907 #ifdef PICOJSON_USE_INT64
 908   bool set_int64(int64_t i) {
 909       *out_ = value(i);
 910       return true;
 911     }
 912 #endif
 913   bool set_number(double f) {
 914     *out_ = value(f);
 915     return true;
 916   }
 917   template<typename Iter> bool parse_string(input<Iter>& in) {
 918     *out_ = value(string_type, false);
 919     return _parse_string(out_->get<std::string>(), in);
 920   }
 921   bool parse_array_start() {
 922     *out_ = value(array_type, false);
 923     return true;
 924   }
 925   template <typename Iter> bool parse_array_item(input<Iter>& in, size_t) {
 926     array& a = out_->get<array>();
 927     a.push_back(value());
 928     default_parse_context ctx(&a.back());
 929     return _parse(ctx, in);
 930   }
 931   bool parse_array_stop(size_t) { return true; }
 932   bool parse_object_start() {
 933     *out_ = value(object_type, false);
 934     return true;
 935   }
 936   template <typename Iter> bool parse_object_item(input<Iter>& in, const std::string& key) {
 937     object& o = out_->get<object>();
 938     default_parse_context ctx(&o[key]);
 939     return _parse(ctx, in);
 940   }
 941 private:
 942   default_parse_context(const default_parse_context&);
 943   default_parse_context& operator=(const default_parse_context&);
 944 };
 945
 946 class null_parse_context {
 947 public:
 948   struct dummy_str {
 949     void push_back(int) {}
 950   };
 951 public:
 952   null_parse_context() {}
 953   bool set_null() { return true; }
 954   bool set_bool(bool) { return true; }
 955 #ifdef PICOJSON_USE_INT64
 956   bool set_int64(int64_t) { return true; }
 957 #endif
 958   bool set_number(double) { return true; }
 959   template <typename Iter> bool parse_string(input<Iter>& in) {
 960     dummy_str s;
 961     return _parse_string(s, in);
 962   }
 963   bool parse_array_start() { return true; }
 964   template <typename Iter> bool parse_array_item(input<Iter>& in, size_t) {
 965     return _parse(*this, in);
 966   }
 967   bool parse_array_stop(size_t) { return true; }
 968   bool parse_object_start() { return true; }
 969   template <typename Iter> bool parse_object_item(input<Iter>& in, const std::string&) {
 970     return _parse(*this, in);
 971   }
 972 private:
 973   null_parse_context(const null_parse_context&);
 974   null_parse_context& operator=(const null_parse_context&);
 975 };
 976
 977 // obsolete, use the version below
 978 template <typename Iter> inline std::string parse(value& out, Iter& pos, const Iter& last) {
 979   std::string err;
 980   pos = parse(out, pos, last, &err);
 981   return err;
 982 }
 983
 984 template <typename Context, typename Iter> inline Iter _parse(Context& ctx, const Iter& first, const Iter& last, std::string* err) {
 985   input<Iter> in(first, last);
 986   if (! _parse(ctx, in) && err != NULL) {
 987     char buf[64];
 988     SNPRINTF(buf, sizeof(buf), "syntax error at line %d near: ", in.line());
 989     *err = buf;
 990     while (1) {
 991       int ch = in.getc();
 992       if (ch == -1 || ch == '\n') {
 993         break;
 994       } else if (ch >= ' ') {
 995         err->push_back(ch);
 996       }
 997     }
 998   }
 999   return in.cur();
1000 }
1001
1002 template <typename Iter> inline Iter parse(value& out, const Iter& first, const Iter& last, std::string* err) {
1003   default_parse_context ctx(&out);
1004   return _parse(ctx, first, last, err);
1005 }
1006
1007 inline std::string parse(value& out, const std::string& s) {
1008   std::string err;
1009   parse(out, s.begin(), s.end(), &err);
1010   return err;
1011 }
1012
1013 inline std::string parse(value& out, std::istream& is) {
1014   std::string err;
1015   parse(out, std::istreambuf_iterator<char>(is.rdbuf()),
1016         std::istreambuf_iterator<char>(), &err);
1017   return err;
1018 }
1019
1020 template <typename T> struct last_error_t {
1021   static std::string s;
1022 };
1023 template <typename T> std::string last_error_t<T>::s;
1024
1025 inline void set_last_error(const std::string& s) {
1026   last_error_t<bool>::s = s;
1027 }
1028
1029 inline const std::string& get_last_error() {
1030   return last_error_t<bool>::s;
1031 }
1032
1033 inline bool operator==(const value& x, const value& y) {
1034   if (x.is<null>())
1035     return y.is<null>();
1036 #define PICOJSON_CMP(type)                                      \
1037     if (x.is<type>())                                           \
1038       return y.is<type>() && x.get<type>() == y.get<type>()
1039   PICOJSON_CMP(bool);
1040   PICOJSON_CMP(double);
1041   PICOJSON_CMP(std::string);
1042   PICOJSON_CMP(array);
1043   PICOJSON_CMP(object);
1044 #undef PICOJSON_CMP
1045   PICOJSON_ASSERT(0);
1046 #ifdef _MSC_VER
1047   __assume(0);
1048 #endif
1049   return false;
1050 }
1051
1052 inline bool operator!=(const value& x, const value& y) {
1053   return ! (x == y);
1054 }
1055 }
1056
1057 #if !PICOJSON_USE_RVALUE_REFERENCE
1058 namespace std {
1059   template<> inline void swap(picojson::value& x, picojson::value& y)
1060     {
1061       x.swap(y);
1062     }
1063 }
1064 #endif
1065
1066 inline std::istream& operator>>(std::istream& is, picojson::value& x)
1067 {
1068   picojson::set_last_error(std::string());
1069   std::string err = picojson::parse(x, is);
1070   if (! err.empty()) {
1071     picojson::set_last_error(err);
1072     is.setstate(std::ios::failbit);
1073   }
1074   return is;
1075 }
1076
1077 inline std::ostream& operator<<(std::ostream& os, const picojson::value& x)
1078 {
1079   x.serialize(std::ostream_iterator<char>(os));
1080   return os;
1081 }
1082 #ifdef _MSC_VER
1083 #pragma warning(pop)
1084 #endif
1085
1086 #endif