parse.cpp

PL编译器

// Parse.cpp: implementation of the CParse class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "PascalCompiler.h"
#include "Parse.h"
#include "Tokenize.h"


#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

extern FILE *pfile;					//指向输入文件的指针

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CParse::CParse()
{
	flag = 0;
}

CParse::~CParse()
{

}

void CParse::PASCALparse()
{
	fscanf(pfile,"%s %s\n",tokenSign,tokenValue);
	program();
	fclose(pfile);
}

int CParse::match(int temp)
{
	int tmp=atoi(tokenSign);

	if (temp == tmp)
		return 1;
	else
		return 0;
}
	
void CParse::advance()
{
	fscanf(pfile,"%s %s\n",tokenSign,tokenValue);
}

CString CParse::returnError()
{
	switch(flag)
	{
	case 1:		return mStr[1];			break;
	case 2:		return mStr[2];			break;
	case 3:		return mStr[3];			break;
	case 4:		return mStr[4];			break;
	case 5:		return mStr[5];			break;
	case 6:		return mStr[6];			break;
	case 7:		return mStr[7];			break;
	case 8:		return mStr[8];			break;
	case 9:		return mStr[9];			break;
	case 10:	return mStr[10];		break;
	case 11:	return mStr[11];		break;
	case 12:	return mStr[12];		break;
	case 13:	return mStr[13];		break;
	case 14:	return mStr[14];		break;
	case 15:	return mStr[15];		break;
	case 16:	return mStr[16];		break;
	default:	return mStr[0];			break;
	}
}

//<program> → <declaration_list>BEGIN<statement_list>END.
void CParse::program()
{
	declaration_list();

	match(SYN_BEGIN);

	statement_list();

	if(match(SYN_END))
		advance();
	else
	{
		mStr[1]=mErr.Error(SYN_END);
		flag=1;
	}

	if(match(SYN_PERIOD))
	{
		mStr[0]="Grammer Analysis Successful!";
		flag=0;
	}

	else
	{
		mStr[2]=mErr.Error(SYN_PERIOD);
		flag=2;
	}
}

//<declaration_list> → VAR<variable_list>:INTEGER; |ε
void CParse::declaration_list()
{
	if(!match(SYN_VAR))
		return;

	if(match(SYN_VAR))
		advance();
	else
	{
		mStr[3]=mErr.Error(SYN_VAR);
		flag=3;
	}

	varible_list();

	if(match(SYN_COLON))
		advance();
	else
	{
		mStr[4]=mErr.Error(SYN_COLON);
		flag=4;
	}

	if(match(SYN_INTEGER))
		advance();
	else
	{
		mStr[5]=mErr.Error(SYN_INTEGER);
		flag=5;
	}

	if(match(SYN_SEMI))
		advance();
	else
	{
		mStr[6]=mErr.Error(SYN_SEMI);
		flag=6;
	}
}

//<varible_list> →ID A
void CParse::varible_list()
{
	if(match(SYN_ID))
		advance();
	else
	{
		mStr[7]=mErr.Error(SYN_ID);
		flag=7;
	}

	A();
}
	
//A →  ,ID A |ε
void CParse::A()
{
	if(!match(SYN_COMMA))
		return;

	if(match(SYN_COMMA))
		advance();
	else
	{
		mStr[8]=mErr.Error(SYN_COMMA);
		flag=8;
	}

	if(match(SYN_ID))
		advance();
	else
	{
		mStr[9]=mErr.Error(SYN_ID);
		flag=9;
	}

	A();
}

//<statement_list> → <statement>B
void CParse::statement_list()
{
	statement();
	B();
}

//B →;<statement_list> |ε
void CParse::B()
{
	if(!match(SYN_SEMI))
		return;

	match(SYN_SEMI);

	statement_list();
}

//<statement> → <assignment_stat> | <conditional_stat> | <while_stat> | <compound_stat>
void CParse::statement()
{
	advance();

	if(match(SYN_ID))
		assignment_stat();

	if(match(SYN_IF))
		conditional_stat();

	if(match(SYN_WHILE))
		while_stat();

	if(match(SYN_BEGIN))
		compound_stat();
}

//<assignment_stat> → ID:=<arithmetic_expr>
void CParse::assignment_stat()
{
	if(match(SYN_ID))
		advance();
	else
	{
		mStr[10]=mErr.Error(SYN_ID);
		flag=10;
	}

	if(match(SYN_COLE))
		advance();
	else
	{
		mStr[11]=mErr.Error(SYN_COLE);
		flag=11;
	}

	arithmetic_expr();
}

//<conditional_stat> → IF<relational_expr>THEN<statement>ELSE<statement>
void CParse::conditional_stat()
{
	if(match(SYN_IF))
		advance();
	else
	{
		mStr[12]=mErr.Error(SYN_IF);
		flag=12;
	}

	relational_expr();

	match(SYN_THEN);
	statement();

	match(SYN_ELSE);
	statement();
}

//<while_stat> → WHILE<relational_expr>DO<statement>
void CParse::while_stat()
{
	if(match(SYN_WHILE))
		advance();
	else
	{
		mStr[13]=mErr.Error(SYN_WHILE);
		flag=13;
	}

	relational_expr();

	match(SYN_DO);

	statement();
}

//<compound_stat> → BEGIN<statement_list>END
void CParse::compound_stat()
{
	match(SYN_BEGIN);
	statement_list();

	if(match(SYN_END))
		advance();
	else
	{
		mStr[14]=mErr.Error(SYN_END);
		flag=14;
	}
}

//<arithmetic_expr> → <item>C
void CParse::arithmetic_expr()
{
	item();
	C();
}

//C → +<item>C | -<item>C |ε
void CParse::C()
{
	if(match(SYN_PLUS) || match(SYN_SUB))
	{
		advance();
		item();
		C();
	}

	else
		return;
}

//<item> → <factor>D
void CParse::item()
{
	factor();
	D();
}

//D → *<factor>D | /<factor>D |ε
void CParse::D()
{
	if(match(SYN_MUL) || match(SYN_DIV))
	{
		advance();
		factor();
		D();
	}

	else
		return;
}

//<factor> → ID | NUM | (<arithmetic_expr>)
void CParse::factor()
{
	if(match(SYN_ID) || match(SYN_NUM))
	{
		advance();
	}

	else
	{
		if(match(SYN_LPAREN))
			advance();
		else
		{
			mStr[15]=mErr.Error(SYN_LPAREN);
			flag=15;
		}

		arithmetic_expr();

		if(match(SYN_RPAREN))
			advance();
		else
		{
			mStr[16]=mErr.Error(SYN_RPAREN);
			flag=16;
		}
	}
}

//<relational_expr> → <arithmetic_expr><<arithmetic_expr>
//<relational_expr> → <arithmetic_expr><=<arithmetic_expr>
//<relational_expr> → <arithmetic_expr>==<arithmetic_expr>
//<relational_expr> → <arithmetic_expr>><arithmetic_expr>
//<relational_expr> → <arithmetic_expr>>=<arithmetic_expr>
//<relational_expr> → <arithmetic_expr><><arithmetic_expr>
void CParse::relational_expr()
{
	arithmetic_expr();

	if(match(SYN_LT) || match(SYN_LE) || match(SYN_EQ) || match(SYN_LG) || match(SYN_ME) || match(SYN_NE))
	{
		advance();
		arithmetic_expr();
	}
}