void SaveTab(struct MyGadget *gd) { write_integer(gd->data.tab.sel); write_integer(gd->data.tab.tabwidth); write_integer(gd->data.tab.tabheight); }
void SaveMx(struct MyGadget *gd) { write_integer(gd->data.mx.pixdiv); write_integer(gd->data.mx.sel); write_integer(gd->data.mx.align); write_string(&gd->data.mx.Label[0]); }
void SaveColor(struct MyGadget *gd) { write_integer(gd->data.col.cellsize); write_integer(gd->data.col.layout); write_integer(gd->data.col.redrawbuffer); write_color(&gd->data.col.value); }
int bencode_recursive(OutIt& out, const entry& e) { int ret = 0; switch(e.type()) { case entry::int_t: write_char(out, 'i'); ret += write_integer(out, e.integer()); write_char(out, 'e'); ret += 2; break; case entry::string_t: ret += write_integer(out, e.string().length()); write_char(out, ':'); ret += write_string(e.string(), out); ret += 1; break; case entry::list_t: write_char(out, 'l'); for (entry::list_type::const_iterator i = e.list().begin(); i != e.list().end(); ++i) ret += bencode_recursive(out, *i); write_char(out, 'e'); ret += 2; break; case entry::dictionary_t: write_char(out, 'd'); for (entry::dictionary_type::const_iterator i = e.dict().begin(); i != e.dict().end(); ++i) { // write key ret += write_integer(out, i->first.length()); write_char(out, ':'); ret += write_string(i->first, out); // write value ret += bencode_recursive(out, i->second); ret += 1; } write_char(out, 'e'); ret += 2; break; case entry::preformatted_t: std::copy(e.preformatted().begin(), e.preformatted().end(), out); ret += int(e.preformatted().size()); break; case entry::undefined_t: // empty string write_char(out, '0'); write_char(out, ':'); ret += 2; break; } return ret; }
void SaveStatus(struct MyGadget *gd) { write_integer(gd->data.sta.barheight); write_integer(gd->data.sta.maxvalue); write_integer(gd->data.sta.value); write_color(&gd->data.sta.barcolor); write_string(&gd->data.sta.Label[0]); write_string(&gd->data.sta.Trail[0]); }
int bencode_recursive(OutIt& out, const entry& e) { int ret = 0; switch(e.type()) { case entry::int_t: write_char(out, 'i'); ret += write_integer(out, e.integer()); write_char(out, 'e'); ret += 2; break; case entry::string_t: ret += write_integer(out, e.string().length()); write_char(out, ':'); ret += write_string(e.string(), out); ret += 1; break; case entry::list_t: write_char(out, 'l'); for (entry::list_type::const_iterator i = e.list().begin(); i != e.list().end(); ++i) ret += bencode_recursive(out, *i); write_char(out, 'e'); ret += 2; break; case entry::dictionary_t: write_char(out, 'd'); for (entry::dictionary_type::const_iterator i = e.dict().begin(); i != e.dict().end(); ++i) { // write key ret += write_integer(out, i->first.length()); write_char(out, ':'); ret += write_string(i->first, out); // write value ret += bencode_recursive(out, i->second); ret += 1; } write_char(out, 'e'); ret += 2; break; case entry::undefined_t: // trying to encode a structure with uninitialized values! // TORRENT_ASSERT_VAL(false, e.type()); // do nothing break; } return ret; }
static void write_blob(ID3DBlob *blob) { int size = blob ? (int)blob->GetBufferSize() : -1; write_integer(size); if (size > 0) fwrite(blob->GetBufferPointer(), size, 1, stdout); }
pfs::error_code ubjson_ostream<OStreamType, JsonType>::write_json (json_type const & j, bool with_prefix) { switch (j.type()) { case data_type::null: _os << UBJSON_CHAR_NULL; break; case data_type::boolean: _os << (j.boolean_data() ? UBJSON_CHAR_TRUE : UBJSON_CHAR_FALSE); break; case data_type::integer: return write_integer(j.integer_data(), with_prefix); case data_type::real: return write_real(j.real_data(), with_prefix); case data_type::string: return write_string(j.string_data(), with_prefix); case data_type::array: return write_array(j); case data_type::object: return write_object(j); } return pfs::error_code(); }
void SaveText(struct MyGadget *gd) { write_integer(gd->data.txt.align); write_string(&gd->data.txt.Label[0]); }
void SaveNumber(struct MyGadget *gd) { write_integer(gd->data.num.align); write_string(&gd->data.num.Label[0]); }
void SaveBbox(struct MyGadget *gd) { write_integer(gd->data.bbox.style); write_string(&gd->data.bbox.Label[0]); }
static size_t write_compact_array(json_t* array, stream_t* stream) { size_t bytes = 0; assert(json_is_array(array)); json_t* header = build_compact_array_header(array); uint8_t tag = BSER_TAG_COMPACT_ARRAY; if (stream->write(stream, &tag, SIZE_U8) == SIZE_U8) { size_t header_bytes = write_array(header, stream); if (header_bytes > 0) { size_t array_length = json_array_size(array); json_t* array_length_node = json_integer(array_length); size_t integer_size = write_integer(array_length_node, stream); if (integer_size > 0) { size_t written = write_compact_objects(array, header, stream); if (written > 0) { bytes = SIZE_U8 + header_bytes + integer_size + written; } } json_decref(array_length_node); } } json_decref(header); return bytes; }
static void write_expression(const expression_t *expression) { /* TODO */ switch(expression->kind) { case EXPR_LITERAL_INTEGER: write_integer(&expression->literal); break; case EXPR_ENUM_CONSTANT: { /* UHOH... hacking */ entity_t *entity = expression->reference.entity; write_enum_name(entity->enum_value.enume); fprintf(out, ".%s.val", entity->base.symbol->string); break; } case EXPR_UNARY_CASES: write_unary_expression(&expression->unary); break; case EXPR_BINARY_CASES: write_binary_expression(&expression->binary); break; default: panic("not implemented expression"); } }
static int unpack_field(int ctype, int ptype, char * buffer, struct atom * a, void *out) { if (ctype == CTYPE_ARRAY) { return unpack_array(ptype, buffer, a , out); } if (ctype == CTYPE_PACKED) { pbc_ctx packed; struct context * ctx = (struct context *)packed; int n = _pbcC_open_packed(packed , ptype, (uint8_t *)buffer + a->v.s.start, a->v.s.end - a->v.s.start); if (n<=0) return -1; int i; int r =0; for (i=0;i<n;i++) { r |= unpack_array(ptype , buffer , &(ctx->a[i]) , out); } if (r) return -1; return 0; } switch(ptype) { case PTYPE_DOUBLE: return write_real(ctype, read_double(a), out); case PTYPE_FLOAT: return write_real(ctype, read_float(a), out); case PTYPE_INT64: case PTYPE_UINT64: case PTYPE_INT32: case PTYPE_UINT32: case PTYPE_FIXED32: case PTYPE_FIXED64: case PTYPE_SFIXED32: case PTYPE_SFIXED64: case PTYPE_ENUM: // enum must be integer type in pattern mode case PTYPE_BOOL: return write_integer(ctype, a , out); case PTYPE_SINT32: { struct longlong temp = a->v.i; varint_dezigzag32(&temp); return write_longlong(ctype, &temp , out); } case PTYPE_SINT64: { struct longlong temp = a->v.i; varint_dezigzag64(&temp); return write_longlong(ctype, &temp , out); } case PTYPE_MESSAGE: ((union _pbc_var *)out)->m.buffer = buffer + a->v.s.start; ((union _pbc_var *)out)->m.len = a->v.s.end - a->v.s.start; return 0; case PTYPE_STRING: ((union _pbc_var *)out)->s.str = buffer + a->v.s.start; ((union _pbc_var *)out)->s.len = a->v.s.end - a->v.s.start; return 0; } return -1; }
int bencode_recursive(OutIt& out, const entry& e) { int ret = 0; switch(e.type()) { case entry::int_t: write_char(out, 'i'); ret += write_integer(out, e.integer()); write_char(out, 'e'); ret += 2; break; case entry::string_t: ret += write_integer(out, e.string().length()); write_char(out, ':'); ret += write_string(out, e.string()); ret += 1; break; case entry::list_t: write_char(out, 'l'); for (entry::list_type::const_iterator i = e.list().begin(); i != e.list().end(); ++i) ret += bencode_recursive(out, *i); write_char(out, 'e'); ret += 2; break; case entry::dictionary_t: write_char(out, 'd'); for (entry::dictionary_type::const_iterator i = e.dict().begin(); i != e.dict().end(); ++i) { // write key ret += write_integer(out, i->first.length()); write_char(out, ':'); ret += write_string(out, i->first); // write value ret += bencode_recursive(out, i->second); ret += 1; } write_char(out, 'e'); ret += 2; break; default: // do nothing break; } return ret; }
// write one stroke to file system unsigned char write_stroke (FILE * file, PtrStroke stroke) { if (file == NULL || stroke == NULL || stroke->nPoints == 0) { return 0; } //write pen size if ( !write_integer(stroke->iPenSize,file,WRITEINT_LINEEND) ) { SB_INKERRPRINTF("write failed, iPenSize= %d \n",stroke->iPenSize); return 0; } //write rgb if ( !write_rgb(&stroke->gdkColor,file) ) { SB_INKERRPRINTF("failed write rgb\n"); return 0; } if ( !write_integer(stroke->nPoints,file,WRITEINT_LINEEND) ) { SB_INKERRPRINTF("write failed, nPoints= %d \n",stroke->nPoints); return 0; } SB_INKPRINTF("stroke->nPoints=%d \n", stroke->nPoints); PtrInkPoint point = stroke->firstPoint; while (point) { if ( !write_integer(point->x, file, WRITEINT_2SPACES) ) { SB_INKERRPRINTF("fwrite failed, point->x= %d \n", point->x); return 0; } if ( !write_integer(point->y, file, WRITEINT_LINEEND) ) { SB_INKERRPRINTF("fwrite failed, point->y= %d \n", point->y); return 0; } SB_INKPRINTF("point(%d,%d) \n", point->x, point->y); point = point->nextPoint; } return 1; }
void SaveEdit(struct MyGadget *gd) { write_integer(gd->data.edi.tabwidth); write_integer(gd->data.edi.align); write_integer(gd->data.edi.maxchars); write_integer(gd->data.edi.editable); write_integer(gd->data.edi.stylable); write_integer(gd->data.edi.selectable); write_integer(gd->data.edi.autoident); write_integer(gd->data.edi.wordwrap); }
void SaveScroller(struct MyGadget *gd) { write_integer(gd->data.bscroller.min); write_integer(gd->data.bscroller.max); write_integer(gd->data.bscroller.minrange); write_integer(gd->data.bscroller.maxrange); write_integer(gd->data.bscroller.setprop); write_integer(gd->data.bscroller.pos); write_integer(gd->data.bscroller.minstep); write_integer(gd->data.bscroller.maxstep); }
pfs::error_code ubjson_ostream<OStreamType, JsonType>::write_string (string_type const & s, bool with_prefix) { if (with_prefix) { // Using size is safe here (no matter the string encoding) if (s.size() == 1 && *s.cbegin() <= numeric_limits<int8_t>::max()) { _os << static_cast<int8_t>('C'); _os << static_cast<int8_t>(*s.cbegin()); } else { _os << static_cast<int8_t>('S'); write_integer(static_cast<typename json_type::integer_type>(s.size()), true); _os << s.utf8(); } } else { write_integer(static_cast<typename json_type::integer_type>(s.size()), true); _os << s; } return pfs::error_code(); }
pfs::error_code ubjson_ostream<OStreamType, JsonType>::write_array (json_type const & j) { _os << UBJSON_CHAR_ARRAY_BEGIN; bool use_count_optimization = ((_flags & count_optimized) && !j.empty()); bool is_special_case = false; // If a type is specified, a count must also be specified. // A type cannot be specified by itself. bool use_type_optimization = ((_flags & type_optimized) && use_count_optimization); // Additional checks for type optimization if (use_type_optimization) { // This call is safe. Array is not empty as checked before int8_t first_prefix = prefix(*j.cbegin()); use_type_optimization = pfs::all_of(j.cbegin() , j.cend() , compare_prefix(first_prefix)); if (use_type_optimization) { _os << UBJSON_CHAR_TYPE; _os << first_prefix; // Check special cases if (first_prefix == UBJSON_CHAR_NOOP || first_prefix == UBJSON_CHAR_NULL || first_prefix == UBJSON_CHAR_TRUE || first_prefix == UBJSON_CHAR_FALSE) { is_special_case = true; } } } if (use_count_optimization) { _os << UBJSON_CHAR_SIZE; write_integer(static_cast<typename json_type::integer_type>(j.size()), true); } // Ignore special cases: strongly-typed arrays of null, no-op and boolean values if (! is_special_case) { typename json_type::const_iterator first = j.cbegin(); typename json_type::const_iterator last = j.cend(); for (; first != last; ++first) write_json(*first, !use_type_optimization); } // If a count is specified the container must not specify an end-marker. if (!use_count_optimization) _os << UBJSON_CHAR_ARRAY_END; return pfs::error_code(); }
//write the rgb value in gdkcolor unsigned char write_rgb(GdkColor *pGdkColor, FILE * file) { if ( !write_integer(pGdkColor->red, file, WRITEINT_2SPACES) ) { SB_INKERRPRINTF("failed, pGdkColor->red= %d \n", pGdkColor->red); return 0; } if ( !write_integer(pGdkColor->green, file, WRITEINT_2SPACES) ) { SB_INKERRPRINTF("failed, pGdkColor->green= %d \n", pGdkColor->green); return 0; } if ( !write_integer(pGdkColor->blue, file, WRITEINT_LINEEND) ) { SB_INKERRPRINTF("failed, pGdkColor->blue= %d \n", pGdkColor->blue); return 0; } SB_INKPRINTF("rgb(%d,%d,%d) \n", pGdkColor->red, pGdkColor->green,pGdkColor->blue); return 1; }
void bencode_recursive(OutIt& out, const entry& e) { switch(e.type()) { case entry::int_t: write_char(out, 'i'); write_integer(out, e.integer()); write_char(out, 'e'); break; case entry::string_t: write_integer(out, e.string().length()); write_char(out, ':'); write_string(out, e.string()); break; case entry::list_t: write_char(out, 'l'); for (entry::list_type::const_iterator i = e.list().begin(); i != e.list().end(); ++i) bencode_recursive(out, *i); write_char(out, 'e'); break; case entry::dictionary_t: write_char(out, 'd'); for (entry::dictionary_type::const_iterator i = e.dict().begin(); i != e.dict().end(); ++i) { // write key write_integer(out, i->first.length()); write_char(out, ':'); write_string(out, i->first); // write value bencode_recursive(out, i->second); } write_char(out, 'e'); break; default: throw invalid_encoding(); } }
void SaveSlider(struct MyGadget *gd) { write_integer(gd->data.bslider.min); write_integer(gd->data.bslider.max); write_integer(gd->data.bslider.pos); write_integer(gd->data.bslider.style); write_integer(gd->data.bslider.hashtype); write_integer(gd->data.bslider.hashcount); write_integer(gd->data.bslider.thickness); write_integer(gd->data.bslider.keyinc); write_integer(gd->data.bslider.fillall); write_color(&gd->data.bslider.fillcolor); write_color(&gd->data.bslider.barcolor); write_string(&gd->data.bslider.Label[0]); write_string(&gd->data.bslider.MinLabel[0]); write_string(&gd->data.bslider.MaxLabel[0]); }
static size_t write_json(json_t* json, stream_t* stream) { switch (json_typeof(json)) { case JSON_OBJECT: return write_object(json, stream); case JSON_ARRAY: return write_array(json, stream); case JSON_STRING: return write_string(json, stream); case JSON_INTEGER: return write_integer(json, stream); case JSON_REAL: return write_real(json, stream); case JSON_TRUE: return write_true(json, stream); case JSON_FALSE: return write_false(json, stream); case JSON_NULL: return write_null(json, stream); default: return 0; } }
static size_t write_object(json_t* json, stream_t* stream) { uint8_t tag = BSER_TAG_OBJECT; size_t bytes = 0; assert(json_is_object(json)); if (stream->write(stream, &tag, SIZE_U8) == SIZE_U8) { size_t total_bytes = SIZE_U8; json_t* length_node = json_integer(json_object_size(json)); size_t integer_length = write_integer(length_node, stream); total_bytes += integer_length; json_decref(length_node); if (integer_length > 0) { size_t val_bytes = 1; void *iter = json_object_iter(json); while (iter != NULL && val_bytes > 0) { val_bytes = 0; json_t* key_node = json_string(json_object_iter_key(iter)); size_t key_bytes = write_string(key_node, stream); total_bytes += key_bytes; json_decref(key_node); if (key_bytes > 0) { json_t* value = json_object_iter_value(iter); val_bytes = write_json(value, stream); total_bytes += val_bytes; } iter = json_object_iter_next(json, iter); } if (iter == NULL) { bytes = total_bytes; } } } return bytes; }
static void list_formatted_write_scalar (st_parameter_dt *dtp, bt type, void *p, int kind, size_t size) { if (dtp->u.p.current_unit == NULL) return; if (dtp->u.p.first_item) { dtp->u.p.first_item = 0; write_char (dtp, ' '); } else { if (type != BT_CHARACTER || !dtp->u.p.char_flag || dtp->u.p.current_unit->delim_status != DELIM_NONE) write_separator (dtp); } switch (type) { case BT_INTEGER: write_integer (dtp, p, kind); break; case BT_LOGICAL: write_logical (dtp, p, kind); break; case BT_CHARACTER: write_character (dtp, p, kind, size); break; case BT_REAL: write_real (dtp, p, kind); break; case BT_COMPLEX: write_complex (dtp, p, kind, size); break; default: internal_error (&dtp->common, "list_formatted_write(): Bad type"); } dtp->u.p.char_flag = (type == BT_CHARACTER); }
static size_t write_string(json_t* json, stream_t* stream) { size_t bytes = 0; assert(json_is_string(json)); const char* chars = json_string_value(json); size_t len = strlen(chars); uint8_t tag = BSER_TAG_STRING; if (stream->write(stream, &tag, SIZE_U8) == SIZE_U8) { json_t* length_node = json_integer(len); size_t len_bytes = write_integer(length_node, stream); json_decref(length_node); if (len_bytes > 0 && stream->write(stream, chars, len) == len) { bytes = SIZE_U8 + len_bytes + len; } } return bytes; }
// write ink object to file stream unsigned char write_ink (PtrInk ink, FILE * file) { PtrStroke stroke; if (ink == NULL || file == NULL ) { SB_INKPRINTF("failed:incorrect arguments\n"); return 0; } if (ink->nStrokes == 0) { SB_INKPRINTF("return:ink->nStrokes=0 \n"); return 0; } if ( 0!= fseek (file, 0, SEEK_SET) ) { SB_INKERRPRINTF("fseek failed \n"); return 0; } if ( !write_integer (ink->nStrokes, file,WRITEINT_LINEEND) ) { SB_INKERRPRINTF("failed writing ink->nStrokes=%d \n", ink->nStrokes); return 0; } SB_INKPRINTF("ink=%p, ink->nStrokes=%d \n", ink, ink->nStrokes); stroke = ink->firstStroke; while (stroke) { if (0 ==write_stroke (file, stroke) ) { SB_INKERRPRINTF("write_stroke failed \n"); return 0; } stroke = stroke->nextStroke; } SB_INKPRINTF("succeeded \n"); return 1; }
static size_t write_array(json_t* json, stream_t* stream) { size_t bytes = 0; if (can_be_compact_array(json)) { bytes = write_compact_array(json, stream); } else { uint8_t tag = BSER_TAG_ARRAY; if (stream->write(stream, &tag, SIZE_U8) == SIZE_U8) { size_t int_bytes; size_t length = json_array_size(json); json_t* length_node = json_integer(length); int_bytes = write_integer(length_node, stream); json_decref(length_node); if (int_bytes > 0) { int i; size_t elem_bytes = 1; size_t elems_bytes = 0; for (i = 0; i < length && elem_bytes > 0; ++i) { elem_bytes = write_json(json_array_get(json, i), stream); elems_bytes += elem_bytes; } if (i == length) { bytes = SIZE_U8 + int_bytes + elems_bytes; } } } } return bytes; }
void SaveString(struct MyGadget *gd) { write_integer(gd->data.string.editable); write_integer(gd->data.string.selectable); write_integer(gd->data.string.maxchars); write_integer(gd->data.string.pixdeb); write_integer(gd->data.string.pixdiv); write_integer(gd->data.string.value); write_integer(gd->data.string.aligntxt); write_integer(gd->data.string.alignlab); write_integer(gd->data.string.acceptvir); write_integer(gd->data.string.negvalue); write_integer(gd->data.string.car); write_string(&gd->data.string.Text[0]); }