grammar.java

编译原理的FOR循环语句的翻译

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Hashtable;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.Vector;

public class Grammar {

	Vector wordVector = null;

	Main main = null;

	String terminal[] = { "for", "(", ")", ";", "=", "+", "-", "*", "/", "==",
			">", ">=", "<", "<=", "!=", "i" };

	String operator[] = { ">", ">=", "<", "<=", "==", "!=" };

	String operator1[] = { "(", ")", "+", "-", "*", "/", "=", ";" };

	String assignOperator[] = { "+", "-", "*", "/", "(", ")", ";" };

	int currentPoint = 0;

	int type = 0;

	String currentString = null;

	Hashtable table = null;

	NonTerminal w, x, y, z, s, a, b, h, i, j, k, l, m, n, c, c1, d, d1, e, e1,
			f, f1, g;

	StringTokenizer tokenizer = null;

	boolean isRight = false;

	int maxPoint = 0;

	Token tempToken = null;

	Vector assignVector = null;

	Vector expressionVector = null;

	Vector midcodeVector = null;

	boolean isAssign = false;

	boolean isExpression = false;

	boolean isExpressionProcessed = false;

	boolean isAssignProcessed = false;

	Stack operandStack = null;

	Stack operatorStack = null;

	char priority[][] = null;

	Vector midResult = null;

	String midcode = "";

	String tempString = "";
	
	Vector sentenceVector=null;

	Grammar(Vector vector, Main main) {
		this.wordVector = vector;
		this.main = main;
		maxPoint = wordVector.size();
	}

	public void analyze() {
		init();
		w();
		if (isRight) {
			
			main.jtaResult.append("输入语句语法正确！\n");
			assignProcess((Vector)sentenceVector.elementAt(0));
			int position =midcodeVector.size();
			conditionProcess((Vector)sentenceVector.elementAt(1));
			for(int i=3;i<sentenceVector.size();i++){
				assignProcess((Vector)sentenceVector.elementAt(i));
			}
			assignProcess((Vector)sentenceVector.elementAt(2));
			midcode = "goto "+position;
			midcodeVector.addElement(midcode);
			midcode ="END";
			midcodeVector.addElement(midcode);
			for(int i=0;i<midcodeVector.size();i++){
				tempString=(String)midcodeVector.elementAt(i);
				if(tempString.startsWith("if")){
					int number=midcodeVector.size()-1;
					tempString=tempString+(i+2);
					midcodeVector.removeElementAt(i);
					midcodeVector.insertElementAt(tempString, i);
					i++;
					tempString=(String)midcodeVector.elementAt(i);
					tempString=tempString+number;
					midcodeVector.removeElementAt(i);
					midcodeVector.insertElementAt(tempString, i);
				}
			}
			String temp = null;
			for (int i = 0; i < midcodeVector.size(); i++) {
				temp = (String) midcodeVector.elementAt(i) + '\n';
				temp = i + ": " + temp;
				main.jtaResult.append(temp);
			}
			output();
			main.jbDisplay.setEnabled(true);
		} else {
			main.jtaResult.append("输入语句有语法错误！\n");
			main.jbDisplay.setEnabled(false);
		}

	}

	private void init() {

		assignVector = new Vector();
		expressionVector = new Vector();
		midcodeVector = new Vector();
		operandStack = new Stack();
		operatorStack = new Stack();
		midResult = new Vector();
		midResult.addElement("T" + 0);
		operatorStack.addElement(";");
		sentenceVector=new Vector();

		w = new NonTerminal();
		w.rules = new String[] { "for ( X ; Y ; Z ) S ;" };
		x = new NonTerminal();
		x.rules = new String[] { "A = B" };
		y = new NonTerminal();
		y.rules = new String[] { "H I J" };
		z = new NonTerminal();
		z.rules = new String[] { "X" };
		s = new NonTerminal();
		s.rules = new String[] { "X" };
		a = new NonTerminal();
		a.rules = new String[] { "C" };
		b = new NonTerminal();
		b.rules = new String[] { "C" };
		h = new NonTerminal();
		h.rules = new String[] { "C" };
		i = new NonTerminal();
		i.rules = new String[] { "< <= > >= == !=" };
		j = new NonTerminal();
		j.rules = new String[] { "C" };
		k = new NonTerminal();
		k.rules = new String[] { "C" };
		l = new NonTerminal();
		l.rules = new String[] { "C" };
		m = new NonTerminal();
		m.rules = new String[] { "C" };
		n = new NonTerminal();
		n.rules = new String[] { "C" };
		c = new NonTerminal();
		c.rules = new String[] { "D C1" };
		c1 = new NonTerminal();
		c1.rules = new String[] { "+ D C1", "$" };
		d = new NonTerminal();
		d.rules = new String[] { "E D1" };
		d1 = new NonTerminal();
		d1.rules = new String[] { "- E D1", "$" };
		e = new NonTerminal();
		e.rules = new String[] { "F E1" };
		e1 = new NonTerminal();
		e1.rules = new String[] { "* F E1", "$" };
		f = new NonTerminal();
		f.rules = new String[] { "G F1" };
		f1 = new NonTerminal();
		f1.rules = new String[] { "/ G F1", "$" };
		g = new NonTerminal();
		g.rules = new String[] { "i", "( C )" };

		priority = new char[][] { { '>', '>', '<', '<', '<', '>', '>' },
				{ '>', '>', '<', '<', '<', '>', '>' },
				{ '>', '>', '>', '>', '<', '>', '>' },
				{ '>', '>', '>', '>', '<', '>', '>' },
				{ '<', '<', '<', '<', '<', '=', ' ' },
				{ '>', '>', '>', '>', ' ', '>', '>' },
				{ '<', '<', '<', '<', '<', ' ', '=' } };
	}

	private void w() {
		Vector characterVector = new Vector();
		String rules[] = w.rules;
		String temp = null;
		String nextElement = null;
		int tempPoint = currentPoint;
		for (int i = 0; i < rules.length; i++) {
			characterVector.clear();
			temp = rules[i];
			tokenizer = new StringTokenizer(temp, " ");
			while (tokenizer.hasMoreElements()) {
				nextElement = (String) tokenizer.nextElement();
				characterVector.addElement(nextElement);
			}
			for (int j = 0; j < characterVector.size(); j++) {
				temp = (String) characterVector.elementAt(j);
				tempToken = (Token) wordVector.elementAt(currentPoint);
				currentString = tempToken.getValue();
				tempString = currentString;
				System.out.println(temp);
				System.out.println(currentString);
				type = tempToken.getType();
				if ((type == 1) || (type == 3)) {
					currentString = "i";
				}
				if (isTerminal(temp)) {
					if (temp.equals(currentString)) {
						isRight = true;
						currentPoint++;

						if (currentString.equals("for")) {
							midcode = "BEGIN";
							midcodeVector.addElement(midcode);
						}
						if (isAssign == true) {
							assignVector.addElement(tempString);
						}
						if (currentString.equals(";") && (isAssign == true)) {
							isAssign = false;
							// assignVector.addElement(currentChar);
						}
						if (currentString.equals(")") && (isAssign == true)) {
							isAssign = false;
							assignVector.removeElementAt(assignVector.size() - 1);
							assignVector.addElement(";");
							// assignVector.addElement(currentChar);
						}
						if (assignVector.size() != 0) {
							if (assignVector.lastElement().equals(";")) {
								if (isAssignProcessed == false) {
									//assignProcess(assignVector);
									isAssignProcessed=true;
									sentenceVector.addElement(assignVector);
								}
							}
						}
						if (isExpression == true) {
							expressionVector.addElement(tempString);
						}
						if (currentString.equals(";") && (isExpression == true)) {
							isExpression = false;
							// expressionVector.addElement(currentChar);
						}
						if (expressionVector.size() != 0) {

							if (expressionVector.lastElement().equals(";")) {
								if (isExpressionProcessed == false) {
									//conditionProcess(expressionVector);
									isExpressionProcessed=true;
									sentenceVector.addElement(expressionVector);
								}
							}
						}
						if (currentPoint >= maxPoint) {
							return;
						}
						continue;
					} else {
						currentPoint = tempPoint;
						isRight = false;
						return;
					}

				} else {
					char c = temp.charAt(0);
					switch (c) {
					case 'X':
						x();
						break;
					case 'Y':
						y();
						break;
					case 'Z':
						z();
						break;
					case 'S':
						s();
						break;
					}
				}

			}

		}
	}

	private void x() {
		isAssign = true;
		assignVector=new Vector();
		isAssignProcessed = false;
		Vector characterVector = new Vector();
		String rules[] = x.rules;
		String temp = null;
		String nextElement = null;
		int tempPoint = currentPoint;
		for (int i = 0; i < rules.length; i++) {
			characterVector.clear();
			temp = rules[i];
			tokenizer = new StringTokenizer(temp, " ");
			while (tokenizer.hasMoreElements()) {
				nextElement = (String) tokenizer.nextElement();
				characterVector.addElement(nextElement);
			}
			for (int j = 0; j < characterVector.size(); j++) {
				temp = (String) characterVector.elementAt(j);
				tempToken = (Token) wordVector.elementAt(currentPoint);
				currentString = tempToken.getValue();
				tempString = currentString;
				System.out.println(temp);
				System.out.println(currentString);
				type = tempToken.getType();
				if ((type == 1) || (type == 3)) {
					currentString = "i";
				}
				if (isTerminal(temp)) {
					if (temp.equals(currentString)) {
						isRight = true;
						currentPoint++;

						if (currentString.equals("for")) {
							midcode = "BEGIN";
									
							midcodeVector.addElement(midcode);
						}
						if (isAssign == true) {
							assignVector.addElement(tempString);
						}
						if (currentString.equals(";") && (isAssign == true)) {
							isAssign = false;
							// assignVector.addElement(currentChar);
						}
						
						if (currentPoint >= maxPoint) {
							return;
						}
						continue;
					} else {
						currentPoint = tempPoint;
						isRight = false;
						return;
					}

				} else {
					char c = temp.charAt(0);
					switch (c) {
					case 'A':
						a();
						break;
					case 'B':
						b();
						break;

					}
				}
			}

		}

	}

	private void y() {
		isExpression = true;
		expressionVector.clear();
		isExpressionProcessed = false;
		Vector characterVector = new Vector();
		String rules[] = y.rules;
		String temp = null;
		String nextElement = null;
		// int tempPoint=currentPoint;
		for (int i = 0; i < rules.length; i++) {
			characterVector.clear();
			temp = rules[i];
			tokenizer = new StringTokenizer(temp, " ");
			while (tokenizer.hasMoreElements()) {
				nextElement = (String) tokenizer.nextElement();
				characterVector.addElement(nextElement);
			}
			for (int j = 0; j < characterVector.size(); j++) {
				temp = (String) characterVector.elementAt(j);
				char c = temp.charAt(0);
				switch (c) {
				case 'H':
					h();
					break;
				case 'I':
					i();
					break;
				case 'J':
					j();
					break;

				}
			}

		}
	}

	private void z() {
		x();
	}

	private void s() {
		x();
	}

	private void a() {
		c();
	}

	private void b() {
		c();
	}

	private void c() {
		Vector characterVector = new Vector();
		String rules[] = c.rules;
		String temp = null;
		String nextElement = null;
		// int tempPoint=currentPoint;
		for (int i = 0; i < rules.length; i++) {
			characterVector.clear();
			temp = rules[i];
			tokenizer = new StringTokenizer(temp, " ");
			while (tokenizer.hasMoreElements()) {
				nextElement = (String) tokenizer.nextElement();
				characterVector.addElement(nextElement);
			}
			for (int j = 0; j < characterVector.size(); j++) {
				temp = (String) characterVector.elementAt(j);
				char c = temp.charAt(0);
				switch (c) {
				case 'D':
					d();
					break;
				case 'C':
					c1();
					break;

				}
			}

		}
	}

	private void d() {
		Vector characterVector = new Vector();
		String rules[] = d.rules;
		String temp = null;
		String nextElement = null;
		// int tempPoint=currentPoint;
		for (int i = 0; i < rules.length; i++) {
			characterVector.clear();
			temp = rules[i];
			tokenizer = new StringTokenizer(temp, " ");
			while (tokenizer.hasMoreElements()) {
				nextElement = (String) tokenizer.nextElement();
				characterVector.addElement(nextElement);
			}
			for (int j = 0; j < characterVector.size(); j++) {
				temp = (String) characterVector.elementAt(j);
				char c = temp.charAt(0);
				switch (c) {
				case 'E':
					e();
					break;
				case 'D':
					d1();
					break;

				}
			}
		}
	}

	private void c1() {
		Vector characterVector = new Vector();
		String rules[] = c1.rules;
		String temp = null;
		String nextElement = null;
		int tempPoint = currentPoint;
		for (int i = 0; i < rules.length; i++) {
			characterVector.clear();
			temp = rules[i];
			tokenizer = new StringTokenizer(temp, " ");
			while (tokenizer.hasMoreElements()) {
				nextElement = (String) tokenizer.nextElement();
				characterVector.addElement(nextElement);
			}
			for (int j = 0; j < characterVector.size(); j++) {
				temp = (String) characterVector.elementAt(j);
				tempToken = (Token) wordVector.elementAt(currentPoint);
				currentString = tempToken.getValue();
				tempString = currentString;
				System.out.println(temp);
				System.out.println(currentString);
				type = tempToken.getType();
				if ((type == 1) || (type == 3)) {
					currentString = "i";
				}
				if (isTerminal(temp)) {
					if (temp.equals(currentString)) {
						currentPoint++;

						isRight = true;

						if (currentString.equals("for")) {
							midcode = "BEGIN";
								
							midcodeVector.addElement(midcode);
						}
						if (isAssign == true) {
							assignVector.addElement(tempString);
						}
						if (currentString.equals(";") && (isAssign == true)) {
							isAssign = false;
							// assignVector.addElement(currentChar);
						}
						
						if (isExpression == true) {
							expressionVector.addElement(tempString);
						}
						if (currentString.equals(";") && (isExpression == true)) {
							isExpression = false;
							// expressionVector.addElement(currentChar);
						}
						
						if (currentPoint >= maxPoint) {
							return;
						}
						continue;
					} else {
						currentPoint = tempPoint;
						isRight = false;
						break;
					}

				} else {
					char c = temp.charAt(0);
					switch (c) {
					case 'D':
						d();
						break;
					case 'C':
						c1();
						break;
					case '$':
						break;

					}
				}
			}

		}
	}

	private void e() {
		Vector characterVector = new Vector();
		String rules[] = e.rules;
		String temp = null;
		String nextElement = null;
		// int tempPoint=currentPoint;
		for (int i = 0; i < rules.length; i++) {
			characterVector.clear();
			temp = rules[i];
			tokenizer = new StringTokenizer(temp, " ");
			while (tokenizer.hasMoreElements()) {
				nextElement = (String) tokenizer.nextElement();
				characterVector.addElement(nextElement);
			}
			for (int j = 0; j < characterVector.size(); j++) {
				temp = (String) characterVector.elementAt(j);
				char c = temp.charAt(0);
				switch (c) {
				case 'F':
					f();
					break;
				case 'E':
					e1();
					break;

				}
			}
		}
	}