parser.java

一个C语言子集的编译器

								} else {
									ErrorManager.error(35);
									pSkip(35);
								}
							} else {
								ErrorManager.error(26);
								pSkip(26);
							}
						}
					} else if (symType == ConstSet.CHARACTER
							|| symType == ConstSet.REAL) {
						ErrorManager.error(50);
						pSkip(50);
					} else {
						ErrorManager.error(34);
						pSkip(34);
					}
				} else {
					ErrorManager.error(35);
					pSkip(35);
				}
			} else {
				ErrorManager.error(20);
				if (symType != ConstSet.SEMICOLON)
					symType = Lexer.getSym();
			}
		} else if (value.equals("float")) {
			symType = Lexer.getSym();
			if (symType == ConstSet.IDENTIFIER) {
				nameBuf = Lexer.getValue();
				symType = Lexer.getSym();
				if (symType == ConstSet.EVALUATE) {
					symType = Lexer.getSym();
					if (symType == ConstSet.REAL) {
						value = Lexer.getValue();
						constInsert(nameBuf, "float", value);
						symType = Lexer.getSym();
						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.REAL) {
										value = Lexer.getValue();
										constInsert(nameBuf, "float", value);
										symType = Lexer.getSym();
									} else if (symType == ConstSet.CHARACTER
											|| symType == ConstSet.INTEGER) {
										ErrorManager.error(50);
										pSkip(50);
									} else {
										ErrorManager.error(34);
										pSkip(34);
									}
								} else {
									ErrorManager.error(35);
									pSkip(35);
								}
							} else {
								ErrorManager.error(26);
								pSkip(26);
							}
						}
					} else if (symType == ConstSet.CHARACTER
							|| symType == ConstSet.INTEGER) {
						ErrorManager.error(50);
						pSkip(50);
					} else {
						ErrorManager.error(34);
						pSkip(34);
					}
				} else {
					ErrorManager.error(35);
					pSkip(35);
				}
			} else {
				ErrorManager.error(20);
				if (symType != ConstSet.SEMICOLON)
					symType = Lexer.getSym();
			}
		} else {
			symType = Lexer.getSym();
			if (symType == ConstSet.IDENTIFIER) {
				nameBuf = Lexer.getValue();
				symType = Lexer.getSym();
				if (symType == ConstSet.EVALUATE) {
					symType = Lexer.getSym();
					if (symType == ConstSet.CHARACTER) {
						value = Lexer.getValue();
						constInsert(nameBuf, "char", value);
						symType = Lexer.getSym();
						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.CHARACTER) {
										value = Lexer.getValue();
										constInsert(nameBuf, "char", value);
										symType = Lexer.getSym();
									} else if (symType == ConstSet.REAL
											|| symType == ConstSet.INTEGER) {
										ErrorManager.error(50);
										pSkip(50);
									} else {
										ErrorManager.error(34);
										pSkip(34);
									}
								} else {
									ErrorManager.error(35);
									pSkip(35);
								}
							} else {
								ErrorManager.error(26);
								pSkip(26);
							}
						}
					} else if (symType == ConstSet.REAL
							|| symType == ConstSet.INTEGER) {
						ErrorManager.error(50);
						pSkip(50);
					} else {
						ErrorManager.error(34);
						pSkip(34);
					}
				} else {
					ErrorManager.error(35);
					pSkip(35);
				}
			} else {
				ErrorManager.error(20);
				if (symType != ConstSet.SEMICOLON)
					symType = Lexer.getSym();
			}
		}
		return;
	}

	/**
	 * 变量定义分析方法
	 * 
	 * @param idenTp
	 *            变量类型或函数返回类型
	 * @param add
	 *            参数目标地址
	 * @return 如果是变量定义，返回ConstSet.VARDECRETURN；否则返回ConstSet.RFDECRETURN
	 */
	public static int varDef(String idenTp, int add) {
		InfoPane.write("varDef(String idenTp, int add) is called!" + '\n');
		do {
			symType = Lexer.getSym();
			value = Lexer.getValue();
			if (symType == ConstSet.IDENTIFIER) {
				nameBuf = value;
				symType = Lexer.getSym();
				// 如果是'('，退出变量定义
				if (symType == ConstSet.LEFT_PRENTHESES) {
					CodeGen.gen(ConstSet.INT_INSTR, 0, add);
					Lexer.ungetSym(ConstSet.LEFT_PRENTHESES, "(");
					Lexer.ungetSym(ConstSet.IDENTIFIER, nameBuf);
					rFDec(idenTp);
					return ConstSet.RFDECRETURN;
				} else {
					varInsert(nameBuf, idenTp, dx++);
					varCount++;
				}
			} else {
				ErrorManager.error(26);
				pSkip(26);
			}

		} while (symType == ConstSet.COMMA);

		return ConstSet.VARDECRETURN;
	}

	/**
	 * 声明头部分析方法
	 * 
	 * @param idenTp
	 *            函数返回类型
	 * @param add
	 *            函数目标地址
	 */
	public static void smtHead(String idenTp, int add) {
		InfoPane.write("smtHead(String idenTp, int add) is called!" + '\n');
		symType = Lexer.getSym();
		if (symType == ConstSet.IDENTIFIER) {
			nameBuf = Lexer.getValue();
			{
				paraCount = rFuncInsert(nameBuf, idenTp, add);
			}
			symType = Lexer.getSym();
		} else {
			ErrorManager.error(26);
			pSkip(26);
		}
		value = Lexer.getValue();
		return;
	}

	/**
	 * 参数表分析方法
	 * 
	 * @return 声明参数个数
	 */
	public static int paraLst() {
		InfoPane.write("paraLst() is called!" + '\n');
		int paraCount = 0;

		if (symType == ConstSet.TYPE_IDEN) {
			idenType = Lexer.getValue();
			symType = Lexer.getSym();
			if (symType == ConstSet.IDENTIFIER) {
				nameBuf = Lexer.getValue();
				{
					paraInsert(nameBuf, idenType, 3 + paraCount++);

				}
				symType = Lexer.getSym();
				while (symType == ConstSet.COMMA) {
					symType = Lexer.getSym();
					if (symType == ConstSet.TYPE_IDEN) {
						idenType = Lexer.getValue();
						symType = Lexer.getSym();
						if (symType == ConstSet.IDENTIFIER) {
							nameBuf = Lexer.getValue();
							{
								paraInsert(nameBuf, idenType, 3 + paraCount++);

							}
							symType = Lexer.getSym();
						} else {
							ErrorManager.error(26);
							pSkip(26);
						}
					} else {
						ErrorManager.error(30);
						pSkip(30);
					}
				}
			} else {
				ErrorManager.error(26);
				pSkip(26);
			}
		} else {
			dx = 3;
			return 0;
		}
		dx = paraCount + 3;
		return paraCount;
	}

	/**
	 * 语句列分析方法
	 */
	public static void cmpdStmt() {
		InfoPane.write("cmpdStmt() is called!" + '\n');
		value = Lexer.getValue();
		if (value.equals("const")) {
			cnstDec();
		}
		if (symType == ConstSet.TYPE_IDEN) {
			idenType = Lexer.getValue();
			varDec(idenType);
		}
		do {
			stnc();
			value = Lexer.getValue();
		} while (value.equals("if") || value.equals("while")
				|| value.equals("scanf") || value.equals("printf")
				|| value.equals("switch") || value.equals("return")
				|| symType == ConstSet.IDENTIFIER
				|| symType == ConstSet.LEFT_CURLY
				|| symType == ConstSet.SEMICOLON);

		return;
	}

	/**
	 * 语句分析方法
	 */
	public static void stnc() {
		InfoPane.write("stnc() is called!" + '\n');
		if (symType == ConstSet.RESERVED_WORD) {
			value = Lexer.getValue();
			if (value.equals("if")) {
				cndStnc();
			} else if (value.equals("while")) {
				loopStnc();
			} else if (value.equals("scanf")) {
				readStnc();
				if (symType == ConstSet.SEMICOLON) {
					symType = Lexer.getSym();
				} else {
					ErrorManager.error(19);
					pSkip(19);
				}
			} else if (value.equals("printf")) {
				wrtStnc();
				if (symType == ConstSet.SEMICOLON) {
					symType = Lexer.getSym();
				} else {
					ErrorManager.error(19);
					pSkip(19);
				}
			} else if (value.equals("switch")) {
				csStnc();
			} else if (value.equals("return")) {
				rtStnc();
				if (symType == ConstSet.SEMICOLON) {
					symType = Lexer.getSym();
				} else {
					ErrorManager.error(19);
					pSkip(19);
				}
			} else {
				ErrorManager.error(29);
				pSkip(29);
			}
		} else if (symType == ConstSet.IDENTIFIER) {
			value = Lexer.getValue();
			symType = Lexer.getSym();
			// 赋值语句
			if (symType == ConstSet.EVALUATE) {
				Lexer.ungetSym(ConstSet.EVALUATE, "=");
				symType = ConstSet.IDENTIFIER;
				evlStnc();
			}
			// 有返回值函数调用语句
			else {
				String temp = value;
				value = Lexer.getValue();
				Lexer.ungetSym(symType, value);
				symType = ConstSet.IDENTIFIER;
				value = temp;
				int tmp = SymTable.searchFunc(value);
				if (tmp == ConstSet.RFRETURN) {
					rFcStnc();
				} else if (tmp == ConstSet.NRFRETURN) {
					nrFcStnc();
				}
				// 没有找到
				else {
					ErrorManager.error(8);
					pSkip(8);
				}

			}
			if (symType == ConstSet.SEMICOLON) {
				symType = Lexer.getSym();
			} else {
				ErrorManager.error(19);
				pSkip(19);
			}

		} else if (symType == ConstSet.LEFT_CURLY) {

			symType = Lexer.getSym();
			do {
				stnc();
				value = Lexer.getValue();
			} while (value.equals("if") || value.equals("while")
					|| value.equals("scanf") || value.equals("printf")
					|| value.equals("switch") || value.equals("return")
					|| symType == ConstSet.IDENTIFIER
					|| symType == ConstSet.LEFT_CURLY
					|| symType == ConstSet.SEMICOLON);
			if (symType == ConstSet.RIGHT_CURLY) {

				symType = Lexer.getSym();
			} else {
				ErrorManager.error(33);
				pSkip(33);
			}
		} else if (symType == ConstSet.SEMICOLON) {
			symType = Lexer.getSym();
		} else {
			return;
		}
		return;
	}

	/**
	 * 条件语句分析方法
	 */
	public static void cndStnc() {
		InfoPane.write("cndStnc() is called!" + '\n');
		symType = Lexer.getSym();
		if (symType == ConstSet.LEFT_PRENTHESES) {
			symType = Lexer.getSym();
		} else {
			ErrorManager.error(40);
			pSkip(40);
		}
		cndit();
		int tmp = CodeGen.px;
		CodeGen.gen(ConstSet.JPC_INSTR, 0, 0);
		if (symType == ConstSet.RIGHT_PRENTHESES) {
			symType = Lexer.getSym();
			stnc();
			CodeGen.reset(tmp, ConstSet.JPC_INSTR, 0, CodeGen.px);// 回填，栈顶是零就跳转
			value = Lexer.getValue();
			if (value.equals("else")) {
				CodeGen.reset(tmp, ConstSet.JPC_INSTR, 0, CodeGen.px + 1);// 回填，栈顶是零就跳转
				tmp = CodeGen.px;
				CodeGen.gen(ConstSet.JMP_INSTR, 0, 0);
				symType = Lexer.getSym();
				stnc();
				CodeGen.reset(tmp, ConstSet.JMP_INSTR, 0, CodeGen.px);// 回填
			}
			return;
		} else {
			ErrorManager.error(41);
			pSkip(41);
		}
		return;
	}

	/**
	 * 条件分析方法
	 */
	public static void cndit() {
		InfoPane.write("cndit() is called!" + '\n');
		int tp1 = exprs();
		String tmpVal;
		if (symType == ConstSet.RELA_OPR) {
			tmpVal = Lexer.getValue();
			symType = Lexer.getSym();
		} else {
			return;
		}
		int tp2 = exprs();
		// 先判断做减法的类型
		if (tp1 > ConstSet.REAL && tp2 > ConstSet.REAL)
			CodeGen.gen(ConstSet.OPR_INSTR, 0, ConstSet.OPR_INTSUB);
		else
			CodeGen.gen(ConstSet.OPR_INSTR, 0, ConstSet.OPR_FLTSUB);

		// 对栈顶进行判断
		if (tmpVal.equals("<")) {
			CodeGen.gen(ConstSet.OPR_INSTR, 0, ConstSet.OPR_LESS);// 栈顶>0,=0为假
			// >0为真
		} else if (tmpVal.equals("<=")) {
			CodeGen.gen(ConstSet.OPR_INSTR, 0, ConstSet.OPR_NGREAT);// 栈顶>0为假
			// >0,=0为真
		} else if (tmpVal.equals("==")) {
			CodeGen.gen(ConstSet.OPR_INSTR, 0, ConstSet.OPR_EAQ);// 栈顶<0,>0为假
			// =0为真
		} else if (tmpVal.equals(">")) {
			CodeGen.gen(ConstSet.OPR_INSTR, 0, ConstSet.OPR_GREAT);// 栈顶<0,=0为假
			// <0为真