LCOV - code coverage report
Current view: top level - usr/local/src/libreoffice/helpcompiler/source - HelpLinker.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 0 526 0.0 %
Date: 2013-07-09 Functions: 0 21 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include <HelpCompiler.hxx>
      21             : #include <HelpLinker.hxx>
      22             : 
      23             : #include <map>
      24             : 
      25             : #include <string.h>
      26             : #include <limits.h>
      27             : 
      28             : #include <libxslt/xslt.h>
      29             : #include <libxslt/xsltutils.h>
      30             : #include <libxslt/functions.h>
      31             : #include <libxslt/extensions.h>
      32             : 
      33             : #include <sal/main.h>
      34             : #include <sal/types.h>
      35             : #include <osl/time.h>
      36             : #include <rtl/bootstrap.hxx>
      37             : 
      38             : #include <expat.h>
      39             : 
      40           0 : IndexerPreProcessor::IndexerPreProcessor
      41             :     ( const std::string& aModuleName, const fs::path& fsIndexBaseDir,
      42             :       const fs::path& idxCaptionStylesheet, const fs::path& idxContentStylesheet )
      43             :         : m_aModuleName( aModuleName )
      44           0 :         , m_fsIndexBaseDir( fsIndexBaseDir )
      45             : {
      46           0 :     m_fsCaptionFilesDirName = fsIndexBaseDir / "caption";
      47           0 :     fs::create_directory( m_fsCaptionFilesDirName );
      48             : 
      49           0 :     m_fsContentFilesDirName = fsIndexBaseDir / "content";
      50           0 :     fs::create_directory( m_fsContentFilesDirName );
      51             : 
      52             :     m_xsltStylesheetPtrCaption = xsltParseStylesheetFile
      53           0 :         ((const xmlChar *)idxCaptionStylesheet.native_file_string().c_str());
      54             :     m_xsltStylesheetPtrContent = xsltParseStylesheetFile
      55           0 :         ((const xmlChar *)idxContentStylesheet.native_file_string().c_str());
      56           0 : }
      57             : 
      58           0 : IndexerPreProcessor::~IndexerPreProcessor()
      59             : {
      60           0 :     if( m_xsltStylesheetPtrCaption )
      61           0 :         xsltFreeStylesheet( m_xsltStylesheetPtrCaption );
      62           0 :     if( m_xsltStylesheetPtrContent )
      63           0 :         xsltFreeStylesheet( m_xsltStylesheetPtrContent );
      64           0 : }
      65             : 
      66           0 : std::string getEncodedPath( const std::string& Path )
      67             : {
      68           0 :     OString aOStr_Path( Path.c_str() );
      69             :     OUString aOUStr_Path( OStringToOUString
      70           0 :         ( aOStr_Path, fs::getThreadTextEncoding() ) );
      71           0 :     OUString aPathURL;
      72           0 :     osl::File::getFileURLFromSystemPath( aOUStr_Path, aPathURL );
      73             :     OString aOStr_PathURL( OUStringToOString
      74           0 :         ( aPathURL, fs::getThreadTextEncoding() ) );
      75           0 :     std::string aStdStr_PathURL( aOStr_PathURL.getStr() );
      76           0 :     return aStdStr_PathURL;
      77             : }
      78             : 
      79           0 : void IndexerPreProcessor::processDocument
      80             :     ( xmlDocPtr doc, const std::string &EncodedDocPath )
      81             : {
      82           0 :     std::string aStdStr_EncodedDocPathURL = getEncodedPath( EncodedDocPath );
      83             : 
      84           0 :     if( m_xsltStylesheetPtrCaption )
      85             :     {
      86           0 :         xmlDocPtr resCaption = xsltApplyStylesheet( m_xsltStylesheetPtrCaption, doc, NULL );
      87           0 :         xmlNodePtr pResNodeCaption = resCaption->xmlChildrenNode;
      88           0 :         if( pResNodeCaption )
      89             :         {
      90           0 :             fs::path fsCaptionPureTextFile_docURL = m_fsCaptionFilesDirName / aStdStr_EncodedDocPathURL;
      91             : #ifdef WNT     //We need _wfopen to support long file paths on Windows XP
      92             :             FILE* pFile_docURL = _wfopen(
      93             :                 fsCaptionPureTextFile_docURL.native_file_string_w(), L"w" );
      94             : #else
      95             :             FILE* pFile_docURL = fopen(
      96           0 :                 fsCaptionPureTextFile_docURL.native_file_string().c_str(), "w" );
      97             : #endif
      98           0 :             if( pFile_docURL )
      99             :             {
     100           0 :                 fprintf( pFile_docURL, "%s\n", pResNodeCaption->content );
     101           0 :                 fclose( pFile_docURL );
     102           0 :             }
     103             :         }
     104           0 :         xmlFreeDoc(resCaption);
     105             :     }
     106             : 
     107           0 :     if( m_xsltStylesheetPtrContent )
     108             :     {
     109           0 :         xmlDocPtr resContent = xsltApplyStylesheet( m_xsltStylesheetPtrContent, doc, NULL );
     110           0 :         xmlNodePtr pResNodeContent = resContent->xmlChildrenNode;
     111           0 :         if( pResNodeContent )
     112             :         {
     113           0 :             fs::path fsContentPureTextFile_docURL = m_fsContentFilesDirName / aStdStr_EncodedDocPathURL;
     114             : #ifdef WNT     //We need _wfopen to support long file paths on Windows XP
     115             :             FILE* pFile_docURL = _wfopen(
     116             :                 fsContentPureTextFile_docURL.native_file_string_w(), L"w" );
     117             : #else
     118             :             FILE* pFile_docURL = fopen(
     119           0 :                 fsContentPureTextFile_docURL.native_file_string().c_str(), "w" );
     120             : #endif
     121           0 :             if( pFile_docURL )
     122             :             {
     123           0 :                 fprintf( pFile_docURL, "%s\n", pResNodeContent->content );
     124           0 :                 fclose( pFile_docURL );
     125           0 :             }
     126             :         }
     127           0 :         xmlFreeDoc(resContent);
     128           0 :     }
     129           0 : }
     130             : 
     131           0 : struct Data
     132             : {
     133             :     std::vector<std::string> _idList;
     134             :     typedef std::vector<std::string>::const_iterator cIter;
     135             : 
     136           0 :     void append(const std::string &id)
     137             :     {
     138           0 :         _idList.push_back(id);
     139           0 :     }
     140             : 
     141           0 :     std::string getString() const
     142             :     {
     143           0 :         std::string ret;
     144           0 :         cIter aEnd = _idList.end();
     145           0 :         for (cIter aIter = _idList.begin(); aIter != aEnd; ++aIter)
     146           0 :             ret += *aIter + ";";
     147           0 :         return ret;
     148             :     }
     149             : };
     150             : 
     151           0 : void writeKeyValue_DBHelp( FILE* pFile, const std::string& aKeyStr, const std::string& aValueStr )
     152             : {
     153           0 :     if( pFile == NULL )
     154           0 :         return;
     155           0 :     char cLF = 10;
     156           0 :     unsigned int nKeyLen = aKeyStr.length();
     157           0 :     unsigned int nValueLen = aValueStr.length();
     158           0 :     fprintf( pFile, "%x ", nKeyLen );
     159           0 :     if( nKeyLen > 0 )
     160             :     {
     161           0 :         if (fwrite( aKeyStr.c_str(), 1, nKeyLen, pFile ) != nKeyLen)
     162           0 :             fprintf(stderr, "fwrite to db failed\n");
     163             :     }
     164           0 :     if (fprintf( pFile, " %x ", nValueLen ) < 0)
     165           0 :         fprintf(stderr, "fwrite to db failed\n");
     166           0 :     if( nValueLen > 0 )
     167             :     {
     168           0 :         if (fwrite( aValueStr.c_str(), 1, nValueLen, pFile ) != nValueLen)
     169           0 :             fprintf(stderr, "fwrite to db failed\n");
     170             :     }
     171           0 :     if (fprintf( pFile, "%c", cLF ) < 0)
     172           0 :         fprintf(stderr, "fwrite to db failed\n");
     173             : }
     174             : 
     175           0 : class HelpKeyword
     176             : {
     177             : private:
     178             :     typedef boost::unordered_map<std::string, Data, pref_hash> DataHashtable;
     179             :     DataHashtable _hash;
     180             : 
     181             : public:
     182           0 :     void insert(const std::string &key, const std::string &id)
     183             :     {
     184           0 :         Data &data = _hash[key];
     185           0 :         data.append(id);
     186           0 :     }
     187             : 
     188           0 :     void dump_DBHelp( const fs::path& rFileName )
     189             :     {
     190             : #ifdef WNT     //We need _wfopen to support long file paths on Windows XP
     191             :         FILE* pFile = _wfopen( rFileName.native_file_string_w(), L"wb" );
     192             : #else
     193           0 :         FILE* pFile = fopen( rFileName.native_file_string().c_str(), "wb" );
     194             : #endif
     195           0 :         if( pFile == NULL )
     196           0 :             return;
     197             : 
     198           0 :         DataHashtable::const_iterator aEnd = _hash.end();
     199           0 :         for (DataHashtable::const_iterator aIter = _hash.begin(); aIter != aEnd; ++aIter)
     200           0 :             writeKeyValue_DBHelp( pFile, aIter->first, aIter->second.getString() );
     201             : 
     202           0 :         fclose( pFile );
     203             :     }
     204             : };
     205             : 
     206             : namespace URLEncoder
     207             : {
     208           0 :     static std::string encode(const std::string &rIn)
     209             :     {
     210           0 :         const char *good = "!$&'()*+,-.=@_";
     211             :         static const char hex[17] = "0123456789ABCDEF";
     212             : 
     213           0 :         std::string result;
     214           0 :         for (size_t i=0; i < rIn.length(); ++i)
     215             :         {
     216           0 :             unsigned char c = rIn[i];
     217           0 :             if (isalnum (c) || strchr (good, c))
     218           0 :                 result += c;
     219             :             else {
     220           0 :                 result += '%';
     221           0 :                 result += hex[c >> 4];
     222           0 :                 result += hex[c & 0xf];
     223             :             }
     224             :         }
     225           0 :         return result;
     226             :     }
     227             : }
     228             : 
     229           0 : void HelpLinker::addBookmark( FILE* pFile_DBHelp, std::string thishid,
     230             :         const std::string& fileB, const std::string& anchorB,
     231             :         const std::string& jarfileB, const std::string& titleB)
     232             : {
     233             :     HCDBG(std::cerr << "HelpLinker::addBookmark " << thishid << " " <<
     234             :         fileB << " " << anchorB << " " << jarfileB << " " << titleB << std::endl);
     235             : 
     236           0 :     thishid = URLEncoder::encode(thishid);
     237             : 
     238           0 :     int fileLen = fileB.length();
     239           0 :     if (!anchorB.empty())
     240           0 :         fileLen += (1 + anchorB.length());
     241           0 :     int dataLen = 1 + fileLen + 1 + jarfileB.length() + 1 + titleB.length();
     242             : 
     243           0 :     std::vector<unsigned char> dataB(dataLen);
     244           0 :     size_t i = 0;
     245           0 :     dataB[i++] = static_cast<unsigned char>(fileLen);
     246           0 :     for (size_t j = 0; j < fileB.length(); ++j)
     247           0 :         dataB[i++] = static_cast<unsigned char>(fileB[j]);
     248           0 :     if (!anchorB.empty())
     249             :     {
     250           0 :         dataB[i++] = '#';
     251           0 :         for (size_t j = 0; j < anchorB.length(); ++j)
     252           0 :             dataB[i++] = anchorB[j];
     253             :     }
     254           0 :     dataB[i++] = static_cast<unsigned char>(jarfileB.length());
     255           0 :     for (size_t j = 0; j < jarfileB.length(); ++j)
     256           0 :         dataB[i++] = jarfileB[j];
     257             : 
     258           0 :     dataB[i++] = static_cast<unsigned char>(titleB.length());
     259           0 :     for (size_t j = 0; j < titleB.length(); ++j)
     260           0 :         dataB[i++] = titleB[j];
     261             : 
     262           0 :     if( pFile_DBHelp != NULL )
     263             :     {
     264           0 :         std::string aValueStr( dataB.begin(), dataB.end() );
     265           0 :         writeKeyValue_DBHelp( pFile_DBHelp, thishid, aValueStr );
     266           0 :     }
     267           0 : }
     268             : 
     269           0 : void HelpLinker::initIndexerPreProcessor()
     270             : {
     271           0 :     if( m_pIndexerPreProcessor )
     272           0 :         delete m_pIndexerPreProcessor;
     273           0 :     std::string mod = module;
     274           0 :     std::transform (mod.begin(), mod.end(), mod.begin(), tocharlower);
     275             :     m_pIndexerPreProcessor = new IndexerPreProcessor( mod, indexDirParentName,
     276           0 :          idxCaptionStylesheet, idxContentStylesheet );
     277           0 : }
     278             : 
     279             : /**
     280             : *
     281             : */
     282           0 : void HelpLinker::link() throw( HelpProcessingException )
     283             : {
     284           0 :     bool bIndexForExtension = true;
     285             : 
     286           0 :     if( bExtensionMode )
     287             :     {
     288           0 :         indexDirParentName = extensionDestination;
     289             :     }
     290             :     else
     291             :     {
     292           0 :         indexDirParentName = zipdir;
     293           0 :         fs::create_directory(indexDirParentName);
     294             :     }
     295             : 
     296           0 :     std::string mod = module;
     297           0 :     std::transform (mod.begin(), mod.end(), mod.begin(), tocharlower);
     298             : 
     299             :     // do the work here
     300             :     // continue with introduction of the overall process thing into the
     301             :     // here all hzip files will be worked on
     302           0 :     std::string appl = mod;
     303           0 :     if (appl[0] == 's')
     304           0 :         appl = appl.substr(1);
     305             : 
     306           0 :     bool bUse_ = true;
     307           0 :     if( !bExtensionMode )
     308           0 :         bUse_ = false;
     309             : 
     310           0 :     fs::path helpTextFileName_DBHelp(indexDirParentName / (mod + (bUse_ ? ".ht_" : ".ht")));
     311             : #ifdef WNT
     312             :     //We need _wfopen to support long file paths on Windows XP
     313             :     FILE* pFileHelpText_DBHelp = _wfopen
     314             :         ( helpTextFileName_DBHelp.native_file_string_w(), L"wb" );
     315             : #else
     316             : 
     317             :     FILE* pFileHelpText_DBHelp = fopen
     318           0 :         ( helpTextFileName_DBHelp.native_file_string().c_str(), "wb" );
     319             : #endif
     320             : 
     321           0 :     fs::path dbBaseFileName_DBHelp(indexDirParentName / (mod + (bUse_ ? ".db_" : ".db")));
     322             : #ifdef WNT
     323             :     //We need _wfopen to support long file paths on Windows XP
     324             :     FILE* pFileDbBase_DBHelp = _wfopen
     325             :         ( dbBaseFileName_DBHelp.native_file_string_w(), L"wb" );
     326             : #else
     327             :     FILE* pFileDbBase_DBHelp = fopen
     328           0 :         ( dbBaseFileName_DBHelp.native_file_string().c_str(), "wb" );
     329             : #endif
     330             : 
     331           0 :     fs::path keyWordFileName_DBHelp(indexDirParentName / (mod + (bUse_ ? ".key_" : ".key")));
     332             : 
     333           0 :     HelpKeyword helpKeyword;
     334             : 
     335             :     // catch HelpProcessingException to avoid locking data bases
     336             :     try
     337             :     {
     338             : 
     339             :     // lastly, initialize the indexBuilder
     340           0 :     if ( (!bExtensionMode || bIndexForExtension) && !helpFiles.empty())
     341           0 :         initIndexerPreProcessor();
     342             : 
     343             :     // here we start our loop over the hzip files.
     344           0 :     HashSet::iterator end = helpFiles.end();
     345           0 :     for (HashSet::iterator iter = helpFiles.begin(); iter != end; ++iter)
     346             :     {
     347             :         // process one file
     348             :         // streamTable contains the streams in the hzip file
     349           0 :         StreamTable streamTable;
     350           0 :         const std::string &xhpFileName = *iter;
     351             : 
     352           0 :         if (!bExtensionMode && xhpFileName.rfind(".xhp") != xhpFileName.length()-4)
     353             :         {
     354             :             // only work on .xhp - files
     355             :             SAL_WARN("helpcompiler",
     356             :                 "ERROR: input list entry '"
     357             :                     << xhpFileName
     358             :                     << "' has the wrong extension (only files with extension .xhp "
     359             :                     << "are accepted)");
     360             : 
     361           0 :             continue;
     362             :         }
     363             : 
     364           0 :         fs::path langsourceRoot(sourceRoot);
     365           0 :         fs::path xhpFile;
     366             : 
     367           0 :         if( bExtensionMode )
     368             :         {
     369             :             // langsourceRoot == sourceRoot for extensions
     370           0 :             std::string xhpFileNameComplete( extensionPath );
     371           0 :             xhpFileNameComplete.append( '/' + xhpFileName );
     372           0 :             xhpFile = fs::path( xhpFileNameComplete );
     373             :         }
     374             :         else
     375             :         {
     376           0 :             langsourceRoot.append( "/" );
     377           0 :             if ( m_bUseLangRoot )
     378           0 :                 langsourceRoot.append( lang + '/' );
     379           0 :             xhpFile = fs::path(xhpFileName, fs::native);
     380             :         }
     381             : 
     382             :         HelpCompiler hc( streamTable, xhpFile, langsourceRoot, zipdir,
     383           0 :             compactStylesheet, embeddStylesheet, module, lang, bExtensionMode );
     384             : 
     385             :         HCDBG(std::cerr << "before compile of " << xhpFileName << std::endl);
     386           0 :         bool success = hc.compile();
     387             :         HCDBG(std::cerr << "after compile of " << xhpFileName << std::endl);
     388             : 
     389           0 :         if (!success && !bExtensionMode)
     390             :         {
     391           0 :             std::stringstream aStrStream;
     392             :             aStrStream <<
     393           0 :                 "\nERROR: compiling help particle '"
     394           0 :                     << xhpFileName
     395           0 :                     << "' for language '"
     396           0 :                     << lang
     397           0 :                     << "' failed!";
     398           0 :             throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() );
     399             :         }
     400             : 
     401           0 :         if (!m_bCreateIndex)
     402           0 :             continue;
     403             : 
     404           0 :         std::string documentPath = streamTable.document_path;
     405           0 :         if (documentPath.find("/") == 0)
     406           0 :             documentPath = documentPath.substr(1);
     407             : 
     408           0 :         std::string documentJarfile = streamTable.document_module + ".jar";
     409             : 
     410           0 :         std::string documentTitle = streamTable.document_title;
     411           0 :         if (documentTitle.empty())
     412           0 :             documentTitle = "<notitle>";
     413             : 
     414           0 :         const std::string& fileB = documentPath;
     415           0 :         const std::string& jarfileB = documentJarfile;
     416           0 :         std::string& titleB = documentTitle;
     417             : 
     418             :         // add once this as its own id.
     419           0 :         addBookmark( pFileDbBase_DBHelp, documentPath, fileB, std::string(), jarfileB, titleB);
     420             : 
     421           0 :         const HashSet *hidlist = streamTable.appl_hidlist;
     422           0 :         if (!hidlist)
     423           0 :             hidlist = streamTable.default_hidlist;
     424           0 :         if (hidlist && !hidlist->empty())
     425             :         {
     426             :             // now iterate over all elements of the hidlist
     427           0 :             HashSet::const_iterator aEnd = hidlist->end();
     428           0 :             for (HashSet::const_iterator hidListIter = hidlist->begin();
     429             :                 hidListIter != aEnd; ++hidListIter)
     430             :             {
     431           0 :                 std::string thishid = *hidListIter;
     432             : 
     433           0 :                 std::string anchorB;
     434           0 :                 size_t index = thishid.rfind('#');
     435           0 :                 if (index != std::string::npos)
     436             :                 {
     437           0 :                     anchorB = thishid.substr(1 + index);
     438           0 :                     thishid = thishid.substr(0, index);
     439             :                 }
     440           0 :                 addBookmark( pFileDbBase_DBHelp, thishid, fileB, anchorB, jarfileB, titleB);
     441           0 :             }
     442             :         }
     443             : 
     444             :         // now the keywords
     445           0 :         const Hashtable *anchorToLL = streamTable.appl_keywords;
     446           0 :         if (!anchorToLL)
     447           0 :             anchorToLL = streamTable.default_keywords;
     448           0 :         if (anchorToLL && !anchorToLL->empty())
     449             :         {
     450           0 :             std::string fakedHid = URLEncoder::encode(documentPath);
     451           0 :             Hashtable::const_iterator aEnd = anchorToLL->end();
     452           0 :             for (Hashtable::const_iterator enumer = anchorToLL->begin();
     453             :                 enumer != aEnd; ++enumer)
     454             :             {
     455           0 :                 const std::string &anchor = enumer->first;
     456             :                 addBookmark(pFileDbBase_DBHelp, documentPath, fileB,
     457           0 :                             anchor, jarfileB, titleB);
     458           0 :                 std::string totalId = fakedHid + "#" + anchor;
     459             :                 // std::cerr << hzipFileName << std::endl;
     460           0 :                 const LinkedList& ll = enumer->second;
     461           0 :                 LinkedList::const_iterator aOtherEnd = ll.end();
     462           0 :                 for (LinkedList::const_iterator llIter = ll.begin();
     463             :                     llIter != aOtherEnd; ++llIter)
     464             :                 {
     465           0 :                         helpKeyword.insert(*llIter, totalId);
     466             :                 }
     467           0 :             }
     468             : 
     469             :         }
     470             : 
     471             :         // and last the helptexts
     472           0 :         const Stringtable *helpTextHash = streamTable.appl_helptexts;
     473           0 :         if (!helpTextHash)
     474           0 :             helpTextHash = streamTable.default_helptexts;
     475           0 :         if (helpTextHash && !helpTextHash->empty())
     476             :         {
     477           0 :             Stringtable::const_iterator aEnd = helpTextHash->end();
     478           0 :             for (Stringtable::const_iterator helpTextIter = helpTextHash->begin();
     479             :                 helpTextIter != aEnd; ++helpTextIter)
     480             :             {
     481           0 :                 std::string helpTextId = helpTextIter->first;
     482           0 :                 const std::string& helpTextText = helpTextIter->second;
     483             : 
     484           0 :                 helpTextId = URLEncoder::encode(helpTextId);
     485             : 
     486           0 :                 if( pFileHelpText_DBHelp != NULL )
     487           0 :                     writeKeyValue_DBHelp( pFileHelpText_DBHelp, helpTextId, helpTextText );
     488           0 :             }
     489             :         }
     490             : 
     491             :         //IndexerPreProcessor
     492           0 :         if( !bExtensionMode || bIndexForExtension )
     493             :         {
     494             :             // now the indexing
     495           0 :             xmlDocPtr document = streamTable.appl_doc;
     496           0 :             if (!document)
     497           0 :                 document = streamTable.default_doc;
     498           0 :             if (document)
     499             :             {
     500           0 :                 std::string temp = module;
     501           0 :                 std::transform (temp.begin(), temp.end(), temp.begin(), tocharlower);
     502           0 :                 m_pIndexerPreProcessor->processDocument(document, URLEncoder::encode(documentPath) );
     503             :             }
     504             :         }
     505             : 
     506           0 :     } // while loop over hzip files ending
     507             : 
     508             :     } // try
     509           0 :     catch( const HelpProcessingException& )
     510             :     {
     511             :         // catch HelpProcessingException to avoid locking data bases
     512           0 :         if( pFileHelpText_DBHelp != NULL )
     513           0 :             fclose( pFileHelpText_DBHelp );
     514           0 :         if( pFileDbBase_DBHelp != NULL )
     515           0 :             fclose( pFileDbBase_DBHelp );
     516           0 :         throw;
     517             :     }
     518             : 
     519           0 :     if( pFileHelpText_DBHelp != NULL )
     520           0 :         fclose( pFileHelpText_DBHelp );
     521           0 :     if( pFileDbBase_DBHelp != NULL )
     522           0 :         fclose( pFileDbBase_DBHelp );
     523             : 
     524           0 :     helpKeyword.dump_DBHelp( keyWordFileName_DBHelp);
     525             : 
     526           0 :     if( !bExtensionMode )
     527             :     {
     528             :         // New index
     529           0 :         Stringtable::iterator aEnd = additionalFiles.end();
     530           0 :         for (Stringtable::iterator enumer = additionalFiles.begin(); enumer != aEnd;
     531             :             ++enumer)
     532             :         {
     533           0 :             const std::string &additionalFileName = enumer->second;
     534           0 :             const std::string &additionalFileKey = enumer->first;
     535             : 
     536           0 :             fs::path fsAdditionalFileName( additionalFileName, fs::native );
     537             :             HCDBG({
     538             :                     std::string aNativeStr = fsAdditionalFileName.native_file_string();
     539             :                     const char* pStr = aNativeStr.c_str();
     540             :                     std::cerr << pStr << std::endl;
     541             :             });
     542             : 
     543           0 :             fs::path fsTargetName( indexDirParentName / additionalFileKey );
     544             : 
     545           0 :             fs::copy( fsAdditionalFileName, fsTargetName );
     546           0 :         }
     547           0 :     }
     548           0 : }
     549             : 
     550             : 
     551           0 : void HelpLinker::main( std::vector<std::string> &args,
     552             :                        std::string* pExtensionPath, std::string* pDestination,
     553             :                        const OUString* pOfficeHelpPath )
     554             :     throw( HelpProcessingException )
     555             : {
     556           0 :     bExtensionMode = false;
     557           0 :     helpFiles.clear();
     558             : 
     559           0 :     if ((!args.empty()) && args[0][0] == '@')
     560             :     {
     561           0 :         std::vector<std::string> stringList;
     562           0 :         std::ifstream fileReader(args[0].substr(1).c_str());
     563             : 
     564           0 :         while (fileReader)
     565             :         {
     566           0 :             std::string token;
     567           0 :             fileReader >> token;
     568           0 :             if (!token.empty())
     569           0 :                 stringList.push_back(token);
     570           0 :         }
     571           0 :         fileReader.close();
     572             : 
     573           0 :         args = stringList;
     574             :     }
     575             : 
     576           0 :     size_t i = 0;
     577           0 :     bool bSrcOption = false;
     578           0 :     while (i < args.size())
     579             :     {
     580           0 :         if (args[i].compare("-extlangsrc") == 0)
     581             :         {
     582           0 :             ++i;
     583           0 :             if (i >= args.size())
     584             :             {
     585           0 :                 std::stringstream aStrStream;
     586           0 :                 aStrStream << "extension source missing" << std::endl;
     587           0 :                 throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() );
     588             :             }
     589           0 :             extsource = args[i];
     590             :         }
     591           0 :         else if (args[i].compare("-extlangdest") == 0)
     592             :         {
     593             :             //If this argument is not provided then the location provided in -extsource will
     594             :             //also be the destination
     595           0 :             ++i;
     596           0 :             if (i >= args.size())
     597             :             {
     598           0 :                 std::stringstream aStrStream;
     599           0 :                 aStrStream << "extension destination missing" << std::endl;
     600           0 :                 throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() );
     601             :             }
     602           0 :             extdestination = args[i];
     603             :         }
     604           0 :         else if (args[i].compare("-src") == 0)
     605             :         {
     606           0 :             ++i;
     607           0 :             if (i >= args.size())
     608             :             {
     609           0 :                 std::stringstream aStrStream;
     610           0 :                 aStrStream << "sourceroot missing" << std::endl;
     611           0 :                 throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() );
     612             :             }
     613           0 :             bSrcOption = true;
     614           0 :             sourceRoot = fs::path(args[i], fs::native);
     615             :         }
     616           0 :         else if (args[i].compare("-compact") == 0)
     617             :         {
     618           0 :             ++i;
     619           0 :             if (i >= args.size())
     620             :             {
     621           0 :                 std::stringstream aStrStream;
     622           0 :                 aStrStream << "compactStylesheet missing" << std::endl;
     623           0 :                 throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() );
     624             :             }
     625             : 
     626           0 :             compactStylesheet = fs::path(args[i], fs::native);
     627             :         }
     628           0 :         else if (args[i].compare("-sty") == 0)
     629             :         {
     630           0 :             ++i;
     631           0 :             if (i >= args.size())
     632             :             {
     633           0 :                 std::stringstream aStrStream;
     634           0 :                 aStrStream << "embeddingStylesheet missing" << std::endl;
     635           0 :                 throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() );
     636             :             }
     637             : 
     638           0 :             embeddStylesheet = fs::path(args[i], fs::native);
     639             :         }
     640           0 :         else if (args[i].compare("-zipdir") == 0)
     641             :         {
     642           0 :             ++i;
     643           0 :             if (i >= args.size())
     644             :             {
     645           0 :                 std::stringstream aStrStream;
     646           0 :                 aStrStream << "idxtemp missing" << std::endl;
     647           0 :                 throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() );
     648             :             }
     649             : 
     650           0 :             zipdir = fs::path(args[i], fs::native);
     651             :         }
     652           0 :         else if (args[i].compare("-idxcaption") == 0)
     653             :         {
     654           0 :             ++i;
     655           0 :             if (i >= args.size())
     656             :             {
     657           0 :                 std::stringstream aStrStream;
     658           0 :                 aStrStream << "idxcaption stylesheet missing" << std::endl;
     659           0 :                 throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() );
     660             :             }
     661             : 
     662           0 :             idxCaptionStylesheet = fs::path(args[i], fs::native);
     663             :         }
     664           0 :         else if (args[i].compare("-idxcontent") == 0)
     665             :         {
     666           0 :             ++i;
     667           0 :             if (i >= args.size())
     668             :             {
     669           0 :                 std::stringstream aStrStream;
     670           0 :                 aStrStream << "idxcontent stylesheet missing" << std::endl;
     671           0 :                 throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() );
     672             :             }
     673             : 
     674           0 :             idxContentStylesheet = fs::path(args[i], fs::native);
     675             :         }
     676           0 :         else if (args[i].compare("-o") == 0)
     677             :         {
     678           0 :             ++i;
     679           0 :             if (i >= args.size())
     680             :             {
     681           0 :                 std::stringstream aStrStream;
     682           0 :                 aStrStream << "outputfilename missing" << std::endl;
     683           0 :                 throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() );
     684             :             }
     685             : 
     686           0 :             outputFile = fs::path(args[i], fs::native);
     687             :         }
     688           0 :         else if (args[i].compare("-mod") == 0)
     689             :         {
     690           0 :             ++i;
     691           0 :             if (i >= args.size())
     692             :             {
     693           0 :                 std::stringstream aStrStream;
     694           0 :                 aStrStream << "module name missing" << std::endl;
     695           0 :                 throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() );
     696             :             }
     697             : 
     698           0 :             module = args[i];
     699             :         }
     700           0 :         else if (args[i].compare("-lang") == 0)
     701             :         {
     702           0 :             ++i;
     703           0 :             if (i >= args.size())
     704             :             {
     705           0 :                 std::stringstream aStrStream;
     706           0 :                 aStrStream << "language name missing" << std::endl;
     707           0 :                 throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() );
     708             :             }
     709             : 
     710           0 :             lang = args[i];
     711             :         }
     712           0 :         else if (args[i].compare("-hid") == 0)
     713             :         {
     714           0 :             ++i;
     715           0 :             throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, "obsolete -hid argument used" );
     716             :         }
     717           0 :         else if (args[i].compare("-add") == 0)
     718             :         {
     719           0 :             std::string addFile, addFileUnderPath;
     720           0 :             ++i;
     721           0 :             if (i >= args.size())
     722             :             {
     723           0 :                 std::stringstream aStrStream;
     724           0 :                 aStrStream << "pathname missing" << std::endl;
     725           0 :                 throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() );
     726             :             }
     727             : 
     728           0 :             addFileUnderPath = args[i];
     729           0 :             ++i;
     730           0 :             if (i >= args.size())
     731             :             {
     732           0 :                 std::stringstream aStrStream;
     733           0 :                 aStrStream << "pathname missing" << std::endl;
     734           0 :                 throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() );
     735             :             }
     736           0 :             addFile = args[i];
     737           0 :             if (!addFileUnderPath.empty() && !addFile.empty())
     738           0 :                 additionalFiles[addFileUnderPath] = addFile;
     739             :         }
     740           0 :         else if (args[i].compare("-nolangroot") == 0)
     741           0 :             m_bUseLangRoot = false;
     742           0 :         else if (args[i].compare("-noindex") == 0)
     743           0 :             m_bCreateIndex = false;
     744             :         else
     745           0 :             helpFiles.push_back(args[i]);
     746           0 :         ++i;
     747             :     }
     748             : 
     749             :     //We can be called from the helplinker executable or the extension manager
     750             :     //In the latter case extsource is not used.
     751           0 :     if( (pExtensionPath && pExtensionPath->length() > 0 && pOfficeHelpPath)
     752           0 :         || !extsource.empty())
     753             :     {
     754           0 :         bExtensionMode = true;
     755           0 :         if (!extsource.empty())
     756             :         {
     757             :             //called from helplinker.exe, pExtensionPath and pOfficeHelpPath
     758             :             //should be NULL
     759           0 :             sourceRoot = fs::path(extsource, fs::native);
     760           0 :             extensionPath = sourceRoot.toUTF8();
     761             : 
     762           0 :             if (extdestination.empty())
     763             :             {
     764           0 :                 std::stringstream aStrStream;
     765           0 :                 aStrStream << "-extlangdest is missing" << std::endl;
     766           0 :                 throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() );
     767             :             }
     768             :             else
     769             :             {
     770             :                 //Convert from system path to file URL!!!
     771           0 :                 fs::path p(extdestination, fs::native);
     772           0 :                 extensionDestination = p.toUTF8();
     773             :             }
     774             :         }
     775             :         else
     776             :         { //called from extension manager
     777           0 :             extensionPath = *pExtensionPath;
     778           0 :             sourceRoot = fs::path(extensionPath);
     779           0 :             extensionDestination = *pDestination;
     780             :         }
     781             :         //check if -src option was used. This option must not be used
     782             :         //when extension help is compiled.
     783           0 :         if (bSrcOption)
     784             :         {
     785           0 :             std::stringstream aStrStream;
     786           0 :             aStrStream << "-src must not be used together with -extsource missing" << std::endl;
     787           0 :             throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() );
     788             :         }
     789             :     }
     790             : 
     791           0 :     if (!bExtensionMode && zipdir.empty())
     792             :     {
     793           0 :         std::stringstream aStrStream;
     794           0 :         aStrStream << "no index dir given" << std::endl;
     795           0 :         throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() );
     796             :     }
     797             : 
     798           0 :     if ( (!bExtensionMode && idxCaptionStylesheet.empty())
     799           0 :         || (!extsource.empty() && idxCaptionStylesheet.empty()) )
     800             :     {
     801             :         //No extension mode and extension mode using commandline
     802             :         //!extsource.empty indicates extension mode using commandline
     803             :         // -idxcaption paramter is required
     804           0 :         std::stringstream aStrStream;
     805           0 :         aStrStream << "no index caption stylesheet given" << std::endl;
     806           0 :         throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() );
     807             :     }
     808           0 :     else if ( bExtensionMode &&  extsource.empty())
     809             :     {
     810             :         //This part is used when compileExtensionHelp is called from the extensions manager.
     811             :         //If extension help is compiled using helplinker in the build process
     812           0 :         OUString aIdxCaptionPathFileURL( *pOfficeHelpPath );
     813           0 :         aIdxCaptionPathFileURL += OUString("/idxcaption.xsl");
     814             : 
     815             :         OString aOStr_IdxCaptionPathFileURL( OUStringToOString
     816           0 :             ( aIdxCaptionPathFileURL, fs::getThreadTextEncoding() ) );
     817           0 :         std::string aStdStr_IdxCaptionPathFileURL( aOStr_IdxCaptionPathFileURL.getStr() );
     818             : 
     819           0 :         idxCaptionStylesheet = fs::path( aStdStr_IdxCaptionPathFileURL );
     820             :     }
     821             : 
     822           0 :     if ( (!bExtensionMode && idxContentStylesheet.empty())
     823           0 :         || (!extsource.empty() && idxContentStylesheet.empty()) )
     824             :     {
     825             :         //No extension mode and extension mode using commandline
     826             :         //!extsource.empty indicates extension mode using commandline
     827             :         // -idxcontent paramter is required
     828           0 :         std::stringstream aStrStream;
     829           0 :         aStrStream << "no index content stylesheet given" << std::endl;
     830           0 :         throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() );
     831             :     }
     832           0 :     else if ( bExtensionMode && extsource.empty())
     833             :     {
     834             :         //If extension help is compiled using helplinker in the build process
     835             :         //then  -idxcontent must be supplied
     836             :         //This part is used when compileExtensionHelp is called from the extensions manager.
     837           0 :         OUString aIdxContentPathFileURL( *pOfficeHelpPath );
     838           0 :         aIdxContentPathFileURL += OUString("/idxcontent.xsl");
     839             : 
     840             :         OString aOStr_IdxContentPathFileURL( OUStringToOString
     841           0 :             ( aIdxContentPathFileURL, fs::getThreadTextEncoding() ) );
     842           0 :         std::string aStdStr_IdxContentPathFileURL( aOStr_IdxContentPathFileURL.getStr() );
     843             : 
     844           0 :         idxContentStylesheet = fs::path( aStdStr_IdxContentPathFileURL );
     845             :     }
     846           0 :     if (!bExtensionMode && embeddStylesheet.empty())
     847             :     {
     848           0 :         std::stringstream aStrStream;
     849           0 :         aStrStream << "no embedding resolving file given" << std::endl;
     850           0 :         throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() );
     851             :     }
     852           0 :     if (sourceRoot.empty())
     853             :     {
     854           0 :         std::stringstream aStrStream;
     855           0 :         aStrStream << "no sourceroot given" << std::endl;
     856           0 :         throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() );
     857             :     }
     858           0 :     if (!bExtensionMode && outputFile.empty())
     859             :     {
     860           0 :         std::stringstream aStrStream;
     861           0 :         aStrStream << "no output file given" << std::endl;
     862           0 :         throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() );
     863             :     }
     864           0 :     if (module.empty())
     865             :     {
     866           0 :         std::stringstream aStrStream;
     867           0 :         aStrStream << "module missing" << std::endl;
     868           0 :         throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() );
     869             :     }
     870           0 :     if (!bExtensionMode && lang.empty())
     871             :     {
     872           0 :         std::stringstream aStrStream;
     873           0 :         aStrStream << "language missing" << std::endl;
     874           0 :         throw HelpProcessingException( HELPPROCESSING_GENERAL_ERROR, aStrStream.str() );
     875             :     }
     876           0 :     link();
     877           0 : }
     878             : 
     879             : // Variable to set an exception in "C" StructuredXMLErrorFunction
     880             : static const HelpProcessingException* GpXMLParsingException = NULL;
     881             : 
     882           0 : extern "C" void StructuredXMLErrorFunction(void *userData, xmlErrorPtr error)
     883             : {
     884             :     (void)userData;
     885             :     (void)error;
     886             : 
     887           0 :     std::string aErrorMsg = error->message;
     888           0 :     std::string aXMLParsingFile;
     889           0 :     if( error->file != NULL )
     890           0 :         aXMLParsingFile = error->file;
     891           0 :     int nXMLParsingLine = error->line;
     892           0 :     HelpProcessingException* pException = new HelpProcessingException( aErrorMsg, aXMLParsingFile, nXMLParsingLine );
     893           0 :     GpXMLParsingException = pException;
     894             : 
     895             :     // Reset error handler
     896           0 :     xmlSetStructuredErrorFunc( NULL, NULL );
     897           0 : }
     898             : 
     899           0 : HelpProcessingErrorInfo& HelpProcessingErrorInfo::operator=( const struct HelpProcessingException& e )
     900             : {
     901           0 :     m_eErrorClass = e.m_eErrorClass;
     902           0 :     OString tmpErrorMsg( e.m_aErrorMsg.c_str() );
     903           0 :     m_aErrorMsg = OStringToOUString( tmpErrorMsg, fs::getThreadTextEncoding() );
     904           0 :     OString tmpXMLParsingFile( e.m_aXMLParsingFile.c_str() );
     905           0 :     m_aXMLParsingFile = OStringToOUString( tmpXMLParsingFile, fs::getThreadTextEncoding() );
     906           0 :     m_nXMLParsingLine = e.m_nXMLParsingLine;
     907           0 :     return *this;
     908             : }
     909             : 
     910             : 
     911             : // Returns true in case of success, false in case of error
     912           0 : HELPLINKER_DLLPUBLIC bool compileExtensionHelp
     913             : (
     914             :     const OUString& aOfficeHelpPath,
     915             :     const OUString& aExtensionName,
     916             :     const OUString& aExtensionLanguageRoot,
     917             :     sal_Int32 nXhpFileCount, const OUString* pXhpFiles,
     918             :     const OUString& aDestination,
     919             :     HelpProcessingErrorInfo& o_rHelpProcessingErrorInfo
     920             : )
     921             : {
     922           0 :     bool bSuccess = true;
     923             : 
     924           0 :     std::vector<std::string> args;
     925           0 :     args.reserve(nXhpFileCount + 2);
     926           0 :     args.push_back(std::string("-mod"));
     927           0 :     OString aOExtensionName = OUStringToOString( aExtensionName, fs::getThreadTextEncoding() );
     928           0 :     args.push_back(std::string(aOExtensionName.getStr()));
     929             : 
     930           0 :     for( sal_Int32 iXhp = 0 ; iXhp < nXhpFileCount ; ++iXhp )
     931             :     {
     932           0 :         OUString aXhpFile = pXhpFiles[iXhp];
     933             : 
     934           0 :         OString aOXhpFile = OUStringToOString( aXhpFile, fs::getThreadTextEncoding() );
     935           0 :         args.push_back(std::string(aOXhpFile.getStr()));
     936           0 :     }
     937             : 
     938           0 :     OString aOExtensionLanguageRoot = OUStringToOString( aExtensionLanguageRoot, fs::getThreadTextEncoding() );
     939           0 :     const char* pExtensionPath = aOExtensionLanguageRoot.getStr();
     940           0 :     std::string aStdStrExtensionPath = pExtensionPath;
     941           0 :     OString aODestination = OUStringToOString(aDestination, fs::getThreadTextEncoding());
     942           0 :     const char* pDestination = aODestination.getStr();
     943           0 :     std::string aStdStrDestination = pDestination;
     944             : 
     945             :     // Set error handler
     946           0 :     xmlSetStructuredErrorFunc( NULL, (xmlStructuredErrorFunc)StructuredXMLErrorFunction );
     947             :     try
     948             :     {
     949           0 :         HelpLinker* pHelpLinker = new HelpLinker();
     950           0 :         pHelpLinker->main( args, &aStdStrExtensionPath, &aStdStrDestination, &aOfficeHelpPath );
     951           0 :         delete pHelpLinker;
     952             :     }
     953           0 :     catch( const HelpProcessingException& e )
     954             :     {
     955           0 :         if( GpXMLParsingException != NULL )
     956             :         {
     957           0 :             o_rHelpProcessingErrorInfo = *GpXMLParsingException;
     958           0 :             delete GpXMLParsingException;
     959           0 :             GpXMLParsingException = NULL;
     960             :         }
     961             :         else
     962             :         {
     963           0 :             o_rHelpProcessingErrorInfo = e;
     964             :         }
     965           0 :         bSuccess = false;
     966             :     }
     967             :     // Reset error handler
     968           0 :     xmlSetStructuredErrorFunc( NULL, NULL );
     969             : 
     970             :     // i83624: Tree files
     971             :     // The following basically checks if the help.tree is well formed XML.
     972             :     // Apparently there have been cases when translations contained
     973             :     // non-well-formed XML in the past.
     974           0 :     OUString aTreeFileURL = aExtensionLanguageRoot;
     975           0 :     aTreeFileURL += OUString("/help.tree");
     976           0 :     osl::DirectoryItem aTreeFileItem;
     977           0 :     osl::FileBase::RC rcGet = osl::DirectoryItem::get( aTreeFileURL, aTreeFileItem );
     978           0 :     osl::FileStatus aFileStatus( osl_FileStatus_Mask_FileSize );
     979           0 :     if( rcGet == osl::FileBase::E_None &&
     980           0 :         aTreeFileItem.getFileStatus( aFileStatus ) == osl::FileBase::E_None &&
     981           0 :         aFileStatus.isValid( osl_FileStatus_Mask_FileSize ) )
     982             :     {
     983           0 :         sal_uInt64 ret, len = aFileStatus.getFileSize();
     984           0 :         char* s = new char[ int(len) ];  // the buffer to hold the installed files
     985           0 :         osl::File aFile( aTreeFileURL );
     986           0 :         aFile.open( osl_File_OpenFlag_Read );
     987           0 :         aFile.read( s, len, ret );
     988           0 :         aFile.close();
     989             : 
     990           0 :         XML_Parser parser = XML_ParserCreate( 0 );
     991           0 :         XML_Status parsed = XML_Parse( parser, s, int( len ), true );
     992             : 
     993           0 :         if (XML_STATUS_ERROR == parsed)
     994             :         {
     995           0 :             XML_Error nError = XML_GetErrorCode( parser );
     996           0 :             o_rHelpProcessingErrorInfo.m_eErrorClass = HELPPROCESSING_XMLPARSING_ERROR;
     997           0 :             o_rHelpProcessingErrorInfo.m_aErrorMsg = OUString::createFromAscii( XML_ErrorString( nError ) );;
     998           0 :             o_rHelpProcessingErrorInfo.m_aXMLParsingFile = aTreeFileURL;
     999             :             // CRAHSES!!! o_rHelpProcessingErrorInfo.m_nXMLParsingLine = XML_GetCurrentLineNumber( parser );
    1000           0 :             bSuccess = false;
    1001             :         }
    1002             : 
    1003           0 :         XML_ParserFree( parser );
    1004           0 :         delete[] s;
    1005             :     }
    1006             : 
    1007           0 :     return bSuccess;
    1008             : }
    1009             : 
    1010             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10