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 : #include <boost/scoped_array.hpp>
40 : #include <boost/scoped_ptr.hpp>
41 :
42 0 : IndexerPreProcessor::IndexerPreProcessor
43 : ( const std::string& aModuleName, const fs::path& fsIndexBaseDir,
44 : const fs::path& idxCaptionStylesheet, const fs::path& idxContentStylesheet )
45 : : m_aModuleName( aModuleName )
46 0 : , m_fsIndexBaseDir( fsIndexBaseDir )
47 : {
48 0 : m_fsCaptionFilesDirName = fsIndexBaseDir / "caption";
49 0 : fs::create_directory( m_fsCaptionFilesDirName );
50 :
51 0 : m_fsContentFilesDirName = fsIndexBaseDir / "content";
52 0 : fs::create_directory( m_fsContentFilesDirName );
53 :
54 : m_xsltStylesheetPtrCaption = xsltParseStylesheetFile
55 0 : (reinterpret_cast<const xmlChar *>(idxCaptionStylesheet.native_file_string().c_str()));
56 : m_xsltStylesheetPtrContent = xsltParseStylesheetFile
57 0 : (reinterpret_cast<const xmlChar *>(idxContentStylesheet.native_file_string().c_str()));
58 0 : }
59 :
60 0 : IndexerPreProcessor::~IndexerPreProcessor()
61 : {
62 0 : if( m_xsltStylesheetPtrCaption )
63 0 : xsltFreeStylesheet( m_xsltStylesheetPtrCaption );
64 0 : if( m_xsltStylesheetPtrContent )
65 0 : xsltFreeStylesheet( m_xsltStylesheetPtrContent );
66 0 : }
67 :
68 0 : std::string getEncodedPath( const std::string& Path )
69 : {
70 0 : OString aOStr_Path( Path.c_str() );
71 : OUString aOUStr_Path( OStringToOUString
72 0 : ( aOStr_Path, fs::getThreadTextEncoding() ) );
73 0 : OUString aPathURL;
74 0 : osl::File::getFileURLFromSystemPath( aOUStr_Path, aPathURL );
75 : OString aOStr_PathURL( OUStringToOString
76 0 : ( aPathURL, fs::getThreadTextEncoding() ) );
77 0 : std::string aStdStr_PathURL( aOStr_PathURL.getStr() );
78 0 : return aStdStr_PathURL;
79 : }
80 :
81 0 : void IndexerPreProcessor::processDocument
82 : ( xmlDocPtr doc, const std::string &EncodedDocPath )
83 : {
84 0 : std::string aStdStr_EncodedDocPathURL = getEncodedPath( EncodedDocPath );
85 :
86 0 : if( m_xsltStylesheetPtrCaption )
87 : {
88 0 : xmlDocPtr resCaption = xsltApplyStylesheet( m_xsltStylesheetPtrCaption, doc, NULL );
89 0 : xmlNodePtr pResNodeCaption = resCaption->xmlChildrenNode;
90 0 : if( pResNodeCaption )
91 : {
92 0 : fs::path fsCaptionPureTextFile_docURL = m_fsCaptionFilesDirName / aStdStr_EncodedDocPathURL;
93 : #ifdef WNT //We need _wfopen to support long file paths on Windows XP
94 : FILE* pFile_docURL = _wfopen(
95 : fsCaptionPureTextFile_docURL.native_file_string_w(), L"w" );
96 : #else
97 : FILE* pFile_docURL = fopen(
98 0 : fsCaptionPureTextFile_docURL.native_file_string().c_str(), "w" );
99 : #endif
100 0 : if( pFile_docURL )
101 : {
102 0 : fprintf( pFile_docURL, "%s\n", pResNodeCaption->content );
103 0 : fclose( pFile_docURL );
104 0 : }
105 : }
106 0 : xmlFreeDoc(resCaption);
107 : }
108 :
109 0 : if( m_xsltStylesheetPtrContent )
110 : {
111 0 : xmlDocPtr resContent = xsltApplyStylesheet( m_xsltStylesheetPtrContent, doc, NULL );
112 0 : xmlNodePtr pResNodeContent = resContent->xmlChildrenNode;
113 0 : if( pResNodeContent )
114 : {
115 0 : fs::path fsContentPureTextFile_docURL = m_fsContentFilesDirName / aStdStr_EncodedDocPathURL;
116 : #ifdef WNT //We need _wfopen to support long file paths on Windows XP
117 : FILE* pFile_docURL = _wfopen(
118 : fsContentPureTextFile_docURL.native_file_string_w(), L"w" );
119 : #else
120 : FILE* pFile_docURL = fopen(
121 0 : fsContentPureTextFile_docURL.native_file_string().c_str(), "w" );
122 : #endif
123 0 : if( pFile_docURL )
124 : {
125 0 : fprintf( pFile_docURL, "%s\n", pResNodeContent->content );
126 0 : fclose( pFile_docURL );
127 0 : }
128 : }
129 0 : xmlFreeDoc(resContent);
130 0 : }
131 0 : }
132 :
133 0 : struct Data
134 : {
135 : std::vector<std::string> _idList;
136 : typedef std::vector<std::string>::const_iterator cIter;
137 :
138 0 : void append(const std::string &id)
139 : {
140 0 : _idList.push_back(id);
141 0 : }
142 :
143 0 : std::string getString() const
144 : {
145 0 : std::string ret;
146 0 : cIter aEnd = _idList.end();
147 0 : for (cIter aIter = _idList.begin(); aIter != aEnd; ++aIter)
148 0 : ret += *aIter + ";";
149 0 : return ret;
150 : }
151 : };
152 :
153 0 : void writeKeyValue_DBHelp( FILE* pFile, const std::string& aKeyStr, const std::string& aValueStr )
154 : {
155 0 : if( pFile == NULL )
156 0 : return;
157 0 : char cLF = 10;
158 0 : unsigned int nKeyLen = aKeyStr.length();
159 0 : unsigned int nValueLen = aValueStr.length();
160 0 : fprintf( pFile, "%x ", nKeyLen );
161 0 : if( nKeyLen > 0 )
162 : {
163 0 : if (fwrite( aKeyStr.c_str(), 1, nKeyLen, pFile ) != nKeyLen)
164 0 : fprintf(stderr, "fwrite to db failed\n");
165 : }
166 0 : if (fprintf( pFile, " %x ", nValueLen ) < 0)
167 0 : fprintf(stderr, "fwrite to db failed\n");
168 0 : if( nValueLen > 0 )
169 : {
170 0 : if (fwrite( aValueStr.c_str(), 1, nValueLen, pFile ) != nValueLen)
171 0 : fprintf(stderr, "fwrite to db failed\n");
172 : }
173 0 : if (fprintf( pFile, "%c", cLF ) < 0)
174 0 : fprintf(stderr, "fwrite to db failed\n");
175 : }
176 :
177 0 : class HelpKeyword
178 : {
179 : private:
180 : typedef std::unordered_map<std::string, Data, pref_hash> DataHashtable;
181 : DataHashtable _hash;
182 :
183 : public:
184 0 : void insert(const std::string &key, const std::string &id)
185 : {
186 0 : Data &data = _hash[key];
187 0 : data.append(id);
188 0 : }
189 :
190 0 : void dump_DBHelp( const fs::path& rFileName )
191 : {
192 : #ifdef WNT //We need _wfopen to support long file paths on Windows XP
193 : FILE* pFile = _wfopen( rFileName.native_file_string_w(), L"wb" );
194 : #else
195 0 : FILE* pFile = fopen( rFileName.native_file_string().c_str(), "wb" );
196 : #endif
197 0 : if( pFile == NULL )
198 0 : return;
199 :
200 0 : DataHashtable::const_iterator aEnd = _hash.end();
201 0 : for (DataHashtable::const_iterator aIter = _hash.begin(); aIter != aEnd; ++aIter)
202 0 : writeKeyValue_DBHelp( pFile, aIter->first, aIter->second.getString() );
203 :
204 0 : fclose( pFile );
205 : }
206 : };
207 :
208 : namespace URLEncoder
209 : {
210 0 : static std::string encode(const std::string &rIn)
211 : {
212 0 : const char *good = "!$&'()*+,-.=@_";
213 : static const char hex[17] = "0123456789ABCDEF";
214 :
215 0 : std::string result;
216 0 : for (size_t i=0; i < rIn.length(); ++i)
217 : {
218 0 : unsigned char c = rIn[i];
219 0 : if (isalnum (c) || strchr (good, c))
220 0 : result += c;
221 : else {
222 0 : result += '%';
223 0 : result += hex[c >> 4];
224 0 : result += hex[c & 0xf];
225 : }
226 : }
227 0 : return result;
228 : }
229 : }
230 :
231 0 : void HelpLinker::addBookmark( FILE* pFile_DBHelp, std::string thishid,
232 : const std::string& fileB, const std::string& anchorB,
233 : const std::string& jarfileB, const std::string& titleB)
234 : {
235 : HCDBG(std::cerr << "HelpLinker::addBookmark " << thishid << " " <<
236 : fileB << " " << anchorB << " " << jarfileB << " " << titleB << std::endl);
237 :
238 0 : thishid = URLEncoder::encode(thishid);
239 :
240 0 : int fileLen = fileB.length();
241 0 : if (!anchorB.empty())
242 0 : fileLen += (1 + anchorB.length());
243 0 : int dataLen = 1 + fileLen + 1 + jarfileB.length() + 1 + titleB.length();
244 :
245 0 : std::vector<unsigned char> dataB(dataLen);
246 0 : size_t i = 0;
247 0 : dataB[i++] = static_cast<unsigned char>(fileLen);
248 0 : for (size_t j = 0; j < fileB.length(); ++j)
249 0 : dataB[i++] = static_cast<unsigned char>(fileB[j]);
250 0 : if (!anchorB.empty())
251 : {
252 0 : dataB[i++] = '#';
253 0 : for (size_t j = 0; j < anchorB.length(); ++j)
254 0 : dataB[i++] = anchorB[j];
255 : }
256 0 : dataB[i++] = static_cast<unsigned char>(jarfileB.length());
257 0 : for (size_t j = 0; j < jarfileB.length(); ++j)
258 0 : dataB[i++] = jarfileB[j];
259 :
260 0 : dataB[i++] = static_cast<unsigned char>(titleB.length());
261 0 : for (size_t j = 0; j < titleB.length(); ++j)
262 0 : dataB[i++] = titleB[j];
263 :
264 0 : if( pFile_DBHelp != NULL )
265 : {
266 0 : std::string aValueStr( dataB.begin(), dataB.end() );
267 0 : writeKeyValue_DBHelp( pFile_DBHelp, thishid, aValueStr );
268 0 : }
269 0 : }
270 :
271 0 : void HelpLinker::initIndexerPreProcessor()
272 : {
273 0 : if( m_pIndexerPreProcessor )
274 0 : delete m_pIndexerPreProcessor;
275 0 : std::string mod = module;
276 0 : std::transform (mod.begin(), mod.end(), mod.begin(), tocharlower);
277 : m_pIndexerPreProcessor = new IndexerPreProcessor( mod, indexDirParentName,
278 0 : idxCaptionStylesheet, idxContentStylesheet );
279 0 : }
280 :
281 : /**
282 : *
283 : */
284 0 : void HelpLinker::link() throw(HelpProcessingException, BasicCodeTagger::TaggerException)
285 : {
286 :
287 0 : if( bExtensionMode )
288 : {
289 0 : indexDirParentName = extensionDestination;
290 : }
291 : else
292 : {
293 0 : indexDirParentName = zipdir;
294 0 : fs::create_directory(indexDirParentName);
295 : }
296 :
297 0 : std::string mod = module;
298 0 : std::transform (mod.begin(), mod.end(), mod.begin(), tocharlower);
299 :
300 : // do the work here
301 : // continue with introduction of the overall process thing into the
302 : // here all hzip files will be worked on
303 0 : std::string appl = mod;
304 0 : if (appl[0] == 's')
305 0 : appl = appl.substr(1);
306 :
307 0 : bool bUse_ = true;
308 0 : if( !bExtensionMode )
309 0 : bUse_ = false;
310 :
311 0 : fs::path helpTextFileName_DBHelp(indexDirParentName / (mod + (bUse_ ? ".ht_" : ".ht")));
312 : #ifdef WNT
313 : //We need _wfopen to support long file paths on Windows XP
314 : FILE* pFileHelpText_DBHelp = _wfopen
315 : ( helpTextFileName_DBHelp.native_file_string_w(), L"wb" );
316 : #else
317 :
318 : FILE* pFileHelpText_DBHelp = fopen
319 0 : ( helpTextFileName_DBHelp.native_file_string().c_str(), "wb" );
320 : #endif
321 :
322 0 : fs::path dbBaseFileName_DBHelp(indexDirParentName / (mod + (bUse_ ? ".db_" : ".db")));
323 : #ifdef WNT
324 : //We need _wfopen to support long file paths on Windows XP
325 : FILE* pFileDbBase_DBHelp = _wfopen
326 : ( dbBaseFileName_DBHelp.native_file_string_w(), L"wb" );
327 : #else
328 : FILE* pFileDbBase_DBHelp = fopen
329 0 : ( dbBaseFileName_DBHelp.native_file_string().c_str(), "wb" );
330 : #endif
331 :
332 0 : fs::path keyWordFileName_DBHelp(indexDirParentName / (mod + (bUse_ ? ".key_" : ".key")));
333 :
334 0 : HelpKeyword helpKeyword;
335 :
336 : // catch HelpProcessingException to avoid locking data bases
337 : try
338 : {
339 0 : bool bIndexForExtension = true;
340 : // lastly, initialize the indexBuilder
341 0 : if ( (!bExtensionMode || bIndexForExtension) && !helpFiles.empty())
342 0 : initIndexerPreProcessor();
343 :
344 : // here we start our loop over the hzip files.
345 0 : HashSet::iterator end = helpFiles.end();
346 0 : for (HashSet::iterator iter = helpFiles.begin(); iter != end; ++iter)
347 : {
348 : // process one file
349 : // streamTable contains the streams in the hzip file
350 0 : StreamTable streamTable;
351 0 : const std::string &xhpFileName = *iter;
352 :
353 0 : if (!bExtensionMode && xhpFileName.rfind(".xhp") != xhpFileName.length()-4)
354 : {
355 : // only work on .xhp - files
356 : SAL_WARN("helpcompiler",
357 : "ERROR: input list entry '"
358 : << xhpFileName
359 : << "' has the wrong extension (only files with extension .xhp 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 : }
507 :
508 : }
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 parameter 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 += "/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 parameter 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 += "/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 : 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, StructuredXMLErrorFunction );
947 : try
948 : {
949 0 : boost::scoped_ptr<HelpLinker> pHelpLinker(new HelpLinker());
950 0 : pHelpLinker->main( args, &aStdStrExtensionPath, &aStdStrDestination, &aOfficeHelpPath );
951 : }
952 0 : catch( const HelpProcessingException& e )
953 : {
954 0 : if( GpXMLParsingException != NULL )
955 : {
956 0 : o_rHelpProcessingErrorInfo = *GpXMLParsingException;
957 0 : delete GpXMLParsingException;
958 0 : GpXMLParsingException = NULL;
959 : }
960 : else
961 : {
962 0 : o_rHelpProcessingErrorInfo = e;
963 : }
964 0 : bSuccess = false;
965 : }
966 : // Reset error handler
967 0 : xmlSetStructuredErrorFunc( NULL, NULL );
968 :
969 : // i83624: Tree files
970 : // The following basically checks if the help.tree is well formed XML.
971 : // Apparently there have been cases when translations contained
972 : // non-well-formed XML in the past.
973 0 : OUString aTreeFileURL = aExtensionLanguageRoot + "/help.tree";
974 0 : osl::DirectoryItem aTreeFileItem;
975 0 : osl::FileBase::RC rcGet = osl::DirectoryItem::get( aTreeFileURL, aTreeFileItem );
976 0 : osl::FileStatus aFileStatus( osl_FileStatus_Mask_FileSize );
977 0 : if( rcGet == osl::FileBase::E_None &&
978 0 : aTreeFileItem.getFileStatus( aFileStatus ) == osl::FileBase::E_None &&
979 0 : aFileStatus.isValid( osl_FileStatus_Mask_FileSize ) )
980 : {
981 0 : sal_uInt64 ret, len = aFileStatus.getFileSize();
982 0 : boost::scoped_array<char> s(new char[ int(len) ]); // the buffer to hold the installed files
983 0 : osl::File aFile( aTreeFileURL );
984 0 : aFile.open( osl_File_OpenFlag_Read );
985 0 : aFile.read( s.get(), len, ret );
986 0 : aFile.close();
987 :
988 0 : XML_Parser parser = XML_ParserCreate( 0 );
989 0 : XML_Status parsed = XML_Parse( parser, s.get(), int( len ), true );
990 :
991 0 : if (XML_STATUS_ERROR == parsed)
992 : {
993 0 : XML_Error nError = XML_GetErrorCode( parser );
994 0 : o_rHelpProcessingErrorInfo.m_eErrorClass = HELPPROCESSING_XMLPARSING_ERROR;
995 0 : o_rHelpProcessingErrorInfo.m_aErrorMsg = OUString::createFromAscii( XML_ErrorString( nError ) );;
996 0 : o_rHelpProcessingErrorInfo.m_aXMLParsingFile = aTreeFileURL;
997 : // CRAHSES!!! o_rHelpProcessingErrorInfo.m_nXMLParsingLine = XML_GetCurrentLineNumber( parser );
998 0 : bSuccess = false;
999 : }
1000 :
1001 0 : XML_ParserFree( parser );
1002 : }
1003 :
1004 0 : return bSuccess;
1005 336 : }
1006 :
1007 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
