| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| |
| #include "HelpCompiler.hxx" |
| #include <limits.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <libxslt/xslt.h> |
| #include <libxslt/xsltInternals.h> |
| #include <libxslt/transform.h> |
| #include <libxslt/xsltutils.h> |
| #ifdef __MINGW32__ |
| #include <tools/prewin.h> |
| #include <tools/postwin.h> |
| #endif |
| #include <osl/thread.hxx> |
| |
| static void impl_sleep( sal_uInt32 nSec ) |
| { |
| TimeValue aTime; |
| aTime.Seconds = nSec; |
| aTime.Nanosec = 0; |
| |
| osl::Thread::wait( aTime ); |
| } |
| |
| HelpCompiler::HelpCompiler(StreamTable &in_streamTable, const fs::path &in_inputFile, |
| const fs::path &in_src, const fs::path &in_resEmbStylesheet, |
| const std::string &in_module, const std::string &in_lang, bool in_bExtensionMode) |
| : streamTable(in_streamTable), inputFile(in_inputFile), |
| src(in_src), module(in_module), lang(in_lang), resEmbStylesheet(in_resEmbStylesheet), |
| bExtensionMode( in_bExtensionMode ) |
| { |
| xmlKeepBlanksDefaultValue = 0; |
| } |
| |
| xmlDocPtr HelpCompiler::getSourceDocument(const fs::path &filePath) |
| { |
| static const char *params[4 + 1]; |
| static xsltStylesheetPtr cur = NULL; |
| |
| xmlDocPtr res; |
| if( bExtensionMode ) |
| { |
| res = xmlParseFile(filePath.native_file_string().c_str()); |
| if( !res ){ |
| impl_sleep( 3 ); |
| res = xmlParseFile(filePath.native_file_string().c_str()); |
| } |
| } |
| else |
| { |
| if (!cur) |
| { |
| static std::string fsroot('\'' + src.toUTF8() + '\''); |
| static std::string esclang('\'' + lang + '\''); |
| |
| xmlSubstituteEntitiesDefault(1); |
| xmlLoadExtDtdDefaultValue = 1; |
| cur = xsltParseStylesheetFile((const xmlChar *)resEmbStylesheet.native_file_string().c_str()); |
| |
| int nbparams = 0; |
| params[nbparams++] = "Language"; |
| params[nbparams++] = esclang.c_str(); |
| params[nbparams++] = "fsroot"; |
| params[nbparams++] = fsroot.c_str(); |
| params[nbparams] = NULL; |
| } |
| xmlDocPtr doc = xmlParseFile(filePath.native_file_string().c_str()); |
| if( !doc ) |
| { |
| impl_sleep( 3 ); |
| doc = xmlParseFile(filePath.native_file_string().c_str()); |
| } |
| |
| //???res = xmlParseFile(filePath.native_file_string().c_str()); |
| |
| res = xsltApplyStylesheet(cur, doc, params); |
| xmlFreeDoc(doc); |
| } |
| return res; |
| } |
| |
| HashSet HelpCompiler::switchFind(xmlDocPtr doc) |
| { |
| HashSet hs; |
| xmlChar *xpath = (xmlChar*)"//switchinline"; |
| |
| xmlXPathContextPtr context = xmlXPathNewContext(doc); |
| xmlXPathObjectPtr result = xmlXPathEvalExpression(xpath, context); |
| xmlXPathFreeContext(context); |
| if (result) |
| { |
| xmlNodeSetPtr nodeset = result->nodesetval; |
| for (int i = 0; i < nodeset->nodeNr; i++) |
| { |
| xmlNodePtr el = nodeset->nodeTab[i]; |
| xmlChar *select = xmlGetProp(el, (xmlChar*)"select"); |
| if (select) |
| { |
| if (!strcmp((const char*)select, "appl")) |
| { |
| xmlNodePtr n1 = el->xmlChildrenNode; |
| while (n1) |
| { |
| if ((!xmlStrcmp(n1->name, (const xmlChar*)"caseinline"))) |
| { |
| xmlChar *appl = xmlGetProp(n1, (xmlChar*)"select"); |
| hs.push_back(std::string((const char*)appl)); |
| xmlFree(appl); |
| } |
| else if ((!xmlStrcmp(n1->name, (const xmlChar*)"defaultinline"))) |
| hs.push_back(std::string("DEFAULT")); |
| n1 = n1->next; |
| } |
| } |
| xmlFree(select); |
| } |
| } |
| xmlXPathFreeObject(result); |
| } |
| hs.push_back(std::string("DEFAULT")); |
| return hs; |
| } |
| |
| // returns a node representing the whole stuff compiled for the current |
| // application. |
| xmlNodePtr HelpCompiler::clone(xmlNodePtr node, const std::string& appl) |
| { |
| xmlNodePtr parent = xmlCopyNode(node, 2); |
| xmlNodePtr n = node->xmlChildrenNode; |
| while (n != NULL) |
| { |
| bool isappl = false; |
| if ( (!strcmp((const char*)n->name, "switchinline")) || |
| (!strcmp((const char*)n->name, "switch")) ) |
| { |
| xmlChar *select = xmlGetProp(n, (xmlChar*)"select"); |
| if (select) |
| { |
| if (!strcmp((const char*)select, "appl")) |
| isappl = true; |
| xmlFree(select); |
| } |
| } |
| if (isappl) |
| { |
| xmlNodePtr caseNode = n->xmlChildrenNode; |
| if (appl == "DEFAULT") |
| { |
| while (caseNode) |
| { |
| if (!strcmp((const char*)caseNode->name, "defaultinline")) |
| { |
| xmlNodePtr cnl = caseNode->xmlChildrenNode; |
| while (cnl) |
| { |
| xmlAddChild(parent, clone(cnl, appl)); |
| cnl = cnl->next; |
| } |
| break; |
| } |
| caseNode = caseNode->next; |
| } |
| } |
| else |
| { |
| while (caseNode) |
| { |
| isappl=false; |
| if (!strcmp((const char*)caseNode->name, "caseinline")) |
| { |
| xmlChar *select = xmlGetProp(n, (xmlChar*)"select"); |
| if (select) |
| { |
| if (!strcmp((const char*)select, appl.c_str())) |
| isappl = true; |
| xmlFree(select); |
| } |
| if (isappl) |
| { |
| xmlNodePtr cnl = caseNode->xmlChildrenNode; |
| while (cnl) |
| { |
| xmlAddChild(parent, clone(cnl, appl)); |
| cnl = cnl->next; |
| } |
| break; |
| } |
| |
| } |
| caseNode = caseNode->next; |
| } |
| } |
| |
| } |
| else |
| xmlAddChild(parent, clone(n, appl)); |
| |
| n = n->next; |
| } |
| return parent; |
| } |
| |
| class myparser |
| { |
| public: |
| std::string documentId; |
| std::string fileName; |
| std::string title; |
| HashSet *hidlist; |
| Hashtable *keywords; |
| Stringtable *helptexts; |
| private: |
| HashSet extendedHelpText; |
| public: |
| myparser(const std::string &indocumentId, const std::string &infileName, |
| const std::string &intitle) : documentId(indocumentId), fileName(infileName), |
| title(intitle) |
| { |
| hidlist = new HashSet; |
| keywords = new Hashtable; |
| helptexts = new Stringtable; |
| } |
| void traverse( xmlNodePtr parentNode ); |
| private: |
| std::string dump(xmlNodePtr node); |
| }; |
| |
| std::string myparser::dump(xmlNodePtr node) |
| { |
| std::string app; |
| if (node->xmlChildrenNode) |
| { |
| xmlNodePtr list = node->xmlChildrenNode; |
| while (list) |
| { |
| app += dump(list); |
| list = list->next; |
| } |
| } |
| if (xmlNodeIsText(node)) |
| { |
| xmlChar *pContent = xmlNodeGetContent(node); |
| app += std::string((const char*)pContent); |
| xmlFree(pContent); |
| // std::cout << app << std::endl; |
| } |
| return app; |
| } |
| |
| void trim(std::string& str) |
| { |
| std::string::size_type pos = str.find_last_not_of(' '); |
| if(pos != std::string::npos) |
| { |
| str.erase(pos + 1); |
| pos = str.find_first_not_of(' '); |
| if(pos != std::string::npos) |
| str.erase(0, pos); |
| } |
| else |
| str.erase(str.begin(), str.end()); |
| } |
| |
| void myparser::traverse( xmlNodePtr parentNode ) |
| { |
| // traverse all nodes that belong to the parent |
| xmlNodePtr test ; |
| for (test = parentNode->xmlChildrenNode; test; test = test->next) |
| { |
| if (fileName.empty() && !strcmp((const char*)test->name, "filename")) |
| { |
| xmlNodePtr node = test->xmlChildrenNode; |
| if (xmlNodeIsText(node)) |
| { |
| xmlChar *pContent = xmlNodeGetContent(node); |
| fileName = std::string((const char*)pContent); |
| xmlFree(pContent); |
| } |
| } |
| else if (title.empty() && !strcmp((const char*)test->name, "title")) |
| { |
| title = dump(test); |
| if (title.empty()) |
| title = "<notitle>"; |
| } |
| else if (!strcmp((const char*)test->name, "bookmark")) |
| { |
| xmlChar *branchxml = xmlGetProp(test, (const xmlChar*)"branch"); |
| xmlChar *idxml = xmlGetProp(test, (const xmlChar*)"id"); |
| std::string branch((const char*)branchxml); |
| std::string anchor((const char*)idxml); |
| xmlFree (branchxml); |
| xmlFree (idxml); |
| |
| std::string hid; |
| |
| if (branch.find("hid") == 0) |
| { |
| size_t index = branch.find('/'); |
| if (index != std::string::npos) |
| { |
| hid = branch.substr(1 + index); |
| // one shall serve as a documentId |
| if (documentId.empty()) |
| documentId = hid; |
| extendedHelpText.push_back(hid); |
| std::string foo = anchor.empty() ? hid : hid + "#" + anchor; |
| HCDBG(std::cerr << "hid pushback" << foo << std::endl); |
| hidlist->push_back( anchor.empty() ? hid : hid + "#" + anchor); |
| } |
| else |
| continue; |
| } |
| else if (branch.compare("index") == 0) |
| { |
| LinkedList ll; |
| |
| for (xmlNodePtr nd = test->xmlChildrenNode; nd; nd = nd->next) |
| { |
| if (strcmp((const char*)nd->name, "bookmark_value")) |
| continue; |
| |
| std::string embedded; |
| xmlChar *embeddedxml = xmlGetProp(nd, (const xmlChar*)"embedded"); |
| if (embeddedxml) |
| { |
| embedded = std::string((const char*)embeddedxml); |
| xmlFree (embeddedxml); |
| std::transform (embedded.begin(), embedded.end(), |
| embedded.begin(), tolower); |
| } |
| |
| bool isEmbedded = !embedded.empty() && embedded.compare("true") == 0; |
| if (isEmbedded) |
| continue; |
| |
| std::string keyword = dump(nd); |
| size_t keywordSem = keyword.find(';'); |
| if (keywordSem != std::string::npos) |
| { |
| std::string tmppre = |
| keyword.substr(0,keywordSem); |
| trim(tmppre); |
| std::string tmppos = |
| keyword.substr(1+keywordSem); |
| trim(tmppos); |
| keyword = tmppre + ";" + tmppos; |
| } |
| ll.push_back(keyword); |
| } |
| if (!ll.empty()) |
| (*keywords)[anchor] = ll; |
| } |
| else if (branch.compare("contents") == 0) |
| { |
| // currently not used |
| } |
| } |
| else if (!strcmp((const char*)test->name, "ahelp")) |
| { |
| std::string text = dump(test); |
| trim(text); |
| std::string name; |
| |
| HashSet::const_iterator aEnd = extendedHelpText.end(); |
| for (HashSet::const_iterator iter = extendedHelpText.begin(); iter != aEnd; |
| ++iter) |
| { |
| name = *iter; |
| (*helptexts)[name] = text; |
| } |
| extendedHelpText.clear(); |
| } |
| |
| // traverse children |
| traverse(test); |
| } |
| } |
| |
| bool HelpCompiler::compile( void ) throw( HelpProcessingException ) |
| { |
| // we now have the jaroutputstream, which will contain the document. |
| // now determine the document as a dom tree in variable docResolved |
| |
| xmlDocPtr docResolvedOrg = getSourceDocument(inputFile); |
| |
| // now add path to the document |
| // resolve the dom |
| if (!docResolvedOrg) |
| { |
| impl_sleep( 3 ); |
| docResolvedOrg = getSourceDocument(inputFile); |
| if( !docResolvedOrg ) |
| { |
| std::stringstream aStrStream; |
| aStrStream << "ERROR: file not existing: " << inputFile.native_file_string().c_str() << std::endl; |
| throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() ); |
| } |
| } |
| |
| // now find all applications for which one has to compile |
| std::string documentId; |
| std::string fileName; |
| std::string title; |
| // returns all applications for which one has to compile |
| HashSet applications = switchFind(docResolvedOrg); |
| |
| HashSet::const_iterator aEnd = applications.end(); |
| for (HashSet::const_iterator aI = applications.begin(); aI != aEnd; ++aI) |
| { |
| std::string appl = *aI; |
| std::string modulename = appl; |
| if (modulename[0] == 'S') |
| { |
| modulename = modulename.substr(1); |
| std::transform(modulename.begin(), modulename.end(), modulename.begin(), tolower); |
| } |
| if (modulename != "DEFAULT" && modulename != module) |
| continue; |
| |
| // returns a clone of the document with swich-cases resolved |
| xmlNodePtr docResolved = clone(xmlDocGetRootElement(docResolvedOrg), appl); |
| myparser aparser(documentId, fileName, title); |
| aparser.traverse(docResolved); |
| |
| documentId = aparser.documentId; |
| fileName = aparser.fileName; |
| title = aparser.title; |
| |
| HCDBG(std::cerr << documentId << " : " << fileName << " : " << title << std::endl); |
| |
| xmlDocPtr docResolvedDoc = xmlCopyDoc(docResolvedOrg, false); |
| xmlDocSetRootElement(docResolvedDoc, docResolved); |
| |
| if (modulename == "DEFAULT") |
| { |
| streamTable.dropdefault(); |
| streamTable.default_doc = docResolvedDoc; |
| streamTable.default_hidlist = aparser.hidlist; |
| streamTable.default_helptexts = aparser.helptexts; |
| streamTable.default_keywords = aparser.keywords; |
| } |
| else if (modulename == module) |
| { |
| streamTable.dropappl(); |
| streamTable.appl_doc = docResolvedDoc; |
| streamTable.appl_hidlist = aparser.hidlist; |
| streamTable.appl_helptexts = aparser.helptexts; |
| streamTable.appl_keywords = aparser.keywords; |
| } |
| else |
| { |
| std::stringstream aStrStream; |
| aStrStream << "ERROR: Found unexpected module name \"" << modulename |
| << "\" in file" << src.native_file_string().c_str() << std::endl; |
| throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() ); |
| } |
| |
| } // end iteration over all applications |
| |
| streamTable.document_id = documentId; |
| streamTable.document_path = fileName; |
| streamTable.document_title = title; |
| std::string actMod = module; |
| if ( !bExtensionMode && !fileName.empty()) |
| { |
| if (fileName.find("/text/") == 0) |
| { |
| int len = strlen("/text/"); |
| actMod = fileName.substr(len); |
| actMod = actMod.substr(0, actMod.find('/')); |
| } |
| } |
| streamTable.document_module = actMod; |
| |
| xmlFreeDoc(docResolvedOrg); |
| return true; |
| } |
| |
| namespace fs |
| { |
| rtl_TextEncoding getThreadTextEncoding( void ) |
| { |
| static bool bNeedsInit = true; |
| static rtl_TextEncoding nThreadTextEncoding; |
| if( bNeedsInit ) |
| { |
| bNeedsInit = false; |
| nThreadTextEncoding = osl_getThreadTextEncoding(); |
| } |
| return nThreadTextEncoding; |
| } |
| |
| void create_directory(const fs::path indexDirName) |
| { |
| HCDBG( |
| std::cerr << "creating " << |
| rtl::OUStringToOString(indexDirName.data, RTL_TEXTENCODING_UTF8).getStr() |
| << std::endl |
| ); |
| osl::Directory::createPath(indexDirName.data); |
| } |
| |
| void rename(const fs::path &src, const fs::path &dest) |
| { |
| osl::File::move(src.data, dest.data); |
| } |
| |
| void copy(const fs::path &src, const fs::path &dest) |
| { |
| osl::File::copy(src.data, dest.data); |
| } |
| |
| bool exists(const fs::path &in) |
| { |
| osl::File tmp(in.data); |
| return (tmp.open(osl_File_OpenFlag_Read) == osl::FileBase::E_None); |
| } |
| |
| void remove(const fs::path &in) |
| { |
| osl::File::remove(in.data); |
| } |
| |
| void removeRecursive(rtl::OUString const& _suDirURL) |
| { |
| { |
| osl::Directory aDir(_suDirURL); |
| aDir.open(); |
| if (aDir.isOpen()) |
| { |
| osl::DirectoryItem aItem; |
| osl::FileStatus aStatus(osl_FileStatus_Mask_FileName | osl_FileStatus_Mask_Attributes); |
| while (aDir.getNextItem(aItem) == ::osl::FileBase::E_None) |
| { |
| if (osl::FileBase::E_None == aItem.getFileStatus(aStatus) && |
| aStatus.isValid(osl_FileStatus_Mask_FileName | osl_FileStatus_Mask_Attributes)) |
| { |
| rtl::OUString suFilename = aStatus.getFileName(); |
| rtl::OUString suFullFileURL; |
| suFullFileURL += _suDirURL; |
| suFullFileURL += rtl::OUString::createFromAscii("/"); |
| suFullFileURL += suFilename; |
| |
| if (aStatus.getFileType() == osl::FileStatus::Directory) |
| removeRecursive(suFullFileURL); |
| else |
| osl::File::remove(suFullFileURL); |
| } |
| } |
| aDir.close(); |
| } |
| } |
| osl::Directory::remove(_suDirURL); |
| } |
| |
| void remove_all(const fs::path &in) |
| { |
| removeRecursive(in.data); |
| } |
| } |
| |
| /* vi:set tabstop=4 shiftwidth=4 expandtab: */ |
