parsea.java

编译原理实验

	// 产生式 < inputStm > ::= READ(id) /
	// 说 明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点 /
	// /
	private TreeNode inputStm() {
		TreeNode t = newStmtNode(StmtKind.ReadK);
		match(LexType.READ);
		match(LexType.LPAREN);
		if ((t != null && token.lex == LexType.ID)) {
			t.lineno = lineno;
			t.name[0] = token.sem;
			(t.idnum)++;
		}
		match(LexType.ID);
		match(LexType.RPAREN);
		return t;
	}

	// /
	// 函数名 outputStm /
	// 功 能 输出语句部分的处理函数 /
	// 产生式 < outputStm > ::= WRITE(exp) /
	// 说 明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点 /
	// /
	private TreeNode outputStm() {
		TreeNode t = newStmtNode(StmtKind.WriteK);
		match(LexType.WRITE);
		match(LexType.LPAREN);
		if (t != null) {
			t.lineno = lineno;
			t.child[0] = exp();
		}
		match(LexType.RPAREN);
		return t;
	}

	// /
	// 函数名 returnStm /
	// 功 能 返回语句部分的处理函数 /
	// 产生式 < returnStm > ::= RETURN /
	// 说 明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点 /
	// /
	private TreeNode returnStm() {
		TreeNode t = newStmtNode(StmtKind.ReturnK);
		match(LexType.RETURN);
		if (t != null)
			t.lineno = lineno;
		return t;
	}

	// /
	// 函数名 callStmRest /
	// 功 能 函数调用语句部分的处理函数 /
	// 产生式 < callStmRest > ::= (actParamList) /
	// 说 明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点 /
	// /
	private TreeNode callStmRest() {
		TreeNode t = newStmtNode(StmtKind.CallK);
		match(LexType.LPAREN);
		// 函数调用时，其子节点指向实参 /
		if (t != null) {
			t.lineno = lineno;

			// 函数名的结点也用表达式类型结点 /
			TreeNode child0 = newExpNode(ExpKind.VariK);
			if (child0 != null) {
				child0.lineno = lineno;
				child0.name[0] = temp_name;
				(child0.idnum)++;
				t.child[0] = child0;
			}
			t.child[1] = actParamList();
		}
		match(LexType.RPAREN);
		return t;
	}

	// /
	// 函数名 actParamList /
	// 功 能 函数调用实参部分的处理函数 /
	// 产生式 < actParamList > ::= ε | exp actParamMore /
	// 说 明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点 /
	// /
	private TreeNode actParamList() {
		TreeNode t = null;

		switch (token.lex) {
		case RPAREN:
			break;
		case ID:
		case INTC:
			t = exp();
			if (t != null)
				t.sibling = actParamMore();
			break;
		default:
			ReadNextToken();
			syntaxisError("unexpected token is here!");
			break;
		}
		return t;
	}

	// /
	// 函数名 actParamMore /
	// 功 能 函数调用实参部分的处理函数 /
	// 产生式 < actParamMore > ::= ε | , actParamList /
	// 说 明 函数根据文法产生式,调用相应的递归处理函数,生成语法树节点 /
	// /
	private TreeNode actParamMore() {
		TreeNode t = null;
		switch (token.lex) {
		case RPAREN:
			break;
		case COMMA:
			match(LexType.COMMA);
			t = actParamList();
			break;
		default:
			ReadNextToken();
			syntaxisError("unexpected token is here!");
			break;
		}
		return t;
	}

	// 表达式部分 /
	// /
	// 函数名 exp /
	// 功 能 表达式处理函数 /
	// 产生式 < 表达式 > ::= < 简单表达式 > [< 关系运算符 > < 简单表达式 > ] /
	// 说 明 该函数根据产生式调用相应递归处理函数,生成表达式类型语法树节点 /
	// /
	private TreeNode exp()

	{
		// 调用简单表达式处理函数simple_exp(),返回语法树节点指针给t /
		TreeNode t = simple_exp();

		// 当前单词token为逻辑运算单词LT或者EQ /
		if ((token.lex == LexType.LT) || (token.lex == LexType.EQ)) {
			// 创建新的OpK类型语法树节点，新语法树节点指针赋给p /
			TreeNode p = newExpNode(ExpKind.OpK);

			// 新语法树节点p创建成功,初始化p第一个子节点成员child[0]
			// 并将当前单词token(为EQ或者LT)赋给语法树节点p的运算符成员attr.op /
			if (p != null) {
				p.lineno = lineno;
				p.child[0] = t;
				p.attr.expAttr.op = token.lex;

				// 将新的表达式类型语法树节点p作为函数返回值t /
				t = p;
			}

			// 当前单词token与指定逻辑运算符单词(为EQ或者LT)匹配 /
			match(token.lex);

			// 语法树节点t非空,调用简单表达式处理函数simple_exp()
			// 函数返回语法树节点指针给t的第二子节点成员child[1] /
			if (t != null)
				t.child[1] = simple_exp();
		}

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

	// /
	// 函数名 simple_exp /
	// 功 能 简单表达式处理函数 /
	// 产生式 < 简单表达式 >::= < 项 > { < 加法运算符 > < 项 > } /
	// 说 明 该函数根据产生式调用相应递归处理函数,生成表达式类型语法树节点 /
	// /
	private TreeNode simple_exp()

	{
		// 调用元处理函数term(),函数返回语法树节点指针给t /
		TreeNode t = term();

		// 当前单词token为加法运算符单词PLUS或MINUS /
		while ((token.lex == LexType.PLUS) || (token.lex == LexType.MINUS))

		{
			// 创建新OpK表达式类型语法树节点，新语法树节点指针赋给p /
			TreeNode p = newExpNode(ExpKind.OpK);

			// 语法树节点p创建成功,初始化p第一子节点成员child[0]
			// 返回语法树节点指针给p的运算符成员attr.op /
			if (p != null) {
				p.lineno = lineno;
				p.child[0] = t;
				p.attr.expAttr.op = token.lex;

				// 将函数返回值t赋成语法树节点p /
				t = p;

				// 当前单词token与指定加法运算单词(为PLUS或MINUS)匹配 /
				match(token.lex);

				// 调用元处理函数term(),函数返回语法树节点指针给t的第二子节点成员child[1] /
				t.child[1] = term();
			}
		}
		// 函数返回表达式类型语法树节点t /
		return t;
	}

	// /
	// 函数名 term /
	// 功 能 项处理函数 /
	// 产生式 < 项 > ::= < 因子 > { < 乘法运算符 > < 因子 > } /
	// 说 明 该函数根据产生式调用相应递归处理函数,生成表达式类型语法树节点 /
	// /
	private TreeNode term()

	{
		// 调用因子处理函数factor(),函数返回语法树节点指针给t /
		TreeNode t = factor();

		// 当前单词token为乘法运算符单词TIMES或OVER /
		while ((token.lex == LexType.TIMES) || (token.lex == LexType.OVER))

		{
			// 创建新的OpK表达式类型语法树节点,新节点指针赋给p /
			TreeNode p = newExpNode(ExpKind.OpK);

			// 新语法树节点p创建成功,初始化第一个子节点成员child[0]为t
			// 将当前单词token赋值给语法树节点p的运算符成员attr.op /
			if (p != null) {
				p.lineno = lineno;
				p.child[0] = t;
				p.attr.expAttr.op = token.lex;
				t = p;
			}

			// 当前单词token与指定乘法运算符单词(为TIMES或OVER)匹配 /
			match(token.lex);

			// 调用因子处理函数factor(),函数返回语法树节点指针赋给p第二个子节点成员child[1] /
			p.child[1] = factor();

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

	// /
	// 函数名 factor /
	// 功 能 因子处理函数 /
	// 产生式 factor ::= ( exp ) | INTC | variable /
	// 说 明 该函数根据产生式调用相应的递归处理函数,生成表达式类型语法树节点 /
	// /
	private TreeNode factor()

	{
		// 函数返回语法树节点指针t初始为为null /
		TreeNode t = null;

		switch (token.lex) {
		case INTC:

			// 创建新的ConstK表达式类型语法树节点,赋值给t /
			t = newExpNode(ExpKind.ConstK);

			// 新语法树节点t创建成功,当前单词token为数字单词NUM
			// 将当前单词名tokenString转换为整数并赋给语法树节点t的数值成员attr.val /
			if ((t != null && token.lex == LexType.INTC)) {
				t.lineno = lineno;
				t.attr.expAttr.val = Integer.parseInt(token.sem);
			}

			// 当前单词token与数字单词NUM匹配 /
			match(LexType.INTC);
			break;

		// 当前单词token为标识符单词ID /
		case ID:

			// 创建新的IdK表达式类型语法树节点t /
			t = variable();
			break;

		// 当前单词token为左括号单词LPAREN /
		case LPAREN:

			// 当前单词token与左括号单词LPAREN匹配 /
			match(LexType.LPAREN);

			// 调用表达式处理函数exp(),函数返回语法树节点指针给t /
			t = exp();

			// 当前单词token与右括号单词RPAREN匹配 /
			match(LexType.RPAREN);

			break;

		// 当前单词token为其它单词 /
		default:
			ReadNextToken();
			syntaxisError("unexpected token is here!");
			break;
		}
		// 函数返回表达式类型语法树节点t /
		return t;
	}

	// /
	// 函数名 variable /
	// 功 能 变量处理函数 /
	// 产生式 variable ::= id variMore /
	// 说 明 该函数根据产生式, 处理变量，生成其语法树节点 /
	// /
	private TreeNode variable() {
		TreeNode t = newExpNode(ExpKind.VariK);

		if ((t != null && token.lex == LexType.ID)) {
			t.lineno = lineno;
			t.name[0] = token.sem;
			(t.idnum)++;
		}

		match(LexType.ID);
		variMore(t);
		return t;
	}

	// /
	// 函数名 variMore /
	// 功 能 变量处理函数 /
	// 产生式 variMore ::= ε /
	// | [exp] {[} /
	// | . fieldvar {DOT} /
	// 说 明 该函数根据产生式调用相应的递归处理变量中的几种不同类型 /
	// /
	void variMore(TreeNode t) {
		switch (token.lex) {
		case ASSIGN:
		case TIMES:
		case EQ:
		case LT:
		case PLUS:
		case MINUS:
		case OVER:
		case RPAREN:
		case RMIDPAREN:
		case SEMI:
		case COMMA:
		case THEN:
		case ELSE:
		case FI:
		case DO:
		case ENDWH:
		case END:
			break;
		case LMIDPAREN:
			match(LexType.LMIDPAREN);

			// 用来以后求出其表达式的值，送入用于数组下标计算 /
			t.child[0] = exp();

			t.attr.expAttr.varkind = VarKind.ArrayMembV;

			// 此表达式为数组成员变量类型 /
			t.child[0].attr.expAttr.varkind = VarKind.IdV;
			match(LexType.RMIDPAREN);
			break;
		case DOT:
			match(LexType.DOT);
			// 第一个儿子指向域成员变量结点 /
			t.child[0] = fieldvar();

			t.attr.expAttr.varkind = VarKind.FieldMembV;

			t.child[0].attr.expAttr.varkind = VarKind.IdV;
			break;
		default:
			ReadNextToken();
			syntaxisError("unexpected token is here!");
			break;
		}
	}

	// /
	// 函数名 fieldvar /
	// 功 能 变量处理函数 /
	// 产生式 fieldvar ::= id fieldvarMore /
	// 说 明 该函数根据产生式，处理域变量，并生成其语法树节点 /
	// /
	private TreeNode fieldvar() {
		// 注意，可否将此处的IdEK改为一个新的标识，用来记录记录类型的域 /
		TreeNode t = newExpNode(ExpKind.VariK);

		if ((t != null && token.lex == LexType.ID)) {
			t.lineno = lineno;
			t.name[0] = token.sem;
			(t.idnum)++;
		}
		match(LexType.ID);

		fieldvarMore(t);

		return t;
	}

	// /
	// 函数名 fieldvarMore /
	// 功 能 变量处理函数 /
	// 产生式 fieldvarMore ::= ε /
	// | [exp] {[} /
	// 说 明 该函数根据产生式调用相应的递归处理域变量为数组类型的情况 /
	// /
	void fieldvarMore(TreeNode t) {
		switch (token.lex) {
		case ASSIGN:
		case TIMES:
		case EQ:
		case LT:
		case PLUS:
		case MINUS:
		case OVER:
		case RPAREN:
		case SEMI:
		case COMMA:
		case THEN:
		case ELSE:
		case FI:
		case DO:
		case ENDWH:
		case END:
			break;
		case LMIDPAREN:
			match(LexType.LMIDPAREN);

			// 用来以后求出其表达式的值，送入用于数组下标计算 /
			t.child[0] = exp();
			t.child[0].attr.expAttr.varkind = VarKind.ArrayMembV;
			match(LexType.RMIDPAREN);
			break;
		default:
			ReadNextToken();
			syntaxisError("unexpected token is here!");
			break;
		}
	}

	// 函数名 parse /
	// 功 能 语法分析函数 /
	// 说 明 该函数把词法分析程序作为子程序调用,采用递归下降法 /
	// 根据产生式调用递归处理函数,函数为源程序创建语法分析树 /
	// /
	private TreeNode parse()

	{
		TreeNode t = null;

		// 从文件Tokenlist中取得第一个单词,将词法信息送给token /

		ReadNextToken();

		// 当前单词token不是ENDFILE,报代码在文件结束前提前结束错误 /
		if (token.lex == LexType.ENDFILE)
			syntaxisError("Code ends before file\n");
		// 开始调用基本语法分析处理函数,递归下降处理 /
		t = program();

		// 函数返回语法树根节点t /
		return t;

	}
}