You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@openoffice.apache.org by ja...@apache.org on 2013/01/24 13:21:39 UTC
svn commit: r1437973 [2/11] - in
/openoffice/branches/l10n/main/l10ntools/source: ./ filter/ filter/merge/
filter/utils/ help/
Added: openoffice/branches/l10n/main/l10ntools/source/export.cxx
URL: http://svn.apache.org/viewvc/openoffice/branches/l10n/main/l10ntools/source/export.cxx?rev=1437973&view=auto
==============================================================================
--- openoffice/branches/l10n/main/l10ntools/source/export.cxx (added)
+++ openoffice/branches/l10n/main/l10ntools/source/export.cxx Thu Jan 24 12:21:38 2013
@@ -0,0 +1,2641 @@
+/**************************************************************
+ *
+ * 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;
+}
Propchange: openoffice/branches/l10n/main/l10ntools/source/export.cxx
------------------------------------------------------------------------------
svn:executable = *