bianyi1.cpp

一个简单的编译器

		Statement();
		MatchToken(SEMICO);
	}
	back("Program");
}
static void Statement(){//Statement的递归子程序
	enter("Statement");
	switch(token.type){
	case ORIGIN: OriginStatement();break;
	case SCALE:  ScaleStatement(); break;
	case ROT:    RotStatement();   break;
	case FOR:    ForStatement();   break;
	default:     SyntaxError(2);
	}
	back("Statement");
}
static void OriginStatement(void){//OriginStatement的递归子程序
	struct ExprNode *tmp;
	enter("OriginStatement");
	MatchToken(ORIGIN);
	MatchToken(IS);
	MatchToken(L_BRACKET);
	tmp=Expression();
	Origin_x=GetExprValue(tmp);
	DelExprTree(tmp);
	MatchToken(COMMA);
	tmp=Expression();
	Origin_y=GetExprValue(tmp);
	DelExprTree(tmp);
	MatchToken(R_BRACKET);
	back("OriginStatement");
}
static void ScaleStatement(void){//ScaleStatement的递归子程序
	struct ExprNode *tmp;
	enter("ScaleStatement");
	MatchToken(SCALE);
	MatchToken(IS);
	MatchToken(L_BRACKET);
	tmp=Expression();
	Scale_x=GetExprValue(tmp);
	DelExprTree(tmp);
	MatchToken(COMMA);
	tmp=Expression();
	Scale_y=GetExprValue(tmp);
	DelExprTree(tmp);
	MatchToken(R_BRACKET);
	back("ScaleStatement");
}
static void RotStatement(void){//RotStatement的递归子程序
	struct ExprNode *tmp;
	enter("RotStatement");
	MatchToken(ROT);
	MatchToken(IS);
	tmp=Expression();
	Rot_angle=GetExprValue(tmp);
	DelExprTree(tmp);
	back("RotStatement");
}
#define call_match(x) printf("matchtoken");printf(x);printf("\n");
extern void DrawLoop(double Start,double End,double Step,
					 struct ExprNode*HorPtr,struct ExprNode*VerPtr);
static void ForStatement(void){//ForStatement的递归子程序
	double Start,End,Step;
	struct ExprNode *start_ptr,*end_ptr,*step_ptr,*x_ptr,*y_ptr;
	enter("ForStatement");
	MatchToken(FOR); call_match("FOR");
	MatchToken(T);   call_match("T");
	MatchToken(FROM);call_match("FROM");
	start_ptr=Expression();
	Start=GetExprValue(start_ptr);
	DelExprTree(start_ptr);
	MatchToken(TO); call_match("TO");
	end_ptr=Expression();
	End=GetExprValue(start_ptr);
    DelExprTree(end_ptr);
    MatchToken(STEP);   call_match("STEP");
    step_ptr=Expression();
	Step=GetExprValue(step_ptr);
    DelExprTree(step_ptr);
	MatchToken(DRAW); call_match("DRAW");
    MatchToken(L_BRACKET); call_match("(");
	x_ptr=Expression();
	MatchToken(COMMA);call_match(",");
	y_ptr=Expression();
	MatchToken(R_BRACKET);call_match(")");
    DrawLoop(Start,End,Step,x_ptr,y_ptr);
	DelExprTree(x_ptr);
	DelExprTree(x_ptr);
	back("ForStatement");
}
#define Tree_trace(x) PrintSyntaxTree(x,1);
static struct ExprNode* Expression(){//Expression的递归子程序
	struct ExprNode *left,*right;
	Token_Type token_tmp;
	enter("Expression");
	left=Term();
	while(token.type==PLUS||token.type==MINUS){
		token_tmp=token.type;
		MatchToken(token_tmp);
		right=Term();
		left=MakeExprNode(token_tmp,left,right);
	}
	Tree_trace(left);
	back("Expression");
	return left;
}
static struct ExprNode *Term(){//Term的递归子程序
	struct ExprNode *left,*right;
	Token_Type token_tmp;
	left=Factor();
	while(token.type==MUL||token.type==DIV){
		token_tmp=token.type;
		MatchToken(token_tmp);
		right=Factor();
		left=MakeExprNode(token_tmp,left,right);
	}
	return left;
}
static struct ExprNode *Factor(){//Factor的递归子程序
	struct ExprNode *left,*right;
	if(token.type==PLUS){
		MatchToken(PLUS);
		right=Factor();
	}
	else if(token.type==MINUS){
		MatchToken(MINUS);
		right=Factor();
		left=new ExprNode;
		left->OpCode=CONST_ID;
		left->Content.CaseConst=0.0;
		right=MakeExprNode(MINUS,left,right);
	}
	else right=Component();
	return right;
}
static struct ExprNode*Component(){//Component的递归子程序
	struct ExprNode *left,*right;
	left=Atom();
	if(token.type==POWER){
		MatchToken(POWER);
		right=Component();
		left=MakeExprNode(POWER,left,right);
	}
	return left;
}
static struct ExprNode*Atom(){//Atom的递归子程序
	struct Token t=token;
	struct ExprNode*address,*tmp;
	switch(token.type){
	case CONST_ID:
		MatchToken(CONST_ID);
		address=MakeExprNode(CONST_ID,t.value);
		break;
	case T:
		MatchToken(CONST_ID);
		address=MakeExprNode(T);
		break;
    case FUNC:
		MatchToken(FUNC);
		MatchToken(L_BRACKET);
		tmp=Expression();
		address=MakeExprNode(FUNC,t.Funcptr,tmp);
		MatchToken(R_BRACKET);
		break;
	case L_BRACKET:
		MatchToken(L_BRACKET);
		address=Expression();
		MatchToken(R_BRACKET);
		break;
	default:
		SyntaxError(2);
	}
	return address;
}
static struct ExprNode*MakeExprNode(enum Token_Type opcode,...){//生成语法树的一个节点
	struct ExprNode*ExprPtr=new(struct ExprNode);
	ExprPtr->OpCode=opcode;
	va_list ArgPtr;
	va_start(ArgPtr,opcode);
	switch(opcode){
	case CONST_ID:
		ExprPtr->Content.CaseConst=(double)va_arg(ArgPtr,double);
		break;
	case T:
		ExprPtr->Content.CaseParmPtr=&Parameter;
		break;
	case FUNC:
		ExprPtr->Content.CaseFunc.MathFuncPtr=(FuncPtr)va_arg(ArgPtr,FuncPtr);
		ExprPtr->Content.CaseFunc.Child=(struct ExprNode*)va_arg(ArgPtr,struct ExprNode*);
		break;
	default:
		ExprPtr->Content.CaseOperator.Left=
			(struct ExprNode*)va_arg(ArgPtr,struct ExprNode*);
		ExprPtr->Content.CaseOperator.Right=
			(struct ExprNode*)va_arg(ArgPtr,struct ExprNode*);
		break;
	}
	va_end(ArgPtr);
	return ExprPtr;
}
#include<windows.h>
#include<wingdi.h>
extern HDC hDC;
#include"graphics.h"
using namespace std;
#include<conio.h>
#define red RGB(255,0,0)
#define black RGB(0,0,0)
#define white 255
extern void DrawPixel(unsigned long x,unsigned long y);
extern int InGraphMode=0;
extern int InitGraph(void);
extern void CloseGraph(void);
extern double Parameter,Origin_x,Origin_y,Scale_x,Scale_y,Rot_angle;
static void Errmsg(char*string){
exit(1);
}
static void CalcCoord(struct ExprNode*Hor_Exp,
					  struct ExprNode*Ver_Exp,
					  double &Hor_x,double &Ver_y){
	double HorCord,VerCord,Hor_tmp;
	HorCord=GetExprValue(Hor_Exp);
	VerCord=GetExprValue(Ver_Exp);
	HorCord*=Scale_x;
	VerCord*=Scale_y;
	Hor_tmp=HorCord*cos(Rot_angle)+VerCord*sin(Rot_angle);
	VerCord=VerCord*cos(Rot_angle)-HorCord*sin(Rot_angle);
	HorCord=Hor_tmp;
	HorCord+=Origin_x;
	VerCord+=Origin_y;
	Hor_x=HorCord;
	Ver_y=VerCord;
}
void DrawLoop(double Start,double End,double Step,
			  struct ExprNode*HorPtr,struct ExprNode*VerPtr){
	//extern double Parameter;
	double x,y;
	for(Parameter=Start;Parameter<=End;Parameter+=Step){
		CalcCoord(HorPtr,VerPtr,x,y);
		DrawPixel(x,y);
	}
}
void DrawPixel(unsigned long x,unsigned long y){
	SetPixel(hDC,x,y,black);
}
int InitGraph(void){
	int gd=DETECT,gm;
	if(InGraphMode)return 0;
	registerbgidriver(EGAVGA_driver);
	initgraph(&gd,&gm,"");
	setcolor(-1);
	InGraphMode=1;
	return 1;
}
void CloseGraph(void){
	if(!InGraphMode)return;
	getch();
	closegraph();
	InGraphMode=0;
}
#define MAX_CHARS 200
char SrcFilePath[MAX_CHARS];
static char Name[]="Compiler";
static bool PrepareWindow(HINSTANCE,HINSTANCE,int);
static bool CheckSrcFile(LPSTR);
static LRESULT CALLBACK WndProc(HWND,UINT,WPARAM,LPARAM);
int APIENTRY WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,
					 LPSTR lpCmdLine,int nCmdShow){
	strcpy(SrcFilePath,lpCmdLine);
	if(PrepareWindow(hInstance,hPrevInstance,nCmdShow)!=true){
		MessageBox(NULL,"Init failture!!!","mistake",MB_OK);
		return 1;
	}
	if(!CheckSrcFile(lpCmdLine))return 1;
	Parser(SrcFilePath);
	MSG Msg;
	while(GetMessage(&Msg,NULL,0,0)){
		TranslateMessage(&Msg);
		DispatchMessage(&Msg);
	}
	return Msg.wParam;
}
void main(int argc,char *argv[]){
	if(argc<2){
		cout<<"请输入源文件！"<<endl;
		return;
	}
    Token token;
	if(!InitScanner(argv[1])){
		cout<<"打开文件失败！"<<endl;
	}
	cout<<"记号类别      字符串         常数值              函数指针"<<endl;
	cout<<"---------------------------------------------------------"<<endl;
	while(1){
		token=GetToken();
		if(token.type!=NONTOKEN){
			cout<<token.type<<"               ";
			cout<<token.lexeme<<"               ";
			cout<<token.value<<"                 ";
			cout<<token.Funcptr<<endl;
		}
		else break;
	}
	cout<<"-----------------------------------------------------"<<endl;
	Parser("text.txt");
	CloseScanner();
}