void MolCatalogEntry::initFromStream(std::istream &ss) { delete dp_mol; dp_mol = nullptr; delete dp_props; dp_props = nullptr; // the molecule: dp_mol = new ROMol(); MolPickler::molFromPickle(ss, *const_cast<ROMol *>(dp_mol)); dp_props = new Dict(); boost::int32_t tmpInt; // the bitId: streamRead(ss, tmpInt); setBitId(tmpInt); // the order: streamRead(ss, tmpInt); setOrder(tmpInt); // the description: streamRead(ss, tmpInt); auto *tmpText = new char[tmpInt + 1]; ss.read(tmpText, tmpInt * sizeof(char)); tmpText[tmpInt] = 0; d_descrip = tmpText; delete[] tmpText; }
/* Documentation from Andrew's code on the structure of the arena: The 'AREN'a starts with a header: <num_bytes: 4 bytes> -- the number of bytes in a fingerprint <storage_size: 4 bytes> -- number of bytes in fingerprint + extra bytes <spacer_size: 1 byte> -- the number of spacer bytes used so the fingerprint chunk starts on an aligned file position. <spacer : $spacer_size> NUL bytes> -- up to 255 NUL bytes, used for alignment. The fingerprints are N fingerprint fields, ordered sequentially. <fp0: $storage_size bytes> -- the first fingerprint <fp1: $storage_size bytes> -- the second fingerprint ... The last fingerprint ends at the last byte of the arena chunk. Each fingerprint contains: <fingerprint: $num_bytes bytes> -- the actual fingerprint data <extra: $storage_size-$num_bytes bytes> -- the 'extra' NULL padding bytes used so storage_size is a multiple of the alignment. To get the number of fingerprints in the arena: (len(arena content) - 4 - 4 - 1 - $spacer_size) // $storage_size */ void extractArenaDetails(FPBReader_impl *dp_impl, boost::uint64_t sz) { PRECONDITION(dp_impl, "bad pointer"); PRECONDITION(dp_impl->df_lazy, "should only be used in lazy mode"); boost::uint32_t numBytesPerFingerprint; streamRead(*dp_impl->istrm, numBytesPerFingerprint); dp_impl->nBits = numBytesPerFingerprint * 8; boost::uint32_t numBytesStoredPerFingerprint; streamRead(*dp_impl->istrm, numBytesStoredPerFingerprint); dp_impl->numBytesStoredPerFingerprint = numBytesStoredPerFingerprint; boost::uint8_t spacer; streamRead(*dp_impl->istrm, spacer); dp_impl->len = (sz - 9 - spacer) / numBytesStoredPerFingerprint; // streamRead(*dp_impl->istrm, spacer); // now move forward the length of the spacer if (spacer) dp_impl->istrm->seekg(static_cast<std::streamoff>(spacer), std::ios_base::cur); dp_impl->fpDataOffset = dp_impl->istrm->tellg(); dp_impl->istrm->seekg( static_cast<std::streamoff>(numBytesStoredPerFingerprint * dp_impl->len), std::ios_base::cur); }
// NOTE: if the reaction passed in here already has reactants and products // be left intact. void ReactionPickler::reactionFromPickle(std::istream &ss, ChemicalReaction *rxn) { PRECONDITION(rxn, "empty reaction"); Tags tag; int32_t tmpInt; streamRead(ss, tmpInt); if (tmpInt != endianId) { throw ReactionPicklerException( "Bad pickle format: bad endian ID or invalid file format"); } streamRead(ss, tag); if (tag != VERSION) { throw ReactionPicklerException("Bad pickle format: no version tag"); } int32_t majorVersion, minorVersion, patchVersion; streamRead(ss, majorVersion); streamRead(ss, minorVersion); streamRead(ss, patchVersion); if (majorVersion > versionMajor || (majorVersion == versionMajor && minorVersion > versionMinor)) { BOOST_LOG(rdWarningLog) << "Depickling from a version number (" << majorVersion << "." << minorVersion << ")" << "that is higher than our version (" << versionMajor << "." << versionMinor << ").\nThis probably won't work." << std::endl; } majorVersion = 1000 * majorVersion + minorVersion * 10 + patchVersion; _depickle(ss, rxn, majorVersion); }
void UniformGrid3D::initFromText(const char *pkl,const unsigned int length){ std::stringstream ss(std::ios_base::binary|std::ios_base::in|std::ios_base::out); ss.write(pkl,length); boost::int32_t tVers; streamRead(ss,tVers); tVers *= -1; if(tVers==0x1){ } else { throw ValueErrorException("bad version in UniformGrid3D pickle"); } boost::uint32_t tInt; streamRead(ss,tInt); d_numX=tInt; streamRead(ss,tInt); d_numY=tInt; streamRead(ss,tInt); d_numZ=tInt; streamRead(ss,d_spacing); double oX,oY,oZ; streamRead(ss,oX); streamRead(ss,oY); streamRead(ss,oZ); d_offSet = Point3D(oX,oY,oZ); boost::uint32_t pklSz; streamRead(ss,pklSz); char *buff = new char[pklSz]; ss.read(buff,pklSz*sizeof(char)); if(dp_storage) delete dp_storage; dp_storage = new RDKit::DiscreteValueVect(buff,pklSz); delete [] buff; }
/* Documentation from Andrew's code on the structure of the arena: The actual layout inside of the chunk is: <num_4byte_elements: 4 bytes> -- the number of 4 byte offsets. <num_8byte_elements: 4 bytes> -- the number of 8 byte offsets Note: the number of indicies is num_4byte_elements + num_8byte_elements + 1 because even with no elements there will be the initial '\0\0\0\0'. <id 0> + NUL -- the first string, with an added NUL terminator <id 1> + NUL -- the second string, with an added NUL terminator .... <id N> + NUL -- the last string, with an added NUL terminator <offset 0: 4 bytes> -- the offset relative to the start of <text 0>. (This always contains the 4 bytes "\0\0\0\0") ... <offset num_4byte_elements: 4 bytes> -- the last offset stored in 4 bytes (Note: This next section exists only when <num 8 byte offsets> > 0) <offset num_4byte_elements+1: 8 bytes> -- the first offset stored in 8 bytes ... <offset num_4byte_elements+num_8byte_elements: 8 bytes> -- the last offset stored in 8 bytes To get the identifier for record at position P >= 0: chunk_size = size of the chunk num_4byte_elements = decode bytes[0:4] as uint32 num_8byte_elements = decode bytes[4:8] as uint32 if P >= num_4byte_elements + num_8byte_elements: record does not exist offset_start = chunk_size - num_4byte_elements*4 - num_8byte_elements*8 if P < num_4byte_elements: start, end = decode bytes[offset_start:offset_start+8] as (uint32, uint32) elif P == N4: start, end = decode bytes[offset_start:offset_start+12] as (uint32, uint64) else: start, end = decode bytes[offset_start:offset_start+16] as (uint64, uint64) id = bytes[start:end-1] */ void extractIdsDetails(FPBReader_impl *dp_impl, boost::uint64_t sz) { PRECONDITION(dp_impl, "bad pointer"); std::streampos start = dp_impl->istrm->tellg(); dp_impl->idChunkOffset = start; streamRead(*dp_impl->istrm, dp_impl->num4ByteElements); streamRead(*dp_impl->istrm, dp_impl->num8ByteElements); dp_impl->idDataOffset = static_cast<boost::uint64_t>(start) + sz - (dp_impl->num4ByteElements + 1) * 4 - dp_impl->num8ByteElements * 8; dp_impl->istrm->seekg(start + static_cast<std::streampos>(sz), std::ios_base::beg); };
void readByteString(GsfInput* stream, char*& str, UT_uint16* aLength) throw(UT_Error) { UT_uint16 length; str = NULL; streamRead(stream, length); str = new char[length + 1]; if (length) streamRead(stream, str, length); str[length] = 0; if (aLength) *aLength = length; }
/** * Read block from backing ciphertext file, decrypt it (normal mode) * or * Read block from backing plaintext file, then encrypt it (reverse mode) */ ssize_t CipherFileIO::readOneBlock(const IORequest &req) const { int bs = blockSize(); off_t blockNum = req.offset / bs; ssize_t readSize = 0; IORequest tmpReq = req; // adjust offset if we have a file header if (haveHeader && !fsConfig->reverseEncryption) { tmpReq.offset += HEADER_SIZE; } readSize = base->read(tmpReq); bool ok; if (readSize > 0) { if (haveHeader && fileIV == 0) const_cast<CipherFileIO *>(this)->initHeader(); if (readSize != bs) { rDebug("streamRead(data, %d, IV)", (int)readSize); ok = streamRead(tmpReq.data, (int)readSize, blockNum ^ fileIV); } else { ok = blockRead(tmpReq.data, (int)readSize, blockNum ^ fileIV); } if (!ok) { rDebug("decodeBlock failed for block %" PRIi64 ", size %i", blockNum, (int)readSize); readSize = -1; } } else rDebug("readSize zero for offset %" PRIi64, req.offset); return readSize; }
/** * @brief Reads a whole line from the input channel. * @note Input chars are echoed on the same stream object with the * following exceptions: * - DEL and BS are echoed as BS-SPACE-BS. * - CR is echoed as CR-LF. * - 0x4 is echoed as "^D". * - Other values below 0x20 are not echoed. * . * * @param[in] chp pointer to a @p BaseSequentialStream object * @param[in] line pointer to the line buffer * @param[in] size buffer maximum length * @return The operation status. * @retval true the channel was reset or CTRL-D pressed. * @retval false operation successful. * * @api */ bool shellGetLine(BaseSequentialStream *chp, char *line, unsigned size) { char *p = line; while (true) { char c; if (streamRead(chp, (uint8_t *)&c, 1) == 0) return true; if (c == 4) { chprintf(chp, "^D"); return true; } if ((c == 8) || (c == 127)) { if (p != line) { streamPut(chp, c); streamPut(chp, 0x20); streamPut(chp, c); p--; } continue; } if (c == '\r') { chprintf(chp, "\r\n"); *p = 0; return false; } if (c < 0x20) continue; if (p < line + size - 1) { streamPut(chp, c); *p++ = (char)c; } } }
void SimPlanet::unpackUpdate(Net::GhostManager *, BitStream *stream) { streamRead(*stream); stream->read(&planet.size); stream->read(&planet.distance); if (manager) load(); }
// the caller is responsible for calling delete[] on `data` void readChunkDetails(std::istream &istrm, std::string &nm, boost::uint64_t &sz) { streamRead(istrm, sz); char tag[tagNameSize + 1]; tag[tagNameSize] = 0; istrm.read(tag, tagNameSize); nm = tag; }
void TransformCatalogEntry::initFromStream(std::istream &ss) { // the reaction: dp_transform = new ChemicalReaction(); ReactionPickler::reactionFromPickle(ss, *dp_transform); std::int32_t tmpInt; // the bitId: streamRead(ss, tmpInt); setBitId(tmpInt); // the description: streamRead(ss, tmpInt); char *tmpText = new char[tmpInt + 1]; ss.read(tmpText, tmpInt * sizeof(char)); tmpText[tmpInt] = 0; d_descrip = tmpText; delete[] tmpText; }
void NodeDataInterface::streamToOutput(AbstractWriteFacet &write_to_storeentity) { static char readBuffer[4096]; size_t bytesRead; openStream(); while((bytesRead = streamRead(readBuffer, 4096)) > 0){ write_to_storeentity(readBuffer, bytesRead); } closeStream(); }
void FragmentCatalogEntry::initFromStream(std::istream &ss) { // the molecule: dp_mol = new ROMol(); MolPickler::molFromPickle(ss, *dp_mol); boost::int32_t tmpInt; // the bitId: streamRead(ss, tmpInt); setBitId(tmpInt); // the description: streamRead(ss, tmpInt); char *tmpText = new char[tmpInt + 1]; ss.read(tmpText, tmpInt * sizeof(char)); tmpText[tmpInt] = 0; d_descrip = tmpText; delete[] tmpText; }
static THD_FUNCTION(net_rx1_thd, arg) { if_list[1].arg = arg; serial_datagram_rcv_handler_init(&port1_rx, port1_rx_buf, sizeof(port1_rx_buf), serial_datagram_rx_cb, &port_1_if_idx); while (1) { uint8_t buf; size_t len = streamRead((BaseSequentialStream*)arg, &buf, 1); serial_datagram_receive(&port1_rx, &buf, len); if (len == 0) { chThdSleepMilliseconds(10); // queue is probably reset, avoid busy loop } } }
Persistent::Base::Error SimPlanet::read(StreamIO &sio, int version, int b) { Persistent::Base::Error error = SimNetObject::read(sio, version, b); if (error != Persistent::Base::Ok) return error; streamRead(sio); if (version == CurrentVersion) { sio.read(&planet.size); sio.read(&planet.distance); } return (sio.getStatus() == STRM_OK) ? Ok : ReadError; }
void InputStream::streamReadAll (VoidBuffer buf) { static const int step = 256; int nb = step; int offset = 0; buf.realloc(step); while (nb) { nb = streamRead(buf + offset); if (nb) { offset += nb; buf.grow (nb); } } buf.reduce(step); }
void IE_Imp_StarOffice::readRecSize(GsfInput* aStream, UT_uint32& aSize, gsf_off_t* aEOR) throw(UT_Error) { // Yes, that's correct, only 3 bytes. guint8 buf [3]; aSize = 0; streamRead(aStream, buf, 3); // buf content is little endian. aSize = buf [0] | (buf[1] << 8) | (buf [2] << 16); aSize -= 4; // Substract 4 for the rec type + size if (aSize == 0xFFFFFF && mDocHdr.nVersion >= SWG_LONGRECS) { // XXX need recsizes from header, see above UT_ASSERT_HARMLESS(UT_NOT_IMPLEMENTED); } if (aEOR) *aEOR = gsf_input_tell(aStream) + aSize; }
/** * @brief Reads a whole line from the input channel. * @note Input chars are echoed on the same stream object with the * following exceptions: * - DEL and BS are echoed as BS-SPACE-BS. * - CR is echoed as CR-LF. * - 0x4 is echoed as "^D". * - Other values below 0x20 are not echoed. * . * * @param[in] chp pointer to a @p BaseSequentialStream object * @param[in] line pointer to the line buffer * @param[in] size buffer maximum length * @return The operation status. * @retval true the channel was reset or CTRL-D pressed. * @retval false operation successful. * * @api */ bool shellGetLine(BaseSequentialStream *chp, char *line, unsigned size) { char *p = line; while (true) { char c; if (streamRead(chp, (uint8_t *)&c, 1) == 0) return true; #if (SHELL_CMD_EXIT_ENABLED == TRUE) && !defined(_CHIBIOS_NIL_) if (c == 4) { chprintf(chp, "^D"); return true; } #endif if ((c == 8) || (c == 127)) { if (p != line) { streamPut(chp, c); streamPut(chp, 0x20); streamPut(chp, c); p--; } continue; } if (c == '\r') { chprintf(chp, "\r\n"); *p = 0; return false; } if (c < 0x20) continue; if (p < line + size - 1) { streamPut(chp, c); *p++ = (char)c; } } }
void FragCatalogEntry::initFromStream(std::istream &ss) { // the molecule: dp_mol = new ROMol(); MolPickler::molFromPickle(ss, *dp_mol); std::int32_t tmpInt; // the bitId: streamRead(ss, tmpInt); setBitId(tmpInt); // the description: streamRead(ss, tmpInt); auto *tmpText = new char[tmpInt + 1]; ss.read(tmpText, tmpInt * sizeof(char)); tmpText[tmpInt] = 0; d_descrip = tmpText; delete[] tmpText; streamRead(ss, tmpInt); d_order = tmpInt; // now the map: streamRead(ss, tmpInt); for (int i = 0; i < tmpInt; i++) { std::int32_t key, value, size; streamRead(ss, key); streamRead(ss, size); INT_VECT tmpVect; tmpVect.clear(); for (int j = 0; j < size; j++) { streamRead(ss, value); tmpVect.push_back(value); } d_aToFmap[key] = tmpVect; } }
void DiscreteValueVect::initFromText(const char *pkl,const unsigned int len){ std::stringstream ss(std::ios_base::binary|std::ios_base::in|std::ios_base::out); ss.write(pkl,len); boost::int32_t tVers; streamRead(ss,tVers); tVers *= -1; if(tVers==0x1){ } else { throw ValueErrorException("bad version in DiscreteValueVect pickle"); } boost::uint32_t tInt; streamRead(ss,tInt); d_type=static_cast<DiscreteValueType>(tInt); streamRead(ss,tInt); d_bitsPerVal=tInt; d_valsPerInt = BITS_PER_INT/d_bitsPerVal; streamRead(ss,tInt); d_mask=tInt; streamRead(ss,tInt); d_length=tInt; streamRead(ss,tInt); d_numInts=tInt; boost::uint32_t *data = new boost::uint32_t[d_numInts]; ss.read((char *)data,d_numInts*sizeof(boost::uint32_t)); #if defined(BOOST_BIG_ENDIAN) boost::uint32_t *td = new boost::uint32_t[d_numInts]; for(unsigned int i=0;i<d_numInts;++i) td[i]=EndianSwapBytes<LITTLE_ENDIAN_ORDER,HOST_ENDIAN_ORDER>(data[i]); d_data.reset(td); delete [] data; #else d_data.reset(data); #endif };
UT_Error IE_Imp_StarOffice::_loadFile(GsfInput * input) { try { UT_DEBUGMSG(("SDW: Starting import\n")); mOle = GSF_INFILE (gsf_infile_msole_new(input, NULL)); if (!mOle) return UT_IE_BOGUSDOCUMENT; // firstly, load metadata SDWDocInfo::load(mOle, getDoc()); mDocStream = gsf_infile_child_by_name(mOle, "StarWriterDocument"); if (!mDocStream) return UT_IE_BOGUSDOCUMENT; gsf_off_t size = gsf_input_size(mDocStream); if (!appendStrux(PTX_Section, PP_NOPROPS)) return UT_IE_NOMEMORY; UT_DEBUGMSG(("SDW: Attempting to load DocHdr...\n")); mDocHdr.load(mDocStream); UT_DEBUGMSG(("SDW: ...success\n")); // Ask for and verify the password if (mDocHdr.cryptor) { if (!mDocHdr.cryptor->SetPassword(GetPassword().c_str())) { UT_DEBUGMSG(("SDW: Wrong password\n")); return UT_IE_PROTECTED; } } // do the actual reading char type; bool done = false; UT_uint32 recSize; while (!done) { if (gsf_input_tell(mDocStream) == size) break; readChar(mDocStream, type); gsf_off_t eor; readRecSize(mDocStream, recSize, &eor); switch (type) { case SWG_CONTENTS: { gsf_off_t flagsEnd = 0; UT_uint32 nNodes; // sw/source/core/sw3io/sw3sectn.cxx#L129 if (mDocHdr.nVersion >= SWG_LAYFRAMES) { UT_uint8 flags; readFlagRec(mDocStream, flags, &flagsEnd); } if (mDocHdr.nVersion >= SWG_LONGIDX) streamRead(mDocStream, nNodes); else { if (mDocHdr.nVersion >= SWG_LAYFRAMES) { UT_uint16 sectidDummy; streamRead(mDocStream, sectidDummy); } UT_uint16 nodes16; streamRead(mDocStream, nodes16); nNodes = (UT_uint32)nodes16; } if (flagsEnd) { UT_ASSERT(flagsEnd >= gsf_input_tell(mDocStream)); if (gsf_input_tell(mDocStream) != flagsEnd) { UT_DEBUGMSG(("SDW: have not read all flags\n")); if (gsf_input_seek(mDocStream, flagsEnd, G_SEEK_SET)) return UT_IE_BOGUSDOCUMENT; } } bool done2 = false; UT_uint32 size2; while (!done2) { readChar(mDocStream, type); gsf_off_t eor2; readRecSize(mDocStream, size2, &eor2); switch (type) { case SWG_TEXTNODE: { // sw/source/core/sw3io/sw3nodes.cxx#L788 UT_DEBUGMSG(("SDW: Found Textnode! (start at 0x%08llX end at 0x%08llX)\n", (long long)gsf_input_tell(mDocStream), (long long)eor2)); UT_uint8 flags; gsf_off_t newPos; readFlagRec(mDocStream, flags, &newPos); // XXX check flags if (gsf_input_seek(mDocStream, newPos, G_SEEK_SET)) return UT_IE_BOGUSDOCUMENT; // Read the actual text UT_UCS4Char* str; readByteString(mDocStream, str); UT_UCS4String textNode(str); free(str); UT_DEBUGMSG(("SDW: ...length=%zu contents are: |%s|\n", textNode.length(), textNode.utf8_str())); // now get the attributes UT_String attrs; UT_String pAttrs; UT_Vector charAttributes; while (gsf_input_tell(mDocStream) < eor2) { char attVal; streamRead(mDocStream, attVal); UT_uint32 attSize; gsf_off_t eoa; // end of attribute readRecSize(mDocStream, attSize, &eoa); if (attVal == SWG_ATTRIBUTE) { TextAttr* a = new TextAttr; streamRead(mDocStream, *a, eoa); UT_DEBUGMSG(("SDW: ...found text-sub-node, which=0x%x, ver=0x%x, start=%u, end=%u - data:%s len:%llu data is:", a->which, a->ver, a->start, a->end, a->data?"Yes":"No", (long long unsigned)a->dataLen)); #ifdef DEBUG hexdump(a->data, a->dataLen); putc('\n', stderr); #endif charAttributes.addItem(a); } else if (attVal == SWG_ATTRSET) { // bah, yet another loop UT_DEBUGMSG(("SDW: ...paragraph attributes found\n")); while (gsf_input_tell(mDocStream) < eoa) { // reusing attVal and attSize streamRead(mDocStream, attVal); gsf_off_t eoa2; // end of attribute readRecSize(mDocStream, attSize, &eoa2); if (attVal == SWG_ATTRIBUTE) { TextAttr a; streamRead(mDocStream, a, eoa2); if (!a.attrVal.empty()) { if (a.isPara) UT_String_setProperty(pAttrs, a.attrName, a.attrVal); else UT_String_setProperty(attrs, a.attrName, a.attrVal); } UT_DEBUGMSG(("SDW: ......found paragraph attr, which=0x%x, ver=0x%x, start=%u, end=%u (string now %s) Data:%s Len=%lld Data:", a.which, a.ver, (a.startSet?a.start:0), (a.endSet?a.end:0), attrs.c_str(), (a.data ? "Yes" : "No"), (long long)a.dataLen)); #ifdef DEBUG hexdump(a.data, a.dataLen); putc('\n', stderr); #endif } if (gsf_input_seek(mDocStream, eoa2, G_SEEK_SET)) return UT_IE_BOGUSDOCUMENT; } } else { UT_DEBUGMSG(("SDW: ...unknown attribute '%c' found (start=%" GSF_OFF_T_FORMAT " end=%" GSF_OFF_T_FORMAT ")\n", attVal, gsf_input_tell(mDocStream), eoa)); } if (gsf_input_seek(mDocStream, eoa, G_SEEK_SET)) return UT_IE_BOGUSDOCUMENT; } PP_PropertyVector attributes = { "props", pAttrs.c_str() }; // first, insert the paragraph if (!appendStrux(PTX_Block, attributes)) return UT_IE_NOMEMORY; UT_String pca(attrs); // character attributes for the whole paragraph // now insert the spans of text UT_uint32 len = textNode.length(); UT_uint32 lastInsPos = 0; for (UT_uint32 i = 1; i < len; i++) { bool doInsert = false; // whether there was an attribute change for (UT_sint32 j = 0; j < charAttributes.getItemCount(); j++) { const TextAttr* a = reinterpret_cast<const TextAttr*>(charAttributes[j]); // clear the last attribute, if set if (a->endSet && a->end == (i - 1)) { if (a->isOff) { UT_String propval = UT_String_getPropVal(pca, a->attrName); UT_String_setProperty(attrs, a->attrName, propval); } else UT_String_removeProperty(attrs, a->attrName); } // now set new attribute, if needed if (a->startSet && a->start == (i - 1)) { if (a->isPara) UT_String_setProperty(pAttrs, a->attrName, a->attrVal); else if (a->isOff) UT_String_removeProperty(attrs, a->attrName); else UT_String_setProperty(attrs, a->attrName, a->attrVal); } // insert if this is the last character, or if there was a format change if ((a->endSet && a->end == i) || (a->startSet && a->start == i)) doInsert = true; } if (doInsert || i == (len - 1)) { attributes[1] = attrs.c_str(); UT_DEBUGMSG(("SDW: Going to appendFmt with %s\n", attributes[1].c_str())); if (!appendFmt(attributes)) return UT_IE_NOMEMORY; /* leave cast alone! */ UT_DEBUGMSG(("SDW: About to insert %u-%u\n", lastInsPos, i)); size_t spanLen = i - lastInsPos; if (i == (len - 1)) spanLen++; UT_UCS4String span = textNode.substr(lastInsPos, spanLen); appendSpan(span.ucs4_str(), spanLen); lastInsPos = i; } } UT_VECTOR_PURGEALL(TextAttr*, charAttributes); break; } case SWG_JOBSETUP: { // flags are apparently unused here. no idea why they are there. gsf_off_t newpos; UT_uint8 flags; readFlagRec(mDocStream, flags, &newpos); if (gsf_input_seek(mDocStream, newpos, G_SEEK_SET)) return UT_IE_BOGUSDOCUMENT; UT_uint16 len, system; streamRead(mDocStream, len); streamRead(mDocStream, system); char printerName[64]; streamRead(mDocStream, printerName, 64); char deviceName[32], portName[32], driverName[32]; streamRead(mDocStream, deviceName, 32); streamRead(mDocStream, portName, 32); streamRead(mDocStream, driverName, 32); UT_DEBUGMSG(("SDW: Jobsetup: len %u sys 0x%x printer |%.64s| device |%.32s| port |%.32s| driver |%.32s|\n", len, system, printerName, deviceName, portName, driverName)); if (system == JOBSET_FILE364_SYSTEM || system == JOBSET_FILE605_SYSTEM) { UT_uint16 len2, system2; streamRead(mDocStream, len2); streamRead(mDocStream, system2); UT_uint32 ddl; // driver data length streamRead(mDocStream, ddl); // now the interesting data UT_uint16 orient; // 0=portrait 1=landscape streamRead(mDocStream, orient); UT_uint16 paperBin; streamRead(mDocStream, paperBin); UT_uint16 paperFormat; streamRead(mDocStream, paperFormat); UT_uint32 width, height; streamRead(mDocStream, width); streamRead(mDocStream, height); UT_DEBUGMSG(("SDW: orient %u bin %u format %u width %u height %u\n", orient, paperBin, paperFormat, width, height)); // rest of the data is ignored, seems to be printer specific anyway. // Use A4, Portrait by default PP_PropertyVector attributes = { "pagetype", "a4", // A4/Letter/... "orientation", "portrait", "width", "210", "height", "297", "units", "mm" }; const char* sdwPaperToAbi[] = { "A3", "A4", "A5", "B4", "B5", "Letter", "Legal", "Tabloid/Ledger", "Custom" }; if (paperFormat < sizeof(sdwPaperToAbi)/sizeof(*sdwPaperToAbi)) { attributes[1] = sdwPaperToAbi[paperFormat]; } const char* sdwOrientToAbi[] = { "portrait", "landscape" }; if (orient < sizeof(sdwOrientToAbi)/sizeof(*sdwOrientToAbi)) { attributes[3] = sdwOrientToAbi[orient]; } attributes[5] = UT_std_string_sprintf("%f", static_cast<double>(width)/100); attributes[7] = UT_std_string_sprintf("%f", static_cast<double>(height)/100); getDoc()->setPageSizeFromFile(attributes); } break; } case SWG_EOF: done2 = true; break; default: UT_DEBUGMSG(("SDW: SWG_CONTENT: Skipping %u bytes for record type '%c' (starting at 0x%08llX)\n", size2, type, (long long)gsf_input_tell(mDocStream))); } if (gsf_input_seek(mDocStream, eor2, G_SEEK_SET)) return UT_IE_BOGUSDOCUMENT; } break; } case SWG_STRINGPOOL: { if (mDocHdr.nVersion <= SWG_POOLIDS) { UT_ASSERT_HARMLESS(UT_NOT_IMPLEMENTED); break; } UT_uint8 encoding; streamRead(mDocStream, encoding); UT_iconv_t cd = findConverter(encoding); if (!UT_iconv_isValid(cd)) throw UT_IE_IMPORTERROR; UT_uint16 count; streamRead(mDocStream, count); while (count--) { UT_uint16 id; streamRead(mDocStream, id); char* str; UT_uint16 len; ::readByteString(mDocStream, str, &len); if (id == IDX_NOCONV_FF) { UT_ASSERT_HARMLESS(UT_NOT_IMPLEMENTED); } // FIXME: find a way to not have to copy and free // the result of UT_convert_cd.... --hub UT_DEBUGMSG(("SDW: StringPool: found 0x%04x <-> %.*s\n", id, len, str)); UT_UCS4Char* convertedString = reinterpret_cast<UT_UCS4Char*>(UT_convert_cd(str, len + 1, cd, NULL, NULL)); mStringPool.insert(stringpool_map::value_type(id, convertedString)); FREEP(convertedString); delete [] str; } UT_iconv_close(cd); break; } case SWG_COMMENT: // skip over comments break; case SWG_EOF: done = true; break; default: UT_DEBUGMSG(("SDW: Skipping %u bytes for record type '%c' (starting at 0x%08llX)\n", recSize, type, (long long)gsf_input_tell(mDocStream))); } // Seek to the end of the record, in case it wasn't read completely if (gsf_input_seek(mDocStream, eor, G_SEEK_SET)) return UT_IE_BOGUSDOCUMENT; } UT_DEBUGMSG(("SDW: Done\n")); return UT_OK; } catch(UT_Error e) { UT_DEBUGMSG(("SDW: error %d\n", e)); return e; } catch(...) { UT_DEBUGMSG(("SDW: Unknown error\n")); return UT_IE_BOGUSDOCUMENT; } }
/** * @brief Reads a whole line from the input channel. * @note Input chars are echoed on the same stream object with the * following exceptions: * - DEL and BS are echoed as BS-SPACE-BS. * - CR is echoed as CR-LF. * - 0x4 is echoed as "^D". * - Other values below 0x20 are not echoed. * . * * @param[in] scfg pointer to a @p ShellConfig object * @param[in] line pointer to the line buffer * @param[in] size buffer maximum length * @param[in] shp pointer to a @p ShellHistory object or NULL * @return The operation status. * @retval true the channel was reset or CTRL-D pressed. * @retval false operation successful. * * @api */ bool shellGetLine(ShellConfig *scfg, char *line, unsigned size, ShellHistory *shp) { char *p = line; BaseSequentialStream *chp = scfg->sc_channel; #if SHELL_USE_ESC_SEQ == TRUE bool escape = false; bool bracket = false; #endif #if SHELL_USE_HISTORY != TRUE (void) shp; #endif while (true) { char c; if (streamRead(chp, (uint8_t *)&c, 1) == 0) return true; #if SHELL_USE_ESC_SEQ == TRUE if (c == 27) { escape = true; continue; } if (escape) { escape = false; if (c == '[') { escape = true; bracket = true; continue; } if (bracket) { bracket = false; #if SHELL_USE_HISTORY == TRUE if (c == 'A') { int len = get_history(shp, line, SHELL_HIST_DIR_BK); if (len > 0) { _shell_reset_cur(chp); _shell_clr_line(chp); chprintf(chp, "%s", line); p = line + len; } continue; } if (c == 'B') { int len = get_history(shp, line, SHELL_HIST_DIR_FW); if (len == 0) *line = 0; if (len >= 0) { _shell_reset_cur(chp); _shell_clr_line(chp); chprintf(chp, "%s", line); p = line + len; } continue; } #endif } continue; } #endif #if (SHELL_CMD_EXIT_ENABLED == TRUE) && !defined(_CHIBIOS_NIL_) if (c == 4) { chprintf(chp, "^D"); return true; } #endif if ((c == 8) || (c == 127)) { if (p != line) { streamPut(chp, 0x08); streamPut(chp, 0x20); streamPut(chp, 0x08); p--; } continue; } if (c == '\r') { chprintf(chp, SHELL_NEWLINE_STR); #if SHELL_USE_HISTORY == TRUE save_history(shp, line, p - line); #endif *p = 0; return false; } #if SHELL_USE_COMPLETION == TRUE if (c == '\t') { if (p < line + size - 1) { *p = 0; get_completions(scfg, line); int len = process_completions(scfg, line, p - line, size); if (len > 0) { write_completions(scfg, line, p - line); p = line + len; } } continue; } #endif #if SHELL_USE_HISTORY == TRUE if (c == 14) { int len = get_history(shp, line, SHELL_HIST_DIR_FW); if (len == 0) *line = 0; if (len >= 0) { _shell_reset_cur(chp); _shell_clr_line(chp); chprintf(chp, "%s", line); p = line + len; } continue; } if (c == 16) { int len = get_history(shp, line, SHELL_HIST_DIR_BK); if (len > 0) { _shell_reset_cur(chp); _shell_clr_line(chp); chprintf(chp, "%s", line); p = line + len; } continue; } #endif if (c < 0x20) continue; if (p < line + size - 1) { streamPut(chp, c); *p++ = (char)c; } } }
int InputStream::streamRead(VoidBuffer buffer) { return streamRead(buffer, buffer.size()); }
static inline T streamRead(InputStreamHandle &in) { T t; streamRead(in, t); return t; }
static inline void streamRead(InputStreamHandle &in, T *dst, size_t numElements) { streamRead(*in, dst, numElements); }
static inline void streamRead(InputStreamHandle &in, std::vector<T> &dst) { streamRead(*in, dst); }
static inline void streamRead(InputStreamHandle &in, T &dst) { streamRead(*in, dst); }
void streamRead(GsfInput* aStream, TextAttr& aAttr, gsf_off_t aEoa) throw(UT_Error) { UT_uint8 flags; gsf_off_t newPos; readFlagRec(aStream, flags, &newPos); streamRead(aStream, aAttr.which); streamRead(aStream, aAttr.ver); if (flags & 0x10) { aAttr.startSet = true; streamRead(aStream, aAttr.start); } else aAttr.startSet = false; if (flags & 0x20) { aAttr.endSet = true; streamRead(aStream, aAttr.end); } else aAttr.endSet = false; if (gsf_input_seek(aStream, newPos, G_SEEK_SET)) throw UT_IE_BOGUSDOCUMENT; gsf_off_t curPos = gsf_input_tell(aStream); if (curPos != aEoa) { // there is data aAttr.dataLen = aEoa - curPos; aAttr.data = new UT_uint8[aAttr.dataLen]; streamRead(aStream, aAttr.data, aAttr.dataLen); } // LIST OF THE VALUES: http://ooo.ximian.com/lxr/source/sw/sw/inc/hintids.hxx#086 // together with http://ooo.ximian.com/lxr/source/sw/sw/source/core/sw3io/sw3fmts.cxx#172 switch (aAttr.which) { case 0x1004: // strikethrough aAttr.attrName = "text-decoration"; if (!aAttr.data || aAttr.data[0]) aAttr.attrVal = "line-through"; else aAttr.isOff = true; break; case 0x1005: { // sub-/superscript if (aAttr.dataLen < 3) break; // first byte is size of text % of normal size UT_sint16 height = GSF_LE_GET_GINT16(aAttr.data + 1); aAttr.attrName = "text-position"; if (height > 0) aAttr.attrVal = "superscript"; else if (height < 0) aAttr.attrVal = "subscript"; else aAttr.isOff = true; break; } case 0x1006: { // font family if (!aAttr.data || aAttr.dataLen < 7) // 7 = 3 byte family etc., 2 byte name length, 2 byte style length break; aAttr.attrName = "font-family"; // XXX TODO This code here assumes that the font names are in latin1 UT_uint16 fontLen = GSF_LE_GET_GUINT16(aAttr.data + 3); UT_String_sprintf(aAttr.attrVal, "%.*s", fontLen, (aAttr.data + 5)); break; } case 0x1007: // font height // structure: | height (2 byte, twips) | prop (?) (2 byte) (if version >= 2, if ver=1 1 byte) | unit (if version>=2) | // XXX we ignore "prop" and unit for now, they seem not used much aAttr.attrName = "font-size"; if (aAttr.data) aAttr.attrVal = twipsToSizeString(GSF_LE_GET_GUINT16(aAttr.data)); break; case 0x100a: // Italic aAttr.attrName = "font-style"; if (!aAttr.data || aAttr.data[0]) // if there is data, first byte must be != 0 // abiword doesn't support oblique, so always set italic aAttr.attrVal = "italic"; else aAttr.isOff = true; break; case 0x100d: // Underline aAttr.attrName = "text-decoration"; if (!aAttr.data || aAttr.data[0]) aAttr.attrVal = "underline"; else aAttr.isOff = true; break; case 0x100e: // Bold aAttr.attrName = "font-weight"; if (!aAttr.data || aAttr.data[0] >= 8) // 8=Bold. aAttr.attrVal = "bold"; else aAttr.isOff = true; break; case 0x4000: // line spacing aAttr.attrName = "line-height"; aAttr.isPara = true; // prop space (s8) | inter space (s16) | height (u16) | rule (s8) | interrule (s8) if (aAttr.data && aAttr.dataLen >= 7) { // Abiword wants it as float value, StarOffice saves as percentage (e.g. // 150 for 1.5) float proportionalLineSpace = float(aAttr.data[0])/100; // But maybe we need to use the height - stored as twips, need points // (used for "exact" and "minimum" line spacing) // XXX inter-line spacing not supported by abiword (would be rule=0x00 // interrule=0x02, value to use=inter space, unit twips) UT_String lineHeight = twipsToSizeString(GSF_LE_GET_GINT16(aAttr.data + 3)); // We'll turn the bytes at 5 and 6 into a single integer, for easier // evaluation switch (GSF_LE_GET_GUINT16(aAttr.data + 5)) { case 0x0100: // proportional aAttr.attrVal = std_size_string(proportionalLineSpace); break; case 0x0001: case 0x0002: aAttr.attrVal = lineHeight; if (aAttr.data[5] == 2) // "minimum" case aAttr.attrVal += '+'; break; default: UT_DEBUGMSG(("Unsupported linespacing: %02x %02x\n", aAttr.data[5], aAttr.data[6])); } } break; case 0x4001: // Alignment aAttr.attrName = "text-align"; aAttr.isPara = true; if (aAttr.data) { switch (aAttr.data[0]) { case 0: aAttr.attrVal = "left"; break; case 1: aAttr.attrVal = "right"; break; case 2: case 4: // BLOCKLINE!? what's BLOCKLINE? I'm guessing justify. aAttr.attrVal = "justify"; break; case 3: aAttr.attrVal = "center"; break; } } break; case 0x4005: {// Tabstops aAttr.attrName = "tabstops"; aAttr.isPara = true; // Data structure: // Count(8) | Position (in twips) (32) | Adjustment (8) | Decimal Separator (?) (8) | Fill character (8) // (total size per tab = 7) // UT_sint8 count = aAttr.data[0]; for (UT_uint32 i = 1; (i + 6) < aAttr.dataLen; i += 7) { // Abiword wants: 12.3cm/L0, where 0 indicates what to fill with UT_uint16 posInTwips = GSF_LE_GET_GUINT32(aAttr.data + i); UT_String pos = twipsToSizeString(posInTwips); aAttr.attrVal += pos; aAttr.attrVal += '/'; if (aAttr.data[i + 4] < sizeof(sTabAlignment)/sizeof(*sTabAlignment)) aAttr.attrVal += sTabAlignment[aAttr.data[i + 4]]; else aAttr.attrVal += 'L'; // fallback char fillIndex = '0'; // Fill character switch (aAttr.data[i + 6]) { case '.': fillIndex = '1'; break; case '-': fillIndex = '2'; break; case '_': fillIndex = '3'; break; case ' ': fillIndex = '0'; break; default: UT_DEBUGMSG(("Filling with '%c' is not supported\n", aAttr.data[i + 6])); } aAttr.attrVal += fillIndex; aAttr.attrVal += ','; } } break; default: UT_DEBUGMSG(("SDW: unknown attribute 0x%x, compressed %d\n", aAttr.which, lcl_sw3io__CompressWhich(aAttr.which))); } }
void DocHdr::load(GsfInput* stream) throw(UT_Error) { UT_DEBUGMSG(("SDW: entering DocHdr::load\n")); static const char sw3hdr[] = "SW3HDR"; static const char sw4hdr[] = "SW4HDR"; static const char sw5hdr[] = "SW5HDR"; char header[7]; streamRead(stream, header, 7); if (memcmp(header, sw3hdr, sizeof(sw3hdr)) != 0 && memcmp(header, sw4hdr, sizeof(sw4hdr)) != 0 && memcmp(header, sw5hdr, sizeof(sw5hdr)) != 0) throw UT_IE_BOGUSDOCUMENT; streamRead(stream, cLen); streamRead(stream, nVersion); streamRead(stream, nFileFlags); streamRead(stream, nDocFlags); streamRead(stream, nRecSzPos); streamRead(stream, nDummy); streamRead(stream, nDummy16); streamRead(stream, cRedlineMode); streamRead(stream, nCompatVer); UT_DEBUGMSG(("SDW: clen %i nversion %i fileflags %i docflags %i recszpos %i readlinemode %i compatver %i\n", cLen, nVersion, nFileFlags, nDocFlags, nRecSzPos, cRedlineMode, nCompatVer)); // (see sw/source/core/sw3io/sw3doc.cxx line 700) if (nVersion >= SWG_MAJORVERSION && nCompatVer > 0) { // File is in a too new format throw UT_IE_BOGUSDOCUMENT; } streamRead(stream, cPasswd, 16); streamRead(stream, cSet); streamRead(stream, cGui); streamRead(stream, nDate); streamRead(stream, nTime); UT_DEBUGMSG(("SDW: nDate %u nTime %u\n", nDate, nTime)); // Find the name of the used encoding converter = findConverter(cSet); if (!UT_iconv_isValid(converter)) throw UT_ERROR; if (nFileFlags & SWGF_BLOCKNAME) { char buf[64]; streamRead(stream, buf, 64); UT_DEBUGMSG(("SDW: BLOCKNAME: %.64s\n", buf)); // XXX verify that the string is really null terminated sBlockName = reinterpret_cast<UT_UCS4Char*>(UT_convert_cd(buf, strlen(buf) + 1, converter, NULL, NULL)); } if (nRecSzPos != 0 && nVersion >= SWG_RECSIZES) { // Read the Recsizes // XXX to be done see sw/source/core/sw3io/sw3imp.cxx#L1070 UT_ASSERT_HARMLESS(UT_NOT_IMPLEMENTED); } if (nFileFlags & SWGF_BAD_FILE) throw UT_IE_BOGUSDOCUMENT; if (nFileFlags & SWGF_HAS_PASSWD) cryptor = new SDWCryptor(nDate, nTime, cPasswd); else cryptor = NULL; }
void readFlagRec(GsfInput* stream, UT_uint8& flags, gsf_off_t* newPos) throw(UT_Error) { streamRead(stream, flags); if (newPos) *newPos = gsf_input_tell(stream) + (flags & 0xF); }