cli_interpret.c

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

    {
        EOS_StrCpy( &(pPointer->szPatch[0]),CI_SetPatch(szToken,&szResult[0]));
        pPointer->ucMatchFlag = CTMF_PARTIAL;
        return G_FAILURE;
    }
    if(pObject == G_NULL)
    {
        return G_FAILURE;
    }

    SET_MATCHSUCC(*pulStatus);
    return G_SUCCESS;
} /* End of Function CI_CheckElementObject() */

/*********************************************************************/
/* 函数名称 : CI_CheckElementParameter()                                */
/* 函数功能 : 检验命令参数的合法性                                   */
/* 输入参数 : szToken   当前的命令字                                 */
/*            pPointer  命令解释核心结构                             */
/*            pulStatus 命令解释状态                                 */
/* 输出参数 : pulStatus 命令解释状态                                 */
/* 返回     : 成功、失败                                             */
/* 上层函数 : CI_CheckElement                                           */
/* 创建者   :                                                        */
/* 修改记录 :                                                        */
/*********************************************************************/
_U32 CI_CheckElementParameter(_S8 *szToken,
                    CI_POINTER_P pPointer,
                    _U32 *pulStatus )
{
    CI_INTERPT_POINTER_P pexpP;
    CT_PARAMETER_P pParam, pSaveParam, pParamMutex;
    _BOOL fParamMatched;
    _U32 ulIndex;
    _U32 ulMtIndex;
    _U32 ulCount = 0 ;
    _S8 szResult[256];

    szResult[0] = '\0';
    pexpP = &(pPointer->expP);
    pParam = pPointer->expP.pParam;
    fParamMatched = G_FALSE;

    if(pParam == G_NULL)
    {
        return G_FAILURE;
    }
    CLR_MUTEXPARAM(*pulStatus);

    if(CT_PARAM_IS_INDEX(pParam) && (G_NULL == pPointer->pIndexParam))
    {
        pPointer->pIndexParam = pParam;
    }
    /* Check if the parameter wanted is mutex.                      */
    /* if Mutex, we should search all brothers to match parameter   */
    if( CT_PARAM_IS_MUTEX(pParam) &&
       ((szToken != G_NULL) && (*szToken != '\0')))
    {
        pSaveParam = pParam ;
        ulMtIndex = pParam->ulAbsoluteIndex;

        while((pParam != G_NULL)
           && (CT_PARAM_IS_MUTEX(pParam))
           && (pParam->ulAbsoluteIndex == ulMtIndex))
        {
            /* 处理全字匹配命令参数的情况 */
            if( EOS_StriCmp( szToken, pParam->szName ) == 0 )
            {
                /* 只要出现全字匹配，就进入ulCount=1的流程(即使在全字匹配前ulCount>=1) */
                ulCount = 1; /* modify by wumo 2003-10-28 */
                pSaveParam = pParam ;
                break;
            }

           /* Partial Matching */
            else if( strmatch( szToken, pParam->szName ) == 0 )
            {
                ulCount++;
                pSaveParam = pParam ;
                CI_MatchMore(szResult,pParam->szName);
            }

            pParam = pParam->pNext;

        }/* end of while() */

        if( ulCount == 1)
        {
            /* 此处pc-lint有告警,确认不会有问题 */
            EOS_StrCpy( &(pPointer->szPatch[0]),
                    (pSaveParam->szName + EOS_StrLen(szToken)) );
            EOS_StrCat(szToken, pPointer->szPatch);
            pPointer->ucMatchFlag = CTMF_FULL;
            fParamMatched = G_TRUE;
            pexpP->pParam = pSaveParam;
            pParam = pSaveParam;
            COPY_POINTER_TO_CUR( pPointer );
            SET_MUTEXPARAM(*pulStatus);
            if( IS_VIRTUAL_P(*pulStatus) )
            {
                CLR_VIRTUAL_P(*pulStatus);
            }

        }
        else if(ulCount > 1)
        {
            EOS_StrCpy( &(pPointer->szPatch[0]),CI_SetPatch(szToken,&szResult[0]));
            pPointer->ucMatchFlag = CTMF_PARTIAL;
            if( IS_VIRTUAL_P(*pulStatus) )
            {
                CLR_VIRTUAL_P(*pulStatus);
            }

            return G_FAILURE;
        }


    }
    /* if not Mutex, then check if parameter name is needed? */
    else if( !CT_PARAM_NEED_NAME(pParam) )
    {

        if( CT_PARAM_IS_OPTIONAL(pParam) )
        {

            SET_VIRTUAL_P(*pulStatus);
        }

        SET_SKIP_FLAG(*pulStatus);
        fParamMatched = G_TRUE;
        COPY_POINTER_TO_CUR( pPointer );
    }
    /* Then check the current one */
    else if( strmatch( szToken, pexpP->pParam->szName ) == 0 )
    {
        if(szToken == G_NULL)
        {
            return G_FAILURE;
        }

        // 可选参数在交互后的行编辑情况下比较特殊，作以下处理
        if ((_U32)pParam != pPointer->pWS->ulExpectEle && pPointer->pWS->ulExpectEle != 0)
        {
            pSaveParam = (CT_PARAMETER_P)pPointer->pWS->ulExpectEle;
            // 如果当前参数为可选，则依次往下判断，看是否有合适的参数
            if (CT_PARAM_IS_OPTIONAL(pSaveParam))
            {
                if (strmatch(szToken, pSaveParam->szName) != 0)
                {
                    pexpP->pParam = pParam;
                    COPY_POINTER_TO_CUR( pPointer );
                    return G_SUCCESS;
                }
                pexpP->pParam = pSaveParam;
                pParam = pSaveParam;
            }
        }
        EOS_StrCpy( &(pPointer->szPatch[0]),
                 (pParam->szName + EOS_StrLen(szToken)) );
        EOS_StrCat(szToken, pPointer->szPatch);
        pPointer->ucMatchFlag = CTMF_FULL;
        fParamMatched = G_TRUE;
        COPY_POINTER_TO_CUR( pPointer );
        if( IS_VIRTUAL_P(*pulStatus) )
        {
            CLR_VIRTUAL_P(*pulStatus);
        }

    }

    if(fParamMatched == G_FALSE)
    {
        /* 如果参数互斥，这期望参数指针指向最后一个互斥参数 */
        if( CT_PARAM_IS_MUTEX(pexpP->pParam) )
        {

            /* 参数互斥可选 */
            if(CT_PARAM_IS_OPTIONAL(pexpP->pParam))
            {
                pParam = pexpP->pParam;
                pParamMutex = G_NULL;
                ulMtIndex = pParam->ulAbsoluteIndex;
                /* 允许某些连续兄弟参数存在互斥，
                   同时允许其他的兄弟参数可选或不互斥 */
                /* 搜索第一个不可选并且互斥或不互斥的
                   参数的前一个参数 */
                while((pParam != G_NULL)
                     && CT_PARAM_IS_OPTIONAL(pParam)
                     && CT_PARAM_IS_MUTEX(pParam)
                     && pParam->ulAbsoluteIndex == ulMtIndex)
                {
                    pParamMutex = pParam;
                    pParam = pParam->pNext;
                }
                pexpP->pParam = pParamMutex;
                SET_SKIP_FLAG(*pulStatus);
                COPY_POINTER_TO_CUR( pPointer );
                return G_SUCCESS;
            }
            else
            {
                return G_FAILURE;
            }
        }
        else if( CT_PARAM_IS_OPTIONAL(pexpP->pParam) || IS_VIRTUAL_P(*pulStatus))
        {
            if (szToken == G_NULL)
            {
                return G_FAILURE ;
            }

            if ( (IS_INTERACTIVE(*pulStatus) || ((_U32)pexpP->pParam == pPointer->pWS->ulExpectEle))
              && (*szToken != 0) )
            {
                return G_FAILURE ;
            }

            SET_SKIP_FLAG(*pulStatus);
            COPY_POINTER_TO_CUR( pPointer );
            return G_SUCCESS;
        }
        return G_FAILURE;
    }
    else
    {
        if (pParam == G_NULL)
        {
            return G_FAILURE ;
        }

        if( CT_PARAM_IS_INDEX(pParam)
         && !IS_INTERACTIVE(*pulStatus)
         && !IS_ENV_NEWLINE(pPointer->pWS->ulStatus))
            CI_AdjustParam(pPointer);

        if(!IS_SKIP_FLAG(*pulStatus))
        {
            ulIndex = pParam->ulAbsoluteIndex
                        + pPointer->ulValueIndex;
            if( CI_SaveParameter( pParam->szName, pParam->szName,
                    ulIndex, pPointer->pWS ) != G_SUCCESS )
            {
                //Show Error
                IO_Print(CLI_PARAM_CANNOT_SAVE, szToken, ulIndex);
                return G_FAILURE;
            }
        }
    }

    SET_MATCHSUCC(*pulStatus);
    return G_SUCCESS;

} /* End of Functioin CI_CheckElementParameter() */

/*********************************************************************/
/* 函数名称 : CI_CheckElementValue()                                 */
/* 函数功能 : 检验命令参数值的合法性                                 */
/* 输入参数 : szToken   当前的命令字                                 */
/*            pPointer  命令解释核心结构                             */
/*            pulStatus 命令解释状态                                 */
/* 输出参数 : pulStatus 命令解释状态                                 */
/* 返回     : 成功、失败                                             */
/* 上层函数 : CI_CheckElement                                        */
/* 创建者   :                                                        */
/* 修改记录 :                                                        */
/*********************************************************************/
_U32 CI_CheckElementValue( _S8 *szToken,
                    CI_POINTER_P pPointer,
                    _U32 *pulStatus )
{
    _BOOL bValueMatched;
    _S32 iVal;
    _U32 uVal;
    _U32 ulIndex, i;
    _U32 ulMlInfo = CLI_ML_NULL;
    CI_INTERPT_POINTER_P pexpP;
    CT_SERIAL_WORD_P pKeyword;
    _S8 szTmpToken[2][MAX_TOKEN_SIZE+1];
    _U8 ucDataType;

    szTmpToken[0][0] = 0 ;
    szTmpToken[1][0] = 0 ;
    pexpP = &(pPointer->expP);
    ulIndex = pexpP->pValue->ulAbsoluteIndex + pPointer->ulValueIndex;

    if ( IS_INTERACTIVE(*pulStatus) && (0 == szToken[0]) )
    {
        if ( CT_VALUE_HAVE_DEFAULT(pexpP->pValue) )
        {
            EOS_StrCpy(szToken,pexpP->pValue->szDefault);
            IO_OutString(szToken);
        }
    }

    if ( IS_INTERACTIVE(*pulStatus) && (strchr(szToken, ' ') != G_NULL) )
    {
        IO_Print(CLI_VALUE_HAS_BLANK);
        return G_FAILURE ;
    }

    /* Check if token is the expecting value/keyword/discrete */
    bValueMatched = G_FALSE;
    ucDataType = pexpP->pValue->valueType.ucDataType;

    /* Checking is different from each other for different data types */
    switch(ucDataType)
    {
        /* Value of Integer Type */
        case CT_DATA_VIK    :
        case CT_DATA_VI     :
                bValueMatched = ((_U32)_isintstr(szToken) == G_SUCCESS) ;
                if( G_TRUE ==  bValueMatched )
                {
                    if(CT_VALUE_USER_CHECK(pexpP->pValue))
                    {
                        bValueMatched = (pexpP->pValue->pCheckFunc(szToken,G_NULL,pPointer->pWS) == G_SUCCESS);
                    }
                    else if((pexpP->pValue->valueType.ucAttrib & CT_VALPROP_CHECK))
                    {
                        if((_U32)_VerifyAndCvtDwordI(szToken,
                            pexpP->pValue->s32IntFilter[0],
                            pexpP->pValue->s32IntFilter[1],
                            &iVal) != G_SUCCESS)
                        {
                            /* Match failed */
                            bValueMatched = G_FALSE;
                            ulMlInfo = CLI_INTEG_OVERFLOW;
                        }

                        /* 去掉整型字符串前面的0，方便以后处理 */
                        else if ( EOS_StriCmp( szToken, "" ) != 0 )
                        {
                            EOS_Sprintf(szToken, "%d", iVal);
                        }
                    }
                }
                break;
        /* Value of Unsigned Integer Type */
        case CT_DATA_VUK    :
        case CT_DATA_VU     :
                bValueMatched = ((_U32)_isdecstr(szToken) == G_SUCCESS) ;
                if( G_TRUE == bValueMatched )
                {
                    if(CT_VALUE_USER_CHECK(pexpP->pValue))
                    {
                        bValueMatched = (pexpP->pValue->pCheckFunc(szToken,G_NULL,pPointer->pWS) == G_SUCCESS);
                    }
                    else if((pexpP->pValue->valueType.ucAttrib & CT_VALPROP_CHECK))
                    {
                        if((_U32)_VerifyAndCvtDword(szToken,
                            (_U32)pexpP->pValue->s32IntFilter[0],
                            (_U32)pexpP->pValue->s32IntFilter[1],
                            &uVal) != G_SUCCESS)
                        {
                            /* Match failed */
                            bValueMatched = G_FALSE;
                            ulMlInfo = CLI_INTEG_OVERFLOW;
                        }

                        /* 去掉整型字符串前面的0，方便以后处理 */ /*by ljr*/