编译原理课程实验指导书-PL0语言及其编译器
标准实验报告(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语言的扩展1、课程实践要完成下列要求（1）给PL/0语言增加像C语言那样的形式为/*……*/的注释。
（2）给PL/0语言增加带else子句的条件语句和exit语句。
（3）给PL/0语言增加输入输出语句。
（4）给PL/0语言增加带参数的过程。
（5）给PL/0语言增加布尔类型。
（6）给PL/0语言增加数组类型。
（7）给PL/0语言增加函数类型。
（8）给PL/0语言增加实数类型。
（9）分离解释器和编译器为两个独立的程序。
2、扩展后的PL/0语言的语法Program →Block .Block →[ConstDecl][TypeDecl][VarDecl][FuncDecl] StmtConstDecl →const ConstDef {, ConstDef} ;ConstDef →ident = numberTypeDecl →type TypeDef ; {TypeDef ;}TypeDef →ident = TypeExpTypeExp →integer | real | Boolean | array‘[’number .. number‘]’of TypeExpVarDecl →var VarDecl ; {VarDecl ;}VarDec →ident {, ident} : TypeType →integer | real | Boolean | identFuncDecl →FuncDec { FuncDec }FuncDec→procedure ident [ ( ForParal ) ]; Block ; |function ident [ ( ForParal ) ] : Type ; Block ;ForParal →ident : Type {; ident : Type }Stmt →IdentRef := Exp | if Exp then Stmt | if Exp then Stmt else Stmt |begin Stmt {; Stmt } end | while Exp do Stmt | exit | ε |call ident [ ( ActParal ) ] | write ( Exp [, Exp ] ) |read (IdentRef [, IdentRef ] )IdentRef →ident [ ‘[’Exp‘]’ { ‘[’Exp‘]’ } ]ActParal →Exp {, Exp }Exp →odd SimpExp | SimpExp RelOp SimpExpRelOp →= | <> | < | > | <= | >=SimpExp →[+ | - ] Term {+ Term | - Term | or Term}Term →Factor {* Factor | / Factor | div Factor | mod Factor | and Factor}Factor →IdentRef | number | ( Exp ) | not Factor | ident [ ( ActParal ) ] |true | false有关该扩展的说明如下：（1）描述语言的部分符号的解释符号→、|、[、]、{和}是描述语言的符号，其中方括号[…]中的部分可以出现0次或1次，花括号{…}中的部分可以出现任意次数，包括0次。
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的取值取至栈顶。
编译原理实验报告--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%)对题目各项要求自行分点论述设计修改过程。
编译原理实践4——程序设计语言PL0
2.EBNF定义的PL/0语法
program = block ".".
A program is a block.
block = [ "const" ident "=" number { "," ident "=" number } ";" ] [ "var" ident { "," ident } ";" ] { "procedure" ident ";" block ";" } statement.
3. PL/0语法图
block—分程序 statement—语句 condition---条件 expression---表达式 term---项 factor---因子
4.判别是否符合两条限制规则
方法： 1)找出图中每一个分支点，考察每一个分 支点的各个分支的头符号是否相异 2)找出图中每一个透明结构，考察每个透 明结构，考察每个透明结构的头符号集 合与其跟随符号集合是否相异 结论：PL/0语言文法符合两条限制规则， 可以应用简单辨认算法的LL(1)文法。
保留字: begin, call, const, do, end, if, odd, procedure, then, var, while 符号: . , ; := + - * / ( ) 标识符:以字母开头的，任意字母和数字组成 的序列 数:阿拉伯数字的序列 关系运算符: < > <= >= # =
var a, b; begin a:=10; if a < 12 then b := a/2; end.
编译实验指导书-2012.9.18
编译原理实验指导书实验一词法分析一、实验目的通过实现PL/0语言（一种示例小语言）的词法分析器，理解词法分析过程，掌握程序各部分之间的接口安排。
二、实验要求1、要求每位同学单独完成词法分析器，并接受检查；2、撰写实验报告。
(1) 用有限自动机画出“三、实验内容”中的词法规则；(2) 实验报告不要摘抄全部代码，但需要流程图的形式描述程序结构；(3) 必须书写设计和实现的过程中出现的一些问题以及解决方法。
三、实验内容1、PL/0语言的单词结构关键字(10个)：begin, end ,if ,then, while, do, const, var,call,procedure标识符：字母序列，最大长度10常数：整型常数算符和界符（17个）：+，-，*，/，odd，=，<>，<，>，<=，>=，:=，(，) ，, ，.，;2、单词的种别SYM_IDENTIFIER, 标识符SYM_NUMBER, 常数SYM_PLUS, +SYM_MINUS, -SYM_TIMES, *SYM_SLASH, /SYM_ODD, oddSYM_EQU, =SYM_NEQ, <>SYM_LES, <SYM_LEQ, <=SYM_GTR, >SYM_GEQ, >=SYM_LPAREN, (SYM_RPAREN, )SYM_COMMA, ,SYM_SEMICOLON, ;SYM_PERIOD, .SYM_BECOMES, :=SYM_BEGIN, beginSYM_END, endSYM_IF, ifSYM_THEN, thenSYM_WHILE, whileSYM_DO, doSYM_CONST, constSYM_V AR, varSYM_CALL，callSYM_PROCEDURE procedure3、PL/0的语言的词法分析器将要完成以下工作：（1）跳过分隔符（如空格，回车，制表符）；（2）识别诸如begin，end，if，while等保留字；（3）识别非保留字的一般标识符，此标识符值（字符序列）赋给全局量id，而全局量sym赋值为SYM_IDENTIFIER。
实验一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语言的语法规则定义了各种语句和表达式的结构，如条件语句、循环语句、赋值语句等。
PL-0-语言编译器分析实验报告
PL/0 语言编译器分析实验一、实验目的通过阅读与解析一个实际编译器（PL/O语言编译器）的源代码，加深对编译阶段（包括词法分析、语法分析、语义分析、中间代码生成等）和编译系统软件结构的理解，并达到提高学生学习兴趣的目的。
二、实验要求（1）要求掌握基本的程序设计技巧（C语言）和阅读较大规模程序源代码的能力；（2）理解并掌握编译过程的逻辑阶段及各逻辑阶段的功能；⑶要求能把握整个系统（PL/O语言编译器）的体系结构，各功能模块的功能，各模块之间的接口；（4）要求能总结出实现编译过程各逻辑阶段功能采用的具体算法与技三、实验报告pl/O语言是pascal语言的一个子集，我们这里分析的pl/O的编译程序包括了对pl/O语言源程序进行分析处理、编译生成类pcode代码，并在虚拟机上解释运行生成的类pcode代码的功能。
pl/O 语言编译程序采用以语法分析为核心、一遍扫描的编译方法。
词法分析和代码生成作为独立的子程序供语法分析程序调用。
语法分析的同时，提供了出错报告和出错恢复的功能。
在源程序没有错误编译通过的情况下，调用类pcode 解释程序解释执行生成的类pcode代码。
词法分析子程序分析：词法分析子程序名为getsym,功能是从源程序中读出一个单词符号（token），把它的信息放入全局变量sym id和num中，语法分析器需要单词时，直接从这三个变量中获得。
（注意！语法分析器每次用完这三个变量的值就立即调用getsym 子程序获取新的单词供下一次使用。
而不是在需要新单词时才调用getsym过程。
）getsym过程通过反复调用getch子过程从源程序过获取字符，并把它们拼成单词。
getch 过程中使用了行缓冲区技术以提高程序运行效率。
词法分析器的分析过程：调用getsym时，它通过getch过程从源程序中获得一个字符。
如果这个字符是字母，则继续获取字符或数字，最终可以拼成一个单词，查保留字表，如果查到为保留字，则把sym变量赋成相应的保留字类型值；如果没有查到，则这个单词应是一个用户自定义的标识符（可能是变量名、常量名或是过程的名字），把sym 置为ide nt ,把这个单词存入id变量。
PL0编译程序设计说明书
PL/0编译程序设计说明书小组组长：李文（00000000）小组成员：******（00000000）******（00000000）******（00000000）******（00000000）2006年1月16日1引言 (3)1.1编写目的 (3)1.2背景 (3)1.3定义 (3)1.4参考资料 (5)2总体设计 (5)2.1需求规定 (5)2.2运行环境 (6)2.3模块流程 (6)2.4模块机理说明 (7)2.5模块设计与实现 (10)2.6人工处理过程 (12)2.7程序的亮点 (13)2.8尚未问决的问题 (13)3程序介绍和使用说明 (13)4程序测试结果分析 (16)概要设计说明书1引言1.1编写目的此文档为VK 1.0版PL/0编译器详细设计说明书，旨在说明该编译器的设计思想和实现。
此说明书可以在阅读本编译器代码时有效地帮助您理解本编译器的设计方法和实现过程，希望能提供给您所需的帮助。
1.2背景名称：VK1.0版PL/0编译器说明：此编译器为北京师范大学信息科学学院计算机科学与技术系2003级2005-2006学年度第一学期编译原理课程实验作业。
本软件由李文小组合作开发，组长李文，同组人员有吕叶、刘晟忻、肖纯、曲文星。
本软件主要用于PL/0程序的编译，软件提供生成中间代码，并执行检测。
本软件为开源软件，故除了用于编译以外还可给编译器开发者提供开发参考。
本软件开发运行在Windows 32位平台上，尚未开发其他平台版本。
1.3定义本软件开发中，用到了一些PL/0语言和PCODE的定义以及编译原理术语，下面给予说明。
●PL/0语言：BNF范式：〈程序〉∷=〈分程序〉．〈分程序〉∷=[〈常量说明部分〉][〈变量说明部分〉][〈过程说明部分〉]〈语句〉〈常量说明部分〉∷=CONST〈常量定义〉{，〈常量定义〉}；〈常量定义〉∷=〈标识符〉=〈无符号整数〉〈无符号整数〉∷=〈数字〉{〈数字〉}〈变量说明部分〉∷=V AR〈标识符〉{，〈标识符〉}；〈标识符〉∷=〈字母〉{〈字母〉|〈数字〉}〈过程说明部分〉∷=〈过程首部〉〈分程序〉{；〈过程说明部分〉}；〈过程首部〉∷=PROCEDURE〈标识符〉；〈语句〉∷=〈赋值语句〉|〈条件语句〉|〈当型循环语句〉|〈过程调用语句〉|〈读语句〉|〈写语句〉|〈复合语句〉|〈空〉；〈赋值语句〉∷=〈标识符〉∶=〈表达式〉〈复合语句〉∷=BEGIN〈语句〉{；〈语句〉}END〈条件〉∷=〈表达式〉〈关系运算符〉〈表达式〉|ODD〈表达式〉〈表达式〉∷=[+|-]〈项〉{〈加法运算符〉〈项〉}〈项〉∷=〈因子〉{〈乘法运算符〉〈因子〉}〈因子〉∷=〈标识符〉|〈无符号整数〉|'('〈表达式〉')'〈加法运算符〉∷=+|-〈乘法运算符〉∷=*|/〈关系运算符〉∷=#|=|＜|＜=|＞|＞=〈条件语句〉∷=IF〈条件〉THEN〈语句〉〈过程调用语句〉∷=CALL〈标识符〉〈当型循环语句〉∷=WHILE〈条件〉DO〈语句〉〈读语句〉∷=READ'('〈标识符〉{，〈标识符〉}')'〈写语句〉∷=WRITE'('〈表达式〉{，〈表达式〉}')'〈字母〉∷=a|b|…|X|Y|Z〈数字〉∷=0|1|2|…|8|9PL/0语言允许过程嵌套定义，函数及变量作用于本层。
编译原理第2版第二章PL0编译程序
词法分析如何把单词传递给语法分析 type symbol=(nul,ident,number,plus,…,varsym,procsym)；
3个全程量 SYM:symbol; ID:alfa; NUM:integer;
通过三个全程量 SYM 、ID和NUM 将识别出的单词信息传递给语 法分析程序。 SYM：存放单词的类别 如：有程序段落为： begin initial := 60；end 对应单词翻译后变为： begin beginsym, initial ident, ‘:= ‘ becomes, 60 number, ‘；’ semicolon， end endsym 。 ID： 存放用户所定义的标识符的值 如： initial （在 SYM中放ident，在ID中放initial） NUM：存放用户定义的数 如：60 （在SYM中放number,在NUM中放60）
OPR 0 12 OPR 0 13
次栈顶是否大于栈顶，退两个栈元素，结果值进栈 次栈顶是否小于等于栈顶，退两个栈元素，结果值进栈
OPR 0 14 OPR 0 15 OPR 0 16
栈顶值输出至屏幕 屏幕输出换行 从命令行读入一个输入置于栈顶
const a=10; var b,c; procedure p;
出错处理程序 表格管理程序
PL/0编译程序的结构
PL/0源程序 词法分析程 序 语法语义分析程序
代码生成程序
目标程序
PL/0编译程序的总体设计
以语法、语义分析程序为核心 词法分析程序和代码生成程序都作为一个过程， 当语法分析需要读单词时就调用词法分析程序， 而当语法、语义分析正确，需要生成相应的目标 代码时，则调用代码生成程序。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
《编译原理》课程实验指导书（Compiler Principle）目录序言 (1)一、实验安排 (2)第一阶段：编译器的词法分析 (2)第二阶段：编译器的语法分析 (2)第三阶段：编译器的代码生成 (3)二、考核方式及评定标准 (4)三、参考资料与编译器分析 (4)第一部分PL语言及其编译器 (4)1. PL语言介绍 (4)1.1 PL语言的语法图 (5)2. PL语言编译器 (8)2.1 词法分析 (9)2.2 语法分析 (9)2.3 语义分析 (11)2.4代码生成 (11)2.5 代码执行 (13)2.6 错误诊断处理 (15)2.7 符号表管理 (17)2.8其他 (18)第二部分上机实验要求 (19)第三部分PL语言编译器源程序与示例 (21)1．示例与结果表示 (21)1.1 PL语言源程序 (21)1.2 生成的代码（片段） (28)2.PL语言编译器源程序 (28)序言本《编译原理》实验，其目的是让大家动手设计和实现一个规模适中的语言的编译器，该编译器不仅涉及编译程序的各个阶段，而且也强调了编译的总体设计、各个阶段的接口安排等等。
通过上机实践，来设计这个相对完整的编译器，一方面可以使同学们增加对编译程序的整体认识和了解——巩固《编译原理》课程所学知识，另一方面，通过上机练习，学生也可以学到很多程序调试技巧和设计大型程序一般的原则，如模块接口的协调，数据结构的合理选择等等。
为了使学生能尽早动手实践，我们建议把实践分成三部分，首先阅读本教程第一部分，在这部分就PL语言的语法及其编译程序的各个阶段作了简单介绍，以便对PL编译程序有个初步的印象。
其次要认真阅读理解第三部分所给出的PL编译器源程序及示例，使上一阶段的初步印象得以加深、具体化。
最后按照第二部分的实验要求扩充PL语言的功能并加以实现。
具体操作时分成三个阶段：词法分析、语法分析及代码生成。
最后再统一组装成一个完整的PL编译器，并适当进行改进、补充。
一、实验安排第一阶段：编译器的词法分析学时：2（一）、实验目的：通过阅读PL的语法图，设计、编制并调试一个PL词法分析程序，加深对词法分析原理的理解。
（二）、实验内容：PL的词法分析器将要完成以下工作：（1）跳过分隔符（如空格，回车，制表符）；（2）识别诸如begin，end，if，while等保留字；（3）识别非保留字的一般标识符，此标识符值（字符序列）赋给全局量id，而全局量sym赋值为SYM_IDENTIFIER。
（4）识别数字序列，当前值赋给全局量NUM，sym则置为SYM_NUMBER；（5）识别:=，<=，>=之类的特殊符号，全局量sym则分别被赋值为SYM_BECOMES，SYM_LEQ，SYM_GEQ等。
相关过程（函数）有getsym()，getch()，其中getch()为获取单个字符的过程，除此之外，它还完成：（1）识别且跳过行结束符；（2）将输入源文件复写到输出文件；（3）产生一份程序列表，输出相应行号或指令计数器的值。
第二阶段：编译器的语法分析学时：4（一）、实验目的：掌握PL语言编译器的语法分析程序设计与LL（1）文法应用的实现方法。
（二）、实验内容：采用递归下降的方法来设计PL/0编译器，证明PL/0语言属于LL（1）文法。
然后结合语法图编写（递归下降）语法分析程序的一般方法，具体方面有：（1）用合适的替换将语法约化成尽可能少的单个图；（2）将每一个图按下面的规则（3）-（7）翻译成一个过程说明；（3）顺序图对应复合语句：（4）选择：（5）循环（6）表示另一个图A的图：（7）表示终结符的单元图：相关过程有：block(), constdeclaration(), vardeclaration(), statement(), condition(), expression(), term(), factor()等。
并画出它们之间依赖关系图，并在此基础上实现程序的编制。
并适当进行语义分析的相关检查：（1）是否存在标识符先引用未声明的情况；（2）是否存在己声明的标识符的错误引用；（3）是否存在一般标识符的多重声明。
第三阶段：编译器的代码生成学时：2（一）、实验目的：掌握PL语言编译器的中间代码生成的程序分析与实现方法，并能对错误进行分析与处理。
（二）、实验内容：为了使我们的编译程序保持适当简单的水平，不致陷入与本课程无关的实际机器的特有性质的考虑中去，我们假想有台适合PL程序运行的计算机，我们称之为PL处理机。
PL处理机顺序解释生成的目标代码。
PL处理机的指令集根据PL语言的要求而设计，它包括以下的指令：（1）LIT /* 将常数置于栈顶 */（2）LOD /* 将变量值置于栈顶 */（3）STO /* 将栈顶的值赋与某变量 */（4）CAL /* 用于过程调用的指令 */（5）INT /* 在数据栈中分配存贮空间 */（6）JMP, JPC /* 用于if, while语句的条件或无条件控制转移指令 */（7）OPR /* 一组算术或逻辑运算指令 */上述指令的格式由三部分组成：其中，f, l, a的含义见下表：表1 PL 处理机指令PL的编译程序为每一条PL源程序的可执行语句生成后缀式目标代码。
另一方面，发现错误，并给出合适的诊断信息且继续编译下去从而发现更多的错误，对于编译程序而言是完全必要的。
结合关键字规则、镇定规则，采用策略：先用一些明显的关键符号给它赋初值，然后随着分析子目标的层次深入，逐步补充别的合法符号。
并编写子程序去验证之。
二、考核方式及评定标准上机实验要求对PL语言及其编译器进行实现及扩充、修改。
每个扩充或修改方式可得到不同的分数，满分为100分。
完成上机作业后，必须提交下列文档：（1）修改后的PL语言文本。
包含词法分析（正规式），语法分析（BNF）。
（2）有关修改后的PL编译/解释器的说明。
详细说明编译器是如何编译新的PL语言程序的。
指出程序中最精彩的部分，以及为什么这样做，如何控制和恢复语义错误的。
（3）给出改动后的编译器源程序清单，并标记出所修改的部分。
比较你的编译器和原来的编译器之间的差别。
（4）说明你的编译器中可能存在的错误。
（5）总结经验与教训，如果重做一遍，会有哪些新的改进？对现存的PL编译程序做如下修改或扩充，其中（1）、（2）、（11）和（12）必须完成，剩余的均可任意选择，但总分必须超过40分。
（1）注释（5分）（2）布尔类型的数据（10分）（3）布尔表达式的短路计算（5分）（4）数组（10分）为了便于解释执行，可能要增加新的PL机器操作指令。
（5）参数（10分）语法同Pascal（不用var声明）。
（6）函数（10分）语法同Pascal。
（7） else子句和repeat语句（5分）（8） for语句，语法参照Pascal或C语言（5分）（9） exit语句和break语句（5分）（10）记录（结构）,语法同Pascal语言（10分）。
（11）更有力的语法错误恢复机制（20分）（12）分离解释和编译器（5分）三、参考资料与编译器分析第一部分PL语言及其编译器1. PL语言介绍PL程序设计语言是一个较简单的语言，它以赋值语句为基础，构造概念有顺序、条件和重复（循环）三种。
PL有子程序概念，包括过程定义（可以嵌套）与调用且有局部变量说明。
PL中唯一的数据类型是整型，可以用来说明该类型的常量和变量。
当然PL也具有通常的算术运算和关系运算。
具体的PL语法图如下。
1.1PL语言的语法图程序程序体语句序列语句条件表达式因子2. PL语言编译器本书所提供的PL语言编译器的基本工作流程如图1-1所示：源程序执行结果图1-1 PL编译器基本工作流程2.1 词法分析PL 的语言的词法分析器将要完成以下工作： (1) 跳过分隔符（如空格，回车，制表符）；(2) 识别诸如begin ，end ，if ，while 等保留字； (3) 识别非保留字的一般标识符，此标识符值（字符序列）赋给全局量id ，而全局量sym 赋值为SYM_IDENTIFIER 。
(4) 识别数字序列，当前值赋给全局量NUM ，sym 则置为SYM_NUMBER ； (5) 识别:=，<=，>=之类的特殊符号，全局量sym 则分别被赋值为SYM_BECOMES ，SYM_LEQ ，SYM_GEQ 等。
相关过程（函数）有getsym()，getch()，其中getch()为获取单个字符的过程，除此之外，它还完成：(1) 识别且跳过行结束符；(2) 将输入源文件复写到输出文件；(3) 产生一份程序列表，输出相应行号或指令计数器的值。
2.2 语法分析我们采用递归下降的方法来设计PL 编译器。
以下我们给出该语言的FIRST 和FOLLOW 集合。
注：表中R 代表六个关系运算符。
不难证明，PL 语言属于LL （1）文法。
（证明从略。
）以下是我们给出如何结合语法图编写（递归下降）语法分析程序的一般方法。
假定图S 所对应的程序段为T （S ），则：(1) 用合适的替换将语法约化成尽可能少的单个图；(2) 将每一个图按下面的规则（3）-（7）翻译成一个过程说明； (3) 顺序图对应复合语句：对应：begin T(S1); T(S2); ...; T(Sn) end (4)选择：对应：case语句或者条件语句：case ch of if ch in L1 then T(S1) elseL1: T(S1); if ch in L2 then T(S2) elseL2: T(S2); 或 ...... if ch in Ln then T(Sn) elseLn: T(Sn); error其中Li∈FIRST（Si），ch为当前输入符号。
（下同）(5) 循环对应：while ch in L do T(S)(6) 表示另一个图A的图：对应：过程调用A。
(7) 表示终结符的单元图：对应：if ch == x then read(ch) else error相关过程有：block(), constdeclaration(), vardeclaration(), statement(), condition(), expression(), term(), factor()等。
它们之间依赖关系如图1-2：图1-2 语法分析过程依赖关系2.3 语义分析PL的语义分析主要进行以下检查：(1) 是否存在标识符先引用未声明的情况；(2) 是否存在己声明的标识符的错误引用；(3) 是否存在一般标识符的多重声明。
2.4代码生成PL编译程序不仅完成通常的词法分析、语法分析，而且还产生中间代码和“目标”代码。
最终我们要“运行”该目标码。
为了使我们的编译程序保持适当简单的水平，不致陷入与本课程无关的实际机器的特有性质的考虑中去，我们假想有台适合PL程序运行的计算机，我们称之为PL处理机。