inputgrammar.java

有限自动机输入,转换,识别,图形显示与化简

package cn.work.zdj.ui;

import java.util.Hashtable;
import java.util.Vector;

import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.Text;
import org.eclipse.swt.widgets.Widget;
import org.eclipse.ui.ISelectionListener;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.part.ViewPart;

import cn.work.zdj.sys.AutoMachine;
import cn.work.zdj.sys.AutoMachineFactory;
import cn.work.zdj.sys.IAppConstants;

public class InputGrammar extends ViewPart implements ISelectionListener{
	private Group group_1,group_2,group_3,group_4;
	private Button bState_1,bLetter_1,bFunction_1,bFirState_1;
	private Text lState_1,lLetter_1,lFunction_1,lFirState_1;
	private AutoMachine machine;
	private int funLine = 6;
	private Vector<String> threeRow;
	
	public InputGrammar() {
		// TODO 自动生成构造函数存根
		
	}

	@Override
	public void createPartControl(Composite parent) {
		// TODO 自动生成方法存根
		Composite composite = new Composite(parent,SWT.NONE);
		composite.setLayout(new GridLayout(1,false));
		//Color fontColor = new Color(Display.getCurrent(),0xff,0x00,0x00);
		
		Composite comLabel = new Composite(composite,SWT.None);
		comLabel.setLayout(new GridLayout(2,true));
		Label label = new Label(comLabel,SWT.NONE);
		label.setText("请输入转化后自动机的名称");
		final Text txtLabel = new Text(comLabel,SWT.BORDER);
		txtLabel.setLayoutData(new GridData(SWT.FILL,SWT.CENTER,true,false));
		
		//第一组
		group_1 = new Group(composite,SWT.None);
		GridData gd = new GridData(GridData.FILL_BOTH);
		group_1.setLayoutData(gd);
		group_1.setText("输入非终结符");
		final GridLayout gridLayout = new GridLayout(3,false);
		gridLayout.marginRight = 10;
		gridLayout.verticalSpacing = 10;
		gridLayout.marginHeight = 10;
		group_1.setLayout(gridLayout);
		
		final Label label1 = new Label(group_1,SWT.None);
		label1.setText("非终结符");
		
		final Text tState_1 = new Text(group_1,SWT.RIGHT|SWT.BORDER);
		tState_1.setText("");
		bState_1 = new Button(group_1,SWT.NONE);
		bState_1.setText("增加");
		gd = new GridData();
		lState_1 = new Text(group_1,SWT.None);		
		lState_1.setText("未输入非终结符");
		lState_1.setText("S,B,");
		lState_1.setLayoutData(new GridData(SWT.FILL,SWT.FILL,true,true,3,1));
		//lState_1.setEnabled(false);
		
		
		//		第二组
		group_2 = new Group(composite,SWT.None);
		gd = new GridData(GridData.FILL_BOTH);
		group_2.setLayoutData(gd);
		group_2.setText("输入终结符");
		group_2.setLayout(new GridLayout(3,false));
		
		final Label label2 = new Label(group_2,SWT.None);
		label2.setText("终结符");
		
		final Text tLetter_1 = new Text(group_2,SWT.RIGHT|SWT.BORDER);
		tLetter_1.setText("");
		bLetter_1 = new Button(group_2,SWT.NONE);
		bLetter_1.setText("增加");
		lLetter_1 = new Text(group_2,SWT.None);		
		lLetter_1.setText("未输入终结符");
		lLetter_1.setText("a,b,");
		lLetter_1.setLayoutData(new GridData(SWT.FILL,SWT.FILL,true,true,3,1));
		//lLetter_1.setEnabled(false);
		
		//		第三组
		group_3 = new Group(composite,SWT.None);
		gd = new GridData(GridData.FILL_BOTH);
		group_3.setLayoutData(gd);
		group_3.setText("输入右线性文法");
		group_3.setLayout(new GridLayout(9,false));
		
		final Label label3 = new Label(group_3,SWT.None);
		label3.setText("文法");

		final Text tFunction_1 = new Text(group_3,SWT.RIGHT|SWT.BORDER);
		final Label label5 = new Label(group_3,SWT.None);
		label5.setText("->");
		final Text tFunction_2 = new Text(group_3,SWT.RIGHT|SWT.BORDER);
		final Text tFunction_3 = new Text(group_3,SWT.RIGHT|SWT.BORDER);
		tFunction_3.setText("");
		bFunction_1 = new Button(group_3,SWT.NONE);
		bFunction_1.setText("增加");
		
		lFunction_1 = new Text(group_3,SWT.COLOR_RED);
		lFunction_1.setText("未输入右线性文法");
		lFunction_1.setLayoutData(new GridData(SWT.FILL,SWT.FILL,true,true,9,9));
		
		//		第四组
		group_4 = new Group(composite,SWT.None);
		gd = new GridData(GridData.FILL_BOTH);
		group_4.setLayoutData(gd);
		group_4.setText("输入开始符号");
		group_4.setLayout(new GridLayout(3,false));
		
		final Label label8 = new Label(group_4,SWT.None);
		label8.setText("开始符号");
		
		final Text tFirState_1 = new Text(group_4,SWT.RIGHT|SWT.BORDER);
		
		
		bFirState_1 = new Button(group_4,SWT.NONE);
		bFirState_1.setText("增加");
		lFirState_1 = new Text(group_4,SWT.None);		
		lFirState_1.setText("未输入开始符号");
		//lFirState_1.setText("q0");
		lFirState_1.setLayoutData(new GridData(SWT.FILL,SWT.FILL,true,true,3,1));
		//lFirState_1.setEnabled(false);
		
		
		gd = new GridData();
		gd.horizontalAlignment = SWT.CENTER;
		Composite comBtn = new Composite(composite,SWT.None);
		comBtn.setLayout(new GridLayout(3,true));
		comBtn.setLayoutData(gd);
		final Button sure = new Button(comBtn,SWT.RIGHT);
		sure.setText("转化自动机");
		final Button modify = new Button(comBtn,SWT.RIGHT);
		modify.setText("删除");
		modify.setEnabled(false);
		
		final Button clear = new Button(comBtn,SWT.RIGHT);
		clear.setText("重置");
		
		SelectionListener listener = new SelectionListener(){

			public void widgetDefaultSelected(SelectionEvent e) {
				// TODO 自动生成方法存根			
			}

			public void widgetSelected(SelectionEvent e) {
				// TODO 自动生成方法存根
				Widget w = e.widget;
				
				if(w == bState_1){
					if(tState_1.getText().trim().equals("")){
						return ;
					}
					if(lState_1.getText().equals("未输入非终结符")){
						lState_1.setText("非终结符:"+tState_1.getText()+",");
					}else{
						lState_1.append(tState_1.getText()+",");
					}
					//dialog.setType(1);
					//dialog.open();
					tState_1.setText("");
				}else if(w == bLetter_1){
					if(tLetter_1.getText().trim().equals("")){
						return ;
					}
					if(tLetter_1.getText().trim().length() != 1){
						MessageDialog.openError(null,"提示","终结符必须为一位");
						return;
					}
					if(lLetter_1.getText().equals("未输入终结符")){
						lLetter_1.setText("终结符:"+tLetter_1.getText()+",");
					}else{
						lLetter_1.append(tLetter_1.getText()+",");
					}
					tLetter_1.setText("");
				}else if(w == bFunction_1){
					
					if(tFunction_1.getText().trim().equals("") 
							|| tFunction_2.getText().trim().equals("")){
						return ;
					}
					if(lFunction_1.getText().equals("未输入右线性文法")){
						lFunction_1.setText("右线性文法:"+tFunction_1.getText()+"->"+tFunction_2.getText()
														+" "+tFunction_3.getText().trim()+", ");
					}else{
						lFunction_1.append(tFunction_1.getText()+"->"+tFunction_2.getText()
								+" "+tFunction_3.getText().trim()+", ");
					}
					if(--funLine ==0){
						funLine =6;
						lFunction_1.append("\n");
					}
					//tFunction_1.setText("");
					//tFunction_2.setText("");
					//tFunction_3.setText("");
				}else if(w == bFirState_1){
					if(tFirState_1.getText().trim().equals(""))
						return;
					if(lFirState_1.getText().equals("未输入开始符号")){
						lFirState_1.setText("开始符号:"+tFirState_1.getText());
					}
					bFirState_1.setEnabled(false);
				}else if(w == sure){
					
					Vector<String> states = analyzeStates(lState_1.getText());
					Vector letters = analyzeLetters(lLetter_1.getText());
					String endState = analyzeEndState(states);
					Hashtable functions = analyzeFunctions(lFunction_1.getText(),endState);
					Vector<String> endStates = new Vector<String>();
					endStates.add(endState);
					states.add(endState);
					String temp = lFirState_1.getText();
					String firState = temp.substring(temp.indexOf(":")+1,temp.length());
					if(firState.indexOf("未输入") != -1){
						firState = "";
					}
					
					machine = new AutoMachine(txtLabel.getText());
					machine.maxcols = 2;
					machine.Init(states, letters, functions, firState, endStates,threeRow);
					if(! machine.isValidate() || !isValidate(txtLabel.getText(),states,letters,functions,firState,endStates)){
						MessageDialog.openError(null,"提示","自动机无法正常初始化");
						return;
					}			
					AutoMachineFactory.getInstance().add(machine);
					OldZdj.selectionChanged();
					
					modify.setEnabled(true);
					
					clear();
					//init();
					
				}else if(w == modify){
					IViewPart vp = getViewSite().getPage().findView(IAppConstants.OLD_ZDJ_VIEW_ID);
					Table table = ((OldZdj)vp).getTableViewer().getTable();
					if(table.getSelectionIndex() == -1){
						MessageDialog.openInformation(null,"提示","请先在左边选择要删除的自动机");
						return;
					}
					machine = (AutoMachine)table.getItem(table.getSelectionIndex()).getData();
					AutoMachineFactory.getInstance().remove(machine);
					OldZdj.selectionChanged();
					if(AutoMachineFactory.getInstance().getMachines().size() ==0)
						modify.setEnabled(false);
				}else if(w == clear){
					clear();
				}
			}

			private boolean isValidate(String text, Vector states, Vector letters, Hashtable functions,String firState, Vector endStates) {
				// TODO 自动生成方法存根
				if(text.trim().equals("")||states.size() == 0||letters.size() ==0
						||functions == null||firState.trim().equals("")||endStates.size()==0)
					return false;
				return true;
			}
			
			private void clear(){
				txtLabel.setText("");
				lState_1.setText("未输入非终结符");
				lLetter_1.setText("未输入终结符");
				lFunction_1.setText("未输入右线性文法");
				lFirState_1.setText("未输入开始符号");
				bFirState_1.setEnabled(true);
			}

		};
		bState_1.addSelectionListener(listener);
		bFunction_1.addSelectionListener(listener);
		bFirState_1.addSelectionListener(listener);
		bLetter_1.addSelectionListener(listener);
		sure.addSelectionListener(listener);
		modify.addSelectionListener(listener);
		clear.addSelectionListener(listener);
		PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().addSelectionListener(this);
	}

	private String analyzeEndState(Vector states) {
		// TODO 自动生成方法存根
		String[] endStates = {"Z","A","B","C","D","Z0"};
		for(int i=0;i<endStates.length;i++){
			String endState = endStates[i];
			int j;
			for( j=0;j<states.size();j++){
				if(endState.equals((String)states.get(j)))
						break;
				
			}
			if(j == states.size())
				return endState;
		}
		return "Zt";
	}
	
	private Vector analyzeLetters(String letters){
		letters = letters.substring(0,letters.length()-1);
		String[] array = letters.split(",");
		Vector<Character> letter = new Vector<Character>();
		if(array.length ==1 && array[0].trim().indexOf("未输入") != -1){
			return letter;
		}
		for(int i=0;i<array.length;i++){
			if(i==0){
				String temp = array[i];
				letter.add((temp.substring(temp.indexOf(":")+1, temp.length())).charAt(0));
				continue;
			}
			letter.add(array[i].charAt(0));
		}
		//MessageDialog.openError(null,"提示",letter.toString());
		return letter;
	}
	private Vector<String> analyzeStates(String states){
		states = states.substring(0,states.length()-1);
		String[] array = states.split(",");
		Vector<String> state = new Vector<String>();
		if(array.length ==1 && array[0].trim().indexOf("未输入") != -1){
			return state;
		}
		for(int i=0;i<array.length;i++){
			if(i==0){
				String temp = array[i];
				state.add(temp.substring(temp.indexOf(":")+1, temp.length()));
				continue;
			}
			state.add(array[i]);
			
		}
		//MessageDialog.openError(null,"提示",state.toString());
		return state;
	}
	private Hashtable analyzeFunctions(String functions,String endState){
		functions = functions.trim().substring(0,functions.trim().length()-1);
		String[] array = functions.split(", ");
		Hashtable<String,Vector> funs = new Hashtable<String,Vector>();
		if(array.length ==0 && array[0].trim().equals("未输入右线性文法")){
			return null;
		}
		for(int i=0;i<array.length;i++){
			
			String fun = array[i];
			int pos_one = fun.indexOf("->");
			int pos_two = fun.indexOf(" ");
			String one = fun.substring(pos_one-1, pos_one).trim();
			char two = fun.substring(pos_one+2, pos_two).trim().charAt(0);
			String three = null;
			if(pos_two == fun.length()-1)
				three = endState;
			else
				three = fun.substring(pos_two+1,fun.length()).trim();			
			Hashtable<Character,String> temp = new Hashtable<Character,String>();	
			temp.put(two,three);
			if(!funs.containsKey(one)){
				Vector<Hashtable> vecTemp = new Vector<Hashtable>();
				vecTemp.add(temp);
				funs.put(one, vecTemp);
			}else{
				Vector<Hashtable> vecTemp = (Vector<Hashtable>)funs.get(one);
				vecTemp.add(temp);
			}
			if(threeRow == null)
				threeRow = new Vector<String>();
			
			String row = one+":"+two+":"+three;
			threeRow.add(row);
			//MessageDialog.openError(null,"提示",one+":"+two+":"+three);
		}
		
		//MessageDialog.openError(null,"提示",""+array.length);
		return funs;
	}

	@Override
	public void setFocus() {
		// TODO 自动生成方法存根

	}

	public void selectionChanged(IWorkbenchPart part, ISelection selection) {
		// TODO 自动生成方法存根
		
	}

}