• 词法分析（编译原理不用慌）

    目录

    一.简单版

    二.简单版（文本保存）

    c++版

    运行结果：

     Java版

    运行结果：

    三.第三版（文本保存）

    c++版

    运行结果：

    一.简单版

    1. #include
    2. #include
    3. using namespace std;
    4. #include
    5.  
    6. //char  prog[80]="begin if x>=24 then s:=0 end #"
    7. char prog[80];
    8. char token[8];    //prog存放输入符号串；token存放识别出的单词
    9. int   syn, p, sum,m;
    10. char ch;            //syn-种别码；p-prog数组的下标；sum-识别出的整数
    11. char *rwtab[6] = {"begin", "if", "then", "while", "do", "end"};     //关键字表置初值
    12.  
    13. //扫描子程序
    14. void scaner( )
    15. {   
    16.      m=0;
    17.     for (int n=0; n<8; n++ ) token[n]=NULL;     //将token清空
    18.      ch=prog[p++] ;         //根据全局变量p读取下一个字符，分析下一个单词    
    19.      while (ch==' '|| ch == '\n')  ch=prog[p++] ;         
    20.                             //1.首字符为字母的情况，可能为标识符或关键字
    21.       if(ch<='z'&& ch>='a')
    22. 	  {    m=0;  
    23. 		while (ch<='z'&& ch>='a'||ch<='9'&& ch>='0') 
    24. 		{ 
    25. 		 token[m++]=ch;//将ch保存至token[m++]中
    26.          ch=prog[p++] ;//读取下一个字符
    27. 		}
    28.         token[m++]='\0'; 
    29. 		p--;//...... 
    30. 		syn=10 ; //标识符，置syn=10         
    31.         for (int n=0; n<6; n++ )    //判断当前标识符是否为关键字
    32.             if (strcmp( token, rwtab[n])==0)
    33. 			{  
    34. 				syn=n+1;//关键字，置关键字syn  
    35.                 break ;
    36. 			} 
    37. 	  } 
    38.       //2.首字符为数字的情况，为整数
    39. 	else if (ch<='9'&& ch>='0')
    40. 	{   
    41. 		while (ch<='9'&& ch>='0')
    42. 		{ 
    43. 			 sum=sum*10+ch-'0';  //将ch数字字符转换成整数送入sum，进位故sum*10，
    44.              ch=prog[p++] ;//读取下一个字符 
    45. 		}
    46.         p--;//....... 
    47. 	    syn=11;      //整数，置syn=11   
    48. 	}
    49.       //3.其他算符或界符等情况	
    50.     else             	
    51.          switch(ch)
    52. 	{
    53. 			case '<': 
    54. 				token[m++]=ch;	//ch存入token ;
    55. 	            ch=prog[p++] ;// 读下一个字符 ;
    56.                 //三种情况，<=或<>或<	
    57. 				if (ch=='>')
    58. 				{  
    59.                     syn=21;//将<>的种别码赋给syn;	    
    60.                 	token[p++]=ch;	//ch存入token ;
    61. 				}
    62. 				else if (ch=='=')
    63. 				{  
    64.                     syn=22;//将<=的种别码赋给syn;		                
    65.                     token[p++]=ch; // ch存入token ;
    66.                  }
    67. 				else { 
    68.                   syn=20;//将<的种别码赋给syn;		            
    69.                      	p--;
    70. 	      		}
    71.          	break;
    72.            case '>': 
    73.                 token[m++]=ch;	ch=prog[p++] ;// 读下一个字符 ;
    74. 				 if (ch=='=')
    75. 				{  
    76.                     syn=24;//将<=的种别码赋给syn;		                
    77.                     token[m++]=ch; // ch存入token ;
    78.                  }
    79. 				else { 
    80.                     syn=23;//将<的种别码赋给syn;		            
    81.                 	p--;
    82. 				}
    83.             	break;
    84. 		  case ':':
    85.                 token[m++]=ch;	//ch存入token ;
    86. 	            ch=prog[p++] ;// 读下一个字符 ;
    87. 				 if (ch=='=')
    88. 				{  
    89.                     syn=18;//将<=的种别码赋给syn;		                
    90.                     token[m++]=ch; // ch存入token ;
    91.                  }
    92. 				else { 
    93.                   syn=17;//将<的种别码赋给syn;		            
    94.                 	p--;
    95. 				}
    96.             	break;
    97.          case '+': 
    98.                token[m++]=ch;syn=13;break;
    99.          case '-': 
    100.                token[m++]=ch;syn=14;break;
    101.         case '*': 
    102.                token[m++]=ch;syn=15;break;
    103.         case '/': 
    104.                token[m++]=ch;syn=16;break;
    105.         case '=': 
    106.                token[m++]=ch;syn=25;break;
    107.         case ';': 
    108.                token[m++]=ch;syn=26;break;
    109.        case '(': 
    110.                token[m++]=ch;syn=27;break;
    111.        case ')': 
    112.                token[m++]=ch;syn=28;break;
    113.        case '#': 
    114.                token[m++]=ch;syn=0;break;
    115.  
    116.        default: syn= -1; 
    117. 		}
    118.  token[m++]='\0';
    119. }
    120.  
    121. int main( ){ 
    122.    	//......
    123.    	printf( "\n please input  string : \n" ) ;
    124.    	do{   
    125. 	        ch=getchar( );
    126. 	        prog[p++]=ch ;	
    127. 	} while(ch!='#');
    128.    	
    129.     
    130. 	p=0;//......
    131. 	do{   //循环调用scanner()函数分析prog中的字符串，直到syn为0（即#）分析结束
    132. 		scaner();
    133. 		switch(syn){
    134. 		case 11:  //根据syn的值输出(syn,sum或者token)二元组
    135. 			printf("%-6d     %-5d\n",sum,syn);break;
    136. 		default: printf("%-6s     %-5d\n",token,syn);
    137. 		}
    138. 	}while(syn!=0);
    139. }

    二.简单版（文本保存）

    c++版

    此处是自己先创建一个1.txt文件

    如：

    const    a=10;
    var    b,c;
    procedure    p;
          begin
        c:=b+a
          end;
    begin#
     

    1. #include
    2. #include
    3. //"begin if x>24 then s:=0 end #"
    4. char  prog[80], token[10];    //prog存放输入符号串；token存放识别出的单词
    5. int   syn, p, sum=0,m;
    6. char ch;            //syn-种别码；p-prog数组的下标；sum-识别出的整数
    7. char str; 
    8. char *rwtab[13] = {"begin", "if", "then", "while", "do", "end","const","var","procedure","odd","call","read","write"};//关键字表置初值
    9. FILE* pf = fopen("2.txt", "w+");
    10.  
    11. //扫描子程序
    12. void scaner( )
    13. {
    14.      m=0;sum=0;
    15.     for (int n=0; n<8; n++ ) token[n]=NULL;     //将token清空
    16.      ch=prog[p++] ;         //根据全局变量p读取下一个字符，分析下一个单词    
    17.      while (ch==' '|| ch == '\n')  ch=prog[p++] ;         
    18.       //1.首字符为字母的情况，可能为标识符或关键字
    19.       if(ch<='z'&& ch>='a')
    20. 	  {    m=0;  
    21. 		while (ch<='z'&& ch>='a'||ch<='9'&& ch>='0') 
    22. 		{ 
    23. 		 token[m++]=ch;//将ch保存至token[m++]中
    24.          ch=prog[p++] ;//读取下一个字符
    25. 		}
    26.         token[m++]='\0'; 
    27. 		p--;//...... 
    28. 		syn=30 ; //标识符，置syn=30         
    29.         for (int n=0; n<13; n++ )    //判断当前标识符是否为关键字
    30.             if (strcmp( token, rwtab[n])==0)
    31. 			{  
    32. 				syn=n+1;//关键字，置关键字syn  
    33.                 break ;
    34. 			} 
    35. 	  } 
    36.       //2.首字符为数字的情况，为整数
    37. 	else if (ch<='9'&& ch>='0')
    38. 	{   
    39. 		while (ch<='9'&& ch>='0')
    40. 		{ 
    41. 			 sum=sum*10+ch-'0';  //将ch数字字符转换成整数送入sum
    42.              ch=prog[p++] ;//读取下一个字符 
    43. 		}
    44.         p--;//....... 
    45. 	    syn=31;      //整数，置syn=31   
    46. 	}
    47.       //3.其他算符或界符等情况	
    48.     else             	
    49.          switch(ch)
    50. 	{
    51. 			case '<': 
    52. 				token[m++]=ch;	//ch存入token ;
    53. 	            ch=prog[p++] ;// 读下一个字符 ;
    54.                 //三种情况，<=或<>或<	
    55. 				if (ch=='>')
    56. 				{  
    57.                     syn=21;//将<>的种别码赋给syn;	    
    58.                 	token[m++]=ch;	//ch存入token ;
    59. 				}
    60. 				else if (ch=='=')
    61. 				{  
    62.                     syn=22;//将<=的种别码赋给syn;		                
    63.                     token[p++]=ch; // ch存入token ;
    64.                  }
    65. 				else { 
    66.                   syn=20;//将<的种别码赋给syn;		            
    67.                      	p--;
    68. 	      		}
    69.          	break;
    70.            case '>': 
    71.                 token[m++]=ch;	ch=prog[p++] ;// 读下一个字符 ;
    72. 				 if (ch=='=')
    73. 				{  
    74.                     syn=24;//将<=的种别码赋给syn;		                
    75.                     token[p++]=ch; // ch存入token ;
    76.                  }
    77. 				else { 
    78.                     syn=23;//将<的种别码赋给syn;		            
    79.                 	p--;
    80. 				}
    81.             	break;
    82. 		  case ':':
    83.                 token[m++]=ch;	//ch存入token ;
    84. 	            ch=prog[p++] ;// 读下一个字符 ;
    85. 				 if (ch=='=')
    86. 				{  
    87.                     syn=18;//将:=的种别码赋给syn;		                
    88.                     token[m++]=ch; // ch存入token ;
    89.                  }
    90. 				else { 
    91.                   syn=17;//将:的种别码赋给syn;		            
    92.                 	p--;
    93. 				}
    94.             	break;
    95.          case '+': 
    96.                token[m++]=ch;syn=32;break;
    97.          case '-': 
    98.                token[m++]=ch;syn=14;break;
    99.         case '*': 
    100.                token[m++]=ch;syn=15;break;
    101.         case '/': 
    102.                token[m++]=ch;syn=16;break;
    103.         case '=': 
    104.                token[m++]=ch;syn=25;break;
    105.         case ';': 
    106.                token[m++]=ch;syn=26;break;
    107.        case '(': 
    108.                token[m++]=ch;syn=27;break;
    109.        case ')': 
    110.                token[m++]=ch;syn=28;break;
    111.        case '#': 
    112.                token[m++]=ch;syn=0;break;
    113.  
    114.        default: syn= -1; 
    115. 		}
    116.  token[m++]='\0';
    117. }
    118. int f(int syn){
    119. 	if(syn==26||syn==27||syn==28){
    120. 		printf("界符");
    121. 		fprintf(pf,"     界符\n");
    122. 	}else if((syn>=20&&syn<=25)||(syn>=14&&syn<=16)||syn==18||syn==32){
    123. 		printf("运算符");
    124. 		fprintf(pf,"     运算符\n");
    125. 	}else if(syn>=1&&syn<=13){
    126. 		printf("关键字");
    127. 		fprintf(pf,"     关键字\n");
    128. 	}else if(syn==30){
    129. 		printf("标识符");
    130. 		fprintf(pf,"     标识符\n");
    131. 	}else if(syn==17){
    132. 		printf("非法");
    133. 		fprintf(pf,"     非法\n");
    134. 	}
    135. } 
    136.  
    137. int main( ){ 
    138.  
    139. 	p=0;
    140. 	FILE* pf1 = fopen("1.txt", "r");
    141.  
    142. 	while((str=fgetc(pf1))!=EOF)
    143. 	{    //如果没有读到末尾，则继续读取信息
    144. 	        
    145. 		   	prog[p++]=str;
    146. 		   	if(str=='#'){
    147. 			   	break;
    148. 			   }
    149. 	}
    150. 	prog[p++]='\0';
    151. 		
    152. 	p=0;
    153. 	do{   //循环调用scanner()函数分析prog中的字符串，直到syn为0（即#）分析结束
    154. 		scaner();
    155. 		switch(syn){
    156. 		case 31:  //根据syn的值输出(syn,sum或者token)二元组
    157. 			fprintf(pf,"%-6d ",sum);
    158. 			fprintf(pf,"     数字\n");
    159. 			printf("%-6d     数字\n",sum); 
    160. 			break;
    161. 		default: {
    162. 			fprintf(pf,"%-6s ",token);
    163. 			printf("%-6s     ",token);f(syn);printf("\n");
    164. 		}
    165. 		}
    166. 	}while(syn!=0);
    167. 	fclose(pf);//关闭文件
    168. 	pf=NULL;
    169. //	fclose(pf1);
    170. //	pf1=NULL;
    171. 	
    172. }

    运行结果：

     

     Java版

     

     1.txt放你要读的文法

    1. import java.io.FileInputStream;
    2. import java.io.FileNotFoundException;
    3. import java.io.FileOutputStream;
    4. import java.io.IOException;
    5. import java.nio.charset.StandardCharsets;
    6. import java.util.Scanner;
    7. /*
    8. *   保留字13个syn赋值1-13const ,var,procedure,begin,end,odd,if,then,call, while,do, read,write
    9. *   标识符syn赋值14
    10. *   常数syn赋值
    11. *   运算符+，-，*,/,= syn赋值16-20 #syn赋值为0 <,<=,>,>=,:= syn赋值21-25
    12. *   界符( ) , ; . syn赋值26-30
    13. * */
    14. public class PL0 {
    15.     static String  prog="";
    16.     //static String prog="begin if x>=24 then s:=0 end #";
    17.     static String  token1;   //做保留识别出的值
    18.     static int   syn;       //种别码
    19.     static int p=0;         //做索引
    20.     static int sum;         //做常数
    21.  
    22.     static char ch;         //做字符串索引下取值
    23.     static String str=" ";  //做写入txt中分隔
    24.  
    25.     //13个关键字
    26.     static String[] rwtab = {"const" ,"var","procedure","begin","end","odd",
    27.                              "if","then","call", "while","do", "read","write"};
    28.  
    29.     static void scaner()
    30.     {
    31.  
    32.         token1="";     //将token1清空
    33.         sum=0;        //sum清空
    34.  
    35.         ch=prog.charAt(p++) ;         //读字符串p索引下
    36.         while (ch==' '|| ch == '\n')  ch=prog.charAt(p++) ;
    37.         //1.首字符为字母的情况，可能为标识符或关键字
    38.         if(ch<='z'&& ch>='a')
    39.         {
    40.             while (ch<='z'&& ch>='a'||ch<='9'&& ch>='0')
    41.             {
    42.                 token1+=ch;
    43.                 ch=prog.charAt(p++) ;//读取下一个字符
    44.             }
    45.  
    46.             p--;
    47.             syn=14 ; //标识符，置syn=14
    48.             for (int n=0; n<13; n++ )    //判断当前标识符是否为关键字
    49.                 if (token1.equals(rwtab[n]) )
    50.                 {
    51.                     syn=n+1;
    52.                     break ;
    53.                 }
    54.         }
    55.         //2.首字符为数字的情况，为整数
    56.         else if (ch<='9'&& ch>='0')
    57.         {
    58.             while (ch<='9'&& ch>='0')
    59.             {
    60.                 sum=sum*10+ch-'0';  //将ch数字字符转换成整数送入sum，进位故sum*10，
    61.                 ch=prog.charAt(p++) ;//读取下一个字符
    62.             }
    63.             p--;
    64.             syn=15;      //常数，置syn=15
    65.         }
    66.         //3.其他算符或界符等情况
    67.         else
    68.             switch(ch)
    69.             {
    70.                 case '+':
    71.                     token1+=ch;syn=16;break;
    72.                 case '-':
    73.                     token1+=ch;syn=17;break;
    74.                 case '*':
    75.                     token1+=ch;syn=18;break;
    76.                 case '/':
    77.                     token1+=ch;syn=19;break;
    78.                 case '=':
    79.                     token1+=ch;syn=20;break;
    80.                 case '#':
    81.                     token1+=ch;syn=0;break;
    82.                 //<与<=
    83.                 case '<':
    84.                     token1+=ch;
    85.                     ch=prog.charAt(p++) ;
    86.                     if (ch=='=')
    87.                     {
    88.                         syn=22;
    89.                         token1+=ch;
    90.                     }else{
    91.                         syn=21;
    92.                         p--;
    93.                     }
    94.                     break;
    95.                 //>与>=
    96.                 case '>':
    97.                     token1+=ch;	ch=prog.charAt(p++) ;// 读下一个字符 ;
    98.                     if (ch=='=')
    99.                     {
    100.                         syn=24;
    101.                         token1+=ch;
    102.                     }
    103.                     else {
    104.                         syn=23;
    105.                         p--;
    106.                     }
    107.                     break;
    108.                 case ':':
    109.                     token1+=ch;
    110.                     ch=prog.charAt(p++) ;
    111.                     if (ch=='=')
    112.                     {
    113.                         syn=25;
    114.                         token1+=ch;
    115.                     }
    116.                     break;
    117.  
    118.                 case '(':
    119.                     token1+=ch;syn=26;break;
    120.                 case ')':
    121.                     token1+=ch;syn=27;break;
    122.                 case ',':
    123.                     token1+=ch;syn=28;break;
    124.                 case ';':
    125.                     token1+=ch;syn=29;break;
    126.                 case '.':
    127.                     token1+=ch;syn=30;break;
    128.                 default: syn= -1;
    129.             }
    130.     }
    131.  
    132.     public static void main(String[] args) throws IOException {
    133.         //System.out.print("please input  string :");
    134.         //Scanner input = new Scanner(System.in);
    135.         //prog=input.nextLine();
    136.  
    137.         FileInputStream fos0;
    138.         FileOutputStream fos1;
    139.         FileOutputStream fos2;
    140.         FileOutputStream fos3;
    141.         FileOutputStream fos4;
    142.         FileOutputStream fos5;
    143.  
    144.         try {
    145.             fos0=new FileInputStream("src/1.txt");
    146.             int ch=0;
    147.             while ((ch=fos0.read())!=-1){
    148.                 prog+=(char)ch;
    149.             }
    150.  
    151.             System.out.println(prog);
    152.             fos0.close();
    153.             fos1=new FileOutputStream("src/关键字.txt",true);
    154.             fos2=new FileOutputStream("src/标识符.txt",true);
    155.             fos3=new FileOutputStream("src/运算符.txt",true);
    156.             fos4=new FileOutputStream("src/常数.txt",true);
    157.             fos5=new FileOutputStream("src/界符.txt",true);
    158.         } catch (FileNotFoundException e) {
    159.             throw new RuntimeException(e);
    160.         }
    161.  
    162.         do{   //循环调用scanner()函数分析prog中的字符串，直到syn为0（即#）分析结束
    163.             scaner();
    164.  
    165.             if(token1!="") {
    166.                 //System.out.println(token1+" "+syn);
    167.                 System.out.printf("%-8s",token1+" ");
    168.             }
    169.             //关键字1-13
    170.             if(syn>=1&&syn<=13){
    171.                 fos1.write((token1+str+"\n").getBytes(StandardCharsets.UTF_8));
    172.                 System.out.println("基本字");
    173.             }
    174.             //标识符14
    175.             else if(syn==14){
    176.                 fos2.write((token1+str+"\n").getBytes(StandardCharsets.UTF_8));
    177.                 System.out.println("标识符");
    178.             }
    179.             //运算符16-25和#0
    180.             else if(syn>=16&&syn<=25||syn==0){
    181.                 fos3.write((token1+str+"\n").getBytes(StandardCharsets.UTF_8));
    182.                 System.out.println("运算符");
    183.             }
    184.             //常数15
    185.             else if(syn==15){
    186.                 fos4.write((String.valueOf(sum)+str+"\n").getBytes(StandardCharsets.UTF_8));
    187.                 //System.out.println(sum+" "+syn);
    188.                 System.out.printf("%-8d",sum);
    189.                 System.out.println("数字");
    190.             } else {
    191.                 fos5.write((token1+str+"\n").getBytes(StandardCharsets.UTF_8));
    192.                 System.out.println("界符");
    193.             }
    194.  
    195.         }while(syn!=0);
    196.         fos0.close();
    197.         fos1.close();
    198.         fos2.close();
    199.         fos3.close();
    200.         fos4.close();
    201.         fos5.close();
    202.     }
    203. }

    运行结果：

     

    三.第三版（文本保存）

    c++版

    1. #include 
    2. #include 
    3.  
    4.  
    5. enum symbol {
    6. 	nul, ident, number, plus, minus,
    7. 	times, slash, oddsym, eql, neq,
    8. 	lss, leq, gtr, geq, lparen,
    9. 	rparen, comma, semicolon, period, becomes,
    10. 	beginsym, endsym, ifsym, thensym, whilesym,
    11. 	writesym, readsym, dosym, callsym, constsym,
    12. 	varsym, procsym,
    13. };
    14.  
    15. int cc, ll;
    16. FILE * fa1;
    17. int err; /*错误计数器*/ 
    18. FILE* fin;
    19. int cx; 
    20. char ch;
    21. char line[81];
    22. #define getchdo if(-1==getch())return -1
    23. # define al 10 
    24. char a[al + 1];
    25. char id[al + 1];
    26. # define norw 13 
    27. char word[norw][al];
    28. enum symbol sym;
    29. enum symbol wsym[norw];
    30. # define nmax 14 
    31. int num;
    32. enum symbol ssym[256];
    33. char fname[al];
    34.  
    35.  
    36.  
    37. void init();
    38. void error(int n);
    39. int getch();
    40. int getsym();
    41.  
    42.  
    43.  
    44.  
    45. int main()
    46. {
    47.     printf("Input pl/0 file?");
    48. 	scanf("%s", fname);					/* 输入PL/0源程序文件名 */
    49.     fin = fopen(fname, "r");
    50.     if(fin)
    51.     {
    52.         printf("Output pl/0 file?");
    53.         scanf("%s", fname);
    54.         fa1 = fopen(fname, "w");
    55.  
    56.         init();
    57.         
    58. //        err = 0;
    59. //        cc = cx = ll = 0;
    60. //        ch = ' ';
    61.         
    62.         while(getsym() != -1);
    63.  
    64.     }
    65.     else
    66.     {
    67.         printf("找不到文件\n");
    68.     }
    69.     printf("\n");
    70.     
    71.     return 0;
    72. }
    73.  
    74. void init()
    75. {
    76. 	int i;
    77. 	
    78. 	/* 设置单字符符号 */
    79. 	for(i=0; i<=255; i++)
    80. 	{
    81. 		ssym[i] = nul;
    82. 	}
    83. 	ssym['+'] = plus;
    84. 	ssym['-'] = minus;
    85. 	ssym['*'] = times;
    86. 	ssym['/'] = slash;
    87. 	ssym['('] = lparen;
    88. 	ssym[')'] = rparen;
    89. 	ssym['='] = eql;
    90. 	ssym[','] = comma;
    91. 	ssym['.'] = period;
    92. 	ssym['#'] = neq;
    93. 	ssym[';'] = semicolon;
    94.  
    95. 	/* 设置保留字名字，按照字母顺序，便于折半查找 */
    96. 	strcpy(word[0], "begin");
    97. 	strcpy(word[1], "call");
    98. 	strcpy(word[2], "const");
    99. 	strcpy(word[3], "do");
    100. 	strcpy(word[4], "end");
    101. 	strcpy(word[5], "if");
    102. 	strcpy(word[6], "odd");
    103. 	strcpy(word[7], "procedure");
    104. 	strcpy(word[8], "read");
    105. 	strcpy(word[9], "then");
    106. 	strcpy(word[10], "var");
    107. 	strcpy(word[11], "while");
    108. 	strcpy(word[12], "write");
    109.  
    110. 	/* 设置保留字符号 */
    111. 	wsym[0] = beginsym;
    112. 	wsym[1] = callsym;
    113. 	wsym[2] = constsym;
    114. 	wsym[3] = dosym;
    115. 	wsym[4] = endsym;
    116. 	wsym[5] = ifsym;
    117. 	wsym[6] = oddsym;
    118. 	wsym[7] = procsym;
    119. 	wsym[8] = readsym;
    120. 	wsym[9] = thensym;
    121. 	wsym[10] = varsym;
    122. 	wsym[11] = whilesym;
    123. 	wsym[12] = writesym;
    124. }
    125.  
    126.  
    127. /*
    128.  * 出错处理，打印出错位置和错误编码
    129.  */
    130. void error(int n)
    131. {
    132. 	char space[81];
    133. 	memset(space,32,81);
    134. 	space[cc-1] = 0;	//出错时当前符号已经读完，所以cc-1
    135. 	printf("****%s!%d\n",space,n);
    136. 	fprintf(fa1,"****%s!%d\n",space,n);
    137. 	err++;
    138. }
    139.  
    140. /*
    141.  * 漏掉空格，读取一个字符。
    142.  *
    143.  * 每次读一行，存入line缓冲区，line被getsym取空后再读一行
    144.  *
    145.  * 被函数getsym调用。
    146.  */
    147. int getch()
    148. {
    149. 	if(cc==ll)
    150. 	{
    151. 		if(feof(fin))
    152. 		{
    153. 			printf("program incomplete");
    154. 			return -1;
    155. 		}
    156. 		ll=0;
    157. 		cc=0;
    158. 		ch = ' ';
    159. 		while(ch != 10)
    160. 		{
    161. 			if(EOF == fscanf(fin,"%c",&ch))
    162. 			{
    163. 				line[ll]=0;
    164. 				break;
    165. 			}
    166. 			//fprintf(fa1,"%c", ch);
    167. 			line[ll]=ch;
    168. 			ll++;
    169. 		}
    170. 	
    171. 	}
    172. 	ch = line[cc];
    173. 	cc++;
    174. 	return 0;
    175. }
    176.  
    177. /*
    178.  * 词法分析，获取一个符号
    179.  */
    180. int getsym()
    181. {
    182. 	int i,j,k;
    183. 	if(ch=='#'){
    184. 		return -1;
    185. 	}
    186. 	while(ch==' ' || ch==10 || ch==9)		/* 忽略空格、换行和TAB */
    187. 	{
    188. 		getchdo;
    189. 	}
    190. 	if(ch>='a' && ch<='z')
    191. 	{										/* 名字或保留字以a~z开头*/
    192. 		k = 0;
    193. 		do{
    194. 			if(k
    195. 			{
    196. 				a[k]=ch;
    197. 				k++;
    198. 			}
    199. 			getchdo;
    200. 		}while(ch>='a'&&ch<='z' || ch>='0'&&ch<='9');
    201. 		a[k] = 0;
    202. 		strcpy(id,a);
    203. 		i=0;
    204. 		j=norw-1;
    205. 		do{									/* 搜索当前符号是否为保留字 */
    206. 			k=(i+j)/2;
    207. 			if(strcmp(id,word[k]) <= 0)
    208. 			{
    209. 				j=k-1;
    210. 			}
    211. 			if(strcmp(id,word[k]) >= 0)
    212. 			{
    213. 				i=k+1;
    214. 			}			
    215. 		}while(i<=j);
    216. 		if(i-1>j)
    217. 		{
    218. 			printf("%s  保留字\n", id);
    219. 			fprintf(fa1,"%s  保留字\n", id);
    220. 			sym=wsym[k];
    221. 		}
    222. 		else
    223. 		{
    224. 			printf("%s  标识符\n", id);
    225. 			fprintf(fa1,"%s  标识符\n", id);
    226. 			sym=ident;						/* 搜索失败，则是名字或数字 */
    227. 		}
    228. 	}
    229. 	else
    230. 	{
    231. 		if(ch>='0'&&ch<='9')
    232. 		{									/* 检测是否为数字：以0~9开头 */
    233. 			k=0;
    234. 			num=0;
    235. 			sym=number;
    236. 			do{
    237. 				//printf("%c\n",ch);
    238. 				num=10*num+ch-'0';
    239. 				k++;
    240. 				getchdo;
    241. 			}while(ch>='0'&&ch<='9');		/* 获取数字的值 */
    242. 			k--;
    243. 			if(k>nmax)
    244. 			{
    245. 				error(30);
    246. 			}
    247. 			printf("%d  整数\n",num);
    248. 			fprintf(fa1,"%d  整数\n", num);
    249. 		}
    250. 		else
    251. 		{
    252. 			if(ch==':')						/* 检测赋值符号 */
    253. 			{
    254. 				getchdo;
    255. 				if(ch=='=')
    256. 				{
    257. 					printf(":=  运算符\n");
    258. 					fprintf(fa1,":=  运算符\n", id);
    259. 					sym=becomes;
    260. 					getchdo;
    261. 				}
    262. 				else
    263. 				{
    264. 					printf(":  error\n");
    265. 					sym=nul;				/* 不能识别的符号 */
    266. 				}
    267. 			}
    268. 			else
    269. 			{
    270. 				if(ch=='<')					/* 检测小于或小于等于符号 */
    271. 				{
    272. 					getchdo;
    273. 					if(ch=='=')
    274. 					{
    275. 						printf("<=  运算符\n");
    276. 						fprintf(fa1,"<=  运算符\n", id);
    277. 						sym=leq;
    278. 						getchdo;
    279. 					}
    280. 					else
    281. 					{
    282. 						printf("<  运算符\n");
    283. 						fprintf(fa1,"<  运算符\n", id);
    284. 						sym=lss;
    285. 					}
    286. 				}
    287. 				else
    288. 				{
    289. 					if(ch=='>')					/* 检测大于或大于等于符号 */
    290. 					{
    291. 						getchdo;
    292. 						if(ch=='=')
    293. 						{
    294. 							printf(">=  运算符\n");
    295. 							fprintf(fa1,">=  运算符\n", id);
    296. 							sym=geq;
    297. 							getchdo;
    298. 						}
    299. 						else
    300. 						{
    301. 							printf(">  运算符\n");
    302. 							fprintf(fa1,">  运算符\n", id);
    303. 							sym=gtr;
    304. 						}
    305. 					}
    306. 					else
    307.                     {
    308.                         if(ch=='=')
    309.                         {
    310.                            printf("=  运算符\n");
    311.                            fprintf(fa1,"=  运算符\n", id);
    312.                             //getchdo;
    313.                         }
    314.                         if(ch=='+')
    315.                         {
    316.                            printf("+  运算符\n");
    317.                            fprintf(fa1,"+  运算符\n", id);
    318.                             getchdo;
    319.                         }
    320.                         else if(ch=='-')
    321.                         {
    322.                             printf("-  运算符\n");
    323.                             fprintf(fa1,"-  运算符\n", id);
    324.                             getchdo;
    325.                         }
    326.                         else if(ch=='*')
    327.                         {
    328.                             printf("*  运算符\n");
    329.                             fprintf(fa1,"*  运算符\n", id);
    330.                             getchdo;
    331.                         }
    332.                         else if(ch=='/')
    333.                         {
    334.                             printf("/  运算符\n");
    335.                             fprintf(fa1,"/  运算符\n", id);
    336.                             getchdo;
    337.                         }
    338.                         else if(ch=='(')
    339.                         {
    340.                             printf("(  运算符\n");
    341.                             fprintf(fa1,"(  运算符\n", id);
    342.                             getchdo;
    343.                         }
    344.                         else if(ch==')')
    345.                         {
    346.                             printf(")  运算符\n");
    347.                             fprintf(fa1,")  运算符\n", id);
    348.                             getchdo;
    349.                         }
    350.                         else if(ch==',')
    351.                         {
    352.                             printf(",  运算符\n");
    353.                             fprintf(fa1,",  运算符\n", id);
    354.                             getchdo;
    355.                         }
    356.                         else if(ch==';')
    357.                         {
    358.                            printf(";  运算符\n");
    359.                            fprintf(fa1,";  运算符\n", id);
    360.                             getchdo;
    361.                         }
    362.                         else if(ch=='.')
    363.                         {
    364.                             printf(".  运算符\n");
    365.                             fprintf(fa1,".  运算符\n", id);
    366.                             getchdo;
    367.                         }
    368. 						else
    369. 						{							
    370. 							sym=ssym[ch];			/* 当符号不满足上述条件时，全部按照单字符符号处理 */							
    371. 							if(sym != period)
    372. 							{
    373. 								getchdo;
    374. 							}							
    375. 						}
    376. 				   }
    377. 		       }
    378. 			}
    379. 	   }
    380. 	}
    381. 	return 0;
    382. }

    运行结果：

  • 相关阅读:
    开源的滚滚浪潮：近年来开源多样化的几大亮点
    关于自定义 HttpServletRequestWrapper 后续读不到参数的问题
    20年上海站D题Walker（二分，简洁）
    c语言使用fdk_aac库对aac音频解码为pcm
    Python工程师Java之路（h）Java字符串拼接+null拼接处理
    spring---第四篇
    前端设计模式之【迭代器模式】
    [KALI] 开启ssh远程连接
    spring：详解spring MVC
    docker-compose
  • 原文地址：https://blog.csdn.net/qq_58631644/article/details/128128416