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

词法分析器--C实现_词法分析器c语言编写

作者：小小林熬夜学编程 | 2024-03-23 08:49:02

赞

踩

词法分析器c语言编写

实验目的：

编制一个读单词过程，从输入的源程序中，识别出各个具有独立意义的单词，即基本保留字、标识符、常数、运算符、分隔符五大类(可自主添加类别)。并依次输出各个单词的内部编码及单词符号自身值。

 程序及其子程序：

1、文件输入(待分析文本拖入控制台或屏幕输入)

2、划分字符集成7个大类

3、预处理（去除空格、回车换行和非法字符）

4、词法分析

5、打印输出识别的终结符及其类别

  1. //程序无法识别出double,因为它的前缀子串与do重复(如有需要自主修改)
  2. /*
  3. 编译原理实验一：词法分析器
  4. 要求：编制一个读单词过程，从输入的C语言源程序中，识别出各个具有独立意义的单词，
  5. 即基本保留字、标识符、常数、运算符、分隔符、特殊字符、控制命令七大类。
  6. 并依次输出各个单词的内部编码及单词符号自身值的二元组。
  7. */
  8.  
  9. /*
  10. 一、复习c语言字符串数组相关处理，文件相关处理
  12. //用字符数组存放一个字符串
  13. char str[ ]="";
  14. //用字符指针指向一个字符串
  15. char * s="I love China";
  16. //二维数组存放字符串数组
  17. const int N = 5;
  18. char frd[N][10]={"Hello","World","My","Dear","Friends"};
  19. //字符指针的数组存放字符串数组
  20. char *p[]={"This","is","a","char*","array"};
  21. //文件读写函数原型：FILE *fopen(const char *filename, const char *mode);`头文件：#include <stdio.h>`
  23. 二、词法分析器
  24. */
  25. #include <stdio.h>
  26. #include <stdlib.h>
  27. #include <math.h>
  28. #include <string.h>
  29. #include <sys/types.h>
  30. #define MAX_LINE 1024*10
  31.  
  32. //编码,保留字:1、标识符:2、常数:3、运算符:4、分隔符: 5
  33.  
  34. //控制命令表
  35. static char *contCommands[]={"#include","#define","#undef","#asm","#endasm","#ifdef","#ifndef","#else","#endif"};
  36.  
  37. //关键字表
  38. static char *keyWords[]={"main","int","double","struct","if","else","char","return","const","float",
  39. "short","void","while","for","break","then","long","switch","case","do","static","typedef","continue",
  40. "default","sizeof","do","extern","static","auto","register","sizeof"};
  41.  
  42. //运算符表
  43. static char *operators[]={"+","-","*","\/","=","%",">","<","^","&","|","!"};
  44.  
  45. //分隔符表
  46. static char *delimiters[]={",","(",")","{","}","[","]",";","\""};
  47.  
  48. //特殊符号表
  49. static char *Spesymbols[]={".","$","?","~","^","%","\\","#","&",":","`","@"};
  50.  
  51. //科学计数法
  52. // 数字
  53. //const char* number_rule="^([+-]?\\d+\\.\\d+)|([+-]?\\d+)|([+-]?\\.\\d+)$";
  54. //const std::regex pattern_number(number_rule, regex::icase);
  55. //
  56.  科学计数
  57. //const char* scientific_rule="^[+-]?((\\d+\\.?\\d*)|(\\.\\d+))[Ee][+-]?\\d+$";
  58. //const regex pattern_scientific(scientific_rule, regex::icase);
  59. //
  60.  十六进制
  61. //const char* hex_rule="^[+-]?0[xX]([A-Fa-f0-9])+$";
  62. //const regex pattern_hex(hex_rule, regex::icase);
  63. //
  64.  八进制
  65. //const char* oct_rule="^0([0-7])+$";
  66. //const regex pattern_oct(oct_rule, regex::icase);
  67.  
  68. //输入的源程序存放处，最大可以存放MAX_LINE个字符
  69. static char *resourceProject = (char*)malloc(MAX_LINE * sizeof(char));
  70. //p = (int*)realloc(p, sizeof(int)* 20);扩容
  71.  
  72. //存放注释
  73. static char *commentStr = (char*)malloc(MAX_LINE * sizeof(char));
  74. static char *commentStr2 = (char*)malloc(MAX_LINE * sizeof(char));
  75.  
  76. //从str中删除目标字符
  77. void delete_char(char str[],char target){
  78. 	int i,j;
  79. 	for(i=j=0;str[i]!='\0';i++){
  80. 		if(str[i]!=target){
  81. 			str[j++]=str[i];
  82. 		}
  83. 	}
  84. 	str[j]='\0';
  85. 	//i-j即为串中存在的目标字符个数
  86. }
  87.  
  88. //处理"//,/* */"注释
  89. void proComment(char str[]){
  90. 	int j=0;
  91. 	int p=0;
  92. 	//遍历resourceProject，记录注释
  93. 	for(int i=0; i<strlen(str); i++) {
  94. 		if(str[i]=='/'&&str[i+1]=='/') {
  95. 			int k=i-1;
  96. 			while(str[++k]!='\n') {
  97. 				commentStr[p++]=str[k];
  98. 			}
  99. 			i=k;
  100. 		} 
  101. 	}
  102. 	printf("\n单行注释为:%s\n",commentStr);
  103. 	//遍历resourceProject，原地删除单行注释
  104. 	 j=0;
  105. 	 p=0;
  106. 	 int i;
  107. 	for(i=0; i<strlen(str); i++){
  108. 		if(str[i]=='/'&&str[i+1]=='/') {
  109. 		   p=i;
  110. 		   while(str[++p]!='\n');
  111. 		   i=p;
  112. 	}else{
  113.            str[j++]=str[i];
  114. 	}
  115. }
  116. 	while(j<=i)
  117. 	{
  118. 	  str[j++]='\0';
  119. 	}
  120. 	printf("\n单行注释处理后的源程序为:\n%s",str);
  121. 	
  122. 	//处理多行注释“/* 。。。*/”则去除该内容
  123.      int count = 0;
  124.      p=0;
  125.  	 int k=0;
  126.      for (int i=0;i<strlen(str);i++){
  127.          if(str[i]=='/'&&str[i+1]=='*')
  128.          {
  129.          	k=i;
  130.              while(str[k]!='*'||str[k+1]!='/')
  131.              {
  132.              	 commentStr2[p++]=str[k++];
  133.              }
  134.                  commentStr2[p++]='*';
  135. 			     commentStr2[p++]='/';
  136.             i=k+2;
  137.          }
  138. //		 printf("\n多行注释处理后的源程序为:%s\n",str);
  139.      }
  140.      printf("\n多行注释为:%s\n",commentStr2);
  141.      //遍历resourceProject，原地删除多行注释
  142. 	 j=0;
  143. 	 p=0;
  144. 	for(i=0;str[i]!='\0';i++){
  145. 		if(str[i]=='/'&&str[i+1]=='*'){
  146. 		   i=i+2;
  147. 		   p=i;
  148. 		   while(str[p++]!='*'&&str[p+1]!='/');
  149. 		   i=p+2;
  150. 	}else{
  151.            str[j++]=str[i];
  152. 	}
  153. }
  154. printf("end\n");
  155. 	while(j<=i)
  156. 	{
  157. 	  str[j++]='\0';
  158. 	}
  159. 	printf("\n多行注释处理后的源程序为:\n%s",str);
  160. 	
  161. }//endproComment
  162.  
  163. //预处理函数(可以写个target数组传进来)
  164. void preProcessing(){
  165. 	//先处理注释，再处理宏定义等预处理，最后处理空格、换行、制表符
  166. 	proComment(resourceProject);
  167. 	char target1=' ';
  168. 	char target2='\t';
  169. 	char target3='\n';
  170.     delete_char(resourceProject,target1);
  171.     delete_char(resourceProject,target2);
  172.     delete_char(resourceProject,target3);
  173. }
  174.  
  175. //判断是否为字母
  176. bool isChar(char ch){
  177. 	if((ch>='a'&&ch<='z')||(ch>='A'&&ch<='Z'))
  178. 		return true;
  179. 	return false;
  180. }
  181.  
  182. //判断是否为数字
  183. bool isDigit(char ch){
  184. 	if(ch>='0'&&ch<='9')
  185. 		return true;
  186. 	return false;
  187. }
  188.  
  189. //判断是否为定界符等
  190. bool isDelimiters(char ch){
  191. 	for(int i=0;i<sizeof(delimiters)/sizeof(delimiters[0]);i++)
  192. 		if(ch==*delimiters[i])
  193. 			return true;
  194. 	return false;
  195. }
  196.  
  197. //判断是否为控制命令
  198. int isContCommands(char *str){
  199. 	for(int i=0;i<sizeof(contCommands)/sizeof(contCommands[0]);i++) {
  200. 		if(strcmp(str,contCommands[i])==0){//匹配
  201. 			return i;
  202. 		}
  203. 	}
  204. 	//不是关键字即为404
  205. 	return 404;
  206. }
  207.  
  208. //判断是否为关键字
  209. int isKeyword(char *str){
  210. 	for(int i=0;i<sizeof(keyWords)/sizeof(keyWords[0]);i++) {
  211. 		if(strcmp(str,keyWords[i])==0){//匹配
  212. 			return i;
  213. 		}
  214. 	}
  215. 	//不是关键字即为404
  216. 	return 404;
  217. }
  218.  
  219. //判断是否为运算符
  220. int isOperators(char str){
  221. 	for(int i=0; i<sizeof(operators)/sizeof(operators[0]); i++) {
  222. 		if(str==*operators[i]){
  223. 			return i;
  224. 		}
  225. 	}
  226. 	//不是关键字即为404
  227. 	return 404;
  228. }
  229.  
  230. //判断是否为特殊字符
  231. int isSpesymbols(char str){
  232. 	for(int i=0; i<sizeof(Spesymbols)/sizeof(Spesymbols[0]); i++) {
  233. 		if(str==*Spesymbols[i]){
  234. 			return i;
  235. 		}
  236. 	}
  237. 	//不是关键字即为404
  238. 	return 404;
  239. }
  240.  
  241.  
  242. FILE * readTxt(){
  243. 	FILE *fp;
  244.     char filename[100];  //文件名
  245.     char tempstr[1024];  //读文件的缓冲
  246.     bool flag = true;   //文件读取成功标志
  247.     printf("请输入或拖入想要打开的文本文件名及其路径，如c:\\temp.txt\n");
  248.   while(flag){
  249.   	gets(filename);  //这句要用户输入文件名
  250.   	char target='"';
  251.   	delete_char(filename,target);
  252.   	//getchar();
  253.     if ((fp=fopen(filename,"r"))==NULL){//打开文件，并判断是否有打开错误
  254.         printf("打开文件%s出现错误\n",filename);
  255.         memset(filename,0, sizeof filename);          //清空数组
  256.         fclose(fp);  //关闭文件
  257.         printf("请在检查文件路径后再次输入: \n");
  258.     }
  259.     else
  260.     {
  261.     	flag = false;
  262.     	//文件读入resourceProject
  263.     	int cnt=0;
  264. //	 while(!feof(fp))   //读文件，直到文件末尾
  265. //  	 {
  266. //         resourceProject[cnt++] = fgetc(fp);  //将文件内容读入resourceProject
  267. // 	 }
  268.     	printf("文件%s已读取，请检查以下txt文件内容:\n",filename);
  269. 	}
  270.   }
  271.   
  272.   if (fp == NULL )
  273.      return 0;
  274.     //以下显示文件内容
  275.      memset(resourceProject,0,sizeof resourceProject);
  276.     while(fgets(tempstr,1024,fp)!=NULL) //读文件一行内容，最多1024字符到缓冲区，并判断是否文件已经结束
  277.     {
  278.     	 printf("%s",tempstr);   //显示缓冲区内容
  279.     	 strcat(resourceProject,tempstr);//统一读入resourceProject
  280. 	}
  281.         
  282. //    fclose(fp);  //关闭文件
  283.     return  fp;
  284. }//endRead
  285.  
  286.  
  287. //读入下一个字符
  288. char getChar(int p,char str[])
  289. {
  290. 	return str[p];
  291. }
  292.  
  293.  
  294. //分析函数
  295. char textAnalyze(char str[]){
  296. 	 	char* elements[strlen(str)];     //文本元素拆分
  297.         int tag[strlen(str)];//1:关键字 2:标识符 3:常量 4:运算符 5:分隔符 6:特殊字符 7:控制命令
  298.        	memset(tag,'\0',sizeof(tag)/sizeof(tag[0]));
  299.         int indTag=0;//tag的index
  300.         int Tag=0;
  301. 	 	memset(elements,'\0',sizeof elements);
  302. 	 	memset(elements,'\0',(sizeof tag)/sizeof tag[0]);
  303. 		char ch;//读入的字符
  304. 		int p=0;//str的指针
  305. 		char token[128]={};//记录变量名
  306. 		int m=0;
  307. while((ch=getChar(p++,str))!='\0'){
  308. 	Tag=0;
  309. 	//printf("\ngetFirstChar:%c\n",ch);
  310. 	memset(token,'\0',sizeof(token)/sizeof(token[0]));
  311.     if(isChar(ch)||ch=='_')  //可能是标示符或者关键字
  312.       {
  313.         m=0;
  314.         token[m++]=ch;
  315.         token[m]='\0';
  316.         bool isKey=false;
  317.         int tmp=p;
  318.         bool While=false;
  319. 		while(isChar((ch=getChar(tmp++,str)))||isDigit((ch=getChar(--tmp,str))))
  320.         {
  321.         	While=true;
  322.         	//printf("while:%c\n",ch);
  323.         	if(isDigit(ch))
  324.         	tmp++;
  325.         	token[m++]=ch;
  326.            	token[m]='\0';
  327.             p++;
  328.             if(isKeyword(token)!=404)
  329.             {
  330.              	tag[indTag++]=1;//关键字
  331.              	Tag=1;
  332.             	isKey=true;
  333.             //	p--;
  334.             	break;
  335.            	}
  336.            		
  337.         }
  338.         
  339. //                token[m++]='\0';
  340.                 if(!isKey)
  341.                 {
  342.                 	//p++;
  343.                 	tag[indTag++]=2;//标识符
  344.                 	Tag=2;
  345. 				}
  346. 				//else
  347. 					//p++;
  348. 				
  349.     	    //printf("(%d,\"%s\")\n",tag[indTag-1],token);
  350.     	    printf("(%d,\"%s\")\n",Tag,token);
  351.       }
  352.     else if((ch=='-')||isDigit(ch)||(ch=='.'))//数字
  353.       {
  354. 		bool sym=false;
  355. 		int m=0;
  356. 		char digit[128]={};
  357. 		memset(digit,'\0',sizeof(digit)/sizeof(digit[0]));
  358.  	    digit[m++]=ch;
  359.  	    digit[m]='\0';
  360. 		int tmp=p;
  361. 		if((ch=='-')&&isDigit((ch=getChar(tmp+1,str))))
  362. 		{
  363. 			sym=true;
  364. 		}
  365.         	long long constNum=0;
  366. 			while(isDigit(ch=getChar(tmp,str))||(ch=getChar(tmp,str))=='.'||(ch=getChar(tmp,str))=='e'||(ch=getChar(tmp,str))=='E')
  367.             {
  368.             	digit[m++]=ch;
  369.             	digit[m]='\0';
  370.                 constNum=constNum*10+ch-'0';
  371.                 tmp++;
  372.                 p++;
  373.             }
  374.         digit[m++] = '\0';//结束符
  375.         if(!sym)
  376.         {
  377.         	Tag=3;
  378.         	tag[indTag++]=3;//正数常量
  379. 		}
  380.         else
  381.         {
  382.         	tag[indTag++]=13;//负数常量
  383.         	Tag=13;
  384. 		}
  385. 	    if(constNum>9223372036854775807)
  386. 	    {
  387. 	    	tag[indTag++]=23;//大数常量
  388. 	    	Tag=23;
  389. 		}
  390.         printf("(%d,\"%s\")\n",tag[indTag-1],digit);
  391.       }
  392. 	 else if(isDelimiters(ch))
  393. 	    {
  394. 	    //	printf("%c\n",ch);
  395. 	    	token[0]=ch;
  396. 	    	token[1]='\0';
  397. 	    	tag[indTag++]=5;
  398. 		    printf("(%d,\"%s\")\n",tag[indTag-1],token);
  399. 	    }
  400. 	 else if(isOperators(ch)!=404)//操作符
  401. 	    {
  402. 		switch(ch)   //其他字符
  403.      	 {
  404.       	case'<':
  405.      		    m=0;
  406. 	            token[m++]=ch;
  407. 			    ch=getChar(p++,str);
  408.             if(ch=='='){
  409.            	   Tag=4;
  410.    			   tag[indTag++]=4;
  411.      		   token[m++]=ch;
  412.      		   token[m++]='\0';
  413.    		       printf("(%d,\"%s\")\n",tag[indTag-1],token);
  414.             }
  415. 			else{
  416. 				Tag=4;
  417.                 tag[indTag++]=4;
  418.                 token[m++]='\0';
  419. 				p--;
  420.                 printf("(%d,\"%s\")\n",tag[indTag-1],token);
  421.             }
  422. 		break;
  423. 		case'>':
  424. 		    m=0;
  425. 			token[m++]=ch;
  426.             ch=getChar(p++,str);//取字符
  427. 			if(ch=='=')
  428.             {
  429.             	Tag=4;
  430.                 tag[indTag++]=4;
  431.                 token[m++]=ch;
  432.                 token[m++]='\0';
  433.    		        printf("(%d,\"%s\")\n",tag[indTag-1],token);
  434.             }
  435. 			else
  436.             {
  437.             	p--;
  438.             	Tag=4;
  439.                 tag[indTag++]=4;
  440.                 token[m++]='\0';
  441.                 printf("(%d,\"%s\")\n",tag[indTag-1],token);
  442.             }
  443.         break;
  444.         case'|':
  445. 		    m=0;
  446. 			token[m++]=ch;
  447.             ch=getChar(p++,str);//取字符
  448. 			if(ch=='|')
  449.             {
  450.             	Tag=4;
  451.                 tag[indTag++]=4;
  452.                 token[m++]=ch;
  453.                 token[m++]='\0';
  454.    		        printf("(%d,\"%s\")\n",tag[indTag-1],token);
  455.             }
  456. 			else
  457.             {
  458.             	p--;
  459.             	Tag=4;
  460.                 tag[indTag++]=4;
  461.                 token[m++]='\0';
  462.                 printf("(%d,\"%s\")\n",tag[indTag-1],token);
  463.             }
  464.         break;
  465.         case'&':
  466. 		    m=0;
  467. 			token[m++]=ch;
  468.             ch=getChar(p++,str);//取字符
  469. 			if(ch=='&')
  470.             {
  471.             	Tag=4;
  472.                 tag[indTag++]=4;
  473.                 token[m++]=ch;
  474.                 token[m++]='\0';
  475.    		        printf("(%d,\"%s\")\n",tag[indTag-1],token);
  476.             }
  477. 			else
  478.             {
  479.             	p--;
  480.             	Tag=4;
  481.                 tag[indTag++]=4;
  482.                 token[m++]='\0';
  483.                 printf("(%d,\"%s\")\n",tag[indTag-1],token);
  484.             }
  485.         break;
  486.         case'!':
  487. 		    m=0;
  488. 			token[m++]=ch;
  489.             ch=getChar(p++,str);//取字符
  490. 			if(ch=='=')
  491.             {
  492.                 tag[indTag++]=4;
  493.                 token[m++]=ch;
  494.                 token[m++]='\0';
  495.    		        printf("(%d,\"%s\")\n",tag[indTag-1],token);
  496.             }
  497. 			else
  498.             {
  499.             	p--;
  500.                 tag[indTag++]=4;
  501.                 token[m++]='\0';
  502.                 printf("(%d,\"%s\")\n",tag[indTag-1],token);
  503.             }
  504.         break;
  505.         default:
  506.         	{
  507.         		m=0;
  508. 				token[m++]=ch;
  509.         		token[m++]='\0';
  510.         		tag[indTag++]=4;
  511.        		    printf("(%d,\"%s\")\n",tag[indTag-1],token);
  512.        		    break;
  513. 			}
  514.          }//endSwitch
  515.         }//endIfEls
  516. 		else//特殊字符或控制命令
  517. 		{
  518. //			printf("%c\n",ch);
  519. 		    if(isSpesymbols(ch)!=404){
  520. 		    	//printf("%c\n",ch);
  521. 		    	bool isControl=false;
  522. 		    	if(ch=='#')
  523.     	    {
  524. 		    		m=0;
  525.                     token[m++]=ch;
  526.         			token[m]='\0';
  527.         			int t=p;
  528. 		        while(isChar((ch=getChar(t++,str))))
  529.    				   {
  530.    				   	     p++;
  531.    				   	     token[m++]=ch;
  532.                	         token[m]='\0';
  533.             	   	     if(isContCommands(token)!=404)
  534.             			 {
  535.             			 	Tag=7;
  536.              			    tag[indTag++]=7;//控制命令
  537.             				isControl=true;
  538.          				    break;
  539.      					 }
  540.            				    
  541.        		       }
  542.        		      // p++;
  543.                 if(isControl)
  544.                 {
  545. 				 	token[m++]='\0';
  546. //        			printf("(%d,\"%s\")\n",tag[indTag-1],token);
  547. 					printf("(%d,\"%s\")\n",Tag,token);
  548. 				}
  549.    		     }
  550. 		      else
  551.    		   		{
  552.                 	m=0;
  553. 					token[m++]=ch;
  554. 					token[m++]='\0';
  555.        				tag[indTag++]=6;//特殊符号符
  556.        				printf("(%d,\"%s\")\n",tag[indTag-1],token);
  557.   			    }
  558. 		    	
  559. 			}
  560. 	    }//endElse
  561.     }//endWhile
  562. }//endfunc
  563.  
  564. //主函数
  565. int main(){
  566. 	char buf[MAX_LINE];  /*缓冲区*/
  567. 	char ch,sh;
  568. 	FILE* fp;            /*文件指针*/
  569.  
  570. 	 //下面是写数据，将数字0~9写入到data.txt文件中
  571.  
  572.     printf("***请选择读取待编译程序的方式***\n");
  573.     printf("***输入 1：屏幕输入；输入 2：已放入记事本***\n");
  574.     int tmp;
  575.     scanf("%d",&tmp);
  576.     getchar();//吞掉空格
  577.     if (tmp==1)
  578.     {
  579.     	  FILE *fpWrite=fopen("data.txt","a");
  580.     	  	   if(fpWrite==NULL)
  581.    			    {
  582.   				 perror("fail to read");
  583. 				 exit(1);
  584. 		 		 		  return 0;
  585. 	            }
  586.     	printf("您输入的是 1,请继续输入待编译程序，并以@加回车结束！\n");
  587.     	printf("输入内容将同步显示..\n");
  588.     	ch = getchar();
  589.     	while (ch != '@') {
  590.              fputc(ch,fpWrite); //写入文件
  591.              putchar(ch); //输出到屏幕
  592.              ch = getchar();
  593.     	}
  594.     	fclose(fpWrite);//关闭文件
  595. 		    printf("程序已读入文件data.txt..");
  596.     	//已经获取文件处理程序
  597.     	//fpWrite=fopen("data.txt","a");//重新打开文件，重置文件指针
  598.    	    //fclose(fpWrite);//关闭文件
  599.    	    getchar();
  600.    	    fp=readTxt();//获取文件指针
  601.    	    printf("文件读取完毕..\n");
  602. 	    	printf("resourceProject中的程序为:\n");
  603.             printf("%s",resourceProject);
  604.     	fclose(fp);//关闭文件
  605. 	}
  606. 	   else if(tmp==2)
  607.     {
  608. 	     	printf("您输入的是 2,接下来将进入文件读取程序..\n");
  609.    	        fp=readTxt();//获取文件指针
  610. 	    	printf("文件读取完毕..\n");
  611. 	    	printf("resourceProject中的程序为:\n");
  612.             printf("%s",resourceProject);
  613. 	    	fclose(fp);//关闭文件
  614.     }
  615. 	//开始处理读入的程序
  616. 	preProcessing();//预处理
  617.     printf("\n预处处理完成后的程序为:\n");
  618. 	printf("%s",resourceProject);
  619. 	printf("\n下面开始词法分析:\n");
  620. 	textAnalyze(resourceProject);
  621.     //下面是读数据，将读到的数据存到数组a[10]中，并且打印到控制台上
  622. //    int a[10]={0};
  623. //    FILE *fpRead=fopen("data.txt","r");
  624. //    if(fpRead==NULL)
  625. //    {
  626. //        return 0;
  627. //    }
  628. //    for(int i=0;i<10;i++)
  629. //    {
  630. //        fscanf(fpRead,"%d ",&a[i]);
  631. //        printf("%d ",a[i]);
  632. //    }
  633. //    getchar();//等待
  634. //
  635. //	 fclose(fpRead);
  636.  
  637. free(commentStr);
  638. free(resourceProject);
  639. 	return 0;
  640. }

运行结果：

 

        对编译原理中的词法分析实验进行了记录，但需要说明的是，本次实验面向测试集编程，处理方式分为两遍，并非一遍扫描处理。

        编写代码时需十分小心指针的位置，符号的提前读入、回溯等。

        程序逻辑划分较为明显，有需要的可主要对进行词法分析的 char textAnalyze(char str[]) 函数进行改写。

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

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

  

闽ICP备14008679号