/* Recursively print a Json-object */
static void json_print (json_t *r)
{
json_t *v;
for (v = r; v != NULL; v = v->next) {
if (v->label) printf ("\"%s\": ", v->label);
switch (v->type) {
case JSON_TYPE_STR:
printf ("\"%s\"", v->val.str);
break;
case JSON_TYPE_OBJECT:
printf ("{ ");
json_print (v->val.obj);
printf (" }");
break;
case JSON_TYPE_ARRAY:
printf ("[ ");
json_print (v->val.obj);
printf (" ]");
break;
case JSON_TYPE_INT:
printf ("%ld", v->val.num);
break;
case JSON_TYPE_DOUBLE:
printf ("%lf", v->val.f);
break;
case JSON_TYPE_EMPTY:
printf ("(empty)");
break;
case JSON_TYPE_FALSE:
printf ("false");
break;
case JSON_TYPE_TRUE:
printf ("true");
break;
case JSON_TYPE_NULL:
printf ("null");
break;
default:
printf ("unhandled type = %d\n", v->type);
break;
}
if (v->next != NULL)
printf (", ");
}
}
int
main (int argc, char **argv)
{
int size;
FILE *f;
char *filename, *jsonstr;
filename = argv[1];
if ((f = fopen (filename, "r")) == NULL) {
fprintf (stderr, "error opening file\n");
return (1);
}
fseek (f, 0, SEEK_END);
size = ftell (f);
fseek (f, 0, SEEK_SET);
if ((jsonstr = malloc (size+1)) == NULL) {
fprintf (stderr, "out of memory\n");
return (1);
}
size = fread (jsonstr, 1, size, f);
jsonstr[size] = 0;
json_print (json_decode (jsonstr));
return (0);
}
static void json_destroy(struct formatter *fmt)
{
struct json_formatter_data *priv = fmt->priv;
yajl_gen_array_close(priv->yajl);
json_print(fmt->f, priv->yajl);
yajl_gen_free(priv->yajl);
}
int main(int argc, char* argv[]) {
(void) argc;
(void) argv;
char* string =
"{ "
"\"sitename\": "
"\"joys of programming\", "
"\"categories\": "
"[ \"c\", [ \"c++\", \"c\" ], \"java\", \"PHP\" ], "
"\"author-details\": "
"{ \"admin\": false, \"name\": \"Joys of Programming\", \"Number of Posts\": 10 }"
" }";
printf("input: %s\n", string);
json_object* jobj = json_tokener_parse(string);
printf("jobj: %s\n", json_object_to_json_string(jobj));
json_print(jobj, 0);
json_object_put(jobj);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
JSONNode *root = json_loads_from_data(JSON);
if (root == NULL) {
printf("invalid format!\n");
return -1;
}
json_print(root, 0);
json_node_free(root);
return 0;
}
int
main (int argc, char **argv)
{
struct json *arr;
arr = json_make_arr ();
add_bday (arr, "atwbday.json");
add_bday (arr, "epwbday.json");
add_bday (arr, "werbday.json");
add_bday (arr, "pacebday.json");
json_print (arr);
return (0);
}
int main(int argc,char *argv[])
{
FILE *f=fopen(argv[1],"r");
// Parse XML file
struct foo *b=(struct foo *)xml_parse(f,"root",&myschema,metafind(&myschema, "foo"),1);
struct item *i;
// Access values in foo
printf("root->val = %d\n",b->val);
printf("root->val_name = %s\n",b->val_name);
printf("root->items->val = %d\n",b->items->val);
printf("root->items->next->val = %d\n",b->items->next->val);
printf("root->items->next->next->val = %d\n",b->items->next->next->val);
// Print in various formats
xml_print(stdout,"root",0,(struct base *)b);
lisp_print(stdout,"root",0,(struct base *)b);
lisp_print_untagged(stdout,"root",0,(struct base *)b);
indent_print(stdout,"root",0,(struct base *)b);
indent_print_untagged(stdout,"root",0,(struct base *)b);
json_print(stdout,NULL,0,(struct base *)b,0);
// Create a database within C
b=mk(&myschema, "foo");
b->val=10;
b->val_name=strdup("Hello");
// Build list
i=b->items=mk(&myschema, "item");
i->val=7;
i=i->next=mk(&myschema, "item");
i->val=8;
i=i->next=mk(&myschema, "item");
i->val=9;
// Print it
xml_print(stdout,"root",0,(struct base *)b);
return 0;
}
static int json_format(struct formatter *fmt, struct recordset *rset)
{
struct record *r;
struct json_formatter_data *priv = fmt->priv;
yajl_gen_map_open(priv->yajl);
int repeat = 0;
for_each_record(r, rset) {
if(r->type != RECORD_TYPE_RSET || !repeat)
yajl_gen_string(priv->yajl, (unsigned char*)r->name, r->len_n-1);
if(r->type != RECORD_TYPE_RSET) {
if(repeat) yajl_gen_array_close(priv->yajl);
repeat = 0;
}
switch(r->type) {
case RECORD_TYPE_STRING:
yajl_gen_string(priv->yajl, (unsigned char*)r->value_str, r->len_v-1);
break;
case RECORD_TYPE_INT:
yajl_gen_integer(priv->yajl, r->value_int);
break;
case RECORD_TYPE_UINT:
case RECORD_TYPE_HEX:
yajl_gen_integer(priv->yajl, r->value_uint);
break;
case RECORD_TYPE_DOUBLE:
yajl_gen_double(priv->yajl, r->value_double);
break;
case RECORD_TYPE_RSET:
if(!repeat) yajl_gen_array_open(priv->yajl);
json_format(fmt, r->value_rset);
repeat = 1;
break;
default:
break;
}
}
if(repeat) yajl_gen_array_close(priv->yajl);
yajl_gen_map_close(priv->yajl);
json_print(fmt->f, priv->yajl);
return 0;
}
__USE_LIBASN
int main(int argc, char *argv[])
{
char buf[BUFSIZ];
mmatic *mm = mmatic_create();
xstr *xs = xstr_create("", mm);
json *js = json_create(mm);
while (fgets(buf, BUFSIZ, stdin))
xstr_append(xs, buf);
ut *parsed = json_parse(js, xstr_string(xs));
if (ut_ok(parsed))
printf("%s", json_print(js, parsed));
else
printf("%s\n", ut_err(parsed));
return 0;
}
static void test_json (const char *name, const char *s)
{
json_t *root;
char *txt;
printf ("Test: %s\n", name);
txt = strdup (s);
root = json_from_string (txt, NULL);
if (!root) {
fprintf (stderr, "Parse failed\n");
return;
}
json_print (root);
printf ("\n");
json_free (root);
free (txt);
}
int main()
{
JSON_Object root;
JSON_Array arr;
JSON_String *str;
json_object_init(&root);
json_object_set(&root, "a", json_string_new("str123"));
//json_object_debug_hash(&root);
json_object_set(&root, "b", json_number_new(123));
//json_object_debug_hash(&root);
json_array_init(&arr);
json_array_append(&arr, json_boolean_true());
json_array_append(&arr, json_boolean_true());
json_array_append(&arr, json_boolean_false());
json_array_append(&arr, json_null());
json_object_set(&root, "c", &arr);
//json_object_debug_hash(&root);
str = json_value_to_string(&root, 0);
json_value_unref(&root);
json_print(json_string_cstr(str));
json_value_unref(str);
#if 0
# define print_size(T) printf("Size of '" #T "': %lu\n", sizeof(T))
printf("==================================\n");
print_size(JSON_Value);
print_size(JSON_Null);
print_size(JSON_Boolean);
print_size(JSON_Number);
print_size(JSON_String);
print_size(JSON_Array);
print_size(JSON_Object);
#endif
return 0;
}
static inline void json_print(JSONNode * node, unsigned int tab)
{
const char *name = json_node_get_name(node);
if (name == NULL) {
name = "NULL";
}
tab_print(tab);
if (json_node_is_string(node)) {
printf("%s=%s\n", name, json_string_get(node));
} else if (json_node_is_false(node)) {
printf("%s=FALSE\n", name);
} else if (json_node_is_true(node)) {
printf("%s=TRUE\n", name);
} else if (json_node_is_int(node)) {
printf("%s=%ld\n", name, json_int_get(node));
} else if (json_node_is_float(node)) {
printf("%s=%g\n", name, json_float_get(node));
} else if (json_node_is_object(node) || json_node_is_array(node)) {
JList *children = json_node_get_children(node);
if (json_node_is_array(node)) {
printf("%s=[\n", name);
} else {
printf("%s={\n", name);
}
while (children) {
JSONNode *child = (JSONNode *) j_list_data(children);
json_print(child, tab + 1);
children = j_list_next(children);
}
tab_print(tab);
if (json_node_is_array(node)) {
printf("]\n");
} else {
printf("}\n");
}
} else {
printf("%s=NULL\n", name);
}
}
int main(void)
{
int i;
int x = 0;
char *line;
while ((line = csvgetline(stdin)) != NULL) {
if (x == 0) {
for (i = 0; i < csvnfield(); i++) {
csvfield(i);
}
printf("{\n");
} else {
json_print(x);
}
if (x == 0) h_count = 1;
x++;
}
printf("\n } \n}\n");
return 0;
}
STATUS save_as_module(char *file_name)
{
char tmp_dir[256];
char conf_dir[256];
char backup_dir[256];
FILE *file;
CONFIG_DATA_T *root;
char *out;
UINT8 module_id;
STATUS ret = OK;
int tmp_fd;
if(file_name ==NULL)
return USR_MODULE_ERR(E_PARAM);
/*file name and dir*/
sprintf(tmp_dir,"%s/%s",CONFI_DIR,"tmp_XXXXXX");
sprintf(conf_dir,"%s/%s",CONFI_DIR,file_name);
sprintf(backup_dir,"%s/%s",CONFI_DIR,".backup");
/*make temp file*/
tmp_fd = mkstemp (tmp_dir);
if(tmp_fd <0)
{
//printf("mkstemp fd :%d\r\n",tmp_fd);
return USR_MODULE_ERR(E_FAIL);
}
root = create_object();
for(module_id=NULL_MODULE;module_id<MODULE_NUM;module_id++)
{
if(usr_module_arr[module_id] ==NULL ||usr_module_arr[module_id]->name ==NULL \
||usr_module_arr[module_id]->module_save ==NULL)
{
continue;
}
//printf("Save %-38s .........",usr_module_arr[module_id]->name);
/*init ALL user init function*/
if(usr_module_arr[module_id]->module_save !=NULL)
ret = (*(usr_module_arr[module_id]->module_save))(root);
//printf("[ %s ] \r\n",ret==OK ? "OK":"fail");
}
out=json_print(root);
json_delete(root);
/*write data to film and close*/
write (tmp_fd, out, strlen(out));
close(tmp_fd);
/*unlink backup file dir*/
unlink (backup_dir);
/*link to config file*/
link (conf_dir, backup_dir);
/*sync data to device iO*/
sync ();
/*unlink config file dir*/
unlink (conf_dir);
/*link to config file*/
if (link (tmp_dir, conf_dir) != 0)
{
/*if link new file fail backup old film*/
link (backup_dir, tmp_dir);
free(out);
unlink (tmp_dir);
return USR_MODULE_ERR(E_FAIL);
}
/*unlink config file dir*/
if (unlink (tmp_dir) != 0)
{
sync ();
free(out);
return USR_MODULE_ERR(E_NORSRC);
}
/*sync data to device iO*/
sync ();
/*change file authority*/
chmod(conf_dir,S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
//file_name = get_running_confing_name();
//rename(tmp_dir,conf_dir);
free(out);
return ret;
}
int test_basic (void)
{
json_t *root;
json_t *o;
json_t *i;
char *str;
const char *s;
int n;
double d;
int boolval;
str = " {\"l1\" : 1111, "
" \"l2\" : {\"l3\": {\"l4\": \"s2\", \"l5\": 2222 } }, "
" \"l6\" : [1,2,3,4,5], "
" \"l7\" : { \"l8\" : \"Hello World\" }, "
" \"float\": 273.93,"
" \"b1\": trUe,"
" \"nil\": nulL,"
" \"b2\": false} \n\t";
str = strdup (str);
root = json_from_string (str, NULL);
assert (root);
n = json_get_int (root, "l1", NULL);
assert (n == 1111);
d = json_get_double (root, "float", NULL);
assert (d == 273.93);
i = json_get_array (root, "l6", NULL);
assert (i->type == JSON_TYPE_ARRAY);
i = json_get_first (i);
for (n = 0; i; n++, i = i->next) {
int data[] = {1,2,3,4,5};
assert (i->type == JSON_TYPE_INT);
assert (i->val.num == data[n]);
}
o = json_get (root, "nil", NULL);
assert (o->type == JSON_TYPE_NULL);
o = json_get (root, "b1", NULL);
assert (o->type == JSON_TYPE_TRUE);
o = json_get (root, "b2", NULL);
assert (o->type == JSON_TYPE_FALSE);
boolval = json_get_bool (root, "b1", NULL);
assert (boolval == 1);
boolval = json_get_bool (root, "b2", NULL);
assert (boolval == 0);
boolval = json_get_bool (root, "nonexisting", NULL);
assert (boolval == -1);
o = json_get_object (root, "l7", NULL);
assert (o);
if (o) {
s = json_get_string (o, "l8", NULL);
printf ("str = %s\n", s);
}
printf ("\n");
json_print (root);
printf ("\n");
json_free (root);
free (str);
return 0;
}
