parsea.java

编译原理实验

			/* 指定新语法树节点t成员:源代码行号lineno为全局变量lineno */
			t.lineno = lineno;

			t.idnum = 0;

			for (i = 0; i < 10; i++) {
				t.name[i] = "\0";
				t.table[i] = null;
			}
		}
		/* 函数返回语句类型语法树节点指针t */
		return t;
	}

	// /
	// 函数名 newExpNode /
	// 功 能 表达式类型语法树节点创建函数 /
	// 说 明 该函数为语法树创建一个新的表达式类型结点 /
	// 并将语法树节点的成员初始化 /
	// /
	private TreeNode newExpNode(ExpKind kind)

	{
		// 内存中动态申请分配单元，返回指向该单元的语法树节点类型指针t /
		TreeNode t = new TreeNode();

		int i;

		// 语法树节点指针t为null,未能成功分配内存单元
		// 将出错信息及行号lineno写入列表文件listing /
		if (t == null) {
			error.add(new Error(lineno, "out of memory"));
			isError = true;
		}
		// 语法树节点指针t不是null,内存单元已经成功分配 /
		else {

			// 初始化新语法树节点t各子节点child[i]为null /
			for (i = 0; i < 2; i++)
				t.child[i] = null;

			// 初始化新语法树节点t兄弟节点sibling为null(空) /
			t.sibling = null;

			// 指定新语法树节点t成员: 结点类型nodekind为表达式类型ExpK /
			t.nodekind = NodeKind.ExpK;

			// 指定新语法树节点t成员: 表达式类型kind.exp为函数给定参数kind /
			t.kind.exp = kind;

			// 指定新语法树节点t成员: 源代码行号lineno为全局变量lineno /
			t.lineno = lineno;

			// 指定新语法树节点t成员: 表达式为变量类型时的变量类型varkind
			// 为IdV. /
			t.attr.expAttr.varkind = VarKind.IdV;

			// 指定新语法树节点t成员: 类型检查类型type为Void /
			t.attr.expAttr.type = ExpType.Void;

			for (i = 0; i < 10; i++) {
				t.name[i] = "\0";
				t.table[i] = null;
			}
		}

		// 函数返回表达式类型语法树结点指针t /
		return t;
	}

	// /
	// 函数名 ReadNextToken /
	// 功 能 将文件tokenlist中的信息作为返回值 /
	// 一般，listing指向标准输出。 /
	// 说 明 返回值为TokenType类型，用于语法分析中 /
	// /
	void ReadNextToken() {
		if (tokenList.hasNext()) {
			token = tokenList.next();
			lineno = token.lineShow;
		} else
			token = null;
	}

	// /
	// 函数名 printTab /
	// 功 能 打印空格 /
	// 说 明 在输出文件中打印个数为参数tabnum的空格 /
	// /
	void printTab(int tabnum) {
		for (int i = 0; i < tabnum; i++)
			Translate.parseArea.append(" ");
	}

	// /
	// 函数名 printSpaces /
	// 功 能 空格打印函数 /
	// 说 明 该函数打印指定数量空格,用于表示子树缩进 /
	// /
	void printSpaces()

	{
		int i;

		// 按给定缩进量indentno+=4no打印空格进行缩进
		// 其中缩进量indentno+=4no总能保持非负 /
		for (i = 0; i < indentno; i++)
			Translate.parseArea.append(" ");

	}

	// /
	// 函数名 printTree /
	// 功 能 把语法树输出，显示在listing文件中 /
	// 说 明 该函数运用了宏来定义增量减量的缩进 /
	// /
	void printTree(TreeNode tree) {
		int i;

		// 增量缩进宏,每次进入语法树节点都进行增量缩进 /
		indentno += 4;

		// 函数参数给定语法树节点指针tree非null(空) /
		while (tree != null) {
			// 打印行号 /
			if (tree.lineno == 0)
				printTab(9);
			else
				switch ((int) (tree.lineno / 10)) {
				case 0:
					Translate.parseArea.append("line:" + tree.lineno);
					printTab(3);
					break;
				case 1:
				case 2:
				case 3:
				case 4:
				case 5:
				case 6:
				case 7:
				case 8:
				case 9:
					Translate.parseArea.append("line:" + tree.lineno);
					printTab(2);
					break;
				default:
					Translate.parseArea.append("line:" + tree.lineno);
					printTab(1);
				}

			// 调用函数printSpaces,打印相应的空格,进行缩进 /
			printSpaces();

			switch (tree.nodekind) {
			case ProK:
				Translate.parseArea.append("  " + "Prok");
				break;
			case PheadK: {
				Translate.parseArea.append("  " + "PheadK");
				Translate.parseArea.append("  " + tree.name[0]);
			}
				break;
			case DecK: {
				Translate.parseArea.append("  " + "DecK");
				if (tree.attr.procAttr.paramt == ParamType.varparamType)
					Translate.parseArea.append("  " + "var param:");
				if (tree.attr.procAttr.paramt == ParamType.valparamType)
					Translate.parseArea.append("  " + "value param:");
				switch (tree.kind.dec) {
				case ArrayK: {
					Translate.parseArea.append("  " + "ArrayK");
					Translate.parseArea.append("  " + tree.attr.arrayAttr.up);
					Translate.parseArea.append("  " + tree.attr.arrayAttr.low);
					if (tree.attr.arrayAttr.childtype == DecKind.CharK)
						Translate.parseArea.append("  " + "Chark");
					else if (tree.attr.arrayAttr.childtype == DecKind.IntegerK)
						Translate.parseArea.append("  " + "IntegerK");
				}
					;
					break;
				case CharK:
					Translate.parseArea.append("  " + "CharK");
					break;
				case IntegerK:
					Translate.parseArea.append("  " + "IntegerK");
					break;
				case RecordK:
					Translate.parseArea.append("  " + "RecordK");
					break;
				case IdK:
					Translate.parseArea.append("  " + "IdK");
					Translate.parseArea.append("  " + tree.attr.type_name);
					break;
				default:
					Translate.parseArea.append("isError1!");
					isError = true;
				}
				;
				if (tree.idnum >= 0)
					for (i = 0; i <= (tree.idnum); i++) {
						Translate.parseArea.append("  " + tree.name[i]);

					}
				else {
					Translate.parseArea.append("wrong!no var!\n");
					isError = true;
				}
			}
				break;
			case TypeK:
				Translate.parseArea.append("  " + "TypeK");
				break;

			case VarK:
				Translate.parseArea.append("  " + "VarK");
				// if(tree.table[0]!=null)
				// Translate.parseArea.append("
				// "+tree.table[0].attrIR.More.VarAttr.off,tree.table[0].attrIR.More.VarAttr.level);
				break;

			case ProcDecK:
				Translate.parseArea.append("  " + "ProcDecK");
				Translate.parseArea.append("  " + tree.name[0]);
				// if(tree.table[0]!=null)
				// Translate.parseArea.append("
				// "+tree.table[0].attrIR.More.ProcAttr.mOff,tree.table[0].attrIR.More.ProcAttr.nOff,tree.table[0].attrIR.More.ProcAttr.level);
				break;

			case StmLK:
				Translate.parseArea.append("  " + "StmLk");
				break;

			case StmtK: {
				Translate.parseArea.append("  " + "StmtK");
				switch (tree.kind.stmt) {
				case IfK:
					Translate.parseArea.append("  " + "If");
					break;
				case WhileK:
					Translate.parseArea.append("  " + "While");
					break;

				case AssignK:
					Translate.parseArea.append("  " + "Assign");
					break;

				case ReadK:
					Translate.parseArea.append("  " + "Read");
					Translate.parseArea.append("  " + tree.name[0]);
					// if(tree.table[0]!=null)
					// Translate.parseArea.append( "
					// "+tree.table[0].attrIR.More.VarAttr.off,tree.table[0].attrIR.More.VarAttr.level);
					break;

				case WriteK:
					Translate.parseArea.append("  " + "Write");
					break;

				case CallK:
					Translate.parseArea.append("  " + "Call");
					Translate.parseArea.append("  " + tree.name[0]);
					break;

				case ReturnK:
					Translate.parseArea.append("  " + "Return");
					break;

				default:
					Translate.parseArea.append("isError2!");
					isError = true;
				}
			}
				;
				break;
			case ExpK: {
				Translate.parseArea.append("  " + "ExpK");
				switch (tree.kind.exp) {
				case OpK: {
					Translate.parseArea.append("  " + "Op");
					switch (tree.attr.expAttr.op) {
					case EQ:
						Translate.parseArea.append("  " + "=");
						break;
					case LT:
						Translate.parseArea.append("  " + "<");
						break;
					case PLUS:
						Translate.parseArea.append("  " + "+");
						break;
					case MINUS:
						Translate.parseArea.append("  " + "-");
						break;
					case TIMES:
						Translate.parseArea.append("  " + " ");
						break;
					case OVER:
						Translate.parseArea.append("  " + "/");
						break;
					default:
						Translate.parseArea.append("isError3!");
						isError = true;
					}

					if (tree.attr.expAttr.varkind == VarKind.ArrayMembV) {
						Translate.parseArea.append("  ArrayMember  ");
						Translate.parseArea.append("  " + tree.name[0]);
					}
				}
					;
					break;
				case ConstK:
					Translate.parseArea.append("  " + "Const");
					switch (tree.attr.expAttr.varkind) {
					case IdV:
						Translate.parseArea.append("  Id  ");
						Translate.parseArea.append("  " + tree.name[0]);
						break;
					case FieldMembV:
						Translate.parseArea.append("  FieldMember  ");
						Translate.parseArea.append("  " + tree.name[0]);
						break;
					case ArrayMembV:
						Translate.parseArea.append("  ArrayMember  ");
						Translate.parseArea.append("  " + tree.name[0]);
						break;
					default:
						Translate.parseArea.append("var type isError!");
						isError = true;
					}

					Translate.parseArea.append("  " + tree.attr.expAttr.val);
					break;
				case VariK:
					Translate.parseArea.append("  " + "Vari");
					switch (tree.attr.expAttr.varkind) {
					case IdV:
						Translate.parseArea.append("  Id  ");
						Translate.parseArea.append("  " + tree.name[0]);
						break;
					case FieldMembV:
						Translate.parseArea.append("  FieldMember  ");
						Translate.parseArea.append("  " + tree.name[0]);
						break;
					case ArrayMembV:
						Translate.parseArea.append("  ArrayMember  ");
						Translate.parseArea.append("  " + tree.name[0]);
						break;
					default:
						Translate.parseArea.append("var type isError!");
						isError = true;
					}
					// if(tree.table[0]!=null)
					// Translate.parseArea.append("
					// "+tree.table[0].attrIR.More.VarAttr.off,tree.table[0].attrIR.More.VarAttr.level);

					break;
				default:
					Translate.parseArea.append("isError4!");
					isError = true;
				}
			}
				;
				break;
			default:
				Translate.parseArea.append("isError5!");
				isError = true;
			}

			Translate.parseArea.append("\n");

			// 对语法树结点tree的各子结点递归调用printTree过程
			// 缩进写入列表文件listing /
			for (i = 0; i < 3; i++)
				printTree(tree.child[i]);

			// 对语法树结点tree的兄弟节点递归调用printTree过程
			// 缩进写入列表文件listing /
			tree = tree.sibling;
		}

		// 减量缩进宏,每次退出语法树节点时减量缩进 /
		indentno -= 4;

	}

	// /
	// 文件 parse.c /
	// 说明 递归下降的语法分析程序 /
	// 主题 TINY编译器的语法分析器实现 /
	// /

	// 语法分析功能函数 /

	// /
	// 函数名 syntaxisError /
	// 功 能 语法错误处理函数 /
	// 说 明 将函数参数message指定的错误信息格式化写入列表文件listing /
	// 设置错误追踪标志isError为true /
	// /
	void syntaxisError(String message)

	{
		error.add(new Error(token.lineShow, "Syntax isError  :" + message));
		isError = true;

	}

	// /
	// 函数名 match /
	// 功 能 终极符匹配处理函数 /
	// 说 明 函数参数expected给定期望单词符号与当前单词符号token相匹配 /
	// 如果不匹配,则报非期望单词语法错误 /
	// /
	void match(LexType expected) {
		if (token.lex == expected) {
			ReadNextToken();
			if (token != null)
				lineno = token.lineShow;
		} else {
			syntaxisError("not match Error:" + "    " + token.sem);
			ReadNextToken();

			// 问题：遇到错误，要终止程序的执行，应该怎么做？？？？？？
			// exit(0);
		}

	}

	// /
	// 函数名 program /
	// 功 能 总程序的处理函数 /
	// 产生式 < program > ::= programHead declarePart programBody . /
	// 说 明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点 /
	// 语法树的根节点的第一个子节点指向程序头部分programHead, /
	// DeclaraPart为programHead的兄弟节点,程序体部分programBody /
	// 为declarePart的兄弟节点. /
	// /
	private TreeNode program() {
		TreeNode t = programHead();
		TreeNode q = declarePart();
		TreeNode s = programBody();

		TreeNode root = newRootNode();
		if (root != null) {
			root.lineno = 0;
			if (t != null)
				root.child[0] = t;
			else
				syntaxisError("a program head is expected!");
			if (q != null)
				root.child[1] = q;
			if (s != null)
				root.child[2] = s;
			else
				syntaxisError("a program body is expected!");
		}
		match(LexType.DOT);

		return root;
	}

	// /
	// 函数名 programHead /
	// 功 能 程序头的处理函数 /
	// 产生式 < programHead > ::= PROGRAM ProgramName /
	// 说 明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点 /
	// /
	private TreeNode programHead() {
		TreeNode t = newPheadNode();
		match(LexType.PROGRAM);