/**************************************************************
 * 
 * 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_rsc.hxx"
/****************** I N C L U D E S **************************************/
// C and C++ Includes.
#include <ctype.h>		// isdigit(), isalpha()
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include <tools/fsys.hxx>
#include <tools/rc.h>
#include <tools/isofallback.hxx>
#include <rtl/strbuf.hxx>

// Programmabhaengige Includes.
#include <rsctree.hxx>
#include <rsctop.hxx>
#include <rscmgr.hxx>
#include <rscdb.hxx>
#include <rscrsc.hxx>

using namespace rtl;

/*************************************************************************
|*
|*	  RscTypCont :: RscTypCont
|*
|*	  Beschreibung		RES.DOC
|*	  Ersterstellung	MM 22.03.90
|*	  Letzte Aenderung	MM 27.06.90
|*
*************************************************************************/
RscTypCont :: RscTypCont( RscError * pErrHdl,
						  RSCBYTEORDER_TYPE nOrder,
						  const ByteString & rSearchPath,
						  sal_uInt32 nFlagsP )
	:
	  nSourceCharSet( RTL_TEXTENCODING_UTF8 ),
	  nByteOrder( nOrder ),
	  aSearchPath( rSearchPath ),
	  aBool( pHS->getID( "sal_Bool" ), RSC_NOTYPE ),
	  aShort( pHS->getID( "short" ), RSC_NOTYPE ),
	  aUShort( pHS->getID( "sal_uInt16" ), RSC_NOTYPE ),
	  aLong( pHS->getID( "long" ), RSC_NOTYPE ),
	  aEnumLong( pHS->getID( "enum_long" ), RSC_NOTYPE ),
	  aIdUShort( pHS->getID( "IDUSHORT" ), RSC_NOTYPE ),
	  aIdNoZeroUShort( pHS->getID( "IDUSHORT" ), RSC_NOTYPE ),
	  aNoZeroShort( pHS->getID( "NoZeroShort" ), RSC_NOTYPE ),
	  a1to12Short( pHS->getID( "MonthShort" ), RSC_NOTYPE ),
	  a0to23Short( pHS->getID( "HourShort" ), RSC_NOTYPE ),
	  a1to31Short( pHS->getID( "DayShort" ), RSC_NOTYPE ),
	  a0to59Short( pHS->getID( "MinuteShort" ), RSC_NOTYPE ),
	  a0to99Short( pHS->getID( "_0to59Short" ), RSC_NOTYPE ),
	  a0to9999Short( pHS->getID( "YearShort" ), RSC_NOTYPE ),
	  aIdLong( pHS->getID( "IDLONG" ), RSC_NOTYPE ),
	  aString( pHS->getID( "Chars" ), RSC_NOTYPE ),
	  aStringLiteral( pHS->getID( "Chars" ), RSC_NOTYPE ),
	  aWinBits( pHS->getID( "WinBits" ), RSC_NOTYPE ),
	  aLangType(),
	  aLangString( pHS->getID( "Lang_Chars" ), RSC_NOTYPE, &aString, &aLangType ),
	  aLangShort( pHS->getID( "Lang_short" ), RSC_NOTYPE, &aShort, &aLangType ),
      nAcceleratorType( 0 ),
	  nFlags( nFlagsP )
{
	nUniqueId = 256;
	nPMId = RSC_VERSIONCONTROL +1; //mindestens einen groesser
	pEH = pErrHdl;
	Init();
}

static sal_uInt32 getLangIdAndShortenLocale( RscTypCont* pTypCont,
                                             rtl::OString& rLang,
                                             rtl::OString& rCountry,
                                             rtl::OString& rVariant )
{
    rtl::OStringBuffer aLangStr( 64 );
    aLangStr.append( rLang.toAsciiLowerCase() );
    if( rCountry.getLength() )
    {
        aLangStr.append( '-' );
        aLangStr.append( rCountry.toAsciiUpperCase() );
    }
    if( rVariant.getLength() )
    {
        aLangStr.append( '-' );
        aLangStr.append( rVariant );
    }
    rtl::OString aL( aLangStr.makeStringAndClear() );
    sal_uInt32 nRet = GetLangId( aL );
    if( nRet == 0 )
    {
        pTypCont->AddLanguage( aL );
        nRet = GetLangId( aL );
    }
    if( rVariant.getLength() )
        rVariant = rtl::OString();
    else if( rCountry.getLength() )
        rCountry = rtl::OString();
    else
        rLang = rtl::OString();
#if OSL_DEBUG_LEVEL > 1
        fprintf( stderr, " %s (0x%hx)", aL.getStr(), (int)nRet );
#endif
    return nRet;
}

ByteString RscTypCont::ChangeLanguage( const ByteString& rNewLang )
{
    ByteString aRet = aLanguage;
    aLanguage = rNewLang;

    rtl::OString aLang = aLanguage;
    rtl::OString aLg, aCountry, aVariant;
    sal_Int32 nIndex = 0;
    aLg = aLang.getToken( 0, '-', nIndex );
    if( nIndex != -1 )
        aCountry = aLang.getToken( 0, '-', nIndex );
    if( nIndex != -1 )
        aVariant = aLang.copy( nIndex );
    
    bool bAppendEnUsFallback =
        ! (rNewLang.EqualsIgnoreCaseAscii( "en-US" ) ||
           rNewLang.EqualsIgnoreCaseAscii( "x-no-translate" ) );

#if OSL_DEBUG_LEVEL > 1
    fprintf( stderr, "RscTypCont::ChangeLanguage:" );
#endif
    aLangFallbacks.clear();

    do
    {
        aLangFallbacks.push_back(getLangIdAndShortenLocale( this, aLg, aCountry, aVariant ) );
    } while( aLg.getLength() );
    
    if( bAppendEnUsFallback )
    {
        aLg = "en";
        aCountry = "US";
        aVariant = rtl::OString();
        aLangFallbacks.push_back( getLangIdAndShortenLocale( this, aLg, aCountry, aVariant ) );
    }

#if OSL_DEBUG_LEVEL > 1
    fprintf( stderr, "\n" );
#endif

    return aRet;
}

Atom RscTypCont::AddLanguage( const char* pLang )
{
    return aLangType.AddLanguage( pLang, aNmTb );
}


/*************************************************************************
|*
|*	  RscTypCont :: ~RscTypCont
|*
|*	  Beschreibung		RES.DOC
|*	  Ersterstellung	MM 22.03.90
|*	  Letzte Aenderung	MM 27.06.90
|*
*************************************************************************/
void DestroyNode( RscTop * pRscTop, ObjNode * pObjNode ){
	if( pObjNode ){
		DestroyNode( pRscTop, (ObjNode*)pObjNode->Left() );
		DestroyNode( pRscTop, (ObjNode*)pObjNode->Right() );

		if( pObjNode->GetRscObj() ){
			pRscTop->Destroy( RSCINST( pRscTop, pObjNode->GetRscObj() ) );
			rtl_freeMemory( pObjNode->GetRscObj() );
		}
		delete pObjNode;
	};
}

void DestroySubTrees( RscTop * pRscTop ){
	if( pRscTop ){
		DestroySubTrees( (RscTop*)pRscTop->Left() );

		DestroyNode( pRscTop, pRscTop->GetObjNode() );

		DestroySubTrees( (RscTop*)pRscTop->Right() );
	};
}

void DestroyTree( RscTop * pRscTop ){
	if( pRscTop ){
		DestroyTree( (RscTop*)pRscTop->Left() );
		DestroyTree( (RscTop*)pRscTop->Right() );

		delete pRscTop;
	};
}

void Pre_dtorTree( RscTop * pRscTop ){
	if( pRscTop ){
		Pre_dtorTree( (RscTop*)pRscTop->Left() );
		Pre_dtorTree( (RscTop*)pRscTop->Right() );

		pRscTop->Pre_dtor();
	};
}

RscTypCont :: ~RscTypCont(){
	RscTop	*		pRscTmp;
	RscSysEntry   * pSysEntry;

	// Alle Unterbaeume loeschen
	aVersion.pClass->Destroy( aVersion );
	rtl_freeMemory( aVersion.pData );
	DestroySubTrees( pRoot );

	// Alle Klassen noch gueltig, jeweilige Instanzen freigeben
	// BasisTypen
	pRscTmp = aBaseLst.First();
	while( pRscTmp ){
		pRscTmp->Pre_dtor();
		pRscTmp = aBaseLst.Next();
	};
	aBool.Pre_dtor();
	aShort.Pre_dtor();
	aUShort.Pre_dtor();
	aIdUShort.Pre_dtor();
	aIdNoZeroUShort.Pre_dtor();
	aNoZeroShort.Pre_dtor();
	aIdLong.Pre_dtor();
	aString.Pre_dtor();
	aWinBits.Pre_dtor();
	aVersion.pClass->Pre_dtor();
	// Zusammengesetzte Typen
	Pre_dtorTree( pRoot );

	// Klassen zerstoeren
	delete aVersion.pClass;
	DestroyTree( pRoot );

	while( NULL != (pRscTmp = aBaseLst.Remove()) ){
		delete pRscTmp;
	};

	while( NULL != (pSysEntry = aSysLst.Remove()) ){
		delete pSysEntry;
	};
}

void RscTypCont::ClearSysNames()
{
	RscSysEntry   * pSysEntry;
	while( NULL != (pSysEntry = aSysLst.Remove()) ){
		delete pSysEntry;
	};
}

//=======================================================================
RscTop * RscTypCont::SearchType( Atom nId )
/*	[Beschreibung]

	Sucht eine Basistyp nId;
*/
{
	if( nId == InvalidAtom )
		return NULL;

#define ELSE_IF( a )				\
	else if( a.GetId() == nId )	\
		return &a;					\

	if( aBool.GetId() == nId )
		return &aBool;
	ELSE_IF( aShort )
	ELSE_IF( aUShort )
	ELSE_IF( aLong )
	ELSE_IF( aEnumLong )
	ELSE_IF( aIdUShort )
	ELSE_IF( aIdNoZeroUShort )
	ELSE_IF( aNoZeroShort )
	ELSE_IF( a1to12Short )
	ELSE_IF( a0to23Short )
	ELSE_IF( a1to31Short )
	ELSE_IF( a0to59Short )
	ELSE_IF( a0to99Short )
	ELSE_IF( a0to9999Short )
	ELSE_IF( aIdLong )
	ELSE_IF( aString )
	ELSE_IF( aWinBits )
	ELSE_IF( aLangType )
	ELSE_IF( aLangString )
	ELSE_IF( aLangShort )

	RscTop * pEle = aBaseLst.First();
	while( pEle )
	{
		if( pEle->GetId() == nId )
			return pEle;
		pEle = aBaseLst.Next();
	}
	return NULL;
}

/*************************************************************************
|*
|*	  RscTypCont :: Search
|*
|*	  Beschreibung		RES.DOC
|*	  Ersterstellung	MM 22.03.90
|*	  Letzte Aenderung	MM 27.06.90
|*
*************************************************************************/
RscTop * RscTypCont :: Search( Atom nRT ){
	return( (RscTop *)pRoot->Search( nRT ) );
}

CLASS_DATA RscTypCont :: Search( Atom nRT, const RscId & rId ){
	ObjNode *pObjNode;
	RscTop	*pRscTop;

	if( NULL != (pRscTop = Search( nRT )) ){
		if( NULL != (pObjNode = pRscTop->GetObjNode( rId )) ){
			return( pObjNode->GetRscObj() );
		}
	}
	return( (CLASS_DATA)0 );
}

/*************************************************************************
|*
|*	  RscTypCont :: Delete()
|*
|*	  Beschreibung
|*	  Ersterstellung	MM 10.07.91
|*	  Letzte Aenderung	MM 10.07.91
|*
*************************************************************************/
void RscTypCont :: Delete( Atom nRT, const RscId & rId ){
	ObjNode *	pObjNode;
	RscTop	*	pRscTop;

	if( NULL != (pRscTop = Search( nRT )) ){
		if( NULL != (pObjNode = pRscTop->GetObjNode()) ){
			pObjNode = pObjNode->Search( rId );

			if( pObjNode ){
				//Objekt aus Baum entfernen
				pRscTop->pObjBiTree =
					(ObjNode *)pRscTop->pObjBiTree->Remove( pObjNode );

				if( pObjNode->GetRscObj() ){
					pRscTop->Destroy( RSCINST( pRscTop,
											   pObjNode->GetRscObj() ) );
					rtl_freeMemory( pObjNode->GetRscObj() );
				}
				delete pObjNode;
			}
		}
	}
}

/*************************************************************************
|*
|*	  RscTypCont :: PutSysName()
|*
|*	  Beschreibung		RES.DOC
|*	  Ersterstellung	MM 22.03.90
|*	  Letzte Aenderung	MM 27.06.90
|*
*************************************************************************/
sal_uInt32 RscTypCont :: PutSysName( sal_uInt32 nRscTyp, char * pFileName,
								 sal_uInt32 nConst, sal_uInt32 nId, sal_Bool bFirst )
{
	RscSysEntry *	pSysEntry;
	sal_Bool			bId1 = sal_False;

	pSysEntry = aSysLst.First();
	while( pSysEntry )
	{
		if( pSysEntry->nKey == 1 )
			bId1 = sal_True;
		if( !strcmp( pSysEntry->aFileName.GetBuffer(), pFileName ) )
			if( pSysEntry->nRscTyp == nRscTyp
			  && pSysEntry->nTyp == nConst
			  && pSysEntry->nRefId == nId )
				break;
		pSysEntry = aSysLst.Next();
	}

	if ( !pSysEntry || (bFirst && !bId1) )
	{
		pSysEntry = new RscSysEntry;
		pSysEntry->nKey = nUniqueId++;
		pSysEntry->nRscTyp = nRscTyp;
		pSysEntry->nTyp = nConst;
		pSysEntry->nRefId = nId;
		pSysEntry->aFileName = (const char*)pFileName;
		if( bFirst && !bId1 )
		{
			pSysEntry->nKey = 1;
			aSysLst.Insert( pSysEntry, (sal_uLong)0 );
		}
		else
			aSysLst.Insert( pSysEntry, LIST_APPEND );
	}

	return pSysEntry->nKey;
}

/*************************************************************************
|*
|*	  RscTypCont :: WriteInc
|*
|*	  Beschreibung		RES.DOC
|*	  Ersterstellung	MM 21.06.90
|*	  Letzte Aenderung	MM 21.06.90
|*
*************************************************************************/
void RscTypCont :: WriteInc( FILE * fOutput, sal_uLong lFileKey )
{
	RscFile   * pFName;

	if( NOFILE_INDEX == lFileKey )
	{
		pFName = aFileTab.First();
		while( pFName )
		{
			if( pFName && pFName->IsIncFile() )
			{
				fprintf( fOutput, "#include " );
				fprintf( fOutput, "\"%s\"\n",
								  pFName->aFileName.GetBuffer() );
			}
			pFName = aFileTab.Next();
		}
	}
	else
	{
		RscDepend * 	pDep;
		RscFile   * 	pFile;

		pFName = aFileTab.Get( lFileKey );
		if( pFName )
		{
			pDep = pFName->First();
			while( pDep )
			{
				if( pDep->GetFileKey() != lFileKey )
				{
					pFile = aFileTab.GetFile( pDep->GetFileKey() );
					if( pFile )
					{
						fprintf( fOutput, "#include " );
						fprintf( fOutput, "\"%s\"\n",
								 pFile->aFileName.GetBuffer() );
					}
				}
				pDep = pFName->Next();
			};
		};
	};
}

/*************************************************************************
|*
|*	  RscTypCont :: Methoden die ueber all Knoten laufen
|*
|*	  Beschreibung		RES.DOC
|*	  Ersterstellung	MM 22.03.90
|*	  Letzte Aenderung	MM 09.12.91
|*
*************************************************************************/

class RscEnumerateObj
{
friend class RscEnumerateRef;
private:
	ERRTYPE 	aError; 	// Enthaelt den ersten Fehler
	RscTypCont* pTypCont;
	FILE *		fOutput;	// AusgabeDatei
	sal_uLong		lFileKey;	// Welche src-Datei
	RscTop *	pClass;

	DECL_LINK( CallBackWriteRc, ObjNode * );
	DECL_LINK( CallBackWriteSrc, ObjNode * );
	DECL_LINK( CallBackWriteCxx, ObjNode * );
	DECL_LINK( CallBackWriteHxx, ObjNode * );

	ERRTYPE WriteRc( RscTop * pCl, ObjNode * pRoot )
	{
		pClass = pCl;
		if( pRoot )
			pRoot->EnumNodes( LINK( this, RscEnumerateObj, CallBackWriteRc ) );
		return aError;
	}
	ERRTYPE WriteSrc( RscTop * pCl, ObjNode * pRoot ){
		pClass = pCl;
		if( pRoot )
			pRoot->EnumNodes( LINK( this, RscEnumerateObj, CallBackWriteSrc ) );
		return aError;
	}
	ERRTYPE WriteCxx( RscTop * pCl, ObjNode * pRoot ){
		pClass = pCl;
		if( pRoot )
			pRoot->EnumNodes( LINK( this, RscEnumerateObj, CallBackWriteCxx ) );
		return aError;
	}
	ERRTYPE WriteHxx( RscTop * pCl, ObjNode * pRoot ){
		pClass = pCl;
		if( pRoot )
			pRoot->EnumNodes( LINK( this, RscEnumerateObj, CallBackWriteHxx ) );
		return aError;
	}
public:
	void WriteRcFile( RscWriteRc & rMem, FILE * fOutput );
};

/*************************************************************************
|*
|*	  RscEnumerateObj :: CallBackWriteRc
|*
|*	  Beschreibung
|*	  Ersterstellung	MM 09.12.91
|*	  Letzte Aenderung	MM 09.12.91
|*
*************************************************************************/
IMPL_LINK( RscEnumerateObj, CallBackWriteRc, ObjNode *, pObjNode )
{
	RscWriteRc		aMem( pTypCont->GetByteOrder() );

	aError = pClass->WriteRcHeader( RSCINST( pClass, pObjNode->GetRscObj() ),
									 aMem, pTypCont,
									 pObjNode->GetRscId(), 0, sal_True );
	if( aError.IsError() || aError.IsWarning() )
		pTypCont->pEH->Error( aError, pClass, pObjNode->GetRscId() );

	WriteRcFile( aMem, fOutput );
	return 0;
}

/*************************************************************************
|*
|*	  RscEnumerateObj :: CallBackWriteSrc
|*
|*	  Beschreibung
|*	  Ersterstellung	MM 09.12.91
|*	  Letzte Aenderung	MM 09.12.91
|*
*************************************************************************/
IMPL_LINK_INLINE_START( RscEnumerateObj, CallBackWriteSrc, ObjNode *, pObjNode )
{
	if( pObjNode->GetFileKey() == lFileKey ){
		pClass->WriteSrcHeader( RSCINST( pClass, pObjNode->GetRscObj() ),
								fOutput, pTypCont, 0,
								pObjNode->GetRscId(), "" );
		fprintf( fOutput, ";\n" );
	}
	return 0;
}
IMPL_LINK_INLINE_END( RscEnumerateObj, CallBackWriteSrc, ObjNode *, pObjNode )

/*************************************************************************
|*
|*	  RscEnumerateObj :: CallBackWriteCxx
|*
|*	  Beschreibung
|*	  Ersterstellung	MM 09.12.91
|*	  Letzte Aenderung	MM 09.12.91
|*
*************************************************************************/
IMPL_LINK_INLINE_START( RscEnumerateObj, CallBackWriteCxx, ObjNode *, pObjNode )
{
	if( pClass->IsCodeWriteable() && pObjNode->GetFileKey() == lFileKey )
		aError = pClass->WriteCxxHeader(
							  RSCINST( pClass, pObjNode->GetRscObj() ),
							  fOutput, pTypCont, pObjNode->GetRscId() );
	return 0;
}
IMPL_LINK_INLINE_END( RscEnumerateObj, CallBackWriteCxx, ObjNode *, pObjNode )

/*************************************************************************
|*
|*	  RscEnumerateObj :: CallBackWriteHxx
|*
|*	  Beschreibung
|*	  Ersterstellung	MM 09.12.91
|*	  Letzte Aenderung	MM 09.12.91
|*
*************************************************************************/
IMPL_LINK_INLINE_START( RscEnumerateObj, CallBackWriteHxx, ObjNode *, pObjNode )
{
	if( pClass->IsCodeWriteable() && pObjNode->GetFileKey() == lFileKey )
		aError = pClass->WriteHxxHeader(
							  RSCINST( pClass, pObjNode->GetRscObj() ),
							  fOutput, pTypCont, pObjNode->GetRscId() );
	return 0;
}
IMPL_LINK_INLINE_END( RscEnumerateObj, CallBackWriteHxx, ObjNode *, pObjNode )

/*************************************************************************
|*
|*	  RscEnumerateObj :: WriteRcFile
|*
|*	  Beschreibung
|*	  Ersterstellung	MM 09.12.91
|*	  Letzte Aenderung	MM 09.12.91
|*
*************************************************************************/
void RscEnumerateObj :: WriteRcFile( RscWriteRc & rMem, FILE * fOut ){
	// Definition der Struktur, aus denen die Resource aufgebaut ist
	/*
	struct RSHEADER_TYPE{
		sal_uInt32			nId;		// Identifier der Resource
		sal_uInt32			nRT;		// Resource Typ
		sal_uInt32			nGlobOff;	// Globaler Offset
		sal_uInt32			nLocalOff;	// Lokaler Offset
	} aHeader;
	*/

	sal_uInt32 nId = rMem.GetLong( 0 );
	sal_uInt32 nRT = rMem.GetLong( 4 );

	// Tabelle wird entsprechend gefuellt
	pTypCont->PutTranslatorKey( (sal_uInt64(nRT) << 32) + sal_uInt64(nId) );

	if( nRT == RSC_VERSIONCONTROL )
	{ // kommt immmer als letztes
		sal_Int32 nCount = pTypCont->aIdTranslator.size();
		// groesse der Tabelle
		sal_uInt32 nSize = (nCount * (sizeof(sal_uInt64)+sizeof(sal_Int32))) + sizeof(sal_Int32);

		rMem.Put( nCount ); //Anzahl speichern
        for( std::map< sal_uInt64, sal_uLong >::const_iterator it =
             pTypCont->aIdTranslator.begin(); it != pTypCont->aIdTranslator.end(); ++it )
		{
			// Schluessel schreiben
			rMem.Put( it->first );
			// Objekt Id oder Position schreiben
			rMem.Put( (sal_Int32)it->second );
		}
		rMem.Put( nSize ); // Groesse hinten Speichern
	}

	//Dateioffset neu setzen
	pTypCont->IncFilePos( rMem.Size() );


	//Position wurde vorher in Tabelle geschrieben
	fwrite( rMem.GetBuffer(), rMem.Size(), 1, fOut );

};

class RscEnumerateRef
{
private:
	RscTop *		pRoot;

	DECL_LINK( CallBackWriteRc, RscTop * );
	DECL_LINK( CallBackWriteSrc, RscTop * );
	DECL_LINK( CallBackWriteCxx, RscTop * );
	DECL_LINK( CallBackWriteHxx, RscTop * );
	DECL_LINK( CallBackWriteSyntax, RscTop * );
	DECL_LINK( CallBackWriteRcCtor, RscTop * );
public:
	RscEnumerateObj aEnumObj;

			RscEnumerateRef( RscTypCont * pTC, RscTop * pR,
							 FILE * fOutput )
			{
				aEnumObj.pTypCont = pTC;
				aEnumObj.fOutput  = fOutput;
				pRoot			  = pR;
			}
	ERRTYPE WriteRc()
	{
		aEnumObj.aError.Clear();
		pRoot->EnumNodes( LINK( this, RscEnumerateRef, CallBackWriteRc ) );
		return aEnumObj.aError;
	};

	ERRTYPE WriteSrc( sal_uLong lFileKey )
	{
		aEnumObj.lFileKey = lFileKey;

		aEnumObj.aError.Clear();
		pRoot->EnumNodes( LINK( this, RscEnumerateRef, CallBackWriteSrc ) );
		return aEnumObj.aError;
	}

	ERRTYPE WriteCxx( sal_uLong lFileKey )
	{
		aEnumObj.lFileKey = lFileKey;

		aEnumObj.aError.Clear();
		pRoot->EnumNodes( LINK( this, RscEnumerateRef, CallBackWriteCxx ) );
		return aEnumObj.aError;
	}

	ERRTYPE WriteHxx(  sal_uLong lFileKey )
	{
		aEnumObj.lFileKey = lFileKey;

		aEnumObj.aError.Clear();
		pRoot->EnumNodes( LINK( this, RscEnumerateRef, CallBackWriteHxx ) );
		return aEnumObj.aError;
	}

	void	WriteSyntax()
			{
				pRoot->EnumNodes( LINK( this, RscEnumerateRef,
										CallBackWriteSyntax ) );
			}

	void	WriteRcCtor()
			{
				pRoot->EnumNodes( LINK( this, RscEnumerateRef,
										CallBackWriteRcCtor ) );
			}
};

/*************************************************************************
|*
|*	  RscRscEnumerateRef :: CallBack...
|*
|*	  Beschreibung
|*	  Ersterstellung	MM 09.12.91
|*	  Letzte Aenderung	MM 09.12.91
|*
*************************************************************************/
IMPL_LINK_INLINE_START( RscEnumerateRef, CallBackWriteRc, RscTop *, pRef )
{
	aEnumObj.WriteRc( pRef, pRef->GetObjNode() );
	return 0;
}
IMPL_LINK_INLINE_END( RscEnumerateRef, CallBackWriteRc, RscTop *, pRef )
IMPL_LINK_INLINE_START( RscEnumerateRef, CallBackWriteSrc, RscTop *, pRef )
{
	aEnumObj.WriteSrc( pRef, pRef->GetObjNode() );
	return 0;
}
IMPL_LINK_INLINE_END( RscEnumerateRef, CallBackWriteSrc, RscTop *, pRef )
IMPL_LINK_INLINE_START( RscEnumerateRef, CallBackWriteCxx, RscTop *, pRef )
{
	if( pRef->IsCodeWriteable() )
		aEnumObj.WriteCxx( pRef, pRef->GetObjNode() );
	return 0;
}
IMPL_LINK_INLINE_END( RscEnumerateRef, CallBackWriteCxx, RscTop *, pRef )
IMPL_LINK_INLINE_START( RscEnumerateRef, CallBackWriteHxx, RscTop *, pRef )
{
	if( pRef->IsCodeWriteable() )
		aEnumObj.WriteHxx( pRef, pRef->GetObjNode() );
	return 0;
}
IMPL_LINK_INLINE_END( RscEnumerateRef, CallBackWriteHxx, RscTop *, pRef )
IMPL_LINK_INLINE_START( RscEnumerateRef, CallBackWriteSyntax, RscTop *, pRef )
{
	pRef->WriteSyntaxHeader( aEnumObj.fOutput, aEnumObj.pTypCont );
	return 0;
}
IMPL_LINK_INLINE_END( RscEnumerateRef, CallBackWriteSyntax, RscTop *, pRef )
IMPL_LINK_INLINE_START( RscEnumerateRef, CallBackWriteRcCtor, RscTop *, pRef )
{
	pRef->WriteRcCtor( aEnumObj.fOutput, aEnumObj.pTypCont );
	return 0;
}
IMPL_LINK_INLINE_END( RscEnumerateRef, CallBackWriteRcCtor, RscTop *, pRef )

/*************************************************************************
|*
|*	  RscTypCont :: WriteRc
|*
|*	  Beschreibung		RES.DOC
|*	  Ersterstellung	MM 22.03.90
|*	  Letzte Aenderung	MM 22.07.91
|*
*************************************************************************/

ERRTYPE RscTypCont::WriteRc( WriteRcContext& rContext )
{
	ERRTYPE 	  aError;
	RscEnumerateRef aEnumRef( this, pRoot, rContext.fOutput );

	aIdTranslator.clear();
	nFilePos = 0;
	nPMId = RSCVERSION_ID +1; //mindestens einen groesser

	aError = aEnumRef.WriteRc();

	// version control
	RscWriteRc aMem( nByteOrder );
	aVersion.pClass->WriteRcHeader( aVersion, aMem, this, RscId( RSCVERSION_ID ), 0, sal_True );
	aEnumRef.aEnumObj.WriteRcFile( aMem, rContext.fOutput );
		
	return aError;
}

/*************************************************************************
|*
|*	  RscTypCont :: WriteSrc
|*
|*	  Beschreibung		RES.DOC
|*	  Ersterstellung	MM 22.03.90
|*	  Letzte Aenderung	MM 27.06.90
|*
*************************************************************************/
void RscTypCont :: WriteSrc( FILE * fOutput, sal_uLong nFileKey,
							 CharSet /*nCharSet*/, sal_Bool bName )
{
	RscFile 	*	pFName;
	RscEnumerateRef aEnumRef( this, pRoot, fOutput );

    unsigned char aUTF8BOM[3] = { 0xef, 0xbb, 0xbf };
    fwrite( aUTF8BOM, sizeof(unsigned char), sizeof(aUTF8BOM)/sizeof(aUTF8BOM[0]), fOutput );
	if( bName )
	{
		WriteInc( fOutput, nFileKey );

		if( NOFILE_INDEX == nFileKey )
		{
			pFName = aFileTab.First();
			while( pFName  ){
				if( !pFName->IsIncFile() )
					pFName->aDefLst.WriteAll( fOutput );
				aEnumRef.WriteSrc( aFileTab.GetIndex( pFName ) );
				pFName = aFileTab.Next();
			};
		}
		else
		{
			pFName = aFileTab.Get( nFileKey );
			if( pFName ){
				pFName->aDefLst.WriteAll( fOutput );
				aEnumRef.WriteSrc( nFileKey );
			}
		}
	}
	else
	{
		RscId::SetNames( sal_False );
		if( NOFILE_INDEX == nFileKey )
		{
			pFName = aFileTab.First();
			while( pFName  )
			{
				aEnumRef.WriteSrc( aFileTab.GetIndex( pFName ) );
				pFName = aFileTab.Next();
			};
		}
		else
			 aEnumRef.WriteSrc( nFileKey );
		RscId::SetNames();
	};
}

/*************************************************************************
|*
|*	  RscTypCont :: WriteHxx
|*
|*	  Beschreibung
|*	  Ersterstellung	MM 30.05.91
|*	  Letzte Aenderung	MM 30.05.91
|*
*************************************************************************/
ERRTYPE RscTypCont :: WriteHxx( FILE * fOutput, sal_uLong nFileKey )
{
	fprintf( fOutput, "#include <tools/rc.hxx>\n" );
	fprintf( fOutput, "#include <tools/resid.hxx>\n" );
	fprintf( fOutput, "#include <vcl/accel.hxx>\n" );
	fprintf( fOutput, "#include <vcl/bitmap.hxx>\n" );
	fprintf( fOutput, "#include <vcl/button.hxx>\n" );
	fprintf( fOutput, "#include <tools/color.hxx>\n" );
	fprintf( fOutput, "#include <vcl/combobox.hxx>\n" );
	fprintf( fOutput, "#include <vcl/ctrl.hxx>\n" );
	fprintf( fOutput, "#include <vcl/dialog.hxx>\n" );
	fprintf( fOutput, "#include <vcl/edit.hxx>\n" );
	fprintf( fOutput, "#include <vcl/field.hxx>\n" );
	fprintf( fOutput, "#include <vcl/fixed.hxx>\n" );
	fprintf( fOutput, "#include <vcl/group.hxx>\n" );
	fprintf( fOutput, "#include <vcl/image.hxx>\n" );
	fprintf( fOutput, "#include <vcl/button.hxx>\n" );
	fprintf( fOutput, "#include <vcl/keycod.hxx>\n" );
	fprintf( fOutput, "#include <vcl/lstbox.hxx>\n" );
	fprintf( fOutput, "#include <vcl/mapmod.hxx>\n" );
	fprintf( fOutput, "#include <vcl/menu.hxx>\n" );
	fprintf( fOutput, "#include <vcl/menubtn.hxx>\n" );
	fprintf( fOutput, "#include <vcl/morebtn.hxx>\n" );
	fprintf( fOutput, "#include <vcl/msgbox.hxx>\n" );
	fprintf( fOutput, "#include <vcl/scrbar.hxx>\n" );
	fprintf( fOutput, "#include <vcl/spin.hxx>\n" );
	fprintf( fOutput, "#include <vcl/spinfld.hxx>\n" );
	fprintf( fOutput, "#include <vcl/splitwin.hxx>\n" );
	fprintf( fOutput, "#include <vcl/status.hxx>\n" );
	fprintf( fOutput, "#include <vcl/tabctrl.hxx>\n" );
	fprintf( fOutput, "#include <vcl/tabdlg.hxx>\n" );
	fprintf( fOutput, "#include <vcl/tabpage.hxx>\n" );
	fprintf( fOutput, "#include <vcl/toolbox.hxx>\n" );
	fprintf( fOutput, "#include <vcl/window.hxx>\n" );
	fprintf( fOutput, "#include <vcl/wrkwin.hxx>\n" );
	fprintf( fOutput, "#include <svtools/svmedit.hxx>\n" );

	RscEnumerateRef aEnumRef( this, pRoot, fOutput );
	ERRTYPE 		aError;

	if( NOFILE_INDEX == nFileKey )
	{
		RscFile 	*	pFName;

		pFName = aFileTab.First();
		while( pFName  )
		{
			aError = aEnumRef.WriteHxx( aFileTab.GetIndex( pFName ) );
			pFName = aFileTab.Next();
		};
	}
	else
		aError = aEnumRef.WriteHxx( nFileKey );

	return aError;
}

/*************************************************************************
|*
|*	  RscTypCont :: WriteCxx
|*
|*	  Beschreibung
|*	  Ersterstellung	MM 30.05.91
|*	  Letzte Aenderung	MM 30.05.91
|*
*************************************************************************/
ERRTYPE RscTypCont::WriteCxx( FILE * fOutput, sal_uLong nFileKey,
							  const ByteString & rHxxName )
{
	RscEnumerateRef aEnumRef( this, pRoot, fOutput );
	ERRTYPE 		aError;
	fprintf( fOutput, "#include <string.h>\n" );
	WriteInc( fOutput, nFileKey );
	if( rHxxName.Len() )
		fprintf( fOutput, "#include \"%s\"\n", rHxxName.GetBuffer() );
	fprintf( fOutput, "\n\n" );

	if( NOFILE_INDEX == nFileKey )
	{
		RscFile 	*	pFName;

		pFName = aFileTab.First();
		while( pFName  )
		{
			aError = aEnumRef.WriteCxx( aFileTab.GetIndex( pFName ) );
			pFName = aFileTab.Next();
		};
	}
	else
		aError = aEnumRef.WriteCxx( nFileKey );

	return aError;
}

/*************************************************************************
|*
|*	  RscTypCont :: WriteSyntax
|*
|*	  Beschreibung
|*	  Ersterstellung	MM 30.05.91
|*	  Letzte Aenderung	MM 30.05.91
|*
*************************************************************************/
void RscTypCont::WriteSyntax( FILE * fOutput )
{
	for( sal_uInt32 i = 0; i < aBaseLst.Count(); i++ )
		aBaseLst.GetObject( i )->WriteSyntaxHeader( fOutput, this );
	RscEnumerateRef aEnumRef( this, pRoot, fOutput );
	aEnumRef.WriteSyntax();
}

//=======================================================================
void RscTypCont::WriteRcCtor
(
	FILE * fOutput
)
{
	RscEnumerateRef aEnumRef( this, pRoot, fOutput );
	aEnumRef.WriteRcCtor();
}

/*************************************************************************
|*
|*	  RscTypCont :: Delete()
|*
|*	  Beschreibung
|*	  Ersterstellung	MM 09.12.91
|*	  Letzte Aenderung	MM 09.12.91
|*
*************************************************************************/
class RscDel
{
	sal_uLong lFileKey;
	DECL_LINK( Delete, RscTop * );
public:
	RscDel( RscTop * pRoot, sal_uLong lKey );
};


inline RscDel::RscDel( RscTop * pRoot, sal_uLong lKey )
{
	lFileKey = lKey;
	pRoot->EnumNodes( LINK( this, RscDel, Delete ) );
}

IMPL_LINK_INLINE_START( RscDel, Delete, RscTop *, pNode )
{
	if( pNode->GetObjNode() )
		pNode->pObjBiTree = pNode->GetObjNode()->DelObjNode( pNode, lFileKey );
	return 0;
}
IMPL_LINK_INLINE_END( RscDel, Delete, RscTop *, pNode )

void RscTypCont :: Delete( sal_uLong lFileKey ){
	// Resourceinstanzen loeschen
	RscDel aDel( pRoot, lFileKey );
	// Defines loeschen
	aFileTab.DeleteFileContext( lFileKey );
}

/*************************************************************************
|*
|*	  RscTypCont :: MakeConsistent()
|*
|*	  Beschreibung
|*	  Ersterstellung	MM 23.09.91
|*	  Letzte Aenderung	MM 23.09.91
|*
*************************************************************************/
sal_Bool IsInstConsistent( ObjNode * pObjNode, RscTop * pRscTop,
					   RscInconsList * pList )
{
	sal_Bool bRet = sal_True;

	if( pObjNode ){
		RSCINST aTmpI;

		if( ! IsInstConsistent( (ObjNode*)pObjNode->Left(), pRscTop, pList ) )
			bRet = sal_False;

		aTmpI.pClass = pRscTop;
		aTmpI.pData = pObjNode->GetRscObj();
		if( ! aTmpI.pClass->IsConsistent( aTmpI, pList ) )
			bRet = sal_False;

		if( ! IsInstConsistent( (ObjNode*)pObjNode->Right(), pRscTop, pList ) )
			bRet = sal_False;
	};

	return( bRet );
}

sal_Bool MakeConsistent( RscTop * pRscTop, RscInconsList * pList )
{
	sal_Bool bRet = sal_True;

	if( pRscTop ){
		if( ! ::MakeConsistent( (RscTop*)pRscTop->Left(), pList ) )
			bRet = sal_False;

		if( pRscTop->GetObjNode() ){
			if( ! pRscTop->GetObjNode()->IsConsistent() ){
				pRscTop->GetObjNode()->OrderTree();
				if( ! pRscTop->GetObjNode()->IsConsistent( pList ) )
					bRet = sal_False;
			}
			if( ! IsInstConsistent( pRscTop->GetObjNode(), pRscTop, pList ) )
				bRet = sal_False;
		}

		if( ! ::MakeConsistent( (RscTop*)pRscTop->Right(), pList ) )
			bRet = sal_False;
	};

	return bRet;
}

sal_Bool RscTypCont :: MakeConsistent( RscInconsList * pList ){
	return( ::MakeConsistent( pRoot, pList ) );
}

sal_uInt32 RscTypCont::PutTranslatorKey( sal_uInt64 nKey )
{
    aIdTranslator[ nKey ] = nFilePos;
	return nPMId++;
}