实验一：文法的判断与处理

最新推荐文章于 2021-07-15 14:55:11 发布

artguo

最新推荐文章于 2021-07-15 14:55:11 发布

阅读量3.5k

点赞数 8

文章标签：编译原理

本文链接：https://blog.csdn.net/artguo/article/details/89287777

版权

实验一：文法的判断与处理

实验要求：
1）编写一段程序，接受文法的输入；
2）从文法的产生式中分离出非终结符和终结符，并输出；
3）判断该文法的文法类型，是否为0型，1型，2型或3型文法，并输出判断结果。
4）用C#或JAVA语言实现；
5）终结符和非终结符的判断依据为是否为小写字母；

实验报告以及实验程序的提交：
1）本周五晚上9点以前将实验程序和实验报告的word文档打包上传超星网络教学平台。
2）每个同学的文件压缩包命名为：学号_姓名_1.rar
3）压缩包中应包含两个文件夹，一个存放程序，另一个存放实验报告的word文件。

文法用二维数组来存储,定义符号→用“:”代替。
如文法G[S]:
aS:aB
bS:bA
A:bAA
A:a
A:aS
B:b
B:bS
B:aBB

实验代码

package compile_1;

import java.util.Scanner;

public class exp_1 {

	public static void main(String[] args) {
		int flag=4;
		char[] a1;
		char[] a2;
		String str;
        System.out.println("输入产生式的个数");
        Scanner ip = new Scanner(System.in) ; 
        int t=ip.nextInt();
        char[][] num = new char[t][];//定义数组
		char[][] left=new char[t][];
		char[][] right=new char[t][];
        //输入
        Scanner in = new Scanner(System.in); 
            for(int i=0;i<t;i++)
            {   System.out.println("输入第"+(i+1)+"个产生式");
            	num[i]=in.next().toCharArray(); 
            	}
        for(int i=0;i<t-1;i++)
        { 
        	String s=String.valueOf(num[i]);
        	String[]d=s.split(":");
        	a1=d[0].toCharArray(); 
        	a2=d[1].toCharArray(); 
        	left[i]=a1;
        	right[i]=a2;
        	if(zeroJudge(left[i]))
    		{
    			if(oneJudge(left[i],right[i]))
    			{
    				if(twoJudge(left[i],right[i]))
    				{
    					if(threeJudge(left[i],right[i]))
    					{
    						if(flag < 3)
    							;
    						else
    							flag = 3;
    					}
    					else{
    						if(flag < 2)
    							;
    						else
    							flag = 2;
    					}
    				}
    				else{
    					if(flag < 1)
    						;
    					else
    						flag = 1;
    				}
    			}
    			else{
    				flag = 0;
    			}
    		}
    	}
        
        judge(flag);

	}

	
	public static boolean zeroJudge(char left[])  {
		int i=0;
		while(left[i] != '\n'){
			if(left[i] < 65 || (left[i] > 90 && left[i] < 97) || left[i] > 122){
				System.out.println("含有非法符号，不合法产生式");
				return false;
			}
			else 
			if((left[i] >= 97 && left[i] <= 122)){
				if(i == (left.length-1)){
					System.out.println("左侧全为终结符，不合法产生式");
					return false;
				}
			}
			else if(left[i] >= 65 && left[i] <= 90){
				//合法产生式
				break;
			}
			i++;
		}
		return true;
	}

    public static boolean oneJudge(char left[],char right[])  {
    	if(right.length >= left.length)
    	{
    		return true;
    	}
    	return false;
    	
    }
    public static boolean twoJudge(char left[],char right[])  {
    	if((1 == left.length) && (left[0] >= 65 && left[0] <= 90))
    	{
    		return true;
    	}
    	return false;
    	
    }
    public static boolean threeJudge(char left[],char right[])  {
    	if((1 == right.length) && (right[0] >= 97 && right[0] <= 122))
    	{
    		return true;
    	}
    	if(2 == right.length){
    		if((right[0] >= 65 && right[0] <= 90) && (right[1] >= 97 && right[1] <= 122))
    		{
    			return true;
    		}
    		if((right[0] >= 97 && right[0] <= 122) && (right[1] >= 65 && right[1] <= 90))
    		{
    			return true;
    		}
    	}
    	return false;
    	
    }
    public static void judge(int flag)
    {
    	switch(flag)
    	{
    	case 0:
    		System.out.println("0型文法!");
    		break;
    	case 1:
    		System.out.println("1型文法!");
    		break;
    	case 2:
    		System.out.println("2型文法!");
    		break;
    	case 3:
    		System.out.println("3型文法!");
    		break;
    	}
    }
}

输入与输出