翻译while生成四元式--2例
写出如下语句的四元式序列
写出如下语句的四元式序列1.引言1.1 概述在编程语言中，为了对程序进行分析和执行，我们需要将程序转换成计算机能够理解和执行的形式。
而四元式序列就是一种常用的表示方式之一。
四元式序列是由四个元素组成的元组，分别是操作符、操作数1、操作数2和结果。
它可以将复杂的程序语句拆分成更简单的操作，方便计算机进行处理。
在撰写四元式序列时，我们需要根据具体的语句来确定操作符、操作数1、操作数2和结果。
以以下语句为例：pythonx = y + z我们可以将这个语句转换成如下的四元式序列：1. (+, y, z, t1)2. (=, t1, "", x)在这个序列中，第一行的操作符是加号，操作数1和操作数2分别是变量y和z，结果是临时变量t1。
第二行的操作符是赋值号，操作数1是临时变量t1，操作数2为空，结果是变量x。
这样，通过四元式序列的表示，我们可以更清晰地描述程序的执行过程，方便后续的语义分析和执行。
总的来说，四元式序列在程序分析和执行中具有重要的作用，它可以将复杂的程序语句转换成更简单的操作，方便计算机进行处理。
在实际的编程中，我们可以根据具体的语句来编写相应的四元式序列，以达到更高效、更准确地执行程序的目的。
1.2文章结构文章1.2 文章结构文章结构是指文章整体的组织形式，包括各个部分之间的关系和排列顺序。
一个合理的文章结构能够使读者更好地理解文章的主题和内容，提高文章的可读性和逻辑性。
在本文中，我们将主要围绕三个部分展开，分别是引言、正文和结论。
引言部分作为文章的开端，其主要功能是引起读者的兴趣，明确文章的主题和目的。
在引言部分中，我们将对本文的概述进行介绍，简要说明文章的主要内容和结构，并阐述文章撰写的目的。
通过清晰明了地阐述引言部分的内容，能够让读者对后续的内容有一个整体的认识和预期，为接下来的阅读打下基础。
正文部分是文章的核心，也是作者表达观点和论证思路的主要部分。
在正文部分中，我们将围绕两个要点展开，分别是要点一和要点二。
回填拉链翻译举例
<write> <read>
write (E) @gen(out, E.place, _, 标准输出设备) read i name @ look @ gen(IN,标准输入设备,_,i.place) name place
递归下降语法制导翻译方案中实现控制结构的翻译: 翻译思路: 布尔表达式求值, 并设置标号避免回填 <if> if (E) @getlabel @gen(JZ, E.place,_,label1) S1 @getlabel label1 label2
@gen(JP,_,_,label2) @ setlabel(label1:) [else S1] @ setlabel(label2:)
<while> while @ getlabel @ setlabel(label1:) ( E ) @ getlabel label1 label2 @gen(JZ, E.place,_,label2) do S @gen(JP,_,_,label1) @ setlabel(label2:)
<for>
步骤 3： 对于句型 W E do if (c>d) then x=y+z 移进do 并按如下产生式归约 Wd W E do { backpatch(E.true, nextstat); W d .chain=E.false; W d . codebegin= W. codebegin; } 四元式表内容如下： 100 if a<b goto 102 W d .chain 101 goto _ nextstat 102 W d if (c>d) then x=y+z W d .codebegin
翻译
( E .t r u e )
(1 ) 和 ( 5 ） 拉链（真）
c<d e<f
( 4 ) g o to ( 6 ) g o to „„ (p -1 ) (p + 1 ) „„ (q -1 ) (q )
( E .f a l s e )
( 4 ) 和 (6 ) 拉链（假）
(7 )( S 的 四 元 式 „„） (q )
While E do S
Begin: E 的代码
E.true: S 1 的代码
Goto begin
E.true E.false
E.false:
改写为： W->while Wd->W E do S->WdS L->L;S|S 改写为：L->S Ls->L; L->LsS;
3、翻译 C->if E then{backpatch(E.true,nextstat); C.chain:=E.false;} S->CS1 {S.chain:=merge(C.chain,S1.chain)} Tp->CS else {q:=nextstat;emit(‘goto’-); backpatch(C.chain,nextstat); Tp.chain:=merge(S.chain,q);} S->TpS2{S.chain:= merge(Tp.chain, S2.chain);} W->while{W.codebegin:=nextstat} Wd->W E do S->WdS{backpatch(S.chain,wd.codebegin) emit(‘GOTO’ W.codebegin) S.chain:=Wd.chain}
WHILE循环语句的翻译程序设计(递归下降法,输出四元式)
课内实践陈述课程名称编译道理设计题目WHILE轮回语句的翻译程序设计(递归降低法，输出四元式)学院计算机科学与技术专业班级计算机1203班姓名闵丹枫指点教师林泓课程设计任务书先生姓名：闵丹枫专业班级：计算机1203班指点教师：林泓工作单位：计算机科学与技术学院题目: WHILE轮回语句的翻译程序设计（递归降低法、输出四元式）初始条件：理论：学完编译课程，把握一种计算机高级说话的使用.实践：计算机实验室提供计算机及软件环境.如果本人有计算机可以在其上进行设计.请求完成的次要任务: （包含课程设计工作量及其技术请求，和说明书撰写等具体请求）（1）写出符合给定的语法分析方法的文法及属性文法.（2）完成题目请求的两头代码四元式的描述.（3）写出给定的语法分析方法的思想，完成语法分析和语义分析程序设计.（4）编制好分析程序后，设计若干用例，上机测试并通过所设计的分析程序.（5）设计陈述格式按附件请求书写.课程设计陈述书注释的内容应包含：1 零碎描述（成绩域描述）；2 文法及属性文法的描述；3 语法分析方法描述及语法分析表设计；4 按给定的题目给出两头代码方式的描述及两头代码序列的结构设计；5 编译零碎的概要设计；6 具体的算法描述（流程图或伪代码）；7 软件的测试方法和测试结果；8 研制陈述（研制过程，本设计的评价、特点、缺乏、收获与体会等）；9 参考文献（按公开发表的规范书写）.时间安插：设计安插一周：周1、周2：完成零碎分析及设计.周3、周4：完成程序调试及测试.周5：撰写课程设计陈述.设计验收安插：设计周的礼拜五第1节课开始到实验室进行上机验收.设计陈述书收取时间：设计周的次周礼拜一上午10点.指点教师签名： 9月 1日系主任（或义务教师）签名：月日WHILE轮回语句的翻译程序设计（递归降低法、输出四元式）一．零碎描述设计一个WHILE〈布尔表达式〉DO〈赋值语句〉轮回语句的词法﹑语法及语义分析程序，语法分析选择递归降低法，采取用语法制导翻译输出两头代码四元式.设计一个能识别while轮回语句的文法，清除左递归，使文法符合LL(1)文法.利用递归降低法编写一个集词法分析，语法分析和语义分析为一体的程序.该程序首先可以检查输入语句是否符合词法请求，若符合则继续识别输入的语句是否符合while语句的文法，若符合则进行语义分析，输出用四地址代码暗示的两头代码.二．文法及属性文法的描述2.1 文法的描述扩充巴科斯瑙尔范式（EBNF）：<while语句> ::= while (<条件语句>) do{ <赋值语句> }<条件语句> ::= <表达式><条件运算符> <表达式><表达式> ::= <表达式> + <表达式2> | <表达式> <表达式2> | <表达式2><表达式2>::=<表达式2> * <表达式3> |<表达式2> / <表达式3> | <表达式3><表达式3>::=(<表达式>) | <标识符>|<数字><赋值语句>::=<标识符>=<表达式>；根据以上写出来的While轮回语句的文法暗示如下：1.S > while (A) do {B}2.A > CDC3.D > > | = | < | >= |<=4.C > C+E | CE | E5.E > E*F | E/F | E6.F > (C) | i | n对以上文法清除左递归，最初得到的文法为：1.S>while (A) do {B}2.A>CDC3.D> > | = | < | >= | <=4.C>EG5.G>+EG | EG | ε6.E>FH7.H>*FH | / FH | ε8.F>(C) | i | n9.B>i=C；(1)任一非终结符B都不是左递归的，否则会发生死轮回.(2)对A的任意两个右部βi , βj ,有：first(βi)∩first(βj)=φ，First(βi)表βi所能导出串的第一个符号的集合.明显，每个βi的first(βi)是互不不异的，否则则没法判断应履行哪个ζ(βi ).三．语法分析方法描述3．1语法分析方法描述递归降低法是一种比较简单直观，易于构造的语法分析方法.他请求文法满足LL（1）文法，他的设计思想是对应文法中每个非终结符编写一个递归过程，每个过程的功能是识别由该非终结符推出的单词（或串），当某非终结符的发生式有多个候选时，能够按LL（1）方式可独一地确定选择某个候选进行推导.它的长处是简单直观，易于构造，很多编译零碎所实现缺点是对文法请求很高，因为递归调用多，影响分析器的效力.递归降低程序是由一组子程序构成，每个子程序对应于一个非终结(S,A,B,C,D,E,F,G,H).每个子程序处理响应句型中绝对于此非终结符号的发生式.在定义文法时，是递归定义的，所以这些子程序也是递归的.当一个子程序调用另一个子程序时，原子程序顺序履行语句，即老是先履行被调用的子程序，然后再履行后继的程序.程序中9个子程序，其中S 是开始符号，也是递归降低分析的入口，通过调用词法分析器进行单词分析，并通过word=l.Yufa_Queue.front()来得到当前所分析到的单词，然后在递归语法分析中根据这个单词分析下一步要履行的子程序.其中要留意的是，当子程序G()和H()中出现匹配的是空字符串时，不做单词处理，该所取得的单词，应当为下一个匹配发生做筹办.3．2递归降低法实现的道理设A是一个非终结符：A→β1A→β2┊A→βn则写ζ(A) if char∈first(β1 ) thenζ(β1 )else if char∈first(β2 ) then ζ(β2 )else…if char∈first(βn ) then ζ(βn)else ERROR其中ζ(βi)暗示调用途理符号串βi的子程序.对A的任一右部i 设为：βi = y1 y2 … yn则定义ζ( βi) beginζ(y1);ζ(y2);…;ζ(yn) end其中yj可分为以下两种情况（j=1,…,n):1) yj∈VT,则ζ( yj) if char≠ yj then ERROR else READ(char)2) yj∈VN,则ζ(yj)暗示调用关于yj的递归子程序.四．两头代码方式的描述及两头代码序列的结构设计两头代码为四元式，按照请求，要输出四元式一个四元式是一个带有四个域的记录结构，这四个域分别称为op﹑arg1﹑arg2及result.域op包含一个代表运算符的内部码.语句while a<b do a=a+b的四元式输出:1 ( <, a , b , 3 )2 ( j , _ , _ ,6 )3 ( + , a , b , n )4 ( = , n , _ , a )5 ( j , _ , _ , 1)6五．编译零碎的概要设计递归降低分析技术就是通过对每个非终结符编写一个子程序来实现它的操纵，然后通过递归的调用来实现对输入字符串的分析，这其中还包含对输入字符串的词法分析.在词法分析的时，得到的字符单词要和关键字比较，看是否是关键字，根据比较结果进行返回响应的单词类型.单词类型次要包含界限符，关键字，常量，标识符，运算符等，每种符号都是一品种型.在语法分析程序中，根据词法得到的结果，进行判断是否是当前须要的单词类型，如果不是就说明输入字符串不克不及由该文法推导出来；如果是当前须要的类型，就响应得做该单词类型分支程序.根据文法可以得到这个递归降低程序可以分析while语句，在文法的开始符号S开始进行递归调用，是以这个文法的递归中就要考虑到调用和递归.在递归子程序中，在嵌套调用其他子程序时都是有必定条件的，当满足这个条件的时候该程序可以按照满足的条件履行下去，当没有满足程序中的条件时就会显示语法错误.词法分析程序的任务是：从左至右逐一字符地对源程序进行扫描，发生一个个的单词符号，把作为字符串的源程序改形成为单词符号的两头程序.词法分析检查的错误主如果挑出源程序中出现的非法符号.所谓非法符号是指不是程序设计说话中答应出现的符号，就像天然语句中的错字.对每个非终结符A构造一个函数过程，对A的每个继承属性设置一个方式参数，函数的返回值为A的综合属性，A对应的函数过程中，为出此刻A的发生式中的每一个文法符号的每一个属性都设置一个局部变量.非终结符A对应的函数过程中，根据当前的输入符号决定使用哪个发生式候选.每个发生式对应的程序代码中，按照从左到右的次序，对于单词符号，非3：终结符和语义动作分别做以下工作.1.对于带有综合属性x的终结符X，把x的值存入为X，x设置的变量中.然后发生一个匹配X的调用，并继续读入一个输入符号.2.对于每个非终结符号B，发生一个右侧带有函数调用的赋值语句c=B(b1,b2,…，bk)3.对于语义动作，把动作的代码抄进分析器中，用代表属性的变量来代替对应属性的每一次援用.在语法分析过程中，随着分析的步步进展，根据每个发生式所对应的语义子程序（或语义规则描述的语义动作）进行翻译.属性文法的每个符号有属性，所以每个符号入栈时，必须连属性一路入栈，如许，栈符号就由文法符号及存放该符号属性的域所构成.因为属性类型分歧，属性域存放的内容就要根据属性的类型来定.有的可能直接存放属性值，也有的存放的是指向属性值的指针.对于综合属性，其属性域不存放其属性值，而是存放一个指针，指向存贮该属性值的单元.对于继承属性，其属性域直接保管其属性值.继承属性的属性域刚入栈时为空，但是在该栈符号酿成栈顶符号之前的某一时刻，它们必须接受响应的属性值，即在成为栈顶时，继承属性的属性域必须有值.六．具体的算法描述S()W()E F()D()G()R()T()方法和变量的定义做W（）：做E（）：做F（）F > < | = | > | <= | >=做Do_G G> c=R对赋值语句进行四元式输出：七．软件的测试方法和测试结果输入 while（a>b）{z=x+y;}测试结果如下：输入while(a>b){z=x+y*c;} 测试结果如下输入wh(a>b){z=y;} 结果为：输入while(a>b){z=z+y} 结果为：八．研制陈述（研制过程，本设计的评价、特点、缺乏、收获与体会等）在做本次实验之前我对LL(1)文法的构成,递归降低道理不是很了解,在查阅了相干材料后,对此有了深入了解.将词法分析，语法分析，两头说话翻译结合到一路.8.2 设计的评价、特点、缺乏设计的程序基本上实现了用递归降低分析法实现了while语句的翻译，并能够用四元式将其输出，使人了如指掌.程序还能够精确提示词法和语法错误.同时程序运转时简单明了，易于使用.深入了解计算机说话编译和运转的过程，对编译道理有了深刻的认识，把握了递归降低法，熟练地使用四元式两头代码，明白了对于编写程序，解题的思路为次要.在编写程序之前，如果没有比较清晰的思路，根本不成能编出好的程序.就算马马虎虎的编出来，程序的逻辑性、健壮性、完美性、合理性也不会很强.在编程之前，我们应反复研讨题目请求，对题目涉及的情况进行比较充分的分析，以便编写出更加符合题意的程序；其次要充分考虑各种临界情况，对一些错误的输入进行处理.是以在我们编程序之前必定要做好充分的筹办，首先要理清本人的思路，然后再将思路分划成几个模块，逐块的写好算法，最初再将所有的模块无机的联系起来，构成一个完好的程序.在成功通过编译的情况下，对程序运转的结果进行零碎的分析，检验其精确性，如果有错误，应立即去分析源程序的逻辑错误，直到得到精确的结果.九．参考文献《编译道理第2版》清华大学出版社张素琴等著本科生课程设计成绩评定表注：终极成绩以五级分制记.优（90100分）、良（8089分）、中（7079分）、及格（6069分）、60分以下为不及格指点教师签名：201 年月日。
编译原理课程设计——算术表达式、for、while语句转换为四元式
计算机与信息学院《操作系统与编译原理联合课程设计报告》专题：编译原理部分学生姓名：学号：专业班级：指导教师：2014 年 7 月一、设计目标设计一个语法制导翻译器，将算术表达式、for语句、while语句翻译成四元式。
要求先确定一个定义算术表达式、for语句、while语句的文法，为其设计一个语法分析程序，为每条产生式配备一个语义子程序，按照一遍扫描的语法制导翻译方法，实现翻译程序。
对用户输入的任意一个正确的表达式，程序将其转换成四元式输出。
二、设计思路开发平台：Visual C++ MFC解决这个问题的方案分为以下几个步骤：1.将算数表达式、for语句、while语句转换为四元式的第一步为对读入的表达式进行处理，即删除不必要的空格、回车、换行等，保证之后的步骤能够顺利进行。
2.分析算术表达式、for语句、while语句的文法。
3.通过词法分析判断语句中的每个字符的类型，如：数字、字母、符号等。
4.建立每种文法的LR(0)分析表，通过每个文法的LR(0)分析表对相应的表达式进行语法分析。
5.在语法分析正确的情况下，通过语法分析的中间过程的符号栈输出四元式，四元式的形式为：（op arg1 arg2 result）。
（一）算术表达式转换为四元式将算术表达式转换为四元式首先考虑了括号的问题，对于不同的算术表达式第一步进行词法分析，即确定各种符号的位置。
而括号中的式子是优先级最高的，应该最先进行处理。
我使用了一个数组记录算术表达式中括号的位置，并且定义了first_cc和first_jj函数对括号内的乘除法和加减法分别进行处理。
后将括号内的式子以四元式的形式输出。
通过以上转换，已将原算术表达式中的括号中的内容使用大写字母’A’、’B’……等代替（其中定义声明了change函数，用来将括号部分替换为大写字母）。
新的式子中，只含有加减乘除以及赋值这四种运算，后根据优先级的不同，逐步生成四元式。
其算法流程图如右图所示。
附录：语义子程序(四元式)
N
{ N.nextlist := makelist(nextquad) ;
emit (j ,,,)}
M
{ M.quad := nextquad }
SifE then M S1
{ backpatch (E.truelist, M.quad) ;
{ E.truelist := E1.falselist ;
E.falselist := E1.truelist }
E( E1)
{ E.truelist := E1.truelist ;
E.falselist := E1.falselist }
Eid1relop id2
{ E.truelist := makelist ( nextquad ) ;
E
{place := newtemp;
emit (uminus,place,,place) }
E)
{place :=place}
Eid
{place :=entry(id)}
2．布尔表达式的翻译模式
产生式
翻译模式
Eor M
{ backpatch (falselist, M.quad) ;
E.truelist :=merge( E1.truelist, E2.truelist ) ;
E.falselist := makelist ( nextquad + 1 ) ;
emit (jrelop.op,id1.place,id2.place,0) ;
emit (j,,, 0) }
Eid
{ E.truelist := makelist ( nextquad ) ;
编译原理_国防科技大学中国大学mooc课后章节答案期末考试题库2023年
编译原理_国防科技大学中国大学mooc课后章节答案期末考试题库2023年1.对于文法G(S')，该文法识别活前缀的DFA如下图，状态I5包含的项目有G(S')：(0) S' → S(1) S → iSeS(2) S → iS(3) S → a【图片】答案:S → iSeŸS_S → ŸiSeS_S → ŸiS_S → Ÿa2.(a+b)/(c-d)对应的逆波兰式(后缀式)是答案:ab+cd-/3.表达式(a+b)/c-(a+b)*d对应的间接三元式表示如下，其中三元式表中第(3)号三元式应为间接码表三元式表(1) OP ARG1 ARG2 (2) (1) + a b (1) (2) / (1)c (3) (3) (4) (4) - (2) (3)答案:( *, (1), d)4.设AS 为文法的综合属性集, AI 为继承属性集, 则对于下面的属性文法G(P)定义中，AS和AI正确描述是产生式语义规则P → xQR Q.b:=R.d R.c:=1R.e:=Q.a Q → u Q.a:=3 R → v R.d:=R.c R.f:=R.e答案:AS={ Q.a, R.d, R.f } AI={ Q.b, R.c, R.e }5.考虑下面的属性文法G（S）【图片】过程enter(name, type)用来把名字name填入到符号表中，并给出此名字的类型type。
按照该属性文法，关于语句【图片】 , 【图片】 , 【图片】:integr的语义描述准确的是答案:说明 , , 是integer变量，把 , , 三个名字填入符号表中，并在类型栏中填上integer6.考虑下面的属性文法G(S)【图片】对于输入字符串abc进行自下而上的语法分析和属性计算，设S.u的初始值为5，属性计算完成后，S.v的值为答案:187.关于属性文法，下列说法中正确的是答案:属性文法是对上下文无关文法的扩展。
编译原理E课内实践报告：WHILE循环语句的翻译程序设计与实现,递归下降法,输出四元式
文法及属性文法的描述 ............................................................................................... 2 2.1 2.2 文法描述 ............................................................................................................. 2 属性文法描述 ..................................................................................................... 3
2.2 属性文法描述
形式上讲，属性文法是一个三元组 :A=(G，V，F)， 其中： ➢ G:是一个上下文无关文法； ➢ V:有穷的属性集,每个属性与文法的一个终结符或非终结符相连 ,这些属性代表与 文法符号相关信息； ➢ F:关于属性的属性断言或一组属性的计算规则(称为语义规则) 。 断言或语义规则 与一个产生式相联,只引用该产生式左端或右端的终结符或非终结符相联的属性。 属性文法中的属性分成两类：继承属性和综合属性。 ➢ 综合属性（synthesized attribute） ：如果 b 是 A 的属性，c1 , c2 , …, ck 是产生式右 部文法符号的属性或 A 的其它属性，则称 b 是文法符号 A 的综合属性。 ➢ 继承属性(inherited attribute)：如果 b 是产生式右部某个文法符号 X 的属性，并且 c1,c2,…,ck 是 A 或产生式右部文法符号的属性， 则称 b 是文法符号 X 的继承属性。
3
《编译原理》考试试题及答案
《编译原理》考试试题及答案《编译原理》考试试题及答案（附录）⼀、判断题：1.⼀个上下⽂⽆关⽂法的开始符，可以是终结符或⾮终结符。
( X )2.⼀个句型的直接短语是唯⼀的。
( X )3.已经证明⽂法的⼆义性是可判定的。
（X ）4.每个基本块可⽤⼀个DAG表⽰。
（√）5.每个过程的活动记录的体积在编译时可静态确定。
（√）型⽂法⼀定是3型⽂法。
（x ）7.⼀个句型⼀定句⼦。
( X )8.算符优先分析法每次都是对句柄进⾏归约。
(应是最左素短语) ( X )9.采⽤三元式实现三地址代码时，不利于对中间代码进⾏优化。
（√）10.编译过程中，语法分析器的任务是分析单词是怎样构成的。
( x )11.⼀个优先表⼀定存在相应的优先函数。
( x )12.⽬标代码⽣成时，应考虑如何充分利⽤计算机的寄存器的问题。
( )13.递归下降分析法是⼀种⾃下⽽上分析法。
( )14.并不是每个⽂法都能改写成LL(1)⽂法。
( )15.每个基本块只有⼀个⼊⼝和⼀个出⼝。
( )16.⼀个LL(1)⽂法⼀定是⽆⼆义的。
( )17.逆波兰法表⽰的表达试亦称前缀式。
( )18.⽬标代码⽣成时，应考虑如何充分利⽤计算机的寄存器的问题。
( )19.正规⽂法产⽣的语⾔都可以⽤上下⽂⽆关⽂法来描述。
( )20.⼀个优先表⼀定存在相应的优先函数。
( )型⽂法⼀定是2型⽂法。
( )22.如果⼀个⽂法存在某个句⼦对应两棵不同的语法树，则⽂法是⼆义性的。
( )⼆、填空题：1.( 最右推导)称为规范推导。
2.编译过程可分为（词法分析），（语法分析），（语义分析和中间代码⽣成），（代码优化）和（⽬4.从功能上说，程序语⾔的语句⼤体可分为（）语句和（）语句两⼤类。
5.语法分析器的输⼊是（），其输出是（）。
6.扫描器的任务是从（）中识别出⼀个个（）。
7.符号表中的信息栏中登记了每个名字的有关的性质，如（）等等。
8.⼀个过程相应的DISPLAY表的内容为（）。
9.⼀个句型的最左直接短语称为句型的（）。
DO-WHILE循环语句的翻译程序设计(简单优先法、输出四元式)
（二）DO-WHILE循环语句的翻译程序设计（简单优先法、输出四元式）一、1.简单优先法的基本思想根据优先关系的定义，将简单优先文法中各文法符号之间的这种关系用一个矩阵表示，称作简单优先矩阵。
PDA读入一个单词后，比较栈顶符号和该单词的优先级，若栈顶符号优先级低于该单词，继续读入；若栈顶符号优先级高于或等于读入符号，则找句柄进行归约，找不到句柄就继续读入。
直到最后栈内只剩下开始符号，输入串读到“＃”为止。
此时识别正确。
可分点描述如下:（1）、对句型中相邻的文法符号规定优先关系，以寻找句型中的句柄;（2）、规定句柄内各相邻符号之间具有相同的优先级;（3）、规定句柄两端符号优先级要比位于句柄之外而又和句柄相邻的符号的优先级高，以先归约句柄;（4）、对于文法中所有符号，只要它们可能在某个句型中相邻，就要为它们规定相应的优先关系，若某两个符号永远不可能相邻，则它们之间就无关系.2.简单优先矩阵用于表示文法符号之间的简单优先关系的矩阵。
3.简单优先法的优缺点优点：技术简单,当做简单优先矩阵是要求较短。
缺点：适用范围小，分析表尺寸太大。
二、源代码实现：#include<iostream>#define MAX 35#include<list>#include<string>#include<fstream>using namespace std;#define TABLE_LEN 8#define STR_LEN 256int zhlen;char sTable[TABLE_LEN+1] = {"+-*/()i#"};//顺序索引int ShipTable[TABLE_LEN][TABLE_LEN] = //优先表{{ 1, 1,-1,-1,-1, 1,-1, 1},{ 1, 1,-1,-1,-1, 1,-1, 1},{ 1, 1, 1, 1,-1, 1,-1, 1},{ 1, 1, 1, 1,-1, 1,-1, 1},{-1,-1,-1,-1,-1, 0,-1,-2},{ 1, 1, 1, 1,-2, 1,-2, 1},{ 1, 1, 1, 1,-2, 1,-2, 1},{-1,-1,-1,-1,-1,-2,-1, 0}};char X,a;char VN[11]={'K','L','P','S','E','G','T','R','F','Q','\0'};char VT[15]={'i','=','<','>','+','-','*','/','(',')','d','w',';','#','\0'};charp[18][6]={"dLwS\0","SP\0",";SP\0","\0","iQE\0","TG\0","+TG\0","-TG\0","\0","FR\0","*FR\0","/FR\0","\0","(E)\0","i\0","=\0","<\0",">\0"};char stack[MAX];char queue[MAX];int sp,front;intM[10][14]={ {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,0,-1,-1,-1},{1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,3,2,-1},{4,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1},{5,-1,-1,-1,-1,-1,-1,-1,5,-1,-1,-1,-1,-1},{-1,-1,-1,-1,6,7,-1,-1,-1,-1,-1,8,8, 8},{9,-1,-1,-1,-1,-1,-1,-1,9,-1,-1,-1,-1,-1},{-1,-1,-1,-1,12,12,10,11,-1,-1,-1,12,12,12},{14,-1,-1,-1,-1,-1,-1,-1,13,-1,-1,-1,-1,-1},{-1,15,16,17,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1},};int f=0; int count=0;int c=0;char arr_i[MAX];char var[MAX]; //表格管理int td[MAX]; int t=0;int opd=-1;int opr=-1;int id=0;int d=0;char arr[MAX][4];//存放待输出的四元式//char keyword[2][7]={"do\0","while\0"};bool IsCharInStr(char c,char s[]){for(int i=0;s[i]!='\0';i++){if(s[i]==c)return true;}return false;}int GetIndex(char s[],char c){for(int i=0;s[i]!='\0';i++){if(c==s[i])return i;}return -1;}//string GetSubString(char s[],int from,int to){string st;for(int i=from;i<to;i++){st+=s[i];}return st;}/*******************************************翻译赋值表达式********************************************/void translatefuzhi(char *sInput){//栈结构的初始化char Stack[STR_LEN]={0};int index = 0;int top = 1;Stack[0] = '#';list<char> rPolish;list<string> Num;int begin=0;while(sInput[begin]!='='){if(IsCharInStr(sInput[begin],sTable)){cout<<"Equal expression is illegal!"<<endl;return ;}begin++;}Num.push_back(GetSubString(sInput,0,begin));int now = begin+1;int before = begin;rPolish.push_back('i');while(sInput[now]!='\0'){if(IsCharInStr(sInput[now],sTable)){char temp[3]={0};if(now-before>1){temp[0] = 'i';temp[1] = sInput[now];Num.push_back(GetSubString(sInput,before+1,now));}else{temp[0] = sInput[now];}int i=0;while(temp[i]!=0){int left = GetIndex(sTable,Stack[index]);int right = GetIndex(sTable,temp[i]);switch(ShipTable[left][right]){case -1://移入Stack[top++] = temp[i];index = top-1;i++;break;case 0://脱括号if(Stack[index]=='('){Stack[top++] = ')';Stack[index] = 'E';top = index+1;index--;}else//规约{if(top!=2){return;}rPolish.push_back('=');list<char>::iterator iter;list<string>::iterator siter=Num.begin();string fuzhi[256];int d=0,m;for(iter=rPolish.begin();iter!=rPolish.end();iter++){if(*iter=='i'){fuzhi[d++]=*siter;siter++;}else{fuzhi[d++]=*iter;}}m=d;string op1,op2;int flag,xiabiao=0;for(d=0;d<m;d++)cout<<"("<<fuzhi[d]<<","<<op1<<","<<op2<<","<<"T"<<xiabiao<<")"<<endl;fuzhi[d] = "T";fuzhi[d]+=(xiabiao+'0');xiabiao++;}//cout<<fuzhi[d];}return;}i++;break;case 1://归约if(Stack[index]=='i'){rPolish.push_back('i');Stack[index] = 'E';index--;}else{rPolish.push_back(Stack[index]);Stack[index-1] = 'E';top = index;index-=2;}break;default:return;}}before=now;}now++;}}int len(char str[]){int i=0;while(str[i]!='\0')i++;return i;}int index(char ch,char str[]){int i=0;while(str[i]!='\0'){if(ch!=str[i])i++;else break;}if(str[i]=='\0')return -1;return i;}void err(int n){if(n==1)cout<<"字符不匹配"<<endl;else if(n==2)cout<<"字符没有出现在产生式中"<<endl;else if(n==3)cout<<"没有找到合适的¨选产式"<<endl;else cout<<"该句子是文法语言的句子"<<endl;}void print(){cout<<"(";if(count<10)cout<<'0';cout<<count<<")";int i;for(i=0;i<=sp;i++)cout<<stack[i];for(;i<=20;i++)cout<<" ";for(i=0;i<front;i++)cout<<" ";for(;queue[i]!='#';i++)cout<<queue[i];cout<<queue[i];for(;i<=20;i++)cout<<" ";}void semantic(){if(VT[opr]=='='){arr[d][0]='=';arr[d][1]=arr_i[opd];arr[d][2]=id;arr[d][3] ='--';id++;}elseif(opr==-2){arr[d][0]='=';arr[d][1]=id-1;arr[d][2]=arr_i[opd];arr[d][3]='--';} else {arr[d][0]=VT[opr];arr[d][1]=arr_i[opd];arr[d][2]=id;if(VT[opr]!='<'&&VT[opr]!='>')arr[d][3]=id-1;else arr[d][3]=id+1;id++;} d++;}void syntax(){//语法分析int n;count++;print();X=stack[sp];a=queue[front];if(X=='#'&&a=='#')f=4;if(X<'A'||X>'Z'){if(X==a){sp--;front++;if(a!='i'){if(a!='d'&&a!='w'&&a!=';'&&a!='#'){opr=index(a,VT);semantic();}else if(a==';'||a=='w'||a=='#'){opr=-2;semantic();}cout<<'\t'<<'\''<<a<<"'匹配"<<endl;}else {opd=c;cout<<'\t'<<'\''<<arr_i[c++]<<"'匹配"<<endl;}}else f=1;}else {int tx=index(X,VN);int ta=index(a,VT);n=M[tx][ta];td[t++]=M[tx][ta];if(ta==-1){f=2;cout<<a<<endl;}else if(n==-1)f=3;else {sp--;cout<<'\t'<<X<<"->";if(len(p[n])!=0){for(inti=len(p[n])-1;i>=0;i--){stack[++sp]=p[n][i];cout<<p[n][len(p[n])-1-i];} cout<<endl;}else cout<<"空串"<<endl;}}if(f==0)syntax();else {td[t]='-1';err(f);}}void lexical(){ //词法分析int i,j,d;char ch;j=d=0;for(i=0;var[i]!='#';i++){ch=var[i];if(ch=='d'&&var[i+1]=='o'){cout<<"do"<<'\t'<<"keword"<<endl;queue[j++]='d' ;i+=1;}else if(ch=='w'){ch=var[i+1];if(ch=='h'){ch=var[i+2];if(ch=='i'){ch=var[i+3];if(ch=='l'){ch=var[i+4];if(ch=='e'){ch=var[i+5];}}}}cout<<"while"<<'\t'<<"keyword"<<endl;queue[j++]='w';i+=4;}else if(index(ch,VT)<=0){if(ch!='{'&&ch!='}'&&ch!='('&&ch!=')'){cout<<ch<<'\t'<<"variable:i["<<d++< <"]"<<endl;arr_i[d-1]=ch;queue[j++]='i';}else cout<<ch<<'\t'<<"bound"<<endl;}elseif(index(ch,VT)>0){cout<<ch<<'\t'<<"operator"<<endl;queue[j++]=ch;} }queue[j]='#';for(i=0;queue[i]!='#';i++)cout<<queue[i];cout<<endl;}int main(){int i=0,j=0;int len,length;char temp;char S='K';sp=front=0;stack[0]='#';sp++;stack[1]='K';cout<<" ****************************"<<endl;cout<<" * DO-WHILE循环语句 *"<<endl;cout<<" * (简单优先法输出四元式) *"<<endl;cout<<" ****************************"<<endl;ifstream table;table.open("dowhile.txt");if(!table){cout<<"error!";}table.seekg(0,ios::end);length = table.tellg();table.seekg(0,ios::beg);while(length!=table.tellg()){table.read((char*)&temp,1);var[i]=temp;i++;if(var[i]==' ')i--;if(var[i]=='#')break;}table.close();len=i;var[i]='\0';cout<<"词法分析"<<endl;lexical();char fuzhi[20];int flag1,fuzhilen;int s=0; for(i=0;i<len;i++){if(var[i]==';'){flag1=i;}}fuzhilen=flag1-2;for(i=3;i<flag1;i++){fuzhi[s++]=var[i];}fuzhi[s]='#';char shuru;char zh[100];int kaishi=0;zh[0]='d';for(kaishi=1;kaishi<s+1;kaishi++){zh[kaishi]=fuzhi[kaishi-1];}zh[kaishi++]=';';zh[kaishi++]='W';for(i=flag1+8;i<len;i++){if(var[i]=='}')break;else{zh[kaishi++]=var[i];}}zh[kaishi++]='#';zhlen=kaishi;cout<<"输出四元式"<<endl;cout<<"do"<<endl;translatefuzhi(fuzhi);cout<<"("<<var[flag1+9]<<","<<var[flag1+8]<<","<<var[flag1+10]<<","<<"T2"< <")"<<endl;cout<<"if T2=true goto T0"<<endl;return 0;}三、测试结果：词法分析部分：输出四元式：四、课程小结：这次编译原理课程设计的题目是用简单优先分析法进行DO-WHILE循环语句的语法分析,并输出四元式.设计的特点是利用定义每个终极符和非终极符之间优先关系,来进行符号的移进与规约,如果栈顶符号优先级低于该单词，继续读入；若栈顶符号优先级高于或等于读入符号，则找句柄进行归约，找不到句柄就继续读入。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
例1：语法制导翻译下列语句为四元式形式：
while x < y do
if a > b then x:= x + 1 else x := y
语法制导翻译生成四元式
栈内容输入串
语义规则（生成四元式）
#whileM1x<y do if a>b then x:=x+1 else y:=x#
M1.quad=100P195产生式（3）
#whileM1x<y do if a>b then x:=x+1 else y:=x#
#whileM1E1doif a>b then x:=x+1 else y:=x#
100（j<，x，y，0）
（E1.t_l=100；
E1.f_l=101；）101（j，_，_，0）
#whileM1E1doM2if a>b then x:=x+1 else y:=x#
M2.quad=102 P195产生式（3）
#whileM1 E1doM2 if a>b then x:=x+1 else y:=x#
#whileM1E1doM2if E2then x:=x+1 else y:=x#
102（j>，a，b，0）
（E2.t_l=102；E2.f_l=103；）
103（j，_，_，0）
#whileM1E1doM2if E2thenM3x:=x+1 else y:=x# M3.quad=104P195产生式（3）
#whileM1E1doM2if E2thenM3x:=x+1 else y:=x# 104（+，x，1，T）105（:=，T，_，x）
#whileM1E1doM2if E2thenM3S1else y:=x# S1.nextlist=’∧’
#whileM1E1doM2if E2thenM3S1N else y:=x# N.nextlist=106106（j，_，_，0）
#whileM1E1doM2if E2thenM3S1Nelse y:=x# P195 产生式（2）
#whileM1E1doM2if E2thenM3S1Nelse M4y:=x# M4.quad=107P195产生式（3）
#whileM1E1doM2if E2thenM3S1Nelse M4y:=x #
#whileM1E1doM2if E2thenM3S1Nelse M4S2# 107（:=，x，_，y）S2.nextlist=’∧’
#whileM1E1doM2S3# P195产生式（1）
backpatch(E2.t_l，M3.quad)使102（j>, a, b, 104）backpatch(E2.f_l，M4.quad)使103（j, _, _, 107）
S3.nextlist=( S1.nextlist，N.nextlist，S2.nextlist ) 使S3.nextlist=106
#S #
P195产生式（5）
backpatch(S3.nextlist，M1.quad)使106（j, _, _, 100）backpatch(E1.t_l，M2.quad)使100（j<, x, y, 102）S.nextlist:= E1.f_l=101使101（j, _, _, 109）108（j，_，_，M1.quad）使108（j, _, _, 100）
j<，x，y，102
j，_，_，109
j>，a，b，
j，_，_，107
+，x，1，T）
:=，T，_，x
j，_，_，100
:=，x，_，y）
j，_，_，100
例2：语法制导翻译下列语句为四元式形式：
while a < b do
if c < 5 then while x > y do z := x + 1 else x := y
语法制导翻译生成四元式
栈内容输入串
语义规则（生成四元式）
#whileM1a<b do if c<5 then while x>y do z:=x+1 …# M1.quad=100P195产生式（3）
#whileM1a<b do if c<5 then while x>y do z:=x+1 else…#
#whileM1E1do if c<5 then while x>y do z:=x+1 else…# 100（j<, a, b, 0）
（E1.t_l=100；E1.f_l=101；）101（j, _, _, 0）
#whileM1E1doM2if c<5 then while x>y do z:=x+1 else…# M2.quad=102 P195产生式（3）
#whileM1 E1doM2 if c<5 then while x>y do z:=x+1 else…#
#whileM1E1doM2if E2then while x>y do z:=x+1 else x:=y# 102（j<, c, 5, 0）
（E2.t_l=102；E2.f_l=103；）103（j, _, _, 0）
#whileM1E1doM2if E2thenM3while x>y do z:=x+1 else x:=y# M3.quad=104P195产生式（3）
#whileM1E1doM2if E2thenM3whileM4do z:=x+1else x:=y# M4.quad=104P195产生式（3）
#whileM1E1doM2if E2thenM3whileM4x>y do z:=x+1else
x:=y# 104（j>, x, y, 0）105（j, _, _, 0）
#whileM1E1doM2if E2thenM3whileM4E3do z:=x+1else x:=y# （E3.t_l=104；E3.f_l=105；）
#whileM1E1doM2if E2thenM3whileM4E3do M5 z:=x+1else x:=y# M5.quad=106P195产生式（3）
#whileM1E1doM2if E2thenM3whileM4E3doM5z:=x+1 else
x:=y# 106（+, x, 1, T）107（:=, T, _, z）
#whileM1E1doM2if E2thenM3whileM4E3doM5S1else x:=y# S1.nextlist=’∧’
#whileM1E1doM2if E2thenM3S2else x:=y# 108（j, _, _, 104）因M4.quad=104
S1.nextlist为空，不需回填。
backpatch(E3.t_l，M5.quad)使104（j>, x, y, 106）S2.nextlist:=E3.f_l=105
#whileM1E1doM2if E2thenM3S2N elsex:=y# N.nextlist=109109（j, _, _, 0）
#whileM1E1doM2if E2thenM3S2NelseM5 x:=y# M5.quad=110P195产生式（3）
#whileM1E1doM2if E2thenM3S2NelseM5x:=y # 110（:=, x, _, y）S3.nextlist=’∧’
#whileM1E1doM2if E2thenM3S2NelseM5S3 #
#whileM1E1doM2S4
# P195产生式（1）
backpatch(E2.t_l，M3.quad)使102（j<, c, 5, 104）backpatch(E2.f_l，M5.quad)使103（j, _, _, 110）
S4.nextlist=( S2.nextlist，N.nextlist，S3.nextlist )，使109（j, _, _, 105）S4.nextlist=109
#S # P195产生式（5）
backpatch(S4.nextlist，M1.quad)使109（j, _, _, 100）105（j, _, _,100）
backpatch(E1.t_l，M2.quad)使100（j<, a, b, 102）S.nextlist:= E1.f_l=101可使101（j, _, _, 112）
111（j，_，_，M1.quad）即使111（j, _, _, 100）
对上述过程形成的结果,按从后往前顺序依次写出各四元式,得翻译结果如下:
100（j<, a, b, 102）
101（j, _, _, 112）
102（j<, c, 5, 104）
103（j, _, _, 110）
104（j>, x, y, 106）
105（j, _, _,100）
106（+, x, 1, T）
107（:=, T, _, z）
108（j, _, _, 104）109（j, _, _, 100）110（:=, x, _, y）111（j, _, _, 100）112。