mirror of
https://github.com/geometer/FBReaderJ.git
synced 2025-10-03 17:59:33 +02:00
native code: synchronization with C++ version
This commit is contained in:
parent
6fd4e1e98f
commit
d93770c0f8
111 changed files with 804 additions and 697 deletions
|
@ -67,7 +67,7 @@ static void fillMetaInfo(JNIEnv* env, jobject javaBook, Book &book) {
|
||||||
}
|
}
|
||||||
|
|
||||||
const AuthorList &authors = book.authors();
|
const AuthorList &authors = book.authors();
|
||||||
for (size_t i = 0; i < authors.size(); ++i) {
|
for (std::size_t i = 0; i < authors.size(); ++i) {
|
||||||
const Author &author = *authors[i];
|
const Author &author = *authors[i];
|
||||||
javaString = env->NewStringUTF(author.name().c_str());
|
javaString = env->NewStringUTF(author.name().c_str());
|
||||||
jstring key = env->NewStringUTF(author.sortKey().c_str());
|
jstring key = env->NewStringUTF(author.sortKey().c_str());
|
||||||
|
@ -77,7 +77,7 @@ static void fillMetaInfo(JNIEnv* env, jobject javaBook, Book &book) {
|
||||||
}
|
}
|
||||||
|
|
||||||
const TagList &tags = book.tags();
|
const TagList &tags = book.tags();
|
||||||
for (size_t i = 0; i < tags.size(); ++i) {
|
for (std::size_t i = 0; i < tags.size(); ++i) {
|
||||||
const Tag &tag = *tags[i];
|
const Tag &tag = *tags[i];
|
||||||
AndroidUtil::Method_Book_addTag->call(javaBook, tag.javaTag(env));
|
AndroidUtil::Method_Book_addTag->call(javaBook, tag.javaTag(env));
|
||||||
}
|
}
|
||||||
|
@ -149,17 +149,17 @@ static bool initInternalHyperlinks(JNIEnv *env, jobject javaModel, BookModel &mo
|
||||||
}
|
}
|
||||||
ZLUnicodeUtil::utf8ToUcs2(ucs2id, id);
|
ZLUnicodeUtil::utf8ToUcs2(ucs2id, id);
|
||||||
ZLUnicodeUtil::utf8ToUcs2(ucs2modelId, label.Model->id());
|
ZLUnicodeUtil::utf8ToUcs2(ucs2modelId, label.Model->id());
|
||||||
const size_t idLen = ucs2id.size() * 2;
|
const std::size_t idLen = ucs2id.size() * 2;
|
||||||
const size_t modelIdLen = ucs2modelId.size() * 2;
|
const std::size_t modelIdLen = ucs2modelId.size() * 2;
|
||||||
|
|
||||||
char *ptr = allocator.allocate(idLen + modelIdLen + 8);
|
char *ptr = allocator.allocate(idLen + modelIdLen + 8);
|
||||||
ZLCachedMemoryAllocator::writeUInt16(ptr, ucs2id.size());
|
ZLCachedMemoryAllocator::writeUInt16(ptr, ucs2id.size());
|
||||||
ptr += 2;
|
ptr += 2;
|
||||||
memcpy(ptr, &ucs2id.front(), idLen);
|
std::memcpy(ptr, &ucs2id.front(), idLen);
|
||||||
ptr += idLen;
|
ptr += idLen;
|
||||||
ZLCachedMemoryAllocator::writeUInt16(ptr, ucs2modelId.size());
|
ZLCachedMemoryAllocator::writeUInt16(ptr, ucs2modelId.size());
|
||||||
ptr += 2;
|
ptr += 2;
|
||||||
memcpy(ptr, &ucs2modelId.front(), modelIdLen);
|
std::memcpy(ptr, &ucs2modelId.front(), modelIdLen);
|
||||||
ptr += modelIdLen;
|
ptr += modelIdLen;
|
||||||
ZLCachedMemoryAllocator::writeUInt32(ptr, label.ParagraphNumber);
|
ZLCachedMemoryAllocator::writeUInt32(ptr, label.ParagraphNumber);
|
||||||
}
|
}
|
||||||
|
@ -181,7 +181,7 @@ static jobject createTextModel(JNIEnv *env, jobject javaModel, ZLTextModel &mode
|
||||||
jstring language = AndroidUtil::createJavaString(env, model.language());
|
jstring language = AndroidUtil::createJavaString(env, model.language());
|
||||||
jint paragraphsNumber = model.paragraphsNumber();
|
jint paragraphsNumber = model.paragraphsNumber();
|
||||||
|
|
||||||
const size_t arraysSize = model.startEntryIndices().size();
|
const std::size_t arraysSize = model.startEntryIndices().size();
|
||||||
jintArray entryIndices = env->NewIntArray(arraysSize);
|
jintArray entryIndices = env->NewIntArray(arraysSize);
|
||||||
jintArray entryOffsets = env->NewIntArray(arraysSize);
|
jintArray entryOffsets = env->NewIntArray(arraysSize);
|
||||||
jintArray paragraphLenghts = env->NewIntArray(arraysSize);
|
jintArray paragraphLenghts = env->NewIntArray(arraysSize);
|
||||||
|
|
|
@ -27,12 +27,12 @@
|
||||||
extern "C"
|
extern "C"
|
||||||
JNIEXPORT jobjectArray JNICALL Java_org_geometerplus_fbreader_formats_PluginCollection_nativePlugins(JNIEnv* env, jobject thiz) {
|
JNIEXPORT jobjectArray JNICALL Java_org_geometerplus_fbreader_formats_PluginCollection_nativePlugins(JNIEnv* env, jobject thiz) {
|
||||||
const std::vector<shared_ptr<FormatPlugin> > plugins = PluginCollection::Instance().plugins();
|
const std::vector<shared_ptr<FormatPlugin> > plugins = PluginCollection::Instance().plugins();
|
||||||
const size_t size = plugins.size();
|
const std::size_t size = plugins.size();
|
||||||
jclass cls = AndroidUtil::Class_NativeFormatPlugin.j();
|
jclass cls = AndroidUtil::Class_NativeFormatPlugin.j();
|
||||||
// TODO: memory leak?
|
// TODO: memory leak?
|
||||||
jobjectArray javaPlugins = env->NewObjectArray(size, cls, 0);
|
jobjectArray javaPlugins = env->NewObjectArray(size, cls, 0);
|
||||||
|
|
||||||
for (size_t i = 0; i < size; ++i) {
|
for (std::size_t i = 0; i < size; ++i) {
|
||||||
jstring fileType = AndroidUtil::createJavaString(env, plugins[i]->supportedFileType());
|
jstring fileType = AndroidUtil::createJavaString(env, plugins[i]->supportedFileType());
|
||||||
jobject p = AndroidUtil::StaticMethod_NativeFormatPlugin_create->call(fileType);
|
jobject p = AndroidUtil::StaticMethod_NativeFormatPlugin_create->call(fileType);
|
||||||
env->SetObjectArrayElement(javaPlugins, i, p);
|
env->SetObjectArrayElement(javaPlugins, i, p);
|
||||||
|
|
|
@ -232,8 +232,8 @@ void BookReader::addImage(const std::string &id, shared_ptr<const ZLImage> image
|
||||||
|
|
||||||
void BookReader::insertEndParagraph(ZLTextParagraph::Kind kind) {
|
void BookReader::insertEndParagraph(ZLTextParagraph::Kind kind) {
|
||||||
if ((myCurrentTextModel != 0) && mySectionContainsRegularContents) {
|
if ((myCurrentTextModel != 0) && mySectionContainsRegularContents) {
|
||||||
size_t size = myCurrentTextModel->paragraphsNumber();
|
std::size_t size = myCurrentTextModel->paragraphsNumber();
|
||||||
if ((size > 0) && (((*myCurrentTextModel)[(size_t)-1])->kind() != kind)) {
|
if ((size > 0) && (((*myCurrentTextModel)[(std::size_t)-1])->kind() != kind)) {
|
||||||
((ZLTextPlainModel&)*myCurrentTextModel).createParagraph(kind);
|
((ZLTextPlainModel&)*myCurrentTextModel).createParagraph(kind);
|
||||||
mySectionContainsRegularContents = false;
|
mySectionContainsRegularContents = false;
|
||||||
}
|
}
|
||||||
|
@ -293,7 +293,7 @@ void BookReader::endContentsParagraph() {
|
||||||
}
|
}
|
||||||
|
|
||||||
/*
|
/*
|
||||||
void BookReader::setReference(size_t contentsParagraphNumber, int referenceNumber) {
|
void BookReader::setReference(std::size_t contentsParagraphNumber, int referenceNumber) {
|
||||||
ContentsModel &contentsModel = (ContentsModel&)*myModel.myContentsModel;
|
ContentsModel &contentsModel = (ContentsModel&)*myModel.myContentsModel;
|
||||||
if (contentsParagraphNumber >= contentsModel.paragraphsNumber()) {
|
if (contentsParagraphNumber >= contentsModel.paragraphsNumber()) {
|
||||||
return;
|
return;
|
||||||
|
|
|
@ -71,7 +71,7 @@ public:
|
||||||
void beginContentsParagraph(int referenceNumber = -1);
|
void beginContentsParagraph(int referenceNumber = -1);
|
||||||
void endContentsParagraph();
|
void endContentsParagraph();
|
||||||
bool contentsParagraphIsOpen() const;
|
bool contentsParagraphIsOpen() const;
|
||||||
//void setReference(size_t contentsParagraphNumber, int referenceNumber);
|
//void setReference(std::size_t contentsParagraphNumber, int referenceNumber);
|
||||||
|
|
||||||
void addData(const std::string &data);
|
void addData(const std::string &data);
|
||||||
void addContentsData(const std::string &data);
|
void addContentsData(const std::string &data);
|
||||||
|
|
|
@ -44,7 +44,7 @@ bool FormatPlugin::detectEncodingAndLanguage(Book &book, ZLInputStream &stream,
|
||||||
if (collection.isLanguageAutoDetectEnabled() && stream.open()) {
|
if (collection.isLanguageAutoDetectEnabled() && stream.open()) {
|
||||||
static const int BUFSIZE = 65536;
|
static const int BUFSIZE = 65536;
|
||||||
char *buffer = new char[BUFSIZE];
|
char *buffer = new char[BUFSIZE];
|
||||||
const size_t size = stream.read(buffer, BUFSIZE);
|
const std::size_t size = stream.read(buffer, BUFSIZE);
|
||||||
stream.close();
|
stream.close();
|
||||||
shared_ptr<ZLLanguageDetector::LanguageInfo> info = ZLLanguageDetector().findInfo(buffer, size);
|
shared_ptr<ZLLanguageDetector::LanguageInfo> info = ZLLanguageDetector().findInfo(buffer, size);
|
||||||
delete[] buffer;
|
delete[] buffer;
|
||||||
|
@ -77,7 +77,7 @@ bool FormatPlugin::detectLanguage(Book &book, ZLInputStream &stream, const std::
|
||||||
if (collection.isLanguageAutoDetectEnabled() && stream.open()) {
|
if (collection.isLanguageAutoDetectEnabled() && stream.open()) {
|
||||||
static const int BUFSIZE = 65536;
|
static const int BUFSIZE = 65536;
|
||||||
char *buffer = new char[BUFSIZE];
|
char *buffer = new char[BUFSIZE];
|
||||||
const size_t size = stream.read(buffer, BUFSIZE);
|
const std::size_t size = stream.read(buffer, BUFSIZE);
|
||||||
stream.close();
|
stream.close();
|
||||||
shared_ptr<ZLLanguageDetector::LanguageInfo> info =
|
shared_ptr<ZLLanguageDetector::LanguageInfo> info =
|
||||||
ZLLanguageDetector().findInfoForEncoding(encoding, buffer, size, -20000);
|
ZLLanguageDetector().findInfoForEncoding(encoding, buffer, size, -20000);
|
||||||
|
|
|
@ -48,7 +48,7 @@ void StyleSheetTableParser::storeData(const std::string &selector, const StyleSh
|
||||||
std::string id = *it;
|
std::string id = *it;
|
||||||
ZLStringUtil::stripWhiteSpaces(id);
|
ZLStringUtil::stripWhiteSpaces(id);
|
||||||
if (!id.empty()) {
|
if (!id.empty()) {
|
||||||
const size_t index = id.find('.');
|
const std::size_t index = id.find('.');
|
||||||
if (index == std::string::npos) {
|
if (index == std::string::npos) {
|
||||||
myTable.addMap(id, std::string(), map);
|
myTable.addMap(id, std::string(), map);
|
||||||
} else {
|
} else {
|
||||||
|
@ -231,7 +231,7 @@ void StyleSheetParser::processWordWithoutComments(const std::string &word) {
|
||||||
break;
|
break;
|
||||||
case ATTRIBUTE_VALUE:
|
case ATTRIBUTE_VALUE:
|
||||||
{
|
{
|
||||||
const size_t l = word.length();
|
const std::size_t l = word.length();
|
||||||
if (l >= 2 && (word[0] == '"' || word[0] == '\'') && word[0] == word[l - 1]) {
|
if (l >= 2 && (word[0] == '"' || word[0] == '\'') && word[0] == word[l - 1]) {
|
||||||
myMap[myAttributeName].push_back(word.substr(1, l - 2));
|
myMap[myAttributeName].push_back(word.substr(1, l - 2));
|
||||||
} else {
|
} else {
|
||||||
|
|
|
@ -50,7 +50,7 @@ bool DocBookReader::readBook() {
|
||||||
myModelReader.pushKind(REGULAR);
|
myModelReader.pushKind(REGULAR);
|
||||||
myModelReader.beginParagraph();
|
myModelReader.beginParagraph();
|
||||||
|
|
||||||
if (!readDocument(stream)) {
|
if (!readDocument(stream, true)) {
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -89,7 +89,7 @@ void DocBookReader::handleHardLinebreak() {
|
||||||
if (!myCurrentStyleEntry.isNull()) {
|
if (!myCurrentStyleEntry.isNull()) {
|
||||||
myModelReader.addStyleEntry(*myCurrentStyleEntry);
|
myModelReader.addStyleEntry(*myCurrentStyleEntry);
|
||||||
}
|
}
|
||||||
for (size_t i = 0; i < myKindStack.size(); ++i) {
|
for (std::size_t i = 0; i < myKindStack.size(); ++i) {
|
||||||
myModelReader.addControl(myKindStack.at(i), true);
|
myModelReader.addControl(myKindStack.at(i), true);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -156,7 +156,7 @@ void DocBookReader::handleSeparatorField() {
|
||||||
std::vector<std::string> result = ZLStringUtil::split(utf8String, SPACE_DELIMETER);
|
std::vector<std::string> result = ZLStringUtil::split(utf8String, SPACE_DELIMETER);
|
||||||
//TODO split function can returns empty string, maybe fix it
|
//TODO split function can returns empty string, maybe fix it
|
||||||
std::vector<std::string> splitted;
|
std::vector<std::string> splitted;
|
||||||
for (size_t i = 0; i < result.size(); ++i) {
|
for (std::size_t i = 0; i < result.size(); ++i) {
|
||||||
if (!result.at(i).empty()) {
|
if (!result.at(i).empty()) {
|
||||||
splitted.push_back(result.at(i));
|
splitted.push_back(result.at(i));
|
||||||
}
|
}
|
||||||
|
@ -239,7 +239,7 @@ void DocBookReader::handleFontStyle(unsigned int fontStyle) {
|
||||||
if (fontStyle & OleMainStream::CharInfo::FONT_ITALIC) {
|
if (fontStyle & OleMainStream::CharInfo::FONT_ITALIC) {
|
||||||
myKindStack.push_back(ITALIC);
|
myKindStack.push_back(ITALIC);
|
||||||
}
|
}
|
||||||
for (size_t i = 0; i < myKindStack.size(); ++i) {
|
for (std::size_t i = 0; i < myKindStack.size(); ++i) {
|
||||||
myModelReader.addControl(myKindStack.at(i), true);
|
myModelReader.addControl(myKindStack.at(i), true);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -289,7 +289,7 @@ void DocBookReader::handleParagraphStyle(const OleMainStream::Style &styleInfo)
|
||||||
// if it has the same StyleIdCurrent
|
// if it has the same StyleIdCurrent
|
||||||
if (myCurrentStyleInfo.StyleIdCurrent != OleMainStream::Style::STYLE_INVALID &&
|
if (myCurrentStyleInfo.StyleIdCurrent != OleMainStream::Style::STYLE_INVALID &&
|
||||||
myCurrentStyleInfo.StyleIdCurrent == styleInfo.StyleIdCurrent) {
|
myCurrentStyleInfo.StyleIdCurrent == styleInfo.StyleIdCurrent) {
|
||||||
for (size_t i = 0; i < myKindStack.size(); ++i) {
|
for (std::size_t i = 0; i < myKindStack.size(); ++i) {
|
||||||
myModelReader.addControl(myKindStack.at(i), true);
|
myModelReader.addControl(myKindStack.at(i), true);
|
||||||
}
|
}
|
||||||
} else {
|
} else {
|
||||||
|
@ -312,7 +312,7 @@ std::string DocBookReader::parseLink(ZLUnicodeUtil::Ucs2String s, bool urlencode
|
||||||
// [0x13] HYPERLINK "http://yandex.ru/yandsearch?text='some text' и "some text2"" [0x14] link text [0x15]
|
// [0x13] HYPERLINK "http://yandex.ru/yandsearch?text='some text' и "some text2"" [0x14] link text [0x15]
|
||||||
|
|
||||||
static const ZLUnicodeUtil::Ucs2Char QUOTE = 0x22;
|
static const ZLUnicodeUtil::Ucs2Char QUOTE = 0x22;
|
||||||
size_t i, first = 0;
|
std::size_t i, first = 0;
|
||||||
//TODO maybe functions findFirstOf and findLastOf should be in ZLUnicodeUtil class
|
//TODO maybe functions findFirstOf and findLastOf should be in ZLUnicodeUtil class
|
||||||
for (i = 0; i < s.size(); ++i) {
|
for (i = 0; i < s.size(); ++i) {
|
||||||
if (s.at(i) == QUOTE) {
|
if (s.at(i) == QUOTE) {
|
||||||
|
@ -323,7 +323,7 @@ std::string DocBookReader::parseLink(ZLUnicodeUtil::Ucs2String s, bool urlencode
|
||||||
if (i == s.size()) {
|
if (i == s.size()) {
|
||||||
return std::string();
|
return std::string();
|
||||||
}
|
}
|
||||||
size_t j, last = 0;
|
std::size_t j, last = 0;
|
||||||
for (j = s.size(); j > 0 ; --j) {
|
for (j = s.size(); j > 0 ; --j) {
|
||||||
if (s.at(j - 1) == QUOTE) {
|
if (s.at(j - 1) == QUOTE) {
|
||||||
last = j - 1;
|
last = j - 1;
|
||||||
|
@ -335,7 +335,7 @@ std::string DocBookReader::parseLink(ZLUnicodeUtil::Ucs2String s, bool urlencode
|
||||||
}
|
}
|
||||||
|
|
||||||
ZLUnicodeUtil::Ucs2String link;
|
ZLUnicodeUtil::Ucs2String link;
|
||||||
for (size_t k = first + 1; k < last; ++k) {
|
for (std::size_t k = first + 1; k < last; ++k) {
|
||||||
ZLUnicodeUtil::Ucs2Char ch = s.at(k);
|
ZLUnicodeUtil::Ucs2Char ch = s.at(k);
|
||||||
if (urlencode && ZLUnicodeUtil::isSpace(ch)) {
|
if (urlencode && ZLUnicodeUtil::isSpace(ch)) {
|
||||||
//TODO maybe implement function for encoding all signs in url, not only spaces and quotes
|
//TODO maybe implement function for encoding all signs in url, not only spaces and quotes
|
||||||
|
@ -356,11 +356,11 @@ std::string DocBookReader::parseLink(ZLUnicodeUtil::Ucs2String s, bool urlencode
|
||||||
return utf8String;
|
return utf8String;
|
||||||
}
|
}
|
||||||
|
|
||||||
void DocBookReader::footnoteHandler() {
|
void DocBookReader::footnotesStartHandler() {
|
||||||
handlePageBreak();
|
handlePageBreak();
|
||||||
}
|
}
|
||||||
|
|
||||||
void DocBookReader::dataHandler(const char *buffer, size_t len) {
|
void DocBookReader::ansiDataHandler(const char *buffer, std::size_t len) {
|
||||||
if (myConverter.isNull()) {
|
if (myConverter.isNull()) {
|
||||||
// lazy converter initialization
|
// lazy converter initialization
|
||||||
const ZLEncodingCollection &collection = ZLEncodingCollection::Instance();
|
const ZLEncodingCollection &collection = ZLEncodingCollection::Instance();
|
||||||
|
@ -374,6 +374,6 @@ void DocBookReader::dataHandler(const char *buffer, size_t len) {
|
||||||
ZLUnicodeUtil::utf8ToUcs2(myBuffer, utf8String);
|
ZLUnicodeUtil::utf8ToUcs2(myBuffer, utf8String);
|
||||||
}
|
}
|
||||||
|
|
||||||
void DocBookReader::ansiSymbolHandler(ZLUnicodeUtil::Ucs2Char symbol) {
|
void DocBookReader::ucs2SymbolHandler(ZLUnicodeUtil::Ucs2Char symbol) {
|
||||||
myBuffer.push_back(symbol);
|
myBuffer.push_back(symbol);
|
||||||
}
|
}
|
||||||
|
|
|
@ -40,9 +40,9 @@ public:
|
||||||
bool readBook();
|
bool readBook();
|
||||||
|
|
||||||
private:
|
private:
|
||||||
void dataHandler(const char *buffer, size_t len);
|
void ansiDataHandler(const char *buffer, std::size_t len);
|
||||||
void ansiSymbolHandler(ZLUnicodeUtil::Ucs2Char symbol);
|
void ucs2SymbolHandler(ZLUnicodeUtil::Ucs2Char symbol);
|
||||||
void footnoteHandler();
|
void footnotesStartHandler();
|
||||||
|
|
||||||
void handleChar(ZLUnicodeUtil::Ucs2Char ucs2char);
|
void handleChar(ZLUnicodeUtil::Ucs2Char ucs2char);
|
||||||
void handleHardLinebreak();
|
void handleHardLinebreak();
|
||||||
|
|
|
@ -17,6 +17,8 @@
|
||||||
* 02110-1301, USA.
|
* 02110-1301, USA.
|
||||||
*/
|
*/
|
||||||
|
|
||||||
|
#include <ZLLogger.h>
|
||||||
|
|
||||||
#include "OleUtil.h"
|
#include "OleUtil.h"
|
||||||
#include "OleStream.h"
|
#include "OleStream.h"
|
||||||
#include "OleMainStream.h"
|
#include "OleMainStream.h"
|
||||||
|
@ -32,7 +34,10 @@ DocFloatImageReader::DocFloatImageReader(unsigned int off, unsigned int len, sha
|
||||||
|
|
||||||
void DocFloatImageReader::readAll() {
|
void DocFloatImageReader::readAll() {
|
||||||
//OfficeArtContent structure is described at p.405-406 [MS-DOC]
|
//OfficeArtContent structure is described at p.405-406 [MS-DOC]
|
||||||
myTableStream->seek(myOffset, true);
|
if (!myTableStream->seek(myOffset, true)) {
|
||||||
|
ZLLogger::Instance().println("DocPlugin", "problems with reading float images");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
unsigned int count = 0;
|
unsigned int count = 0;
|
||||||
|
|
||||||
|
@ -56,7 +61,7 @@ void DocFloatImageReader::readAll() {
|
||||||
ZLFileImage::Blocks DocFloatImageReader::getBlocksForShapeId(unsigned int shapeId) const {
|
ZLFileImage::Blocks DocFloatImageReader::getBlocksForShapeId(unsigned int shapeId) const {
|
||||||
FSPContainer container;
|
FSPContainer container;
|
||||||
bool found = false;
|
bool found = false;
|
||||||
for (size_t i = 0; !found && i < myItem.FSPs.size(); ++i) {
|
for (std::size_t i = 0; !found && i < myItem.FSPs.size(); ++i) {
|
||||||
if (myItem.FSPs.at(i).fsp.shapeId == shapeId) {
|
if (myItem.FSPs.at(i).fsp.shapeId == shapeId) {
|
||||||
found = true;
|
found = true;
|
||||||
container = myItem.FSPs.at(i);
|
container = myItem.FSPs.at(i);
|
||||||
|
@ -67,7 +72,7 @@ ZLFileImage::Blocks DocFloatImageReader::getBlocksForShapeId(unsigned int shapeI
|
||||||
return ZLFileImage::Blocks();
|
return ZLFileImage::Blocks();
|
||||||
}
|
}
|
||||||
|
|
||||||
for (size_t i = 0; i < container.fopte.size(); ++i) {
|
for (std::size_t i = 0; i < container.fopte.size(); ++i) {
|
||||||
const FOPTE &fopte = container.fopte.at(i);
|
const FOPTE &fopte = container.fopte.at(i);
|
||||||
if (fopte.pId == 0x0104 && !fopte.isComplex) { //0x0104 specifies the BLIP, see p.420 [MS-ODRAW]
|
if (fopte.pId == 0x0104 && !fopte.isComplex) { //0x0104 specifies the BLIP, see p.420 [MS-ODRAW]
|
||||||
if (fopte.value <= myItem.blips.size() && fopte.value > 0) {
|
if (fopte.value <= myItem.blips.size() && fopte.value > 0) {
|
||||||
|
@ -144,8 +149,12 @@ unsigned int DocFloatImageReader::skipRecord(const RecordHeader &header, shared_
|
||||||
unsigned int DocFloatImageReader::readBStoreContainerFileBlock(Blip &blip, shared_ptr<OleStream> stream, shared_ptr<OleStream> mainStream) {
|
unsigned int DocFloatImageReader::readBStoreContainerFileBlock(Blip &blip, shared_ptr<OleStream> stream, shared_ptr<OleStream> mainStream) {
|
||||||
//OfficeArtBStoreContainerFileBlock structure is described at p.59 [MS-ODRAW]
|
//OfficeArtBStoreContainerFileBlock structure is described at p.59 [MS-ODRAW]
|
||||||
unsigned int count = readFBSE(blip.storeEntry, stream);
|
unsigned int count = readFBSE(blip.storeEntry, stream);
|
||||||
if( blip.storeEntry.offsetInDelay != (unsigned int)(-1)) {
|
if (blip.storeEntry.offsetInDelay != (unsigned int)-1) {
|
||||||
mainStream->seek(blip.storeEntry.offsetInDelay, true); //see p.70 [MS-ODRAW]
|
if (mainStream->seek(blip.storeEntry.offsetInDelay, true)) { //see p.70 [MS-ODRAW]
|
||||||
|
//TODO maybe we should stop reading float images here
|
||||||
|
ZLLogger::Instance().println("DocPlugin", "DocFloatImageReader: problems with seeking for offset");
|
||||||
|
return count;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
RecordHeader header;
|
RecordHeader header;
|
||||||
unsigned int count2 = readRecordHeader(header, mainStream);
|
unsigned int count2 = readRecordHeader(header, mainStream);
|
||||||
|
@ -330,7 +339,7 @@ unsigned int DocFloatImageReader::readArrayFOPTE(std::vector<FOPTE> &fopteArray,
|
||||||
count += readFOPTE(fopte, stream);
|
count += readFOPTE(fopte, stream);
|
||||||
fopteArray.push_back(fopte);
|
fopteArray.push_back(fopte);
|
||||||
}
|
}
|
||||||
for (size_t i = 0; i < fopteArray.size(); ++i) {
|
for (std::size_t i = 0; i < fopteArray.size(); ++i) {
|
||||||
if (fopteArray.at(i).isComplex) {
|
if (fopteArray.at(i).isComplex) {
|
||||||
stream->seek(fopteArray.at(i).value, false);
|
stream->seek(fopteArray.at(i).value, false);
|
||||||
count += fopteArray.at(i).value;
|
count += fopteArray.at(i).value;
|
||||||
|
@ -342,29 +351,34 @@ unsigned int DocFloatImageReader::readArrayFOPTE(std::vector<FOPTE> &fopteArray,
|
||||||
unsigned int DocFloatImageReader::readFOPTE(FOPTE &fopte, shared_ptr<OleStream> stream) {
|
unsigned int DocFloatImageReader::readFOPTE(FOPTE &fopte, shared_ptr<OleStream> stream) {
|
||||||
//OfficeArtFOPTE structure is described at p.32 [MS-ODRAW]
|
//OfficeArtFOPTE structure is described at p.32 [MS-ODRAW]
|
||||||
unsigned int dtemp;
|
unsigned int dtemp;
|
||||||
dtemp = read2Bytes (stream);
|
dtemp = read2Bytes(stream);
|
||||||
fopte.pId = (dtemp & 0x3fff);
|
fopte.pId = (dtemp & 0x3fff);
|
||||||
fopte.isBlipId = ((dtemp & 0x4000) >> 14) == 0x1;
|
fopte.isBlipId = ((dtemp & 0x4000) >> 14) == 0x1;
|
||||||
fopte.isComplex = ((dtemp & 0x8000) >> 15) == 0x1;
|
fopte.isComplex = ((dtemp & 0x8000) >> 15) == 0x1;
|
||||||
fopte.value = read4Bytes (stream);
|
fopte.value = read4Bytes(stream);
|
||||||
return 6;
|
return 6;
|
||||||
}
|
}
|
||||||
|
|
||||||
unsigned int DocFloatImageReader::read1Byte(shared_ptr<OleStream> stream) {
|
unsigned int DocFloatImageReader::read1Byte(shared_ptr<OleStream> stream) {
|
||||||
char b[1];
|
char b[1];
|
||||||
stream->read(b, 1);
|
if (stream->read(b, 1) != 1) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
return OleUtil::getU1Byte(b, 0);
|
return OleUtil::getU1Byte(b, 0);
|
||||||
}
|
}
|
||||||
|
|
||||||
unsigned int DocFloatImageReader::read2Bytes(shared_ptr<OleStream> stream) {
|
unsigned int DocFloatImageReader::read2Bytes(shared_ptr<OleStream> stream) {
|
||||||
char b[2];
|
char b[2];
|
||||||
stream->read(b, 2);
|
if (stream->read(b, 2) != 2) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
return OleUtil::getU2Bytes(b, 0);
|
return OleUtil::getU2Bytes(b, 0);
|
||||||
}
|
}
|
||||||
|
|
||||||
unsigned int DocFloatImageReader::read4Bytes(shared_ptr<OleStream> stream) {
|
unsigned int DocFloatImageReader::read4Bytes(shared_ptr<OleStream> stream) {
|
||||||
char b[4];
|
char b[4];
|
||||||
stream->read(b, 4);
|
if (stream->read(b, 4) != 4) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
return OleUtil::getU4Bytes(b, 0);
|
return OleUtil::getU4Bytes(b, 0);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -34,7 +34,7 @@ public:
|
||||||
/*
|
/*
|
||||||
void startElementHandler(int tag, const char **attributes);
|
void startElementHandler(int tag, const char **attributes);
|
||||||
void endElementHandler(int tag);
|
void endElementHandler(int tag);
|
||||||
void characterDataHandler(const char *text, size_t len);
|
void characterDataHandler(const char *text, std::size_t len);
|
||||||
*/
|
*/
|
||||||
|
|
||||||
private:
|
private:
|
||||||
|
|
|
@ -53,9 +53,9 @@ bool DocPlugin::readMetaInfo(Book &book) const {
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
|
||||||
shared_ptr<ZLInputStream> stream = new DocCharStream(book.file(), 50000);
|
shared_ptr<ZLInputStream> stream = new DocAnsiStream(book.file(), 50000);
|
||||||
if (!detectEncodingAndLanguage(book, *stream)) {
|
if (!detectEncodingAndLanguage(book, *stream)) {
|
||||||
stream = new DocAnsiStream(book.file(), 50000);
|
stream = new DocUcs2Stream(book.file(), 50000);
|
||||||
detectLanguage(book, *stream, ZLEncodingConverter::UTF8, true);
|
detectLanguage(book, *stream, ZLEncodingConverter::UTF8, true);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -27,49 +27,54 @@
|
||||||
class DocReader : public OleStreamReader {
|
class DocReader : public OleStreamReader {
|
||||||
|
|
||||||
public:
|
public:
|
||||||
DocReader(char *buffer, size_t maxSize);
|
DocReader(char *buffer, std::size_t maxSize);
|
||||||
~DocReader();
|
~DocReader();
|
||||||
size_t readSize() const;
|
std::size_t readSize() const;
|
||||||
|
|
||||||
private:
|
private:
|
||||||
bool readStream(OleMainStream &stream);
|
bool readStream(OleMainStream &stream);
|
||||||
void dataHandler(const char *buffer, size_t len);
|
void ansiDataHandler(const char *buffer, std::size_t len);
|
||||||
void ansiSymbolHandler(ZLUnicodeUtil::Ucs2Char symbol);
|
void ucs2SymbolHandler(ZLUnicodeUtil::Ucs2Char symbol);
|
||||||
void footnoteHandler();
|
void footnotesStartHandler();
|
||||||
|
|
||||||
protected:
|
protected:
|
||||||
char *myBuffer;
|
char *myBuffer;
|
||||||
const size_t myMaxSize;
|
const std::size_t myMaxSize;
|
||||||
size_t myActualSize;
|
std::size_t myActualSize;
|
||||||
};
|
|
||||||
|
|
||||||
class DocCharReader : public DocReader {
|
|
||||||
|
|
||||||
public:
|
|
||||||
DocCharReader(char *buffer, size_t maxSize);
|
|
||||||
~DocCharReader();
|
|
||||||
|
|
||||||
private:
|
|
||||||
void dataHandler(const char *buffer, size_t len);
|
|
||||||
};
|
};
|
||||||
|
|
||||||
class DocAnsiReader : public DocReader {
|
class DocAnsiReader : public DocReader {
|
||||||
|
|
||||||
public:
|
public:
|
||||||
DocAnsiReader(char *buffer, size_t maxSize);
|
DocAnsiReader(char *buffer, std::size_t maxSize);
|
||||||
~DocAnsiReader();
|
~DocAnsiReader();
|
||||||
|
|
||||||
private:
|
private:
|
||||||
void ansiSymbolHandler(ZLUnicodeUtil::Ucs2Char symbol);
|
void ansiDataHandler(const char *buffer, std::size_t len);
|
||||||
};
|
};
|
||||||
|
|
||||||
DocReader::DocReader(char *buffer, size_t maxSize) : myBuffer(buffer), myMaxSize(maxSize), myActualSize(0) {
|
class DocUcs2Reader : public DocReader {
|
||||||
|
|
||||||
|
public:
|
||||||
|
DocUcs2Reader(char *buffer, std::size_t maxSize);
|
||||||
|
~DocUcs2Reader();
|
||||||
|
|
||||||
|
private:
|
||||||
|
void ucs2SymbolHandler(ZLUnicodeUtil::Ucs2Char symbol);
|
||||||
|
};
|
||||||
|
|
||||||
|
DocReader::DocReader(char *buffer, std::size_t maxSize) : myBuffer(buffer), myMaxSize(maxSize), myActualSize(0) {
|
||||||
}
|
}
|
||||||
|
|
||||||
DocReader::~DocReader() {
|
DocReader::~DocReader() {
|
||||||
}
|
}
|
||||||
|
|
||||||
bool DocReader::readStream(OleMainStream &stream) {
|
bool DocReader::readStream(OleMainStream &stream) {
|
||||||
|
// TODO make 2 optmizations:
|
||||||
|
// 1) If another piece is too big, reading of next piece can be stopped if some size parameter will be specified
|
||||||
|
// (it can be transfered as a parameter (with default 0 value, that means no need to use it) to readNextPiece method)
|
||||||
|
// 2) We can specify as a parameter for readNextPiece, what kind of piece should be read next (ANSI or not ANSI).
|
||||||
|
// As type of piece is known already, there's no necessary to read other pieces.
|
||||||
while (myActualSize < myMaxSize) {
|
while (myActualSize < myMaxSize) {
|
||||||
if (!readNextPiece(stream)) {
|
if (!readNextPiece(stream)) {
|
||||||
break;
|
break;
|
||||||
|
@ -78,50 +83,50 @@ bool DocReader::readStream(OleMainStream &stream) {
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
void DocReader::dataHandler(const char*, size_t) {
|
void DocReader::ansiDataHandler(const char*, std::size_t) {
|
||||||
}
|
}
|
||||||
|
|
||||||
void DocReader::ansiSymbolHandler(ZLUnicodeUtil::Ucs2Char) {
|
void DocReader::ucs2SymbolHandler(ZLUnicodeUtil::Ucs2Char) {
|
||||||
}
|
}
|
||||||
|
|
||||||
void DocReader::footnoteHandler() {
|
void DocReader::footnotesStartHandler() {
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t DocReader::readSize() const {
|
std::size_t DocReader::readSize() const {
|
||||||
return myActualSize;
|
return myActualSize;
|
||||||
}
|
}
|
||||||
|
|
||||||
DocCharReader::DocCharReader(char *buffer, size_t maxSize) : DocReader(buffer, maxSize) {
|
DocAnsiReader::DocAnsiReader(char *buffer, std::size_t maxSize) : DocReader(buffer, maxSize) {
|
||||||
}
|
|
||||||
|
|
||||||
DocCharReader::~DocCharReader() {
|
|
||||||
}
|
|
||||||
|
|
||||||
void DocCharReader::dataHandler(const char *buffer, size_t dataLength) {
|
|
||||||
if (myActualSize < myMaxSize) {
|
|
||||||
const size_t len = std::min(dataLength, myMaxSize - myActualSize);
|
|
||||||
strncpy(myBuffer + myActualSize, buffer, len);
|
|
||||||
myActualSize += len;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
DocAnsiReader::DocAnsiReader(char *buffer, size_t maxSize) : DocReader(buffer, maxSize) {
|
|
||||||
}
|
}
|
||||||
|
|
||||||
DocAnsiReader::~DocAnsiReader() {
|
DocAnsiReader::~DocAnsiReader() {
|
||||||
}
|
}
|
||||||
|
|
||||||
void DocAnsiReader::ansiSymbolHandler(ZLUnicodeUtil::Ucs2Char symbol) {
|
void DocAnsiReader::ansiDataHandler(const char *buffer, std::size_t dataLength) {
|
||||||
if (myActualSize < myMaxSize) {
|
if (myActualSize < myMaxSize) {
|
||||||
char buffer[4];
|
const std::size_t len = std::min(dataLength, myMaxSize - myActualSize);
|
||||||
const size_t dataLength = ZLUnicodeUtil::ucs2ToUtf8(buffer, symbol);
|
std::strncpy(myBuffer + myActualSize, buffer, len);
|
||||||
const size_t len = std::min(dataLength, myMaxSize - myActualSize);
|
|
||||||
strncpy(myBuffer + myActualSize, buffer, len);
|
|
||||||
myActualSize += len;
|
myActualSize += len;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
DocStream::DocStream(const ZLFile& file, size_t maxSize) : myFile(file), myBuffer(0), mySize(maxSize) {
|
DocUcs2Reader::DocUcs2Reader(char *buffer, std::size_t maxSize) : DocReader(buffer, maxSize) {
|
||||||
|
}
|
||||||
|
|
||||||
|
DocUcs2Reader::~DocUcs2Reader() {
|
||||||
|
}
|
||||||
|
|
||||||
|
void DocUcs2Reader::ucs2SymbolHandler(ZLUnicodeUtil::Ucs2Char symbol) {
|
||||||
|
if (myActualSize < myMaxSize) {
|
||||||
|
char buffer[4];
|
||||||
|
const std::size_t dataLength = ZLUnicodeUtil::ucs2ToUtf8(buffer, symbol);
|
||||||
|
const std::size_t len = std::min(dataLength, myMaxSize - myActualSize);
|
||||||
|
std::strncpy(myBuffer + myActualSize, buffer, len);
|
||||||
|
myActualSize += len;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
DocStream::DocStream(const ZLFile& file, std::size_t maxSize) : myFile(file), myBuffer(0), mySize(maxSize) {
|
||||||
}
|
}
|
||||||
|
|
||||||
DocStream::~DocStream() {
|
DocStream::~DocStream() {
|
||||||
|
@ -137,7 +142,7 @@ bool DocStream::open() {
|
||||||
if (stream.isNull() || !stream->open()) {
|
if (stream.isNull() || !stream->open()) {
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
if (!reader->readDocument(stream)) {
|
if (!reader->readDocument(stream, false)) {
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
mySize = reader->readSize();
|
mySize = reader->readSize();
|
||||||
|
@ -145,10 +150,10 @@ bool DocStream::open() {
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t DocStream::read(char *buffer, size_t maxSize) {
|
std::size_t DocStream::read(char *buffer, std::size_t maxSize) {
|
||||||
maxSize = std::min(maxSize, mySize - myOffset);
|
maxSize = std::min(maxSize, mySize - myOffset);
|
||||||
if ((buffer != 0) && (myBuffer !=0)) {
|
if (buffer != 0 && myBuffer != 0) {
|
||||||
memcpy(buffer, myBuffer + myOffset, maxSize);
|
std::memcpy(buffer, myBuffer + myOffset, maxSize);
|
||||||
}
|
}
|
||||||
myOffset += maxSize;
|
myOffset += maxSize;
|
||||||
return maxSize;
|
return maxSize;
|
||||||
|
@ -165,33 +170,33 @@ void DocStream::seek(int offset, bool absoluteOffset) {
|
||||||
if (!absoluteOffset) {
|
if (!absoluteOffset) {
|
||||||
offset += myOffset;
|
offset += myOffset;
|
||||||
}
|
}
|
||||||
myOffset = std::min(mySize, (size_t)std::max(0, offset));
|
myOffset = std::min(mySize, (std::size_t)std::max(0, offset));
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t DocStream::offset() const {
|
std::size_t DocStream::offset() const {
|
||||||
return myOffset;
|
return myOffset;
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t DocStream::sizeOfOpened() {
|
std::size_t DocStream::sizeOfOpened() {
|
||||||
return mySize;
|
return mySize;
|
||||||
}
|
}
|
||||||
|
|
||||||
DocCharStream::DocCharStream(const ZLFile& file, size_t maxSize) : DocStream(file, maxSize) {
|
DocAnsiStream::DocAnsiStream(const ZLFile& file, std::size_t maxSize) : DocStream(file, maxSize) {
|
||||||
}
|
|
||||||
|
|
||||||
DocCharStream::~DocCharStream() {
|
|
||||||
}
|
|
||||||
|
|
||||||
shared_ptr<DocReader> DocCharStream::createReader(char *buffer, size_t maxSize) {
|
|
||||||
return new DocCharReader(buffer, maxSize);
|
|
||||||
}
|
|
||||||
|
|
||||||
DocAnsiStream::DocAnsiStream(const ZLFile& file, size_t maxSize) : DocStream(file, maxSize) {
|
|
||||||
}
|
}
|
||||||
|
|
||||||
DocAnsiStream::~DocAnsiStream() {
|
DocAnsiStream::~DocAnsiStream() {
|
||||||
}
|
}
|
||||||
|
|
||||||
shared_ptr<DocReader> DocAnsiStream::createReader(char *buffer, size_t maxSize) {
|
shared_ptr<DocReader> DocAnsiStream::createReader(char *buffer, std::size_t maxSize) {
|
||||||
return new DocAnsiReader(buffer, maxSize);
|
return new DocAnsiReader(buffer, maxSize);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
DocUcs2Stream::DocUcs2Stream(const ZLFile& file, std::size_t maxSize) : DocStream(file, maxSize) {
|
||||||
|
}
|
||||||
|
|
||||||
|
DocUcs2Stream::~DocUcs2Stream() {
|
||||||
|
}
|
||||||
|
|
||||||
|
shared_ptr<DocReader> DocUcs2Stream::createReader(char *buffer, std::size_t maxSize) {
|
||||||
|
return new DocUcs2Reader(buffer, maxSize);
|
||||||
|
}
|
||||||
|
|
|
@ -28,46 +28,46 @@ class DocReader;
|
||||||
class DocStream : public ZLInputStream {
|
class DocStream : public ZLInputStream {
|
||||||
|
|
||||||
public:
|
public:
|
||||||
DocStream(const ZLFile& file, size_t maxSize);
|
DocStream(const ZLFile& file, std::size_t maxSize);
|
||||||
~DocStream();
|
~DocStream();
|
||||||
|
|
||||||
private:
|
private:
|
||||||
bool open();
|
bool open();
|
||||||
size_t read(char *buffer, size_t maxSize);
|
std::size_t read(char *buffer, std::size_t maxSize);
|
||||||
void close();
|
void close();
|
||||||
|
|
||||||
void seek(int offset, bool absoluteOffset);
|
void seek(int offset, bool absoluteOffset);
|
||||||
size_t offset() const;
|
std::size_t offset() const;
|
||||||
size_t sizeOfOpened();
|
std::size_t sizeOfOpened();
|
||||||
|
|
||||||
protected:
|
protected:
|
||||||
virtual shared_ptr<DocReader> createReader(char *buffer, size_t maxSize) = 0;
|
virtual shared_ptr<DocReader> createReader(char *buffer, std::size_t maxSize) = 0;
|
||||||
|
|
||||||
private:
|
private:
|
||||||
const ZLFile myFile;
|
const ZLFile myFile;
|
||||||
char *myBuffer;
|
char *myBuffer;
|
||||||
size_t mySize;
|
std::size_t mySize;
|
||||||
size_t myOffset;
|
std::size_t myOffset;
|
||||||
};
|
|
||||||
|
|
||||||
class DocCharStream : public DocStream {
|
|
||||||
|
|
||||||
public:
|
|
||||||
DocCharStream(const ZLFile& file, size_t maxSize);
|
|
||||||
~DocCharStream();
|
|
||||||
|
|
||||||
private:
|
|
||||||
shared_ptr<DocReader> createReader(char *buffer, size_t maxSize);
|
|
||||||
};
|
};
|
||||||
|
|
||||||
class DocAnsiStream : public DocStream {
|
class DocAnsiStream : public DocStream {
|
||||||
|
|
||||||
public:
|
public:
|
||||||
DocAnsiStream(const ZLFile& file, size_t maxSize);
|
DocAnsiStream(const ZLFile& file, std::size_t maxSize);
|
||||||
~DocAnsiStream();
|
~DocAnsiStream();
|
||||||
|
|
||||||
private:
|
private:
|
||||||
shared_ptr<DocReader> createReader(char *buffer, size_t maxSize);
|
shared_ptr<DocReader> createReader(char *buffer, std::size_t maxSize);
|
||||||
|
};
|
||||||
|
|
||||||
|
class DocUcs2Stream : public DocStream {
|
||||||
|
|
||||||
|
public:
|
||||||
|
DocUcs2Stream(const ZLFile& file, std::size_t maxSize);
|
||||||
|
~DocUcs2Stream();
|
||||||
|
|
||||||
|
private:
|
||||||
|
shared_ptr<DocReader> createReader(char *buffer, std::size_t maxSize);
|
||||||
};
|
};
|
||||||
|
|
||||||
#endif /* __DOCSTREAMS_H__ */
|
#endif /* __DOCSTREAMS_H__ */
|
||||||
|
|
|
@ -56,12 +56,12 @@ OleMainStream::FloatImageInfo::FloatImageInfo() : ShapeId(0) {
|
||||||
OleMainStream::OleMainStream(shared_ptr<OleStorage> storage, OleEntry oleEntry, shared_ptr<ZLInputStream> stream) : OleStream(storage, oleEntry, stream) {
|
OleMainStream::OleMainStream(shared_ptr<OleStorage> storage, OleEntry oleEntry, shared_ptr<ZLInputStream> stream) : OleStream(storage, oleEntry, stream) {
|
||||||
}
|
}
|
||||||
|
|
||||||
bool OleMainStream::open() {
|
bool OleMainStream::open(bool doReadFormattingData) {
|
||||||
if (OleStream::open() == false) {
|
if (OleStream::open() == false) {
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
|
||||||
static const size_t HEADER_SIZE = 768; //size of data in header of main stream
|
static const std::size_t HEADER_SIZE = 768; //size of data in header of main stream
|
||||||
char headerBuffer[HEADER_SIZE];
|
char headerBuffer[HEADER_SIZE];
|
||||||
seek(0, true);
|
seek(0, true);
|
||||||
|
|
||||||
|
@ -83,7 +83,8 @@ bool OleMainStream::open() {
|
||||||
|
|
||||||
if (!result) {
|
if (!result) {
|
||||||
// cant't find table stream (that can be only in case if file format is below Word 7/8), so building simple table stream
|
// cant't find table stream (that can be only in case if file format is below Word 7/8), so building simple table stream
|
||||||
// TODO: CHECK may be not all old documents have ANSI
|
// TODO: CHECK may be not all old documents have ANSI
|
||||||
|
ZLLogger::Instance().println("DocPlugin", "cant't find table stream, building own simple piece table, that includes all charachters");
|
||||||
Piece piece = {myStartOfText, myEndOfText - myStartOfText, true, Piece::PIECE_TEXT, 0};
|
Piece piece = {myStartOfText, myEndOfText - myStartOfText, true, Piece::PIECE_TEXT, 0};
|
||||||
myPieces.push_back(piece);
|
myPieces.push_back(piece);
|
||||||
return true;
|
return true;
|
||||||
|
@ -92,10 +93,14 @@ bool OleMainStream::open() {
|
||||||
result = readPieceTable(headerBuffer, tableEntry);
|
result = readPieceTable(headerBuffer, tableEntry);
|
||||||
|
|
||||||
if (!result) {
|
if (!result) {
|
||||||
ZLLogger::Instance().println("OleMainStream", "error during reading piece table");
|
ZLLogger::Instance().println("DocPlugin", "error during reading piece table");
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
if (!doReadFormattingData) {
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
OleEntry dataEntry;
|
OleEntry dataEntry;
|
||||||
if (myStorage->getEntryByName("Data", dataEntry)) {
|
if (myStorage->getEntryByName("Data", dataEntry)) {
|
||||||
myDataStream = new OleStream(myStorage, dataEntry, myBaseStream);
|
myDataStream = new OleStream(myStorage, dataEntry, myBaseStream);
|
||||||
|
@ -155,27 +160,27 @@ bool OleMainStream::readFIB(const char *headerBuffer) {
|
||||||
int flags = OleUtil::getU2Bytes(headerBuffer, 0xA); //offset for flags
|
int flags = OleUtil::getU2Bytes(headerBuffer, 0xA); //offset for flags
|
||||||
|
|
||||||
if (flags & 0x0004) { //flag for complex format
|
if (flags & 0x0004) { //flag for complex format
|
||||||
ZLLogger::Instance().println("OleMainStream", "This was fast-saved. Some information is lost");
|
ZLLogger::Instance().println("DocPlugin", "This was fast-saved. Some information is lost");
|
||||||
//lostInfo = (flags & 0xF0) >> 4);
|
//lostInfo = (flags & 0xF0) >> 4);
|
||||||
}
|
}
|
||||||
|
|
||||||
if (flags & 0x1000) { //flag for using extending charset
|
if (flags & 0x1000) { //flag for using extending charset
|
||||||
ZLLogger::Instance().println("OleMainStream", "File uses extended character set (get_word8_char)");
|
ZLLogger::Instance().println("DocPlugin", "File uses extended character set (get_word8_char)");
|
||||||
} else {
|
} else {
|
||||||
ZLLogger::Instance().println("OleMainStream", "File uses get_8bit_char character set");
|
ZLLogger::Instance().println("DocPlugin", "File uses get_8bit_char character set");
|
||||||
}
|
}
|
||||||
|
|
||||||
if (flags & 0x100) { //flag for encrypted files
|
if (flags & 0x100) { //flag for encrypted files
|
||||||
ZLLogger::Instance().println("OleMainStream", "File is encrypted");
|
ZLLogger::Instance().println("DocPlugin", "File is encrypted");
|
||||||
// Encryption key = %08lx ; NumUtil::get4Bytes(header, 14)
|
// Encryption key = %08lx ; NumUtil::get4Bytes(header, 14)
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
|
||||||
unsigned int charset = OleUtil::getU2Bytes(headerBuffer, 0x14); //offset for charset number
|
unsigned int charset = OleUtil::getU2Bytes(headerBuffer, 0x14); //offset for charset number
|
||||||
if (charset && charset != 0x100) { //0x100 = default charset
|
if (charset && charset != 0x100) { //0x100 = default charset
|
||||||
ZLLogger::Instance().println("OleMainStream", "Using not default character set %d");
|
ZLLogger::Instance().println("DocPlugin", "Using not default character set %d");
|
||||||
} else {
|
} else {
|
||||||
ZLLogger::Instance().println("OleMainStream", "Using default character set");
|
ZLLogger::Instance().println("DocPlugin", "Using default character set");
|
||||||
}
|
}
|
||||||
|
|
||||||
myStartOfText = OleUtil::get4Bytes(headerBuffer, 0x18); //offset for start of text value
|
myStartOfText = OleUtil::get4Bytes(headerBuffer, 0x18); //offset for start of text value
|
||||||
|
@ -189,7 +194,7 @@ void OleMainStream::splitPieces(const Pieces &s, Pieces &dest1, Pieces &dest2, P
|
||||||
dest2.clear();
|
dest2.clear();
|
||||||
|
|
||||||
int sumLength = 0;
|
int sumLength = 0;
|
||||||
size_t i = 0;
|
std::size_t i = 0;
|
||||||
for (i = 0; i < source.size(); ++i) {
|
for (i = 0; i < source.size(); ++i) {
|
||||||
Piece piece = source.at(i);
|
Piece piece = source.at(i);
|
||||||
if (piece.Length + sumLength >= boundary) {
|
if (piece.Length + sumLength >= boundary) {
|
||||||
|
@ -229,17 +234,27 @@ std::string OleMainStream::getPiecesTableBuffer(const char *headerBuffer, OleStr
|
||||||
|
|
||||||
//1 step : loading CLX table from table stream
|
//1 step : loading CLX table from table stream
|
||||||
char *clxBuffer = new char[clxLength];
|
char *clxBuffer = new char[clxLength];
|
||||||
tableStream.seek(clxOffset, true);
|
if (!tableStream.seek(clxOffset, true)) {
|
||||||
tableStream.read(clxBuffer, clxLength);
|
ZLLogger::Instance().println("DocPlugin", "getPiecesTableBuffer -- error for seeking to CLX structure");
|
||||||
|
return std::string();
|
||||||
|
}
|
||||||
|
if (tableStream.read(clxBuffer, clxLength) != clxLength) {
|
||||||
|
ZLLogger::Instance().println("DocPlugin", "getPiecesTableBuffer -- CLX structure length is invalid");
|
||||||
|
return std::string();
|
||||||
|
}
|
||||||
std::string clx(clxBuffer, clxLength);
|
std::string clx(clxBuffer, clxLength);
|
||||||
delete[] clxBuffer;
|
delete[] clxBuffer;
|
||||||
|
|
||||||
//2 step: searching for pieces table buffer at CLX
|
//2 step: searching for pieces table buffer at CLX
|
||||||
//(determines it by 0x02 as start symbol)
|
//(determines it by 0x02 as start symbol)
|
||||||
size_t from = 0;
|
std::size_t from = 0;
|
||||||
size_t i;
|
std::size_t i;
|
||||||
std::string pieceTableBuffer;
|
std::string pieceTableBuffer;
|
||||||
while ((i = clx.find_first_of(0x02, from)) != std::string::npos) {
|
while ((i = clx.find_first_of(0x02, from)) != std::string::npos) {
|
||||||
|
if (clx.size() < i + 1 + 4) {
|
||||||
|
ZLLogger::Instance().println("DocPlugin", "getPiecesTableBuffer -- CLX structure has invalid format");
|
||||||
|
return std::string();
|
||||||
|
}
|
||||||
unsigned int pieceTableLength = OleUtil::getU4Bytes(clx.c_str(), i + 1);
|
unsigned int pieceTableLength = OleUtil::getU4Bytes(clx.c_str(), i + 1);
|
||||||
pieceTableBuffer = std::string(clx, i + 1 + 4);
|
pieceTableBuffer = std::string(clx, i + 1 + 4);
|
||||||
if (pieceTableBuffer.length() != pieceTableLength) {
|
if (pieceTableBuffer.length() != pieceTableLength) {
|
||||||
|
@ -256,6 +271,10 @@ bool OleMainStream::readPieceTable(const char *headerBuffer, const OleEntry &tab
|
||||||
OleStream tableStream(myStorage, tableEntry, myBaseStream);
|
OleStream tableStream(myStorage, tableEntry, myBaseStream);
|
||||||
std::string piecesTableBuffer = getPiecesTableBuffer(headerBuffer, tableStream);
|
std::string piecesTableBuffer = getPiecesTableBuffer(headerBuffer, tableStream);
|
||||||
|
|
||||||
|
if (piecesTableBuffer.empty()) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
//getting count of Character Positions for different types of subdocuments in Main Stream
|
//getting count of Character Positions for different types of subdocuments in Main Stream
|
||||||
int ccpText = OleUtil::get4Bytes(headerBuffer, 0x004C); //text
|
int ccpText = OleUtil::get4Bytes(headerBuffer, 0x004C); //text
|
||||||
int ccpFtn = OleUtil::get4Bytes(headerBuffer, 0x0050); //footnote subdocument
|
int ccpFtn = OleUtil::get4Bytes(headerBuffer, 0x0050); //footnote subdocument
|
||||||
|
@ -275,6 +294,10 @@ bool OleMainStream::readPieceTable(const char *headerBuffer, const OleEntry &tab
|
||||||
std::vector<int> cp; //array of character positions for pieces
|
std::vector<int> cp; //array of character positions for pieces
|
||||||
unsigned int j = 0;
|
unsigned int j = 0;
|
||||||
for (j = 0; ; j += 4) {
|
for (j = 0; ; j += 4) {
|
||||||
|
if (piecesTableBuffer.size() < j + 4) {
|
||||||
|
ZLLogger::Instance().println("DocPlugin", "invalid piece table, cp ends not with a lastcp");
|
||||||
|
break;
|
||||||
|
}
|
||||||
int curCP = OleUtil::get4Bytes(piecesTableBuffer.c_str(), j);
|
int curCP = OleUtil::get4Bytes(piecesTableBuffer.c_str(), j);
|
||||||
cp.push_back(curCP);
|
cp.push_back(curCP);
|
||||||
if (curCP == lastCP) {
|
if (curCP == lastCP) {
|
||||||
|
@ -282,15 +305,31 @@ bool OleMainStream::readPieceTable(const char *headerBuffer, const OleEntry &tab
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
if (cp.size() < 2) {
|
||||||
|
ZLLogger::Instance().println("DocPlugin", "invalid piece table, < 2 pieces");
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
std::vector<std::string> descriptors;
|
std::vector<std::string> descriptors;
|
||||||
for (size_t k = 0; k < cp.size() - 1; ++k) {
|
for (std::size_t k = 0; k < cp.size() - 1; ++k) {
|
||||||
//j + 4, because it should be taken after CP in PiecesTable Buffer
|
//j + 4, because it should be taken after CP in PiecesTable Buffer
|
||||||
//k * 8, because it should be taken 8 byte for each descriptor
|
//k * 8, because it should be taken 8 byte for each descriptor
|
||||||
descriptors.push_back(piecesTableBuffer.substr(j + 4 + k * 8, 8));
|
std::size_t substrFrom = j + 4 + k * 8;
|
||||||
|
if (piecesTableBuffer.size() < substrFrom + 8) {
|
||||||
|
ZLLogger::Instance().println("DocPlugin", "invalid piece table, problems with descriptors reading");
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
descriptors.push_back(piecesTableBuffer.substr(substrFrom, 8));
|
||||||
}
|
}
|
||||||
|
|
||||||
//filling the Pieces vector
|
//filling the Pieces vector
|
||||||
for (size_t i = 0; i < descriptors.size(); ++i) {
|
std::size_t minValidSize = std::min(cp.size() - 1, descriptors.size());
|
||||||
|
if (minValidSize == 0) {
|
||||||
|
ZLLogger::Instance().println("DocPlugin", "invalid piece table, there are no pieces");
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
for (std::size_t i = 0; i < minValidSize; ++i) {
|
||||||
//4byte integer with offset and ANSI flag
|
//4byte integer with offset and ANSI flag
|
||||||
int fcValue = OleUtil::get4Bytes(descriptors.at(i).c_str(), 0x2); //offset for piece structure
|
int fcValue = OleUtil::get4Bytes(descriptors.at(i).c_str(), 0x2); //offset for piece structure
|
||||||
Piece piece;
|
Piece piece;
|
||||||
|
@ -306,18 +345,18 @@ bool OleMainStream::readPieceTable(const char *headerBuffer, const OleEntry &tab
|
||||||
splitPieces(piecesFootnote, piecesFootnote, piecesOther, Piece::PIECE_FOOTNOTE, Piece::PIECE_OTHER, ccpFtn);
|
splitPieces(piecesFootnote, piecesFootnote, piecesOther, Piece::PIECE_FOOTNOTE, Piece::PIECE_OTHER, ccpFtn);
|
||||||
|
|
||||||
myPieces.clear();
|
myPieces.clear();
|
||||||
for (size_t i = 0; i < piecesText.size(); ++i) {
|
for (std::size_t i = 0; i < piecesText.size(); ++i) {
|
||||||
myPieces.push_back(piecesText.at(i));
|
myPieces.push_back(piecesText.at(i));
|
||||||
}
|
}
|
||||||
for (size_t i = 0; i < piecesFootnote.size(); ++i) {
|
for (std::size_t i = 0; i < piecesFootnote.size(); ++i) {
|
||||||
myPieces.push_back(piecesFootnote.at(i));
|
myPieces.push_back(piecesFootnote.at(i));
|
||||||
}
|
}
|
||||||
for (size_t i = 0; i < piecesOther.size(); ++i) {
|
for (std::size_t i = 0; i < piecesOther.size(); ++i) {
|
||||||
myPieces.push_back(piecesOther.at(i));
|
myPieces.push_back(piecesOther.at(i));
|
||||||
}
|
}
|
||||||
|
|
||||||
//converting length and offset depending on isANSI
|
//converting length and offset depending on isANSI
|
||||||
for (size_t i = 0; i < myPieces.size(); ++i) {
|
for (std::size_t i = 0; i < myPieces.size(); ++i) {
|
||||||
Piece &piece = myPieces.at(i);
|
Piece &piece = myPieces.at(i);
|
||||||
if (!piece.IsANSI) {
|
if (!piece.IsANSI) {
|
||||||
piece.Length *= 2;
|
piece.Length *= 2;
|
||||||
|
@ -328,7 +367,7 @@ bool OleMainStream::readPieceTable(const char *headerBuffer, const OleEntry &tab
|
||||||
|
|
||||||
//filling startCP field
|
//filling startCP field
|
||||||
unsigned int curStartCP = 0;
|
unsigned int curStartCP = 0;
|
||||||
for (size_t i = 0; i < myPieces.size(); ++i) {
|
for (std::size_t i = 0; i < myPieces.size(); ++i) {
|
||||||
Piece &piece = myPieces.at(i);
|
Piece &piece = myPieces.at(i);
|
||||||
piece.startCP = curStartCP;
|
piece.startCP = curStartCP;
|
||||||
if (piece.IsANSI) {
|
if (piece.IsANSI) {
|
||||||
|
@ -343,7 +382,7 @@ bool OleMainStream::readPieceTable(const char *headerBuffer, const OleEntry &tab
|
||||||
bool OleMainStream::readBookmarks(const char *headerBuffer, const OleEntry &tableEntry) {
|
bool OleMainStream::readBookmarks(const char *headerBuffer, const OleEntry &tableEntry) {
|
||||||
//SttbfBkmk structure is a table of bookmark name strings
|
//SttbfBkmk structure is a table of bookmark name strings
|
||||||
unsigned int beginNamesInfo = OleUtil::getU4Bytes(headerBuffer, 0x142); // address of SttbfBkmk structure
|
unsigned int beginNamesInfo = OleUtil::getU4Bytes(headerBuffer, 0x142); // address of SttbfBkmk structure
|
||||||
size_t namesInfoLength = (size_t)OleUtil::getU4Bytes(headerBuffer, 0x146); // length of SttbfBkmk structure
|
std::size_t namesInfoLength = (std::size_t)OleUtil::getU4Bytes(headerBuffer, 0x146); // length of SttbfBkmk structure
|
||||||
|
|
||||||
if (namesInfoLength == 0) {
|
if (namesInfoLength == 0) {
|
||||||
return true; //there's no bookmarks
|
return true; //there's no bookmarks
|
||||||
|
@ -360,7 +399,11 @@ bool OleMainStream::readBookmarks(const char *headerBuffer, const OleEntry &tabl
|
||||||
std::vector<std::string> names;
|
std::vector<std::string> names;
|
||||||
unsigned int offset = 0x6; //initial offset
|
unsigned int offset = 0x6; //initial offset
|
||||||
for (unsigned int i = 0; i < recordsNumber; ++i) {
|
for (unsigned int i = 0; i < recordsNumber; ++i) {
|
||||||
unsigned int length = OleUtil::getU2Bytes(buffer.c_str(), offset) * 2; //legnth of string in bytes
|
if (buffer.size() < offset + 2) {
|
||||||
|
ZLLogger::Instance().println("DocPlugin", "problmes with reading bookmarks names");
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
unsigned int length = OleUtil::getU2Bytes(buffer.c_str(), offset) * 2; //length of string in bytes
|
||||||
ZLUnicodeUtil::Ucs2String name;
|
ZLUnicodeUtil::Ucs2String name;
|
||||||
for (unsigned int j = 0; j < length; j+=2) {
|
for (unsigned int j = 0; j < length; j+=2) {
|
||||||
char ch1 = buffer.at(offset + 2 + j);
|
char ch1 = buffer.at(offset + 2 + j);
|
||||||
|
@ -376,7 +419,7 @@ bool OleMainStream::readBookmarks(const char *headerBuffer, const OleEntry &tabl
|
||||||
|
|
||||||
//plcfBkmkf structure is table recording beginning CPs of bookmarks
|
//plcfBkmkf structure is table recording beginning CPs of bookmarks
|
||||||
unsigned int beginCharPosInfo = OleUtil::getU4Bytes(headerBuffer, 0x14A); // address of plcfBkmkf structure
|
unsigned int beginCharPosInfo = OleUtil::getU4Bytes(headerBuffer, 0x14A); // address of plcfBkmkf structure
|
||||||
size_t charPosInfoLen = (size_t)OleUtil::getU4Bytes(headerBuffer, 0x14E); // length of plcfBkmkf structure
|
std::size_t charPosInfoLen = (std::size_t)OleUtil::getU4Bytes(headerBuffer, 0x14E); // length of plcfBkmkf structure
|
||||||
|
|
||||||
if (charPosInfoLen == 0) {
|
if (charPosInfoLen == 0) {
|
||||||
return true; //there's no bookmarks
|
return true; //there's no bookmarks
|
||||||
|
@ -387,13 +430,13 @@ bool OleMainStream::readBookmarks(const char *headerBuffer, const OleEntry &tabl
|
||||||
}
|
}
|
||||||
|
|
||||||
static const unsigned int BKF_SIZE = 4;
|
static const unsigned int BKF_SIZE = 4;
|
||||||
size_t size = calcCountOfPLC(charPosInfoLen, BKF_SIZE);
|
std::size_t size = calcCountOfPLC(charPosInfoLen, BKF_SIZE);
|
||||||
std::vector<unsigned int> charPage;
|
std::vector<unsigned int> charPage;
|
||||||
for (size_t index = 0, offset = 0; index < size; ++index, offset += 4) {
|
for (std::size_t index = 0, offset = 0; index < size; ++index, offset += 4) {
|
||||||
charPage.push_back(OleUtil::getU4Bytes(buffer.c_str(), offset));
|
charPage.push_back(OleUtil::getU4Bytes(buffer.c_str(), offset));
|
||||||
}
|
}
|
||||||
|
|
||||||
for (size_t i = 0; i < names.size(); ++i) {
|
for (std::size_t i = 0; i < names.size(); ++i) {
|
||||||
if (i >= charPage.size()) {
|
if (i >= charPage.size()) {
|
||||||
break; //for the case if something in these structures goes wrong, to not to lose all bookmarks
|
break; //for the case if something in these structures goes wrong, to not to lose all bookmarks
|
||||||
}
|
}
|
||||||
|
@ -409,28 +452,32 @@ bool OleMainStream::readBookmarks(const char *headerBuffer, const OleEntry &tabl
|
||||||
bool OleMainStream::readStylesheet(const char *headerBuffer, const OleEntry &tableEntry) {
|
bool OleMainStream::readStylesheet(const char *headerBuffer, const OleEntry &tableEntry) {
|
||||||
//STSH structure is a stylesheet
|
//STSH structure is a stylesheet
|
||||||
unsigned int beginStshInfo = OleUtil::getU4Bytes(headerBuffer, 0xa2); // address of STSH structure
|
unsigned int beginStshInfo = OleUtil::getU4Bytes(headerBuffer, 0xa2); // address of STSH structure
|
||||||
size_t stshInfoLength = (size_t)OleUtil::getU4Bytes(headerBuffer, 0xa6); // length of STSH structure
|
std::size_t stshInfoLength = (std::size_t)OleUtil::getU4Bytes(headerBuffer, 0xa6); // length of STSH structure
|
||||||
|
|
||||||
OleStream tableStream(myStorage, tableEntry, myBaseStream);
|
OleStream tableStream(myStorage, tableEntry, myBaseStream);
|
||||||
char *buffer = new char[stshInfoLength];
|
char *buffer = new char[stshInfoLength];
|
||||||
tableStream.seek(beginStshInfo, true);
|
if (!tableStream.seek(beginStshInfo, true)) {
|
||||||
|
ZLLogger::Instance().println("DocPlugin", "problems with reading STSH structure");
|
||||||
|
return false;
|
||||||
|
}
|
||||||
if (tableStream.read(buffer, stshInfoLength) != stshInfoLength) {
|
if (tableStream.read(buffer, stshInfoLength) != stshInfoLength) {
|
||||||
|
ZLLogger::Instance().println("DocPlugin", "problems with reading STSH structure, invalid length");
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t stdCount = (size_t)OleUtil::getU2Bytes(buffer, 2);
|
std::size_t stdCount = (std::size_t)OleUtil::getU2Bytes(buffer, 2);
|
||||||
size_t stdBaseInFile = (size_t)OleUtil::getU2Bytes(buffer, 4);
|
std::size_t stdBaseInFile = (std::size_t)OleUtil::getU2Bytes(buffer, 4);
|
||||||
myStyleSheet.resize(stdCount);
|
myStyleSheet.resize(stdCount);
|
||||||
|
|
||||||
std::vector<bool> isFilled;
|
std::vector<bool> isFilled;
|
||||||
isFilled.resize(stdCount, false);
|
isFilled.resize(stdCount, false);
|
||||||
|
|
||||||
size_t stdLen = 0;
|
std::size_t stdLen = 0;
|
||||||
bool styleSheetWasChanged = false;
|
bool styleSheetWasChanged = false;
|
||||||
do { //make it in while loop, because some base style can be after their successors
|
do { //make it in while loop, because some base style can be after their successors
|
||||||
styleSheetWasChanged = false;
|
styleSheetWasChanged = false;
|
||||||
for (size_t index = 0, offset = 2 + (size_t)OleUtil::getU2Bytes(buffer, 0); index < stdCount; index++, offset += 2 + stdLen) {
|
for (std::size_t index = 0, offset = 2 + (std::size_t)OleUtil::getU2Bytes(buffer, 0); index < stdCount; index++, offset += 2 + stdLen) {
|
||||||
stdLen = (size_t)OleUtil::getU2Bytes(buffer, offset);
|
stdLen = (std::size_t)OleUtil::getU2Bytes(buffer, offset);
|
||||||
if (isFilled.at(index)) {
|
if (isFilled.at(index)) {
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
|
@ -468,8 +515,8 @@ bool OleMainStream::readStylesheet(const char *headerBuffer, const OleEntry &tab
|
||||||
isFilled[index] = true;
|
isFilled[index] = true;
|
||||||
styleSheetWasChanged = true;
|
styleSheetWasChanged = true;
|
||||||
|
|
||||||
size_t pos = 2 + stdBaseInFile;
|
std::size_t pos = 2 + stdBaseInFile;
|
||||||
size_t nameLen = (size_t)OleUtil::getU2Bytes(buffer, offset + pos);
|
std::size_t nameLen = (std::size_t)OleUtil::getU2Bytes(buffer, offset + pos);
|
||||||
nameLen = nameLen * 2 + 2; //from Unicode characters to bytes + Unicode null charachter length
|
nameLen = nameLen * 2 + 2; //from Unicode characters to bytes + Unicode null charachter length
|
||||||
pos += 2 + nameLen;
|
pos += 2 + nameLen;
|
||||||
if (pos % 2 != 0) {
|
if (pos % 2 != 0) {
|
||||||
|
@ -478,7 +525,7 @@ bool OleMainStream::readStylesheet(const char *headerBuffer, const OleEntry &tab
|
||||||
if (pos >= stdLen) {
|
if (pos >= stdLen) {
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
size_t upxLen = (size_t)OleUtil::getU2Bytes(buffer, offset + pos);
|
std::size_t upxLen = (std::size_t)OleUtil::getU2Bytes(buffer, offset + pos);
|
||||||
if (pos + upxLen > stdLen) {
|
if (pos + upxLen > stdLen) {
|
||||||
//UPX length too large
|
//UPX length too large
|
||||||
continue;
|
continue;
|
||||||
|
@ -494,7 +541,7 @@ bool OleMainStream::readStylesheet(const char *headerBuffer, const OleEntry &tab
|
||||||
if (pos % 2 != 0) {
|
if (pos % 2 != 0) {
|
||||||
++pos;
|
++pos;
|
||||||
}
|
}
|
||||||
upxLen = (size_t)OleUtil::getU2Bytes(buffer, offset + pos);
|
upxLen = (std::size_t)OleUtil::getU2Bytes(buffer, offset + pos);
|
||||||
}
|
}
|
||||||
if (upxLen == 0 || pos + upxLen > stdLen) {
|
if (upxLen == 0 || pos + upxLen > stdLen) {
|
||||||
//too small/too large
|
//too small/too large
|
||||||
|
@ -516,7 +563,7 @@ bool OleMainStream::readStylesheet(const char *headerBuffer, const OleEntry &tab
|
||||||
bool OleMainStream::readCharInfoTable(const char *headerBuffer, const OleEntry &tableEntry) {
|
bool OleMainStream::readCharInfoTable(const char *headerBuffer, const OleEntry &tableEntry) {
|
||||||
//PlcfbteChpx structure is table with formatting for particular run of text
|
//PlcfbteChpx structure is table with formatting for particular run of text
|
||||||
unsigned int beginCharInfo = OleUtil::getU4Bytes(headerBuffer, 0xfa); // address of PlcfbteChpx structure
|
unsigned int beginCharInfo = OleUtil::getU4Bytes(headerBuffer, 0xfa); // address of PlcfbteChpx structure
|
||||||
size_t charInfoLength = (size_t)OleUtil::getU4Bytes(headerBuffer, 0xfe); // length of PlcfbteChpx structure
|
std::size_t charInfoLength = (std::size_t)OleUtil::getU4Bytes(headerBuffer, 0xfe); // length of PlcfbteChpx structure
|
||||||
if (charInfoLength < 4) {
|
if (charInfoLength < 4) {
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
@ -528,14 +575,14 @@ bool OleMainStream::readCharInfoTable(const char *headerBuffer, const OleEntry &
|
||||||
}
|
}
|
||||||
|
|
||||||
static const unsigned int CHPX_SIZE = 4;
|
static const unsigned int CHPX_SIZE = 4;
|
||||||
size_t size = calcCountOfPLC(charInfoLength, CHPX_SIZE);
|
std::size_t size = calcCountOfPLC(charInfoLength, CHPX_SIZE);
|
||||||
std::vector<unsigned int> charBlocks;
|
std::vector<unsigned int> charBlocks;
|
||||||
for (size_t index = 0, offset = (size + 1) * 4; index < size; ++index, offset += CHPX_SIZE) {
|
for (std::size_t index = 0, offset = (size + 1) * 4; index < size; ++index, offset += CHPX_SIZE) {
|
||||||
charBlocks.push_back(OleUtil::getU4Bytes(buffer.c_str(), offset));
|
charBlocks.push_back(OleUtil::getU4Bytes(buffer.c_str(), offset));
|
||||||
}
|
}
|
||||||
|
|
||||||
char *formatPageBuffer = new char[OleStorage::BBD_BLOCK_SIZE];
|
char *formatPageBuffer = new char[OleStorage::BBD_BLOCK_SIZE];
|
||||||
for (size_t index = 0; index < charBlocks.size(); ++index) {
|
for (std::size_t index = 0; index < charBlocks.size(); ++index) {
|
||||||
seek(charBlocks.at(index) * OleStorage::BBD_BLOCK_SIZE, true);
|
seek(charBlocks.at(index) * OleStorage::BBD_BLOCK_SIZE, true);
|
||||||
if (read(formatPageBuffer, OleStorage::BBD_BLOCK_SIZE) != OleStorage::BBD_BLOCK_SIZE) {
|
if (read(formatPageBuffer, OleStorage::BBD_BLOCK_SIZE) != OleStorage::BBD_BLOCK_SIZE) {
|
||||||
return false;
|
return false;
|
||||||
|
@ -587,16 +634,15 @@ bool OleMainStream::readFloatingImages(const char *headerBuffer, const OleEntry
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
static const unsigned int SPA_SIZE = 26;
|
static const unsigned int SPA_SIZE = 26;
|
||||||
size_t size = calcCountOfPLC(picturesInfoLength, SPA_SIZE);
|
std::size_t size = calcCountOfPLC(picturesInfoLength, SPA_SIZE);
|
||||||
|
|
||||||
std::vector<unsigned int> picturesBlocks;
|
std::vector<unsigned int> picturesBlocks;
|
||||||
for (size_t index = 0, tOffset = 0; index < size; ++index, tOffset += 4) {
|
for (std::size_t index = 0, tOffset = 0; index < size; ++index, tOffset += 4) {
|
||||||
picturesBlocks.push_back(OleUtil::getU4Bytes(buffer.c_str(), tOffset));
|
picturesBlocks.push_back(OleUtil::getU4Bytes(buffer.c_str(), tOffset));
|
||||||
}
|
}
|
||||||
|
|
||||||
for (size_t index = 0, tOffset = (size + 1) * 4; index < size; ++index, tOffset += SPA_SIZE) {
|
for (std::size_t index = 0, tOffset = (size + 1) * 4; index < size; ++index, tOffset += SPA_SIZE) {
|
||||||
unsigned int spid = OleUtil::getU4Bytes(buffer.c_str(), tOffset);
|
unsigned int spid = OleUtil::getU4Bytes(buffer.c_str(), tOffset);
|
||||||
FloatImageInfo info;
|
FloatImageInfo info;
|
||||||
unsigned int charPos = picturesBlocks.at(index);
|
unsigned int charPos = picturesBlocks.at(index);
|
||||||
|
@ -626,7 +672,7 @@ bool OleMainStream::readFloatingImages(const char *headerBuffer, const OleEntry
|
||||||
bool OleMainStream::readParagraphStyleTable(const char *headerBuffer, const OleEntry &tableEntry) {
|
bool OleMainStream::readParagraphStyleTable(const char *headerBuffer, const OleEntry &tableEntry) {
|
||||||
//PlcBtePapx structure is table with formatting for all paragraphs
|
//PlcBtePapx structure is table with formatting for all paragraphs
|
||||||
unsigned int beginParagraphInfo = OleUtil::getU4Bytes(headerBuffer, 0x102); // address of PlcBtePapx structure
|
unsigned int beginParagraphInfo = OleUtil::getU4Bytes(headerBuffer, 0x102); // address of PlcBtePapx structure
|
||||||
size_t paragraphInfoLength = (size_t)OleUtil::getU4Bytes(headerBuffer, 0x106); // length of PlcBtePapx structure
|
std::size_t paragraphInfoLength = (std::size_t)OleUtil::getU4Bytes(headerBuffer, 0x106); // length of PlcBtePapx structure
|
||||||
if (paragraphInfoLength < 4) {
|
if (paragraphInfoLength < 4) {
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
@ -638,15 +684,15 @@ bool OleMainStream::readParagraphStyleTable(const char *headerBuffer, const OleE
|
||||||
}
|
}
|
||||||
|
|
||||||
static const unsigned int PAPX_SIZE = 4;
|
static const unsigned int PAPX_SIZE = 4;
|
||||||
size_t size = calcCountOfPLC(paragraphInfoLength, PAPX_SIZE);
|
std::size_t size = calcCountOfPLC(paragraphInfoLength, PAPX_SIZE);
|
||||||
|
|
||||||
std::vector<unsigned int> paragraphBlocks;
|
std::vector<unsigned int> paragraphBlocks;
|
||||||
for (size_t index = 0, tOffset = (size + 1) * 4; index < size; ++index, tOffset += PAPX_SIZE) {
|
for (std::size_t index = 0, tOffset = (size + 1) * 4; index < size; ++index, tOffset += PAPX_SIZE) {
|
||||||
paragraphBlocks.push_back(OleUtil::getU4Bytes(buffer.c_str(), tOffset));
|
paragraphBlocks.push_back(OleUtil::getU4Bytes(buffer.c_str(), tOffset));
|
||||||
}
|
}
|
||||||
|
|
||||||
char *formatPageBuffer = new char[OleStorage::BBD_BLOCK_SIZE];
|
char *formatPageBuffer = new char[OleStorage::BBD_BLOCK_SIZE];
|
||||||
for (size_t index = 0; index < paragraphBlocks.size(); ++index) {
|
for (std::size_t index = 0; index < paragraphBlocks.size(); ++index) {
|
||||||
seek(paragraphBlocks.at(index) * OleStorage::BBD_BLOCK_SIZE, true);
|
seek(paragraphBlocks.at(index) * OleStorage::BBD_BLOCK_SIZE, true);
|
||||||
if (read(formatPageBuffer, OleStorage::BBD_BLOCK_SIZE) != OleStorage::BBD_BLOCK_SIZE) {
|
if (read(formatPageBuffer, OleStorage::BBD_BLOCK_SIZE) != OleStorage::BBD_BLOCK_SIZE) {
|
||||||
return false;
|
return false;
|
||||||
|
@ -687,7 +733,7 @@ bool OleMainStream::readSectionsInfoTable(const char *headerBuffer, const OleEnt
|
||||||
unsigned int beginOfText = OleUtil::getU4Bytes(headerBuffer, 0x18); //address of text's begin in main stream
|
unsigned int beginOfText = OleUtil::getU4Bytes(headerBuffer, 0x18); //address of text's begin in main stream
|
||||||
unsigned int beginSectInfo = OleUtil::getU4Bytes(headerBuffer, 0xca); //address if PlcfSed structure
|
unsigned int beginSectInfo = OleUtil::getU4Bytes(headerBuffer, 0xca); //address if PlcfSed structure
|
||||||
|
|
||||||
size_t sectInfoLen = (size_t)OleUtil::getU4Bytes(headerBuffer, 0xce); //length of PlcfSed structure
|
std::size_t sectInfoLen = (std::size_t)OleUtil::getU4Bytes(headerBuffer, 0xce); //length of PlcfSed structure
|
||||||
if (sectInfoLen < 4) {
|
if (sectInfoLen < 4) {
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
@ -699,24 +745,24 @@ bool OleMainStream::readSectionsInfoTable(const char *headerBuffer, const OleEnt
|
||||||
}
|
}
|
||||||
|
|
||||||
static const unsigned int SED_SIZE = 12;
|
static const unsigned int SED_SIZE = 12;
|
||||||
size_t decriptorsCount = calcCountOfPLC(sectInfoLen, SED_SIZE);
|
std::size_t decriptorsCount = calcCountOfPLC(sectInfoLen, SED_SIZE);
|
||||||
|
|
||||||
//saving the section offsets (in character positions)
|
//saving the section offsets (in character positions)
|
||||||
std::vector<unsigned int> charPos;
|
std::vector<unsigned int> charPos;
|
||||||
for (size_t index = 0, tOffset = 0; index < decriptorsCount; ++index, tOffset += 4) {
|
for (std::size_t index = 0, tOffset = 0; index < decriptorsCount; ++index, tOffset += 4) {
|
||||||
unsigned int ulTextOffset = OleUtil::getU4Bytes(buffer.c_str(), tOffset);
|
unsigned int ulTextOffset = OleUtil::getU4Bytes(buffer.c_str(), tOffset);
|
||||||
charPos.push_back(beginOfText + ulTextOffset);
|
charPos.push_back(beginOfText + ulTextOffset);
|
||||||
}
|
}
|
||||||
|
|
||||||
//saving sepx offsets
|
//saving sepx offsets
|
||||||
std::vector<unsigned int> sectPage;
|
std::vector<unsigned int> sectPage;
|
||||||
for (size_t index = 0, tOffset = (decriptorsCount + 1) * 4; index < decriptorsCount; ++index, tOffset += SED_SIZE) {
|
for (std::size_t index = 0, tOffset = (decriptorsCount + 1) * 4; index < decriptorsCount; ++index, tOffset += SED_SIZE) {
|
||||||
sectPage.push_back(OleUtil::getU4Bytes(buffer.c_str(), tOffset + 2));
|
sectPage.push_back(OleUtil::getU4Bytes(buffer.c_str(), tOffset + 2));
|
||||||
}
|
}
|
||||||
|
|
||||||
//reading the section properties
|
//reading the section properties
|
||||||
char tmpBuffer[2];
|
char tmpBuffer[2];
|
||||||
for (size_t index = 0; index < sectPage.size(); ++index) {
|
for (std::size_t index = 0; index < sectPage.size(); ++index) {
|
||||||
if (sectPage.at(index) == 0xffffffffUL) { //check for invalid record, to make default section info
|
if (sectPage.at(index) == 0xffffffffUL) { //check for invalid record, to make default section info
|
||||||
SectionInfo sectionInfo;
|
SectionInfo sectionInfo;
|
||||||
sectionInfo.CharPosition = charPos.at(index);
|
sectionInfo.CharPosition = charPos.at(index);
|
||||||
|
@ -730,7 +776,7 @@ bool OleMainStream::readSectionsInfoTable(const char *headerBuffer, const OleEnt
|
||||||
if (read(tmpBuffer, 2) != 2) {
|
if (read(tmpBuffer, 2) != 2) {
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
size_t bytes = 2 + (size_t)OleUtil::getU2Bytes(tmpBuffer, 0);
|
std::size_t bytes = 2 + (std::size_t)OleUtil::getU2Bytes(tmpBuffer, 0);
|
||||||
|
|
||||||
if (!seek(sectPage.at(index), true)) {
|
if (!seek(sectPage.at(index), true)) {
|
||||||
continue;
|
continue;
|
||||||
|
@ -863,9 +909,9 @@ void OleMainStream::getCharInfo(unsigned int chpxOffset, unsigned int /*styleId*
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
void OleMainStream::getSectionInfo(const char *grpprlBuffer, size_t bytes, SectionInfo §ionInfo) {
|
void OleMainStream::getSectionInfo(const char *grpprlBuffer, std::size_t bytes, SectionInfo §ionInfo) {
|
||||||
unsigned int tmp;
|
unsigned int tmp;
|
||||||
size_t offset = 0;
|
std::size_t offset = 0;
|
||||||
while (bytes >= offset + 2) {
|
while (bytes >= offset + 2) {
|
||||||
switch (OleUtil::getU2Bytes(grpprlBuffer, offset)) {
|
switch (OleUtil::getU2Bytes(grpprlBuffer, offset)) {
|
||||||
case 0x3009: //new page
|
case 0x3009: //new page
|
||||||
|
@ -916,7 +962,7 @@ OleMainStream::Style OleMainStream::getStyleFromStylesheet(unsigned int styleId,
|
||||||
//TODO optimize it: StyleSheet can be map structure with styleId key
|
//TODO optimize it: StyleSheet can be map structure with styleId key
|
||||||
Style style;
|
Style style;
|
||||||
if (styleId != Style::STYLE_INVALID && styleId != Style::STYLE_NIL && styleId != Style::STYLE_USER) {
|
if (styleId != Style::STYLE_INVALID && styleId != Style::STYLE_NIL && styleId != Style::STYLE_USER) {
|
||||||
for (size_t index = 0; index < stylesheet.size(); ++index) {
|
for (std::size_t index = 0; index < stylesheet.size(); ++index) {
|
||||||
if (stylesheet.at(index).StyleIdCurrent == styleId) {
|
if (stylesheet.at(index).StyleIdCurrent == styleId) {
|
||||||
return stylesheet.at(index);
|
return stylesheet.at(index);
|
||||||
}
|
}
|
||||||
|
@ -942,7 +988,7 @@ int OleMainStream::getStyleIndex(unsigned int styleId, const std::vector<bool> &
|
||||||
|
|
||||||
unsigned int OleMainStream::getStyleIdByCharPos(unsigned int charPos, const StyleInfoList &styleInfoList) {
|
unsigned int OleMainStream::getStyleIdByCharPos(unsigned int charPos, const StyleInfoList &styleInfoList) {
|
||||||
unsigned int styleId = Style::STYLE_INVALID;
|
unsigned int styleId = Style::STYLE_INVALID;
|
||||||
for (size_t i = 0; i < styleInfoList.size(); ++i) {
|
for (std::size_t i = 0; i < styleInfoList.size(); ++i) {
|
||||||
const Style &info = styleInfoList.at(i).second;
|
const Style &info = styleInfoList.at(i).second;
|
||||||
if (i == styleInfoList.size() - 1) { //if last
|
if (i == styleInfoList.size() - 1) { //if last
|
||||||
styleId = info.StyleIdCurrent;
|
styleId = info.StyleIdCurrent;
|
||||||
|
@ -970,8 +1016,8 @@ bool OleMainStream::offsetToCharPos(unsigned int offset, unsigned int &charPos,
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t pieceNumber = 0;
|
std::size_t pieceNumber = 0;
|
||||||
for (size_t i = 0; i < pieces.size(); ++i) {
|
for (std::size_t i = 0; i < pieces.size(); ++i) {
|
||||||
if (i == pieces.size() - 1) { //if last
|
if (i == pieces.size() - 1) { //if last
|
||||||
pieceNumber = i;
|
pieceNumber = i;
|
||||||
break;
|
break;
|
||||||
|
@ -993,7 +1039,7 @@ bool OleMainStream::offsetToCharPos(unsigned int offset, unsigned int &charPos,
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
bool OleMainStream::readToBuffer(std::string &result, unsigned int offset, size_t length, OleStream &stream) {
|
bool OleMainStream::readToBuffer(std::string &result, unsigned int offset, std::size_t length, OleStream &stream) {
|
||||||
char *buffer = new char[length];
|
char *buffer = new char[length];
|
||||||
stream.seek(offset, true);
|
stream.seek(offset, true);
|
||||||
if (stream.read(buffer, length) != length) {
|
if (stream.read(buffer, length) != length) {
|
||||||
|
|
|
@ -150,7 +150,7 @@ public:
|
||||||
OleMainStream(shared_ptr<OleStorage> storage, OleEntry oleEntry, shared_ptr<ZLInputStream> stream);
|
OleMainStream(shared_ptr<OleStorage> storage, OleEntry oleEntry, shared_ptr<ZLInputStream> stream);
|
||||||
|
|
||||||
public:
|
public:
|
||||||
bool open();
|
bool open(bool doReadFormattingData);
|
||||||
const Pieces &getPieces() const;
|
const Pieces &getPieces() const;
|
||||||
const CharInfoList &getCharInfoList() const;
|
const CharInfoList &getCharInfoList() const;
|
||||||
const StyleInfoList &getStyleInfoList() const;
|
const StyleInfoList &getStyleInfoList() const;
|
||||||
|
@ -179,7 +179,7 @@ private: //formatting reader helpers methods
|
||||||
static unsigned int getPrlLength(const char *grpprlBuffer, unsigned int byteNumber);
|
static unsigned int getPrlLength(const char *grpprlBuffer, unsigned int byteNumber);
|
||||||
static void getCharInfo(unsigned int chpxOffset, unsigned int styleId, const char *grpprlBuffer, unsigned int bytes, CharInfo &charInfo);
|
static void getCharInfo(unsigned int chpxOffset, unsigned int styleId, const char *grpprlBuffer, unsigned int bytes, CharInfo &charInfo);
|
||||||
static void getStyleInfo(unsigned int papxOffset, const char *grpprlBuffer, unsigned int bytes, Style &styleInfo);
|
static void getStyleInfo(unsigned int papxOffset, const char *grpprlBuffer, unsigned int bytes, Style &styleInfo);
|
||||||
static void getSectionInfo(const char *grpprlBuffer, size_t bytes, SectionInfo §ionInfo);
|
static void getSectionInfo(const char *grpprlBuffer, std::size_t bytes, SectionInfo §ionInfo);
|
||||||
static bool getInlineImageInfo(unsigned int chpxOffset, const char *grpprlBuffer, unsigned int bytes, InlineImageInfo &pictureInfo);
|
static bool getInlineImageInfo(unsigned int chpxOffset, const char *grpprlBuffer, unsigned int bytes, InlineImageInfo &pictureInfo);
|
||||||
|
|
||||||
static Style getStyleFromStylesheet(unsigned int styleId, const StyleSheet &stylesheet);
|
static Style getStyleFromStylesheet(unsigned int styleId, const StyleSheet &stylesheet);
|
||||||
|
@ -187,7 +187,7 @@ private: //formatting reader helpers methods
|
||||||
static unsigned int getStyleIdByCharPos(unsigned int offset, const StyleInfoList &styleInfoList);
|
static unsigned int getStyleIdByCharPos(unsigned int offset, const StyleInfoList &styleInfoList);
|
||||||
|
|
||||||
static bool offsetToCharPos(unsigned int offset, unsigned int &charPos, const Pieces &pieces);
|
static bool offsetToCharPos(unsigned int offset, unsigned int &charPos, const Pieces &pieces);
|
||||||
static bool readToBuffer(std::string &result, unsigned int offset, size_t length, OleStream &stream);
|
static bool readToBuffer(std::string &result, unsigned int offset, std::size_t length, OleStream &stream);
|
||||||
|
|
||||||
static unsigned int calcCountOfPLC(unsigned int totalSize, unsigned int elementSize);
|
static unsigned int calcCountOfPLC(unsigned int totalSize, unsigned int elementSize);
|
||||||
|
|
||||||
|
|
|
@ -24,7 +24,7 @@
|
||||||
|
|
||||||
#include <cstring>
|
#include <cstring>
|
||||||
|
|
||||||
const size_t OleStorage::BBD_BLOCK_SIZE = 512;
|
const std::size_t OleStorage::BBD_BLOCK_SIZE = 512;
|
||||||
|
|
||||||
OleStorage::OleStorage() {
|
OleStorage::OleStorage() {
|
||||||
clear();
|
clear();
|
||||||
|
@ -46,7 +46,7 @@ void OleStorage::clear() {
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
bool OleStorage::init(shared_ptr<ZLInputStream> stream, size_t streamSize) {
|
bool OleStorage::init(shared_ptr<ZLInputStream> stream, std::size_t streamSize) {
|
||||||
clear();
|
clear();
|
||||||
|
|
||||||
myInputStream = stream;
|
myInputStream = stream;
|
||||||
|
@ -54,13 +54,13 @@ bool OleStorage::init(shared_ptr<ZLInputStream> stream, size_t streamSize) {
|
||||||
myInputStream->seek(0, true);
|
myInputStream->seek(0, true);
|
||||||
|
|
||||||
char oleBuf[BBD_BLOCK_SIZE];
|
char oleBuf[BBD_BLOCK_SIZE];
|
||||||
size_t ret = myInputStream->read(oleBuf, BBD_BLOCK_SIZE);
|
std::size_t ret = myInputStream->read(oleBuf, BBD_BLOCK_SIZE);
|
||||||
if (ret != BBD_BLOCK_SIZE) {
|
if (ret != BBD_BLOCK_SIZE) {
|
||||||
clear();
|
clear();
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
static const char OLE_SIGN[] = {0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1, 0};
|
static const char OLE_SIGN[] = {0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1, 0};
|
||||||
if (strncmp(oleBuf, OLE_SIGN, 8) != 0) {
|
if (std::strncmp(oleBuf, OLE_SIGN, 8) != 0) {
|
||||||
clear();
|
clear();
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
@ -85,11 +85,11 @@ bool OleStorage::readDIFAT(char *oleBuf) {
|
||||||
|
|
||||||
//for files > 6.78 mb we need read additional DIFAT fields
|
//for files > 6.78 mb we need read additional DIFAT fields
|
||||||
for (int i = 0; difatBlock > 0 && i < difatSectorNumbers; ++i) {
|
for (int i = 0; difatBlock > 0 && i < difatSectorNumbers; ++i) {
|
||||||
ZLLogger::Instance().println("OleStorage", "Read additional data for DIFAT");
|
ZLLogger::Instance().println("DocPlugin", "Read additional data for DIFAT");
|
||||||
char buffer[mySectorSize];
|
char buffer[mySectorSize];
|
||||||
myInputStream->seek(BBD_BLOCK_SIZE + difatBlock * mySectorSize, true);
|
myInputStream->seek(BBD_BLOCK_SIZE + difatBlock * mySectorSize, true);
|
||||||
if (myInputStream->read(buffer, mySectorSize) != mySectorSize) {
|
if (myInputStream->read(buffer, mySectorSize) != mySectorSize) {
|
||||||
ZLLogger::Instance().println("OleStorage", "Error read DIFAT!");
|
ZLLogger::Instance().println("DocPlugin", "Error read DIFAT!");
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
for (unsigned int j = 0; j < (mySectorSize - 4); j += 4) {
|
for (unsigned int j = 0; j < (mySectorSize - 4); j += 4) {
|
||||||
|
@ -112,19 +112,19 @@ bool OleStorage::readBBD(char *oleBuf) {
|
||||||
|
|
||||||
if (myDIFAT.size() < bbdNumberBlocks) {
|
if (myDIFAT.size() < bbdNumberBlocks) {
|
||||||
//TODO maybe add check on myDIFAT == bbdNumberBlocks
|
//TODO maybe add check on myDIFAT == bbdNumberBlocks
|
||||||
ZLLogger::Instance().println("OleStorage", "Wrong number of FAT blocks value");
|
ZLLogger::Instance().println("DocPlugin", "Wrong number of FAT blocks value");
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
|
||||||
for (unsigned int i = 0; i < bbdNumberBlocks; ++i) {
|
for (unsigned int i = 0; i < bbdNumberBlocks; ++i) {
|
||||||
int bbdSector = myDIFAT.at(i);
|
int bbdSector = myDIFAT.at(i);
|
||||||
if (bbdSector >= (int)(myStreamSize / mySectorSize) || bbdSector < 0) {
|
if (bbdSector >= (int)(myStreamSize / mySectorSize) || bbdSector < 0) {
|
||||||
ZLLogger::Instance().println("OleStorage", "Bad BBD entry!");
|
ZLLogger::Instance().println("DocPlugin", "Bad BBD entry!");
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
myInputStream->seek(BBD_BLOCK_SIZE + bbdSector * mySectorSize, true);
|
myInputStream->seek(BBD_BLOCK_SIZE + bbdSector * mySectorSize, true);
|
||||||
if (myInputStream->read(buffer, mySectorSize) != mySectorSize) {
|
if (myInputStream->read(buffer, mySectorSize) != mySectorSize) {
|
||||||
ZLLogger::Instance().println("OleStorage", "Error during reading BBD!");
|
ZLLogger::Instance().println("DocPlugin", "Error during reading BBD!");
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
for (unsigned int j = 0; j < mySectorSize; j += 4) {
|
for (unsigned int j = 0; j < mySectorSize; j += 4) {
|
||||||
|
@ -139,7 +139,7 @@ bool OleStorage::readSBD(char *oleBuf) {
|
||||||
int sbdCount = OleUtil::get4Bytes(oleBuf, 0x40); //count of small sectors
|
int sbdCount = OleUtil::get4Bytes(oleBuf, 0x40); //count of small sectors
|
||||||
|
|
||||||
if (sbdCur <= 0) {
|
if (sbdCur <= 0) {
|
||||||
ZLLogger::Instance().println("OleStorage", "There's no SBD, don't read it");
|
ZLLogger::Instance().println("DocPlugin", "There's no SBD, don't read it");
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -147,7 +147,7 @@ bool OleStorage::readSBD(char *oleBuf) {
|
||||||
for (int i = 0; i < sbdCount; ++i) {
|
for (int i = 0; i < sbdCount; ++i) {
|
||||||
if (i != 0) {
|
if (i != 0) {
|
||||||
if (sbdCur < 0 || (unsigned int)sbdCur >= myBBD.size()) {
|
if (sbdCur < 0 || (unsigned int)sbdCur >= myBBD.size()) {
|
||||||
ZLLogger::Instance().println("OleStorage", "error during parsing SBD");
|
ZLLogger::Instance().println("DocPlugin", "error during parsing SBD");
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
sbdCur = myBBD.at(sbdCur);
|
sbdCur = myBBD.at(sbdCur);
|
||||||
|
@ -157,7 +157,7 @@ bool OleStorage::readSBD(char *oleBuf) {
|
||||||
}
|
}
|
||||||
myInputStream->seek(BBD_BLOCK_SIZE + sbdCur * mySectorSize, true);
|
myInputStream->seek(BBD_BLOCK_SIZE + sbdCur * mySectorSize, true);
|
||||||
if (myInputStream->read(buffer, mySectorSize) != mySectorSize) {
|
if (myInputStream->read(buffer, mySectorSize) != mySectorSize) {
|
||||||
ZLLogger::Instance().println("OleStorage", "reading error during parsing SBD");
|
ZLLogger::Instance().println("DocPlugin", "reading error during parsing SBD");
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
for (unsigned int j = 0; j < mySectorSize; j += 4) {
|
for (unsigned int j = 0; j < mySectorSize; j += 4) {
|
||||||
|
@ -171,7 +171,7 @@ bool OleStorage::readSBD(char *oleBuf) {
|
||||||
bool OleStorage::readProperties(char *oleBuf) {
|
bool OleStorage::readProperties(char *oleBuf) {
|
||||||
int propCur = OleUtil::get4Bytes(oleBuf, 0x30); //offset for address of sector with first property
|
int propCur = OleUtil::get4Bytes(oleBuf, 0x30); //offset for address of sector with first property
|
||||||
if (propCur < 0) {
|
if (propCur < 0) {
|
||||||
ZLLogger::Instance().println("OleStorage", "Wrong first directory sector location");
|
ZLLogger::Instance().println("DocPlugin", "Wrong first directory sector location");
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -179,13 +179,13 @@ bool OleStorage::readProperties(char *oleBuf) {
|
||||||
do {
|
do {
|
||||||
myInputStream->seek(BBD_BLOCK_SIZE + propCur * mySectorSize, true);
|
myInputStream->seek(BBD_BLOCK_SIZE + propCur * mySectorSize, true);
|
||||||
if (myInputStream->read(buffer, mySectorSize) != mySectorSize) {
|
if (myInputStream->read(buffer, mySectorSize) != mySectorSize) {
|
||||||
ZLLogger::Instance().println("OleStorage", "Error during reading properties");
|
ZLLogger::Instance().println("DocPlugin", "Error during reading properties");
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
for (unsigned int j = 0; j < mySectorSize; j += 128) {
|
for (unsigned int j = 0; j < mySectorSize; j += 128) {
|
||||||
myProperties.push_back(std::string(buffer + j, 128));
|
myProperties.push_back(std::string(buffer + j, 128));
|
||||||
}
|
}
|
||||||
if (propCur < 0 || (size_t)propCur >= myBBD.size()) {
|
if (propCur < 0 || (std::size_t)propCur >= myBBD.size()) {
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
propCur = myBBD.at(propCur);
|
propCur = myBBD.at(propCur);
|
||||||
|
@ -219,7 +219,7 @@ bool OleStorage::readOleEntry(int propNumber, OleEntry &e) {
|
||||||
|
|
||||||
char oleType = property.at(0x42); //offset for Ole Type
|
char oleType = property.at(0x42); //offset for Ole Type
|
||||||
if (oleType != 1 && oleType != 2 && oleType != 3 && oleType != 5) {
|
if (oleType != 1 && oleType != 2 && oleType != 3 && oleType != 5) {
|
||||||
ZLLogger::Instance().println("OleStorage", "entry -- not right ole type");
|
ZLLogger::Instance().println("DocPlugin", "entry -- not right ole type");
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -243,14 +243,18 @@ bool OleStorage::readOleEntry(int propNumber, OleEntry &e) {
|
||||||
e.isBigBlock = e.length >= 0x1000 || e.name == ROOT_ENTRY;
|
e.isBigBlock = e.length >= 0x1000 || e.name == ROOT_ENTRY;
|
||||||
|
|
||||||
// Read sector chain
|
// Read sector chain
|
||||||
|
if (property.size() < 0x74 + 4) {
|
||||||
|
ZLLogger::Instance().println("DocPlugin", "problems with reading ole entry");
|
||||||
|
return false;
|
||||||
|
}
|
||||||
int chainCur = OleUtil::get4Bytes(property.c_str(), 0x74); //offset for start block of entry
|
int chainCur = OleUtil::get4Bytes(property.c_str(), 0x74); //offset for start block of entry
|
||||||
if (chainCur >= 0 && (chainCur <= (int)(myStreamSize / (e.isBigBlock ? mySectorSize : myShortSectorSize)))) {
|
if (chainCur >= 0 && (chainCur <= (int)(myStreamSize / (e.isBigBlock ? mySectorSize : myShortSectorSize)))) {
|
||||||
//filling blocks with chains
|
//filling blocks with chains
|
||||||
do {
|
do {
|
||||||
e.blocks.push_back((unsigned int)chainCur);
|
e.blocks.push_back((unsigned int)chainCur);
|
||||||
if (e.isBigBlock && (size_t)chainCur < myBBD.size()) {
|
if (e.isBigBlock && (std::size_t)chainCur < myBBD.size()) {
|
||||||
chainCur = myBBD.at(chainCur);
|
chainCur = myBBD.at(chainCur);
|
||||||
} else if (!mySBD.empty() && (size_t)chainCur < mySBD.size()) {
|
} else if (!mySBD.empty() && (std::size_t)chainCur < mySBD.size()) {
|
||||||
chainCur = mySBD.at(chainCur);
|
chainCur = mySBD.at(chainCur);
|
||||||
} else {
|
} else {
|
||||||
chainCur = -1;
|
chainCur = -1;
|
||||||
|
@ -263,26 +267,38 @@ bool OleStorage::readOleEntry(int propNumber, OleEntry &e) {
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
unsigned int OleStorage::getFileOffsetOfBlock(const OleEntry &e, unsigned int blockNumber) const {
|
bool OleStorage::countFileOffsetOfBlock(const OleEntry &e, unsigned int blockNumber, unsigned int &result) const {
|
||||||
unsigned int res;
|
//TODO maybe better syntax can be used?
|
||||||
|
if (e.blocks.size() <= (std::size_t)blockNumber) {
|
||||||
|
ZLLogger::Instance().println("DocPlugin", "countFileOffsetOfBlock can't be done, blockNumber is invalid");
|
||||||
|
return false;
|
||||||
|
}
|
||||||
if (e.isBigBlock) {
|
if (e.isBigBlock) {
|
||||||
res = BBD_BLOCK_SIZE + e.blocks.at(blockNumber) * mySectorSize;
|
result = BBD_BLOCK_SIZE + e.blocks.at(blockNumber) * mySectorSize;
|
||||||
} else {
|
} else {
|
||||||
unsigned int sbdPerSector = mySectorSize / myShortSectorSize;
|
unsigned int sbdPerSector = mySectorSize / myShortSectorSize;
|
||||||
unsigned int sbdSectorNumber = e.blocks.at(blockNumber) / sbdPerSector;
|
unsigned int sbdSectorNumber = e.blocks.at(blockNumber) / sbdPerSector;
|
||||||
unsigned int sbdSectorMod = e.blocks.at(blockNumber) % sbdPerSector;
|
unsigned int sbdSectorMod = e.blocks.at(blockNumber) % sbdPerSector;
|
||||||
res = BBD_BLOCK_SIZE + myEntries.at(myRootEntryIndex).blocks.at(sbdSectorNumber) * mySectorSize + sbdSectorMod * myShortSectorSize;
|
if (myEntries.at(myRootEntryIndex).blocks.size() <= (std::size_t)sbdSectorNumber) {
|
||||||
|
ZLLogger::Instance().println("DocPlugin", "countFileOffsetOfBlock can't be done, invalid sbd data");
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
result = BBD_BLOCK_SIZE + myEntries.at(myRootEntryIndex).blocks.at(sbdSectorNumber) * mySectorSize + sbdSectorMod * myShortSectorSize;
|
||||||
}
|
}
|
||||||
return res;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
bool OleStorage::getEntryByName(std::string name, OleEntry &returnEntry) const {
|
bool OleStorage::getEntryByName(std::string name, OleEntry &returnEntry) const {
|
||||||
for (size_t i = 0; i < myEntries.size(); ++i) {
|
//TODO fix the workaround for duplicates streams: now it takes a stream with max length
|
||||||
|
unsigned int maxLength = 0;
|
||||||
|
for (std::size_t i = 0; i < myEntries.size(); ++i) {
|
||||||
const OleEntry &entry = myEntries.at(i);
|
const OleEntry &entry = myEntries.at(i);
|
||||||
if (entry.name == name) {
|
if (entry.name == name && entry.length >= maxLength) {
|
||||||
returnEntry = entry;
|
returnEntry = entry;
|
||||||
return true;
|
maxLength = entry.length;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
return false;
|
return maxLength > 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
|
@ -46,11 +46,11 @@ struct OleEntry {
|
||||||
class OleStorage {
|
class OleStorage {
|
||||||
|
|
||||||
public:
|
public:
|
||||||
static const size_t BBD_BLOCK_SIZE;
|
static const std::size_t BBD_BLOCK_SIZE;
|
||||||
|
|
||||||
public:
|
public:
|
||||||
OleStorage();
|
OleStorage();
|
||||||
bool init(shared_ptr<ZLInputStream>, size_t streamSize);
|
bool init(shared_ptr<ZLInputStream>, std::size_t streamSize);
|
||||||
void clear();
|
void clear();
|
||||||
const std::vector<OleEntry> &getEntries() const;
|
const std::vector<OleEntry> &getEntries() const;
|
||||||
bool getEntryByName(std::string name, OleEntry &entry) const;
|
bool getEntryByName(std::string name, OleEntry &entry) const;
|
||||||
|
@ -59,7 +59,7 @@ public:
|
||||||
unsigned int getShortSectorSize() const;
|
unsigned int getShortSectorSize() const;
|
||||||
|
|
||||||
public: //TODO make private
|
public: //TODO make private
|
||||||
unsigned int getFileOffsetOfBlock(const OleEntry &e, unsigned int blockNumber) const;
|
bool countFileOffsetOfBlock(const OleEntry &e, unsigned int blockNumber, unsigned int &result) const;
|
||||||
|
|
||||||
private:
|
private:
|
||||||
bool readDIFAT(char *oleBuf);
|
bool readDIFAT(char *oleBuf);
|
||||||
|
@ -75,7 +75,7 @@ private:
|
||||||
shared_ptr<ZLInputStream> myInputStream;
|
shared_ptr<ZLInputStream> myInputStream;
|
||||||
unsigned int mySectorSize, myShortSectorSize;
|
unsigned int mySectorSize, myShortSectorSize;
|
||||||
|
|
||||||
size_t myStreamSize;
|
std::size_t myStreamSize;
|
||||||
std::vector<int> myDIFAT; //double-indirect file allocation table
|
std::vector<int> myDIFAT; //double-indirect file allocation table
|
||||||
std::vector<int> myBBD; //Big Block Depot
|
std::vector<int> myBBD; //Big Block Depot
|
||||||
std::vector<int> mySBD; //Small Block Depot
|
std::vector<int> mySBD; //Small Block Depot
|
||||||
|
|
|
@ -37,20 +37,20 @@ bool OleStream::open() {
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t OleStream::read(char *buffer, size_t maxSize) {
|
std::size_t OleStream::read(char *buffer, std::size_t maxSize) {
|
||||||
size_t length = maxSize;
|
std::size_t length = maxSize;
|
||||||
size_t readedBytes = 0;
|
std::size_t readedBytes = 0;
|
||||||
size_t bytesLeftInCurBlock;
|
std::size_t bytesLeftInCurBlock;
|
||||||
unsigned int newFileOffset;
|
unsigned int newFileOffset;
|
||||||
|
|
||||||
unsigned int curBlockNumber, modBlock;
|
unsigned int curBlockNumber, modBlock;
|
||||||
size_t toReadBlocks, toReadBytes;
|
std::size_t toReadBlocks, toReadBytes;
|
||||||
|
|
||||||
if (myOleOffset + length > myOleEntry.length) {
|
if (myOleOffset + length > myOleEntry.length) {
|
||||||
length = myOleEntry.length - myOleOffset;
|
length = myOleEntry.length - myOleOffset;
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t sectorSize = (size_t)(myOleEntry.isBigBlock ? myStorage->getSectorSize() : myStorage->getShortSectorSize());
|
std::size_t sectorSize = (std::size_t)(myOleEntry.isBigBlock ? myStorage->getSectorSize() : myStorage->getShortSectorSize());
|
||||||
|
|
||||||
curBlockNumber = myOleOffset / sectorSize;
|
curBlockNumber = myOleOffset / sectorSize;
|
||||||
if (curBlockNumber >= myOleEntry.blocks.size()) {
|
if (curBlockNumber >= myOleEntry.blocks.size()) {
|
||||||
|
@ -65,20 +65,28 @@ size_t OleStream::read(char *buffer, size_t maxSize) {
|
||||||
toReadBlocks = toReadBytes = 0;
|
toReadBlocks = toReadBytes = 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
newFileOffset = myStorage->getFileOffsetOfBlock(myOleEntry, curBlockNumber) + modBlock;
|
if (!myStorage->countFileOffsetOfBlock(myOleEntry, curBlockNumber, newFileOffset)) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
newFileOffset += modBlock;
|
||||||
|
|
||||||
myBaseStream->seek(newFileOffset, true);
|
myBaseStream->seek(newFileOffset, true);
|
||||||
|
|
||||||
readedBytes = myBaseStream->read(buffer, std::min(length, bytesLeftInCurBlock));
|
readedBytes = myBaseStream->read(buffer, std::min(length, bytesLeftInCurBlock));
|
||||||
for (size_t i = 0; i < toReadBlocks; ++i) {
|
for (std::size_t i = 0; i < toReadBlocks; ++i) {
|
||||||
if (++curBlockNumber >= myOleEntry.blocks.size()) {
|
if (++curBlockNumber >= myOleEntry.blocks.size()) {
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
newFileOffset = myStorage->getFileOffsetOfBlock(myOleEntry, curBlockNumber);
|
if (!myStorage->countFileOffsetOfBlock(myOleEntry, curBlockNumber, newFileOffset)) {
|
||||||
|
return readedBytes;
|
||||||
|
}
|
||||||
myBaseStream->seek(newFileOffset, true);
|
myBaseStream->seek(newFileOffset, true);
|
||||||
readedBytes += myBaseStream->read(buffer + readedBytes, std::min(length - readedBytes, sectorSize));
|
readedBytes += myBaseStream->read(buffer + readedBytes, std::min(length - readedBytes, sectorSize));
|
||||||
}
|
}
|
||||||
if (toReadBytes > 0 && ++curBlockNumber < myOleEntry.blocks.size()) {
|
if (toReadBytes > 0 && ++curBlockNumber < myOleEntry.blocks.size()) {
|
||||||
newFileOffset = myStorage->getFileOffsetOfBlock(myOleEntry, curBlockNumber);
|
if (!myStorage->countFileOffsetOfBlock(myOleEntry, curBlockNumber, newFileOffset)) {
|
||||||
|
return readedBytes;
|
||||||
|
}
|
||||||
myBaseStream->seek(newFileOffset, true);
|
myBaseStream->seek(newFileOffset, true);
|
||||||
readedBytes += myBaseStream->read(buffer + readedBytes, toReadBytes);
|
readedBytes += myBaseStream->read(buffer + readedBytes, toReadBytes);
|
||||||
}
|
}
|
||||||
|
@ -113,13 +121,16 @@ bool OleStream::seek(unsigned int offset, bool absoluteOffset) {
|
||||||
}
|
}
|
||||||
|
|
||||||
unsigned int modBlock = newOleOffset % sectorSize;
|
unsigned int modBlock = newOleOffset % sectorSize;
|
||||||
newFileOffset = myStorage->getFileOffsetOfBlock(myOleEntry, blockNumber) + modBlock;
|
if (!myStorage->countFileOffsetOfBlock(myOleEntry, blockNumber, newFileOffset)) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
newFileOffset += modBlock;
|
||||||
myBaseStream->seek(newFileOffset, true);
|
myBaseStream->seek(newFileOffset, true);
|
||||||
myOleOffset = newOleOffset;
|
myOleOffset = newOleOffset;
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t OleStream::offset() {
|
std::size_t OleStream::offset() {
|
||||||
return myOleOffset;
|
return myOleOffset;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -131,7 +142,11 @@ ZLFileImage::Blocks OleStream::getBlockPieceInfoList(unsigned int offset, unsign
|
||||||
return list;
|
return list;
|
||||||
}
|
}
|
||||||
unsigned int modBlock = offset % sectorSize;
|
unsigned int modBlock = offset % sectorSize;
|
||||||
unsigned int startFileOffset = myStorage->getFileOffsetOfBlock(myOleEntry, curBlockNumber) + modBlock;
|
unsigned int startFileOffset = 0;
|
||||||
|
if (!myStorage->countFileOffsetOfBlock(myOleEntry, curBlockNumber, startFileOffset)) {
|
||||||
|
return ZLFileImage::Blocks();
|
||||||
|
}
|
||||||
|
startFileOffset += modBlock;
|
||||||
|
|
||||||
unsigned int bytesLeftInCurBlock = sectorSize - modBlock;
|
unsigned int bytesLeftInCurBlock = sectorSize - modBlock;
|
||||||
unsigned int toReadBlocks = 0, toReadBytes = 0;
|
unsigned int toReadBlocks = 0, toReadBytes = 0;
|
||||||
|
@ -147,13 +162,19 @@ ZLFileImage::Blocks OleStream::getBlockPieceInfoList(unsigned int offset, unsign
|
||||||
if (++curBlockNumber >= myOleEntry.blocks.size()) {
|
if (++curBlockNumber >= myOleEntry.blocks.size()) {
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
unsigned int newFileOffset = myStorage->getFileOffsetOfBlock(myOleEntry, curBlockNumber);
|
unsigned int newFileOffset = 0;
|
||||||
|
if (!myStorage->countFileOffsetOfBlock(myOleEntry, curBlockNumber, newFileOffset)) {
|
||||||
|
return ZLFileImage::Blocks();
|
||||||
|
}
|
||||||
unsigned int readbytes = std::min(size - readedBytes, sectorSize);
|
unsigned int readbytes = std::min(size - readedBytes, sectorSize);
|
||||||
list.push_back(ZLFileImage::Block(newFileOffset, readbytes));
|
list.push_back(ZLFileImage::Block(newFileOffset, readbytes));
|
||||||
readedBytes += readbytes;
|
readedBytes += readbytes;
|
||||||
}
|
}
|
||||||
if (toReadBytes > 0 && ++curBlockNumber < myOleEntry.blocks.size()) {
|
if (toReadBytes > 0 && ++curBlockNumber < myOleEntry.blocks.size()) {
|
||||||
unsigned int newFileOffset = myStorage->getFileOffsetOfBlock(myOleEntry, curBlockNumber);
|
unsigned int newFileOffset = 0;
|
||||||
|
if (!myStorage->countFileOffsetOfBlock(myOleEntry, curBlockNumber, newFileOffset)) {
|
||||||
|
return ZLFileImage::Blocks();
|
||||||
|
}
|
||||||
unsigned int readbytes = toReadBytes;
|
unsigned int readbytes = toReadBytes;
|
||||||
list.push_back(ZLFileImage::Block(newFileOffset, readbytes));
|
list.push_back(ZLFileImage::Block(newFileOffset, readbytes));
|
||||||
readedBytes += readbytes;
|
readedBytes += readbytes;
|
||||||
|
@ -169,7 +190,7 @@ ZLFileImage::Blocks OleStream::concatBlocks(const ZLFileImage::Blocks &blocks) {
|
||||||
ZLFileImage::Blocks optList;
|
ZLFileImage::Blocks optList;
|
||||||
ZLFileImage::Block curBlock = blocks.at(0);
|
ZLFileImage::Block curBlock = blocks.at(0);
|
||||||
unsigned int nextOffset = curBlock.offset + curBlock.size;
|
unsigned int nextOffset = curBlock.offset + curBlock.size;
|
||||||
for (size_t i = 1; i < blocks.size(); ++i) {
|
for (std::size_t i = 1; i < blocks.size(); ++i) {
|
||||||
ZLFileImage::Block b = blocks.at(i);
|
ZLFileImage::Block b = blocks.at(i);
|
||||||
if (b.offset == nextOffset) {
|
if (b.offset == nextOffset) {
|
||||||
curBlock.size += b.size;
|
curBlock.size += b.size;
|
||||||
|
@ -184,12 +205,17 @@ ZLFileImage::Blocks OleStream::concatBlocks(const ZLFileImage::Blocks &blocks) {
|
||||||
return optList;
|
return optList;
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t OleStream::fileOffset() {
|
std::size_t OleStream::fileOffset() {
|
||||||
size_t sectorSize = (size_t)(myOleEntry.isBigBlock ? myStorage->getSectorSize() : myStorage->getShortSectorSize());
|
//TODO maybe remove this method, it doesn't use at this time
|
||||||
|
std::size_t sectorSize = (std::size_t)(myOleEntry.isBigBlock ? myStorage->getSectorSize() : myStorage->getShortSectorSize());
|
||||||
unsigned int curBlockNumber = myOleOffset / sectorSize;
|
unsigned int curBlockNumber = myOleOffset / sectorSize;
|
||||||
if (curBlockNumber >= myOleEntry.blocks.size()) {
|
if (curBlockNumber >= myOleEntry.blocks.size()) {
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
unsigned int modBlock = myOleOffset % sectorSize;
|
unsigned int modBlock = myOleOffset % sectorSize;
|
||||||
return myStorage->getFileOffsetOfBlock(myOleEntry, curBlockNumber) + modBlock;
|
unsigned int curOffset = 0;
|
||||||
|
if (!myStorage->countFileOffsetOfBlock(myOleEntry, curBlockNumber, curOffset)) {
|
||||||
|
return 0; //TODO maybe remove -1?
|
||||||
|
}
|
||||||
|
return curOffset + modBlock;
|
||||||
}
|
}
|
||||||
|
|
|
@ -31,17 +31,17 @@ public:
|
||||||
|
|
||||||
public:
|
public:
|
||||||
bool open();
|
bool open();
|
||||||
size_t read(char *buffer, size_t maxSize);
|
std::size_t read(char *buffer, std::size_t maxSize);
|
||||||
void close();
|
void close();
|
||||||
|
|
||||||
public:
|
public:
|
||||||
bool seek(unsigned int offset, bool absoluteOffset);
|
bool seek(unsigned int offset, bool absoluteOffset);
|
||||||
size_t offset();
|
std::size_t offset();
|
||||||
|
|
||||||
public:
|
public:
|
||||||
ZLFileImage::Blocks getBlockPieceInfoList(unsigned int offset, unsigned int size) const;
|
ZLFileImage::Blocks getBlockPieceInfoList(unsigned int offset, unsigned int size) const;
|
||||||
static ZLFileImage::Blocks concatBlocks(const ZLFileImage::Blocks &blocks);
|
static ZLFileImage::Blocks concatBlocks(const ZLFileImage::Blocks &blocks);
|
||||||
size_t fileOffset();
|
std::size_t fileOffset();
|
||||||
|
|
||||||
public:
|
public:
|
||||||
bool eof() const;
|
bool eof() const;
|
||||||
|
|
|
@ -87,15 +87,15 @@ private:
|
||||||
protected:
|
protected:
|
||||||
ZLUnicodeUtil::Ucs2String myBuffer;
|
ZLUnicodeUtil::Ucs2String myBuffer;
|
||||||
private:
|
private:
|
||||||
size_t myCurBufferPosition;
|
std::size_t myCurBufferPosition;
|
||||||
|
|
||||||
unsigned int myCurCharPos;
|
unsigned int myCurCharPos;
|
||||||
|
|
||||||
size_t myNextStyleInfoIndex;
|
std::size_t myNextStyleInfoIndex;
|
||||||
size_t myNextCharInfoIndex;
|
std::size_t myNextCharInfoIndex;
|
||||||
size_t myNextBookmarkIndex;
|
std::size_t myNextBookmarkIndex;
|
||||||
size_t myNextInlineImageInfoIndex;
|
std::size_t myNextInlineImageInfoIndex;
|
||||||
size_t myNextFloatImageInfoIndex;
|
std::size_t myNextFloatImageInfoIndex;
|
||||||
};
|
};
|
||||||
|
|
||||||
#endif /* __OLESTREAMPARSER_H__ */
|
#endif /* __OLESTREAMPARSER_H__ */
|
||||||
|
|
|
@ -26,13 +26,13 @@
|
||||||
OleStreamReader::OleStreamReader() : myNextPieceNumber(0) {
|
OleStreamReader::OleStreamReader() : myNextPieceNumber(0) {
|
||||||
}
|
}
|
||||||
|
|
||||||
bool OleStreamReader::readDocument(shared_ptr<ZLInputStream> inputStream) {
|
bool OleStreamReader::readDocument(shared_ptr<ZLInputStream> inputStream, bool doReadFormattingData) {
|
||||||
static const std::string WORD_DOCUMENT = "WordDocument";
|
static const std::string WORD_DOCUMENT = "WordDocument";
|
||||||
|
|
||||||
shared_ptr<OleStorage> storage = new OleStorage;
|
shared_ptr<OleStorage> storage = new OleStorage;
|
||||||
|
|
||||||
if (!storage->init(inputStream, inputStream->sizeOfOpened())) {
|
if (!storage->init(inputStream, inputStream->sizeOfOpened())) {
|
||||||
ZLLogger::Instance().println("OleStreamReader", "Broken OLE file");
|
ZLLogger::Instance().println("DocPlugin", "Broken OLE file");
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -42,8 +42,8 @@ bool OleStreamReader::readDocument(shared_ptr<ZLInputStream> inputStream) {
|
||||||
}
|
}
|
||||||
|
|
||||||
OleMainStream oleStream(storage, wordDocumentEntry, inputStream);
|
OleMainStream oleStream(storage, wordDocumentEntry, inputStream);
|
||||||
if (!oleStream.open()) {
|
if (!oleStream.open(doReadFormattingData)) {
|
||||||
ZLLogger::Instance().println("OleStreamReader", "Cannot open OleMainStream");
|
ZLLogger::Instance().println("DocPlugin", "Cannot open OleMainStream");
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
return readStream(oleStream);
|
return readStream(oleStream);
|
||||||
|
@ -57,7 +57,7 @@ bool OleStreamReader::readNextPiece(OleMainStream &stream) {
|
||||||
const OleMainStream::Piece &piece = pieces.at(myNextPieceNumber);
|
const OleMainStream::Piece &piece = pieces.at(myNextPieceNumber);
|
||||||
|
|
||||||
if (piece.Type == OleMainStream::Piece::PIECE_FOOTNOTE) {
|
if (piece.Type == OleMainStream::Piece::PIECE_FOOTNOTE) {
|
||||||
footnoteHandler();
|
footnotesStartHandler();
|
||||||
} else if (piece.Type == OleMainStream::Piece::PIECE_OTHER) {
|
} else if (piece.Type == OleMainStream::Piece::PIECE_OTHER) {
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
@ -67,17 +67,17 @@ bool OleStreamReader::readNextPiece(OleMainStream &stream) {
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
char *textBuffer = new char[piece.Length];
|
char *textBuffer = new char[piece.Length];
|
||||||
size_t readBytes = stream.read(textBuffer, piece.Length);
|
std::size_t readBytes = stream.read(textBuffer, piece.Length);
|
||||||
if (readBytes != (size_t)piece.Length) {
|
if (readBytes != (std::size_t)piece.Length) {
|
||||||
ZLLogger::Instance().println("OleStreamReader", "not all bytes have been read from piece");
|
ZLLogger::Instance().println("DocPlugin", "not all bytes have been read from piece");
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!piece.IsANSI) {
|
if (!piece.IsANSI) {
|
||||||
for (size_t i = 0; i < readBytes; i += 2) {
|
for (std::size_t i = 0; i < readBytes; i += 2) {
|
||||||
ansiSymbolHandler(OleUtil::getU2Bytes(textBuffer, i));
|
ucs2SymbolHandler(OleUtil::getU2Bytes(textBuffer, i));
|
||||||
}
|
}
|
||||||
} else {
|
} else {
|
||||||
dataHandler(textBuffer, readBytes);
|
ansiDataHandler(textBuffer, readBytes);
|
||||||
}
|
}
|
||||||
++myNextPieceNumber;
|
++myNextPieceNumber;
|
||||||
delete[] textBuffer;
|
delete[] textBuffer;
|
||||||
|
|
|
@ -28,19 +28,19 @@ class OleStreamReader {
|
||||||
|
|
||||||
public:
|
public:
|
||||||
OleStreamReader();
|
OleStreamReader();
|
||||||
bool readDocument(shared_ptr<ZLInputStream> stream);
|
bool readDocument(shared_ptr<ZLInputStream> stream, bool doReadFormattingData);
|
||||||
|
|
||||||
protected:
|
protected:
|
||||||
virtual bool readStream(OleMainStream &stream) = 0;
|
virtual bool readStream(OleMainStream &stream) = 0;
|
||||||
|
|
||||||
bool readNextPiece(OleMainStream &stream);
|
bool readNextPiece(OleMainStream &stream);
|
||||||
|
|
||||||
virtual void dataHandler(const char *buffer, size_t len) = 0;
|
virtual void ansiDataHandler(const char *buffer, std::size_t len) = 0;
|
||||||
virtual void ansiSymbolHandler(ZLUnicodeUtil::Ucs2Char symbol) = 0;
|
virtual void ucs2SymbolHandler(ZLUnicodeUtil::Ucs2Char symbol) = 0;
|
||||||
virtual void footnoteHandler() = 0;
|
virtual void footnotesStartHandler() = 0;
|
||||||
|
|
||||||
private:
|
private:
|
||||||
size_t myNextPieceNumber;
|
std::size_t myNextPieceNumber;
|
||||||
};
|
};
|
||||||
|
|
||||||
#endif /* __OLESTREAMREADER_H__ */
|
#endif /* __OLESTREAMREADER_H__ */
|
||||||
|
|
|
@ -32,7 +32,7 @@
|
||||||
|
|
||||||
FB2BookReader::FB2BookReader(BookModel &model) : myModelReader(model) {
|
FB2BookReader::FB2BookReader(BookModel &model) : myModelReader(model) {
|
||||||
myInsideCoverpage = false;
|
myInsideCoverpage = false;
|
||||||
myParagraphsBeforeBodyNumber = (size_t)-1;
|
myParagraphsBeforeBodyNumber = (std::size_t)-1;
|
||||||
myInsidePoem = false;
|
myInsidePoem = false;
|
||||||
mySectionDepth = 0;
|
mySectionDepth = 0;
|
||||||
myBodyCounter = 0;
|
myBodyCounter = 0;
|
||||||
|
@ -42,7 +42,7 @@ FB2BookReader::FB2BookReader(BookModel &model) : myModelReader(model) {
|
||||||
myInsideTitle = false;
|
myInsideTitle = false;
|
||||||
}
|
}
|
||||||
|
|
||||||
void FB2BookReader::characterDataHandler(const char *text, size_t len) {
|
void FB2BookReader::characterDataHandler(const char *text, std::size_t len) {
|
||||||
if ((len > 0) && (!myCurrentImageId.empty() || myModelReader.paragraphIsOpen())) {
|
if ((len > 0) && (!myCurrentImageId.empty() || myModelReader.paragraphIsOpen())) {
|
||||||
std::string str(text, len);
|
std::string str(text, len);
|
||||||
if (!myCurrentImageId.empty()) {
|
if (!myCurrentImageId.empty()) {
|
||||||
|
|
|
@ -34,14 +34,14 @@ public:
|
||||||
bool processNamespaces() const;
|
bool processNamespaces() const;
|
||||||
void startElementHandler(int tag, const char **attributes);
|
void startElementHandler(int tag, const char **attributes);
|
||||||
void endElementHandler(int tag);
|
void endElementHandler(int tag);
|
||||||
void characterDataHandler(const char *text, size_t len);
|
void characterDataHandler(const char *text, std::size_t len);
|
||||||
|
|
||||||
private:
|
private:
|
||||||
int mySectionDepth;
|
int mySectionDepth;
|
||||||
int myBodyCounter;
|
int myBodyCounter;
|
||||||
bool myReadMainText;
|
bool myReadMainText;
|
||||||
bool myInsideCoverpage;
|
bool myInsideCoverpage;
|
||||||
size_t myParagraphsBeforeBodyNumber;
|
std::size_t myParagraphsBeforeBodyNumber;
|
||||||
std::string myCoverImageReference;
|
std::string myCoverImageReference;
|
||||||
bool myInsidePoem;
|
bool myInsidePoem;
|
||||||
BookReader myModelReader;
|
BookReader myModelReader;
|
||||||
|
|
|
@ -84,7 +84,7 @@ void FB2CoverReader::endElementHandler(int tag) {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void FB2CoverReader::characterDataHandler(const char *text, size_t len) {
|
void FB2CoverReader::characterDataHandler(const char *text, std::size_t len) {
|
||||||
if (len > 0 && myLookForImage) {
|
if (len > 0 && myLookForImage) {
|
||||||
myImageStart = getCurrentPosition();
|
myImageStart = getCurrentPosition();
|
||||||
myLookForImage = false;
|
myLookForImage = false;
|
||||||
|
|
|
@ -35,7 +35,7 @@ private:
|
||||||
bool processNamespaces() const;
|
bool processNamespaces() const;
|
||||||
void startElementHandler(int tag, const char **attributes);
|
void startElementHandler(int tag, const char **attributes);
|
||||||
void endElementHandler(int tag);
|
void endElementHandler(int tag);
|
||||||
void characterDataHandler(const char *text, size_t len);
|
void characterDataHandler(const char *text, std::size_t len);
|
||||||
|
|
||||||
private:
|
private:
|
||||||
const ZLFile myFile;
|
const ZLFile myFile;
|
||||||
|
|
|
@ -34,7 +34,7 @@ FB2MetaInfoReader::FB2MetaInfoReader(Book &book) : myBook(book) {
|
||||||
myBook.removeAllTags();
|
myBook.removeAllTags();
|
||||||
}
|
}
|
||||||
|
|
||||||
void FB2MetaInfoReader::characterDataHandler(const char *text, size_t len) {
|
void FB2MetaInfoReader::characterDataHandler(const char *text, std::size_t len) {
|
||||||
switch (myReadState) {
|
switch (myReadState) {
|
||||||
case READ_TITLE:
|
case READ_TITLE:
|
||||||
myBuffer.append(text, len);
|
myBuffer.append(text, len);
|
||||||
|
|
|
@ -34,7 +34,7 @@ public:
|
||||||
|
|
||||||
void startElementHandler(int tag, const char **attributes);
|
void startElementHandler(int tag, const char **attributes);
|
||||||
void endElementHandler(int tag);
|
void endElementHandler(int tag);
|
||||||
void characterDataHandler(const char *text, size_t len);
|
void characterDataHandler(const char *text, std::size_t len);
|
||||||
|
|
||||||
private:
|
private:
|
||||||
Book &myBook;
|
Book &myBook;
|
||||||
|
|
|
@ -401,7 +401,7 @@ HtmlBookReader::HtmlBookReader(const std::string &baseDirectoryPath, BookModel &
|
||||||
HtmlBookReader::~HtmlBookReader() {
|
HtmlBookReader::~HtmlBookReader() {
|
||||||
}
|
}
|
||||||
|
|
||||||
void HtmlBookReader::addConvertedDataToBuffer(const char *text, size_t len, bool convert) {
|
void HtmlBookReader::addConvertedDataToBuffer(const char *text, std::size_t len, bool convert) {
|
||||||
if (len > 0) {
|
if (len > 0) {
|
||||||
if (myDontBreakParagraph) {
|
if (myDontBreakParagraph) {
|
||||||
while ((len > 0) && isspace(*text)) {
|
while ((len > 0) && isspace(*text)) {
|
||||||
|
@ -445,7 +445,7 @@ bool HtmlBookReader::tagHandler(const HtmlTag &tag) {
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
void HtmlBookReader::preformattedCharacterDataHandler(const char *text, size_t len, bool convert) {
|
void HtmlBookReader::preformattedCharacterDataHandler(const char *text, std::size_t len, bool convert) {
|
||||||
const char *start = text;
|
const char *start = text;
|
||||||
const char *end = text + len;
|
const char *end = text + len;
|
||||||
|
|
||||||
|
@ -517,7 +517,7 @@ void HtmlBookReader::preformattedCharacterDataHandler(const char *text, size_t l
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
bool HtmlBookReader::characterDataHandler(const char *text, size_t len, bool convert) {
|
bool HtmlBookReader::characterDataHandler(const char *text, std::size_t len, bool convert) {
|
||||||
if (!myStyleSheetParser.isNull()) {
|
if (!myStyleSheetParser.isNull()) {
|
||||||
myStyleSheetParser->parse(text, len);
|
myStyleSheetParser->parse(text, len);
|
||||||
return true;
|
return true;
|
||||||
|
|
|
@ -50,11 +50,11 @@ protected:
|
||||||
void startDocumentHandler();
|
void startDocumentHandler();
|
||||||
void endDocumentHandler();
|
void endDocumentHandler();
|
||||||
bool tagHandler(const HtmlTag &tag);
|
bool tagHandler(const HtmlTag &tag);
|
||||||
bool characterDataHandler(const char *text, size_t len, bool convert);
|
bool characterDataHandler(const char *text, std::size_t len, bool convert);
|
||||||
|
|
||||||
private:
|
private:
|
||||||
void preformattedCharacterDataHandler(const char *text, size_t len, bool convert);
|
void preformattedCharacterDataHandler(const char *text, std::size_t len, bool convert);
|
||||||
void addConvertedDataToBuffer(const char *text, size_t len, bool convert);
|
void addConvertedDataToBuffer(const char *text, std::size_t len, bool convert);
|
||||||
|
|
||||||
protected:
|
protected:
|
||||||
BookReader myBookReader;
|
BookReader myBookReader;
|
||||||
|
|
|
@ -56,7 +56,7 @@ bool HtmlDescriptionReader::tagHandler(const HtmlTag &tag) {
|
||||||
}
|
}
|
||||||
if (it != tag.Attributes.end()) {
|
if (it != tag.Attributes.end()) {
|
||||||
const std::string prefix = "charset=";
|
const std::string prefix = "charset=";
|
||||||
size_t index = it->Value.find(prefix);
|
std::size_t index = it->Value.find(prefix);
|
||||||
if (index != std::string::npos) {
|
if (index != std::string::npos) {
|
||||||
std::string charset = it->Value.substr(index + prefix.length());
|
std::string charset = it->Value.substr(index + prefix.length());
|
||||||
index = charset.find(';');
|
index = charset.find(';');
|
||||||
|
@ -74,7 +74,7 @@ bool HtmlDescriptionReader::tagHandler(const HtmlTag &tag) {
|
||||||
return tag.Name != "BODY";
|
return tag.Name != "BODY";
|
||||||
}
|
}
|
||||||
|
|
||||||
bool HtmlDescriptionReader::characterDataHandler(const char *text, size_t len, bool) {
|
bool HtmlDescriptionReader::characterDataHandler(const char *text, std::size_t len, bool) {
|
||||||
if (myReadTitle) {
|
if (myReadTitle) {
|
||||||
myBuffer.append(text, len);
|
myBuffer.append(text, len);
|
||||||
}
|
}
|
||||||
|
|
|
@ -35,7 +35,7 @@ protected:
|
||||||
void endDocumentHandler();
|
void endDocumentHandler();
|
||||||
|
|
||||||
bool tagHandler(const HtmlTag &tag);
|
bool tagHandler(const HtmlTag &tag);
|
||||||
bool characterDataHandler(const char *text, size_t len, bool convert);
|
bool characterDataHandler(const char *text, std::size_t len, bool convert);
|
||||||
|
|
||||||
private:
|
private:
|
||||||
bool myReadTitle;
|
bool myReadTitle;
|
||||||
|
|
|
@ -50,8 +50,8 @@ void HtmlReader::setTag(HtmlTag &tag, const std::string &name) {
|
||||||
tag.Name = name.substr(1);
|
tag.Name = name.substr(1);
|
||||||
}
|
}
|
||||||
|
|
||||||
const size_t len = tag.Name.length();
|
const std::size_t len = tag.Name.length();
|
||||||
for (size_t i = 0; i < len; ++i) {
|
for (std::size_t i = 0; i < len; ++i) {
|
||||||
tag.Name[i] = toupper(tag.Name[i]);
|
tag.Name[i] = toupper(tag.Name[i]);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -124,10 +124,10 @@ void HtmlReader::readDocument(ZLInputStream &stream) {
|
||||||
HtmlTag currentTag;
|
HtmlTag currentTag;
|
||||||
char endOfComment[2] = "\0";
|
char endOfComment[2] = "\0";
|
||||||
|
|
||||||
const size_t BUFSIZE = 2048;
|
const std::size_t BUFSIZE = 2048;
|
||||||
char *buffer = new char[BUFSIZE];
|
char *buffer = new char[BUFSIZE];
|
||||||
size_t length;
|
std::size_t length;
|
||||||
size_t offset = 0;
|
std::size_t offset = 0;
|
||||||
do {
|
do {
|
||||||
length = stream.read(buffer, BUFSIZE);
|
length = stream.read(buffer, BUFSIZE);
|
||||||
char *start = buffer;
|
char *start = buffer;
|
||||||
|
|
|
@ -43,7 +43,7 @@ public:
|
||||||
|
|
||||||
struct HtmlTag {
|
struct HtmlTag {
|
||||||
std::string Name;
|
std::string Name;
|
||||||
size_t Offset;
|
std::size_t Offset;
|
||||||
bool Start;
|
bool Start;
|
||||||
std::vector<HtmlAttribute> Attributes;
|
std::vector<HtmlAttribute> Attributes;
|
||||||
|
|
||||||
|
@ -74,7 +74,7 @@ protected:
|
||||||
// returns false iff processing must be stopped
|
// returns false iff processing must be stopped
|
||||||
virtual bool tagHandler(const HtmlTag &tag) = 0;
|
virtual bool tagHandler(const HtmlTag &tag) = 0;
|
||||||
// returns false iff processing must be stopped
|
// returns false iff processing must be stopped
|
||||||
virtual bool characterDataHandler(const char *text, size_t len, bool convert) = 0;
|
virtual bool characterDataHandler(const char *text, std::size_t len, bool convert) = 0;
|
||||||
|
|
||||||
private:
|
private:
|
||||||
void appendString(std::string &to, std::string &from);
|
void appendString(std::string &to, std::string &from);
|
||||||
|
|
|
@ -27,27 +27,27 @@
|
||||||
class HtmlTextOnlyReader : public HtmlReader {
|
class HtmlTextOnlyReader : public HtmlReader {
|
||||||
|
|
||||||
public:
|
public:
|
||||||
HtmlTextOnlyReader(char *buffer, size_t maxSize);
|
HtmlTextOnlyReader(char *buffer, std::size_t maxSize);
|
||||||
size_t size() const;
|
std::size_t size() const;
|
||||||
|
|
||||||
private:
|
private:
|
||||||
void startDocumentHandler();
|
void startDocumentHandler();
|
||||||
void endDocumentHandler();
|
void endDocumentHandler();
|
||||||
|
|
||||||
bool tagHandler(const HtmlTag &tag);
|
bool tagHandler(const HtmlTag &tag);
|
||||||
bool characterDataHandler(const char *text, size_t len, bool convert);
|
bool characterDataHandler(const char *text, std::size_t len, bool convert);
|
||||||
|
|
||||||
private:
|
private:
|
||||||
char *myBuffer;
|
char *myBuffer;
|
||||||
size_t myMaxSize;
|
std::size_t myMaxSize;
|
||||||
size_t myFilledSize;
|
std::size_t myFilledSize;
|
||||||
bool myIgnoreText;
|
bool myIgnoreText;
|
||||||
};
|
};
|
||||||
|
|
||||||
HtmlTextOnlyReader::HtmlTextOnlyReader(char *buffer, size_t maxSize) : HtmlReader(std::string()), myBuffer(buffer), myMaxSize(maxSize), myFilledSize(0), myIgnoreText(false) {
|
HtmlTextOnlyReader::HtmlTextOnlyReader(char *buffer, std::size_t maxSize) : HtmlReader(std::string()), myBuffer(buffer), myMaxSize(maxSize), myFilledSize(0), myIgnoreText(false) {
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t HtmlTextOnlyReader::size() const {
|
std::size_t HtmlTextOnlyReader::size() const {
|
||||||
return myFilledSize;
|
return myFilledSize;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -67,16 +67,16 @@ bool HtmlTextOnlyReader::tagHandler(const HtmlTag &tag) {
|
||||||
return myFilledSize < myMaxSize;
|
return myFilledSize < myMaxSize;
|
||||||
}
|
}
|
||||||
|
|
||||||
bool HtmlTextOnlyReader::characterDataHandler(const char *text, size_t len, bool) {
|
bool HtmlTextOnlyReader::characterDataHandler(const char *text, std::size_t len, bool) {
|
||||||
if (!myIgnoreText) {
|
if (!myIgnoreText) {
|
||||||
len = std::min((size_t)len, myMaxSize - myFilledSize);
|
len = std::min((std::size_t)len, myMaxSize - myFilledSize);
|
||||||
memcpy(myBuffer + myFilledSize, text, len);
|
std::memcpy(myBuffer + myFilledSize, text, len);
|
||||||
myFilledSize += len;
|
myFilledSize += len;
|
||||||
}
|
}
|
||||||
return myFilledSize < myMaxSize;
|
return myFilledSize < myMaxSize;
|
||||||
}
|
}
|
||||||
|
|
||||||
HtmlReaderStream::HtmlReaderStream(shared_ptr<ZLInputStream> base, size_t maxSize) : myBase(base), myBuffer(0), mySize(maxSize) {
|
HtmlReaderStream::HtmlReaderStream(shared_ptr<ZLInputStream> base, std::size_t maxSize) : myBase(base), myBuffer(0), mySize(maxSize) {
|
||||||
}
|
}
|
||||||
|
|
||||||
HtmlReaderStream::~HtmlReaderStream() {
|
HtmlReaderStream::~HtmlReaderStream() {
|
||||||
|
@ -96,10 +96,10 @@ bool HtmlReaderStream::open() {
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t HtmlReaderStream::read(char *buffer, size_t maxSize) {
|
std::size_t HtmlReaderStream::read(char *buffer, std::size_t maxSize) {
|
||||||
maxSize = std::min(maxSize, mySize - myOffset);
|
maxSize = std::min(maxSize, mySize - myOffset);
|
||||||
if (buffer != 0) {
|
if (buffer != 0) {
|
||||||
memcpy(buffer, myBuffer, maxSize);
|
std::memcpy(buffer, myBuffer, maxSize);
|
||||||
}
|
}
|
||||||
myOffset += maxSize;
|
myOffset += maxSize;
|
||||||
return maxSize;
|
return maxSize;
|
||||||
|
@ -116,13 +116,13 @@ void HtmlReaderStream::seek(int offset, bool absoluteOffset) {
|
||||||
if (!absoluteOffset) {
|
if (!absoluteOffset) {
|
||||||
offset += myOffset;
|
offset += myOffset;
|
||||||
}
|
}
|
||||||
myOffset = std::min(mySize, (size_t)std::max(0, offset));
|
myOffset = std::min(mySize, (std::size_t)std::max(0, offset));
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t HtmlReaderStream::offset() const {
|
std::size_t HtmlReaderStream::offset() const {
|
||||||
return myOffset;
|
return myOffset;
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t HtmlReaderStream::sizeOfOpened() {
|
std::size_t HtmlReaderStream::sizeOfOpened() {
|
||||||
return mySize;
|
return mySize;
|
||||||
}
|
}
|
||||||
|
|
|
@ -26,23 +26,23 @@
|
||||||
class HtmlReaderStream : public ZLInputStream {
|
class HtmlReaderStream : public ZLInputStream {
|
||||||
|
|
||||||
public:
|
public:
|
||||||
HtmlReaderStream(shared_ptr<ZLInputStream> base, size_t maxSize);
|
HtmlReaderStream(shared_ptr<ZLInputStream> base, std::size_t maxSize);
|
||||||
~HtmlReaderStream();
|
~HtmlReaderStream();
|
||||||
|
|
||||||
private:
|
private:
|
||||||
bool open();
|
bool open();
|
||||||
size_t read(char *buffer, size_t maxSize);
|
std::size_t read(char *buffer, std::size_t maxSize);
|
||||||
void close();
|
void close();
|
||||||
|
|
||||||
void seek(int offset, bool absoluteOffset);
|
void seek(int offset, bool absoluteOffset);
|
||||||
size_t offset() const;
|
std::size_t offset() const;
|
||||||
size_t sizeOfOpened();
|
std::size_t sizeOfOpened();
|
||||||
|
|
||||||
private:
|
private:
|
||||||
shared_ptr<ZLInputStream> myBase;
|
shared_ptr<ZLInputStream> myBase;
|
||||||
char *myBuffer;
|
char *myBuffer;
|
||||||
size_t mySize;
|
std::size_t mySize;
|
||||||
size_t myOffset;
|
std::size_t myOffset;
|
||||||
};
|
};
|
||||||
|
|
||||||
#endif /* __HTMLREADERSTREAM_H__ */
|
#endif /* __HTMLREADERSTREAM_H__ */
|
||||||
|
|
|
@ -34,7 +34,7 @@ static const std::string TAG_TEXT = "text";
|
||||||
|
|
||||||
void NCXReader::startElementHandler(const char *fullTag, const char **attributes) {
|
void NCXReader::startElementHandler(const char *fullTag, const char **attributes) {
|
||||||
std::string tag = fullTag;
|
std::string tag = fullTag;
|
||||||
const size_t index = tag.rfind(':');
|
const std::size_t index = tag.rfind(':');
|
||||||
if (index != std::string::npos) {
|
if (index != std::string::npos) {
|
||||||
tag = tag.substr(index + 1);
|
tag = tag.substr(index + 1);
|
||||||
}
|
}
|
||||||
|
@ -76,7 +76,7 @@ void NCXReader::startElementHandler(const char *fullTag, const char **attributes
|
||||||
|
|
||||||
void NCXReader::endElementHandler(const char *fullTag) {
|
void NCXReader::endElementHandler(const char *fullTag) {
|
||||||
std::string tag = fullTag;
|
std::string tag = fullTag;
|
||||||
const size_t index = tag.rfind(':');
|
const std::size_t index = tag.rfind(':');
|
||||||
if (index != std::string::npos) {
|
if (index != std::string::npos) {
|
||||||
tag = tag.substr(index + 1);
|
tag = tag.substr(index + 1);
|
||||||
}
|
}
|
||||||
|
@ -110,7 +110,7 @@ void NCXReader::endElementHandler(const char *fullTag) {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void NCXReader::characterDataHandler(const char *text, size_t len) {
|
void NCXReader::characterDataHandler(const char *text, std::size_t len) {
|
||||||
if (myReadState == READ_TEXT) {
|
if (myReadState == READ_TEXT) {
|
||||||
myPointStack.back().Text.append(text, len);
|
myPointStack.back().Text.append(text, len);
|
||||||
}
|
}
|
||||||
|
@ -127,5 +127,5 @@ const std::map<int,NCXReader::NavPoint> &NCXReader::navigationMap() const {
|
||||||
NCXReader::NavPoint::NavPoint() {
|
NCXReader::NavPoint::NavPoint() {
|
||||||
}
|
}
|
||||||
|
|
||||||
NCXReader::NavPoint::NavPoint(int order, size_t level) : Order(order), Level(level) {
|
NCXReader::NavPoint::NavPoint(int order, std::size_t level) : Order(order), Level(level) {
|
||||||
}
|
}
|
||||||
|
|
|
@ -32,10 +32,10 @@ class NCXReader : public ZLXMLReader {
|
||||||
public:
|
public:
|
||||||
struct NavPoint {
|
struct NavPoint {
|
||||||
NavPoint();
|
NavPoint();
|
||||||
NavPoint(int order, size_t level);
|
NavPoint(int order, std::size_t level);
|
||||||
|
|
||||||
int Order;
|
int Order;
|
||||||
size_t Level;
|
std::size_t Level;
|
||||||
std::string Text;
|
std::string Text;
|
||||||
std::string ContentHRef;
|
std::string ContentHRef;
|
||||||
};
|
};
|
||||||
|
@ -47,7 +47,7 @@ public:
|
||||||
private:
|
private:
|
||||||
void startElementHandler(const char *tag, const char **attributes);
|
void startElementHandler(const char *tag, const char **attributes);
|
||||||
void endElementHandler(const char *tag);
|
void endElementHandler(const char *tag);
|
||||||
void characterDataHandler(const char *text, size_t len);
|
void characterDataHandler(const char *text, std::size_t len);
|
||||||
const std::vector<std::string> &externalDTDs() const;
|
const std::vector<std::string> &externalDTDs() const;
|
||||||
|
|
||||||
private:
|
private:
|
||||||
|
|
|
@ -229,7 +229,7 @@ void OEBBookReader::generateTOC(const XHTMLReader &xhtmlReader) {
|
||||||
if (ncxReader.readDocument(ZLFile(myFilePrefix + myNCXTOCFileName))) {
|
if (ncxReader.readDocument(ZLFile(myFilePrefix + myNCXTOCFileName))) {
|
||||||
const std::map<int,NCXReader::NavPoint> navigationMap = ncxReader.navigationMap();
|
const std::map<int,NCXReader::NavPoint> navigationMap = ncxReader.navigationMap();
|
||||||
if (!navigationMap.empty()) {
|
if (!navigationMap.empty()) {
|
||||||
size_t level = 0;
|
std::size_t level = 0;
|
||||||
for (std::map<int,NCXReader::NavPoint>::const_iterator it = navigationMap.begin(); it != navigationMap.end(); ++it) {
|
for (std::map<int,NCXReader::NavPoint>::const_iterator it = navigationMap.begin(); it != navigationMap.end(); ++it) {
|
||||||
const NCXReader::NavPoint &point = it->second;
|
const NCXReader::NavPoint &point = it->second;
|
||||||
int index = myModelReader.model().label(xhtmlReader.normalizedReference(point.ContentHRef)).ParagraphNumber;
|
int index = myModelReader.model().label(xhtmlReader.normalizedReference(point.ContentHRef)).ParagraphNumber;
|
||||||
|
|
|
@ -40,7 +40,7 @@ static const std::string DC_METADATA = "dc-metadata";
|
||||||
static const std::string META = "meta";
|
static const std::string META = "meta";
|
||||||
static const std::string AUTHOR_ROLE = "aut";
|
static const std::string AUTHOR_ROLE = "aut";
|
||||||
|
|
||||||
void OEBMetaInfoReader::characterDataHandler(const char *text, size_t len) {
|
void OEBMetaInfoReader::characterDataHandler(const char *text, std::size_t len) {
|
||||||
switch (myReadState) {
|
switch (myReadState) {
|
||||||
case READ_NONE:
|
case READ_NONE:
|
||||||
case READ_METADATA:
|
case READ_METADATA:
|
||||||
|
|
|
@ -34,7 +34,7 @@ public:
|
||||||
|
|
||||||
void startElementHandler(const char *tag, const char **attributes);
|
void startElementHandler(const char *tag, const char **attributes);
|
||||||
void endElementHandler(const char *tag);
|
void endElementHandler(const char *tag);
|
||||||
void characterDataHandler(const char *text, size_t len);
|
void characterDataHandler(const char *text, std::size_t len);
|
||||||
bool processNamespaces() const;
|
bool processNamespaces() const;
|
||||||
const std::vector<std::string> &externalDTDs() const;
|
const std::vector<std::string> &externalDTDs() const;
|
||||||
|
|
||||||
|
|
|
@ -37,7 +37,7 @@ private:
|
||||||
private:
|
private:
|
||||||
std::string myFilePrefix;
|
std::string myFilePrefix;
|
||||||
std::vector<std::string> myXHTMLFileNames;
|
std::vector<std::string> myXHTMLFileNames;
|
||||||
size_t myIndex;
|
std::size_t myIndex;
|
||||||
};
|
};
|
||||||
|
|
||||||
#endif /* __OEBTEXTSTREAM_H__ */
|
#endif /* __OEBTEXTSTREAM_H__ */
|
||||||
|
|
|
@ -29,9 +29,9 @@
|
||||||
RtfBookReader::RtfBookReader(BookModel &model, const std::string &encoding) : RtfReader(encoding), myBookReader(model) {
|
RtfBookReader::RtfBookReader(BookModel &model, const std::string &encoding) : RtfReader(encoding), myBookReader(model) {
|
||||||
}
|
}
|
||||||
|
|
||||||
static const size_t maxBufferSize = 1024;
|
static const std::size_t maxBufferSize = 1024;
|
||||||
|
|
||||||
void RtfBookReader::addCharData(const char *data, size_t len, bool convert) {
|
void RtfBookReader::addCharData(const char *data, std::size_t len, bool convert) {
|
||||||
if (myCurrentState.ReadText) {
|
if (myCurrentState.ReadText) {
|
||||||
if (convert || myConverter.isNull()) {
|
if (convert || myConverter.isNull()) {
|
||||||
myOutputBuffer.append(data, len);
|
myOutputBuffer.append(data, len);
|
||||||
|
@ -119,7 +119,7 @@ void RtfBookReader::switchDestination(DestinationType destination, bool on) {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void RtfBookReader::insertImage(const std::string &mimeType, const std::string &fileName, size_t startOffset, size_t size) {
|
void RtfBookReader::insertImage(const std::string &mimeType, const std::string &fileName, std::size_t startOffset, std::size_t size) {
|
||||||
std::string id;
|
std::string id;
|
||||||
ZLStringUtil::appendNumber(id, myImageIndex++);
|
ZLStringUtil::appendNumber(id, myImageIndex++);
|
||||||
myBookReader.addImageReference(id, 0, false);
|
myBookReader.addImageReference(id, 0, false);
|
||||||
|
|
|
@ -44,8 +44,8 @@ public:
|
||||||
void setEncoding(int code);
|
void setEncoding(int code);
|
||||||
void setAlignment();
|
void setAlignment();
|
||||||
void switchDestination(DestinationType destination, bool on);
|
void switchDestination(DestinationType destination, bool on);
|
||||||
void addCharData(const char *data, size_t len, bool convert);
|
void addCharData(const char *data, std::size_t len, bool convert);
|
||||||
void insertImage(const std::string &mimeType, const std::string &fileName, size_t startOffset, size_t size);
|
void insertImage(const std::string &mimeType, const std::string &fileName, std::size_t startOffset, std::size_t size);
|
||||||
|
|
||||||
void setFontProperty(FontProperty property);
|
void setFontProperty(FontProperty property);
|
||||||
void newParagraph();
|
void newParagraph();
|
||||||
|
|
|
@ -43,7 +43,7 @@ bool RtfDescriptionReader::readDocument(const ZLFile &file) {
|
||||||
return RtfReader::readDocument(file);
|
return RtfReader::readDocument(file);
|
||||||
}
|
}
|
||||||
|
|
||||||
void RtfDescriptionReader::addCharData(const char *data, size_t len, bool convert) {
|
void RtfDescriptionReader::addCharData(const char *data, std::size_t len, bool convert) {
|
||||||
if (myDoRead && len > 0) {
|
if (myDoRead && len > 0) {
|
||||||
if (convert) {
|
if (convert) {
|
||||||
myConverter->convert(myBuffer, data, data + len);
|
myConverter->convert(myBuffer, data, data + len);
|
||||||
|
@ -82,7 +82,7 @@ void RtfDescriptionReader::switchDestination(DestinationType destination, bool o
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void RtfDescriptionReader::insertImage(const std::string&, const std::string&, size_t, size_t) {
|
void RtfDescriptionReader::insertImage(const std::string&, const std::string&, std::size_t, std::size_t) {
|
||||||
}
|
}
|
||||||
|
|
||||||
void RtfDescriptionReader::setFontProperty(FontProperty) {
|
void RtfDescriptionReader::setFontProperty(FontProperty) {
|
||||||
|
|
|
@ -37,8 +37,8 @@ public:
|
||||||
void setEncoding(int code);
|
void setEncoding(int code);
|
||||||
void setAlignment();
|
void setAlignment();
|
||||||
void switchDestination(DestinationType destination, bool on);
|
void switchDestination(DestinationType destination, bool on);
|
||||||
void addCharData(const char *data, size_t len, bool convert);
|
void addCharData(const char *data, std::size_t len, bool convert);
|
||||||
void insertImage(const std::string &mimeType, const std::string &fileName, size_t startOffset, size_t size);
|
void insertImage(const std::string &mimeType, const std::string &fileName, std::size_t startOffset, std::size_t size);
|
||||||
|
|
||||||
void setFontProperty(FontProperty property);
|
void setFontProperty(FontProperty property);
|
||||||
void newParagraph();
|
void newParagraph();
|
||||||
|
|
|
@ -424,7 +424,7 @@ void RtfReader::processKeyword(const std::string &keyword, int *parameter) {
|
||||||
it->second->run(*this, parameter);
|
it->second->run(*this, parameter);
|
||||||
}
|
}
|
||||||
|
|
||||||
void RtfReader::processCharData(const char *data, size_t len, bool convert) {
|
void RtfReader::processCharData(const char *data, std::size_t len, bool convert) {
|
||||||
if (myState.Destination != RtfReader::DESTINATION_SKIP) {
|
if (myState.Destination != RtfReader::DESTINATION_SKIP) {
|
||||||
addCharData(data, len, convert);
|
addCharData(data, len, convert);
|
||||||
}
|
}
|
||||||
|
|
|
@ -68,8 +68,8 @@ protected:
|
||||||
FONT_UNDERLINED
|
FONT_UNDERLINED
|
||||||
};
|
};
|
||||||
|
|
||||||
virtual void addCharData(const char *data, size_t len, bool convert) = 0;
|
virtual void addCharData(const char *data, std::size_t len, bool convert) = 0;
|
||||||
virtual void insertImage(const std::string &mimeType, const std::string &fileName, size_t startOffset, size_t size) = 0;
|
virtual void insertImage(const std::string &mimeType, const std::string &fileName, std::size_t startOffset, std::size_t size) = 0;
|
||||||
virtual void setEncoding(int code) = 0;
|
virtual void setEncoding(int code) = 0;
|
||||||
virtual void switchDestination(DestinationType destination, bool on) = 0;
|
virtual void switchDestination(DestinationType destination, bool on) = 0;
|
||||||
virtual void setAlignment() = 0;
|
virtual void setAlignment() = 0;
|
||||||
|
@ -81,7 +81,7 @@ protected:
|
||||||
private:
|
private:
|
||||||
bool parseDocument();
|
bool parseDocument();
|
||||||
void processKeyword(const std::string &keyword, int *parameter = 0);
|
void processKeyword(const std::string &keyword, int *parameter = 0);
|
||||||
void processCharData(const char *data, size_t len, bool convert = true);
|
void processCharData(const char *data, std::size_t len, bool convert = true);
|
||||||
|
|
||||||
protected:
|
protected:
|
||||||
struct RtfReaderState {
|
struct RtfReaderState {
|
||||||
|
|
|
@ -27,13 +27,13 @@
|
||||||
class RtfTextOnlyReader : public RtfReader {
|
class RtfTextOnlyReader : public RtfReader {
|
||||||
|
|
||||||
public:
|
public:
|
||||||
RtfTextOnlyReader(char *buffer, size_t maxSize);
|
RtfTextOnlyReader(char *buffer, std::size_t maxSize);
|
||||||
~RtfTextOnlyReader();
|
~RtfTextOnlyReader();
|
||||||
size_t readSize() const;
|
std::size_t readSize() const;
|
||||||
|
|
||||||
protected:
|
protected:
|
||||||
void addCharData(const char *data, size_t len, bool convert);
|
void addCharData(const char *data, std::size_t len, bool convert);
|
||||||
void insertImage(const std::string &mimeType, const std::string &fileName, size_t startOffset, size_t size);
|
void insertImage(const std::string &mimeType, const std::string &fileName, std::size_t startOffset, std::size_t size);
|
||||||
void setEncoding(int code);
|
void setEncoding(int code);
|
||||||
void switchDestination(DestinationType destination, bool on);
|
void switchDestination(DestinationType destination, bool on);
|
||||||
void setAlignment();
|
void setAlignment();
|
||||||
|
@ -51,25 +51,25 @@ private:
|
||||||
|
|
||||||
private:
|
private:
|
||||||
char* myBuffer;
|
char* myBuffer;
|
||||||
const size_t myMaxSize;
|
const std::size_t myMaxSize;
|
||||||
size_t myFilledSize;
|
std::size_t myFilledSize;
|
||||||
};
|
};
|
||||||
|
|
||||||
RtfTextOnlyReader::RtfTextOnlyReader(char *buffer, size_t maxSize) : RtfReader(std::string()), myBuffer(buffer), myMaxSize(maxSize), myFilledSize(0) {
|
RtfTextOnlyReader::RtfTextOnlyReader(char *buffer, std::size_t maxSize) : RtfReader(std::string()), myBuffer(buffer), myMaxSize(maxSize), myFilledSize(0) {
|
||||||
myCurrentState.ReadText = true;
|
myCurrentState.ReadText = true;
|
||||||
}
|
}
|
||||||
|
|
||||||
RtfTextOnlyReader::~RtfTextOnlyReader() {
|
RtfTextOnlyReader::~RtfTextOnlyReader() {
|
||||||
}
|
}
|
||||||
|
|
||||||
void RtfTextOnlyReader::addCharData(const char *data, size_t len, bool) {
|
void RtfTextOnlyReader::addCharData(const char *data, std::size_t len, bool) {
|
||||||
if (myBuffer == 0) {
|
if (myBuffer == 0) {
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
if (myCurrentState.ReadText) {
|
if (myCurrentState.ReadText) {
|
||||||
if (myFilledSize < myMaxSize) {
|
if (myFilledSize < myMaxSize) {
|
||||||
len = std::min((size_t)len, myMaxSize - myFilledSize);
|
len = std::min((std::size_t)len, myMaxSize - myFilledSize);
|
||||||
memcpy(myBuffer + myFilledSize, data, len);
|
std::memcpy(myBuffer + myFilledSize, data, len);
|
||||||
myFilledSize += len;
|
myFilledSize += len;
|
||||||
}
|
}
|
||||||
if (myFilledSize < myMaxSize) {
|
if (myFilledSize < myMaxSize) {
|
||||||
|
@ -80,11 +80,11 @@ void RtfTextOnlyReader::addCharData(const char *data, size_t len, bool) {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t RtfTextOnlyReader::readSize() const {
|
std::size_t RtfTextOnlyReader::readSize() const {
|
||||||
return myFilledSize;
|
return myFilledSize;
|
||||||
}
|
}
|
||||||
|
|
||||||
void RtfTextOnlyReader::insertImage(const std::string&, const std::string&, size_t, size_t) {
|
void RtfTextOnlyReader::insertImage(const std::string&, const std::string&, std::size_t, std::size_t) {
|
||||||
}
|
}
|
||||||
|
|
||||||
void RtfTextOnlyReader::setEncoding(int) {
|
void RtfTextOnlyReader::setEncoding(int) {
|
||||||
|
@ -124,7 +124,7 @@ void RtfTextOnlyReader::newParagraph() {
|
||||||
void RtfTextOnlyReader::interrupt() {
|
void RtfTextOnlyReader::interrupt() {
|
||||||
}
|
}
|
||||||
|
|
||||||
RtfReaderStream::RtfReaderStream(const ZLFile& file, size_t maxSize) : myFile(file), myBuffer(0), mySize(maxSize) {
|
RtfReaderStream::RtfReaderStream(const ZLFile& file, std::size_t maxSize) : myFile(file), myBuffer(0), mySize(maxSize) {
|
||||||
}
|
}
|
||||||
|
|
||||||
RtfReaderStream::~RtfReaderStream() {
|
RtfReaderStream::~RtfReaderStream() {
|
||||||
|
@ -142,10 +142,10 @@ bool RtfReaderStream::open() {
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t RtfReaderStream::read(char *buffer, size_t maxSize) {
|
std::size_t RtfReaderStream::read(char *buffer, std::size_t maxSize) {
|
||||||
maxSize = std::min(maxSize, mySize - myOffset);
|
maxSize = std::min(maxSize, mySize - myOffset);
|
||||||
if ((buffer != 0) && (myBuffer !=0)) {
|
if ((buffer != 0) && (myBuffer !=0)) {
|
||||||
memcpy(buffer, myBuffer + myOffset, maxSize);
|
std::memcpy(buffer, myBuffer + myOffset, maxSize);
|
||||||
}
|
}
|
||||||
myOffset += maxSize;
|
myOffset += maxSize;
|
||||||
return maxSize;
|
return maxSize;
|
||||||
|
@ -162,13 +162,13 @@ void RtfReaderStream::seek(int offset, bool absoluteOffset) {
|
||||||
if (!absoluteOffset) {
|
if (!absoluteOffset) {
|
||||||
offset += myOffset;
|
offset += myOffset;
|
||||||
}
|
}
|
||||||
myOffset = std::min(mySize, (size_t)std::max(0, offset));
|
myOffset = std::min(mySize, (std::size_t)std::max(0, offset));
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t RtfReaderStream::offset() const {
|
std::size_t RtfReaderStream::offset() const {
|
||||||
return myOffset;
|
return myOffset;
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t RtfReaderStream::sizeOfOpened() {
|
std::size_t RtfReaderStream::sizeOfOpened() {
|
||||||
return mySize;
|
return mySize;
|
||||||
}
|
}
|
||||||
|
|
|
@ -28,23 +28,23 @@
|
||||||
class RtfReaderStream : public ZLInputStream {
|
class RtfReaderStream : public ZLInputStream {
|
||||||
|
|
||||||
public:
|
public:
|
||||||
RtfReaderStream(const ZLFile& file, size_t maxSize);
|
RtfReaderStream(const ZLFile& file, std::size_t maxSize);
|
||||||
~RtfReaderStream();
|
~RtfReaderStream();
|
||||||
|
|
||||||
private:
|
private:
|
||||||
bool open();
|
bool open();
|
||||||
size_t read(char *buffer, size_t maxSize);
|
std::size_t read(char *buffer, std::size_t maxSize);
|
||||||
void close();
|
void close();
|
||||||
|
|
||||||
void seek(int offset, bool absoluteOffset);
|
void seek(int offset, bool absoluteOffset);
|
||||||
size_t offset() const;
|
std::size_t offset() const;
|
||||||
size_t sizeOfOpened();
|
std::size_t sizeOfOpened();
|
||||||
|
|
||||||
private:
|
private:
|
||||||
const ZLFile myFile;
|
const ZLFile myFile;
|
||||||
char *myBuffer;
|
char *myBuffer;
|
||||||
size_t mySize;
|
std::size_t mySize;
|
||||||
size_t myOffset;
|
std::size_t myOffset;
|
||||||
};
|
};
|
||||||
|
|
||||||
#endif /* __RTFREADERSTREAM_H__ */
|
#endif /* __RTFREADERSTREAM_H__ */
|
||||||
|
|
|
@ -94,10 +94,10 @@ TxtReaderCoreUtf16::TxtReaderCoreUtf16(TxtReader &reader) : TxtReaderCore(reader
|
||||||
}
|
}
|
||||||
|
|
||||||
void TxtReaderCore::readDocument(ZLInputStream &stream) {
|
void TxtReaderCore::readDocument(ZLInputStream &stream) {
|
||||||
const size_t BUFSIZE = 2048;
|
const std::size_t BUFSIZE = 2048;
|
||||||
char *buffer = new char[BUFSIZE];
|
char *buffer = new char[BUFSIZE];
|
||||||
std::string str;
|
std::string str;
|
||||||
size_t length;
|
std::size_t length;
|
||||||
do {
|
do {
|
||||||
length = stream.read(buffer, BUFSIZE);
|
length = stream.read(buffer, BUFSIZE);
|
||||||
char *start = buffer;
|
char *start = buffer;
|
||||||
|
@ -136,10 +136,10 @@ void TxtReaderCore::readDocument(ZLInputStream &stream) {
|
||||||
}
|
}
|
||||||
|
|
||||||
void TxtReaderCoreUtf16::readDocument(ZLInputStream &stream) {
|
void TxtReaderCoreUtf16::readDocument(ZLInputStream &stream) {
|
||||||
const size_t BUFSIZE = 2048;
|
const std::size_t BUFSIZE = 2048;
|
||||||
char *buffer = new char[BUFSIZE];
|
char *buffer = new char[BUFSIZE];
|
||||||
std::string str;
|
std::string str;
|
||||||
size_t length;
|
std::size_t length;
|
||||||
do {
|
do {
|
||||||
length = stream.read(buffer, BUFSIZE);
|
length = stream.read(buffer, BUFSIZE);
|
||||||
char *start = buffer;
|
char *start = buffer;
|
||||||
|
|
|
@ -27,10 +27,10 @@ bool MergedStream::open() {
|
||||||
return !myCurrentStream.isNull() && myCurrentStream->open();
|
return !myCurrentStream.isNull() && myCurrentStream->open();
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t MergedStream::read(char *buffer, size_t maxSize) {
|
std::size_t MergedStream::read(char *buffer, std::size_t maxSize) {
|
||||||
size_t bytesToRead = maxSize;
|
std::size_t bytesToRead = maxSize;
|
||||||
while ((bytesToRead > 0) && !myCurrentStream.isNull()) {
|
while ((bytesToRead > 0) && !myCurrentStream.isNull()) {
|
||||||
size_t len = myCurrentStream->read(buffer, bytesToRead);
|
std::size_t len = myCurrentStream->read(buffer, bytesToRead);
|
||||||
bytesToRead -= len;
|
bytesToRead -= len;
|
||||||
if (buffer != 0) {
|
if (buffer != 0) {
|
||||||
buffer += len;
|
buffer += len;
|
||||||
|
@ -62,11 +62,11 @@ void MergedStream::seek(int offset, bool absoluteOffset) {
|
||||||
read(0, offset);
|
read(0, offset);
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t MergedStream::offset() const {
|
std::size_t MergedStream::offset() const {
|
||||||
return myOffset;
|
return myOffset;
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t MergedStream::sizeOfOpened() {
|
std::size_t MergedStream::sizeOfOpened() {
|
||||||
// coudn't be implemented
|
// coudn't be implemented
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
|
@ -31,15 +31,15 @@ protected:
|
||||||
|
|
||||||
private:
|
private:
|
||||||
bool open();
|
bool open();
|
||||||
size_t read(char *buffer, size_t maxSize);
|
std::size_t read(char *buffer, std::size_t maxSize);
|
||||||
void close();
|
void close();
|
||||||
void seek(int offset, bool absoluteOffset);
|
void seek(int offset, bool absoluteOffset);
|
||||||
size_t offset() const;
|
std::size_t offset() const;
|
||||||
size_t sizeOfOpened();
|
std::size_t sizeOfOpened();
|
||||||
|
|
||||||
private:
|
private:
|
||||||
shared_ptr<ZLInputStream> myCurrentStream;
|
shared_ptr<ZLInputStream> myCurrentStream;
|
||||||
size_t myOffset;
|
std::size_t myOffset;
|
||||||
};
|
};
|
||||||
|
|
||||||
#endif /* __MERGEDSTREAM_H__ */
|
#endif /* __MERGEDSTREAM_H__ */
|
||||||
|
|
|
@ -33,7 +33,7 @@ public:
|
||||||
|
|
||||||
private:
|
private:
|
||||||
void startElementHandler(const char *tag, const char **attributes);
|
void startElementHandler(const char *tag, const char **attributes);
|
||||||
void characterDataHandler(const char *text, size_t len);
|
void characterDataHandler(const char *text, std::size_t len);
|
||||||
|
|
||||||
private:
|
private:
|
||||||
const std::string myStartTag;
|
const std::string myStartTag;
|
||||||
|
@ -50,7 +50,7 @@ void XMLTextReader::startElementHandler(const char *tag, const char**) {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void XMLTextReader::characterDataHandler(const char *text, size_t len) {
|
void XMLTextReader::characterDataHandler(const char *text, std::size_t len) {
|
||||||
if (myStarted) {
|
if (myStarted) {
|
||||||
myBuffer.append(text, len);
|
myBuffer.append(text, len);
|
||||||
}
|
}
|
||||||
|
@ -73,9 +73,9 @@ bool XMLTextStream::open() {
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t XMLTextStream::read(char *buffer, size_t maxSize) {
|
std::size_t XMLTextStream::read(char *buffer, std::size_t maxSize) {
|
||||||
while (myDataBuffer.size() < maxSize) {
|
while (myDataBuffer.size() < maxSize) {
|
||||||
size_t len = myBase->read((char*)myStreamBuffer.data(), 2048);
|
std::size_t len = myBase->read((char*)myStreamBuffer.data(), 2048);
|
||||||
/*if ((len == 0) || !myReader->readFromBuffer(myStreamBuffer.data(), len)) {
|
/*if ((len == 0) || !myReader->readFromBuffer(myStreamBuffer.data(), len)) {
|
||||||
break;
|
break;
|
||||||
}*/
|
}*/
|
||||||
|
@ -87,9 +87,9 @@ size_t XMLTextStream::read(char *buffer, size_t maxSize) {
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
size_t realSize = std::min(myDataBuffer.size(), maxSize);
|
std::size_t realSize = std::min(myDataBuffer.size(), maxSize);
|
||||||
if (buffer != 0) {
|
if (buffer != 0) {
|
||||||
memcpy(buffer, myDataBuffer.data(), realSize);
|
std::memcpy(buffer, myDataBuffer.data(), realSize);
|
||||||
}
|
}
|
||||||
myDataBuffer.erase(0, realSize);
|
myDataBuffer.erase(0, realSize);
|
||||||
myOffset += realSize;
|
myOffset += realSize;
|
||||||
|
@ -114,11 +114,11 @@ void XMLTextStream::seek(int offset, bool absoluteOffset) {
|
||||||
read(0, offset);
|
read(0, offset);
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t XMLTextStream::offset() const {
|
std::size_t XMLTextStream::offset() const {
|
||||||
return myOffset;
|
return myOffset;
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t XMLTextStream::sizeOfOpened() {
|
std::size_t XMLTextStream::sizeOfOpened() {
|
||||||
// couldn't be implemented
|
// couldn't be implemented
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
|
@ -34,11 +34,11 @@ public:
|
||||||
|
|
||||||
private:
|
private:
|
||||||
bool open();
|
bool open();
|
||||||
size_t read(char *buffer, size_t maxSize);
|
std::size_t read(char *buffer, std::size_t maxSize);
|
||||||
void close();
|
void close();
|
||||||
void seek(int offset, bool absoluteOffset);
|
void seek(int offset, bool absoluteOffset);
|
||||||
size_t offset() const;
|
std::size_t offset() const;
|
||||||
size_t sizeOfOpened();
|
std::size_t sizeOfOpened();
|
||||||
|
|
||||||
private:
|
private:
|
||||||
shared_ptr<ZLInputStream> myBase;
|
shared_ptr<ZLInputStream> myBase;
|
||||||
|
@ -46,7 +46,7 @@ private:
|
||||||
shared_ptr<ZLAsynchronousInputStream> myStream;
|
shared_ptr<ZLAsynchronousInputStream> myStream;
|
||||||
std::string myStreamBuffer;
|
std::string myStreamBuffer;
|
||||||
std::string myDataBuffer;
|
std::string myDataBuffer;
|
||||||
size_t myOffset;
|
std::size_t myOffset;
|
||||||
};
|
};
|
||||||
|
|
||||||
#endif /* __XMLTEXTSTREAM_H__ */
|
#endif /* __XMLTEXTSTREAM_H__ */
|
||||||
|
|
|
@ -630,7 +630,7 @@ void XHTMLReader::endParagraph() {
|
||||||
myModelReader.endParagraph();
|
myModelReader.endParagraph();
|
||||||
}
|
}
|
||||||
|
|
||||||
void XHTMLReader::characterDataHandler(const char *text, size_t len) {
|
void XHTMLReader::characterDataHandler(const char *text, std::size_t len) {
|
||||||
switch (myReadState) {
|
switch (myReadState) {
|
||||||
case READ_NOTHING:
|
case READ_NOTHING:
|
||||||
break;
|
break;
|
||||||
|
@ -648,7 +648,7 @@ void XHTMLReader::characterDataHandler(const char *text, size_t len) {
|
||||||
beginParagraph();
|
beginParagraph();
|
||||||
myModelReader.addControl(PREFORMATTED, true);
|
myModelReader.addControl(PREFORMATTED, true);
|
||||||
}
|
}
|
||||||
size_t spaceCounter = 0;
|
std::size_t spaceCounter = 0;
|
||||||
while (spaceCounter < len && isspace((unsigned char)*(text + spaceCounter))) {
|
while (spaceCounter < len && isspace((unsigned char)*(text + spaceCounter))) {
|
||||||
++spaceCounter;
|
++spaceCounter;
|
||||||
}
|
}
|
||||||
|
@ -684,7 +684,7 @@ bool XHTMLReader::processNamespaces() const {
|
||||||
}
|
}
|
||||||
|
|
||||||
const std::string XHTMLReader::normalizedReference(const std::string &reference) const {
|
const std::string XHTMLReader::normalizedReference(const std::string &reference) const {
|
||||||
const size_t index = reference.find('#');
|
const std::size_t index = reference.find('#');
|
||||||
if (index == std::string::npos) {
|
if (index == std::string::npos) {
|
||||||
return fileAlias(reference);
|
return fileAlias(reference);
|
||||||
} else {
|
} else {
|
||||||
|
|
|
@ -67,7 +67,7 @@ public:
|
||||||
private:
|
private:
|
||||||
void startElementHandler(const char *tag, const char **attributes);
|
void startElementHandler(const char *tag, const char **attributes);
|
||||||
void endElementHandler(const char *tag);
|
void endElementHandler(const char *tag);
|
||||||
void characterDataHandler(const char *text, size_t len);
|
void characterDataHandler(const char *text, std::size_t len);
|
||||||
|
|
||||||
const std::vector<std::string> &externalDTDs() const;
|
const std::vector<std::string> &externalDTDs() const;
|
||||||
|
|
||||||
|
|
|
@ -34,7 +34,7 @@ shared_ptr<Author> Author::getAuthor(const std::string &name, const std::string
|
||||||
ZLStringUtil::stripWhiteSpaces(strippedKey);
|
ZLStringUtil::stripWhiteSpaces(strippedKey);
|
||||||
|
|
||||||
if (strippedKey.empty()) {
|
if (strippedKey.empty()) {
|
||||||
const size_t index = strippedName.find(',');
|
const std::size_t index = strippedName.find(',');
|
||||||
if (index != std::string::npos) {
|
if (index != std::string::npos) {
|
||||||
strippedKey = strippedName.substr(0, index);
|
strippedKey = strippedName.substr(0, index);
|
||||||
ZLStringUtil::stripWhiteSpaces(strippedKey);
|
ZLStringUtil::stripWhiteSpaces(strippedKey);
|
||||||
|
@ -42,12 +42,12 @@ shared_ptr<Author> Author::getAuthor(const std::string &name, const std::string
|
||||||
}
|
}
|
||||||
|
|
||||||
if (strippedKey.empty()) {
|
if (strippedKey.empty()) {
|
||||||
size_t index = strippedName.rfind(' ');
|
std::size_t index = strippedName.rfind(' ');
|
||||||
if (index == std::string::npos) {
|
if (index == std::string::npos) {
|
||||||
strippedKey = strippedName;
|
strippedKey = strippedName;
|
||||||
} else {
|
} else {
|
||||||
strippedKey = strippedName.substr(index + 1);
|
strippedKey = strippedName.substr(index + 1);
|
||||||
const size_t size = strippedName.size();
|
const std::size_t size = strippedName.size();
|
||||||
while (index < size && strippedName[index] == ' ') {
|
while (index < size && strippedName[index] == ' ') {
|
||||||
--index;
|
--index;
|
||||||
}
|
}
|
||||||
|
|
|
@ -217,9 +217,9 @@ bool Book::cloneTag(shared_ptr<Tag> from, shared_ptr<Tag> to, bool includeSubTag
|
||||||
|
|
||||||
const std::string &tagList = info.TagsOption.value();
|
const std::string &tagList = info.TagsOption.value();
|
||||||
if (!tagList.empty()) {
|
if (!tagList.empty()) {
|
||||||
size_t index = 0;
|
std::size_t index = 0;
|
||||||
do {
|
do {
|
||||||
size_t newIndex = tagList.find(',', index);
|
std::size_t newIndex = tagList.find(',', index);
|
||||||
book->addTag(Tag::getTagByFullName(tagList.substr(index, newIndex - index)));
|
book->addTag(Tag::getTagByFullName(tagList.substr(index, newIndex - index)));
|
||||||
index = newIndex + 1;
|
index = newIndex + 1;
|
||||||
} while (index != 0);
|
} while (index != 0);
|
||||||
|
@ -227,9 +227,9 @@ bool Book::cloneTag(shared_ptr<Tag> from, shared_ptr<Tag> to, bool includeSubTag
|
||||||
|
|
||||||
const std::string &authorList = info.AuthorDisplayNameOption.value();
|
const std::string &authorList = info.AuthorDisplayNameOption.value();
|
||||||
if (!authorList.empty()) {
|
if (!authorList.empty()) {
|
||||||
size_t index = 0;
|
std::size_t index = 0;
|
||||||
do {
|
do {
|
||||||
size_t newIndex = authorList.find(',', index);
|
std::size_t newIndex = authorList.find(',', index);
|
||||||
book->addAuthor(authorList.substr(index, newIndex - index));
|
book->addAuthor(authorList.substr(index, newIndex - index));
|
||||||
index = newIndex + 1;
|
index = newIndex + 1;
|
||||||
} while (index != 0);
|
} while (index != 0);
|
||||||
|
|
|
@ -79,8 +79,8 @@ bool TagComparator::operator() (
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t level0 = tag0->level();
|
std::size_t level0 = tag0->level();
|
||||||
size_t level1 = tag1->level();
|
std::size_t level1 = tag1->level();
|
||||||
if (level0 > level1) {
|
if (level0 > level1) {
|
||||||
for (; level0 > level1; --level0) {
|
for (; level0 > level1; --level0) {
|
||||||
tag0 = tag0->parent();
|
tag0 = tag0->parent();
|
||||||
|
|
|
@ -53,7 +53,7 @@ shared_ptr<Tag> Tag::getTag(const std::string &name, shared_ptr<Tag> parent, int
|
||||||
shared_ptr<Tag> Tag::getTagByFullName(const std::string &fullName) {
|
shared_ptr<Tag> Tag::getTagByFullName(const std::string &fullName) {
|
||||||
std::string tag = fullName;
|
std::string tag = fullName;
|
||||||
ZLStringUtil::stripWhiteSpaces(tag);
|
ZLStringUtil::stripWhiteSpaces(tag);
|
||||||
size_t index = tag.rfind(DELIMITER);
|
std::size_t index = tag.rfind(DELIMITER);
|
||||||
if (index == std::string::npos) {
|
if (index == std::string::npos) {
|
||||||
return getTag(tag);
|
return getTag(tag);
|
||||||
} else {
|
} else {
|
||||||
|
|
|
@ -69,7 +69,7 @@ public:
|
||||||
bool isAncestorOf(shared_ptr<Tag> tag) const;
|
bool isAncestorOf(shared_ptr<Tag> tag) const;
|
||||||
|
|
||||||
int tagId() const;
|
int tagId() const;
|
||||||
size_t level() const;
|
std::size_t level() const;
|
||||||
|
|
||||||
private:
|
private:
|
||||||
const std::string myName;
|
const std::string myName;
|
||||||
|
@ -77,7 +77,7 @@ private:
|
||||||
|
|
||||||
shared_ptr<Tag> myParent;
|
shared_ptr<Tag> myParent;
|
||||||
TagList myChildren;
|
TagList myChildren;
|
||||||
const size_t myLevel;
|
const std::size_t myLevel;
|
||||||
|
|
||||||
int myTagId;
|
int myTagId;
|
||||||
|
|
||||||
|
@ -102,6 +102,6 @@ inline const std::string &Tag::name() const { return myName; }
|
||||||
inline shared_ptr<Tag> Tag::parent() const { return myParent; }
|
inline shared_ptr<Tag> Tag::parent() const { return myParent; }
|
||||||
|
|
||||||
inline int Tag::tagId() const { return myTagId; }
|
inline int Tag::tagId() const { return myTagId; }
|
||||||
inline size_t Tag::level() const { return myLevel; }
|
inline std::size_t Tag::level() const { return myLevel; }
|
||||||
|
|
||||||
#endif /* __TAG_H__ */
|
#endif /* __TAG_H__ */
|
||||||
|
|
|
@ -215,7 +215,7 @@ jobject AndroidUtil::createJavaImage(JNIEnv *env, const ZLFileImage &image) {
|
||||||
|
|
||||||
std::vector<jint> offsets, sizes;
|
std::vector<jint> offsets, sizes;
|
||||||
const ZLFileImage::Blocks &blocks = image.blocks();
|
const ZLFileImage::Blocks &blocks = image.blocks();
|
||||||
for (size_t i = 0; i < blocks.size(); ++i) {
|
for (std::size_t i = 0; i < blocks.size(); ++i) {
|
||||||
offsets.push_back((jint)blocks.at(i).offset);
|
offsets.push_back((jint)blocks.at(i).offset);
|
||||||
sizes.push_back((jint)blocks.at(i).size);
|
sizes.push_back((jint)blocks.at(i).size);
|
||||||
}
|
}
|
||||||
|
@ -274,14 +274,14 @@ std::string AndroidUtil::convertNonUtfString(const std::string &str) {
|
||||||
}
|
}
|
||||||
|
|
||||||
jintArray AndroidUtil::createJavaIntArray(JNIEnv *env, const std::vector<jint> &data) {
|
jintArray AndroidUtil::createJavaIntArray(JNIEnv *env, const std::vector<jint> &data) {
|
||||||
size_t size = data.size();
|
std::size_t size = data.size();
|
||||||
jintArray array = env->NewIntArray(size);
|
jintArray array = env->NewIntArray(size);
|
||||||
env->SetIntArrayRegion(array, 0, size, &data.front());
|
env->SetIntArrayRegion(array, 0, size, &data.front());
|
||||||
return array;
|
return array;
|
||||||
}
|
}
|
||||||
|
|
||||||
jbyteArray AndroidUtil::createJavaByteArray(JNIEnv *env, const std::vector<jbyte> &data) {
|
jbyteArray AndroidUtil::createJavaByteArray(JNIEnv *env, const std::vector<jbyte> &data) {
|
||||||
size_t size = data.size();
|
std::size_t size = data.size();
|
||||||
jbyteArray array = env->NewByteArray(size);
|
jbyteArray array = env->NewByteArray(size);
|
||||||
env->SetByteArrayRegion(array, 0, size, &data.front());
|
env->SetByteArrayRegion(array, 0, size, &data.front());
|
||||||
return array;
|
return array;
|
||||||
|
|
|
@ -61,11 +61,11 @@ std::string Utf8EncodingConverter::name() const {
|
||||||
|
|
||||||
void Utf8EncodingConverter::convert(std::string &dst, const char *srcStart, const char *srcEnd) {
|
void Utf8EncodingConverter::convert(std::string &dst, const char *srcStart, const char *srcEnd) {
|
||||||
if (myBuffer.size() > 0) {
|
if (myBuffer.size() > 0) {
|
||||||
const size_t len = ZLUnicodeUtil::length(myBuffer, 1);
|
const std::size_t len = ZLUnicodeUtil::length(myBuffer, 1);
|
||||||
if (len < myBuffer.size()) {
|
if (len < myBuffer.size()) {
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
const size_t diff = std::min(len - myBuffer.size(), (size_t)(srcEnd - srcStart));
|
const std::size_t diff = std::min(len - myBuffer.size(), (std::size_t)(srcEnd - srcStart));
|
||||||
myBuffer.append(srcStart, diff);
|
myBuffer.append(srcStart, diff);
|
||||||
srcStart += diff;
|
srcStart += diff;
|
||||||
if (myBuffer.size() == len) {
|
if (myBuffer.size() == len) {
|
||||||
|
|
|
@ -38,7 +38,7 @@ ZLFile::ZLFile() : myMimeTypeIsUpToDate(true), myInfoIsFilled(true) {
|
||||||
ZLFile::ZLFile(const std::string &path, const std::string &mimeType) : myPath(path), myMimeType(mimeType), myMimeTypeIsUpToDate(!mimeType.empty()), myInfoIsFilled(false) {
|
ZLFile::ZLFile(const std::string &path, const std::string &mimeType) : myPath(path), myMimeType(mimeType), myMimeTypeIsUpToDate(!mimeType.empty()), myInfoIsFilled(false) {
|
||||||
ZLFSManager::Instance().normalize(myPath);
|
ZLFSManager::Instance().normalize(myPath);
|
||||||
{
|
{
|
||||||
size_t index = ZLFSManager::Instance().findLastFileNameDelimiter(myPath);
|
std::size_t index = ZLFSManager::Instance().findLastFileNameDelimiter(myPath);
|
||||||
if (index < myPath.length() - 1) {
|
if (index < myPath.length() - 1) {
|
||||||
myNameWithExtension = myPath.substr(index + 1);
|
myNameWithExtension = myPath.substr(index + 1);
|
||||||
} else {
|
} else {
|
||||||
|
@ -224,7 +224,7 @@ bool ZLFile::exists() const {
|
||||||
return myInfo.Exists;
|
return myInfo.Exists;
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t ZLFile::size() const {
|
std::size_t ZLFile::size() const {
|
||||||
if (!myInfoIsFilled) {
|
if (!myInfoIsFilled) {
|
||||||
fillInfo();
|
fillInfo();
|
||||||
}
|
}
|
||||||
|
@ -252,9 +252,9 @@ bool ZLFile::canRemove() const {
|
||||||
|
|
||||||
std::string ZLFile::replaceIllegalCharacters(const std::string &fileName, char replaceWith) {
|
std::string ZLFile::replaceIllegalCharacters(const std::string &fileName, char replaceWith) {
|
||||||
static const char charsToReplace[] = ":;<|>+\\/\"*?";
|
static const char charsToReplace[] = ":;<|>+\\/\"*?";
|
||||||
const size_t len = fileName.length();
|
const std::size_t len = fileName.length();
|
||||||
char *data = new char[len];
|
char *data = new char[len];
|
||||||
memcpy(data, fileName.data(), len);
|
std::memcpy(data, fileName.data(), len);
|
||||||
char *end = data + len;
|
char *end = data + len;
|
||||||
for (char *ptr = data; ptr != end; ++ptr) {
|
for (char *ptr = data; ptr != end; ++ptr) {
|
||||||
if (strchr(charsToReplace, *ptr) != 0) {
|
if (strchr(charsToReplace, *ptr) != 0) {
|
||||||
|
|
|
@ -57,7 +57,7 @@ public:
|
||||||
~ZLFile();
|
~ZLFile();
|
||||||
|
|
||||||
bool exists() const;
|
bool exists() const;
|
||||||
size_t size() const;
|
std::size_t size() const;
|
||||||
|
|
||||||
void forceArchiveType(ArchiveType type) const;
|
void forceArchiveType(ArchiveType type) const;
|
||||||
|
|
||||||
|
|
|
@ -23,7 +23,7 @@
|
||||||
struct ZLFileInfo {
|
struct ZLFileInfo {
|
||||||
bool Exists;
|
bool Exists;
|
||||||
bool IsDirectory;
|
bool IsDirectory;
|
||||||
size_t Size;
|
std::size_t Size;
|
||||||
|
|
||||||
ZLFileInfo();
|
ZLFileInfo();
|
||||||
};
|
};
|
||||||
|
|
|
@ -32,12 +32,12 @@ protected:
|
||||||
public:
|
public:
|
||||||
virtual ~ZLInputStream();
|
virtual ~ZLInputStream();
|
||||||
virtual bool open() = 0;
|
virtual bool open() = 0;
|
||||||
virtual size_t read(char *buffer, size_t maxSize) = 0;
|
virtual std::size_t read(char *buffer, std::size_t maxSize) = 0;
|
||||||
virtual void close() = 0;
|
virtual void close() = 0;
|
||||||
|
|
||||||
virtual void seek(int offset, bool absoluteOffset) = 0;
|
virtual void seek(int offset, bool absoluteOffset) = 0;
|
||||||
virtual size_t offset() const = 0;
|
virtual std::size_t offset() const = 0;
|
||||||
virtual size_t sizeOfOpened() = 0;
|
virtual std::size_t sizeOfOpened() = 0;
|
||||||
|
|
||||||
private:
|
private:
|
||||||
// disable copying
|
// disable copying
|
||||||
|
@ -52,16 +52,16 @@ public:
|
||||||
|
|
||||||
private:
|
private:
|
||||||
bool open();
|
bool open();
|
||||||
size_t read(char *buffer, size_t maxSize);
|
std::size_t read(char *buffer, std::size_t maxSize);
|
||||||
void close();
|
void close();
|
||||||
|
|
||||||
void seek(int offset, bool absoluteOffset);
|
void seek(int offset, bool absoluteOffset);
|
||||||
size_t offset() const;
|
std::size_t offset() const;
|
||||||
size_t sizeOfOpened();
|
std::size_t sizeOfOpened();
|
||||||
|
|
||||||
private:
|
private:
|
||||||
shared_ptr<ZLInputStream> myBaseStream;
|
shared_ptr<ZLInputStream> myBaseStream;
|
||||||
size_t myBaseOffset;
|
std::size_t myBaseOffset;
|
||||||
};
|
};
|
||||||
|
|
||||||
inline ZLInputStream::ZLInputStream() {}
|
inline ZLInputStream::ZLInputStream() {}
|
||||||
|
|
|
@ -28,9 +28,9 @@ bool ZLInputStreamDecorator::open() {
|
||||||
return result;
|
return result;
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t ZLInputStreamDecorator::read(char *buffer, size_t maxSize) {
|
std::size_t ZLInputStreamDecorator::read(char *buffer, std::size_t maxSize) {
|
||||||
myBaseStream->seek(myBaseOffset, true);
|
myBaseStream->seek(myBaseOffset, true);
|
||||||
size_t result = myBaseStream->read(buffer, maxSize);
|
std::size_t result = myBaseStream->read(buffer, maxSize);
|
||||||
myBaseOffset = myBaseStream->offset();
|
myBaseOffset = myBaseStream->offset();
|
||||||
return result;
|
return result;
|
||||||
}
|
}
|
||||||
|
@ -48,10 +48,10 @@ void ZLInputStreamDecorator::seek(int offset, bool absoluteOffset) {
|
||||||
myBaseOffset = myBaseStream->offset();
|
myBaseOffset = myBaseStream->offset();
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t ZLInputStreamDecorator::offset() const {
|
std::size_t ZLInputStreamDecorator::offset() const {
|
||||||
return myBaseOffset;
|
return myBaseOffset;
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t ZLInputStreamDecorator::sizeOfOpened() {
|
std::size_t ZLInputStreamDecorator::sizeOfOpened() {
|
||||||
return myBaseStream->sizeOfOpened();
|
return myBaseStream->sizeOfOpened();
|
||||||
}
|
}
|
||||||
|
|
|
@ -30,7 +30,7 @@ protected:
|
||||||
public:
|
public:
|
||||||
virtual ~ZLOutputStream();
|
virtual ~ZLOutputStream();
|
||||||
virtual bool open() = 0;
|
virtual bool open() = 0;
|
||||||
virtual void write(const char *data, size_t len) = 0;
|
virtual void write(const char *data, std::size_t len) = 0;
|
||||||
virtual void write(const std::string &str) = 0;
|
virtual void write(const std::string &str) = 0;
|
||||||
virtual void close() = 0;
|
virtual void close() = 0;
|
||||||
|
|
||||||
|
|
|
@ -85,8 +85,8 @@ bool ZLGzipInputStream::open() {
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t ZLGzipInputStream::read(char *buffer, size_t maxSize) {
|
std::size_t ZLGzipInputStream::read(char *buffer, std::size_t maxSize) {
|
||||||
size_t realSize = myDecompressor->decompress(*myBaseStream, buffer, maxSize);
|
std::size_t realSize = myDecompressor->decompress(*myBaseStream, buffer, maxSize);
|
||||||
myOffset += realSize;
|
myOffset += realSize;
|
||||||
return realSize;
|
return realSize;
|
||||||
}
|
}
|
||||||
|
@ -111,11 +111,11 @@ void ZLGzipInputStream::seek(int offset, bool absoluteOffset) {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t ZLGzipInputStream::offset() const {
|
std::size_t ZLGzipInputStream::offset() const {
|
||||||
return myOffset;
|
return myOffset;
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t ZLGzipInputStream::sizeOfOpened() {
|
std::size_t ZLGzipInputStream::sizeOfOpened() {
|
||||||
// TODO: implement
|
// TODO: implement
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
|
@ -24,10 +24,10 @@
|
||||||
#include "../ZLInputStream.h"
|
#include "../ZLInputStream.h"
|
||||||
#include "ZLZDecompressor.h"
|
#include "ZLZDecompressor.h"
|
||||||
|
|
||||||
const size_t IN_BUFFER_SIZE = 2048;
|
const std::size_t IN_BUFFER_SIZE = 2048;
|
||||||
const size_t OUT_BUFFER_SIZE = 32768;
|
const std::size_t OUT_BUFFER_SIZE = 32768;
|
||||||
|
|
||||||
ZLZDecompressor::ZLZDecompressor(size_t size) : myAvailableSize(size) {
|
ZLZDecompressor::ZLZDecompressor(std::size_t size) : myAvailableSize(size) {
|
||||||
myZStream = new z_stream;
|
myZStream = new z_stream;
|
||||||
memset(myZStream, 0, sizeof(z_stream));
|
memset(myZStream, 0, sizeof(z_stream));
|
||||||
inflateInit2(myZStream, -MAX_WBITS);
|
inflateInit2(myZStream, -MAX_WBITS);
|
||||||
|
@ -44,9 +44,9 @@ ZLZDecompressor::~ZLZDecompressor() {
|
||||||
delete myZStream;
|
delete myZStream;
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t ZLZDecompressor::decompress(ZLInputStream &stream, char *buffer, size_t maxSize) {
|
std::size_t ZLZDecompressor::decompress(ZLInputStream &stream, char *buffer, std::size_t maxSize) {
|
||||||
while ((myBuffer.length() < maxSize) && (myAvailableSize > 0)) {
|
while ((myBuffer.length() < maxSize) && (myAvailableSize > 0)) {
|
||||||
size_t size = std::min(myAvailableSize, (size_t)IN_BUFFER_SIZE);
|
std::size_t size = std::min(myAvailableSize, (std::size_t)IN_BUFFER_SIZE);
|
||||||
|
|
||||||
myZStream->next_in = (Bytef*)myInBuffer;
|
myZStream->next_in = (Bytef*)myInBuffer;
|
||||||
myZStream->avail_in = stream.read(myInBuffer, size);
|
myZStream->avail_in = stream.read(myInBuffer, size);
|
||||||
|
@ -76,9 +76,9 @@ size_t ZLZDecompressor::decompress(ZLInputStream &stream, char *buffer, size_t m
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t realSize = std::min(maxSize, myBuffer.length());
|
std::size_t realSize = std::min(maxSize, myBuffer.length());
|
||||||
if (buffer != 0) {
|
if (buffer != 0) {
|
||||||
memcpy(buffer, myBuffer.data(), realSize);
|
std::memcpy(buffer, myBuffer.data(), realSize);
|
||||||
}
|
}
|
||||||
myBuffer.erase(0, realSize);
|
myBuffer.erase(0, realSize);
|
||||||
return realSize;
|
return realSize;
|
||||||
|
|
|
@ -29,14 +29,14 @@ class ZLInputStream;
|
||||||
class ZLZDecompressor {
|
class ZLZDecompressor {
|
||||||
|
|
||||||
public:
|
public:
|
||||||
ZLZDecompressor(size_t size);
|
ZLZDecompressor(std::size_t size);
|
||||||
~ZLZDecompressor();
|
~ZLZDecompressor();
|
||||||
|
|
||||||
size_t decompress(ZLInputStream &stream, char *buffer, size_t maxSize);
|
std::size_t decompress(ZLInputStream &stream, char *buffer, std::size_t maxSize);
|
||||||
|
|
||||||
private:
|
private:
|
||||||
z_stream *myZStream;
|
z_stream *myZStream;
|
||||||
size_t myAvailableSize;
|
std::size_t myAvailableSize;
|
||||||
char *myInBuffer;
|
char *myInBuffer;
|
||||||
char *myOutBuffer;
|
char *myOutBuffer;
|
||||||
std::string myBuffer;
|
std::string myBuffer;
|
||||||
|
|
|
@ -36,9 +36,9 @@ public:
|
||||||
static shared_ptr<ZLZipEntryCache> cache(const std::string &containerName, ZLInputStream &containerStream);
|
static shared_ptr<ZLZipEntryCache> cache(const std::string &containerName, ZLInputStream &containerStream);
|
||||||
|
|
||||||
private:
|
private:
|
||||||
static const size_t ourStorageSize;
|
static const std::size_t ourStorageSize;
|
||||||
static shared_ptr<ZLZipEntryCache> *ourStoredCaches;
|
static shared_ptr<ZLZipEntryCache> *ourStoredCaches;
|
||||||
static size_t ourIndex;
|
static std::size_t ourIndex;
|
||||||
|
|
||||||
public:
|
public:
|
||||||
struct Info {
|
struct Info {
|
||||||
|
@ -70,12 +70,12 @@ private:
|
||||||
public:
|
public:
|
||||||
~ZLZipInputStream();
|
~ZLZipInputStream();
|
||||||
bool open();
|
bool open();
|
||||||
size_t read(char *buffer, size_t maxSize);
|
std::size_t read(char *buffer, std::size_t maxSize);
|
||||||
void close();
|
void close();
|
||||||
|
|
||||||
void seek(int offset, bool absoluteOffset);
|
void seek(int offset, bool absoluteOffset);
|
||||||
size_t offset() const;
|
std::size_t offset() const;
|
||||||
size_t sizeOfOpened();
|
std::size_t sizeOfOpened();
|
||||||
|
|
||||||
private:
|
private:
|
||||||
shared_ptr<ZLInputStream> myBaseStream;
|
shared_ptr<ZLInputStream> myBaseStream;
|
||||||
|
@ -83,9 +83,9 @@ private:
|
||||||
std::string myEntryName;
|
std::string myEntryName;
|
||||||
bool myIsDeflated;
|
bool myIsDeflated;
|
||||||
|
|
||||||
size_t myUncompressedSize;
|
std::size_t myUncompressedSize;
|
||||||
size_t myAvailableSize;
|
std::size_t myAvailableSize;
|
||||||
size_t myOffset;
|
std::size_t myOffset;
|
||||||
|
|
||||||
shared_ptr<ZLZDecompressor> myDecompressor;
|
shared_ptr<ZLZDecompressor> myDecompressor;
|
||||||
|
|
||||||
|
@ -100,18 +100,18 @@ private:
|
||||||
public:
|
public:
|
||||||
~ZLGzipInputStream();
|
~ZLGzipInputStream();
|
||||||
bool open();
|
bool open();
|
||||||
size_t read(char *buffer, size_t maxSize);
|
std::size_t read(char *buffer, std::size_t maxSize);
|
||||||
void close();
|
void close();
|
||||||
|
|
||||||
void seek(int offset, bool absoluteOffset);
|
void seek(int offset, bool absoluteOffset);
|
||||||
size_t offset() const;
|
std::size_t offset() const;
|
||||||
size_t sizeOfOpened();
|
std::size_t sizeOfOpened();
|
||||||
|
|
||||||
private:
|
private:
|
||||||
shared_ptr<ZLInputStream> myBaseStream;
|
shared_ptr<ZLInputStream> myBaseStream;
|
||||||
size_t myFileSize;
|
std::size_t myFileSize;
|
||||||
|
|
||||||
size_t myOffset;
|
std::size_t myOffset;
|
||||||
|
|
||||||
shared_ptr<ZLZDecompressor> myDecompressor;
|
shared_ptr<ZLZDecompressor> myDecompressor;
|
||||||
|
|
||||||
|
|
|
@ -23,15 +23,15 @@
|
||||||
#include "ZLZip.h"
|
#include "ZLZip.h"
|
||||||
#include "ZLZipHeader.h"
|
#include "ZLZipHeader.h"
|
||||||
|
|
||||||
const size_t ZLZipEntryCache::ourStorageSize = 5;
|
const std::size_t ZLZipEntryCache::ourStorageSize = 5;
|
||||||
shared_ptr<ZLZipEntryCache> *ZLZipEntryCache::ourStoredCaches =
|
shared_ptr<ZLZipEntryCache> *ZLZipEntryCache::ourStoredCaches =
|
||||||
new shared_ptr<ZLZipEntryCache>[ourStorageSize];
|
new shared_ptr<ZLZipEntryCache>[ourStorageSize];
|
||||||
size_t ZLZipEntryCache::ourIndex = 0;
|
std::size_t ZLZipEntryCache::ourIndex = 0;
|
||||||
|
|
||||||
shared_ptr<ZLZipEntryCache> ZLZipEntryCache::cache(const std::string &containerName, ZLInputStream &containerStream) {
|
shared_ptr<ZLZipEntryCache> ZLZipEntryCache::cache(const std::string &containerName, ZLInputStream &containerStream) {
|
||||||
//ZLLogger::Instance().registerClass("ZipEntryCache");
|
//ZLLogger::Instance().registerClass("ZipEntryCache");
|
||||||
//ZLLogger::Instance().println("ZipEntryCache", "requesting cache for " + containerName);
|
//ZLLogger::Instance().println("ZipEntryCache", "requesting cache for " + containerName);
|
||||||
for (size_t i = 0; i < ourStorageSize; ++i) {
|
for (std::size_t i = 0; i < ourStorageSize; ++i) {
|
||||||
shared_ptr<ZLZipEntryCache> cache = ourStoredCaches[i];
|
shared_ptr<ZLZipEntryCache> cache = ourStoredCaches[i];
|
||||||
if (!cache.isNull() && cache->myContainerName == containerName) {
|
if (!cache.isNull() && cache->myContainerName == containerName) {
|
||||||
return cache;
|
return cache;
|
||||||
|
|
|
@ -29,7 +29,7 @@ const int ZLZipHeader::SignatureEndOfCentralDirectory = 0x06054B50;
|
||||||
const int ZLZipHeader::SignatureData = 0x08074B50;
|
const int ZLZipHeader::SignatureData = 0x08074B50;
|
||||||
|
|
||||||
bool ZLZipHeader::readFrom(ZLInputStream &stream) {
|
bool ZLZipHeader::readFrom(ZLInputStream &stream) {
|
||||||
size_t startOffset = stream.offset();
|
std::size_t startOffset = stream.offset();
|
||||||
Signature = readLong(stream);
|
Signature = readLong(stream);
|
||||||
switch (Signature) {
|
switch (Signature) {
|
||||||
default:
|
default:
|
||||||
|
@ -95,8 +95,8 @@ void ZLZipHeader::skipEntry(ZLInputStream &stream, ZLZipHeader &header) {
|
||||||
case SignatureLocalFile:
|
case SignatureLocalFile:
|
||||||
if ((header.Flags & 0x08) == 0x08 && header.CompressionMethod != 0) {
|
if ((header.Flags & 0x08) == 0x08 && header.CompressionMethod != 0) {
|
||||||
stream.seek(header.ExtraLength, false);
|
stream.seek(header.ExtraLength, false);
|
||||||
ZLZDecompressor decompressor((size_t)-1);
|
ZLZDecompressor decompressor((std::size_t)-1);
|
||||||
size_t size;
|
std::size_t size;
|
||||||
do {
|
do {
|
||||||
size = decompressor.decompress(stream, 0, 2048);
|
size = decompressor.decompress(stream, 0, 2048);
|
||||||
header.UncompressedSize += size;
|
header.UncompressedSize += size;
|
||||||
|
|
|
@ -57,7 +57,7 @@ bool ZLZipInputStream::open() {
|
||||||
myUncompressedSize = info.UncompressedSize;
|
myUncompressedSize = info.UncompressedSize;
|
||||||
myAvailableSize = info.CompressedSize;
|
myAvailableSize = info.CompressedSize;
|
||||||
if (myAvailableSize == 0) {
|
if (myAvailableSize == 0) {
|
||||||
myAvailableSize = (size_t)-1;
|
myAvailableSize = (std::size_t)-1;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (myIsDeflated) {
|
if (myIsDeflated) {
|
||||||
|
@ -68,8 +68,8 @@ bool ZLZipInputStream::open() {
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t ZLZipInputStream::read(char *buffer, size_t maxSize) {
|
std::size_t ZLZipInputStream::read(char *buffer, std::size_t maxSize) {
|
||||||
size_t realSize = 0;
|
std::size_t realSize = 0;
|
||||||
if (myIsDeflated) {
|
if (myIsDeflated) {
|
||||||
realSize = myDecompressor->decompress(*myBaseStream, buffer, maxSize);
|
realSize = myDecompressor->decompress(*myBaseStream, buffer, maxSize);
|
||||||
myOffset += realSize;
|
myOffset += realSize;
|
||||||
|
@ -103,10 +103,10 @@ void ZLZipInputStream::seek(int offset, bool absoluteOffset) {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t ZLZipInputStream::offset() const {
|
std::size_t ZLZipInputStream::offset() const {
|
||||||
return myOffset;
|
return myOffset;
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t ZLZipInputStream::sizeOfOpened() {
|
std::size_t ZLZipInputStream::sizeOfOpened() {
|
||||||
return myUncompressedSize;
|
return myUncompressedSize;
|
||||||
}
|
}
|
||||||
|
|
|
@ -38,7 +38,7 @@ public:
|
||||||
typedef std::vector<Block> Blocks;
|
typedef std::vector<Block> Blocks;
|
||||||
|
|
||||||
public:
|
public:
|
||||||
ZLFileImage(const ZLFile &file, const std::string &encoding, size_t offset, size_t size = 0);
|
ZLFileImage(const ZLFile &file, const std::string &encoding, std::size_t offset, std::size_t size = 0);
|
||||||
ZLFileImage(const ZLFile &file, const std::string &encoding, const Blocks &blocks);
|
ZLFileImage(const ZLFile &file, const std::string &encoding, const Blocks &blocks);
|
||||||
|
|
||||||
//Kind kind() const;
|
//Kind kind() const;
|
||||||
|
@ -57,7 +57,7 @@ private:
|
||||||
|
|
||||||
inline ZLFileImage::Block::Block(unsigned int off, unsigned int s) : offset(off), size(s) {}
|
inline ZLFileImage::Block::Block(unsigned int off, unsigned int s) : offset(off), size(s) {}
|
||||||
|
|
||||||
inline ZLFileImage::ZLFileImage(const ZLFile &file, const std::string &encoding, size_t offset, size_t size) : ZLSingleImage(file.mimeType()), myFile(file), myEncoding(encoding) {
|
inline ZLFileImage::ZLFileImage(const ZLFile &file, const std::string &encoding, std::size_t offset, std::size_t size) : ZLSingleImage(file.mimeType()), myFile(file), myEncoding(encoding) {
|
||||||
myBlocks.push_back(Block(offset, size));
|
myBlocks.push_back(Block(offset, size));
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -28,25 +28,25 @@
|
||||||
class ZLStreamImage : public ZLSingleImage {
|
class ZLStreamImage : public ZLSingleImage {
|
||||||
|
|
||||||
public:
|
public:
|
||||||
ZLStreamImage(const std::string &mimeType, const std::string &encoding, size_t offset, size_t size = 0);
|
ZLStreamImage(const std::string &mimeType, const std::string &encoding, std::size_t offset, std::size_t size = 0);
|
||||||
//const shared_ptr<std::string> stringData() const;
|
//const shared_ptr<std::string> stringData() const;
|
||||||
|
|
||||||
const std::string &encoding() const;
|
const std::string &encoding() const;
|
||||||
size_t offset() const;
|
std::size_t offset() const;
|
||||||
size_t size() const;
|
std::size_t size() const;
|
||||||
|
|
||||||
private:
|
private:
|
||||||
//virtual shared_ptr<ZLInputStream> inputStream() const = 0;
|
//virtual shared_ptr<ZLInputStream> inputStream() const = 0;
|
||||||
|
|
||||||
private:
|
private:
|
||||||
const std::string myEncoding;
|
const std::string myEncoding;
|
||||||
const size_t myOffset;
|
const std::size_t myOffset;
|
||||||
mutable size_t mySize;
|
mutable std::size_t mySize;
|
||||||
};
|
};
|
||||||
|
|
||||||
inline ZLStreamImage::ZLStreamImage(const std::string &mimeType, const std::string &encoding, size_t offset, size_t size) : ZLSingleImage(mimeType), myEncoding(encoding), myOffset(offset), mySize(size) {}
|
inline ZLStreamImage::ZLStreamImage(const std::string &mimeType, const std::string &encoding, std::size_t offset, std::size_t size) : ZLSingleImage(mimeType), myEncoding(encoding), myOffset(offset), mySize(size) {}
|
||||||
inline const std::string &ZLStreamImage::encoding() const { return myEncoding; }
|
inline const std::string &ZLStreamImage::encoding() const { return myEncoding; }
|
||||||
inline size_t ZLStreamImage::offset() const { return myOffset; }
|
inline std::size_t ZLStreamImage::offset() const { return myOffset; }
|
||||||
inline size_t ZLStreamImage::size() const { return mySize; }
|
inline std::size_t ZLStreamImage::size() const { return mySize; }
|
||||||
|
|
||||||
#endif /* __ZLSTREAMIMAGE_H__ */
|
#endif /* __ZLSTREAMIMAGE_H__ */
|
||||||
|
|
|
@ -21,13 +21,13 @@
|
||||||
|
|
||||||
#include "ZLCharSequence.h"
|
#include "ZLCharSequence.h"
|
||||||
|
|
||||||
ZLCharSequence::ZLCharSequence(const char *ptr, size_t size) : mySize(size) {
|
ZLCharSequence::ZLCharSequence(const char *ptr, std::size_t size) : mySize(size) {
|
||||||
if (mySize == 0) {
|
if (mySize == 0) {
|
||||||
myHead = 0;
|
myHead = 0;
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
myHead = new char[mySize];
|
myHead = new char[mySize];
|
||||||
for (size_t count = 0; count < mySize; ++count){
|
for (std::size_t count = 0; count < mySize; ++count){
|
||||||
myHead[count] = ptr[count];
|
myHead[count] = ptr[count];
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -38,7 +38,7 @@ ZLCharSequence::ZLCharSequence(const ZLCharSequence& other) : mySize(other.mySiz
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
myHead = new char[other.mySize];
|
myHead = new char[other.mySize];
|
||||||
for (size_t count = 0; count < mySize; ++count) {
|
for (std::size_t count = 0; count < mySize; ++count) {
|
||||||
myHead[count] = other.myHead[count];
|
myHead[count] = other.myHead[count];
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -46,7 +46,7 @@ ZLCharSequence::ZLCharSequence(const ZLCharSequence& other) : mySize(other.mySiz
|
||||||
ZLCharSequence::ZLCharSequence(const std::string &hexSequence) {
|
ZLCharSequence::ZLCharSequence(const std::string &hexSequence) {
|
||||||
mySize = (hexSequence.size() + 1) / 5;
|
mySize = (hexSequence.size() + 1) / 5;
|
||||||
myHead = new char[mySize];
|
myHead = new char[mySize];
|
||||||
for (size_t count = 0; count < mySize; ++count){
|
for (std::size_t count = 0; count < mySize; ++count){
|
||||||
char a = hexSequence[count * 5 + 2];
|
char a = hexSequence[count * 5 + 2];
|
||||||
char b = hexSequence[count * 5 + 3];
|
char b = hexSequence[count * 5 + 3];
|
||||||
a -= (a >= 97) ? 87 : 48;
|
a -= (a >= 97) ? 87 : 48;
|
||||||
|
@ -66,7 +66,7 @@ ZLCharSequence& ZLCharSequence::operator= (const ZLCharSequence& other) {
|
||||||
if (myHead == 0) {
|
if (myHead == 0) {
|
||||||
myHead = new char[mySize];
|
myHead = new char[mySize];
|
||||||
}
|
}
|
||||||
for (size_t count = 0; count < mySize; ++count) {
|
for (std::size_t count = 0; count < mySize; ++count) {
|
||||||
myHead[count] = other.myHead[count];
|
myHead[count] = other.myHead[count];
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -77,7 +77,7 @@ ZLCharSequence& ZLCharSequence::operator= (const ZLCharSequence& other) {
|
||||||
std::string ZLCharSequence::toHexSequence() const {
|
std::string ZLCharSequence::toHexSequence() const {
|
||||||
std::string result;
|
std::string result;
|
||||||
static const char table[] = "0123456789abcdef";
|
static const char table[] = "0123456789abcdef";
|
||||||
for (size_t count = 0;; ++count) {
|
for (std::size_t count = 0;; ++count) {
|
||||||
result += "0x";
|
result += "0x";
|
||||||
result += table[(myHead[count] >> 4) & 0x0F];
|
result += table[(myHead[count] >> 4) & 0x0F];
|
||||||
result += table[myHead[count] & 0x0F];
|
result += table[myHead[count] & 0x0F];
|
||||||
|
@ -94,7 +94,7 @@ int ZLCharSequence::compareTo(const ZLCharSequence &other) const {
|
||||||
if (difference != 0) {
|
if (difference != 0) {
|
||||||
return difference;
|
return difference;
|
||||||
}
|
}
|
||||||
for (size_t i = 0; i < mySize; ++i) {
|
for (std::size_t i = 0; i < mySize; ++i) {
|
||||||
int a = (int)(unsigned int)(unsigned char) myHead[i];
|
int a = (int)(unsigned int)(unsigned char) myHead[i];
|
||||||
int b = (int)(unsigned int)(unsigned char) other.myHead[i];
|
int b = (int)(unsigned int)(unsigned char) other.myHead[i];
|
||||||
difference = a - b;
|
difference = a - b;
|
||||||
|
|
|
@ -26,13 +26,13 @@ class ZLCharSequence {
|
||||||
|
|
||||||
public:
|
public:
|
||||||
ZLCharSequence();
|
ZLCharSequence();
|
||||||
ZLCharSequence(const char *ptr, size_t size);
|
ZLCharSequence(const char *ptr, std::size_t size);
|
||||||
ZLCharSequence(const std::string &hexSequence);
|
ZLCharSequence(const std::string &hexSequence);
|
||||||
ZLCharSequence(const ZLCharSequence &other);
|
ZLCharSequence(const ZLCharSequence &other);
|
||||||
~ZLCharSequence();
|
~ZLCharSequence();
|
||||||
|
|
||||||
size_t getSize() const;
|
std::size_t getSize() const;
|
||||||
const char &operator [] (size_t index) const;
|
const char &operator [] (std::size_t index) const;
|
||||||
ZLCharSequence &operator = (const ZLCharSequence& other);
|
ZLCharSequence &operator = (const ZLCharSequence& other);
|
||||||
|
|
||||||
std::string toHexSequence() const;
|
std::string toHexSequence() const;
|
||||||
|
@ -44,13 +44,13 @@ public:
|
||||||
int compareTo(const ZLCharSequence &other) const;
|
int compareTo(const ZLCharSequence &other) const;
|
||||||
|
|
||||||
private:
|
private:
|
||||||
size_t mySize;
|
std::size_t mySize;
|
||||||
char *myHead;
|
char *myHead;
|
||||||
};
|
};
|
||||||
|
|
||||||
inline ZLCharSequence::ZLCharSequence() : mySize(0), myHead(0) {}
|
inline ZLCharSequence::ZLCharSequence() : mySize(0), myHead(0) {}
|
||||||
|
|
||||||
inline const char& ZLCharSequence::operator [] (size_t index) const {
|
inline const char& ZLCharSequence::operator [] (std::size_t index) const {
|
||||||
return myHead[index];
|
return myHead[index];
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -64,7 +64,7 @@ inline ZLCharSequence::~ZLCharSequence() {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
inline size_t ZLCharSequence::getSize() const {
|
inline std::size_t ZLCharSequence::getSize() const {
|
||||||
return mySize;
|
return mySize;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -55,7 +55,7 @@ ZLLanguageDetector::ZLLanguageDetector() {
|
||||||
ZLLanguageDetector::~ZLLanguageDetector() {
|
ZLLanguageDetector::~ZLLanguageDetector() {
|
||||||
}
|
}
|
||||||
|
|
||||||
static std::string naiveEncodingDetection(const unsigned char *buffer, size_t length) {
|
static std::string naiveEncodingDetection(const unsigned char *buffer, std::size_t length) {
|
||||||
if (buffer[0] == 0xFE && buffer[1] == 0xFF) {
|
if (buffer[0] == 0xFE && buffer[1] == 0xFF) {
|
||||||
return ZLEncodingConverter::UTF16BE;
|
return ZLEncodingConverter::UTF16BE;
|
||||||
}
|
}
|
||||||
|
@ -89,7 +89,7 @@ static std::string naiveEncodingDetection(const unsigned char *buffer, size_t le
|
||||||
return ascii ? ZLEncodingConverter::ASCII : ZLEncodingConverter::UTF8;
|
return ascii ? ZLEncodingConverter::ASCII : ZLEncodingConverter::UTF8;
|
||||||
}
|
}
|
||||||
|
|
||||||
shared_ptr<ZLLanguageDetector::LanguageInfo> ZLLanguageDetector::findInfo(const char *buffer, size_t length, int matchingCriterion) {
|
shared_ptr<ZLLanguageDetector::LanguageInfo> ZLLanguageDetector::findInfo(const char *buffer, std::size_t length, int matchingCriterion) {
|
||||||
std::string naive;
|
std::string naive;
|
||||||
if ((unsigned char)buffer[0] == 0xFE &&
|
if ((unsigned char)buffer[0] == 0xFE &&
|
||||||
(unsigned char)buffer[1] == 0xFF) {
|
(unsigned char)buffer[1] == 0xFF) {
|
||||||
|
@ -103,7 +103,7 @@ shared_ptr<ZLLanguageDetector::LanguageInfo> ZLLanguageDetector::findInfo(const
|
||||||
return findInfoForEncoding(naive, buffer, length, matchingCriterion);
|
return findInfoForEncoding(naive, buffer, length, matchingCriterion);
|
||||||
}
|
}
|
||||||
|
|
||||||
shared_ptr<ZLLanguageDetector::LanguageInfo> ZLLanguageDetector::findInfoForEncoding(const std::string &encoding, const char *buffer, size_t length, int matchingCriterion) {
|
shared_ptr<ZLLanguageDetector::LanguageInfo> ZLLanguageDetector::findInfoForEncoding(const std::string &encoding, const char *buffer, std::size_t length, int matchingCriterion) {
|
||||||
shared_ptr<LanguageInfo> info;
|
shared_ptr<LanguageInfo> info;
|
||||||
std::map<int,shared_ptr<ZLMapBasedStatistics> > statisticsMap;
|
std::map<int,shared_ptr<ZLMapBasedStatistics> > statisticsMap;
|
||||||
for (SBVector::const_iterator it = myMatchers.begin(); it != myMatchers.end(); ++it) {
|
for (SBVector::const_iterator it = myMatchers.begin(); it != myMatchers.end(); ++it) {
|
||||||
|
|
|
@ -40,8 +40,8 @@ public:
|
||||||
ZLLanguageDetector();
|
ZLLanguageDetector();
|
||||||
~ZLLanguageDetector();
|
~ZLLanguageDetector();
|
||||||
|
|
||||||
shared_ptr<LanguageInfo> findInfo(const char *buffer, size_t length, int matchingCriterion = 0);
|
shared_ptr<LanguageInfo> findInfo(const char *buffer, std::size_t length, int matchingCriterion = 0);
|
||||||
shared_ptr<LanguageInfo> findInfoForEncoding(const std::string &encoding, const char *buffer, size_t length, int matchingCriterion = 0);
|
shared_ptr<LanguageInfo> findInfoForEncoding(const std::string &encoding, const char *buffer, std::size_t length, int matchingCriterion = 0);
|
||||||
|
|
||||||
private:
|
private:
|
||||||
typedef std::vector<shared_ptr<ZLStatisticsBasedMatcher> > SBVector;
|
typedef std::vector<shared_ptr<ZLStatisticsBasedMatcher> > SBVector;
|
||||||
|
|
|
@ -28,12 +28,12 @@ ZLStatistics::ZLStatistics() : myCharSequenceSize(0), myVolumesAreUpToDate(true)
|
||||||
myVolume(0), mySquaresVolume(0) {
|
myVolume(0), mySquaresVolume(0) {
|
||||||
}
|
}
|
||||||
|
|
||||||
ZLStatistics::ZLStatistics(size_t charSequenceSize) :
|
ZLStatistics::ZLStatistics(std::size_t charSequenceSize) :
|
||||||
myCharSequenceSize(charSequenceSize), myVolumesAreUpToDate(true),
|
myCharSequenceSize(charSequenceSize), myVolumesAreUpToDate(true),
|
||||||
myVolume(0), mySquaresVolume(0) {
|
myVolume(0), mySquaresVolume(0) {
|
||||||
}
|
}
|
||||||
|
|
||||||
ZLStatistics::ZLStatistics(size_t charSequenceSize, size_t volume, unsigned long long squaresVolume) :
|
ZLStatistics::ZLStatistics(std::size_t charSequenceSize, std::size_t volume, unsigned long long squaresVolume) :
|
||||||
myCharSequenceSize(charSequenceSize), myVolumesAreUpToDate(true),
|
myCharSequenceSize(charSequenceSize), myVolumesAreUpToDate(true),
|
||||||
myVolume(volume), mySquaresVolume(squaresVolume) {
|
myVolume(volume), mySquaresVolume(squaresVolume) {
|
||||||
}
|
}
|
||||||
|
@ -41,7 +41,7 @@ ZLStatistics::ZLStatistics(size_t charSequenceSize, size_t volume, unsigned long
|
||||||
ZLStatistics::~ZLStatistics() {
|
ZLStatistics::~ZLStatistics() {
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t ZLStatistics::getVolume() const {
|
std::size_t ZLStatistics::getVolume() const {
|
||||||
if (!myVolumesAreUpToDate) {
|
if (!myVolumesAreUpToDate) {
|
||||||
calculateVolumes();
|
calculateVolumes();
|
||||||
}
|
}
|
||||||
|
@ -86,7 +86,7 @@ int ZLStatistics::correlation(const ZLStatistics& candidate, const ZLStatistics&
|
||||||
const shared_ptr<ZLStatisticsItem> endA = candidate.end();
|
const shared_ptr<ZLStatisticsItem> endA = candidate.end();
|
||||||
const shared_ptr<ZLStatisticsItem> endB = pattern.end();
|
const shared_ptr<ZLStatisticsItem> endB = pattern.end();
|
||||||
|
|
||||||
size_t count = 0;
|
std::size_t count = 0;
|
||||||
long long correlationSum = 0;
|
long long correlationSum = 0;
|
||||||
while ((*ptrA != *endA) && (*ptrB != *endB)) {
|
while ((*ptrA != *endA) && (*ptrB != *endB)) {
|
||||||
++count;
|
++count;
|
||||||
|
@ -172,14 +172,14 @@ void ZLMapBasedStatistics::calculateVolumes() const {
|
||||||
myVolume = 0;
|
myVolume = 0;
|
||||||
mySquaresVolume = 0;
|
mySquaresVolume = 0;
|
||||||
for (Dictionary::const_iterator it = myDictionary.begin(); it != myDictionary.end(); ++it) {
|
for (Dictionary::const_iterator it = myDictionary.begin(); it != myDictionary.end(); ++it) {
|
||||||
const size_t frequency = it->second;
|
const std::size_t frequency = it->second;
|
||||||
myVolume += frequency;
|
myVolume += frequency;
|
||||||
mySquaresVolume += frequency * frequency;
|
mySquaresVolume += frequency * frequency;
|
||||||
}
|
}
|
||||||
myVolumesAreUpToDate = true;
|
myVolumesAreUpToDate = true;
|
||||||
}
|
}
|
||||||
|
|
||||||
ZLMapBasedStatistics ZLMapBasedStatistics::top(size_t amount) const {
|
ZLMapBasedStatistics ZLMapBasedStatistics::top(std::size_t amount) const {
|
||||||
if (myDictionary.empty()) {
|
if (myDictionary.empty()) {
|
||||||
return ZLMapBasedStatistics();
|
return ZLMapBasedStatistics();
|
||||||
}
|
}
|
||||||
|
@ -237,10 +237,10 @@ void ZLMapBasedStatistics::retain(const ZLMapBasedStatistics &other) {
|
||||||
}
|
}
|
||||||
|
|
||||||
void ZLMapBasedStatistics::scaleToShort() {
|
void ZLMapBasedStatistics::scaleToShort() {
|
||||||
const size_t maxFrequency = std::max_element(myDictionary.begin(), myDictionary.end(), LessFrequency())->second;
|
const std::size_t maxFrequency = std::max_element(myDictionary.begin(), myDictionary.end(), LessFrequency())->second;
|
||||||
const size_t maxShort = 65535;
|
const std::size_t maxShort = 65535;
|
||||||
if (maxFrequency > maxShort) {
|
if (maxFrequency > maxShort) {
|
||||||
const size_t devider = maxFrequency / maxShort + 1;
|
const std::size_t devider = maxFrequency / maxShort + 1;
|
||||||
Dictionary::iterator it = myDictionary.begin();
|
Dictionary::iterator it = myDictionary.begin();
|
||||||
const Dictionary::iterator end = myDictionary.end();
|
const Dictionary::iterator end = myDictionary.end();
|
||||||
while (it != end) {
|
while (it != end) {
|
||||||
|
@ -266,7 +266,7 @@ ZLArrayBasedStatistics::ZLArrayBasedStatistics() : ZLStatistics(),
|
||||||
myCapacity(0), myBack(0), mySequences(0), myFrequencies(0) {
|
myCapacity(0), myBack(0), mySequences(0), myFrequencies(0) {
|
||||||
}
|
}
|
||||||
|
|
||||||
ZLArrayBasedStatistics::ZLArrayBasedStatistics(size_t charSequenceSize, size_t size, size_t volume, unsigned long long squaresVolume) :
|
ZLArrayBasedStatistics::ZLArrayBasedStatistics(std::size_t charSequenceSize, std::size_t size, std::size_t volume, unsigned long long squaresVolume) :
|
||||||
ZLStatistics(charSequenceSize, volume, squaresVolume), myCapacity(size) {
|
ZLStatistics(charSequenceSize, volume, squaresVolume), myCapacity(size) {
|
||||||
myBack = 0;
|
myBack = 0;
|
||||||
mySequences = new char[myCharSequenceSize * size];
|
mySequences = new char[myCharSequenceSize * size];
|
||||||
|
@ -280,11 +280,11 @@ ZLArrayBasedStatistics::~ZLArrayBasedStatistics() {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void ZLArrayBasedStatistics::insert(const ZLCharSequence &charSequence, size_t frequency) {
|
void ZLArrayBasedStatistics::insert(const ZLCharSequence &charSequence, std::size_t frequency) {
|
||||||
if (myBack == myCapacity) {
|
if (myBack == myCapacity) {
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
for (size_t i = 0; i < myCharSequenceSize; ++i) {
|
for (std::size_t i = 0; i < myCharSequenceSize; ++i) {
|
||||||
mySequences[myBack * myCharSequenceSize + i] = charSequence[i];
|
mySequences[myBack * myCharSequenceSize + i] = charSequence[i];
|
||||||
}
|
}
|
||||||
myFrequencies[myBack] = (unsigned short) frequency;
|
myFrequencies[myBack] = (unsigned short) frequency;
|
||||||
|
@ -295,8 +295,8 @@ void ZLArrayBasedStatistics::insert(const ZLCharSequence &charSequence, size_t f
|
||||||
void ZLArrayBasedStatistics::calculateVolumes() const {
|
void ZLArrayBasedStatistics::calculateVolumes() const {
|
||||||
myVolume = 0;
|
myVolume = 0;
|
||||||
mySquaresVolume = 0;
|
mySquaresVolume = 0;
|
||||||
for (size_t i = 0; i != myBack; ++i) {
|
for (std::size_t i = 0; i != myBack; ++i) {
|
||||||
const size_t frequency = myFrequencies[i];
|
const std::size_t frequency = myFrequencies[i];
|
||||||
myVolume += frequency;
|
myVolume += frequency;
|
||||||
mySquaresVolume += frequency * frequency;
|
mySquaresVolume += frequency * frequency;
|
||||||
}
|
}
|
||||||
|
|
|
@ -32,13 +32,13 @@ class ZLStatistics {
|
||||||
|
|
||||||
public:
|
public:
|
||||||
ZLStatistics();
|
ZLStatistics();
|
||||||
ZLStatistics(size_t charSequenceSize);
|
ZLStatistics(std::size_t charSequenceSize);
|
||||||
ZLStatistics(size_t charSequenceSize, size_t volume, unsigned long long squaresVolume);
|
ZLStatistics(std::size_t charSequenceSize, std::size_t volume, unsigned long long squaresVolume);
|
||||||
virtual ~ZLStatistics();
|
virtual ~ZLStatistics();
|
||||||
|
|
||||||
size_t getVolume() const;
|
std::size_t getVolume() const;
|
||||||
unsigned long long getSquaresVolume() const;
|
unsigned long long getSquaresVolume() const;
|
||||||
size_t getCharSequenceSize() const;
|
std::size_t getCharSequenceSize() const;
|
||||||
|
|
||||||
public:
|
public:
|
||||||
virtual shared_ptr<ZLStatisticsItem> begin() const = 0;
|
virtual shared_ptr<ZLStatisticsItem> begin() const = 0;
|
||||||
|
@ -51,26 +51,26 @@ public:
|
||||||
static int correlation(const ZLStatistics &candidate, const ZLStatistics &pattern);
|
static int correlation(const ZLStatistics &candidate, const ZLStatistics &pattern);
|
||||||
|
|
||||||
protected:
|
protected:
|
||||||
size_t myCharSequenceSize;
|
std::size_t myCharSequenceSize;
|
||||||
mutable bool myVolumesAreUpToDate;
|
mutable bool myVolumesAreUpToDate;
|
||||||
mutable size_t myVolume;
|
mutable std::size_t myVolume;
|
||||||
mutable unsigned long long mySquaresVolume;
|
mutable unsigned long long mySquaresVolume;
|
||||||
};
|
};
|
||||||
|
|
||||||
class ZLMapBasedStatistics : public ZLStatistics {
|
class ZLMapBasedStatistics : public ZLStatistics {
|
||||||
|
|
||||||
private:
|
private:
|
||||||
typedef std::vector<std::pair<ZLCharSequence, size_t> > Vector;
|
typedef std::vector<std::pair<ZLCharSequence, std::size_t> > Vector;
|
||||||
typedef std::map<ZLCharSequence, size_t> Dictionary;
|
typedef std::map<ZLCharSequence, std::size_t> Dictionary;
|
||||||
|
|
||||||
public:
|
public:
|
||||||
ZLMapBasedStatistics();
|
ZLMapBasedStatistics();
|
||||||
ZLMapBasedStatistics(const Dictionary &dictionary);
|
ZLMapBasedStatistics(const Dictionary &dictionary);
|
||||||
~ZLMapBasedStatistics();
|
~ZLMapBasedStatistics();
|
||||||
|
|
||||||
size_t getSize() const;
|
std::size_t getSize() const;
|
||||||
|
|
||||||
ZLMapBasedStatistics top(size_t amount) const;
|
ZLMapBasedStatistics top(std::size_t amount) const;
|
||||||
|
|
||||||
void scaleToShort();
|
void scaleToShort();
|
||||||
void retain(const ZLMapBasedStatistics &other);
|
void retain(const ZLMapBasedStatistics &other);
|
||||||
|
@ -85,7 +85,7 @@ protected:
|
||||||
|
|
||||||
private:
|
private:
|
||||||
struct LessFrequency {
|
struct LessFrequency {
|
||||||
bool operator() (const std::pair<ZLCharSequence, size_t> a, const std::pair<ZLCharSequence, size_t> b) {
|
bool operator() (const std::pair<ZLCharSequence, std::size_t> a, const std::pair<ZLCharSequence, std::size_t> b) {
|
||||||
return (a.second < b.second);
|
return (a.second < b.second);
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
@ -97,11 +97,11 @@ private:
|
||||||
class ZLArrayBasedStatistics : public ZLStatistics {
|
class ZLArrayBasedStatistics : public ZLStatistics {
|
||||||
public:
|
public:
|
||||||
ZLArrayBasedStatistics();
|
ZLArrayBasedStatistics();
|
||||||
ZLArrayBasedStatistics(size_t charSequenceSize, size_t size, size_t volume, unsigned long long squaresVolume);
|
ZLArrayBasedStatistics(std::size_t charSequenceSize, std::size_t size, std::size_t volume, unsigned long long squaresVolume);
|
||||||
~ZLArrayBasedStatistics();
|
~ZLArrayBasedStatistics();
|
||||||
|
|
||||||
ZLArrayBasedStatistics &operator = (const ZLArrayBasedStatistics &other);
|
ZLArrayBasedStatistics &operator = (const ZLArrayBasedStatistics &other);
|
||||||
void insert(const ZLCharSequence &charSequence, size_t frequency);
|
void insert(const ZLCharSequence &charSequence, std::size_t frequency);
|
||||||
|
|
||||||
bool empty() const;
|
bool empty() const;
|
||||||
|
|
||||||
|
@ -112,17 +112,17 @@ protected:
|
||||||
void calculateVolumes() const;
|
void calculateVolumes() const;
|
||||||
|
|
||||||
private:
|
private:
|
||||||
size_t myCapacity;
|
std::size_t myCapacity;
|
||||||
size_t myBack;
|
std::size_t myBack;
|
||||||
char* mySequences;
|
char* mySequences;
|
||||||
unsigned short* myFrequencies;
|
unsigned short* myFrequencies;
|
||||||
};
|
};
|
||||||
|
|
||||||
inline size_t ZLStatistics::getCharSequenceSize() const {
|
inline std::size_t ZLStatistics::getCharSequenceSize() const {
|
||||||
return myCharSequenceSize;
|
return myCharSequenceSize;
|
||||||
}
|
}
|
||||||
|
|
||||||
inline size_t ZLMapBasedStatistics::getSize() const {
|
inline std::size_t ZLMapBasedStatistics::getSize() const {
|
||||||
return myDictionary.size();
|
return myDictionary.size();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -28,7 +28,7 @@
|
||||||
#include "ZLStatistics.h"
|
#include "ZLStatistics.h"
|
||||||
#include "ZLStatisticsGenerator.h"
|
#include "ZLStatisticsGenerator.h"
|
||||||
|
|
||||||
size_t ZLStatisticsGenerator::ourBufferSize = 102400;
|
std::size_t ZLStatisticsGenerator::ourBufferSize = 102400;
|
||||||
|
|
||||||
ZLStatisticsGenerator::ZLStatisticsGenerator(const std::string &breakSymbols) {
|
ZLStatisticsGenerator::ZLStatisticsGenerator(const std::string &breakSymbols) {
|
||||||
myBreakSymbolsTable = new char[256];
|
myBreakSymbolsTable = new char[256];
|
||||||
|
@ -56,21 +56,21 @@ int ZLStatisticsGenerator::read(const std::string &inputFileName) {
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
void ZLStatisticsGenerator::generate(const std::string &inputFileName, size_t charSequenceSize, ZLMapBasedStatistics &statistics) {
|
void ZLStatisticsGenerator::generate(const std::string &inputFileName, std::size_t charSequenceSize, ZLMapBasedStatistics &statistics) {
|
||||||
if (read(inputFileName) == 1) {
|
if (read(inputFileName) == 1) {
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
if ((size_t)(myEnd - myStart) < (charSequenceSize-1)) {
|
if ((std::size_t)(myEnd - myStart) < (charSequenceSize-1)) {
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
generate(myStart, myEnd - myStart, charSequenceSize, statistics);
|
generate(myStart, myEnd - myStart, charSequenceSize, statistics);
|
||||||
}
|
}
|
||||||
|
|
||||||
void ZLStatisticsGenerator::generate(const char* buffer, size_t length, size_t charSequenceSize, ZLMapBasedStatistics &statistics) {
|
void ZLStatisticsGenerator::generate(const char* buffer, std::size_t length, std::size_t charSequenceSize, ZLMapBasedStatistics &statistics) {
|
||||||
const char *start = buffer;
|
const char *start = buffer;
|
||||||
const char *end = buffer + length;
|
const char *end = buffer + length;
|
||||||
std::map<ZLCharSequence, size_t> dictionary;
|
std::map<ZLCharSequence, std::size_t> dictionary;
|
||||||
size_t locker = charSequenceSize;
|
std::size_t locker = charSequenceSize;
|
||||||
for (const char *ptr = start; ptr < end;) {
|
for (const char *ptr = start; ptr < end;) {
|
||||||
if (myBreakSymbolsTable[(unsigned char)*(ptr)] == 1) {
|
if (myBreakSymbolsTable[(unsigned char)*(ptr)] == 1) {
|
||||||
locker = charSequenceSize;
|
locker = charSequenceSize;
|
||||||
|
|
|
@ -30,8 +30,8 @@ public:
|
||||||
ZLStatisticsGenerator(const std::string &breakSymbols);
|
ZLStatisticsGenerator(const std::string &breakSymbols);
|
||||||
~ZLStatisticsGenerator();
|
~ZLStatisticsGenerator();
|
||||||
|
|
||||||
void generate(const std::string &inputFileName, size_t charSequenceSizpe, ZLMapBasedStatistics &statistics);
|
void generate(const std::string &inputFileName, std::size_t charSequenceSizpe, ZLMapBasedStatistics &statistics);
|
||||||
void generate(const char* buffer, size_t length, size_t charSequenceSize, ZLMapBasedStatistics &statistics);
|
void generate(const char* buffer, std::size_t length, std::size_t charSequenceSize, ZLMapBasedStatistics &statistics);
|
||||||
|
|
||||||
private:
|
private:
|
||||||
int read(const std::string &inputFileName);
|
int read(const std::string &inputFileName);
|
||||||
|
@ -42,7 +42,7 @@ private:
|
||||||
char *myStart;
|
char *myStart;
|
||||||
char *myEnd;
|
char *myEnd;
|
||||||
|
|
||||||
static size_t ourBufferSize;
|
static std::size_t ourBufferSize;
|
||||||
};
|
};
|
||||||
|
|
||||||
#endif //__ZLSTATISTICSGENERATOR_H__
|
#endif //__ZLSTATISTICSGENERATOR_H__
|
||||||
|
|
|
@ -19,7 +19,7 @@
|
||||||
|
|
||||||
#include "ZLStatisticsItem.h"
|
#include "ZLStatisticsItem.h"
|
||||||
|
|
||||||
ZLMapBasedStatisticsItem::ZLMapBasedStatisticsItem(const std::map<ZLCharSequence, size_t>::const_iterator it, size_t index) : ZLStatisticsItem(index),
|
ZLMapBasedStatisticsItem::ZLMapBasedStatisticsItem(const std::map<ZLCharSequence, std::size_t>::const_iterator it, std::size_t index) : ZLStatisticsItem(index),
|
||||||
myIterator(it) {
|
myIterator(it) {
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -27,7 +27,7 @@ ZLCharSequence ZLMapBasedStatisticsItem::sequence() const {
|
||||||
return myIterator->first;
|
return myIterator->first;
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t ZLMapBasedStatisticsItem::frequency() const {
|
std::size_t ZLMapBasedStatisticsItem::frequency() const {
|
||||||
return myIterator->second;
|
return myIterator->second;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -36,7 +36,7 @@ void ZLMapBasedStatisticsItem::next() {
|
||||||
++myIterator;
|
++myIterator;
|
||||||
}
|
}
|
||||||
|
|
||||||
ZLArrayBasedStatisticsItem::ZLArrayBasedStatisticsItem(size_t sequenceLength, char* sequencePtr, unsigned short* frequencyPtr, size_t index) :
|
ZLArrayBasedStatisticsItem::ZLArrayBasedStatisticsItem(std::size_t sequenceLength, char* sequencePtr, unsigned short* frequencyPtr, std::size_t index) :
|
||||||
ZLStatisticsItem(index),
|
ZLStatisticsItem(index),
|
||||||
mySequencePtr(sequencePtr),
|
mySequencePtr(sequencePtr),
|
||||||
myFrequencyPtr(frequencyPtr),
|
myFrequencyPtr(frequencyPtr),
|
||||||
|
@ -47,8 +47,8 @@ ZLCharSequence ZLArrayBasedStatisticsItem::sequence() const {
|
||||||
return ZLCharSequence(mySequencePtr, mySequenceLength);
|
return ZLCharSequence(mySequencePtr, mySequenceLength);
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t ZLArrayBasedStatisticsItem::frequency() const {
|
std::size_t ZLArrayBasedStatisticsItem::frequency() const {
|
||||||
return (size_t) *myFrequencyPtr;
|
return (std::size_t) *myFrequencyPtr;
|
||||||
}
|
}
|
||||||
|
|
||||||
void ZLArrayBasedStatisticsItem::next() {
|
void ZLArrayBasedStatisticsItem::next() {
|
||||||
|
|
|
@ -28,53 +28,53 @@
|
||||||
struct ZLStatisticsItem {
|
struct ZLStatisticsItem {
|
||||||
|
|
||||||
public:
|
public:
|
||||||
ZLStatisticsItem(size_t index);
|
ZLStatisticsItem(std::size_t index);
|
||||||
virtual ~ZLStatisticsItem();
|
virtual ~ZLStatisticsItem();
|
||||||
|
|
||||||
virtual ZLCharSequence sequence() const = 0;
|
virtual ZLCharSequence sequence() const = 0;
|
||||||
virtual size_t frequency() const = 0;
|
virtual std::size_t frequency() const = 0;
|
||||||
virtual void next() = 0;
|
virtual void next() = 0;
|
||||||
|
|
||||||
bool operator == (const ZLStatisticsItem &otherItem) const;
|
bool operator == (const ZLStatisticsItem &otherItem) const;
|
||||||
bool operator != (const ZLStatisticsItem &otherItem) const;
|
bool operator != (const ZLStatisticsItem &otherItem) const;
|
||||||
|
|
||||||
size_t index() const;
|
std::size_t index() const;
|
||||||
|
|
||||||
protected:
|
protected:
|
||||||
size_t myIndex;
|
std::size_t myIndex;
|
||||||
};
|
};
|
||||||
|
|
||||||
struct ZLMapBasedStatisticsItem : public ZLStatisticsItem {
|
struct ZLMapBasedStatisticsItem : public ZLStatisticsItem {
|
||||||
ZLMapBasedStatisticsItem(const std::map<ZLCharSequence, size_t>::const_iterator it, size_t index);
|
ZLMapBasedStatisticsItem(const std::map<ZLCharSequence, std::size_t>::const_iterator it, std::size_t index);
|
||||||
|
|
||||||
ZLCharSequence sequence() const;
|
ZLCharSequence sequence() const;
|
||||||
size_t frequency() const;
|
std::size_t frequency() const;
|
||||||
void next();
|
void next();
|
||||||
|
|
||||||
private:
|
private:
|
||||||
std::map<ZLCharSequence, size_t>::const_iterator myIterator;
|
std::map<ZLCharSequence, std::size_t>::const_iterator myIterator;
|
||||||
};
|
};
|
||||||
|
|
||||||
struct ZLArrayBasedStatisticsItem : public ZLStatisticsItem {
|
struct ZLArrayBasedStatisticsItem : public ZLStatisticsItem {
|
||||||
ZLArrayBasedStatisticsItem(size_t sequenceLength, char* sequencePtr, unsigned short* frequencyPtr, size_t index);
|
ZLArrayBasedStatisticsItem(std::size_t sequenceLength, char* sequencePtr, unsigned short* frequencyPtr, std::size_t index);
|
||||||
|
|
||||||
ZLCharSequence sequence() const;
|
ZLCharSequence sequence() const;
|
||||||
size_t frequency() const;
|
std::size_t frequency() const;
|
||||||
void next();
|
void next();
|
||||||
|
|
||||||
private:
|
private:
|
||||||
char const *mySequencePtr;
|
char const *mySequencePtr;
|
||||||
unsigned short const *myFrequencyPtr;
|
unsigned short const *myFrequencyPtr;
|
||||||
const size_t mySequenceLength;
|
const std::size_t mySequenceLength;
|
||||||
};
|
};
|
||||||
|
|
||||||
inline ZLStatisticsItem::ZLStatisticsItem(size_t index) : myIndex(index) {
|
inline ZLStatisticsItem::ZLStatisticsItem(std::size_t index) : myIndex(index) {
|
||||||
}
|
}
|
||||||
|
|
||||||
inline ZLStatisticsItem::~ZLStatisticsItem() {
|
inline ZLStatisticsItem::~ZLStatisticsItem() {
|
||||||
}
|
}
|
||||||
|
|
||||||
inline size_t ZLStatisticsItem::index() const {
|
inline std::size_t ZLStatisticsItem::index() const {
|
||||||
return myIndex;
|
return myIndex;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -33,7 +33,7 @@ const std::string ZLStatisticsXMLReader::STATISTICS_TAG = "statistics";
|
||||||
|
|
||||||
void ZLStatisticsXMLReader::startElementHandler(const char *tag, const char **attributes) {
|
void ZLStatisticsXMLReader::startElementHandler(const char *tag, const char **attributes) {
|
||||||
if (STATISTICS_TAG == tag) {
|
if (STATISTICS_TAG == tag) {
|
||||||
size_t volume = atoi(attributeValue(attributes, "volume"));
|
std::size_t volume = atoi(attributeValue(attributes, "volume"));
|
||||||
unsigned long long squaresVolume = atoll(attributeValue(attributes, "squaresVolume"));
|
unsigned long long squaresVolume = atoll(attributeValue(attributes, "squaresVolume"));
|
||||||
//std::cerr << "XMLReader: frequencies sum & ^2: " << volume << ":" << squaresVolume << "\n";
|
//std::cerr << "XMLReader: frequencies sum & ^2: " << volume << ":" << squaresVolume << "\n";
|
||||||
myStatisticsPtr = new ZLArrayBasedStatistics( atoi(attributeValue(attributes, "charSequenceSize")), atoi(attributeValue(attributes, "size")), volume, squaresVolume);
|
myStatisticsPtr = new ZLArrayBasedStatistics( atoi(attributeValue(attributes, "charSequenceSize")), atoi(attributeValue(attributes, "size")), volume, squaresVolume);
|
||||||
|
|
|
@ -60,7 +60,7 @@ void ZLibrary::parseArguments(int &argc, char **&argv) {
|
||||||
}
|
}
|
||||||
} else*/ if (LOGGER_OPTION == argument) {
|
} else*/ if (LOGGER_OPTION == argument) {
|
||||||
std::string loggerClasses = argv[2];
|
std::string loggerClasses = argv[2];
|
||||||
while (size_t index = loggerClasses.find(':') != std::string::npos) {
|
while (std::size_t index = loggerClasses.find(':') != std::string::npos) {
|
||||||
ZLLogger::Instance().registerClass(loggerClasses.substr(0, index));
|
ZLLogger::Instance().registerClass(loggerClasses.substr(0, index));
|
||||||
loggerClasses.erase(0, index + 1);
|
loggerClasses.erase(0, index + 1);
|
||||||
}
|
}
|
||||||
|
|
|
@ -41,7 +41,7 @@ void ZLLogger::registerClass(const std::string &className) {
|
||||||
|
|
||||||
void ZLLogger::print(const std::string &className, const std::string &message) const {
|
void ZLLogger::print(const std::string &className, const std::string &message) const {
|
||||||
std::string m = message;
|
std::string m = message;
|
||||||
for (size_t index = m.find('%'); index != std::string::npos; index = m.find('%', index + 2)) {
|
for (std::size_t index = m.find('%'); index != std::string::npos; index = m.find('%', index + 2)) {
|
||||||
m.replace(index, 1, "%%");
|
m.replace(index, 1, "%%");
|
||||||
}
|
}
|
||||||
if (className == DEFAULT_CLASS) {
|
if (className == DEFAULT_CLASS) {
|
||||||
|
|
|
@ -38,7 +38,7 @@ bool ZLUnixFileInputStream::open() {
|
||||||
return myFile != 0;
|
return myFile != 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t ZLUnixFileInputStream::read(char *buffer, size_t maxSize) {
|
std::size_t ZLUnixFileInputStream::read(char *buffer, std::size_t maxSize) {
|
||||||
if (buffer != 0) {
|
if (buffer != 0) {
|
||||||
if (myNeedRepositionToStart) {
|
if (myNeedRepositionToStart) {
|
||||||
fseek(myFile, 0, SEEK_SET);
|
fseek(myFile, 0, SEEK_SET);
|
||||||
|
@ -65,7 +65,7 @@ void ZLUnixFileInputStream::close() {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t ZLUnixFileInputStream::sizeOfOpened() {
|
std::size_t ZLUnixFileInputStream::sizeOfOpened() {
|
||||||
if (myFile == 0) {
|
if (myFile == 0) {
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
@ -84,6 +84,6 @@ void ZLUnixFileInputStream::seek(int offset, bool absoluteOffset) {
|
||||||
fseek(myFile, offset, absoluteOffset ? SEEK_SET : SEEK_CUR);
|
fseek(myFile, offset, absoluteOffset ? SEEK_SET : SEEK_CUR);
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t ZLUnixFileInputStream::offset() const {
|
std::size_t ZLUnixFileInputStream::offset() const {
|
||||||
return myNeedRepositionToStart ? 0 : ftell(myFile);
|
return myNeedRepositionToStart ? 0 : ftell(myFile);
|
||||||
}
|
}
|
||||||
|
|
|
@ -30,12 +30,12 @@ public:
|
||||||
ZLUnixFileInputStream(const std::string &name);
|
ZLUnixFileInputStream(const std::string &name);
|
||||||
~ZLUnixFileInputStream();
|
~ZLUnixFileInputStream();
|
||||||
bool open();
|
bool open();
|
||||||
size_t read(char *buffer, size_t maxSize);
|
std::size_t read(char *buffer, std::size_t maxSize);
|
||||||
void close();
|
void close();
|
||||||
|
|
||||||
void seek(int offset, bool absoluteOffset);
|
void seek(int offset, bool absoluteOffset);
|
||||||
size_t offset() const;
|
std::size_t offset() const;
|
||||||
size_t sizeOfOpened();
|
std::size_t sizeOfOpened();
|
||||||
|
|
||||||
private:
|
private:
|
||||||
std::string myName;
|
std::string myName;
|
||||||
|
|
|
@ -46,14 +46,14 @@ bool ZLUnixFileOutputStream::open() {
|
||||||
return myFile != 0;
|
return myFile != 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
void ZLUnixFileOutputStream::write(const char *data, size_t len) {
|
void ZLUnixFileOutputStream::write(const char *data, std::size_t len) {
|
||||||
if (::fwrite(data, 1, len, myFile) != len) {
|
if (::fwrite(data, 1, len, myFile) != len) {
|
||||||
myHasErrors = true;
|
myHasErrors = true;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void ZLUnixFileOutputStream::write(const std::string &str) {
|
void ZLUnixFileOutputStream::write(const std::string &str) {
|
||||||
if (::fwrite(str.data(), 1, str.length(), myFile) != (size_t)str.length()) {
|
if (::fwrite(str.data(), 1, str.length(), myFile) != (std::size_t)str.length()) {
|
||||||
myHasErrors = true;
|
myHasErrors = true;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -30,7 +30,7 @@ public:
|
||||||
ZLUnixFileOutputStream(const std::string &name);
|
ZLUnixFileOutputStream(const std::string &name);
|
||||||
~ZLUnixFileOutputStream();
|
~ZLUnixFileOutputStream();
|
||||||
bool open();
|
bool open();
|
||||||
void write(const char *data, size_t len);
|
void write(const char *data, std::size_t len);
|
||||||
void write(const std::string &str);
|
void write(const std::string &str);
|
||||||
void close();
|
void close();
|
||||||
|
|
||||||
|
|
|
@ -64,7 +64,7 @@ void ZLStringUtil::appendNumber(std::string &str, unsigned int n) {
|
||||||
}
|
}
|
||||||
|
|
||||||
void ZLStringUtil::append(std::string &str, const std::vector<std::string> &text) {
|
void ZLStringUtil::append(std::string &str, const std::vector<std::string> &text) {
|
||||||
size_t len = str.length();
|
std::size_t len = str.length();
|
||||||
for (std::vector<std::string>::const_iterator it = text.begin(); it != text.end(); ++it) {
|
for (std::vector<std::string>::const_iterator it = text.begin(); it != text.end(); ++it) {
|
||||||
len += it->length();
|
len += it->length();
|
||||||
}
|
}
|
||||||
|
@ -75,15 +75,15 @@ void ZLStringUtil::append(std::string &str, const std::vector<std::string> &text
|
||||||
}
|
}
|
||||||
|
|
||||||
void ZLStringUtil::stripWhiteSpaces(std::string &str) {
|
void ZLStringUtil::stripWhiteSpaces(std::string &str) {
|
||||||
size_t counter = 0;
|
std::size_t counter = 0;
|
||||||
size_t length = str.length();
|
std::size_t length = str.length();
|
||||||
while ((counter < length) && isspace((unsigned char)str[counter])) {
|
while ((counter < length) && isspace((unsigned char)str[counter])) {
|
||||||
counter++;
|
counter++;
|
||||||
}
|
}
|
||||||
str.erase(0, counter);
|
str.erase(0, counter);
|
||||||
length -= counter;
|
length -= counter;
|
||||||
|
|
||||||
size_t r_counter = length;
|
std::size_t r_counter = length;
|
||||||
while ((r_counter > 0) && isspace((unsigned char)str[r_counter - 1])) {
|
while ((r_counter > 0) && isspace((unsigned char)str[r_counter - 1])) {
|
||||||
r_counter--;
|
r_counter--;
|
||||||
}
|
}
|
||||||
|
@ -92,8 +92,8 @@ void ZLStringUtil::stripWhiteSpaces(std::string &str) {
|
||||||
|
|
||||||
std::vector<std::string> ZLStringUtil::split(const std::string &str, const std::string &delimiter) {
|
std::vector<std::string> ZLStringUtil::split(const std::string &str, const std::string &delimiter) {
|
||||||
std::vector<std::string> result;
|
std::vector<std::string> result;
|
||||||
size_t start = 0;
|
std::size_t start = 0;
|
||||||
size_t index = str.find(delimiter);
|
std::size_t index = str.find(delimiter);
|
||||||
while (index != std::string::npos) {
|
while (index != std::string::npos) {
|
||||||
result.push_back(str.substr(start, index - start));
|
result.push_back(str.substr(start, index - start));
|
||||||
start = index + delimiter.length();
|
start = index + delimiter.length();
|
||||||
|
@ -135,7 +135,7 @@ int ZLStringUtil::stringToInteger(const std::string &str, int defaultValue) {
|
||||||
return defaultValue;
|
return defaultValue;
|
||||||
}
|
}
|
||||||
|
|
||||||
for (size_t i = 1; i < str.length(); ++i) {
|
for (std::size_t i = 1; i < str.length(); ++i) {
|
||||||
if (!isdigit(str[i])) {
|
if (!isdigit(str[i])) {
|
||||||
return defaultValue;
|
return defaultValue;
|
||||||
}
|
}
|
||||||
|
|
|
@ -32,7 +32,7 @@ public:
|
||||||
virtual ~Handler();
|
virtual ~Handler();
|
||||||
virtual void initialize(const char *encoding) = 0;
|
virtual void initialize(const char *encoding) = 0;
|
||||||
virtual void shutdown() = 0;
|
virtual void shutdown() = 0;
|
||||||
virtual bool handleBuffer(const char *data, size_t len) = 0;
|
virtual bool handleBuffer(const char *data, std::size_t len) = 0;
|
||||||
};
|
};
|
||||||
|
|
||||||
public:
|
public:
|
||||||
|
@ -40,7 +40,7 @@ public:
|
||||||
virtual ~ZLAsynchronousInputStream();
|
virtual ~ZLAsynchronousInputStream();
|
||||||
|
|
||||||
void setEof();
|
void setEof();
|
||||||
void setBuffer(const char *data, size_t len);
|
void setBuffer(const char *data, std::size_t len);
|
||||||
bool eof() const;
|
bool eof() const;
|
||||||
bool initialized() const;
|
bool initialized() const;
|
||||||
|
|
||||||
|
@ -51,7 +51,7 @@ protected:
|
||||||
|
|
||||||
protected:
|
protected:
|
||||||
const char *myData;
|
const char *myData;
|
||||||
size_t myDataLen;
|
std::size_t myDataLen;
|
||||||
|
|
||||||
private:
|
private:
|
||||||
std::string myEncoding;
|
std::string myEncoding;
|
||||||
|
@ -65,7 +65,7 @@ private:
|
||||||
};
|
};
|
||||||
|
|
||||||
inline void ZLAsynchronousInputStream::setEof() { myEof = true; myData = 0; myDataLen = 0; }
|
inline void ZLAsynchronousInputStream::setEof() { myEof = true; myData = 0; myDataLen = 0; }
|
||||||
inline void ZLAsynchronousInputStream::setBuffer(const char *data, size_t len) { myData = data; myDataLen = len; }
|
inline void ZLAsynchronousInputStream::setBuffer(const char *data, std::size_t len) { myData = data; myDataLen = len; }
|
||||||
inline bool ZLAsynchronousInputStream::eof() const { return myEof; }
|
inline bool ZLAsynchronousInputStream::eof() const { return myEof; }
|
||||||
inline bool ZLAsynchronousInputStream::initialized() const { return myInitialized; }
|
inline bool ZLAsynchronousInputStream::initialized() const { return myInitialized; }
|
||||||
|
|
||||||
|
|
|
@ -39,7 +39,7 @@ public:
|
||||||
|
|
||||||
void initialize(const char *encoding);
|
void initialize(const char *encoding);
|
||||||
void shutdown();
|
void shutdown();
|
||||||
bool handleBuffer(const char *data, size_t len);
|
bool handleBuffer(const char *data, std::size_t len);
|
||||||
|
|
||||||
private:
|
private:
|
||||||
ZLXMLReader &myReader;
|
ZLXMLReader &myReader;
|
||||||
|
@ -56,11 +56,11 @@ void ZLXMLReaderHandler::shutdown() {
|
||||||
myReader.shutdown();
|
myReader.shutdown();
|
||||||
}
|
}
|
||||||
|
|
||||||
bool ZLXMLReaderHandler::handleBuffer(const char *data, size_t len) {
|
bool ZLXMLReaderHandler::handleBuffer(const char *data, std::size_t len) {
|
||||||
return myReader.readFromBuffer(data, len);
|
return myReader.readFromBuffer(data, len);
|
||||||
}
|
}
|
||||||
|
|
||||||
static const size_t BUFFER_SIZE = 2048;
|
static const std::size_t BUFFER_SIZE = 2048;
|
||||||
|
|
||||||
void ZLXMLReader::startElementHandler(const char*, const char**) {
|
void ZLXMLReader::startElementHandler(const char*, const char**) {
|
||||||
}
|
}
|
||||||
|
@ -68,7 +68,7 @@ void ZLXMLReader::startElementHandler(const char*, const char**) {
|
||||||
void ZLXMLReader::endElementHandler(const char*) {
|
void ZLXMLReader::endElementHandler(const char*) {
|
||||||
}
|
}
|
||||||
|
|
||||||
void ZLXMLReader::characterDataHandler(const char*, size_t) {
|
void ZLXMLReader::characterDataHandler(const char*, std::size_t) {
|
||||||
}
|
}
|
||||||
|
|
||||||
const ZLXMLReader::nsMap &ZLXMLReader::namespaces() const {
|
const ZLXMLReader::nsMap &ZLXMLReader::namespaces() const {
|
||||||
|
@ -108,7 +108,7 @@ bool ZLXMLReader::readDocument(shared_ptr<ZLInputStream> stream) {
|
||||||
}
|
}
|
||||||
initialize(useWindows1252 ? "windows-1252" : 0);
|
initialize(useWindows1252 ? "windows-1252" : 0);
|
||||||
|
|
||||||
size_t length;
|
std::size_t length;
|
||||||
do {
|
do {
|
||||||
length = stream->read(myParserBuffer, BUFFER_SIZE);
|
length = stream->read(myParserBuffer, BUFFER_SIZE);
|
||||||
if (!readFromBuffer(myParserBuffer, length)) {
|
if (!readFromBuffer(myParserBuffer, length)) {
|
||||||
|
@ -133,7 +133,7 @@ void ZLXMLReader::shutdown() {
|
||||||
myNamespaces.clear();
|
myNamespaces.clear();
|
||||||
}
|
}
|
||||||
|
|
||||||
bool ZLXMLReader::readFromBuffer(const char *data, size_t len) {
|
bool ZLXMLReader::readFromBuffer(const char *data, std::size_t len) {
|
||||||
return myInternalReader->parseBuffer(data, len);
|
return myInternalReader->parseBuffer(data, len);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -179,7 +179,7 @@ ZLXMLReader::NamespaceAttributeNamePredicate::NamespaceAttributeNamePredicate(co
|
||||||
|
|
||||||
bool ZLXMLReader::NamespaceAttributeNamePredicate::accepts(const ZLXMLReader &reader, const char *name) const {
|
bool ZLXMLReader::NamespaceAttributeNamePredicate::accepts(const ZLXMLReader &reader, const char *name) const {
|
||||||
const std::string full(name);
|
const std::string full(name);
|
||||||
const size_t index = full.find(':');
|
const std::size_t index = full.find(':');
|
||||||
const std::string namespaceId =
|
const std::string namespaceId =
|
||||||
index == std::string::npos ? std::string() : full.substr(0, index);
|
index == std::string::npos ? std::string() : full.substr(0, index);
|
||||||
|
|
||||||
|
@ -239,6 +239,6 @@ void ZLXMLReader::setErrorMessage(const std::string &message) {
|
||||||
interrupt();
|
interrupt();
|
||||||
}
|
}
|
||||||
|
|
||||||
size_t ZLXMLReader::getCurrentPosition() const {
|
std::size_t ZLXMLReader::getCurrentPosition() const {
|
||||||
return myInternalReader != 0 ? myInternalReader->getCurrentPosition() : (size_t)-1;
|
return myInternalReader != 0 ? myInternalReader->getCurrentPosition() : (std::size_t)-1;
|
||||||
}
|
}
|
||||||
|
|
|
@ -83,19 +83,19 @@ public:
|
||||||
private:
|
private:
|
||||||
void initialize(const char *encoding = 0);
|
void initialize(const char *encoding = 0);
|
||||||
void shutdown();
|
void shutdown();
|
||||||
bool readFromBuffer(const char *data, size_t len);
|
bool readFromBuffer(const char *data, std::size_t len);
|
||||||
|
|
||||||
protected:
|
protected:
|
||||||
virtual void startElementHandler(const char *tag, const char **attributes);
|
virtual void startElementHandler(const char *tag, const char **attributes);
|
||||||
virtual void endElementHandler(const char *tag);
|
virtual void endElementHandler(const char *tag);
|
||||||
virtual void characterDataHandler(const char *text, size_t len);
|
virtual void characterDataHandler(const char *text, std::size_t len);
|
||||||
virtual bool processNamespaces() const;
|
virtual bool processNamespaces() const;
|
||||||
virtual const std::vector<std::string> &externalDTDs() const;
|
virtual const std::vector<std::string> &externalDTDs() const;
|
||||||
virtual void collectExternalEntities(std::map<std::string,std::string> &entityMap);
|
virtual void collectExternalEntities(std::map<std::string,std::string> &entityMap);
|
||||||
|
|
||||||
bool testTag(const std::string &ns, const std::string &name, const std::string &tag) const;
|
bool testTag(const std::string &ns, const std::string &name, const std::string &tag) const;
|
||||||
bool isInterrupted() const;
|
bool isInterrupted() const;
|
||||||
size_t getCurrentPosition() const;
|
std::size_t getCurrentPosition() const;
|
||||||
|
|
||||||
protected:
|
protected:
|
||||||
void interrupt();
|
void interrupt();
|
||||||
|
|
Some files were not shown because too many files have changed in this diff Show more
Loading…
Add table
Add a link
Reference in a new issue