《编译原理-龙书》练习第2章

最新推荐文章于 2022-12-27 10:25:24 发布
最新推荐文章于 2022-12-27 10:25:24 发布
阅读量5.2k 收藏 26
点赞数 4
分类专栏： 编译原理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/buck84/article/details/8253309
版权
本文详细探讨了《编译原理》第二章的内容，包括语法定义、语法制导翻译、语法分析和词法分析。重点讲解了后缀表达式的生成，无二义性文法的识别，以及罗马数字的上下文无关文法。同时，介绍了如何进行语法制导翻译，以及转换为中缀和前缀表达式的方法，并讨论了词法分析中的注释和错误处理策略。
摘要由CSDN通过智能技术生成

第2章 一个简单的语法制导翻译器

2.2 语法定义

主要描述了“上下文无关文法”

2.2.1 

1）

S1 = aa+

S2 = S1a*

2）              *

          +

a  a        a

3）该文法生成的语言是由+和*组成的后缀表达式，怎么证明呢？

2.2.2 同不懂怎么证明

1）前面n个0后面n个1组成的串

2）+/-组成的关于a计算的前缀表达式

3）空串或成对出现的单个或嵌套括号组成的表达式

4）空串或a和b组成的任意表达式

5）由+连接起来的1个或多个a，可以加括号，每个a后面可以有0个或多个*

2.2.3

1）没有二义性

2）有，跟例2.1中语法一样

3）没有

4）有，ab可以随意结合

5）有，S+S和SS无法确定如何结合

2.2.4

1）S -> SS+|SS-|SS*|SS/|a

2）left -> left,expr | expr

3）right -> expr,right|expr

4）这道题中文版翻译有误，应该将书中“标识符”去掉。

expr -> expr+term | expr-term|term

term -> term*factor | term/factor|fa

最低0.47元/天 解锁文章
buck
关注
  • 4
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
编译原理 龙书 第二章 一个简单的算术式（+，-）翻译器实现
ggzk1995的专栏
06-10 824
昨天晚上决定正面硬刚神课《编译原理》。硬上龙书。    下面是 一个简单的算术式中缀变后缀的翻译器。       这个也是 龙书中 一个C实现源码 。部分用c++改写。#include #include #include #include using namespace std; int lookahead; void error()//错误处理 { cout<<"erro
编译原理-龙书-习题答案
07-23
第二章部分习题答案 2.1 考虑文法 S→ S S + | S S * | a 证明文法可生成符号串 a a + a * 解：S→ S S * → S S + S * →a S + S * → a a + S *→ a a + a * 为此符号串构造语法树 解： 文法生成什么样的语言？...
编译原理 龙书 第二章 答案
09-23
编译原理 龙书 第二章 答案 不是非常全的版本 希望能有帮助
编译原理 龙书 答案 第二章 a2
09-23
编译原理 龙书 答案 第二章 不算非常详细 希望能有帮助
【编译原理】龙书 第二章课后题答案
热门推荐
韬霖笔记
01-05 1万+
Exercises for Section 2.2 2.2.1 Consider the context-free grammar: S -> S S + | S S * | a Show how the string aa+a* can be generated by this grammar. Construct a parse tree for this string. What l...
编译原理 龙书 第二章部分作业 2.2.1~2.2.3
菱形继承
03-09 850
这里给出 3)、4)二义性的反例，读者可自行去画两棵分析树： 3)：（）（） 4)： abab
编译原理--龙书
10-11
第2章 词法分析 21 2.1 扫描处理 21 2.2 正则表达式 23 2.2.1 正则表达式的定义 23 2.2.2 正则表达式的扩展 27 2.2.3 程序设计语言记号的正则表达式 29 2.3 有穷自动机 32 2.3.1 确定性有穷自动机的定义 32 ...
编译原理（龙书英文版第二版）.rar
07-26
编译原理的经典教程，英文版，文字版pdf。本书深入讨论了编译器设计的重要主题，包括词法分析、语法分析、语法制导分析、类型检查、运行环境、中间代码生成、代码生成、代码优化等，并在最后两章中讨论了实现编译器...
龙书 编译原理练习答案 第二版
03-16
这个压缩包中的内容主要是针对《编译原理》第二版的习题答案和书中lexer（词法分析器）的源码。尽管缺失了第9、10和11章的答案，但其他章节的习题解答仍能为读者提供大量实践指导。以下是这些知识点的详细介绍： 1....
编译原理龙书答案第三章第四章
04-27
《编译原理》一书，通常被称为“龙书”...总结来说，"编译原理龙书答案第三章第四章"是关于词法分析和语法分析理论及实践的宝贵资源，通过Homework系列文件，学习者可以深入理解和掌握这两个关键阶段的编译器设计技术。
编译原理龙书答案
05-13
编译原理龙书答案 完整性高 第二章 2.2 Exercises for Section 2.2 2.2.1 Consider the context-free grammar: S -> S S + | S S * | a Show how the string aa+a* can be generated by this grammar. Construct a parse tree for this string. What language does this grammar generate? Justify your answer. answer S -> S S * -> S S + S * -> a S + S * -> a a + S * -> a a + a * L = {Postfix expression consisting of digits, plus and multiple signs} 2.2.2 What language is generated by the following grammars? In each case justify your answer. S -> 0 S 1 | 0 1 S -> + S S | - S S | a S -> S ( S ) S | ε S -> a S b S | b S a S | ε ⧗ S -> a | S + S | S S | S * | ( S ) answer L = {0n1n | n>=1} L = {Prefix expression consisting of plus and minus signs} L = {Matched brackets of arbitrary arrangement and nesting, includes ε} L = {String has the same amount of a and b, includes ε} ？ 2.2.3 Which of the grammars in Exercise 2.2.2 are ambiguous answer No No Yes Yes Yes 2.2.4 Construct unambiguous context-free grammars for each of the following languages. In each case show that your grammar is correct. Arithmetic expressions in postfix notation. Left-associative lists of identifiers separated by commas. Right-associative lists of identifiers separated by commas. Arithmetic expressions of integers and identifiers with the four binary operators +, - , *, /. answer 1. E -> E E op | num 2. list -> list , id | id 3. list -> id , list | id 4. expr -> expr + term | expr - term | term term -> term * factor | term / factor | factor factor -> id | num | (expr) 5. expr -> expr + term | expr - term | term term -> term * unary | term / unary | unary unary -> + factor | - factor factor - > id | num | (expr) 2.2.5 Show that all binary strings generated by the following grammar have values divisible by 3. Hint. Use induction on the number of nodes in a parse tree. num -> 11 | 1001 | num 0 | num num Does the grammar generate all binary strings with values divisible by 3? answer prove any string derived from the grammar can be considered to be a sequence consisting of 11, 1001 and 0, and not prefixed with 0. the sum of this string is: sum = Σn (21 + 20) * 2 n + Σm (23 + 20) * 2m = Σn 3 * 2 n + Σm 9 * 2m It is obviously can divisible by 3. No. Consider string "10101", it is divisible by 3, but cannot derived from the grammar. Question: any general prove? 2.2.6 Construct a context-free grammar for roman numerals. Note: we just consider a subset of roman numerals which is less than 4k. answer wikipedia: Roman_numerals via wikipedia, we can categorize the single noman numerals into 4 groups: I, II, III | I V | V, V I, V II, V III | I X then get the production: digit -> smallDigit | I V | V smallDigit | I X smallDigit -> I | II | III | ε and we can find a simple way to map roman to arabic numerals. For example: XII => X, II => 10 + 2 => 12 CXCIX => C, XC, IX => 100 + 90 + 9 => 199 MDCCCLXXX => M, DCCC, LXXX => 1000 + 800 + 80 => 1880 via the upper two rules, we can derive the production: romanNum -> thousand hundred ten digit thousand -> M | MM | MMM | ε hundred -> smallHundred | C D | D smallHundred | C M smallHundred -> C | CC | CCC | ε ten -> smallTen | X L | L smallTen | X C smallTen -> X | XX | XXX | ε digit -> smallDigit | I V | V smallDigit | I X smallDigit -> I | II | III | ε 2.3 Exercises for Section 2.3 2.3.1 Construct a syntax-directed translation scheme that trans­ lates arithmetic expressions from infix notation into prefix notation in which an operator appears before its operands; e.g. , -xy is the prefix notation for x - y . Give annotated parse trees for the inputs 9-5+2 and 9-5*2.。 answer productions: expr -> expr + term | expr - term | term term -> term * factor | term / factor | factor factor -> digit | (expr) translation schemes: expr -> {print("+")} expr + term | {print("-")} expr - term | term term -> {print("*")} term * factor | {print("/")} term / factor | factor factor -> digit {print(digit)} | (expr) 2.3.2 Construct a syntax-directed translation scheme that trans­ lates arithmetic expressions from postfix notation into infix notation. Give annotated parse trees for the inputs 95-2* and 952*-. answer productions: expr -> expr expr + | expr expr - | expr expr * | expr expr / | digit translation schemes: expr -> expr {print("+")} expr + | expr {print("-")} expr - | {print("(")} expr {print(")*(")} expr {print(")")} * | {print("(")} expr {print(")/(")} expr {print(")")} / | digit {print(digit)} Another reference answer E -> {print("(")} E {print(op)} E {print(")"}} op | digit {print(digit)} 2.3.3 Construct a syntax-directed translation scheme that trans­ lates integers into roman numerals answer assistant function: repeat(sign, times) // repeat('a',2) = 'aa' translation schemes: num -> thousand hundred ten digit { num.roman = thousand.roman || hundred.roman || ten.roman || digit.roman; print(num.roman)} thousand -> low {thousand.roman = repeat('M', low.v)} hundred -> low {hundred.roman = repeat('C', low.v)} | 4 {hundred.roman = 'CD'} | high {hundred.roman = 'D' || repeat('X', high.v - 5)} | 9 {hundred.roman = 'CM'} ten -> low {ten.roman = repeat('X', low.v)} | 4 {ten.roman = 'XL'} | high {ten.roman = 'L' || repeat('X', high.v - 5)} | 9 {ten.roman = 'XC'} digit -> low {digit.roman = repeat('I', low.v)} | 4 {digit.roman = 'IV'} | high {digit.roman = 'V' || repeat('I', high.v - 5)} | 9 {digit.roman = 'IX'} low -> 0 {low.v = 0} | 1 {low.v = 1} | 2 {low.v = 2} | 3 {low.v = 3} high -> 5 {high.v = 5} | 6 {high.v = 6} | 7 {high.v = 7} | 8 {high.v = 8} 2.3.4 Construct a syntax-directed translation scheme that trans­ lates roman numerals into integers. answer productions: romanNum -> thousand hundred ten digit thousand -> M | MM | MMM | ε hundred -> smallHundred | C D | D smallHundred | C M smallHundred -> C | CC | CCC | ε ten -> smallTen | X L | L smallTen | X C smallTen -> X | XX | XXX | ε digit -> smallDigit | I V | V smallDigit | I X smallDigit -> I | II | III | ε translation schemes: romanNum -> thousand hundred ten digit {romanNum.v = thousand.v || hundred.v || ten.v || digit.v; print(romanNun.v)} thousand -> M {thousand.v = 1} | MM {thousand.v = 2} | MMM {thousand.v = 3} | ε {thousand.v = 0} hundred -> smallHundred {hundred.v = smallHundred.v} | C D {hundred.v = smallHundred.v} | D smallHundred {hundred.v = 5 + smallHundred.v} | C M {hundred.v = 9} smallHundred -> C {smallHundred.v = 1} | CC {smallHundred.v = 2} | CCC {smallHundred.v = 3} | ε {hundred.v = 0} ten -> smallTen {ten.v = smallTen.v} | X L {ten.v = 4} | L smallTen {ten.v = 5 + smallTen.v} | X C {ten.v = 9} smallTen -> X {smallTen.v = 1} | XX {smallTen.v = 2} | XXX {smallTen.v = 3} | ε {smallTen.v = 0} digit -> smallDigit {digit.v = smallDigit.v} | I V {digit.v = 4} | V smallDigit {digit.v = 5 + smallDigit.v} | I X {digit.v = 9} smallDigit -> I {smallDigit.v = 1} | II {smallDigit.v = 2} | III {smallDigit.v = 3} | ε {smallDigit.v = 0} 2.3.5 Construct a syntax-directed translation scheme that trans­ lates postfix arithmetic expressions into equivalent prefix arithmetic expressions. answer production: expr -> expr expr op | digit translation scheme: expr -> {print(op)} expr expr op | digit {print(digit)} Exercises for Section 2.4 2.4.1 Construct recursive-descent parsers, starting with the follow­ ing grammars: S -> + S S | - S S | a S -> S ( S ) S | ε S -> 0 S 1 | 0 1 Answer 1） S -> + S S | - S S | a void S(){ switch(lookahead){ case "+": match("+"); S(); S(); break; case "-": match("-"); S(); S(); break; case "a": match("a"); break; default: throw new SyntaxException(); } } void match(Terminal t){ if(lookahead = t){ lookahead = nextTerminal(); }else{ throw new SyntaxException() } } 2） S -> S ( S ) S | ε void S(){ if(lookahead == "("){ S(); match("("); S(); match(")"); S(); } } 3） S -> 0 S 1 | 0 1 void S(){ switch(lookahead){ case "0": match("0"); S(); match("1"); break; case "1": // match(epsilon); break; default: throw new SyntaxException(); } } Exercises for Section 2.6 2.6.1 Extend the lexical analyzer in Section 2.6.5 to remove com­ ments, defined as follows: A comment begins with // and includes all characters until the end of that line. A comment begins with /* and includes all characters through the next occurrence of the character sequence */. 2.6.2 Extend the lexical analyzer in Section 2.6.5 to recognize the relational operators <, =, >. 2.6.3 Extend the lexical analyzer in Section 2.6.5 to recognize float­ ing point numbers such as 2., 3.14, and . 5. Answer Source code: commit 8dd1a9a Code snippet(src/lexer/Lexer.java)： public Token scan() throws IOException, SyntaxException{ for(;;peek = (char)stream.read()){ if(peek == ' ' || peek == '\t'){ continue; }else if(peek == '\n'){ line = line + 1; }else{ break; } } // handle comment if(peek == '/'){ peek = (char) stream.read(); if(peek == '/'){ // single line comment for(;;peek = (char)stream.read()){ if(peek == '\n'){ break; } } }else if(peek == '*'){ // block comment char prevPeek = ' '; for(;;prevPeek = peek, peek = (char)stream.read()){ if(prevPeek == '*' && peek == '/'){ break; } } }else{ throw new SyntaxException(); } } // handle relation sign if("".indexOf(peek) > -1){ StringBuffer b = new StringBuffer(); b.append(peek); peek = (char)stream.read(); if(peek == '='){ b.append(peek); } return new Rel(b.toString()); } // handle number, no type sensitive if(Character.isDigit(peek) || peek == '.'){ Boolean isDotExist = false; StringBuffer b = new StringBuffer(); do{ if(peek == '.'){ isDotExist = true; } b.append(peek); peek = (char)stream.read(); }while(isDotExist == true ? Character.isDigit(peek) : Character.isDigit(peek) || peek == '.'); return new Num(new Float(b.toString())); } // handle word if(Character.isLetter(peek)){ StringBuffer b = new StringBuffer(); do{ b.append(peek); peek = (char)stream.read(); }while(Character.isLetterOrDigit(peek)); String s = b.toString(); Word w = words.get(s); if(w == null){ w = new Word(Tag.ID, s); words.put(s, w); } return w; } Token t = new Token(peek); peek = ' '; return t; } Exercises for Section 2.8 2.8.1 For-statements in C and Java have the form: for ( exprl ; expr2 ; expr3 ) stmt The first expression is executed before the loop; it is typically used for initializ­ ing the loop index. The second expression is a test made before each iteration of the loop; the loop is exited if the expression becomes O. The loop itself can be thought of as the statement {stmt expr3 ; }. The third expression is executed at the end of each iteration; it is typically used to increment the loop index. The meaning of the for-statement is similar to expr1 ; while ( expr2 ) {stmt expr3 ; } Define a class For for for-statements, similar to class If in Fig. 2.43. Answer class For extends Stmt{ Expr E1; Expr E2; Expr E3; Stmt S; public For(Expr expr1, Expr expr2, Expr expr3, Stmt stmt){ E1 = expr1; E2 = expr2; E3 = expr3; S = stmt; } public void gen(){ E1.gen(); Label start = new Lable(); Lalel end = new Lable(); emit("ifFalse " + E2.rvalue().toString() + " goto " + end); S.gen(); E3.gen(); emit("goto " + start); emit(end + ":") } } 2.8.2 The programming language C does not have a boolean type. Show how a C compiler might translate an if-statement into three-address code. Answer Replace emit("isFalse " + E.rvalue().toString() + " goto " + after); with emit("ifNotEqual " + E.rvalue().toString() + " 0 goto " + after); or emit("isNotEqualZero " + E.rvalue().toString() + " goto " + after);
编译原理 龙书 练习2.2.1习题与答案
ciqingloveless的博客
03-06 6372
练习2.2.1：考虑下面的上下文无关文法： S -&amp;amp;amp;amp;gt; SS + | SS * | a 试说明如何使用该问法生成串 aa + a* 由于上述问法生成式可知： S -&amp;amp;amp;amp;gt; a S -&amp;amp;amp;amp;gt; SS* S -&amp;amp;amp;amp;gt; SS+ 所以可知： a是S aa+是S 所以上述生成串是S ...
编译原理第二章
sxy_hetao的博客
03-07 534
第二章高级语言及其语法描述2.1程序语言的定义2.2高级语言的一般特性2.3程序语言的语法描述2.3.1上下文无关文法文法是描述语言的语法结构的形式规则语法分析树：用一种图示化的方法来表示这种推导归纳起来，一个上下文无关文法G包括四个组成部分：一组终结符号，一组非终结符号，一个开始符号，以及一组产生式。大写：非终结界  小写：终结界最左推导，最右推导2.3.2语法分析树与二义性如果一个文法存在某个...
编译原理龙书习题
weixin_44952024的博客
11-16 449
编译原理课后习题
DirectX12 3D游戏开发实践（龙书）第二章_矩阵代数
c++、UE
10-25 974
一个规模为m×n\;m×n\;m×n的矩阵M\;M\;M，是由m\;m\;m行n\;n\;n列实数所构成的矩阵阵列。行数和列数的乘积代表了矩阵的维度。矩阵中的数字则称作元素或者元。通过双下标表示法Mij\;M_{ij}\;Mij​指定元素的行和列就可以确定出对应的矩阵元素，Mij\;M_{ij}\;Mij​表示的是矩阵的第i\;i\;i行、第j\;j\;j列元素。AAA是一个4×44×44×4矩阵,B。
2.2 节的练习--Compiler principles, technologys, &tools
weixin_30786657的博客
03-06 1375
2.2 节的练习 2.2.1 考虑下面的上下文无关文法： S -> S S + | S S * | a 试说明如何使用该文法生成串 aa+a* 试为这个串构造一颗语法分析树 ⧗ 该文法生成的语言是什么？试证明 解答 S -> S S * -> S S + S * -> a S + S * -> a a + S * -> a a + a...
8、运算符的优先级别
JavaDayUp
08-27 9642
学习目标： 1、熟练Java的集中基本的运算符的优先级 2、掌握不同数据类型的转换学习过程： 一、运算符的优先级 在一系列复杂的运算符中，优先级较高的运算符总是先被运算，然后才按照优先级的高低依次完成所有计算，在前面的章节中我们也简单了提到了一些运算符的优先顺序，其中优先级最高的是小括号括号：”(...)”,多个括号分割运算表达式会让一个复杂的表达式变得更具有可读性。其他的运算符按照优先级...
下列运算符中优先级最高的是（ ）。 A. < B. + C. && D. ||
weixin_42605397的博客
12-27 3042
在 C 语言中，优先级最高的运算符是： 单目运算符(如 ++、--、! 等) 取地址符(&) 解除引用符(*) 类型转换运算符(如 (int)、(char) 等) 乘法、除法、取模运算符(*、/、%) 加法、减法运算符(+、-) 左移、右移运算符(<<、>>) 关系运算符(如 <、>、<=、>= 等) 相等运算符(==、!=) 位运算符(如...
编译原理龙书第二版英文版
最新发布
02-25
《编译原理龙书》第二版不仅提供了理论基础，还包含大量实例和练习，适合计算机科学专业的学生和专业开发者学习。通过阅读本书，读者可以深入理解编译器的工作机制，这对于编写高效软件、理解现有系统和开发新的编程...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值