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;
}
