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 gchar * _j4status_i3bar_output_generate_header(J4statusPluginContext *context) { yajl_gen json_gen; json_gen = yajl_gen_alloc(NULL); yajl_gen_map_open(json_gen); yajl_gen_string(json_gen, (const unsigned char *)"version", strlen("version")); yajl_gen_integer(json_gen, 1); yajl_gen_string(json_gen, (const unsigned char *)"stop_signal", strlen("stop_signal")); yajl_gen_integer(json_gen, SIGUSR2); yajl_gen_string(json_gen, (const unsigned char *)"cont_signal", strlen("cont_signal")); yajl_gen_integer(json_gen, SIGUSR1); if ( ! context->no_click_events ) { yajl_gen_string(json_gen, (const unsigned char *)"click_events", strlen("click_events")); yajl_gen_bool(json_gen, 1); } yajl_gen_map_close(json_gen); const unsigned char *buffer; size_t length; yajl_gen_get_buf(json_gen, &buffer, &length); gchar *header; header = g_strdup_printf("%s\n[[]\n", buffer); yajl_gen_free(json_gen); return header; }
yajl_gen_status yajl_gen_value(yajl_gen gen, VALUE obj) { if (FIXNUM_P(obj)) return yajl_gen_integer(gen, NUM2LONG(obj)); else if (NIL_P(obj) || obj == Qundef) return yajl_gen_null(gen); else if (obj == Qtrue) return yajl_gen_bool(gen, 1); else if (obj == Qfalse) return yajl_gen_bool(gen, 0); else if (SYMBOL_P(obj)) return yajl_gen_format(gen, ":%s", rb_id2name(SYM2ID(obj))); else return yajl_gen_format(gen, "0x%x", obj); }
static int lyajl_gen_boolean (lua_State *L) { int value; luvit_generator_t *generator = generator_get(L, 1); value = lua_toboolean(L, 2); yajl_gen_bool(generator->gen, value); return 0; }
static int js_generator_boolean(lua_State *L) { luaL_checktype(L, 2, LUA_TBOOLEAN); js_generator_assert(L, yajl_gen_bool(*js_check_generator(L, 1), lua_toboolean(L, 2)), __FILE__, __LINE__); return 0; }
static VALUE rb_cFalseClass_ffi_yajl(VALUE self, VALUE rb_yajl_gen, VALUE state) { yajl_gen_status status; struct yajl_gen_t *yajl_gen; Data_Get_Struct(rb_yajl_gen, struct yajl_gen_t, yajl_gen); CHECK_STATUS( yajl_gen_bool(yajl_gen, 0) ); return Qnil; }
/* encode a false value */ VALUE gen_false(VALUE rb_yajl_gen) { yajl_gen_status status; struct yajl_gen_t *yajl_gen; Data_Get_Struct(rb_yajl_gen, struct yajl_gen_t, yajl_gen); if ((status = yajl_gen_bool(yajl_gen, 0)) != yajl_gen_status_ok) { rb_funcall(mEncoder2, rb_intern("raise_error_for_status"), 2, INT2FIX(status), rb_str_new2("false")); } return Qnil; }
int enc_atom(Encoder* enc, ERL_NIF_TERM atom) { int ret = ERROR; char buf[512]; if(!enif_get_atom_compat(enc->env, atom, buf, 512)) { enc->error = enif_make_atom(enc->env, "internal_atom_error"); return ERROR; } if(strncmp(buf, "null", MIN(strlen(buf), 4)) == 0) { if(yajl_gen_null(enc->handle) != yajl_gen_status_ok) goto done; } else if(strncmp(buf, "true", MIN(strlen(buf), 4)) == 0) { if(yajl_gen_bool(enc->handle, 1) != yajl_gen_status_ok) goto done; } else if(strncmp(buf, "false", MIN(strlen(buf), 5)) == 0) { if(yajl_gen_bool(enc->handle, 0) != yajl_gen_status_ok) goto done; } else { if(yajl_gen_string(enc->handle, (unsigned char*) buf, strlen(buf)) != yajl_gen_status_ok) { goto done; } } ret = OK; done: return ret; }
static int reformat_boolean(void* ctx, int boolean) { ccJSONContext* jc = (ccJSONContext*)ctx; bool array = *(jc->flagStack->rbegin()); if(array) { CCJSONArray* p = (CCJSONArray*)(*(jc->objStack->rbegin())); p->addBool(boolean); } else { CCJSONObject* p = (CCJSONObject*)(*(jc->objStack->rbegin())); p->addBool(jc->key, boolean); } return yajl_gen_status_ok == yajl_gen_bool(jc->g, boolean); }
int orderly_write_json2(yajl_gen g, const orderly_json * j) { yajl_gen_status s; int rv = 1; if (j) { if (j->k) yajl_gen_string(g, (const unsigned char *) j->k, strlen(j->k)); switch (j->t) { case orderly_json_none: return 0; case orderly_json_null: s = yajl_gen_null(g); break; case orderly_json_string: s = yajl_gen_string(g, (const unsigned char *) j->v.s, strlen(j->v.s)); break; case orderly_json_boolean: s = yajl_gen_bool(g, j->v.b); break; case orderly_json_integer: s = yajl_gen_integer(g, j->v.i); break; case orderly_json_number: s = yajl_gen_double(g, j->v.n); break; case orderly_json_object: s = yajl_gen_map_open(g); rv = orderly_write_json2(g, j->v.children.first); s = yajl_gen_map_close(g); break; case orderly_json_array: s = yajl_gen_array_open(g); rv = orderly_write_json2(g, j->v.children.first); s = yajl_gen_array_close(g); break; } if (rv && j->next) rv = orderly_write_json2(g, j->next); } return rv; }
static int reformat_boolean(void * ctx, int boolean) { yajl_gen g = (yajl_gen) ctx; yajl_gen_bool(g, boolean); return 1; }
static int reformat_boolean(void * ctx, int boolean) { yajl_gen g = (yajl_gen) ctx; return yajl_gen_status_ok == yajl_gen_bool(g, boolean); }
static void _j4status_i3bar_output_process_section(J4statusPluginContext *context, J4statusSection *section) { const gchar *value; gchar *labelled_value = NULL; value = j4status_section_get_value(section); if ( value == NULL ) { j4status_section_set_cache(section, NULL); return; } yajl_gen json_gen; json_gen = yajl_gen_alloc(NULL); const gchar *label; label = j4status_section_get_label(section); const gchar *label_colour; label_colour = j4status_colour_to_hex(j4status_section_get_label_colour(section)); if ( ( label != NULL ) && ( label_colour != NULL ) ) { gchar *label_with_sep; label_with_sep = g_strdup_printf("%s: ", label); /* * We create a fake section with just the label * so we open an array to have yajl generate a * comma between the two sections */ yajl_gen_array_open(json_gen); yajl_gen_clear(json_gen); /* We need the comma alone */ yajl_gen_map_open(json_gen); yajl_gen_string(json_gen, (const unsigned char *)"color", strlen("color")); yajl_gen_string(json_gen, (const unsigned char *)label_colour, strlen("#000000")); yajl_gen_string(json_gen, (const unsigned char *)"full_text", strlen("full_text")); yajl_gen_string(json_gen, (const unsigned char *)label_with_sep, strlen(label_with_sep)); yajl_gen_string(json_gen, (const unsigned char *)"separator", strlen("separator")); yajl_gen_bool(json_gen, FALSE); yajl_gen_string(json_gen, (const unsigned char *)"separator_block_width", strlen("separator_block_width")); yajl_gen_integer(json_gen, 0); yajl_gen_map_close(json_gen); g_free(label_with_sep); } else if ( label != NULL ) value = labelled_value = g_strdup_printf("%s: %s", label, value); yajl_gen_map_open(json_gen); const gchar *name; name = j4status_section_get_name(section); if ( name != NULL ) { yajl_gen_string(json_gen, (const unsigned char *)"name", strlen("name")); yajl_gen_string(json_gen, (const unsigned char *)name, strlen(name)); } const gchar *instance; instance = j4status_section_get_instance(section); if ( instance != NULL ) { yajl_gen_string(json_gen, (const unsigned char *)"instance", strlen("instance")); yajl_gen_string(json_gen, (const unsigned char *)instance, strlen(instance)); } gint64 max_width; max_width = j4status_section_get_max_width(section); if ( context->align && ( max_width != 0 ) ) { yajl_gen_string(json_gen, (const unsigned char *)"min_width", strlen("min_width")); if ( max_width < 0 ) { gsize l = - max_width + 1; if ( ( label != NULL ) && ( label_colour == NULL ) ) l += strlen(label); gchar max_value[l]; memset(max_value, 'm', l); max_value[l] ='\0'; yajl_gen_string(json_gen, (const unsigned char *)max_value, l); } else yajl_gen_integer(json_gen, max_width); const gchar *align = NULL; switch ( j4status_section_get_align(section) ) { case J4STATUS_ALIGN_LEFT: align = "left"; break; case J4STATUS_ALIGN_RIGHT: align = "right"; break; case J4STATUS_ALIGN_CENTER: break; } if ( align != NULL ) { yajl_gen_string(json_gen, (const unsigned char *)"align", strlen("align")); yajl_gen_string(json_gen, (const unsigned char *)align, strlen(align)); } } J4statusState state = j4status_section_get_state(section); const gchar *colour = NULL; switch ( state & ~J4STATUS_STATE_FLAGS ) { case J4STATUS_STATE_NO_STATE: colour = context->colours.no_state; break; case J4STATUS_STATE_UNAVAILABLE: colour = context->colours.unavailable; break; case J4STATUS_STATE_BAD: colour = context->colours.bad; break; case J4STATUS_STATE_AVERAGE: colour = context->colours.average; break; case J4STATUS_STATE_GOOD: colour = context->colours.good; break; case J4STATUS_STATE_URGENT: break; } if ( state & J4STATUS_STATE_URGENT ) { yajl_gen_string(json_gen, (const unsigned char *)"urgent", strlen("urgent")); yajl_gen_bool(json_gen, TRUE); } const gchar *forced_colour; forced_colour = j4status_colour_to_hex(j4status_section_get_colour(section)); if ( forced_colour != NULL ) colour = forced_colour; if ( colour != NULL ) { yajl_gen_string(json_gen, (const unsigned char *)"color", strlen("color")); yajl_gen_string(json_gen, (const unsigned char *)colour, strlen("#000000")); } const gchar *short_value; short_value = j4status_section_get_short_value(section); if ( short_value != NULL ) { yajl_gen_string(json_gen, (const unsigned char *)"short_text", strlen("short_text")); yajl_gen_string(json_gen, (const unsigned char *)short_value, strlen(short_value)); } yajl_gen_string(json_gen, (const unsigned char *)"full_text", strlen("full_text")); yajl_gen_string(json_gen, (const unsigned char *)value, strlen(value)); g_free(labelled_value); yajl_gen_map_close(json_gen); const unsigned char *buffer; size_t length; yajl_gen_get_buf(json_gen, &buffer, &length); j4status_section_set_cache(section, g_strdup((const gchar *)buffer)); yajl_gen_free(json_gen); }
void obj_dump(VALUE obj, yajl_gen gen) { int type; yajl_gen_map_open(gen); yajl_gen_cstr(gen, "_id"); yajl_gen_value(gen, obj); struct obj_track *tracker = NULL; if (st_lookup(objs, (st_data_t)obj, (st_data_t *)&tracker) && BUILTIN_TYPE(obj) != T_NODE) { yajl_gen_cstr(gen, "file"); yajl_gen_cstr(gen, tracker->source); yajl_gen_cstr(gen, "line"); yajl_gen_integer(gen, tracker->line); } yajl_gen_cstr(gen, "type"); switch (type=BUILTIN_TYPE(obj)) { case T_DATA: yajl_gen_cstr(gen, "data"); if (RBASIC(obj)->klass) { yajl_gen_cstr(gen, "class"); yajl_gen_value(gen, RBASIC(obj)->klass); yajl_gen_cstr(gen, "class_name"); VALUE name = rb_classname(RBASIC(obj)->klass); if (RTEST(name)) yajl_gen_cstr(gen, RSTRING(name)->ptr); else yajl_gen_cstr(gen, 0); } break; case T_FILE: yajl_gen_cstr(gen, "file"); break; case T_FLOAT: yajl_gen_cstr(gen, "float"); yajl_gen_cstr(gen, "data"); yajl_gen_double(gen, RFLOAT(obj)->value); break; case T_BIGNUM: yajl_gen_cstr(gen, "bignum"); yajl_gen_cstr(gen, "negative"); yajl_gen_bool(gen, RBIGNUM(obj)->sign == 0); yajl_gen_cstr(gen, "length"); yajl_gen_integer(gen, RBIGNUM(obj)->len); yajl_gen_cstr(gen, "data"); yajl_gen_string(gen, RBIGNUM(obj)->digits, RBIGNUM(obj)->len); break; case T_MATCH: yajl_gen_cstr(gen, "match"); yajl_gen_cstr(gen, "data"); yajl_gen_value(gen, RMATCH(obj)->str); break; case T_REGEXP: yajl_gen_cstr(gen, "regexp"); yajl_gen_cstr(gen, "length"); yajl_gen_integer(gen, RREGEXP(obj)->len); yajl_gen_cstr(gen, "data"); yajl_gen_cstr(gen, RREGEXP(obj)->str); break; case T_SCOPE: yajl_gen_cstr(gen, "scope"); struct SCOPE *scope = (struct SCOPE *)obj; if (scope->local_tbl) { int i = 1; int n = scope->local_tbl[0]; VALUE *list = &scope->local_vars[-1]; VALUE cur = *list++; yajl_gen_cstr(gen, "node"); yajl_gen_value(gen, cur); if (n) { yajl_gen_cstr(gen, "variables"); yajl_gen_map_open(gen); while (n--) { cur = *list++; yajl_gen_cstr(gen, scope->local_tbl[i] == 95 ? "_" : rb_id2name(scope->local_tbl[i])); yajl_gen_value(gen, cur); i++; } yajl_gen_map_close(gen); } } break; case T_NODE: yajl_gen_cstr(gen, "node"); yajl_gen_cstr(gen, "node_type"); yajl_gen_cstr(gen, nd_type_str(obj)); yajl_gen_cstr(gen, "file"); yajl_gen_cstr(gen, RNODE(obj)->nd_file); yajl_gen_cstr(gen, "line"); yajl_gen_integer(gen, nd_line(obj)); yajl_gen_cstr(gen, "node_code"); yajl_gen_integer(gen, nd_type(obj)); switch (nd_type(obj)) { case NODE_SCOPE: break; } break; case T_STRING: yajl_gen_cstr(gen, "string"); yajl_gen_cstr(gen, "length"); yajl_gen_integer(gen, RSTRING(obj)->len); if (FL_TEST(obj, ELTS_SHARED|FL_USER3)) { yajl_gen_cstr(gen, "shared"); yajl_gen_value(gen, RSTRING(obj)->aux.shared); yajl_gen_cstr(gen, "flags"); yajl_gen_array_open(gen); if (FL_TEST(obj, ELTS_SHARED)) yajl_gen_cstr(gen, "elts_shared"); if (FL_TEST(obj, FL_USER3)) yajl_gen_cstr(gen, "str_assoc"); yajl_gen_array_close(gen); } else { yajl_gen_cstr(gen, "data"); yajl_gen_string(gen, (unsigned char *)RSTRING(obj)->ptr, RSTRING(obj)->len); } break; case T_VARMAP: yajl_gen_cstr(gen, "varmap"); struct RVarmap *vars = (struct RVarmap *)obj; if (vars->next) { yajl_gen_cstr(gen, "next"); yajl_gen_value(gen, (VALUE)vars->next); } if (vars->id) { yajl_gen_cstr(gen, "data"); yajl_gen_map_open(gen); yajl_gen_cstr(gen, rb_id2name(vars->id)); yajl_gen_value(gen, vars->val); yajl_gen_map_close(gen); } break; case T_CLASS: case T_MODULE: case T_ICLASS: yajl_gen_cstr(gen, type==T_CLASS ? "class" : type==T_MODULE ? "module" : "iclass"); yajl_gen_cstr(gen, "name"); VALUE name = rb_classname(obj); if (RTEST(name)) yajl_gen_cstr(gen, RSTRING(name)->ptr); else yajl_gen_cstr(gen, 0); yajl_gen_cstr(gen, "super"); yajl_gen_value(gen, RCLASS(obj)->super); yajl_gen_cstr(gen, "super_name"); VALUE super_name = rb_classname(RCLASS(obj)->super); if (RTEST(super_name)) yajl_gen_cstr(gen, RSTRING(super_name)->ptr); else yajl_gen_cstr(gen, 0); if (FL_TEST(obj, FL_SINGLETON)) { yajl_gen_cstr(gen, "singleton"); yajl_gen_bool(gen, 1); } if (RCLASS(obj)->iv_tbl && RCLASS(obj)->iv_tbl->num_entries) { yajl_gen_cstr(gen, "ivars"); yajl_gen_map_open(gen); st_foreach(RCLASS(obj)->iv_tbl, each_ivar, (st_data_t)gen); yajl_gen_map_close(gen); } if (type != T_ICLASS && RCLASS(obj)->m_tbl && RCLASS(obj)->m_tbl->num_entries) { yajl_gen_cstr(gen, "methods"); yajl_gen_map_open(gen); st_foreach(RCLASS(obj)->m_tbl, each_ivar, (st_data_t)gen); yajl_gen_map_close(gen); } break; case T_OBJECT: yajl_gen_cstr(gen, "object"); yajl_gen_cstr(gen, "class"); yajl_gen_value(gen, RBASIC(obj)->klass); yajl_gen_cstr(gen, "class_name"); yajl_gen_cstr(gen, rb_obj_classname(obj)); struct RClass *klass = RCLASS(obj); if (klass->iv_tbl && klass->iv_tbl->num_entries) { yajl_gen_cstr(gen, "ivars"); yajl_gen_map_open(gen); st_foreach(klass->iv_tbl, each_ivar, (st_data_t)gen); yajl_gen_map_close(gen); } break; case T_ARRAY: yajl_gen_cstr(gen, "array"); struct RArray *ary = RARRAY(obj); yajl_gen_cstr(gen, "length"); yajl_gen_integer(gen, ary->len); if (FL_TEST(obj, ELTS_SHARED)) { yajl_gen_cstr(gen, "shared"); yajl_gen_value(gen, ary->aux.shared); } else if (ary->len) { yajl_gen_cstr(gen, "data"); yajl_gen_array_open(gen); int i; for(i=0; i < ary->len; i++) yajl_gen_value(gen, ary->ptr[i]); yajl_gen_array_close(gen); } break; case T_HASH: yajl_gen_cstr(gen, "hash"); struct RHash *hash = RHASH(obj); yajl_gen_cstr(gen, "length"); if (hash->tbl) yajl_gen_integer(gen, hash->tbl->num_entries); else yajl_gen_integer(gen, 0); yajl_gen_cstr(gen, "default"); yajl_gen_value(gen, hash->ifnone); if (hash->tbl && hash->tbl->num_entries) { yajl_gen_cstr(gen, "data"); //yajl_gen_map_open(gen); yajl_gen_array_open(gen); st_foreach(hash->tbl, each_hash_entry, (st_data_t)gen); yajl_gen_array_close(gen); //yajl_gen_map_close(gen); } break; default: yajl_gen_cstr(gen, "unknown"); } yajl_gen_cstr(gen, "code"); yajl_gen_integer(gen, BUILTIN_TYPE(obj)); yajl_gen_map_close(gen); }
void json_writer::entry_bool(bool b) { yajl_gen_bool(pimpl->gen, b ? 1 : 0); }
int LKStreamTranslator::handle_boolean(void *ctx, int val) { return yajl_gen_bool(static_cast<LKStreamTranslator::ctx_t*>(ctx)->gen, val) == yajl_gen_status_ok; }
void json_from_bson_bool(yajl_gen *g, bson_iterator *it) { bson_bool_t value = bson_iterator_bool( it ); yajl_gen_bool( *g, value ); }
static yajl_gen_status ProcessObject(_YajlEncoder *self, PyObject *object) { yajl_gen handle = (yajl_gen)(self->_generator); yajl_gen_status status = yajl_gen_in_error_state; PyObject *iterator, *item; if (object == Py_None) { return yajl_gen_null(handle); } if (object == Py_True) { return yajl_gen_bool(handle, 1); } if (object == Py_False) { return yajl_gen_bool(handle, 0); } if (PyUnicode_Check(object)) { Py_ssize_t length = PyUnicode_GET_SIZE(object); Py_UNICODE *raw_unicode = PyUnicode_AS_UNICODE(object); /* * Create a buffer with enough space for code-points, preceeding and * following quotes and a null termination character */ char *buffer = (char *)(malloc(sizeof(char) * (1 + length * 6))); unsigned int offset = 0; while (length-- > 0) { Py_UNICODE ch = *raw_unicode++; /* Escape escape characters */ switch (ch) { case '\t': buffer[offset++] = '\\'; buffer[offset++] = 't'; continue; break; case '\n': buffer[offset++] = '\\'; buffer[offset++] = 'n'; continue; break; case '\r': buffer[offset++] = '\\'; buffer[offset++] = 'r'; continue; break; case '\f': buffer[offset++] = '\\'; buffer[offset++] = 'f'; continue; break; case '\b': buffer[offset++] = '\\'; buffer[offset++] = 'b'; continue; break; case '\\': buffer[offset++] = '\\'; buffer[offset++] = '\\'; continue; break; case '\"': buffer[offset++] = '\\'; buffer[offset++] = '\"'; continue; break; default: break; } /* Map 16-bit characters to '\uxxxx' */ if (ch >= 256) { buffer[offset++] = '\\'; buffer[offset++] = 'u'; buffer[offset++] = hexdigit[(ch >> 12) & 0x000F]; buffer[offset++] = hexdigit[(ch >> 8) & 0x000F]; buffer[offset++] = hexdigit[(ch >> 4) & 0x000F]; buffer[offset++] = hexdigit[ch & 0x000F]; continue; } /* Map non-printable US ASCII to '\u00hh' */ if ( (ch < 0x20) || (ch >= 0x7F) ) { buffer[offset++] = '\\'; buffer[offset++] = 'u'; buffer[offset++] = '0'; buffer[offset++] = '0'; buffer[offset++] = hexdigit[(ch >> 4) & 0x0F]; buffer[offset++] = hexdigit[ch & 0x0F]; continue; } /* Handle proper ascii chars */ if ( (ch >= 0x20) && (ch < 0x7F) ) { buffer[offset++] = (char)(ch); continue; } }
static int gen_jansson_value(yajl_gen gen, json_t *value) { json_error_t jerr; const char *str; size_t len; int rc; int type = json_typeof(value); switch(type) { case JSON_OBJECT: yajl_gen_map_open(gen); gen_jansson_object(gen,value); yajl_gen_map_close(gen); break; case JSON_ARRAY: yajl_gen_array_open(gen); gen_jansson_array(gen,value); yajl_gen_array_close(gen); break; case JSON_STRING: rc = json_unpack_ex(value, &jerr, 0, "s%", &str,&len); if(rc != 0) { rdlog(LOG_ERR,"Couldn't extract string: %s",jerr.text); return 0; } yajl_gen_string(gen, (const unsigned char *)str, len); break; case JSON_INTEGER: { json_int_t i = json_integer_value(value); yajl_gen_integer(gen,i); } break; case JSON_REAL: { double d = json_number_value(value); yajl_gen_double(gen,d); } break; case JSON_TRUE: yajl_gen_bool(gen,1); break; case JSON_FALSE: yajl_gen_bool(gen,0); break; case JSON_NULL: yajl_gen_null(gen); break; default: rdlog(LOG_ERR,"Unkown jansson type %d",type); break; }; return 1; }
static yajl_gen_status ProcessObject(_YajlEncoder *self, PyObject *object) { yajl_gen handle = (yajl_gen)(self->_generator); yajl_gen_status status = yajl_gen_in_error_state; PyObject *iterator, *item; unsigned short int decref = 0; if (object == Py_None) { return yajl_gen_null(handle); } if (object == Py_True) { return yajl_gen_bool(handle, 1); } if (object == Py_False) { return yajl_gen_bool(handle, 0); } if (PyUnicode_Check(object)) { object = PyUnicode_AsUTF8String(object); decref = 1; } if (PyString_Check(object)) { const unsigned char *buffer = NULL; Py_ssize_t length; PyString_AsStringAndSize(object, (char **)&buffer, &length); status = yajl_gen_string(handle, buffer, (unsigned int)(length)); if (decref) { Py_XDECREF(object); } return status; } if (PyInt_Check(object)) { return yajl_gen_integer(handle, PyInt_AsLong(object)); } if (PyLong_Check(object)) { return yajl_gen_integer(handle, PyLong_AsLong(object)); } if (PyFloat_Check(object)) { return yajl_gen_double(handle, PyFloat_AsDouble(object)); } if (PyList_Check(object)) { /* * Recurse and handle the list */ iterator = PyObject_GetIter(object); if (iterator == NULL) goto exit; status = yajl_gen_array_open(handle); while ((item = PyIter_Next(iterator))) { status = ProcessObject(self, item); Py_XDECREF(item); } Py_XDECREF(iterator); status = yajl_gen_array_close(handle); return status; } if (PyDict_Check(object)) { PyObject *key, *value; Py_ssize_t position = 0; status = yajl_gen_map_open(handle); while (PyDict_Next(object, &position, &key, &value)) { status = ProcessObject(self, key); status = ProcessObject(self, value); } return yajl_gen_map_close(handle); } exit: return yajl_gen_in_error_state; }
ngx_chain_t * ngx_http_tfs_json_custom_file_info(ngx_http_tfs_json_gen_t *tj_gen, ngx_http_tfs_custom_meta_info_t *meta_info, uint8_t file_type) { size_t size; u_char time_buf[NGX_HTTP_TFS_GMT_TIME_SIZE]; yajl_gen g; uint32_t count; ngx_buf_t *b; ngx_int_t is_file; ngx_uint_t i; ngx_chain_t *cl; ngx_http_tfs_custom_file_t *file; g = tj_gen->gen; size = 0; if (file_type == NGX_HTTP_TFS_CUSTOM_FT_DIR) { yajl_gen_array_open(g); } for(; meta_info; meta_info = meta_info->next) { count = meta_info->file_count; file = meta_info->files; for (i = 0; i < count; i++) { yajl_gen_map_open(g); yajl_gen_string(g, (const unsigned char *) "NAME", 4); yajl_gen_string(g, (const unsigned char *) file[i].file_name.data, file[i].file_name.len); yajl_gen_string(g, (const unsigned char *) "PID", 3); yajl_gen_integer(g, file[i].file_info.pid); yajl_gen_string(g, (const unsigned char *) "ID", 2); yajl_gen_integer(g, file[i].file_info.id); yajl_gen_string(g, (const unsigned char *) "SIZE", 4); yajl_gen_integer(g, file[i].file_info.size); yajl_gen_string(g, (const unsigned char *) "IS_FILE", 7); if (file_type == NGX_HTTP_TFS_CUSTOM_FT_DIR) { is_file = (file[i].file_info.pid >> 63) & 0x01; } else { is_file = 1; } yajl_gen_bool(g, is_file); ngx_http_tfs_time(time_buf, file[i].file_info.create_time); yajl_gen_string(g, (const unsigned char *) "CREATE_TIME", 11); yajl_gen_string(g, time_buf, NGX_HTTP_TFS_GMT_TIME_SIZE); ngx_http_tfs_time(time_buf, file[i].file_info.modify_time); yajl_gen_string(g, (const unsigned char *) "MODIFY_TIME", 11); yajl_gen_string(g, time_buf, NGX_HTTP_TFS_GMT_TIME_SIZE); yajl_gen_string(g, (const unsigned char *) "VER_NO", 6); yajl_gen_integer(g, file[i].file_info.ver_no); yajl_gen_map_close(g); }
static int reformat_boolean(void * ctx, int boolean) { yajl_gen g = (yajl_gen) ctx; GEN_AND_RETURN(yajl_gen_bool(g, boolean)); }
void yajl_encode_part(yajl_gen g, VALUE obj, VALUE io, int write_buffer_size) { size_t len; int idx = 0; VALUE keys, entry, str; const char * cptr; yajl_gen_status status; switch (TYPE(obj)) { case T_HASH: status = yajl_gen_map_open(g); yajl_helper_check_gen_status(status); keys = rb_funcall(obj, intern_keys, 0); for(idx = 0; idx < RARRAY_LEN(keys); idx++) { entry = rb_ary_entry(keys, idx); str = rb_funcall(entry, intern_to_s, 0); /* key must be a string */ /* the key */ yajl_encode_part(g, str, io, write_buffer_size); /* the value */ yajl_encode_part(g, rb_hash_aref(obj, entry), io, write_buffer_size); } status = yajl_gen_map_close(g); yajl_helper_check_gen_status(status); break; case T_ARRAY: status = yajl_gen_array_open(g); yajl_helper_check_gen_status(status); for(idx = 0; idx < RARRAY_LEN(obj); idx++) { yajl_encode_part(g, rb_ary_entry(obj, idx), io, write_buffer_size); } status = yajl_gen_array_close(g); yajl_helper_check_gen_status(status); break; case T_NIL: status = yajl_gen_null(g); yajl_helper_check_gen_status(status); break; case T_TRUE: status = yajl_gen_bool(g, 1); yajl_helper_check_gen_status(status); break; case T_FALSE: status = yajl_gen_bool(g, 0); yajl_helper_check_gen_status(status); break; case T_FIXNUM: case T_FLOAT: case T_BIGNUM: str = rb_funcall(obj, intern_to_s, 0); cptr = RSTRING_PTR(str); len = RSTRING_LEN(str); if (memcmp(cptr, "NaN", 3) == 0 || memcmp(cptr, "Infinity", 8) == 0 || memcmp(cptr, "-Infinity", 9) == 0) { rb_raise(e_encodeError, "'%s' is an invalid number", cptr); } status = yajl_gen_number(g, cptr, len); yajl_helper_check_gen_status(status); break; case T_STRING: cptr = RSTRING_PTR(obj); len = RSTRING_LEN(obj); status = yajl_gen_string(g, (const unsigned char *)cptr, len); yajl_helper_check_gen_status(status); break; default: if (rb_respond_to(obj, intern_to_json)) { str = rb_funcall(obj, intern_to_json, 0); Check_Type(str, T_STRING); cptr = RSTRING_PTR(str); len = RSTRING_LEN(str); status = yajl_gen_number(g, cptr, len); yajl_helper_check_gen_status(status); } else { str = rb_funcall(obj, intern_to_s, 0); Check_Type(str, T_STRING); cptr = RSTRING_PTR(str); len = RSTRING_LEN(str); status = yajl_gen_string(g, (const unsigned char *)cptr, len); yajl_helper_check_gen_status(status); } break; } wankelEncoder_flush(g, io, write_buffer_size); }
static int virJSONValueToStringOne(virJSONValuePtr object, yajl_gen g) { int i; VIR_DEBUG("object=%p type=%d gen=%p", object, object->type, g); switch (object->type) { case VIR_JSON_TYPE_OBJECT: if (yajl_gen_map_open(g) != yajl_gen_status_ok) return -1; for (i = 0; i < object->data.object.npairs ; i++) { if (yajl_gen_string(g, (unsigned char *)object->data.object.pairs[i].key, strlen(object->data.object.pairs[i].key)) != yajl_gen_status_ok) return -1; if (virJSONValueToStringOne(object->data.object.pairs[i].value, g) < 0) return -1; } if (yajl_gen_map_close(g) != yajl_gen_status_ok) return -1; break; case VIR_JSON_TYPE_ARRAY: if (yajl_gen_array_open(g) != yajl_gen_status_ok) return -1; for (i = 0; i < object->data.array.nvalues ; i++) { if (virJSONValueToStringOne(object->data.array.values[i], g) < 0) return -1; } if (yajl_gen_array_close(g) != yajl_gen_status_ok) return -1; break; case VIR_JSON_TYPE_STRING: if (yajl_gen_string(g, (unsigned char *)object->data.string, strlen(object->data.string)) != yajl_gen_status_ok) return -1; break; case VIR_JSON_TYPE_NUMBER: if (yajl_gen_number(g, object->data.number, strlen(object->data.number)) != yajl_gen_status_ok) return -1; break; case VIR_JSON_TYPE_BOOLEAN: if (yajl_gen_bool(g, object->data.boolean) != yajl_gen_status_ok) return -1; break; case VIR_JSON_TYPE_NULL: if (yajl_gen_null(g) != yajl_gen_status_ok) return -1; break; default: return -1; } return 0; }
nx_string_t *nx_logdata_to_json(nx_json_parser_ctx_t *ctx) { const unsigned char *json; size_t jsonlen; yajl_gen gen; nx_logdata_field_t *field; nx_string_t *retval; char *value; gen = yajl_gen_alloc(NULL); yajl_gen_map_open(gen); for ( field = NX_DLIST_FIRST(&(ctx->logdata->fields)); field != NULL; field = NX_DLIST_NEXT(field, link) ) { if ( strcmp(field->key, "raw_event") == 0 ) { continue; } if ( (field->key[0] == '.') || (field->key[0] == '_') ) { continue; } ASSERT(yajl_gen_string(gen, (const unsigned char *) field->key, strlen(field->key)) == yajl_gen_status_ok); if ( field->value->defined == FALSE ) { ASSERT(yajl_gen_null(gen) == yajl_gen_status_ok); } else { switch ( field->value->type ) { case NX_VALUE_TYPE_BOOLEAN: ASSERT(yajl_gen_bool(gen, (int) field->value->boolean) == yajl_gen_status_ok); break; case NX_VALUE_TYPE_INTEGER: ASSERT(yajl_gen_integer(gen, (long long) field->value->integer) == yajl_gen_status_ok); break; case NX_VALUE_TYPE_STRING: ASSERT(yajl_gen_string(gen, (const unsigned char *) field->value->string->buf, field->value->string->len) == yajl_gen_status_ok); break; default: value = nx_value_to_string(field->value); ASSERT(yajl_gen_string(gen, (const unsigned char *) value, strlen(value)) == yajl_gen_status_ok); free(value); break; } } } yajl_gen_map_close(gen); yajl_gen_get_buf(gen, &json, &jsonlen); retval = nx_string_create((const char *) json, (int) jsonlen); yajl_gen_free(gen); return ( retval ); }
void yajl_encode_part(void * wrapper, VALUE obj, VALUE io) { VALUE str, outBuff, otherObj; yajl_encoder_wrapper * w = wrapper; yajl_gen_status status; int idx = 0; const unsigned char * buffer; const char * cptr; unsigned int len; if (io != Qnil || w->on_progress_callback != Qnil) { status = yajl_gen_get_buf(w->encoder, &buffer, &len); if (len >= WRITE_BUFSIZE) { outBuff = rb_str_new((const char *)buffer, len); if (io != Qnil) { rb_io_write(io, outBuff); } else if (w->on_progress_callback != Qnil) { rb_funcall(w->on_progress_callback, intern_call, 1, outBuff); } yajl_gen_clear(w->encoder); } } switch (TYPE(obj)) { case T_HASH: status = yajl_gen_map_open(w->encoder); /* TODO: itterate through keys in the hash */ VALUE keys = rb_funcall(obj, intern_keys, 0); VALUE entry, keyStr; for(idx=0; idx<RARRAY_LEN(keys); idx++) { entry = rb_ary_entry(keys, idx); keyStr = rb_funcall(entry, intern_to_s, 0); /* key must be a string */ /* the key */ yajl_encode_part(w, keyStr, io); /* the value */ yajl_encode_part(w, rb_hash_aref(obj, entry), io); } status = yajl_gen_map_close(w->encoder); break; case T_ARRAY: status = yajl_gen_array_open(w->encoder); for(idx=0; idx<RARRAY_LEN(obj); idx++) { otherObj = rb_ary_entry(obj, idx); yajl_encode_part(w, otherObj, io); } status = yajl_gen_array_close(w->encoder); break; case T_NIL: status = yajl_gen_null(w->encoder); break; case T_TRUE: status = yajl_gen_bool(w->encoder, 1); break; case T_FALSE: status = yajl_gen_bool(w->encoder, 0); break; case T_FIXNUM: case T_FLOAT: case T_BIGNUM: str = rb_funcall(obj, intern_to_s, 0); cptr = RSTRING_PTR(str); len = RSTRING_LEN(str); if (memcmp(cptr, "NaN", 3) == 0 || memcmp(cptr, "Infinity", 8) == 0 || memcmp(cptr, "-Infinity", 9) == 0) { rb_raise(cEncodeError, "'%s' is an invalid number", cptr); } status = yajl_gen_number(w->encoder, cptr, len); break; case T_STRING: cptr = RSTRING_PTR(obj); len = RSTRING_LEN(obj); status = yajl_gen_string(w->encoder, (const unsigned char *)cptr, len); break; default: if (rb_respond_to(obj, intern_to_json)) { str = rb_funcall(obj, intern_to_json, 0); cptr = RSTRING_PTR(str); len = RSTRING_LEN(str); status = yajl_gen_number(w->encoder, cptr, len); } else { str = rb_funcall(obj, intern_to_s, 0); cptr = RSTRING_PTR(str); len = RSTRING_LEN(str); status = yajl_gen_string(w->encoder, (const unsigned char *)cptr, len); } break; } }
static bool element(mpack_reader_t* reader, yajl_gen gen, options_t* options, int depth) { const mpack_tag_t tag = mpack_read_tag(reader); if (mpack_reader_error(reader) != mpack_ok) return false; if (!options->debug && depth == 0 && (tag.type != mpack_type_map && tag.type != mpack_type_array)) { fprintf(stderr, "%s: Top-level object must be a map or array. Try debug viewing mode (-d)\n", options->command); return false; } // TODO check not depth zero switch (tag.type) { case mpack_type_bool: return yajl_gen_bool(gen, tag.v.b) == yajl_gen_status_ok; case mpack_type_nil: return yajl_gen_null(gen) == yajl_gen_status_ok; case mpack_type_int: return yajl_gen_integer(gen, tag.v.i) == yajl_gen_status_ok; case mpack_type_float: return yajl_gen_double(gen, tag.v.f) == yajl_gen_status_ok; case mpack_type_double: return yajl_gen_double(gen, tag.v.d) == yajl_gen_status_ok; case mpack_type_uint: if (tag.v.u > (uint64_t)INT64_MAX) { char buf[32]; snprintf(buf, sizeof(buf), "%" PRIu64, tag.v.u); return yajl_gen_string(gen, (const unsigned char*)buf, strlen(buf)) == yajl_gen_status_ok; } return yajl_gen_integer(gen, (int64_t)tag.v.u) == yajl_gen_status_ok; case mpack_type_str: return string(reader, gen, options, tag.v.l); case mpack_type_bin: if (options->base64) { return base64_bin(reader, gen, options, tag.v.l, options->base64_prefix); } else if (options->debug) { mpack_skip_bytes(reader, tag.v.l); mpack_done_bin(reader); // output nothing to allow us to print our debug string skip_quotes = true; if (yajl_gen_string(gen, (const unsigned char*)"", 0) != yajl_gen_status_ok) return false; skip_quotes = false; char buf[64]; snprintf(buf, sizeof(buf), "<bin of size %u>", tag.v.l); print(out_file, buf, strlen(buf)); return true; } else { fprintf(stderr, "%s: bin unencodable in JSON. Try debug viewing mode (-d)\n", options->command); return false; } case mpack_type_ext: if (options->base64) { return base64_ext(reader, gen, options, tag.exttype, tag.v.l); } else if (options->debug) { mpack_skip_bytes(reader, tag.v.l); mpack_done_ext(reader); // output nothing to allow us to print our debug string skip_quotes = true; if (yajl_gen_string(gen, (const unsigned char*)"", 0) != yajl_gen_status_ok) return false; skip_quotes = false; char buf[64]; snprintf(buf, sizeof(buf), "<ext of type %i size %u>", tag.exttype, tag.v.l); print(out_file, buf, strlen(buf)); return true; } else { fprintf(stderr, "%s: ext type %i unencodable in JSON. Try debug viewing mode (-d)\n", options->command, tag.exttype); return false; } case mpack_type_array: if (yajl_gen_array_open(gen) != yajl_gen_status_ok) return false; for (size_t i = 0; i < tag.v.l; ++i) if (!element(reader, gen, options, depth + 1)) return false; mpack_done_array(reader); return yajl_gen_array_close(gen) == yajl_gen_status_ok; case mpack_type_map: if (yajl_gen_map_open(gen) != yajl_gen_status_ok) return false; for (size_t i = 0; i < tag.v.l; ++i) { if (options->debug) { element(reader, gen, options, depth + 1); } else { uint32_t len = mpack_expect_str(reader); if (mpack_reader_error(reader) != mpack_ok) { fprintf(stderr, "%s: map key is not a string. Try debug viewing mode (-d)\n", options->command); return false; } if (!string(reader, gen, options, len)) return false; } if (!element(reader, gen, options, depth + 1)) return false; } mpack_done_map(reader); return yajl_gen_map_close(gen) == yajl_gen_status_ok; } return true; }
IoObject *IoYajlGen_pushBool(IoYajlGen *self, IoObject *locals, IoMessage *m) { int b = IoMessage_locals_boolArgAt_(m, locals, 0); yajl_gen_bool(DATA(self), b); return self; }
int main(int argc, char **argv) { bstring info_page; info_t info; yajl_gen yajl; const unsigned char *json; size_t json_len; curl_global_init(CURL_GLOBAL_NOTHING); for (size_t i = 0; argv[i]; i += 1) { if (strcmp(argv[i], "-r") == 0) { modem_touch(MODEM_RESTART_URL); return EXIT_SUCCESS; } } info_page = modem_fetch(MODEM_INFO_URL); if (!info_page) { fprintf(stderr, "hektor: Couldn't fetch '%s'\n", MODEM_INFO_URL); return EXIT_FAILURE; } info_init(&info, info_page); yajl = yajl_gen_alloc(NULL); assert(yajl); yajl_gen_config(yajl, yajl_gen_beautify, true); #define yajl_gen_strst(y, s) yajl_gen_string((y), (s), sizeof(s) - 1) yajl_gen_map_open(yajl); yajl_gen_strst(yajl, "connection"); yajl_gen_integer(yajl, info.conn); yajl_gen_strst(yajl, "fapped"); yajl_gen_bool(yajl, info.fap == FAP_ACTIVE); yajl_gen_strst(yajl, "refill_secs"); yajl_gen_integer(yajl, info.refill_secs); yajl_gen_strst(yajl, "refill_ts"); yajl_gen_integer(yajl, info.refill_ts); yajl_gen_strst(yajl, "usage_allowed"); yajl_gen_integer(yajl, info.usage_allowed); yajl_gen_strst(yajl, "usage_remain"); yajl_gen_integer(yajl, info.usage_remain); yajl_gen_map_close(yajl); #undef yajl_gen_strst yajl_gen_get_buf(yajl, &json, &json_len); printf("%s", json); bdestroy(info_page); yajl_gen_free(yajl); curl_global_cleanup(); return EXIT_SUCCESS; }