LL（1）文法

最新推荐文章于 2023-11-07 20:12:38 发布
最新推荐文章于 2023-11-07 20:12:38 发布
阅读量1.1k 收藏 6
点赞数
分类专栏： 编译原理 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45876090/article/details/124123984
版权
本文介绍了LL(1)分析法和算符优先分析法在编译原理实验中的应用。实验中，LL(1)分析法通过预测分析表实现了自上而下的语法分析，算符优先分析法则是自下而上的方法，定义了算符的优先关系。实验详细展示了两种方法的实现步骤，并给出了具体源代码及输入、输出示例。
摘要由CSDN通过智能技术生成

编译原理实验报告

LL（1）grammar：LL（1）分析法
operator precedence grammar算符优先分析法

一、LL（1）、OPG

LL（1）分析法：功能是利用LL（1）控制程序根据显示栈栈顶内容、向前看符号以及LL（1）分析表，对输入符号串自上而下的分析过程。

算符优先分析法：是一种简单直观、广泛使用、便于手工实现的自下而上的语法分析方法。定义算符之间的某种优先关系，寻找“归约串”，并进行归约。

二、LL（1）步骤

1.创建test2.txt

i+i*i#

2.源代码

代码如下：

 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream>
using namespace std;
struct Stack {
	char s[30];
	int top; //栈顶指针
}Stack;
char v1[6] = { 'i','+','*','(',')','#' };//终结符
char v2[5] = { 'E','G','T','S','F' };//非终结符
//预测分析表，用符号^来代替ε
char table[5][6][4] = { { "TG","","","","TG","" },
{ "","+TG","","","^","^" },
{ "FS","","","FS","","" },
{ "","^","*FS","","^","^" },
{ "i","","","(E)","","" } };
void push(char ch) {
	Stack.s[Stack.top] = ch;
	Stack.top++;
}
char pop() {
	Stack.top--;
	return Stack.s[Stack.top];
}
/**逆序进栈**/
void InversePush(int row, int line) {
	char temp[4];
	int i;
	for (i = 0; i < 4; i++) {
		if (table[row][line][i] != '\0')//字符串结束位是'\0'
			temp[i] = table[row][line][i];
		else {
			temp[i] = '\0';
			break;
		}
	}
	if (i == 0)
		return;
	cout << v2[row] << "->";
	for (int k = 0; k < i; k++) 
		cout << temp[k];
	cout << endl;
	for (i = i - 1; i >= 0; i--) {
		if (temp[i] != '^')	//^代表ε
			push(temp[i]);
	}
}
/**判断X是否为终结符**/
int IsTerminal(char X) {//若是则返回下标,非终结符返回-1
	for (int i = 0; i<6; i++) {
		if (X == v1[i])
			return i;
	}
	return -1;
}
/**查找预测表**/
bool FindTable(char X, char a) {//若为空白则出错，否则进栈
	int row;
	for (row = 0; row < 5; row++){
		if (X == v2[row])
			break;
	}
	if (row == 5)
		return false;
 
	int line = IsTerminal(a);
	if (line == -1)
		return false;
 
	if (table[row][line][0] == '\0')
		return false;
	else
		InversePush(row, line);	
	return true;
}
 
int  main()
{
	FILE *fp; 
	char a, X; 
	bool flag = true;
	char str[20]; 
	int len = 0;
//	if (() != NULL) {
//		printf("error opening.\n");
//		exit(1);
//	}
    fp = fopen("D:\\VS1\\code2\\compile\\ll1grammar\\test2.txt", "r");
    
	Stack.top = 0;
	push('#'); //栈底放一个’#’
	push('E');//放入文法开始符号
	a = fgetc(fp);
	str[len] = a;
	str[++len] = '\0';
    while (flag) {
		X = pop();
		if (X == '#') {
			if (a == '#') {
				cout << str << "是合法符号串" << endl;
                system("pause");
				return 0;
			}
		}
		else if ((IsTerminal(X)) != -1) {//栈顶是终结符
			if (a == X) {//栈顶和输入串第一个字符进行抵消
				a = fgetc(fp);
				str[len] = a;
				str[++len] = '\0';
			}
			else {
				flag = false;
			}
		}
		else if (!FindTable(X, a))
			flag = false;
	}
	cout << str << "是非法符号串" << endl;
    fclose(fp);
    fp = NULL;
    system("pause");
	return 0;
}

2.实验结果

在这里插入图片描述

三、OPG步骤

1.源代码

代码如下：

#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();
    }
    printf("按Ctrl+Z退出");
    system("pause");
}

2.输入：

5
S->a
S->^
S->(T)
T->T,S
T->S
在这里插入图片描述

3.实验结果

在这里插入图片描述

白茶LXL
关注
专栏目录
LL(1)文法
Meskjei的博客
02-26 2万+
文章目录预测分析法的工作过程S_文法（简单的确定性文法）什么时候使用$\epsilon$产生式？非终结符的后继符号集产生式的可选集q_文法串首终结符集LL(1)文法 预测分析法的工作过程 从文法开始符号触发，在每一步推导过程中根据当前句型的最左非终结符A和当前输入符号a，选择正确的A-产生式。为保证分析的确定性，选出的候选式必须是唯一的。 S_文法（简单的确定性文法） 特点： 每个产生式的右部都...
ll(1)语法分析
10-25
可读取文法文件，可消除左递归，替换：当XVN时选相应产生式的右部去替换X。此时X出栈，逆序入栈。 匹配：当XVT时它与a进行匹配，其结果可能成功，也可能失败，如果成功则符号栈中将X退栈并将输入流指针向前移动一位，否则报错。 接受：当格局为（#，空#）时报告分析成功。 报错：出错后，停止分析。并给出相应的错误提示信息。
LL(1)文法判断程序
05-11
1. 实验内容 1、 让计算机接受一个文法，示例如(仅供参考)： G[S] 为: S→AB S→bC A→ε A→b B→ε B→aD C→AD C→b D→aS D→c 2、 编程实现对上述文法是否是LL(1)文法的判断，是则给出肯定回答，否则给出否定回答。 3、判别是否是LL(1)文法 。。。。。。
编译原理—LL(1)文法
热门推荐
weixin_47365232的博客
05-21 1万+
LL(1)文法
LL(1)文法源代码
05-18
需要建立一个input文档。文档内容如： S->TE E->@ E->+TE T->FN N->@ N->*FN F->i F->(S) 注：空串用@表示。
LL（1）文法的判别以及非LL（1）文法的转换（完整可运行代码）
09-10
### LL（1）文法的判别以及非LL（1）文法的转换知识点解析 #### 实验背景及目的 本实验旨在通过编程的方式实现对上下文无关文法的分析，特别是针对LL（1）文法的判别及其转换。LL（1）文法是一种重要的文法类别，...
LL(1)文法——vc.rar_LL(1)文法_LL1 文法 实现_ll1_ll1 文法_编译原理
09-23
LL(1)文法是编译原理中一种重要的形式语法，它是左到右（Left-to-Right）扫描输入串，并且在每个决策点最多查看一个输入符号（Lookahead of 1）来确定如何进行解析的文法。这种文法特别适用于自上而下的语法分析，如...
编译原理实验四LL（1）文法【C语言实现】
05-30
编译原理实验四 LL（1）文法 C 语言实现 本实验报告的主要目的是通过实现 LL（1）分析法来加深对预测分析的理解。 LL（1）分析法是一种常用的语法分析方法，它可以对输入的符号串进行自上而下的分析。 实验报告的...
LL(1)文法判断（Compilation principle）
06-10
编译原理的LL(1)文法判断代码，可以在codeblocks上无碍运行（凑字数用：祝大家学习进步天天开心）
LL1文法分析c语言代码
06-26
用C语言实现编译原理中LL1文法分析算法
LL1文法程序
07-20
LL1文法分析程序，基于Win32控制台程序，编译原理课程作业
编译原理LL1文法实现
12-23
编译原理LL1文法实现，使用D盘下TXT文档输入字符串例子
LL（1）文法解析
qq_44791528的博客
06-17 3474
一、 问题描述 给定上下文无关文法，对其进行解析，得出first集和follow集。在有能力的情况下，可以求出LL（1）分析表。 二、 算法设计 本程序主要分成三块内容，第一是文法的读入解析，第二是first集的求解，第三为follow集的求解。 文法的解析需要根据整行读入的文法，生成rulelist 表，存储文法的左部和右部，num为产生式的条数。Start list表存储非终结符，startnum为非终结符个数，endlist存储终结符，endnum为终结符个数。 First集求解过程伪代码： Firs
LL（1）文法 JAVA
ja.rome
06-01 1887
E文法表达式类 G 定义文法类 LL 文法分析类 ， 包含对First,Follow,Select集合的求解以及对表达式的分析函数  Main测试分析程序，并输出结果 E.java import java.util.ArrayList; import java.util.List; /** * 文法表达式类 * @author jiangliuhong * @createT
【编译原理】LL(1)文法
最新发布
m0_61819793的博客
11-07 3306
编译原理课程笔记，自上而下的语法分析，LL(1)分析法，FIRST集和FOLLOW集的求法
c语言文法(新)
ITsys2016的博客
12-06 416
程序->外部声明 | 程序 外部声明 程序->外部声明A' A'->外部声明A'|ε 外部声明->修饰符 变量名 形参 修饰符->void | int | char | float 形参->修饰符A' A'->函数名|指针 变量名 函数名->L | IL | ID 函数名->LA' A'->LA'|DA'|ε ...
Java实现LL(1)文法分析
本资源是一个Java程序，用于实现LL(1)文法分析。LL(1)文法是一种自左向右扫描输入串，并且在每次选择下一个符号时查看最多一个输入符号（即“L”代表Left-to-right扫描，“1”代表查看1个输入符号）的语法分析方法。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值