/**
	@file
		DHL_DBG_Shell.c

	@brief
		DHL mini debug shell implementation

	Copyright 2006~2010 Digital STREAM Technology, Inc.
	All Rights Reserved
*/


#include "DHL_OSAL.h"
#include "DHL_DBG.h"

#include "DHL_OSAL_Priv.h" // get line API
#include "DHL_DBG_Priv.h" // symtab API
#include "DHL_OSAL_Config.h"

//#include <string.h>
#include <stdio.h>

/*
	모든 헤더 파일을 포함하지는 않으며, compile time을 줄이기 위해
	각 모듈은 필요한 만큼의 헤더를 선언하도록 함.
*/



/*
	DHL 디버그 모듈 이름 정의 룰 참고:

	DHL 모듈들은 모두 * 로 시작.
	API는 대문자, Platform 및 기타는 소문자 사용.

	디폴트 레벨은 0으로 설정한다. (0: 에러 메시지만 출력)
	
	
*/

DHL_MODULE("*shl", 0);



#if COMMENT
____Config____(){}
#endif

/*
	이 모듈 내부에서 사용되는 각종 configuration 정의.
*/

#define SUPPORT_DBG_SHELL 1
	// image size를 줄이기 위해 shell 코드를 완전히 제거하고 싶다면 
	// 이 flag 값을 0으로 설정하면 된다.


#if SUPPORT_DBG_SHELL
	// 이 if 조건은 "굉장히" 넓은 조건으로, 이 파일 소스 코드의 대부분을 포함한다.


#define SHELL_DEBUG 1



#define MAX_SHELL_HISTORY 30


/*
	naming rule: SHELL_XXXXX
	values: 0 or 1
*/

#define SHELL_USE_SHELL_TASK 0
	// 1이면 shell 전용 task를 사용한다.
	//
	// 제공되는 platform에서 shell이 이미 제공되는 경우
	// 두개의 shell 동작이 불가함으로 
	// minishell은 dispatch extension으로 동작해야 한다. 
	// 그럴 경우 0 으로 하고, command dispatch 를 사용하여 동작하도록 한다.


#define SHELL_INTERNAL_ECHO 1
	// 1이면 shell 내부에서 local echo (입력 받은 문자를 다시 화면에 출력) 한다.
	//
	// stdio api와 서로 맞춰야 한다.
	// 가능하면 stdio 에서는 echo를 하지 말고 
	// 여기 shell에서 local echo를 하는 게 권장됨.


#define SHELL_AUTHORIZED_ACCESS 0
	// 1이면 임의의 사용자가 shell 접근을 하지 못하도록 
	// passwd를 통한 authorized 사용자만을 접근 허용한다.
	//
	// 보안이 필요한 경우 양산 SW build 시에 사용 가능. 
	// 반드시 필요하지는 않음.

#define SHELL_SUPPORT_BG_EXE 1
	// 1이면 shell 명령을 실행할 때 background 실행 flag가 있는 경우 
	// 별도의 task를 생성하는 것을 허용한다.
	//
	// 메모리가 부족하지 않고, task 생성에 제약이 없는 경우 사용 권장.

#define SHELL_ALLOW_EXIT 1
	// 1이면 'exit' 명령을 입력하여 shell exit을 허용한다.
	//
	// linux 처럼 multi processing이 가능한 os에서 유용.
	// 기타 os에서는 허용하지 않도록 해야 한다.

#define SHELL_SUPPORT_EXT_KEY 1
	// 1이면 LG box/LG term 에서 사용 가능한 확장 키를 지원한다.
	//
	// platform에 맞춰서 설정.

#define SHELL_ECHO_TEST 1
	// 1이면 echo 명령에 의한 echo test 코드 포함한다.
	//
	// 확장키 등의 테스트에 유용하게 사용된다.
	// serial emulator등의 터미널 타입이 특수한 경우 
	// echo test로 적절한 key code를 찾아낼 수 있다.


#define SHELL_USE_OS_SYMBOL 0
	// 1이면 os symbol (build 과정에서 linker가 만들어주는 symbol) 을 사용한다.
	//
	// 보통 symtable on/off flag는 makefile 등에서 설정하기 때문에 
	// 여기서는 항상 1로 하는 것이 권장된다.


#define SHELL_SUPPORT_INPUT_EMULATION 0
	// 임시..
	// @todo ..

#define SHELL_SUPPORT_HISTORY 1
	// 1이면 과거 입력 명령들의 재활용 기능 추가.
	


#if COMMENT
____Types____(){}
#endif

/*
	이 모듈 내부에서 사용되는 structure 및 enumerations.
*/


typedef UINT32 (*SHELL_CMD_HANDLER_TYPE)(int,...);


#if SHELL_SUPPORT_BG_EXE
#define DHL_SHELL_BG_TASK_PRIORITY  TASK_PRI_DHL_SHELLX
#define DHL_SHELL_BG_TASK_STACKSIZE 16384
#endif


#define DHL_SHELL_TASK_PRIORITY   TASK_PRI_DHL_SHELL
#define DHL_SHELL_TASK_STACKSIZE  16384


#if SHELL_AUTHORIZED_ACCESS
static BOOL s_buser_authorized;
	// 일단 1로 해두자.
	// 나중에 양산시에는 디폴트로 0이 되고
	// authorize 된 사용자에게만 shell 사용이 허가된다
#endif // SHELL_AUTHORIZED_ACCESS


#if SHELL_ALLOW_EXIT
// shell exit 요청 flag
static BOOL s_request_exit;
#endif // SHELL_ALLOW_EXIT


static DHL_OS_TASK_ID s_shell_tid;


// cafrii 070302, argument 8개 제한 사항을 없앰.
typedef struct 
{
	void *fn;   // function pointer
	int n_arg;
	int args[1]; // 사실은 1개가 아니라 필요한 만큼 가변적으로 할당한다.
	
} DebugShellParam;

#define SIZE_OF_DEBUG_SHELL_PARAM(n_arg) \
		(sizeof(DebugShellParam) + sizeof(int)*(n_arg))



#define MAX_CALL_ARG 8 // for newcon3, <- 32


#define DHL_SHELL_MAX_CMDLINE 255

// cafrii 061226 new shell token management design
//
#define DHL_SHELL_MAX_TOKEN_LEN 80
#define DHL_SHELL_MAX_TOKEN (MAX_CALL_ARG + 4) //10

typedef enum
{
	ShellToken_Unknown = 0,
	
	ShellToken_Digit,
	ShellToken_HexDigit,
	ShellToken_String,
	ShellToken_Symbol,

} DebugShellTokenType;


typedef struct
{
	char text[DHL_SHELL_MAX_TOKEN_LEN+1]; // max 80 characters

	DebugShellTokenType type;

	union {
		UINT32 value; // if text is digit..
		void *addr;   // if text is symbol..
		char *string; // if text is string..
	} u;

} DebugShellToken;


//DebugShellToken *g_dbg_tokens;


typedef struct
{
	char cmdline[DHL_SHELL_MAX_CMDLINE];
	
	DebugShellToken *tokens;
	

	BOOL bCmdMatched;

} DebugShellContext;



// 유효한 call 주소 영역인지 체크하는 macro.
//
#define DHL_VALID_ADDR(ad) 0 // 임시.. dhl_dbg_is_text_symbol((UINT32)ad)
		// call 가능한 text symbol 인지 체크..
		// dhl_dbg api 가 제공되니 그것을 사용할 것..



// cafrii 061212 add
//   ZMon에서 입력되는 모든 address는 다음과 같은 form을 취해야 한다.
//   0x12345678  또는  0X12345678
//
#define DHL_VALID_HEX_ADDR(s) ( \
	((s)[0] == '0') && ((s)[1] == 'x' || (s)[1] == 'X') && (strlen(s) == 8) )



#if COMMENT
____Variables____(){}
#endif

/*
	global로 적용되는 variable 정의.
	각 function 별로 특수한 용도의 variable은 각 functionX block 에서 정의 가능.
*/



#if COMMENT
____History____(){}
#endif


static char *g_dhl_pShellHistory[MAX_SHELL_HISTORY];

static void shell_add_to_history(char *buf)
{
	// history buffer의 맨 앞으로 push 된다.
	// 만약 완전히 동일한 command가 history buf에 이미 있으면 그 buf는 삭제된다.
	int i, k;
	char *p = NULL;
	
	if (buf == NULL || buf[0] == 0) return;

	// 동일한 내용 검색..
	for (i=0; i<MAX_SHELL_HISTORY; i++) {
		if (g_dhl_pShellHistory[i] && strcmp(buf, g_dhl_pShellHistory[i])==0) {
			p = g_dhl_pShellHistory[i];
			break;
		}
	}

	if (p && i < MAX_SHELL_HISTORY) // 동일한 것이 존재한다.
	{
		// i를 맨 앞으로 위치 이동..
		g_dhl_pShellHistory[i] = NULL;
		for (k=i; k>0; k--)
			g_dhl_pShellHistory[k] = g_dhl_pShellHistory[k-1];
		g_dhl_pShellHistory[0] = p;
		return;
	}

	p = DHL_OS_Malloc(strlen(buf)+1);
	strcpy(p, buf);
	
	if (g_dhl_pShellHistory[MAX_SHELL_HISTORY-1])
		DHL_OS_Free((void **)&g_dhl_pShellHistory[MAX_SHELL_HISTORY-1]);
	
	for (i=MAX_SHELL_HISTORY-1; i>0; i--)
		g_dhl_pShellHistory[i] = g_dhl_pShellHistory[i-1];

	g_dhl_pShellHistory[0] = p;
}


static void shell_cmd_history(DebugShellToken *tokens, int nToken)
{
	int i;

	DHL_UNUSED(tokens);
	DHL_UNUSED(nToken);
	
	for (i=MAX_SHELL_HISTORY-1; i>=0; i--) {
		if (g_dhl_pShellHistory[i] == 0) continue;
		DHL_OS_Printf("  (%2d) '%s'\n", i, g_dhl_pShellHistory[i]);
	}
}




#if COMMENT
____Symbol____(){}
#endif


/*
	symbol을 분석한다.

	먼저 os symtab을 보고, 그 다음에 DHL symtab을 찾는다.

*/

#define SYM_TYPE_UNKNOWN 0
#define SYM_TYPE_TEXT 1
#define SYM_TYPE_DATA 2

static void *shell_lookup_symbol(char *str, int *pType)
{
	UINT32 calladdr;
	int type;

	/* alias symbol에 우선 순위를 두도록 한다. */
	if (DHL_DBG_QuerySymbol(str, (void **)&calladdr, &type) == DHL_OK && 
		type == DHL_SYM_FN) {

		if (pType) *pType = type;

		return (void *)calladdr;
	}
	
#if SHELL_USE_OS_SYMBOL
	calladdr = dhl_dbg_find_sym_by_name(str);

	if (calladdr)
	{
		if (pType)
		{
			if (dhl_dbg_is_text_symbol(calladdr))
				*pType = DHL_SYM_FN;
			else if (dhl_dbg_is_data_symbol(calladdr))
				*pType = DHL_SYM_V4;
			else
				*pType = DHL_SYM_NONE;
		}
		return (void *)calladdr;
	}
#endif // SHELL_USE_OS_SYMBOL

	return NULL;
	
}



#if COMMENT
____Parser____(){}
#endif


/*
	shell command line 파서 디자인.

	1. string 입력을 지원한다.
		ex) print "this is test" -> arg[0] "print", arg[1] "this is test"

	2. string 내의 escape sequence를 지원한다.
	
	3. comma in string is treated as it is..

	return
		맨 앞 command 부분을 포함하여, 분리된 전체 token 갯수를 리턴.
*/

static int shell_parse_line_to_tokens(char *buf, DebugShellToken *tokens, int maxtoken)
{
	//int i, n;
	char *p = buf;
	BOOL inside_quote = FALSE;
	DebugShellToken *t = tokens;

	// 토큰 인텍스 (몇 번 째 토큰인지?)
	int num_tokens = 0;
	// 현재 토큰 안에서의 writer pointer index (현재 트큰의 길이)
	int len = 0;

	DHL_ASSERT(tokens!=NULL, "token should be non-null");

	#define NEW_TOKEN()  \
		num_tokens=0; len=0; memset(t, 0, sizeof(*t)); 
	
	#define NEXT_TOKEN()  \
		t->text[len] = 0; t++; num_tokens++; len=0; \
		if (num_tokens>=DHL_SHELL_MAX_TOKEN) goto label_end; \
		memset(t, 0, sizeof(*t));

	#define END_TOKEN()  \
		t->text[len] = 0; t++; num_tokens++; len=0;

	#define INPUT_CH(c) \
		if (len<DHL_SHELL_MAX_TOKEN_LEN) { t->text[len]=(c); len++;}


	NEW_TOKEN();

	while (*p)
	{
		if (*p == '"') 
		{
			if (inside_quote) // string 처리 중이면 string 종료.
			{
				INPUT_CH(*p);
				inside_quote = FALSE;

				NEXT_TOKEN();
			}
			else 
			{
				// 새롭게 string을 시작한다.
				// 만약 그 이전 token이 종료가 안된 거라면 
				// 여기서 먼저 종료하고 새 token 진행.
				// 예:  test"code" -> arg1 'test' arg2 'code'
				
				if (len) {
					NEXT_TOKEN();
				}

				inside_quote = TRUE;
				INPUT_CH(*p);
			}
			
			p++;
			continue;
		}

		if (inside_quote)
		{
			if (*p == '\\' && *(p+1) == '"') {
				// escape sequence 내의 quote 기호는 그대로 통과시킨다.
				INPUT_CH('\\');
				INPUT_CH('"');
			}
			else {
				INPUT_CH(*p);
			}
		}
		else
		{
			if (*p == ' ' || *p == '\r' || *p == '\n' || *p == ',') {
				if (len) {
					NEXT_TOKEN();
				}
			}
			else if (*p == ';') {  // cafrii 070124 add
				// it is comment from this..
				break;
			}
			else {
				INPUT_CH(*p);
			}
		}
		
		p++;
	}

label_end:

	if (len) {
		END_TOKEN();
	}
	
	return num_tokens;
}


// 
//  단어 해석하는 함수.  
// 
//  현재 인식 가능한 단어는 string, 10진수, 16진수, symbol 이다.
//  
//  10진수, 16진수의 경우 - 기호를 지원하고 overflow check는 하지 않는다.
//
static void shell_translate_one_token(int idx, DebugShellToken *token)
{
	char *text;
	int value;
	
	if (token == NULL) return;

	text = token->text;

	if (text[0] == 0) {
		token->type = ShellToken_Unknown;
		token->u.value = 0;
		return;
	}

	if (text[0] == '"') { // this token is probably string.

		token->type = ShellToken_String;
		token->u.string = &text[1];  // skip quote sign..

		// trim last trailing quote sign
		if (token->u.string[strlen(token->u.string)-1] == '"') {
			token->u.string[strlen(token->u.string)-1] = 0;
		}
		else
			DHL_OS_Printf("!! token[%d] (%s) trailing quote sign not found\n", idx, text);
		return;
	}

	if (1)  // check if digit..  
	{
		// 현재 overflow 체크는 하지 않는다.
		//
		int i, len, negative = 0;
		value = 0;

		if (text[0] == '-') {
			negative = 1;
			text++;
		}
		
		if (text[0] == '0' && (text[1] == 'x' || text[1] == 'X')) {
			token->type = ShellToken_HexDigit;
			text += 2;
		}
		else
			token->type = ShellToken_Digit;

		len = strlen(text);
		for (i=0; i<len; i++) 
		{
			if (token->type == ShellToken_HexDigit) {
				if (
					!((text[i] >= '0' && text[i] <= '9') ||
					(text[i] >= 'A' && text[i] <= 'F') ||
					(text[i] >= 'a' && text[i] <= 'f')))
				{
					//DHL_OS_Printf("!! token[%d] '%s' not hex digit\n", idx, text);
					token->type = ShellToken_Unknown;
					break;
				}
				value = (value << 4UL) + (
					(text[i] >= '0' && text[i] <= '9') ? (text[i] - '0') :
					(text[i] >= 'A' && text[i] <= 'F') ? (text[i] - 'A' + 10) :
					(text[i] >= 'a' && text[i] <= 'f') ? (text[i] - 'a' + 10) : 0);
			}
			else {
				if (!(text[i] >= '0' && text[i] <= '9')) {
					//DHL_OS_Printf("!! token[%d] '%s' not decimal digit\n", idx, text);
					token->type = ShellToken_Unknown;
					break;
				}
				value = value * 10 + (text[i] - '0');
			}
		}

		if (token->type != ShellToken_Unknown) {
			token->u.value = negative ? -1*value : value;
			return;
		}
	}

	// symbol 가능성 체크..
	//
	if (1)
	{
		void *addr = shell_lookup_symbol(token->text, 0);

		//printf("lookup symtab (%s) return %d\n", token->text, addr);
		
		if (addr == NULL) {
			DHL_OS_Printf("!! token[%d] '%s' not symbol\n", idx, text);
				// 이런 경고를 보기 싫으면 항상 string은 quote 마킹을 하면 된다.
				// ex:
				//  Shell> symlkup dbg    --> error message and symbol lookup.
				//  Shell> symlkup "dbg"  --> symbol lookup without error message
				
		}
		else {
			token->u.addr = addr;
			token->type = ShellToken_Symbol;
			return;
		}
	}

	// 마지막 남은 것은 string 뿐이다.

	token->u.string = token->text;
	token->type = ShellToken_String;

	return;
	
}


static void shell_translate_tokens(DebugShellToken *token, int nToken)
{
	int i;
	
	// 맨 처음 token은 command 라서 
	for (i=0; i<nToken; i++) {
		shell_translate_one_token(i, &token[i]);
	}

#if SHELL_DEBUG
	if (dprintable(2))
	{
		char buf2[100];
		sprintf(buf2, "== %d tokens: ", nToken);
		for (i=0; i<nToken; i++) {
			sprintf(buf2 + strlen(buf2), "%c[%s] ", 
			token[i].type == ShellToken_Digit ? 'd' :
			token[i].type == ShellToken_HexDigit ? 'h' :
			token[i].type == ShellToken_Symbol ? 'm' :
			token[i].type == ShellToken_String ? 's' : '?',
			token[i].type == ShellToken_String ? token[i].u.string : token[i].text);
		}		
		strcat(buf2, "\n");
		DHL_OS_Printf(buf2);
	}
#endif
	
}






#if COMMENT
____Cmds____(){}
#endif

struct dispatch_tbl_t
{
	char *name;
	void (*fnptr)(DebugShellToken *, int);
	char *help;
};
static struct dispatch_tbl_t *shell_get_dispatch_table(void);

static void shell_cmd_help(DebugShellToken *tokens, int nToken)
{
	int i;
	struct dispatch_tbl_t *dpt = shell_get_dispatch_table();

	DHL_UNUSED(tokens);
	DHL_UNUSED(nToken);
	
	DHL_OS_Printf("help:\n");

	for (i=0; ; i++) {
		if (dpt[i].name == NULL) break;
		DHL_OS_Printf(" %-8s - %s\n", dpt[i].name, dpt[i].help);
	}
}


#if SHELL_ECHO_TEST

static void shell_cmd_echo(DebugShellToken *tokens, int nToken)
{
	// this is previously KeyCodeSampler().

	UINT32 key, prev_key = 0xffffffff, repeat = 0;

	DHL_UNUSED(tokens);
	DHL_UNUSED(nToken);
	
	DHL_OS_Printf("EchoTest: press same key 5 times to exit\n");

	while (1) 
	{
		while ((key = DHL_OS_GetChar()) == DHL_EXTKEY_NONE) 
			DHL_OS_Delay(20);

		DHL_OS_Printf("Incoming key: 0x%08x\n", key);

		if (key == prev_key) {
			if (++repeat > 5)
				break;
		}
		else {
			repeat = 0;
			prev_key = key;
		}
	}

	DHL_OS_Printf("EchoTest end\n");
	
}

#endif // SHELL_ECHO_TEST





static void shell_cmd_set(DebugShellToken *tokens, int nToken)
{
	char *string;
	UINT32 value;
	
	UINT32 ptr;
	int type;

	// sanity check.
	// if (strcmp(tokens[0].text, "set") != 0) return;

#if SHELL_DEBUG
	dprint(1, "set command, %d tokens\n", nToken);
#endif
	if (nToken-1 < 2) {
		DHL_OS_Printf("!! too few arguments\n");
		return;
	}
	
	// 맨 처음 token은 "set" 이라서 skip. [1], [2] 만 변환...
	shell_translate_tokens(&tokens[1], 2);

	string = tokens[1].text;
	value = tokens[2].u.value;

	//bCmdMatched = TRUE;

	
	if (string[0] == 0)
		return;
	
	// 먼저 symbol table을 뒤져서 그곳에 등록이 되어 있으면 그 정보를 사용하도록 하자.
	//
	if (DHL_DBG_QuerySymbol(string, (void **)&ptr, &type) == DHL_OK)
	{
		// type 별로 잘 관리해야 한다. 안그러면 access violation 날 수도 있음..
		//
		if (type == DHL_SYM_V1 && (ptr)) {     // no alignment required for byte addressing
			*(UINT8 *)ptr = (UINT8) value;
			DHL_OS_Printf("set '%s' value = 0x%02x (%d, %uU)\n", 
				string, (int)*(UINT8 *)ptr, (int)*(UINT8 *)ptr, (UINT32)*(UINT8 *)ptr);
		}
		else if (type == DHL_SYM_V2 && (ptr & 1) == 0) {
			*(UINT16 *)ptr = (UINT16) value;
			DHL_OS_Printf("set '%s' value = 0x%04x (%d, %uU)\n", 
				string, (int)*(UINT16 *)ptr, (int)*(UINT16 *)ptr, (UINT32)*(UINT16 *)ptr);
		}
		else if (type == DHL_SYM_V4 && (ptr & 3) == 0) {
			*(UINT32 *)ptr = (UINT32) value;
			DHL_OS_Printf("set '%s' value = 0x%08x (%d, %uU)\n", 
				string, *(int *)ptr, *(int *)ptr, *(UINT32 *)ptr);
		}		
		else
			DHL_OS_Printf("!! alignment err: 0x%x, type %d\n", ptr, type);
			
		return;
	}
	
	DHL_OS_Printf("set: var symbol '%s' not found\n", string);
}


/*
	alias variable symbol
*/
static void shell_cmd_show(DebugShellToken *tokens, int nToken)
{
	char *string;
	int value;
	UINT32 ptr;
	int type;


	if (nToken <= 1)
		string = NULL; // show all
	
	else {
		shell_translate_tokens(&tokens[1], 1);
		string = tokens[1].text;
	}
	
	if (string && string[0])
	{
		if (DHL_DBG_QuerySymbol(string, (void **)&ptr, &type) == DHL_OK)
		{
			value = type==DHL_SYM_V1 ? *(INT8*)ptr : type==DHL_SYM_V2 ? *(INT16*)ptr : *(INT32*)ptr;
	
			DHL_OS_Printf("'%s' size %d, value = 0x%x (%d, %uU)\n", 
					string, type, value, value, value);
			return;
		}
		DHL_OS_Printf("show: symbol '%s' not found\n\n", string);
		
		DHL_DBG_PrintSymbolTable(DHL_SYM_FN | DHL_SYM_V1 | DHL_SYM_V2 | DHL_SYM_V4, string);
		DHL_OS_Printf("\n");
		return;
	}
	
	DHL_DBG_PrintSymbolTable(DHL_SYM_FN | DHL_SYM_V1 | DHL_SYM_V2 | DHL_SYM_V4, NULL);
	DHL_OS_Printf("\n");
}



/*
	usage:
		assign my_symbol_name 0x123456

	my_symbol_name 이라는 symbol을 주소 0x123456 으로 등록한다.
	0x123456 주소는 valid 한 주소이어야 한다.

	param:
		max token: 3 fixed.
*/
static void shell_cmd_assign(DebugShellToken *tokens, int nToken)
{
	if (nToken < 3) return;

	shell_translate_tokens(&tokens[1], 2);

	// 새로운 symbol을 등록한다.
	
	// symbol 부분 체크..
	if (tokens[1].text == NULL || strlen(tokens[1].text) < 1) {
		DHL_OS_Printf("!! invalid symbol '%s'\n", tokens[1].text);
		return;
	}

	// address 부분 체크..
	if (!DHL_VALID_ADDR(tokens[2].u.value) || 
		!DHL_VALID_HEX_ADDR(tokens[2].text))
	{
		DHL_OS_Printf("!! addr 0x%x '%s' invalid\n", tokens[2].u.value, tokens[2].text);
		return;
	}

	DHL_OS_Printf("assign symbol '%s' to 0x%x\n", tokens[1].text, tokens[2].u.value);

	DHL_DBG_RegisterFunctionSymbol(tokens[1].text, (void *)tokens[2].u.value);
}


#if SHELL_AUTHORIZED_ACCESS
static BOOL shell_check_authorized(char *passwd)
{
	return s_buser_authorized;
}

static void shell_cmd_passwd(DebugShellToken *tokens, int nToken)
{
	int n;
	char buf[32];

	DHL_UNUSED(tokens);
	DHL_UNUSED(nToken);

	if (shell_check_authorized(NULL)) {
		DHL_OS_Printf("already authorized. no passwd required\n");
		return;
	}

	n = dhl_os_get_line(buf, sizeof(buf), eDHL_OS_GLF_PASSWD);

	if (n > 0 && shell_check_authorized(buf)) {
		DHL_OS_Printf("ok\n");
	}
	else {
		DHL_OS_Printf("not authorized user!!\n");
	}
}
#endif /* SHELL_AUTHORIZED_ACCESS */



void shell_cmd_which(DebugShellToken *tokens, int nToken)
{
	if (nToken < 2) {
		DHL_OS_Printf(" usage: which substring   // search cmds\n");
		DHL_OS_Printf(" usage: which *           // all cmds\n");
	}
	else
		dhl_dbg_print_symtab(tokens[1].text);
}


#if COMMENT
____Call____(){}
#endif


#if SHELL_SUPPORT_BG_EXE
// 
// User가 Shell 에서 명령을 입력하면 Shell task에서 바로 함수를 실행하는 것이 아니고
// 별도의 executer task를 만들어서 실행하도록 한다.
//
// 그러면 시간이 오래 걸리는 명령 (ex: autoscan) 을 실행시킨 후에도
// Prompt가 다시 뜨기 때문에 다시 다른 명령을 실행 시킬 수 있다.
// 
//
static void shell_bgtask(DebugShellParam *param)
{
	int i;
	SHELL_CMD_HANDLER_TYPE fn;
	int n_arg, arg[MAX_CALL_ARG];
	UINT32 result;

	memset(arg, 0, sizeof(arg));

	// copy all params to local variables..
	fn = (SHELL_CMD_HANDLER_TYPE)(int)param->fn;
	n_arg = param->n_arg;
	
	for (i=0; i<param->n_arg; i++)
		arg[i] = param->args[i];
	for (; i<MAX_CALL_ARG; i++) // cafrii 070130 add for safety
		arg[i] = 0;

	// free param block
	DHL_OS_Free((void **)&param);
	
	//result = fn(args[0], args[1], args[2], args[3], 
	//			args[4], args[5], args[6], args[7]);

	if (n_arg <= 8)
		result = (*fn)(
			arg[ 0], arg[ 1], arg[ 2], arg[ 3], arg[ 4], arg[ 5], arg[ 6], arg[ 7]);
	else
		result = (*fn)(
			arg[ 0], arg[ 1], arg[ 2], arg[ 3], arg[ 4], arg[ 5], arg[ 6], arg[ 7],
			arg[ 8], arg[ 9], arg[10], arg[11], arg[12], arg[13], arg[14], arg[15],
			arg[16], arg[17], arg[18], arg[19], arg[20], arg[21], arg[22], arg[23],
			arg[24], arg[25], arg[26], arg[27], arg[28], arg[29], arg[30], arg[31]);

	
	DHL_OS_Printf("call 0x%x result = 0x%x (%u %d)\n", (UINT32)fn, result, result, result);
	
	DHL_OS_Delay(100);
	
	DHL_OS_SelfDeleteTask();
}

#endif // SHELL_SUPPORT_BG_EXE

static void shell_exec_cmd(void *fn, int n_arg, DebugShellToken *arglist, BOOL bSpawn)
{
#if SHELL_SUPPORT_BG_EXE
	DebugShellParam *param;
	char pTaskNameBuf[30];
	static UINT32 nShellExeCount;
	DHL_OS_TASK_ID tid;
#endif

	int i;
	UINT32 result;
	int arg[MAX_CALL_ARG];
	
	if (n_arg > MAX_CALL_ARG) {
		DHL_OS_Printf("!! call arg number %d exceed limit %d..\n", n_arg, MAX_CALL_ARG);
		//n_arg = MAX_CALL_ARG;
		return;
	}

	// cafrii 070306 bugfix. move position
	memset(arg, 0, sizeof(arg));

	for (i=0; i<n_arg; i++)
		arg[i] = arglist[i].u.value;
	for (; i<MAX_CALL_ARG; i++) // cafrii 070130 add for safety
		arg[i] = 0;

#if SHELL_SUPPORT_BG_EXE

	if (bSpawn) {
		param = (DebugShellParam *) DHL_OS_Malloc(SIZE_OF_DEBUG_SHELL_PARAM(n_arg));
		if (param == NULL)
			DHL_OS_Printf("!! ShellSpawn requested but out of mem. normal execution\n");
	}
	
	if (bSpawn && param)
	{
		param->fn = fn;
		//param->n_arg = n_arg - 1; // 맨 마지막 arg는 '&' 이므로 제외.
		param->n_arg = n_arg;  // 이미 앞에서 제외 했으므로 그대로 사용.

		for (i=0; i<n_arg; i++)
			param->args[i] = arg[i];
		
		sprintf(pTaskNameBuf, "Shl%02x", nShellExeCount++);
		
		tid = DHL_OS_CreateTask((DHL_OS_TASKFUNCTION) shell_bgtask, 
				pTaskNameBuf, DHL_SHELL_BG_TASK_PRIORITY, 
				DHL_SHELL_BG_TASK_STACKSIZE, (int)param);
		if (tid == 0)
			DHL_OS_Free((void **)&param);

		return;
	}
#endif // SHELL_SUPPORT_BG_EXE

	if (n_arg <= 8)
		result = (*(SHELL_CMD_HANDLER_TYPE)(int)fn)(
			arg[ 0], arg[ 1], arg[ 2], arg[ 3], arg[ 4], arg[ 5], arg[ 6], arg[ 7]);
	else
		result = (*(SHELL_CMD_HANDLER_TYPE)(int)fn)(
			arg[ 0], arg[ 1], arg[ 2], arg[ 3], arg[ 4], arg[ 5], arg[ 6], arg[ 7],
			arg[ 8], arg[ 9], arg[10], arg[11], arg[12], arg[13], arg[14], arg[15],
			arg[16], arg[17], arg[18], arg[19], arg[20], arg[21], arg[22], arg[23],
			arg[24], arg[25], arg[26], arg[27], arg[28], arg[29], arg[30], arg[31]);

	DHL_OS_Printf("call 0x%x result = 0x%x (%u)\n", (UINT32)fn, result, result);

}


/*

	symbol은 없고 직접 symbol address를 입력해서 실행하는 경우에 유용..

	usage:
		call symbol_name arg1, arg2, ..
		call 0x80203040  arg1, arg2, ..

	최소한 토큰 2개 필요.
		
*/
void shell_cmd_call(DebugShellToken *tokens, int nToken)
{
	BOOL bShellSpawn = FALSE;
	
	if (nToken < 2) {
		DHL_OS_Printf("!! too few arguments for cmd '%s'\n", tokens[0].text);
		return;
	}

	// 맨 마지막 word가 '&' 이면 background run flag임.
	if (nToken > 1 &&
		tokens[nToken-1].text[0] == '&' && 
		tokens[nToken-1].text[1] == 0) {
		// this is background spawn flag
		//DHL_OS_Printf("&& shell spawn specified\n");
		bShellSpawn = TRUE;
		nToken--;
	}

	
	// 맨 처음 token은 "call" 이라서 skip
	shell_translate_tokens(&tokens[1], nToken-1);

	if (tokens[1].type != ShellToken_HexDigit &&
		tokens[1].type != ShellToken_Symbol) 
	{
		DHL_OS_Printf("!! invalid call address 0x%x\n", tokens[1].u.value);
		return;
	}

	DHL_OS_Printf("call function of '0x%08x' %s\n", 
		tokens[1].u.value, bShellSpawn ? "in separate task.." : "");

#if 0
	// 직접 입력한 function address이므로 잘못된 값이 입력된 것인지 체크를 해 볼 필요가 있다.
	//
	if (tokens[1].type == ShellToken_Symbol &&
		dhl_dbg_in_text_range(tokens[1].u.value))
	{
		// text 영역에 해당하는 주소이다. 정확히 함수 start 주소인지는 알수 없으나,
		// static function 과 같은 것들을 실행시킬 수 있도록 symtab 에 없는 주소도 허용한다.
		//
		shell_exec_cmd((void *)tokens[1].u.value, 
				nToken-2, &tokens[2], bShellSpawn);
	}
	else if (tokens[1].type == ShellToken_HexDigit && 
		dhl_dbg_in_text_range(tokens[1].u.value))
	{
		// digit으로 입력받은 call address는 반드시 0x로 시작하도록 하자.
		// 즉 hex digit만 허용한다.
		shell_exec_cmd((void *)tokens[1].u.value, 
				nToken-2, &tokens[2], bShellSpawn);
	}
	else
	{
		DHL_OS_Printf("!! err: call address/symbol '%s' invalid\n", tokens[1].text);
	}
#else
	// 090909 cafrii bugfix
	// shared lib 인 경우 symbol table에도 등록이 안될 수 있다. 
	// 또한 address range도 기대하는 영역이 아닐 수 있다.
	// 직접 "call" 명령을 사용하는 경우에는 무조건 실행하도록 하자.

	shell_exec_cmd((void *)tokens[1].u.value, 
			nToken-2, &tokens[2], bShellSpawn);
#endif

}


BOOL shell_default(DebugShellToken *tokens, int nToken)
{
	BOOL bCmdMatched = FALSE;
	BOOL bShellSpawn = FALSE;
	
	// DHL command table에서 찾아서 해당 function을 실행시킨다.
	//
	int type;
	void *addr;
	
	// 맨 마지막 word가 '&' 이면 background run flag임.
	if (nToken > 1 &&
		tokens[nToken-1].text[0] == '&' && 
		tokens[nToken-1].text[1] == 0) {
		// this is background spawn flag
		//DHL_OS_Printf("&& shell spawn specified\n");
		bShellSpawn = TRUE;
		nToken--;
	}

	if (DHL_DBG_QuerySymbol(tokens[0].text, (void **)&addr, &type) == DHL_OK && 
		type == DHL_SYM_FN) 
	{
		bCmdMatched = TRUE;
		DHL_OS_Printf("call function of '0x%08x' (aliased)\n", addr);

		// dhl_dbg_in_text_range() 함수는 숫자 범위만 체크하는 함수. 
		// 여기서는 정확하게 symbol 과 일치하는지 여부가 중요함.
		if (!dhl_dbg_is_text_symbol((UINT32)addr))
			DHL_OS_Printf("!! err: call address invalid\n");
			// 등록된 symbol 임에도 이런 문제가 생기는 경우는 어떤 경우??
		else {
			// 맨 처음 token은 command 라서 skip
			shell_translate_tokens(&tokens[1], nToken-1);

			shell_exec_cmd((void *)addr,
					nToken-1, &tokens[1], bShellSpawn);
		}
		goto end;
	}

	
#if 1
	// call 없이도 실행이 가능하도록 변경.. 
	// 조금 위험할 수도 있으나 개발 중에는 이게 편함..

	addr = shell_lookup_symbol(tokens[0].text, &type);
	if (addr && type == DHL_SYM_FN)
	{
		bCmdMatched = TRUE;
		DHL_OS_Printf("build symbol found: '%s' = 0x%08x. executing..\n", 
			tokens[0].text, (UINT32)addr);

		// 맨 처음 token은 command 라서 skip
		shell_translate_tokens(&tokens[1], nToken-1);

		shell_exec_cmd((void *)addr, 
				nToken-1, &tokens[1], bShellSpawn);

		goto end;
	}
#endif

	if (addr) {
		DHL_OS_Printf("entry found: %s (type %d) = 0x%08x, but invalid\n", 
				tokens[0].text, tokens[0].type, (UINT32)addr);
	}
	else
		DHL_OS_Printf("unknown command '%s'\n", tokens[0].text);

end:
	return bCmdMatched;

}


#if COMMENT
____Dispatcher____(){}
#endif

static struct dispatch_tbl_t s_dispatch_table[] = 
{
	{ "help",   shell_cmd_help,  "show this help", },
	{ "?",      shell_cmd_help,  "show this help", },
#if SHELL_ECHO_TEST
	{ "echo",   shell_cmd_echo,  "key input echo test", },
#endif
	{ "set",    shell_cmd_set,    "change alias variable with new value", },
	{ "show",   shell_cmd_show,   "show alias symbol (var. with value. or func.)", },
	{ "assign", shell_cmd_assign, "assign new alias symbol", },
#if SHELL_AUTHORIZED_ACCESS	
	{ "passwd", shell_cmd_passwd, "authorize shell use", },
#endif
	{ "which",  shell_cmd_which,  "search build symbols", },
	{ "h",      shell_cmd_history, "show command history", },
	{ "call",   shell_cmd_call,    "call function with symbol", },
	{ NULL, NULL, },
};

static struct dispatch_tbl_t *shell_get_dispatch_table(void)
{
	return s_dispatch_table;
}

static BOOL shell_process_cmdline(char *buf)
{
	int i, nToken;
	BOOL bCmdMatched;

	DebugShellToken tokens[DHL_SHELL_MAX_TOKEN];

	struct dispatch_tbl_t *dpt = s_dispatch_table;
	
	//int arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8;

	// 각 token 별로 분석.. tokens 에다 저장
	//
	nToken = shell_parse_line_to_tokens(buf, tokens, DHL_SHELL_MAX_TOKEN);
	
	if (nToken <= 0) 
		return FALSE;

#if SHELL_DEBUG
	dprint(2, "== %d tokens\n", nToken);
	for (i=0; i<nToken; i++)
		dprint(2, "   (%d) %s\n", i, tokens[i].text);
#endif


	bCmdMatched = FALSE;
	
	if (0);
#if SHELL_AUTHORIZED_ACCESS
	// authorized 된 경우에만 사용 가능.. */
	else if (!shell_check_authorized(NULL) && 
		strcmp(tokens[0].text, "passwd"))
	{
		DHL_OS_Printf("not authorized yet! use passwd first!!\n");
		bCmdMatched = TRUE;
	}
#endif

#if SHELL_ALLOW_EXIT
	else if (strcmp(tokens[0].text, "exit") == 0)
	{
		s_request_exit = TRUE;
		bCmdMatched = TRUE;
	}
#endif // SHELL_ALLOW_EXIT

	for (i=0; !bCmdMatched; i++)
	{
		if (dpt[i].name == NULL)
			break;
		
		if (strcmp(tokens[0].text, dpt[i].name)==0) {
#if SHELL_DEBUG
			dprint(1, "cmd '%s' executing, with %d args\n", dpt[i].name, nToken);
#endif
			dpt[i].fnptr(&tokens[0], nToken);
			bCmdMatched = TRUE;
		}	
	}

	// 어떠한 명령과도 일치하지 않는 경우..
	if (!bCmdMatched) {
		bCmdMatched = shell_default(&tokens[0], nToken);
	}

//label_end:

	if (bCmdMatched)
		DHL_OS_Delay(200);
			// Zmon prompt, 메시지 등과 섞여서 나오기 때문에
			// 약간의 지연시간을 두어 메시지가 섞이지 않도록 하자..

	return bCmdMatched;  // 일치한 command가 있으면 TRUE
}







#if COMMENT
____InputOutput____(){}
#endif

#if SHELL_SUPPORT_INPUT_EMULATION
/**
	virtual input buffer for input emulation.
	다른 프로그램에서 마치 사용자가 cmd 입력을 한 것과 동일한 
	흉내를 내도록 하는 trick.
*/
char g_shell_vibuf[200];
#endif

static void shell_print(char *msg)
{
	// user interactive 한 출력 구문이므로 바로바로 flush 되도록 한다.
	//
	// cafrii 081014, 
	// console_flush는 interrupt disable을 유발하므로 가능하면 사용하지 않도록 한다.
	//
	if (msg[0])
	{
		// kjkam
		// 어떤 컴파일러 stdio 라이브러리는 msg[0]이 null 일때
		// 이상하게 처리하는 것도 있으므로 한번 검사를 해준다.
		_DHL_OS_Printf(msg);
	}
	
	//console_flush();
}
static void shell_putc(char c)
{
	char msg[2];
	msg[0] = c; msg[1] = 0;
	_DHL_OS_Printf(msg);
}

/*

*/
static void shell_input_command(char *buf, int size)
{
	char *p;
	int pos; // 현재 커서 위치. 새로 입력한 키가 저장될 위치.
	UINT32 key; // cafrii UINT16 -> UINT32
	int idx_history = -1;
	int i;

label_start:

	idx_history = -1;
	pos = 0;
	memset(buf, 0, size);
	shell_print("Shell> ");

#if SHELL_SUPPORT_INPUT_EMULATION
	if (g_shell_vibuf[0]) 
	{
		UINT32 flag = DHL_OS_DisableInterrupts();
			strncpy(buf, g_shell_vibuf, size-1);
			buf[size-1] = 0;
			g_shell_vibuf[0] = 0;
		DHL_OS_RestoreInterrupts(flag);

		// cafrii 090119, move printf to outside of Lock/Unlock task region.
		shell_print(g_shell_vibuf);
		shell_print("\n");

		goto input_end;
	}
#endif
	
	while (1)
	{
		// ZMon 이 enable 되어 있지 않을 때에, ZTCP가 없을 때 등등의 경우에 대해
		// UART에서 데이터를 입력 받는 방법이 각기 다를 수 있음..

		key = DHL_OS_GetChar();
		
		// DbgGetChar는 키 입력에 실패하면 0xFFFF 리턴한다.
		if (key == (UINT32)0)
			continue;

		if (key == DHL_EXTKEY_CR) {
			#if SHELL_INTERNAL_ECHO
				shell_print("\n");
			#endif
			break;
		}
		else if (key == DHL_EXTKEY_ESC) { // ESC key
			shell_print("\n");
			goto label_start;
		}
	#if SHELL_SUPPORT_EXT_KEY
		else if (key == DHL_EXTKEY_UP || key == DHL_EXTKEY_DN)
		{
			char **his = g_dhl_pShellHistory;
			
			if (0);
			else if (key == DHL_EXTKEY_UP) {
				if (idx_history+1 >= MAX_SHELL_HISTORY ||
					his[idx_history+1] == NULL ||
					his[idx_history+1][0] == 0) {
					continue; // ignore this key input.
				}
				idx_history++;
			}
			else if (key == DHL_EXTKEY_DN) {
				if (idx_history-1 < 0 ||
					his[idx_history-1] == NULL ||
					his[idx_history-1][0] == 0)
					continue; // ignore this key input.
				idx_history--;
			}
			for (i=0; i<pos; i++)
				shell_print("\b \b");

			strcpy(buf, his[idx_history]);
			
			//DHL_OS_Printf("[%d]\n", idx_history);

			shell_print(buf);
			pos = strlen(buf);
			
			continue;
		}
	#endif

		// 아무 일반 키가 입력되면 hist buf는 처음부터..
		idx_history = -1;
		
		// process input key
		//
		if (0);
	#if SHELL_SUPPORT_EXT_KEY
		else if (key == DHL_EXTKEY_LF) 	{
			if (pos > 0) {
			#if SHELL_INTERNAL_ECHO
				shell_print("\b");
			#endif
				pos--;
			}
		}
		else if (key == DHL_EXTKEY_RG) {
			if (pos < strlen(buf)) {
			#if SHELL_INTERNAL_ECHO
				shell_putc(buf[pos]);
			#endif
				pos++;
			}
		}
		else if (key == DHL_EXTKEY_HOME) {
			if (pos > 0) {
			#if SHELL_INTERNAL_ECHO
				for (i=0; i<pos; i++) shell_putc('\b');
			#endif
				pos = 0;
			}
		}
		else if (key == DHL_EXTKEY_END) {
			if (pos < strlen(buf)) {
			#if SHELL_INTERNAL_ECHO
				shell_print(&buf[pos]);
			#endif
				pos = strlen(buf);
			}
		}
		else if (key == DHL_EXTKEY_DEL)
		{
			if (pos < strlen(buf)) {
				memmove(&buf[pos], &buf[pos+1], strlen(&buf[pos+1])+1);
			#if SHELL_INTERNAL_ECHO
				shell_print(&buf[pos]); shell_putc(' ');
				for (i=0; i<strlen(&buf[pos])+1; i++) shell_putc('\b');
			#endif
			}
		}
	#endif /* SHELL_SUPPORT_EXT_KEY */

		else if (key == '\b' || key == 0x7F)  // backspace is treated as special
		{
			if (pos > 0) {   // go back 할 글자가 있는 경우에만..
				memmove(&buf[pos-1], &buf[pos], strlen(&buf[pos])+1);
				pos--;
			#if SHELL_INTERNAL_ECHO
				shell_putc('\b'); 
				shell_print(&buf[pos]); shell_putc(' ');
				for (i=0; i<strlen(&buf[pos])+1; i++) 	shell_putc('\b');
			#endif
			}
		}
		else if (key >= 0x20 && key < 0x7F)
		{
			if (strlen(buf) < size-1) {
				memmove(&buf[pos+1], &buf[pos], strlen(&buf[pos])+1);
				buf[pos++] = key;
			#if SHELL_INTERNAL_ECHO
				shell_putc(key); // at [pos-1]
				shell_print(&buf[pos]);
				for (i=0; i<strlen(&buf[pos]); i++)
					shell_putc('\b');
			#endif
			}
		}
		else {
			// do nothing, just ignore key.. buffer full
		}
	}
	goto input_end;

input_end:

	// trim trailing spaces

	p = buf + strlen(buf) - 1;

	while (p >= buf && (*p == ' ' || *p == '\t')) {
		*p-- = 0;
		//n_trim++;
	}

	// skip head spaces
	p = buf;
	while (*p == ' ' || *p == '\t') p++;
	if (p != buf)
		memmove(buf, p, strlen(p)+1);

}


#if COMMENT
____Group2____(){}
#endif


static void shell_task_main(UINT32 arg)
{
	DebugShellContext context;
	char buf[256];
	BOOL bExecuted, bExit=FALSE;

	DHL_UNUSED(arg);
	
	DHL_OS_Printf("Mini Shell Task Spawned..\n");
	
#if SHELL_ALLOW_EXIT
	s_request_exit = 0;
#endif

#if 0
	if (g_dbg_tokens == NULL) {
		// 이 메모리는 맨 처음 한번만 생성된다.
		g_dbg_tokens = DHL_OS_Malloc(DHL_SHELL_MAX_TOKEN * sizeof(DebugShellToken));
	}	
#endif
	memset(&context, 0, sizeof(context));
	
	while (!bExit)
	{	
		//DHL_OS_Delay(1);
		
		memset(buf, 0, sizeof(buf));
		shell_input_command(context.cmdline, sizeof(context.cmdline));

		if (context.cmdline[0] == 0) // just blank..
			continue;

#if SHELL_DEBUG
		dprint(2, "cmd input [%s]\n", context.cmdline);
#endif

		bExecuted = shell_process_cmdline(context.cmdline);

		/* 방금 전 입력한 명령을 history에 추가..
		*/
		if (!(buf[0] == 'h' && buf[1] == 0))
			shell_add_to_history(context.cmdline);
		
		if (bExecuted == FALSE) {
			//DHL_OS_Printf("\nInvalid command\n");
		}
		DHL_OS_Printf("\n");

#if SHELL_ALLOW_EXIT
		if (s_request_exit)
			bExit = TRUE;
#endif

	}

	DHL_OS_Printf("shell exit\n");

#if SHELL_ALLOW_EXIT
	s_shell_tid = 0;
#endif

}




#if COMMENT
____Debug____(){}
#endif





#if COMMENT
____Symbol____(){}
#endif


#if DHL_REGISTER_DEUBG_SYMBOLS

static DHL_SymbolTable _symbols[] =
{
	/* however, if you want typing short-cut, it is good usage.
	DHL_FNC_SYM_ENTRY2("epg_start", App_EpgUpdateStart),
	DHL_FNC_SYM_ENTRY2("epg_stop", App_EpgUpdateCancel),
	DHL_FNC_SYM_ENTRY2("epg_list", Dmc_EpgPrintAllTables),
	DHL_FNC_SYM_ENTRY2("epg_delete", App_EpgDeleteAll),

	DHL_VAR_SYM_ENTRY(g_XX_TestMode),
	*/
	0,
};

#endif	/* DHL_REGISTER_DEUBG_SYMBOLS */


// shell 기능의 대부분을 disable 시키려면 아래 플래그를 1로 설정하라.
#endif /* SUPPORT_DBG_SHELL */


#if COMMENT
____Init____(){}
#endif


void DHL_DBG_StartDbgShell(void)
{
#if SUPPORT_DBG_SHELL
	/* 각종 init code.. */

#if SHELL_USE_SHELL_TASK
	if (1) 
	{
		DHL_OS_TASK_ID tid;

		DHL_OS_Printf("Starting MiniShell, priority %d ...\n", DHL_SHELL_TASK_PRIORITY);

		tid = s_shell_tid = DHL_OS_CreateTask((DHL_OS_TASKFUNCTION)shell_task_main, "Shell", 
						DHL_SHELL_TASK_PRIORITY, DHL_SHELL_TASK_STACKSIZE, 0);

		if (tid == DHL_INVALID_TASK_ID)
			DHL_OS_Printf("!! Shell task spawn error!\n");
		else
			DHL_OS_Printf("Minishell TID 0x%x running\n", tid);
	}
#elif SHELL_ALLOW_EXIT
	DHL_OS_Printf("enter debug shell. this will block calling thread.\n");
	DHL_OS_Printf("type 'exit' to return.\n");

	shell_task_main(0);
	
#endif


#if DHL_REGISTER_DEUBG_SYMBOLS
	DHL_DBG_RegisterSymbols(_symbols, DHL_NUMSYMBOLS(_symbols));
#endif

#endif /* SUPPORT_DBG_SHELL */
}


/*
	debug minishell의 각종 정보 query.
*/
void DHL_DBG_GetDbgShellInfo(DHL_DBG_SHELL_INFO *pInfo)
{
#if SUPPORT_DBG_SHELL
	if (s_shell_tid) {
		pInfo->started = TRUE;
		pInfo->tid = s_shell_tid;
	}
	else {
		pInfo->started = FALSE;
	}
#else
	DHL_UNUSED(pInfo);
#endif
}
/*
	return TRUE if current task is debug shell task
*/
BOOL DHL_DBG_IsDbgShell(void)
{
#if SUPPORT_DBG_SHELL
	DHL_DBG_SHELL_INFO si;
	DHL_DBG_GetDbgShellInfo(&si);
	
	return si.tid == DHL_OS_GetTaskID() ? TRUE : FALSE;
#else
	return FALSE;
#endif
}

/*
	debug command emulation 함수.
	debug shell에 입력된 것처럼 처리한다.
*/
void DHL_DBG_EmulateCommand(const char *cmd)
{
#if SUPPORT_DBG_SHELL && SHELL_SUPPORT_INPUT_EMULATION
	if (cmd && *cmd)
	{
		UINT32 flag;
		flag = DHL_OS_DisableInterrupts();
		strncpy(g_shell_vibuf, cmd, sizeof(g_shell_vibuf));
		g_shell_vibuf[sizeof(g_shell_vibuf)-1] = 0;
		DHL_OS_RestoreInterrupts(flag);
	}
#else
	DHL_UNUSED(cmd);
#endif
}



/* end of file */