coins.ypp

%{
    #include <sstream>
    #include <iostream>

    #include <vector>    
    
    #include "shared.h"
    #include "bp.hpp"
    #include "symbol_table.h"                  

	#define EMIT_GOTO emit("goto ")

    #define YYDEBUG 1
    
    using namespace std;
       
    extern int yylex();
    
    extern int yylineno;
    extern char* yytext;
    
    int yyerror(char* message);
    
    list<int> breakList;
    list<int> breakStack;
       
    //static vector<int> memoryS;
    static int memoryS;
    
    typedef enum
    {
    	PLUS_A,
    	MINUS_A,
    	MUL_A,
    	DIV_A
    } ArithmeticOp;
    
    void arithmeticOpEmit(ExpTraits& lval, ExpTraits& exp1, ExpTraits& exp2, ArithmeticOp op );
    void emitRelOperation(ExpTraits& lVal,ExpTraits& exp1, ExpTraits& exp2, RelOp relOp);
    string getExpRep(ExpTraits& expR);
	int convertIfNeeded(Type toType,ExpTraits& fromExp);        
    int getMemoryLocation();
%}

%nonassoc IF
%nonassoc ELSE

%token LP
%token RP
%token LC
%token RC
%token SC
%token ASSIGN

%token INT
%token NIS
%token AGORA
%token PRINT
%token INPUT
%token<varTraits> ID
%token<stringValue> STRING
%token TRUE
%token FALSE

%token WHILE
%token BREAK
%token BOOL
%token<numValue> NUM

%right NOT

%left AND OR
%left SE GE EQ NEQ GT ST
%left PLUS MINUS
%left MULT DIV


%type<typeTrait> Type
%type<typeTrait> CoinType
%type<expTraits> Exp
%type<statementList> Statement
%type<statementList> Statements
%type<statementList> S
%type<bufferLocation> M
%type<bufferLocation> N
%type<bufferLocation> R
%type<relOp> Rel

%%

S	: Statements {bp($1.nextList,next());}
	;
Statements	: Statements M Statement {
										bp($1.nextList,$2);
										$$.nextList = $3.nextList;										
 									 }
			| Statement {$$.nextList = $1.nextList;}
			;
			
Statement	: LC {addSymbolScope();} Statements RC {
									$$.nextList = $3.nextList;
									
									
									
									removeSymbolScope();
								}	/* { ... } */
			| Type ID SC {							
							addToSymbolTable($2.idName,$1,getMemoryLocation());
						 }	   	/* int x; */
						 
			| Type ID ASSIGN Exp SC {
										int offset = addToSymbolTable($2.idName,$1,getMemoryLocation());					
										ostringstream oss;
										oss << "s[" << offset << "]=";
										if ($4.varTraits.varType != BOOL_T)
										{										
											
								 			int newMem = convertIfNeeded($1,$4);
								 			oss << "s[" << newMem << "]";
											emit(oss.str());
										}
										else
										{
											oss << 0;
											
											bp($4.falseList,next());
											emit(oss.str());
											
											ostringstream oss2;
											oss2 << "goto " << next()+2;
											emit(oss2.str());
											
											ostringstream oss3;
											oss3 << "s[" << offset << "]=1";
											bp($4.trueList,next());
											emit(oss3.str());
											
											
										}										 
						
									} /* int x = a+b; */
			| ID ASSIGN Exp SC { 
									int offset = getSymbolOffset($1.idName);
									ostringstream oss;
									oss << "s[" << offset << "]=";
									if ($3.varTraits.varType != BOOL_T)
									{										
							 			int newMem = convertIfNeeded(getSymbolType($1.idName),$3);
							 			oss << "s[" << newMem << "]";																	 	
										emit(oss.str());
									}
									else
									{
										oss << 0;
										
										bp($3.falseList,next());
										emit(oss.str());
										
										ostringstream oss2;
										oss2 << "goto " << next()+2;
										emit(oss2.str());
										
										ostringstream oss3;
										oss3 << "s[" << offset << "]=1";
										bp($3.trueList,next());
										emit(oss3.str());
										
										
									}								
								}	   /* x = a+b; */
			| PRINT ID SC   { 
								ostringstream oss;
								oss << "print s[" << getSymbolOffset($2.idName) << "]";
								emit(oss.str());
							}   	   /* print x; */
			| PRINT STRING SC 	{
									ostringstream oss;
									oss << "print " << $2;
									emit(oss.str());
								}	   /* print "bla bla"; */
			| INPUT ID SC 	{
								ostringstream oss;
								oss << "input s[" << getSymbolOffset($2.idName) << "]";
								emit(oss.str());			
							}  	   /* input x; */
			
			
			| IF ScopeIf LP Exp RP M Statement %prec IF {
													bp($4.trueList,$6);
													$$.nextList = merge($4.falseList,$7.nextList);
													
													removeSymbolScope();													
												}   /* if ( x == 4 ) { ...} */
			| IF ScopeIf LP Exp RP M Statement ELSE {removeSymbolScope(); addSymbolScope();} N M Statement %prec ELSE 											  
											 {
											 	bp($4.trueList,$6);
											 	bp($4.falseList,$11);
											 	$$.nextList = merge(merge($7.nextList,$12.nextList),makelist($10));
											 	removeSymbolScope();
											 } 											  
			 /* if ( x == 4 ) { ...} else { ... } */ 
			
			| WHILE { addSymbolScope();} R LP Exp RP M Statement {
												
												while (breakStack.back() != -1)
												{
													int bk = breakStack.back();
													breakStack.pop_back();
													breakList.push_back(bk);
												}
												bp($8.nextList,$3);
												bp($5.trueList,$7);
												$$.nextList = merge($5.falseList,breakList);
												breakList = list<int>();
												
												ostringstream oss;
												oss << "goto " << $3;
												emit(oss.str());
												
												removeSymbolScope();
											} /* while ( x > 2 ) { ... } */
			| BREAK SC {
							breakStack.push_back(next());
							EMIT_GOTO;
						
						 }  /* break; */
			;

R:
	/* empty */ {
					breakStack.push_back(-1);
					$$ = next();
				}
				;

ScopeIf:
		/* empty */ {addSymbolScope();}
		;


CoinType	: NIS { $$ = NIS_T; } /* NIS */
			| AGORA { $$ = AGORA_T; } /* AGORA */
			;

Type		: CoinType { $$ = $1; } 	    /* NIS */
		| INT {	$$ = INT_T; }   	    /* int */
		| BOOL {$$ = BOOL_T; } 	    /* bool */
		;

Exp		: LP Exp RP {
						$$ = $2;
						$$.trueList = $2.trueList;
						$$.falseList = $2.falseList;
					} 	    /* ( x < 4 ) */

/* Arithmetic Rules */					
					
		| Exp PLUS Exp {
							$$.memoryOffset = getMemoryLocation();
							arithmeticOpEmit($$,$1,$3,PLUS_A);										
					   }   /* a + b */
		| Exp MINUS Exp {										
							$$.memoryOffset = getMemoryLocation();
							arithmeticOpEmit($$,$1,$3,MINUS_A);							
					    }   /* a - b */
		| Exp MULT Exp  {										
							$$.memoryOffset = getMemoryLocation();
							arithmeticOpEmit($$,$1,$3,MUL_A);							
					    }    /* a * b */
		| Exp DIV Exp   {
							$$.memoryOffset = getMemoryLocation();
							arithmeticOpEmit($$,$1,$3,DIV_A);		   
						}     /* a / b */
					    
/* Type rules and var names */					    
					    
		| ID { 
				$$.varTraits.idName = $1.idName;
				$$.memoryOffset = getSymbolOffset($1.idName);
				$$.varTraits.varType = getSymbolType($1.idName);
				$$.isConst = false;
				if (getSymbolType($1.idName) == BOOL_T)
				{
					$$.trueList = makelist(next());
					ostringstream oss;
					oss << "if s[" << $$.memoryOffset << "]==1 goto ";
					emit(oss.str()); 
					$$.falseList = makelist(next());
					ostringstream oss2;
					oss2 << "if s[" << $$.memoryOffset << "]==0 goto ";
					emit(oss2.str());
				}
				
			 }	      	    /* a */
		| NUM {
				$$.varTraits.numValue = $1;
				$$.isConst = true;
			  }	    /* 4 */
		| NUM CoinType {
							$$.varTraits.numValue = $1;
							$$.varTraits.varType = $2;
							$$.isConst = true;
						}   /* 4 NIS */
		| TRUE {
					$$.varTraits.varType = BOOL_T;
					$$.varTraits.numValue = 1;
					$$.trueList = makelist(next());
					$$.isConst = true;
					EMIT_GOTO;
				}	    /* True */
		| FALSE	{
					$$.varTraits.varType = BOOL_T;
					$$.varTraits.numValue = 0;
					$$.falseList = makelist(next());
					$$.isConst = true;
					EMIT_GOTO;		
				}	    /* False */
		
/* Boolean rules */
		
		| NOT Exp 	{ 
						$$.falseList = $2.trueList;
						$$.trueList = $2.falseList;
					}	    /* not (x < 4) */
		| Exp OR M Exp 
					{
						bp($1.falseList,$3);
						$$.falseList = $4.falseList;
						$$.trueList = merge($1.trueList,$4.trueList);
					}	    /* (x > 4) || (x < 5) */
		| Exp AND M Exp 
						{
							bp($1.trueList,$3);
							$$.trueList = $4.trueList;
							$$.falseList = merge($1.falseList,$4.falseList);
						}    /* (x > 4) && (x < 5) */
		| Exp Rel Exp %prec SE 
							{
								//$$.trueList = makelist(next());
								emitRelOperation($$,$1,$3,$2);
								/*$$.falseList = makelist(next());
								EMIT_GOTO; 
								
								$$.varTraits.varType = BOOL_T;*/ 
							}    /* x < 4 */
		;

Rel		: GT { $$ = GT_R; } /* > */
		| GE { $$ = GE_R; } /* >= */
		| ST { $$ = ST_R; } /* < */
		| SE { $$ = SE_R; } /* <= */
		| EQ { $$ = EQ_R; } /* == */
		| NEQ { $$ = NEQ_R; } /* != */
		;
		
M		:
		/*empty*/	{$$ = next();}
		;
		
N		:
		/* empty */	{
						$$ = next();
						EMIT_GOTO;
					}		 		
%%

int main()
{
	memoryS = 0;
	addSymbolScope();
	yyparse();
	removeSymbolScope();
	
	printBuffer();
}

int yyerror(char* message)
{
}

int getMemoryLocation()
{
	//memoryS.push_back(0);
	return (memoryS++) ;	
}

void arithmeticOpEmit(ExpTraits& lval, ExpTraits& exp1, ExpTraits& exp2, ArithmeticOp op )
{
	string ope;
	ostringstream oss;
	if (op == PLUS_A)
		ope = "+";
	else if (op == MINUS_A)
		ope = "-";
	else if (op == MUL_A)
		ope = "*";
	else
		ope = "/";
		
	Type opType = exp1.varTraits.varType;
	lval.varTraits.varType = opType;

	int exp2NewMem = convertIfNeeded(exp1.varTraits.varType,exp2);
	int newRvalLocation = getMemoryLocation();
	
	oss << "s[" << newRvalLocation << "]=" << getExpRep(exp1) << ope << "s[" << exp2NewMem << "]";
	emit(oss.str());
	
	ExpTraits temp;
	temp.varTraits.varType = exp1.varTraits.varType;
	temp.isConst = false;
	temp.memoryOffset = newRvalLocation;
	
	int finalRval = convertIfNeeded(opType,temp);
	
	/*stringstream oss2;
	oss2 << "==" << getExpRep(lval) << "=s[" << finalRval << "]";
	emit(oss2.str());*/
	
	lval.isConst = false;
	lval.memoryOffset = finalRval;                         

	return;
}

int convertIfNeeded(Type toType,ExpTraits& fromExp)
{
	int newLocation = getMemoryLocation();
	ostringstream oss;
	Type originType = fromExp.varTraits.varType;
	
	oss << "s[" << newLocation << "]=" << getExpRep(fromExp);
	
	if (fromExp.varTraits.varType != toType)
	{
		if (toType == NIS_T && originType == AGORA_T)
			oss << "/100";
		else if (toType == AGORA_T && originType == NIS_T)
			oss << "*100";
	}
	
	emit(oss.str());	
	return newLocation;
	
}

void emitRelOperation(ExpTraits& lVal,ExpTraits& exp1, ExpTraits& exp2, RelOp relOp)
{
	ostringstream oss;
	oss << "if ";
	bool isTwoTime = false;

	int tmp,tmpl;
	
	bool tmpIsConst = exp1.isConst;
	if (tmpIsConst)
		tmpl = exp1.varTraits.numValue;
	else
		tmpl = exp1.memoryOffset; 
			
	tmp = getMemoryLocation();
	ostringstream oss2;
	oss2 << "s[" << tmp << "]=";
	if (tmpIsConst)
			oss2 << tmpl;
	else
			oss2 << "s[" << tmpl << "]"; 			

	if (exp1.varTraits.varType == NIS_T && exp2.varTraits.varType == AGORA_T)
	{
		oss2 << "*" << 100; 
	}
	else if (exp1.varTraits.varType == AGORA_T && exp2.varTraits.varType == NIS_T)
	{	
		oss2 <<  "/100"; 
	}
	emit(oss2.str());
	oss << "s[" << tmp << "]";
		 
	switch (relOp)
	{
		case GE_R:
			oss << ">";
			isTwoTime = true;
			break; 
		case SE_R:
			oss << "<";
			isTwoTime = true;
			break;
		case EQ_R:
			oss << "==";
			break;	
		case NEQ_R:
			oss << "!=";
			break;
		case GT_R:
			oss << ">";
			break;
		case ST_R:
			oss << "<";
			break;									
	}	
	
	if (exp2.isConst)
		oss << exp2.varTraits.numValue;
	else
		oss << "s[" << exp2.memoryOffset << "]";
		
	oss << " goto ";
	


	lVal.trueList = makelist(next());
	emit(oss.str());

	
	if (isTwoTime)
	{
		lVal.trueList.push_back(next());
		ostringstream oss3;
		
		oss3 << "if ";
		oss3 << "s[" << tmp << "]";
		
		oss3 << "==";
		if (exp2.isConst)
			oss3 << exp2.varTraits.numValue;
		else
			oss3 << "s[" << exp2.memoryOffset << "]";
			
		oss3 << " goto ";
		
		emit(oss3.str());
	}
	int nex = next();

	lVal.falseList = makelist(nex);
	EMIT_GOTO;
	
	lVal.varTraits.varType = BOOL_T; 
	
	
		
}

string getExpRep(ExpTraits& expR)
{
	ostringstream oss;
	if (expR.isConst)
		oss << expR.varTraits.numValue;
	else
		oss << "s[" << expR.memoryOffset << "]";
		
	return oss.str();
}