/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: 

*

*/

#define __INCLUDE_CAPABILITY_NAMES__

#include <stdarg.h>

#include <stdlib.h>

#include <e32std.h>

#include <e32std_private.h>

#include "h_utl.h"

#if defined(__MSVCDOTNET__)|| defined(__TOOLS2__)

#else //!__MSVCDOTNET__

#include <string.h>

#endif //__MSVCDOTNET__

#ifdef __LINUX__

 // Convert the supplied string to uppercase, in-place 

 char* strupr(char *a)

    {

     char *ret = a;

    while (*a)

        {

        *a = toupper(*a);

        a++;

         }

     return ret;

     }

 off_t filelength(int filedes)

     {

     struct stat buf;

     if(!fstat(filedes, &buf))

         {

        return buf.st_size;

         }

    perror("fstat failed");

   return 0;

    }

#endif

TBool PVerbose=ETrue;

HPrint H;

HPrint::~HPrint()

	{

	iLogFile.close();

	}

void HPrint::SetLogFile(const char* aFileName)

	{

	iLogFile.open(aFileName);

	}

/**

Closing the logfile.(since 'n' number of drive images can be created)

@internalComponent

@released

*/

void HPrint::CloseLogFile()

	{

	if(iLogFile.is_open())

		iLogFile.close();

	}

TInt HPrint::PrintString(TPrintType aType,const char *aFmt,...)

//

// Print text, noting where to send it.

//

	{

	TInt r=KErrNone;

	va_list list;

	va_start(list,aFmt);

	_vsnprintf((char *)iText,KMaxStringLength,aFmt,list);

	va_end(list);

	switch (aType)

		{

	case EAlways:

		cout << iText;

		iLogFile << iText;

		break;

	case EScreen:

		cout << iText;

		break;

	case ELog:

		if (iVerbose)

			cout << iText;

		iLogFile << iText;

		break;

	case EWarning:

		cerr << "WARNING: " << iText;

		iLogFile << "WARNING: "<<iText;

		break;

	case EError:

		cerr << "ERROR: " << iText;

		iLogFile << "ERROR: " << iText;

		r=KErrGeneral;

		break;

	case EPeError:

		if (PVerbose)

			{

			cerr << "ERROR: " << iText;

			iLogFile << "ERROR: " << iText;

			}

		r=KErrGeneral;

		break;

	case ESevereError:

		cerr << "ERROR: " << iText;

		iLogFile << "ERROR: " << iText;

		r=KErrGeneral;

		break;

	case EDiagnostic:

		cerr << "DIAGNOSTIC MESSAGE: " << iText;

		iLogFile << "DIAGNOSTIC MESSAGE: "<<iText;

		break;

	default:

		cerr << "ERROR: Invalid print type" << endl;

		r=KErrGeneral;

		}

	cout.flush();

	iLogFile.flush();

	return r;

    }

TVersion::TVersion()

	{}

TVersion::TVersion(TInt aMajor, TInt aMinor, TInt aBuild)

	: iMajor((TInt8)aMajor), iMinor((TInt8)aMinor), iBuild((TInt16)aBuild)

	{}

#if defined(__TOOLS2__ ) ||  defined(__MSVCDOTNET__ )

istringstream &operator>>(istringstream &is, TVersion &aVersion)

#else

istrstream &operator>>(istrstream &is, TVersion &aVersion)

#endif

//

// Input a TVersion with syntax: major[.minor][(build)]

//	

	{

#if defined(__TOOLS2__ ) ||  defined(__MSVCDOTNET__ )

string tmp = is.str();

const char *str=tmp.c_str();

#else

#ifdef __LINUX__

    char *str = is.rdbuf()->str();

#else

    char *str=is.str();

#endif

#endif

	TInt build=0;

	memset(&aVersion, 0, sizeof(TVersion));	

	TInt i;

	TInt len=strlen(str);

	for (i=0; i<len; i++)

		if (str[i]=='(')

			break;

	if (i<len)

		build=atoi(str+i+1);

	aVersion.iMajor = (TInt8)Min(KMaxTInt8, atoi(str));

	int majorV = atoi(str);

	// iMajor is defined as TInt8 so it should not be bigger than 127

	if (majorV > 127)

		{ 

		cout << "\n Warning: major version must be in range 0 - 127 \n";

		}

	char* pMinor = (char*)strchr(str, '.');

	if (pMinor)

		{

		pMinor++; 

		aVersion.iMinor = (TInt8)Min(KMaxTInt8, atoi(pMinor));

		int minorV = atoi(pMinor);

		// iMinor is defined as TInt8 so it should not be bigger than 127

		if (minorV > 127)

			{ 

			cout << "\n Warning: minor version must be in range 0 - 127 \n";

			}

		}	

	aVersion.iBuild=(TInt16)build;

	return is;

	}

TInt Locate(const char *aString, char aChar)

//

// Locate aChar in aString

//

	{

	if (aString==NULL)

		return KErrNotFound;

	TInt i=0;

	while (*aString!=0)

		{

		if (*aString==aChar)

			return i;

		aString++;

		i++;

		}

	return KErrNotFound;

	}

#define KHoursToMicroSeconds	Int64(3600000000UL) 

#define KDaysToMicroSeconds		(Int64(24)*KHoursToMicroSeconds)

const TInt KMinutesToMicroSeconds = 60000000;

const TInt KSecondsToMicroSeconds =  1000000;

const TInt8 mTab[2][12]=

    {

    {31,28,31,30,31,30,31,31,30,31,30,31}, // 28 days in Feb

    {31,29,31,30,31,30,31,31,30,31,30,31}  // 29 days in Feb

    };

TInt Time::LeapYearsUpTo(TInt aYear)

//

// from 0AD to present year according to the rule above

//

	{

	if (aYear<=0)

		return(aYear/4);

	if (aYear<=1600)

		return(1+((aYear-1)/4));

	TInt num=401; // 1600/4+1

	aYear-=1601;

	num+=(aYear/4-aYear/100+aYear/400);

	return(num);

	}

TBool Time::IsLeapYear(TInt aYear)

//

// up to and including 1600 leap years were every 4 years,since then leap years are every 4 years unless

// the year falls on a century which is not divisible by 4 (ie 1900 wasnt,2000 will be)

// for simplicity define year 0 as a leap year

//

	{

	if (aYear>1600)

    	return(!(aYear%4) && (aYear%100 || !(aYear%400)));

	return(!(aYear%4));

	}

Int64 ConvertTime(TInt aDay, TInt aMonth, TInt aYear, TInt aHour, TInt aMinute, TInt aSecond, TInt aMilliSeconds)

//

// converts TDateTime into a TTime, doesnt check for overflows

//

	{

	TInt days=365*aYear+Time::LeapYearsUpTo(aYear);

	TBool isleap=Time::IsLeapYear(aYear);

	for (TInt ii=0; ii<aMonth; ii++)

	    days+=(mTab[isleap][ii]);	

	days+=aDay;

	TInt sum=aMilliSeconds+aSecond*KSecondsToMicroSeconds;

	return((Int64(days)*KDaysToMicroSeconds+Int64(aHour)*KHoursToMicroSeconds) 

			+(Int64(KMinutesToMicroSeconds)*Int64(aMinute)+Int64(sum))); 

	}

TInt StringToTime(Int64 &aTime, char *aString)

//

// Convert string to time. String is in the format:

//

// dd/mm/yyyy hh:mm:ss.mmmmmmm

//

	{

	TInt day=1;

	TInt month=1;

	TInt year=1997;

	TInt hour=10;

	TInt minute=10;

	TInt sec=0;

	TInt mill=0;

	char ch;

	#if defined(__TOOLS2__) || defined(__MSVCDOTNET__)

	istringstream val(aString);

	#else

	istrstream val(aString,strlen(aString));

	#endif

	val >> dec >> day; // locks istrstream in decimal mode for further extractions

	val >> ch;

	if (ch!='/')

		return KErrGeneral;

	val >> month;

	val >> ch;

	if (ch!='/')

		return KErrGeneral;

	val >> year;

	val >> ch;

	if (ch=='_')

		{

		// time too.

		val >> hour;

		val >> ch;

		if (ch!=':')

			return KErrGeneral;

		val >> minute;

		val >> ch;

		if (ch!=':')

			return KErrGeneral;

		val >> sec;

		val >> ch;

		if (ch=='.')

			{

			val >> mill;

			}

		}

	if (day<1 || day>31)

		return KErrArgument;

	if (month<1 || month>12)

		return KErrArgument;

	if (year<1970 || year>2060)

		return KErrArgument;

	if (hour<0 || hour>23)

		return KErrArgument;

	if (minute<0 || minute>59)

		return KErrArgument;

	if (sec<0 || sec>59)

		return KErrArgument;

	if (mill<0 || mill>999999)

		return KErrArgument;

	aTime=ConvertTime(day-1, month-1, year, hour, minute, sec, mill);

	return KErrNone;

	}

void ByteSwap(TUint &aVal)

	{

	TUint t0=aVal & 0xff;

	TUint t1=(aVal>>8)  & 0xff;

	TUint t2=(aVal>>16) & 0xff;

	TUint t3=aVal>>24;

	aVal=(t0 << 24) | (t1 << 16) | (t2 << 8) | (t3);

	}

void ByteSwap(TUint16 &aVal)

	{

	TUint16 t0=(TUint16)((aVal >> 8) & 0xff);

	TUint16 t1=(TUint16)(aVal & 0xff);

	aVal=(TUint16)((t1 << 8) | t0);

	}

void ByteSwap(TUint *aPtr, TInt aSize)

	{

	while ((aSize-=4)>=0)

		ByteSwap(*aPtr++);

	}

TBool IsBracketedHex(const char* s, const char* brackets, TInt digits, TUint32& aValue)

	{

	if (s[0]!=brackets[0] || s[1+digits]!=brackets[1])

		return EFalse;

	TInt i;

	TUint32 x = 0;

	for (i=1; i<=digits; ++i)

		{

		TInt c = s[i];

		if (c>='a' && c<='z') c-=32;

		if (c<'0' || (c>'9' && c<'A') || c>'F')

			return EFalse;

		c-='0';

		if (c>9) c-=7;

		x = (x<<4) | (TUint32)c;

		}

	aValue = x;

	return ETrue;

	}

TInt CheckForDecimalVersion(const char* begin, const char* s, TUint32& aValue)

	{

	aValue = 0;

	if (s <= begin || *s != '}')

		return 0;

	TUint32 v[2] = {0,0};

	TUint32 m = 1;

	TInt pos = 0;

	const char* s0 = s + 1;

	for (--s; s >= begin; --s)

		{

		int c = *s;

		if (c >= '0' && c <= '9')

			{

			v[pos] += m * (c - '0');

			if (v[pos] >= 65536u)

				return 0;

			m *= 10;

			}

		else if (c == '.')

			{

			m = 1;

			if (++pos >= 2)

				return 0;

			}

		else if (c == '{')

			break;

		else

			return 0;

		}

	if (s < begin)

		return 0;

	aValue = (v[1] << 16) | v[0];

	return s0 - s;

	}

// Decompose a name of the form NAME{MMMMmmmm}[UUUUUUUU].EXT where the bracketed

// sections and extension are both optional.

// Return a newly malloc-ed string containing NAME.EXT

// Set aUid = 0xUUUUUUUU if present, 0 if not

// Set aModuleVersion = 0xMMMMmmmm if present, 0 if not

// Set aFlags according to which of these are present

char* SplitFileName(const char* aName, TUint32& aUid, TUint32& aModuleVersion, TUint32& aFlags)

	{

	TFileNameInfo f(aName, ETrue);

	aUid = f.iUid3;

	aModuleVersion = f.iModuleVersion;

	aFlags = f.iFlags;

	TInt nl = f.iBaseLength;

	TInt el = f.iTotalLength - f.iExtPos;

	TInt tl = nl + el;

	char* t = (char*)malloc(tl + 1);

	if (t)

		{

		memcpy(t, aName, nl);

		if (el)

			memcpy(t + nl, aName + f.iExtPos, el);

		t[tl] = 0;

		}

	return t;

	}

// Decompose a name of the form NAME{MMMMmmmm}.EXT where the bracketed

// sections and extension are both optional.

// Return a newly malloc-ed string containing NAME.EXT

// Set aModuleVersion = 0xMMMMmmmm if present, 0 if not

// Set aFlags according to whether version present

char* SplitFileName(const char* aName, TUint32& aModuleVersion, TUint32& aFlags)

	{

	TFileNameInfo f(aName, EFalse);

	aModuleVersion = f.iModuleVersion;

	aFlags = f.iFlags;

	TInt nl = f.iBaseLength;

	TInt el = f.iTotalLength - f.iExtPos;

	TInt tl = nl + el;

	char* t = (char*)malloc(tl + 1);

	if (t)

		{

		memcpy(t, aName, nl);

		if (el)

			memcpy(t + nl, aName + f.iExtPos, el);

		t[tl] = 0;

		}

	return t;

	}

// Parse a filename and convert decimal version number to hex

char* NormaliseFileName(const char* aName) {

	//convert forward slashes into back slashes.

	char* filename = strdup(aName);  //prevent violated access from stack.	

#ifdef WIN32