java实现算符优先文法ll1文法

最新推荐文章于 2024-05-09 10:52:55 发布
最新推荐文章于 2024-05-09 10:52:55 发布
阅读量2k 收藏 15
点赞数 1
分类专栏： 新手学习 文章标签： 编译原理 算符优先文法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41705703/article/details/90813568
版权

实验要求：

1.[实验项目]

实现LL(1)分析中控制程序（表驱动程序）；完成以下描述赋值语句的LL(1)文法的LL(1)分析过程。

G[E]:

E →E+T∣E-T∣T

T→T*F∣T/F∣F

F→(E)∣i

2.[设计说明]

终结符号i 为用户定义的简单变量,即标识符的定义。

3.[设计要求]

（1）构造该算符优先文法的优先关系矩阵或优先函数；

（2）输入串应是词法分析的输出二元式序列，即某算术表达式“专题
1”的输出结果。输出为输入串是否为该文法定义的算术表达式的判断结果。

（3）算符优先分析过程应能发现输入串出错。

（4）设计两个测试用例（尽可能完备，正确和出错），并给出测试结果；

（5）考虑编写程序根据算符优先文法构造算符优先关系矩阵，并添加到你的算符优先分析程序中。

实验过程：

1、算符优先分析程序设计说明
1.1设计要求：

（1）构造该算符优先文法的优先关系矩阵或优先函数；

（2）输入串应是词法分析的输出二元式序列，即某算术表达式“专题
1”的输出结果。输出为输入串是否为该文法定义的算术表达式的判断结果。

（3）算符优先分析过程应能发现输入串出错。

（4）设计两个测试用例（尽可能完备，正确和出错），并给出测试结果；

（5）考虑编写程序根据算符优先文法构造算符优先关系矩阵，并添加到你的算符优先分析程序中。

1.2设计说明：

（1）该语言大小写不敏感；

（2）字母为a-zA-Z，数字为0-9；

（3）对文法进行扩充和改造；

（4）根据FIRSTVT集和LASTVE集的构造规则，构造出文法的FIRSTVT集和LASTVT集

（5）根据FIRSTVT集和LASTVT集构造算符优先矩阵；

（6）根据分析规则，构造算符优先矩阵分析器。

3、程序功能描述

（1）、能够录入一个.tys文件中的二元式内容；二元式内容为表达式

（2）、根据.tys文件内容进行算符优先分析，可识别

（3）、根据输入的二元式内容进行分析语法分析，并打印结果；

（4）、打印分析过程（分析栈和保留串）和错误提示；

（5）、根据文法构造FIRSTVT集和LASTVT集；

（6）、根据构造FIRSTVT集和LASTVT集，构造出算符优先矩阵分析表；

（7）、算符优先矩阵分析器。

4、主要的数据结构描述
4.1主要使用的java数据结构类型
4.1.1 List

//终结符号集

private List<Character> Vt = new ArrayList<Character>();

//非终结符号集

private List<Character> Vn = new ArrayList<Character>();

使用List保存文法的非终结符号和终结符号，一旦文法给定，非终结符号集合和终结符号集合也就确定，所以对Vt、Vn的操作一般是查找元素和遍历元素。

List添加元素

//设置非终结符号

Vn.add(‘S’);

Vn.add(‘E’);

Vn.add(‘T’);

Vn.add(‘F’);

//设置终结符号

Vt.add(’#’);

Vt.add(’+’);

Vt.add(’-’);

Vt.add(’*’);

Vt.add(’/’);

Vt.add(’(’);

Vt.add(’)’);

Vt.add(‘i’);

使用add()方法即可添加元素，上面的程序保存了Vt、Vn集合。

list中是否包含某个元素

方法：.contains（Object o）； 返回true或者false

例如下面在程序中使用到的：

Vn.contains(nArryStr[i].charAt(0))&&Vt.contains(nArryStr[i].charAt(1))

list获取长度：

Vt.size()

使用size()即可返回List的长度

list中查看（判断）元素的索引

注意：.indexOf（）； 和 lastIndexOf（）的不同；

List<String> names=new ArrayList<>();

names.add(“刘备”); //索引为0

names.add(“关羽”); //索引为1

names.add(“张飞”); //索引为2

names.add(“刘备”); //索引为3

names.add(“张飞”); //索引为4

System.out.println(names.indexOf(“刘备”));

System.out.println(names.lastIndexOf(“刘备”));

System.out.println(names.indexOf(“张飞”));

System.out.println(names.lastIndexOf(“张飞”));

根据元素索引位置进行的判断
if (names.indexOf("刘备")==0) {
    System.out.println("刘备在这里");
}else if (names.lastIndexOf("刘备")==3) {
    System.out.println("刘备在那里");
}else {
    System.out.println("刘备到底在哪里？");
}

在程序中使用OPGtable[Vt.indexOf(Vt1)][Vt.indexOf(Vt2)]

判断list是否为空

//空则返回true，非空则返回false


if (person.isEmpty()) {
    System.out.println("空的");
}else {
    System.out.println("不是空的");
}
4.1.2 Map
HashMap

最常用的Map,它根据键的HashCode
值存储数据,根据键可以直接获取它的值，具有很快的访问速度。HashMap最多只允许一条记录的键为Null(多条会覆盖);允许多条记录的值为
Null。非同步的。

常用API
clear()从 Map 中删除所有映射
remove(Object key)从 Map 中删除键和关联的值
put(Object key, Object value)将指定值与指定键相关联
putAll(Map t)将指定 Map 中的所有映射复制到此 map
entrySet()返回 Map 中所包含映射的 Set 视图。Set 中的每个元素都是一个 Map.Entry 对象，可以使用 getKey() 和 getValue() 方法（还有一个 setValue() 方法）访问后者的键元素和值元素
keySet()返回 Map 中所包含键的 Set 视图。删除 Set 中的元素还将删除 Map 中相应的映射（键和值）
values()返回 map 中所包含值的 Collection 视图。删除 Collection 中的元素还将删除 Map 中相应的映射（键和值）
get(Object key)返回与指定键关联的值
containsKey(Object key)如果 Map 包含指定键的映射，则返回 true
containsValue(Object value)如果此 Map 将一个或多个键映射到指定值，则返回 true
isEmpty()如果 Map 不包含键-值映射，则返回 true
size()返回 Map 中的键-值映射的数目

在程序中使用了MAP:

//文法

private Map<String, String> grammar = new HashMap<String, String>();

//FIRSTVT集

private Map<Character,Set<Character>> FIRSTVT = new
HashMap<Character,Set<Character>>();

//LASTVT集

private Map<Character,Set<Character>> LASTVT = new
HashMap<Character,Set<Character>>();

使用map保存文法，和FIRSTVT,LASTVT。

Map添加元素

grammar.put(“S”, “#E#”);

grammar.put(“E”, “E+T|E-T|T”);

grammar.put(“T”, “T*F|T/F|F”);

grammar.put(“F”, “(E)|i”);

上面程序将题目要求的文法保存到map对象grammar中

Map的遍历

		grammar.forEach((k,v)->{
			String []nArryStr = v.split("\\|");
			for(int i=0 ;i<nArryStr.length;i++)
				
			{
				//System.out.println(nArryStr[i]);
				if(Vt.contains(nArryStr[i].charAt(0)))
				{
					char b= nArryStr[i].charAt(0);
					FIRSTVT.get(k.charAt(0)).add(b);
				}
				if(nArryStr[i].length()>=2)
				if(Vn.contains(nArryStr[i].charAt(0))&&Vt.contains(nArryStr[i].charAt(1)))
				{
					char b=nArryStr[i].charAt(1);
					FIRSTVT.get(k.charAt(0)).add(b);
				}
			}
			
			
		});

使用forEach方法，参数(k,v)

其中k为每个values的索引值，通过forEach的方法，遍历map的所有元素，就返回每个元素的key和values，并赋给参数（k,v）。

Map获取元素

Map获取元素一般根据key值获取对应的values：

例如：

LASTVT.get(k.charAt(0))

结果返回的是，key对应的values，而且values是声明map时设置的类型对应，

比如：

private Map<Character,Set<Character>> LASTVT = new
HashMap<Character,Set<Character>>();

key的类型为Character

values的类型为Set<Character>

所以通过LASTVT.get(key)获得values时，得到类型为Set<Character>。

4.2 二元式文件结构

二元式文件通过专题1的词法分析程序得到：

其中一个测试用例为：

(1,a)
(4,+)
(1,b)
(10,*)
(3,(）
(1,c)
(5,-)
(2,34)
(3,))
(11,/)
(1,num5)

二元式文件内容被录入到

br = new BufferedReader(new InputStreamReader(new FileInputStream(fp.getName())));
			String erYuanShi = "";
			while((erYuanShi=br.readLine())!=null) {
				//截取符号串
				String substr=erYuanShi.substring(erYuanShi.indexOf("(") + 1, erYuanShi.lastIndexOf(","));
				if(substr.equals("1")||substr.equals("2"))
				{		
					s+="i";
				}
				else 
				{
					s+=erYuanShi.substring(erYuanShi.indexOf(",") + 1, erYuanShi.lastIndexOf(")"));
				}

			}

二元式文件的录入和专题2一样，InputStream是一个Java
List列表的一个对象，list列表是一系列的String类型的字符串，具体的操作：

br = new BufferedReader(new InputStreamReader(new FileInputStream(fp.getName())));
			String erYuanShi = "";
			while((erYuanShi=br.readLine())!=null) {
				//截取符号串
				InputStream.add(erYuanShi.substring(erYuanShi.indexOf(",") + 1, erYuanShi.lastIndexOf(")")));
			}
			InputStream.add("#");  //末尾添加#号

br为一个文件的读入流，通过使用br.readLine()方法读入二元式文件当前行内容并返回给String类型的变量erYuanShi，然后每一行的内容类似为(1,num1)的形式，但是我们需要就是num1，所以通过erYuanShi.substring(erYuanShi.indexOf(",")+ 1,
erYuanShi.lastIndexOf(")"))方法将num1截取下来，放入List列表对象中，继续读文件，直到读取结束。这样就将二元式文件的内容读取到了字符串s中。1
和2表示标识符和数字在符号表中的序号，也即1表示当前二元式的实际内容为标识符，2表示为数字，所以如果是标识符和数字时，就将内容转换为i保存到s中。

最后得到字符串s类似为: i+i*(i-i)/i

但是实际算术表达式为：a+a*(b-c)/2。

也就是将用户定义的标识符和数字都转为i。

4.5 FIRSTVT 集

private Map<Character,Set<Character>> FIRSTVT = new HashMap<Character,Set<Character>>();

根据构造规则：

U∈Vn

FIRSTVT(U)=

{b∣U=+>b…, 或U =+> Vb…, b∈Vt,V∈Vn }

则形如W→…aU…的规则 a < b

b ∈ FIRSTVT(U)

在这里插入图片描述

编写代码：

//遍历文法。进行非终结符号的FIRSTVT的初始化
		grammar.forEach((k,v)->{
			String []nArryStr = v.split("\\|");
			for(int i=0 ;i<nArryStr.length;i++)
				
			{
				//System.out.println(nArryStr[i]);
				if(Vt.contains(nArryStr[i].charAt(0)))
				{
					char b= nArryStr[i].charAt(0);
					FIRSTVT.get(k.charAt(0)).add(b);
				}
				if(nArryStr[i].length()>=2)
				if(Vn.contains(nArryStr[i].charAt(0))&&Vt.contains(nArryStr[i].charAt(1)))
				{
					char b=nArryStr[i].charAt(1);
					FIRSTVT.get(k.charAt(0)).add(b);
				}
			}
			
			
		});
		
		do 
		{
			FIRSTVTAllNochange=1;
			grammar.forEach((k,v)->{
				String []nArryStr = v.split("\\|");
				for(int i=0 ;i<nArryStr.length;i++)
					
				{
					char U=k.charAt(0);
					char V=nArryStr[i].charAt(0);
					if(Vn.contains(U)&&U!=V&&Vn.contains(V))
					{
						
							FIRSTVT.get(V).forEach(values->{
								if(!FIRSTVT.get(U).contains(values))
								{
								//	System.out.println(values);
								 FIRSTVT.get(U).add(values);
								 FIRSTVTAllNochange = 0;
								}
							
							});
							
						
					}
					
				}
				
				
			});
			if(FIRSTVTAllNochange==1)
				break;
		}while(true);

获得FIRSTVT集：

S:[#]
T:[(, i, *, /]
E:[(, i, *, +, -, /]
F:[(, i]

4.6 LASTVT 集

//LASTVT集 private Map<Character,Set<Character>> LASTVT = new
HashMap<Character,Set<Character>>();

LASTVT构造规则：

U∈Vn

LASTVT(U)=

{a∣U=+>…a, 或U =+>…aV, a∈Vt, V ∈Vn }

则形如W→…Ub…的规则 a > b

a ∈LASTVT(U)

编写代码：

//遍历文法。进行非终结符号的LASTVT的初始化
		grammar.forEach((k,v)->{
			String []nArryStr = v.split("\\|");
			for(int i=0 ;i<nArryStr.length;i++)
				
			{
				//System.out.println(nArryStr[i]);
				int len= nArryStr[i].length();
				if(Vt.contains(nArryStr[i].charAt(len-1)))
				{
					char b= nArryStr[i].charAt(len-1);
					LASTVT.get(k.charAt(0)).add(b);
				}
				if(nArryStr[i].length()>=2)
				if(Vt.contains(nArryStr[i].charAt(len-2))&&Vn.contains(nArryStr[i].charAt(len-1)))
				{
					char b=nArryStr[i].charAt(len-2);
					LASTVT.get(k.charAt(0)).add(b);
				}
			}
			
			
		});
		
		do 
		{
			FIRSTVTAllNochange=1;
			grammar.forEach((k,v)->{
				String []nArryStr = v.split("\\|");
				for(int i=0 ;i<nArryStr.length;i++)
					
				{
					int len =nArryStr[i].length();
					char U=k.charAt(0);
					char V=nArryStr[i].charAt(len-1);
					if(Vn.contains(U)&&U!=V&&Vn.contains(V))
					{
						
						LASTVT.get(V).forEach(values->{
								if(!LASTVT.get(U).contains(values))
								{
									//System.out.println(values);
									LASTVT.get(U).add(values);
								 FIRSTVTAllNochange = 0;
								}
							
							});
							
						
					}
					
				}
				
				
			});
			if(FIRSTVTAllNochange==1)
				break;
		}while(true);

最后得到LASTVT集：

S:[#]

T:[), i, *, /]

E:[), i, *, +, -, /]

F:[), i]

4.7 算符优先矩阵

/算符优先权关系表
/**
* 在OPGtable中，用-1，0,1,2表示优先权关系
* 0 表示优先关系等于
* 1 表示优先关系小于
* 2 表示优先关系大于
* -1 表示不存在优先权关系
* *
*/
private int [][]OPGtable = new int [N][N];

在这里插入图片描述

构造规则：

编写代码：

/**
		 * 在OPGtable中，用-1，0,1,2表示优先权关系
		 * 0 表示优先关系等于
		 * 1 表示优先关系小于
		 * 2 表示优先关系大于
		 * -1 表示不存在优先权关系
		 * *
		 */
		grammar.forEach((k,v)->{
			String []nArryStr = v.split("\\|");
			
			for(int i=0 ;i<nArryStr.length;i++)			
			{		
				String ruleRight=nArryStr[i];
				int  len = ruleRight.length();
				if(len>=2)
				{
					for(int i1= 0 ;i1<len-1 ;i1++)
					{
						char X1=ruleRight.charAt(i1);
						char X2=ruleRight.charAt(i1+1);
						
						if(Vt.contains(X1)&&Vt.contains(X2))				
							OPGtable[Vt.indexOf(X1)][Vt.indexOf(X2)]=0;//0 表示优先关系等于
						if(Vt.contains(X1)&&Vn.contains(X2))
						{
							FIRSTVT.get(X2).forEach(values->{
								OPGtable[Vt.indexOf(X1)][Vt.indexOf(values)]=1;//1 表示优先关系小于
							});
						}
						if(Vn.contains(X1)&&Vt.contains(X2))				
						{
							LASTVT.get(X1).forEach(values->{
								OPGtable[Vt.indexOf(values)][Vt.indexOf(X2)]=2;//2 表示优先关系大于
							});
						}
						if(len>=3&&i1<len-2)
						{
							char X3=ruleRight.charAt(i1+2);
							if(Vt.contains(X1)&&Vn.contains(X2)&&Vt.contains(X3))
							{	
								OPGtable[Vt.indexOf(X1)][Vt.indexOf(X3)]=0; //0 表示优先关系等于
							}
						}
							
							
					}
					
				}
				
			}
			
			
		});

最终的算符优先矩阵：

在这里插入图片描述

5、程序结构描述
5.1Java 主类：OPGMain

在这里插入图片描述

5.1.1全局变量
变量类型变量名称变量作用
private List<Character>Vt保存终结符号集，需要手动设置
Private List<Character>Vn保存非终结符号集。需要手动设置
private Map<Character, String>grammar保存文法，需要手动设置
private Map<Character,Set<Character>>FIRSTVT保存非终结符号的FIRSTVT集，由函数生成内容
private Map<Character,Set<Character>>LASTVT保存非终结符号的LASTVT集，有相应的生成函数生成其内容
private Map<String,Set<Character>>OPGtable//算符优先权关系矩阵 /** * 在OPGtable中，用-1，0,1,2表示优先权关系 * 0 表示优先关系等于 * 1 表示优先关系小于 * 2 表示优先关系大于 * -1 表示不存在优先权关系 * * */
5.1.2函数
类型返回值函数名功能
public无OPGMain构造函数，初始化文法，Vt和Vn
publicvoidCreate_FIRSTVT构造FIRSTVT集
publicvoidCreate_LASTVT输出LASTVT集
publicvoidCreate_OPGTable构造算符优先关系矩阵
publicvoidOPGanalysis算符优先文法分析器
publicintget_PriorityRelationship获得两个终结符号的优先关系
publicstatic voidmain类的主函数，实例化主类，并传入中间文件。
./media/image5.png

5.1.3函数调用关系图
在这里插入图片描述

绿色虚线为调用

6、程序测试
6.1 正确用例

测试用例为二元式文件结构部分的用例

(1,a)
(4,+)
(1,b)
(10,*)
(3,()
(1,c)
(5,-)
(2,34)
(3,))
(11,/)
(1,num5)

结果为：

在这里插入图片描述

在这里插入图片描述

6.2 错误用例

通过修改测试用例1使其不符合赋值语句语法：

6.2.1缺少操作符

在这里插入图片描述

6.2.2缺少 ‘）’符号

在这里插入图片描述
源代码：https://github.com/Topdu/Compilation-principle/tree/master/16281002-杜永坤-专题4

topduke
关注
  • 1
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
算符优先算法实现
xurui1073337662的博客
06-23 2495
实现算符优先算法，完成一个算符优先文法的算法优先分析过程。(1)根据给定文法,先求出FirstVt和LastVt集合,构造算符优先关系表(要求算符优先关系表输出到屏幕或者输出到文件);(2)根据算法和优先关系表分析给定表达式是否是该文法识别的正确的算术表达式(要求输出归约过程)(3)给定表达式文法为:G(E’): E’→#E#E→E+T | TT→T*F |FF→(E)|i(4)分析的句子为:...
LL（1）文法的语法分析java实现
tyh1579152915的博客
11-21 2801
java代码如下： package 文法分析器; import java.io.BufferedReader; import java.io.FileInputStream; import java.io.InputStreamReader; import java.util.*; /* *(1)产生式集合 *(2)first和follower集合 **/ public class Grammar_Analysis { //first集合 public static Hash.
编译原理Java实现正规式生成NFA（利用算符优先级实现Thompson算法）
weixin_52424236的博客
04-23 1205
该部分代码属于仓库当中part03的部分，使用的语言为Java由于代码比较多，文件数量也较多，因此先介绍一下不同的文件的功能：其他文件是一些结构代码，方便进行数据的处理和面向对象，源码已上传至Github，地址。
算符优先文法分析 讲解+java代码（看这一篇就够了）
最新发布
weixin_74039195的博客
05-09 830
我提炼出的信息就是从栈顶终结符往下找，找到满足ai-1 < ai关系的终结符ai-1，将ai-1右边的所有元素出栈。将产生式右部第一个是非终结符，将非终结符的FirstVT(R)加入到FirstVT(T)中。产生式右部最后一个是非终结符，将非终结符的LastVT(R)加入到LastVT(T)中。产生式右部最后一个是非终结符，倒数第二个是终结符，将终结符加入LastVT(T)中。产生式右部第一个是非终结符，第二个是终结符，将终结符加入FirstVT(T)中。(1)形式：T->...ab...
算符优先
l__fengjin的博客
05-27 333
算符优先-------Java实现 实验题目 实验结果 1、读取文本 package by02; import java.io.BufferedReader; import java.io.File; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; import java.util.ArrayList; public class by02file { pri
编译原理之LL1文法的java代码实现
05-06
本实验是对LL1文法的代码实现,仅供学习交流参考使用,禁止用于商业用途,如有错误,请批评斧正.同时欢迎各位大佬交流
编译原理语法分析器（算符优先文法）
07-19
在C++中，实现一个基于算符优先文法的语法分析器通常涉及以下步骤： - 定义算符优先关系表：这是文法的基础，用于指导解析过程。 - 词法分析：将输入的源代码分解成一个个符号（token），如数字、变量名、运算符...
编译原理 语法分析器 算符优先
06-14
编译原理语法分析器算符优先 编译原理语法分析器算符优先是编译器设计中的一种重要技术，用于分析程序源代码的语法结构...同时，算符优先的设计和实现需要考虑到语法规则的设计、算符优先的实现、语法树的生成等方面。
学习编译原理2（算符优先分析法、LL1分析法、SLR分析法）
07-23
编译原理是研究编译器构造的理论基础，其中算符优先分析法、LL1分析法和SLR分析法是三种常用的语法分析方法。接下来，我们将深入探讨这些方法的核心概念和应用。 首先，算符优先分析法是一种基于算符优先关系的语法...
LL1预测分析和算符优先分析程序（语法分析程序）（VC++）
02-26
通过分析并运行这个项目，不仅可以了解LL1预测分析和算符优先分析的基本原理，还可以学习到如何在实际编程环境中实现这些理论，这对于理解和设计编译器具有重要的实践意义。同时，这也是对编译原理课程理论知识的...
编译原理课程设计-LL(1)预测分析法 算符优先分析 LR分析
06-29
语法分析程序可以根据个人的掌握情况选用常见的几种语法分析方法：递归下降分析方法、LL(1)预测分析法、算符优先分析、LR分析等方法中的任何一种来实现，也可以选用不同的方法来分析不同的语法成分，最后再综合起来...
java编写的算符优先分析法分析器
05-22
使用算符优先分析算法分析下面的文法：<br>E’ → #E#<br>E → E+T | T<br>T → T*F | F<br>F → P^F | P<br>P → (E) | i<br>其中i可以看作是一个终结符，无需作词法分析。具体要求如下：<br>1、如果输入符号串为正确句子，显示分析步骤，包括分析栈中的内容、优先关系、输入符号串的变化情况；<br>2、如果输入符号串不是正确句子，则指示出错位置。<br>
算符优先文法分析器的设计与实现(java gui 版)
07-05
1． 设计扫描程序，将任何一种整数运算表达式（无变量，操作数为正整数，允许加减乘除四种运算，允许使用括号和多层括号）识别为单词，并能发现单词的拼写错误 2． 设计自底向上分析程序，在栈上实现对单词token串的自底向上分析 3． 根据算符优先文法的分析步骤，展示分析栈、token串的状态变化、相关量的优先级比较(算符优先分析表)结果输出 、判断当前是否进行规约或移进操作、（若须规约）显示当前应规约的串 4． 展示语法树
编译原理预测分析LL(1)文法 JAVA实现
06-21
1、项目开发工具为MyEclipse2014 2、使用了Struts2框架作为控制层 3、HTML5图形用户界面 4、JAVA语言写后端 该项目完成的功能有：自动消去规则左递归；自动计算出First、Follow集；自动构造预测分析表；可输入句子进行判断。 代码我都写了注释，由于项目后期完成的比较急促，所以代码冗余度比较大，还没有时间进行精简。 如果不需要网页的图形用户界面，可将项目中的算法部分单独取出，也可直接运行得到结果。算法部分位于项目中的MyClass包中。
java编写的LL(1)文法
01-16
LL(1)简单模拟测试 给定某一文法，试构造其简单优先矩阵(或LL(1)矩阵)，并编制程序。 给出相应句子的语法分析过程，判其正确性。 例如：给定文法G： E→T E1 E1→+TE1／ε T→FT1 T1→*F／ε F→id／(E)
编译原理LL1文法实现
12-23
编译原理LL1文法实现，使用D盘下TXT文档输入字符串例子
LL(1)语法分析器识别句子（java）
Ich/liebe/dich的编程せかい
12-03 2501
一、实验目的 设计、编制并调试一个语法分析程序，加深对语法分析原理的理解。 二、使用仪器、器材 计算机一台 操作系统：Windows10 编程软件：Intellij IDEA 三、实验内容及原理 设有文法G[E]: E→E+T|T T→T*F|F F→(E)|i 消除左递归后的文法为： E→TE’ E’→+TE’|ε T→FT’ T’→*FT’|ε F→(E)|i 建立LL(1)分析表如下： I + * ( ) # E E→TE’ E→TE’ E’ E’→+TE’
算符优先文法
心升明月的博客
11-28 9160
算符优先文法概述自底向上分析优先关系算符文法算符优先文法构造算符优先表的算法确定算符优先关系构造集合FIRSTVT(P)FIRSTVT(P)FIRSTVT(P)的算法构造集合LASTVT(P)LASTVT(P)LASTVT(P)的算法构造算符优先表实例算符优先分析算法最左素短语最左素短语定理流程评价 概述 自底向上分析 在自底向上分析中，分析过程的每一步都是从当前句型中选择一个可规约的子串，将它规约到某个非终结符。 自底向上分析的关键问题是在分析过程中如何确定句柄或其他可规约串，也就是说如何知道何时在栈符号
C++实现算符优先文法
Gowi的博客
09-05 2839
Operator-precedence-grammar C++读取文件，求解firstvt集与lastvt集，构建算符优先关系表，打印文法分析过程，实现算符优先文法 文章目录Operator-precedence-grammar概述FIRSTVT集和LASTVT集构造算符优先关系表构计算分析过程实现过程输出结果代码链接 概述 算符优先分析法(Operator Precedence Parse)是仿效四则运算的计算过程而构造的一种语法分析方法。算符优先分析法的关键是比较两个相继出现的终结符的优先级而决定应采取
用Java代码实现算符优先文法
05-14
以下是用 Java 代码实现算符优先文法的示例： ``` import java.util.Scanner; import java.util.Stack; public class OperatorPrecedenceGrammar { private static final String[] OPERATORS = {"+", "-", "*", ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值