l10ntools/source/cfgmerge.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 #include <sal/config.h>
  21
  22 #include <cfglex.hxx>
  23 #include <common.hxx>
  24
  25 #include <cstdio>
  26 #include <cstdlib>
  27 #include <cstring>
  28
  29 #include <memory>
  30 #include <rtl/strbuf.hxx>
  31
  32 #include <helper.hxx>
  33 #include <export.hxx>
  34 #include <cfgmerge.hxx>
  35 #include <tokens.h>
  36
  37 namespace {
  38
  39 namespace global {
  40
  41 OString inputPathname;
  42 std::unique_ptr< CfgParser > parser;
  43
  44 }
  45 }
  46
  47 extern "C" {
  48
  49 FILE * init(int argc, char ** argv) {
  50
  51     common::HandledArgs aArgs;
  52     if ( !common::handleArguments(argc, argv, aArgs) )
  53     {
  54         common::writeUsage("cfgex","*.xcu");
  55         std::exit(EXIT_FAILURE);
  56     }
  57     global::inputPathname = aArgs.m_sInputFile;
  58
  59     FILE * pFile = std::fopen(global::inputPathname.getStr(), "r");
  60     if (pFile == nullptr) {
  61         std::fprintf(
  62             stderr, "Error: Cannot open file \"%s\"\n",
  63             global::inputPathname.getStr() );
  64         std::exit(EXIT_FAILURE);
  65     }
  66
  67     if (aArgs.m_bMergeMode) {
  68         global::parser.reset(
  69             new CfgMerge(
  70                 aArgs.m_sMergeSrc, aArgs.m_sOutputFile,
  71                 global::inputPathname, aArgs.m_sLanguage ));
  72     } else {
  73         global::parser.reset(
  74             new CfgExport(
  75                 aArgs.m_sOutputFile, global::inputPathname ));
  76     }
  77
  78     return pFile;
  79 }
  80
  81 void workOnTokenSet(int nTyp, char * pTokenText) {
  82     global::parser->Execute( nTyp, pTokenText );
  83 }
  84
  85 }
  86
  87
  88
  89
  90 CfgStackData* CfgStack::Push(const OString &rTag, const OString &rId)
  91 {
  92     CfgStackData *pD = new CfgStackData( rTag, rId );
  93     maList.push_back( pD );
  94     return pD;
  95 }
  96
  97
  98
  99
 100 CfgStack::~CfgStack()
 101 {
 102 }
 103
 104 OString CfgStack::GetAccessPath( size_t nPos )
 105 {
 106     OStringBuffer sReturn;
 107     for (size_t i = 0; i <= nPos; ++i)
 108     {
 109         if (i)
 110             sReturn.append('.');
 111         sReturn.append(maList[i]->GetIdentifier());
 112     }
 113
 114     return sReturn.makeStringAndClear();
 115 }
 116
 117 CfgStackData *CfgStack::GetStackData()
 118 {
 119     if (!maList.empty())
 120         return maList[maList.size() - 1];
 121     else
 122         return nullptr;
 123 }
 124
 125
 126
 127
 128 CfgParser::CfgParser()
 129                 : pStackData( nullptr ),
 130                 bLocalize( false )
 131 {
 132 }
 133
 134 CfgParser::~CfgParser()
 135 {
 136 }
 137
 138 bool CfgParser::IsTokenClosed(const OString &rToken)
 139 {
 140     return rToken[rToken.getLength() - 2] == '/';
 141 }
 142
 143 void CfgParser::AddText(
 144     OString &rText,
 145     const OString &rIsoLang,
 146     const OString &rResTyp )
 147 {
 148     rText = rText.replaceAll(OString('\n'), OString()).
 149         replaceAll(OString('\r'), OString()).
 150         replaceAll(OString('\t'), OString());
 151     pStackData->sResTyp = rResTyp;
 152     WorkOnText( rText, rIsoLang );
 153     pStackData->sText[ rIsoLang ] = rText;
 154 }
 155
 156 #if defined _MSC_VER
 157 #pragma warning(disable: 4702) // unreachable code, bug in MSVC2015, it thinks the std::exit is unreachable
 158 #endif
 159 void CfgParser::ExecuteAnalyzedToken( int nToken, char *pToken )
 160 {
 161     OString sToken( pToken );
 162
 163     if ( sToken == " " || sToken == "\t" )
 164         sLastWhitespace += sToken;
 165
 166     OString sTokenName;
 167
 168     bool bOutput = true;
 169
 170     switch ( nToken ) {
 171         case CFG_TOKEN_PACKAGE:
 172         case CFG_TOKEN_COMPONENT:
 173         case CFG_TOKEN_TEMPLATE:
 174         case CFG_TOKEN_CONFIGNAME:
 175         case CFG_TOKEN_OORNAME:
 176         case CFG_TOKEN_OORVALUE:
 177         case CFG_TAG:
 178         case ANYTOKEN:
 179         case CFG_TEXT_START:
 180         {
 181             sTokenName = sToken.getToken(1, '<').getToken(0, '>').
 182                 getToken(0, ' ');
 183
 184             if ( !IsTokenClosed( sToken )) {
 185                 OString sSearch;
 186                 switch ( nToken ) {
 187                     case CFG_TOKEN_PACKAGE:
 188                         sSearch = "package-id=";
 189                     break;
 190                     case CFG_TOKEN_COMPONENT:
 191                         sSearch = "component-id=";
 192                     break;
 193                     case CFG_TOKEN_TEMPLATE:
 194                         sSearch = "template-id=";
 195                     break;
 196                     case CFG_TOKEN_CONFIGNAME:
 197                         sSearch = "cfg:name=";
 198                     break;
 199                     case CFG_TOKEN_OORNAME:
 200                         sSearch = "oor:name=";
 201                         bLocalize = true;
 202                     break;
 203                     case CFG_TOKEN_OORVALUE:
 204                         sSearch = "oor:value=";
 205                     break;
 206                     case CFG_TEXT_START: {
 207                         if ( sCurrentResTyp != sTokenName ) {
 208                             WorkOnResourceEnd();
 209                         }
 210                         sCurrentResTyp = sTokenName;
 211
 212                         OString sTemp = sToken.copy( sToken.indexOf( "xml:lang=" ));
 213                         sCurrentIsoLang = sTemp.getToken(1, '"');
 214
 215                         if ( sCurrentIsoLang == NO_TRANSLATE_ISO )
 216                             bLocalize = false;
 217
 218                         pStackData->sTextTag = sToken;
 219
 220                         sCurrentText = "";
 221                     }
 222                     break;
 223                 }
 224                 OString sTokenId;
 225                 if ( !sSearch.isEmpty())
 226                 {
 227                     OString sTemp = sToken.copy( sToken.indexOf( sSearch ));
 228                     sTokenId = sTemp.getToken(1, '"');
 229                 }
 230                 pStackData = aStack.Push( sTokenName, sTokenId );
 231
 232                 if ( sSearch == "cfg:name=" ) {
 233                     OString sTemp( sToken.toAsciiUpperCase() );
 234                     bLocalize = sTemp.indexOf("CFG:TYPE=\"STRING\"")>=0
 235                         && sTemp.indexOf( "CFG:LOCALIZED=\"TRUE\"" )>=0;
 236                 }
 237             }
 238             else if ( sTokenName == "label" ) {
 239                 if ( sCurrentResTyp != sTokenName ) {
 240                     WorkOnResourceEnd();
 241                 }
 242                 sCurrentResTyp = sTokenName;
 243             }
 244         }
 245         break;
 246         case CFG_CLOSETAG:
 247         {
 248             sTokenName = sToken.getToken(1, '/').getToken(0, '>').
 249                 getToken(0, ' ');
 250             if ( aStack.GetStackData() && ( aStack.GetStackData()->GetTagType() == sTokenName ))
 251             {
 252                 if (sCurrentText.isEmpty())
 253                     WorkOnResourceEnd();
 254                 aStack.Pop();
 255                 pStackData = aStack.GetStackData();
 256             }
 257             else
 258             {
 259                 const OString sError{ "Misplaced close tag: " + sToken + " in file " + global::inputPathname };
 260                 yyerror(sError.getStr());
 261                 std::exit(EXIT_FAILURE);
 262             }
 263         }
 264         break;
 265
 266         case CFG_TEXTCHAR:
 267             sCurrentText += sToken;
 268             bOutput = false;
 269         break;
 270
 271         case CFG_TOKEN_NO_TRANSLATE:
 272             bLocalize = false;
 273         break;
 274     }
 275
 276     if ( !sCurrentText.isEmpty() && nToken != CFG_TEXTCHAR )
 277     {
 278         AddText( sCurrentText, sCurrentIsoLang, sCurrentResTyp );
 279         Output( sCurrentText );
 280         sCurrentText.clear();
 281         pStackData->sEndTextTag = sToken;
 282     }
 283
 284     if ( bOutput )
 285         Output( sToken );
 286
 287     if ( sToken != " " && sToken != "\t" )
 288         sLastWhitespace = "";
 289 }
 290
 291 void CfgExport::Output(const OString&)
 292 {
 293 }
 294
 295 void CfgParser::Execute( int nToken, char * pToken )
 296 {
 297     OString sToken( pToken );
 298
 299     switch ( nToken ) {
 300         case CFG_TAG:
 301             if ( sToken.indexOf( "package-id=" ) != -1 ) {
 302                 ExecuteAnalyzedToken( CFG_TOKEN_PACKAGE, pToken );
 303                 return;
 304             } else if ( sToken.indexOf( "component-id=" ) != -1 ) {
 305                 ExecuteAnalyzedToken( CFG_TOKEN_COMPONENT, pToken );
 306                 return;
 307             } else if ( sToken.indexOf( "template-id=" ) != -1 ) {
 308                 ExecuteAnalyzedToken( CFG_TOKEN_TEMPLATE, pToken );
 309                 return;
 310             } else if ( sToken.indexOf( "cfg:name=" ) != -1 ) {
 311                 ExecuteAnalyzedToken( CFG_TOKEN_OORNAME, pToken );
 312                 return;
 313             } else if ( sToken.indexOf( "oor:name=" ) != -1 ) {
 314                 ExecuteAnalyzedToken( CFG_TOKEN_OORNAME, pToken );
 315                 return;
 316             } else if ( sToken.indexOf( "oor:value=" ) != -1 ) {
 317                 ExecuteAnalyzedToken( CFG_TOKEN_OORVALUE, pToken );
 318                 return;
 319             }
 320         break;
 321     }
 322     ExecuteAnalyzedToken( nToken, pToken );
 323 }
 324
 325
 326
 327
 328 CfgExport::CfgExport(
 329         const OString &rOutputFile,
 330         const OString &rFilePath )
 331
 332                 : sPath( rFilePath )
 333 {
 334     pOutputStream.open( rOutputFile, PoOfstream::APP );
 335     if (!pOutputStream.isOpen())
 336     {
 337         std::cerr << "ERROR: Unable to open output file: " << rOutputFile << "\n";
 338         std::exit(EXIT_FAILURE);
 339     }
 340 }
 341
 342 CfgExport::~CfgExport()
 343 {
 344     pOutputStream.close();
 345 }
 346
 347
 348 void CfgExport::WorkOnResourceEnd()
 349 {
 350     if ( !bLocalize )
 351         return;
 352
 353     if ( pStackData->sText["en-US"].isEmpty() )
 354         return;
 355
 356     OString sXComment = pStackData->sText[OString("x-comment")];
 357     OString sLocalId = pStackData->sIdentifier;
 358     OString sGroupId;
 359     if ( aStack.size() == 1 ) {
 360         sGroupId = sLocalId;
 361         sLocalId = "";
 362     }
 363     else {
 364         sGroupId = aStack.GetAccessPath( aStack.size() - 2 );
 365     }
 366
 367
 368     OString sText = pStackData->sText[ "en-US" ];
 369     sText = helper::UnQuotHTML( sText );
 370
 371     common::writePoEntry(
 372         "Cfgex", pOutputStream, sPath, pStackData->sResTyp,
 373         sGroupId, sLocalId, sXComment, sText);
 374 }
 375
 376 void CfgExport::WorkOnText(
 377     OString &rText,
 378     const OString &rIsoLang
 379 )
 380 {
 381     if( !rIsoLang.isEmpty() ) rText = helper::UnQuotHTML( rText );
 382 }
 383
 384
 385
 386
 387 CfgMerge::CfgMerge(
 388     const OString &rMergeSource, const OString &rOutputFile,
 389     const OString &rFilename, const OString &rLanguage )
 390                 : sFilename( rFilename ),
 391                 bEnglish( false )
 392 {
 393     pOutputStream.open(
 394         rOutputFile.getStr(), std::ios_base::out | std::ios_base::trunc);
 395     if (!pOutputStream.is_open())
 396     {
 397         std::cerr << "ERROR: Unable to open output file: " << rOutputFile << "\n";
 398         std::exit(EXIT_FAILURE);
 399     }
 400
 401     if (!rMergeSource.isEmpty())
 402     {
 403         pMergeDataFile.reset(new MergeDataFile(
 404             rMergeSource, global::inputPathname, true ));
 405         if (rLanguage.equalsIgnoreAsciiCase("ALL") )
 406         {
 407             aLanguages = pMergeDataFile->GetLanguages();
 408         }
 409         else aLanguages.push_back(rLanguage);
 410     }
 411     else
 412         aLanguages.push_back(rLanguage);
 413 }
 414
 415 CfgMerge::~CfgMerge()
 416 {
 417     pOutputStream.close();
 418 }
 419
 420 void CfgMerge::WorkOnText(OString &, const OString& rLangIndex)
 421 {
 422     if ( !(pMergeDataFile && bLocalize) )
 423         return;
 424
 425     if ( !pResData ) {
 426         OString sLocalId = pStackData->sIdentifier;
 427         OString sGroupId;
 428         if ( aStack.size() == 1 ) {
 429             sGroupId = sLocalId;
 430             sLocalId.clear();
 431         }
 432         else {
 433             sGroupId = aStack.GetAccessPath( aStack.size() - 2 );
 434         }
 435
 436         pResData.reset( new ResData( sGroupId, sFilename ) );
 437         pResData->sId = sLocalId;
 438         pResData->sResTyp = pStackData->sResTyp;
 439     }
 440
 441     if (rLangIndex.equalsIgnoreAsciiCase("en-US"))
 442         bEnglish = true;
 443 }
 444
 445 void CfgMerge::Output(const OString& rOutput)
 446 {
 447     pOutputStream << rOutput;
 448 }
 449
 450 void CfgMerge::WorkOnResourceEnd()
 451 {
 452
 453     if ( pMergeDataFile && pResData && bLocalize && bEnglish ) {
 454         MergeEntrys *pEntrys = pMergeDataFile->GetMergeEntrysCaseSensitive( pResData.get() );
 455         if ( pEntrys ) {
 456             OString sCur;
 457
 458             for( size_t i = 0; i < aLanguages.size(); ++i ){
 459                 sCur = aLanguages[ i ];
 460
 461                 OString sContent;
 462                 pEntrys->GetText( sContent, sCur, true );
 463                 if (
 464                     ( !sCur.equalsIgnoreAsciiCase("en-US") ) && !sContent.isEmpty())
 465                 {
 466                     OString sTextTag = pStackData->sTextTag;
 467                     const sal_Int32 nLangAttributeStart{ sTextTag.indexOf( "xml:lang=" ) };
 468                     const sal_Int32 nLangStart{ sTextTag.indexOf( '"', nLangAttributeStart )+1 };
 469                     const sal_Int32 nLangEnd{ sTextTag.indexOf( '"', nLangStart ) };
 470                     OString sAdditionalLine{ "\t"
 471                         + sTextTag.replaceAt(nLangStart, nLangEnd-nLangStart, sCur)
 472                         + helper::QuotHTML(sContent)
 473                         + pStackData->sEndTextTag
 474                         + "\n"
 475                         + sLastWhitespace };
 476                     Output( sAdditionalLine );
 477                 }
 478             }
 479         }
 480     }
 481     pResData.reset();
 482     bEnglish = false;
 483 }
 484
 485 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */