编译原理—pl0实验报告
编译原理实验报告
编译原理实验报告一、实验目的和要求本次实验旨在对PL_0语言进行功能扩充,添加新的语法特性,进一步提高编译器的功能和实用性。
具体要求如下:1.扩展PL_0语言的语法规则,添加新的语法特性;2.实现对新语法的词法分析和语法分析功能;3.对扩展语法规则进行语义分析,并生成中间代码;4.验证扩展功能的正确性。
二、实验内容1.扩展语法规则本次实验选择扩展PL_0语言的语句部分,添加新的控制语句,switch语句。
其语法规则如下:<switch_stmt> -> SWITCH <expression> CASE <case_list><default_stmt> ENDSWITCH<case_list> -> <case_stmt> , <case_stmt> <case_list><case_stmt> -> CASE <constant> : <statement><default_stmt> -> DEFAULT : <statement> ,ε2.词法分析和语法分析根据扩展的语法规则,需要对新的关键字和符号进行词法分析,识别出符号类型和记号类型。
然后进行语法分析,建立语法树。
3.语义分析在语义分析阶段,首先对switch语句的表达式进行求值,判断其类型是否为整型。
然后对case语句和default语句中的常量进行求值,判断是否与表达式的值相等。
最后将语句部分生成中间代码。
4.中间代码生成根据语法树和语义分析的结果,生成对应的中间代码。
例如,生成switch语句的跳转表,根据表达式的值选择相应的跳转目标。
5.验证功能的正确性设计一些测试用例,验证新语法的正确性和扩展功能的实用性。
三、实验步骤与结果1.扩展语法规则,更新PL_0语法分析器的词法规则和语法规则。
编译原理pL0实验报告
一.课程设计要求基本内容:(1)扩充赋值运算:*= 和/=(2)扩充语句(Pascal的FOR语句):①FOR <变量>:=<表达式> TO <表达式> DO <语句>②FOR <变量>:=<表达式> DOWNTO <表达式> DO <语句>其中,语句①的循环变量的步长为2,语句②的循环变量的步长为-2。
二.设计思路在课内实验的基础上,额外增加*=和/=运算符和关键字的语义动作,以下是设计思路:1. 扩充单词在头文件pl0.h中的enum symbol中增加关键字forsym, tosym, downtosym, timeseqlsym,slasheqlsym,并修改关键字数#define symnum 46。
/*初始化*/// ssym['*=']=timeseql;// ssym['/=']=slasheql;/*设置保留字名字,按照字母顺序,便于折半查找*/strcpy(&(word[14][0]),"to"); /*增加后需要按序排列*/strcpy(&(word[7][0]),"for");strcpy(&(word[4][0]),"downto");strcpy(&(word[3][0]),"do");/*设置保留字符号*/wsym[7]=forsym;wsym[14]=tosym;/*语法分析,获取一个符号*/在getsym()部分添加:else if(ch=='*'){ /** “*=” **/getchdo;if(ch=='='){sym=timeseql;getchdo;printf("check *= success!");}else sym=times;}else if(ch=='/'){ /* “/=” */getchdo;if(ch=='='){sym=slasheql;getchdo;printf("check /= success!");}else sym=slash;}/*其中printf部分均为识别成功后用作返回的信息而设*/2.扩充赋值运算符:*=和/=,关键字For①EBNF范式的书写:<变量>*=|/=<表达式><for 语句>::=for<变量>:=<表达式> to <表达式> do <语句><for 语句>::=for<变量>:=<表达式> downto <表达式> do <语句>②语法描述图:a.*=和/=:③ 递归下降子程序a.增加+=,/=;找到statement 部分的becomes 部分作为修改: /以下为连接become 语句后的修改部分*/ else if(sym==timeseql) {getsymdo;memcpy(nxtlev,fsys,sizeof(bool)* symnum);expressiondo(nxtlev,ptx,lev);gendo(lod,lev-table[i].level,table[i].adr); gendo(opr,0,4); gendo(sto,lev-table[i].level,table[i].adr); }else if(sym==slasheql){getsymdo;memcpy(nxtlev,fsys,sizeof(bool)* symnum); gendo(lod,lev-table[i].level,table[i].adr);expressiondo(nxtlev,ptx,lev);gendo(opr,0,5);gendo(sto,lev-table[i].level,table[i].adr);}语句 Ident:=/=*=表达式}}}b.增加for:找到statement部分的calsym部分后作为增加:/以下为连接callsym语句后的增加部分*/elseif(sym==forsym){getsymdo;if(sym==ident){i=position(id,*ptx);if(i==0){error(11);}else{if(table[i].kind!=variable){error(12);i=0;}else{getsymdo;if(sym==becomes){getsymdo;}else{error(13);}memcpy(nxtlev,fsys,sizeof(bool)* symnum);expressiondo(nxtlev,ptx,lev);if(i!=0){gendo(sto,lev-table[i].level,table[i].adr);}}}}if(sym==tosym){getsymdo;memcpy(nxtlev,fsys,sizeof(bool)*symnum);nxtlev[dosym]=true;/*后跟符号为do*/cx1=cx; /*保存判断条件超作的位置*/gendo(lod,lev-table[i].level,table[i].adr);expressiondo(nxtlev,ptx,lev);gendo(opr,0,13);cx2=cx; /*保存循环体的结束的下一个位置*/ gendo(jpc,0,0);/*生成条件跳转,但跳出循环的地址未知*/if(sym==dosym){getsymdo;}else{error(18); /*缺少do*/}statementdo(fsys,ptx,lev); /*循环体*/gendo(lod,lev-table[i].level,table[i].adr);gendo(lit,lev-table[i].level,2);gendo(opr,0,2);gendo(sto,lev-table[i].level,table[i].adr);gendo(jmp,0,cx1);/*回头重新判断条件*/code[cx2].a=cx; /*反填跳出循环的地址,与if类似*/}else{if(sym==downtosym) {getsymdo;memcpy(nxtlev,fsys,sizeof(bool)*symnum);nxtlev[dosym]=true;/*后跟符号为do*/cx1=cx; /*保存判断条件超作的位置*/gendo(lod,lev-table[i].level,table[i].adr);expressiondo(nxtlev,ptx,lev);gendo(opr,0,11);cx2=cx; /*保存循环体的结束的下一个位置*/gendo(jpc,0,0);/*生成条件跳转,但跳出循环的地址未知*/if(sym==dosym) {getsymdo;statementdo(fsys,ptx,lev); /*循环体*/}else{error(18); /*缺少do*/}gendo(lod,lev-table[i].level,table[i].adr);gendo(lit,lev-table[i].level,2);gendo(opr,0,3);gendo(sto,lev-table[i].level,table[i].adr);gendo(jmp,0,cx1);/*回头重新判断条件*/code[cx2].a=cx; /*反填跳出循环的地址,与if类似*/}c. 生成的pcode代码:1 int 0 82 lit 0 53 sto 0 34 lit 0 55 sto 0 46 lit 0 17 sto 0 78 lod 0 79 lit 0 1010 opr 0 1311 jpc 0 2112 lod 0 313 lit 0 114 opr 0 215 sto 0 316 lod 0 717 lit 0 218 opr 0 219 sto 0 720 jmp 0 821 lod 0 322 opr 0 1423 opr 0 1524 lit 0 1825 sto 0 726 lod 0 727 lit 0 128 opr 0 1129 jpc 0 3930 lod 0 431 lit 0 132 opr 0 233 sto 0 434 lod 0 735 lit 0 236 opr 0 337 sto 0 738 jmp 0 2639 lod 0 440 opr 0 1441 opr 0 1542 opr 0 0start pl03.测试用例的编写和运行结果:本次测试使用了三个测试用例,其中E02.PL0为检测是否能正确识别所增加的关键字和运算符,E04.PL0就是检测*=和/=是否能正确符合运算规则并求出得数,E05.PL0是for语句的检测。
标准实验报告(PL0编译程序)
[标准实验报告]南昌航空大学实验报告年月日课程名称:编译原理实验名称:扩充的PL/0编译程序班级:姓名:同组人:指导教师评定:签名:一、实验目的进一步熟悉编译程序的整体框架,给出整个编译程序的流程结构,用C 或vc++语言编写程序;并将编制的编译程序进行调试、实现PL/0编译程序。
二、实验要求(1)根据所选的程序设计语言,修改并调试。
(2)举出例子程序,在程序中进行编译。
(3)用此编译程序对有关语句进行编译,并输出目标指令。
(4)书写出合格的实验报告。
三、实验步骤1.输入文件中变量的声明形如:var a,b,c; 以var保留字开始,不同变量以”,”分隔,最后以”;”结束。
2.read语句格式为read(a)或者read(a,b);3.write语句格式为write(a),括号里面没有字符串常量,注意与书后的形如write(‘a=’,a)是不相同的。
4.的声明形如:”procedure proname;”不含参数表。
5.一维数组形如:变量类型array 数组名[数组下标]。
6.条件语句形如:if <条件>then<语句> {;else,语句>}7.扩充的记录型数据类型形如:for 循环语句及带参数的过程。
四、参考源代码#include<stdio.h>/*#include"plo.h"*/#include"string.h"#define stacksize 500typedef enum{false,true}bool;enum object{procedur , constant ,variable};#define norw 13#define txmax 100#define nmax 14#define al 10#define levmax 3#define cxmax 200#define amax 2047#define symnum 32enum symbol{nul, ident, number, plus, minus,times, slash, oddsym, eql, neq,lss, leq, gtr, geq, lparen,rparen, comma, semicolon, period, becomes,beginsym, endsym, ifsym, thensym, whilesym,writesym, readsym, dosym, callsym, constsym,varsym, procsym,};enum fct {lit, opr, lod,sto, cal, inte,jmp, jpc,};#define fctnum 8struct instruction{enum fct f;int l;int a;};FILE* fas;FILE* fa;FILE* fal;FILE* fa2;bool listswitch;bool tableswitch;char ch;enum symbol sym;char id[al+1];int num;int cc,ll;int cx;char line[81];char a [al+1];int num ;int cc,ll;int cx;char line [81];char a [al+1];struct instruction code [cxmax]; char word [norw][al];struct instruction code [cxmax]; char word [norw][al];enum symbol wsym [norw]; enum symbol ssym [256]; char mnemonic [fctnum][5]; bool declbegsys [symnum]; bool statbegsys [symnum]; bool facbegsys [symnum]; bool facstatbegsys[symnum]; struct tablestruct{char name [al];enum object kind ;int val;int level;int adr;int size;};struct tablestruct table [txmax]; FILE * fin;FILE * fout;char fname [al];int err;#define getsymdo if(-1==getsym())return -1#define getchdo if(-1==getch())return -1#define testdo(a,b,c) if(-1==test(a,b,c))return -1#define gendo(a,b,c) if(-1==gen(a,b,c))return -1#define expressiondo(a,b,c) if(-1==expression(a,b,c))return -1#define factordo(a,b,c) if(-1==factor(a,b,c))return -1#define termdo(a,b,c) if(-1==term(a,b,c))return -1#define conditiondo(a,b,c) if(-1==condition(a,b,c))return -1#define statementdo(a,b,c) if(-1==statement(a,b,c))return -1#define constdeclarationdo(a,b,c) if(-1==constdeclaration(a,b,c))return -1 #define vardeclarationdo(a,b,c) if(-1==vardeclaration(a,b,c))return -1 void error(int n);int getsym();int getch();void init();int gen(enum fct x,int y,int z);int test(bool *sl,bool *s2,int n);int inset (int e,bool *s);int addset (bool* sr,bool* sl,bool *s2,int n);int subset (bool* sr,bool* sl,bool *s2,int n);int mulset (bool* sr,bool* sl,bool *s2,int n);int block (int lev,int tx,bool* fsys);void interpret();int factor (bool* fays,int * ptx,int lev);int term (bool* fays,int * ptx,int lev);int condition (bool* fays,int * ptx,int lev);int expression (bool* fays,int * ptx,int lev);int statement (bool* fays,int * ptx,int lev);void listcode(int cx0);int vardeclaration (int * ptx,int lev,int * pdx);int constdeclaration (int * ptx,int lev ,int * pdx);int position (char * idt,int tx);void enter (enum object k,int * ptx ,int lev ,int *pdx);int base (int l,int * s,int b);int main(){bool nxtlev[symnum];printf("input pl/o file?");scanf("%s",fname);fin=fopen(fname,"r");if(fin){printf("list objeck code? (Y/N)");scanf("%s",fname);/*listwitch=(fname[0]=='y'||fname[0]=='Y');*/ printf("list symbol table? (Y/N)");scanf("%s",fname);tableswitch=(fname[0]=='y'||fname[0]=='Y'); fal=fopen("fal.tmp","w");fprintf(fal,"input pl/o file?");fprintf(fal,"%s",fname);init();err=0;cc=cx=ll=0;ch='';if(-1 !=getsym()){ fa=fopen("fa.tmp","w");fas=fopen("fas.tmp","w");addset(nxtlev,declbegsys,statbegsys,symnum); nxtlev[period]=true;if(-1==block(0,0,nxtlev)){fclose(fa);fclose(fal);fclose(fas);fclose(fin);printf("\n");return 0;}fclose(fa);fclose(fal);fclose(fas);if(sym!=period){error(9);}if(err==0){fa2=fopen("fa2.tmp","w");interpret();fclose(fa2);}else{printf("error in pl/o program"); }}fclose(fin);}else{printf("can't open file! \n");}printf("\n");return 0;}/*chushihua*/void init(){ int i;for (i=0;i<=255;i++){ssym[i]=nul;}ssym['+']=plus;ssym['-']=minus;ssym['*']=times;ssym['/']=slash;ssym['(']=lparen;ssym[')']=rparen;ssym['=']=eql;ssym[',']=comma;ssym['.']=period;ssym['#']=neq;ssym[';']=semicolon;strcpy(&(word[0][0]),"begin"); strcpy(&(word[1][0]),"call"); strcpy(&(word[2][0]),"const"); strcpy(&(word[3][0]),"do");strcpy(&(word[4][0]),"end");strcpy(&(word[5][0]),"if");strcpy(&(word[6][0]),"odd"); strcpy(&(word[7][0]),"procedure"); strcpy(&(word[8][0]),"read"); strcpy(&(word[9][0]),"then"); strcpy(&(word[10][0]),"var"); strcpy(&(word[11][0]),"while"); strcpy(&(word[12][0]),"write");wsym[0]=beginsym;wsym[1]=callsym;wsym[2]=constsym;wsym[3]=dosym;wsym[4]=endsym;wsym[5]=ifsym;wsym[6]=oddsym;wsym[7]=procsym;wsym[8]=readsym;wsym[9]=thensym;wsym[10]=varsym;wsym[11]=whilesym;wsym[12]=writesym;strcpy(&(mnemonic[lit][0]),"lit"); strcpy(&(mnemonic[opr][0]),"opr"); strcpy(&(mnemonic[lod][0]),"lod"); strcpy(&(mnemonic[sto][0]),"sto"); strcpy(&(mnemonic[cal][0]),"cal"); strcpy(&(mnemonic[inte][0]),"inte"); strcpy(&(mnemonic[jmp][0]),"jmp"); strcpy(&(mnemonic[jpc][0]),"jpc");for(i=0;i<symnum;i++){declbegsys[i]=false;statbegsys[i]=false;facbegsys[i]=false;}declbegsys[constsym]=true;declbegsys[varsym]=true;declbegsys[procsym]=true;statbegsys[beginsym]=true;statbegsys[callsym]=true;statbegsys[ifsym]=true;statbegsys[whilesym]=true;facstatbegsys[ident]=true; facstatbegsys[number]=true; facstatbegsys[lparen]=true;}int inset(int e,bool*s){return s[e];}int addset(bool* sr,bool * s1,bool* s2,int n) {int i ;for(i=0;i<n;i++){sr[i]=s1[i]||s2[i];}return 0;}int subset(bool* sr,bool * s1,bool* s2,int n) {int i ;for(i=0;i<n;i++){sr[i]=s1[i]&&(!s2[i]);}return 0;}int mulset(bool* sr,bool * s1,bool* s2,int n) {int i ;for(i=0;i<n;i++){sr[i]=s1[i]&&(s2[i]);}return 0;}void error(int n){char space[81];memset(space,32,81);space[cc-1]=0;printf("*****%s!%d\n",space,n);fprintf(fal,"********%s!%d\n",space,n); err++;}int getch(){if(cc==ll){if(feof(fin)){printf("program,incomplete");return -1;}ll=0;cc=0;printf("%d",cx);fprintf(fal,"%d",cx);ch='';while(ch!=10){if(EOF==fscanf(fin,"%c",&ch)){line[ll]=0;break;}printf("%c",ch);fprintf(fal,"%c",ch);line[ll]=ch;++ll;}printf("\n");fprintf(fal,"\n");}ch=line[cc];cc++;return 0;}/*****************************8 */int getsym(){int i,j,k;while (ch==''||ch==10||ch==9){getchdo;}if(ch>='a'&& ch<='z'){k=0;do{if(k<al){a[k]=ch;k++;}getchdo;}while(ch>='a'&& ch<='z'||ch>='0'&& ch<='9');a[k]=0;strcpy(id,a);i=0;j=norw-1 ;do{k=(i+j)/2 ;if(strcmp(id,word[k])<=0) {j=k-1;}if(strcmp(id,word[k])>=0)i=k+1;}while(i<=j);if(i-1>j){sym=wsym[k];}else{sym=ident;}}else{if(ch>='0'&&ch<='9'){k=0;num=0;sym=number;do{num=10*num+ch-'0';k++;getchdo;}while (ch>='0'&&ch<='9');k--;if(k>nmax){error(30);}}else{if(ch==';'){getchdo;if(ch=='='){sym=becomes;getchdo;}else{sym=nul;}}else{if (ch=='<'){getchdo;if(ch=='='){sym=leq;getchdo;}else{sym=lss;}}else{if(ch=='>'){getchdo;if(ch=='='){sym=geq;getchdo;}else{sym=gtr;}}else{sym=ssym[ch];if(sym!=period){getchdo;}}}}}}return 0;}int gen(enum fct x,int y,int z){if(cx>=cxmax){printf("program too ling ");return -1;}code[cx].f=x;code[cx].l=y;code[cx].a=z;cx++;return 0;}int test(bool * s1,bool * s2,int n){if(! inset(sym,s1)){error(n);while((! inset(sym,s1))&&(! inset(sym,s2))) {getsymdo;}}return 0;}int block(int lev,int tx,bool* fsys){int i;int dx;int txo;int cxo;bool nxtlev[symnum];dx=3;txo=tx;table[tx].adr=cx;gendo(jmp,0,0);if(lev>levmax){error(32);}do{if(sym==constsym){getsymdo;do{constdeclarationdo(&tx,lev,&dx);while(sym==comma){getsymdo;constdeclarationdo(&tx,lev,&dx);}if (sym==semicolon) {getsymdo;}else{error(5);}}while(sym==ident);}if(sym==varsym) {getsymdo;do{vardeclarationdo(&tx,lev,&dx); while(sym==comma) {getsymdo; vardeclarationdo(&tx,lev,&dx); }if(sym==semicolon) {getsymdo;}else{error(5);}}while(sym==ident);}while(sym==procsym) {getsymdo;if(sym==ident){enter(procedur,&tx,lev,&dx); getsymdo;}else{error(4);}if(sym==semicolon) {getsymdo;}else{error(5);}memcpy(nxtlev,fsys,sizeof(bool)*symnum); nxtlev[semicolon]=true;if(-1==block(lev+1,tx,nxtlev)){return -1;}if(sym==semicolon){getsymdo;memcpy(nxtlev,statbegsys,sizeof(bool) * symnum); nxtlev[ident]=true;nxtlev[procsym]=true;testdo(nxtlev,fsys,6);}else{error(5);}}memcpy(nxtlev,statbegsys,sizeof(bool) * symnum); nxtlev[ident]=true;nxtlev[period]=true;testdo(nxtlev,declbegsys,7);}while(inset(sym,declbegsys));code[table[txo].adr].a=cx;table[txo].adr=cx;table[txo].size=dx;cxo=cx;gendo(inte,0,dx);if(tableswitch){printf("TABLE:\n");if(txo+1>tx){printf("NULL\n");}for(i=txo+1;i<=tx;i++){switch(table[i].kind){case constant:printf("%d const %s",i,table[i].name);printf("val=%d\n",table[i].val);fprintf(fas,"%d const %s",i,table[i].name);fprintf(fas,"val=%d\n",table[i].val);break;case variable:printf("%d var %s",i,table[i].name);printf("lev=%d addr=%d\n",table[i].level,table[i].adr);fprintf(fas,"%d var %s",i,table[i].name);fprintf(fas,"lev=%d addr=%d\n",table[i].level,table[i].adr);break;case procedur:printf("%d proc %s",i,table[i].name);printf("lev=%d addr=%d size=%d\n",table[i].level,table[i].adr,table[i].size); fprintf(fas,"%d proc %s",i,table[i].name);fprintf(fas,"lev=%d addr=%d size=%d\n",table[i].level,table[i].adr,table[i].size); break;}}printf("\n");}memcpy(nxtlev,fsys,sizeof(bool) * symnum);nxtlev[semicolon]=true;nxtlev[endsym]=true;statementdo(nxtlev,&tx,lev);gendo(opr,0,0);memset(nxtlev,0,sizeof(bool) * symnum);testdo(fsys,nxtlev,8);listcode(cxo);return 0;}void enter(enum object k , int * ptx , int lev , int * pdx){(*ptx)++;strcpy(table[(*ptx)].name,id);table[(*ptx)].kind=k;switch(k){case constant:if(num>amax){error(31);num=0;}table[(*ptx)].val=num;break;case variable:table[(*ptx)].level=lev;table[(*ptx)].adr=(*pdx);(*pdx)++;break;case procedur:table[(*ptx)].level=lev;break;}}int position(char*idt,int tx){int i;strcpy(table[0].name,idt);i=tx;while(strcmp(table[i].name,idt)!=0){i--;}return i;}int constdecalration(int *ptx,int lev,int *pdx) {if(sym==ident){getsymdo;if(sym==eql||sym==becomes){if(sym==becomes)error(1);getsymdo;if(sym==number){enter(constant,ptx,lev,pdx);getsymdo;}else{error(2);}}else{error(3);}}else{error(4);}return 0;}int constdeclaration(int * ptx,int lev,int * pdx){if (sym==ident){getsymdo;if (sym==eql||sym==becomes){if (sym==becomes){error(1);}getsymdo;if (sym ==number){enter(constant,ptx,lev,pdx);getsymdo;}else{error(2);}}else{error(3);}}else{error(4);}return 0;}int vardeclaration(int* ptx,int lev,int* pdx){if (sym==ident){enter(variable,ptx,lev,pdx);getsymdo;}else{error(4);}return 0;}void listcode(int cx0){int i;if (listswitch){for (i=cx0;i<cx;i++){printf("%d %d %d %d\n",i,mnemonic[code[i].f],code[i].l,code[i].a);fprintf(fa,"%d %s %d %d\n",i,mnemonic[code[i].f],code[i].l,code[i].a);}}}int statement(bool* fsys,int* ptx,int lev){int i,cxl,cx2;bool nxtlev[symnum];if (sym==ident){i=position(id,*ptx);if (i==0){error(11);}else{if(table[i].kind !=variable){error(12);i=0;}else{getsymdo;if(sym==becomes){getsymdo;}else{error(13);}memcpy(nxtlev,fsys,sizeof(bool)*symnum);expressiondo(nxtlev,ptx,lev);if(i!=0){gendo(sto,lev-table[i].level,table[i].adr);}}}/*if(i==0)*/}else{if(sym==readsym){getsymdo;if(sym!=lparen){error(34);}else{do{getsymdo;if(sym==ident){i=position(id,*ptx);}else{i=0;}if(i==0){error(35);}else{gendo(opr,0,16);gendo(sto,lev-table[i].level,table[i].adr) ;}getsymdo;}while(sym==comma);}if(sym!=rparen){error(33);while(! inset(sym,fsys)){getsymdo;}}else{getsymdo;}}else{if(sym==writesym){getsymdo;if(sym==lparen){do{getsymdo; memcpy(nxtlev,fsys,sizeof(bool)*symnum);nxtlev[rparen]=true;nxtlev[comma]=true;expressiondo(nxtlev,ptx,lev);gendo(opr,0,14);}while(sym==comma);if(sym!=rparen){error(33);}else{getsymdo;}}gendo(opr,0,15);}else{if(sym==callsym){getsymdo;if(sym!=ident){error(14);}else{i=position(id,*ptx);if(i==0){error(11);}else{if(table[i].kind==procedur){gendo(cal,lev-table[i].level,table[i].adr);}else{error(15);}}getsymdo;}}else{if(sym==ifsym){getsymdo;memcpy(nxtlev,fsys,sizeof(bool)*symnum);nxtlev[thensym]=true;nxtlev[dosym]=true;conditiondo(nxtlev,ptx,lev);if(sym==thensym){getsymdo;}else{error(16);}cxl=cx;gendo(jpc,0,0);statementdo(fsys,ptx,lev);code[cxl].a=cx;}else{if(sym==beginsym){getsymdo;memcpy(nxtlev,fsys,sizeof(bool)*symnum);nxtlev[semicolon]=true;nxtlev[endsym]=true;statementdo(nxtlev,ptx,lev);while(inset(sym,statbegsys)||sym==semicolon){if(sym==semicolon){getsymdo;}else{error(10);}statementdo(nxtlev,ptx,lev);}if(sym==endsym){getsymdo;}else{error(17);}}else{if(sym==whilesym){cxl=cx;getsymdo;memcpy(nxtlev,fsys,sizeof(bool)*symnum);nxtlev[dosym]=true;conditiondo(nxtlev,ptx,lev);cx2=cx;gendo(jpc,0,0);if(sym==dosym){getsymdo;}else{error(18);}statementdo(fsys,ptx,lev);gendo(jmp,0,cxl);code[cx2].a=cx;}else{testdo(fsys,nxtlev,19);}}}}}}}return 0;}int expression(bool * fsys,int * ptx,int lev){enum symbol addop;bool nxtlev[symnum];if(sym==plus||sym==minus){addop=sym;getsymdo;memcpy(nxtlev,fsys,sizeof(bool)*symnum);nxtlev[plus]=true;nxtlev[minus]=true;termdo(nxtlev,ptx,lev);if(addop==minus){gendo(opr,0,1);}}else{memcpy(nxtlev,fsys,sizeof(bool)*symnum);nxtlev[plus]=true;nxtlev[minus]=true;termdo(nxtlev,ptx,lev);}while(sym==plus||sym==minus){addop=sym;getsymdo;memcpy(nxtlev,fsys,sizeof(bool)*symnum);nxtlev[plus]=true;nxtlev[minus]=true;termdo(nxtlev,ptx,lev);if(addop==plus){gendo(opr,0,2);}else{gendo(opr,0,3);}}return 0;}int term(bool*fsys,int*ptx,int lev){enum symbol mulop;bool nxtlev[symnum];memcpy(nxtlev,fsys,sizeof(bool)*symnum);nxtlev[times]=true;nxtlev[slash]=true;factordo(nxtlev,ptx,lev);while(sym==times||sym==slash){mulop=sym;getsymdo;factordo(nxtlev,ptx,lev);if(mulop==times){gendo(opr,0,4);}else{gendo(opr,0,5);}}return 0;}int factor(bool*fsys,int*ptx,int lev){int i;bool nxtlev[symnum];testdo(facbegsys,fsys,24);while(inset(sym,facbegsys)){if(sym==ident){i=position(id,*ptx);if(i==0){error(11);}else{switch(table[i].kind){case constant:gendo(lit,0,table[i].val);break;case variable:gendo(lod,lev-table[i].level,table[i].adr);break;case procedur:error(21);break;}}getsymdo;}else{if(sym==number){if(num>amax){error(31);num=0;}gendo(lit,0,num);getsymdo;}else{if(sym==lparen){getsymdo;memcpy(nxtlev,fsys,sizeof(bool)*symnum);nxtlev[rparen]=true;expressiondo(nxtlev,ptx,lev);if(sym==rparen){getsymdo;}else{error(22);}}testdo(fsys,facbegsys,23);}}}return 0;}int condition(bool*fsys,int*ptx,int lev){enum symbol relop;bool nxtlev[symnum];if(sym==oddsym){getsymdo;expressiondo(fsys,ptx,lev);gendo(opr,0,6);}else{memcpy(nxtlev,fsys,sizeof(bool)*symnum);nxtlev[eql]=true;nxtlev[neq]=true;nxtlev[lss]=true;nxtlev[leq]=true;nxtlev[gtr]=true;nxtlev[geq]=true;expressiondo(nxtlev,ptx,lev);if(sym!=eql&&sym!=neq&&sym!=lss&&sym!=leq&&sym!=gtr&&s ym!=geq){error(20);}else{relop=sym;getsymdo;expressiondo(fsys,ptx,lev);switch(relop){case eql:gendo(opr,0,8);break;case neq:gendo(opr,0,9);break;case lss:gendo(opr,0,10);break;case geq:gendo(opr,0,11);break;case gtr:gendo(opr,0,12);break;case leq:gendo(opr,0,13);break;}}}return 0;}void interpret(){int p,b,t;struct instruction i;int s[stacksize];printf("start pl0\n");t=0;b=0;p=0;s[0]=s[1]=s[2]=0;do{i=code[p];p++;switch(i.f){case lit:s[t]=i.a;t++;break;case opr:switch(i.a){case 0:t=b;p=s[t+2];b=s[t+1]; break;case 1:s[t-1]=-s[t-1]; break;case 2:t--;s[t-1]=s[t-1]+s[t]; break;case 3:t--;s[t-1]=s[t-1]-s[t]; break;case 4:t--;s[t-1]=s[t-1]*s[t]; break;case 5:t--;s[t-1]=s[t-1]/s[t]; break;case 6:t--;s[t-1]=s[t-1]%2; break;case 8:t--;s[t-1]=(s[t-1]==s[t]); break;case 9:t--;s[t-1]=(s[t-1]!=s[t]); break;case 10:t--;s[t-1]=(s[t-1]<s[t]); break;case 11:t--;s[t-1]=(s[t-1]>=s[t]); break;case 12:t--;s[t-1]=(s[t-1]>s[t]); break;case 13:t--;s[t-1]=(s[t-1]<=s[t]); break;case 14:printf("%d",s[t-1]); fprintf(fa2,"%d",s[t-1]); t--;break;case 15:printf("\n");fprintf(fa2,"\n"); break;case 16:printf("?");fprintf(fa2,"?");scanf("%d",&(s[t])); fprintf(fa2,"%d\n",s[t]);t++;break;}break;case lod:s[t]=s[base(i.l,s,b)+i.a];t++;break;case sto:t--;s[t]=s[base(i.l,s,b)+i.a]=s[t]; break;case cal:s[t]=base(i.l,s,b);s[t+1]=b;s[t+2]=p;b=t;p=i.a;break;case inte:t+=i.a;break;case jmp:p=i.a;break;case jpc:t--;if(s[t]==0)p=i.a;break;}}while(p!=0);}int base(int l,int *s,int b) {int b1;b1=b;while(l>0){b1=s[b1];l--;}return b1;}五、实验结果1.输入PL/0源程序const a=10;var b,c;procedure pbeginc:=b+aend;beginread (b);while b#0 dobegincall p;write(2*c);read(b)endend.2. 输入分别输入b值的结果当b=2;输出结果为24当b=3;输出结果为26当b=1;出结果为22当b=0;结束程序六、实验体会通过该实验,本人学会了应用C语言调试和扩充PL/0编译程序的能力,此实验完成了PL/0词法分析、语法分析、语义分析、代码生成和代码优化等功能,并在此基础上实现了PL/0语言的扩充能力,从实际的应用中深刻领悟了编译程序的原理,更加深刻的学习了理论知识。
《编译原理(实验部分)》实验3_PL0语法分析
《编译原理(实验部分)》实验3_PL0语法分析《编译原理》(实验部分)实验3_PL0语法分析一、实验目的加深和巩固对于语法分析的了解和掌握;给出PL/0文法规范,要求编写PL/0语言的语法分析程序。
二、实验设备1、PC 兼容机一台;操作系统为WindowsWindowsXP。
2、Visual C++ 6.0 或以上版本, Windows 2000 或以上版本,汇编工具(在Software 子目录下)。
三、实验原理PL/O语言的编译程序,是用高级语言PASCAL语言书写的。
整个编译过程是由一些嵌套及并列的过程或函数完成。
语法分析是由过程BLOCK完成。
采用自顶向下的递归子程序法。
所产生的目标程序为假象栈式计算机的汇编语言。
对目标程序的执行是由PASCAL语言书写的解释程序进行的。
四、实验步骤实验代码int lp=0;int rp=0;#define getsymdo if(-1==getsym()) return -1#define expressiondo() if(-1==expression()) return -1#define termdo() if(-1==term()) return -1#define factordo() if(-1==factor()) return -1int expression();//语法分析int factor(){if(sym!=ident &&sym!=number&&sym!=lparen){err++;if(err==1) printf("语法错误: \n");printf("error----Factor Needs Ident or Number or Lparen\n");}if ((sym == ident) || (sym == number) || (sym == lparen)){if (sym == ident){WordAnalyse();if(getsym()==-1){return -1;}if(sym!=times&&sym!=slash&&sym!=plus&&sym!=minus &&sym!=rparen){err++;if(err==1) printf("语法错误: \n");printf("变量后没有跟上+-*\\ \n");}if(lp==0 && sym==rparen){err++;if(err==1) printf("语法错误: \n");printf("没有左括号匹配\n");}}else if (sym == number){WordAnalyse();if(getsym()==-1){return -1;}if(sym!=times&&sym!=slash&&sym!=plus&&sym!=minus &&sym!=rparen) {err++;if(err==1) printf("语法错误: \n");printf("数字后没有跟上+-*\\ \n");}if(lp==0 && sym==rparen){err++;if(err==1) printf("语法错误: \n");printf("没有左括号匹配\n");}}else if (sym == lparen){WordAnalyse();lp++;if(getsym()==-1){lp--;err++;if(err==1) printf("语法错误: \n");printf("error----Needs Rparen \n");return -1;}expressiondo();if (sym == rparen){WordAnalyse();lp--;if(getsym()==-1){return -1;}if(sym!=times&&sym!=slash&&sym!=plus&&sym!=minus) {err++;if(err==1) printf("语法错误: \n");printf("括号后没有跟上+-*\\ \n");}}else{err++;if(err==1) printf("语法错误: \n");printf("error----Needs Rparen \n");}}}return 0;}int term(){factordo();if(sym!=times&&sym!=slash&&sym!=plus&&sym!=minus&&sym!=ident&&sym!=number&&sym!=lparen&&sym!=rparen) {err++;if(err==1) printf("语法错误: \n");printf("不能识别字符\n");}while ((sym == times) || (sym == slash)){WordAnalyse();if(getsym()==-1){err++;if(err==1) printf("语法错误: \n");printf("* \\ 后缺项\n");return -1;}factordo();}return 0;}int expression(){if ((sym == plus) || (sym == minus)){//cout<<strlen(id)<<endl;< p="">if (sym==minus&&2==strlen(ID)+1)flg=1;else{flg=0;WordAnalyse();}getsymdo;termdo();}else{//WordAnalyse();termdo();}if(sym!=times&&sym!=slash&&sym!=plus&&sym!=minus &&sym!=ident&&sym!=number&&sym!=lparen&&sym!=rparen){err++;if(err==1) printf("语法错误: \n");printf("不能识别字符\n");}while ((sym == plus) || (sym == minus)){WordAnalyse();if(getsym()==-1){err++;if(err==1) printf("语法错误: \n");printf("+ - 后缺项\n");return -1;}termdo();}return 0;}int main(int argc, char* argv[]){init();err=0;ifstream fin("in.txt");ofstream fout("out.txt");ch=' ';lp=0;getsymdo;expression();if(err==0) cout<<"语法正确"<<endl;< p="">elsecout<<"语法错误,错误个数: "<<err<<=""></err< </endl;<></strlen(id)<<endl;<>。
《编译原理》实验3_PL0语法分析
《编译原理》实验3_PL0语法分析编译原理是计算机科学中的重要课程,它涉及了程序语言的设计、编译器的构建以及编程语言的解释和执行等方面。
在编译原理的实验部分中,PL0语法分析是一个重要的实验项目。
PL0语法分析是基于PL0语言的语法规则来构建语法分析器,实现对PL0代码的分析和解释。
在这个实验中,我们将完成PL0语法分析器的设计和实现,并对其进行测试。
首先,我们需要了解PL0语言的语法规则。
PL0语言是一种过程型语言,类似于Pascal语言。
它有一套严格的语法规则,包括声明语句、赋值语句、条件语句、循环语句等。
我们需要先从PL0语言文法中提取出规则,然后将其转化为一个语法分析器。
接下来,我们需要设计和实现语法分析器。
语法分析器的主要任务是根据PL0语言的文法规则来分析和解释PL0代码。
我们可以选择使用自顶向下的语法分析方法,如递归下降分析法。
递归下降分析法是一种简单直观的语法分析方法,它通过递归调用子程序来分析和解释代码。
在设计语法分析器时,我们需要根据PL0语言的文法规则来设计相应的文法产生式和语法分析程序。
文法产生式描述了PL0语言的句子结构,它由非终结符和终结符组成,并用箭头“->”来表示产生关系。
语法分析程序则是根据产生式来解释和分析代码。
最后,我们需要编写测试代码来验证语法分析器的正确性。
测试代码应该包含PL0语言的各种语法结构和语法错误,从而验证语法分析器在不同情况下的正确性和鲁棒性。
通过完成这个实验项目,我们能够深入了解编译原理中的语法分析技术,并提升我们的编程能力和问题解决能力。
同时,我们也能够加深对PL0语言的理解,为以后的编程工作打下坚实的基础。
《编译原理(实验部分)》实验2_PL0词法分析
《编译原理》(实验部分)实验2_PL0 词法分析一、实验目的加深和巩固对于词法分析的了解和掌握;初步认识PL/0 语言的基础和简单的程序编写;通过本实验能够初步的了解和掌握程序词法分析的整个过程;提高自己上机和编程过程中处理具体问题的能力。
二、实验设备1、P C兼容机一台;操作系统为WindowsWindowsX P2、Visual C++ 6.0 或以上版本,Windows 2000 或以上版本,汇编工具 (在Software 子目录下)。
三、实验原理PL/O语言的编译程序,是用高级语言PASCAL语言书写的。
整个编译过程是由一些嵌套及并列的过程或函数完成。
词法分析程序是独立的过程GETSY完成,供语法分析读单词时使用。
四、实验步骤阅读所给出的词法分析程序( pl0_lexical.c ),搞懂程序中每一个变量的含义,以及每一个过程的作用,并在该过程中进行中文注释;阅读完程序后,画出各过程的流程图;给出的程序包含两处输入错误,利用所给的pl/0 源程序(test.pl0) 对程序进行调试,使其能正确对所给文件进行分析并能够解释运行;在阅读懂所给出的词法分析程序后,将你对词法分析的理解写在实验报告上。
实验代码#include<stdio.h>main(){ printf ("my name is 08061118 yuchaofeng ");}主程序:#include <stdio.h>#include <ctype.h>#include <alloc.h>#include <stdlib.h>#include <string.h>#define NULL 0FILE *fp;char cbuffer;char *key[8]={"DO","BEGIN","ELSE","END","IF","THEN","VAR","WHILE"}; char *border[6]={",",";",":=",".","(",")"};char *arithmetic[4]={"+","-","*","/"};char *relation[6]={"<","<=","=",">",">=","<>"};char *consts[20];char *label[20];int constnum=0,labelnum=0;int search(char searchchar[],int wordtype){int i=0;switch (wordtype) {case 1:for (i=0;i<=7;i++){if (strcmp(key[i],searchchar)==0)return(i+1);};case 2:{for (i=0;i<=5;i++){if (strcmp(border[i],searchchar)==0)return(i+1);};return(0);}case 3:{for (i=0;i<=3;i++){ if (strcmp(arithmetic[i],searchchar)==0){};};return(0);};case 4:{for (i=0;i<=5;i++){ if (strcmp(relation[i],searchchar)==0){return(i+1);};};return(0);};case 5:{for (i=0;i<=constnum;i++){ if (strcmp(consts[i],searchchar)==0){return(i+1);};}consts[i-1]=(char *)malloc(sizeof(searchchar));strcpy(consts[i-1],searchchar);constnum++;return(i);};case 6:{for (i=0;i<=labelnum;i++){ if (strcmp(label[i],searchchar)==0){ return(i+1);};}label[i-1]=(char *)malloc(sizeof(searchchar)); strcpy(label[i-1],searchchar);return(i);};}}char alphaprocess(char buffer){int atype;int i=-1;char alphatp[20];while ((isalpha(buffer))||(isdigit(buffer))){ alphatp[++i]=buffer; buffer=fgetc(fp);}; alphatp[i+1]='\0';if (atype=search(alphatp,1)) printf("%s (1,%d)\n",alphatp,atype-1); else { atype=search(alphatp,6);printf("%s (6,%d)\n",alphatp,atype-1); };return(buffer);char digitprocess(char buffer){int i=-1;char digittp[20];int dtype;while ((isdigit(buffer))){ digittp[++i]=buffer;buffer=fgetc(fp);}digittp[i+1]='\0';dtype=search(digittp,5);printf("%s (5,%d)\n",digittp,dtype-1); return(buffer);}char otherprocess(char buffer){int i=-1;char othertp[20];int otype,otypetp;othertp[0]=buffer;othertp[1]='\0';if (otype=search(othertp,3)){printf("%s (3,%d)\n",othertp,otype-1);buffer=fgetc(fp);goto out;};if (otype=search(othertp,4)){buffer=fgetc(fp);othertp[1]=buffer;othertp[2]='\0';if (otypetp=search(othertp,4)){printf("%s (4,%d)\n",othertp,otypetp-1); goto out;}elseothertp[1]='\0';printf("%s (4,%d)\n",othertp,otype-1);goto out;};if (buffer==':'){ buffer=fgetc(fp);if (buffer=='=')printf(":= (2,2)\n");buffer=fgetc(fp);goto out;}else{if (otype=search(othertp,2)){ printf("%s (2,%d)\n",othertp,otype-1); buffer=fgetc(fp); goto out;}};if ((buffer!='\n')&&(buffer!=' '))printf("%c error,not a word\n",buffer); buffer=fgetc(fp);out: return(buffer);} void main(){ int i;for (i=0;i<=20;i++){label[i]=NULL; consts[i]=NULL;};if ((fp=fopen("skh.c","r"))==NULL) printf("error");else{ cbuffer = fgetc(fp);while (cbuffer!=EOF){if (isalpha(cbuffer)) cbuffer=alphaprocess(cbuffer);else if (isdigit(cbuffer))cbuffer=digitprocess(cbuffer); else cbuffer=otherprocess(cbuffer); };printf("over\n");};}。
PL0编译程序原理实验报告
编译原理实验报告——理解PL/0编译程序原理实验4.1 理解PL/0编译程序原理一、实验目的1.学习使用教学辅助软件THPL0CAI2.掌握PL/0源程序的编译和解释过程二、实验平台Windows + THPL0CAI三、实验内容1.运行THPL0CAI 程序(1)选择0 - Static Link 方式进入;(2)选择Open/Create a source file 打开一个PL/0源程序,如Test2.pl0:const a=10;var b,c;procedure p;var k;beginc:=b+10;end;beginread(b);while b#0 dobegincall p;write(2*c);read(b)endend.2.按F9键开始单步编译Test2.pl0 程序(1)观察符号表的构造过程Table.dat 窗口;(2)观察目标代码的构造过程Code.dat 窗口。
3.按F9键开始单步执行编译Test2.pl0 生成的代码(1)观察运行栈的变化过程Stack.dat 窗口;(2)观察数据的输入输出Result.dat 窗口。
四、实验分析1.PL/0编译程序结构(a)PL/0编译程序的结构图(b)PL/0的解释执行结构PL/0语言是PASCAL语言的子集 ----指令功能表2.给出编译过程中符号表的建立过程Code.dat:符号表table.dat如图所示:符号表建立过程:(1)运行主程序,“main”存入符号表,类型为procedure,地址:8,大小:6;(2)常量a存入符号表,值为10;(3)存入b,c,类型为variable,地址分别为3,4;(4)执行p程序,存入p,类型为procedure,地址为1;(5)存入k,类型为variable,地址为3;被引用变量或过程所在层次为1;3.给出运行过程中运行栈的变化过程,只给出部分说明即可程序开始(1)输入b=5,将变量b的取值取至栈顶。
编译原理实验报告(PL_0语言功能扩充)
《编译原理》课程实验报告题目PL/0编译程序的C语言扩充专业化学工程与工艺班级学号姓名任课教师华东理工大学信息学院一.实验题目PL/0编译程序的C语言扩充二.实验目的在分析理解PL/0编译程序的基础上,对其词法分析程序、语法分析程序和语义处理程序进行部分修改扩充。
三.实验内容在PL/0语言的基础上增加对整型一维数组的支持、扩充IF-THEN-ELSE条件语句、增加REPEAT 语句、支持带参数的过程和增加注释等,如下所示:(1)整型一维数组,数组的定义格式为:VAR<数组标识名>(<下界>:<上界>)其中上界和下界可以是整数或者常量标识名。
访问数组元素的时候,数组下表是整型的表达式,包括整数、常量或者变量和他们的组合。
(2)扩充条件语句,格式为:<条件语句> ::= EF<条件>THEN<语句> [ELSE<语句>](3)增加REPEAT语句,格式为:<复合语句> ::= REPEAT<语句>UNTL<条件>四.实验过程(1)PL/0编译程序的C语言源代码输入(2)运行PL/0编译程序的C语言源代码,调试运行PL/0编译程序(3)对PL/0编译程序进行功能扩充(4)PL/0编译程序功能扩充部分的分析与设计(5)对PL/0编译程序进行功能扩充,即编写代码(6)进行PL/0编译程序功能扩充部分的运行调试(7)完成实验报告总结五.PL/0编译程序的功能扩充程序说明(1)扩充赋值运算:+=,-=.此功能扩充只需在语句分析里面进行增加如下程序:if(SYM==BECOMES||SYM==PLUSBECOMES||SYM==MINUSBECOMES){if (SYM==BECOMES){GetSym();EXPRESSION(FSYS,LEV,TX);}elseif(SYM==PLUSBECOMES||SYM==MINUSBECOMES){GEN(LOD,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);if(SYM==PLUSBECOMES){GetSym();FACTOR(FSYS,LEV,TX);GEN(OPR,0,2);}elseif(SYM==MINUSBECOMES){GetSym();FACTOR(FSYS,LEV,TX);GEN(OPR,0,3);}}if (i!=0)GEN(STO,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);}(2)扩充FOR TO和FOR DOWNTO语句,此功能的关键是如何判断条件是否成立,并如何进行程序跳转.在这里用到了几条指令,和地址回填技术.扩充程序如下:case FORSYM:GetSym();if(SYM!=IDENT)Error(31); //FOR后面要标识符i=POSITION(ID,TX);if (i==0) Error(11);elseif (TABLE[i].KIND!=VARIABLE) { /*ASSIGNMENT TO NON-VARIABLE*/Error(12); //变量}GetSym();if(SYM!=BECOMES)Error(13);GetSym();EXPRESSION(SymSetUnion(SymSetNew(TOSYM,DOWNTOSYM,DOSYM),FSYS),LEV,TX);//表达式if(SYM==DOWNTOSYM)CX1=CX;GetSym();GEN(STO,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);//保存结果至变量单元GEN(LOD,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);//重新调入栈顶EXPRESSION(SymSetAdd(DOSYM,FSYS),LEV,TX);//表达式GEN(OPR,0,11);//判断运算CX2=CX;GEN(JPC,0,0);//如果栈顶非真跳转GEN(LOD,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);///重新调入栈顶GEN(LIT,0,1) ;//送1到栈顶GEN(OPR,0,3); //减运算if(SYM==DOSYM){GetSym();STATEMENT(FSYS,LEV,TX);}GEN(JMP,0,CX1);CODE[CX2].A=CX;}else if(SYM==TOSYM){CX1=CX;GetSym();GEN(STO,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR); //保存结果至变量单元GEN(LOD,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR); /重新调入栈顶EXPRESSION(SymSetAdd(DOSYM,FSYS),LEV,TX);//表达式分析GEN(OPR,0,13);//判断运算CX2=CX;GEN(JPC,0,0);//如果栈顶非真跳转GEN(LOD,LEV-TABLE[i].vp.LEVEL,TABLE[i].vp.ADR);GEN(LIT,0,1);GEN(OPR,0,2);if(SYM==DOSYM){GetSym();STATEMENT(FSYS,LEV,TX);}GEN(JMP,0,CX1);CODE[CX2].A=CX;//回填地址}else Error(35);break;(3) 增加条件语句的ELSE子ELSE语句的语法语义分析程序:case IFSYM:GetSym();CONDITION(SymSetUnion(SymSetNew(THENSYM,DOSYM),FSYS),LEV,TX);if (SYM==THENSYM) GetSym();else Error(16);CX1=CX; GEN(JPC,0,0);STATEMENT(FSYS,LEV,TX);CX2=CX; GEN(JMP,0,CX+1);CODE[CX1].A=CX;if (SYM==SEMICOLON) GetSym();if(SYM==ELSESYM){GetSym();STATEMENT(FSYS,LEV,TX);CODE[CX2].A=CX;} //add the statement of ELSEelse STATEMENT(FSYS,LEV,TX);break;(4)修改单词:不等号# 改为 <>if (CH=='<'){GetCh();if (CH=='=') { SYM=LEQ; GetCh(); }elseif(CH=='>') { SYM=NEQ; GetCh(); }else SYM=LSS;六.实验设计思想1.设计说明PL/0语言是Pascal语言的一个子集,这里分析的PL/0的编译程序包括了对PL/0语言源程序进行分析处理、编译生成类PCODE代码,并在虚拟机上解释运行生成的类PCODE代码的功能。
编译原理修改后地PL0报告材料
一、上机实践要求“编译原理与技术〞的上机实验要求你对PL/0语言与其编译器进展扩大和修改。
每个扩大或修改方式可得到不同的分数,总分为为100分。
完成上机作业后,必须提交如下文档:(1)修改后的PL/0语言文本。
包含词法分析〔正规式〕,语法分析〔BNF〕。
(2)有关修改后的PL/0编译/解释器的说明。
详细说明你的编译器是如何编译新的PL/0语言程序的。
指出你的程序中最精彩的局部,以与你为什么这样做,你是如何控制和恢复语义错误的。
(3)给出你所改动后的编译器源程序清单,并标记出你所修改的局部。
比拟你的编译器和原来的编译器之间的差异。
(4)说明你的编译器中可能存在的错误。
(5)总结经验与教训,如果重做一遍,你会有哪些新的改良?对现存的PL/0编译程序可做如下修改或扩大,其中〔1〕、〔2〕、〔11〕和〔12〕必须完成,剩余的均可任意选择,但总分必须超过70分。
(1)注释〔5分〕注释由(*和*)包含,不允许嵌套。
(2)布尔类型的数据〔10分〕布尔类型的BNF为:var_option →ε| var var_decl_listvar_decl_list → var_decl | var_decl_list var_declvar_decl → ident_list : data_typedata_type →integer | boolean这种修改包括:(i)区别整型与布尔型变量、常量和表达式。
(ii)增加按严格计算的布尔类型运算符and、or和not。
这些算符以与己有的运算符的优先级与Pascal语言一样。
(iii)能够使用布尔常量true和false。
(iv)把PL/0语言中的“条件〞概念一般化为Pascal语言那样。
(v)布尔表达式可以比拟大小:false < true(3)布尔表达式的短路计算〔5分〕增加布尔类型〔见〔2〕,除〔2〕的〔ii〕外〕,但对and和or采取短路计算。
(4)数组〔10分〕增加由任何数据类型构造的一维数组。
编译原理实验报告--PLO编译器的修改
《编译原理》实验报告题目PLO编译器的修改学院计算机学院专业计算机科学与技术2011年1月11日一、课程题目1、对PL/0编译器作以下修改扩充:(1)增加单词:保留字ELSE,FOR,TO,DOWNTO,RETURN 运算符+=,-=,++,――其中FOR,TO,DOWNTO,RETURN属于选做内容。
(2)修改单词:不等号# 改为<>(3)增加条件语句的ELSE子句2、我在本次实验中实现了以下内容:(1)增加单词:保留字ELSE,FOR,TO,DOWNTO,运算符+=,-=,++,――(2)修改单词:不等号# 改为<>(3)增加条件语句的ELSE子句二、测试方案的设计(30%)1、不等号#改为<>的测试方案通过的方案:PROGRAM EX01; V AR A,B,C; BEGINA:=8;C:=10;READ(B);IF B<>1 THEN C:=A+B*(3+B); WRITE(C); END. 不能通过的方案:PROGRAM EX01; V AR A,B,C; BEGINA:=8;C:=10;READ(B);IF B#1 THENC:=A+B*(3+B);WRITE(C); END.2、增加运算符+=,-=,++,――的测试方案:通过的方案1:PROGRAM EX01; V AR a,b,c; BEGINa:=8;b:=4;a+=2*b;WRITE(a);a++;WRITE(a);++b;WRITE(b); END. 通过的方案2:PROGRAM EX01; V AR a,b,c; BEGINa:=8;b:=4;a-=b;WRITE(a);a--;WRITE(a);--b;WRITE(b); END.不通过的方案1:PROGRAM EX01; V AR a,b;BEGINa:=2;++a++;WRITE(a);4++;END. 不通过的方案2:PROGRAM EX01; V AR a,b;BEGINa:=2;--a--;WRITE(a);4--;END.3、增加条件语句的ELSE子句的测试方案:通过的方案:PROGRAM EX01; V AR A,B,C; BEGINA:=8;READ(B);IF B<>1 THENC:=A+B*(3+B); ELSEC:=A+10; WRITE(C); END. 不能通过的方案:PROGRAM EX01; V AR A,B,C; BEGINA:=8;READ(B); WHILE B<>1 DOC:=A+B*(3+B); ELSEC:=A+10; WRITE(C); END.4、FOR——TO\DOWNTO的测试方案:通过的方案1:PROGRAM EX01;V AR a,B,C;BEGINa:=1;B:=2;FOR C:=1 TO 3 DOBEGINa+=B*(3+B);WRITE(a);END;END. 通过的方案2:PROGRAM EX01;V AR a,B,C;BEGINa:=1;B:=2;FOR C:=3 DOWNTO 1 DOBEGINa+=B*(3+B);WRITE(a);END;END.不能通过的方案1:PROGRAM EX01; V AR a,B;BEGINa:=1;B:=2;FOR 1 TO 3 DOBEGINa+=B*(3+B);WRITE(a); ENDEND. 不能通过的方案2:PROGRAM EX01;V AR a,B,C;BEGINa:=1;B:=2;FOR C:=3 DOWNTO 1BEGINa+=B*(3+B);WRITE(a);ENDEND.三、题目分析与设计(40%)对题目各项要求自行分点论述设计修改过程。
PL0编译原理实践
编译原理实验报告一、上机实验检查(总计70分):二、完成情况(15分):1.修改后的PL/0词法(正规式)下面是本设计用到的正规式,bool类型的常量与变量都是通过保留字来体现的,number只是用于识别整型变量与常量。
空白w->’’; //空格n->\n; //回车t->Tab; //制表blank -> (w | n | t)+;保留字begin ->begin; //保留字end -> end;if -> if;then -> then;while -> while;do -> do;call->call;const -> const;var -> var;procedure -> procedure;boolean ->boolean;bool ->true|false;//布尔常量数字以及IDdigit -> 0|1|2|3|4|5|6|7|8|9;number -> digit(digit)*;letter -> a-zA-Z;id -> letter (digit|letter)*;特殊符号becomes->:=;leq-> ‘<=’;les -> ’<’;req-> ‘>=’;res -> ‘>’;relation -> = | <= | >= | > | < ;//关系运算符plus -> ‘+’;minus-> ‘-’;times -> ‘*’;slash -> ‘/’;odd -> ‘odd’;equ ->’=’;lparen ->’(’;rparen -> ‘)’;comma -> ‘,’;semicolon -> ‘;’;period -> ‘.’;and -> ‘&’;or -> ‘|’;not -> ‘!’;2.修改后的PL/0语法(产生式)设计采用递归预测分析的方法进行语法分析。
实验一PL0编译程序
实验一PL0编译程序编译原理上机实验一1.软件准备(1)、pl/0编译程序:pl0 .exe(2)、pl/0编译程序源代码程序(PASCAL程序):pl0.pas(或pl0pl0.pas)(3)、pl/0程序实例(文本文件):text.pl0, text1.pl0, test2.pl0, … text9.pl0共10个例子2.实验要求:(1)阅读pl/0源程序实例(text.pl0,test1.pl0,………text9.pl0共10个例子)理解每个PL0程序的功能;熟悉并掌握pl/0语言相关规则。
(2)用pl/0编译程序,对提供的10个例子逐一进行编译并运行。
熟悉pl/0编译程序使用操作方法。
通过理解每个实例程序的功能,编程思想,进一步理解PL/0语言的语法及其语义;提高阅读程序的能力,应用程序设计语言的编程能力;增强程序语言语法、语义意识。
(3)用pl/0语言编写以下程序,进一步熟悉PL/0语言:a、由三角形的三条边长计算三角形面积。
b、编写一个PL0过程,计算以a为直径的圆的面积。
用主程序确定圆的直径,输出计算结果。
c、编写递归程序,计算n!。
d、计算1000之内的所有素数,并输出结果。
求出1000之内所有素数之和。
(要求编写3个以上的pl/0过程实现)3.文件(软件)使用说明(1)、打开文件目录“PL0编译…”,运行PL/0编译程序(pl0.exe),按提示要求输入PL0源程序文件名(如test1.pl0),┉(2)、打开Fa2.txt文件,可看到当前经过编译并运行后的pl/0程序的目标代码及其执行结果。
(3)、打开out1.txt或out2.txt、┉或out9.txt文件,可看到各个pl/0程序实例的编译、运行、操作过程结果。
4.提交实验报告及要求(1)、简述test4.pl0 …test7.pl0各程序语法含义,执行结果。
(2)、提交实验要求编写的4个PL/0源程序及其执行结果。
(3)、简写本次实验的收获与体会。
PL0语言编译器分析实验报告
PL0语言编译器分析实验报告1. 引言1.1 PL0语言简介PL0语言是一种早期的程序设计语言,由瑞士计算机科学家尼克劳斯·沃斯(Niklaus Wirth)于1970年左右设计。
它是为了教学目的而设计的,具有简单、清晰、易于理解的特点。
PL0语言是一种过程式编程语言,不支持面向对象编程。
它的语法与Pascal语言相似,是许多编程语言教材中的入门语言。
1.2 编译器概述编译器是一种将高级编程语言源代码转换为低级机器语言或中间代码的程序。
它主要包括词法分析、语法分析、语义分析、中间代码生成、代码优化和目标代码生成等阶段。
编译器的主要目的是提高程序的可移植性、执行效率和开发效率。
1.3 实验目的与意义本次实验通过对PL0语言编译器的分析,旨在让学生深入了解编译器的工作原理和实现方法,提高编程实践能力。
实验的意义在于:1.加深对编译原理的理解,掌握编译器各阶段的基本任务和关键技术;2.培养学生独立分析问题、解决问题的能力;3.提高学生的编程技巧,为后续学习更高级的编程语言打下基础;4.通过实验,使学生了解编译器在软件开发中的重要作用,为今后从事软件开发工作奠定基础。
2 PL0语言编译器原理2.1 编译器的工作流程编译器的工作流程主要包括词法分析、语法分析、语义分析、中间代码生成、代码优化和目标代码生成等阶段。
1.词法分析:将源程序中的字符序列转换为记号(Token)序列。
2.语法分析:根据语法规则,将记号序列转换为抽象语法树(AST)。
3.语义分析:检查源程序是否有语义错误,如类型检查、作用域检查等。
4.中间代码生成:将AST转换为中间代码,方便后续优化和目标代码生成。
5.代码优化:对中间代码进行优化,提高目标代码的执行效率。
6.目标代码生成:将优化后的中间代码转换为特定平台的目标代码。
2.2 PL0语言的词法、语法和语义1.词法:PL0语言的词法规则包括标识符、常数、运算符和界限符等。
2.语法:PL0语言的语法规则定义了各种语句和表达式的结构,如条件语句、循环语句、赋值语句等。
《编译原理》课程实验报告(词法分析)
信息科学与工程学院__《编译原理》_实验报告系别计算机科学与工程专业计算机科学与应用班级_____计122_______学号_____10123544_____姓名_____ 陈柏君_________指导教师金登男2014学年第二学期1.实验题目:词法分析2.实验日期:2015.4.9-2015.4.163.实验环境(操作系统,开发语言)操作系统:Windows开发语言:C4.实验要求4.1.用C语言开发词法分析程序PL0Compiler。
4.2.修改PL/0词法,将其定义为一种新的语言,例如称其为PL/1语言,并完成PL/1语言的词法分析程序。
5.实验步骤5.1.用PL/0语言编写PL/0测试用例源程序,将其命名为Test0.pl。
5.2.用C语言开发PL/0词法分析程序PL0Compiler。
PL0Compiler读入Test0.pl,识别出一个个单词,并将这些单词流依序同时输出到屏幕和文件中。
被输出的每个单词应包括(1)单词序号(2)单词字符串(3)单词类型(4)单词值(如果是标识符,其值是字符串;如果是数,其值是数值;如果是符号,其值是ASCII代码…)在程序开发过程中,应设立断点,单步运行词法分析程序,依次输出一个个单词。
分析和理解词法分析程序,解释词法分析程序中的数据和变量变化的原因和输出结果。
5.3.研究其他程序设计语言,找出与PL/0词法不同的构词法则(例如C语言的标识符的组成规则与PL/0标识符的组成规则有所不同)。
据此修改PL/0的某些词法(例如,将PL/0标识符组成规则修改为C语言的标识符的组成规则),将其定义为一种新的语言,例如称其为PL/1语言。
5.4.用PL/1语言编写PL/1测试用例源程序,将其命名为Test1.pl。
5.5.开发PL/1词法分析程序PL1Compiler。
(可通过修改原PL0Compiler,实现PL/1语言的词法分析功能)。
5.6.PL1Compiler读入Test1.pl,识别出一个个单词,并将这些单词流依序同时输出到屏幕和文件中。
编译原理—pl0实验报告材料
PL/0实验报告课程名称编译原理题目名称PL/0编译程序学生学院计算机科学与技术学院专业班级学号学生姓名班内序号山东理工大学实验报告纸第 1 页姓名:蔡鹏飞计算机院_11_级02班同组者成绩_________室温:气压:课程名称:编译原理教师签字实验项目编号(1)PL/0编译程序的分析指导教师鞠传香实验目的1.熟悉pl/0语言并能编写小程序2.掌握pl/0编译程序的编译过程(词法分析、语法分析、语义分析等)实验仪器(编号)材料、工具PC机、VC++6.0(原理概述)pl/0语言编译程序采用以语法分析为核心、一遍扫描的编译方法。
词法分析和代码生成作为独立的子程序供语法分析程序调用。
语法分析的同时,提供了出错报告和出错恢复的功能。
在源程序没有错误编译通过的情况下,调用类pcode解释程序解释执行生成的类pcode代码。
PL/0语言文法的EBNF表示EBNF表示的符号说明。
〈〉:用左右尖括号括起来的中文字表示语法构造成分,或称语法单位,为非终结符。
∷= :该符号的左部由右部定义,可读作'定义为'。
| :表示'或',为左部可由多个右部定义。
{ } :花括号表示其内的语法成分可以重复。
在不加上下界时可重复0到任意次数,有上下界时为可重复次数的限制。
如:{*}表示*重复任意次,{*}38表示*重复3-8次。
[ ] :方括号表示其内的成分为任选项。
( ) :表示圆括号内的成分优先。
例:用EBNF描述<整数>文法的定义:<整数>∷=[+|-]<数字>{<数字>}<数字>∷=0|1|2|3|4|5|6|7|8|9或更好的写法<整数>∷=[+|-]<非零数字>{<数字>}|0<非零数字>∷=1|2|3|4|5|6|7|8|9<数字>∷=0|<非零数字>PL/0语言文法的EBNF表示PL/0语言文法的EBNF表示为:〈程序〉∷=〈分程序〉.〈分程序〉∷=[〈常量说明部分〉][〈变量说明部分〉][〈过程说明部分〉]〈语句〉〈常量说明部分〉∷=CONST〈常量定义〉{,〈常量定义〉};〈常量定义〉∷=〈标识符〉=〈无符号整数〉〈无符号整数〉∷=〈数字〉{〈数字〉}〈变量说明部分〉∷=VAR〈标识符〉{,〈标识符〉};〈标识符〉∷=〈字母〉{〈字母〉|〈数字〉}〈过程说明部分〉∷=〈过程首部〉〈分程序〉{;〈过程说明部分〉};〈过程首部〉∷=PROCEDURE〈标识符〉;〈语句〉∷=〈赋值语句〉|〈条件语句〉|〈当型循环语句〉|〈过程调用语句〉|〈读语句〉|〈写语句〉|〈复合语句〉|〈空〉〈赋值语句〉∷=〈标识符〉∶=〈表达式〉〈复合语句〉∷=BEGIN〈语句〉{;〈语句〉}END〈条件〉∷=〈表达式〉〈关系运算符〉〈表达式〉|ODD〈表达式〉〈表达式〉∷=[+|-]〈项〉{〈加法运算符〉〈项〉}〈项〉∷=〈因子〉{〈乘法运算符〉〈因子〉}〈因子〉∷=〈标识符〉|〈无符号整数〉|'('〈表达式〉')'〈加法运算符〉∷=+|-〈乘法运算符〉∷=*|/// 栈顶指针减一相关过程:base(),interpret()。
编译原理实验部分实验PL词法分析
《编译原理》(实验部分)实验2_PL0词法分析一、实验目的加深和巩固对于词法分析的了解和掌握;初步认识PL/0语言的基础和简单的程序编写;通过本实验能够初步的了解和掌握程序词法分析的整个过程;提高自己上机和编程过程中处理具体问题的能力。
二、实验设备1、PC 兼容机一台;操作系统为WindowsWindowsXP。
2、Visual C++ 6.0 或以上版本, Windows 2000 或以上版本,汇编工具(在Software 子目录下)。
三、实验原理PL/O语言的编译程序,是用高级语言PASCAL语言书写的。
整个编译过程是由一些嵌套及并列的过程或函数完成。
词法分析程序是独立的过程GETSYM完成,供语法分析读单词时使用。
四、实验步骤阅读所给出的词法分析程序(pl0_lexical.c),搞懂程序中每一个变量的含义,以及每一个过程的作用,并在该过程中进行中文注释;阅读完程序后,画出各过程的流程图;给出的程序包含两处输入错误,利用所给的pl/0源程序(test.pl0)对程序进行调试,使其能正确对所给文件进行分析并能够解释运行;在阅读懂所给出的词法分析程序后,将你对词法分析的理解写在实验报告上。
实验代码#include<stdio.h>main(){ printf ("my name is 08061118 yuchaofeng ");}主程序:#include <stdio.h>#include <ctype.h>#include <alloc.h>#include <stdlib.h>#include <string.h>#define NULL 0FILE *fp;char cbuffer;char *key[8]={"DO","BEGIN","ELSE","END","IF","THEN","VAR","WHILE"}; char *border[6]={",",";",":=",".","(",")"};char *arithmetic[4]={"+","-","*","/"};char *relation[6]={"<","<=","=",">",">=","<>"};char *consts[20];char *label[20];int constnum=0,labelnum=0;int search(char searchchar[],int wordtype){int i=0;switch (wordtype) {case 1:for (i=0;i<=7;i++){if (strcmp(key[i],searchchar)==0)return(i+1);};case 2:{for (i=0;i<=5;i++){if (strcmp(border[i],searchchar)==0)return(i+1);};return(0);}case 3:{for (i=0;i<=3;i++){ if (strcmp(arithmetic[i],searchchar)==0){return(i+1);};};return(0);};case 4:{for (i=0;i<=5;i++){ if (strcmp(relation[i],searchchar)==0){return(i+1);};};return(0);};case 5:{for (i=0;i<=constnum;i++){ if (strcmp(consts[i],searchchar)==0){return(i+1);};}consts[i-1]=(char *)malloc(sizeof(searchchar)); strcpy(consts[i-1],searchchar);constnum++;return(i);};case 6:{for (i=0;i<=labelnum;i++){ if (strcmp(label[i],searchchar)==0){return(i+1);};}label[i-1]=(char *)malloc(sizeof(searchchar)); strcpy(label[i-1],searchchar);labelnum++;return(i);};}}char alphaprocess(char buffer){int atype;int i=-1;char alphatp[20];while ((isalpha(buffer))||(isdigit(buffer))){ alphatp[++i]=buffer;buffer=fgetc(fp);};alphatp[i+1]='\0';if (atype=search(alphatp,1))printf("%s (1,%d)\n",alphatp,atype-1);else{atype=search(alphatp,6);printf("%s (6,%d)\n",alphatp,atype-1);};return(buffer);}char digitprocess(char buffer){int i=-1;char digittp[20];int dtype;while ((isdigit(buffer))){ digittp[++i]=buffer;buffer=fgetc(fp);}digittp[i+1]='\0';dtype=search(digittp,5);printf("%s (5,%d)\n",digittp,dtype-1); return(buffer);}char otherprocess(char buffer){int i=-1;char othertp[20];int otype,otypetp;othertp[0]=buffer;othertp[1]='\0';if (otype=search(othertp,3)){printf("%s (3,%d)\n",othertp,otype-1); buffer=fgetc(fp);goto out;};if (otype=search(othertp,4)){buffer=fgetc(fp);othertp[1]=buffer;othertp[2]='\0';if (otypetp=search(othertp,4)){printf("%s (4,%d)\n",othertp,otypetp-1); goto out;}elseothertp[1]='\0';printf("%s (4,%d)\n",othertp,otype-1);goto out;};if (buffer==':'){ buffer=fgetc(fp);if (buffer=='=')printf(":= (2,2)\n");buffer=fgetc(fp);goto out;}else{if (otype=search(othertp,2)){ printf("%s (2,%d)\n",othertp,otype-1); buffer=fgetc(fp);goto out;}};if ((buffer!='\n')&&(buffer!=' '))printf("%c error,not a word\n",buffer); buffer=fgetc(fp);out: return(buffer);}void main(){ int i;for (i=0;i<=20;i++){label[i]=NULL;consts[i]=NULL;};if ((fp=fopen("skh.c","r"))==NULL) printf("error");else{ cbuffer = fgetc(fp);while (cbuffer!=EOF){if (isalpha(cbuffer))cbuffer=alphaprocess(cbuffer); else if (isdigit(cbuffer))cbuffer=digitprocess(cbuffer); else cbuffer=otherprocess(cbuffer); };printf("over\n");};}。
编译原理PL0课程设计报告材料
课程设计班级:21301学号:1361080108姓名:马瑞泽百度一.课程设计目的在分析理解一个教学型编译程序(如PL/0)的基础上,对其词法分析程序、语法分析程序和语义处理程序进行部分修改扩充。
达到进一步了解程序编译过程的基本原理和基本实现方法的目的。
二.课程设计要求1. 基本内容(1)扩充赋值运算:+= 和 -=(2)扩充语句(Pascal的FOR语句):①FOR <变量>:=<表达式> TO <表达式> DO <语句>②FOR <变量>:=<表达式> DOWNTO <表达式> DO <语句>其中,语句①的循环变量的步长为2,语句②的循环变量的步长为-2。
2. 选做内容(1)增加运算:++ 和 --。
(2)增加类型:①字符类型;②实数类型。
(3)扩充函数:①有返回值和返回语句;②有参数函数。
(4)增加一维数组类型(可增加指令)。
(5)其他典型语言设施。
3.本人在课程设计中已实现的功能(1)增加单词:保留字 ELSE,FOR,TO,DOWNTO, REPEAT, UNTIL, RETURN运算符 +=,-=,++,--(2)修改单词:不等号# 改为 <>(3)增加条件语句的ELSE子句(4)扩充赋值运算:+= 和 -=(5)扩充语句①FOR <变量>:=<表达式> TO <表达式> DO <语句>②FOR <变量>:=<表达式> DOWNTO <表达式> DO <语句>(6)增加运算:++ 和 --(包括前后++、--运算)(7)增加一维数组类型(8)其他典型语言设施:REPEAT 语句 UNTIL 语句三.课程设计环境与工具(1)计算机及操作系统:PC机,Win7(2)实现工具:VC++ 6.0, C语言(3)教学型编译程序:PL/0四.结构设计说明1)PL/0编译程序的结构图2)PL/0编译程序的过程或函数的功能表4)GETSYM的NUM中,单词,常量Getch,并把拼成SYM置成NUL。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
PL/0实验报告
课程名称编译原理
题目名称PL/0编译程序
学生学院计算机科学与技术学院专业班级
学号
学生姓名
班内序号
山东理工大学实验报告纸第 1 页
姓名:蔡鹏飞计算机院_11_级02班同组者成绩_________室温:气压:课程名称:编译原理教师签字
实验项目
编号(1)
PL/0编译程序的分析指导教师鞠传香
实验目的1.熟悉pl/0语言并能编写小程序
2.掌握pl/0编译程序的编译过程(词法分析、语法分析、语义分析等)
实验仪器(编号)
材料、工具
PC机、VC++6.0
(原理概述)
pl/0语言编译程序采用以语法分析为核心、一遍扫描的编译方法。
词法分析和代码生成作为独立的子程序供语法分析程序调用。
语法分析的同时,提供了出错报告和出错恢复的功能。
在源程序没有错误编译通过的情况下,调用类pcode解释程序解释执行生成的类pcode代码。
PL/0语言文法的EBNF表示
EBNF表示的符号说明。
〈〉:用左右尖括号括起来的中文字表示语法构造成分,或称语法单位,为非终结符。
∷= :该符号的左部由右部定义,可读作'定义为'。
| :表示'或',为左部可由多个右部定义。
{ } :花括号表示其内的语法成分可以重复。
在不加上下界时可重复0到任意次数,
有上下界时为可重复次数的限制。
如:{*}表示*重复任意次,{*}38表示*重复3-8次。
[ ] :方括号表示其内的成分为任选项。
( ) :表示圆括号内的成分优先。
例:用EBNF描述<整数>文法的定义:
<整数>∷=[+|-]<数字>{<数字>}
<数字>∷=0|1|2|3|4|5|6|7|8|9
或更好的写法
<整数>∷=[+|-]<非零数字>{<数字>}|0
<非零数字>∷=1|2|3|4|5|6|7|8|9
<数字>∷=0|<非零数字>
PL/0语言文法的EBNF表示
PL/0语言文法的EBNF表示为:
〈程序〉∷=〈分程序〉.
〈分程序〉∷=[〈常量说明部分〉][〈变量说明部分〉][〈过程说明部分〉]〈语句〉
〈常量说明部分〉∷=CONST〈常量定义〉{,〈常量定义〉};
〈常量定义〉∷=〈标识符〉=〈无符号整数〉
〈无符号整数〉∷=〈数字〉{〈数字〉}
〈变量说明部分〉∷=VAR〈标识符〉{,〈标识符〉};
〈标识符〉∷=〈字母〉{〈字母〉|〈数字〉}
〈过程说明部分〉∷=〈过程首部〉〈分程序〉{;〈过程说明部分〉};
〈过程首部〉∷=PROCEDURE〈标识符〉;
〈语句〉∷=〈赋值语句〉|〈条件语句〉|〈当型循环语句〉|
〈过程调用语句〉|〈读语句〉|〈写语句〉|〈复合语句〉|〈空〉
〈赋值语句〉∷=〈标识符〉∶=〈表达式〉
〈复合语句〉∷=BEGIN〈语句〉{;〈语句〉}END
〈条件〉∷=〈表达式〉〈关系运算符〉〈表达式〉|ODD〈表达式〉
〈表达式〉∷=[+|-]〈项〉{〈加法运算符〉〈项〉}
〈项〉∷=〈因子〉{〈乘法运算符〉〈因子〉}
〈因子〉∷=〈标识符〉|〈无符号整数〉|'('〈表达式〉')'
〈加法运算符〉∷=+|-
〈乘法运算符〉∷=*|/
// 栈顶指针减一
相关过程:base(),interpret()。
其中base()的功能是根据层次差并从当前数据区沿着静态链查找,以便获取变量实际所在的数据区其地址;interpret()则完成各种指令的执行工作。
错误诊断处理
一个编译程序,在多数情况下,所接受的源程序正文都是有错误的。
发现错误,并给出合适的诊断信息且继续编译下去从而发现更多的错误,对于编译程序而言是完全必要的。
一个好的编译器,其特征在于:
任何输入序列都不会引起编译程序的崩溃。
一切按语言定义为非法的结构,都能被发现和标志出来。
经常出现的错误,程序员的粗心或误解造成的错误能被正确地诊断出来,而不致引起进一步的株连错误。
根据这样的要求,我们为PL/0编译程序制定了以下两条规则:
(1)关键字规则;程序员在写程序时,可能会因为粗心而漏掉语句的分隔符——“;”,但他决不会漏掉算术运算符“+”,对于编译程序而言,不论是分隔符号类的符号还是关键字符号类的符号,它们都具有同等重要的地位。
基于这样的特点,我们可以采用不易出错的部分来作为恢复正常步调的标记。
每当遇到错误时,分析程序跳过后面的某些部分,直到出现所期望的符号为止。
对于程序设计语言来说,这种符号(称为同步符号)的最好选择就是关键字。
PL/0的每一种构造语句以begin、if或while开头;每种说明则以var、const或procedure开头。
每遇到错误时,编译程序便可跳过一段程序,直到遇到这类符号为止,而继续编译。
(2)镇定规则;自顶向下分析的特点在于目标对分成一些子目标,分程序则用别的分析程序来处理其子目标。
镇定规则是说一个分析程序发现了错误,它不应该消极地停止前进,仅仅向调用它的程序报告发生的错误;而应该自己继续向前扫描,找到似乎可以使正常的分析得以恢复的地方。
这一规则在程序设计上的含义就是任一分析程序除了正常终止外,没有其它出口。
对于镇定规则,一个可能的严格解释为:一旦发现非法结构,即跳过后面的输入正文,直到下一个可以正确地跟随当前正在分析的句子结构的符号为止。
这意味着每一分析程序需知道其当前活动结点的后继符号集合。
为了找到这个后继符号集合,我们给对应语法图的每一个分析过程提供一个显式参数,set,它指明可能的后继集合。
不过在任何条件下,如果都跳到输入正文中下一个这种后继符号出现的地方,未免太短视了。
程序中所含的错误可能只不过是漏掉了一个符号(如“;”)而己,由此而忽略去源程序的符号集合中,再凑加一些关键字,它们用于标记那些不容忽略的结构的开始符,因此,作为参数传递给分析过程的那些符号就不仅是后继符号了。
对于这样的符号集,我们采用这样的计算策略:先用一些明显的关键符号给它赋初值,然后随着分析子目标的层次深入,逐步补充别的合法符号。
为了灵活起见,我们引入test子程序来实现所说的验证工作。
test过程有三个参数:
(1)可允许的下一个符号集合S1,如果当前符号不在此集合中,当即得到一个错误号;
(2)另加的停止符号集合S2,有些符号的出现,虽然无疑是错的,但它们绝对不应被忽略而跳过;
(3)整数n,表示有关错误的诊断号:
void test(symset s1, symset s2, int n)
{ symset s;
if (! inset(sym, s1))
{ error(n);
s = uniteset(s1, s2);
while(! inset(sym, s))
(数据记录表及处理)
生成的代码(片段)
前面我们给出了PL/0语言写的一段程序,其中乘法过程经过编译程序产生以下代码: 2 INT 0 5 -- allocate storage
a := x
3 LOD 1 3 -- x
4 STO 0 3 -- a
b := y
5 LOD 1 4 -- y
6 STO 0 4 -- b
z := 0
7 LIT 0 0 -- 0
8 STO 1 5 -- z
b > 0
9 LOD 0 4 -- b
10 LIT 0 0 -- 0
11 OPR 0 12 -- >
12 JPC 0 29 -- if b <= 0 then goto 29
odd(b)
13 LOD 0 4 -- b
14 OPR 0 6 -- odd
15 JPC 0 20 -- if not(odd(b)) goto 20
if
16 LOD 1 5 -- z
while
z := z + a
17 LOD 0 3 -- a
18 OPR 0 2 -- +
19 STO 1 5 -- z
a := 2 * a
20 LIT 0 2 -- 2
21 LOD 0 3 -- a
22 OPR 0 4 -- *
23 STO 0 3 -- a
24 LOD 0 4 -- b。