#include "app_console.h"

#include "ctype.h"

#include "unistd.h"

#include "app_test.h"

// 说明

// read write 使用的是 POSIX 的标准文件读写函数

// unistd.h 包含了 STDIN_FILENO 等文件描述符的定义

// ctype.h 包含了 isprint 函数的声明

// 经过仔细考虑，决定不支持 ESC 键，因为ESC 键的键值为 0x1b 与 上下左右的键值重复

// 但可以考虑按2下ESC清除本行输入

// 对不可打印字符的处理仅限于以下已经列出的宏定义

// change:

// 放弃对 double ESC 的支持,因为可能出现按了 ESC 又按了 方向键 的情况

// 则用户输入编码为 '/x1b' '/x1b' '[' 'A' (按了ESC 又按了上键)

// change:

// 为了将应用与控制台应用剥离，则将 #define MAX_CMD_LEN 512 房到 app_test.h 中定义

// 二维数组作为参数进行传递时，需要明确第二个维度的大小，否则编译器无法正确定位地址

#define KEY_BACKSPACE    '/x08'    // back space

#define KEY_DEL          '/x7F'    // del

#define KEY_ENTER        '/x0A'    // 回车

// 以下为 0x1b 开头的键值

//#define KEY_DOUBLEESC    "/x1B/x1B"// ESC

//#define KEY_ARROW_UP     "/x1B[A"  // 上

//#define KEY_ARROW_DOWN   "/x1B[B"  // 下

//#define KEY_ARROW_LEFT   "/x1B[D"  // 左

//#define KEY_ARROW_RIGHT  "/x1B[C"  // 右

typedefenum

{

WKS_WAIT,

WKS_RECV1B,

WKS_UDLR,

}T_WaitKeyState;

#define MAX_CMD_HISTORY 32

#define MAX_PAR_COUNT 16

staticcharszPrompt[] = {"TR_Console> "};

staticT_WaitKeyState waitKeyState = WKS_WAIT;

staticcharszCmdHistory[MAX_CMD_HISTORY][MAX_CMD_LEN];

staticcharszCmdNow[MAX_CMD_LEN] = {0};

staticUINT32nCmdIndex = 0;

staticUINT32nCmdCursor = 0;

staticUINT32nCmdInputCount = 0;

staticUINT32nCmdInputCursor = 0;

staticvoidApp_Console_ParseCmd(constchar* pCmd);

staticUINT32App_Console_ReadInput(char*input)

{

U32    nRead=0;

structpollfd p;

structtermio term,term_old;

/* Get control of the terminal */

ioctl(STDIN_FILENO,TCGETA,(void*)&term);

term_old = term;

term.c_lflag &= ~ICANON;

term.c_lflag &= ~ECHO;

ioctl(STDIN_FILENO,TCSETAW,(void*)&term);

/* Get event we want to know */

p.fd     = STDIN_FILENO;

p.events = POLLIN;

/* If we receive one thing, get the byte now */

if(poll(&p,1,-1)>0)

{

if(p.revents==POLLIN)

{

nRead=read(STDIN_FILENO,input,1);

}

}

/* Purge the byte */

/* tcflush(0,TCIOFLUSH); */

/* Leave control */

ioctl(STDIN_FILENO,TCSETAW,(void*)&term_old);

return(nRead);

}

staticvoidApp_Console_BSChar()

{

charszTemp[3];

szTemp[0] = '/b';

szTemp[1] = ' ';

szTemp[2] = '/b';

write(STDOUT_FILENO,szTemp,3);

}

staticvoidApp_Console_OnPrintChar(charinput)

{

if(nCmdInputCount == MAX_CMD_LEN)return;

if(nCmdInputCursor 

{

charszTemp[MAX_CMD_LEN] = {0};

char* pCmd = szCmdNow;

intnBackCount = nCmdInputCount-nCmdInputCursor;

szTemp[0] = input;

memcpy(&szTemp[1],&pCmd[nCmdInputCursor],nBackCount);

write(STDOUT_FILENO,szTemp,nBackCount+1);

memcpy(&pCmd[nCmdInputCursor],&szTemp,nBackCount+1);

memset(szTemp,'/b',nBackCount);

write(STDOUT_FILENO,szTemp,nBackCount);

}

else

{

write(STDOUT_FILENO,&input,1);

szCmdNow[nCmdInputCount] = input;

}

nCmdInputCursor++;

nCmdInputCount++;

}

staticvoidApp_Console_OnBackspace()

{

if(nCmdInputCursor > 0)

{

if(nCmdInputCursor == nCmdInputCount)// 光标在末尾

App_Console_BSChar();

else// 光标不在末尾

{

charszTemp[MAX_CMD_LEN] = {0};

char* pCmd = szCmdNow;

intnBackCount = nCmdInputCount-nCmdInputCursor;

szTemp[0] = '/b';

memcpy(&szTemp[1],&pCmd[nCmdInputCursor],nBackCount);

szTemp[nBackCount+1] = ' ';

write(STDOUT_FILENO,szTemp,nBackCount+2);

memcpy(&pCmd[nCmdInputCursor-1],&szTemp[1],nBackCount);

memset(szTemp,'/b',nBackCount+1);

write(STDOUT_FILENO,szTemp,nBackCount+1);

}

nCmdInputCount --;

nCmdInputCursor--;

}

}

staticvoidApp_Console_OnDel()

{

if(nCmdInputCursor 

{

charszTemp[MAX_CMD_LEN] = {0};

char* pCmd = szCmdNow;

intnBackCount = nCmdInputCount-nCmdInputCursor-1;

memcpy(szTemp,&pCmd[nCmdInputCursor+1],nBackCount);

szTemp[nBackCount] = ' ';

write(STDOUT_FILENO,szTemp,nBackCount+1);

memcpy(&pCmd[nCmdInputCursor],szTemp,nBackCount);

memset(szTemp,'/b',nBackCount+1);

write(STDOUT_FILENO,szTemp,nBackCount+1);

nCmdInputCount--;

}

}

staticvoidApp_Console_OnDoubleEsc()

{

if(nCmdInputCount > 0)

{

char* pCmd = szCmdNow;

// 将光标移动到最末尾

while(nCmdInputCursor 

{

write(STDOUT_FILENO,&pCmd[nCmdInputCursor],1);

nCmdInputCursor++;

}

// 清除所有输入的数据

inti=0;

for(i=0;i

nCmdInputCount = 0;

nCmdInputCursor = 0;

}

}

staticvoidApp_Console_OnUp()

{

if(nCmdCursor == 0)return;

nCmdCursor --;

// 清除掉现在所有的输入

App_Console_OnDoubleEsc();

char* pCmdHistory = &szCmdHistory[nCmdCursor][0];

memcpy(szCmdNow,pCmdHistory,MAX_CMD_LEN);

nCmdInputCount = strlen(szCmdNow);

nCmdInputCursor= nCmdInputCount;

write(STDOUT_FILENO,szCmdNow,nCmdInputCount);

}

staticvoidApp_Console_OnDown()

{

if(nCmdCursor >= (nCmdIndex-1))return;

nCmdCursor ++;

// 清除掉现在所有的输入

App_Console_OnDoubleEsc();

char* pCmdHistory = &szCmdHistory[nCmdCursor][0];

memcpy(szCmdNow,pCmdHistory,MAX_CMD_LEN);

nCmdInputCount = strlen(szCmdNow);

nCmdInputCursor= nCmdInputCount;

write(STDOUT_FILENO,szCmdNow,nCmdInputCount);

}

staticvoidApp_Console_OnLeft()

{

if(nCmdInputCursor > 0)

{

charc ='/b';

write(STDOUT_FILENO,&c,1);

nCmdInputCursor--;

}

}

staticvoidApp_Console_OnRight()

{

if(nCmdInputCursor 

{

char* pCmd = szCmdNow;

charc = pCmd[nCmdInputCursor];

write(STDOUT_FILENO,&c,1);

nCmdInputCursor++;

}

}

staticvoidApp_Console_OnEnter()

{

szCmdNow[nCmdInputCount] = '/0';

charszTemp[] = {"/r/n"};

write(STDOUT_FILENO,szTemp,strlen(szTemp));

nCmdInputCount = 0;

nCmdInputCursor = 0;

if(strlen(szCmdNow) == 0)return;

if(nCmdIndex == MAX_CMD_HISTORY)// 命令队列满了，移动

{

charszTempCmd[MAX_CMD_HISTORY][MAX_CMD_LEN];

memcpy(szTempCmd,&szCmdHistory[1][0],MAX_CMD_LEN*(MAX_CMD_HISTORY-1));

memcpy(szCmdHistory,szTempCmd,MAX_CMD_LEN*(MAX_CMD_HISTORY-1));

nCmdIndex = MAX_CMD_HISTORY-1;

nCmdCursor = nCmdIndex;

}

memcpy(szCmdHistory[nCmdIndex],szCmdNow,MAX_CMD_LEN);

nCmdIndex++;

nCmdCursor = nCmdIndex;

// 解析命令

App_Console_ParseCmd(szCmdNow);

}

staticvoidApp_Console_CmdLoop()

{

BOOLbGetEnter = FALSE;

while(TRUE)

{

// 读取一个console输入

UINT32nReturn = 0;

charinput;

nReturn = App_Console_ReadInput (&input);

if(nReturn > 0)

{

switch(waitKeyState)

{

caseWKS_WAIT :

if(isprint(input))// 可打印字符

App_Console_OnPrintChar(input);

else

{

if(input == KEY_BACKSPACE)

App_Console_OnBackspace();

elseif(input == KEY_DEL)

App_Console_OnDel();

elseif(input == KEY_ENTER)

{

App_Console_OnEnter();

bGetEnter = TRUE;

}

elseif(input =='/x1b')

waitKeyState = WKS_RECV1B;

else

waitKeyState = WKS_WAIT;

}

break;

caseWKS_RECV1B:

if(input =='/x1b')// 按了ESC 又按了方向键，或者是 ESC

{

//App_Console_OnDoubleEsc();

waitKeyState = WKS_RECV1B;

}

else

if(input =='[')//可能为 上下左右 4个键

waitKeyState = WKS_UDLR;

else//下面的情况为 按了 ESC 键之后，按了其他的键的处理

{

if(isprint(input)) App_Console_OnPrintChar(input);

waitKeyState = WKS_WAIT;

}

break;

caseWKS_UDLR:

if(input =='A')// 上

App_Console_OnUp();

elseif(input =='B')// 下

App_Console_OnDown();

elseif(input =='D')// 左

App_Console_OnLeft();

elseif(input =='C')// 右

App_Console_OnRight();

else

{

if(isprint(input)) App_Console_OnPrintChar(input);

}

waitKeyState = WKS_WAIT;

break;

default:

break;

}

}

if(bGetEnter)

{

break;

}

}

}

voidApp_Console_Start()

{

// 清空 sdtout 缓冲

fflush(stdout);

fflush(stdin);

charszTemp[] = {"/r/nStart TR Console.../r/n/r/n"};

write(STDOUT_FILENO,szTemp,strlen(szTemp));

while(TRUE)

{

write(STDOUT_FILENO,szPrompt,strlen(szPrompt));

App_Console_CmdLoop();

}

}

// 解析命令

staticvoidApp_Console_ParseCmd(constchar* pCmd)

{

intlength = strlen(pCmd);

// 全部转小写

inti=0;

charszTempCmd[MAX_CMD_LEN];

for(i=0; i 

// 将输入的命令各个 part 分开

charszPart[MAX_PAR_COUNT][MAX_CMD_LEN];

intnPartCount = 0;

intnPartCursor = 0;

intnCmdCursor = 0;

memset(szPart,0,sizeof(szPart));

while(TRUE)

{

if(nCmdCursor == length)

{

if(nPartCursor > 0)

{

nPartCount++;

nPartCursor = 0;

}

break;

}

if( (szTempCmd[nCmdCursor] ==',') || (szTempCmd[nCmdCursor] ==' ') )// part 分割符

{

szPart[nPartCount][nPartCursor] = '/0';

nPartCount++;

nPartCursor = 0;

}

else

{

szPart[nPartCount][nPartCursor] = szTempCmd[nCmdCursor];

nPartCursor++;

}

nCmdCursor++;

}

App_Test_OnCmd(szPart,nPartCount);

}