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