编译原理(七) 算符优先分析法(构造算符优先关系表算法及C++实现)

最新推荐文章于 2021-07-14 22:45:22 发布
最新推荐文章于 2021-07-14 22:45:22 发布
阅读量2k 收藏 6
点赞数
分类专栏： 编译原理 文章标签： 编译原理

概念简述

移动归约分析法：自底向上的语法分析方法，也称为移动归约分析法。

短语：文法G[S]，αβδ是文法G的一个句型，S=>*αAδ且A=>+β则称β是句型αβδ相对于非终结符A的短语。 
直接短语：若有A  ⇒+ β则称β是句型αβδ相对于该规则A→β的直接短语。 
句柄：一个句型的最左直接短语称为该句型的句柄。 
其实作为一个常年和树打交道的acmer来说，我觉得下面这种定义方法更容易理解…. 
短语：一棵子树的所有叶子自左至右排列起来形成一个相对于子树根的短语。 
直接短语：仅有父子两代的一棵子树，它的所有叶子自左至右排列起来所形成的符号串。 
句柄：一个句型的分析树中最左那棵只有父子两代的子树的所有叶子的自左至右排列。 
算符文法的定义：

算符优先文法的特点：

算法优先关系构造算法

一、首先对于优先关系进行如下定义：

二、定义并构造FIRSTVT和LASTVT两个集合

FIRSTVT(P)={a|P⇒+a⋯或P⇒+Qa⋯}

LASTVT(P)={a|P⇒+⋯a或P⇒+⋯aQ}

FIRSTVT(P)直接根据定义递归的构造即可：

LASTVT(P)直接根据定义递归的构造即可：

代码实现见代码部分的make_first和make_last函数，是两个简单的递归实现。

三、利用FIRSTVT和LASTVT集合构造算法优先关系表

FOR 每个产生式 P->X1 X2 ……Xn   
DO  FOR  i:=1  TO   n-1    DO      
      IF  X[i]和X[i+1]均为终结符
        THEN   置 X[i]=X[i+1]        
      IF  X[i]和X[i+2]均为终结符,X[i+1]为非终结符,i≤n-2,       
        THEN   置 X[i]=X[i+2]                
      IF  X[i]为终结符, 但X[i+1]为非终结符                                    
      THEN  FOR  FIRSTVT(X[i+1])中的每个a                                    
          DO  置 X[i]<a                
      IF  Xi为非终结符, 但X i+1 为终结符                                  
          THEN  FOR  LASTVT(X i )中的每个a
              DO   置 a>X[i+1]

C++代码实现

#include <iostream>
#include <cstring>
#include <cstdio>
#include <vector>
#include <stack>
#include <map>
#include <set>
#include <algorithm>
#include <string>
#include <cstdlib>
#include <cctype>
#define MAX 507

using namespace std;

class WF
{
    public:
    string left;
    vector<string> right;
    WF ( const string& str )
    {
        left = str;
    }
    void insert ( char str[] )
    {
        right.push_back(str);
    }
    void print ( )
    {
        printf ( "%s->%s" , left.c_str() , right[0].c_str() );
        for ( int i = 1 ; i < right.size() ; i++ )
            printf ( "|%s" , right[i].c_str() );
        puts("");
    }
};

char relation[MAX][MAX];
vector<char> VT;
vector<WF> VN_set;
map<string,int> VN_dic;
set<char> first[MAX];
set<char> last[MAX];
int used[MAX];
int vis[MAX];


void dfs (  int x )
{
    if ( vis[x] ) return;
    vis[x] = 1;
    string& left = VN_set[x].left;
    for ( int i = 0 ; i < VN_set[x].right.size() ; i++ )
    {
        string& str = VN_set[x].right[i];
        if ( isupper(str[0]) )
        {
            int y = VN_dic[str.substr(0,1)]-1;
            if ( str.length() > 1 && !isupper(str[1] ) )
                first[x].insert ( str[1] );
            dfs ( y );
            set<char>::iterator it = first[y].begin();
            for ( ; it!= first[y].end() ; it++ )
                first[x].insert ( *it );
        }
        else 
            first[x].insert ( str[0] );
    }
}

void make_first ( )
{
    memset ( vis , 0 , sizeof ( vis ) );
    for ( int i = 0 ; i < VN_set.size() ; i++ )
        if ( vis[i] ) continue;
        else dfs ( i );
#define DEBUG
#ifdef DEBUG
    puts("------------FIRSTVT集-------------------");
    for ( int i = 0 ; i < VN_set.size() ; i++ )
    {
        printf ( "%s : " , VN_set[i].left.c_str() );
        set<char>::iterator it = first[i].begin();
        for ( ; it!= first[i].end() ; it++ )
            printf ( "%c " , *it );
        puts ("" );
    }
#endif 
}

void dfs1 ( int x )
{
    if ( vis[x] ) return;
    vis[x] = 1;
    string& left = VN_set[x].left;
    for ( int i = 0 ; i < VN_set[x].right.size() ; i++ )
    {
        string& str = VN_set[x].right[i];
        int n = str.length() -1;
        if ( isupper(str[n] ) )
        {
            int y = VN_dic[str.substr(n,1)]-1;
            if ( str.length() > 1 && !isupper(str[n-1]) )
                last[x].insert ( str[1] );
            dfs1 ( y );
            set<char>::iterator it = last[y].begin();
            for ( ; it != last[y].end() ; it++ )
                last[x].insert ( *it );
        }
        else 
            last[x].insert ( str[n] );
    }
}


void make_last ( )
{
    memset ( vis , 0 , sizeof ( vis ) );
    for ( int i = 0 ; i < VN_set.size() ; i++ )
        if ( vis[i] ) continue;
        else dfs1 ( i );
#define DEBUG
#ifdef DEBUG
    puts("--------------LASTVT集---------------------");
    for ( int i = 0 ; i < VN_set.size() ; i++ )
    {
        printf ( "%s : " , VN_set[i].left.c_str() );
        set<char>::iterator it = last[i].begin();
        for ( ; it!= last[i].end() ; it++ )
            printf ( "%c " , *it );
        puts ("" );
    }
#endif
}

void make_table ( )
{
    for ( int i = 0 ; i < MAX ; i++ )
        for ( int j = 0 ; j < MAX ; j++ )
            relation[i][j] = ' ';
    for ( int i = 0 ; i < VN_set.size() ; i++ )
        for ( int j = 0 ; j < VN_set[i].right.size() ; j++ )
        {
            string& str = VN_set[i].right[j];
            for ( int k = 0 ; k < str.length()-1 ; k++ )
            {
                if ( !isupper(str[k]) && !isupper(str[k+1]) )
                    relation[str[k]][str[k+1]] = '=';
                if ( !isupper(str[k]) && isupper(str[k+1]) )
                {
                    int x = VN_dic[str.substr(k+1,1)]-1;
                    set<char>::iterator it = first[x].begin();
                    for ( ; it != first[x].end() ; it++ )
                        relation[str[k]][*it] = '<';
                }
                if ( isupper(str[k]) && !isupper(str[k+1]) )
                {
                    int x = VN_dic[str.substr(k,1)]-1;
                    set<char>::iterator it = last[x].begin();
                    for ( ; it != last[x].end() ; it++ )
                        relation[*it][str[k+1]] = '>';
                }
                if ( k > str.length()-2 ) continue;
                if ( !isupper(str[k]) && !isupper(str[k+2]) && isupper(str[k+1]) )
                    relation[str[k]][str[k+2]] = '=';
            }
        }
#define DEBUG
#ifdef DEBUG
    for ( int i = 0 ; i < VT.size()*5 ; i++ )
        printf ("-");
    printf ( "算符优先关系表" );
    for ( int i = 0 ; i < VT.size()*5 ; i++ )
        printf ( "-" );
    puts("");
    printf ( "|%8s|" , "" );
    for ( int i = 0 ; i < VT.size() ; i++ )
        printf ( "%5c%5s" , VT[i] , "|" );
    puts ("");
    for ( int i = 0 ; i < (VT.size()+1)*10 ; i++ )
        printf ("-");
    puts("");
    for ( int i = 0 ; i < VT.size() ; i++ )
    {
        printf ( "|%4c%5s" , VT[i] , "|");
        for ( int j = 0 ; j < VT.size() ; j++ )
            printf ( "%5c%5s" , relation[VT[i]][VT[j]] , "|" );
        puts ("");
        for ( int i = 0 ; i < (VT.size()+1)*10 ; i++ )
            printf ("-");
        puts("");
    }
#endif
}


int main ( )
{
    int n;
    char s[MAX];
    while ( ~scanf ( "%d" , &n ) )
    {
        memset ( used , 0 , sizeof ( used ) );
        for ( int i = 0 ; i < n ; i++ )
        {
            scanf ( "%s" , s );
            int len = strlen(s),j;
            for ( j = 0 ; j < len ; j++ )
                if ( s[j] == '-' ) 
                    break;
            s[j] = 0;
            if ( !VN_dic[s] )
            {
                VN_set.push_back ( WF(s) );
                VN_dic[s] = VN_set.size();
            }
            int x = VN_dic[s]-1;
            VN_set[x].insert ( s+j+2 );
            for ( int k = 0 ; k < j; k++ )
                if ( !isupper(s[k] ) )
                {
                    if ( used[s[k]] ) continue;
                    used[s[k]] = 1;
                    VT.push_back ( s[k] );
                }
            for ( int k = j+2 ; k < len; k++ )
                if ( !isupper(s[k] ) )
                {
                    if ( used[s[k]] ) continue;
                    VT.push_back ( s[k] );
                    used[s[k]] = VT.size();
                }   
        }
#define DEBUG
#ifdef DEBUG
        puts ("************VT集*******************");
        for ( int i = 0 ; i < VT.size() ; i++ )
            printf ( "%c " , VT[i] );
        puts ("");
        puts("*************产生式*****************");
        for ( int i = 0 ; i < VN_set.size() ; i++ )
            VN_set[i].print();
        puts("************************************");
#endif
        make_first();
        make_last();
        make_table();
    }
}

Input: 
这里写图片描述 
Output: 
这里写图片描述

yolosliu
关注
专栏目录
编译原理 —— 算符优先分析法
starter_____的博客
05-17 2万+
什么是算符优先分析法 算符优先分析法是一种简单、直观的自下而上分析法 算符优先分析法就是仿照算术表达式的四则运算过程而设计的一种语法分析方法。 这种分析方法首先要规定运算符之间（确切地说终结符之间）的优先关系和结合性质，然后借助这种关系，比较相邻运算符的优先级来确定句型的可归约串并进行归约。 算符优先文法的定义 一、算符文法的定义 在算符文法中，任何一个规则右部都不存在两个非终...
编译原理：算符优先分析法
jianbai_的博客
05-28 8945
编译原理：算符优先分析文法
编译原理算符优先表
07-12
编译原理算符优先表，有firstvt 和lastvt的求解！MFC实现的！
算符优先分析算法
Acapplella的博客
05-24 160
算符优先分析算法的本质就是在不断寻找最左素短语的过程。
算符优先分析算法（c语言）
12-12
完成一个交互式面向对象的算符优先分析程序，而一个交互式面向对象的算符优先分析程序基本功能是： （1） 输入文法规则 （2） 对文法进行转换 （3） 生成每个非终结符的FirstVT和LastVT （4） 生成算符优先分析表 （5） 再输入文法符号 （6） 生成移进规约步骤
语法分析（算符优先）
12-11
（1）根据给定文法，先求出FirstVt和LastVt集合，构造算符优先关系表（要求算符优先关系表 输出到屏幕或者输出到文件）； （2）根据算法和优先关系表分析给定表达式是否是该文法识别的正确的算术表达式（要求输出归约过程） （3）给定表达式文法为： G(E’): E’→#E# E→E+T | T T→T*F |F F→(E)|i (4)分析的句子为: (i+i)*i和i+i)*i
编译原理实验二——算符优先分析法设计与实现
08-29
给出的代码片段展示了部分实现，包括了计算字符在算符优先关系表中的下标、非终结符的 FIRSTVT 和 LASTVT 集的计算函数。在实际实现中，还需要包含以下关键部分： - **词法分析器**：扫描输入，识别并生成标记。 - ...
算符优先分析算法的设计与实现 编译原理
12-01
《算符优先分析算法的设计与实现——基于编译原理》 在计算机科学领域，编译原理是理解程序设计语言如何转换为机器可执行代码的关键学科。其中，算符优先分析算法是编译器设计中的一个重要组成部分，它主要用于解决...
编译原理 实验3《算符优先分析法设计与实现》
热门推荐
渣渣的夏天
08-04 1万+
实验3《算符优先分析法设计与实现》 一、实验目的   加深对语法分析器工作过程的理解；加强对算符优先分析法实现语法分析程序的掌握；能够采用一种编程语言实现简单的语法分析程序；能够使用自己编写的分析程序对简单的程序段进行语法翻译。 二、实验内容   在实验1的基础上，用算符优先分析法编制语法分析程序，语法分析程序的实现可以采用任何一种编程语言和工具。 三、实验方法   1．实验采用C++程序语言进行...
编译原理算符优先表C++
12-28
只是算符优先表 现在dat.txt 中写入这些 E->E+T|T E->T*F|F F->(E)|i#
算符优先分析算法（实验报告）
12-15
三 设计源码 算符优先分析器 #include "stdio.h" #include "stdlib.h" #include "iostream.h" char data[20][20]; //算符优先关系 char s[100]; //模拟符号栈s char lable[20]; //文法终极符集 char input[100]; //文法输入符号串 char string[20][10]; //用于输入串的分析 int k; char a; int j; char q; int r; //文法规则个数 int r1;
算符优先语法分析程序
07-07
实现算符优先分析算法，完成以下描述算术表达式的算符优先文法的算符优先分析过程。 G[E]:E→E+T∣E-T∣T T→T*F∣T/F∣F F→(E)∣i 说明：终结符号i为用户定义的简单变量,即标识符的定义。 要求： （1）构造该算符优先文法的优先关系矩阵或优先函数； （2）输入串应是词法分析的输出二元式序列，即某算术表达式“实验项目一”的输出结果。输出为输入串是否为该文法定义的算术表达式的判断结果。 （3）算符优先分析过程应能发现输入串出错。 （4）设计两个测试用例（尽可能完备），并给出测试结果。
算符优先分析算法的设计与实现
11-30
实验三 算符优先分析算法的设计与实现，郑州大学，昝红英，编译原理，源码，已通过
基于算符优先分析方法的表达式语法分析器
02-15
了解用算符优先法对表达进行语法分析的方法，掌握自顶向下的预测语法分析程序的手工构造方法。 附加功能： 1. 循环输入表达式和输出结果 2. 输出表达式对应的后缀表达式
编译原理 词法分析 算符优先分析法
oowadanoko的博客
07-14 1046
编译原理 词法分析 算符优先分析法 实验目的 加深对语法分析器工作工程的理解，加强对算符优先分析法实现语法分析程序的掌握；能够采用一种编程语言实现简单的语法分析程序；能够使用自己辨析的分析程序对简单的程序段进行语法翻译。 实验环境 Microsoft Visual Studio 2019 Community 思路 首先从文件中读取产生式，并进行分割，将包含“|”的产生式分割成单独的一条产生式。 然后根据产生式求Vt和Vn。先获取每条产生式左侧的字符，这些就是所有的Vn，然后在每条产生式右侧中寻找非Vn的字符
算符优先分析算法及其代码实现
Clover's blog
11-06 3629
最近编译课要求写一个OPG的算法实现，记录一下~也希望帮助到你
【20200422】编译原理课程课业打卡十七之求解文法FirstVT&LastVT&构造文法算符优先关系表
小啊呜的博客
04-29 8262
【20200422】编译原理课程课业打卡十七之求解文法FirstVT&LastVT&构造文法算符优先关系表 一、课业打卡十七之求解文法FirstVT&LastVT&构造文法算符优先关系表 问题描述 题目解析 二、知识巩固 1、自下而上的语法分析 2、分析符号串是否为文法的句子实例 3、自下而上语法分析的策略 4、我们如何决定什么时候移进，什么时候规约？ 5、关于短语、直接短语、句柄的定义 6、关于移进-归约冲突的产生&解决方法 7、简单优先分析法 8、算符优先分析法 9、算符文法（OG）& 算符优先文法
编译原理算符优先分析算法
ye_se_cong_cong的博客
06-02 9762
算符优先分析算法          编译原理中自上而下算符优先分析算法是一种“移进-规约”法，本例运用的是编译原理第三版何炎祥中的算符优先分析算法，省去了输出分析过程部分，读者可以参考我发的编译原理语法分析器中的输出部分写出本算法的输出部分。下附加代码： /* Name: 自上而下算符优先分析算法  Copyright:  Author: cc  Date: 18/04/17 16:2
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值