xref: /AOO41X/main/soldep/bootstrp/prj.cxx (revision d9e04f7d457e8d4292f3a8dc854ee7656a676fbb)

/**************************************************************
 *
 * 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.
 *
 *************************************************************/


#include <stdlib.h>
#include <stdio.h>
#include <soldep/sstring.hxx>
#include <vos/mutex.hxx>

#define ENABLE_BYTESTRING_STREAM_OPERATORS
#include <tools/stream.hxx>
#include <tools/geninfo.hxx>
#include <soldep/prj.hxx>
//#include <bootstrp/inimgr.hxx>

#ifndef MACOSX
#pragma hdrstop
#endif

//#define TEST 	1

#if defined(WNT) || defined(OS2)
#define LIST_DELIMETER ';'
#else
#ifdef UNX
#define LIST_DELIMETER ':'
#else
#endif
#endif

#if defined(WNT) || defined(OS2)
#define PATH_DELIMETER '\\'
#else
#ifdef UNX
#define PATH_DELIMETER '/'
#else
#endif
#endif

//static const char * XML_ALL  =	"all";

//
//	class SimpleConfig
//

/*****************************************************************************/
SimpleConfig::SimpleConfig( String aSimpleConfigFileName )
/*****************************************************************************/
{
	nLine = 0;
	aFileName = aSimpleConfigFileName;
	aFileStream.Open ( aFileName, STREAM_READ );
}

/*****************************************************************************/
SimpleConfig::SimpleConfig( DirEntry& rDirEntry )
/*****************************************************************************/
{
	nLine = 0;
	aFileName = rDirEntry.GetFull();
	aFileStream.Open ( aFileName, STREAM_READ );
}

/*****************************************************************************/
SimpleConfig::~SimpleConfig()
/*****************************************************************************/
{
	aFileStream.Close ();
}

/*****************************************************************************/
ByteString SimpleConfig::GetNext()
/*****************************************************************************/
{
	ByteString aString;

	if ( aStringBuffer =="" )
	  while ((aStringBuffer = GetNextLine()) == "\t"); //solange bis != "\t"
	if ( aStringBuffer =="" )
		return ByteString();

	aString = aStringBuffer.GetToken(0,'\t');
	aStringBuffer.Erase(0, aString.Len()+1);

	aStringBuffer.EraseLeadingChars( '\t' );

	return aString;
}

/*****************************************************************************/
ByteString	SimpleConfig::GetNextLine()
/*****************************************************************************/
{
	ByteString aSecStr;
    sal_Bool bStreamOk;
//	sal_uInt16 iret = 0;
	nLine++;

	bStreamOk = aFileStream.ReadLine ( aTmpStr );
	if ( (aTmpStr.Search( "#" ) == 0) )
		return "\t";
	aTmpStr = aTmpStr.EraseLeadingChars();
	aTmpStr = aTmpStr.EraseTrailingChars();
	while ( aTmpStr.SearchAndReplace(ByteString(' '),ByteString('\t') ) != STRING_NOTFOUND );
	int nLength = aTmpStr.Len();
    if ( bStreamOk && (nLength == 0) )
		return "\t";
//	sal_uInt16 nPos = 0;
	sal_Bool bFound = sal_False;
	ByteString aEraseString;
	for ( sal_uInt16 i = 0; i<= nLength; i++)
	{
		if ( aTmpStr.GetChar( i ) == 0x20  && !bFound )
			aTmpStr.SetChar( i, 0x09 );
	}
	return aTmpStr;
}

/*****************************************************************************/
ByteString SimpleConfig::GetCleanedNextLine( sal_Bool bReadComments )
/*****************************************************************************/
{
	sal_Bool bStreamOk;
	sal_Bool bReadNextLine = sal_True;
	while (bReadNextLine)
	{
		bStreamOk = aFileStream.ReadLine ( aTmpStr );
		if (!bStreamOk)
			return ByteString();

		ByteString sTab = "\t";
		ByteString sDoubleTab = "\t\t";
		ByteString sSpace = " ";
		xub_StrLen nIndex = 0;

		aTmpStr.SearchAndReplaceAll(sSpace, sTab);
		while ( (nIndex = aTmpStr.SearchAndReplace(sDoubleTab, sTab, nIndex )) != STRING_NOTFOUND );

		aTmpStr = aTmpStr.EraseLeadingAndTrailingChars('\t'); // remove tabs

		if ( aTmpStr.Search( "#" ) == 0 )
		{
			if (bReadComments )
				return aTmpStr;
		}
        else if (aTmpStr != ByteString::EmptyString())
			bReadNextLine = sal_False;
	}

	return aTmpStr;
}


//
//	class CommandData
//

/*****************************************************************************/
CommandData::CommandData()
/*****************************************************************************/
{
	nOSType = 0;
	nCommand = 0;
	pDepList = 0;
	pCommandList = 0;
}

/*****************************************************************************/
CommandData::~CommandData()
/*****************************************************************************/
{
	if ( pDepList )
	{
		ByteString *pString = pDepList->First();
		while ( pString )
		{
			delete pString;
			pString = pDepList->Next();
		}
		delete pDepList;

		pDepList = NULL;
	}
	if ( pCommandList )
	{
		ByteString *pString = pCommandList->First();
		while ( pString )
		{
			delete pString;
			pString = pCommandList->Next();
		}
		delete pCommandList;

		pCommandList = NULL;
	}
}

/*****************************************************************************/
ByteString CommandData::GetOSTypeString()
/*****************************************************************************/
{
	ByteString aRetStr;

	switch (nOSType)
	{
		case OS_WIN16 | OS_WIN32 | OS_OS2 | OS_UNX | OS_MAC :
			aRetStr = "all";
			break;
		case OS_WIN32 | OS_WIN16 :
			aRetStr = "w";
			break;
		case OS_OS2 :
			aRetStr = "p";
			break;
		case OS_UNX :
			aRetStr = "u";
			break;
		case OS_WIN16 :
			aRetStr = "d";
			break;
		case OS_WIN32 :
			aRetStr = "n";
			break;
		case OS_MAC :
			aRetStr = "m";
			break;
		default :
			aRetStr = "none";
	}

	return aRetStr;
}

/*****************************************************************************/
ByteString CommandData::GetCommandTypeString()
/*****************************************************************************/
{
	ByteString aRetStr;

	switch (nCommand)
	{
		case COMMAND_NMAKE :
			aRetStr = "nmake";
			break;
		case COMMAND_GET :
			aRetStr = "get";
			break;
		default :
			aRetStr = "usr";
			aRetStr += ByteString::CreateFromInt64( nCommand + 1 - COMMAND_USER_START );

	}

	return aRetStr;
}

/*****************************************************************************/
void CommandData::AddCommand(ByteString* pCommand)
/*****************************************************************************/
{
	if (!pCommandList)
		pCommandList = new SByteStringList();
	pCommandList->Insert(pCommand, LIST_APPEND);
}

/*****************************************************************************/
CommandData& CommandData::operator>>  ( SvStream& rStream )
/*****************************************************************************/
{
	rStream << aPrj;
	rStream << aLogFileName;
	rStream << aInpath;
	rStream << aUpd;
	rStream << aUpdMinor;
	rStream << aProduct;
	rStream << aCommand;
	rStream << aPath;
	rStream << aPrePath;
	rStream << aPreFix;
	rStream << aCommandPara;
	rStream << aComment;
	rStream << sClientRestriction;

	rStream << nOSType;
	rStream << nCommand;
	rStream << nDepth;

	if (pDepList)
	{
		rStream << sal_True;
		*pDepList >> rStream;
	}
	else
		rStream << sal_False;

	if (pCommandList)
	{
		rStream << sal_True;
		*pCommandList >> rStream;
	}
	else
		rStream << sal_False;

	return *this;
}

/*****************************************************************************/
CommandData& CommandData::operator<<  ( SvStream& rStream )
/*****************************************************************************/
{
	rStream >> aPrj;
	rStream >> aLogFileName;
	rStream >> aInpath;
	rStream >> aUpd;
	rStream >> aUpdMinor;
	rStream >> aProduct;
	rStream >> aCommand;
	rStream >> aPath;
	rStream >> aPrePath;
	rStream >> aPreFix;
	rStream >> aCommandPara;
	rStream >> aComment;
	rStream >> sClientRestriction;

	rStream >> nOSType;
	rStream >> nCommand;
	rStream >> nDepth;

	sal_Bool bDepList;
	rStream >> bDepList;
	if (pDepList)
		pDepList->CleanUp();
	if (bDepList)
	{
		if (!pDepList)
			pDepList = new SByteStringList();
		*pDepList << rStream;
	}
	else
	{
		if (pDepList)
		DELETEZ (pDepList);
	}

	sal_Bool bCommandList;
	rStream >> bCommandList;
	if (pCommandList)
		pCommandList->CleanUp();
	if (bCommandList)
	{
		if (!pCommandList)
			pCommandList = new SByteStringList();
		*pCommandList << rStream;
	}
	else
	{
		if (pCommandList)
			DELETEZ (pCommandList);
	}

	return *this;
}



//
// class DepInfo
//

/*****************************************************************************/
DepInfo::~DepInfo()
/*****************************************************************************/
{
	RemoveProject();

	if ( pModeList )
	{
		ByteString *pString = pModeList->First();
		while ( pString )
		{
			delete pString;
			pString = pModeList->Next();
		}
		delete pModeList;

		pModeList = NULL;
	}
}

/*****************************************************************************/
void DepInfo::SetProject (ByteString* pStr)
/*****************************************************************************/
{
	RemoveProject();
	pProject = pStr;
}

/*****************************************************************************/
void DepInfo::RemoveProject ()
/*****************************************************************************/
{
	if (pProject)
	{
		delete pProject;
		pProject = NULL;
	}
}

/*****************************************************************************/
DepInfo& DepInfo::operator<<  ( SvStream& rStream )
/*****************************************************************************/
{
	RemoveProject();
	pProject = new ByteString();
	rStream >> *pProject;

	sal_Bool bModeList;
	rStream >> bModeList;
	if (pModeList)
		pModeList->CleanUp();
	if (bModeList)
	{
		if (!pModeList)
			pModeList = new SByteStringList();
		*pModeList << rStream;
	}
	else
		DELETEZ (pModeList);

	rStream >> bAllModes;
	return *this;
}

/*****************************************************************************/
DepInfo& DepInfo::operator>>  ( SvStream& rStream )
/*****************************************************************************/
{
	rStream << *pProject;
	if (pModeList)
	{
		rStream << sal_True;
		*pModeList >> rStream;
	}
	else
		rStream << sal_False;
	rStream << bAllModes;

	return *this;
}

//
// class SDepInfoList
//

/*****************************************************************************/
SDepInfoList::SDepInfoList()
/*****************************************************************************/
								: pAllModeList(0)
{
}

/*****************************************************************************/
SDepInfoList::~SDepInfoList()
/*****************************************************************************/
{
	if (pAllModeList)
		delete pAllModeList;
}

/*****************************************************************************/
sal_uIntPtr SDepInfoList::IsString( ByteString* pStr )
/*****************************************************************************/
{
	sal_uIntPtr nRet = NOT_THERE;
	if ( (nRet = GetPrevString( pStr )) != 0 )
	{
		ByteString* pString = GetObject( nRet )->GetProject();
		if ( *pString == *pStr )
			return nRet;
		else
			return NOT_THERE;
	}
	else
	{
		ByteString* pString = GetObject( 0 )->GetProject();
		if ( pString && (*pString == *pStr) )
			return 0;
		else
			return NOT_THERE;
	}
	return nRet;
}

/*****************************************************************************/
sal_uIntPtr SDepInfoList::GetPrevString( ByteString* pStr )
/*****************************************************************************/
{
	sal_uIntPtr nRet = 0;
	sal_Bool bFound = sal_False;
	sal_uIntPtr nCount_l = Count();
	sal_uIntPtr nUpper = nCount_l;
	sal_uIntPtr nLower = 0;
	sal_uIntPtr nCurrent = nUpper / 2;
	sal_uIntPtr nRem = 0;
	ByteString* pString;

	do
	{
		if ( (nCurrent == nLower) || (nCurrent == nUpper) )
			return nLower;
		pString = GetObject( nCurrent )->GetProject();
		int nResult =  pStr->CompareTo( *pString );
		if ( nResult == COMPARE_LESS )
		{
			nUpper = nCurrent;
			nCurrent = (nCurrent + nLower) /2;
		}
		else if ( nResult == COMPARE_GREATER )
		{
			nLower = nCurrent;
			nCurrent = (nUpper + nCurrent) /2;
		}
		else if ( nResult == COMPARE_EQUAL )
			return nCurrent;
		if ( nRem == nCurrent )
			return nCurrent;
		nRem = nCurrent;
	}
	while ( !bFound );
	return nRet;
}

/*****************************************************************************/
void SDepInfoList::PutModeString( DepInfo* pInfoList, ByteString* pStr )
/*****************************************************************************/
{
	SByteStringList* pList = pInfoList->GetModeList();
	if (!pList)
	{
		pList = new SByteStringList;
		pInfoList->SetModeList(pList);

	}

	if (pList)
	{
		// check if string exists
		ByteString *pString = pList->First();
		while ( pString )
		{
			if (*pString == *pStr)
			{
				delete pStr;
				return;
			}
			pString = pList->Next();
		}
		pList->PutString( pStr );
	}
	else
		delete pStr;
}

/*****************************************************************************/
sal_uIntPtr SDepInfoList::PutString( ByteString* pStr)
/*****************************************************************************/
{
	return PutString( pStr, NULL);
}

/**************************************************************************
*
*	Sortiert einen ByteString in die Liste ein und gibt die Position,
*	an der einsortiert wurde, zurueck
*
**************************************************************************/

sal_uIntPtr SDepInfoList::PutString( ByteString* pStr, ByteString* pModeStr)
{
	if (pAllModeList)
	{
		delete pAllModeList;
		pAllModeList = NULL;
	}

	sal_uIntPtr nPos = GetPrevString ( pStr );
	if ( Count() )
	{
		{
			DepInfo* pInfo = GetObject( 0 );
			ByteString* pString = pInfo->GetProject();
			if ( pString->CompareTo( *pStr ) == COMPARE_GREATER )
			{
				pInfo = new DepInfo;
				if (pInfo)
				{
					pInfo->SetProject(pStr);
					if (pModeStr)
						PutModeString(pInfo, pModeStr);
					else
						pInfo->SetAllModes();
					Insert( pInfo, (sal_uIntPtr)0 );
				}
				return (sal_uIntPtr)0;
			}
		}
		ByteString* pString = GetObject( nPos )->GetProject();
		if ( *pStr != *pString )
		{
			DepInfo* pInfo = new DepInfo;
			if (pInfo)
			{
				pInfo->SetProject(pStr);
				if (pModeStr)
					PutModeString(pInfo, pModeStr);
				else
					pInfo->SetAllModes();
				Insert( pInfo, nPos+1 );
			}
			return ( nPos +1 );
		}
		else
		{
			delete pStr;
			DepInfo* pInfo = GetObject( nPos );
			if (pModeStr)
				PutModeString(pInfo, pModeStr);
			else
				pInfo->SetAllModes();
			return ( nPos +1 );
		}
	}
	else
	{
		DepInfo* pInfo = new DepInfo;
		if (pInfo)
		{
			pInfo->SetProject(pStr);
			if (pModeStr)
				PutModeString(pInfo, pModeStr);
			else
				pInfo->SetAllModes();
			Insert( pInfo);
			return (sal_uIntPtr)0;
		}
	}

	delete pStr;
	if (pModeStr)
		delete pModeStr;
	return NOT_THERE;
}

/*****************************************************************************/
ByteString* SDepInfoList::RemoveString( const ByteString& rName )
/*****************************************************************************/
{
	sal_uIntPtr i;
	ByteString* pReturn;
	if (pAllModeList)
	{
		delete pAllModeList;
		pAllModeList = NULL;
	}

	for( i = 0 ; i < Count(); i++ )
	{
		if ( rName == *(GetObject( i )->GetProject()) )
		{
			pReturn = new ByteString(*(GetObject(i)->GetProject()));
			DepInfo* pInfo;
			pInfo = GetObject(i);
			delete pInfo;
			Remove(i);
			return pReturn;
		}
	}

	return NULL;
}

/*****************************************************************************/
SByteStringList* SDepInfoList::GetAllDepModes()
/*****************************************************************************/
{
	if (pAllModeList)
			return pAllModeList;

	DepInfo *pInfo = First();
	while ( pInfo )
	{
		if (!pInfo->IsAllModes() && pInfo->GetModeList())
		{
			if (!pAllModeList)
				pAllModeList = new SByteStringList();
			ByteString* pStr = pInfo->GetModeList()->First();
			while (pStr)
			{
				if (pAllModeList->IsString(pStr) == NOT_THERE)
					pAllModeList->PutString(pStr);
				pStr = pInfo->GetModeList()->Next();
			}
		}
		pInfo = Next();
	}
	return pAllModeList;
}

/*****************************************************************************/
SDepInfoList& SDepInfoList::operator<< ( SvStream& rStream )
/*****************************************************************************/
{
	sal_uIntPtr nCount_l;
	rStream >> nCount_l;
	for ( sal_uInt16 i = 0; i < nCount_l; i++ ) {
        DepInfo* pDepInfo = new DepInfo();
        *pDepInfo << rStream;
        Insert (pDepInfo, LIST_APPEND);
    }
	return *this;
}

/*****************************************************************************/
SDepInfoList& SDepInfoList::operator>> ( SvStream& rStream )
/*****************************************************************************/
{
	sal_uIntPtr nCount_l = Count();
	rStream << nCount_l;
	DepInfo* pDepInfo = First();
	while (pDepInfo) {
		*pDepInfo >> rStream;
		pDepInfo = Next();
	}

	return *this;
}

/*****************************************************************************/
CommandData* Prj::GetDirectoryList ( sal_uInt16 nWhatOS, sal_uInt16 nCommand )
/*****************************************************************************/
{
	return (CommandData *)NULL;
}

/*****************************************************************************/
CommandData* Prj::GetDirectoryData( ByteString aLogFileName )
/*****************************************************************************/
{
	PrjList* pPrjList = GetCommandDataList ();
	CommandData *pData = NULL;
	sal_uIntPtr nCount_l = pPrjList->Count();
	for ( sal_uIntPtr i=0; i<nCount_l; i++ )
	{
		pData = pPrjList->GetObject(i);
		if ( pData->GetLogFile() == aLogFileName )
			return pData;
	}
	return NULL;
}

//
//	class Prj
//

/*****************************************************************************/
Prj::Prj() :
	pPrjInitialDepList(0),
	pPrjDepList(0),
	pPrjDepInfoList(0),
	bSorted( sal_False ),
	bHardDependencies( sal_False ),
	bFixedDependencies( sal_False ),
	bVisited( sal_False ),
	bIsAvailable( sal_True ),
	pTempCommandDataList (0),
	bTempCommandDataListPermanent (sal_False),
	bError (sal_False)
/*****************************************************************************/
{
}

/*****************************************************************************/
Prj::Prj( ByteString aName ) :
	aProjectName( aName ),
	pPrjInitialDepList(0),
	pPrjDepList(0),
	pPrjDepInfoList(0),
	bSorted( sal_False ),
	bHardDependencies( sal_False ),
	bFixedDependencies( sal_False ),
	bVisited( sal_False ),
	bIsAvailable( sal_True ),
	pTempCommandDataList (0),
	bTempCommandDataListPermanent (sal_False),
	bError (sal_False)
/*****************************************************************************/
{
}

/*****************************************************************************/
Prj::~Prj()
/*****************************************************************************/
{
	pPrjDepList = RemoveStringList (pPrjDepList);
	pPrjInitialDepList = RemoveStringList (pPrjInitialDepList);
	pPrjDepInfoList = RemoveDepInfoList (pPrjDepInfoList);
}

/*****************************************************************************/
SByteStringList* Prj::RemoveStringList(SByteStringList* pStringList )
/*****************************************************************************/
{
	if ( pStringList )
	{
		ByteString *pString = pStringList->First();
		while ( pString )
		{
			delete pString;
			pString = pStringList->Next();
		}

		delete pStringList;

		pStringList = NULL;
	}
	return pStringList;
}

/*****************************************************************************/
SDepInfoList* Prj::RemoveDepInfoList(SDepInfoList* pInfoList )
/*****************************************************************************/
{
	if ( pInfoList )
	{
		DepInfo *pInfo = pInfoList->First();
		while ( pInfo )
		{
			delete pInfo;
			pInfo = pInfoList->Next();
		}

		delete pInfoList;

		pInfoList = NULL;
	}
	return pInfoList;
}

/*****************************************************************************/
void Prj::AddDependencies( ByteString aStr )
/*****************************************************************************/
{

	if ( !pPrjDepInfoList )
		pPrjDepInfoList = new SDepInfoList;

	pPrjDepInfoList->PutString( new ByteString(aStr) );
}

/*****************************************************************************/
void Prj::AddDependencies( ByteString aStr, ByteString aModeStr )
/*****************************************************************************/
{

	// needs dirty flag - not expanded
	if ( !pPrjDepInfoList )
		pPrjDepInfoList = new SDepInfoList;

	pPrjDepInfoList->PutString( new ByteString(aStr), new ByteString(aModeStr) );
}

/*****************************************************************************/
SByteStringList* Prj::GetDependencies( sal_Bool bExpanded )
/*****************************************************************************/
{
	if ( bExpanded )
	{
		if (!pPrjDepList)
			SetMode (NULL);
		return pPrjDepList;
	}
	else
	{
		if (!pPrjInitialDepList)
			SetMode (NULL);
		return pPrjInitialDepList;
	}
}

/*****************************************************************************/
void Prj::SetMode(SByteStringList* pModList)
/*****************************************************************************/
{
	pPrjDepList = RemoveStringList (pPrjDepList);
	pPrjInitialDepList = RemoveStringList (pPrjInitialDepList);

	if (!pPrjDepInfoList)
		return;

	pPrjDepList = new SByteStringList;
	pPrjInitialDepList = new SByteStringList;

	DepInfo *pInfo = pPrjDepInfoList->First();
	while ( pInfo )
	{
		if (pInfo->IsAllModes() || !pInfo->GetModeList() || !pModList)
		{
			pPrjDepList->PutString( new ByteString((ByteString) *(pInfo->GetProject())));
			pPrjInitialDepList->PutString( new ByteString((ByteString) *(pInfo->GetProject())));
			//pPrjDepList->PutString( pInfo->GetProject());
			//pPrjInitialDepList->PutString( pInfo->GetProject());
		}
		else
		{
			sal_Bool bStringFound = sal_False;
			SByteStringList * pDepList = pInfo->GetModeList();
			ByteString *pModString = pDepList->First();
			while ( pModString )
			{
				ByteString *pDefModString = pModList->First();
				while ( pDefModString )
				{
					if (*pDefModString == *pModString)
					{
						pPrjDepList->PutString( new ByteString((ByteString) *(pInfo->GetProject())));
						pPrjInitialDepList->PutString( new ByteString((ByteString) *(pInfo->GetProject())));
						//pPrjDepList->PutString( pInfo->GetProject());
						//pPrjInitialDepList->PutString( pInfo->GetProject());
						bStringFound = sal_True;
						break;
					}
					pDefModString = pModList->Next();
				}
				if (bStringFound)
					break;
				pModString = pDepList->Next();
			}

		}

		pInfo = pPrjDepInfoList->Next();
	}
}

/*****************************************************************************/
sal_Bool Prj::InsertDirectory ( ByteString aDirName, sal_uInt16 aWhat,
								sal_uInt16 aWhatOS, ByteString aLogFileName,
								const ByteString &rClientRestriction )
/*****************************************************************************/
{
	CommandData* pData = new CommandData();

	pData->SetPath( aDirName );
	pData->SetCommandType( aWhat );
	pData->SetOSType( aWhatOS );
	pData->SetLogFile( aLogFileName );
	pData->SetClientRestriction( rClientRestriction );

	PrjList* pPrjList = GetCommandDataList ();
	pPrjList->Insert( pData );

	return sal_False;
}

/*****************************************************************************/
//
// removes directory and existing dependencies on it
//
CommandData* Prj::RemoveDirectory ( ByteString aLogFileName )
/*****************************************************************************/
{
	PrjList* pPrjList = GetCommandDataList ();
	sal_uIntPtr nCount_l = pPrjList->Count();
	CommandData* pData;
	CommandData* pDataFound = NULL;
	SByteStringList* pDataDeps;

	for ( sal_uInt16 i = 0; i < nCount_l; i++ )
	{
		pData = pPrjList->GetObject( i );
		if ( pData->GetLogFile() == aLogFileName )
			pDataFound = pData;
		else
		{
			pDataDeps = pData->GetDependencies();
			if ( pDataDeps )
			{
				ByteString* pString;
				sal_uIntPtr nDataDepsCount = pDataDeps->Count();
				for ( sal_uIntPtr j = nDataDepsCount; j > 0; j-- )
				{
					pString = pDataDeps->GetObject( j - 1 );
					if ( pString->GetToken( 0, '.') == aLogFileName )
						pDataDeps->Remove( pString );
				}
			}
		}
	}

	Remove( pDataFound );

	return pDataFound;
}

/*****************************************************************************/
void Prj::ExtractDependencies()
/*****************************************************************************/
{
	sal_uIntPtr nPos = 0;
	CommandData* pData = GetObject(nPos);
	while (pData)
	{
		SByteStringList* pDepList = pData->GetDependencies();
		if (pDepList)
		{
			ByteString * pDepStr = pDepList->First();
			while (pDepStr)
			{
				CommandData* pSearchData = First();
				while (pSearchData)
				{
					if ((*pDepStr == pSearchData->GetPath()) && (pData->GetOSType() & pSearchData->GetOSType()))
					{
						*pDepStr = pSearchData->GetLogFile();
						break;
					}

					pSearchData = Next();
				}

				pDepStr = pDepList->Next();
			}
		}
		nPos ++;
		pData = GetObject(nPos);
	}
}

/*****************************************************************************/
PrjList* Prj::GetCommandDataList ()
/*****************************************************************************/
{
	if (pTempCommandDataList)
		return pTempCommandDataList;
	else
		return (PrjList*)this;
}

/*****************************************************************************/
void Prj::RemoveTempCommandDataList()
/*****************************************************************************/
{
	if (pTempCommandDataList)
	{
		delete pTempCommandDataList; // this list remove the elements by itself
		pTempCommandDataList = NULL;
	}
}

/*****************************************************************************/
void Prj::GenerateTempCommandDataList()
/*****************************************************************************/
{
	if (pTempCommandDataList)
		RemoveTempCommandDataList();
	pTempCommandDataList = new PrjList();
	CommandData* pCommandData = First();
	while (pCommandData) {
		SvMemoryStream* pStream = new SvMemoryStream();
		*pCommandData >> *pStream;
		CommandData* pNewCommandData = new CommandData();
		pStream->Seek( STREAM_SEEK_TO_BEGIN );
		*pNewCommandData << *pStream;
		pTempCommandDataList->Insert(pNewCommandData, LIST_APPEND);
		delete pStream;
		pCommandData = Next();
	}
}

/*****************************************************************************/
void Prj::GenerateEmptyTempCommandDataList()
/*****************************************************************************/
{
	if (pTempCommandDataList)
		RemoveTempCommandDataList();
	pTempCommandDataList = new PrjList();
}

/*****************************************************************************/
Prj& Prj::operator>>  ( SvStream& rStream )
/*****************************************************************************/
{
	rStream << bVisited;
    rStream << aProjectName;
    rStream << aProjectPrefix;
    rStream << bHardDependencies;
    rStream << bFixedDependencies;
    rStream << bSorted;
    rStream << bIsAvailable;
	rStream << bError;

	if (pPrjDepInfoList)
	{
		rStream << sal_True;
		*pPrjDepInfoList >> rStream;
	}
	else
		rStream << sal_False;

    sal_uIntPtr nCount_l = Count();
    rStream << nCount_l;

    CommandData* pData = First();
    while (pData) {
        *pData >> rStream;
        pData = Next();
    }

	return *this;
}

/*****************************************************************************/
Prj& Prj::operator<<  ( SvStream& rStream )
/*****************************************************************************/
{
   	rStream >> bVisited;
    rStream >> aProjectName;
    rStream >> aProjectPrefix;
    rStream >> bHardDependencies;
    rStream >> bFixedDependencies;
    rStream >> bSorted;
    rStream >> bIsAvailable;
	rStream >> bError;

	sal_Bool bDepList;
	rStream >> bDepList;
	DELETEZ (pPrjDepInfoList);
	if (bDepList)
	{
		pPrjDepInfoList = new SDepInfoList();
		*pPrjDepInfoList << rStream;
	}

    sal_uIntPtr nCount_l;
    rStream >> nCount_l;

    for ( sal_uInt16 i = 0; i < nCount_l; i++ ) {
        CommandData* pData = new CommandData();
        *pData << rStream;
        Insert (pData, LIST_APPEND);
    }

	return *this;
}


//
//	class Star
//

/*****************************************************************************/
Star::Star()
/*****************************************************************************/
				: pDepMode (NULL),
				pAllDepMode (NULL)
{
	// this ctor is only used by StarWriter
}

/*****************************************************************************/
Star::Star(String aFileName, sal_uInt16 nMode )
/*****************************************************************************/
				: nStarMode( nMode ),
				sFileName( aFileName ),
				pDepMode (NULL),
				pAllDepMode (NULL)
{
	Read( aFileName );
}

/*****************************************************************************/
Star::Star(SolarFileList *pSolarFiles )
/*****************************************************************************/
				: nStarMode( STAR_MODE_MULTIPLE_PARSE ),
				pDepMode (NULL),
				pAllDepMode (NULL)
{
	// this ctor is used by StarBuilder to get the information for the whole workspace
	Read( pSolarFiles );
}

/*****************************************************************************/
Star::Star(GenericInformationList *pStandLst, ByteString &rVersion )
/*****************************************************************************/
				: pDepMode (NULL),
				pAllDepMode (NULL)
{
	UpdateFileList (pStandLst, rVersion, sal_True );
}

/*****************************************************************************/
void Star::UpdateFileList( GenericInformationList *pStandLst, ByteString &rVersion,
	sal_Bool bRead )
/*****************************************************************************/
{
	sSourceRoot=String::CreateFromAscii(""); // clear old SourceRoot
	ByteString sPath( rVersion );

#ifdef UNX
	sPath += "/settings/UNXSOLARLIST";
#else
	sPath += "/settings/SOLARLIST";
#endif
	GenericInformation *pInfo = pStandLst->GetInfo( sPath, sal_True );

	if( pInfo && pInfo->GetValue().Len()) {
		ByteString sFile( pInfo->GetValue());
		String sFileName_l( sFile, RTL_TEXTENCODING_ASCII_US );
		nStarMode = STAR_MODE_SINGLE_PARSE;
		if (bRead)
			Read( sFileName_l );
	}
	else {
		SolarFileList *pFileList = new SolarFileList();

		sPath = rVersion;
		sPath += "/drives";

		GenericInformation *pInfo_l = pStandLst->GetInfo( sPath, sal_True );
		if ( pInfo_l && pInfo_l->GetSubList())  {
			GenericInformationList *pDrives = pInfo_l->GetSubList();
			for ( sal_uIntPtr i = 0; i < pDrives->Count(); i++ ) {
				GenericInformation *pDrive = pDrives->GetObject( i );
				if ( pDrive ) {
					DirEntry aEntry;
					sal_Bool bOk = sal_False;
					if ( sSourceRoot.Len()) {
						aEntry = DirEntry( sSourceRoot );
						bOk = sal_True;
					}
					else {
#ifdef UNX
						sPath = "UnixVolume";
						GenericInformation *pUnixVolume = pDrive->GetSubInfo( sPath );
						if ( pUnixVolume ) {
							String sRoot( pUnixVolume->GetValue(), RTL_TEXTENCODING_ASCII_US );
							aEntry = DirEntry( sRoot );
							bOk = sal_True;
				 		}
#else
						bOk = sal_True;
						String sRoot( *pDrive, RTL_TEXTENCODING_ASCII_US );
						sRoot += String::CreateFromAscii( "\\" );
						aEntry = DirEntry( sRoot );
#endif
					}
					if ( bOk ) {
						sPath = "projects";
						GenericInformation *pProjectsKey = pDrive->GetSubInfo( sPath, sal_True );
						if ( pProjectsKey ) {
							if ( !sSourceRoot.Len()) {
								sPath = rVersion;
								sPath += "/settings/PATH";
								GenericInformation *pPath = pStandLst->GetInfo( sPath, sal_True );
								if( pPath ) {
									ByteString sAddPath( pPath->GetValue());
#ifdef UNX
									sAddPath.SearchAndReplaceAll( "\\", "/" );
#else
									sAddPath.SearchAndReplaceAll( "/", "\\" );
#endif
									String ssAddPath( sAddPath, RTL_TEXTENCODING_ASCII_US );
									aEntry += DirEntry( ssAddPath );
								}
							}
							sPath = rVersion;
							sPath += "/settings/SHORTPATH";
							GenericInformation *pShortPath = pStandLst->GetInfo( sPath, sal_True );
							sal_Bool bShortPath = sal_False;
							if (pShortPath && (pShortPath->GetValue() == "_TRUE"))
								bShortPath = sal_True;
							sSourceRoot = aEntry.GetFull();
							GenericInformationList *pProjects = pProjectsKey->GetSubList();
							if ( pProjects ) {
								GenericInformation * pProject = pProjects->First();
								while (pProject) {
									String sLocalSourceRoot = sSourceRoot;
									ByteString sProject( *pProject );
									String ssProject( sProject, RTL_TEXTENCODING_ASCII_US );

									ByteString aDirStr ("Directory");
									GenericInformation * pDir = pProject->GetSubInfo (aDirStr);
									if (pDir) {
										ByteString aDir = pDir->GetValue();
										DirEntry aRootEntry;
										if (bShortPath)
											aRootEntry = aEntry + DirEntry(aDir);
										else
											aRootEntry = aEntry.GetPath() + DirEntry(aDir);
										sLocalSourceRoot = aRootEntry.GetFull();
									}

									String aBuildListPath = CreateFileName(ssProject, sLocalSourceRoot);

									pFileList->Insert( new String( aBuildListPath ), LIST_APPEND );
									ByteString sFile( aBuildListPath, RTL_TEXTENCODING_ASCII_US );
									pProject = pProjects->Next();
								}
							}
						}
					}
				}
			}
		}

		if (!CheckFileLoadList(pFileList))
		{
			ClearAvailableDeps();
			ClearCurrentDeps();
			ClearLoadedFilesList();
			RemoveAllPrj();
			bRead = sal_True; // read new list because old list is deleted
		}

		if (bRead)
			Read( pFileList );
		else
			GenerateFileLoadList( pFileList );
	}
}

/*****************************************************************************/
void Star::FullReload( GenericInformationList *pStandLst, ByteString &rVersion,
	sal_Bool bRead )
/*****************************************************************************/
{
	ClearAvailableDeps();
	ClearCurrentDeps();
	ClearLoadedFilesList();
	RemoveAllPrj();
	UpdateFileList( pStandLst, rVersion, bRead );
}

/*****************************************************************************/
sal_Bool Star::CheckFileLoadList(SolarFileList *pSolarFiles)
/*****************************************************************************/
{
	sal_Bool bRet = sal_True;
	if (aLoadedFilesList.Count() == 0)
		return bRet;
	StarFile * pLoadFile = aLoadedFilesList.First();
	while (pLoadFile)
	{
		sal_Bool bIsAvailable = sal_False;
		String * pFile = pSolarFiles->First();
		while (pFile)
		{
			if (*pFile == pLoadFile->GetName())
			{
				bIsAvailable = sal_True;
				break;
			}
			pFile = pSolarFiles->Next();
		}
		if (!bIsAvailable)
		{
			bRet = sal_False;
			break;
		}
		pLoadFile = aLoadedFilesList.Next();
	}
   	return bRet;
}

/*****************************************************************************/
Star::~Star()
/*****************************************************************************/
{
	ClearAvailableDeps();
	ClearCurrentDeps();
	ClearLoadedFilesList();
	RemoveAllPrj();
}

/*****************************************************************************/
void Star::GenerateFileLoadList( SolarFileList *pSolarFiles )
/*****************************************************************************/
{
	SolarFileList* pNewSolarFiles = NULL;
	while(  pSolarFiles->Count()) {
		StarFile *pFile = new StarFile( *pSolarFiles->GetObject(( sal_uIntPtr ) 0 ));
		aMutex.acquire();
		sal_uIntPtr nPos = SearchFileEntry(&aLoadedFilesList, pFile);
		if ( nPos == LIST_ENTRY_NOTFOUND )
		{
			if (!pNewSolarFiles)
				pNewSolarFiles = new SolarFileList();

			pNewSolarFiles->Insert(new String(pFile->GetName()), LIST_APPEND );
		}
		aMutex.release();
		delete pSolarFiles->Remove(( sal_uIntPtr ) 0 );
		delete pFile;
	}
	delete pSolarFiles;
	if (pNewSolarFiles)
		Read (pNewSolarFiles);
}

/*****************************************************************************/
SolarFileList* Star::NeedsFilesForUpdate()
/*****************************************************************************/
{
	aMutex.acquire();
	SolarFileList* pPrjList = NULL;
	for ( sal_uIntPtr i = 0; i < aLoadedFilesList.Count(); i++ )
		if ( aLoadedFilesList.GetObject( i )->NeedsUpdate()) {
			if (!pPrjList)
				pPrjList = new SolarFileList();

			pPrjList->Insert(new String (aLoadedFilesList.GetObject( i )->GetName()), LIST_APPEND);
		}

	aMutex.release();
	return pPrjList;
}

/*****************************************************************************/
sal_Bool Star::NeedsUpdate()
/*****************************************************************************/
{
	aMutex.acquire();
	for ( sal_uIntPtr i = 0; i < aLoadedFilesList.Count(); i++ )
		if ( aLoadedFilesList.GetObject( i )->NeedsUpdate()) {
			aMutex.release();
			return sal_True;
		}

	aMutex.release();
	return sal_False;
}

/*****************************************************************************/
void Star::Read( String &rFileName )
/*****************************************************************************/
{
	ClearAvailableDeps ();
	ByteString aString;
	aFileList.Insert( new String( rFileName ));

	DirEntry aEntry( rFileName );
	aEntry.ToAbs();
	aEntry = aEntry.GetPath().GetPath().GetPath();
	sSourceRoot = aEntry.GetFull();

	while( aFileList.Count()) {
		String ssFileName = *aFileList.GetObject(( sal_uIntPtr ) 0 );
		StarFile* pFile = ReadBuildlist (ssFileName);
		aMutex.acquire();
		ReplaceFileEntry (&aLoadedFilesList, pFile);
		//aLoadedFilesList.Insert( pFile, LIST_APPEND );
		aMutex.release();
		aFileList.Remove(( sal_uIntPtr ) 0 );
	}
	// resolve all dependencies recursive
	Expand_Impl();
}

/*****************************************************************************/
sal_uIntPtr Star::SearchFileEntry( StarFileList *pStarFiles, StarFile* pFile )
/*****************************************************************************/
{
	StarFile *pSearchFile;
	sal_uIntPtr nCount_l;

	nCount_l = pStarFiles->Count();

	for ( sal_uIntPtr i=0; i<nCount_l; i++)
	{
		pSearchFile = pStarFiles->GetObject(i);
		if ( pSearchFile->GetName() == pFile->GetName() )
		{
			return i;
		}
	}
	return LIST_ENTRY_NOTFOUND;
}

/*****************************************************************************/
void Star::ReplaceFileEntry( StarFileList *pStarFiles, StarFile* pFile )
/*****************************************************************************/
{
	sal_uIntPtr nPos = SearchFileEntry(pStarFiles, pFile);
	if ( nPos != LIST_ENTRY_NOTFOUND )
	{
		StarFile* pTmpStarFile = pStarFiles->GetObject(nPos);
		delete pTmpStarFile;
		pStarFiles->Replace(pFile, nPos);
		return;
	}
	pStarFiles->Insert( pFile,	LIST_APPEND );
}

/*****************************************************************************/
void Star::Read( SolarFileList *pSolarFiles )
/*****************************************************************************/
{
	ClearAvailableDeps ();
	while(  pSolarFiles->Count()) {
		ByteString aString;

		String ssFileName = *pSolarFiles->GetObject(( sal_uIntPtr ) 0 );
		StarFile *pFile = ReadBuildlist ( ssFileName);

		if ( pFile->Exists()) {
			DirEntry aEntry( pFile->GetName() );
			DirEntry aEntryPrj = aEntry.GetPath().GetPath();
			if (aEntryPrj.GetExtension() != String::CreateFromAscii( "" ))
			{
				aEntryPrj.CutExtension();
				ByteString aPrjName = ByteString( aEntryPrj.GetName(), gsl_getSystemTextEncoding());
				Prj* pPrj = GetPrj(aPrjName);
				if (pPrj)
					pPrj->IsAvailable (sal_False);
			}

		}

		aMutex.acquire();
		ReplaceFileEntry (&aLoadedFilesList, pFile);
		//aLoadedFilesList.Insert( pFile,	LIST_APPEND );
		aMutex.release();
		delete pSolarFiles->Remove(( sal_uIntPtr ) 0 );
	}
	delete pSolarFiles;

	Expand_Impl();
}

/*****************************************************************************/
String Star::CreateFileName( String& rProject, String& rSourceRoot )
/*****************************************************************************/
{
	// this method is used to find solarlist parts of nabours (other projects)
	String sPrjDir( String::CreateFromAscii( "prj" ));
	String sBuildList( String::CreateFromAscii( "build.lst" ));
//	String sXmlBuildList( String::CreateFromAscii( "build.xlist" ));

	DirEntry aEntry( rSourceRoot );
	aEntry += DirEntry( rProject );

	// if this project not exists, maybe it's a not added project of a CWS

	if ( !aEntry.Exists() ) {
		aEntry.SetExtension(String::CreateFromAscii( "lnk" ));
		if ( !aEntry.Exists() )
			aEntry.CutExtension();

		aEntry.SetExtension(String::CreateFromAscii( "link" ));
		if ( !aEntry.Exists() )
			aEntry.CutExtension();
	}

	aEntry += DirEntry( sPrjDir );

//	DirEntry aPossibleEntry(aEntry);
//  aPossibleEntry += DirEntry( sXmlBuildList );

	aEntry += DirEntry( sBuildList );

    DirEntry& aActualEntry = aEntry;
/*
    if (aPossibleEntry.Exists()) {
        aActualEntry = aPossibleEntry;
    } else */
	if ( !aActualEntry.Exists() && aDBNotFoundHdl.IsSet())
		aDBNotFoundHdl.Call( &rProject );
	return aActualEntry.GetFull();
}

/*****************************************************************************/
void Star::InsertSolarList( String sProject )
/*****************************************************************************/
{
	// inserts a new solarlist part of another project
	String sFileName_l( CreateFileName( sProject, sSourceRoot ));

	for ( sal_uIntPtr i = 0; i < aFileList.Count(); i++ ) {
		if (( *aFileList.GetObject( i )) == sFileName_l )
			return;
	}

	ByteString ssProject( sProject, RTL_TEXTENCODING_ASCII_US );
	if ( HasProject( ssProject ))
		return;

	aFileList.Insert( new String( sFileName_l ), LIST_APPEND );
}

/*****************************************************************************/
void Star::ExpandPrj_Impl( Prj *pPrj, Prj *pDepPrj )
/*****************************************************************************/
{
	if ( pDepPrj->bVisited )
		return;

	pDepPrj->bVisited = sal_True;

	SByteStringList* pPrjLst = pPrj->GetDependencies();
	SByteStringList* pDepLst = NULL;
	ByteString* pDepend;
	ByteString* pPutStr;
	Prj *pNextPrj = NULL;
	sal_uIntPtr i, nRetPos;

	if ( pPrjLst ) {
		pDepLst = pDepPrj->GetDependencies();
		if ( pDepLst ) {
			for ( i = 0; i < pDepLst->Count(); i++ ) {
				pDepend = pDepLst->GetObject( i );
				pPutStr = new ByteString( *pDepend );
				nRetPos = pPrjLst->PutString( pPutStr );
				if( nRetPos == NOT_THERE )
					delete pPutStr;
				pNextPrj = GetPrj( *pDepend );
				if ( pNextPrj ) {
					ExpandPrj_Impl( pPrj, pNextPrj );
				}
			}
		}
	}
}

/*****************************************************************************/
void Star::Expand_Impl()
/*****************************************************************************/
{
	for ( sal_uIntPtr i = 0; i < Count(); i++ ) {
		for ( sal_uIntPtr j = 0; j < Count(); j++ )
			GetObject( j )->bVisited = sal_False;

		Prj* pPrj = GetObject( i );
		pPrj->SetMode(pDepMode); // DepList f�r Mode initialisieren
		ExpandPrj_Impl( pPrj, pPrj );
	}
}

/*****************************************************************************/
StarFile* Star::ReadBuildlist (const String& rFilename, sal_Bool bReadComments, sal_Bool bExtendAlias)
/*****************************************************************************/
{
	ByteString sFileName_l(rFilename, RTL_TEXTENCODING_ASCII_US);
	StarFile *pFile = new StarFile( rFilename );
	if ( pFile->Exists()) {
		SimpleConfig aSolarConfig( rFilename );
		DirEntry aEntry(rFilename);
		ByteString sProjectName (aEntry.GetPath().GetPath().GetName(), RTL_TEXTENCODING_ASCII_US);
		Prj* pPrj = GetPrj (sProjectName); // 0, if Prj not found
		if (pPrj)
		{
			Remove(pPrj); // Project exist, remove old Project and read again
			DELETEZ (pPrj); // delete and set pPrj to 0
		}
		ByteString aString;
		while (( aString = aSolarConfig.GetCleanedNextLine( bReadComments )) != ByteString::EmptyString() )
    		InsertTokenLine ( aString, &pPrj, sProjectName, bExtendAlias );
	}
	return pFile;
}

/*****************************************************************************/
void Star::InsertTokenLine ( const ByteString& rTokenLine, Prj** ppPrj, const ByteString& rProjectName, const sal_Bool bExtendAlias )
/*****************************************************************************/
{
	int i = 0;
	ByteString aWhat, aWhatOS,
		sClientRestriction, aLogFileName, aProjectName, aPrefix, aCommandPara;
	ByteString aDirName;
	sal_Bool bPrjDep = sal_False;
	sal_Bool bHardDep = sal_False;
	sal_Bool bFixedDep = sal_False;
	sal_Bool bNewProject = sal_False;
	int nCommandType=0, nOSType=0;
	Prj* pPrj = *ppPrj;
	CommandData* pCmdData;
	SByteStringList *pDepList = NULL;
	ByteString aCommentString;
	ByteString sToken;
	ByteString sStringBuffer = rTokenLine;

	while (sStringBuffer != ByteString::EmptyString())
	{
		ByteString sToken = sStringBuffer.GetToken(0,'\t');
		sStringBuffer.Erase(0, sToken.Len()+1);

		switch (i)
		{
			case 0:
					if ( sToken.Search( "#" ) == 0 )
					{
						i = -1;
						aCommentString = sToken;
						sStringBuffer = ByteString::EmptyString();
						if ( Count() == 0 )
							aDirName = "null_entry" ; //comments at begin of file
					}
					else
					{
						aPrefix = sToken;
						pDepList = 0;
					}
					break;
			case 1:
					aDirName = sToken;
					aProjectName = aDirName.GetToken ( 0, 0x5c);
					if (aProjectName != rProjectName)
						sStringBuffer = ByteString::EmptyString(); // something is wrong, ignore line
					break;
			case 2:
					if ( sToken.CompareTo(":") == COMPARE_EQUAL )
					{
						bPrjDep = sal_True;
						bHardDep = sal_False;
						bFixedDep = sal_False;
						i = 9;
					}
					else if ( sToken.CompareTo("::") == COMPARE_EQUAL )
					{
						bPrjDep = sal_True;
						bHardDep = sal_True;
						bFixedDep = sal_False;
						i = 9;
					}
					else if ( sToken.CompareTo(":::") == COMPARE_EQUAL )
					{
						bPrjDep = sal_True;
						bHardDep = sal_True;
						bFixedDep = sal_True;
						i = 9;
					}
					else
					{
						bPrjDep = sal_False;
						bHardDep = sal_False;
						bFixedDep = sal_False;

						aWhat = sToken;
						nCommandType = GetJobType(aWhat);
					}
					if (bPrjDep)
					{
						if (pPrj)
							sStringBuffer = ByteString::EmptyString(); // definition more than once or not first line, ignore line
					}
					break;
			case 3:
					if ( !bPrjDep )
					{
						aWhat = sToken;
						if ( aWhat == "-" )
						{
							aCommandPara = ByteString();
						}
						else
							aCommandPara = aWhat;
					}
					break;
			case 4:
					if ( !bPrjDep )
					{
						aWhatOS = sToken;
						if ( aWhatOS.GetTokenCount( ',' ) > 1 ) {
							sClientRestriction = aWhatOS.Copy( aWhatOS.GetToken( 0, ',' ).Len() + 1 );
							aWhatOS = aWhatOS.GetToken( 0, ',' );
						}
						nOSType = GetOSType (aWhatOS);
					}
					break;
			case 5:
					if ( !bPrjDep )
					{
						if (bExtendAlias)
							aLogFileName = (ByteString(aProjectName).Append("_")).Append(sToken);
						else
							aLogFileName = sToken;

					}
					break;
			default:
					if ( !bPrjDep )
					{
						ByteString aItem = sToken;
						if ( aItem == "NULL" )
						{
							// Liste zu Ende
							i = -1;
						}
						else
						{
							// ggfs. Dependency liste anlegen und ergaenzen
							if ( !pDepList )
								pDepList = new SByteStringList;
							ByteString* pStr;
							if (bExtendAlias)
								pStr = new ByteString ((ByteString (aProjectName).Append("_")).Append(aItem));
							else
								pStr = new ByteString (aItem);
							pDepList->PutString( pStr );
						}
					}
					else
					{
						ByteString aItem = sToken;
						if ( aItem == "NULL" )
						{
							// Liste zu Ende
							i = -1;
							bPrjDep= sal_False;
						}
						else
						{
							ByteString sMode;
							sal_Bool bHasModes = sal_False;
							if (aItem.Search(":") != STRING_NOTFOUND)
							{
								sMode = aItem.GetToken ( 0, ':');
								aItem = aItem.GetToken ( 1, ':');
								bHasModes = sal_True;
							}
							if (!pPrj)
							{
								// neues Project anlegen
								pPrj = new Prj ( aProjectName );
								pPrj->SetPreFix( aPrefix );
								bNewProject = sal_True;
							}
							if (bHasModes)
								pPrj->AddDependencies( aItem, sMode );
							else
								pPrj->AddDependencies( aItem );
							pPrj->HasHardDependencies( bHardDep );
							pPrj->HasFixedDependencies( bFixedDep );
						}
					}
					break;
		}
		if ( i == -1 )
			break;
		i++;
	}
	/* Wenn dieses Project noch nicht vertreten ist, in die Liste
	   der Solar-Projekte einfuegen */
	if ( i == -1 )
	{
		if (!pPrj)
		{
			// neues Project anlegen
			pPrj = new Prj ( aProjectName );
			pPrj->SetPreFix( aPrefix );
			bNewProject = sal_True;
		}

		if (bNewProject)
			Insert(pPrj,LIST_APPEND);

		pCmdData = new CommandData;
		pCmdData->SetPath( aDirName );
		pCmdData->SetCommandType( nCommandType );
		pCmdData->SetCommandPara( aCommandPara );
		pCmdData->SetOSType( nOSType );
		pCmdData->SetLogFile( aLogFileName );
		pCmdData->SetComment( aCommentString );
		pCmdData->SetClientRestriction( sClientRestriction );
		if ( pDepList )
			pCmdData->SetDependencies( pDepList );

		pDepList = 0;
		pPrj->Insert ( pCmdData, LIST_APPEND );

		// und wer raeumt die depLst wieder ab ?
		// CommandData macht das
	}
	else
	{
		if (!pPrj)
		{
			// new project to set the error flag
			pPrj = new Prj ( rProjectName );
			pPrj->SetPreFix( aPrefix );
			bNewProject = sal_True;
		}
		if (pPrj)
		{
			pPrj->SetError();
			if (bNewProject)
				Insert(pPrj,LIST_APPEND); // add project even if there is a buildlist error
		}
		if ( pDepList )
			delete pDepList;
	}
	*ppPrj = pPrj;
}

/*****************************************************************************/
sal_Bool Star::HasProject ( ByteString aProjectName )
/*****************************************************************************/
{
	Prj *pPrj;
	int nCount_l;

	nCount_l = Count();

	for ( int i=0; i<nCount_l; i++)
	{
		pPrj = GetObject(i);
		if ( pPrj->GetProjectName().ToLowerAscii() == aProjectName.ToLowerAscii() )
			return sal_True;
	}
	return sal_False;
}

/*****************************************************************************/
Prj* Star::GetPrj ( ByteString aProjectName )
/*****************************************************************************/
{
	Prj* pPrj;
	int nCount_l = Count();
	for ( int i=0;i<nCount_l;i++)
	{
		pPrj = GetObject(i);
		if ( pPrj->GetProjectName().ToLowerAscii() == aProjectName.ToLowerAscii() )
			return pPrj;
	}
//	return (Prj*)NULL;
	return 0L ;
}

/*****************************************************************************/
sal_Bool Star::RemovePrj ( Prj* pPrj )
/*****************************************************************************/
{
	sal_uIntPtr nPos = GetPos(pPrj);
	if (nPos != LIST_ENTRY_NOTFOUND) {
		delete pPrj;
		Remove(nPos);
		return sal_True;
	}
	return sal_False;
}

/*****************************************************************************/
void Star::RemoveAllPrj ()
/*****************************************************************************/
{
	Prj* pPrj = First();
	while (pPrj)
	{
		delete pPrj;
		pPrj = Next();
	}
	Clear();
}

/*****************************************************************************/
ByteString Star::GetPrjName( DirEntry &aPath )
/*****************************************************************************/
{
	ByteString aRetPrj, aDirName;
	ByteString aFullPathName = ByteString( aPath.GetFull(), gsl_getSystemTextEncoding());

	sal_uInt16 nToken = aFullPathName.GetTokenCount(PATH_DELIMETER);
	for ( int i=0; i< nToken; i++ )
	{
		aDirName = aFullPathName.GetToken( i, PATH_DELIMETER );
		if ( HasProject( aDirName ))
		{
			aRetPrj = aDirName;
			break;
		}
	}

	return aRetPrj;
}

/*****************************************************************************/
void Star::ClearAvailableDeps ()
/*****************************************************************************/
{
	if ( pAllDepMode )
	{
		ByteString *pString = pAllDepMode->First();
		while ( pString )
		{
			delete pString;
			pString = pAllDepMode->Next();
		}
		delete pAllDepMode;
		pAllDepMode = NULL;
	}
}

/*****************************************************************************/
void Star::ClearLoadedFilesList ()
/*****************************************************************************/
{
	StarFile *pStarFile = aLoadedFilesList.First();
	while ( pStarFile )
	{
		delete pStarFile;
		pStarFile = aLoadedFilesList.Next();
	}
	aLoadedFilesList.Clear();
}

/*****************************************************************************/
void Star::ClearCurrentDeps ()
/*****************************************************************************/
{
	if ( pDepMode )
	{
		ByteString *pString = pDepMode->First();
		while ( pString )
		{
			delete pString;
			pString = pDepMode->Next();
		}
		delete pDepMode;
		pDepMode = NULL;
	}
}

/*****************************************************************************/
SByteStringList* Star::GetAvailableDeps ()
/*****************************************************************************/
{
	if ( pAllDepMode )
		return pAllDepMode;

	Prj *pPrj;
	ByteString* pStr;
	pPrj = First();
	while (pPrj)
	{
		SByteStringList* pModeList = NULL;
		if (pPrj->GetModeAndDependencies() && (pModeList = pPrj->GetModeAndDependencies()->GetAllDepModes()))
		{
			pStr = pModeList->First();
			while (pStr)
			{
				if ( !pAllDepMode )
					pAllDepMode = new SByteStringList();

				if (pAllDepMode->IsString(pStr) == NOT_THERE)
					pAllDepMode->PutString(new ByteString(*pStr));

				pStr = pModeList->Next();
			}
		}
		pPrj = Next();
	}
	return pAllDepMode;
}

/*****************************************************************************/
void Star::SetCurrentDeps (SByteStringList* pDepList)
/*****************************************************************************/
{
	ClearCurrentDeps();

	if (pDepList)
	{
		pDepMode = new SByteStringList();
		ByteString *pString = pDepList->First();
		while ( pString )
		{
			ByteString* pStr = new ByteString (*pString);
			if (pDepMode->PutString(pStr) == NOT_THERE)
				delete pStr; // String is not in List
			pString = pDepList->Next();
		}
	}
	Expand_Impl();
}

///*****************************************************************************/
//void Star::ReadXmlBuildList(const ByteString& sBuildLstPath) {
///*****************************************************************************/
//	if (mpXmlBuildList) {
//		Prj* pPrj = NULL;
//
//		try {
//			mpXmlBuildList->loadXMLFile(sBuildLstPath);
//		}
//		catch (XmlBuildListException) {
//			DirEntry aDirEntry (sBuildLstPath);
//			String ssPrjName = aDirEntry.GetPath().GetPath().GetBase();
//			ByteString sPrjName = ByteString(ssPrjName, RTL_TEXTENCODING_ASCII_US);
//			pPrj = GetPrj( sPrjName );
//			if (pPrj)
//			{
//				//remove old Project
//				RemovePrj (pPrj);
//			}
//			return;
//		}
//
//		try {
//			ByteString sProjectName = mpXmlBuildList->getModuleName();
//			pPrj = GetPrj( sProjectName );
//			if (pPrj)
//			{
//				//remove old Project
//				RemovePrj (pPrj);
//			}
//
//			// insert new Project
//			pPrj = new Prj ( sProjectName );
//			pPrj->SetPreFix( sProjectName ); // use ProjectName as Prefix
//			Insert(pPrj,LIST_APPEND);
//
//			// get global dependencies
//			FullByteStringListWrapper aProducts = mpXmlBuildList->getProducts();
//			ByteString aDepType = ByteString(DEP_MD_ALWAYS_STR);
//			if (mpXmlBuildList->hasModuleDepType(aProducts, aDepType))
//				pPrj->HasHardDependencies( sal_True );
//
//			aDepType = ByteString(DEP_MD_FORCE_STR);
//			if (mpXmlBuildList->hasModuleDepType(aProducts, aDepType))
//			{
//				pPrj->HasHardDependencies( sal_True );
//				pPrj->HasFixedDependencies( sal_True );
//			}
//
//			// modul dependencies
//			ByteString sModulDepType = ByteString();
//			FullByteStringListWrapper aModulDeps = mpXmlBuildList->getModuleDependencies(aProducts, sModulDepType);
//			ByteString * pModulDep = aModulDeps.First();
//			while (pModulDep)
//			{
//				FullByteStringListWrapper aModulProducts = mpXmlBuildList->getModuleProducts(*pModulDep);
//				ByteString *pModulePoduct = aModulProducts.First();
//				while (pModulePoduct)
//				{
//					if (*pModulePoduct == XML_ALL)
//						pPrj->AddDependencies( *pModulDep );
//					else
//						pPrj->AddDependencies( *pModulDep, *pModulePoduct);
//
//					pModulePoduct = aModulProducts.Next();
//				}
//				pModulDep = aModulDeps.Next();
//			}
//
//			// job dirs
//			ByteString sJobType = ByteString();
//			ByteString sJobPlatforms = ByteString();
//			FullByteStringListWrapper aJobDirs = mpXmlBuildList->getJobDirectories(sJobType, sJobPlatforms); // all dirs
//			ByteString* pJobDir = aJobDirs.First();
//			while (pJobDir)
//			{
//				FullByteStringListWrapper aJobPlatforms = mpXmlBuildList->getJobPlatforms (*pJobDir);
//				ByteString* pJobPlatform = aJobPlatforms.First();
//				while (pJobPlatform)
//				{
//					ByteString sJobRestriction = ByteString();
//					FullByteStringListWrapper aJobReq = mpXmlBuildList->getJobBuildReqs (*pJobDir, *pJobPlatform);
//					// nur ein Req pro Platform wird zur Zeit unterst�tzt
//					// mehr geht wegen der Struktur zur Zeit nicht!
//					// lese sie trotzdem kommasepariert ein, wenn n�tig
//					if (aJobReq.Count() > 0)
//					{
//						ByteString* pRestriction = aJobReq.First();
//						sJobRestriction = ByteString (*pRestriction);
//						pRestriction = aJobReq.Next();
//						while (pRestriction)
//						{
//							sJobRestriction += ByteString (",");
//							sJobRestriction += ByteString (*pRestriction);
//							pRestriction = aJobReq.Next();
//						}
//					}
//
//					FullByteStringListWrapper aJobTypes = mpXmlBuildList->getJobTypes (*pJobDir);
//					ByteString * pJobType = aJobTypes.First();
//					while(pJobType)
//					{
//						FullByteStringListWrapper aDirDependencies = mpXmlBuildList->getDirDependencies(*pJobDir, *pJobType, *pJobPlatform);
//						SByteStringList *pDepList = NULL;
//						if (aDirDependencies.Count() > 0)
//						{
//							pDepList = new SByteStringList;
//							ByteString* pDirDep = aDirDependencies.First();
//							while (pDirDep)
//							{
//								ByteString sFullDir = sProjectName;
//								sFullDir += *pDirDep;
//								sFullDir.SearchAndReplaceAll('/', '\\');
//								*pDirDep = sFullDir;
//								pDepList->PutString(pDirDep);	// String wird �bergeben
//								aDirDependencies.Remove();		// Zeiger aus alter Liste l�schen
//								pDirDep = aDirDependencies.First();
//							}
//						}
//						// insert CommandData
//						CommandData * pCmdData = new CommandData;
//						ByteString sRequiredPath = sProjectName;
//						sRequiredPath += *pJobDir;
//						sRequiredPath.SearchAndReplaceAll('/', '\\');
//						pCmdData->SetPath(sRequiredPath);
//						pCmdData->SetCommandType( GetJobType(*pJobType) );
//						pCmdData->SetCommandPara( ByteString() );
//						pCmdData->SetOSType( GetOSType(*pJobPlatform) );
//						ByteString sLogFileName = sProjectName;
//						sLogFileName += ByteString::CreateFromInt64( pPrj->Count() );
// 						pCmdData->SetLogFile( sLogFileName );
//						pCmdData->SetClientRestriction( sJobRestriction );
//						if ( pDepList )
//							pCmdData->SetDependencies( pDepList );
//
//						pPrj->Insert ( pCmdData, LIST_APPEND );
//
//						pJobType = aJobTypes.Next();
//					}
//
//					pJobPlatform = aJobPlatforms.Next();
//				}
//
//				pJobDir = aJobDirs.Next();
//			}
//			pPrj->ExtractDependencies();
//		}
//		catch (XmlBuildListException) {
//			if (pPrj)
//			{
//				RemovePrj (pPrj);
//				delete pPrj;
//			}
//
//		}
//	}
//}

/*****************************************************************************/
int Star::GetOSType ( ByteString& aWhatOS ) {
/*****************************************************************************/
    int nOSType = OS_NONE;
    if ( aWhatOS == "all" )
	    nOSType = ( OS_WIN16 | OS_WIN32 | OS_OS2 | OS_UNX | OS_MAC );
    else if ( aWhatOS == "w" || aWhatOS == "wnt" )
	    nOSType = ( OS_WIN16 | OS_WIN32 );
    else if ( aWhatOS == "p" )
	    nOSType = OS_OS2;
    else if ( aWhatOS == "u" || aWhatOS == "unx" )
	    nOSType = OS_UNX;
    else if ( aWhatOS == "d" )
	    nOSType = OS_WIN16;
    else if ( aWhatOS == "n" )
	    nOSType = OS_WIN32;
    else if ( aWhatOS == "m" || aWhatOS == "mac" )
	    nOSType = OS_MAC;
    return nOSType;

};

/*****************************************************************************/
int Star::GetJobType ( ByteString& JobType ) {
/*****************************************************************************/
    int nCommandType = 0;
    if ( JobType == "nmake" || JobType == "make")
        nCommandType = COMMAND_NMAKE;
    else if ( JobType == "get" )
        nCommandType = COMMAND_GET;
    else {
        sal_uIntPtr nOffset = JobType.Copy( 3 ).ToInt32();
	    nCommandType = COMMAND_USER_START + nOffset - 1;
    }
    return nCommandType;
};

/*****************************************************************************/
void Star::PutPrjIntoStream (SByteStringList* pPrjNameList, SvStream* pStream)
/*****************************************************************************/
{
    aMutex.acquire();
    *pStream << sal_False; // not full Star / only some Projects

    sal_uIntPtr nCount_l = pPrjNameList->Count();
    *pStream << nCount_l;
    ByteString* pStr = pPrjNameList->First();
    while (pStr) {
        Prj* pPrj = GetPrj (*pStr);
        *pPrj >> *pStream;
        pStr = pPrjNameList->Next();
    }
    aMutex.release();
}

/*****************************************************************************/
Star& Star::operator>>  ( SvStream& rStream )
/*****************************************************************************/
{
    aMutex.acquire();
    rStream << sal_True; // full Star
    rStream << nStarMode;
	if (pDepMode)
	{
		rStream << sal_True;
		*pDepMode >> rStream;
	}
	else
		rStream << sal_False;

    sal_uIntPtr nCount_l = Count();
    rStream << nCount_l;
    Prj* pPrj = First();
    while (pPrj) {
        *pPrj >> rStream;
        pPrj = Next();
    }
    aMutex.release();

	return *this;
}

/*****************************************************************************/
Star& Star::operator<<  ( SvStream& rStream )
/*****************************************************************************/
{
    aMutex.acquire();
    sal_Bool bFullList;
    rStream >> bFullList;
    if (bFullList)
    {
        rStream >> nStarMode;
	    sal_Bool bDepMode;
	    rStream >> bDepMode;
	    if (pDepMode)
		    pDepMode->CleanUp();
	    if (bDepMode)
	    {
		    if (!pDepMode)
			    pDepMode = new SByteStringList();
		    *pDepMode << rStream;
	    }
	    else
		    DELETEZ (pDepMode);

    }
    sal_uIntPtr nCount_l;
    rStream >> nCount_l;
    for ( sal_uInt16 i = 0; i < nCount_l; i++ ) {
        Prj* pPrj = new Prj();
        *pPrj << rStream;
		pPrj->SetMode(pDepMode);
        if (HasProject (pPrj->GetProjectName())) {
            Prj* pTmpPrj = GetPrj( pPrj->GetProjectName() );
            Replace (pPrj, pTmpPrj);
            delete pTmpPrj;
        }
        else
            Insert (pPrj, LIST_APPEND);
    }
	Expand_Impl();
    aMutex.release();
	return *this;
}



//
//	class StarWriter
//

/*****************************************************************************/
StarWriter::StarWriter( String aFileName, sal_Bool bReadComments, sal_uInt16 nMode )
/*****************************************************************************/
				: Star ()
{
	sFileName = aFileName;
	Read ( aFileName, bReadComments, nMode );
}

/*****************************************************************************/
StarWriter::StarWriter( SolarFileList *pSolarFiles, sal_Bool bReadComments )
/*****************************************************************************/
				: Star ()
{
	Read( pSolarFiles, bReadComments );
}

/*****************************************************************************/
StarWriter::StarWriter( GenericInformationList *pStandLst, ByteString &rVersion,
	ByteString &rMinor, sal_Bool bReadComments )
/*****************************************************************************/
				: Star ()
{
	ByteString sPath( rVersion );

#ifdef UNX
	sPath += "/settings/UNXSOLARLIST";
#else
	sPath += "/settings/SOLARLIST";
#endif
	GenericInformation *pInfo_l = pStandLst->GetInfo( sPath, sal_True );

	if( pInfo_l && pInfo_l->GetValue().Len()) {
		ByteString sFile( pInfo_l->GetValue());
		String sFileName_l( sFile, RTL_TEXTENCODING_ASCII_US );
		nStarMode = STAR_MODE_SINGLE_PARSE;
		Read( sFileName_l, bReadComments );
	}
	else {
		SolarFileList *pFileList = new SolarFileList();

		sPath = rVersion;
		sPath += "/drives";

		GenericInformation *pInfo_k = pStandLst->GetInfo( sPath, sal_True );
		if ( pInfo_k && pInfo_k->GetSubList())  {
			GenericInformationList *pDrives = pInfo_k->GetSubList();
			for ( sal_uIntPtr i = 0; i < pDrives->Count(); i++ ) {
				GenericInformation *pDrive = pDrives->GetObject( i );
				if ( pDrive ) {
					DirEntry aEntry;
					sal_Bool bOk = sal_False;
					if ( sSourceRoot.Len()) {
						aEntry = DirEntry( sSourceRoot );
						bOk = sal_True;
					}
					else {
#ifdef UNX
						sPath = "UnixVolume";
						GenericInformation *pUnixVolume = pDrive->GetSubInfo( sPath );
						if ( pUnixVolume ) {
							String sRoot( pUnixVolume->GetValue(), RTL_TEXTENCODING_ASCII_US );
							aEntry = DirEntry( sRoot );
							bOk = sal_True;
				 		}
#else
						bOk = sal_True;
						String sRoot( *pDrive, RTL_TEXTENCODING_ASCII_US );
						sRoot += String::CreateFromAscii( "\\" );
						aEntry = DirEntry( sRoot );
#endif
					}
					if ( bOk ) {
						sPath = "projects";
						GenericInformation *pProjectsKey = pDrive->GetSubInfo( sPath, sal_True );
						if ( pProjectsKey ) {
							if ( !sSourceRoot.Len()) {
								sPath = rVersion;
								sPath += "/settings/PATH";
								GenericInformation *pPath = pStandLst->GetInfo( sPath, sal_True );
								if( pPath ) {
									ByteString sAddPath( pPath->GetValue());
#ifdef UNX
									sAddPath.SearchAndReplaceAll( "\\", "/" );
#else
									sAddPath.SearchAndReplaceAll( "/", "\\" );
#endif
                                     //If Minor has been set add it to path
                                    if (rMinor.Len()>0) {
                                        sAddPath += ".";
                                        sAddPath += rMinor;
                                    }
									String ssAddPath( sAddPath, RTL_TEXTENCODING_ASCII_US );

									aEntry += DirEntry( ssAddPath );
								}
							}
							sPath = rVersion;
							sPath += "/settings/SHORTPATH";
							GenericInformation *pShortPath = pStandLst->GetInfo( sPath, sal_True );
							sal_Bool bShortPath = sal_False;
							if (pShortPath && (pShortPath->GetValue() == "_TRUE"))
								bShortPath = sal_True;
							sSourceRoot = aEntry.GetFull();
							GenericInformationList *pProjects = pProjectsKey->GetSubList();
							if ( pProjects ) {
								String sPrjDir( String::CreateFromAscii( "prj" ));
								String sSolarFile( String::CreateFromAscii( "build.lst" ));

								GenericInformation * pProject = pProjects->First();
								while (pProject) {
									ByteString sProject( *pProject);
									String ssProject( sProject, RTL_TEXTENCODING_ASCII_US );

									DirEntry aPrjEntry( aEntry );

									ByteString aDirStr ("Directory");
									GenericInformation * pDir = pProject->GetSubInfo (aDirStr);
									if (pDir) {
										ByteString aDir = pDir->GetValue();
										if (bShortPath)
											aPrjEntry = aEntry;
										else
											aPrjEntry = aEntry.GetPath();
										aPrjEntry += DirEntry(aDir);
									}

									aPrjEntry += DirEntry( ssProject );
									aPrjEntry += DirEntry( sPrjDir );
									aPrjEntry += DirEntry( sSolarFile );

									pFileList->Insert( new String( aPrjEntry.GetFull()), LIST_APPEND );

									ByteString sFile( aPrjEntry.GetFull(), RTL_TEXTENCODING_ASCII_US );
									fprintf( stdout, "%s\n", sFile.GetBuffer());
									pProject = pProjects->Next();
								}
							}
						}
					}
				}
			}
		}
		Read( pFileList, bReadComments );
	}
}

/*****************************************************************************/
void StarWriter::CleanUp()
/*****************************************************************************/
{
	Expand_Impl();
}

/*****************************************************************************/
sal_uInt16 StarWriter::Read( String aFileName, sal_Bool bReadComments, sal_uInt16 nMode  )
/*****************************************************************************/
{
	sFileName = aFileName;

	nStarMode = nMode;

	ByteString aString;
	aFileList.Insert( new String( aFileName ));

	DirEntry aEntry( aFileName );
	aEntry.ToAbs();
	aEntry = aEntry.GetPath().GetPath().GetPath();
	sSourceRoot = aEntry.GetFull();

	while( aFileList.Count()) {
		String ssFileName = *aFileList.GetObject(( sal_uIntPtr ) 0 );
		StarFile* pFile = ReadBuildlist (ssFileName, bReadComments, sal_False);
		aMutex.acquire();
		aLoadedFilesList.Insert( pFile, LIST_APPEND );
		aMutex.release();
		delete aFileList.Remove(( sal_uIntPtr ) 0 );
	}
	// resolve all dependencies recursive
	Expand_Impl();

	// Die gefundenen Abhaengigkeiten rekursiv aufloesen
	Expand_Impl();
	return 0;
}

/*****************************************************************************/
sal_uInt16 StarWriter::Read( SolarFileList *pSolarFiles, sal_Bool bReadComments )
/*****************************************************************************/
{
	nStarMode = STAR_MODE_MULTIPLE_PARSE;

	// this ctor is used by StarBuilder to get the information for the whole workspace
	while(  pSolarFiles->Count()) {
		ByteString aString;
		String ssFileName = *pSolarFiles->GetObject(( sal_uIntPtr ) 0 );
		StarFile* pFile = ReadBuildlist(ssFileName, bReadComments, sal_False);
		aMutex.acquire();
		aLoadedFilesList.Insert( pFile,	LIST_APPEND );
		aMutex.release();
		delete pSolarFiles->Remove(( sal_uIntPtr ) 0 );
	}
	delete pSolarFiles;

	Expand_Impl();
	return 0;
}

/*****************************************************************************/
sal_uInt16 StarWriter::WritePrj( Prj *pPrj, SvFileStream& rStream )
/*****************************************************************************/
{
	ByteString aDataString;
	ByteString aTab('\t');
	ByteString aSpace(' ');
	ByteString aEmptyString("");
	SByteStringList* pCmdDepList;
	SByteStringList* pPrjDepList;

	CommandData* pCmdData = NULL;
	if ( pPrj->Count() > 0 )
	{
		pCmdData = pPrj->First();
		if ( (pPrjDepList = pPrj->GetDependencies( sal_False )) )
		{
			aDataString = pPrj->GetPreFix();
			aDataString += aTab;
			aDataString += pPrj->GetProjectName();
			aDataString += aTab;
			if ( pPrj->HasFixedDependencies())
				aDataString+= ByteString(":::");
			else if ( pPrj->HasHardDependencies())
				aDataString+= ByteString("::");
			else
				aDataString+= ByteString(":");
			aDataString += aTab;
			for ( sal_uInt16 i = 0; i< pPrjDepList->Count(); i++ ) {
				aDataString += *pPrjDepList->GetObject( i );
				aDataString += aSpace;
			}
			aDataString+= "NULL";

			rStream.WriteLine( aDataString );

			pCmdData = pPrj->Next();
		}
		if ( pCmdData ) {
			do
			{
				if (( aDataString = pCmdData->GetComment()) == aEmptyString )
				{
					aDataString = pPrj->GetPreFix();
					aDataString += aTab;

					aDataString+= pCmdData->GetPath();
					aDataString += aTab;
					sal_uInt16 nPathLen = pCmdData->GetPath().Len();
					if ( nPathLen < 40 )
						for ( int i = 0; i < 9 - pCmdData->GetPath().Len() / 4 ; i++ )
							aDataString += aTab;
					else
						for ( int i = 0; i < 12 - pCmdData->GetPath().Len() / 4 ; i++ )
							aDataString += aTab;
					aDataString += pCmdData->GetCommandTypeString();
					aDataString += aTab;
					if ( pCmdData->GetCommandType() == COMMAND_GET )
						aDataString += aTab;
					if ( pCmdData->GetCommandPara() == aEmptyString )
						aDataString+= ByteString("-");
					else
						aDataString+= pCmdData->GetCommandPara();
					aDataString += aTab;
					aDataString+= pCmdData->GetOSTypeString();
					if ( pCmdData->GetClientRestriction().Len()) {
						aDataString += ByteString( "," );
						aDataString += pCmdData->GetClientRestriction();
					}
					aDataString += aTab;
					aDataString += pCmdData->GetLogFile();
					aDataString += aSpace;

					pCmdDepList = pCmdData->GetDependencies();
					if ( pCmdDepList )
						for ( sal_uInt16 i = 0; i< pCmdDepList->Count(); i++ ) {
							aDataString += *pCmdDepList->GetObject( i );
							aDataString += aSpace;
					}
					aDataString += "NULL";
				}

				rStream.WriteLine( aDataString );

				pCmdData = pPrj->Next();
			} while ( pCmdData );
		}
	}
	return 0;
}

/*****************************************************************************/
sal_uInt16 StarWriter::Write( String aFileName )
/*****************************************************************************/
{
	sFileName = aFileName;

	FileStat::SetReadOnlyFlag( DirEntry( aFileName ), sal_False );

	SvFileStream aFileStream;

	aFileStream.Open( aFileName, STREAM_WRITE | STREAM_TRUNC);
	if ( !aFileStream.IsOpen() && aFileIOErrorHdl.IsSet()) {
		String sError( String::CreateFromAscii( "Error: Unable to open \"" ));
		sError += aFileName;
		sError += String::CreateFromAscii( "for writing!" );
		aFileIOErrorHdl.Call( &sError );
	}

	if ( Count() > 0 )
	{
		Prj* pPrj = First();
		do
		{
			WritePrj( pPrj, aFileStream );
			pPrj = Next();
		} while ( pPrj );
	}

	aFileStream.Close();

	return 0;
}

/*****************************************************************************/
sal_uInt16 StarWriter::WriteMultiple( String rSourceRoot )
/*****************************************************************************/
{
	sSourceRoot = rSourceRoot;

	if ( Count() > 0 )
	{
		String sPrjDir( String::CreateFromAscii( "prj" ));
		String sSolarFile( String::CreateFromAscii( "build.lst" ));

		Prj* pPrj = First();
		do
		{
			String sName( pPrj->GetProjectName(), RTL_TEXTENCODING_ASCII_US );

			DirEntry aEntry( rSourceRoot );
			aEntry += DirEntry( sName );
			aEntry += DirEntry( sPrjDir );
			aEntry += DirEntry( sSolarFile );

			FileStat::SetReadOnlyFlag( aEntry, sal_False );

			SvFileStream aFileStream;
			aFileStream.Open( aEntry.GetFull(), STREAM_WRITE | STREAM_TRUNC);

			if ( !aFileStream.IsOpen() && aFileIOErrorHdl.IsSet()) {
				String sError( String::CreateFromAscii( "Error: Unable to open \"" ));
				sError += aEntry.GetFull();
				sError += String::CreateFromAscii( "for writing!" );
				aFileIOErrorHdl.Call( &sError );
			}

	  		WritePrj( pPrj, aFileStream );

			aFileStream.Close();

			pPrj = Next();
		} while ( pPrj );
	}

	return 0;
}

/*****************************************************************************/
void StarWriter::InsertTokenLine ( const ByteString& rTokenLine )
/*****************************************************************************/
{
	ByteString sProjectName = rTokenLine.GetToken(1,'\t');
	Prj* pPrj = GetPrj (sProjectName); // 0, if Prj not found;
	Star::InsertTokenLine ( rTokenLine, &pPrj, sProjectName, sal_False );
}

/*****************************************************************************/
sal_Bool StarWriter::InsertProject ( Prj* /*pNewPrj*/ )
/*****************************************************************************/
{
	return sal_False;
}

/*****************************************************************************/
Prj* StarWriter::RemoveProject ( ByteString aProjectName )
/*****************************************************************************/
{
	sal_uIntPtr nCount_l = Count();
	Prj* pPrj;
	Prj* pPrjFound = NULL;
	SByteStringList* pPrjDeps;

	for ( sal_uInt16 i = 0; i < nCount_l; i++ )
	{
		pPrj = GetObject( i );
		if ( pPrj->GetProjectName() == aProjectName )
			pPrjFound = pPrj;
		else
		{
			pPrjDeps = pPrj->GetDependencies( sal_False );
			if ( pPrjDeps )
			{
				ByteString* pString;
				sal_uIntPtr nPrjDepsCount = pPrjDeps->Count();
				for ( sal_uIntPtr j = nPrjDepsCount; j > 0; j-- )
				{
					pString = pPrjDeps->GetObject( j - 1 );
					if ( pString->GetToken( 0, '.') == aProjectName )
						pPrjDeps->Remove( pString );
				}
			}
		}
	}

	Remove( pPrjFound );

	return pPrjFound;
}

//
// class StarFile
//

/*****************************************************************************/
StarFile::StarFile( const String &rFile )
/*****************************************************************************/
				: aFileName( rFile )
{
	DirEntry aEntry( aFileName );
	if ( aEntry.Exists()) {
		bExists = sal_True;
		FileStat aStat( aEntry );
		aDate = aStat.DateModified();
		aTime = aStat.TimeModified();
		aDateCreated = aStat.DateCreated();
		aTimeCreated = aStat.TimeCreated();
	}
	else
		bExists = sal_False;
}

/*****************************************************************************/
sal_Bool StarFile::NeedsUpdate()
/*****************************************************************************/
{
	DirEntry aEntry( aFileName );
	if ( aEntry.Exists()) {
		if ( !bExists ) {
			bExists = sal_True;
			return sal_True;
		}
		FileStat aStat( aEntry );
		if (( aStat.DateModified() != aDate ) || ( aStat.TimeModified() != aTime )
			|| ( aStat.DateCreated() != aDateCreated ) || ( aStat.TimeCreated() != aTimeCreated ))
			return sal_True;
	}
	return sal_False;
}