代码分析工具

最新推荐文章于 2024-04-04 18:22:37 发布
最新推荐文章于 2024-04-04 18:22:37 发布
阅读量1.2k 收藏
点赞数 1
文章标签： 代码分析 工具 token string action matrix
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/selooloo/article/details/6583470
版权
 

#include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <stack>
#include <queue>
#include <cmath>
#include <fstream>

#define LEN 6
#define END ";"
#define COL 28
#define ROW 49
#define ACCEPT  "ac"
using namespace std;

class Token
{
    public:
           typedef double Value;
           typedef string Property;
           string name; 
           Value sync;
           Property property;
          
           Token():sync(0.0){}
           Token(const string &s):name(s),property(s),sync(0.0) {}
           Token(const char* s):name(s),property(s),sync(0.0) {}
           friend bool operator ==(const Token& t1,const Token& t2);
   
};
bool operator ==(const Token& t1,const Token& t2)
{
     return t1.name==t2.name;
}


class LRpda//定义LL语法分析下推自动机
{
   
    typedef vector<Token> Engender;//定义产生式
    typedef int State;
    typedef string Action;
    typedef struct eexpr//定义表达式
            {
                Token uToken;
                Engender engender;
            }eExpr;
    public:
        LRpda();
        LRpda(const char* filename);
       
        bool in_propertys(Token::Property pro,vector<Token::Property> &pVec);
        bool is_unTerminateToken(const Token& token);//判断是否为非终结符
        bool is_TerminateToken(const Token& token);//判断是否为终结符
        bool StringToEngender(const char *exprtmp,Engender &engender);
        bool is_delim(char ch);
        bool is_operator(char ch);
        bool is_letter(char ch);
        bool is_num(const string& str);
        bool is_num(const Token& token) {}
        bool is_id(const string& str);
       
        double get_digit(char *&exprtmp);
        string get_operator(char *&exprtmp);
        void get_propertys(const char* str,vector<Token::Property> &pVec);
        Token::Property get_property(const string& str);
        void combine_token(int index);
       
        void addExpr(const Token& token,const Engender& engender);//添加产生式
        void addExpr(const Token& token,const string& engender);
        void addType(const string type);
       
        string LRpda::der_operate(const Token& t1,const string& d1,const string& op,const Token& t2,const string& d2);
        Action ACTION(const State state,const Token& ttoken);//返回 LL语法分析表中行为uToken,列为tToken中的元素
        Action GOTO(const State state,const Token& utoken);
       
        bool Execute(const char * exprtmp);//执行PDA
        bool Caculate(const string& exprtmp);//执行PDA
        bool Derivative(const string& exprtmp);
       
    private:
        State start;    //开始符号
        Token end;        //结束符号
       
        vector<Token::Property> uTokens;//非终结符号集
        vector<Token::Property> tTokens;//终结符号集
        vector<Token::Property> TYPE;
        vector<Token::Property> Prefix;
        vector<Token::Property> KeyWords;
       
        vector<string> Error;
        vector<eExpr> eExprs;//表达式集合
       
        stack<Token> tStack;
        stack<State> sStack;
        stack<Token::Value> vStack;
     stack<string> dStack;
       
        unsigned int uTokenCount;//非终结符号数量
        unsigned int tTokenCount;//终结符号数量
       
        string matrix[ROW][COL];//LR语法分析表
       
       
};


LRpda::LRpda()
{
                                  //ext  stat const TYPE id  num   * &  =  (   )    [ ]  ,   ;    M E S C T D F A L I I'
    string copymatrix[ROW][COL]={  {"s3","r3","r3","r3","e0","r3","r3","r3","r3","r3","r3","r3","r3","r3","r3","1","2","-1","-1","-1","-1","-1","-1","-1","-1","-1"},   //0
                                   {"e0","e0","e0","e0","e0","e0","e0","e0","e0","e0","e0","e0","e0","e0","ac","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1"},   //1
                                   {"r5","s5","r5","r5","r5","r5","r5","r5","r5","r5","r5","r5","r5","r5","r5","-1","-1","4","-1","-1","-1","-1","-1","-1","-1","-1"},   //2
                                   {"r2","r2","r2","r2","r2","r2","r2","r2","r2","r2","r2","r2","r2","r2","r2","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1"},   //3
                                   {"r7","r7","s7","r7","r7","r7","r7","r7","r7","r7","r7","r7","r7","r7","r7","-1","-1","-1","6","-1","-1","-1","-1","-1","-1","-1"},   //4
                                   {"r4","r4","r4","r4","r4","r4","r4","r4","r4","r4","r4","r4","r4","r4","r4","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1"},   //5
                                   {"e0","e0","e0","s8","e0","e0","e0","e0","e0","e0","e0","e0","e0","e0","e0","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1"},   //6
                                   {"r6","r6","r6","r6","r6","r6","r6","r6","r6","r6","r6","r6","r6","r6","r6","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1"},   //7
                                   {"e0","e0","r7","e0","s12","e0","r7","r7","e0","s13","e0","e0","e0","e0","e0","-1","-1","-1","10","-1","9","-1","-1","-1","11","-1"},   //8
                                   {"r24","r24","r24","r24","e0","r24","r24","r24","r24","s16","r1","r24","r24","s15","r1","-1","-1","-1","-1","-1","-1","14","-1","-1","-1","-1"},   //9
                                   {"e0","e0","e0","e0","e0","e0","s41","s42","e0","e0","e0","e0","e0","e0","e0","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1"},   //10
                                   {"r13","r13","r13","r13","r13","r13","r13","r13","r13","r13","r13","r13","r13","r13","r13","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1"},   //11
                                   {"r22","r22","r22","r22","r22","e0","e0","e0","s26","s32","r22","r22","r22","r22","r22","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1","25"},   //12
                                   {"e0","e0","s7","e0","s12","e0","r7","r7","e0","s13","e0","e0","e0","e0","e0","-1","-1","-1","10","-1","23","-1","-1","-1","11","-1"},   //13
                                   {"r29","r29","r29","r29","r29","r29","r29","r29","r29","r29","r29","s18","r29","r29","r29","-1","-1","-1","-1","-1","-1","-1","17","-1","-1","-1"},   //14
                                   {"r7","r7","r7","r7","s12","r7","r7","r7","r7","s13","r7","r7","r7","r7","r7","-1","-1","-1","10","-1","22","-1","-1","-1","11","-1"},   //15
                                   {"r3","r3","r3","r3","r3","r3","r3","r3","r3","r3","r27","r3","r3","r3","r3","37","2","-1","-1","-1","-1","-1","-1","36","-1","-1"},   //16
                                   {"r11","r11","r11","r11","r11","r11","r11","r11","r11","r11","r11","r11","r11","r11","r11","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1"},   //17
                                   {"e0","e0","e0","e0","s46","s19","e0","e0","e0","e0","e0","e0","e0","e0","e0","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1"},   //18
                                   {"e0","e0","e0","e0","e0","e0","e0","e0","e0","e0","e0","e0","s20","e0","e0","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1"},   //19
                                   {"r29","r29","r29","r29","r29","r29","r29","r29","r29","r29","r29","s18","r29","r29","r29","-1","-1","-1","-1","-1","-1","-1","21","-1","-1","-1"},   //20
                                   {"r28","r28","r28","r28","r28","r28","r28","r28","r28","r28","r28","r28","r28","r28","r28","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1"},   //21
                                   {"r24","r24","r24","r24","r24","r24","r24","r24","r24","s16","r24","r24","r24","s15","r12","-1","-1","-1","-1","-1","-1","14","-1","-1","-1","-1"},   //22
                                   {"r24","r24","r24","r24","e0","r24","r24","r24","r24","s16","s24","r24","r24","e0","e0","-1","-1","-1","-1","-1","-1","14","-1","-1","-1","-1"},   //23
                                   {"r8","r8","r8","r8","r8","r8","r8","r8","r8","r8","r8","r8","r8","r8","e0","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1"},   //24
                                   {"r15","r15","r15","r15","r15","r15","r15","r15","r15","r15","r15","r15","r15","r15","r15","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1"},   //25
                                   {"e0","e0","e0","e0","s45","s31","s27","s29","e0","s32","e0","e0","e0","e0","e0","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1","33"},   //26
                                   {"e0","e0","e0","e0","s28","e0","e0","e0","e0","e0","e0","e0","e0","e0","e0","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1"},   //27
                                   {"r17","r17","r17","r17","r17","r17","r17","r17","r17","r17","r17","r17","r17","r17","r17","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1"},   //28
                                   {"e0","e0","e0","e0","s30","e0","e0","e0","e0","e0","e0","e0","e0","e0","e0","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1"},   //29
                                   {"r18","r18","r18","r18","r18","r18","r18","r18","r18","r18","r18","r18","r18","r18","r18","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1"},   //30
                                   {"r20","r20","r20","r20","r20","r20","r20","r20","r20","r20","r20","r20","r20","r20","r20","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1"},   //31
                                   {"e0","e0","e0","e0","s45","s31","s27","s29","e0","s32","e0","e0","e0","e0","e0","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1","34"},   //32
                                   {"r16","r16","r16","r16","r16","r16","r16","r16","r16","r16","r16","r16","r16","r16","r16","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1"},   //33
                                   {"e0","e0","e0","e0","e0","e0","e0","e0","e0","e0","s35","e0","e0","e0","e0","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1"},   //34
                                   {"r19","r19","r19","r19","r19","r19","r19","r19","r19","r19","r19","r19","r19","r19","r19","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1"},   //35
                                   {"e0","e0","e0","e0","e0","e0","e0","e0","e0","e0","s38","e0","e0","e0","e0","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1"},   //36
                                   {"r25","r25","r25","r25","r25","r25","r25","r25","r25","r25","r25","r25","r25","s39","r25","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1"},   //37
                                   {"r23","r23","r23","r23","r23","r23","r23","r23","r23","r23","r23","r23","r23","r23","r23","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1"},   //38
                                   {"r3","r3","r3","r3","r3","r3","r3","r3","r3","r3","r3","r3","r3","r3","r3","37","2","-1","10","-1","-1","-1","-1","40","11","-1"},   //39
                                   {"r26","r26","r26","r26","r26","r26","r26","r26","r26","r26","r26","r26","r26","r26","r26","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1"},   //40
                                   {"e0","e0","s7","r7","s12","r7","r7","r7","r7","s13","r14","r7","r7","r14","r7","-1","-1","-1","10","-1","43","-1","-1","-1","11","-1"},   //41
                                   {"e0","e0","s7","r7","s12","r7","r7","r7","r7","s13","r14","r7","r7","r14","r7","-1","-1","-1","10","-1","44","-1","-1","-1","11","-1"},   //42
                                   {"r9","r9","r9","r9","r9","r9","r9","r9","r9","r9","r9","r9","r9","r9","r9","-1","-1","-1","-1","-1","14","-1","-1","-1","-1","-1"},   //43
                                   {"r10","r10","r10","r10","r10","r10","r10","r10","r10","r10","r10","r10","r10","r10","r10","-1","-1","-1","-1","-1","14","-1","-1","-1","-1","-1"},   //44
                                   {"r21","r21","r21","r21","r21","r21","r21","r21","r21","r21","r21","r21","r21","r21","r21","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1"},   //45
                                   {"e0","e0","e0","e0","e0","e0","e0","e0","e0","e0","e0","e0","s47","e0","e0","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1"},   //46
                                   {"r29","r29","r29","r29","r29","r29","r29","r29","r29","r29","r29","s18","r29","r29","r29","-1","-1","-1","-1","-1","-1","-1","48","-1","-1","-1"},   //47
                                   {"r30","r30","r30","r30","r30","r30","r30","r30","r30","r30","r30","r30","r30","r30","r30","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1","-1"},   //48
                                   };
    Token tTmp;
    string sTmp;
    int i,j;
   
    for(i=0;i<ROW;++i)
    for(j=0;j<COL;++j)
        matrix[i][j]=copymatrix[i][j];
   
    get_propertys("extern static const type id num * & = ( ) [ ] , ;",tTokens);
    get_propertys("M E S C T D F A L I I'",uTokens);
    get_propertys("int float char void",TYPE);
    get_propertys("extern static const",Prefix);
    get_propertys("return if while class struct default: typedef",KeyWords);
    uTokenCount=uTokens.size();
    tTokenCount=tTokens.size();
   
    start=0;
    end=END;
   
    addExpr("M'","M ;");           //0
    addExpr("M","E S C T D");      //1
    addExpr("E","extern");
    addExpr("E","");
    addExpr("S","static");
    addExpr("S","");
    addExpr("C","const");
    addExpr("C","");
    addExpr("D","( D )");      //2
    addExpr("D","C * D");      //3
    addExpr("D","C & D");
    addExpr("D","D F A");      //4
    addExpr("D","D , D");
    addExpr("D","I");
    addExpr("D","");
    addExpr("I","id I'");
    addExpr("I'","= I'");
    addExpr("I'","* id");
    addExpr("I'","& id");
    addExpr("I'","( I' )");
    addExpr("I'","num");
    addExpr("I'","id");
    addExpr("I'","");
    addExpr("F","( L )");        //5
    addExpr("F","");          //6
    addExpr("L","M");        //7
    addExpr("L","M , L");          //8
    addExpr("L","");           //9
    addExpr("A","[ num ] A");           //9
    addExpr("A","");           //9 
    addExpr("A","[ id ] A");  
   
    Error.push_back("语法错误!");
}


void LRpda::get_propertys(const char* str,vector<Token::Property> &pVec)
{
    stringstream ss(str);
    string sTmp;
   
    while( ss>>sTmp)
        pVec.push_back(sTmp);
}

bool LRpda::in_propertys(Token::Property pro,vector<Token::Property> &pVec)
{
    int i,size=pVec.size();
   
    for(i=0;i<size;++i)
    {
        if(pVec[i]==pro)
        return true;
    }
    return false;
}

Token::Property LRpda::get_property(const string& str)
{
   
    if(in_propertys(str,TYPE))
        return "type";
    else if(str==",")
        return ",";
    else if(in_propertys(str,Prefix))
        return str;
    else if(is_num(str))
        return "num";
    else if(is_id(str))
        return "id";
    else if(str==")")
        return ")";
    else if(str=="(")
        return "(";
    else if(str=="[")
        return "[";
    else if(str=="]")
        return "]";
    else if(str=="*")
        return "*";
    else if(str=="&")
        return "&";
    else if(str=="=")
        return "=";
    else if(str==END)
        return END;
    else
        return "";
            
}   

void LRpda::combine_token(int index)
{
    Token tokens[LEN],token;
    int i,len;
   
    if(index>=eExprs.size())
        return;
    len=eExprs[index].engender.size();
    if(len>tStack.size()||len>=LEN)
        return;
    if(len<1)
    {
        token.name="";
    }
    else
    {          
    for(i=0;i<len;++i)
    {
        tokens[i]=tStack.top();
        tStack.pop();
    }
    for(i=len-1;i>=0;--i)
    {
        token.name=token.name+tokens[i].name;
    }
    }
    tStack.push(token);
}


bool LRpda::is_num(const string& str)
{
    int state=0;
    char ch;
    bool flag=1;
    const char *exprtmp=str.c_str();
   
    while((ch=*exprtmp)!=0 && flag)
    {
        switch(state)
        {
            case 0:
                   if(ch=='+' || ch=='-')
                       state=2;
                   else if(isdigit(ch))
                       state=5;
                   else
                       flag=0;
                   break;
            case 1:
                   if(ch=='+' || ch=='-')
                       state=4;
                   else
                       flag=0;
                   break;
            case 2:
                   if(isdigit(ch))
                       state=5;
                   else
                       flag=0;
                   break;
            case 3:
                   if(isdigit(ch))
                       state=6;
                   else
                       flag=0;
                   break;
            case 4:
                   if(isdigit(ch))
                       state=7;
                   else
                       flag=0;
                   break;
            case 5:
                   if(isdigit(ch))
                       state=5;
                   else if(ch=='.')
                       state=3;
                   else if(ch=='e' || ch=='E')
                       state=1;
                   else
                       flag=0;
                   break;
            case 6:
                   if(isdigit(ch))
                       state=6;
                   else if(ch=='e' || ch=='E')
                       state=1;
                   else
                       flag=0;
                   break;
            case 7:
                   if(isdigit(ch))
                       state=7;
                   else
                       flag=0;
                   break;
            default: break;
        }
        ++exprtmp;
    }
   
    if(flag==1 && (state==5 || state==6 || state==7))
        return true;
    return false;
}

bool LRpda::is_letter(char ch)
{
     if((ch>='a' && ch<='z')||(ch>='A' && ch<='Z')||ch=='_'||ch==':'||ch=='<'||ch=='>'||ch==','||ch==' ')
         return true;
     return false;
}

bool LRpda::is_id(const string &str)
{
    int state=0;
    char ch;
    bool flag=1;
    const char *exprtmp=str.c_str();
   
    while((ch=*exprtmp)!=0 && flag)
    {
        switch(state)
        {
            case 0:
                   if(is_letter(ch))
                       state=1;
                   else
                       flag=0;
                   break;
            case 1:
                   if(is_letter(ch)||isdigit(ch))
                       state=1;
                   else
                       flag=0;
                   break;
       
            default: break;
        }
        ++exprtmp;
    }
   
    if(flag==1 && state==1)
        return true;
    return false;
}
      


double LRpda::get_digit(char *&exprtmp)
{
    int state=0;
    char ch;
    string digit;
    double resault=0.0;
    bool flag=1;
   
    while((ch=*exprtmp)!=0 && flag)
    {
        digit.push_back(ch);
        switch(state)
        {
            case 0:
                   if(is_letter(ch))
                       state=1;
                   else
                       flag=0;
                   break;
            case 1:
                   if(is_letter(ch)||isdigit(ch))
                       state=1;
                   else
                       flag=0;
                   break;
            default: break;
        }
        ++exprtmp;
    }
    if(flag==0)
        --exprtmp;
   
    if(state==1)
        sscanf(digit.c_str(),"%lf",&resault);
    return resault;
}
              
bool LRpda::is_delim(char ch)
{
    return (ch==' '||ch=='\n' ||ch=='\t');
}            
               
   

bool LRpda::StringToEngender(const char *expr,Engender &engender)
{
     string sTmp;
     char ch;
     Token token;
     int flag=1;
     bool type_first=0;
     int bracecounts=0;
     bool brace_first=0;
    
     while(is_delim(*expr))
         ++expr;
     if(*expr=='\0')
         return 0;
     while((ch=*expr)!='\0')
     {
         
          if(ch=='<' )
          {
              brace_first=1;
          }
          if(brace_first==0)
          {
          if(ch==';')
          {
                  token.name=sTmp;
                  token.property=get_property(sTmp);
                  if(type_first==0)
                  {
                  if(token.property=="type")
                      type_first=1;
                  else if(token.property=="id"&&!in_propertys(token.name,KeyWords))
                  {
                      token.property="type";
                      type_first=1;
                  }
                  }
                  if(token.property=="")
                  {
                      return 0;
                  }
                  sTmp.clear();
                  engender.push_back(token);
              sTmp.push_back(ch);
              break;
          }
          else if(ch=='(' || ch==')' ||ch=='[' ||ch==']' ||ch==',' ||ch=='*' ||ch=='&' ||ch=='=' ||ch==';' )
          {
              if(sTmp.size()!=0)
              {
                  token.name=sTmp;
                  token.property=get_property(sTmp);
                  if(type_first==0)
                  {
                  if(token.property=="type")
                      type_first=1;
                  else if(token.property=="id"&&!in_propertys(token.name,KeyWords))
                  {
                      token.property="type";
                      type_first=1;
                  }
                  }
                  if(token.property=="")
                  {
                      return 0;
                  }
                  sTmp.clear();
                  engender.push_back(token);
              }  
              ++expr;
              sTmp.push_back(ch);
              flag=1;
          }
          else if(is_delim(ch))
          {
              if(sTmp.size()!=0)
              {
                  token.name=sTmp;
                  token.property=get_property(sTmp);
                  if(type_first==0)
                  {
                  if(token.property=="type")
                      type_first=1;
                  else if(token.property=="id"&&!in_propertys(token.name,KeyWords))
                  {
                      token.property="type";
                      type_first=1;
                  }
                  }
                  if(token.property=="")
                  {
                      return 0;
                  }
                  sTmp.clear();
                  engender.push_back(token);
              }
              ++expr;   
          }
         
          else if(flag)
          {
              if(sTmp.size()!=0)
              {
                  token.name=sTmp;
                  token.property=get_property(sTmp);
                  if(type_first==0)
                  {
                  if(token.property=="type")
                      type_first=1;
                  else if(token.property=="id"&&!in_propertys(token.name,KeyWords))
                  {
                      token.property="type";
                      type_first=1;
                  }
                  }
                  if(token.property=="")
                  {
                      return 0;
                  }
                  sTmp.clear();
                  engender.push_back(token);
              }
              ++expr;
              sTmp.push_back(ch);
              flag=0;
          }
          else
          {
              sTmp.push_back(ch);
              ++expr;
          }
          }
          else
          {       
          if(ch=='<' )
          {
              ++bracecounts;
          }
          else if(ch=='>')
          {
              --bracecounts;
              if(bracecounts==0)
              {
                  brace_first=0;
              }
          }
          sTmp.push_back(ch);
              ++expr;
          }
     }
     if(sTmp.size()!=0)
     {
                  token.name=sTmp;
                  token.property=get_property(sTmp);
                  if(token.property=="")
                  {
                      return 0;
                  }
                  engender.push_back(token);
     }
     return 1;
}

        
bool LRpda::Execute(const char * exprtmp)
{
    State state;
    Action action,actiontmp;
    Token token,token1,token2,token3,token4,token5,token0;
    Engender expr;
    int index=0,enlen,cur;
    string sTmp;
    int expr_len=0;
    string suffix;
    int para_num=0;
    char sbuf[128]={};
    string var;
    bool cur8=0;
   
    if(StringToEngender(exprtmp,expr)==0)
    {
            return 0;
    }
   
       
    expr_len=expr.size();
    state=start;
    token=expr[index++];
    sStack.push(state);
    while(1)
    {
        action=ACTION(state,token);
        if(state==12)
        {
            if(index<expr_len)
            {
            token1=expr[index];
            if(in_propertys(token1.name,TYPE))
                action="r22";
            }
        }
        else if(state==9)
        {
            if(index<expr_len)
            {
                if(token.name==",")
                {
                token1=expr[index];
                if(in_propertys(token1.name,TYPE)||token1.name=="const")
                    action="r1";
                }
            }
        }
        else if(state==8)
        {
            if(index<expr_len)
            {
                if(token.name=="(")
                {
                token1=expr[index];
                if(in_propertys(token1.name,TYPE)||token1.name=="const")
                    action="r14";
                }
                if(token.name==",")
                {
                token1=expr[index];
                if(in_propertys(token1.name,TYPE)||token1.name=="const")
                    action="r14";
                }
            }
        }
        else if(state==41||state==42)
        {
            if(index<expr_len)
            {
                if(token.name=="(")
                {
                token1=expr[index];
                if(in_propertys(token1.name,TYPE)||token1.name=="const"||token1.name==")")
                    action="r14";
                }
            }
        }
        if(action[0]=='e')
        {
            actiontmp=action.substr(1,action.size());
            state=atoi(actiontmp.c_str());
            return 0;
        }
        else if(action[0]=='s')
        {
            actiontmp=action.substr(1,action.size());
            state=atoi(actiontmp.c_str());
            sStack.push(state);
            tStack.push(token);
           
            if(index >=expr_len)
            {
                return 0;
            }
            token=expr[index++];
           
        }
        else if(action[0]=='r')
        {
            actiontmp=action.substr(1,action.size());
            cur=atoi(actiontmp.c_str());
           
            switch(cur)
            {
                case 8:
                     cur8=1;
                     break;
                case 15:
                     token2=tStack.top();
                     tStack.pop();
                     token1=tStack.top();
                     tStack.pop();
                     break;
                case 23:
                     if(cur8==0)
                         return 0;
                     break;
               
            }
            combine_token(cur);
           
                 
            enlen=eExprs[cur].engender.size();
            while(enlen)
            {
                sStack.pop();
                --enlen;
            }
            state=sStack.top();
            action=GOTO(state,eExprs[cur].uToken);
           
            state=atoi(action.c_str());
            if(state==-1)
            {
                return 0;
            }
            sStack.push(state);
        }
        else if(action==ACCEPT)
        {
            return 1;
        }
        else
        {
            return 0;
        }
    }
}

          
       
void LRpda::addExpr(const Token& token,const string& engender)
{
    stringstream enStream(engender);
    Token tTmp;
    eExpr eTmp;
    string sTmp;
   
    eTmp.uToken=token;
    while(enStream>>sTmp)
    {
        tTmp.name=sTmp;
        tTmp.property=sTmp;
        eTmp.engender.push_back(tTmp);
    }
    eExprs.push_back(eTmp);
} 
void LRpda::addType(const string type)
{
    TYPE.push_back(type);
}

LRpda::Action LRpda::ACTION(const State state,const Token& ttoken)
{
    int j;
   
    for(j=0;j<tTokenCount;++j)
    if(tTokens[j]==ttoken.property)
        break;
    if(j>=tTokenCount)
    {
        return "e0";
    }
    return matrix[state][j];
}

LRpda::Action LRpda::GOTO(const State state,const Token& utoken)
{
    int j;
   
    for(j=0;j<uTokenCount;++j)
    if(uTokens[j]==utoken.property)
        break;
    if(j>=uTokenCount)
    {
        return "e0";
    }
   
    return matrix[state][tTokenCount+j];
}


void treate_code(string& code)
{
    string::iterator it,del_begin,del_end;
    int bracecounts=0;
   
    for(it=code.begin();it!=code.end();)
    {
        if(*it=='{' )
        {
            if(bracecounts==0)
            {
                del_begin=it;
               
            }
            ++bracecounts;
            ++it;
        }
        else if(*it=='}')
        {
            --bracecounts;
            ++it;
            if(bracecounts==0)
            {
                del_end=it;
                it=code.erase(del_begin,del_end);
            }
        }
        else
            ++it;
    }
}

void analyze(const char * filename1,char * filename2)
{
    ifstream fin(filename1);
    ofstream fout(filename2);
    string stmp,code;
    string::iterator it;
    LRpda lrpda;
   
    if(fin.fail())
    {
        cout<<"无法打开文件"<<filename1<<endl;
        return;
    }
    if(fout.fail())
    {
        cout<<"无法打开文件"<<filename2<<endl;
        return;
    }
    while(!fin.eof())
    {
        getline(fin,stmp);
        code+=stmp+"\n";
    }
    for(it=code.begin();it!=code.end();++it)
    {
        if(*it!='\n')
            stmp.push_back(*it);
        else
        {
            if(lrpda.Execute(stmp.c_str()))
            {
                cout<<stmp<<endl;
                fout<<stmp<<endl;
            }
            stmp.clear();
        }
    }  
    fin.close();
    fout.close();
}
void menu(void)
{
    LRpda lrpda;
    string expr;
    char *filename="resault.txt";
    while(1)
    {
        cout<<"请输入代码文件(直接按回车退出)： "<<endl;
        getline(cin,expr);
        if(expr.size()==0)
        {
            cout<<"谢谢使用，再见！"<<endl;
            return;
        }
        cout<<"变量如下:"<<endl;
        analyze(expr.c_str(),filename);
        cout<<"结果保存在"<<filename<<endl;
        expr.clear();
    }
}
int main(void)
{
    menu();
    getchar();
   
    return 0;
}


 

selooloo
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
源码解析工具源码解析工具
11-11
源码解析工具源码解析工具
代码解析工具cpg
qq_44370676的博客
02-10 2579
代码解析工具cpg
静态代码分析工具简介
star的博客
09-25 4739
静态代码分析工具简介 什么是静态代码分析 静态代码分析是指无需运行被测代码，仅通过分析或检查源程序的语法、结构、过程、接口等来检查程序的正确性，找出代码隐藏的错误和缺陷，如参数不匹配，有歧义的嵌套语句，错误的递归，非法计算，可能出现的空指针引用等等。 在软件开发过程中，静态代码分析往往先于动态测试之前进行，同时也可以作为制定动态测试用例的参考。统计证明，在整个软件开发生命周期中，30% 至 70%...
5 款逆向工具，7 款代码分析工具，11 项优化建议
chuyouyinghe的专栏
02-08 3636
本文主要说了三个部分内容，第一部分内容是业务问题和挑战。第二部分内容是包体优化基础知识。第三部分内容是代码优化。代码优化分为四部分内容，第一部分内容是代码优化的思路，第二部分内容是 7 款 apk 黑盒逆向工具，第三部分内容是 7 款代码分析工具，最后一部分内容是代码优化注意事项。近些年来，中大厂门户 app 不断成熟，功能不断堆积和迭代，Android 打包后体积越来越大。安装包体大小不仅对用户留存、市场推广有负面影响，而且如果后续缺乏长效治理监管机制，那么包体大小会出现边治理边污染的现象。
代码分析工具 - SonarQube
Janet的博客
04-13 7959
1. 常见代码质量分析工具 1. DeepSource DeepSource是一种静态分析工具，可以智能化测试代码，帮助弄清楚几个关键方面的问题，比如性能、反模式、缺陷风险、安全漏洞、样式和文档问题。 功能： 可使用配置文件生成器进行简单配置。可对每个合并请求(PR)进行连续分析。误报较少。缺点： 目前只有SaaS Web应用程序这个版本，CLI版仍在开发中。2. embold embold使您可以对软件项目进行静态分析，并提供代码质量报告，其中包括检测到的问题的热图，可帮助您直观地查看导致代码
10个Python代码分析工具，助力高效编程
xiangxue666的博客
11-29 1319
10个Python代码分析工具，助力高效编程
Linux源代码分析工具链
01-09
　在Windows下有sourceinsight这个源码阅读软件（虽然我没用过，但是网上评价还不错），由于我是个Linuxer，并不喜欢用Windows，所以自然是选择在Linux下阅读源码的工具了。 　下面我将逐一介绍在Linux下阅读源码...
代码分析工具 understand 5 Linux 64
11-13
下载地址 https://scitools.com/download/all-builds/ 大家可以自己取下载
常用Java静态代码分析工具的分析与比较
02-21
本文首先介绍了静态代码分析的基本概念及主要技术，随后分别介绍了现有4种主流Java静态代码分析工具(Checkstyle，FindBugs，PMD，Jtest)，最后从功能、特性等方面对它们进行分析和比较，希望能够帮助Java软件开发...
its4静态分析工具
03-13
一个静态扫描工具，主要针对API漏洞进行检测，他的分析技术比较简单，基于词法的
超强代码分析工具 Understand 4.0.793 Win32 Part1
07-31
2015年7月最新 超过了source insight的代码分析工具， 可以直接出程序流程图，而且能直接导出到visio 包括调用关系等 程序猿的必备首选
源代码阅读分析工具
04-13
可直接连接github等代码托管网站的版本库，可在代码上建立批注，分享批注
代码解析工具汇总
qq_44370676的博客
03-09 1万+
代码解析工具汇总
源代码分析工具
SHELLCODE_8BIT的博客
09-27 2779
该工具目前支持 Java、.Net、Go、Python、Ruby、JS（Node、Angular、JQuery 等）、PHP、Perl、COBOL、APEX 等等。Apex、C/C++、C#、CUDA、Java#、JavaScript、PHP、Python、.NET Core、ASP.NET、Objective-C、Go、JSP、Ruby、Swift、Fortran、Scala、VB.NET、iOS、Android , 打字稿, Kotlin。使用图形、文档和指标提供静态代码分析的 IDE。
11个代码质量审核和管理工具，程序员必备！
民工哥的博客
01-10 2043
「读者福利！2 TB 各类技术资源免费赠送」如今，代码质量分析和审核已成为每个企业的基本流程。随着开源代码库使用的增加，安全性和代码质量对于构建高质量软件至关重要。不良的代码不仅会影...
静态代码分析工具列表分析---代码分析工具列表（30款工具）
热门推荐
视频质量测试mazhitong1227的博客
09-07 2万+
本文是一个静态代码分析工具的清单，共有30个工具。包括4个.NET工具、2个Ada工具、7个C++工具、4个Java工具、2个JavaScript工具、1个Opa工具、2个Packaging工具、3个Perl工具、1个Python工具、1个嵌入式工具、2个二进制工具、1个静态分析工具 Fortify SCA        Fortify SCA 是一个静态的、白
Python代码静态分析工具推荐与使用
qq_41314882的博客
12-21 1649
在大型的Python项目中，保持代码的质量和可维护性是至关重要的。为了达到这个目标，使用静态分析工具是一种有效的手段。本文将深入介绍几款常用的Python代码静态分析工具，包括它们的功能特性、优缺点分析以及安装和详细使用示例。
程序代码分析工具
最新发布
qq_46457076的博客
04-04 663
Doxygen + Graphviz 程序代码分析工具快速分析函数间的调用关系。
QT 静态代码分析工具
05-23
QT静态代码分析工具是一种用于分析源代码中潜在问题的工具。这种工具可以通过扫描源代码文件来查找可能存在的错误、漏洞、内存泄漏、未定义的行为等问题。QT静态代码分析工具可以帮助开发人员及时发现和修复代码中的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值