/**Jason Shilinski, Dante Papada AS03
to change the test file, look for instructions indicated by alot of ***
*/

#include <string>
#include <iostream>
#include <fstream>

using namespace std;


/** TSTA tests accumulator A */
void TSTA (){
	cout<<";-------------------------------------------------------------------"<<endl;
	cout<<"; Macro to 'test' the accumulator; that is, it sets the condition"<<endl;
	cout<<"; codes after comparing the accumulator to zero."<<endl;
    cout<<".MACRO TSTA\nCPA 0,i\n.MACROEND\n"<<endl;
}
/** TSTX tests the index register */
void TSTX (){
	cout<<";-------------------------------------------------------------------"<<endl;
	cout<<"; Macro to 'test' the index register; that is, it sets the condition"<<endl;
	cout<<"; codes after comparing the index register to zero."<<endl;
    cout<<".MACRO TSTX\nCPA 0,i\n.MACROEND\n"<<endl;
	
}

/** INCA Increments accumulator A*/
void INCA (){
	cout<<";-------------------------------------------------------------------"<<endl;
	cout<<".MACRO\tINCA\n";
	cout<<";Macro to 'increment' the accumulator;  that is, it adds 1 to this register.\n";
    cout<<"ADDA\t1,i\n.MACROEND\n\n"<<endl;
}
/** INCX increments the accumulator register */
void INCX (){
	cout<<";-------------------------------------------------------------------"<<endl;
	cout<<".MACRO\tINCX\n";
	cout<<";Macro to 'increment' the accumulator;  that is, it adds 1 to this register.\n";
    cout<<"ADDX\t1,i\n.MACROEND\n\n"<<endl;
}
/** INC increments a word in memory*/
void INC (string word){
	cout<<";-------------------------------------------------------------------"<<endl;
	cout<<"; Macro to 'increment' the contents of a word in memory addressed"<<endl;
	cout<<"; using direct addressing mode."<<endl;
	cout<<".MACRO\tINC\t"<<word<<endl;
	cout<<"LDA\t"<<word<<",d"<<endl;
	cout<<"ADDA\t1,i"<<endl;
	cout<<"STA\t"<<word<<",d"<<endl;
	cout<<".MACROEND"<<endl<<endl;
}

/** PUSHA pushes A onto the stack */
void PUSHA (){
	cout<<";-------------------------------------------------------------------"<<endl;
	cout<<".MACRO\tPUSHA"<<endl;
	cout<<"STA\t-2,s\t; SUBSP 2,i"<<endl;
	cout<<"SUBSP\t2,i\t; STA 0,s"<<endl;
	cout<<".MACROEND"<<endl<<endl;
}

/** POPA pops A from the stack */
void POPA (){
	cout<<";-------------------------------------------------------------------"<<endl;
	cout<<".MACRO\tPOPA"<<endl;
	cout<<"LDA\t0,s"<<endl;
	cout<<"ADDSP\t2,i"<<endl;
	cout<<".MACROEND"<<endl<<endl;
}

/** PUSHX pushes X onto the stack */
void PUSHX (){
	cout<<";-------------------------------------------------------------------"<<endl;
	cout<<".MACRO\tPUSHX"<<endl;
	cout<<"STX\t-2,s\t; SUBSP 2,i"<<endl;
	cout<<"SUBSP\t2,i\t"<<endl;
	cout<<".MACROEND"<<endl<<endl;
}

/** POPX pops A from the stack */
void POPX (){
	cout<<";-------------------------------------------------------------------"<<endl;
	cout<<".MACRO\tPOPX"<<endl;
	cout<<"LDX\t0,s"<<endl;
	cout<<"ADDSP\t2,i"<<endl;
	cout<<".MACROEND"<<endl<<endl;
}

/** PUSH pushes the contents of a word in memory on the stack */
void PUSH (string word){
	cout<<";-------------------------------------------------------------------"<<endl;
	cout<<"; Macro to 'push' the contents of a word in memory addressed using"<<endl;
	cout<<"; direct addressing mode onto the stack."<<endl;
	cout<<".MACRO\tPUSH\t"<<word<<endl;
	cout<<"LDA\t"<<word<<",d"<<endl;
	cout<<"STA\t-2,s\t; PUSHA"<<endl;
	cout<<"SUBSP\t2,i\t;"<<endl;
	cout<<".MACROEND"<<endl<<endl;
}

/** POP pops the contents of a word in memory off the stack */
void POP (string word){
	cout<<";-------------------------------------------------------------------"<<endl;
	cout<<"; Macro to 'pop' the contents of a word in memory addressed using"<<endl;
	cout<<"; direct addressing mode off of the stack."<<endl;
	cout<<".MACRO\tPOP\t"<<word<<endl;
	cout<<"LDA\t0,s"<<endl;
	cout<<"STA\t"<<word<<",d"<<endl;
	cout<<"ADDSP\t2,i"<<endl;
	cout<<".MACROEND"<<endl<<endl;
}
/** Saves the contents of both registers by pushing them */
void SAVE (){
	cout<<";-------------------------------------------------------------------"<<endl;
	cout<<"; Macro to 'save' the contents of both registers, by pushing them"<<endl;
	cout<<"; onto the stack."<<endl;
	cout<<".MACRO\tSAVE"<<endl;
	cout<<"PUSHX"<<endl;
	cout<<"PUSHA"<<endl;
	cout<<".MACROEND"<<endl<<endl;
}
/** Restores the contents of both registers by popping them */
void RESTORE (){
	cout<<";-------------------------------------------------------------------"<<endl;
	cout<<"; Macro to 'restore' the contents of both registers, by popping them"<<endl;
	cout<<"; off of the stack."<<endl;
	cout<<".MACRO\tRESTORE"<<endl;
	cout<<"POPA"<<endl;
	cout<<"POPX"<<endl;
	cout<<".MACROEND"<<endl<<endl;
}
/** Swaps the contents of two strings */
void SWAP (string one, string two){
	cout<<";-------------------------------------------------------------------"<<endl;
	cout<<"; Macro to 'swap' the contents of two words, both addressed using"<<endl;
	cout<<"; direct addressing mode."<<endl;
	cout<<".MACRO\tSWAP\t"<<one<<","<<two<<endl;
	cout<<"PUSH\t"<<one<<endl;
	cout<<"PUSH\t"<<two<<endl;
	cout<<"POP\t"<<one<<endl;
	cout<<"POP\t"<<two<<endl;
	cout<<".MACROEND"<<endl<<endl;
}
/** Multiplies two words */
void MUL (string multiplicand, string multiplier,string product){
	cout<<";-------------------------------------------------------------------"<<endl;
	cout<<"; Macro to 'multiply' the contents of two words, both addressed using"<<endl;
	cout<<"; direct addressing mode."<<endl;
	cout<<".MACRO\tMUL\t"<<multiplicand<<","<<multiplier<<","<<product<<endl;
	cout<<"PUSH\t"<<multiplier<<endl;
	cout<<"PUSH\t"<<multiplicand<<endl;
	cout<<"CALL\tMultiply"<<endl;
	cout<<"STA\tproduct,d"<<endl;
	cout<<"POP\t"<<multiplicand<<endl;
	cout<<"POP\t"<<multiplier<<endl;
	cout<<".MACROEND"<<endl<<endl;
}

/** Determines the higher of two words */
void MAX (string word1, string word2,int times){
	cout<<";----------------------------------------------------------------"<<endl;
	cout<<"; Macro to determine the maximum of two words"<<endl;
	cout<<"; Note that this makes use of a 'local label'"<<endl;
    cout<<"LDA\t"<<word1<<",d"<<endl;
	cout<<"CPA\t"<<word2<<",d"<<endl;
    cout<<"BGT\tDone"<<times<<endl;
	cout<<"LDA\t"<<word2<<",d"<<endl;
	cout<<"Done"<<times<<":\tNOP0"<<endl;
	cout<<".MACROEND"<<endl<<endl;
}


//end of Macros
//*************************************************************************************************
//*************************************************************************************************

int main(){
	string text;/// basically the current line read 
	string one,two,three; ///first parameter, second, etc
	ifstream fin;
	int param1,param2,param3; ///paramater start positions
	int comma1,comma2;        ///comma position
	int length,tab;			  ///position of tab
	int times = 0;

/** **************************************************
PROFESSOR JACKOWICZ
if you are testing a different file, you need to change location and file name
*****************************************************
*/
	fin.open("D:/Jay/Debug/TestMacros1.pep",ios::in); 
/****************************************************/
	getline(fin, text);
	cout<<"Welcome to Poseidon++'s MACRO program!!"<<endl<<endl;
	cout<<text<<endl; ///just printing out each line read
	
	 while(!fin.eof()){ 		
		cout<<endl;
		length = text.length();
	
		if ((text.find("\t",0) == string::npos) ){ ///checks for a parameter ==> means no tab is present in line
			if (text == "TSTA"){
				TSTA ();
			}else if (text == "INCA"){
				INCA ();
			}else if (text == "INCX"){
				INCX ();
			}else if (text == "PUSHA"){
				PUSHA();
			}else if (text == "POPA"){
				POPA();
			}else if (text == "PUSHX"){
				PUSHX();
			}else if (text == "POPX"){
				POPX();
			}else if (text == "SAVE"){
				SAVE();
			}else if (text == "RESTORE"){
				RESTORE();
			}else
				cout<<"Not a recognized macro which lacks a parameter"<<endl;
		}else if(!(text.find("\t",0) == string::npos)){ ///there is a tab which implies AT LEAST ONE parameter

			tab =  text.find("\t",0); ///gives position of tab
			param1 = (text.find("\t",0) + 1 ); ///location of first letter of parameter
		
			if ( text.find(",",param1) == string::npos) ///checks for comma
				one = text.substr(param1,(length-1)-param1);  
			else 
				comma1= text.find(",",tab); ///position of comma
				one = text.substr(param1,(comma1-1)-tab);   ///the first parameter
				if(text.substr(0,text.find("\t",0)) == "INC"){ ///checks for macro by looking for position before tab
					INC (one);
				}else  if(text.substr(0,text.find("\t",0)) == "PUSH"){
					PUSH (one);
				}else if(text.substr(0,text.find("\t",0)) == "POP"){
					POP (one);
				}else
					;

				if( !(text.find(",",param1) == string::npos) ){ ///looks for second parameter by searching for a comma
					
					param2 = (text.find(",",param1) + 1); ///location of 1st letter of 2nd parameter
					two = text.substr(param2,(length-1)-comma1); ///the second parameter
					if(text.substr(0,text.find("\t",0)) == "SWAP"){
						SWAP (one,two);
					}else if (text.substr(0,text.find("\t",0)) == "MAX"){
						MAX (one,two,times);
						times++;
					}else
						;
				if( !(text.find(",",param2) == string::npos) ){	///checks for 3rd parameter
					comma2 = text.find(",",comma1+1); ///position of second comma
					param3 = text.find(",",comma2);   ///position of 1st letter of 3rd parameter
					two = text.substr(comma1+1,(comma2-1)-comma1); ///should give second parameter
					three = text.substr(comma2+1,(text.length()-1)-comma2); ///3rd parameter
					if(text.substr(0,text.find("\t",0)) == "MUL"){
						MUL (one,two,three);
					}else
						;
				}
			}
				}else
			cout<<"Not a recognized macro"<<endl;

		getline(fin, text); ///gets the next line of file
		cout<<text<<endl;   ///prints what was got
		
	}fin.close();
	
	
		return 0;
}