#ifndef _SIMPLE_DATA_STORAGE_FORMAT_H_

#define _SIMPLE_DATA_STORAGE_FORMAT_H_

#ifdef __cplusplus

extern "C" {

#include

#include

#ifndef SDSF_VALUES_ARRAY_DEFAULT_CAPACITY

# define SDSF_VALUES_ARRAY_DEFAULT_CAPACITY 1024

#ifndef SDSF_VALUES_PTR_ARRAY_DEFAULT_CAPACITY

# define SDSF_VALUES_PTR_ARRAY_DEFAULT_CAPACITY 8

#ifndef SDSF_STRING_ARRAY_DEFAULT_CAPACITY

# define SDSF_STRING_ARRAY_DEFAULT_CAPACITY 2048

#ifndef SDSF_SERIALIZER_STAGING_BUFFER_CAPACITY

# define SDSF_SERIALIZER_STAGING_BUFFER_CAPACITY 128

#ifndef SDSF_SERIALIZER_STACK_DEFAULT_CAPACITY

# define SDSF_SERIALIZER_STACK_DEFAULT_CAPACITY 32

#ifndef SDSF_SERIALIZER_BINARY_DATA_BUFFER_DEFAULT_CAPACITY

# define SDSF_SERIALIZER_BINARY_DATA_BUFFER_DEFAULT_CAPACITY 128

#ifndef SDSF_SERIALIZER_MAIN_BUFFER_DEFAULT_CAPACITY

# define SDSF_SERIALIZER_MAIN_BUFFER_DEFAULT_CAPACITY 2048

typedef enum

{

SDSF_VALUE_UNDEFINED,

SDSF_VALUE_BOOL,

SDSF_VALUE_INT,

SDSF_VALUE_FLOAT,

SDSF_VALUE_STRING,

SDSF_VALUE_BINARY,

SDSF_VALUE_ARRAY,

SDSF_VALUE_COMPOSITE,

} SdsfValueType;

const char* SDSF_VALUE_TYPE_TO_STR[] =

{

"SDSF_VALUE_UNDEFINED",

"SDSF_VALUE_BOOL",

"SDSF_VALUE_INT",

"SDSF_VALUE_FLOAT",

"SDSF_VALUE_STRING",

"SDSF_VALUE_BINARY",

"SDSF_VALUE_ARRAY",

"SDSF_VALUE_COMPOSITE",

};

typedef enum

{

SDSF_DESERIALIZATION_ERROR_ALL_FINE = 0,

SDSF_DESERIALIZATION_ERROR_TOKENIZER_FAILED,

SDSF_DESERIALIZATION_ERROR_EXPECTED_IDENTIFIER,

SDSF_DESERIALIZATION_ERROR_UNEXPECTED_RESERVED_SYMBOL,

SDSF_DESERIALIZATION_ERROR_UNEXPECTED_BINARY_DATA_BLOB,

SDSF_DESERIALIZATION_ERROR_UNEXPECTED_IDENTIFIER,

SDSF_DESERIALIZATION_ERROR_INVALID_BINARY_LITERAL,

} SdsfDeserializationError;

const char* SDSF_DESERIALIZATION_ERROR_TO_STR[] =

{

"SDSF_DESERIALIZATION_ERROR_ALL_FINE",

"SDSF_DESERIALIZATION_ERROR_TOKENIZER_FAILED",

"SDSF_DESERIALIZATION_ERROR_EXPECTED_IDENTIFIER",

"SDSF_DESERIALIZATION_ERROR_UNEXPECTED_RESERVED_SYMBOL",

"SDSF_DESERIALIZATION_ERROR_UNEXPECTED_BINARY_DATA_BLOB",

"SDSF_DESERIALIZATION_ERROR_UNEXPECTED_IDENTIFIER",

"SDSF_DESERIALIZATION_ERROR_INVALID_BINARY_LITERAL",

};

typedef struct

{

void* (*alloc)(size_t size, void* userData);

void (*dealloc)(void* ptr, size_t size, void* userData);

void* userData;

} SdsfAllocator;

typedef struct

{

struct SdsfValue* ptr;

size_t size;

size_t capacity;

} SdsfValueArray;

typedef struct

{

struct SdsfValue** ptr;

size_t size;

size_t capacity;

} SdsfValuePtrArray;

typedef struct

{

char* ptr;

size_t size;

size_t capacity;

} SdsfStringArray;

typedef struct SdsfValue

{

struct SdsfValue* parent;

const char* name;

SdsfValueType type;

union

{

bool asBool;

int32_t asInt;

float asFloat;

const char* asString;

struct

{

size_t dataOffset;

size_t dataSize;

} asBinary;

struct

{

SdsfValuePtrArray childs;

} asArray;

struct

{

SdsfValuePtrArray childs;

} asComposite;

};

} SdsfValue;

typedef struct

{

SdsfAllocator allocator;

SdsfValuePtrArray topLevelValues;

SdsfValueArray values;

SdsfStringArray strings;

void* binaryData;

size_t binaryDataSize;

const char* errorMsg;

} SdsfDeserializedResult;

typedef enum

{

SDSF_SERIALIZATION_ERROR_ALL_FINE = 0,

SDSF_SERIALIZATION_ERROR_NO_NAME_PROVIDED,

SDSF_SERIALIZATION_ERROR_INVALID_NAME,

SDSF_SERIALIZATION_ERROR_NO_VALUE_PROVIDED,

SDSF_SERIALIZATION_ERROR_UNABLE_TO_CONVERT_VALUE_TO_STRING,

SDSF_SERIALIZATION_ERROR_UNABLE_TO_END_ARRAY,

SDSF_SERIALIZATION_ERROR_UNABLE_TO_END_COMPOSITE,

SDSF_SERIALIZATION_ERROR_UNFINISHED_ARRAY_OR_COMPOSITE_VALUES,

} SdsfSerializationError;

const char* SDSF_SERIALIZATION_ERROR_TO_STR[] =

{

"SDSF_SERIALIZATION_ERROR_ALL_FINE",

"SDSF_SERIALIZATION_ERROR_NO_NAME_PROVIDED",

"SDSF_SERIALIZATION_ERROR_INVALID_NAME",

"SDSF_SERIALIZATION_ERROR_NO_VALUE_PROVIDED",

"SDSF_SERIALIZATION_ERROR_UNABLE_TO_CONVERT_VALUE_TO_STRING",

"SDSF_SERIALIZATION_ERROR_UNABLE_TO_END_ARRAY",

"SDSF_SERIALIZATION_ERROR_UNABLE_TO_END_COMPOSITE",

"SDSF_SERIALIZATION_ERROR_UNFINISHED_ARRAY_OR_COMPOSITE_VALUES",

};

typedef enum

{

_SDSF_SERIALIZER_IN_NOTHING,

_SDSF_SERIALIZER_IN_ARRAY,

_SDSF_SERIALIZER_IN_COMPOSITE,

} _SdsfSerializerStackEntry;

typedef struct

{

SdsfAllocator allocator;

char* stagingBuffer1;

char* stagingBuffer2;

_SdsfSerializerStackEntry* stack;

size_t stackSize;

size_t stackCapacity;

void* binaryDataBuffer;

size_t binaryDataBufferSize;

size_t binaryDataBufferCapacity;

void* mainBuffer;

size_t mainBufferSize;

size_t mainBufferCapacity;

const char* errorMsg;

} SdsfSerializer;

typedef struct

{

SdsfAllocator allocator;

void* buffer;

size_t bufferSize;

size_t bufferCapacity;

} SdsfSerializedResult;

SdsfDeserializationError sdsf_deserialize(SdsfDeserializedResult* result, const void* data, size_t dataSize, SdsfAllocator allocator);

void sdsf_deserialized_result_free(SdsfDeserializedResult* sdsf);

SdsfSerializer sdsf_serializer_begin(SdsfAllocator allocator);

SdsfSerializationError sdsf_serialize_bool(SdsfSerializer* sdsf, const char* name, bool value);

SdsfSerializationError sdsf_serialize_int(SdsfSerializer* sdsf, const char* name, int32_t value);

SdsfSerializationError sdsf_serialize_float(SdsfSerializer* sdsf, const char* name, float value);

SdsfSerializationError sdsf_serialize_string(SdsfSerializer* sdsf, const char* name, const char* value);

SdsfSerializationError sdsf_serialize_binary(SdsfSerializer* sdsf, const char* name, const void* value, size_t size);

SdsfSerializationError sdsf_serialize_array_start(SdsfSerializer* sdsf, const char* name);

SdsfSerializationError sdsf_serialize_array_end(SdsfSerializer* sdsf);

SdsfSerializationError sdsf_serialize_composite_start(SdsfSerializer* sdsf, const char* name);

SdsfSerializationError sdsf_serialize_composite_end(SdsfSerializer* sdsf);

SdsfSerializationError sdsf_serializer_end(SdsfSerializer* sdsf, SdsfSerializedResult* result);

void sdsf_serialized_result_free(SdsfSerializedResult* sdsf);

#define sdsf_get_error_message(obj) (obj).errorMsg

#ifdef __cplusplus

}

#endif //_SIMPLE_DATA_STORAGE_FORMAT_H_

#define SDSF_IMPL

#ifdef SDSF_IMPL

#ifndef _SDSF_IMPL_INNER_

#define _SDSF_IMPL_INNER_

#ifdef __cplusplus

extern "C" {

#include

#include

#ifdef _SDSF_INDENT_SIZE

# error User should not redefine _SDSF_INDENT_SIZE value

#define _SDSF_INDENT_SIZE 4

#ifdef _SDSF_INDENT

# error User should not redefine _SDSF_INDENT value

#define _SDSF_INDENT " "

typedef struct

{

const char* ptr;

size_t size;

} _SdsfComsumedString;

typedef enum

{

_SDSF_TOKEN_TYPE_INVALID,

_SDSF_TOKEN_TYPE_IDENTIFIER,

_SDSF_TOKEN_TYPE_RESERVED_SYMBOL,

_SDSF_TOKEN_TYPE_BOOL_LITERAL,

_SDSF_TOKEN_TYPE_INT_LITERAL,

_SDSF_TOKEN_TYPE_FLOAT_LITERAL,

_SDSF_TOKEN_TYPE_BINARY_LITERAL,

_SDSF_TOKEN_TYPE_STRING_LITERAL,

} _SdsfTokenType;

typedef enum

{

_SDSF_STRING_LITERAL_NONE,

_SDSF_STRING_LITERAL_BEGIN,

_SDSF_STRING_LITERAL_END,

} _SdsfStringLiteralState;

typedef struct

{

const char* data;

size_t dataSize;

_SdsfStringLiteralState stringLiteralState;

size_t stringConsumePtr;

} _SdsfTokenizerData;

typedef struct

{

const char* stringPtr;

size_t stringSize;

_SdsfTokenType tokenType;

} _SdsfConsumedToken;

inline bool _sdsf_is_skipped_char(char c)

{

return (c == ' ') || (c == '\n') || (c == '\r') || (c == '\t');

}

inline bool _sdsf_is_reserved_symbol(char c)

{

return

(c == ',') ||

(c == '[') ||

(c == ']') ||

(c == '{') ||

(c == '}') ||

(c == '\"') ||

(c == '@');

}

inline bool _sdsf_is_number(char c)

{

return c >= '0' && c <= '9';

}

bool _sdsf_consume_string(const char* sourceBuffer, size_t sourceBufferSize, size_t* consumePtr, _SdsfComsumedString* result, bool isStringLiteral)

{

if (*consumePtr >= sourceBufferSize)

{

return false;

}

size_t beginning;

if (!isStringLiteral)

{

// Skip spaces and stuff

for (; *consumePtr < sourceBufferSize; *consumePtr += 1)

{

if (!_sdsf_is_skipped_char(sourceBuffer[*consumePtr])) break;

}

// Check reserved symbol

if (_sdsf_is_reserved_symbol(sourceBuffer[*consumePtr]))

{

result->ptr = sourceBuffer + *consumePtr;

result->size = 1;

*consumePtr += 1;

return true;

}

// Consume string until reserved or skip symbol

beginning = *consumePtr;

for (; *consumePtr < sourceBufferSize; *consumePtr += 1)

{

const char c = sourceBuffer[*consumePtr];

const bool isSkipped = _sdsf_is_skipped_char(c);

const bool isReserved = _sdsf_is_reserved_symbol(c);

if (isSkipped || isReserved) break;

}

// Zero size means we finished

const size_t size = *consumePtr - beginning;

if (!size)

{

return false;

}

}

else

{

beginning = *consumePtr;

for (; *consumePtr < sourceBufferSize; *consumePtr += 1)

{

const char c = sourceBuffer[*consumePtr];

if (c == '\"') break;

}

}

result->ptr = sourceBuffer + beginning;

result->size = *consumePtr - beginning;

return true;

}

_SdsfTokenType _sdsf_match_string(SdsfDeserializedResult* sdsf, const _SdsfComsumedString* str)

{

if (!str->ptr || !str->size)

{

sdsf->errorMsg = "Tokenzer error - invalid string provided";

return _SDSF_TOKEN_TYPE_INVALID;

}

if (str->size == 1)

{

const char c = *str->ptr;

const bool isReserved = _sdsf_is_reserved_symbol(c);

if (isReserved)

{

return _SDSF_TOKEN_TYPE_RESERVED_SYMBOL;

}

else

{

if (_sdsf_is_number(c)) return _SDSF_TOKEN_TYPE_INT_LITERAL;

switch (c)

{

case 't':

case 'f': return _SDSF_TOKEN_TYPE_BOOL_LITERAL;

sdsf->errorMsg = "Tokenzer error - invalid bool literal";

default: return _SDSF_TOKEN_TYPE_INVALID;

}

}

}

else

{

typedef enum

{

_POSSIBLE_IDENTIFIER = 1 << 0,

_POSSIBLE_INT_LITERAL = 1 << 1,

_POSSIBLE_FLOAT_LITERAL = 1 << 2,

_POSSIBLE_BINARY_LITERAL = 1 << 3,

} _PossibilitySpaceValue;

int32_t possibilitySpace = 0;

bool dotFound = false;

bool dashFound = false;

const char firstChar = *str->ptr;

if (firstChar == 'b')

{

possibilitySpace = _POSSIBLE_BINARY_LITERAL | _POSSIBLE_IDENTIFIER;

}

else if (_sdsf_is_number(firstChar) || firstChar == '-')

{

possibilitySpace = _POSSIBLE_INT_LITERAL | _POSSIBLE_FLOAT_LITERAL;

if (firstChar == '-') dashFound = true;

}

else if (firstChar == '.' )

{

possibilitySpace = _POSSIBLE_FLOAT_LITERAL;

dotFound = true;

}

else if (_sdsf_is_skipped_char(firstChar) || _sdsf_is_reserved_symbol(firstChar))

{

sdsf->errorMsg = "Tokenzer error - unexpected character";

return _SDSF_TOKEN_TYPE_INVALID;

}

else

{

possibilitySpace = _POSSIBLE_IDENTIFIER;

}

for (size_t it = 1; it < str->size; it++)

{

const char c = str->ptr[it];

if (_sdsf_is_number(c))

{

continue; // can be anything

}

if (_sdsf_is_skipped_char(c) || _sdsf_is_reserved_symbol(c))

{

sdsf->errorMsg = "Tokenzer error - unexpected character";

return _SDSF_TOKEN_TYPE_INVALID;

}

switch(c)

{

case '.':

{

if (dotFound)

{

sdsf->errorMsg = "Tokenzer error - two '.' characters in single literal";

return _SDSF_TOKEN_TYPE_INVALID;

}

// only floats can have '.'

possibilitySpace &= _POSSIBLE_FLOAT_LITERAL;

dotFound = true;

} break;

case '-':

{

if (dashFound)

{

sdsf->errorMsg = "Tokenzer error - two '-' characters in single literal";

return _SDSF_TOKEN_TYPE_INVALID;

}

// everything, but identifier can have '-'

possibilitySpace &= ~_POSSIBLE_IDENTIFIER;

dashFound = true;

} break;

default:

{

// only identifier can have something other than number, dot or dash (binary literal 'b' prefix is checked earlier)

possibilitySpace &= _POSSIBLE_IDENTIFIER;

} break;

}

}

if (possibilitySpace & _POSSIBLE_IDENTIFIER)

{

// It is possible to have both _POSSIBLE_IDENTIFIER and _POSSIBLE_BINARY_LITERAL in possibility space,

// but if we have _POSSIBLE_IDENTIFIER that means binary literal wasn't fully completed (it must have '-' symbol)

return _SDSF_TOKEN_TYPE_IDENTIFIER;

}

if (possibilitySpace & _POSSIBLE_INT_LITERAL)

{

// It is possible to have both _POSSIBLE_INT_LITERAL and _POSSIBLE_FLOAT_LITERAL in possibility space,

// but if we have _POSSIBLE_INT_LITERAL that means float literal wasn't fully completed (it must have '.' symbol)

return _SDSF_TOKEN_TYPE_INT_LITERAL;

}

if (possibilitySpace & _POSSIBLE_FLOAT_LITERAL)

{

return _SDSF_TOKEN_TYPE_FLOAT_LITERAL;

}

if (possibilitySpace & _POSSIBLE_BINARY_LITERAL)

{

return _SDSF_TOKEN_TYPE_BINARY_LITERAL;

}

}

sdsf->errorMsg = "Tokenzer error - failed to match token";

return _SDSF_TOKEN_TYPE_INVALID;

}

bool _sdsf_consume_token(SdsfDeserializedResult* sdsf, _SdsfConsumedToken* result, _SdsfTokenizerData* data)

{

_SdsfComsumedString consumedString;

if (!_sdsf_consume_string(data->data, data->dataSize, &data->stringConsumePtr, &consumedString, data->stringLiteralState == _SDSF_STRING_LITERAL_BEGIN))

{

return false;

}

result->stringPtr = consumedString.ptr;

result->stringSize = consumedString.size;

if (data->stringLiteralState == _SDSF_STRING_LITERAL_BEGIN)

{

data->stringLiteralState = _SDSF_STRING_LITERAL_END;

result->tokenType = _SDSF_TOKEN_TYPE_STRING_LITERAL;

}

else

{

result->tokenType = _sdsf_match_string(sdsf, &consumedString);

if (result->tokenType == _SDSF_TOKEN_TYPE_RESERVED_SYMBOL && consumedString.ptr[0] == '\"')

{

if (data->stringLiteralState == _SDSF_STRING_LITERAL_NONE)

{

data->stringLiteralState = _SDSF_STRING_LITERAL_BEGIN;

}

else // (data->stringLiteralState == _SDSF_STRING_LITERAL_END)

{

data->stringLiteralState = _SDSF_STRING_LITERAL_NONE;

}

}

}

return true;

}

SdsfValue* _sdsf_val_array_add(SdsfValueArray* array, const SdsfAllocator* allocator)

{

if (array->capacity == 0)

{

array->ptr = (SdsfValue*)allocator->alloc(SDSF_VALUES_ARRAY_DEFAULT_CAPACITY * sizeof(SdsfValue), allocator->userData);

memset(array->ptr, 0, SDSF_VALUES_ARRAY_DEFAULT_CAPACITY * sizeof(SdsfValue));

array->size = 0;

array->capacity = SDSF_VALUES_ARRAY_DEFAULT_CAPACITY;

}

else if (array->size == array->capacity)

{

const size_t newCapacity = array->capacity * 2;

const size_t oldCapacity = array->capacity;

SdsfValue* const newMem = (SdsfValue*)allocator->alloc(newCapacity * sizeof(SdsfValue), allocator->userData);

memcpy(newMem, array->ptr, oldCapacity * sizeof(SdsfValue));

allocator->dealloc(array->ptr, oldCapacity * sizeof(SdsfValue), allocator->userData);

void* const toZero = newMem + oldCapacity;

memset(toZero, 0, (newCapacity - oldCapacity) * sizeof(SdsfValue));

array->ptr = newMem;

array->capacity = newCapacity;

}

return &array->ptr[array->size++];

}

void _sdsf_val_array_clear(SdsfValueArray* array, const SdsfAllocator* allocator)

{

if (array->capacity)

{

allocator->dealloc(array->ptr, array->capacity * sizeof(SdsfValue), allocator->userData);

}

}

SdsfValue** _sdsf_val_ptr_array_add(SdsfValuePtrArray* array, const SdsfAllocator* allocator)

{

if (array->capacity == 0)

{

array->ptr = (SdsfValue**)allocator->alloc(SDSF_VALUES_PTR_ARRAY_DEFAULT_CAPACITY * sizeof(SdsfValue*), allocator->userData);

memset(array->ptr, 0, SDSF_VALUES_PTR_ARRAY_DEFAULT_CAPACITY * sizeof(SdsfValue*));

array->size = 0;

array->capacity = SDSF_VALUES_PTR_ARRAY_DEFAULT_CAPACITY;

}

else if (array->size == array->capacity)

{

const size_t newCapacity = array->capacity * 2;

const size_t oldCapacity = array->capacity;

SdsfValue** const newMem = (SdsfValue**)allocator->alloc(newCapacity * sizeof(SdsfValue*), allocator->userData);

memcpy(newMem, array->ptr, oldCapacity * sizeof(SdsfValue*));

allocator->dealloc(array->ptr, oldCapacity * sizeof(SdsfValue*), allocator->userData);

void* const toZero = newMem + oldCapacity;

memset(toZero, 0, (newCapacity - oldCapacity) * sizeof(SdsfValue*));

array->ptr = newMem;

array->capacity = newCapacity;

}

return &array->ptr[array->size++];

}

void _sdsf_val_ptr_array_clear(SdsfValuePtrArray* array, const SdsfAllocator* allocator)

{

if (array->capacity)

{

allocator->dealloc(array->ptr, array->capacity * sizeof(SdsfValue*), allocator->userData);

}

}

char* _sdsf_string_array_save(SdsfStringArray* array, const SdsfAllocator* allocator, const char* string, size_t stringLength)

{

if (array->capacity == 0)

{

const size_t initialCapacity = (stringLength + 1) > SDSF_STRING_ARRAY_DEFAULT_CAPACITY ? (stringLength + 1) : SDSF_STRING_ARRAY_DEFAULT_CAPACITY;

array->ptr = allocator->alloc(initialCapacity, allocator->userData);

memset(array->ptr, 0, initialCapacity);

array->size = 0;

array->capacity = initialCapacity;

}

else if ((array->size + stringLength + 1) >= array->capacity)

{

const size_t requiredCapacity = array->size + stringLength + 1;

const size_t doubledCapacity = array->capacity * 2;

const size_t newCapacity = (requiredCapacity > doubledCapacity) ? requiredCapacity : doubledCapacity;

const size_t oldCapacity = array->capacity;

char* const newMem = (char*)allocator->alloc(newCapacity, allocator->userData);

memcpy(newMem, array->ptr, oldCapacity);

allocator->dealloc(array->ptr, oldCapacity, allocator->userData);

void* const toZero = newMem + oldCapacity;

memset(toZero, 0, newCapacity - oldCapacity);

array->ptr = newMem;

array->capacity = newCapacity;

}

char* result = &array->ptr[array->size];

if (string)

{

memcpy(result, string, stringLength);

}

array->size += stringLength + 1;

return result;

}

void _sdsf_string_array_clear(SdsfStringArray* array, const SdsfAllocator* allocator)

{

if (array->capacity)

{

allocator->dealloc(array->ptr, array->capacity, allocator->userData);

}

}

SdsfDeserializationError sdsf_deserialize(SdsfDeserializedResult* sdsf, const void* data, size_t dataSize, SdsfAllocator allocator)

{

_SdsfTokenizerData tokenizerData;

tokenizerData.data = (const char*)data;

tokenizerData.dataSize = dataSize;

tokenizerData.stringLiteralState = _SDSF_STRING_LITERAL_NONE;

tokenizerData.stringConsumePtr = 0;

_SdsfConsumedToken token;

_SdsfConsumedToken previousToken = {0};

*sdsf = (SdsfDeserializedResult){0};

sdsf->allocator = allocator;

SdsfValuePtrArray* topLevelValues = &sdsf->topLevelValues;

SdsfValueArray* values = &sdsf->values;

SdsfStringArray* strings = &sdsf->strings;

SdsfValue* currentValue = NULL;

bool expectsBinaryDataBlob = false;

bool shouldRun = true;

while (shouldRun && _sdsf_consume_token(sdsf, &token, &tokenizerData))

{

if (token.tokenType == _SDSF_TOKEN_TYPE_INVALID)

{

// Error message is set in _sdsf_match_string

return SDSF_DESERIALIZATION_ERROR_TOKENIZER_FAILED;

}

if (token.tokenType == _SDSF_TOKEN_TYPE_IDENTIFIER)

{

if (currentValue)

{

if (currentValue->type == SDSF_VALUE_UNDEFINED)

{

sdsf->errorMsg = "Unexpected identifier - got two identifiers in a row";

return SDSF_DESERIALIZATION_ERROR_UNEXPECTED_IDENTIFIER;

}

if (currentValue->type != SDSF_VALUE_COMPOSITE)

{

sdsf->errorMsg = "Unexpected identifier - only composite values can have named childs";

return SDSF_DESERIALIZATION_ERROR_UNEXPECTED_IDENTIFIER;

}

}

SdsfValue* const val = _sdsf_val_array_add(values, &allocator);

val->parent = currentValue;

val->name = _sdsf_string_array_save(strings, &allocator, token.stringPtr, token.stringSize);

if (currentValue)

{

SdsfValue** const ptr = _sdsf_val_ptr_array_add(&currentValue->asComposite.childs, &allocator);

*ptr = val;

}

else

{

SdsfValue** const ptr = _sdsf_val_ptr_array_add(topLevelValues, &allocator);

*ptr = val;

}

currentValue = val;

}

else if (token.tokenType == _SDSF_TOKEN_TYPE_RESERVED_SYMBOL)

{

switch (token.stringPtr[0])

{

case ',':

{

if (!currentValue || currentValue->type != SDSF_VALUE_ARRAY)

{

sdsf->errorMsg = "Unexpected ',' character - commas can be used in arrays only";

return SDSF_DESERIALIZATION_ERROR_UNEXPECTED_RESERVED_SYMBOL;

}

if (currentValue->asArray.childs.size == 0)

{

sdsf->errorMsg = "Unexpected ',' character - commas must be used only after first array child";

return SDSF_DESERIALIZATION_ERROR_UNEXPECTED_RESERVED_SYMBOL;

}

if (previousToken.tokenType == _SDSF_TOKEN_TYPE_RESERVED_SYMBOL && previousToken.stringPtr[0] == ',')

{

sdsf->errorMsg = "Unexpected ',' character - can't have multiple commas in a row";

return SDSF_DESERIALIZATION_ERROR_UNEXPECTED_RESERVED_SYMBOL;

}

// @NOTE : comma doesn't allocate new values, new value is allocated when processing literals or creating composites/arrays

} break;

case ']':

{

if (!currentValue || currentValue->type != SDSF_VALUE_ARRAY)

{

sdsf->errorMsg = "Unexpected ']' character - only arrays can end with this symbol";

return SDSF_DESERIALIZATION_ERROR_UNEXPECTED_RESERVED_SYMBOL;

}

currentValue = currentValue->parent;

} break;

case '}':

{

if (!currentValue || currentValue->type != SDSF_VALUE_COMPOSITE)

{

sdsf->errorMsg = "Unexpected '}' character - only composites can end with this symbol";

return SDSF_DESERIALIZATION_ERROR_UNEXPECTED_RESERVED_SYMBOL;

}

currentValue = currentValue->parent;

} break;

case '[':

{

if (!currentValue)

{

sdsf->errorMsg = "Unexpected '[' character - new array value can be created only after identifier or as child of another array";

return SDSF_DESERIALIZATION_ERROR_UNEXPECTED_RESERVED_SYMBOL;

}

if (currentValue->type == SDSF_VALUE_UNDEFINED)

{

// Array with an identifier

currentValue->type = SDSF_VALUE_ARRAY;

}

else if (currentValue->type == SDSF_VALUE_ARRAY)

{

// Array in array

SdsfValue* const newChild = _sdsf_val_array_add(values, &allocator);

SdsfValue** const newChildPtr = _sdsf_val_ptr_array_add(&currentValue->asArray.childs, &allocator);

*newChildPtr = newChild;

newChild->parent = currentValue;

currentValue = newChild;

currentValue->type = SDSF_VALUE_ARRAY;

}

else

{

sdsf->errorMsg = "New array value can be created only after identifier or in the another array";

return SDSF_DESERIALIZATION_ERROR_UNEXPECTED_RESERVED_SYMBOL;

}

} break;

case '{':

{

if (!currentValue)

{

sdsf->errorMsg = "Unexpected '[' character - new composite value can be created only after identifier or as child of the array";

return SDSF_DESERIALIZATION_ERROR_UNEXPECTED_RESERVED_SYMBOL;

}

if (currentValue->type == SDSF_VALUE_UNDEFINED)

{

// Composite with an identifier

currentValue->type = SDSF_VALUE_COMPOSITE;

}

else if (currentValue->type == SDSF_VALUE_ARRAY)

{

// Composite in an array

SdsfValue* const newChild = _sdsf_val_array_add(values, &allocator);

SdsfValue** const newChildPtr = _sdsf_val_ptr_array_add(&currentValue->asArray.childs, &allocator);

*newChildPtr = newChild;

newChild->parent = currentValue;

currentValue = newChild;

currentValue->type = SDSF_VALUE_COMPOSITE;

}

else

{

sdsf->errorMsg = "Unexpected '[' character - new composite value can be created only after identifier or as child of the array";

return SDSF_DESERIALIZATION_ERROR_UNEXPECTED_RESERVED_SYMBOL;

}

} break;

case '\"':

{

// Nothing

} break;

case '@':

{

if (!expectsBinaryDataBlob)

{

sdsf->errorMsg = "Unexpected binary data blob - no binary literals were used";

return SDSF_DESERIALIZATION_ERROR_UNEXPECTED_BINARY_DATA_BLOB;

}

const size_t binaryDataSize = tokenizerData.dataSize - tokenizerData.stringConsumePtr;

if (binaryDataSize)

{

void* const memory = allocator.alloc(binaryDataSize, allocator.userData);

sdsf->binaryData = memory;

sdsf->binaryDataSize = binaryDataSize;

const void* const from = tokenizerData.data + tokenizerData.stringConsumePtr;

memcpy(memory, from, binaryDataSize);

}

// Binary data blob is always in the end of file

shouldRun = false;

} break;

}

}

else

{

if (!currentValue)

{

sdsf->errorMsg = "Values must be associated with identifier or array";

return SDSF_DESERIALIZATION_ERROR_EXPECTED_IDENTIFIER;

}

SdsfValue* valueToUpdate = NULL;

if (currentValue->type == SDSF_VALUE_ARRAY)

{

valueToUpdate = _sdsf_val_array_add(values, &allocator);

valueToUpdate->parent = currentValue;

SdsfValue** const ptr = _sdsf_val_ptr_array_add(&currentValue->asArray.childs, &allocator);

*ptr = valueToUpdate;

}

else

{

if (!currentValue->name)

{

sdsf->errorMsg = "Unexpected unnamed value. Only arrays can have values without names";

return SDSF_DESERIALIZATION_ERROR_EXPECTED_IDENTIFIER;

}

valueToUpdate = currentValue;

currentValue = currentValue->parent;