补充：PL0编译程序的实现
第二章PLO编译程序的实现
W.Backus与丹麦的Peter Naur来命名的，它从语法上描 述程序设计语言的元语言。采用BNF就可说明哪些符号 序列是对于某给定语言在语法上有效的程序
12
BNF引入的符号：
< > 用左右尖括号括起来的中文字表示语法构造成分，
或称语法单位，为非终结符
盛 威 网 ： 专 业 的 计 算 机 学 习 网 站
图 2.2(b) PL/0的解释执行结构
24
PL/O编译程序（包括主程序）是由18个嵌套及并列的过程 或函数组成:
盛 威 网 ： 专 业 的 计 算 机 学 习 网 站
25
盛 威 网 ： 专 业 的 计 算 机 学 习 网 站
26
PL/O编译程序的过程与函数定义层次结构图
盛 威 网 ： 专 业 的 计 算 机 学 习 网 站
界符：
如‘,’、‘.’ 、‘;’ 、‘(’ 、‘)’等
33
词法分析程序GETSYM所要完成的任务：
滤空格、识别保留字 识别标识符、拼数
盛 威 网 ： 专 业 的 计 算 机 学 习 网 站
拼复合词、输出源程序
34
取字符过程GETCH：
盛 威 网 ： 专 业 的 计 算 机 学 习 网 站
43
（2）过程体的处理： 程序的主体是由语句构成的
盛 威 网 ： 专 业 的 计 算 机 学 习 网 站
处理完过程的说明后就处理由语句组成的过程体，从语法 上对语句逐句分析 当语法正确时就生成相应语句功能的目标代码
图 2.6 取字符过程GETCH
35
§2.4 PL/O编译程序的语法语义分析
语法分析的任务：识别单词符号序列是否符合给定的语法
盛 威 网 ： 专 业 的 计 算 机 学 习 网 站
标准实验报告(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语言的扩充能力，从实际的应用中深刻领悟了编译程序的原理，更加深刻的学习了理论知识。
编译原理(PL0编译程序源代码)
下载可编辑/*PL/0编译程序（C语言版）*编译和运行环境：*Visual C++6.0*WinXP/7*使用方法：*运行后输入 PL/0 源程序文件名*回答是否将虚拟机代码写入文件*回答是否将符号表写入文件* 执行成功会产生四个文件（词法分析结果.txt符号表.txt虚拟代码.txt源程序和地址.txt）*/#include <stdio.h>#include"pl0.h"#include"string"#define stacksize 500//解释执行时使用的栈int main(){bool nxtlev[symnum];printf("请输入源程序文件名:");scanf("%s",fname);fin=fopen(fname,"r");//以只读方式打开pl0 源程序文件cifa=fopen(" 词法分析结果.txt","w");fa1=fopen(" 源程序和地址 .txt","w");//输出源文件及各行对应的首地址fprintf(fa1,"输入 pl0 源程序文件名：");fprintf(fa1,"%s\n",fname);if(fin){printf("是否将虚拟机代码写入文件?(Y/N)");//是否输出虚拟机代码scanf("%s",fname);listswitch=(fname[0]=='y'||fname[0]=='Y');printf("是否将符号表写入文件?(Y/N)");//是否输出符号表scanf("%s",fname);tableswitch=(fname[0]=='y'||fname[0]=='Y');init();//初始化err=0;cc=cx=ll=0;ch=' ';if(-1!=getsym()){fa=fopen("虚拟代码.txt","w");fas=fopen(" 符号表 .txt","w");addset(nxtlev,declbegsys,statbegsys,symnum);nxtlev[period]=true;if(-1==block(0,0,nxtlev)){//调用编译程序fclose(fa);fclose(fa1);fclose(fas);fclose(fin);return 0;}if(sym!=period){error(9);//结尾丢失了句号}if(err!=0){printf("pl0源程序出现错误，退出编译!!!请从第一个错误处开始修改 .\n\n");fprintf(cifa,"源程序出现错误，请检查!!!");fprintf(fa1,"源程序出现错误，请检查!!!");fprintf(fa,"源程序出现错误，请检查!!!");fprintf(fas,"源程序出现错误，请检查!!!");}fclose(fa);fclose(fa1);fclose(fas);}fclose(fin);}else{printf("Can't open file!\n");}fclose(cifa);//printf("\n");return 0;}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[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]),"int");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;facbegsys[ident]=true;//设置因子开始符号集facbegsys[number]=true;facbegsys[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;}void error(int n){//出错处理，打印出错位置和错误编码char space[81];memset(space, 32,81);space[cc-1]=0;printf("error(%d)",n);fprintf(fa1,"error(%d)",n);case 1:printf("\t\t常量说明中的“=”写成“ := ” \n");fprintf(fa1,"\t\t常量说明中的“=”写成“ := ”\n");break;case 2:printf("\t\t常量说明中的=后应该是数字\n");fprintf(fa1,"\t\t常量说明中的 =后应该是数字\n");break;case 3:printf("\t\t常量说明符中的表示符应该是=\n" );fprintf(fa1,"\t\t常量说明符中的表示符应该是=\n");break;case 4:printf("\t\tconst,var,procedure后应为标识符 \n" );fprintf(fa1,"\t\tconst,var,procedure后应为标识符\n");break;case 5:printf("\t\t漏掉了“ , ”或“ ; ” \n" );fprintf(fa1,"\t\t漏掉了“ , ”或“ ; ”\n" );break;case 6:printf("\t\t过程说明后的符号不正确\n" );fprintf(fa1,"\t\t过程说明后的符号不正确\n");break;case 7:printf("\t\t应是语句开始符\n" );fprintf(fa1,"\t\t应是语句开始符\n" );break;case 8:printf("\t\t程序体语句部分的后跟符不正确\n" );fprintf(fa1,"\t\t程序体语句部分的后跟符不正确\n" );break;case 9:printf("\t\t程序结尾丢了句号“. ”\n\n" );fprintf(fa1,"\t\t程序结尾丢了句号“. ” \n");break;case 10:printf("\t\t语句之间漏了“; ” \n" );fprintf(fa1,"\t\t语句之间漏了“; ” \n");break;case 11:printf("\t\t标识符拼写错误或未说明\n" );fprintf(fa1,"\t\t标识符拼写错误或未说明\n");break;case 12:printf("\t\t赋值语句中，赋值号左部标识符属性应是变量\n" );fprintf(fa1,"\t\t赋值语句中，赋值号左部标识符属性应是变量\n");break;case 13:printf("\t\t赋值语句左部标识符后应是复制号“:= ” \n" );fprintf(fa1,"\t\t赋值语句左部标识符后应是复制号“:= ” \n");break;case 14:printf("\t\tcall后应为标识符 \n" );fprintf(fa1,"\t\tcall后应为标识符 \n");break;case 15:printf("\t\tcall后标识符属性应为过程\n" );fprintf(fa1,"\t\tcall后标识符属性应为过程\n");break;case 16:printf("\t\t条件语句中丢了then\n" );fprintf(fa1,"\t\t条件语句中丢了then\n");break;case 17:printf("\t\t丢了“ end”或“ ; ” \n" );fprintf(fa1,"\t\t丢了“ end”或“ ; ”\n");break;case 18:printf("\t\twhile型循环语句中丢了“do” \n" );fprintf(fa1,"\t\twhile型循环语句中丢了“do” \n");break;case 19:printf("\t\t语句后的符号不正确\n" );fprintf(fa1,"\t\t语句后的符号不正确\n" );break;case 20:printf("\t\t应为关系运算符\n" );fprintf(fa1,"\t\t应为关系运算符\n");break;case 21:printf("\t\t表达式标示符属性不能是过程\n" );fprintf(fa1,"\t\t表达式标示符属性不能是过程\n");break;case 22:printf("\t\t表达式漏掉了右括号\n" );fprintf(fa1,"\t\t表达式漏掉了右括号\n");break;case 23:printf("\t\t因子后的非法符号\n" );fprintf(fa1,"\t\t因子后的非法符号\n");break;case 24:printf("\t\t表达式的开始符不能是此符号\n" );fprintf(fa1,"\t\t表达式的开始符不能是此符号\n");break;case 25:printf("\t\t标识符越界 \n" );fprintf(fa1,"\t\t标识符越界 \n");break;case 26:printf("\t\t非法字符 \n" );fprintf(fa1,"\t\t非法字符 \n");break;case 31:printf("\t\t数越界 \n");fprintf(fa1,"\t\t数越界 \n");break;case 32:printf("\t\tread语句括号中的标识符不是变量\n" );fprintf(fa1,"\t\tread语句括号中的标识符不是变量\n");break;case 33:printf("\t\twrite()或 read() 中应为完整表达式\n" );fprintf(fa1,"\t\twrite()或 read() 中应为完整表达式\n");break;default:printf("\t\t出现未知错误 \n" );fprintf(fa1,"\t\t出现未知错误 \n");}err++;}// 漏掉空格，读取一个字符，每次读一行，存入line缓冲区，line被getsym取空后再读一// 行，被函数getsym 调用int getch(){if(cc==ll){if(feof(fin)){printf("program incomplete");return-1;}ll=0;cc=0;printf("\n%d ",cx);fprintf(fa1,"\n%d ",cx);ch=' ';while(ch!=10){if(EOF==fscanf(fin,"%c",&ch)){line[ll]=0;break;}printf("%c",ch);fprintf(fa1,"%c",ch);line[ll]=ch;ll++;}fprintf(cifa,"\n");}ch=line[cc];cc++;return 0;}int getsym(){//词法分析int i,j,k,l;while(ch==' '||ch==10||ch==9)//忽略空格换行TABgetchdo;if(ch>='a'&&ch<='z'){//以字母开头的为保留字或者标识符k=0,l=1;do{if(k<al){//al为标识符或保留字最大长度a[k]=ch;k++;}if(k==al&&l==1){error(25);l=0;}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];fprintf(cifa,"%s\t\t%ssym\n",id,id);//printf("%s\t\t%ssym\n",id,id);}else{//否则为标识符或数字sym=ident;fprintf(cifa,"%s\t\tident\n",id);//printf("%s\t\tident\n",id);}}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){//数字的长度限制fprintf(cifa,"0\t\tnumber\n");num=0;error(31);}elsefprintf(cifa,"%d\t\tnumber\n",num);//printf("%d\t\tnumber\n",num);}else{if(ch==':'){//检测赋值符号，:只能和=匹配，否则不能识别getchdo;if(ch=='='){sym=becomes;fprintf(cifa,":=\t\tbecomes\n");getchdo;}else{sym=nul;}}else{if(ch=='<'){getchdo;if(ch=='='){sym=leq;//小于等于fprintf(cifa,"<=\t\tleq\n");getchdo;}else{sym=lss;//小于fprintf(cifa,"<\t\tlss\n");}}else{if(ch=='>'){getchdo;if(ch=='='){sym=geq;// 大于等于fprintf(cifa,">=\t\tgeq\n");getchdo;}else{sym=gtr;//大于fprintf(cifa,">\t\tgtr\n");}}else{sym=ssym[ch];//不满足上述条件时按单字// 符处理switch(ch){case'+':fprintf(cifa,"%c\t\tplus\n",ch);break;case '-':fprintf(cifa,"%c\t\tminus\n",ch);break;case '*':fprintf(cifa,"%c\t\ttimes\n",ch);break;case '/':fprintf(cifa,"%c\t\tslash\n",ch);break;case '(':fprintf(cifa,"%c\t\tlparen\n",ch);break;case ')':fprintf(cifa,"%c\t\trparen\n",ch);break;case '=':fprintf(cifa,"%c\t\teql\n",ch);break;case ',':fprintf(cifa,"%c\t\tcomma\n",ch);break;case '#':fprintf(cifa,"%c\t\tneq\n",ch);break;case ';':fprintf(cifa,"%c\t\tsemicolon\n",ch);break;case '.':break;default :error(26);}if(sym!=period){//判断是否结束getchdo;}else{printf("\n");fprintf(cifa,".\t\tperiod\n");}}}}}}return 0;}//生成目标代码 // 目标代码的功能码，层差和位移量int gen(enum fct x,int y,int z){if(cx>=cxmax){//如果目标代码索引过大，报错printf("Program too long");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)){//测试sym是否属于s1，不属于则报错n error(n);while((!inset(sym,s1))&&(!inset(sym,s2))){//检测不通过时，不停获得符号，直到它属于需要或补救的集合getsymdo;}}return 0;}// 编译程序主体//lev：当前分程序所在层，tx: 名字表当前尾指针fsys ：当前模块后跟符号集合int block(int lev,int tx,bool* fsys){int i;int dx;//名字分配到的相对地址int tx0;//保留初始txint cx0;//保留初始cxbool nxtlev[symnum];dx=3;//相对地址从 3 开始，前 3 个单元即0、 1、 2 单元分别为SL: 静态链；//DL ：动态链； RA：返回地址tx0=tx;//记录本层的初始位置table[tx].adr=cx;gendo(jmp,0,0);if(lev>levmax){//层数超过3error(32);}do{if(sym==constsym){//收到常量声明printf("该语句为常量定义语句\n");getsymdo;do{constdeclarationdo(&tx,lev,&dx);//常量声明处理，dx 会改 // 变所以使用指针while(sym==comma){//处理一次多常量定义getsymdo;constdeclarationdo(&tx,lev,&dx);}if(sym==semicolon){//常量声明处理结束getsymdo;}else{error(5);//漏掉了逗号或者分号（一般是分号）}}while(sym==ident);}if(sym==varsym){//收到变量声明printf("该语句为变量声明语句\n");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){//收到过程声明printf("该语句为过程声明语句\n");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[tx0].adr].a=cx;//开始生成当前过程代码table[tx0].adr=cx;//当前过程代码地址table[tx0].size=dx;cx0=cx;gendo(inte,0,dx);//生成分配存代码if(tableswitch){//输出符号表if(tx0+1<tx){fprintf(fas,"TABLE:\n");//printf("NULL\n");}for(i=tx0+1;i<=tx;i++){switch(table[i].kind){case constant:fprintf(fas,"%d const %s ",i,table[i].name);fprintf(fas,"val=%d\n",table[i].val);break;case variable:fprintf(fas,"%d var %s ",i,table[i].name);fprintf(fas,"lev=%daddr=%d\n",table[i].level,table[i].adr);break;case procedur:fprintf(fas,"%d proc %s ",i,table[i].name);fprintf(fas,"lev=%daddr=%dsize=%d\n",table[i].level,table[i].adr,table[i].size);break;}}}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(cx0);//输出代码return 0;}//k:const var procedure//ptx:符号表尾的指针//pdx:dx为当前应分配变量的相对地址//lev: 符号名字所在的层次// 往符号表中添加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 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++){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,cx1,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;printf("该语句为赋值语句。
编译原理课程设计报告PL0编译程序改良及完善
燕山大学《编译原理课程设计》题目：《PL/0编译程序改良及完善》姓名：简越班级：06级运算机应用3班学号：060104010084日期：2020年7月15日设计题目：PL/0编译程序改良及完善。
设计目的：阅读研究，改良设计和调试一个简单的编译程序。
加深对编译理论和进程的了解。
设计要求：1.有选择的对PL/0编译源程序补充，完善.2.设计编译典型的运行实例，以便反映出自己作出改良后的编具有的功能。
设计思想：PL/0语言能够看成PASCAL语言的子集，它的编译程序是一个编译说明执行系统。
PL/0的目标程序为假想栈式运算机的汇编语言，与具体运算机无关。
PL/0的编译程序和目标程序的说明执行程序都是用PASCAL语言书写的，因此PL/0语言可在配备PASCAL语言的任何机械上实现。
其编译进程采纳一趟扫描方式，以语法分析程序为核心，词法分析和代码生成程序都作为一个独立的进程，当语法分析需要读单词时就挪用词法分析程序，而当语法分析正确需要生成相应的目标代码时，那么挪用代码生成程序。
用表格治理程序成立变量、常量和进程表示符的说明与引用之间的信息联系。
当源程序编译正确时，PL/0编译程序自动挪用说明执行程序，对目标代码进行说明执行，并按用户程序的要求输入数据和输出运行结果。
要紧变量说明：/*变量说明*/FILE* fas; /*输出名字表*/FILE* fa; /*输出虚拟机代码*/FILE* fa1; /*输出源文件及其各行对应的首地址*/FILE* fa2; /*输出结果*/bool listswitch; /*显示虚拟机代码与否*/bool tableswitch; /*显示名字表与否*/char ch; /*获取字符的缓冲区，getch利用*/enum symbol sym; /*当前的符号*/char id[al+1]; /*当前ident，多出的一个字节用于寄存0*/ int num; /*当前number*/int cc,ll; /*getch利用的计数器，cc表示当前字符（ch）的位置*/int cx; /*虚拟机代码指针，取值范围[0，cxmax-1]*/char line[81]; /*读取行缓冲区*/char a[al+1]; /*临时符号，多出的一个字节用于寄存0*/ 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]; /*表示因子开始的符号集合*//* 目标指令*/一、LIT:将常量值取到运行栈顶.二、LOD:将变量放到运行栈顶.3、STO:将栈顶的内容送入某变量单元中.4、CAL:挪用进程的指令.五、INT:为被挪用的进程(或主程序)在运行栈中开辟数据区.六、JMP:无条件转移指令.7、JPC:条件转移指令,当栈顶的布尔值为真时, 顺序执行,不然转向域的地址.八、OPR:系运算符和算术运算指令.将栈顶和次栈顶的内容进行运算,结果寄存栈顶./*函数说明*/void error(int n,int line)说明：犯错处置函数，打印犯错信息，错误总数加1。
第2章 PL0编译程序的实现
1
2. 1 PL/0语言描述
终结符和非终结符 ➢ 终结符是最小的语法单位，例如构成文法的单词。 ➢ 非终结符是一个语法单位，它可以由其他一些语法单位组 成，即可以由其他一些终结符和非终结符串、或终结符串 组成。
PL/0语言的语法描述图 ➢ 用圆圈表示终结符 ➢ 用长方形表示非终结符
10
回家作业
1 编写一个PL0语言的程序，要求：
a) 声明2个常数，c1为2，c2为10 b) 声明3个变量，num1、count和sum c) 第一条语句是赋值语句，将c1赋给num1 d) 第二条语句是条件语句，如果num1>0，则执行第三条语句，
否则将num1减1 e) 第三条语句是赋值语句，将0赋给sum e) 第四条语句是循环语句，循环变量count从1到c2，每次将
常量说明部分
变量说明部分 过程说明部分
语句
<分程序>::=[<常量说明部分>][<变量说明部分>][<过程说明部分>]<语句>
9
由语法描述图转化到BNF范式
常量定义
<常量说明部分>::=CONST<常量定义>{,<常量定义>}； <常量定义>::=<标识符>=<无符号整数> <无符号整数>::=<数字>{<数字>}
a+2(x+10)是不是表达式？
6
BNF范式
BNF(Backus Normal Form)范式表示
< > 用左右尖括号括起来的中文字表示待描述的语法 成分<语法单位>，为非终结符
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的取值取至栈顶。
PL0编译程序的实现(精)
( 0) ( 1) ( 2) ( 3) ( 4) ( 5) ( 6) ( 7) ( 8) ( 9) (10) (11) (12) (13) (14) (15) (16) (17) (18) (19) (20) (21) (22) (23) (24)
jmp jmp int lod lit opr sto opr int opr sto lod lit opr jpc cal lit lod opr opr opr opr sto jmp opr
PL/0编译程序功能的框架 PL/0源程序 PL/0编译程序
类 pcode代码
类 pcode解释程序 输入 输出
第2 章
PL/0编译程序的实现
步骤1. 源语言PL/0与目标代码类pcode 之间的映射 步骤2. PL/0编译程序的总体设计 步骤3. PL/0编译程序词法分析的设计与实现 步骤4. PL/0编译程序语法语义分析的设计与实现 步骤5. PL/0编译程序代码生成的实现 *步骤6. PL/0编译程序错误处理的实现 步骤7. 类pcode代码解释器的设计与实现
步骤1 PL/0程序到类pcode代码的映射
目标代码类pcode是一种假想栈式计算机的汇编 语言。 指令格式 f l a
f
l a
功能码
层次差 （标识符的引用层减去它的定义层） 根据不同的指令有所区别
假想栈式计算机的运行栈 T是栈顶指针 B是基地址：分配给一个过程数据空间的开始位置 T
B
2 1 0
步骤3
PL/0编译程序词法分析的 设计与实现
词法分析如何把单词传递给语法分析 单词定义（见教材288页） type symbol=(nul,ident,number,plus,…, varsym,procsym); （ 定义纯量/枚举类型，类似C的enum） sym:symbol; id:alfa; (type alfa=packed array[1..al] of char) al=10; num:integer;
PL0编译程序的实现
出错处理程序 表格管理程序
2. PL/0编译程序的结构 PL/0源程序 词法分析程 序
语法语义分析程序
代码生成程序
目标程序
PL/0编译系统的结构框架
PL/0源程序
PL/0编译程序
目标代码
解释执行程序
输入
wsym[6]=(symbol)oddsym;
wsym[7]=(symbol)procsym;
wsym[8]=(symbol)readsym;
wsym[9]=(symbol)thensym;
wsym[10]=(symbol)varsym;
wsym[11]=(symbol)whilesym;
wsym[12]=(symbol)writesym;
｝‘）’
❖＜写语句＞ ::= WRITE’（’＜表达式＞｛，＜表达式＞ ｝‘）’
❖＜字母＞ ::= a|b|…|X|Y|Z ❖＜数字＞ ::= 0|1|…|8|9
2.2 PL/0编译程序的结构
PL/0的目标程序为假想栈式计算机的汇编语言，与计算机 无关
PL/0的编译程序和目标程序的解释执行程序可用各种语言 编写。
❖＜表达式＞ ::=[＋｜－]＜项＞｛＜加法运算符＞＜ 项＞｝
❖＜项＞ ::= ＜因子＞｛＜乘法运算符＞＜因子＞｝ ❖＜因子＞ ::= ＜标识符＞｜＜无符号整数＞｜‘（’＜
表达式＞‘）’
❖＜加法运算符＞ ::= ＋｜－ ❖＜乘法运算符＞ ::= *｜/ ❖＜关系运算符＞ ::= ＝｜＃｜＜｜＜＝｜＞｜＞＝ ❖＜条件语句＞ ::= IF＜条件＞THEN＜语句＞ ❖＜过程调用语句＞ ::= CALL＜标识符＞ ❖＜当型循环语句＞ ::= WHILE＜条件＞DO＜语句＞ ❖＜读语句＞ ::= READ’（’＜标识符＞｛，＜标识符＞
编译原理PL0编译程序的实现1(希赛教育基础学院)
◇第二章PL/0编译程序的实现【课前思考】复习第1章介绍的一个高级程序设计语言编译程序的功能和实现的步骤。
编译程序就是一个语言的翻译程序，通常是把一种高级程序设计语言（称源语言）书写的程序翻译成另一种等价功能语言（称目标语言）的程序。
换句话说，编译是指把一种用源语言表示的算法转换到另一种等价的用目标语言表示的算法。
编译程序实现的必要步骤有词法、语法、语义分析和代码生成。
此外必需有符号表管理程序和出错处理程序。
本章介绍的PL/0编译程序的实现是用PASCAL语言书写的。
【学习目标】本章目的：以PL/0语言编译程序为实例,学习编译程序实现的基本步骤和相关技术，对编译程序的构造和实现得到一些感性认识和建立起整体概念，为后面的原理学习打下基础。
◇了解并掌握用语法图和扩充的巴科斯-瑙尔范式(EBNF)对PL/0语言的形式描述。
◇了解并掌握PL/0语言编译程序构造和实现的基本技术和步骤。
◇了解并掌握PL/0语言编译程序的目标程序在运行时数据空间的组织管理。
【学习指南】◇要求读者阅读PL/0语言编译程序文本，了解一个编译程序构造的必要步骤和实现技术。
一个编译程序的实现比较复杂，读懂一个典型的程序从设计思想到实现技术也有一定难度，特别是入门开始需要耐心。
一但读懂，不仅了解编译程序的实现方法和技术，还可学到许多编程技巧和好的编程风格。
◇阅读PL/0语言编译程序文本时，应从整体结构开始逐步细化，弄清楚每个过程的功能和实现方法及过程之间的相互关系。
◇建议用一个PL/0源程序的例子为导引作为阅读PL/0语言编译程序文本的入门，然后再逐步全面读懂。
◇通过对PL/0语言编译程序某些指定功能的扩充，加深对编译程序构造步骤和实现技术的理解，并能在实践中应用。
【难重点】重点：◇弄清源语言(PL/0)目标语言(类pcode)实现语言（pascal) 这3个语言之间的关系和作用。
◇掌握用语法图和扩充的巴科斯-瑙尔范式(EBNF)对一个高级程序设计语言的形式描述。
第2章 PL-0编译程序的实现
3、PL/0编译程序是用PASCAL语言编写， 可在任何配有PASCAL编译系统的计算机 上运行。
PL/0 Compiler 源文本
PASCAL Compiler
PL/0 Compiler 目标文本
PL/0 Compiler 目标文本
PL/0 目标程序
PL/0 源程序
2.2 PL/0编译程序的结构
第 2章 PL/0编译程序的实现
2.1 2.2 2.3 2.4 2.5
PL/0语言描述 PL/0编译程序的结构 PL/0编译程序的语法语义分析 PL/0编译程序的错误处理 类pcode代码解释器
本章目的：以PL/0为实例,学习编译 程序实现的基本步骤和相关技术
PL/0语言简介 PL/0是一个非常小的程序设计语言， 它是由Pascal的发明人Niklaus Wirth所定 义的。它是Pascal的一个子集，有嵌套的 过程，但过程不能有参数，没有函数，没 有分支语句，没有for 循环，条件语句不支 持else，只有一个整数数据类型。
程序
分程序
.
内的文字表示非终结符 或 内的文字或符号表示终结符
2.1.1 PL/0语言的语法描述图
语法描述图 下页
分程序
Const , ;
ident
=
number
Var
, ; ;
procedure
ident
ident
;
分程序
语句
语句
ident call begin
:=
表达式
ident
.
语句 语句
0 l l l 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
a a a a a a a 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
编译原理第二章解析
0 jmp 0 8 1 jmp 0 2 2 int 0 3 3 lod 1 3 4 lit 0 10 5 opr 0 2 6 sto 1 4 7 opr 0 0 8 int 0 5 9 opr 0 16 10 sto 0 3 11 cal 0 2 12 lod 0 4 13 opr 0 14 14 opr 0 15 15 opr 0 0
8
PL/0的语法描述图
分程序 程序
分程序
const
ident
=
number
.
,
;
var
，
ident
;
;
procedure
ident
;
分程序
语句
9
PL/0语言文法的EBNF表示
BNF与EBNF的介绍
BNF引入的符号： < > 用左右尖括号括起来的语法成分为非终结符 ∷= ‘定义为’ | ‘或’ EBNF引入的符号： { } 表示花括号内的语法成分可重复内的成分优先
3
认识源语言PL/0与目标代码 pcode及它们之间的映射
何为PL/0语言? 认识目标代码pcode PL/0程序到pcode代码的映射
4
何为PL/0语言?
PL/0语言：PASCAL语言的子集，功能简单， 结构清晰，可读性强，具备了一般高级语 言的必备部分 PL/0程序示例 PL/0的非形式描述 PL/0的语法描述图 PL/0语言文法的EBNF表示
0 l l l 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
a a a a a a a 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
PL0编译程序的实现-教案
10
11
12
ô ¯ Æ ¶ Ã õ µ Ö ³ Ö
编 译 程 序 总 体 流 程 图
ôÃ GETSYMÈ ¥ Ê µ Ó ¡ µ ´ ôÃ BLOCK¹ Ì µ Ó ù ³
±°¥ Ê µ Ç µ ´ Ç ñ ª ´ Ì ò á ÷ ø Ê ²Î Ô ³ Ð ½ Ê ² '.'£ ¿ Y ´ Ì ò Ð Ô ³ Ð Ö Ç ñ Ð í ó ¿ Ê ²Ó ´ Î £ N ôà â Í ù Ì INTERPRET µ Ó ½ Ê ¹ ³ â Í ´ Ð ¿ ê Ì ò ½ Ê Ö Ä ±³ Ð Y
23
表格管理
CONST A=35，B=49； VAR C，D，E； PROCEDURE P； VAR G
1 2
实例分析
层次/值 VAL：35 VAL：49 LEVEL：LEV LEVEL：LEV LEVEL：LEV LEVEL：LEV LEVE：LEV+1 …… 地址 存储空间
3
4 5 6 7
名字 NAME：A NAME：B NAME：C NAME：D NAME：E NAME：P NAME：G ……
变量 b
RA 0 DL 0 SL：静态链 DL：动态链 RA：返回地址 SL 0 0 运行栈 27
允许过程嵌套、递归语言的目标程序
ห้องสมุดไป่ตู้
运行时存储空间的组织与管理
• 活动记录的内容
– 连接数据：
• RA：返回地址 • DL：动态链 • SL：静态链
– 局部变量数据区 – 临时单元
• 活动记录存储区指示器
1
PL/0语言程序实例
• • • • • • • • • • Test1.pl0 Test2.pl0 Test3.pl0 Test4.pl0 Test5.pl0 Test6.pl0 Test7.pl0 Test8.pl0 Test9.pl0 Test.pl0 : 最简单的PL/0程序 : 用while语句求累加和 ：含有“过程”子程序 ：定义全局量、“过程”中的局部量 ：用同一标识符定义全局量和局部量 : 递归调用计算n! ：“过程”嵌套，全局量和局部量为同一标识符 ：多个过程嵌套或并列 : 定义全局常量和变量、局部常量和变量 ：I/O语句中使用多个变量
PL0编译程序的实现
译程序实现的基本步骤和相关技术，对编译程序的 构造和实现得到一些感性认识和建立起整体概念， 为后面的原理学习打下基础。
◇ 了解并掌握用语法图和扩充的巴科斯-瑙尔 范式(EBNF)对计算机语言的形式描述。
【难 重 点】 重点： ◇ 弄清源语言(PL/0)目标语言(类 pcode)实现
2. V集n合是N一on个-te非rm空in有als穷，集且合V，t称Vn作= 非。终结符号 3. S Vn ，称作开始符号Start Symbol 。 4. P是一个非空有穷集合，称为产生式集合
Production Rules ，每条产生式形为A，其22 中AV ，(V V )*。
例2.1 简单的算术表达式
17
Bakus-Naur范式(BNF)
18
Examples of BNF
19
Syntax Graph
20
2.2 语法定义
❖ 语法描述程序设计语言的层次结构，如C语言 的条件语句为
if_stmt if (expr) stmt else stmt if_stmt if (expr) stmt
string
string + string
string - string 2
9
5
string
string - string
9 string + string
5
2
对某个文法，如一个句子有两棵以上的分析树，称为
二义（歧义）文法。
29
2.2.3 Associativity of Operators
❖ 可以用括号来表明计算顺序，如 9-5+2 = (9-5)+2
cha2 PL0编译程序的实现(补充)
写操作 调用返回
22
PL/0程序如下：
BEGIN b:=8; READ( c ); WHILE c>0 DO BEGIN WRITE(b); CALL s; b:=b+c; WRITE(b); READ( c ); END; CALL p END.
52 53 54 55 56 57 58 59 60 61 62 63 64 INT LIT STO OPR STO LOD LIT OPR JPC LOD OPR OPR CAL 0 0 0 0 0 0 0 0 0 0 0 0 0
7
8条伪代码的指令
OPR：关系或算数运算； L：0； A：具体运算（0～6，8～13），运算 对象取自S栈栈顶和次栈顶；
8
8条伪代码的指令
OPR，0，0 OPR，0，1 OPR，0，2 OPR，0，3 OPR，0，4 OPR，0，5 OPR，0，6
调用返回； 取“负”运算； 加法运算； 减法运算； 乘法运算； 除法运算； 取奇运算；
17
伪代码的生成顺序
（8）为主程序main产生目标代码程序块， 其入口地址为L： L:INT 0 A1(主程序main所需单元个数） …… OPR 0 0
18
伪代码的生成顺序
JMP 0 L JMP 0 L1 JMP 0 L2 JMP 0 L3 L3:过程P3目标程序代码 L2:过程P2目标程序代码 L1:过程P1目标程序代码 L:主程序main目标程序代码
21
PL/0程序如下：
BEGIN d:=a+b; WRITE(d); CALL q END; PROCEDURE s; BEGIN CALL p; b:=-10; WRITE(b) END;
PL000编译程序
第二章 编译程序的实现
26
2、PL/0语法规则的BNF表示
<写语句>::= WRITE(<表达式>{, <表达式>}) <写语句>举例： WRITE( a+b,b*c);
第二章 编译程序的实现
27
2、PL/0语法规则的BNF表示
<过程调用语句>::=CALL <标识符>; <过程调用语句>举例：
第二章 编译程序的实现
30
2、PL/0语法规则的BNF表示
<因子>::=
<标识符>|<常量>|(<表达式>)
PROCEDURE FACTOR P294~P295
第二章 编译程序的实现
31
2、PL/0语法规则的BNF表示
<项>::=
<因子>|<项> <乘法运算符><因子>
<乘法运算符>::=*|/
第二章 编译程序的实现 38
符号表的内容
标识符名：NAME
类型：KIND ①CONSTANT(常量）
②VARIABLE(变量） ③PROCEDURE(过程） 值或层次：VAL或LEVEL 地址：ADR 大小：SIZE
第二章 编译程序的实现 39
地址：ADR
地址：ADR 简单变量或常量：该量在数据区所占单元 的绝对地址或相对地址；
（PROGRAM PROGSYM），（mysource IDENT) , (CONST CONSTSYM) , (a IDENT) , (= EQL) , (10 NUMBER) , (; SEMICOLON) , (VAR VARSYM) , (b IDENT) , (, COMMA) , (c IDENT) , (; SEMICOLON) , (PROCEDURE PROCSYM) , …… (g IDENT) , (:= BECOMES) , (a IDENT) , (+ PLUS) , (e IDENT) , (; SEMICOLON) This is a assign Statement;(赋值语句) (f IDENT) , (:= BECOMES) , (g IDENT) , (; SEMICOLON) This is a assign Statement; (赋值语句) (WRITE WRITESYM) , (( LPAREN) , (g IDENT) , ( ) RPAREN) , (; SEMICOLON) This is a write Statement;(写语句) ……
chPL编译程序的实现
begin read(n); call rec;
end. 8
计算 sum = 1! + 2 ! + ... + n!,
n从控制台读入
begin
{ 读入n }
var n, m, fact, sum;
read(n); sum := 0;
{ 递规计算 fact = m! }
while n > 0 do
24
通过三个全程量 SYM 、ID和NUM 将识别出的单词信息传递给 语法分析程序。
SYM：存放单词的类别
如：有程序段落为：
begin initial := 60；end
对应单词翻译后变为：
begin beginsym, initial ident,
‘:= ‘ becomes, 60 number, ‘；’ semicolon，
保留字表：（ begin (* main * ) ）
word[1]:=‘begin
‘；word[2]:=‘call ‘；
...
word[13]:=‘write
‘；
查到时找到相应的内部表示
Wsym[1]:=beginsym; wsym[2]:=callsym；
…
wsym[13]:=writesym；
23
(18) opr 0 4 次栈顶与栈顶相乘(2*c)
(19) opr 0 14 栈顶值输出至屏幕 (20) opr 0 15 换行 (21) opr 0 16 从命令行读取值到栈顶 (22) sto 0 3 栈顶值送变量b中 (23) jmp 0 11 无条件转到循环入口(11) (24) opr 0 0 结束退栈
19
第2章 PL/0编译程序
第2章 PL0编译程序的实现(4学时)
表格管理举例
CONST A=35，B=49； VAR C，D，E； PROCEDURE P； VAR G
名字
TX0 NAME：A
类型
层次/值
地址
存储空间
NAME：B NAME：C NAME：D NAME：E NAME：P TX1 NAME：G ……
KIND：CONSTANT KIND：CONSTANT KIND：VARIABLE KIND：VARIABLE KIND：VARIABLE KIND：PROCEDUR KIND：VARIABLE ……
何为PL/0语言?
PL/0语言： PASCAL语言的子集，功 能简单，结构清晰，可 读性强，具备了一般高 级语言的必备部分。
PL/0程序示例： CONST A=10; VAR B,C; PROCEDURE P; VAR D; PROCEDURE Q; VAR X; BEGIN READ(X); D:=X; WHILE X#0 DO CALL P; END; BEGIN WRITE(D); CALL Q; END; BEGIN CALL P; END.
存储空间
SIZE：4
ADR：DX SIZE：4 SIZE：5 ADR：DX ADR：DX ADR：DX+1 SIZE：5 ADR：DX ADR：DX+1
15 15
2.5 PL/0编译程序的目标代码结构和代码生成
• 目标代码pcode是一种假想栈式计算机的汇编语言。
• 指令格式 功能码
f l
a
层次差 通常为“位移量” 根据不同的指令 有所不同
18
Const a=10; var b,c; procedure p; begin c:=b+a; end; begin read(b); call p; write(c); end.
PL0语言编译器的设计与实现
PL0语⾔编译器的设计与实现⼀、设计任务1.1程序实现要求PL/0语⾔可以看成PASCAL语⾔的⼦集，它的编译程序是⼀个编译解释执⾏系统。
PL/0的⽬标程序为假想栈式计算机的汇编语⾔，与具体计算机⽆关。
PL/0的编译程序和⽬标程序的解释执⾏程序都是⽤JAVA语⾔书写的，因此PL/0语⾔可在配备JDK的任何机器上实现。
其编译过程采⽤⼀趟扫描⽅式，以语法分析程序为核⼼，词法分析和代码⽣成程序都作为⼀个独⽴的过程，当语法分析需要读单词时就调⽤词法分析程序，⽽当语法分析正确需要⽣成相应的⽬标代码时，则调⽤代码⽣成程序。
⽤表格管理程序建⽴变量、常量和过程标⽰符的说明与引⽤之间的信息联系。
⽤出错处理程序对词法和语法分析遇到的错误给出在源程序中出错的位置和错误性质。
当源程序编译正确时，PL/0编译程序⾃动调⽤解释执⾏程序，对⽬标代码进⾏解释执⾏，并按⽤户程序的要求输⼊数据和输出运⾏结果。
1.2 PL/0语⾔的BNF描述（扩充的巴克斯范式表⽰法）<prog> → program <id>；<block><block> → [<condecl>][<vardecl>][<proc>]<body><condecl> → const <const>{,<const>};<const> → <id>:=<integer><vardecl> → var <id>{,<id>};<proc> → procedure <id>（[<id>{,<id>}]）;<block>{;<proc>}<body> → begin <statement>{;<statement>}end<statement> → <id> := <exp>|if <lexp> then <statement>[else <statement>]|while <lexp> do <statement>|call <id>（[<exp>{,<exp>}]）|<body>|read (<id>{，<id>})|write (<exp>{,<exp>})<lexp> → <exp> <lop> <exp>|odd <exp><exp> → [+|-]<term>{<aop><term>}<term> → <factor>{<mop><factor>}<factor>→<id>|<integer>|(<exp>)<lop> → =|<>|<|<=|>|>=<aop> → +|-<mop> → *|/<id> → l{l|d} （注：l表⽰字母）<integer> → d{d}注释：<prog>：程序；<block>：块、程序体；<condecl>：常量说明；<const>：常量；<vardecl>：变量说明；<proc>：分程序； <body>：复合语句；<statement>：语句；<exp>：表达式；<lexp>：条件；<term>：项； <factor>：因⼦；<aop>：加法运算符；<mop>：乘法运算符； <lop>：关系运算符。
COMPILER-PL0语言的示例-语法描述
补充: PL/0语言及其编译程序的实现✧PL/0语言的编译程序把PL/0语言程序翻译成为一种称为类pcode的假想的栈式计算机汇编语言程序。
这种汇编语言与机器无关，若要在某一机器上实现PL/0语言程序，只需用机器上配置的任何语言对类pcode语言程序进行解释执行。
✧世界著名计算机科学家N.Wirth编写了"PL/0语言的编译程序"。
✧后面附了PL/0编译程序源代码。
⏹何为PL/0语言－PL/0语言是PASCAL语言的子集. 具备了一般高级语言的必备部分.(如: read，write，if－then，do，while，call，begin－end，赋值语句)☐PL/0语言中的数据类型只有整型，没有浮点数，所以圆周率只能近似为3。
数字最多为14位。
标识符的有效长度是10 ☐PL/0语言允许过程嵌套定义和递归调用的。
过程最多可嵌套三层。
☐过程可以引用自己定义的局部标识符，也可以引用包围在它的外过程（包括主程序）定义的标识符。
以下将用扩充的巴科斯-瑙尔范式（BACKUS-NAUR FORM）和语法图(EBNF)两种形式给出PL/0语言的语法描述。
------------------------------------------------------------------------------------------------------------------------------------------------------- (a) PL/0语言文法的EBNF表示EBNF表示的符号说明1)〈〉：用左右尖括号括起来的中文字表示语法构造成分，或称语法单位，为非终结符。
2)∷= ：该符号的左部由右部定义，可读作'定义为'。
3)| ：表示'或'，为左部可由多个右部定义。
<标识符| 常量> 是不允许的. 因为非终结符作为一个独立的单位,不可分割4){ } ：花括号表示其内的语法成分可以重复。