coins.ypp

%{
    #include "shared.h"
    #include "scope.h"
    #include "coins.tab.hpp"
    
    #include <iostream>
    
    #include <cstring>
    
    #define DBG
    #define YYDEBUG 1
    extern int yylex();
    
    extern int yylineno;
    extern char* yytext;
    
    extern ScopeGlobal* globals;
    extern int globalCounter;
    int yyerror(char* message);
    
    VarType arithmeticParse(VarType lhs, VarType rhs,enum yytokentype op);
    void dumpScope(struct scope scopeD);
    bool addVar(struct scope scopeD, VarType varType, std::string idName);
    bool varExists(struct scope scopeD,std::string name);
    VarType varType(struct scope scopeD,std::string name);
    
    static void dumbScope(struct scope scopeD)
    {
    	std::cout << "==== Dumping scope ====\n";
		std::cout << "Contents of scope varset:\n";
		for (VariableSet::iterator it = scopeD.varSet.begin() ; it != scopeD.varSet.end() ; it++)
			std::cout << it->name << " " << (int)it->type << " " << it->offset << std::endl;
		std::cout << scopeD.curlyBraced << " " << scopeD.breakEncountered << std::endl;
		std::cout << "====== Dump end =====\n";	    
    }

%}

%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<name> ID
%token<name> STRING
%token TRUE
%token FALSE

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

%right NOT

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


%type<type> Type
%type<type> CoinType
%type<expInfo> Exp
%type<scopeData> Statement
%type<scopeData> Statements
%type<scopeData> S
%%

S	: Statements {dumpScope($1);}
	;
Statements	: Statements Statement {dumbScope($$);$$ = $1;}
			| Statement {dumbScope($$);$$ = $1;/*dumpScope($1);*/}
			;
			
Statement	: LC Statements RC {
									$2.curlyBraced = true;
									dumpScope($2);
									$$ = $2;
								}	/* { ... } */
			| Type ID SC {
							if (!addVar($$,$1,$2))
							{
								output::errorDef(yylineno,$2.c_str());
								YYABORT;
							}
								
						 }	   	/* int x; */
						 
			| Type ID ASSIGN Exp SC {
										if (!addVar($$,$1,$2))
										{
											output::errorDef(yylineno,$2.c_str());
											YYABORT;
										}
										if ($4.type != $1)
										{
											output::errorMismatch(yylineno);
											YYABORT;											
										}
										
									} /* int x = a+b; */
			| ID ASSIGN Exp SC {
									if (!varExists($$,$1))
									{
										output::errorUndef(yylineno,$1.c_str());
										YYABORT;
									}
									if ($3.type != varType($$,$1))
									{
										output::errorMismatch(yylineno);
										YYABORT;											
									}			
							   }	   /* x = a+b; */
			| PRINT ID SC {
							if (!varExists($$,$2))
							{
								output::errorUndef(yylineno,$2.c_str());
								YYABORT;															
							}
							if (varType($$,$2) == BOOL_T)
							{
								output::errorMismatch(yylineno);
								YYABORT;								
							}
			
						  }   	   /* print x; */
			| PRINT STRING SC {}	   /* print "bla bla"; */
			| INPUT ID SC {
							if (!varExists($$,$2))
							{
								output::errorUndef(yylineno,$2.c_str());
								YYABORT;															
							}
							if (varType($$,$2) == BOOL_T)
							{
								output::errorMismatch(yylineno);
								YYABORT;								
							}			
						  }  	   /* input x; */
			
			
			| IF LP Exp RP Statement %prec IF {
												if ($3.type != BOOL_T)
												{
													output::errorMismatch(yylineno);
													YYABORT;												
												}
												
												if ($5.breakEncountered == true)
												{
													output::errorUnexpectedBreak(yylineno);
													YYABORT;
												}
												if ($5.curlyBraced == false &&
													$5.varSet.size() > 0)
													dumpScope($5);												
																								
											  }   /* if ( x == 4 ) { ...} */
			| IF LP Exp RP Statement ELSE Statement %prec ELSE 
											  {
												if ($3.type != BOOL_T)
												{
													output::errorMismatch(yylineno);
													YYABORT;												
												}
												
												if ($5.breakEncountered || $7.breakEncountered)
												{
													output::errorUnexpectedBreak(yylineno);
													YYABORT;
												}
												if ($5.curlyBraced == false &&
													$5.varSet.size() > 0)
													dumpScope($5);
												if ($7.curlyBraced == false &&
													$7.varSet.size() > 0)
													dumpScope($7);																											  
											  }
			 /* if ( x == 4 ) { ...} else { ... } */
			
			| WHILE LP Exp RP Statement {
											if ($3.type != BOOL_T)
											{
												output::errorMismatch(yylineno);
												YYABORT;												
											}
											
											if ($5.breakEncountered == true)
												$$.breakEncountered == false;
											
											if ($5.curlyBraced == false &&
												$5.varSet.size() > 0)
												dumpScope($5);
													
												
										} /* while ( x > 2 ) { ... } */
			| BREAK SC {
							$$.breakEncountered = true;
						}  /* break; */
			;

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 {
						$$.type = $2.type;
					} 	    /* ( x < 4 ) */

/* Arithmetic Rules */					
					
		| Exp PLUS Exp {										
							$$.type = arithmeticParse($1.type,$3.type,PLUS);
							if ($$.type == ERROR_T)
								YYABORT;
					   }   /* a + b */
		| Exp MINUS Exp {										
							$$.type = arithmeticParse($1.type,$3.type,MINUS);
							if ($$.type == ERROR_T)
								YYABORT;							
					    }   /* a - b */
		| Exp MULT Exp  {										
							$$.type = arithmeticParse($1.type,$3.type,MULT);
							if ($$.type == ERROR_T)
								YYABORT;							
					    }    /* a * b */
		| Exp DIV Exp   {										
							$$.type = arithmeticParse($1.type,$3.type,DIV);
							if ($$.type == ERROR_T)
								YYABORT;							
					    }     /* a / b */
					    
/* Type rules and var names */					    
					    
		| ID {$$.name = std::string($1);}	      	    /* a */
		| NUM {$$.type = INT_T;}	    /* 4 */
		| NUM CoinType {$$.type = $2;}   /* 4 NIS */
		| TRUE {$$.type = BOOL_T;}	    /* True */
		| FALSE	{ $$.type = BOOL_T;}	    /* False */
		
/* Boolean rules */
		
		| NOT Exp {
						if ($2.type != BOOL_T)
						{
							output::errorMismatch(yylineno);
							YYABORT;
						}
						else
						{
							$$.type = BOOL_T;
						}						
				  }	    /* not (x < 4) */
		| Exp OR Exp {
						if ($1.type != BOOL_T || $3.type != BOOL_T)
						{
							output::errorMismatch(yylineno);
							YYABORT;
						}
						else
						{
							$$.type = BOOL_T;
						}
						
					 }	    /* (x > 4) || (x < 5) */
		| Exp AND Exp {
						if ($1.type != BOOL_T || $3.type != BOOL_T)
						{
							output::errorMismatch(yylineno);
							YYABORT;
						}
						else
						{
							$$.type = BOOL_T;
						}		
					  }    /* (x > 4) && (x < 5) */
		| Exp Rel Exp %prec SE {
									if (($1.type == INT_T && $3.type == INT_T)||
										(($1.type == AGORA_T || $1.type == NIS_T) &&
											($3.type == AGORA_T || $3.type == NIS_T)))
									{
										$$.type = BOOL_T;
									}
									else
									{
										output::errorMismatch(yylineno);
										YYABORT;										
									}
									
							   }    /* x < 4 */
		;

Rel		: GT {} /* > */
		| GE {} /* >= */
		| ST {} /* < */
		| SE {} /* <= */
		| EQ {} /* == */
		| NEQ {} /* != */
		;
%%

int main()
{
	/* Init */
	globals = new ScopeGlobal();
	globalCounter = 0;
	
	//yydebug = 1;
		
	yyparse();
		
	/* Clean-up */
	delete globals;
}

int yyerror(char* message)
{
	if (strcmp(message,"syntax error") == 0)
	{
		output::errorSyn(yylineno);
	}
}

VarType arithmeticParse(VarType lhs, VarType rhs,enum yytokentype op)
{
	if (rhs == BOOL_T || rhs == BOOL_T)
	{
			output::errorMismatch(yylineno);
			return ERROR_T;
	}		
		
	switch(lhs)
	{
		case INT_T:		
			if (rhs == INT_T)
				return lhs;
			if (op == MULT)
				return rhs;
			output::errorMismatch(yylineno);
			return ERROR_T;
			
			break;
		case AGORA_T:
		case NIS_T:
			if (rhs == INT_T)
			{
				if(op == MULT || op == DIV)
					return lhs;
				output::errorMismatch(yylineno);
				return ERROR_T;
			}
			if (rhs == AGORA_T || rhs == NIS_T)
			{
				if (op == DIV)
					return INT_T;
				if (op == MULT)
				{
					output::errorMismatch(yylineno);
					return ERROR_T;				 	
				}
				return lhs;
			}					
			break;	
			
	}
	
	return lhs;

}

void dumpScope(struct scope scopeD)
{
	const char* BOOL_S = "BOOL";
	const char* INT_S = "INT";
	const char* AGORA_S = "AGORA";
	const char* NIS_S = "NIS";
	
	int offset = scopeD.varSet.size();
	output::endScope();
	for (VariableSet::iterator it = scopeD.varSet.begin() ; it != scopeD.varSet.end() ; it++)
	{
		switch(it->type)
		{
		case BOOL_T:
			output::printVar(it->name.c_str(),it->offset,BOOL_S);
			break;
		case INT_T:
			output::printVar(it->name.c_str(),it->offset,INT_S);
			break;
		case AGORA_T:
		 	output::printVar(it->name.c_str(),it->offset,AGORA_S);
			break;
		case NIS_T:
			output::printVar(it->name.c_str(),it->offset,NIS_S);
			break;
		}
		
	}
	
	globalCounter -= offset;
}

bool addVar(struct scope scopeD, VarType varType, std::string idName)
{

#ifdef DBG
//	std::cout << "Adding Var: " << idName << " with type " << (int)varType << std::endl;
		
#endif

	Variable var;
	var.name = idName;
	var.offset = globalCounter++;
	var.type = varType;
	
	VarSetRet ret = scopeD.varSet.insert(var);
#ifdef DBG	
/*	std::cout << "Contents of scope varset:\n";
	for (VariableSet::iterator it = scopeD.varSet.begin() ; it != scopeD.varSet.end() ; it++)
		std::cout << it->name << " " << (int)it->type << " " << it->offset << std::endl;*/
#endif	
	
	if (ret.second == false)
	{
		globalCounter--;
		return false;
	}
	return true;	
}

bool varExists(struct scope scopeD,std::string idName)
{
	Variable dummy;
	dummy.name = idName;
	dummy.offset = 0;
	dummy.type = INT_T;
	
	VariableSet::iterator t =  scopeD.varSet.find(dummy);
	if (t == scopeD.varSet.end())
		return false;
		
	return true;
}

VarType varType(struct scope scopeD,std::string idName)
{
	Variable dummy;
	dummy.name = idName;
	VariableSet::iterator it = scopeD.varSet.find(dummy);
	
	return it->type;
}