l10ntools/source/lngmerge.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 <cstddef>
  23 #include <fstream>
  24 #include <iterator>
  25 #include <memory>
  26 #include <string>
  27
  28 #include <po.hxx>
  29 #include <lngmerge.hxx>
  30
  31 namespace {
  32
  33 bool lcl_isNextGroup(OString &sGroup_out, const OString &sLineTrim)
  34 {
  35     if (sLineTrim.startsWith("[") && sLineTrim.endsWith("]"))
  36     {
  37         sGroup_out = sLineTrim.getToken(1, '[').getToken(0, ']').trim();
  38         return true;
  39     }
  40     return false;
  41 }
  42
  43 void lcl_RemoveUTF8ByteOrderMarker( OString &rString )
  44 {
  45     if( rString.getLength() >= 3 && rString[0] == '\xEF' &&
  46         rString[1] == '\xBB' && rString[2] == '\xBF' )
  47     {
  48         rString = rString.copy(3);
  49     }
  50 }
  51
  52 }
  53
  54
  55
  56 LngParser::LngParser(const OString &rLngFile)
  57     : sSource( rLngFile )
  58 {
  59     std::ifstream aStream(sSource.getStr());
  60     if (!aStream.is_open())
  61         return;
  62
  63     bool bFirstLine = true;
  64     std::string s;
  65     std::getline(aStream, s);
  66     while (!aStream.eof())
  67     {
  68         OString sLine(s.data(), s.length());
  69
  70         if( bFirstLine )
  71         {
  72             // Always remove UTF8 BOM from the first line
  73             lcl_RemoveUTF8ByteOrderMarker( sLine );
  74             bFirstLine = false;
  75         }
  76
  77         mvLines.push_back( sLine );
  78         std::getline(aStream, s);
  79     }
  80     mvLines.push_back( OString() );
  81 }
  82
  83 LngParser::~LngParser()
  84 {
  85 }
  86
  87 void LngParser::CreatePO( const OString &rPOFile )
  88 {
  89     PoOfstream aPOStream( rPOFile, PoOfstream::APP );
  90     if (!aPOStream.isOpen()) {
  91         std::cerr << "Ulfex error: Can't open po file:" << rPOFile << "\n";
  92     }
  93
  94     size_t nPos  = 0;
  95     bool bStart = true;
  96     OString sGroup, sLine;
  97     OStringHashMap Text;
  98     OString sID;
  99
 100     while( nPos < mvLines.size() ) {
 101         sLine = mvLines[ nPos++ ];
 102         while( nPos < mvLines.size() && !isNextGroup( sGroup , sLine ) ) {
 103             ReadLine( sLine , Text );
 104             sID = sGroup;
 105             sLine = mvLines[ nPos++ ];
 106         }
 107         if( bStart ) {
 108             bStart = false;
 109             sID = sGroup;
 110         }
 111         else {
 112             WritePO( aPOStream , Text , sSource , sID );
 113         }
 114         Text.erase("x-comment");
 115     }
 116     aPOStream.close();
 117 }
 118
 119 void LngParser::WritePO(PoOfstream &aPOStream,
 120     OStringHashMap &rText_inout, const OString &rActFileName,
 121     const OString &rID)
 122 {
 123     common::writePoEntry(
 124         "Ulfex", aPOStream, rActFileName, "LngText",
 125         rID, OString(), rText_inout.count("x-comment") ? rText_inout["x-comment"] : OString(), rText_inout["en-US"]);
 126 }
 127
 128 bool LngParser::isNextGroup(OString &sGroup_out, const OString &sLine_in)
 129 {
 130     return lcl_isNextGroup(sGroup_out, sLine_in.trim());
 131 }
 132
 133 void LngParser::ReadLine(const OString &rLine_in,
 134         OStringHashMap &rText_inout)
 135 {
 136     if (!rLine_in.match(" *") && !rLine_in.match("/*"))
 137     {
 138         OString sLang(rLine_in.getToken(0, '=').trim());
 139         if (!sLang.isEmpty()) {
 140             OString sText(rLine_in.getToken(1, '"'));
 141             rText_inout[sLang] = sText;
 142         }
 143     }
 144 }
 145
 146 void LngParser::Merge(
 147     const OString &rPOFile,
 148     const OString &rDestinationFile,
 149     const OString &rLanguage )
 150 {
 151     std::ofstream aDestination(
 152         rDestinationFile.getStr(), std::ios_base::out | std::ios_base::trunc);
 153
 154     MergeDataFile aMergeDataFile( rPOFile, sSource, false, true );
 155     if( rLanguage.equalsIgnoreAsciiCase("ALL") )
 156         aLanguages = aMergeDataFile.GetLanguages();
 157
 158     size_t nPos = 0;
 159     bool bGroup = false;
 160     OString sGroup;
 161
 162     // seek to next group
 163     while ( nPos < mvLines.size() && !bGroup )
 164         bGroup = lcl_isNextGroup(sGroup, mvLines[nPos++].trim());
 165
 166     while ( nPos < mvLines.size()) {
 167         OStringHashMap Text;
 168         OString sID( sGroup );
 169         std::size_t nLastLangPos = 0;
 170
 171         std::unique_ptr<ResData> pResData( new ResData( sID, sSource ) );
 172         pResData->sResTyp = "LngText";
 173         MergeEntrys *pEntrys = aMergeDataFile.GetMergeEntrys( pResData.get() );
 174         // read languages
 175         bGroup = false;
 176
 177         OString sLanguagesDone;
 178
 179         while ( nPos < mvLines.size() && !bGroup )
 180         {
 181             const OString sLine{ mvLines[nPos].trim() };
 182             if ( lcl_isNextGroup(sGroup, sLine) )
 183             {
 184                 bGroup = true;
 185                 nPos ++;
 186                 sLanguagesDone = "";
 187             }
 188             else
 189             {
 190                 sal_Int32 n = 0;
 191                 OString sLang(sLine.getToken(0, '=', n));
 192                 if (n == -1 || static_cast<bool>(sLine.match("/*")))
 193                 {
 194                     ++nPos;
 195                 }
 196                 else
 197                 {
 198                     sLang = sLang.trim();
 199
 200                     OString sSearch{ ";" + sLang + ";" };
 201
 202                     if ( sLanguagesDone.indexOf( sSearch ) != -1 ) {
 203                         mvLines.erase( mvLines.begin() + nPos );
 204                     }
 205                     if( pEntrys )
 206                     {
 207                         if( !sLang.isEmpty() )
 208                         {
 209                             OString sNewText;
 210                             pEntrys->GetText( sNewText, sLang, true );
 211                             if( sLang == "qtz" )
 212                                 continue;
 213
 214                             if ( !sNewText.isEmpty()) {
 215                                 mvLines[ nPos ] = sLang
 216                                     + " = \""
 217                                     // escape quotes, unescape double escaped quotes fdo#56648
 218                                     + sNewText.replaceAll("\"","\\\"").replaceAll("\\\\\"","\\\"")
 219                                     + "\"";
 220                                 Text[ sLang ] = sNewText;
 221                             }
 222                         }
 223                         nLastLangPos = nPos;
 224                         nPos ++;
 225                         sLanguagesDone += sSearch;
 226                     }
 227                     else {
 228                         nLastLangPos = nPos;
 229                         nPos ++;
 230                         sLanguagesDone += sSearch;
 231                     }
 232                 }
 233             }
 234         }
 235         OString sCur;
 236         if ( nLastLangPos )
 237         {
 238             for(size_t n = 0; n < aLanguages.size(); ++n)
 239             {
 240                 sCur = aLanguages[ n ];
 241                 if( !sCur.equalsIgnoreAsciiCase("en-US") && Text[sCur].isEmpty() && pEntrys )
 242                 {
 243
 244                     OString sNewText;
 245                     pEntrys->GetText( sNewText, sCur, true );
 246                     if( sCur == "qtz" )
 247                         continue;
 248                     if ( !sNewText.isEmpty() && sCur != "x-comment")
 249                     {
 250                         const OString sLine { sCur
 251                             + " = \""
 252                             // escape quotes, unescape double escaped quotes fdo#56648
 253                             + sNewText.replaceAll("\"","\\\"").replaceAll("\\\\\"","\\\"")
 254                             + "\"" };
 255
 256                         nLastLangPos++;
 257                         nPos++;
 258
 259                         if ( nLastLangPos < mvLines.size() ) {
 260                             mvLines.insert( mvLines.begin() + nLastLangPos, sLine );
 261                         } else {
 262                             mvLines.push_back( sLine );
 263                         }
 264                     }
 265                 }
 266             }
 267         }
 268     }
 269
 270     for ( size_t i = 0; i < mvLines.size(); ++i )
 271         aDestination << mvLines[i] << '\n';
 272
 273     aDestination.close();
 274 }
 275
 276 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */