pl0.c

C语言编写的PLO源代码

* （该部分的后跟符号），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;
}

/*
*   出错处理，打印出错位置和错误编码
*/
void error(int n)
{
    char space[81];
    memset(space,32,81); //ASC码32为空格

    space[cc-1]=0; //出错时当前符号已经读完，所以cc-1

    printf("****%s!%d\n", space, n);
    fprintf(fa1,"****%s!%d\n", space, n);

    err++;
}

/*
* 生成虚拟机代码
*
* 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;
}

/*
* 输出目标代码清单
*/
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);
    	}
    }
}

/* 通过过程基址求上l层过程的基址 */
int base(int l, int* s, int b)
{
    int b1;
    b1 = b;
    while (l > 0)
    {
        b1 = s[b1];
        l--;
    }
    return b1;
}

/*
* 解释程序
*/
void interpret()
{
    int p, b, t;    /* 指令指针，指令基址，栈顶指针 */
    struct instruction i;   /* 存放当前指令 */
    int s[stacksize];   /* 栈 */

    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:
                printf("%d", s[t-1]);
                fprintf(fa2, "%d", s[t-1]);
        		t--;
            	break;
            case 15:
                printf("\n");
                fprintf(fa2,"\n");
            	break;
            case 16:
                printf("?");
                fprintf(fa2, "?");
                scanf("%d", &(s[t]));
                fprintf(fa2, "%d\n", s[t]);
        		t++;
            	break;
    		}
            break;
        case lod:   /* 取相对当前过程的数据基地址为a的内存的值到栈顶 */
            s[t] = s[base(i.l,s,b)+i.a];
        	t++;
            break;
        case sto:   /* 栈顶的值存到相对当前过程的数据基地址为a的内存 */
        	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);
}


/*
* 编译程序主程序
*
* 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;

            constdeclarationdo(&tx, lev, &dx);  
							/* dx的值会被constdeclaration改变，使用指针 */
            while (sym == comma)      //comma为逗号
    		{
                getsymdo;
                constdeclarationdo(&tx, lev, &dx);
    		}
            if (sym == semicolon)     //semicolon为分号
    		{
                getsymdo;
    		}
        	else
    		{
                error(5);   /*漏掉了逗号或者分号*/
    		}           
    	}

        if (sym == varsym)      /* 收到变量声明符号，开始处理变量声明 */
    	{
            getsymdo;

            vardeclarationdo(&tx, lev, &dx);
            while (sym == comma)
    		{
                getsymdo;
                vardeclarationdo(&tx, lev, &dx);
    		}
            if (sym == semicolon)
    		{
                getsymdo;
    		}
        	else
    		{
                error(5);  /*漏掉了逗号或者分号*/
    		}
    	}

        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;
        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 addr=%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); /*分程序没有补救集合 */
    testdo(fsys, nxtlev, 8);                /* 检测后跟符号正确性 */
    listcode(cx0);                          /* 输出代码 */
    return 0;
}

/*
* 常量声明处理
*/
int constdeclaration(int* ptx, int lev, int* pdx)
{
    if (sym == ident)
    {
        getsymdo;
        if (sym==eql || sym==becomes)  //eql为等于，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);   /* var后应是标识 */
    }
    return 0;
}

/*
* 语句处理
*/
int statement(bool* fsys, int* ptx, int lev)
{