1244 lines
38 KiB
C
1244 lines
38 KiB
C
#include "json_t/json_t.h"
|
|
|
|
bool is_js_space(char c){
|
|
//printf("c=|%c|[%d]\n",c,c);
|
|
if(c == ' ') return true;
|
|
if(c == '\t') return true;
|
|
if(c == '\n') return true;
|
|
if(c == '\r') return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
void set_index_(struct js_value *js, size_t index){
|
|
if(js->code_type == jstype_object)
|
|
js->type.object.index = index;
|
|
else if(js->code_type == jstype_array)
|
|
js->type.array.index = index;
|
|
}
|
|
|
|
long get_index_(struct js_value *js){
|
|
if(js->code_type == jstype_object)
|
|
return js->type.object.index;
|
|
if(js->code_type == jstype_array)
|
|
return js->type.array.index;
|
|
return -1;
|
|
}
|
|
|
|
|
|
|
|
struct js_value * next_(struct js_value *js){
|
|
if(js->code_type == jstype_object){
|
|
return js->type.object.next_object;
|
|
}
|
|
if(js->code_type == jstype_array){
|
|
return js->type.array.next_element;
|
|
}
|
|
return NULL;
|
|
}
|
|
struct js_value * prev_(struct js_value *js){
|
|
if(js->code_type == jstype_object){
|
|
return js->type.object.prev_object;
|
|
}
|
|
if(js->code_type == jstype_array){
|
|
return js->type.array.prev_element;
|
|
}
|
|
return NULL;
|
|
}
|
|
void free_js_value__(struct js_value *js){
|
|
if(js->code_type == jstype_string){
|
|
free(js->type.string);
|
|
}else if(js->code_type == jstype_object){
|
|
// free_js_value(js->type.object.key);
|
|
free_js_value(js->type.object.value);
|
|
struct js_value *tmpV = js->type.object.next_object;
|
|
js->type.object.next_object = NULL;
|
|
struct js_value *ttmp;
|
|
while(tmpV){
|
|
ttmp = tmpV;
|
|
tmpV = ttmp->type.object.next_object ; //next_(ttmp);
|
|
ttmp->type.object.next_object = NULL;
|
|
//print_js_value(ttmp);
|
|
free_js_value(ttmp);
|
|
}
|
|
if(js->type.object.index == 0 && js->type.object.iter){
|
|
free(js->type.object.iter);
|
|
js->type.object.iter = NULL;
|
|
}
|
|
}else if(js->code_type == jstype_array){
|
|
free_js_value(js->type.array.value);
|
|
struct js_value *tmpV = js->type.array.next_element;
|
|
js->type.array.next_element = NULL;
|
|
struct js_value *ttmp;
|
|
while(tmpV){
|
|
ttmp = tmpV;
|
|
tmpV = ttmp->type.array.next_element ; //next_(ttmp);
|
|
ttmp->type.array.next_element = NULL;
|
|
//print_js_value(ttmp);
|
|
free_js_value(ttmp);
|
|
}
|
|
if(js->type.array.index == 0 && js->type.array.iter){
|
|
free(js->type.array.iter);
|
|
js->type.array.iter = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
free(js);
|
|
|
|
}
|
|
|
|
void _free_js_value_no_free_iter(struct js_value *js){
|
|
if(js!=NULL){
|
|
|
|
if(js->code_type == jstype_number){
|
|
|
|
free(js);
|
|
}else if(js->code_type == jstype_string){
|
|
free(js->type.string);
|
|
free(js);
|
|
}else if(js->code_type == jstype_bool){
|
|
free(js);
|
|
}else if(js->code_type == jstype_null){
|
|
free(js);
|
|
}else if(js->code_type == jstype_object){
|
|
struct js_value *tmpjs = NULL;
|
|
|
|
while(js){
|
|
tmpjs=js;
|
|
|
|
_free_js_value_no_free_iter(tmpjs->type.object.value);
|
|
|
|
js = tmpjs->type.object.next_object;
|
|
free(tmpjs);
|
|
}
|
|
}else if(js->code_type == jstype_array){
|
|
struct js_value *tmpjs = NULL;
|
|
while(js){
|
|
tmpjs = js;
|
|
_free_js_value_no_free_iter(tmpjs->type.array.value);
|
|
|
|
js = tmpjs->type.array.next_element; // next_(tmpjs);
|
|
free(tmpjs);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void free_js_value(struct js_value *js){
|
|
if(js!=NULL){
|
|
|
|
if(js->code_type == jstype_number){
|
|
|
|
free(js);
|
|
}else if(js->code_type == jstype_string){
|
|
free(js->type.string);
|
|
free(js);
|
|
}else if(js->code_type == jstype_bool){
|
|
free(js);
|
|
}else if(js->code_type == jstype_null){
|
|
free(js);
|
|
}else if(js->code_type == jstype_object){
|
|
struct js_value *tmpjs = NULL;
|
|
|
|
while(js){
|
|
tmpjs=js;
|
|
if((tmpjs->type.object.iter != NULL) && (tmpjs->type.object.prev_object == NULL)){
|
|
free(tmpjs->type.object.iter);
|
|
}
|
|
if(tmpjs->type.object.key)
|
|
free(tmpjs->type.object.key);
|
|
free_js_value(tmpjs->type.object.value);
|
|
|
|
js = tmpjs->type.object.next_object;
|
|
free(tmpjs);
|
|
}
|
|
}else if(js->code_type == jstype_array){
|
|
struct js_value *tmpjs = NULL;
|
|
while(js){
|
|
tmpjs = js;
|
|
if((tmpjs->type.array.iter!=NULL) && (tmpjs->type.array.prev_element == NULL)){
|
|
free(tmpjs->type.array.iter);
|
|
}
|
|
free_js_value(tmpjs->type.array.value);
|
|
|
|
js = tmpjs->type.array.next_element; // next_(tmpjs);
|
|
free(tmpjs);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
struct js_value * create_js_value_string(char * input, struct js_value * parent){
|
|
struct js_value * js = malloc(sizeof(struct js_value));
|
|
js->parent = parent;
|
|
/*
|
|
if(*input == '"')
|
|
js->str_value = input+1;
|
|
else*/
|
|
js->str_value = input;
|
|
js->code_type = jstype_string;
|
|
char *cur = js->str_value;
|
|
//if(*input == '"') ++cur;
|
|
for(;*cur && *cur!='"'; ++cur);
|
|
if(*cur=='\0'){
|
|
fprintf(stderr, "error string format, \" missing\n");
|
|
free(js);
|
|
return NULL;
|
|
}
|
|
js->length = cur - js->str_value;
|
|
js->type.string = malloc(js->length + 1);
|
|
strncpy(js->type.string, js->str_value, js->length);
|
|
js->type.string[js->length]='\0';
|
|
return js;
|
|
}
|
|
|
|
struct js_value * create_js_value_number(char * input, struct js_value * parent){
|
|
struct js_value * js = malloc(sizeof(struct js_value));
|
|
js->parent = parent;
|
|
js->str_value = input;
|
|
js->code_type = jstype_number;
|
|
char *end;
|
|
js->type.number = strtold(input, &end);
|
|
js->length = end - input;
|
|
// printf("\nend_num:%s, num:%s, lenN:%ld\n",end,input, js->length);
|
|
return js;
|
|
}
|
|
|
|
struct js_value * create_js_value_null(char * input, struct js_value * parent){
|
|
struct js_value * js = malloc(sizeof(struct js_value));
|
|
js->parent = parent;
|
|
js->str_value = input;
|
|
js->code_type = jstype_null;
|
|
js->length = 4;
|
|
|
|
return js;
|
|
}
|
|
|
|
|
|
struct js_value * create_js_value_true(char * input, struct js_value * parent){
|
|
struct js_value * js = malloc(sizeof(struct js_value));
|
|
js->parent = parent;
|
|
js->str_value = input;
|
|
js->code_type = jstype_bool;
|
|
js->type.boolean = true;
|
|
js->length = 4;
|
|
|
|
return js;
|
|
}
|
|
struct js_value * create_js_value_false(char * input, struct js_value * parent){
|
|
struct js_value * js = malloc(sizeof(struct js_value));
|
|
js->parent = parent;
|
|
js->str_value = input;
|
|
js->code_type = jstype_bool;
|
|
js->type.boolean = false;
|
|
js->length = 5;
|
|
|
|
return js;
|
|
}
|
|
|
|
|
|
struct js_value * create_js_value_array(char * _input, struct js_value * parent){
|
|
struct js_value * js_parent = malloc(sizeof(struct js_value));
|
|
struct js_value * js, *tmp_js;
|
|
js = js_parent;
|
|
char *input = _input;
|
|
if(*_input == '[')
|
|
input = _input + 1;
|
|
|
|
char *cur = input;
|
|
for(long depth = 1; *cur != '\0' && depth != 0; ++cur){
|
|
if(*cur == '[') ++depth;
|
|
if(*cur == ']') --depth;
|
|
}
|
|
js->length = cur - input;
|
|
// printf("\na]input ==%s, len:%ld\n",input,js->length);
|
|
|
|
js->type.array.next_element = NULL;
|
|
js->type.array.prev_element = NULL;
|
|
js->type.array.index = 0;
|
|
|
|
js->type.array.iter = malloc(sizeof(struct js_iterator));
|
|
|
|
js->type.array.iter->size = js->type.array.index + 1;
|
|
js->type.array.iter->begin = js;
|
|
js->type.array.iter->end = js;
|
|
js->type.array.iter->current = js;
|
|
|
|
if(parent == NULL)
|
|
js->type.array.depth= 0;
|
|
else
|
|
js->type.array.depth = parent->type.array.depth + 1;
|
|
// js->index = 0;
|
|
|
|
js->str_value = input;
|
|
js->code_type = jstype_array;
|
|
cur = input;
|
|
for(; is_js_space(*cur); ++cur);
|
|
if(*cur == ']'){
|
|
|
|
js->type.array.value = create_js_value_null(NULL, js); // NULL;
|
|
js->type.array.value->length = cur - input + 1;
|
|
js->type.array.next_element = NULL;
|
|
js->parent = parent;
|
|
|
|
//js->type.object.key_length = cur - input;
|
|
//js->type.array.value = NULL;
|
|
|
|
return js;
|
|
}
|
|
|
|
while(cur < input + js_parent->length )
|
|
{
|
|
// printf("aa::%c\n",*cur);
|
|
if(*cur == ','){
|
|
++cur;
|
|
tmp_js = malloc(sizeof(struct js_value));
|
|
//for(; is_js_space(*cur); ++cur);
|
|
tmp_js->str_value = cur;// + 1;
|
|
tmp_js->code_type = jstype_array;
|
|
char *ccur = cur;
|
|
for(; *ccur != '\0' && *ccur != ',' ; ++ccur){
|
|
if(*ccur == '{'){ // to ignore ',' in the object
|
|
++ccur;
|
|
for(long depth = 1; *ccur != '\0' && depth != 0; ++ccur){
|
|
if(*ccur == '{') ++depth;
|
|
if(*ccur == '}') --depth;
|
|
}
|
|
//break;
|
|
}
|
|
if(*ccur == ']')
|
|
break;
|
|
if(*cur == '['){// to ignore ',' in the list
|
|
++ccur;
|
|
for(long depth = 1; *ccur != '\0' && depth != 0; ++ccur){
|
|
if(*ccur == '[') ++depth;
|
|
if(*ccur == ']') --depth;
|
|
}
|
|
//break;
|
|
}
|
|
if(*cur == '"'){ // to ignore ',' in "string value"
|
|
for(; *ccur != '\0' || *ccur !='"'; ++ccur);
|
|
}
|
|
}
|
|
tmp_js->length = ccur - cur;
|
|
tmp_js->type.array.prev_element = js;
|
|
tmp_js->type.array.next_element = NULL;
|
|
tmp_js->type.array.iter = js_parent->type.array.iter;
|
|
tmp_js->type.array.index = js->type.array.index + 1;
|
|
//tmp_js->type.object.iter = NULL;
|
|
js->type.array.next_element = tmp_js;
|
|
js= tmp_js;
|
|
if(parent == NULL)
|
|
js->type.array.depth= 0;
|
|
else
|
|
js->type.array.depth = parent->type.array.depth + 1;
|
|
|
|
|
|
js_parent->type.array.iter->size = js->type.array.index + 1;
|
|
js_parent->type.array.iter->end = js;
|
|
js_parent->type.array.iter->current = js;
|
|
|
|
}else{
|
|
|
|
}
|
|
|
|
js->parent = parent;
|
|
|
|
|
|
for(; is_js_space(*cur); ++cur);
|
|
|
|
// value section
|
|
char *str_value = cur; // + js->type.object.key->length;
|
|
|
|
|
|
js->type.array.value = create_js_value(str_value, js);
|
|
|
|
//cur = str_value + js->type.array.value->length + (js->type.array.value->code_type != jstype_number) ; //1 ;
|
|
cur = str_value + js->type.array.value->length + (js->type.array.value->code_type == jstype_string) ; //1 ;
|
|
// printf("<a>>strVal:%s\n",cur);
|
|
|
|
if(js->type.array.value->code_type == jstype_string)
|
|
for(; is_js_space(*cur) || *cur=='"' || *cur=='}' || *cur == ']'; ++cur);
|
|
else
|
|
for(; is_js_space(*cur) || *cur=='}' || *cur == ']'; ++cur);
|
|
|
|
}
|
|
|
|
return js_parent;
|
|
|
|
|
|
}
|
|
|
|
struct js_value * create_js_value(char *_input, struct js_value *parent){
|
|
char *input = _input;
|
|
for(; is_js_space(*input); ++input){}
|
|
|
|
//printf("\n>>strVal:%s\n",input);
|
|
if(*input == '"'){
|
|
return create_js_value_string(input+1, parent);
|
|
}else if(strncmp(input,"true",4) == 0){
|
|
return create_js_value_true(input, parent);
|
|
}else if(strncmp(input,"false",5) == 0){
|
|
return create_js_value_false(input, parent);
|
|
}else if(strncmp(input,"null",4) == 0){
|
|
return create_js_value_null(input, parent);
|
|
}else if(*input == '{'){
|
|
return create_js_value_object(input + 1, parent);
|
|
}else if(*input == '['){
|
|
return create_js_value_array(input + 1, parent);
|
|
}else /*if(isdigit(*input))*/{
|
|
return create_js_value_number(input, parent);
|
|
}
|
|
|
|
|
|
}
|
|
|
|
struct js_value * create_js_value_object(char *_input /*, struct js_value *prev*/, struct js_value * parent){
|
|
struct js_value * js_parent = malloc(sizeof(struct js_value));
|
|
struct js_value * js, *tmp_js;
|
|
js = js_parent;
|
|
char *input = _input;
|
|
|
|
if(*_input == '{')
|
|
input = _input + 1;
|
|
|
|
char *cur = input;
|
|
for(long depth = 1; *cur != '\0' && depth != 0; ++cur){
|
|
if(*cur == '{') ++depth;
|
|
if(*cur == '}') --depth;
|
|
}
|
|
js->length = cur - input;
|
|
|
|
|
|
js->type.object.next_object = NULL;
|
|
js->type.object.prev_object = NULL;
|
|
js->type.object.index = 0;
|
|
|
|
js->type.object.iter = malloc(sizeof(struct js_iterator));
|
|
js->type.object.iter->size = js->type.object.index + 1;
|
|
js->type.object.iter->begin = js;
|
|
js->type.object.iter->end = js;
|
|
js->type.object.iter->current = js;
|
|
|
|
if(parent == NULL)
|
|
js->type.object.depth = 0;
|
|
else
|
|
js->type.object.depth = parent->type.object.depth + 1;
|
|
|
|
js->str_value = input;
|
|
js->code_type = jstype_object;
|
|
|
|
cur = input;
|
|
for(; is_js_space(*cur); ++cur);
|
|
if(*cur == '}'){
|
|
|
|
js->type.object.value = create_js_value_null(NULL, js);// NULL;
|
|
js->type.object.value->length = cur - input;
|
|
js->type.object.key_length = 0;
|
|
js->type.object.key = NULL;
|
|
js->type.object.next_object = NULL;
|
|
js->parent = parent;
|
|
return js;
|
|
}
|
|
|
|
|
|
|
|
while(cur < input + js_parent->length)
|
|
{
|
|
if(*cur == ','){
|
|
++cur;
|
|
tmp_js = malloc(sizeof(struct js_value));
|
|
//for(; is_js_space(*cur); ++cur);
|
|
tmp_js->str_value = cur ;//+ 1;
|
|
tmp_js->code_type = jstype_object;
|
|
char *ccur = cur;
|
|
for(; *ccur != '\0' && *ccur != ',' ; ++ccur){
|
|
if(*ccur == '{'){ // to ignore ',' in the object
|
|
++ccur;
|
|
for(long depth = 1; *ccur != '\0' && depth != 0; ++ccur){
|
|
if(*ccur == '{') ++depth;
|
|
if(*ccur == '}') --depth;
|
|
}
|
|
//break;
|
|
}
|
|
if(*ccur == '}')
|
|
break;
|
|
if(*cur == '['){// to ignore ',' in the list
|
|
++ccur;
|
|
for(long depth = 1; *ccur != '\0' && depth != 0; ++ccur){
|
|
if(*ccur == '[') ++depth;
|
|
if(*ccur == ']') --depth;
|
|
}
|
|
//break;
|
|
}
|
|
if(*cur == '"'){ // to ignore ',' in "string value"
|
|
for(; *ccur != '\0' || *ccur !='"'; ++ccur);
|
|
}
|
|
}
|
|
tmp_js->length = ccur - cur;
|
|
tmp_js->type.object.prev_object = js;
|
|
tmp_js->type.object.next_object = NULL;
|
|
tmp_js->type.object.iter = js_parent->type.object.iter;
|
|
tmp_js->type.object.index = js->type.object.index + 1;
|
|
js->type.object.next_object = tmp_js;
|
|
js= tmp_js;
|
|
if(parent == NULL)
|
|
js->type.object.depth = 0;
|
|
else
|
|
js->type.object.depth = parent->type.object.depth + 1;
|
|
|
|
js_parent->type.object.iter->size = js->type.object.index + 1;
|
|
js_parent->type.object.iter->end = js;
|
|
js_parent->type.object.iter->current = js;
|
|
|
|
}else{
|
|
|
|
}
|
|
|
|
js->parent = parent;
|
|
for(; is_js_space(*cur); ++cur);
|
|
// key section
|
|
// js->type.object.key = create_js_value_string(cur, js);
|
|
|
|
if(*cur == '"'){
|
|
++cur;
|
|
}else{// no key ! problem format
|
|
printf("debug: format json error, no string with \" symbole as key\n");
|
|
free(js->type.object.iter);
|
|
free(js);
|
|
return NULL;
|
|
}
|
|
char *key = cur;
|
|
// /1/js->type.object.key = cur;
|
|
for(; *cur && *cur != '"'; ++cur);
|
|
if(*cur=='\0'){// no \" ! problem format
|
|
printf("debug: format json error: no \" symbole after key!\n");
|
|
free(js->type.object.iter);
|
|
free(js);
|
|
return NULL;
|
|
}
|
|
|
|
|
|
//js->key = cur;
|
|
//for(; *cur != '"'; ++cur);
|
|
//js->key_length = cur - js->key;
|
|
// /1/js->type.object.key_length = cur - js->type.object.key;
|
|
js->type.object.key_length = cur - key ;
|
|
js->type.object.key = malloc(js->type.object.key_length+1);
|
|
memcpy(js->type.object.key,key,js->type.object.key_length);
|
|
*(js->type.object.key + js->type.object.key_length) ='\0';
|
|
|
|
//js->type.object.key = cur;
|
|
for(; *cur && *cur != ':'; ++cur);
|
|
if(*cur=='\0'){// no \" ! problem format
|
|
printf("debug: format json error, no : after key\n");
|
|
free(js->type.object.key);
|
|
free(js->type.object.iter);
|
|
free(js);
|
|
return NULL;
|
|
}
|
|
|
|
++cur;
|
|
for(; is_js_space(*cur); ++cur);
|
|
// printf("cur=%s| lenKey :%ld \n",cur,js->type.object.key_length);
|
|
|
|
|
|
// value section
|
|
char *str_value = cur; // + js->type.object.key->length;
|
|
|
|
js->type.object.value = create_js_value(str_value, js);
|
|
if(js->type.object.value==NULL){
|
|
fprintf(stderr,"debug: format json error value\n");
|
|
free(js->type.object.key);
|
|
free(js->type.object.iter);
|
|
free(js);
|
|
return NULL;
|
|
|
|
}
|
|
//printf("\n[<<<: cur:%s\n(js->type.object.value->code_type != jstype_number)=%d\n",cur,(js->type.object.value->code_type != jstype_number));
|
|
|
|
cur = str_value + js->type.object.value->length + (js->type.object.value->code_type == jstype_string); // ((js->type.object.value->code_type < jstype_bool)||(js->type.object.value->code_type > jstype_number));// 1 ;
|
|
//printf("\n[>>>: cur:%s\n",cur);
|
|
|
|
if(js->type.object.value->code_type == jstype_string)
|
|
for(; is_js_space(*cur) || *cur=='"' || *cur=='}' || *cur == ']'; ++cur);
|
|
else
|
|
for(; is_js_space(*cur) || *cur=='}' || *cur == ']'; ++cur);
|
|
|
|
|
|
}
|
|
|
|
return js_parent;
|
|
|
|
}
|
|
void create_copy_js_iterator(struct js_iterator **_dstit, struct js_iterator *srcit){
|
|
if(*_dstit == NULL){
|
|
*_dstit = malloc(sizeof(struct js_iterator));
|
|
}
|
|
struct js_iterator * dstit = *_dstit;
|
|
dstit->size = srcit->size;
|
|
// dstit->next_ = srcit->next_;
|
|
// dstit->prev_ = srcit->prev_;
|
|
// dstit->set_index_ = srcit->set_index_;
|
|
// dstit->get_index_ = srcit->get_index_;
|
|
dstit->begin = srcit->begin;
|
|
dstit->end = srcit->end;
|
|
dstit->current = srcit->current;
|
|
|
|
}
|
|
|
|
void setup_js_iterator(struct js_iterator **_iter, struct js_value * js){
|
|
|
|
|
|
if(js->code_type == jstype_object || js->code_type == jstype_array ) {
|
|
if(*_iter == NULL){
|
|
*_iter = malloc(sizeof(struct js_iterator));
|
|
}
|
|
struct js_iterator *iter = *_iter ;
|
|
// iter->next_ = next_;
|
|
// iter->prev_ = prev_;
|
|
// iter->set_index_ = set_index_;
|
|
// iter->get_index_ = get_index_;
|
|
|
|
iter->begin = js;
|
|
struct js_value *tmpjs = js;
|
|
//struct js_value *tmpit = iter->begin;
|
|
//size_t index = 0;
|
|
while(tmpjs){
|
|
//iter->set_index_(tmpjs, index);
|
|
//++index;
|
|
|
|
iter->size = get_index_(tmpjs);
|
|
|
|
iter->end = tmpjs;
|
|
iter->current = tmpjs;
|
|
tmpjs = next_(tmpjs);
|
|
}
|
|
|
|
//return iter;
|
|
|
|
}
|
|
|
|
//return NULL;
|
|
|
|
|
|
}
|
|
|
|
long get_size_(struct js_value *js){
|
|
if(js->code_type < jstype_object) return -1;
|
|
if(js->code_type == jstype_object) return js->type.object.iter->size;
|
|
return js->type.array.iter->size;
|
|
}
|
|
|
|
long move_current_iter_to_index_(struct js_value *js, size_t index){
|
|
if(js->code_type < jstype_object) return -1;
|
|
if(js->code_type == jstype_object){
|
|
struct js_iterator *iter = js->type.object.iter;
|
|
if(index == js->type.object.index) return index;
|
|
long size = iter->size;
|
|
if(index >= size ){
|
|
iter->current = iter->end;
|
|
return size - 1;
|
|
}
|
|
long from_current_index = iter->current->type.object.index - index;
|
|
size_t abs_cur_diff = abs(from_current_index);
|
|
size_t array_diff_index[3] = {index, abs_cur_diff , size - 1 - index};
|
|
size_t index_nearest = ARG_MIN_ARRAY_TYPE_SIZE_T(array_diff_index, 3);
|
|
if(index_nearest == 0){
|
|
iter->current = iter->begin;
|
|
for(size_t i=0; i<array_diff_index[0]; ++i) iter->current = iter->current->type.object.next_object;//next_(iter->current);
|
|
}
|
|
else if(index_nearest == 2){
|
|
iter->current = iter->end;
|
|
for(size_t i=0; i < array_diff_index[2]; ++i) iter->current = iter->current->type.object.prev_object;//prev_(iter->current);
|
|
}else if(from_current_index >= 0)
|
|
for(size_t i=0; i < array_diff_index[1]; ++i) iter->current = iter->current->type.object.prev_object;//prev_(iter->current); prev_(iter->current);
|
|
else
|
|
for(size_t i=0; i < array_diff_index[1]; ++i) iter->current = iter->current->type.object.next_object;//next_(iter->current); next_(iter->current);
|
|
|
|
return index;
|
|
|
|
}else{
|
|
struct js_iterator *iter = js->type.array.iter;
|
|
if(index == js->type.array.index) return index;
|
|
long size = iter->size;
|
|
if(index >= size ){
|
|
iter->current = iter->end;
|
|
return size - 1;
|
|
}
|
|
long from_current_index = iter->current->type.array.index - index;
|
|
size_t abs_cur_diff = abs(from_current_index);
|
|
size_t array_diff_index[3] = {index, abs_cur_diff , size - 1 - index};
|
|
size_t index_nearest = ARG_MIN_ARRAY_TYPE_SIZE_T(array_diff_index, 3);
|
|
if(index_nearest == 0){
|
|
iter->current = iter->begin;
|
|
for(size_t i=0; i<array_diff_index[0]; ++i) iter->current = iter->current->type.array.next_element;//next_(iter->current);
|
|
}
|
|
else if(index_nearest == 2){
|
|
iter->current = iter->end;
|
|
for(size_t i=0; i < array_diff_index[2]; ++i) iter->current = iter->current->type.array.prev_element;//prev_(iter->current);
|
|
}else if(from_current_index >= 0)
|
|
for(size_t i=0; i < array_diff_index[1]; ++i) iter->current = iter->current->type.array.prev_element;//prev_(iter->current); prev_(iter->current);
|
|
else
|
|
for(size_t i=0; i < array_diff_index[1]; ++i) iter->current = iter->current->type.array.next_element;//next_(iter->current); next_(iter->current);
|
|
|
|
return index;
|
|
|
|
|
|
}
|
|
|
|
|
|
#if 0
|
|
|
|
struct js_iterator *iter = get_iterator_(js);
|
|
if(index == get_index_(iter->current)) return index;
|
|
//if(js->begin_list == NULL) return 0;
|
|
long size = get_size_(js);
|
|
if(index >= size){
|
|
iter->current = iter->end;
|
|
//js->current_index = js->size - 1;
|
|
return size - 1;
|
|
}
|
|
|
|
long from_current_index = get_index_(iter->current) - index;
|
|
size_t abs_cur_diff = abs(from_current_index);
|
|
size_t array_diff_index[3] = {index, abs_cur_diff , size - 1 - index};
|
|
size_t index_nearest = ARG_MIN_ARRAY_TYPE_SIZE_T(array_diff_index, 3);
|
|
if(index_nearest == 0){
|
|
iter->current = iter->begin;
|
|
for(size_t i=0; i<array_diff_index[0]; ++i) iter->current = next_(iter->current);
|
|
}
|
|
else if(index_nearest == 2){
|
|
iter->current = iter->end;
|
|
for(size_t i=0; i < array_diff_index[2]; ++i) iter->current = prev_(iter->current);
|
|
}else if(from_current_index >= 0)
|
|
for(size_t i=0; i < array_diff_index[1]; ++i) iter->current = prev_(iter->current);
|
|
else
|
|
for(size_t i=0; i < array_diff_index[1]; ++i) iter->current = next_(iter->current);
|
|
|
|
return index;
|
|
#endif
|
|
}
|
|
|
|
struct js_value * get_js_value_of_index_(size_t index, struct js_value *js){
|
|
if(move_current_iter_to_index_(js, index) >=0)
|
|
return get_iterator_(js)->current;
|
|
return NULL;
|
|
}
|
|
|
|
void set_next_(struct js_value * dstjs, struct js_value * jsnxt){
|
|
if(dstjs->code_type == jstype_object){
|
|
struct js_value *tmpjs = dstjs->type.object.next_object;
|
|
struct js_iterator *iter = dstjs->type.object.iter;
|
|
size_t last_index = dstjs->type.object.index;
|
|
|
|
if(jsnxt->code_type == jstype_object){
|
|
dstjs->type.object.next_object = jsnxt;
|
|
struct js_iterator *it_er = jsnxt->type.object.iter;
|
|
jsnxt->type.object.prev_object = dstjs;
|
|
while(jsnxt){
|
|
jsnxt->type.object.iter = iter;
|
|
jsnxt->type.object.index = ++last_index;
|
|
jsnxt = jsnxt->type.object.next_object;
|
|
}
|
|
if(tmpjs == NULL && it_er){
|
|
iter->end = it_er->end;
|
|
}else{
|
|
while(tmpjs){
|
|
tmpjs->type.object.index = ++last_index;
|
|
tmpjs = tmpjs->type.object.next_object;
|
|
}
|
|
}
|
|
iter->size = last_index + 1;
|
|
if(it_er){
|
|
free(it_er);
|
|
}
|
|
}
|
|
}
|
|
else if(dstjs->code_type == jstype_array){
|
|
struct js_value *tmpjs = dstjs->type.array.next_element;
|
|
struct js_iterator *iter = dstjs->type.array.iter;
|
|
size_t last_index = dstjs->type.array.index;
|
|
|
|
if(jsnxt->code_type == jstype_array){
|
|
dstjs->type.array.next_element = jsnxt;
|
|
struct js_iterator *it_er = jsnxt->type.array.iter;
|
|
jsnxt->type.array.prev_element= dstjs;
|
|
while(jsnxt){
|
|
jsnxt->type.array.iter = iter;
|
|
jsnxt->type.array.index = ++last_index;
|
|
jsnxt = jsnxt->type.array.next_element;
|
|
}
|
|
if(tmpjs == NULL && it_er){
|
|
iter->end = it_er->end;
|
|
}else{
|
|
while(tmpjs){
|
|
tmpjs->type.array.index = ++last_index;
|
|
tmpjs = tmpjs->type.array.next_element;
|
|
}
|
|
}
|
|
iter->size = last_index + 1;
|
|
if(it_er){
|
|
free(it_er);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void set_prev_(struct js_value ** _dst, struct js_value * jsprv){
|
|
struct js_value *dst = *_dst;
|
|
if(dst->code_type == jstype_object){
|
|
struct js_value *tmpjs = dst->type.object.prev_object;//, *ttmpjs;
|
|
//ttmpjs = dst;
|
|
//while(prev_(ttmpjs)) ttmpjs = prev_(ttmpjs);
|
|
//struct js_iterator *iter = ttmpjs->type.object.iter;
|
|
struct js_iterator *iter = dst->type.object.iter;
|
|
jsprv->type.object.iter = iter;
|
|
dst->type.object.prev_object = jsprv;
|
|
jsprv->type.object.prev_object = tmpjs;
|
|
jsprv->type.object.index = dst->type.object.index;
|
|
jsprv->type.object.prev_object = tmpjs;
|
|
size_t last_index = dst->type.object.index;
|
|
struct js_value *ttmp = jsprv;
|
|
while(next_(ttmp)){
|
|
ttmp->type.object.index = (++last_index);
|
|
ttmp = next_(ttmp);
|
|
if(iter) ++(iter->size);// = last_index + 1;
|
|
}
|
|
ttmp->type.object.next_object = dst;
|
|
if(tmpjs){
|
|
tmpjs->type.object.next_object = jsprv;
|
|
}else{// dst prev null (top)
|
|
*_dst = jsprv;
|
|
//(*_dst)->type.object.iter = iter; // malloc(sizeof(struct js_iterator));
|
|
//(*_dst)->type.object.iter->begin = jsprv;
|
|
if(iter){
|
|
iter->begin = jsprv;
|
|
// (*_dst)->type.object.iter->end = iter->end;
|
|
// (*_dst)->type.object.iter->current = iter->current;
|
|
// (*_dst)->type.object.iter->size = iter->size; // + (last_index + 1 - dst->type.object.index);
|
|
}
|
|
//iter = (*_dst)->type.object.iter;
|
|
}
|
|
tmpjs = dst;
|
|
while(tmpjs){
|
|
tmpjs->type.object.index = (++last_index);
|
|
tmpjs = next_(tmpjs);
|
|
//if(iter) {
|
|
// iter->size = last_index + 1;
|
|
// iter->end = tmpjs;
|
|
//}
|
|
}
|
|
}else if(dst->code_type == jstype_array){
|
|
struct js_value *tmpjs = dst->type.array.prev_element;//, *ttmpjs;
|
|
//ttmpjs = dst;
|
|
//while(prev_(ttmpjs)) ttmpjs = prev_(ttmpjs);
|
|
//struct js_iterator *iter = ttmpjs->type.array.iter;
|
|
struct js_iterator *iter = dst->type.array.iter;
|
|
jsprv->type.array.iter = iter;
|
|
dst->type.array.prev_element = jsprv;
|
|
jsprv->type.array.prev_element = tmpjs;
|
|
jsprv->type.array.index = dst->type.array.index;
|
|
jsprv->type.array.prev_element = tmpjs;
|
|
size_t last_index = dst->type.array.index;
|
|
struct js_value *ttmp = jsprv;
|
|
while(next_(ttmp)){
|
|
ttmp->type.array.index = (++last_index);
|
|
ttmp = next_(ttmp);
|
|
if(iter) ++(iter->size);// = last_index + 1;
|
|
}
|
|
ttmp->type.array.next_element = dst;
|
|
if(tmpjs){
|
|
tmpjs->type.array.next_element = jsprv;
|
|
}else{// dst prev null (top)
|
|
*_dst = jsprv;
|
|
//(*_dst)->type.array.iter = malloc(sizeof(struct js_iterator));
|
|
//(*_dst)->type.array.iter->begin = jsprv;
|
|
if(iter){
|
|
iter->begin = jsprv;
|
|
//(*_dst)->type.array.iter->end = iter->end;
|
|
//(*_dst)->type.array.iter->current = iter->current;
|
|
//(*_dst)->type.array.iter->size = iter->size; // + (last_index + 1 - dst->type.array.index);
|
|
}
|
|
//iter = (*_dst)->type.array.iter;
|
|
}
|
|
tmpjs = dst;
|
|
while(tmpjs){
|
|
++(tmpjs->type.array.index);
|
|
tmpjs = next_(tmpjs);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
|
|
void add_js_value_index(size_t index, struct js_value *js_to_add, struct js_value **js_org){
|
|
if((*js_org)->code_type >= jstype_object && (*js_org)->code_type == js_to_add->code_type ){
|
|
struct js_value /**tmpjs = *js_org,*/ *ttmp=NULL;
|
|
/*while(tmpjs){// TO DO : use iter to optimize
|
|
if(get_index_(tmpjs) == index){
|
|
// printf("broken, index:%ld\n",index);
|
|
break;
|
|
}
|
|
ttmp = tmpjs;
|
|
tmpjs = next_(tmpjs);
|
|
}*/
|
|
ttmp = get_js_value_of_index_(index, *js_org);
|
|
if(ttmp != *js_org){
|
|
// printf("not NULL\n");
|
|
set_next_(ttmp,js_to_add);
|
|
}else{
|
|
set_prev_(js_org, js_to_add);
|
|
}
|
|
}
|
|
}
|
|
|
|
void delete_index_js_value(size_t index, struct js_value **js_org){
|
|
if((*js_org) && ( (*js_org)->code_type >= jstype_object) ){
|
|
struct js_value *ttmp=NULL;
|
|
ttmp = get_js_value_of_index_(index, *js_org);
|
|
|
|
if(ttmp && ((*js_org)->code_type == jstype_object)){
|
|
struct js_iterator *iter = (*js_org)->type.object.iter;
|
|
struct js_value *prevJS = ttmp->type.object.prev_object;
|
|
struct js_value *nextJS = ttmp->type.object.next_object;
|
|
|
|
if(prevJS){
|
|
prevJS->type.object.next_object = nextJS;
|
|
|
|
}else{
|
|
iter->begin = nextJS;
|
|
}
|
|
|
|
if(iter->current == ttmp){
|
|
iter->current = (nextJS ? nextJS : prevJS) ;
|
|
}
|
|
if(nextJS){
|
|
nextJS->type.object.prev_object = prevJS;
|
|
}else{
|
|
iter->end = prevJS;
|
|
}
|
|
|
|
if(ttmp == *js_org){
|
|
*js_org = nextJS;
|
|
iter->begin = nextJS;
|
|
}
|
|
while(nextJS){
|
|
--(nextJS->type.object.index);
|
|
nextJS = nextJS->type.object.next_object;
|
|
}
|
|
--(iter->size);
|
|
|
|
ttmp->type.object.next_object = NULL;
|
|
ttmp->type.object.prev_object = NULL;
|
|
|
|
if(*js_org){
|
|
ttmp->type.object.iter = NULL;
|
|
}
|
|
|
|
free_js_value(ttmp);
|
|
|
|
}else{
|
|
struct js_iterator *iter = (*js_org)->type.array.iter;
|
|
struct js_value *prevJS = ttmp->type.array.prev_element;
|
|
struct js_value *nextJS = ttmp->type.array.next_element;
|
|
|
|
if(prevJS){
|
|
prevJS->type.array.next_element = nextJS;
|
|
|
|
}else{
|
|
iter->begin = nextJS;
|
|
}
|
|
|
|
if(iter->current == ttmp){
|
|
iter->current = (nextJS ? nextJS : prevJS) ;
|
|
}
|
|
if(nextJS){
|
|
nextJS->type.array.prev_element = prevJS;
|
|
}else{
|
|
iter->end = prevJS;
|
|
}
|
|
|
|
if(ttmp == *js_org){
|
|
*js_org = nextJS;
|
|
iter->begin = nextJS;
|
|
}
|
|
while(nextJS){
|
|
--(nextJS->type.array.index);
|
|
nextJS = nextJS->type.array.next_element;
|
|
}
|
|
--(iter->size);
|
|
|
|
ttmp->type.array.next_element = NULL;
|
|
ttmp->type.array.prev_element = NULL;
|
|
|
|
if(*js_org)
|
|
ttmp->type.array.iter = NULL;
|
|
|
|
free_js_value(ttmp);
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
struct js_iterator * get_iterator_(struct js_value *js){
|
|
if(js->code_type == jstype_object) return js->type.object.iter;
|
|
if(js->code_type == jstype_array) return js->type.array.iter;
|
|
return NULL;
|
|
}
|
|
void set_iterator_(struct js_value *js, struct js_iterator *iter){
|
|
|
|
if(js->code_type == jstype_object) js->type.object.iter = iter;
|
|
if(js->code_type == jstype_array) js->type.array.iter = iter;
|
|
}
|
|
|
|
void append_js_value(struct js_value *dst, char *input){/* if object type: input = { "key" : value }, if key already exists value replace the old value! */
|
|
if(dst){
|
|
if(dst->code_type < jstype_object || get_iterator_(dst) == NULL) return;
|
|
struct js_value *newval = create_js_value(input, dst->parent);
|
|
if(newval->code_type != dst->code_type) {
|
|
free_js_value(newval);
|
|
return;
|
|
}
|
|
struct js_iterator *iter = get_iterator_(dst);
|
|
set_next_(iter->end, newval);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
char * original_string_js_value(struct js_value *js){
|
|
char *ret = malloc(js->length+1);
|
|
strncpy(ret,js->str_value,js->length);
|
|
ret[js->length] = '\0';
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
//lret=strlen(buf);
|
|
|
|
#define UPDATE_RET_N_PUSH_Y_STRING(local_size, global_size, m_str, y_string_b_uf, buf)\
|
|
(y_string_b_uf) = create_y_ptr_STRING((buf), (local_size));\
|
|
(global_size) += (local_size);\
|
|
push_back_list_y_ptr_STRING((m_str), (y_string_b_uf));\
|
|
|
|
// printf("debug:global_size=%ld, local_size=%ld, buf=%s / / %d / /\n",(global_size),(local_size),(buf), js->code_type);
|
|
|
|
/* tab_depth = number of tabulationfor values, */
|
|
long int sprint_js_value_to_y_string_list(struct main_list_y_ptr_STRING *m_str, struct js_value *js, char sep, int tab_depth){
|
|
long int global_size = 0, local_size;
|
|
//char *buf = malloc(js->length);
|
|
//printf("debug: js->length = %ld\n",js->length);
|
|
char buf[500]; memset(buf,0,500);
|
|
y_ptr_STRING y_string_b_uf;
|
|
|
|
if(js->code_type == jstype_number){
|
|
//memset(buf,0,499);
|
|
local_size = sprintf(buf,"%Lf",js->type.number);
|
|
UPDATE_RET_N_PUSH_Y_STRING(local_size, global_size, m_str, y_string_b_uf, buf)
|
|
}else if(js->code_type == jstype_string){
|
|
//memset(buf,0,499);
|
|
local_size = sprintf(buf,"\"%s\"",js->type.string);
|
|
UPDATE_RET_N_PUSH_Y_STRING(local_size, global_size, m_str, y_string_b_uf, buf)
|
|
}else if(js->code_type == jstype_bool){
|
|
//memset(buf,0,499);
|
|
local_size = sprintf(buf,"%s",js->type.boolean ? "true" : "false");
|
|
UPDATE_RET_N_PUSH_Y_STRING(local_size, global_size, m_str, y_string_b_uf, buf)
|
|
}else if(js->code_type == jstype_null){
|
|
//memset(buf,0,499);
|
|
local_size = sprintf(buf,"%s","null");
|
|
UPDATE_RET_N_PUSH_Y_STRING(local_size, global_size, m_str, y_string_b_uf, buf)
|
|
}else if(js->code_type == jstype_object){
|
|
struct js_value *tmpjs = js;
|
|
|
|
while(tmpjs){
|
|
|
|
if(tmpjs->type.object.prev_object == NULL){
|
|
local_size = sprintf(buf,"%c%*c{ ",sep,tab_depth*(tmpjs->type.object.depth),' ');
|
|
UPDATE_RET_N_PUSH_Y_STRING(local_size, global_size, m_str, y_string_b_uf, buf)
|
|
}
|
|
|
|
local_size = sprintf(buf,"%c%*c\"%s\" : ",sep, tab_depth*(tmpjs->type.object.depth),' ', tmpjs->type.object.key);
|
|
UPDATE_RET_N_PUSH_Y_STRING(local_size, global_size, m_str, y_string_b_uf, buf)
|
|
|
|
global_size += sprint_js_value_to_y_string_list(m_str, tmpjs->type.object.value, sep, tab_depth );
|
|
|
|
if(tmpjs->type.object.next_object == NULL){
|
|
local_size = sprintf(buf,"%c%*c} ",sep,tab_depth*(tmpjs->type.object.depth),' '); //printf(" }");
|
|
UPDATE_RET_N_PUSH_Y_STRING(local_size, global_size, m_str, y_string_b_uf, buf)
|
|
}else{
|
|
//memset(buf,0,499);
|
|
local_size = sprintf(buf,", ");
|
|
UPDATE_RET_N_PUSH_Y_STRING(local_size, global_size, m_str, y_string_b_uf, buf)
|
|
}
|
|
//printf("\n");
|
|
tmpjs = tmpjs->type.object.next_object;
|
|
}
|
|
}else if(js->code_type == jstype_array){
|
|
struct js_value *tmpjs = js;
|
|
while(tmpjs){
|
|
if(tmpjs->type.array.prev_element == NULL){
|
|
//memset(buf,0,499);
|
|
local_size = sprintf(buf, "%c%*c[ ",sep,tab_depth*(tmpjs->type.array.depth),' ');
|
|
UPDATE_RET_N_PUSH_Y_STRING(local_size, global_size, m_str, y_string_b_uf, buf)
|
|
}
|
|
if(tmpjs->type.array.value->code_type < jstype_object ) {
|
|
//memset(buf,0,499);
|
|
local_size = sprintf(buf,"%c%*c ",sep,tab_depth*(tmpjs->type.array.depth),' ');
|
|
UPDATE_RET_N_PUSH_Y_STRING(local_size, global_size, m_str, y_string_b_uf, buf)
|
|
}
|
|
global_size += sprint_js_value_to_y_string_list(m_str,tmpjs->type.array.value,sep,tab_depth);
|
|
if(tmpjs->type.array.next_element == NULL){ //printf(" ]");
|
|
//memset(buf,0,499);
|
|
local_size = sprintf(buf,"%c%*c] ",sep,tab_depth*(tmpjs->type.array.depth),' ');
|
|
UPDATE_RET_N_PUSH_Y_STRING(local_size, global_size, m_str, y_string_b_uf, buf)
|
|
}else{
|
|
//memset(buf,0,499);
|
|
local_size = sprintf(buf,", ");
|
|
UPDATE_RET_N_PUSH_Y_STRING(local_size, global_size, m_str, y_string_b_uf, buf)
|
|
}
|
|
tmpjs = tmpjs->type.array.next_element; // next_(tmpjs);
|
|
}
|
|
}
|
|
|
|
//free(buf);
|
|
return global_size;
|
|
}
|
|
|
|
/* dstString can be NULL ! (it's better)*/
|
|
long int sprint_js_value(char **dstString, struct js_value *js, char sep, int tab_depth){
|
|
struct main_list_y_ptr_STRING *m_str=create_var_list_y_ptr_STRING();
|
|
// remove_all_ptr_type_list_y_ptr_STRING(m_str);
|
|
long int ret = sprint_js_value_to_y_string_list(m_str,js,sep, tab_depth);
|
|
copy_list_y_ptr_STRING_to_one_string(dstString , m_str);
|
|
//printf("debug:%s\n",*dstString);
|
|
purge_ptr_type_list_y_ptr_STRING(m_str);
|
|
return ret;
|
|
}
|
|
/* dstString can be NULL ! (it's better)*/
|
|
long int sprint_one_line_js_value(char **dstString, struct js_value *js){
|
|
struct main_list_y_ptr_STRING *m_str=create_var_list_y_ptr_STRING();
|
|
// remove_all_ptr_type_list_y_ptr_STRING(m_str);
|
|
long int ret = sprint_js_value_to_y_string_list(m_str,js,' ', 1);
|
|
copy_list_y_ptr_STRING_to_one_string(dstString , m_str);
|
|
//printf("debug:%s\n",*dstString);
|
|
|
|
purge_ptr_type_list_y_ptr_STRING(m_str);
|
|
return ret;
|
|
}
|
|
|
|
void print_js_value(struct js_value *js){
|
|
if(js->code_type == jstype_number){
|
|
printf("%Lf",js->type.number);
|
|
}else if(js->code_type == jstype_string){
|
|
printf("\"%s\"",js->type.string);
|
|
}else if(js->code_type == jstype_bool){
|
|
printf("%s",js->type.boolean ? "true" : "false");
|
|
}else if(js->code_type == jstype_null){
|
|
printf("%s","null");
|
|
}else if(js->code_type == jstype_object){
|
|
struct js_value *tmpjs = js;
|
|
|
|
while(tmpjs){
|
|
|
|
if(tmpjs->type.object.prev_object == NULL){
|
|
printf("\n%*c{ ",4*(tmpjs->type.object.depth),' ');
|
|
}
|
|
/*
|
|
char key[tmpjs->type.object.key_length + 1];
|
|
strncpy(key, tmpjs->type.object.key, tmpjs->type.object.key_length);
|
|
key[tmpjs->type.object.key_length]='\0';
|
|
printf("\n%*c%s : ", 4*(tmpjs->type.object.depth),' ', key );
|
|
*/
|
|
printf("\n%*c\"%s\" : ", 4*(tmpjs->type.object.depth),' ', tmpjs->type.object.key);
|
|
print_js_value(tmpjs->type.object.value);
|
|
|
|
if(tmpjs->type.object.next_object == NULL)
|
|
printf("\n%*c} ",4*(tmpjs->type.object.depth),' '); //printf(" }");
|
|
else printf(", ");
|
|
//printf("\n");
|
|
tmpjs = tmpjs->type.object.next_object;
|
|
}
|
|
}else if(js->code_type == jstype_array){
|
|
struct js_value *tmpjs = js;
|
|
while(tmpjs){
|
|
if(tmpjs->type.array.prev_element == NULL){
|
|
printf("\n%*c[ ",4*(tmpjs->type.array.depth),' ');
|
|
}
|
|
if(tmpjs->type.array.value->code_type < jstype_object )
|
|
printf("\n%*c ",4*(tmpjs->type.array.depth),' ');
|
|
print_js_value(tmpjs->type.array.value);
|
|
if(tmpjs->type.array.next_element == NULL) //printf(" ]");
|
|
printf("\n%*c] ",4*(tmpjs->type.array.depth),' ');
|
|
else printf(", ");
|
|
tmpjs = tmpjs->type.array.next_element; // next_(tmpjs);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
struct js_value * value_of_(struct js_value * js){
|
|
if(js->code_type == jstype_object){
|
|
return js->type.object.value;
|
|
}
|
|
if(js->code_type == jstype_array){
|
|
return js->type.array.value;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
struct js_value *get_js_value_of_key(char * key, struct js_value *js ){
|
|
if(js->code_type == jstype_object){
|
|
struct js_value *tmp = js;
|
|
while(tmp){
|
|
if(strncmp(key,tmp->type.object.key, tmp->type.object.key_length) == 0){
|
|
js->type.object.iter->current = tmp;
|
|
return tmp; //tmp->type.object.value == value_of_(tmp);
|
|
}
|
|
tmp = tmp->type.object.next_object;//next_(tmp);
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
void delete_key_js_value(char * key, struct js_value **js_org){
|
|
struct js_value *js = get_js_value_of_key(key, *js_org);
|
|
if(js){
|
|
delete_index_js_value(js->type.object.index, js_org);
|
|
}
|
|
}
|
|
|
|
size_t js_org_str_length(struct js_value *js){
|
|
// if string add 2 \" values
|
|
return js->length+1+2*(js->code_type == 0);
|
|
}
|
|
|
|
/*
|
|
void set_value_of_key(char *key, char * value, struct js_value *js ){
|
|
if(js->code_type != jstype_object)
|
|
return;
|
|
struct js_value *valjs = get_js_value_of_key(key, js);
|
|
if(valjs){
|
|
struct js_value *tmp = valjs->type.object.value;
|
|
valjs->type.object.value = create_js_value(value, valjs);
|
|
|
|
free_js_value(tmp);
|
|
}else{
|
|
js->type.object.
|
|
}
|
|
}
|
|
*/
|