From 3e07927700136867e4be235ce8ef76e510a16f4e Mon Sep 17 00:00:00 2001
From: Nikita Mahoviya <mahoviyanikita@gmail.com>
Date: Mon, 27 Sep 2021 19:13:33 +0530
Subject: [PATCH] Added various Assembly Language instructions

---
 include/xasm/utils.hpp |   4 +
 src/instruction.cc     | 775 +++++++++++++++++++++++++++++++++++++++++
 src/utils.cc           | 178 ++++++++++
 3 files changed, 957 insertions(+)

diff --git a/include/xasm/utils.hpp b/include/xasm/utils.hpp
index e5e4908..ce658d4 100644
--- a/include/xasm/utils.hpp
+++ b/include/xasm/utils.hpp
@@ -31,6 +31,10 @@ bool validityRegisters(string reg);
 bool validityRegisterPair(string reg);
 int registerNumber(string str);
 string hexAdd(string arg1, string arg2, bool flag[], bool carry);
+string hexSub(string arg1,string arg2,bool flag[],bool carry);
+string increaseAddress(string a);
+string complement(string a);
+string hexSub16bit(string arg1,string arg2,bool flag[],bool carry);
 
 // map<string, function<void(string, string[], bool[], map<string, string> &)>>
 // instruction1{{"add", ADD}};
diff --git a/src/instruction.cc b/src/instruction.cc
index 99e75b5..6ca69e2 100644
--- a/src/instruction.cc
+++ b/src/instruction.cc
@@ -104,4 +104,779 @@ void MVI (string arg1,string arg2,string registers[],bool flags[],map<string,str
 		cout<<"Error: "<<"Invalid content\nThe program will quit\n";
 		exit(0);
 	}
+}
+
+void ADI(string arg, string registers[],bool flag[]){
+
+	int length = arg.length();
+	if(length == 2){
+	
+		if(validityData(arg)){
+			
+			/*Performs immediate addition and stores in accumulator*/
+			registers[0] = hexAdd(arg,registers[0],flag,true);
+		}
+		else{
+			
+			cout<<"Error: "<<arg<<"\nInvalid data content\nThe program will quit\n";
+			exit(0);
+			/*Error message of invalid data content*/
+		}
+	}
+	else{
+		
+		cout<<"Error: "<<arg<<"\nInvalid data size\nThe program will quit\n";
+		exit(0);
+		/*Error message of invalid data size*/
+	}
+	
+}
+
+void SUB(string arg1,string registers[],bool flag[],map<string,string>&memory){
+	
+	int length=arg1.length();
+	if(length == 1){
+		
+		if(validityRegisters(arg1)){
+			
+			if(arg1 != "M"){
+			
+				/*Fetches index of register to access array string registers[]*/
+				int registerID = registerNumber(arg1);              
+				/*Converting decimal value to string format and storing in accumulator*/
+				registers[0] = hexSub(registers[registerID],registers[0],flag,true);
+				
+			}
+			else{                         
+		
+				/*Fetches data of HL pair*/
+				string address = "";
+				address = address + registers[5] + registers[6];
+				if(address >= "0000" && address <= "FFFF"){
+				
+					/*Converting decimal value to string format and storing in accumulator*/
+					registers[0] = hexSub(memory[address],registers[0],flag,true);				
+					
+				}
+				else{
+					cout<<"Error: "<<arg1<<"\nAddress out of bounds\nThe program will quit\n";
+					exit(0);
+					/*error message of address out of bounds*/
+				}						
+			}
+		}
+		else{
+			cout<<"Error: "<<arg1<<"\nInvalid register details\nThe program will quit\n";
+			exit(0);
+			/*error of invalid register details*/
+		}
+	}
+	else{
+		cout<<"Error: "<<arg1<<"\nInvalid arguments\nThe program will quit\n";
+		exit(0);
+		/*Error message of invalid arguments*/
+	}
+}
+
+void DAD(string arg,string registers[],bool flag[]){
+
+	int length = arg.length();
+	if(length == 1){
+	
+		if(validityRegisters(arg)){
+		
+			int registerID = registerNumber(arg);
+			if(registerID == 1 || registerID == 3 || registerID == 5){
+				
+				string data16bit = "";
+				string data16bitHL = "";
+				string resultant = "";
+				if(validityData(registers[registerID]) && validityData(registers[registerID+1]) && validityData(registers[5]) && validityData(registers[6])){
+				
+					data16bit = data16bit + registers[registerID] + registers[registerID];
+					data16bitHL = data16bitHL + registers[5] + registers[6];
+					int value16bit[4];
+					int value16bitHL[4];
+					int carry = 0;
+					hexToDecimal(arg,value16bit);
+					hexToDecimal(arg,value16bitHL);	  
+					for(int i = 3;i>=0;i--){
+					
+						int value = value16bit[i] + value16bitHL[i] + carry;
+						if(value >= 16)
+							flag[0] = true;
+						else
+							flag[0] = false;
+						carry = value / 16;
+						value = value % 16;
+						if(value>=0 && value<=9)
+							resultant = (char)('0' + value) + resultant;
+						else{
+							switch(value){
+							
+								case 10:
+									resultant = "A" + resultant;
+									break;
+								case 11:
+									resultant = "B" + resultant;
+									break;
+								case 12:
+									resultant = "C" + resultant;
+									break;
+								case 13:
+									resultant = "D" + resultant;
+									break;
+								case 14:
+									resultant = "E" + resultant;
+									break;
+								case 15:
+									resultant = "F" + resultant;
+									break;	
+							}
+						}
+					}
+					
+					registers[5] = resultant[0] + resultant[1];
+					registers[6] = resultant[2] + resultant[3];	
+				}		
+				else{
+					cout<<"Error: "<<arg<<"\nInvalid data content in registet\nThe program will quit\n";
+					exit(0);
+					/*Error:Invalid data content in registers*/
+				}
+			}
+			else{
+				cout<<"Error: "<<arg<<"\nInvalid register pair\nThe program will quit\n";
+				exit(0);
+				/*Error:Invaid register pair*/
+			}
+		}
+		else{
+			cout<<"Error: "<<arg<<"\nInvalid register content\nThe program will quit\n";
+			exit(0);
+			/*Error:Invalid register content*/ 
+		}
+	}
+	else{
+		cout<<"Error: "<<arg<<"\nInvalid arguments\nThe program will quit\n";
+		exit(0);
+		/*Error:Invalid Input Argument*/
+	}
+}
+
+void INR(string arg,string registers[],bool flag[],map<string,string>&memory){
+
+	int length = arg.length();
+	if(length == 1){
+	
+		if(validityRegisters(arg)){
+		
+			if(arg != "M"){
+				
+				/*Performs INR on a register*/
+				int registerID = registerNumber(arg);
+				registers[registerID] = hexAdd(registers[registerID],"01",flag,false); 
+			}
+			else{
+				/*Performs DCR on HL pair*/
+				string address = "";
+				address = address + registers[5] + registers[6];
+				if(validityAddress(address)){
+				
+					memory[address] = hexAdd(memory[address],"01",flag,false);
+				}
+				else{
+					
+					cout<<"Error: "<<arg<<"\nAddress out of bounds\nThe program will quit\n";
+					exit(0);
+				}
+			}
+		}
+		else{
+			
+			cout<<"Error: "<<arg<<"\nInvalid register details\nThe program will quit\n";
+			exit(0);
+			/*Error:Invalid Register*/
+		}
+	}
+	else{
+		
+		cout<<"Error: "<<arg<<"\nInvalid argument type\nThe program will quit\n";
+		exit(0);
+		/*Error: Invalid argument type*/
+	}
+}
+
+void INX(string arg,string registers[],bool flag[]){
+
+	int length = arg.length();
+	if(length == 1){
+	
+		if(validityRegisters(arg)){
+			
+			int registerID = registerNumber(arg);
+			if(registerID == 1 || registerID == 3 || registerID == 5){
+			
+				string data16bit = "";
+				string temporary = "";	
+				string s1 = "";
+				string s2 = "";
+				if(validityData(registers[registerID]) == true && validityData(registers[registerID+1]) == true){
+					
+					data16bit = data16bit + registers[registerID] + registers[registerID + 1];
+					//temporary =  hexAdd16bit(data16bit,"0001",flag,false);
+					temporary = increaseAddress(data16bit);
+					 s1 = s1 + temporary[0] + temporary[1];		
+					 s2 = s2 + temporary[2] + temporary[3];
+					 registers[registerID] = s1; 
+					 registers[registerID+1] = s2;
+				}
+				else{
+					
+					cout<<"Error: "<<arg<<"\nInvalid data content in registers\nThe program will quit\n";
+					exit(0);
+					/*Error:Invalid data content in registers*/
+				}
+			}
+			else{
+				cout<<"Error: "<<arg<<"\nInvalid register pair\nThe program will quit\n";
+				exit(0);
+				/*Error:Invaid register pair*/
+			}
+		}
+		else{
+			cout<<"Error: "<<arg<<"\nInvalid register content\nThe program will quit\n";
+			exit(0);
+			/*Error:Invalid register content*/ 
+		}
+	}
+	else{
+		cout<<"Error: "<<arg<<"\nInvalid input arguments\nThe program will quit\n";
+		exit(0);
+		/*Error:Invalid Input Argument*/
+	}
+}
+
+void CMA(string registers[],bool flags[])
+{
+	string complment = complement(registers[0]);
+	registers[0] = complment;
+	if(registers[0]=="00")
+    {
+        flags[6] = true;
+        flags[2] = true;
+    }
+    else
+    {
+        string temp = registers[0];
+		int array[2];
+		hexToDecimal(temp,array);
+		int value=array[1]*16+array[0];
+		bitset<8> dataInBinary(value);
+		int parity = dataInBinary.count();
+		if(parity%2 == 0 && parity!=0)
+			flags[2] = true;
+		else
+			flags[2] = false;
+    }
+}
+
+void CMP (string arg1,string registers[],bool flag[],map<string,string> &memory)
+{
+	int l1=arg1.length();
+	if(l1==1)
+	{
+		if(arg1=="M")
+		{
+		    string address=registers[5]+registers[6];
+			if(registers[0]<memory[address])
+			{
+			    flag[0]=true;
+			}
+			else if(registers[0]==memory[address])
+			{
+				flag[6]=true;
+				//cout<<"zero set\n";
+			}
+			else
+			{
+				//cout<<"both reset\n";
+				flag[0]=false;
+				flag[6]=false;
+			}
+		}
+		else if(validityRegisters(arg1))
+		{
+			int index=registerNumber(arg1);
+    		if(registers[0]<registers[index])
+    		{
+				//cout<<"carry set\n";
+				flag[0]=true;
+			}
+			else if(registers[0]==registers[index])
+			{
+				//cout<<"zero set\n";
+				flag[6]=true;
+			}
+			else
+			{
+				//cout<<"both reset\n";
+			    flag[0]=false;
+				flag[6]=false;
+			}
+		}
+		else{
+			
+			cout<<"Error: "<<arg1<<"\nInvalid registers\nThe program will quit\n";
+			exit(0);
+		}
+	}
+	else{
+		
+		cout<<"Error: "<<arg1<<"\nInvalid argument\nThe program will quit\n";
+		exit(0);
+	}
+}
+
+void DCR(string arg,string registers[],bool flag[],map<string,string>&memory){
+
+	int length = arg.length();
+	if(length == 1){
+	
+		if(validityRegisters(arg)){
+		
+			if(arg != "M"){
+				
+				/*Performs INR on a register*/
+				int registerID = registerNumber(arg);
+				registers[registerID] = hexSub(registers[registerID],"01",flag,false);
+			}
+			else{
+				/*Performs DCR on HL pair*/
+				string address = "";
+				address = address + registers[5] + registers[6];
+				if(validityAddress(address)){
+				
+					memory[address] = hexSub(memory[address],"01",flag,false);
+				}
+				else{
+					cout<<"Error: "<<arg<<"\nInvalid register details\nThe program will quit\n";
+					exit(0);
+					/*Error:Address out of bounds*/
+				}
+			}
+		}
+		else{
+			cout<<"Error: "<<arg<<"\nInvalid register\nThe program will quit\n";
+			exit(0);
+			/*Error:Invalid Register*/
+		}
+	}
+	else{
+		
+		cout<<"Error: "<<arg<<"\nInvalid argument\nThe program will quit\n";
+				exit(0);
+		/*Error: Invalid argument type*/
+	}
+}
+
+void DCX(string arg,string registers[],bool flag[]){
+
+	int length = arg.length();
+	if(length == 1){
+	
+		if(validityRegisters(arg)){
+			
+			int registerID = registerNumber(arg);
+			if(registerID == 1 || registerID == 3 || registerID == 5){
+			
+				string data16bit = "";
+				string temporary = "";
+				string s1 = "";
+				string s2 = "";
+				if(validityData(registers[registerID]) == true && validityData(registers[registerID+1]) == true){
+					
+					data16bit = data16bit + registers[registerID] + registers[registerID + 1];
+					temporary = hexSub16bit(data16bit,"0001",flag,false);
+					 s1 = s1 + temporary[0] + temporary[1];		
+					 s2 = s2 +temporary[2] + temporary[3];
+					registers[registerID] = s1;
+					registers[registerID+1] = s2;
+				}
+				else{
+					cout<<"Error: "<<arg<<"\nInvalid data content\nThe program will quit\n";
+					exit(0);
+					/*Error:Invalid data content in registers*/
+				}
+			}
+			else{
+				cout<<"Error: "<<arg<<"\nInvalid register pair\nThe program will quit\n";
+				exit(0);
+				/*Error:Invaid register pair*/
+			}
+		}
+		else{
+			cout<<"Error: "<<arg<<"\nInvalid register content\nThe program will quit\n";
+			exit(0);
+			/*Error:Invalid register content*/ 
+		}
+	}
+	else{
+		cout<<"Error: "<<arg<<"\nInvalid input arguments\nThe program will quit\n";
+		exit(0);
+		/*Error:Invalid Input Argument*/
+	}
+}
+
+string JC(string arg, string programCounter, string Registers[],bool flag[]){
+
+	if(flag[0] == true)
+		return arg;
+	else{
+		
+		string resultant = "";
+		int value16bit[4];
+		int returnValue[] = {0,0,0,3};
+		int carry = 0;
+		hexToDecimal(programCounter,value16bit);	  
+		for(int i = 3;i>=0;i--){
+					
+			int value = value16bit[i] + returnValue[i] + carry;
+			carry = value / 16;
+			value = value % 16;
+			if(value>=0 && value<=9)
+				resultant = (char)('0'+value) + resultant;
+			else{
+				resultant = (char)('A'+(value-10)) + resultant;
+			}
+		}
+		if(validityAddress(resultant))
+			return resultant;
+		else{
+			
+			cout<<"Error: "<<arg<<"\nAddress overflow\nThe program will quit\n";
+				exit(0);
+		}
+	}
+}
+
+string JMP(string arg, string Registers[],bool flag[]){
+
+	if(validityAddress(arg))
+		return arg;
+	else{
+		
+		cout<<"Error encountered in: "<<arg<<"\n";
+		cout<<"The program will quit\n";
+		exit(0);
+	}
+}
+
+string JNC(string arg, string programCounter, string Registers[],bool flag[]){
+
+	if(flag[0] == false)
+		return arg;
+	else{
+		
+		string resultant = "";
+		int value16bit[4];
+		int returnValue[] = {0,0,0,3};
+		int carry = 0;
+		hexToDecimal(programCounter,value16bit);	  
+		for(int i = 3;i>=0;i--){
+					
+			int value = value16bit[i] + returnValue[i] + carry;
+			carry = value / 16;
+			value = value % 16;
+			if(value>=0 && value<=9)
+				resultant = (char)('0' + value) + resultant;
+			else{
+				resultant = (char)('A' + (value-10)) + resultant;
+			}
+		}
+		if(validityAddress(resultant))
+			return resultant;
+		else
+		{
+			cout<<"Error: "<<arg<<"\nAdress overflow\nThe program will quit\n";
+				exit(0);
+		}
+			/*Error - Address over-flow*/
+	}
+}
+
+string JNZ(string arg, string programCounter, string Registers[],bool flag[]){
+
+	if(flag[6] == false){
+		
+		return arg;
+	}
+	else{
+
+		string resultant = "";
+		int value16bit[4];
+		int returnValue[] = {0,0,0,3};
+		int carry = 0;
+		hexToDecimal(programCounter,value16bit);	  
+		for(int i = 3;i>=0;i--){
+					
+			int value = value16bit[i] + returnValue[i] + carry;
+			carry = value / 16;
+			value = value % 16;
+			if(value>=0 && value<=9)
+				resultant = (char)('0' + value) + resultant;
+			else{
+				resultant = (char)('A'+(value-10)) + resultant;
+			}
+		}
+		if(validityAddress(resultant))
+			return resultant;
+		else
+		{
+			cout<<"Error: "<<arg<<"\nAddress overflow\nThe program will quit\n";
+				exit(0);
+			}
+			/*Error - Address over-flow*/
+	}
+}
+
+string JZ(string arg, string programCounter, string Registers[],bool flag[]){
+
+	if(flag[6] == true)
+		return arg;
+	else{
+		
+		string resultant = "";
+		int value16bit[4];
+		int returnValue[] = {0,0,0,3};
+		int carry = 0;
+		hexToDecimal(programCounter,value16bit);	  
+		for(int i = 3;i>=0;i--){
+					
+			int value = value16bit[i] + returnValue[i] + carry;
+			carry = value / 16;
+			value = value % 16;
+			if(value>=0 && value<=9)
+				resultant = (char)('0' + value) + resultant;
+			else{
+				resultant = (char)('A'+(value-10)) + resultant;
+			}
+		}
+		if(validityAddress(resultant))
+			return resultant;
+		else
+		{
+			cout<<"Error: "<<arg<<"\nAddress overflow\nThe program will quit\n";
+				exit(0);
+		}
+			/*Error - Address over-flow*/
+	}
+}
+
+void LDA (string arg1,string registers[],bool flag[],map<string,string> &memory)
+{
+	int l1=arg1.length();
+	if(l1==4)
+	{
+		if(validityAddress(arg1)){
+
+			registers[0] = memory[arg1];
+		}
+		else
+		{
+			cout<<"Error: "<<arg1<<"\nInvalid address\nThe program will quit\n";
+				exit(0);
+		}
+	}
+	else
+	{
+		cout<<"Error: "<<arg1<<"\nInvalid arguments\nThe program will quit\n";
+				exit(0);
+	}
+}
+
+void LHLD (string arg1,string registers[],bool flag[],map<string,string> &memory)
+{
+	int l1=arg1.length();
+	if(l1==4)
+	{
+		if(validityAddress(arg1)&&validityAddress(increaseAddress(arg1)))
+		{
+			registers[6]=memory[arg1];
+			registers[5]=memory[increaseAddress(arg1)];
+		}
+		else 
+		{
+			cout<<"Error: "<<arg1<<"\nSome error is thrown\nThe program will quit\n";
+				exit(0);
+		}
+	}
+	else
+	{
+		cout<<"Error: "<<arg1<<"\nInvalid arguments\nThe program will quit\n";
+				exit(0);
+	}
+}
+
+void LXI (string arg1,string arg2,string registers[],bool flags[],map<string,string> &memory)
+{
+	int l1=arg1.length();
+	int l2=arg2.length();
+	if(l1==1&&l2==4)
+	{
+		if(arg1=="M")
+		{
+			if(validityAddress(arg2))
+			{
+				string part1="",part2="";
+				for(int i=0;i<2;i++)
+				{
+					part1+=arg2[i];
+					part2+=arg2[i+2];
+				}
+				registers[5]=part1;
+				registers[6]=part2;
+			}
+			else
+			{
+				cout<<"Error: "<<arg1<<" & "<<arg2<<"\nInvalid content\nThe program will quit\n";
+				exit(0);
+			}
+		}
+		else
+		{
+			if(validityRegisterPair(arg1)&&validityAddress(arg2))
+			{
+				string part1="",part2="";
+				for(int i=0;i<2;i++)
+				{
+					part1+=arg2[i];
+					part2+=arg2[i+2];
+				}
+				registers[registerNumber(arg1)]=part1;
+				registers[registerNumber(arg1)+1]=part2;
+			}
+			else
+			{
+				cout<<"Error: "<<arg1<<" & "<<arg2<<"\nInvalid content\nThe program will quit\n";
+				exit(0);
+			}
+		}
+	}
+	else
+	{
+		cout<<"Error: "<<arg1<<" & "<<arg2<<"\nInvalid arguments\nThe program will quit\n";
+				exit(0);
+		}
+}
+
+void SET(string arg1,string arg2,map<string,string> &memory){
+	int l1=arg1.length();
+	int l2=arg2.length();
+	if(l1==4 && l2==2 && validityAddress(arg1)&&validityData(arg2))
+		memory[arg1]=arg2;
+	else{
+		cout<<"Error: "<<arg1<<" & "<<arg2<<"\nInvalid arguments\nThe program will quit\n";
+		exit(0);
+	}
+}
+
+void SHLD (string arg1, string registers[],bool flag[], map<string,string> &memory){
+	int l1=arg1.length();
+	if(l1 == 4 && validityAddress(arg1) && registers[5]!="" && registers[6]!="" && memory.empty() == false){
+		memory[arg1]=registers[6];
+		memory[increaseAddress(arg1)]=registers[5];
+	}
+	else{
+		cout<<"Error: "<<arg1<<"\nInvalid content\nThe program will quit\n";
+	}
+}
+
+void STA (string arg1,string registers[],bool flag[],map<string,string> &memory)
+{
+	int l1=arg1.length();
+	if(l1==4)
+	{
+		if(validityAddress(arg1))
+			memory[arg1]=registers[0];
+		else
+		{
+			cout<<"Error: "<<arg1<<"\nInvalid address\nThe program will quit\n";
+			exit(0);
+		}
+	}
+	else
+	{
+		cout<<"Error: "<<arg1<<"\nInvalid arguments\nThe program will quit\n";
+		exit(0);
+	}
+}
+
+void STAX(string arg1,string registers[],bool flag[],map<string,string> &memory)
+{
+	int l1=arg1.length();
+	if(l1==1)
+	{
+		if(validityRegisterPair(arg1))
+		{
+			string address="";
+			int index=registerNumber(arg1);
+			address+=registers[index]+registers[index+1];
+			if(validityAddress(address))
+				memory[address]=registers[0];
+			else
+			{
+				cout<<"Error: "<<arg1<<"Invalid address\nThe program will quit\n";
+				exit(0);
+			}
+		}
+		else
+		{
+			cout<<"Error: "<<arg1<<"\nInvalid register pair\nThe program will quit\n";
+			exit(0);
+		}
+	}
+	else
+	{
+		cout<<"Error: "<<arg1<<"\nInvalid content\nThe program will quit\n";
+		exit(0);
+	}
+}
+
+void SUI(string arg, string registers[],bool flag[]){
+
+	int length = arg.length();
+	if(length == 2){
+	
+		if(validityData(arg)){
+			
+			/*Performs immediate subtraction and stores in accumulator*/
+			registers[0] = hexSub(arg,registers[0],flag,true);
+		}
+		else{
+			
+			cout<<"Error: "<<arg<<"\n";
+			cout<<"This is an invalid data\n";
+			exit(0);
+			/*Error message of invalid data content*/
+		}
+	}
+	else{
+		
+		cout<<"Error: "<<arg<<"\n";
+		cout<<"You have tried to enter invalid data\nThe program will quit\n";
+		exit(0);
+		/*Error message of invalid data size*/
+	}
+	
+}
+
+void XCHG (string registers[],bool flag[])
+{
+	string temp=registers[3];
+	registers[3]=registers[5];
+	registers[5]=temp;
+	temp=registers[4];
+	registers[4]=registers[6];
+	registers[6]=temp;
 }
\ No newline at end of file
diff --git a/src/utils.cc b/src/utils.cc
index 8ad8f4b..f4804b1 100644
--- a/src/utils.cc
+++ b/src/utils.cc
@@ -237,3 +237,181 @@ bool validityData(string a){
 	else 
 		return false;
 }
+
+string hexSub(string arg1,string arg2,bool flag[],bool carry){
+	
+	string resultant = "";
+	int variable;
+	int parity;
+	int value1[2];
+	int value2[2];
+	int tempAnswer[2];
+	hexToDecimal(arg1,value1);
+	hexToDecimal(arg2,value2);
+
+	if(value1[1] < value2[1]){
+		
+		tempAnswer[1] = (16+value1[1])-value2[1];
+		--value1[0];
+		}
+	else{
+		tempAnswer[1] = value1[1] - value2[1];
+	}
+
+	if(value1[0] < value2[0]){
+	
+		if(carry == true)
+			flag[0] = true;
+			
+		tempAnswer[0] = (16+value1[0]-value2[0]);
+		}
+	else
+		tempAnswer[0] = value1[0] - value2[0];
+		
+	 
+	variable = tempAnswer[0]*16 + tempAnswer[1];
+	bitset<8> dataInBinary(variable);
+	/*Setting parity flag*/
+	parity = dataInBinary.count();
+	if(parity%2 == 0 && parity!=0)
+		flag[2] = true;
+	else
+		flag[2] = false;
+	/*Setting sign flag*/
+	flag[7] = dataInBinary[7];
+	/*Setting zero flag*/
+	if(parity == 0)
+		flag[6] = true;
+	else
+		flag[6] = false;
+		
+	/*Convert decimal data to hexadecimal and store in accumulator*/
+	for(int i = 1;i>=0;--i){
+		
+		if(tempAnswer[i]>=0 && tempAnswer[i]<=9)
+			resultant = char('0'+tempAnswer[i]) + resultant;
+		else if(tempAnswer[i]>=10 && tempAnswer[i]<=15)
+			resultant = (char)('A'+(tempAnswer[i] - 10)) + resultant;
+		}
+	
+	return resultant;
+	
+}
+
+string increaseAddress(string a)
+{
+	int number[5];
+	string nextAddress="";
+	int l=a.length();
+	for(int i=l-1;i>=0;i--)
+	{
+		if(a[i]>='A'&&a[i]<='F')
+			number[i]=(int)(10+(a[i]-'A'));
+		if(a[i]>='0'&&a[i]<='9')
+			number[i]=(int)(a[i]-'0');
+	}
+	number[l-1]++;
+	for(int i=l-1;i>=0;i--)
+	{
+		if(number[i]>=0&&number[i]<=15)
+			break;
+		if(number[i]>=16)
+		{
+			number[i]=number[i]%16;
+			number[i-1]++;
+		}
+	}
+	for(int i=0;i<l;i++)
+	{
+		if(number[i]>=0&&number[i]<=9)
+			nextAddress+=(char)('0'+(number[i]));
+		else if(number[i]>=10 && number[i]<=15)
+			nextAddress+=(char)('A'+(number[i]-10));
+	}
+	return nextAddress;
+}
+
+string complement(string a)
+{
+	int l=a.length();
+	string complement="";
+	for(int i=0;i<l;i++)
+	{
+		if(a[i]>='0'&&a[i]<='9')
+		{
+			int diff=15-(a[i]-'0');
+			if(diff>=0&&diff<=9)
+				complement+=('0'+diff);
+			else if(diff>=10&&diff<=15)
+				complement+=('A'+(diff-10));	
+		}
+		if(a[i]>='A'&&a[i]<='F')
+		{
+			int value=a[i]-'A';
+			int diff=15-value;
+			if(diff>=0&&diff<=9)
+				complement+=('0'+diff);
+			else if(diff>=10&&diff<=15)
+				complement+=('A'+(diff-10));
+		}
+	}
+	return complement;
+}
+
+string hexSub16bit(string arg1,string arg2,bool flag[],bool carry){
+	
+	string resultant = "";
+	int variable;
+	int parity;
+	int value1[4];
+	int value2[4];
+	int tempAnswer[4];
+	hexToDecimal(arg1,value1);
+	hexToDecimal(arg2,value2);
+	for(int i=3;i>=0;i--){
+		
+		if(value1[i] < value2[i]){
+			
+			tempAnswer[i] = (16 + value1[i]) - value2[i];
+			if(i!=0)
+				--value1[i-1];
+			else{
+				if(carry)
+					flag[0] = true;
+			}
+		}
+		else
+		
+			tempAnswer[i] = value1[i] - value2[i];
+	}
+	variable = tempAnswer[0]*16*16*16 + tempAnswer[1]*16*16 + tempAnswer[2]*16 + tempAnswer[3];
+	bitset<16> dataInBinary(variable);
+	/*Setting parity flag*/
+	parity = dataInBinary.count();
+	if(parity%2 == 0 && parity!=0)
+		flag[2] = true;
+	else
+		flag[2] = false;
+	/*Setting sign flag*/
+	flag[7] = dataInBinary[7];
+	/*Setting zero flag*/
+	if(parity == 0){
+
+		flag[6] = true;
+	}
+	else{
+
+		flag[6] = false;
+	}
+	/*Convert decimal data to hexadecimal and store in accumulator*/
+	for(int i = 3;i>=0;--i){
+		
+		if(tempAnswer[i]>=0 && tempAnswer[i]<=9)
+			resultant = char('0'+tempAnswer[i]) + resultant;
+		else if(tempAnswer[i]>=10 && tempAnswer[i]<=15)
+			resultant = (char)('A'+(tempAnswer[i] - 10)) + resultant;
+		}
+	
+	return resultant;
+	
+}
\ No newline at end of file