#include <FileSystem.hh>

Collaboration diagram for FileSystem:

Static Public Member Functions
static bool	fileExists (const std::string fileName)

static bool	fileIsWritable (const std::string fileName)

static bool	fileIsReadable (const std::string fileName)

static bool	fileIsExecutable (const std::string fileName)

static bool	fileIsCreatable (const std::string fileName)

static bool	fileIsDirectory (const std::string fileName)

static std::string	directoryOfPath (const std::string fileName)

static std::string	fileOfPath (const std::string pathName)

static bool	isAbsolutePath (const std::string &pathName)

static bool	isRelativePath (const std::string &pathName)

static bool	isPath (const std::string &pathName)

static std::string	fileExtension (const std::string &fileName)

static std::string	fileNameBody (const std::string &fileName)

static std::string	absolutePathOf (const std::string &pathName)

static std::string	currentWorkingDir ()

static bool	changeWorkingDir (const std::string &path)

static std::string	homeDirectory ()

static bool	setFileExecutable (const std::string fileName)

static std::time_t	lastModificationTime (const std::string &filePath)

static uintmax_t	sizeInBytes (const std::string &filePath)

static bool	runShellCommand (const std::string command)

static void	globPath (const std::string &pattern, std::vector< std::string > &filenames)

static std::string	expandTilde (const std::string &stringWithTilde)

static bool	createDirectory (const std::string &path)

static std::string	createTempDirectory (const std::string &path="/tmp", const std::string &tempDirPrefix="tmp_tce_")

static bool	createFile (const std::string &file)

static bool	removeFileOrDirectory (const std::string &path)

static void	copy (const std::string &source, const std::string &target)

static std::string	findFileInSearchPaths (const std::vector< std::string > &searchPaths, const std::string &file)

static std::vector< std::string >	directoryContents (const std::string &directory, const bool absolutePaths=true)

static std::vector< std::string >	directorySubTrees (const std::string &directory)

static bool	findFileInDirectoryTree (const Path &startDirectory, const std::string &fileName, Path &pathFound)

template<typename STLCONT >
static bool	findFromDirectory (const std::string &regex, const std::string &directory, STLCONT &found)

template<typename STLCONT >
static bool	findFromDirectoryRecursive (const std::string &regex, const std::string &directory, STLCONT &found)

static bool	compareFileNames (const std::string &first, const std::string &second, const std::string &rootDirectory)

static bool	relativeDir (const std::string &baseDir, std::string &toRelDir)

static bool	makeRelativePath (const std::vector< std::string > &searchPaths, const std::string &basePath, std::string &toRelPath)

static bool	readBlockFromFile (const std::string &sourceFile, const std::string &blockStartRE, const std::string &blockEndRE, std::string &readBlock, const bool includeMatchingLines=true)

static bool	appendReplaceFile (const std::string &targetFile, const std::string &ARStartRE, const std::string &writeToFile, const std::string &AREndRE="", const bool discardBlockBorder="true")

static int	countLines (const std::string &filepath)

Static Public Attributes
static const std::string	DIRECTORY_SEPARATOR

static const std::string	CURRENT_DIRECTORY = "."

static const std::string	STRING_WILD_CARD = "*"

Detailed Description

Portability layer for platform-dependent functions that access the filesystem.

Definition at line 86 of file FileSystem.hh.

Member Function Documentation

◆ absolutePathOf()

string FileSystem::absolutePathOf ( const std::string & pathName )

static

Returns the given path as absolute path.

Parameters

pathName The path.

Returns: The absolute path.

Definition at line 303 of file FileSystem.cc.

                                                     {
     string absolutePath("");
     if (isAbsolutePath(pathName)) {
         absolutePath = pathName;
     } else {
         absolutePath = currentWorkingDir() + DIRECTORY_SEPARATOR + pathName;
     }
     Path path(absolutePath);
     path.normalize();
     return path.string();
 }

Referenced by HDB::HDBRegistry::addHDB(), PlatformIntegrator::createOutputDir(), ProcessorImplementationWindow::doSaveIDF(), DSDBManager::dsdbFile(), ProGeScriptGenerator::fetchFiles(), HDB::HDBManager::fileName(), GenerateProcessor::getOutputDir(), HDB::HDBRegistry::hasHDB(), HDB::HDBRegistry::hdb(), ImplementationTester::ImplementationTester(), ProGe::ProGeUI::integrateProcessor(), HDB::HDBRegistry::loadFromSearchPaths(), Environment::osalPaths(), PlatformIntegrator::outputFilePath(), PlatformIntegrator::progeFilePath(), PlatformIntegrator::setSharedOutputDir(), and ProGeOptions::validate().

◆ appendReplaceFile()

bool FileSystem::appendReplaceFile	(	const std::string &	targetFile,
		const std::string &	ARStartRE,
		const std::string &	writeToFile,
		const std::string &	AREndRE = `""`,
		const bool	discardBlockBorder = `"true"`
	)

static

Appends to specified place in file, can replace a section.

Doesn't use temp files so uses lot of memory for big files.

Parameters

targetFile	File to be edited.
ARStartRE	Regex that matches the line where appending starts.
writeToFile	String that is written to the file.
AREndRE	Regex that matches last line that is replaced or deleted if writeToFile string contains less lines than is between start and end matches.
discardBlockBorder	If true Regex matching lines are replaced or deleted.

Returns: True if something was writen to the file, otherwise false.

Definition at line 958 of file FileSystem.cc.

                                    {
  
     const int LINESIZE = 1000;
     char line[LINESIZE];
     
     const boost::regex reStart(ARStartRE, 
         boost::regex::perl|boost::regex::icase);
     boost::regex reEnd;
     if (!AREndRE.empty()) {
         reEnd = boost::regex(AREndRE, boost::regex::perl|boost::regex::icase);
     }
     boost::regex re = reStart;
     
     string::const_iterator begin;
     string::const_iterator end;
     string stemp = "";
     string endFile = "";
     int blockStartPos = -1;
     std::fstream fs(targetFile.c_str(), std::fstream::in | std::fstream::out);
     boost::match_results<string::const_iterator> matches;
  
     bool beforeBlock = true;
     bool afterBlock = false;
     while (fs.good()) {
  
         fs.getline(line, LINESIZE-1);
  
         if (fs.eof()) {
             if (blockStartPos != -1) {
                 fs.clear();
                 fs.seekp(blockStartPos); 
                 fs.seekg(blockStartPos); 
             } else {
                 // no place of appending was found, ARStartRE didn't match any
                 // line
                 fs.close();
                 return false;
             }
  
             if (!fs.good()) {
                 fs.close();
                 return false;
             }
  
             fs.write(writeToFile.c_str(), writeToFile.length());
             fs.write(endFile.c_str(), endFile.length());
  
             if (truncate(targetFile.c_str(), fs.tellp()) != 0) {
                 abortWithError("truncate failed!");
             }
  
             break;
         }
  
         stemp = string(line);
         begin = stemp.begin();
         end = stemp.end();
  
         // test if found block border
         if (!afterBlock && boost::regex_search(begin, end, re)) {
             if (beforeBlock) {
                 // to inside replace block
                 beforeBlock = false;
                 // if no replace block end then no searching for it
                 afterBlock = AREndRE.empty() ? true : afterBlock;
  
                 if (discardBlockBorder) {
                     blockStartPos = static_cast<int>(fs.tellg()) - 
                         static_cast<int>(fs.gcount());
                 } else {
                     blockStartPos = fs.tellg();
                 }
                 re = reEnd;
             } else {
                 // to outside replace block
                 if (!discardBlockBorder) {
                     endFile.append(stemp + "\n");
                 }
                 afterBlock = true;
             }
         } else if (afterBlock) { 
             // outside replace block
             endFile.append(stemp + "\n");
         }
     }
  
     fs.close();
     return true;
 }

References abortWithError.

Referenced by ProGeTestBenchGenerator::createProcArchVhdl().

◆ changeWorkingDir()

bool FileSystem::changeWorkingDir ( const std::string & path )

static

Changes the working directory to a new one

Parameters

path	The new working directory to be set

Returns: true on success, false on error

Definition at line 185 of file FileSystem.cc.

                                                   {
     return (chdir(path.c_str()) == 0);
 }

Referenced by GhdlSimulator::compile(), ModelsimSimulator::compile(), GhdlSimulator::simulate(), and ImplementationSimulator::~ImplementationSimulator().

◆ compareFileNames()

bool FileSystem::compareFileNames	(	const std::string &	first,
		const std::string &	second,
		const std::string &	rootDirectory
	)

static

Compares two file names considering path.

Compares two strings representing file names that can be with absolut or relative paths. Relative paths are interpreted against given root directory parameter.

Parameters

first	File name to be compared.
second	File name to be compared.
rootDirectory	Base dir for relative paths in file names.

Returns: True if file names are same considering path, otherwise false.

Definition at line 724 of file FileSystem.cc.

                                     {
     
     std::string testRootDir = rootDirectory;
     if (rootDirectory.substr(rootDirectory.size()-1) != DIRECTORY_SEPARATOR) {
         testRootDir += DIRECTORY_SEPARATOR;    
     } 
  
     if (first == second) {
         return true;
     }
  
     if (FileSystem::isRelativePath(first) && 
         FileSystem::isRelativePath(second)) {
         return false; 
     } else if (FileSystem::isRelativePath(first)) {
         return ((testRootDir + first) == second) ? true : false;
     } else if (FileSystem::isRelativePath(second)) {
         return ((testRootDir + second) == first) ? true : false;
     }
  
     return false;
 }

References isRelativePath().

Referenced by ProGeScriptGenerator::sortFilesFirst(), and ProGeScriptGenerator::sortFilesLast().

Here is the call graph for this function:

◆ copy()

void FileSystem::copy	(	const std::string &	source,
		const std::string &	target
	)

static

Copies source file to target file.

Copying can fail for the following reasons: Source file doesn't exist, source is directory, or target string is empty.

If target file already exists then it's removed and source file is copied in its place. If target file is a existing directory copies the file under it without changing the files name.

Parameters

source	File to be copied.
target	Target of the copy operation.

Exceptions

IOException in case the copying failed.

Definition at line 524 of file FileSystem.cc.

                                                                  {
     namespace fs = boost::filesystem;
     Path sourcePath(source);
     Path targetPath(target);
  
     try {
         if (fs::exists(targetPath)) {
             if(!fileIsDirectory(target)) {
                 fs::remove(targetPath);
             } else {
                 fs::path::iterator lastIt = --(sourcePath.end());
                 targetPath /= *lastIt;
                 // The target directory may have already a file by name
                 if(!fileIsDirectory(targetPath.string())) {
                     fs::remove(targetPath);
                 }
             }
         }
         fs::copy_file(sourcePath, targetPath);
     } catch (boost::filesystem::filesystem_error e) {
         throw IOException(
             __FILE__, __LINE__, __func__, 
             (boost::format(
                 "Unable to copy '%s' to '%s'") %
                 sourcePath.string() % targetPath.string()).str());                           
     }
 }

References __func__.

Referenced by ProGe::BlockSourceCopier::copyFiles(), copyImageToTb(), FUGen::copyImplementation(), AlmaIFIntegrator::copyPlatformFile(), ProGe::BlockSourceCopier::copyProcessorSpecific(), ProGe::BlockSourceCopier::copyShared(), ProGeTestBenchGenerator::copyTestBenchFiles(), OSEdModifyBehaviorCmd::Do(), XilinxBlockRamGenerator::generateComponentFile(), OperationBuilder::installDataFile(), and OperationPropertyDialog::onOpen().

◆ countLines()

int FileSystem::countLines ( const std::string & filepath )

static

Counts lines in a file.

Parameters

filepath Path to the file.

Returns: The count if successful. On error returns negative number.

Definition at line 1060 of file FileSystem.cc.

                                                 {
     std::ifstream fileStream(filepath);
     if (!fileStream.is_open()) {
         return -1;
     }
     unsigned count = 0;
     std::string dummyLine;
     while (std::getline(fileStream, dummyLine)) {
         count++;
     }
     return count;
 }

◆ createDirectory()

bool FileSystem::createDirectory ( const std::string & path )

static

Creates a directory if it doesn't already exist.

All non-existing directories in the path are created.

Parameters

path	The path of directory.

Returns: True if directory is created, false otherwise.

Definition at line 400 of file FileSystem.cc.

                                                  {
     std::string p = path;
     if (!isAbsolutePath(p)) {
         p = absolutePathOf(p);
     }
     Path DS(DIRECTORY_SEPARATOR);
     Path orPath(p.substr(1));
     string origPath = orPath.string();
     string currentPath = DS.string();
     while (origPath.size() > 0) {
         string::size_type pos = origPath.find(DS.string());
         if (pos == string::npos) {
             currentPath += origPath;
             origPath = "";
         } else {
             currentPath += origPath.substr(0, pos);
             origPath.replace(0, pos + 1, "");
         }
         try {
             Path dirPath(currentPath);
             if (!boost::filesystem::exists(dirPath)) {
                 boost::filesystem::create_directory(dirPath);
             }
         } catch (...) {
             // directory creation failed, probably because of lacking rights
             return false;
         }
         currentPath += DS.string();
     }
     return true;
 }

References DS.

Referenced by Environment::bitmapsDirPath(), ProGe::BlockSourceCopier::copyFiles(), FUGen::copyImplementation(), ProGe::BlockSourceCopier::copyProcessorSpecific(), ProGeTestBenchGenerator::copyTestBenchFiles(), FUGen::createImplementationFiles(), PlatformIntegrator::createOutputDir(), LLVMBackend::createPlugin(), ImplementationSimulator::createWorkDir(), Environment::dataDirPath(), OSEdAddModuleCmd::Do(), Environment::errorLogFilePath(), ProGe::ProcessorGenerator::generateProcessor(), Environment::iconDirPath(), Environment::initialize(), OperationBuilder::installDataFile(), ProGe::BlockSourceCopier::instantiateHDLTemplate(), OSEdAddModuleCmd::isEnabled(), Environment::manDirPath(), Environment::schemaDirPath(), ProGe::TestBenchBlock::write(), and ProGe::NetlistBlock::write().

◆ createFile()

bool FileSystem::createFile ( const std::string & file )

static

Creates a file if it doesn't already exist.

Parameters

file	The name of the file.

Returns: True if file is created, false otherwise.

Definition at line 468 of file FileSystem.cc.

                                             {
  
     Path filePath(file);
     string fileName = filePath.string();
  
     if (fileExists(file)) {
         return true;
     }
  
     if (fileIsCreatable(fileName)) {
         FILE* f = fopen(fileName.c_str(), "w");
         fclose(f);
         return true;
     } else {
         return false;
     }
 }

Referenced by Environment::confPath(), createCompressor(), ProGeScriptGenerator::createExecutableFile(), ProGeTestBenchGenerator::createFile(), createMauPkg(), Environment::errorLogFilePath(), ProGe::ProcessorGenerator::generateGlobalsPackage(), DefaultDecoderGenerator::generateInstructionDecoder(), DefaultICGenerator::generateInterconnectionNetwork(), DefaultICGenerator::generateSocket(), OSEdAddOperationCmd::isEnabled(), OSEdAddModuleCmd::isEnabled(), main(), and Environment::userConfPath().

◆ createTempDirectory()

std::string FileSystem::createTempDirectory	(	const std::string &	path = `"/tmp"`,
		const std::string &	tempDirPrefix = `"tmp_tce_"`
	)

static

Creates a temporary directory to the given path

Parameters

path	Path to create the temporary directory in
tempDirPrefix	Prefix string before randomly generated string part.

Returns: Full path to the generated temporary directory. Empty string on error.

Definition at line 441 of file FileSystem.cc.

                                     {
     const int RANDOM_CHARS = 10;
     const string DS(DIRECTORY_SEPARATOR);
     string tempDir = path + DS + tempDirPrefix;
     
     for (int i = 0; i < RANDOM_CHARS || fileExists(tempDir); ++i) {
         tempDir += static_cast<char>(MathTools::random('0', '9'));
         tempDir += static_cast<char>(MathTools::random('a', 'z'));
         tempDir += static_cast<char>(MathTools::random('A', 'Z'));
     }
     
     if (!createDirectory (tempDir)) {
         return "";
     } else {
         return tempDir;
     }
 }

References DS, and MathTools::random().

Referenced by CompileTools::compileAsC(), CompileTools::compileAsLLVM(), ImplementationTester::createTempDir(), CompiledSimController::reset(), DesignSpaceExplorer::schedule(), and OperationDAGDialog::updateDAG().

Here is the call graph for this function:

◆ currentWorkingDir()

std::string FileSystem::currentWorkingDir ( )

static

Returns the current working directory.

Returns: The current working directory or, in case of error, an empty string.

Definition at line 142 of file FileSystem.cc.

                               {
  
     // the amount of bytes to stretch the char buffer if the path doesn't
     // fit in it
     const int increment = 100;
     int bufSize = 200;
     char* buf = new char[bufSize];
  
     // sets errno to ERANGE if buffer was too small
     char* retValue = getcwd(buf, bufSize);
  
     // grow the buffer until the path fits in it
     while (retValue == NULL && errno == ERANGE) {
         delete[] buf;
         bufSize += increment;
         buf = new char[bufSize];
         retValue = getcwd(buf, bufSize);
     }
  
     std::string dirName = "";
     if (retValue == NULL) {
  
         std::string procName = "FileSystem::currentWorkingDir";
         std::string errorMsg = "Current working directory cannot be read.";
         Application::writeToErrorLog(__FILE__, __LINE__, procName, errorMsg);
  
         assert(errno == EACCES);
     } else {
         dirName = buf;
     }
  
     delete[] buf;
     Path path(dirName);
     return path.string();
 }

References assert, and Application::writeToErrorLog().

Referenced by OperationBuilder::behaviorFile(), OperationBuilder::buildObject(), IDF::MachineImplementation::checkImplFiles(), Environment::codeCompressorPaths(), CompileTools::compileAsC(), CompileTools::compileAsLLVM(), Environment::decompressorPaths(), ProcessorImplementationWindow::doSaveIDF(), Environment::estimatorPluginPaths(), Environment::explorerPluginPaths(), GenerateProcessor::generateProcessor(), GenerateProcessor::getOutputDir(), Environment::hdbPaths(), Environment::hwModulePaths(), Environment::icDecoderPluginPaths(), ImplementationSimulator::ImplementationSimulator(), XMLSerializer::initializeParser(), Environment::longHDBPath(), main(), Environment::osalPaths(), Environment::schedulerPluginPaths(), Environment::shortHDBPath(), TTASimulatorCLI::TTASimulatorCLI(), Environment::vhdlPaths(), and OperationBuilder::xmlFilePath().

Here is the call graph for this function:

◆ directoryContents()

std::vector< std::string > FileSystem::directoryContents	(	const std::string &	directory,
		const bool	absolutePaths = `true`
	)

static

Returns the files found in the given directory.

Parameters

directory The directory.

Returns: Vector containing the files.

Exceptions

FileNotFound If the given directory does not exist.

Definition at line 600 of file FileSystem.cc.

                                                           {
     try {
         std::vector<std::string> contents;
         // default construction yields past the end
         boost::filesystem::directory_iterator end_iter;
         
         if (directory != "") {
             Path path(directory);
             for (boost::filesystem::directory_iterator iter(path); 
                  iter != end_iter; iter++) {
                 if (absolutePaths) {
                     contents.push_back(absolutePathOf(iter->path().string()));
                 } else {
                     contents.push_back(iter->path().string());
                 }
  
             }
         } else {
             for (boost::filesystem::directory_iterator iter(
                      boost::filesystem::current_path()); 
                  iter != end_iter; iter++) {
                 if (absolutePaths) {
                     contents.push_back(absolutePathOf(iter->path().string()));
                 } else {
                     contents.push_back(iter->path().string());
                 }
             }
         }
         
         return contents;
  
     } catch (const boost::filesystem::filesystem_error& e) {
         throw FileNotFound(__FILE__, __LINE__, __func__, e.what());
     }
 }

References __func__.

Referenced by ProgramImageGenerator::availableCompressors(), ProGeScriptGenerator::fetchFiles(), HDB::HDBRegistry::loadFromSearchPaths(), and PlatformIntegrator::progeOutputHdlFiles().

◆ directoryOfPath()

std::string FileSystem::directoryOfPath ( const std::string fileName )

static

Returns the path part of the given file name.

Parameters

fileName A file name with a (partial or absolute) path.

Returns: Path part of the file name.

Definition at line 79 of file FileSystem.cc.

                                                     {
  
     Path origString(fileName);
     string file = origString.string();
     Path DS(DIRECTORY_SEPARATOR);
     string::size_type lastPathPos = file.rfind(DS.string());
     if (lastPathPos == string::npos) {
         return CURRENT_DIRECTORY;
     }
  
     string dirPath = file.substr(0, lastPathPos);
     Path path(dirPath);
     return path.string();
 }

References DS.

Referenced by CompiledSimulation::compileAndLoadFunction(), CompiledSimCompiler::compileFile(), ImplementationTester::createListOfSimulationFiles(), IDF::MachineImplementation::decompressorFile(), ProcessorImplementationWindow::doSaveIDF(), FUGen::findAbsolutePath(), IDF::UnitImplementationLocation::hdbFile(), IDF::MachineImplementation::icDecoderHDB(), IDF::MachineImplementation::icDecoderPluginFile(), ImplementationSimulator::ImplementationSimulator(), ProGe::ProGeUI::loadProcessorConfiguration(), SimulatorFrontend::loadProcessorConfiguration(), main(), BlockImplementationFileDialog::onBrowse(), OSEdOptionsDialog::onBrowse(), MDFDocument::openCFG(), OperationModule::OperationModule(), OperationModule::operator=(), IDF::MachineImplementation::setDecompressorFile(), IDF::MachineImplementation::setICDecoderHDB(), IDF::MachineImplementation::setICDecoderPluginFile(), and Environment::vhdlPaths().

◆ directorySubTrees()

std::vector< std::string > FileSystem::directorySubTrees ( const std::string & directory )

static

Returns all the sub-directories found starting from the given directory. Uses recursion to find out all the possible sub-directory levels as well.

Parameters

directory The directory where to search. Not listed in the results!

Returns: Vector containing the sub-directories (and their sub-dirs, and...).

Note: This function will not search the directories containing "." !

Exceptions

FileNotFound If the given directory does not exist.

Definition at line 647 of file FileSystem.cc.

                                                         {
     std::vector<std::string> subTrees;
     
     try {    
         directory_iterator end_itr;
     
         for (directory_iterator itr(directory); itr != end_itr; ++itr) {
             if (is_directory(*itr) && exists(*itr) && 
                 (*itr).path().string().find(".") == string::npos) {
                 subTrees.push_back((*itr).path().string());
                 
                 std::vector<std::string> subSubTrees = 
                     directorySubTrees((*itr).path().string());
                     
                 for (size_t i = 0; i < subSubTrees.size(); ++i) {
                     subTrees.push_back(subSubTrees.at(i));
                 }
             }
         }
     } catch (const boost::filesystem::filesystem_error& e) {
         throw FileNotFound(__FILE__, __LINE__, __func__, e.what());
     }        
         
     return subTrees;
 }

References __func__.

◆ expandTilde()

string FileSystem::expandTilde ( const std::string & stringWithTilde )

static

Replaces "~/" with "$HOME/". Doesn't replace ~user.

Parameters

stringWithTilde A string containing tilde to expanded.

Returns: The string with tilde expanded.

Definition at line 217 of file FileSystem.cc.

                                                         {
     string withoutTilde = stringWithTilde;
     if (withoutTilde == "~" || withoutTilde.substr(0, 2) == "~/") {
         withoutTilde.erase(0, 1);
         withoutTilde.insert(0, FileSystem::homeDirectory());
  
     }
     return withoutTilde;
 }

References homeDirectory().

Referenced by ConfCommand::execute(), MachCommand::execute(), ProgCommand::execute(), GenerateProcessor::getOutputDir(), IDF::UnitImplementationLocation::hdbFile(), IDF::MachineImplementation::icDecoderPluginFile(), IDF::MachineImplementation::setICDecoderHDB(), IDF::MachineImplementation::setICDecoderPluginFile(), and ProGeOptions::validate().

Here is the call graph for this function:

◆ fileExists()

static bool FileSystem::fileExists ( const std::string fileName )

static

◆ fileExtension()

string FileSystem::fileExtension ( const std::string & fileName )

static

Returns the file extension of an file, if anything is found.

If not extension is found, an empty string is returned.

Parameters

fileName The name of the file.

Returns: The file extension.

Definition at line 279 of file FileSystem.cc.

                                                    {
     const Path path(fileName);
     return boost::filesystem::extension(path);
 }

Referenced by ProgramImageGenerator::availableCompressors(), ProDeExportCmd::Do(), ProximOpenMachineCmd::Do(), GenerateProcessor::generateProcessor(), ProximMachineStateWindow::onExport(), and MDFDocument::OnOpenDocument().

◆ fileIsCreatable()

bool FileSystem::fileIsCreatable ( const std::string fileName )

static

Tests if a file or directory can be created by user.

The file or directory can be created if:

it does not already exist,
the path where it should be created exists and is writable.

Parameters

fileName Name of the file or directory to test.

Returns: True if file or directory can be created, false otherwise.

Definition at line 123 of file FileSystem.cc.

                                                     {
  
     if (fileName == "") {
         return false;
     }
  
     std::string destPath = directoryOfPath(fileName);
  
     return !fileExists(fileName) && fileExists(destPath) &&
         fileIsWritable(destPath);
 }

Referenced by copyImageToTb(), HDB::HDBManager::createNew(), DSDBManager::createNew(), SetHistoryFilename::execute(), main(), ProGe::VerilogNetlistWriter::writeBlock(), ProGe::VHDLNetlistWriter::writeBlock(), and XMLSerializer::writeFile().

◆ fileIsDirectory()

static bool FileSystem::fileIsDirectory ( const std::string fileName )

static

Referenced by ProgramImageGenerator::availableCompressors(), copyImageToTb(), ProGeTestBenchGenerator::copyTestBenchFiles(), LLVMBackend::createPlugin(), SetHistoryFilename::execute(), ProGeScriptGenerator::fetchFiles(), HDB::HDBRegistry::loadFromSearchPaths(), main(), and GenerateProcessorDialog::onOK().

◆ fileIsExecutable()

static bool FileSystem::fileIsExecutable ( const std::string fileName )

static

Referenced by Environment::defaultTextEditorPath(), UserManualCmd::Do(), and Environment::findExecutableFromPATH().

◆ fileIsReadable()

static bool FileSystem::fileIsReadable ( const std::string fileName )

static

Referenced by LLVMBackend::createPlugin(), ProGeTestBenchGenerator::createProcArchVhdl(), MemWriteCommand::execute(), HDB::HDBManager::HDBManager(), OperationBuilder::installDataFile(), HDB::HDBRegistry::loadFromSearchPaths(), SimulatorFrontend::loadMachine(), SimulatorFrontend::loadProcessorConfiguration(), SimulatorFrontend::loadProgram(), main(), and DesignSpaceExplorer::schedule().

◆ fileIsWritable()

static bool FileSystem::fileIsWritable ( const std::string fileName )

static

Referenced by copyImageToTb(), createMauPkg(), ProGeTestBenchGenerator::createProcArchVhdl(), OSEdPropertiesCmd::Do(), SetHistoryFilename::execute(), OSEdModifyBehaviorCmd::isEnabled(), OSEdRemoveOperationCmd::isEnabled(), OSEdRemoveModuleCmd::isEnabled(), main(), ExecutionTrace::open(), ProGe::VHDLNetlistWriter::writeBlock(), ProGe::VerilogNetlistWriter::writeBlock(), and XMLSerializer::writeFile().

◆ fileNameBody()

string FileSystem::fileNameBody ( const std::string & fileName )

static

Returns the name of the file without file extension.

Parameters

fileName The name of the file.

Returns: The name of the file without the file extension.

Definition at line 291 of file FileSystem.cc.

                                                   {
     const Path path(fileName);
     return boost::filesystem::basename(path);
 }

Referenced by OperationIndex::addPath(), CompiledSimulation::compileAndLoadFunction(), CompiledSimCompiler::compileFile(), DesignSpaceExplorer::getPlugins(), GenerateProcessor::listICDecPluginParameters(), ProcessorImplementationWindow::onBrowseICDecPlugin(), outputFileName(), printPlugins(), ProcessorImplementationWindow::ProcessorImplementationWindow(), programDataImageFile(), and programImemImageFile().

◆ fileOfPath()

std::string FileSystem::fileOfPath ( const std::string pathName )

static

Returns the file part of the given path name.

Parameters

pathName The path name.

Returns: The file part of the path name.

Definition at line 101 of file FileSystem.cc.

                                                {
     if (!isPath(pathName)) {
         return pathName;
     }
     Path origString(pathName);
     string path = origString.string();
     Path DS(DIRECTORY_SEPARATOR);
     unsigned int index = path.find_last_of(DIRECTORY_SEPARATOR);
     return path.substr(index + 1);
 }

References DS.

Referenced by OperationIndex::addPath(), IDF::MachineImplementation::checkImplFile(), CompiledSimCompiler::compileFile(), ProGe::BlockSourceCopier::copyFiles(), FUGen::copyImplementation(), AlmaIFIntegrator::copyPlatformFile(), ProGe::BlockSourceCopier::copyProcessorSpecific(), HDBEditorMainFrame::createHDB(), OSEdRemoveModuleCmd::Do(), ProcessorImplementationWindow::doSaveIDF(), PluginTools::findModule(), ProGeScriptGenerator::getBlockOrder(), ProGe::BlockSourceCopier::instantiateHDLTemplate(), GenerateProcessor::listICDecPluginParameters(), SimulatorFrontend::loadProgram(), main(), ProcessorImplementationWindow::onBrowseICDecPlugin(), MDFView::OnChangeFilename(), MDFDocument::openADF(), ImplementationSimulator::parseErrorMessages(), printBEMInfo(), CompiledSimController::reset(), and HDBEditorMainFrame::setHDB().

◆ findFileInDirectoryTree()

bool FileSystem::findFileInDirectoryTree	(	const Path &	startDirectory,
		const std::string &	fileName,
		Path &	pathFound
	)

static

Attempts to find a file from the given directory hierarchy

Parameters

startDirectory	The directory to start the search.
fileName	The filename to search for.
pathFound	A path to the found file.

Returns: true if the file was found. Otherwise false.

Definition at line 682 of file FileSystem.cc.

                      {
  
     if (!exists(startDirectory)) {
         return false;
     }
     directory_iterator end_itr;
     
     for (directory_iterator itr(startDirectory); itr != end_itr; ++itr) {
         if (is_directory(*itr)) {
             Path p((*itr).path().string());
             if (findFileInDirectoryTree(p, fileName, pathFound))
                 return true;
         }
 #if BOOST_VERSION >= 103600
         else if (itr->path().filename() == fileName)
 #else
         else if (itr->leaf() == fileName)
 #endif
         {
             pathFound = Path((*itr).path().string());
             return true;
         }
     }
     return false;
 }

◆ findFileInSearchPaths()

std::string FileSystem::findFileInSearchPaths	(	const std::vector< std::string > &	searchPaths,
		const std::string &	file
	)

static

Searches the given file in the given search paths and returns the absolute path to the file.

Parameters

searchPaths	The search paths in priority order.
file	The file to search.

Returns: Absolute path to the file.

Exceptions

FileNotFound If the file is not found in the search paths.

Definition at line 562 of file FileSystem.cc.

                                                                     {
     string DS = FileSystem::DIRECTORY_SEPARATOR;
  
     if (isAbsolutePath(file)) {
         if (fileExists(file)) {
             return file;
         } else {
             string errorMsg = "File " + file + " not found.";
             throw FileNotFound(__FILE__, __LINE__, __func__, errorMsg);
         }
     }
  
     for (vector<string>::const_iterator iter = searchPaths.begin();
          iter != searchPaths.end(); iter++) {
         string path = *iter;
         string pathToFile = path + DS + file;
         if (fileExists(pathToFile)) {
             return absolutePathOf(pathToFile);
         } 
     }
  
     string errorMsg = "File " + file + " not found in any search path.";
     errorMsg += "Searched paths:\n";
     for (unsigned int i = 0; i < searchPaths.size(); i++) {
         errorMsg += searchPaths.at(i) + "\n";
     }
     throw FileNotFound(__FILE__, __LINE__, __func__, errorMsg);
 }

References __func__, DIRECTORY_SEPARATOR, and DS.

◆ findFromDirectory()

template<typename STLCONT >

static bool FileSystem::findFromDirectory	(	const std::string &	regex,
		const std::string &	directory,
		STLCONT &	found
	)

static

Referenced by ProGeTestBenchGenerator::copyTestBenchFiles(), DesignSpaceExplorer::getPlugins(), and printPlugins().

◆ findFromDirectoryRecursive()

template<typename STLCONT >

static bool FileSystem::findFromDirectoryRecursive	(	const std::string &	regex,
		const std::string &	directory,
		STLCONT &	found
	)

static

Referenced by ProGeScriptGenerator::fetchFiles().

◆ globPath()

void FileSystem::globPath	(	const std::string &	pattern,
		std::vector< std::string > &	filenames
	)

static

Searches path names that matches the pattern and stores the results in string vector.

Parameters

pattern	The pattern to be matched.
filenames	Results are stored here.

Definition at line 197 of file FileSystem.cc.

                                      {
  
     glob_t globbuf;
     glob(pattern.c_str(), 0, NULL, &globbuf);
     for (size_t i = 0; i < globbuf.gl_pathc; i++) {
         filenames.push_back(globbuf.gl_pathv[i]);
     }
     // reserved memory is freed
     globfree(&globbuf);
 }

Referenced by OperationIndex::addPath(), and CompiledSimController::reset().

◆ homeDirectory()

static std::string FileSystem::homeDirectory ( )

static

Referenced by Environment::codeCompressorPaths(), Environment::confPath(), Environment::estimatorPluginPaths(), expandTilde(), Environment::explorerPluginPaths(), Environment::icDecoderPluginPaths(), Environment::initialize(), Environment::llvmtceCachePath(), main(), Environment::osalPaths(), Environment::schedulerPluginPaths(), TTASimulatorCLI::TTASimulatorCLI(), and Environment::userConfPath().

◆ isAbsolutePath()

bool FileSystem::isAbsolutePath ( const std::string & pathName )

static

Checks if the pathName is a string representing an absolute path.

Parameters

pathName The investigated path.

Returns: True, if it is an absolute path, false otherwise.

Definition at line 234 of file FileSystem.cc.

                                                     {
     Path path(pathName);
     string pathString = path.string();
     Path DS(DIRECTORY_SEPARATOR);
     return pathString.substr(0, 1) ==
         DS.string() ? true : false;
 }

References DS.

Referenced by ImplementationTester::createListOfSimulationFiles(), PluginTools::loadSym(), main(), ProcessorConfigurationFile::realPath(), PluginTools::registerModule(), and PluginTools::unregisterModule().

◆ isPath()

bool FileSystem::isPath ( const std::string & pathName )

static

Checks if the pathName is a string representing path (relative or absolute).

Parameters

pathName The investigated path.

Returns: True, if it is a relative path, false otherwise.

Definition at line 265 of file FileSystem.cc.

                                             {
     return (!pathName.empty() &&
             (isRelativePath(pathName) || isAbsolutePath(pathName)));
 }

◆ isRelativePath()

bool FileSystem::isRelativePath ( const std::string & pathName )

static

Checks if the pathName is a string representing a relative path.

Path is relative path, if it is not absolute path and not empty string.

Parameters

pathName The investigated path.

Returns: True, if it is a relative path, false otherwise.

Definition at line 252 of file FileSystem.cc.

                                                     {
     Path path(pathName);
     string pathString = path.string();
     return !isAbsolutePath(pathString) && !pathString.empty();
 }

Referenced by compareFileNames(), and XMLSerializer::initializeParser().

◆ lastModificationTime()

std::time_t FileSystem::lastModificationTime ( const std::string & filePath )

static

Returns last modification time of a file.

If last modification time can't be resolved, std::time_t(-1) is returned.

Parameters

filePath Path to the file.

Returns: Time of the last modification to the file.

Definition at line 352 of file FileSystem.cc.

                                                           {
     if (!isAbsolutePath(filePath) || !fileExists(filePath)) {
         return std::time_t(-1);
     }
     
     std::time_t lastModTime;
     try {
         lastModTime = boost::filesystem::last_write_time(filePath);
     } catch (...) {
         lastModTime = std::time_t(-1);
     }
     
     return lastModTime;
 }

Referenced by HDB::CachedHDBManager::CachedHDBManager(), and HDB::CachedHDBManager::validateCache().

◆ makeRelativePath()

bool FileSystem::makeRelativePath	(	const std::vector< std::string > &	searchPaths,
		const std::string &	basePath,
		std::string &	toRelPath
	)

static

Creates relative path out of provided base path.

A relative path is returned if it is found under any of the search paths. Example: if base path is "/usr/foo/bar/x.hdb" and provided search path is "/usr/foo", the following relative path is formed: "bar/x.hdb".

Parameters

searchPaths	Relative path to base path is searched under these.
basePath	Path that needs to be changed into a relative path.
toRelPath	Outputs possibly created relative path.

Returns: True if a relative path was created out of base path.

Definition at line 844 of file FileSystem.cc.

                           {    
  
     if (!isAbsolutePath(basePath)) {
         return false;
     }
  
     for (unsigned int i = 0; i < searchPaths.size(); ++i) {
         string searchPath = searchPaths.at(i);
         string relativePath = basePath;
         
         // try to find a relative path to the base path under search path
         if (relativeDir(searchPath, relativePath)) {
             string fullPath = searchPath + DIRECTORY_SEPARATOR + relativePath;       
             
             // special case: if provided search path was same as base path
             if (relativePath == "") {
                 toRelPath = relativePath;
                 return true;
             } else if (isRelativePath(relativePath) && fileExists(fullPath)) {
                 if (fullPath.length() == basePath.length()) {
                     toRelPath = relativePath;
                     return true;
                 }
             }
         }
     }
  
     return false;
 }

Referenced by IDF::MachineImplementation::makeHDBPathRelative(), and IDF::MachineImplementation::makeImplFilesRelative().

◆ readBlockFromFile()

bool FileSystem::readBlockFromFile	(	const std::string &	sourceFile,
		const std::string &	blockStartRE,
		const std::string &	blockEndRE,
		std::string &	readBlock,
		const bool	includeMatchingLines = `true`
	)

static

Reads a block of text from a file.

Start and end of the block are found by matching given regular expressions against whole lines in source file.

Parameters

sourceFile	File that is read.
blockStartRE	Regex that matches beginning of the block (one whole line) that is going to be read from the source file.
blockEndRE	Regex that matches end of the block (one whole line) that is going to be read from the source file.
readBlock	Parameter where the read block is to be stored.
includeMatchingLines	Include lines that mark the borders of the block (lines that matched given regular expressions) to the block.

Returns: True if something was stored to readBlock string, otherwise false.

Definition at line 894 of file FileSystem.cc.

                                      { //true by default
  
     const int LINESIZE = 256;
     char line[LINESIZE];
     
     const boost::regex reStart(blockStartRE, 
             boost::regex::perl|boost::regex::icase);
     const boost::regex reEnd(blockEndRE, 
             boost::regex::perl|boost::regex::icase);
     
     string::const_iterator begin;
     string::const_iterator end;
     string stemp;
     std::ifstream ifs(sourceFile.c_str(), std::ifstream::in);
     boost::match_results<string::const_iterator> matches;
     bool outsideBlock = true;
     while (ifs.good()) {
  
         ifs.getline(line, LINESIZE-1);
         stemp = string(line);
         begin = stemp.begin();
         end = stemp.end();
  
         // test if found block border
         if (boost::regex_search(begin, end, outsideBlock ? reStart : reEnd)) {
             if (includeMatchingLines) {
                readBlock.append(stemp + "\n");
             } 
             if (!outsideBlock) {
                 break;
             } else {
                 outsideBlock = false;
             }
         } else if (!outsideBlock) { // if inside block
             readBlock.append(stemp + "\n");
         }
     }
  
     ifs.close();
  
     return ifs.good();
 }

Referenced by ProGeTestBenchGenerator::createProcArchVhdl().

◆ relativeDir()

bool FileSystem::relativeDir	(	const std::string &	baseDir,
		std::string &	toRelDir
	)

static

Creates relative (to given base dir) directory.

Both directories given as parameter have to be absolute or false is returned.

Parameters

baseDir	string representing base directory.
toRelDir	string representing a directory which is changed to relative.

Returns: true if toRelDir is modified as relative directory otherwise false.

Definition at line 762 of file FileSystem.cc.

                                                                      {
  
     namespace fs = boost::filesystem;
     
     Path basePath(baseDir);
     Path toRelPath(toRelDir);
     
     fs::path::iterator dstIt = basePath.begin();
     fs::path::iterator POIt = toRelPath.begin();
  
     fs::path::iterator dstEndIt = basePath.end();
     fs::path::iterator POEndIt = toRelPath.end();
  
     unsigned int sameCount = 0;
     for (; dstIt != dstEndIt && POIt != POEndIt && *dstIt == *POIt;
         ++dstIt, ++POIt, ++sameCount) {}
  
     // both parameter dirs have to be absolute
     // first path part is allways '/'
     if (sameCount < 1) {
         return false;
     }
     
     // if the to be realtive dir is under the base dir
     if (dstIt == dstEndIt) {
         toRelDir.clear();
         while (POIt != POEndIt) {
 #if BOOST_FILESYSTEM_VERSION < 3
             toRelDir.append(*POIt++);
 #else
             std::string const tmp = POIt->string();
             toRelDir.append(tmp);
             POIt++;
 #endif
             if (POIt != POEndIt) {
                 toRelDir.append(DIRECTORY_SEPARATOR);
             }
         }    
         return true;
     } else { // if above
         std::string temp;
         while (POIt != POEndIt) {
 #if BOOST_FILESYSTEM_VERSION < 3
             temp.append(*POIt++);
 #else
             std::string const tmp = POIt->string();
             POIt++;
             temp.append(tmp);
 #endif
             if (POIt != POEndIt) {
                 temp.append(DIRECTORY_SEPARATOR);
             }
         }
  
         unsigned int diffCount = 0;
         for (; dstIt != dstEndIt; ++dstIt, ++diffCount) {
         }
  
         toRelDir.clear();
         for (unsigned int i = 0; diffCount > i; ++i) {
             toRelDir.append("..");
             toRelDir.append(DIRECTORY_SEPARATOR);
         }
         toRelDir.append(temp);
     }
  
     return true;
 }

Referenced by GenerateProcessor::generateProcessor(), and ProGeScriptGenerator::prepareFiles().

◆ removeFileOrDirectory()

bool FileSystem::removeFileOrDirectory ( const std::string & path )

static

Removes a file or a directory.

Parameters

path	The path of a file or a directory.

Returns: True if directory or file is destroyed, false otherwise.

Definition at line 493 of file FileSystem.cc.

                                                        {
     if (fileExists(path)) {
         try {
             Path tcePath(path);
             boost::filesystem::remove_all(tcePath);
             return true;
         } catch (...) {
             // failed to destroy a file or directory
             // probably because of lack of rights.
             return false;
         }
     } else {
         return false;
     }
 }

Referenced by LLVMBackend::compile(), CompileTools::compileAsC(), CompileTools::compileAsLLVM(), ProGeScriptGenerator::createExecutableFile(), ProGeTestBenchGenerator::createFile(), CompiledSimController::deleteGeneratedFiles(), BlocksConnectICCmd::Do(), VLIWConnectICCmd::Do(), OSEdRemoveModuleCmd::Do(), OperationBuilder::installDataFile(), OSEdAddOperationCmd::isEnabled(), OSEdAddModuleCmd::isEnabled(), CallExplorerPluginWindow::onRun(), DesignSpaceExplorer::schedule(), OperationDAGDialog::updateDAG(), ImplementationTester::validateFU(), ImplementationTester::validateRF(), ImplementationSimulator::~ImplementationSimulator(), and ImplementationTester::~ImplementationTester().

◆ runShellCommand()

static bool FileSystem::runShellCommand ( const std::string command )

static

Referenced by TestApplication::cleanupSimulation(), CommandThread::Entry(), TestApplication::setupSimulation(), and TestApplication::verifySimulation().

◆ setFileExecutable()

bool FileSystem::setFileExecutable ( const std::string fileName )

static

Grants execute rights for user to a file.

Parameters

fileName File whitch execute rights are to be changed.

Returns: True if operation was succesfull, otherwise false.

Definition at line 322 of file FileSystem.cc.

                                                       {
     if (fileIsWritable(fileName) && fileIsReadable(fileName)) {
         if (chmod(fileName.c_str(), S_IXUSR | S_IRUSR | S_IWUSR) != 0) {
             return false;
         }
     } else if (fileIsWritable(fileName)) {
         if (chmod(fileName.c_str(), S_IXUSR | S_IWUSR) != 0) {
             return false;
         }
     } else if (fileIsReadable(fileName)) {
         if (chmod(fileName.c_str(), S_IXUSR | S_IRUSR) != 0) {
             return false;
         }
     } else {
         if (chmod(fileName.c_str(), S_IXUSR) != 0) {
             return false;
         }
     }
     return true;
 }

Referenced by ProGeScriptGenerator::createExecutableFile(), and QuartusProjectGenerator::writeScripts().

◆ sizeInBytes()

uintmax_t FileSystem::sizeInBytes ( const std::string & filePath )

static

Returns current size of the file in bytes.

If file size can't be resolved, static_cast<uintmax_t>(-1) is returned.

Parameters

filePath Path to the file.

Returns: Size of the file in bytes.

Definition at line 376 of file FileSystem.cc.

                                                  {
     if (!isAbsolutePath(filePath) || !fileExists(filePath)) {
         return static_cast<uintmax_t>(-1);
     }
  
     uintmax_t fileSize;
     try {
         fileSize = boost::filesystem::file_size(filePath);
     } catch (...) {
         fileSize = static_cast<uintmax_t>(-1);
     }
     
     return fileSize;
 }

Referenced by HDB::CachedHDBManager::CachedHDBManager(), MemWriteCommand::execute(), and HDB::CachedHDBManager::validateCache().

Member Data Documentation

◆ CURRENT_DIRECTORY

const std::string FileSystem::CURRENT_DIRECTORY = "."

static

Definition at line 190 of file FileSystem.hh.

◆ DIRECTORY_SEPARATOR

const std::string FileSystem::DIRECTORY_SEPARATOR

static

Initial value:

=

string(DIR_SEPARATOR)

Definition at line 189 of file FileSystem.hh.

◆ STRING_WILD_CARD

const std::string FileSystem::STRING_WILD_CARD = "*"

static

Definition at line 191 of file FileSystem.hh.

Referenced by OperationIndex::addPath().

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

Static Public Member Functions

Static Public Attributes

Detailed Description

Member Function Documentation

◆ absolutePathOf()

◆ appendReplaceFile()

◆ changeWorkingDir()

◆ compareFileNames()

◆ copy()

◆ countLines()

◆ createDirectory()

◆ createFile()

◆ createTempDirectory()

◆ currentWorkingDir()

◆ directoryContents()

◆ directoryOfPath()

◆ directorySubTrees()

◆ expandTilde()

◆ fileExists()

◆ fileExtension()

◆ fileIsCreatable()

◆ fileIsDirectory()

◆ fileIsExecutable()

◆ fileIsReadable()

◆ fileIsWritable()

◆ fileNameBody()

◆ fileOfPath()

◆ findFileInDirectoryTree()

◆ findFileInSearchPaths()

◆ findFromDirectory()

◆ findFromDirectoryRecursive()

◆ globPath()

◆ homeDirectory()

◆ isAbsolutePath()

◆ isPath()

◆ isRelativePath()

◆ lastModificationTime()

◆ makeRelativePath()

◆ readBlockFromFile()

◆ relativeDir()

◆ removeFileOrDirectory()

◆ runShellCommand()

◆ setFileExecutable()

◆ sizeInBytes()

Member Data Documentation

◆ CURRENT_DIRECTORY

◆ DIRECTORY_SEPARATOR

◆ STRING_WILD_CARD