static int js_generator_number(lua_State *L) {
/* It would be better to make it so an arbitrary string can be
used here, however we would then need to validate that the
generated string is a JSON number which is a bit beyond scope
at this point. Perhaps in the future we will loosen this
restriction, it is always easier to loosen restrictions than it
is to make new restrictions that break other people's code. */
double num = luaL_checknumber(L, 2);
size_t len;
const char* str;
/* These are special cases, not sure how better to represent them
:-(. */
if ( num == HUGE_VAL ) {
str = "1e+666";
len = 6;
} else if ( num == -HUGE_VAL ) {
str = "-1e+666";
len = 7;
} else if ( isnan(num) ) {
str = "-0";
len = 2;
} else {
str = luaL_checklstring(L, 2, &len);
}
js_generator_assert(L,
yajl_gen_number(*js_check_generator(L, 1),
str, len),
__FILE__, __LINE__);
return 0;
}
static int lyajl_gen_number (lua_State *L) {
size_t len;
const char *value;
luvit_generator_t *generator = generator_get(L, 1);
value = luaL_checklstring(L, 2, &len);
yajl_gen_number(generator->gen, value, len);
return 0;
}
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;
}
void json_from_bson_double(yajl_gen *g, bson_iterator *it)
{
double value = bson_iterator_double( it );
char buffer[100];
sprintf( buffer, "%.9g", value );
yajl_gen_number( *g, buffer, strlen(buffer) );
}
IoObject *IoYajlGen_pushNumberString(IoYajlGen *self, IoObject *locals, IoMessage *m)
{
IoSeq *s = IoMessage_locals_seqArgAt_(m, locals, 0);
yajl_gen_number(DATA(self),
(const char *)IOSYMBOL_BYTES(s),
IOSYMBOL_LENGTH(s));
return self;
}
/* encode a ruby string as a yajl number (also used to embed already-rendered json from #to_json) */
VALUE gen_number(VALUE rb_yajl_gen, VALUE str) {
yajl_gen_status status;
struct yajl_gen_t *yajl_gen;
Data_Get_Struct(rb_yajl_gen, struct yajl_gen_t, yajl_gen);
char *cptr = RSTRING_PTR(str);
int len = RSTRING_LEN(str);
if ((status = yajl_gen_number(yajl_gen, cptr, len)) != yajl_gen_status_ok) {
rb_funcall(mEncoder2, rb_intern("raise_error_for_status"), 2, INT2FIX(status), str);
}
return Qnil;
}
static VALUE rb_cObject_ffi_yajl(VALUE self, VALUE rb_yajl_gen, VALUE state) {
yajl_gen_status status;
ID sym_to_json = rb_intern("to_json");
VALUE str;
VALUE json_opts = rb_hash_aref(state, rb_str_new2("json_opts"));
struct yajl_gen_t *yajl_gen;
Data_Get_Struct(rb_yajl_gen, struct yajl_gen_t, yajl_gen);
str = rb_funcall(self, sym_to_json, 1, json_opts);
CHECK_STATUS(
yajl_gen_number(yajl_gen, (char *)RSTRING_PTR(str), RSTRING_LEN(str))
);
return Qnil;
}
bool
JSONGenerator::addPair(const std::string& key, const int value)
{
VALIDATE_STATE();
std::stringstream stream;
stream << value;
std::string str = stream.str();
if (yajl_gen_string(mState->mGen, (const unsigned char *)key.c_str(), key.length()) != yajl_gen_status_ok) {
return false;
} else if (yajl_gen_number(mState->mGen, str.c_str(), str.length()) != yajl_gen_status_ok) {
return false;
}
return true;
}
static int reformat_number(void* ctx, const char * stringVal, size_t stringLen) {
ccJSONContext* jc = (ccJSONContext*)ctx;
char* s = (char*)stringVal;
char oldChar = s[stringLen];
s[stringLen] = 0;
bool array = *(jc->flagStack->rbegin());
if(array) {
CCJSONArray* p = (CCJSONArray*)(*(jc->objStack->rbegin()));
p->addString((const char*)stringVal);
} else {
CCJSONObject* p = (CCJSONObject*)(*(jc->objStack->rbegin()));
p->addString(jc->key, s);
}
s[stringLen] = oldChar;
return yajl_gen_status_ok == yajl_gen_number(jc->g, stringVal, stringLen);
}
static VALUE rb_cFloat_ffi_yajl(VALUE self, VALUE rb_yajl_gen, VALUE state) {
yajl_gen_status status;
ID sym_to_s = rb_intern("to_s");
VALUE str = rb_funcall(self, sym_to_s, 0);
char *cptr = RSTRING_PTR(str);
int len = RSTRING_LEN(str);
struct yajl_gen_t *yajl_gen;
Data_Get_Struct(rb_yajl_gen, struct yajl_gen_t, yajl_gen);
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);
}
if ( rb_hash_aref(state, rb_str_new2("processing_key")) == Qtrue ) {
CHECK_STATUS(
yajl_gen_string(yajl_gen, (unsigned char *)cptr, len)
);
} else {
CHECK_STATUS(
yajl_gen_number(yajl_gen, cptr, len)
);
}
return Qnil;
}
void writejson(FILE * out, char *stamp, char *line, size_t len, int fragment)
{
yajl_gen g;
const unsigned char *buf;
size_t buflen;
g = yajl_gen_alloc(NULL);
yajl_gen_config(g, yajl_gen_beautify, 0);
yajl_gen_config(g, yajl_gen_validate_utf8, 1);
chk(yajl_gen_map_open(g));
chk(yajl_gen_string(g, (const unsigned char *)"timestamp", 9));
chk(yajl_gen_string(g, (const unsigned char *)stamp, TIMESTAMP));
chk(yajl_gen_string(g, (const unsigned char *)"message", 7));
chk(yajl_gen_string(g, (const unsigned char *)line, len));
if (fragment >= 0) {
char fragmentStr[30];
snprintf(fragmentStr, 30, "%d", fragment);
chk(yajl_gen_string(g, (const unsigned char *)"fragmentId", 10));
chk(yajl_gen_number(g, fragmentStr, strlen(fragmentStr)));
}
chk(yajl_gen_map_close(g));
yajl_gen_get_buf(g, &buf, &buflen);
fwrite(buf, 1, buflen, out);
yajl_gen_clear(g);
yajl_gen_free(g);
putc('\n', out);
}
static int reformat_number(void * ctx, const char * s, unsigned int l)
{
yajl_gen g = (yajl_gen) ctx;
yajl_gen_number(g, s, l);
return 1;
}
static int reformat_number(void * ctx, const char * s, size_t l)
{
yajl_gen g = (yajl_gen) ctx;
GEN_AND_RETURN(yajl_gen_number(g, s, l));
}
static int reformat_number(void * ctx, const char * s, size_t l)
{
yajl_gen g = (yajl_gen) ctx;
return yajl_gen_status_ok == yajl_gen_number(g, s, l);
}
static gboolean
log_save_foreach(GtkTreeModel *store,
GtkTreePath *path,
GtkTreeIter *iter,
gpointer data)
{
yajl_gen gen = (yajl_gen)data;
network_t net;
signals_node_t *sample;
const gchar *buffer;
gtk_tree_model_get(GTK_TREE_MODEL(ui.model->store), iter,
COL_ADDRESS, &net.address,
COL_FREQUENCY, &net.frequency,
COL_CHANNEL, &net.channel,
COL_MODE, &net.mode,
COL_SSID, &net.ssid,
COL_RADIONAME, &net.radioname,
COL_MAXRSSI, &net.rssi,
COL_PRIVACY, &net.flags.privacy,
COL_ROUTEROS, &net.flags.routeros,
COL_NSTREME, &net.flags.nstreme,
COL_TDMA, &net.flags.tdma,
COL_WDS, &net.flags.wds,
COL_BRIDGE, &net.flags.bridge,
COL_ROUTEROS_VER, &net.routeros_ver,
COL_FIRSTSEEN, &net.firstseen,
COL_LASTSEEN, &net.lastseen,
COL_LATITUDE, &net.latitude,
COL_LONGITUDE, &net.longitude,
COL_SIGNALS, &net.signals,
-1);
yajl_gen_string(gen, (guchar*)net.address, strlen(net.address));
yajl_gen_map_open(gen);
buffer = model_format_frequency(net.frequency);
yajl_gen_string(gen, (guchar*)keys[KEY_FREQUENCY], strlen(keys[KEY_FREQUENCY]));
yajl_gen_number(gen, buffer, strlen(buffer));
yajl_gen_string(gen, (guchar*)keys[KEY_CHANNEL], strlen(keys[KEY_CHANNEL]));
yajl_gen_string(gen, (guchar*)net.channel, strlen(net.channel));
yajl_gen_string(gen, (guchar*)keys[KEY_MODE], strlen(keys[KEY_MODE]));
yajl_gen_string(gen, (guchar*)net.mode, strlen(net.mode));
yajl_gen_string(gen, (guchar*)keys[KEY_SSID], strlen(keys[KEY_SSID]));
yajl_gen_string(gen, (guchar*)net.ssid, strlen(net.ssid));
yajl_gen_string(gen, (guchar*)keys[KEY_RADIONAME], strlen(keys[KEY_RADIONAME]));
yajl_gen_string(gen, (guchar*)net.radioname, strlen(net.radioname));
yajl_gen_string(gen, (guchar*)keys[KEY_RSSI], strlen(keys[KEY_RSSI]));
yajl_gen_integer(gen, net.rssi);
yajl_gen_string(gen, (guchar*)keys[KEY_PRIVACY], strlen(keys[KEY_PRIVACY]));
yajl_gen_integer(gen, net.flags.privacy);
yajl_gen_string(gen, (guchar*)keys[KEY_ROUTEROS], strlen(keys[KEY_ROUTEROS]));
if(net.routeros_ver && strlen(net.routeros_ver))
yajl_gen_string(gen, (guchar*)net.routeros_ver, strlen(net.routeros_ver));
else
yajl_gen_integer(gen, net.flags.routeros);
yajl_gen_string(gen, (guchar*)keys[KEY_NSTREME], strlen(keys[KEY_NSTREME]));
yajl_gen_integer(gen, net.flags.nstreme);
yajl_gen_string(gen, (guchar*)keys[KEY_TDMA], strlen(keys[KEY_TDMA]));
yajl_gen_integer(gen, net.flags.tdma);
yajl_gen_string(gen, (guchar*)keys[KEY_WDS], strlen(keys[KEY_WDS]));
yajl_gen_integer(gen, net.flags.wds);
yajl_gen_string(gen, (guchar*)keys[KEY_BRIDGE], strlen(keys[KEY_BRIDGE]));
yajl_gen_integer(gen, net.flags.bridge);
yajl_gen_string(gen, (guchar*)keys[KEY_FIRSTSEEN], strlen(keys[KEY_FIRSTSEEN]));
yajl_gen_integer(gen, net.firstseen);
yajl_gen_string(gen, (guchar*)keys[KEY_LASTSEEN], strlen(keys[KEY_LASTSEEN]));
yajl_gen_integer(gen, net.lastseen);
if(!isnan(net.latitude) && !isnan(net.longitude))
{
buffer = model_format_gps(net.latitude);
yajl_gen_string(gen, (guchar*)keys[KEY_LATITUDE], strlen(keys[KEY_LATITUDE]));
yajl_gen_number(gen, buffer, strlen(buffer));
buffer = model_format_gps(net.longitude);
yajl_gen_string(gen, (guchar*)keys[KEY_LONGITUDE], strlen(keys[KEY_LONGITUDE]));
yajl_gen_number(gen, buffer, strlen(buffer));
}
if(net.signals->head)
{
yajl_gen_string(gen, (guchar*)keys[KEY_SIGNALS], strlen(keys[KEY_SIGNALS]));
yajl_gen_array_open(gen);
sample = net.signals->head;
while(sample)
{
yajl_gen_map_open(gen);
yajl_gen_string(gen, (guchar*)keys_signals[KEY_SIGNALS_TIMESTAMP], strlen(keys_signals[KEY_SIGNALS_TIMESTAMP]));
yajl_gen_integer(gen, sample->timestamp);
yajl_gen_string(gen, (guchar*)keys_signals[KEY_SIGNALS_RSSI], strlen(keys_signals[KEY_SIGNALS_RSSI]));
yajl_gen_integer(gen, sample->rssi);
if(!isnan(sample->latitude) && !isnan(sample->longitude))
{
buffer = model_format_gps(sample->latitude);
yajl_gen_string(gen, (guchar*)keys_signals[KEY_SIGNALS_LATITUDE], strlen(keys_signals[KEY_SIGNALS_LATITUDE]));
yajl_gen_number(gen, buffer, strlen(buffer));
buffer = model_format_gps(sample->longitude);
yajl_gen_string(gen, (guchar*)keys_signals[KEY_SIGNALS_LONGITUDE], strlen(keys_signals[KEY_SIGNALS_LONGITUDE]));
yajl_gen_number(gen, buffer, strlen(buffer));
}
yajl_gen_map_close(gen);
sample = sample->next;
}
yajl_gen_array_close(gen);
}
yajl_gen_map_close(gen);
/* Signals are stored in GtkListStore just as pointer,
so set it to NULL before freeing the struct */
net.signals = NULL;
network_free(&net);
return FALSE;
}
int dump_audit_log(struct audit_log_entry_t *a)
{
yajl_gen g;
const unsigned char * buf;
size_t len;
g = yajl_gen_alloc(NULL);
yajl_gen_config(g, yajl_gen_beautify, 1);
yajl_gen_array_open(g);
yajl_gen_map_open(g);
yajl_gen_string(g, "id", strlen("id"));
yajl_gen_string(g, a->id, strlen(a->id));
yajl_gen_string(g, "date", strlen("date"));
yajl_gen_string(g, a->date, strlen(a->date));
yajl_gen_string(g, "origin", strlen("origin"));
yajl_gen_map_open(g);
yajl_gen_string(g, "ip", strlen("ip"));
yajl_gen_string(g, a->origin, strlen(a->origin));
yajl_gen_string(g, "port", strlen("port"));
yajl_gen_number(g, a->origin_port, strlen(a->origin_port));
yajl_gen_map_close(g);
yajl_gen_string(g, "dest", strlen("dest"));
yajl_gen_map_open(g);
yajl_gen_string(g, "ip", strlen("ip"));
yajl_gen_string(g, a->dest, strlen(a->dest));
yajl_gen_string(g, "port", strlen("port"));
yajl_gen_number(g, a->dest_port, strlen(a->dest_port));
yajl_gen_map_close(g);
if (a->section_a != NULL)
{
yajl_gen_string(g, "Section A", strlen("Section A"));
yajl_gen_string(g, a->section_a, strlen(a->section_a));
}
if (a->section_b != NULL)
{
yajl_gen_string(g, "Section B", strlen("Section B"));
yajl_gen_string(g, a->section_b, strlen(a->section_b));
}
if (a->section_f != NULL)
{
yajl_gen_string(g, "Section F", strlen("Section F"));
yajl_gen_string(g, a->section_f, strlen(a->section_f));
}
if (a->section_e != NULL)
{
yajl_gen_string(g, "Section E", strlen("Section E"));
yajl_gen_string(g, a->section_e, strlen(a->section_e));
}
if (a->section_h != NULL)
{
yajl_gen_string(g, "Section H", strlen("Section H"));
yajl_gen_string(g, a->section_h, strlen(a->section_h));
}
yajl_gen_map_close(g);
yajl_gen_array_close(g);
yajl_gen_get_buf(g, &buf, &len);
fwrite(buf, 1, len, stdout);
yajl_gen_free(g);
#if 0
fprintf(stdout, "Section A: %s\n", a->section_a);
fprintf(stdout, "Section B: %s\n", a->section_b);
fprintf(stdout, "Section F: %s\n", a->section_f);
fprintf(stdout, "Section E: %s\n", a->section_e);
fprintf(stdout, "Section H: %s\n", a->section_h);
#endif
}
void json_writer::entry_double(double d) {
// this is the only way, it seems, to use a fixed format for double output.
static char buffer[12];
snprintf(buffer, 12, "%.7f", d);
yajl_gen_number(pimpl->gen, buffer, strlen(buffer));
}
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;
}
void
rb_journalist_socket_send(int count, const char *event, ...)
{
pthread_mutex_lock(&sock_mutex);
yajl_gen_map_open(gen);
yajl_gen_string(gen, (const unsigned char *)"event", 5);
yajl_gen_string(gen, (const unsigned char *)event, strlen(event));
if(count > 0) {
va_list arguments;
va_start(arguments, event);
char buf[32];
const char *key;
int type;
size_t length;
char *string;
int integer;
uint64_t uint64;
int i;
for(i = 0; i < count; i++) {
key = va_arg(arguments, char *);
type = va_arg(arguments, int);
yajl_gen_string(gen, (const unsigned char *)key, strlen(key));
switch(type) {
case 's':
string = va_arg(arguments, char *);
length = strlen(string);
yajl_gen_string(gen, (const unsigned char *)string, length);
break;
case 'i':
integer = va_arg(arguments, int);
sprintf(buf, "%d", integer);
length = strlen(buf);
yajl_gen_number(gen, buf, length);
break;
case 'b':
yajl_gen_bool(gen, va_arg(arguments, int));
break;
case 't':
uint64 = va_arg(arguments, uint64_t);
sprintf(buf, "%" PRIu64, uint64);
length = strlen(buf);
yajl_gen_number(gen, buf, length);
break;
}
}
va_end(arguments);
}
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);
}
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;
}
}
/**
* JSON YAJL encode: Encode a list
*
* @param[in,out] handle YAJL generator handle
* @param[in] name Name of @a list (or NULL)
* @param[in] nlen Length of @a name
* @param[in] list IronBee list to encode
*
* @returns IronBee status code
*/
static ib_status_t encode_list(
yajl_gen handle,
const char *name,
size_t nlen,
const ib_list_t *list)
{
ib_status_t rc = IB_OK;
const ib_list_node_t *node;
yajl_gen_status status;
int errors = 0;
/* Encode the name */
if ( (name != NULL) && (nlen != 0) ) {
status = yajl_gen_string(handle, (const unsigned char *)name, nlen);
if (status != yajl_gen_status_ok) {
return IB_EUNKNOWN;
}
}
/* Encode the map start */
status = yajl_gen_map_open(handle);
if (status != yajl_gen_status_ok) {
return IB_EUNKNOWN;
}
IB_LIST_LOOP_CONST(list, node) {
const ib_field_t *field = (const ib_field_t *)node->data;
ib_status_t tmprc;
status = yajl_gen_string(handle,
(const unsigned char *)field->name,
field->nlen);
if (status != yajl_gen_status_ok) {
rc = IB_EUNKNOWN;
++errors;
continue;
}
switch(field->type) {
case IB_FTYPE_LIST:
{
const ib_list_t *list2;
tmprc = ib_field_value(field, ib_ftype_list_out(&list2));
if ( (tmprc != IB_OK) && (rc == IB_OK) ) {
rc = tmprc;
++errors;
}
else {
tmprc = encode_list(handle, NULL, 0, list2);
if ( (tmprc != IB_OK) && (rc == IB_OK) ) {
rc = tmprc;
++errors;
}
}
break;
}
case IB_FTYPE_NUM:
{
ib_num_t num;
tmprc = ib_field_value(field, ib_ftype_num_out(&num));
if ( (tmprc != IB_OK) && (rc == IB_OK) ) {
rc = tmprc;
++errors;
}
else {
status = yajl_gen_integer(handle, num);
if (status != yajl_gen_status_ok) {
if (rc != IB_OK) {
rc = IB_EUNKNOWN;
}
++errors;
}
}
break;
}
case IB_FTYPE_FLOAT:
{
ib_float_t fnum;
tmprc = ib_field_value(field, ib_ftype_float_out(&fnum));
if ( (tmprc != IB_OK) && (rc == IB_OK) ) {
rc = tmprc;
++errors;
}
else {
char buf[float_buf_size+1];
snprintf(buf, float_buf_size, "%#.8Lg", fnum);
status = yajl_gen_number(handle, buf, strlen(buf));
if (status != yajl_gen_status_ok) {
if (rc != IB_OK) {
rc = IB_EUNKNOWN;
}
++errors;
}
}
break;
}
case IB_FTYPE_NULSTR:
{
const char *str;
tmprc = ib_field_value(field, ib_ftype_nulstr_out(&str));
if ( (tmprc != IB_OK) && (rc == IB_OK) ) {
rc = tmprc;
++errors;
}
else {
status = yajl_gen_string(handle,
(unsigned char *)str,
strlen(str));
if (status != yajl_gen_status_ok) {
if (rc != IB_OK) {
rc = IB_EUNKNOWN;
}
++errors;
}
}
break;
}
case IB_FTYPE_BYTESTR:
{
const ib_bytestr_t *bs;
tmprc = ib_field_value(field, ib_ftype_bytestr_out(&bs));
if ( (tmprc != IB_OK) && (rc == IB_OK) ) {
rc = tmprc;
++errors;
}
else {
status = yajl_gen_string(handle,
ib_bytestr_const_ptr(bs),
ib_bytestr_length(bs));
if (status != yajl_gen_status_ok) {
if (rc != IB_OK) {
rc = IB_EUNKNOWN;
}
++errors;
}
}
break;
}
default: /* Just ignore it */
break;
} /* switch(f->type) */
}
/* Encode the map end */
status = yajl_gen_map_close(handle);
if (status != yajl_gen_status_ok) {
return IB_EUNKNOWN;
}
return IB_OK;
}
int LKStreamTranslator::handle_number(void *ctx, const char *val, size_t len) {
return yajl_gen_number(static_cast<LKStreamTranslator::ctx_t*>(ctx)->gen, val, len) == yajl_gen_status_ok;
}
void StatsPoster::GenNum(yajl_gen g, const char *key, dword value) {
yajl_gen_string(g, (const unsigned char *)key, strlen(key));
const char *s = base::Format::ToString("%lu", value);
yajl_gen_number(g, s, strlen(s));
}
