]> git.cworth.org Git - vogl/blob - src/voglcore/vogl_json.cpp
- Fix for restoring FBO's that have attachments that the tracer was not able to query...
[vogl] / src / voglcore / vogl_json.cpp
1 /**************************************************************************
2  *
3  * Copyright 2013-2014 RAD Game Tools and Valve Software
4  * Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC
5  * All Rights Reserved.
6  *
7  * Permission is hereby granted, free of charge, to any person obtaining a copy
8  * of this software and associated documentation files (the "Software"), to deal
9  * in the Software without restriction, including without limitation the rights
10  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11  * copies of the Software, and to permit persons to whom the Software is
12  * furnished to do so, subject to the following conditions:
13  *
14  * The above copyright notice and this permission notice shall be included in
15  * all copies or substantial portions of the Software.
16  *
17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23  * THE SOFTWARE.
24  *
25  **************************************************************************/
26
27 // File: vogl_json.h
28 #include "vogl_core.h"
29 #include "vogl_json.h"
30 #include "vogl_console.h"
31 #include "vogl_growable_array.h"
32 #include "vogl_hash_map.h"
33 #include "vogl_map.h"
34
35 namespace vogl
36 {
37
38     json_node_object_pool *g_pJSON_node_pool;
39     json_value g_null_json_value;
40
41     static const char *g_to_hex = "0123456789ABCDEF";
42
43     const uint cMaxValidDepth = 511;
44
45     const uint cJSONTabSize = 3;
46
47     void json_node_pool_init()
48     {
49         if (!g_pJSON_node_pool)
50             g_pJSON_node_pool = vogl_new(json_node_object_pool, 256, cObjectPoolGrowExponential);
51     }
52
53     // class json_deserialize_buf_ptr
54
55     class json_deserialize_buf_ptr
56     {
57     public:
58         inline json_deserialize_buf_ptr(const char *p, size_t len)
59         {
60             init(p, len);
61         }
62
63         inline void init(const char *p, size_t len)
64         {
65             m_pPtr = p;
66             m_pEnd = p + len;
67             m_cur_line = 1;
68         }
69
70         inline const char *get_end() const
71         {
72             return m_pEnd;
73         }
74         inline bool at_end() const
75         {
76             return m_pPtr >= m_pEnd;
77         }
78
79         inline size_t get_num_remaining() const
80         {
81             return m_pEnd - m_pPtr;
82         }
83
84         inline char get_char() const
85         {
86             char c = (m_pPtr < m_pEnd) ? *m_pPtr : 0;
87             if (c == '\r')
88                 c = '\n';
89             return c;
90         }
91
92         inline uint get_cur_line() const
93         {
94             return m_cur_line;
95         }
96
97         inline char operator*() const
98         {
99             return get_char();
100         }
101         inline operator const char *() const
102         {
103             return m_pPtr;
104         }
105
106         inline json_deserialize_buf_ptr &operator++()
107         {
108             get_and_advance();
109             return *this;
110         }
111
112         inline json_deserialize_buf_ptr operator++(int)
113         {
114             json_deserialize_buf_ptr cur(*this);
115             get_and_advance();
116             return cur;
117         }
118
119         inline char get_and_advance()
120         {
121             char c = (m_pPtr < m_pEnd) ? *m_pPtr++ : 0;
122             if (c <= '\r')
123             {
124                 if ((c == '\r') && (m_pPtr < m_pEnd) && (*m_pPtr == '\n'))
125                     c = *m_pPtr++;
126                 if ((c == '\n') || (c == '\r'))
127                 {
128                     c = '\n';
129                     m_cur_line++;
130                 }
131             }
132             return c;
133         }
134
135         inline void advance()
136         {
137             get_and_advance();
138         }
139
140         json_deserialize_buf_ptr &skip_whitespace();
141
142         inline bool compare_string(const char *pStr, size_t n) const
143         {
144             return ((m_pEnd - m_pPtr) < (int)n) ? false : !strncmp(m_pPtr, pStr, n);
145         }
146
147         inline json_deserialize_buf_ptr &advance_in_line(uint n)
148         {
149             m_pPtr = VOGL_MIN(m_pEnd, m_pPtr + n);
150             return *this;
151         }
152         inline json_deserialize_buf_ptr &advance_in_line_no_end_check(uint n)
153         {
154             m_pPtr += n;
155             VOGL_ASSERT(m_pPtr <= m_pEnd);
156             return *this;
157         }
158
159     private:
160         const char *m_pPtr;
161         const char *m_pEnd;
162         uint m_cur_line;
163     };
164
165     json_deserialize_buf_ptr &json_deserialize_buf_ptr::skip_whitespace()
166     {
167         while (m_pPtr < m_pEnd)
168         {
169             char c = *m_pPtr;
170             if ((c == ' ') || (c == '\t'))
171             {
172                 ++m_pPtr;
173                 continue;
174             }
175
176             if ((c == '/') && (((m_pPtr + 1) < m_pEnd) && (m_pPtr[1] == '/')))
177             {
178                 m_pPtr += 2;
179                 while ((!at_end()) && (get_char() != '\n'))
180                     advance();
181                 continue;
182             }
183             else if (c > ' ')
184                 break;
185             else if (c == '\r')
186             {
187                 if (((m_pPtr + 1) < m_pEnd) && (m_pPtr[1] == '\n'))
188                     ++m_pPtr;
189                 m_cur_line++;
190             }
191             else if (c == '\n')
192                 m_cur_line++;
193
194             ++m_pPtr;
195         }
196         return *this;
197     }
198
199     // class json_growable_char_buf
200
201     class json_growable_char_buf
202     {
203         VOGL_NO_COPY_OR_ASSIGNMENT_OP(json_growable_char_buf);
204
205     public:
206         inline json_growable_char_buf(vogl::vector<char> &buf)
207             : m_buf(buf)
208         {
209         }
210
211         inline uint size() const
212         {
213             return m_buf.size();
214         }
215
216         inline const vogl::vector<char> &get() const
217         {
218             return m_buf;
219         }
220         inline vogl::vector<char> &get()
221         {
222             return m_buf;
223         }
224
225         void puts(const char *pStr);
226         void printf(const char *pFmt, ...);
227         void print_escaped(const char *pStr);
228         void print_tabs(uint n);
229         inline void print_char(char c)
230         {
231             m_buf.push_back(c);
232         }
233
234     private:
235         vogl::vector<char> &m_buf;
236     };
237
238     void json_growable_char_buf::puts(const char *pStr)
239     {
240         size_t l = strlen(pStr);
241         if (l > cUINT32_MAX)
242             return;
243
244         char *p = m_buf.try_enlarge(static_cast<uint>(l));
245         if (p)
246             memcpy(p, pStr, l);
247     }
248
249     void json_growable_char_buf::printf(const char *pFmt, ...)
250     {
251         char str[512];
252
253         va_list args;
254         va_start(args, pFmt);
255 #ifdef _MSC_VER
256         int l = _vsnprintf_s(str, sizeof(str), pFmt, args);
257 #else
258         int l = vsnprintf(str, sizeof(str), pFmt, args);
259         str[sizeof(str) - 1] = '\0';
260 #endif
261         va_end(args);
262
263         char *p = m_buf.try_enlarge(l);
264         if (p)
265             memcpy(p, str, l);
266     }
267
268     void json_growable_char_buf::print_tabs(uint n)
269     {
270 #if 0
271         // Apparently tabs are not valid JSON.
272         char *p = m_buf.enlarge(n);
273         if (p)
274                 memset(p, '\t', n);
275 #else
276         char *p = m_buf.enlarge(n * cJSONTabSize);
277         if (p)
278             memset(p, ' ', n * cJSONTabSize);
279 #endif
280     }
281
282     void json_growable_char_buf::print_escaped(const char *pStr)
283     {
284         m_buf.push_back('\"');
285
286         while (*pStr)
287         {
288             char c = *pStr++;
289             if ((static_cast<uint8>(c) >= 32U) && (c != '\"') && (c != '\\'))
290                 m_buf.push_back(c);
291             else
292             {
293                 m_buf.push_back('\\');
294                 switch (c)
295                 {
296                     case '\b':
297                         m_buf.push_back('b');
298                         break;
299                     case '\r':
300                         m_buf.push_back('r');
301                         break;
302                     case '\t':
303                         m_buf.push_back('t');
304                         break;
305                     case '\f':
306                         m_buf.push_back('f');
307                         break;
308                     case '\n':
309                         m_buf.push_back('n');
310                         break;
311                     case '\\':
312                         m_buf.push_back('\\');
313                         break;
314                     case '\"':
315                         m_buf.push_back('\"');
316                         break;
317                     default:
318                         m_buf.push_back('u');
319                         m_buf.push_back('0');
320                         m_buf.push_back('0');
321                         m_buf.push_back(g_to_hex[static_cast<uint8>(c) >> 4]);
322                         m_buf.push_back(g_to_hex[c & 0xF]);
323                         break;
324                 }
325             }
326         }
327
328         m_buf.push_back('\"');
329     }
330
331     void json_error_info_t::set_error(uint line, const char *pMsg, ...)
332     {
333         m_error_line = line;
334
335         va_list args;
336         va_start(args, pMsg);
337         m_error_msg.format_args(pMsg, args);
338         va_end(args);
339     }
340
341     // class json_value
342
343     json_value::json_value(const json_value &other)
344         : m_type(other.m_type),
345           m_line(0)
346     {
347         if (other.m_type == cJSONValueTypeString)
348             m_data.m_pStr = vogl_strdup(other.m_data.m_pStr);
349         else if (other.m_type == cJSONValueTypeNode)
350             m_data.m_pNode = get_json_node_pool()->alloc(*other.get_node_ptr());
351         else
352             memcpy(&m_data, &other.m_data, sizeof(m_data));
353     }
354
355     void json_value::set_value(uint64_t nVal)
356     {
357         free_data();
358
359         if (nVal > static_cast<uint64_t>(cINT64_MAX))
360         {
361             // Encode as a hex string because otherwise some json parsers have a fit, and the UJB format doesn't directly support uint64_t.
362             char buf[32];
363             vogl_sprintf_s(buf, sizeof(buf), "0x%" PRIX64, nVal);
364             set_value(buf);
365         }
366         else
367         {
368             set_value(static_cast<int64_t>(nVal));
369         }
370     }
371
372     json_value &json_value::operator=(const json_value &rhs)
373     {
374         free_data();
375
376         m_type = rhs.m_type;
377
378         if (m_type == cJSONValueTypeString)
379             m_data.m_pStr = vogl_strdup(rhs.m_data.m_pStr);
380         else if (m_type == cJSONValueTypeNode)
381             m_data.m_pNode = get_json_node_pool()->alloc(*rhs.get_node_ptr());
382         else
383             memcpy(&m_data, &rhs.m_data, sizeof(m_data));
384
385         m_line = rhs.m_line;
386
387         return *this;
388     }
389
390     bool json_value::convert_to_bool(bool &val, bool def) const
391     {
392         switch (m_type)
393         {
394             case cJSONValueTypeBool:
395             case cJSONValueTypeInt:
396             {
397                 val = (m_data.m_nVal != 0);
398                 return true;
399             }
400             case cJSONValueTypeDouble:
401             {
402                 val = (m_data.m_flVal != 0);
403                 return true;
404             }
405             case cJSONValueTypeString:
406             {
407                 if (!vogl_stricmp(m_data.m_pStr, "false"))
408                 {
409                     val = false;
410                     return true;
411                 }
412                 else if (!vogl_stricmp(m_data.m_pStr, "true"))
413                 {
414                     val = true;
415                     return true;
416                 }
417
418                 double flVal = 0.0f;
419                 const char *pStr = m_data.m_pStr;
420                 if (!string_ptr_to_double(pStr, flVal))
421                 {
422                     val = def;
423                     return false;
424                 }
425                 val = (flVal != 0);
426                 return true;
427             }
428             default:
429                 break;
430         }
431         val = def;
432         return false;
433     }
434
435     bool json_value::convert_to_int32(int32 &val, int32 def) const
436     {
437         val = def;
438         int64_t val64;
439         if (!convert_to_int64(val64, def))
440             return false;
441         if ((val64 < cINT32_MIN) || (val64 > cINT32_MAX))
442             return false;
443         val = static_cast<int32>(val64);
444         return true;
445     }
446
447     bool json_value::convert_to_int64(int64_t &val, int64_t def) const
448     {
449         switch (m_type)
450         {
451             case cJSONValueTypeBool:
452             case cJSONValueTypeInt:
453             {
454                 val = m_data.m_nVal;
455                 return true;
456             }
457             case cJSONValueTypeDouble:
458             {
459                 val = static_cast<int64_t>(m_data.m_flVal);
460                 return true;
461             }
462             case cJSONValueTypeString:
463             {
464                 if (!vogl_stricmp(m_data.m_pStr, "false"))
465                 {
466                     val = 0;
467                     return true;
468                 }
469                 else if (!vogl_stricmp(m_data.m_pStr, "true"))
470                 {
471                     val = 1;
472                     return true;
473                 }
474
475                 const char *pStr = m_data.m_pStr;
476
477                 // string_to_ptr_int64() will handle hex or decimal conversions
478                 if (!string_ptr_to_int64(pStr, val))
479                 {
480                     val = def;
481                     return false;
482                 }
483                 return true;
484             }
485             default:
486                 break;
487         }
488         val = def;
489         return false;
490     }
491
492     bool json_value::convert_to_uint64(uint64_t &val, uint64_t def) const
493     {
494         switch (m_type)
495         {
496             case cJSONValueTypeBool:
497             {
498                 val = m_data.m_nVal;
499                 break;
500             }
501             case cJSONValueTypeInt:
502             {
503                 if (m_data.m_nVal < 0)
504                     break;
505
506                 val = m_data.m_nVal;
507                 return true;
508             }
509             case cJSONValueTypeDouble:
510             {
511                 if (m_data.m_flVal < 0)
512                     break;
513
514                 val = static_cast<uint64_t>(m_data.m_flVal);
515                 return true;
516             }
517             case cJSONValueTypeString:
518             {
519                 if (!vogl_stricmp(m_data.m_pStr, "false"))
520                 {
521                     val = 0;
522                     return true;
523                 }
524                 else if (!vogl_stricmp(m_data.m_pStr, "true"))
525                 {
526                     val = 1;
527                     return true;
528                 }
529
530                 const char *pStr = m_data.m_pStr;
531
532                 // string_to_uint64() will handle hex or decimal conversions
533                 if (!string_ptr_to_uint64(pStr, val))
534                     break;
535
536                 return true;
537             }
538             default:
539                 break;
540         }
541         val = def;
542         return false;
543     }
544
545     bool json_value::convert_to_float(float &val, float def) const
546     {
547         switch (m_type)
548         {
549             case cJSONValueTypeBool:
550             case cJSONValueTypeInt:
551             {
552                 val = static_cast<float>(m_data.m_nVal);
553                 return true;
554             }
555             case cJSONValueTypeDouble:
556             {
557                 val = static_cast<float>(m_data.m_flVal);
558                 return true;
559             }
560             case cJSONValueTypeString:
561             {
562                 if (!vogl_stricmp(m_data.m_pStr, "false"))
563                 {
564                     val = 0;
565                     return true;
566                 }
567                 else if (!vogl_stricmp(m_data.m_pStr, "true"))
568                 {
569                     val = 1;
570                     return true;
571                 }
572
573                 const char *pStr = m_data.m_pStr;
574                 if (!string_ptr_to_float(pStr, val))
575                     break;
576
577                 return true;
578             }
579             default:
580                 break;
581         }
582         val = def;
583         return false;
584     }
585
586     bool json_value::convert_to_double(double &val, double def) const
587     {
588         switch (m_type)
589         {
590             case cJSONValueTypeBool:
591             case cJSONValueTypeInt:
592             {
593                 val = static_cast<double>(m_data.m_nVal);
594                 return true;
595             }
596             case cJSONValueTypeDouble:
597             {
598                 val = m_data.m_flVal;
599                 return true;
600             }
601             case cJSONValueTypeString:
602             {
603                 if (!vogl_stricmp(m_data.m_pStr, "false"))
604                 {
605                     val = 0;
606                     return true;
607                 }
608                 else if (!vogl_stricmp(m_data.m_pStr, "true"))
609                 {
610                     val = 1;
611                     return true;
612                 }
613
614                 const char *pStr = m_data.m_pStr;
615                 if (!string_ptr_to_double(pStr, val))
616                 {
617                     val = def;
618                     return false;
619                 }
620                 return true;
621             }
622             default:
623                 break;
624         }
625         val = def;
626         return false;
627     }
628
629     bool json_value::convert_to_string(dynamic_string &val, const char *pDef) const
630     {
631         switch (m_type)
632         {
633             case cJSONValueTypeNull:
634             {
635                 val.set("null");
636                 return true;
637             }
638             case cJSONValueTypeBool:
639             {
640                 val.set(!m_data.m_nVal ? "false" : "true");
641                 return true;
642             }
643             case cJSONValueTypeInt:
644             {
645                 val.format("%" PRIi64, m_data.m_nVal);
646                 return true;
647             }
648             case cJSONValueTypeDouble:
649             {
650                 val.format("%1.18f", m_data.m_flVal);
651
652                 if ((!val.contains('E')) && (!val.contains('e')))
653                 {
654                     // Remove trailing 0's, except the first after the decimal point which is required for valid JSON.
655                     int dot_ofs = val.find_right('.');
656                     if (dot_ofs >= 0)
657                     {
658                         int len = val.get_len();
659
660                         int i;
661                         for (i = dot_ofs + 1; i < len; i++)
662                         {
663                             char c = val[i];
664                             if (!vogl_isdigit(c))
665                                 break;
666                         }
667                         if (i == len)
668                         {
669                             int cur_ofs = len - 1;
670                             while ((val[cur_ofs] == '0') && (cur_ofs > (dot_ofs + 1)))
671                             {
672                                 val.set_len(cur_ofs);
673                                 cur_ofs--;
674                             }
675                         }
676                     }
677                 }
678                 return true;
679             }
680             case cJSONValueTypeString:
681             {
682                 val = m_data.m_pStr;
683                 return true;
684             }
685             default:
686                 break;
687         }
688         val.set(pDef);
689         return false;
690     }
691
692     static int scan_string_list(const char *p, const char **pList, int def)
693     {
694         int index = 0;
695         for (;;)
696         {
697             const char *s = pList[index];
698             if (!s)
699                 break;
700             if (vogl_stricmp(p, s) == 0)
701                 return index;
702             index++;
703         }
704         return def;
705     }
706
707     bool json_value::get_enum(const char **pStringList, int &val, int def) const
708     {
709         val = def;
710
711         dynamic_string tmp_str;
712         const char *pStr;
713
714         if (get_type() == cJSONValueTypeString)
715             pStr = m_data.m_pStr;
716         else
717         {
718             if (!convert_to_string(tmp_str, ""))
719                 return false;
720             pStr = tmp_str.get_ptr();
721         }
722
723         int val_index = scan_string_list(pStr, pStringList, -1);
724         if (val_index < 0)
725             return false;
726         val = val_index;
727         return true;
728     }
729
730     bool json_value::get_numeric(int8 &val, int8 def) const
731     {
732         int64_t val64;
733         if (!get_numeric(val64))
734         {
735             val = def;
736             return false;
737         }
738         if ((val64 < static_cast<int64_t>(cINT8_MIN)) || (val64 > static_cast<int64_t>(cINT8_MAX)))
739         {
740             val = def;
741             return false;
742         }
743         val = static_cast<int8>(val64);
744         return true;
745     }
746
747     bool json_value::get_numeric(int16 &val, int16 def) const
748     {
749         int64_t val64;
750         if (!get_numeric(val64))
751         {
752             val = def;
753             return false;
754         }
755         if ((val64 < static_cast<int64_t>(cINT16_MIN)) || (val64 > static_cast<int64_t>(cINT16_MAX)))
756         {
757             val = def;
758             return false;
759         }
760         val = static_cast<int16>(val64);
761         return true;
762     }
763
764     bool json_value::get_numeric(uint8 &val, uint8 def) const
765     {
766         uint64_t val64;
767         if (!get_numeric(val64))
768         {
769             val = def;
770             return false;
771         }
772         if (val64 > static_cast<int64_t>(cUINT8_MAX))
773         {
774             val = def;
775             return false;
776         }
777         val = static_cast<uint8>(val64);
778         return true;
779     }
780
781     bool json_value::get_numeric(uint16 &val, uint16 def) const
782     {
783         uint64_t val64;
784         if (!get_numeric(val64))
785         {
786             val = def;
787             return false;
788         }
789         if (val64 > static_cast<int64_t>(cUINT16_MAX))
790         {
791             val = def;
792             return false;
793         }
794         val = static_cast<uint16>(val64);
795         return true;
796     }
797
798     bool json_value::get_numeric(uint32 &val, uint32 def) const
799     {
800         int64_t val64;
801         if (!get_numeric(val64))
802         {
803             val = def;
804             return false;
805         }
806         if ((val64 < 0) || (val64 > static_cast<int64_t>(cUINT32_MAX)))
807         {
808             val = def;
809             return false;
810         }
811         val = static_cast<uint32>(val64);
812         return true;
813     }
814
815     bool json_value::validate(const json_node *pParent) const
816     {
817         if (is_node())
818         {
819             const json_node *pNode = get_node_ptr();
820             if (!pNode)
821                 return false;
822
823             if (!pNode->basic_validation(pParent))
824                 return false;
825
826             for (uint i = 0; i < pNode->size(); i++)
827                 if ((pNode->is_child(i)) && (!pNode->get_value(i).validate(pNode)))
828                     return false;
829         }
830         else if (is_string())
831         {
832             if (!m_data.m_pStr)
833                 return false;
834         }
835
836         return true;
837     }
838
839     void json_value::binary_serialize_value(vogl::vector<uint8> &buf) const
840     {
841         switch (m_type)
842         {
843             case cJSONValueTypeNull:
844             {
845                 buf.push_back('Z');
846                 break;
847             }
848             case cJSONValueTypeBool:
849             {
850                 buf.push_back(m_data.m_nVal ? 'T' : 'F');
851                 break;
852             }
853             case cJSONValueTypeInt:
854             {
855                 int shift;
856                 uint8 *pDst;
857                 if (static_cast<uint64_t>(m_data.m_nVal) <= 0xFFU)
858                 {
859                     pDst = buf.enlarge(2);
860                     *pDst++ = 'B';
861                     shift = 8 - 8;
862                 }
863                 else if ((m_data.m_nVal >= cINT16_MIN) && (m_data.m_nVal <= cINT16_MAX))
864                 {
865                     pDst = buf.enlarge(3);
866                     *pDst++ = 'i';
867                     shift = 16 - 8;
868                 }
869                 else if ((m_data.m_nVal >= cINT32_MIN) && (m_data.m_nVal <= cINT32_MAX))
870                 {
871                     pDst = buf.enlarge(5);
872                     *pDst++ = 'I';
873                     shift = 32 - 8;
874                 }
875                 else
876                 {
877                     pDst = buf.enlarge(9);
878                     *pDst++ = 'L';
879                     shift = 64 - 8;
880                 }
881
882                 uint64_t n = static_cast<uint64_t>(m_data.m_nVal);
883                 do
884                 {
885                     *pDst++ = static_cast<uint8>(n >> shift);
886                 } while ((shift -= 8) >= 0);
887
888                 break;
889             }
890             case cJSONValueTypeDouble:
891             {
892                 float flVal32 = static_cast<float>(m_data.m_flVal);
893                 if (math::equal_tol(m_data.m_flVal, static_cast<double>(flVal32), 1e-17))
894                 {
895                     uint8 *pDst = buf.enlarge(5);
896                     pDst[0] = 'd';
897                     utils::write_obj(flVal32, pDst + 1, false);
898                 }
899                 else
900                 {
901                     uint8 *pDst = buf.enlarge(9);
902                     pDst[0] = 'D';
903                     utils::write_obj(m_data.m_flVal, pDst + 1, false);
904                 }
905
906                 break;
907             }
908             case cJSONValueTypeString:
909             {
910                 uint len = static_cast<uint>(strlen(m_data.m_pStr));
911                 if (len <= 254)
912                 {
913                     uint8 *pDst = buf.enlarge(2 + len);
914                     pDst[0] = 's';
915                     pDst[1] = static_cast<uint8>(len);
916                     memcpy(pDst + 2, m_data.m_pStr, len);
917                 }
918                 else
919                 {
920                     uint8 *pDst = buf.enlarge(5 + len);
921                     pDst[0] = 'S';
922                     pDst[1] = static_cast<uint8>(len >> 24);
923                     pDst[2] = static_cast<uint8>(len >> 16);
924                     pDst[3] = static_cast<uint8>(len >> 8);
925                     pDst[4] = static_cast<uint8>(len);
926                     memcpy(pDst + 5, m_data.m_pStr, len);
927                 }
928
929                 break;
930             }
931             default:
932                 break;
933         }
934     }
935
936     void json_value::binary_serialize(vogl::vector<uint8> &buf) const
937     {
938         const json_node *pNode = get_node_ptr();
939         if (pNode)
940             pNode->binary_serialize(buf);
941         else
942             binary_serialize_value(buf);
943     }
944
945     bool json_value::binary_serialize_to_file(const char *pFilename)
946     {
947         FILE *pFile = vogl_fopen(pFilename, "wb");
948         if (!pFile)
949             return false;
950         bool success = binary_serialize(pFile);
951         if (vogl_fclose(pFile) == EOF)
952             success = false;
953         return success;
954     }
955
956     bool json_value::binary_serialize(FILE *pFile)
957     {
958         vogl::vector<uint8> buf;
959         binary_serialize(buf);
960         return fwrite(buf.get_ptr(), 1, buf.size(), pFile) == buf.size();
961     }
962
963     void json_value::serialize(vogl::vector<char> &buf, bool formatted, uint cur_indent, bool null_terminate, uint max_line_len) const
964     {
965         const json_node *pNode = get_node_ptr();
966         if (pNode)
967         {
968             pNode->serialize(buf, formatted, cur_indent, false, max_line_len);
969             if (formatted)
970                 buf.push_back('\n');
971         }
972         else
973         {
974             if (formatted)
975             {
976                 while (cur_indent--)
977                 {
978 #if 0
979                     // Apparently tabs are not valid JSON.
980                     buf.push_back('\t');
981 #else
982                     for (uint i = 0; i < cJSONTabSize; i++)
983                         buf.push_back(' ');
984 #endif
985                 }
986             }
987             if (is_string())
988             {
989                 json_growable_char_buf growable_buf(buf);
990                 growable_buf.print_escaped(m_data.m_pStr);
991             }
992             else
993             {
994                 dynamic_string str;
995                 get_string(str);
996                 buf.append(str.get_ptr(), str.get_len());
997             }
998         }
999
1000         if (null_terminate)
1001             buf.push_back('\0');
1002     }
1003
1004     bool json_value::binary_deserialize_file(const char *pFilename)
1005     {
1006         FILE *pFile = vogl_fopen(pFilename, "rb");
1007         if (!pFile)
1008             return false;
1009         bool success = binary_deserialize(pFile);
1010         if (vogl_fclose(pFile) == EOF)
1011             success = false;
1012         return success;
1013     }
1014
1015     bool json_value::binary_deserialize(FILE *pFile)
1016     {
1017         vogl_fseek(pFile, 0, SEEK_END);
1018         const uint64_t filesize = vogl_ftell(pFile);
1019         vogl_fseek(pFile, 0, SEEK_SET);
1020
1021         if (!filesize)
1022             return false;
1023
1024         if ((filesize > VOGL_MAX_POSSIBLE_HEAP_BLOCK_SIZE) || (filesize != static_cast<size_t>(filesize)))
1025             return false;
1026
1027         uint8 *pBuf = (uint8 *)vogl_malloc(static_cast<size_t>(filesize));
1028         if (!pBuf)
1029             return false;
1030
1031         if (vogl_fread(pBuf, 1, static_cast<size_t>(filesize), pFile) != filesize)
1032         {
1033             vogl_free(pBuf);
1034             return false;
1035         }
1036
1037         bool status = binary_deserialize(pBuf, static_cast<size_t>(filesize));
1038
1039         vogl_free(pBuf);
1040
1041         return status;
1042     }
1043
1044     bool json_value::binary_deserialize(const vogl::vector<uint8> &buf)
1045     {
1046         return buf.size() ? binary_deserialize(buf.get_ptr(), buf.size()) : false;
1047     }
1048
1049     bool json_value::binary_deserialize(const uint8 *pBuf, size_t n)
1050     {
1051         return binary_deserialize(pBuf, pBuf + n, NULL, 0);
1052     }
1053
1054     bool json_value::binary_deserialize(const uint8 *&pBuf, const uint8 *pBuf_end, json_node *pParent, uint depth)
1055     {
1056 #define JSON_BD_FAIL() \
1057     do                 \
1058     {                  \
1059         pBuf = pSrc;   \
1060         return false;  \
1061     } while (0)
1062         const uint8 *pSrc = pBuf;
1063         set_value_to_null();
1064
1065         if (depth > cMaxValidDepth)
1066             return false;
1067
1068         uint8 c;
1069         for (;;)
1070         {
1071             if (pSrc >= pBuf_end)
1072                 JSON_BD_FAIL();
1073             c = *pSrc++;
1074             if (c != 'N')
1075                 break;
1076         }
1077
1078         size_t n = pBuf_end - pSrc;
1079
1080         // Process huge nums as strings
1081         if (c == 'h')
1082             c = 's';
1083         else if (c == 'H')
1084             c = 'S';
1085
1086         switch (c)
1087         {
1088             case 'E':
1089                 JSON_BD_FAIL();
1090             case 'Z':
1091                 break;
1092             case 'A':
1093             case 'a':
1094             case 'O':
1095             case 'o':
1096             {
1097                 const bool is_object = ((c == 'O') || (c == 'o'));
1098
1099                 if (n < 1)
1100                     JSON_BD_FAIL();
1101
1102                 uint l = *pSrc++;
1103                 n--;
1104
1105                 bool unknown_len = false;
1106
1107                 if (c <= 'O')
1108                 {
1109                     if (n < 3)
1110                         JSON_BD_FAIL();
1111                     l = (l << 24) | (pSrc[0] << 16) | (pSrc[1] << 8) | pSrc[2];
1112
1113                     pSrc += 3;
1114                     n -= 3;
1115                 }
1116                 else if (l == 255)
1117                     unknown_len = true;
1118
1119                 json_node *pNode = set_value_to_node(is_object, pParent);
1120                 if (!unknown_len)
1121                     pNode->resize(l);
1122
1123                 uint idx = 0;
1124                 while ((unknown_len) || (idx < l))
1125                 {
1126                     uint8 q;
1127                     for (;;)
1128                     {
1129                         if (n < 1)
1130                             JSON_BD_FAIL();
1131                         q = *pSrc;
1132                         if (q != 'N')
1133                             break;
1134                         pSrc++;
1135                         n--;
1136                     }
1137
1138                     if (q == 'E')
1139                     {
1140                         pSrc++;
1141                         break;
1142                     }
1143                     if (unknown_len)
1144                         pNode->enlarge(1);
1145
1146                     if (is_object)
1147                     {
1148                         if ((q != 'S') && (q != 's'))
1149                             JSON_BD_FAIL();
1150
1151                         pSrc++;
1152                         n--;
1153
1154                         if (!n)
1155                             JSON_BD_FAIL();
1156
1157                         uint l = *pSrc++;
1158                         n--;
1159
1160                         if (c == 'S')
1161                         {
1162                             if (n < 3)
1163                                 JSON_BD_FAIL();
1164                             l = (l << 24) | (pSrc[0] << 16) | (pSrc[1] << 8) | pSrc[2];
1165                             pSrc += 3;
1166                             n -= 3;
1167                         }
1168
1169                         if (n < l)
1170                             JSON_BD_FAIL();
1171
1172                         pNode->get_key(idx).set_from_buf(pSrc, l);
1173
1174                         pSrc += l;
1175                     }
1176
1177                     if (!pNode->get_value(idx).binary_deserialize(pSrc, pBuf_end, pNode, depth + 1))
1178                         JSON_BD_FAIL();
1179
1180                     ++idx;
1181                 }
1182
1183                 break;
1184             }
1185             case 's':
1186             case 'S':
1187             {
1188                 if (!n)
1189                     JSON_BD_FAIL();
1190
1191                 uint l = *pSrc++;
1192                 n--;
1193
1194                 if (c == 'S')
1195                 {
1196                     if (n < 3)
1197                         JSON_BD_FAIL();
1198                     l = (l << 24) | (pSrc[0] << 16) | (pSrc[1] << 8) | pSrc[2];
1199                     pSrc += 3;
1200                     n -= 3;
1201                 }
1202
1203                 if (n < l)
1204                     JSON_BD_FAIL();
1205
1206                 m_type = cJSONValueTypeString;
1207                 m_data.m_pStr = (char *)vogl_malloc(l + 1);
1208                 if (!m_data.m_pStr)
1209                 {
1210                     set_value_to_null();
1211                     JSON_BD_FAIL();
1212                 }
1213                 memcpy(m_data.m_pStr, pSrc, l);
1214                 m_data.m_pStr[l] = '\0';
1215                 pSrc += l;
1216                 break;
1217             }
1218             case 'T':
1219             {
1220                 set_value(true);
1221                 break;
1222             }
1223             case 'F':
1224             {
1225                 set_value(false);
1226                 break;
1227             }
1228             case 'B':
1229             {
1230                 if (n < 1)
1231                     JSON_BD_FAIL();
1232                 m_type = cJSONValueTypeInt;
1233                 m_data.m_nVal = *pSrc++;
1234                 break;
1235             }
1236             case 'i':
1237             {
1238                 if (n < 2)
1239                     JSON_BD_FAIL();
1240                 m_type = cJSONValueTypeInt;
1241                 m_data.m_nVal = static_cast<int16>((pSrc[0] << 8) | pSrc[1]);
1242                 pSrc += 2;
1243                 break;
1244             }
1245             case 'I':
1246             {
1247                 if (n < 4)
1248                     JSON_BD_FAIL();
1249                 m_type = cJSONValueTypeInt;
1250                 m_data.m_nVal = static_cast<int32>((pSrc[0] << 24) | (pSrc[1] << 16) | (pSrc[2] << 8) | pSrc[3]);
1251                 pSrc += 4;
1252                 break;
1253             }
1254             case 'L':
1255             {
1256                 if (n < 8)
1257                     JSON_BD_FAIL();
1258                 m_type = cJSONValueTypeInt;
1259                 uint64_t v = 0;
1260                 for (uint i = 8; i; --i)
1261                     v = (v << 8) | *pSrc++;
1262                 m_data.m_nVal = static_cast<int64_t>(v);
1263                 break;
1264             }
1265             case 'd':
1266             {
1267                 if (n < 4)
1268                     JSON_BD_FAIL();
1269                 m_type = cJSONValueTypeDouble;
1270                 union
1271                 {
1272                     uint32 m_u32;
1273                     float m_fl32;
1274                 } bits;
1275                 bits.m_u32 = static_cast<uint32>((pSrc[0] << 24) | (pSrc[1] << 16) | (pSrc[2] << 8) | pSrc[3]);
1276                 pSrc += 4;
1277                 m_data.m_flVal = static_cast<double>(bits.m_fl32);
1278                 break;
1279             }
1280             case 'D':
1281             {
1282                 if (n < 8)
1283                     JSON_BD_FAIL();
1284                 m_type = cJSONValueTypeDouble;
1285                 uint64_t v = 0;
1286                 for (uint i = 8; i; --i)
1287                     v = (v << 8) | *pSrc++;
1288                 m_data.m_nVal = v;
1289                 break;
1290             }
1291             default:
1292                 return false;
1293         }
1294
1295 #undef JSON_BD_FAIL
1296
1297         pBuf = pSrc;
1298         return true;
1299     }
1300
1301     dynamic_string &json_value::serialize(dynamic_string &str, bool formatted, uint cur_indent, uint max_line_len) const
1302     {
1303         vogl::vector<char> buf;
1304         serialize(buf, formatted, cur_indent, false, max_line_len);
1305         return str.set_from_buf(buf.get_ptr(), buf.size_in_bytes());
1306     }
1307
1308     void json_value::print(bool formatted, uint cur_indent, uint max_line_len) const
1309     {
1310         vogl::vector<char> buf;
1311         serialize(buf, formatted, cur_indent, true, max_line_len);
1312         puts(buf.get_ptr());
1313     }
1314
1315     bool json_value::serialize_to_file(const char *pFilename, bool formatted, uint max_line_len) const
1316     {
1317         FILE *pFile = vogl_fopen(pFilename, "wb");
1318         if (!pFile)
1319             return false;
1320         bool success = serialize(pFile, formatted, max_line_len);
1321         if (vogl_fclose(pFile) == EOF)
1322             success = false;
1323         return success;
1324     }
1325
1326     bool json_value::serialize(FILE *pFile, bool formatted, uint max_line_len) const
1327     {
1328         vogl::vector<char> buf;
1329         serialize(buf, formatted, 0, false, max_line_len);
1330         return fwrite(buf.get_ptr(), 1, buf.size(), pFile) == buf.size();
1331     }
1332
1333     bool json_value::deserialize_node(json_deserialize_buf_ptr &pStr, json_node *pParent, uint level, json_error_info_t &error_info)
1334     {
1335         const bool is_object = (*pStr == '{');
1336         const char end_char = is_object ? '}' : ']';
1337
1338         json_node *pNode = set_value_to_node(is_object, pParent);
1339         pNode->m_line = pStr.get_cur_line();
1340
1341         pStr.advance_in_line_no_end_check(1);
1342         pStr.skip_whitespace();
1343
1344         for (;;)
1345         {
1346             char c = pStr.get_char();
1347             if (c == end_char)
1348                 break;
1349
1350             uint value_index = pNode->enlarge(1);
1351
1352             if (is_object)
1353             {
1354                 if (c != '\"')
1355                 {
1356                     error_info.set_error(pStr.get_cur_line(), "Expected quoted key string");
1357                     return false;
1358                 }
1359
1360                 pStr.advance_in_line_no_end_check(1);
1361
1362                 uint estimated_len;
1363                 if (!estimate_deserialized_string_size(pStr, error_info, estimated_len))
1364                     return false;
1365
1366                 if (estimated_len >= cMaxDynamicStringLen)
1367                 {
1368                     error_info.set_error(pStr.get_cur_line(), "Quoted name string is too long");
1369                     return false;
1370                 }
1371                 uint buf_size = estimated_len + 1;
1372                 char *pBuf = dynamic_string::create_raw_buffer(buf_size);
1373
1374                 char *pDst = pBuf;
1375                 if (!deserialize_quoted_string_to_buf(pDst, buf_size, pStr, error_info))
1376                 {
1377                     dynamic_string::free_raw_buffer(pBuf);
1378                     return false;
1379                 }
1380                 pNode->get_key(value_index).set_from_raw_buf_and_assume_ownership(pBuf, buf_size, static_cast<uint>(pDst - pBuf));
1381
1382                 pStr.skip_whitespace();
1383
1384                 if (*pStr != ':')
1385                 {
1386                     error_info.set_error(pStr.get_cur_line(), "Missing colon after key");
1387                     return false;
1388                 }
1389
1390                 pStr.advance_in_line_no_end_check(1);
1391
1392                 pStr.skip_whitespace();
1393             }
1394
1395             json_value &newVal = pNode->m_values[value_index];
1396             if (level > cMaxValidDepth)
1397             {
1398                 error_info.set_error(pStr.get_cur_line(), "Document is too complex");
1399                 return false;
1400             }
1401
1402             if (!newVal.deserialize(pStr, pNode, level + 1, error_info))
1403                 return false;
1404
1405             pStr.skip_whitespace();
1406
1407             if (*pStr != ',')
1408                 break;
1409
1410             pStr.advance_in_line_no_end_check(1);
1411
1412             pStr.skip_whitespace();
1413         }
1414
1415         if (pStr.get_and_advance() != end_char)
1416         {
1417             error_info.set_error(pStr.get_cur_line(), "Unexpected character within object or array");
1418             return false;
1419         }
1420
1421         return true;
1422     }
1423
1424     static const uint8 g_utf8_first_byte[7] =
1425         {
1426             0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC
1427         };
1428
1429     bool json_value::estimate_deserialized_string_size(json_deserialize_buf_ptr &pStr, json_error_info_t &error_info, uint &size)
1430     {
1431         json_deserialize_buf_ptr pTmpStr(pStr);
1432         uint len = 0;
1433         for (;;)
1434         {
1435             char c = pTmpStr.get_and_advance();
1436             if ((!c) || (c == '\n'))
1437             {
1438                 error_info.set_error(pStr.get_cur_line(), "Missing end quote in string");
1439                 return false;
1440             }
1441             if (c == '\"')
1442                 break;
1443             else if (c == '\\')
1444             {
1445                 c = pTmpStr.get_and_advance();
1446                 if ((!c) || (c == '\n'))
1447                 {
1448                     error_info.set_error(pStr.get_cur_line(), "Missing escape character");
1449                     return false;
1450                 }
1451                 len++; // in case the escape char is a backslash
1452             }
1453             len++;
1454         }
1455         size = len;
1456         return true;
1457     }
1458
1459     // Note: This method assumes estimate_deserialized_string_size() was called on the string first, so it skips some checks.
1460     bool json_value::deserialize_quoted_string_to_buf(char *&pBuf, uint buf_size, json_deserialize_buf_ptr &pStr, json_error_info_t &error_info)
1461     {
1462         VOGL_NOTE_UNUSED(buf_size);
1463
1464         char *pDst = pBuf;
1465         for (;;)
1466         {
1467             char c = pStr.get_and_advance();
1468             if (c == '\"')
1469                 break;
1470             else if (c == '\\')
1471             {
1472                 c = pStr.get_and_advance();
1473                 if (c == 'u')
1474                 {
1475                     uint u = 0;
1476                     for (uint i = 0; i < 4; i++)
1477                     {
1478                         u <<= 4;
1479                         int c = vogl_tolower(pStr.get_and_advance());
1480                         if ((c >= 'a') && (c <= 'f'))
1481                             u += c - 'a' + 10;
1482                         else if ((c >= '0') && (c <= '9'))
1483                             u += c - '0';
1484                         else
1485                         {
1486                             error_info.set_error(pStr.get_cur_line(), "Invalid Unicode escape");
1487                             return false;
1488                         }
1489                     }
1490
1491                     uint len;
1492                     if ((u) && (u < 0x80))
1493                         len = 1;
1494                     else if (u < 0x800)
1495                         len = 2;
1496                     else
1497                         len = 3;
1498
1499                     pDst += len;
1500                     switch (len)
1501                     {
1502                         case 3:
1503                             *--pDst = static_cast<char>((u | 0x80) & 0xBF);
1504                             u >>= 6; // falls through
1505                         case 2:
1506                             *--pDst = static_cast<char>((u | 0x80) & 0xBF);
1507                             u >>= 6; // falls through
1508                         case 1:
1509                             *--pDst = static_cast<char>(u | g_utf8_first_byte[len]);
1510                     }
1511                     pDst += len;
1512                 }
1513                 else
1514                 {
1515                     switch (c)
1516                     {
1517                         case 'b':
1518                             c = '\b';
1519                             break;
1520                         case 'f':
1521                             c = '\f';
1522                             break;
1523                         case 'n':
1524                             c = '\n';
1525                             break;
1526                         case 'r':
1527                             c = '\r';
1528                             break;
1529                         case 't':
1530                             c = '\t';
1531                             break;
1532                         case '\\':
1533                         case '\"':
1534                         case '/':
1535                             break;
1536                         default:
1537                             *pDst++ = '\\';
1538                             break; // unrecognized escape, so forcefully escape the backslash
1539                     }
1540
1541                     *pDst++ = c;
1542                 }
1543             }
1544             else
1545             {
1546                 *pDst++ = c;
1547             }
1548         }
1549
1550         *pDst = '\0';
1551
1552         VOGL_ASSERT((pDst - pBuf) < (int)buf_size);
1553
1554         pBuf = pDst;
1555
1556         return true;
1557     }
1558
1559     bool json_value::deserialize_string(json_deserialize_buf_ptr &pStr, json_error_info_t &error_info)
1560     {
1561         pStr.advance_in_line_no_end_check(1);
1562
1563         uint estimated_len;
1564         if (!estimate_deserialized_string_size(pStr, error_info, estimated_len))
1565             return false;
1566
1567         uint buf_size = estimated_len + 1;
1568         char *pBuf = (char *)vogl_malloc(buf_size);
1569         if (!pBuf)
1570         {
1571             error_info.set_error(pStr.get_cur_line(), "Out of memory");
1572             return false;
1573         }
1574
1575         char *pDst = pBuf;
1576         if (!deserialize_quoted_string_to_buf(pDst, buf_size, pStr, error_info))
1577             return false;
1578
1579         set_value_assume_ownership(pBuf);
1580
1581         return true;
1582     }
1583
1584     bool json_value::is_equal(const json_value &other, double tol) const
1585     {
1586         if (this == &other)
1587             return true;
1588
1589         if (get_type() != other.get_type())
1590         {
1591             if (is_numeric() && other.is_numeric())
1592                 return math::equal_tol(as_double(), other.as_double(), tol);
1593             return false;
1594         }
1595
1596         switch (get_type())
1597         {
1598             case cJSONValueTypeNull:
1599                 return true;
1600             case cJSONValueTypeBool:
1601             case cJSONValueTypeInt:
1602                 return m_data.m_nVal == other.m_data.m_nVal;
1603             case cJSONValueTypeDouble:
1604                 return math::equal_tol(m_data.m_flVal, other.m_data.m_flVal, tol);
1605             case cJSONValueTypeString:
1606                 return !strcmp(m_data.m_pStr, other.m_data.m_pStr);
1607             case cJSONValueTypeNode:
1608             {
1609                 const json_node *pNode = get_node_ptr();
1610                 const json_node *pOther_node = other.get_node_ptr();
1611                 if (pNode->is_object() != pOther_node->is_object())
1612                     return false;
1613
1614                 if (pNode->size() != pOther_node->size())
1615                     return false;
1616
1617                 for (uint i = 0; i < pNode->size(); i++)
1618                 {
1619                     if ((pNode->is_object()) && (pNode->get_key(i).compare(pOther_node->get_key(i), true) != 0))
1620                         return false;
1621                     if (!pNode->get_value(i).is_equal(pOther_node->get_value(i), tol))
1622                         return false;
1623                 }
1624             }
1625         }
1626
1627         return true;
1628     }
1629
1630     static const double g_pow10_table[63] =
1631         {
1632             1.e-031, 1.e-030, 1.e-029, 1.e-028, 1.e-027, 1.e-026, 1.e-025, 1.e-024, 1.e-023, 1.e-022, 1.e-021, 1.e-020, 1.e-019, 1.e-018, 1.e-017, 1.e-016,
1633             1.e-015, 1.e-014, 1.e-013, 1.e-012, 1.e-011, 1.e-010, 1.e-009, 1.e-008, 1.e-007, 1.e-006, 1.e-005, 1.e-004, 1.e-003, 1.e-002, 1.e-001, 1.e+000,
1634             1.e+001, 1.e+002, 1.e+003, 1.e+004, 1.e+005, 1.e+006, 1.e+007, 1.e+008, 1.e+009, 1.e+010, 1.e+011, 1.e+012, 1.e+013, 1.e+014, 1.e+015, 1.e+016,
1635             1.e+017, 1.e+018, 1.e+019, 1.e+020, 1.e+021, 1.e+022, 1.e+023, 1.e+024, 1.e+025, 1.e+026, 1.e+027, 1.e+028, 1.e+029, 1.e+030, 1.e+031
1636         };
1637
1638     bool json_value::deserialize_number(json_deserialize_buf_ptr &pStr, json_error_info_t &error_info)
1639     {
1640         uint64_t n = 0, limit = cINT64_MAX;
1641         int sign = 1;
1642         bool bParseAsDouble = false;
1643
1644         char c = pStr.get_char();
1645         if (c == '-')
1646         {
1647             sign = -1;
1648             limit++;
1649             pStr.advance_in_line_no_end_check(1);
1650             c = pStr.get_char();
1651         }
1652
1653         while ((c >= '0') && (c <= '9'))
1654         {
1655             if (n > 0x1999999999999998ULL)
1656             {
1657                 bParseAsDouble = true;
1658                 break;
1659             }
1660             n = n * 10U + c - '0';
1661             pStr.advance_in_line_no_end_check(1);
1662             c = pStr.get_char();
1663         }
1664
1665         if ((bParseAsDouble) || (n > limit) || (c == 'e') || (c == 'E') || (c == '.'))
1666         {
1667             double f = static_cast<double>(n);
1668             int scale = 0, escalesign = 1, escale = 0;
1669
1670             while ((c >= '0') && (c <= '9'))
1671             {
1672                 f = f * 10.0f + (c - '0');
1673                 pStr.advance_in_line_no_end_check(1);
1674                 c = pStr.get_char();
1675             }
1676
1677             if (c == '.')
1678             {
1679                 pStr.advance_in_line_no_end_check(1);
1680                 c = pStr.get_char();
1681                 while ((c >= '0') && (c <= '9'))
1682                 {
1683                     scale--;
1684                     f = f * 10.0f + (c - '0');
1685                     pStr.advance_in_line_no_end_check(1);
1686                     c = pStr.get_char();
1687                 }
1688             }
1689
1690             if ((c == 'e') || (c == 'E'))
1691             {
1692                 pStr.advance_in_line_no_end_check(1);
1693                 char c = pStr.get_char();
1694                 if (c == '-')
1695                 {
1696                     escalesign = -1;
1697                     pStr.advance_in_line_no_end_check(1);
1698                     c = pStr.get_char();
1699                 }
1700                 else if (c == '+')
1701                 {
1702                     pStr.advance_in_line_no_end_check(1);
1703                     c = pStr.get_char();
1704                 }
1705                 while ((c >= '0') && (c <= '9'))
1706                 {
1707                     if (escale > 0xCCCCCCB)
1708                     {
1709                         error_info.set_error(pStr.get_cur_line(), "Failed parsing numeric value");
1710                         return false;
1711                     }
1712                     escale = escale * 10 + (c - '0');
1713                     pStr.advance_in_line_no_end_check(1);
1714                     c = pStr.get_char();
1715                 }
1716             }
1717
1718             double v = sign * f;
1719             int64_t final_scale = scale + escale * escalesign;
1720             if ((final_scale < -31) || (final_scale > 31))
1721             {
1722                 if ((final_scale < cINT32_MIN) || (final_scale > cINT32_MAX))
1723                 {
1724                     error_info.set_error(pStr.get_cur_line(), "Failed parsing numeric value");
1725                     return false;
1726                 }
1727                 v *= pow(10.0, static_cast<int>(final_scale));
1728             }
1729             else
1730                 v *= g_pow10_table[static_cast<int>(final_scale) + 31];
1731
1732             set_value(v);
1733         }
1734         else
1735         {
1736             int64_t v = static_cast<int64_t>(n);
1737             if (sign < 0)
1738                 v = -v;
1739             set_value(v);
1740         }
1741
1742         return true;
1743     }
1744
1745     bool json_value::deserialize_file(const char *pFilename, json_error_info_t *pError_info)
1746     {
1747         clear();
1748
1749         FILE *pFile = vogl_fopen(pFilename, "rb");
1750         if (!pFile)
1751         {
1752             if (pError_info)
1753                 pError_info->set_error(0, "Unable to open file");
1754             return false;
1755         }
1756
1757         bool success = deserialize(pFile, pError_info);
1758
1759         if (vogl_fclose(pFile) == EOF)
1760             success = false;
1761
1762         return success;
1763     }
1764
1765     bool json_value::deserialize(const vogl::vector<char> &buf, json_error_info_t *pError_info)
1766     {
1767         return deserialize(buf.get_ptr(), buf.size(), pError_info);
1768     }
1769
1770     bool json_value::deserialize(FILE *pFile, json_error_info_t *pError_info)
1771     {
1772         vogl_fseek(pFile, 0, SEEK_END);
1773         const uint64_t filesize = vogl_ftell(pFile);
1774         vogl_fseek(pFile, 0, SEEK_SET);
1775
1776         if ((filesize > VOGL_MAX_POSSIBLE_HEAP_BLOCK_SIZE) || (filesize != static_cast<size_t>(filesize)))
1777         {
1778             if (pError_info)
1779                 pError_info->set_error(0, "File too large");
1780             return false;
1781         }
1782
1783         char *pBuf = (char *)vogl_malloc(static_cast<size_t>(filesize) + 1);
1784         if (!pBuf)
1785         {
1786             if (pError_info)
1787                 pError_info->set_error(0, "Out of memory");
1788             return false;
1789         }
1790
1791         if (vogl_fread(pBuf, 1, static_cast<size_t>(filesize), pFile) != static_cast<size_t>(filesize))
1792         {
1793             vogl_free(pBuf);
1794             if (pError_info)
1795                 pError_info->set_error(0, "Failed reading from file");
1796             return false;
1797         }
1798
1799         // Not really necesssary
1800         pBuf[filesize] = '\0';
1801
1802         bool status = deserialize(pBuf, static_cast<size_t>(filesize), pError_info);
1803
1804         vogl_free(pBuf);
1805
1806         return status;
1807     }
1808
1809     bool json_value::deserialize(const char *pStr, json_error_info_t *pError_info)
1810     {
1811         return deserialize(pStr, strlen(pStr), pError_info);
1812     }
1813
1814     bool json_value::deserialize(const dynamic_string &str, json_error_info_t *pError_info)
1815     {
1816         return deserialize(str.get_ptr(), str.get_len(), pError_info);
1817     }
1818
1819     bool json_value::deserialize(const char *pBuf, size_t buf_size, json_error_info_t *pError_info)
1820     {
1821         set_value_to_null();
1822
1823         if (!buf_size)
1824         {
1825             if (pError_info)
1826                 pError_info->set_error(0, "Nothing to deserialize");
1827             return false;
1828         }
1829
1830         json_deserialize_buf_ptr buf_ptr(pBuf, buf_size);
1831         buf_ptr.skip_whitespace();
1832         if (*buf_ptr == '\0')
1833         {
1834             if (pError_info)
1835                 pError_info->set_error(0, "Nothing to deserialize");
1836             return false;
1837         }
1838
1839         json_error_info_t dummy_error_info;
1840         if (!deserialize(buf_ptr, NULL, 0, pError_info ? *pError_info : dummy_error_info))
1841             return false;
1842
1843         buf_ptr.skip_whitespace();
1844         if (!buf_ptr.at_end())
1845         {
1846             if (pError_info)
1847                 pError_info->set_error(buf_ptr.get_cur_line(), "Syntax error on/near line");
1848             return false;
1849         }
1850         return true;
1851     }
1852
1853     bool json_value::deserialize(json_deserialize_buf_ptr &pStr, json_node *pParent, uint level, json_error_info_t &error_info)
1854     {
1855         m_line = pStr.get_cur_line();
1856
1857         char c = *pStr;
1858         switch (c)
1859         {
1860             case '{':
1861             case '[':
1862                 return deserialize_node(pStr, pParent, level, error_info);
1863             case '\"':
1864                 return deserialize_string(pStr, error_info);
1865             case 'n':
1866             {
1867                 if (pStr.compare_string("null", 4))
1868                 {
1869                     set_value_to_null();
1870                     pStr.advance_in_line(4);
1871                     return true;
1872                 }
1873                 break;
1874             }
1875             case 't':
1876             {
1877                 if (pStr.compare_string("true", 4))
1878                 {
1879                     set_value(true);
1880                     pStr.advance_in_line(4);
1881                     return true;
1882                 }
1883                 break;
1884             }
1885             case 'f':
1886             {
1887                 if (pStr.compare_string("false", 5))
1888                 {
1889                     set_value(false);
1890                     pStr.advance_in_line(5);
1891                     return true;
1892                 }
1893                 break;
1894             }
1895             default:
1896             {
1897                 if ((c == '-') || (c == '.') || ((c >= '0') && (c <= '9')))
1898                     return deserialize_number(pStr, error_info);
1899                 break;
1900             }
1901         }
1902         error_info.set_error(pStr.get_cur_line(), "Unrecognized character: '%c'", c);
1903         return false;
1904     }
1905
1906     // class json_node
1907
1908     json_node::json_node()
1909         : m_pParent(NULL),
1910           m_line(0),
1911           m_is_object(false)
1912     {
1913     }
1914
1915     json_node::json_node(const json_node &other)
1916         : m_pParent(NULL),
1917           m_line(0),
1918           m_is_object(false)
1919     {
1920         *this = other;
1921     }
1922
1923     json_node::json_node(const json_node *pParent, bool is_object)
1924         : m_pParent(pParent),
1925           m_line(0),
1926           m_is_object(is_object)
1927     {
1928     }
1929
1930     json_node::~json_node()
1931     {
1932         clear();
1933     }
1934
1935     json_node &json_node::operator=(const json_node &rhs)
1936     {
1937         if (this == &rhs)
1938             return *this;
1939
1940         clear();
1941
1942         set_is_object(rhs.is_object());
1943         m_pParent = rhs.m_pParent;
1944
1945         if (is_object())
1946             m_keys.resize(rhs.size());
1947         m_values.resize(rhs.size());
1948
1949         for (uint i = 0; i < rhs.size(); i++)
1950         {
1951             if (is_object())
1952                 m_keys[i] = rhs.m_keys[i];
1953
1954             m_values[i] = rhs.m_values[i];
1955             if (m_values[i].is_node())
1956                 m_values[i].get_node_ptr()->m_pParent = this;
1957
1958             //VOGL_ASSERT(m_values[i].validate(this));
1959         }
1960
1961         m_line = rhs.m_line;
1962
1963         return *this;
1964     }
1965
1966     const json_value &json_node::find_value(const char *pKey) const
1967     {
1968         int index = find_key(pKey);
1969         return (index < 0) ? g_null_json_value : m_values[index];
1970     }
1971
1972     int json_node::find_key(const char *pKey) const
1973     {
1974         for (uint i = 0; i < m_keys.size(); i++)
1975             if (m_keys[i] == pKey)
1976                 return i;
1977         return cInvalidIndex;
1978     }
1979
1980     int json_node::find_child(const json_node *pNode) const
1981     {
1982         for (uint i = 0; i < m_values.size(); i++)
1983             if (m_values[i].get_node_ptr() == pNode)
1984                 return i;
1985         return cInvalidIndex;
1986     }
1987
1988     json_value_type_t json_node::find_value_type(const char *pKey) const
1989     {
1990         int index = find_key(pKey);
1991         return (index >= 0) ? get_value_type(index) : cJSONValueTypeNull;
1992     }
1993
1994     const json_node *json_node::find_child(const char *pKey) const
1995     {
1996         int index = find_key(pKey);
1997         return (index >= 0) ? get_child(index) : NULL;
1998     }
1999
2000     json_node *json_node::find_child(const char *pKey)
2001     {
2002         int index = find_key(pKey);
2003         return (index >= 0) ? get_child(index) : NULL;
2004     }
2005
2006     const json_node *json_node::find_child_array(const char *pKey) const
2007     {
2008         const json_node *pNode = find_child(pKey);
2009         return (pNode && pNode->is_array()) ? pNode : NULL;
2010     }
2011
2012     json_node *json_node::find_child_array(const char *pKey)
2013     {
2014         json_node *pNode = find_child(pKey);
2015         return (pNode && pNode->is_array()) ? pNode : NULL;
2016     }
2017
2018     const json_node *json_node::find_child_object(const char *pKey) const
2019     {
2020         const json_node *pNode = find_child(pKey);
2021         return (pNode && pNode->is_object()) ? pNode : NULL;
2022     }
2023
2024     bool json_node::are_all_children_values() const
2025     {
2026         for (uint i = 0; i < m_values.size(); i++)
2027             if (m_values[i].is_object_or_array())
2028                 return false;
2029         return true;
2030     }
2031
2032     bool json_node::are_all_children_objects() const
2033     {
2034         for (uint i = 0; i < m_values.size(); i++)
2035             if (!m_values[i].is_object())
2036                 return false;
2037         return true;
2038     }
2039
2040     bool json_node::are_all_children_arrays() const
2041     {
2042         for (uint i = 0; i < m_values.size(); i++)
2043             if (!m_values[i].is_array())
2044                 return false;
2045         return true;
2046     }
2047
2048     bool json_node::are_all_children_objects_or_arrays() const
2049     {
2050         for (uint i = 0; i < m_values.size(); i++)
2051             if (!m_values[i].is_object_or_array())
2052                 return false;
2053         return true;
2054     }
2055
2056     json_node *json_node::find_child_object(const char *pKey)
2057     {
2058         json_node *pNode = find_child(pKey);
2059         return (pNode && pNode->is_object()) ? pNode : NULL;
2060     }
2061
2062     bool json_node::get_value_as_string(const char *pKey, dynamic_string &val, const char *pDef) const
2063     {
2064         int index = find_key(pKey);
2065         if (index < 0)
2066         {
2067             val.set(pDef);
2068             return false;
2069         }
2070         return m_values[index].get_string(val, pDef);
2071     }
2072
2073     bool json_node::get_value_as_int64(const char *pKey, int64_t &val, int64_t def) const
2074     {
2075         int index = find_key(pKey);
2076         if (index < 0)
2077         {
2078             val = def;
2079             return false;
2080         }
2081         return m_values[index].get_numeric(val, def);
2082     }
2083
2084     bool json_node::get_value_as_uint32(const char *pKey, uint32 &val, uint32 def) const
2085     {
2086         int index = find_key(pKey);
2087         if (index < 0)
2088         {
2089             val = def;
2090             return false;
2091         }
2092         return m_values[index].get_numeric(val, def);
2093     }
2094
2095     bool json_node::get_value_as_uint64(const char *pKey, uint64_t &val, uint64_t def) const
2096     {
2097         int index = find_key(pKey);
2098         if (index < 0)
2099         {
2100             val = def;
2101             return false;
2102         }
2103         return m_values[index].get_numeric(val, def);
2104     }
2105
2106     bool json_node::get_value_as_float(const char *pKey, float &val, float def) const
2107     {
2108         int index = find_key(pKey);
2109         if (index < 0)
2110         {
2111             val = def;
2112             return false;
2113         }
2114         return m_values[index].get_numeric(val, def);
2115     }
2116
2117     bool json_node::get_value_as_double(const char *pKey, double &val, double def) const
2118     {
2119         int index = find_key(pKey);
2120         if (index < 0)
2121         {
2122             val = def;
2123             return false;
2124         }
2125         return m_values[index].get_numeric(val, def);
2126     }
2127
2128     bool json_node::get_value_as_bool(const char *pKey, bool &val, bool def) const
2129     {
2130         int index = find_key(pKey);
2131         if (index < 0)
2132         {
2133             val = def;
2134             return false;
2135         }
2136         return m_values[index].get_bool(val, def);
2137     }
2138
2139     dynamic_string json_node::value_as_string(const char *pKey, const char *pDef) const
2140     {
2141         dynamic_string result;
2142         get_value_as_string(pKey, result, pDef);
2143         return result;
2144     }
2145
2146     const char *json_node::value_as_string_ptr(const char *pKey, const char *pDef) const
2147     {
2148         int index = find_key(pKey);
2149         if (index < 0)
2150             return pDef;
2151         return value_as_string_ptr(index, pDef);
2152     }
2153
2154     int json_node::value_as_int(const char *pKey, int def) const
2155     {
2156         int result;
2157         get_value_as_int(pKey, result, def);
2158         return result;
2159     }
2160
2161     int32 json_node::value_as_int32(const char *pKey, int32 def) const
2162     {
2163         int32 result;
2164         get_value_as_int(pKey, result, def);
2165         return result;
2166     }
2167
2168     uint32 json_node::value_as_uint32(const char *pKey, uint32 def) const
2169     {
2170         uint32 result;
2171         get_value_as_uint32(pKey, result, def);
2172         return result;
2173     }
2174
2175     uint64_t json_node::value_as_uint64(const char *pKey, uint64_t def) const
2176     {
2177         uint64_t result;
2178         get_value_as_uint64(pKey, result, def);
2179         return result;
2180     }
2181
2182     int64_t json_node::value_as_int64(const char *pKey, int64_t def) const
2183     {
2184         int64_t result;
2185         get_value_as_int(pKey, result, def);
2186         return result;
2187     }
2188
2189     float json_node::value_as_float(const char *pKey, float def) const
2190     {
2191         float result;
2192         get_value_as_float(pKey, result, def);
2193         return result;
2194     }
2195
2196     double json_node::value_as_double(const char *pKey, double def) const
2197     {
2198         double result;
2199         get_value_as_double(pKey, result, def);
2200         return result;
2201     }
2202
2203     bool json_node::value_as_bool(const char *pKey, bool def) const
2204     {
2205         bool result;
2206         get_value_as_bool(pKey, result, def);
2207         return result;
2208     }
2209
2210     dynamic_string json_node::value_as_string(uint index, const char *pDef) const
2211     {
2212         return m_values[index].as_string(pDef);
2213     }
2214
2215     const char *json_node::value_as_string_ptr(uint index, const char *pDef) const
2216     {
2217         return m_values[index].as_string_ptr(pDef);
2218     }
2219
2220     int json_node::value_as_int(uint index, int def) const
2221     {
2222         return m_values[index].as_int(def);
2223     }
2224
2225     int32 json_node::value_as_int32(uint index, int32 def) const
2226     {
2227         return m_values[index].as_int32(def);
2228     }
2229
2230     int64_t json_node::value_as_int64(uint index, int64_t def) const
2231     {
2232         return m_values[index].as_int64(def);
2233     }
2234
2235     uint64_t json_node::value_as_uint64(uint index, uint64_t def) const
2236     {
2237         return m_values[index].as_uint64(def);
2238     }
2239
2240     uint32 json_node::value_as_uint32(uint index, uint32 def) const
2241     {
2242         return m_values[index].as_uint32(def);
2243     }
2244
2245     float json_node::value_as_float(uint index, float def) const
2246     {
2247         return m_values[index].as_float(def);
2248     }
2249
2250     double json_node::value_as_double(uint index, double def) const
2251     {
2252         return m_values[index].as_double(def);
2253     }
2254
2255     bool json_node::value_as_bool(uint index, bool def) const
2256     {
2257         return m_values[index].as_bool(def);
2258     }
2259
2260     void json_node::clear()
2261     {
2262         m_keys.clear();
2263         m_values.clear();
2264         m_is_object = false;
2265         m_line = 0;
2266     }
2267
2268     void json_node::resize(uint new_size)
2269     {
2270         if (m_is_object)
2271             m_keys.resize(new_size, true);
2272         m_values.resize(new_size, true);
2273     }
2274
2275     void json_node::reserve(uint new_capacity)
2276     {
2277         if (m_is_object)
2278             m_keys.reserve(new_capacity);
2279         m_values.reserve(new_capacity);
2280     }
2281
2282     void json_node::set_is_object(bool is_object)
2283     {
2284         if (m_is_object == is_object)
2285             return;
2286         if (is_object)
2287             m_keys.resize(size());
2288         else
2289             m_keys.clear();
2290         m_is_object = is_object;
2291     }
2292
2293     void json_node::ensure_is_object()
2294     {
2295         if (!m_is_object)
2296         {
2297             m_is_object = true;
2298             m_keys.resize(m_values.size());
2299         }
2300     }
2301
2302     json_value &json_node::add_key_value(const char *pKey, const json_value &val)
2303     {
2304         ensure_is_object();
2305
2306         uint new_index = m_values.size();
2307
2308         m_keys.push_back(pKey);
2309
2310         m_values.push_back(val);
2311         if (val.is_node())
2312             m_values[new_index].get_node_ptr()->m_pParent = this;
2313
2314         return m_values[new_index];
2315     }
2316
2317     json_value &json_node::add_value()
2318     {
2319         if (m_is_object)
2320             m_keys.enlarge(1);
2321         return *m_values.enlarge(1);
2322     }
2323
2324     json_value &json_node::add_value(const json_value &val)
2325     {
2326         uint new_index = m_values.size();
2327
2328         if (m_is_object)
2329             m_keys.enlarge(1);
2330
2331         m_values.push_back(val);
2332         if (val.is_node())
2333             m_values[new_index].get_node_ptr()->m_pParent = this;
2334
2335         return m_values[new_index];
2336     }
2337
2338     bool json_node::add_key_and_parsed_value(const char *pKey, const char *pStr)
2339     {
2340         json_value val;
2341         if (!val.deserialize(pStr))
2342             return false;
2343
2344         ensure_is_object();
2345
2346         m_keys.push_back(pKey);
2347
2348         json_value *p = m_values.enlarge(1);
2349         val.release_ownership(*p);
2350         if (p->is_node())
2351             p->get_node_ptr()->m_pParent = this;
2352
2353         return true;
2354     }
2355
2356     bool json_node::add_parsed_value(const char *pStr)
2357     {
2358         json_value val;
2359         if (!val.deserialize(pStr))
2360             return false;
2361
2362         if (m_is_object)
2363             m_keys.enlarge(1);
2364
2365         json_value *p = m_values.enlarge(1);
2366         val.release_ownership(*p);
2367         if (p->is_node())
2368             p->get_node_ptr()->m_pParent = this;
2369
2370         return true;
2371     }
2372
2373     dynamic_string &json_node::get_key(uint index)
2374     {
2375         if (!m_is_object)
2376         {
2377             VOGL_ASSERT_ALWAYS;
2378             return g_empty_dynamic_string;
2379         }
2380         return m_keys[index];
2381     }
2382
2383     void json_node::set_key_value(uint index, const char *pKey, const json_value &val)
2384     {
2385         ensure_is_object();
2386         m_keys[index].set(pKey);
2387
2388         m_values[index] = val;
2389         if (m_values[index].is_node())
2390             m_values[index].get_node_ptr()->m_pParent = this;
2391     }
2392
2393     void json_node::set_key(uint index, const char *pKey)
2394     {
2395         ensure_is_object();
2396         m_keys[index].set(pKey);
2397     }
2398
2399     void json_node::set_value(uint index, const json_value &val)
2400     {
2401         m_values[index] = val;
2402         if (m_values[index].is_node())
2403             m_values[index].get_node_ptr()->m_pParent = this;
2404     }
2405
2406     void json_node::set_value_assume_ownership(uint index, json_value &val)
2407     {
2408         json_value &val_to_set = m_values[index];
2409         val_to_set.set_value_to_null();
2410         val_to_set.swap(val);
2411
2412         if (val_to_set.is_node())
2413             val_to_set.get_node_ptr()->m_pParent = this;
2414     }
2415
2416     void json_node::add_value_assume_ownership(json_value &val)
2417     {
2418         if (m_is_object)
2419             m_keys.enlarge(1);
2420         uint new_index = m_values.size();
2421         m_values.enlarge(1);
2422         set_value_assume_ownership(new_index, val);
2423     }
2424
2425     void json_node::add_key_value_assume_ownership(const char *pKey, json_value &val)
2426     {
2427         ensure_is_object();
2428         m_keys.push_back(pKey);
2429
2430         uint new_index = m_values.size();
2431         m_values.enlarge(1);
2432         set_value_assume_ownership(new_index, val);
2433     }
2434
2435     json_value &json_node::get_or_add(const char *pKey)
2436     {
2437         int index = find_key(pKey);
2438         if (index >= 0)
2439             return m_values[index];
2440
2441         ensure_is_object();
2442         m_keys.push_back(pKey);
2443         return *m_values.enlarge(1);
2444     }
2445
2446     json_value &json_node::add(const char *pKey)
2447     {
2448         ensure_is_object();
2449         m_keys.push_back(pKey);
2450         return *m_values.enlarge(1);
2451     }
2452
2453     json_node &json_node::add_object(const char *pKey)
2454     {
2455         ensure_is_object();
2456         m_keys.push_back(pKey);
2457
2458         json_node *pNode = get_json_node_pool()->alloc(this, true);
2459         m_values.enlarge(1);
2460         m_values.back().set_value_assume_ownership(pNode);
2461         return *pNode;
2462     }
2463
2464     json_node &json_node::add_array(const char *pKey)
2465     {
2466         ensure_is_object();
2467         m_keys.push_back(pKey);
2468
2469         json_node *pNode = get_json_node_pool()->alloc(this, false);
2470         m_values.enlarge(1)->set_value_assume_ownership(pNode);
2471         return *pNode;
2472     }
2473
2474     json_node &json_node::add_object()
2475     {
2476         if (m_is_object)
2477             m_keys.enlarge(1);
2478         json_node *pNode = get_json_node_pool()->alloc(this, true);
2479         m_values.enlarge(1)->set_value_assume_ownership(pNode);
2480         return *pNode;
2481     }
2482
2483     json_node &json_node::add_array()
2484     {
2485         if (m_is_object)
2486             m_keys.enlarge(1);
2487         json_node *pNode = get_json_node_pool()->alloc(this, false);
2488         m_values.enlarge(1)->set_value_assume_ownership(pNode);
2489         return *pNode;
2490     }
2491
2492     bool json_node::erase(const char *pKey)
2493     {
2494         int index = find_key(pKey);
2495         if (index >= 0)
2496         {
2497             erase(index);
2498             return true;
2499         }
2500         return false;
2501     }
2502
2503     void json_node::erase(uint index)
2504     {
2505         if (m_is_object)
2506             m_keys.erase(index);
2507         m_values.erase(index);
2508     }
2509
2510     bool json_node::basic_validation(const json_node *pParent) const
2511     {
2512         if (m_pParent != pParent)
2513             return false;
2514
2515         if (!m_is_object)
2516         {
2517             if (m_keys.size())
2518                 return false;
2519         }
2520         else if (m_keys.size() != m_values.size())
2521             return false;
2522
2523         return true;
2524     }
2525
2526     bool json_node::validate(const json_node *pParent) const
2527     {
2528         if (!basic_validation(pParent))
2529             return false;
2530
2531         for (uint i = 0; i < m_values.size(); i++)
2532             if (!m_values[i].validate(this))
2533                 return false;
2534
2535         return true;
2536     }
2537
2538     dynamic_string json_node::get_path_to_node() const
2539     {
2540         dynamic_string_array node_names;
2541
2542         const json_node *pCur_node = this;
2543
2544         for (;;)
2545         {
2546             const json_node *pParent = pCur_node->m_pParent;
2547
2548             if (!pParent)
2549             {
2550                 node_names.push_back("[root]");
2551                 break;
2552             }
2553
2554             int parent_child_index = pParent->find_child(pCur_node);
2555             if (parent_child_index < 0)
2556             {
2557                 VOGL_VERIFY(0);
2558                 break;
2559             }
2560
2561             if (pParent->is_array())
2562                 node_names.push_back(dynamic_string(cVarArg, "[%u]", parent_child_index));
2563             else
2564                 node_names.push_back(pParent->get_key(parent_child_index));
2565
2566             pCur_node = pParent;
2567         }
2568
2569         dynamic_string result;
2570         for (int i = node_names.size() - 1; i >= 0; i--)
2571         {
2572             result.append(node_names[i]);
2573             if (i)
2574                 result.append("/");
2575         }
2576
2577         return result;
2578     }
2579
2580     dynamic_string json_node::get_path_to_key(const char *pKey) const
2581     {
2582         dynamic_string path(get_path_to_node());
2583         path.append("/");
2584         path.append(pKey);
2585         return path;
2586     }
2587
2588     dynamic_string json_node::get_path_to_item(uint index) const
2589     {
2590         dynamic_string path(get_path_to_node());
2591         if (is_array())
2592             path.append(dynamic_string(cVarArg, "/[%u]", index).get_ptr());
2593         else
2594             path.append(dynamic_string(cVarArg, "/%s", m_keys[index].get_ptr()).get_ptr());
2595         return path;
2596     }
2597
2598     bool json_node::check_for_duplicate_keys() const
2599     {
2600         VOGL_VERIFY(validate(m_pParent));
2601
2602         bool status = false;
2603
2604         if (m_is_object)
2605         {
2606             dynamic_string_array sorted_keys(m_keys);
2607
2608             sorted_keys.sort(dynamic_string_less_than_case_sensitive());
2609
2610             for (uint i = 0; i < sorted_keys.size(); i++)
2611             {
2612                 uint count = 1;
2613
2614                 while (((i + 1) < sorted_keys.size()) && (sorted_keys[i].compare(sorted_keys[i + 1], true) == 0))
2615                 {
2616                     count++;
2617                     i++;
2618                 }
2619
2620                 VOGL_ASSERT(((i + 1) == sorted_keys.size()) || (sorted_keys[i].compare(sorted_keys[i + 1], true) < 0));
2621
2622                 if (count > 1)
2623                 {
2624                     status = true;
2625
2626                     console::debug("%s: Key appears %u times in node: %s\n", VOGL_METHOD_NAME, count, get_path_to_item(i).get_ptr());
2627                 }
2628             }
2629         }
2630
2631         for (uint i = 0; i < m_values.size(); i++)
2632         {
2633             const json_node *pChild = get_child(i);
2634
2635             if ((pChild) && (pChild->check_for_duplicate_keys()))
2636                 status = true;
2637         }
2638
2639         return status;
2640     }
2641
2642     void json_node::serialize(vogl::vector<char> &buf, bool formatted, uint cur_indent, bool null_terminate, uint max_line_len) const
2643     {
2644         json_growable_char_buf growable_buf(buf);
2645         if ((cur_indent) && (formatted))
2646             growable_buf.print_tabs(cur_indent);
2647         serialize(growable_buf, formatted, cur_indent, max_line_len);
2648         if (null_terminate)
2649             buf.push_back('\0');
2650     }
2651
2652     void json_node::serialize(dynamic_string &str, bool formatted, uint cur_index, uint max_line_len) const
2653     {
2654         vogl::vector<char> buf;
2655         serialize(buf, formatted, cur_index, max_line_len);
2656
2657         // FIXME: Pass along string ownership once dynamic_string supports non-pow2 sized buffers
2658         str.set_from_buf(buf.get_ptr(), vogl_strlen(buf.get_ptr()));
2659     }
2660
2661     void json_node::serialize(json_growable_char_buf &buf, bool formatted, uint cur_indent, uint max_line_len) const
2662     {
2663         if (is_object())
2664         {
2665             VOGL_ASSERT(m_keys.size() == m_values.size());
2666         }
2667         else
2668         {
2669             VOGL_ASSERT(!m_keys.size());
2670         }
2671
2672         if (!size())
2673         {
2674             if (formatted)
2675                 buf.puts(is_object() ? "{ }" : "[ ]");
2676             else
2677                 buf.puts(is_object() ? "{}" : "[]");
2678             return;
2679         }
2680
2681         const uint cMaxLineLen = max_line_len;
2682
2683 #if 0
2684         if (formatted && !has_children() && !is_object() && (size() <= 40))
2685         {
2686                 uint orig_buf_size = buf.size();
2687                 buf.puts("[ ");
2688
2689                 for (uint i = 0; i < size(); i++)
2690                 {
2691                         dynamic_string val;
2692                         get_value(i).get_string(val);
2693                         if (get_value_type(i) == cJSONValueTypeString)
2694                                 buf.print_escaped(val.get_ptr());
2695                         else
2696                                 buf.puts(val.get_ptr());
2697
2698                         if (i != size() - 1)
2699                         {
2700                                 buf.print_char(',');
2701                                 buf.print_char(' ');
2702                         }
2703
2704                         if ((buf.size() - orig_buf_size) > cMaxLineLen)
2705                                 break;
2706                 }
2707
2708                 buf.puts(" ]");
2709
2710                 if ((buf.size() - orig_buf_size) <= cMaxLineLen)
2711                         return;
2712
2713                 buf.get().resize(orig_buf_size);
2714         }
2715 #else
2716         if (formatted && !has_children() && !is_object())
2717         {
2718             uint line_start_ofs = buf.size();
2719
2720             buf.puts("[ ");
2721             if (formatted && !cMaxLineLen)
2722                 buf.print_char('\n');
2723
2724             for (uint i = 0; i < size(); i++)
2725             {
2726                 dynamic_string val;
2727                 get_value(i).get_string(val);
2728
2729                 if (formatted && !cMaxLineLen)
2730                     buf.print_tabs(cur_indent);
2731
2732                 if (get_value_type(i) == cJSONValueTypeString)
2733                     buf.print_escaped(val.get_ptr());
2734                 else
2735                     buf.puts(val.get_ptr());
2736
2737                 if (i != size() - 1)
2738                 {
2739                     buf.print_char(',');
2740                     if (formatted && !cMaxLineLen)
2741                         buf.print_char('\n');
2742                 }
2743
2744                 if (cMaxLineLen)
2745                 {
2746                     if ((buf.size() - line_start_ofs) >= cMaxLineLen)
2747                     {
2748                         buf.print_char('\n');
2749
2750                         buf.print_tabs(cur_indent);
2751
2752                         line_start_ofs = buf.size();
2753                     }
2754                     else if (i != size() - 1)
2755                         buf.print_char(' ');
2756                 }
2757             }
2758
2759             buf.puts(" ]");
2760
2761             return;
2762         }
2763 #endif
2764
2765         buf.print_char(is_object() ? '{' : '[');
2766         if (formatted)
2767             buf.print_char('\n');
2768
2769         cur_indent++;
2770
2771         dynamic_string val;
2772
2773         for (uint i = 0; i < size(); i++)
2774         {
2775             if (formatted)
2776                 buf.print_tabs(cur_indent);
2777             if (is_object())
2778             {
2779                 buf.print_escaped(get_key(i).get_ptr());
2780                 buf.puts(formatted ? " : " : ":");
2781             }
2782
2783             json_value_type_t val_type = get_value_type(i);
2784             if (val_type == cJSONValueTypeNode)
2785                 get_child(i)->serialize(buf, formatted, cur_indent, max_line_len);
2786             else if (val_type == cJSONValueTypeString)
2787                 buf.print_escaped(get_value(i).as_string_ptr());
2788             else
2789             {
2790                 get_value(i).get_string(val);
2791                 buf.puts(val.get_ptr());
2792             }
2793
2794             if (i != size() - 1)
2795                 buf.print_char(',');
2796             if (formatted)
2797                 buf.print_char('\n');
2798         }
2799
2800         cur_indent--;
2801
2802         if (formatted)
2803             buf.print_tabs(cur_indent);
2804         buf.print_char(is_object() ? '}' : ']');
2805     }
2806
2807     void json_node::binary_serialize(vogl::vector<uint8> &buf) const
2808     {
2809         uint8 *pDst;
2810         uint n = m_values.size();
2811         if (n <= 254)
2812         {
2813             pDst = buf.enlarge(2);
2814             pDst[0] = m_is_object ? 'o' : 'a';
2815             pDst[1] = static_cast<uint8>(n);
2816         }
2817         else
2818         {
2819             pDst = buf.enlarge(5);
2820             pDst[0] = m_is_object ? 'O' : 'A';
2821             pDst[1] = static_cast<uint8>(n >> 24);
2822             pDst[2] = static_cast<uint8>(n >> 16);
2823             pDst[3] = static_cast<uint8>(n >> 8);
2824             pDst[4] = static_cast<uint8>(n);
2825         }
2826         if (!n)
2827             return;
2828
2829         const dynamic_string *pKey = m_keys.get_ptr();
2830         const json_value *pVal = m_values.get_ptr();
2831         for (uint i = n; i; --i, ++pKey, ++pVal)
2832         {
2833             if (m_is_object)
2834             {
2835                 uint len = pKey->get_len();
2836                 if (len <= 254)
2837                 {
2838                     uint8 *pDst = buf.enlarge(2 + len);
2839                     pDst[0] = 's';
2840                     pDst[1] = static_cast<uint8>(len);
2841                     memcpy(pDst + 2, pKey->get_ptr(), len);
2842                 }
2843                 else
2844                 {
2845                     uint8 *pDst = buf.enlarge(5 + len);
2846                     pDst[0] = 'S';
2847                     pDst[1] = static_cast<uint8>(len >> 24);
2848                     pDst[2] = static_cast<uint8>(len >> 16);
2849                     pDst[3] = static_cast<uint8>(len >> 8);
2850                     pDst[4] = static_cast<uint8>(len);
2851                     memcpy(pDst + 5, pKey->get_ptr(), len);
2852                 }
2853             }
2854
2855             if (pVal->is_node())
2856                 pVal->get_node_ptr()->binary_serialize(buf);
2857             else
2858                 pVal->binary_serialize_value(buf);
2859         }
2860     }
2861
2862     bool json_node::has_children() const
2863     {
2864         for (uint i = 0; i < m_values.size(); i++)
2865             if (m_values[i].get_type() == cJSONValueTypeNode)
2866                 return true;
2867         return false;
2868     }
2869
2870     bool json_node::get_value_as_enum(const char *pKey, const char **pStringList, int &val, int def) const
2871     {
2872         val = def;
2873         int index = find_key(pKey);
2874         if (index < 0)
2875             return false;
2876         return get_value(index).get_enum(pStringList, val, def);
2877     }
2878
2879     // class json_document
2880
2881     json_document::json_document()
2882         : m_error_line(0)
2883     {
2884         init_object();
2885     }
2886
2887     json_document::json_document(const json_value &other)
2888         : m_error_line(0)
2889     {
2890         get_value() = other;
2891     }
2892
2893     json_document &json_document::operator=(const json_value &rhs)
2894     {
2895         if (&get_value() == &rhs)
2896             return *this;
2897
2898         clear();
2899
2900         get_value() = rhs;
2901
2902         return *this;
2903     }
2904
2905     json_document::json_document(const json_document &other)
2906         : json_value(other),
2907           m_error_line(0)
2908     {
2909         *this = other;
2910     }
2911
2912     json_document &json_document::operator=(const json_document &rhs)
2913     {
2914         if (this == &rhs)
2915             return *this;
2916
2917         clear();
2918
2919         m_error_msg = rhs.m_error_msg;
2920         m_error_line = rhs.m_error_line;
2921         m_filename = rhs.m_filename;
2922
2923         get_value() = rhs.get_value();
2924
2925         return *this;
2926     }
2927
2928     json_document::json_document(const char *pStr, const char *pFilename)
2929         : m_error_line(0)
2930     {
2931         deserialize(pStr, pFilename);
2932     }
2933
2934     json_document::json_document(const char *pBuf, uint n, const char *pFilename)
2935         : m_error_line(0)
2936     {
2937         deserialize(pBuf, n, pFilename);
2938     }
2939
2940     json_document::json_document(json_value_type_t value_type)
2941         : m_error_line(0)
2942     {
2943         init(value_type);
2944     }
2945
2946     json_document::~json_document()
2947     {
2948         clear();
2949     }
2950
2951     void json_document::swap(json_document &other)
2952     {
2953         std::swap(m_error_line, other.m_error_line);
2954         m_error_msg.swap(other.m_error_msg);
2955         m_filename.swap(other.m_filename);
2956         get_value().swap(other.get_value());
2957     }
2958
2959     bool json_document::deserialize_file(const char *pFilename)
2960     {
2961         set_filename(pFilename);
2962
2963         json_error_info_t err_info;
2964         if (!json_value::deserialize_file(pFilename, &err_info))
2965         {
2966             m_error_msg.swap(err_info.m_error_msg);
2967             m_error_line = err_info.m_error_line;
2968
2969             return false;
2970         }
2971
2972         return true;
2973     }
2974
2975     bool json_document::deserialize(const vogl::vector<char> &buf, const char *pFilename)
2976     {
2977         return deserialize(buf.get_ptr(), buf.size(), pFilename);
2978     }
2979
2980     bool json_document::deserialize(FILE *pFile, const char *pFilename)
2981     {
2982         set_filename(pFilename);
2983
2984         json_error_info_t err_info;
2985         if (!json_value::deserialize(pFile, &err_info))
2986         {
2987             m_error_msg.swap(err_info.m_error_msg);
2988             m_error_line = err_info.m_error_line;
2989
2990             return false;
2991         }
2992
2993         return true;
2994     }
2995
2996     bool json_document::deserialize(const char *pBuf, size_t n, const char *pFilename)
2997     {
2998         set_filename(pFilename);
2999
3000         json_error_info_t err_info;
3001         if (!json_value::deserialize(pBuf, n, &err_info))
3002         {
3003             m_error_msg.swap(err_info.m_error_msg);
3004             m_error_line = err_info.m_error_line;
3005
3006             return false;
3007         }
3008
3009         return true;
3010     }
3011
3012     bool json_document::deserialize(const char *pStr, const char *pFilename)
3013     {
3014         return deserialize(pStr, static_cast<uint>(strlen(pStr)), pFilename);
3015     }
3016
3017     bool json_document::deserialize(const dynamic_string &str, const char *pFilename)
3018     {
3019         return deserialize(str.get_ptr(), str.get_len(), pFilename);
3020     }
3021
3022     class my_type
3023     {
3024     public:
3025         vogl::vector<dynamic_string> a1;
3026         vogl::map<dynamic_string, dynamic_string_array> a2;
3027         dynamic_string a;
3028         dynamic_string b;
3029
3030         bool json_serialize(json_value &val) const
3031         {
3032             json_node *pObj = val.init_object();
3033             pObj->add_object("a1", a1);
3034             pObj->add_object("a2", a2);
3035             pObj->add_object("a", a);
3036             pObj->add_object("b", b);
3037             return true;
3038         }
3039
3040         bool json_deserialize(const json_value &val)
3041         {
3042             const json_node *pObj = val.get_node_ptr();
3043             if (!pObj)
3044                 return false;
3045             pObj->get_object("a1", a1);
3046             pObj->get_object("a2", a2);
3047             pObj->get_object("a", a);
3048             pObj->get_object("b", b);
3049             return true;
3050         }
3051     };
3052
3053     // TODO: Actually test these classes.
3054     bool json_test()
3055     {
3056         // Create a JSON document
3057         json_document doc;
3058         json_node *pRoot = doc.get_root();
3059
3060         typedef vogl::growable_array<uint, 16> my_growable_array_type;
3061         my_growable_array_type growable_array;
3062         growable_array.push_back(99);
3063         growable_array.push_back(100);
3064         pRoot->add_object("growable_array", growable_array);
3065         pRoot->get_object("growable_array", growable_array);
3066
3067         pRoot->add_vector("growable_array2", growable_array);
3068         pRoot->get_vector("growable_array2", growable_array);
3069
3070         // Create a vector of my_type's, put it into a JSON document, then retrieve it into another vector.
3071         typedef vogl::vector<my_type> my_type_vec;
3072
3073         my_type_vec mv;
3074         mv.resize(2);
3075         mv[0].a1.push_back("a");
3076         mv[0].a1.push_back("b");
3077         mv[0].a1.push_back("c");
3078         dynamic_string_array dsa;
3079         dsa.push_back("1");
3080         mv[0].a2.insert("zz", dsa);
3081         dsa.push_back("2");
3082         mv[0].a2.insert("xx", dsa);
3083         dsa.push_back("3");
3084         mv[0].a2.insert("yy", dsa);
3085         mv[0].a = "one";
3086         mv[0].b = "two";
3087         mv[1].a = "three";
3088         mv[1].b = "four";
3089
3090         pRoot->add_vector("my_type_vec", mv);
3091
3092         pRoot->add_object("hey", 2);
3093         int z = 0;
3094         pRoot->get_object("hey", z);
3095
3096         pRoot->add_object("blah", mv);
3097         pRoot->get_object("blah", mv);
3098
3099         my_type_vec mv2;
3100         pRoot->get_vector("my_type_vec", mv2);
3101
3102         printf("my_type_vec:\n");
3103         for (uint i = 0; i < mv2.size(); i++)
3104         {
3105             printf("a: %s\nb: %s\n", mv2[i].a.get_ptr(), mv2[i].b.get_ptr());
3106         }
3107
3108         // Create a string set and add it to the JSON document under the "set" object
3109         typedef vogl::map<dynamic_string> string_set;
3110         string_set ss;
3111         ss.insert("blah");
3112         pRoot->add_map("set", ss);
3113
3114         typedef vogl::vector<int16> cool_vec;
3115         cool_vec blah;
3116         blah.push_back(1);
3117         blah.push_back(3);
3118         blah.push_back(5);
3119         pRoot->add_vector("vec", blah);
3120
3121         cool_vec blah2;
3122         pRoot->get_vector("vec", blah2);
3123         printf("vec:\n");
3124         for (uint i = 0; i < blah2.size(); i++)
3125             printf("%i\n", blah2[i]);
3126
3127         // Now create a string to string array map
3128         typedef vogl::map<dynamic_string, dynamic_string_array> string_map;
3129         string_map s;
3130
3131         dynamic_string_array sa;
3132         sa.push_back("a");
3133         s.insert("1", sa);
3134
3135         dynamic_string_array sb;
3136         sb.push_back("b");
3137         sb.push_back("c");
3138         sb.push_back("d");
3139         s.insert("2", sb);
3140
3141         // Add the string to string map to the JSON document under the "hashmap" object
3142         pRoot->add_map("hashmap", s);
3143
3144         // Now serialize the JSON document to text and print it to stdout
3145         dynamic_string str;
3146         doc.serialize(str);
3147         printf("JSON: %s\n", str.get_ptr());
3148
3149         // Retrieve the string map under the "hashmap" object and put it into q
3150         string_map q;
3151         pRoot->get_map("hashmap", q);
3152
3153         // Now print q
3154         printf("hashmap:\n");
3155         for (string_map::const_iterator it = q.begin(); it != q.end(); ++it)
3156         {
3157             const dynamic_string_array &b = it->second;
3158
3159             printf("%s :\n", it->first.get_ptr());
3160             for (uint i = 0; i < b.size(); i++)
3161                 printf(" %s\n", b[i].get_ptr());
3162         }
3163
3164         return true;
3165     }
3166
3167 } // namespace vogl