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