transex3/source/export2.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: export2.cxx,v $
  10  * $Revision: 1.43 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_transex3.hxx"
  33 #include "export.hxx"
  34 #include "utf8conv.hxx"
  35 #include <tools/datetime.hxx>
  36 #include <tools/isofallback.hxx>
  37 #include <stdio.h>
  38 #include <osl/time.h>
  39 #include <osl/process.h>
  40 #include <rtl/ustring.hxx>
  41 #include <iostream>
  42 #include <iomanip>
  43 #include <tools/urlobj.hxx>
  44 #include <time.h>
  45
  46 using namespace std;
  47 //
  48 // class ResData();
  49 //
  50
  51 /*****************************************************************************/
  52 ResData::~ResData()
  53 /*****************************************************************************/
  54 {
  55     if ( pStringList ) {
  56         // delete existing res. of type StringList
  57         for ( ULONG i = 0; i < pStringList->Count(); i++ ) {
  58             ExportListEntry* test = pStringList->GetObject( i );
  59             if( test != NULL ) delete test;
  60         }
  61         delete pStringList;
  62     }
  63     if ( pFilterList ) {
  64         // delete existing res. of type FilterList
  65         for ( ULONG i = 0; i < pFilterList->Count(); i++ ) {
  66             ExportListEntry* test = pFilterList->GetObject( i );
  67             delete test;
  68         }
  69         delete pFilterList;
  70     }
  71     if ( pItemList ) {
  72         // delete existing res. of type ItemList
  73         for ( ULONG i = 0; i < pItemList->Count(); i++ ) {
  74             ExportListEntry* test = pItemList->GetObject( i );
  75             delete test;
  76         }
  77         delete pItemList;
  78     }
  79     if ( pUIEntries ) {
  80         // delete existing res. of type UIEntries
  81         for ( ULONG i = 0; i < pUIEntries->Count(); i++ ) {
  82             ExportListEntry* test = pUIEntries->GetObject( i );
  83             delete test;
  84         }
  85         delete pUIEntries;
  86     }
  87 }
  88
  89 //
  90 // class Export
  91 //
  92
  93 /*****************************************************************************/
  94 ByteString Export::sLanguages;
  95 ByteString Export::sForcedLanguages;
  96 ByteString Export::sIsoCode99;
  97 /*****************************************************************************/
  98
  99 void Export::DumpExportList( ByteString& sListName , ExportList& aList ){
 100     printf( "%s\n", sListName.GetBuffer() );
 101     ByteString l("");
 102     ExportListEntry* aEntry;
 103     for( unsigned int x = 0; x < aList.Count() ; x++ ){
 104         aEntry = (ExportListEntry*) aList.GetObject( x );
 105         Export::DumpMap( l , *aEntry );
 106     }
 107     printf("\n");
 108 }
 109 ByteString Export::DumpMap( ByteString& sMapName , ByteStringHashMap& aMap ){
 110     ByteStringHashMap::const_iterator idbg;
 111     ByteString sReturn;
 112
 113     if( sMapName.Len() )
 114         printf("MapName %s\n", sMapName.GetBuffer());
 115     if( aMap.size() < 1 ) return ByteString();
 116     for( idbg = aMap.begin() ; idbg != aMap.end(); ++idbg ){
 117         ByteString a( idbg->first );
 118         ByteString b( idbg->second );
 119         printf("[%s]= %s",a.GetBuffer(),b.GetBuffer());
 120         printf("\n");
 121     }
 122     printf("\n");
 123     return sReturn;
 124 }
 125 /*****************************************************************************/
 126 void Export::SetLanguages( std::vector<ByteString> val ){
 127 /*****************************************************************************/
 128     aLanguages = val;
 129     isInitialized = true;
 130 }
 131 /*****************************************************************************/
 132 std::vector<ByteString> Export::GetLanguages(){
 133 /*****************************************************************************/
 134     return aLanguages;
 135 }
 136 /*****************************************************************************/
 137 std::vector<ByteString> Export::GetForcedLanguages(){
 138 /*****************************************************************************/
 139     return aForcedLanguages;
 140 }
 141 std::vector<ByteString> Export::aLanguages       = std::vector<ByteString>();
 142 std::vector<ByteString> Export::aForcedLanguages = std::vector<ByteString>();
 143
 144
 145 /*****************************************************************************/
 146 void Export::QuotHTMLXRM( ByteString &rString )
 147 /*****************************************************************************/
 148 {
 149     ByteString sReturn;
 150     //BOOL bBreak = FALSE;
 151     for ( USHORT i = 0; i < rString.Len(); i++ ) {
 152         ByteString sTemp = rString.Copy( i );
 153         if ( sTemp.Search( "<Arg n=" ) == 0 ) {
 154             while ( i < rString.Len() && rString.GetChar( i ) != '>' ) {
 155                  sReturn += rString.GetChar( i );
 156                 i++;
 157             }
 158             if ( rString.GetChar( i ) == '>' ) {
 159                 sReturn += ">";
 160                 i++;
 161             }
 162         }
 163
 164         if ( i < rString.Len()) {
 165             switch ( rString.GetChar( i )) {
 166                 case '<':
 167                     if( i+2 < rString.Len() &&
 168                         (rString.GetChar( i+1 ) == 'b' || rString.GetChar( i+1 ) == 'B') &&
 169                         rString.GetChar( i+2 ) == '>' )
 170                     {
 171                            sReturn +="<b>";
 172                            i += 2;
 173                     }
 174                     else if( i+3 < rString.Len() &&
 175                              rString.GetChar( i+1 ) == '/' &&
 176                              (rString.GetChar( i+2 ) == 'b' || rString.GetChar( i+2 ) == 'B') &&
 177                              rString.GetChar( i+3 ) == '>' )
 178                     {
 179                            sReturn +="</b>";
 180                            i += 3;
 181                     }
 182                     else
 183                         sReturn += "&lt;";
 184                 break;
 185
 186                 case '>':
 187                     sReturn += "&gt;";
 188                 break;
 189
 190                 case '\"':
 191                     sReturn += "&quot;";
 192                 break;
 193
 194                 case '\'':
 195                     sReturn += "&apos;";
 196                 break;
 197
 198                 case '&':
 199                     if ((( i + 4 ) < rString.Len()) &&
 200                         ( rString.Copy( i, 5 ) == "&amp;" ))
 201                             sReturn += rString.GetChar( i );
 202                     else
 203                         sReturn += "&amp;";
 204                 break;
 205
 206                 default:
 207                     sReturn += rString.GetChar( i );
 208                 break;
 209             }
 210         }
 211     }
 212     rString = sReturn;
 213 }
 214 /*****************************************************************************/
 215 void Export::QuotHTML( ByteString &rString )
 216 /*****************************************************************************/
 217 {
 218     ByteString sReturn;
 219     for ( USHORT i = 0; i < rString.Len(); i++ ) {
 220         ByteString sTemp = rString.Copy( i );
 221         if ( sTemp.Search( "<Arg n=" ) == 0 ) {
 222             while ( i < rString.Len() && rString.GetChar( i ) != '>' ) {
 223                  sReturn += rString.GetChar( i );
 224                 i++;
 225             }
 226             if ( rString.GetChar( i ) == '>' ) {
 227                 sReturn += ">";
 228                 i++;
 229             }
 230         }
 231         if ( i < rString.Len()) {
 232             switch ( rString.GetChar( i )) {
 233                 case '<':
 234                     sReturn += "&lt;";
 235                 break;
 236
 237                 case '>':
 238                     sReturn += "&gt;";
 239                 break;
 240
 241                 case '\"':
 242                     sReturn += "&quot;";
 243                 break;
 244
 245                 case '\'':
 246                     sReturn += "&apos;";
 247                 break;
 248
 249                 case '&':
 250                     if ((( i + 4 ) < rString.Len()) &&
 251                         ( rString.Copy( i, 5 ) == "&amp;" ))
 252                             sReturn += rString.GetChar( i );
 253                     else
 254                         sReturn += "&amp;";
 255                 break;
 256
 257                 default:
 258                     sReturn += rString.GetChar( i );
 259                 break;
 260             }
 261         }
 262     }
 263     rString = sReturn;
 264 }
 265
 266 void Export::RemoveUTF8ByteOrderMarker( ByteString &rString ){
 267     if( hasUTF8ByteOrderMarker( rString ) )
 268         rString.Erase( 0 , 3 );
 269 }
 270
 271 bool Export::hasUTF8ByteOrderMarker( const ByteString &rString ){
 272     // Byte order marker signature
 273
 274     const unsigned char c1 =  0xEF;
 275     const unsigned char c2 =  0xBB;
 276     const unsigned char c3 =  0xBF;
 277
 278     const char bom[ 3 ] = { c1 , c2 , c3 };
 279
 280     return      rString.Len() >= 3 &&
 281                 rString.GetChar( 0 ) == bom[ 0 ] &&
 282                 rString.GetChar( 1 ) == bom[ 1 ] &&
 283                 rString.GetChar( 2 ) == bom[ 2 ] ;
 284 }
 285 bool Export::fileHasUTF8ByteOrderMarker( const ByteString &rString ){
 286     SvFileStream aFileIn( String( rString , RTL_TEXTENCODING_ASCII_US ) , STREAM_READ );
 287     ByteString sLine;
 288     if( !aFileIn.IsEof() ) {
 289         aFileIn.ReadLine( sLine );
 290         if( aFileIn.IsOpen() ) aFileIn.Close();
 291         return hasUTF8ByteOrderMarker( sLine );
 292     }
 293     if( aFileIn.IsOpen() ) aFileIn.Close();
 294     return false;
 295 }
 296 void Export::RemoveUTF8ByteOrderMarkerFromFile( const ByteString &rFilename ){
 297     SvFileStream aFileIn( String( rFilename , RTL_TEXTENCODING_ASCII_US ) , STREAM_READ );
 298     ByteString sLine;
 299     if( !aFileIn.IsEof() ) {
 300         aFileIn.ReadLine( sLine );
 301         // Test header
 302         if( hasUTF8ByteOrderMarker( sLine ) ){
 303             //cout << "UTF8 Header found!\n";
 304             DirEntry aTempFile = Export::GetTempFile();
 305             ByteString sTempFile = ByteString( aTempFile.GetFull() , RTL_TEXTENCODING_ASCII_US );
 306             SvFileStream aNewFile( String( sTempFile , RTL_TEXTENCODING_ASCII_US ) , STREAM_WRITE );
 307             // Remove header
 308             RemoveUTF8ByteOrderMarker( sLine );
 309             //cout << "Copy stripped stuff to " << sTempFile.GetBuffer() << endl;
 310             aNewFile.WriteLine( sLine );
 311             // Copy the rest
 312             while( !aFileIn.IsEof() ){
 313                 aFileIn.ReadLine( sLine );
 314                 aNewFile.WriteLine( sLine );
 315             }
 316             if( aFileIn.IsOpen() ) aFileIn.Close();
 317             if( aNewFile.IsOpen() ) aNewFile.Close();
 318             DirEntry aEntry( rFilename.GetBuffer() );
 319             //cout << "Removing file " << rFilename.GetBuffer() << "\n";
 320             aEntry.Kill();
 321             //cout << "Renaming file " << sTempFile.GetBuffer() << " to " << rFilename.GetBuffer() << "\n";
 322             DirEntry( sTempFile ).MoveTo( DirEntry( rFilename.GetBuffer() ) );
 323         }
 324     }
 325     if( aFileIn.IsOpen() ) aFileIn.Close();
 326 }
 327
 328 // Merge it into source code!
 329 //bool Export::isMergingGermanAllowed( const ByteString& rPrj ){
 330 //    (void) rPrj;
 331 //      return true;
 332 /*      static ByteStringBoolHashMap aHash;
 333
 334     if( aHash.find( rPrj ) != aHash.end() ){
 335         return aHash[ rPrj ];
 336     }
 337
 338     ByteString sFile = Export::GetEnv( "SRC_ROOT" ) ;
 339     sFile.Append("/");
 340     sFile.Append( rPrj );
 341     sFile.Append("/prj/l10n");
 342 #if defined(WNT) || defined(OS2)
 343     sFile.SearchAndReplaceAll('/','\\');
 344 #endif
 345     DirEntry aFlagfile( sFile );
 346
 347     aHash[ rPrj ] = !aFlagfile.Exists();
 348     return aHash[ rPrj ];*/
 349 //}
 350 bool Export::CopyFile( const ByteString& source , const ByteString& dest )
 351 {
 352 //    cout << "CopyFile( " << source.GetBuffer() << " , " << dest.GetBuffer() << " )\n";
 353     const int BUFFERSIZE    = 8192;
 354     char buf[ BUFFERSIZE ];
 355
 356     FILE*  IN_FILE = fopen( source.GetBuffer() , "r" );
 357     FILE* OUT_FILE = fopen( dest.GetBuffer() , "w" );
 358
 359     if( IN_FILE == NULL )
 360     {
 361         cerr << "Export::CopyFile WARNING: Could not open " << source.GetBuffer() << "\n";
 362         return false;
 363     }
 364     if( OUT_FILE == NULL )
 365     {
 366         cerr << "Export::CopyFile WARNING: Could not open/create " << dest.GetBuffer() << " for writing\n";
 367         return false;
 368     }
 369
 370     while( fgets( buf , BUFFERSIZE , IN_FILE ) != NULL )
 371     {
 372         if( fputs( buf , OUT_FILE ) == EOF )
 373         {
 374             cerr << "Export::CopyFile WARNING: Write problems " << source.GetBuffer() << "\n";
 375             fclose( IN_FILE );
 376             fclose( OUT_FILE );
 377             return false;
 378         }
 379     }
 380     if( ferror( IN_FILE ) )
 381     {
 382         cerr << "Export::CopyFile WARNING: Read problems " << dest.GetBuffer() << "\n";
 383         fclose( IN_FILE );
 384         fclose( OUT_FILE );
 385         return false;
 386     }
 387     fclose ( IN_FILE );
 388     fclose ( OUT_FILE );
 389
 390     return true;
 391 }
 392
 393 /*****************************************************************************/
 394 void Export::UnquotHTML( ByteString &rString )
 395 /*****************************************************************************/
 396 {
 397     ByteString sReturn;
 398     while ( rString.Len()) {
 399         if ( rString.Copy( 0, 5 ) == "&amp;" ) {
 400             sReturn += "&";
 401             rString.Erase( 0, 5 );
 402         }
 403         else if ( rString.Copy( 0, 4 ) == "&lt;" ) {
 404             sReturn += "<";
 405             rString.Erase( 0, 4 );
 406         }
 407         else if ( rString.Copy( 0, 4 ) == "&gt;" ) {
 408             sReturn += ">";
 409             rString.Erase( 0, 4 );
 410         }
 411         else if ( rString.Copy( 0, 6 ) == "&quot;" ) {
 412             sReturn += "\"";
 413             rString.Erase( 0, 6 );
 414         }
 415         else if ( rString.Copy( 0, 6 ) == "&apos;" ) {
 416             sReturn += "\'";
 417             rString.Erase( 0, 6 );
 418         }
 419         else {
 420             sReturn += rString.GetChar( 0 );
 421             rString.Erase( 0, 1 );
 422         }
 423     }
 424     rString = sReturn;
 425 }
 426 bool Export::isSourceLanguage( const ByteString &sLanguage )
 427 {
 428     return !isAllowed( sLanguage );
 429 }
 430 bool Export::isAllowed( const ByteString &sLanguage ){
 431     return ! ( sLanguage.EqualsIgnoreCaseAscii("en-US") );
 432 }
 433 /*****************************************************************************/
 434 bool Export::LanguageAllowed( const ByteString &nLanguage )
 435 /*****************************************************************************/
 436 {
 437     return std::find( aLanguages.begin() , aLanguages.end() , nLanguage ) != aLanguages.end();
 438 }
 439
 440 bool Export::isInitialized = false;
 441
 442 /*****************************************************************************/
 443 void Export::InitLanguages( bool bMergeMode ){
 444 /*****************************************************************************/
 445     if( !isInitialized ){
 446         ByteString sTmp;
 447         ByteStringBoolHashMap aEnvLangs;
 448         for ( USHORT x = 0; x < sLanguages.GetTokenCount( ',' ); x++ ){
 449             sTmp = sLanguages.GetToken( x, ',' ).GetToken( 0, '=' );
 450             sTmp.EraseLeadingAndTrailingChars();
 451             if( bMergeMode && !isAllowed( sTmp ) ){}
 452             else if( !( (sTmp.GetChar(0)=='x' || sTmp.GetChar(0)=='X') && sTmp.GetChar(1)=='-' ) ){
 453                 aLanguages.push_back( sTmp );
 454             }
 455         }
 456         InitForcedLanguages( bMergeMode );
 457         isInitialized = true;
 458     }
 459 }
 460 /*****************************************************************************/
 461 void Export::InitForcedLanguages( bool bMergeMode ){
 462 /*****************************************************************************/
 463     ByteString sTmp;
 464     ByteStringBoolHashMap aEnvLangs;
 465     for ( USHORT x = 0; x < sForcedLanguages.GetTokenCount( ',' ); x++ ){
 466         sTmp = sForcedLanguages.GetToken( x, ',' ).GetToken( 0, '=' );
 467         sTmp.EraseLeadingAndTrailingChars();
 468         if( bMergeMode && isAllowed( sTmp ) ){}
 469         else if( !( (sTmp.GetChar(0)=='x' || sTmp.GetChar(0)=='X') && sTmp.GetChar(1)=='-' ) )
 470             aForcedLanguages.push_back( sTmp );
 471     }
 472 }
 473
 474 /*****************************************************************************/
 475 ByteString Export::GetFallbackLanguage( const ByteString nLanguage )
 476 /*****************************************************************************/
 477 {
 478     ByteString sFallback=nLanguage;
 479     GetIsoFallback( sFallback );
 480     return sFallback;
 481 }
 482
 483 void Export::replaceEncoding( ByteString& rString )
 484 {
 485 // &#x2122; -> \u2122
 486
 487     for( xub_StrLen idx = 0; idx <= rString.Len()-8 ; idx++ )
 488     {
 489         if( rString.GetChar( idx )   == '&' &&
 490             rString.GetChar( idx+1 ) == '#' &&
 491             rString.GetChar( idx+2 ) == 'x' &&
 492             rString.GetChar( idx+7 ) == ';' )
 493         {
 494             ByteString sTmp = rString.Copy( 0 , idx );
 495             sTmp.Append( "\\u" );
 496             sTmp.Append( rString.GetChar( idx+3 ) );
 497             sTmp.Append( rString.GetChar( idx+4 ) );
 498             sTmp.Append( rString.GetChar( idx+5 ) );
 499             sTmp.Append( rString.GetChar( idx+6 ) );
 500             sTmp.Append( rString.Copy( idx+8 , rString.Len() ) );
 501             rString = sTmp;
 502          }
 503     }
 504 }
 505
 506 /*****************************************************************************/
 507 void Export::FillInFallbacks( ResData *pResData )
 508 /*****************************************************************************/
 509 {
 510     ByteString sCur;
 511     for( unsigned int n = 0; n < aLanguages.size(); n++ ){
 512         sCur = aLanguages[ n ];
 513         if( isAllowed( sCur )  ){
 514             ByteString nFallbackIndex = GetFallbackLanguage( sCur );
 515             if( nFallbackIndex.Len() ){
 516                 if ( !pResData->sText[ sCur ].Len())
 517                     pResData->sText[ sCur ] =
 518                         pResData->sText[ nFallbackIndex ];
 519
 520                 if ( !pResData->sHelpText[ sCur ].Len())
 521                     pResData->sHelpText[ sCur ] =
 522                         pResData->sHelpText[ nFallbackIndex ];
 523
 524                 if ( !pResData->sQuickHelpText[ sCur ].Len())
 525                     pResData->sQuickHelpText[ sCur ] =
 526                         pResData->sQuickHelpText[ nFallbackIndex ];
 527
 528                 if ( !pResData->sTitle[ sCur ].Len())
 529                     pResData->sTitle[ sCur ] =
 530                         pResData->sTitle[ nFallbackIndex ];
 531
 532                 if ( pResData->pStringList )
 533                     FillInListFallbacks(
 534                         pResData->pStringList, sCur, nFallbackIndex );
 535
 536                 if ( pResData->pPairedList )
 537                     FillInListFallbacks(
 538                         pResData->pPairedList, sCur, nFallbackIndex );
 539
 540                 if ( pResData->pFilterList )
 541                     FillInListFallbacks(
 542                         pResData->pFilterList, sCur, nFallbackIndex );
 543
 544                 if ( pResData->pItemList )
 545                     FillInListFallbacks(
 546                         pResData->pItemList, sCur, nFallbackIndex );
 547
 548                 if ( pResData->pUIEntries )
 549                     FillInListFallbacks(
 550                         pResData->pUIEntries, sCur, nFallbackIndex );
 551             }
 552         }
 553     }
 554 }
 555
 556 /*****************************************************************************/
 557 void Export::FillInListFallbacks(
 558     ExportList *pList, const ByteString &nSource, const ByteString &nFallback )
 559 /*****************************************************************************/
 560 {
 561
 562     for ( ULONG i = 0; i < pList->Count(); i++ ) {
 563         ExportListEntry *pEntry = pList->GetObject( i );
 564         if ( !( *pEntry )[ nSource ].Len()){
 565              ( *pEntry )[ nSource ] = ( *pEntry )[ nFallback ];
 566             ByteString x = ( *pEntry )[ nSource ];
 567             ByteString y = ( *pEntry )[ nFallback ];
 568         }
 569     }
 570 }
 571
 572 /*****************************************************************************/
 573 ByteString Export::GetTimeStamp()
 574 /*****************************************************************************/
 575 {
 576 //      return "xx.xx.xx";
 577     char buf[20];
 578     Time aTime;
 579
 580     snprintf(buf, sizeof(buf), "%8d %02d:%02d:%02d", int(Date().GetDate()),
 581         int(aTime.GetHour()), int(aTime.GetMin()), int(aTime.GetSec()));
 582     return ByteString(buf);
 583 }
 584
 585 /*****************************************************************************/
 586 BOOL Export::ConvertLineEnds(
 587     ByteString sSource, ByteString sDestination )
 588 /*****************************************************************************/
 589 {
 590     String sSourceFile( sSource, RTL_TEXTENCODING_ASCII_US );
 591     String sDestinationFile( sDestination, RTL_TEXTENCODING_ASCII_US );
 592
 593     SvFileStream aSource( sSourceFile, STREAM_READ );
 594     if ( !aSource.IsOpen())
 595         return FALSE;
 596     SvFileStream aDestination( sDestinationFile, STREAM_STD_WRITE | STREAM_TRUNC );
 597     if ( !aDestination.IsOpen()) {
 598         aSource.Close();
 599         return FALSE;
 600     }
 601
 602     ByteString sLine;
 603
 604     while ( !aSource.IsEof()) {
 605         aSource.ReadLine( sLine );
 606         if ( !aSource.IsEof()) {
 607             sLine.EraseAllChars( '\r' );
 608             aDestination.WriteLine( sLine );
 609         }
 610         else
 611             aDestination.WriteByteString( sLine );
 612     }
 613
 614     aSource.Close();
 615     aDestination.Close();
 616
 617     return TRUE;
 618 }
 619
 620 /*****************************************************************************/
 621 ByteString Export::GetNativeFile( ByteString sSource )
 622 /*****************************************************************************/
 623 {
 624     DirEntry aTemp( GetTempFile());
 625     ByteString sReturn( aTemp.GetFull(), RTL_TEXTENCODING_ASCII_US );
 626
 627     for ( USHORT i = 0; i < 10; i++ )
 628         if ( ConvertLineEnds( sSource, sReturn ))
 629             return sReturn;
 630
 631     return "";
 632 }
 633
 634 const char* Export::GetEnv( const char *pVar )
 635 {
 636         char *pRet = getenv( pVar );
 637         if ( !pRet )
 638             pRet = 0;
 639         return pRet;
 640 }
 641
 642
 643 int Export::getCurrentDirectory( rtl::OUString& base_fqurl_out, rtl::OUString& base_out )
 644 {
 645     DirEntry aDir(".");
 646     aDir.ToAbs();
 647     base_out = rtl::OUString( aDir.GetFull() );
 648     return osl::File::getFileURLFromSystemPath( base_out , base_fqurl_out );
 649 }
 650
 651
 652 // Stolen from sal/osl/unx/tempfile.c
 653
 654 #define RAND_NAME_LENGTH 6
 655
 656 void Export::getRandomName( const ByteString& sPrefix , ByteString& sRandStr , const ByteString& sPostfix )
 657 {
 658     static const char LETTERS[]        = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
 659     static const int  COUNT_OF_LETTERS = sizeof(LETTERS)/sizeof(LETTERS[0]) - 1;
 660     sRandStr.Append( sPrefix );
 661
 662     static sal_uInt64 value;
 663     char     buffer[RAND_NAME_LENGTH];
 664
 665     TimeValue                   tv;
 666     sal_uInt64                  v;
 667     int                                 i;
 668
 669     osl_getSystemTime( &tv );
 670     oslProcessInfo      proInfo;
 671     osl_getProcessInfo( 0 , osl_Process_IDENTIFIER , &proInfo );
 672
 673     value += ((sal_uInt64) ( tv.Nanosec / 1000 ) << 16) ^ ( tv.Nanosec / 1000 ) ^ proInfo.Ident;
 674
 675     v = value;
 676
 677     for (i = 0; i < RAND_NAME_LENGTH; i++)
 678     {
 679         buffer[i] = LETTERS[v % COUNT_OF_LETTERS];
 680         v        /= COUNT_OF_LETTERS;
 681     }
 682
 683     sRandStr.Append( buffer , RAND_NAME_LENGTH );
 684     sRandStr.Append( sPostfix );
 685 }
 686
 687 void Export::getRandomName( ByteString& sRandStr )
 688 {
 689     const ByteString sEmpty;
 690     getRandomName( sEmpty , sRandStr , sEmpty );
 691 }
 692
 693 /*****************************************************************************/
 694 DirEntry Export::GetTempFile()
 695 /*****************************************************************************/
 696 {
 697 #if defined(WNT) || defined(OS2)
 698     String sTempDir( Export::GetEnv( "TEMP" ), RTL_TEXTENCODING_ASCII_US );
 699 #else
 700     String sTempDir( String::CreateFromAscii( "/tmp" ));
 701 #endif
 702     rtl::OUString* sTempFilename = new rtl::OUString();
 703
 704     // Create a temp file
 705     int nRC = osl::FileBase::createTempFile( 0 , 0 , sTempFilename );
 706     if( nRC ) printf(" osl::FileBase::createTempFile RC = %d",nRC);
 707
 708     String strTmp( *sTempFilename  );
 709
 710     INetURLObject::DecodeMechanism eMechanism = INetURLObject::DECODE_TO_IURI;
 711     String sDecodedStr = INetURLObject::decode( strTmp , '%' , eMechanism );
 712     ByteString sTmp( sDecodedStr , RTL_TEXTENCODING_UTF8 );
 713
 714 #if defined(WNT) || defined(OS2)
 715     sTmp.SearchAndReplace("file:///","");
 716     sTmp.SearchAndReplaceAll('/','\\');
 717 #else
 718     // Set file permission to 644
 719      const sal_uInt64 nPerm = osl_File_Attribute_OwnRead | osl_File_Attribute_OwnWrite |
 720                              osl_File_Attribute_GrpRead | osl_File_Attribute_OthRead ;
 721
 722     nRC = osl::File::setAttributes( *sTempFilename , nPerm );
 723     if( nRC ) printf(" osl::File::setAttributes RC = %d",nRC);
 724
 725     sTmp.SearchAndReplace("file://","");
 726 #endif
 727     DirEntry aDirEntry( sTmp );
 728     delete sTempFilename;
 729     return aDirEntry;
 730 }