devbox
AllinToyou
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

山东大学编译原理——语法分析器_山东大学编译原理实验

作者：AllinToyou | 2024-05-19 13:02:17

赞

踩

山东大学编译原理实验

编译原理课程实验 语法分析器

概述

你需要完成一个 PL/0 语言的编译器。这个实验分为若干部分。在这个部分中，你需要完成 PL/0 语言的语法分析器。

你应当已经正确完成了词法分析器。如果没有，请先完成词法分析器的实验。

词法分析器会向语法分析器提供词语流。你需要以合适的方式对词语流进行分析，并生成一颗语法树，或者宣告语法错误。

PL/0 语言的语法可以用以下上下文无关文法描述：

  1. <程序>→<分程序>.
  2. <分程序>→ [<常量说明部分>][<变量说明部分>][<过程说明部分>]<语句>
  3. <常量说明部分> → CONST<常量定义>{ ,<常量定义>};
  4. <常量定义> → <标识符>=<无符号整数>
  5. <无符号整数> → <数字>{<数字>}
  6. <变量说明部分> → VAR<标识符>{ ,<标识符>};
  7. <标识符> → <字母>{<字母>|<数字>}
  8. <过程说明部分> → <过程首部><分程序>;{<过程说明部分>}
  9. <过程首部> → PROCEDURE <标识符>;
  10. <语句> → <赋值语句>|<条件语句>|<当型循环语句>|<过程调用语句>|<读语句>|<写语句>|<复合语句>|<空语句>
  11. <赋值语句> → <标识符>:=<表达式>
  12. <复合语句> → BEGIN<语句>{ ;<语句>} END
  13. <条件> → <表达式><关系运算符><表达式>|ODD<表达式>
  14. <表达式> → [+|-]<项>{<加减运算符><项>}
  15. <项> → <因子>{<乘除运算符><因子>}
  16. <因子> → <标识符>|<无符号整数>|(<表达式>)
  17. <加减运算符> → +|-
  18. <乘除运算符> → *|/
  19. <关系运算符> → =|#|<|<=|>|>=
  20. <条件语句> → IF<条件>THEN<语句>
  21. <过程调用语句> → CALL<标识符>
  22. <当型循环语句> → WHILE<条件>DO<语句>
  23. <读语句> → READ(<标识符>{ ,<标识符>})
  24. <写语句> → WRITE(<标识符>{,<标识符>})
  25. <字母> → A|B|C…X|Y|Z
  26. <数字> → 0|1|2…7|8|9
  27. <空语句> → epsilon

上表中 epsilon 指ϵ，即空

特别的，PL/0 语言允许嵌套定义函数（即，上述文法第 8 行中，由过程说明部分推导出的分程序再次推导出过程说明部分），但嵌套不得超过三层。

例如

  1. procedure f1;
  2. 	procedure f2;
  3. 		procedure f3;
  4. 		begin
  5. 		end;
  6. 	begin
  7. 	end;
  8. begin
  9. end;
  10. begin end.

是允许的，而

  1. procedure f1;
  2. 	procedure f2;
  3. 		procedure f3;
  4. 			procedure f4;
  5. 			begin
  6. 			end;
  7. 		begin
  8. 		end;
  9. 	begin
  10. 	end;
  11. begin
  12. end;
  13. begin end.

则是一个语法错误的程序。

Tips:请注意和

  1. procedure f1;
  2. begin
  3. end;
  4. procedure f2;
  5. begin
  6. end;
  7. procedure f3;
  8. begin
  9. end;

的区别。

对 PL/0 程序进行语法分析后，如果语法正确，应当生成以 < 程序 > 为根节点的抽象语法树。

你应该给出的抽象语法树应当对应规范推导所生成的抽象语法树。这种情况下，对应的答案是唯一的。

我们建议你使用递归下降子程序法进行语法分析。

在本程序中，请忽略语义错误，诸如重复声明的变量、使用未声明的变量等。在语法分析阶段，这些程序暂且还是正确的。

请注意你编写程序的可扩展性。之后的实验需要你对你编写的语法分析程序进行一定的修改。

树的括号表示形式

根据下列三条规则生成树的括号表示形式

  • 如果树T为空，那么它的括号表示形式为空
  • 如果树T仅包含一个节点，那么它的括号表示形式为节点本身
  • 如果树T由根节点R和若干子树T1​,T2​...Tn​组成，那么其括号表示形式为R(T1​的括号表示形式,T2​的括号表示形式, ... ,Tn​的括号表示形式)

例如

 

的括号表示形式为

3(5(6,2(7,4)),1(0,8))

括号表示形式中应当不含空格。

节点名称约定

为评测方便考虑，语法分析树的各节点应当遵循以下命名规则：

  • 如果该节点是(，即左括号，该节点应当输出为 LP

  • 如果该节点是)，即右括号，该节点应当输出为 RP

  • 如果该节点是,，即逗号，该节点应当输出为 COMMA

  • 如果该节点是其他的叶子节点（对应词法分析器中的某一个词语），那么其名称为其本身

  • 如果该节点不是一个叶子节点，则遵循下表进行替换输出

上下文无关文法中的节点对应的替换词语
程序PROGRAM
分程序SUBPROG
常量说明部分CONSTANTDECLARE
常量定义CONSTANTDEFINE
无符号整数< 这是一个叶子节点，用其本身替代 >
变量说明部分VARIABLEDECLARE
标识符< 这是一个叶子节点，用其本身替代 >
过程说明部分PROCEDUREDECLARE
过程首部PROCEDUREHEAD
语句SENTENCE
赋值语句ASSIGNMENT
复合语句COMBINED
条件CONDITION
表达式EXPRESSION
项ITEM
因子FACTOR
加减运算符< 这是一个叶子节点，用其本身替代 >
乘除运算符< 这是一个叶子节点，用其本身替代 >
关系运算符< 这是一个叶子节点，用其本身替代 >
条件语句IFSENTENCE
过程调用语句CALLSENTENCE
当型循环语句WHILESENTENCE
读语句READSENTENCE
写语句WRITESENTENCE
空语句EMPTY

提交程序

考虑到对于编译器这样的大型工程将代码分布在多个文件中是一个很实用的做法，我们会采用多文件编译/评测。你需要提供一个构建脚本来告知我们的评测系统如何构建你的答案可执行文件。

你需要把编译所需的代码以及一个名为 build.sh 的构建脚本压缩在 answer.zip 压缩包中（压缩包不含子文件夹），文件结构应该类似下图

  1. answer.zip
  2. |--build.sh
  3. |--source1.xxx
  4. |--source2.xxx
  5. ...

上图中的 source 开头的文件是你的源代码，不必遵循 source 开头的命名格式，可以任意命名。其中，.xxx 是对应语言的后缀，如.cpp 对应 c++，.java 对应 java，.c 对应 C 语言。

在执行 build.sh 后，应该构造出一个名为 Main 的可执行文件（对于 C/C++）或可被 java Main 执行的 Java 类文件（对于 Java），区分大小写。

这里提供示例 build.sh。

下文中的 sourcex 对应你的源文件，可以任意更名/增加/删除。你也可以自行编写自己的 build.sh 脚本

C

  1. #! /bin/bash
  2. gcc -c source1.c -o source1.o -O2
  3. gcc -c source2.c -o source2.o -O2
  4.  
  5. gcc source1.o source2.o -o Main -lm

C++

  1. #! /bin/bash
  2. g++ -c source1.cpp -o source1.o -O2
  3. g++ -c source2.cpp -o source2.o -O2
  4.  
  5. g++ source1.o source2.o -o Main -lm

Java

  1. #! /bin/bash
  2. javac *.java

样例

样例 1

输入

  1. CONST C=0;
  2. VAR A,B;
  3. BEGIN
  4. 	READ(B,A);
  5. 	A:=B+C;
  6. 	WRITE(A);
  7. END.

输出

PROGRAM(SUBPROG(CONSTANTDECLARE(CONST,CONSTANTDEFINE(C,=,0),;),VARIABLEDECLARE(VAR,A,COMMA,B,;),SENTENCE(COMBINED(BEGIN,SENTENCE(READSENTENCE(READ,LP,B,COMMA,A,RP)),;,SENTENCE(ASSIGNMENT(A,:=,EXPRESSION(ITEM(FACTOR(B)),+,ITEM(FACTOR(C))))),;,SENTENCE(WRITESENTENCE(WRITE,LP,A,RP)),;,SENTENCE(EMPTY),END))),.)

解释

一个比较适合人类阅读的，经过处理的输出序列是

  1. PROGRAM(
  2. 	SUBPROG(
  3. 		CONSTANTDECLARE(
  4. 			CONST,
  5. 			CONSTANTDEFINE(
  6. 				C,
  7. 				=,
  8. 				0
  9. 			),
  10. 			;
  11. 		),
  12. 		VARIABLEDECLARE(
  13. 			VAR,
  14. 			A,
  15. 			COMMA,
  16. 			B,
  17. 			;
  18. 		),
  19. 		SENTENCE(
  20. 			COMBINED(
  21. 				BEGIN,
  22. 				SENTENCE(
  23. 					READSENTENCE(
  24. 						READ,
  25. 						LP,
  26. 						B,
  27. 						COMMA,
  28. 						A,
  29. 						RP
  30. 					)
  31. 				),
  32. 				;,
  33. 				SENTENCE(
  34. 					ASSIGNMENT(
  35. 						A,
  36. 						:=,
  37. 						EXPRESSION(
  38. 							ITEM(
  39. 								FACTOR(
  40. 									B
  41. 								)
  42. 							),
  43. 							+,
  44. 							ITEM(
  45. 								FACTOR(
  46. 									C
  47. 								)
  48. 							)
  49. 						)
  50. 					)
  51. 				),
  52. 				;,
  53. 				SENTENCE(
  54. 					WRITESENTENCE(
  55. 						WRITE,
  56. 						LP,
  57. 						A,
  58. 						RP
  59. 					)
  60. 				),
  61. 				;,
  62. 				SENTENCE(
  63. 					EMPTY
  64. 				),
  65. 				END
  66. 			)
  67. 		)
  68. 	),
  69. 	.
  70. )

样例 2

输入

1=2=3=4=5

输出

Syntax Error

样例 3

输入

  1. VAR A,B;
  2. BEGIN
  3. 	A : = B;
  4. END.

输出

Lexical Error

样例 4

输入

  1. VAR A,B;
  2. BEGIN
  3. 	READ(A);
  4. 	B := A;
  5. 	WRITE(B)
  6. END.
  7. PROCEDURE APPENDIX
  8. BEGIN
  9. ;
  10. END

输出

Syntax Error

main.cpp

  1. #include <bits/stdc++.h>
  2. #include "PLPLO.cpp"
  3. //#include "PLLexiacl.cpp"
  4. using namespace std;
  5. void output(Tree *root){
  6. 	cout<<root->str;
  7. 	int m=root->child.size();
  8. 	if(m!=0)
  9. 	{
  10. 		cout<<"(";
  11. 		for(int i=0;i<m;i++){
  12. 			output(root->child[i]);
  13. 			if(i+1<m) cout<<",";
  14. 		}
  15. 		cout<<")";
  16. 	}
  17. 	
  18. }
  19. int main(){
  20. 	freopen("program.txt","r",stdin);
  21. 	freopen("program_out.txt","w",stdout);
  22. 	string str;
  23. 	while(getline(cin,str)){
  24. 		is_no(str);
  25. 		change(str);
  26. 	}
  27. 	if(isno) cout<<"Lexical Error";
  28. 	else{
  29. //		for(int j=0;j<result.size();j++) cout<<result[j].str<<endl;
  30. 		Tree *root=Parser();
  31. 		if(is_error==1) cout<<"Syntax Error";
  32. 		else output(root);
  33. 	}
  34. }

PLLexiacl.cpp

  1. #include <bits/stdc++.h>
  2. using namespace std;
  3.  
  4. #define is_number(a)	((a)>='0'&&(a)<='9')
  5. #define is_smallidentifier(a)	((a)>='a'&&(a)<='z')
  6. #define is_bigidentifier(a)		((a)>='A'&&(a)<='Z')
  7. #define is_twospecial(a)		(((a)=='>'||(a)=='<'||(a)==':')?1:0)
  8.  
  9.  
  10. bool isno=0;
  11. struct Word{
  12. 	string type;
  13. 	string str;
  14. 	Word(string t,string s):type(t),str(s){};
  15. };
  16.  
  17. vector<string> a;
  18. vector<Word> result;
  19.  
  20. /* bool is_number(char a){
  21. 	return a>='0'&&a<='9';
  22. }
  23. bool is_smallidentifier(char a){
  24. 	return a>='a'&&a<='z';
  25. }
  26. bool is_bigidentifier(char a){
  27. 	return a>='A'&&a<='Z';
  28. } */
  29. /* bool is_twospecial(char a){
  30. 	if(a=='>'||a=='<'||a==':') return 1;
  31. 	else return 0;
  32. } */
  33. bool is_special(char a){
  34. 	if(a=='='||a=='+'||a=='-'||a=='*'||a=='/'||a=='#')
  35. 	return 1;
  36. 	if(a==';'||a==','||a=='.'||a=='('||a==')') 
  37. 	return 1;
  38. 	else return 0;
  39. }
  40.  
  41. bool is_special2(string a){
  42. 	if(a=="CONST"||a=="VAR"||a=="PROCEDURE"||a=="BEGIN"||a=="END"
  43. 	||a=="ODD"||a=="IF"||a=="THEN"||a=="CALL"||a=="WHILE"||a=="DO"||a=="READ"||a=="WRITE")
  44. 	return 1;
  45. 	if(a==">="||a=="<="||a==":="||a==">"||a=="<") return 1;
  46. 	else return 0;
  47. }
  48.  
  49. void print(string s,bool is1,bool is2,int m){
  50. 	if(is_special2(s)){
  51. 		a.push_back(s);
  52. 		result.emplace_back("Special",s);
  53. 		s.clear();
  54. 		is1=0;is2=0;
  55. 	}
  56. 	if(is1){
  57. 		string st="NUMBER "+to_string(m);
  58. 		a.push_back(st);
  59. 		result.emplace_back("NUMBER",to_string(m));
  60. 		s.clear(),is1=0;
  61. 	}
  62. 	if(is2){
  63. 		string st="IDENTIFIER "+s;
  64. 		a.push_back(st);
  65. 		result.emplace_back("IDENTIFIER",s);
  66. 		s.clear(),is2=0;
  67. 	}
  68. }
  69. bool is_no(string s){
  70. 	string str;
  71. 	bool isnum=0,isdir=0;
  72. 	for(int i=0;i<s.size();i++){
  73. 		if(is_number(s[i])){
  74. 			isnum=1;
  75. 			str+=s[i];
  76. 		}
  77. 		else if(is_bigidentifier(s[i])) {
  78. 			if(isnum) {
  79. 				isno=1;
  80. 				return 1;
  81. 			}
  82. 			isdir=1;
  83. 			str+=s[i];
  84. 		}
  85. 		else if(is_smallidentifier(s[i])) {
  86. 			if(isnum) {
  87. 				isno=1;
  88. 				return 1;
  89. 			}
  90. 			isdir=1;
  91. 			str+=s[i]-'a'+'A';
  92. 		}
  93. 		else if(s[i]==':'&&s[i+1]!='=') {
  94. 			isno=1;
  95. 			str.clear(),isnum=0,isdir=0;
  96. 			return 1;
  97. 		}
  98. 		else if(s[i]==' '||s[i]=='	'){
  99. 			str.clear(),isnum=0,isdir=0;
  100. 		}
  101. 		else if(is_special(s[i])||is_twospecial(s[i])) {
  102. 			
  103. 			str.clear(),isnum=0,isdir=0;
  104. 		}
  105. 		else if(is_special2(str)) {
  106. 			str.clear(),isnum=0,isdir=0;
  107. 		}
  108. 		else {
  109. 			isno=1;
  110. 			str.clear(),isnum=0,isdir=0;
  111. 			return 1;
  112. 		}
  113. 		if(str.size()>10) {
  114. 			isno=1;
  115. 			return 1;
  116. 		}
  117. 	}
  118. 	str.clear();
  119. 	return 0;
  120. }
  121. void change(string s){
  122. 	string str;
  123. 	int l=s.size();
  124. 	bool is1=0,is2=0;
  125. 	int m=0;
  126. 	for(int i=0;i<s.size();i++){
  127. 		if((s[i]==' '||s[i]=='	')) {
  128. 			if(is2) print(str,is1,is2,m),str.clear(),is2=0;
  129. 			if(is1) print(str,is1,is2,m),str.clear(),is1=0,m=0;
  130. 		}
  131. 		if(is_special(s[i])){
  132. 			if(is2) print(str,is1,is2,m),str.clear(),is2=0;
  133. 			if(is1) print(str,is1,is2,m),str.clear(),is1=0,m=0;
  134. 			string st;
  135. 			st+=s[i];
  136. 			a.push_back(st);
  137. 			result.emplace_back("Special",st);
  138. 		}
  139. 		if(is_twospecial(s[i])){
  140. 			if(is2)print(str,is1,is2,m),str.clear(),is2=0;
  141. 			if(is1)print(str,is1,is2,m),str.clear(),is1=0,m=0;
  142. 			if(s[i+1]=='=') 
  143. 			{
  144. 				string st1;
  145. 				st1+=s[i];
  146. 				st1+=s[i+1];
  147. 				a.push_back(st1);
  148. 				result.emplace_back("Special",st1);
  149. 				i++;
  150. 			}
  151. 			if((s[i]=='>'&&s[i+1]!='=')||(s[i]=='<'&&s[i+1]!='=')) {
  152. 				string st2;
  153. 				st2+=s[i];
  154. 				a.push_back(st2);
  155. 				result.emplace_back("Special",st2);	
  156. 			}
  157. 		}
  158. 		if(is_number(s[i])){
  159. 			is1=1;
  160. 			if(is2) {
  161. 				str+=s[i];
  162. 				is1=0;
  163. 			}
  164. 			else{
  165. 				m*=10;
  166. 				m+=s[i]-'0';
  167. 			} 
  168. 		}
  169. 		if(is_bigidentifier(s[i])) {
  170. 			if(is1) print(str,is1,is2,m),str.clear(),is1=0;
  171. 			is2=1;
  172. 			str+=s[i];
  173. 		}
  174. 		if(is_smallidentifier(s[i])) {
  175. 			if(is1) print(str,is1,is2,m),str.clear(),is1=0;
  176. 			is2=1;
  177. 			str+=s[i]-'a'+'A';
  178. 		}
  179. 	}
  180. 	if(is2)	print(str,is1,is2,m),str.clear(),is2=0;
  181. 	if(is1)	print(str,is1,is2,m),str.clear(),is1=0;
  182. }

PLPLO.cpp

  1. #include <bits/stdc++.h>
  2. #include "PLLexiacl.cpp"
  3. using namespace std;
  4. class Tree{
  5. public:
  6. 	Tree* root;
  7. 	vector<Tree *> child;
  8. 	string str;
  9. public:
  10. 	Tree(string ss){
  11. 		this->str=ss,this->root=NULL,this->child.clear();
  12. 	}
  13. 	Tree *newNode(string s){
  14. 		Tree* Node=new Tree(s);
  15. 		Node->root=this;
  16. 		this->child.push_back(Node);
  17. 		return Node;
  18. 	}	
  19. };
  20. Tree* Parser();
  21. void Subprog(Tree *Node);
  22. void Const(Tree *Node);
  23. void Var(Tree *Node);
  24. void Procedure(Tree *Node);
  25. void ProcedureHead(Tree *Node);
  26. void Sentence(Tree *Node);
  27. void Assignment(Tree *Node);
  28. //void Epsilon(Tree *Node);
  29. void Combined(Tree *Node);
  30. //void Writesentence(Tree *Node);
  31. //void Readsentence(Tree *Node);
  32. //void Callsentence(Tree *Node);
  33. void Whilesectence(Tree *Node);
  34. void Condition(Tree *Node);
  35. void Expression(Tree *Node);
  36. void Factor(Tree *Node);
  37. void Item(Tree *Node);
  38. void IF(Tree *Node);
  39. void Empty(Tree *Node);
  40.  
  41. bool is_error=0;
  42. int i=0;
  43. int k=0;
  44. Tree* Parser(){
  45. 	if(result.size()==0) {
  46. 		is_error=1;
  47. 		return NULL;
  48. 	}
  49. 	Tree *ROOT=new Tree("PROGRAM");
  50. 	Subprog(ROOT);
  51. 	if(result[i].str=="."){
  52. 		ROOT->newNode("."),i++;
  53. 	}
  54. 	else is_error=1;
  55. 	if(i<result.size()){
  56. 		is_error=1;
  57. 	}
  58. 	return ROOT;
  59. 	
  60. }
  61.  
  62. void Subprog(Tree *Node){
  63. 	Tree *newchild=Node->newNode("SUBPROG"); 
  64. 	if(result[i].str=="CONST") Const(newchild);
  65. 	if(result[i].str=="VAR")  Var(newchild);
  66. 	if(result[i].str=="PROCEDURE") Procedure(newchild);
  67. 	Sentence(newchild);
  68. }
  69.  
  70. void Const(Tree *Node){
  71. 	Tree *thisNode=Node->newNode("CONSTANTDECLARE");
  72. 	thisNode->newNode("CONST");
  73. 	i++;
  74. 	if(result[i].type=="IDENTIFIER"&&result[i+1].str=="="&&result[i+2].type=="NUMBER") {
  75. 		Tree* newchild=thisNode->newNode("CONSTANTDEFINE");
  76. 		newchild->newNode(result[i].str);
  77. 		newchild->newNode(result[i+1].str);
  78. 		newchild->newNode(result[i+2].str);
  79. 		i+=3;
  80. 	}
  81. 	else{
  82. 		is_error=1;
  83. 		return;	
  84. 	}
  85. 	while(result[i].str==","){
  86. 		thisNode->newNode("COMMA");
  87. 		i++; 
  88. 		if(result[i].type=="IDENTIFIER"&&result[i+1].str=="="&&result[i+2].type=="NUMBER") {
  89. 			Tree* newchild=thisNode->newNode("CONSTANTDEFINE");
  90. 			newchild->newNode(result[i].str);
  91. 			newchild->newNode(result[i+1].str);
  92. 			newchild->newNode(result[i+2].str);
  93. 			i+=3;
  94. 		}
  95. 		else {
  96. 			is_error=1;
  97. 			return;	
  98. 		}
  99. 	}
  100. 	if(result[i].str==";") thisNode->newNode(";"),i++;
  101. 	else {
  102. 		is_error=1;
  103. 		return;	
  104. 	}
  105. }
  106.  
  107. void Var(Tree *Node){
  108. 	Tree *thisNode=Node->newNode("VARIABLEDECLARE");
  109. 	thisNode->newNode("VAR"),i++;
  110. 	if(result[i].type=="IDENTIFIER"){
  111. 		thisNode->newNode(result[i].str);
  112. 		i++;
  113. 	}
  114. 	else{
  115. 		is_error=1;
  116. 		return;
  117. 	}
  118. 	while(result[i].str==","){
  119. 		thisNode->newNode("COMMA");i++;
  120. 		if(result[i].type=="IDENTIFIER"){
  121. 			thisNode->newNode(result[i].str);
  122. 			i++;
  123. 		}
  124. 		else{
  125. 			is_error=1;
  126. 			return;
  127. 		}
  128. 	}
  129. 	if(result[i].str==";"){
  130. 		thisNode->newNode(";"),i++;
  131. 	}
  132. 	else{
  133. 		is_error=1;
  134. 		return;
  135. 	}
  136. }
  137. void ProcedureHead(Tree *Node){
  138. 	Tree *Head=Node->newNode("PROCEDUREHEAD");
  139. 	Head->newNode("PROCEDURE");i++;
  140. 	if(result[i].type=="IDENTIFIER"){
  141. 		Head->newNode(result[i].str);
  142. 		i++;
  143. 	}
  144. 	else{
  145. 		is_error=1;
  146. 		return;
  147. 	}
  148. 	if(result[i].str==";"){
  149. 		Head->newNode(";");
  150. 	    i++;
  151. 	}
  152. 	else{
  153. 		is_error=1;
  154. 		return;
  155. 	}
  156. } 
  157. void Procedure(Tree *Node){
  158. 	Tree *thisNode=Node->newNode("PROCEDUREDECLARE");
  159. 	k++;
  160. 	if(k>3){
  161. 		is_error=1;
  162. 		return;
  163. 	}
  164. 	ProcedureHead(thisNode);
  165. 	Subprog(thisNode);
  166. 	k--;
  167. 	if(result[i].str==";"){
  168. 		thisNode->newNode(";");
  169. 		i++;
  170. 	}else{
  171. 		is_error=1;
  172. 		return;
  173. 	}
  174. 	while(result[i].str=="PROCEDURE"){
  175. 		Procedure(thisNode);
  176. 	}
  177. }
  178.  
  179. void Sentence(Tree *Node){
  180. 	Tree *newNode=Node->newNode("SENTENCE");
  181. 	if(i+1<result.size()&&result[i+1].str==":=") Assignment(newNode);
  182. 	else if(result[i].str=="IF") IF(newNode);
  183. 	else if(result[i].str=="WHILE") Whilesectence(newNode);
  184. 	else if(result[i].str=="CALL")  Callsentence(newNode);
  185. 	else if(result[i].str=="READ") Readsentence(newNode);
  186. 	else if(result[i].str=="WRITE") Writesentence(newNode);
  187. 	else if(result[i].str=="BEGIN") Combined(newNode) ;
  188. 	else Empty(newNode);
  189. }
  190. void Empty(Tree *Node){
  191. 	Node->newNode("EMPTY");
  192. }
  193. void Assignment(Tree *Node){
  194. 	Tree *thisNode=Node->newNode("ASSIGNMENT");
  195. 	if(result[i].type=="IDENTIFIER"&&result[i+1].str==":="){
  196. 		thisNode->newNode(result[i].str);
  197. 		thisNode->newNode(result[i+1].str),i+=2;
  198. 	}
  199. 	else{
  200. 		is_error=1;
  201. 		return;
  202. 	}
  203. 	Expression(thisNode); 
  204. }
  205.  
  206. void Expression(Tree *Node){
  207. 	Tree *newchild=Node->newNode("EXPRESSION");
  208. 	if(result[i].str=="+"||result[i].str=="-"){
  209. 		newchild->newNode(result[i].str),i++;
  210. 	}
  211. 	Item(newchild);
  212. 	while(result[i].str=="+"||result[i].str=="-"){
  213. 		newchild->newNode(result[i].str),i++;
  214. 		Item(newchild);
  215. 	}
  216. }
  217.  
  218. void Item(Tree *Node){
  219. 	Tree *newchild=Node->newNode("ITEM");
  220. 	Factor(newchild);
  221. 	while(result[i].str=="*"||result[i].str=="/"){
  222. 		newchild->newNode(result[i].str);
  223. 		i++;
  224. 		Factor(newchild); 
  225. 	}
  226. }
  227.  
  228. void Factor(Tree *Node){
  229. 	Tree *newchild=Node->newNode("FACTOR");
  230. 	if(result[i].type=="IDENTIFIER"||result[i].type=="NUMBER"){
  231. 		newchild->newNode(result[i].str),i++;
  232. 		return; 
  233. 	}
  234. 	else if(result[i].str=="("){
  235. 		newchild->newNode("LP");
  236. 		i++;
  237. 		Expression(newchild);
  238. 		if(result[i].str==")"){
  239. 			newchild->newNode("RP");
  240. 			i++;
  241. 			return;
  242. 		}
  243. 		else{
  244. 			is_error=1;
  245. 			return;
  246. 		}
  247. 	}
  248. 	else{
  249. 		is_error=1;
  250. 		return;
  251. 	}
  252. }
  253. void Condition(Tree *Node){
  254. 	Tree *child=Node->newNode("CONDITION");
  255. 	if(result[i].str=="ODD"){
  256. 		child->newNode("ODD");
  257. 		i++;
  258. 		Expression(child);
  259. 	}
  260. 	else{
  261. 		Expression(child);
  262. 		if(result[i].str=="="||result[i].str=="#"||result[i].str=="<"||result[i].str=="<="||result[i].str==">"||result[i].str==">="){
  263. 			child->newNode(result[i].str);i++;	
  264. 		}
  265. 		else{
  266. 			is_error=1;
  267. 			return; 
  268. 		}
  269. 		Expression(child);
  270. 	}
  271. }
  272. void IF(Tree* Node){
  273. 	Tree *thisNode=Node->newNode("IFSENTENCE");
  274. 	Tree *newchild=thisNode->newNode("IF");
  275. 	i++;
  276. 	Condition(thisNode);
  277. 	if(result[i].str=="THEN"){
  278. 		thisNode->newNode("THEN");
  279. 		i++;
  280. 	}
  281. 	else{
  282. 		is_error=1;
  283. 		return;	
  284. 	}
  285. 	Sentence(thisNode);
  286. }
  287.  
  288.  
  289. void Whilesectence(Tree *Node){
  290. 	Tree *thisNode=Node->newNode("WHILESENTENCE");
  291. 	Tree *newchild=thisNode->newNode("WHILE");
  292. 	i++;
  293. 	Condition(thisNode);
  294. 	if(result[i].str=="DO"){
  295. 		thisNode->newNode("DO");i++;
  296. 		
  297. 	}
  298. 	else{
  299. 		is_error=1;
  300. 		return;
  301. 	}
  302. 	Sentence(thisNode);
  303. }
  304.  
  305. void Callsentence(Tree *Node){
  306. 	Tree *thisNode=Node->newNode("CALLSENTENCE");
  307. 	thisNode->newNode("CALL");
  308. 	i++;
  309. 	if(result[i].type=="IDENTIFIER"){
  310. 		thisNode->newNode(result[i].str);
  311. 		i++;
  312. 	}
  313. 	else{
  314. 		is_error=1;
  315. 		return;
  316. 	}
  317. }
  318.  
  319. void Readsentence(Tree* Node){
  320. 	Tree *thisNode=Node->newNode("READSENTENCE");
  321. 	thisNode->newNode("READ");
  322. 	i++;
  323. 	if(result[i].str=="("){
  324. 		thisNode->newNode("LP");
  325. 		i++;
  326. 		if(result[i].type=="IDENTIFIER"){
  327. 			thisNode->newNode(result[i].str);i++;
  328. 		}
  329. 		else {
  330. 			is_error=1;
  331. 			return;
  332. 		}
  333. 		while(result[i].str==","){
  334. 			thisNode->newNode("COMMA"),i++;
  335. 			if(result[i].type=="IDENTIFIER"){
  336. 				thisNode->newNode(result[i].str);i++;
  337. 			}
  338. 			else {
  339. 				is_error=1;
  340. 				return;
  341. 			}
  342. 		}
  343. 		if(result[i].str==")"){
  344. 			thisNode->newNode("RP");i++;
  345. 		}
  346. 		else {
  347. 			is_error=1;
  348. 			return;
  349. 		}
  350. 	}
  351. 	else {
  352. 		is_error=1;
  353. 		return;
  354. 	}
  355. }
  356.  
  357. void Writesentence(Tree *Node){
  358. 	Tree *thisNode=Node->newNode("WRITESENTENCE");
  359. 	thisNode->newNode("WRITE"),i++;
  360. 	if(result[i].str=="("){
  361. 		thisNode->newNode("LP");
  362. 		i++;
  363. 		if(result[i].type=="IDENTIFIER"){
  364. 			thisNode->newNode(result[i].str);i++;
  365. 		}
  366. 		else {
  367. 			is_error=1;
  368. 			return;
  369. 		}
  370. 		while(result[i].str==","){
  371. 			thisNode->newNode("COMMA"),i++;
  372. 			if(result[i].type=="IDENTIFIER"){
  373. 				thisNode->newNode(result[i].str);i++;
  374. 			}
  375. 			else {
  376. 				is_error=1;
  377. 				return;
  378. 			}
  379. 		}
  380. 		if(result[i].str==")"){
  381. 			thisNode->newNode("RP");i++;
  382. 		}
  383. 		else {
  384. 			is_error=1;
  385. 			return;
  386. 		}
  387. 	}
  388. 	else {
  389. 		is_error=1;
  390. 		return;
  391. 	}
  392. }
  393.  
  394. void Combined(Tree *Node){
  395. 	Tree *thisNode=Node->newNode("COMBINED");
  396. 	thisNode->newNode("BEGIN");
  397. 	i++;
  398. 	Sentence(thisNode);
  399. 	while(result[i].str==";"){
  400. 		thisNode->newNode(";");
  401. 		i++;
  402. 		Sentence(thisNode);
  403. 	}
  404. 	if(result[i].str=="END"){
  405. 		thisNode->newNode("END");
  406. 		i++;
  407. 	}
  408. 	else{
  409. 		is_error=1;
  410. 		return;
  411. 	}
  412. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/AllinToyou/article/detail/592960
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号