#include <iostream>
#include <fstream>
#include <math.h>
#include <stdlib.h>
#include <ctype.h>
#include <string>

using std::iostream;

using namespace std;

int strtoint(string num);
bool num(char num);
int log2(int num);

void ADD(int *inputs_v,int &carry_out,int C[],int size);
void COMPARE(int *inputs,int size,int C[]);
void MULTIPLY(int *inputs,int size,int C[]);
void ogen_menu();
void igen_menu();

int main()
{	
	
	char cont;

	do{

	system("cls");

	char choice;

	cout << "\t\tEspresso I/O Generator v1.3\n";
	cout << "Dept. of Computer Science & Engineering - University of California, Riverside\n";
	cout << "programmed by Korey Sewell as part of of a research project assigned under Dr. Frank Vahid";
	
	cout << "\n\nGenerate Inputs - I\nRead from Outputs - R\nQuit - Q?\nEnter Choice: ";
	cin >> choice;

	if(toupper(int(choice)) == 'I')
		igen_menu();
	else if (toupper(int(choice)) == 'R')
		ogen_menu();
	else if(toupper((int)choice) == 'Q')
		break;

	cout << "\n\nContinue ESPRESSO I/O GENERATOR?\n\n";
	cin >> cont;

	}while(cont == 'y');

	cout << "Program ended.\n";
	return 0;
	
}

//ogen_menu(): Analyzes ESPRESSO output file
void ogen_menu()
{
	cout << "\nThe following program will do some basic analysis on the output of" << endl;
	cout << "some espresso files\n\n";


		//Get Input
		string strFiles;
		bool details = true;
		bool cla = true;

		cout << "Enter the names of your output files separated by a single space\n";

		string tmpString;
		while(1)
		{
			cin >> tmpString;

			if(strcmp(tmpString.c_str(),";") != 0)
				strFiles += " " + tmpString;
			else
				break;
		}
		
		//cin >> strFiles;

		cout << "The name: " << strFiles << endl;
		


		//getline(cin,strFiles,50);
		//Tokenize Input
		char *output_file[50];
	    int num_files=0;    
	    char *files = new char [strFiles.length()];
		strcpy(files,strFiles.c_str());
	    char *tok = strtok(files," ");
	    while(tok != NULL)
	      {
			output_file[num_files] = tok;
			num_files++;
			tok = strtok(NULL," ");
	      }
		output_file[num_files] = NULL;

		//Create Output File
		string a_file;
		cout << "\nWhat name do you want to call the analysis file? \n";
		//getline(cin,a_file);

		while(1)
		{
			cin >> tmpString;
			a_file += tmpString;
			break;
		}

		ofstream outfile(a_file.c_str(),ios::out);
		if(!outfile)
		 {
		   cout << "Error creating analysis file.\n";
		 }
	

		//Analyze Each File
		for(int i=0;i<num_files;i++)
	      {
			
			//Open Separate Instance of the File
			ifstream infile;
			infile.open(output_file[i],ios::in);
			
			if(!infile)
			{
			  cout << "Error opening " << output_file[i] << "\n";
			  break;
			}		
			outfile << "\n" << output_file[i]<< ":";

			cout << output_file[i] << ":\n";

			//1st Declarations
			string line;
			int bzero=0;
			int max_AND_inputs=0;
			int max_OR_inputs=0;

			
			//Skip to Third Line
			getline(infile,line);	//Read Line1
			//cout << line << endl;
			getline(infile,line);	//Read Line2
			//cout << line << endl;
			getline(infile,line);	//Finally, Read Line 3
			//cout << line << endl;

			//Tokenize Line 3 => (Num Tokens - 2) Equal The # of Outputs in a ESPRESSO FILE
			char *line3 = new char[line.length()];
			strcpy(line3,line.c_str());
			char *output_names[50];
			char *l3_tok = strtok(line3," ");
			int token_count = 0;
			while(l3_tok != NULL)
			  {
				output_names[token_count] = l3_tok;
				token_count++;
				l3_tok = strtok(NULL," ");
			  }
			output_names[token_count] = NULL;

			getline(infile,line);	//Finally, Read Line 3
			//cout << line << endl;
			//getline(infile,line);	//Finally, Read Line 3
			//cout << line << endl;
			//getline(infile,line);	//Finally, Read Line 3
			//cout << line << endl;

			//Tokenize Line 3 => (Num Tokens - 2) Equal The # of Outputs in a ESPRESSO FILE
			char *line4 = new char[line.length()];
			strcpy(line4,line.c_str());
			char *in_out_nums[50];
			char *l4_tok = strtok(line4," ");
			token_count = 0;
			while(l4_tok != NULL)
			  {
				in_out_nums[token_count] = l4_tok;
				token_count++;
				l4_tok = strtok(NULL," ");
			  }
			in_out_nums[token_count] = NULL;

			int num_ins  = strtoint(in_out_nums[5]);
			int num_outs = strtoint(in_out_nums[8]);	//Eliminates ".olb" and extra increment from count

			char *output_stats[50];
			int *and_gate_inputs = new int [num_outs];	//MAX inputs for each minimized AND gate
			int *or_gate_inputs= new int [num_outs];	//MAX inputs for each minimized OR  gate
			int omax_and_inputs = 0;					//Overall MAX and inputs. (Useful to
														//determine critical path)
			string tnum_and_gates;
			double max_delay = 0;

			for(int m=0;m<num_outs;m++)					//Initialize # of gate inputs for
			  {											//each output to 0
				and_gate_inputs[m]=0;
				or_gate_inputs[m]=0;
			  }
			
			do
			{
				int max_AND_inputs=0;					//MAX inputs on the current line
														//equal to number of 0s and 1s on the line
				
				if(line[1] == 'p')						//the line starting with ".p", tells the
				{										//the total # of AND gates
					for(int i=3;i<line.length();i++)
						tnum_and_gates += line[i];
				}

				char *line_char = new char[line.length()];
				strcpy(line_char,line.c_str());

				//cout << line.c_str() << " | " << strncmp(line.c_str(),"# ESPRESSO",10);
				if(strncmp(line.c_str(),"# ESPRESSO",10) == 0)
				{
					//Tokenize/Parse Line
					char *tok = strtok(line_char," ");
					int token_count = 0;
					while(tok != NULL)
					  {
						output_stats[token_count] = tok;
						token_count++;
						tok = strtok(NULL," ");
					  }
					output_stats[token_count] = NULL;
				}

				line_char = NULL;

				if(num(line[0])!=0)						//Skip Line if Doesn't Start with a Decimal Value
				  {
					int l_pos=0;						//Line Position
					
					
					while(line[l_pos]!=' ')				//Count # of 0s & 1s in Line & Stop at 1st space
					{                                   //Skip '-'s because that means "Don't Care"
						if(line[l_pos] != '-')			
							max_AND_inputs++;							
						l_pos++;
					}
					l_pos++;
					
					int outputNUM=0;					

					for(int i=l_pos;i<line.length();i++)//Scan Outputs and see what outputs a
					  {									//particular combination goes to
						//cout << line[i];

						if(line[i] == '1')
						{
							

							or_gate_inputs[outputNUM]++;//Increment # of OR gate inputs for that
														//Output

							if(and_gate_inputs[outputNUM] < max_AND_inputs) //Update the MAX # of and gate
								and_gate_inputs[outputNUM] = max_AND_inputs;//inputs for that output

							//cout << "-> " << outputNUM << " " << and_gate_inputs[outputNUM] << " incrementing\n";
						}

						outputNUM++;							
					  }
					//cout << "-> " << max_AND_inputs << endl;
					}

					if(omax_and_inputs < max_AND_inputs)	//Update OVERALL MAX "AND GATE" inputs
					  omax_and_inputs = max_AND_inputs;
				}while(getline(infile,line));

				int y,statcount;
				
			
				if(details)
				{
					cout << "\n----------- DETAILS -----------\n";
					cout << "*** The Maximum # of Inputs Table per Output w/Gate Delay ***\n";
					cout << "Name" << "\t";
					cout << "AND " << "\t";
					cout << "OR "<< "\t";
					cout << "Gate Delay" << endl;	

					

					for(y=0;y<num_outs;y++)
					  {
						if(output_names[y] == NULL)
							break;

						int and_gate_levels = log2(and_gate_inputs[y]);
						int  or_gate_levels = log2(or_gate_inputs[y]);
						double temp = (and_gate_levels * .12) + (or_gate_levels * .14);
						cout << output_names[y+1]    << ":\t";
						cout << and_gate_inputs[y] << "\t";
						cout << or_gate_inputs[y]  << "\t";
						cout << temp << "\t" << and_gate_levels << "\t" << or_gate_levels << endl ;

						if(max_delay < temp)
							max_delay = temp;
					  }
				}

				cout << "\n----------- SUMMARY -----------\n";
				
				int cla_ANDs = 0;
				int cla_ORs = 0;
				int cla_INV = 0;
				double cla_delay = 0;
				double inv_delay = .03;

				if(cla)
				{
					cla_ANDs = num_ins / 4;
					cla_ORs = num_ins / 4;
					cla_INV = (num_ins / 2) * -1;
					cla_delay = .14;
				}

				int and_gates = strtoint(tnum_and_gates) + cla_ANDs;
				int or_gates = num_outs + cla_ORs;
				int inv_gates = num_ins + cla_INV;

				cout << "# of AND Gates: " << and_gates << "\n"; 
				cout << "# of OR Gates:  " << or_gates  << "\n";
				cout << "# of INV Gates: " << inv_gates << "\n";
				cout << "Total # of Gates: " << and_gates + or_gates + inv_gates << endl;
				cout << "# of Transistors: " << (and_gates * 5) + (or_gates * 5) + (inv_gates * 2) << endl;
				cout << "MAX Gate Delay: " << max_delay + inv_delay + cla_delay << endl;

				statcount = 0;
				while(output_stats[statcount] != NULL)
				{
					if(num(output_stats[statcount][0]))
					{
						cout << "Simulation Time: " << output_stats[statcount] << output_stats[statcount + 1] << endl;
						statcount++;
					}
					else if(output_stats[statcount][0] == 'i' && output_stats[statcount][1] == 'n')
						cout << "# of AND Gate Inputs: " << output_stats[statcount] << endl;
					else if(output_stats[statcount][0] == 'o')
						cout << "# of OR Gate Inputs: " <<  output_stats[statcount] << endl;
					else if(output_stats[statcount][0] == 't' && output_stats[statcount][1] == 'o')	
						cout << "Total # Gate of Inputs: " << output_stats[statcount] << endl;	
					
					statcount++;
				}


				if(details)
				{
					outfile << "\n----------- DETAILS for " << output_file[i] << " -----------\n";
					outfile << "*** The Maximum # of Inputs Table per Output w/Gate Delay ***\n";
					outfile << "Name" << "\t";
					outfile << "AND " << "\t";
					outfile << "OR "<< "\t";
					outfile << "Gate Delay" << endl;	

					for(y=0;y<num_outs;y++)
					  {
						if(output_names[y] == NULL)
							break;

						int and_gate_levels = log2(and_gate_inputs[y]);
						int  or_gate_levels = log2(or_gate_inputs[y]);
						double temp = (and_gate_levels * .12) + (or_gate_levels * .14);
						outfile << output_names[y+1]    << ":\t";
						outfile << and_gate_inputs[y] << "\t";
						outfile << or_gate_inputs[y]  << "\t";
						outfile << temp << and_gate_levels << or_gate_levels << endl ;

						if(max_delay < temp)
							max_delay = temp;
					  }
				}

				outfile << "\n----------- SUMMARY  " << output_file[i] << "-----------\n";
				if(cla)
				{
					cla_ANDs = num_ins / 4;
					cla_ORs = num_ins / 4;
					cla_INV = (num_ins / 2) * -1;
					cla_delay = .14;
				}

				and_gates = strtoint(tnum_and_gates) + cla_ANDs;
				or_gates = num_outs + cla_ORs;
				inv_gates = num_ins + cla_INV;

				outfile << "# of AND Gates: " << and_gates << "\n"; 
				outfile << "# of OR Gates:  " << or_gates  << "\n";
				outfile << "# of INV Gates: " << inv_gates << "\n";
				outfile << "Total # of Gates: " << and_gates + or_gates + inv_gates << endl;
				outfile << "# of Transistors: " << (and_gates * 5) + (or_gates * 5) + (inv_gates * 2) << endl;
				outfile << "MAX Gate Delay: " << max_delay + inv_delay + cla_delay  << endl;
				
				statcount = 0;
				while(output_stats[statcount] != NULL)
				{
					if(num(output_stats[statcount][0]))
					{
						outfile << "Simulation Time: " << output_stats[statcount] << output_stats[statcount + 1] << endl;
						statcount++;
					}
					else if(output_stats[statcount][0] == 'i' && output_stats[statcount][1] == 'n')
						outfile << "# of AND Gate Inputs: " << output_stats[statcount] << endl;
					else if(output_stats[statcount][0] == 'o')
						outfile << "# of OR Gate Inputs: " <<  output_stats[statcount] << endl;
					else if(output_stats[statcount][0] == 't' && output_stats[statcount][1] == 'o')	
						outfile << "Total # Gate of Inputs" << output_stats[statcount] << endl;	
					
					statcount++;
				}
	}



}


void igen_menu()
{
    		char input_size;
            int type_inputs = 0;
			int size;
			bool adder,comparator,multiplier,cla;
			adder = comparator = multiplier = cla = false;
			int carry_out;
			string espresso_file;

			cout << "\n\nFor which unit would you like to create inputs for?\n";
			cout << "1 - Adder\t2 - Comparator\t3 - Multiplier\n4 - CLA Adder\n";
			cin >> type_inputs;
		  
			if(type_inputs == 1) adder = true;
			if(type_inputs == 2) comparator = true;
			if(type_inputs == 3) multiplier = true;
			if(type_inputs == 4) cla = true;
			
			cout << "Enter The Size (in bits) of the Component (q-quit): ";
			cin >> input_size;


			size = input_size - 48;	

			if(adder) espresso_file	= "a_";
			if(multiplier) espresso_file = "m_";
			if(comparator) espresso_file = "c_";
			if(cla) espresso_file = "cl_";
				espresso_file += input_size;

			ofstream e_file(espresso_file.c_str(),ios::out);

			if(!e_file)
			   cout << "File couldn't be created\n";
			else
				cout << "Input File: " << espresso_file << " is created: \n";

			cout << "Output make take awhile.\n";

			int inputs;

			if(cla)
				inputs = size * 4; 
			else
				inputs = size * 2;

			int *inputs_v = new int[inputs];
			int *SUM = new int[size];
			int rows = pow((double)2,(double)size+size);
			

			//Write # of Inputs
			e_file << ".i " << inputs << endl;
			
			//Write # of Outputs
			if(comparator)
				e_file << ".o 3" << endl;
			else if(multiplier)
				e_file << ".o " << inputs << endl;
			else if(adder || cla)
				e_file << ".o " << size+1 << endl;

			//Write Names of Inputs
			e_file << ".ilb ";
			int b_count=0;
			int g_count=0;

			if(cla)
			{
				int loopi = size * 2;
				for(int i=0;i<loopi;i++)
				  {
					if(i>(loopi/2)-1)
					  {
					e_file << "B";
					e_file << b_count++;
					  }
					else
					  {
					e_file << "A";
						e_file << i;
					  }
					e_file << " ";
				  }

				for(i=0;i<loopi;i++)
				  {
					if(i>(loopi/2)-1)
					  {
					e_file << "P";
					e_file << g_count++;
					  }
					else
					  {
					e_file << "G";
						e_file << i;
					  }
					e_file << " ";
				  }
			}
			else
			{
				for(int i=0;i<inputs;i++)
				  {
					if(i>(inputs/2)-1)
					  {
					e_file << "B";
					e_file << b_count++;
					  }
					else
					  {
					e_file << "A";
						e_file << i;
					  }
					e_file << " ";
				  }
			}

			//Write Names of Outputs
			e_file << "\n.olb ";
			if(adder || cla)
			{
				for(int j=0;j<size;j++)
				  {
					e_file << "O" << j << " ";
				  }
				e_file << "C";
			}
			else if(comparator)
				e_file << "L G E";
			else if(multiplier)
			{
				for(int j=0;j<inputs;j++)
				  {
					e_file << "O" << j << " ";
				  }
			}
			e_file << endl;
			
			int row_value = 0;
			for(int i=0;i<rows;i++)
			{
				int *row_table = new int[inputs];
				int spot = 0;
				int row_value2 = row_value;
				int f = 1;

				if(cla)
				{
					int loopi = size * 2;
					for(int j=loopi-1;j>=0;j--)
					{
						double test = pow((double)2,(double)j);
						if(test > row_value2)
						{
							row_table[spot] = 0;
						}
						else
						{
							row_table[spot] = 1;
							row_value2 -= test;
						}
						e_file << row_table[spot];
						   
						spot++;
					}

					spot = 0;
					for(j=size-1;j>=0;j--)
					{
						e_file << (row_table[spot] && row_table[spot+size]);
						spot++;
					}

					spot = 0;
					for(j=size-1;j>=0;j--)
					{
						e_file << (row_table[spot] || row_table[spot+size]);
						spot++;
					}
					e_file << " ";
				}
				else
				{
					for(int j=inputs-1;j>=0;j--)
					{
						double test = pow((double)2,(double)j);
						if(test > row_value2)
						{
							row_table[spot] = 0;
						}
						else
						{
							row_table[spot] = 1;
							row_value2 -= test;
						}
						e_file << row_table[spot];
						   
						spot++;
					}
					e_file << " ";
				}
				

				if(adder == 1)
				{
					ADD(row_table,carry_out,SUM,inputs);	
					for(int m=0;m<size;m++)
					{
						e_file << SUM[m];
					}
					e_file << carry_out << endl;
				}
				else if(comparator == 1)
				{
					int C[3];
					COMPARE(row_table,inputs,C);
					e_file << C[0] << C[1] << C[2] << endl;
				}
				else if(multiplier == 1)
				{
					int *C = new int[inputs];
					MULTIPLY(row_table,inputs,C);
					for(int i = 0; i < inputs; i++)
						e_file << C[i];
					e_file << endl;
				}
				else if(cla == 1)
				{
					int bsize = size * 2;
					int *cla_rows = new int[bsize];

					for(int w=0;w<bsize;w++)
					{
						cla_rows[w] = row_table[w];
					}

					ADD(cla_rows,carry_out,SUM,bsize);	
					for(int m=0;m<size;m++)
					{
						e_file << SUM[m];
					}
					e_file << carry_out << endl;
				}

				row_value++;
			}
			
			e_file << ".e" << endl;
			
			e_file.close();
				
}


int strtoint(string num)
{
	int conv_num = 0;

	int numlen = num.length();

	int z = num.length() - 1;
	for(unsigned i=0;i<num.length();i++)
	{
		conv_num += (num[z] - 48) * (int)pow(10,i);
		z--;
	}
	
	return conv_num;
}

int log2(int num)
{
	int rmdr = num % 2;
	int retvalue;

	if(rmdr == 0)
	{
		int levels = 0;
		int temp = num;
		
		while(temp > 1)
		{
			temp = temp / 2;
			levels++;
		}

		retvalue = levels;
	}
	else
	{
		int levels = 0;
		int temp = num;

		while(temp != 1)
		{
			temp = temp / 2;
			levels++;
		}

		retvalue = levels + 1;
	}

	return retvalue;
}

bool num(char num)
{
	switch(num)
	{
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
		case '-':
			return true;
			break;

		default:
			return false;
	}
}

void COMPARE(int *inputs,int size,int C[])
{  
	int bsum,asum,power,b_count;
	b_count = bsum = asum = power = 0;

	int *A = new int[size/2];
	int *B = new int[size/2];

	for(int j=0;j<size;j++)
	{
		if(j > ((size/2)-1))
		{
			B[b_count] = inputs[j];
			b_count++;
		}
		else	
			A[j] = inputs[j];
	}

	for(int i=(size/2)-1;i>=0;i--)
	{
		if(A[i] == 1)
			asum += pow(2,power);
		
		if(B[i] == 1)
			bsum += pow(2,power);

		power++;
	}

	C[0] = (asum < bsum);
	C[1] = (asum > bsum);
	C[2] = (asum == bsum);
}

void MULTIPLY(int *inputs,int size,int C[])
{  
	int bsum,asum,power,b_count;
	b_count = bsum = asum = power = 0;

	int *A = new int[size/2];
	int *B = new int[size/2];

	for(int j=0;j<size;j++)
	{
		if(j > ((size/2)-1))
		{
			B[b_count] = inputs[j];
			b_count++;
		}
		else	
			A[j] = inputs[j];
	}

	for(int i=(size/2)-1;i>=0;i--)
	{
		if(A[i] == 1)
			asum += pow(2,power);
		
		if(B[i] == 1)
			bsum += pow(2,power);

		power++;
	}

	int temp = asum * bsum;

	int spot = 0;
	for(int k=size-1;k>=0;k--)
	{
		double test = pow((double)2,(double)k);
		
		if(test > temp)
		{
			C[spot] = 0;
		}
		else
		{
			C[spot] = 1;
			temp -= test;
		}			   
		spot++;
	}
}

void ADD(int *inputs,int &carry_out,int C[],int size)
{
	int *A = new int[size/2];
	int *B = new int[size/2];
    
	int b_count=0;

	for(int j=0;j<size;j++)
	{
		if(j > ((size/2)-1))
		{
			B[b_count] = inputs[j];
			b_count++;
		}
		else	
			A[j] = inputs[j];
	}

	int cin = 0;
	for(int i=(size/2)-1;i>=0;i--)
	{
		if((cin == 0) && (A[i] == 0) && (B[i] == 0))
		{
			C[i] = 0; 
			cin = 0;
		}
		else if((cin == 0) && (A[i] == 0) && (B[i] == 1))
		{
			C[i] = 1;
			cin = 0;
		}
		else if((cin == 0) && (A[i] == 1) && (B[i] == 0))
		{
			C[i] = 1;
			cin = 0;
		}
		else if((cin == 0) && (A[i] == 1) && (B[i] == 1))
		{
			C[i] = 0;
			cin = 1;
		}
		else if((cin == 1) && (A[i] == 0) && (B[i] == 0))
		{
			C[i] = 1; 
			cin = 0;
		}
		else if((cin == 1) && (A[i] == 0) && (B[i] == 1))
		{
			C[i] = 0;
			cin = 1;
		}
		else if((cin == 1) && (A[i] == 1) && (B[i] == 0))
		{
			C[i] = 0;
			cin = 1;
		}
		else if((cin == 1) && (A[i] == 1) && (B[i] == 1))
		{
			C[i] = 1;
			cin = 1;
		}

	}
	carry_out = cin;
}