do-while语句翻译程序
WHILE循环语句的翻译程序设计(简单优先法,三地址输出)
目录1 问题域描述 (3)2 文法及属性文法的描述 (3)2.1 WHILE循环语句的文法 (3)2.2 WHILE循环语句的属性文法 (4)3 语法分析方法及中间代码形式的描述 (4)3.1语法分析方法 (4)3.2中间代码形式描述 (6)4 编译系统的概要设计 (7)4.1词法分析 (7)4.2语法制导翻译 (8)5 详细的算法描述 (8)5.1 文法设计 (8)5.2 算法描述 (8)5.3 源程序代码 (9)6 软件的调试过程和结果测试 (19)6.1调试过程 (19)6.2结果测试 (19)7 使用说明 (20)8 课设总结 (20)9 参考文献 (22)WHILE循环语句的翻译程序设计（简单优先法、输出三地址表示）1 问题域描述while循环语句的翻译程序设计（简单优先法，输出单地址表示），要求完成：（1）用C++语言正确编写程序，完成WHILE循环语句的翻译程序设计。
（2）求能正确进行词法分析，语法分析，并能正确的输出预期结果。
（3）根据指定的文法，判定程序的正确性。
本次课程设计中要求设计一个WHILE循环语句的词法﹑语法及语义分析程序，语法分析选择简单优先法，采用语法制导翻译输出中间代码三元式。
通过设计、编制、调试一个WHILE循环语句的语法及语义分析程序，加深对语法及语义分析原理的理解，实现功能。
while循环语句的格式为：while（P）{do A}，其中A为循环体，可为一个或多个赋值语句；P为循环控制条件。
while循环语句首先根据循环控制条件P进行判断，若满足条件则执行循环体A，否则执行下面的程序段；本次课程设计中系统首先要进行词法分析，即从左到右把源文件的字符序列逐个进行扫描，产生一个个的单词序列，作为语法分析的输入从而继续编译过程。
该程序的语法分析读入词法分析的结果，并判断输入语句是否满足while循环语句的文法所描述的形式。
通过简单优先法对语句进行分析，看是否能通过给定的输入串归约到文法的开始符号。
do-while语句的语法格式及其流程
do-while语句的语法格式及其流程`do-while` 语句是一种循环语句，它在执行循环体之前先执行一次条件判断。
这意味着，无论条件是否满足，循环体至少会被执行一次。
下面是`do-while` 语句的语法格式和执行流程：```cppdo {// 循环体} while (条件表达式);```- `do` 后面紧跟着循环体，用花括号`{}` 括起来，循环体是需要重复执行的语句块。
- `while` 后面跟着条件表达式，条件表达式返回一个布尔值。
如果条件为真，循环会继续执行；如果条件为假，循环结束。
执行流程如下：1. 执行`do` 后的循环体。
2. 执行完循环体后，计算`while` 后的条件表达式。
3. 如果条件表达式为真，则回到步骤1，重新执行循环体；如果条件表达式为假，则退出循环。
下面是一个简单的C++ 示例，演示了`do-while` 语句的用法：```cpp#include <iostream>int main() {int count = 0;do {std::cout << "Count: " << count << std::endl;count++;} while (count < 5);return 0;}```这个例子会输出以下内容：```Count: 0Count: 1Count: 2Count: 3Count: 4```即使条件`count < 5` 在第一次循环后变为假，`do-while` 语句仍然执行了一次循环体。
DO-WHILE循环语句翻译程序设计
DO-WHILE循环语句翻译程序的设计目录第一章概述 (1)1.1 课程设计背景 (1)1.2 课程设计目的 (1)1.3 实验环境与开发工具 (1)1.4 C++语言简单介绍 (2)第二章设计内容 (3)2.1 设计需求陈述 (3)2.1.1词法分析的原理 (4)2.1.2 语法分析器的原理 (5)2.1.3 语义分析中间代码生成器的原理.......................................... 错误！未定义书签。
2.2 需要完成的功能................................................................................. 错误！未定义书签。
2.2.1 判定输入的文法词法分析是否正确 (8)2.2.2 判定输入的文法语法分析是否正确 (9)2.2.3中间代码（四元式）的生成与输出 (10)2.3 分析器的构造 (11)第三章逻辑设计 (12)3.1系统的组织与基本工作流程 (12)3.2 总体结构逻辑结构图 (13)第四章详细设计.............................................................................................. 错误！未定义书签。
4.1 软件功能分析................................................................................... 错误！未定义书签。
4.1.1 判定输入文法词法分析是否正确 (14)4.1.2 判定输入的文法的语法分析是否正确.................................. 错误！未定义书签。
4.1.3 语义分析和中间代码生成...................................................... 错误！未定义书签。
dowhile的用法c语言
dowhile的用法c语言【原创实用版】目录1.概述 do-while 循环的用途2.do-while 循环的基本语法3.do-while 循环与 while 循环的区别4.使用 do-while 循环的注意事项5.示例：使用 do-while 循环实现的功能正文一、概述 do-while 循环的用途在 C 语言编程中，循环结构是经常使用的一种控制结构，用于重复执行某些操作。
do-while 循环是其中一种循环结构，它的主要用途是当满足某个条件时，重复执行一段代码。
与 while 循环不同，do-while 循环会至少执行一次循环体。
二、do-while 循环的基本语法do-while 循环的基本语法如下：```do {// 循环体} while (条件);```其中，`do`和`while`是关键字，`do`后面跟着的是循环体，`while`后面跟着的是条件表达式。
只要条件表达式为真，循环体就会一直执行。
三、do-while 循环与 while 循环的区别do-while 循环与 while 循环的主要区别在于执行顺序不同。
while 循环是先进行条件判断，如果条件为真，则执行循环体；而 do-while 循环是先执行一次循环体，然后再进行条件判断。
因此，do-while 循环至少会执行一次循环体。
四、使用 do-while 循环的注意事项在使用 do-while 循环时，需要注意以下几点：1.循环条件表达式应尽可能简单，以减少程序执行的时间。
2.循环体内部不要包含可能影响循环执行的语句，例如使用 break 语句跳出循环。
3.do-while 循环一般用于需要重复执行一定次数的操作，或者用于处理可能需要多次尝试才能成功的情况。
五、示例：使用 do-while 循环实现的功能下面是一个使用 do-while 循环实现的简单示例，用于计算 1 到100 之间所有偶数的和：```c#include <stdio.h>int main() {int sum = 0;int i = 1;do {if (i % 2 == 0) {sum += i;}i++;} while (i <= 100);printf("1 到 100 之间的偶数和为：%d", sum);return 0;}```在这个示例中，我们使用 do-while 循环遍历 1 到 100 之间的所有整数，当整数 i 为偶数时，将其累加到变量 sum 中。
dowhile语句的用法
dow hi le语句的用法篇一：4.d o-wh il e语句的用法d o-wh il e语句的一般形式为:d o语句w hi le(表达式)；这个循环与wh il e循环的不同在于:它先执行循环中的语句,然后再判断表达式是否为真,如果为真则继续循环；如果为假,则终止循环。
因此,do-w hi le循环至少要执行一次循环语句。
其执行过程可用下图表示。
【例6.5】用d o-wh il e语句计算从1加到100的值m ai n(){in ti,su m=0;i=1;do{s um=s um+i;i++;}w hi le(i=100)p ri nt f(%d\n,s um);}同样当有许多语句参加循环时,要用{和}把它们括起来。
【例6.6】wh il e和do-w hi le循环比较。
（1）ma in(){in tsu m=0,i;s ca nf(“%d”,wh il e(i=10){su m=su m+i;i++;}pr in tf(“su m=%d”,su m);}（2）m ai n(){i nts um=0,i;sc an f(“%d”,do{su m=su m+i;i++;}wh il e(i=10);pr in tf(“su m=%d”,su m);}篇二：d ow hi le使用技巧#de fi neM AC RO_N AM E(pa ra)do{m ac roc on te nt}w hi le(0)的格式，总结了以下几个原因：1，空的宏定义避免wa rn in g:#de fi nef oo()d o{}w hi le(0)2，存在一个独立的b lo ck，可以用来进行变量定义，进行比较复杂的实现。
java中do while的用法
Java中的do-while循环是一种常见的循环结构，它与while循环和for循环一样，用于重复执行一段代码，直到满足某个条件时停止。
本文将详细介绍java中do-while循环的用法，包括语法、示例代码和一些注意事项。
一、语法do-while循环的语法如下所示：```javado {// 循环体} while (条件表达式);```二、示例代码下面是一个简单的示例代码，演示了do-while循环的基本用法：```javapublic class DoWhileDemo {public static void m本人n(String[] args) {int i = 1;do {System.out.println(i);i++;} while (i <= 5);}}```三、解释与注意事项1. do-while循环与while循环的区别在于，do-while循环会先执行一次循环体，然后再判断条件是否满足。
这意味着，即使条件一开始就不满足，循环体也会被执行一次。
而while循环则先判断条件是否满足，然后再决定是否执行循环体。
2. 在使用do-while循环时，要特别注意条件表达式的初始值和更新方式，以免造成死循环或者跳不出循环的情况。
3. 在实际编程中，do-while循环通常用于需要先执行一次循环体才能确定条件是否满足的情况。
读取用户输入的信息，或者进行一些初始化操作。
以上就是关于java中do-while循环的介绍。
希望本文能够帮助大家更好地理解和运用do-while循环。
四、do-while循环的嵌套和实际应用除了基本的do-while循环语法外，我们还可以将多个do-while循环嵌套在一起，以实现更复杂的循环逻辑。
下面的示例演示了嵌套的do-while循环：public class NestedDoWhileDemo {public static void m本人n(String[] args) {int i = 1, j;do {j = 1;do {System.out.print(i * j + " ");j++;} while (j <= 3);System.out.println();i++;} while (i <= 3);}}```在这个示例中，外层的do-while循环负责控制输出的行数，内层的do-while循环负责控制每行输出的内容。
c语言中do while的用法
c语言中do while的用法C语言中的do while循环是一种循环结构，它与while循环和for 循环一样，可以用来重复执行一段代码。
但是，它与while循环和for循环不同的是，它的循环体至少会被执行一次，即使循环条件一开始就不满足。
do while循环的语法格式如下：```do {// 循环体} while (循环条件);```在这个语法格式中，循环体是需要重复执行的代码块，循环条件是一个布尔表达式，用来判断是否继续执行循环体。
当循环条件为真时，循环体会被重复执行，直到循环条件为假为止。
下面是一个简单的例子，演示了do while循环的用法：```#include <stdio.h>int main() {int i = 1;do {printf("%d ", i);i++;} while (i <= 10);return 0;}```这个程序会输出从1到10的数字，因为循环体会被执行10次，直到i的值大于10为止。
即使i的初始值为11，循环体也会被执行一次，因为do while循环的特点是至少会被执行一次。
do while循环的优点是它可以保证循环体至少被执行一次，这在某些情况下非常有用。
比如，当需要从用户那里获取输入时，可以使用do while循环来保证至少获取一次输入。
另外，do while循环也可以用来处理一些需要先执行一次循环体的情况，比如初始化变量等。
do while循环是C语言中一种非常有用的循环结构，它可以保证循环体至少被执行一次，同时也可以用来处理一些特殊情况。
在编写程序时，我们应该根据具体情况选择合适的循环结构，以便更好地完成任务。
《编译原理》课程设计说明书_DO_WHILE循环语句的翻译程序设计(LR方法、输出三地址表示)
DO-WHILE循环语句的翻译程序设计（LR方法、输出三地址表示）1.系统描述1.1设计目的通过设计、编制、调试一个DO-WHILE循环语句的语法及语义分析程序，加深对语法及语义分析原理的理解，并实现词法分析程序对单词序列的词法检查和分析。
1.2设计内容及步骤对循环语句：DO〈赋值语句〉WHILE 〈表达式〉按给定的题目写出符合自身语法分析方法要求的文法和属性文法描述。
(1)按给定的题目给出语法分析方法的思想及分析表设计。
(2)按给定的题目给出中间代码序列的结构设计。
(3)完成相应的词法分析、语法分析和语义分析程序设计。
(4)编制好分析程序后，设计若干用例，上机测试并通过所设计的分析程序。
2文法的描述本程序所用的文法如下：G[S]:(1)S->do{E;}while(B) {if B.true goto B.true else goto B.false;}(2)B->I1 rop I2 {B.type=bool;B.val=I1.val rop I2.val;}(3)E->I1=I2 op I3 {I1.val=I2.val op I3.val;}(4)I->id {I.val=id.val;}注意：rop is < or >，op is +,-,*,/, id is any number or identifier由上可知，非终结符B表示布尔表达式，E表示赋值表达式3.语法分析方法描述及语法分析表设计3.1语法分析方法描述本实验采用LR分析方法对DO-WHILE语句进行语法分析。
LR分析法是一种能根据当前分析栈中的符号串（通常以状态表示）和向右顺序查看输入串的K个（K>=0）符号就能惟一的确定分析器的动作是移进还是归约和用哪个产生式归约，因而也就能惟一的确定句柄。
LR分析法的归约过程是规范推导的逆过程，所以LR分析过程是一种规范过程。
一个LR分析器由3个部分组成：总控程序，也可以称为驱动程序。
do while循环语句用法
do while循环语句用法
嘿，朋友们！咱今儿个就来好好唠唠 do while 循环语句的用法。
你想啊，就好比你去跑马拉松，do while 循环就像是你先不管三七
二十一地跑起来，然后在特定条件下才决定是不是继续跑。
比如说，
你设定一个目标，“只要我还没跑到终点，我就继续跑”，这就是 do while 循环的精髓所在！
咱先说说它的基本结构哈。
“do”后面紧跟着要执行的代码块，然后
是“while”，再加上判断条件。
这就像是一个有决心的人，先行动起来，然后再看看情况决定下一步。
比如说，你让程序一直输出数字，直到某个数字出现。
这就像你在
玩猜数字游戏，一直猜，直到猜对了为止！“哎呀，我怎么还没猜对呀！”这时候 do while 循环就派上用场啦。
再举个例子，你想让程序不断地接收用户输入，直到用户输入一个
特定的字符。
这多有意思呀，就像你和朋友聊天，一直聊到说到某个
关键词为止。
“嘿，你怎么还不说那个词呀！”
它和其他循环语句比起来，有它独特的优势呢。
它至少会执行一次
代码块，这就好比你下定决心要做一件事，不管怎样先做了再说。
不
像有些循环，可能因为条件不满足一开始就不执行。
总之，do while 循环语句就像是一个勇往直前的战士，先冲出去再说！它在很多情况下都超级实用，能帮我们解决好多问题呢。
我觉得 do while 循环语句真是编程世界里不可或缺的一部分呀，它能让我们的程序更灵活、更有趣！你们觉得呢？。
dowhile循环语句用法
dowhile循环语句用法1. 嘿呀，你知道 do while 循环语句怎么用吗？就像你一直往前走，直到遇到特定条件才停下来。
比如说，你想要让用户一直输入直到输入正确，那就可以用 do while 循环呀！“do { 获取用户输入; } while (输入不正确);”，是不是很神奇呀！2. 哎呀，do while 循环语句可有意思啦！它就像一场冒险，先行动起来，然后再看条件决定要不要继续呢。
好比你在找宝藏，先找，然后看是不是找到了，没找到就接着找！“do { 尝试打开宝箱; } while (宝箱未打开);”，妙不妙呀！3. 告诉你哦，do while 循环语句真是个好东西呢！这就像是打游戏，先出招，然后判断能不能过关。
比如说统计输入的数字总和，直到输入负数就停止，“do { 输入数字; 总和 += 数字; } while (数字不小于0);”，是不是超好用呀！4. 哇塞，do while 循环语句的用法你可得搞清楚呀！它就如同你在跑步，先跑一段，然后看符不符合要求。
像是计算从 1 开始到多少累加和超过100，“do { 当前数++; 累加和 += 当前数; } while (累加和<= 100);”，多有趣呀！5. 嘿，do while 循环语句的魅力可大啦！它好比是你去尝试做一件事，做完看看情况，不行再接着做。
就像检查输入是否为偶数，“do { 输入数字; } while (数字不是偶数);”，这方法简直绝了！6. 你看，do while 循环语句是不是特别神奇呀！它就像一个执着的人，先做了再说，然后看结果决定下一步。
假设要反复询问是否喜欢编程，“do { 询问是否喜欢; } while (回答否);”，是不是让你大开眼界呢！我觉得 do while 循环语句是非常实用且有趣的，它能让我们的程序更灵活，让我们能更轻松地处理一些先执行后判断的情况。
dowhile语句实践运用
dowhile语句实践运用do-while语句是一种循环结构，它先执行一次循环体，然后再根据条件判断是否继续执行循环。
接下来，我将以人类的视角，用准确的中文描述，给你展示几个do-while语句的实践运用场景。
一、购物结算小明去超市购物，他买了苹果、香蕉和橙子。
他需要使用do-while 语句来实现购物结算的功能。
首先，他将购买的商品放入购物车，然后计算购物车中商品的总价。
接着，他询问是否继续购买，如果是，则继续添加商品到购物车，否则结束购物并输出购物车中商品的总价。
二、学生成绩统计某班级有10名学生，老师需要使用do-while语句来统计学生的成绩。
老师首先输入学生的姓名和成绩，然后判断是否还有其他学生需要输入成绩。
如果是，则继续输入下一位学生的成绩，否则结束输入并计算学生的平均成绩和最高分。
三、密码验证某应用程序需要使用do-while语句来验证用户的密码。
用户需要输入密码，然后程序判断密码是否正确。
如果密码不正确，则提示用户重新输入密码，直到输入正确的密码为止。
四、游戏猜数小明和小红在玩一个猜数字的游戏。
小红想一个数字，小明需要猜这个数字是多少。
小明每次猜完后，小红会告诉他猜的数字是大了还是小了。
小明使用do-while语句来循环猜数字，直到猜中为止。
五、倒计时某个倒计时程序需要使用do-while语句来实现倒计时功能。
程序首先设置倒计时的时间，然后开始倒计时。
在每次倒计时结束后，程序判断是否还需要继续倒计时。
如果是，则继续倒计时，否则结束倒计时。
六、跳绳计数小明正在练习跳绳，他使用do-while语句来记录他跳绳的次数。
每次跳绳后，他会询问自己是否还要继续跳绳。
如果是，则继续跳绳并增加跳绳次数，否则结束跳绳并输出跳绳的总次数。
七、旅行计划小红正在计划一个旅行，她使用do-while语句来帮助她安排旅行的行程。
首先，她选择旅行的目的地和出发日期。
然后，她询问自己是否还要添加其他目的地。
如果是，则继续添加目的地和出发日期，否则结束计划并输出旅行的行程安排。
DO-WHILE循环语句的翻译程序设计(简单优先法、输出三地址表示)
附件1：学号：0120910340525课程设计题目DO-WHILE（简单优先法、输出三地址表示）学院计算机科学与技术专业计算机科学与技术班级0905姓名明正超指导教师杨克俭2012 年 1 月 3 日课程设计任务书学生姓名：明正超专业班级：计算机0905班指导教师：杨克俭工作单位：计算机科学与技术学院题目: DO-WHILE循环语句的翻译程序设计（简单优先法、输出三地址表示）初始条件：理论：学完编译课程，掌握一种计算机高级语言的使用。
实践：计算机实验室提供计算机及软件环境。
如果自己有计算机可以在其上进行设计。
要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求）（1）写出符合给定的语法分析方法的文法及属性文法。
（2）完成题目要求的中间代码三地址表示的描述。
（3）写出给定的语法分析方法的思想，完成语法分析和语义分析程序设计。
（4）编制好分析程序后，设计若干用例，上机测试并通过所设计的分析程序。
（5）设计报告格式按附件要求书写。
课程设计报告书正文的内容应包括：1 系统描述（问题域描述）；2 文法及属性文法的描述；3 语法分析方法描述及语法分析表设计；4 按给定的题目给出中间代码形式的描述及中间代码序列的结构设计；5 编译系统的概要设计；6 详细的算法描述（流程图或伪代码）；7 软件的测试方法和测试结果；8 研制报告（研制过程，本设计的评价、特点、不足、收获与体会等）；9 参考文献（按公开发表的规范书写）。
时间安排：设计安排一周：周1、周2：完成系统分析及设计。
周3、周4：完成程序调试及测试。
周5：撰写课程设计报告。
设计验收安排：设计周的星期五第1节课开始到实验室进行上机验收。
设计报告书收取时间：设计周的次周星期一上午10点。
指导教师签名： 2011年 11月23日系主任（或责任教师）签名： 2011年 11月 23日（一）系统描述根据所学编译原理有关词法分析，语法分析，语义分析有关规则,对DO_WHILE循环语句的翻译程序进行设计，使用高级语言或者伪代码形式，进行编写，其中要求使用简单优先法法并在程序的最终结果中显示出表达式的三地址形式。
dowhile的用法c语言
dowhile的用法c语言do-while是一种循环结构，它在执行循环体之前先判断条件是否为真。
与while循环不同的是，do-while循环保证循环体至少会执行一次。
在C语言中，do-while循环的语法如下：```do//循环体语句} while (条件);```接下来，我将详细介绍do-while循环的用法，并给出一些示例。
1.基本用法：do-while循环的基本结构是先执行循环体，然后判断条件是否为真，如果为真则继续执行循环体；如果为假，则跳出循环。
因此，循环体至少会执行一次。
```c#include <stdio.h>int maiint i = 0;doprintf("%d ", i);} while (i < 5);return 0;```输出结果为：012342.多层嵌套循环：do-while循环可以与其他循环结构（如for、while）嵌套使用，实现多层循环嵌套的功能。
可以通过一个或多个条件来控制循环次数。
```c#include <stdio.h>int maiint i, j;i=0;doj=0;doprintf("%d %d\n", i, j);j++;} while (j < 3);} while (i < 2);return 0;```输出结果为：```000102101112```3. 使用break语句跳出循环：在循环体内部，可以使用break语句来跳出do-while循环，即使条件仍然为真。
```c#include <stdio.h>int maiint i = 0;doprintf("%d ", i);i++;if (i == 3)break;}} while (i < 5);return 0;```输出结果为：0124. 使用continue语句跳过本次循环：在循环体内部，可以使用continue语句来跳过本次循环，并继续执行下一次循环。
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循环语句的语法分析,并输出四元式.设计的特点是利用定义每个终极符和非终极符之间优先关系,来进行符号的移进与规约,如果栈顶符号优先级低于该单词，继续读入；若栈顶符号优先级高于或等于读入符号，则找句柄进行归约，找不到句柄就继续读入。
dowhile循环语句
dowhile循环语句
嘿，朋友！你知道那个超厉害的 do while 循环语句吗？就好像是一
个不知疲倦的小勇士，一直在战斗呢！比如说，你想让程序先执行一
段代码，然后再根据条件判断是否继续循环，这时候 do while 就派上
大用场啦！
想象一下，你在玩一个游戏，你必须先迈出第一步，然后看看情况
再决定要不要继续走下去，这和 do while 循环多像呀！你先执行一次
代码，然后再去检查条件。
“哎呀，条件满足，那就再来一次呗！”它
就是这么直接，这么干脆！
我记得有一次，我在写一个程序，要计算一些数据的累计和。
我一
开始用了其他的循环语句，结果总是不太对。
后来我突然想到了 do while，一试，哇塞，简直完美！就像找到了一把神奇的钥匙，一下子
就打开了那扇困住我的门。
在编程的世界里，do while 循环语句就像是一个可靠的伙伴。
它不
会轻易放弃，一直陪着你解决问题。
它不会问你“行不行呀”“能不能呀”，而是直接就上，“先干了再说！”这种勇往直前的精神，真的让人佩服。
你看，其他的循环语句可能会先看看条件再决定要不要行动，do while 可不一样，它就是这么有个性！它就像一个勇敢的探险家，不管
前面有什么，先冲进去再说。
总之，do while 循环语句就是那么独特，那么不可或缺。
它在编程中有着重要的地位，能帮我们解决好多难题呢！你难道不想去试试，感受一下它的魅力吗？。
do while的执行流程
do while的执行流程下载温馨提示:该文档是我店铺精心编制而成，希望大家下载以后，能够帮助大家解决实际的问题。
文档下载后可定制随意修改，请根据实际需要进行相应的调整和使用，谢谢!并且，本店铺为大家提供各种各样类型的实用资料，如教育随笔、日记赏析、句子摘抄、古诗大全、经典美文、话题作文、工作总结、词语解析、文案摘录、其他资料等等，如想了解不同资料格式和写法，敬请关注!Download tips: This document is carefully compiled by theeditor. I hope that after you download them,they can help yousolve practical problems. The document can be customized andmodified after downloading,please adjust and use it according toactual needs, thank you!In addition, our shop provides you with various types ofpractical materials,such as educational essays, diaryappreciation,sentence excerpts,ancient poems,classic articles,topic composition,work summary,word parsing,copy excerpts,other materials and so on,want to know different data formats andwriting methods,please pay attention!1. 执行`do`后面的循环体语句。
2. 计算`while`后面的条件表达式的值。
do while用法c语言
do while用法c语言
在C语言中，do-while循环用于执行一段代码块，然后再判断条件是否满足，如果满足则继续执行循环，否则退出循环。
do-while循环的基本语法如下：
do {
// 代码块
} while (条件);
代码块是要执行的语句块，而条件是一个表达式，用于判断是否继续执行循环。
do-while循环的执行过程如下：
1. 先执行一次代码块。
2. 判断条件是否满足，如果满足则继续执行循环，否则退出循环。
3. 重复步骤1和步骤2，直到条件不满足为止。
下面是一个使用do-while循环的例子，计算1到10的和：
```c
#include <stdio.h>
int main() {
int i = 1;
int sum = 0;
do {
sum += i;
i++;
} while (i <= 10);
printf("Sum = %d\n", sum);
return 0;
}
```
输出结果为：
```
Sum = 55
```
在这个例子中，首先将变量`i`和`sum`初始化为1和0，然后执行do-while循环。
在循环中，将当前的`i`累加到`sum`中，并
将`i`的值加1。
当`i`的值等于11时，条件不满足，循环退出。
最后，输出变量`sum`的值。
scala 的dowhile 语句
scala 的dowhile 语句1. 哎呀，Scala 的 do-while 语句可真是个神奇的家伙！就像你在黑暗中摸索，一直走一直走，直到看到那一丝亮光才停下来。
比如说，我想让程序一直输出数字，直到数字大于 10 ，那我就可以这样写：`var num = 1; do { println(num); num += 1; } while (num <= 10);` 难道你不觉得这很有趣吗？2. 朋友，Scala 的 do-while 语句简直是编程世界的一把利器！好比你在追逐梦想的路上，不停奔跑，直到达到目标。
举个例子，假设要计算 1 到 5 的和，就可以这么搞：`var sum = 0; var i = 1; do { sum += i;i += 1; } while (i <= 5);` 这难道不酷吗？3. 嘿呀，Scala 的 do-while 语句就像是一个不知疲倦的工人！一直干活，直到满足条件。
比如说，要找出第一个大于 20 的偶数，代码可以这样：`var num = 1; do { if (num % 2 == 0 && num > 20){ println(num); break; } num += 1; } while (true);` 是不是很神奇呢？4. 亲，Scala 的 do-while 语句那可真是太实用啦！仿佛是一位坚定的勇士，勇往直前，不达目的不罢休。
比如，要打印出从 5 到 1 的数字，就这么来：`var num = 5; do { println(num); num -= 1; } while (num >= 1);` 这难道不让你眼前一亮？5. 哇哦，Scala 的 do-while 语句简直是个魔法咒语！就像一个永不停歇的时钟，一直转动。
比如说，要找出小于 100 且能被 7 整除的最大数，就写：`var num = 100; do { if (num % 7 == 0) { println(num); break; } num -= 1; } while (num > 0);` 难道你不想试试？6. 哎呀呀，Scala 的 do-while 语句真是妙不可言！好比是一只不停跳跃的袋鼠，直到找到合适的地方。
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 年月日。
do while语句格式
do while语句格式
嘿，朋友！你知道吗？do while 语句格式就像是一个固执的小孩，非得先把事情做一遍，然后再去判断条件是否满足。
比如说，你让这小孩去洗手，他会先洗一次，然后才会看看手是不是真的洗干净了。
在编程里，do while 语句是这样的：先执行一次循环体中的代码，然后再去判断条件。
就好比你参加一场比赛，先冲出去跑一圈，然后才看自己有没有达到规定的成绩。
假设我们要写一个程序，计算 1 到 10 的和。
用 do while 语句就会是这样：
int sum = 0;
int i = 1;
do {
sum += i;
i++;
} while (i <= 10);
你看，先不管三七二十一，把计算和、增加数字的操作做了，然后再看 i 是不是小于等于 10 来决定要不要继续。
这不就像是你先大胆地尝试做一件事，然后再看结果是不是符合预期嘛！
我觉得啊，do while 语句格式有时候虽然有点“任性”，但在某些情况下，还真是能解决大问题，让程序更加灵活多变呢！。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
DO-WHILE循环语句的翻译程序设计（LR方法、输出三地址表示）1.系统描述1.1设计目的通过设计、编制、调试一个DO-WHILE循环语句的语法及语义分析程序，加深对语法及语义分析原理的理解，并实现词法分析程序对单词序列的词法检查和分析。
1.2设计内容及步骤对循环语句：DO〈赋值语句〉WHILE 〈表达式〉按给定的题目写出符合自身语法分析方法要求的文法和属性文法描述。
(1)按给定的题目给出语法分析方法的思想及分析表设计。
(2)按给定的题目给出中间代码序列的结构设计。
(3)完成相应的词法分析、语法分析和语义分析程序设计。
(4)编制好分析程序后，设计若干用例，上机测试并通过所设计的分析程序。
2文法的描述本程序所用的文法如下：G[S]:(1)S->do{E;}while(B) {if B.true goto B.true else goto B.false;}(2)B->I1 rop I2 {B.type=bool;B.val=I1.val rop I2.val;}(3)E->I1=I2 op I3 {I1.val=I2.val op I3.val;}(4)I->id {I.val=id.val;}注意：rop is < or >，op is +,-,*,/, id is any number or identifier由上可知，非终结符B表示布尔表达式，E表示赋值表达式3.语法分析方法描述及语法分析表设计3.1语法分析方法描述本实验采用LR分析方法对DO-WHILE语句进行语法分析。
LR分析法是一种能根据当前分析栈中的符号串（通常以状态表示）和向右顺序查看输入串的K个（K>=0）符号就能惟一的确定分析器的动作是移进还是归约和用哪个产生式归约，因而也就能惟一的确定句柄。
LR分析法的归约过程是规范推导的逆过程，所以LR分析过程是一种规范过程。
一个LR分析器由3个部分组成：总控程序，也可以称为驱动程序。
对所有的LR分析器，总控程序是相同的。
分析表或分析函数。
不同的方法分析表将不同，同一个方法采用的LR分析器不同时，分析表也不同，分析表表又可以分为动作（ACTION）表和状态转换（GOTO）表两个部分，它们都可以用二维数组表示。
分析栈，包括文法符号栈和相应的状态栈。
它们均是先进后出栈。
分析器的动作由栈顶状态和当前输入符号所决定。
LR 分析器工作过程示意图如图所示：其中SP 为栈顶指针，S[i]为状态栈，X[i]为文法符号栈。
状态转换表内容按关系GOTO[Si,X]=Sj 确定，改关系式是指当前栈顶状态为Si 遇到当前文法符号为X 时应转向状态Sj 。
X 为终结符或非终结符。
ACTION[Si,a]规定了栈顶状态为Sj 时遇到输入符号c[i]应该执行的动作。
动作有以下四种可能：移进：当Sj=GOTO[Si ，a]成立，则把Sj 移入到文法符号栈。
其中i ，j 表示状态号。
规约：当在栈顶形成句柄为b 时，则用b 归约为相应的非终结符A ，即当文法中有A->b 的产生式，而b 的长度为r ，则从状态栈和文法符号栈中自栈顶向下去掉r 个符号。
并把A 移入文法符号栈内，再把满足Sj=GOTO[Si ，A]的状态移进状态栈，其中Si 为修改指针后的栈顶状态。
接受acc ：当归约到文法符号栈中只剩下文法的开始符号S 时，并且输入符号串已结束即当前输入符是‘#’，则为分析成功。
报错：当遇到状态栈顶为某一状态下出现不该遇到的文法符号时，则报错，说明输入串不是该分发能接受的句子。
3.2语法分析表设计3.2.1构造文法的DFAI0:S ’->.SS->.do{E;}while(B)I1:S ’->S.I2:S->do.{E;}while(B) I3:S->do{.E;}while(B) E->.I= I op I I->.id输入串XXX …#总控程序 ACTION 表GOTO 表Sn . . S1 S0 Xn . . X1 #SP输出I4:S->do{E.;}while(B) I5:E->I . =I op I I6:I->id.I7:S->do{E;.}while(B) I8:E->I=.I op I I->.idI9:S->do{E;}.while(B) I10:E->I = I. op II11:S->do{E;}while.(B) I12:E->I=I op .I I=.idI13:S->do{E;}while(.B) B->.I rop I I->.idI14:E->I=I op I.I15:S->do{E;}while(B.) I16:B->I .rop II17:S->do{E;}while(B). I18:B->I rop .I I19:B->IropI.3.2.2然后写出LR 分析表：状态ACTIONGOTO Do { = ; } While ( ) Rop Op Id #S B EI 0 S21 1 acc2 S3I1I0I19I4I13I9I14I15I12I6I10I8I2I7I16I11I5I3I17I183 S64 54 S75 S86 R4 R4 R4 R4 R4 R4 R4 R4 R4 R4 R4 R47 S98 S6 109 S1110 S1211 S1312 S1413 S6 15 1614 R3 R3 R3 R3 R3 R3 R3 R3 R3 R3 R3 R315 S1716 S1817 R1 R1 R1 R1 R1 R1 R1 R1 R1 R1 R1 R118 S6 1919 R2 R2 R2 R2 R2 R2 R2 R2 R2 R2 R2 R24.中间代码形式的描述及中间代码序列的结构设计4.1中间代码形式的描述在本程序中作用三地址码表示中间代码三地址码的表达形式为：标号结果：= 操作数1 操作符操作数2常见三地址表示举例：赋值语句t1 := a op b，a:= b条件转移if true goto Label无条件转移goto Label4.2中间代码序列的结构设计本程序用标号来表示程序的跳转过程，示例如下100 赋值语句101赋值语句102 条件跳转语句103 无条件转移语句…5.编译系统的概要设计本编译程序的结构图如下：源程序(do-while 语句)词法分析(Lex函数)语法语义分析（Analyze函数）代码生成程序程序输出说明：源程序（do-while语句）通过控制台输入。
然后通过Lex函数对输入的源程序进行分析后，将分析结果以二元组的方式输出到控制台。
接下来通过调用语法语义分析函数来完成对分析得到的单词进行文法句子的识别，并用进行语法制导翻译，完成属性文法定义规定的相关语义动作。
本编译程序最后完成的三地址码输出是通过中间文件间接输出到控制台上的。
在执行Analyze函数的过程中，同时运用ofstream文件流将三地址码输出到一个ASCII码的txt类型文件中，最后从该文件中读出最终处理的三地址码输出至控制台。
6.详细的算法描述（流程图或伪代码）6.1词法分析词法分析程序要做的工作是：从源程序的第一个字符开始，顺序读字符，一次读一个，根据所读进的字符识别各类单词，同时去掉源程序中的空白和注释。
词法分析检查的错误主要是挑出源程序中出现的非法符号。
下面为本程序中所用来进行词法分析的伪代码：输入字符；If(字符是字母){查找关键词表；If(是关键字do或者while)识别关键词;Else 判断为标识符；}Else if(字符是数字)获取整个数;Else if(运算符){If(是算术运算符)识别算术运算符；Else 识别为关系运算符;}Else 标识为其他类型以下附部分源码:int Lex(char InStr[20][8],int InStrLen){//0关键字，1标识符2数字3界符4算符5其他char strsrc[BUFFURSIZE],strdst[8],ch;int strcount=0,strLength,i=0;cout<<"Please input the do-while statement:"<<endl;gets(strsrc);strLength=strlen(strsrc);cout<<endl<<" Lexical Analyse:"<<endl;while(strcount<strLength){while(strsrc[strcount]==' ') strcount++;ch=strsrc[strcount];if(Alpha(ch)){i=0;do strdst[i++]=strsrc[strcount++];while((Alpha(strsrc[strcount])||Digit(strsrc[strcount]))&&(strcount<strLength));strdst[i]='\0';if(!strcmp(strdst,"while"))cout<<setw(10)<<"(0,"<<strdst<<")"<<endl;elsecout<<setw(10)<<"(1,"<<strdst<<")"<<endl;for(int k=0;strdst[k]!='\0';k++){InStr[InStrLen][k]=strdst[k];}InStr[InStrLen++][k]='\0';}else if(Digit(ch)){i=0;do strdst[i++]=strsrc[strcount++];while(Digit(strsrc[strcount])&&(strcount<strLength));strdst[i]='\0';cout<<setw(10)<<"(2,"<<strdst<<")"<<endl;for(int k=0;strdst[k]!='\0';k++){InStr[InStrLen][k]=strdst[k];}InStr[InStrLen++][k]='\0';}else if(Oper(ch)){i=0;strdst[i]=ch;strdst[i+1]='\0';if(!strcmp(strdst,";")||!strcmp(strdst,"(")||!strcmp(strdst,")")||!strcmp(strdst,"{")||!st rcmp(strdst,"}"))cout<<setw(10)<<"(3,"<<ch<<")"<<endl;elsecout<<setw(10)<<"(4,"<<ch<<")"<<endl;for(int k=0;strdst[k]!='\0';k++){InStr[InStrLen][k]=strdst[k];}InStr[InStrLen++][k]='\0';strcount++;}else{cout<<setw(10)<<"(5,"<<ch<<")"<<endl;isillegal=1; cout<<"isillegal="<<isillegal<<endl;cout<<"not while statement "<<endl;break;strcount++;}}InStr[InStrLen++][0]='#';cout<<"inputed string"<<endl;for(int j=0;j<InStrLen;j++)cout<<" "<<InStr[j];cout<<"grammer analysis"<<'\n';return InStrLen;}6.2语法分析流程图如下，具本处理过程，请参见本文档3.1小节此处附上语法语义分析函数 void Analyze(State state) {int row=0,col=0,numchange=0;cout<<" Procedure"<<endl; cout.setf(ios::left); cout<<"step"<<""<<setw(20)<<"STATESTACK"<<setw(20)<<"SYMBOLSTACK"<<setw(20)<<"IN PUT"<<setw(8)<<"ACTION"<<setw(6)<<"GOTO"<<endl;strcpy(next,state.InStr[state.CurInstr]); ropOrOp(next);row=state.stkState[state.CurState]; col=Index(next);numchange=table[row][col];输入串XXX …#总控程序 ACTION 表GOTO 表Sn . . S1 S0 Xn . . X1 #SP输出ofstream outfile("do_while.txt");while(strcmp(state.stkSymbol[state.CurSymbol],"S")!=0&&numchange!=20) {if(numchange==0){isillegal=1;break;}numchange=Action(state,numchange,outfile);}if(isillegal==0){cout<<setw(4)<<step++<<" ";state.showState();cout<<setw(8)<<"acc"<<endl;}cout<<"processing semantic analysis"<<endl;system("PAUSE");}关键的状态转移函数ACTION和GOTOint Action(State &state,int actionnum,ofstream &outfile){int row=0,col=0,numchange=0;int choice=0;int ct=100;int m=0;if(actionnum>=1&&actionnum<=18)choice=1;else choice =actionnum;switch(choice){case 0:{isillegal=1;cout<<"isillegal="<<isillegal<<endl;break;}case 1://移进项目{cout<<setw(4)<<step++<<" ";state.showState();cout<<setw(8)<<actionnum<<endl;state.CurState++; s tate.stkState[state.CurState]=actionnum;state.CurSymbol++;strcpy(state.stkSymbol[state.CurSymbol],state.InStr[state.CurInstr]);strcpy(next,state.InStr[state.CurInstr]);ropOrOp(next);row=state.stkState[state.CurState];col=Index(next);numchange=table[row][col];break;}case 20://接收{cout<<setw(4)<<step++<<" ";state.showState();cout<<setw(8)<<"acc"<<endl;break;}case 21://r1 S-->while(B){E;}{cout<<setw(4)<<step++<<" ";state.showState();cout<<setw(8)<<actionnum;for(int i=9;i>0;i--){state.stkState[state.CurState--]=0;}for(i=9-1;i>=0;i--){strcpy(B[i],state.stkSymbol[state.CurSymbol]);strcpy(state.stkSymbol[state.CurSymbol--],"");}outfile<<"B.false: "<<'\n';state.CurSymbol++;strcpy(state.stkSymbol[state.CurSymbol],"S"); //B-->IropI strcpy(next,state.stkSymbol[state.CurSymbol]);ropOrOp(next);row=state.stkState[state.CurState];col=Index(next);numchange=table[row][col];numchange=Goto(state,numchange);break;}case 22://r2 B-->IropI{cnt=0;cout<<setw(4)<<step++<<" ";cout<<setw(8)<<actionnum;for(int i=3;i>0;i--){state.stkState[state.CurState--]=0;}for(i=3-1;i>=0;i--){strcpy(B[i],state.stkSymbol[state.CurSymbol]);strcpy(state.stkSymbol[state.CurSymbol--],"");}outfile<<"102 t1:="<<I[0]<<B[1]<<I[1]<<endl;outfile<<"103 if t1.val=true"<<" goto 100"<<endl;outfile<<"104 goto 105"<<endl;state.CurSymbol++;strcpy(state.stkSymbol[state.CurSymbol],"B"); //归约B-->IropI strcpy(next,state.stkSymbol[state.CurSymbol]);ropOrOp(next);row=state.stkState[state.CurState];col=Index(next);numchange=table[row][col];numchange=Goto(state,numchange);break;}case 23://r3 E-->I=IopI{cnt=0;cout<<setw(4)<<step++<<" ";state.showState();cout<<setw(8)<<actionnum;for(int i=5;i>0;i--){state.stkState[state.CurState--]=0;}for(i=5-1;i>=0;i--){strcpy(E[i],state.stkSymbol[state.CurSymbol]);strcpy(state.stkSymbol[state.CurSymbol--],"");}outfile<<"100 "<<"t1:="<<I[1]<<E[3]<<I[2]<<endl;outfile<<"101 "<<I[0]<<":=t1"<<endl;state.CurSymbol++;strcpy(state.stkSymbol[state.CurSymbol],"E");strcpy(next,state.stkSymbol[state.CurSymbol]);ropOrOp(next);row=state.stkState[state.CurState];col=Index(next);numchange=table[row][col];numchange=Goto(state,numchange);break;}case 24://r4归约I-->id{cout<<setw(4)<<step++<<" ";state.showState();cout<<setw(8)<<actionnum;state.stkState[state.CurState--]=0;strcpy(I[cnt++],state.stkSymbol[state.CurSymbol]);//{I.value=id.value}strcpy(state.stkSymbol[state.CurSymbol],"I"); //归约I-->idstrcpy(next,state.stkSymbol[state.CurSymbol]);ropOrOp(next);row=state.stkState[state.CurState];col=Index(next);numchange=table[row][col];numchange=Goto(state,numchange);break;}}return numchange;}int Goto(State &state,int gotonum){int row=0,col=0,numchange=0;cout<<setw(6)<<gotonum<<endl;state.CurState++;state.stkState[state.CurState]=gotonum;strcpy(next,state.InStr[state.CurInstr]);ropOrOp(next);row=state.stkState[state.CurState];col=Index(next);return table[row][col];}7.软件的测试方法和测试结果(1)运行程序，显示如下程序界面(2)按照提示输入合法的do-while语句Do{a=b+c;}while(a<b)(3)按enter确定输入完毕，得到词法分析结果,显示如下：并且最后一行提示了经过词法分析后合法的待输入串在栈中的存储情况。