xref: /aoo42x/main/l10ntools/source/export.cxx (revision 17ad1cec)
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 <stdio.h>
27 #include <stdlib.h>
28 #include <tools/fsys.hxx>
29 #include "export.hxx"
30 #include "tokens.h"
31 #include "utf8conv.hxx"
32 #include <iostream>
33 
34 extern "C" { int yyerror( char * ); }
35 extern "C" { int YYWarning( char * ); }
36 
37 Export *pExport = 0L;
38 
39 // defines to parse command line
40 #define STATE_NON		0x0001
41 #define STATE_INPUT		0x0002
42 #define STATE_OUTPUT	0x0003
43 #define STATE_PRJ		0x0004
44 #define STATE_ROOT		0x0005
45 #define STATE_MERGESRC	0x0006
46 #define STATE_ERRORLOG	0x0007
47 #define STATE_BREAKHELP	0x0008
48 #define STATE_UNMERGE	0x0009
49 #define STATE_UTF8		0x000A
50 #define STATE_LANGUAGES	0X000B
51 
52 // set of global variables
53 DECLARE_LIST( FileList, ByteString * )
54 FileList aInputFileList;
55 sal_Bool bEnableExport;
56 sal_Bool bMergeMode;
57 sal_Bool bErrorLog;
58 sal_Bool bBreakWhenHelpText;
59 sal_Bool bUnmerge;
60 sal_Bool bUTF8;
61 ByteString sPrj;
62 ByteString sPrjRoot;
63 ByteString sActFileName;
64 ByteString sOutputFile;
65 ByteString sMergeSrc;
66 ByteString sTempFile;
67 ByteString sFile;
68 MergeDataFile *pMergeDataFile;
69 FILE *pTempFile;
70 
71 
72 ByteString sStrBuffer;
73 bool bMarcro = false;
74 
75 extern "C" {
76 // the whole interface to lexer is in this extern "C" section
77 
78 
79 /*****************************************************************************/
GetOutputFile(int argc,char * argv[])80 extern char *GetOutputFile( int argc, char* argv[])
81 /*****************************************************************************/
82 {
83 	bEnableExport = sal_False;
84 	bMergeMode = sal_False;
85 	bErrorLog = sal_True;
86 	bBreakWhenHelpText = sal_False;
87 	bUnmerge = sal_False;
88 	bUTF8 = sal_True;
89 	sPrj = "";
90 	sPrjRoot = "";
91 	sActFileName = "";
92 	Export::sLanguages = "";
93 	Export::sForcedLanguages = "";
94 	sTempFile = "";
95 	pTempFile = NULL;
96 	sal_uInt16 nState = STATE_NON;
97 	sal_Bool bInput = sal_False;
98 
99 	// parse command line
100 	for( int i = 1; i < argc; i++ ) {
101 		ByteString sSwitch( argv[ i ] );
102 
103 		if (sSwitch == "-i"  || sSwitch == "-I" ) {
104 			nState = STATE_INPUT; // next tokens specifies source files
105 		}
106 		else if (sSwitch == "-o"  || sSwitch == "-O" ) {
107 			nState = STATE_OUTPUT; // next token specifies the dest file
108 		}
109 		else if (sSwitch == "-p"  || sSwitch == "-P" ) {
110 			nState = STATE_PRJ; // next token specifies the cur. project
111 		}
112 
113 		else if (sSwitch == "-r"  || sSwitch == "-R" ) {
114 			nState = STATE_ROOT; // next token specifies path to project root
115 		}
116 		else if (sSwitch == "-m"  || sSwitch == "-M" ) {
117 			nState = STATE_MERGESRC; // next token specifies the merge database
118 		}
119 		else if (sSwitch == "-e"  || sSwitch == "-E" ) {
120 			nState = STATE_ERRORLOG;
121 			bErrorLog = sal_False;
122 		}
123 		else if (sSwitch == "-b"  || sSwitch == "-B" ) {
124 			nState = STATE_BREAKHELP;
125 			bBreakWhenHelpText = sal_True;
126 		}
127 		else if (sSwitch == "-u"  || sSwitch == "-U" ) {
128 			nState = STATE_UNMERGE;
129 			bUnmerge = sal_True;
130 			bMergeMode = sal_True;
131 		}
132 		else if ( sSwitch.ToUpperAscii() == "-UTF8" ) {
133 			nState = STATE_UTF8;
134 			bUTF8 = sal_True;
135 		}
136 		else if ( sSwitch.ToUpperAscii() == "-NOUTF8" ) {
137 			nState = STATE_UTF8;
138 			bUTF8 = sal_False;
139 		}
140 		else if ( sSwitch == "-l"  || sSwitch == "-L" ) {
141 			nState = STATE_LANGUAGES;
142 		}
143 		else {
144 			switch ( nState ) {
145 				case STATE_NON: {
146 					return NULL;	// no valid command line
147 				}
148 				case STATE_INPUT: {
149 					aInputFileList.Insert( new ByteString( argv[ i ]), LIST_APPEND );
150 					bInput = sal_True; // min. one source file found
151 				}
152 				break;
153 				case STATE_OUTPUT: {
154 					sOutputFile = ByteString( argv[ i ]); // the dest. file
155 				}
156 				break;
157 				case STATE_PRJ: {
158 					sPrj = ByteString( argv[ i ]);
159 				}
160 				break;
161 				case STATE_ROOT: {
162 					sPrjRoot = ByteString( argv[ i ]); // path to project root
163 				}
164 				break;
165 				case STATE_MERGESRC: {
166 					sMergeSrc = ByteString( argv[ i ]);
167 					bMergeMode = sal_True; // activate merge mode, cause merge database found
168 				}
169 				break;
170 				case STATE_LANGUAGES: {
171 					Export::sLanguages = ByteString( argv[ i ]);
172 				}
173 				break;
174 			}
175 		}
176 	}
177 	if( bUnmerge ) sMergeSrc = ByteString();
178 	if ( bInput ) {
179 		// command line is valid
180 		bEnableExport = sal_True;
181 		char *pReturn = new char[ sOutputFile.Len() + 1 ];
182 		strcpy( pReturn, sOutputFile.GetBuffer()); // #100211# - checked
183 		return pReturn;
184 	}
185 
186 	// command line is not valid
187 	return NULL;
188 }
189 /*****************************************************************************/
InitExport(char * pOutput,char * pFilename)190 int InitExport( char *pOutput , char* pFilename )
191 /*****************************************************************************/
192 {
193 	// instanciate Export
194 	ByteString sOutput( pOutput );
195 	ByteString sFilename( pFilename );
196 
197 	if ( bMergeMode && !bUnmerge ) {
198 		// merge mode enabled, so read database
199 		pExport = new Export(sOutput, bEnableExport, sPrj, sPrjRoot, sMergeSrc , sFilename );
200 	}
201 	else
202 		// no merge mode, only export
203 		pExport = new Export( sOutput, bEnableExport, sPrj, sPrjRoot , sFilename );
204 	return 1;
205 }
206 
207 /*****************************************************************************/
EndExport()208 int EndExport()
209 /*****************************************************************************/
210 {
211 	delete pExport;
212 	return 1;
213 }
214 
getFilename()215 extern const char* getFilename()
216 {
217 	return (*(aInputFileList.GetObject( 0 ))).GetBuffer();
218 }
219 /*****************************************************************************/
GetNextFile()220 extern FILE *GetNextFile()
221 /*****************************************************************************/
222 {
223 	// look for next valid filename in input file list
224 	if ( sTempFile.Len()) {
225 		fclose( pTempFile );
226 		String sTemp( sTempFile, RTL_TEXTENCODING_ASCII_US );
227 		DirEntry aTemp( sTemp );
228 		aTemp.Kill();
229 	}
230 
231 	while ( aInputFileList.Count()) {
232 		ByteString sFileName( *(aInputFileList.GetObject( 0 )));
233 
234 		ByteString sOrigFile( sFileName );
235 
236 		sFileName = Export::GetNativeFile( sFileName );
237 		delete aInputFileList.GetObject(( sal_uLong ) 0 );
238 		aInputFileList.Remove(( sal_uLong ) 0 );
239 
240 		if ( sFileName == "" ) {
241 			fprintf( stderr, "ERROR: Could not precompile File %s\n",
242 				sOrigFile.GetBuffer());
243 			return GetNextFile();
244 		}
245 
246 		sTempFile = sFileName;
247 		Export::RemoveUTF8ByteOrderMarkerFromFile( sFileName );
248 
249 		// able to open file?
250 		FILE *pFile = fopen( sFileName.GetBuffer(), "r" );
251 		if ( !pFile )
252 			fprintf( stderr, "Error: Could not open File %s\n",
253 				sFileName.GetBuffer());
254 		else {
255 			pTempFile = pFile;
256 
257 			// this is a valid file which can be opened, so
258 			// create path to project root
259 			DirEntry aEntry( String( sOrigFile, RTL_TEXTENCODING_ASCII_US ));
260 			aEntry.ToAbs();
261 			ByteString sFullEntry( aEntry.GetFull(), RTL_TEXTENCODING_ASCII_US );
262 			aEntry += DirEntry( String( "..", RTL_TEXTENCODING_ASCII_US ));
263 			aEntry += DirEntry( sPrjRoot );
264 			ByteString sPrjEntry( aEntry.GetFull(), RTL_TEXTENCODING_ASCII_US );
265 
266 			// create file name, beginning with project root
267 			// (e.g.: source\ui\src\menue.src)
268 			sActFileName = sFullEntry.Copy( sPrjEntry.Len() + 1 );
269 
270 
271 			sActFileName.SearchAndReplaceAll( "/", "\\" );
272 			sFile = sActFileName;
273 
274 			if ( pExport ) {
275 				// create instance of class export
276 				pExport->Init();
277 			}
278 			// return the valid file handle
279 			return pFile;
280 		}
281 	}
282 	// this means the file could not be opened
283 	return NULL;
284 }
285 
Parse(int nTyp,const char * pTokenText)286 int Parse( int nTyp, const char *pTokenText ){
287 	pExport->Execute( nTyp , pTokenText );
288 	return 1;
289 }
Close()290 void Close(){
291 	pExport->pParseQueue->Close();
292 }
293 /*****************************************************************************/
WorkOnTokenSet(int nTyp,char * pTokenText)294 int WorkOnTokenSet( int nTyp, char *pTokenText )
295 /*****************************************************************************/
296 {
297 
298 	pExport->pParseQueue->Push( QueueEntry( nTyp , ByteString( pTokenText ) ) );
299 	return 1;
300 }
301 
302 } // extern
303 
304 extern "C" {
305 /*****************************************************************************/
SetError()306 int SetError()
307 /*****************************************************************************/
308 {
309 	// set error at global instance of class Export
310 	pExport->SetError();
311 	return 1;
312 }
313 }
314 
315 extern "C" {
316 /*****************************************************************************/
GetError()317 int GetError()
318 /*****************************************************************************/
319 {
320 	// get error at global instance of class Export
321 	if ( pExport->GetError())
322 		return 1;
323 	return sal_False;
324 }
325 }
326 
327 //
328 // class ResData
329 //
330 
Dump()331 void ResData::Dump(){
332 	printf("**************\nResData\n");
333 	printf("sPForm = %s , sResTyp = %s , sId = %s , sGId = %s , sHelpId = %s\n",sPForm.GetBuffer()
334 		,sResTyp.GetBuffer(),sId.GetBuffer(),sGId.GetBuffer(),sHelpId.GetBuffer());
335 
336 	ByteString a("*pStringList");
337 	ByteString b("*pUIEntries");
338 	ByteString c("*pFilterList");
339 	ByteString d("*pItemList");
340 	ByteString e("*pPairedList");
341 	ByteString f("sText");
342 
343 	Export::DumpMap( f , sText );
344 
345 	if( pStringList )	Export::DumpExportList( a , *pStringList );
346 	if( pUIEntries )	Export::DumpExportList( b , *pUIEntries );
347 	if( pFilterList )	Export::DumpExportList( c , *pFilterList );
348 	if( pItemList )		Export::DumpExportList( d , *pItemList );
349 	if( pPairedList )	Export::DumpExportList( e , *pPairedList );
350 	printf("\n");
351 }
352 
addFallbackData(ByteString & sId_in,const ByteString & sText_in)353 void ResData::addFallbackData( ByteString& sId_in , const ByteString& sText_in ){
354 	//printf(" ResData::addFallbackData ( sId = %s , sText = %s )\n", sId_in.GetBuffer() , sText_in.GetBuffer() );
355 	aFallbackData[ sId_in ] = sText_in;
356 }
getFallbackData(ByteString & sId_in,ByteString & sText_inout)357 bool ResData::getFallbackData( ByteString& sId_in , ByteString& sText_inout ){
358 	sText_inout = aFallbackData[ sId_in ];
359 	//printf("ResData::getFallbackData( sId = %s , return sText = %s \n" , sId_in.GetBuffer(), sText_inout.GetBuffer());
360 	return sText_inout.Len() > 0;
361 }
362 
addMergedLanguage(ByteString & sLang)363 void ResData::addMergedLanguage( ByteString& sLang ){
364 	aMergedLanguages[ sLang ]=ByteString("1");
365 }
isMerged(ByteString & sLang)366 bool ResData::isMerged( ByteString& sLang ){
367 	return aMergedLanguages[ sLang ].Equals("1");
368 }
369 
370 /*****************************************************************************/
SetId(const ByteString & rId,sal_uInt16 nLevel)371 sal_Bool ResData::SetId( const ByteString &rId, sal_uInt16 nLevel )
372 /*****************************************************************************/
373 {
374 	if ( nLevel > nIdLevel )
375 	{
376 		nIdLevel = nLevel;
377 		sId = rId;
378 
379 		if ( bChild && bChildWithText ) {
380 			ByteString sError( "ResId after child definition" );
381 			yyerror( sError.GetBufferAccess());
382 			sError.ReleaseBufferAccess();
383 			SetError();
384 		}
385 
386 		if ( sId.Len() > 255 ) {
387 			ByteString sWarning( "LocalId > 255 chars, truncating..." );
388 			YYWarning( sWarning.GetBufferAccess());
389 			sWarning.ReleaseBufferAccess();
390 			sId.Erase( 255 );
391 			sId.EraseTrailingChars( ' ' );
392 			sId.EraseTrailingChars( '\t' );
393 		}
394 
395 		return sal_True;
396 	}
397 
398 	return sal_False;
399 }
400 
401 //
402 // class Export
403 //
404 
405 /*****************************************************************************/
Export(const ByteString & rOutput,sal_Bool bWrite,const ByteString & rPrj,const ByteString & rPrjRoot,const ByteString & rFile)406 Export::Export( const ByteString &rOutput, sal_Bool bWrite,
407 				const ByteString &rPrj, const ByteString &rPrjRoot , const ByteString& rFile )
408 /*****************************************************************************/
409 				:
410 				pWordTransformer( NULL ),
411 				aCharSet( RTL_TEXTENCODING_MS_1252 ),
412 				bDefine( sal_False ),
413 				bNextMustBeDefineEOL( sal_False ),
414 				nLevel( 0 ),
415 				nList( LIST_NON ),
416 				nListIndex( 0 ),
417 				nListLevel( 0 ),
418 				bSkipFile( false ),
419 				sProject( sPrj ),
420 				sRoot( sPrjRoot ),
421 				bEnableExport( bWrite ),
422 				bMergeMode( bUnmerge ),
423 				bError( sal_False ),
424 				bReadOver( sal_False ),
425 				bDontWriteOutput( sal_False ),
426 				sFilename( rFile )
427 {
428 	pParseQueue = new ParserQueue( *this );
429 	(void) rPrj;
430 	(void) rPrjRoot;
431 	(void) rFile;
432 
433 	if( !isInitialized ) InitLanguages();
434 	// used when export is enabled
435 
436 	// open output stream
437 	if ( bEnableExport ) {
438 		aOutput.Open( String( rOutput, RTL_TEXTENCODING_ASCII_US ), STREAM_STD_WRITE | STREAM_TRUNC );
439 		if( !aOutput.IsOpen() ) {
440 			printf("ERROR : Can't open file %s\n",rOutput.GetBuffer());
441 			exit ( -1 );
442 		}
443 		aOutput.SetStreamCharSet( RTL_TEXTENCODING_UTF8 );
444 
445 		aOutput.SetLineDelimiter( LINEEND_CRLF );
446 	}
447 }
448 
449 /*****************************************************************************/
Export(const ByteString & rOutput,sal_Bool bWrite,const ByteString & rPrj,const ByteString & rPrjRoot,const ByteString & rMergeSource,const ByteString & rFile)450 Export::Export( const ByteString &rOutput, sal_Bool bWrite,
451 				const ByteString &rPrj, const ByteString &rPrjRoot,
452 				const ByteString &rMergeSource , const ByteString& rFile )
453 /*****************************************************************************/
454 				:
455 				pWordTransformer( NULL ),
456 				aCharSet( RTL_TEXTENCODING_MS_1252 ),
457 				bDefine( sal_False ),
458 				bNextMustBeDefineEOL( sal_False ),
459 				nLevel( 0 ),
460 				nList( LIST_NON ),
461 				nListIndex( 0 ),
462 				nListLevel( 0 ),
463 				bSkipFile( false ),
464 				sProject( sPrj ),
465 				sRoot( sPrjRoot ),
466 				bEnableExport( bWrite ),
467 				bMergeMode( sal_True ),
468 				sMergeSrc( rMergeSource ),
469 				bError( sal_False ),
470 				bReadOver( sal_False ),
471 				bDontWriteOutput( sal_False ),
472 				sFilename( rFile )
473 {
474 	(void) rPrj;
475 	(void) rPrjRoot;
476 	(void) rFile;
477 	pParseQueue = new ParserQueue( *this );
478 	if( !isInitialized ) InitLanguages( bMergeMode );
479 	// used when merge is enabled
480 
481 	// open output stream
482 	if ( bEnableExport ) {
483 		aOutput.Open( String( rOutput, RTL_TEXTENCODING_ASCII_US ), STREAM_STD_WRITE | STREAM_TRUNC );
484 		aOutput.SetStreamCharSet( RTL_TEXTENCODING_UTF8 );
485 		aOutput.SetLineDelimiter( LINEEND_CRLF );
486 	}
487 
488 }
489 
490 /*****************************************************************************/
Init()491 void Export::Init()
492 /*****************************************************************************/
493 {
494 	// resets the internal status, used before parsing another file
495 	sActPForm = "";
496 	bDefine = sal_False;
497 	bNextMustBeDefineEOL = sal_False;
498 	nLevel = 0;
499 	nList = LIST_NON;
500 	nListLang = ByteString( String::CreateFromAscii(""),RTL_TEXTENCODING_ASCII_US );
501 	nListIndex = 0;
502 	while ( aResStack.Count()) {
503 		delete aResStack.GetObject(( sal_uLong ) 0 );
504 		aResStack.Remove(( sal_uLong ) 0 );
505 	}
506 }
507 
508 /*****************************************************************************/
~Export()509 Export::~Export()
510 /*****************************************************************************/
511 {
512 	if( pParseQueue )
513 		delete pParseQueue;
514 	// close output stream
515 	if ( bEnableExport )
516 		aOutput.Close();
517 	while ( aResStack.Count()) {
518 		delete aResStack.GetObject(( sal_uLong ) 0 );
519 		aResStack.Remove(( sal_uLong ) 0 );
520 	}
521 
522 	if ( bMergeMode && !bUnmerge ) {
523 		if ( !pMergeDataFile )
524 			pMergeDataFile = new MergeDataFile( sMergeSrc,sFile , bErrorLog, aCharSet);//, bUTF8 );
525 
526 		//pMergeDataFile->WriteErrorLog( sActFileName );
527 		delete pMergeDataFile;
528 	}
529 }
530 
531 /*****************************************************************************/
Execute(int nToken,const char * pToken)532 int Export::Execute( int nToken, const char * pToken )
533 /*****************************************************************************/
534 {
535 
536 	ByteString sToken( pToken );
537 	ByteString sOrig( sToken );
538 /*	printf("+---------------\n");
539 	printf("sToken = %s\n",sToken.GetBuffer());
540 	printf("nToken = %d\n",nToken);
541 	printf("+---------------\n"); */
542 	sal_Bool bWriteToMerged = bMergeMode;
543 
544 	if ( nToken == CONDITION ) {
545 		ByteString sTestToken( pToken );
546 		sTestToken.EraseAllChars( '\t' );
547 		sTestToken.EraseAllChars( ' ' );
548 		if (( !bReadOver ) && ( sTestToken.Search( "#ifndef__RSC_PARSER" ) == 0 ))
549 			bReadOver = sal_True;
550 		else if (( bReadOver ) && ( sTestToken.Search( "#endif" ) == 0 ))
551 			bReadOver = sal_False;
552 	}
553 	if ((( nToken < FILTER_LEVEL ) || ( bReadOver )) &&
554 		(!(( bNextMustBeDefineEOL ) && ( sOrig == "\n" )))) {
555 		// these tokens are not mandatory for parsing, so ignore them...
556 		if ( bMergeMode )
557 			WriteToMerged( sOrig , false ); // ...or write them directly to dest.
558 		return 0;
559 	}
560 
561 	ResData *pResData = NULL;
562 	if ( nLevel ) {
563 		// res. exists at cur. level
564 		pResData = aResStack.GetObject( nLevel-1 );
565 	}
566 	else if (( nToken != RESSOURCE ) &&
567 			( nToken != RESSOURCEEXPR ) &&
568 			( nToken != SMALRESSOURCE ) &&
569 			( nToken != LEVELUP ) &&
570 			( nToken != NORMDEFINE ) &&
571 			( nToken != RSCDEFINE ) &&
572 			( nToken != CONDITION ) &&
573 			( nToken != PRAGMA ))
574 	{
575 		// no res. exists at cur. level so return
576 		if ( bMergeMode )
577 			WriteToMerged( sOrig , false );
578 		return 0;
579 	}
580 	// #define NO_LOCALIZE_EXPORT
581 	if( bSkipFile ){
582 		if ( bMergeMode ) {
583 			WriteToMerged( sOrig , false );
584 		}
585 		return 1;
586 	}
587 
588 
589 	if ( bDefine ) {
590 		if (( nToken != EMPTYLINE ) && ( nToken != LEVELDOWN ) && ( nToken != LEVELUP )) {
591 			// cur. res. defined in macro
592 			if ( bNextMustBeDefineEOL ) {
593 				if ( nToken != RSCDEFINELEND ) {
594 					// end of macro found, so destroy res.
595 					bDefine = sal_False;
596 					if ( bMergeMode ) {
597 						/*if ( bDontWriteOutput && bUnmerge ) {
598 							bDontWriteOutput = sal_False;
599 							bNextMustBeDefineEOL = sal_False;
600 							bDefine = sal_True;
601 						}*/
602 						MergeRest( pResData );
603 					}
604 					bNextMustBeDefineEOL = sal_False;
605 					Execute( LEVELDOWN, "" );
606 				}
607 				else {
608 					// next line also in macro definition
609 					bNextMustBeDefineEOL = sal_False;
610 					if ( bMergeMode )
611 						WriteToMerged( sOrig , false );
612 					return 1;
613 				}
614 			}
615 			else if (( nToken != LISTASSIGNMENT ) && ( nToken != UIENTRIES )){
616 				// cur. line has macro line end
617 				ByteString sTmpLine( sToken );
618 				sTmpLine.EraseAllChars( '\t' ); sTmpLine.EraseAllChars( ' ' );
619 				#if 0
620 				// impossible, unsigned is never negative
621 				if( sTmpLine.Len() < 0 ){
622 					if ( sTmpLine.GetChar(( sal_uInt16 )( sTmpLine.Len() - 1 )) != '\\' )
623 						bNextMustBeDefineEOL = sal_True;
624 				}
625 				#endif
626 			}
627 		}
628 	}
629 
630 	sal_Bool bExecuteDown = sal_False;
631 	if ( nToken != LEVELDOWN ) {
632 		sal_uInt16 nOpen = 0;
633 		sal_uInt16 nClose = 0;
634 		sal_Bool bReadOver1 = sal_False;
635 		sal_uInt16 i = 0;
636 		for ( i = 0; i < sToken.Len(); i++ ) {
637 			if ( sToken.GetChar( i ) == '\"' )
638 				bReadOver1 = !bReadOver1;
639 			if ( !bReadOver1 && ( sToken.GetChar( i ) == '{' ))
640 				nOpen++;
641 		}
642 
643 		bReadOver1 = sal_False;
644 		for ( i = 0; i < sToken.Len(); i++ ) {
645 			if ( sToken.GetChar( i ) == '\"' )
646 				bReadOver1 = !bReadOver1;
647 			if ( !bReadOver1 && ( sToken.GetChar( i ) == '}' ))
648 				nClose++;
649 		}
650 
651 		if ( nOpen < nClose )
652 			bExecuteDown = sal_True;
653 	}
654 	switch ( nToken ) {
655 
656 		case NORMDEFINE:
657                         //printf("sToken = '%s'",sToken.GetBuffer());
658                         while( sToken.SearchAndReplace( "\r", " " ) != STRING_NOTFOUND ) {};
659                         while( sToken.SearchAndReplace( "\t", " " ) != STRING_NOTFOUND ) {};
660                         while( sToken.SearchAndReplace( "  ", " " ) != STRING_NOTFOUND ) {};
661                         if( sToken.EqualsIgnoreCaseAscii( "#define NO_LOCALIZE_EXPORT" ) ){
662                             bSkipFile = true;
663                             return 0;
664                         }
665                         if ( bMergeMode )
666                           WriteToMerged( sOrig , false );
667 
668                         return 0;
669 
670 
671 		case RSCDEFINE:
672 			bDefine = sal_True; // res. defined in macro
673 
674 		case RESSOURCE:
675 		case RESSOURCEEXPR: {
676 			bDontWriteOutput = sal_False;
677 			if ( nToken != RSCDEFINE )
678 				bNextMustBeDefineEOL = sal_False;
679 			// this is the beginning of a new res.
680 			nLevel++;
681 			if ( nLevel > 1 ) {
682 				aResStack.GetObject( nLevel - 2 )->bChild = sal_True;
683 			}
684 
685 			// create new instance for this res. and fill mandatory fields
686 
687 			pResData = new ResData( sActPForm, FullId() , sFilename );
688 			aResStack.Insert( pResData, LIST_APPEND );
689 			ByteString sBackup( sToken );
690 			sToken.EraseAllChars( '\n' );
691 			sToken.EraseAllChars( '\r' );
692 			sToken.EraseAllChars( '{' );
693 			while( sToken.SearchAndReplace( "\t", " " ) != STRING_NOTFOUND ) {};
694 			sToken.EraseTrailingChars( ' ' );
695 			ByteString sT = sToken.GetToken( 0, ' ' );
696 			pResData->sResTyp = sT.ToLowerAscii();
697 			ByteString sId( sToken.Copy( pResData->sResTyp.Len() + 1 ));
698 			ByteString sCondition;
699 			if ( sId.Search( "#" ) != STRING_NOTFOUND ) {
700 				// between ResTyp, Id and paranthes is a precomp. condition
701 				sCondition = "#";
702 				sCondition += sId.GetToken( 1, '#' );
703 				sId = sId.GetToken( 0, '#' );
704 			}
705 			sId = sId.GetToken( 0, '/' );
706 			CleanValue( sId );
707 			sId = sId.EraseAllChars( '\t' );
708 			pResData->SetId( sId, ID_LEVEL_IDENTIFIER );
709 			if ( sCondition.Len()) {
710 				ByteString sEmpty( "" );
711 				Execute( CONDITION, sEmpty.GetBufferAccess()); 	// execute the
712 														  		// precomp.
713 																// condition
714 				sEmpty.ReleaseBufferAccess();
715 			}
716 		}
717 		break;
718 		case SMALRESSOURCE: {
719 			bDontWriteOutput = sal_False;
720 			// this is the beginning of a new res.
721 			bNextMustBeDefineEOL = sal_False;
722 			nLevel++;
723 			if ( nLevel > 1 ) {
724 				aResStack.GetObject( nLevel - 2 )->bChild = sal_True;
725 			}
726 
727 			// create new instance for this res. and fill mandatory fields
728 
729 			pResData = new ResData( sActPForm, FullId() , sFilename );
730 			aResStack.Insert( pResData, LIST_APPEND );
731 			sToken.EraseAllChars( '\n' );
732 			sToken.EraseAllChars( '\r' );
733 			sToken.EraseAllChars( '{' );
734 			sToken.EraseAllChars( '\t' );
735 			sToken.EraseAllChars( ' ' );
736 			sToken.EraseAllChars( '\\' );
737 			pResData->sResTyp = sToken.ToLowerAscii();
738 		}
739 		break;
740 		case LEVELUP: {
741 			// push
742 			if ( nList )
743 				nListLevel++;
744 			if ( nList )
745 				break;
746 
747 			bDontWriteOutput = sal_False;
748 			ByteString sLowerTyp;
749 			if ( pResData )
750 				sLowerTyp = "unknown";
751 			nLevel++;
752 			if ( nLevel > 1 ) {
753 				aResStack.GetObject( nLevel - 2 )->bChild = sal_True;
754 			}
755 
756 			ResData *pNewData = new ResData( sActPForm, FullId() , sFilename );
757 			pNewData->sResTyp = sLowerTyp;
758 			aResStack.Insert( pNewData, LIST_APPEND );
759 		}
760 		break;
761 		case LEVELDOWN: {
762 			// pop
763 			if ( !nList ) {
764 				bDontWriteOutput = sal_False;
765 				if ( nLevel ) {
766 					if ( bDefine && (nLevel == 1 )) {
767 						bDefine = sal_False;
768 						bNextMustBeDefineEOL = sal_False;
769 					}
770 					WriteData( pResData );
771 					delete aResStack.GetObject( nLevel - 1 );
772 					aResStack.Remove( nLevel - 1 );
773 					nLevel--;
774 				}
775 			}
776 			else {
777 				if ( bDefine )
778 					bNextMustBeDefineEOL = sal_True;
779 				if ( !nListLevel ) {
780 					if ( bMergeMode )
781 						MergeRest( pResData, MERGE_MODE_LIST );
782 					nList = LIST_NON;
783 				}
784 				else
785 					nListLevel--;
786 			}
787 		}
788 		break;
789 		case ASSIGNMENT: {
790 			bDontWriteOutput = sal_False;
791 			// interpret different types of assignment
792  			ByteString sKey = sToken.GetToken( 0, '=' );
793 			sKey.EraseAllChars( ' ' );
794 			sKey.EraseAllChars( '\t' );
795 			ByteString sValue = sToken.GetToken( 1, '=' );
796 			CleanValue( sValue );
797 			if ( sKey.ToUpperAscii() == "IDENTIFIER" ) {
798 				ByteString sId( sValue.EraseAllChars( '\t' ));
799 				pResData->SetId( sId.EraseAllChars( ' ' ), ID_LEVEL_IDENTIFIER );
800 			}
801 			else if ( sKey == "HELPID" ) {
802 				pResData->sHelpId = sValue;
803 			}
804 			else if ( sKey == "STRINGLIST" ) {
805 				//if ( bUnmerge ){
806 				//	( sOrig.SearchAndReplace( "=", "[ de ] =" ));
807 				//}
808 
809 				pResData->bList = sal_True;
810 				nList = LIST_STRING;
811                 //ByteString sLang("en-US" , RTL_TEXTENCODING_ASCII_US );
812                 nListLang = SOURCE_LANGUAGE;
813 				nListIndex = 0;
814 				nListLevel = 0;
815 			}
816 			else if ( sKey == "FILTERLIST" ) {
817 				//if ( bUnmerge ){
818 				//	( sOrig.SearchAndReplace( "=", "[ de ] =" ));
819 				//}
820 				pResData->bList = sal_True;
821 				nList = LIST_FILTER;
822                 //ByteString sLang("en-US" , RTL_TEXTENCODING_ASCII_US );
823 				nListLang = SOURCE_LANGUAGE;
824 				nListIndex = 0;
825 				nListLevel = 0;
826 			}
827 			else if ( sKey == "UIENTRIES" ) {
828 				//if ( bUnmerge ){
829 				//	( sOrig.SearchAndReplace( "=", "[ de ] =" ));}
830 				pResData->bList = sal_True;
831 				nList = LIST_UIENTRIES;
832 				//ByteString sLang("en-US" , RTL_TEXTENCODING_ASCII_US );
833 				nListLang = SOURCE_LANGUAGE;
834 				nListIndex = 0;
835 				nListLevel = 0;
836 			}
837 			if (( sToken.Search( "{" ) != STRING_NOTFOUND ) &&
838 				( sToken.GetTokenCount( '{' ) > sToken.GetTokenCount( '}' )))
839 			{
840 				//WorkOnTokenSet( LEVELUP, pTkn );
841                 Parse( LEVELUP, "" );
842 			}
843             //if ( bUnmerge && ( nListLang.EqualsIgnoreCaseAscii("de") || nListLang.EqualsIgnoreCaseAscii("en-US") ) && ListExists( pResData, nList ))
844 			//	bDontWriteOutput = sal_True;
845  		}
846 		break;
847 		case UIENTRIES:
848 		case LISTASSIGNMENT: {
849 			bDontWriteOutput = sal_False;
850             ByteString sTmpToken( sToken);
851             sTmpToken.EraseAllChars(' ');
852             sal_uInt16 nPos = 0;
853             //nPos = sTmpToken.ToLowerAscii().Search("[de]=");
854 			nPos = sTmpToken.ToLowerAscii().Search("[en-us]=");
855             if( nPos != STRING_NOTFOUND ) {
856 				//if ( bUnmerge ){
857 				//	( sOrig.SearchAndReplace( "=", "[ de ] =" ));
858 				//}
859                 ByteString sKey = sTmpToken.Copy( 0 , nPos );
860 				sKey.EraseAllChars( ' ' );
861 				sKey.EraseAllChars( '\t' );
862 				ByteString sValue = sToken.GetToken( 1, '=' );
863 				CleanValue( sValue );
864 				if ( sKey.ToUpperAscii() == "STRINGLIST" ) {
865 					pResData->bList = sal_True;
866 					nList = LIST_STRING;
867 					//ByteString sLang("en-US" , RTL_TEXTENCODING_ASCII_US );
868 					nListLang = SOURCE_LANGUAGE;
869 					nListIndex = 0;
870 					nListLevel = 0;
871 				}
872 				else if ( sKey == "FILTERLIST" ) {
873 					pResData->bList = sal_True;
874 					nList = LIST_FILTER;
875 					//ByteString sLang("en-US" , RTL_TEXTENCODING_ASCII_US );
876 					nListLang = SOURCE_LANGUAGE;
877 					nListIndex = 0;
878 					nListLevel = 0;
879 				}
880 				// PairedList
881                 else if ( sKey == "PAIREDLIST" ) {
882 					pResData->bList = sal_True;
883 					nList = LIST_PAIRED;
884 					//ByteString sLang("en-US" , RTL_TEXTENCODING_ASCII_US );
885 					nListLang = SOURCE_LANGUAGE;
886 					nListIndex = 0;
887 					nListLevel = 0;
888 				}
889 
890                 else if ( sKey == "ITEMLIST" ) {
891 					pResData->bList = sal_True;
892 					nList = LIST_ITEM;
893 					//ByteString sLang("en-US" , RTL_TEXTENCODING_ASCII_US );
894 					nListLang = SOURCE_LANGUAGE;
895 					nListIndex = 0;
896 					nListLevel = 0;
897 				}
898 				else if ( sKey == "UIENTRIES" ) {
899 					pResData->bList = sal_True;
900 					nList = LIST_UIENTRIES;
901 					//ByteString sLang("en-US" , RTL_TEXTENCODING_ASCII_US );
902 					nListLang = SOURCE_LANGUAGE;
903 					nListIndex = 0;
904 					nListLevel = 0;
905 				}
906                 /*if ( bUnmerge && ( nListLang.EqualsIgnoreCaseAscii( "de" )
907                     || nListLang.EqualsIgnoreCaseAscii("en-US" ) )
908                     && ListExists( pResData, nList ))
909 					bDontWriteOutput = sal_True;*/
910 			}
911 			else {
912 				// new res. is a String- or FilterList
913 				ByteString sKey = sToken.GetToken( 0, '[' );
914 				sKey.EraseAllChars( ' ' );
915 				sKey.EraseAllChars( '\t' );
916 				if ( sKey.ToUpperAscii() == "STRINGLIST" )
917 					nList = LIST_STRING;
918 				else if ( sKey == "FILTERLIST" )
919 					nList = LIST_FILTER;
920 				else if ( sKey == "PAIREDLIST" )
921 					nList = LIST_PAIRED;				// abcd
922 				else if ( sKey == "ITEMLIST" )
923 					nList = LIST_ITEM;
924 				else if ( sKey == "UIENTRIES" )
925 					nList = LIST_UIENTRIES;
926 				if ( nList ) {
927 					ByteString sLang=sToken.GetToken( 1, '[' ).GetToken( 0, ']' );
928 					CleanValue( sLang );
929                     nListLang = sLang;
930                     /*if (( bUnmerge ) && ( !nListLang.EqualsIgnoreCaseAscii("de")) && ( !nListLang.EqualsIgnoreCaseAscii("en-US")))
931                         bDontWriteOutput = sal_True;*/
932 					nListIndex = 0;
933 					nListLevel = 0;
934                     /*if ( bUnmerge && nListLang.EqualsIgnoreCaseAscii("de") && ListExists( pResData, nList ) )
935 						bDontWriteOutput = sal_True;*/
936 				}
937 			}
938 		}
939 		break;
940 		case TEXT:
941 		case _LISTTEXT:
942 		case LISTTEXT: {
943 			// this is an entry for a String- or FilterList
944 			if ( nList ) {
945 				SetChildWithText();
946 				ByteString sEntry( sToken.GetToken( 1, '\"' ));
947 				if ( sToken.GetTokenCount( '\"' ) > 3 )
948 					sEntry += "\"";
949 				if ( sEntry == "\\\"" )
950 					sEntry = "\"";
951 				//sEntry = sEntry.Convert( aCharSet, RTL_TEXTENCODING_MS_1252 );
952 				//sEntry = sEntry.Convert( RTL_TEXTENCODING_MS_1252, RTL_TEXTENCODING_UTF8 );
953 				InsertListEntry( sEntry, sOrig );
954 				if ( bMergeMode && ( sEntry != "\"" )) {
955 					PrepareTextToMerge( sOrig, nList, nListLang, pResData );
956 				}
957 			}
958 		}
959 		break;
960 		case LONGTEXTLINE:
961 		case TEXTLINE:
962 			bDontWriteOutput = sal_False;
963 			if ( nLevel ) {
964 				CutComment( sToken );
965 
966 				// this is a text line!!!
967 				ByteString sKey = sToken.GetToken( 0, '=' ).GetToken( 0, '[' );
968 				sKey.EraseAllChars( ' ' );
969 				sKey.EraseAllChars( '\t' );
970 				ByteString sText( GetText( sToken, nToken ));
971 				if ( !bMergeMode )
972 					sText = sText.Convert( aCharSet, RTL_TEXTENCODING_MS_1252 );
973 				ByteString sLang;
974 				if ( sToken.GetToken( 0, '=' ).Search( "[" ) != STRING_NOTFOUND ) {
975  					sLang = sToken.GetToken( 0, '=' ).GetToken( 1, '[' ).GetToken( 0, ']' );
976 					CleanValue( sLang );
977 				}
978 				ByteString nLangIndex = sLang;
979                 ByteString sOrigKey = sKey;
980 				if ( sText.Len() && sLang.Len() ) {
981 					if (( sKey.ToUpperAscii() == "TEXT" ) ||
982 						( sKey == "MESSAGE" ) ||
983 						( sKey == "CUSTOMUNITTEXT" ) ||
984 						( sKey == "SLOTNAME" ) ||
985 						( sKey == "UINAME" ))
986 					{
987 						//if ( bUnmerge && sToken.GetToken( 0, '=' ).Search( "[" ) == STRING_NOTFOUND )
988 						//	( sOrig.SearchAndReplace( "=", "[ de ] =" ));
989 
990 						SetChildWithText();
991                         //if ( nLangIndex.EqualsIgnoreCaseAscii("en-US") )
992 						if ( Export::isSourceLanguage( nLangIndex ) )
993 							pResData->SetId( sText, ID_LEVEL_TEXT );
994 
995 						pResData->bText = sal_True;
996 						pResData->sTextTyp = sOrigKey;
997 						if ( bMergeMode ) {
998 							PrepareTextToMerge( sOrig, STRING_TYP_TEXT, nLangIndex, pResData );
999 							//if ( bUnmerge )
1000 							//	pResData->sText[ nLangIndex ] = sText;
1001 						}
1002 						else {
1003 							if ( pResData->sText[ nLangIndex ].Len()) {
1004 								ByteString sError( "Language " );
1005                                 sError += nLangIndex;
1006 								sError += " defined twice";
1007 							}
1008 							pResData->sText[ nLangIndex ] = sText;
1009 						}
1010 					}
1011 					else if ( sKey == "HELPTEXT" ) {
1012 						//if ( bUnmerge && sToken.GetToken( 0, '=' ).Search( "[" ) == STRING_NOTFOUND ){
1013 						//	( sOrig.SearchAndReplace( "=", "[ de ] =" ));
1014 						//	}
1015 						SetChildWithText();
1016 						pResData->bHelpText = sal_True;
1017 						if ( bBreakWhenHelpText ) {
1018 							ByteString sError( "\"HelpText\" found in source\n" );
1019 							YYWarning( sError.GetBufferAccess());
1020 							sError.ReleaseBufferAccess();
1021 							SetError();
1022 						}
1023 						if ( bMergeMode )
1024 							PrepareTextToMerge( sOrig, STRING_TYP_HELPTEXT, nLangIndex, pResData );
1025 							//if ( bUnmerge )
1026 							//	pResData->sHelpText[ nLangIndex ] = sText;
1027 						else {
1028 							if ( pResData->sHelpText[ nLangIndex ].Len()) {
1029 								ByteString sError( "Language " );
1030                                 sError += nLangIndex;
1031 								sError += " defined twice";
1032 							}
1033 							pResData->sHelpText[ nLangIndex ] = sText;
1034 						}
1035 					}
1036 					else if ( sKey == "QUICKHELPTEXT" ) {
1037 						//if ( bUnmerge && sToken.GetToken( 0, '=' ).Search( "[" ) == STRING_NOTFOUND ){
1038 						//	( sOrig.SearchAndReplace( "=", "[ de ] =" ));
1039 						//	}
1040 						SetChildWithText();
1041 						pResData->bQuickHelpText = sal_True;
1042 						if ( bMergeMode )
1043 							PrepareTextToMerge( sOrig, STRING_TYP_QUICKHELPTEXT, nLangIndex, pResData );
1044 							//if ( bUnmerge )
1045 							//	pResData->sQuickHelpText[ nLangIndex ] = sText;
1046 						else {
1047 							if ( pResData->sQuickHelpText[ nLangIndex ].Len()) {
1048 								ByteString sError( "Language " );
1049                                 sError += nLangIndex;
1050 								sError += " defined twice";
1051 							}
1052 							pResData->sQuickHelpText[ nLangIndex ] = sText;
1053 						}
1054 					}
1055 					else if ( sKey == "TITLE" ) {
1056 						//if ( bUnmerge && sToken.GetToken( 0, '=' ).Search( "[" ) == STRING_NOTFOUND ){
1057 						//	( sOrig.SearchAndReplace( "=", "[ de ] =" ));
1058 						//	}
1059 						SetChildWithText();
1060 						pResData->bTitle = sal_True;
1061 						if ( bMergeMode )
1062 							PrepareTextToMerge( sOrig, STRING_TYP_TITLE, nLangIndex, pResData );
1063 							//if ( bUnmerge )
1064 							//	pResData->sTitle[ nLangIndex ] = sText;
1065 						else {
1066 							if ( pResData->sTitle[ nLangIndex ].Len()) {
1067 								ByteString sError( "Language " );
1068                                 sError += nLangIndex;
1069 								sError += " defined twice";
1070 							}
1071 							pResData->sTitle[ nLangIndex ] = sText;
1072 						}
1073 					}
1074 					else if ( sKey == "ACCESSPATH" ) {
1075 						pResData->SetId( sText, ID_LEVEL_ACCESSPATH );
1076 					}
1077 					else if ( sKey == "FIELDNAME" ) {
1078 						pResData->SetId( sText, ID_LEVEL_FIELDNAME );
1079 					}
1080 				}
1081 			}
1082 		break;
1083 		case APPFONTMAPPING: {
1084 			bDontWriteOutput = sal_False;
1085 			// this is a AppfontMapping, so look if it's a definition
1086 			// of field size
1087 			ByteString sKey = sToken.GetToken( 0, '=' );
1088 			sKey.EraseAllChars( ' ' );
1089 			sKey.EraseAllChars( '\t' );
1090 			ByteString sMapping = sToken.GetToken( 1, '=' );
1091 			sMapping = sMapping.GetToken( 1, '(' );
1092 			sMapping = sMapping.GetToken( 0, ')' );
1093 			sMapping.EraseAllChars( ' ' );
1094 			sMapping.EraseAllChars( '\t' );
1095 			if ( sKey.ToUpperAscii() == "SIZE" ) {
1096 				pResData->nWidth = ( sal_uInt16 ) sMapping.GetToken( 0, ',' ).ToInt64();
1097 			}
1098 			else if ( sKey == "POSSIZE" ) {
1099 				pResData->nWidth = ( sal_uInt16 ) sMapping.GetToken( 2, ',' ).ToInt64();
1100 			}
1101 		}
1102 		break;
1103 		case RSCDEFINELEND:
1104 			bDontWriteOutput = sal_False;
1105 		break;
1106 		case CONDITION: {
1107 			bDontWriteOutput = sal_False;
1108 			while( sToken.SearchAndReplace( "\r", " " ) != STRING_NOTFOUND ) {};
1109 			while( sToken.SearchAndReplace( "\t", " " ) != STRING_NOTFOUND ) {};
1110 			while( sToken.SearchAndReplace( "  ", " " ) != STRING_NOTFOUND ) {};
1111 			ByteString sCondition = sToken.GetToken( 0, ' ' );
1112 			if ( sCondition == "#ifndef" ) {
1113 				sActPForm = "!defined ";
1114 				sActPForm += sToken.GetToken( 1, ' ' );
1115 			}
1116 			else if ( sCondition == "#ifdef" ) {
1117 				sActPForm = "defined ";
1118 				sActPForm += sToken.GetToken( 1, ' ' );
1119 			}
1120 			else if ( sCondition == "#if" ) {
1121 				sActPForm = sToken.Copy( 4 );
1122 				while ( sActPForm.SearchAndReplace( "||", "\\or" ) != STRING_NOTFOUND ) {};
1123 			}
1124 			else if ( sCondition == "#elif" ) {
1125 				sActPForm = sToken.Copy( 6 );
1126 				while ( sActPForm.SearchAndReplace( "||", "\\or" ) != STRING_NOTFOUND ) {};
1127 			}
1128 			else if ( sCondition == "#else" ) {
1129 				sActPForm = sCondition;
1130 			}
1131 			else if ( sCondition == "#endif" ) {
1132 				sActPForm = "";
1133 			}
1134 			else break;
1135 			if ( nLevel ) {
1136 				WriteData( pResData, sal_True );
1137 				pResData->sPForm = sActPForm;
1138 			}
1139 		}
1140 		break;
1141 		case EMPTYLINE : {
1142 			bDontWriteOutput = sal_False;
1143 			if ( bDefine ) {
1144 				bNextMustBeDefineEOL = sal_False;
1145                 bDefine = sal_False;
1146 				while ( nLevel )
1147 					Parse( LEVELDOWN, "" );
1148                     //WorkOnTokenSet( LEVELDOWN, pTkn );
1149 			}
1150 		}
1151 		break;
1152 		case PRAGMA : {
1153 			bDontWriteOutput = sal_False;
1154 			while( sToken.SearchAndReplace( "\t", " " ) != STRING_NOTFOUND ) {};
1155 			while( sToken.SearchAndReplace( "  ", " " ) != STRING_NOTFOUND ) {};
1156 			sToken.EraseLeadingChars( ' ' );
1157 			sToken.EraseTrailingChars( ' ' );
1158 
1159 			ByteString sCharset = sToken.GetToken( 1, ' ' );
1160 			ByteString sSet = sToken.GetToken( 2, ' ' );
1161 			if (( sCharset.ToUpperAscii() == "CHARSET_IBMPC" ) ||
1162 				( sCharset == "RTL_TEXTENCODING_IBM_850" ) ||
1163 				(( sCharset == "CHARSET" ) && ( sSet.ToUpperAscii() == "IBMPC" )))
1164 			{
1165 				aCharSet = RTL_TEXTENCODING_IBM_850;
1166 			}
1167 			else if (( sCharset == "CHARSET_ANSI" ) ||
1168 				( sCharset == "RTL_TEXTENCODING_MS_1252" ) ||
1169 				(( sCharset == "CHARSET" ) && ( sSet.ToUpperAscii() == "ANSI" )))
1170 			{
1171 				aCharSet = RTL_TEXTENCODING_MS_1252;
1172 			}
1173 		}
1174 		break;
1175 		case TEXTREFID : {
1176 			bDontWriteOutput = sal_True;
1177  			/*ByteString sK = sToken.GetToken( 0, '=' );
1178             ByteString sKey = sK.EraseAllChars( '\t' ).EraseAllChars( ' ' );
1179 			ByteString sT = sToken.GetToken( 1, '=' ).GetToken( 0, ';' );
1180             sal_uInt16 nRefId = ( sal_uInt16 ) sT.EraseAllChars( '\t' ).EraseAllChars( ' ' ).ToInt32();
1181 			if (( sKey.ToUpperAscii() == "TEXT" ) ||
1182 				( sKey == "MESSAGE" ) ||
1183 				( sKey == "CUSTOMUNITTEXT" ) ||
1184 				( sKey == "SLOTNAME" ) ||
1185 				( sKey == "UINAME" ))
1186 					pResData->nTextRefId = nRefId;
1187 			else if ( sKey == "HELPTEXT" )
1188 				pResData->nHelpTextRefId = nRefId;
1189 			else if ( sKey == "QUICKHELPTEXT" )
1190 				pResData->nQuickHelpTextRefId = nRefId;
1191 			else if ( sKey == "TITLE" )
1192 				pResData->nTitleRefId = nRefId;*/
1193 		}
1194 		}
1195 	if ( bWriteToMerged ) {
1196 		// the current token must be written to dest. without merging
1197 
1198         if( bDefine && sOrig.Len() > 2 ){
1199             for( sal_uInt16 n = 0 ; n < sOrig.Len() ; n++ ){
1200                 if( sOrig.GetChar( n ) == '\n' && sOrig.GetChar( n-1 ) != '\\'){
1201                     sOrig.Insert('\\' , n++ );
1202                 }
1203             }
1204         }
1205         WriteToMerged( sOrig , false);
1206 	}
1207 
1208 	if ( bExecuteDown ) {
1209 		Parse( LEVELDOWN, "" );
1210         //WorkOnTokenSet( LEVELDOWN, pTkn );
1211 	}
1212 
1213 	return 1;
1214 }
1215 
1216 /*****************************************************************************/
CutComment(ByteString & rText)1217 void Export::CutComment( ByteString &rText )
1218 /*****************************************************************************/
1219 {
1220 	if ( rText.Search( "//" ) != STRING_NOTFOUND ) {
1221 		ByteString sWork( rText );
1222 		sWork.SearchAndReplaceAll( "\\\"", "XX" );
1223 		sal_uInt16 i = 0;
1224 		sal_Bool bInner = sal_False;
1225 
1226 		while ( i < sWork.Len() - 1 ) {
1227 			if ( sWork.GetChar( i ) == '\"' )
1228 				bInner = !bInner;
1229 			else if
1230 				(( sWork.GetChar( i ) == '/' ) &&
1231 				( !bInner ) &&
1232 				( sWork.GetChar( i + 1 ) == '/' ))
1233 			{
1234 				rText.Erase( i );
1235 				return;
1236 			}
1237 			i++;
1238 		}
1239 	}
1240 }
1241 
UnmergeUTF8(ByteString & sOrig)1242 void Export::UnmergeUTF8( ByteString& sOrig ){
1243 	sal_uInt16 nPos1 = sOrig.Search('\"');
1244 	sal_uInt16 nPos2 = sOrig.SearchBackward('\"');
1245 	if( nPos1 > 0 && nPos2 > 0 && nPos1 < nPos2){
1246 		ByteString sPart = sOrig.Copy(nPos1+1 , nPos2-1);
1247 		ByteString sPartUTF8 = sPart;
1248 		sPartUTF8.Convert( RTL_TEXTENCODING_MS_1252 , RTL_TEXTENCODING_UTF8 );
1249 		sOrig.SearchAndReplace( sPart , sPartUTF8 );
1250 	}
1251 }
1252 
1253 /*****************************************************************************/
ListExists(ResData * pResData,sal_uInt16 nLst)1254 sal_Bool Export::ListExists( ResData *pResData, sal_uInt16 nLst )
1255 /*****************************************************************************/
1256 {
1257 	switch ( nLst ) {
1258 		case LIST_STRING: return pResData->pStringList != NULL;
1259 		case LIST_FILTER: return pResData->pFilterList != NULL;
1260 		case LIST_ITEM: return pResData->pItemList != NULL;
1261 		case LIST_PAIRED: return pResData->pPairedList != NULL;
1262 		case LIST_UIENTRIES: return pResData->pUIEntries != NULL;
1263 	}
1264 	return sal_False;
1265 }
1266 
1267 /*****************************************************************************/
WriteData(ResData * pResData,sal_Bool bCreateNew)1268 sal_Bool Export::WriteData( ResData *pResData, sal_Bool bCreateNew )
1269 /*****************************************************************************/
1270 {
1271 	if ( bMergeMode ) {
1272 		MergeRest( pResData );
1273 		return sal_True;
1274 	}
1275 
1276 	if ( bUnmerge )
1277 		return sal_True;
1278 
1279 /*    ByteStringHashMap::iterator pos3 = pResData->sText.begin();
1280     ByteStringHashMap::iterator end3 = pResData->sText.end();
1281     for(;pos3!=end3;++pos3){
1282 
1283         printf("[%s]=%s\n", pos3->first.GetBuffer(), pos3->second.GetBuffer() );
1284     }*/
1285    	// mandatory to export: en-US
1286 
1287      if (( //pResData->sText[ ByteString("de") ].Len() &&
1288         ( pResData->sText[ SOURCE_LANGUAGE ].Len()))
1289         ||
1290         ( //pResData->sHelpText[ ByteString("de") ].Len() &&
1291         (  pResData->sHelpText[ SOURCE_LANGUAGE ].Len()))
1292         ||
1293         ( //pResData->sQuickHelpText[ ByteString("de") ].Len() &&
1294         (  pResData->sQuickHelpText[ SOURCE_LANGUAGE ].Len()))
1295          ||
1296         ( //pResData->sTitle[ ByteString("de") ].Len() &&
1297         (  pResData->sTitle[ SOURCE_LANGUAGE ].Len())))
1298 
1299 	{
1300 		FillInFallbacks( pResData );
1301 
1302 		ByteString sGID = pResData->sGId;
1303 		ByteString sLID;
1304 		if ( !sGID.Len())
1305 			sGID = pResData->sId;
1306 		else
1307 			sLID = pResData->sId;
1308 
1309 		ByteString sXText;
1310 		ByteString sXHText;
1311 		ByteString sXQHText;
1312 		ByteString sXTitle;
1313 
1314 		ByteString sTimeStamp( Export::GetTimeStamp());
1315         ByteString sCur;
1316 
1317         for( unsigned int n = 0; n < aLanguages.size(); n++ ){
1318             sCur = aLanguages[ n ];
1319                 if ( !sCur.EqualsIgnoreCaseAscii("x-comment") ){
1320                     if ( pResData->sText[ sCur ].Len())
1321                         sXText = pResData->sText[ sCur ];
1322 					else {
1323 						sXText = pResData->sText[ SOURCE_LANGUAGE ];
1324 						/*if ( !sXText.Len())
1325 							sXText = pResData->sText[ ByteString("en") ];
1326 						if ( !sXText.Len())
1327 							sXText = pResData->sText[ ByteString("de") ];*/
1328 					}
1329 
1330                     if ( pResData->sHelpText[ sCur ].Len())
1331                         sXHText = pResData->sHelpText[ sCur ];
1332 					else {
1333 						sXHText = pResData->sHelpText[ SOURCE_LANGUAGE ];
1334 						/*if ( !sXHText.Len())
1335 							sXHText = pResData->sHelpText[ ByteString("en") ];
1336 						if ( !sXText.Len())
1337 							sXHText = pResData->sHelpText[ ByteString("de") ];*/
1338 					}
1339 
1340                     if ( pResData->sQuickHelpText[ sCur ].Len())
1341                         sXQHText = pResData->sQuickHelpText[ sCur ];
1342 					else {
1343 						sXQHText = pResData->sQuickHelpText[ SOURCE_LANGUAGE ];
1344 						/*if ( !sXQHText.Len())
1345 							sXQHText = pResData->sQuickHelpText[ ByteString("en") ];
1346 						if ( !sXQHText.Len())
1347 							sXQHText = pResData->sQuickHelpText[ ByteString("de") ];*/
1348 					}
1349 
1350                     if ( pResData->sTitle[ sCur ].Len())
1351                         sXTitle = pResData->sTitle[ sCur ];
1352 					else {
1353 						sXTitle = pResData->sTitle[ SOURCE_LANGUAGE ];
1354 						/*if ( !sXTitle.Len())
1355 							sXTitle = pResData->sTitle[ ByteString("en") ];
1356 						if ( !sXTitle.Len())
1357 							sXTitle = pResData->sTitle[ ByteString("de") ];*/
1358 					}
1359 
1360 					if ( !sXText.Len())
1361 						sXText = "-";
1362 
1363 					if ( !sXHText.Len()) {
1364 						/*if ( pResData->sHelpText[ ByteString("de") ].Len())
1365 							sXHText = pResData->sHelpText[ ByteString("de") ];*/
1366 						if ( pResData->sHelpText[ SOURCE_LANGUAGE ].Len())
1367 							sXHText = pResData->sHelpText[ SOURCE_LANGUAGE ];
1368 						/*else if ( pResData->sHelpText[ ByteString("en") ].Len())
1369 							sXHText = pResData->sHelpText[ ByteString("en") ];*/
1370 					}
1371 				}
1372 				else
1373                     sXText = pResData->sText[ sCur ];
1374 
1375 				if ( bEnableExport ) {
1376 					ByteString sOutput( sProject ); sOutput += "\t";
1377 					if ( sRoot.Len())
1378 						sOutput += sActFileName;
1379 					sOutput += "\t0\t";
1380 					sOutput += pResData->sResTyp; sOutput += "\t";
1381 					sOutput += sGID; sOutput += "\t";
1382 					sOutput += sLID; sOutput += "\t";
1383 					sOutput += pResData->sHelpId; sOutput	+= "\t";
1384 					sOutput += pResData->sPForm; sOutput	+= "\t";
1385 					sOutput += ByteString::CreateFromInt64( pResData->nWidth ); sOutput += "\t";
1386                     sOutput += sCur; sOutput += "\t";
1387 
1388 
1389 					sOutput += sXText; sOutput	+= "\t";
1390 					sOutput += sXHText; sOutput += "\t";
1391 					sOutput += sXQHText; sOutput+= "\t";
1392 					sOutput += sXTitle; sOutput += "\t";
1393 					sOutput += sTimeStamp;
1394 
1395                  // if( !sCur.EqualsIgnoreCaseAscii("de") ||( sCur.EqualsIgnoreCaseAscii("de") && !Export::isMergingGermanAllowed( sProject ) ) )
1396 				    aOutput.WriteLine( sOutput );
1397 				}
1398 
1399 				if ( bCreateNew ) {
1400                     pResData->sText[ sCur ]			= "";
1401 					pResData->sHelpText[ sCur ]		= "";
1402 					pResData->sQuickHelpText[ sCur ]= "";
1403 					pResData->sTitle[ sCur ]		= "";
1404 				}
1405 			}
1406 	}
1407 	FillInFallbacks( pResData );
1408 	if ( pResData->pStringList ) {
1409 		ByteString sList( "stringlist" );
1410 		WriteExportList( pResData, pResData->pStringList, sList, bCreateNew );
1411 		if ( bCreateNew )
1412 			pResData->pStringList = 0;
1413 	}
1414 	if ( pResData->pFilterList ) {
1415 		ByteString sList( "filterlist" );
1416 		WriteExportList( pResData, pResData->pFilterList, sList, bCreateNew );
1417 		if ( bCreateNew )
1418 			pResData->pFilterList = 0;
1419 	}
1420 	if ( pResData->pItemList ) {
1421 		ByteString sList( "itemlist" );
1422 		WriteExportList( pResData, pResData->pItemList, sList, bCreateNew );
1423 		if ( bCreateNew )
1424 			pResData->pItemList = 0;
1425 	}
1426 	if ( pResData->pPairedList ) {
1427 		ByteString sList( "pairedlist" );
1428 		WriteExportList( pResData, pResData->pPairedList, sList, bCreateNew );
1429 		if ( bCreateNew )
1430 			pResData->pItemList = 0;
1431 	}
1432 	if ( pResData->pUIEntries ) {
1433 		ByteString sList( "uientries" );
1434 		WriteExportList( pResData, pResData->pUIEntries, sList, bCreateNew );
1435 		if ( bCreateNew )
1436 			pResData->pUIEntries = 0;
1437 	}
1438 	return sal_True;
1439 }
GetPairedListID(const ByteString & sText)1440 ByteString Export::GetPairedListID( const ByteString& sText ){
1441 // < "STRING" ; IDENTIFIER ; > ;
1442 	ByteString sIdent = sText.GetToken( 1, ';' );
1443 	sIdent.ToUpperAscii();
1444 	while( sIdent.SearchAndReplace( "\t", " " ) != STRING_NOTFOUND ) {};
1445 	sIdent.EraseTrailingChars( ' ' );
1446 	sIdent.EraseLeadingChars( ' ' );
1447 	return sIdent;
1448 }
GetPairedListString(const ByteString & sText)1449 ByteString Export::GetPairedListString( const ByteString& sText ){
1450 // < "STRING" ; IDENTIFIER ; > ;
1451 	ByteString sString = sText.GetToken( 0, ';' );
1452 	while( sString.SearchAndReplace( "\t", " " ) != STRING_NOTFOUND ) {};
1453 	sString.EraseTrailingChars( ' ' );
1454 	ByteString s1 = sString.Copy( sString.Search( '\"' )+1 );
1455 	sString = s1.Copy( 0 , s1.SearchBackward( '\"' ) );
1456 	sString.EraseTrailingChars( ' ' );
1457 	sString.EraseLeadingChars( ' ' );
1458 	return sString;
1459 }
StripList(const ByteString & sText)1460 ByteString Export::StripList( const ByteString& sText ){
1461 	ByteString s1 = sText.Copy( sText.Search( '\"' ) + 1 );
1462 	return s1.Copy( 0 , s1.SearchBackward( '\"' ) );
1463 }
1464 
1465 /*****************************************************************************/
WriteExportList(ResData * pResData,ExportList * pExportList,const ByteString & rTyp,sal_Bool bCreateNew)1466 sal_Bool Export::WriteExportList( ResData *pResData, ExportList *pExportList,
1467 						const ByteString &rTyp, sal_Bool bCreateNew )
1468 /*****************************************************************************/
1469 {
1470 	ByteString sGID = pResData->sGId;
1471 	if ( !sGID.Len())
1472 		sGID = pResData->sId;
1473 	else {
1474 		sGID += ".";
1475 		sGID += pResData->sId;
1476 		sGID.EraseTrailingChars( '.' );
1477 	}
1478 
1479 	ByteString sTimeStamp( Export::GetTimeStamp());
1480 	ByteString sCur;
1481 	for ( sal_uLong i = 0; pExportList != NULL && i < pExportList->Count(); i++ ) {
1482 		ExportListEntry *pEntry = pExportList->GetObject( i );
1483 				// mandatory for export: german and eng. and/or enus
1484 		//ByteString a("Export::WriteExportList::pEntry");
1485 		//Export::DumpMap( a, *pEntry );
1486 
1487 		ByteString sLID( ByteString::CreateFromInt64( i + 1 ));
1488         for( unsigned int n = 0; n < aLanguages.size(); n++ ){
1489             sCur = aLanguages[ n ];
1490             if ( //1 )
1491 				  //(*pEntry)[ ByteString("de") ].Len() &&
1492 				 	(*pEntry)[ SOURCE_LANGUAGE ].Len() )
1493 					//||
1494 				 	// 	(*pEntry)[ ByteString("en") ].Len()))
1495 				{
1496 					if ( bEnableExport )
1497 					{
1498 						ByteString sText((*pEntry)[ SOURCE_LANGUAGE ] );
1499 
1500                         // Strip PairList Line String
1501 						if( rTyp.EqualsIgnoreCaseAscii("pairedlist") ){
1502                             sLID = GetPairedListID( sText );
1503 							if ((*pEntry)[ sCur ].Len())
1504 								sText = (*pEntry)[ sCur ];
1505 							sText = GetPairedListString( sText );
1506                         }
1507 						else{
1508 							//if ((*pEntry)[ sCur ].Len()){
1509 							//	if( sCur.EqualsIgnoreCaseAscii("de") ){
1510 							//		sText = StripList( (*pEntry)[ sCur ] );
1511 							//	}
1512 							//	else
1513 									sText = StripList( (*pEntry)[ sCur ] );
1514                                     if( sText == "\\\"" )
1515                                         sText = "\"";
1516 							//}
1517 						}
1518 
1519 						ByteString sOutput( sProject ); sOutput += "\t";
1520 						if ( sRoot.Len())
1521 							sOutput += sActFileName;
1522 						sOutput += "\t0\t";
1523 						sOutput += rTyp; sOutput += "\t";
1524 						sOutput += sGID; sOutput += "\t";
1525 						sOutput += sLID; sOutput += "\t\t";
1526 						sOutput += pResData->sPForm; sOutput += "\t0\t";
1527                         sOutput += sCur; sOutput += "\t";
1528 
1529 						sOutput += sText; sOutput += "\t\t\t\t";
1530 						sOutput += sTimeStamp;
1531 
1532                         //if( !sCur.EqualsIgnoreCaseAscii("de") ||( sCur.EqualsIgnoreCaseAscii("de") && !Export::isMergingGermanAllowed( sProject ) ) )
1533                         aOutput.WriteLine( sOutput );
1534 
1535 					}
1536 				}
1537 		}
1538 		if ( bCreateNew )
1539 			delete [] pEntry;
1540 	}
1541 	if ( bCreateNew )
1542 		delete pExportList;
1543 
1544 	return sal_True;
1545 }
1546 
1547 /*****************************************************************************/
FullId()1548 ByteString Export::FullId()
1549 /*****************************************************************************/
1550 {
1551 	ByteString sFull;
1552 	if ( nLevel > 1 ) {
1553 		sFull = aResStack.GetObject( 0 )->sId;
1554 		for ( sal_uInt16 i = 1; i < nLevel - 1; i++ ) {
1555 			ByteString sToAdd = aResStack.GetObject( i )->sId;
1556 			if ( sToAdd.Len()) {
1557 				sFull += ".";
1558 				sFull += sToAdd;
1559 			}
1560 		}
1561 	}
1562     if ( sFull.Len() > 255 ) {
1563 		ByteString sError( "GroupId > 255 chars" );
1564 	    printf("GroupID = %s\n",sFull.GetBuffer());
1565         yyerror( sError.GetBufferAccess());
1566 		sError.ReleaseBufferAccess();
1567 	}
1568 
1569 	return sFull;
1570 }
1571 
1572 /*****************************************************************************/
InsertListEntry(const ByteString & rText,const ByteString & rLine)1573 void Export::InsertListEntry( const ByteString &rText, const ByteString &rLine )
1574 /*****************************************************************************/
1575 {
1576 	ResData *pResData = aResStack.GetObject( nLevel-1 );
1577 
1578 	ExportList *pList = NULL;
1579 	if ( nList == LIST_STRING ) {
1580 		pList = pResData->pStringList;
1581 		if ( !pList ) {
1582 			pResData->pStringList = new ExportList();
1583 			pList = pResData->pStringList;
1584 			nListIndex = 0;
1585 		}
1586 	}
1587 	else if ( nList == LIST_FILTER ) {
1588 		pList = pResData->pFilterList;
1589 		if ( !pList ) {
1590 			pResData->pFilterList = new ExportList();
1591 			pList = pResData->pFilterList;
1592 			nListIndex = 0;
1593 		}
1594 	}
1595 	else if ( nList == LIST_ITEM ) {
1596 		pList = pResData->pItemList;
1597 		if ( !pList ) {
1598 			pResData->pItemList = new ExportList();
1599 			pList = pResData->pItemList;
1600 			nListIndex = 0;
1601 		}
1602 	}
1603 	else if ( nList == LIST_PAIRED ) {
1604 		pList = pResData->pPairedList;
1605 		if ( !pList ) {
1606 			pResData->pPairedList = new ExportList();
1607 			pList = pResData->pPairedList;
1608 			nListIndex = 0;
1609 		}
1610 	}
1611 	else if ( nList == LIST_UIENTRIES ) {
1612 		pList = pResData->pUIEntries;
1613 		if ( !pList ) {
1614 			pResData->pUIEntries = new ExportList();
1615 			pList = pResData->pUIEntries;
1616 			nListIndex = 0;
1617 		}
1618 	}
1619 	else
1620 		return;
1621 
1622 	if ( nListIndex + 1 > pList->Count()) {
1623 		ExportListEntry *pNew = new ExportListEntry();
1624 		(*pNew)[ LIST_REFID ] = ByteString::CreateFromInt32( REFID_NONE );
1625 		pList->Insert( pNew, LIST_APPEND );
1626 	}
1627 	ExportListEntry *pCurEntry = pList->GetObject( nListIndex );
1628 
1629 	// For paired list use the line to set proper lid
1630 	if( nList == LIST_PAIRED ){
1631 		(*pCurEntry)[ nListLang ] = rLine;
1632 	}else
1633 		(*pCurEntry)[ nListLang ] = rText;
1634 
1635 	// Remember en-US fallback string, so each list has the same amount of elements
1636 	//if ( nListLang.EqualsIgnoreCaseAscii("en-US") ) {
1637 	if ( Export::isSourceLanguage( nListLang ) ) {
1638 		if( nList == LIST_PAIRED ){
1639 			const ByteString sPlist("pairedlist");
1640 			ByteString sKey = MergeDataFile::CreateKey( sPlist , pResData->sId , GetPairedListID( rLine ) , sFilename );
1641 			pResData->addFallbackData( sKey , rText );
1642 		}
1643 		// new fallback
1644 		else{
1645 			const ByteString sPlist("list");
1646 			ByteString a( pResData->sGId );
1647 			a.Append( "." );
1648 			a.Append( pResData->sId );
1649 			sal_Int64 x = nListIndex+1;
1650 			ByteString b( ByteString::CreateFromInt64( x ) );
1651 			ByteString sKey = MergeDataFile::CreateKey( sPlist , a , b , sFilename );
1652 			pResData->addFallbackData( sKey , rText );
1653 		}
1654 		// new fallback
1655 	}
1656 
1657 	//if ( nListLang.EqualsIgnoreCaseAscii("en-US") ) {
1658 	if ( Export::isSourceLanguage( nListLang ) ) {
1659 		if( nList == LIST_PAIRED ){
1660 			(*pCurEntry)[ SOURCE_LANGUAGE ] = rLine;
1661 		}
1662 		else
1663 			(*pCurEntry)[ SOURCE_LANGUAGE ] = rLine;
1664 
1665 		pList->NewSourceLanguageListEntry();
1666 	}
1667 
1668 	//printf("Export::InsertListEntry ResData.id = %s ResData.ListData = %s\n",pResData->sId.GetBuffer() ,(*pCurEntry)[ nListLang ].GetBuffer());
1669 	nListIndex++;
1670 }
1671 
1672 /*****************************************************************************/
CleanValue(ByteString & rValue)1673 void Export::CleanValue( ByteString &rValue )
1674 /*****************************************************************************/
1675 {
1676 	while ( rValue.Len()) {
1677 		if (( rValue.GetChar( 0 ) == ' ' ) || ( rValue.GetChar( 0 ) == '\t' ))
1678 			rValue = rValue.Copy( 1 );
1679 		else
1680 			break;
1681 	}
1682 
1683 	if ( rValue.Len()) {
1684 		for ( sal_uInt16 i = rValue.Len() - 1; i > 0; i-- ) {
1685 			if (( rValue.GetChar( i ) == ' ' ) || ( rValue.GetChar( i ) == '\t' ) ||
1686 				( rValue.GetChar( i ) == '\n' ) || ( rValue.GetChar( i ) == ';' ) ||
1687 				( rValue.GetChar( i ) == '{' ) || ( rValue.GetChar( i ) == '\\' ) ||
1688 				( rValue.GetChar( i ) == '\r' ))
1689 				rValue.Erase( i );
1690 			else
1691 				break;
1692 		}
1693 	}
1694 }
1695 
1696 
1697 /*****************************************************************************/
GetText(const ByteString & rSource,int nToken)1698 ByteString Export::GetText( const ByteString &rSource, int nToken )
1699 /*****************************************************************************/
1700 #define TXT_STATE_NON  	0x000
1701 #define TXT_STATE_TEXT	0x001
1702 #define TXT_STATE_MACRO	0x002
1703 {
1704 	ByteString sReturn;
1705 	switch ( nToken ) {
1706 		case TEXTLINE:
1707 		case LONGTEXTLINE: {
1708 			ByteString sTmp( rSource.Copy( rSource.Search( "=" )));
1709 			CleanValue( sTmp );
1710 			sTmp.EraseAllChars( '\n' );
1711 			sTmp.EraseAllChars( '\r' );
1712 
1713 			while ( sTmp.SearchAndReplace( "\\\\\"", "-=<[BSlashBSlashHKom]>=-\"" )
1714 				!= STRING_NOTFOUND ) {};
1715 			while ( sTmp.SearchAndReplace( "\\\"", "-=<[Hochkomma]>=-" )
1716 				!= STRING_NOTFOUND ) {};
1717 			while ( sTmp.SearchAndReplace( "\\", "-=<[0x7F]>=-" )
1718 				!= STRING_NOTFOUND ) {};
1719 			while ( sTmp.SearchAndReplace( "\\0x7F", "-=<[0x7F]>=-" )
1720 				!= STRING_NOTFOUND ) {};
1721 
1722 			sal_uInt16 nStart = 0;
1723 			sal_uInt16 nState = TXT_STATE_MACRO;
1724 
1725 		    nState = TXT_STATE_TEXT;
1726 			nStart = 1;
1727 
1728 
1729 			for ( sal_uInt16 i = nStart; i < sTmp.GetTokenCount( '\"' ); i++ ) {
1730 				ByteString sToken = sTmp.GetToken( i, '\"' );
1731 				if ( sToken.Len()) {
1732 					if ( nState == TXT_STATE_TEXT ) {
1733 						sReturn += sToken;
1734 						nState = TXT_STATE_MACRO;
1735 					}
1736 					else {
1737 						while( sToken.SearchAndReplace( "\t", " " ) !=
1738 							STRING_NOTFOUND ) {};
1739 						while( sToken.SearchAndReplace( "  ", " " ) !=
1740 							STRING_NOTFOUND ) {};
1741 						sToken.EraseLeadingChars( ' ' );
1742 						sToken.EraseTrailingChars( ' ' );
1743 						if ( sToken.Len()) {
1744 							sReturn += "\\\" ";
1745 							sReturn += sToken;
1746 							sReturn += " \\\"";
1747 						}
1748 						nState = TXT_STATE_TEXT;
1749 					}
1750 				}
1751 			}
1752 
1753 			while ( sReturn.SearchAndReplace( "-=<[0x7F]>=-", "" )
1754 				!= STRING_NOTFOUND ) {};
1755 			while ( sReturn.SearchAndReplace( "-=<[Hochkomma]>=-", "\"" )
1756 				!= STRING_NOTFOUND ) {};
1757 			while ( sReturn.SearchAndReplace( "-=<[BSlashBSlashHKom]>=-", "\\\\" )
1758 				!= STRING_NOTFOUND ) {};
1759 
1760 
1761 			while ( sReturn.SearchAndReplace( "\\\\", "-=<[BSlashBSlash]>=-" )
1762 				!= STRING_NOTFOUND ) {};
1763 			while ( sReturn.SearchAndReplace( "-=<[BSlashBSlash]>=-", "\\" )
1764 				!= STRING_NOTFOUND ) {};
1765 
1766 		}
1767 		break;
1768 	}
1769 	return sReturn;
1770 }
1771 
1772 /*****************************************************************************/
WriteToMerged(const ByteString & rText,bool bSDFContent)1773 void Export::WriteToMerged( const ByteString &rText , bool bSDFContent )
1774 /*****************************************************************************/
1775 {
1776 	static ByteString SLASH  ('\\');
1777     static ByteString RETURN ('\n');
1778 	//printf("%s\n",rText.GetBuffer() );
1779 
1780     #if 0
1781     // statement has no effect
1782     if( pParseQueue->bMflag && !bSDFContent ) pParseQueue->bMflag;
1783     #endif
1784 
1785     if ( !bDontWriteOutput || !bUnmerge ) {
1786 		ByteString sText( rText );
1787 		while ( sText.SearchAndReplace( " \n", "\n" ) != STRING_NOTFOUND ) {};
1788         if( pParseQueue->bNextIsM && bSDFContent && sText.Len() > 2 ){
1789             for( sal_uInt16 n = 0 ; n < sText.Len() ; n++ ){
1790                 if( sText.GetChar( n ) == '\n' && sText.GetChar( n-1 ) != '\\'){
1791                     sText.Insert('\\' , n++ );
1792 
1793                 }
1794             }
1795         }
1796         else if( pParseQueue->bLastWasM && sText.Len() > 2 ){
1797             for( sal_uInt16 n = 0 ; n < sText.Len() ; n++ ){
1798                 if( sText.GetChar( n ) == '\n' && sText.GetChar( n-1 ) != '\\'){
1799                     sText.Insert('\\' , n++ );
1800                 }
1801                 if( sText.GetChar( n ) == '\n' )pParseQueue->bMflag=true;
1802             }
1803         }
1804         else if( pParseQueue->bCurrentIsM && bSDFContent && sText.Len() > 2 ){
1805             for( sal_uInt16 n = 0 ; n < sText.Len() ; n++ ){
1806                 if( sText.GetChar( n ) == '\n' && sText.GetChar( n-1 ) != '\\'){
1807                     sText.Insert('\\' , n++ );
1808                     pParseQueue->bMflag=true;
1809                 }
1810             }
1811         }
1812         else if( pParseQueue->bMflag ){
1813             for( sal_uInt16 n = 1 ; n < sText.Len() ; n++ ){
1814                 if( sText.GetChar( n ) == '\n' && sText.GetChar( n-1 ) != '\\'){
1815                     sText.Insert('\\' , n++ );
1816                 }
1817             }
1818         }
1819         for ( sal_uInt16 i = 0; i < sText.Len(); i++ ) {
1820 			if ( sText.GetChar( i ) != '\n' ){
1821 				aOutput.Write( ByteString( sText.GetChar( i )).GetBuffer(), 1 );
1822 
1823 			}
1824             else{
1825                 aOutput.WriteLine( ByteString());
1826             }
1827 
1828 		}
1829 	}
1830 }
1831 
1832 /*****************************************************************************/
ConvertMergeContent(ByteString & rText)1833 void Export::ConvertMergeContent( ByteString &rText )
1834 /*****************************************************************************/
1835 {
1836 	sal_Bool bNoOpen = ( rText.Search( "\\\"" ) != 0 );
1837 	ByteString sClose( rText.Copy( rText.Len() - 2 ));
1838 	sal_Bool bNoClose = ( sClose != "\\\"" );
1839 	ByteString sNew;
1840 	for ( sal_uInt16 i = 0; i < rText.Len(); i++ ) {
1841 		ByteString sChar( rText.GetChar( i ));
1842 		if ( sChar == "\\" ) {
1843 			if (( i + 1 ) < rText.Len()) {
1844 				ByteString sNext( rText.GetChar( i + 1 ));
1845 				if ( sNext == "\"" ) {
1846 					sChar = "\"";
1847 					i++;
1848 				}
1849 				else if ( sNext == "n" ) {
1850 					sChar = "\\n";
1851 					i++;
1852 				}
1853 				else if ( sNext == "t" ) {
1854 					sChar = "\\t";
1855 					i++;
1856 				}
1857 				else if ( sNext == "\'" ) {
1858 					sChar = "\\\'";
1859 					i++;
1860 				}
1861 				else
1862 					sChar = "\\\\";
1863 			}
1864 			else {
1865 				sChar = "\\\\";
1866 			}
1867 		}
1868 		else if ( sChar == "\"" ) {
1869 			sChar = "\\\"";
1870 		}
1871 		else if ( sChar == "" ) {
1872 			sChar = "\\0x7F";
1873 		}
1874 		sNew += sChar;
1875 	}
1876 
1877 	rText = sNew;
1878 
1879 	if ( bNoOpen ) {
1880 		ByteString sTmp( rText );
1881 		rText = "\"";
1882 		rText += sTmp;
1883 	}
1884 	if ( bNoClose )
1885 		rText += "\"";
1886 }
1887 
1888 /*****************************************************************************/
PrepareTextToMerge(ByteString & rText,sal_uInt16 nTyp,ByteString & nLangIndex,ResData * pResData)1889 sal_Bool Export::PrepareTextToMerge( ByteString &rText, sal_uInt16 nTyp,
1890                                 ByteString &nLangIndex, ResData *pResData )
1891 /*****************************************************************************/
1892 {
1893 	// position to merge in:
1894 	sal_uInt16 nStart = 0;
1895 	sal_uInt16 nEnd = 0;
1896 	ByteString sOldId = pResData->sId;
1897 	ByteString sOldGId = pResData->sGId;
1898 	ByteString sOldTyp = pResData->sResTyp;
1899 
1900 	ByteString sOrigText( rText );
1901 
1902 	switch ( nTyp ) {
1903 		case LIST_STRING :
1904 		case LIST_UIENTRIES :
1905 		case LIST_FILTER :
1906 		case LIST_PAIRED:
1907 		case LIST_ITEM :
1908 		{
1909 			if ( bUnmerge )
1910 				return sal_True;
1911 
1912 			ExportList *pList = NULL;
1913 			switch ( nTyp ) {
1914 				case LIST_STRING : {
1915 					pResData->sResTyp = "stringlist";
1916 					pList = pResData->pStringList;
1917 				}
1918 				break;
1919 				case LIST_UIENTRIES : {
1920 					pResData->sResTyp = "uientries";
1921 					pList = pResData->pUIEntries;
1922 				}
1923 				break;
1924 				case LIST_FILTER : {
1925 					pResData->sResTyp = "filterlist";
1926 					pList = pResData->pFilterList;
1927 				}
1928 				break;
1929 				case LIST_ITEM : {
1930 					pResData->sResTyp = "itemlist";
1931 					pList = pResData->pItemList;
1932 				}
1933 				break;
1934 				case LIST_PAIRED : {
1935 					pResData->sResTyp = "pairedlist";
1936 					pList = pResData->pPairedList;
1937 				}
1938 				break;
1939 
1940 			}
1941 			if ( pList ) {
1942 				ExportListEntry *pCurEntry = pList->GetObject( nListIndex - 1 );
1943 				if ( pCurEntry ) {
1944 					//printf("%s\n",Export::DumpMap( "pCurEntry", *pCurEntry ).GetBuffer() );
1945 					//ByteString a("pCurEntry");
1946 					//Export::DumpMap( a , *pCurEntry );
1947 					rText = (*pCurEntry)[ SOURCE_LANGUAGE ];
1948 					if( nTyp == LIST_PAIRED ){
1949 						pResData->addMergedLanguage( nLangIndex );
1950 					}
1951                 }
1952 			}
1953 
1954 			nStart = rText.Search( "\"" );
1955 			if ( nStart == STRING_NOTFOUND ) {
1956 				rText = sOrigText;
1957 				return sal_False;
1958 			}
1959 
1960 			sal_Bool bFound = sal_False;
1961 			for ( nEnd = nStart + 1; nEnd < rText.Len() && !bFound; nEnd++ ) {
1962 				if ( rText.GetChar( nEnd ) == '\"' )
1963 					bFound = sal_True;
1964 			}
1965 			if ( !bFound ) {
1966 				rText = sOrigText;
1967 				return sal_False;
1968 			}
1969 
1970 			nEnd --;
1971 			sLastListLine = rText;
1972 			if (( sLastListLine.Search( ">" ) != STRING_NOTFOUND ) &&
1973 				( sLastListLine.Search( "<" ) == STRING_NOTFOUND ))
1974 			{
1975 				ByteString sTmp = sLastListLine;
1976 				sLastListLine = "<";
1977 				sLastListLine += sTmp;
1978 			}
1979 			if ( pResData->sResTyp.EqualsIgnoreCaseAscii( "pairedlist" ) ){
1980                pResData->sId = GetPairedListID( sLastListLine );
1981             }
1982             else pResData->sId = ByteString::CreateFromInt32( nListIndex );
1983 
1984 			if ( pResData->sGId.Len())
1985 				pResData->sGId += ".";
1986 			pResData->sGId += sOldId;
1987 			nTyp = STRING_TYP_TEXT;
1988 		}
1989 		break;
1990 		case STRING_TYP_TEXT :
1991 		case STRING_TYP_HELPTEXT :
1992 		case STRING_TYP_QUICKHELPTEXT :
1993 		case STRING_TYP_TITLE :
1994 		{
1995 			/*if ( bUnmerge ) {
1996 				if (( nLangIndex != ByteString("de") ) &&
1997                     ( nLangIndex != ByteString("en-US") ))
1998 				{
1999 					bDontWriteOutput = sal_True;
2000 				}
2001 				return sal_True;
2002 			}*/
2003 
2004 			nStart = rText.Search( "=" );
2005 			if ( nStart == STRING_NOTFOUND ) {
2006 				rText = sOrigText;
2007 				return sal_False;
2008 			}
2009 
2010 			nStart++;
2011 			sal_Bool bFound = sal_False;
2012 			while(( nStart < rText.Len()) && !bFound ) {
2013 				if (( rText.GetChar( nStart ) != ' ' ) && ( rText.GetChar( nStart ) != '\t' ))
2014 					bFound = sal_True;
2015 				else
2016 					nStart ++;
2017 			}
2018 
2019 			// no start position found
2020 			if ( !bFound ) {
2021 				rText = sOrigText;
2022 				return sal_False;
2023 			}
2024 
2025 			// position to end merging in
2026 			nEnd = rText.Len() - 1;
2027 			bFound = sal_False;
2028 
2029 			while (( nEnd > nStart ) && !bFound ) {
2030 				if (( rText.GetChar( nEnd ) != ' ' ) && ( rText.GetChar( nEnd ) != '\t' ) &&
2031 					( rText.GetChar( nEnd ) != '\n' ) && ( rText.GetChar( nEnd ) != ';' ) &&
2032 					( rText.GetChar( nEnd ) != '{' ) && ( rText.GetChar( nEnd ) != '\\' ))
2033 				{
2034 					bFound = sal_True;
2035 				}
2036 				else
2037 					nEnd --;
2038 			}
2039 		}
2040 		break;
2041 	}
2042 
2043 	// search for merge data
2044     if ( !pMergeDataFile ){
2045         pMergeDataFile = new MergeDataFile( sMergeSrc, sFile , bErrorLog, aCharSet);//, bUTF8 );
2046 
2047         // Init Languages
2048         ByteString sTmp = Export::sLanguages;
2049         if( sTmp.ToUpperAscii().Equals("ALL") )
2050             SetLanguages( pMergeDataFile->GetLanguages() );
2051         else if( !isInitialized )InitLanguages();
2052 
2053     }
2054 //	printf("*************DUMPING****************\n");
2055 //	printf("%s\n",pMergeDataFile->Dump().GetBuffer());
2056 //	printf("*************DUMPING****************\n");
2057 
2058 //	printf("Dumping ResData\n");
2059 //	pResData->Dump();
2060 	PFormEntrys *pEntrys = pMergeDataFile->GetPFormEntrys( pResData );
2061 	//printf("Dumping pEntrys\n");
2062 	//if( pEntrys ) pEntrys->Dump();
2063 	pResData->sId = sOldId;
2064 	pResData->sGId = sOldGId;
2065 	pResData->sResTyp = sOldTyp;
2066 
2067 	if ( !pEntrys ) {
2068 		rText = sOrigText;
2069 		return sal_False; // no data found
2070 	}
2071 
2072 	ByteString sContent;
2073 	pEntrys->GetTransex3Text( sContent, nTyp, nLangIndex );
2074 	//if ( !sContent.Len() && ( ! nLangIndex.EqualsIgnoreCaseAscii("en-US") )) {
2075 	if ( !sContent.Len() && ( ! Export::isSourceLanguage( nLangIndex ) )) {
2076 		rText = sOrigText;
2077 		return sal_False; // no data found
2078 	}
2079 
2080 	//if ( nLangIndex.EqualsIgnoreCaseAscii("en-US") ) {
2081 	if ( Export::isSourceLanguage( nLangIndex ) ) {
2082 		return sal_False;
2083 	}
2084 
2085 	ByteString sPostFix( rText.Copy( ++nEnd ));
2086 	rText.Erase( nStart );
2087 
2088 	//ConvertMergeContent( sContent, nTyp );
2089 	ConvertMergeContent( sContent );
2090 
2091 
2092 
2093 	//printf("Merged %s\n",nLangIndex.GetBuffer());
2094 	// merge new res. in text line
2095 	rText += sContent;
2096 	rText += sPostFix;
2097 
2098 	return sal_True;
2099 }
2100 
2101 /*****************************************************************************/
MergeRest(ResData * pResData,sal_uInt16 nMode)2102 void Export::MergeRest( ResData *pResData, sal_uInt16 nMode )
2103 /*****************************************************************************/
2104 {
2105 	//if ( bUnmerge ) { return;}
2106 
2107 	//pResData->Dump();
2108 
2109 	if ( !pMergeDataFile ){
2110 		pMergeDataFile = new MergeDataFile( sMergeSrc, sFile ,bErrorLog, aCharSet);//, bUTF8 );
2111 
2112         // Init Languages
2113         ByteString sTmp = Export::sLanguages;
2114         if( sTmp.ToUpperAscii().Equals("ALL") )
2115             SetLanguages( pMergeDataFile->GetLanguages() );
2116         else if( !isInitialized )InitLanguages();
2117 
2118 	}
2119 	switch ( nMode ) {
2120 		case MERGE_MODE_NORMAL : {
2121 			PFormEntrys *pEntry = pMergeDataFile->GetPFormEntrys( pResData );
2122 
2123             bool bWriteNoSlash = false;
2124 			if ( pEntry && pResData->bText ) {
2125 
2126 				sal_Bool bAddSemikolon = sal_False;
2127 				sal_Bool bFirst = sal_True;
2128                 ByteString sCur;
2129                 ByteString sTmp = Export::sLanguages;
2130 
2131                 for( unsigned int n = 0; n < aLanguages.size(); n++ ){
2132                     sCur = aLanguages[ n ];
2133 
2134                     ByteString sText;
2135                     sal_Bool bText = pEntry->GetTransex3Text( sText, STRING_TYP_TEXT, sCur , sal_True );
2136 					if ( bText && sText.Len() && sText != "-" ) {
2137 						ByteString sOutput;
2138 						if ( bNextMustBeDefineEOL) {
2139 							if ( bFirst )
2140 								sOutput += "\t\\\n";
2141 							else
2142 								sOutput += ";\t\\\n";
2143 						}
2144 						bFirst=sal_False;
2145 						sOutput += "\t";
2146 						sOutput += pResData->sTextTyp;
2147                         //if ( !sCur.EqualsIgnoreCaseAscii("en-US")) {
2148 						if ( ! Export::isSourceLanguage( sCur ) ) {
2149 							sOutput += "[ ";
2150 							sOutput += sCur;
2151 							sOutput += " ] ";
2152 						}
2153 						sOutput += "= ";
2154                         ConvertMergeContent( sText );
2155 						sOutput += sText;
2156 
2157                         if ( bDefine && bWriteNoSlash )
2158 						    sOutput += ";\n";
2159 
2160                         if ( bDefine )
2161 							sOutput += ";\\\n";
2162 						else if ( !bNextMustBeDefineEOL )
2163 							sOutput += ";\n";
2164 						else
2165 							bAddSemikolon = sal_True;
2166 						for ( sal_uInt16 j = 1; j < nLevel; j++ )
2167 							sOutput += "\t";
2168 						WriteToMerged( sOutput , true );
2169 					}
2170                 }
2171 
2172 
2173 				if ( bAddSemikolon ) {
2174 					ByteString sOutput( ";" );
2175 					WriteToMerged( sOutput , false );
2176 				}
2177 			}
2178 
2179 			if ( pEntry && pResData->bQuickHelpText ) {
2180 				sal_Bool bAddSemikolon = sal_False;
2181 				sal_Bool bFirst = sal_True;
2182                 ByteString sCur;
2183 
2184                 for( unsigned int n = 0; n < aLanguages.size(); n++ ){
2185                     sCur = aLanguages[ n ];
2186 
2187 					ByteString sText;
2188                     sal_Bool bText = pEntry->GetTransex3Text( sText, STRING_TYP_QUICKHELPTEXT, sCur, sal_True );
2189 					if ( bText && sText.Len() && sText != "-" ) {
2190 						ByteString sOutput;
2191 						if ( bNextMustBeDefineEOL) {
2192 							if ( bFirst )
2193 								sOutput += "\t\\\n";
2194 							else
2195 								sOutput += ";\t\\\n";
2196 						}
2197 						bFirst=sal_False;
2198 						sOutput += "\t";
2199 						sOutput += "QuickHelpText";
2200                         //if ( !sCur.EqualsIgnoreCaseAscii("en-US") ) {
2201 						if ( ! Export::isSourceLanguage( sCur ) ) {
2202 							sOutput += "[ ";
2203 							sOutput += sCur;
2204 							sOutput += " ] ";
2205 						}
2206 						sOutput += "= ";
2207                         ConvertMergeContent( sText );
2208 						sOutput += sText;
2209 						if ( bDefine )
2210 							sOutput += ";\\\n";
2211 						else if ( !bNextMustBeDefineEOL )
2212 							sOutput += ";\n";
2213 						else
2214 							bAddSemikolon = sal_True;
2215 						for ( sal_uInt16 j = 1; j < nLevel; j++ )
2216 							sOutput += "\t";
2217 						WriteToMerged( sOutput ,true );
2218 					}
2219 				}
2220 				if ( bAddSemikolon ) {
2221 					ByteString sOutput( ";" );
2222 					WriteToMerged( sOutput , false );
2223 				}
2224 			}
2225 
2226 			if ( pEntry && pResData->bTitle ) {
2227 				sal_Bool bAddSemikolon = sal_False;
2228 				sal_Bool bFirst = sal_True;
2229                 ByteString sCur;
2230 
2231                 for( unsigned int n = 0; n < aLanguages.size(); n++ ){
2232                     sCur = aLanguages[ n ];
2233 
2234                 ByteString sText;
2235                     sal_Bool bText = pEntry->GetTransex3Text( sText, STRING_TYP_TITLE, sCur, sal_True );
2236 					if ( bText && sText.Len() && sText != "-" ) {
2237 						ByteString sOutput;
2238 						if ( bNextMustBeDefineEOL) {
2239 							if ( bFirst )
2240 								sOutput += "\t\\\n";
2241 							else
2242 								sOutput += ";\t\\\n";
2243 						}
2244 						bFirst=sal_False;
2245 						sOutput += "\t";
2246 						sOutput += "Title";
2247                         //if ( !sCur.EqualsIgnoreCaseAscii("en-US") ) {
2248 						if ( ! Export::isSourceLanguage( sCur ) ) {
2249 							sOutput += "[ ";
2250 							sOutput += sCur;
2251 							sOutput += " ] ";
2252 						}
2253 						sOutput += "= ";
2254                         ConvertMergeContent( sText );
2255 						sOutput += sText;
2256 						if ( bDefine )
2257 							sOutput += ";\\\n";
2258 						else if ( !bNextMustBeDefineEOL )
2259 							sOutput += ";\n";
2260 						else
2261 							bAddSemikolon = sal_True;
2262 						for ( sal_uInt16 j = 1; j < nLevel; j++ )
2263 							sOutput += "\t";
2264 						WriteToMerged( sOutput ,true );
2265 					}
2266 				}
2267 				if ( bAddSemikolon ) {
2268 					ByteString sOutput( ";" );
2269 					WriteToMerged( sOutput ,false);
2270 				}
2271 			}
2272 			// Merge Lists
2273 
2274 			if ( pResData->bList ) {
2275 				//printf("Dumping ResData\n");
2276 				//pResData->Dump();
2277 
2278 				bool bPairedList = false;
2279 				ByteString sOldId = pResData->sId;
2280 				ByteString sOldGId = pResData->sGId;
2281 				ByteString sOldTyp = pResData->sResTyp;
2282 				if ( pResData->sGId.Len())
2283 					pResData->sGId += ".";
2284 				pResData->sGId += sOldId;
2285 				ByteString sSpace;
2286 				for ( sal_uInt16 i = 1; i < nLevel-1; i++ )
2287 					sSpace += "\t";
2288 				for ( sal_uInt16 nT = LIST_STRING; nT <= LIST_UIENTRIES; nT++ ) {
2289 					ExportList *pList = NULL;
2290 					switch ( nT ) {
2291                         case LIST_STRING : pResData->sResTyp = "stringlist"; pList = pResData->pStringList; bPairedList = false; break;
2292 						case LIST_FILTER : pResData->sResTyp = "filterlist"; pList = pResData->pFilterList; bPairedList = false; break;
2293 						case LIST_UIENTRIES : pResData->sResTyp = "uientries"; pList = pResData->pUIEntries;bPairedList = false; break;
2294 						case LIST_ITEM : pResData->sResTyp = "itemlist"; pList = pResData->pItemList;       bPairedList = false; break;
2295                         case LIST_PAIRED : pResData->sResTyp = "pairedlist"; pList = pResData->pPairedList; bPairedList = true;  break;
2296 					}
2297                     ByteString sCur;
2298                     for( unsigned int n = 0; n < aLanguages.size(); n++ ){
2299                         sCur = aLanguages[ n ];
2300 						sal_uInt16 nIdx = 1;
2301 
2302 						// Set matching pairedlist identifier
2303 						if( bPairedList && pResData->pPairedList && ( nIdx == 1 ) ){
2304 							ExportListEntry* pListE = ( ExportListEntry* ) pResData->pPairedList->GetObject( nIdx-1 );
2305 							pResData->sId = GetPairedListID ( (*pListE)[ SOURCE_LANGUAGE ] );
2306 						}
2307 						else
2308 							pResData->sId = ByteString("1");
2309 
2310 						PFormEntrys *pEntrys;
2311 						sal_uLong nLIndex = 0;
2312 						sal_uLong nMaxIndex = 0;
2313 						if ( pList )
2314 							nMaxIndex = pList->GetSourceLanguageListEntryCount();
2315 						pEntrys = pMergeDataFile->GetPFormEntrys( pResData );
2316                         while( pEntrys && ( nLIndex < nMaxIndex )) {
2317 						    //printf("Lang %s, List Index %d\n",sCur.GetBuffer(),(int)nLIndex);
2318 							ByteString sText;
2319                             sal_Bool bText;
2320 							bText = pEntrys->GetTransex3Text( sText, STRING_TYP_TEXT, sCur, sal_True );
2321 							if( !bText )
2322 								bText = pEntrys->GetTransex3Text( sText , STRING_TYP_TEXT, SOURCE_LANGUAGE , sal_False );
2323 
2324 							// Use fallback, if data is missing in sdf file
2325 							//if( !bText && pResData->sResTyp.Equals( "pairedlist" ) ){
2326 							if( !bText && bPairedList ){
2327 								if( pResData->isMerged( sCur ) ) break;
2328 								const ByteString sPlist("pairedlist");
2329 								ByteString sKey = MergeDataFile::CreateKey( sPlist , pResData->sGId , pResData->sId , sFilename );
2330 								bText = pResData->getFallbackData( sKey , sText );
2331 							}else if ( !bText ){// new fallback
2332 								if( pResData->isMerged( sCur ) ) break;
2333 								const ByteString sPlist("list");
2334 								ByteString sKey = MergeDataFile::CreateKey( sPlist , pResData->sGId , pResData->sId , sFilename );
2335 								bText = pResData->getFallbackData( sKey , sText );
2336 							} // new fallback
2337 
2338 							if ( bText && sText.Len()) {
2339 								//if( pEntrys ) pEntrys->Dump();
2340 								if ( nIdx == 1 ) {
2341 									ByteString sHead;
2342 									if ( bNextMustBeDefineEOL )
2343 										sHead = "\\\n\t";
2344 									sHead += sSpace;
2345 									switch ( nT ) {
2346 										case LIST_STRING : sHead += "StringList "; break;
2347 										case LIST_FILTER : sHead += "FilterList "; break;
2348 										case LIST_ITEM : sHead += "ItemList "; break;
2349 										case LIST_PAIRED : sHead += "PairedList "; break;
2350 										case LIST_UIENTRIES : sHead += "UIEntries "; break;
2351 									}
2352   									sHead += "[ ";
2353                                     sHead += sCur;
2354 									sHead += " ] ";
2355 									//}
2356 									if ( bDefine || bNextMustBeDefineEOL ) {
2357 										sHead += "= \\\n";
2358 										sHead += sSpace;
2359 										sHead += "\t{\\\n\t";
2360 									}
2361 									else {
2362 										sHead += "= \n";
2363 										sHead += sSpace;
2364 										sHead += "\t{\n\t";
2365 									}
2366 									WriteToMerged( sHead , true);
2367 								}
2368 								ByteString sLine;
2369 								if ( pList && pList->GetObject( nLIndex ))
2370 									sLine = ( *pList->GetObject( nLIndex ))[ SOURCE_LANGUAGE ];
2371 								if ( !sLine.Len())
2372 									sLine = sLastListLine;
2373 
2374 								if ( sLastListLine.Search( "<" ) != STRING_NOTFOUND ) {
2375 									if (( nT != LIST_UIENTRIES ) &&
2376 										(( sLine.Search( "{" ) == STRING_NOTFOUND ) ||
2377 										( sLine.Search( "{" ) >= sLine.Search( "\"" ))) &&
2378 										(( sLine.Search( "<" ) == STRING_NOTFOUND ) ||
2379 										( sLine.Search( "<" ) >= sLine.Search( "\"" ))))
2380 									{
2381 										sLine.SearchAndReplace( "\"", "< \"" );
2382 									}
2383 								}
2384 
2385 								sal_uInt16 nStart, nEnd;
2386 								nStart = sLine.Search( "\"" );
2387 
2388 								ByteString sPostFix;
2389 								if( !bPairedList ){
2390 									nEnd = sLine.SearchBackward( '\"' );
2391 									sPostFix = ByteString( sLine.Copy( ++nEnd ));
2392 									sLine.Erase( nStart );
2393 								}
2394 
2395 
2396                             	ConvertMergeContent( sText );
2397 
2398 								// merge new res. in text line
2399 								if( bPairedList ){
2400 									sLine = MergePairedList( sLine , sText );
2401 								}
2402 								else{
2403 									sLine += sText;
2404 									sLine += sPostFix;
2405 								}
2406 
2407 								ByteString sText1( "\t" );
2408 								sText1 += sLine;
2409 								if ( bDefine || bNextMustBeDefineEOL )
2410 									sText1 += " ;\\\n";
2411 								else
2412 									sText1 += " ;\n";
2413 								sText1 += sSpace;
2414 								sText1 += "\t";
2415 								//printf("Writing '%s'\n",sText1.GetBuffer());
2416 								WriteToMerged( sText1 ,true );
2417 
2418 								// Set matching pairedlist identifier
2419 								if ( bPairedList ){
2420 									nIdx++;
2421 									ExportListEntry* pListE = ( ExportListEntry* ) pResData->pPairedList->GetObject( ( nIdx ) -1 );
2422 									if( pListE ){
2423 										pResData->sId = GetPairedListID ( (*pListE)[ SOURCE_LANGUAGE ] );
2424 									}
2425                                 }
2426                                 else
2427                                     pResData->sId = ByteString::CreateFromInt32( ++nIdx );
2428                             }
2429 							else
2430 								break;
2431 							nLIndex ++;
2432 							PFormEntrys *oldEntry = pEntrys;
2433 							pEntrys = pMergeDataFile->GetPFormEntrys( pResData ); // <--- game over
2434 							if( !pEntrys )
2435 								pEntrys = oldEntry;
2436 						}
2437 						if ( nIdx > 1 ) {
2438 							ByteString sFooter( sSpace.Copy( 1 ));
2439 							if ( bNextMustBeDefineEOL )
2440 								sFooter += "};";
2441 							else if ( !bDefine )
2442 								sFooter += "};\n\t";
2443 							else
2444 								sFooter += "\n\n";
2445 							WriteToMerged( sFooter ,true );
2446 						}
2447 					}
2448 				}
2449 
2450 				pResData->sId = sOldId;
2451 				pResData->sGId = sOldGId;
2452 				pResData->sResTyp = sOldTyp;
2453 			}
2454 		}
2455 		break;
2456 		case MERGE_MODE_LIST : {
2457 			ExportList *pList = NULL;
2458 			switch ( nList ) {
2459 			    // PairedList
2460                 case LIST_STRING : pList = pResData->pStringList; break;
2461 				case LIST_FILTER : pList = pResData->pFilterList; break;
2462 				case LIST_UIENTRIES : pList = pResData->pUIEntries; break;
2463 				case LIST_ITEM : pList = pResData->pItemList; break;
2464 				case LIST_PAIRED : pList = pResData->pPairedList; break;
2465 
2466 			}
2467 
2468 			nListIndex++;
2469 			sal_uLong nMaxIndex = 0;
2470 			if ( pList )
2471 				nMaxIndex = pList->GetSourceLanguageListEntryCount();
2472 			ByteString sLine;
2473 			if ( pList && pList->GetObject( nListIndex ))
2474 				sLine = ( *pList->GetObject( nListIndex ))[ SOURCE_LANGUAGE ];
2475 			if ( !sLine.Len())
2476 				sLine = sLastListLine;
2477 
2478 			if ( sLastListLine.Search( "<" ) != STRING_NOTFOUND ) {
2479 				if (( nList != LIST_UIENTRIES ) &&
2480 					(( sLine.Search( "{" ) == STRING_NOTFOUND ) ||
2481 					( sLine.Search( "{" ) >= sLine.Search( "\"" ))) &&
2482 					(( sLine.Search( "<" ) == STRING_NOTFOUND ) ||
2483 					( sLine.Search( "<" ) >= sLine.Search( "\"" ))))
2484 				{
2485 					sLine.SearchAndReplace( "\"", "< \"" );
2486 				}
2487 			}
2488 
2489 			while( PrepareTextToMerge( sLine, nList, nListLang, pResData ) && ( nListIndex <= nMaxIndex )) {
2490 				ByteString sText( "\t" );
2491 				sText += sLine;
2492 				sText += " ;";
2493 				sText += "\n";
2494 				for ( sal_uInt16 i = 0; i < nLevel; i++ )
2495 					sText += "\t";
2496 				WriteToMerged( sText ,false );
2497 				nListIndex++;
2498 				if ( pList && pList->GetObject( nListIndex ))
2499 					sLine = ( *pList->GetObject( nListIndex ))[ SOURCE_LANGUAGE ];
2500 				if ( !sLine.Len())
2501 					sLine = sLastListLine;
2502 				sLine += " ;";
2503 			}
2504 		}
2505 		break;
2506 	}
2507     pParseQueue->bMflag = false;
2508 }
2509 
MergePairedList(ByteString & sLine,ByteString & sText)2510 ByteString Export::MergePairedList( ByteString& sLine , ByteString& sText ){
2511 // < "xy" ; IDENTIFIER ; >
2512 	ByteString sPre  = sLine.Copy( 0 , sLine.Search('\"') );
2513 	ByteString sPost = sLine.Copy( sLine.SearchBackward('\"') + 1 , sLine.Len() );
2514 	sPre.Append( sText );
2515 	sPre.Append( sPost );
2516 	return sPre;
2517 }
2518 
2519 /*****************************************************************************/
SetChildWithText()2520 void Export::SetChildWithText()
2521 /*****************************************************************************/
2522 {
2523 	if ( aResStack.Count() > 1 ) {
2524 		for ( sal_uLong i = 0; i < aResStack.Count() - 1; i++ ) {
2525 			aResStack.GetObject( i )->bChildWithText = sal_True;
2526 		}
2527 	}
2528 }
2529 
Push(const QueueEntry & aEntry)2530 void ParserQueue::Push( const QueueEntry& aEntry ){
2531 //    printf("nTyp = %d ",aEntry.nTyp);
2532     sal_uInt16 nLen = aEntry.sLine.Len();
2533 
2534     if( !bStart ){
2535         aQueueCur->push( aEntry );
2536         if( nLen > 1 && aEntry.sLine.GetChar( nLen-1 ) == '\n' )
2537             bStart = true;
2538         else if ( aEntry.nTyp != IGNOREDTOKENS ){
2539             if( nLen > 1 && ( aEntry.sLine.GetChar( nLen-1 ) == '\\') ){
2540                 // Next is Macro
2541                 bCurrentIsM = true;
2542              }else{
2543                 // Next is no Macro
2544                 bCurrentIsM = false;
2545              }
2546         }
2547     }
2548     else{
2549         aQueueNext->push( aEntry );
2550         if( nLen > 1 && aEntry.sLine.GetChar( nLen-1 ) != '\n' ){
2551             if( nLen > 1 && ( aEntry.sLine.GetChar( nLen-1 ) == '\\') ){
2552                 // Next is Macro
2553                 bNextIsM = true;
2554             }
2555             else{
2556                 // Next is no Macro
2557                 bNextIsM = false;
2558             }
2559         }else if( nLen > 2 && aEntry.sLine.GetChar( nLen-1 ) == '\n' ){
2560             if( aEntry.nTyp != IGNOREDTOKENS ){
2561                 if( nLen > 2 && ( aEntry.sLine.GetChar( nLen-2 ) == '\\') ){
2562                     // Next is Macro
2563                     bNextIsM = true;
2564                 }
2565                 else{
2566                     // Next is no Macro
2567                     bNextIsM = false;
2568                 }
2569             }
2570             // Pop current
2571             Pop( *aQueueCur );
2572             bLastWasM = bCurrentIsM;
2573             // next -> current
2574             bCurrentIsM = bNextIsM;
2575             aQref = aQueueCur;
2576             aQueueCur = aQueueNext;
2577             aQueueNext = aQref;
2578 
2579         }
2580 
2581         else{
2582             // Pop current
2583             Pop( *aQueueCur );
2584             bLastWasM = bCurrentIsM;
2585             // next -> current
2586             bCurrentIsM = bNextIsM;
2587             aQref = aQueueCur;
2588             aQueueCur = aQueueNext;
2589             aQueueNext = aQref;
2590         }
2591     }
2592 }
2593 
Close()2594 void ParserQueue::Close(){
2595     // Pop current
2596     Pop( *aQueueCur );
2597     // next -> current
2598     bLastWasM = bCurrentIsM;
2599     bCurrentIsM = bNextIsM;
2600     aQref = aQueueCur;
2601     aQueueCur = aQueueNext;
2602     aQueueNext = aQref;
2603     bNextIsM = false;
2604     Pop( *aQueueNext );
2605 };
Pop(std::queue<QueueEntry> & aQueue)2606 void ParserQueue::Pop( std::queue<QueueEntry>& aQueue ){
2607     while( !aQueue.empty() ){
2608         QueueEntry aEntry = aQueue.front();
2609         aQueue.pop();
2610         aExport.Execute( aEntry.nTyp , (char*) aEntry.sLine.GetBuffer() );
2611     }
2612 }
ParserQueue(Export & aExportObj)2613 ParserQueue::ParserQueue( Export& aExportObj )
2614         :
2615           bCurrentIsM( false ),
2616           bNextIsM( false ) ,
2617           bLastWasM( false ),
2618           bMflag( false ) ,
2619           aExport( aExportObj ) ,
2620           bStart( false ) ,
2621           bStartNext( false )
2622 {
2623           aQueueNext = new std::queue<QueueEntry>;
2624           aQueueCur  = new std::queue<QueueEntry>;
2625 }
2626 
2627 
~ParserQueue()2628 ParserQueue::~ParserQueue(){
2629     if( aQueueNext )    delete aQueueNext;
2630     if( aQueueCur )     delete aQueueCur;
2631 }
2632 
2633