编译程序实验指导书解讲．编译程序实验指导书实验目的：用C语言对一个C语言的子集编制一个一遍扫描的编译程序，以加深对编译原理的理解，掌握编译程序的实现方法和技术。

1．词法分析1.1 实验目的设计、编制并测试一个词法分析程序，加深对词法分析原理的理解。

1.2 实验要求1.2.1 待分析的C语言子集的词法1. 关键字main if else int char for while所有的关键字都是小写。

2．专用符号= + - * / < <= > >= == != ; : , { } [ ] ( )3．其他标记ID和NUM通过以下正规式定义其他标记：→letter(letter|digit)*ID→digit digit*NUMletter→a|…|z|A|…|Zdigit→0|…|9…4．空格由空白、制表符和换行符组成空格一般用来分隔ID、NUM、专用符号和关键字，词法分析阶段通常被忽略。

1.2.2 各种单词符号对应的种别码表1 各种单词符号的种别码单词符号种别码单词符号种别码单词符号种别码main 1 = 21 , 32int 2 + 22 : 33char 3 - 23 ; 34if 4 * 24 > 35else 5 / 25 < 36for 6 ( 26 >= 37while 7 ) 27 <= 38ID 10 [ 28 == 39MUN 20 ] 29 != 40{ 30 ‘\0' 1000} 31 ERROR -11.2.3 词法分析程序的功能输入：所给文法的源程序字符串。

输出：二元组（syn,token或sum）构成的序列。

其中，. syn为单词种别码。

. Token为存放的单词自身字符串。

. Sum为整型常量。

具体实现时，可以将单词的二元组用结构进行处理。

例如，对源程序main(){int i=10;while(i) i=i-1;}的源文件，经词法分析后输出如下序列：(1,main) (26,() (27,)) (30,{} (2,int) (10,i) (21,=) (20,10) (34,;) (7,while) (26,() (10,i) (27,)) (10,i) (21,=) (10,i) (23,-) (20,1) (34,;) (31,))1.3 词法分析程序的主要算法思想算法的基本任务是从字符串表示的源程序中识别出具有独立意义的单词符号，其基本思想是根据扫描到的单词符号的第一个字符的种类，拼出相应的单词符号。

1. 主程序示意图主程序示意图如图1所示。

置初值调用扫描子程序输出单词二元组否输入串结束是结束图1 词法分析主程序示意图其中初值包括如下两方面：(1)关键字表初值关键字作为特殊标识符处理,把它们预先安排在一张表格中(称为关键字表),当扫描程序识别出标识符时,查关键字表。

如能查到匹配的单词，则该单词为关键字，否则为一般标识符。

关键字表为一个字符串数组，其描述如下：char *KEY_WORDS[8]={“main”,”int”,”char”,”if”,”else”,”for”,”while”}；为分析方便，这里把main作关键字处理。

(2) 程序中需要用到的主要变量：syn,token和sum。

2. 扫描子程序的算法思想首先设置三个变量：token用来存放构成单词符号的字符串；sum用来存放整型单词；syn用来存放单词符号的种别编码。

扫描子程序主要部分流程如图2所示。

变量初始忽略空返是否文件结运算字数其他符符等符拼字符拼是否关键对不同符号给相应sySyn=10Syn为对应关键报错Syn=11字的单词种别码返回图2 词法分析程序流程2．语法分析2.1 实验目的编制一个递归下降分析程序，实现对词法分析程序所提供的单词序列进行语法检查和结构分析。

2.2 实验要求利用C语言编制递归下降分析程序，并对C语言的简单子集进行分析。

2.2.1 待分析的C语言子集的语法用扩充的BNF表示如下：>语句块=main( )<∷>程序(1) <(2) <语句块>∷='{'<语句串>'}'(3) <语句串>∷=<语句>{;<语句>};(4) <语句>∷=<赋值语句>|<条件语句>|<循环语句>(5) <赋值语句>∷=ID=<表达式>(6) <条件语句>∷=if(<条件>)<语句块>(7) <循环语句>∷=while<条件><语句块>(8) <条件>∷=<表达式><关系运算符><表达式>(9) <表达式>∷=<项>{+<项>|-<项>}(10)<项>∷=<因子>{*<因子>|/<因子>}(11)<因子>∷=ID|NUM|(<表达式>)(12)<关系运算符>∷=<|<=|>|>=|==|!=2.3 语法分析程序的算法思想(1)主程序示意图如图3所示。

置初值读下一个单词符号调用scanerlrparser 调用结束3 语法分析主程序示意图图所示。

递归下降分析程序示意图如图4(2) lrparser否否main() 是否单词串是scaner 调用出错处理调用语句块分析函数否源程序是否结束是打印分析成功图4递归下降分析程序示意图(3)语句块分析过程示意图如图5所示。

{是否是scaner调用出错处调用语句串分析过程否}是否是出口5语句块分析示意图图6(4)所示。

语句串分析过程示意图如图statement函数调用否否是否；是scaner 调用调用statement函数出错处理语句串分析示意图图6函数流程如图7所示；) (5)statement (语句所示；（表达式）分析过程如图(6)expression8 （项）分析过程如图9所示；term(7)所示；10（条件）分析过程如图condition(8)．(9)factor（因子）分析过程如图11所示。

while是是否标识是if是scanerscaner调scaner调调用否=是condition调condition调用是调用语句调用语句块scaner调用expression 出错处理调用7 statement函数流程图factor 调用term 调用否否/ 是否*、-、是否+是是scaner 出错处理调用出错处理调用scanerfactor 调用term调用分析过程示意图图9 term 图8 expression分析过程示意图expression 调用否是否逻辑运算符是出错处理scaner 调用expression调用．分析过程示意图10 condition是是否标识符否是是否数字否是否（调用expression调用scanerscaner调用否是否）是出错处理scaner调用分析过程示意图11 factor图．语义分析产生中间代码3实验目的3.1通过上机实验，加深对语法制导翻译原理的理解，掌握将语法分析所识别的语法成分变换为中间代码的语义翻译方法。

实验要求3.2采用递归下降语法制导翻译法对算术表达式、赋值语句、条件语句、循环语句进行语义分析生成四元式序列。

实验的输入和输出3.2.1输入是语法分析提供的正确的单词串，输出是四元式序列。

例如，对于语句串i=2*3+4;if (i>10) j=3;while j>10 k=1;输出的四元式序列如下：(*,2,3,T1) (1)(+,2,T1,T2) (2)(=,T2, ,i) (3)(j>,i,10,6) (4)(j<, , ,7)) (5)(=,3, ,j) (6)(j<,j,10,9) (7)(j, , ,11) (8)(=,1, ,k) (9)(10)(j, , ,7)(11) ......算法思想3.2.2设置语义过程1.(1). int gen(op,arg1,arg2,result)送到四元式表中。

(op,arg1,arg2,result)该函数是将四元式(2). char *newtemp( )T1,T2,.... 该函数回送一个新的临时变量名，临时变量名产生的顺序为(3). int merg(p1,p2) p2为头指针的两条链合并为一，合并后的链首为返回值。

p1该函数将以和(4). int bp(p,t) t。

所链接的每个四元式的第四区段都填为该函数的功能是把p 主程序示意图 2.置初值scaner调用…lrparser调用打印四元式列表结束语义分析主程序示意图图123.函数lrparser在原来语法分析的基础上插入相应的语义动作语句进行翻译，将输入串翻译成四元式序列。

在实验中我们只对表达式、if语句和while 其具体翻译程序见实验实例。

．实验实例4/****************************************************/globals.h *//*文件：定义分析器需要的一些数据结构、宏等*//* */ 本头文件必须在其他文件前引用/*/***************************************************/# ifndef _GLOBALS_H# define _GLOBALS_H# include <stdio.h># include <stdlib.h># include <string.h>*/单词种别码/*1 # define _SYN_MAIN2 # define _SYN_INT3 # define _SYN_CHAR4 # define _SYN_IF5 # define _SYN_ELSE6 # define _SYN_FOR7# define _SYN_WHILE*/ /*以上为关键字的单词种别码# define _SYN_ID 10 /*标识符的单词种别码*//*整数的单词种别码*/ # define _SYN_NUM 20# define _SYN_ASSIGN /* = */ 21# define _SYN_PLUS /* + */ 22# define _SYN_MINUS 23 /* -*/# define _SYN_TIMES 24 /* * */# define _SYN_DIVIDE 25 /* / */# define _SYN_LPAREN 26 /* ( */# define _SYN_RPAREN/* ) */ 27# define _SYN_LEFTBRACKET1 28 /* [ */# define _SYN_RIGHTBRACKET1 29 /* ] */# define _SYN_LEFTBRACKET2 30 /* { */# define _SYN_RIGHTBRACKET2 /* } */ 31# define _SYN_COMMA /* , */ 32/* : */ 33 # define _SYN_COLON# define _SYN_SEMICOLON /* ; */3435 /* > */ # define _SYN_LG36 /* < */ # define _SYN_LT37 /* >= */ # define _SYN_ME38 /* <= */ # define _SYN_LE39 /* == */ # define _SYN_EQ40 # define _SYN_NE /* != */1000 */ # define _SYN_END 源程序结束标志/*# define _SYN_ERROR -1/* error *//* # define MAXLENGTH 255 一行允许的字符个数*//*存放单词内容的联合union WORDCONTENT { */ char T1[MAXLENGTH];int T2;char T3;};*/ typedef struct WORD { /*单词二元组int syn;union WORDCONTENT value;} WORD;# endif/**************************************************/scan.h */文件：/*/*定义词法分析器的接口*//**************************************************/# ifndef _SCAN_H# define _SCAN_H/* 一个TAB占用的空格数*/# define _TAB_LENGTH 4*/ /* 关键字结束标记waiting for your expanding# define _KEY_WORD_END*/得到源程序里的下一个单词符号/* 函数Scanervoid Scaner(void);# endif/**************************************************/scan.c */ /*文件：分析器的词法扫描部分*//*/**************************************************/# include globals.h# Include scan.h*/ 识别标识符的中间状态void Do_Tag(char *strSource); /**/ /* 识别数字的中间状态void Do_Digit(char *strSource);*/ /* void Do_EndOfTag(char *strSource); 识别标识符最后的一个状态*/ /* void Do_EndOfDigit(char *strSource); 识别数字最后的一个状态void Do_EndOfEqual(char *strSource); /* =,== *//* + */ void Do_EndOfPlus(char *strSource);void Do_EndOfSubtraction(char *strSource); /* -*/void Do_EndOfMultiply(char *strSource); /* * */void Do_EndOfDivide(char *strSource); /* / */void Do_EndOfLParen(char *strSource); /* ( */void Do_EndOfRParen(char *strSource); /* ) */void Do_EndOfLeftBracket1(char *strSource); /* [ */void Do_EndOfRightBracket1(char *strSource); /* ] */void Do_EndOfLeftBracket2(char *strSource); /* { */void Do_EndOfRightBracket2(char *strSource); /* } *//* : */ void Do_EndOfColon(char *strSource);void Do_EndOfComma(char *strSource); /* , */void Do_EndOfSemicolon(char *strSource); /* ; *//* >,>= */ void Do_EndOfMore(char *strSource);/* <,<= */void Do_EndOfLess(char *strSource);' \0 ' 用/* 作为源程序结束void Do_EndOfEnd(char *strSource); */ void PrintError(int nColumn,int nRow,char chInput);/* 词法分析错误输出*/*/词法扫描函数/* ；void Scaner(void)extern char *strSource; /* 待分析的源程序*//* 结果输出文件*/extern FILE *fw ;/* 行列号*/int gnColumn,gnRow,/* 下一个字符脚标gnLocate, *//* 下一个单词开始位置*/ gnLocateStart;/* 扫描出的单词*/Word uWord;*/ /* 关键字表char*KEY_WORDS[20]={main,int,char,if,else,or,while,void,_KEY_WORD_END};int IsDigit(char chInput) /* 判断扫描的字符是否数字*/{if (chInput<='9' && chInput>='0') return 1;else return 0;}*/ int IsChar(char chInput) 判断扫描的字符是否字母/*{if ((chInput<='z' && chInput>='a')|| (chInput<='Z' && chInput>='A'))return 1;else return 0;}*/ void Do_Start(char *strSource) /* 开始识别最先一个单词{gnLocateStart=gnLocate;*/根据第一个字符判断/* switch (strSource[gnLocate]) {break; case '+': Do_EndOfPlus(strSource);case '-': Do_EndOfSubtraction(strSource); break;case '*': Do_EndOfMultiply(strSource); break;case '/': Do_EndOfDivide(strSource); break;break; case '(': Do_EndOfLParen(strSource);case ')': Do_EndOfRParen(strSource); break;case '[': Do_EndOfLeftBracket1(strSource); break;case ']': Do_EndOfRightBracket1(strSource); break;case '{': Do_EndOfLeftBracket2(strSource); break;break;case '}': Do_EndOfRightBracket2(strSource);case ':': Do_EndOfColon(strSource); break;case ',': Do_EndOfComma(strSource); break;case ';': Do_EndOfSemicolon(strSource); break;break; case '>': Do_EndOfMore(strSource);case '<': Do_EndOfLess(strSource); break;case '=': Do_EndOfEqual(strSource); break;case '\0': Do_EndOfEnd(strSource); break;default:*/ /* if (IsChar(strSource[gnLocate])) { 是标识符或关键字Do_Tag(strSource); }*/ else if (IsDigit(strSource[gnLocate])) { /* 可能是整数uWord.value.T2=strSource[gnLocate]-'0';Do_Digit(strSource);*/其他符号/* else {if (strSource[gnLocate]!=' ' && strSource[gnLocate]!='\t'&& strSource[gnLocate]!=' \n' && strSource[gnLocate]!='\r'] {PrintError(gnColumn,gnRow,strSource[gnLocate]);}if (strSource[gnLocate]=='\n ' || strSource[gnLocate}=='\r') { gnColumn++;gnRow=1;}else if (strSource[gnLocate]=='\t') {gnColumn+=_TAB_LENGTH;}else gnRow++;gnLocate++;Do_Start(strSouce);}break;}return;}void Do_Tag(char *strSource) */识别标识符的中间状态/*{gnLocate++;gnRow++;if (IsChar(strSource[gnLocate]) || IsDigit(strSource[gnLocate])) {*/ /* 是数字或者字母Do_Tag(strSource);}else Do_EndOfTag(strSource);return;}void Do_Digit(char *strSource) /* 识别整数的中间状态*/gnLocate++;gnRow++;/* 是数字if (IsDigit(strSource[gnLocate])) { */uWord.value.T2=uWord.value.T2*10+strSource[gnLocate]-'0';累加识别的数字*//*Do_Digit(strSource);}else Do_EndOfDigit(strSource);return;}/* void Do_EndOfTag(char *strSource) 标识符的最后状态*/{int nLoop;/* 单词种别码缺省为标识符uWord.syn=_SYN_ID; */*//* 记录标识符strncpy(uWord.value.T1,strSource+gnLocateStart,gnLocate-gnLocateStart);uWord.value.T1[gnLocate-gnLocateStart]='\0';nLoop=0;while (strcmp(KEY_WORDS[nLoop],_KEY_WORD_END)) {/* 查关键字表，是否关键字*/if (! strcmp(KEY_WORDS[nLoop],uWord.value.T1)) {*/比较和某关键字相符/*syn */设置正确的uWord.syn=nLoop+1; /*break;}nLoop++;}return;}*/void Do_EndOfDigit(char *strSource) 识别数字的最后状态/*{uWord.syn=_SYN_NUM;return;}/* =,== */void Do_EndOfEqual(char *strSource){/* = */ if (strSource[gnLocate+1]!='=') { uWord.syn=_SYN_ASSIGN;uWord.value.T3=strSource[gnLocate];}else { /* == */gnLocate++;gnRow++;uWord.syn=_SYN_EQ;strcpy(uWord.value.T1,==);}gnLocate++;gnRow++;return;}void Do_EndOfPlus(char *strSource) /* + */ {uWord.syn=_SYN_PLUS;uWord.value.T3=strSource[gnLocate];gnLocate++;gnRow++;return;}/* - */void Do_EndOfSubtraction(char *strSource) {uWord.syn=_SYN_MINUS;uWord.value.T3=strSource[gnLocate];gnLocate++;gnRow++;return;}/* * */ void Do_EndOfMultply(char *strSource){uWord.syn=_SYN_ TIMES;uWord.value.T3=strSource[gnLocate];gnLocate++;gnRow++;return;}void Do_EndOfDivide(char *strSource) /* / */ {uWord.syn=_SYN_DIVIDE;uWord.value.T3=strSource[gnLocate];gnLocate++;gnRow++;return;}/* ( */void Do_EndOfLParen(char *strSource) {uWord.syn=_SYN_LPAREN;uWord.value.T3=strSource[gnLocate];gnLocate++;gnRow++;return;}/* ( */void Do_EndOfRParen(char *strSource){uWord.syn=_SYN_RPAREN;uWord.value.T3=strSource[gnLocate];gnLocate++;gnRow++;return;}/* [ */void Do_EndOfLeftBracket1(char *strSource) {uWord.syn=_SYN_LEFTBRACKET1;uWord.value.T3=strSource[gnLocate];gnLocate++;gnRow++;return;}/* ] */ void Do_EndOfRightBracket1(char *strSource) {uWord.syn=_SYN_RIGHTBRACKET1;uWord.value.T3=strSource[gnLocate];gnLocate++;gnRow++;return;}void Do_EndOfLeftBracket2(char *strSource) /* { */ {uWord.syn=_SYN_LEFTBRACKET2;uWord.value.T3=strSource[gnLocate];gnLocate++;gnRow++;return;}/* } */ void Do_EndOfRightBracket2(char *strSource) {uWord.syn=_SYN_RIGHTBRACKET2;uWord.value.T3=strSource[gnLocate];gnLocate++;gnRow++;return;}/* : */ void Do_EndOfColon(char *strSource){uWord.syn=_SYN_COLON;uWord.value.T3=strSource[gnLocate];gnLocate++;gnRow++;return;}/* , */ void Do_EndOfComma(char *strSource) {uWord.syn=_SYN_COMMA;uWord.value.T3=strSource[gnLocate];gnLocate++;gnRow++;return;}void Do_EndOfSemicolon(char *strSource) /* ; */ {uWord.syn=_SYN_SEMICOLON;uWord.value.T3=strSource[gnLocate];gnLocate++;gnRow++;return;}/* >,>= */ void Do_EndOfMore(char *strSource) {/* > */if (strSource[gnLocate+1]!='=') {uWord.syn=_SYN_LG;uWord.value.T3=strSource[gnLocate];}/*>= */else {gnLocate++;gnRow++;uWord.syn=_SYN_ME;strcpy(uWord.value.T1,>=);}gnLocate++;gnRow++;return;}/* <,<= */void Do_EndOfLess(char *strSource){/* < */if (strSource[gnLocate+1]!='=') {uWord.syn=_SYN_LT;uWord.value.T3=strSource[gnLocate];}/*<= */else {gnLocate++;gnRow++;uWord.syn=_SYN_LE;strcpy(uWord.value.T1,<=);}gnLocate++;gnRow++;return;}void Do_EndOfEnd(char *strSource) /* 读到'\0',源程序结束*/{uWord.syn=_SYN_END;uWord.value.T3=strSource[gnLocate];gnLocate++;gnRow++;return;}*/ /* void PrintWord(Word uWord) 打印二元组{*//* if (uWord.syn<=_SYN_ID 关键字、标识符或者有错误/* >= */ || uWord.syn==_SYN_ME /* <= */|| uWord.syn==_SYN_LE|| uWord.syn==_SYN_EQ) { /* == */fprintf(fw,\(%d,\t%s),uWord.syn,uWord.value.T1);}else if (uWord.syn==_SYN_NUM) { /* 数字*/fprintf(fw,\(%d,\t%d),uWord.syn,uWord.value.T2);}else { /* 其他符号*/fprintf(fw,\(%d,\t%c),uWord.syn,uWord.value.T3);}return;}*/void ApartWord(char *strSource) 根据输入的源程序识别所有的单词/*{gnColumn=gnRow=1;gnLocate=gnLocateStart=0;while (strSource[gnLocate]) {Scaner( );}return;}*/void Scaner(void) 词法扫描函数/*{Do_Start(strSource); /* 识别出一个单词*//* 打印二元组printWord(uWord); */return;}void PrintError(int nColumn,int nRow,char chInput) /* 打印词法扫描发现的错误*/ {fprintf(fw,\无法识别的单词--->Col:%d\tRow:%d\tChar:%c,nColumn,nRow,chInput);return;}/**************************************************//*文件：semanteme.h *//*定义语法（语义）分析器的接口*//**************************************************/# ifndef _SEMANTEME_H# define _SEMANTEME_H/* 四元组的结构*/typedef struct QUAD {char op[MAXLENGTH]; /* 操作符*//* 第一个操作数char argv1[MAXLENGTH]; *//* 第二个操作数*/ char argv2[MAXLENGTH];/* 运算结果char result[MAXLENGTH]; */}QUATERNION;*/ 语法语义分析主函数/* void lrparse(void);# endif/**************************************************/semanteme.c */ 文件：/*/*分析器的语法语义扫描部分*//**************************************************/# include globals.h# include scan.h# include semanteme.h*/ QUATERNION *pQuad; /* 存放四元组的元组*//* 临时变量的编号int nSuffix,nNXQ,ntc,nfc;extern Word uWord; /* */ 扫描得到的单词extern int gnColumn,gnRow; */行列号/*FILE *fw;*/ 打印结果的文件指针/*char *strFileName;*/打印结果的文件名/*char *strSource; /* 源程序*/char *Expression(void);char *Term(void);char *Factor(void);void Statement_Block(int *nChain);void LocateError(int nColumn,int nRow) /* 定位语法错误*/{fprintf(fw,\Col:%d\tRow:%d--->,nColumn+1,nRow);}void error(char *strError) */输出扫描发现的错误/*{LocateError(gnColumn,gnRow);fprintf(fw,%s,strError);return;}void Match(int syn,char *strError) /* 判断当前识别出的单词是否需要的单词，*/ 如果不是则报错，否则扫描下一个单词{if (syn==uWod.syn) Scaner( );else error(strError);return;}*/ void gen(char *op,char *argv1,char *argv2,char *result) /* 生成一个四元式{ sprintf(pQuad[nNXQ].op,op);sprintf(pQuad[nNXQ].argv1,argv1);sprintf(pQuad[nNXQ].argv2,argv2);sprintf(pQuad[nNXQ].result,result);nNXQ++;return;}*/void PrintQuaternion(void) 打印一个四元式/*{int nLoop;for (nLoop=1;nLoop<nNXQ;nLoop++) {fprintf(fw,\%d:%s,\t%s,\t%s,nLoop,pQuad[nLoop].op,pQuad[nLoop].argv1,pQuad[nLoop].argv2,pQuad[nLoop].result);}}char *Newtemp(void) */产生一个临时变量/*{char *strTempID=(char *) malloc(MAXLENGTH);sprintf(strTempID,T%d,++nSuffix);return strTempID;}p2 */和p1int merg(int p1,int p2) 合并/*{int p,nResult;if (p2==0) nResult=p1;else {nResult=p=p2;while (atoi(pQuad[p].result)) {p=atoi(pQuad[p].result);sprintf(pQuad[p].result,%d,p1);}}return nResult;}*/为首的四元式链中p回填到以t将/* void bp(int p,int t){int w,q=p;while (q) {w=atoi(pQuad[q].result);sprintf(pQuad[q].result,%d,t);q=w;}return;}char *Expression(void){char opp[MAXLENGTH],*eplace,eplace1[MAXLENGTH],eplace2[MAXLENGTH];eplace=(char *) malloc(MAXLENGTH);strcpy(eplace1,Term( ));strcpy(eplace,eplace1);while (uWord.syn==_SYN_PLUS || uWord.syn==_SYN_MINUS) { /* + - */ sprintf(opp,%c,uWord.value.T3);Scaner( );strcpy(eplace2,Term( ));strcpy(eplace,Newtemp( ));gen(opp,eplace1,eplace2,eplace);strcpy(eplace1,eplace);}return;char *Term(void){char opp[2],*eplace1,*eplace2,*eplace;eplace=eplace1=Factor( );while (uWord.syn==_SYN_TIMES || uWord.syn==_SYN_DIVIDE) { /* * / */ sprintf(opp,%c,uWord.value.T3);Scaner( );eplace2=Factor( );eplace=Newtemp( );gen(opp,eplace1,eplace2,eplace);eplace1=eplace;}return eplace;}char *Factor(void){char *eplace=(char *) malloc(MAXLENGTH);/* i */if (uWord.syn==_SYN_ID || uWord.syn==_SYN_NUM) {if (uWord.syn==_SYN_ID) sprintf(eplace,%s,uWord.value.T1);else sprintf(eplace,%d,uWord.value.T2);Scaner( );}else {Match(_SYN_LPAREN,();eplace=Expression( );Match(_SYN_RPAREN,));}return eplace;}void Condition(int *etc,int *efc){char opp[3],*eplace1,*eplace2;char strTemp[4 ];eplace1=Expression( );if (uWord.syn<=_SYN_NE && uWord.syn>=_SYN_LG) {swich (uWord.syn) {case _SYN_LT:case _SYN_LG:sprintf(opp,%c,uWord.value.T3);break;default:sprintf(opp,%s,uWord.value.T1);break;}Scaner( );eplace2=Expression( );*etc=nNXQ;*efc=nNXQ+1;sprintf(strTemp,j%s,opp);gen(strTemp,eplace1,eplace2,gen(j,\,\,}); 关系运算符??汥敳攠牲牯尨}*//* void Statement(int *nChain) 语句分析函数{char strTemp[MAXLENGTH],eplace[MAXLENGTH];int nChainTemp,nWQUAD;switch (uWord.syn) {case _SYN_ID:strcpy(strTemp,uWord.value.T1);Scaner( );ch(_SYN_ASSIGN,”=”);MatStrcpy(eplace,Expression( ));Match(_SYN_SEMICOLON,;);gen(=,eplace,\,strTemp);*nChain=0;break;case _SYN_IF:Match(_SYN_IF,if);Match(_SYN_LPAREN,();Condition(&ntc,&nfc);bp(ntc,nNXQ);Match(_SYN_RPAREN,));Statement_Block(&nChainTemp);*nChain=merg(nChainTemp,nfc);break;case _SYN_WHILE:Match(_SYN_WHILE,while);nWQUAD=nNXQ;Match(_SYN_LPAREN,();Condition(&ntc,&nfc);bp(ntc,nNXQ);Match(_SYN_RPAREN,));Statement_Block(&nChainTemp);bp(nChainTemp,nWQUAD);sprintf(strTemp,%d,nWQUAD);gen(j,\,\,strTemp);*nChain=nfc;break;}return;}*/语句串分析函数void Statement_Sequence(int *nChain) /* {Statement(nChain);while (uWord.syn==_SYN_ID || uWord.syn==_SYN_IF /* id if while */|| uWord.syn==_SYN_WHILE) {bp(*nChain,nNXQ);Statement(nChain);}bp(*nChain,nNXQ);return;}*/void Statement_Block(int *nChain) 语句块分析函数/*{Match(_SYN_LEFTBRACKET2,{);Statement_Sequence(nChain);Match(_SYN_RIGHTBRACKET2,});}void Parse(void){int *nChain;Scaner( );Match(_SYN_MAIN,main);Match(_SYN_LPAREN,();Match(_SYN_RPAREN,));Statement_Block(&nChain);if (uWord.syn!=_SYN_END) fprintf(fw, 源程序非正常结束！);PrintQuaternion( );}void lrparse(void) /* 语法语义分析主函数*/{pQuad=(QUATERNION *) malloc(strlen(strSource) * sizeof(QUATERNION));nSuffix=0;nfc=ntc=nNXQ=1;fw=fopen(strFileName,w);Parse( );fclose(fw);}。