xref: /aoo4110/main/l10ntools/source/export.cxx (revision b1cdbd2c)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_l10ntools.hxx"
#include <stdio.h>
#include <stdlib.h>
#include <tools/fsys.hxx>
#include "export.hxx"
#include "tokens.h"
#include "utf8conv.hxx"
#include <iostream>

extern "C" { int yyerror( char * ); }
extern "C" { int YYWarning( char * ); }

Export *pExport = 0L;

// defines to parse command line
#define STATE_NON  		0x0001
#define STATE_INPUT		0x0002
#define STATE_OUTPUT	0x0003
#define STATE_PRJ		0x0004
#define STATE_ROOT		0x0005
#define STATE_MERGESRC	0x0006
#define STATE_ERRORLOG	0x0007
#define STATE_BREAKHELP	0x0008
#define STATE_UNMERGE	0x0009
#define STATE_UTF8		0x000A
#define STATE_LANGUAGES	0X000B

// set of global variables
DECLARE_LIST( FileList, ByteString * )
FileList aInputFileList;
sal_Bool bEnableExport;
sal_Bool bMergeMode;
sal_Bool bErrorLog;
sal_Bool bBreakWhenHelpText;
sal_Bool bUnmerge;
sal_Bool bUTF8;
ByteString sPrj;
ByteString sPrjRoot;
ByteString sActFileName;
ByteString sOutputFile;
ByteString sMergeSrc;
ByteString sTempFile;
ByteString sFile;
MergeDataFile *pMergeDataFile;
FILE *pTempFile;


ByteString sStrBuffer;
bool bMarcro = false;

extern "C" {
// the whole interface to lexer is in this extern "C" section


/*****************************************************************************/
extern char *GetOutputFile( int argc, char* argv[])
/*****************************************************************************/
{
	bEnableExport = sal_False;
	bMergeMode = sal_False;
	bErrorLog = sal_True;
	bBreakWhenHelpText = sal_False;
	bUnmerge = sal_False;
	bUTF8 = sal_True;
	sPrj = "";
	sPrjRoot = "";
	sActFileName = "";
	Export::sLanguages = "";
    Export::sForcedLanguages = "";
	sTempFile = "";
	pTempFile = NULL;
	sal_uInt16 nState = STATE_NON;
	sal_Bool bInput = sal_False;

	// parse command line
	for( int i = 1; i < argc; i++ ) {
		ByteString sSwitch( argv[ i ] );

        if (sSwitch == "-i"  || sSwitch == "-I" ) {
			nState = STATE_INPUT; // next tokens specifies source files
		}
		else if (sSwitch == "-o"  || sSwitch == "-O" ) {
			nState = STATE_OUTPUT; // next token specifies the dest file
		}
		else if (sSwitch == "-p"  || sSwitch == "-P" ) {
			nState = STATE_PRJ; // next token specifies the cur. project
		}

		else if (sSwitch == "-r"  || sSwitch == "-R" ) {
			nState = STATE_ROOT; // next token specifies path to project root
		}
		else if (sSwitch == "-m"  || sSwitch == "-M" ) {
			nState = STATE_MERGESRC; // next token specifies the merge database
		}
		else if (sSwitch == "-e"  || sSwitch == "-E" ) {
			nState = STATE_ERRORLOG;
			bErrorLog = sal_False;
		}
		else if (sSwitch == "-b"  || sSwitch == "-B" ) {
			nState = STATE_BREAKHELP;
			bBreakWhenHelpText = sal_True;
		}
		else if (sSwitch == "-u"  || sSwitch == "-U" ) {
			nState = STATE_UNMERGE;
			bUnmerge = sal_True;
			bMergeMode = sal_True;
		}
		else if ( sSwitch.ToUpperAscii() == "-UTF8" ) {
			nState = STATE_UTF8;
			bUTF8 = sal_True;
		}
		else if ( sSwitch.ToUpperAscii() == "-NOUTF8" ) {
			nState = STATE_UTF8;
			bUTF8 = sal_False;
		}
		else if ( sSwitch == "-l"  || sSwitch == "-L" ) {
			nState = STATE_LANGUAGES;
		}
		else {
			switch ( nState ) {
				case STATE_NON: {
					return NULL;	// no valid command line
				}
				case STATE_INPUT: {
					aInputFileList.Insert( new ByteString( argv[ i ]), LIST_APPEND );
					bInput = sal_True; // min. one source file found
				}
				break;
				case STATE_OUTPUT: {
					sOutputFile = ByteString( argv[ i ]); // the dest. file
				}
				break;
				case STATE_PRJ: {
					sPrj = ByteString( argv[ i ]);
				}
				break;
				case STATE_ROOT: {
					sPrjRoot = ByteString( argv[ i ]); // path to project root
				}
				break;
				case STATE_MERGESRC: {
					sMergeSrc = ByteString( argv[ i ]);
					bMergeMode = sal_True; // activate merge mode, cause merge database found
				}
				break;
				case STATE_LANGUAGES: {
					Export::sLanguages = ByteString( argv[ i ]);
				}
				break;
			}
		}
	}
    if( bUnmerge ) sMergeSrc = ByteString();
	if ( bInput ) {
		// command line is valid
		bEnableExport = sal_True;
		char *pReturn = new char[ sOutputFile.Len() + 1 ];
		strcpy( pReturn, sOutputFile.GetBuffer());  // #100211# - checked
		return pReturn;
	}

	// command line is not valid
	return NULL;
}
/*****************************************************************************/
int InitExport( char *pOutput , char* pFilename )
/*****************************************************************************/
{
	// instanciate Export
	ByteString sOutput( pOutput );
    ByteString sFilename( pFilename );

	if ( bMergeMode && !bUnmerge ) {
		// merge mode enabled, so read database
		pExport = new Export(sOutput, bEnableExport, sPrj, sPrjRoot, sMergeSrc , sFilename );
	}
	else
		// no merge mode, only export
		pExport = new Export( sOutput, bEnableExport, sPrj, sPrjRoot , sFilename );
	return 1;
}

/*****************************************************************************/
int EndExport()
/*****************************************************************************/
{
	delete pExport;
	return 1;
}

extern const char* getFilename()
{
	return (*(aInputFileList.GetObject( 0 ))).GetBuffer();
}
/*****************************************************************************/
extern FILE *GetNextFile()
/*****************************************************************************/
{
	// look for next valid filename in input file list
	if ( sTempFile.Len()) {
		fclose( pTempFile );
		String sTemp( sTempFile, RTL_TEXTENCODING_ASCII_US );
		DirEntry aTemp( sTemp );
		aTemp.Kill();
	}

	while ( aInputFileList.Count()) {
		ByteString sFileName( *(aInputFileList.GetObject( 0 )));

		ByteString sOrigFile( sFileName );

		sFileName = Export::GetNativeFile( sFileName );
		delete aInputFileList.GetObject(( sal_uLong ) 0 );
		aInputFileList.Remove(( sal_uLong ) 0 );

		if ( sFileName == "" ) {
			fprintf( stderr, "ERROR: Could not precompile File %s\n",
				sOrigFile.GetBuffer());
			return GetNextFile();
		}

		sTempFile = sFileName;
        Export::RemoveUTF8ByteOrderMarkerFromFile( sFileName );

		// able to open file?
		FILE *pFile = fopen( sFileName.GetBuffer(), "r" );
		if ( !pFile )
			fprintf( stderr, "Error: Could not open File %s\n",
				sFileName.GetBuffer());
		else {
			pTempFile = pFile;

			// this is a valid file which can be opened, so
			// create path to project root
			DirEntry aEntry( String( sOrigFile, RTL_TEXTENCODING_ASCII_US ));
			aEntry.ToAbs();
			ByteString sFullEntry( aEntry.GetFull(), RTL_TEXTENCODING_ASCII_US );
			aEntry += DirEntry( String( "..", RTL_TEXTENCODING_ASCII_US ));
			aEntry += DirEntry( sPrjRoot );
			ByteString sPrjEntry( aEntry.GetFull(), RTL_TEXTENCODING_ASCII_US );

			// create file name, beginnig with project root
			// (e.g.: source\ui\src\menue.src)
			sActFileName = sFullEntry.Copy( sPrjEntry.Len() + 1 );


			sActFileName.SearchAndReplaceAll( "/", "\\" );
            sFile = sActFileName;

			if ( pExport ) {
				// create instance of class export
				pExport->Init();
			}
			// return the valid file handle
            return pFile;
		}
	}
	// this means the file could not be opened
	return NULL;
}

int Parse( int nTyp, const char *pTokenText ){
    pExport->Execute( nTyp , pTokenText );
    return 1;
}
void Close(){
    pExport->pParseQueue->Close();
}
/*****************************************************************************/
int WorkOnTokenSet( int nTyp, char *pTokenText )
/*****************************************************************************/
{

    pExport->pParseQueue->Push( QueueEntry( nTyp , ByteString( pTokenText ) ) );
    return 1;
}

} // extern

extern "C" {
/*****************************************************************************/
int SetError()
/*****************************************************************************/
{
	// set error at global instance of class Export
	pExport->SetError();
	return 1;
}
}

extern "C" {
/*****************************************************************************/
int GetError()
/*****************************************************************************/
{
	// get error at global instance of class Export
	if ( pExport->GetError())
		return 1;
	return sal_False;
}
}

//
// class ResData
//

void ResData::Dump(){
	printf("**************\nResData\n");
	printf("sPForm = %s , sResTyp = %s , sId = %s , sGId = %s , sHelpId = %s\n",sPForm.GetBuffer()
		,sResTyp.GetBuffer(),sId.GetBuffer(),sGId.GetBuffer(),sHelpId.GetBuffer());

	ByteString a("*pStringList");
	ByteString b("*pUIEntries");
	ByteString c("*pFilterList");
	ByteString d("*pItemList");
	ByteString e("*pPairedList");
	ByteString f("sText");

	Export::DumpMap( f , sText );

	if( pStringList )	Export::DumpExportList( a , *pStringList );
	if( pUIEntries )	Export::DumpExportList( b , *pUIEntries );
	if( pFilterList )	Export::DumpExportList( c , *pFilterList );
	if( pItemList )		Export::DumpExportList( d , *pItemList );
	if( pPairedList )	Export::DumpExportList( e , *pPairedList );
	printf("\n");
}

void ResData::addFallbackData( ByteString& sId_in , const ByteString& sText_in ){
	//printf(" ResData::addFallbackData ( sId = %s , sText = %s )\n", sId_in.GetBuffer() , sText_in.GetBuffer() );
    aFallbackData[ sId_in ] = sText_in;
}
bool ResData::getFallbackData( ByteString& sId_in , ByteString& sText_inout ){
	sText_inout = aFallbackData[ sId_in ];
	//printf("ResData::getFallbackData( sId = %s , return sText = %s \n" , sId_in.GetBuffer(), sText_inout.GetBuffer());
    return sText_inout.Len() > 0;
}

void ResData::addMergedLanguage( ByteString& sLang ){
	aMergedLanguages[ sLang ]=ByteString("1");
}
bool ResData::isMerged( ByteString& sLang ){
	return aMergedLanguages[ sLang ].Equals("1");
}

/*****************************************************************************/
sal_Bool ResData::SetId( const ByteString &rId, sal_uInt16 nLevel )
/*****************************************************************************/
{
	if ( nLevel > nIdLevel )
	{
		nIdLevel = nLevel;
		sId = rId;

		if ( bChild && bChildWithText ) {
			ByteString sError( "ResId after child definition" );
			yyerror( sError.GetBufferAccess());
			sError.ReleaseBufferAccess();
			SetError();
		}

		if ( sId.Len() > 255 ) {
			ByteString sWarning( "LocalId > 255 chars, truncating..." );
			YYWarning( sWarning.GetBufferAccess());
			sWarning.ReleaseBufferAccess();
			sId.Erase( 255 );
			sId.EraseTrailingChars( ' ' );
			sId.EraseTrailingChars( '\t' );
		}

		return sal_True;
	}

	return sal_False;
}

//
// class Export
//

/*****************************************************************************/
Export::Export( const ByteString &rOutput, sal_Bool bWrite,
				const ByteString &rPrj, const ByteString &rPrjRoot , const ByteString& rFile )
/*****************************************************************************/
				:
				pWordTransformer( NULL ),
				aCharSet( RTL_TEXTENCODING_MS_1252 ),
				bDefine( sal_False ),
				bNextMustBeDefineEOL( sal_False ),
                nLevel( 0 ),
				nList( LIST_NON ),
				nListIndex( 0 ),
				nListLevel( 0 ),
                bSkipFile( false ),
				sProject( sPrj ),
				sRoot( sPrjRoot ),
				bEnableExport( bWrite ),
				bMergeMode( bUnmerge ),
				bError( sal_False ),
				bReadOver( sal_False ),
				bDontWriteOutput( sal_False ),
				sFilename( rFile )
{
    pParseQueue = new ParserQueue( *this );
    (void) rPrj;
    (void) rPrjRoot;
    (void) rFile;

    if( !isInitialized ) InitLanguages();
    // used when export is enabled

	// open output stream
	if ( bEnableExport ) {
		aOutput.Open( String( rOutput, RTL_TEXTENCODING_ASCII_US ), STREAM_STD_WRITE | STREAM_TRUNC );
		if( !aOutput.IsOpen() ) {
            printf("ERROR : Can't open file %s\n",rOutput.GetBuffer());
            exit ( -1 );
        }
        aOutput.SetStreamCharSet( RTL_TEXTENCODING_UTF8 );

		aOutput.SetLineDelimiter( LINEEND_CRLF );
	}
}

/*****************************************************************************/
Export::Export( const ByteString &rOutput, sal_Bool bWrite,
				const ByteString &rPrj, const ByteString &rPrjRoot,
				const ByteString &rMergeSource , const ByteString& rFile )
/*****************************************************************************/
				:
				pWordTransformer( NULL ),
				aCharSet( RTL_TEXTENCODING_MS_1252 ),
				bDefine( sal_False ),
				bNextMustBeDefineEOL( sal_False ),
                nLevel( 0 ),
				nList( LIST_NON ),
				nListIndex( 0 ),
				nListLevel( 0 ),
                bSkipFile( false ),
				sProject( sPrj ),
				sRoot( sPrjRoot ),
				bEnableExport( bWrite ),
				bMergeMode( sal_True ),
				sMergeSrc( rMergeSource ),
				bError( sal_False ),
				bReadOver( sal_False ),
				bDontWriteOutput( sal_False ),
				sFilename( rFile )
{
    (void) rPrj;
    (void) rPrjRoot;
    (void) rFile;
    pParseQueue = new ParserQueue( *this );
    if( !isInitialized ) InitLanguages( bMergeMode );
    // used when merge is enabled

	// open output stream
	if ( bEnableExport ) {
		aOutput.Open( String( rOutput, RTL_TEXTENCODING_ASCII_US ), STREAM_STD_WRITE | STREAM_TRUNC );
        aOutput.SetStreamCharSet( RTL_TEXTENCODING_UTF8 );
		aOutput.SetLineDelimiter( LINEEND_CRLF );
	}

}

/*****************************************************************************/
void Export::Init()
/*****************************************************************************/
{
	// resets the internal status, used before parseing another file
	sActPForm = "";
	bDefine = sal_False;
	bNextMustBeDefineEOL = sal_False;
	nLevel = 0;
	nList = LIST_NON;
    nListLang = ByteString( String::CreateFromAscii(""),RTL_TEXTENCODING_ASCII_US );
	nListIndex = 0;
	while ( aResStack.Count()) {
		delete aResStack.GetObject(( sal_uLong ) 0 );
		aResStack.Remove(( sal_uLong ) 0 );
	}
}

/*****************************************************************************/
Export::~Export()
/*****************************************************************************/
{
	if( pParseQueue )
        delete pParseQueue;
	// close output stream
	if ( bEnableExport )
		aOutput.Close();
	while ( aResStack.Count()) {
		delete aResStack.GetObject(( sal_uLong ) 0 );
		aResStack.Remove(( sal_uLong ) 0 );
	}

	if ( bMergeMode && !bUnmerge ) {
		if ( !pMergeDataFile )
			pMergeDataFile = new MergeDataFile( sMergeSrc,sFile , bErrorLog, aCharSet);//, bUTF8 );

		//pMergeDataFile->WriteErrorLog( sActFileName );
		delete pMergeDataFile;
	}
}

/*****************************************************************************/
int Export::Execute( int nToken, const char * pToken )
/*****************************************************************************/
{

    ByteString sToken( pToken );
	ByteString sOrig( sToken );
/*	printf("+---------------\n");
	printf("sToken = %s\n",sToken.GetBuffer());
	printf("nToken = %d\n",nToken);
	printf("+---------------\n"); */
    sal_Bool bWriteToMerged = bMergeMode;

	if ( nToken == CONDITION ) {
		ByteString sTestToken( pToken );
		sTestToken.EraseAllChars( '\t' );
		sTestToken.EraseAllChars( ' ' );
		if (( !bReadOver ) && ( sTestToken.Search( "#ifndef__RSC_PARSER" ) == 0 ))
			bReadOver = sal_True;
		else if (( bReadOver ) && ( sTestToken.Search( "#endif" ) == 0 ))
			bReadOver = sal_False;
	}
	if ((( nToken < FILTER_LEVEL ) || ( bReadOver )) &&
		(!(( bNextMustBeDefineEOL ) && ( sOrig == "\n" )))) {
		// this tokens are not mandatory for parsing, so ignore them ...
		if ( bMergeMode )
			WriteToMerged( sOrig , false ); // ... ore whrite them directly to dest.
		return 0;
	}

	ResData *pResData = NULL;
	if ( nLevel ) {
		// res. exists at cur. level
		pResData = aResStack.GetObject( nLevel-1 );
	}
	else if (( nToken != RESSOURCE ) &&
			( nToken != RESSOURCEEXPR ) &&
			( nToken != SMALRESSOURCE ) &&
			( nToken != LEVELUP ) &&
			( nToken != NORMDEFINE ) &&
            ( nToken != RSCDEFINE ) &&
			( nToken != CONDITION ) &&
			( nToken != PRAGMA ))
	{
		// no res. exists at cur. level so return
		if ( bMergeMode )
			WriteToMerged( sOrig , false );
		return 0;
	}
    // #define NO_LOCALIZE_EXPORT
    if( bSkipFile ){
        if ( bMergeMode ) {
            WriteToMerged( sOrig , false );
        }
        return 1;
	}


	if ( bDefine ) {
		if (( nToken != EMPTYLINE ) && ( nToken != LEVELDOWN ) && ( nToken != LEVELUP )) {
			// cur. res. defined in macro
			if ( bNextMustBeDefineEOL ) {
                if ( nToken != RSCDEFINELEND ) {
					// end of macro found, so destroy res.
					bDefine = sal_False;
					if ( bMergeMode ) {
						/*if ( bDontWriteOutput && bUnmerge ) {
							bDontWriteOutput = sal_False;
							bNextMustBeDefineEOL = sal_False;
							bDefine = sal_True;
						}*/
						MergeRest( pResData );
					}
					bNextMustBeDefineEOL = sal_False;
					Execute( LEVELDOWN, "" );
				}
				else {
					// next line also in macro definition
					bNextMustBeDefineEOL = sal_False;
					if ( bMergeMode )
						WriteToMerged( sOrig , false );
					return 1;
				}
			}
			else if (( nToken != LISTASSIGNMENT ) && ( nToken != UIENTRIES )){
				// cur. line has macro line end
				ByteString sTmpLine( sToken );
				sTmpLine.EraseAllChars( '\t' ); sTmpLine.EraseAllChars( ' ' );
                #if 0
                // impossible, unsigned is never negative
				if( sTmpLine.Len() < 0 ){
					if ( sTmpLine.GetChar(( sal_uInt16 )( sTmpLine.Len() - 1 )) != '\\' )
						bNextMustBeDefineEOL = sal_True;
				}
                #endif
			}
		}
	}

	sal_Bool bExecuteDown = sal_False;
	if ( nToken != LEVELDOWN ) {
		sal_uInt16 nOpen = 0;
		sal_uInt16 nClose = 0;
		sal_Bool bReadOver1 = sal_False;
        sal_uInt16 i = 0;
		for ( i = 0; i < sToken.Len(); i++ ) {
			if ( sToken.GetChar( i ) == '\"' )
				bReadOver1 = !bReadOver1;
			if ( !bReadOver1 && ( sToken.GetChar( i ) == '{' ))
				nOpen++;
		}

		bReadOver1 = sal_False;
		for ( i = 0; i < sToken.Len(); i++ ) {
			if ( sToken.GetChar( i ) == '\"' )
				bReadOver1 = !bReadOver1;
			if ( !bReadOver1 && ( sToken.GetChar( i ) == '}' ))
				nClose++;
		}

		if ( nOpen < nClose )
			bExecuteDown = sal_True;
	}
	switch ( nToken ) {

        case NORMDEFINE:
                        //printf("sToken = '%s'",sToken.GetBuffer());
                        while( sToken.SearchAndReplace( "\r", " " ) != STRING_NOTFOUND ) {};
                        while( sToken.SearchAndReplace( "\t", " " ) != STRING_NOTFOUND ) {};
                        while( sToken.SearchAndReplace( "  ", " " ) != STRING_NOTFOUND ) {};
                        if( sToken.EqualsIgnoreCaseAscii( "#define NO_LOCALIZE_EXPORT" ) ){
                            bSkipFile = true;
                            return 0;
                        }
                        if ( bMergeMode )
                          WriteToMerged( sOrig , false );

                        return 0;


        case RSCDEFINE:
			bDefine = sal_True; // res. defined in macro

		case RESSOURCE:
		case RESSOURCEEXPR: {
			bDontWriteOutput = sal_False;
			if ( nToken != RSCDEFINE )
				bNextMustBeDefineEOL = sal_False;
			// this is the beginning of a new res.
			nLevel++;
			if ( nLevel > 1 ) {
				aResStack.GetObject( nLevel - 2 )->bChild = sal_True;
			}

			// create new instance for this res. and fill mandatory fields

			pResData = new ResData( sActPForm, FullId() , sFilename );
			aResStack.Insert( pResData, LIST_APPEND );
			ByteString sBackup( sToken );
			sToken.EraseAllChars( '\n' );
			sToken.EraseAllChars( '\r' );
			sToken.EraseAllChars( '{' );
			while( sToken.SearchAndReplace( "\t", " " ) != STRING_NOTFOUND ) {};
			sToken.EraseTrailingChars( ' ' );
			ByteString sT =  sToken.GetToken( 0, ' ' );
            pResData->sResTyp = sT.ToLowerAscii();
			ByteString sId( sToken.Copy( pResData->sResTyp.Len() + 1 ));
			ByteString sCondition;
			if ( sId.Search( "#" ) != STRING_NOTFOUND ) {
				// between ResTyp, Id and paranthes is a precomp. condition
				sCondition = "#";
				sCondition += sId.GetToken( 1, '#' );
				sId = sId.GetToken( 0, '#' );
			}
			sId = sId.GetToken( 0, '/' );
			CleanValue( sId );
			sId = sId.EraseAllChars( '\t' );
			pResData->SetId( sId, ID_LEVEL_IDENTIFIER );
			if ( sCondition.Len()) {
				ByteString sEmpty( "" );
				Execute( CONDITION, sEmpty.GetBufferAccess()); 	// execute the
														  		// precomp.
																// condition
				sEmpty.ReleaseBufferAccess();
			}
		}
		break;
		case SMALRESSOURCE: {
			bDontWriteOutput = sal_False;
			// this is the beginning of a new res.
			bNextMustBeDefineEOL = sal_False;
			nLevel++;
			if ( nLevel > 1 ) {
				aResStack.GetObject( nLevel - 2 )->bChild = sal_True;
			}

			// create new instance for this res. and fill mandatory fields

			pResData = new ResData( sActPForm, FullId() , sFilename );
			aResStack.Insert( pResData, LIST_APPEND );
			sToken.EraseAllChars( '\n' );
			sToken.EraseAllChars( '\r' );
			sToken.EraseAllChars( '{' );
			sToken.EraseAllChars( '\t' );
			sToken.EraseAllChars( ' ' );
			sToken.EraseAllChars( '\\' );
			pResData->sResTyp = sToken.ToLowerAscii();
		}
		break;
		case LEVELUP: {
			// push
			if ( nList )
				nListLevel++;
			if ( nList )
				break;

			bDontWriteOutput = sal_False;
			ByteString sLowerTyp;
			if ( pResData )
				sLowerTyp = "unknown";
			nLevel++;
			if ( nLevel > 1 ) {
				aResStack.GetObject( nLevel - 2 )->bChild = sal_True;
			}

			ResData *pNewData = new ResData( sActPForm, FullId() , sFilename );
			pNewData->sResTyp = sLowerTyp;
			aResStack.Insert( pNewData, LIST_APPEND );
		}
		break;
		case LEVELDOWN: {
			// pop
			if ( !nList  ) {
				bDontWriteOutput = sal_False;
				if ( nLevel ) {
					if ( bDefine && (nLevel == 1 )) {
                        bDefine = sal_False;
						bNextMustBeDefineEOL = sal_False;
					}
					WriteData( pResData );
					delete aResStack.GetObject( nLevel - 1 );
					aResStack.Remove( nLevel - 1 );
					nLevel--;
				}
			}
			else {
				if ( bDefine )
					bNextMustBeDefineEOL = sal_True;
				if ( !nListLevel ) {
					if ( bMergeMode )
						MergeRest( pResData, MERGE_MODE_LIST );
					nList = LIST_NON;
				}
				else
					nListLevel--;
			}
		}
		break;
        case ASSIGNMENT: {
			bDontWriteOutput = sal_False;
			// interpret different types of assignement
 			ByteString sKey = sToken.GetToken( 0, '=' );
			sKey.EraseAllChars( ' ' );
			sKey.EraseAllChars( '\t' );
			ByteString sValue = sToken.GetToken( 1, '=' );
			CleanValue( sValue );
			if ( sKey.ToUpperAscii() == "IDENTIFIER" ) {
				ByteString sId( sValue.EraseAllChars( '\t' ));
				pResData->SetId( sId.EraseAllChars( ' ' ), ID_LEVEL_IDENTIFIER );
			}
			else if ( sKey == "HELPID" ) {
				pResData->sHelpId = sValue;
			}
			else if ( sKey == "STRINGLIST" ) {
				//if ( bUnmerge ){
				//	( sOrig.SearchAndReplace( "=", "[ de ] =" ));
				//}

				pResData->bList = sal_True;
				nList = LIST_STRING;
                //ByteString sLang("en-US" , RTL_TEXTENCODING_ASCII_US );
                nListLang = SOURCE_LANGUAGE;
				nListIndex = 0;
				nListLevel = 0;
			}
			else if ( sKey == "FILTERLIST" ) {
				//if ( bUnmerge ){
				//	( sOrig.SearchAndReplace( "=", "[ de ] =" ));
				//}
				pResData->bList = sal_True;
				nList = LIST_FILTER;
                //ByteString sLang("en-US" , RTL_TEXTENCODING_ASCII_US );
				nListLang = SOURCE_LANGUAGE;
				nListIndex = 0;
				nListLevel = 0;
			}
			else if ( sKey == "UIENTRIES" ) {
				//if ( bUnmerge ){
				//	( sOrig.SearchAndReplace( "=", "[ de ] =" ));}
				pResData->bList = sal_True;
				nList = LIST_UIENTRIES;
				//ByteString sLang("en-US" , RTL_TEXTENCODING_ASCII_US );
				nListLang = SOURCE_LANGUAGE;
				nListIndex = 0;
				nListLevel = 0;
			}
			if (( sToken.Search( "{" ) != STRING_NOTFOUND ) &&
				( sToken.GetTokenCount( '{' ) > sToken.GetTokenCount( '}' )))
			{
				//WorkOnTokenSet( LEVELUP, pTkn );
                Parse( LEVELUP, "" );
			}
            //if ( bUnmerge && ( nListLang.EqualsIgnoreCaseAscii("de") || nListLang.EqualsIgnoreCaseAscii("en-US") ) && ListExists( pResData, nList ))
			//	bDontWriteOutput = sal_True;
 		}
		break;
		case UIENTRIES:
		case LISTASSIGNMENT: {
			bDontWriteOutput = sal_False;
            ByteString sTmpToken( sToken);
            sTmpToken.EraseAllChars(' ');
            sal_uInt16 nPos = 0;
            //nPos = sTmpToken.ToLowerAscii().Search("[de]=");
			nPos = sTmpToken.ToLowerAscii().Search("[en-us]=");
            if( nPos != STRING_NOTFOUND ) {
				//if ( bUnmerge ){
				//	( sOrig.SearchAndReplace( "=", "[ de ] =" ));
				//}
                ByteString sKey = sTmpToken.Copy( 0 , nPos );
				sKey.EraseAllChars( ' ' );
				sKey.EraseAllChars( '\t' );
				ByteString sValue = sToken.GetToken( 1, '=' );
				CleanValue( sValue );
				if ( sKey.ToUpperAscii() ==  "STRINGLIST" ) {
					pResData->bList = sal_True;
					nList = LIST_STRING;
					//ByteString sLang("en-US" , RTL_TEXTENCODING_ASCII_US );
					nListLang = SOURCE_LANGUAGE;
					nListIndex = 0;
					nListLevel = 0;
				}
				else if ( sKey == "FILTERLIST" ) {
					pResData->bList = sal_True;
					nList = LIST_FILTER;
					//ByteString sLang("en-US" , RTL_TEXTENCODING_ASCII_US );
					nListLang = SOURCE_LANGUAGE;
					nListIndex = 0;
					nListLevel = 0;
				}
				// PairedList
                else if ( sKey ==  "PAIREDLIST" ) {
					pResData->bList = sal_True;
					nList = LIST_PAIRED;
					//ByteString sLang("en-US" , RTL_TEXTENCODING_ASCII_US );
					nListLang = SOURCE_LANGUAGE;
					nListIndex = 0;
					nListLevel = 0;
				}

                else if ( sKey ==  "ITEMLIST" ) {
					pResData->bList = sal_True;
					nList = LIST_ITEM;
					//ByteString sLang("en-US" , RTL_TEXTENCODING_ASCII_US );
					nListLang = SOURCE_LANGUAGE;
					nListIndex = 0;
					nListLevel = 0;
				}
				else if ( sKey ==  "UIENTRIES" ) {
					pResData->bList = sal_True;
					nList = LIST_UIENTRIES;
					//ByteString sLang("en-US" , RTL_TEXTENCODING_ASCII_US );
					nListLang = SOURCE_LANGUAGE;
					nListIndex = 0;
					nListLevel = 0;
				}
                /*if ( bUnmerge && ( nListLang.EqualsIgnoreCaseAscii( "de" )
                    || nListLang.EqualsIgnoreCaseAscii("en-US" ) )
                    && ListExists( pResData, nList ))
					bDontWriteOutput = sal_True;*/
			}
			else {
				// new res. is a String- or FilterList
				ByteString sKey = sToken.GetToken( 0, '[' );
				sKey.EraseAllChars( ' ' );
				sKey.EraseAllChars( '\t' );
				if ( sKey.ToUpperAscii() == "STRINGLIST" )
					nList = LIST_STRING;
				else if ( sKey == "FILTERLIST" )
					nList = LIST_FILTER;
				else if ( sKey == "PAIREDLIST" )
					nList = LIST_PAIRED;				// abcd
				else if ( sKey == "ITEMLIST" )
					nList = LIST_ITEM;
				else if ( sKey == "UIENTRIES" )
					nList = LIST_UIENTRIES;
				if ( nList ) {
					ByteString sLang=sToken.GetToken( 1, '[' ).GetToken( 0, ']' );
					CleanValue( sLang );
                    nListLang = sLang;
                    /*if (( bUnmerge ) && ( !nListLang.EqualsIgnoreCaseAscii("de")) && ( !nListLang.EqualsIgnoreCaseAscii("en-US")))
                        bDontWriteOutput = sal_True;*/
					nListIndex = 0;
					nListLevel = 0;
                    /*if ( bUnmerge && nListLang.EqualsIgnoreCaseAscii("de")  && ListExists( pResData, nList ) )
						bDontWriteOutput = sal_True;*/
				}
			}
		}
		break;
		case TEXT:
		case _LISTTEXT:
		case LISTTEXT: {
			// this is an entry for a String- or FilterList
			if ( nList ) {
				SetChildWithText();
				ByteString sEntry( sToken.GetToken( 1, '\"' ));
				if ( sToken.GetTokenCount( '\"' ) > 3 )
					sEntry += "\"";
				if ( sEntry == "\\\"" )
					sEntry = "\"";
				//sEntry = sEntry.Convert( aCharSet, RTL_TEXTENCODING_MS_1252 );
				//sEntry = sEntry.Convert( RTL_TEXTENCODING_MS_1252, RTL_TEXTENCODING_UTF8 );
				InsertListEntry( sEntry, sOrig );
				if ( bMergeMode && ( sEntry != "\"" )) {
					PrepareTextToMerge( sOrig, nList, nListLang, pResData );
				}
			}
		}
		break;
		case LONGTEXTLINE:
		case TEXTLINE:
			bDontWriteOutput = sal_False;
			if ( nLevel ) {
				CutComment( sToken );

				// this is a text line!!!
				ByteString sKey = sToken.GetToken( 0, '=' ).GetToken( 0, '[' );
				sKey.EraseAllChars( ' ' );
				sKey.EraseAllChars( '\t' );
				ByteString sText( GetText( sToken, nToken ));
				if ( !bMergeMode )
					sText = sText.Convert( aCharSet, RTL_TEXTENCODING_MS_1252 );
				ByteString sLang;
				if ( sToken.GetToken( 0, '=' ).Search( "[" ) != STRING_NOTFOUND ) {
 					sLang = sToken.GetToken( 0, '=' ).GetToken( 1, '[' ).GetToken( 0, ']' );
					CleanValue( sLang );
				}
				ByteString nLangIndex = sLang;
                ByteString sOrigKey = sKey;
				if ( sText.Len() && sLang.Len() ) {
					if (( sKey.ToUpperAscii() == "TEXT" ) ||
						( sKey == "MESSAGE" ) ||
						( sKey == "CUSTOMUNITTEXT" ) ||
						( sKey == "SLOTNAME" ) ||
						( sKey == "UINAME" ))
					{
						//if ( bUnmerge && sToken.GetToken( 0, '=' ).Search( "[" ) == STRING_NOTFOUND )
						//	( sOrig.SearchAndReplace( "=", "[ de ] =" ));

						SetChildWithText();
                        //if ( nLangIndex.EqualsIgnoreCaseAscii("en-US") )
						if ( Export::isSourceLanguage( nLangIndex ) )
							pResData->SetId( sText, ID_LEVEL_TEXT );

						pResData->bText = sal_True;
						pResData->sTextTyp = sOrigKey;
						if ( bMergeMode ) {
							PrepareTextToMerge( sOrig, STRING_TYP_TEXT, nLangIndex, pResData );
							//if ( bUnmerge )
							//	pResData->sText[ nLangIndex ] = sText;
						}
						else {
							if ( pResData->sText[ nLangIndex ].Len()) {
								ByteString sError( "Language " );
                                sError += nLangIndex;
								sError += " defined twice";
							}
							pResData->sText[ nLangIndex ] = sText;
						}
					}
					else if ( sKey == "HELPTEXT" ) {
						//if ( bUnmerge && sToken.GetToken( 0, '=' ).Search( "[" ) == STRING_NOTFOUND ){
						//	( sOrig.SearchAndReplace( "=", "[ de ] =" ));
						//	}
						SetChildWithText();
						pResData->bHelpText = sal_True;
						if ( bBreakWhenHelpText ) {
							ByteString sError( "\"HelpText\" found in source\n" );
							YYWarning( sError.GetBufferAccess());
							sError.ReleaseBufferAccess();
							SetError();
						}
						if ( bMergeMode )
							PrepareTextToMerge( sOrig, STRING_TYP_HELPTEXT, nLangIndex, pResData );
							//if ( bUnmerge )
							//	pResData->sHelpText[ nLangIndex ] = sText;
						else {
							if ( pResData->sHelpText[ nLangIndex ].Len()) {
								ByteString sError( "Language " );
                                sError += nLangIndex;
								sError += " defined twice";
							}
							pResData->sHelpText[ nLangIndex ] = sText;
						}
					}
					else if ( sKey == "QUICKHELPTEXT" ) {
						//if ( bUnmerge && sToken.GetToken( 0, '=' ).Search( "[" ) == STRING_NOTFOUND ){
						//	( sOrig.SearchAndReplace( "=", "[ de ] =" ));
						//	}
						SetChildWithText();
						pResData->bQuickHelpText = sal_True;
						if ( bMergeMode )
							PrepareTextToMerge( sOrig, STRING_TYP_QUICKHELPTEXT, nLangIndex, pResData );
							//if ( bUnmerge )
							//	pResData->sQuickHelpText[ nLangIndex ] = sText;
						else {
							if ( pResData->sQuickHelpText[ nLangIndex ].Len()) {
								ByteString sError( "Language " );
                                sError += nLangIndex;
								sError += " defined twice";
							}
							pResData->sQuickHelpText[ nLangIndex ] = sText;
						}
					}
					else if ( sKey == "TITLE" ) {
						//if ( bUnmerge && sToken.GetToken( 0, '=' ).Search( "[" ) == STRING_NOTFOUND ){
						//	( sOrig.SearchAndReplace( "=", "[ de ] =" ));
						//	}
						SetChildWithText();
						pResData->bTitle = sal_True;
						if ( bMergeMode )
							PrepareTextToMerge( sOrig, STRING_TYP_TITLE, nLangIndex, pResData );
							//if ( bUnmerge )
							//	pResData->sTitle[ nLangIndex ] = sText;
						else {
							if ( pResData->sTitle[ nLangIndex ].Len()) {
								ByteString sError( "Language " );
                                sError += nLangIndex;
								sError += " defined twice";
							}
							pResData->sTitle[ nLangIndex ] = sText;
						}
					}
					else if ( sKey == "ACCESSPATH" ) {
						pResData->SetId( sText, ID_LEVEL_ACCESSPATH );
					}
					else if ( sKey == "FIELDNAME" ) {
						pResData->SetId( sText, ID_LEVEL_FIELDNAME );
					}
				}
			}
		break;
		case NEWTEXTINRES: {
			bDontWriteOutput = sal_True;
			// this means something like // ### Achtung : Neuer Text ...
			/*ByteString sLang( "GERMAN" );
			ByteString sText = sToken.GetToken( 2, ':' ).GetToken( 0, '*' );
			CleanValue( sText );
			if ( sText.Len())
            	pResData->sText[ sLang ] = sText;*/
		}
		break;
		case APPFONTMAPPING: {
			bDontWriteOutput = sal_False;
			// this is a AppfontMapping, so look if its a definition
			// of field size
			ByteString sKey = sToken.GetToken( 0, '=' );
			sKey.EraseAllChars( ' ' );
			sKey.EraseAllChars( '\t' );
			ByteString sMapping = sToken.GetToken( 1, '=' );
			sMapping = sMapping.GetToken( 1, '(' );
			sMapping = sMapping.GetToken( 0, ')' );
			sMapping.EraseAllChars( ' ' );
			sMapping.EraseAllChars( '\t' );
			if ( sKey.ToUpperAscii() == "SIZE" ) {
				pResData->nWidth = ( sal_uInt16 ) sMapping.GetToken( 0, ',' ).ToInt64();
			}
			else if ( sKey == "POSSIZE" ) {
				pResData->nWidth = ( sal_uInt16 ) sMapping.GetToken( 2, ',' ).ToInt64();
			}
		}
		break;
		case RSCDEFINELEND:
			bDontWriteOutput = sal_False;
		break;
		case CONDITION: {
			bDontWriteOutput = sal_False;
			while( sToken.SearchAndReplace( "\r", " " ) != STRING_NOTFOUND ) {};
			while( sToken.SearchAndReplace( "\t", " " ) != STRING_NOTFOUND ) {};
			while( sToken.SearchAndReplace( "  ", " " ) != STRING_NOTFOUND ) {};
			ByteString sCondition = sToken.GetToken( 0, ' ' );
			if ( sCondition == "#ifndef" ) {
				sActPForm = "!defined ";
				sActPForm += sToken.GetToken( 1, ' ' );
			}
			else if ( sCondition == "#ifdef" ) {
				sActPForm = "defined ";
				sActPForm += sToken.GetToken( 1, ' ' );
			}
			else if ( sCondition == "#if" ) {
				sActPForm = sToken.Copy( 4 );
				while ( sActPForm.SearchAndReplace( "||", "\\or" ) != STRING_NOTFOUND ) {};
			}
			else if ( sCondition == "#elif" ) {
				sActPForm = sToken.Copy( 6 );
				while ( sActPForm.SearchAndReplace( "||", "\\or" ) != STRING_NOTFOUND ) {};
			}
			else if ( sCondition == "#else" ) {
				sActPForm = sCondition;
			}
			else if ( sCondition == "#endif" ) {
				sActPForm = "";
			}
			else break;
			if ( nLevel ) {
				WriteData( pResData, sal_True );
				pResData->sPForm = sActPForm;
			}
		}
		break;
		case EMPTYLINE : {
			bDontWriteOutput = sal_False;
			if ( bDefine ) {
				bNextMustBeDefineEOL = sal_False;
                bDefine = sal_False;
				while ( nLevel )
					Parse( LEVELDOWN, "" );
                    //WorkOnTokenSet( LEVELDOWN, pTkn );
			}
		}
		break;
		case PRAGMA : {
			bDontWriteOutput = sal_False;
			while( sToken.SearchAndReplace( "\t", " " ) != STRING_NOTFOUND ) {};
			while( sToken.SearchAndReplace( "  ", " " ) != STRING_NOTFOUND ) {};
			sToken.EraseLeadingChars( ' ' );
			sToken.EraseTrailingChars( ' ' );

			ByteString sCharset = sToken.GetToken( 1, ' ' );
			ByteString sSet = sToken.GetToken( 2, ' ' );
			if (( sCharset.ToUpperAscii() == "CHARSET_IBMPC" ) ||
				( sCharset == "RTL_TEXTENCODING_IBM_850" ) ||
				(( sCharset == "CHARSET" ) && ( sSet.ToUpperAscii() == "IBMPC" )))
			{
				aCharSet = RTL_TEXTENCODING_IBM_850;
			}
			else if (( sCharset == "CHARSET_ANSI" ) ||
				( sCharset == "RTL_TEXTENCODING_MS_1252" ) ||
				(( sCharset == "CHARSET" ) && ( sSet.ToUpperAscii() == "ANSI" )))
			{
				aCharSet = RTL_TEXTENCODING_MS_1252;
			}
		}
		break;
		case TEXTREFID : {
			bDontWriteOutput = sal_True;
 			/*ByteString sK = sToken.GetToken( 0, '=' );
            ByteString sKey = sK.EraseAllChars( '\t' ).EraseAllChars( ' ' );
			ByteString sT = sToken.GetToken( 1, '=' ).GetToken( 0, ';' );
            sal_uInt16 nRefId = ( sal_uInt16 ) sT.EraseAllChars( '\t' ).EraseAllChars( ' ' ).ToInt32();
			if (( sKey.ToUpperAscii() == "TEXT" ) ||
				( sKey == "MESSAGE" ) ||
				( sKey == "CUSTOMUNITTEXT" ) ||
				( sKey == "SLOTNAME" ) ||
				( sKey == "UINAME" ))
					pResData->nTextRefId = nRefId;
			else if ( sKey == "HELPTEXT" )
				pResData->nHelpTextRefId = nRefId;
			else if ( sKey == "QUICKHELPTEXT" )
				pResData->nQuickHelpTextRefId = nRefId;
			else if ( sKey == "TITLE" )
				pResData->nTitleRefId = nRefId;*/
		}
		}
	if ( bWriteToMerged ) {
		// the current token must be written to dest. without merging

        if( bDefine && sOrig.Len() > 2 ){
            for( sal_uInt16 n = 0 ; n < sOrig.Len() ; n++ ){
                if( sOrig.GetChar( n ) == '\n' && sOrig.GetChar( n-1 ) != '\\'){
                    sOrig.Insert('\\' , n++ );
                }
            }
        }
        WriteToMerged( sOrig , false);
	}

	if ( bExecuteDown ) {
		Parse( LEVELDOWN, "" );
        //WorkOnTokenSet( LEVELDOWN, pTkn );
	}

	return 1;
}

/*****************************************************************************/
void Export::CutComment( ByteString &rText )
/*****************************************************************************/
{
	if ( rText.Search( "//" ) != STRING_NOTFOUND ) {
		ByteString sWork( rText );
		sWork.SearchAndReplaceAll( "\\\"", "XX" );
		sal_uInt16 i = 0;
		sal_Bool bInner = sal_False;

		while ( i < sWork.Len() - 1 ) {
			if ( sWork.GetChar( i ) == '\"' )
				bInner = !bInner;
			else if
				(( sWork.GetChar( i ) == '/' ) &&
				( !bInner ) &&
				( sWork.GetChar( i + 1 ) == '/' ))
			{
				rText.Erase( i );
				return;
			}
			i++;
		}
	}
}

void Export::UnmergeUTF8( ByteString& sOrig ){
	sal_uInt16 nPos1 = sOrig.Search('\"');
	sal_uInt16 nPos2 = sOrig.SearchBackward('\"');
	if( nPos1 > 0 && nPos2 > 0 && nPos1 < nPos2){
		ByteString sPart = sOrig.Copy(nPos1+1 , nPos2-1);
		ByteString sPartUTF8 = sPart;
		sPartUTF8.Convert( RTL_TEXTENCODING_MS_1252 , RTL_TEXTENCODING_UTF8 );
		sOrig.SearchAndReplace( sPart , sPartUTF8 );
	}
}

/*****************************************************************************/
sal_Bool Export::ListExists( ResData *pResData, sal_uInt16 nLst )
/*****************************************************************************/
{
	switch ( nLst ) {
		case LIST_STRING: return pResData->pStringList != NULL;
		case LIST_FILTER: return pResData->pFilterList != NULL;
		case LIST_ITEM: return pResData->pItemList != NULL;
        case LIST_PAIRED: return pResData->pPairedList != NULL;
		case LIST_UIENTRIES: return pResData->pUIEntries != NULL;
	}
	return sal_False;
}

/*****************************************************************************/
sal_Bool Export::WriteData( ResData *pResData, sal_Bool bCreateNew )
/*****************************************************************************/
{
	if ( bMergeMode ) {
		MergeRest( pResData );
		return sal_True;
	}

	if ( bUnmerge )
		return sal_True;

/*    ByteStringHashMap::iterator pos3 = pResData->sText.begin();
    ByteStringHashMap::iterator end3 = pResData->sText.end();
    for(;pos3!=end3;++pos3){

        printf("[%s]=%s\n", pos3->first.GetBuffer(), pos3->second.GetBuffer() );
    }*/
   	// mandatory to export: en-US

     if (( //pResData->sText[ ByteString("de") ].Len() &&
        ( pResData->sText[ SOURCE_LANGUAGE ].Len()))
        ||
        ( //pResData->sHelpText[ ByteString("de") ].Len() &&
        (  pResData->sHelpText[ SOURCE_LANGUAGE ].Len()))
        ||
        ( //pResData->sQuickHelpText[ ByteString("de") ].Len() &&
        (  pResData->sQuickHelpText[ SOURCE_LANGUAGE ].Len()))
         ||
        ( //pResData->sTitle[ ByteString("de") ].Len() &&
        (  pResData->sTitle[ SOURCE_LANGUAGE ].Len())))

   	{
		FillInFallbacks( pResData );

		ByteString sGID = pResData->sGId;
		ByteString sLID;
		if ( !sGID.Len())
			sGID = pResData->sId;
		else
			sLID = pResData->sId;

		ByteString sXText;
		ByteString sXHText;
		ByteString sXQHText;
		ByteString sXTitle;

		ByteString sTimeStamp( Export::GetTimeStamp());
        ByteString sCur;

        for( unsigned int n = 0; n < aLanguages.size(); n++ ){
            sCur = aLanguages[ n ];
                if ( !sCur.EqualsIgnoreCaseAscii("x-comment") ){
                    if ( pResData->sText[ sCur ].Len())
                        sXText = pResData->sText[ sCur ];
					else {
						sXText = pResData->sText[ SOURCE_LANGUAGE ];
						/*if ( !sXText.Len())
							sXText = pResData->sText[ ByteString("en") ];
						if ( !sXText.Len())
							sXText = pResData->sText[ ByteString("de") ];*/
					}

                    if ( pResData->sHelpText[ sCur ].Len())
                        sXHText = pResData->sHelpText[ sCur ];
					else {
						sXHText = pResData->sHelpText[ SOURCE_LANGUAGE ];
						/*if ( !sXHText.Len())
							sXHText = pResData->sHelpText[ ByteString("en") ];
						if ( !sXText.Len())
							sXHText = pResData->sHelpText[ ByteString("de") ];*/
					}

                    if ( pResData->sQuickHelpText[ sCur ].Len())
                        sXQHText = pResData->sQuickHelpText[ sCur ];
					else {
						sXQHText = pResData->sQuickHelpText[ SOURCE_LANGUAGE ];
						/*if ( !sXQHText.Len())
							sXQHText = pResData->sQuickHelpText[ ByteString("en") ];
						if ( !sXQHText.Len())
							sXQHText = pResData->sQuickHelpText[ ByteString("de") ];*/
					}

                    if ( pResData->sTitle[ sCur ].Len())
                        sXTitle = pResData->sTitle[ sCur ];
					else {
						sXTitle = pResData->sTitle[ SOURCE_LANGUAGE ];
						/*if ( !sXTitle.Len())
							sXTitle = pResData->sTitle[ ByteString("en") ];
						if ( !sXTitle.Len())
							sXTitle = pResData->sTitle[ ByteString("de") ];*/
					}

					if ( !sXText.Len())
						sXText = "-";

					if ( !sXHText.Len()) {
						/*if ( pResData->sHelpText[ ByteString("de") ].Len())
							sXHText = pResData->sHelpText[ ByteString("de") ];*/
						if ( pResData->sHelpText[ SOURCE_LANGUAGE ].Len())
							sXHText = pResData->sHelpText[ SOURCE_LANGUAGE ];
						/*else if ( pResData->sHelpText[ ByteString("en") ].Len())
							sXHText = pResData->sHelpText[ ByteString("en") ];*/
					}
				}
				else
                    sXText = pResData->sText[ sCur ];

				if ( bEnableExport ) {
					ByteString sOutput( sProject ); sOutput += "\t";
					if ( sRoot.Len())
						sOutput += sActFileName;
					sOutput += "\t0\t";
					sOutput += pResData->sResTyp; sOutput += "\t";
					sOutput += sGID; sOutput += "\t";
					sOutput += sLID; sOutput += "\t";
					sOutput += pResData->sHelpId; sOutput	+= "\t";
					sOutput += pResData->sPForm; sOutput	+= "\t";
					sOutput += ByteString::CreateFromInt64( pResData->nWidth ); sOutput += "\t";
                    sOutput += sCur; sOutput += "\t";


					sOutput += sXText; sOutput	+= "\t";
					sOutput += sXHText; sOutput += "\t";
					sOutput += sXQHText; sOutput+= "\t";
					sOutput += sXTitle; sOutput += "\t";
					sOutput += sTimeStamp;

                 // if( !sCur.EqualsIgnoreCaseAscii("de") ||( sCur.EqualsIgnoreCaseAscii("de") && !Export::isMergingGermanAllowed( sProject ) ) )
				    aOutput.WriteLine( sOutput );
				}

				if ( bCreateNew ) {
                    pResData->sText[ sCur ]			= "";
					pResData->sHelpText[ sCur ]		= "";
					pResData->sQuickHelpText[ sCur ]= "";
					pResData->sTitle[ sCur ]		= "";
				}
			}
	}
	FillInFallbacks( pResData );
	if ( pResData->pStringList ) {
		ByteString sList( "stringlist" );
		WriteExportList( pResData, pResData->pStringList, sList, bCreateNew );
		if ( bCreateNew )
			pResData->pStringList = 0;
	}
	if ( pResData->pFilterList ) {
		ByteString sList( "filterlist" );
		WriteExportList( pResData, pResData->pFilterList, sList, bCreateNew );
		if ( bCreateNew )
			pResData->pFilterList = 0;
	}
	if ( pResData->pItemList ) {
		ByteString sList( "itemlist" );
		WriteExportList( pResData, pResData->pItemList, sList, bCreateNew );
		if ( bCreateNew )
			pResData->pItemList = 0;
	}
	if ( pResData->pPairedList ) {
		ByteString sList( "pairedlist" );
		WriteExportList( pResData, pResData->pPairedList, sList, bCreateNew );
		if ( bCreateNew )
			pResData->pItemList = 0;
	}
	if ( pResData->pUIEntries ) {
		ByteString sList( "uientries" );
		WriteExportList( pResData, pResData->pUIEntries, sList, bCreateNew );
		if ( bCreateNew )
			pResData->pUIEntries = 0;
	}
	return sal_True;
}
ByteString Export::GetPairedListID( const ByteString& sText ){
// < "STRING" ; IDENTIFIER ; > ;
    ByteString sIdent = sText.GetToken( 1, ';' );
    sIdent.ToUpperAscii();
    while( sIdent.SearchAndReplace( "\t", " " ) != STRING_NOTFOUND ) {};
    sIdent.EraseTrailingChars( ' ' );
	sIdent.EraseLeadingChars( ' ' );
    return sIdent;
}
ByteString Export::GetPairedListString( const ByteString& sText ){
// < "STRING" ; IDENTIFIER ; > ;
	ByteString sString = sText.GetToken( 0, ';' );
    while( sString.SearchAndReplace( "\t", " " ) != STRING_NOTFOUND ) {};
    sString.EraseTrailingChars( ' ' );
	ByteString s1 = sString.Copy( sString.Search( '\"' )+1 );
	sString = s1.Copy( 0 , s1.SearchBackward( '\"' ) );
	sString.EraseTrailingChars( ' ' );
	sString.EraseLeadingChars( ' ' );
    return sString;
}
ByteString Export::StripList( const ByteString& sText ){
	ByteString s1 = sText.Copy( sText.Search( '\"' ) + 1 );
	return s1.Copy( 0 , s1.SearchBackward( '\"' ) );
}

/*****************************************************************************/
sal_Bool Export::WriteExportList( ResData *pResData, ExportList *pExportList,
						const ByteString &rTyp, sal_Bool bCreateNew )
/*****************************************************************************/
{
	ByteString sGID = pResData->sGId;
	if ( !sGID.Len())
		sGID = pResData->sId;
	else {
		sGID += ".";
		sGID += pResData->sId;
		sGID.EraseTrailingChars( '.' );
	}

	ByteString sTimeStamp( Export::GetTimeStamp());
    ByteString sCur;
	for ( sal_uLong i = 0; pExportList != NULL && i < pExportList->Count(); i++ ) {
		ExportListEntry *pEntry = pExportList->GetObject( i );
				// mandatory for export: german and eng. and/or enus
		//ByteString a("Export::WriteExportList::pEntry");
		//Export::DumpMap( a,  *pEntry );

		ByteString sLID( ByteString::CreateFromInt64( i + 1 ));
        for( unsigned int n = 0; n < aLanguages.size(); n++ ){
            sCur = aLanguages[ n ];
            if ( //1 )
				  //(*pEntry)[ ByteString("de") ].Len() &&
				 	(*pEntry)[ SOURCE_LANGUAGE ].Len() )
					//||
				 	// 	(*pEntry)[ ByteString("en") ].Len()))
				{
					if ( bEnableExport )
					{
						ByteString sText((*pEntry)[ SOURCE_LANGUAGE ] );

                        // Strip PairList Line String
						if( rTyp.EqualsIgnoreCaseAscii("pairedlist") ){
                            sLID = GetPairedListID( sText );
							if ((*pEntry)[ sCur ].Len())
								sText = (*pEntry)[ sCur ];
							sText = GetPairedListString( sText );
                        }
						else{
							//if ((*pEntry)[ sCur ].Len()){
							//	if( sCur.EqualsIgnoreCaseAscii("de") ){
							//		sText = StripList( (*pEntry)[ sCur ] );
							//	}
							//	else
									sText = StripList( (*pEntry)[ sCur ] );
                                    if( sText == "\\\"" )
                                        sText = "\"";
							//}
						}

						ByteString sOutput( sProject ); sOutput += "\t";
						if ( sRoot.Len())
							sOutput += sActFileName;
						sOutput += "\t0\t";
						sOutput += rTyp; sOutput += "\t";
						sOutput += sGID; sOutput += "\t";
						sOutput += sLID; sOutput += "\t\t";
						sOutput += pResData->sPForm; sOutput += "\t0\t";
                        sOutput += sCur; sOutput += "\t";

						sOutput += sText; sOutput += "\t\t\t\t";
						sOutput += sTimeStamp;

                        //if( !sCur.EqualsIgnoreCaseAscii("de") ||( sCur.EqualsIgnoreCaseAscii("de") && !Export::isMergingGermanAllowed( sProject ) ) )
                        aOutput.WriteLine( sOutput );

					}
				}
		}
		if ( bCreateNew )
			delete [] pEntry;
	}
	if ( bCreateNew )
		delete pExportList;

	return sal_True;
}

/*****************************************************************************/
ByteString Export::FullId()
/*****************************************************************************/
{
	ByteString sFull;
	if ( nLevel > 1 ) {
		sFull = aResStack.GetObject( 0 )->sId;
		for ( sal_uInt16 i = 1; i < nLevel - 1; i++ ) {
			ByteString sToAdd = aResStack.GetObject( i )->sId;
			if ( sToAdd.Len()) {
				sFull += ".";
				sFull += sToAdd;
			}
		}
	}
    if ( sFull.Len() > 255 ) {
		ByteString sError( "GroupId > 255 chars" );
	    printf("GroupID = %s\n",sFull.GetBuffer());
        yyerror( sError.GetBufferAccess());
		sError.ReleaseBufferAccess();
	}

	return sFull;
}

/*****************************************************************************/
void Export::InsertListEntry( const ByteString &rText, const ByteString &rLine )
/*****************************************************************************/
{
	ResData *pResData = aResStack.GetObject( nLevel-1 );

	ExportList *pList = NULL;
	if ( nList == LIST_STRING ) {
		pList = pResData->pStringList;
		if ( !pList ) {
			pResData->pStringList = new ExportList();
			pList = pResData->pStringList;
			nListIndex = 0;
		}
	}
	else if ( nList == LIST_FILTER ) {
		pList = pResData->pFilterList;
		if ( !pList ) {
			pResData->pFilterList = new ExportList();
			pList = pResData->pFilterList;
			nListIndex = 0;
		}
	}
	else if ( nList == LIST_ITEM ) {
		pList = pResData->pItemList;
		if ( !pList ) {
			pResData->pItemList = new ExportList();
			pList = pResData->pItemList;
			nListIndex = 0;
		}
	}
	else if ( nList == LIST_PAIRED ) {
		pList = pResData->pPairedList;
		if ( !pList ) {
			pResData->pPairedList = new ExportList();
			pList = pResData->pPairedList;
			nListIndex = 0;
		}
	}
    else if ( nList == LIST_UIENTRIES ) {
		pList = pResData->pUIEntries;
		if ( !pList ) {
			pResData->pUIEntries = new ExportList();
			pList = pResData->pUIEntries;
			nListIndex = 0;
		}
	}
	else
		return;

	if ( nListIndex + 1 > pList->Count()) {
        ExportListEntry *pNew = new ExportListEntry();
		(*pNew)[ LIST_REFID ] = ByteString::CreateFromInt32( REFID_NONE );
		pList->Insert( pNew, LIST_APPEND );
	}
	ExportListEntry *pCurEntry = pList->GetObject( nListIndex );

	// For paired list use the line to set proper lid
	if( nList == LIST_PAIRED ){
		(*pCurEntry)[ nListLang ] = rLine;
	}else
		(*pCurEntry)[ nListLang ] = rText;

	// Remember en-US fallback string, so each list has the same amount of elements
	//if ( nListLang.EqualsIgnoreCaseAscii("en-US")  ) {
	if ( Export::isSourceLanguage( nListLang ) ) {
		if( nList == LIST_PAIRED ){
			const ByteString sPlist("pairedlist");
			ByteString sKey = MergeDataFile::CreateKey( sPlist , pResData->sId , GetPairedListID( rLine ) , sFilename );
			pResData->addFallbackData( sKey , rText );
		}
		// new fallback
		else{
			const ByteString sPlist("list");
			ByteString a( pResData->sGId );
			a.Append( "." );
			a.Append( pResData->sId );
			sal_Int64 x = nListIndex+1;
			ByteString b( ByteString::CreateFromInt64( x ) );
			ByteString sKey = MergeDataFile::CreateKey( sPlist , a , b  , sFilename );
			pResData->addFallbackData( sKey , rText );
		}
		// new fallback
	}

	//if ( nListLang.EqualsIgnoreCaseAscii("en-US")  ) {
	if ( Export::isSourceLanguage( nListLang ) ) {
		if( nList == LIST_PAIRED ){
			(*pCurEntry)[ SOURCE_LANGUAGE ] = rLine;
		}
		else
			(*pCurEntry)[ SOURCE_LANGUAGE ] = rLine;

        pList->NewSourceLanguageListEntry();
	}

	//printf("Export::InsertListEntry ResData.id = %s ResData.ListData = %s\n",pResData->sId.GetBuffer() ,(*pCurEntry)[ nListLang ].GetBuffer());
	nListIndex++;
}

/*****************************************************************************/
void Export::CleanValue( ByteString &rValue )
/*****************************************************************************/
{
	while ( rValue.Len()) {
		if (( rValue.GetChar( 0 ) == ' ' ) || ( rValue.GetChar( 0 ) == '\t' ))
			rValue = rValue.Copy( 1 );
		else
			break;
	}

	if ( rValue.Len()) {
		for ( sal_uInt16 i = rValue.Len() - 1; i > 0; i-- ) {
			if (( rValue.GetChar( i ) == ' ' ) || ( rValue.GetChar( i ) == '\t' ) ||
				( rValue.GetChar( i ) == '\n' ) || ( rValue.GetChar( i ) == ';' ) ||
				( rValue.GetChar( i ) == '{' ) || ( rValue.GetChar( i ) == '\\' ) ||
				( rValue.GetChar( i ) == '\r' ))
				rValue.Erase( i );
			else
				break;
		}
	}
}


/*****************************************************************************/
ByteString Export::GetText( const ByteString &rSource, int nToken )
/*****************************************************************************/
#define TXT_STATE_NON  	0x000
#define TXT_STATE_TEXT	0x001
#define TXT_STATE_MACRO	0x002
{
	ByteString sReturn;
	switch ( nToken ) {
		case TEXTLINE:
		case LONGTEXTLINE: {
			ByteString sTmp( rSource.Copy( rSource.Search( "=" )));
			CleanValue( sTmp );
			sTmp.EraseAllChars( '\n' );
			sTmp.EraseAllChars( '\r' );

			while ( sTmp.SearchAndReplace( "\\\\\"", "-=<[BSlashBSlashHKom]>=-\"" )
				!= STRING_NOTFOUND ) {};
			while ( sTmp.SearchAndReplace( "\\\"", "-=<[Hochkomma]>=-" )
				!= STRING_NOTFOUND ) {};
			while ( sTmp.SearchAndReplace( "\\", "-=<[0x7F]>=-" )
				!= STRING_NOTFOUND ) {};
			while ( sTmp.SearchAndReplace( "\\0x7F", "-=<[0x7F]>=-" )
				!= STRING_NOTFOUND ) {};

			sal_uInt16 nStart = 0;
			sal_uInt16 nState = TXT_STATE_MACRO;

		    nState = TXT_STATE_TEXT;
			nStart = 1;


			for ( sal_uInt16 i = nStart; i < sTmp.GetTokenCount( '\"' ); i++ ) {
				ByteString sToken = sTmp.GetToken( i, '\"' );
				if ( sToken.Len()) {
					if ( nState == TXT_STATE_TEXT ) {
						sReturn += sToken;
						nState = TXT_STATE_MACRO;
					}
					else {
						while( sToken.SearchAndReplace( "\t", " " ) !=
							STRING_NOTFOUND ) {};
						while( sToken.SearchAndReplace( "  ", " " ) !=
							STRING_NOTFOUND ) {};
						sToken.EraseLeadingChars( ' ' );
						sToken.EraseTrailingChars( ' ' );
						if ( sToken.Len()) {
							sReturn += "\\\" ";
							sReturn += sToken;
							sReturn += " \\\"";
						}
						nState = TXT_STATE_TEXT;
					}
				}
			}

			while ( sReturn.SearchAndReplace( "-=<[0x7F]>=-", "" )
				!= STRING_NOTFOUND ) {};
			while ( sReturn.SearchAndReplace( "-=<[Hochkomma]>=-", "\"" )
				!= STRING_NOTFOUND ) {};
			while ( sReturn.SearchAndReplace( "-=<[BSlashBSlashHKom]>=-", "\\\\" )
				!= STRING_NOTFOUND ) {};


			while ( sReturn.SearchAndReplace( "\\\\", "-=<[BSlashBSlash]>=-" )
				!= STRING_NOTFOUND ) {};
			while ( sReturn.SearchAndReplace( "-=<[BSlashBSlash]>=-", "\\" )
				!= STRING_NOTFOUND ) {};

		}
		break;
	}
	return sReturn;
}

/*****************************************************************************/
void Export::WriteToMerged( const ByteString &rText , bool bSDFContent )
/*****************************************************************************/
{
	static ByteString SLASH  ('\\');
    static ByteString RETURN ('\n');
	//printf("%s\n",rText.GetBuffer() );

    #if 0
    // statement has no effect
    if( pParseQueue->bMflag && !bSDFContent ) pParseQueue->bMflag;
    #endif

    if ( !bDontWriteOutput || !bUnmerge ) {
		ByteString sText( rText );
		while ( sText.SearchAndReplace( " \n", "\n" ) != STRING_NOTFOUND ) {};
        if( pParseQueue->bNextIsM && bSDFContent && sText.Len() > 2 ){
            for( sal_uInt16 n = 0 ; n < sText.Len() ; n++ ){
                if( sText.GetChar( n ) == '\n' && sText.GetChar( n-1 ) != '\\'){
                    sText.Insert('\\' , n++ );

                }
            }
        }
        else if( pParseQueue->bLastWasM && sText.Len() > 2 ){
            for( sal_uInt16 n = 0 ; n < sText.Len() ; n++ ){
                if( sText.GetChar( n ) == '\n' && sText.GetChar( n-1 ) != '\\'){
                    sText.Insert('\\' , n++ );
                }
                if( sText.GetChar( n ) == '\n' )pParseQueue->bMflag=true;
            }
        }
        else if( pParseQueue->bCurrentIsM && bSDFContent && sText.Len() > 2 ){
            for( sal_uInt16 n = 0 ; n < sText.Len() ; n++ ){
                if( sText.GetChar( n ) == '\n' && sText.GetChar( n-1 ) != '\\'){
                    sText.Insert('\\' , n++ );
                    pParseQueue->bMflag=true;
                }
            }
        }
        else if( pParseQueue->bMflag ){
            for( sal_uInt16 n = 1 ; n < sText.Len() ; n++ ){
                if( sText.GetChar( n ) == '\n' && sText.GetChar( n-1 ) != '\\'){
                    sText.Insert('\\' , n++ );
                }
            }
        }
        for ( sal_uInt16 i = 0; i < sText.Len(); i++ ) {
			if ( sText.GetChar( i ) != '\n' ){
				aOutput.Write( ByteString( sText.GetChar( i )).GetBuffer(), 1 );

			}
            else{
                aOutput.WriteLine( ByteString());
            }

		}
    }
}

/*****************************************************************************/
void Export::ConvertMergeContent( ByteString &rText )
/*****************************************************************************/
{
	sal_Bool bNoOpen = ( rText.Search( "\\\"" ) != 0 );
	ByteString sClose( rText.Copy( rText.Len() - 2 ));
	sal_Bool bNoClose = ( sClose != "\\\"" );
	ByteString sNew;
	for ( sal_uInt16 i = 0; i < rText.Len(); i++ ) {
		ByteString sChar( rText.GetChar( i ));
		if ( sChar == "\\" ) {
			if (( i + 1 ) < rText.Len()) {
				ByteString sNext( rText.GetChar( i + 1 ));
				if ( sNext == "\"" ) {
					sChar = "\"";
					i++;
				}
				else if ( sNext == "n" ) {
					sChar = "\\n";
					i++;
				}
				else if ( sNext == "t" ) {
					sChar = "\\t";
					i++;
				}
				else if ( sNext == "\'" ) {
					sChar = "\\\'";
					i++;
				}
				else
					sChar = "\\\\";
			}
			else {
				sChar = "\\\\";
			}
		}
		else if ( sChar == "\"" ) {
			sChar = "\\\"";
		}
		else if ( sChar == "" ) {
			sChar = "\\0x7F";
		}
		sNew += sChar;
	}

	rText = sNew;

	if ( bNoOpen ) {
		ByteString sTmp( rText );
		rText = "\"";
		rText += sTmp;
	}
	if ( bNoClose )
		rText += "\"";
}

/*****************************************************************************/
sal_Bool Export::PrepareTextToMerge( ByteString &rText, sal_uInt16 nTyp,
                                ByteString &nLangIndex, ResData *pResData )
/*****************************************************************************/
{
	// position to merge in:
	sal_uInt16 nStart = 0;
	sal_uInt16 nEnd = 0;
	ByteString sOldId = pResData->sId;
	ByteString sOldGId = pResData->sGId;
	ByteString sOldTyp = pResData->sResTyp;

	ByteString sOrigText( rText );

	switch ( nTyp ) {
		case LIST_STRING :
		case LIST_UIENTRIES :
		case LIST_FILTER :
		case LIST_PAIRED:
		case LIST_ITEM :
		{
			if ( bUnmerge )
				return sal_True;

			ExportList *pList = NULL;
			switch ( nTyp ) {
				case LIST_STRING : {
					pResData->sResTyp = "stringlist";
					pList = pResData->pStringList;
				}
				break;
				case LIST_UIENTRIES : {
					pResData->sResTyp = "uientries";
					pList = pResData->pUIEntries;
				}
				break;
				case LIST_FILTER : {
					pResData->sResTyp = "filterlist";
					pList = pResData->pFilterList;
				}
				break;
				case LIST_ITEM : {
					pResData->sResTyp = "itemlist";
					pList = pResData->pItemList;
				}
				break;
				case LIST_PAIRED : {
					pResData->sResTyp = "pairedlist";
					pList = pResData->pPairedList;
				}
				break;

			}
			if ( pList ) {
				ExportListEntry *pCurEntry = pList->GetObject( nListIndex - 1 );
				if ( pCurEntry ) {
					//printf("%s\n",Export::DumpMap( "pCurEntry", *pCurEntry ).GetBuffer() );
					//ByteString a("pCurEntry");
					//Export::DumpMap( a , *pCurEntry );
					rText = (*pCurEntry)[ SOURCE_LANGUAGE ];
					if( nTyp == LIST_PAIRED ){
						pResData->addMergedLanguage( nLangIndex );
					}
                }
			}

			nStart = rText.Search( "\"" );
			if ( nStart == STRING_NOTFOUND ) {
				rText = sOrigText;
				return sal_False;
			}

			sal_Bool bFound = sal_False;
			for ( nEnd = nStart + 1; nEnd < rText.Len() && !bFound; nEnd++ ) {
				if ( rText.GetChar( nEnd ) == '\"' )
					bFound = sal_True;
			}
			if ( !bFound ) {
				rText = sOrigText;
				return sal_False;
			}

			nEnd --;
			sLastListLine = rText;
			if (( sLastListLine.Search( ">" ) != STRING_NOTFOUND ) &&
				( sLastListLine.Search( "<" ) == STRING_NOTFOUND ))
			{
				ByteString sTmp = sLastListLine;
				sLastListLine = "<";
				sLastListLine += sTmp;
			}
			if ( pResData->sResTyp.EqualsIgnoreCaseAscii( "pairedlist" ) ){
               pResData->sId = GetPairedListID( sLastListLine );
            }
            else pResData->sId = ByteString::CreateFromInt32( nListIndex );

			if ( pResData->sGId.Len())
				pResData->sGId += ".";
			pResData->sGId += sOldId;
			nTyp = STRING_TYP_TEXT;
		}
		break;
		case STRING_TYP_TEXT :
		case STRING_TYP_HELPTEXT :
		case STRING_TYP_QUICKHELPTEXT :
		case STRING_TYP_TITLE :
		{
			/*if ( bUnmerge ) {
				if (( nLangIndex != ByteString("de") ) &&
                    ( nLangIndex != ByteString("en-US") ))
				{
					bDontWriteOutput = sal_True;
				}
				return sal_True;
			}*/

			nStart = rText.Search( "=" );
			if ( nStart == STRING_NOTFOUND ) {
				rText = sOrigText;
				return sal_False;
			}

			nStart++;
			sal_Bool bFound = sal_False;
			while(( nStart < rText.Len()) && !bFound ) {
				if (( rText.GetChar( nStart ) != ' ' ) && ( rText.GetChar( nStart ) != '\t' ))
					bFound = sal_True;
				else
					nStart ++;
			}

			// no start position found
			if ( !bFound ) {
				rText = sOrigText;
				return sal_False;
			}

			// position to end mergeing in
			nEnd = rText.Len() - 1;
			bFound = sal_False;

			while (( nEnd > nStart ) && !bFound ) {
				if (( rText.GetChar( nEnd ) != ' ' ) && ( rText.GetChar( nEnd ) != '\t' ) &&
					( rText.GetChar( nEnd ) != '\n' ) && ( rText.GetChar( nEnd ) != ';' ) &&
					( rText.GetChar( nEnd ) != '{' ) && ( rText.GetChar( nEnd ) != '\\' ))
				{
					bFound = sal_True;
				}
				else
					nEnd --;
			}
		}
		break;
	}

	// search for merge data
    if ( !pMergeDataFile ){
        pMergeDataFile = new MergeDataFile( sMergeSrc, sFile , bErrorLog, aCharSet);//, bUTF8 );

        // Init Languages
        ByteString sTmp = Export::sLanguages;
        if( sTmp.ToUpperAscii().Equals("ALL") )
            SetLanguages( pMergeDataFile->GetLanguages() );
        else if( !isInitialized )InitLanguages();

    }
//	printf("*************DUMPING****************\n");
//	printf("%s\n",pMergeDataFile->Dump().GetBuffer());
//	printf("*************DUMPING****************\n");

//	printf("Dumping ResData\n");
//	pResData->Dump();
	PFormEntrys *pEntrys = pMergeDataFile->GetPFormEntrys( pResData );
	//printf("Dumping pEntrys\n");
	//if( pEntrys ) pEntrys->Dump();
	pResData->sId = sOldId;
	pResData->sGId = sOldGId;
	pResData->sResTyp = sOldTyp;

	if ( !pEntrys ) {
		rText = sOrigText;
		return sal_False; // no data found
	}

	ByteString sContent;
	pEntrys->GetTransex3Text( sContent, nTyp, nLangIndex );
	//if ( !sContent.Len() && ( ! nLangIndex.EqualsIgnoreCaseAscii("en-US") )) {
	if ( !sContent.Len() && ( ! Export::isSourceLanguage( nLangIndex ) )) {
		rText = sOrigText;
		return sal_False; // no data found
	}

	//if ( nLangIndex.EqualsIgnoreCaseAscii("en-US") ) {
	if ( Export::isSourceLanguage( nLangIndex ) ) {
		return sal_False;
	}

	ByteString sPostFix( rText.Copy( ++nEnd ));
	rText.Erase( nStart );

	//ConvertMergeContent( sContent, nTyp );
    ConvertMergeContent( sContent );



	//printf("Merged %s\n",nLangIndex.GetBuffer());
	// merge new res. in text line
	rText += sContent;
	rText += sPostFix;

	return sal_True;
}

/*****************************************************************************/
void Export::MergeRest( ResData *pResData, sal_uInt16 nMode )
/*****************************************************************************/
{
	//if ( bUnmerge ) { return;}

	//pResData->Dump();

    if ( !pMergeDataFile ){
		pMergeDataFile = new MergeDataFile( sMergeSrc, sFile ,bErrorLog, aCharSet);//, bUTF8 );

        // Init Languages
        ByteString sTmp = Export::sLanguages;
        if( sTmp.ToUpperAscii().Equals("ALL") )
            SetLanguages( pMergeDataFile->GetLanguages() );
        else if( !isInitialized )InitLanguages();

    }
	switch ( nMode ) {
		case MERGE_MODE_NORMAL : {
			PFormEntrys *pEntry = pMergeDataFile->GetPFormEntrys( pResData );

            bool bWriteNoSlash = false;
			if ( pEntry && pResData->bText ) {

				sal_Bool bAddSemikolon = sal_False;
				sal_Bool bFirst = sal_True;
                ByteString sCur;
                ByteString sTmp = Export::sLanguages;

                for( unsigned int n = 0; n < aLanguages.size(); n++ ){
                    sCur = aLanguages[ n ];

                    ByteString sText;
                    sal_Bool bText = pEntry->GetTransex3Text( sText, STRING_TYP_TEXT, sCur , sal_True );
					if ( bText && sText.Len() && sText != "-" ) {
						ByteString sOutput;
						if ( bNextMustBeDefineEOL)  {
							if ( bFirst )
								sOutput += "\t\\\n";
							else
								sOutput += ";\t\\\n";
						}
						bFirst=sal_False;
						sOutput += "\t";
						sOutput += pResData->sTextTyp;
                        //if ( !sCur.EqualsIgnoreCaseAscii("en-US")) {
						if ( ! Export::isSourceLanguage( sCur ) ) {
							sOutput += "[ ";
							sOutput += sCur;
							sOutput += " ] ";
						}
						sOutput += "= ";
                        ConvertMergeContent( sText );
						sOutput += sText;

                        if ( bDefine && bWriteNoSlash )
						    sOutput += ";\n";

                        if ( bDefine )
							sOutput += ";\\\n";
						else if ( !bNextMustBeDefineEOL )
							sOutput += ";\n";
						else
							bAddSemikolon = sal_True;
						for ( sal_uInt16 j = 1; j < nLevel; j++ )
							sOutput += "\t";
						WriteToMerged( sOutput , true );
					}
                }


				if ( bAddSemikolon ) {
					ByteString sOutput( ";" );
					WriteToMerged( sOutput , false );
				}
			}

			if ( pEntry && pResData->bQuickHelpText ) {
				sal_Bool bAddSemikolon = sal_False;
				sal_Bool bFirst = sal_True;
                ByteString sCur;

                for( unsigned int n = 0; n < aLanguages.size(); n++ ){
                    sCur = aLanguages[ n ];

					ByteString sText;
                    sal_Bool bText = pEntry->GetTransex3Text( sText, STRING_TYP_QUICKHELPTEXT, sCur, sal_True );
					if ( bText && sText.Len() && sText != "-" ) {
						ByteString sOutput;
						if ( bNextMustBeDefineEOL)  {
							if ( bFirst )
								sOutput += "\t\\\n";
							else
								sOutput += ";\t\\\n";
						}
						bFirst=sal_False;
						sOutput += "\t";
						sOutput += "QuickHelpText";
                        //if ( !sCur.EqualsIgnoreCaseAscii("en-US") ) {
						if ( ! Export::isSourceLanguage( sCur ) ) {
							sOutput += "[ ";
							sOutput += sCur;
							sOutput += " ] ";
						}
						sOutput += "= ";
                        ConvertMergeContent( sText );
						sOutput += sText;
						if ( bDefine )
							sOutput += ";\\\n";
						else if ( !bNextMustBeDefineEOL )
							sOutput += ";\n";
						else
							bAddSemikolon = sal_True;
						for ( sal_uInt16 j = 1; j < nLevel; j++ )
							sOutput += "\t";
						WriteToMerged( sOutput ,true );
					}
				}
				if ( bAddSemikolon ) {
					ByteString sOutput( ";" );
					WriteToMerged( sOutput , false );
				}
			}

			if ( pEntry && pResData->bTitle ) {
				sal_Bool bAddSemikolon = sal_False;
				sal_Bool bFirst = sal_True;
                ByteString sCur;

                for( unsigned int n = 0; n < aLanguages.size(); n++ ){
                    sCur = aLanguages[ n ];

                ByteString sText;
                    sal_Bool bText = pEntry->GetTransex3Text( sText, STRING_TYP_TITLE, sCur, sal_True );
					if ( bText && sText.Len() && sText != "-" ) {
						ByteString sOutput;
						if ( bNextMustBeDefineEOL)  {
							if ( bFirst )
								sOutput += "\t\\\n";
							else
								sOutput += ";\t\\\n";
						}
						bFirst=sal_False;
						sOutput += "\t";
						sOutput += "Title";
                        //if ( !sCur.EqualsIgnoreCaseAscii("en-US") ) {
						if ( ! Export::isSourceLanguage( sCur ) ) {
							sOutput += "[ ";
							sOutput += sCur;
							sOutput += " ] ";
						}
						sOutput += "= ";
                        ConvertMergeContent( sText );
						sOutput += sText;
						if ( bDefine )
							sOutput += ";\\\n";
						else if ( !bNextMustBeDefineEOL )
							sOutput += ";\n";
						else
							bAddSemikolon = sal_True;
						for ( sal_uInt16 j = 1; j < nLevel; j++ )
							sOutput += "\t";
						WriteToMerged( sOutput ,true );
					}
				}
				if ( bAddSemikolon ) {
					ByteString sOutput( ";" );
					WriteToMerged( sOutput ,false);
				}
			}
			// Merge Lists

			if ( pResData->bList ) {
				//printf("Dumping ResData\n");
				//pResData->Dump();

				bool bPairedList = false;
				ByteString sOldId = pResData->sId;
				ByteString sOldGId = pResData->sGId;
				ByteString sOldTyp = pResData->sResTyp;
				if ( pResData->sGId.Len())
					pResData->sGId += ".";
				pResData->sGId += sOldId;
				ByteString sSpace;
				for ( sal_uInt16 i = 1; i < nLevel-1; i++ )
					sSpace += "\t";
				for ( sal_uInt16 nT = LIST_STRING; nT <= LIST_UIENTRIES; nT++ ) {
					ExportList *pList = NULL;
					switch ( nT ) {
                        case LIST_STRING : pResData->sResTyp = "stringlist"; pList = pResData->pStringList; bPairedList = false; break;
						case LIST_FILTER : pResData->sResTyp = "filterlist"; pList = pResData->pFilterList; bPairedList = false; break;
						case LIST_UIENTRIES : pResData->sResTyp = "uientries"; pList = pResData->pUIEntries;bPairedList = false; break;
						case LIST_ITEM : pResData->sResTyp = "itemlist"; pList = pResData->pItemList;       bPairedList = false; break;
                        case LIST_PAIRED : pResData->sResTyp = "pairedlist"; pList = pResData->pPairedList; bPairedList = true;  break;
					}
                    ByteString sCur;
                    for( unsigned int n = 0; n < aLanguages.size(); n++ ){
                        sCur = aLanguages[ n ];
						sal_uInt16 nIdx = 1;

						// Set matching pairedlist identifier
						if( bPairedList && pResData->pPairedList && ( nIdx == 1 ) ){
							ExportListEntry* pListE = ( ExportListEntry* ) pResData->pPairedList->GetObject( nIdx-1 );
							pResData->sId = GetPairedListID ( (*pListE)[ SOURCE_LANGUAGE ] );
						}
						else
							pResData->sId = ByteString("1");

						PFormEntrys *pEntrys;
						sal_uLong nLIndex = 0;
						sal_uLong nMaxIndex = 0;
						if ( pList )
							nMaxIndex = pList->GetSourceLanguageListEntryCount();
						pEntrys = pMergeDataFile->GetPFormEntrys( pResData );
                        while( pEntrys  && ( nLIndex < nMaxIndex )) {
						    //printf("Lang %s, List Index %d\n",sCur.GetBuffer(),(int)nLIndex);
							ByteString sText;
                            sal_Bool bText;
							bText = pEntrys->GetTransex3Text( sText, STRING_TYP_TEXT, sCur, sal_True );
							if( !bText )
								bText = pEntrys->GetTransex3Text( sText , STRING_TYP_TEXT, SOURCE_LANGUAGE , sal_False );

							// Use fallback, if data is missing in sdf file
							//if( !bText && pResData->sResTyp.Equals( "pairedlist" ) ){
							if( !bText && bPairedList ){
								if( pResData->isMerged( sCur ) ) break;
								const ByteString sPlist("pairedlist");
								ByteString sKey = MergeDataFile::CreateKey( sPlist , pResData->sGId , pResData->sId , sFilename );
								bText = pResData->getFallbackData( sKey , sText );
							}else if ( !bText ){// new fallback
								if( pResData->isMerged( sCur ) ) break;
								const ByteString sPlist("list");
								ByteString sKey = MergeDataFile::CreateKey( sPlist , pResData->sGId , pResData->sId , sFilename );
								bText = pResData->getFallbackData( sKey , sText );
							} // new fallback

							if ( bText && sText.Len()) {
								//if( pEntrys ) pEntrys->Dump();
								if ( nIdx == 1 ) {
									ByteString sHead;
									if ( bNextMustBeDefineEOL )
										sHead = "\\\n\t";
									sHead += sSpace;
									switch ( nT ) {
										case LIST_STRING : sHead += "StringList "; break;
										case LIST_FILTER : sHead += "FilterList "; break;
										case LIST_ITEM : sHead += "ItemList "; break;
										case LIST_PAIRED : sHead += "PairedList "; break;
										case LIST_UIENTRIES : sHead += "UIEntries "; break;
									}
  									sHead += "[ ";
                                    sHead += sCur;
									sHead += " ] ";
									//}
									if ( bDefine || bNextMustBeDefineEOL ) {
										sHead += "= \\\n";
										sHead += sSpace;
										sHead += "\t{\\\n\t";
									}
									else {
										sHead += "= \n";
										sHead += sSpace;
										sHead += "\t{\n\t";
									}
									WriteToMerged( sHead , true);
								}
								ByteString sLine;
								if ( pList && pList->GetObject( nLIndex ))
									sLine = ( *pList->GetObject( nLIndex ))[ SOURCE_LANGUAGE ];
								if ( !sLine.Len())
									sLine = sLastListLine;

								if ( sLastListLine.Search( "<" ) != STRING_NOTFOUND ) {
									if (( nT != LIST_UIENTRIES ) &&
										(( sLine.Search( "{" ) == STRING_NOTFOUND ) ||
										( sLine.Search( "{" ) >= sLine.Search( "\"" ))) &&
										(( sLine.Search( "<" ) == STRING_NOTFOUND ) ||
										( sLine.Search( "<" ) >= sLine.Search( "\"" ))))
									{
										sLine.SearchAndReplace( "\"", "< \"" );
									}
								}

								sal_uInt16 nStart, nEnd;
								nStart = sLine.Search( "\"" );

								ByteString sPostFix;
								if( !bPairedList ){
									nEnd = sLine.SearchBackward( '\"' );
									sPostFix = ByteString( sLine.Copy( ++nEnd ));
									sLine.Erase( nStart );
								}


                            	ConvertMergeContent( sText );

								// merge new res. in text line
								if( bPairedList ){
									sLine = MergePairedList( sLine , sText );
								}
								else{
									sLine += sText;
									sLine += sPostFix;
								}

								ByteString sText1( "\t" );
								sText1 += sLine;
								if ( bDefine || bNextMustBeDefineEOL )
									sText1 += " ;\\\n";
								else
									sText1 += " ;\n";
								sText1 += sSpace;
								sText1 += "\t";
								//printf("Writing '%s'\n",sText1.GetBuffer());
								WriteToMerged( sText1 ,true );

								// Set matching pairedlist identifier
								if ( bPairedList ){
									nIdx++;
									ExportListEntry* pListE = ( ExportListEntry* ) pResData->pPairedList->GetObject( ( nIdx ) -1 );
									if( pListE ){
										pResData->sId = GetPairedListID ( (*pListE)[ SOURCE_LANGUAGE ] );
									}
                                }
                                else
                                    pResData->sId = ByteString::CreateFromInt32( ++nIdx );
                            }
							else
								break;
							nLIndex ++;
							PFormEntrys *oldEntry = pEntrys;
							pEntrys = pMergeDataFile->GetPFormEntrys( pResData ); // <--- game over
							if( !pEntrys )
								pEntrys = oldEntry;
						}
						if ( nIdx > 1 ) {
							ByteString sFooter( sSpace.Copy( 1 ));
							if ( bNextMustBeDefineEOL )
								sFooter += "};";
							else if ( !bDefine )
								sFooter += "};\n\t";
							else
								sFooter += "\n\n";
							WriteToMerged( sFooter ,true );
						}
					}
				}

				pResData->sId = sOldId;
				pResData->sGId = sOldGId;
				pResData->sResTyp = sOldTyp;
			}
		}
		break;
		case MERGE_MODE_LIST : {
			ExportList *pList = NULL;
			switch ( nList ) {
			    // PairedList
                case LIST_STRING : pList = pResData->pStringList; break;
				case LIST_FILTER : pList = pResData->pFilterList; break;
				case LIST_UIENTRIES : pList = pResData->pUIEntries; break;
				case LIST_ITEM : pList = pResData->pItemList; break;
				case LIST_PAIRED : pList = pResData->pPairedList; break;

			}

			nListIndex++;
			sal_uLong nMaxIndex = 0;
			if ( pList )
				nMaxIndex = pList->GetSourceLanguageListEntryCount();
			ByteString sLine;
			if ( pList && pList->GetObject( nListIndex ))
				sLine = ( *pList->GetObject( nListIndex ))[ SOURCE_LANGUAGE ];
			if ( !sLine.Len())
				sLine = sLastListLine;

			if ( sLastListLine.Search( "<" ) != STRING_NOTFOUND ) {
				if (( nList != LIST_UIENTRIES ) &&
					(( sLine.Search( "{" ) == STRING_NOTFOUND ) ||
					( sLine.Search( "{" ) >= sLine.Search( "\"" ))) &&
					(( sLine.Search( "<" ) == STRING_NOTFOUND ) ||
					( sLine.Search( "<" ) >= sLine.Search( "\"" ))))
				{
					sLine.SearchAndReplace( "\"", "< \"" );
				}
			}

			while( PrepareTextToMerge( sLine, nList, nListLang, pResData ) && ( nListIndex <= nMaxIndex )) {
				ByteString sText( "\t" );
				sText += sLine;
				sText += " ;";
				sText += "\n";
				for ( sal_uInt16 i = 0; i < nLevel; i++ )
					sText += "\t";
				WriteToMerged( sText ,false );
				nListIndex++;
				if ( pList && pList->GetObject( nListIndex ))
					sLine = ( *pList->GetObject( nListIndex ))[ SOURCE_LANGUAGE ];
				if ( !sLine.Len())
					sLine = sLastListLine;
				sLine += " ;";
			}
		}
		break;
	}
    pParseQueue->bMflag = false;
}

ByteString Export::MergePairedList( ByteString& sLine , ByteString& sText ){
// < "xy" ; IDENTIFIER ; >
	ByteString sPre  = sLine.Copy( 0 , sLine.Search('\"') );
	ByteString sPost = sLine.Copy( sLine.SearchBackward('\"') + 1 , sLine.Len() );
	sPre.Append( sText );
	sPre.Append( sPost );
	return sPre;
}

/*****************************************************************************/
void Export::SetChildWithText()
/*****************************************************************************/
{
	if ( aResStack.Count() > 1 ) {
		for ( sal_uLong i = 0; i < aResStack.Count() - 1; i++ ) {
			aResStack.GetObject( i )->bChildWithText = sal_True;
		}
	}
}

void ParserQueue::Push( const QueueEntry& aEntry ){
//    printf("nTyp = %d ",aEntry.nTyp);
    sal_uInt16 nLen = aEntry.sLine.Len();

    if( !bStart ){
        aQueueCur->push( aEntry );
        if( nLen > 1 && aEntry.sLine.GetChar( nLen-1 ) == '\n' )
            bStart = true;
        else if ( aEntry.nTyp != IGNOREDTOKENS ){
            if( nLen > 1 && ( aEntry.sLine.GetChar( nLen-1 ) == '\\') ){
                // Next is Macro
                bCurrentIsM = true;
             }else{
                // Next is no Macro
                bCurrentIsM = false;
             }
        }
    }
    else{
        aQueueNext->push( aEntry );
        if( nLen > 1 && aEntry.sLine.GetChar( nLen-1 ) != '\n' ){
            if( nLen > 1 && ( aEntry.sLine.GetChar( nLen-1  ) == '\\') ){
                // Next is Macro
                bNextIsM = true;
            }
            else{
                // Next is no Macro
                bNextIsM = false;
            }
        }else if( nLen > 2 && aEntry.sLine.GetChar( nLen-1 ) == '\n' ){
            if( aEntry.nTyp != IGNOREDTOKENS ){
                if( nLen > 2 && ( aEntry.sLine.GetChar( nLen-2  ) == '\\') ){
                    // Next is Macro
                    bNextIsM = true;
                }
                else{
                    // Next is no Macro
                    bNextIsM = false;
                }
            }
            // Pop current
            Pop( *aQueueCur );
            bLastWasM = bCurrentIsM;
            // next -> current
            bCurrentIsM = bNextIsM;
            aQref = aQueueCur;
            aQueueCur = aQueueNext;
            aQueueNext = aQref;

        }

        else{
            // Pop current
            Pop( *aQueueCur );
            bLastWasM = bCurrentIsM;
            // next -> current
            bCurrentIsM = bNextIsM;
            aQref = aQueueCur;
            aQueueCur = aQueueNext;
            aQueueNext = aQref;
        }
    }
}

void ParserQueue::Close(){
    // Pop current
    Pop( *aQueueCur );
    // next -> current
    bLastWasM = bCurrentIsM;
    bCurrentIsM = bNextIsM;
    aQref = aQueueCur;
    aQueueCur = aQueueNext;
    aQueueNext = aQref;
    bNextIsM = false;
    Pop( *aQueueNext );
};
void ParserQueue::Pop( std::queue<QueueEntry>& aQueue ){
    while( !aQueue.empty() ){
        QueueEntry aEntry = aQueue.front();
        aQueue.pop();
        aExport.Execute( aEntry.nTyp , (char*) aEntry.sLine.GetBuffer() );
    }
}
ParserQueue::ParserQueue( Export& aExportObj )
        :
          bCurrentIsM( false ),
          bNextIsM( false ) ,
          bLastWasM( false ),
          bMflag( false ) ,
          aExport( aExportObj ) ,
          bStart( false ) ,
          bStartNext( false )
{
          aQueueNext = new std::queue<QueueEntry>;
          aQueueCur  = new std::queue<QueueEntry>;
}


ParserQueue::~ParserQueue(){
    if( aQueueNext )    delete aQueueNext;
    if( aQueueCur )     delete aQueueCur;
}