c2asm.cpp

将C语言转换成汇编语言

		int t_2=newlabel();
		
		expr i,e,s,i2,e2,ed,t1,t2,i4,e4;
		int r;

		s.index=start;
		s.datatype=25;
		s.whichtable=4;

		ed.index=end;
		ed.datatype=25;
		ed.whichtable=4;

		t1.index=t_1;
		t1.datatype=25;
		t1.whichtable=4;

		t2.index=t_2;
		t2.datatype=25;
		t2.whichtable=4;

		advanc();

		if(input.clas=="parenthesis_open")
			advanc();
		else reject();

		if(input.clas=="id")
		{
			long ind=chk_ident(long(input.index));
			if(ind==-10)
			{
			cout<<"\nFailed in <Statement>-->for(id=<expression>.......;";
			cout<<"\nVariable Not Found ";
			reject();
			}
			i.index=ind;
			i.whichtable=table;
			if(table==0)
			i.datatype=syn_identifier[ind].datatype;
			else if(table==1)
			i.datatype=args_identifier[ind].datatype;

			advanc();
		}
		else reject();

		if(input.clas=="assignop")
			advanc();
		else reject();
		
		expression(e);

		if(chk_types(i,e)==true)
			setatom(26,e,dump,i);
		else
		{
			cout<<"\nType of id!!!!!!!======<right_hand_side>";
			reject();
		}
								
		if(input.clas=="semicolon")
			advanc();
		else reject();

		setatom(25,dump,dump,s);

		if(input.clas=="id")
		{
			long ind=chk_ident(long(input.index));
			if(ind==-10)
			{
			cout<<"\nFailed in <Statement>-->for(id=<expression>.......;";
			cout<<"\nVariable Not Found ";
			reject();
			}
			i2.index=ind;
			i2.whichtable=table;
			if(table==0)
			i2.datatype=syn_identifier[ind].datatype;
			else if(table==1)
			i2.datatype=args_identifier[ind].datatype;
			advanc();
		}
		else reject();

		if(input.clas=="relop")
		{
			r=input.index;
			advanc();
		}
		else reject();
		
		expression(e2);

		if(chk_types(i2,e2)!=true)
		{
           		cout<<"\nType of id!!!!!!!======<right_hand_side>";
				reject();
		}

		setatom(r,i2,e2,ed);
		setatom(28,dump,dump,t1);
		
		if(input.clas=="semicolon")
			advanc();
		else reject();

		setatom(25,dump,dump,t2);

		if(input.clas=="id")
		{
			long ind=chk_ident(long(input.index));
			if(ind==-10)
			{
			cout<<"\nFailed in <Statement>-->for(id=<expression>.......;";
			cout<<"\nVariable Not Found ";
			reject();
			}
			i4.index=ind;
			i4.whichtable=table;
			if(table==0)
			i4.datatype=syn_identifier[ind].datatype;
			else if(table==1)
			i4.datatype=args_identifier[ind].datatype;
			advanc();
		}
		else reject();

		if(input.clas=="assignop")
			advanc();
		else reject();

		expression(e4);

		if(chk_types(i4,e4)==true)
			setatom(26,e4,dump,i4);
		else
		{
			cout<<"\nType of id!!!!!!!======<right_hand_side>";
			reject();
		}

		setatom(28,dump,dump,s);

		if(input.clas=="parenthesis_close")
			advanc();
		else reject();
		
		setatom(25,dump,dump,t1);

		statement();

		setatom(28,dump,dump,t2);
		
		setatom(25,dump,dump,ed);
	}
	else if(input.clas=="do")
	{
		int start=newlabel();
		expr temp;

		temp.datatype=25;
		temp.index=start;
		temp.whichtable=4;
		
		setatom(25,dump,dump,temp);

		advanc();

		compound_statement();

		if(input.clas=="while")
			advanc();
		else reject();

		if(input.clas=="parenthesis_open")
			advanc();
		else reject();

		expr k; expression(k);

		if(input.clas=="parenthesis_close")
			advanc();
		else reject();

		if(input.clas=="semicolon")
			advanc();
		else reject();

		expr temp1;
		temp1.datatype=1;
		temp1.index=-10;
		temp1.whichtable=-10;

		setatom(27,k,temp1,temp);
	}
	else if(input.clas=="return")
	{
		/*Since This Fucntion Shld've a RETURN statement in it's 
		body,Therefore Setting "isreturn=true",Since We Found a 
		RETURN Statement*/
		isreturn=true;

		advanc();
		expr r;
		right_hand_side(r);
		
		//t takes the index of Function Name which is binded to this 
		//particular return statement
		int t=args_identifier[args_identifier.size()-1].binding;
		
		expr temp;
		temp.datatype=syn_identifier[t].datatype;
		temp.index=t;		
		temp.whichtable=0;

		if(chk_types(temp,r)!=true)
		{
		if(func_index!=-10)
			cout<<"\nFunction "<<syn_identifier[t].name <<
				" is trying to Return mismatching datatype "<<
				r.datatype;
		else 
			cout<<"\nFunction void main(void) is trying to Return a Value";
			reject();
		}
		
		if(input.clas=="semicolon")
			advanc();
		else reject();

		setatom(29,temp,dump,r);
	}
	else if(input.clas=="if")
	{
		int end=newlabel();
		int end2=newlabel();

		advanc();
		
		if(input.clas=="parenthesis_open")
			advanc();
		else reject();
		
		expr k; expression(k);

		if(input.clas=="parenthesis_close")
			advanc();
		else reject();

		expr temp1;
		temp1.datatype=0;
		temp1.index=-10;
		temp1.whichtable=-10;

		expr temp;
		temp.datatype=25;
		temp.index=end;
		temp.whichtable=4;

		setatom(27,k,temp1,temp);

		statement();

		temp.datatype=25;
		temp.index=end2;
		temp.whichtable=4;

		setatom(28,dump,dump,temp);

		temp.datatype=25;
		temp.index=end;
		temp.whichtable=4;

		setatom(25,dump,dump,temp);

		optional_else();

		temp.datatype=25;
		temp.index=end2;
		temp.whichtable=4;

		setatom(25,dump,dump,temp);

	}
	else if(input.clas=="square_open")
	{
		advanc();
		expr f;
		function_call(f);

		if(input.clas=="square_close")
			advanc();
		else reject();

		if(input.clas=="semicolon")
			advanc();
		else reject();
		//Chking Whether This Fucntion Can Return a Value or NOT?
		//Place an ERROR if it can RETURN a value other than Void
		if(f.datatype!=22)//If it's not void
		{
			cout<<endl<<"Fucntion named "<<syn_identifier[f.index].name
				<<" is returning a value,Which is Not being CAUGHT";
			reject();
		}
	}
	else reject();
}

void optional_else()
{
	if(input.clas=="else")
	{
		advanc();
		statement();
	}
	else if(input.clas=="id"||input.clas=="while"||input.clas=="braces_open"||
		input.clas=="for"||input.clas=="do"||input.clas=="return"||
		input.clas=="if"||input.clas=="braces_close"||input.clas=="square_open")
	{

	}
	else reject();
}

void right_hand_side(expr &r)
{
	if(input.clas=="parenthesis_open" ||input.clas=="id" ||input.clas=="int_const"
		|| input.clas=="long_const")
	{
		 expression(r);
	}
	else if(input.clas=="square_open")
	{
		advanc();
		function_call(r);
		if(input.clas=="square_close")
			advanc();
		else reject();
		//Assuring that a function with void as return type 
		//doesn't appear as RIGHT HAND SIDE.
		if(r.datatype!=22)	
		{
			/*Locating the 1st RETURN statement of this particular 
			function and assigning that return value to r*/
            for(unsigned int i=0;i<atoms.size();i++)
				if(atoms[i].type==29 && atoms[i].arg1.index==r.index)
				{
					r=atoms[i].result;
					break;
				}
		}
		else{
			cout<<endl<<"Fucntion named "<<syn_identifier[r.index].name
				<<"is returning a void,Therefore It can't APPEAR as an R.H.S";
			reject();
		}
	}
	else reject();
}

void function_call(expr &f)
{
	if(input.clas=="id")
	{
		expr temp;
		long indx=chk_func(input.index);
		int no_args=-10;
		if(indx==-10)
		{
			cout<<"\nFailed in <function_call>-->id=(<optional_expression_list>)";
			cout<<"\nUsing Undefined Fuction--> "<< lex_identifier[input.index];
			reject();
		}
		f.index=indx;
		f.datatype=syn_identifier[indx].datatype;
		f.whichtable=table;

		args_info(indx,init_arg,fin_arg);
		
		/*If the Fucntion is expecting a VOID type then SET No. Of
          Arguments to 0*/
		if(args_identifier[init_arg].datatype!=22)
			no_args=(fin_arg-init_arg)+1;
		else 
			no_args=0;
		//cout<<"\nArguments "<<no_args << init_arg<< fin_arg;
		temp.datatype=-10;
		temp.index=no_args;
		temp.whichtable=-10;

		advanc();
		
		if(input.clas=="parenthesis_open")
			advanc();
		else reject();

		optional_expression_list();

		if(input.clas=="parenthesis_close")
			advanc();
		else reject();

		/*If the Fucntion is expecting a VOID type then SKIP 
		Argument PASSING STEPS*/
		if(args_identifier[init_arg].datatype!=22)
		{
			if(init_arg <= fin_arg)
			{
			cout<<"\nLess arguments are passed to function "
				<< syn_identifier[indx].name;
			reject();
			}
			if((init_arg-1) > fin_arg)
			{
			cout<<"\nMore arguments are passed to function "
				<< syn_identifier[indx].name;
			reject();
			}
		}
		setatom(31,temp,dump,f);
	}
	else reject();
}

void optional_expression_list()
{
	if(input.clas=="parenthesis_close")
	{

	}
	else if(input.clas=="parenthesis_open" || input.clas=="id" || input.clas=="int_const" ||
		input.clas=="long_const" ||	input.clas=="square_open" )
	{
		expression_list_element();
		expression_listf();
	}
	else reject();
}

void expression_listf()
{
	if(input.clas=="comma")
	{
		advanc();
		expression_list_element();
		expression_listf();
	}
	else if(input.clas=="parenthesis_close")
	{
	
	}
	else reject();
}

void expression_list_element()
{
	if(input.clas=="parenthesis_open" || input.clas=="id" || input.clas=="int_const" || 
		input.clas=="long_const")
	{
		expr k;
		expr temp;
			temp.index=init_arg;
			temp.datatype=args_identifier[init_arg].datatype;
			temp.whichtable=1;
	
			expression(k);
			
			//if((init_arg-1) > fin_arg) //OLD one
			if(init_arg > fin_arg)
			{
				cout<<"\nvoid expression_list_element() More arguments are passed to function "
					<< syn_identifier[args_identifier[fin_arg].binding].name;
					reject();
			}

            if(chk_types(k,temp)==true)
				{
				setatom(30,dump,dump,k);
				//cout<<"\nArgument List "<<k.index;
				}
			else
				{
				cout<<"Type mismatched in passing arguments to Fucntion "
					<< syn_identifier[args_identifier[fin_arg].binding].name;
				reject();
				}
		init_arg++;
	}
	else if(input.clas=="square_open")
	{
		advanc();
		expr f;
		function_call(f);
		if(input.clas=="square_close")
			advanc();
		else reject();
	}
	else reject();
}

void expression(expr &k)
{
	if(input.clas=="parenthesis_open" || input.clas=="id" || input.clas=="int_const" || 
		input.clas=="long_const")
	{
		expr t1;
		arithmetic(t1);
		relational(k,t1);
	}
	else reject();
}

void relational(expr &k,expr &t1)
{
	if(input.clas=="relop")
	{
		int op=input.index;
		advanc();
		expr t2;
		arithmetic(t2);
		if(chk_types(t1,t2)==true)
		{
		k=newtemp(t2.datatype);
		setatom(op+100,t1,t2,k);
		}
		else
		{
		cout<<"\nFailed in <Relational>--->.... "<<t1.index <<" is different from "<<t2.index;
		reject();
		}
	}
	else if(input.clas=="parenthesis_close" ||input.clas=="semicolon" ||input.clas=="comma")
	{
		k=t1;
	}
	else reject();
}

void arithmetic(expr &p)
{
	if(input.clas=="parenthesis_open" || input.clas=="id" || input.clas=="int_const" 
	  || input.clas=="long_const")
	{
		expr p1;
		t(p1);
		subtract(p1,p);
	}
	else reject();
}

void subtract(expr p,expr &q)
{
	if(input.clas=="add_sub"
		&& input.index==16)
	{
		advanc();
		expr q1;
		t(q1);
		if(chk_types(p,q1)==true)
		{
		expr r1=newtemp(p.datatype);
		setatom(16,p,q1,r1);
		subtract(r1,q);
		}
		else
		{
			cout<<"\nFailed in <Subract>--->"<< p.index<<" is different from "<<q1.index;
			reject();
		}
	}
	else if(input.clas=="relop" || input.clas=="parenthesis_close" || input.clas=="semicolon" || 
		input.clas=="comma")
	{
	q=p;
	}
	else reject();