cifa.c

c语言写的pascal词法语法分析器

#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);
}
}
}