?//A.2 C 版 本

/*編譯和運行環境:
*1Visual C++6.0,VisualC++.NET and Visual C++.NET 2003
*WinNT, Win 200, WinXP and Win2003
*2 gcc version 3.3.2 20031022(Red Hat Linux 3.3.2-1)
*Redhat Fedora core 1
*Intel 32 platform
*使用方法:
*運行后輸入PL/0 源程序文件名
*回答是否輸出虛擬機代碼
*回答是否輸出名字表
*fa.tmp 輸出虛擬機代碼
*fa1.tmp 輸出源文件及其各行對應的首地址
*fa2.tmp 輸出結果
*fas.tmp 輸出名字表
*/
#include<stdio.h>
#include"pl0.h"
#include"string.h"
/*解釋執行時使用的棧*/
#define stacksize 500
int main()
{
bool nxtlev[symnum];
printf("Input pl/0 file ?");
scanf(">s",fname); /*輸入文件名*/
fin=fopen(fname,"r");
if(fin)
{
printf("List object code ?(Y/N)"); /*是否輸出虛擬機代碼*/
scanf(">s",fname);
listswitch=(fname[0]=='y'||fname[0]=='Y');
printf("List symbol table ? (Y/N)"); /*是否輸出名字表*/
scanf(">s",fname);
tableswitch=(fname[0]=='y'||fname[0]=='Y');
fa1=fopen("fa1.tmp","w");
fprintf(fa1,"Iput pl/0 file ?");
fprintf(fa1,">s\n", 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(fa1);
fclose(fas);
fclose(fin);
printf("\n");
return 0;
}
fclose(fa);
fclose(fa1);
fclose(fas);
if(sym!=period)
{
error(9);
}
if(err==0)
{
fa2=fopen("fa2.tmp", "w");
interpret();
fclose(fa2);
}
else
{
printf("Errors in pl/0 program");
}
}
fclose(fin);
}
else
{
printf("Can't open file! \n");
}
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(&amt;(word[0][0]),"begin");
strcpy(&amt;(word[1][0]),"call");
strcpy(&amt;(word[2][0]),"const");
strcpy(&amt;(word[3][0]),"do");
strcpy(&amt;(word[4][0]),"end");
strcpy(&amt;(word[5][0]),"if");
strcpy(&amt;(word[6][0]),"odd");
strcpy(&amt;(word[7][0]),"procedure");
strcpy(&amt;(word[8][0]),"read");
strcpy(&amt;(word[9][0]),"then");
strcpy(&amt;(word[10][0]),"var");
strcpy(&amt;(word[11][0]),"while");
strcpy(&amt;(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(&amt;(mnemonic[lit][0]),"lit");
strcpy(&amt;(mnemonic[opr][0]),"opr");
strcpy(&amt;(mnemonic[lod][0]),"lod");
strcpy(&amt;(mnemonic[sto][0]),"sto");
strcpy(&amt;(mnemonic[cal][0]),"cal");
strcpy(&amt;(mnemonic[inte][0]),"int");
strcpy(&amt;(mnemonic[jmp][0]),"jmp");
strcpy(&amt;(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;
}
int subset(bool* sr,bool* s1,bool* s2,int n)
{
int i;
for(i=0;i<n;i++)
{
sr[i]=s1[i]&amt;&amt;(!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]&amt;&amt;s2[i];
}
return 0;
}
/*
*出錯處理，打印出錯位置和錯誤編碼
*/
void error(int n)

{
char space[81];
memset(space,32,81); printf("------->c\n",ch);
space[cc-1]=0;//出錯時當前符號已經讀完，所以cc-1
printf("****>s!>d\n",space,n);
err++;
}
/*
* 漏掉空格，讀取一個字符
*
* 每次讀一行，存入line緩沖區，line被getsym取空后再讀一行
*
* 被函數getsym調用
*/
int getch()
{
if(cc==ll)
{
if(feof(fin))
{
printf("program incomplete");
return -1;
}
ll=0;
cc=0;
printf(">d ",cx );
fprintf(fa1,">d ",cx);
ch=' ';
while(ch!=10)
{
//fscanf(fin,">c",&amt;ch)
if(EOF==fscanf(fin,">c",&amt;ch))
{
line[ll]=0;
break;
}
printf(">c",ch);
fprintf(fa1,">c",ch);
line[ll]=ch;
ll++;
}
printf("\n");
fprintf(fa1,"\n");
}
ch=line[cc];
cc++;
return 0;
}
/*詞法分析，獲取一個符號
*/

int getsym()
{
int i,j,k;
while( ch==' '||ch==10||ch==9)
{
getchdo;
}
if(ch>='a'&amt;&amt;ch<='z')
{
k=0;
do{
if(k<al)
{
a[k]=ch;
k++;
}
getchdo;
}while(ch>='a'&amt;&amt;ch<='z'||ch>='0'&amt;&amt;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'&amt;&amt;ch<='9')
{
k=0;
num=0;
sym=number;
do{
num=10*num+ch-'0';
k++;
getchdo;
}while(ch>='0'&amt;&amt;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];/* 當符號不滿足上述條件時，全部按照單字符號處理*/
//getchdo;
//richard
if(sym!=period)
{
getchdo;
}
//end richard
}
}
}
}
}
return 0;
}
/*
*生成虛擬機代碼
*
*x:instruction.f;
*y:instruction.l;
*z:instruction.a;
*/
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;
}
/*
*測試當前符號是否合法
*
*在某一部分（如一條語句，一個表達式）將要結束時時我們希望下一個符號屬于某集合
*（該部分的后跟符號） test 負責這項檢測，并且負責當檢測不通過時的補救措施
*程序在需要檢測時指定當前需要的符號集合和補救用的集合（如之前未完成部分的后跟
*符號），以及不通過時的錯誤號
*
*S1：我們需要的符號
*s2:如果不是我們需要的，則需要一個補救用的集合
*n:錯誤號
*/


int test(bool* s1,bool* s2,int n)
{
if(! inset(sym,s1))
{
error(n);
/*當檢測不通過時，不停獲取符號，直到它屬于需要的集合或補救的集合*/
while((! inset(sym,s1))&amt;&amt;(! inset(sym,s2)))
{
getsymdo;
}
}
return 0;
}
/*
*編譯程序主體
*
*lev:當前分程序所在層
*tx:名字表當前尾指針
*fsys:當前模塊后跟符號集合
*/
int block(int lev,int tx,bool* fsys)
{
int i;
int dx; /*名字分配到的相對地址*/
int tx0; /*保留初始tx*/
int cx0; /*保留初始cx*/
bool nxtlev[symnum]; /*在下級函數的參數中，符號集合均為值參，但由于使用數組
實現，傳遞進來的是指針，為防止下級函數改變上級函數的
集合，開辟新的空間傳遞給下級函數*/
dx=3;
tx0=tx; /*記錄本層名字的初始位置*/
table[tx].adr=cx;
gendo(jmp,0,0);
if(lev > levmax)
{
error(32);
}
do{
if(sym==constsym) /*收到常量聲明符號，開始處理常量聲明*/
{
getsymdo;
do{
constdeclarationdo(&amt;tx,lev,&amt;dx); /*dx的值會被constdeclaration改變，使用
指針*/
while(sym==comma)
{
getsymdo;
constdeclarationdo(&amt;tx,lev,&amt;dx);
}
if(sym==semicolon)
{
getsymdo;
}
else
{
error(5); /*漏掉了逗號或者分號*/
}
}while(sym==ident);
}
if(sym==varsym)/*收到變量聲名符號，開始處理變量聲名*/
{
getsymdo;
do{
vardeclarationdo(&amt;tx,lev,&amt;dx);
while(sym==comma)
{
getsymdo;
vardeclarationdo(&amt;tx,lev,&amt;dx);
}
if(sym==semicolon)
{
getsymdo;
}
else
{
error(5);
}
}while(sym==ident);
}
while(sym==procsym)/*收到過程聲名符號，開始處理過程聲名*/
{
getsymdo;
if(sym==ident)
{
enter(procedur,&amt;tx,lev,&amt;dx);/*記錄過程名字*/
getsymdo;
}
else
{
error(4);/*procedure后應為標識符*/
}
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; /*聲明部分中每增加一條聲明都會給dx增加1,聲明部分已經結束,dx就是當前過程數據的size*/

cx0=cx;
gendo(inte,0,dx); /*生成分配內存代碼*/
if(tableswitch) /*輸出名字表*/
{
printf("TABLE:\n");
if(tx0+1>tx)
{
printf("NULL\n");
}
for(i=tx0+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 adr=>d size=>d \n",table[i].level,table[i].adr,table[i].size);
break;
}
}
printf("\n");
}
/*語句后跟符號為分號或end*/
memcpy(nxtlev,fsys,sizeof(bool)*symnum);/*每個后跟符號集和都包含上層后跟符號集和，以便補救*/
nxtlev[semicolon]=true;
nxtlev[endsym]=true;
statementdo(nxtlev,&amt;tx,lev);
gendo(opr,0,0); /*每個過程出口都要使用的釋放數據段命令*/
memset(nxtlev,0,sizeof(bool)*symnum); /*分程序沒有補救集合*/
test(fsys,nxtlev,8); /*檢測后跟符號正確性*/
listcode(cx0); /*輸出代碼*/
return 0;
}
/*
*在名字表中加入一項
*
*k:名字種類const,var or procedure
*ptx:名字表尾指針的指針，為了可以改變名字表尾指針的數值
*lev:名字所在的層次，以后所有的lev都是這樣
*pdx:為當前應分配的變量的相對地址，分配后要增加1
*/
void enter (enum object k,int *ptx,int lev, int *pdx)
{
(*ptx)++;
strcpy(table[(*ptx)].name,id); /*全局變量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;
}

}
/*
*查找名字的位置
*找到則返回在名字表中的位置，否則返回0
*
*idt: 要查找的名字
*tx:：當前名字表尾指針
*/
int position(char * idt,int tx)
{
int i;
strcpy(table[0].name,idt);
i=tx;
while(strcmp(table[i].name,idt)!=0)
{
i--;
}