rexy712/rjp
1
0
Fork 0
Code Issues Pull Requests Projects Releases Activity

removed excess 'struct's (typedefs)

Browse Source
This commit is contained in:
rexy712 2018-12-01 08:33:08 -08:00
parent b27031876b
commit 6f4a55a766
5 changed files with 164 additions and 168 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

123
include/rjp.h
View File

@ -26,7 +26,7 @@ extern "C"{
#endif
//type of data
enum JSON_type{
typedef enum RJP_type{
json_object,
json_string,
json_integer,
@ -34,105 +34,100 @@ enum JSON_type{
json_boolean,
json_array,
json_null
};
enum JSON_flags{
json_flag_string = 1, //in a string
json_flag_comment = 2, //in a comment block
json_flag_search_name = 4, //looking for key/value pair
json_flag_escape = 16 //escaped character in a string
};
}RJP_type;
//keep track of string length
struct JSON_string{
typedef struct RJP_string{
char* value;
size_t length;
};
}RJP_string;
//keep a linked list of all members of a given object
struct JSON_object{
struct JSON_object_member* members;
struct JSON_object_member* last;
struct RJP_object_member;
typedef struct RJP_object{
struct RJP_object_member* members;
struct RJP_object_member* last;
size_t num_members;
};
}RJP_object;
//keep array plus length
struct JSON_array{
struct JSON_array_element* elements;
struct JSON_array_element* last;
struct RJP_array_element;
typedef struct RJP_array{
struct RJP_array_element* elements;
struct RJP_array_element* last;
size_t num_elements;
};
}RJP_array;
//hold any json data type
struct JSON_value{
typedef struct RJP_value{
union{
long integer;
double dfloat;
char boolean;
struct JSON_object object;
struct JSON_string string;
struct JSON_array array;
struct RJP_object object;
struct RJP_string string;
struct RJP_array array;
};
struct JSON_value* parent;
enum JSON_type type;
};
struct RJP_value* parent;
enum RJP_type type;
}RJP_value;
struct JSON_array_element{
struct JSON_value value;
struct JSON_array_element* next;
};
typedef struct RJP_array_element{
struct RJP_value value;
struct RJP_array_element* next;
}RJP_array_element;
//A member of an object
struct JSON_object_member{
struct JSON_value value;
struct JSON_string name;
struct JSON_object_member* next;
};
typedef struct RJP_object_member{
struct RJP_value value;
struct RJP_string name;
struct RJP_object_member* next;
}RJP_object_member;
//read in json and convert to easy to work with format
struct JSON_value* rjp_parse(const char* str);
RJP_value* rjp_parse(const char* str);
//deallocate a json handle
void rjp_free_json(char* json);
void rjp_free(struct JSON_value* root);
void rjp_free(RJP_value* root);
//initialize an empty json handle (outputting to string would result in '{}')
struct JSON_value* rjp_init_json(void);
RJP_value* rjp_init_json(void);
//add a member to a json object
struct JSON_value* rjp_add_member(struct JSON_value* dest, int alloc_key, char* key, size_t keylen, struct JSON_value value);
RJP_value* rjp_add_member(RJP_value* dest, int alloc_key, char* key, size_t keylen, RJP_value value);
//add an element to a json array
struct JSON_value* rjp_add_element(struct JSON_value* dest, struct JSON_value value);
RJP_value* rjp_add_element(RJP_value* dest, RJP_value value);
//initialize a JSON_value to the requested type and value
struct JSON_value rjp_integer(long i);
struct JSON_value rjp_boolean(char b);
struct JSON_value rjp_dfloat(double d);
struct JSON_value rjp_string(char* c, size_t len);
struct JSON_value rjp_null(void);
struct JSON_value rjp_object(void);
struct JSON_value rjp_array(void);
//initialize a RJP_value to the requested type and value
RJP_value rjp_integer(long i);
RJP_value rjp_boolean(char b);
RJP_value rjp_dfloat(double d);
RJP_value rjp_string(char* c, size_t len);
RJP_value rjp_null(void);
RJP_value rjp_object(void);
RJP_value rjp_array(void);
//access members/elements
struct JSON_value* rjp_get_member(struct JSON_value* object);
struct JSON_value* rjp_next_member(struct JSON_value* member);
struct JSON_value* rjp_get_element(struct JSON_value* array);
struct JSON_value* rjp_next_element(struct JSON_value* element);
RJP_value* rjp_get_member(RJP_value* object);
RJP_value* rjp_next_member(RJP_value* member);
RJP_value* rjp_get_element(RJP_value* array);
RJP_value* rjp_next_element(RJP_value* element);
//member metadata
char* rjp_member_name(struct JSON_value* member);
size_t rjp_member_name_length(struct JSON_value* member);
char* rjp_member_name(RJP_value* member);
size_t rjp_member_name_length(RJP_value* member);
//value metadata
struct JSON_value* rjp_value_parent(struct JSON_value* element);
enum JSON_type rjp_value_type(struct JSON_value* value);
RJP_value* rjp_value_parent(RJP_value* element);
RJP_type rjp_value_type(RJP_value* value);
//value accessors
double rjp_value_dfloat(struct JSON_value* value);
int rjp_value_integer(struct JSON_value* value);
char rjp_value_boolean(struct JSON_value* value);
char* rjp_value_string(struct JSON_value* value);
size_t rjp_value_string_length(struct JSON_value* value);
double rjp_value_dfloat(RJP_value* value);
int rjp_value_integer(RJP_value* value);
char rjp_value_boolean(RJP_value* value);
char* rjp_value_string(RJP_value* value);
size_t rjp_value_string_length(RJP_value* value);
//copy input string and add json escape sequences
@ -140,9 +135,9 @@ size_t rjp_escape_strcpy(char* dest, const char* src);
//length of string including escape sequences
size_t rjp_escape_strlen(const char* str);
size_t rjp_dump_object(struct JSON_value* root, char* dest);
size_t rjp_dump_array(struct JSON_value* arr, char* dest);
char* rjp_to_json(struct JSON_value* root);
size_t rjp_dump_object(RJP_value* root, char* dest);
size_t rjp_dump_array(RJP_value* arr, char* dest);
char* rjp_to_json(RJP_value* root);
#ifdef __cplusplus
}

12
include/rjp_internal.h
View File

@ -3,11 +3,11 @@
#include "rjp.h"
char* _rjp__parse_string(struct JSON_value* root, const char* str, int* len, int* row, int* column);
size_t _rjp__object_strlen(struct JSON_value* root);
void _rjp__add_member(struct JSON_object* j, char* str, size_t len);
void _rjp__add_member_no_alloc(struct JSON_object* j, char* str, size_t len);
void _rjp__add_element(struct JSON_array* j);
size_t _rjp__object_strlen(struct JSON_value* root);
char* _rjp__parse_string(RJP_value* root, const char* str, int* len, int* row, int* column);
size_t _rjp__object_strlen(RJP_value* root);
void _rjp__add_member(RJP_object* j, char* str, size_t len);
void _rjp__add_member_no_alloc(RJP_object* j, char* str, size_t len);
void _rjp__add_element(RJP_array* j);
size_t _rjp__object_strlen(RJP_value* root);
#endif

97
src/input.c
View File

@ -37,42 +37,42 @@
#define DIAG_PRINT(...)
#endif
struct JSON_state{
typedef struct RJP_state{
int in_array;
int search_target;
};
}RJP_state;
//types of searches in the text
enum json_search_target{
typedef enum json_search_target{
json_key,
json_colon,
json_comma,
json_value
};
}json_search_target;
//Determine if the character is valid whitespace
static int _rjp__is_whitespace(char c){
return c == ' ' || c == '\n' || c == '\r' || c == '\t';
}
//add an element to an array
void _rjp__add_element(struct JSON_array* j){
void _rjp__add_element(RJP_array* j){
++j->num_elements;
if(!j->elements){
j->elements = calloc(1, sizeof(struct JSON_array_element));
j->elements = calloc(1, sizeof(RJP_array_element));
j->last = j->elements;
}else{
j->last->next = calloc(1, sizeof(struct JSON_array_element));
j->last->next = calloc(1, sizeof(RJP_array_element));
j->last = j->last->next;
}
}
//create member of the object as a linked list member and assign a name with name allocation
void _rjp__add_member(struct JSON_object* j, char* str, size_t len){
void _rjp__add_member(RJP_object* j, char* str, size_t len){
++j->num_members;
if(!j->members){
j->members = calloc(1, sizeof(struct JSON_object_member));
j->members = calloc(1, sizeof(RJP_object_member));
j->last = j->members;
}else{
j->last->next = calloc(1, sizeof(struct JSON_object_member));
j->last->next = calloc(1, sizeof(RJP_object_member));
j->last = j->last->next;
}
j->last->name.value = malloc(len + 1);
@ -80,92 +80,92 @@ void _rjp__add_member(struct JSON_object* j, char* str, size_t len){
j->last->name.value[len] = 0;
j->last->name.length = len;
}
void _rjp__add_member_no_alloc(struct JSON_object* j, char* str, size_t len){
void _rjp__add_member_no_alloc(RJP_object* j, char* str, size_t len){
++j->num_members;
if(!j->members){
j->members = calloc(1, sizeof(struct JSON_object_member));
j->members = calloc(1, sizeof(RJP_object_member));
j->last = j->members;
}else{
j->last->next = calloc(1, sizeof(struct JSON_object_member));
j->last->next = calloc(1, sizeof(RJP_object_member));
j->last = j->last->next;
}
j->last->name.value = str;
j->last->name.length = len;
}
static struct JSON_value* _rjp__add_element_to_array(struct JSON_value* curr, struct JSON_state* state, struct JSON_value* element){
struct JSON_value* tmp = &curr->object.members->value;
static RJP_value* _rjp__add_element_to_array(RJP_value* curr, RJP_state* state, RJP_value* element){
RJP_value* tmp = &curr->object.members->value;
for(int i = state->in_array-1;i > 0;--i, tmp = &tmp->array.last->value);
_rjp__add_element(&tmp->array);
tmp->array.last->value = *element;
return &tmp->array.last->value;
}
//Assign object characteristics to previously allocated JSON_value
static struct JSON_value* _rjp__add_object(struct JSON_value* curr, struct JSON_state* state){
//Assign object characteristics to previously allocated RJP_value
static RJP_value* _rjp__add_object(RJP_value* curr, RJP_state* state){
if(!curr){
curr = calloc(1, sizeof(struct JSON_value));
curr = calloc(1, sizeof(RJP_value));
curr->type = json_object;
return curr;
}
struct JSON_value new_object = {.type = json_object, .integer = 0, .parent = curr};
RJP_value new_object = {.type = json_object, .integer = 0, .parent = curr};
if(state->in_array)
return _rjp__add_element_to_array(curr, state, &new_object);
curr->object.last->value = new_object;
return &curr->object.last->value;
}
//Assign array characteristics to previously allocated JSON_value
static struct JSON_value* _rjp__add_array(struct JSON_value* curr, struct JSON_state* state){
struct JSON_value new_array = {.type = json_array, .array = {.num_elements = 0, .elements = NULL}, .parent = curr};
//Assign array characteristics to previously allocated RJP_value
static RJP_value* _rjp__add_array(RJP_value* curr, RJP_state* state){
RJP_value new_array = {.type = json_array, .array = {.num_elements = 0, .elements = NULL}, .parent = curr};
if(state->in_array)
return _rjp__add_element_to_array(curr, state, &new_array);
curr->object.last->value = new_array;
return &curr->object.last->value;
}
//Assign string characteristics to previously allocated JSON_value with no string allocation
static struct JSON_value* _rjp__add_string_no_alloc(struct JSON_value* curr, char* str, int len, struct JSON_state* state){
struct JSON_value new_string = {.type = json_string, .string = {.value = str, .length = len}, .parent = curr};
//Assign string characteristics to previously allocated RJP_value with no string allocation
static RJP_value* _rjp__add_string_no_alloc(RJP_value* curr, char* str, int len, RJP_state* state){
RJP_value new_string = {.type = json_string, .string = {.value = str, .length = len}, .parent = curr};
if(state->in_array)
return _rjp__add_element_to_array(curr, state, &new_string);
curr->object.last->value = new_string;
return &curr->object.last->value;
}
//Assign double characteristics to previously allocated JSON_value
static struct JSON_value* _rjp__add_dfloat(struct JSON_value* curr, double value, struct JSON_state* state){
struct JSON_value new_double = {.type = json_dfloat, .dfloat = value, .parent = curr};
//Assign double characteristics to previously allocated RJP_value
static RJP_value* _rjp__add_dfloat(RJP_value* curr, double value, RJP_state* state){
RJP_value new_double = {.type = json_dfloat, .dfloat = value, .parent = curr};
if(state->in_array)
return _rjp__add_element_to_array(curr, state, &new_double);
curr->object.last->value = new_double;
return &curr->object.last->value;
}
//Assign integer characteristics to previously allocated JSON_value
static struct JSON_value* _rjp__add_integer(struct JSON_value* curr, long value, struct JSON_state* state){
struct JSON_value new_integer = {.type = json_integer, .integer = value, .parent = curr};
//Assign integer characteristics to previously allocated RJP_value
static RJP_value* _rjp__add_integer(RJP_value* curr, long value, RJP_state* state){
RJP_value new_integer = {.type = json_integer, .integer = value, .parent = curr};
if(state->in_array)
return _rjp__add_element_to_array(curr, state, &new_integer);
curr->object.last->value = new_integer;
return &curr->object.last->value;
}
static struct JSON_value* _rjp__add_boolean(struct JSON_value* curr, int value, struct JSON_state* state){
struct JSON_value new_boolean = {.type = json_boolean, .boolean = value, .parent = curr};
static RJP_value* _rjp__add_boolean(RJP_value* curr, int value, RJP_state* state){
RJP_value new_boolean = {.type = json_boolean, .boolean = value, .parent = curr};
if(state->in_array)
return _rjp__add_element_to_array(curr, state, &new_boolean);
curr->object.last->value = new_boolean;
return &curr->object.last->value;
}
static struct JSON_value* _rjp__add_null(struct JSON_value* curr, struct JSON_state* state){
struct JSON_value new_null = {.type = json_null, .integer = 0, .parent = curr};
static RJP_value* _rjp__add_null(RJP_value* curr, RJP_state* state){
RJP_value new_null = {.type = json_null, .integer = 0, .parent = curr};
if(state->in_array)
return _rjp__add_element_to_array(curr, state, &new_null);
curr->object.last->value = new_null;
return &curr->object.last->value;
}
static void _rjp__free_object_recurse(struct JSON_value* root);
static void _rjp__free_object_recurse(RJP_value* root);
static void _rjp__free_array(struct JSON_value* root){
struct JSON_array_element* arr = root->array.elements;
for(struct JSON_array_element* i = arr;i != NULL;i = arr){
static void _rjp__free_array(RJP_value* root){
RJP_array_element* arr = root->array.elements;
for(RJP_array_element* i = arr;i != NULL;i = arr){
arr = arr->next;
if(i->value.type == json_object){
_rjp__free_object_recurse(&i->value);
@ -178,9 +178,9 @@ static void _rjp__free_array(struct JSON_value* root){
}
}
//Recursively free JSON objects
static void _rjp__free_object_recurse(struct JSON_value* root){
struct JSON_object_member* next;
for(struct JSON_object_member* m = root->object.members;m;m = next){
static void _rjp__free_object_recurse(RJP_value* root){
RJP_object_member* next;
for(RJP_object_member* m = root->object.members;m;m = next){
next = m->next;
if(m->value.type == json_object)
_rjp__free_object_recurse(&m->value);
@ -197,14 +197,14 @@ void rjp_free_json(char* json){
free(json);
}
//Same as recurse but also frees root node
void rjp_free(struct JSON_value* root){
void rjp_free(RJP_value* root){
if(!root)
return;
_rjp__free_object_recurse(root);
free(root);
}
MAYBE_UNUSED static int _rjp__is_array_empty(struct JSON_value* curr){
MAYBE_UNUSED static int _rjp__is_array_empty(RJP_value* curr){
if(curr->object.members->value.type != json_array)
return 0;
return curr->object.members->value.array.num_elements == 0;
@ -214,15 +214,15 @@ MAYBE_UNUSED static int _rjp__is_array_empty(struct JSON_value* curr){
do{DIAG_PRINT(stderr, "Syntax error! %s (%i:%i)\n", msg, row, column);rjp_free(root);return NULL;}while(0)
#define MAX_DEPTH 16
struct JSON_value* rjp_parse(const char* str){
struct JSON_value* root = 0;
struct JSON_value* curr = 0;
RJP_value* rjp_parse(const char* str){
RJP_value* root = 0;
RJP_value* curr = 0;
int row = 1, column = 0;
int in_line_comment = 0;
int in_block_comment = 0;
//keep track of where we are in a given subobject
struct JSON_state state_stack[MAX_DEPTH] = {0},*top = state_stack;
RJP_state state_stack[MAX_DEPTH] = {0},*top = state_stack;
//initially search for the root object
top->search_target = json_value;
@ -413,3 +413,4 @@ struct JSON_value* rjp_parse(const char* str){
#undef syntax_error

86
src/output.c
View File

@ -5,12 +5,12 @@
#include <stdlib.h> //malloc, calloc, free
#include <stdio.h> //sprintf
struct JSON_value* rjp_init_json(void){
struct JSON_value* ret = calloc(1, sizeof(struct JSON_value));
RJP_value* rjp_init_json(void){
RJP_value* ret = calloc(1, sizeof(RJP_value));
ret->type = json_object;
return ret;
}
struct JSON_value* rjp_add_member(struct JSON_value* dest, int alloc_key, char* key, size_t keylen, struct JSON_value value){
RJP_value* rjp_add_member(RJP_value* dest, int alloc_key, char* key, size_t keylen, RJP_value value){
if(!keylen && alloc_key)
keylen = strlen(key);
if(alloc_key)
@ -21,81 +21,81 @@ struct JSON_value* rjp_add_member(struct JSON_value* dest, int alloc_key, char*
dest->object.last->value.parent = dest;
return &dest->object.last->value;
}
struct JSON_value* rjp_add_element(struct JSON_value* dest, struct JSON_value value){
RJP_value* rjp_add_element(RJP_value* dest, RJP_value value){
_rjp__add_element(&dest->array);
dest->array.last->value = value;
dest->array.last->value.parent = dest;
return &dest->array.last->value;
}
struct JSON_value rjp_integer(long i){
return (struct JSON_value){.integer = i, .type = json_integer};
RJP_value rjp_integer(long i){
return (RJP_value){.integer = i, .type = json_integer};
}
struct JSON_value rjp_boolean(char b){
return (struct JSON_value){.boolean = b, .type = json_boolean};
RJP_value rjp_boolean(char b){
return (RJP_value){.boolean = b, .type = json_boolean};
}
struct JSON_value rjp_dfloat(double d){
return (struct JSON_value){.dfloat = d, .type = json_dfloat};
RJP_value rjp_dfloat(double d){
return (RJP_value){.dfloat = d, .type = json_dfloat};
}
struct JSON_value rjp_string(char* c, size_t len){
return (struct JSON_value){.string = {.value = c, .length = len}, .type = json_string};
RJP_value rjp_string(char* c, size_t len){
return (RJP_value){.string = {.value = c, .length = len}, .type = json_string};
}
struct JSON_value rjp_null(void){
return (struct JSON_value){.integer = 0, .type = json_null};
RJP_value rjp_null(void){
return (RJP_value){.integer = 0, .type = json_null};
}
struct JSON_value rjp_object(void){
return (struct JSON_value){.object = {0}, .type = json_object};
RJP_value rjp_object(void){
return (RJP_value){.object = {0}, .type = json_object};
}
struct JSON_value rjp_array(void){
return (struct JSON_value){.array = {0}, .type = json_array};
RJP_value rjp_array(void){
return (RJP_value){.array = {0}, .type = json_array};
}
struct JSON_value* rjp_get_member(struct JSON_value* object){
RJP_value* rjp_get_member(RJP_value* object){
return &object->object.members->value;
}
struct JSON_value* rjp_next_member(struct JSON_value* member){
RJP_value* rjp_next_member(RJP_value* member){
//polymorphism
return (struct JSON_value*)(((struct JSON_object_member*)member)->next);
return (RJP_value*)(((RJP_object_member*)member)->next);
}
struct JSON_value* rjp_get_element(struct JSON_value* array){
RJP_value* rjp_get_element(RJP_value* array){
return &array->array.elements->value;
}
struct JSON_value* rjp_next_element(struct JSON_value* element){
return (struct JSON_value*)(((struct JSON_array_element*)element)->next);
RJP_value* rjp_next_element(RJP_value* element){
return (RJP_value*)(((RJP_array_element*)element)->next);
}
char* rjp_member_name(struct JSON_value* member){
return ((struct JSON_object_member*)member)->name.value;
char* rjp_member_name(RJP_value* member){
return ((RJP_object_member*)member)->name.value;
}
size_t rjp_member_name_length(struct JSON_value* member){
return ((struct JSON_object_member*)member)->name.length;
size_t rjp_member_name_length(RJP_value* member){
return ((RJP_object_member*)member)->name.length;
}
struct JSON_value* rjp_value_parent(struct JSON_value* value){
RJP_value* rjp_value_parent(RJP_value* value){
return value->parent;
}
enum JSON_type rjp_value_type(struct JSON_value* value){
RJP_type rjp_value_type(RJP_value* value){
return value->type;
}
double rjp_value_dfloat(struct JSON_value* value){
double rjp_value_dfloat(RJP_value* value){
return value->dfloat;
}
int rjp_value_integer(struct JSON_value* value){
int rjp_value_integer(RJP_value* value){
return value->integer;
}
char rjp_value_boolean(struct JSON_value* value){
char rjp_value_boolean(RJP_value* value){
return value->boolean;
}
char* rjp_value_string(struct JSON_value* value){
char* rjp_value_string(RJP_value* value){
return value->string.value;
}
size_t rjp_value_string_length(struct JSON_value* value){
size_t rjp_value_string_length(RJP_value* value){
return value->string.length;
}
static size_t _rjp__write_value(char* dest, struct JSON_value* val){
static size_t _rjp__write_value(char* dest, RJP_value* val){
size_t ret;
switch(val->type){
case json_integer:
@ -130,9 +130,9 @@ static size_t _rjp__write_value(char* dest, struct JSON_value* val){
return ret;
}
size_t rjp_dump_array(struct JSON_value* arr, char* dest){
struct JSON_array* array = &arr->array;
struct JSON_array_element* element_list = array->elements;
size_t rjp_dump_array(RJP_value* arr, char* dest){
RJP_array* array = &arr->array;
RJP_array_element* element_list = array->elements;
size_t pos = 0;
for(;element_list;element_list = element_list->next){
pos += _rjp__write_value(dest+pos, &element_list->value);
@ -145,9 +145,9 @@ size_t rjp_dump_array(struct JSON_value* arr, char* dest){
return pos;
}
size_t rjp_dump_object(struct JSON_value* root, char* dest){
struct JSON_object* root_obj = &root->object;
struct JSON_object_member* member_list = root_obj->members;
size_t rjp_dump_object(RJP_value* root, char* dest){
RJP_object* root_obj = &root->object;
RJP_object_member* member_list = root_obj->members;
size_t pos = 0;
for(;member_list;member_list = member_list->next){
pos += sprintf(dest+pos, "\"%s\":", member_list->name.value);
@ -161,7 +161,7 @@ size_t rjp_dump_object(struct JSON_value* root, char* dest){
return pos;
}
char* rjp_to_json(struct JSON_value* root){
char* rjp_to_json(RJP_value* root){
if(!root)
return NULL;
size_t len = _rjp__object_strlen(root);

14
src/strings.c
View File

@ -5,7 +5,7 @@
#include <stdlib.h> //malloc, free
//Convert escape sequences in strings
char* _rjp__parse_string(struct JSON_value* root, const char* str, int* len, int* row, int* column){
char* _rjp__parse_string(RJP_value* root, const char* str, int* len, int* row, int* column){
char* new_string;
++(*column); //account for starting quotation mark
for(*len = 0;*(str+*len) != '"';++(*len), ++(*column)){
@ -121,10 +121,10 @@ size_t rjp_escape_strlen(const char* str){
}
return count;
}
size_t _rjp__array_strlen(struct JSON_value* arr){
size_t _rjp__array_strlen(RJP_value* arr){
size_t count = 2; //[]
struct JSON_array* array = &arr->array;
struct JSON_array_element* element_list = array->elements;
RJP_array* array = &arr->array;
RJP_array_element* element_list = array->elements;
for(;element_list;element_list = element_list->next){
switch(element_list->value.type){
case json_integer:
@ -157,10 +157,10 @@ size_t _rjp__array_strlen(struct JSON_value* arr){
return count;
}
size_t _rjp__object_strlen(struct JSON_value* root){
size_t _rjp__object_strlen(RJP_value* root){
size_t count = 2; //{}
struct JSON_object* root_obj = &root->object;
struct JSON_object_member* member_list = root_obj->members;
RJP_object* root_obj = &root->object;
RJP_object_member* member_list = root_obj->members;
for(;member_list;member_list = member_list->next){
if(member_list->name.length == 0 || member_list->name.value[0] == 0)
return 0;