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