翻译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循环语句的语法分析,并输出四元式.设计的特点是利用定义每个终极符和非终极符之间优先关系,来进行符号的移进与规约,如果栈顶符号优先级低于该单词，继续读入；若栈顶符号优先级高于或等于读入符号，则找句柄进行归约，找不到句柄就继续读入。
while循环语句的LR翻译
While循环语句的的LR翻译源代码#include<string>#include <iomanip>#include<iostream>#include <fstream>#include<cctype>#include<stack>#include "conio.h"using namespace std;ofstream coutf("cifa.txt",ios::out);//结果输出至文件cifa.txtofstream couty("yufa.txt",ios::out);//结果输出至文件yufa.txtofstream couts("obj.txt",ios::out);//结果输出至文件obj.txtchar shuru[100],tmp;char sr[100];char b[10],op[10],rop[10];char a[10];int q=0;struct Table{char act_0[10];int act_1[10];int go[4];}action[18];struct sys{char f;char op1;char op2;char result;}equ[10];void Init(){/*--------------- ACTION -----------------------*/action[0].act_0[0]='s'; action[0].act_1[0]=2;action[1].act_0[9]='Z';action[2].act_0[1]='s'; action[2].act_1[1]=3;action[3].act_0[5]='s'; action[3].act_1[5]=5;action[4].act_0[2]='s'; action[4].act_1[2]=6;action[5].act_0[2]='r'; action[5].act_1[2]=7;action[5].act_0[7]='s'; action[5].act_1[7]=7;action[6].act_0[3]='s'; action[6].act_1[3]=9;action[7].act_0[5]='s'; action[7].act_1[5]=8;action[8].act_0[2]='r'; action[8].act_1[2]=6;action[9].act_0[5]='s'; action[9].act_1[5]=14;action[10].act_0[4]='r'; action[10].act_1[4]=3;action[10].act_0[5]='s'; action[10].act_1[5]=14;action[11].act_0[4]='s'; action[11].act_1[4]=12;action[12].act_0[9]='r'; action[12].act_1[9]=1;action[13].act_0[4]='r'; action[13].act_1[4]=2;action[14].act_0[8]='s'; action[14].act_1[8]=17;action[14].act_0[6]='s'; action[14].act_1[6]=15;action[15].act_0[5]='s'; action[15].act_1[5]=14;action[16].act_0[4]='r'; action[16].act_1[4]=4;action[16].act_0[5]='r'; action[16].act_1[5]=4;action[17].act_0[4]='r'; action[17].act_1[4]=5;action[17].act_0[5]='r'; action[17].act_1[5]=5;/*-------------------- GOTO -------------------------*/action[0].go[0]=1;action[3].go[2]=4;;action[9].go[1]=11;action[9].go[3]=10;action[10].go[1]=13;action[10].go[3]=10;action[15].go[3]=16;}void cifa(){int i=0,j=0,k=0,m=0;for(q=1;q<strlen(sr);q++){tmp=sr[q];if(tmp>='0'&&tmp<='9'||tmp>='a'&&tmp<='z'||tmp>='A'&&tmp<='Z') a[i++]=tmp;else if(tmp=='+'||tmp=='-'||tmp=='/'||tmp=='*')op[j++]=tmp;else if(tmp=='>'||tmp=='<')rop[k++]=tmp;else if(tmp=='('||tmp==')'||tmp=='{'||tmp=='}'||tmp==';')b[m++]=tmp;}cout<<"词法分析完成,结果输出到文件cifa.txt"<<endl;coutf<<"词法分析结果："<<endl;coutf<<"关键字："<<"w"<<endl;coutf<<"变量名：";for(i=0;i<strlen(a);i++){coutf<<a[i]<<" ";}coutf<<endl;coutf<<"表达式运算符：";for(i=0;i<strlen(op);i++){coutf<<op[i]<<" ";}coutf<<endl;coutf<<"比较运算符：";for(i=0;i<strlen(rop);i++){coutf<<rop[i]<<" ";}coutf<<endl;coutf<<"界符：";for(i=0;i<strlen(b);i++){coutf<<b[i]<<" ";}}void Print_LR(){int i,j;cout<<"LR分析表如下："<<endl;cout<<" ACTION GOTO"<<endl;cout<<"-----------------------------------------------------------------------------"<<endl;cout<<"状态w ( ) { } i op rop ; # S E B A"<<endl;cout<<"------------------------------------------------------------------------------"<<endl;for(i=0;i<18;i++){cout<<setw(3)<<i;for(j=0;j<10;j++)cout<<setw(3)<<action[i].act_0[j]<<setw(2)<<action[i].act_1[j];for(j=0;j<4;j++)cout<<setw(4)<<action[i].go[j];cout<<endl;}cout<<"-------------------------------------------------------------------------------"<<endl;}void LR(){int Tai[50],len=1;int i,j,k,l,m,tmp_n=0,num=0;int X;char temp;char fuhao[50]={"#"};char*W[]={"7","SW(B){E}","EAE","EA","AiPA","Ai;","BiTi","Bi"};num=strlen(shuru);Tai[0]=0;couty<<"状态符号输入串"<<endl;for(i=0;i<num;){j=Tai[len-1];temp=shuru[i];switch(temp){case '+':case '-':case '*':case '/':case '=': temp='P'; break;case '<':case '>': temp='T'; break;}if(temp!='P'&&temp!='T'&&temp!='w')if(temp>='0'&&temp<='9'||temp>='a'&&temp<='z'||temp>='A'&&temp<='Z') temp='i';switch(temp){case 'w': k=0; break;case '(': k=1; break;case ')': k=2; break;case '{': k=3; break;case '}': k=4; break;case 'i': k=5; break;case 'P': k=6; break;case 'T': k=7; break;case ';': k=8; break;case '#': k=9; break;}if(action[j].act_0[k]=='s'){Tai[len++]=action[j].act_1[k];tmp_n=strlen(fuhao)-1;fuhao[++tmp_n]=shuru[i++];for(l=0;l<len;l++)couty<<Tai[l];couty<<setw(20)<<fuhao;couty<<setw(3)<<" ";for(l=i;l<num;l++)couty<<shuru[l];couty<<endl;}else if(action[j].act_0[k]=='r'){X=strlen(W[action[j].act_1[k]])-1;len-=X;for(m=len;m<len+X;m++)fuhao[m]='\0';fuhao[len]=W[action[j].act_1[k]][0];switch(W[action[j].act_1[k]][0]){case 'S':l=0;break;case 'E':l=1;break;case 'B':l=2;break;case 'A':l=3;break;}len+=1;Tai[len-1]=action[Tai[len-2]].go[l];for(l=0;l<len;l++){couty<<Tai[l];}couty<<setw(20)<<fuhao;couty<<" ";for(l=i;l<num;l++)couty<<shuru[l];couty<<endl;}else if(action[j].act_0[k]=='Z'){cout<<"语法分析正确，分析过程输出到文件yufa.txt\n";break;}else{cout<<" 语法分析出错！！"<<endl;cout<<" 按任意键退出！！"<<endl;getch();exit(0);}}}int cmp(char a,char b)//判断优先级{while(a=='*'||a=='/'){switch(b){case '+':case '-':case '=':case ';':return 1;break;case '*':case '/':return 0;break;}}while(a=='+'||a=='-'){switch(b){case '=':case ';':return 1;break;case '*':case '/':case '+':return 0;break;}}while(a=='('){switch(b){case '=':case ';':return 1;break;case '*':case '/':case '+':case '-':return 0;break;}}while(a=='='){switch(b){case ';':return 1;break;case '*':case '/':case '+':case '-':case '=':return 0;break;}}while(a==';'){switch(b){case '*':case '/':case '-':case '=':case ';':return 0;break;}}return 1;}void code(char c[]){stack<char> sf;stack<char> s1;stack<char> s;int i,j=0;sf.push(';');char t[5]={"ABCD"};for(i=0;i<strlen(c);i++){if(isalnum(c[i]))s1.push(c[i]);else if(c[i]==';'){while(sf.top()!=';'){s1.push(sf.top());sf.pop();}}else{loop:if(cmp(c[i],sf.top()))sf.push(c[i]);else{s1.push(sf.top());sf.pop();goto loop;}}}while(!isalnum(s1.top())){s.push(s1.top());s1.pop();}while(!s.empty()){if(s.top()=='+'||s.top()=='-'||s.top()=='*'||s.top()=='/'){equ[j].f=s.top();s.pop();equ[j].op2=s1.top();s1.pop();equ[j].op1=s1.top();s1.pop();equ[j].result=t[j];s1.push(equ[j].result);j++;}else{equ[j].f=s.top();s.pop();s1.pop();equ[j].result=s1.top();s1.pop();equ[j].op2='^';equ[j].op1=equ[j-1].result;}}couts<<"100"<<"("<<"j"<<rop[0]<<","<<a[0]<<","<<a[1]<<","<<"101"<<")"<<endl;for(i=0;i<=j;i++)couts<<"10"<<i+1<<"("<<equ[i].f<<","<<equ[i].op1<<","<<equ[i].op2<<","<<equ[i].result <<")"<<endl;cout<<"输出四元式中间代码序列到文件obj.txt\n";}void main(){cout<<"产生式集合："<<endl;cout<<"(1)S->while(B){E}"<<endl;cout<<"(2)E->AE"<<endl;cout<<"(3)E->A"<<endl;cout<<"(4)A->i op A "<<endl;cout<<"(5)A->i;"<<endl;cout<<"(6)B->i rop i"<<endl;cout<<"(7)B->i"<<endl;Init();Print_LR();char filename[20];cout<<"现在开始编译，请输入文件名："<<endl;cin>>filename;ifstream dic(filename,ios::in);while(!dic.eof()){char m;m=dic.get();sr[q]=m;if(sr[q]=='#'){cout<<"你输入的程序段为\t\n";cout.write(sr,q);break;}q++;}cout<<endl;cout<<" 按回车键进行词法分析"<<endl;getch();cifa();cout<<" 按回车键进行语法分析"<<endl;getch();cout<<endl;for(q=0;q<strlen(sr);q++)shuru[q]=sr[q];LR();int i,j=0;char d[50];for(i=6;sr[i]!='}';i++)d[j++]=sr[i+1];code(d);}。
WHILE循环语句的翻译程序设计(简单优先法、输出四元式)
WHILE循环语句的翻译程序设计（简单优先法、输出四元式）1 需求说明或问题描述1.1 问题描述对C++中while循环语句的理解及分析，通过编译中的词法分析、语法分析、语义分析及中间代码生成等编译过程，用简单优先分析法分析并翻译while语句。
1.2 需求说明1 写出符合给定的语法分析方法的文法及属性文法2 完成题目要求的中间代码四元式的描述3 写出给定的语法分析方法的思想，完成语法分析及语义分析程序设计4 设计若干用例，上机通过测试2 文法及语法设计2.1文法及属性文法：文法G=(V N ,V T ,P ,S)其中V N={S , B, E, C, A, B, P, T} V T={w, (, ), { ,}, i, ;}P={S -> w(B){E}E -> CC -> CAC -> AA -> iPAA -> i;P -> +|-|*|/B -> iTiB-> iT -> >|<|>=|<=|==}2.2 语法分析方法描述及语法分析表设计2.2.1 语法分析方法描述：简单优先分析法是按照文法符号（终极符和非终极符）的优先关系确定句柄的。
基本思想可设计如下，首先根据已知优先文法构造相应优先关系矩阵，并将文法的产生式保存，设置符号栈S，步骤如下：（1）将输入符号串a1a2…a n#依次逐个存入符号栈S中，直到遇到栈顶符号a i的优先性>下一个待输入符号a j为止。
（2）栈顶当前符号a i为句柄尾，由此向左在栈中找句柄的头符号a k,即找到a k-1<a k为止。
（3）由句柄a k...a i在文法的产生式中查找右部为a k…a i的产生式，若找到则用相应左部代替句柄，若找不到则为出错，这时可断定输入串不是该文法的句子。
（4）重复上述（1）、（2）、（3）步骤直到规约完输入符号串，栈中只剩文法的开始符号为止。
编译原理试题及答案(期末复习版)
<编译原理>历年试题及答案一．（每项选择2分，共20分）选择题1．将编译程序分成若干个“遍”是为了_b__。
a.提高程序的执行效率b.使程序的结构更加清晰c.利用有限的机器内存并提高机器的执行效率d.利用有限的机器内存但降低了机器的执行效率2．构造编译程序应掌握__d__。
a.源程序b.目标语言c.编译方法d.以上三项都是3．变量应当c＿。
a.持有左值b.持有右值c.既持有左值又持有右值d.既不持有左值也不持有右值4．编译程序绝大多数时间花在_d___上。
a.出错处理b.词法分析c.目标代码生成d.管理表格5．词法分析器的输出结果是_c___。
a.单词的种别编码b.单词在符号表中的位置c.单词的种别编码和自身值d.单词自身值6．正规式MI和M2等价是指__c__。
a.MI和M2的状态数相等b.Ml和M2的有向弧条数相等。
C.M1和M2所识别的语言集相等 d.Ml和M2状态数和有向弧条数相等7．中间代码生成时所依据的是—c。
a．语法规则b．词法规则c．语义规则d．等价变换规则8．后缀式ab+cd+/可用表达式__b_来表示。
a．a+b/c+d b．(a+b)/(c+d)c．a+b/(c+d)d．a+b+c/d9．程序所需的数据空间在程序运行前就可确定，称为____c_＿管理技术。
a.动态存储b.栈式存储c.静态存储d.堆式存储10.堆式动态分配申请和释放存储空间遵守___d____＿原则。
a.先请先放b.先请后放c.后请先放d.任意二（每小题10分，共80分）简答题1.画出编译程序的总体结构图，简述各部分的主要功能。
2.已知文法G[E]:E→ET+|T T→TF*|F F→F^|a试证：FF^^*是文法的句型，指出该句型的短语、简单短语和句柄.3．为正规式(a|b)*a(a|b)构造一个确定的有限自动机。
4．设文法G(S)：S→(L)|a S|aL→L，S|S(1)消除左递归和回溯；(2)计算每个非终结符的FIRST和FOLLOW；(3)构造预测分析表。
WHILE循环语句的翻译程序设计(LR方法、输出四元式)资料
目录课程设计任务书 (1)1系统描述 (2)2文法及属性文法描述 (2)2.1文法的描述 (2)2.2属性文法的描述 (2)3语法分析方法描述及语法分析表设计 (2)3.1语法分析表设计 (2)3.1.1文法的DFA (3)3.1.2LR(0)分析表 (4)3.1.3LR(0)分析方法描述说明 (4)4中间代码形式的描述及中间代码序列的结构设计 (4)5编译系统的概要设计 (5)5.1词法分析 (5)5.2语法分析 (6)5.3语法制导翻译 (7)6详细的算法描述 (8)7 软件的测试方法和测试结果 (14)8小结与体会 (18)9参考文献 (18)本科生课程设计成绩评定表 (20)课程设计任务书学生姓名：王世创专业班级：计算机0909班指导教师：高曙工作单位：计算机科学与技术学院题目: WHILE循环语句的翻译程序设计（LR方法、输出四元式）初始条件：理论：学完编译课程，掌握一种计算机高级语言的使用。
实践：计算机实验室提供计算机及软件环境。
如果自己有计算机可以在其上进行设计。
要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求）（1）写出符合给定的语法分析方法的文法及属性文法。
（2）完成题目要求的中间代码四元式的描述。
（3）写出给定的语法分析方法的思想，完成语法分析和语义分析程序设计。
（4）编制好分析程序后，设计若干用例，上机测试并通过所设计的分析程序。
（5）设计报告格式按附件要求书写。
课程设计报告书正文的内容应包括：1 系统描述（问题域描述）；2 文法及属性文法的描述；3 语法分析方法描述及语法分析表设计；4 按给定的题目给出中间代码形式的描述及中间代码序列的结构设计；5 编译系统的概要设计；6 详细的算法描述（流程图或伪代码）；7 软件的测试方法和测试结果；8 研制报告（研制过程，本设计的评价、特点、不足、收获与体会等）；9 参考文献（按公开发表的规范书写）。
时间安排：设计安排一周：周1、周2：完成系统分析及设计。
编译原理-语法分析生成四元式
学号1406410107 成绩编译原理上机报告名称：语法分析生成四元式学院：信息与控制工程学院专业：计算机科学与技术班级：计算机1401班*名：***2016年11月11日一、上机目的（a）根据算符优先分析算法，编写一个分析对象的语法分析程序。
读者可根据自己的能力选择以下三项(由易到难)之一作为分析算法中的输入：Ⅰ：通过构造算符优先关系表，设计编制并调试一个算法优先分析程序Ⅱ：输入FIRSTVT，LASTVT集合，由程序自动生成该文法的算符优先关系矩阵。
Ⅲ：输入已知文法，由程序自动生成该文法的算符优先关系矩阵。
（b）程序具有通用性，即所编制的语法分析程序能够使用于不同文法以及各种输入单词串，并能判断该文法是否为算符文法和算符优先文法。
（c）有运行实例。
对于输入的一个文法和一个单词串，所编制的语法分析程序应能正确地判断，此单词串是否为该文法的句子，并要求输出分析过程。
二、基本原理和上机步骤1.借用实验二的结果，可将其中的取字符函数几乎原封不动地移植过来，其中的分割和分析单词的方法可借用过来分割现在这个实验的运算符、常量和变量。
2.模块结构：（1）初始化：设立算符优先关系表（或优先函数）、初始化变量空间（包括堆栈、结构体、数组、临时变量等）；（2）控制部分：将一个表达式从文件中读出；（3）词法分析：将表达式分割成单词序列；（4）利用算符优先文法进行表达式处理：根据算符优先关系表（或优先函数）对表达式单词序列进行堆栈（或其他）操作，得到并保存四元组，如果遇到错误则显示错误信息；（5）输出四元组。
三、上机结果程序清单：#include<stdio.h>#include<stdlib.h>#define MAX 100void SET_Mul_Div(int i,int m);void SET_Add_Sub(int j,int m);void print();int m=0;int count=0;char tempvar='A';int temp;char string[MAX]; //用于存放表达式int main() {i nt p[MAX];c har ch;i nt c=-1,q=0;p rintf("请输入赋值语句:\n");w hile((ch = getchar())!='\n') {string[m++]=ch;if(ch=='='||ch=='+'||ch=='-'||ch=='*'||ch=='/')count++;else if(ch=='(') {p[++c]=m-1; }else if(ch==')'){q=m-1;SET_Mul_Div(p[c],q); //从左括号处理到又括号SET_Add_Sub(p[c],q);temp=(int)tempvar-1;tempvar=(char)temp;string[p[c]]=string[m-1]=tempvar;c--;temp=(int)tempvar+1;tempvar=(char)temp; }}/********调用生成四元式的函数********/p rint();/*********判断是否成功**********/i f(count==0)printf("Successful！\n");e lseprintf("Wrong！");p rintf("\n");s ystem("pause");}void SET_Mul_Div(int i,int m) //处理乘除运算{for(i++;i<=m-1;i++){i f(string[i]=='*'||string[i]=='/') {printf("(%c %c %c %c)\n",string[i],string[i-1],string[i+1], tempvar);string[i-1]=string[i]=string[i+1]=tempvar;count--;temp=(int)tempvar+1;tempvar=(char)temp;}}}void SET_Add_Sub(int j,int m) //处理加减运算{j++;for(;j<=m-1;j++){i f(string[j]=='+'||string[j]=='-') {printf("(%c %c %c %c)\n",string[j],string[j-1],string[j+1],tempvar);string[j-1]=string[j]=string[j+1]=tempvar;count--;temp=(int)tempvar+1;tempvar=(char)temp; }}}/*打印*/void print(){i nt i;f or(i=0;i<=m-1;i++)//处理乘除运算{if(string[i]=='*'||string[i]=='/'){printf("(%c %c %c %c)\n",string[i],string[i-1],string[i+1],tempvar);string[i-1]=string[i]=string[i+1]=tempvar;count--;temp=(int)tempvar+1;tempvar=(char)temp;}}i nt j;f or(j=0;j<=m-1;j++)//处理加减运算{if(string[j]=='+'||string[j]=='-'){printf("(%c %c %c %c)\n",string[j],string[j-1],string[j+1],tempvar);string[j-1]=string[j]=string[j+1]=tempvar;count--;temp=(int)tempvar+1;tempvar=(char)temp;}}i nt k;f or(k=0;k<=m-1;k++) //处理赋值运算{if(string[k]=='='){temp=(int)tempvar--;tempvar=(char)temp;printf("(%c %c %c) \n",string[k],string[k+1], string[k-1],tempvar);count--;string[k-1]=tempvar; }}}屏幕截图：四、讨论与分析通过本次实验我完成生成四元式的语法分析程序，掌握的结合语法分析实现翻译方案的思路和方法。
if和while语句的翻译
(3)混用布尔与算术表达式，如(a&&b)+c
见“简单C编译器.ppt”
Expression分为算术和布尔表达式，
算术表达式：+ - * /构成
布尔表达式: && || & |构成
（可以像Java一样分开处理，也可以像C语言一样合在一起处理
Java在这方面的处理更安全些，可避免以下错误
inta = 3;
if(a = 4){//本意是判断a是否等于4，结果写成了a=4
}
）
//翻译完statement，要产生一条Jmp跳回while的开始位置，重新进行判断
//同时，可知statement中出口未知的四元式也应跳往while的开始位置
//回填出口的功能由myc中的backpatch来完成
(2)布尔表达式置于if和while中
& |非短路运算把&看成*把|看成+，类似于算术表达式的翻译
翻译需要用到的四元式代码形如：
29:Jtrue 3 0 31//若3号内存单元为真，跳往31号四元式
30:Jmp 0 0 35//跳往35号四元式
(1)先考虑把算术表达式当布尔值用C语言支持，Java不支持
int a = 1;
int b = 2;
// if问题：if为假跳往何处？
if(a){
a =f(a){
a = 30;//问题:此处如何处理？要跳往何处？
}else{
a =40;
}
// while问题：while为假跳往何处？
while(a){
a = a-1;
}
控制语句的翻译四元式例题及答案
控制语句的翻译四元式例题及答案
1. 例题：if语句
高级语言代码：
python
if x > 5:
y = x + 10
else:
y = x - 10
翻译四元式：
1: if x > 5 goto 4
2: y = x + 10
3: goto 5
4: y = x - 10
5: (end if)
答案解析：
- 第1行表示条件判断，如果x大于5，则跳转到第4行执行。
- 第2行为if语句为真时的语句，将x加10赋值给y。
- 第3行为跳转到if语句结束位置的标记。
- 第4行为if语句为假时的语句，将x减10赋值给y。
- 第5行为if语句结束位置的标记。
2. 例题：while循环语句
高级语言代码：
python
while x > 0:
y = y + x
x = x - 1
翻译四元式：
1: (start while)
2: if x > 0 goto 4
3: goto 5
4: y = y + x
5: x = x - 1
6: goto 2
7: (end while)
答案解析：
- 第1行为while循环的起始位置。
- 第2行为条件判断，如果x大于0，则跳转到第4行执行循环体内的语句。
- 第3行为否则跳转到while循环结束位置的标记。
- 第4行为循环体内的语句，将y加上x的值。
- 第5行为循环体内的语句，将x减1。
- 第6行为跳转回while循环起始位置的标记。
- 第7行为while循环结束位置的标记。
6-7--程序控制语句翻译举例
{BackPatch ($1.Chain, NXQ);
GEN(return , 0, 0, 0);}
其中，四元式（return ,0,0,0）将控制返回主程序。但若 此过程本身就是主程序，则return四元式最后应被“中止 程序运行”的系统调用所代替。对于前者，最后所得的四 元式表见下页
100 j< , a, b, 102 Statement.Chain→ 101 j , 0, 0, 0
102 j> , c, d, 104 103 j , 0, 0, 100 104 + ， y, z, T 105 = , T, 0, x 106 j , 0, 0,100 NXQ→107
8
第十步 最后应当提及，若忽略程序中的说明部分，则可 将一个过程视为上述文法的一个语句。此时应考虑补充 如下产生式及语义动作：
WED. LSP → WED.Chain→
NXQ→
100 j<, a, b, 102 101 j, 0, 0, 0 102
3
第四步 对当前句型 WED if (c>d) then x:=y+z 的关系表达式c>d，用类似于第二步的方法进行 归约和处理后，四元式表为
WED.LSP→ 100 j< , a, b, 102 WED.Chain→ 101 j , 0, 0, 0 Expr.TC→ 102 j>, c, d, 0 Expr.FC→ 103 j , 0, 0, 0
E.TC→ 100 j<, a, b, 0 ←Wl.LSP
E.FC→ 101 j, 0, 0, 0
NXQ→ 102
2
第三步 当前句型为
Wl Expr do if(c>d) then x:=y+z 此时，语法分析及翻译将按如下的产生式进行归 约和处理
翻译while生成四元式--2例
例1：语法制导翻译下列语句为四元式形式：while x < y doif 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，102j，_，_，109j>，a，b，j，_，_，107+，x，1，T）:=，T，_，xj，_，_，100:=，x，_，y）j，_，_，100例2：语法制导翻译下列语句为四元式形式：while a < b doif 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+1elsex:=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 elsex:=y# 106（+, x, 1, T）107（:=, T, _, z）#whileM1E1doM2if E2thenM3whileM4E3doM5S1else x:=y# S1.nextlist=’∧’#whileM1E1doM2if E2thenM3S2else x:=y# 108（j, _, _, 104）因M4.quad=104S1.nextlist为空，不需回填。
- 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。