LR分析器c++

本文详细介绍了如何使用C语言实现一个LR分析器,包括ACTION表和GOTO表的定义,状态栈、符号栈的管理,以及输入字符串的处理,通过移进和归约规则进行语法分析。
摘要由CSDN通过智能技术生成

对于文法

(0)E->S

(1)S->BB

(2)B->aB

(3)B->b

构造LR分析器

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

/* ACTION表*/
char *action_table[10][3]={"S3","S4",NULL,
                      NULL,NULL,"acc",
                      "S6","S7",NULL,
                      "S3","S4",NULL,
                      "r3","r3",NULL,
                       NULL,NULL,"r1",
                      "S6","S7",NULL,
                       NULL,NULL,"r3",
                      "r2","r2",NULL,
                       NULL,NULL,"r2"};

/* GOTO表*/
int goto_table[10][2]={1,2,
                  0,0,
                  0,5,
                  0,8,
                  0,0,
                  0,0,
                  0,9,
                  0,0,
                  0,0,
                  0,0};
char vt[3]={'a','b','#'};  /*存放终结符*/
char vn[2]={'S','B'};   /*存放非终结符*/

struct Production{    //产生式类型定义
      char alp;    //大写字符
    char array[10];    //产生式右边字符
    int length;        //字符个数
};
Production production[4]; //存放产生式

int statueStack[10]; //状态栈
char symbolStack[10]; //符号栈
char input_string[10]; //输入串

int statueStackPointer = -1; //状态栈的指针
int symbolStackPointer = -1; //符号栈的指针
int inputStringPointer = 0; //输入串的指针
int input_string_length = 0; //输入串的长度
int proce = 1;

bool input_judge();
void printAll();
void analyse();
void init();

int main(){
    bool input_right = false;
    while(!input_right){
        input_right = input_judge();
    }
    init();
    printf("步骤\t\t状态栈\t\t符号栈\t\t输入串\t\t");
    printf("Action\t\t");
    printf("Goto\n");
    printAll();
    analyse();
}

void printAll(){
    printf("%d\t\t",proce++);

    for(int i=0; i<=statueStackPointer;i++){ //输出状态栈
        printf("%d",statueStack[i]);
    }
    printf("\t\t");

    for(int i=0; i<=symbolStackPointer;i++){ /*输出符号栈*/
        printf("%c",symbolStack[i]);
    }
    printf("\t\t");

    for(int i=inputStringPointer; i<input_string_length;i++){ /*输出输入栈*/

        printf("%c",input_string[i]);
    }
    printf("\t\t");
}

void analyse(){
    int stop =  0;
    while(!stop){
        char store[10];
        char input = input_string[inputStringPointer]; //获取输入串的第一个字符
        int col = -1;
        int row = statueStack[statueStackPointer];

/*查action表*/
        if(input=='a'){
            col=0;
        }
        if(input=='b'){
            col=1;
        }
        if(input=='#'){
            col=2;
        }
        if(action_table[row][col]==NULL){
            printf("err\n");
            exit(0);
        }

        else{
            strcpy(store,action_table[row][col]);
        }

        if(strcmp(store,"acc")==0){
            printf("acc\n");
            stop = 1;
            break;//结束
        }

        /*移进*/
        else if(store[0]=='S'){
            statueStack[++statueStackPointer]=store[1]-'0';
            symbolStack[++symbolStackPointer]=input_string[inputStringPointer];
            inputStringPointer+=1;
            printf("%s\n",store);
            printAll();
        }


        /*归约*/
        else if(store[0]=='r'){
            int col = -1;
            int index=store[1]-'0';
            if(production[index].alp=='S'){
                col=0;
            }
            else if(production[index].alp=='B'){
                col=1;
            }
            else{
                printf("err");
                exit(0);
            }

            int length = production[index].length; //表达式的字符长度
            statueStackPointer-=length; //状态栈出栈
            symbolStackPointer-=length; //符号栈出栈
            int row = statueStack[statueStackPointer]; //获取状态栈在出栈操作后的栈顶状态
            statueStack[++statueStackPointer]=goto_table[row][col]; //goto表中的状态进入状态栈
            symbolStack[++symbolStackPointer]=production[index].alp; //表达式的左边的大写字母进入符号栈
            printf("%s\t\t",store);
            printf("%d\n",goto_table[row][col]);
            printAll();
        }
        else{
            printf("err!\n");
            exit(0);
        }
    }
}

void init(){
    struct Production a1,a2,a3,a4;
    a1.alp = 'E';
    strcpy(a1.array,"S");
    a1.length = 1;

    a2.alp = 'S';
    a2.length = 2;
    strcpy(a3.array,"BB");

    a3.alp = 'B';
    a3.length = 2;
    strcpy(a3.array,"aB");

    a4.alp = 'B';
    a4.length = 1;
    strcpy(a4.array,"b");

    production[0] = a1;
    production[1] = a2;
    production[2] = a3;
    production[3] = a4;

    statueStack[++statueStackPointer] = 0; //0
    symbolStack[++symbolStackPointer] = '#';//#
}

bool input_judge(){
    int j=0;
    char ch;
    printf("Input:");
    while(true){
        ch = getchar();
        if(ch=='\n'){
            break;
        }
        input_string[j++] = ch;
    }

    for(int i=0; i<j; i++){
        ch = input_string[i];
        if(!((ch=='a')||(ch=='b'))){
            printf("输入有误\n");
            return false;
        }
    }

    input_string[j++] = '#';
    input_string_length = j;
    return true;
}
 

  • 31
    点赞
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
LR语法分析器是一种自底向上的语法分析器,可以用于分析上下文无关文法。下面是一个使用C++实现的LR语法分析器的示例: ```cpp #include <iostream> #include <vector> #include <stack> #include <map> using namespace std; // 定义文法符号类型 enum SymbolType { TERMINAL, // 终结符 NONTERMINAL // 非终结符 }; // 定义文法符号结构体 struct Symbol { SymbolType type; // 符号类型 string name; // 符号名称 }; // 定义产生式结构体 struct Production { Symbol left; // 产生式左部 vector<Symbol> right; // 产生式右部 }; // 定义LR分析表项结构体 struct LRTableItem { char action; // 动作类型 int state; // 转移状态 }; // 定义LR语法分析器类 class LRParser { public: LRParser(vector<Production> grammar, Symbol startSymbol, map<Symbol, map<Symbol, int>> actionTable, map<int, map<Symbol, int>> gotoTable, Symbol endSymbol); bool parse(vector<Symbol> input); private: vector<Production> grammar_; // 文法 Symbol startSymbol_; // 起始符号 map<Symbol, map<Symbol, int>> actionTable_; // 动作表 map<int, map<Symbol, int>> gotoTable_; // 转移表 Symbol endSymbol_; // 结束符号 }; // LR语法分析器构造函数 LRParser::LRParser(vector<Production> grammar, Symbol startSymbol, map<Symbol, map<Symbol, int>> actionTable, map<int, map<Symbol, int>> gotoTable, Symbol endSymbol) { grammar_ = grammar; startSymbol_ = startSymbol; actionTable_ = actionTable; gotoTable_ = gotoTable; endSymbol_ = endSymbol; } // LR语法分析器解析函数 bool LRParser::parse(vector<Symbol> input) { stack<int> stateStack; // 状态栈 stack<Symbol> symbolStack; // 符号栈 stateStack.push(0); // 初始状态为0 symbolStack.push(endSymbol_); // 符号栈初始为$(结束符号) int i = 0; while (i < input.size()) { int state = stateStack.top(); Symbol symbol = input[i]; if (actionTable_[state][symbol] > 0) { // 移进 stateStack.push(actionTable_[state][symbol]); symbolStack.push(symbol); i++; } else if (actionTable_[state][symbol] < 0) { // 规约 int productionIndex = -actionTable_[state][symbol]; Production production = grammar_[productionIndex]; for (int j = 0; j < production.right.size(); j++) { stateStack.pop(); symbolStack.pop(); } Symbol nonterminal = production.left; state = stateStack.top(); stateStack.push(gotoTable_[state][nonterminal]); symbolStack.push(nonterminal); } else { // 错误 return false; } } return true; } int main() { // 定义文法符号 Symbol E = {NONTERMINAL, "E"}; Symbol T = {NONTERMINAL, "T"}; Symbol F = {NONTERMINAL, "F"}; Symbol plus = {TERMINAL, "+"}; Symbol minus = {TERMINAL, "-"}; Symbol times = {TERMINAL, "*"}; Symbol divide = {TERMINAL, "/"}; Symbol lparen = {TERMINAL, "("}; Symbol rparen = {TERMINAL, ")"}; Symbol id = {TERMINAL, "id"}; Symbol num = {TERMINAL, "num"}; // 定义产生式 vector<Production> grammar = { {E, {E, plus, T}}, {E, {E, minus, T}}, {E, {T}}, {T, {T, times, F}}, {T, {T, divide, F}}, {T, {F}}, {F, {lparen, E, rparen}}, {F, {id}}, {F, {num}} }; // 定义LR分析表 map<Symbol, map<Symbol, int>> actionTable = { {{0, plus}, {{TERMINAL, 4}}}, {{0, minus}, {{TERMINAL, 5}}}, {{0, id}, {{TERMINAL, 6}}}, {{0, num}, {{TERMINAL, 7}}}, {{1, plus}, {{TERMINAL, 0}, {NONTERMINAL, 2}}}, {{1, minus}, {{TERMINAL, 0}, {NONTERMINAL, 2}}}, {{1, rparen}, {{TERMINAL, 0}, {NONTERMINAL, 2}}}, {{1, endSymbol}, {{TERMINAL, 0}, {NONTERMINAL, 2}}}, {{2, plus}, {{TERMINAL, -1}}}, {{2, minus}, {{TERMINAL, -1}}}, {{2, times}, {{TERMINAL, 8}, {NONTERMINAL, 3}}}, {{2, divide}, {{TERMINAL, 9}, {NONTERMINAL, 3}}}, {{2, rparen}, {{TERMINAL, -1}}}, {{2, endSymbol}, {{TERMINAL, -1}}}, {{3, plus}, {{TERMINAL, -3}}}, {{3, minus}, {{TERMINAL, -3}}}, {{3, times}, {{TERMINAL, -3}}}, {{3, divide}, {{TERMINAL, -3}}}, {{3, rparen}, {{TERMINAL, -3}}}, {{3, endSymbol}, {{TERMINAL, -3}}}, {{4, id}, {{TERMINAL, 6}}}, {{4, num}, {{TERMINAL, 7}}}, {{5, id}, {{TERMINAL, 6}}}, {{5, num}, {{TERMINAL, 7}}}, {{6, plus}, {{TERMINAL, -6}}}, {{6, minus}, {{TERMINAL, -6}}}, {{6, times}, {{TERMINAL, -6}}}, {{6, divide}, {{TERMINAL, -6}}}, {{6, rparen}, {{TERMINAL, -6}}}, {{6, endSymbol}, {{TERMINAL, -6}}}, {{7, plus}, {{TERMINAL, -7}}}, {{7, minus}, {{TERMINAL, -7}}}, {{7, times}, {{TERMINAL, -7}}}, {{7, divide}, {{TERMINAL, -7}}}, {{7, rparen}, {{TERMINAL, -7}}}, {{7, endSymbol}, {{TERMINAL, -7}}} }; map<int, map<Symbol, int>> gotoTable = { {0, {{E, 1}, {T, 2}, {F, 3}}}, {2, {{T, 5}, {F, 3}}}, {3, {{F, 6}}}, {8, {{F, 9}}}, {9, {{F, 10}}} }; // 定义LR语法分析器 LRParser parser(grammar, E, actionTable, gotoTable, endSymbol_); // 进行语法分析 vector<Symbol> input = {id, plus, id, times, id, endSymbol_}; bool result = parser.parse(input); if (result) { cout << "Input is valid." << endl; } else { cout << "Input is invalid." << endl; } return 0; } ```

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值