char *virJSONValueToString(virJSONValuePtr object, bool pretty) { yajl_gen g; const unsigned char *str; char *ret = NULL; yajl_size_t len; # ifndef WITH_YAJL2 yajl_gen_config conf = { pretty ? 1 : 0, pretty ? " " : " "}; # endif VIR_DEBUG("object=%p", object); # ifdef WITH_YAJL2 g = yajl_gen_alloc(NULL); if (g) { yajl_gen_config(g, yajl_gen_beautify, pretty ? 1 : 0); yajl_gen_config(g, yajl_gen_indent_string, pretty ? " " : " "); yajl_gen_config(g, yajl_gen_validate_utf8, 1); } # else g = yajl_gen_alloc(&conf, NULL); # endif if (!g) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("Unable to create JSON formatter")); goto cleanup; } if (virJSONValueToStringOne(object, g) < 0) { virReportOOMError(); goto cleanup; } if (yajl_gen_get_buf(g, &str, &len) != yajl_gen_status_ok) { virReportOOMError(); goto cleanup; } ignore_value(VIR_STRDUP(ret, (const char *)str)); cleanup: yajl_gen_free(g); VIR_DEBUG("result=%s", NULLSTR(ret)); return ret; }
char *virJSONValueToString(virJSONValuePtr object) { yajl_gen g; const unsigned char *str; char *ret = NULL; yajl_size_t len; # ifndef HAVE_YAJL2 yajl_gen_config conf = { 0, " " }; /* Turns off pretty printing since QEMU can't cope */ # endif VIR_DEBUG("object=%p", object); # ifdef HAVE_YAJL2 g = yajl_gen_alloc(NULL); if (g) { yajl_gen_config(g, yajl_gen_beautify, 0); yajl_gen_config(g, yajl_gen_indent_string, " "); yajl_gen_config(g, yajl_gen_validate_utf8, 1); } # else g = yajl_gen_alloc(&conf, NULL); # endif if (!g) { virJSONError(VIR_ERR_INTERNAL_ERROR, "%s", _("Unable to create JSON formatter")); goto cleanup; } if (virJSONValueToStringOne(object, g) < 0) { virReportOOMError(); goto cleanup; } if (yajl_gen_get_buf(g, &str, &len) != yajl_gen_status_ok) { virReportOOMError(); goto cleanup; } if (!(ret = strdup((const char *)str))) virReportOOMError(); cleanup: yajl_gen_free(g); VIR_DEBUG("result=%s", NULLSTR(ret)); return ret; }
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; }
xlw::XlfOper HttpProtocol::Execute(const char* name, bool sendCaller, xlw::XlfOper* args, int argc) { REQUEST_CONTEXT context; context.hEvent = CreateEvent(0, 1, 0, 0); context.hConnect = WinHttpConnect(hSession, host, urlc.nPort, 0); int flags = WINHTTP_FLAG_BYPASS_PROXY_CACHE; if(urlc.nScheme == INTERNET_SCHEME_HTTPS) flags |= WINHTTP_FLAG_SECURE; context.hRequest = WinHttpOpenRequest(context.hConnect, L"POST", path, 0, 0, 0, flags); context.conf.beautify = 0; context.conf.indentString = ""; context.g = yajl_gen_alloc(&context.conf, 0); context.px = xlw::XlfOper(); //context.px->xltype = xltypeNil | xlbitDLLFree; GenerateRequest(context.g, name, sendCaller, args, argc); const unsigned char * buf; unsigned int len = 0; yajl_gen_get_buf(context.g, &buf, &len); BOOL res = FALSE; res = WinHttpSendRequest(context.hRequest, 0, 0, (LPVOID) buf, len, len, (DWORD_PTR) &context); if(!res) { const char* err = "#Could not connect to server"; Log::Error(err); WinHttpCloseHandle(context.hRequest); WinHttpCloseHandle(context.hConnect); context.px = xlw::XlfOper(err); return context.px; } // TODO timeout/background res = WinHttpReceiveResponse(context.hRequest, 0); if(!res) { const char* err = "#Error retrieving server response"; Log::Error(err); WinHttpCloseHandle(context.hRequest); WinHttpCloseHandle(context.hConnect); context.px = xlw::XlfOper(err); return context.px; } // Check http response code DWORD status; DWORD statusLength = 4; res = WinHttpQueryHeaders(context.hRequest, WINHTTP_QUERY_STATUS_CODE| WINHTTP_QUERY_FLAG_NUMBER, NULL, &status, &statusLength, 0); if(!res || status != 200) { Log::Error("Status code: %d", status); const char* err = "#Server returned an error"; WinHttpCloseHandle(context.hRequest); WinHttpCloseHandle(context.hConnect); context.px = xlw::XlfOper(err); return context.px; } ReadData(&context); WinHttpCloseHandle(context.hRequest); WinHttpCloseHandle(context.hConnect); yajl_gen_clear(context.g); yajl_gen_free(context.g); //context.px->xltype |= xlbitDLLFree; return context.px; }
IoYajlGen *IoYajlGen_proto(void *state) { IoYajlGen *self = IoObject_new(state); IoObject_tag_(self, IoYajlGen_newTag(state)); yajl_gen_config config = { 0, "" }; IoObject_setDataPointer_(self, yajl_gen_alloc(&config, NULL)); IoState_registerProtoWithFunc_(state, self, IoYajlGen_proto); { IoMethodTable methodTable[] = { {"pushNull", IoYajlGen_pushNull}, {"pushString", IoYajlGen_pushString}, {"pushInteger", IoYajlGen_pushInteger}, {"pushDouble", IoYajlGen_pushDouble}, {"pushNumberString", IoYajlGen_pushNumberString}, {"pushBool", IoYajlGen_pushBool}, {"openMap", IoYajlGen_openMap}, {"closeMap", IoYajlGen_closeMap}, {"openArray", IoYajlGen_openArray}, {"closeArray", IoYajlGen_closeArray}, {"generate", IoYajlGen_generate}, {NULL, NULL}, }; IoObject_addMethodTable_(self, methodTable); } return self; }
ngx_http_tfs_json_gen_t * ngx_http_tfs_json_init(ngx_log_t *log, ngx_pool_t *pool) { yajl_gen g; ngx_http_tfs_json_gen_t *tj_gen; g = yajl_gen_alloc(NULL); if (g == NULL) { ngx_log_error(NGX_LOG_ERR, log, errno, "alloc yajl_gen failed"); return NULL; } tj_gen = ngx_pcalloc(pool, sizeof(ngx_http_tfs_json_gen_t)); if (tj_gen == NULL) { return NULL; } yajl_gen_config(g, yajl_gen_beautify, 1); tj_gen->gen = g; tj_gen->pool = pool; tj_gen->log = log; return tj_gen; }
json_writer::json_writer(boost::shared_ptr<output_buffer> &out, bool indent) : pimpl(new pimpl_()) { #ifdef HAVE_YAJL2 pimpl->gen = yajl_gen_alloc(NULL); #else /* older version of YAJL */ // setup whether the generator should produce pretty output if (indent) { pimpl->config.beautify = 1; pimpl->config.indentString = " "; } else { pimpl->config.beautify = 0; pimpl->config.indentString = ""; } pimpl->gen = yajl_gen_alloc2(&wrap_write, &pimpl->config, NULL, out.get()); #endif /* HAVE_YAJL2 */ if (pimpl->gen == 0) { throw std::runtime_error("error creating json writer."); } #ifdef HAVE_YAJL2 if (indent) { yajl_gen_config(pimpl->gen, yajl_gen_beautify, 1); yajl_gen_config(pimpl->gen, yajl_gen_indent_string, " "); } else { yajl_gen_config(pimpl->gen, yajl_gen_beautify, 0); yajl_gen_config(pimpl->gen, yajl_gen_indent_string, ""); } yajl_gen_config(pimpl->gen, yajl_gen_print_callback, &wrap_write, (void *)out.get()); #endif /* HAVE_YAJL2 */ }
gboolean log_save(gchar *filename) { gzFile gzfp = NULL; FILE *fp = NULL; gchar *ext; gboolean compression; yajl_gen gen; const guchar *json_string; size_t json_length; gint wrote; ext = strrchr(filename, '.'); compression = (ext && !g_ascii_strcasecmp(ext, ".gz")); if(compression) gzfp = gzopen(filename, "wb"); else fp = fopen(filename, "w"); if(!gzfp && !fp) { ui_dialog(ui.window, GTK_MESSAGE_ERROR, "Error", "Unable to save a file:\n%s", filename); return FALSE; } gen = yajl_gen_alloc(NULL); //yajl_gen_config(gen, yajl_gen_beautify, 1); yajl_gen_map_open(gen); gtk_tree_model_foreach(GTK_TREE_MODEL(ui.model->store), log_save_foreach, gen); yajl_gen_map_close(gen); yajl_gen_get_buf(gen, &json_string, &json_length); if(compression) { wrote = gzwrite(gzfp, json_string, json_length); gzclose(gzfp); } else { wrote = fwrite(json_string, sizeof(gchar), json_length, fp); fclose(fp); } yajl_gen_free(gen); if(json_length != wrote) { ui_dialog(ui.window, GTK_MESSAGE_ERROR, "Error", "Unable to save a file:\n%s\n\nWrote only %d of %d uncompressed bytes.", filename, wrote, json_length); return FALSE; } return TRUE; }
luvit_generator_t* generator_new(lua_State *L) { luvit_generator_t *generator = lua_newuserdata(L, sizeof(*generator)); generator->gen = yajl_gen_alloc(NULL); luaL_getmetatable(L, JSON_GENERATOR_HANDLE); lua_setmetatable(L, -2); return generator; }
IoYajlGen *IoYajlGen_rawClone(IoYajlGen *proto) { IoObject *self = IoObject_rawClonePrimitive(proto); yajl_gen_config config = { 0, "" }; IoObject_setDataPointer_(self, yajl_gen_alloc(&config, NULL)); return self; }
/* * Format (prometheus/alertmanager v1): * * [{ * "labels": { * "alertname": "collectd_cpu", * "instance": "host.example.com", * "severity": "FAILURE", * "service": "collectd", * "cpu": "0", * "type": "wait" * }, * "annotations": { * "summary": "...", * // meta * }, * "startsAt": <rfc3339 time>, * "endsAt": <rfc3339 time>, // not used * }] */ int format_json_notification(char *buffer, size_t buffer_size, /* {{{ */ notification_t const *n) { yajl_gen g; unsigned char const *out; #if HAVE_YAJL_V2 size_t unused_out_len; #else unsigned int unused_out_len; #endif if ((buffer == NULL) || (n == NULL)) return EINVAL; #if HAVE_YAJL_V2 g = yajl_gen_alloc(NULL); if (g == NULL) return -1; #if COLLECT_DEBUG yajl_gen_config(g, yajl_gen_beautify, 1); yajl_gen_config(g, yajl_gen_validate_utf8, 1); #endif #else /* !HAVE_YAJL_V2 */ yajl_gen_config conf = {0}; #if COLLECT_DEBUG conf.beautify = 1; conf.indentString = " "; #endif g = yajl_gen_alloc(&conf, NULL); if (g == NULL) return -1; #endif if (format_alert(g, n) != 0) { yajl_gen_clear(g); yajl_gen_free(g); return -1; } /* copy to output buffer */ yajl_gen_get_buf(g, &out, &unused_out_len); sstrncpy(buffer, (void *)out, buffer_size); yajl_gen_clear(g); yajl_gen_free(g); return 0; } /* }}} format_json_notification */
char *store_restart_layout(void) { setlocale(LC_NUMERIC, "C"); yajl_gen gen = yajl_gen_alloc(NULL); dump_node(gen, croot, true); setlocale(LC_NUMERIC, ""); const unsigned char *payload; size_t length; y(get_buf, &payload, &length); /* create a temporary file if one hasn't been specified, or just * resolve the tildes in the specified path */ char *filename; if (config.restart_state_path == NULL) { filename = get_process_filename("restart-state"); if (!filename) return NULL; } else { filename = resolve_tilde(config.restart_state_path); } int fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR); if (fd == -1) { perror("open()"); free(filename); return NULL; } size_t written = 0; while (written < length) { int n = write(fd, payload + written, length - written); /* TODO: correct error-handling */ if (n == -1) { perror("write()"); free(filename); close(fd); return NULL; } if (n == 0) { DLOG("write == 0?\n"); free(filename); close(fd); return NULL; } written += n; DLOG("written: %zd of %zd\n", written, length); } close(fd); if (length > 0) { DLOG("layout: %.*s\n", (int)length, payload); } y(free); return filename; }
static int json_init(struct formatter *fmt) { struct json_formatter_data *priv = fmt->priv; if((priv->yajl = yajl_gen_alloc(NULL)) == NULL) return -1; yajl_gen_array_open(priv->yajl); return 0; }
void VertexServer_setupYajl(VertexServer *self) { if(self->yajl) yajl_gen_free(self->yajl); yajl_gen_config config = { 0, "" }; self->yajl = yajl_gen_alloc(&config, NULL); PDB_setYajl_(self->pdb, self->yajl); }
IoYajlGen *IoYajlGen_rawClone(IoYajlGen *proto) { IoObject *self = IoObject_rawClonePrimitive(proto); yajl_gen yg = yajl_gen_alloc(NULL); //yajl_gen_config(yg, yajl_gen_beautify, 0); IoObject_setDataPointer_(self, yg); return self; }
static int json_start(struct asfd *asfd) { if(!yajl) { if(!(yajl=yajl_gen_alloc(NULL))) return -1; yajl_gen_config(yajl, yajl_gen_beautify, pretty_print); } if(yajl_map_open_w()) return -1; return 0; }
yajl_gen bson_to_yajl(bson *b) { bson_iterator it[1]; bson_iterator_init( it, b ); yajl_gen g = yajl_gen_alloc( NULL ); yajl_gen_config( g, yajl_gen_beautify, 1 ); json_from_bson_object( &g, it ); return g; }
/* OVS DB echo request handler. When OVS DB sends * "echo" request to the client, client should generate * "echo" replay with the same content received in the * request */ static int ovs_db_table_echo_cb(const ovs_db_t *pdb, yajl_val jnode) { yajl_val jparams; yajl_val jid; yajl_gen jgen; size_t resp_len = 0; const char *resp = NULL; const char *params_path[] = {"params", NULL}; const char *id_path[] = {"id", NULL}; yajl_gen_status yajl_gen_ret; if ((jgen = yajl_gen_alloc(NULL)) == NULL) return -1; /* check & get request attributes */ if ((jparams = yajl_tree_get(jnode, params_path, yajl_t_array)) == NULL || ((jid = yajl_tree_get(jnode, id_path, yajl_t_any)) == NULL)) { OVS_ERROR("parse echo request failed"); goto yajl_gen_failure; } /* generate JSON echo response */ OVS_YAJL_CALL(yajl_gen_map_open, jgen); OVS_YAJL_CALL(ovs_yajl_gen_tstring, jgen, "result"); OVS_YAJL_CALL(ovs_yajl_gen_val, jgen, jparams); OVS_YAJL_CALL(ovs_yajl_gen_tstring, jgen, "error"); OVS_YAJL_CALL(yajl_gen_null, jgen); OVS_YAJL_CALL(ovs_yajl_gen_tstring, jgen, "id"); OVS_YAJL_CALL(ovs_yajl_gen_val, jgen, jid); OVS_YAJL_CALL(yajl_gen_map_close, jgen); OVS_YAJL_CALL(yajl_gen_get_buf, jgen, (const unsigned char **)&resp, &resp_len); /* send the response */ OVS_DEBUG("response: %s", resp); if (ovs_db_data_send(pdb, resp, resp_len) < 0) { OVS_ERROR("send echo reply failed"); goto yajl_gen_failure; } /* clean up and return success */ yajl_gen_clear(jgen); return 0; yajl_gen_failure: /* release memory */ yajl_gen_clear(jgen); return -1; }
veBool pubnub_atPublishN(struct PubnubAt* nubat, char const *buf, size_t buf_len) { struct PubnubRequest *nubreq; u8 const *json; size_t json_len; /* allocate request */ if (!nubat->g) { nubat->g = yajl_gen_alloc(NULL); if (!nubat->g) return veFalse; } nubreq = (struct PubnubRequest *) ve_malloc(sizeof(struct PubnubRequest)); if (!nubreq) { /* reuse the nubat->q next time */ return veFalse; } pubnub_req_init(&nubat->nub, nubreq, 512, 512); /* build json data.. */ if (yajl_gen_string(nubat->g, (u8*) buf, buf_len) != yajl_gen_status_ok) { ve_error("json: not a valid string"); goto error; } if (yajl_gen_get_buf(nubat->g, &json, &json_len) != yajl_gen_status_ok) { ve_error("json: could not get buf"); return veFalse; } /* sent it */ if (pubnub_publish(nubreq, (char*) json, publish_callback) != RET_OK) { ve_error("could not pubnub_publish"); goto error; } yajl_gen_clear(nubat->g); /* empty buffers */ yajl_gen_free(nubat->g); nubat->g = NULL; return veTrue; error: pubnub_req_deinit(nubreq); ve_free(nubreq); yajl_gen_free(nubat->g); nubat->g = NULL; return veFalse; }
/* * Document-method: new * * call-seq: initialize([:pretty => false[, :indent => ' '][, :terminator => "\n"]]) * * :pretty will enable/disable beautifying or "pretty priting" the output string. * * :indent is the character(s) used to indent the output string. * * :terminator allows you to specify a character to be used as the termination character after a full JSON string has been generated by * the encoder. This would be especially useful when encoding in chunks (via a block or callback during the encode process), to be able to * determine when the last chunk of the current encode is sent. * If you specify this option to be nil, it will be ignored if encoding directly to an IO or simply returning a string. But if a block is used, * the encoder will still pass it - I hope that makes sense ;). */ static VALUE rb_yajl_encoder_new(int argc, VALUE * argv, VALUE klass) { yajl_encoder_wrapper * wrapper; yajl_gen_config cfg; VALUE opts, obj, indent; unsigned char *indentString = NULL, *actualIndent = NULL; int beautify = 0, htmlSafe = 0; /* Scan off config vars */ if (rb_scan_args(argc, argv, "01", &opts) == 1) { Check_Type(opts, T_HASH); if (rb_hash_aref(opts, sym_pretty) == Qtrue) { beautify = 1; indent = rb_hash_aref(opts, sym_indent); if (indent != Qnil) { #ifdef HAVE_RUBY_ENCODING_H indent = rb_str_export_to_enc(indent, utf8Encoding); #endif Check_Type(indent, T_STRING); indentString = (unsigned char*)malloc(RSTRING_LEN(indent)+1); memcpy(indentString, RSTRING_PTR(indent), RSTRING_LEN(indent)); indentString[RSTRING_LEN(indent)] = '\0'; actualIndent = indentString; } } if (rb_hash_aref(opts, sym_html_safe) == Qtrue) { htmlSafe = 1; } } if (!indentString) { indentString = defaultIndentString; } cfg = (yajl_gen_config){beautify, (const char *)indentString, htmlSafe}; obj = Data_Make_Struct(klass, yajl_encoder_wrapper, yajl_encoder_wrapper_mark, yajl_encoder_wrapper_free, wrapper); wrapper->indentString = actualIndent; wrapper->encoder = yajl_gen_alloc(&cfg, NULL); wrapper->on_progress_callback = Qnil; if (opts != Qnil && rb_funcall(opts, intern_has_key, 1, sym_terminator) == Qtrue) { wrapper->terminator = rb_hash_aref(opts, sym_terminator); #ifdef HAVE_RUBY_ENCODING_H if (TYPE(wrapper->terminator) == T_STRING) { wrapper->terminator = rb_str_export_to_enc(wrapper->terminator, utf8Encoding); } #endif } else { wrapper->terminator = 0; } rb_obj_call_init(obj, 0, 0); return obj; }
void reformat(ErlDrvPort port, char* buf, int len) { yajl_handle hand; /* generator config */ yajl_gen_config conf = { 1, " " }; yajl_gen g; yajl_status stat; /* allow comments */ yajl_parser_config cfg = { 1, 1 }; g = yajl_gen_alloc(&conf, NULL); /* ok. open file. let's read and parse */ hand = yajl_alloc(&callbacks, &cfg, NULL, (void *) g); /* read file data, pass to parser */ stat = yajl_parse(hand, (unsigned char*) buf, len); if (stat != yajl_status_ok && stat != yajl_status_insufficient_data) { char* err = (char*) yajl_get_error(hand, 1, (unsigned char*) buf, len); int len = strlen(err); ErlDrvTermData msg[] = { ERL_DRV_ATOM, driver_mk_atom("error"), ERL_DRV_BUF2BINARY, (ErlDrvTermData) err, (ErlDrvUInt) len, ERL_DRV_TUPLE, 2 }; driver_send_term(port, driver_caller(port), msg, sizeof(msg) / sizeof(msg[0])); } else { const unsigned char* json; unsigned int len; yajl_gen_get_buf(g, &json, &len); ErlDrvTermData msg[] = { ERL_DRV_ATOM, driver_mk_atom("ok"), ERL_DRV_BUF2BINARY, (ErlDrvTermData) json, (ErlDrvUInt) len, ERL_DRV_TUPLE, 2 }; driver_send_term(port, driver_caller(port), msg, sizeof(msg) / sizeof(msg[0])); yajl_gen_clear(g); } yajl_gen_free(g); yajl_free(hand); }
static VALUE rb_yajl_encoder_new(int argc, VALUE * argv, VALUE klass) { yajl_encoder_wrapper * wrapper; yajl_gen_config cfg; VALUE opts, obj, indent; const char * indentString = " "; int beautify = 0; int ascii_only = default_to_ascii_only == Qtrue ? 1 : 0; /* Scan off config vars */ if (rb_scan_args(argc, argv, "01", &opts) == 1) { Check_Type(opts, T_HASH); if (rb_hash_aref(opts, sym_pretty) == Qtrue) { beautify = 1; indent = rb_hash_aref(opts, sym_indent); if (indent != Qnil) { #ifdef HAVE_RUBY_ENCODING_H indent = rb_str_export_to_enc(indent, utf8Encoding); #endif Check_Type(indent, T_STRING); indentString = RSTRING_PTR(indent); } } if (rb_hash_aref(opts, sym_ascii_only) == Qtrue) { ascii_only= 1; } if (rb_hash_aref(opts, sym_ascii_only) == Qfalse) { ascii_only= 0; } } cfg = (yajl_gen_config){beautify, indentString, ascii_only}; obj = Data_Make_Struct(klass, yajl_encoder_wrapper, yajl_encoder_wrapper_mark, yajl_encoder_wrapper_free, wrapper); wrapper->encoder = yajl_gen_alloc(&cfg, NULL); wrapper->on_progress_callback = Qnil; if (opts != Qnil && rb_funcall(opts, intern_has_key, 1, sym_terminator) == Qtrue) { wrapper->terminator = rb_hash_aref(opts, sym_terminator); #ifdef HAVE_RUBY_ENCODING_H if (TYPE(wrapper->terminator) == T_STRING) { wrapper->terminator = rb_str_export_to_enc(wrapper->terminator, utf8Encoding); } #endif } else { wrapper->terminator = 0; } rb_obj_call_init(obj, 0, 0); return obj; }
static bool convert(options_t* options) { FILE* in_file; if (options->in_filename) { in_file = fopen(options->in_filename, "rb"); if (in_file == NULL) { fprintf(stderr, "%s: could not open \"%s\" for reading.\n", options->command, options->in_filename); return false; } } else { in_file = stdin; } if (options->out_filename) { out_file = fopen(options->out_filename, "wb"); if (out_file == NULL) { fprintf(stderr, "%s: could not open \"%s\" for writing.\n", options->command, options->out_filename); if (in_file != stdin) fclose(in_file); return false; } } else { out_file = stdout; } yajl_gen gen = yajl_gen_alloc(NULL); if (options->pretty) yajl_gen_config(gen, yajl_gen_beautify); if (options->debug) yajl_gen_config(gen, yajl_gen_allow_non_string_keys); yajl_gen_config(gen, yajl_gen_print_callback, print, out_file); mpack_reader_t reader; mpack_reader_init_stack(&reader); mpack_reader_set_fill(&reader, fill); mpack_reader_set_context(&reader, in_file); bool ret = element(&reader, gen, options, 0); mpack_error_t error = mpack_reader_destroy(&reader); yajl_gen_free(gen); if (out_file != stdout) fclose(out_file); if (in_file != stdin) fclose(in_file); if (!ret || error != mpack_ok) fprintf(stderr, "%s: parse error %i\n", options->command, (int)error); return ret; }
IoObject *IoYajlGen_generate(IoYajlGen *self, IoObject *locals, IoMessage *m) { const unsigned char *jsonBuffer; unsigned int jsonBufferLength; yajl_gen_get_buf(DATA(self), &jsonBuffer, &jsonBufferLength); IoSeq *out = IOSEQ(jsonBuffer, jsonBufferLength); yajl_gen_free(DATA(self)); yajl_gen_config config = { 0, "" }; IoObject_setDataPointer_(self, yajl_gen_alloc(&config, NULL)); return out; }
IoObject *IoYajlGen_generate(IoYajlGen *self, IoObject *locals, IoMessage *m) { const unsigned char *jsonBuffer; size_t jsonBufferLength; yajl_gen_get_buf(DATA(self), &jsonBuffer, &jsonBufferLength); IoSeq *out = IOSEQ(jsonBuffer, jsonBufferLength); yajl_gen_free(DATA(self)); yajl_gen yg = yajl_gen_alloc(NULL); //yajl_gen_config(yg, yajl_gen_beautify, 0); IoObject_setDataPointer_(self, yg); return out; }
static VALUE mEncoder_do_yajl_encode(VALUE self, VALUE obj, VALUE yajl_gen_opts, VALUE json_opts) { ID sym_ffi_yajl = rb_intern("ffi_yajl"); VALUE sym_yajl_gen_beautify = ID2SYM(rb_intern("yajl_gen_beautify")); VALUE sym_yajl_gen_validate_utf8 = ID2SYM(rb_intern("yajl_gen_validate_utf8")); VALUE sym_yajl_gen_indent_string = ID2SYM(rb_intern("yajl_gen_indent_string")); yajl_gen yajl_gen; const unsigned char *buf; size_t len; VALUE state; VALUE ret; VALUE indent_string; VALUE rb_yajl_gen; yajl_gen = yajl_gen_alloc(NULL); if ( rb_hash_aref(yajl_gen_opts, sym_yajl_gen_beautify) == Qtrue ) { yajl_gen_config(yajl_gen, yajl_gen_beautify, 1); } if ( rb_hash_aref(yajl_gen_opts, sym_yajl_gen_validate_utf8) == Qtrue ) { yajl_gen_config(yajl_gen, yajl_gen_validate_utf8, 1); } indent_string = rb_hash_aref(yajl_gen_opts, sym_yajl_gen_indent_string); if (indent_string != Qnil) { yajl_gen_config(yajl_gen, yajl_gen_indent_string, RSTRING_PTR(indent_string)); } else { yajl_gen_config(yajl_gen, yajl_gen_indent_string, " "); } state = rb_hash_new(); rb_hash_aset(state, rb_str_new2("processing_key"), Qfalse); rb_hash_aset(state, rb_str_new2("json_opts"), json_opts); rb_yajl_gen = Data_Wrap_Struct(cYajl_Gen, NULL, NULL, yajl_gen); rb_funcall(obj, sym_ffi_yajl, 2, rb_yajl_gen, state); yajl_gen_get_buf(yajl_gen, &buf, &len); ret = rb_str_new2((char *)buf); yajl_gen_free(yajl_gen); return ret; }
static package bf_generate_json(Var arglist, Byte next, void *vdata, Objid progr) { yajl_gen g; yajl_gen_config cfg = { 0, "" }; struct generate_context gctx; gctx.mode = MODE_COMMON_SUBSET; const char *buf; unsigned int len; Var json; package pack; if (1 < arglist.v.list[0].v.num) { if (!mystrcasecmp(arglist.v.list[2].v.str, "common-subset")) { gctx.mode = MODE_COMMON_SUBSET; } else if (!mystrcasecmp(arglist.v.list[2].v.str, "embedded-types")) { gctx.mode = MODE_EMBEDDED_TYPES; } else { free_var(arglist); return make_error_pack(E_INVARG); } } g = yajl_gen_alloc(&cfg, NULL); if (yajl_gen_status_ok == generate(g, arglist.v.list[1], &gctx)) { yajl_gen_get_buf(g, (const unsigned char **)&buf, &len); json.type = TYPE_STR; json.v.str = str_dup(buf); pack = make_var_pack(json); } else { pack = make_error_pack(E_INVARG); } yajl_gen_clear(g); yajl_gen_free(g); free_var(arglist); return pack; }
/* Encode an IB list into JSON */ ib_status_t ib_json_encode( ib_mpool_t *mpool, const ib_list_t *list, bool pretty, char **obuf, size_t *olen) { assert(mpool != NULL); assert(list != NULL); assert(obuf != NULL); yajl_gen handle; json_yajl_alloc_context_t alloc_ctx = { mpool, IB_OK }; ib_status_t rc; yajl_gen_status status; yajl_alloc_funcs alloc_fns = { json_yajl_alloc, json_yajl_realloc, json_yajl_free, &alloc_ctx }; handle = yajl_gen_alloc(&alloc_fns); /* Probably should validate the handle here, but it's not clear from the * YAJL documentation how to do that */ /* Set pretty option */ if (pretty) { int opt = yajl_gen_config(handle, yajl_gen_beautify); if (opt == 0) { return IB_EINVAL; } } rc = encode_list(handle, NULL, 0, list); if (rc != IB_OK) { return rc; } status = yajl_gen_get_buf(handle, (const unsigned char **)obuf, olen); if (status != yajl_gen_status_ok) { return IB_EUNKNOWN; } return rc; }
void rb_journalist_socket_init() { gen = yajl_gen_alloc(NULL); yajl_gen_config(gen, yajl_gen_beautify, 0); pid_t pid = getpid(); char path[1024]; snprintf( path, 1024, journalist_file_path_fmt, pid ); journalist_file = fopen(path, "w"); }
LKStreamTranslator::LKStreamTranslator(LKTranslator &translator, std::string lastPathComponent): ctx { translator, nullptr, nullptr, lastPathComponent } { callbacks.yajl_null = &LKStreamTranslator::handle_null; callbacks.yajl_boolean = &LKStreamTranslator::handle_boolean; callbacks.yajl_number = &LKStreamTranslator::handle_number; callbacks.yajl_string = &LKStreamTranslator::handle_string; callbacks.yajl_start_map = &LKStreamTranslator::handle_start_map; callbacks.yajl_map_key = &LKStreamTranslator::handle_map_key; callbacks.yajl_end_map = &LKStreamTranslator::handle_end_map; callbacks.yajl_start_array = &LKStreamTranslator::handle_start_array; callbacks.yajl_end_array = &LKStreamTranslator::handle_end_array; ctx.parser = yajl_alloc(&callbacks, NULL, &ctx); ctx.gen = yajl_gen_alloc(NULL); ctx.translator = translator; ctx.lastPathComponent = lastPathComponent; }