parse.h

一个简单的C语言子集的编译器,一个简单的C语言子集的编译器

#ifndef PARSE_H_
#define PARSE_H_

#include <list>
#include "global.h"
#include "scan.h"
#include "util.h"
using namespace std;

TreeNode *declar_list();
TreeNode *declar();
TreeNode *params();
TreeNode *param_list();
TreeNode *param();
TreeNode *compound_stmt();
TreeNode *local_declar();
TreeNode *stmt_list();
TreeNode *statement();
TreeNode *exp_stmt();
TreeNode *select_stmt();
TreeNode *while_stmt();
TreeNode *return_stmt();
TreeNode *exp();
TreeNode *simple_exp();
TreeNode *additive_exp();
TreeNode *term();
TreeNode *factor();
TreeNode *assign_exp();
TreeNode *call();
TreeNode *arg_list();
TreeNode *var();

void match(TokenType expected)
{
	if(Error==1) ParseError("Compile stopped",lineno);
	if(token==expected) token=GetToken();
	else {
		ParseError(GetTokenString(token)+" expected",lineno);
	}
}

TreeNode *declar_list()
{
	TreeNode *p=declar(),*q=p;
	while(token!=ENDFILE){
		q->pNext=declar();
		q=q->pNext;
	}
	return p;
}
TreeNode *declar()
{
	TreeNode *p;
	if(token==INT || token==VOID){
		p=NewNode(DECLAR);
		p->tokenT=token;
		match(token);
		p->name=TokenString;
		match(ID);
		if(token==SEMI){
			match(token);
			p->childkind.declarK=VAR_DECLAR;
		}
		else if(token==LSQUAR) {
			p->childkind.declarK=ARRAY_DECLAR;
			match(token);
			p->arraynum=atoi(TokenString.c_str());
			match(NUMBER);
			match(RSQUAR);
			match(SEMI);
		}
		else if(token==LPAREN){
			p->childkind.declarK=FUNC_DECLAR;
			match(token);
			p->pChild[0]=params();
			match(RPAREN);
			p->pChild[1]=compound_stmt();
		}
		else Error=1;
	}
	else Error=1;
	if(Error==1) ParseError("Declaration error",lineno);
	return p;
		
}
TreeNode *params()
{
	TreeNode *p;
	if(token==VOID){
		p=NULL;
		match(token);
	}
	else{
		p=param_list();
	}
	return p;
}
TreeNode *param_list()
{
	TreeNode *p=param(),*q=p;
	while(token==COMMA){
		match(COMMA);
		q->pNext=param();
		q=q->pNext;
	}
	return p;
}
TreeNode *param()
{
	TreeNode *p=NewNode(PARAM);
	if(token==INT || token==VOID)
	{
		p->tokenT=token;
		match(token);
		p->name=TokenString;
		p->childkind.declarK=VAR_DECLAR;
		match(ID);
		if(token==LSQUAR){
			p->childkind.declarK=ARRAY_DECLAR;
			p->arraynum=0;
			match(token);
			match(RSQUAR);
		}
	}
	else Error=1;
	if(Error==1) ParseError("Parameter declaration error",lineno);
	return p;
}
TreeNode *compound_stmt()
{
	TreeNode *p=NewNode(CSTMT);
	match(LBRACE);
	p->pChild[0]=local_declar();
	p->pChild[1]=stmt_list();
	match(RBRACE);
	return p;
}

TreeNode *local_declar()
{
	TreeNode *p=NULL,*q=p;
	while(token==INT || token==VOID){
		if(q==NULL) {q=NewNode(DECLAR);p=q;}
		else {q->pNext=NewNode(DECLAR);q=q->pNext;}
		q->tokenT=token;
		match(token);
		q->name=TokenString;
		match(ID);
		if(token==SEMI){
			match(token);
			q->childkind.declarK=VAR_DECLAR;
		}
		else if(token==LSQUAR) {
			q->childkind.declarK=ARRAY_DECLAR;
			match(token);
			q->arraynum=atoi(TokenString.c_str());
			match(NUMBER);
			match(RSQUAR);
			match(SEMI);
		}
		else Error=1;
		if(Error==1)
			ParseError("Local declaration error",lineno);
	}
	return p;
}
TreeNode *stmt_list()
{
	TreeNode *p=NULL,*q=p;
	while(token!=RBRACE){
		if(p==NULL) {q=statement();p=q;}
		else {q->pNext=statement();q=q->pNext;}
	}
	return p;
}
TreeNode *statement()
{
	TreeNode *p;
	switch(token)
	{
	case LBRACE:
		p=compound_stmt();
		break;
	case IF:
		p=select_stmt();
		break;
	case WHILE:
		p=while_stmt();
		break;
	case RETURN:
		p=return_stmt();
		break;
	default:
		p=exp_stmt();
		break;
	}
	return p;
}
TreeNode *exp_stmt()
{
	TreeNode *p=NULL;
	if(token!=SEMI) p=exp();
	match(SEMI);
	return p;
}
TreeNode *select_stmt()
{
	TreeNode *p=NewNode(STMT);
	p->childkind.stmtK=IF_STMT;
	match(IF);
	match(LPAREN);
	p->pChild[0]=exp();
	match(RPAREN);
	p->pChild[1]=statement();
	if(token==ELSE){
		match(ELSE);
		p->pChild[2]=statement();
	}
	return p;
}
TreeNode *while_stmt()
{
	TreeNode *p=NewNode(STMT);
	p->childkind.stmtK=WHILE_STMT;
	match(WHILE);
	match(LPAREN);
	p->pChild[0]=exp();
	match(RPAREN);
	p->pChild[1]=statement();
	return p;
}
TreeNode *return_stmt()
{
	TreeNode *p=NewNode(STMT);
	p->childkind.stmtK=RETURN_STMT;
	match(RETURN);
	if(token!=SEMI) p->pChild[0]=exp();
	match(SEMI);
	return p;
}
TreeNode *exp()
{
	TreeNode *p,*t;
	if(token==ID){
		list<TokenUnit>::iterator
			&it=Backup();
		t=var();delete t;
		if(token==ASSIGN) {
			Restore(it);
			p=assign_exp();
        }
		else{
			Restore(it);
			p=simple_exp();
		}
	}
	else p=simple_exp();
	return p;
}
TreeNode *simple_exp()
{
	TreeNode *p,*q=additive_exp();
	if(token==LT || token==LTEQ || token==GT ||
		token== GTEQ || token==NEQ || token==EQ)
	{
		p=NewNode(RELOP);
		p->tokenT=token;
		p->name=TokenString;
		match(token);
		p->pChild[0]=q;
		p->pChild[1]=additive_exp();
	}
	else p=q;
	return p;
}
TreeNode *additive_exp()
{
	TreeNode *p=term();
	while(token==PLUS || token==MINUS)
	{
		TreeNode *q=NewNode(OP);
		if(p!=NULL){
			q->tokenT=token;
			q->name=TokenString;
			match(token);
			q->pChild[0]=p;
			p=q;
			p->pChild[1]=term();
		}
	}
	return p;
}
TreeNode *term()
{
	TreeNode *p=factor();
	while(token==MUL || token==DIV)
	{
		TreeNode *q=NewNode(OP);
		if(p!=NULL){
			q->tokenT=token;
			q->name=TokenString;
			match(token);
			q->pChild[0]=p;
			p=q;
			p->pChild[1]=factor();
		}
	}
	return p;
}
TreeNode *factor()
{
	TreeNode *p;
	list<TokenUnit>::iterator it;
	switch(token)
	{
	case LPAREN:
		p=exp();
		break;
	case NUMBER:
		p=NewNode(NUM);
		p->name=TokenString;
		match(NUMBER);
		break;
	case ID:
		it=Backup();
        p=var();
		delete p;
		if(token==LPAREN) {
			Restore(it);
			p=call();
        }
		else{
			Restore(it);
			p=var();
		}
		break;
	default:
		Error=1;
	}
	if(Error==1) ParseError("Factor error",lineno);
	return p;
}
TreeNode *assign_exp()
{
	TreeNode *p=var();
	p->kind=EXP;
	p->childkind.expK=ASSIGN_EXP;
	match(ASSIGN);
	p->pChild[1]=exp();
	return p;
}

TreeNode *call()
{
	TreeNode *p=NewNode(CALL);
	p->name=TokenString;
	match(ID);
	match(LPAREN);
	p->pChild[0]=arg_list();
	match(RPAREN);
	return p;
}
TreeNode *arg_list()
{
	if(token==RPAREN) return NULL;
	TreeNode *p=exp(),*q=p;
	p->pPrev=NULL;
	while(token==COMMA)
	{
		match(COMMA);
		q->pNext=exp();
		q->pNext->pPrev=q;
		q=q->pNext;
	}
	return p;
}

TreeNode *var()
{
	TreeNode *p=NewNode(REFER);
	p->name=TokenString;
	match(ID);
	if(token==LSQUAR){
		match(token);
		p->pChild[0]=exp();
		match(RSQUAR);
	}
	return p;
}
TreeNode *parse()
{
	token=GetToken();
	return declar_list();
}

#endif