| /************************************************************** |
| * |
| * 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 <map> |
| |
| #include <string.h> |
| #include <limits.h> |
| |
| #include <libxslt/xslt.h> |
| #include <libxslt/transform.h> |
| #include <libxslt/xsltutils.h> |
| #include <libxslt/functions.h> |
| #include <libxslt/extensions.h> |
| |
| #include <sal/types.h> |
| #include <osl/time.h> |
| #include <rtl/bootstrap.hxx> |
| |
| #include <expat.h> |
| |
| class IndexerPreProcessor |
| { |
| private: |
| std::string m_aModuleName; |
| fs::path m_fsIndexBaseDir; |
| fs::path m_fsCaptionFilesDirName; |
| fs::path m_fsContentFilesDirName; |
| |
| xsltStylesheetPtr m_xsltStylesheetPtrCaption; |
| xsltStylesheetPtr m_xsltStylesheetPtrContent; |
| |
| public: |
| IndexerPreProcessor( const std::string& aModuleName, const fs::path& fsIndexBaseDir, |
| const fs::path& idxCaptionStylesheet, const fs::path& idxContentStylesheet ); |
| ~IndexerPreProcessor(); |
| |
| void processDocument( xmlDocPtr doc, const std::string& EncodedDocPath ); |
| }; |
| |
| IndexerPreProcessor::IndexerPreProcessor |
| ( const std::string& aModuleName, const fs::path& fsIndexBaseDir, |
| const fs::path& idxCaptionStylesheet, const fs::path& idxContentStylesheet ) |
| : m_aModuleName( aModuleName ) |
| , m_fsIndexBaseDir( fsIndexBaseDir ) |
| { |
| m_fsCaptionFilesDirName = fsIndexBaseDir / "caption"; |
| fs::create_directory( m_fsCaptionFilesDirName ); |
| |
| m_fsContentFilesDirName = fsIndexBaseDir / "content"; |
| fs::create_directory( m_fsContentFilesDirName ); |
| |
| m_xsltStylesheetPtrCaption = xsltParseStylesheetFile |
| ((const xmlChar *)idxCaptionStylesheet.native_file_string().c_str()); |
| m_xsltStylesheetPtrContent = xsltParseStylesheetFile |
| ((const xmlChar *)idxContentStylesheet.native_file_string().c_str()); |
| } |
| |
| IndexerPreProcessor::~IndexerPreProcessor() |
| { |
| if( m_xsltStylesheetPtrCaption ) |
| xsltFreeStylesheet( m_xsltStylesheetPtrCaption ); |
| if( m_xsltStylesheetPtrContent ) |
| xsltFreeStylesheet( m_xsltStylesheetPtrContent ); |
| } |
| |
| |
| std::string getEncodedPath( const std::string& Path ) |
| { |
| rtl::OString aOStr_Path( Path.c_str() ); |
| rtl::OUString aOUStr_Path( rtl::OStringToOUString |
| ( aOStr_Path, fs::getThreadTextEncoding() ) ); |
| rtl::OUString aPathURL; |
| osl::File::getFileURLFromSystemPath( aOUStr_Path, aPathURL ); |
| rtl::OString aOStr_PathURL( rtl::OUStringToOString |
| ( aPathURL, fs::getThreadTextEncoding() ) ); |
| std::string aStdStr_PathURL( aOStr_PathURL.getStr() ); |
| return aStdStr_PathURL; |
| } |
| |
| void IndexerPreProcessor::processDocument |
| ( xmlDocPtr doc, const std::string &EncodedDocPath ) |
| { |
| std::string aStdStr_EncodedDocPathURL = getEncodedPath( EncodedDocPath ); |
| |
| if( m_xsltStylesheetPtrCaption ) |
| { |
| xmlDocPtr resCaption = xsltApplyStylesheet( m_xsltStylesheetPtrCaption, doc, NULL ); |
| xmlNodePtr pResNodeCaption = resCaption->xmlChildrenNode; |
| if( pResNodeCaption ) |
| { |
| fs::path fsCaptionPureTextFile_docURL = m_fsCaptionFilesDirName / aStdStr_EncodedDocPathURL; |
| std::string aCaptionPureTextFileStr_docURL = fsCaptionPureTextFile_docURL.native_file_string(); |
| #ifdef WNT //We need _wfopen to support long file paths on Windows XP |
| FILE* pFile_docURL = _wfopen( |
| fsCaptionPureTextFile_docURL.native_file_string_w(), L"w" ); |
| #else |
| FILE* pFile_docURL = fopen( |
| fsCaptionPureTextFile_docURL.native_file_string().c_str(), "w" ); |
| #endif |
| if( pFile_docURL ) |
| { |
| fprintf( pFile_docURL, "%s\n", pResNodeCaption->content ); |
| fclose( pFile_docURL ); |
| } |
| } |
| xmlFreeDoc(resCaption); |
| } |
| |
| if( m_xsltStylesheetPtrContent ) |
| { |
| xmlDocPtr resContent = xsltApplyStylesheet( m_xsltStylesheetPtrContent, doc, NULL ); |
| xmlNodePtr pResNodeContent = resContent->xmlChildrenNode; |
| if( pResNodeContent ) |
| { |
| fs::path fsContentPureTextFile_docURL = m_fsContentFilesDirName / aStdStr_EncodedDocPathURL; |
| #ifdef WNT //We need _wfopen to support long file paths on Windows XP |
| FILE* pFile_docURL = _wfopen( |
| fsContentPureTextFile_docURL.native_file_string_w(), L"w" ); |
| #else |
| FILE* pFile_docURL = fopen( |
| fsContentPureTextFile_docURL.native_file_string().c_str(), "w" ); |
| #endif |
| if( pFile_docURL ) |
| { |
| fprintf( pFile_docURL, "%s\n", pResNodeContent->content ); |
| fclose( pFile_docURL ); |
| } |
| } |
| xmlFreeDoc(resContent); |
| } |
| } |
| |
| struct Data |
| { |
| std::vector<std::string> _idList; |
| typedef std::vector<std::string>::const_iterator cIter; |
| |
| void append(const std::string &id) |
| { |
| _idList.push_back(id); |
| } |
| |
| std::string getString() const |
| { |
| std::string ret; |
| cIter aEnd = _idList.end(); |
| for (cIter aIter = _idList.begin(); aIter != aEnd; ++aIter) |
| ret += *aIter + ";"; |
| return ret; |
| } |
| }; |
| |
| void writeKeyValue_DBHelp( FILE* pFile, const std::string& aKeyStr, const std::string& aValueStr ) |
| { |
| if( pFile == NULL ) |
| return; |
| char cLF = 10; |
| unsigned int nKeyLen = aKeyStr.length(); |
| unsigned int nValueLen = aValueStr.length(); |
| fprintf( pFile, "%x ", nKeyLen ); |
| if( nKeyLen > 0 ) |
| { |
| if (fwrite( aKeyStr.c_str(), 1, nKeyLen, pFile ) != nKeyLen) |
| fprintf(stderr, "fwrite to db failed\n"); |
| } |
| if (fprintf( pFile, " %x ", nValueLen ) < 0) |
| fprintf(stderr, "fwrite to db failed\n"); |
| if( nValueLen > 0 ) |
| { |
| if (fwrite( aValueStr.c_str(), 1, nValueLen, pFile ) != nValueLen) |
| fprintf(stderr, "fwrite to db failed\n"); |
| } |
| if (fprintf( pFile, "%c", cLF ) < 0) |
| fprintf(stderr, "fwrite to db failed\n"); |
| } |
| |
| class HelpKeyword |
| { |
| private: |
| typedef std::hash_map<std::string, Data, pref_hash> DataHashtable; |
| DataHashtable _hash; |
| |
| public: |
| void insert(const std::string &key, const std::string &id) |
| { |
| Data &data = _hash[key]; |
| data.append(id); |
| } |
| |
| void dump_DBHelp( const fs::path& rFileName ) |
| { |
| #ifdef WNT //We need _wfopen to support long file paths on Windows XP |
| FILE* pFile = _wfopen( rFileName.native_file_string_w(), L"wb" ); |
| #else |
| FILE* pFile = fopen( rFileName.native_file_string().c_str(), "wb" ); |
| #endif |
| if( pFile == NULL ) |
| return; |
| |
| DataHashtable::const_iterator aEnd = _hash.end(); |
| for (DataHashtable::const_iterator aIter = _hash.begin(); aIter != aEnd; ++aIter) |
| writeKeyValue_DBHelp( pFile, aIter->first, aIter->second.getString() ); |
| |
| fclose( pFile ); |
| } |
| }; |
| |
| class HelpLinker |
| { |
| public: |
| void main(std::vector<std::string> &args, |
| std::string* pExtensionPath = NULL, |
| std::string* pDestination = NULL, |
| const rtl::OUString* pOfficeHelpPath = NULL ) |
| |
| throw( HelpProcessingException ); |
| |
| HelpLinker() |
| : init(true) |
| , m_pIndexerPreProcessor(NULL) |
| {} |
| ~HelpLinker() |
| { delete m_pIndexerPreProcessor; } |
| |
| private: |
| int locCount, totCount; |
| Stringtable additionalFiles; |
| HashSet helpFiles; |
| fs::path sourceRoot; |
| fs::path embeddStylesheet; |
| fs::path idxCaptionStylesheet; |
| fs::path idxContentStylesheet; |
| fs::path zipdir; |
| fs::path outputFile; |
| std::string extsource; |
| std::string extdestination; |
| std::string module; |
| std::string lang; |
| std::string extensionPath; |
| std::string extensionDestination; |
| bool bExtensionMode; |
| fs::path indexDirName; |
| fs::path indexDirParentName; |
| bool init; |
| IndexerPreProcessor* m_pIndexerPreProcessor; |
| void initIndexerPreProcessor(); |
| void link() throw( HelpProcessingException ); |
| void addBookmark( FILE* pFile_DBHelp, std::string thishid, |
| const std::string& fileB, const std::string& anchorB, |
| const std::string& jarfileB, const std::string& titleB ); |
| }; |
| |
| namespace URLEncoder |
| { |
| static std::string encode(const std::string &rIn) |
| { |
| const char *good = "!$&'()*+,-.=@_"; |
| static const char hex[17] = "0123456789ABCDEF"; |
| |
| std::string result; |
| for (size_t i=0; i < rIn.length(); ++i) |
| { |
| unsigned char c = rIn[i]; |
| if (isalnum (c) || strchr (good, c)) |
| result += c; |
| else { |
| result += '%'; |
| result += hex[c >> 4]; |
| result += hex[c & 0xf]; |
| } |
| } |
| return result; |
| } |
| } |
| |
| void HelpLinker::addBookmark( FILE* pFile_DBHelp, std::string thishid, |
| const std::string& fileB, const std::string& anchorB, |
| const std::string& jarfileB, const std::string& titleB) |
| { |
| HCDBG(std::cerr << "HelpLinker::addBookmark " << thishid << " " << |
| fileB << " " << anchorB << " " << jarfileB << " " << titleB << std::endl); |
| |
| thishid = URLEncoder::encode(thishid); |
| |
| int fileLen = fileB.length(); |
| if (!anchorB.empty()) |
| fileLen += (1 + anchorB.length()); |
| int dataLen = 1 + fileLen + 1 + jarfileB.length() + 1 + titleB.length(); |
| |
| std::vector<unsigned char> dataB(dataLen); |
| size_t i = 0; |
| dataB[i++] = static_cast<unsigned char>(fileLen); |
| for (size_t j = 0; j < fileB.length(); ++j) |
| dataB[i++] = fileB[j]; |
| if (!anchorB.empty()) |
| { |
| dataB[i++] = '#'; |
| for (size_t j = 0; j < anchorB.length(); ++j) |
| dataB[i++] = anchorB[j]; |
| } |
| dataB[i++] = static_cast<unsigned char>(jarfileB.length()); |
| for (size_t j = 0; j < jarfileB.length(); ++j) |
| dataB[i++] = jarfileB[j]; |
| |
| dataB[i++] = static_cast<unsigned char>(titleB.length()); |
| for (size_t j = 0; j < titleB.length(); ++j) |
| dataB[i++] = titleB[j]; |
| |
| if( pFile_DBHelp != NULL ) |
| { |
| std::string aValueStr( dataB.begin(), dataB.end() ); |
| writeKeyValue_DBHelp( pFile_DBHelp, thishid, aValueStr ); |
| } |
| } |
| |
| void HelpLinker::initIndexerPreProcessor() |
| { |
| if( m_pIndexerPreProcessor ) |
| delete m_pIndexerPreProcessor; |
| std::string mod = module; |
| std::transform (mod.begin(), mod.end(), mod.begin(), tolower); |
| m_pIndexerPreProcessor = new IndexerPreProcessor( mod, indexDirParentName, |
| idxCaptionStylesheet, idxContentStylesheet ); |
| } |
| |
| /** |
| * |
| */ |
| void HelpLinker::link() throw( HelpProcessingException ) |
| { |
| bool bIndexForExtension = true; |
| |
| if( bExtensionMode ) |
| { |
| //indexDirParentName = sourceRoot; |
| indexDirParentName = extensionDestination; |
| } |
| else |
| { |
| indexDirParentName = zipdir; |
| fs::create_directory(indexDirParentName); |
| } |
| |
| std::string mod = module; |
| std::transform (mod.begin(), mod.end(), mod.begin(), tolower); |
| |
| // do the work here |
| // continue with introduction of the overall process thing into the |
| // here all hzip files will be worked on |
| std::string appl = mod; |
| if (appl[0] == 's') |
| appl = appl.substr(1); |
| |
| bool bUse_ = true; |
| if( !bExtensionMode ) |
| bUse_ = false; |
| |
| fs::path helpTextFileName_DBHelp(indexDirParentName / (mod + (bUse_ ? ".ht_" : ".ht"))); |
| #ifdef WNT |
| //We need _wfopen to support long file paths on Windows XP |
| FILE* pFileHelpText_DBHelp = _wfopen |
| ( helpTextFileName_DBHelp.native_file_string_w(), L"wb" ); |
| #else |
| |
| FILE* pFileHelpText_DBHelp = fopen |
| ( helpTextFileName_DBHelp.native_file_string().c_str(), "wb" ); |
| #endif |
| |
| fs::path dbBaseFileName_DBHelp(indexDirParentName / (mod + (bUse_ ? ".db_" : ".db"))); |
| #ifdef WNT |
| //We need _wfopen to support long file paths on Windows XP |
| FILE* pFileDbBase_DBHelp = _wfopen |
| ( dbBaseFileName_DBHelp.native_file_string_w(), L"wb" ); |
| #else |
| FILE* pFileDbBase_DBHelp = fopen |
| ( dbBaseFileName_DBHelp.native_file_string().c_str(), "wb" ); |
| #endif |
| |
| fs::path keyWordFileName_DBHelp(indexDirParentName / (mod + (bUse_ ? ".key_" : ".key"))); |
| |
| HelpKeyword helpKeyword; |
| |
| // catch HelpProcessingException to avoid locking data bases |
| try |
| { |
| |
| // lastly, initialize the indexBuilder |
| if ( (!bExtensionMode || bIndexForExtension) && !helpFiles.empty()) |
| initIndexerPreProcessor(); |
| |
| if( !bExtensionMode ) |
| { |
| #ifndef OS2 // YD @TODO@ crashes libc runtime :-( |
| std::cout << "Making " << outputFile.native_file_string() << |
| " from " << helpFiles.size() << " input files" << std::endl; |
| #endif |
| } |
| |
| // here we start our loop over the hzip files. |
| HashSet::iterator end = helpFiles.end(); |
| for (HashSet::iterator iter = helpFiles.begin(); iter != end; ++iter) |
| { |
| if( !bExtensionMode ) |
| { |
| std::cout << "."; |
| std::cout.flush(); |
| } |
| |
| // process one file |
| // streamTable contains the streams in the hzip file |
| StreamTable streamTable; |
| const std::string &xhpFileName = *iter; |
| |
| if (!bExtensionMode && xhpFileName.rfind(".xhp") != xhpFileName.length()-4) |
| { |
| // only work on .xhp - files |
| std::cerr << |
| "ERROR: input list entry '" |
| << xhpFileName |
| << "' has the wrong extension (only files with extension .xhp " |
| << "are accepted)"; |
| continue; |
| } |
| |
| fs::path langsourceRoot(sourceRoot); |
| fs::path xhpFile; |
| |
| if( bExtensionMode ) |
| { |
| // langsourceRoot == sourceRoot for extensions |
| std::string xhpFileNameComplete( extensionPath ); |
| xhpFileNameComplete.append( '/' + xhpFileName ); |
| xhpFile = fs::path( xhpFileNameComplete ); |
| } |
| else |
| { |
| langsourceRoot.append('/' + lang + '/'); |
| xhpFile = fs::path(xhpFileName, fs::native); |
| } |
| |
| HelpCompiler hc( streamTable, xhpFile, langsourceRoot, |
| embeddStylesheet, module, lang, bExtensionMode ); |
| |
| HCDBG(std::cerr << "before compile of " << xhpFileName << std::endl); |
| bool success = hc.compile(); |
| HCDBG(std::cerr << "after compile of " << xhpFileName << std::endl); |
| |
| if (!success && !bExtensionMode) |
| { |
| std::stringstream aStrStream; |
| aStrStream << |
| "\nERROR: compiling help particle '" |
| << xhpFileName |
| << "' for language '" |
| << lang |
| << "' failed!"; |
| throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() ); |
| } |
| |
| const std::string documentBaseId = streamTable.document_id; |
| std::string documentPath = streamTable.document_path; |
| if (documentPath.find("/") == 0) |
| documentPath = documentPath.substr(1); |
| |
| std::string documentJarfile = streamTable.document_module + ".jar"; |
| |
| std::string documentTitle = streamTable.document_title; |
| if (documentTitle.empty()) |
| documentTitle = "<notitle>"; |
| |
| const std::string& fileB = documentPath; |
| const std::string& jarfileB = documentJarfile; |
| std::string& titleB = documentTitle; |
| |
| // add once this as its own id. |
| addBookmark(pFileDbBase_DBHelp, documentPath, fileB, std::string(), jarfileB, titleB); |
| |
| const HashSet *hidlist = streamTable.appl_hidlist; |
| if (!hidlist) |
| hidlist = streamTable.default_hidlist; |
| if (hidlist && !hidlist->empty()) |
| { |
| // now iterate over all elements of the hidlist |
| HashSet::const_iterator aEnd = hidlist->end(); |
| for (HashSet::const_iterator hidListIter = hidlist->begin(); |
| hidListIter != aEnd; ++hidListIter) |
| { |
| std::string thishid = *hidListIter; |
| |
| std::string anchorB; |
| size_t index = thishid.rfind('#'); |
| if (index != std::string::npos) |
| { |
| anchorB = thishid.substr(1 + index); |
| thishid = thishid.substr(0, index); |
| } |
| addBookmark(pFileDbBase_DBHelp, thishid, fileB, anchorB, jarfileB, titleB); |
| } |
| } |
| |
| // now the keywords |
| const Hashtable *anchorToLL = streamTable.appl_keywords; |
| if (!anchorToLL) |
| anchorToLL = streamTable.default_keywords; |
| if (anchorToLL && !anchorToLL->empty()) |
| { |
| std::string fakedHid = URLEncoder::encode(documentPath); |
| Hashtable::const_iterator aEnd = anchorToLL->end(); |
| for (Hashtable::const_iterator enumer = anchorToLL->begin(); |
| enumer != aEnd; ++enumer) |
| { |
| const std::string &anchor = enumer->first; |
| addBookmark(pFileDbBase_DBHelp, documentPath, fileB, |
| anchor, jarfileB, titleB); |
| std::string totalId = fakedHid + "#" + anchor; |
| // std::cerr << hzipFileName << std::endl; |
| const LinkedList& ll = enumer->second; |
| LinkedList::const_iterator aOtherEnd = ll.end(); |
| for (LinkedList::const_iterator llIter = ll.begin(); |
| llIter != aOtherEnd; ++llIter) |
| { |
| helpKeyword.insert(*llIter, totalId); |
| } |
| } |
| |
| } |
| |
| // and last the helptexts |
| const Stringtable *helpTextHash = streamTable.appl_helptexts; |
| if (!helpTextHash) |
| helpTextHash = streamTable.default_helptexts; |
| if (helpTextHash && !helpTextHash->empty()) |
| { |
| Stringtable::const_iterator aEnd = helpTextHash->end(); |
| for (Stringtable::const_iterator helpTextIter = helpTextHash->begin(); |
| helpTextIter != aEnd; ++helpTextIter) |
| { |
| std::string helpTextId = helpTextIter->first; |
| const std::string& helpTextText = helpTextIter->second; |
| |
| helpTextId = URLEncoder::encode(helpTextId); |
| |
| if( pFileHelpText_DBHelp != NULL ) |
| writeKeyValue_DBHelp( pFileHelpText_DBHelp, helpTextId, helpTextText ); |
| } |
| } |
| |
| //IndexerPreProcessor |
| if( !bExtensionMode || bIndexForExtension ) |
| { |
| // now the indexing |
| xmlDocPtr document = streamTable.appl_doc; |
| if (!document) |
| document = streamTable.default_doc; |
| if (document) |
| { |
| std::string temp = module; |
| std::transform (temp.begin(), temp.end(), temp.begin(), tolower); |
| m_pIndexerPreProcessor->processDocument(document, URLEncoder::encode(documentPath) ); |
| } |
| } |
| |
| } // while loop over hzip files ending |
| if( !bExtensionMode ) |
| std::cout << std::endl; |
| |
| } // try |
| catch( const HelpProcessingException& ) |
| { |
| // catch HelpProcessingException to avoid locking data bases |
| if( pFileHelpText_DBHelp != NULL ) |
| fclose( pFileHelpText_DBHelp ); |
| if( pFileDbBase_DBHelp != NULL ) |
| fclose( pFileDbBase_DBHelp ); |
| throw; |
| } |
| |
| if( pFileHelpText_DBHelp != NULL ) |
| fclose( pFileHelpText_DBHelp ); |
| if( pFileDbBase_DBHelp != NULL ) |
| fclose( pFileDbBase_DBHelp ); |
| |
| helpKeyword.dump_DBHelp( keyWordFileName_DBHelp); |
| |
| if( !bExtensionMode ) |
| { |
| // New index |
| Stringtable::iterator aEnd = additionalFiles.end(); |
| for (Stringtable::iterator enumer = additionalFiles.begin(); enumer != aEnd; |
| ++enumer) |
| { |
| const std::string &additionalFileName = enumer->second; |
| const std::string &additionalFileKey = enumer->first; |
| |
| fs::path fsAdditionalFileName( additionalFileName, fs::native ); |
| std::string aNativeStr = fsAdditionalFileName.native_file_string(); |
| const char* pStr = aNativeStr.c_str(); |
| std::cerr << pStr; |
| |
| fs::path fsTargetName( indexDirParentName / additionalFileKey ); |
| |
| fs::copy( fsAdditionalFileName, fsTargetName ); |
| } |
| } |
| |
| } |
| |
| |
| void HelpLinker::main( std::vector<std::string> &args, |
| std::string* pExtensionPath, std::string* pDestination, |
| const rtl::OUString* pOfficeHelpPath ) |
| throw( HelpProcessingException ) |
| { |
| bExtensionMode = false; |
| helpFiles.clear(); |
| |
| if (args.size() > 0 && args[0][0] == '@') |
| { |
| std::vector<std::string> stringList; |
| std::string strBuf; |
| std::ifstream fileReader(args[0].substr(1).c_str()); |
| |
| while (fileReader) |
| { |
| std::string token; |
| fileReader >> token; |
| if (!token.empty()) |
| stringList.push_back(token); |
| } |
| fileReader.close(); |
| |
| args = stringList; |
| } |
| |
| size_t i = 0; |
| bool bSrcOption = false; |
| while (i < args.size()) |
| { |
| if (args[i].compare("-extlangsrc") == 0) |
| { |
| ++i; |
| if (i >= args.size()) |
| { |
| std::stringstream aStrStream; |
| aStrStream << "extension source missing" << std::endl; |
| throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() ); |
| } |
| extsource = args[i]; |
| } |
| else if (args[i].compare("-extlangdest") == 0) |
| { |
| //If this argument is not provided then the location provided in -extsource will |
| //also be the destination |
| ++i; |
| if (i >= args.size()) |
| { |
| std::stringstream aStrStream; |
| aStrStream << "extension destination missing" << std::endl; |
| throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() ); |
| } |
| extdestination = args[i]; |
| } |
| else if (args[i].compare("-src") == 0) |
| { |
| ++i; |
| if (i >= args.size()) |
| { |
| std::stringstream aStrStream; |
| aStrStream << "sourceroot missing" << std::endl; |
| throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() ); |
| } |
| bSrcOption = true; |
| sourceRoot = fs::path(args[i], fs::native); |
| } |
| else if (args[i].compare("-sty") == 0) |
| { |
| ++i; |
| if (i >= args.size()) |
| { |
| std::stringstream aStrStream; |
| aStrStream << "embeddingStylesheet missing" << std::endl; |
| throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() ); |
| } |
| |
| embeddStylesheet = fs::path(args[i], fs::native); |
| } |
| else if (args[i].compare("-zipdir") == 0) |
| { |
| ++i; |
| if (i >= args.size()) |
| { |
| std::stringstream aStrStream; |
| aStrStream << "idxtemp missing" << std::endl; |
| throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() ); |
| } |
| |
| zipdir = fs::path(args[i], fs::native); |
| } |
| else if (args[i].compare("-idxcaption") == 0) |
| { |
| ++i; |
| if (i >= args.size()) |
| { |
| std::stringstream aStrStream; |
| aStrStream << "idxcaption stylesheet missing" << std::endl; |
| throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() ); |
| } |
| |
| idxCaptionStylesheet = fs::path(args[i], fs::native); |
| } |
| else if (args[i].compare("-idxcontent") == 0) |
| { |
| ++i; |
| if (i >= args.size()) |
| { |
| std::stringstream aStrStream; |
| aStrStream << "idxcontent stylesheet missing" << std::endl; |
| throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() ); |
| } |
| |
| idxContentStylesheet = fs::path(args[i], fs::native); |
| } |
| else if (args[i].compare("-o") == 0) |
| { |
| ++i; |
| if (i >= args.size()) |
| { |
| std::stringstream aStrStream; |
| aStrStream << "outputfilename missing" << std::endl; |
| throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() ); |
| } |
| |
| outputFile = fs::path(args[i], fs::native); |
| } |
| else if (args[i].compare("-mod") == 0) |
| { |
| ++i; |
| if (i >= args.size()) |
| { |
| std::stringstream aStrStream; |
| aStrStream << "module name missing" << std::endl; |
| throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() ); |
| } |
| |
| module = args[i]; |
| } |
| else if (args[i].compare("-lang") == 0) |
| { |
| ++i; |
| if (i >= args.size()) |
| { |
| std::stringstream aStrStream; |
| aStrStream << "language name missing" << std::endl; |
| throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() ); |
| } |
| |
| lang = args[i]; |
| } |
| else if (args[i].compare("-hid") == 0) |
| { |
| ++i; |
| throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, "obsolete -hid argument used" ); |
| } |
| else if (args[i].compare("-add") == 0) |
| { |
| std::string addFile, addFileUnderPath; |
| ++i; |
| if (i >= args.size()) |
| { |
| std::stringstream aStrStream; |
| aStrStream << "pathname missing" << std::endl; |
| throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() ); |
| } |
| |
| addFileUnderPath = args[i]; |
| ++i; |
| if (i >= args.size()) |
| { |
| std::stringstream aStrStream; |
| aStrStream << "pathname missing" << std::endl; |
| throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() ); |
| } |
| addFile = args[i]; |
| if (!addFileUnderPath.empty() && !addFile.empty()) |
| additionalFiles[addFileUnderPath] = addFile; |
| } |
| else |
| helpFiles.push_back(args[i]); |
| ++i; |
| } |
| |
| //We can be called from the helplinker executable or the extension manager |
| //In the latter case extsource is not used. |
| if( (pExtensionPath && pExtensionPath->length() > 0 && pOfficeHelpPath) |
| || !extsource.empty()) |
| { |
| bExtensionMode = true; |
| if (!extsource.empty()) |
| { |
| //called from helplinker.exe, pExtensionPath and pOfficeHelpPath |
| //should be NULL |
| sourceRoot = fs::path(extsource, fs::native); |
| extensionPath = sourceRoot.toUTF8(); |
| |
| if (extdestination.empty()) |
| { |
| std::stringstream aStrStream; |
| aStrStream << "-extlangdest is missing" << std::endl; |
| throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() ); |
| } |
| else |
| { |
| //Convert from system path to file URL!!! |
| fs::path p(extdestination, fs::native); |
| extensionDestination = p.toUTF8(); |
| } |
| } |
| else |
| { //called from extension manager |
| extensionPath = *pExtensionPath; |
| sourceRoot = fs::path(extensionPath); |
| extensionDestination = *pDestination; |
| } |
| //check if -src option was used. This option must not be used |
| //when extension help is compiled. |
| if (bSrcOption) |
| { |
| std::stringstream aStrStream; |
| aStrStream << "-src must not be used together with -extsource missing" << std::endl; |
| throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() ); |
| } |
| } |
| |
| if (!bExtensionMode && zipdir.empty()) |
| { |
| std::stringstream aStrStream; |
| aStrStream << "no index dir given" << std::endl; |
| throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() ); |
| } |
| |
| if (!bExtensionMode && idxCaptionStylesheet.empty() |
| || !extsource.empty() && idxCaptionStylesheet.empty()) |
| { |
| //No extension mode and extension mode using commandline |
| //!extsource.empty indicates extension mode using commandline |
| // -idxcaption paramter is required |
| std::stringstream aStrStream; |
| aStrStream << "no index caption stylesheet given" << std::endl; |
| throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() ); |
| } |
| else if ( bExtensionMode && extsource.empty()) |
| { |
| //This part is used when compileExtensionHelp is called from the extensions manager. |
| //If extension help is compiled using helplinker in the build process |
| rtl::OUString aIdxCaptionPathFileURL( *pOfficeHelpPath ); |
| aIdxCaptionPathFileURL += rtl::OUString::createFromAscii( "/idxcaption.xsl" ); |
| |
| rtl::OString aOStr_IdxCaptionPathFileURL( rtl::OUStringToOString |
| ( aIdxCaptionPathFileURL, fs::getThreadTextEncoding() ) ); |
| std::string aStdStr_IdxCaptionPathFileURL( aOStr_IdxCaptionPathFileURL.getStr() ); |
| |
| idxCaptionStylesheet = fs::path( aStdStr_IdxCaptionPathFileURL ); |
| } |
| |
| if (!bExtensionMode && idxContentStylesheet.empty() |
| || !extsource.empty() && idxContentStylesheet.empty()) |
| { |
| //No extension mode and extension mode using commandline |
| //!extsource.empty indicates extension mode using commandline |
| // -idxcontent paramter is required |
| std::stringstream aStrStream; |
| aStrStream << "no index content stylesheet given" << std::endl; |
| throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() ); |
| } |
| else if ( bExtensionMode && extsource.empty()) |
| { |
| //If extension help is compiled using helplinker in the build process |
| //then -idxcontent must be supplied |
| //This part is used when compileExtensionHelp is called from the extensions manager. |
| rtl::OUString aIdxContentPathFileURL( *pOfficeHelpPath ); |
| aIdxContentPathFileURL += rtl::OUString::createFromAscii( "/idxcontent.xsl" ); |
| |
| rtl::OString aOStr_IdxContentPathFileURL( rtl::OUStringToOString |
| ( aIdxContentPathFileURL, fs::getThreadTextEncoding() ) ); |
| std::string aStdStr_IdxContentPathFileURL( aOStr_IdxContentPathFileURL.getStr() ); |
| |
| idxContentStylesheet = fs::path( aStdStr_IdxContentPathFileURL ); |
| } |
| if (!bExtensionMode && embeddStylesheet.empty()) |
| { |
| std::stringstream aStrStream; |
| aStrStream << "no embedding resolving file given" << std::endl; |
| throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() ); |
| } |
| if (sourceRoot.empty()) |
| { |
| std::stringstream aStrStream; |
| aStrStream << "no sourceroot given" << std::endl; |
| throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() ); |
| } |
| if (!bExtensionMode && outputFile.empty()) |
| { |
| std::stringstream aStrStream; |
| aStrStream << "no output file given" << std::endl; |
| throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() ); |
| } |
| if (module.empty()) |
| { |
| std::stringstream aStrStream; |
| aStrStream << "module missing" << std::endl; |
| throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() ); |
| } |
| if (!bExtensionMode && lang.empty()) |
| { |
| std::stringstream aStrStream; |
| aStrStream << "language missing" << std::endl; |
| throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() ); |
| } |
| link(); |
| } |
| |
| int main(int argc, char**argv) |
| { |
| sal_uInt32 starttime = osl_getGlobalTimer(); |
| std::vector<std::string> args; |
| for (int i = 1; i < argc; ++i) |
| args.push_back(std::string(argv[i])); |
| try |
| { |
| HelpLinker* pHelpLinker = new HelpLinker(); |
| pHelpLinker->main( args ); |
| delete pHelpLinker; |
| } |
| catch( const HelpProcessingException& e ) |
| { |
| std::cerr << e.m_aErrorMsg; |
| exit(1); |
| } |
| sal_uInt32 endtime = osl_getGlobalTimer(); |
| #ifndef OS2 // YD @TODO@ crashes libc runtime :-( |
| std::cout << "time taken was " << (endtime-starttime)/1000.0 << " seconds" << std::endl; |
| #endif |
| return 0; |
| } |
| |
| // Variable to set an exception in "C" StructuredXMLErrorFunction |
| static const HelpProcessingException* GpXMLParsingException = NULL; |
| |
| extern "C" void StructuredXMLErrorFunction(void *userData, xmlErrorPtr error) |
| { |
| (void)userData; |
| (void)error; |
| |
| std::string aErrorMsg = error->message; |
| std::string aXMLParsingFile; |
| if( error->file != NULL ) |
| aXMLParsingFile = error->file; |
| int nXMLParsingLine = error->line; |
| HelpProcessingException* pException = new HelpProcessingException( aErrorMsg, aXMLParsingFile, nXMLParsingLine ); |
| GpXMLParsingException = pException; |
| |
| // Reset error handler |
| xmlSetStructuredErrorFunc( NULL, NULL ); |
| } |
| |
| HelpProcessingErrorInfo& HelpProcessingErrorInfo::operator=( const struct HelpProcessingException& e ) |
| { |
| m_eErrorClass = e.m_eErrorClass; |
| rtl::OString tmpErrorMsg( e.m_aErrorMsg.c_str() ); |
| m_aErrorMsg = rtl::OStringToOUString( tmpErrorMsg, fs::getThreadTextEncoding() ); |
| rtl::OString tmpXMLParsingFile( e.m_aXMLParsingFile.c_str() ); |
| m_aXMLParsingFile = rtl::OStringToOUString( tmpXMLParsingFile, fs::getThreadTextEncoding() ); |
| m_nXMLParsingLine = e.m_nXMLParsingLine; |
| return *this; |
| } |
| |
| |
| // Returns true in case of success, false in case of error |
| HELPLINKER_DLLPUBLIC bool compileExtensionHelp |
| ( |
| const rtl::OUString& aOfficeHelpPath, |
| const rtl::OUString& aExtensionName, |
| const rtl::OUString& aExtensionLanguageRoot, |
| sal_Int32 nXhpFileCount, const rtl::OUString* pXhpFiles, |
| const rtl::OUString& aDestination, |
| HelpProcessingErrorInfo& o_rHelpProcessingErrorInfo |
| ) |
| { |
| bool bSuccess = true; |
| |
| std::vector<std::string> args; |
| args.reserve(nXhpFileCount + 2); |
| args.push_back(std::string("-mod")); |
| rtl::OString aOExtensionName = rtl::OUStringToOString( aExtensionName, fs::getThreadTextEncoding() ); |
| args.push_back(std::string(aOExtensionName.getStr())); |
| |
| for( sal_Int32 iXhp = 0 ; iXhp < nXhpFileCount ; ++iXhp ) |
| { |
| rtl::OUString aXhpFile = pXhpFiles[iXhp]; |
| |
| rtl::OString aOXhpFile = rtl::OUStringToOString( aXhpFile, fs::getThreadTextEncoding() ); |
| args.push_back(std::string(aOXhpFile.getStr())); |
| } |
| |
| rtl::OString aOExtensionLanguageRoot = rtl::OUStringToOString( aExtensionLanguageRoot, fs::getThreadTextEncoding() ); |
| const char* pExtensionPath = aOExtensionLanguageRoot.getStr(); |
| std::string aStdStrExtensionPath = pExtensionPath; |
| rtl::OString aODestination = rtl::OUStringToOString(aDestination, fs::getThreadTextEncoding()); |
| const char* pDestination = aODestination.getStr(); |
| std::string aStdStrDestination = pDestination; |
| |
| // Set error handler |
| xmlSetStructuredErrorFunc( NULL, (xmlStructuredErrorFunc)StructuredXMLErrorFunction ); |
| try |
| { |
| HelpLinker* pHelpLinker = new HelpLinker(); |
| pHelpLinker->main( args, &aStdStrExtensionPath, &aStdStrDestination, &aOfficeHelpPath ); |
| delete pHelpLinker; |
| } |
| catch( const HelpProcessingException& e ) |
| { |
| if( GpXMLParsingException != NULL ) |
| { |
| o_rHelpProcessingErrorInfo = *GpXMLParsingException; |
| delete GpXMLParsingException; |
| GpXMLParsingException = NULL; |
| } |
| else |
| { |
| o_rHelpProcessingErrorInfo = e; |
| } |
| bSuccess = false; |
| } |
| // Reset error handler |
| xmlSetStructuredErrorFunc( NULL, NULL ); |
| |
| // i83624: Tree files |
| ::rtl::OUString aTreeFileURL = aExtensionLanguageRoot; |
| aTreeFileURL += rtl::OUString::createFromAscii( "/help.tree" ); |
| osl::DirectoryItem aTreeFileItem; |
| osl::FileBase::RC rcGet = osl::DirectoryItem::get( aTreeFileURL, aTreeFileItem ); |
| osl::FileStatus aFileStatus( FileStatusMask_FileSize ); |
| if( rcGet == osl::FileBase::E_None && |
| aTreeFileItem.getFileStatus( aFileStatus ) == osl::FileBase::E_None && |
| aFileStatus.isValid( FileStatusMask_FileSize ) ) |
| { |
| sal_uInt64 ret, len = aFileStatus.getFileSize(); |
| char* s = new char[ int(len) ]; // the buffer to hold the installed files |
| osl::File aFile( aTreeFileURL ); |
| aFile.open( OpenFlag_Read ); |
| aFile.read( s, len, ret ); |
| aFile.close(); |
| |
| XML_Parser parser = XML_ParserCreate( 0 ); |
| int parsed = XML_Parse( parser, s, int( len ), true ); |
| |
| if( parsed == 0 ) |
| { |
| XML_Error nError = XML_GetErrorCode( parser ); |
| o_rHelpProcessingErrorInfo.m_eErrorClass = HELPPROCESSING_XMLPARSING_ERROR; |
| o_rHelpProcessingErrorInfo.m_aErrorMsg = rtl::OUString::createFromAscii( XML_ErrorString( nError ) );; |
| o_rHelpProcessingErrorInfo.m_aXMLParsingFile = aTreeFileURL; |
| // CRAHSES!!! o_rHelpProcessingErrorInfo.m_nXMLParsingLine = XML_GetCurrentLineNumber( parser ); |
| bSuccess = false; |
| } |
| |
| XML_ParserFree( parser ); |
| delete[] s; |
| } |
| |
| return bSuccess; |
| } |
| |
