compare.c~

基于嵌入式linux的命令行接口

函数：nodeJmp
功能：跳到retWord对应的结点
参数：
    输入--retWord:用户输入命令行中的一个关键字。
                    ppHead:开始搜索的命令节点。
                    flg:这个命令关键字在命令树中存在的状态(存在、不存在、是参数)。
    输出--
返回：retWord对应的结点
描述：
*******************************************************************************/
COMMAND_NODE *nodeJmp(INT8 *retWord, COMMAND_NODE *ppHead, UINT8 flg)
{
    	if (flg==WORD_EXIST)
    	{
        	while(1)
        	{
            		/*匹配的单词*/
            		if (stringCpm(ppHead->command_string ,retWord) == OK)
            		{
                		return ppHead;
            		}
            		ppHead = ppHead->brother;
        	}
    	}

    	while(1)
    	{
        	/*参数*/
        	if (stringCpm(ppHead->command_string ,"[") == OK)
        	{
            		return ppHead;
        	}

        	ppHead = ppHead->brother;
    	}
}

/*******************************************************************************
函数：cmdHlpMsg
功能：显示命令的帮助信息
参数：
    输入--comSchNum:命令号
    输出--
返回：
描述：
*******************************************************************************/
void cmdHlpMsg(UINT8 comSchNum)
{
    	INT8 * outputString;
		
    	outputString = outputStringList[comSchNum];
    	printf("\n%s", outputString);
}

/*******************************************************************************
函数：GainRemainWords
功能：显示当前结点下的所有命令
参数：
    输入--ppHead:要显示的命令节点。
    输出--
返回：
描述：
*******************************************************************************/
void GainRemainWords(COMMAND_NODE *ppHead)
{
    	INT8 * string;
    	const struct  cmd_entry *command = &commandList[ppHead->command_number];

    	if (ppHead->son == NULL)
    	{
        	if (((strcmp(userLogin, SuperUsrName) != 0)&&(command->cmdEna == 1))
            							||(strcmp(userLogin, SuperUsrName) == 0))
        	{
            		string = command->cmdString;
            		printf("\n%s", string);
            		listDeep ++;
            		if (listDeep >= 20)
            		{
                		printf("\n\nPress any key to continue......");
                		getchar();
                		listDeep = 0;
            		}
        	}
    	}
    	else
    	{
    		GainRemainWords(ppHead->son);
    	}
		
    	if(ppHead->brother == NULL) 		
	{
       	return;
    	}
    	GainRemainWords(ppHead->brother);
}

/*******************************************************************************
函数：list
功能：显示所有的命令
参数：
    输入--
    输出--
返回：
描述：
*******************************************************************************/
void list(void)
{
    	listDeep = 0;
    	GainRemainWords(pHead);
}


/*******************************************************************************
函数：cmdPorcess
功能：处理用户输入的命令
参数：
    输入--
    输出--
返回：
描述：不断检测用户输入的命令，当超时则返回退出
*******************************************************************************/
void cmdPorcess(void)
{
    	UINT8 inputed_length;
    	UINT8 comSchNum, errorPos, retValue;
    	UINT8 finished;

    	inputed_length = 0;

    	while(1)
    	{
        	printf("\n");
#if 0
        	if (switchType==S2024)
        	{
            		commonMsgPrint(43, TRUE);
        	}
        	else if(switchType==S2016)
        	{
            		commonMsgPrint(66, TRUE);
        	}
			else
			{
				commonMsgPrint(71, TRUE);
			}
#endif			
        	if (strcmp(userLogin, SuperUsrName) != 0)
        	{
            		printf("(config)#");
        	}
        	else
        	{
            		putchar('%');
            		putchar('%');
        	}

        	if (inputed_length!=0)
        	{
			printf("%s",s);
        	}
			
        	inputed_length = inputStr(GET_COMMAND_FLAG, inputed_length);

        	/*超时, logout*/
        	if(inputed_length == 0xff)
        	{
            		return;
        	}

        	/*字符超长，重新输入*/
        	if(inputed_length == MAXLENTH)
        	{
            		commonMsgPrint(44, TRUE);
            		inputed_length = 0;
            		continue;
        	}

        	/*如果用户没有输入命令则继续输入*/
        	errorPos = 0;
        	finished = TRUE;

		/*去除开头的空格*/	
        	while(finished)
        	{
            		if(s[errorPos]==' ')
            		{
                		errorPos++;
            		}
            		else
            		{
                		finished = FALSE;
            		}
        	}
			
        	if (s[errorPos] == '\0')
        	{
            		if (s[errorPos+1] == '\0')
            		{
                		if (s[errorPos+2] == '?')
                		{
                    			list();
                		}
            		}
            		inputed_length = 0;
            		continue;
        	}

        	comSchNum = 0;
        	retValue = cmdCmp(&errorPos, &comSchNum);
			
        	if (retValue == COMMAND_FOUND)/*用户命令调配*/
        	{
            		if (comSchNum != 0xff)
            		{
                		taskCmd = 0;
                		if (cmdSchedule(comSchNum) == LOGOUT)
                		{
                    			taskCmd = 1;
                    			return;/*logout*/
                		}
                		taskCmd = 1;
            		}
        	}
        	else if (retValue == COMMAND_HELP)/*用户命令命令帮助*/
        	{
            		if (comSchNum < MAX_COMMAND)
            		{
				cmdHlpMsg(comSchNum);
            		}
                	continue;
        	}
        	else if (retValue == COMMAND_LIST)/*显示相关的命令*/
        	{
            		cmdListShow();
            		continue;
        	}
        	else if (retValue == WORD_TOO_LONG)
        	{
            		commonMsgPrint(41, TRUE);
        	}
        	else
        	{
            		commonMsgPrint(19, TRUE);
        	}

        	inputed_length = 0;
    	}
}

/*******************************************************************************
函数：cmdCmp
功能：将用户输入的命令与命令集中的所有命令做比较
参数：
    输入--
    输出--ErrorPos，字符串中错误的位置
　　　0xff-----输入的命令在命令集中找到，命令编号为comSchNum
　　　其它--输入的命令不在命令集中
返回：函数编号command_num
描述：将输入的命令字符串用splitWord分隔为一个个单词，然
　　　后用nodeChk检查是否符合命令集中的命令
*******************************************************************************/
UINT8 cmdCmp(UINT8 *ErrorPos, UINT8 *commandNum)
{
    	UINT8 ErrorPosTmp;
    	INT8 retWord[WORD_LENGTN];
    	COMMAND_NODE * ppHead;
    	UINT8 nodeStatus;
    	COMMAND_NODE * ppHeadBrother;

    	ppHead = pHead;
    	ErrorPosTmp = *ErrorPos;
    	nodeStatus = WORD_EXIST;

    	variableDeep = 0;
    	*commandNum = 0;
		
    	/*取第一个单词*/
    	if ( splitWord(s, retWord, ErrorPos) == ERROR)
    	{
        	return WORD_TOO_LONG;
    	}

    	while(1)
    	{
        	/*在brother结点中查询当前的单词*/
        	nodeStatus = nodeChk(retWord, ppHead);
        	if (nodeStatus != WORD_NOT_EXIST)
        	{	
        		ppHead = nodeJmp(retWord, ppHead, nodeStatus);
            		ErrorPosTmp = *ErrorPos;

            		/*如果当前的单词为参数，则保存到参数数组里*/
            		if (nodeStatus == VARIABLE_WORD)
            		{		
				if(strlen(retWord)<20)/*added by wys???*/
				{
                			strcpy((variable_string[variableDeep++]), retWord);
				}
				else
				{
					return WORD_TOO_LONG;
				}
            		}
        	}
        	else
        	{	
            		*ErrorPos = ErrorPosTmp;
            		return COMMAND_NOT_EXIST;
        	}
			
	
        	/*用户输入的命令到了结尾*/
        	if(s[*ErrorPos] == '\0')
        	{	
            		/*用户输入的命令有匹配的，但没有输入完整*/
            		/*显示相关的命令*/
            		if(ppHead->command_number == 0xff)
            		{		
                		return COMMAND_LIST;
            		}
            		else
            		{		
                		/*用户输入的命令完整，用户希望得到命令的帮助*/
                		if (s[(*ErrorPos)+1] == '\0' && s[(*ErrorPos)+2] == 0x2f)
                		{		
                    			*commandNum = ppHead->command_number;
                    			return COMMAND_HELP;
                		}
                		else/*用户输入的命令完整，调试任务*/
                		{		
                    			*commandNum = ppHead->command_number;

                    			//如果brother结点也符合要求则打印相关的命令
                    			ppHeadBrother = ppHead->brother;
                    			if (ppHeadBrother == NULL)
                    			{
                        			return COMMAND_FOUND;
                    			}
                    
                    			nodeStatus = nodeChk(retWord, ppHeadBrother);
                    			if ((nodeStatus == WORD_EXIST)||(nodeStatus == VARIABLE_WORD))
                    			{
                        			return COMMAND_LIST;
                    			}
                    			else
                    			{
                        			return COMMAND_FOUND;
                    			}
                		}
            		}
        	}
        	else/*判断用户输入命令的下一个单词*/
        	{
            		if (splitWord(s, retWord, ErrorPos)==ERROR)
            		{
                		*ErrorPos = ErrorPosTmp;
                		return WORD_TOO_LONG;
            		}
            		ppHead = ppHead->son;
        	}

    	}
}

/*******************************************************************************
函数：splitWord
功能：从字符串中分离一个关键字
参数：
    输入--
    输出--
返回：
描述：从ErrorPos位置开始分离一个关键字
*******************************************************************************/
void cmdListShow(void)
{
    	UINT8 ErrorPosTmp, ErrorPos;
    	INT8 retWord[WORD_LENGTN];
    	COMMAND_NODE * ppHead;
    	UINT8 nodeStatus, finished;
    	COMMAND_NODE * ppHeadTmp;
    	const struct  cmd_entry *command;
    
    	ppHead = pHead;
    	ErrorPosTmp = ErrorPos = 0;
    	nodeStatus = WORD_EXIST;
    
    	ErrorPos = 0;
    	finished = TRUE;
    	while(finished)
    	{
        	if(s[ErrorPos]==' ')
        	{
            		ErrorPos++;
        	}
        	else
        	{
            		finished = FALSE;
        	}
    	}

    	/*取第一个单词*/
    	splitWord(s, retWord, &ErrorPos);

    	while(1)
    	{
        	nodeStatus = nodeChk(retWord, ppHead);
        	if (nodeStatus != WORD_NOT_EXIST)
        	{
            		ppHead = nodeJmp(retWord, ppHead, nodeStatus);
            		ErrorPosTmp = ErrorPos;
        	}