编译原理三级项目PL/0的研究与改进

最新推荐文章于 2024-07-25 14:57:29 发布
最新推荐文章于 2024-07-25 14:57:29 发布
阅读量719 收藏 13
点赞数 2
分类专栏： 编译原理 文章标签： 编辑器 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52142023/article/details/127521859
版权

PL/0的研究与改进

1.扩充else语句

if-then-else语句的EBNF范式描述
<条件语句>:=if<条件>then<语句>[else <语句>]
语法描述图为
在这里插入图片描述
需要修改的代码：
1.头文件修改
2.设置保留字名字和符号
3.statement中修改
（文章最后会放入整体代码）

2. 扩充for-to|downto语句

for语句的EBNF范式描述为
<for循环语句>:=for<赋值语句>to|downtodo<语句>
语法描述图为
在这里插入图片描述
需要修改的代码：
1.头文件修改：增加关键字个数，扩充符号集
2.设置保留字名字和符号、增加语句开始符号集
3.statement中修改

3.+=、-=、*=、/=、注释语句

EBNF范式描述
<赋值语句>::=<标识符>[+=|-=| * =| /=|:=]<标识符>
<行注释> ::= // <语句>
<块注释> ::=/ * 语句{<语句>} * /
语法描述图
在这里插入图片描述在这里插入图片描述
在这里插入图片描述
代码的修改：
①注释只需要修改.c文件中的getsym函数
②其余运算符需修改：
1.头文件修改：增加关键字个数，扩充符号集
2.修改getsym()，读出+=、-=、*=、/=运算符
3.statement中修改

4.++、–的扩充

EBNF描述为：
<自增语句>::=++<标识符>|<标识符>++
<自减语句>::=–<标识符>|<标识符>–
语法描述图为：
在这里插入图片描述
代码的修改：
1.头文件修改：增加关键字个数，扩充符号集
2.修改语句开始符号集
3.修改getsym()，读出++、–运算符
4.对statement中修改

代码

pl0.c

//else  ok;for  ok;to  and  downto ok;   
//识别出*=  /=  后++  后--   能识别出/* */注释 ; 

//Array4.pl0    识别if-then-else
//Array16.pl0 识别for循环 
//Array11  *=  /=   注释 
//Array8 后++  后--  前++  前-- 
//Array18 +=   -=
//Array12  识别单字符 


/*
*使用方法:
*运行后输入PL/0 源程序文件名
*回答是否输出虚拟机代码
*回答是否输出名字表
*fa.tmp 输出虚拟机代码
*fa1.tmp  输出源文件及其各行对应的首地址
*fa2.tmp  输出结果 
*fas.tmp  输出名字表
*/
#include<stdio.h>
#include"pl0(11).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");
    getchar();
    getchar();
    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]),"downto");/*增加保留字downto*/
    strcpy(&(word[5][0]),"else");/*增加保留字else*/
    strcpy(&(word[6][0]),"end");
    strcpy(&(word[7][0]),"for");/**增加保留字for*/
    strcpy(&(word[8][0]),"if");
    strcpy(&(word[9][0]),"odd");
    strcpy(&(word[10][0]),"procedure");
    strcpy(&(word[11][0]),"read");
    strcpy(&(word[12][0]),"then");
    strcpy(&(word[13][0]),"to");/*增加保留字to*/
    strcpy(&(word[14][0]),"var");
    strcpy(&(word[15][0]),"while");
    strcpy(&(word[16][0]),"write");
    /*设置保留字符号*/
    wsym[0]=beginsym;
    wsym[1]=callsym;
    wsym[2]=constsym;
    wsym[3]=dosym;
    wsym[4]=downtosym;/*增加保留字符号downtosym*/
    wsym[5]=elsesym;/*增加保留字符号elsesym*/
    wsym[6]=endsym;
    wsym[7]=forsym;/*增加保留字符号forsym*/
    wsym[8]=ifsym;
    wsym[9]=oddsym;
    wsym[10]=procsym;
    wsym[11]=readsym;
    wsym[12]=thensym;
    wsym[13]=tosym;/*增加保留字符号tosym*/ 
    wsym[14]=varsym;
    wsym[15]=whilesym;
    wsym[16]=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;
    statbegsys[forsym]=true;
    statbegsys[plusplus]=true;
    statbegsys[minusminus]=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]&&(!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);
    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",&ch)
            if(EOF==fscanf(fin,"%c",&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'&&ch<='z')
    { 
        k=0;
        do{
            if(k<al)
            { 
                a[k]=ch;
                k++;
            }
            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];
        }
        else
        {
            sym=ident;
        }
    }
    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)
            {
                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 if(ch=='*')
                    {
                        getchdo;
                        if(ch=='=')
                        {
                            sym=timeseql;//构成*=号
                            
                            getchdo;
                        }
                        else
                        {
                            sym=times;
                        }
                    }
                    else if(ch=='/')
                    {
                        getchdo;
                        if(ch=='=')
                        {
                            sym=slasheql;//构成/=号
                            
                            getchdo;
                        }
                        else if(ch == '*')
                        {
                        	getch();
                        	while(1)
                        	{
                        		while(ch != '*')
                        		   getch();
                        		getch();
                        		if(ch == '/')
                        		   break;
							}
							getch();
							getsym();
						}
                        else if(ch=='/')//增加注释功能
                        {
                            cc=ll;
                            ch=' ';
                            getsym();
                        }
                        else
                        {
                            sym=slash;
                        }
                    }
                    else if(ch=='+')
                    {
                        getchdo;
                        if(ch=='+')
                        {
                            sym=plusplus;//构成++号
                            
                            getchdo;
                        }
                        else if(ch=='=')
						{
							sym=pluseql;
							getchdo;
						}
						else
                        {
                            sym=plus;
                        }
                    }
                    else if(ch=='-')
                    {
                        getchdo;
                        if(ch=='-')
                        {
                            sym=minusminus;//构成--号
                           
                            getchdo;
                        }
                        else if(ch=='=')
                        {
                        	sym=minuseql;
                        	getchdo;
						}
						else
                        {
                            sym=minus;
                        }
                    }
                    
                    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))&&(! 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(&tx,lev,&dx);   /*dx的值会被constdeclaration改变，使用
                                                     指针*/
                while(sym==comma)
                {
                   getsymdo;
                   constdeclarationdo(&tx,lev,&dx);
                }
                if(sym==semicolon)
                {
                  getsymdo;
                }
                else
                {
                    error(5); /*漏掉了逗号或者分号*/
                }
            }while(sym==ident);
        }
        if(sym==varsym)/*收到变量声名符号，开始处理变量声名*/
        {
            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)/*收到过程声名符号，开始处理过程声名*/
        {
            getsymdo;
            if(sym==ident)
            {
                enter(procedur,&tx,lev,&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,&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--;
    }
    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);                        /*const后应是标识*/
    }
    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++)
        {
            printf("%d %s %d %d\n",i,mnemonic[code[i].f],code[i].l,code[i].a);
            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;
                    memcpy(nxtlev,fsys,sizeof(bool)* symnum);
                    expressiondo(nxtlev,ptx,lev);
                    if(i!=0)//如果不曾出错，i将不为0，i所指为当前语句
                            //左部标识符在符号表中的位置 
                    {
                        gendo(sto,lev-table[i].level,table[i].adr);
                    }
                }
                else if(sym==timeseql) // *=运算 
                {
                    getsymdo;
                    memcpy(nxtlev,fsys,sizeof(bool)* symnum);
                    gendo(lod,lev-table[i].level,table[i].adr);
					expressiondo(nxtlev,ptx,lev); 
                    if(i!=0)
                    {
                       gendo(opr,0,4);
                       gendo(sto,lev-table[i].level,table[i].adr);
                    }
                    
                }
                else if(sym==slasheql) // /=运算 
                {
                    getsymdo;
                    memcpy(nxtlev,fsys,sizeof(bool)* symnum);
                    gendo(lod,lev-table[i].level,table[i].adr);
                    expressiondo(nxtlev,ptx,lev);
                    if(i!=0)
                    {
                        gendo(opr,0,5);
                        gendo(sto,lev-table[i].level,table[i].adr);
                    }
                }
                else if(sym==plusplus) // 后++运算 
                {
                    getsymdo;
                    gendo(lod,lev-table[i].level,table[i].adr);//找到变量地址，将其值入栈
                    gendo(lit,0,1);//将常数1取到栈顶
                    if(i!=0)
                    {
                        gendo(opr,0,2);     //执行加操作
                        gendo(sto,lev-table[i].level,table[i].adr);
                    }
                }
                else if(sym==minusminus) // 后--运算 
                {
                    getsymdo;
                    gendo(lod,lev-table[i].level,table[i].adr);//找到变量地址，将其值入栈
                    gendo(lit,0,1);//将常数1取到栈顶
                    if(i!=0)
                    {
                        gendo(opr,0,3);     //执行减操作
                        gendo(sto,lev-table[i].level,table[i].adr);
                    }
                }
                else if(sym==pluseql) // +=运算 
                {
                    getsymdo;
                    memcpy(nxtlev,fsys,sizeof(bool)* symnum);
                    gendo(lod,lev-table[i].level,table[i].adr);
					expressiondo(nxtlev,ptx,lev); 
                    if(i!=0)
                    {
                        gendo(opr,0,2);     //执行加操作
                        gendo(sto,lev-table[i].level,table[i].adr);
                    }
                }
                else if(sym==minuseql) // -=运算 
                {
                    getsymdo;
                    memcpy(nxtlev,fsys,sizeof(bool)* symnum);
                    gendo(lod,lev-table[i].level,table[i].adr);
					expressiondo(nxtlev,ptx,lev); 
                    if(i!=0)
                    {
                        gendo(opr,0,3);     //执行减操作
                        gendo(sto,lev-table[i].level,table[i].adr);
                    }
                }
                else
                {
                    error(13);
                }

            }
        }
    }
    else if(sym==plusplus) // 前++运算 
    {
        getsymdo;
        if(sym==ident)
        {
            i=position(id,*ptx);
            if(i==0) error(11);
            else
            {
                if(table[i].kind!=variable) 
                {
                    error(12);
                    i=0;
                }
                else    //++后跟的是变量
                {
                    getsymdo;
                    gendo(lod,lev-table[i].level,table[i].adr);//找到变量地址，将其值入栈
                    gendo(lit,0,1);//将常数1取到栈顶
                    if(i!=0)
                    {
                        gendo(opr,0,2);     //执行加操作
                        gendo(sto,lev-table[i].level,table[i].adr);
                    }
                }

            }
        }
        else
        {
            error(19);
        }
    }
    else if(sym==minusminus) // 前--运算 
    {
        getsymdo;
        if(sym==ident)
        {
            i=position(id,*ptx);
            if(i==0) error(11);
            else
            {
                if(table[i].kind!=variable) 
                {
                    error(12);
                    i=0;
                }
                else  //--后跟的是变量
                {
                    getsymdo;
                    gendo(lod,lev-table[i].level,table[i].adr);//找到变量地址，将其值入栈
                    gendo(lit,0,1);//将常数1取到栈顶
                    if(i!=0)
                    {
                        gendo(opr,0,3);     //执行减操作
                        gendo(sto,lev-table[i].level,table[i].adr);
                    }
                }

            }
        }
        else
        {
            error(19);
        }
    }
    else if(sym==forsym)      //检测到for语句
    {
        getsymdo;
        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) error(13);             //赋值语句左部标识符后应是赋值号:=
                    else getsymdo;
                    memcpy(nxtlev,fsys,sizeof(bool)*symnum); 
                    nxtlev[tosym]=true;                     //后跟符to和downto
                    nxtlev[downtosym]=true;
                    expressiondo(nxtlev,ptx,lev);           //处理赋值语句右部的表达式E1
                    gendo(sto,lev-table[i].level,table[i].adr);     //保存初值
                    switch(sym)
                    {
                            case tosym:           //步长为的向上增加
                                getsymdo;
                                cx1=cx;       //保存循环开始点
                                //将循环判断变量取出放到栈顶
                                gendo(lod,lev-table[i].level,table[i].adr);                                        
                                memcpy(nxtlev,fsys,sizeof(bool)*symnum);    //处理表达式E2
                                nxtlev[dosym]=true;                         //后跟符do
                                expressiondo(nxtlev,ptx,lev);
                                /*判断循环变量条件，比如for i:=E1 to E2 do S中，判断i是否小于E2，如小于等于，继续循环，大于的话，跳出循环*/     
                                gendo(opr,0,13);             //生成比较指令，i是否小于等于E2的值
                                cx2=cx;                      //保存循环结束点
                                //生成条件跳转指令，跳出循环，跳出的地址未知
                                gendo(jpc,0,0);                     
                                if(sym==dosym)               //处理循环体S
                                {
                                    getsymdo;
                                    statement(fsys,ptx,lev);  //循环体处理
                                    //增加循环变量步长为1
                                    //将循环变量取出放在栈顶
                                    gendo(lod,lev-table[i].level,table[i].adr);                                       
                                    gendo(lit,0,1);                            //将步长取到栈顶
                                    gendo(opr,0,2);                            //循环变量加步长
                                    //将栈顶的值存入循环变量
                                    gendo(sto,lev-table[i].level,table[i].adr); 
                                    gendo(jmp,0,cx1);                 //无条件跳转到循环开始点
                                    /*回填循环结束点的地址，cx为else后语句执行完的位置，它正是前面未定的跳转地址*/
                                    code[cx2].a=cx;                     
                                 }
                                 else
                                 {
                                    error(29);    //for语句中少了do
                                 }
                                break;

                            case downtosym:            //步长为的向下减少
                                getsymdo;
                                cx1=cx;            //保存循环开始点
                                //将循环判断变量取出放到栈顶                         
                                gendo(lod,lev-table[i].level,table[i].adr);                                        
                                memcpy(nxtlev,fsys,sizeof(bool)*symnum);      //处理表达式E2
                                nxtlev[dosym]=true;                           //后跟符do
                                expressiondo(nxtlev,ptx,lev);
                                /*判断循环变量条件，比如for i:=E1 downto E2 do S中，判断i是否大于等于E2，如大于等于，继续循环， 小于的话，跳出循环*/
                                gendo(opr,0,11);   //生成比较指令，i是否大于等于E2的值
                                cx2=cx;            //保存循环结束点
                                //生成条件跳转指令，跳出循环，跳出的地址未知             
                                gendo(jpc,0,0);                 
                                if(sym==dosym)     //处理循环体S
                                {
                                    getsymdo;
                                    statement(fsys,ptx,lev);   //循环体处理
                                    //增加循环变量步长为
                                    //将循环变量取出放在栈顶
                                    gendo(lod,lev-table[i].level,table[i].adr);                                       
                                    gendo(lit,0,1);                 //将步长取到栈顶
                                    gendo(opr,0,3);                 //循环变量加步长
                                    //将栈顶的值存入循环变量
                                    gendo(sto,lev-table[i].level,table[i].adr);                                       
                                    gendo(jmp,0,cx1);     //无条件跳转到循环开始点
                                    /*回填循环结束点的地址，cx为else后语句执行完的位置，它正是前面未定的跳转地址*/
                                    code[cx2].a=cx;                     
                                }
                                else 
                                {
                                    error(29);//for语句中少了do
                                }
                                break;
                    }
                }
            }
        }
        else 
        {
            error(19);         //for语句后跟赋值语句，赋值语句左部是变量，缺少变量
        }
    }

    else
    {
        if(sym==readsym)
        {
            getsymdo;
            if(sym!=lparen)
            {
               error(34);
            }
            else
            {
                do{
                    getsymdo;
                    if(sym==ident)
                    {
                        i=position(id, *ptx);
                    }
                    else
                    {
                        i=0;
                    }
                    if(i==0)
                    {
                        error(35);
                    }
                  
                    else
                    {
                        gendo(opr,0,16);
                        gendo(sto,lev-table[i].level,table[i].adr); /* 储存到变量*/
                    }
                    getsymdo;
                }while (sym==comma);    /*一条read语句可读多个变量 */
            }
            if(sym!=rparen)
            {
                error(33);          /* 格式错误，应是右括号*/
                while(!inset(sym,fsys))/* 出错补救，直到收到上层函数的后跟符号*/
                {
                    getsymdo;
                }
            }
            else
            {
                getsymdo;
            }
        }
        else
        {
            if(sym==writesym)           /* 准备按照write语句处理，与read类似*/
            {
                getsymdo;
                if(sym==lparen)
                {
                    do{
                        getsymdo;
                        if(sym==ident)
                        {
                            i=position(id,*ptx);
                            if(i==0)
                            {
                                error(11);          /*过程未找到*/
                            }
                        }
                        memcpy(nxtlev,fsys,sizeof(bool)*symnum);
                        nxtlev[rparen]=true;
                        nxtlev[comma]=true;     /* write的后跟符号为）or，*/
                        expressiondo(nxtlev,ptx,lev);/* 调用表达式处理，此处与read不同，read为给变量赋值*/
                        else gendo(opr,0,14);/* 生成输出指令，输出栈顶的值*/
                    }while(sym==comma);
                    if(sym!=rparen)
                    {
                        error(33);/* write()应为完整表达式*/
                    }
                    else
                    {
                        getsymdo;
                    }
                }
                gendo(opr,0,15);        /* 输出换行*/
            }
            else
            {
                if(sym==callsym)        /* 准备按照call语句处理*/
                {
                    getsymdo;
                    if(sym!=ident)
                    {
                        error(14);           /*call后应为标识符*/
                    }
                    else
                    {
                        i=position(id,*ptx);
                        if(i==0)
                        {
                            error(11);          /*过程未找到*/
                        }
                        else
                        {
                            if(table[i].kind==procedur)
                            {
                                gendo(cal,lev-table[i].level,table[i].adr);  /*生成call指令*/
                            }
                            else
                            {
                                error(15);      /*call后标识符应为过程*/
                            }
                        }
                        getsymdo;
                    }
                }
                else
                {
                    if(sym==ifsym)     /*准备按照if语句处理*/
                    {
                        getsymdo;
                        memcpy(nxtlev,fsys,sizeof(bool)*symnum);
                        nxtlev[thensym]=true;
                        nxtlev[dosym]=true;    /*后跟符号为then或do*/
                        conditiondo(nxtlev,ptx,lev);   /*调用条件处理（逻辑运算）函数*/
                        if(sym==thensym)
                        {
                            getsymdo;
                        }
                        else
                        {error(16);}          /*缺少then*/
                        cx1=cx;                /*保存当前指令地址*/
                        gendo(jpc,0,0);        /*生成条件跳转指令，跳转地址暂写0*/
                        statementdo(fsys,ptx,lev);   /*处理then后的语句*/
                        if(sym==elsesym)/*than语句后面发现else*/
                        {
                            getsymdo;
                            cx2=cx;
                            code[cx1].a=cx+1;/*cx为当前的指令地址，cx+1即为then语句执行后的else语句的位置，回填地址*/
                            gendo(jmp,0,0);
                            statementdo(fsys,ptx,lev);
                            code[cx2].a=cx;     /*经statement处理后，cx为else后语句执行完的位置，它正是前面未定的跳转地址，回填地址*/
                        }
                        else 
                        {code[cx1].a=cx;}      /*经statement处理后，cx为then后语句执行完的位置，它正是前面未定的跳转地址*/  
                    }
                    else
                    {
                        if(sym==beginsym)   /*准备按照复合语句处理*/
                        {
                            getsymdo;
                            memcpy(nxtlev,fsys,sizeof(bool)*symnum);
                            nxtlev[semicolon]=true;
                            nxtlev[endsym]=true;/*后跟符号为分号或end*/
                            /*循环调用语句处理函数，直到下一个符号不是语句开始符号或收到end*/
                            statementdo(nxtlev,ptx,lev);
                            while(inset(sym,statbegsys)||sym==semicolon)
                            {
                                if(sym==semicolon)
                                {
                                    getsymdo;
                                }
                                else
                                {
                                    error(10);/*缺少分号*/
                                }
                                statementdo(nxtlev,ptx,lev);
                            }
                            if(sym==endsym)
                            {
                                getsymdo;
                            }
                            else
                            {
                                error(17); /*缺少end或分号*/
                            }
                        }
                        else
                        {
                            if(sym==whilesym)/*准备按照while语句处理*/
                            {
                                cx1=cx;        /*保存判断条件超作的位置*/
                                getsymdo;
                                memcpy(nxtlev,fsys,sizeof(bool)*symnum);
                                nxtlev[dosym]=true;/*后跟符号为do*/
                                conditiondo(nxtlev,ptx,lev);  /*调用条件处理*/
                                cx2=cx;       /*保存循环体的结束的下一个位置*/
                                gendo(jpc,0,0);/*生成条件跳转，但跳出循环的地址未知*/
                                if(sym==dosym)
                                {
                                    getsymdo;
                                }
                                else
                                {
                                    error(18);      /*缺少do*/
                                }
                                statementdo(fsys,ptx,lev); /*循环体*/
                                gendo(jmp,0,cx1);/*回头重新判断条件*/
                                code[cx2].a=cx;   /*反填跳出循环的地址，与if类似*/
                            }
                            else
                            {
                                memset(nxtlev,0,sizeof(bool)*symnum);/*语句结束无补救集合*/
                                testdo(fsys,nxtlev,19);/*检测语句结束的正确性*/
                            }
                        }
                    }
                }
            }
        }
    }
    return 0;
}
/*
*表达式处理
*/
int expression(bool*fsys,int*ptx,int lev)
{
    enum symbol addop;                    /*用于保存正负号*/
    bool nxtlev[symnum];
    if(sym==plus||sym==minus)             /*开头的正负号，此时当前表达式被看作一个正的或负的项*/
    {
        addop=sym;                    /*保存开头的正负号*/
        getsymdo;
        memcpy(nxtlev,fsys,sizeof(bool)*symnum);
        nxtlev[plus]=true;
        nxtlev[minus]=true;
        termdo(nxtlev,ptx,lev);                /*处理项*/
        if(addop==minus)
        {
            gendo(opr,0,1);                   /*如果开头为负号生成取负指令*/
        }
    }
    else                             /*此时表达式被看作项的加减*/
    {
        memcpy(nxtlev,fsys,sizeof(bool)*symnum);
        nxtlev[plus]=true;
        nxtlev[minus]=true;
        termdo(nxtlev,ptx,lev);            /*处理项*/
    }
    while(sym==plus||sym==minus)
    {
        addop=sym;
        getsymdo;
        memcpy(nxtlev,fsys,sizeof(bool)*symnum);
        nxtlev[plus]=true;
        nxtlev[minus]=true;
        termdo(nxtlev,ptx,lev);              /*处理项*/
        if(addop==plus)
        {
            gendo(opr,0,2);                    /*生成加法指令*/
        }
        else
        {
             gendo(opr,0,3);                /*生成减法指令*/
        }
    }
    return 0;
}
/*
*项处理
*/
int term(bool*fsys,int *ptx,int lev)
{
    enum symbol mulop;               /*用于保存乘除法符号*/
    bool nxtlev[symnum];
    memcpy(nxtlev,fsys,sizeof(bool)*symnum) ;
    nxtlev[times]=true;
    nxtlev[slash]=true;
    factordo(nxtlev,ptx,lev);       /*处理因子*/
    while(sym==times||sym==slash)
    {
        mulop=sym;
        getsymdo;
        factordo(nxtlev,ptx,lev);
        if(mulop==times)
        {
            gendo(opr,0,4);          /*生成乘法指令*/
        }
        else
        {
            gendo(opr,0,5);           /*生成除法指令*/
        }
    }
     return 0;
}
/*
*因子处理
*/
int factor(bool*fsys,int *ptx,int lev)
 {
    int i;
    bool nxtlev[symnum];
    testdo(facbegsys,fsys,24);           /*检测因子的开始符好号*/
    while(inset(sym,facbegsys))          /*循环直到不是因子开始符号*/
    {
        if(sym==ident)                   /*因子为常量或者变量*/
        {
            i=position(id,*ptx);        /*查找名字*/
            if(i==0)
            {
                error(11);               /*标识符未声明*/
            }
            else
            {
                switch(table[i].kind)
                {
                    case constant:                                      /*名字为常量*/
                        gendo(lit,0,table[i].val);                       /*直接把常量的值入栈*/
                        break;
                    case variable:                                      /*名字为变量*/
                        gendo(lod,lev-table[i].level,table[i].adr);      /*找到变量地址并将其值入栈*/
                        break;
                    case procedur:                                      /*名字为过程*/
                        error(21);                                       /*不能为过程*/
                        break;
                   
                }
            }
            getsymdo;
        }
        else
        {
            if(sym==number)                                             /*因子为数*/
            {
                if(num>amax)
                {
                    error(31);
                    num=0;
                }
                gendo(lit,0,num);
                getsymdo;
            }
            else
            {
                if(sym==lparen)                                           /*因子为表达式*/
                {
                    getsymdo;
                    memcpy(nxtlev,fsys,sizeof(bool)*symnum);
                    nxtlev[rparen]=true;
                    expressiondo(nxtlev,ptx,lev);
                    if(sym==rparen)
                    {
                        getsymdo;
                    }
                    else
                    {
                        error(22);                                       /*缺少右括号*/
                    }
                }
                testdo(fsys,facbegsys,23);                        /*银子后有非法符号*/
            }
        }
    }
    return 0;
}
/*条件处理*/
int condition(bool* fsys,int* ptx,int lev)
{
    enum symbol relop;
    bool nxtlev[symnum];
    if(sym==oddsym)                        /*准备按照odd运算处理*/
    {
        getsymdo;
        expressiondo(fsys,ptx,lev);
        gendo(opr,0,6);                              /*生成odd指令*/
    }
    else
    {
        memcpy(nxtlev,fsys,sizeof(bool)*symnum);
        nxtlev[eql]=true;
        nxtlev[neq]=true;
        nxtlev[lss]=true;
        nxtlev[leq]=true;
        nxtlev[gtr]=true;
        nxtlev[geq]=true;
        expressiondo(nxtlev,ptx,lev);
        if(sym!=eql&&sym!=neq&&sym!=lss&&sym!=leq&&sym!=gtr&&sym!=geq)
        {
            error(20);
        }
        else
        {
            relop=sym;
            getsymdo;
            expressiondo(fsys,ptx,lev);
            switch(relop)
            {
                case eql:
                    gendo(opr,0,8);
                    break;
                case neq:
                    gendo(opr,0,9);
                    break;
                case lss:
                    gendo(opr,0,10);
                    break;
                case geq:
                    gendo(opr,0,11);
                    break;
                case gtr:
                    gendo(opr,0,12);
                    break;
                case leq:
                    gendo(opr,0,13);
                    break;
            }

        }
    }
    return 0;
}                                                  /*解释程序*/

void interpret()
{
    int p,b,t;             /*指令指针，指令基址，栈顶指针*/
    struct instruction i;  /*存放当前指令*/
    int s[stacksize];      /*栈*/
    //double s[stacksize];  //改成doubule型栈
    printf("start pl0\n");
    t=0;
    b=0;
    p=0;
    s[0]=s[1]=s[2]=0;
    do{
        i=code[p];         /*读当前指令*/
        p++;
        switch(i.f)
        {
            case lit:        /*将a的值取到栈顶*/
                s[t]=i.a;
                t++;
                break;
            case opr:        /*数字、逻辑运算*/
                switch(i.a)
                {
                    case 0:
                        t=b;
                        p=s[t+2];
                        b=s[t+1];
                        break;
                    case 1:
                        s[t-1]=-s[t-1];
                        break;
                    case 2:
                        t--;
                        s[t-1]=s[t-1]+s[t];
                        break;
                    case 3:
                        t--;
                        s[t-1]=s[t-1]-s[t];
                        break;
                    case 4:
                        t--;
                        s[t-1]=s[t-1]*s[t];
                        break;
                    case 5:
                        t--;
                        s[t-1]=s[t-1]/s[t];
                        break;
                    case 6:
                        s[t-1]=s[t-1]%2;
                        break;
                    case 8:
                        t--;
                        s[t-1]=(s[t-1]==s[t]);
                        break;
                    case 9:
                        t--;
                        s[t-1]=(s[t-1]!=s[t]);
                        break;
                    case 10:
                        t--;
                        s[t-1]=(s[t-1]<s[t]);
                        break;
                    case 11:
                        t--;
                        s[t-1]=(s[t-1]>=s[t]);
                        break;
                    case 12:
                        t--;
                        s[t-1]=(s[t-1]>s[t]);
                        break;
                    case 13:
                        t--;
                        s[t-1]=(s[t-1]<=s[t]);
                        break;
                    case 14://14号操作为输出栈顶值操作
                        printf("%d",s[t-1]);//未修改成实型字符型型前
                        fprintf(fa2,"%d",s[t-1]);
                        t--;//栈顶下移
                        break;
                    case 15://15号操作为输出换行操作
                        printf("\n");
                        fprintf(fa2,"\n");
                        break;
                    case 16:
                        printf("?");
                        fprintf(fa2,"?");
                        scanf("%d",&(s[t]));
                        fprintf(fa2,"%d\n",s[t]);
                        t++;
                        break;

                    case 17://17号操作为输出栈顶值操作
                        printf("输出字符:");
                        printf("%c\n",s[t-1]);//输出栈顶值
                        fprintf(fa2,"%c\n",s[t-1]);//同时打印到文件
                        t--;//栈顶下移
                        break;

                }
                break;
            case lod:       /*取相对当前过程的数据基地址为ａ的内存的值到栈顶*/
                s[t]=s[base(i.l,s,b)+i.a];
                t++;
                break;
            case sto:       /*栈顶的值存到相对当前过程的数据基地址为ａ的内存*/
                t--;
                s[base(i.l,s,b)+i.a]=s[t];
                break;
            case cal:              /*调用子程序*/
                s[t]=base(i.l,s,b); /*将父过程基地址入栈*/
                s[t+1]=b;           /*将本过程基地址入栈，此两项用于base函数*/
                s[t+2]=p;           /*将当前指令指针入栈*/
                b=t;                /*改变基地址指针值为新过程的基地址*/
                p=i.a;              /*跳转*/
                break;
            case inte:             /*分配内存*/
                t+=i.a;
                break;
            case jmp:             /*直接跳转*/
                p=i.a;
                break;
            case jpc:              /*条件跳转*/
                t--;
                if(s[t]==0)
                {
                    p=i.a;
                }
                break;
        }
    }while (p!=0);
}
/*通过过程基址求上1层过程的基址*/
int base(int l,int * s,int b)
{
    int b1;
    b1=b;
     while(l>0)
     {
         b1=s[b1];
         l--;
     }
     return b1;
}

pl0.h

  /*PL/0 编译系统C版本头文件 pl0.h*/
typedef enum 
{
    false,
    true
} bool;

# define norw 18                 /*关键字个数*/ //关键字个数数由初始值13增加至18
# define txmax 100               /*名字表容量*/
# define nmax  14                /*number的最大位数*/
# define al 10                   /*符号的最大长度*/
# define amax 2047               /*地址上界*/
# define levmax 3                /*最大允许过程嵌套声明层数[0，lexmax]*/
# define cxmax 200               /*最多的虚拟机代码数*/

enum symbol{
     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, elsesym, forsym, tosym, 
	 downtosym, timeseql, slasheql, plusplus, minusminus,
	 pluseql,minuseql
};
#define symnum 43    //符号数初始值由32增加至42
/*-------------*/
enum object{
   constant,
   variable,
   procedur,

};

enum fct{
lit, opr,  lod,  sto,  cal,  inte,  jmp,  jpc,
};
#define fctnum 8

struct instruction
{
  enum fct f;
  int l;
  int a;

};

FILE* fas;  /* 输出名字表 */
FILE* fa;   /* 输出虚拟机代码 */
FILE* fa1;  /* 输出源文件及其各行对应的首地址 */
FILE* fa2;  /* 输出结果 */

bool tableswitch;
bool listswitch;
char ch;
enum symbol sym;
char id[al+1];
int  num;
int cc,ll;
int cx;
char line[81];
char a[al+1];
struct instruction code[cxmax];
char word[norw][al];
enum symbol wsym[norw];
enum symbol ssym[256];
char mnemonic[fctnum][5];
bool declbegsys[symnum];
bool statbegsys[symnum];
bool facbegsys[symnum];

struct tablestruct
{
   char name[al];                            /*名字*/
   enum object kind;                         /*类型：const，var，array or procedure*/
   int val;                                  /*数值，仅const使用*/
   int level;                                /*所处层，仅const不使用*/
   int adr;                                  /*地址，仅const不使用*/
   int size;                                 /*需要分配的数据区空间，仅procedure使用*/
};
struct tablestruct table[txmax];             /*名字表*/
FILE * fin;
FILE* fout;
char fname[al];
int err;                                       /*错误计数器*/
/*当函数中会发生fatal error时，返回－1告知调用它的函数，最终退出程序*/
#define getsymdo                              if(-1==getsym())return -1
#define getchdo                               if(-1==getch())return -1
#define testdo(a,b,c)                         if(-1==test(a,b,c))return -1
#define gendo(a,b,c)                          if(-1==gen(a,b,c))return -1
#define expressiondo(a,b,c)                   if(-1==expression(a,b,c))return -1
#define factordo(a,b,c)                       if(-1==factor(a,b,c))return -1
#define termdo(a,b,c)                         if(-1==term(a,b,c))return -1
#define conditiondo(a,b,c)                    if(-1==condition(a,b,c))return -1
#define statementdo(a,b,c)                    if(-1==statement(a,b,c))return -1
#define constdeclarationdo(a,b,c)             if(-1==constdeclaration(a,b,c))return -1
#define vardeclarationdo(a,b,c)               if(-1==vardeclaration(a,b,c))return -1

void error(int n);
int getsym();
int getch();
void init();
int gen(enum fct x,int y,int z);
int test(bool*s1,bool*s2,int n);
int inset(int e,bool*s);
int addset(bool*sr,bool*s1,bool*s2,int n);
int subset(bool*sr,bool*s1,bool*s2,int n);
int mulset(bool*sr,bool*s1,bool*s2,int n);
int block(int lev,int tx,bool* fsys);
void interpret();
int factor(bool* fsys,int* ptx,int lev);
int term(bool*fsys,int*ptx,int lev);
int condition(bool*fsys,int*ptx,int lev);
int expression(bool*fsys,int*ptx,int lev);
int statement(bool*fsys,int*ptx,int lev);
void listcode(int cx0);
int vardeclaration(int* ptx,int lev, int* pdx);
int constdeclaration(int* ptx,int lev, int* pdx);

int position(char* idt,int tx);
void enter(enum object k,int* ptx,int lev,int* pdx);
int base(int l,int* s,int b);

测试用例

else测试

1.pl0

var a,b,c;
begin
b:= 20;
c := 5;
read(a);
write(a);
if a < c
then
c := 2 * c
else
c := 2 * c + 1;
write©;
end.

for测试

2.pl0

var c,b, d, e;
procedure p;
begin
c:=c+1;
write( c );
end;

begin
read( c );
read(d);
read(e);
for b := d to e do
begin
call p;
end;
end.

*=、/=、注释

3.pl0

var b, c,d,e;
begin
read(b);
read( c );
read(d);
read(e);
c/=b; //zhushi
d*=e; /d=de*/
write( c );
write(d);
end.

++、–

4.pl0

var b, c,d,e;
begin
read(b);//1
read©;//2
read(d);//1
read(e);//2
b++;
c–;
++d;
–e;
write(b);//2
write©;//1
write(d);//2
write(e);//1
end.

+=、-=

5.pl0

var b, c,d,e;
begin
read(b);//1
read©;//2
read(d);//3
read(e);//2
b+=c;
d-=e;
write(b);//3
write(d);//1
end.

阿鱼的博客
关注
  • 2
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
编译原理课程设计-PL/0编译器的扩充（C语言完整版）
Cheung
03-21 3万+
课程设计要求： 1、基本内容（成绩范围：“中”、“及格”或“不及格”） （1）扩充赋值运算：*= 和 /= (2)扩充语句（Pascal的FOR语句）: ①FOR <变量>:=<表达式> TO <表达式> DO <语句> ②FOR <变量>:=<表达式> DOWNTO <表达式> DO <语句> 其中，语句①的循环变量的步长为1， 语句②的循环变量的步长为-1。2、选做内容（成
java pl0 四元式_PL0语言编译器的中间代码生成
weixin_34094559的博客
02-28 779
《PL0语言编译器的中间代码生成》由会员分享，可在线阅读，更多相关《PL0语言编译器的中间代码生成(14页珍藏版)》请在人人文库网上搜索。1、课程设计报告( 2016-2017年度第一学期)名 称： 编译技术课程设计 题 目： PL/0语言编译器的中间代码生成 院 系： 控制与计算机工程 班 级： 信安1401 学 号： 学生姓名： 黄竞昶 指导教师： 徐欢 设计周数： 一周 成 绩： 日期：20...
编译原理 实验1《词法分析程序设计与实现》
热门推荐
渣渣的夏天
08-04 3万+
实验1《词法分析程序设计与实现》 一、实验目的   加深对词法分析器的工作过程的理解；加强对词法分析方法的掌握；能够采用一种编程语言实现简单的词法分析程序；能够使用自己编写的分析程序对简单的程序段进行词法分析。 二、实验内容   自定义一种程序设计语言，或者选择已有的一种高级语言，编制它的词法分析程序。词法分析程序的实现可以采用任何一种编程语言和编程工具。   从输入的源程序中，识别出各个具有独立...
PL/SQL知识点总结
陆山右的技术博客
07-16 1281
1.7您应该掌握的内容 PL/SQL语言是一种什么样的程序设计语言？ PL/SQL提供了现代软件工程的哪些主要特点？ 在基于Oracle的软件开发项目中，为什么首选的编程语言是PL/SQL？ 除了包括过程语言之外，PL/SQL程序还可以包括什么语句？ PL/SQL引擎是是怎样编译和执行PL/SQL程序的？ 为什么 使用PL/SQL可以改进系统的整体性能并减少网络的流量？ 了解在PL/SQL中模块...
编译原理实验（三）词法语法分析综合设计
Java/Golang
03-11 2万+
版权声明：本文为原创文章，版权归 Geekerstar 所有。 本文链接：http://www.geekerstar.com/technology/105.html 除了有特殊标注文章外欢迎转载，但请务必标明出处，格式如上，谢谢合作。 1 概述 通过某种高级语言（如C/C++，Java）实现词法，语法分析器的功能。 2 实验目标 理解并掌握词法，语法分析的...
java pl0 四元式,PL0语言编译器的中间代码生成
weixin_39629947的博客
03-13 246
PL0语言编译器的中间代码生成 课程设计报告 ( 2016--2017年度第一学期) 名 称： 编译技术课程设计 题 目： PL/0语言编译器的中间代码生成 院 系： 控制与计算机工程 班 级： 信安1401 学 号： 学生姓名： 黄竞昶 指导教师： 徐欢 设计周数： 一周 成 绩： 日期：2016年 12 月29日 1 课程设计的目的和要求 1.1 课程设计的目的 本次设计的时间为1周，目的是通...
编译原理学习——引论篇
wenn的博客
03-15 1281
语言的基础是一组符号和一组规则，根据规则由符号构成的符号串的总体就是语言；程序设计语言就是编写计算机程序的语言。但是，在一个程序可以运行之前，它需要被翻译成一种能够被计算机执行的形式。因此，引论篇从高级程序设计语言出发，介绍编译与解释两种翻译方式；然后概述一个编译过程具有的典型逻辑阶段介绍一个典型编译程序的结构；最后简单介绍与编译程序有关的概念，包括前端与后端、趟、自编译、自展以及移植。编译有两种方式：一种是编译方式，一种是解释方式。
编译原理期末复习自用
qq_62271524的博客
10-21 293
区别在于是否生成目标程序编译是将高级语言程序翻译为汇编语言程序或二进制语言程序(目标程序)，然后由目标程序在计算机上运行得到结果 只翻译不执行 最后得到的是目标程序解释是接受某个语言的程序进行解释，每解释一句计算机执行一句 边翻译边执行 最后得到的是程序的运行结果编译程序产生目标程序的执行速度比解释程序的执行速度要快。
北航计算机学院编译原理,GitHub - BUAA-SE-Compiling/mainpage: 北航软件学院编译原理实验首页...
weixin_35695434的博客
07-02 1043
北航软件学院编译原理实验前言我们写代码从第一天起就和编译器打交道，而编译原理就是一门探究编译器背后奥秘的课程。编译原理这门课程不仅理论性很强，同时也需要大量的实际编码才能理解学习到的知识和实践之间的关联，因此编译实验是课程非常重要的一部分。以往的实验内容是一脉传承——第一次词法分析，第二次 OPG，第三次语法分析，第四次最终检查，基础是做 PL0，选做 C0，以及有 GUI 等加分项。我们两位助教...
PL/0编译程序的研究与改进（编译原理三级项目）
11-27
《PL/0编译程序的研究与改进》 PL/0是一种简化版的编程语言，用于教学和理解编译原理。本项目的重点在于深入研究PL/0编译程序的设计与实现，以及对其进行功能扩充，以便更好地理解和掌握编译器的相关技术。 1. PL/...
C语言PL/0编译程序的研究与改进（编译原理三级项目）
11-27
扩充功能，以语法分析部分为例，可以增加处理更多语法成分的功能，如可处理一维数组、++、--、+=、-=、*=、/=、%（取余）、！（取反）、repeat、for、else、开方、处理注释、错误提示、标示符或变量中可以有下划线等...
编译原理三级项目pl0扩展
04-05
《编译原理三级项目PL0扩展》 PL0语言是一种简化的编程语言，常用于编译原理的教学与学习。在此次三级项目中，PL0语言得到了一系列的扩展，增加了更丰富的编程元素，使得它能够更好地支持实际编程需求。以下是对...
PL/0编译程序的研究与改进
10-16
本文档为YSU《编译原理》课程三级项目的总结报告，内容为pl0编译程序的研究与改进，内容详细，含源码和截图，共29页。
编译原理课程设计报告，PL/0的研究与功能扩展
11-11
在编译原理课程设计报告中，小组成员对PL/0语言进行了深入研究并实现了多项功能扩展，这涉及到了编译器的基本组成部分和工作原理。PL/0是一种简化版的编程语言，通常用于教学和理解编译器的工作机制。在此次改进中，...
图形编辑器基于Paper.js教程10：导入导出svg，导入导出json数据
知无涯
07-25 6826
如svg的g标签转换为group，rect标签转换为shape，一些符合元素转换为CompoundPath对象，内部其实是Path对象组成的。将提供的SVG内容转换为Paper.js项目中的图形项，并将其添加到此项目的活动层中。请注意，首先不会清除项目。最外层是一个group，然后会有很多子元素，一些svg的元素会被转换为paperjs画布中的元素。导出svg，你可以将一个元素导出成svg，也可以将一整个项目导出成svg。在这里，我们将导出的JSON对象保存到了本地存储中，便于后续的导入操作。
C语言系统调用linux文件系统
C or CPP
07-25 927
在C语言中，openwrite和read函数是系统调用（system calls），它们直接由操作系统提供，用于底层的文件操作。这些函数是UNIX和类UNIX系统（如Linux）中的标准接口，不同于C标准库中的文件操作函数（如fopenfwrite和fread。
基于NSGA-II的智能车辆换道轨迹规划与优化_查云飞.caj
最新发布
07-31
基于NSGA-II的智能车辆换道轨迹规划与优化_查云飞
chromedriver-mac-x64_122.0.6261.111.zip
07-31
chromedriver-mac-x64_122.0.6261.111.zip
编译原理实践：PL/0语言编译器详解与源码分析
"该资源是一份关于编译原理的学习资料，包含了PL/0语言的文档和源码，适合学习编译原理的学生。文档详细介绍了PL/0语言的语法和编译器的各个阶段，包括词法分析、语法分析、语义分析、代码生成、错误处理和符号表...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值