FOR循环语句翻译程序设计简单优先法三地址码JAVA
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循环语句的文法所描述的形式。
通过简单优先法对语句进行分析，看是否能通过给定的输入串归约到文法的开始符号。
编译原理报告for循环语句的翻译程序
学号：0120810680326课程设计题目f or循环语句的翻译程序学院计算机学院专业软件工程班级0803姓名徐泽前指导教师何九周2011 年 6 月日目录1设计目的 (4)2设计环境与工具 (4)3设计任务要求与说明 (4)4设计时间 (4)5设计地点 (4)6系统描述 (4)7文法及属性文法的描述 (5)7.1文法描述 (5)7．1．1 FOR语句相关的产生式： (5)7．1．2 布尔表达式： (5)7．1．3 赋值表达式： (5)7．2属性文法的描述 (5)8 语法分析方法描述及语法分析表设计 (7)8．1语法分析方法描述 (7)8．2系统中使用的action和goto表（见附录1） (9)9 给出中间代码形式的描述及中间代码序列的结构设计 (9)10简要的分析与概要设计 (10)11 详细的算法描述 (11)11．1词法分析的数据结构设计与详细的流程图 (11)11.2词法分析流程图 (11)11.3语法制导翻译的数据结构与详细的设计图 (12)11.3.1数据结构的设计 (12)11.3.2算法描述 (13)11.3.3程序流程图 (13)12给出软件的测试方法和测试结果 (14)12.1 FOR循环语句的测试 (14)12.2词法分析出错处理 (15)12.3语法分析出错处理 (16)13收获与体会 (16)14 参考文献 (17)课程设计任务书学生姓名：徐泽前专业班级：软件0803班指导教师：何九周工作单位：计算机学院题目: for循环语句的翻译程序初始条件：程序设计语言:主要使用C语言的开发工具，或者采用LEX、YACC等工具，也可利用其他熟悉的开发工具。
算法：可以根据《编译原理》课程所讲授的算法进行设计。
要求完成的主要任务:（包括课程设计工作量及其技术要求，说明书撰写等具体要求）1.明确课程设计的目的和重要性，认真领会课程设计的题目，读懂课程设计指导书的要求，学会设计的基本方法与步骤，学会如何运用前修知识与收集、归纳相关资料解决具体问题的方法。
简述for循环语句的执行顺序,举例说明
For循环是一种常用的控制流语句，用于重复执行特定的代码块。
它的执行顺序如下所述:1. 程序先执行for循环的初始化部分，例如for(int i=0; i<5; i++)中的i=0。
2. 程序会检查循环条件是否为真，即i<5是否成立。
3. 如果循环条件为真，则程序执行循环体内的代码块。
4. 循环体执行完毕后，程序会执行for循环的更新部分，例如i++。
5. 然后程序会再次检查循环条件，如果仍然为真，则重复执行循环体内的代码块；否则，退出for循环，继续执行下一条语句。
举例说明:假设有如下的for循环语句:```for(int i=0; i<5; i++) {System.out.println("Hello, world!");}```根据上述的执行顺序，该for循环的执行流程如下:1. 初始化部分: i=02. 检查循环条件: i<53. 循环体内执行: 打印"Hello, world!"4. 更新部分: i++5. 再次检查循环条件: i<56. 循环体内执行: 打印"Hello, world!"7. 更新部分: i++8. 再次检查循环条件: i<59. 循环体内执行: 打印"Hello, world!"10. 更新部分: i++11. 再次检查循环条件: i<512. 循环体内执行: 打印"Hello, world!"13. 更新部分: i++14. 再次检查循环条件: i<515. 循环体内执行: 打印"Hello, world!"16. 更新部分: i++17. 再次检查循环条件: i<5 (此时不成立，跳出for循环)上述的for循环语句将会执行5次，分别打印出5次"Hello, world!"。
java中的4种循环方法示例详情
java中的4种循环⽅法⽰例详情⽬录java循环结构1.while循环2.do…while循环3.for循环4.java 增强for循环java循环结构顺序结构的程序语句只能被执⾏⼀次。
如果你要同样的操作执⾏多次，就需要使⽤循环结构。
java中有三种主要的循环结构：while 循环do...while 循环for 循环在java5中引⼊⼀种主要⽤于数组的增强型for循环。
1.while循环while是最基本的循环，它的结构为：package com.example.lesson1;//while（布尔（true/false）表达式）{//循环内容//只要布尔表达式为 true 循环体就会⼀直执⾏下去。
//来看看实例吧:public class Test {public static void main(String args[]) {int x = 10;while (x < 20) {System.out.print("value of x :" + x);x++;System.out.print("\n");}}}以上实例编译运⾏结构如下：value of x : 10value of x : 11...value of x : 192.do…while循环对于while语句⽽⾔，如果不满⾜条件，则不能进⼊循环。
但有时候我们需要即使不满⾜条件，也⾄少执⾏⼀次。
do…while循环和while循环相同，不同的是，do…while循环⾄少会执⾏⼀次。
package com.example.lesson1;//do{// //代码语句// }while（布尔值表达式）；// 注意：布尔表达式在循环体的后⾯，所以语句块在检测布尔表达式之前已经执⾏了。
如果布尔表达式值为true，则语句块//⼀直执⾏，直到布尔表达式的值为false。
// 实例:public class Test {public static void main(Staing args[]) {int x = 10;do {System.out.print("value of x :" + x);x++;System.out.print("\n");} while (x < 20);}}以上实例编译运⾏结果如下：value of x : 10...value of x :193.for循环虽然所有循环结构都可以⽤while或者do…while表⽰，但java提供了另⼀种语句（for循环），使⼀些循环结构变得更简单。
java for循环用法
java for循环用法
java for循环是一种用来重复执行语句的语句结构。
for循环通
常用于重复执行固定次数的语句，在循环次数确定的前提下，可以节
省编程的时间和工作量，更加简洁高效。
本文将对java for循环进行
详细介绍。
java for循环的基本语法：
for(初始化语句; 条件判断; 循环后要执行的语句) {
//代码段
}
for循环共分为3个部分，初始化语句，条件判断，循环后要执
行的语句。
•初始化语句：在for循环开始之前，需要对变量进行初始化，通常是声明变量并赋值，用于在循环过程中保存循环次数。
•条件判断：在循环内部，会不断的判断某个变量的值，当
变量的值满足条件，就继续循环，否则跳出循环。
•循环后要执行的语句：在每一次循环结束后，都会执行的
语句，通常是改变变量的值，以便开始下一轮循环。
for循环的好处在于，不管循环次数是多少，都可以通过相同的
方式来实现，大大节省了编程的工作量，对于简单重复性操作很有用。
此外，java中还有另一种for循环——foreach循环，此循环用
于遍历集合中的元素，当拥有一个元素的集合时，可以使用foreach
循环来遍历元素，节省更多的时间和工作量。
总之，java for循环是一种非常实用的语句结构，能够减少编程的工作量，简化程序流程，是不可或缺的编程技术。
java foreach循环用法
Java foreach循环用法在Java编程中，我们经常需要遍历数组或集合中的元素。
为了简化遍历的过程，Java提供了foreach循环（也称为增强for循环），它能够以一种简洁而直观的方式遍历数组或集合中的元素。
本文将详细介绍Java foreach循环的用法和注意事项。
1. foreach循环语法foreach循环是一种迭代器模式，它可以遍历数组或实现了Iterable接口的集合类。
其语法如下：for (元素类型变量名 : 数组或集合) {// 执行代码块}其中，元素类型代表数组或集合中元素的类型，变量名代表每次迭代获取到的当前元素。
2. 遍历数组使用foreach循环遍历数组非常简单和方便。
下面是一个示例代码，展示了如何使用foreach循环遍历整型数组并打印每个元素：int[] numbers = {1, 2, 3, 4, 5};for (int number : numbers) {System.out.println(number);}输出结果为：12345上述代码中，我们定义了一个整型数组numbers并初始化了一些值。
然后使用foreach循环逐个获取数组中的元素，并通过System.out.println()方法打印出来。
3. 遍历集合除了数组，我们还可以使用foreach循环遍历实现了Iterable接口的集合类，例如ArrayList、LinkedList等。
下面是一个示例代码，展示了如何使用foreach循环遍历ArrayList并打印每个元素：import java.util.ArrayList;ArrayList<String> fruits = new ArrayList<>();fruits.add("apple");fruits.add("banana");fruits.add("orange");for (String fruit : fruits) {System.out.println(fruit);}输出结果为：applebananaorange上述代码中，我们创建了一个ArrayList对象fruits并添加了一些水果名称。
for循环遍历用法
for循环遍历用法说到“for循环”，估计很多人脑袋里就浮现出一堆乱七八糟的代码符号，嗯，这就是编程世界的常态吧！但其实呢，这个看似复杂的东西，真的可以说是编程中的一颗“小太阳”，无论你是刚接触编程的新手，还是已经在代码的海洋里畅游多年的大牛，都会经常用到它。
你想啊，生活中，我们不也总是有许多事情要一遍又一遍地做吗？比如说，早晨起床拿起杯子准备倒水，这动作不是做一次，而是每天都得做，是不是？“for 循环”就有点像我们每天的惯性动作，反复的、按一定规律执行的。
“for循环”就是为了让我们不必重复写很多次类似的代码。
你就想象一下，如果你需要打印从1到10的数字，假如不使用“for循环”，你得写10行代码，每行都写一个`print`语句，那简直像是在做无意义的重复劳动，对吧？让你看了都想给自己泡杯茶休息休息。
那么如果用上了“for循环”呢？一行代码搞定！那感觉简直像是找到了隐藏的快捷键，省时省力，事半功倍，效率提升得飞起。
就像你平时刷朋友圈，刷到一个短视频，心情一下子变得愉快了，大家都是追求轻松和高效的。
你可能会问，什么是“for循环”呢？嗯，简单来说，“for循环”就是让你把某些重复的工作交给电脑来做。
比方说，你想要遍历一个列表，看看里面都有哪些元素。
假设你有一个水果清单：苹果、香蕉、橙子、葡萄。
你如果要一一打印这些水果的名字，用“for循环”来做，那就是给自己找了个万能的“搬运工”。
你只需要告诉它：“嘿，帮我从这个清单里拿出每个水果名打印出来就行了。
”然后，它就会乖乖的按顺序拿出清单中的每一个水果，并且给你打印出来，像一个可靠的助手一样。
看起来是不是简单得让人心情大好？而且呀，最妙的是，这个“for循环”还挺灵活的。
你不仅可以遍历列表，还能遍历其他东西。
比如，遍历数字区间，或者遍历字符串中的每一个字符，甚至可以遍历字典中的键和值，凡是你能想到的，几乎都能用它搞定。
如果你有一个数字1到5的范围，用“for循环”遍历一遍，它能帮你做出精准的输出，不会漏掉任何一个细节。
java循环比较语句
java循环比较语句在Java中，循环比较语句用于在满足一定条件时重复执行某段代码。
下面列举了10个常用的循环比较语句，分别是：for循环、while 循环、do-while循环、foreach循环、break语句、continue语句、return语句、if语句、switch语句、三元运算符。
1. for循环：for循环是一种常用的循环语句，用于在满足一定条件时重复执行某段代码。
for循环由三部分组成：初始化语句、循环条件和循环迭代语句。
例如：```for (int i = 0; i < 10; i++) {System.out.println(i);}```以上代码将输出0到9的数字。
2. while循环：while循环是一种在满足循环条件的情况下重复执行某段代码的循环语句。
例如：```int i = 0;while (i < 10) {System.out.println(i);i++;}```以上代码同样输出0到9的数字。
3. do-while循环：do-while循环先执行一次循环体，然后再判断循环条件是否满足，如果满足则继续执行循环体，否则结束循环。
例如：```int i = 0;do {System.out.println(i);i++;} while (i < 10);```以上代码同样输出0到9的数字。
4. foreach循环：foreach循环用于遍历数组或集合中的元素，无需手动控制循环变量。
例如：```int[] nums = {1, 2, 3, 4, 5};for (int num : nums) {System.out.println(num);}```以上代码将输出数组中的每个元素。
5. break语句：break语句用于在循环中提前结束循环。
例如：```for (int i = 0; i < 10; i++) {if (i == 5) {break;}System.out.println(i);}```以上代码在i等于5时提前结束循环。
Java基础2—{循环语句（for、while、do...while）、控制跳转语句（br。。。
Java基础2—{循环语句（for、while、do...while）、控制跳转语句（br。
1、循环语句1.1 for语句(1）for语句的格式：for(初始化表达式语句;判断条件语句;控制条件语句) {循环体语句;}（2）执⾏流程：a:执⾏初始化表达式语句b:执⾏判断条件语句,看其返回值是true还是false如果是true，就继续执⾏如果是false，就结束循环c:执⾏循环体语句;d:执⾏控制条件语句e:回到b继续。
(3)注意事项：初始化表达式语句只执⾏⼀次判断条件语句⽆论简单还是复杂结果是boolean类型。
循环体语句如果是⼀条语句，⼤括号可以省略；如果是多条语句，⼤括号不能省略。
建议不要省略。
1.2 for语句案例演⽰1需求：在控制台输出所有的”⽔仙花数”所谓的⽔仙花数是指⼀个三位数，其各位数字的⽴⽅和等于该数本⾝。
举例：153就是⼀个⽔仙花数。
153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153 2代码：3public class Demo01{4public static void main(String[] args) {5int count=0;6for (int i = 100; i <= 999; i++) {7int ge = i / 1 % 10;8int shi = i / 10 % 10;9int bai = i / 100 % 10;10int flowerNumber=ge*ge*ge+shi*shi*shi+bai*bai*bai;11if(flowerNumber==i){12 System.out.println("⽔仙花数是: "+i);13 count++;14 }15 }16 System.out.println("⽔仙花数有"+count+"个");17 }18 }运⾏结果：1.3 while语句1（1）while语句的格式：2 while循环的基本格式：3while(判断条件语句) {4循环体语句;5 }6完整格式：7初始化条件语句;8while(判断条件语句) {9循环体语句;10控制条件语句;11 }12（2）while语句执⾏流程：13 a:执⾏初始化条件语句;14 b:执⾏判断条件语句,看其返回值是true还是false15如果是true，就继续执⾏16如果是false，就结束循环17 c:执⾏循环体语句;18 d:执⾏控制条件语句19 e:回到b继续。
Java中for的几种用法
Java中for的几种用法J2SE 提供了另一种形式的for循环。
借助这种形式的for循环，可以用更简单地方式来遍历数组和Collection等类型的对象。
本文介绍利用这种循环的具体方式，说明如何自行概念能被这样遍历的类，并解释和这一机制的一些常见问题。
在Java程序中，要“一一处置”――或说，“遍历”――某一个数组或Collection 中的元素的时候，一般会利用一个for循环来实现（固然，用其它种类的循环也不是不可以，只是不知道是因为for这个词的长度比较短，仍是因为for这个词的含义和这种操作比较配，在这种时候for循环比其它循环常常利用得多）。
对于遍历数组，这个循环一般是采取这样的写法：清单1：遍历数组的传统方式/* 成立一个数组*/int[] integers = {1，2，3，4};/* 开始遍历*/for (int j = 0; j<; j++){int i = integers[j];而对于遍历Collection对象，这个循环则一般是采用这样的形式：清单2：遍历Collection对象的传统方式/* 成立一个Collection */String[] strings = {"A"，"B"，"C"，"D"};Collection stringList = 开始遍历*/for (Iterator itr = (); ();) {Object str = ();而在Java语言的最新版本――J2SE 中，引入了另一种形式的for循环。
借助这种形式的for循环，此刻可以用一种更简单地方式来进行遍历的工作。
1. 第二种for循环不严格的说，Java的第二种for循环大体是这样的格式：for (循环变量类型循环变量名称: 要被遍历的对象) 循环体借助这种语法，遍历一个数组的操作就可以够采取这样的写法：清单3：遍历数组的简单方式/* 成立一个数组*/int[] integers = {1，2，3，4};/* 开始遍历*/for (int i : integers) {依次输出“1”、“2”、“3”、“4” */}这里所用的for循环，会在编译期间被看成是这样的形式：清单4：遍历数组的简单方式的等价代码/* 成立一个数组*/int[] integers = {1，2，3，4};/* 开始遍历*/for (int 变量名甲= 0; 变量名甲<; 变量名甲++)="" {变量名甲]);/* 依次输出“1”、“2”、“3”、“4” */}这里的“变量名甲”是一个由编译器自动生成的不会造成混乱的名字。
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循环语句的翻译程序进行设计，使用高级语言或者伪代码形式，进行编写，其中要求使用简单优先法法并在程序的最终结果中显示出表达式的三地址形式。
详解for循环（各种用法）
详解for循环（各种⽤法）常见的for循环⼀般是⼀下代码这种结构：for (int i = 0; i < 100; i++){Console.WriteLine(i);}或者递减的：for (int i = 100; i > 0 ; i--){Console.WriteLine(i);}但for当然不⽌这样⼀种⽤法。
for的定义，()内的三段表达式，除了中间的必须产⽣布尔型，并未对其余两段有所限制，只要是表达式就可以了。
在中就有好⼏次这样的⽤法。
例如：for (Token token = input.Next(result); token != null; token = input.Next(result)){int len = token.TermText().Length;if (len >= min && len <= max){return token;}}这个语句和下⾯代码的效果是⼀样的：Token token;while((token = input.Next(result)) != null){int len = token.TermText().Length;if (len >= min && len <= max){return token;}}其实我认为在这两种循环中，第⼆种⽐第⼀种好理解⼀点。
还有这种for (i = 75; i-- > 0; )jjrounds[i] = 0x80000000;出了⼀个空表达式，呵呵。
其实理解⼀下也很简单，和下⾯代码的效果⼀样：for (i = 75; i > 0; i--)jjrounds[i] = 0x80000000;朋友留⾔指正，修正以上代码为：for(i = 74;i > 0;i--){jjrounds[i] = 0x80000000;}空表达式，也是⼀个表达式啊，放在这⾥也不犯法。
java中for循环写法
java中for循环写法在Java中，for循环是一种常用的循环结构，用于重复执行一段代码，可以按照指定的条件和步长进行迭代。
下面我将从不同的角度介绍Java中for循环的写法。
1. 基本写法：for (初始化语句; 循环条件; 循环迭代) {。
// 循环体代码。
}。
初始化语句在循环开始前执行一次，循环条件用于判断是否继续循环，循环迭代用于每次循环结束后执行，循环体代码是需要重复执行的代码块。
2. 初始化语句：初始化语句用于初始化循环控制变量，可以是声明和赋值语句，也可以是多个语句用逗号分隔。
for (int i = 0; i < 10; i++) {。
// 循环体代码。
}。
3. 循环条件：循环条件是一个布尔表达式，用于判断是否继续执行循环。
当循环条件为true时，继续执行循环；当循环条件为false时，跳出循环。
for (int i = 0; i < 10; i++) {。
// 循环体代码。
}。
4. 循环迭代：循环迭代用于每次循环结束后对循环控制变量进行操作，可以是递增或递减操作，也可以是其他复杂的操作。
for (int i = 0; i < 10; i++) {。
// 循环体代码。
}。
5. 循环体代码：循环体代码是需要重复执行的代码块，可以是单条语句或多条语句的组合。
循环体代码执行完毕后，再次判断循环条件，如果满足条件则继续执行循环，否则跳出循环。
for (int i = 0; i < 10; i++) {。
// 循环体代码。
}。
6. 嵌套循环：在循环体中可以再次使用循环结构，形成嵌套循环，用于处理更复杂的问题。
for (int i = 0; i < 10; i++) {。
for (int j = 0; j < 5; j++) {。
// 循环体代码。
}。
}。
以上是关于Java中for循环的基本写法和相关要点的介绍。
通过灵活运用for循环，可以实现各种不同的循环需求。
循环指令代码
循环指令代码循环指令是在计算机程序中实现重复执行一段代码的一种常见方法。
循环指令有助于简化程序结构，提高代码的可读性和可维护性。
在不同的编程语言中，循环指令的实现方式略有不同，下面将以几种常见的编程语言为例，介绍循环指令的相关内容。
1. C语言中的循环指令：C语言提供了三种主要的循环指令：for循环、while循环和do-while循环。
这些循环指令的基本语法如下：- for循环：```cfor (初始化表达式; 终止条件; 更新表达式) {// 循环体}```- while循环：```cwhile (条件表达式) {// 循环体}```- do-while循环：```cdo {// 循环体} while (条件表达式);```2. Python语言中的循环指令：Python语言提供了两种主要的循环指令：for循环和while循环。
这些循环指令的基本语法如下：- for循环：```pythonfor 变量 in 序列:# 循环体```- while循环：```pythonwhile 条件表达式:# 循环体```3. Java语言中的循环指令：Java语言提供了三种主要的循环指令：for循环、while循环和do-while循环。
这些循环指令的基本语法如下：- for循环：```javafor (初始化语句; 条件表达式; 更新语句) {// 循环体}```- while循环：```javawhile (条件表达式) {// 循环体}```- do-while循环：```javado {// 循环体} while (条件表达式);```4. JavaScript语言中的循环指令：JavaScript语言提供了两种主要的循环指令：for循环和while 循环。
这些循环指令的基本语法如下：- for循环：```javascriptfor (初始化表达式; 终止条件; 更新表达式) {// 循环体}```- while循环：```javascriptwhile (条件表达式) {// 循环体}```以上介绍的是几种常见编程语言中的循环指令的基本语法，循环指令还有一些高级用法，比如嵌套循环、循环控制语句（如break、continue）、循环的初始化和更新表达式可以使用多个变量等。
java for循环的三种写法
在Java中，有三种常见的方式可以使用`for`循环。
下面是这三种写法的示例：1. 基本`for`循环：```javafor (初始化; 条件; 更新) {// 循环体代码}```示例：```javafor (int i = 0; i < 5; i++) {System.out.println("当前值为: " + i);}```2. 增强`for`循环（也称为`foreach`循环）：```javafor (元素类型元素变量 : 遍历对象) {// 循环体代码}```示例：```javaint[] nums = {1, 2, 3, 4, 5};for (int num : nums) {System.out.println("当前值为: " + num);}```3. `for-each`循环（用于遍历集合类对象）：```javafor (元素类型元素变量 : 集合对象) {// 循环体代码}```示例：```javaList<String> names = Arrays.asList("Alice", "Bob", "Charlie");for (String name : names) {System.out.println("当前名字为: " + name);}```这三种写法都可以实现循环控制，并根据不同的需求选择合适的方式。
基本`for`循环提供了更大的灵活性，适用于需要手动管理循环变量和更新条件的情况。
增强`for`循环和`for-each`循环则更加简洁，适用于遍历数组或集合对象的场景。
Java循环结构（while、do...while、for），break和continue。。。
Java循环结构（while、do...while、for），break和continue。
现在有⼀个需求：打印1-100的数字，每10个换⼀⾏。
如果我们直接使⽤输出语句的话，会打印到崩溃。
Java中除了有顺序结构、选择结构，也有循环结构，可以⽤循环结构来解决这个问题：从定义⼀个变量⼀开始为1，每输出⼀个数，变量就+1，直到变量等于100，就结束。
Java中有三种循环：while，do...while，for1.while语法：初始化语句；while（条件表达式）{ //循环体//满⾜条件（为 true 时）执⾏语句//迭代语句（退出机制，当不再满⾜条件时就会退出）}//不满⾜条件则会直接跳过package com.dh.control;public class WhileDemo {public static void main(String[] args) {//1.初始化变量int i = 1;//count⽤于计数（10个数换⼀⾏）int count = 0;while(i<=100){ //2.条件表达式//3.执⾏语句System.out.print(i+"\t");count++; //计数器+1if(count%10 == 0){System.out.println();}//4.迭代语句（退出机制）i++;}}}注意：如果没有退出机制，或者条件永远为true时，程序就没有办法跳出循环，程序就会⼀直运⾏，称为死循环。
⼀定要尽量避免书写死循环程序，除⾮真的有使⽤死循环的需求！while(true){}2.do...while语法：初始化语句；do{//循环执⾏体//迭代语句}while（条件表达式）; //不满⾜条件表达式则跳过则结束循环语句将上述问题，采⽤do...while循环来解决：package com.dh.control;public class DoWhile {public static void main(String[] args) {int i = 1;int count = 0;do{System.out.print(i+"\t");i++;count++;if(count%10 == 0){System.out.println();}}while (i<=100);}}那while和do...while有什么区别呢？看下⾯这个案例package com.dh.control;public class Demo {public static void main(String[] args) {int i = 1;//do...whiledo {System.out.println("do...while执⾏了");} while (i < 0);//whilewhile (i < 0) {System.out.println("while执⾏了");}}}通过观察实验结果，可以看出do...while和while的⽤法是⼀致的，只不过do…while 先执⾏再判断（⽆论如何都会先执⾏⼀次循环执⾏体中的代码）、while 是先判断再执⾏，如果条件⼀开始就不满⾜，就不会执⾏循环执⾏体代码。
for循环的代码
for循环的代码循环结构是编程语言中的一种重要控制结构，其目的是为了重复执行一段代码，直到满足某个条件结束循环。
在各种编程语言中，最常用的循环结构是for循环。
for循环通常具有以下几个关键部分：- 初始化语句：一般用于初始化循环变量，指定循环的起始状态。
- 循环条件：判断循环是否继续执行的条件。
- 循环体：需要重复执行的代码部分。
- 更新循环变量：循环体执行完毕后，通常需要更新循环变量的值，使其趋近于循环条件。
下面是一个使用for循环计算1到100的整数和的例子：```pythonsum = 0for i in range(1, 101):sum += iprint("1到100的整数和为：", sum)```在这个例子中，我们首先初始化了一个变量`sum`，并将其赋值为0。
然后，使用for循环遍历从1到100的整数。
在每一次循环中，将当前整数加到`sum`中。
循环结束后，输出最终结果。
以上是一个简单的使用for循环的例子，接下来我们将展示更复杂的应用场景来探索for循环的更多用法。
###### 1. 遍历列表在编程中，经常需要对列表、数组等数据结构进行遍历操作。
for循环是处理这类任务的理想选择。
以下是一个使用for循环遍历列表并打印出所有元素的示例：```pythonfruits = ["apple", "banana", "orange", "grape"]for fruit in fruits:print(fruit)```在这个例子中，我们定义了一个列表`fruits`，其中包含了几种水果。
然后，使用for循环遍历列表中的每一个元素，将其赋值给变量`fruit`，并打印出来。
###### 2. 嵌套循环除了对单个数据结构进行遍历，for循环还可以嵌套使用，用于处理多维的数据结构。
以下是一个使用双层嵌套循环打印九九乘法表的例子：```pythonfor i in range(1, 10):for j in range(1, i+1):print(f"{j}x{i}={i*j}", end="\t")print()```在这个例子中，外层循环控制着被乘数（1到9），内层循环控制着乘数（1到当前的被乘数）。
for循环的三种写法
for循环的三种写法for环是常用的编程技术，它可以用来重复执行一定次数的代码，在许多编程语言中，for循环有三种不同的写法，分别为：for-in环、for-of环、for-each环。
一、for-in环for-in环是一种最常见的 for环，也是最简单的一种写法，用它可以遍历可迭代对象，如数组、字符串、对象等等。
for-in循环的一般格式如下：for (variable in object) {statement}其中，variable是一个变量，object是要被遍历的对象，而statement则是要在每次循环迭代中要执行的代码。
例如：//历数组const array = [1, 2, 3, 4, 5];for (let i in array) {console.log(i);}//出结果为：0 1 2 3 4二、for-of环for-of环是ES6提出的标准，它允许我们遍历迭代对象（如数组、字符串、Map等）但是不允许遍历象一般的写法如下：for (variable of object) {statement}其中，variable 代表变量，object 代表要被遍历的可迭代对象，而statement是要在每次循环迭代中要执行的代码。
例如：//历数组const array = [1, 2, 3, 4, 5];for (let i of array) {console.log(i);}//出结果为：1 2 3 4 5三、for-each环for-each环是一种新的循环语法，它可以帮助我们快速遍历数组中的元素。
它的一般格式如下：array.forEach(function(element) {statement});其中，array代表要被遍历的数组，element则代表数组中的每一个元素，而statement则是要在每次循环迭代中要执行的代码。
例如：//历数组const array = [1, 2, 3, 4, 5];array.forEach(function(element) {console.log(element);});//出结果为：1 2 3 4 5结论以上就是for循环的三种写法，每种写法都有自己的优点和特点，我们可以根据实际的需求来选择不同的写法，以实现更高效的代码编写。
(完整word版)FOR循环语句的翻译程序设计(LL(1)法、输出三地址)
课程设计任务书学生姓名：专业班级：指导教师：工作单位：题目: FOR循环语句的翻译程序设计（LL（1）法、输出三地址表示）初始条件：理论：学完编译课程，掌握一种计算机高级语言的使用。
实践：计算机实验室提供计算机及软件环境。
如果自己有计算机可以在其上进行设计。
要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求）（1）写出符合给定的语法分析方法的文法及属性文法。
（2）完成题目要求的中间代码三地址表示的描述。
（3）写出给定的语法分析方法的思想，完成语法分析和语义分析程序设计。
（4）编制好分析程序后，设计若干用例，上机测试并通过所设计的分析程序。
（5）设计报告格式按附件要求书写。
课程设计报告书正文的内容应包括：1 系统描述（问题域描述）；2 文法及属性文法的描述；3 语法分析方法描述及语法分析表设计；4 按给定的题目给出中间代码形式的描述及中间代码序列的结构设计；5 编译系统的概要设计；6 详细的算法描述（流程图或伪代码）；7 软件的测试方法和测试结果；8 研制报告（研制过程，本设计的评价、特点、不足、收获与体会等）；9 参考文献（按公开发表的规范书写）。
时间安排：设计安排一周：周1、周2：完成系统分析及设计。
周3、周4：完成程序调试及测试。
周5：撰写课程设计报告。
设计验收安排：设计周的星期五第1节课开始到实验室进行上机验收。
设计报告书收取时间：设计周的次周星期一上午10点。
指导教师签名：年月日系主任（或责任教师）签名：年月日FOR循环语句的翻译程序设计——LL（1）法、输出三地址1.系统描述1.1问题描述用LL（1）法设计、编制、调试一个FOR（表达式1；表达式2；表达式3）〈赋值语句〉的语法及语义分析程序,输出三地址代码。
1.2功能描述(1)能对for循环语句做词法分析，并将其中的某些语句做预处理，如i++转换为i=i+1等。
(2)能依据给定的LL（1）文法判断输入串是否符合LL(1)文法(3)给出输入串的LL（1）分析过程(4)完成对语句中控制变量赋值语句，控制条件语句以及控制变量变换语句的翻译(5)完成对赋值语句包括复杂语句的翻译(6)能够对三个表达式缺少一个或多个的情况下进行翻译(7)用翻译后的语句以三地址代码的中间代码形式正确的表达for循环的执行流程。
for循环的执行逻辑
for循环的执行逻辑for循环是一种常用的程序控制结构，它可以重复执行一段代码块，直到满足某个条件为止。
下面我们来详细探讨一下for循环的执行逻辑。
for循环由三部分组成：初始化部分、条件判断部分和循环体部分。
它的基本语法如下：```for (初始化表达式; 条件表达式; 循环后操作表达式) {// 循环体}```1. 初始化部分：在循环开始之前执行一次的代码。
这里可以进行一些变量的初始化或赋值操作。
例如：```int i = 0; // 初始化i为0```2. 条件判断部分：在每次循环开始前判断的条件。
只有条件为真时，才会执行循环体内的代码。
例如：```i < 10 // 当i小于10时，继续循环```3. 循环体部分：在每次循环时执行的代码块。
这里可以进行具体的操作或逻辑处理。
例如：```System.out.println(i); // 输出i的值```4. 循环后操作表达式：在每次循环结束后执行的代码。
通常用来对循环变量进行操作，例如使其递增或递减。
例如：```i++; // i自增1```接下来我们来看一下for循环的执行逻辑。
首先，初始化部分会在循环开始前执行一次，用来初始化一些变量。
然后，在每次循环开始前，条件判断部分会被执行，判断条件是否为真。
如果条件为假，循环将结束，否则将执行循环体内的代码。
在循环体内，可以进行一些操作或逻辑处理。
然后，在每次循环结束后，循环后操作表达式会被执行，对循环变量进行操作。
之后，条件判断部分会再次被执行，判断条件是否为真。
如果条件为假，循环将结束，否则将再次执行循环体内的代码。
如此反复，直到条件不满足为止。
for循环是一种非常灵活的循环结构，可以根据需要进行各种操作。
可以通过控制循环变量的范围和变化规律，来控制循环的次数和具体操作。
例如，可以通过改变初始化部分的变量值和条件判断部分的条件表达式，来控制循环的起始值和终止条件。
可以通过在循环体内进行一些操作，来实现对数据的处理和计算。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
学号：27课内实践报告课程名称编译原理题目FOR循环语句的翻译程序设计（简单优先法、输出三地址码）学院计算机科学及技术专业计算机科学及技术班级1201姓名李潇颖指导教师林泓2014年12月9日课内实践任务书学生姓名：李潇颖专业班级：计算机1201班指导教师：林泓工作单位：计算机科学及技术学院题目: FOR循环语句的翻译程序设计（简单优先法、输出三地址码）初始条件：理论：学完编译课程，掌握一种计算机高级语言的使用。
实践：计算机实验室提供计算机及软件环境。
如果自己有计算机可以在其上进行设计。
要求完成的主要任务:（包括课内实践工作量及其技术要求，以及说明书撰写等具体要求）（1）写出符合给定的语法分析方法的文法及属性文法。
（2）完成题目要求的中间代码三地址码的描述。
（3）写出给定的语法分析方法的思想，完成语法分析和语义分析程序设计。
（4）编制好分析程序后，设计若干用例，上机测试并通过所设计的分析程序。
（5）设计报告格式按附件要求书写。
课内实践报告书正文的内容应包括：1 系统描述（问题域描述）；2 文法及属性文法的描述；3 语法分析方法描述及语法分析表设计；4 按给定的题目给出中间代码形式的描述及中间代码序列的结构设计；5 编译系统的概要设计；6 详细的算法描述（流程图或伪代码）；7 软件的测试方法和测试结果；8 研制报告（研制过程，本设计的评价、特点、不足、收获及体会等）；9 参考文献（按公开发表的规范书写）。
时间安排：设计安排一周：周1、周2：完成系统分析及设计。
周3、周4：完成程序调试及测试。
周5：撰写课内实践报告。
设计验收安排：设计周的星期五第1节课开始到实验室进行上机验收。
设计报告书收取时间：设计周的次周星期一上午10点。
指导教师签名：年月日系主任（或责任教师）签名：目录1 系统描述（问题域描述）41.1设计目的41.2设计内容描述42.文法的描述53 语法分析方法描述及语法分析表设计63.1语法分析方法描述63.2 分析法操作步骤73.3优先关系矩阵74 中间代码形式的描述95 编译系统的概要设计（主要函数）106 详细的算法描述（流程图）116.1词法分析过程116.2语法分析过程126.3三地址码的输出127 测试方法和测试结果138.心得体会179.代码（完整）1810.本科生课内实践成绩评定表38FOR循环语句的翻译程序设计（简单优先法、输出三地址码）1 系统描述（问题域描述）1.1设计目的通过学习编译原理的相关内容，设计并编写FOR循环语句的翻译程序，使用简单优先法，按三地址码输出，能够实现词法分析，语法和语义的分析，加深对所学知识的理解，并且能够熟练运用到实际当中。
1.2设计内容描述FOR循环语句的基本格式如下：FOR（表达式1；表达式2；表达式3）{赋值语句}根据所给题目要求，设计出符合FOR循环语句的文法及属性文法的描述，语法分析方法以及三地址码的输出方式，罗列出词法分析和语法分析的流程，根据语法规则设计输入输出方法，简单优先法中的优先关系表格。
设计好并且进行编译，设计若干输入输出用例（包括正确的输入和错误的输入，用来检查程序的完整性）。
2.文法的描述根据For语句的特点，制定的产生式规则及由产生式对应的语义动作如下：H->f(G;A;B){S;}G O T OH->f(G;C;D){S;}G O T OG->i1=i2 i1.CODE=i2.CODEA->i1<i2I F i1.C O D E>=i2.C O D E G O T O O V E RB->id i.CODE=i.CODE+1C->i1>i2I F i1.C O D E<=i2.C O D E G O T O O V E RD->ia i.CODE=i.CODE-1S->j=M j.CODE=M.CODEM->E M.CODE=E.CODEE->W E.CODE=W.CODEW->W+U W.C O D E=W.C O D E+U.C O D EW->W-U W.C O D E=W.C O D E-U.C O D EW->U W.CODE=U.CODEU->T U.CODE=T.CODET->T* F T.C O D E=T.C O D E”F.C O D ET->T/ FT.C O D E=T.C O D E/F.C O D ET->F T.CODE=F.CODEF->(E) F.C O D E=(E.C O D E)F->j F.CODE=j.CODE（备注：其中d表示--，a表示++）3 语法分析方法描述及语法分析表设计3.1语法分析方法描述本次课内实践要求使用简单优先关系方法。
简单优先分析法的基本思想史对一个文法按照一定原则求出该文法所有符号即包括终结符和非终结符之间的优先关系确定归约过程中的句柄，它的归约实际上是一种规范归约。
一个文法是简单优先文法必须满足以下条件（1）在文法符号集V中，任意两个符号之间最多只有一种优先关系成立；（2）在文法中任意两个产生式没有相同的右部。
三种优先关系及其判定方法如下所示：（1）X=Y 表示X和Y的优先关系相等，当且仅当G中存在产生式规则A→…XY…；（2）X<Y表示X的优先性比Y的优先性小，当且仅当G中存在产生式规则A→…XB…，且B Y…；（3）X>Y表示X的优先性比Y的优先性大，当且仅当G中存在产生式规则A→…BD…，且B…X和D Y…；（4）对任何X，若文法开始符号S→X…，则#<X，若S→…X则X>#。
3.2 分析法操作步骤由简单优先分析法的基本思想设计的如下算法，首先要构造优先关系矩阵（如3.3所示），并将文法产生式保存，设置符号数组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），直到归约完输入符号串，数组中只剩文法的开始符号为止。
3.3优先关系矩阵H G A B S C D M E W U T F f(;){}i=<++>--j+-*/#空白表示，没有优先级关系4 中间代码形式的描述三地址码是由下面一般形式的语句构成的序列：x:=y op z其中，xyz为名字、常数或变量；op代表运算符。
对于本程序的具体三地址码输出，预计显示结果如下：给定输入程序for(i=0;i<10;i++){j=b+c;}三地址码输出为<1> i=0<2> goto <5><3> i++<4> if i<10 goto<5> else goto<7><5> j=b+c<6> goto<3><7> end5 编译系统的概要设计（主要函数）主要函数及对应实现的功能如下表所示：6 详细的算法描述（流程图）6.1词法分析过程给定输入程序for(i=0;i<10;i++){j=b+c;}词法分析结果为关键字为：1；标识符为：2；常数为：3；运算符为：4；界符为：5<for 1><( 5><i 2><= 4><0 3><; 5><i 2><< 4><10 3><; 5><i 2><++ 4><) 5><{ 5> <j 2> <= 4><b 2><+ 4><c 2><; 5><} 5>6.2语法分析过程6.3三地址码的输出给定输入程序for(i=0;i<10;i++){j=b+c;}三地址码输出为<1> i=0<2> goto <5><3> i++<4> if i<10 goto<5> else goto<7><5> j=b+c<6> goto<3><7> end7 测试方法和测试结果计算机系统：Windows 7编译调试环境：Eclipse程序语言：JAVA设计测试用例：（1）data.txt中保存如下程序段for(i=0;i<10;i++){j=b+c;}输出如下结果（2）data.txt 中保存如下程序段for(i=5;i>0;i--){j=a*(h+c);} 输出如下结果8.心得体会经过这次课内实践，使我更加扎实的掌握了有关编译原理方面的知识，在编写程序的过程中遇到了许多问题，但经过一遍遍的调试终于使得程序可以顺利运行。
但是程序中存在着很大的不足：例如在for 循环语句的循环体中只能有一个赋值语句。
对for（）括号中的格式也有着严格的输入要求等等，这些都是以后要改进的地方。
过而能改，善莫大焉。
在课内过程中，我们不断发现错误，不断改正，不断领悟，不断获取。
最终的检测调试环节，本身就是在践行“过而能改，善莫大焉”的知行观。
这次课内实践终于顺利完成了，在设计中遇到了很多问题，最后在老师的指导下，终于游逆而解。
在今后社会的发展和学习实践过程中，一定要不懈努力，不能遇到问题就想到要退缩，一定要不厌其烦的发现问题所在，然后一一进行解决，只有这样，才能成功的做成想做的事，才能在今后的道路上劈荆斩棘，而不是知难而退，那样永远不可能收获成功，收获喜悦，也永远不可能得到社会及他人对你的认可！回顾这次课内实践，是一个痛并快乐的过程，在构造简单优先文法的矩阵时我尝试了5次构造，花费了许多时间，但是当成功构造出来时那种喜悦也是难以言表的。
学习是个不断提升自我的过程。
9.代码（完整）package lxy;import java.io.;import java.io.IOException;import java.io.InputStreamReader;import java.io.Reader;import java.util.*;publicclass Bianyiyuanlikeshe{publicstatic String sy[]=new String[100];staticint js=0;static String m[]=new String[4];publicstatic String sh=new String(); publicstaticvoid main(String[] args) {String s[]=new String[19];s[0]="f(G;A;B){S;}";s[1]="f(G;C;D){S;}";s[2]="i=i";s[3]="i<i";s[4]="id";s[5]="i>i";s[6]="ia";s[7]="j=M";s[8]="E";s[9]="W";s[10]="W+U";s[11]="W-U";s[12]="U";s[13]="T";s[14]="T*F";s[15]="T/F";s[16]="F";s[17]="(E)";s[18]="j";char ss[]=newchar[19];ss[0]='H';ss[1]='H';ss[2]='G';ss[3]='A';ss[4]='B';ss[5]='C';ss[6]='D';ss[7]='S';ss[8]='M';ss[9]='E';ss[10]='W';ss[11]='W';ss[12]='W';ss[13]='U';ss[14]='T';ss[15]='T';ss[16]='T';ss[17]='F';ss[18]='F';cifafenxi();String pp=new String();pp="";for(int i=0;i<sh.length();i++){if(!sy.equals("null"))pp=pp+sy[i];}String[] re=pp.split(";|\\{|r");m[0]=re[1];char tt[]=m[0].toCharArray();m[0]="";for(int i=1;i<m.length;i++)m[0]=m[0]+String.valueOf(tt[i]); m[1]=re[2];m[2]=re[3];char ttt[]=m[2].toCharArray();m[2]="";for(inti=0;i<m.length-1;i++)m[2]=m[2]+String.valueOf(ttt[i]);m[3]=re[4];String n=new String();System.out.println ("采用文法：");for(inti=0;i<s.length;i++)System.out.println(ss[i]+"->"+s[i]);//输出文法System.out.println ("语法分析结果");String str=new String();str=sh+"#";char r[]=str.toCharArray();char ru[]=newchar[r.length];int l=r.length;for(int i=0;i<r.length;i++){ru[i]=r[l-1];l--;}char fu[]=newchar[ru.length ];fu[0]='#';int coutru=ru.length-1;int coutfu=0;int coutbi=0;char bi[]=newchar[ru.length];while(fu[1]!='H'){//System.out.println(fu[coutfu]+" "+ru[coutru]);int b=bijiao(fu[coutfu],ru[coutru]);if(b==-1){System.out.println("wrong");System.out.println(coutf u+"wrong"+coutru);return ;}if(b==0||b==1){if(b==0){ coutfu++;//System.out.println(coutfu);fu[coutfu]=ru[coutru];for(int i=0;i<coutfu;i++){System.out.print(fu[i]);} System.out.print(" ");for(int i=coutru;i>=0;i--){System.out.print(ru[i]);} System.out.println();System.out.println(ru[coutru]+" 移入");bi[coutbi]='0';coutbi++;coutru--;}if(b==1){coutfu++;fu[coutfu]=ru[coutru];for(int i=0;i<coutfu;i++){System.out.print(fu[i]);} System.out.print(" ");for(int i=coutru;i>=0;i--){System.out.print(ru[i]);} System.out.println();System.out.println(ru[coutru]+" 移入");bi[coutbi]='1';coutbi++;coutru--;}}if(b==2){int m=0;for (int i=coutbi-1;i>=0;i--){if(bi[i]=='1')break;else m++;}for(int j=0;j<=coutfu;j++){System.out.print(fu[j]);} System.out.print(" ");for(int j=coutru;j>=0;j--){System.out.print(ru[j]);} System.out.println();coutbi=coutbi-m;String str2=new String();String str3=new String();for(int i=0;i<=m;i++){str3=String.valueOf(fu[coutfu])+str3;if(fu[coutfu]!=';'&&fu[coutfu]!='f'&&fu[coutfu]!='>'&&fu[cou tfu]!='<'&&fu[coutfu]!='B'&&fu[coutfu]!='C'&&fu[coutfu]!='D' &&fu[coutfu]!='H'&&fu[coutfu]!='G'&&fu[coutfu]!='A'&&fu[cout fu]!='i'&&fu[coutfu]!='S'&&fu[coutfu]!='M'&&fu[coutfu]!='W'& &fu[coutfu]!='U'&&fu[coutfu]!='T'&&fu[coutfu]!='F'&&fu[coutfu]!='='&&fu[coutfu]!='+'&&fu[coutfu]!='-'&&fu[coutfu ]!='*'&&fu[coutfu]!='/'&&fu[coutfu]!='('&&fu[coutfu]!=')'&&f u[coutfu]!='E'&&fu[coutfu]!='#'&&fu[coutfu]!='j'&&fu[coutfu] !='#'&&fu[coutfu]!='j'&&fu[coutfu]!='a'&&fu[coutfu]!='d'&&fu [coutfu]!='{'&&fu[coutfu]!='}')str2="i"+str2;elsestr2=String.valueOf(fu[coutfu])+str2;coutfu--;}for(int i=0;i<s.length;i++){if(str2.equals(s[i])){fu[++coutfu]=ss[i];System.out.println(ss[i]+"->"+s[i]+" 规约");n=n+Sandizhima(s[i]);}}int t=bijiao(fu[coutfu-1],fu[coutfu]);if(t==0)bi[coutbi-1]='0';elseif(t==1)bi[coutbi-1]='1';else bi[coutbi-1]='2';}}if(fu[1]=='H')System.out.println("成功！");System.out.println("生成的三地址为：");String m[]=n.split(",");for(int k=0;k<m.length;k++)System.out.println(m[k]);}publicstaticint bijiao(char f,char r){int rr=0,ff=0;charz[]={'H','G','A','B','S','C','D','M','E','W','U','T','F','f','(',';',')','{','}','i','=','<','d','>','a','j','+','-','*' ,'/','#'};int fc=0;int rc=0;for(int i=0;i<z.length;i++){if(f!=z[i])fc++;if(r!=z[i])rc++;}if(fc==16)f='i';if(rc==16)r='i';for (int i=0;i<z.length;i++){if(r==z[i])rr=i;if(f==z[i])ff=i;}int a[][]={{-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, 2},{-1, -1, -1, -1, -1, -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, -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, -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, -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, -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, -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, -1, 2, -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, 2, 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, -1, 2, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, -1, -1, -1},{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2, 2, -1, -1, -1},{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2, 2, -1, -1, -1, -1, -1,-1, -1, -1, -1, 2, 2, 0, 0, -1},{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2, 2, -1, -1, -1, -1, -1,-1, -1, -1, -1, 2, 2, 2, 2, -1},{-1, -1, -1, -1, -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, 0, -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, 0, 0, -1, 0, 0, -1, -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, 2, 2, 0, -1, -1, -1, -1, -1, -1, -1, -1, 2, 2, 2, 2, -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, -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, 2},{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 2, -1, -1, -1, -1, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1, -1},{-1, -1, -1, -1, -1, -1, -1, 0, 1, 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, -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, 2, -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, -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, 2, -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, 2, 2, -1, -1, -1, 0, -1, -1, -1, -1, -1, 2, 2, 2, 2, -1},{-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, -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, -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, -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, -1, -1, -1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},};//-1表示没关系，0表示等于，2表示大于，1表示小于return a[ff][rr];}publicstatic String Sandizhima(String p){char a;int j=0;String s[]=new String[19];s[0]="f(G;A;B){S;}";s[1]="f(G;C;D){S;}";s[2]="i=i";s[3]="i<i";s[4]="id";s[5]="i>i";s[6]="ia";s[7]="j=M";s[8]="E";s[9]="W";s[10]="W+U";s[11]="W-U";s[12]="U";s[13]="T";s[14]="T*F";s[15]="T/F";s[16]="F";s[17]="(E)";s[18]="j";for(int i=0;i<19;i++)if(p.equals(s[i]))j=i; char ss[]=newchar[19];ss[0]='H';ss[1]='H';ss[2]='G';ss[3]='A';ss[4]='B';ss[5]='C';ss[6]='D';ss[7]='S';ss[8]='M';ss[9]='E';ss[10]='W';ss[11]='W';ss[12]='W';ss[13]='U';ss[14]='T';ss[15]='T';ss[16]='T';ss[17]='F';ss[18]='F';if(j==7){String f=new String();f=",<5> "+m[3]+",<6> goto<3>"+",<7> end";return f;}if(j==4){String f=new String();f=",<3> "+m[2]+",<4> if "+m[1]+" goto<5> else goto<7>"; return f;}if(j==6){String f=new String();f=",<3> "+m[2]+",<4> if "+m[1]+" goto<5> else goto<7>"; return f;}if(j==2){String f=new String();f="<1> "+m[0]+",<2> "+"goto <5>";return f;}return"";}publicstaticvoid sansidzhima(String m){char b[]=m.toCharArray();String a[]=new String[b.length];for(int i=0;i<a.length;i++){a[i]=String.valueOf(b[i]);} String f[]={"+","-","*","/","="};int c2=1;int bc=0;int t=0;for(int i=0;i<a.length;i++){int cc=0;for(int j=0;j<f.length;j++){if(a[i].equals(f[j])){ System.out.print("("+String.valueOf(c2)+")"+"("+a[i]+",");a[ i]=null;for(int k=i-1;k>=0;k--){if(a[k]!=null&&cc<2){if(cc==0)System.out.print(a[k]+",");if( cc==1)System.out.print(a[k]);cc++;a[k]=null;}}System.out.print(")");System.out.println();a[i]="("+String.valueOf(c2)+")";c2++;break;}}}} publicstaticint yunsuanfu(char a){boolean b;if(a=='i')return 0;char p[]={'+','-','*','/',')','('};for(int i=0;i<p.length;i++){if(a==p[i])return 2;}return 0;}publicstaticvoid cifafenxi(){System.out.println("关键字为：1；" );System.out.println ("标识符为：2；" );System.out.println ("常数为：3；" );System.out.println ("运算符为：4；");System.out.println ("界符为：5");System.out.println ("词法分析结果");read("c:/data.txt");char x[]=sh.toCharArray();for(int i=13;i<sh.length();i++){if(x[i]=='i')x[i]='j';}sh="";for(int i=0;i<x.length;i++){sh=sh+x[i];}}publicstaticvoid read(String ) {Reader reader = null;try {char[] tempchars = newchar[3000];int charread = 0;String str1=new String();String str3=new String();int c=0;reader = new InputStreamReader(new ());// 读入多个字符到字符数组中，charread为一次读取字符数while ((charread = reader.read(tempchars)) != -1) {// 屏蔽掉\r不显示if ((charread == tempchars.length)&& (tempchars[tempchars.length - 1] != '\r')) {System.out.print(tempchars);} else{for(int i = 0; i < charread; i++) {if (tempchars[i] == '\r'||tempchars[i] == '\n') {continue;}else {boolean b1,b2,b3,b4;String str = String.valueOf(tempchars[i]);b1=Isjiefu(str);b2=Isyunsuanfu(str);if(!b1&&!b2&&c==0){str1=str1+str;}else{if((str.equals("|")||str.equals("&")||str.equals("=")||str.e quals(">")||str.equals("<")||str.equals("-")||str.equals("!" )||str.equals("+"))&&c<=1){str3=str3+str;c++;if(c==1)continue;}if(str3.equals(""))str3=str;if(c==1)b2=true;b3=Isguanjianzi(str1);if(b3==true){System.out.println("<"+str1+" 1"+">");sh=sh+"f";sy[js]=str1;js++;}else{b4=Ischangshu(str1);if(b4==true&&!str1.equals("")){System.out.println("<"+str1+" 3"+">");sh=sh+"i";sy[js]=str1;js++;}else{if(!str1.equals("")){System.out.println("<"+str1+" 2"+">");sh=sh+"i";sy[js]=str1;js++;}}}shuchu(b1,b2,str3);if(c==1)str1=str;else str1="";str3="";c=0;b1=b2=true;}}}}}}catch (Exception e1) {e1.printStackTrace();} finally {if (reader != null) {try {reader.close();} catch (IOException e1) {}}}}publicstaticboolean Isjiefu(String a){String jiefu []=new String[]{";",",","'","\"","//","(",")"," ","{","}","[","]","#"};boolean p=false;for (int i=0;i<12;i++)if (a.equals(jiefu[i]))p=true;return p;}publicstaticboolean Isyunsuanfu(String a){String yunsuanfu []=newString[]{"+","-","*","/","<",">","<=",">=","=","!=","%","++" ,"--","==","&&","||"};boolean p=false;for (int i=0;i<14;i++)if (a.equals(yunsuanfu[i]))p=true;return p;} publicstaticboolean Isguanjianzi(String a){String guanjianzi []=newString[]{"include","iostream","using","namespace","std","voi d","main","return","int","bool","long","char","double","stri ng","new","const","if","elseif","else","while","for"}; boolean p=false;for (int i=0;i<guanjianzi.length;i++)if (a.equals(guanjianzi[i]))p=true;return p;} publicstaticboolean Ischangshu(String a){for (int i = a.length();--i>=0;){if (!Character.isDigit(a.charAt(i))){if(a.charAt(i)!='.')returnfalse;}}returntrue;} publicstaticvoid shuchu(boolean a,boolean b,String st){if(a==true&&!st.equals(" ")){System.out.println("<"+st+" 5"+">");sh=sh+st;sy[js]=st;js++;}elseif(st.equals(" "))System.out.print("");else{ System.out.println("<"+st+" 4"+">");if(st.equals("++"))sh=sh+"d";elseif(st.equals("--"))sh=sh+"a";else sh=sh+st;sy[js]=st;js++;}} }10.本科生课内实践成绩评定表班级：计算机1201班姓名：李潇颖学号：27注：最终成绩以五级分制记。