xref: /aoo41x/main/l10ntools/source/helpmerge.cxx (revision ebd57642)
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 <tools/fsys.hxx>
27 #include <osl/file.hxx>
28 // local includes
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include "helpmerge.hxx"
32 #include "utf8conv.hxx"
33 #include <algorithm>
34 #include <sys/types.h>
35 #include <sys/stat.h>
36 #include <iostream>
37 #include <fstream>
38 #include <vector>
39 #include "rtl/strbuf.hxx"
40 #ifdef WNT
41 #include <direct.h>
42 //#include <WinBase.h>
43 #include "tools/prewin.h"
44 #include <windows.h>
45 #include "tools/postwin.h"
46 #endif
47 
48 /*****************************************************************************/
FillInFallbacks(LangHashMap & rElem_out,ByteString sLangIdx_in)49 void HelpParser::FillInFallbacks( LangHashMap& rElem_out, ByteString sLangIdx_in ){
50 /*****************************************************************************/
51     static const ByteString ENGLISH_LANGUAGECODE( "en-US" );
52     static const ByteString GERMAN_LANGUAGECODE ( "de"    );
53     ByteString sCur;
54     XMLElement* pTmp     = NULL;
55     XMLElement* pTmp2    = NULL;
56 
57     sCur = sLangIdx_in;
58     ByteString sFallback( sCur );
59     GetIsoFallback( sFallback );
60     if( (rElem_out.find( sFallback ) != rElem_out.end()) && rElem_out[ sFallback ] != NULL ){
61 	    pTmp2 = rElem_out[ sFallback ];
62         pTmp = new XMLElement( *pTmp2 )  ; // Copy
63         pTmp->SetPos( pTmp2->GetPos()+1 );
64         pTmp->ChangeLanguageTag( String( sLangIdx_in , RTL_TEXTENCODING_ASCII_US) );
65         rElem_out[ sLangIdx_in ] = pTmp;
66         pTmp2 = NULL;
67     }
68     else if( (rElem_out.find( ENGLISH_LANGUAGECODE ) != rElem_out.end()) && rElem_out[ ENGLISH_LANGUAGECODE ] != NULL ){// No English
69 	    pTmp2 = rElem_out[ ENGLISH_LANGUAGECODE ];
70         pTmp = new XMLElement( *pTmp2 )  ; // Copy
71         pTmp->SetPos( pTmp2->GetPos()+1 );
72         pTmp->ChangeLanguageTag( String( sLangIdx_in , RTL_TEXTENCODING_ASCII_US) );
73         rElem_out[ sCur ] = pTmp;
74         pTmp2 = NULL;
75     }
76     else if( (rElem_out.find( GERMAN_LANGUAGECODE ) != rElem_out.end() ) && rElem_out[ GERMAN_LANGUAGECODE ] != NULL ){// No English
77 	    pTmp2 = rElem_out[ GERMAN_LANGUAGECODE ];
78         pTmp = new XMLElement( *pTmp2 ); // Copy
79         pTmp->SetPos( pTmp2->GetPos()+1 );
80         pTmp->ChangeLanguageTag( String( sLangIdx_in , RTL_TEXTENCODING_ASCII_US ) );
81         rElem_out[ sCur ] = pTmp;
82         pTmp2 = NULL;
83 	}else{
84         fprintf(stdout,"ERROR: No Fallback found for language %s:\n",sCur.GetBuffer());
85         rElem_out[ sCur ]=new XMLElement(); // Use dummy element
86 	}
87 }
88 
89 /*****************************************************************************/
Dump(XMLHashMap * rElem_in)90 void HelpParser::Dump(XMLHashMap* rElem_in) {
91 /*****************************************************************************/
92     for(XMLHashMap::iterator pos = rElem_in->begin();pos != rElem_in->end(); ++pos){
93 	    Dump(pos->second,pos->first);
94     }
95 }
96 /*****************************************************************************/
Dump(LangHashMap * rElem_in,const ByteString sKey_in)97 void HelpParser::Dump(LangHashMap* rElem_in,const ByteString sKey_in) {
98 /*****************************************************************************/
99     ByteString x;
100     OString y;
101     fprintf(stdout,"+------------%s-----------+\n",sKey_in.GetBuffer() );
102     for(LangHashMap::iterator posn=rElem_in->begin();posn!=rElem_in->end();++posn){
103         x=posn->first;
104         y=posn->second->ToOString();
105         fprintf(stdout,"key=%s value=%s\n",x.GetBuffer(),y.getStr());
106     }
107     fprintf(stdout,"+--------------------------+\n");
108 }
109 
HelpParser(const ByteString & rHelpFile,bool rUTF8,bool rHasInputList)110 HelpParser::HelpParser( const ByteString &rHelpFile, bool rUTF8 , bool rHasInputList  )
111         : sHelpFile( rHelpFile ),
112           bUTF8    ( rUTF8     ),
113           bHasInputList( rHasInputList )
114           {};
115 
116 /*****************************************************************************/
CreateSDF(const ByteString & rSDFFile_in,const ByteString & rPrj_in,const ByteString & rRoot_in,const ByteString & sHelpFile,XMLFile * pXmlFile,const ByteString & rGsi1)117 bool HelpParser::CreateSDF(
118 /*****************************************************************************/
119 	const ByteString &rSDFFile_in, const ByteString &rPrj_in,const ByteString &rRoot_in,
120     const ByteString &sHelpFile, XMLFile *pXmlFile, const ByteString &rGsi1){
121     // GSI File constants
122     static const String GSI_SEQUENCE1( String::CreateFromAscii("\t0\t")	);
123     static const String GSI_SEQUENCE2( String::CreateFromAscii("\t\t\t0\t")		);
124     static const String GSI_TAB      ( String::CreateFromAscii("\t")			);
125     static const String GSI_SEQUENCE4( String::CreateFromAscii("\t\t\t\t")		);
126 	static const String ret			 ( String::CreateFromAscii("\n")			);
127     static const String ret_char	 ( String::CreateFromAscii("")				);
128     static const String tab			 ( String::CreateFromAscii("\t")			);
129     static const String tab_char	 ( String::CreateFromAscii("")				);
130 
131     SimpleXMLParser aParser;
132     String sUsedTempFile;
133     String sXmlFile;
134 
135     if( Export::fileHasUTF8ByteOrderMarker( sHelpFile ) ){
136         DirEntry aTempFile = Export::GetTempFile();
137         DirEntry aSourceFile( String( sHelpFile , RTL_TEXTENCODING_ASCII_US ) );
138         aSourceFile.CopyTo( aTempFile , FSYS_ACTION_COPYFILE );
139         String sTempFile = aTempFile.GetFull();
140         Export::RemoveUTF8ByteOrderMarkerFromFile( ByteString( sTempFile , RTL_TEXTENCODING_ASCII_US ) );
141         sUsedTempFile = sTempFile;
142         sXmlFile = sTempFile;
143     }else{
144         sUsedTempFile = String::CreateFromAscii("");
145         sXmlFile = String( sHelpFile , RTL_TEXTENCODING_ASCII_US );
146     }
147 
148 //    ByteString fullFilePath;
149     //DirEntry aFile( sXmlFile );
150     //makeAbsolutePath( sHelpFile , rRoot_in);
151     ByteString fullFilePath = rPrj_in;
152     fullFilePath.Append( "\\" );
153     fullFilePath.Append( makeAbsolutePath( sHelpFile , rRoot_in ) );
154 	fullFilePath.SearchAndReplaceAll( "\\", "/" );
155 
156     String strFullPath( fullFilePath.GetBuffer() , RTL_TEXTENCODING_ASCII_US );
157 
158     //printf( "%s\n", fullFilePath.GetBuffer() );
159     std::auto_ptr <XMLFile> file ( aParser.Execute( strFullPath , sXmlFile, pXmlFile ) );
160 
161 	if(file.get() == NULL){
162 		printf("%s\n",ByteString(aParser.GetError().sMessage,RTL_TEXTENCODING_ASCII_US).GetBuffer());
163         exit(-1);
164 		//return false;
165 	}
166     file->Extract();
167     if( !file->CheckExportStatus() ){
168         return true;
169     }
170     SvFileStream aSDFStream( String( rSDFFile_in, RTL_TEXTENCODING_ASCII_US ),
171 		STREAM_STD_WRITE | STREAM_TRUNC );
172 
173 	if ( !aSDFStream.IsOpen()) {
174         fprintf(stdout,"Can't open file %s\n",rSDFFile_in.GetBuffer());
175         return false;
176 	}
177 
178     ByteString sActFileName = makeAbsolutePath( sHelpFile , rRoot_in );
179 
180 	XMLHashMap*  aXMLStrHM   = file->GetStrings();
181 	LangHashMap* pElem;
182 	XMLElement*  pXMLElement  = NULL;
183 
184 	//Dump(aXMLStrHM);
185 
186 	ByteString sTimeStamp( Export::GetTimeStamp() );
187     OUString sOUTimeStamp( sTimeStamp.GetBuffer() , sTimeStamp.Len() , RTL_TEXTENCODING_ASCII_US );
188 
189     OUStringBuffer sBuffer;
190     const OUString sOUPrj( rPrj_in.GetBuffer() , rPrj_in.Len() , RTL_TEXTENCODING_ASCII_US );
191     const OUString sOUActFileName(sActFileName.GetBuffer() , sActFileName.Len() , RTL_TEXTENCODING_ASCII_US );
192     const OUString sOUGsi1( rGsi1.GetBuffer() , rGsi1.Len() , RTL_TEXTENCODING_ASCII_US );
193 
194     Export::InitLanguages( false );
195     std::vector<ByteString> aLanguages = Export::GetLanguages();
196 
197     std::vector<ByteString> order = file->getOrder();
198     std::vector<ByteString>::iterator pos;
199     XMLHashMap::iterator posm;
200 
201     for( pos = order.begin(); pos != order.end() ; ++pos )
202 	{
203         posm = aXMLStrHM->find( *pos );
204         pElem = posm->second;
205         ByteString sCur;
206 
207         for( unsigned int n = 0; n < aLanguages.size(); n++ )
208 		{
209 			sCur = aLanguages[ n ];
210 			if(pElem->find( sCur )==pElem->end())
211 			{
212 				FillInFallbacks( *pElem , sCur );
213             }
214             pXMLElement = (*pElem)[ sCur ];
215 
216 			if( pXMLElement != NULL )
217 			{
218 				OUString data = pXMLElement->ToOUString();
219    				String sTmp = String(data.getStr());
220 				sTmp.SearchAndReplaceAll(ret,ret_char);    // Remove \n
221 				sTmp.SearchAndReplaceAll(tab,tab_char);    // Remove \t
222 
223                 data = OUString( sTmp );
224                 sBuffer.append( sOUPrj );
225                 sBuffer.append( GSI_TAB );				//"\t";
226                 if ( rRoot_in.Len())
227 					sBuffer.append( sOUActFileName );
228    				sBuffer.append( GSI_SEQUENCE1 );		//"\t0\t";
229    				sBuffer.append( sOUGsi1 );		        //"help";
230    				sBuffer.append( GSI_TAB );              //"\t";
231                 ByteString sID = posm->first;			// ID
232                 sBuffer.append( OUString( sID.GetBuffer() , sID.Len() , RTL_TEXTENCODING_UTF8 ) );
233                 sBuffer.append( GSI_TAB ); //"\t";
234    				ByteString sOldRef = pXMLElement->GetOldref(); // oldref
235                 sBuffer.append( OUString(sOldRef.GetBuffer() , sOldRef.Len() , RTL_TEXTENCODING_UTF8 ) );
236    				sBuffer.append( GSI_SEQUENCE2 );		//"\t\t\t0\t";
237                 sBuffer.append( OUString( sCur.GetBuffer() , sCur.Len() , RTL_TEXTENCODING_UTF8 ) );
238    				sBuffer.append( GSI_TAB );				//"\t";
239 				sBuffer.append( data );
240   				sBuffer.append( GSI_SEQUENCE4 );		//"\t\t\t\t";
241                 sBuffer.append( sOUTimeStamp );
242 				ByteString sOut( sBuffer.makeStringAndClear().getStr() , RTL_TEXTENCODING_UTF8 );
243                 //if( !sCur.EqualsIgnoreCaseAscii("de") ||( sCur.EqualsIgnoreCaseAscii("de") && !Export::isMergingGermanAllowed( rPrj_in ) ) )
244 				//{
245 				if( data.getLength() > 0 ) aSDFStream.WriteLine( sOut );
246                 //}
247                 pXMLElement=NULL;
248 			}else fprintf(stdout,"\nDBG: NullPointer in HelpParser::CreateSDF , Language %s\n",sCur.GetBuffer() );
249 		}
250 
251 	}
252     //Dump(aXMLStrHM);
253 	aSDFStream.Close();
254 
255     if( !sUsedTempFile.EqualsIgnoreCaseAscii( "" ) ){
256         DirEntry aTempFile( sUsedTempFile );
257         aTempFile.Kill();
258     }
259     return sal_True;
260 }
261 
makeAbsolutePath(const ByteString & sHelpFile,const ByteString & rRoot_in)262 ByteString HelpParser::makeAbsolutePath( const ByteString& sHelpFile , const ByteString& rRoot_in )
263 {
264   	DirEntry aEntry( String( sHelpFile, RTL_TEXTENCODING_ASCII_US ));
265 	aEntry.ToAbs();
266 	String sFullEntry = aEntry.GetFull();
267 	aEntry += DirEntry( String( "..", RTL_TEXTENCODING_ASCII_US ));
268 	aEntry += DirEntry( rRoot_in );
269 	ByteString sPrjEntry( aEntry.GetFull(), gsl_getSystemTextEncoding());
270 	ByteString sActFileName(
271 	sFullEntry.Copy( sPrjEntry.Len() + 1 ), gsl_getSystemTextEncoding());
272 
273 	sActFileName.SearchAndReplaceAll( "/", "\\" );
274     return sActFileName;
275 }
Merge(const ByteString & rSDFFile,const ByteString & rDestinationFile,ByteString & sLanguage,MergeDataFile & aMergeDataFile)276 bool HelpParser::Merge( const ByteString &rSDFFile, const ByteString &rDestinationFile  ,
277 		ByteString& sLanguage , MergeDataFile& aMergeDataFile )
278 {
279 
280     (void) rSDFFile;
281     bool hasNoError = true;
282 
283     SimpleXMLParser aParser;
284 
285     String sUsedTempFile;
286     String sXmlFile;
287 
288     if( Export::fileHasUTF8ByteOrderMarker( sHelpFile ) ){
289         DirEntry aTempFile = Export::GetTempFile();
290         DirEntry aSourceFile( String( sHelpFile , RTL_TEXTENCODING_ASCII_US ) );
291         aSourceFile.CopyTo( aTempFile , FSYS_ACTION_COPYFILE );
292         String sTempFile = aTempFile.GetFull();
293         Export::RemoveUTF8ByteOrderMarkerFromFile( ByteString( sTempFile , RTL_TEXTENCODING_ASCII_US ) );
294         sUsedTempFile = sTempFile;
295         sXmlFile = sTempFile;
296     }else{
297         sUsedTempFile = String::CreateFromAscii("");
298         sXmlFile = String( sHelpFile , RTL_TEXTENCODING_ASCII_US );
299     }
300 
301     OUString sOUHelpFile( sXmlFile );
302 	String fullFilePath;
303     DirEntry aFile( sXmlFile );
304 
305 	XMLFile* xmlfile = ( aParser.Execute( aFile.GetFull() , sOUHelpFile, new XMLFile( '0' ) ) );
306     if (xmlfile == NULL) {
307         printf("%s\n",ByteString(aParser.GetError().sMessage,
308                                  RTL_TEXTENCODING_ASCII_US).GetBuffer());
309         exit(-1);
310     }
311 	printf("Dest file %s\n",rDestinationFile.GetBuffer());
312 	hasNoError = MergeSingleFile( xmlfile , aMergeDataFile , sLanguage , rDestinationFile );
313 	delete xmlfile;
314     if( !sUsedTempFile.EqualsIgnoreCaseAscii( "" ) ){
315         DirEntry aTempFile( sUsedTempFile );
316         aTempFile.Kill();
317     }
318 	return hasNoError;
319 }
320 
ByteStringEqual(const ByteString & rKey1,const ByteString & rKey2)321 bool ByteStringEqual( const ByteString& rKey1, const ByteString& rKey2 )  {
322     return rKey1.CompareTo( rKey2 )==COMPARE_EQUAL;
323 };
ByteStringLess(const ByteString & rKey1,const ByteString & rKey2)324 bool ByteStringLess( const ByteString& rKey1, const ByteString& rKey2 )  {
325      return rKey1.CompareTo( rKey2 )==COMPARE_LESS;
326 }
327 
parse_languages(std::vector<ByteString> & aLanguages,MergeDataFile & aMergeDataFile)328 void HelpParser::parse_languages( std::vector<ByteString>& aLanguages , MergeDataFile& aMergeDataFile ){
329     std::vector<ByteString> aTmp;
330 
331     const ByteString DE		("de");
332 	const ByteString ENUS	("en-US");
333 	static const ByteString ALL( "ALL" );
334 
335 	Export::InitLanguages( false );
336 
337 	if( Export::sLanguages.EqualsIgnoreCaseAscii( ALL ) )
338 	{
339 		aLanguages = aMergeDataFile.GetLanguages();
340         aLanguages.push_back( DE );
341         aLanguages.push_back( ENUS );
342 
343         if( !Export::sForcedLanguages.Equals("") )
344 		{
345 			std::vector<ByteString> aFL = Export::GetForcedLanguages();
346             std::copy( aFL.begin() ,
347                        aFL.end() ,
348                        back_inserter( aLanguages )
349                      );
350             std::sort(   aLanguages.begin() , aLanguages.end() , ByteStringLess );
351             std::vector<ByteString>::iterator unique_iter =  std::unique( aLanguages.begin() , aLanguages.end() , ByteStringEqual );
352             std::copy( aLanguages.begin() , unique_iter , back_inserter( aTmp ) );
353             aLanguages = aTmp;
354         }
355     }
356     else{
357         aLanguages = Export::GetLanguages();
358     }
359 
360 }
361 
Merge(const ByteString & rSDFFile,const ByteString & rPathX,const ByteString & rPathY,bool bISO,const std::vector<ByteString> & aLanguages,MergeDataFile & aMergeDataFile,bool bCreateDir)362 bool HelpParser::Merge(
363 	const ByteString &rSDFFile, const ByteString &rPathX , const ByteString &rPathY , bool bISO ,
364 	const std::vector<ByteString>& aLanguages , MergeDataFile& aMergeDataFile , bool bCreateDir )
365 {
366 
367 
368     (void) rSDFFile ;
369     bool hasNoError = true;
370     SimpleXMLParser aParser;
371     String sUsedTempFile;
372     String sXmlFile;
373 
374 	if( Export::fileHasUTF8ByteOrderMarker( sHelpFile ) )
375 	{
376         DirEntry aTempFile = Export::GetTempFile();
377         DirEntry aSourceFile( String( sHelpFile , RTL_TEXTENCODING_ASCII_US ) );
378         aSourceFile.CopyTo( aTempFile , FSYS_ACTION_COPYFILE );
379         String sTempFile = aTempFile.GetFull();
380         Export::RemoveUTF8ByteOrderMarkerFromFile( ByteString( sTempFile , RTL_TEXTENCODING_ASCII_US ) );
381         sUsedTempFile = sTempFile;
382         sXmlFile = sTempFile;
383     }
384 	else
385 	{
386         sUsedTempFile = String::CreateFromAscii("");
387         sXmlFile = String( sHelpFile , RTL_TEXTENCODING_ASCII_US );
388     }
389 
390 
391 	OUString sOUHelpFile( sXmlFile );
392   	String fullFilePath;
393     DirEntry aFile( sXmlFile );
394 
395 	XMLFile* xmlfile = ( aParser.Execute( aFile.GetFull() , sOUHelpFile, new XMLFile( '0' ) ) );
396 
397 	if( xmlfile == NULL)
398 	{
399 		printf("%s\n",ByteString(aParser.GetError().sMessage,RTL_TEXTENCODING_UTF8).GetBuffer());
400 		exit(-1);
401 		//return false;
402 	}
403 	xmlfile->Extract();
404 
405 
406     ByteString sCur;
407     for( unsigned int n = 0; n < aLanguages.size(); n++ ){
408 		sCur = aLanguages[ n ];
409 
410         ByteString sFilepath;
411         if( bISO )	sFilepath = GetOutpath( rPathX , sCur , rPathY );
412         else        sFilepath = rPathX;
413         if( bCreateDir ) MakeDir( sFilepath );
414 
415         XMLFile* file = new XMLFile( *xmlfile );
416         sFilepath.Append( sHelpFile );
417 		hasNoError = MergeSingleFile( file , aMergeDataFile , sCur , sFilepath );
418 		delete file;
419 
420 		if( !hasNoError ) return false;			// Stop on error
421      }
422 
423     if( !sUsedTempFile.EqualsIgnoreCaseAscii( "" ) )
424 	{
425         DirEntry aTempFile( sUsedTempFile );
426         aTempFile.Kill();
427     }
428 	delete xmlfile;
429 	return hasNoError;
430 }
431 
MergeSingleFile(XMLFile * file,MergeDataFile & aMergeDataFile,const ByteString & sLanguage,ByteString sPath)432 bool HelpParser::MergeSingleFile( XMLFile* file , MergeDataFile& aMergeDataFile , const ByteString& sLanguage ,
433 								  ByteString sPath )
434 {
435 	file->Extract();
436 
437    	XMLHashMap*   aXMLStrHM     = file->GetStrings();
438 	LangHashMap*  aLangHM;
439 	static	ResData	pResData( "","","");
440 	pResData.sResTyp   = "help";
441 
442     ByteString sTmp             = Export::sLanguages;
443 
444     sTmp.EraseLeadingAndTrailingChars();
445 
446     for(XMLHashMap::iterator pos=aXMLStrHM->begin();pos!=aXMLStrHM->end();++pos)    // Merge every l10n related string
447     {
448 
449         aLangHM             = pos->second;
450         //printf("*********************DUMPING HASHMAP***************************************");
451 		//Dump( aXMLStrHM );
452 		//printf("DBG: sHelpFile = %s\n",sHelpFile.GetBuffer() );
453 
454         pResData.sGId      =  pos->first;
455 		pResData.sFilename  =  sHelpFile;
456 
457         ProcessHelp( aLangHM , sLanguage, &pResData , aMergeDataFile );
458      }
459 
460 
461     // Init temp and target file
462 	ByteString sTempFile;
463 	ByteString sTargetFile( sPath );
464     ByteString sTempFileCopy;
465 
466 	static const ByteString INPATH = Export::GetEnv( "INPATH" );
467 	Export::getRandomName( sPath , sTempFile , INPATH );
468   	Export::getRandomName( sPath , sTempFileCopy , INPATH );
469 	// Write in the temp file
470 	bool hasNoError = file->Write ( sTempFile );
471 	if( !hasNoError )
472     {
473         cerr << "ERROR: file->Write failed\n";
474         return false;
475     }
476 
477     DirEntry aTmp( sTempFile );
478     DirEntry aTmp2( sTempFileCopy );
479     DirEntry aTar( sTargetFile );
480 
481     if( !Export::CopyFile( sTempFile , sTempFileCopy ) )
482     {
483 #if defined(UNX) || defined(OS2)
484         sleep( 3 );
485 #else
486         Sleep( 3 );
487 #endif
488         if( !Export::CopyFile( sTempFile , sTempFileCopy ) )
489         {
490             cerr << "ERROR: Can not copy file from " << sTempFile.GetBuffer() << " to " << sTempFileCopy.GetBuffer() << "\n";
491             return false;
492         }
493     }
494     //remove( sTargetFile.GetBuffer() );
495 
496     FileStat aFSTest( aTar );
497     if( aFSTest.GetSize() < 1 )
498     {
499         remove( sTargetFile.GetBuffer() );
500     }
501     int rc;
502 #if defined(UNX) || defined(OS2)
503     rc = rename( sTempFile.GetBuffer() , sTargetFile.GetBuffer() );
504 #else
505     rc = MoveFileEx( sTempFile.GetBuffer() , sTargetFile.GetBuffer(), MOVEFILE_REPLACE_EXISTING );
506 #endif
507     FileStat aFS( aTar );
508 
509     //cout << "mv " << sTempFile.GetBuffer() << " " << sTargetFile.GetBuffer() << "\n";
510     //cout << "rc -> " << rc << " filesize -> " << aFS.GetSize() << "\n";
511 // Windows rename returns -1 if the file already exits
512 //#ifdef UNX
513     if( rc < 0 || aFS.GetSize() < 1 )
514 //#else
515 //    if( aFS.GetSize() < 1 )
516 //#endif
517     {
518 #if defined(UNX) || defined(OS2)
519         sleep( 3 );
520 #else
521         Sleep( 3 );
522 #endif
523         aFSTest.Update( aTar );
524         if( aFSTest.GetSize() < 1 )
525         {
526             remove( sTargetFile.GetBuffer() );
527         }
528 #if defined(UNX) || defined(OS2)
529         rc = rename( sTempFileCopy.GetBuffer() , sTargetFile.GetBuffer() );
530 #else
531         rc = MoveFileEx( sTempFileCopy.GetBuffer() , sTargetFile.GetBuffer() , MOVEFILE_REPLACE_EXISTING );
532 #endif
533         aFS.Update( aTar );
534 
535         //cout << "mv2 " << sTempFileCopy.GetBuffer() << " " << sTargetFile.GetBuffer() << "\n";
536         //cout << "rc -> " << rc << " filesize -> " << aFS.GetSize() << "\n";
537 
538 // Windows rename returns -1 if the file already exits
539 //#ifdef WNT
540 //        if( aFS.GetSize() < 1 )
541 //#else
542         if( rc < 0 || aFS.GetSize() < 1 )
543 //#endif
544         {
545             cerr << "ERROR: helpex Can't rename file " << sTempFileCopy.GetBuffer() << " to " << sTargetFile.GetBuffer() << " rename rc=" << rc << " filesize=" << aFS.GetSize() << "\n";
546             aTmp.Kill();
547             aTmp2.Kill();
548             if( aFS.GetSize() < 1 )
549                 aTar.Kill();
550             return false;
551         }
552     }
553     aTmp.Kill();
554     aTmp2.Kill();
555 
556 	return true;
557 }
558 
GetOutpath(const ByteString & rPathX,const ByteString & sCur,const ByteString & rPathY)559 ByteString HelpParser::GetOutpath( const ByteString& rPathX , const ByteString& sCur , const ByteString& rPathY ){
560     ByteString testpath = rPathX;
561     static const ByteString sDelimiter( DirEntry::GetAccessDelimiter(), RTL_TEXTENCODING_ASCII_US );
562     testpath.EraseTrailingChars( '/' );
563     testpath.EraseTrailingChars( '\\' );
564     testpath += sDelimiter;
565     testpath += sCur;
566     testpath += sDelimiter;
567     ByteString sRelativePath( rPathY );
568     sRelativePath.EraseLeadingChars( '/' );
569     sRelativePath.EraseLeadingChars( '\\' );
570     testpath += sRelativePath;
571 	testpath += sDelimiter;
572     return testpath;
573 }
MakeDir(const ByteString & sPath)574 void HelpParser::MakeDir( const ByteString& sPath ){
575     ByteString sTPath( sPath );
576     ByteString sDelimiter( DirEntry::GetAccessDelimiter(), RTL_TEXTENCODING_ASCII_US );
577     sTPath.SearchAndReplaceAll( sDelimiter , '/' );
578     sal_uInt16 cnt = sTPath.GetTokenCount( '/' );
579     ByteString sCreateDir;
580     for( sal_uInt16 i = 0 ; i < cnt ; i++ )
581     {
582         sCreateDir += sTPath.GetToken( i , '/' );
583         sCreateDir += sDelimiter;
584 #ifdef WNT
585         _mkdir( sCreateDir.GetBuffer() );
586 #else
587         mkdir( sCreateDir.GetBuffer() , S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH );
588 #endif
589     }
590 }
591 
592 
593 /* ProcessHelp Methode: search for en-US entry and replace it with the current language*/
ProcessHelp(LangHashMap * aLangHM,const ByteString & sCur,ResData * pResData,MergeDataFile & aMergeDataFile)594 void HelpParser::ProcessHelp( LangHashMap* aLangHM , const ByteString& sCur , ResData *pResData , MergeDataFile& aMergeDataFile ){
595 
596 	XMLElement*   pXMLElement = NULL;
597    	PFormEntrys   *pEntrys    = NULL;
598     XMLData       *data       = NULL;
599     XMLParentNode *parent     = NULL;
600 
601     String        sNewdata;
602 	ByteString sLId;
603     ByteString sGId;
604 
605     pEntrys = NULL;
606 
607 #ifdef MERGE_SOURCE_LANGUAGES
608     if( true ){                  // Merge en-US!
609 #else
610     if( !sCur.EqualsIgnoreCaseAscii("en-US") ){
611 #endif
612         pXMLElement = (*aLangHM)[ "en-US" ];
613         if( pXMLElement == NULL )
614 		{
615             printf("Error: Can't find en-US entry\n");
616         }
617         if( pXMLElement != NULL )
618 		{
619             parent  = pXMLElement->GetParent();
620             sLId    = pXMLElement->GetOldref();
621             pResData->sId     =  sLId;
622 
623             pEntrys = aMergeDataFile.GetPFormEntrys( pResData );
624             if( pEntrys != NULL)
625 			{
626                 ByteString sNewText;
627 		        pEntrys->GetText( sNewText, STRING_TYP_TEXT, sCur , true );
628 		        sNewdata = String(  sNewText , RTL_TEXTENCODING_UTF8 );
629                 if ( sNewdata.Len())
630 				{
631                     if( pXMLElement != NULL )
632 					{
633 				        data   = new XMLData( sNewdata , NULL , true ); // Add new one
634                         pXMLElement->RemoveAndDeleteAllChilds();
635 						pXMLElement->AddChild( data );
636                         aLangHM->erase( sCur );
637 				    }
638 			    }
639             }else if( pResData == NULL ){fprintf(stdout,"Can't find GID=%s LID=%s TYP=%s\n",pResData->sGId.GetBuffer(),pResData->sId.GetBuffer(),pResData->sResTyp.GetBuffer());}
640             pXMLElement->ChangeLanguageTag( String( sCur , RTL_TEXTENCODING_ASCII_US) );
641         }
642 
643     }
644 }
645 /* Process() Method merges */
646 void HelpParser::Process( LangHashMap* aLangHM , const ByteString& sCur , ResData *pResData , MergeDataFile& aMergeDataFile ){
647 
648 	XMLElement*   pXMLElement = NULL;
649    	PFormEntrys   *pEntrys    = NULL;
650     XMLData       *data       = NULL;
651     XMLParentNode *parent     = NULL;
652     XMLDefault    *xmldefault = NULL;
653 
654 	short		  curLang     = 0;
655     String        sNewdata;
656     bool          isFallback  = false;
657 	ByteString sLId;
658     ByteString sGId;
659 
660     pEntrys = NULL;
661 
662 #ifdef MERGE_SOURCE_LANGUAGES
663     if( true ){                  // Merge en-US!
664 #else
665     if( !sCur.EqualsIgnoreCaseAscii("en-US") ){
666 #endif
667         pXMLElement = (*aLangHM)[ sCur ];
668         if( pXMLElement == NULL )
669 		{
670             FillInFallbacks( *aLangHM , sCur );
671             pXMLElement =   ( *aLangHM )[ sCur ];
672             isFallback = true;
673         }
674         if( pXMLElement != NULL )
675 		{
676             parent  = pXMLElement->GetParent();
677             sLId    = pXMLElement->GetOldref();
678             pResData->sId     =  sLId;
679 
680             pEntrys = aMergeDataFile.GetPFormEntrys( pResData );
681             if( pEntrys != NULL)
682 			{
683                 ByteString sNewText;
684 		        pEntrys->GetText( sNewText, STRING_TYP_TEXT, sCur , true );
685 		        sNewdata = String(  sNewText , RTL_TEXTENCODING_UTF8 );
686                 if ( sNewdata.Len())
687 				{
688 			        printf("Entries found\n");
689                     if( pXMLElement != NULL )
690 					{
691 				        data   = new XMLData( sNewdata , NULL , true ); // Add new one
692 					    if( pXMLElement->ToOUString().compareTo( OUString(data->GetData()) ) != 0 )
693 						{
694 					        pXMLElement->RemoveAndDeleteAllChilds();
695 						    pXMLElement->AddChild( data );
696                         }
697                         if( isFallback )
698 						{
699 					        xmldefault = new XMLDefault( String::CreateFromAscii("\n") , NULL );
700                             int pos = parent->GetPosition( pXMLElement->GetId() );
701                             if( pos != -1 ){
702 						        parent->AddChild(xmldefault , pos+1 );
703                                 parent->AddChild(pXMLElement , pos+2 );
704                             }
705 							else fprintf(stdout,"ERROR: Can't find reference Element of id %s language %d\n",pXMLElement->GetId().GetBuffer(),curLang);
706                         }
707 
708                         aLangHM->erase( sCur );
709 				    }
710 			    }
711 			    delete pResData;
712             }else if( pResData == NULL ){fprintf(stdout,"Can't find GID=%s LID=%s TYP=%s\n",pResData->sGId.GetBuffer(),pResData->sId.GetBuffer(),pResData->sResTyp.GetBuffer());}
713         }
714 
715     }
716 }
717 
718