词法、语法、语义分析结合

更新时间：2024-06-15 14:44:01 阅读量：综合文库文档下载

说明：文章内容仅供预览，部分内容可能不全。下载后的文档，内容与下面显示的完全一致。下载之前请确认下面内容是否您想要的，是否完整无缺。

词法、语法、语义分析结合

一、实验目的与要求

在实现词法、语法分析程序的基础上，编写相应的语义子程序，进行语义处理，加深对语法制导翻译原理的理解，进一步掌握将语法分析所识别的语法范畴变换为某种中间代码（四元式）的语义分析方法，并完成相关语义分析器的代码开发。

二、实验内容

语法制导翻译模式是在语法分析的基础上，增加语义操作来实现的。对于给定文法中的每一产生式，编写相应的语义子程序。在语法分析过程中，每当用一个产生式进行推导或归约时，语法分析程序除执行相应的语法分析动作之外，还要调用相应的语义子程序，以便完成生成中间代码、查填有关表格、检查并报告源程序中的语义错误等工作。每个语义子程序需指明相应产生式中各个符号的具体含义，并规定使用该产生式进行分析时所应采取的语义动作。这样，语法制导翻译程序在对源程序从左到右进行的一遍扫描中，既完成语法分析任务，又完成语义分析和中间代码生成方面的工作。

输入：包含测试用例，如由无符号数和+、?、*、/、(、)构成的算术表达式的源程序文件。

输出：将源程序转换为中间代码形式表示，并将中间代码序列输出到文件中。若源程序中有错误，应指出错误信息。

三、一般实现方法

语法制导翻译模式实际上是对前后文无关文法的一种扩展。一般而言，首先需要根据进行的语义工作，完成对文法的必要拆分和语义动作的编写，从而为每个产生式都配备相应的语义子程序，以便在进行语法分析的同时进行语义解释。要求从编译器的整体设计出发，重点通过对实验二中语法分析程序的扩展，完成一个编译器前端程序的编写、调试和测试工作，形成一个将源程序翻译为中间代码序列的编译系统。

四、基本实验题目

题目：对文法G3[<算术表达式>]中的产生式添加语义处理子程序，完成无符号数的四则运算的计值处理，将输入的四则运算转换为四元式形式的中间代码。本实验只进行了算术表达式四元式的翻译。

五、源代码

*****************************词法分析.h# include # include # include # include # include

# define UNKNOWN -1 # define LB 0//左括号 # define RB 1//右括号

# define PL 2

文件

# define MI 3 # define MU 4 # define DI 5

# define UCON 6 //Suppose the class number of unsigned constant is 7 # define OVER 7

//# define INT 7 # define LT 8 # define LE 9 # define EQ 10 # define NE 11 # define GT 12 # define GE 13

# define IS 19//14至18被五个关键字占用 # define ID 20

#define MAX_KEY_NUMBER 20 /*关键字的数量*/

#define KEY_WORD_END \ /*关键字结束标记*/ char *KeyWordTable[MAX_KEY_NUMBER]={\KEY_WORD_END};

char TOKEN[20]=\存储已扫描的单词 char ch=' ';//用于存储带判断的字符 int row=1;//row标识错误在第几行

//无符号数部分 #define DIGIT 1 #define POINT 2 #define OTHER 3 #define POWER 4 #define PLUS 5 #define MINUS 6

#define ClassOther 200 #define EndState -1

int index=0;//保存已读的字符串的索引 //char JudgeStr[256];//存储已读的字符串 int w,n,p,e,d;

int Class; //Used to indicate class of the word int ICON; float FCON;

static int CurrentState; //Used to present current state, the initial value:0

///////语法分析部分

//产生式

/* 1、E->E+T 2、E->E-T 3、E->T 4、T->T*F 5、T->T/F 6、T->F 7、F->(E) 8、F->i */

# define SMAX 256 //goto表的列项 # define E 0 # define T 1 # define F 2

int StateStack[SMAX];//状态栈 int StackPoint;//状态栈指针

int TopState;//作为状态栈盏栈顶指针 int InputWordType;//输入的单词类型 // ( ) + - * / i #

char Action[16][8][4]={\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \表

// E T F int Goto[16][3]={ { 1, 2, 3}, {-1, -1, -1}, {-1, -1, -1}, {-1, -1, -1}, {10, 2, 3}, {-1, -1, -1}, {-1, 11, 3}, {-1, 12, 3}, {-1, -1, 13},

{-1, -1, 14}, {-1, -1, -1}, {-1, -1, -1}, {-1, -1, -1}, {-1, -1, -1}, {-1, -1, -1}, {-1, -1, -1},};//goto表

//语义分析部分

#define PMAX 5//define 后面不加括号，定义产生式符号属性字符串的长度

int NXQ=0; /*全局变量NXQ用于指示所要产生的下一个四元式的编号*/ int NXTemp=1;//整型变量NXTemp指示临时变量的编号 int SentenceCount=1;//存放文件中句子的个数

struct QUATERNION /*四元式表的结构*/ {

char op[PMAX]; /*操作符*/

char arg1[PMAX]; /*第一个操作数*/ char arg2[PMAX]; /*第二个操作数*/ char result[PMAX]; /*运算结果*/ }pQuad[256]; /*存放四元式的数组*/

char EBracket_Place[PMAX];//(E)的语义属性 char i_Place[PMAX]; char E_Place[PMAX]; char T_Place[PMAX]; char F_Place[PMAX];

//char JudgeStr[100];

int EXCUTE (int state, int symbol,FILE *fp,char JudgeStr[],int row,int index); int GetChar (char ch);

int HandleError (char StrJudge[],int row); int Push( int State ); int Pop(int count);

int SLRControl(FILE* fp);

void GEN(char *Op, char *Arg1, char *Arg2, char *Result); char *NewTemp(void);

void NextSentence(FILE* fp);//当语法或者词法产生错误的时候，跳过当前错误的句子，将文件指针指向下一个句子的开始

*****************************词法分析.c

文件

#include \词法分析.h\

//////////////////////////////////////////////////查保留字表，判断是否为关键字 int lookup (char *token) {

int n=0;

while (strcmp(KeyWordTable[n], KEY_WORD_END)) /*strcmp比较两串是否相同，若相同返回0*/ { if (!strcmp(KeyWordTable[n], token)) /*比较token所指向的关键字和保留字表中哪个关键字相符*/ { return n+1; /*根据单词分类码表I，设置正确的关键字类别码，并返回此类别码的值*/ break; } n++; }

return 6; /*单词不是关键字，而是标识符*/ }

///////////////////////////////////////////////////输出分析结果 void out (int i, char* pStr) {

char Mnemonic[5]; if(0==i) { strcpy(Mnemonic,\ }

else if(1==i) { strcpy(Mnemonic,\ }

else if(2==i) { strcpy(Mnemonic,\ }

else if(3==i) { strcpy(Mnemonic,\ }

else if(4==i) { strcpy(Mnemonic,\ }

else if(5==i) { strcpy(Mnemonic,\}

else if(6==i) { strcpy(Mnemonic,\}

else if(7==i) { strcpy(Mnemonic,\}

else if(8==i) { strcpy(Mnemonic,\}

else if(9==i) { strcpy(Mnemonic,\}

else if(10==i) { strcpy(Mnemonic,\}

else if(11==i) { strcpy(Mnemonic,\}

else if(12==i) { strcpy(Mnemonic,\}

else if(13==i) { strcpy(Mnemonic,\}

else if(14==i) { strcpy(Mnemonic,\}

else if(15==i) { strcpy(Mnemonic,\}

else if(16==i) { strcpy(Mnemonic,\ }

else if(17==i) { strcpy(Mnemonic,\ }

else if(18==i) { strcpy(Mnemonic,\ }

else if(19==i) { strcpy(Mnemonic,\ }

else if(20==i) { strcpy(Mnemonic,\ } else { strcpy(Mnemonic,\ }

printf(\ )对应 %s\\n\}

/////////////////////////////////////////////////报错 void report_error (int row) {

printf(\ 无法识别的单词! In the %d row\\n\}

/////////////////////////////////////////////////////////////扫描程序

void scanner(FILE *fp)//总的判断函数开始就应该判断已读取的字符是否为空字符，不为则不用再读，直接进行判断，否则再读 {

//printf(\ int i, c;

fseek(fp,-1,1);//首先回溯一个字符，就是将文件所有的字符都在scanner内部判断，外部while循环不会浪费任何字符

ch=fgetc (fp);//scanner中要想判断字符，必须开头先读一个字符 while(' '==ch||'\\n'==ch||'\\t'==ch)//将文件中的所有空字符浪费在这里 { if('\\n'==ch)

{ row++; } ch=fgetc (fp); }

if(EOF==ch) { return;

}//必须在这里判断一下 /*if(' '==ch||'\\n'==ch||'\\t'==ch) { fseek(fp,-1,1); return; }*/ //ch=fgetc (fp); /*if(' '==ch||'\\n'==ch||'\\t'==ch) { fseek(fp,-1,1); return;//文件结束标志不能与这几个空白符作为一种情况考虑，因为文件遇到结束标志时，不能回退 }//文件指针，否则在外层的while循环中造成死循环，由此猜测fgetc函数执行的过程为，先读取 */ //当前文件指针所指的字符，再将字符指针后移！

if (isalpha (ch)) /*it must be a identifer!*/ { TOKEN[0]=ch; ch=fgetc (fp); i=1; while (isalnum (ch)) { TOKEN[i]=ch; i++; ch=fgetc (fp); } TOKEN[i]= '\\0'; fseek(fp,-1,1); /* retract*/ c=lookup (TOKEN); if (c!=6) out (c+13,TOKEN); else out (c+14,TOKEN);//此处加13或者14因为一些常量的定义产生冲突，被迫修改以适应 }

else if(isdigit(ch)|| '.'==ch) { fseek (fp,-1,1);//首先回溯一个字符，下面为了循环内部使用先读字符后判

断的格式。 int Type;

CurrentState=0; i=0; do { ch=fgetc(fp); TOKEN[i]=ch; i++; TOKEN[i]='\\0';//为随时输出字符串做准备 Type=GetChar(ch); EXCUTE (CurrentState,Type,fp,TOKEN,row,i); }while(CurrentState!=EndState); /*TOKEN[0]=ch; ch=fgetc(fp); i=1; while(isdigit(ch)) { TOKEN[i]=ch; i++; ch=fgetc(fp); } TOKEN[i]= '\\0'; fseek(fp,-1,1); out(INT,TOKEN);*/

} else

switch(ch) { case '<': ch=fgetc(fp); if(ch=='=')out(LE,\ else if(ch=='>') out (NE,\ else { //fseek (fp,-1,1); out (LT,\ } break; case '=': { ch=fgetc(fp); if('='==ch) { out(EQ, \ } else

{ //fseek (fp,-1,1); out(IS, \ } } break;

case '>': ch=fgetc(fp); if(ch=='=')out(GE,\ else { //fseek(fp,-1,1); out(GT,\ } break; case '+': { InputWordType=PL; out(PL,\ } break; case '-': { InputWordType=MI; out(MI,\ } break; case '*': { InputWordType=MU; out(MU,\ } break; case '/': { InputWordType=DI; out(DI,\ } break; case '(': { InputWordType=LB; out(LB,\ } break;

case ')': { InputWordType=RB; out(RB,\ } break; case '#': { InputWordType=OVER; out(OVER,\ } break; default: { InputWordType=UNKNOWN; report_error(row); }break; }

return; }

///////////////////////////////////无符号数判断矩阵执行程序

int EXCUTE (int state, int symbol,FILE *fp,char JudgeStr[],int row,int index)

{//row用于指示出错的行数，index用于为待输出的字符串赋结束符‘\\0’时用 switch (state) {

case 0:switch (symbol) {

case DIGIT: n=0;p=0;e=1;w=d;CurrentState=1;Class=UCON;break; case POINT: w=0;n=0;p=0;e=1;CurrentState=3;Class=UCON;break; default: { Class=ClassOther;

CurrentState=EndState; InputWordType=UNKNOWN; printf(\无符号数的第一个字符是非法的！\\n\ } }

break;

case 1:switch (symbol) {

case DIGIT: w=w*10+d;break; //CurrentState=1 case POINT: CurrentState=2;break;

case POWER: CurrentState=4;break; default: { if (ch!=EOF)//如果是因为读到文件结束字符而终止识别（是正确识别一个无符号数结束），就不应该回退，否则可能造成死循环 { fseek(fp,-1,1);//遇到其他的字符，可能是一条语句中的其他字符，需后退，因为主函数外层循环每次都要读一个字符进行判断，而这个判读不回溯，所以在内部把这个多读的字符回溯 } ICON=w;CurrentState=EndState; JudgeStr[index-1]='\\0'; InputWordType=UCON; printf(\对应 %s\\n\ }break; }

break;

case 2:switch (symbol) {

case DIGIT: n++;w=w*10+d;break; case POWER: CurrentState=4;break; default: { if (ch!=EOF) { fseek(fp,-1,1); } FCON=w*pow(10,e*p-n);CurrentState=EndState; JudgeStr[index-1]='\\0'; InputWordType=UCON; printf(\对应于 %s\\n\ } }

break;

case 3:switch (symbol) {

case DIGIT: n++;w=w*10+d;CurrentState=2;break; default: { /* if (ch!=EOF)//识别无符号数产生错误时，不应该再回溯，应该把造成错误的那个字符算到错误的无符号数字符串中，再向下面识别单词时跳过这个字符，不回溯就能达到这个目的

{ fseek(fp,-1,1); }*/ InputWordType=UNKNOWN; HandleError(JudgeStr,row);CurrentState=EndState; } }

break;

case 4:switch (symbol) {

case DIGIT: p=p*10+d;CurrentState=6;break; case MINUS: e=-1;CurrentState=5;break; case PLUS: CurrentState=5;break; default: { /* if (ch!=EOF) { fseek(fp,-1,1); }*/ InputWordType=UNKNOWN; HandleError(JudgeStr,row);CurrentState=EndState; } }

break;

case 5:switch (symbol) {

case DIGIT: p=p*10+d;CurrentState=6;break; default: { /* if (ch!=EOF) { fseek(fp,-1,1); }*/ InputWordType=UNKNOWN; HandleError(JudgeStr,row);CurrentState=EndState; }//判断一个无符号数的最后一个字符应该都是多余读取的，所以为了防止引起后面再次判断下一无符号数时产生呑字符的现象，都应该回溯一个字符

}

break;

case 6:switch (symbol) {

case DIGIT:p=p*10+d;break; default:

{ if (ch!=EOF) { fseek(fp,-1,1); } FCON=w*pow(10,e*p-n);CurrentState=EndState; JudgeStr[index-1]='\\0'; InputWordType=UCON; printf(\对应 %s\\n\ }break; }

break; }

return CurrentState; }

////////////////////////////////无符号数判断过程中的字符类型判断程序 int GetChar (char ch) {

if(isdigit(ch)) {d=ch-'0';return DIGIT;} if (ch=='.') return POINT;

if (ch=='E'||ch=='e') return POWER; if (ch=='+') return PLUS; if (ch=='-') return MINUS; return OTHER; }

/////////////////////////////判断出错报错程序 int HandleError (char StrJudge[],int row) {

printf (\不合法的无符号数!\\n\ return 0; }

/////////////////////////////////////语法分析程序 int SLRControl(FILE* fp) {

while(Action[TopState][InputWordType][0] != 'A') { if (UNKNOWN==InputWordType) { printf(\分析语句 %i 时词法分析出错******************\\n\ return 0; }

printf(\栈顶状态：%i\\n\

printf(\扫描的单词类型：%i\\n\ /*if ('A'==Action[State][WordType][0]) { TopState=0;//正确后把栈顶状态置为初始化 StackPoint=0;//同理上面 memset(StateStack,-1,sizeof(StateStack)); printf(\ return 1; }*/

if (-1==TopState) { printf(\分析语句 %i 时状态栈栈顶指针错误！分析结束\\n\ return 0; }

if (' ' == Action[TopState][InputWordType][0]) { printf(\分析语句 %i 时语法分析出错！分析结束\\n\ return 0; }

else if('s'==Action[TopState][InputWordType][0]) { //TopState=atoi(&Action[TopState][InputWordType][1]); Push(atoi(&Action[TopState][InputWordType][1])); printf(\执行压栈操作\\n\ if (EOF!=fgetc(fp)) { scanner(fp); } else { printf(\语句 %i 不完整！分析结束\\n\ return 0; } }

else if('r'==Action[TopState][InputWordType][0]) { //do//用一个while循环为了可能遇到连续规约的情况，即从文件中扫描一个单词之后，可能连续规约多次 //{

int ProductionNum=atoi(&Action[TopState][InputWordType][1]); int ProdutionLeft=0; if (1==ProductionNum) { ProdutionLeft=E;//为下面差goto表提供列坐标 Pop(3); printf(\用产生式 1 归约\\n\ char* Temp=NewTemp(); GEN(\ strcpy(E_Place,Temp); printf(\生成四元式：(“+”，E_Place，T_Place，E_Place)\\n\ }

else if(2==ProductionNum) { ProdutionLeft=E; Pop(3); printf(\用产生式 2 归约\\n\ char* Temp=NewTemp(); GEN(\ strcpy(E_Place,Temp); printf(\生成四元式：(“-”，E_Place，T_Place，E_Place)\\n\ }

else if(3==ProductionNum) { ProdutionLeft=E; Pop(1); printf(\用产生式 3 归约\\n\ char* Temp=NewTemp(); GEN(\ strcpy(E_Place,Temp); printf(\生成四元式：(-，-，T_Place，E_Place)\\n\ }

else if(4==ProductionNum) { ProdutionLeft=T; Pop(3); printf(\用产生式 4 归约\\n\ char* Temp=NewTemp(); GEN(\ strcpy(T_Place,Temp); printf(\生成四元式：(“*”，T_Place，F_Place，T_Place)\\n\ }

else if(5==ProductionNum) {

ProdutionLeft=T; Pop(3); printf(\用产生式 5 归约\\n\ char* Temp=NewTemp(); GEN(\ strcpy(T_Place,Temp); printf(\生成四元式：(“/”，T_Place，F_Place，T_Place)\\n\ } else if(6==ProductionNum) { ProdutionLeft=T; Pop(1); printf(\用产生式 6 归约\\n\ char* Temp=NewTemp(); GEN(\ strcpy(T_Place,Temp); printf(\生成四元式：（-，-，F_Place，T_Place）\\n\ } else if(7==ProductionNum) { ProdutionLeft=F; Pop(3); printf(\用产生式 7 归约\\n\ char* Temp=NewTemp(); GEN(\ strcpy(F_Place,Temp); printf(\生成四元式：(-，-，(E)_Place，F_Place)\\n\ } else if(8==ProductionNum) { ProdutionLeft=F; Pop(1); printf(\用产生式 8 归约\\n\ char* Temp=NewTemp(); GEN(\ strcpy(F_Place,Temp); printf(\生成四元式：(-，-，i_Place，F_Place)\\n\ } else { printf(\分析语句 %i 时产生式编号超出范围！分析结束\\n\ return 0; }

Push(Goto[TopState][ProdutionLeft]); // }while('r' == Action[TopState][InputWordType][0]) } }

printf(\栈顶状态：%i\\n\

printf(\扫描的单词类型：%i\\n\

printf(\语句 %i 正确*********************************\\n\ return 1; }

/////////////////////////////////状态栈的压栈和出栈程序 int Push( int State ) {

if (SMAX==StackPoint) { printf(\状态栈已满！\ return 0; }

StateStack[StackPoint]=State; StackPoint++;

TopState=State;//用topstate存储当前栈顶状态 return 1; }

int Pop(int count) //内部要把处理完的数组的顶部的值赋给topstate {

StackPoint=StackPoint-count; if (StackPoint<0) { printf(\状态栈指针不能为负值！\ return 0; }

TopState=StateStack[StackPoint-1]; return 1; }

//////////////////////////////////////语法分析部分