📄 pll.h
字号:
{
//to the end
getsymdo;
}
else
{
printerr(0);
}
}while(sym==ident);//只对标识符进行
}
if(sym==varsym)//如果是变量
{
getsymdo;
if(sym!=ident)
printerr(21);
again: varnum=0;
do
{
//变量处理函数
//递归调用
varnum++;
do_deal_var(&tx,lev,&dx);
while(sym==comma)
{
getsymdo;
//变量函数处理
//调用
varnum++;
do_deal_var(&tx,lev,&dx);
}
if(sym==colon)
{
getsymdo;
if(sym==charsym||sym==realsym||sym==integersym)
{
for(j=varnum-1;j>=0;j--)
{
//fill the table
if(sym==integersym)
table[tx-j].type=integer;//???????????
if(sym==realsym)
table[tx-j].type=real;
if(sym==charsym)
table[tx-j].type=plchar;
}
getsymdo;
}
else
printerr(4);//can't find the type
}
if(sym==semicolon)
{
varnum=0;
getsymdo;
if(sym==ident)
goto again;//deal_var(&tx,lev,&dx);//??????????
}
else
{
printerr(0);
}
}while(sym==ident);
}
//关于函数处理的位置,是否合理,
//需再做分析.
if(sym==functionsym)
{ //为函数
//处理过程与过程相似.
//filltable(function,&tx,lev,&dx,nul);
//rex=tx;//save the value of the function in the table
//类型先为空
varnum=0;
j=0;
getsymdo;
if(sym!=ident)
{
printerr(38);
}
else
{
filltable(function,&tx,lev,&dx,nul);//fill the table in the tx+1 item
rex=tx;//vip
getsymdo;
if(sym==lparen)
{
do
{
varnum=0;
j=0;
do//对前部分类型变量的处理.
{
getsymdo;
if(sym!=ident)
{
printerr(18);
}
varnum++;
filltable(parameter,&tx,lev,&dx,nul);//求知类型
getsymdo;
}while(sym==comma);
//getsymdo;
if(sym!=colon)
printerr(4);
//else
getsymdo;
if(sym!=integersym&&sym!=charsym&&sym!=realsym)
{
printerr(4);
}
else
{
for(j=varnum-1;j>=0;j--)
{
if(sym==integersym)
{
table[tx-j].type=integer;
}
if(sym==charsym)
{
table[tx-j].type=plchar;
}
if(sym==realsym)
{
table[tx-j].type=real;
}
}
}//处理结束.
getsymdo;
}while(sym==semicolon);
if(sym!=rparen)
{
printerr(7);
}
getsymdo;
//}
//函数的返回值反填表
if(sym!=colon)
{
printerr(39);
}
getsymdo;
if(sym!=integersym&&sym!=realsym&&sym!=charsym)
{
printerr(4);
//type is nul
}
else
{
if(sym==integersym)
{
table[rex].type=integer;
}
if(sym==realsym)
{
table[rex].type=real;
//printf("函数的返回类型测试:real\n");
}
if(sym==charsym)
{
table[rex].type=plchar;
}
table[rex].paranum=varnum;
}
getsymdo;
if(sym==semicolon)
{
getsymdo;
}
else
{
printerr(0);// 分号
//getsymdo;///vip:???
}
}
else
{
if(sym!=colon)
printerr(39);
else
getsymdo;
if(sym!=integersym&&sym!=charsym&&sym!=realsym)
printerr(39);
else
{
if(sym==integersym)
table[rex].type=integer;
if(sym==charsym)
table[rex].type=plchar;
if(sym==realsym)
table[rex].type=real;
}
getsymdo;
if(sym!=semicolon)
printerr(0);
else
getsymdo;
}//printerr(11);
//end of the lparen
//if(-1==senantic(lev+1,tx,nextlev))
// {
// return -1;
// }
//在上部分代码中,递归调用,处理嵌套.
// if(sym==semicolon)
// {
// getsymdo;
// memcpy(nextlev,statement_firstset,sizeof(bool)*keynum);
// nextlev[ident]=true;
// nextlev[proceduresym]=true;
// do_test(nextlev,fsys,6);// pay attention to the 6
// }
// else
// {
//printerr(0);///////////
// }
}
}
if(sym==proceduresym)//对其形式参数的处理与对函数的处理一致.
{
varnum=0;
j=0;
getsymdo;
//过程声明
if(sym==ident)
{
//记录过程名字
filltable(procedure,&tx,lev,&dx,nul);//由于过程无返回类型,
//故而该项对其而言无意义
//在填表后,过程在表中的位置应该是tx+1;
getsymdo;
if(sym==lparen)
{
do{
varnum=0;
j=0;
do
{
getsymdo;
if(sym!=ident)
{
printerr(18);
}
varnum++;
filltable(parameter,&tx,lev,&dx,nul);//求知类型
getsymdo;
}while(sym==comma);
////////////
//getsymdo;
if(sym!=colon)
printerr(4);
getsymdo;
if(sym!=integersym&&sym!=charsym&&sym!=realsym)
{
printerr(4);
}
else
{
for(j=varnum-1;j>=0;j--)
{
if(sym==integersym)
{
table[tx-j].type=integer;
}
if(sym==charsym)
{
table[tx-j].type=plchar;
}
if(sym==realsym)
{
table[tx-j].type=real;
}
}
}
getsymdo;
}while(sym==semicolon);
if(sym!=rparen)
{
printerr(7);
}
getsymdo;
if(sym==semicolon)
{
getsymdo;
}
else
{
printerr(0);// 分号
}
}
else
{
if(sym!=semicolon)
printerr(0);
else
getsymdo;
}
}
memcpy(nextlev,fsys,sizeof(bool)*keynum);
nextlev[semicolon]=true;
if(-1==senantic(lev+1,tx,nextlev))
{
return -1;
}
//在上部分代码中,递归调用,处理嵌套.
if(sym==semicolon)
{
getsymdo;
memcpy(nextlev,statement_firstset,sizeof(bool)*keynum);
nextlev[ident]=true;
nextlev[proceduresym]=true;
do_test(nextlev,fsys,6);// pay attention to the 6
}
else
{
//printerr(0);///////////
}
//no ;
}
memcpy(nextlev,statement_firstset,sizeof(bool)*keynum);
nextlev[ident]=true;
nextlev[period]=true;
//to the end .
//do_test(nextlev,block_firstset,4);
}while(sym==varsym||sym==functionsym||sym==proceduresym||sym==constsym);//!in_set(sym,block_firstset));
code[table[tx0].adr].a=cx;
//开始生成当前过程的代码
table[tx0].adr=cx;
table[tx0].size=dx;
//
cx0=cx;
pa.i=dx;
do_genecode(inte,0,pa,integer);
//符号表输出,到文件.tab中.
//以下printf用于测试,同时也写入文件中
printf("符号表输出:\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 \t",i,table[i].name);
fprintf(ftab,"%d const :%s\t",i,&(table[i].name));
if(table[i].type==integer)
{
printf("val=%d\n",table[i].val_int);
fprintf(ftab,"val=%d \n",table[i].val_int);
}
if(table[i].type==real)
{
printf("val=%f\n",table[i].val_real);
fprintf(ftab,"val=%f \n",table[i].val_real);
}
if(table[i].type==plchar)
{
printf("val= %c \n",table[i].c);
fprintf(ftab,"val=%c \n",table[i].c);
}
if(table[i].type==string)
{
printf("val=%s\n",&(table[i].string[0]));
fprintf(ftab,"val=%s\n",&(table[i].string[0]));
}
break;
case var:
printf("%d var %s \t",i,table[i].name);
printf("lev=%d addr=%d\n",table[i].level,table[i].adr);
fprintf(ftab,"%d var %s\t",i,&(table[i].name));
fprintf(ftab,"lev=%d addr=%d\n",table[i].level,table[i].adr);//directly return stringely:10
if(table[i].type==integer)
{
printf("val type is:integer\n");
fprintf(ftab,"val type is:integer\n");
}
if(table[i].type==real)
{
printf("val type is: real\n");
fprintf(ftab,"val type is:real\n");
}
if(table[i].type==plchar)
{
printf("val type is:char\n");
fprintf(ftab,"val type is:char\n");
}
if(table[i].type==string)
{
printf("val type is:string\n");
fprintf(ftab,"val type is:string\n");
}
break;
case procedure:
printf("%d procedure %s\t",i,table[i].name);
fprintf(ftab,"%d,procedure %s\n",i,table[i].name);
printf("lev=%d addr=%d size=%d \n",table[i].level,table[i].adr,table[i].size);
fprintf(ftab,"lev=%d addr=%d size=%d \n",table[i].level,table[i].adr,table[i].size);
break;
case function:
printf("%d function %s\t",i,table[i].name);
printf("lev=%d paramenter_num=%d\n",table[i].level,table[i].paranum);
fprintf(ftab,"%d function %s\n",i,table[i].name);
fprintf(ftab,"lev=%d patameter_num=%d\n",table[i].level,table[i].paranum);
//此处未考虑地址以及大小.
if(table[i].type==integer)
{
printf("return type is:integer\n");
fprintf(ftab,"return type is:integer\n");
}
if(table[i].type==real)
{
printf("function type is: real\n");
fprintf(ftab,"function type is:real\n");
}
if(table[i].type==plchar)
{
printf("function type is:char\n");
fprintf(ftab,"function type is:char\n");
}
if(table[i].type==string)
{
printf("function type is:string\n");
fprintf(ftab,"function type is:string\n");
}
break;
case parameter://参数
printf("%d parameter name:%s\t",i,table[i].name);
fprintf(ftab,"%d parameter name:%",i,table[i].name);
if(table[i].type==integer)
{
printf("val type is:integer\n");
fprintf(ftab,"val type is:integer\n");
}
if(table[i].type==real)
{
printf("val type is: real\n");
fprintf(ftab,"val type is:real\n");
}
if(table[i].type==plchar)
{
printf("val type is:char\n");
fprintf(ftab,"val type is:char\n");
}
if(table[i].type==string)
{
printf("val type is:string\n");
fprintf(ftab,"val type is:string\n");
}
break;
default:
printf("Warning %d !.\n",i);// just for test
break;
}
}
memcpy(nextlev,fsys,sizeof(bool)*keynum);
nextlev[semicolon]=true;
nextlev[endsym]=true;
do_deal_statement(nextlev,&tx,lev);
// printf("have to the before of the deal_statement.\n");
pa.i=0;
do_genecode(opr,0,pa,integer);
memset(nextlev,0,sizeof(bool)*keynum);
//do_test(fsys,nextlev,8);//////////////////////??????????????????????
//list out the code
return 0;
}
//在下面将实现各部分对应的处理函数,名称约定:deal_加上对应的名称
//常量处理函数
int deal_constant(int *ptx,int lev,int *pdx)
{
if(sym==ident)
{
getsymdo;
if(sym!=eql)
{
printerr(1);
do
{
getsymdo;
}while(sym==semicolon);//control the error spreading
return -1;
}
else
{
getsymdo;
if(sym==integersym)
{
filltable(constant,ptx,lev,pdx,integer);
//fill the table
getsymdo;
}
else if(sym==realsym)
{
filltable(constant,ptx,lev,pdx,real);
getsymdo;
}
else if(sym==charsym)
{
filltable(constant,ptx,lev,pdx,plchar);
getsymdo;
}
else if(sym==stringsym)
{
filltable(constant,ptx,lev,pdx,string);
getsymdo;
}
else if(sym==minus)
{
pa.i=0;
//genecode(opr,0,pa,integer);
getsymdo;
if(sym==integersym||sym==realsym)
{
if(sym==integersym)
//int
{
num=-num;
filltable(constant,ptx,lev,pdx,integer);
getsymdo;
}
if(sym==realsym)
{
fnum=-fnum;
filltable(constant,ptx,lev,pdx,real);
getsymdo;
}
// getsymdo;
}
else
printerr(20);
}
else
printerr(20);//unknow type
}
return 0;
}
else
{
printerr(19); //no ident
return -1;
}
}
int deal_var(int *ptx,int lev,int *pdx)//如果在此处就对多个变量的一次定义进行处理则在上面sennatic函数中 //就不需要进循环处理,否则重复出错; //应对此选择,在此处理易填表.
{
int k=1;
int j=0;
//while(sym==ident)//||sym==comma)
// {
if(sym==ident)
{
filltable(var,ptx,lev,pdx,real);//the type of the var ////////?????
//they have the same type
getsymdo;
}
//else if(sym==comma)
// {
// k++;
// getsymdo;
// }
else
{
printerr(21);
}
//}
/// 反添
//sym==colon;
/*getsymdo;
if(sym==integersym||sym==realsym||sym==charsym)
{
for(j=k;j>0;j--)
{
//fill the table
if(sym==integersym)
table[(*ptx)-j].type=integer;
if(sym==realsym)
table[(*ptx)-j].type=real;
if(sym==charsym)
table[(*ptx)-j].type=plchar;
}
}
else
{
printerr(20);
return -1;
}*/
return 0;
}
void filltable(enum typeset k,int *ptx,int lev,int *pdx,enum typeset t )
{
(*ptx)++;
strcpy(&(table[(*ptx)].name[0]),id);
table[(*ptx)].kind=k;
if(k!=procedure)
table[(*ptx)].type=t;// pay attention ,when it is a function or parameter should be nul first
switch(k)//deal with the different type with different ways
{
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -