// Copyright (c) 2008-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:

// e32test\nkernsa\diag.cpp

// 

//

#include <nktest/diag.h>

#ifdef __cplusplus

extern "C" {

#endif

const DiagIO* TheIoFunctions;

int InputAvailable(void)

	{

	return (*TheIoFunctions->iAvail)();

	}

char GetC(void)

	{

	int c;

	do	{

		c = (*TheIoFunctions->iPoll)();

		} while (c<0);

	return (char)c;

	}

void PutC(char c)

	{

	(*TheIoFunctions->iOut)(c);

	}

void PutS(const char* s)

	{

	while (*s)

		PutC(*s++);

	}

void PrtHex(unsigned long x, int n)

	{

	if (n>8)

		n=8;

	if (n<1)

		n=1;

	x <<= (32-4*n);

	while (n--)

		{

		char c = (char)(x>>28);

		x<<=4;

		c += '0';

		if (c > '9')

			c += ('a'-'9'-1);

		PutC(c);

		}

	}

void PrtHex2(unsigned long x)

	{

	PrtHex(x, 2);

	}

void PrtHex4(unsigned long x)

	{

	PrtHex(x, 4);

	}

void PrtHex8(unsigned long x)

	{

	PrtHex(x, 8);

	}

void NewLine(void)

	{

	PutC('\r');

	PutC('\n');

	}

void PutSpc(void)

	{

	PutC(' ');

	}

int GetAndEchoLine(char* buf, int max, const char* prompt)

	{

	int n = 0;

	PutS(prompt);

	for (;;)

		{

		int c;

		do	{

			c = GetC();

			} while (c==0x0a);	// ignore LF

		if (c==0x0d || c==0x18 || c==0x03)

			{

			if (c!=0x0d)

				n = 0;

			NewLine();

			break;

			}

		else if (c==0x08)

			{

			if (n>0)

				--n;

			}

		else if (n<max-1)

			{

			buf[n++] = (char)c;

			}

		PutC((char)c);

		}

	buf[n] = 0;

	return n;

	}

int SkipSpc(const char* s)

	{

	const char* s0 = s;

	while (*s==32 || *s==9)

		++s;

	return s - s0;

	}

int CharToHex(char c)

	{

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

		return c - '0';

	else if (c>='A' && c<='F')

		return c - 'A' + 10;

	else if (c>='a' && c<='f')

		return c - 'a' + 10;

	return -1;

	}

int ReadHex(const char* s, unsigned long* d)

	{

	const char* s0 = s;

	unsigned long x = 0;

	for (;;)

		{

		int digit = CharToHex(*s);

		if (digit < 0)

			break;

		++s;

		x = (x<<4) | ((unsigned long)digit);

		}

	*d = x;

	return s - s0;

	}

int ReadRangeHex(const char* s, unsigned long* base, unsigned long* length)

	{

	unsigned long b = 0;

	unsigned long l = 0;

	const char* s0 = s;

	char c;

	int i;

	s += SkipSpc(s);

	i = ReadHex(s, &b);

	if (i == 0)

		return 0;

	s += i;

	s += SkipSpc(s);

	c = *s;

	if (c!='+' && CharToHex(c)<0)

		return 0;

	if (c=='+')

		{

		++s;

		s += SkipSpc(s);

		}

	i = ReadHex(s, &l);

	if (i == 0)

		return 0;

	s += i;

	if (c!='+')

		{

		if (l >= b)		// inclusive end address given

			l -= (b-1);	// calculate length

		else

			l = 1;		// end < base so assume length of 1

		}

	*base = b;

	*length = l;

	return s - s0;

	}

void DumpMemory1(const void* mem, const void* disp)

	{

	int i;

	const unsigned char* s = (const unsigned char*)mem;

	PrtHex8((unsigned long)disp);

	PutC(':');

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

		{

		PutSpc();

		PrtHex2(s[i]);

		}

	PutSpc();

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

		{

		char c = s[i];

		if (c<32 || c>=127)

			c = '.';

		PutC(c);

		}

	NewLine();

	}

void DumpMemoryRange1(const void* base, unsigned long length, const void* disp)

	{

	const char* s = (const char*)base;

	const char* sd = (const char*)disp;

	do	{

		DumpMemory1(s, sd);

		s += 16;

		sd += 16;

		if (length < 16)

			length = 0;

		else

			length -= 16;

		if ((*TheIoFunctions->iPoll)() == 3)

			break;

		} while (length > 0);

	}

unsigned long _readdata(const void** pp, unsigned long bytes, int align)

	{

	unsigned long x = 0;

	unsigned long addr = (unsigned long)(*pp);

	const unsigned char* s;

	if (align)

		{

		addr += (bytes - 1);

		addr &= ~(bytes - 1);

		}

	s = (const unsigned char*)(addr + bytes);

	*pp = s;

	while (bytes--)

		x = (x<<8) | (*--s);

	return x;

	}

void DumpStruct(const char* s, const void* p)

	{

	for (;;)

		{

		char c = *s++;

		if (c == 0)

			break;

		if (c == '\n')

			PutC('\r');

		if (c != '%')

			{

			PutC(c);

			continue;

			}

		c = *s++;

		switch (c)

			{

			case '%':	PutC(c); break;

			case 'b':	PrtHex2(_readdata(&p, 1, 1)); break;

			case 'h':	PrtHex4(_readdata(&p, 2, 1)); break;

			case 'w':	PrtHex8(_readdata(&p, 4, 1)); break;

			}

		}

	}

void RunCrashDebugger()

	{

	char buf[128];

	for (;;)

		{

		int len = GetAndEchoLine(buf, 128, ".");

		(void)len;

		int i = 0;

		int err = 0;

		const char* s = buf;

		char cmd = *s++;

		switch (cmd)

			{

			case 'x':

			case 'X':

				return;

			case '\0':

				break;

			case 'm':

				{

				unsigned long mbase = 0;

				unsigned long mlen = 0;

				i = ReadRangeHex(s, &mbase, &mlen);

				if (i)

					DumpMemoryRange1((void*)mbase, mlen, (void*)mbase);

				else

					err = 2;

				break;

				}

			default:

				err = 1;

				break;

			}

		switch (err)

			{

			case 1: PutS("\r\nUnknown command\r\n"); break;

			case 2: PutS("\r\nSyntax error\r\n"); break;

			default: break;

			}

		}

	}

#ifdef __cplusplus

}

#endif