Ejemplo n.º 1
0
VOS_UINT32 atParsePara( VOS_UINT8 * pData, VOS_UINT16 usLen)
{
    VOS_UINT16 usLength = 0;                        /*  记录当前已经处理的字符个数*/
    VOS_UINT8 *pucCurrPtr = pData;                  /*  指向当前正在处理的字符*/
    VOS_UINT8 *pucCopyPtr = pData;                  /*  拷贝内容的起始指针 */
    AT_STATE_TYPE_ENUM curr_state = AT_NONE_STATE;  /*  设置初始状态 */
    AT_STATE_TYPE_ENUM new_state = AT_NONE_STATE;   /*  设置初始状态 */

    /* 依次分析字符串中的每个字符*/
    while( (usLength++ < usLen) && (g_stATParseCmd.ucParaNumRangeIndex < AT_MAX_PARA_NUMBER) && (g_stATParseCmd.ucParaStrRangeIndex < AT_MAX_PARA_NUMBER))        /* 依次比较每个字符 */
    {
        curr_state = new_state;                 /*  当前状态设置为新状态*/

        /* 根据当前处理的字符和当前状态查表得到新状态 */
        new_state = atFindNextMainState(AT_MAIN_PARA_STATE_TAB,*pucCurrPtr,curr_state);

        switch(new_state)                       /* 状态处理*/
        {
        case AT_PARA_NUM_STATE:                 /* 参数状态*/
        case AT_PARA_LETTER_STATE:              /* 字母状态*/
        case AT_PARA_LEFT_QUOT_STATE:           /* 参数左引号状态*/
        case AT_PARA_NUM_SUB_STATE:             /* 范围数字状态*/
        case AT_PARA_ZERO_STATE:                /* 数字0状态 */
        case AT_PARA_ZERO_SUB_STATE:            /* 范围数字0状态 */
        case AT_PARA_NO_QUOT_LETTER_STATE:      /* 无双引号包括字母状态 */
            if(curr_state != new_state)         /* 新状态部分不等于当前状态*/
            {
                pucCopyPtr = pucCurrPtr;            /*  准备接收参数*/
            }
            break;

        case AT_PARA_HEX_STATE:                 /* 十六进制状态 */
            /* continue */
        case AT_PARA_HEX_NUM_STATE:             /* 十六进制数字状态 */
            /* continue */
        case AT_PARA_HEX_SUB_STATE:             /* 匹配范围十六进制状态 */
            /* continue */
        case AT_PARA_HEX_NUM_SUB_STATE:         /* 匹配范围十六进制数字状态 */
            break;

        case AT_PARA_QUOT_COLON_STATE:          /* 引号逗号状态 */

            /* 拷贝到字符参数脚本列表 */
            /* 字符参数索引加1*/

            if ((VOS_UINT32)(pucCurrPtr - pucCopyPtr) < sizeof(g_stATParseCmd.auStrRange[g_stATParseCmd.ucParaStrRangeIndex]))
            {
                atRangeCopy(g_stATParseCmd.auStrRange[g_stATParseCmd.ucParaStrRangeIndex++],pucCopyPtr,pucCurrPtr);
            }
            else
            {
                return AT_FAILURE;                  /* 返回错误 */
            }
            break;

        case AT_PARA_NUM_SUB_COLON_STATE:

            /* 转成数字拷贝到数字参数脚本列表的上界 */
            /* 数字参数索引加1*/
            g_stATParseCmd.astParaNumRange[g_stATParseCmd.ucParaNumRangeIndex++].ulBig = atRangeToU32(pucCopyPtr,pucCurrPtr);

            break;

        case AT_PARA_NUM_COLON_STATE:

            /* 转成数字拷贝到数字参数脚本列表的下界 */
            g_stATParseCmd.astParaNumRange[g_stATParseCmd.ucParaNumRangeIndex].ulSmall = atRangeToU32(pucCopyPtr,pucCurrPtr);

            /* 上界等于下界*/
            g_stATParseCmd.astParaNumRange[g_stATParseCmd.ucParaNumRangeIndex].ulBig = g_stATParseCmd.astParaNumRange[g_stATParseCmd.ucParaNumRangeIndex].ulSmall;

            /* 数字参数索引加1*/
            g_stATParseCmd.ucParaNumRangeIndex++;

            break;

        case AT_PARA_SUB_STATE:

            /* 转成数字拷贝到数字参数脚本列表的下界 */
            g_stATParseCmd.astParaNumRange[g_stATParseCmd.ucParaNumRangeIndex].ulSmall = atRangeToU32(pucCopyPtr,pucCurrPtr);

            break;

        case AT_PARA_RIGHT_BRACKET_STATE:             /* 参数匹配右括号状态 */
            switch (curr_state)
            {
            case AT_PARA_NUM_SUB_STATE:          /* 参数匹配范围数字状态 */
                /* continue */
            case AT_PARA_ZERO_SUB_STATE:
                /* continue */
            case AT_PARA_HEX_NUM_SUB_STATE:

                /* 转成数字拷贝到数字参数脚本列表的上界 */
                /* 数字参数索引加1*/
                g_stATParseCmd.astParaNumRange[g_stATParseCmd.ucParaNumRangeIndex++].ulBig = atRangeToU32(pucCopyPtr,pucCurrPtr);

                pgAtCheckFunc = atCheckNumPara;    /* 设置参数比较函数 */

                break;

            case AT_PARA_NUM_STATE:
                /* continue */
            case AT_PARA_ZERO_STATE:
                /* continue */
            case AT_PARA_HEX_NUM_STATE:

                /* 转成数字拷贝到数字参数脚本列表的下界 */
                g_stATParseCmd.astParaNumRange[g_stATParseCmd.ucParaNumRangeIndex].ulSmall = atRangeToU32(pucCopyPtr,pucCurrPtr);

                /* 上界等于下界*/
                g_stATParseCmd.astParaNumRange[g_stATParseCmd.ucParaNumRangeIndex].ulBig = g_stATParseCmd.astParaNumRange[g_stATParseCmd.ucParaNumRangeIndex].ulSmall;

                /* 数字参数索引加1*/
                g_stATParseCmd.ucParaNumRangeIndex++;

                pgAtCheckFunc = atCheckNumPara;    /* 设置参数比较函数 */

                break;

            case AT_PARA_LETTER_STATE:

                /* 拷贝到字符参数脚本列表 */
                if ((VOS_UINT32)(pucCurrPtr - pucCopyPtr) < sizeof(g_stATParseCmd.auStrRange[g_stATParseCmd.ucParaStrRangeIndex]))
                {
                    atRangeCopy(g_stATParseCmd.auStrRange[g_stATParseCmd.ucParaStrRangeIndex],pucCopyPtr,pucCurrPtr);
                }
                else
                {
                    return AT_FAILURE;                  /* 返回错误 */
                }

                /* 设置参数比较函数 */
                pgAtCheckFunc = At_CheckStringPara;

                break;

            case AT_PARA_NO_QUOT_LETTER_STATE:      /* 无双引号包括字母状态 */

                /* 拷贝到字符参数脚本列表 */
                if ((VOS_UINT32)(pucCurrPtr - pucCopyPtr) < sizeof(g_stATParseCmd.auStrRange[g_stATParseCmd.ucParaStrRangeIndex]))
                {
                    atRangeCopy(g_stATParseCmd.auStrRange[g_stATParseCmd.ucParaStrRangeIndex],pucCopyPtr,pucCurrPtr);
                }
                else
                {
                    return AT_FAILURE;                  /* 返回错误 */
                }

                /* 设置参数比较函数 */
                pgAtCheckFunc = atCheckNoQuotStringPara;

                break;

            default:    /* AT_PARA_RIGHT_QUOT_STATE */

                /* 拷贝到字符参数脚本列表 */
                if ((VOS_UINT32)(pucCurrPtr - pucCopyPtr) < sizeof(g_stATParseCmd.auStrRange[g_stATParseCmd.ucParaStrRangeIndex]))
                {
                    atRangeCopy(g_stATParseCmd.auStrRange[g_stATParseCmd.ucParaStrRangeIndex++],pucCopyPtr,pucCurrPtr);
                }
                else
                {
                    return AT_FAILURE;                  /* 返回错误 */
                }

                /* 设置参数比较函数 */
                pgAtCheckFunc = atCheckCharPara;

                break;
            }

            if(AT_FAILURE == atCmparePara())       /* 参数比较 */
            {
                return AT_FAILURE;                   /* 返回错误 */
            }
            break;

        case AT_BUTT_STATE:                     /* 无效状态 */
            return AT_FAILURE;                  /* 返回错误 */

        default:
            break;
        }
        pucCurrPtr++;                               /*  继续分析下一个字符*/
    }

    if(AT_NONE_STATE == new_state)                  /* 初始状态 */
    {
        return AT_FAILURE;                          /* 返回错误 */
    }

    return AT_SUCCESS;                          /*  返回正确*/
}
static VOS_VOID atScanDmcmdModifier( VOS_UINT8 *pData, VOS_UINT16 *pLen)
{
    VOS_UINT16 usLen     = 0;
    VOS_UINT8  *pWrite   = VOS_NULL_PTR;
    VOS_UINT8  *pRead    = VOS_NULL_PTR;
    VOS_UINT8  *pTmp     = VOS_NULL_PTR;
    VOS_UINT8  *pDataTmp = VOS_NULL_PTR;
    VOS_UINT8  aucStr[]  = "*99**PPP";
    VOS_UINT16 usStrLen  = 0;

    pDataTmp = (VOS_UINT8*)AT_MALLOC(*pLen + 1);
    if (VOS_NULL_PTR == pDataTmp)
    {
        vos_printf("atScanDmcmdModifier(): AT_MALLOC Failed!\n");
        return;
    }

    atRangeCopy(pDataTmp, pData, (pData + *pLen));

    /* 保证字符串有结束符 */
    pDataTmp[*pLen] = 0;

    pRead   = pDataTmp;
    pWrite  = pDataTmp;

    pTmp = (VOS_UINT8*)AT_STRSTR((VOS_CHAR *)pDataTmp,(VOS_CHAR *)aucStr);
    if(NULL != pTmp)
    {
        usStrLen = (VOS_UINT16)AT_STRLEN((VOS_CHAR *)aucStr);
        /* 检查前一半参数 */
        while ( pRead < pTmp )
        {
            /*删除修饰符,',','T','P','!','W','@'*/
            if((',' != *pRead) && ('T' != *pRead) && ('P' != *pRead)
                && ('!' != *pRead) && ('W' != *pRead) && ('@' != *pRead))
            {
                *pWrite++ = *pRead;
                usLen++;
            }
            pRead++;
        }
        while( pRead < (pTmp+usStrLen) )
        {
            *pWrite++ = *pRead++;
            usLen++;
        }
        while( pRead < (pDataTmp+(*pLen)) )
        {
            /*删除修饰符,',','T','P','!','W','@'*/
            if((',' != *pRead) && ('T' != *pRead) && ('P' != *pRead)
                && ('!' != *pRead) && ('W' != *pRead) && ('@' != *pRead))
            {
                *pWrite++ = *pRead;
                usLen++;
            }
            pRead++;
        }
    }
    else
    {
        /* 输入参数检查 */
        while ( pRead < (pDataTmp+(*pLen)) )
        {
            /*删除修饰符,',','T','P','!','W','@'*/
            if((',' != *pRead) && ('T' != *pRead) && ('P' != *pRead)
                && ('!' != *pRead) && ('W' != *pRead) && ('@' != *pRead))
            {
                *pWrite++ = *pRead;
                usLen++;
            }
            pRead++;
        }
    }

    atRangeCopy(pData, pDataTmp, (pDataTmp + *pLen));

    *pLen = usLen;

    AT_FREE(pDataTmp);
    return;
}
Ejemplo n.º 3
0
VOS_UINT32 atParseExtendCmd( VOS_UINT8 * pData, VOS_UINT16 usLen)
{
    AT_STATE_TYPE_ENUM curr_state = AT_NONE_STATE;  /*  设置初始状态 */
    AT_STATE_TYPE_ENUM new_state = AT_NONE_STATE;   /*  设置初始状态 */
    VOS_UINT8 *pucCurrPtr = pData;                  /*  指向当前正在处理的字符*/
    VOS_UINT8 *pucCopyPtr = pData;                  /*  拷贝内容的起始指针 */
    VOS_UINT16 usLength = 0;                        /*  记录当前已经处理的字符个数*/

    /* 依次分析字符串中的每个字符*/
    while(usLength++ < usLen)                  /* 依次比较每个字符 */
    {
        curr_state = new_state;                 /* 当前状态设置为新状态*/

        /*  根据当前处理的字符和当前状态查表得到新状态*/
        new_state = atFindNextMainState(AT_E_CMD_MAIN_STATE_TAB,*pucCurrPtr,curr_state);

        switch(new_state)                       /* 状态处理*/
        {
        case AT_E_CMD_NAME_STATE:               /* 扩展命令名状态*/
            if(curr_state != new_state)         /* 新状态部分不等于当前状态*/
            {
                g_stATParseCmd.ucCmdFmtType = AT_EXTEND_CMD_TYPE;           /* 设置命令类型*/
                g_stATParseCmd.ucCmdOptType = AT_CMD_OPT_SET_CMD_NO_PARA;   /* 设置命令操作类型*/

                pucCopyPtr = pucCurrPtr;            /* 准备接收扩展类型命令名*/
            }
            break;

        case AT_E_CMD_SET_STATE:                /* AT扩展命令等号状态 */
            /* 存储命令名到全局变量中 */
            g_stATParseCmd.ucCmdOptType = AT_CMD_OPT_SET_PARA_CMD;  /* 设置命令操作类型*/
            g_stATParseCmd.stCmdName.usCmdNameLen = (VOS_UINT16)(pucCurrPtr - pucCopyPtr);
            if(g_stATParseCmd.stCmdName.usCmdNameLen < sizeof(g_stATParseCmd.stCmdName.aucCmdName))
            {
                atRangeCopy(g_stATParseCmd.stCmdName.aucCmdName,pucCopyPtr,pucCurrPtr);
            }
            else
            {
                return AT_ERROR;                  /* 返回错误 */
            }
            break;

        case AT_E_CMD_PARA_STATE:               /* AT扩展命令参数状态 */
        case AT_E_CMD_LEFT_QUOT_STATE:          /* AT扩展命令左引号状态 */
            if(curr_state != new_state)         /* 新状态部分不等于当前状态*/
            {
                pucCopyPtr = pucCurrPtr;            /* 准备接收参数内容*/
            }
            break;

        case AT_E_CMD_COLON_STATE:              /* AT扩展命令逗号状态 */
            if((curr_state != new_state) && (AT_E_CMD_SET_STATE != curr_state))         /* 新状态部分不等于当前状态*/
            {
                /* 存储参数到全局变量中 */
                if(ERR_MSP_SUCCESS != atfwParseSaveParam(pucCopyPtr, (VOS_UINT16)(pucCurrPtr - pucCopyPtr)))
                {
                    return AT_ERROR;
                }

            }
            else
            {
                /*连续两个逗号,参数不存在*/
                if(ERR_MSP_SUCCESS != atfwParseSaveParam(pucCopyPtr, 0))
                {
                    return AT_ERROR;
                }

            }
            break;

        case AT_E_CMD_READ_STATE:                   /* AT扩展命令查询参数状态 */

            /* 存储命令名到全局变量中 */
            g_stATParseCmd.stCmdName.usCmdNameLen = (VOS_UINT16)(pucCurrPtr - pucCopyPtr);
            if (g_stATParseCmd.stCmdName.usCmdNameLen < sizeof(g_stATParseCmd.stCmdName.aucCmdName))
            {
                atRangeCopy(g_stATParseCmd.stCmdName.aucCmdName,pucCopyPtr,pucCurrPtr);
            }
            else
            {
                return AT_ERROR;                  /* 返回错误 */
            }

            g_stATParseCmd.ucCmdOptType = AT_CMD_OPT_READ_CMD;   /* 设置命令操作类型*/

            break;

        case AT_E_CMD_TEST_STATE:                   /* AT扩展命令测试参数状态 */
            g_stATParseCmd.ucCmdOptType = AT_CMD_OPT_TEST_CMD;   /* 设置命令操作类型*/
            break;

        case AT_BUTT_STATE:                         /* 无效状态 */
            return AT_ERROR;                      /* 返回错误 */

        default:
            break;
        }
        pucCurrPtr++;                                 /* 继续分析下一个字符*/
    }

    switch(new_state)                               /* 根据最后的状态判断*/
    {
    case AT_E_CMD_PARA_STATE:                       /* AT扩展命令参数状态 */
    case AT_E_CMD_RIGHT_QUOT_STATE:                 /* AT扩展命令右引号状态 */

        /* 存储参数到全局变量中 */
        if (ERR_MSP_SUCCESS != atfwParseSaveParam(pucCopyPtr, (VOS_UINT16)(pucCurrPtr - pucCopyPtr)))
        {
            return AT_ERROR;
        }

        break;

    case AT_E_CMD_NAME_STATE:                   /* AT扩展命令查询参数状态 */

        /* 存储命令名到全局变量中 */
        g_stATParseCmd.stCmdName.usCmdNameLen = (VOS_UINT16)(pucCurrPtr - pucCopyPtr);
        if (g_stATParseCmd.stCmdName.usCmdNameLen < sizeof(g_stATParseCmd.stCmdName.aucCmdName))
        {
            atRangeCopy(g_stATParseCmd.stCmdName.aucCmdName,pucCopyPtr,pucCurrPtr);
        }
        else
        {
            return AT_ERROR;                  /* 返回错误 */
        }

        g_stATParseCmd.ucCmdOptType = AT_CMD_OPT_SET_CMD_NO_PARA;   /* 设置命令操作类型*/

        break;

    case AT_E_CMD_COLON_STATE:                      /* AT命令后面跟有无参的逗号 */

        if (ERR_MSP_SUCCESS != atfwParseSaveParam(pucCopyPtr, 0))
        {
            return AT_ERROR;
        }

        break;

    case AT_E_CMD_SET_STATE:                        /* AT扩展命令等号状态 */
    case AT_E_CMD_TEST_STATE:                       /* AT扩展命令查询参数状态 */
    case AT_E_CMD_READ_STATE:                       /* AT扩展命令测试参数状态 */
        break;

    default:
        return AT_ERROR;                          /* 返回错误*/
    }
    return AT_SUCCESS;                              /*  返回正确*/
}
static VOS_UINT32 atParseDCmd( VOS_UINT8 * pData, VOS_UINT16 usLen)
{
    AT_STATE_TYPE_ENUM curr_state = AT_NONE_STATE;  /*  设置初始状态 */
    AT_STATE_TYPE_ENUM new_state = AT_NONE_STATE;   /*  设置初始状态 */
    VOS_UINT8 *pucCurrPtr = pData;                  /*  指向当前正在处理的字符*/
    VOS_UINT8 *pucCopyPtr = pData;                  /*  拷贝内容的起始指针 */
    VOS_UINT16 usLength = 0;                        /*  记录当前已经处理的字符个数*/

    /* 依次分析字符串中的每个字符*/
    while( (usLength++ < usLen) && (g_stATParseCmd.ucParaIndex < AT_MAX_PARA_NUMBER))                     /* 依次比较每个字符 */
    {
        curr_state = new_state;                  /* 当前状态设置为新状态*/

        /* 根据当前处理的字符和当前状态查表得到新状态*/
        new_state = atFindNextMainState(AT_D_CMD_MAIN_STATE_TAB,*pucCurrPtr,curr_state);

        switch(new_state)                        /* 状态处理*/
        {
        case AT_D_CMD_NAME_STATE:                /* AT D命令命令名状态 */
            g_stATParseCmd.ucCmdFmtType = AT_BASIC_CMD_TYPE;     /* 设置命令类型*/
            g_stATParseCmd.ucCmdOptType = AT_CMD_OPT_SET_CMD_NO_PARA;   /* 设置命令操作类型*/
            pucCopyPtr = pucCurrPtr;                 /* 准备接收D类型命令名*/
            break;

        case AT_D_CMD_RIGHT_ARROW_STATE:         /* AT D命令右箭头状态 */
        case AT_D_CMD_DIALSTRING_STATE:          /* AT D命令拨号字符串状态 */
            if(curr_state != new_state)          /* 新状态部分不等于当前状态*/
            {
                g_stATParseCmd.stCmdName.usCmdNameLen = (VOS_UINT16)(pucCurrPtr - pucCopyPtr);
                if(g_stATParseCmd.stCmdName.usCmdNameLen < sizeof(g_stATParseCmd.stCmdName.aucCmdName))
                {
                    atRangeCopy(g_stATParseCmd.stCmdName.aucCmdName,pucCopyPtr,pucCurrPtr);
                }
                else
                {
                    return AT_FAILURE;                  /* 返回错误 */
                }
                pucCopyPtr = pucCurrPtr;             /* 准备接收参数*/
            }
            break;

        case AT_D_CMD_DIGIT_STATE:               /* AT D命令数字状态 */
        case AT_D_CMD_LEFT_QUOT_STATE:           /* AT D命令左引号状态 */
        case AT_D_CMD_CHAR_STATE:
            if(curr_state != new_state)          /* 新状态部分不等于当前状态*/
            {
                /* 存储参数到全局变量中 */
                if(ERR_MSP_SUCCESS != atfwParseSaveParam(pucCopyPtr, (VOS_UINT16)(pucCurrPtr - pucCopyPtr)))
                {
                    return AT_FAILURE;
                }

                pucCopyPtr = pucCurrPtr;                /* 准备接收下一个参数*/
            }
            break;

        case AT_D_CMD_CHAR_I_STATE:              /* AT D命令字符I状态 */
        case AT_D_CMD_CHAR_G_STATE:              /* AT D命令字符G状态 */
        case AT_D_CMD_SEMICOLON_STATE:           /* AT D命令分号状态 */
            /* 存储参数到全局变量中 */
            if(ERR_MSP_SUCCESS != atfwParseSaveParam(pucCopyPtr, (VOS_UINT16)(pucCurrPtr - pucCopyPtr)))
            {
                return AT_FAILURE;
            }

            pucCopyPtr = pucCurrPtr;                /* 准备接收下一个参数*/
            break;

        case AT_BUTT_STATE:                     /* 无效状态 */
            return AT_FAILURE;                  /* 返回错误 */

        default:
            break;
        }
        pucCurrPtr++;                             /* 继续分析下一个字符*/
    }

    switch(new_state)                           /* 根据最后的状态判断*/
    {
    case AT_D_CMD_SEMICOLON_STATE:              /* AT D命令分号状态 */
        break;

    case AT_D_CMD_DIALSTRING_STATE:             /* AT D命令拨号字符串状态 */
    case AT_D_CMD_DIGIT_STATE:                  /* AT D命令数字状态 */
    case AT_D_CMD_RIGHT_QUOT_STATE:             /* AT D命令右引号状态 */
    case AT_D_CMD_CHAR_G_STATE:                 /* AT D命令字符G状态 */
    case AT_D_CMD_CHAR_I_STATE:                 /* AT D命令字符I状态 */
        /* 存储参数到全局变量中 */
        if(ERR_MSP_SUCCESS != atfwParseSaveParam(pucCopyPtr, (VOS_UINT16)(pucCurrPtr - pucCopyPtr)))
        {
            return AT_FAILURE;
        }

        break;

    default:
        return AT_FAILURE;                      /* 返回错误*/
    }
    return AT_SUCCESS;                          /* 返回正确*/
}
VOS_UINT32 atParseBasicCmd(VOS_UINT8 * pData, VOS_UINT16 usLen)
{
    AT_STATE_TYPE_ENUM curr_state = AT_NONE_STATE;  /*  设置初始状态 */
    AT_STATE_TYPE_ENUM new_state = AT_NONE_STATE;   /*  设置初始状态 */
    VOS_UINT8 *pucCurrPtr = pData;                  /*  指向当前正在处理的字符*/
    VOS_UINT8 *pucCopyPtr = pData;                  /*  拷贝内容的起始指针 */
    VOS_UINT16 usLength = 0;                        /*  记录当前已经处理的字符个数*/

    if(AT_FAILURE == atCheckBasicCmdName(*pucCurrPtr))
    {
        return AT_ERROR;
    }

    /* 依次分析字符串中的每个字符*/
    while( (usLength++ < usLen) && (g_stATParseCmd.ucParaIndex < AT_MAX_PARA_NUMBER))                    /* 依次比较每个字符 */
    {
        curr_state = new_state;                 /*  当前状态设置为新状态*/

        /*  根据当前处理的字符和当前状态查表得到新状态*/
        new_state = atFindNextMainState(AT_B_CMD_MAIN_STATE_TAB,*pucCurrPtr,curr_state);

        switch(new_state)                       /*  状态处理*/
        {
        case AT_B_CMD_NAME_STATE:               /*  基本命令名状态*/
            if(curr_state != new_state)         /*  新状态部分不等于当前状态*/
            {
                g_stATParseCmd.ucCmdFmtType = AT_BASIC_CMD_TYPE;            /*  设置命令类型*/
                g_stATParseCmd.ucCmdOptType = AT_CMD_OPT_SET_CMD_NO_PARA;   /*  设置命令操作类型*/
                pucCopyPtr = pucCurrPtr;            /*  准备接收基本类型命令名*/
            }
            break;

        case AT_B_CMD_PARA_STATE:               /* AT基本命令参数状态 */
            if(curr_state != new_state)         /* 新状态部分不等于当前状态*/
            {
                /* 存储命令名到全局变量中 */
                g_stATParseCmd.stCmdName.usCmdNameLen = (VOS_UINT16)(pucCurrPtr - pucCopyPtr);
                if(g_stATParseCmd.stCmdName.usCmdNameLen < sizeof(g_stATParseCmd.stCmdName.aucCmdName))
                {
                    atRangeCopy(g_stATParseCmd.stCmdName.aucCmdName,pucCopyPtr,pucCurrPtr);
                }
                else
                {
                    return AT_FAILURE;                      /* 返回错误 */
                }

                g_stATParseCmd.ucCmdOptType = AT_CMD_OPT_SET_PARA_CMD;  /* 设置命令操作类型*/
                pucCopyPtr = pucCurrPtr;                    /* 准备接收参数*/
            }
            break;

        default:
            return AT_FAILURE;                  /* 返回错误 */
        }
        pucCurrPtr++;                           /*  继续分析下一个字符*/
    }

    switch(new_state)                           /*  根据最后的状态判断*/
    {
    case AT_B_CMD_NAME_STATE:                   /*  基本命令名状态*/

        /* 存储命令名到全局变量中 */
        g_stATParseCmd.stCmdName.usCmdNameLen = (VOS_UINT16)(pucCurrPtr - pucCopyPtr);
        if(g_stATParseCmd.stCmdName.usCmdNameLen < sizeof(g_stATParseCmd.stCmdName.aucCmdName))
        {
            atRangeCopy(g_stATParseCmd.stCmdName.aucCmdName,pucCopyPtr,pucCurrPtr);
        }
        else
        {
            return AT_FAILURE;                  /* 返回错误 */
        }
        break;

    case AT_B_CMD_PARA_STATE:                   /*  基本命令名状态*/
        /* 存储参数到全局变量中 */
        if(ERR_MSP_SUCCESS != atfwParseSaveParam(pucCopyPtr, (VOS_UINT16)(pucCurrPtr - pucCopyPtr)))
        {
            return AT_FAILURE;
        }

        break;

    default:                                    /* 其它错误状态*/
        return AT_FAILURE;                      /* 返回错误 */
    }

    return AT_SUCCESS;                          /*  返回正确*/
}