pilotlight/pl-libs
1
0
Fork 0
Code Actions
f33209447e
pl-libs/pl_json.h

2007 lines
68 KiB
C
Raw Blame History

/*
pl_json.h
Do this:
#define PL_JSON_IMPLEMENTATION
before you include this file in *one* C or C++ file to create the implementation.
// i.e. it should look like this:
#include ...
#include ...
#include ...
#define PL_JSON_IMPLEMENTATION
#include "pl_json.h"
*/
// library version
#define PL_JSON_VERSION "0.2.0"
#define PL_JSON_VERSION_NUM 00200
/*
Index of this file:
// [SECTION] header mess
// [SECTION] includes
// [SECTION] forward declarations
// [SECTION] public api
// [SECTION] internal structs
// [SECTION] jsmn.h
// [SECTION] c file
*/
//-----------------------------------------------------------------------------
// [SECTION] header mess
//-----------------------------------------------------------------------------
#ifndef PL_JSON_H
#define PL_JSON_H
#ifndef PL_JSON_MAX_NAME_LENGTH
#define PL_JSON_MAX_NAME_LENGTH 256
#endif
//-----------------------------------------------------------------------------
// [SECTION] includes
//-----------------------------------------------------------------------------
#include <stdint.h>
#include <stdbool.h>
//-----------------------------------------------------------------------------
// [SECTION] forward declarations
//-----------------------------------------------------------------------------
// basic types
typedef struct _plJsonObject plJsonObject; // opaque pointer
// enums
typedef int plJsonType; // internal
//-----------------------------------------------------------------------------
// [SECTION] public api
//-----------------------------------------------------------------------------
// main
bool pl_load_json (const char* cPtrJson, plJsonObject* tPtrJsonOut);
void pl_unload_json (plJsonObject* tPtrJson);
char* pl_write_json (plJsonObject* tPtrJson, char* pcBuffer, uint32_t* puBufferSize);
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~reading~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// members
plJsonObject* pl_json_member_by_name (plJsonObject* tPtrJson, const char* pcName);
plJsonObject* pl_json_member_by_index (plJsonObject* tPtrJson, uint32_t uIndex);
void pl_json_member_list (plJsonObject* tPtrJson, char** cPtrListOut, uint32_t* uPtrSizeOut, uint32_t* uPtrLength);
bool pl_json_member_exist (plJsonObject* tPtrJson, const char* pcName);
// retrieve and cast values (default used if member isn't present)
int pl_json_int_member (plJsonObject* tPtrJson, const char* pcName, int iDefaultValue);
uint32_t pl_json_uint_member (plJsonObject* tPtrJson, const char* pcName, uint32_t uDefaultValue);
float pl_json_float_member (plJsonObject* tPtrJson, const char* pcName, float fDefaultValue);
double pl_json_double_member (plJsonObject* tPtrJson, const char* pcName, double dDefaultValue);
char* pl_json_string_member (plJsonObject* tPtrJson, const char* pcName, char* cPtrDefaultValue, uint32_t uLength);
bool pl_json_bool_member (plJsonObject* tPtrJson, const char* pcName, bool bDefaultValue);
plJsonObject* pl_json_member (plJsonObject* tPtrJson, const char* pcName);
plJsonObject* pl_json_array_member (plJsonObject* tPtrJson, const char* pcName, uint32_t* uPtrSizeOut);
// retrieve and cast array values (default used if member isn't present)
void pl_json_int_array_member (plJsonObject* tPtrJson, const char* pcName, int* iPtrOut, uint32_t* uPtrSizeOut);
void pl_json_uint_array_member (plJsonObject* tPtrJson, const char* pcName, uint32_t* uPtrOut, uint32_t* uPtrSizeOut);
void pl_json_float_array_member (plJsonObject* tPtrJson, const char* pcName, float* fPtrOut, uint32_t* uPtrSizeOut);
void pl_json_double_array_member(plJsonObject* tPtrJson, const char* pcName, double* dPtrOut, uint32_t* uPtrSizeOut);
void pl_json_bool_array_member (plJsonObject* tPtrJson, const char* pcName, bool* bPtrOut, uint32_t* uPtrSizeOut);
void pl_json_string_array_member(plJsonObject* tPtrJson, const char* pcName, char** cPtrOut, uint32_t* uPtrSizeOut, uint32_t* uPtrLength);
// cast values
int pl_json_as_int (plJsonObject* tPtrJson);
uint32_t pl_json_as_uint (plJsonObject* tPtrJson);
float pl_json_as_float (plJsonObject* tPtrJson);
double pl_json_as_double (plJsonObject* tPtrJson);
const char* pl_json_as_string (plJsonObject* tPtrJson);
bool pl_json_as_bool (plJsonObject* tPtrJson);
// cast array values
void pl_json_as_int_array (plJsonObject* tPtrJson, int* iPtrOut, uint32_t* uPtrSizeOut);
void pl_json_as_uint_array (plJsonObject* tPtrJson, uint32_t* uPtrOut, uint32_t* uPtrSizeOut);
void pl_json_as_float_array (plJsonObject* tPtrJson, float* fPtrOut, uint32_t* uPtrSizeOut);
void pl_json_as_double_array (plJsonObject* tPtrJson, double* dPtrOut, uint32_t* uPtrSizeOut);
void pl_json_as_bool_array (plJsonObject* tPtrJson, bool* bPtrOut, uint32_t* uPtrSizeOut);
void pl_json_as_string_array (plJsonObject* tPtrJson, char** cPtrOut, uint32_t* uPtrSizeOut, uint32_t* uPtrLength);
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~writing~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
void pl_json_add_int_member (plJsonObject* tPtrJson, const char* pcName, int iValue);
void pl_json_add_uint_member (plJsonObject* tPtrJson, const char* pcName, uint32_t uValue);
void pl_json_add_float_member (plJsonObject* tPtrJson, const char* pcName, float fValue);
void pl_json_add_double_member (plJsonObject* tPtrJson, const char* pcName, double dValue);
void pl_json_add_bool_member (plJsonObject* tPtrJson, const char* pcName, bool bValue);
void pl_json_add_string_member (plJsonObject* tPtrJson, const char* pcName, const char* pcValue);
void pl_json_add_member (plJsonObject* tPtrJson, const char* pcName, plJsonObject* ptValue);
void pl_json_add_member_array (plJsonObject* tPtrJson, const char* pcName, plJsonObject* ptValues, uint32_t uSize);
void pl_json_add_int_array (plJsonObject* tPtrJson, const char* pcName, int* piValues, uint32_t uSize);
void pl_json_add_uint_array (plJsonObject* tPtrJson, const char* pcName, uint32_t* puValues, uint32_t uSize);
void pl_json_add_float_array (plJsonObject* tPtrJson, const char* pcName, float* pfValues, uint32_t uSize);
void pl_json_add_double_array (plJsonObject* tPtrJson, const char* pcName, double* pdValues, uint32_t uSize);
void pl_json_add_bool_array (plJsonObject* tPtrJson, const char* pcName, bool* pbValues, uint32_t uSize);
void pl_json_add_string_array (plJsonObject* tPtrJson, const char* pcName, char** ppcBuffer, uint32_t uSize);
//-----------------------------------------------------------------------------
// [SECTION] internal structs
//-----------------------------------------------------------------------------
typedef struct _plJsonObject
{
plJsonType tType;
uint32_t uChildCount;
char acName[PL_JSON_MAX_NAME_LENGTH];
plJsonObject* sbtChildren;
uint32_t uChildrenFound;
char* sbcBuffer;
char** psbcBuffer;
union
{
struct
{
uint32_t* sbuValueOffsets;
uint32_t* sbuValueLength;
};
struct
{
uint32_t uValueOffset;
uint32_t uValueLength;
};
};
} plJsonObject;
#endif //PL_JSON_H
#ifdef PL_JSON_IMPLEMENTATION
#ifndef PL_GLTF_EXTENSION_H
//-----------------------------------------------------------------------------
// [SECTION] jsmn.h
//-----------------------------------------------------------------------------
/*
* MIT License
*
* Copyright (c) 2010 Serge Zaitsev
*
* 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.
*/
#ifndef JSMN_H
#define JSMN_H
#include <stddef.h>
#ifdef __cplusplus
extern "C" {
#endif
#ifdef JSMN_STATIC
#define JSMN_API static
#else
#define JSMN_API extern
#endif
typedef enum
{
JSMN_UNDEFINED = 0,
JSMN_OBJECT = 1 << 0,
JSMN_ARRAY = 1 << 1,
JSMN_STRING = 1 << 2,
JSMN_PRIMITIVE = 1 << 3 // number, boolean (true/false) or null
} jsmntype_t;
enum jsmnerr
{
JSMN_ERROR_NOMEM = -1, // Not enough tokens were provided
JSMN_ERROR_INVAL = -2, // Invalid character inside JSON string
JSMN_ERROR_PART = -3 // The string is not a full JSON packet, more bytes expected
};
typedef struct jsmntok
{
jsmntype_t type; // type (object, array, string etc.)
int start; // start position in JSON data string
int end; // end position in JSON data string
int size;
} jsmntok_t;
typedef struct jsmn_parser
{
unsigned int pos; // offset in the JSON string
unsigned int toknext; // next token to allocate
int toksuper; // superior token node, e.g. parent object or array
} jsmn_parser;
JSMN_API void jsmn_init (jsmn_parser* parser);
JSMN_API int jsmn_parse(jsmn_parser* parser, const char* js, const size_t len, jsmntok_t* tokens, const unsigned int num_tokens);
#ifndef JSMN_HEADER
// allocates a fresh unused token from the token pool.
static jsmntok_t*
jsmn_alloc_token(jsmn_parser* parser, jsmntok_t* tokens, const size_t num_tokens)
{
jsmntok_t* tok;
if (parser->toknext >= num_tokens)
return NULL;
tok = &tokens[parser->toknext++];
tok->start = tok->end = -1;
tok->size = 0;
return tok;
}
// Fills token type and boundaries.
static void
jsmn_fill_token(jsmntok_t* token, const jsmntype_t type, const int start, const int end)
{
token->type = type;
token->start = start;
token->end = end;
token->size = 0;
}
// Fills next available token with JSON primitive.
static int
jsmn_parse_primitive(jsmn_parser* parser, const char* js, const size_t len, jsmntok_t* tokens, const size_t num_tokens)
{
jsmntok_t* token;
int start;
start = parser->pos;
for (; parser->pos < len && js[parser->pos] != '\0'; parser->pos++)
{
switch (js[parser->pos])
{
/* In strict mode primitive must be followed by "," or "}" or "]" */
case ':':
case '\t':
case '\r':
case '\n':
case ' ':
case ',':
case ']':
case '}':
goto found;
default:
/* to quiet a warning from gcc*/
break;
}
if (js[parser->pos] < 32 || js[parser->pos] >= 127)
{
parser->pos = start;
return JSMN_ERROR_INVAL;
}
}
found:
if (tokens == NULL)
{
parser->pos--;
return 0;
}
token = jsmn_alloc_token(parser, tokens, num_tokens);
if (token == NULL)
{
parser->pos = start;
return JSMN_ERROR_NOMEM;
}
jsmn_fill_token(token, JSMN_PRIMITIVE, start, parser->pos);
parser->pos--;
return 0;
}
// fills next token with JSON string.
static int
jsmn_parse_string(jsmn_parser* parser, const char* js, const size_t len, jsmntok_t* tokens, const size_t num_tokens)
{
jsmntok_t* token;
int start = parser->pos;
/* Skip starting quote */
parser->pos++;
for (; parser->pos < len && js[parser->pos] != '\0'; parser->pos++)
{
char c = js[parser->pos];
/* Quote: end of string */
if (c == '\"')
{
if (tokens == NULL)
return 0;
token = jsmn_alloc_token(parser, tokens, num_tokens);
if (token == NULL)
{
parser->pos = start;
return JSMN_ERROR_NOMEM;
}
jsmn_fill_token(token, JSMN_STRING, start + 1, parser->pos);
return 0;
}
/* Backslash: Quoted symbol expected */
if (c == '\\' && parser->pos + 1 < len)
{
int i;
parser->pos++;
switch (js[parser->pos])
{
/* Allowed escaped symbols */
case '\"':
case '/':
case '\\':
case 'b':
case 'f':
case 'r':
case 'n':
case 't':
break;
/* Allows escaped symbol \uXXXX */
case 'u':
parser->pos++;
for (i = 0; i < 4 && parser->pos < len && js[parser->pos] != '\0'; i++)
{
/* If it isn't a hex character we have an error */
if (!((js[parser->pos] >= 48 && js[parser->pos] <= 57) || /* 0-9 */
(js[parser->pos] >= 65 && js[parser->pos] <= 70) || /* A-F */
(js[parser->pos] >= 97 && js[parser->pos] <= 102))) /* a-f */
{
parser->pos = start;
return JSMN_ERROR_INVAL;
}
parser->pos++;
}
parser->pos--;
break;
/* Unexpected symbol */
default:
parser->pos = start;
return JSMN_ERROR_INVAL;
}
}
}
parser->pos = start;
return JSMN_ERROR_PART;
}
JSMN_API int
jsmn_parse(jsmn_parser* parser, const char* js, const size_t len, jsmntok_t* tokens, const unsigned int num_tokens)
{
int r;
int i;
jsmntok_t* token;
int count = parser->toknext;
for (; parser->pos < len && js[parser->pos] != '\0'; parser->pos++)
{
char c;
jsmntype_t type;
c = js[parser->pos];
switch (c)
{
case '{':
case '[':
count++;
if (tokens == NULL)
break;
token = jsmn_alloc_token(parser, tokens, num_tokens);
if (token == NULL)
return JSMN_ERROR_NOMEM;
if (parser->toksuper != -1)
{
jsmntok_t *t = &tokens[parser->toksuper];
t->size++;
}
token->type = (c == '{' ? JSMN_OBJECT : JSMN_ARRAY);
token->start = parser->pos;
parser->toksuper = parser->toknext - 1;
break;
case '}':
case ']':
if (tokens == NULL)
break;
type = (c == '}' ? JSMN_OBJECT : JSMN_ARRAY);
for (i = parser->toknext - 1; i >= 0; i--)
{
token = &tokens[i];
if (token->start != -1 && token->end == -1)
{
if (token->type != type)
return JSMN_ERROR_INVAL;
parser->toksuper = -1;
token->end = parser->pos + 1;
break;
}
}
/* Error if unmatched closing bracket */
if (i == -1)
return JSMN_ERROR_INVAL;
for (; i >= 0; i--)
{
token = &tokens[i];
if (token->start != -1 && token->end == -1)
{
parser->toksuper = i;
break;
}
}
break;
case '\"':
r = jsmn_parse_string(parser, js, len, tokens, num_tokens);
if (r < 0)
return r;
count++;
if (parser->toksuper != -1 && tokens != NULL)
tokens[parser->toksuper].size++;
break;
case '\t':
case '\r':
case '\n':
case ' ':
break;
case ':':
parser->toksuper = parser->toknext - 1;
break;
case ',':
if (tokens != NULL && parser->toksuper != -1 &&
tokens[parser->toksuper].type != JSMN_ARRAY &&
tokens[parser->toksuper].type != JSMN_OBJECT)
{
for (i = parser->toknext - 1; i >= 0; i--)
{
if (tokens[i].type == JSMN_ARRAY || tokens[i].type == JSMN_OBJECT)
{
if (tokens[i].start != -1 && tokens[i].end == -1)
{
parser->toksuper = i;
break;
}
}
}
}
break;
/* In non-strict mode every unquoted value is a primitive */
default:
r = jsmn_parse_primitive(parser, js, len, tokens, num_tokens);
if (r < 0)
return r;
count++;
if (parser->toksuper != -1 && tokens != NULL)
tokens[parser->toksuper].size++;
break;
}
}
if (tokens != NULL)
{
for (i = parser->toknext - 1; i >= 0; i--) {
/* Unmatched opened object or array */
if (tokens[i].start != -1 && tokens[i].end == -1)
return JSMN_ERROR_PART;
}
}
return count;
}
JSMN_API void
jsmn_init(jsmn_parser* parser)
{
parser->pos = 0;
parser->toknext = 0;
parser->toksuper = -1;
}
#endif /* JSMN_HEADER */
#ifdef __cplusplus
}
#endif
#endif /* JSMN_H */
#endif
//-----------------------------------------------------------------------------
// [SECTION] c file
//-----------------------------------------------------------------------------
/*
Index of this file:
// [SECTION] includes
// [SECTION] stretchy buffer
// [SECTION] internal api
// [SECTION] internal enums
// [SECTION] public api implementation
// [SECTION] internal api implementation
*/
//-----------------------------------------------------------------------------
// [SECTION] includes
//-----------------------------------------------------------------------------
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#ifndef PL_ASSERT
#include <assert.h>
#define PL_ASSERT(x) assert((x))
#endif
#if defined(PL_JSON_ALLOC) && defined(PL_JSON_FREE)
// ok
#elif !defined(PL_JSON_ALLOC) && !defined(PL_JSON_FREE)
// ok
#else
#error "Must define both or none of PL_JSON_ALLOC and PL_JSON_FREE"
#endif
#ifndef PL_JSON_ALLOC
#include <stdlib.h>
#define PL_JSON_ALLOC(x) malloc(x)
#define PL_JSON_FREE(x) free((x))
#endif
//-----------------------------------------------------------------------------
// [SECTION] stretchy buffer
//-----------------------------------------------------------------------------
// based on pl_ds.h version "0.2.0"
#define pl_sb_json_capacity(buf) \
((buf) ? pl__sb_json_header((buf))->uCapacity : 0u)
#define pl_sb_json_size(buf) \
((buf) ? pl__sb_json_header((buf))->uSize : 0u)
#define pl_sb_json_pop(buf) \
(buf)[--pl__sb_json_header((buf))->uSize]
#define pl_sb_json_top(buf) \
((buf)[pl__sb_json_header((buf))->uSize-1])
#define pl_sb_json_free(buf) \
if((buf)){ PL_JSON_FREE(pl__sb_json_header(buf));} (buf) = NULL;
#define pl_sb_json_reset(buf) \
if((buf)){ pl__sb_json_header((buf))->uSize = 0u;}
#define pl_sb_json_push(buf, v) \
(pl__sb_json_may_grow((buf), sizeof(*(buf)), 1, 8), (buf)[pl__sb_json_header((buf))->uSize++] = (v))
#define pl_sb_json_reserve(buf, n) \
(pl__sb_json_may_grow((buf), sizeof(*(buf)), (n), (n)))
#define pl_sb_json_resize(buf, n) \
(pl__sb_json_may_grow((buf), sizeof(*(buf)), (n), (n)), pl__sb_json_header((buf))->uSize = (n))
#define pl_sb_json_add_n(buf, n) \
(pl__sb_json_may_grow((buf), sizeof(*(buf)), (n), (n)), (n) ? (pl__sb_json_header(buf)->uSize += (n), pl__sb_json_header(buf)->uSize - (n)) : pl_sb_json_size(buf))
#define pl_sb_json_sprintf(buf, pcFormat, ...) \
pl__sb_json_sprintf(&(buf), (pcFormat), __VA_ARGS__)
#define pl__sb_json_header(buf) ((plSbJsonHeader_*)(((char*)(buf)) - sizeof(plSbJsonHeader_)))
#define pl__sb_json_may_grow(buf, s, n, m) pl__sb_json_may_grow_((void**)&(buf), (s), (n), (m))
typedef struct
{
uint32_t uSize;
uint32_t uCapacity;
} plSbJsonHeader_;
static void
pl__sb_json_grow(void** ptrBuffer, size_t szElementSize, size_t szNewItems)
{
plSbJsonHeader_* ptOldHeader = pl__sb_json_header(*ptrBuffer);
plSbJsonHeader_* ptNewHeader = (plSbJsonHeader_*)PL_JSON_ALLOC((ptOldHeader->uCapacity + szNewItems) * szElementSize + sizeof(plSbJsonHeader_));
memset(ptNewHeader, 0, (ptOldHeader->uCapacity + szNewItems) * szElementSize + sizeof(plSbJsonHeader_));
if(ptNewHeader)
{
ptNewHeader->uSize = ptOldHeader->uSize;
ptNewHeader->uCapacity = ptOldHeader->uCapacity + (uint32_t)szNewItems;
memcpy(&ptNewHeader[1], *ptrBuffer, ptOldHeader->uSize * szElementSize);
PL_JSON_FREE(ptOldHeader);
*ptrBuffer = &ptNewHeader[1];
}
}
static void
pl__sb_json_may_grow_(void** ptrBuffer, size_t szElementSize, size_t szNewItems, size_t szMinCapacity)
{
if(*ptrBuffer)
{
plSbJsonHeader_* ptOriginalHeader = pl__sb_json_header(*ptrBuffer);
if(ptOriginalHeader->uSize + szNewItems > ptOriginalHeader->uCapacity)
{
pl__sb_json_grow(ptrBuffer, szElementSize, szNewItems);
}
}
else // first run
{
plSbJsonHeader_* ptHeader = (plSbJsonHeader_*)PL_JSON_ALLOC(szMinCapacity * szElementSize + sizeof(plSbJsonHeader_));
memset(ptHeader, 0, szMinCapacity * szElementSize + sizeof(plSbJsonHeader_));
if(ptHeader)
{
*ptrBuffer = &ptHeader[1];
ptHeader->uSize = 0u;
ptHeader->uCapacity = (uint32_t)szMinCapacity;
}
}
}
static void
pl__sb_json_vsprintf(char** ppcBuffer, const char* pcFormat, va_list args)
{
va_list args2;
va_copy(args2, args);
int32_t n = vsnprintf(NULL, 0, pcFormat, args2);
va_end(args2);
uint32_t an = pl_sb_json_size(*ppcBuffer);
pl_sb_json_resize(*ppcBuffer, an + n + 1);
vsnprintf(*ppcBuffer + an, n + 1, pcFormat, args);
}
static void
pl__sb_json_sprintf(char** ppcBuffer, const char* pcFormat, ...)
{
va_list args;
va_start(args, pcFormat);
pl__sb_json_vsprintf(ppcBuffer, pcFormat, args);
va_end(args);
}
//-----------------------------------------------------------------------------
// [SECTION] internal api
//-----------------------------------------------------------------------------
static plJsonType pl__get_json_token_object_type(const char* cPtrJson, jsmntok_t* tPtrToken);
static void pl__write_json_object(plJsonObject* ptJson, char* pcBuffer, uint32_t* puBufferSize, uint32_t* puCursor, uint32_t* puDepth);
static void pl__check_json_object(plJsonObject* ptJson, uint32_t* puBufferSize, uint32_t* puCursor, uint32_t* puDepth);
//-----------------------------------------------------------------------------
// [SECTION] internal enums
//-----------------------------------------------------------------------------
enum plJsonType_
{
PL_JSON_TYPE_UNSPECIFIED,
PL_JSON_TYPE_STRING,
PL_JSON_TYPE_ARRAY,
PL_JSON_TYPE_NUMBER,
PL_JSON_TYPE_BOOL,
PL_JSON_TYPE_OBJECT,
PL_JSON_TYPE_NULL,
};
//-----------------------------------------------------------------------------
// [SECTION] public api implementation
//-----------------------------------------------------------------------------
bool
pl_load_json(const char* cPtrJson, plJsonObject* tPtrJsonOut)
{
jsmn_parser tP = {0};
jsmntok_t* sbtTokens = NULL;
pl_sb_json_resize(sbtTokens, 512);
jsmn_init(&tP);
int iResult = 0;
while(true)
{
iResult = jsmn_parse(&tP, cPtrJson, strlen(cPtrJson), sbtTokens, pl_sb_json_size(sbtTokens));
if(iResult == JSMN_ERROR_INVAL)
{
PL_ASSERT(false);
}
else if(iResult == JSMN_ERROR_NOMEM)
{
pl_sb_json_add_n(sbtTokens, 256);
}
else if(iResult == JSMN_ERROR_PART)
{
PL_ASSERT(false);
}
else
{
break;
}
}
uint32_t uLayer = 0;
uint32_t uCurrentTokenIndex = 0;
plJsonObject** sbtObjectStack = NULL;
tPtrJsonOut->tType = PL_JSON_TYPE_OBJECT;
pl_sb_json_reserve(tPtrJsonOut->sbcBuffer, strlen(cPtrJson));
tPtrJsonOut->psbcBuffer = &tPtrJsonOut->sbcBuffer;
tPtrJsonOut->uChildCount = sbtTokens[uCurrentTokenIndex].size;
strcpy(tPtrJsonOut->acName, "ROOT");
pl_sb_json_reserve(tPtrJsonOut->sbtChildren, sbtTokens[uCurrentTokenIndex].size);
pl_sb_json_push(sbtObjectStack, tPtrJsonOut);
while(uCurrentTokenIndex < (uint32_t)iResult)
{
if(pl_sb_json_top(sbtObjectStack)->uChildrenFound == pl_sb_json_top(sbtObjectStack)->uChildCount)
pl_sb_json_pop(sbtObjectStack);
else
{
plJsonObject* tPtrParentObject = pl_sb_json_top(sbtObjectStack);
jsmntok_t* tPtrCurrentToken = &sbtTokens[uCurrentTokenIndex];
jsmntok_t* tPtrNextToken = &sbtTokens[uCurrentTokenIndex + 1];
switch (tPtrCurrentToken->type)
{
// value
case JSMN_PRIMITIVE:
if(tPtrParentObject->tType == PL_JSON_TYPE_ARRAY)
{
const uint32_t uBufferLocation = pl_sb_json_size(tPtrJsonOut->sbcBuffer);
pl_sb_json_resize(tPtrJsonOut->sbcBuffer, uBufferLocation + tPtrCurrentToken->end - tPtrCurrentToken->start + 1);
memcpy(&tPtrJsonOut->sbcBuffer[uBufferLocation], &cPtrJson[tPtrCurrentToken->start], tPtrCurrentToken->end - tPtrCurrentToken->start);
pl_sb_json_push(tPtrParentObject->sbuValueOffsets, uBufferLocation);
pl_sb_json_push(tPtrParentObject->sbuValueLength, tPtrCurrentToken->end - tPtrCurrentToken->start);
tPtrParentObject->uChildrenFound++;
}
else
{
const uint32_t uBufferLocation = pl_sb_json_size(tPtrJsonOut->sbcBuffer);
pl_sb_json_resize(tPtrJsonOut->sbcBuffer, uBufferLocation + tPtrCurrentToken->end - tPtrCurrentToken->start + 1);
memcpy(&tPtrJsonOut->sbcBuffer[uBufferLocation], &cPtrJson[tPtrCurrentToken->start], tPtrCurrentToken->end - tPtrCurrentToken->start);
tPtrParentObject->uValueOffset = uBufferLocation;
tPtrParentObject->uValueLength = tPtrCurrentToken->end - tPtrCurrentToken->start;
tPtrParentObject->uChildrenFound++;
pl_sb_json_pop(sbtObjectStack);
}
break;
case JSMN_STRING:
{
// value
if(tPtrCurrentToken->size == 0)
{
if(tPtrParentObject->tType == PL_JSON_TYPE_ARRAY)
{
const uint32_t uBufferLocation = pl_sb_json_size(tPtrJsonOut->sbcBuffer);
pl_sb_json_resize(tPtrJsonOut->sbcBuffer, uBufferLocation + tPtrCurrentToken->end - tPtrCurrentToken->start + 1);
memcpy(&tPtrJsonOut->sbcBuffer[uBufferLocation], &cPtrJson[tPtrCurrentToken->start], tPtrCurrentToken->end - tPtrCurrentToken->start);
pl_sb_json_push(tPtrParentObject->sbuValueOffsets, uBufferLocation);
pl_sb_json_push(tPtrParentObject->sbuValueLength, tPtrCurrentToken->end - tPtrCurrentToken->start);
tPtrParentObject->uChildrenFound++;
}
else
{
const uint32_t uBufferLocation = pl_sb_json_size(tPtrJsonOut->sbcBuffer);
pl_sb_json_resize(tPtrJsonOut->sbcBuffer, uBufferLocation + tPtrCurrentToken->end - tPtrCurrentToken->start + 1);
memcpy(&tPtrJsonOut->sbcBuffer[uBufferLocation], &cPtrJson[tPtrCurrentToken->start], tPtrCurrentToken->end - tPtrCurrentToken->start);
tPtrParentObject->uValueOffset = uBufferLocation;
tPtrParentObject->uValueLength = tPtrCurrentToken->end - tPtrCurrentToken->start;
tPtrParentObject->uChildrenFound++;
pl_sb_json_pop(sbtObjectStack);
}
}
// key
else
{
plJsonObject tNewJsonObject = {
pl__get_json_token_object_type(cPtrJson, tPtrNextToken),
(uint32_t)tPtrNextToken->size
};
tNewJsonObject.psbcBuffer = &tPtrJsonOut->sbcBuffer;
if(tNewJsonObject.uChildCount == 0)
{
tNewJsonObject.uChildrenFound--;
}
tPtrParentObject->uChildrenFound++;
strncpy(tNewJsonObject.acName, &cPtrJson[tPtrCurrentToken->start], tPtrCurrentToken->end - tPtrCurrentToken->start);
pl_sb_json_push(tPtrParentObject->sbtChildren, tNewJsonObject);
pl_sb_json_reserve(pl_sb_json_top(tPtrParentObject->sbtChildren).sbtChildren, tPtrNextToken->size);
pl_sb_json_reserve(pl_sb_json_top(tPtrParentObject->sbtChildren).sbuValueOffsets, tPtrNextToken->size);
pl_sb_json_reserve(pl_sb_json_top(tPtrParentObject->sbtChildren).sbuValueLength, tPtrNextToken->size);
pl_sb_json_push(sbtObjectStack, &pl_sb_json_top(tPtrParentObject->sbtChildren));
if(tNewJsonObject.tType == PL_JSON_TYPE_ARRAY)
{
uCurrentTokenIndex++;
}
}
break;
}
case JSMN_OBJECT:
{
if(tPtrParentObject->tType == PL_JSON_TYPE_ARRAY)
{
plJsonObject tNewJsonObject = {
pl__get_json_token_object_type(cPtrJson, tPtrCurrentToken),
(uint32_t)tPtrCurrentToken->size
};
tNewJsonObject.psbcBuffer = &tPtrJsonOut->sbcBuffer;
strcpy(tNewJsonObject.acName, "UNNAMED OBJECT");
pl_sb_json_push(tPtrParentObject->sbtChildren, tNewJsonObject);
pl_sb_json_reserve(pl_sb_json_top(tPtrParentObject->sbtChildren).sbtChildren, tPtrCurrentToken->size);
pl_sb_json_reserve(pl_sb_json_top(tPtrParentObject->sbtChildren).sbuValueOffsets, tPtrCurrentToken->size);
pl_sb_json_reserve(pl_sb_json_top(tPtrParentObject->sbtChildren).sbuValueLength, tPtrCurrentToken->size);
pl_sb_json_push(sbtObjectStack, &pl_sb_json_top(tPtrParentObject->sbtChildren));
tPtrParentObject->uChildrenFound++;
}
else if(tPtrParentObject->tType == PL_JSON_TYPE_OBJECT)
{
// combining key/pair
// tPtrParentObject->uChildrenFound++;
}
else
{
PL_ASSERT(false); // shouldn't be possible
}
break;
}
case JSMN_ARRAY:
{
if(tPtrParentObject->tType == PL_JSON_TYPE_ARRAY)
{
plJsonObject tNewJsonObject = {
pl__get_json_token_object_type(cPtrJson, tPtrCurrentToken),
(uint32_t)tPtrCurrentToken->size
};
tNewJsonObject.psbcBuffer = &tPtrJsonOut->sbcBuffer;
strcpy(tNewJsonObject.acName, "UNNAMED ARRAY");
pl_sb_json_push(tPtrParentObject->sbtChildren, tNewJsonObject);
pl_sb_json_reserve(pl_sb_json_top(tPtrParentObject->sbtChildren).sbtChildren, tPtrCurrentToken->size);
pl_sb_json_reserve(pl_sb_json_top(tPtrParentObject->sbtChildren).sbuValueOffsets, tPtrCurrentToken->size);
pl_sb_json_reserve(pl_sb_json_top(tPtrParentObject->sbtChildren).sbuValueLength, tPtrCurrentToken->size);
pl_sb_json_push(sbtObjectStack, &pl_sb_json_top(tPtrParentObject->sbtChildren));
tPtrParentObject->uChildrenFound++;
}
else if(tPtrParentObject->tType == PL_JSON_TYPE_STRING)
{
// combining key/pair
}
else
{
// shouldn't be possible
PL_ASSERT(false);
}
break;
}
default:
break;
}
uCurrentTokenIndex++;
}
}
pl_sb_json_free(sbtTokens);
return true;
}
void
pl_unload_json(plJsonObject* tPtrJson)
{
for(uint32_t i = 0; i < pl_sb_json_size(tPtrJson->sbtChildren); i++)
pl_unload_json(&tPtrJson->sbtChildren[i]);
if(tPtrJson->tType == PL_JSON_TYPE_ARRAY)
{
pl_sb_json_free(tPtrJson->sbuValueOffsets);
pl_sb_json_free(tPtrJson->sbtChildren);
pl_sb_json_free(tPtrJson->sbuValueLength);
}
else
{
tPtrJson->uValueOffset = 0;
tPtrJson->uValueLength = 0;
}
tPtrJson->uChildCount = 0;
tPtrJson->uChildrenFound = 0;
pl_sb_json_free(tPtrJson->sbcBuffer);
memset(tPtrJson->acName, 0, PL_JSON_MAX_NAME_LENGTH);
tPtrJson->tType = PL_JSON_TYPE_UNSPECIFIED;
}
char*
pl_write_json(plJsonObject* tPtrJson, char* pcBuffer, uint32_t* puBufferSize)
{
uint32_t uCursorPosition = 0;
uint32_t uDepth = 0;
if(pcBuffer)
pl__write_json_object(tPtrJson, pcBuffer, puBufferSize, &uCursorPosition, &uDepth);
else
pl__check_json_object(tPtrJson, puBufferSize, &uCursorPosition, &uDepth);
*puBufferSize = uCursorPosition;
return pcBuffer;
}
plJsonObject*
pl_json_member_by_name(plJsonObject* tPtrJson, const char* pcName)
{
for(uint32_t i = 0; i < tPtrJson->uChildCount; i++)
{
if(strncmp(pcName, tPtrJson->sbtChildren[i].acName, strlen(tPtrJson->sbtChildren[i].acName)) == 0)
return &tPtrJson->sbtChildren[i];
}
return NULL;
}
plJsonObject*
pl_json_member_by_index(plJsonObject* tPtrJson, uint32_t uIndex)
{
PL_ASSERT(uIndex < tPtrJson->uChildCount);
return &tPtrJson->sbtChildren[uIndex];
}
void
pl_json_member_list(plJsonObject* tPtrJson, char** cPtrListOut, uint32_t* uPtrSizeOut, uint32_t* uPtrLength)
{
if(cPtrListOut)
{
for(uint32_t i = 0; i < pl_sb_json_size(tPtrJson->sbtChildren); i++)
strcpy(cPtrListOut[i], tPtrJson->sbtChildren[i].acName);
}
if(uPtrSizeOut)
*uPtrSizeOut = pl_sb_json_size(tPtrJson->sbtChildren);
if(uPtrLength)
{
for(uint32_t i = 0; i < pl_sb_json_size(tPtrJson->sbtChildren); i++)
{
const uint32_t uLength = (uint32_t)strlen(tPtrJson->sbtChildren[i].acName);
if(uLength > *uPtrLength) *uPtrLength = uLength;
}
}
}
bool
pl_json_member_exist(plJsonObject* tPtrJson, const char* pcName)
{
return pl_json_member_by_name(tPtrJson, pcName) != NULL;
}
int
pl_json_int_member(plJsonObject* tPtrJson, const char* pcName, int iDefaultValue)
{
plJsonObject* tPtrMember = pl_json_member_by_name(tPtrJson, pcName);
if(tPtrMember)
return pl_json_as_int(tPtrMember);
return iDefaultValue;
}
uint32_t
pl_json_uint_member(plJsonObject* tPtrJson, const char* pcName, uint32_t uDefaultValue)
{
plJsonObject* tPtrMember = pl_json_member_by_name(tPtrJson, pcName);
if(tPtrMember)
return pl_json_as_uint(tPtrMember);
return uDefaultValue;
}
float
pl_json_float_member(plJsonObject* tPtrJson, const char* pcName, float fDefaultValue)
{
plJsonObject* tPtrMember = pl_json_member_by_name(tPtrJson, pcName);
if(tPtrMember)
return pl_json_as_float(tPtrMember);
return fDefaultValue;
}
double
pl_json_double_member(plJsonObject* tPtrJson, const char* pcName, double dDefaultValue)
{
plJsonObject* tPtrMember = pl_json_member_by_name(tPtrJson, pcName);
if(tPtrMember)
return pl_json_as_double(tPtrMember);
return dDefaultValue;
}
char*
pl_json_string_member(plJsonObject* tPtrJson, const char* pcName, char* cPtrDefaultValue, uint32_t uLength)
{
plJsonObject* tPtrMember = pl_json_member_by_name(tPtrJson, pcName);
if(tPtrMember)
{
PL_ASSERT(uLength >= tPtrMember->uValueLength);
memset(cPtrDefaultValue, 0, uLength);
strncpy(cPtrDefaultValue, &(*tPtrMember->psbcBuffer)[tPtrMember->uValueOffset], tPtrMember->uValueLength);
}
return cPtrDefaultValue;
}
bool
pl_json_bool_member(plJsonObject* tPtrJson, const char* pcName, bool bDefaultValue)
{
plJsonObject* tPtrMember = pl_json_member_by_name(tPtrJson, pcName);
if(tPtrMember)
return pl_json_as_bool(tPtrMember);
return bDefaultValue;
}
plJsonObject*
pl_json_member(plJsonObject* tPtrJson, const char* pcName)
{
plJsonObject* tPtrMember = pl_json_member_by_name(tPtrJson, pcName);
if(tPtrMember)
{
PL_ASSERT(tPtrMember->tType == PL_JSON_TYPE_OBJECT);
return tPtrMember;
}
return NULL;
}
plJsonObject*
pl_json_array_member(plJsonObject* tPtrJson, const char* pcName, uint32_t* uPtrSizeOut)
{
plJsonObject* tPtrMember = pl_json_member_by_name(tPtrJson, pcName);
if(uPtrSizeOut)
*uPtrSizeOut = 0;
if(tPtrMember)
{
PL_ASSERT(tPtrMember->tType == PL_JSON_TYPE_ARRAY);
if(uPtrSizeOut)
*uPtrSizeOut = tPtrMember->uChildCount;
return tPtrMember->sbtChildren;
}
return NULL;
}
void
pl_json_int_array_member(plJsonObject* tPtrJson, const char* pcName, int* iPtrOut, uint32_t* uPtrSizeOut)
{
plJsonObject* tPtrMember = pl_json_member_by_name(tPtrJson, pcName);
if(tPtrMember)
pl_json_as_int_array(tPtrMember, iPtrOut, uPtrSizeOut);
}
void
pl_json_uint_array_member(plJsonObject* tPtrJson, const char* pcName, uint32_t* uPtrOut, uint32_t* uPtrSizeOut)
{
plJsonObject* tPtrMember = pl_json_member_by_name(tPtrJson, pcName);
if(tPtrMember)
pl_json_as_uint_array(tPtrMember, uPtrOut, uPtrSizeOut);
}
void
pl_json_float_array_member(plJsonObject* tPtrJson, const char* pcName, float* fPtrOut, uint32_t* uPtrSizeOut)
{
plJsonObject* tPtrMember = pl_json_member_by_name(tPtrJson, pcName);
if(tPtrMember)
pl_json_as_float_array(tPtrMember, fPtrOut, uPtrSizeOut);
}
void
pl_json_double_array_member(plJsonObject* tPtrJson, const char* pcName, double* dPtrOut, uint32_t* uPtrSizeOut)
{
plJsonObject* tPtrMember = pl_json_member_by_name(tPtrJson, pcName);
if(tPtrMember)
pl_json_as_double_array(tPtrMember, dPtrOut, uPtrSizeOut);
}
void
pl_json_string_array_member(plJsonObject* tPtrJson, const char* pcName, char** cPtrOut, uint32_t* uPtrSizeOut, uint32_t* uPtrLength)
{
plJsonObject* tPtrMember = pl_json_member_by_name(tPtrJson, pcName);
if(tPtrMember)
pl_json_as_string_array(tPtrMember, cPtrOut, uPtrSizeOut, uPtrLength);
}
void
pl_json_bool_array_member(plJsonObject* tPtrJson, const char* pcName, bool* bPtrOut, uint32_t* uPtrSizeOut)
{
plJsonObject* tPtrMember = pl_json_member_by_name(tPtrJson, pcName);
if(tPtrMember)
pl_json_as_bool_array(tPtrMember, bPtrOut, uPtrSizeOut);
}
int
pl_json_as_int(plJsonObject* tPtrJson)
{
PL_ASSERT(tPtrJson->tType == PL_JSON_TYPE_NUMBER);
return (int)strtod(&(*tPtrJson->psbcBuffer)[tPtrJson->uValueOffset], NULL);
}
uint32_t
pl_json_as_uint(plJsonObject* tPtrJson)
{
PL_ASSERT(tPtrJson->tType == PL_JSON_TYPE_NUMBER);
return (uint32_t)strtod(&(*tPtrJson->psbcBuffer)[tPtrJson->uValueOffset], NULL);
}
float
pl_json_as_float(plJsonObject* tPtrJson)
{
PL_ASSERT(tPtrJson->tType == PL_JSON_TYPE_NUMBER);
return (float)strtod(&(*tPtrJson->psbcBuffer)[tPtrJson->uValueOffset], NULL);
}
double
pl_json_as_double(plJsonObject* tPtrJson)
{
PL_ASSERT(tPtrJson->tType == PL_JSON_TYPE_NUMBER);
return strtod(&(*tPtrJson->psbcBuffer)[tPtrJson->uValueOffset], NULL);
}
const char*
pl_json_as_string(plJsonObject* tPtrJson)
{
PL_ASSERT(tPtrJson->tType == PL_JSON_TYPE_STRING);
return &(*tPtrJson->psbcBuffer)[tPtrJson->uValueOffset];
}
bool
pl_json_as_bool(plJsonObject* tPtrJson)
{
PL_ASSERT(tPtrJson->tType == PL_JSON_TYPE_BOOL);
return (&(*tPtrJson->psbcBuffer)[tPtrJson->uValueOffset])[0] == 't';
}
void
pl_json_as_int_array(plJsonObject* tPtrJson, int* iPtrOut, uint32_t* uPtrSizeOut)
{
PL_ASSERT(tPtrJson->tType == PL_JSON_TYPE_ARRAY);
if(uPtrSizeOut)
*uPtrSizeOut = tPtrJson->uChildCount;
if(iPtrOut)
{
for(uint32_t i = 0; i < tPtrJson->uChildCount; i++)
iPtrOut[i] = (int)strtod(&(*tPtrJson->psbcBuffer)[tPtrJson->sbuValueOffsets[i]], NULL);
}
}
void
pl_json_as_uint_array(plJsonObject* tPtrJson, uint32_t* uPtrOut, uint32_t* uPtrSizeOut)
{
PL_ASSERT(tPtrJson->tType == PL_JSON_TYPE_ARRAY);
if(uPtrSizeOut)
*uPtrSizeOut = tPtrJson->uChildCount;
if(uPtrOut)
{
for(uint32_t i = 0; i < tPtrJson->uChildCount; i++)
uPtrOut[i] = (uint32_t)strtod(&(*tPtrJson->psbcBuffer)[tPtrJson->sbuValueOffsets[i]], NULL);
}
}
void
pl_json_as_float_array(plJsonObject* tPtrJson, float* fPtrOut, uint32_t* uPtrSizeOut)
{
PL_ASSERT(tPtrJson->tType == PL_JSON_TYPE_ARRAY);
if(uPtrSizeOut)
{
*uPtrSizeOut = tPtrJson->uChildCount;
}
if(fPtrOut)
{
for(uint32_t i = 0; i < tPtrJson->uChildCount; i++)
fPtrOut[i] = (float)strtod(&(*tPtrJson->psbcBuffer)[tPtrJson->sbuValueOffsets[i]], NULL);
}
}
void
pl_json_as_double_array(plJsonObject* tPtrJson, double* dPtrOut, uint32_t* uPtrSizeOut)
{
PL_ASSERT(tPtrJson->tType == PL_JSON_TYPE_ARRAY);
if(uPtrSizeOut)
*uPtrSizeOut = tPtrJson->uChildCount;
if(dPtrOut)
{
for(uint32_t i = 0; i < tPtrJson->uChildCount; i++)
dPtrOut[i] = strtod(&(*tPtrJson->psbcBuffer)[tPtrJson->sbuValueOffsets[i]], NULL);
}
}
void
pl_json_as_string_array(plJsonObject* tPtrJson, char** cPtrOut, uint32_t* uPtrSizeOut, uint32_t* uPtrLength)
{
PL_ASSERT(tPtrJson->tType == PL_JSON_TYPE_ARRAY);
if(cPtrOut)
{
for(uint32_t i = 0; i < tPtrJson->uChildCount; i++)
{
PL_ASSERT(*uPtrLength >= tPtrJson->sbuValueLength[i]);
memset(cPtrOut[i], 0, *uPtrLength);
strncpy(cPtrOut[i],&(*tPtrJson->psbcBuffer)[tPtrJson->sbuValueOffsets[i]], tPtrJson->sbuValueLength[i]);
}
}
else if(uPtrSizeOut)
*uPtrSizeOut = tPtrJson->uChildCount;
if(uPtrLength)
{
for(uint32_t i = 0; i < tPtrJson->uChildCount; i++)
{
if(tPtrJson->sbuValueLength[i] > *uPtrLength)
*uPtrLength = tPtrJson->sbuValueLength[i];
}
}
}
void
pl_json_as_bool_array(plJsonObject* tPtrJson, bool* bPtrOut, uint32_t* uPtrSizeOut)
{
PL_ASSERT(tPtrJson->tType == PL_JSON_TYPE_ARRAY);
if(uPtrSizeOut)
*uPtrSizeOut = tPtrJson->uChildCount;
if(bPtrOut)
{
for(uint32_t i = 0; i < tPtrJson->uChildCount; i++)
bPtrOut[i] = (&(*tPtrJson->psbcBuffer)[tPtrJson->sbuValueOffsets[i]])[0] == 't';
}
}
void
pl_json_add_int_member(plJsonObject* tPtrJson, const char* pcName, int iValue)
{
tPtrJson->uChildCount++;
tPtrJson->uChildrenFound++;
tPtrJson->tType = PL_JSON_TYPE_OBJECT;
if(tPtrJson->psbcBuffer == NULL)
tPtrJson->psbcBuffer = &tPtrJson->sbcBuffer;
plJsonObject tNewJsonObject = {0};
tNewJsonObject.tType = PL_JSON_TYPE_NUMBER;
snprintf(tNewJsonObject.acName, PL_JSON_MAX_NAME_LENGTH, "%s", pcName);
tNewJsonObject.sbcBuffer = NULL;
tNewJsonObject.psbcBuffer = tPtrJson->psbcBuffer;
tNewJsonObject.uValueOffset = pl_sb_json_size(*tPtrJson->psbcBuffer);
tNewJsonObject.uValueLength = snprintf(NULL, 0, "%i", iValue);
pl_sb_json_resize(*tPtrJson->psbcBuffer, tNewJsonObject.uValueOffset + tNewJsonObject.uValueLength);
snprintf(&(*tPtrJson->psbcBuffer)[tNewJsonObject.uValueOffset], tNewJsonObject.uValueLength + 1, "%i", iValue);
pl_sb_json_push(tPtrJson->sbtChildren, tNewJsonObject);
}
void
pl_json_add_uint_member(plJsonObject* tPtrJson, const char* pcName, uint32_t uValue)
{
tPtrJson->uChildCount++;
tPtrJson->uChildrenFound++;
tPtrJson->tType = PL_JSON_TYPE_OBJECT;
if(tPtrJson->psbcBuffer == NULL)
tPtrJson->psbcBuffer = &tPtrJson->sbcBuffer;
plJsonObject tNewJsonObject = {0};
tNewJsonObject.tType = PL_JSON_TYPE_NUMBER;
snprintf(tNewJsonObject.acName, PL_JSON_MAX_NAME_LENGTH, "%s", pcName);
tNewJsonObject.sbcBuffer = NULL;
tNewJsonObject.psbcBuffer = tPtrJson->psbcBuffer;
tNewJsonObject.uValueOffset = pl_sb_json_size(*tPtrJson->psbcBuffer);
tNewJsonObject.uValueLength = snprintf(NULL, 0, "%u", uValue);
pl_sb_json_resize(*tPtrJson->psbcBuffer, tNewJsonObject.uValueOffset + tNewJsonObject.uValueLength);
snprintf(&(*tPtrJson->psbcBuffer)[tNewJsonObject.uValueOffset], tNewJsonObject.uValueLength, "%u", uValue);
pl_sb_json_push(tPtrJson->sbtChildren, tNewJsonObject);
}
void
pl_json_add_float_member(plJsonObject* tPtrJson, const char* pcName, float fValue)
{
tPtrJson->uChildCount++;
tPtrJson->uChildrenFound++;
tPtrJson->tType = PL_JSON_TYPE_OBJECT;
if(tPtrJson->psbcBuffer == NULL)
tPtrJson->psbcBuffer = &tPtrJson->sbcBuffer;
plJsonObject tNewJsonObject = {0};
tNewJsonObject.tType = PL_JSON_TYPE_NUMBER;
snprintf(tNewJsonObject.acName, PL_JSON_MAX_NAME_LENGTH, "%s", pcName);
tNewJsonObject.sbcBuffer = NULL;
tNewJsonObject.psbcBuffer = tPtrJson->psbcBuffer;
tNewJsonObject.uValueOffset = pl_sb_json_size(*tPtrJson->psbcBuffer);
tNewJsonObject.uValueLength = snprintf(NULL, 0, "%0.7f", fValue);
pl_sb_json_resize(*tPtrJson->psbcBuffer, tNewJsonObject.uValueOffset + tNewJsonObject.uValueLength);
snprintf(&(*tPtrJson->psbcBuffer)[tNewJsonObject.uValueOffset], tNewJsonObject.uValueLength, "%0.7f", fValue);
pl_sb_json_push(tPtrJson->sbtChildren, tNewJsonObject);
}
void
pl_json_add_double_member(plJsonObject* tPtrJson, const char* pcName, double dValue)
{
tPtrJson->uChildCount++;
tPtrJson->uChildrenFound++;
tPtrJson->tType = PL_JSON_TYPE_OBJECT;
if(tPtrJson->psbcBuffer == NULL)
tPtrJson->psbcBuffer = &tPtrJson->sbcBuffer;
plJsonObject tNewJsonObject = {0};
tNewJsonObject.tType = PL_JSON_TYPE_NUMBER;
snprintf(tNewJsonObject.acName, PL_JSON_MAX_NAME_LENGTH, "%s", pcName);
tNewJsonObject.sbcBuffer = NULL;
tNewJsonObject.psbcBuffer = tPtrJson->psbcBuffer;
tNewJsonObject.uValueOffset = pl_sb_json_size(*tPtrJson->psbcBuffer);
tNewJsonObject.uValueLength = snprintf(NULL, 0, "%0.15f", dValue);
pl_sb_json_resize(*tPtrJson->psbcBuffer, tNewJsonObject.uValueOffset + tNewJsonObject.uValueLength);
snprintf(&(*tPtrJson->psbcBuffer)[tNewJsonObject.uValueOffset], tNewJsonObject.uValueLength, "%0.15f", dValue);
pl_sb_json_push(tPtrJson->sbtChildren, tNewJsonObject);
}
void
pl_json_add_bool_member(plJsonObject* tPtrJson, const char* pcName, bool bValue)
{
tPtrJson->uChildCount++;
tPtrJson->uChildrenFound++;
tPtrJson->tType = PL_JSON_TYPE_OBJECT;
if(tPtrJson->psbcBuffer == NULL)
tPtrJson->psbcBuffer = &tPtrJson->sbcBuffer;
plJsonObject tNewJsonObject = {0};
tNewJsonObject.tType = PL_JSON_TYPE_BOOL;
snprintf(tNewJsonObject.acName, PL_JSON_MAX_NAME_LENGTH, "%s", pcName);
tNewJsonObject.sbcBuffer = NULL;
tNewJsonObject.psbcBuffer = tPtrJson->psbcBuffer;
tNewJsonObject.uValueOffset = pl_sb_json_size(*tPtrJson->psbcBuffer);
tNewJsonObject.uValueLength = snprintf(NULL, 0, "%s", bValue ? "true" : "false");
pl_sb_json_resize(*tPtrJson->psbcBuffer, tNewJsonObject.uValueOffset + tNewJsonObject.uValueLength);
snprintf(&(*tPtrJson->psbcBuffer)[tNewJsonObject.uValueOffset], tNewJsonObject.uValueLength, bValue ? "true" : "false");
pl_sb_json_push(tPtrJson->sbtChildren, tNewJsonObject);
}
void
pl_json_add_string_member(plJsonObject* tPtrJson, const char* pcName, const char* pcValue)
{
tPtrJson->uChildCount++;
tPtrJson->uChildrenFound++;
tPtrJson->tType = PL_JSON_TYPE_OBJECT;
if(tPtrJson->psbcBuffer == NULL)
tPtrJson->psbcBuffer = &tPtrJson->sbcBuffer;
plJsonObject tNewJsonObject = {0};
tNewJsonObject.tType = PL_JSON_TYPE_STRING;
snprintf(tNewJsonObject.acName, PL_JSON_MAX_NAME_LENGTH, "%s", pcName);
tNewJsonObject.sbcBuffer = NULL;
tNewJsonObject.psbcBuffer = tPtrJson->psbcBuffer;
tNewJsonObject.uValueOffset = pl_sb_json_size(*tPtrJson->psbcBuffer);
tNewJsonObject.uValueLength = (uint32_t)strlen(pcValue);
pl_sb_json_resize(*tPtrJson->psbcBuffer, tNewJsonObject.uValueOffset + tNewJsonObject.uValueLength + 1);
strncpy(&(*tPtrJson->psbcBuffer)[tNewJsonObject.uValueOffset], pcValue, tNewJsonObject.uValueLength);
pl_sb_json_push(tPtrJson->sbtChildren, tNewJsonObject);
}
void
pl_json_add_member(plJsonObject* tPtrJson, const char* pcName, plJsonObject* ptValue)
{
tPtrJson->uChildCount++;
tPtrJson->uChildrenFound++;
tPtrJson->tType = PL_JSON_TYPE_OBJECT;
if(tPtrJson->psbcBuffer == NULL)
tPtrJson->psbcBuffer = &tPtrJson->sbcBuffer;
snprintf(ptValue->acName, PL_JSON_MAX_NAME_LENGTH, "%s", pcName);
pl_sb_json_push(tPtrJson->sbtChildren, *ptValue);
}
void
pl_json_add_member_array(plJsonObject* tPtrJson, const char* pcName, plJsonObject* ptValues, uint32_t uSize)
{
tPtrJson->uChildCount++;
tPtrJson->uChildrenFound++;
tPtrJson->tType = PL_JSON_TYPE_OBJECT;
if(tPtrJson->psbcBuffer == NULL)
tPtrJson->psbcBuffer = &tPtrJson->sbcBuffer;
plJsonObject tNewJsonObject = {0};
tNewJsonObject.tType = PL_JSON_TYPE_ARRAY;
snprintf(tNewJsonObject.acName, PL_JSON_MAX_NAME_LENGTH, "%s", pcName);
tNewJsonObject.sbcBuffer = NULL;
tNewJsonObject.psbcBuffer = tPtrJson->psbcBuffer;
tNewJsonObject.uChildCount = uSize;
tNewJsonObject.uChildrenFound = uSize;
tNewJsonObject.sbuValueLength = NULL;
tNewJsonObject.sbuValueOffsets = NULL;
tNewJsonObject.sbtChildren = NULL;
pl_sb_json_resize(tNewJsonObject.sbtChildren, uSize);
for(uint32_t i = 0; i < uSize; i++)
tNewJsonObject.sbtChildren[i] = ptValues[i];
pl_sb_json_push(tPtrJson->sbtChildren, tNewJsonObject);
}
void
pl_json_add_int_array(plJsonObject* tPtrJson, const char* pcName, int* piValues, uint32_t uSize)
{
tPtrJson->uChildCount++;
tPtrJson->uChildrenFound++;
tPtrJson->tType = PL_JSON_TYPE_OBJECT;
if(tPtrJson->psbcBuffer == NULL)
tPtrJson->psbcBuffer = &tPtrJson->sbcBuffer;
plJsonObject tNewJsonObject = {0};
tNewJsonObject.tType = PL_JSON_TYPE_ARRAY;
snprintf(tNewJsonObject.acName, PL_JSON_MAX_NAME_LENGTH, "%s", pcName);
tNewJsonObject.sbcBuffer = NULL;
tNewJsonObject.psbcBuffer = tPtrJson->psbcBuffer;
tNewJsonObject.uChildCount = uSize;
tNewJsonObject.uChildrenFound = uSize;
tNewJsonObject.sbuValueLength = NULL;
tNewJsonObject.sbuValueOffsets = NULL;
pl_sb_json_resize(tNewJsonObject.sbuValueLength, uSize);
pl_sb_json_resize(tNewJsonObject.sbuValueOffsets, uSize);
for(uint32_t i = 0; i < uSize; i++)
{
const uint32_t uValueOffset = pl_sb_json_size(*tPtrJson->psbcBuffer);
const uint32_t uValueLength = snprintf(NULL, 0, "%i", piValues[i]);
tNewJsonObject.sbuValueOffsets[i] = uValueOffset;
tNewJsonObject.sbuValueLength[i] = uValueLength;
pl_sb_json_resize(*tPtrJson->psbcBuffer, uValueOffset + uValueLength + 1);
snprintf(&(*tPtrJson->psbcBuffer)[uValueOffset], uValueLength + 1, "%i", piValues[i]);
}
pl_sb_json_push(tPtrJson->sbtChildren, tNewJsonObject);
}
void
pl_json_add_uint_array(plJsonObject* tPtrJson, const char* pcName, uint32_t* puValues, uint32_t uSize)
{
tPtrJson->uChildCount++;
tPtrJson->uChildrenFound++;
tPtrJson->tType = PL_JSON_TYPE_OBJECT;
if(tPtrJson->psbcBuffer == NULL)
tPtrJson->psbcBuffer = &tPtrJson->sbcBuffer;
plJsonObject tNewJsonObject = {0};
tNewJsonObject.tType = PL_JSON_TYPE_ARRAY;
snprintf(tNewJsonObject.acName, PL_JSON_MAX_NAME_LENGTH, "%s", pcName);
tNewJsonObject.sbcBuffer = NULL;
tNewJsonObject.psbcBuffer = tPtrJson->psbcBuffer;
tNewJsonObject.uChildCount = uSize;
tNewJsonObject.uChildrenFound = uSize;
tNewJsonObject.sbuValueLength = NULL;
tNewJsonObject.sbuValueOffsets = NULL;
pl_sb_json_resize(tNewJsonObject.sbuValueLength, uSize);
pl_sb_json_resize(tNewJsonObject.sbuValueOffsets, uSize);
for(uint32_t i = 0; i < uSize; i++)
{
const uint32_t uValueOffset = pl_sb_json_size(*tPtrJson->psbcBuffer);
const uint32_t uValueLength = snprintf(NULL, 0, "%u", puValues[i]);
tNewJsonObject.sbuValueOffsets[i] = uValueOffset;
tNewJsonObject.sbuValueLength[i] = uValueLength;
pl_sb_json_resize(*tPtrJson->psbcBuffer, uValueOffset + uValueLength + 1);
snprintf(&(*tPtrJson->psbcBuffer)[uValueOffset], uValueLength + 1, "%u", puValues[i]);
}
pl_sb_json_push(tPtrJson->sbtChildren, tNewJsonObject);
}
void
pl_json_add_float_array(plJsonObject* tPtrJson, const char* pcName, float* pfValues, uint32_t uSize)
{
tPtrJson->uChildCount++;
tPtrJson->uChildrenFound++;
tPtrJson->tType = PL_JSON_TYPE_OBJECT;
if(tPtrJson->psbcBuffer == NULL)
tPtrJson->psbcBuffer = &tPtrJson->sbcBuffer;
plJsonObject tNewJsonObject = {0};
tNewJsonObject.tType = PL_JSON_TYPE_ARRAY;
snprintf(tNewJsonObject.acName, PL_JSON_MAX_NAME_LENGTH, "%s", pcName);
tNewJsonObject.sbcBuffer = NULL;
tNewJsonObject.psbcBuffer = tPtrJson->psbcBuffer;
tNewJsonObject.uChildCount = uSize;
tNewJsonObject.uChildrenFound = uSize;
tNewJsonObject.sbuValueLength = NULL;
tNewJsonObject.sbuValueOffsets = NULL;
pl_sb_json_resize(tNewJsonObject.sbuValueLength, uSize);
pl_sb_json_resize(tNewJsonObject.sbuValueOffsets, uSize);
for(uint32_t i = 0; i < uSize; i++)
{
const uint32_t uValueOffset = pl_sb_json_size(*tPtrJson->psbcBuffer);
const uint32_t uValueLength = snprintf(NULL, 0, "%0.7f", pfValues[i]);
tNewJsonObject.sbuValueOffsets[i] = uValueOffset;
tNewJsonObject.sbuValueLength[i] = uValueLength;
pl_sb_json_resize(*tPtrJson->psbcBuffer, uValueOffset + uValueLength + 1);
snprintf(&(*tPtrJson->psbcBuffer)[uValueOffset], uValueLength + 1, "%0.7f", pfValues[i]);
}
pl_sb_json_push(tPtrJson->sbtChildren, tNewJsonObject);
}
void
pl_json_add_double_array(plJsonObject* tPtrJson, const char* pcName, double* pdValues, uint32_t uSize)
{
tPtrJson->uChildCount++;
tPtrJson->uChildrenFound++;
tPtrJson->tType = PL_JSON_TYPE_OBJECT;
if(tPtrJson->psbcBuffer == NULL)
tPtrJson->psbcBuffer = &tPtrJson->sbcBuffer;
plJsonObject tNewJsonObject = {0};
tNewJsonObject.tType = PL_JSON_TYPE_ARRAY;
snprintf(tNewJsonObject.acName, PL_JSON_MAX_NAME_LENGTH, "%s", pcName);
tNewJsonObject.sbcBuffer = NULL;
tNewJsonObject.psbcBuffer = tPtrJson->psbcBuffer;
tNewJsonObject.uChildCount = uSize;
tNewJsonObject.uChildrenFound = uSize;
tNewJsonObject.sbuValueLength = NULL;
tNewJsonObject.sbuValueOffsets = NULL;
pl_sb_json_resize(tNewJsonObject.sbuValueLength, uSize);
pl_sb_json_resize(tNewJsonObject.sbuValueOffsets, uSize);
for(uint32_t i = 0; i < uSize; i++)
{
const uint32_t uValueOffset = pl_sb_json_size(*tPtrJson->psbcBuffer);
const uint32_t uValueLength = snprintf(NULL, 0, "%0.15f", pdValues[i]);
tNewJsonObject.sbuValueOffsets[i] = uValueOffset;
tNewJsonObject.sbuValueLength[i] = uValueLength;
pl_sb_json_resize(*tPtrJson->psbcBuffer, uValueOffset + uValueLength + 1);
snprintf(&(*tPtrJson->psbcBuffer)[uValueOffset], uValueLength + 1, "%0.15f", pdValues[i]);
}
pl_sb_json_push(tPtrJson->sbtChildren, tNewJsonObject);
}
void
pl_json_add_bool_array(plJsonObject* tPtrJson, const char* pcName, bool* pbValues, uint32_t uSize)
{
tPtrJson->uChildCount++;
tPtrJson->uChildrenFound++;
tPtrJson->tType = PL_JSON_TYPE_OBJECT;
if(tPtrJson->psbcBuffer == NULL)
tPtrJson->psbcBuffer = &tPtrJson->sbcBuffer;
plJsonObject tNewJsonObject = {0};
tNewJsonObject.tType = PL_JSON_TYPE_ARRAY;
snprintf(tNewJsonObject.acName, PL_JSON_MAX_NAME_LENGTH, "%s", pcName);
tNewJsonObject.sbcBuffer = NULL;
tNewJsonObject.psbcBuffer = tPtrJson->psbcBuffer;
tNewJsonObject.uChildCount = uSize;
tNewJsonObject.uChildrenFound = uSize;
tNewJsonObject.sbuValueLength = NULL;
tNewJsonObject.sbuValueOffsets = NULL;
pl_sb_json_resize(tNewJsonObject.sbuValueLength, uSize);
pl_sb_json_resize(tNewJsonObject.sbuValueOffsets, uSize);
for(uint32_t i = 0; i < uSize; i++)
{
const uint32_t uValueOffset = pl_sb_json_size(*tPtrJson->psbcBuffer);
const uint32_t uValueLength = snprintf(NULL, 0, "%s", pbValues[i] ? "true" : "false");
tNewJsonObject.sbuValueOffsets[i] = uValueOffset;
tNewJsonObject.sbuValueLength[i] = uValueLength;
pl_sb_json_resize(*tPtrJson->psbcBuffer, uValueOffset + uValueLength + 1);
snprintf(&(*tPtrJson->psbcBuffer)[uValueOffset], uValueLength + 1, "%s", pbValues[i] ? "true" : "false");
}
pl_sb_json_push(tPtrJson->sbtChildren, tNewJsonObject);
}
void
pl_json_add_string_array(plJsonObject* tPtrJson, const char* pcName, char** ppcBuffer, uint32_t uSize)
{
tPtrJson->uChildCount++;
tPtrJson->uChildrenFound++;
tPtrJson->tType = PL_JSON_TYPE_OBJECT;
if(tPtrJson->psbcBuffer == NULL)
tPtrJson->psbcBuffer = &tPtrJson->sbcBuffer;
plJsonObject tNewJsonObject = {0};
tNewJsonObject.tType = PL_JSON_TYPE_ARRAY;
snprintf(tNewJsonObject.acName, PL_JSON_MAX_NAME_LENGTH, "%s", pcName);
tNewJsonObject.sbcBuffer = NULL;
tNewJsonObject.psbcBuffer = tPtrJson->psbcBuffer;
tNewJsonObject.uChildCount = uSize;
tNewJsonObject.uChildrenFound = uSize;
tNewJsonObject.sbuValueLength = NULL;
tNewJsonObject.sbuValueOffsets = NULL;
pl_sb_json_resize(tNewJsonObject.sbuValueLength, uSize);
pl_sb_json_resize(tNewJsonObject.sbuValueOffsets, uSize);
for(uint32_t i = 0; i < uSize; i++)
{
const uint32_t uValueOffset = pl_sb_json_size(*tPtrJson->psbcBuffer);
const uint32_t uValueLength = snprintf(NULL, 0, "\"%s\"", ppcBuffer[i]);
tNewJsonObject.sbuValueOffsets[i] = uValueOffset;
tNewJsonObject.sbuValueLength[i] = uValueLength;
pl_sb_json_resize(*tPtrJson->psbcBuffer, uValueOffset + uValueLength + 1);
snprintf(&(*tPtrJson->psbcBuffer)[uValueOffset], uValueLength + 1, "\"%s\"", ppcBuffer[i]);
}
pl_sb_json_push(tPtrJson->sbtChildren, tNewJsonObject);
}
//-----------------------------------------------------------------------------
// [SECTION] internal api implementation
//-----------------------------------------------------------------------------
static plJsonType
pl__get_json_token_object_type(const char* cPtrJson, jsmntok_t* tPtrToken)
{
switch (tPtrToken->type)
{
case JSMN_ARRAY: return PL_JSON_TYPE_ARRAY;
case JSMN_OBJECT: return PL_JSON_TYPE_OBJECT;
case JSMN_STRING: return PL_JSON_TYPE_STRING;
case JSMN_PRIMITIVE:
if (cPtrJson[tPtrToken->start] == 'n') { return PL_JSON_TYPE_NULL;}
else if(cPtrJson[tPtrToken->start] == 't' || cPtrJson[tPtrToken->start] == 'f') { return PL_JSON_TYPE_BOOL;}
else { return PL_JSON_TYPE_NUMBER;}
default:
PL_ASSERT(false);
break;
}
return PL_JSON_TYPE_UNSPECIFIED;
}
static void
pl__write_json_object(plJsonObject* ptJson, char* pcBuffer, uint32_t* puBufferSize, uint32_t* puCursor, uint32_t* puDepth)
{
uint32_t uBufferSize = *puBufferSize;
uint32_t uCursorPosition = *puCursor;
switch(ptJson->tType)
{
case PL_JSON_TYPE_NULL:
{
int iSizeNeeded = snprintf(NULL, 0, "null");
snprintf(&pcBuffer[uCursorPosition], iSizeNeeded + 1, "null");
uCursorPosition += iSizeNeeded;
break;
}
case PL_JSON_TYPE_BOOL:
{
int iSizeNeeded = snprintf(NULL, 0, "%s", (&(*ptJson->psbcBuffer)[ptJson->uValueOffset])[0] == 't' ? "true" : "false");
snprintf(&pcBuffer[uCursorPosition], iSizeNeeded + 1, "%s", (&(*ptJson->psbcBuffer)[ptJson->uValueOffset])[0] == 't' ? "true" : "false");
uCursorPosition += iSizeNeeded;
break;
}
case PL_JSON_TYPE_NUMBER:
{
memcpy(&pcBuffer[uCursorPosition], &(*ptJson->psbcBuffer)[ptJson->uValueOffset], ptJson->uValueLength);
uCursorPosition += ptJson->uValueLength;
break;
}
case PL_JSON_TYPE_STRING:
{
int iSizeNeeded = snprintf(&pcBuffer[uCursorPosition], (int)ptJson->uValueLength + 2 + 1, "\"%s\"", &(*ptJson->psbcBuffer)[ptJson->uValueOffset]);
uCursorPosition += iSizeNeeded;
break;
}
case PL_JSON_TYPE_OBJECT:
{
*puDepth += 1;
int iSizeNeeded = 1 + *puDepth * 4;
pcBuffer[uCursorPosition] = '{';
memset(&pcBuffer[uCursorPosition + 1], 0x20, iSizeNeeded - 1);
uCursorPosition += iSizeNeeded;
for(uint32_t i = 0; i < ptJson->uChildCount; i++)
{
int iSizeNeeded3 = *puDepth * 4 + 1;
pcBuffer[uCursorPosition] = '\n';
memset(&pcBuffer[uCursorPosition + 1], 0x20, iSizeNeeded3);
uCursorPosition += iSizeNeeded3;
int iSizeNeeded2 = snprintf(NULL, 0, "\"%s\": ", ptJson->sbtChildren[i].acName);
snprintf(&pcBuffer[uCursorPosition], iSizeNeeded2 + 1 , "\"%s\": ", ptJson->sbtChildren[i].acName);
uCursorPosition += iSizeNeeded2;
pl__write_json_object(&ptJson->sbtChildren[i], pcBuffer, &uBufferSize, &uCursorPosition, puDepth);
if(i != ptJson->uChildCount - 1)
{
pcBuffer[uCursorPosition] = ',';
pcBuffer[uCursorPosition + 1] = ' ';
uCursorPosition += 2;
}
}
*puDepth -= 1;
int iSizeNeeded3 = *puDepth * 4 + 2;
pcBuffer[uCursorPosition] = '\n';
memset(&pcBuffer[uCursorPosition + 1], 0x20, iSizeNeeded3 - 2);
uCursorPosition += iSizeNeeded3;
pcBuffer[uCursorPosition - 1] = '}';
break;
}
case PL_JSON_TYPE_ARRAY:
{
*puDepth += 1;
int iSizeNeeded = 2 + *puDepth * 4;
pcBuffer[uCursorPosition] = '[';
pcBuffer[uCursorPosition + 1] = '\n';
memset(&pcBuffer[uCursorPosition + 2], 0x20, iSizeNeeded - 2);
uCursorPosition += iSizeNeeded;
if(ptJson->sbuValueOffsets)
{
for(uint32_t i = 0; i < ptJson->uChildCount; i++)
{
// pl__write_json_object(&ptJson->sbtChildren[i], pcBuffer, &uBufferSize, &uCursorPosition, puDepth);
const char* cPtrPrevChar = &(*ptJson->psbcBuffer)[ptJson->sbuValueOffsets[i]];
char cPreviousChar = ' ';
if(cPtrPrevChar)
{
const char* cPtrPrevCharAddr = cPtrPrevChar - 1;
cPreviousChar = cPtrPrevCharAddr[0];
}
if(cPreviousChar == '\"')
{
int iSizeNeeded2 = ptJson->sbuValueLength[i] + 2;
snprintf(&pcBuffer[uCursorPosition], iSizeNeeded2 + 1, "\"%s\"", &(*ptJson->psbcBuffer)[ptJson->sbuValueOffsets[i]]);
uCursorPosition += iSizeNeeded2;
}
else
{
memcpy(&pcBuffer[uCursorPosition], &(*ptJson->psbcBuffer)[ptJson->sbuValueOffsets[i]], ptJson->sbuValueLength[i]);
uCursorPosition += ptJson->sbuValueLength[i];
}
if(i != ptJson->uChildCount - 1)
{
pcBuffer[uCursorPosition] = ',';
pcBuffer[uCursorPosition + 1] = ' ';
uCursorPosition += 2;
}
}
}
else
{
for(uint32_t i = 0; i < ptJson->uChildCount; i++)
{
pl__write_json_object(&ptJson->sbtChildren[i], pcBuffer, &uBufferSize, &uCursorPosition, puDepth);
if(i != ptJson->uChildCount - 1)
{
pcBuffer[uCursorPosition] = ',';
pcBuffer[uCursorPosition + 1] = ' ';
uCursorPosition += 2;
}
}
}
*puDepth -= 1;
int iSizeNeeded3 = *puDepth * 4 + 2;
pcBuffer[uCursorPosition] = '\n';
memset(&pcBuffer[uCursorPosition + 1], 0x20, iSizeNeeded3 - 2);
uCursorPosition += iSizeNeeded3;
pcBuffer[uCursorPosition - 1] = ']';
break;
}
}
*puBufferSize = uBufferSize;
*puCursor = uCursorPosition;
}
static void
pl__check_json_object(plJsonObject* ptJson, uint32_t* puBufferSize, uint32_t* puCursor, uint32_t* puDepth)
{
uint32_t uBufferSize = *puBufferSize;
uint32_t uCursorPosition = *puCursor;
switch(ptJson->tType)
{
case PL_JSON_TYPE_NULL:
{
int iSizeNeeded = snprintf(NULL, 0, "null");
uCursorPosition += iSizeNeeded;
break;
}
case PL_JSON_TYPE_BOOL:
{
int iSizeNeeded = snprintf(NULL, 0, "%s", (&(*ptJson->psbcBuffer)[ptJson->uValueOffset])[0] == 't' ? "true" : "false");
uCursorPosition += iSizeNeeded;
break;
}
case PL_JSON_TYPE_NUMBER:
{
uCursorPosition += ptJson->uValueLength;
break;
}
case PL_JSON_TYPE_STRING:
{
int iSizeNeeded = (int)ptJson->uValueLength + 2;
uCursorPosition += iSizeNeeded;
break;
}
case PL_JSON_TYPE_OBJECT:
{
*puDepth += 1;
int iSizeNeeded = 1 + *puDepth * 4;
uCursorPosition += iSizeNeeded;
for(uint32_t i = 0; i < ptJson->uChildCount; i++)
{
int iSizeNeeded3 = *puDepth * 4 + 1;
uCursorPosition += iSizeNeeded3;
int iSizeNeeded2 = snprintf(NULL, 0, "\"%s\": ", ptJson->sbtChildren[i].acName);
uCursorPosition += iSizeNeeded2;
pl__check_json_object(&ptJson->sbtChildren[i], &uBufferSize, &uCursorPosition, puDepth);
if(i != ptJson->uChildCount - 1)
uCursorPosition += 2;
}
*puDepth -= 1;
int iSizeNeeded3 = *puDepth * 4 + 2;
uCursorPosition += iSizeNeeded3;
break;
}
case PL_JSON_TYPE_ARRAY:
{
*puDepth += 1;
int iSizeNeeded = 2 + *puDepth * 4;
uCursorPosition += iSizeNeeded;
if(ptJson->sbuValueOffsets)
{
for(uint32_t i = 0; i < ptJson->uChildCount; i++)
{
// pl__check_json_object(&ptJson->sbtChildren[i], &uBufferSize, &uCursorPosition, puDepth);
const char* cPtrPrevChar = &(*ptJson->psbcBuffer)[ptJson->sbuValueOffsets[i]];
char cPreviousChar = ' ';
if(cPtrPrevChar)
{
const char* cPtrPrevCharAddr = cPtrPrevChar - 1;
cPreviousChar = cPtrPrevCharAddr[0];
}
if(cPreviousChar == '\"')
{
int iSizeNeeded2 = ptJson->sbuValueLength[i] + 2;
uCursorPosition += iSizeNeeded2;
}
else
uCursorPosition += ptJson->sbuValueLength[i];
if(i != ptJson->uChildCount - 1)
uCursorPosition += 2;
}
}
else
{
for(uint32_t i = 0; i < ptJson->uChildCount; i++)
{
pl__check_json_object(&ptJson->sbtChildren[i], &uBufferSize, &uCursorPosition, puDepth);
if(i != ptJson->uChildCount - 1)
uCursorPosition += 2;
}
}
*puDepth -= 1;
int iSizeNeeded3 = *puDepth * 4 + 2;
uCursorPosition += iSizeNeeded3;
break;
}
}
*puBufferSize = uBufferSize;
*puCursor = uCursorPosition;
}
#endif // PL_JSON_IMPLEMENTATION
View Git Blame Copy Permalink