Environment Class Reference

#include <Environment.hh>

Collaboration diagram for Environment:

Static Public Member Functions
static void	initialize ()
static std::string	schemaDirPath (const std::string &prog)
static std::string	dataDirPath (const std::string &prog)
static std::string	bitmapsDirPath (const std::string &prog)
static std::string	manDirPath (const std::string &prog)
static TCEString	confPath (const std::string &fileName)
static TCEString	userConfPath (const std::string &fileName)
static std::string	errorLogFilePath ()
static std::string	iconDirPath ()
static std::vector< std::string >	includeDirPaths ()
static std::vector< std::string >	opsetIncludeDir ()
static void	setNewSchemaFileDir (const std::string &path)
static void	setNewDataFileDir (const std::string &path)
static void	setNewBitmapsFileDir (const std::string &path)
static void	setNewManFileDir (const std::string &path)
static void	setNewErrorLogFileDir (const std::string &path)
static std::string	environmentVariable (const std::string &variable)
static std::vector< std::string >	osalPaths ()
static std::vector< std::string >	codeCompressorPaths (bool libraryPathsOnly=false)
static std::vector< std::string >	schedulerPluginPaths ()
static std::vector< std::string >	icDecoderPluginPaths (bool libraryPathsOnly=false)
static std::vector< std::string >	hwModulePaths ()
static std::vector< std::string >	hdbPaths (bool libraryPathsOnly=false)
static TCEString	shortHDBPath (const TCEString &hdbPath)
static TCEString	longHDBPath (const TCEString &hdbPath)
static std::vector< std::string >	vhdlPaths (const std::string &hdbPath)
static std::vector< std::string >	decompressorPaths (bool libraryPathsOnly=false)
static std::vector< std::string >	explorerPluginPaths ()
static std::vector< std::string >	estimatorPluginPaths ()
static std::string	pdfManual ()
static std::string	minimalADF ()
static std::string	tceCompiler ()
static std::string	defaultSchedulerConf ()
static std::string	oldGccSchedulerConf ()
static std::string	defaultICDecoderPlugin ()
static std::string	defaultTextEditorPath ()
static std::string	llvmtceCachePath ()
static std::vector< std::string >	implementationTesterTemplatePaths ()
static std::string	simTraceDirPath ()
static bool	developerMode ()

Private Member Functions
	Environment ()
	~Environment ()

Static Private Member Functions
static std::string	pathTo (const std::string &name)
static void	parsePathEnvVariable (std::vector< std::string > &paths)
static std::string	findExecutableFromPATH (const std::vector< std::string > &file)

Static Private Attributes
static const std::string	SCHEMA_DIR_NAME_ = "data"
	Name of the XML Schema directory. More...
static const std::string	DATA_DIR_NAME_ = "data"
	Name of the data directory. More...
static const std::string	BITMAPS_DIR_NAME_ = "bitmaps"
	Name of the bitmaps directory. More...
static const std::string	MAN_DIR_NAME_ = "man"
	Name of the manual directory. More...
static const std::string	CONF_DIR_NAME_ = "conf"
	Name of the configuration directory. More...
static const std::string	ICON_DIR_NAME_ = "icons"
	Name of the toolbar icon directory. More...
static const std::string	ERROR_LOG_FILE_NAME_ = "error_log.log"
	Name of the system error log file. More...
static bool	initialized_ = false
	Flag indicating whether class has been initialized. More...
static bool	developerMode_ = false
	Flag indicating whether TCE is executing in developer mode. More...
static std::vector< std::string >	schemaPaths_
	Schema directory search paths. More...
static std::vector< std::string >	dataPaths_
	Data directory search paths. More...
static std::vector< std::string >	bitmapsPaths_
	Bitmaps directory search paths. More...
static std::vector< std::string >	manPaths_
	Man directory search paths. More...
static std::vector< std::string >	iconPaths_
	Toolbar icon search paths. More...
static std::vector< std::string >	errorPaths_
	Error file search paths. More...
static std::vector< std::string >	pathsToUse_
	Paths used in a particular search. More...
static std::string	newSchemaFileDir_ = ""
	Directory for new schema file. More...
static std::string	newDataFileDir_ = ""
	Directory for new data file. More...
static std::string	newBitmapsFileDir_ = ""
	Directory for new bitmaps file. More...
static std::string	newIconFileDir_ = ""
	Directory for new icon file. More...
static std::string	newManFileDir_ = ""
	Directory for new manual file. More...
static std::string	newConfFile_ = ""
	Directory for new configure file. More...
static std::string	newErrorLogFileDir_ = ""
	Directory for new error log file. More...
static std::string	simTraceDir_ = ""
	Directory to store ttasim traces. More...
static const std::string	PDF_MANUAL_INSTALLED = "manual/OpenASIP_manual.pdf"
	Relative path to the installed TCE .pdf manual. More...
static const std::string	PDF_MANUAL_SRC = "manual/OpenASIP_manual.pdf"
	Relative path to the TCE .pdf manual in source tree. More...
static const std::string	MINIMAL_ADF_INSTALLED = "data/mach/minimal.adf"
	Relative path to the installed minimal.adf. More...
static const std::string	MINIMAL_ADF_SRC = "data/mach/minimal.adf"
	Relative path to the minimal.adf in source tree. More...

Detailed Description

A class to get the environmental variable values as well as to find files or directories from the project's directory structure.

Definition at line 47 of file Environment.hh.

Constructor & Destructor Documentation

Environment()

Environment::Environment ( )

private

Constructor.

Definition at line 420 of file Environment.cc.

                         {
}

~Environment()

Environment::~Environment ( )

private

Destructor.

Definition at line 427 of file Environment.cc.

                          {
}

Member Function Documentation

bitmapsDirPath()

string Environment::bitmapsDirPath ( const std::string &  prog )

static

Tries to locate the directory where the application bitmaps are stored.

Returns the first absolute path of the directory where the file is found. If bitmaps directory is not found and a new directory is given, it is created. If creation fails, an empty string is returned.

Parameters

prog	The program whose bitmaps directory are searched.

Returns

The path of the bitmaps directory.

Definition at line 201 of file Environment.cc.

                                                 {
    initialize();
    string path = DATA_DIR_NAME_ + FileSystem::DIRECTORY_SEPARATOR +
        BITMAPS_DIR_NAME_ + FileSystem::DIRECTORY_SEPARATOR + prog;
    pathsToUse_.assign(bitmapsPaths_.begin(), bitmapsPaths_.end());
    string bitmapsPath = pathTo(path);
    if (bitmapsPath == "" && newBitmapsFileDir_ != "") {
        if (FileSystem::createDirectory(newBitmapsFileDir_)) {
            return newBitmapsFileDir_;
        }
    }
    return bitmapsPath;
}

References BITMAPS_DIR_NAME_, bitmapsPaths_, FileSystem::createDirectory(), DATA_DIR_NAME_, FileSystem::DIRECTORY_SEPARATOR, initialize(), newBitmapsFileDir_, pathsToUse_, and pathTo().

Referenced by ProDe::bitmapsDirPath(), OSEdAboutDialog::createContents(), HelpBrowser::HelpBrowser(), and OSEdMainFrame::OSEdMainFrame().

Here is the call graph for this function:

codeCompressorPaths()

vector< string > Environment::codeCompressorPaths ( bool  libraryPathsOnly = false )

static

Returns the paths in which code compressor plugins are searched.

Parameters

libraryPathsOnly

When set to true, excludes CWD from search paths.

Returns

The paths in which code compressor plugins are searched.

Definition at line 571 of file Environment.cc.

                                                      {
 
    vector<string> paths;
 
    if (Environment::developerMode()) {
        string path = string(TCE_SRC_ROOT) + DS + "compressors";
        paths.push_back(path);
    } else {
        string base = Application::installationDir() + string(INSTALLATION_DIR) +
            "codecompressors" + DS + "base";
        string custom = Application::installationDir() + string(INSTALLATION_DIR)+
            "codecompressors" + DS + "custom";
        string personal = FileSystem::homeDirectory() + DS + ".openasip" + DS +
            "codecompressors" + DS + "custom";
 
        paths.push_back(base);
        paths.push_back(personal);
        paths.push_back(custom);
    }
    string cwd = FileSystem::currentWorkingDir();
    if (!libraryPathsOnly) paths.push_back(cwd);
    return paths;
}

References FileSystem::currentWorkingDir(), developerMode(), DS, FileSystem::homeDirectory(), INSTALLATION_DIR, and Application::installationDir().

Referenced by ProgramImageGenerator::availableCompressors(), and ProgramImageGenerator::createCompressor().

Here is the call graph for this function:

confPath()

TCEString Environment::confPath ( const std::string &  fileName )

static

Tries to locate the application's configuration file for reading.

First tries to find one in the user's homedir, if not found, uses the installed one (with defaults). Note: when writing (overriding) configuration files, one should call userConfDirPath() instead!

Parameters

fileName

The name of the configuration file.

Returns

The path of the configuration file.

Definition at line 277 of file Environment.cc.

                                               {
    initialize();
 
    TCEString userConf =
        FileSystem::homeDirectory() + DS + ".openasip" + DS + fileName;
    TCEString srcDirConf =
        TCEString(TCE_SRC_ROOT) + DS + CONF_DIR_NAME_ + DS + fileName;
 
    TCEString installedConf =
        Application::installationDir() + TCEString(INSTALLATION_DIR) +
        DS + CONF_DIR_NAME_ + DS + fileName;
    if (FileSystem::fileExists(userConf)) {
        return userConf;
    }
 
    if (Environment::developerMode() && FileSystem::fileExists(srcDirConf)) {
        return srcDirConf;
    } else if (FileSystem::fileExists(installedConf)) {
        return installedConf;
    }
 
    FileSystem::createFile(userConf);
    return userConf;
}

References CONF_DIR_NAME_, FileSystem::createFile(), developerMode(), DS, FileSystem::fileExists(), FileSystem::homeDirectory(), initialize(), INSTALLATION_DIR, and Application::installationDir().

Referenced by Proxim::loadOptions(), OSEd::OnInit(), and ProDe::OnInit().

Here is the call graph for this function:

dataDirPath()

string Environment::dataDirPath ( const std::string &  prog )

static

Tries to locate the directory where the application data is stored.

Returns the first absolute path of the directory where the data is found. If directory is not found and directory for new data file is given, it is created. If creation fails, an empty string is returned.

Parameters

prog	The program whose data directory is searched.

Returns

The path of data directory or an empty string.

Definition at line 176 of file Environment.cc.

                                              {
    initialize();
    string path = DATA_DIR_NAME_ + FileSystem::DIRECTORY_SEPARATOR + prog;
    pathsToUse_.assign(dataPaths_.begin(), dataPaths_.end());
    string dataPath = pathTo(path);
    if (dataPath == "" && newDataFileDir_ != "") {
        if (FileSystem::createDirectory(newDataFileDir_)) {
            return newDataFileDir_;
        }
    }
    return dataPath;
}

References FileSystem::createDirectory(), DATA_DIR_NAME_, dataPaths_, FileSystem::DIRECTORY_SEPARATOR, initialize(), newDataFileDir_, pathsToUse_, and pathTo().

Referenced by AlmaIFIntegrator::addAlmaifFiles(), AlmaIFIntegrator::connectCoreMemories(), ProGe::BlockSourceCopier::copyProcessorSpecific(), ProGe::BlockSourceCopier::copyShared(), ProGeTestBenchGenerator::copyTestBenchFiles(), ProGeTestBenchGenerator::createProcArchVhdl(), OSEdModifyBehaviorCmd::Do(), DefaultICDecoderGenerator::generate(), ProGeScriptGenerator::generateCompileStart(), ProGeScriptGenerator::generateSimulationStart(), ProGe::RV32MicroCodeGenerator::generateWrapper(), AlmaIFIntegrator::initAlmaifBlock(), Proxim::loadOptions(), ProDe::OnInit(), OperationPropertyDialog::onOpen(), MemoryGenerator::templatePath(), ProGe::TestBenchBlock::write(), ProGe::SinglePortSSRAMBlock::write(), ProGe::SinglePortByteMaskSSRAMBlock::write(), and ProGe::LoopBufferBlock::write().

Here is the call graph for this function:

decompressorPaths()

std::vector< std::string > Environment::decompressorPaths ( bool  libraryPathsOnly = false )

static

Returns the paths in which decompressor module definitions are searhed.

Parameters

libraryPathsOnly

When set to true, excludes CWD from search paths.

Returns

The paths in which decompressor module definitions are searched.

Definition at line 793 of file Environment.cc.

                                                    {
    vector<string> paths;
    if (!libraryPathsOnly) {
        paths.push_back(FileSystem::currentWorkingDir());
        paths.push_back(FileSystem::currentWorkingDir() + DS + "data");
    }
    return paths;
}

References FileSystem::currentWorkingDir(), and DS.

Referenced by IDF::MachineImplementation::checkImplFiles(), IDF::MachineImplementation::decompressorFile(), IDF::MachineImplementation::isLibraryImplFile(), IDF::MachineImplementation::makeImplFilesRelative(), and IDF::MachineImplementation::setDecompressorFile().

Here is the call graph for this function:

defaultICDecoderPlugin()

string Environment::defaultICDecoderPlugin ( )

static

Returns full path to the default IC/Decoder plugin file.

Returns

Full path to the defaultICDecoderPlugin.so

Definition at line 1012 of file Environment.cc.

                                    {
 
    try {
        std::string file = "DefaultICDecoderPlugin.so";
        vector<std::string> paths = icDecoderPluginPaths();
        std::string path = FileSystem::findFileInSearchPaths(paths, file);
 
        return path;
    } catch(FileNotFound e) {
        abortWithError(
            "Installation broken, DefaultICDecoderPlugin.so not found.");
        return ""; // just to remove a warning
    }
}

References abortWithError, FileSystem::findFileInSearchPaths(), and icDecoderPluginPaths().

Referenced by ProcessorImplementationWindow::ProcessorImplementationWindow().

Here is the call graph for this function:

defaultSchedulerConf()

string Environment::defaultSchedulerConf ( )

static

Returns full path to the default scheduler pass configuration file.

Returns

Full path to the default_scheduler.conf

Definition at line 957 of file Environment.cc.

                                  {
 
    if (Environment::developerMode()) {
        std::string srcPath =
            string(TCE_SRC_ROOT) + "/scheduler/passes/default_scheduler.conf";
        assert(
            FileSystem::fileExists(srcPath) &&
            "Build broken, default_scheduler.conf not found.");
        return srcPath;
    } else {
        std::string path = Application::installationDir() +
            string(INSTALLATION_DIR) + "/scheduler/passes/default_scheduler.conf";
        assert(
            FileSystem::fileExists(path) &&
            "Installation broken, default_scheduler.conf not found.");
        return path;
    }
}

References assert, developerMode(), FileSystem::fileExists(), INSTALLATION_DIR, and Application::installationDir().

Here is the call graph for this function:

defaultTextEditorPath()

string Environment::defaultTextEditorPath ( )

static

Returns default GUI text editor to be used, atm. for osed

Returns

Full path of default text editor, first from VISUAL and, failing that, from a list of popular GUI editors

Definition at line 1034 of file Environment.cc.

                                   {
 
    std::string editor = environmentVariable("VISUAL");
 
    if (editor.empty()) {
        // If env variable is empty, check a list of known GUI editors
        vector<std::string> editors;
        editors.push_back("gedit");    // Gnome
        editors.push_back("leafpad");  // LXDE
        editors.push_back("mousepad"); // XFCE (old)
        editors.push_back("kate");     // KDE
 
        // returns empty string if none found
        return findExecutableFromPATH(editors);
    }
 
    // test if env variable contained full path to text editor executable
    if (FileSystem::fileIsExecutable(editor)) {
        return editor;
    }
 
    // EDITOR and VISUAL doesn't have to contain full path
    // so let's search PATH enviroment variable to get the full path
    std::string testEditor = "";
    vector<std::string> paths;
    parsePathEnvVariable(paths);
    for (unsigned int i = 0; i < paths.size(); ++i) {
        testEditor = paths.at(i) + DS + editor;
        if (FileSystem::fileIsExecutable(testEditor)) {
            return testEditor;
        }
    }
 
    // no editor were found
    return "";
}

References DS, environmentVariable(), FileSystem::fileIsExecutable(), findExecutableFromPATH(), and parsePathEnvVariable().

Here is the call graph for this function:

developerMode()

bool Environment::developerMode ( )

static

Returns true in case TCE is running in developer mode.

The developer mode can be enabled by setting environment variable TCE_DEVEL_MODE to 1 and causes the following differences at TCE runtime:

• build directories are used as various search paths instead of installation prefix paths
• debug output printed to stderr

Definition at line 1166 of file Environment.cc.

                           {
    Environment::initialize();
    return developerMode_;
}

References developerMode_, and initialize().

Referenced by OperationBuilder::buildObject(), codeCompressorPaths(), confPath(), defaultSchedulerConf(), estimatorPluginPaths(), explorerPluginPaths(), hdbPaths(), icDecoderPluginPaths(), implementationTesterTemplatePaths(), includeDirPaths(), Application::initialize(), Application::isInstalled(), minimalADF(), oldGccSchedulerConf(), osalPaths(), pdfManual(), schedulerPluginPaths(), tceCompiler(), and vhdlPaths().

Here is the call graph for this function:

environmentVariable()

string Environment::environmentVariable ( const std::string &  variable )

static

Returns the value of the given environment variable.

An empty string is returned if the variable does not exist.

Parameters

variable

The environment variable whose value is required.

Returns

The value of the environment variable.

Definition at line 406 of file Environment.cc.

                                                          {
 
    char* varValue = getenv(variable.c_str());
    if (varValue == NULL) {
        return "";
    }
 
    return varValue;
}

Referenced by OperationBuilder::buildObject(), CompiledSimCompiler::CompiledSimCompiler(), ConflictDetectionCodeGenerator::ConflictDetectionCodeGenerator(), defaultTextEditorPath(), UserManualCmd::Do(), initialize(), Application::installationDir(), osalPaths(), parsePathEnvVariable(), and QuartusProjectGenerator::writeScripts().

errorLogFilePath()

string Environment::errorLogFilePath ( )

static

Tries to locate the error log file on system.

Returns the first absolute path where the file is found. If the file is not found and directory for the error log file is given, the directory and the error log file is created. If creation fails, an empty string is returned.

Returns

The path of the error log file.

Definition at line 323 of file Environment.cc.

                              {
    initialize();
    pathsToUse_.assign(errorPaths_.begin(), errorPaths_.end());
    string errorPath = pathTo(ERROR_LOG_FILE_NAME_);
    if (errorPath == "" && newErrorLogFileDir_ != "") {
        if (FileSystem::createDirectory(newErrorLogFileDir_)) {
            string filePath = newErrorLogFileDir_ +
                FileSystem::DIRECTORY_SEPARATOR + ERROR_LOG_FILE_NAME_;
            if (FileSystem::createFile(filePath)) {
                return filePath;
            }
        }
    }
    return errorPath;
}

References FileSystem::createDirectory(), FileSystem::createFile(), FileSystem::DIRECTORY_SEPARATOR, ERROR_LOG_FILE_NAME_, errorPaths_, initialize(), newErrorLogFileDir_, pathsToUse_, and pathTo().

Referenced by Application::initialize().

Here is the call graph for this function:

estimatorPluginPaths()

vector< string > Environment::estimatorPluginPaths ( )

static

Returns the paths in which estimator plugins are searched.

Returns

The paths in which estimator plugins are searched.

Definition at line 842 of file Environment.cc.

                                  {
 
    vector<string> paths;
    string base = Application::installationDir() + string(INSTALLATION_DIR) +
        "cost_estimator_plugins";
    string baseRF = Application::installationDir() + string(INSTALLATION_DIR) +
        "cost_estimator_plugins/rf";
    string baseFU = Application::installationDir() + string(INSTALLATION_DIR) +
        "cost_estimator_plugins/fu";
    string personal = FileSystem::homeDirectory() + DS + ".openasip" + DS +
        "cost_estimator_plugins";
    string custom = string(TCE_SRC_ROOT) + DS + "cost_estimator_plugins";
    string cwd = FileSystem::currentWorkingDir();
    string data = FileSystem::currentWorkingDir() + DS + "data";
 
    if (Environment::developerMode()) {
        paths.push_back(custom);
    } else {
        paths.push_back(base);
        paths.push_back(baseRF);
        paths.push_back(baseFU);
    }
    paths.push_back(personal);
    paths.push_back(cwd);
    paths.push_back(data);
    return paths;
}

References FileSystem::currentWorkingDir(), developerMode(), DS, FileSystem::homeDirectory(), INSTALLATION_DIR, and Application::installationDir().

Here is the call graph for this function:

explorerPluginPaths()

vector< string > Environment::explorerPluginPaths ( )

static

Returns the paths in which explorer plugins are searched.

Returns

The paths in which explorer plugins are searched.

Definition at line 809 of file Environment.cc.

                                 {
 
    vector<string> paths;
 
    if (Environment::developerMode()) {
        string srcBase = string(TCE_SRC_ROOT) + DS + "explorer";
        paths.push_back(srcBase);
    } else {
        string base = Application::installationDir() + string(INSTALLATION_DIR) +
            "explorer" + DS + "base";
        paths.push_back(base);
 
        string personal = FileSystem::homeDirectory() + DS + ".openasip" + DS +
            "explorer";
        paths.push_back(personal);
    }
 
    string cwd = FileSystem::currentWorkingDir();
    paths.push_back(cwd);
 
    string data = FileSystem::currentWorkingDir() + DS + "data";
    paths.push_back(data);
 
    return paths;
}

References FileSystem::currentWorkingDir(), developerMode(), DS, FileSystem::homeDirectory(), INSTALLATION_DIR, and Application::installationDir().

Referenced by DesignSpaceExplorer::getPlugins(), DesignSpaceExplorer::loadExplorerPlugin(), and printPlugins().

Here is the call graph for this function:

findExecutableFromPATH()

std::string Environment::findExecutableFromPATH ( const std::vector< std::string > &  execs )

staticprivate

Finds a first match of a given list of files from PATH env variable.

Finds a first executable match of a given list of files from paths in the PATH environment variable.

Parameters

execs

A list of file names, that are to be searched from PATH.

Returns

Full path of the executable found or a zero length string, in case nothing was found.

Definition at line 1109 of file Environment.cc.

                                                                     {
    vector<std::string> paths;
    parsePathEnvVariable(paths);
    for (unsigned int i = 0; i < paths.size(); ++i) {
        for (unsigned int j = 0; j < execs.size(); ++j) {
            std::string exec = paths.at(i) + DS + execs.at(j);
            if (FileSystem::fileIsExecutable(exec)) {
                return exec;
            }
        }
    }
    return "";
}

References DS, FileSystem::fileIsExecutable(), and parsePathEnvVariable().

Referenced by defaultTextEditorPath().

Here is the call graph for this function:

hdbPaths()

std::vector< std::string > Environment::hdbPaths ( bool  libraryPathsOnly = false )

static

Returns the paths in which hardware databases are searched.

Parameters

libraryPathsOnly

When set to true, excludes CWD from search paths.

Returns

The paths in which hardware databases are searched.

Definition at line 683 of file Environment.cc.

                                           {
 
    vector<string> paths;
    if (Environment::developerMode()) {
        string srcBase = string(TCE_SRC_ROOT) + DS + "hdb";
        paths.push_back(srcBase);
    } else {
        string instBase = Application::installationDir() +
            string(INSTALLATION_DIR) + "hdb";
        paths.push_back(instBase);
    }
    if (!libraryPathsOnly) {
        string cwd = FileSystem::currentWorkingDir();
        paths.push_back(cwd);
        paths.push_back(cwd + DS + "data");
    }
    return paths;
}

References FileSystem::currentWorkingDir(), developerMode(), DS, INSTALLATION_DIR, and Application::installationDir().

Referenced by IDF::MachineImplementation::checkImplFiles(), ProcessorImplementationWindow::doSaveIDF(), FUGen::findAbsolutePath(), Automagic::findHDBPath(), ProGeTools::findHDBPath(), IDF::UnitImplementationLocation::hdbFile(), IDF::MachineImplementation::icDecoderHDB(), IDF::MachineImplementation::isLibraryImplFile(), HDB::HDBRegistry::loadFromSearchPaths(), main(), IDF::MachineImplementation::makeHDBPathRelative(), IDF::MachineImplementation::makeImplFilesRelative(), IDF::MachineImplementation::setICDecoderHDB(), and AddIUFromHDBDialog::TransferDataToWindow().

Here is the call graph for this function:

hwModulePaths()

std::vector< std::string > Environment::hwModulePaths ( )

static

Returns the paths in which hardware modules are searched.

Returns

The paths in which hardware modules are searched.

Definition at line 669 of file Environment.cc.

                           {
    vector<string> paths;
    paths.push_back(FileSystem::currentWorkingDir());
    return paths;
}

References FileSystem::currentWorkingDir().

Here is the call graph for this function:

icDecoderPluginPaths()

vector< string > Environment::icDecoderPluginPaths ( bool  libraryPathsOnly = false )

static

Returns the paths in which IC/decoder plugins are searched.

Parameters

libraryPathsOnly

Set to true excludes CWD from search paths.

Returns

The paths in which IC/decoder plugins are searched.

Definition at line 635 of file Environment.cc.

                                                       {
 
    vector<string> paths;
 
    string base = Application::installationDir() + string(INSTALLATION_DIR) +
        "icdecoder_plugins" + DS + "base";
    string custom = Application::installationDir() + string(INSTALLATION_DIR)+
        "icdecoder_plugins" + DS + "custom";
    string personal = FileSystem::homeDirectory() + DS + ".openasip" + DS + 
        "icdecoder_plugins";
    string cwd = FileSystem::currentWorkingDir();
    string data = cwd + DS + "data";
    if (Environment::developerMode()) {
        // first find from the src tree to make the system tests etc.
        // to test the plugins in source base, not the installed plugins
        string path = string(TCE_SRC_ROOT) + DS + "icdecoder_plugins";
        paths.push_back(path);
    } else {
        paths.push_back(base);
        paths.push_back(personal);
        paths.push_back(custom);
    }
    if (!libraryPathsOnly) paths.push_back(cwd);
    if (!libraryPathsOnly) paths.push_back(data);
    return paths;
}

References FileSystem::currentWorkingDir(), developerMode(), DS, FileSystem::homeDirectory(), INSTALLATION_DIR, and Application::installationDir().

Referenced by IDF::MachineImplementation::checkImplFiles(), defaultICDecoderPlugin(), IDF::MachineImplementation::icDecoderPluginFile(), IDF::MachineImplementation::isLibraryImplFile(), GenerateProcessor::listICDecPluginParameters(), GenerateProcessorDialog::loadICDecoderGeneratorPlugin(), ProGe::ProGeUI::loadICDecoderGeneratorPlugin(), ProcessorImplementationWindow::loadICDecoderPlugin(), IDF::MachineImplementation::makeImplFilesRelative(), ComponentImplementationSelector::selectComponents(), and IDF::MachineImplementation::setICDecoderPluginFile().

Here is the call graph for this function:

iconDirPath()

string Environment::iconDirPath ( )

static

Tries to locate the directory where common toolbar icon files are stored.

Returns the first absolute path of the directory where the file is found. If icons directory is not found and a new directory is given, it is created. If creation fails, an empty string is returned.

Returns

The path of the icons directory.

Definition at line 225 of file Environment.cc.

                         {
    initialize();
    string path = DATA_DIR_NAME_ + FileSystem::DIRECTORY_SEPARATOR +
        ICON_DIR_NAME_;
    pathsToUse_.assign(bitmapsPaths_.begin(), bitmapsPaths_.end());
    string iconPath = pathTo(path);
    if (iconPath == "" && newIconFileDir_ != "") {
        if (FileSystem::createDirectory(newIconFileDir_)) {
            return newIconFileDir_;
        }
    }
    return iconPath;
}

References bitmapsPaths_, FileSystem::createDirectory(), DATA_DIR_NAME_, FileSystem::DIRECTORY_SEPARATOR, ICON_DIR_NAME_, initialize(), newIconFileDir_, pathsToUse_, and pathTo().

Referenced by AddFUFromHDBDialog::AddFUFromHDBDialog(), AddIUFromHDBDialog::AddIUFromHDBDialog(), AddRFFromHDBDialog::AddRFFromHDBDialog(), MainFrame::createToolbar(), and ProximMainFrame::createToolbar().

Here is the call graph for this function:

implementationTesterTemplatePaths()

std::vector< std::string > Environment::implementationTesterTemplatePaths ( )

static

Returns full paths to implementation tester vhdl testbench template directory

Returns

Paths to testbench templates

Definition at line 1129 of file Environment.cc.

                                                                    {
    std::vector<std::string> paths;
    if (Environment::developerMode()) {
        string path = string(TCE_SRC_ROOT) + DS + "data" + DS + "hdb";
        paths.push_back(path);
    }
    string path = Application::installationDir() + string(INSTALLATION_DIR) +
        "data" + DS + "hdb";
    paths.push_back(path);
    return paths;
}

References developerMode(), DS, INSTALLATION_DIR, and Application::installationDir().

Referenced by TestbenchGenerator::findVhdlTemplate().

Here is the call graph for this function:

includeDirPaths()

std::vector< std::string > Environment::includeDirPaths ( )

static

Returns path where installable tce include headers reside.

The list returned contains both post-installation paths and the paths to the original header files found in the source tree.

Returns

Paths where tce installable headers files reside.

Definition at line 348 of file Environment.cc.

                             {
    vector<string> includes;
    const std::string ROOT = string(TCE_SRC_ROOT);
    const std::string BASE = ROOT + DS + "src" + DS + "base";
    const std::string APPLIBS = ROOT + DS + "src" + DS + "applibs";
    const std::string BLD = string(TCE_BLD_ROOT);
 
    if (Environment::developerMode()) {
        includes.push_back(ROOT);
        includes.push_back(ROOT + DS + "src" + DS + "tools");
        includes.push_back(BASE + DS + "osal");
        includes.push_back(BASE + DS + "memory");
        includes.push_back(BASE + DS + "bem");
        includes.push_back(BASE + DS + "Graph");
        includes.push_back(BASE + DS + "idf");
        includes.push_back(BASE + DS + "mach");
        includes.push_back(BASE + DS + "program");
        includes.push_back(BASE + DS + "tpef");
        includes.push_back(BASE + DS + "umach");
        includes.push_back(APPLIBS + DS + "Simulator");
        includes.push_back(APPLIBS + DS + "mach");
        includes.push_back(APPLIBS + DS + "FSA");
        includes.push_back(TCE_BLD_ROOT);
    } else {
        includes.push_back(Application::installationDir() + DS + "include");
    }
 
    return includes;
}

References developerMode(), DS, and Application::installationDir().

Referenced by OperationBuilder::buildObject(), CompiledSimCompiler::compileFile(), and CompiledSimCodeGenerator::generateMakefile().

Here is the call graph for this function:

initialize()

void Environment::initialize ( )

static

Initializes the program environment.

Initializes all of the source directories the program needs.

Definition at line 95 of file Environment.cc.

                        {
 
    if (initialized_) {
        return;
    }
 
    developerMode_ =
        Environment::environmentVariable("TCE_DEVEL_MODE") == "1";
 
    errorPaths_.push_back(
        FileSystem::homeDirectory() +
        FileSystem::DIRECTORY_SEPARATOR + string(".openasip"));
 
    if (developerMode_) {
        schemaPaths_.push_back(string(TCE_SRC_ROOT));
        iconPaths_.push_back(string(TCE_SRC_ROOT));
        dataPaths_.push_back(string(TCE_SRC_ROOT));
        bitmapsPaths_.push_back(string(TCE_SRC_ROOT));
        manPaths_.push_back(
            string(TCE_SRC_ROOT) +
            FileSystem::DIRECTORY_SEPARATOR + string("doc"));
    } else {
        string instDir =
            Application::installationDir() + string(INSTALLATION_DIR);
        schemaPaths_.push_back(instDir);
        iconPaths_.push_back(instDir);
        dataPaths_.push_back(instDir);
        bitmapsPaths_.push_back(instDir);
        manPaths_.push_back(instDir);
    }
 
    string traceEnv = environmentVariable("TTASIM_TRACE_DIR");
    if (traceEnv != "") {
        if (!FileSystem::fileExists(traceEnv)) {
            if (!FileSystem::createDirectory(traceEnv)) {
                traceEnv = "";
            }
        }
    }
    simTraceDir_ = traceEnv;
 
    initialized_ = true;
}

References bitmapsPaths_, FileSystem::createDirectory(), dataPaths_, developerMode_, FileSystem::DIRECTORY_SEPARATOR, environmentVariable(), errorPaths_, FileSystem::fileExists(), FileSystem::homeDirectory(), iconPaths_, initialized_, INSTALLATION_DIR, Application::installationDir(), manPaths_, schemaPaths_, and simTraceDir_.

Referenced by bitmapsDirPath(), confPath(), dataDirPath(), developerMode(), errorLogFilePath(), iconDirPath(), manDirPath(), schemaDirPath(), and simTraceDirPath().

Here is the call graph for this function:

llvmtceCachePath()

string Environment::llvmtceCachePath ( )

static

Returns full path to the default LLVM backend plugin cache directory.

Definition at line 1087 of file Environment.cc.

                              {
 
    std::string path =
        FileSystem::homeDirectory() +
        FileSystem::DIRECTORY_SEPARATOR + string(".openasip") +
        FileSystem::DIRECTORY_SEPARATOR + string("tcecc") +
        FileSystem::DIRECTORY_SEPARATOR + string("cache");
 
    return path;
}

References FileSystem::DIRECTORY_SEPARATOR, and FileSystem::homeDirectory().

Referenced by LLVMTCECmdLineOptions::backendCacheDir(), and LLVMBackend::LLVMBackend().

Here is the call graph for this function:

longHDBPath()

TCEString Environment::longHDBPath ( const TCEString &  hdbPath )

static

Undoes the shortening done by shortHDBPath

Definition at line 731 of file Environment.cc.

                                                 {
    string sourceRoot = string("<source tree>") + DS;
    string installRoot = string("<install directory>") + DS;
    string cwd = string(".") + DS;
 
    TCEString longPath = hdbPath;
    if (hdbPath.startsWith(sourceRoot)) {
        int rootPathLength = sourceRoot.length();
        longPath = string(TCE_SRC_ROOT) + DS + hdbPath.substr(rootPathLength);
    } else if (hdbPath.startsWith(installRoot)) {
        int installDirLength = installRoot.length();
        longPath = Application::installationDir() + DS +
                    hdbPath.substr(installDirLength);
    } else if (hdbPath.startsWith(cwd)) {
        int cwdLength = cwd.length();
        longPath = FileSystem::currentWorkingDir() + DS +
                    hdbPath.substr(cwdLength);
    }
    return longPath;
}

References FileSystem::currentWorkingDir(), DS, Application::installationDir(), and TCEString::startsWith().

Referenced by BlockImplementationDialog::doOK(), AutoSelectImplementationsDialog::onFind(), and BlockImplementationDialog::onHDBSelection().

Here is the call graph for this function:

manDirPath()

string Environment::manDirPath ( const std::string &  prog )

static

Tries to locate the directory where the system's manual is stored.

Returns the first absolute path of the directory where the file is found. If no directory is found and a new directory for manual is given, it is created. If creation fails, an empty string is returned.

Parameters

prog	The program whose manual directory is searched.

Returns

The path of the manual directory.

Definition at line 250 of file Environment.cc.

                                             {
    initialize();
    string path = MAN_DIR_NAME_ + FileSystem::DIRECTORY_SEPARATOR + prog;
    pathsToUse_.assign(manPaths_.begin(), manPaths_.end());
    string manPath = pathTo(path);
    if (manPath == "" && newManFileDir_ != "") {
        if (FileSystem::createDirectory(newManFileDir_)) {
            return newManFileDir_;
        }
    }
    return manPath;
}

References FileSystem::createDirectory(), FileSystem::DIRECTORY_SEPARATOR, initialize(), MAN_DIR_NAME_, manPaths_, newManFileDir_, pathsToUse_, and pathTo().

Referenced by OSEdUserManualCmd::userManual().

Here is the call graph for this function:

minimalADF()

string Environment::minimalADF ( )

static

Returns the full path to the minimal.adf.

Definition at line 901 of file Environment.cc.

                        {
 
    if (Environment::developerMode()) {
        std::string srcPath =
            string(TCE_SRC_ROOT) + FileSystem::DIRECTORY_SEPARATOR +
            MINIMAL_ADF_SRC;
 
        assert(
            FileSystem::fileExists(srcPath) &&
            "Installation broken, minimal.adf not found");
        return srcPath;
    } else {
        std::string path = Application::installationDir() +
            string(INSTALLATION_DIR) + MINIMAL_ADF_INSTALLED;
 
        assert(
            FileSystem::fileExists(path) &&
            "Installation broken, minimal.adf not found");
        return path;
    }
}

References assert, developerMode(), FileSystem::DIRECTORY_SEPARATOR, FileSystem::fileExists(), INSTALLATION_DIR, Application::installationDir(), MINIMAL_ADF_INSTALLED, and MINIMAL_ADF_SRC.

Referenced by MinimalOpSetCheck::buildMinimalOpSet(), and MinimalOpSetCheck::fix().

Here is the call graph for this function:

oldGccSchedulerConf()

string Environment::oldGccSchedulerConf ( )

static

Returns full path to the old gcc scheduler pass configuration file.

This is the scheduler conf that is used to schedule code from the old gcc compiler.

Returns

Full path to the old_gcc.conf

Definition at line 986 of file Environment.cc.

                                 {
 
    if (Environment::developerMode()) {
        // first find from the src tree
        std::string srcPath =
            string(TCE_SRC_ROOT) + "/scheduler/passes/old_gcc.conf";
        assert(
            FileSystem::fileExists(srcPath) &&
            "Build broken, old_gcc.conf not found.");
        return srcPath;
    } else {
        std::string path = Application::installationDir() +
            string(INSTALLATION_DIR) + "/scheduler/passes/old_gcc.conf";
        assert(
            FileSystem::fileExists(path) &&
            "Installation broken, old_gcc.conf not found.");
        return path;
    }
}

References assert, developerMode(), FileSystem::fileExists(), INSTALLATION_DIR, and Application::installationDir().

Here is the call graph for this function:

opsetIncludeDir()

vector< string > Environment::opsetIncludeDir ( )

static

Returns the include dir needed to build base opset in compiling the distributed version of TCE

Definition at line 384 of file Environment.cc.

                             {
    string BASE = TCE_SRC_ROOT + DS + "src" + DS + "base";
    
    vector<string> includePaths;   
    includePaths.push_back(BASE + DS + "osal ");
    includePaths.push_back(BASE + DS + "tpef ");
    includePaths.push_back(BASE + DS + "memory ");
    includePaths.push_back(TCE_SRC_ROOT + DS + "src" + DS +  "tools");
    includePaths.push_back(TCE_SRC_ROOT);
 
    return includePaths;
}

References DS.

Referenced by OperationBuilder::buildObject().

osalPaths()

vector< string > Environment::osalPaths ( )

static

Returns the paths in which operation set files are searched.

The paths are returned in the order of preference. The user can override global operation definitions by redefining them in a local search path.

Returns

The paths in which operations are searched.

Definition at line 519 of file Environment.cc.

                       {
 
    vector<string> paths;
 
    // ./data
    string data = FileSystem::currentWorkingDir() + DS + "data";
 
    // tce/opset/base -- these are needed during newlib build,
    // specifically STDOUT is needed to build puts() correctly.
    string src = string(TCE_BLD_ROOT) + DS + "opset" + DS + "base";
 
    // default path for predefined and "standard" operations
    string basePath =
        Application::installationDir() + string(INSTALLATION_DIR) + "opset" +
        DS + "base";
    // path for user-local custom operations
    string userPath =
        FileSystem::homeDirectory() + DS + ".openasip" + DS + "opset" +
        DS + "custom";
    // path for system-wide, shared custom operations
    string customPath =
        Application::installationDir() + string(INSTALLATION_DIR) + "opset" +
        DS + "custom";
    // search path taken from environment
    string envPath = Environment::environmentVariable("TCE_OSAL_PATH");
    envPath = FileSystem::absolutePathOf(envPath);
    // as a last resort fall-back, operations are always searched in
    // in current working directory
    string cwd = FileSystem::currentWorkingDir();
 
    if (envPath != "")
        VectorTools::insertUnique(paths, envPath);
    VectorTools::insertUnique(paths, cwd);
    VectorTools::insertUnique(paths, data);
    if (Environment::developerMode()) {
        VectorTools::insertUnique(paths, src);
    } else {
        VectorTools::insertUnique(paths, userPath);
        VectorTools::insertUnique(paths, customPath);
        VectorTools::insertUnique(paths, basePath);
    }
 
    return paths;
}

References FileSystem::absolutePathOf(), FileSystem::currentWorkingDir(), developerMode(), DS, environmentVariable(), FileSystem::homeDirectory(), VectorTools::insertUnique(), INSTALLATION_DIR, and Application::installationDir().

Referenced by OSEdTreeView::constructTree(), OperationContainer::operationIndex(), OperationPoolPimpl::OperationPoolPimpl(), OSEdInfoView::pathView(), and OperationBuilder::xmlFilePath().

Here is the call graph for this function:

parsePathEnvVariable()

void Environment::parsePathEnvVariable ( std::vector< std::string > &  paths )

inlinestaticprivate

Returns Paths in PATH environment variable.

Returns

Paths in PATH environment variable.

Definition at line 1077 of file Environment.cc.

                                                             {
 
    std::string pathsEnv = environmentVariable("PATH");
    StringTools::chopString(pathsEnv, ":", paths);
}

References StringTools::chopString(), and environmentVariable().

Referenced by defaultTextEditorPath(), and findExecutableFromPATH().

Here is the call graph for this function:

pathTo()

string Environment::pathTo ( const std::string &  name )

staticprivate

Tries to locate the given directory or file on system.

Returns the first absolute path of the directory if the directory/file is found. In case the directory/file is not found in any of the search paths, returns an empty string.

@fixme this is not thread safe due to the use of pathsToUse_ member variable for data passing!

Parameters

name	The name of the searched directory/file.

Returns

The path of the directory/file.

Definition at line 444 of file Environment.cc.

                                         {
 
    // test the stored paths and try to open the file
    for (unsigned int i = 0; i < pathsToUse_.size(); ++i) {
        string path =
            pathsToUse_[i] + FileSystem::DIRECTORY_SEPARATOR + name;
 
        if (FileSystem::fileExists(path)) {
            return path;
        }
    }
 
    return "";
}

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

Referenced by bitmapsDirPath(), dataDirPath(), errorLogFilePath(), iconDirPath(), manDirPath(), and schemaDirPath().

Here is the call graph for this function:

pdfManual()

string Environment::pdfManual ( )

static

Returns full path to the TCE .pdf manual.

Returns

Full path to the TCE manual pdf.

Definition at line 877 of file Environment.cc.

                       {
 
    if (Environment::developerMode()) {
        std::string srcPath =
            string(TCE_SRC_ROOT) + FileSystem::DIRECTORY_SEPARATOR +
            PDF_MANUAL_SRC;
        assert(
            FileSystem::fileExists(srcPath) &&
            "Installation broken, minimal.adf not found");
        return srcPath;
    } else {
        std::string path = Application::installationDir() +
            string(INSTALLATION_DIR) + PDF_MANUAL_INSTALLED;
 
        if (!FileSystem::fileExists(path))
            debugLog("Installation broken, manual not found");
        return path;
    }
}

References assert, debugLog, developerMode(), FileSystem::DIRECTORY_SEPARATOR, FileSystem::fileExists(), INSTALLATION_DIR, Application::installationDir(), PDF_MANUAL_INSTALLED, and PDF_MANUAL_SRC.

Referenced by UserManualCmd::askFromUser(), and UserManualCmd::Do().

Here is the call graph for this function:

schedulerPluginPaths()

vector< string > Environment::schedulerPluginPaths ( )

static

Returns the paths in which scheduler plugins are searched.

Returns

The paths in which scheduler plugins are searched.

Definition at line 601 of file Environment.cc.

                                  {
 
    vector<string> paths;
 
    string base = Application::installationDir() + string(INSTALLATION_DIR) +
        "scheduler" + DS + "passes";
 
    string personal = FileSystem::homeDirectory() + DS + ".openasip" + DS +
        "scheduler" + DS + "passes";
 
    string srcBase = string(TCE_SRC_ROOT) + DS + "scheduler" + DS + "passes";
 
    string cwd = FileSystem::currentWorkingDir();
 
    if (Environment::developerMode()) {
        // first find from the src tree to make the system tests etc.
        // to test the plugins in source base, not the installed plugins
        paths.push_back(srcBase);
    } else {
        paths.push_back(base);
        paths.push_back(personal);
    }
    paths.push_back(cwd);
 
    return paths;
}

References FileSystem::currentWorkingDir(), developerMode(), DS, FileSystem::homeDirectory(), INSTALLATION_DIR, and Application::installationDir().

Here is the call graph for this function:

schemaDirPath()

string Environment::schemaDirPath ( const std::string &  prog )

static

Tries to locate the directory where the XML Schema file is stored.

Returns the first absolute path of the directory where the file is found. If directory for new data file is given, it is created and returned. If the directory can not be created, an empty string is returned.

Parameters

prog	The program whose Schema is searched.

Returns

The path of the Schema directory.

Definition at line 151 of file Environment.cc.

                                                {
    initialize();
    string path = SCHEMA_DIR_NAME_ + FileSystem::DIRECTORY_SEPARATOR + prog;
    pathsToUse_.assign(schemaPaths_.begin(), schemaPaths_.end());
    string schemaPath = pathTo(path);
    if (schemaPath == "" && newSchemaFileDir_ != "") {
        if (FileSystem::createDirectory(newSchemaFileDir_)) {
            return newSchemaFileDir_;
        }
    }
    return schemaPath;
}

References FileSystem::createDirectory(), FileSystem::DIRECTORY_SEPARATOR, initialize(), newSchemaFileDir_, pathsToUse_, pathTo(), SCHEMA_DIR_NAME_, and schemaPaths_.

Referenced by ADFSerializer::ADFSerializer(), BEMSerializer::BEMSerializer(), IDF::IDFSerializer::IDFSerializer(), and OperationSerializer::OperationSerializer().

Here is the call graph for this function:

setNewBitmapsFileDir()

void Environment::setNewBitmapsFileDir ( const std::string &  path )

static

Sets the value for new bitmaps file directory.

Parameters

path	The path for new bitmaps directory.

Definition at line 485 of file Environment.cc.

                                                       {
    newBitmapsFileDir_ = path;
}

References newBitmapsFileDir_.

setNewDataFileDir()

void Environment::setNewDataFileDir ( const std::string &  path )

static

Sets the value for new data file directory

Parameters

path	The path of new data file directory.

Definition at line 475 of file Environment.cc.

                                                    {
    newDataFileDir_ = path;
}

References newDataFileDir_.

setNewErrorLogFileDir()

void Environment::setNewErrorLogFileDir ( const std::string &  path )

static

Sets the path for new error log file directory.

Parameters

path	The path of new error log file directory.

Definition at line 505 of file Environment.cc.

                                                        {
    newErrorLogFileDir_ = path;
}

References newErrorLogFileDir_.

setNewManFileDir()

void Environment::setNewManFileDir ( const std::string &  path )

static

Sets the path for new manual file directory.

Parameters

path	The path of new manual file directory.

Definition at line 495 of file Environment.cc.

                                                   {
    newManFileDir_ = path;
}

References newManFileDir_.

setNewSchemaFileDir()

void Environment::setNewSchemaFileDir ( const std::string &  path )

static

Sets the value for new schema file directory.

Parameters

path	The path of new schema file directory.

Definition at line 465 of file Environment.cc.

                                                      {
    newSchemaFileDir_ = path;
}

References newSchemaFileDir_.

shortHDBPath()

TCEString Environment::shortHDBPath ( const TCEString &  hdbPath )

static

Shortens the given HDB path by replacing source tree, install directory or current working directory paths with human-readable aliases.

Definition at line 707 of file Environment.cc.

                                                  {
    string sourceRoot = string(TCE_SRC_ROOT) + DS;
    string installRoot = Application::installationDir() + DS;
    string cwd = FileSystem::currentWorkingDir() + DS;
 
    TCEString shortPath = hdbPath;
    if (hdbPath.startsWith(sourceRoot)) {
        int rootPathLength = sourceRoot.length();
        shortPath = "<source tree>" + DS + hdbPath.substr(rootPathLength);
    } else if (hdbPath.startsWith(installRoot)) {
        int installDirLength = installRoot.length();
        shortPath = "<install directory>" + DS +
                    hdbPath.substr(installDirLength);
    } else if (hdbPath.startsWith(cwd)) {
        int cwdLength = cwd.length();
        shortPath = "." + DS + hdbPath.substr(cwdLength);
    }
    return shortPath;
}

References FileSystem::currentWorkingDir(), DS, Application::installationDir(), and TCEString::startsWith().

Referenced by AutoSelectImplementationsDialog::AutoSelectImplementationsDialog(), BlockImplementationDialog::BlockImplementationDialog(), BlockImplementationDialog::onBrowse(), AutoSelectImplementationsDialog::onBrowse(), ProcessorImplementationWindow::updateFUList(), ProcessorImplementationWindow::updateImplementationLists(), and ProcessorImplementationWindow::updateRFList().

Here is the call graph for this function:

simTraceDirPath()

string Environment::simTraceDirPath ( )

static

Returns full path to ttasim trace dir if set using TTASIM_TRACE_DIR environment variable

Return full path to ttasim trace dir location if environment variable TTASIM_TRACE_DIR is pointing to valid dir. Empty string otherwise.

Definition at line 1149 of file Environment.cc.

                             {
    initialize();
    return simTraceDir_;
}

References initialize(), and simTraceDir_.

Referenced by SimulatorFrontend::loadProgram().

Here is the call graph for this function:

tceCompiler()

string Environment::tceCompiler ( )

static

Returns

Full path to the tce compiler tcecc.

Definition at line 928 of file Environment.cc.

                         {
 
    if (Environment::developerMode()) {
        std::string srcPath =
            string(TCE_SRC_ROOT) + "/src/bintools/Compiler/oacc";
 
        std::string llvmTceSrcPath =
            string(TCE_SRC_ROOT) + "/src/bintools/Compiler/llvm-tce/llvm-tce";
 
        assert(FileSystem::fileExists(srcPath) &&
               FileSystem::fileExists(llvmTceSrcPath) &&
               "Build broken, compiler paths not found.");
        return srcPath;
    } else {
        std::string path = Application::installationDir() + "/bin/oacc";
        assert(
            FileSystem::fileExists(path) &&
            "Installation broken: oacc not found.");
        return path;
    }
}

References assert, developerMode(), FileSystem::fileExists(), and Application::installationDir().

Referenced by CompileTools::compileAsC(), CompileTools::compileAsLLVM(), and DesignSpaceExplorer::schedule().

Here is the call graph for this function:

userConfPath()

TCEString Environment::userConfPath ( const std::string &  fileName )

static

Definition at line 303 of file Environment.cc.

                                                   {
    TCEString userConf =
        FileSystem::homeDirectory() + DS + ".openasip" + DS + fileName;
    if (!FileSystem::fileExists(userConf)) {
        FileSystem::createFile(userConf);
    }
    return userConf;
}

References FileSystem::createFile(), DS, FileSystem::fileExists(), and FileSystem::homeDirectory().

Referenced by OSEd::createDefaultOptions(), Proxim::createDefaultOptions(), SaveOptionsCmd::Do(), ProximQuitCmd::Do(), and OSEdOptionsDialog::onSave().

Here is the call graph for this function:

vhdlPaths()

std::vector< std::string > Environment::vhdlPaths ( const std::string &  hdbPath )

static

Returns the paths in which VHDL files are searched for.

Parameters

hdbPath

The path where the HDB file is, to be added to the search paths.

Returns

The paths in which VHDL files are searched for.

Definition at line 760 of file Environment.cc.

                                               {
 
    vector<string> paths;
 
    // Drop the name of hdb file from hdb path
    string hdbDir = FileSystem::directoryOfPath(hdbPath);
    paths.push_back(hdbDir);
    paths.push_back(hdbDir + DS + "vhdl");
 
    if (Environment::developerMode()) {
        string srcBase = string(TCE_SRC_ROOT) + DS + "hdb";
        paths.push_back(srcBase);
        paths.push_back(srcBase + DS + "vhdl");
    } else {
        string srcBase = Application::installationDir() +
            string(INSTALLATION_DIR) + "hdb";
        paths.push_back(srcBase);
        paths.push_back(srcBase + DS + "vhdl");
    }
    string cwd = FileSystem::currentWorkingDir();
    paths.push_back(cwd);
    paths.push_back(cwd + DS + "data");
    return paths;
}

References FileSystem::currentWorkingDir(), developerMode(), FileSystem::directoryOfPath(), DS, INSTALLATION_DIR, and Application::installationDir().

Referenced by ProGe::BlockSourceCopier::copyFiles(), BlockImplementationFileDialog::onBrowse(), and BlockImplementationFileDialog::onOK().

Here is the call graph for this function:

Member Data Documentation

BITMAPS_DIR_NAME_

const string Environment::BITMAPS_DIR_NAME_ = "bitmaps"

staticprivate

Name of the bitmaps directory.

Definition at line 117 of file Environment.hh.

Referenced by bitmapsDirPath().

bitmapsPaths_

vector< string > Environment::bitmapsPaths_

staticprivate

Bitmaps directory search paths.

Definition at line 136 of file Environment.hh.

Referenced by bitmapsDirPath(), iconDirPath(), and initialize().

CONF_DIR_NAME_

const string Environment::CONF_DIR_NAME_ = "conf"

staticprivate

Name of the configuration directory.

Definition at line 121 of file Environment.hh.

Referenced by confPath().

DATA_DIR_NAME_

const string Environment::DATA_DIR_NAME_ = "data"

staticprivate

Name of the data directory.

Definition at line 115 of file Environment.hh.

Referenced by bitmapsDirPath(), dataDirPath(), and iconDirPath().

dataPaths_

vector< string > Environment::dataPaths_

staticprivate

Data directory search paths.

Definition at line 134 of file Environment.hh.

Referenced by dataDirPath(), and initialize().

developerMode_

bool Environment::developerMode_ = false

staticprivate

Flag indicating whether TCE is executing in developer mode.

Definition at line 129 of file Environment.hh.

Referenced by developerMode(), and initialize().

ERROR_LOG_FILE_NAME_

const string Environment::ERROR_LOG_FILE_NAME_ = "error_log.log"

staticprivate

Name of the system error log file.

Definition at line 125 of file Environment.hh.

Referenced by errorLogFilePath().

errorPaths_

vector< string > Environment::errorPaths_

staticprivate

Error file search paths.

Definition at line 142 of file Environment.hh.

Referenced by errorLogFilePath(), and initialize().

ICON_DIR_NAME_

const string Environment::ICON_DIR_NAME_ = "icons"

staticprivate

Name of the toolbar icon directory.

Definition at line 123 of file Environment.hh.

Referenced by iconDirPath().

iconPaths_

vector< string > Environment::iconPaths_

staticprivate

Toolbar icon search paths.

Definition at line 140 of file Environment.hh.

Referenced by initialize().

initialized_

bool Environment::initialized_ = false

staticprivate

Flag indicating whether class has been initialized.

Definition at line 127 of file Environment.hh.

Referenced by initialize().

MAN_DIR_NAME_

const string Environment::MAN_DIR_NAME_ = "man"

staticprivate

Name of the manual directory.

Definition at line 119 of file Environment.hh.

Referenced by manDirPath().

manPaths_

vector< string > Environment::manPaths_

staticprivate

Man directory search paths.

Definition at line 138 of file Environment.hh.

Referenced by initialize(), and manDirPath().

MINIMAL_ADF_INSTALLED

const string Environment::MINIMAL_ADF_INSTALLED = "data/mach/minimal.adf"

staticprivate

Relative path to the installed minimal.adf.

Definition at line 168 of file Environment.hh.

Referenced by minimalADF().

MINIMAL_ADF_SRC

const string Environment::MINIMAL_ADF_SRC = "data/mach/minimal.adf"

staticprivate

Relative path to the minimal.adf in source tree.

Definition at line 170 of file Environment.hh.

Referenced by minimalADF().

newBitmapsFileDir_

string Environment::newBitmapsFileDir_ = ""

staticprivate

Directory for new bitmaps file.

Definition at line 151 of file Environment.hh.

Referenced by bitmapsDirPath(), and setNewBitmapsFileDir().

newConfFile_

string Environment::newConfFile_ = ""

staticprivate

Directory for new configure file.

Definition at line 157 of file Environment.hh.

newDataFileDir_

string Environment::newDataFileDir_ = ""

staticprivate

Directory for new data file.

Definition at line 149 of file Environment.hh.

Referenced by dataDirPath(), and setNewDataFileDir().

newErrorLogFileDir_

string Environment::newErrorLogFileDir_ = ""

staticprivate

Directory for new error log file.

Definition at line 159 of file Environment.hh.

Referenced by errorLogFilePath(), and setNewErrorLogFileDir().

newIconFileDir_

string Environment::newIconFileDir_ = ""

staticprivate

Directory for new icon file.

Definition at line 153 of file Environment.hh.

Referenced by iconDirPath().

newManFileDir_

string Environment::newManFileDir_ = ""

staticprivate

Directory for new manual file.

Definition at line 155 of file Environment.hh.

Referenced by manDirPath(), and setNewManFileDir().

newSchemaFileDir_

string Environment::newSchemaFileDir_ = ""

staticprivate

Directory for new schema file.

Definition at line 147 of file Environment.hh.

Referenced by schemaDirPath(), and setNewSchemaFileDir().

pathsToUse_

vector< string > Environment::pathsToUse_

staticprivate

Paths used in a particular search.

Definition at line 144 of file Environment.hh.

Referenced by bitmapsDirPath(), dataDirPath(), errorLogFilePath(), iconDirPath(), manDirPath(), pathTo(), and schemaDirPath().

PDF_MANUAL_INSTALLED

const string Environment::PDF_MANUAL_INSTALLED = "manual/OpenASIP_manual.pdf"

staticprivate

Relative path to the installed TCE .pdf manual.

Definition at line 164 of file Environment.hh.

Referenced by pdfManual().

PDF_MANUAL_SRC

const string Environment::PDF_MANUAL_SRC = "manual/OpenASIP_manual.pdf"

staticprivate

Relative path to the TCE .pdf manual in source tree.

Definition at line 166 of file Environment.hh.

Referenced by pdfManual().

SCHEMA_DIR_NAME_

const string Environment::SCHEMA_DIR_NAME_ = "data"

staticprivate

Name of the XML Schema directory.

Definition at line 113 of file Environment.hh.

Referenced by schemaDirPath().

schemaPaths_

vector< string > Environment::schemaPaths_

staticprivate

Schema directory search paths.

Definition at line 132 of file Environment.hh.

Referenced by initialize(), and schemaDirPath().

simTraceDir_

string Environment::simTraceDir_ = ""

staticprivate

Directory to store ttasim traces.

Definition at line 161 of file Environment.hh.

Referenced by initialize(), and simTraceDirPath().

---

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

• Environment.hh
• Environment.cc