Subversion Repositories theia_gpu

#include "Preprocessor.h"
#include <iostream>
#include <fstream>
#include <map>
#include <vector>
using namespace std;
void find_and_replace( string& input_string,
                       const string& find_string,
                       const string& replace_string )
{
  if( find_string.empty()
      or find_string == replace_string
      or input_string.length() < find_string.length() )
  {
    return;
  }
 
  string output_string;
  output_string.reserve( input_string.length() );
  size_t last_pos = 0u;
  for( size_t new_pos = input_string.find( find_string );
       new_pos != string::npos;
       new_pos = input_string.find( find_string, new_pos ) )
  {
    bool did_replace = false;
    if( ( new_pos == 0u
          or not std::isalpha( input_string.at( new_pos - 1u ) ) )
        and ( new_pos + find_string.length() == input_string.length()
              or not std::isalpha( input_string.at( new_pos + find_string.length() ) ) ) )
    {
      output_string.append( input_string, last_pos, new_pos - last_pos );
      output_string.append( replace_string );
      did_replace = true;
    }
    new_pos += find_string.length();
    if( did_replace )
    {
      last_pos = new_pos;
    }
  }
  output_string.append( input_string, last_pos,
                        input_string.length() - last_pos );
 
  input_string.swap( output_string );
}
//----------------------------------------------------------------
Preprocessor::Preprocessor()
{
}
//----------------------------------------------------------------
Preprocessor::~Preprocessor()
{
}
//-----------------------------------------------------------------------
void Tokenize(const string& str,
                      vector<string>& tokens,
                      const string& delimiters = " ")
{
 
    string::size_type lastPos = str.find_first_not_of(delimiters, 0);
      string::size_type pos     = str.find_first_of(delimiters, lastPos);
 
    while (string::npos != pos || string::npos != lastPos)
    {
 
        tokens.push_back(str.substr(lastPos, pos - lastPos));
        lastPos = str.find_first_not_of(delimiters, pos);
        pos = str.find_first_of(delimiters, lastPos);
    }
}
//----------------------------------------------------------------
void Preprocessor::IncludeFile(  string aPath, vector<string> & NewFile )
{
	ifstream ifs;
	ifs.open(aPath.c_str());
	if (!ifs.is_open())
		throw string("Could not include file '") + aPath + "'";
 
	while( !ifs.eof())
	{
			char Buffer[1024];
			ifs.getline( Buffer,1024 );
			string Line = Buffer;
			ScanLine(Line,NewFile,ifs, false);
			//	NewFile.push_back("//" + Line);	
	}
	ifs.close();	
}
//----------------------------------------------------------------
void Preprocessor::ScanLine( string & Line , vector<string> & NewFile, ifstream & ifs, bool aAddLineToFile = true )
{
	 //replace tabs with spaces
		 int pos = 0;
		 while ((pos = Line.find("\t")) != string::npos)
					Line.replace(pos,1," ");
 
		 if (Line.find("#") == string::npos)
		 {
 
			NewFile.push_back(Line);
			return;
		 }
 
		 if (Line.find("#macro") != string::npos)
		 {
			  if (aAddLineToFile)
				NewFile.push_back("//" + Line);
			  PopulateMacroFunction(Line,ifs,NewFile);
			  return;
	     }
 
		vector<string> Tokens;
		Tokenize(Line,Tokens," ");
		if (Tokens.size() != 0)
		{
 
			if (Tokens[0] == "#define")
			{
				mMacros[ Tokens[1] ] = Tokens[2];
				if (aAddLineToFile)
					NewFile.push_back("//" + Line);	
			}
 
			if (Tokens[0] == "#include")
			{
				string IncludeFilaPath = Tokens[1];
 
				while(IncludeFilaPath.find("\"") != string::npos) IncludeFilaPath.erase(IncludeFilaPath.find("\""),1);
				IncludeFile( IncludeFilaPath, NewFile );
			/*	ifstream ifs;
				ifs.open(IncludeFilaPath.c_str());
				if (!ifs.is_open())
					throw string("Could not include file '") + IncludeFilaPath + "'";
 
				while( !ifs.eof())
				{
					char Buffer[1024];
					ifs.getline( Buffer,1024 );
					string Line = Buffer;
					ScanLine(Line,NewFile,ifs);
				//	NewFile.push_back("//" + Line);	
				}
				ifs.close();	*/
			}
		}
}
//----------------------------------------------------------------
vector<string> Preprocessor::ScanFile(  std::ifstream & ifs )
{
	vector<string> NewFile;
	while (!ifs.eof())
	{
		 char Buffer[1024];
		 ifs.getline( Buffer,1024 );
		 string Line = Buffer;
		 ScanLine( Line,NewFile,ifs );
 
 
	}
 
 
	return NewFile;
}
//----------------------------------------------------------------
void Preprocessor::SubstitudeMacros( vector<string> & aFile, ofstream & ofs )
{
	//for (int i = 0; i < NewFile.size(); i++)
	int i = 0;
	for ( vector<string>::iterator I = aFile.begin(); (I != aFile.end() && i < aFile.size()); I++, i++)
	{
 
	//Now the macro literals
		for( map<string,string>::const_iterator it = mMacros.begin(); it != mMacros.end(); ++it )
		{
			string Key = it->first;
			string Value = it->second;
			string Line = aFile[i];
			if (Line.find("#define") != string::npos)
			{
				aFile[i] = Line;	
				continue;
			}
			find_and_replace(Line,Key,Value);
 
			aFile[i] = Line;
		}
 
 
		//Now the macro functions
		for( map<string,TMacroFunction>::iterator it = mMacroFunctions.begin(); it != mMacroFunctions.end(); ++it )
		{
			string Key = it->first;
			TMacroFunction MacroFunction = it->second;
			string Line =*I;
			if (Line.find("//") != string::npos)
				Line.erase(Line.find("//"),Line.length()-Line.find("//"));
				//continue;
 
			if (Line.find(Key) != string::npos)
			{
				int pos = 0;
				 while ((pos = Line.find(" ")) != string::npos)
					Line.erase(pos,1);
				  vector<string> Tokens;
				Tokenize(Line,Tokens,"=");
 
				MacroFunction.mReturnValue = Tokens[0];
				vector<string> Tokens2;
				string Tmp = Tokens[1];
				Tokens.clear();
				Tokenize(Tmp,Tokens,"(");
				Tmp = Tokens[1];
				 while ((pos = Tmp.find(")")) != string::npos)
					 Tmp.erase(pos,1);
				 while ((pos = Tmp.find(";")) != string::npos)
					 Tmp.erase(pos,1);
				 Tokens.clear();
				 Tokenize(Tmp,Tokens,",");
				 MacroFunction.mParamterValue = Tokens;
 
				 vector<string> MacroString = MacroFunction.GetSubstitudedMacro();
				 aFile[i] = "//" + aFile[i];
				 I = aFile.begin() + i+1;
				 aFile.insert(I,MacroString.begin(),MacroString.end());
 
				 I = aFile.begin() + i;
			}
		}
 
	//	cout <<  aFile[i].c_str() << std::endl;
		ofs << aFile[i].c_str() << std::endl;
	}
}
//----------------------------------------------------------------
void Preprocessor::Execute( string aFile )
{
	ifstream ifs;
	ifs.open(aFile.c_str());
	if (!ifs.good())
		std::cout << "Cannot open file" << aFile << "\n";
	cout << "Scanning file " << aFile << "\n";
	vector<string> NewFile = ScanFile( ifs );
	ifs.close();	
	cout << "Preprocessing file " << aFile << "\n";
	ofstream ofs(string(aFile + ".preprocessed").c_str());
	SubstitudeMacros( NewFile, ofs );
	ofs.close();
}
//----------------------------------------------------------------
vector<string> TMacroFunction::GetSubstitudedMacro()
	{
		vector<string> ReturnString;
		for (int i = 0; i < mLines.size(); i++)
		{
 
			string Line = mLines[i];
			for (int j = 0; j < mParamterSymbol.size(); j++)
			{
				while(  Line.find(mParamterSymbol[j]) != string::npos )
					Line.replace(Line.find(mParamterSymbol[j]),mParamterSymbol[j].length(),mParamterValue[j]);
 
				while(  Line.find(mReturnSymbol) != string::npos )
					Line.replace(Line.find(mReturnSymbol),mReturnSymbol.length(),mReturnValue);
 
			}	
 
			ReturnString.push_back( Line );
		}
		return ReturnString;
	}
//----------------------------------------------------------------
void Preprocessor::PopulateMacroFunction(string aSignature, std::ifstream & ifs, vector<string> & aNewFile)
{
 
	 //Get rid of spaces
	 int pos = 0;
	 while ((pos = aSignature.find(" ")) != string::npos)
				 aSignature.erase(pos,1);
	//Delete the "#macro" string
	aSignature.erase(0,6);
	vector<string> Tokens;
	Tokenize(aSignature,Tokens,"=");
	TMacroFunction M;		
	M.mReturnSymbol = Tokens[0];
 
	string Tmp = Tokens[1];
	Tokens.clear();
	Tokenize(Tmp,Tokens,"(");
	M.mName = Tokens[0];
	Tmp = Tokens[1];
	while ((pos = Tmp.find(")")) != string::npos)
		 Tmp.erase(pos,1);
	 Tokens.clear();
	 Tokenize(Tmp,Tokens,",");
	 M.mParamterSymbol = Tokens;
 
	 int MacroLineCount = 0;
	 while (MacroLineCount < MAX_MACRO_FUNCTION_LINE_COUNT)
	 {
		char Buffer[1024];
		 ifs.getline( Buffer,1024 );
		 string Line = Buffer;
	     aNewFile.push_back("//" + Line);
		 if (Line.find("#endmacro") != string::npos)
				 break;
		 M.mLines.push_back( Line );
		 MacroLineCount++;
	 }
 
	 mMacroFunctions[M.mName] = M;
	 M.mLines.clear();
}
//----------------------------------------------------------------