Bump OculusVR RIFT SDK to 0.5.0.1vanilla_0.5.0.1

1 files changed, 1332 insertions, 0 deletions

diff --git a/LibOVRKernel/Src/Kernel/OVR_JSON.cpp b/LibOVRKernel/Src/Kernel/OVR_JSON.cpp
new file mode 100644
index 0000000..b0ae183
--- /dev/null
+++ b/LibOVRKernel/Src/Kernel/OVR_JSON.cpp
@@ -0,0 +1,1332 @@
+/************************************************************************************
+
+PublicHeader:   None
+Filename    :   OVR_JSON.h
+Content     :   JSON format reader and writer
+Created     :   April 9, 2013
+Author      :   Brant Lewis
+Notes       :
+  The code is a derivative of the cJSON library written by Dave Gamble and subject 
+  to the following permissive copyright.
+
+  Copyright (c) 2009 Dave Gamble
+ 
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+ 
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+ 
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
+
+
+Copyright   :   Copyright 2014 Oculus VR, LLC All Rights reserved.
+
+Licensed under the Oculus VR Rift SDK License Version 3.2 (the "License"); 
+you may not use the Oculus VR Rift SDK except in compliance with the License, 
+which is provided at the time of installation or download, or which 
+otherwise accompanies this software in either electronic or hard copy form.
+
+You may obtain a copy of the License at
+
+http://www.oculusvr.com/licenses/LICENSE-3.2 
+
+Unless required by applicable law or agreed to in writing, the Oculus VR SDK 
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+************************************************************************************/
+
+#include <string.h>
+#include <stdio.h>
+#include <math.h>
+#include <stdlib.h>
+#include <float.h>
+#include <limits.h>
+#include <ctype.h>
+#include "OVR_JSON.h"
+#include "OVR_SysFile.h"
+#include "OVR_Log.h"
+
+
+namespace OVR {
+
+
+//-----------------------------------------------------------------------------
+// Create a new copy of a string
+static char* JSON_strdup(const char* str)
+{
+    size_t len  = OVR_strlen(str) + 1;
+    char* copy = (char*)OVR_ALLOC(len);
+    if (!copy)
+        return 0;
+    memcpy(copy, str, len);
+    return copy;
+}
+
+
+//-----------------------------------------------------------------------------
+// Render the number from the given item into a string.
+static char* PrintInt(int valueint)
+{
+    char *str;
+    str = (char*)OVR_ALLOC(21);    // 2^64+1 can be represented in 21 chars.
+    if (str)
+    {
+        OVR_sprintf(str, 21, "%d", valueint);
+    }
+    return str;
+}
+
+
+//-----------------------------------------------------------------------------
+// Render the number from the given item into a string.
+static char* PrintNumber(double d)
+{
+    char *str;
+    int valueint = (int)d;
+
+    if ((fabs(((double)valueint)-d) <= DBL_EPSILON) && (d <= INT_MAX) && (d >= INT_MIN))
+    {
+        return PrintInt(valueint);
+    }
+    else
+    {
+        const size_t kCapacity = 64;
+
+        str=(char*)OVR_ALLOC(kCapacity);    // This is a nice tradeoff.
+        if (str)
+        {
+            // The JSON Standard, section 7.8.3, specifies that decimals are always expressed with '.' and 
+            // not some locale-specific decimal such as ',' or ' '. However, since we are using the C standard
+            // library below to write a floating point number, we need to make sure that it's writing a '.' 
+            // and not something else. We can't change the locale (even temporarily) here, as it will affect 
+            // the whole process by default. That are compiler-specific ways to change this per-thread, but 
+            // below we implement the simple solution of simply fixing the decimal after the string was written.
+
+            if ((fabs(floor(d)-d) <= DBL_EPSILON) && (fabs(d) < 1.0e60))
+                OVR_sprintf(str, kCapacity, "%.0f", d);
+            else if ((fabs(d) < 1.0e-6) || (fabs(d) > 1.0e9))
+                OVR_sprintf(str, kCapacity, "%e", d);
+            else
+                OVR_sprintf(str, kCapacity, "%f", d);
+
+            // Convert any found ',' or ''' char to '.'. This will happen only if the locale was set to write a ',' 
+            // instead of a '.' for the decimal point. Decimal points are represented only by one of these
+            // three characters in practice.
+            for(char* p = str; *p; p++)
+            {
+                if((*p == ',') || (*p == '\''))
+                {
+                    *p = '.';
+                    break;
+                }
+            }
+        }
+    }
+    return str;
+}
+
+
+// Parse the input text into an un-escaped cstring, and populate item.
+static const unsigned char firstByteMark[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
+
+// Helper to assign error sting and return 0.
+const char* AssignError(const char** perror, const char *errorMessage)
+{
+    if (perror)
+        *perror = errorMessage;
+    return 0;
+}
+
+//-----------------------------------------------------------------------------
+// ***** JSON Node class
+
+JSON::JSON(JSONItemType itemType) :
+    Type(itemType), dValue(0.)
+{
+}
+
+JSON::~JSON()
+{
+    JSON* child = Children.GetFirst();
+    while (!Children.IsNull(child))
+    {
+        child->RemoveNode();
+        child->Release();
+        child = Children.GetFirst();
+    }
+}
+
+//-----------------------------------------------------------------------------
+// Parse the input text to generate a number, and populate the result into item
+// Returns the text position after the parsed number
+const char* JSON::parseNumber(const char *num)
+{
+    const char* num_start = num;
+    double      n=0, scale=0;
+    int         subscale     = 0,
+                signsubscale = 1;
+    bool        positiveSign = true;
+    const char  decimalSeparator = '.';  // The JSON standard specifies that numbers use '.' regardless of locale.
+
+    // Could use sscanf for this?
+    if (*num == '-')
+    {
+        positiveSign = false;
+        num++;    // Has sign?
+    }
+    if (*num == '0')
+    {
+        num++;            // is zero
+    }
+
+    if (*num>='1' && *num<='9')    
+    {
+        do
+        {
+            n = (n*10.0) + (*num++ - '0');
+        }
+        while (*num>='0' && *num<='9');    // Number?
+    }
+
+    if ((*num=='.' || *num==decimalSeparator) && num[1]>='0' && num[1]<='9')
+    {
+        num++;
+        do
+        {
+            n=(n*10.0)+(*num++ -'0');
+            scale--;
+        }
+        while (*num>='0' && *num<='9');  // Fractional part?
+    }
+
+    if (*num=='e' || *num=='E')        // Exponent?
+    {
+        num++;
+        if (*num == '+')
+        {
+            num++;
+        }
+        else if (*num=='-')
+        {
+            signsubscale=-1;
+            num++;        // With sign?
+        }
+
+        while (*num >= '0' && *num <= '9')
+        {
+            subscale = (subscale * 10) + (*num++ - '0');    // Number?
+        }
+    }
+
+    // Number = +/- number.fraction * 10^+/- exponent
+    n *= pow(10.0, (scale + subscale*signsubscale));
+
+    if (!positiveSign)
+    {
+        n = -n;
+    }
+
+    // Assign parsed value.
+    Type = JSON_Number;
+    dValue = n;
+    Value.AssignString(num_start, num - num_start);
+
+    return num;
+}
+
+// Parses a hex string up to the specified number of digits.
+// Returns the first character after the string.
+const char* ParseHex(unsigned* val, unsigned digits, const char* str)
+{
+    *val = 0;
+
+    for(unsigned digitCount = 0; digitCount < digits; digitCount++, str++)
+    {
+        unsigned v = *str;
+
+        if ((v >= '0') && (v <= '9'))
+            v -= '0';
+        else if ((v >= 'a') && (v <= 'f'))
+            v = 10 + v - 'a';
+        else if ((v >= 'A') && (v <= 'F'))
+            v = 10 + v - 'A';
+        else
+            break;
+
+        *val = *val * 16 + v;
+    }
+
+    return str;
+}
+
+//-----------------------------------------------------------------------------
+// Parses the input text into a string item and returns the text position after
+// the parsed string
+const char* JSON::parseString(const char* str, const char** perror)
+{
+    const char* ptr = str+1;
+    const char* p;
+    char*       ptr2;
+    char*       out;
+    int         len=0;
+    unsigned    uc, uc2;
+    
+    if (*str!='\"')
+    {
+        return AssignError(perror, "Syntax Error: Missing quote");
+    }
+    
+    while (*ptr!='\"' && *ptr && ++len)
+    {   
+        if (*ptr++ == '\\') ptr++;    // Skip escaped quotes.
+    }
+    
+    // This is how long we need for the string, roughly.
+    out=(char*)OVR_ALLOC(len+1);
+    if (!out)
+        return 0;
+    
+    ptr = str+1;
+    ptr2= out;
+
+    while (*ptr!='\"' && *ptr)
+    {
+        if (*ptr!='\\')
+        {
+            *ptr2++ = *ptr++;
+        }
+        else
+        {
+            ptr++;
+            switch (*ptr)
+            {
+                case 'b': *ptr2++ = '\b';    break;
+                case 'f': *ptr2++ = '\f';    break;
+                case 'n': *ptr2++ = '\n';    break;
+                case 'r': *ptr2++ = '\r';    break;
+                case 't': *ptr2++ = '\t';    break;
+
+                // Transcode utf16 to utf8.
+                case 'u':
+
+                    // Get the unicode char.
+                    p = ParseHex(&uc, 4, ptr + 1);
+                    if (ptr != p)
+                        ptr = p - 1;
+
+                    if ((uc>=0xDC00 && uc<=0xDFFF) || uc==0)
+                        break;    // Check for invalid.
+
+                    // UTF16 surrogate pairs.
+                    if (uc>=0xD800 && uc<=0xDBFF)
+                    {
+                        if (ptr[1]!='\\' || ptr[2]!='u')
+                            break;    // Missing second-half of surrogate.
+
+                        p= ParseHex(&uc2, 4, ptr + 3);
+                        if (ptr != p)
+                            ptr = p - 1;
+                        
+                        if (uc2<0xDC00 || uc2>0xDFFF)
+                            break;    // Invalid second-half of surrogate.
+
+                        uc = 0x10000 + (((uc&0x3FF)<<10) | (uc2&0x3FF));
+                    }
+
+                    len=4;
+                    
+                    if (uc<0x80)
+                        len=1;
+                    else if (uc<0x800)
+                        len=2;
+                    else if (uc<0x10000)
+                        len=3;
+                    
+                    ptr2+=len;
+                    
+                    switch (len)
+                    {
+                        case 4: *--ptr2 =((uc | 0x80) & 0xBF); uc >>= 6;
+                            //no break, fall through
+                        case 3: *--ptr2 =((uc | 0x80) & 0xBF); uc >>= 6;
+                            //no break
+                        case 2: *--ptr2 =((uc | 0x80) & 0xBF); uc >>= 6;
+                            //no break
+                        case 1: *--ptr2 = (char)(uc | firstByteMark[len]);
+                            //no break
+                    }
+                    ptr2+=len;
+                    break;
+
+                default:
+                    *ptr2++ = *ptr;
+                    break;
+            }
+            ptr++;
+        }
+    }
+
+    *ptr2 = 0;
+    if (*ptr=='\"')
+        ptr++;
+    
+    // Make a copy of the string 
+    Value=out;
+    OVR_FREE(out);
+    Type=JSON_String;
+
+    return ptr;
+}
+
+//-----------------------------------------------------------------------------
+// Render the string provided to an escaped version that can be printed.
+char* PrintString(const char* str)
+{
+    const char *ptr;
+    char *ptr2,*out;
+    int len=0;
+    unsigned char token;
+    
+    if (!str)
+        return JSON_strdup("");
+    ptr=str;
+    
+    token=*ptr;
+    while (token && ++len)\
+    {
+        if (strchr("\"\\\b\f\n\r\t",token))
+            len++;
+        else if (token<32) 
+            len+=5;
+        ptr++;
+        token=*ptr;
+    }
+    
+    int buff_size = len+3;
+    out=(char*)OVR_ALLOC(buff_size);
+    if (!out)
+        return 0;
+
+    ptr2 = out;
+    ptr  = str;
+    *ptr2++ = '\"';
+
+    while (*ptr)
+    {
+        if ((unsigned char)*ptr>31 && *ptr!='\"' && *ptr!='\\') 
+            *ptr2++=*ptr++;
+        else
+        {
+            *ptr2++='\\';
+            switch (token=*ptr++)
+            {
+                case '\\':    *ptr2++='\\';    break;
+                case '\"':    *ptr2++='\"';    break;
+                case '\b':    *ptr2++='b';    break;
+                case '\f':    *ptr2++='f';    break;
+                case '\n':    *ptr2++='n';    break;
+                case '\r':    *ptr2++='r';    break;
+                case '\t':    *ptr2++='t';    break;
+                default: 
+                    OVR_sprintf(ptr2, buff_size - (ptr2-out), "u%04x",token);
+                    ptr2+=5;
+                    break;    // Escape and print.
+            }
+        }
+    }
+    *ptr2++='\"';
+    *ptr2++=0;
+    return out;
+}
+
+//-----------------------------------------------------------------------------
+// Utility to jump whitespace and cr/lf
+static const char* skip(const char* in)
+{
+    while (in && *in && (unsigned char)*in<=' ') 
+        in++; 
+    return in;
+}
+
+//-----------------------------------------------------------------------------
+// Parses the supplied buffer of JSON text and returns a JSON object tree
+// The returned object must be Released after use
+JSON* JSON::Parse(const char* buff, const char** perror)
+{
+    const char* end = 0;
+    JSON*       json = new JSON();
+    
+    if (!json)
+    {
+        AssignError(perror, "Error: Failed to allocate memory");
+        return 0;
+    }
+ 
+    end = json->parseValue(skip(buff), perror);
+    if (!end)
+    {
+        json->Release();
+        return NULL;
+    }    // parse failure. ep is set.
+
+    return json;
+}
+
+//-----------------------------------------------------------------------------
+// This version works for buffers that are not null terminated strings.
+JSON* JSON::ParseBuffer(const char *buff, int len, const char** perror)
+{
+    // Our JSON parser does not support length-based parsing,
+    // so ensure it is null-terminated.
+    char *termStr = new char[len + 1];
+    memcpy(termStr, buff, len);
+    termStr[len] = '\0';
+
+    JSON *objJson = Parse(termStr, perror);
+
+    delete[]termStr;
+
+    return objJson;
+}
+
+//-----------------------------------------------------------------------------
+// Parser core - when encountering text, process appropriately.
+const char* JSON::parseValue(const char* buff, const char** perror)
+{
+    if (perror)
+        *perror = 0;
+
+    if (!buff)
+        return NULL;    // Fail on null.
+
+    if (!OVR_strncmp(buff, "null", 4))
+    {
+        Type = JSON_Null;
+        return buff + 4;
+    }
+    if (!OVR_strncmp(buff, "false", 5))
+    { 
+        Type   = JSON_Bool;
+        Value  = "false";
+        dValue = 0.;
+        return buff + 5;
+    }
+    if (!OVR_strncmp(buff, "true", 4))
+    {
+        Type   = JSON_Bool;
+        Value  = "true";
+        dValue = 1.;
+        return buff + 4;
+    }
+    if (*buff=='\"')
+    {
+        return parseString(buff, perror);
+    }
+    if (*buff=='-' || (*buff>='0' && *buff<='9'))
+    { 
+        return parseNumber(buff);
+    }
+    if (*buff=='[')
+    { 
+        return parseArray(buff, perror);
+    }
+    if (*buff=='{')
+    {
+        return parseObject(buff, perror);
+    }
+
+    return AssignError(perror, "Syntax Error: Invalid syntax");
+}
+
+//-----------------------------------------------------------------------------
+// Render a value to text. 
+char* JSON::PrintValue(int depth, bool fmt)
+{
+    char *out=0;
+
+    switch (Type)
+    {
+        case JSON_Null:        out = JSON_strdup("null");    break;
+        case JSON_Bool:
+            if ((int)dValue == 0)
+                out = JSON_strdup("false");
+            else
+                out = JSON_strdup("true");
+            break;
+        case JSON_Number:    out = PrintNumber(dValue); break;
+        case JSON_String:    out = PrintString(Value); break;
+        case JSON_Array:    out = PrintArray(depth, fmt); break;
+        case JSON_Object:    out = PrintObject(depth, fmt); break;
+        case JSON_None: OVR_ASSERT_LOG(false, ("Bad JSON type.")); break;
+    }
+    return out;
+}
+
+//-----------------------------------------------------------------------------
+// Build an array object from input text and returns the text position after
+// the parsed array
+const char* JSON::parseArray(const char* buff, const char** perror)
+{
+    JSON *child;
+    if (*buff!='[')
+    {
+        return AssignError(perror, "Syntax Error: Missing opening bracket");
+    }
+
+    Type=JSON_Array;
+    buff=skip(buff+1);
+    
+    if (*buff==']')
+        return buff+1;    // empty array.
+
+    child = new JSON();
+    if (!child)
+        return 0;         // memory fail
+    Children.PushBack(child);
+    
+    buff=skip(child->parseValue(skip(buff), perror));    // skip any spacing, get the buff. 
+    if (!buff)
+        return 0;
+
+    while (*buff==',')
+    {
+        JSON *new_item = new JSON();
+        if (!new_item)
+            return AssignError(perror, "Error: Failed to allocate memory");
+        
+        Children.PushBack(new_item);
+
+        buff=skip(new_item->parseValue(skip(buff+1), perror));
+        if (!buff)
+            return AssignError(perror, "Error: Failed to allocate memory");
+    }
+
+    if (*buff==']')
+        return buff+1;    // end of array
+
+    return AssignError(perror, "Syntax Error: Missing ending bracket");
+}
+
+//-----------------------------------------------------------------------------
+// Render an array to text.  The returned text must be freed
+char* JSON::PrintArray(int depth, bool fmt)
+{
+    char **  entries;
+    char *   out = 0, *ptr,*ret;
+    intptr_t len = 5;
+    
+    bool fail = false;
+    
+    // How many entries in the array? 
+    int numentries = GetItemCount();
+    if (!numentries)
+    {
+        out=(char*)OVR_ALLOC(3);
+        if (out)
+            OVR_strcpy(out, 3, "[]");
+        return out;
+    }
+    // Allocate an array to hold the values for each
+    entries=(char**)OVR_ALLOC(numentries*sizeof(char*));
+    if (!entries)
+        return 0;
+    memset(entries,0,numentries*sizeof(char*));
+
+    //// Retrieve all the results:
+    JSON* child = Children.GetFirst();
+    for (int i=0; i<numentries; i++)
+    {
+        //JSON* child = Children[i];
+        ret=child->PrintValue(depth+1, fmt);
+        entries[i]=ret;
+        if (ret)
+            len+=OVR_strlen(ret)+2+(fmt?1:0);
+        else
+        {
+            fail = true;
+            break;
+        }
+        child = Children.GetNext(child);
+    }
+    
+    // If we didn't fail, try to malloc the output string 
+    if (!fail)
+        out=(char*)OVR_ALLOC(len);
+    // If that fails, we fail. 
+    if (!out)
+        fail = true;
+
+    // Handle failure.
+    if (fail)
+    {
+        for (int i=0; i<numentries; i++) 
+        {
+            if (entries[i])
+                OVR_FREE(entries[i]);
+        }
+        OVR_FREE(entries);
+        return 0;
+    }
+    
+    // Compose the output array.
+    *out='[';
+    ptr=out+1;
+    *ptr=0;
+    for (int i=0; i<numentries; i++)
+    {
+        OVR_strcpy(ptr, len - (ptr-out), entries[i]);
+        ptr+=OVR_strlen(entries[i]);
+        if (i!=numentries-1)
+        {
+            *ptr++=',';
+            if (fmt)
+                *ptr++=' ';
+            *ptr=0;
+        }
+        OVR_FREE(entries[i]);
+    }
+    OVR_FREE(entries);
+    *ptr++=']';
+    *ptr++=0;
+    return out;    
+}
+
+//-----------------------------------------------------------------------------
+// Build an object from the supplied text and returns the text position after
+// the parsed object
+const char* JSON::parseObject(const char* buff, const char** perror)
+{
+    if (*buff!='{')
+    {
+        return AssignError(perror, "Syntax Error: Missing opening brace");
+    }
+    
+    Type=JSON_Object;
+    buff=skip(buff+1);
+    if (*buff=='}')
+        return buff+1;    // empty array.
+    
+    JSON* child = new JSON();
+    Children.PushBack(child);
+
+    buff=skip(child->parseString(skip(buff), perror));
+    if (!buff) 
+        return 0;
+    child->Name = child->Value;
+    child->Value.Clear();
+    
+    if (*buff!=':')
+    {
+        return AssignError(perror, "Syntax Error: Missing colon");
+    }
+
+    buff=skip(child->parseValue(skip(buff+1), perror));    // skip any spacing, get the value.
+    if (!buff)
+        return 0;
+    
+    while (*buff==',')
+    {
+        child = new JSON();
+        if (!child)
+            return 0; // memory fail
+        
+        Children.PushBack(child);
+
+        buff=skip(child->parseString(skip(buff+1), perror));
+        if (!buff)
+            return 0;
+        
+        child->Name=child->Value;
+        child->Value.Clear();
+        
+        if (*buff!=':')
+        {
+            return AssignError(perror, "Syntax Error: Missing colon");
+        }    // fail!
+        
+        // Skip any spacing, get the value.
+        buff=skip(child->parseValue(skip(buff+1), perror));
+        if (!buff)
+            return 0;
+    }
+    
+    if (*buff=='}')
+        return buff+1;    // end of array 
+    
+    return AssignError(perror, "Syntax Error: Missing closing brace");
+}
+
+//-----------------------------------------------------------------------------
+// Render an object to text.  The returned string must be freed
+char* JSON::PrintObject(int depth, bool fmt)
+{
+    char**   entries = 0, **names = 0;
+    char*    out = 0;
+    char*    ptr, *ret, *str;
+    intptr_t len = 7, i = 0, j;
+    bool     fail = false;
+    
+    // Count the number of entries.
+    int numentries = GetItemCount();
+    
+    // Explicitly handle empty object case
+    if (numentries == 0)
+    {
+        out=(char*)OVR_ALLOC(fmt?depth+4:4);
+        if (!out)
+            return 0;
+        ptr=out;
+        *ptr++='{';
+        
+        if (fmt)
+        {
+            *ptr++='\n';
+            for (i=0;i<depth-1;i++)
+                *ptr++='\t';
+        }
+        *ptr++='}';
+        *ptr++=0;
+        return out;
+    }
+    // Allocate space for the names and the objects
+    entries=(char**)OVR_ALLOC(numentries*sizeof(char*));
+    if (!entries)
+        return 0;
+    names=(char**)OVR_ALLOC(numentries*sizeof(char*));
+    
+    if (!names)
+    {
+        OVR_FREE(entries);
+        return 0;
+    }
+    memset(entries,0,sizeof(char*)*numentries);
+    memset(names,0,sizeof(char*)*numentries);
+
+    // Collect all the results into our arrays:
+    depth++;
+    if (fmt)
+        len+=depth;
+
+    JSON* child = Children.GetFirst();
+    while (!Children.IsNull(child))
+    {
+        names[i]     = str = PrintString(child->Name);
+        entries[i++] = ret = child->PrintValue(depth, fmt);
+
+        if (str && ret)
+        {
+            len += OVR_strlen(ret)+OVR_strlen(str)+2+(fmt?3+depth:0);
+        }
+        else
+        {
+            fail = true;
+            break;
+        }
+        
+        child = Children.GetNext(child);
+    }
+    
+    // Try to allocate the output string
+    if (!fail)
+        out=(char*)OVR_ALLOC(len);
+    if (!out)
+        fail=true;
+
+    // Handle failure
+    if (fail)
+    {
+        for (i=0;i<numentries;i++)
+        {
+            if (names[i])
+                OVR_FREE(names[i]);
+            
+            if (entries[i])
+                OVR_FREE(entries[i]);}
+        
+        OVR_FREE(names);
+        OVR_FREE(entries);
+        return 0;
+    }
+    
+    // Compose the output:
+    *out = '{';
+    ptr  = out+1;
+    if (fmt)
+    {
+#ifdef OVR_OS_WIN32
+        *ptr++ = '\r';
+#endif
+        *ptr++ = '\n';
+    }
+    *ptr = 0;
+    
+    for (i=0; i<numentries; i++)
+    {
+        if (fmt)
+        {
+            for (j = 0; j < depth; j++)
+            {
+                *ptr++ = '\t';
+            }
+        }
+        OVR_strcpy(ptr, len - (ptr-out), names[i]);
+        ptr   += OVR_strlen(names[i]);
+        *ptr++ =':';
+        
+        if (fmt)
+        {
+            *ptr++ = '\t';
+        }
+        
+        OVR_strcpy(ptr, len - (ptr-out), entries[i]);
+        ptr+=OVR_strlen(entries[i]);
+        
+        if (i != numentries - 1)
+        {
+            *ptr++ = ',';
+        }
+        
+        if (fmt)
+        {
+#ifdef OVR_OS_WIN32
+            *ptr++ = '\r';
+#endif
+            *ptr++ = '\n';
+        }
+        *ptr = 0;
+        
+        OVR_FREE(names[i]);
+        OVR_FREE(entries[i]);
+    }
+    
+    OVR_FREE(names);
+    OVR_FREE(entries);
+    
+    if (fmt)
+    {
+        for (i = 0; i < depth - 1; i++)
+        {
+            *ptr++ = '\t';
+        }
+    }
+    *ptr++='}';
+    *ptr++=0;
+    
+    return out;    
+}
+
+
+
+// Returns the number of child items in the object
+// Counts the number of items in the object.
+unsigned JSON::GetItemCount() const
+{
+    unsigned count = 0;
+    for (const JSON* p = Children.GetFirst(); !Children.IsNull(p); p = Children.GetNext(p))
+    {
+        count++;
+    }
+    return count;
+}
+
+JSON* JSON::GetItemByIndex(unsigned index)
+{
+    unsigned i     = 0;
+    JSON*    child = 0;
+
+    if (!Children.IsEmpty())
+    {
+        child = Children.GetFirst();
+
+        while (i < index)
+        {   
+            if (Children.IsLast(child))
+            {
+                child = 0;
+                break;
+            }
+            child = child->GetNext();
+            i++;
+        }
+    }
+  
+    return child;
+}
+
+// Returns the child item with the given name or NULL if not found
+JSON* JSON::GetItemByName(const char* name)
+{
+    JSON* child = 0;
+
+    if (!Children.IsEmpty())
+    {
+        child = Children.GetFirst();
+
+        while (OVR_strcmp(child->Name, name) != 0)
+        {   
+            if (Children.IsLast(child))
+            {
+                child = 0;
+                break;
+            }
+            child = child->GetNext();
+        }
+    }
+
+    return child;
+}
+
+//-----------------------------------------------------------------------------
+// Adds a new item to the end of the child list
+void JSON::AddItem(const char *string, JSON *item)
+{
+    if (item)
+    {
+        item->Name = string;
+        Children.PushBack(item);
+    }
+}
+
+/*
+
+// Removes and frees the items at the given index
+void JSON::DeleteItem(unsigned int index)
+{
+    unsigned int num_items = 0;
+    JSON* child = Children.GetFirst();
+    while (!Children.IsNull(child) && num_items < index)
+    {   
+        num_items++;
+        child = Children.GetNext(child);
+    }
+
+    if (!Children.IsNull(child))
+    
+        child->RemoveNode();
+        child->Release();
+    }
+}
+
+// Replaces and frees the item at the give index with the new item
+void JSON::ReplaceItem(unsigned int index, JSON* new_item)
+{
+    unsigned int num_items = 0;
+    JSON* child = Children.GetFirst();
+    while (!Children.IsNull(child) && num_items < index)
+    {   
+        num_items++;
+        child = Children.GetNext(child);
+    }
+
+    if (!Children.IsNull(child))
+    {
+        child->ReplaceNodeWith(new_item);
+        child->Release();        
+    }
+}
+*/
+
+// Removes and frees the last child item
+void JSON::RemoveLast()
+{
+    JSON* child = Children.GetLast();
+    if (!Children.IsNull(child))
+    {
+        child->RemoveNode();
+        child->Release();
+    }
+}
+
+JSON* JSON::CreateBool(bool b)
+{
+    JSON *item = new JSON(JSON_Bool);
+    if (item)
+    {
+        item->dValue = b ? 1. : 0.;
+        item->Value = b ? "true" : "false";
+    }
+    return item;
+}
+
+JSON* JSON::CreateNumber(double num)
+{
+    JSON *item = new JSON(JSON_Number);
+    if (item)
+    {
+        item->dValue = num;
+    }
+    return item;
+}
+
+JSON* JSON::CreateInt(int num)
+{
+    JSON *item = new JSON(JSON_Number);
+    if (item)
+    {
+        item->dValue = num;
+    }
+    return item;
+}
+
+JSON* JSON::CreateString(const char *s)
+{
+    JSON *item = new JSON(JSON_String);
+    if (item && s)
+    {
+        item->Value = s;
+    }
+    return item;
+}
+
+
+//-----------------------------------------------------------------------------
+// Get elements by name
+double JSON::GetNumberByName(const char *name, double defValue)
+{
+    JSON* item = GetItemByName(name);
+    if (!item || item->Type != JSON_Number)
+    {
+        return defValue;
+    }
+    else
+    {
+        return item->dValue;
+    }
+}
+
+int JSON::GetIntByName(const char *name, int defValue)
+{
+    JSON* item = GetItemByName(name);
+    if (!item || item->Type != JSON_Number)
+    {
+        return defValue;
+    }
+    else
+    {
+        return (int)item->dValue;
+    }
+}
+
+bool JSON::GetBoolByName(const char *name, bool defValue)
+{
+    JSON* item = GetItemByName(name);
+    if (!item || item->Type != JSON_Bool)
+    {
+        return defValue;
+    }
+    else
+    {
+        return (int)item->dValue != 0;
+    }
+}
+
+String JSON::GetStringByName(const char *name, const String &defValue)
+{
+    JSON* item = GetItemByName(name);
+    if (!item || item->Type != JSON_String)
+    {
+        return defValue;
+    }
+    else
+    {
+        return item->Value;
+    }
+}
+
+
+int JSON::GetArrayByName(const char *name, double values[], int count)
+{
+    JSON* array = GetItemByName(name);
+    if (!array || array->Type != JSON_Array)
+        return 0;
+
+    int i = 0;
+    for (JSON* child = array->Children.GetFirst(); !array->Children.IsNull(child); child = array->Children.GetNext(child))
+    {
+        if (i >= count)
+            break;
+        values[i++] = child->dValue;
+    }
+
+    OVR_ASSERT(i <= count);
+    return i;
+}
+
+
+//-----------------------------------------------------------------------------
+// Adds an element to an array object type
+void JSON::AddArrayElement(JSON *item)
+{
+    if (item)
+    {
+        Children.PushBack(item);
+    }
+}
+
+// Inserts an element into a valid array position
+void JSON::InsertArrayElement(int index, JSON *item)
+{
+    if (!item)
+    {
+        return;
+    }
+
+    if (index == 0)
+    {
+        Children.PushFront(item);
+        return;
+    }
+
+    JSON* iter = Children.GetFirst();
+    int i=0;
+    while (iter && i<index)
+    {
+        iter = Children.GetNext(iter);
+        i++;
+    }
+
+    if (iter)
+        iter->InsertNodeBefore(item);
+    else
+        Children.PushBack(item);
+}
+
+// Returns the size of an array
+int JSON::GetArraySize()
+{
+    if (Type == JSON_Array)
+    {
+        return GetItemCount();
+    }
+
+    return 0;
+}
+
+// Returns the number value an the give array index
+double JSON::GetArrayNumber(int index)
+{
+    if (Type == JSON_Array)
+    {
+        JSON* number = GetItemByIndex(index);
+        return number ? number->dValue : 0.0;
+    }
+
+    return 0;
+}
+
+// Returns the string value at the given array index
+const char* JSON::GetArrayString(int index)
+{
+    if (Type == JSON_Array)
+    {
+        JSON* number = GetItemByIndex(index);
+        return number ? number->Value : 0;
+    }
+
+    return 0;
+}
+
+JSON* JSON::Copy()
+{
+    JSON* copy = new JSON(Type);
+    copy->Name = Name;
+    copy->Value = Value;
+    copy->dValue = dValue;
+
+    JSON* child = Children.GetFirst();
+    while (!Children.IsNull(child))
+    {
+        copy->Children.PushBack(child->Copy());
+        child = Children.GetNext(child);
+    }
+
+    return copy;
+}
+
+char* JSON::PrintValue(bool fmt)
+{
+    return PrintValue(0, fmt);
+}
+
+//-----------------------------------------------------------------------------
+// Loads and parses the given JSON file pathname and returns a JSON object tree.
+// The returned object must be Released after use.
+JSON* JSON::Load(const char* path, const char** perror)
+{
+    SysFile f;
+    if (!f.Open(path, File::Open_Read, File::Mode_Read))
+    {
+        AssignError(perror, "Failed to open file");
+        return NULL;
+    }
+
+    int    len   = f.GetLength();
+    uint8_t* buff  = (uint8_t*)OVR_ALLOC(len + 1);
+    int    bytes = f.Read(buff, len);
+    f.Close();
+
+    if (bytes == 0 || bytes != len)
+    {
+        OVR_FREE(buff);
+        return NULL;
+    }
+
+    // Ensure the result is null-terminated since Parse() expects null-terminated input.
+    buff[len] = '\0';
+
+    JSON* json = JSON::Parse((char*)buff, perror);
+    OVR_FREE(buff);
+    return json;
+}
+
+//-----------------------------------------------------------------------------
+// Serializes the JSON object and writes to the give file path
+bool JSON::Save(const char* path)
+{
+    SysFile f;
+    if (!f.Open(path, File::Open_Write | File::Open_Create | File::Open_Truncate, File::Mode_Write))
+        return false;
+
+    char* text = PrintValue(0, true);
+    if (text)
+    {
+        intptr_t len   = OVR_strlen(text);
+        OVR_ASSERT(len <= (intptr_t)(int)len);
+
+        int   bytes = f.Write((uint8_t*)text, (int)len);
+        f.Close();
+        OVR_FREE(text);
+        return (bytes == len);
+    }
+    else
+    {
+        return false;
+    }
+}
+
+//-----------------------------------------------------------------------------
+// Serializes the JSON object to a String
+String JSON::Stringify(bool fmt)
+{
+    char* text = PrintValue(0, fmt);
+    String copy(text);
+    OVR_FREE(text);
+    return copy;
+}
+
+
+} // namespace OVR