#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "conio.h"
#include "iostream.h"
#include "ctype.h"

#define NORW 13//Pascal 子集的關鍵字的個數
#define TXMAX 100//標識符表的長度
#define NMAX 14 //數中數字的最大個數
#define AL 10 //標識符的長度
#define AMAX 2047 //最大地址
#define LEVMAX 3//分程序的最大深度
#define CXMAX 200//目標代碼數組的大小
#define STACKSIZE 500 //棧的深度

char *symbol[32]=
{
"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"
};

//PASCAL源程序關鍵字
char *word[NORW]=
{
"begin","call","const","do","end","if","odd","procedure",
"read","then","var","while","write"
};

//中間代碼關鍵字，與PASCAL源程序關鍵字對應
char *wsym[NORW]=
{
"beginsym","callsym","constsym","dosym","endsym","ifsym",
"oddsym","procsym","readsym","thensym","varsym","whilesym","writesym"
};

//操作命令代碼
char *mnemonic[8]=
{
"lit","opr","lod","sto","cal","ini","jmp","jpc"
};

char ch;//當前字符
char id[AL];//分析出的單詞的ID號即當前標識符
char sym[10];//當前符號
char line[81];//單詞輸入緩沖區
char a[AL];//暫存分析出的單詞
char fname[AL];//需讀入的文件名

enum object{constant,variable,procedur};
enum object kind;
enum fct{lit,opr,lod,sto,cal,ini,jmp,jpc};
enum listswitcher{fals,tru};//是否列目標清單的開關
enum listswitcher listswitch;


FILE *fa;
FILE *fa1,*fa2;
FILE *fin,*fout;

int err;//總的錯誤數
int num;//當前數
int cc;//字符計數
int ll;//行長
int kk;//預計要讀的單詞的長度
int cx=0;//code指針即目標代碼下標
int lev=0;//層次數
int tx=0;//table指針
int dx=0;//在s棧中相對的位置
int linecnt=0;//

struct instruction//生成的目標代碼的格式
{
enum fct f;//操作碼
int l;//層次值
int a;
};
struct instruction code[CXMAX+1];

struct table1
{//符號表
char name[AL];
enum object kind;
int val,level,adr,size;
};
struct table1 table[TXMAX+1];

//存放單詞
struct node
{
char *pa[32];
}*declbegsys,*statbegsys,*facbegsys,*tempsetsys;

//檢查str串是否在set結構體記錄中,若在返回1，否則返回0
int in(char *str,struct node *set)
{
int i=0;
while(set->pa[i]!=NULL)
{
if(strcmp(str,set->pa[i])==0)
{
return 1;
}
else
{
i++;
}
}
return 0;
}

//將set1和set1中沒有的set2的內容合成為一個node類型并返回(合并set1,set2)
struct node *add(struct node *set1,struct node *set2)
{
int i=0,j=0,k=0,cnt;
//定義pt，并申請空間
struct node *pt;
pt=(struct node *)malloc(sizeof(struct node));
for(cnt=0;cnt<32;cnt++)
{
pt->pa[cnt]=(char *)malloc(10*sizeof(char));
}
//將set1中內容拷貝到pt
while(set1->pa[i]!=NULL)
{
strcpy(pt->pa[j++],set1->pa[i++]);
}
//現在pt和set1中內容相同，但若set2中有與set1不同的內容，加入到pt中
while((set2->pa[k])!=NULL)
{
if(in(set2->pa[k],set1)==0)
{
strcpy(pt->pa[j++],set2->pa[k++]);
}
else
{
k++;
}
}
pt->pa[j]=NULL;
return(pt);
}

//輸出錯誤信息（錯誤類型代碼）并記錄總錯誤數
void error(int n)
{
int i;
printf("***");
fputs("***",fa1);
for(i=0;i<cc;i++)
{
printf("*");
}
for(i=0;i<cc;i++)
{
fputs("*",fa1);
}
printf("\nerror: %d\t",n);
fprintf(fa1,"\nerror: %d\t",n);
switch(n)
{
case 1:
printf("常量說明中的'='寫成了':='!\n");
fprintf(fa1,"常量說明中的'='寫成了':='!\n");
break;
case 2:
printf("常量說明中的'='之后不是數字!\n");
fprintf(fa1,"常量說明中的'='之后不是數字!\n");
break;
case 3:
printf("常量說明中的標識符的后繼符號不是'='!\n");
fprintf(fa1,"常量說明中的標識符的后繼符號不是'='!\n");
break;
case 4:
printf("CONST、VAR、PROCEDURE的后繼符號不是標識符!\n");
fprintf(fa1,"CONST、VAR、PROCEDURE的后繼符號不是標識符!\n");
break;
case 5:
printf("漏了','或';'!\n");
fprintf(fa1,"漏了','或';'!\n");
break;
case 6:
printf("過程說明結束符;的后繼符號既不是語句開始符也不是其它說明符(PROCEDURE)!\n");
fprintf(fa1,"過程說明結束符;的后繼符號既不是語句開始符也不是其它說明符(PROCEDURE)!\n");
break;
case 7:
printf("過程說明結束符;的后繼符號既不是語句開始符也不是其它說明符!\n");
fprintf(fa1,"過程說明結束符;的后繼符號既不是語句開始符也不是其它說明符!\n");
break;
case 8:
printf("程序體內語句部分的后繼符號不正確!\n");
fprintf(fa1,"程序體內語句部分的后繼符號不正確!\n");
break;
case 9:
printf("程序沒有以'.'結尾!\n");
fprintf(fa1,"程序沒有以'.'結尾!\n");
break;
case 10:
printf("語句之間缺';'!\n");
fprintf(fa1,"語句之間缺';'!\n");
break;
case 11:
printf("標識符未說明!\n");
fprintf(fa1,"標識符未說明!\n");
break;
case 12:
printf("賦值號左部標識符的屬性不是變量!\n");
fprintf(fa1,"賦值號左部標識符的屬性不是變量!\n");
break;
case 13:
printf("賦值號左部標識符的后繼符號不是':='!\n");
fprintf(fa1,"賦值號左部標識符的后繼符號不是':='!\n");
break;
case 14:
printf("CALL后繼符號不是標識符!\n");
fprintf(fa1,"CALL后繼符號不是標識符!\n");
break;
case 15:
printf("CALL后繼標識符的屬性不是過程!\n");
fprintf(fa1,"CALL后繼標識符的屬性不是過程!\n");
break;
case 16:
printf("條件語句缺'THEN'!\n");
fprintf(fa1,"條件語句缺'THEN'!\n");
break;
case 17:
printf("復合語句缺'END'!\n");
fprintf(fa1,"復合語句缺'END'!\n");
break;
case 18:
printf("WHILE型循環語句缺'DO'!\n");
fprintf(fa1,"WHILE型循環語句缺'DO'!\n");
break;
case 19:
printf("語句的后繼符號不正確!\n");
fprintf(fa1,"語句的后繼符號不正確!\n");
break;
case 20:
printf("布爾表達式中有非法關系運算符!\n");
fprintf(fa1,"布爾表達式中有非法關系運算符!\n");
break;
case 21:
printf("表達式內不能有過程標識符!\n");
fprintf(fa1,"表達式內不能有過程標識符!\n");
break;
case 22:
printf("因子中缺匹配的')'!\n");
fprintf(fa1,"因子中缺匹配的')'!\n");
break;
case 23:
printf("因子不能以此符號結束!\n");
fprintf(fa1,"因子不能以此符號結束!\n");
break;
case 24:
printf("因子不能以此符號開始!\n");
fprintf(fa1,"因子不能以此符號開始!\n");
break;
case 30:
printf("常數越界!\n");
fprintf(fa1,"常數越界!\n");
break;
case 31:
printf("表達式內常數越界!\n");
fprintf(fa1,"表達式內常數越界!\n");
break;
case 32:
printf("嵌套深度超過允許值!\n");
fprintf(fa1,"嵌套深度超過允許值!\n");
break;
case 33:
printf("READ或WRITE語句中缺')'!\n");
fprintf(fa1,"READ或WRITE語句中缺')'!\n");
break;
case 34:
printf("READ或WRITE語句中缺'('!\n");
fprintf(fa1,"READ或WRITE語句中缺'('!\n");
break;
case 35:
printf("READ語句中標識符未說明!\n");
fprintf(fa1,"READ語句中標識符未說明!\n");
break;
default:
printf("未處理的異常!\n");
fprintf(fa1,"未處理的異常!\n");
break;
}
err=err+1;
}

//如果緩沖區中有字符，則從中順序讀出一個字符，否則從文件讀入
void get_ch()
{
if(cc==ll+1)//已經完成上次讀入行的分析
{
if(feof(fin))
{ 
//已到文件結尾
printf("程序沒有結束!\n"); 
printf("要取消此次編譯嗎?(Y/N)");
char mychar;
cin>>mychar;
if(mychar=='Y'||mychar=='y')
{
exit(0);
}
}
ll=0;
cc=0;
//重新讀入一行
while(feof(fin)==false&&(ch=fgetc(fin))!='\n'&&ch!=-1)//尚未結束，將一行記錄輸出打印
{
putchar(ch);
fputc(ch,fa1);
line[ll++]=ch;
}
line[ll]=ch;
printf("\n");
line[ll]=ch;
fprintf(fa1,"\n");
}
ch=line[cc++];
if(ch>='A'&&ch<='Z')//處理大小寫區別
{
ch=ch+32;
}
}

//詞法分析,分解出一個單詞
void getsym()
{
int i,j,k;
while(ch==' '||ch=='\t'||ch=='\n')
{
get_ch();//讀字符
}
if(ch>='a'&&ch<='z')
{
k=0;

do
{
if(k<AL)
{
a[k]=ch;
k=k+1;
}
get_ch();
}
while((ch>='a'&&ch<='z')||(ch>='0'&&ch<='9'));

if(k>=kk)
{
kk=k;
}
else
{
if(k<kk-1)
{
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)
{
strcpy(sym,wsym[k]);
}
else
{
strcpy(sym,"ident");
}
}
else if(ch>='0'&&ch<='9')
{
k=0;
num=0;
strcpy(sym,"number");
do
{
num=10*num+(int)ch-'0';
k=k+1;
get_ch();
}
while(ch>='0'&&ch<='9');

if(k>NMAX)
{
error(30);
}
}
else if(ch==':')
{
get_ch();
if(ch=='=')
{
strcpy(sym,"becomes");
get_ch();
}
else
{
strcpy(sym,"nul");
}
}
else if(ch=='<')
{
get_ch();
if(ch=='=')
{
strcpy(sym,"leq");
get_ch();
}
else 
{
strcpy(sym,"lss");
}
}
else if(ch=='>')
{
get_ch();
if(ch=='=')
{
strcpy(sym,"geq");
get_ch();
}
else
{
strcpy(sym,"gtr");
}
}
else
{
switch(ch)
{
case '+': strcpy(sym,"plus");break;
case '-': strcpy(sym,"minus");break;
case '*': strcpy(sym,"times");break;
case '/': strcpy(sym,"slash");break;
case '(': strcpy(sym,"lparen");break;
case ')': strcpy(sym,"rparen");break;
case '=': strcpy(sym,"eql");break;
case ',': strcpy(sym,"comma");break;
case '.': strcpy(sym,"period");break;
case '#': strcpy(sym,"neq");break;
case ';': strcpy(sym,"semicolon");break;
}
get_ch();
}
}

//生成偽代碼
void gen(enum fct x,int y,int z)
{
if(cx>CXMAX)
{
printf("程序太長!");
}
else
{
code[cx].f=x;
code[cx].l=y;
code[cx].a=z;
cx++;
}
}

//檢測錯誤,如果分析時有錯，輸出該錯誤并繼續分析
void test(struct node *s1,struct node *s2,int n)
{
if(in(sym,s1)==0)
{
error(n);
s1=add(s1,s2);
while(in(sym,s1)==0)
{
getsym();
}
}
}

//造符號表table,將k加入table,k為類型聲明
void enter(enum object k)
{
tx=tx+1;
strcpy(table[tx].name,id);
table[tx].kind=k;
switch(k)
{
case constant:
if(num>NMAX)
{
error(31);
num=0;
}
table[tx].val=num;
break;
case variable:
table[tx].level=lev; 
table[tx].adr=dx;
dx++;
break;
case procedur:
table[tx].level=lev;
break;
}
}

//定位ID :查符號表并返回位置
int position(char id[10])
{
int i;
strcpy(table[0].name,id);
i=tx;
while(i>=0&&strcmp(table[i].name,id)!=0)
{
i--; 
}
return i;
}

//造常量表
void constdeclaration()
{
if(strcmp(sym,"ident")==0)
{
getsym();
if(strcmp(sym,"eql")==0||strcmp(sym,"becomes")==0)
{
if(strcmp(sym,"becomes")==0)
{
error(1);
}
getsym();
if(strcmp(sym,"number")==0)
{
enter(constant);
getsym();
}
else error(2);
}
else error(3);
}
else error(4);
}

//造變量表
void vardeclaration()
{

if(strcmp(sym,"ident")==0)
{
enter(variable);
getsym();
}
else error(4);
}


void listcode(int *cx0)
{
//打印本層的偽代碼
int i;
if(listswitch==tru)
{
printf("\n");
for(i=*cx0;i<=cx-1;i++)
{
printf("%2d %5s %3d %5d\n",i,mnemonic[(int)code[i].f],code[i].l,code[i].a);
fprintf(fa,"%2d %5s %3d %5d\n",i,mnemonic[(int)code[i].f],code[i].l,code[i].a);
}
printf("\n");
printf("\n");
}
}

//處理因子
void factor(struct node *fsys)
{
void expression(struct node *fsys);
int m=0,n=0,i;
char *tempset[]={"rparen",NULL};
struct node *temp;
temp=(struct node*)malloc(sizeof(struct node));
while(tempset[m]!=NULL) 
{
temp->pa[n++]=tempset[m++];
}
temp->pa[n]=NULL;
test(facbegsys,fsys,24);
while(in(sym,facbegsys)==1)
{
if(strcmp(sym,"ident")==0)
{
i=position(id);
if(i==0)//標識符未聲明
{
error(11);
}
else 
{
switch(table[i].kind)
{
case constant:
gen(lit,0,table[i].val);
break;
case variable:
gen(lod,lev-table[i].level,table[i].adr);
break;
case procedur:
error(21);
break;
}
}
getsym();
}
else if(strcmp(sym,"number")==0)
{
if(num>AMAX)
{
error(31);
num=0;
}
gen(lit,0,num);
getsym();
}
else if(strcmp(sym,"lparen")==0)
{
getsym();
expression(add(temp,fsys));
if(strcmp(sym,"rparen")==0)
{
getsym();
}
else
{
error(22);//缺匹配的右括號
}
}
test(fsys,facbegsys,23);
}
}

//處理項
void term(struct node *fsys)
{
int i=0,j=0;
char mulop[10];
char *tempset[]={"times","slash",NULL};
struct node *temp;
temp=(struct node *)malloc(sizeof(struct node));
while(tempset[i]!=NULL)
{
temp->pa[i++]=tempset[j++];
}
temp->pa[i]=NULL;
factor(add(temp,fsys));
while(in(sym,temp)==1)
{
strcpy(mulop,sym);
getsym();
factor(add(temp,fsys));
if(strcmp(mulop,"times")==0)
{
gen(opr,0,4);
}
else
{
gen(opr,0,5);
}
}
}

//處理算術表達式
void expression(struct node *fsys)
{
int m=0,n=0;
char addop[10];
char *tempset[]={"plus","minus",NULL};
struct node *temp;
temp=(struct node *)malloc(sizeof(struct node));
while(tempset[m]!=NULL)
{
temp->pa[n++]=tempset[m++];
}
temp->pa[n]=NULL;

if(in(sym,temp)==1)
{
strcpy(addop,sym);
getsym();
term(add(fsys,temp));
if(strcmp(addop,"minus")==0)
{
gen(opr,0,1);
}
}
else
{
term(add(fsys,temp));
}

while(in(sym,temp)==1)
{
strcpy(addop,sym);
getsym();
term(add(fsys,temp));
if(strcmp(addop,"plus")==0)
{
gen(opr,0,2);
}
else
{
gen(opr,0,3);
}
}
}

//處理條件表達式
void condition(struct node *fsys)
{
int i=0,j=0;
char relop[10];
char *tempset[]={"eql","neq","lss","leq","gtr","geq",NULL};
struct node *temp;
temp=(struct node *)malloc(sizeof(struct node));
while(tempset[i]!=NULL)
{
temp->pa[j++]=tempset[i++];
}
temp->pa[j]=NULL;
if(strcmp(sym,"oddsym")==0)
{
getsym();
expression(fsys);
gen(opr,0,6);
}
else
{
expression(add(temp,fsys));
if(in(sym,temp)==0)
{
error(20);
}
else
{
strcpy(relop,sym);
getsym();
expression(fsys);
if(strcmp(relop,"eql")==0) gen(opr,0,8);
if(strcmp(relop,"neq")==0) gen(opr,0,9);
if(strcmp(relop,"lss")==0) gen(opr,0,10);

if(strcmp(relop,"geq")==0) gen(opr,0,11);
if(strcmp(relop,"gtr")==0) gen(opr,0,12);
if(strcmp(relop,"leq")==0) gen(opr,0,13);
}
}
}