/*

* Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  

*

*/

#include "CmdGlobals.h"

#ifdef __WIN__

#pragma warning(disable:4786)

#endif

#include <time.h>

#include <map>

#include <list>

#include <algorithm>

#include <assert.h>

#include <fstream>

#include <stdlib.h>

#include <boost/thread.hpp>

#include <boost/bind.hpp>

#ifdef __WIN__

#include <io.h>

#include <direct.h>

#include <windows.h>

#else

#include <unistd.h>

#endif

#include "Analyser.h"

#include "CPPParser.h"

#include "CommandLine.h"

#include "CommandFile.h"

#include "BBCFileUtils.h"

#include "HAException.h"

#include "BBCAnalyser.h"

#include "AnalyserParams.h"

#include "MacroAnalyser.h"

#include "Utils.h"

#include "PlatformData.h"

const int KMaxDirLength=1024;

boost::mutex m;

boost::mutex::scoped_lock lock(m,false); //for synchronizing creation & destruction of threads in gHeaderThreads

boost::thread_group gComponentThreads;

boost::thread_group gHeaderThreads;

boost::thread* gpComponentThreads[MAX_THREAD_COUNT];

boost::thread* gpHeaderThreads[MAX_THREAD_COUNT2];

XERCES_CPP_NAMESPACE_USE

typedef pair<string,string> stringpair;

//the total number of files to be processed

static int _total_files = 0;

//the number of files that have been processed

static int _current_files = 0;

// make sure globbing is turned off when GCC is used

int _CRT_glob = 0;

// Fill the headers having API Info in global vector, so that report generator can access it.

vector<pair<string,stringpair> > HeaderInfoList; // vector<pair< headerfile name, pair<API name, API category>>>

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

// Analyser::Analyser

// Constructor

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

//

Analyser::Analyser(char** args, int argc) : iCPPParser(NULL)

{

    iCmdLine = new CommandLine(args, argc);

    iUseBaselinePlatformData = false;   

    iUseCurrentPlatformData = false;

    iBasePlatformData = 0;

    iProductPlatformData = 0;

}

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

// Analyser::Analyser

// Constructor

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

//

Analyser::Analyser()

{

}

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

// Analyser::Analyser

// Destructor

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

//

Analyser::~Analyser()

{

    delete iCmdLine;

    iCmdLine = NULL;

    if (iCPPParser != NULL)

    {

        delete iCPPParser;

        iCPPParser = NULL;

    }

    if (iBasePlatformData)

    {

      delete iBasePlatformData;

      iBasePlatformData = 0;

    }

    if ( iProductPlatformData)

    {

      delete iProductPlatformData;

      iProductPlatformData = 0;

    }

}

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

// Analyser::validateHeaders

// validates header for include guards

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

//

void Analyser::validateHeaders(vector<pair<string, string> >& aFiles, vector<pair<string, string> >& aUnsuccessful)

{

	int count = 0;

	string input;

	string files[2];

	bool exists[2];

	string guard[2];

	vector<string> guards[2];

	vector< pair<string, string> >::iterator fileStart = aFiles.begin();

	vector< pair<string, string> >::iterator fileEnd = aFiles.end();

	//vector used to temporarily hold file pairs with include guards

	vector< pair<string, string> > temp;

	while(fileStart != fileEnd )

	{

		files[0] = fileStart->first;

		files[1] = fileStart->second;

		for(int i=0; i<2; i++)

		{

			//check for include guard in Base header

			exists[i] = guardExists(files[i], guard[i]);

		}

		//if either Base or Current header in the PAIR do not have include guards

		//add the file pair to RemovedFiles list.

		if( !exists[0] || !exists[1] )

			aUnsuccessful.push_back(*fileStart);

		else 

		{

			if ( find(guards[0].begin(),guards[0].end(),guard[0]) == guards[0].end() && find(guards[1].begin(),guards[1].end(),guard[1]) == guards[1].end())

			{

				guards[0].push_back(guard[0]);

				guards[1].push_back(guard[1]);

				temp.push_back(*fileStart);			

			}

			else

			{

				aUnsuccessful.push_back(*fileStart);

			}

		}

		++fileStart;

	}

	guards[0].clear();

	guards[1].clear();

	aFiles.clear();

	aFiles = temp;

}

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

// Analyser::guardExists

// guard Exists checs to see if the input file has include guards

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

//

bool Analyser::guardExists(const string& aFile, string& aGuard)

{

	bool exists = false;

	string guard("");

	string input("");

	string temp("");

	//macro used in the #ifndef line

	pair<string,string> macroOne;

	//macro #defined subsequently

	pair<string,string> macroTwo;

	int linenum = 0;

	//linenum containing the #ifndef statement

	int ifndefline = 0;

	ifstream fileRead(aFile.c_str(), ios::in);

	if( !fileRead.is_open())

		throw HAException("Header file does not exist");;

	while( !fileRead.eof() )

	{

		linenum++;

		temp = getLine(fileRead);

		input = trimWhiteSpace(temp);

		// Check if #ifndef are being used

		// Get the MACRO string if they are present

		if(input.substr(0,7) == "#ifndef") 

		{

			macroOne = MacroAnalyser::FindMacro(input);

			ifndefline = linenum;

		}

		// checks for the usage of #if (!defined ...) in include guard defns

		else if (input.substr(0,3) == "#if")

		{

			string tempstr("!defined");

			//strip all braces from the Macro string

			while(input.find("(") < input.length())

			{

				replaceChar(input,'(',' ');

				replaceChar(input,')',' ');

			}

			//get the actual MACRO string after required temp modifications

			string::size_type index = input.find(tempstr);

			if (index == string::npos)

			  continue;

			index = index + tempstr.length();

			tempstr = input.substr( index );

			input = trimWhiteSpace(tempstr);

			pair<string,string> temppair(input, "");

			macroOne = temppair;

			ifndefline = linenum;

		}

		// Check if #define is used 

		else if (input.substr(0, 7) == "#define")

		{

			macroTwo = MacroAnalyser::FindMacro(input);

			//if macro strings used in both #ifndef and #define are same

			//consider that include guard exists

			//also verify that #define follows #if

			if( macroTwo.first == macroOne.first && macroTwo.second == macroOne.second && ifndefline < linenum )

			{

				exists = true;

				aGuard = macroOne.first;

			}

			break;

		}

		// additional statement will be used for early termination of the loop

		// in cases with no "include" guards

		else if( input.substr(0, 8) == "#include") 

		{

			exists = false;

			break;

		}

	}

	fileRead.close();

	return exists;

}

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

// Analyser::readParameters

// readParameters should be called so that first is called baseline command

// and after that current command, otherwise it doesn't work

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

//

void Analyser::readParameters(basetype type, list<pair<string, string> >& files, string& forcedheaders)

{    

    string headerset;

    string dir;

    string file;

    string platform;

    string forcedheadersfile;

    string forcedheaders_file;

    string version;

    string versionstr;

    BBCFileUtils* fileUtils = NULL;

    static basetype first = type;

    if (first != EBase)

    {

        cout << "Error: Parameter read has been called in wrong order.";

        exit(3);

    }

    switch(type)

    {

    case EBase:

        dir = BASELINEDIR;

        file = BASELINE;

        platform = BASELINEPLAT;

        forcedheadersfile = BASEFORCEDHEADERSFILE;

        version = BASELINEVERSION;

        versionstr = "BASELINE";

        break;

    case ECurrent:

        dir = CURRENTDIR;

        file = CURRENT;

        platform = CURRENTPLAT;

        forcedheadersfile = CURRENTFORCEDHEADERSFILE;

        version = CURRENTVERSION;

        versionstr = "CURRENT";

        break;

    default:

        cout << "Error: Unknown type (not baseline, nor current).";

        exit(3);

    }

    // Query the baseline-related command line parameters

    // since validation has passed, none of these should really

    // cause an exception

    try

    {

        if( iParams.parameterExists(BASEPLATFORMDATA))

        {

            iUseBaselinePlatformData = true;

            string pfdir(BBCFileUtils::getFullPath(iParams.getParameter(BASEPLATFORMDATA)));

            if (!BBCFileUtils::isValidFilename(pfdir))

            {

                throw HAException("Baseline platform data file '" + pfdir + "' is not valid.");

            }

            iParams.storeParameter(BASEPLATFORMDATA, pfdir);

        }

        if( iParams.parameterExists(CURRENTPLATFORMDATA))

        {

            iUseCurrentPlatformData = true;         

            string pfdir(BBCFileUtils::getFullPath(iParams.getParameter(CURRENTPLATFORMDATA)));

            if (!BBCFileUtils::isValidFilename(pfdir))

            {

                throw HAException("Current platform data file '" + pfdir + "' is not valid.");

            }

            iParams.storeParameter(CURRENTPLATFORMDATA, pfdir);

        }

        if (iParams.parameterExists(TEMPDIR))

        {

            string tempdir(BBCFileUtils::getFullPath(iParams.getParameter(TEMPDIR)));

            iParams.storeParameter(TEMPDIR, tempdir);

            if (!BBCFileUtils::isValidDirectory(tempdir))

            {

                throw HAException("Temporary directory '" + tempdir + "' is not valid directory.");

            }

        }

        if (iParams.parameterExists(REPORTFILE))

        {

            string reportfile(BBCFileUtils::getFullPath(iParams.getParameter(REPORTFILE)));

            iParams.storeParameter(REPORTFILE, reportfile);

            if (rightmostDirSeparatorIndex(reportfile) == reportfile.length() - 1 || BBCFileUtils::isValidDirectory(reportfile))

            {

                throw HAException("No filename given for report file.");

            }

            string reportdir = reportfile.substr(0, rightmostDirSeparatorIndex(reportfile));

            if (reportdir.size() == ANALYSER_REPORT_DIR_SIZE)

            {

                reportdir += DIR_SEPARATOR;

            }

            if (!BBCFileUtils::isValidDirectory(reportdir))

            {

                throw HAException("Directory for report file is non-existent.");

            }

        }

        if (iParams.parameterExists(HEADERSET))

        {

            iHeaderSetInUse = true;

        }

		if (iParams.parameterExists(USETHREAD))

        {

            iUseThread = true;

        }

        if (iParams.parameterExists(dir))

        {

            // START -- Support for multiple header directories

            // Validate the ; separated header paths and store them

            list<pair<string, string> > dirs = BBCFileUtils::extractFilenames(iParams.getParameter(dir));

            list<pair<string, string> >::iterator dirbegin = dirs.begin();

            string tempval = "";

            for(; dirbegin != dirs.end(); dirbegin++)

            {

                if (dirbegin != dirs.begin())

                {

                    tempval += ";";

                }

                string header = BBCFileUtils::getFullPath(dirbegin->first);

               if (header.length() != ANALYSER_HEADER_MAX_LENGTH && header.at(header.length() - 1) == DIR_SEPARATOR)

                {

                    header.resize(header.length() - 1);

                }

                if (!BBCFileUtils::isValidDirectory(header))

                {

                    string::size_type pos = rightmostDirSeparatorIndex(header);

                    string tempvar;

                    if (pos != header.length() - 1)

                    {

                        tempvar = header.substr(pos + 1);

                        header.resize(pos);

                    }

                    if (header.size() == ANALYSER_HEADER_SIZE)

                    {

                        header += DIR_SEPARATOR;

                    }

                    if (!BBCFileUtils::isValidDirectory(header) || tempvar.find_first_of("*?") == string::npos)

                    {

                        string errormsg;

                        errormsg = "Non-existent ";

                        if (type == EBase)

                        {

                            errormsg += "base";

                        } else

                        {

                            errormsg += "current";

                        }

                        errormsg += " directory '" + header + DIR_SEPARATOR + tempvar + "'.\n";

                        throw HAException(errormsg);

                    }

                }

                if (header.at(header.length() - 1) == DIR_SEPARATOR)

                {

                    header.resize(header.length() - 1);

                }

                tempval += header;

            }

            iParams.storeParameter(dir, tempval);

            // END -- Support for multiple header directories

        }

        else

        {

            iParams.storeParameter(file, BBCFileUtils::getFullPath(iParams.getParameter(file)));

        }

        // Location of baseline's platform headers

        list<pair<string, string> > platformheaders = BBCFileUtils::extractFilenames(iParams.getParameter(platform));

        list<pair<string, string> >::iterator platformbegin = platformheaders.begin();

        string tempval = "";

        for(; platformbegin != platformheaders.end(); platformbegin++)

        {

            if (platformbegin != platformheaders.begin())

            {

                tempval += ";";

            }

            string header = BBCFileUtils::getFullPath(platformbegin->first);

            if (header.length() != ANALYSER_HEADER_MAX_LENGTH && header.at(header.length() - 1) == DIR_SEPARATOR)

            {

                header.resize(header.length() - 1);

            }

            tempval += header;

        }

        iParams.storeParameter(platform, tempval);

        // Location of forced headers file (containing full names of headers that 

        // will be included to preprocessing and processing phases, e.g. e32base.h)

        if (iParams.parameterExists(forcedheadersfile))

        {

            // START -- Support for multiple forced headers

            list<pair<string, string> > fheaders = BBCFileUtils::extractFilenames(iParams.getParameter(forcedheadersfile));

            list<pair<string, string> >::iterator fheadersbegin = fheaders.begin();

            string tempval = "";

            //for each forced header, get the full path before storing it

            for(; fheadersbegin != fheaders.end(); fheadersbegin++)

            {

                if (fheadersbegin != fheaders.begin())

                {

                    tempval += ";";

                }

                tempval += BBCFileUtils::getFullPath(fheadersbegin->first);

            }

            iParams.storeParameter(forcedheadersfile, tempval);

            forcedheaders = iParams.getParameter(forcedheadersfile);

            // END -- Support for multiple forced headers

        }

        if (!iParams.parameterExists(version))

        {

            iParams.storeParameter(version, versionstr);

        }

    } catch (HAException& e)

    {

        cout << "Error: "<<e.errorMessage()<<"\n";

        exit(2);

    }

    // Instantiate file utilities that generate the file lists based on 

    // commandline parameters. In this try/catch block, we're

    // handling the baseline files

    try

    {

        if (iParams.parameterExists(dir))

        {

            // baselinedir/currentdir commandline parameters given

            fileUtils = new BBCFileUtils(iParams.getParameter(dir));

            fileUtils->setTemp(iParams.getParameter(TEMPDIR));

            string wildcard;

            list<stringpair > sets;

            list<stringpair > discarddirs;

            list<stringpair > foundfiles;

            list<stringpair > completefilenames; // Filenames that are complete, i.e no wildcards used.

            vector<string> wildcardsinset;

            if (type == EBase)

            {                

                // We are reading the parameters of the baseline platform               

                if(iHeaderSetInUse)

                {

                    // the files to be analysed are defined using 'set' parameter.

                    sets = fileUtils->extractFilenames(iParams.getParameter(HEADERSET));   

                }

                else

                {

                    // 'set' parameter is absent. Use default file types in the files to be analysed.

                    sets = fileUtils->extractFilenames(WILDCARD_DEFAULT);

                }

                sets = canonicalizeFilename(sets);

                for(list<stringpair >::iterator s = sets.begin(); s != sets.end(); ++s )

                {

                    if( s->first.find_first_of("*?") != string::npos )

                    {

                        // Wildcard is used in filename.

                        std::string wc(s->first);