cli_interpret.c

命令行在嵌入式系统的实现

/************************************************************************
Copyright 200X - 200X+1.

filename     : CLI_Interpret.c

description  : 实现了命令解释的过程。包括命令的匹配、联想、交互输入
               与解释成功的操作执行

author       : Woodhead

modification : Woodhead    create              2004-12-07
************************************************************************/

#include "Ros.h"
#include "ML.h"
#include "Sys_Ml.h"
#include "Cli_MlPriv.h"
#include "Cli_Private.inc"
#include "Cli_intp.inc"
#include "..\include\Cli_Io.h"
#include "Board_Pub.h"

extern CT_MODE_T m_sCliSysModes[MAX_MODE_NUM];
extern CT_USERTYPE_T m_sCliUserType[CT_MAX_USERTYPES];
extern CT_MODE_RECORD_T *m_sModeMutex[CTM_TOTAL];

_U32 m_ulLogTag = 0;

/*********************************************************************/
/* 函数名称 : CI_IntpKernelProc()                                    */
/* 函数功能 : 命令解释核心函数，本文件的其它函数都围绕该函数而展开   */
/* 输入参数 : pWS 环境变量                                           */
/* 输出参数 :                                                        */
/* 返回     : SUCCESS: 解释成功，目前调用者对此返回值不敏感          */
/*            FAILURE: 由于特定的原因导致解释失败，调用者对此也不敏感*/
/*            CT_INTP_RETURNED_FOR_HELP: 帮助信息获取结束的返回，如果*/
/*                 是这种情况，编辑缓冲是不会清除的                  */
/*            CT_INTP_RETURNED_FOR_NEWLINE: 由于解释过程需要用户输入 */
/*                 新的命令字，输入完毕后应当返回该值，命令执行者会  */
/*                 据此重新调用本函数，以便支持正常的行编辑操作      */
/* 上层函数 :                                                        */
/* 创建者   :                                                        */
/* 修改记录 :                                                        */
/*********************************************************************/
_U32 CI_IntpKernelProc(CT_WS_P pWS)
{
    _S8 *szCmd;
    _S8 szToken[CT_MAX_CMDLEN + 1];
    _U32 ulStatus=0;
    _U32 ulUserRightLevel;
    _U32 ulCurrentMode;
    _BOOL bFirstToken;
    _U32 ulRet;
    CI_POINTER_T pointer;

    CLI_ASSURE_OR_FAIL(pWS != G_NULL)

    if ((pWS->ulStatus & STAT_ENV_NEWLINE) == 0)
    {
        pWS->ulValidParams = 0;
        CI_ResetIndexTable(pWS);
    }

    /* Initialize Pointers */
    pointer.curP.pObj   = G_NULL;
    pointer.curP.pParam = G_NULL;
    pointer.curP.pValue = G_NULL;

    pointer.expP.pObj   = G_NULL;
    pointer.expP.pParam = G_NULL;
    pointer.expP.pValue = G_NULL;
    pointer.pIndexParam = G_NULL;
    /* reset patch string */
    pointer.szPatch[0] = 0;
    pointer.szToken = &szToken[0];

    /* set parameter/value ulIndex */
    pointer.ulValueIndex = pWS->ulParamIndex;


    /* store the pointer of enviroment structure */
    pointer.pWS = pWS;


    szToken[0] = 0;
    szCmd = pWS->szCmdString;
    _rtrim(szCmd);
    ulCurrentMode = pWS->ulCurrentMode;

    /* Null command string is ignored by interpreter */
    if(G_NULL != strchr(szCmd,KEY_CTRL_C) || G_NULL != strchr(szCmd,KEY_CTRL_Z))
    {
        szCmd[0] = '\0';
        return G_SUCCESS;
    }

    if(szCmd[0] == '!')
    {
        szCmd[0] = '\0';
        return G_SUCCESS;
    }


    if(EOS_StrLen(szCmd) == 0)
    {
        return G_SUCCESS;
    }

    if (!EOS_StriCmp(szCmd, "cm..") && !IS_ENV_SILENT(pWS->ulStatus))
    {
        EOS_StrCpy (szCmd, CMD_CM "..");
    }

    SET_WAIT_OBJ(ulStatus);
    if(IS_ENV_SILENT(pWS->ulStatus))
        ulStatus |= STAT_ENV_SILENT ;

    /* 初始化pointer指针 */

    pointer.ulStatus = &ulStatus;
    pointer.curP.pObj = m_sCliSysModes[ulCurrentMode].pObject;
    if(pointer.curP.pObj == G_NULL)
    {
        MT_ERRLOG(ulCurrentMode);
        return G_FAILURE;
    }

    if(G_NULL != pointer.curP.pObj->pSubObject)
    {
        pointer.expP.pObj = pointer.curP.pObj->pSubObject;
        pointer.expP.pParam = G_NULL;
        pointer.expP.pValue = G_NULL;

    }
    else
    {
        if(!IS_ENV_SILENT(pWS->ulStatus))
            MT_ERRLOG(0);
        return G_FAILURE;
    }

    /* First Token */
    bFirstToken = G_TRUE;
    ulUserRightLevel = CI_GetUserRightLevel(pWS);

    for(;;)
    {
        while((ulRet = CI_GetCmdToken( &szCmd, &szToken[0], &ulStatus, &pointer ))
               == G_SUCCESS )
        {
            pointer.szPatch[0] = '\0';

            /* If token include '?', show help information */
            if( G_NULL != strchr(szToken,'?') )
            {
                m_ulLogTag = 1;
                /* 交互状态下，该值由用户输入获取，因此需要填入，作用见于函数 CLI_CmdRecord*/
                if (IS_INTERACTIVE(ulStatus))
                {
                    EOS_StrCat(szCmd, " ");
                    EOS_StrCat(szCmd, szToken);
                }
                CI_ShowHelp( &pointer, ulCurrentMode, ulStatus);
                return CT_INTP_RETURNED_FOR_HELP;
            }

            if((G_NULL != strchr(szToken,KEY_CTRL_C)) || (G_NULL != strchr(szToken,KEY_CTRL_Z)))
            {
                szToken[0] = '\0';
                SET_WAIT_NULL(ulStatus);
                return G_SUCCESS;
            }
            /* if this is the first token, 'no' token has a
               special meaning of no_form_command.          */
            if( ( bFirstToken == G_TRUE) &&
                ( EOS_StriCmp(szToken, "no") == 0 ) )
            {
                SET_NOFORM(ulStatus);
                SET_MATCHSUCC(ulStatus);
                bFirstToken = G_FALSE;
                continue;
            }

            /* Check the token with the waiting element */
            if( CI_CheckElement(szToken, &pointer, &ulStatus)
                  != G_SUCCESS )
            {
                if((pointer.szPatch[0]) && (!IS_ENV_ENTER(pWS->ulStatus)))
                {
                    if (EOS_StrLen(pWS->szCmdString) + EOS_StrLen(pointer.szPatch) >= CT_MAX_CMDBUF)
                    {
                        DBG_Out(PID_CLI, MT_DBGOUT_NOTE, "\r\n IntpKernel::命令缓冲濒临溢出");
                        MT_ERRLOG(0);
                        return G_SUCCESS;
                    }
                    EOS_StrCat( pWS->szCmdString, &pointer.szPatch[0]);
                    return G_SUCCESS;
                }
                if(IS_WAIT_OBJ(ulStatus))
                {
                    if((!IS_ENV_SILENT(pWS->ulStatus))
                      && (CI_IfCommandHelp(pWS) != G_SUCCESS))
                    {
                        IO_Print(CLI_INTP_CMD_ERR);
                        IO_OutString(pWS->szCmdString);
                        IO_OutString("(");
                        IO_OutString(pointer.expP.pObj->szName);
                        IO_OutString(")");
                    }
                    return G_FAILURE;
                }
                else if(IS_WAIT_PARAM(ulStatus))
                {
                    if(!IS_ENV_SILENT(pWS->ulStatus))
                    {
                        IO_Print(CLI_INTP_INVALID_PARAM) ;
                        IO_OutString(szToken);
                        IO_OutString("(");
                        IO_OutString(pointer.expP.pParam->szName);
                        IO_OutString(")");
                        return G_FAILURE;
                    }
                }
                else if(IS_WAIT_VALUE(ulStatus))
                {
                    if(!IS_ENV_SILENT(pWS->ulStatus))
                    {
                        IO_Print(CLI_INTP_INVALID_VALUE) ;
                        IO_OutString(szToken);
                        IO_OutString("(");
                        IO_OutString(pointer.expP.pValue->szName);
                        IO_OutString(")");
                        return G_FAILURE;
                    }
                }

            }
            else
            {
                if( CI_UserPermitted(ulUserRightLevel, pointer.curP.pObj, ulStatus)
                     != G_SUCCESS )
                {
                    if(CI_IfCommandHelp(pWS) != G_SUCCESS)
                    {
                        if(!IS_ENV_SILENT(pWS->ulStatus))
                        {
                            IO_Print(CLI_INTP_CMD_ERR);
                            IO_OutString(szToken);
                        }
                    }

                    return G_FAILURE;
                }

                if( IS_INTERACTIVE(ulStatus) )
                {
                    IO_OutString(pointer.szPatch);
                    if(pointer.ucMatchFlag != CTMF_FULL)
                        EOS_StrCat(szToken, pointer.szPatch);
                    pointer.szPatch[0] = '\0';
                    if(szToken[0])
                    {
                        if((EOS_StrLen(pWS->szCmdString) + EOS_StrLen(szToken) + 1)
                            < CT_MAX_CMDBUF - 1)
                        {
                            EOS_StrCat(pWS->szCmdString, " ");
                            EOS_StrCat(pWS->szCmdString, szToken);
                        }
                        szCmd = szCmd + EOS_StrLen(szToken) + 1;
                    }
                }
            }
            /* If status is tailing string, we stop here.           */
            /* When tailing string is encountered, we could suppose
              that we reach the end of a command tree.              */

            /* Get the next element in the object tree */
            if( CI_GetExpectedElement( &pointer, &ulStatus )
                 != G_SUCCESS )
            {
                /* No more elements exist => end of a command tree */
                if(strchr(szCmd,'?') != G_NULL)
                {
                    m_ulLogTag = 1;
                    if(!IS_ENV_SILENT(pWS->ulStatus))
                    {
                        CI_ShowHelp( &pointer, ulCurrentMode, ulStatus);
                    }
                    return CT_INTP_RETURNED_FOR_HELP;
                }

                break;
            }

            bFirstToken = G_FALSE;

        }//end of while(CI_GetCmdToken())
        if (ulRet == CT_INTP_RETURNED_FOR_NEWLINE)
            return CT_INTP_RETURNED_FOR_NEWLINE;

        if(IS_BIGTOKEN(ulStatus))
        {
            return G_FAILURE;
        }

        if(IS_UNWANTED(ulStatus))
        {
            if(!IS_ENV_SILENT(pWS->ulStatus) && (*szCmd != 0))
            {
                IO_Print(CLI_INTP_INNEED_PARAM) ;
                IO_OutString(szCmd);
            }
            return G_FAILURE;
        }

        /* No more elements exist => end of a command tree */
        if( !IS_COMPLETE(ulStatus) && !IS_ENV_SILENT(pWS->ulStatus))
        {
            if(CT_IS_SMARTON(pointer))
            {
                SET_INTERACTIVE( ulStatus );
            }
            else
            {
                if (IS_WAIT_PARAM(ulStatus)
                 && (pointer.expP.pParam->paramType.ucAttrib == CT_PRMPROP_NULL)
                 && (pointer.expP.pParam->valueList.ulNumber != 0))
                {
                    pointer.expP.pValue = pointer.expP.pParam->valueList.pValue;
                    SET_WAIT_VALUE(ulStatus);
                }
                break;
            }
        }
        else if(*szCmd != 0)
        {
            if(!IS_ENV_SILENT(pWS->ulStatus))
            {
                IO_Print(CLI_INTP_INNEED_PARAM) ;
                IO_OutString(szCmd);
            }
            return G_FAILURE;
        }
        else
        {
            break;
        }
    } /* end of while(1) */

    if ((!IS_NOFORM(pWS->ulStatus)
      && (CI_IsObjectExecutable(pointer.curP.pObj,HAVEACTIONS) != G_SUCCESS))
     || (IS_NOFORM(pWS->ulStatus)
      && (CI_IsObjectExecutable(pointer.curP.pObj,HAVENOACTIONS) != G_SUCCESS)))
    {
        if(!IS_ENV_SILENT(pWS->ulStatus))
        {
            IO_Print(CLI_INTP_CMD_INCOMPLETE);
            /* Simulate the "xxx ?" format */
            EOS_StrCpy(pointer.szToken,"?");
            CI_ShowHelp( &pointer, ulCurrentMode, ulStatus);