OperationBuilder Class Reference

#include <OperationBuilder.hh>

Collaboration diagram for OperationBuilder:

Public Member Functions
std::string	xmlFilePath (const std::string &xmlFile)
std::string	behaviorFile (const std::string &baseName, std::string &path)
bool	buildObject (const std::string &baseName, const std::string &behaviorFile, const std::string &path, std::vector< std::string > &output)
bool	installDataFile (const std::string &path, const std::string &xmlFile, const std::string &destination)
bool	verifyXML (const std::string file)

Static Public Member Functions
static OperationBuilder &	instance ()

Private Member Functions
	OperationBuilder ()
virtual	~OperationBuilder ()
std::string	makeIncludeString (const std::vector< std::string > &paths)

Static Private Attributes
static OperationBuilder *	instance_ = NULL
	Static unique instance.

Detailed Description

Class that handles building the operation behavior.

Definition at line 42 of file OperationBuilder.hh.

Constructor & Destructor Documentation

OperationBuilder()

OperationBuilder::OperationBuilder ( )

private

Constructor.

Definition at line 56 of file OperationBuilder.cc.

                                   {
}

Referenced by instance().

~OperationBuilder()

OperationBuilder::~OperationBuilder ( )

privatevirtual

Destructor.

Definition at line 62 of file OperationBuilder.cc.

                                    {
}

Member Function Documentation

behaviorFile()

string OperationBuilder::behaviorFile	(	const std::string &	baseName,
		std::string &	path
	)

Searches for the path of behavior file.

If path for the file is not given, it is searched from the current working directory. If file is not found, an empty string is returned.

Parameters

baseName	The name of behavior file.
path	The path where the file is located.

Definition at line 115 of file OperationBuilder.cc.

                     {
 
    string behFile = baseName + ".cc";
    if (path == "") {
        path = FileSystem::currentWorkingDir();
    }
    string pathToFile = path + FileSystem::DIRECTORY_SEPARATOR + behFile;
    if (FileSystem::fileExists(pathToFile)) {
        return pathToFile;
    }
    return "";
}

References FileSystem::currentWorkingDir(), FileSystem::DIRECTORY_SEPARATOR, and FileSystem::fileExists().

Referenced by buildObject(), and main().

Here is the call graph for this function:

buildObject()

bool OperationBuilder::buildObject	(	const std::string &	baseName,
		const std::string &	behaviorFile,
		const std::string &	path,
		std::vector< std::string > &	output
	)

Builds dynamic module and copies it to the same location where XML property file is located.

Parameters

baseName	The base name for the module.
behaviorFile	The full path for behavior file.
path	Path where built module is put.
output	Output of compilation.

Returns

True if everything is successful, false otherwise.

Definition at line 141 of file OperationBuilder.cc.

                                  {
 
    if (behaviorFile != "") {
        TCEString CPPFLAGS = Environment::environmentVariable("CPPFLAGS");
        TCEString CXXFLAGS = Environment::environmentVariable("CXXFLAGS")
            + " " + CONFIGURE_CPPFLAGS + " ";
        TCEString LDFLAGS = Environment::environmentVariable("LDFLAGS")
            + " " + CONFIGURE_LDFLAGS + " ";
        TCEString CXXCOMPILER = Environment::environmentVariable("CXX");
        vector<string> includes = Environment::includeDirPaths();
 
        TCEString INCLUDES = makeIncludeString(includes);
 
        // Ugly fix. When compiling TCE the base opset is compiled in the
        // source directory. When distributed version is enabled buildopset
        // needs to know some include paths from the source tree because these
        // headers aren't resident in places that includeDirPaths() returns.
        if (!Environment::developerMode()) {
            string cwd = FileSystem::currentWorkingDir();
            string DS = FileSystem::DIRECTORY_SEPARATOR;
            string srcOpsetDir = TCE_SRC_ROOT + DS + "opset" + DS + "base";
            if (cwd == srcOpsetDir) {
                vector<string> extraIncludes = Environment::opsetIncludeDir();
                INCLUDES += makeIncludeString(extraIncludes);
            }
         }
 
        if (Application::isInstalled()) {
            /* Add a dependency to the installed libopenasip.so just in case
               the .opb will be loaded through a libopenasip.so that is loaded
               through a dlopen() with the RTLD_LOCAL flag. In that case
               it can happen the loading of libopenasip.so to access some 
               specific functionality might not import all the symbols
               required by the .opb loaded by libopenasip later. */
            LDFLAGS += " -L" + Application::installationDir() + "/lib -lopenasip ";
        } else {
            LDFLAGS += " -L" + string(TCE_SRC_ROOT) + "/src/.libs -lopenasip ";        
        }
 
        // Add user defined CXXFLAGS + CPPFLAGS to the end because they
        // might point to paths with incompatible TCE headers.
        string COMPILE_FLAGS = \
            INCLUDES + " " + 
            CONFIGURE_CPPFLAGS + " " + CONFIGURE_LDFLAGS + " " +
            CXXFLAGS + " " + CPPFLAGS + " ";
 
        string module = path + FileSystem::DIRECTORY_SEPARATOR +
            baseName + ".opb";
 
        string command = (CXXCOMPILER == "") ? (string(CXX)) : (CXXCOMPILER);
        command += " " + COMPILE_FLAGS + " " + behaviorFile + " " +
            string(SHARED_CXX_FLAGS) + " " + LDFLAGS + " -o " + module + " 2>&1";
 
        if (Application::verboseLevel() > Application::VERBOSE_LEVEL_DEFAULT) {
            Application::logStream() << command << std::endl;
        }
        
        if (Application::runShellCommandAndGetOutput(command, output) != 0) {
            return false;
        }
    }
    return true;
}

References behaviorFile(), FileSystem::currentWorkingDir(), Environment::developerMode(), FileSystem::DIRECTORY_SEPARATOR, DS, Environment::environmentVariable(), Environment::includeDirPaths(), Application::installationDir(), Application::isInstalled(), Application::logStream(), makeIncludeString(), Environment::opsetIncludeDir(), Application::runShellCommandAndGetOutput(), Application::VERBOSE_LEVEL_DEFAULT, and Application::verboseLevel().

Referenced by OperationIndex::addPath(), OSEdBuildAllCmd::Do(), OSEdBuildCmd::Do(), and main().

Here is the call graph for this function:

installDataFile()

bool OperationBuilder::installDataFile	(	const std::string &	sourcePath,
		const std::string &	xmlFile,
		const std::string &	destinationPath
	)

Installs the data file containing operation property declarations.

Creates the destination path if it does not exist. Overwrites the existing file, if it is already installed in given destination.

Installation can fail for several reasons: no rights to create destination directory, no rights to overwrite a previously installed version of the data file, no rights to read the source data file.

Parameters

path	Source path of data file.
xmlFile	Name of the data file.
destination	Destination path where the data file is to be installed.

Returns

True, if installation is completed successfully, false otherwise.

Definition at line 226 of file OperationBuilder.cc.

                                      {
 
    const string source = 
        sourcePath + FileSystem::DIRECTORY_SEPARATOR + xmlFile;
 
    // an unreadable or nonexisting file should have been caught earlier on
    // (for example, during validation)
    assert(FileSystem::fileExists(source) && 
           FileSystem::fileIsReadable(source));
 
    if (!FileSystem::fileExists(destinationPath)) {
        if (!FileSystem::createDirectory(destinationPath)) {
            return false;
        }
    }
 
    const string dest = 
        destinationPath + FileSystem::DIRECTORY_SEPARATOR + xmlFile;
 
    if (FileSystem::fileExists(dest)) {
        if (FileSystem::removeFileOrDirectory(dest)) {
            return false;
        }
    }
 
    FileSystem::copy(source, dest);
    return true;
}

References assert, FileSystem::copy(), FileSystem::createDirectory(), FileSystem::DIRECTORY_SEPARATOR, FileSystem::fileExists(), FileSystem::fileIsReadable(), and FileSystem::removeFileOrDirectory().

Here is the call graph for this function:

instance()

OperationBuilder & OperationBuilder::instance ( )

static

Returns an instance of OperationBuilder.

Returns

An instance of OperationBuilder.

Definition at line 71 of file OperationBuilder.cc.

                           {
    if (instance_ == NULL) {
        instance_ = new OperationBuilder();
    }
    return *instance_;
}

References instance_, and OperationBuilder().

Referenced by OperationIndex::addPath(), OSEdBuildAllCmd::Do(), OSEdBuildCmd::Do(), and main().

Here is the call graph for this function:

makeIncludeString()

string OperationBuilder::makeIncludeString ( const std::vector< std::string > &  paths )

private

Makes an include string for compiler (-I<path1> -I<path2> etc) from the paths in the vector

Parameters

Vector

containing the include paths

Definition at line 286 of file OperationBuilder.cc.

                                                               {
    string includes = "";
    for (size_t i = 0; i < paths.size(); i++) {
        includes += "-I" + paths.at(i) + " ";
    }
    return includes;
}

Referenced by buildObject().

verifyXML()

bool OperationBuilder::verifyXML

(

const std::string

file

)

Verifies the correctness of XML file.

Parameters

file	Absolute path of XML file.

Definition at line 265 of file OperationBuilder.cc.

                                                {
    OperationSerializer serializer;
    serializer.setSourceFile(file);
 
    try {
        ObjectState* root = serializer.readState();
        delete root;
    } catch (const SerializerException& s) {
        cerr << "Invalid XML file: " << s.errorMessage() << endl;
        return false;
    }
    return true;
}

References Exception::errorMessage(), OperationSerializer::readState(), and OperationSerializer::setSourceFile().

Referenced by main().

Here is the call graph for this function:

xmlFilePath()

string OperationBuilder::xmlFilePath

(

const std::string &

xmlFile

)

Finds the path for XML file.

File is searched only from certain locations. If file is not found, returns an empty string.

Parameters

xmlFile

The name of the XML file.

Returns

The path to XML file.

Definition at line 88 of file OperationBuilder.cc.

                                                      {
 
    vector<string> searchPaths = Environment::osalPaths();
    searchPaths.push_back(FileSystem::currentWorkingDir());
 
    string filePath = "";
    for (unsigned int i = 0; i < searchPaths.size(); i++) {
        string file = searchPaths[i] + FileSystem::DIRECTORY_SEPARATOR +
            xmlFile;
        if (FileSystem::fileExists(file)) {
            filePath = searchPaths[i];
            break;
        }
    }
    return filePath;
}

References FileSystem::currentWorkingDir(), FileSystem::DIRECTORY_SEPARATOR, FileSystem::fileExists(), and Environment::osalPaths().

Here is the call graph for this function:

Member Data Documentation

instance_

OperationBuilder * OperationBuilder::instance_ = NULL

staticprivate

Static unique instance.

Definition at line 70 of file OperationBuilder.hh.

Referenced by instance().

---

The documentation for this class was generated from the following files:

• OperationBuilder.hh
• OperationBuilder.cc