l10ntools/source/xrmmerge.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 <cstring>
  23
  24 #include <stdio.h>
  25
  26 #include "common.hxx"
  27 #include "export.hxx"
  28 #include "po.hxx"
  29 #include "xrmlex.hxx"
  30 #include "xrmmerge.hxx"
  31 #include "tokens.h"
  32 #include "helper.hxx"
  33 #include <iostream>
  34 #include <fstream>
  35 #include <vector>
  36 #include <boost/scoped_array.hpp>
  37
  38 using namespace std;
  39
  40 void yyerror( const char * );
  41
  42 // set of global variables
  43 bool bMergeMode;
  44 bool bDisplayName;
  45 bool bExtensionDescription;
  46 OString sLanguage;
  47 OString sInputFileName;
  48 OString sOutputFile;
  49 OString sMergeSrc;
  50 OString sLangAttribute;
  51 OString sResourceType;
  52 XRMResParser *pParser = NULL;
  53
  54 extern "C" {
  55 // the whole interface to lexer is in this extern "C" section
  56
  57 extern bool GetOutputFile( int argc, char* argv[])
  58 {
  59     bDisplayName = false;
  60     bExtensionDescription = false;
  61
  62     common::HandledArgs aArgs;
  63     if ( common::handleArguments(argc, argv, aArgs) )
  64     {
  65         bMergeMode = aArgs.m_bMergeMode;
  66         sLanguage = aArgs.m_sLanguage;
  67         sInputFileName = aArgs.m_sInputFile;
  68         sOutputFile = aArgs.m_sOutputFile;
  69         sMergeSrc = aArgs.m_sMergeSrc;
  70         return true;
  71     }
  72     else
  73     {
  74         // command line is not valid
  75         common::writeUsage("xrmex","*.xrm/*.xml");
  76         return false;
  77     }
  78 }
  79
  80 int InitXrmExport( const char* pFilename)
  81 {
  82     // instanciate Export
  83     OString sFilename( pFilename );
  84
  85     if ( bMergeMode )
  86         pParser = new XRMResMerge( sMergeSrc, sOutputFile, sFilename );
  87       else if (!sOutputFile.isEmpty()) {
  88         pParser = new XRMResExport( sOutputFile, sInputFileName );
  89     }
  90
  91     return 1;
  92 }
  93
  94 int EndXrmExport()
  95 {
  96     delete pParser;
  97     return 1;
  98 }
  99 extern const char* getFilename()
 100 {
 101     return sInputFileName.getStr();
 102 }
 103
 104 extern FILE *GetXrmFile()
 105 {
 106     // look for valid filename
 107     if (!sInputFileName.isEmpty()) {
 108         //TODO: explicit BOM handling?
 109         FILE * pFile = fopen(sInputFileName.getStr(), "r");
 110         if ( !pFile ){
 111             fprintf( stderr, "Error: Could not open file %s\n",
 112                 sInputFileName.getStr());
 113         }
 114         else {
 115             return pFile;
 116         }
 117     }
 118     // this means the file could not be opened
 119     return NULL;
 120 }
 121
 122 int WorkOnTokenSet( int nTyp, char *pTokenText )
 123 {
 124     //printf("Typ = %d , text = '%s'\n",nTyp , pTokenText );
 125     pParser->Execute( nTyp, pTokenText );
 126
 127     return 1;
 128 }
 129
 130 int SetError()
 131 {
 132     pParser->SetError();
 133     return 1;
 134 }
 135 }
 136
 137 extern "C" {
 138
 139 int GetError()
 140 {
 141     return pParser->GetError();
 142 }
 143 }
 144
 145
 146 // class XRMResParser
 147
 148
 149
 150 XRMResParser::XRMResParser()
 151     : bError( false ),
 152     bText( false )
 153 {
 154 }
 155
 156 XRMResParser::~XRMResParser()
 157 {
 158 }
 159
 160 int XRMResParser::Execute( int nToken, char * pToken )
 161 {
 162     OString rToken( pToken );
 163
 164     switch ( nToken ) {
 165         case XRM_TEXT_START:{
 166                 OString sNewGID = GetAttribute( rToken, "id" );
 167                 if ( sNewGID != sGID ) {
 168                     sGID = sNewGID;
 169                 }
 170                 bText = true;
 171                 sCurrentText = "";
 172                 sCurrentOpenTag = rToken;
 173                 Output( rToken );
 174             }
 175         break;
 176
 177         case XRM_TEXT_END: {
 178                 sCurrentCloseTag = rToken;
 179                 sResourceType = OString ( "readmeitem" );
 180                 sLangAttribute = OString ( "xml:lang" );
 181                 WorkOnText( sCurrentOpenTag, sCurrentText );
 182                 Output( sCurrentText );
 183                 EndOfText( sCurrentOpenTag, sCurrentCloseTag );
 184                 bText = false;
 185                 rToken = OString("");
 186                 sCurrentText  = OString("");
 187         }
 188         break;
 189
 190         case DESC_DISPLAY_NAME_START:{
 191                 bDisplayName = true;
 192             }
 193         break;
 194
 195         case DESC_DISPLAY_NAME_END:{
 196                 bDisplayName = false;
 197             }
 198         break;
 199
 200         case DESC_TEXT_START:{
 201                 if (bDisplayName) {
 202                     sGID = OString("dispname");
 203                     bText = true;
 204                     sCurrentText = "";
 205                     sCurrentOpenTag = rToken;
 206                     Output( rToken );
 207                 }
 208             }
 209         break;
 210
 211         case DESC_TEXT_END: {
 212                 if (bDisplayName) {
 213                     sCurrentCloseTag = rToken;
 214                     sResourceType = OString ( "description" );
 215                     sLangAttribute = OString ( "lang" );
 216                     WorkOnText( sCurrentOpenTag, sCurrentText );
 217                     Output( sCurrentText );
 218                     EndOfText( sCurrentOpenTag, sCurrentCloseTag );
 219                     bText = false;
 220                     rToken = OString("");
 221                     sCurrentText  = OString("");
 222                 }
 223         }
 224         break;
 225
 226         case DESC_EXTENSION_DESCRIPTION_START: {
 227                 bExtensionDescription = true;
 228             }
 229         break;
 230
 231         case DESC_EXTENSION_DESCRIPTION_END: {
 232                 bExtensionDescription = false;
 233             }
 234         break;
 235
 236         case DESC_EXTENSION_DESCRIPTION_SRC: {
 237                 if (bExtensionDescription) {
 238                     sGID = OString("extdesc");
 239                     sResourceType = OString ( "description" );
 240                     sLangAttribute = OString ( "lang" );
 241                     sCurrentOpenTag = rToken;
 242                     sCurrentText  = OString("");
 243                     Output( rToken );
 244                     WorkOnDesc( sCurrentOpenTag, sCurrentText );
 245                     sCurrentCloseTag = rToken;
 246                     Output( sCurrentText );
 247                     rToken = OString("");
 248                     sCurrentText  = OString("");
 249                 }
 250             }
 251         break;
 252
 253         default:
 254             if ( bText ) {
 255                 sCurrentText += rToken;
 256             }
 257         break;
 258     }
 259
 260     if ( !bText )
 261     {
 262         Output( rToken );
 263     }
 264     return 0;
 265 }
 266
 267 OString XRMResParser::GetAttribute( const OString &rToken, const OString &rAttribute )
 268 {
 269     OString sTmp( rToken );
 270     sTmp = sTmp.replace('\t', ' ');
 271
 272     OString sSearch( " " );
 273     sSearch += rAttribute;
 274     sSearch += "=";
 275     sal_Int32 nPos = sTmp.indexOf( sSearch );
 276
 277     if ( nPos != -1 )
 278     {
 279         sTmp = sTmp.copy( nPos );
 280         OString sId = sTmp.getToken(1, '"');
 281         return sId;
 282     }
 283     return OString();
 284 }
 285
 286
 287 void XRMResParser::Error( const OString &rError )
 288 {
 289     yyerror(rError.getStr());
 290 }
 291
 292
 293 // class XMLResExport
 294
 295
 296 XRMResExport::XRMResExport(
 297     const OString &rOutputFile, const OString &rFilePath )
 298                 : XRMResParser(),
 299                 pResData( NULL ),
 300                 sPath( rFilePath )
 301 {
 302     pOutputStream.open( rOutputFile, PoOfstream::APP );
 303     if (!pOutputStream.isOpen())
 304     {
 305         OString sError( "Unable to open output file: " );
 306         sError += rOutputFile;
 307         Error( sError );
 308     }
 309 }
 310
 311 XRMResExport::~XRMResExport()
 312 {
 313     pOutputStream.close();
 314     delete pResData;
 315 }
 316
 317 void XRMResExport::Output( const OString& ) {}
 318
 319 void XRMResExport::WorkOnDesc(
 320     const OString &rOpenTag,
 321     OString &rText )
 322 {
 323     OString sDescFileName(
 324         sInputFileName.replaceAll("description.xml", OString()));
 325     sDescFileName += GetAttribute( rOpenTag, "xlink:href" );
 326     ifstream file (sDescFileName.getStr(), ios::in|ios::binary|ios::ate);
 327     if (file.is_open()) {
 328         int size = static_cast<int>(file.tellg());
 329         boost::scoped_array<char> memblock(new char [size+1]);
 330         file.seekg (0, ios::beg);
 331         file.read (memblock.get(), size);
 332         file.close();
 333         memblock[size] = '\0';
 334         rText = OString(memblock.get());
 335      }
 336     WorkOnText( rOpenTag, rText );
 337     EndOfText( rOpenTag, rOpenTag );
 338 }
 339
 340 void XRMResExport::WorkOnText(
 341     const OString &rOpenTag,
 342     OString &rText )
 343 {
 344     OString sLang( GetAttribute( rOpenTag, sLangAttribute ));
 345
 346     if ( !pResData )
 347     {
 348         pResData = new ResData( GetGID() );
 349     }
 350     pResData->sText[sLang] = rText;
 351 }
 352
 353 void XRMResExport::EndOfText(
 354     const OString &,
 355     const OString & )
 356 {
 357     if ( pResData )
 358     {
 359         OString sAct = pResData->sText["en-US"];
 360
 361         if( !sAct.isEmpty() )
 362             common::writePoEntry(
 363                 "Xrmex", pOutputStream, sPath, sResourceType,
 364                 pResData->sGId, OString(), OString(), sAct );
 365     }
 366     delete pResData;
 367     pResData = NULL;
 368 }
 369
 370
 371 // class XRMResMerge
 372
 373
 374 XRMResMerge::XRMResMerge(
 375     const OString &rMergeSource, const OString &rOutputFile,
 376     const OString &rFilename )
 377                 : XRMResParser(),
 378                 pMergeDataFile( NULL ),
 379                 sFilename( rFilename ) ,
 380                 pResData( NULL )
 381 {
 382     if (!rMergeSource.isEmpty() && sLanguage.equalsIgnoreAsciiCase("ALL"))
 383     {
 384         pMergeDataFile = new MergeDataFile(
 385             rMergeSource, sInputFileName, false);
 386         aLanguages = pMergeDataFile->GetLanguages();
 387     }
 388     else
 389         aLanguages.push_back( sLanguage );
 390     pOutputStream.open(
 391         rOutputFile.getStr(), std::ios_base::out | std::ios_base::trunc);
 392     if (!pOutputStream.is_open()) {
 393         OString sError( "Unable to open output file: " );
 394         sError += rOutputFile;
 395         Error( sError );
 396     }
 397 }
 398
 399 XRMResMerge::~XRMResMerge()
 400 {
 401     pOutputStream.close();
 402     delete pMergeDataFile;
 403     delete pResData;
 404 }
 405
 406 void XRMResMerge::WorkOnDesc(
 407     const OString &rOpenTag,
 408     OString &rText )
 409 {
 410     WorkOnText( rOpenTag, rText);
 411     if ( pMergeDataFile && pResData ) {
 412         MergeEntrys *pEntrys = pMergeDataFile->GetMergeEntrys( pResData );
 413         if ( pEntrys ) {
 414             OString sCur;
 415             OString sDescFilename = GetAttribute ( rOpenTag, "xlink:href" );
 416             for( unsigned int n = 0; n < aLanguages.size(); n++ ){
 417                 sCur = aLanguages[ n ];
 418                 OString sContent;
 419                 if ( !sCur.equalsIgnoreAsciiCase("en-US")  &&
 420                     ( pEntrys->GetText(
 421                         sContent, STRING_TYP_TEXT, sCur, true )) &&
 422                     !sContent.isEmpty())
 423                 {
 424                     OString sText( sContent );
 425                     OString sAdditionalLine( "\n        " );
 426                     sAdditionalLine += rOpenTag;
 427                     OString sSearch = sLangAttribute;
 428                     sSearch += "=\"";
 429                     OString sReplace( sSearch );
 430
 431                     sSearch += GetAttribute( rOpenTag, sLangAttribute );
 432                     sReplace += sCur;
 433                     sAdditionalLine = sAdditionalLine.replaceFirst(
 434                         sSearch, sReplace);
 435
 436                     sSearch = OString("xlink:href=\"");
 437                     sReplace = sSearch;
 438
 439                     OString sLocDescFilename = sDescFilename;
 440                     sLocDescFilename = sLocDescFilename.replaceFirst(
 441                         "en-US", sCur);
 442
 443                     sSearch += sDescFilename;
 444                     sReplace += sLocDescFilename;
 445                     sAdditionalLine = sAdditionalLine.replaceFirst(
 446                         sSearch, sReplace);
 447
 448                     Output( sAdditionalLine );
 449
 450                     sal_Int32 i = sOutputFile.lastIndexOf('/');
 451                     if (i == -1) {
 452                         std::cerr
 453                             << "Error: output file " << sOutputFile.getStr()
 454                             << " does not contain any /\n";
 455                         throw false; //TODO
 456                     }
 457                     OString sOutputDescFile(
 458                         sOutputFile.copy(0, i + 1) + sLocDescFilename);
 459                     ofstream file(sOutputDescFile.getStr());
 460                     if (file.is_open()) {
 461                         file << sText.getStr();
 462                         file.close();
 463                     } else {
 464                         std::cerr
 465                             << "Error: cannot write "
 466                             << sOutputDescFile.getStr() << '\n';
 467                         throw false; //TODO
 468                     }
 469                 }
 470             }
 471         }
 472     }
 473     delete pResData;
 474     pResData = NULL;
 475 }
 476
 477 void XRMResMerge::WorkOnText(
 478     const OString &,
 479     OString & )
 480 {
 481     if ( pMergeDataFile ) {
 482         if ( !pResData ) {
 483             pResData = new ResData( GetGID(), sFilename );
 484             pResData->sResTyp = sResourceType;
 485         }
 486     }
 487 }
 488
 489 void XRMResMerge::Output( const OString& rOutput )
 490 {
 491     if (!rOutput.isEmpty())
 492         pOutputStream << rOutput.getStr();
 493 }
 494
 495 void XRMResMerge::EndOfText(
 496     const OString &rOpenTag,
 497     const OString &rCloseTag )
 498 {
 499
 500     Output( rCloseTag );
 501     if ( pMergeDataFile && pResData ) {
 502         MergeEntrys *pEntrys = pMergeDataFile->GetMergeEntrys( pResData );
 503         if ( pEntrys ) {
 504             OString sCur;
 505             for( unsigned int n = 0; n < aLanguages.size(); n++ ){
 506                 sCur = aLanguages[ n ];
 507                 OString sContent;
 508                 if (!sCur.equalsIgnoreAsciiCase("en-US") &&
 509                     ( pEntrys->GetText(
 510                         sContent, STRING_TYP_TEXT, sCur, true )) &&
 511                     !sContent.isEmpty() &&
 512                     helper::isWellFormedXML( sContent ))
 513                 {
 514                     OString sText( sContent );
 515                     OString sAdditionalLine( "\n        " );
 516                     sAdditionalLine += rOpenTag;
 517                     OString sSearch = sLangAttribute;
 518                     sSearch += "=\"";
 519                     OString sReplace( sSearch );
 520
 521                     sSearch += GetAttribute( rOpenTag, sLangAttribute );
 522                     sReplace += sCur;
 523
 524                     sAdditionalLine = sAdditionalLine.replaceFirst(
 525                         sSearch, sReplace);
 526
 527                     sAdditionalLine += sText;
 528                     sAdditionalLine += rCloseTag;
 529
 530                     Output( sAdditionalLine );
 531                 }
 532             }
 533         }
 534     }
 535     delete pResData;
 536     pResData = NULL;
 537 }
 538
 539 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */