compile.cpp

编译原理课程设计大作业PL0文法简易编译器

}

/*标准函数*/
void standfct(int n)
{
	int x, l;
	switch(n)
	{
	case fabs:
		skip(lparen);
		expression(&x);
		mustbe(intip, x);
		gen0(dupl);
		gen1(ldc, 0);
		gen0(lssi);
		l = codelabel();
		gen1(jumpz, 0);
		gen0(neg);
		code[l].a = codelabel();
		skip(rparen);
		break;
	case fsqr:
		skip(lparen);
		expression(&x);
		mustbe(intip, x);
		gen0(dupl);
		gen0(mul);
		skip(rparen);
		break;
	case fodd:
		skip(lparen);
		expression(&x);
		mustbe(intip, x);
		gen0(rem2);
		skip(rparen);
		break;
	case fchr:
		skip(lparen);
		expression(&x);
		mustbe(intip, x);
		skip(rparen);
		break;
	case ford:
		skip(lparen);
		expression(&x);
		mustbe(chartip, x);
		skip(rparen);
		break;
	case fwrite:
	case fwriteln:
		if(n == fwrite)
			check(lparen);
		if(sym == lparen)
		{
			do{
				getsym();
				if(sym == sstring)
				{
					for(x = 0; x < slen; x++)
					{
						gen1(ldc, str[x]);
						gen0(wrc);
					}
					getsym();
				}
				else
				{
					expression(&x);
					if(sym == colon)
					{
						mustbe(intip, x);
						getsym();
						expression(&x);
						mustbe(intip, x);
						gen0(wri);
					}
					else if(x == intip)
					{
						gen1(ldc, 8);
						gen0(wri);
					}
					else if(x == chartip)
					{
						gen0(wrc);
					}
					else
						error(111);
				}
			}while(sym == comma);
			skip(rparen);
		}
		if(n == fwriteln)
			gen0(wrl);
		break;
	case fread:
	case freadln:
		if(n == fread)
			check(lparen);
		if(sym == lparen)
		{
			do{
				getsym();
				varpar(&x);
				if(x == intip)
					gen0(rdi);
				else if(x == chartip)
					gen0(rdc);
				else
					error(112);
			}while(sym == comma);
			skip(rparen);
		}
		if(n == freadln)
			gen0(rdl);
		break;
	case feoln:
		gen0(eol);
		break;
 }
}

/*函数，过程调用*/
void funcall(int i)
{
	int d, p, x;
	getsym();
	if(itab[i].flevel < 0)
		standfct(itab[i].fadr);
	else
	{
		if(itab[i].tip != 0)
			gen1(ldc, 0);
		p = i;
		d = dx;
		if(sym == lparen)
		{
			do{
				getsym();
				if(p == itab[i].lastpar)
					error(113);
				else
				{
					p = p + 1;
					if(itab[p].refpar == TRUE)
						varpar(&x);
					else
					{
						expression(&x);
						if(ttab[x].kind != simple)
							gen1(copy, ttab[x].size);
					}
				}
				mustbe(itab[p].tip, x);
			}while(sym == comma);
			skip(rparen);
		}
		if(p != itab[i].lastpar)
			error(114);
		if(itab[i].flevel != 0)
			address(itab[i].flevel, 0);
		gen1(call, itab[i].fadr);
		dx = d;
	}
}

/*因子*/
void factor(int * t)
{
	int i;
	if(sym == ident)
	{
		i = position();
		*t = itab[i].tip;
		switch(itab[i].kind)
		{
		case konst:
			getsym();
			gen1(ldc, itab[i].val);
			break;
		case varbl:
			selector(t, &i);
			if(i != 0)
				addressvar(i);
			if(ttab[i].kind == simple)
				gen0(load);
			break;
		case funkt:
			if(*t == 0)
				error(115);
			else
				funcall(i);
			break;
		case tipe:
			error(116); /*类型名不能作为因子*/
			break;
		}
	}
	else if(sym == number)
	{
		gen1(ldc, num);
		*t = intip;
		getsym();
	}
	else if(sym == sstring && slen == 2)
	{
		gen1(ldc, str[0]);
		*t = chartip;
		getsym();
	}
	else if(sym == lparen)
	{
		getsym();
		expression(t);
		skip(rparen);
	}
	else if(sym == notsym)
	{
		getsym();
		factor(t);
		mustbe(booltip, *t);
		gen0(neg);
		gen1(addc, 1);
	}
	else
		error(117);
}

/*表达式的项*/
void term(int * x)
{
	int y;
	factor(x);
	while(sym == andsym || sym == star || sym == divsym || sym == modsym)
	{
		if(sym == andsym)
			mustbe(booltip, *x);
		else
			mustbe(intip, *x);
		switch(sym)
		{
		case star:
			getsym();
			factor(&y);
			gen0(mul);
			break;
		case divsym:
			getsym();
			factor(&y);
			gen0(divd);
			break;
		case modsym:
			getsym();
			factor(&y);
			gen0(remd);
			break;
		case andsym:
			getsym();
			factor(&y);
			gen0(andb);
			break;
		}
		mustbe(*x, y);
	}
}

/*简单表达式*/
void simpleexpression(int * x)
{
	int y;
	if(sym == plus)
	{
		getsym();
		term(x);
		mustbe(intip, *x);
	}
	else if(sym == minus)
	{
		getsym();
		term(x);
		mustbe(intip, *x);
		gen0(neg);
	}
	else
		term(x);
	while(sym == orsym || sym == plus || sym == minus)
	{
		if(sym == orsym)
			mustbe(booltip, *x);
		else
			mustbe(intip, *x);
		switch(sym)
		{
		case plus:
			getsym();
			term(&y);
			gen0(add);
			break;
		case minus:
			getsym();
			term(&y);
			gen0(neg);
			gen0(add);
			break;
		case orsym:
			getsym();
			term(&y);
			gen0(orb);
			break;
		}
		mustbe(*x, y);
	}
}

/*表达式*/
void expression(int * x)
{
	symbol op;
	int y;
	simpleexpression(x);
	if(sym == eql ||sym == neq || sym == lss || sym == leq || sym == gtr ||sym == geq)
	{
		if(ttab[*x].kind != simple)
			error(118);
		else
		{
			op = sym;
			getsym();
			simpleexpression(&y);
			mustbe(*x, y);
			switch(op)
			{
			case eql:
				gen0(eqli);
				break;
			case neq:
				gen0(neqi);
				break;
			case lss:
				gen0(lssi);
				break;
			case leq:
				gen0(leqi);
				break;
			case gtr:
				gen0(gtri);
				break;
			case geq:
				gen0(geqi);
				break;
			}
			*x = booltip;
		}
	}
}

/*语句*/
void statement()
{
	int i, j, t, x;
	if(sym == ident)
	{
		i = position();
		switch(itab[i].kind)
		{
		case varbl:
			selector(&t, &i);
			skip(becomes);
			expression(&x);
			mustbe(t, x);
			if(i == 0)
				gen0(swap);
			else
				addressvar(i);
			if(ttab[i].kind == simple)
				gen0(stor);
			else
				gen1(move, ttab[i].size);
			break;
		case funkt:
			if(itab[i].tip == 0)
				funcall(i);
			else
			{
				if(itab[i].inside == FALSE)
					error(119);/*此处不能对函数赋值*/
				else
				{
					getsym();
					skip(becomes);
					expression(&x);
					mustbe(itab[i].tip, x);
					address(itab[i].flevel + 1, itab[i].resultadr);
					gen0(stor);
				}
			}
			break;
		case konst:
		case field:
		case tipe:
			error(120); /*变量不能用在此处*/
			break;
		}
	}
	else if(sym == ifsym)
	{
		getsym();
		expression(&t);
		mustbe(booltip, t);
		skip(thensym);
		i = codelabel();
		gen1(jumpz, 0);
		statement();
		if(sym == elsesym)
		{
			getsym();
			j = codelabel();
			gen1(jump, 0);
			code[i].a = codelabel();
			i = j;
			statement();
		}
		code[i].a = codelabel();
	}
	else if(sym == forsym)
	{
		int sign, pos;
		getsym();
		pos = position();
		selector(&t, &pos);
		skip(becomes);
		simpleexpression(&x);
		mustbe(t, x);
		if(pos == 0)
			gen0(swap);
		else
			addressvar(pos);
		if(ttab[pos].kind == simple)
			gen0(stor);
		else
			gen1(move, ttab[pos].size);

		if(sym == downtosym){
			skip(downtosym);
            sign = 1;
		}
		else if(sym == tosym){
			skip(tosym);
			sign = -1;
		}
		else check(tosym);
		
		i = codelabel();
		t = itab[pos].tip;
		if(pos != 0)
			addressvar(pos);
		if(ttab[pos].kind == simple)
			gen0(load);

		simpleexpression(&x);
		mustbe(intip, x);
		skip(dosym);

		if(sign == 1)
			gen0(geqi);
		else 
			gen0(leqi);
		
		j = codelabel();
		gen1(jumpz, 0);
		statement();

		if(pos != 0)
			addressvar(pos);
		if(ttab[pos].kind == simple)
			gen0(load);
		if (sign == -1)
			gen0(inc);
		else 
			gen0(dec);
		if(pos == 0)
			gen0(swap);
		else
			addressvar(pos);
		if(ttab[pos].kind == simple)
			gen0(stor);
		else
			gen1(move, ttab[pos].size);

		gen1(jump, i);
		code[j].a = codelabel();
	}
	else if(sym == whilesym)
	{ 
		getsym();
		i = codelabel();
		expression(&t);
		mustbe(booltip, t);
		skip(dosym);
		j = codelabel();
		gen1(jumpz, 0);
		statement();
		gen1(jump, i);
		/*这里表写错了*/
		code[j].a = codelabel();
	}
	else if(sym == repeatsym)
	{
		i = codelabel();
		do{
			getsym();
			statement();
		}while(sym == semicolon);
		skip(untilsym);
		expression(&t);
		mustbe(booltip, t);
		gen1(jumpz, i);
	}
	else if(sym == beginsym)
	{
		do{
			getsym();
			statement();
		}while(sym == semicolon);
		skip(endsym);
	}
}

void block(int l);

/*常量*/
void constant(int * c, int * t)
{
	int i, s;
	if(sym == sstring && slen == 2)
	{
		*c = str[0];
		*t = chartip;
	}
	else
	{
		if(sym == plus)
		{
			getsym();
			s = +1;
		}
		else if(sym == minus)
		{
			getsym();
			s = -1;
		}
		else
			s = 0;
		if(sym == ident)
		{
			i = position();
			if(itab[i].kind != konst)
				error(121);
			else
			{
				*c = itab[i].val;
				*t = itab[i].tip;
			}
		}
		else if(sym == number)
		{
			*c = num;
			*t = intip;
		}
		else
			error(122);
		if(s != 0)
		{
			mustbe(*t, intip);
			(*c) = (*c) * (s);
		}
	}
	getsym();
}

/*常量声明*/
void constdeclaration()
{
	alfa a;
	int t, c;
	strcpy(a, id);
	getsym();
	skip(eql);
	constant(&c, &t);
	skip(semicolon);
	enter(a, konst, t);
	itab[ix].val = c;
}

void typ(int * t);

/*数组类型*/
void arraytyp(int * t)
{
	int x;
	ttab[*t].kind = arrays;
	getsym();
	constant(&(ttab[*t].low), &x);
	mustbe(intip, x);
	skip(colon);
	constant(&(ttab[*t].high), &x);
	mustbe(intip, x);
	if(ttab[*t].low > ttab[*t].high)
		error(123); /*数组边界问题*/
	if(sym == comma)
		arraytyp(&(ttab[*t].elemtip));
	else
	{
		skip(rbrack);
		skip(ofsym);
		typ(&(ttab[*t].elemtip));
	}
	ttab[*t].size = (ttab[*t].high - ttab[*t].low + 1) * ttab[ttab[*t].elemtip].size;
}

/*类型定义*/
void typ(int * t)
{
	int i, j, sz, ft;
	if(sym == ident)
	{
		i = position();
		if(itab[i].kind != tipe)
			error(124); /*这个标识符不是类型能够*/
		else
		{
			*t = itab[i].tip;
			getsym();
		}
	}
	else
	{
		if(tx == tmax)
		{
			error(125); /*溢出，应退出*/
		}
		else
		{
			tx = tx + 1;
			*t = tx;
		}
		if(sym == arraysym)
		{
			getsym();
			check(lbrack);
			arraytyp(t);
		}
		else
		{
			skip(recordsym);
			if(lev == lmax)
			{
				error(126); /*深度超过限度，应退出*/
			}
			else
			{
				lev = lev + 1;
				if(lev == -1)
					nl = 0;
				else
					namelist[lev] = 0;
				check(ident);
				sz = 0;
				do{
					enter(id, field, 0);
					i = ix;
					getsym();
					while(sym == comma)
					{
						getsym();
						check(ident);
						enter(id, field, 0);
						getsym();
					}
					j = ix;
					skip(colon);
					typ(&ft);
					do{
						itab[i].tip = ft;
						itab[i].offset = sz;
						sz = sz + ttab[ft].size;
						i = i + 1;
					}while(i <= j);
					if(sym == semicolon)
						getsym();
					else
						check(endsym);
				}while(sym == ident);
				ttab[*t].size = sz;
				ttab[*t].kind = records;
				if(lev == -1)
					ttab[*t].fields = nl;