for(i = 0;i < 16;i ++)
			free(lpAddr[i]);
	}

	for(i = 0;i < 16;i ++)
	{
		lpAddr[i] = malloc(i * 8192);
		Hex2Str((DWORD)lpAddr[i],Buffer);
		PrintLine(Buffer);
	}
	for(i = 0;i < 16;i ++)
		free(lpAddr[i]);
	//DriverEntry(NULL,NULL);
}

VOID IoCtrlApp(LPSTR)
{
	__KERNEL_THREAD_OBJECT*    lpIoCtrlThread    = NULL;

	lpIoCtrlThread = KernelThreadManager.CreateKernelThread(
		(__COMMON_OBJECT*)&KernelThreadManager,
		0L,
		KERNEL_THREAD_STATUS_READY,
		PRIORITY_LEVEL_NORMAL,
		IoCtrlStart,
		NULL,
		NULL);
	if(NULL == lpIoCtrlThread)    //Can not create the IO control thread.
	{
		PrintLine("Can not create IO control thread.");
		return;
	}

	DeviceInputManager.SetFocusThread((__COMMON_OBJECT*)&DeviceInputManager,
		(__COMMON_OBJECT*)lpIoCtrlThread);    //Set the current focus to IO control
	                                          //application.

	lpIoCtrlThread->WaitForThisObject((__COMMON_OBJECT*)lpIoCtrlThread);  //Block the shell
	                                                                      //thread until
	                                                                      //the IO control
	                                                                      //application end.

}

//
//System diag application's shell start code.
//

VOID SysDiagApp(LPSTR)
{
	__KERNEL_THREAD_OBJECT*        lpSysDiagThread    = NULL;

	lpSysDiagThread = KernelThreadManager.CreateKernelThread(
		(__COMMON_OBJECT*)&KernelThreadManager,
		0L,
		KERNEL_THREAD_STATUS_READY,
		PRIORITY_LEVEL_NORMAL,
		SysDiagStart,
		NULL,
		NULL);
	if(NULL == lpSysDiagThread)    //Can not create the kernel thread.
	{
		PrintLine("Can not start system diag application,please retry again.");
		return;
	}

	DeviceInputManager.SetFocusThread((__COMMON_OBJECT*)&DeviceInputManager,
		(__COMMON_OBJECT*)lpSysDiagThread);

	lpSysDiagThread->WaitForThisObject((__COMMON_OBJECT*)lpSysDiagThread);
}

VOID UnTestHandler(LPSTR)
{
	DWORD*      lpdwTest = NULL;

	lpdwTest = (DWORD*)MemoryManager.MemoryAlloc((__COMMON_OBJECT*)&MemoryManager,
		0L,
		1024);
	if(NULL == lpdwTest)
	{
		PrintLine("Can not allocate memory.");
		return;
	}
	*lpdwTest = 1024;  //Throw an exception.

	MemoryManager.MemoryFree((__COMMON_OBJECT*)&MemoryManager,
		0L,
		lpdwTest,
		1024);
}

VOID RunTimeHandler(LPSTR)
{
	DWORD dwTime = System.GetClockTickCounter((__COMMON_OBJECT*)&System);
	BYTE  Buffer[12];
	dwTime /= SYSTEM_TIME_SLICE;
	PrintLine("The system has running ");
	Int2Str(dwTime,Buffer);
	PrintStr(Buffer);
	PrintStr(" second(s).");
}

VOID ClsHandler(LPSTR)
{
	ClearScreen();
}

VOID VerHandler(LPSTR)
{
	LPSTR strVer1 = "    Hello China's version information:";
	LPSTR strVer2 = "    Boot loader    : V0.1";
	LPSTR strVer3 = "    MINI kernal    : V0.1";
	LPSTR strVer4 = "    Master         : V0.1";
	LPSTR strVer5 = "    IPv6 stack     : V0.0";

	GotoHome();
	ChangeLine();
	PrintStr(strVer1);
	GotoHome();
	ChangeLine();
	PrintStr(strVer2);
	GotoHome();
	ChangeLine();
	PrintStr(strVer3);
	GotoHome();
	ChangeLine();
	PrintStr(strVer4);
	GotoHome();
	ChangeLine();
	PrintStr(strVer5);
}

VOID MemHandler(LPSTR)
{
	PrintLine("------------------ ** memory layout ** ------------------");
	PrintLine("    0x00000000 - 0x000FFFFF        Hardware buffer       ");
	PrintLine("    0x00100000 - 0x0010FFFF        Mini-kernal           ");
	PrintLine("    0x00110000 - 0x013FFFFF        Master(OS Kernal)     ");
	PrintLine("    0x01400000 - 0xFFFFFFFF        User Space            ");
}


LPSTR strHdr[] = {               //I have put the defination of this strings
	                             //in the function SysInfoHandler,but it do
	                             //not work,see the asm code,it generates the
	                             //incorrect asm code!Fuck Bill Gates!.
	"    EDI   :   0x",
	"    ESI   :   0x",
	"    EBP   :   0x",
	"    ESP   :   0x",
	"    EBX   :   0x",
	"    EDX   :   0x",
	"    ECX   :   0x",
	"    EAX   :   0x",
	"    CS-DS :   0x",
	"    FS-GS :   0x",
	"    ES-SS :   0x"};

static BYTE Buffer[] = {"Hello,China!"};

VOID SysInfoHandler(LPSTR)
{
	DWORD sysContext[11];

#ifdef __I386__
	__asm{                       //Get the system information.
		pushad                   //Save all the general registers.
			                     //NOTICE: This operation only get
								 //the current status of system
								 //where this instruction is executed.
        push eax
        mov eax,dword ptr [esp + 0x04]
		mov dword ptr [ebp - 0x2c],eax    //Get the eax register's value.
		                                  //Fuck Bill Gates!!!!!
		mov eax,dword ptr [esp + 0x08]
		mov dword ptr [ebp - 0x28],eax    //Get the ecx value.
		mov eax,dword ptr [esp + 0x0c]
		mov dword ptr [ebp - 0x24],eax    //edx
		mov eax,dword ptr [esp + 0x10]
		mov dword ptr [ebp - 0x20],eax    //ebx
		mov eax,dword ptr [esp + 0x14]
		mov dword ptr [ebp - 0x1c],eax    //esp
		mov eax,dword ptr [esp + 0x18]
		mov dword ptr [ebp - 0x18],eax    //ebp
		mov eax,dword ptr [esp + 0x1c]
		mov dword ptr [ebp - 0x14],eax    //esi
		mov eax,dword ptr [esp + 0x20]
		mov dword ptr [ebp - 0x10],eax    //edi

		mov ax,cs
		shl eax,0x10
		mov ax,ds
		mov dword ptr [ebp - 0x0c],eax    //Get cs : ds.
		mov ax,fs
		shl eax,0x10
		mov ax,gs
		mov dword ptr [ebp - 0x08],eax    //Get fs : gs.
		mov ax,es
		shl eax,0x10
		mov ax,ss
		mov dword ptr [ebp - 0x04],eax   //Get es : ss.

		pop eax
		popad                    //Restore the stack frame.
	}
#else                            //If not an I386 or above platform.
	GotoHome();
	ChangeLine();
	PrintStr("    This operation can not supported on no-I386 platform.");
	return;
#endif                           //Now,we got the general registers and segment
	                             //registers' value,print them out.
	GotoHome();
	ChangeLine();
	PrintStr("    System context information(general registers and segment registers):");
	for(DWORD bt = 0;bt < 11;bt ++)
	{
		GotoHome();
		ChangeLine();
		PrintStr(strHdr[bt]);
		Hex2Str(sysContext[bt],Buffer);
		//Buffer[8] = 0x00;
		PrintStr(Buffer);
	}
	return;
}

VOID DateHandler(LPSTR)
{
	GotoHome();
	ChangeLine();
	PrintStr("DateHandler called.");
}

VOID TimeHandler(LPSTR)
{
	GotoHome();
	ChangeLine();
	PrintStr("Time Handler called.");
}

VOID CpuHandler(LPSTR)
{
	GotoHome();
	ChangeLine();
	PrintStr("Cpu Handler called.");
}

VOID SptHandler(LPSTR)           //Command 'support' handler.
{
	LPSTR strSupportInfo1 = "    For any technical support,send E-Mail to:";
	LPSTR strSupportInfo2 = "    garryxin@yahoo.com.cn.";
	
	GotoHome();
	ChangeLine();
	PrintStr(strSupportInfo1);
	GotoHome();
	ChangeLine();
	PrintStr(strSupportInfo2);
	return;
}

VOID  DefaultHandler(LPSTR)      //Default command handler.
{
	LPSTR strPrompt = "You entered incorrect command name.";
	ChangeLine();
	GotoHome();
	PrintStr(strPrompt);
	return;
}

//static BYTE tmpBuffer[36] = {0x00000000};   //If I declare this variable as the local
                                            //variable,as following,it would not work,
                                            //but I put it here,it works,I don't know
                                            //why,maybe some rules I do not know,but I
                                            //think it's would be gate's reason,so I
                                            //want to fuck bill gates again!!!
VOID  DoCommand()
{
	DWORD wIndex = 0x0000;
	BOOL bResult = FALSE;        //If find the correct command object,then
	                             //This flag set to TRUE.
	BYTE tmpBuffer[36];
	__KERNEL_THREAD_OBJECT* hKernelThread = NULL;

	CmdBuffer[BufferPtr] = 0x00; //Prepare the command string.
	BufferPtr = 0;

	while((' ' != CmdBuffer[wIndex]) && CmdBuffer[wIndex] && (wIndex < 32))
	{
		tmpBuffer[wIndex] = CmdBuffer[wIndex];
		wIndex ++;
	}
	tmpBuffer[wIndex] = 0;

	for(DWORD dwIndex = 0;dwIndex < CMD_OBJ_NUM;dwIndex ++)
	{
		if(StrCmp(&tmpBuffer[0],CmdObj[dwIndex].CmdStr))
		{
			CmdObj[dwIndex].CmdHandler(&CmdBuffer[wIndex]);  //Call the command handler.
			bResult = TRUE;      //Set the flag.
			break;
		}
	}
	if(bResult)
		goto __END;

	dwIndex = 0;  //Now,should search external command array.

	while(ExtCmdArray[dwIndex].lpszCmdName)
	{
		if(StrCmp(&tmpBuffer[0],ExtCmdArray[dwIndex].lpszCmdName))  //Found.
		{
			hKernelThread = KernelThreadManager.CreateKernelThread(
				(__COMMON_OBJECT*)&KernelThreadManager,
				0L,
				KERNEL_THREAD_STATUS_READY,
				PRIORITY_LEVEL_NORMAL,
				ExtCmdArray[dwIndex].ExtCmdHandler,
				(LPVOID)&CmdBuffer[wIndex],
				NULL);
			if(!ExtCmdArray[dwIndex].bBackground)  //Should wait.
			{
				hKernelThread->WaitForThisObject((__COMMON_OBJECT*)hKernelThread);
				KernelThreadManager.DestroyKernelThread(
					(__COMMON_OBJECT*)&KernelThreadManager,
					(__COMMON_OBJECT*)hKernelThread);  //Destroy it.
			}
			bResult = TRUE;
			goto __END;
		}
		dwIndex ++;
	}

	if(!bResult)
	{
		DefaultHandler(NULL);        //Call the default command handler.
	}

__END:
	return;
}

VOID  PrintPrompt()
{
	LPSTR pszSysName = "[system-view]";
	if(HostName[0])
	{
		PrintLine(&HostName[0]);
	}
	else
	{
		ChangeLine();
	    GotoHome();
	    PrintStr(pszSysName);
	}
	return;
}


BOOL EventHandler(WORD wCommand,WORD wParam,DWORD dwParam)
{
	WORD wr = 0x0700;
	BYTE bt = 0x00;
	BYTE Buffer[12];

	switch(wCommand)
	{
	case MSG_KEY_DOWN:
		bt = LOBYTE(LOWORD(dwParam));
		if(VK_RETURN == bt)
		{
			if(BufferPtr)
				DoCommand();
			PrintPrompt();
			break;
		}
		if(VK_BACKSPACE == bt)
		{
			if(0 != BufferPtr)
			{
				GotoPrev();
				BufferPtr --;
			}
			break;
		}
		else
		{
			if(MAX_BUFFER_LEN - 1 > BufferPtr)
			{
				CmdBuffer[BufferPtr] = bt;
				BufferPtr ++;
				wr += LOBYTE(LOWORD(dwParam));
				PrintCh(wr);
			}
		}
		break;
	case KERNEL_MESSAGE_TIMER:
		switch(dwParam){
		case 100:
			GotoHome();
			ChangeLine();
			PrintStr("Timer ID = 100,please handle it.");
			Int2Str(100,Buffer);
			PrintStr(Buffer);
			break;
		case 200:
			GotoHome();
			ChangeLine();
			PrintStr("Timer ID = 200,please handle it.");
			Int2Str(200,Buffer);
			PrintStr(Buffer);
			break;
		case 300:
			GotoHome();
			ChangeLine();
			PrintStr("Timer ID = 300,please handle it.");
			break;
		case 400:
			GotoHome();
			ChangeLine();
			PrintStr("Timer ID = 400,please handle it.");
			break;
		case 500:
			GotoHome();
			ChangeLine();
			PrintStr("Timer ID = 500,please handle it.");
			break;
		default:
			break;
		}
	default:
		break;
	}
	return 0L;
}

//
//Entry point.
//
DWORD EntryPoint()
{
	//__KTHREAD_MSG Msg;
	__KERNEL_THREAD_MESSAGE KernelThreadMessage;

	PrintPrompt();

	while(TRUE)
	{
		if(GetMessage(&KernelThreadMessage))
		{
			if(KTMSG_THREAD_TERMINAL == KernelThreadMessage.wCommand)
				goto __TERMINAL;
			DispatchMessage(&KernelThreadMessage,EventHandler);
		}
	}

__TERMINAL:                      //Terminal code here.

	return 0L;
}