PL 0 语言编译器分析实验报告
标准实验报告(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语言的扩充能力，从实际的应用中深刻领悟了编译程序的原理，更加深刻的学习了理论知识。
《编译原理(实验部分)》实验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语言语法分析器实验报告
PL0语言语法分析器实验报告一、引言编译器是一种用于把高级语言程序转换成机器可执行代码的软件工具。
编译器由多个组件构成，其中语法分析器是编译器中的重要组成部分，其主要功能是对输入的源代码进行解析，并生成一个语法树。
本实验旨在通过使用BNF（巴科斯范式）描述PL0语言的语法规则，并通过实现PL0语言的语法分析器，来深入理解语法分析的原理和过程。
二、PL0语言的语法规则1.程序结构：<程序>::=[<常量说明部分>][<变量说明部分>][<过程说明部分>]<语句>2.常量说明部分：<常量说明部分> ::= const <常量定义> { , <常量定义> };<常量定义>::=<标识符>=<无符号整数>3.变量说明部分：<变量说明部分> ::= var <标识符> { , <标识符> };4.过程说明部分：<过程说明部分>::=<过程首部><分程序>;<过程首部> ::= procedure <标识符> ;5.语句：<语句> ::= <赋值语句> ， <if语句> ， <while语句> ， <调用语句> ， <复合语句> ， <读语句> ， <写语句> ， <空><赋值语句>::=<标识符>:=<表达式><if语句> ::= if <条件> then <语句> else <语句><while语句> ::= while <条件> do <语句><调用语句> ::= call <标识符><复合语句> ::= begin <语句> { ; <语句> } end<读语句> ::= read ( <标识符> )<写语句> ::= write ( <表达式> )6.表达式：<表达式>::=[+，-]<项>{(+，-)<项>}<项>::=<因子>{(*，/)<因子>}<因子>::=<标识符>，<无符号整数>，(<表达式>)7.条件：<条件>::=<表达式><关系运算符><表达式><关系运算符>::==，<>，<，<=，>，>=三、PL0语言的语法分析器设计与实现1.设计思路本次实验中，我们将使用自顶向下的递归下降分析法，来对PL0语言进行语法分析。
PL0编译器源程序分析
PL/0编译器源程序分析PL/0语言是Pascal语言的一个子集，我们这里分析的PL/0的编译程序包括了对PL/0语言源程序进行分析处理、编译生成类PCODE代码，并在虚拟机上解释运行生成的类PCODE代码的功能。
PL/0语言编译程序采用以语法分析为核心、一遍扫描的编译方法。
词法分析和代码生成作为独立的子程序供语法分析程序调用。
语法分析的同时，提供了出错报告和出错恢复的功能。
在源程序没有错误编译通过的情况下，调用类PCODE解释程序解释执行生成的类PCODE代码。
词法分析子程序分析：词法分析子程序名为getsym，功能是从源程序中读出一个单词符号（token），把它的信息放入全局变量sym、id和num中，语法分析器需要单词时，直接从这三个变量中获得。
（注意！语法分析器每次用完这三个变量的值就立即调用getsym子程序获取新的单词供下一次使用。
而不是在需要新单词时才调用getsym过程。
）getsym过程通过反复调用getch子过程从源程序过获取字符，并把它们拼成单词。
getch过程中使用了行缓冲区技术以提高程序运行效率。
词法分析器的分析过程：调用getsym时，它通过getch过程从源程序中获得一个字符。
如果这个字符是字母，则继续获取字符或数字，最终可以拼成一个单词，查保留字表，如果查到为保留字，则把sym变量赋成相应的保留字类型值；如果没有查到，则这个单词应是一个用户自定义的标识符（可能是变量名、常量名或是过程的名字），把sym置为ident，把这个单词存入id变量。
查保留字表时使用了二分法查找以提高效率。
如果getch获得的字符是数字，则继续用getch获取数字，并把它们拼成一个整数，然后把sym置为number，并把拼成的数值放入num变量。
如果识别出其它合法的符号（比如：赋值号、大于号、小于等于号等），则把sym则成相应的类型。
如果遇到不合法的字符，把sym置成nul。
语法分析子程序分析：语法分析子程序采用了自顶向下的递归子程序法，语法分析同时也根据程序的语意生成相应的代码，并提供了出错处理的机制。
编译原理课程实验指导书-PL0语言及其编译器
《编译原理》课程实验指导书（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编译器，并适当进行改进、补充。
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编译器源程序分析
PL/0编译器源程序分析PL/0语言是Pascal语言的一个子集，我们这里分析的PL/0的编译程序包括了对PL/0语言源程序进行分析处理、编译生成类PCODE代码，并在虚拟机上解释运行生成的类PCODE代码的功能。
PL/0语言编译程序采用以语法分析为核心、一遍扫描的编译方法。
词法分析和代码生成作为独立的子程序供语法分析程序调用。
语法分析的同时，提供了出错报告和出错恢复的功能。
在源程序没有错误编译通过的情况下，调用类PCODE解释程序解释执行生成的类PCODE代码。
词法分析子程序分析： 词法分析子程序名为getsym，功能是从源程序中读出一个单词符号（token），把它的信息放入全局变量sym、id和num中，语法分析器需要单词时，直接从这三个变量中获得。
（注意！语法分析器每次用完这三个变量的值就立即调用getsym子程序获取新的单词供下一次使用。
而不是在需要新单词时才调用getsym过程。
）getsym过程通过反复调用getch 子过程从源程序过获取字符，并把它们拼成单词。
getch过程中使用了行缓冲区技术以提高程序运行效率。
词法分析器的分析过程：调用getsym时，它通过getch过程从源程序中获得一个字符。
如果这个字符是字母，则继续获取字符或数字，最终可以拼成一个单词，查保留字表，如果查到为保留字，则把sym变量赋成相应的保留字类型值；如果没有查到，则这个单词应是一个用户自定义的标识符（可能是变量名、常量名或是过程的名字），把sym置为ident，把这个单词存入id变量。
查保留字表时使用了二分法查找以提高效率。
如果getch获得的字符是数字，则继续用getch获取数字，并把它们拼成一个整数，然后把sym置为number，并把拼成的数值放入num变量。
如果识别出其它合法的符号（比如：赋值号、大于号、小于等于号等），则把sym则成相应的类型。
如果遇到不合法的字符，把sym置成nul。
语法分析子程序分析： 语法分析子程序采用了自顶向下的递归子程序法，语法分析同时也根据程序的语意生成相应的代码，并提供了出错处理的机制。
PL0语言编译程序分析 .txt
PL/0语言编译程序分析PL/0语言是Pascal语言的一个子集，我们这里分析的PL/0的编译程序包括了对PL/0语言源程序进行分析处理、编译生成类PCODE代码，并在虚拟机上解释运行生成的类PCODE代码的功能。
PL/0语言编译程序采用以语法分析为核心、一遍扫描的编译方法。
词法分析和代码生成作为独立的子程序供语法分析程序调用。
语法分析的同时，提供了出错报告和出错恢复的功能。
在源程序没有错误编译通过的情况下，调用类PCODE解释程序解释执行生成的类PCODE代码。
词法分析子程序分析：词法分析子程序名为getsym，功能是从源程序中读出一个单词符号（token），把它的信息放入全局变量sym、id和num中，语法分析器需要单词时，直接从这三个变量中获得。
（注意！语法分析器每次用完这三个变量的值就立即调用getsym子程序获取新的单词供下一次使用。
而不是在需要新单词时才调用getsym过程。
）getsym过程通过反复调用getch子过程从源程序过获取字符，并把它们拼成单词。
getch过程中使用了行缓冲区技术以提高程序运行效率。
词法分析器的分析过程：调用getsym时，它通过getch过程从源程序中获得一个字符。
如果这个字符是字母，则继续获取字符或数字，最终可以拼成一个单词，查保留字表，如果查到为保留字，则把sym变量赋成相应的保留字类型值；如果没有查到，则这个单词应是一个用户自定义的标识符（可能是变量名、常量名或是过程的名字），把sym置为ident，把这个单词存入id变量。
查保留字表时使用了二分法查找以提高效率。
如果getch获得的字符是数字，则继续用getch获取数字，并把它们拼成一个整数，然后把sym置为number，并把拼成的数值放入num变量。
如果识别出其它合法的符号（比如：赋值号、大于号、小于等于号等），则把sym则成相应的类型。
如果遇到不合法的字符，把sym置成nul。
语法分析子程序分析：语法分析子程序采用了自顶向下的递归子程序法，语法分析同时也根据程序的语意生成相应的代码，并提供了出错处理的机制。
编译原理修改后地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分〕增加由任何数据类型构造的一维数组。
PL0语言语法分析器实验报告
PL/0语言语法分析器实验报告信息资源管理学院10级档案班马雪静2010202609 一、实验内容用bison工具生成一个PL/0语言的语法分析程序，对PL/0源程序进行语法分析，并输出归约时所用的语法规则。
二、实验环境语法分析器生成工具：bison编程语言：C三、程序设计原理与方法1.cifa.l%{#include<stdio.h>#include<string.h>#include<stdlib.h>%}Letter [A-Za-z]Digit [0-9]D [1-9]LetterDigit [A-Za-z0-9]SPACE [\n\t\f\040]%%"+" {return ADD;}"-" {return MINUS;}"*" {return MULTIPL Y;}"/" {return DIVIDE;}"=" {return EQUAL;}"#" {return UNEQUAL;}"<" {return LESS;}"<=" {return LESSEQUAL;}">" {return MORE;}">=" {return MOREEQUAL;}":=" {return EV ALUATE;}"(" {return LPARENTHESES;}")" {return RPARENTHESES;}"," {return COMMA;}";" {return SEMICOLON;}"." {return DOT;}"if"|"IF" {return IF;}"then"|"THEN" {return THEN;}"while"|"WHILE" {return WHILE;}"do"|"DO" {return DO;}"read"|"READ" {return READ;}"write"|"WRITE" {return WRITE;}"call"|"CALL" {return CALL;}"begin"|"BEGIN" {return BEG;}"end"|"END" {return END;}"const"|"CONST" {return CONST;}"var"|"V AR" {return V AR;}"procedure"|"PROCEDURE" {return PROCEDURE;}"odd"|"ODD" {return ODD;}{D}{Digit}*|"0" {return NOSIGNINTEGER;}{Letter}{LetterDigit}* {return IDENT;}{Digit}{LetterDigit}* {return ERROR;}{SPACE}* {}. {return ERRORCHAR;}%%int yywrap(){return 1;}2.Yufa.y%{#include<stdio.h>#include<string.h>#include"lex.yy.c"%}%token IF THEN WHILE DO READ WRITE CALL BEG END CONST V AR PROCEDURE ODD%token ADD MINUS MULTIPL Y DIVIDE EQUAL UNEQUAL LESS LESSEQUAL MORE MOREEQUAL EV ALUA TE%token LPARENTHESES RPARENTHESES COMMA SEMICOLON DOT ERROR ERRORCHAR%token NOSIGNINTEGER IDENT%%//<程序> ::= <分程序>.Program:PartialProgram DOT {printf("<程序> --> <分程序>.\n");};//<分程序> ::= [<常量说明部分>][<变量说明部分>][<过程说明部分>]<语句> PartialProgram:ConstantDeclaration VariableDeclaration ProcedureDeclaration Statement {printf("<分程序> --> <常量说明部分><变量说明部分><过程说明部分><语句>\n");}|VariableDeclaration ProcedureDeclaration Statement {printf("<分程序> --> <变量说明部分><过程说明部分><语句>\n");}|ConstantDeclaration ProcedureDeclaration Statement {printf("<分程序> --> <常量说明部分><过程说明部分><语句>\n");}|ConstantDeclaration VariableDeclaration Statement {printf("<分程序> --> <常量说明部分><变量说明部分><语句>\n");}|ConstantDeclaration Statement {printf("<分程序> --> <常量说明部分><语句>\n");}|VariableDeclaration Statement {printf("<分程序> --> <变量说明部分><语句>\n");}|ProcedureDeclaration Statement {printf("<分程序> --> <过程说明部分><语句>\n");}|Statement {printf("<分程序> --> <语句>\n");};//<常量说明部分> ::= CONST<常量定义>{,<常量定义>};ConstantDeclaration:CONST ConstList SEMICOLON {printf("<常量说明部分> --> CONST <常量定义串>;\n");} ;//<常量定义串> ::= <常量定义>|<常量定义串>,<常量定义>ConstList:ConstDefination {printf("<常量定义串> --> <常量定义>\n");}|ConstList COMMA ConstDefination {printf("<常量定义串> --> <常量定义串>,<常量定义>\n");};//<常量定义> ::= <标识符>:=<无符号整数>ConstDefination:IDENT EVALUATE NOSIGNINTEGER {printf("<常量定义> --> <标识符>:=<无符号整数>\n");};//<变量说明部分> ::= V AR<标识符>{,<标识符>};VariableDeclaration:V AR IdentList SEMICOLON {printf("<变量说明部分> --> V AR <标识符串>;\n");};//<标识符串> ::= <标识符>|<标识符串>,<标识符>IdentList:IDENT {printf("<标识符串> --> <标识符>\n");}|IdentList COMMA IDENT {printf("<标识符串> --> <标识符串>,<标识符>\n");}//<过程说明部分> ::= <过程首部><分程序>{;<过程说明部分>};ProcedureDeclaration:ProcedureHead PartialProgram SEMICOLON ProcedureDeclaration SEMICOLON {printf("<过程说明部分>--><过首部><分程序>;<过程说明部分>;");}|ProcedureHead PartialProgram SEMICOLON {printf("<过程说明部分>--><过程首部><分程序>;\n");};//<过程首部> ::= PROCEDURE<标识符>;ProcedureHead:PROCEDURE IDENT SEMICOLON {printf("<过程首部> --> PROCEDURE<标识符>;\n");} ;//<语句> ::= <赋值语句>|<复合语句>|<条件语句>|<当型循环语句>|<过程调用语句>|<读语句>|<写语句>|<空>Statement:EvaluateStatement {printf("<语句> --> <赋值语句>\n");}|ComplexStatement {printf("<语句> --> <复合语句>\n");}|ConditionStatement {printf("<语句> --> <条件语句>\n");}|WhileStatement {printf("<语句> --> <当型循环语句>\n");}|ProcedureCallStatement {printf("<语句> --> <过程调用语句>\n");}|ReadStatement {printf("<语句> --> <读语句>\n");}|WriteStatement {printf("<语句> --> <写语句>\n");}| {printf("<语句> --> <空>\n");};//<赋值语句> ::= <标识符>:=<表达式>EvaluateStatement:IDENT EVALUATE Expression {printf("<赋值语句> --> <标识符>:=<表达式>\n");};//<复合语句> ::= BEGIN<语句>{;<语句>}ENDComplexStatement:BEG StatementList END {printf("<复合语句> --> BEGIN<语句串>END\n");};//<语句串> ::= <语句>|<语句串>;<语句>StatementList:Statement {printf("<语句串> --> <语句>\n");}|StatementList SEMICOLON Statement {printf("<语句串> --> <语句串>;<语句>\n");};//<条件> ::= <表达式><关系运算符><表达式>|ODD<表达式>Condition:Expression RelationOperator Expression {printf("<条件> --> <表达式><关系运算符><表达式>\n");}|ODD Expression {printf("<条件> --> ODD<表达式>\n");};//<条件语句> ::= IF<条件>THEN<语句>ConditionStatement:IF Condition THEN Statement {printf("<条件语句> --> IF<条件>THEN<语句>\n");};//<表达式> ::= [+|-]<项>{<加法运算符><项>}Expression:ADD TermList {printf("<表达式> --> +<项串>\n");}|MINUS TermList {printf("<表达式> --> -<项串>\n");}|TermList {printf("<表达式> --> <项串>\n");};// <项串> ::= <项>|<项串><加法运算符><项>TermList:Term {printf("<项串> --> <项>\n");}|TermList ADD Term {printf("<项串> --> <项串>+<项>\n");}|TermList MINUS Term {printf("<项串> --> <项串>-<项>\n");};//<项> ::= <因子>{<乘法运算符><因子>}Term:GeneList {printf("<项> --> <因子串>\n");};//<因子串> ::= <因子>|<因子串><乘法运算符><因子>GeneList:Gene {printf("<因子串> --> <因子>\n");}|GeneList MULTIPL Y Gene {printf("<因子串> --> <因子串>*<因子>\n");}|GeneList DIVIDE Gene {printf("<因子串> --> <因子串>/<因子>\n");};//<因子> ::= <标识符>|<无符号整数>|'('<表达式>')'Gene:IDENT {printf("<因子> --> <标识符>\n");}|NOSIGNINTEGER {printf("<因子> --> <无符号整数>\n");}|LPARENTHESES Expression RPARENTHESES {printf("<因子> --> '('<表达式>')'\n");};//<关系运算符> ::= =|#|<|<=|>|>= */RelationOperator:EQUAL {printf("<关系运算符> --> =\n");}|UNEQUAL {printf("<关系运算符> --> #\n");}|LESS {printf("<关系运算符> --> <\n");}|LESSEQUAL {printf("<关系运算符> --> <=\n");}|MORE {printf("<关系运算符> --> >\n");}|MOREEQUAL {printf("<关系运算符> --> >=\n");};//<当型循环语句> ::= WHILE<条件>DO<语句>WhileStatement:WHILE Condition DO Statement{printf("<当型循环语句> --> WHILE<条件>DO<语句>\n");} ;//<过程调用语句> ::= CALL<标识符> */ProcedureCallStatement:CALL IDENT {printf("<过程调用语句> --> CALL<标识符>\n");};//<读语句> ::= READ'('<标识符>{,<标识符>}')'ReadStatement:READ LPARENTHESES IdentList RPARENTHESES {printf("<读语句> --> READ(<标识符串>)\n");};//<写语句> ::= WRITE'('<表达式>{,<表达式>}')'WriteStatement:WRITE LPARENTHESES ExpressionList RPARENTHESES {printf("<写语句> --> WRITE(<表达式串>)\n");};//<表达式串> ::= <表达式>|<表达式串>,<表达式>ExpressionList:Expression {printf("<表达式串> --> <表达式>\n");}|ExpressionList COMMA Expression {printf("<表达式串> --> <表达式串>,<表达式>\n");};%%int main(){char filename[20];printf("file name:");scanf("%s",filename);yyin=fopen(filename,"r");if(!yyin){printf("\nno files\n");return 0;}yyparse();fclose(yyin);return 0;}yyerror(char *s){printf("Error!\n");}四、实验结果1.源文件：column.pl0var r, h, len, a1, a2, volumn;beginread(r);read(h);len := 2 * 3 * r;a1 := 3 * r * r;a2 := a1 + a1 + len * h;volumn := a1 * h;write(len);write(a1);write(a2);write(volumn);end.2.归约结果：。
PL0语言编译器分析实验报告
PL/0 语言编译器分析实验报告一、实验目的通过阅读与解析一个实际编译器（PL/0语言编译器）的源代码，加深对编译阶段（包括词法分析、语法分析、语义分析、中间代码生成等）和编译系统软件结构的理解，并达到提高学生学习兴趣的目的。
二、实验要求(1)要求掌握基本的程序设计技巧（C语言）和阅读较大规模程序源代码的能力；(2)理解并掌握编译过程的逻辑阶段及各逻辑阶段的功能；(3)要求能把握整个系统（PL/0语言编译器）的体系结构，各功能模块的功能，各模块之间的接口；(4)要求能总结出实现编译过程各逻辑阶段功能采用的具体算法与技术。
三、实验步骤(1) 根据PL/0语言的语法图，理解PL/0语言各级语法单位的结构，掌握PL/0语言合法程序的结构；(2)从总体上分析整个系统的体系结构、各功能模块的功能、各模块之间的调用关系、各模块之间的接口；(3)详细分析各子程序和函数的代码结构、程序流程、采用的主要算法及实现的功能；(4)撰写分析报告，主要内容包括系统结构框图、模块接口、主要算法、各模块程序流程图等。
四、报告内容pl/0语言是pascal语言的一个子集，我们这里分析的pl/0的编译程序包括了对pl/0语言源程序进行分析处理、编译生成类pcode代码，并在虚拟机上解释运行生成的类pcode代码的功能。
pl/0语言编译程序采用以语法分析为核心、一遍扫描的编译方法。
词法分析和代码生成作为独立的子程序供语法分析程序调用。
语法分析的同时，提供了出错报告和出错恢复的功能。
在源程序没有错误编译通过的情况下，调用类pcode 解释程序解释执行生成的类pcode代码。
PL/0语言文法的EBNF表示EBNF表示的符号说明。
〈〉用左右尖括号括起来的中文字表示语法构造成分，或称语法单位，为非终结符。
∷=该符号的左部由右部定义，可读作“定义为”。
|表示“或”，为左部可由多个右部定义。
{ }花括号表示其内的语法成分可以重复。
在不加上下界时可重复0到任意次数，有上下界时为可重复次数的限制。
PLO编译器扩展实验报告
云南大学编译原理实验报告实验题目：PLO编译器扩展学院：信息学院专业：计算机科学与技术学号：20091060064姓名：刘继远目录一、实验目的 (1)二、实验内容 (1)三、源程序分析 (2)1、PL/0语言编译器的基本工作流程 (2)2、PL/0语言编译器主要函数的作用及其函数之间的调用 (3)3、编译器的语法语义分析 (4)(1)、编译器在进行语法语义分析时，各函数的调用关系 (4)(2)、递归子程序实现 (5)(3)、其他两大部分的功能 (6)1)、说明部分的分析 (6)2)、过程体的分析： (6)4、PL/0编译程序的目标代码结构和代码生成 (7)(1)、对分程序体人口的处理 (7)(2)、类pcode代码指令的详细解释 (7)5、PL/0编译程序的语法错误处理 (8)四、设计的基本思想 (9)1、对else语句的扩展： (9)2、对一维数组的扩展： (10)五、结果及分析 (16)1、对else语句扩展的测试结果 (16)2、对一维数组扩展的测试结果 (19)一、实验目的1.理解语法、语义分析程序为中心的单遍编译程序组织方法；2.理解编译程序的基本逻辑过程（词法分析、语法分析、语义分析及目标代码的生成；3.理解编译过程中的符号表、内存管理、错误处理的基本方法；二、实验内容在已知的PL0程序的基础上，修改PL/0编译程序和类P-code解释程序的源代码，以支持对PL/0语言所进行的如下扩充，并调试通过：(1)条件语句改为：＜条件语句＞::=IF ＜条件＞THEN ＜语句＞[ELSE ＜语句＞] 问题：按照你的修改方式，如下PL/0代码执行后变量x的值是什么？你认为这样的结果是否合理？为什么？(2)增加整型一维数组变量，形式为：＜数组变量声明＞::=＜标识符＞( ＜下界＞：＜上界＞)＜数组变量引用＞::= ＜标识符＞( ＜表达式＞)其中＜下界＞和＜上界＞是常量名或整数，例如：三、源程序分析1、PL/0语言编译器的基本工作流程如图1-1所示：源程序执行结果图1-1 PL/0编译器基本工作流程2、PL/0语言编译器主要函数的作用及其函数之间的调用它反映了编译程序工作的基理，如图1-2所示：图1-2 PL/0编译器函数调用3、编译器的语法语义分析(1)、编译器在进行语法语义分析时，各函数的调用关系从PL/0的语法描述图中可以清楚地看到，当对PL/0语言进行语法分析时，各个非终结符语法单元所对应的分析过程之间必须存在相互调用的关系。
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报告(附源码教程)
编译原理课程设计学院计算机学院专业计算机科学与技术班级学号姓名指导教师20 年月日一、课程设计要求基本内容（成绩范围：“中”、“及格”或“不及格”）（1）扩充赋值运算：*= 和/=扩充语句（Pascal的FOR语句）:①FOR <变量>:=<表达式> TO <表达式> DO <语句>②FOR <变量>:=<表达式> DOWNTO <表达式> DO <语句>其中，语句①的循环变量的步长为2，语句②的循环变量的步长为-2。
（3）增加运算：++ 和--。
选做内容（成绩评定范围扩大到：“优”和“良”）（1）增加类型：①字符类型；②实数类型。
（2）扩充函数：①有返回值和返回语句；②有参数函数。
（3）增加一维数组类型（可增加指令）。
（4）其他典型语言设施。
二、概述目标：实现PL0某些特定语句实现语言：C语言实现工具平台：VS201运行平台：WIN7三、结构设计说明与功能块描述PL/0编译程序的结构图PL/0编译程序的总体流程图四、主要成分描述1、符号表编译程序里用了一个枚举类型enum symbol，然后定义了enum symbol sym来存放当前的符号，前面讲过，主程序定义了一个以字符为元素的一维数组word，称保留字表，这个保留字表也存放在符号表里，为了识别当前的符号是属于哪些保留字；还有标识符，拼数，拼符合词等的符号名都存放在符号表里，当sym存放当前的符号时，我们可以判断它是属于哪类的符号，然后加以处理。
在运行的过程中，主程序中又定义了一个名字表，也就是符号表，来专门存放变量、常量和过程名的各个属性，里面的属性包括name，kind，val/level，adr，size，我们来举一个PL/0语言过程说明部分的片段：Const a=35,b=49;Var c,d,e;Procedure p;Var g;当遇到标识符的引用时就调用position函数，根据当前sym的符号类型来查table表，看是否有过正确的定义，若已有，则从表中取相应的有关信息，供代码的生成用。
实验一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实验报告课程名称编译原理题目名称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()。
PL0
将常数值取到栈顶， 将常数值取到栈顶，a为常数值 将变量值取到栈顶， 为偏移量， 将变量值取到栈顶，a为偏移量，l为层差 将栈顶内容送入某变量单元中， 为偏移量， 将栈顶内容送入某变量单元中，a为偏移量，l为层差 调用过程， 为过程地址， 调用过程，a为过程地址，l为层差 在运行栈中为被调用的过程开辟a 在运行栈中为被调用的过程开辟a个单元的数据区 无条件跳转至a 无条件跳转至a地址 条件跳转，当栈顶布尔值非真则跳转至a地址， 条件跳转，当栈顶布尔值非真则跳转至a地址，否则顺序执行 过程调用结束后, 过程调用结束后,返回调用点并退栈 栈顶元素取反 次栈顶与栈顶相加 退两个栈元素， 顶相加， 次栈顶与栈顶相加，退两个栈元素，结果值进栈 次栈顶减去栈顶，退两个栈元素， 次栈顶减去栈顶，退两个栈元素，结果值进栈 次栈顶乘以栈顶，退两个栈元素， 次栈顶乘以栈顶，退两个栈元素，结果值进栈 次栈顶除以栈顶，退两个栈元素， 次栈顶除以栈顶，退两个栈元素，结果值进栈 栈顶元素的奇偶判断， 栈顶元素的奇偶判断，结果值在栈顶 次栈顶与栈顶是否相等，退两个栈元素， 次栈顶与栈顶是否相等，退两个栈元素，结果值进栈 次栈顶与栈顶是否不等，退两个栈元素， 次栈顶与栈顶是否不等，退两个栈元素，结果值进栈 次栈顶是否小于栈顶，退两个栈元素， 次栈顶是否小于栈顶，退两个栈元素，结果值进栈 次栈顶是否大于等于栈顶 退两个栈元素， 否大于等于栈顶， 次栈顶是否大于等于栈顶，退两个栈元素，结果值进栈 次栈顶是否大于栈顶，退两个栈元素， 次栈顶是否大于栈顶，退两个栈元素，结果值进栈 次栈顶是否小于等于栈顶，退两个栈元素， 次栈顶是否小于等于栈顶，退两个栈元素，结果值进栈 栈顶值输出至屏幕 屏幕输出换行 从命令行读入一个输入置于栈顶
指 令 功 能 表
LIT LOD STO CAL INT JMP JPC OPR OPR OPR OPR OPR OPR OPR OPR OPR OPR OPR OPR OPR OPR OPR OPR
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
PL/0 语言编译器分析实验一、实验目的通过阅读与解析一个实际编译器（PL/0语言编译器）的源代码，加深对编译阶段（包括词法分析、语法分析、语义分析、中间代码生成等）和编译系统软件结构的理解，并达到提高学生学习兴趣的目的。
二、实验要求(1)要求掌握基本的程序设计技巧（C语言）和阅读较大规模程序源代码的能力；(2)理解并掌握编译过程的逻辑阶段及各逻辑阶段的功能；(3)要求能把握整个系统（PL/0语言编译器）的体系结构，各功能模块的功能，各模块之间的接口；(4)要求能总结出实现编译过程各逻辑阶段功能采用的具体算法与技三、实验报告pl/0语言是pascal语言的一个子集，我们这里分析的pl/0的编译程序包括了对pl/0语言源程序进行分析处理、编译生成类pcode代码，并在虚拟机上解释运行生成的类pcode代码的功能。
pl/0语言编译程序采用以语法分析为核心、一遍扫描的编译方法。
词法分析和代码生成作为独立的子程序供语法分析程序调用。
语法分析的同时，提供了出错报告和出错恢复的功能。
在源程序没有错误编译通过的情况下，调用类pcode 解释程序解释执行生成的类pcode代码。
词法分析子程序分析：词法分析子程序名为getsym，功能是从源程序中读出一个单词符号（token），把它的信息放入全局变量sym、id和num中，语法分析器需要单词时，直接从这三个变量中获得。
（注意！语法分析器每次用完这三个变量的值就立即调用getsym 子程序获取新的单词供下一次使用。
而不是在需要新单词时才调用getsym过程。
）getsym过程通过反复调用getch子过程从源程序过获取字符，并把它们拼成单词。
getch过程中使用了行缓冲区技术以提高程序运行效率。
词法分析器的分析过程：调用getsym时，它通过getch过程从源程序中获得一个字符。
如果这个字符是字母，则继续获取字符或数字，最终可以拼成一个单词，查保留字表，如果查到为保留字，则把sym变量赋成相应的保留字类型值；如果没有查到，则这个单词应是一个用户自定义的标识符（可能是变量名、常量名或是过程的名字），把sym 置为ident，把这个单词存入id变量。
查保留字表时使用了二分法查找以提高效率。
如果getch获得的字符是数字，则继续用getch获取数字，并把它们拼成一个整数，然后把sym置为number，并把拼成的数值放入num变量。
如果识别出其它合法的符号（比如：赋值号、大于号、小于等于号等），则把sym则成相应的类型。
如果遇到不合法的字符，把sym置成nul。
语法分析子程序分析：语法分析子程序采用了自顶向下的递归子程序法，语法分析同时也根据程序的语意生成相应的代码，并提供了出错处理的机制。
语法分析主要由分程序分析过程（block）、常量定义分析过程（constdeclaration）、变量定义分析过程（vardeclaration）、语句分析过程（statement）、表达式处理过程（expression）、项处理过程（term）、因子处理过程（factor）和条件处理过程（condition）构成。
这些过程在结构上构成一个嵌套的层次结构。
除此之外，还有出错报告过程（error）、代码生成过程（gen）、测试单词合法性及出错恢复过程（test）、登录名字表过程（enter）、查询名字表函数（position）以及列出类pcode代码过程（listcode）作过语法分析的辅助过程。
由pl/0的语法图可知：一个完整的pl/0程序是由分程序和句号构成的。
因此，本编译程序在运行的时候，通过主程序中调用分程序处理过程block来分析分程序部分（分程序分析过程中还可能会递归调用block过程），然后，判断最后读入的符号是否为句号。
如果是句号且分程序分析中未出错，则是一个合法的pl/0程序，可以运行生成的代码，否则就说明源pl/0程序是不合法的，输出出错提示即可。
语法单元分析：1、分程序处理过程：语法分析开始后，首先调用分程序处理过程（block）处理分程序。
过程入口参数置为：0层、符号表位置0、出错恢复单词集合为句号、声明符或语句开始符。
进入block过程后，首先把局部数据段分配指针设为3，准备分配3个单元供运行期存放静态链sl、动态链dl和返回地址ra。
然后用tx0记录下当前符号表位置并产生一条jmp指令，准备跳转到主程序的开始位置，由于当前还没有知到主程序究竟在何处开始，所以jmp的目标暂时填为0，稍后再改。
同时在符号表的当前位置记录下这个jmp指令在代码段中的位置。
在判断了嵌套层数没有超过规定的层数后，开始分析源程序。
首先判断是否遇到了常量声明，如果遇到则开始常量定义，把常量存入符号表。
接下去用同样的方法分析变量声明，变量定义过程中会用dx变量记录下局部数据段分配的空间个数。
然后如果遇到procedure保留字则进行过程声明和定义，声明的方法是把过程的名字和所在的层次记入符号表，过程定义的方法就是通过递归调用block过程，因为每个过程都是一个分程序。
由于这是分程序中的分程序，因此调用block时需把当前的层次号lev加一传递给block过程。
分程序声明部分完成后，即将进入语句的处理，这时的代码分配指针cx的值正好指向语句的开始位置，这个位置正是前面的jmp指令需要跳转到的位置。
于是通过前面记录下来的地址值，把这个jmp指令的跳转位置改成当前cx的位置。
并在符号表中记录下当前的代码段分配地址和局部数据段要分配的大小（dx的值）。
生成一条int指令，分配dx个空间，作为这个分程序段的第一条指令。
下面就调用语句处理过程statement分析语句。
分析完成后，生成操作数为0的opr指令，用于从分程序返回（对于0层的主程序来说，就是程序运行完成，退出）。
2、常量定义过程：通过循环，反复获得标识符和对应的值，存入符号表。
符号表中记录下标识符的名字和它对应的值。
3、变量定义过程：与常量定义类似，通过循环，反复获得标识符，存入符号表。
符号表中记录下标识符的名字、它所在的层及它在所在层中的偏移地址。
4、语句处理过程：语句处理过程是一个嵌套子程序，通过调用表达式处理、项处理、因子处理等过程及递归调用自己来实现对语句的分析。
语句处理过程可以识别的语句包括赋值语句、read语句、write语句、call语句、if语句、while语句。
当遇到begin/end 语句时，就递归调用自己来分析。
分析的同时生成相应的类pcode指令。
5、赋值语句的处理：首先获取赋值号左边的标识符，从符号表中找到它的信息，并确认这个标识符确为变量名。
然后通过调用表达式处理过程算得赋值号右部的表达式的值并生成相应的指令保证这个值放在运行期的数据栈顶。
最后通过前面查到的左部变量的位置信息，生成相应的sto指令，把栈顶值存入指定的变量的空间，实现了赋值操作。
6、read语句的处理：确定read语句语法合理的前提下（否则报错），生成相应的指令：第一条是16号操作的opr指令，实现从标准输入设备上读一个整数值，放在数据栈顶。
第二条是sto指令，把栈顶的值存入read语句括号中的变量所在的单元。
7、write语句的处理：与read语句相似。
在语法正确的前提下，生成指令：通过循环调用表达式处理过程分析write语句括号中的每一个表达式，生成相应指令保证把表达式的值算出并放到数据栈顶并生成14号操作的opr指令，输出表达式的值。
最后生成15号操作的opr指令输出一个换行。
8、call语句的处理：从符号表中找到call语句右部的标识符，获得其所在层次和偏移地址。
然后生成相应的cal指令。
至于调用子过程所需的保护现场等工作是由类pcode解释程序在解释执行cal指令时自动完成的。
9、if语句的处理：按if语句的语法，首先调用逻辑表达式处理过程处理if语句的条件，把相应的真假值放到数据栈顶。
接下去记录下代码段分配位置（即下面生成的jpc指令的位置），然后生成条件转移jpc指令（遇0或遇假转移），转移地址未知暂时填0。
然后调用语句处理过程处理then语句后面的语句或语句块。
then后的语句处理完后，当前代码段分配指针的位置就应该是上面的jpc指令的转移位置。
通过前面记录下的jpc指令的位置，把它的跳转位置改成当前的代码段指针位置。
10、begin/end语句的处理：通过循环遍历begin/end语句块中的每一个语句，通过递归调用语句分析过程分析并生成相应代码。
11、while语句的处理：首先用cx1变量记下当前代码段分配位置，作为循环的开始位置。
然后处理while语句中的条件表达式生成相应代码把结果放在数据栈顶，再用cx2变量记下当前位置，生成条件转移指令，转移位置未知，填0。
通过递归调用语句分析过程分析do语句后的语句或语句块并生成相应代码。
最后生成一条无条件跳转指令jmp，跳转到cx1所指位置，并把cx2所指的条件跳转指令的跳转位置改成当前代码段分配位置。
12、表达式、项、因子处理：根据pl/0语法可知，表达式应该是由正负号或无符号开头、由若干个项以加减号连接而成。
而项是由若干个因子以乘除号连接而成，因子则可能是一个标识符或一个数字，或是一个以括号括起来的子表达式。
根据这样的结构，构造出相应的过程，递归调用就完成了表达式的处理。
把项和因子独立开处理解决了加减号与乘除号的优先级问题。
在这几个过程的反复调用中，始终传递fsys变量的值，保证可以在出错的情况下跳过出错的符号，使分析过程得以进行下去。
13、逻辑表达式的处理：首先判断是否为一元逻辑表达式：判奇偶。
如果是，则通过调用表达式处理过程分析计算表达式的值，然后生成判奇指令。
如果不是，则肯定是二元逻辑运算符，通过调用表达式处理过程依次分析运算符左右两部分的值，放在栈顶的两个空间中，然后依不同的逻辑运算符，生成相应的逻辑判断指令，放入代码段。
14、判断单词合法性与出错恢复过程分析：本过程有三个参数，s1、s2为两个符号集合，n为出错代码。
本过程的功能是：测试当前符号（即sym变量中的值）是否在s1集合中，如果不在，就通过调用出错报告过程输出出错代码n，并放弃当前符号，通过词法分析过程获取一下单词，直到这个单词出现在s1或s2集合中为止。
这个过程在实际使用中很灵活，主要有两个用法：在进入某个语法单位时，调用本过程，检查当前符号是否属于该语法单位的开始符号集合。
若不属于，则滤去开始符号和后继符号集合外的所有符号。
在语法单位分析结束时，调用本过程，检查当前符号是否属于调用该语法单位时应有的后继符号集合。
若不属于，则滤去后继符号和开始符号集合外的所有符号。
通过这样的机制，可以在源程序出现错误时，及时跳过出错的部分，保证语法分析可以继续下去。
15、类pcode代码解释执行过程分析：这个过程模拟了一台可以运行类pcode指令的栈式计算机。