// Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// wins\specific\property.cpp

// Emulator property management for emulator settings

// 

//

#define _CRTIMP			// we want to use the static runtime library

#define __INCLUDE_CAPABILITY_NAMES__

#include "variant.h"

#include <string.h>

#include <stdlib.h>

#include <emulator.h>

#ifdef _DEBUG

#define _DUMP_PROPERTY

#endif

const char* KDefaultMachineName = "epoc";

const char* KDefaultTestMachineName = "defaulttest";

// name of the environment variable to check for default path

const char* KDefaultEpocRootName = "EPOCROOT";

TInt ScreenId=0;

// At the point this is created there is no kernel heap available

// So all memory allocation is done from a custom allocator

const TInt KMaxTokenLength = 255;

class Allocator

	{

	enum {ETotalMemory=0x10000};	// 64K

public:

	Allocator();

	TAny* Alloc(TInt aSize);

	TAny* Realloc(TAny* aCell, TInt aSize);

	void Free(TAny* aCell);

private:

	TUint iBuf[ETotalMemory];

	TUint* iFree;

	};

Allocator::Allocator()

	:iFree(iBuf)

	{}

TAny* Allocator::Alloc(TInt aSize)

	{

	aSize = (aSize + 7) >> 2;

	if (iFree + aSize > iBuf + ETotalMemory)

		return NULL;

	TUint* p = iFree;

	iFree += aSize;

	*p++ = aSize;

	return p;

	}

TAny* Allocator::Realloc(TAny* aCell, TInt aSize)

	{

	if (!aCell)

		return Alloc(aSize);

	TUint* p = (TUint*)aCell;

	TInt size = *--p;

	if (iFree == p + size)

		{

		aSize = (aSize + 7) >> 2;

		if (p + aSize > iBuf + ETotalMemory)

			return NULL;

		iFree = p + aSize;

		*p = aSize;

		return aCell;

		}

	TAny* newp = Alloc(aSize);

	if (newp)

		{

		memcpy(newp, aCell, size*sizeof(TUint));

		Free(aCell);

		}

	return newp;

	}

void Allocator::Free(TAny* )

	{

	}

Allocator TheAllocator;

///////

char* Duplicate(const char* aString)

	{

	if (aString == NULL)

		aString = "";

	TInt size = strlen(aString) + 1;

	char* p = (char*)TheAllocator.Alloc(size);

	if (p)

		memcpy(p, aString, size);

	return p;

	}

// Properties class implementation

Properties::Properties()

	:iEntries(NULL),iCount(0),iSize(0)

	{}

const char* Properties::Insert(TInt aIndex, const char* aProperty, const char* aValue)

	{

	if (iCount == iSize)

		{

		TInt size = iSize == 0 ? 8 : iSize*2;

		TAny* array = TheAllocator.Realloc(iEntries, size*sizeof(SEntry));

		if (array == NULL)

			return NULL;

		iEntries = (SEntry*)array;

		iSize = size;

		}

	char* prop = Duplicate(aProperty);

	if (prop == NULL)

		return NULL;

	char* value = Duplicate(aValue);

	if (value == NULL)

		TheAllocator.Free(prop);

	else

		{

		SEntry* e = &iEntries[aIndex];

		memmove(e+1, e, (iCount-aIndex)*sizeof(SEntry));

		e->iProperty = prop;

		e->iValue = value;

		++iCount;

		}

	return value;

	}

const char* Properties::Replace(const char* aProperty, const char* aValue)

	{

	TInt ix = Find(aProperty);

	if (ix < 0)

		return Insert(~ix, aProperty, aValue);

	// replacing a property

	SEntry& e = iEntries[ix];

	char* value = Duplicate(aValue);

	if (value != NULL)

		{

		TheAllocator.Free(e.iValue);

		e.iValue = value;

		}

	return value;

	}

const char* Properties::Append(const char* aProperty, const char* aValue)

	{

	TInt ix = Find(aProperty);

	if (ix < 0)

		return Insert(~ix, aProperty, aValue);

	// append a property

	SEntry& e = iEntries[ix];

	TInt size = strlen(e.iValue) + strlen(aValue) + 2;

	char* value = (char*)TheAllocator.Realloc(e.iValue, size);

	if (value != NULL)

		{

		strcat(value, ";");

		strcat(value, aValue);

		e.iValue = value;

		}

	return value;

	}

TInt Properties::GetString(const char* aProperty, const char*& aValue) const

	{

	TInt ix = Find(aProperty);

	if (ix < 0)

		return KErrNotFound;

	aValue = iEntries[ix].iValue;

	return KErrNone;

	}

TInt Properties::GetInt(const char* aProperty, TInt& aValue) const

	{

	TInt ix = Find(aProperty);

	if (ix < 0)

		return KErrNotFound;

	char* value = iEntries[ix].iValue;

	char* end;

	TBool neg = *value=='-';

	value += neg;

	long val = strtoul(value, &end, 0);

	if(neg)

		{

		if(val<0)

			return KErrArgument;

		val = -val;

		}

	if (*end != '\0')

		return KErrArgument;

	aValue = val;

	return KErrNone;

	}

TInt Properties::GetBool(const char* aProperty, TBool& aValue, TBool aDefaultValue) const

	{

	TInt ix = Find(aProperty);

	if (ix < 0)

		{

		aValue = aDefaultValue;

		return KErrNone;

		}

	const char* value=iEntries[ix].iValue;

	if (_stricmp(value, "on")==0 || _stricmp(value, "yes")==0 || _stricmp(value, "1")==0 || strlen(value)==0)

		{

		aValue = ETrue;

		return KErrNone;

		}

	if (_stricmp(value, "off")==0 || _stricmp(value, "no")==0 || _stricmp(value, "0")==0 )

		{

		aValue = EFalse;

		return KErrNone;

		}

	// Bool property has an illegal value!

	return KErrArgument;

	}

TInt Properties::Find(const char* aProperty) const

//

// Lookup a property in the table

// return index (>=0) if found, ~insertion-point (<0) if not

//

	{

	TInt l = 0, r = iCount;

	while (l < r)

		{

		TInt m = (l + r) >> 1;

		const SEntry& e = iEntries[m];

		TInt k = _stricmp(aProperty,e.iProperty);

		if (k < 0)

			r = m;

		else if (k > 0)

			l = m + 1;

		else

			return m;

		}

	return ~l;

	}

#ifdef _DUMP_PROPERTY

void Properties::Dump() const

	{

	for (TInt i = 0; i < iCount; ++i)

		{

		const SEntry& e = iEntries[i];

		char buf[512];

		strcpy(buf, e.iProperty);

		TInt len = strlen(e.iValue);

		if (len)

			{

			strcat(buf, " = ");

			if (len <= 256)

				strcat(buf, e.iValue);

			else

				{

				strncat(buf, e.iValue, 256);

				strcat(buf, "...");

				}

			}

		strcat(buf, "\r\n");

		OutputDebugStringA(buf);

		}

	}

#endif

// Property related variant functions

TInt Wins::EmulatorHal(TInt aFunction, TAny* a1, TAny* a2)

	{

	TInt r=KErrNone;

	switch(aFunction)

		{

		case EEmulatorHalStringProperty:

			return iProperties.GetString((const char*)a1,*(const char**)a2);

		case EEmulatorHalIntProperty:

			return iProperties.GetInt((const char*)a1,*(TInt*)a2);

		case EEmulatorHalBoolProperty:

			return iProperties.GetBool((const char*)a1,*(TBool*)a2);

		case EEmulatorHalMapFilename:

			return MapFilename(*(const TDesC*)a1,*(TDes*)a2);

		case EEmulatorHalSetFlip:

			{

			if (iUi)

				{

				TInt screen = (TInt)a2;

				if((TUint)screen < (TUint)iUi->NumberOfScreens())

					return iUi->SetFlip(TEmulatorFlip(TInt(a1)),screen);

				}

			break;

			}

		case EEmulatorHalColorDepth:

			{

			TUint colorDepth = KDefaultColorDepth;

			if(iUi)

				{

				if((TUint)a2 < (TUint)iUi->NumberOfScreens())

					colorDepth = iUi->ColorDepth((TInt)a2);

				}

			*(TUint*)a1 = colorDepth;

			return KErrNone;

			}

		case EEmulatorHalCPUSpeed:

			if (a1)

				return SetCpuSpeed(TUint(a2)/1000);

			*(TInt*)a2 = iCpuSpeed ? iCpuSpeed * 1000 : 1;

			return KErrNone;

		case EEmulatorHalNumberOfScreens:

			*(TInt*)a2 = iUi ? iUi->NumberOfScreens() : 1;

			return KErrNone;

		case EEmulatorHalSetDisplayChannel:

			if (iUi && (TUint)a1 < (TUint)iUi->NumberOfScreens())

				{

				r = iUi->SetDisplayChannel((TInt)a1, static_cast<DDisplayChannel*>(a2));

				}

			else

				{

				r = KErrNotSupported;

				}

			break;

		default:

			r=KErrNotSupported;

			break;

		}

	return r;

	}

const char* KExtensionListNormal = "btracex.ldd;hcr.dll;winsgui;elocd.ldd;medint.pdd;medlfs.pdd;medmmc.pdd;epbusmmc.dll;epbusv.dll";

const char* KExtensionUsiiNand = "?medusiiw.pdd";

const char* KExtensionUsiiNandLoader = "?medusiiws.pdd";

const char* KExtensionUsiiNandTest = "?medusiiwt.pdd";

const int KMaxEpocRootSize = 120;

TInt Wins::InitProperties(TBool aRunExe)

	{

	if (iProperties.Replace("MachineName", KDefaultMachineName) == NULL)

		return KErrNoMemory;

    char epocRoot[KMaxEpocRootSize];

    TInt total = GetEnvironmentVariableA( KDefaultEpocRootName, epocRoot, KMaxEpocRootSize);

    if (total != 0)

		{

	    if (iProperties.Replace("EpocRoot", epocRoot) == NULL)

    	    return KErrNoMemory;

		}

	if (iProperties.Append("Extension", KExtensionListNormal) == NULL)

		return KErrNoMemory;

	char overrideCDrive[MAX_PATH];

	overrideCDrive[0] = '\0';

	TInt r = ProcessCommandLine(aRunExe, overrideCDrive);

	if (r != KErrNone)

		return r;

	r = SetupPaths();

	if (r != KErrNone)

		return r;

	r = LoadProperties();

	if (r != KErrNone)

		return r;

	//	get Unistore II Media Driver type from epoc.ini

	const char* value = NULL;

	iProperties.GetString("NandDriverType", value);

	if (value)

		{

		if (value && _stricmp("XSR",value)==0)

			{

			// epoc.ini "NandDriverType=XSR" for XSR/Unistore-II driver

			if (iProperties.Append("Extension", KExtensionUsiiNand) == NULL)

				return KErrNoMemory;		

			}

		else if (value && _stricmp("XSRNandloader",value)==0)

			{

			// epoc.ini "NandDriverType=XSRNandloader" for XSR/Unistore-II nandloader driver

			if (iProperties.Append("Extension", KExtensionUsiiNandLoader) == NULL)

				return KErrNoMemory;		

			}

		else if (value && _stricmp("XSRTest",value)==0)

			{

			// epoc.ini "NandDriverType=XSRTest" for XSR/Unistore-II test driver

			if (iProperties.Append("Extension", KExtensionUsiiNandTest) == NULL)

				return KErrNoMemory;

			}

		else	

			{

			// If epoc.ini contains "NandDriverType=???" but ??? not equal to any

			// of above XSR driver types then load production/release XSR

			// driver

			if (iProperties.Append("Extension", KExtensionUsiiNand) == NULL)

				return KErrNoMemory;

			}

		}

	else

		{

		// Load the production/release XSR driver, if value is NULL

		if (iProperties.Append("Extension", KExtensionUsiiNand) == NULL)

			return KErrNoMemory;

		}

	// Get the name of the extension media drivers from epoc.ini (optional)

	value = NULL;

	iProperties.GetString("MediaExtensionDriver", value);

	if (value)

		{

		if (iProperties.Append("Extension", value) == NULL)

			return KErrNoMemory;		

		}

//	load additional configuration specific properties

//	get the multi property "configuration"

	value = NULL;

	iProperties.GetString("configuration", value);

//	load each one of these

//	check for any screen specific properties in the main epoc.ini

//	if configuration property is set

	if (value && !iConfigPropertySet)	//configuration

		{

		iConfigId = 0;

		char configFileName[100];

		do

			{

			//load each set of properties

		   const char * pdest = strchr(value, ';');

		   TInt result = pdest - value;

		   if(pdest)

			   {

			   strncpy(configFileName, value, result);

			   configFileName[result] = '\0';

			   value = value + result + 1;

			   }

		   else

			   {

			   strcpy(configFileName, value);

			   value += strlen(value);

			   }

			r = LoadConfigSpecificProperties(configFileName);

			if (r == KErrNone)

				iConfigId++;

			}

		while(*value);

		}

	char scr[30];

	//if iConfigId is zero, there is only 1 configuration

	wsprintfA(scr, "ConfigCount %d", iConfigId ? iConfigId : 1);

	r = AddProperty(scr, scr+strlen(scr));

	if (r != KErrNone)

		return r;

	r = SetupMediaPath();

	if (r != KErrNone)

		return r;

	if (overrideCDrive[0] != '\0')

		SetupDrive('c', overrideCDrive);

	if (iProperties.Append("Extension", "exstart") == NULL)

		return KErrNoMemory;

#ifdef _DUMP_PROPERTY

	iProperties.Dump();

#endif

	return KErrNone;

	}

char* skipws(char* aPtr)

	{

	while (isspace(*aPtr))

		++aPtr;

	return aPtr;

	}

char* skiptok(char* aPtr)

	{

	if (*aPtr == '\"')

		{

		++aPtr;

		while (*aPtr && *aPtr++ != '\"')

			{}

		}

	else

		{

		while (*aPtr && !isspace(*aPtr))