编译原理PL0程序分析和详细注释

合集下载

编译原理(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[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]),"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);switch(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，不属于则报错nerror(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("该语句为赋值语句。

《编译原理（实验部分）》实验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语言的理解，为以后的编程工作打下坚实的基础。

PL0编译程序

PL/0语言编译系统春秋五霸目录1 PL/0语言及编译系统2 驱动代码3 编译程序4 解释程序①词法分析②语法分析③语义分析及目标代码生成1 PL/0语言编译系统PL/语言编译系统PL/0语言编译系统是世界著名计算机科学家N.Wirth编写的。

对PL/0编译程序进行实例分析，有助于对一般编译过程和编译程序结构的理解。

PL/0语言功能简单、结构清晰、可读性强，又具备了一般高级语言的必须部分，因而PL/0语言的编译程序能充分体现一个高级语言编译程序实现的基本技术和步骤，是一个非常合适的编译程序教学模型。

PL/0源程序PL/0编译系统语法语义分析程序词法分析程序目标代码代码生成程序表格管理程序出错处理程序PL/0源程序PL/0编译系统构成类P-code程序PL/0编译程序输出数据输入数据类P-code虚拟机类P-code解释程序PL/0语言文法的EBNF表示●〈程序〉∷=〈分程序〉.●〈分程序〉∷=[〈常量说明部分〉][〈变量说明部分〉][〈过程说明部分〉]〈语句〉●〈常量说明部分〉∷=CONST〈常量定义部分〉{，〈常量定义〉}；●〈常量定义〉 ::= 〈标识符〉＝〈无符号整数〉;●〈无符号整数〉∷=〈数字〉{〈数字〉}●〈变量说明部分〉∷=V AR〈标识符〉{，〈标识符〉}；●〈标识符〉∷=〈字母〉{〈字母〉|〈数字〉}PL/0语言文法的EBNF表示●＜过程说明部分＞::=＜过程首部＞＜分程序＞｛；＜过程说明部分＞｝●＜过程首部＞::=PROCEDURE＜标识符＞；●＜语句＞::=＜赋值语句＞｜＜条件语句＞｜＜当型循环语句＞｜＜过程调用语句＞｜＜读语句＞｜＜写语句＞｜＜复合语句＞｜＜空＞●＜赋值语句＞::= ＜标识符＞:=＜表达式＞●＜复合语句＞::= BEGIN＜语句＞｛；＜语句＞｝END●＜条件＞::= ＜表达式＞＜关系运算符＞＜表达式＞PL/0语言文法的EBNF表示●＜表达式＞::=[＋｜－]＜项＞｛＜加法运算符＞＜项＞｝●＜项＞::= ＜因子＞｛＜乘法运算符＞＜因子＞｝●＜因子＞::= ＜标识符＞｜＜无符号整数＞｜‘（’＜表达式＞‘）’PL/0语言文法的EBNF表示●＜加法运算符＞::= ＋｜－●＜乘法运算符＞::= *｜/●＜关系运算符＞::= ＝｜＃｜＜｜＜＝｜＞｜＞＝●＜条件语句＞::= IF＜条件＞THEN＜语句＞●＜过程调用语句＞::= CALL＜标识符＞●＜当型循环语句＞::= WHILE＜条件＞DO＜语句＞●＜读语句＞::= READ’（’＜标识符＞｛，＜标识符＞｝‘）’PL/0语言文法的EBNF表示●＜写语句＞::= WRITE’（’＜表达式＞｛，＜表达式＞｝‘）’●＜字母＞::= a|b|…|X|Y|Z●＜数字＞::= 0|1|…|8|9指令过程调用相关指令类P-code 虚拟机指令系统…存取指令int 0 a cal l ajmp 0 alit 0 alod l a sto l a指令一元运算和比较指令类P-code 虚拟机指令系统…二元运算指令opr 0 5opr 0 1opr 0 6opr 0 2opr 0 3 opr 0 4指令转移指令类P-code 虚拟机指令系统输入输出指令二元运算指令opr 0 13 jmp 0 ajpc 0 aopr 0 8 opr 0 10opr 0 12opr 0 14opr 0 16opr 0 15opr 0 9opr 0 112 驱动代码词法分析主要函数：main()函数功能：驱动整个编译系统的运行变量说明：fa.tmp 输出虚拟机代码fa1.tmp 输出源文件及其各行对应的首地址fa2.tmp 输出结果fas.tmp 输出名字表main函数int main(){……/*打开源程序文件*/If 打开源程序文件成功{…… /*初始化输出文件信息*/init(); /*初始化各类名字和符号信息*/err=0; /*初始化错误数*/…… /*初始化其他信息*/if(-1!=getsym()) /*成功读取第一个单词*/{……main函数if(-1==block(0,0,nxtlev)) /*调用编译程序*/{…… /*编译过程未成功结束关闭所有已打开的文件，返回*/}…… /*编译过程结束关闭所有已打开的输出文件*/if(sym!=period) /*当前符号不是程序结束符’.’*/{error(9); /*提示9号出错信息：缺少程序结束符’.’*/}if(err==0) /*未发现程序中的错误*/{……interpret(); /*调用解释程序，执行所产生的类P-code代码*/……main函数else{printf("Errors in pl/0 program");}}…… /*关闭已打开的文件*/}else{printf(“Can‘t open file! \n”);/*打开源程序文件不成功*/}printf("\n");return 0; /*返回*/}集合运算函数int inset(int e,bool* s){/*返回e在数组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){/*s1[i]为true，s2[i]为false时，sr[i]才为true*/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);printf("-------%c\n",ch);fprintf(fa1,"-------%c\n",ch);space[cc-1]=0;//出错时当前符号已经读完，所以cc-1printf("****%s!%d\n",space,n);fprintf(fa1,"****%s!%d\n",space,n);err++;}PL/O语言的出错信息表：出错编号出错原因1：常数说明中的“=”写成“∶=”。

编译原理实验剖析

定次数 [ ] ：表示方括号内的语法成分为任选项 ( ) ：表示圆括号内的成分优先
例：用EBNF描述分程序的定义
<分程序>∷=[<常量说明部分>][<变量说明部分>][<过程说明部分>] <语句> <常量说明部分>∷= CONST<常量定义>
{, <常量定义>}; <常量定义>∷= <标识符>＝<无符号整数> <变量说明部分>∷= VAR <标识符>
任务一：读程序
内容
读程序GetSym()
识别保留字识别标识符拼数拼双字符单词识别单字符单词
要求
每班前十名同学给予检查
任务二：扩充单词
内容
增加保留字：FOR、DOWNTO和TO 增加双字符单词：*=和/=
要求
设计测试方式，测试单词是否能被识别每班前十名同学给予检查
5. 语法分析
—递归子程序法
PL/0语言是PASCAL语言的子集
数据类型,只有整型数据结构 ,只有简变和常量整数最多为14位标识符的有效长度是10位过程最多可嵌套三层作用域规则（内层可引用包围它的外层定义的标识符），过程可嵌套定义，可递归调用
2.2 语法描述图
内的文字或符号表示非终结符或内的文字或符号表示终结符
符号表
重要变量及过程
type symbol=( nul, ident, number, plus, …,
varsym, procsym )；
保留字表： word[1]:=‘BEGIN‘； word[2]:=‘CALL‘；
... word[13]:=‘WRITE‘；

pl0编译原理

pl0编译原理编译原理是计算机科学中的一门重要课程，它研究的是如何将高级语言转化为机器语言的过程。

在编译原理中，pl0是一种简单的编程语言，它的设计目标是为了教学和研究目的而产生的。

本文将介绍pl0编译原理的基本概念和主要过程。

一、pl0编译原理的基本概念1.1 什么是pl0编程语言pl0是一种结构化的过程性编程语言，它的语法规则简单明了，易于学习和理解。

pl0支持基本的数据类型和控制结构，包括整型、实型、布尔型等。

1.2 pl0编译器的作用pl0编译器的主要作用是将pl0源代码转化为目标代码，使计算机能够理解和执行这些代码。

编译器的工作包括词法分析、语法分析、语义分析、中间代码生成和目标代码生成等。

1.3 pl0编译过程的主要阶段pl0编译过程主要包括词法分析、语法分析、语义分析和代码生成等阶段。

在词法分析阶段，编译器将源代码分解成一个个的词法单元；在语法分析阶段，编译器将词法单元按照语法规则组织成一个抽象语法树；在语义分析阶段，编译器对抽象语法树进行语义检查和类型推导；最后，在代码生成阶段，编译器将抽象语法树转化为目标代码。

二、pl0编译原理的主要过程2.1 词法分析词法分析是编译过程的第一步，它将源代码分解成一个个的词法单元。

在pl0编译器中，常见的词法单元包括关键字、标识符、常量、运算符和界符等。

编译器通过正则表达式和有限自动机等技术来实现词法分析。

2.2 语法分析语法分析是编译过程的第二步，它将词法单元按照语法规则组织成一个抽象语法树。

在pl0编译器中，常见的语法规则包括表达式、语句、函数和过程等。

编译器通过上下文无关文法和递归下降等技术来实现语法分析。

2.3 语义分析语义分析是编译过程的第三步，它对抽象语法树进行语义检查和类型推导。

在pl0编译器中，常见的语义检查包括变量声明检查、类型匹配检查和作用域检查等。

编译器通过符号表和类型推导等技术来实现语义分析。

2.4 代码生成代码生成是编译过程的最后一步，它将抽象语法树转化为目标代码。

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的取值取至栈顶。

编译原理实践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.

编译原理实践PL0的词法分析程序构造

取符号
字符串源程序
词法分析器
送符号
语法分析器
程序getsym
本课程采用第2种方案，程序名getsym，预先审视源程序下一个符号，并将读入的符号放在变量sym中，语法分析的判断分析将以这个读入的符号为基础具体任务：
跳过空格字符识别像begin、end、if、while等这样的保留字识别非保留字，作为标识符处理识别数字识别专用符号组合，如:=、<=、>= 识别特殊的单个字符，如+、-、/、* 跳过注释行（书中例子程序没有体现）
if i-1>j then sym:=wsym[k] else sym:=ident end else…
3)处理常数
相关变量/常量说明 num:integer (*词法分析器输出结果之用*) nmax=14 (*数字允许的最长位数*)
if ch in ['0'..'9'] then begin (* number *) k:=0; num:=0; sym:=number; repeat num:=10*num+(ord(ch)-ord('0')); k:=k+1; getch; until not (ch in ['0'..'9']); if k> nmax then error(30) end else…
word:array[1..norw] of alfa word[1]~word[11] (*保留字表，长度为10的保留字，多余用空格填充，以便词法分析时用二分法查找保留字*) wsym:array[1..norw] of symbol wsym[1]~wsym[11] (*在上面的保留字表中找到保留字后可以在本表中相应位置找到保留字类型*) ssym:array [char] of symbol ssym[‘+’]~ssym[‘;’] (*符号表，把可能出现的符号赋予上相应的类型，其余符号为nul*) 相关变量说明 sym:symbol (*词法分析器输出结果之用*) id:alfa (*词法分析器输出结果之用*) num:integer (*词法分析器输出结果之用*) i,j,k:integer (*局部变量*) a:alfa (*词法分析器中用于临时存放正在分析的词*) kk:integer (*引入此变量为了性能，初始为10 *)

编译原理实践6—PL0的语法分析程序构造

function position(id:alfa):integer; var i:integer; begin(* find identifier id in table *) table[0].name:=id; i:=tx; while table[i].name<>id do i:=i-1; position:=i end(* position *);
编译原理实践 --PL/0的语法分析程序
构造
由语法图到过程调用相关图从相关图到程序的总体结构写出每一个语法分析子程序语法分析程序的扩充 PL/0语法分析程序及其执行
PL/0编译程序在对PL/0源程序编译时，要经历词法分析、语法分析、出错处理、代码生成和解释执行一系列过程自顶向下、逐步扩充、分阶段实施 “结构化程序设计方法”
1. 建立符号表与主程序的扩充 2. 建立error子过程过程和出错信息表 3. 标识符的处理与程序的扩充
4.1建立符号表与主程序的扩充
在主程序的说明部分，对PL/0语言的符号类型symbol及其取值范围做了说明在主程序部分，对PL/0语言的所有保留字相பைடு நூலகம்的符号，以及在词法分析程序 getsym里最后要确定的各个单字符做了定义
1.由语法图到过程调用相关图
program
condition expression term
block
statement
factor
program PL0; procedure getsym; procedure getch; getch; getsym; procedure procedure procedure procedure procedure factor;
扩充常量说明、变量说明和过程说明扩充涉及调用标识符的有关赋值语句、过程调用语句，还有表达式等。

实验一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编译程序原理

课程: 编译原理理解PL/0编译程序原理实验报告系专业班级姓名学号指导教师1.实验目的1. 学习使用教学辅助软件THPL0CAI2. 掌握PL/0源程序的编译和解释过程2.实验平台Windows + THPL0CAI3.实验内容目录：pl0演示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 窗口4.实验报告给出编译过程中符号表的建立过程，1.选定编译内容test22.按空格键进行编译3.得出的符号表table.dat给出运行过程中运行栈的变化过程，只给出部分说明即可。

1.F9开始运行栈2.输入2，给变量赋值3.输入3，给变量赋值，得出结果4.输入0，结束运行栈5.思考题1) 理解编译和解释的含义，目标代码是按何种方式执行的？PL/0编译程序所产生的目标代码是一个假想栈式计算机的汇编语言，可称为类PCODE指令代码，它不依赖任何具体计算机，其指令集极为简单，指令格式也很单纯，其格式如下：f l a其中f代表功能码，l表示层次差，也就是变量或过程被引用的分程序与说明该变量或过程的分程序之间的层次差。

a的含意对不同的指令有所区别，对存取指令表示位移量，而对其它的指令则分别有不同的含义，见下面对每条指令的解释说明。

PL0编译程序实例剖析

PL/0 语言的EBNF表示语言的表示
语言的EBNF表示片断例:PL/0 语言பைடு நூலகம் 表示片断
<程序 ::= <分程序程序> 分程序>. 程序分程序 <分程序 ::= [<常量说明部分 [<变量说明部分分程序> 常量说明部分>] 变量说明部分变量说明部分>] 分程序常量说明部分 [<过程说明部分 <语句过程说明部分>] 语句语句> 过程说明部分
指令格式
f : 操作码
f
l
a
l : 层次差 (标识符引用层减去定义层) 标识符引用层减去定义层) a : 不同的指令含义不同
类P-code虚拟机虚拟机
指令 "INT 0 A"
《编译原理》
在栈顶开辟 A 个存储单元,服务于被调用的过程个存储单元, A 等于该过程的局部变量数加 3 等于该过程的局部变量数加 3 个特殊的联系单元特殊的联系单元
PL/0 语言的语义规则
类型, 类型,上下文约束与作用域规则
数据类型只有整数类型数据类型只有整数类型
数据结构只支持简单变量和常数数据结构只支持简单变量和简单变量所支持的数字为最长 9 位的十进制数标识符的有效长度为标识符的有效长度为10 标识符引用前先要声明过程无参数过程可嵌套,最多嵌套 3 层过程可嵌套, 过程可递归调用
第二讲
PL/0 编译程序
《编译原理》
PL/0编译程序编译程序
PL/0 编译程序总体结构 PL/0 语言简介类 P-code 虚拟机 PL/0 编译程序的词法分析 PL/0 编译程序的语法分析 PL/0 编译程序的语义分析 PL/0 编译程序的错误处理 PL/0 编译程序的目标代码生成

编译原理第2版第二章PL0编译程序

… ssym[‘;’]:=semicolon;
词法分析如何把单词传递给语法分析 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编译程序的总体设计
以语法、语义分析程序为核心词法分析程序和代码生成程序都作为一个过程，当语法分析需要读单词时就调用词法分析程序，而当语法、语义分析正确，需要生成相应的目标代码时，则调用代码生成程序。

编译原理PL0程序分析和详细注释

PL/0语言编译程序分析PL/0语言是Pascal语言的一个子集，我们这里分析的PL/0的编译程序包括了对PL/0语言源程序进行分析处理、编译生成类PCODE代码，并在虚拟机上解释运行生成的类PCODE代码的功能。

PL/0语言编译程序采用以语法分析为核心、一遍扫描的编译方法。

词法分析和代码生成作为独立的子程序供语法分析程序调用。

语法分析的同时，提供了出错报告和出错恢复的功能。

在源程序没有错误编译通过的情况下，调用类PCODE解释程序解释执行生成的类PCODE代码。

（注意：语法分析器每次用完这三个变量的值就立即调用getsym子程序获取新的单词供下一次使用。

而不是在需要新单词时才调用getsym过程）。

getsym过程通过反复调用getch子过程从源程序过获取字符，并把它们拼成单词。

getch过程中使用了行缓冲区技术以提高程序运行效率。

词法分析器的分析过程：调用getsym时，它通过getch过程从源程序中获得一个字符。

如果这个字符是字母，则继续获取字符或数字，最终可以拼成一个单词，查保留字表，如果查到则为保留字，把sym变量赋成相应的保留字类型值；如果没有查到，则这个单词应是一个用户自定义的标识符（可能是变量名、常量名或是过程的名字），把sym 置为ident，把这个单词存入id变量。

查保留字表时使用了二分法查找以提高效率。

如果getch获得的字符是数字，则继续用getch获取数字，并把它们拼成一个整数，然后把sym置为number，并把拼成的数值放入num变量。

如果识别出其它合法的符号（比如：赋值号、大于号、小于等于号等），则把sym则成相应的类型。

如果遇到不合法的字符，把sym置成nul。

语法分析子程序分析：语法分析子程序采用了自顶向下的递归子程序法，语法分析同时也根据程序的语意生成相应的代码，并提供了出错处理的机制。

编译原理实践-PL0的词法分析程序构造

编译原理实践-PL0的词法分析程序构造
通过本次演讲，将带你领略编译原理的奇妙之处，并深入介绍PL0语言的词法分析及程序构造，让你轻松掌握。
编译原理简介
编译原理是计算机科学的重要基础，涉及源代码的解析、优化和转换过程。它是开发高效程序和语言的关键。
PL0语言简介
PL0是一种简单且易于学习的编程语言，适合编译原理教学。它具有C语言的语法特点，是学习编译原理的理想选择。
词法分析的概念和作用
词法分析是编译过程中的第一步，将源代码分解为各种标记(Token)。它有助于语法分析和语义分析的进行。
PL0的词法规则
PL0的词法规则定义了它的各类标记，如关键字、标识符、运算符和常量。了解规则对于正确理解代码至关重要。
词法分析程序的设计思路
设词法分析程序需要考虑标识符的判别、关键字的识别等问题。采用有限自动机是一种常用的设计方法。
PL0的词法分析程序实现
使用C语言编写PL0的词法分析程序，结合有限自动机算法，有效地识别源代码中的各种标记。
实验结果与总结
通过实验，我们验证了词法分析程序的正确性和性能。深入总结实验结果，对编译原理的学习和应用有了更深入的理解。