helpcompiler/source/HelpCompiler.cxx

   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
  21 #include <memory>
  22 #include <HelpCompiler.hxx>
  23 #include <BasCodeTagger.hxx>
  24 #include <limits.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <libxslt/xslt.h>
  28 #include <libxslt/xsltInternals.h>
  29 #include <libxslt/transform.h>
  30 #include <libxslt/xsltutils.h>
  31 #include <osl/thread.hxx>
  32 #include <chrono>
  33 #include<rtl/character.hxx>
  34
  35 static void impl_sleep( sal_uInt32 nSec )
  36 {
  37     osl::Thread::wait( std::chrono::seconds(nSec) );
  38 }
  39 HelpCompiler::HelpCompiler(StreamTable &in_streamTable, const fs::path &in_inputFile,
  40     const fs::path &in_src, const fs::path &in_zipdir, const fs::path &in_resCompactStylesheet,
  41     const fs::path &in_resEmbStylesheet, const std::string &in_module, const std::string &in_lang,
  42     bool in_bExtensionMode)
  43     : streamTable(in_streamTable), inputFile(in_inputFile),
  44     src(in_src), zipdir(in_zipdir), module(in_module), lang(in_lang), resCompactStylesheet(in_resCompactStylesheet),
  45     resEmbStylesheet(in_resEmbStylesheet), bExtensionMode( in_bExtensionMode )
  46 {
  47     xmlKeepBlanksDefaultValue = 0;
  48     char* os = getenv("OS");
  49     if (os)
  50     {
  51         gui = (strcmp(os, "WNT") ? "UNIX" : "WIN");
  52         gui = (strcmp(os, "MACOSX") ? gui : "MAC");
  53     }
  54 }
  55
  56 void HelpCompiler::tagBasicCodeExamples( xmlDocPtr doc )
  57 {
  58     try
  59     {
  60         BasicCodeTagger bct( doc );
  61         bct.tagBasicCodes();
  62     }
  63     catch ( BasicCodeTagger::TaggerException &ex )
  64     {
  65         if ( ex != BasicCodeTagger::EMPTY_DOCUMENT )
  66             throw;
  67     }
  68 }
  69
  70 xmlDocPtr HelpCompiler::compactXhpForJar( xmlDocPtr doc )
  71 {
  72     static xsltStylesheetPtr compact = nullptr;
  73     static const char *params[2 + 1];
  74     params[0] = nullptr;
  75     xmlDocPtr compacted;
  76
  77     if (!compact)
  78     {
  79         compact = xsltParseStylesheetFile(reinterpret_cast<const xmlChar *>(resCompactStylesheet.native_file_string().c_str()));
  80     }
  81
  82     compacted = xsltApplyStylesheet(compact, doc, params);
  83     return compacted;
  84 }
  85
  86 void HelpCompiler::saveXhpForJar( xmlDocPtr doc, const fs::path &filePath )
  87 {
  88     //save processed xhp document in ziptmp<module>_<lang>/text directory
  89 #ifdef _WIN32
  90     std::string pathSep = "\\";
  91 #else
  92     std::string pathSep = "/";
  93 #endif
  94     const std::string& sourceXhpPath = filePath.native_file_string();
  95     std::string zipdirPath = zipdir.native_file_string();
  96     const std::string srcdirPath( src.native_file_string() );
  97     // srcdirPath contains trailing /, but we want the file path with / at the beginning
  98     std::string jarXhpPath = sourceXhpPath.substr( srcdirPath.length() - 1 );
  99     std::string xhpFileName = jarXhpPath.substr( jarXhpPath.rfind( pathSep ) + 1 );
 100     jarXhpPath = jarXhpPath.substr( 0, jarXhpPath.rfind( pathSep ) );
 101     if ( !jarXhpPath.compare( 1, 11, "text" + pathSep + "sbasic" ) )
 102     {
 103         tagBasicCodeExamples( doc );
 104     }
 105     if ( !jarXhpPath.compare( 1, 11, "text" + pathSep + "shared" ) )
 106     {
 107         const size_t pos = zipdirPath.find( "ziptmp" );
 108         if ( pos != std::string::npos )
 109             zipdirPath.replace( pos + 6, module.length(), "shared" );
 110     }
 111     xmlDocPtr compacted = compactXhpForJar( doc );
 112     fs::create_directory( fs::path( zipdirPath + jarXhpPath, fs::native ) );
 113     if ( -1 == xmlSaveFormatFileEnc( (zipdirPath + jarXhpPath + pathSep + xhpFileName).c_str(), compacted, "utf-8", 0 ) )
 114         std::cerr << "Error saving file to " << (zipdirPath + jarXhpPath + pathSep + xhpFileName).c_str() << std::endl;
 115     xmlFreeDoc(compacted);
 116 }
 117
 118
 119 xmlDocPtr HelpCompiler::getSourceDocument(const fs::path &filePath)
 120 {
 121     static xsltStylesheetPtr cur = nullptr;
 122
 123     xmlDocPtr res;
 124     if( bExtensionMode )
 125     {
 126         res = xmlParseFile(filePath.native_file_string().c_str());
 127         if( !res ){
 128             impl_sleep( 3 );
 129             res = xmlParseFile(filePath.native_file_string().c_str());
 130         }
 131     }
 132     else
 133     {
 134         static const char *params[2 + 1];
 135         if (!cur)
 136         {
 137             static std::string fsroot('\'' + src.toUTF8() + '\'');
 138
 139             xmlSubstituteEntitiesDefault(1);
 140             xmlLoadExtDtdDefaultValue = 1;
 141             cur = xsltParseStylesheetFile(reinterpret_cast<const xmlChar *>(resEmbStylesheet.native_file_string().c_str()));
 142
 143             int nbparams = 0;
 144             params[nbparams++] = "fsroot";
 145             params[nbparams++] = fsroot.c_str();
 146             params[nbparams] = nullptr;
 147         }
 148         xmlDocPtr doc = xmlParseFile(filePath.native_file_string().c_str());
 149         if( !doc )
 150         {
 151             impl_sleep( 3 );
 152             doc = xmlParseFile(filePath.native_file_string().c_str());
 153         }
 154
 155         saveXhpForJar( doc, filePath );
 156
 157         res = xsltApplyStylesheet(cur, doc, params);
 158         xmlFreeDoc(doc);
 159     }
 160     return res;
 161 }
 162
 163 // returns a node representing the whole stuff compiled for the current
 164 // application.
 165 xmlNodePtr HelpCompiler::clone(xmlNodePtr node, const std::string& appl)
 166 {
 167     xmlNodePtr root = xmlCopyNode(node, 2);
 168     if (node->xmlChildrenNode)
 169     {
 170         xmlNodePtr list = node->xmlChildrenNode;
 171         while (list)
 172         {
 173             if (strcmp(reinterpret_cast<const char*>(list->name), "switchinline") == 0 || strcmp(reinterpret_cast<const char*>(list->name), "switch") == 0)
 174             {
 175                 std::string tmp="";
 176                 xmlChar * prop = xmlGetProp(list, reinterpret_cast<xmlChar const *>("select"));
 177                 if (prop != nullptr)
 178                 {
 179                     if (strcmp(reinterpret_cast<char *>(prop), "sys") == 0)
 180                     {
 181                         tmp = gui;
 182                     }
 183                     else if (strcmp(reinterpret_cast<char *>(prop), "appl") == 0)
 184                     {
 185                         tmp = appl;
 186                     }
 187                     xmlFree(prop);
 188                 }
 189                 if (tmp.compare("") != 0)
 190                 {
 191                     bool isCase=false;
 192                     xmlNodePtr caseList=list->xmlChildrenNode;
 193                     while (caseList)
 194                     {
 195                         xmlChar *select = xmlGetProp(caseList, reinterpret_cast<xmlChar const *>("select"));
 196                         if (select)
 197                         {
 198                             if (!strcmp(reinterpret_cast<char*>(select), tmp.c_str()) && !isCase)
 199                             {
 200                                 isCase=true;
 201                                 xmlNodePtr clp = caseList->xmlChildrenNode;
 202                                 while (clp)
 203                                 {
 204                                     xmlAddChild(root, clone(clp, appl));
 205                                     clp = clp->next;
 206                                 }
 207                             }
 208                             xmlFree(select);
 209                         }
 210                         else
 211                         {
 212                             if ((strcmp(reinterpret_cast<const char*>(caseList->name), "defaultinline") != 0) && (strcmp(reinterpret_cast<const char*>(caseList->name), "default") != 0))
 213                             {
 214                                 xmlAddChild(root, clone(caseList, appl));
 215                             }
 216                             else
 217                             {
 218                                 if (!isCase)
 219                                 {
 220                                     xmlNodePtr clp = caseList->xmlChildrenNode;
 221                                     while (clp)
 222                                     {
 223                                         xmlAddChild(root, clone(clp, appl));
 224                                         clp = clp->next;
 225                                     }
 226                                 }
 227                             }
 228                         }
 229                         caseList = caseList->next;
 230                     }
 231                 }
 232             }
 233             else
 234             {
 235                 xmlAddChild(root, clone(list, appl));
 236             }
 237             list = list->next;
 238         }
 239     }
 240     return root;
 241 }
 242
 243 class myparser
 244 {
 245 public:
 246     std::string documentId;
 247     std::string fileName;
 248     std::string title;
 249     std::unique_ptr<HashSet> hidlist;
 250     std::unique_ptr<Hashtable> keywords;
 251     std::unique_ptr<Stringtable> helptexts;
 252 private:
 253     HashSet extendedHelpText;
 254 public:
 255     myparser(const std::string &indocumentId, const std::string &infileName,
 256         const std::string &intitle) : documentId(indocumentId), fileName(infileName),
 257         title(intitle)
 258     {
 259         hidlist.reset(new HashSet);
 260         keywords.reset(new Hashtable);
 261         helptexts.reset(new Stringtable);
 262     }
 263     void traverse( xmlNodePtr parentNode );
 264 private:
 265     std::string dump(xmlNodePtr node);
 266 };
 267
 268 std::string myparser::dump(xmlNodePtr node)
 269 {
 270     std::string app;
 271     if (node->xmlChildrenNode)
 272     {
 273         xmlNodePtr list = node->xmlChildrenNode;
 274         while (list)
 275         {
 276             app += dump(list);
 277             list = list->next;
 278         }
 279     }
 280     if (xmlNodeIsText(node))
 281     {
 282         xmlChar *pContent = xmlNodeGetContent(node);
 283         app += std::string(reinterpret_cast<char*>(pContent));
 284         xmlFree(pContent);
 285     }
 286     return app;
 287 }
 288
 289 void trim(std::string& str)
 290 {
 291     std::string::size_type pos = str.find_last_not_of(' ');
 292     if(pos != std::string::npos)
 293     {
 294         str.erase(pos + 1);
 295         pos = str.find_first_not_of(' ');
 296         if(pos != std::string::npos)
 297             str.erase(0, pos);
 298     }
 299     else
 300         str.erase(str.begin(), str.end());
 301 }
 302
 303 void myparser::traverse( xmlNodePtr parentNode )
 304 {
 305     // traverse all nodes that belong to the parent
 306     xmlNodePtr test ;
 307     for (test = parentNode->xmlChildrenNode; test; test = test->next)
 308     {
 309         if (fileName.empty() && !strcmp(reinterpret_cast<const char*>(test->name), "filename"))
 310         {
 311             xmlNodePtr node = test->xmlChildrenNode;
 312             if (xmlNodeIsText(node))
 313             {
 314                 xmlChar *pContent = xmlNodeGetContent(node);
 315                 fileName = std::string(reinterpret_cast<char*>(pContent));
 316                 xmlFree(pContent);
 317             }
 318         }
 319         else if (title.empty() && !strcmp(reinterpret_cast<const char*>(test->name), "title"))
 320         {
 321             title = dump(test);
 322             if (title.empty())
 323                 title = "<notitle>";
 324         }
 325         else if (!strcmp(reinterpret_cast<const char*>(test->name), "bookmark"))
 326         {
 327             xmlChar *branchxml = xmlGetProp(test, reinterpret_cast<const xmlChar*>("branch"));
 328             xmlChar *idxml = xmlGetProp(test, reinterpret_cast<const xmlChar*>("id"));
 329             std::string branch(reinterpret_cast<char*>(branchxml));
 330             std::string anchor(reinterpret_cast<char*>(idxml));
 331             xmlFree (branchxml);
 332             xmlFree (idxml);
 333
 334             if (branch.compare(0, 3, "hid") == 0)
 335             {
 336                 size_t index = branch.find('/');
 337                 if (index != std::string::npos)
 338                 {
 339                     auto hid = branch.substr(1 + index);
 340                     // one shall serve as a documentId
 341                     if (documentId.empty())
 342                         documentId = hid;
 343                     extendedHelpText.push_back(hid);
 344                     HCDBG(std::cerr << "hid pushback" << (anchor.empty() ? hid : hid + "#" + anchor) << std::endl);
 345                     hidlist->push_back( anchor.empty() ? hid : hid + "#" + anchor);
 346                 }
 347                 else
 348                     continue;
 349             }
 350             else if (branch.compare("index") == 0)
 351             {
 352                 LinkedList ll;
 353
 354                 for (xmlNodePtr nd = test->xmlChildrenNode; nd; nd = nd->next)
 355                 {
 356                     if (strcmp(reinterpret_cast<const char*>(nd->name), "bookmark_value"))
 357                         continue;
 358
 359                     std::string embedded;
 360                     xmlChar *embeddedxml = xmlGetProp(nd, reinterpret_cast<const xmlChar*>("embedded"));
 361                     if (embeddedxml)
 362                     {
 363                         embedded = std::string(reinterpret_cast<char*>(embeddedxml));
 364                         xmlFree (embeddedxml);
 365                         std::transform (embedded.begin(), embedded.end(),
 366                             embedded.begin(), tocharlower);
 367                     }
 368
 369                     bool isEmbedded = !embedded.empty() && embedded.compare("true") == 0;
 370                     if (isEmbedded)
 371                         continue;
 372
 373                     std::string keyword = dump(nd);
 374                     size_t keywordSem = keyword.find(';');
 375                     if (keywordSem != std::string::npos)
 376                     {
 377                         std::string tmppre =
 378                                     keyword.substr(0,keywordSem);
 379                         trim(tmppre);
 380                         std::string tmppos =
 381                                     keyword.substr(1+keywordSem);
 382                         trim(tmppos);
 383                         keyword = tmppre + ";" + tmppos;
 384                     }
 385                     ll.push_back(keyword);
 386                 }
 387                 if (!ll.empty())
 388                     (*keywords)[anchor] = ll;
 389             }
 390             else if (branch.compare("contents") == 0)
 391             {
 392                 // currently not used
 393             }
 394         }
 395         else if (!strcmp(reinterpret_cast<const char*>(test->name), "ahelp"))
 396         {
 397             //tool-tip
 398             std::string text = dump(test);
 399             std::replace(text.begin(), text.end(), '\n', ' ');
 400             trim(text);
 401
 402             //tool-tip target
 403             std::string hidstr(".");  //. == previous seen hid bookmarks
 404             xmlChar *hid = xmlGetProp(test, reinterpret_cast<const xmlChar*>("hid"));
 405             if (hid)
 406             {
 407                 hidstr = std::string(reinterpret_cast<char*>(hid));
 408                 xmlFree (hid);
 409             }
 410
 411             if (hidstr != "." && !hidstr.empty())  //simple case of explicitly named target
 412             {
 413                 assert(!hidstr.empty());
 414                 (*helptexts)[hidstr] = text;
 415             }
 416             else //apply to list of "current" hids determined by recent bookmarks that have hid in their branch
 417             {
 418                 //TODO: make these asserts and flush out all our broken help ids
 419                 SAL_WARN_IF(hidstr.empty(), "helpcompiler", "hid='' for text:" << text);
 420                 SAL_WARN_IF(!hidstr.empty() && extendedHelpText.empty(), "helpcompiler", "hid='.' with no hid bookmark branches in file: " << fileName + " for text: " << text);
 421                 for (auto const& elem : extendedHelpText)
 422                 {
 423                     std::string name = elem;
 424                     (*helptexts)[name] = text;
 425                 }
 426             }
 427             extendedHelpText.clear();
 428         }
 429         // traverse children
 430         traverse(test);
 431     }
 432 }
 433
 434 bool HelpCompiler::compile()
 435 {
 436     // we now have the jaroutputstream, which will contain the document.
 437     // now determine the document as a dom tree in variable docResolved
 438
 439     xmlDocPtr docResolvedOrg = getSourceDocument(inputFile);
 440
 441     // now add path to the document
 442     // resolve the dom
 443
 444     if (!docResolvedOrg)
 445     {
 446         impl_sleep( 3 );
 447         docResolvedOrg = getSourceDocument(inputFile);
 448         if( !docResolvedOrg )
 449         {
 450             std::stringstream aStrStream;
 451             aStrStream << "ERROR: file not existing: " << inputFile.native_file_string().c_str() << std::endl;
 452             throw HelpProcessingException( HelpProcessingErrorClass::General, aStrStream.str() );
 453         }
 454     }
 455
 456     std::string documentId;
 457     std::string fileName;
 458     std::string title;
 459     // returns a clone of the document with switch-cases resolved
 460     std::string appl = module.substr(1);
 461     for (char & i : appl)
 462     {
 463         i=rtl::toAsciiUpperCase(static_cast<unsigned char>(i));
 464     }
 465     xmlNodePtr docResolved = clone(xmlDocGetRootElement(docResolvedOrg), appl);
 466     myparser aparser(documentId, fileName, title);
 467     aparser.traverse(docResolved);
 468     documentId = aparser.documentId;
 469     fileName = aparser.fileName;
 470     title = aparser.title;
 471
 472     HCDBG(std::cerr << documentId << " : " << fileName << " : " << title << std::endl);
 473
 474     xmlDocPtr docResolvedDoc = xmlCopyDoc(docResolvedOrg, false);
 475     xmlDocSetRootElement(docResolvedDoc, docResolved);
 476
 477     streamTable.dropappl();
 478     streamTable.appl_doc = docResolvedDoc;
 479     streamTable.appl_hidlist = std::move(aparser.hidlist);
 480     streamTable.appl_helptexts = std::move(aparser.helptexts);
 481     streamTable.appl_keywords = std::move(aparser.keywords);
 482
 483     streamTable.document_id = documentId;
 484     streamTable.document_path = fileName;
 485     streamTable.document_title = title;
 486     std::string actMod = module;
 487
 488     if ( !bExtensionMode && !fileName.empty())
 489     {
 490         if (fileName.compare(0, 6, "/text/") == 0)
 491         {
 492             actMod = fileName.substr(strlen("/text/"));
 493             actMod = actMod.substr(0, actMod.find('/'));
 494         }
 495     }
 496     streamTable.document_module = actMod;
 497     xmlFreeDoc(docResolvedOrg);
 498     return true;
 499 }
 500
 501 namespace fs
 502 {
 503     rtl_TextEncoding getThreadTextEncoding()
 504     {
 505         static bool bNeedsInit = true;
 506         static rtl_TextEncoding nThreadTextEncoding;
 507         if( bNeedsInit )
 508         {
 509             bNeedsInit = false;
 510             nThreadTextEncoding = osl_getThreadTextEncoding();
 511         }
 512         return nThreadTextEncoding;
 513     }
 514
 515     void create_directory(const fs::path& indexDirName)
 516     {
 517         HCDBG(
 518             std::cerr << "creating " <<
 519             OUStringToOString(indexDirName.data, RTL_TEXTENCODING_UTF8).getStr()
 520             << std::endl
 521            );
 522         osl::Directory::createPath(indexDirName.data);
 523     }
 524
 525     void copy(const fs::path &src, const fs::path &dest)
 526     {
 527         osl::File::copy(src.data, dest.data);
 528     }
 529 }
 530
 531 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */