From 6f4a55a7669273eae20a46aaa114188765a06126 Mon Sep 17 00:00:00 2001 From: rexy712 Date: Sat, 1 Dec 2018 08:33:08 -0800 Subject: [PATCH] removed excess 'struct's (typedefs) --- include/rjp.h | 123 ++++++++++++++++++++--------------------- include/rjp_internal.h | 12 ++-- src/input.c | 97 ++++++++++++++++---------------- src/output.c | 86 ++++++++++++++-------------- src/strings.c | 14 ++--- 5 files changed, 164 insertions(+), 168 deletions(-) diff --git a/include/rjp.h b/include/rjp.h index 164355b..0325e75 100644 --- a/include/rjp.h +++ b/include/rjp.h @@ -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 } diff --git a/include/rjp_internal.h b/include/rjp_internal.h index fbeee6c..854f7af 100644 --- a/include/rjp_internal.h +++ b/include/rjp_internal.h @@ -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 diff --git a/src/input.c b/src/input.c index d71d6a0..2b1f538 100644 --- a/src/input.c +++ b/src/input.c @@ -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 + diff --git a/src/output.c b/src/output.c index e3a2b48..59526bc 100644 --- a/src/output.c +++ b/src/output.c @@ -5,12 +5,12 @@ #include //malloc, calloc, free #include //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); diff --git a/src/strings.c b/src/strings.c index 8988c31..7f60a20 100644 --- a/src/strings.c +++ b/src/strings.c @@ -5,7 +5,7 @@ #include //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;