cli_cmdreg.c

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

    /* 3. set value type */
    pTempValue->valueType.ucAttrib  = CT_VALPROP_CHECK;
    pTempValue->valueType.ucDataLen = ucDataLen;
    pTempValue->valueType.ucDataType = ucDataType;

    /* 4. Set absolute ulIndex */
    pTempValue->ulAbsoluteIndex = ulIndex;

    /* 5. other data set according to datatype */
    switch(ucDataType)
    {
        case CT_DATA_VU:
        case CT_DATA_VH:
                if((_U32)iLow <= (_U32)iHigh)
                {
                    /* Unsigned value saved as signed */
                    pTempValue->s32IntFilter[0] = iLow;
                    pTempValue->s32IntFilter[1] = iHigh;
                }
                else
                {
                    if (CT_FreeValue(pTempValue) != G_SUCCESS)
                    {
                        //统计
                    }
                    return G_NULL;
                }
                break;
        case CT_DATA_VI:
                if(iLow <= iHigh)
                {
                    pTempValue->s32IntFilter[0] = iLow;
                    pTempValue->s32IntFilter[1] = iHigh;
                }
                else
                {
                    if (CT_FreeValue(pTempValue) != G_SUCCESS)
                    {
                        //统计
                    }
                    return G_NULL;
                }
                break;

        case CT_DATA_VS:
                if(ucDataLen >= CT_MAX_PARAMLEN)
                {
                    if (CT_FreeValue(pTempValue) != G_SUCCESS)
                    {
                        //统计
                    }
                    return G_NULL;
                }
                break;
        case CT_DATA_K:
                pKeyword = CT_NewKeywords(szKeys,&ulCount);
                if(pKeyword == G_NULL)
                {
                    if (CT_FreeValue(pTempValue) != G_SUCCESS)
                    {
                        //统计
                    }
                    return G_NULL;
                }
                pTempValue->keywords.pKeyword = pKeyword;
                pTempValue->keywords.ulNumber = ulCount;
                break;

        case CT_DATA_IP:
        case CT_DATA_MAC:
        case CT_DATA_MASK:
        case CT_DATA_DATE:
        case CT_DATA_TIME:
                break;
        default:
                if((ucDataType >= CT_DATA_USER) && (ucDataType < CT_DATA_BOTTOM))
                {
                    if(CT_ValidateUserType((_U32)ucDataType) != G_SUCCESS)
                    {
                        if (CT_FreeValue(pTempValue) != G_SUCCESS)
                        {
                            //统计
                        }
                        return G_NULL;
                    }
                }
                else
                {
                    if (CT_FreeValue(pTempValue) != G_SUCCESS)
                    {
                        //统计
                    }
                    return G_NULL;
                }
    }

    return pTempValue;

}

CT_VALUE_P CT_CreateValueWithCheck(_S8 *szName,
                                _U8 ucAttrib, _U8 ucDataType, _U8 ucDataLen,
                                _S8 *szKeys,  _S32 iLow, _S32 iHigh,
                                _U32 ulIndex,
                                CT_USERCHECK_FUNC_T pFunc)
{
    _U32 ulCount;
    _S8 szNameTmp[15];
    CT_VALUE_P pValue;
    CT_SERIAL_WORD_P pKeyword = G_NULL;

    /* 1. Malloc memory */
    pValue = CT_NewValue();
    if(pValue == G_NULL)
        return G_NULL;

    /* 2. Set Name */
    if(szName == G_NULL)
    {
        EOS_StrCpy(szNameTmp, "value");
        pValue->szName = ROS_MemAlloc(EOS_StrLen(szNameTmp)+1, ROS_MEM_ALLOC_OPT_NONE);
        if(pValue->szName == G_NULL)
        {
            if (CT_FreeValue(pValue) != G_SUCCESS)
            {
                //统计
            }
            return G_NULL;
        }
        EOS_StrCpy(pValue->szName,szNameTmp);
    }
    else
    {
        pValue->szName = ROS_MemAlloc(EOS_StrLen(szName)+1, ROS_MEM_ALLOC_OPT_NONE);
        if(pValue->szName == G_NULL)
        {
            if (CT_FreeValue(pValue) != G_SUCCESS)
            {
                //统计
            }
            return G_NULL;
        }
        EOS_StrCpy(pValue->szName,szName);
    }

    /* 3. set value type */
    /* 数据的长度不得超过最大参数长度*/
    if (ucDataLen >= CT_MAX_PARAMLEN)
    {
        return G_NULL;
    }
    pValue->valueType.ucDataLen = ucDataLen;
    pValue->valueType.ucAttrib  = CT_VALPROP_NULL;
    pValue->valueType.ucDataType = ucDataType;

    /* 4. Set absolute ulIndex */
    pValue->ulAbsoluteIndex = ulIndex;

    /* 5. other data set according to datatype */
    switch(ucDataType)
    {
        case CT_DATA_VU:
        case CT_DATA_VH:
                if(ucAttrib & CT_VALPROP_CHECK)
                {
                    if((_U32)iLow <= (_U32)iHigh)
                    {
                        /* Unsigned value saved as signed */
                        pValue->s32IntFilter[0] = iLow;
                        pValue->s32IntFilter[1] = iHigh;
                    }
                    else
                    {
                        if (CT_FreeValue(pValue) != G_SUCCESS)
                        {
                            //统计
                        }
                        return G_NULL;
                    }
                }
                break;
        case CT_DATA_VI:
                if(ucAttrib & CT_VALPROP_CHECK)
                {
                    if(iLow <= iHigh)
                    {
                        pValue->s32IntFilter[0] = iLow;
                        pValue->s32IntFilter[1] = iHigh;
                    }
                    else
                    {
                        if (CT_FreeValue(pValue) != G_SUCCESS)
                        {
                            //统计
                        }
                        return G_NULL;
                    }
                }
                break;
        case CT_DATA_VS:
                break;
        case CT_DATA_K:
                pKeyword = CT_NewKeywords(szKeys,&ulCount);
                if(pKeyword == G_NULL)
                {
                    if (CT_FreeValue(pValue) != G_SUCCESS)
                    {
                        //统计
                    }
                    return G_NULL;
                }
                pValue->keywords.pKeyword = pKeyword;
                pValue->keywords.ulNumber = ulCount;
                break;
        default:
                /* Here we get an invalid data type */
                if (CT_FreeValue(pValue) != G_SUCCESS)
                {
                    //统计
                }
                return G_NULL;
    }

    /* Register Value Check User Defined Function */
    pValue->pCheckFunc = pFunc;

    return pValue;

}

_U32 CT_DefineValueCheck(CT_VALUE_P pValue,CT_USERCHECK_FUNC_T pFunc)
{
    if(pValue == G_NULL)
    {
        return G_FAILURE;
    }

    pValue->pCheckFunc = pFunc;

    return G_SUCCESS;
}

_U32 CT_SetValueDefault(CT_VALUE_P pInValue, _S8 *szDefault)
{
    if(szDefault != G_NULL)
    {
        if(pInValue->szDefault != G_NULL)
        {
            ROS_MemFree(pInValue->szDefault);
            pInValue->szDefault = G_NULL;
        }

        pInValue->szDefault = ROS_MemAlloc(EOS_StrLen(szDefault)+1, ROS_MEM_ALLOC_OPT_NONE);
        if(pInValue->szDefault == G_NULL)
            return G_FAILURE;

        EOS_StrCpy(pInValue->szDefault,szDefault);
        pInValue->valueType.ucAttrib |= CT_VALPROP_DEFAULT;
    }
    else
    {
        if(pInValue->szDefault != G_NULL)
        {
            ROS_MemFree(pInValue->szDefault);
            pInValue->szDefault = G_NULL;
        }

        pInValue->valueType.ucAttrib &= ~CT_VALPROP_DEFAULT;
    }

    return G_SUCCESS;
}

_U32 CT_SetMode(_U32 ulMode, const _S8 *szName, const _S8 *szPrompt,
              const _S8 *s8Verb, CLI_OPERAT_LEVEL_T level,
              _U32 ulParentMode, CT_OBJECT_P pObject)
{
    CT_MODE_T ModeTemp;

    if(ulMode >= CTM_TOTAL)
    {
        return G_FAILURE;
    }
    ModeTemp.ulMode = ulMode;

    if( (szName == G_NULL)
     || (szPrompt == G_NULL)
     || (s8Verb == G_NULL) )
    {
        return G_FAILURE;
    }
    if( (EOS_StrLen(szName) >= CT_MAX_MODE_NAME - 1)
     || (EOS_StrLen(szPrompt) >= CT_MAX_MODE_PROMPT - 1)
     || (EOS_StrLen(s8Verb) >= CT_MAX_MODE_VERB - 1) )
    {
        return G_FAILURE;
    }
    EOS_StrCpy(ModeTemp.szModeVerb,s8Verb);
    EOS_StrCpy(ModeTemp.szModeName,szName);
    EOS_StrCpy(ModeTemp.szModePrompt,szPrompt);

    ModeTemp.rightLevel = level;

    if((ulParentMode >= ulMode) && (ulParentMode != NULL_MODE))
        return G_FAILURE;

    ModeTemp.ulParent = ulParentMode;
    ModeTemp.pObject = pObject;

    return (CT_RegMode(&ModeTemp));

}

_U32 CT_RegMode(CT_MODE_T *pMode)
{

    if(pMode == G_NULL)
        return G_FAILURE;

    if(pMode->ulMode < MAX_MODE_NUM)
    {
        if(m_sCliSysModes[pMode->ulMode].ulMode == NULL_MODE)
            m_sCliSysModes[pMode->ulMode].ulMode = pMode->ulMode;
        else
            return G_FAILURE;
    }
    else
        return G_FAILURE;

    EOS_StrCpy(&(m_sCliSysModes[pMode->ulMode].szModeName[0]),
           &(pMode->szModeName[0]));

    EOS_StrCpy(&(m_sCliSysModes[pMode->ulMode].szModePrompt[0]),
           &(pMode->szModePrompt[0]));

    EOS_StrCpy(&(m_sCliSysModes[pMode->ulMode].szModeVerb[0]),
           &(pMode->szModeVerb[0]));

    m_sCliSysModes[pMode->ulMode].rightLevel = pMode->rightLevel;

    m_sCliSysModes[pMode->ulMode].ulParent  = pMode->ulParent;

    m_sCliSysModes[pMode->ulMode].pObject   = pMode->pObject;

    return G_SUCCESS;
}

_U32 CT_RegModeObject(_U32 ulMode,CT_OBJECT_P pObject, _U32 ulParamCount)
{
    _U32 ulParentMode, ulRet = G_FAILURE;
    CT_OBJECT_P pObject1;

    if(ulMode < MAX_MODE_NUM)
    {
        if(m_sCliSysModes[ulMode].ulMode == ulMode)
        {
            m_sCliSysModes[ulMode].pObject = pObject;
            if(ulParamCount > 0)
            {
                /* 转换到新模式的命令 */
                m_sCliSysModes[ulMode].ulParamCount = ulParamCount;
            }

            if(ulMode > 0)
            {
                pObject1 = pObject->pParent;
                while( (pObject1 != G_NULL)&& !CT_OBJ_CHANGE_MODE(pObject1)  )
                {
                    pObject1 = pObject1->pParent;
                }
                ulParentMode = CI_GetNewMode(pObject1) ;
                m_sCliSysModes[ulMode].ulHierarchy = m_sCliSysModes[ulParentMode].ulHierarchy + 1 ;
            }
            ulRet = G_SUCCESS;
        }
    }

    if ((ulRet == G_SUCCESS) && (ulMode != CTM_GENL) && (ulMode != CTM_GLOBAL))
    {
        ulRet += CT_CmdAutoRegistEx(CMD_CM "..",
                                   (_U8)ulMode,
                                   CT_AL_QUERY,
                                   G_NULL,
                                   CT_MC_EXIT,
                                   NULL_MODE,
                                   CMDHELP_GLB_CM,
                                   CMDHELP_GLB_CM_PARENT,
                                   CLI_ML_NULL);
        ulRet += CT_CmdAutoRegistEx(CMD_CM "root",
                                   (_U8)ulMode,
                                   CT_AL_QUERY,
                                   G_NULL,
                                   CT_MC_END,
                                   NULL_MODE,
                                   CMDHELP_GLB_CM,
                                   CMDHELP_GLB_CM_ROOT,
                                   CLI_ML_NULL);

        if (ulMode != CTM_DIAG)
        {
            ulRet += CT_CmdAutoRegistEx(CMD_CM "diagnose",
                                       (_U8)ulMode,
                                       CT_AL_DEBUG,
                                       CLI_EnterDiagMode,
                                       CT_MC_NULL,
                                       NULL_MODE,
                                       CMDHELP_GLB_CM,
                                       CMDHELP_GENL_CM_DIAGNOSE,
                                       CLI_ML_NULL);
        }
    }

    return ulRet;

}

/* 该函数为一扩展的注册模式对象的函数,在注册该对象时可以为exit,end
   命令指定一个执行函数   */
_U32 CT_RegModeObjectExt( _U32 ulMode, CT_OBJECT_P pObject,
                        _U32 ulParamCount, CLI_CALLBACK_EXEC_FUN pFunc)
{
    _U32 ulParentMode, ulRet = G_FAILURE;
    CT_OBJECT_P pObject1;

    if(ulMode < MAX_MODE_NUM)
    {