static int translate_configs_(yajl_val js_configs) { yajl_val js_connect_timeout = wsn_yajl_tree_get(js_configs, "connect-timeout", yajl_t_number); if (js_connect_timeout) { all_configs_.connect_timeout = YAJL_GET_INTEGER(js_connect_timeout); } yajl_val js_idle_timeout = wsn_yajl_tree_get(js_configs, "idle-timeout", yajl_t_number); if (js_idle_timeout) { all_configs_.idle_timeout = YAJL_GET_INTEGER(js_idle_timeout); } all_configs_.servers_conf = wsn_nodes_conf_find(WSN_NODE_TYPE_SERVER, &all_configs_.server_count, js_configs); if (all_configs_.servers_conf == NULL && wsn_last_err() != WSN_ERR_MISSING_CONF_ITEM) { return wsn_last_err(); } all_configs_.clients_conf = wsn_nodes_conf_find(WSN_NODE_TYPE_CLIENT, &all_configs_.client_count, js_configs); if (all_configs_.servers_conf == NULL && wsn_last_err() != WSN_ERR_MISSING_CONF_ITEM) { return wsn_last_err(); } if (all_configs_.servers_conf == NULL && all_configs_.clients_conf == NULL) { wsn_report_err(WSN_ERR_MISSING_CONF_ITEM, "Invalid config file, no node config was found"); return WSN_ERR_MISSING_CONF_ITEM; } return 0; }
void FontLoadFromJSON(Font *f, const char *imgPath, const char *jsonPath) { yajl_val node = YAJLReadFile(jsonPath); if (node == NULL) { fprintf(stderr, "Error parsing font JSON '%s'\n", jsonPath); goto bail; } memset(f, 0, sizeof *f); // Load definitions from JSON data YAJLVec2i(&f->Size, node, "Size"); YAJLInt(&f->Stride, node, "Stride"); // Padding order is: left/top/right/bottom const yajl_val paddingNode = YAJLFindNode(node, "Padding"); f->Padding.Left = (int)YAJL_GET_INTEGER(YAJL_GET_ARRAY(paddingNode)->values[0]); f->Padding.Top = (int)YAJL_GET_INTEGER(YAJL_GET_ARRAY(paddingNode)->values[1]); f->Padding.Right = (int)YAJL_GET_INTEGER(YAJL_GET_ARRAY(paddingNode)->values[2]); f->Padding.Bottom = (int)YAJL_GET_INTEGER(YAJL_GET_ARRAY(paddingNode)->values[3]); YAJLVec2i(&f->Gap, node, "Gap"); bool proportional = false; YAJLBool(&proportional, node, "Proportional"); FontLoad(f, imgPath, proportional); bail: yajl_tree_free(node); }
void YAJLVec2i(Vec2i *value, yajl_val node, const char *name) { if (!YAJLTryLoadValue(&node, name) || !YAJL_IS_ARRAY(node)) { return; } value->x = (int)YAJL_GET_INTEGER(YAJL_GET_ARRAY(node)->values[0]); value->y = (int)YAJL_GET_INTEGER(YAJL_GET_ARRAY(node)->values[1]); }
const webhdfs_fstat_t *webhdfs_dir_read (webhdfs_dir_t *dir) { const char *path[] = {"pathSuffix", NULL}; const char *replication[] = {"replication", NULL}; const char *permission[] = {"permission", NULL}; const char *length[] = {"length", NULL}; const char *group[] = {"group", NULL}; const char *owner[] = {"owner", NULL}; const char *type[] = {"type", NULL}; const char *mtime[] = {"modificationTime", NULL}; const char *block[] = {"blockSize", NULL}; const char *atime[] = {"accessTime", NULL}; yajl_val node, v; if (dir->current >= YAJL_GET_ARRAY(dir->statuses)->len) return(NULL); node = YAJL_GET_ARRAY(dir->statuses)->values[dir->current]; dir->current++; if ((v = yajl_tree_get(node, atime, yajl_t_number))) dir->stat.atime = YAJL_GET_INTEGER(v); if ((v = yajl_tree_get(node, mtime, yajl_t_number))) dir->stat.mtime = YAJL_GET_INTEGER(v); if ((v = yajl_tree_get(node, length, yajl_t_number))) dir->stat.length = YAJL_GET_INTEGER(v); if ((v = yajl_tree_get(node, block, yajl_t_number))) dir->stat.block = YAJL_GET_INTEGER(v); if ((v = yajl_tree_get(node, replication, yajl_t_number))) dir->stat.replication = YAJL_GET_INTEGER(v); if ((v = yajl_tree_get(node, permission, yajl_t_string))) dir->stat.permission = strtol(YAJL_GET_STRING(v), NULL, 8); if ((v = yajl_tree_get(node, path, yajl_t_string))) dir->stat.path = YAJL_GET_STRING(v); if ((v = yajl_tree_get(node, group, yajl_t_string))) dir->stat.group = YAJL_GET_STRING(v); if ((v = yajl_tree_get(node, owner, yajl_t_string))) dir->stat.owner = YAJL_GET_STRING(v); if ((v = yajl_tree_get(node, type, yajl_t_string))) dir->stat.type = YAJL_GET_STRING(v); return(&(dir->stat)); }
static rc_ReturnCode_t send_reg_payload(const char *payload, size_t payloadLen, int *regId) { rc_ReturnCode_t res; char *rpayload = NULL, *respPayload = NULL; uint32_t respPayloadLen; yajl_val yval = NULL; res = emp_send_and_wait_response(EMP_REGISTERSMSLISTENER, 0, payload, payloadLen, &respPayload, &respPayloadLen); if (res != RC_OK) goto quit; rpayload = strndup(respPayload, respPayloadLen); if (rpayload == NULL) { res = RC_NO_MEMORY; goto quit; } YAJL_TREE_PARSE(yval, rpayload); if (yval->type != yajl_t_number) { SWI_LOG("SMS", ERROR, "Invalid regId type received from RA, got type=%u, expected %u\n", __FUNCTION__, yval->type, yajl_t_number); res = RC_BAD_PARAMETER; goto quit; } *regId = YAJL_GET_INTEGER(yval); quit: yajl_tree_free(yval); free(respPayload); free(rpayload); return res; }
void YAJLInt(int *value, yajl_val node, const char *name) { if (!YAJLTryLoadValue(&node, name) || !YAJL_IS_INTEGER(node)) { return; } *value = (int)YAJL_GET_INTEGER(node); }
yajl_gen_status GenVal(yajl_gen g, yajl_val v) { yajl_gen_status status; switch (v->type) { case yajl_t_string: return yajl_gen_string(g, (unsigned char*)v->u.string, strlen(v->u.string)); case yajl_t_number: { char buffer[100]; char *num = buffer; size_t len; //if (YAJL_IS_INTEGER(v)) // buggy if (v->u.number.flags & YAJL_NUMBER_INT_VALID) len = sprintf(num, "%lld", YAJL_GET_INTEGER(v)); //else if (YAJL_IS_DOUBLE(v)) // buggy else if (v->u.number.flags & YAJL_NUMBER_DOUBLE_VALID) len = sprintf(num, "%g", YAJL_GET_DOUBLE(v)); else { num = YAJL_GET_NUMBER(v); len = strlen(buffer); } return yajl_gen_number(g, num, len); } case yajl_t_object: status = yajl_gen_map_open(g); if (status != yajl_gen_status_ok) return status; for (size_t i = 0; i < v->u.object.len; i++) { status = yajl_gen_string(g, (unsigned char *)v->u.object.keys[i], strlen(v->u.object.keys[i])); if (status != yajl_gen_status_ok) return status; status = GenVal(g, v->u.object.values[i]); if (status != yajl_gen_status_ok) return status; } return yajl_gen_map_close(g); case yajl_t_array: status = yajl_gen_array_open(g); if (status != yajl_gen_status_ok) return status; for (size_t i = 0; i < v->u.array.len; i++) { status = GenVal(g, v->u.array.values[i]); if (status != yajl_gen_status_ok) return status; } return yajl_gen_array_close(g); case yajl_t_true: return yajl_gen_bool(g, 1); case yajl_t_false: return yajl_gen_bool(g, 0); case yajl_t_null: return yajl_gen_null(g); case yajl_t_any: break; } return yajl_gen_in_error_state; }
static rc_ReturnCode_t newSmsHdlr(uint32_t payloadsize, char* payload) { int regId; rc_ReturnCode_t res = RC_OK; cb_list_t *entry; char *sender, *message, *jsonPayload; yajl_val yval; jsonPayload = malloc(payloadsize + 1); memcpy(jsonPayload, payload, payloadsize); jsonPayload[payloadsize] = '\0'; YAJL_TREE_PARSE(yval, jsonPayload); if (yval->u.array.values[0]->type != yajl_t_string) { SWI_LOG("SMS", ERROR, "%s: sender is not an string, got type=%d\n", __FUNCTION__, yval->u.array.values[0]->type); res = RC_BAD_PARAMETER; goto quit; } sender = YAJL_GET_STRING(yval->u.array.values[0]); if (yval->u.array.values[1]->type != yajl_t_string) { SWI_LOG("SMS", ERROR, "%s: message is not an string, got type=%d\n", __FUNCTION__, yval->u.array.values[1]->type); res = RC_BAD_PARAMETER; goto quit; } message = YAJL_GET_STRING(yval->u.array.values[1]); if (yval->u.array.values[2]->type != yajl_t_number) { SWI_LOG("SMS", ERROR, "%s: regId is not an number, got type=%d\n", __FUNCTION__, yval->u.array.values[2]->type); res = RC_BAD_PARAMETER; goto quit; } regId = YAJL_GET_INTEGER(yval->u.array.values[2]); pthread_mutex_lock(&handler_lock); for (entry = cb_list; entry; entry = entry->next) { if (entry->regId == regId) { entry->cb(sender, message); break; } } pthread_mutex_unlock(&handler_lock); quit: free(jsonPayload); emp_freemessage(payload); yajl_tree_free(yval); return res; }
/* Add YAJL value into YAJL generator handle (JSON object) * * jgen - YAJL generator handle allocated by yajl_gen_alloc() * jval - YAJL value usually returned by yajl_tree_get() */ static yajl_gen_status ovs_yajl_gen_val(yajl_gen jgen, yajl_val jval) { size_t array_len = 0; yajl_val *jvalues = NULL; yajl_val jobj_value = NULL; const char *obj_key = NULL; size_t obj_len = 0; yajl_gen_status yajl_gen_ret = yajl_gen_status_ok; if (jval == NULL) return yajl_gen_generation_complete; if (YAJL_IS_STRING(jval)) OVS_YAJL_CALL(ovs_yajl_gen_tstring, jgen, YAJL_GET_STRING(jval)); else if (YAJL_IS_DOUBLE(jval)) OVS_YAJL_CALL(yajl_gen_double, jgen, YAJL_GET_DOUBLE(jval)); else if (YAJL_IS_INTEGER(jval)) OVS_YAJL_CALL(yajl_gen_double, jgen, YAJL_GET_INTEGER(jval)); else if (YAJL_IS_TRUE(jval)) OVS_YAJL_CALL(yajl_gen_bool, jgen, 1); else if (YAJL_IS_FALSE(jval)) OVS_YAJL_CALL(yajl_gen_bool, jgen, 0); else if (YAJL_IS_NULL(jval)) OVS_YAJL_CALL(yajl_gen_null, jgen); else if (YAJL_IS_ARRAY(jval)) { /* create new array and add all elements into the array */ array_len = YAJL_GET_ARRAY(jval)->len; jvalues = YAJL_GET_ARRAY(jval)->values; OVS_YAJL_CALL(yajl_gen_array_open, jgen); for (size_t i = 0; i < array_len; i++) OVS_YAJL_CALL(ovs_yajl_gen_val, jgen, jvalues[i]); OVS_YAJL_CALL(yajl_gen_array_close, jgen); } else if (YAJL_IS_OBJECT(jval)) { /* create new object and add all elements into the object */ OVS_YAJL_CALL(yajl_gen_map_open, jgen); obj_len = YAJL_GET_OBJECT(jval)->len; for (size_t i = 0; i < obj_len; i++) { obj_key = YAJL_GET_OBJECT(jval)->keys[i]; jobj_value = YAJL_GET_OBJECT(jval)->values[i]; OVS_YAJL_CALL(ovs_yajl_gen_tstring, jgen, obj_key); OVS_YAJL_CALL(ovs_yajl_gen_val, jgen, jobj_value); } OVS_YAJL_CALL(yajl_gen_map_close, jgen); } else { OVS_ERROR("%s() unsupported value type %d (skip)", __FUNCTION__, (int)(jval)->type); goto yajl_gen_failure; } return yajl_gen_status_ok; yajl_gen_failure: OVS_ERROR("%s() error to generate value", __FUNCTION__); return yajl_gen_ret; }
void bson_from_json_type(bson *b, yajl_val value, const char* key) { if( YAJL_IS_STRING( value ) ) { char* string = YAJL_GET_STRING( value ); bson_append_string( b, key, string ); } else if( YAJL_IS_NUMBER( value ) ) { char* string = value->u.number.r; size_t len = strlen( string ); // Hack to detect a double, since 'flags' is always set to double. if( memchr( string, '.', len ) || memchr( string, 'e', len ) || memchr( string, 'E', len ) ) { double number = YAJL_GET_DOUBLE( value ); bson_append_double( b, key, number ); } else { uint64_t number = YAJL_GET_INTEGER( value ); if( number <= INT_MIN && number <= INT_MAX) bson_append_int( b, key, (int)number ); else bson_append_long( b, key, number); } } else if ( YAJL_IS_FALSE( value ) ) { bson_append_bool( b, key, 0 ); } else if ( YAJL_IS_TRUE( value ) ) { bson_append_bool( b, key, 1 ); } else if ( YAJL_IS_ARRAY( value ) ) { bson_append_start_array( b, key ); bson_from_json_array( b, value ); bson_append_finish_array( b ); } else if ( YAJL_IS_OBJECT( value ) ) { bson_append_start_object( b, key ); bson_from_json_object( b, value ); bson_append_finish_object( b ); } }
SEXP ParseValue(yajl_val node, int bigint){ if(YAJL_IS_NULL(node)){ return R_NilValue; } if(YAJL_IS_STRING(node)){ SEXP tmp = PROTECT(allocVector(STRSXP, 1)); SET_STRING_ELT(tmp, 0, mkCharCE(YAJL_GET_STRING(node), CE_UTF8)); UNPROTECT(1); return tmp; } if(YAJL_IS_INTEGER(node)){ long long int val = YAJL_GET_INTEGER(node); /* 2^53 is highest int stored as double without loss */ if(bigint && (val > 9007199254740992 || val < -9007199254740992)){ char buf[32]; #ifdef _WIN32 snprintf(buf, 32, "%I64d", val); #else snprintf(buf, 32, "%lld", val); #endif return mkString(buf); /* see .Machine$integer.max in R */ } else if(val > 2147483647 || val < -2147483647){ return ScalarReal(val); } else { return ScalarInteger(val); } } if(YAJL_IS_DOUBLE(node)){ return(ScalarReal(YAJL_GET_DOUBLE(node))); } if(YAJL_IS_NUMBER(node)){ /* A number that is not int or double (very rare) */ /* This seems to correctly round to Inf/0/-Inf */ return(ScalarReal(YAJL_GET_DOUBLE(node))); } if(YAJL_IS_TRUE(node)){ return(ScalarLogical(1)); } if(YAJL_IS_FALSE(node)){ return(ScalarLogical(0)); } if(YAJL_IS_OBJECT(node)){ return(ParseObject(node, bigint)); } if(YAJL_IS_ARRAY(node)){ return(ParseArray(node, bigint)); } error("Invalid YAJL node type."); }
bool JSONParser::find(const std::string& key, int& value) { VALIDATE_STATE(); bool result = false; if (mState->mTree) { const char* path[2] = { key.c_str(), NULL }; yajl_val num = yajl_tree_get(mState->mTree, path, yajl_t_number); if (YAJL_IS_INTEGER(num)) { result = true; value = (int)YAJL_GET_INTEGER(num); } } return result; }
void message_json_handler_function(yajl_val j, void *context) { state *s = context; // LLog("[message_json_handler_function] will read value type\n"); // LLog("[message_json_handler_function] value is %d\n", (unsigned int)j); // LLog("[message_json_handler_function] value type is %d\n", j->type); if (!YAJL_IS_OBJECT(j)) { LLog("[message_json_handler_function] value was not an object, bailing out\n"); return; } int num_vals = YAJL_GET_OBJECT(j)->len; for (int i = 0; i < num_vals; i++) { const char *name = YAJL_GET_OBJECT(j)->keys[i]; //LLog("[message_json_handler_function] did get name = %s\n", name); yajl_val value = YAJL_GET_OBJECT(j)->values[i]; if (YAJL_IS_INTEGER(value)) { //LLog("[message_json_handler_function] value is integer\n"); state_set_int(s, name, YAJL_GET_INTEGER(value)); } else if (YAJL_IS_DOUBLE(value)) { //LLog("[message_json_handler_function] value is double\n"); state_set_float(s, name, (float)YAJL_GET_DOUBLE(value)); } else if (YAJL_IS_TRUE(value)) { //LLog("[message_json_handler_function] value is true\n"); state_set_int(s, name, 1); } else if (YAJL_IS_FALSE(value)) { //LLog("[message_json_handler_function] value is false\n"); state_set_int(s, name, 0); } else { //LLog("[message_json_handler_function] value is complex\n"); state_set_json(s, name, value); } } }
webhdfs_fstat_t *webhdfs_stat (webhdfs_t *fs, const char *path, char **error) { const char *pathSuffix[] = {"pathSuffix", NULL}; const char *replication[] = {"replication", NULL}; const char *permission[] = {"permission", NULL}; const char *length[] = {"length", NULL}; const char *group[] = {"group", NULL}; const char *owner[] = {"owner", NULL}; const char *type[] = {"type", NULL}; const char *mtime[] = {"modificationTime", NULL}; const char *block[] = {"blockSize", NULL}; const char *atime[] = {"accessTime", NULL}; yajl_val root, node, v; webhdfs_fstat_t *stat; webhdfs_req_t req; webhdfs_req_open(&req, fs, path); webhdfs_req_set_args(&req, "op=GETFILESTATUS"); char *error2 = NULL; int ret = -1; if ((ret = webhdfs_req_exec(&req, WEBHDFS_REQ_GET, &error2)) != 0) { *error = __strdup(error2); free(error2); webhdfs_req_close(&req); return(NULL); } root = webhdfs_req_json_response(&req); webhdfs_req_close(&req); if ((v = webhdfs_response_exception(root)) != NULL) { // const char *exceptionNode[] = {"exception", NULL}; // yajl_val exception = yajl_tree_get(v, exceptionNode , yajl_t_string); // YAJL_GET_STRING(exception); const char *messageNode[] = {"message", NULL}; yajl_val message = yajl_tree_get(v, messageNode, yajl_t_string); *error = __strdup(YAJL_GET_STRING(message)); yajl_tree_free(root); return(NULL); } if ((node = webhdfs_response_file_status(root)) == NULL) { yajl_tree_free(root); return(NULL); } if ((stat = (webhdfs_fstat_t *) malloc(sizeof(webhdfs_fstat_t))) == NULL) { yajl_tree_free(root); return(NULL); } memset(stat, 0, sizeof(webhdfs_fstat_t)); if ((v = yajl_tree_get(node, atime, yajl_t_number))) stat->atime = YAJL_GET_INTEGER(v); if ((v = yajl_tree_get(node, mtime, yajl_t_number))) stat->mtime = YAJL_GET_INTEGER(v); if ((v = yajl_tree_get(node, length, yajl_t_number))) stat->length = YAJL_GET_INTEGER(v); if ((v = yajl_tree_get(node, block, yajl_t_number))) stat->block = YAJL_GET_INTEGER(v); if ((v = yajl_tree_get(node, replication, yajl_t_number))) stat->replication = YAJL_GET_INTEGER(v); if ((v = yajl_tree_get(node, permission, yajl_t_string))) stat->permission = strtol(YAJL_GET_STRING(v), NULL, 8); if ((v = yajl_tree_get(node, pathSuffix, yajl_t_string))) stat->path = __strdup(YAJL_GET_STRING(v)); if ((v = yajl_tree_get(node, group, yajl_t_string))) stat->group = __strdup(YAJL_GET_STRING(v)); if ((v = yajl_tree_get(node, owner, yajl_t_string))) stat->owner = __strdup(YAJL_GET_STRING(v)); if ((v = yajl_tree_get(node, type, yajl_t_string))) stat->type = __strdup(YAJL_GET_STRING(v)); yajl_tree_free(root); return(stat); }
Map * LoadMap(char * map_info){ yajl_val node; char errbuf[1024]; short x,y; short i; Map * map = (Map *) malloc(sizeof(Map)); //logger("Parsing packet from JSON message"); node = yajl_tree_parse(( char *) map_info, errbuf, sizeof(errbuf)); if (node == NULL) { fprintf(stderr,"parse_error: "); if (strlen(errbuf)){ fprintf(stderr," %s", errbuf); }else{ fprintf(stderr,"unknown error"); } fprintf(stderr,"\n"); return false; } const char * path[] = { "map_id", ( char *) 0 }; map->area_id = YAJL_GET_INTEGER(yajl_tree_get(node, path, yajl_t_number)); path[0] = "cell_size"; map->cell_size = YAJL_GET_INTEGER(yajl_tree_get(node, path, yajl_t_number)); path[0] = "x_cells"; map->x_cells = YAJL_GET_INTEGER(yajl_tree_get(node, path, yajl_t_number)); path[0] = "y_cells"; map->y_cells = YAJL_GET_INTEGER(yajl_tree_get(node, path, yajl_t_number)); map->cells = (Cell **) malloc(map->x_cells * sizeof(Cell *)); for (x = 0; x < map->x_cells; x++){ map->cells[x] = (Cell *) malloc(map->y_cells * sizeof(Cell)); } path[0] = "cells"; for (x = 0; x < map->x_cells; x++) for (y = 0; y < map->y_cells; y++){ map->cells[x][y].prob_location = 1; map->cells[x][y].transition_cell = true; yajl_val cell = YAJL_GET_ARRAY(YAJL_GET_ARRAY((yajl_tree_get(node,path, yajl_t_array)))->values[x])->values[y]; if (YAJL_IS_NUMBER(cell)){ map->cells[x][y].prob_location = YAJL_GET_INTEGER(YAJL_GET_ARRAY(YAJL_GET_ARRAY((yajl_tree_get(node,path, yajl_t_array)))->values[x])->values[y]); map->cells[x][y].transition_cell = false; }else if (YAJL_IS_NULL(cell)){ map->cells[x][y].transp.area_id = 0; map->cells[x][y].transp.x_cell = 0; map->cells[x][y].transp.y_cell = 0; }else{ for (i = 0; i < YAJL_GET_OBJECT(cell)->len; i++){ if (!strcmp(YAJL_GET_OBJECT(cell)->keys[i], "area_id")) map->cells[x][y].transp.area_id = YAJL_GET_INTEGER(YAJL_GET_OBJECT(cell)->values[i]); else if (!strcmp(YAJL_GET_OBJECT(cell)->keys[i], "x_cell")) map->cells[x][y].transp.x_cell = YAJL_GET_INTEGER(YAJL_GET_OBJECT(cell)->values[i]); else if (!strcmp(YAJL_GET_OBJECT(cell)->keys[i], "y_cell")) map->cells[x][y].transp.y_cell = YAJL_GET_INTEGER(YAJL_GET_OBJECT(cell)->values[i]); } } } return map; }
void* events_thread(void* args) { char input[2048] = {0}; char errbuf[1024] = {0}; char* walker; yajl_val node; yajl_val val; char name[512], instance[512]; int button, x, y; while(fgets(input, sizeof(input), stdin)) { walker = input; if(*walker == '[') walker++; if(*walker == '\0') continue; if(*walker == ',') walker++; node = yajl_tree_parse(walker, errbuf, sizeof(errbuf)); if (node == NULL) { fprintf(stderr, "parse_error: "); if (strlen(errbuf)) fprintf(stderr, " %s", errbuf); else fprintf(stderr, "unknown error"); fprintf(stderr, "\n"); continue; } val = yajl_tree_get(node, events_paths[0], yajl_t_string); if(val && YAJL_IS_STRING(val)) strncpy(name, val->u.string, 512); else name[0] = '\0'; val = yajl_tree_get(node, events_paths[1], yajl_t_string); if(val && YAJL_IS_STRING(val)) strncpy(instance, val->u.string, 512); else instance[0] = '\0'; val = yajl_tree_get(node, events_paths[2], yajl_t_number); button = (val ? YAJL_GET_INTEGER(val) : -1); val = yajl_tree_get(node, events_paths[3], yajl_t_number); x = (val ? YAJL_GET_INTEGER(val) : -1); val = yajl_tree_get(node, events_paths[4], yajl_t_number); y = (val ? YAJL_GET_INTEGER(val) : -1); yajl_tree_free(node); if(strcmp(name, "volume") == 0) { char* mixer = strchr(instance, '.'); if(mixer == NULL) continue; *(mixer++) = '\0'; char* mixer_id = strchr(mixer, '.'); if(mixer_id == NULL) continue; *(mixer_id++) = '\0'; mouse_volume(button, instance, mixer, atoi(mixer_id)); } } return NULL; }
int maina(void) { size_t rd; yajl_val node; char errbuf[1024]; /* null plug buffers */ fileData[0] = errbuf[0] = 0; /* read the entire config file */ rd = fread((void *) fileData, 1, sizeof(fileData) - 1, stdin); /* file read error handling */ if (rd == 0 && !feof(stdin)) { fprintf(stderr, "error encountered on file read\n"); return 1; } else if (rd >= sizeof(fileData) - 1) { fprintf(stderr, "config file too big\n"); return 1; } /* we have the whole config file in memory. let's parse it ... */ node = yajl_tree_parse((const char *) fileData, errbuf, sizeof(errbuf)); /* parse error handling */ if (node == NULL) { fprintf(stderr, "parse_error: "); if (strlen(errbuf)) fprintf(stderr, " %s", errbuf); else fprintf(stderr, "unknown error"); fprintf(stderr, "\n"); return 1; } /* ... and extract a nested value from the config file */ { const char * path[] = { "wallet", (const char *) 0 }; yajl_val v = yajl_tree_get(node, path, yajl_t_array); if(v) { yajl_val *objs = v->u.array.values; int i = 0; for(i; i < v->u.array.len; i++) { if(objs[i]) { /*A complete JSON object*/ char **keys = objs[i]->u.object.keys; /*keys for JSON obj*/ yajl_val *vals = objs[i]->u.object.values; /*values for JSON obj*/ int j=0; for (j; j< objs[i]->u.object.len; j++) { printf("Object key : %s\n", keys[j]); if(YAJL_IS_INTEGER(vals[j])) { printf("Object value : %lli\n", YAJL_GET_INTEGER(vals[j])); }else if(YAJL_IS_DOUBLE(vals[j])) { printf("Object value : %lf\n", YAJL_GET_DOUBLE(vals[j])); } else { printf("Object value : %s\n", YAJL_GET_STRING(vals[j])); } } } } } } yajl_tree_free(node); return 0; }