parser.java

一个C语言子集的编译器

/*
 * @(#)Parser.java	1.0.0  05/13/2007
 *
 * Copyright 2007 Xuxt@buaa, No.34060520 All rights reserved.
 */

package com.king4solomon.homework.compiler.core;

import java.io.*;

import com.king4solomon.homework.compiler.gui.*;

/**
 * 语法分析类，实现Runnable接口，采用递归下降子方法完成分析
 * 
 * @author Xuxt@buaa
 * @version 1.0.0
 */
public final class Parser implements Runnable {
	// 线程的run方法
	public void run() {
		init();
		try {
			if (SourcePane.index != -1) {
				Lexer.setFileRdr(new FileReader(toOpen));
				Lexer.setThread(thr);
				HandoutFrame.tb11.setEnabled(true);
				Parser.program();
			} else {
				ProblemPane.write("No avaliable file!" + '\n');
				excHalt();
			}

		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			InfoPane.write(e.getMessage());
		}

	}

	/**
	 * 程序分析方法
	 * 
	 * @return ConstSet.STOP词法异常中止；ConstSet.EXECNOM正常中止
	 */
	public static int program() {
		InfoPane.write("program() is called!" + '\n');
		symType = Lexer.getSym();
		switch (symType) {
		// 词法分析出错
		case ConstSet.STOP:
			return ConstSet.STOP;
		case ConstSet.IDENTIFIER:
			ErrorManager.error(9);
			pSkip(9);
		case ConstSet.RESERVED_WORD:
		case ConstSet.TYPE_IDEN:
			value = Lexer.getValue();
			// 常量说明部分，可选
			if (value.equals("const"))
				cnstDec();
			// 变量说明部分或有返回值函数定义部分，可选
			if (symType == ConstSet.TYPE_IDEN) {
				idenType = value;
				symType = Lexer.getSym();
				if (symType == ConstSet.IDENTIFIER) {
					value = Lexer.getValue();
					symType = Lexer.getSym();
					// 变量说明部分
					if (symType == ConstSet.SEMICOLON) {
						Lexer.ungetSym(ConstSet.SEMICOLON, ";");
						Lexer.ungetSym(ConstSet.IDENTIFIER, value);
						varDec(idenType);
					} else if (symType == ConstSet.COMMA) {
						Lexer.ungetSym(ConstSet.COMMA, ",");
						Lexer.ungetSym(ConstSet.IDENTIFIER, value);
						varDec(idenType);
					}
					// 有返回值函数定义部分
					else if (symType == ConstSet.LEFT_PRENTHESES) {
						Lexer.ungetSym(ConstSet.LEFT_PRENTHESES, "(");
						Lexer.ungetSym(ConstSet.IDENTIFIER, value);
						rFDec(idenType);
					}
					// 出错，未知内容
					else {
						ErrorManager.error(14);
						pSkip(14);
						Lexer.getValue();
					}
					// 出错，未知内容
				} else {
					ErrorManager.error(26);
					pSkip(26);
					Lexer.getValue();
				}
			}
			// 函数定义部分
			while (symType == ConstSet.TYPE_IDEN || value.equals("void")) {
				// 有返回值函数定义部分
				if (!value.equals("void")) {
					idenType = value;
					rFDec(idenType);
				} else {
					symType = Lexer.getSym();
					value = Lexer.getValue();
					// 无返回值函数定义部分
					if (symType == ConstSet.IDENTIFIER) {
						Lexer.ungetSym(ConstSet.IDENTIFIER, value);
						nrFDec();
					}
					// 主函数或其他
					else {
						Lexer.ungetSym(symType, value);
						symType = ConstSet.RESERVED_WORD;
						value = "void";
						break;
					}
				}
			}
			// 主函数
			if (symType == ConstSet.RESERVED_WORD && value.equals("void"))
				mainF();
			// 出错
			else {
				ErrorManager.error(27);
				pSkip(27);
			}
			// 程序中止处理
			halt();
			break;

		default:
			ErrorManager.error(11);
			excHalt();
		}
		return ConstSet.EXECNOM;
	}

	/**
	 * 常量说明部分分析方法
	 * 
	 * @return 常量个数
	 */
	public static int cnstDec() {
		InfoPane.write("cnstDec() is called!" + '\n');
		int cstCount = 0;
		do {
			symType = Lexer.getSym();
			// 常量定义
			if (symType == ConstSet.TYPE_IDEN) {
				value = Lexer.getValue();
				idenType = value;
				cnstDef();
			} else {
				ErrorManager.error(30);
				pSkip(30);
			}
			// 下一个常量定义
			if (symType == ConstSet.SEMICOLON) {
				symType = Lexer.getSym();
			} else {
				ErrorManager.error(19);
				pSkip(19);
			}
			value = Lexer.getValue();
			cstCount++;
		} while (value.equals("const"));

		return cstCount;
	}

	/**
	 * 变量说明部分分析方法
	 * 
	 * @param idenTp
	 *            变量声明类型
	 */
	public static void varDec(String idenTp) {
		InfoPane.write("varDec(String idenTp) is called!" + '\n');
		varCount = 0;
		int tmp = varDef(idenTp, varCount);
		if (tmp == ConstSet.VARDECRETURN) {
			// 变量定义或有返回值函数定义部分
			if (symType == ConstSet.SEMICOLON) {
				symType = Lexer.getSym();
				while (symType == ConstSet.TYPE_IDEN) {
					idenType = Lexer.getValue();
					tmp = varDef(idenType, varCount);
					// 是变量定义
					if (tmp == ConstSet.VARDECRETURN) {
						if (symType == ConstSet.SEMICOLON) {
							symType = Lexer.getSym();
						} else {
							ErrorManager.error(19);
							pSkip(19);
						}
					}
					// 变量定义结束
					else
						return;
				}
			} else {
				ErrorManager.error(19);
				pSkip(19);
				CodeGen.gen(ConstSet.INT_INSTR, 0, varCount);
				return;
			}

			value = Lexer.getValue();
			CodeGen.gen(ConstSet.INT_INSTR, 0, varCount);
			return;
		} else {
			return;
		}
	}

	/**
	 * 有返回值函数定义部分分析方法
	 * 
	 * @param idenTp
	 *            函数返回值类型
	 * @return 返回值类型
	 */
	public static int rFDec(String idenTp) {
		InfoPane.write("rFDec(String idenTp) is called!" + '\n');
		int paras;// 记录参数个数
		if (idenTp == "int")
			crtRetType = ConstSet.INTEGER;
		else if (idenTp == "char")
			crtRetType = ConstSet.CHARACTER;
		else if (idenTp == "float")
			crtRetType = ConstSet.REAL;
		// 探测生成跳转到主函数的指令
		if (!hasJumped) {
			tmpPx = CodeGen.px;
			CodeGen.gen(ConstSet.JMP_INSTR, 0, 0);
			hasJumped = true;
		}
		smtHead(idenTp, CodeGen.px);
		if (symType == ConstSet.LEFT_PRENTHESES) {
			symType = Lexer.getSym();
		} else {
			ErrorManager.error(31);
			pSkip(31);
		}
		crtLevel++;
		paras = paraLst();
		SymTable.setValue(paras, paraCount, 5);// 将参数个数填入函数的层数域
		if (symType == ConstSet.RIGHT_PRENTHESES) {
			symType = Lexer.getSym();
			if (symType == ConstSet.LEFT_CURLY) {
				symType = Lexer.getSym();
			} else {
				ErrorManager.error(16);
				pSkip(16);
			}
		} else {
			ErrorManager.error(32);
			pSkip(32);
		}
		cmpdStmt();
		// 探测是否已返回值，如果没有返回
		if (!hasValReturned || hasNVReturned) {
			ErrorManager.error(54);
			pSkip(54);
			hasNVReturned = false;
		} else {
			hasValReturned = false;
		}

		if (symType == ConstSet.RIGHT_CURLY) {
			crtLevel--;
			fQuit();
			symType = Lexer.getSym();
		} else {
			ErrorManager.error(33);
			pSkip(33);
		}
		value = Lexer.getValue();
		int tmp = crtRetType;
		crtRetType = ConstSet.VOIDTYPE;
		return tmp;
	}

	/**
	 * 无返回值函数定义部分分析方法
	 */
	public static void nrFDec() {
		InfoPane.write("nrFDec() is called!" + '\n');
		crtRetType = ConstSet.VOIDTYPE;
		// 探测生成跳转到主函数的指令
		if (!hasJumped) {
			tmpPx = CodeGen.px;
			CodeGen.gen(ConstSet.JMP_INSTR, 0, 0);
			hasJumped = true;
		}
		int paras;
		symType = Lexer.getSym();
		if (symType == ConstSet.IDENTIFIER) {
			nameBuf = Lexer.getValue();
			paraCount = nrFuncInsert(nameBuf, CodeGen.px);
			symType = Lexer.getSym();
			if (symType == ConstSet.LEFT_PRENTHESES) {
				symType = Lexer.getSym();
			} else {
				ErrorManager.error(31);
				pSkip(31);
			}
			crtLevel++;
			paras = paraLst();
			SymTable.setValue(paras, paraCount, 5);
			if (symType == ConstSet.RIGHT_PRENTHESES) {

				symType = Lexer.getSym();
				if (symType == ConstSet.LEFT_CURLY) {
					symType = Lexer.getSym();
					cmpdStmt();
					if (!hasNVReturned) {
						ErrorManager.warning(1);
						CodeGen.gen(ConstSet.RET_INSTR, 0, 0);
					} else if (hasValReturned) {
						ErrorManager.error(57);
						pSkip(57);
						hasValReturned = false;
					}
					hasNVReturned = false;
					if (symType == ConstSet.RIGHT_CURLY) {
						crtLevel--;
						fQuit();
						symType = Lexer.getSym();
						value = Lexer.getValue();
						return;
					} else {
						ErrorManager.error(33);
						pSkip(33);
					}
				} else {
					ErrorManager.error(16);
					pSkip(16);
				}
			} else {
				ErrorManager.error(32);
				pSkip(32);
			}
		} else {
			ErrorManager.error(39);
			pSkip(39);
		}
		return;
	}

	/**
	 * 主函数分析方法
	 */
	public static void mainF() {
		InfoPane.write("mainF() is called!" + '\n');
		// 已经跳转过需要回填主函数地址
		if (hasJumped) {
			CodeGen.reset(tmpPx, ConstSet.JMP_INSTR, 0, CodeGen.px);
		}
		CodeGen.gen(ConstSet.INT_INSTR, 0, 3);
		CodeGen.gen(ConstSet.STC_INSTR, 0, 0);
		int tmpVal = CodeGen.px;
		CodeGen.gen(ConstSet.CAL_INSTR, 0, tmpVal + 1);
		symType = Lexer.getSym();
		symType = Lexer.getSym();
		paraCount = nrFuncInsert("main", CodeGen.px);
		if (symType == ConstSet.LEFT_PRENTHESES) {

			symType = Lexer.getSym();
			if (symType == ConstSet.RIGHT_PRENTHESES) {
				dx = 3;
				symType = Lexer.getSym();
				if (symType == ConstSet.LEFT_CURLY) {
					crtLevel++;
					symType = Lexer.getSym();
					value = Lexer.getValue();
					cmpdStmt();
					if (!hasNVReturned) {
						ErrorManager.warning(1);
						CodeGen.gen(ConstSet.RET_INSTR, 0, 0);
					} else if (hasValReturned) {
						ErrorManager.error(57);
						pSkip(57);
						hasValReturned = false;
					}
					if (symType == ConstSet.RIGHT_CURLY) {
						fQuit();
						CodeGen.reset(CodeGen.px - 1, ConstSet.HLT_INSTR, 0, 0);
						crtLevel--;
						return;
					}
				} else {
					ErrorManager.error(16);
					pSkip(16);
					if (symType == ConstSet.RESERVED_WORD
							|| symType == ConstSet.TYPE_IDEN) {
						symType = Lexer.getSym();
						cmpdStmt();
					} else {
						// read till EOF
					}
				}
			} else {
				ErrorManager.error(17);
				pSkip(17);
			}
		} else {
			ErrorManager.error(18);
			pSkip(18);
		}
		return;
	}

	/**
	 * 常量定义分析方法
	 */
	public static void cnstDef() {
		InfoPane.write("cnstDef() is called!" + '\n');
		// 整型常量
		if (value.equals("int")) {
			symType = Lexer.getSym();
			if (symType == ConstSet.IDENTIFIER) {
				value = Lexer.getValue();
				nameBuf = value;
				symType = Lexer.getSym();
				if (symType == ConstSet.EVALUATE) {
					symType = Lexer.getSym();
					// 类型检查正确
					if (symType == ConstSet.INTEGER) {
						value = Lexer.getValue();
						symType = Lexer.getSym();
						constInsert(nameBuf, "int", value);

						// 下一个整形常量
						while (symType == ConstSet.COMMA) {
							symType = Lexer.getSym();
							if (symType == ConstSet.IDENTIFIER) {
								nameBuf = Lexer.getValue();
								symType = Lexer.getSym();
								if (symType == ConstSet.EVALUATE) {
									symType = Lexer.getSym();
									// 类型检查正确
									if (symType == ConstSet.INTEGER) {
										value = Lexer.getValue();
										constInsert(nameBuf, "int", value);
										symType = Lexer.getSym();
									} else if (symType == ConstSet.CHARACTER
											|| symType == ConstSet.REAL) {
										ErrorManager.error(50);
										pSkip(50);
									} else {
										ErrorManager.error(34);
										pSkip(34);
									}