Subversion Repositories theia_gpu

#include "Preprocessor.h"

#include <iostream>

#include <fstream>

#include <map>

#include <vector>

using namespace std;

//----------------------------------------------------------------

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);

    }

}

//----------------------------------------------------------------

vector<string> Preprocessor::ScanFile(  std::ifstream & ifs )

{

        vector<string> NewFile;

        while (!ifs.eof())

        {

                 char Buffer[1024];

                 ifs.getline( Buffer,1024 );

                 string Line = Buffer;

                 //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);

                        continue;

                 }

                 if (Line.find("#macro") != string::npos)

                 {

                          NewFile.push_back("//" + Line);

                          PopulateMacroFunction(Line,ifs,NewFile);

                          continue;

             }

                vector<string> Tokens;

                Tokenize(Line,Tokens," ");

                if (Tokens.size() != 0)

                {

                if (Tokens[0] == "#define")

                        mMacros[ Tokens[1] ] = Tokens[2];

                }

                NewFile.push_back("//" + Line);

        }

        //for( map<string,string>::const_iterator it = mMacros.begin(); it != mMacros.end(); ++it )

                //cout << "macro " << it->first << " = " << it->second << "\n";

        //cout << "\n";

        //for( map<string,TMacroFunction>::iterator it = mMacroFunctions.begin(); it != mMacroFunctions.end(); ++it )

                //cout << "macro function " << it->first << "\n";

        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++)

        {

                //cout << "Line " << *I << "\n";

        //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];

                        while (Line.find(Key) != string::npos)

                                Line.replace(Line.find(Key),Key.length(),Value);

                        aFile[i] = Line;

                }

                //First 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();

}

//----------------------------------------------------------------