成果类.txt

WHILE条件语句的翻译程序设计（LL（1）法、输出四元式）。。按照课程设计的要求

import javax.swing.*;
import java.awt.*;
import java.io.*;
import java.awt.Event;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.UIManager.LookAndFeelInfo;
import javax.swing.filechooser.FileFilter;

import java.util.*;

public class cheng
{ 
	public static void main(String args[])
    {
    	cfFrame frame=new cfFrame();
    	frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    	frame.setVisible(true);
    	frame.setResizable(false);
    	
    }
}
class cfFrame extends JFrame 
{
	public cfFrame()
	{
		LookAndFeelInfo[] infos=UIManager.getInstalledLookAndFeels();
		setTitle("while循环");
		setSize(DEFAULT_WIDTH,DEFAULT_HEIGHT);
		cfPanel panel=new cfPanel();
		add(panel);
		
		
	}
	public static final int DEFAULT_WIDTH=600;
	public static final int DEFAULT_HEIGHT=650;
}
class cfPanel extends JPanel
{
	JPanel bei,center,nan;
	JButton chose,save,start,qingkong,wenfafenxi,fanyi,jieguo;
	JFileChooser chooser;
	JScrollPane scrollin,scrollout;

	JTextArea in,out;//输入输出文本区
	File file;
	String read,write;//保存输入输出
	String tj[],fzhi1[],fzhi2[],fzhi3[];//分别保存源程序中的条件表达式，和赋值语句
	int i=0,j=0,m=0;
	int k=0;
	 int temzhi1=0;//记录赋值语句一的后缀表达式的长度
	 int temzhi2=0;//记录赋值语句二的后缀表达式长度
	 int temzhi3=0;////记录赋值语句三的后缀表达式长度
	//翻译时记录赋值语句一要翻译的个数
	int tongji;
	final int N=100;
	public int lenth1,fuzhi1,fuzhi2,fuzhi3;
	boolean tjTrue=true,fz1True=true,fz2True=true,fz3True=true;
	//String s1[],s2[],s3[],s4[];
	private final String[] operatorOffz={"+","-","*","/","(",")","=","#"};
	private final String[] operatorOftj={"(",")","=","#","<",">"};
	String matrix1[][]={{"D","","","" },
            {"iRi","","",""},
            {"","<",">","="}
};
String matrix2[][]={{"","","","","","","","","i=A"},
            {"","","","","BC","","","","BC"},
            {"+BC","-BA","","","","0","","0",""},
            {"","","","","FD","","","","FD"},
            {"0","0","*FD","/FD","","0","","0",""},
            {"","","","","(A)","","","","i"}

};
String hei1[]={"E","D","R"};
String len1[]={"i","<",">","="};
String hei2[]={"E","A","C","B","D","F"};
String len2[]={"+","-","*","/","(",")","=","#","i",};

public  cfPanel()//界面设置
	{
	    center=new JPanel();
		qingkong=new JButton("清 空");
		jieguo=new JButton("翻 译");
		
	    in=new JTextArea(25,25);
		out=new JTextArea(25,25);
		out.setEditable(false);
		in.setEditable(true);
	    
	    scrollin=new JScrollPane(in);
	    scrollout=new JScrollPane(out);
		center.add(scrollin);
		center.add(scrollout);
		add(center,BorderLayout.CENTER);
		add(qingkong,BorderLayout.SOUTH);
		add(jieguo,BorderLayout.SOUTH);	
		
		jieguo.addActionListener(new ActionListener()
		{
			public void actionPerformed(ActionEvent q)
			{
				tjTrue=true;
				fz1True=true;
				fz2True=true;
				fenxi();
				
			}
		});
		qingkong.addActionListener(new ActionListener()
		{
			public void actionPerformed(ActionEvent q)
			{
				in.setText("");//清空两个文本框
				out.setText("");
			}
		});
	}

public void fenxi()
    {
	  int pan=0;//pan是用来表示把当前字符放到哪一个部分中，fen是用来匹配括号的
	  int i=0,j=0,m=0,k=0;//分别表示条件，赋值语句一，语句二的长度
	  fzhi1=new String[N] ;//存放第一个赋值语句部分
	  fzhi2=new String[N] ;//存放第二个赋值语句部分
	  fzhi3=new String[N];//存放第三个赋值语句部分
	  tj=new String[N] ;//存放条件表达式 
	  String s=in.getText();//获得输入源程序
	  StringTokenizer fenxi=new StringTokenizer(s," \n\t\r;+=/-*\"\')(}{[]<>?:!",true);
	  //用来把输入串分割为单词
	  while(fenxi.hasMoreTokens())//将输入的源程序截取为三个几个部分
	 {   
		 String str=fenxi.nextToken();
		 if (str.equals(" ")||str.equals("\n"))//如果是空格或者回车则分析下一个
			 continue;
		 if(str.equalsIgnoreCase("while"))//将第一个左括号放到第一个赋值表达式
		 {
			 pan=pan+1;
		 }
		 else if(str.equalsIgnoreCase(")")&&pan!=2)
		 { 
			 tj[i++]=str;
			 
		     pan=pan+1;
		 }
		 else if(pan==1)
			 
		        { 
			       tj[i]=str;  
		    	    i++; 
		        }
		else if(pan==2)
			    {
			    	     fzhi1[m]=str;		
			    	     m=m+1;   	   
			     }
	    else 
	    	out.append("输入有误"+"\n");
		    	 
	 }//while
	     lenth1=i;//条件表达式的长度
		 fuzhi1=m;//赋值语句1的长度
	
    if (tj[0].equals("(")&&tj[i-1].equals(")"))//判断条件for是否符合要求
     {
    	 if(fzhi1[1].equals("="))//判断复制语句是否符合要求
    	 {
    		 for(int b=0;b<i-1;b++)
			 {
				 tj[b]=tj[b+1];
			 }
    		 lenth1--;
			
    		 if(has(tj,operatorOftj,lenth1)&&has(fzhi1,operatorOffz,1))
    		 {   
    			 out.append("词法分析通过");
    			 vertify(allString (tj),matrix1,hei1,len1,1);
    			 vertify(allString (fzhi1),matrix2,hei2,len2,2);
    			 if(tjTrue&&fz1True)
    			 {
    				 out.append("语法分析通过"+"\n"+"四元式为："+"\n");
    				 siyuanshi();
    			 }  
    			 else 
    				 out.append("您的句子语法有错误，无法翻译"+"\n");
    		 }//if  
    		 else 
    		 {out.append("词法有错误，请重新输入 ");
    		 }//else
    	 	}//if(fzhi1[1].equals("=")&&fzhi2[1].equals("="))
    	 else
    		 out.append("赋值表达式不符合要求"+"\n");
    	 }//if (tj[0]=="("&&tj[i-1]==")")
     else 
     {
    	 out.append("条件表达式应该在括号内"+"\n");
     }
    }

 public boolean has(String  aaa[],String operator[],int num)
 //判断条件表达式中是否有非法字符。其中的参数分别代表要判断的字符串，要参照的符号表，和字符的长度
 { int b,d;
   boolean isOperator=true,isfu=true; 
  for( b=0;b<num;b++)
  { 
  	for( d=0;d<operator.length;d++)
	{
		if(aaa[b].equals(operator[d]))
			{
			isOperator=true;
			isfu=true;
		    break;
		    }
		else
		{
	     isfu=false;
		continue;
		}
	}//for
	 if (!bianliangpan(aaa[b])&&!isfu)//如果不是合法变量并且不是字符则出错 
		  {
			isOperator=false;
			System.out.print("错了"+aaa[b]);
			break;
		  }
		else if(bianliangpan(aaa[b])&&!isfu)//如果是合法变量
		{
			continue;
		}	
	
  }//for
  if(isOperator==false)
  	{
	  out.append("输入了非法标志符！");
	  return false;
  	}
  else 
  	return true;
 }

 //判断是不是合法的变量
  public boolean bianliangpan(String a)
  { int c;
    char zhjian[];
    boolean istrue=false;
    String ss=a; 
    int f=a.toCharArray().length;
    zhjian=new char[f];
    zhjian=ss.toCharArray();//将当前字符串转化为字符数组来分析

    for( c=0;c<f;c++)
    {
    	if(c==0)
    	{ 
    		if(Character.isDigit(zhjian[0]))
			   {
				   if(f==1)
				   {
				   istrue=true;
				   break;
				   }
				   for(int ii=1;ii<f;ii++)
				   {
					   if(Character.isLetter(zhjian[ii]))
					   {
						   istrue=false;//开头有数字，后面的有一个是字母则就是非法的变量
						   break;
					   }
					   else istrue=true;
				   }//for
				   
			   }//if
    		else if(Character.isLetter(zhjian[0])||zhjian[0]=='_')
    		{
    			istrue=true;//开头是下划线或者字母则是合法变量
    		    break;
    		}
    		else
    		{
    			istrue=false;
    			break;
    		}   		   			
    	}//if
    	 		
    }//for
    if(istrue)
        return true;
    else return false;
    
  }

  public String allString(String arg[]){
      String s=null;
      for(int i=0;i<arg.length;i++){
              s+=arg[i];
      }
      return s;
  }
  public int isOperate(String c){
      String s[]={"+","-","*","/","=","(",")","<",">"};
      for(int i=0;i<s.length;i++){
          if(c!=null&&c.equals(s[i])){
              //System.out.println(c);
              return 1;
          }
      }
      return 0;
  }

 public void vertify(String input,String matrix[][],String s1[],String s2[],int num){
      ArrayList list=new ArrayList();
      StringTokenizer st=new StringTokenizer(input," \n\t\r;+=-*\"\'/)(}{[]<>?:!",true);
      while(st.hasMoreTokens()){
              list.add(new String(st.nextToken()));
      }
      String ci[]=new String[list.size()+1];
      for(int e=0;e<list.size();e++){
              ci[e]=list.get(e).toString();
      }
      ci[list.size()]="#";
      String stack[]=new String[8];
      for(int k=0;k<8;k++){
          stack[k]="_";
      }
      stack[0]="E";
      int point1=0;
      int point2=0;
      int length=ci.length;
      //out.append(allString(stack)+allString(ci)+"\n");

      for(int i=0;i<length-1;i++){
          if(isOperate(ci[i])==0){
              ci[i]="i";
          }
      }
      //out.append(allString(stack)+allString(ci)+"\n");
      while(true){
          if(point1==-1&&point2==length-1){
             // out.append("success"+"\n");
        	  if(num==1)
        		  tjTrue=true;
        	  else if(num==2)
        		  fz1True=true;
        	  else if(num==3)
        		  fz2True=true;
        	  else if(num==4)
        		  fz3True=true;
        	 // out.append("suceedd");
              break;
          }
          if(point1==-1){
             // out.append(allString(stack)+allString(ci)+"\n");
              //out.append("fail"+"\n");
              break;
          }
          if(stack[point1].equals(ci[point2])){
              stack[point1]="_";
              ci[point2]="_";
              point1--;
              point2++;
              //out.append(allString(stack)+allString(ci)+"\n");
              continue;
          }
          String res=getString(stack[point1],ci[point2],matrix,s1,s2);
          if(!res.equals("error")){
              if(res.equals("0")){
                  stack[point1]="_";
                  point1--;
              }
              else{
                  char tem[] = res.toCharArray();
                  int tem2 = 0;
                  int length2 = tem.length;
                  for (int j = point1+length2-1; j > point1-1; j--) {
                      stack[j] = String.valueOf(tem[tem2]);
                      tem2++;
                  }
                  point1+= length2- 1;
              }
              //out.append(allString(stack)+allString(ci)+"\n");
          }
          if(res.equals("error")){
             // out.append("the expression is error"+"\n");
              break;
          }
      }
      ///out.append("over"+"\n");
  }
 
  public String getString(String m,String n,String matrix[][],String s1[],String s2[]){
      //int h;
      for(int i=0;i<s1.length;i++)
      {
          if(s1[i].equals(m))
          {
        	 // out.append("diyi");
              for(int j=0;j<s2.length;j++)
              {
                  if(s2[j].equals(n))
                  {
                	  //out.append("dier");
                      if(matrix[i][j]!=null)
                      {
                          return matrix[i][j];
                      }
                  }
              }
          }
      }
      return "error";
  }


public boolean isZiFu(String a)
{
	if(a.equals("+")||a.equals("-")||a.equals("*")||a.equals("/"))
		return true;
	else 
		return false; 
}
public void siyuanshi()
{
	String siyuanshi[]=new String[100];
	int qianzhui=100;//前缀标志
	int siyuanjishu=2;//四元式的个数
	int t1=1;//分别用于记录规约后的非终结符
	int t2=1;
	tongji=0;//用于记录跳转时候的步骤
		
	String zhi1[]=zhuanhouzhui(fzhi1,fuzhi1,1);//返回第一个赋值语句的后缀式
	
	String tiao=String.valueOf((tongji+4+100));
	
	siyuanshi[0]="( "+tj[1]+" ,"+tj[0]+", "+tj[2]+" ,"+"102"+" )";//将条件表达式转化为四元式
	siyuanshi[1]="(-- ,-- ,-- ,"+tiao+" )";

	for(int i=0;i<temzhi1;i++)//从前往后依次将第一个赋值语句转化为四元式 
	{  
		int j=0,m=0;//用于记录找到的操作符前面的两个操作数
		if(!isZiFu(zhi1[i]))//不是操作符就往后找，直到找到操作符
		continue;
		j=i;
		while(zhi1[j-1].equals("0"))//找到一个不为0的操作数
		j--;
		String s1=zhi1[j-1];
		m=j-1;
		while(zhi1[m-1].equals("0"))
			m--;
		String s2=zhi1[m-1];
		
		siyuanshi[siyuanjishu]="( "+zhi1[i]+" ,"+s2+", "+s1+" ,T"+t1+" )";
		System.out.print(siyuanshi[siyuanjishu]);
		zhi1[m-1]="T"+t1;//将第一个操作数处置为非终结符
		zhi1[j-1]="0";//另外的操作数和操作符处置为0
		zhi1[i]="0";
		t1++;
		siyuanjishu++;	
	}//for
	
	siyuanshi[siyuanjishu]="( ="+" ,"+zhi1[0]+" ,"+" -- ,"+fzhi1[0]+" )";
	System.out.print(siyuanshi[siyuanjishu]);
	siyuanjishu++;
	siyuanshi[siyuanjishu++]="(jump,--,--,100)";
	siyuanshi[siyuanjishu++]="( --,--,--,--)";
	for(int m=0;m<siyuanjishu;m++)
	{
		out.append(qianzhui+++siyuanshi[m]+"\n");//输出四元式
	}
	
}
  
  public String[] zhuanhouzhui(String a[],int length,int biaozhi)
  {
	  String tem[]=new String[10];//存放得到的后缀表达式
	  int temzhi0=0; //记录后缀表达式的长度
	  String Stack[]=new String[length];//当作栈存放操作符
	  int pointer=-1;//栈指针
	 
	  for(int i=2;i<length;i++)
	  {    
           if(a[i].equals("("))//如果为左括号则直接入栈
           {
           Stack[++pointer]=a[i];
           }
           else if(a[i].equals(")"))//碰到右括号 则把左括号以前的都取出来放到后缀式数组
           {
            	while(pointer!=-1&&!(Stack[pointer].equals("(")))
        	    {    
        	    	   System.out.print("dfsdfsdf");
        	    	   tem[temzhi0++]=Stack[pointer--];	
        	    	   System.out.print(tem[temzhi0-1]+" !!");
 
        	    }
        	    pointer--;//丢掉左括号
        	 
           }  
          else if(a[i].equals("+")||a[i].equals("-"))//把所有的*/号放到后缀式数组
            {
        	       tongji++;
	    		   while(pointer!=-1&&(Stack[pointer].equals("*")||Stack[pointer].equals("/")))
	    		   {   
	    			   tem[temzhi0++]=Stack[pointer--];	
	    			   //System.out.print(tem[temzhi0-1]+" !!");
	    		   }    		   
	    	       Stack[++pointer]=a[i];	//然后把+-放到栈里
        	 }
           else if(a[i].equals("*")||a[i].equals("/"))//如果是*/则直接入栈
         {
        	   tongji++;
        	   
        	   Stack[++pointer]=a[i];
    		   
     	  }
           else//否则是操作数则直接入后缀表达式数组
         {
        	 tem[temzhi0++]=a[i];
        	 System.out.print(tem[temzhi0-1]+" !!");
         }	    		 
        	    	

  }
	  
	  while(pointer!=-1)//将所有的栈里面的操作符放到后缀表达式数组中
	  {
		  tem[temzhi0++]=Stack[pointer--];
		  System.out.print(tem[temzhi0-1]+" !!");
	  }
		  temzhi1=temzhi0;
	  return tem;
	 
	  
  }
	
}//cfPanel