void WP3Parser::parseSubDocument(librevenge::RVNGTextInterface *textInterface)
{
std::list<WPXPageSpan> pageList;
WPXTableList tableList;
std::vector<WP3SubDocument *> subDocuments;
librevenge::RVNGInputStream *input = getInput();
try
{
WP3StylesListener stylesListener(pageList, tableList, subDocuments);
stylesListener.startSubDocument();
parseDocument(input, 0, &stylesListener);
stylesListener.endSubDocument();
input->seek(0, librevenge::RVNG_SEEK_SET);
WP3ContentListener listener(pageList, subDocuments, textInterface);
listener.startSubDocument();
parseDocument(input, 0, &listener);
listener.endSubDocument();
for (std::vector<WP3SubDocument *>::iterator iterSubDoc = subDocuments.begin(); iterSubDoc != subDocuments.end(); ++iterSubDoc)
if (*iterSubDoc)
delete *iterSubDoc;
}
catch (FileException)
{
WPD_DEBUG_MSG(("WordPerfect: File Exception. Parse terminated prematurely."));
for (std::vector<WP3SubDocument *>::iterator iterSubDoc = subDocuments.begin(); iterSubDoc != subDocuments.end(); ++iterSubDoc)
if (*iterSubDoc)
delete *iterSubDoc;
throw FileException();
}
}
/*!
Loads non-context sensitive objects.
*/
HsMenuViewBuilder::HsMenuViewBuilder():
ALL_APPS_ACTION_NAME("allAppsAction"),
ALL_COLLECTIONS_ACTION_NAME("allCollectionsAction"),
SEARCH_ACTION_NAME("searchAction"),
OVI_STORE_ACTION_NAME("oviStoreAction"),
OPERATOR_ACTION_NAME("operatorAction"),
mToolBar(new HbToolBar),
mToolBarExtension(new HbToolBarExtension),
mStateContext(HsAllAppsContext),
mOperationalContext(HsItemViewContext)
{
mCommonObjectsLoader = parseDocument(COMMON_OBJECTS_DOCUMENT_BASE_NAME);
mToolBar->addAction(allAppsAction());
mToolBar->addAction(allCollectionsAction());
mToolBar->addAction(searchAction());
mToolBarExtensionAction = mToolBar->addExtension(mToolBarExtension);
mToolBarExtensionAction->setIcon(HbIcon("qtg_mono_store"));
mToolBarExtensionAction->setVisible(false);
mToolBarActionGroup = new QActionGroup(allAppsAction());
allAppsAction()->setActionGroup(mToolBarActionGroup);
allCollectionsAction()->setActionGroup(mToolBarActionGroup);
}
string TgTypeParser::parseMessage(const Message::Ptr& object) const {
if (!object) {
return "";
}
string result;
result += '{';
appendToJson(result, "message_id", object->messageId);
appendToJson(result, "from", parseUser(object->from));
appendToJson(result, "date", object->date);
appendToJson(result, "chat", parseChat(object->chat));
appendToJson(result, "forward_from", parseUser(object->forwardFrom));
appendToJson(result, "forward_date", object->forwardDate);
appendToJson(result, "reply_to_message", parseMessage(object->replyToMessage));
appendToJson(result, "text", object->text);
appendToJson(result, "audio", parseAudio(object->audio));
appendToJson(result, "document", parseDocument(object->document));
appendToJson(result, "photo", parseArray(&TgTypeParser::parsePhotoSize, object->photo));
appendToJson(result, "sticker", parseSticker(object->sticker));
appendToJson(result, "video", parseVideo(object->video));
appendToJson(result, "contact", parseContact(object->contact));
appendToJson(result, "location", parseLocation(object->location));
appendToJson(result, "new_chat_participant", parseUser(object->newChatParticipant));
appendToJson(result, "left_chat_participant", parseUser(object->leftChatParticipant));
appendToJson(result, "new_chat_title", object->newChatTitle);
appendToJson(result, "new_chat_photo", parseArray(&TgTypeParser::parsePhotoSize, object->newChatPhoto));
appendToJson(result, "delete_chat_photo", object->deleteChatPhoto);
appendToJson(result, "group_chat_created", object->groupChatCreated);
appendToJson(result, "caption", object->caption);
result.erase(result.length() - 1);
result += '}';
return result;
}
bool PmlReader::readDocument(ZLInputStream& stream) {
myStreamBuffer = new char[pmlStreamBufferSize];
myIsInterrupted = false;
myState.Italic = false;
myState.Bold = false;
myState.Underlined = false;
myState.SmallCaps = false;
myState.Subscript = false;
myState.Superscript = false;
myState.Alignment = ALIGN_UNDEFINED;
myState.FontSize = NORMAL;
myState.Indent = 0;
myState.IndentBlockOn = false;
myState.BoldBlockOn = false;
myState.FootnoteLinkOn = false;
myState.InternalLinkOn = false;
myState.InvisibleText = false;
bool code = parseDocument(stream);
delete[] myStreamBuffer;
return code;
}
BsonTreeModel::BsonTreeModel(const std::vector<MongoDocumentPtr> &documents, QObject *parent) :
BaseClass(parent),
_root(new BsonTreeItem(this))
{
for (int i = 0; i < documents.size(); ++i) {
MongoDocumentPtr doc = documents[i];
BsonTreeItem *child = new BsonTreeItem(doc->bsonObj(), _root);
parseDocument(child, doc->bsonObj(), doc->bsonObj().isArray());
QString idValue;
BsonTreeItem *idItem = child->childByKey("_id");
if (idItem) {
idValue = idItem->value();
}
child->setKey(QString("(%1) %2").arg(i + 1).arg(idValue));
int count = BsonUtils::elementsCount(doc->bsonObj());
if (doc->bsonObj().isArray()) {
child->setValue(arrayValue(count));
child->setType(mongo::Array);
} else {
child->setValue(objectValue(count));
child->setType(mongo::Object);
}
_root->addChild(child);
}
}
bool RtfReader::readDocument(const std::string &fileName) {
myFileName = fileName;
myStream = ZLFile(fileName).inputStream();
if (!myStream || !myStream->open()) {
return false;
}
fillKeywordMap();
myStreamBuffer = new char[rtfStreamBufferSize];
myIsInterrupted = false;
mySpecialMode = false;
myState.Alignment = ALIGN_UNDEFINED;
myState.Italic = false;
myState.Bold = false;
myState.Underlined = false;
myState.Destination = RtfReader::DESTINATION_NONE;
myState.ReadDataAsHex = false;
bool code = parseDocument();
while (!myStateStack.empty()) {
myStateStack.pop();
}
delete[] myStreamBuffer;
myStream->close();
return code;
}
/*!
\fn cs8ModbusConfigFile::restoreConfig(QSettings settings)
*/
bool cs8ModbusConfigFile::restoreConfig(QSettings & settings)
{
QString xml=settings.value("modbus/xml", QString()).toString();
QDomDocument doc;
doc.setContent(xml);
parseDocument(doc);
}
/**
* CLiteHTMLReader::Read
* This method is similar to the Read(LPCTSTR) method,
* except that, it accepts a file HANDLE instead of
* an in-memory string buffer containing HTML text.
*
* @param hFile - file handle
*
* @return number of TCHARs successfully parsed
* @since 1.0
* @author Gurmeet S. Kochar
*/
UINT CLiteHTMLReader::ReadFile(HANDLE hFile)
{
ASSERT(hFile != INVALID_HANDLE_VALUE);
ASSERT(::GetFileType(hFile) == FILE_TYPE_DISK);
HANDLE hFileMap;
LPCTSTR lpsz;
UINT nRetVal;
// determine file size
m_dwBufLen = ::GetFileSize(hFile, NULL);
if (m_dwBufLen == INVALID_FILE_SIZE)
{
TRACE1("(Error) CLiteHTMLReader::Read:"
" GetFileSize() failed;"
" GetLastError() returns 0x%08x.\n", ::GetLastError());
goto LError;
}
// calculate length, in TCHARs, of the buffer
m_dwBufLen /= sizeof(TCHAR);
if (!m_dwBufLen)
return (0U);
// create a file-mapping object for the file
hFileMap = ::CreateFileMapping(hFile, NULL, PAGE_READONLY, 0L, 0L, NULL);
if (hFileMap == NULL)
{
TRACE1("(Error) CLiteHTMLReader::Read:"
" CreateFileMapping() failed;"
" GetLastError() returns 0x%08x.\n", ::GetLastError());
goto LError;
}
// map the entire file into the address-space of the application
lpsz = (LPCTSTR)::MapViewOfFile(hFileMap, FILE_MAP_READ, 0L, 0L, 0L);
if (lpsz == NULL)
{
TRACE1("(Error) CLiteHTMLReader::Read:"
" MapViewOfFile() failed;"
" GetLastError() returns 0x%08x.\n", ::GetLastError());
goto LError;
}
m_lpszBuffer = lpsz;
nRetVal = parseDocument();
goto LCleanExit;
LError:
nRetVal = 0U;
m_dwBufLen = 0L;
LCleanExit:
if (lpsz != NULL)
VERIFY(::UnmapViewOfFile(lpsz));
if (hFileMap)
VERIFY(::CloseHandle(hFileMap));
return (nRetVal);
}
TEST_F(ParserIdentifierTests, identifier)
{
ASSERT_FALSE( parseDocument(
"identifier") );
ASSERT_EQ(1U, mpParser->messages().size());
EXPECT_TRUE(checkErrorMessage(0, 1, 11, compil::Message::p_expectStatementName));
}
TEST_F(ParserIdentifierTests, identifierNameOpen)
{
ASSERT_FALSE( parseDocument(
"identifier name {") );
ASSERT_EQ(1U, mpParser->messages().size());
EXPECT_TRUE(checkErrorMessage(0, 1, 18, compil::Message::p_unexpectEOFInStatementBody));
}
TEST_F(ParserFactoryTests, factoryName)
{
ASSERT_FALSE( parseDocument(
"hierarchy factory name") );
ASSERT_EQ(2U, mpParser->messages().size());
EXPECT_TRUE(checkErrorMessage(0, 1, 19, compil::Message::p_expectType));
}
TEST_F(ParserFactoryTests, hierarchyFactoryTypeNameCommentOpenFilter)
{
ASSERT_FALSE( parseDocument(
"hierarchy factory<integer> name { filter") );
ASSERT_EQ(1U, mpParser->messages().size());
EXPECT_TRUE(checkErrorMessage(0, 1, 35, compil::Message::p_filterInNonObjectFactory));
}
TEST_F(ParserFactoryTests, factoryTypeNameOpen)
{
ASSERT_FALSE( parseDocument(
"hierarchy factory<integer> name {") );
ASSERT_EQ(1U, mpParser->messages().size());
EXPECT_TRUE(checkErrorMessage(0, 1, 34, compil::Message::p_unexpectEOFInStatementBody));
}
TEST_F(ParserFactoryTests, factoryTypeNameCommentOpenFilterWithNoStructureType)
{
ASSERT_FALSE( parseDocument(
"object factory<integer> name { filter") );
ASSERT_EQ(1U, mpParser->messages().size());
EXPECT_TRUE(checkErrorMessage(0, 1, 32, compil::Message::p_filterInFactoryForNonStructure));
}
TEST_F(ParserFactoryTests, factoryTypeNameCommentOpen)
{
ASSERT_FALSE( parseDocument(
"hierarchy factory<integer> name /* */ {") );
ASSERT_EQ(2U, mpParser->messages().size());
EXPECT_TRUE(checkWarningMessage(0, 1, 33, compil::Message::p_misplacedComment));
EXPECT_TRUE(checkErrorMessage(1, 1, 40, compil::Message::p_unexpectEOFInStatementBody));
}
TEST_F(ParserIdentifierTests, identifierNameCommentOpen)
{
ASSERT_FALSE( parseDocument(
"identifier name /* */ {") );
ASSERT_EQ(2U, mpParser->messages().size());
EXPECT_TRUE(checkWarningMessage(0, 1, 17, compil::Message::p_misplacedComment));
EXPECT_TRUE(checkErrorMessage(1, 1, 24, compil::Message::p_unexpectEOFInStatementBody));
}
TEST_F(ParserFactoryTests, factoryCommentBaseTypeOpenType)
{
ASSERT_FALSE( parseDocument(
"hierarchy factory < /* */ integer") );
ASSERT_EQ(2U, mpParser->messages().size());
EXPECT_TRUE(checkWarningMessage(0, 1, 21, compil::Message::p_misplacedComment));
EXPECT_TRUE(checkErrorMessage(1, 1, 34, compil::Message::p_expectClosingAngleBracket));
}
TEST_F(ParserFactoryTests, factoryCommentBaseTypeOpen)
{
ASSERT_FALSE( parseDocument(
"hierarchy factory /* */ <") );
ASSERT_EQ(2U, mpParser->messages().size());
EXPECT_TRUE(checkWarningMessage(0, 1, 19, compil::Message::p_misplacedComment));
EXPECT_TRUE(checkErrorMessage(1, 1, 26, compil::Message::p_expectType));
}
TEST_F(ParserFactoryTests, factoryTypeNameCommentOpenFilterFieldWithMethodSemicolon)
{
ASSERT_FALSE( parseDocument(
"structure sname { integer i; }\n"
"object factory<sname> name { filter i with blah;") );
ASSERT_EQ(1U, mpParser->messages().size());
EXPECT_TRUE(checkErrorMessage(0, 2, 49, compil::Message::p_unexpectEOFInStatementBody));
}
TEST_F(ParserFactoryTests, factoryTypeCommentName)
{
ASSERT_FALSE( parseDocument(
"hierarchy factory<integer> /* */ name") );
ASSERT_EQ(2U, mpParser->messages().size());
EXPECT_TRUE(checkWarningMessage(0, 1, 28, compil::Message::p_misplacedComment));
EXPECT_TRUE(checkErrorMessage(1, 1, 38, compil::Message::p_expectStatementBody));
}
TEST_F(ParserIdentifierTests, identifierCommentBaseTypeOpenType)
{
ASSERT_FALSE( parseDocument(
"identifier < /* */ integer") );
ASSERT_EQ(2U, mpParser->messages().size());
EXPECT_TRUE(checkWarningMessage(0, 1, 14, compil::Message::p_misplacedComment));
EXPECT_TRUE(checkErrorMessage(1, 1, 27, compil::Message::p_expectClosingAngleBracket));
}
TEST_F(ParserIdentifierTests, strongIdentifierNameCommentOpenClose)
{
ASSERT_TRUE( parseDocument(
"strong identifier name {}") );
EXPECT_EQ(1U, mDocument->objects().size());
checkIdentifier(0, 1, 1, "name");
checkIdentifierCast(0, compil::CastableType::ECast::strong());
}
TEST_F(ParserIdentifierTests, identifierNameWrongBaseOpenClose)
{
ASSERT_FALSE( parseDocument(
"identifier<real32> name {}") );
ASSERT_EQ(1U, mpParser->messages().size());
EXPECT_TRUE(checkErrorMessage(0, 1, 1, compil::Message::v_unacceptableParameterType,
compil::Message::Options("small, short, integer, long, byte, word, dword or qword")));
}
TEST_F(ParserIdentifierTests, identifierNameMissingBaseOpenClose)
{
ASSERT_FALSE( parseDocument(
"identifier<blah> name {}") );
ASSERT_EQ(1U, mpParser->messages().size());
EXPECT_TRUE(checkErrorMessage(0, 1, 12, compil::Message::p_unknownClassifierType,
compil::Message::Type("blah")));
}
TEST_F(ParserIdentifierTests, identifierComment)
{
ASSERT_FALSE( parseDocument(
"identifier //") );
ASSERT_EQ(2U, mpParser->messages().size());
EXPECT_TRUE(checkWarningMessage(0, 1, 12, compil::Message::p_misplacedComment));
EXPECT_TRUE(checkErrorMessage(1, 1, 14, compil::Message::p_expectStatementName));
}
TEST_F(ParserIdentifierTests, identifierCommentBaseTypeOpen)
{
ASSERT_FALSE( parseDocument(
"identifier /* */ <") );
ASSERT_EQ(2U, mpParser->messages().size());
EXPECT_TRUE(checkWarningMessage(0, 1, 12, compil::Message::p_misplacedComment));
EXPECT_TRUE(checkErrorMessage(1, 1, 19, compil::Message::p_expectType));
}
TEST_F(ParserFactoryTests, factoryMissingParameterTypeNameOpenClose)
{
ASSERT_FALSE( parseDocument(
"hierarchy factory<blah> name {}") );
ASSERT_EQ(1U, mpParser->messages().size());
EXPECT_TRUE(checkErrorMessage(0, 1, 19, compil::Message::p_unknownClassifierType,
compil::Message::Type("blah")));
}
TEST_F(ParserFactoryTests, objectFactoryTypeNameOpenClose)
{
ASSERT_TRUE( parseDocument(
"object factory<integer> name {}") );
EXPECT_EQ(1U, mDocument->objects().size());
EXPECT_TRUE(checkFactory(0, 1, 1, "name", compil::Factory::EType::object()));
EXPECT_TRUE(checkFactoryParameterType(0, "integer"));
}
BsonTableModel::BsonTableModel(const std::vector<MongoDocumentPtr> &documents, QObject *parent)
: BaseClass(parent) ,
_root(new BsonTableItem(this))
{
for (std::vector<MongoDocumentPtr>::const_iterator it = documents.begin(); it!=documents.end(); ++it)
{
MongoDocumentPtr doc = (*it);
parseDocument(_root,doc->bsonObj());
}
}
TEST_F(ParserFactoryTests, noTypeFactory)
{
ASSERT_FALSE( parseDocument(
"factory") );
ASSERT_EQ(1U, mpParser->messages().size());
EXPECT_TRUE(checkErrorMessage(0, 1, 8, compil::Message::p_expectAppropriateType,
compil::Message::Classifier("factory"),
compil::Message::Options("hierarchy, object or plugin")));
}
