实验一、词法分析实验

专业   姓名  学号

一、        实验目的

      编制一个词法分析程序

二、        实验内容和要求

输入:源程序字符串

    输出:二元组(种码，单词符号本身)。

三、        实验方法、步骤及结果测试

1. 1.     源程序名：压缩包文件（rar或zip）中源程序名cifafenxiqi.c

可执行程序名：cifafenxi.exe

1. 2.     原理分析及流程图

主要总体设计问题。

(包括存储结构，主要算法，关键函数的实现等)

1. 3.     主要程序段及其解释：
2. 4.  #include <stdio.h> 
3. 5.  #include <string.h> 
4. 6.    
5. 7.  char prog[80],token[8],ch;    //创建字符数组
6. 8.  int syn,p,m,n,sum;  //syn 是种码
7. 9.  char *rwtab[6]={"begin","if","then","while","do","end"};   //字符数组’关键字’
8. 10.    

11. void scaner(void); 

1. 12.   

13. main() 

14. { 

1. 15.     p=0; 
2. 16.     printf("\n please input a string(end with ‘#‘):\n");  //’#’字符为结束标志
3. 17.       // 输入 用prog字符数组存储
4. 18.     do{ 
5. 19.             scanf("%c",&ch); 
6. 20.             prog[p++]=ch; 
7. 21.     }while(ch!=‘#‘); 
8. 22.       
9. 23.     p=0;     //prog数组 从头开始 行数53
10. 24.     do{ 
11. 25.             scaner();     //将输入的源程序分类别
12. 26.             switch(syn) 
13. 27.             { 
14. 28.                 case 11: 
15. 29.                     printf("( %-10d%5d )\n",sum,syn); 
16. 30.                 break; 
17. 31.                   
18. 32.                 case -1: 
19. 33.                     printf("you have input a wrong string\n"); 
20. 34.                     //getch(); 
21. 35.                     return 0; 
22. 36.                 break; 
23. 37.                   
24. 38.                 default:  
25. 39.                 printf("( %-10s%5d )\n",token,syn); 
26. 40.                 break; 
27. 41.             } 
28. 42.         }while(syn!=0); 
29. 43.     //getch(); 
30. 44.  } 
31. 45.   

46. void scaner(void) 

47. {   

1. 48.     sum=0; 
2. 49.       
3. 50.     for(m=0;m<8;m++) 
4. 51.         token[m++]= NULL;  //初始化
5. 52.       
6. 53.         ch=prog[p++];    //调出prog字符数组的字符
7. 54.         m=0; 
8. 55.           
9. 56.     while((ch==‘ ‘)||(ch==‘\n‘)) 
10. 57.         ch=prog[p++];  //将回车、空格忽略
11. 58.       
12. 59.     if(((ch<=‘z‘)&&(ch>=‘a‘))||((ch<=‘Z‘)&&(ch>=‘A‘)))  //判断是否为字母
13. 60.      {  
14. 61.         while(((ch<=‘z‘)&&(ch>=‘a‘))||((ch<=‘Z‘)&&(ch>=‘A‘))||((ch>=‘0‘)&&(ch<=‘9‘))) 
15. 62.         { 
16. 63.             token[m++]=ch;  //存储字母到token字符数组中
17. 64.             ch=prog[p++]; 
18. 65.         } 
19. 66.           
20. 67.         p--;  //否，退回一格
21. 68.         syn=10;  //输出
22. 69.   
23. 70.         for(n=0;n<6;n++) 
24. 71.         if(strcmp(token,rwtab[n])==0)  //判断是否万为关键字
25. 72.         {  
26. 73.             syn=n+1; 
27. 74.             break; 
28. 75.         } 
29. 76.      } 
30. 77.      else if((ch>=‘0‘)&&(ch<=‘9‘))  //判断是否为数字
31. 78.      {  
32. 79.         while((ch>=‘0‘)&&(ch<=‘9‘)) 
33. 80.         { 
34. 81.             sum=sum*10+ch-‘0‘; 
35. 82.             ch=prog[p++]; 
36. 83.         } 
37. 84.         p--; 
38. 85.         syn=11; 
39. 86.     } 
40. 87.     else   //界符、运算符、其他特殊符号
41. 88.     { 
42. 89.         switch(ch) 
43. 90.         { 
44. 91.         case ‘<‘: 
45. 92.             token[m++]=ch; 
46. 93.             ch=prog[p++]; 
47. 94.             if(ch==‘=‘)  //判断是〈还是<=
48. 95.             {  
49. 96.                 syn=22; 
50. 97.                 token[m++]=ch; 
51. 98.             } 
52. 99.             else 
53. 100.               {   
54. 101.                   syn=20; 
55. 102.                   p--; 
56. 103.               } 
57. 104.           break; 
58. 105.     
59. 106.           case ‘>‘: 
60. 107.               token[m++]=ch; 
61. 108.               ch=prog[p++]; 
62. 109.               if(ch==‘=‘) 
63. 110.               { 
64. 111.                   syn=24; 
65. 112.                   token[m++]=ch; 
66. 113.               } 
67. 114.               else 
68. 115.               {  
69. 116.                   syn=23; 
70. 117.                   p--; 
71. 118.               } 
72. 119.           break; 
73. 120.     
74. 121.           case ‘+‘: 
75. 122.               token[m++]=ch; 
76. 123.               ch=prog[p++]; 
77. 124.               if(ch==‘+‘) 
78. 125.               { 
79. 126.                   syn=17;  
80. 127.                   token[m++]=ch; 
81. 128.               } 
82. 129.               else 
83. 130.               { 
84. 131.                   syn=13; 
85. 132.                   p--; 
86. 133.               } 
87. 134.           break; 
88. 135.     
89. 136.           case ‘-‘: 
90. 137.               token[m++]=ch; 
91. 138.               ch=prog[p++]; 
92. 139.               if(ch==‘-‘) 
93. 140.               { 
94. 141.                   syn=29; 
95. 142.                   token[m++]=ch; 
96. 143.               } 
97. 144.               else 
98. 145.               {  
99. 146.                   syn=14; 
100. 147.                   p--; 
101. 148.               } 
102. 149.           break; 
103. 150.     
104. 151.           case ‘!‘: 
105. 152.               ch=prog[p++]; 
106. 153.               if(ch==‘=‘) 
107. 154.               {  
108. 155.                   syn=21; 
109. 156.                   token[m++]=ch; 
110. 157.               } 
111. 158.               else 
112. 159.               {  
113. 160.                   syn=31; 
114. 161.                   p--; 
115. 162.               } 
116. 163.           break; 
117. 164.     
118. 165.           case ‘=‘: 
119. 166.               token[m++]=ch; 
120. 167.               ch=prog[p++]; 
121. 168.               if(ch==‘=‘) 
122. 169.               { 
123. 170.                   syn=25; 
124. 171.                   token[m++]=ch; 
125. 172.               } 
126. 173.               else 
127. 174.               { 
128. 175.                   syn=18; 
129. 176.                   p--; 
130. 177.               } 
131. 178.           break; 
132. 179.     
133. 180.           case ‘*‘: 
134. 181.               syn=15; 
135. 182.               token[m++]=ch; 
136. 183.           break; 
137. 184.     
138. 185.           case ‘/‘: 
139. 186.               syn=16; 
140. 187.               token[m++]=ch; 
141. 188.           break; 
142. 189.     
143. 190.           case ‘(‘:  
144. 191.               syn=27; 
145. 192.               token[m++]=ch; 
146. 193.           break; 
147. 194.     
148. 195.           case ‘)‘: 
149. 196.               syn=28; 
150. 197.               token[m++]=ch; 
151. 198.           break; 
152. 199.     
153. 200.           case ‘{‘:  
154. 201.               syn=5; 
155. 202.               token[m++]=ch; 
156. 203.           break; 
157. 204.     
158. 205.           case ‘}‘:  
159. 206.               syn=6; 
160. 207.               token[m++]=ch; 
161. 208.           break; 
162. 209.     
163. 210.           case ‘;‘: 
164. 211.               syn=26; 
165. 212.               token[m++]=ch; 
166. 213.           break; 
167. 214.     
168. 215.           case ‘\"‘: 
169. 216.               syn=30; 
170. 217.               token[m++]=ch; 
171. 218.           break; 
172. 219.     
173. 220.           case ‘#‘:  
174. 221.               syn=0; 
175. 222.               token[m++]=ch; 
176. 223.           break; 
177. 224.     
178. 225.           case ‘:‘: 
179. 226.               syn=17; 
180. 227.               token[m++]=ch; 
181. 228.           break; 
182. 229.     
183. 230.           default: 
184. 231.               syn=-1; 
185. 232.           break; 
186. 233.           } 
187. 234.       } 
188. 235.           token[m++]=‘\0‘; 
189. 236.   } 
190. 237.      
191. 238.     运行结果及分析

一般必须配运行结果截图，结果是否符合预期及其分析。

   （截图需根据实际，截取有代表性的测试例子）

四、        实验总结

心得体会，实验过程的难点问题及其解决的方法。

刚刚接触词法分析，有很不懂得地方，程序还不是完善，只是一个简简单单的词法分析器，还有很多地方要学习。

词法分析作业