#include"scanner.h" typedef double(*FuncPtr)(double); //语法树的节点 struct ExprNode //type of syntax tree's node { enum Token_Type OpCode; //PLUS MINUS DIV POWER FUNC CONST_ID union { struct{ExprNode *Left,*Right;}CaseOperator; struct{ExprNode *Child;FuncPtr MathFuncPtr;}CaseFunc; double CaseConst; double * CaseParmPtr; }Content; }; extern void Parser(char *SrcFilePtr);//参数为字符串
#include <cstring> #include <cstdio> #include <cstdlib> #include <cmath> #include <SDKDDKVer.h> #include <stdio.h> #include <tchar.h> enum Token_Type // 记号的类别 { ORIGIN, SCALE, ROT, IS, // 保留字（一字一码） TO, STEP, DRAW,FOR, FROM, // 保留字 T, // 参数 SEMICO, L_BRACKET, R_BRACKET, COMMA,// 分隔符 PLUS, MINUS, MUL, DIV, POWER, // 运算符 FUNC, // 函数 CONST_ID, // 常数 NONTOKEN, // 空记号（源程序结束） ERRTOKEN }; typedef double (*MathFuncPtr)(double);//函数指针 struct Token // 记号的数据结构 { Token_Type type; // 类别 const char * lexeme; // 属性，原始输入的字符串 double value; // 属性，若记号是常数则是常数的值 double (* FuncPtr)(double); // 属性，若记号是函数则是函数的指针 }; static Token TokenTab[] = { {CONST_ID, "PI", 3.1415926, NULL}, {CONST_ID, "E", 2.71828, NULL}, {T, "T", 0.0, NULL}, {FUNC, "SIN", 0.0, sin}, {FUNC, "COS", 0.0, cos}, {FUNC, "TAN", 0.0, tan}, {FUNC, "LN", 0.0, log}, {FUNC, "EXP", 0.0, exp}, {FUNC, "SQRT", 0.0, sqrt}, {ORIGIN, "ORIGIN", 0.0, NULL}, {SCALE, "SCALE", 0.0, NULL}, {ROT, "ROT", 0.0, NULL}, {IS, "IS", 0.0, NULL}, {FOR, "FOR", 0.0, NULL}, {FROM, "FROM", 0.0, NULL}, {TO, "TO", 0.0, NULL}, {STEP, "STEP", 0.0, NULL}, {DRAW, "DRAW", 0.0, NULL} }; extern unsigned int LineNo; extern int InitScanner(const char*); extern Token GetToken(void); extern void CloseScanner(void);
#include<windows.h> #include<wingdi.h> #define red RGB(255,0,0) //红色 #define black RGB(0,0,0) //黑色 extern HDC hDC; //----------------外部函数声明 extern void DrawPixel(unsigned long x,unsigned long y); //绘制一个点 extern double GetExprValue(struct ExprNode *root); //获得表达式的值 extern void DrawLoop(double Start, double End, double Step, struct ExprNode *HorPtr, struct ExprNode *VerPtr); extern void DelExprTree(struct ExprNode *root); //删除一棵树
#include "semantics.h" #include <cmath> #include "parser.h" extern double Parameter, //参数T的存储空间 Origin_x, Origin_y, //横、纵平移距离 Scale_x, Scale_y, //横、纵比例因子 Rot_angle; extern HDC hDC; void DrawPixel(unsigned long x,unsigned long y); //绘制一个点 double GetExprValue(struct ExprNode *root); //获得表达式的值 void DrawLoop(double Start, double End, double Step, struct ExprNode *HorPtr, struct ExprNode *VerPtr); void DelExprTree(struct ExprNode *root); //删除一棵树 static void Errmsg(char *string); static void CalcCoord(struct ExprNode *Hor_Exp, struct ExprNode *Ver_Exp, double &Hor_x, double &Ver_y); //----------------出错处理 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((unsigned long)x, (unsigned long)y); } } //---------------计算表达式的值 double GetExprValue(struct ExprNode *root) { if(root == NULL) return 0.0; switch(root->OpCode) { case PLUS : return GetExprValue(root->Content.CaseOperator.Left) + GetExprValue(root->Content.CaseOperator.Right); case MINUS : return GetExprValue(root->Content.CaseOperator.Left) - GetExprValue(root->Content.CaseOperator.Right); case MUL : return GetExprValue(root->Content.CaseOperator.Left) * GetExprValue(root->Content.CaseOperator.Right); case DIV : return GetExprValue(root->Content.CaseOperator.Left) / GetExprValue(root->Content.CaseOperator.Right); case POWER : return pow(GetExprValue(root->Content.CaseOperator.Left), GetExprValue(root->Content.CaseOperator.Right)); case FUNC : return (*root->Content.CaseFunc.MathFuncPtr)(GetExprValue(root->Content.CaseFunc.Child)); case CONST_ID : return root->Content.CaseConst; case T : return *(root->Content.CaseParmPtr); default : return 0.0; } } //---------------删除一颗语法树 void DelExprTree(struct ExprNode *root) { if(root == NULL) return; switch(root ->OpCode) { case PLUS : case MINUS : case MUL : case DIV : case POWER : DelExprTree(root->Content.CaseOperator.Left); DelExprTree(root->Content.CaseOperator.Right); break; case FUNC : DelExprTree(root->Content.CaseFunc.Child); break; default : break; } delete(root); } //--------------绘制一个点 void DrawPixel(unsigned long x, unsigned long y) { SetPixel(hDC, x, y, black); }
#include "semantics.h" #include <stdio.h> #define MAX_CHARS 200 extern void Parser(char *SrcFilePtr); HDC hDC; 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, "testerror.txt"); //初始化窗口 if(PrepareWindow(hInstance, hPrevInstance, nCmdShow)!=true) { MessageBox(NULL, "窗口初始化失败 !", "错误", MB_OK); return 1; } //检查要分析的源程序文件 if (!CheckSrcFile(SrcFilePath)) return 1; //---------------------------------------- // 调用绘图语言解释器 Parser(SrcFilePath); //---------------------------------------- //进入窗口消息循环 MSG Msg; while(GetMessage(&Msg, NULL,0, 0)) { TranslateMessage(&Msg); DispatchMessage(&Msg); } return Msg.wParam; } //--------------初始化窗口函数实现 bool PrepareWindow(HINSTANCE hInst, HINSTANCE hPrevInstance, int nCmdShow) { HWND hWnd; WNDCLASS W; memset(&W, 0, sizeof(WNDCLASS)); W.style = CS_HREDRAW | CS_VREDRAW; W.lpfnWndProc = WndProc; W.hInstance = hInst; W.hCursor = LoadCursor(NULL, IDC_ARROW); W.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1); W.lpszClassName = Name; RegisterClass(&W); hWnd = CreateWindow(Name, Name, WS_OVERLAPPEDWINDOW, 225, 225, 740, 490, NULL, NULL,hInst,NULL); if(hWnd == NULL) return false; ShowWindow(hWnd, nCmdShow); UpdateWindow(hWnd); SetCursor(LoadCursor(hInst, IDC_ARROW)); hDC = GetDC(hWnd); return true; } //--------------------检查源程序文件是否合法函数实现 bool CheckSrcFile(LPSTR lpszCmdParam) { FILE *file = NULL; if(strlen(lpszCmdParam) == 0) { MessageBox(NULL,"未指定源程序文件!", "Error", MB_OK); return false; } if((file=fopen(lpszCmdParam, "r"))==NULL) { MessageBox(NULL, "打开源程序文件出错！", "错误", MB_OK); MessageBox(NULL, lpszCmdParam, "文件名", MB_OK); return false; } else fclose(file); return true; } //-------------------窗口消息处理函数实现 LRESULT CALLBACK WndProc(HWND hWnd, UINT Message, WPARAM wParam, LPARAM lParam) { switch(Message) { case WM_DESTROY : ReleaseDC(hWnd, hDC); PostQuitMessage(0); return 0; case WM_PAINT : PAINTSTRUCT pt; BeginPaint(hWnd, &pt); Parser(SrcFilePath); EndPaint(hWnd, &pt); default: return DefWindowProc(hWnd,Message,wParam, lParam); } }
#include "parser.h" #include <cstdio> #include <stdarg.h> #include "semantics.h" //构造语法树的目的是求表达式的值 //全是递归程序 double Parameter=0, //参数T的存储空间 Origin_x=0,Origin_y=0, //横、纵平移距离 Scale_x=1, Scale_y=1, //横、纵比例因子 Rot_angle=0; //旋转角度 static Token token; //----------------------辅助函数声明 static void FetchToken(); static void MatchToken(enum Token_Type AToken); static void SyntaxError(int case_of); static void ErrMsg(unsigned LineNo,const char *descrip,const char *string); static void PrintSyntaxTree(struct ExprNode *root,int indent);//打印语法树 //-----------------------外部接口与语法树构造声明函数 void Parser(char * SrcFilePtr); static struct ExprNode * MakeExprNode(enum Token_Type opcode,...); //---------------------非终结符的递归子程序声明 static void Program(); static void Statement(); static void OriginStatement(); static void RotStatement(); static void ScaleStatement(); static void ForStatement(); static struct ExprNode *Expression(); static struct ExprNode *Term(); static struct ExprNode *Factor(); static struct ExprNode *Component(); static struct ExprNode *Atom(); //-----------------------辅助函数 //通过词法分析器接口GetToken获取一个记号 static void FetchToken() { token = GetToken(); if(token.type == ERRTOKEN) SyntaxError(1); } //匹配记号 static void MatchToken(enum Token_Type The_Token) { if(token.type != The_Token) SyntaxError(2); FetchToken(); } //处理语法错误 static void SyntaxError(int case_of) { switch(case_of) { case 1 :ErrMsg(LineNo,"错误记号",token.lexeme);break; case 2 :ErrMsg(LineNo,"不是预期的记号",token.lexeme);break; } } //打印错误信息 void ErrMsg(unsigned LineNo,const char *descrip,const char *string) { printf("Line No %d: %s %s!\n",LineNo,descrip,string); char msg[256]; memset(msg, 0, 256); sprintf(msg, "Line No %d: %s %s",LineNo,descrip,string); MessageBox(NULL, msg, "Error!", MB_OK); CloseScanner(); exit(1); } //深度优先先序遍历语法树并打印 void PrintSyntaxTree(struct ExprNode *root,int indent) { int temp; for(temp = 1;temp <= indent;temp++)printf("\t"); switch(root->OpCode) //打印根节点 { case PLUS: printf("%s\n","+");break; case MINUS: printf("%s\n","-");break; case MUL: printf("%s\n","*");break; case DIV: printf("%s\n","/");break; case POWER: printf("%s\n","**");break; case FUNC: printf("%x\n", root->Content.CaseFunc.MathFuncPtr);break; case CONST_ID: printf("%f\n",root->Content.CaseConst);break; case T: printf("%s\n","T");break; default: printf("Error Tree Node! \n");exit(0); } if(root->OpCode == CONST_ID || root->OpCode == T) //叶子节点返回 return ; if(root->OpCode == FUNC) //递归打印一份孩子的节点 PrintSyntaxTree(root->Content.CaseFunc.Child,indent+1); else { PrintSyntaxTree(root->Content.CaseOperator.Left,indent+1); PrintSyntaxTree(root->Content.CaseOperator.Right,indent+1); } } //-------------------绘图解释器的外部接口 void Parser(char *SrcFilePtr) { if(!InitScanner(SrcFilePtr)) { printf("Open Source File Failed!\n"); } FetchToken(); Program(); CloseScanner(); } //----------------生成语法树的一个节点 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; } //-------------------非终结符的递归子程序 //program的递归子程序 static void Program() { while(token.type != NONTOKEN) { Statement(); MatchToken(SEMICO); } } //statement的递归子程序 static void Statement() { switch(token.type) { case ORIGIN: OriginStatement(); break; case SCALE: ScaleStatement(); break; case ROT: RotStatement(); break; case FOR: ForStatement(); break; default: SyntaxError(2); } } //originstatement的递归子程序 static void OriginStatement() { struct ExprNode *tmp; 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); } //scalestatement的递归子程序 static void ScaleStatement() { struct ExprNode *tmp; 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); } //rotstatement的递归子程序 static void RotStatement() { struct ExprNode *tmp; MatchToken(ROT); MatchToken(IS); tmp = Expression(); Rot_angle = GetExprValue(tmp); DelExprTree(tmp); } //forstatement的递归子程序 static void ForStatement() { double Start, End, Step; struct ExprNode *start_ptr,*end_ptr,*step_ptr,*x_ptr,*y_ptr; //各表达式语法树根节点指针 MatchToken(FOR); MatchToken(T); MatchToken(FROM); start_ptr = Expression(); //构造参数起点表达式语法树 Start = GetExprValue(start_ptr); DelExprTree(start_ptr); MatchToken(TO); end_ptr = Expression(); //构造参数终点表达式语法树 End = GetExprValue(end_ptr); DelExprTree(end_ptr); MatchToken(STEP); step_ptr = Expression(); //构造步长表达式语法树 Step = GetExprValue(step_ptr); DelExprTree(step_ptr); MatchToken(DRAW); MatchToken(L_BRACKET); x_ptr = Expression(); //构造横坐标表达式语法树 MatchToken(COMMA); y_ptr = Expression(); //纵坐标 MatchToken(R_BRACKET); DrawLoop(Start, End, Step, x_ptr, y_ptr); DelExprTree(x_ptr); DelExprTree(y_ptr); } //expression的递归子程序 static struct ExprNode * Expression() { struct ExprNode *left,*right; //左右子树节点的指针 Token_Type token_tmp; //当前记号 left = Term(); //分析左操作数且得到其语法树 while(token.type == PLUS || token.type == MINUS) { token_tmp = token.type; MatchToken(token_tmp); right = Term(); //分析右操作数且得到其语法树 left = MakeExprNode(token_tmp,left,right); //构造运算的语法树，结果为左子树 } return left; } //term的递归子程序 static struct ExprNode* 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; } //factor的递归子程序 static struct ExprNode* 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(); //匹配非终结符Component return right; } //component的递归子程序 static struct ExprNode* Component() { struct ExprNode *left,*right; left = Atom(); if(token.type == POWER) { MatchToken(POWER); right = Component(); //递归调用Component以实现POWER的右结合 left = MakeExprNode(POWER,left,right); } return left; } //atom的递归子程序 static struct ExprNode* Atom() { struct Token t = token; struct ExprNode *address=NULL,*tmp; switch (token.type) { case CONST_ID: MatchToken(CONST_ID); address = MakeExprNode(CONST_ID,t.value); break; case T: MatchToken(T); 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; }
#include "scanner.h" #include <cctype> #define TOKEN_LEN 100 unsigned int LineNo; static FILE *InFile; static char TokenBuffer[TOKEN_LEN]; extern int InitScanner(const char *FileName) { LineNo = 1; InFile = fopen(FileName, "r"); if(InFile != NULL) return 1; else return 0; } extern void CloseScanner(void) { if(InFile != NULL) fclose(InFile); } static char GetChar(void) { int Char = getc(InFile); return toupper(Char); } static void BackChar(char Char) { if(Char != EOF) ungetc(Char, InFile); } static void AddCharTokenString(char Char) { int TokenLength = strlen(TokenBuffer); if(TokenLength + 1 >= sizeof(TokenBuffer)) return; TokenBuffer[TokenLength] = Char; TokenBuffer[TokenLength+1] = '\0'; } static void EmptyTokenString(){ memset(TokenBuffer, 0, TOKEN_LEN); } //判断是否为合法标记 static Token JudgeKeyToken(const char *IDString) { int loop; for(loop=0; loop<sizeof(TokenTab)/sizeof(TokenTab[0]); loop++) { //遍历符号表 if(strcmp(TokenTab[loop].lexeme, IDString)==0) return TokenTab[loop]; } Token errortoken; memset(&errortoken, 0, sizeof(Token)); errortoken.type = ERRTOKEN; return errortoken; } //只是获得一个记号 extern Token GetToken() { Token token; int Char; memset(&token, 0, sizeof(Token)); EmptyTokenString();//memset(TokenBuffer) token.lexeme = TokenBuffer; for(;;) { Char = GetChar(); if(Char == EOF) { token.type = NONTOKEN; return token; } if(Char == '\n') LineNo++; if(!isspace(Char)) break; }//处理空格等 AddCharTokenString(Char); //主要就是三个if if(isalpha(Char)) { for(;;) { Char = GetChar(); if(isalnum(Char)) AddCharTokenString(Char); else break; } BackChar(Char); token = JudgeKeyToken(TokenBuffer); //返回的是一个新的token，不再是GetToken函数一开始声明的token token.lexeme = TokenBuffer; return token; } else if(isdigit(Char)) { for(;;) { Char = GetChar(); if(isdigit(Char)) AddCharTokenString(Char); else break; } //处理小数 if(Char == '.') { AddCharTokenString(Char); for(;;) { Char = GetChar(); if(isdigit(Char)) AddCharTokenString(Char); else break; } }//end of if(Char == '.') BackChar(Char); token.type = CONST_ID; token.value = atof(TokenBuffer); return token; } else { switch(Char) { case ';' : token.type = SEMICO; break; case '(' : token.type = L_BRACKET; break; case ')' : token.type = R_BRACKET; break; case ',' : token.type = COMMA; break; case '+' : token.type = PLUS; break; case '-' ://处理注释 Char = GetChar(); if(Char == '-') { while(Char != '\n' && Char != EOF) Char = GetChar(); BackChar(Char); return GetToken();//token函数的开始都会memset的 } else { BackChar(Char); token.type = MINUS; break; } case '/' : Char = GetChar(); if(Char == '/') { while(Char != '\n' && Char != EOF) Char = GetChar(); BackChar(Char); return GetToken(); } else { BackChar(Char); token.type = DIV; break; } case '*' : Char = GetChar(); if(Char == '*') { token.type = POWER; AddCharTokenString(Char); break; } else { BackChar(Char); token.type = MUL; break; } default : token.type = ERRTOKEN; break; }//end of switch return token; }//end of else(不是字母和数字，就是符号) }//end of GetToken /* int main() { Token token; char fname[100]; strcpy(fname, "test.txt"); if (!InitScanner(fname)) // 初始化词法分析器 { printf("Open Source File Error ! \n"); return 0; } printf("记号类别 字符串 常数值 函数指针\n"); printf("____________________________________________\n"); while (1) { token = GetToken(); // 通过词法分析器获得一个记号 if (token.type != NONTOKEN) // 打印记号的内容 printf("%4d %12s %12f %12x\n", token.type, token.lexeme, token.value, token.FuncPtr); else break; // 源程序结束，退出循环 }; printf("____________________________________________\n"); CloseScanner(); // 关闭词法分析器 return 0; } */