l10ntools/source/po.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
  10 #include <rtl/ustring.hxx>
  11
  12 #include <cstring>
  13 #include <ctime>
  14 #include <cassert>
  15
  16 #include <vector>
  17 #include <string>
  18
  19 #ifdef _MSC_VER
  20 #pragma warning (push, 1)
  21 #pragma warning (disable: 4245)
  22 #endif
  23 #include <boost/crc.hpp>
  24 #ifdef _MSC_VER
  25 #pragma warning (pop)
  26 #endif
  27
  28
  29 #include "po.hxx"
  30 #include "helper.hxx"
  31
  32 /** Container of po entry
  33
  34     Provide all file operations related to LibreOffice specific
  35     po entry and store it's attributes.
  36 */
  37 class GenPoEntry
  38 {
  39 private:
  40
  41     OString    m_sExtractCom;
  42     OString    m_sReference;
  43     OString    m_sMsgCtxt;
  44     OString    m_sMsgId;
  45     OString    m_sMsgStr;
  46     bool       m_bFuzzy;
  47     bool       m_bNull;
  48
  49 public:
  50
  51                         GenPoEntry();
  52     virtual             ~GenPoEntry();
  53                         // Default copy constructor and copy operator work well
  54
  55     OString     getReference() const    { return m_sReference; }
  56     OString     getMsgCtxt() const      { return m_sMsgCtxt; }
  57     OString     getMsgId() const        { return m_sMsgId; }
  58     OString     getMsgStr() const       { return m_sMsgStr; }
  59     bool        isFuzzy() const         { return m_bFuzzy; }
  60     bool        isNull() const          { return m_bNull; }
  61
  62     void        setExtractCom(const OString& rExtractCom)
  63                         {
  64                             m_sExtractCom = rExtractCom;
  65                         }
  66     void        setReference(const OString& rReference)
  67                         {
  68                             m_sReference = rReference;
  69                         }
  70     void        setMsgCtxt(const OString& rMsgCtxt)
  71                         {
  72                             m_sMsgCtxt = rMsgCtxt;
  73                         }
  74     void        setMsgId(const OString& rMsgId)
  75                         {
  76                             m_sMsgId = rMsgId;
  77                         }
  78     void        setMsgStr(const OString& rMsgStr)
  79                         {
  80                             m_sMsgStr = rMsgStr;
  81                         }
  82
  83     void        writeToFile(std::ofstream& rOFStream) const;
  84     void        readFromFile(std::ifstream& rIFStream);
  85 };
  86
  87 namespace
  88 {
  89     // Convert a normal string to msg/po output string
  90     static OString lcl_GenMsgString(const OString& rString)
  91     {
  92         if ( rString.isEmpty() )
  93             return "\"\"";
  94
  95         OString sResult =
  96             "\"" +
  97             helper::escapeAll(rString,"\n""\t""\r""\\""\"","\\n""\\t""\\r""\\\\""\\\"") +
  98             "\"";
  99         sal_Int32 nIndex = 0;
 100         while((nIndex=sResult.indexOf("\\n",nIndex))!=-1)
 101         {
 102             if( sResult.copy(nIndex-1,3)!="\\\\n" &&
 103                 nIndex!=sResult.getLength()-3)
 104             {
 105                sResult = sResult.replaceAt(nIndex,2,"\\n\"\n\"");
 106             }
 107             ++nIndex;
 108         }
 109
 110         if ( sResult.indexOf('\n') != -1 )
 111             return "\"\"\n" +  sResult;
 112
 113         return sResult;
 114     }
 115
 116     // Convert msg string to normal form
 117     static OString lcl_GenNormString(const OString& rString)
 118     {
 119         return
 120             helper::unEscapeAll(
 121                 rString.copy(1,rString.getLength()-2),
 122                 "\\n""\\t""\\r""\\\\""\\\"",
 123                 "\n""\t""\r""\\""\"");
 124     }
 125 }
 126
 127 GenPoEntry::GenPoEntry()
 128     : m_sExtractCom( OString() )
 129     , m_sReference( OString() )
 130     , m_sMsgCtxt( OString() )
 131     , m_sMsgId( OString() )
 132     , m_sMsgStr( OString() )
 133     , m_bFuzzy( false )
 134     , m_bNull( false )
 135 {
 136 }
 137
 138 GenPoEntry::~GenPoEntry()
 139 {
 140 }
 141
 142 void GenPoEntry::writeToFile(std::ofstream& rOFStream) const
 143 {
 144     if ( rOFStream.tellp() != std::ofstream::pos_type( 0 ))
 145         rOFStream << std::endl;
 146     if ( !m_sExtractCom.isEmpty() )
 147         rOFStream
 148             << "#. "
 149             << m_sExtractCom.replaceAll("\n","\n#. ").getStr() << std::endl;
 150     if ( !m_sReference.isEmpty() )
 151         rOFStream << "#: " << m_sReference.getStr() << std::endl;
 152     if ( m_bFuzzy )
 153         rOFStream << "#, fuzzy" << std::endl;
 154     if ( !m_sMsgCtxt.isEmpty() )
 155         rOFStream << "msgctxt "
 156                   << lcl_GenMsgString(m_sReference+"\n"+m_sMsgCtxt).getStr()
 157                   << std::endl;
 158     rOFStream << "msgid "
 159               << lcl_GenMsgString(m_sMsgId).getStr() << std::endl;
 160     rOFStream << "msgstr "
 161               << lcl_GenMsgString(m_sMsgStr).getStr() << std::endl;
 162 }
 163
 164 void GenPoEntry::readFromFile(std::ifstream& rIFStream)
 165 {
 166     *this = GenPoEntry();
 167     OString* pLastMsg = 0;
 168     std::string sTemp;
 169     getline(rIFStream,sTemp);
 170     if( rIFStream.eof() || sTemp.empty() )
 171     {
 172         m_bNull = true;
 173         return;
 174     }
 175     while(!rIFStream.eof())
 176     {
 177         OString sLine = OString(sTemp.data(),sTemp.length());
 178         if (sLine.startsWith("#. "))
 179         {
 180             if( !m_sExtractCom.isEmpty() )
 181             {
 182                 m_sExtractCom += "\n";
 183             }
 184             m_sExtractCom += sLine.copy(3);
 185         }
 186         else if (sLine.startsWith("#: "))
 187         {
 188             m_sReference = sLine.copy(3);
 189         }
 190         else if (sLine.startsWith("#, fuzzy"))
 191         {
 192             m_bFuzzy = true;
 193         }
 194         else if (sLine.startsWith("msgctxt "))
 195         {
 196             m_sMsgCtxt = lcl_GenNormString(sLine.copy(8));
 197             pLastMsg = &m_sMsgCtxt;
 198         }
 199         else if (sLine.startsWith("msgid "))
 200         {
 201             m_sMsgId = lcl_GenNormString(sLine.copy(6));
 202             pLastMsg = &m_sMsgId;
 203         }
 204         else if (sLine.startsWith("msgstr "))
 205         {
 206             m_sMsgStr = lcl_GenNormString(sLine.copy(7));
 207             pLastMsg = &m_sMsgStr;
 208         }
 209         else if (sLine.startsWith("\"") && pLastMsg)
 210         {
 211             if (pLastMsg != &m_sMsgCtxt || sLine != "\"" + m_sReference + "\\n\"")
 212             {
 213                 *pLastMsg += lcl_GenNormString(sLine);
 214             }
 215         }
 216         else
 217             break;
 218         getline(rIFStream,sTemp);
 219     }
 220  }
 221
 222
 223 // Class PoEntry
 224
 225
 226 PoEntry::PoEntry()
 227     : m_pGenPo( 0 )
 228     , m_bIsInitialized( false )
 229 {
 230 }
 231
 232 PoEntry::PoEntry(
 233     const OString& rSourceFile, const OString& rResType, const OString& rGroupId,
 234     const OString& rLocalId, const OString& rHelpText,
 235     const OString& rText, const TYPE eType )
 236     : m_pGenPo( 0 )
 237     , m_bIsInitialized( false )
 238 {
 239     if( rSourceFile.isEmpty() )
 240         throw NOSOURCFILE;
 241     else if ( rResType.isEmpty() )
 242         throw NORESTYPE;
 243     else if ( rGroupId.isEmpty() )
 244         throw NOGROUPID;
 245     else if ( rText.isEmpty() )
 246         throw NOSTRING;
 247     else if ( rHelpText.getLength() == 5 )
 248         throw WRONGHELPTEXT;
 249
 250     m_pGenPo = new GenPoEntry();
 251     m_pGenPo->setReference(rSourceFile.copy(rSourceFile.lastIndexOf('/')+1));
 252
 253     OString sMsgCtxt =
 254         rGroupId + "\n" +
 255         (rLocalId.isEmpty() ? OString( "" ) : rLocalId + "\n") +
 256         rResType;
 257     switch(eType){
 258     case TTEXT:
 259         sMsgCtxt += ".text"; break;
 260     case TQUICKHELPTEXT:
 261         sMsgCtxt += ".quickhelptext"; break;
 262     case TTITLE:
 263         sMsgCtxt += ".title"; break;
 264     // Default case is unneeded because the type of eType has only three element
 265     }
 266     m_pGenPo->setMsgCtxt(sMsgCtxt);
 267     m_pGenPo->setMsgId(rText);
 268     m_pGenPo->setExtractCom(
 269         ( !rHelpText.isEmpty() ?  rHelpText + "\n" : OString( "" )) +
 270         genKeyId( m_pGenPo->getReference() + rGroupId + rLocalId + rResType + rText ) );
 271     m_bIsInitialized = true;
 272 }
 273
 274 PoEntry::~PoEntry()
 275 {
 276     delete m_pGenPo;
 277 }
 278
 279 PoEntry::PoEntry( const PoEntry& rPo )
 280     : m_pGenPo( rPo.m_pGenPo ? new GenPoEntry( *(rPo.m_pGenPo) ) : 0 )
 281     , m_bIsInitialized( rPo.m_bIsInitialized )
 282 {
 283 }
 284
 285 PoEntry& PoEntry::operator=(const PoEntry& rPo)
 286 {
 287     if( this == &rPo )
 288     {
 289         return *this;
 290     }
 291     if( rPo.m_pGenPo )
 292     {
 293         if( m_pGenPo )
 294         {
 295             *m_pGenPo = *(rPo.m_pGenPo);
 296         }
 297         else
 298         {
 299             m_pGenPo = new GenPoEntry( *(rPo.m_pGenPo) );
 300         }
 301     }
 302     else
 303     {
 304         delete m_pGenPo;
 305         m_pGenPo = 0;
 306     }
 307     m_bIsInitialized = rPo.m_bIsInitialized;
 308     return *this;
 309 }
 310
 311 OString PoEntry::getSourceFile() const
 312 {
 313     assert( m_bIsInitialized );
 314     return m_pGenPo->getReference();
 315 }
 316
 317 OString PoEntry::getGroupId() const
 318 {
 319     assert( m_bIsInitialized );
 320     return m_pGenPo->getMsgCtxt().getToken(0,'\n');
 321 }
 322
 323 OString PoEntry::getLocalId() const
 324 {
 325     assert( m_bIsInitialized );
 326     const OString sMsgCtxt = m_pGenPo->getMsgCtxt();
 327     if (sMsgCtxt.indexOf('\n')==sMsgCtxt.lastIndexOf('\n'))
 328         return OString();
 329     else
 330         return sMsgCtxt.getToken(1,'\n');
 331 }
 332
 333 OString PoEntry::getResourceType() const
 334 {
 335     assert( m_bIsInitialized );
 336     const OString sMsgCtxt = m_pGenPo->getMsgCtxt();
 337     if (sMsgCtxt.indexOf('\n')==sMsgCtxt.lastIndexOf('\n'))
 338         return sMsgCtxt.getToken(1,'\n').getToken(0,'.');
 339     else
 340         return sMsgCtxt.getToken(2,'\n').getToken(0,'.');
 341 }
 342
 343 PoEntry::TYPE PoEntry::getType() const
 344 {
 345     assert( m_bIsInitialized );
 346     const OString sMsgCtxt = m_pGenPo->getMsgCtxt();
 347     const OString sType = sMsgCtxt.copy( sMsgCtxt.lastIndexOf('.') + 1 );
 348     assert(
 349         (sType == "text" || sType == "quickhelptext" || sType == "title") );
 350     if ( sType == "text" )
 351         return TTEXT;
 352     else if ( sType == "quickhelptext" )
 353         return TQUICKHELPTEXT;
 354     else
 355         return TTITLE;
 356 }
 357
 358 bool PoEntry::isFuzzy() const
 359 {
 360     assert( m_bIsInitialized );
 361     return m_pGenPo->isFuzzy();
 362 }
 363
 364 // Get translation string in merge format
 365 OString PoEntry::getMsgId() const
 366 {
 367     assert( m_bIsInitialized );
 368     return m_pGenPo->getMsgId();
 369 }
 370
 371 // Get translated string in merge format
 372 OString PoEntry::getMsgStr() const
 373 {
 374     assert( m_bIsInitialized );
 375     return m_pGenPo->getMsgStr();
 376
 377 }
 378
 379 bool PoEntry::IsInSameComp(const PoEntry& rPo1,const PoEntry& rPo2)
 380 {
 381     assert( rPo1.m_bIsInitialized && rPo2.m_bIsInitialized );
 382     return ( rPo1.getSourceFile() == rPo2.getSourceFile() &&
 383              rPo1.getGroupId() == rPo2.getGroupId() &&
 384              rPo1.getLocalId() == rPo2.getLocalId() &&
 385              rPo1.getResourceType() == rPo2.getResourceType() );
 386 }
 387
 388 OString PoEntry::genKeyId(const OString& rGenerator)
 389 {
 390     boost::crc_32_type aCRC32;
 391     aCRC32.process_bytes(rGenerator.getStr(), rGenerator.getLength());
 392     sal_uInt32 nCRC = aCRC32.checksum();
 393     // Use simple ASCII characters, exclude I, l, 1 and O, 0 to avoid confusing IDs
 394     static const char sSymbols[] =
 395         "ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz23456789";
 396     char sKeyId[6];
 397     for( short nKeyInd = 0; nKeyInd < 5; ++nKeyInd )
 398     {
 399         sKeyId[nKeyInd] = sSymbols[(nCRC & 63) % strlen(sSymbols)];
 400         nCRC >>= 6;
 401     }
 402     sKeyId[5] = '\0';
 403     return OString(sKeyId);
 404 }
 405
 406
 407 // Class PoHeader
 408
 409
 410 namespace
 411 {
 412     // Get actual time in "YEAR-MO-DA HO:MI+ZONE" form
 413     static OString lcl_GetTime()
 414     {
 415         time_t aNow = time(NULL);
 416         struct tm* pNow = localtime(&aNow);
 417         char pBuff[50];
 418         strftime( pBuff, sizeof pBuff, "%Y-%m-%d %H:%M%z", pNow );
 419         return pBuff;
 420     }
 421 }
 422
 423 PoHeader::PoHeader( const OString& rExtSrc )
 424     : m_pGenPo( new GenPoEntry() )
 425     , m_bIsInitialized( false )
 426 {
 427     m_pGenPo->setExtractCom("extracted from " + rExtSrc);
 428     m_pGenPo->setMsgStr(
 429         OString("Project-Id-Version: PACKAGE VERSION\n"
 430         "Report-Msgid-Bugs-To: https://bugs.libreoffice.org/enter_bug.cgi?"
 431         "product=LibreOffice&bug_status=UNCONFIRMED&component=UI\n"
 432         "POT-Creation-Date: ") + lcl_GetTime() +
 433         OString("\nPO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 434         "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 435         "Language-Team: LANGUAGE <LL@li.org>\n"
 436         "MIME-Version: 1.0\n"
 437         "Content-Type: text/plain; charset=UTF-8\n"
 438         "Content-Transfer-Encoding: 8bit\n"
 439         "X-Generator: LibreOffice\n"
 440         "X-Accelerator-Marker: ~\n"));
 441     m_bIsInitialized = true;
 442 }
 443
 444 PoHeader::~PoHeader()
 445 {
 446     delete m_pGenPo;
 447 }
 448
 449
 450 // Class PoOfstream
 451
 452
 453 PoOfstream::PoOfstream()
 454     : m_aOutPut()
 455     , m_bIsAfterHeader( false )
 456 {
 457 }
 458
 459 PoOfstream::PoOfstream(const OString& rFileName, OpenMode aMode )
 460     : m_aOutPut()
 461     , m_bIsAfterHeader( false )
 462 {
 463     open( rFileName, aMode );
 464 }
 465
 466 PoOfstream::~PoOfstream()
 467 {
 468     if( isOpen() )
 469     {
 470        close();
 471     }
 472 }
 473
 474 void PoOfstream::open(const OString& rFileName, OpenMode aMode )
 475 {
 476     assert( !isOpen() );
 477     if( aMode == TRUNC )
 478     {
 479         m_aOutPut.open( rFileName.getStr(),
 480             std::ios_base::out | std::ios_base::trunc );
 481         m_bIsAfterHeader = false;
 482     }
 483     else if( aMode == APP )
 484     {
 485         m_aOutPut.open( rFileName.getStr(),
 486             std::ios_base::out | std::ios_base::app );
 487         m_bIsAfterHeader = m_aOutPut.tellp() != std::ofstream::pos_type( 0 );
 488     }
 489 }
 490
 491 void PoOfstream::close()
 492 {
 493     assert( isOpen() );
 494     m_aOutPut.close();
 495 }
 496
 497 void PoOfstream::writeHeader(const PoHeader& rPoHeader)
 498 {
 499     assert( isOpen() && !m_bIsAfterHeader && rPoHeader.m_bIsInitialized );
 500     rPoHeader.m_pGenPo->writeToFile( m_aOutPut );
 501     m_bIsAfterHeader = true;
 502 }
 503
 504 void PoOfstream::writeEntry( const PoEntry& rPoEntry )
 505 {
 506     assert( isOpen() && m_bIsAfterHeader && rPoEntry.m_bIsInitialized );
 507     rPoEntry.m_pGenPo->writeToFile( m_aOutPut );
 508 }
 509
 510
 511 // Class PoIfstream
 512
 513
 514 namespace
 515 {
 516
 517 // Check the validity of read entry
 518 static bool lcl_CheckInputEntry(const GenPoEntry& rEntry)
 519 {
 520     const OString sMsgCtxt = rEntry.getMsgCtxt();
 521     const sal_Int32 nFirstEndLine = sMsgCtxt.indexOf('\n');
 522     const sal_Int32 nLastEndLine = sMsgCtxt.lastIndexOf('\n');
 523     const sal_Int32 nLastDot = sMsgCtxt.lastIndexOf('.');
 524     const OString sType = sMsgCtxt.copy( nLastDot + 1 );
 525     return !rEntry.getReference().isEmpty() &&
 526             nFirstEndLine > 0 &&
 527             (nLastEndLine == nFirstEndLine || nLastEndLine == sMsgCtxt.indexOf('\n',nFirstEndLine+1)) &&
 528             nLastDot - nLastEndLine > 1 &&
 529             (sType == "text" || sType == "quickhelptext" || sType == "title")&&
 530             !rEntry.getMsgId().isEmpty();
 531 }
 532
 533 }
 534
 535 PoIfstream::PoIfstream()
 536     : m_aInPut()
 537     , m_bEof( false )
 538 {
 539 }
 540
 541 PoIfstream::PoIfstream(const OString& rFileName)
 542     : m_aInPut()
 543     , m_bEof( false )
 544 {
 545     open( rFileName );
 546 }
 547
 548 PoIfstream::~PoIfstream()
 549 {
 550     if( isOpen() )
 551     {
 552        close();
 553     }
 554 }
 555
 556 void PoIfstream::open( const OString& rFileName )
 557 {
 558     assert( !isOpen() );
 559     m_aInPut.open( rFileName.getStr(), std::ios_base::in );
 560
 561     // Skip header
 562     std::string sTemp;
 563     std::getline(m_aInPut,sTemp);
 564     while( !sTemp.empty() && !m_aInPut.eof() )
 565     {
 566         std::getline(m_aInPut,sTemp);
 567     }
 568     m_bEof = false;
 569 }
 570
 571 void PoIfstream::close()
 572 {
 573     assert( isOpen() );
 574     m_aInPut.close();
 575 }
 576
 577 void PoIfstream::readEntry( PoEntry& rPoEntry )
 578 {
 579     assert( isOpen() && !eof() );
 580     GenPoEntry aGenPo;
 581     aGenPo.readFromFile( m_aInPut );
 582     if( aGenPo.isNull() )
 583     {
 584         m_bEof = true;
 585         rPoEntry = PoEntry();
 586     }
 587     else
 588     {
 589         if( lcl_CheckInputEntry(aGenPo) )
 590         {
 591             if( rPoEntry.m_pGenPo )
 592             {
 593                 *(rPoEntry.m_pGenPo) = aGenPo;
 594             }
 595             else
 596             {
 597                 rPoEntry.m_pGenPo = new GenPoEntry( aGenPo );
 598             }
 599             rPoEntry.m_bIsInitialized = true;
 600         }
 601         else
 602         {
 603             throw INVALIDENTRY;
 604         }
 605     }
 606 }
 607
 608 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */