cli_cmdreg.c

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

    }

    return pReturn;
}

_U32 CT_FreeParameter(CT_PARAMETER_P pParam)
{
    CT_PARAMETER_P pParamTemp,pParamNext;

    if(pParam == G_NULL)  return G_FAILURE;

    pParamTemp = pParam;

    while(pParamTemp != G_NULL)
    {
        pParamNext = pParamTemp->pNext;

        /* 1. Free the heir parameter */
        if(pParamTemp->subParam != G_NULL)
        {
            if (CT_FreeParameter(pParamTemp->subParam) != G_SUCCESS)
            {
                return G_FAILURE;
            }
        }

        /* 2. Free itself */
        if(pParamTemp->szName != G_NULL)
        {
            ROS_MemFree(pParamTemp->szName);
        }
        if(pParamTemp->valueList.pValue != G_NULL)
        {
            if (CT_FreeValue(pParamTemp->valueList.pValue) != G_SUCCESS)
            {
                return G_FAILURE;
            }
        }
        ROS_MemFree(pParamTemp);

        pParamTemp = pParamNext;

    }

    return G_SUCCESS;
}

_U32 CT_FreeParamlink(CT_PARAMGROUP_P pParamLink)
{
    if(pParamLink == G_NULL)  return G_FAILURE;

    if(pParamLink->pParam != G_NULL)
    {
        if (CT_FreeParameter(pParamLink->pParam) != G_SUCCESS)
        {
            return G_FAILURE;
        }
    }

    ROS_MemFree(pParamLink);

    return G_SUCCESS;
}

_U32 CT_FreeObject(CT_OBJECT_P pObject)
{
    if(pObject == G_NULL) return G_FAILURE;

    /* 1. Free the szName String            */
    if(pObject->szName != G_NULL)
        ROS_MemFree(pObject->szName);

    /* 2. Free action's parameter link      */
    if(pObject->action.pParamLink != G_NULL)
    {
        if (CT_FreeParamlink(pObject->action.pParamLink) != G_SUCCESS)
        {
            return G_FAILURE;
        }
    }

    /* 3. Free noAction's parameter link    */
    if(pObject->noAction.pParamLink != G_NULL)
    {
        if (CT_FreeParamlink(pObject->noAction.pParamLink) != G_SUCCESS)
        {
            return G_FAILURE;
        }
    }

    /* 4. Free the Object   */
    ROS_MemFree(pObject);
    pObject = G_NULL;
    return G_SUCCESS;
}

CT_VALUE_P CT_NewValue(_VOID)
{
    CT_VALUE_P pValue;

    pValue = (CT_VALUE_P) ROS_MemAlloc(sizeof(CT_VALUE_T), ROS_MEM_ALLOC_OPT_NONE);

    if(pValue != G_NULL)
    {
        pValue->szName = G_NULL;
        pValue->s32IntFilter[0] = 0;
        pValue->s32IntFilter[1] = 0;
        pValue->pPrevious = G_NULL;
        pValue->pNext = G_NULL;
        pValue->ulAbsoluteIndex = 0;

        /* intialize valueType */
        pValue->valueType.ucAttrib = 0;
        pValue->valueType.ucDataType = CT_DATA_NULL;
        pValue->valueType.ucDataLen = 0;

        /* intialize keywords */
        pValue->keywords.ulNumber = 0;
        pValue->keywords.pKeyword = G_NULL;

        /* default value */
        pValue->szDefault = G_NULL;

        /* intialize check function pointer */
        pValue->pCheckFunc = G_NULL;
    }

    return pValue;

}

CT_VALUEGROUP_P CT_NewValuelink(_VOID)
{
    CT_VALUEGROUP_P pValue;

    pValue = (CT_VALUEGROUP_P) ROS_MemAlloc(sizeof(CT_VALUEGROUP_T), ROS_MEM_ALLOC_OPT_NONE);

    if(pValue != G_NULL)
    {
        pValue->ulNumber = 0;
        pValue->pValue = G_NULL;
    }

    return pValue;
}

CT_SERIAL_WORD_P CT_NewKeyword(_VOID)
{
    CT_SERIAL_WORD_P pKeyW;

    pKeyW = (CT_SERIAL_WORD_P) ROS_MemAlloc(sizeof(CT_SERIAL_WORD_T), ROS_MEM_ALLOC_OPT_NONE);

    if(pKeyW != G_NULL)
    {
        pKeyW->pK = G_NULL;
        pKeyW->pPrevious = G_NULL;
        pKeyW->pNext = G_NULL;
    }

    return pKeyW;
}

CT_OBJECT_P CT_NewObject(_VOID)
{
    CT_OBJECT_P pObj;

    pObj = (CT_OBJECT_P) ROS_MemAlloc(sizeof(CT_OBJECT_T), ROS_MEM_ALLOC_OPT_NONE);

    if(pObj != G_NULL)
    {
        pObj->szName = G_NULL;
        pObj->ulObjectCount = 0;
        pObj->pSubObject = G_NULL;
        pObj->pPrevious = G_NULL;
        pObj->pNext = G_NULL;
        pObj->pParent = G_NULL;
        pObj->ulNoFlag = 0;
        /* Initailize the action */
        pObj->action.ulMode = NULL_MODE;
        pObj->action.rightLevel = CT_AL_QUERY;
        pObj->action.pFunction = G_NULL;
        pObj->action.ulHelpID = CLI_ML_NULL;
        pObj->action.modeConv = CT_MC_NULL;
        pObj->action.pParamLink = G_NULL;

        pObj->noAction.ulMode = NULL_MODE;
        pObj->noAction.rightLevel = CT_AL_QUERY;
        pObj->noAction.pFunction = G_NULL;
        pObj->noAction.ulHelpID = CLI_ML_NULL;
        pObj->noAction.modeConv = CT_MC_NULL;
        pObj->noAction.pParamLink = G_NULL;

    }

    return pObj;

}

CT_PARAMETER_P CT_NewParameter(_VOID)
{
    CT_PARAMETER_P pParam;

    pParam = (CT_PARAMETER_P) ROS_MemAlloc(sizeof(CT_PARAMETER_T), ROS_MEM_ALLOC_OPT_NONE);

    if(pParam != G_NULL)
    {
        pParam->szName = G_NULL;
        pParam->subParam = G_NULL;
        pParam->pPrevious = G_NULL;
        pParam->pNext = G_NULL;
        pParam->pParent = G_NULL;

        /* intialize the paramType */
        pParam->paramType.ucAttrib = 0;
        pParam->paramType.reserved1 = 0;
        pParam->paramType.reserved2 = 0;

        /* intialize the valueList */
        pParam->valueList.ulNumber = 0;
        pParam->valueList.pValue = G_NULL;
    }

    return pParam;
}


CT_PARAMGROUP_P CT_NewParamlink(_VOID)
{
    CT_PARAMGROUP_P pParamLink;

    pParamLink = (CT_PARAMGROUP_P) ROS_MemAlloc(sizeof(CT_PARAMLINK_T), ROS_MEM_ALLOC_OPT_NONE);

    if(pParamLink != G_NULL)
    {
        pParamLink->ulNumber = 0;
        pParamLink->pParam = G_NULL;
    }

    return pParamLink;
}

CT_OBJECT_P CT_CreateObject(const _S8 *szName, _U32 ulMode,
            CLI_OPERAT_LEVEL_T level, CLI_CALLBACK_EXEC_FUN pFunc,
            _BOOL bChangeMode, CT_MODE_CHANGE_T modeConv,
            CLI_CALLBACK_EXEC_FUN pNoFunc)
{
    CT_OBJECT_P pObjTmp;
    CT_MODE_T *pMode;
    _U32 ulModeLevel;
    (void)bChangeMode;

    if(ulMode >= CTM_TOTAL)
        return G_NULL;

    if((szName == G_NULL) || (*szName == 0))
        return G_NULL;

    if(!EOS_StriCmp(szName, "show"))
        if(ulMode != CTM_GLOBAL)
            return G_NULL ;

    pObjTmp = CT_NewObject();
    if(pObjTmp == G_NULL)
        return G_NULL;

    /* 2. set object Name */
    pObjTmp->szName = ROS_MemAlloc(EOS_StrLen(szName) + 1, ROS_MEM_ALLOC_OPT_NONE);
    if(pObjTmp->szName == G_NULL)
    {
        if (CT_FreeObject(pObjTmp) != G_SUCCESS)
        {
            //统计
        }
        return G_NULL;
    }
    EOS_StrCpy(pObjTmp->szName,szName);
    _AffirmStrBeLower(pObjTmp->szName);

    /* 3. Set action */
    pObjTmp->action.ulMode = ulMode;
    pMode = CI_GetMode(ulMode);
    if(pMode == G_NULL)
    {
        if (CT_FreeObject(pObjTmp) != G_SUCCESS)
        {
            //统计
        }
        return G_NULL;
    }

    ulModeLevel = pMode->rightLevel;
    if(level != CT_AL_NULL)
    {
        if((_U32)level >= ulModeLevel)
            pObjTmp->action.rightLevel = level;
        else
            pObjTmp->action.rightLevel = (CLI_OPERAT_LEVEL_T)ulModeLevel;
    }
    else
        pObjTmp->action.rightLevel = (CLI_OPERAT_LEVEL_T)ulModeLevel;

    pObjTmp->action.modeConv = modeConv;
    pObjTmp->action.pFunction = pFunc;

    /* 4. Set no form action  */
    if( pNoFunc != G_NULL )
    {
        pObjTmp->noAction.ulMode = ulMode;
        pObjTmp->noAction.rightLevel = pObjTmp->action.rightLevel;
        pObjTmp->noAction.pFunction  = pNoFunc;
        pObjTmp->ulNoFlag = 1;
    }

    return pObjTmp;
}

CT_PARAMETER_P CT_CreateParameter( _S8 *szNameStr, _U8 ucTypeAttrib,
                                   _U8 ucIndex, _U32 ulIndex )
{
    _S8 szNameTmp[15];
    CT_PARAMETER_P pTempParam;
    (void)ucIndex;
    /* 1. Malloc memory */
    pTempParam = CT_NewParameter();
    if(pTempParam == G_NULL)
        return G_NULL;

    /* 2. Set name */
    if(szNameStr == G_NULL)
    {
        /* if name needed, G_NULL cause an error! */
        if(ucTypeAttrib & CT_PRMPROP_NAME)
        {
            if (CT_FreeParameter(pTempParam) != G_SUCCESS)
            {
                //统计
            }
            return G_NULL;
        }
        else
        {
            EOS_StrCpy(szNameTmp, "virtual-param");
            pTempParam->szName = ROS_MemAlloc(EOS_StrLen(szNameTmp)+1, ROS_MEM_ALLOC_OPT_NONE);
            if(pTempParam->szName == G_NULL)
            {
                if (CT_FreeParameter(pTempParam) != G_SUCCESS)
                {
                    //统计
                }
                return G_NULL;
            }
            EOS_StrCpy(pTempParam->szName,szNameTmp);
            _AffirmStrBeLower(pTempParam->szName);
        }
    }
    else
    {
        pTempParam->szName = ROS_MemAlloc(EOS_StrLen(szNameStr) + 1, ROS_MEM_ALLOC_OPT_NONE);
        if(pTempParam->szName == G_NULL)
        {
            if (CT_FreeParameter(pTempParam) != G_SUCCESS)
            {
                //统计
            }
            return G_NULL;
        }
        EOS_StrCpy(pTempParam->szName,szNameStr);
    }

    /* 3. Set attrib & Index */
    pTempParam->paramType.ucAttrib = ucTypeAttrib;

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

    return pTempParam;

}

CT_PARAMGROUP_P CT_CreateParamLink(_VOID)
{
    return CT_NewParamlink();
}

CT_VALUE_P CT_CreateValue(_S8 *szName, _U8 ucDataType,
                          _U8 ucDataLen, _S8 *szKeys,  _S32 iLow, _S32 iHigh,
                          _U32 ulIndex)
{
    _U32 ulCount;
    _S8 szNameTmp[15];
    CT_VALUE_P pTempValue;
    CT_SERIAL_WORD_P pKeyword = G_NULL;

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

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