编译技术课程设计A实验报告(华北电力大学科技学院)

课程设计报告( 2011-- 2012年度第1学期)名称：编译技术课程设计A 院系：科技学院信息工程系班级：软件09k2学号：0919********学生姓名：闫雪峰指导教师：郭丰娟设计周数： 2成绩：日期：2011年12 月6日《编译技术课程设计A》任务书一、目的与要求1. 理解和掌握编译程序设计原理及常用的技术，建立编译程序的整体概念；2. 理解和掌握编译程序词法分析、语法分析、语义分析、中间代码生成和目标代码生成等几个关键环节原理和实现算法；3. 掌握软件模块设计技能；熟悉并能较好地利用软件开发环境独立编程、调试和分析程序运行情况，逐渐形成创新思维和从事系统软件的研究和开发能力。

二、主要内容定义一个简化的类C语言—L语言作为源语言，重点针对词法分析、语法分析、语义分析、中间代码生成和目标代码生成等几个关键环节进行编程和调试训练，最终设计实现L语言的编译程序。

通过调试L编译程序，了解一般编译程序的总体框架，掌握编译各阶段程序的构造，理解和掌握错误处理方法及符号表的组织方式，理解和掌握语法制导翻译方法。

还可以适当扩展L语言成分，并对相应的编译程序进行扩充。

可使用C、VC++等语言编程实现。

具体内容包括：1.由单词的语法规则出发、画出识别单词的状态转换图，然后用程序实现扫描器设计。

2.设计、编写和调试算法优先分析程序，了解算法优先分析器的组成结构以及对文法的要求，掌握实现通用算法优先分析算法的方法。

3.在算符优先分析文法的基础上进行翻译工作，生成四元式表；4.设计一个简单的代码生成器，该代码生成器以基本块为单位，依次将每条中间代码变换成相应的目标代码。

5.综合以上实验的结果，并进行集成与设计，开发出一个小型编译程序。

对于各项主要内容的实现细节描述和指导，请参考《计算机综合实践指导》编译技术的相关内容。

三、进度计划四、设计（实验）成果要求至少完成简单变量定义语句及包含算术运算符的赋值语句的整个编译过程，统一使用课程设计报告书，文字清楚、工整。

五、考核方式实验结果（60％）+实验报告（30％）+实验过程表现（10％）学生姓名：指导教师：年月日一、课程设计(综合实验)的目的与要求实验整体思想：a)词法分析总体概述：由单词的语法规则出发、画出识别单词的状态转换图，然后用程序实现扫描器设计。

具体要求：设计一个扫描器，该扫描器是一个子程序，其输入是源程序字符串，每调用一次，就输出一个以内部形式表示的单词符号。

（1）单词符号及其内部表示注：其中关键字保留，不支持将关键字作为变量名。

（2）输入预处理1.词法分析器工作的第一步就是输入源程序文本。

2.预处理工作会剔除源程序中多余的空格（将多个空格换行符合并成一个）。

3.能识别//*** 这样的单行注视将其过滤掉。

4.将固定字长的过滤过字节放到循环扫缓冲区，并记录扫描位置，下次继续从上次扫描结尾继续扫描取固定字长。

5.本程序设计为255个字节，最大单个标识符长度不能超过255个字节。

（3）输入缓冲区设计扫描缓冲去一分为二。

每半个缓冲区可容纳256个字符，两个半区互补。

如果搜索指示器从单词起点出发搜索到半区边缘尚未到达单词的终点，那么就调用预处理程序，另其把后序的256个字符装进另半区(4)缓冲区中字符的存放其中如下代码在缓冲区里的存放a=b+c;（5）识别单词符号的状态装换图b)语法分析总体概述：采用自下而上规约过程，根据算符优先文法。

具体要求：设计、编写和调试算法优先分析程序，了解算法优先分析器的组成结构以及对文法的要求，掌握实现通用算法优先分析算法的方法。

（1）算符优先文法定义算符优先文法是一种自下而上的分析方法，其文法的特点是文法的产生式中不含两个相邻的非终结符。

自上而下的分析方法，通常要求文法的产生式不含左递归，如LL(I)文法就是一种可以自上而下分析的文法。

假定G是不含ε- 产生式的算符文法。

对于任何一对终结符a、b，我们说：（1）a等于b 当且仅当文法G中含有形如P→ ···ab···或P→···aQb···的产生式；（2）a小于b 当且仅当G中含有形如P→···aR···的产生式，而R(+=>)b···或R(+=>)Qb···；（3）a大于 b 当且仅当G中含有形如P→···Rb···的产生式，而R(+=>)···a或R(+=>)···aQ；如果一个算符文法G中的任何终结符对（a,b）之多满足下述三个条件之一：a=b,a<b,a>b则称G是一个算符优先文法。

(2) 文法S->D;ED->T spe L;T->keyL->varE->Evar=F;|var=F;F->M+F|M|M-FM->M*T|M|M/T|TT->L|const（3）优先表程序采用递归方式求的优先关系表（4）符号栈1.每次入站判断栈顶终结符和栈外终结符的有限关系，小于等于就入栈，大于规约2.每次规约比较靠近栈顶的第二个终结符和栈顶终结符的有限关系，若小于规约第二个终结符到栈顶。

3.每次规约查找文发表进行规约。

4.二、课程设计（综合实验）总结或结论1．1通过实验掌握了词法分析和语法分析的设计以及制导过程如何生成四元式。

1．2了解了算符优先文法的原理及具体过程。

1．3加深了c语言文件应用，加深了编程能力，深入掌握了库函数的用法。

三、参考文献[1] 陈火旺, 刘春林 编译原理. 国防工业出版社, 第三版. 2009.6附录（设计流程图、程序、表格、数据等）头文件MyHead.h#pragma once#define SBUFSIZE 256//定义扫描缓冲区的大小#define ARROPELEN 9//定义运算符数组的长度#define ARRKEYLEN 2//定义关键字数组的长度struct sBinaryRelation//返回值若为关键字或变量{int iId;//区分是什么int iSubScript;//存放操作符和关键字的偏移量，若是常量返回为常量的整型值char acTempValName[SBUFSIZE];//存放变量的值};char * apcKeyWords[]={"","int"};char apcOperator[]={' ','=','+','-','*','/','(',')',';','#'};char * apcWordList[]={"key","var","const","operate","nonTerminalSymbol","special"}; 词法分析器/*Lu语言词法分析器颜海镜 11.12.30代码已通过编译，尚未优化没次调用正确返回一个符合词法规则的单词源文件保存在.lu文件支持形如变量定义（仅支持int类型），基本加减乘除法，不支持,支持单行注视支持()可扩展：支持N个关键字，单个标识符最大支持256个字符，支持运算符扩展，支持函数名扩展int a=b+c;int a=100;//颜海镜*/#include<stdio.h>#include<stdlib.h>#include<ctype.h>#include<string.h>#include"MyHeader.h"static char acScanBufL[SBUFSIZE]={0};//扫描缓冲区static char acScanBufR[SBUFSIZE]={0};static long lnOffset=0;//偏移量，记录当前文件指针距离开头的距离char CheckChar(FILE * pfSubSourceFile,char ** ppcSubCurrent,char cSubTemp,char fcSubBlank)//检查字符功能，具有合并空格，去除回车{if(cSubTemp==EOF){return 0x20;}//判断是否到文件末尾，结束返回空格if(cSubTemp!=10&&isspace(cSubTemp))//判断是否为空格,合并多个空格为一个{if(fcSubBlank=='N'){**ppcSubCurrent=0x20;(*ppcSubCurrent)++;fcSubBlank='Y';//修改空格标志位}cSubTemp=fgetc(pfSubSourceFile);//空格的话再读入一个字符cSubTemp=CheckChar(pfSubSourceFile,ppcSubCurrent,cSubTemp,fcSubBlank);//递归检查}if(cSubTemp=='/')//判断注视{char cTemp;//临时变量，用于检查下一个是否为'/'cTemp=fgetc(pfSubSourceFile);//再读入一个字符if(cTemp=='/') //若为注视一直读入知道换行符，否则退回刚才读入的字符{while(fgetc(pfSubSourceFile)!='\n');//遇到注视，在注视结尾返回空格cSubTemp='\n';}else ungetc(cTemp,pfSubSourceFile);//退回刚才读入的字符}return cSubTemp;//返回字符}int PreProcess(char *pcSubName)//预处理子程序，完成功能每次向ScanBuffer中装入固定字长的源程序代码{static char fcFlag='L';int i;//将源程序中读入剔除空格注视等放到bufferchar * pcCurrent=0;//只是当前要赋值的字节char ** ppcCurrent=&pcCurrent;//指向指针的指针char * pcStart;//指向数组的开始，计算偏移量用char * pcTemp;//临时变量，初始化用FILE * pfSourceFile;//指向要打开的源程序文件//初始化pcCurrent确认当前要装入的缓冲区if(fcFlag=='L'){pcCurrent=acScanBufL;pcStart=acScanBufL;}else{pcCurrent=acScanBufR;pcStart=acScanBufR;}//初始化当前缓冲区为空字符pcTemp=pcCurrent;for(i=0;i<SBUFSIZE;i++){*pcTemp=0;pcTemp++;}//打开文件pfSourceFile=fopen("test.txt","r");if(pfSourceFile==NULL){printf("The file %s was not opened\n",pcSubName);//判断文件打开是否成功exit(0);//装入失败退出}else//打开成功读入{if(fseek(pfSourceFile,lnOffset,SEEK_SET))//移动文件指针到应该的位置{perror("Fseek failed");exit(1);//移动光标失败退出}while((pcCurrent-pcStart)!=SBUFSIZE)//循环读入指定长度字符{char cTemp;//临时变量cTemp=fgetc(pfSourceFile);//读入一个字符cTemp=CheckChar(pfSourceFile,ppcCurrent,cTemp,'N');//获取一个合法的字符if(cTemp==0x20){*pcCurrent=cTemp;pcCurrent++;*pcCurrent='#';//程序结束break;//判断是否到文件末尾}*pcCurrent=cTemp;//若刚才输入的不为空格也没结束则输入到缓冲区pcCurrent++;}//修改偏移量为当前偏移量，为下次读入用lnOffset=ftell(pfSourceFile);//关闭文件//修改fcFlag为下次再次装入，更改缓冲区if(fcFlag=='L') fcFlag='R';else fcFlag='L';}return 3;}int CheckOperate(char cCheck)//检查是否运算符，返回在运算符数组中的偏移量{int i;for(i=0;i<ARROPELEN;i++){if(cCheck==apcOperator[i]) return i;//返回在运算符数组中的偏移量}return 0;//不是运算符}int CheckNewLine(char cCheck,int *piSubLine)//检测字符是否为回车{if(cCheck=='\n'){(*piSubLine)++;return 1;}return 0;}int CheckKeyWords(char acCheckWords[])//检查单词是否为关键字若是返回在关键字列表中的下标，不是返回0{int i;for(i=0;i<ARRKEYLEN;i++){if(!strcmp(acCheckWords, apcKeyWords[i])) return i;}return 0;}int Error(int iSubLine)//错误处理函数，buffer质控{//打印错误信息printf("第%d行",iSubLine);lnOffset=0;//初始化文件偏移量return 0;}int CheckEndBuffer(char **ppcCheckPoint,char *pcSubName)//检测是否越界,并自动切换缓冲区，bufferL越界返回1，bufferR越界返回2，没有越界返回0{static char fcBuffer ='L';//初始化第一次扫描bufferlint iTempOffset;//临时偏移量变量fcBuffer=='L'?(iTempOffset=*ppcCheckPoint-acScanBufL):(iTempOffset=*ppcCheckPoint-acSca nBufR);//计算偏移量if(iTempOffset>=SBUFSIZE-1)//越界{{PreProcess(pcSubName);//装入Buffer*ppcCheckPoint=acScanBufR;//修改当前的指示器到下一个缓冲区的开始fcBuffer='R';//修改buffer标志，当前指针在bufferR中return 1;//bufferL越界返回1}else{PreProcess(pcSubName);//装入Buffer*ppcCheckPoint=acScanBufL;//修改当前的指示器到下一个缓冲区的开始fcBuffer='L';//修改buffer标志，当前指针在bufferL中return 2;//bufferR越界返回2}}return 0;//没有越界返回0}struct sBinaryRelation LexicalAnalyzer(char *pcSubName)//词法分析器{static char fcFirst='Y';//初始化扫描指示器为第一个元素static char *fpcStart;char **fppcStart=&fpcStart;//取fpcstart的地址static char *fpcSerching;char **fppcfpcSerching=&fpcSerching;//取fpcSerching的地址static int iLine=1;//记录当前的行数int *piLine=&iLine;//指向行数的指针struct sBinaryRelation sTempResult;//存放返回结果{PreProcess(pcSubName);fcFirst='N';fpcStart=acScanBufL;//将start和serch都指向第一个地址}while(*fpcStart==0x20){if(!CheckEndBuffer(fppcStart,pcSubName)) fpcStart++;//检查是否越界,若没越界将start 指针指向一个不为空格的字符}fpcSerching=fpcStart;//serching指向start//fpcSerching++;//serching指向start的下一个位置while(*fpcSerching!=0x00){if(CheckNewLine(*fpcStart,piLine))//检查回车，记录行数加一{//待扩建是否将\n也算作标识符fpcStart++;fpcSerching=fpcStart;//serching指向start}else if(isalpha(*fpcStart))//第一个字符是字母，为关键字{char cTempResult[SBUFSIZE]={0};char *pcCurrent=cTempResult;//检查是否为变量或关键字while(isalnum(*fpcSerching))//下一个是字符或数字//if(isspace(*fpcSerching)) break;//若为空格结束*(pcCurrent++)=*fpcSerching;//将字符保存到临时数组，并且指针后移if(!CheckEndBuffer(fppcfpcSerching,pcSubName)) fpcSerching++; //检查是否越界,若没越界将serching++}//循环完成时fpceSerching指向当前标识符的下一个位置//将start和serching重合fpcStart=fpcSerching;//返回当前的标识符放到结构体中int KeyWordScript;//关键字的下标if((KeyWordScript=CheckKeyWords(cTempResult))!=0)//检查是否为关键字还是普通变量{sTempResult.iId=0;//标志符置为0，关键字的下标sTempResult.iSubScript=KeyWordScript;sTempResult.acTempValName[0]='\0';//赋值}else//普通变量{sTempResult.iId=1;//单词为变量int i=-1;while(cTempResult[++i]!='\0')//将变量的值赋给变量名字数组{sTempResult.acTempValName[i]=cTempResult[i];}sTempResult.acTempValName[i]=cTempResult[i];//赋值个'\0'sTempResult.iSubScript=0;//赋值//返回结构体return sTempResult;}else if(isdigit(*fpcStart))//如果是数字常量{int iTemp=0;while(*fpcSerching!=0x20)//下面字符都要是数字{if((!isdigit(*fpcSerching))&&(isalpha(*fpcSerching)))//若后面是字幕或者不是操作符{printf("词法分析：");Error(iLine);//不是数字报错printf(" %d %c非法字符\n",iTemp,*fpcSerching);}iTemp=iTemp*10+int(*fpcSerching-0x30);//将数字字符转化为整形if(!CheckEndBuffer(fppcfpcSerching,pcSubName)) fpcSerching++; //检查是否越界,若没越界将serching++//判断是否是；若下一个字符是分号或者操作符就结束if(*fpcSerching==';') break;if(CheckOperate(*fpcSerching)) break;}//循环完成时fpceSerching指向当前标识符的下一个位置fpcStart=fpcSerching;//将start和serching重合//返回当前的标识符放到结构体中sTempResult.iId=2;sTempResult.iSubScript=iTemp;return sTempResult;}else if(CheckOperate(*fpcStart)) //判断运算符{int iTempOperateOffset;//记录标识符下标iTempOperateOffset=CheckOperate(*fpcStart);//不需要因为serching本来就在start的下一个fpceSerching++;if(!CheckEndBuffer(fppcStart,pcSubName)) fpcStart=++fpcSerching;//检查serching 是否越界,若没越界将start和serching重合//返回当前的标识符放到结构体中sTempResult.iId=3;sTempResult.iSubScript=iTempOperateOffset;sTempResult.acTempValName[0]='\0';//赋值return sTempResult;}else{printf("词法分析：");Error(iLine);//不是数字报错printf(" %c非法字符\n",*fpcSerching);exit(1);//退出程序}}if(*fpcSerching!=0) printf("词法分析：未知错误\n");//若不为结束符，显示未知错误exit(1);//失败返回空int DebugLexicalAnalyzer(char *pcSubName){struct sBinaryRelation sDebugResult;//存放返回结果int i;for(i=0;i<500;i++){sDebugResult=LexicalAnalyzer(pcSubName);printf("%d %d %d %s\n",i,sDebugResult.iId,sDebugResult.iSubScript,sDebugResult.acTempV alName);}return 0;}语法分析#include"MyHeader.h"#include<stdio.h>#include<string.h>#define GRAMMARLEN 14//定义问法表长度#define FIRSTTABLELEN 12//定义优先表长度#define VTLEN 10//定义vp集的长度#define STACLSIZE 100//第一堆栈大小#define NULL {1000,1000,"end"}extern struct sBinaryRelation LexicalAnalyzer(char *pcSubName);//来自lexicalanalyzer中的函数struct sQuarternaryForm //四元式数组int iOperateScript;//操作符的下标struct sBinaryRelation sArgLeft;struct sBinaryRelation sArgRight;struct sBinaryRelation sArgResult;//next;//指向下一个};struct sVp//vt集的结构体{struct sBinaryRelation sHead;//标识符struct sBinaryRelation asVt[VTLEN];//vp集};struct sStack//栈结构体{char cType;struct sBinaryRelation sPlace;};static struct sBinaryRelation aasQuarternaryForm[GRAMMARLEN][10]={{{4,0,"start"},{4,0,"define"},{3,8,""},{4,0,"operate"},NULL},//非终结符start开始符号全部归结到start程序的开始符号start->define;operate;{{4,0,"type"},{5,0,"special"},{4,0,"name"},NULL},//define->type special name{{4,0,"type"},{0,0,""},NULL},//type->key{{4,0,"name"},{1,0,""},NULL},//name->var{{4,0,"operate"},{1,0,""},{3,1,""},{4,0,"operater"},{3,8,""},{4,0,"operate"},NULL},//op erate->var=operater;operate{{4,0,"operate"},{1,0,""},{3,1,""},{4,0,"operater"},NULL},//operate->var=operater{{4,0,"operater"},{4,0,"left"},{3,2,""},{4,0,"right"},NULL},//operater->left+right{{4,0,"operater"},{4,0,"left"},{3,3,""},{4,0,"right"},NULL},//operater->left-right {{4,0,"left"},{4,0,"left"},{3,4,""},{4,0,"other"},NULL},//left->left*other{{4,0,"left"},{4,0,"left"},{3,5,""},{4,0,"other"},NULL},//left->left/other{{4,0,"left"},{4,0,"other"},NULL},//left->other{{4,0,"other"},{4,0,"name"},NULL},//other->name{{4,0,"other"},{2,0,""},NULL}//other->const};//问法定义结束static struct sBinaryRelation asFirstTableIndex[FIRSTTABLELEN]={NULL,{3,1,"="},{3,2,"+"},{3,3,"-"},{3,4,"*"},{3,5,"/"},{3,8,";"},{0,0,"key"},{1,0,"var" },{2,0,"const"},{5,0,"spe"},{3,9,"#"}};//定义优先表索引函数数组下标即为在优先表中的下标static char acFirstTable[FIRSTTABLELEN][FIRSTTABLELEN]={{'0','=','+','-','*','/',';','0','1','2','5','3'},//{'=',0},// ={'+',0},// +{'-',0},// -{'*',0},// *{'/',0},// /{';',0},// ;{'0',0},// key{'1',0},// var{'2',0},// const{'5',0},// spe{'3',0},// #};//第7 8存放var和const的优先级char RequestVt(struct sVp asVt[],int iIndex,int iVtIndex,char fcVt)//返回要求的vt集的asVt[iIndex].sHead=aasQuarternaryForm[iIndex][0];//赋值给是谁的vt值if(fcVt=='F')//求firstvt{if (aasQuarternaryForm[iIndex][1].iId==4)//Q...{if(aasQuarternaryForm[iIndex][2]!=NULL)//Qa{asVt[iIndex].asVt[iVtIndex]=aasQuarternaryForm[iIndex][2];//将a付RequestVt(asVt,iIndex,iVtIndex+1,'F');//递归调用求F（q）}else//Q{RequestVt(asVt,iIndex,iVtIndex,'F');//递归调用求F（q）}}else//a....{asVt[iIndex].asVt[iVtIndex]=aasQuarternaryForm[iIndex][1];//赋值asVt[iIndex].asVt[iVtIndex+1]=NULL;//将下一项赋值为空}return 'F';}else//求lastvt{int i=0;while(aasQuarternaryForm[iIndex][i+1]!=NUll) i++;//结束是i=....Q的下标if(aasQuarternaryForm[iIndex][i].iId==4)//...Qif(i!=1)//...aQ{asVt[iIndex].asVt[iVtIndex]=aasQuarternaryForm[iIndex][i-1];//赋值aRequestVt(asVt,iIndex,iVtIndex+1,'L');//求lastvt}else//...Q{RequestVt(asVt,iIndex,iVtIndex,'L');//求lastvt}}else//.......a{asVt[iIndex].asVt[iVtIndex]=aasQuarternaryForm[iIndex][i];//赋值aasVt[iIndex].asVt[iVtIndex+1]=NULL;//赋值NULL}return 'L';}return 'E';//出错}int RequestFirstTableScript(static struct sBinaryRelation RequestScript)//返回终结符在firsttable中的下标{int i;for(i=1;i<FIRSTTABLELEN;i++)//循环查找firsttableindex表中的每一项{if(asFirstTableIndex[i].iId==RequestScript.iId&&asFirstTableIndex[i].iSubScript==Reques tScript.iSubScript) return i;return 0;//没找到失败}int MyRequestQuarternaryFormScript(static struct sBinaryRelation RequestScript)//返回非终结符在文发表中的偏移量{int i;for(i=0;i<GRAMMARLEN;i++)//循环查找文发表{if(asFirstTableIndex[0][i]==RequestScript) return i;}return -1;//错误}int MyRequestVtLength(struct sVp RequestVtItem)//返回vt级中一项的长度{int iLength=0;while(RequestVtItem.asVt[iLength]!=NULL) iLength++;return iLength;//返回vt的长度}int CheckGrammar(char CheckChar,int iRowScript,int iLineScript)//检查优先表是否复过值从而判断问法是否正确，若未赋值返回1付过值退出{if(CheckChar==0) return 1;printf("优先表错误，非算符优先文法 %s %s 以有关系不能再有有限关系\n",asFirstTableIndex[iRowScript].acTempValName,asFirstTableIndex[iLineScript].acTempValNameexit(0);//退出return 0;}int IniFirstTable()//初始化firsttable优先表,每次规约前必须初始化{struct sVp asFirstVt[GRAMMARLEN];//firstvt的集合，每项代表一个开始符，下标和文发表兼容struct sVp asLastVt[GRAMMARLEN];//lastvt的集合int i;for(i=1;i<FIRSTTABLELEN;i++)//初始化firsttable表中的#{acFirstTable[i][FIRSTTABLELEN-1]='>';acFirstTable[FIRSTTABLELEN-1][i]='<';}acFirstTable[FIRSTTABLELEN-1][FIRSTTABLELEN-1]='=';//#和#的关系为等于for(i=0;i<GRAMMARLEN;i++)//循环求firstvt和lastvt{RequestVt(asFirstVt,i,0,'F');//求firstvtRequestVt(asLastVt,i,0,'L');//求lastvt}for(i=0;i<GRAMMARLEN;i++)//循环求优先表{int iGrammarItemLen=0;//记录每项表项长度int j;while(aasQuarternaryForm[i][iGrammarItemLen]!=NULL) iGrammarItemLen++;//求的当前表for(j=0;j<iGrammarItemLen;j++)//循环求{if(aasQuarternaryForm[i][j].iId!=4&&aasQuarternaryForm[i][j+1].iId!=4)//j和j+1都为终结符j==j+1{int ij;//j的下标int ij1;//j+1的下标ij=RequestFirstTableScript(aasQuarternaryForm[i][j]);ij1=RequestFirstTableScript(aasQuarternaryForm[i][j+1]);if(CheckGrammar(acFirstTable[ij][ij1],ij,ij1))acFirstTable[ij][ij1]='=';//有限关系相等}if((j<iGrammarItemLen-1)&&(aasQuarternaryForm[i][j].iId!=4&&aasQuarternaryForm[i][j+2]. iId!=4))//xj和xj+2都为终结符{if(aasQuarternaryForm[i][j+1]==4)//xj+1为为非终结符{int ij;//j的下标int ij2;//j+1的下标ij=RequestFirstTableScript(aasQuarternaryForm[i][j]);ij2=RequestFirstTableScript(aasQuarternaryForm[i][j+2]);if(CheckGrammar(acFirstTable[ij][ij2],ij,ij2))}}if(aasQuarternaryForm[i][j].iId!=4&&aasQuarternaryForm[i][j+1].iId==4)//xj为终结符xj+1为非终结符{int iVtIdenx;//非终结符的下标int iVtLength;//非终结符的firstvt的长度int i;iIdenx=MyRequestQuarternaryFormScript(aasQuarternaryForm[i][j+1]);//返回非终结符的在问法表中的偏移量也就是在vt中的偏移量iVtLength=MyRequestVtLength(asFirstVt[iIdenx]);for(i=0;i<iVtLength;i++)//firstvt(xj+1)的每个符号优先级大于xj{int ij;//j的下标int ij1;//j+1的下标ij=RequestFirstTableScript(aasQuarternaryForm[i][j]);//返回xj终结符在优先表中的下标ij1=RequestFirstTableScript(asFirstVt[iIdenx].asVt[i]);//返回xj+1非终结符的first中的每项在优先表中的下标if(CheckGrammar(acFirstTable[ij][ij1],ij,ij1))//判断是否优先关系已经存在{acFirstTable[ij][ij1]='<';//优先关系小于}}}if(aasQuarternaryForm[i][j].iId==4&&aasQuarternaryForm[i][j+1].iId!=4)//xj为非终结符，xj+1为终结符{int iVtIdenx;int iVtLength;int i;iIdenx=MyRequestQuarternaryFormScript(aasQuarternaryForm[i][j]);//返回非终结符的在问法表中的偏移量也就是在vt中的偏移量iVtLength=MyRequestVtLength(asLastVt[iIdenx]);for(i=0;i<iVtLength;i++)//firstvt(xj+1)的每个符号优先级大于xj{int ij;//j的下标int ij1;//j+1的下标ij=RequestFirstTableScript(asLastVt[iIdenx].asVt[i]);//返回xj终结符在优先表中的下标ij1=RequestFirstTableScript(aasQuarternaryForm[i][j+1]);//返回xj+1非终结符的first中的每项在优先表中的下标if(CheckGrammar(acFirstTable[ij][ij1],ij,ij1))//判断是否优先关系已经存在{acFirstTable[ij][ij1]='>';//优先关系小于}}}}}return 1;//初始化成功}char CheckTerminalPriority(struct sBinaryRelation sLeft,struct sBinaryRelation sRight)//返回参数的有限关系< > = 若为其他返回E{int iLeftOfFirstScript;int iRightOfFirstScript;iLeftOfFirstScript=RequestFirstTableScript(sLeft);iRightOfFirstScript=RequestFirstTableScript(sRight);if(acFirstTable[iLeftOfFirstScript][iRightOfFirstScript]=='<') return '<';if(acFirstTable[iLeftOfFirstScript][iRightOfFirstScript]=='>') return '>';if(acFirstTable[iLeftOfFirstScript][iRightOfFirstScript]=='=') return '=';return 'E';//返回错误标志}int FindStackTopTerminal(struct sStack asSubStack[],int iSubStackTop,int iSubStackBottom)//返回栈顶的终结符，返回值为栈顶终结符的下标{int i;for(i=iSubStackTop;i>=iSubStackBottom;i--)//从栈顶开始向栈底找{if(asSubStack[i].cType=='T') return i;}printf("语法分析：未知错误，搜寻栈顶终结符出错");exit(0);return -1;}int FindTermHead(struct sStack asSubStack[],int iSubTermTail,int iSubTempHead)//求规约中的规约头的栈下标{char cTempCheck;//临时存放终结符的优先关系iTempTermHead=FindStackTopTerminal(asSubStack,iSubTempHead,0);cTempCheck=CheckTerminalPriority(asSubStack[iSubTermTail],asSubStack[iTempTermHead]);//求的当前终结符和栈顶终结符的优先关系iSubTempHead=iTempTermHead-1;if(cTempCheck=='<')//若关系为小于{iTempTermHead=FindTermHead(asSubStack,iSubTermTail,iSubTempHead);//递归求下一个终结符}return iTempTermHead;}int MyFindGrammarTableHead(struct sStack asSubStack[],int iSubTermHead,int iSubTermTail)//查找可归约串若返回值小于grammar则查找成功若等于则失败，成功i为文法在文法表中的下标{int i;for(i=0;i<GRAMMARLEN;i++)//循环扫描整个文法表{if(aasQuarternaryForm[i][1]==asSubStack[iSubTermHead])//找到可规约头部{int j;int k=2;char cFlag='Y';for(j=iSubTermHead+1;j<=iSubTermTail;j++,k++)//循环查找后边是否相等{if(aasQuarternaryForm[i][k]==NULL)//若文法结束尚照完则错误cFlag='N';break;}if(asSubStack[j].cType=='N'&&aasQuarternaryForm[i][k].iId==4) continue;//若当前符号为非终结符且当前文法表中文法符号也为非终结符号规约if(asSubStack[j].sPlace==aasQuarternaryForm[i][k]) continue //若为终结符，且相等//执行到此与本条文法不相等cFlag='N';break;}if(cFlag=='Y') return i;//找到了i为下标}}return i;//失败返回grammar}int SyntacticAnalyzer(char *pcSubName)//语法分析器{struct sStack asStack[STACLSIZE]={NULL};struct sStack sTempItem=NULL;//临时存放可规约的字符int iStackTop=0;//栈顶int iStackBottom=0;//栈底int iStackTopTerminal;//栈顶的终结符//int iStackNearTopTerminal=iStackBottom;//靠近栈顶的非终结符//int iTopTerminalInFirstScript;//栈顶非终结符在firsttable中的下标//int iOutTerminalInFirstScript;//栈外终结符在firsttable中的下标//初始化符号栈栈底有个#asStack[0].cType='T';//终结符asStack[0].sPlace.iId=3;//为运算符asStack[0].sPlace.iSubScript=9;//#//iTopTerminalInFirstScript=FIRSTTABLELEN-1;//初始化top为#if(IniFirstTable())//如果初始化优先关系表成功{while(1)//规约{if(sTempItem==NULL)//判断sTempItem是否为空{struct sBinaryRelation sTemp;sTemp=LexicalAnalyzer(char *pcSubName);//从词法分析拿来一个字符if(sTemp.iId==4)//若是非终结符{sTempItem.cType='N';}else//是终结符{sTempItem.cType='T';}sTempItem.sPlace=sTemp;}//判断是否进站还是规约及如何规约进栈//RequestFirstTableScript(static struct sBinaryRelation RequestScript)char cTemp;iStackTopTerminal=FindStackTopTerminal(asStack,iStackTop,iStackBottom);cTemp=CheckTerminalPriority(asStack[iStackTopTerminal].sPlace,sTempItem.sPlace);//判断cTemp为大于小于还是等于或空if(cTemp=='<'||cTemp=='=')//若栈顶终结符优先级小于或等于栈外终结符入站{iStackTop++;//栈顶指针++asStack[iStackTop]=sTempItem;//入栈if(asStack[iStackTop].sPlace.iId==3&&asStack[iStackTop].sPlace.iSubScript==9) exit();//程序结束//初始化stemp为下次做准备sTempItem=NULL;}else if(cTemp=='>')//规约{//规约代码int iTermTail;//存放规约的尾int iTermHead;//存放规约的头//开始规约iTermTail=FindStackTopTerminal(asStack,iStackTop,iStackBottom);//找到栈顶部首个的终结符iTermHead=FindTermHead(asSubStack,iTermTail,iTermTail-1)+1;//找到有限关系小于等于栈顶终结符的下标iTermTail=iStackTop;//重新负值规约尾为栈顶//规约if(iTermHead==iTermTail)//若规约var这样只有一个符号的{//查找文发表看能否规约int i;char cFlag='N';for(i=0;i<GRAMMARLEN;i++)//循环扫描整个文法表{if(aasQuarternaryForm[i][1]==asStack[iTermHead].sPlace)//找到可规约头部{cFlag='Y';//设置i=文法表长度+1此时i为标志位若循环完毕i=grammar时可以规约break;}}if(cFlag=='Y')//可以规约{asStack[iTermHead].cType='N';//规约为非终结符}}else//非是一项规约a=b+c；这样的{//循环查找文发表找到规约地点int iTemp;iTemp=MyFindGrammarTableHead(asStack,iTermHead,iTermTail);//查找文发表查找可规约文法if(iTemp<GRAMMARLEN)//规约成功{//规约成功//调用函数知道产生四元式//调整堆栈asStack[iTermHead].cType='T';asStack[iTermHead].sPlace=aasQuarternaryForm[iTemp][0];iStackTop=iTermHead;//调整堆栈}else{//规约失败打印错误信息printf("规约过程中未在文法标中查到规约串");}}}else//优先关系为空错误{//报错printf("规约过程中有限关系出错");}}}return 0;}注：根据课程设计、综合实验的内容将标题任选其一。