对字符串提取以及运算操作处理

     enum.h文件，枚举类型文件

#ifndef ENUM_H
#define ENUM_H

#include <QDataStream>
#include <QtCore/qmath.h>

enum REG_INS_TYPE {REG_INS,POS_REG_INS,POS_REG_AXIS_INS,AR_PAL_REG_INS,STR_REG};
enum VALUE_TYPE
{
    REG_AR,REG_CONST,REG_R,REG_PR,REG_GI,
    REG_GO,REG_AI,REG_AO,REG_DI,REG_DO,REG_RI,
    REG_RO,REG_SI,REG_SO,REG_UI,REG_UO,REG_TIMER,
    REG_TIMER_OVERFLOW,REG_P,REG_Lpos,REG_Jpos,
    REG_UFRAM,REG_UTOOL,REG_PL,REG_ADD,REG_DEC,
    REG_MUL,REG_DIVIVIDE,REG_MOD,REG_DIV,
    REG_LEFT_BRK,REG_RIGHT_BRK,REG_PL_CONST,REG_PR_IJ
};

enum ADDRESSING_TYPE {DIRECT,INDIRECT};

#endif // ENUM_H

字符串的解析

parseStack.h

#ifndef PARSESTACK_H
#define PARSESTACK_H

//#include "datavector.h"
#include <QVector>
#include <QStack>
#include <QDebug>

#include "register.h"

class ParseStack
{
public:
    ParseStack();
    
    QVector<RegConditionBlock> listData;

//    QVector<DataVector> listData;
    
    void initData();
    double parseData();
    void calc();

    void startReg(Register reg);
    void parsePlData();
    
    QList <int> rList;
    QList <int> prList;
    QList <int> plList;
    QList <int> srList;

    QVector <int> DI;

    QVector <int> arList;
    QVector <int> utooList;

    QVector <QVector <int> > prIjList;

    QVector <QVector<int> > realPList;

    QVector <int> cVector;
    
    QStack <int> chStack;
    QStack <double> numStack;

//    QStack <QVector <int> > numStack;
    
};

#endif // PARSESTACK_H

parseStack.cpp

#include "parsestack.h"

ParseStack::ParseStack()
{
    for(int i = 0; i < 5;i++)
    {
        rList.append(i);
        prList.append(i+2);
        plList.append(i+3);
        srList.append(i+4);
        DI.append(i+5);
        arList.append(i);
        utooList.append(i+1);
    }

    realPList.resize(5);
    prIjList.resize(5);
    for(int i = 0; i < 5;i++)
    {
        realPList[i].resize(3);
        prIjList[i].resize(3);
    }

    for(int i = 0; i < 5;i++)
    {
        for(int j = 0; j < 3;j++)
        {
            realPList[i][j] = (i + j);
            prIjList[i][j] = (i + j);
        }
    }

    cVector.resize(3);
}

//void ParseStack::initData()
//{
////    DataVector dataVec;
////    dataVec.regType = REG_R;
////    dataVec.i = 0;
////    listData.append(dataVec);
    
////    dataVec.regType = REG_DIV;
////    listData.append(dataVec);
    
////    dataVec.regType = REG_LEFT_BRK;
////    listData.append(dataVec);
    
////    dataVec.regType = REG_LEFT_BRK;
////    listData.append(dataVec);
    
////    dataVec.regType = REG_R;
////    dataVec.i = 1;
////    listData.append(dataVec);

////    dataVec.regType = REG_ADD;
////    listData.append(dataVec);
    
////    dataVec.regType = REG_PR;
////    dataVec.i = 1;
////    listData.append(dataVec);
    
////    dataVec.regType = REG_DIV;
////    listData.append(dataVec);
    
////    dataVec.regType = REG_PL;
////    dataVec.i = 1;
////    listData.append(dataVec);
    
////    dataVec.regType = REG_RIGHT_BRK;
////    listData.append(dataVec);
    
////    dataVec.regType = REG_MUL;
////    listData.append(dataVec);
    
////    dataVec.regType = REG_LEFT_BRK;
////    listData.append(dataVec);
    
////    dataVec.regType = REG_SR;
////    dataVec.i = 1;
////    listData.append(dataVec);
    
////    dataVec.regType = REG_DEC;
////    listData.append(dataVec);
    
////    dataVec.regType = REG_R;
////    dataVec.i = 2;
////    listData.append(dataVec);
    
////    dataVec.regType = REG_RIGHT_BRK;
////    listData.append(dataVec);
    
////    dataVec.regType = REG_DEC;
////    listData.append(dataVec);
    
////    dataVec.regType = REG_SR;
////    dataVec.i = 2;
////    listData.append(dataVec);
    
////    dataVec.regType = REG_RIGHT_BRK;
////    listData.append(dataVec);
    
////    dataVec.regType = REG_MOD;
////    listData.append(dataVec);
    
////    dataVec.regType = REG_CONST;
////    dataVec.i = 4;
////    listData.append(dataVec);
    
////    dataVec.regType = REG_ADD;
////    listData.append(dataVec);
    
////    dataVec.regType = REG_PR;
////    dataVec.i = 2;
////    listData.append(dataVec);
//    DataVector dataVec;

//    dataVec.regType = REG_LEFT_BRK;
//    listData.append(dataVec);

//    dataVec.regType = REG_R;
//    dataVec.i = 3;
//    listData.append(dataVec);

//    dataVec.regType = REG_ADD;
//    listData.append(dataVec);

//    dataVec.regType = REG_AR;
//    dataVec.i = 2;
//    listData.append(dataVec);

//    dataVec.regType = REG_RIGHT_BRK;
//    listData.append(dataVec);

//    dataVec.regType = REG_MUL;
//    listData.append(dataVec);

//    dataVec.regType = REG_PR;
//    dataVec.i = 3;
//    listData.append(dataVec);

//    dataVec.regType = REG_DIV;
//    listData.append(dataVec);

//    dataVec.regType = REG_LEFT_BRK;
//    listData.append(dataVec);

//    dataVec.regType = REG_R;
//    dataVec.i = 1;
//    listData.append(dataVec);

//    dataVec.regType = REG_ADD;
//    listData.append(dataVec);

//    dataVec.regType = REG_PR;
//    dataVec.i = 1;
//    listData.append(dataVec);

//    dataVec.regType = REG_RIGHT_BRK;
//    listData.append(dataVec);

//    dataVec.regType = REG_DEC;
//    listData.append(dataVec);

//    dataVec.regType = REG_CONST;
//    dataVec.i = 10;
//    listData.append(dataVec);

//    dataVec.regType = REG_DIV;
//    listData.append(dataVec);

//    dataVec.regType = REG_LEFT_BRK;
//    listData.append(dataVec);

//    dataVec.regType = REG_PR;
//    dataVec.i = 0;
//    listData.append(dataVec);

//    dataVec.regType = REG_MUL;
//    listData.append(dataVec);

//    dataVec.regType = REG_LEFT_BRK;
//    listData.append(dataVec);

//    dataVec.regType = REG_PL;
//    dataVec.i = 3;
//    listData.append(dataVec);

//    dataVec.regType = REG_DIV;
//    listData.append(dataVec);

//    dataVec.regType = REG_PR;
//    dataVec.i = 0;
//    listData.append(dataVec);

//    dataVec.regType = REG_DEC;
//    listData.append(dataVec);

//    dataVec.regType = REG_R;
//    dataVec.i = 0;
//    listData.append(dataVec);

//    dataVec.regType = REG_RIGHT_BRK;
//    listData.append(dataVec);

//    dataVec.regType = REG_MOD;
//    listData.append(dataVec);

//    dataVec.regType = REG_R;
//    dataVec.i = 2;
//    listData.append(dataVec);

//    dataVec.regType = REG_ADD;
//    listData.append(dataVec);

//    dataVec.regType = REG_PR;
//    dataVec.i = 1;
//    listData.append(dataVec);

//    dataVec.regType = REG_RIGHT_BRK;
//    listData.append(dataVec);

//}

double ParseStack::parseData()
{
    qDebug()<<__FUNCTION__<<"******"<<__LINE__<<"****listDataSize****"<<listData.size()<<
              "***ch**"<<chStack.size()<<endl;
    while(listData.size() > 0)
    {
        //获取当前表达式头部的第一个字符
        int dataType = listData.at(0).valueType;
        double num = 0;
        bool existNum = false;

        qDebug() << "**dataType***"<<dataType<<endl;
        if(dataType == REG_CONST ||
                dataType == REG_PR ||
                dataType == REG_PR_IJ ||
                dataType == REG_R ||
                dataType == REG_AR ||
                dataType ==  REG_GI ||
                dataType ==  REG_GO ||
                dataType ==  REG_AI ||
                dataType ==  REG_AO ||
                dataType ==  REG_DI ||
                dataType ==  REG_DO ||
                dataType ==  REG_RI ||
                dataType ==  REG_RO ||
                dataType ==  REG_SI ||
                dataType ==  REG_SO ||
                dataType ==  REG_UI ||
                dataType ==  REG_UO ||
                dataType ==  REG_TIMER ||
                dataType ==  REG_TIMER_OVERFLOW ||
                dataType ==  REG_P ||
                dataType ==  REG_Lpos ||
                dataType ==  REG_Jpos ||
                dataType ==  REG_UFRAM ||
                dataType ==  REG_UTOOL )
        {
            existNum = true;
            if(existNum)
            {
                if(dataType == REG_CONST)
                {
                    num = listData.at(0).val;
                    qDebug() <<__LINE__ <<"***num**"<<num<<endl;
                }
                else if(dataType == REG_PR)
                {
                    if(INDIRECT == listData[0].rightVarType)
                    {
                        num = prList[rList[listData[0].i]];
                    }
                    else if(DIRECT == listData[0].rightVarType)
                    {
                        num = prList.at(listData.at(0).i);
                    }
                    qDebug() <<__LINE__ <<"***num**"<<num<<endl;
                }
                else if(dataType == REG_PR_IJ)
                {
                    num = prIjList[listData[0].i][listData[0].j];
                    qDebug() << __FUNCTION__ <<"*****"<<__LINE__<<"**I**"<<listData[0].i<<
                                "**j***"<<listData[0].j<<"****num**"<<num<<endl;
                }
                else if(dataType == REG_R)
                {
                    if(INDIRECT == listData[0].rightVarType)
                    {
                        num = rList[rList[listData[0].i]];
                    }
                    else if(DIRECT == listData[0].rightVarType)
                    {
                        num = rList.at(listData.at(0).i);
                    }
                    qDebug() <<__LINE__ <<"***num**"<<num<<endl;
                }
                else if(dataType == REG_AR)
                {
                    if(INDIRECT == listData[0].rightVarType)
                    {
                        num = arList[rList[listData[0].i]];
                    }
                    else if(DIRECT == listData[0].rightVarType)
                    {
                        num = arList.at(listData.at(0).i);
                    }
                    qDebug() <<__LINE__ <<"***num**"<<num<<endl;
                }
                else if(dataType ==  REG_GI)
                {

                }
                else if(dataType ==  REG_GO)
                {

                }
                else if(dataType ==  REG_AI)
                {

                }
                else if(dataType ==  REG_AO)
                {

                }
                else if(dataType ==  REG_DI)
                {
                    if(INDIRECT == listData[0].rightVarType)
                    {
                        num = DI[rList[listData[0].i]];
                    }
                    else if(DIRECT == listData[0].rightVarType)
                    {
                        num = DI[listData.at(0).i];
                    }
                    qDebug() <<__LINE__ <<"***num**"<<num<<endl;
                }
                else if(dataType ==  REG_DO)
                {

                }
                else if(dataType ==  REG_RI)
                {

                }
                else if(dataType ==  REG_RO)
                {

                }
                else if(dataType ==  REG_SI)
                {

                }
                else if(dataType ==  REG_SO)
                {

                }
                else if(dataType ==  REG_UI)
                {

                }
                else if(dataType ==  REG_UO)
                {

                }
                else if(dataType ==  REG_TIMER)
                {

                }
                else if(dataType ==  REG_TIMER_OVERFLOW)
                {

                }
                else if(dataType ==  REG_P)
                {

                }
                else if(dataType ==  REG_Lpos)
                {

                }
                else if(dataType ==  REG_Jpos)
                {

                }
                else if(dataType ==  REG_UFRAM)
                {

                }
                else if(dataType ==  REG_UTOOL)
                {
                    if(INDIRECT == listData[0].rightVarType)
                    {
                        num = utooList[rList[listData[0].i]];
                    }
                    else if(DIRECT == listData[0].rightVarType)
                    {
                        num = utooList.at(listData.at(0).i);
                    }
                    qDebug() <<__LINE__ <<"***num**"<<num<<endl;
                }
                listData.removeFirst();
                numStack.push(num);
                if(listData.size() == 0)
                {
                    break;
                }
            }
        }
        else if(dataType == REG_ADD ||
                dataType == REG_DEC ||
                dataType == REG_DIV ||
                dataType == REG_LEFT_BRK ||
                dataType == REG_MOD ||
                dataType == REG_MUL ||
                dataType == REG_DIVIVIDE ||
                dataType == REG_RIGHT_BRK)
        {
            listData.removeFirst();
            if(chStack.isEmpty() ||
//               chStack.top() == REG_LEFT_BRK ||
                    dataType == REG_LEFT_BRK)
            {
                chStack.push(dataType);
                //listData.removeFirst();
                continue;
            }
            switch (dataType)
            {
                case REG_RIGHT_BRK:
                {
                    while((numStack.size() >= 2) &&
                          !chStack.isEmpty()&&
                          (chStack.top() != REG_LEFT_BRK))
                    {
                        qDebug() << __LINE__<<"***numStack****"<<numStack.size()<<endl;
                        calc();
                    }
                    if(!chStack.isEmpty() &&
                        (chStack.top() == REG_LEFT_BRK))
                    {
                        qDebug() <<"***right****"<<chStack.size()<<"%%%%chStack%%%"<<endl;
                        chStack.pop();
                        continue;
                    }
                    else
                    {
                        qDebug()<<"The number of barckets are not equals!!"<<endl;
                    }
                    break;
                }
                case REG_DIV:
                case REG_MOD:
                case REG_MUL:
                case REG_DIVIVIDE:
                {
                    /**若符号栈栈顶元素为+、-、( 或者符号栈为空，
                     * 则意味着符号栈栈顶符号比ch优先级底，
                     * 所以，将ch压栈。否则，将符号栈栈顶元素弹出来，
                     * 然后开始计算。*/
                    while ((numStack.size() >= 2) &&
                           !(chStack.isEmpty() ||
                             (chStack.top() == REG_LEFT_BRK) ||
                             (chStack.top() == REG_ADD) ||
                             (chStack.top() == REG_DEC)))
                    {
                        qDebug() << __LINE__<<"***numStack****"<<numStack.size()<<endl;
                        calc();
                    }
                    /**若符号栈顶元素优先级比ch的低*/
                    if((chStack.isEmpty()) ||
                       (chStack.top() == REG_LEFT_BRK) ||
                            (chStack.top() == REG_ADD)||
                            (chStack.top() == REG_DEC))
                    {
                        chStack.push(dataType);
                        //listData.removeFirst();
                        continue;
                    }

                }
                case REG_ADD:
                case REG_DEC:
                {
                    while((numStack.size() >= 2) &&
                          !chStack.isEmpty() &&
                           (chStack.top() != REG_LEFT_BRK))
                    {
                        qDebug() << __LINE__<<"***numStack****"<<numStack.size()<<endl;
                        calc();
                    }
                    qDebug() << "***chStack**"<<chStack.size()<<endl;
                    if(chStack.isEmpty() || (chStack.top() == REG_LEFT_BRK))
                    {
                        chStack.push(dataType);
                        //listData.removeFirst();
                        continue;
                    }
                    else
                    {
                        qDebug()<<"this string is not illeagal"<<endl;
                    }
                }
                default:
                {
                    qDebug()<<"argument error!!!"<<endl;
                }
            }
             //listData.removeFirst();
             if(listData.size() == 0)
             {
                 break;
             }
        }
    }//while结束

     // 若符号栈不为空，则不断的从符号栈和数字栈中弹出元素，进行计算
    while(!chStack.isEmpty())
    {
        qDebug() << __LINE__<<"***numStack****"<<numStack.size()<<endl;
        calc();
    }
    qDebug() << "***numStackSize***"<<numStack.size()<<endl;
    return (numStack.size() == 1)?numStack.pop():0;
}

void ParseStack::calc()
{

    qDebug() << "**num#######stack###size####"<<numStack.size()<<endl;

    double b = numStack.pop();
    double a = numStack.pop();

    int operatorType = chStack.pop();

    qDebug() <<__FUNCTION__<< "******"<<__LINE__<<"***a**"<<a<<
               "***b**"<<b<<"**oper**"<<operatorType<<endl;

    double result = 0;

    switch (operatorType)
    {
        case REG_ADD:
        {
            result = a + b;
            break;
        }
        case REG_DEC:
        {
            result = a -b;
            break;
        }
        case REG_MUL:
        {
            result = a * b;
            break;
        }
        case REG_DIV:
        {
            if( b == 0)
            {
                qDebug() << "divisor can not be zero!!!"<<endl;
            }
            else
            {
                result = int(a / b);
            }
            break;
        }
        case REG_DIVIVIDE:
        {
            if( b == 0)
            {
                qDebug() << "divisor can not be zero!!!"<<endl;
            }
            else
            {
                result = a / b;
            }
            break;
        }
        case REG_MOD:
        {
            if( b == 0)
            {
                qDebug() << "divisor can not be zero!!!"<<endl;
            }
            else
            {
                result = (int)a%(int)b;
            }
            break;
        }
    }

    qDebug() << "***result#**"<<result<<endl;
    numStack.push(result);
}

//void ParseStack::calc()
//{
//    QVector <int> aVector;
//    QVector <int> bVector;


//    aVector.resize(3);
//    bVector.resize(3);


//    bVector = numStack.pop();
//    aVector = numStack.pop();

//    qDebug() << "**a**"<<aVector<<"***b***"<<bVector<<endl;

//    int operatorType = chStack.pop();



//    switch (operatorType)
//    {
//        case REG_ADD:
//        {
//            for(int i = 0; i < 3;i++)
//            {
//                cVector[i] = aVector[i] + bVector[i];
//            }
//            break;
//        }
//        case REG_DEC:
//        {
//            for(int i = 0; i < 3;i++)
//            {
//                cVector[i] = aVector[i] - bVector[i];
//            }
//            break;
//        }
//    }
//    numStack.push(cVector);
//}


void ParseStack::startReg(Register reg)
{
    for(int i = 0; i < reg.regcondition.size();++i)
    {
        listData.append(reg.regcondition[i]);
    }
    qDebug() << __FUNCTION__<<"******"<<__LINE__<< "***reg**Type**"<<reg.type<<endl;
    switch(reg.type)
    {
        case AR_PAL_REG_INS:
        {
            switch (reg.addressType)
            {
                case INDIRECT:
                {
                    qDebug() << "****INDIRECT***"<<endl;
//                    parsePlData();
                    break;
                }
                case DIRECT:
                {
                    qDebug() << "****DIRECT***"<<endl;
//                    parsePlData();
                    break;
                }
            }
            break;
        }
        case REG_INS:
        {
            switch(reg.addressType)
            {
                case INDIRECT:
                {
                    qDebug() << "****INDIRECT***"<<endl;
                    double result = parseData();
                    qDebug() << __FUNCTION__ <<"******"<<__LINE__<<"***RESULT**"<<result<<endl;
                    break;
                }
                case DIRECT:
                {
                    qDebug() << "****DIRECT***"<<endl;
                    double result = parseData();
                    qDebug() << __FUNCTION__ <<"******"<<__LINE__<<"***RESULT**"<<result<<endl;
                    break;
                }
            }
            break;
        }
    }
}
/*
void ParseStack::parsePlData()
{
    QVector <int> plTempList;
    plTempList.resize(3);
    while(listData.size() > 0)
    {
        //获取当前表达式头部的第一个字符
        int dataType = listData.at(0).valueType;
        double num = 0;
        bool existNum = false;

        if(dataType == REG_PL_CONST ||
                dataType == REG_PL)
        {
            existNum = true;
            if(existNum)
            {
                if(dataType == REG_PL_CONST)
                {
                    if(INDIRECT == listData[0].pl_iVarType)
                    {
                        plTempList[0] = rList[listData[0].i];
                    }
                    else if(DIRECT == listData[0].pl_iVarType)
                    {
                        plTempList[0] = listData[0].i;
                    }
                    if(INDIRECT == listData[0].pl_jVarType)
                    {
                        plTempList[1] = rList[listData[0].j];
                    }
                    else if(DIRECT == listData[0].pl_jVarType)
                    {
                        plTempList[1] = listData[0].j;
                    }
                    if(INDIRECT == listData[0].pl_kVarType)
                    {
                        plTempList[2] = rList[listData[0].k];
                    }
                    else if(DIRECT == listData[0].pl_kVarType)
                    {
                        plTempList[2] = listData[0].k;
                    }
                }
                else if(dataType == REG_PL)
                {
                    if(INDIRECT == listData.at(0).rightVarType)
                    {
                        qDebug()<<"***r[i]***"<<listData[0].plVal<<endl;
                        plTempList = realPList[rList[listData[0].plVal]];
                        qDebug() << "***plTempList***"<<plTempList<<endl;
                    }
                    else if(DIRECT == listData.at(0).rightVarType)
                    {
                       plTempList = realPList[listData[0].plVal];
                    }
                }

                listData.removeFirst();
//                numStack.push(num);

                numStack.push(plTempList);
                if(listData.size() == 0)
                {
                    break;
                }
            }
        }
        else if(dataType == REG_ADD ||
                dataType == REG_DEC ||
                dataType == REG_LEFT_BRK ||
                dataType == REG_RIGHT_BRK)
        {
            listData.removeFirst();
            if(chStack.isEmpty() ||
               chStack.top() == REG_LEFT_BRK ||
                    dataType == REG_LEFT_BRK)
            {
                chStack.push(dataType);
                //listData.removeFirst();
                continue;
            }
            switch (dataType)
            {
                case REG_RIGHT_BRK:
                {
                    while(numStack.size() >= 2 &&
                          !chStack.isEmpty()&&
                          chStack.top() != REG_LEFT_BRK)
                    {
                        calc();
                    }
                    if(!chStack.isEmpty() &&
                        chStack.top() == REG_LEFT_BRK)
                    {
                        chStack.pop();
                        continue;
                    }
                    else
                    {
                        qDebug()<<"The number of barckets are not equals!!"<<endl;
                    }
                    break;
                }
                case REG_ADD:
                case REG_DEC:
                {
                    while(numStack.size() >= 2 &&
                          !chStack.isEmpty() &&
                           chStack.top() != REG_LEFT_BRK)
                    {
                        calc();
                    }
                    if(chStack.isEmpty() || chStack.top() == REG_LEFT_BRK)
                    {
                        chStack.push(dataType);
                        //listData.removeFirst();
                        continue;
                    }
                    else
                    {
                        qDebug()<<"this string is not illeagal"<<endl;
                    }
                }
                default:
                {
                    qDebug()<<"argument error!!!"<<endl;
                }
            }
             //listData.removeFirst();
             if(listData.size() == 0)
             {
                 break;
             }
        }
    }//while结束

     // 若符号栈不为空，则不断的从符号栈和数字栈中弹出元素，进行计算
    while(!chStack.isEmpty())
    {
        calc();
    }

    qDebug() <<"***result***"<<cVector<<endl;

//    return numStack.size() == 1?numStack.pop():0;
}
*/

解析函数

#include "register.h"




Register::Register()
{
}

int Register::strToInt(QString in)
{
    QString tmp;
    for(int j = 0; j < in.length(); j++)
    {
        if(in[j] >= '0' && in[j] <= '9')
            tmp.append(in[j]);
    }
    bool ok;
    int tar=tmp.toInt(&ok,10); // ok=rue
    return tar;
}

double Register::strToDouble (QString in)
{
    QString tmp;
    for(int j = 0; j < in.length(); j++)
    {
        if((in[j] >= '0' && in[j] <= '9')||in[j]=='.')
            tmp.append(in[j]);
    }
    bool ok;
    double tar=tmp.toDouble(&ok); // ok=rue
    return tar;
}

QString Register::strFilt(QString in)
{
    QString tmp;
    for(int j = 0; j < in.length(); j++)
    {
        if((in[j] >= 'a' && in[j] <= 'z') || (in[j] >= 'A' && in[j] <= 'Z')||in[j]=='['||in[j]==']'||in[j] =='%'||in[j] == '/')
            tmp.append(in[j]);
    }
    return tmp;
}


int Register::patRegister(QString programStr)
{
    //  qDebug()<<"patRegister*****************









*****************



******************"<<endl;
    int ownerStart = programStr.indexOf("//");
    programStr = programStr.left(ownerStart);
//    this[0].type = REG;
    QString pattern1 = ("([PSRL]{1,2})\[([R]?\[?\d+\]?)\s*,?\s*(\d*)\s*:?\s*(\w*)\]\s*=(.*)");
    QRegExp rx1(pattern1);
    programStr.indexOf(rx1);

    qDebug() << "***cap**1**"<<rx1.cap(1)<<endl;
    /*********存储等号左边的内容**********/
    if(rx1.cap(1) == "R")
    {
        this[0].type = REG_INS;
    }
    else if(rx1.cap(1) == "PR")
    {
        if(rx1.cap(3) == "")
        {
            this[0].type = POS_REG_INS;
        }
        else
        {
            this[0].type = POS_REG_AXIS_INS;
        }
    }
    else if(rx1.cap(1) == "PL")
    {
        this[0].type = AR_PAL_REG_INS;
    }
    else if(rx1.cap(1) == "SR")
    {
        this[0].type = STR_REG;
    }

    qDebug() << "***cap**2**"<<rx1.cap(2)<<endl;
    qDebug() << "***cap**3**"<<rx1.cap(3)<<endl;
    qDebug() << "***cap**4**"<<rx1.cap(4)<<endl;

    int ri = strToInt(rx1.cap(2));
    int rj = strToInt(rx1.cap(3));
    this[0].i = ri;
    this[0].j = rj;
    this[0].expression = rx1.cap(4);
    if(strFilt(rx1.cap(2)) == "R[]")
    {
        this[0].addressType = INDIRECT;
    }
    else
    {
        this[0].addressType = DIRECT;
    }
    /*********存储等号后边的内容***********/
    /****先取出等号后边的内容,再放在QMap中****/
    QMap<int, QString> map;
    QString strpro = rx1.cap(5);
    strpro.replace(QString(" "),QString(""));//  去掉空格
    QString  strchar ;
    QStringList  strList;
    int xi = 0;
    int p1;
    int p2;
//    qDebug() << __FUNCTION__<<"****"<<__LINE__<<"***strpro**"<<strpro<<endl;
    /*************获取TIMER[] , UFRAM[], UTOOL[]*********/
    strchar  = "TIMER;UFRAM;UTOOL";
    strList = strchar.split(";");
    xi = 0;
    while(xi < strList.length())
    {
        p1 = strpro.indexOf(strList[xi]);
//        qDebug() << __FUNCTION__<<"**1111111**"<<__LINE__<<"***p1**"<<p1<<endl;
        if(p1 != -1)
        {
            p2 = p1;
            while(1)
            {
//                qDebug() << __FUNCTION__<<"****"<<__LINE__<<"***mid***p2**1**"<<strpro.mid(p2,1)<<endl;
                if(strpro.mid(p2,1) == "]")
                break;
                p2++;
            }
            QString strget = strpro.mid(p1,p2-p1+1);
//            qDebug() << __FUNCTION__<<"****"<<__LINE__<<"***p1**"<<p1<<"**p2***"<<p2<<"**strget**"<<strget<<endl;
            map.insert(p1,strget);      //插入到QMAP中
            strpro.replace(p1,5,"@@@@@");
            int R = strget.indexOf("R");
            if(R != -1)
            {
                strpro.replace(p1+R,1,"@");
//                qDebug() << __FUNCTION__<<"***@@***"<<__LINE__<<"***strpro**"<<strpro<<endl;
            }
            qDebug() << __FUNCTION__<<"***@@***"<<__LINE__<<"***strpro**"<<strpro<<endl;
        }
        else if(p1 == -1)
        {
            xi++;
        }
    }
//     qDebug() << __FUNCTION__<<"****"<<__LINE__<<"***map**"<<map.size()<<endl;
    /************获取 DIV MOD******************/
    strchar  = "MOD;DIV";
    strList = strchar.split(";");
    xi = 0;
    while(xi < strList.length())
    {
        p1 = strpro.indexOf(strList[xi]);
//        qDebug() << __FUNCTION__<<"**22222222**"<<__LINE__<<"***p1**"<<p1<<endl;
        if(p1 != -1)
        {
            QString strget = strpro.mid(p1,3);
//            qDebug() << __FUNCTION__<<"****"<<__LINE__<<"***p1**"<<p1<<"**strget**"<<strget<<endl;
            map.insert(p1,strget);      //插入到QMAP中
            strpro.replace(p1,3,"###");
            qDebug() << __FUNCTION__<<"***##***"<<__LINE__<<"***strpro**"<<strpro<<endl;
        }
        else if(p1 == -1)
        {
            xi++;
        }
    }
    /*******PR GI GO AI AO DI DO RI RO SI SO UI UO SR AR PL R[ P[,要放在获取完TIMER[] 和DIV之后*********/
    strchar  = "PR:GI:GO:AI:AO:DI:DO:RI:RO:SI:SO:UI:UO:SR:AR:PL:R[:P[";
    strList = strchar.split(":");
    xi = 0;
    while(xi < strList.length())
    {
        p1 = strpro.indexOf(strList[xi]);
//        qDebug() << __FUNCTION__<<"**3333333**"<<__LINE__<<"***p1**"<<p1<<endl;
        if(p1 != -1)
        {
            p2 = p1;
            while(1)
            {
//                qDebug() << __FUNCTION__<<"****"<<__LINE__<<"***mid***p2**1**"<<strpro.mid(p2,1)<<endl;
                if(strpro.mid(p2,1) == "]")
                break;
                p2++;
            }
            QString strget = strpro.mid(p1,p2-p1+1);
//            qDebug() << __FUNCTION__<<"****"<<__LINE__<<"***p1**"<<p1<<"**p2***"<<p2<<"**strget**"<<strget<<endl;
            map.insert(p1,strget);      //插入到QMAP中
            strpro.replace(p1,2,"@@");
//            qDebug() << __FUNCTION__<<"***@@***"<<__LINE__<<"***strpro**"<<strpro<<endl;
            strget.replace(0,2,"@@");   //因为PR[R[]]里面有两个R；
            qDebug() << __FUNCTION__<<"****"<<__LINE__<<"***p1**"<<p1<<"**p2***"<<p2<<"**strget**"<<strget<<endl;
            int R = strget.indexOf("R");     //判断字符串里面是否有R[]，如果有应该替换掉，避免误认为是外面的R[];
            if(R != -1)
            {
                strpro.replace(p1+R,1,"@");
//                qDebug() << __FUNCTION__<<"***@@***"<<__LINE__<<"***strpro**"<<strpro<<endl;
            }
        }
        else if(p1 == -1)
        {
            xi++;
        }
    }
    /*********************获取“+-* / ( )****************/
    strchar = "+ - * / ( )";
    strList = strchar.split(" ");
    xi  = 0;
    int op = 0;
    while(xi < strList.length() )
    {
        op = strpro.indexOf(strList[xi]);
//        qDebug() << __FUNCTION__<<"**4444444**"<<__LINE__<<"***op**"<<op<<endl;
        if(op != -1)
        {
            QString oper = strpro.mid(op,1);
//            qDebug() << __FUNCTION__<<"******"<<__LINE__<<"***strpro**"<<strpro<<"***oper****"<<oper<<endl;
            map.insert( op,oper);     //插入到QMAP
            strpro.replace(op,1,"#");
            qDebug() << __FUNCTION__<<"******"<<__LINE__<<"***strpro**"<<strpro<<endl;
        }
        else if(op == -1)
        {
            xi++;
        }
    }
    /***********获取 Lpos Jpos ,要 放在获取完＋－＊／（）之后**************/
    strchar  = "Lpos;Jpos";
    strList = strchar.split(";");
    xi = 0;
    while(xi < strList.length())
    {
        p1 = strpro.indexOf(strList[xi]);
//        qDebug() << __FUNCTION__<<"**555555**"<<__LINE__<<"***p1**"<<p1<<endl;
        if(p1 != -1)
        {
            QString strget = strpro.mid(p1,4);
//            qDebug() << __FUNCTION__<<"******"<<__LINE__<<"***strpro**"<<strpro<<"***strget****"<<strget<<endl;
            map.insert(p1,strget);      //插入到QMAP中
            strpro.replace(p1,4,"@@@@");
            qDebug() << __FUNCTION__<<"******"<<__LINE__<<"***strpro**"<<strpro<<endl;
        }
        else if(p1 == -1)
        {
            xi++;
        }
    }
    QMap <int,int> plMap;
    plMap.clear();

    QVector <int> leftList;
    QVector <int> rightList;
    leftList.clear();
    rightList.clear();

    int plCount = 0;
    int pcCount = 0;
    /*********获取【i，j，k】**********/
    for(int i = 0; i < strpro.length();i++)
    {
        if('[' == strpro[i])
        {
            leftList.append(i);
        }
        else if(']' == strpro[i])
        {
            rightList.append(i);
        }
    }
    /***************获取相匹配的括号的位置*****************/
    for(int i = leftList[pcCount]; i < strpro.length();i++)
    {
        if('[' == strpro[i])
        {
            plCount++;
        }
        else if(']' == strpro[i])
        {
            plCount--;
        }

        if(0 == plCount)
        {
           plMap.insert(leftList[pcCount],i);
           if(pcCount < leftList.size() - 1)
           {
               i = leftList[++pcCount] - 1;
           }
        }
    }

    qDebug() << __LINE__<<"***STRPRO***"<<strpro<<endl;
    QString tempStr;
    int front_i,back_i;
    for(int i = 0; i < plMap.size();i++)
    {
        front_i = plMap.keys().at(i);
        back_i = plMap.values().at(i);
        tempStr = strpro.mid(front_i,back_i - front_i + 1);
        qDebug() << __LINE__<<"****i**"<<i<<"**front_i***"<<front_i<<"***back_i***"<<back_i<<"***tempStr**"<<tempStr<<endl;
        int count = tempStr.count(",");
        if(2 == count)
        {
//            qDebug() << "****i**"<<i<<"**front_i***"<<front_i<<"***back_i***"<<back_i<<"***tempStr**"<<tempStr<<endl;
            QString strget = tempStr;
            map.insert(front_i,strget);
            QString str;
            str.fill('@',back_i - front_i + 1);
            strpro.replace(front_i,back_i - front_i + 1,str);
        }
    }

    /**************获取常数项***************/
    while(1)
    {
        p1 = strpro.indexOf("#");
        qDebug() << __FUNCTION__<<"**66666**"<<__LINE__<<"***p1**"<<p1<<endl;
        if(p1 == -1)
        {
            break;
        }
        qDebug() << __FUNCTION__<<"**66666**"<<__LINE__<<"***p1+1**"<<strpro.mid(p1+1,1)<<endl;
        if(strpro.mid(p1+1,1)>="0" && strpro.mid(p1+1,1)<="9")
        {
            p2 = p1;
            while(1)
            {
                p2++;
                qDebug() << __FUNCTION__<<"**66666**"<<__LINE__<<"***p2**"<<strpro.mid(p2,1)<<endl;
                if(strpro.mid(p2,1) == "#" || strpro.mid(p2,1) == "")
                {
                    break;
                }
            }
            QString strget = strpro.mid(p1+1,p2-p1-1);
            qDebug() << __FUNCTION__<<"******"<<__LINE__<<"***strpro**"<<strpro<<"***strget****"<<strget<<endl;
            map.insert(p1+1,strget);      //插入到QMAP中
        }
        strpro.replace(p1,1,"$");
        qDebug() << __FUNCTION__<<"******"<<__LINE__<<"***strpro**"<<strpro<<endl;
    }
    //第一个字符串为常数项的情况
    if(!strpro.contains("$"))//全是数字，没有字母
    {
        QString strget = strpro;
        map.insert(0,strget);
    }
    else
    {
        if(strpro.mid(0,1) >= "0" && strpro.mid(0,1)<="9")
        {
            p1 = 0;
            while(1)
            {
                p1++;
                if(strpro.mid(p1,1) == "$")
                {
                    break;
                }
            }
            QString strget = strpro.mid(0,p1);
            qDebug() << __FUNCTION__<<"******"<<__LINE__<<"***strpro**"<<strpro<<"***strget****"<<strget<<endl;
            map.insert(0,strget);      //插入到QMAP中
        }
    }
    for(int i = 0; i < map.size();i++)
    {
        qDebug() << "***i=***"<<i<<
                    "***key***"<<map.keys().at(i)<<
                    "***value***"<<map.values().at(i)<<endl;
    }

    /********************将获得的每个字符串按顺序存储**********************/
    int pi ;
    int pj ;
    int sum = 0;
    float val;
    QString strfile;
    QString plStr;
    QMap<int, QString>::const_iterator mi;
    for( mi=map.constBegin(); mi!=map.constEnd(); ++mi)
    {
        sum++;
        this[0].regcondition.resize(sum);
        if(this[0].type == AR_PAL_REG_INS)
        {
            qDebug() << __FUNCTION__<<"******"<<__LINE__<<endl;
            strList = mi.value().split("[");
            if("PL" == strList[0])
            {
               qDebug() << __FUNCTION__<<"******"<<__LINE__<<endl;
               this[0].regcondition[sum - 1].valueType = REG_PL;
               if(strList.size()>1)
               {
                    if(strList[1] == "R")
                    {
                         qDebug() << __FUNCTION__<<"******"<<__LINE__<<endl;
                        this[0].regcondition[sum-1].rightVarType = INDIRECT;
                        qDebug() << "**strList[1]***"<<strList[2]<<endl;
                        this[0].regcondition[sum - 1].plVal = strToInt(strList[2]);
                    }
                    else
                    {
                        qDebug() << __FUNCTION__<<"******"<<__LINE__<<endl;
                        this[0].regcondition[sum-1].rightVarType = DIRECT;
                        this[0].regcondition[sum-1].plVal = strToInt(strList[1]);
                    }
               }

            }
            else if("+" == strList[0])
            {
                qDebug() << __FUNCTION__<<"******"<<__LINE__<<endl;
               this[0].regcondition[sum-1].valueType = REG_ADD;
            }
            else if("-" == strList[0])
            {
                qDebug() << __FUNCTION__<<"******"<<__LINE__<<endl;
               this[0].regcondition[sum-1].valueType = REG_DEC;
            }
            else if(strList[0] == "(")
            {
                qDebug() << __FUNCTION__<<"******"<<__LINE__<<endl;
                this[0].regcondition[sum-1].valueType = REG_LEFT_BRK;
            }
            else if(strList[0] == ")")
            {
                qDebug() << __FUNCTION__<<"******"<<__LINE__<<endl;
                this[0].regcondition[sum-1].valueType = REG_RIGHT_BRK;
            }
            else
            {
                qDebug() << __FUNCTION__<<"******"<<__LINE__<<endl;
                this[0].regcondition[sum - 1].valueType = REG_PL_CONST;
                plStr = mi.value();
                if(2 == plStr.count(","))
                {
                    plStr = plStr.remove(" ");
                    plStr = plStr.remove("[");
                    plStr = plStr.remove("]");
                    qDebug() << __FUNCTION__<<"******"<<__LINE__<<endl;
                    strList = plStr.split(",");
                    for(int j = 0; j < strList.size();j++)
                    {
                        if("*" == strList[j])
                        {
                            strList[j] = "-100000";
                        }
                        else if("2-0" == strList[j])
                        {
                            strList[j] = "20000";
                        }
                        else if("2-1" == strList[j])
                        {
                            strList[j] = "-20000";
                        }
                         qDebug() << __FUNCTION__<<"******"<<__LINE__<<endl;
                        QString str_i,str_j,str_k;

                        str_i = strList[0];
                        str_j = strList[1];
                        str_k = strList[2];
                         qDebug() << __FUNCTION__<<"******"<<__LINE__<<endl;
                        if(str_i.contains("R"))
                        {
                           this[0].regcondition[sum - 1].pl_iVarType = INDIRECT;
                           this[0].regcondition[sum - 1].i = strToInt(str_i);
                        }
                        else
                        {
                            this[0].regcondition[sum - 1].pl_iVarType = DIRECT;
                            this[0].regcondition[sum - 1].i = strToInt(str_i);
                        }
                        if(str_j.contains("R"))
                        {
                            this[0].regcondition[sum - 1].pl_jVarType = INDIRECT;
                            this[0].regcondition[sum - 1].j = strToInt(str_j);
                        }
                        else
                        {
                            this[0].regcondition[sum - 1].pl_jVarType = DIRECT;
                            this[0].regcondition[sum - 1].j = strToInt(str_j);
                        }
                        if(str_k.contains("R"))
                        {
                            this[0].regcondition[sum - 1].pl_kVarType = INDIRECT;
                            this[0].regcondition[sum - 1].k = strToInt(str_k);
                        }
                        else
                        {
                            this[0].regcondition[sum - 1].pl_kVarType = DIRECT;
                            this[0].regcondition[sum - 1].k = strToInt(str_k);
                        }
                    }
                }
            }
        }
        else
        {
            strList = mi.value().split("[") ;                          //如 ：R[R[2]] -> R   R 2]];
            qDebug() << __LINE__ <<"****strList*******"<<strList[0]<<endl;
            if(strList[0] == "AR")
            {
                this[0].regcondition[sum-1].valueType = REG_AR;
            }
            else if(strList[0] == "R")
            {
                this[0].regcondition[sum-1].valueType = REG_R;
            }
            else if(strList[0] == "P")
            {
                this[0].regcondition[sum-1].valueType = REG_P;
            }
            else if(strList[0] == "PR")
            {
                this[0].regcondition[sum-1].valueType = REG_PR;
            }
            else if(strList[0] == "GI")
            {
                this[0].regcondition[sum-1].valueType = REG_GI;
            }
            else if(strList[0] == "GO")
            {
                this[0].regcondition[sum-1].valueType = REG_GO;
            }
            else if(strList[0] == "AI")
            {
                this[0].regcondition[sum-1].valueType = REG_AI;
            }
            else if(strList[0] == "AO")
            {
                this[0].regcondition[sum-1].valueType = REG_AO;
            }
            else if(strList[0] == "DI")
            {
                this[0].regcondition[sum-1].valueType = REG_DI;
            }
            else if(strList[0] == "DO")
            {
                this[0].regcondition[sum-1].valueType = REG_DO;
            }
            else if(strList[0] == "RI")
            {
                this[0].regcondition[sum-1].valueType = REG_RI;
            }
            else if(strList[0] == "RO")
            {
                this[0].regcondition[sum-1].valueType = REG_RO;
            }
            else if(strList[0] == "SI")
            {
                this[0].regcondition[sum-1].valueType = REG_SI;
            }
            else if(strList[0] == "SO")
            {
                this[0].regcondition[sum-1].valueType = REG_SO;
            }
            else if(strList[0] == "UI")
            {
                this[0].regcondition[sum-1].valueType = REG_UI;
            }
            else if(strList[0] == "UO")
            {
                this[0].regcondition[sum-1].valueType = REG_UO;
            }
            else if(strList[0] == "TIMER")
            {
                this[0].regcondition[sum-1].valueType = REG_TIMER;
            }
            else if(strList[0] == "TIMER_OVERFLOW")
            {
                this[0].regcondition[sum-1].valueType = REG_TIMER_OVERFLOW;
            }
            else if(strList[0] == "Lpos")
            {
                this[0].regcondition[sum-1].valueType = REG_Lpos;
            }
            else if(strList[0] == "Jpos")
            {
                this[0].regcondition[sum-1].valueType = REG_Jpos;
            }
            else if(strList[0] == "UFRAM")
            {
                this[0].regcondition[sum-1].valueType = REG_UFRAM;
            }
            else if(strList[0] == "UTOOL")
            {
                this[0].regcondition[sum-1].valueType = REG_UTOOL;
            }
//            else if(strList[0] == "PL")
//            {
//                this[0].regcondition[sum-1].valueType = REG_PL;
//            }
            else if(strList[0] == "MOD")
            {
                this[0].regcondition[sum-1].valueType = REG_MOD;
            }
            else if(strList[0] == "DIV")
            {
                this[0].regcondition[sum-1].valueType = REG_DIV;
            }
            else if(strList[0] == "+")
            {
                this[0].regcondition[sum-1].valueType = REG_ADD;
            }
            else if(strList[0] == "-")
            {
                this[0].regcondition[sum-1].valueType = REG_DEC;
            }
            else if(strList[0] == "*")
            {
                this[0].regcondition[sum-1].valueType = REG_MUL;
            }
            else if(strList[0] == "/")
            {
                this[0].regcondition[sum-1].valueType = REG_DIVIVIDE;
            }
            else if(strList[0] == "(")
            {
                this[0].regcondition[sum-1].valueType = REG_LEFT_BRK;
            }
            else if(strList[0] == ")")
            {
                this[0].regcondition[sum-1].valueType = REG_RIGHT_BRK;
            }
            else
            {
                this[0].regcondition[sum-1].valueType = REG_CONST;
                val = strToDouble(strList[0]);
                this[0].regcondition[sum-1].val = val;
            }
            /*************判断地址类型************/
            if(strList.size()>1)
            {
                if(strList[1] == "R")
                {
                    this[0].regcondition[sum-1].rightVarType = INDIRECT;
                }
                else
                {
                    this[0].regcondition[sum-1].rightVarType = DIRECT;
                }
            }
            /***************存储 i,j***************/
            if( this[0].regcondition[sum-1].valueType != REG_CONST)
            {
                strList = mi.value().split(",") ;           //如 R[2,4] ->R[2  ;     4];
                pi = strToInt(strList[0]);
                this[0].regcondition[sum-1].i = pi;
                if(strList.size() > 1)
                {
                    this[0].regcondition[sum-1].valueType = REG_PR_IJ;
                    pj = strToInt(strList[1]);
                    this[0].regcondition[sum-1].j = pj;
                }
            }
        }
    }
    return 1;
}

以上为对字符串的提取解析以及运算操作