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