}

    return G_SUCCESS;

}

_U32 CT_RegParamToLink(CT_PARAMGROUP_P pParamLink,
                                CT_PARAMETER_P pNewParam)
{
    CT_PARAMETER_P pParam,pParam1;

    if((pParamLink == G_NULL) || (pNewParam == G_NULL))
    {
        return G_FAILURE;
    }

    pParam = pParamLink->pParam;
    if(pParam == G_NULL)
    {
        pParamLink->pParam = pNewParam;
        pParamLink->ulNumber++;
    }
    else
    {
        pParam1 = pParam;
        while(pParam != G_NULL)
        {
            if(CT_PARAM_NEED_NAME(pParam) && CT_PARAM_NEED_NAME(pNewParam))
            {
                if(CT_IS_SAME_PARAM(pParam,pNewParam))
                {
                    return G_FAILURE;
                }
            }
            pParam1 = pParam;
            pParam = pParam->pNext;
        }
        /* All parameters in link have null-parent-pointers */
        pParam1->pNext = pNewParam;
        pNewParam->pPrevious = pParam1;
        pParamLink->ulNumber++;
    }

    return G_SUCCESS;

}

/*********************************************************************/
/* 函數名稱 : CLI_GlobalCmdLink()                                    */
/* 函數功能 : 全局模式的命令鏈接                                     */
/* 輸入參數 : 無                                                     */
/* 輸出參數 : 無                                                     */
/* 返回     : 成功、失敗                                             */
/* 上層函數 : CLI_ProcessInit                                        */
/* 創建者   :                                                        */
/* 修改記錄 :                                                        */
/*********************************************************************/
_U32 CLI_GlobalCmdLink(_VOID)
{
    _U32 ulMode;
    CT_OBJECT_P pObject, pGlbObj;

    if (m_sCliSysModes[CTM_GLOBAL].pObject == G_NULL
     || m_sCliSysModes[CTM_GLOBAL].pObject->pSubObject == G_NULL)
    {
        /* ??? LingJian_Tailor : Change form G_FAILURE to G_SUCCESS */
        return G_SUCCESS;
    }

    pGlbObj = m_sCliSysModes[CTM_GLOBAL].pObject->pSubObject;

    for (ulMode = 0; ulMode < MAX_MODE_NUM; ulMode++)
    {
        if (ulMode == CTM_GLOBAL || m_sCliSysModes[ulMode].pObject == G_NULL )
            continue;
        pObject = m_sCliSysModes[ulMode].pObject->pSubObject;
        if (pObject == G_NULL)
            continue;

        while (pObject->pNext != G_NULL)
            pObject = pObject->pNext;
        pObject->pNext = pGlbObj;
    }
    return G_SUCCESS;
}

//*********************************************************
// 自動注冊開始 {{{{

/* 子功能全局變量聲明 */
static _U8 m_ucPosIndex = 1;   /* 變量的絕對位置索引 */

/*lint -e715 */
_U32 CT_CmdAutoRegist
              (const _S8 *szCmd,              //命令格式化串
               _U8  ucMode,                   //命令所屬模式
               CLI_OPERAT_LEVEL_T   ucLevel,  //命令使用等級
               CLI_CALLBACK_EXEC_FUN pFunc,   //命令執行函數
               _U8  ucModeChange,             //模式轉換屬性(非模式轉換命令填CT_MC_NULL)
               _U8  ucNewMode,                //新模式的ID  (僅當上一參數為CT_MC_NEW時有意義 )
               _U32 ulHelp1,                  //第一個對象的幫助信息
               _U32 ulHelp2,                  //第二個對象的幫助信息
               _U32 ulHelp3)
{
    (_VOID)ucMode;
    return G_SUCCESS;
}
/*lint -restore */


/*-------------------------------------------------------------------*/
/* 函數名稱 : CT_CmdAutoRegist                                       */
/* 功    能 : 命令自動注冊函數接口                                   */
/* 輸入參數 : 參數說明見函數定義                                     */
/* 輸出參數 : 無                                                     */
/* 返回     : 注冊成功/失敗                                          */
/* 調用說明 : 調用者自己保證命令語法的正確性,詳細說明可以參見命令行  */
/*            說明文檔. 注冊否定形式的命令,須確定該命令的肯定形式已  */
/*            經注冊,如注冊no timeout命令之前應該已經注冊timeout命令 */
/* 典型示例 : CT_CmdAutoRegist("cmdtest user-test: <type(u1~3)>",    */
/*             CTM_DBG, CT_AL_OPERATOR,  CLI_CmdTest4, CT_MC_NULL,   */
/*             NULL_MODE, CLI_ML_NULL,  CLI_ML_NULL,  CLI_ML_NULL ); */
/*-------------------------------------------------------------------*/
_U32 CT_CmdAutoRegistWithLocfun
              (const _S8 *szCmd,              //命令格式化串
               _U8  ucMode,                   //命令所屬模式
               CLI_OPERAT_LEVEL_T   ucLevel,  //命令使用等級
               CLI_CALLBACK_EXEC_FUN pLocFunc,//命令定位函數
               CLI_CALLBACK_EXEC_FUN pFunc,   //命令執行函數
               _U8  ucModeChange,             //模式轉換屬性(非模式轉換命令填CT_MC_NULL)
               _U8  ucNewMode,                //新模式的ID  (僅當上一參數為CT_MC_NEW時有意義 )
               _U32 ulHelp1,                  //第一個對象的幫助信息
               _U32 ulHelp2,                  //第二個對象的幫助信息
               _U32 ulHelp3)
{
    _S8 szCmdString[CT_MAX_CMD_FORMAT + 1];  /* 命令的表達式可以超過命令的實際長度256,暫定上限為1000*/
    _S8 szToken[CT_MAX_CMDLEN];
    _S8 *pCurPos;
    _U32  ulRet, ulIndex = 0;
    _U32  ulHelpID[CT_MAX_OBJECT_NUM], ulCheckID = ML_NULL_STRING_SID;
    _U8   ucIsNoForm = 0;
    CT_OBJECT_P pObject[CT_MAX_OBJECT_NUM], pObj = G_NULL;
    CT_OBJECT_P pFirstObj = G_NULL;
    CT_MODE_T   *sMode;
    CT_PARAMGROUP_P *pParamLink = G_NULL;

    CLI_ASSURE_OR_FAIL(szCmd != G_NULL && EOS_StrLen(szCmd) > 0);

    /* DEBUG模式的命令只能在調試版本中存在 */
#if !CLI_DEBUG_ON
    if (ucMode == CTM_DBG)
        return G_SUCCESS;
#endif

    EOS_StrCpy(szCmdString, szCmd);
    (_VOID)_AffirmStrBeLower(szCmdString);

    /* 命令的注冊語法檢查 */
    if (CT_IsCmdValid(szCmdString) != G_SUCCESS)
    {
        DBG_Out(PID_CLI, CLI_DBGOUT_ERR, "\r\n CLI: 命令格式不正確:%s",szCmd);
        DBG_ASSERT(0);
        return G_FAILURE;
    }

    /* 其它參數合法性檢查 */
    if (ucMode >= MAX_MODE_NUM || ucNewMode >= MAX_MODE_NUM || ucLevel > CT_AL_DEBUG)
    {
        DBG_Out(PID_CLI, CLI_DBGOUT_ERR,
            "\r\n CLI: 注冊命令存在不合法參數:mode-%d, new mode-%d, level-%d", ucMode, ucNewMode, ucLevel);
        DBG_ASSERT(0);
        return G_FAILURE;
    }

    ulHelpID[0] = ulHelp1;
    ulHelpID[1] = ulHelp2;
    ulHelpID[2] = ulHelp3;

    for (ulIndex = 0; ulIndex < 3; ulIndex++)
    {
        if (ulHelpID[ulIndex] != ML_NULL_STRING_SID)
            ulCheckID = ulHelpID[ulIndex];
    }

    #ifdef PC_LINT
    ulCheckID = ulCheckID;
    #endif

    if(!EOS_StrNCmp(szCmdString, "show ", 5))
        ucLevel = CT_AL_QUERY;

    pCurPos = szCmdString;
    ulIndex = 0;
    /* 如果是否定形式的命令，則命令樹中應該已經存在其肯定形式，
       因此不用再創建對象，而采取搜索對象的形式 */
    if (EOS_StrNCmp("no ", pCurPos, 3) == 0)
    {
        ucIsNoForm = 1;
        pCurPos   += 3;    //跳過"no "
        if ((sMode = CI_GetMode(ucMode)) == G_NULL)
        {
            DBG_Out(PID_CLI, CLI_DBGOUT_ERR,
                    "\r\n CLI: 該命令的肯定形式尚未注冊 : %s", szCmd);
            DBG_ASSERT(0);
            return G_FAILURE;
        }
        pObj = sMode->pObject;   /* 從模式對象開始搜索 */
    }

    /* 注冊對象 */
    while((ulRet = CT_GetObj(pCurPos, szToken)) != G_FAILURE)
    {
        if (ulRet == TOKEN_GET_ONLYSPACE)
        {
            pCurPos++;
            continue;
        }
        if (ulRet == TOKEN_GET_CMDNULL)
        {
            DBG_Out(PID_CLI, CLI_DBGOUT_ERR,
                    "\r\n CLI: 從:%s 中獲取命令字失敗 : %s", szCmd);
            DBG_ASSERT(0);
            return G_FAILURE;
        }

        pCurPos += EOS_StrLen(szToken);

        /* 注冊3個以上對象的命令不成功 */
        if (ulIndex > 2)
        {
            DBG_Out(PID_CLI, CLI_DBGOUT_ERR,
                    "\r\n  CLI: 關鍵命令字過多 : %s!", szCmd);
            DBG_ASSERT(0);
            return G_FAILURE;
        }

        if (EOS_StrLen(szToken) >= MAX_TOKEN_SIZE)
        {
            DBG_Out(PID_CLI, CLI_DBGOUT_ERR,
                    "\r\n  CLI: 超長命令字注冊 : %s!", szToken);
            DBG_ASSERT(0);
            return G_FAILURE;
        }

        /* 肯定形式的對象自動注冊 */
        if (ucIsNoForm == 0)
        {
            if (ulRet == TOKEN_GET_LASTOBJ)
            {
                /* 最后一個命令對象需要處理其操作方法: 回調函數或模式轉換 */
                switch (ucModeChange)
                {
                    case CT_MC_NULL:
                        /* 對于非模式轉換的命令需要保證帶回調函數 */
                        if (pFunc == G_NULL)
                        {
                            DBG_Out(PID_CLI, CLI_DBGOUT_ERR,
                                    "\r\n CLI: 命令(%s)\r\n      的對象(%s)沒有執行操作!", szCmd, szToken);
                            DBG_ASSERT(0);
                            return G_FAILURE;
                        }
                        pObject[ulIndex] = CT_CreateObject(szToken, ucMode, ucLevel,
                                        pFunc, G_FALSE, CT_MC_NULL, G_NULL);
                        pObject[ulIndex]->action.pLocFun = pLocFunc;
                        break;
                    /* 以下是對各種模式轉換類型的對象注冊 */
                    case CT_MC_END:
                        pObject[ulIndex] = CT_CreateObject(szToken, ucMode, ucLevel,
                                        pFunc, G_TRUE, CT_MC_END, G_NULL);
                        break;
                    case CT_MC_EXIT:
                        pObject[ulIndex] = CT_CreateObject(szToken, ucMode, ucLevel,
                                        pFunc, G_TRUE, CT_MC_EXIT, G_NULL);
                        break;
                    case CT_MC_NEW:
                        /* 如果是轉換到新模式，需要保證新模式的正確性 */
                        if (ucNewMode == NULL_MODE)
                        {
                            DBG_Out(PID_CLI, CLI_DBGOUT_ERR,
                                "\r\n CLI: 模式轉換命令注冊錯誤: 新模式ID: %d", ucNewMode);
                            DBG_ASSERT(0);
                            return G_FAILURE;
                        }

                        pObject[ulIndex] = CT_CreateObject(szToken, ucMode, ucLevel,
                                        pFunc, G_TRUE, CT_MC_NEW, G_NULL);

                        /* 如果是轉換到新模式，還需要將該對象注冊為新模式的模式對象*/
                        if (*pCurPos == ':' || *(pCurPos + 1) == ':')  /*這里需要改進*/
                            CT_RegModeObject(ucNewMode, pObject[ulIndex], 2);
                        else
                            CT_RegModeObject(ucNewMode, pObject[ulIndex], 0);
                        break;
                    default:
                        DBG_ASSERT(0);
                        return G_FAILURE;

                }
                pParamLink = &(pObject[ulIndex]->action.pParamLink);
            }
            else
            {
                pObject[ulIndex] = CT_CreateObject(szToken, ucMode, ucLevel,
                                G_NULL, G_FALSE, CT_MC_NULL, G_NULL);
            }
            if (pObject[ulIndex] == G_NULL)
            {
                DBG_Out(PID_CLI, CLI_DBGOUT_ERR, "\r\n CLI: 對象創建失敗: %s", szCmd);
                DBG_ASSERT(0);
                return G_FAILURE;
            }

            if (ulIndex == 0)
            {
                pFirstObj = pObject[ulIndex];
            }
            else
            {
                CT_RegObject(pObject[ulIndex - 1], pObject[ulIndex]);
            }

            if (ucMode != CTM_DBG && ucMode != CTM_DIAG)
            {
                if (ulHelpID[ulIndex] == CLI_ML_NULL)
                {
                    DBG_Out(PID_CLI, CLI_DBGOUT_ERR,
                            "\r\n CLI: 命令(%s)\r\n      的對象(%s) 缺少幫助信息!", szCmd, szToken);
                    DBG_ASSERT(0);
                    return G_FAILURE;
                }
                if (((CI_IsObjectExecutable(pObject[ulIndex], HAVEACTIONS) == G_SUCCESS)
                  && (strstr(ML_DirectGetString(ML_CHS, ulHelpID[ulIndex]), HELP_FUN) == G_NULL))
                 || ((CI_IsObjectExecutable(pObject[ulIndex], HAVEACTIONS) != G_SUCCESS)
                  && (strstr(ML_DirectGetString(ML_CHS, ulHelpID[ulIndex]), HELP_FUN) != G_NULL)))
                {
                    if (EOS_StriCmp(szToken, "cm"))
                    {
                        DBG_Out(PID_CLI, CLI_DBGOUT_ERR,
                                "\r\n CLI: 命令(%s)\r\n      的對象(%s) 幫助信息格式不正確!", szCmd, szToken);
                        DBG_ASSERT(0);
                        return G_FAILURE;
                    }
                }
            }
            CT_RegCmdHelp(pObject[ulIndex], ulHelpID[ulIndex]);

        }

        /* 否定形式的命令注冊: 自動查找肯定形式的命令并修改其屬性 */
        /* 使之具有命令的否定形式                                 */
        else
        {
            if (ulRet == TOKEN_GET_LASTOBJ)
            {
                pObj = CT_GetSubObjByName(pObj, szToken);

                if (pObj == G_NULL)
                {
                    DBG_Out(PID_CLI, CLI_DBGOUT_ERR,
                        "\r\n CLI: 該命令的肯定形式尚未注冊 : %s", szCmd);
                    DBG_ASSERT(0);
                    return G_FAILURE;
                }

                pParamLink = &(pObj->noAction.pParamLink);
                /* 設置該對象的否定屬性 */
                pObj->noAction.ulMode     = pObj->action.ulMode;
                pObj->noAction.rightLevel = pObj->action.rightLevel;
                pObj->noAction.pFunction  = pFunc;
                pObj->ulNoFlag            = 1;
            }
            else
            {
                pObj = CT_GetSubObjByName(pObj, szToken);
                if (pObj == G_NULL)
                {
                    DBG_Out(PID_CLI, CLI_DBGOUT_ERR,
                        "\r\n CLI: 該命令的肯定形式尚未注冊 : %s", szCmd);
                    DBG_ASSERT(0);
                    return G_FAILURE;
                }
                pObj->ulNoFlag = 1;
            }
        }

        ulIndex++;

        /* 如果已經是最后一個對象，則跳出循環 */
        if (ulRet == TOKEN_GET_LASTOBJ)
            break;
    }

    /* 注冊命令到模式必須要在所有對象創建完成之后進行, */
    /* 否則無法注冊具有相同對象的情況                  */
    if (ucIsNoForm == 0)
    {
        if (CT_RegObjToMode(ucMode, pFirstObj))
        {
            DBG_Out(PID_CLI, CLI_DBGOUT_ERR, "\r\n CLI: 命令注冊失敗: %s", szCmd);
            DBG_ASSERT(0);
        }
    }
    while (*pCurPos == KEY_SPACE)
        pCurPos++;

    if (*pCurPos != ':')
    {
//        DBG_Out(PID_CLI, CLI_DBGOUT_ERR, "\r\n【MODE-%d】:%s", ucMode, szCmdString);
        return G_SUCCESS;
    }

    while (*(++pCurPos) == KEY_SPACE)
        ;

    /* 這種情況表示分隔符后面已經沒有參數鏈，直接返回 */
    if (*pCurPos == '\0')
    {
//        DBG_Out(PID_CLI, CLI_DBGOUT_ERR, "\r\n【MODE-%d】:%s", ucMode, szCmdString);
        return G_SUCCESS;
    }

    if (pParamLink == G_NULL)   /* 此判斷不會進來，消除pc-lint告警 */