276 lines
8.3 KiB
C++
276 lines
8.3 KiB
C++
/********************************************************************
|
|
* This file includes functions that handles the file outputting
|
|
* in OpenFPGA framework
|
|
*******************************************************************/
|
|
#include <sys/stat.h>
|
|
#include <vector>
|
|
#include <algorithm>
|
|
|
|
/* Headers from vtrutil library */
|
|
#include "vtr_log.h"
|
|
|
|
/* Headers from openfpgautil library */
|
|
#include "openfpga_digest.h"
|
|
|
|
namespace openfpga {
|
|
|
|
/********************************************************************
|
|
* A most utilized function to validate the file stream
|
|
* This function will return true or false for a valid/invalid file stream
|
|
*******************************************************************/
|
|
bool valid_file_stream(std::fstream& fp) {
|
|
/* Validate the file stream */
|
|
if (!fp.is_open() || !fp.good()) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/********************************************************************
|
|
* A most utilized function to validate the file stream
|
|
* This function will error out for a valid/invalid file stream
|
|
*******************************************************************/
|
|
void check_file_stream(const char* fname,
|
|
std::fstream& fp) {
|
|
|
|
if (false == valid_file_stream(fp)) {
|
|
VTR_LOG("Invalid file stream for file: %s\n",
|
|
fname);
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
/********************************************************************
|
|
* Format a directory path:
|
|
* 1. Replace "\" with "/"
|
|
* 2. add a "/" if the string does not end with a "/"
|
|
*******************************************************************/
|
|
std::string format_dir_path(const std::string& dir_path_to_format) {
|
|
std::string formatted_dir_path = dir_path_to_format;
|
|
|
|
char illegal_back_slash = '\\';
|
|
char legal_back_slash = '/';
|
|
|
|
#ifdef _WIN32
|
|
/* For windows OS, replace any '/' with '\' */
|
|
char illegal_back_slash = '/';
|
|
char legal_back_slash = '\\';
|
|
#endif
|
|
|
|
/* Return an empty string if the input is empty */
|
|
if (true == formatted_dir_path.empty()) {
|
|
return formatted_dir_path;
|
|
}
|
|
|
|
/* Replace "\" with "/" */
|
|
std::replace(formatted_dir_path.begin(), formatted_dir_path.end(), illegal_back_slash, legal_back_slash);
|
|
|
|
/* Add a back slash the string is not ended like this! */
|
|
if (legal_back_slash != formatted_dir_path.back()) {
|
|
formatted_dir_path.push_back(legal_back_slash);
|
|
}
|
|
|
|
return formatted_dir_path;
|
|
}
|
|
|
|
/********************************************************************
|
|
* Extract full file name from a full path of file
|
|
* For example: <dir_path>/<file_name>
|
|
* This function will return <file_name>
|
|
********************************************************************/
|
|
std::string find_path_file_name(const std::string& file_name) {
|
|
|
|
char back_slash = '/';
|
|
|
|
#ifdef _WIN32
|
|
/* For windows OS, replace any '/' with '\' */
|
|
char back_slash = '\\';
|
|
#endif
|
|
|
|
/* Find the last '/' in the string and return the left part */
|
|
size_t found = file_name.rfind(back_slash);
|
|
if (found != std::string::npos) {
|
|
return file_name.substr(found + 1);
|
|
}
|
|
/* Not found. The input is the file name! Return the original string */
|
|
return file_name;
|
|
}
|
|
|
|
/********************************************************************
|
|
* Extract full directory path from a full path of file
|
|
* For example: <dir_path>/<file_name>
|
|
* This function will return <dir_path>
|
|
********************************************************************/
|
|
std::string find_path_dir_name(const std::string& file_name) {
|
|
|
|
char back_slash = '/';
|
|
|
|
#ifdef _WIN32
|
|
/* For windows OS, replace any '/' with '\' */
|
|
char back_slash = '\\';
|
|
#endif
|
|
|
|
/* Find the last '/' in the string and return the left part */
|
|
size_t found = file_name.rfind(back_slash);
|
|
if (found != std::string::npos) {
|
|
return file_name.substr(0, found);
|
|
}
|
|
/* Not found, return an empty string */
|
|
return std::string();
|
|
}
|
|
|
|
/********************************************************************
|
|
* Create a directory with a given path
|
|
********************************************************************/
|
|
static
|
|
bool create_dir_path(const std::string& dir_path,
|
|
const bool& verbose) {
|
|
/* Give up if the path is empty */
|
|
if (true == dir_path.empty()) {
|
|
VTR_LOG_WARN("Directory path is empty and nothing will be created.\n");
|
|
return true;
|
|
}
|
|
|
|
/* Try to create a directory */
|
|
int ret = mkdir(dir_path.c_str(), S_IRWXU|S_IRWXG|S_IROTH|S_IXOTH);
|
|
|
|
/* Analyze the return flag and output status */
|
|
switch (ret) {
|
|
case 0:
|
|
VTR_LOGV(verbose,
|
|
"Succeed to create directory '%s'\n",
|
|
dir_path.c_str());
|
|
return true;
|
|
case -1:
|
|
if (EEXIST == errno) {
|
|
VTR_LOGV_WARN(verbose,
|
|
"Directory '%s' already exists. Will overwrite contents\n",
|
|
dir_path.c_str());
|
|
return true;
|
|
}
|
|
VTR_LOG_ERROR("Create directory '%s'...Failed!\n",
|
|
dir_path.c_str());
|
|
exit(1);
|
|
break;
|
|
default:
|
|
VTR_LOG_ERROR("Create directory '%s'...Failed!\n",
|
|
dir_path.c_str());
|
|
exit(1);
|
|
return false;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/********************************************************************
|
|
* Recursively create a directory with a given path
|
|
* The create_dir_path() function will only try to create a directory
|
|
* in the last level. If any parent directory is not created, it will
|
|
* always fail.
|
|
* This function will try to create all the parent directory before
|
|
* creating the last level.
|
|
********************************************************************/
|
|
static
|
|
bool rec_create_dir_path(const std::string& dir_path) {
|
|
/* Give up if the path is empty */
|
|
if (true == dir_path.empty()) {
|
|
VTR_LOG_WARN("Directory path is empty and nothing will be created.\n");
|
|
return true;
|
|
}
|
|
|
|
/* Try to find the positions of all the slashes
|
|
* which are the splitter between directories
|
|
*/
|
|
char back_slash = '/';
|
|
|
|
#ifdef _WIN32
|
|
/* For windows OS, replace any '/' with '\' */
|
|
char back_slash = '\\';
|
|
#endif
|
|
|
|
std::vector<size_t> slash_pos;
|
|
|
|
/* Keep searching until we reach the end of the string */
|
|
for (size_t pos = 0; pos < dir_path.size(); ++pos) {
|
|
/* Skip the pos = 0, we should avoid creating any root directory */
|
|
if ( (back_slash == dir_path.at(pos))
|
|
&& (0 != pos)) {
|
|
slash_pos.push_back(pos);
|
|
}
|
|
}
|
|
|
|
/* Create directory by following the position of back slash
|
|
* For each back slash, create a sub string from the beginning
|
|
* and try to create directory
|
|
*/
|
|
for (const size_t& pos : slash_pos) {
|
|
std::string sub_dir = dir_path.substr(0, pos);
|
|
|
|
/* Turn on verbose output only for the last position: the leaf directory */
|
|
if (false == create_dir_path(sub_dir, &pos == &slash_pos.back())) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/********************************************************************
|
|
* Top function to create a directory with a given path
|
|
* Allow users to select if use the recursive way or not
|
|
*
|
|
* Strongly recommend to use the recursive way, as it can maximum
|
|
* guarantee the success in creation of directories
|
|
********************************************************************/
|
|
void create_directory(const std::string& dir_path, const bool& recursive) {
|
|
std::string formatted_dir_path = format_dir_path(dir_path);
|
|
bool status = false;
|
|
|
|
if (true == recursive) {
|
|
status = rec_create_dir_path(formatted_dir_path);
|
|
} else {
|
|
status = create_dir_path(formatted_dir_path, true);
|
|
}
|
|
|
|
if (false == status) {
|
|
VTR_LOG_ERROR("Fail to create directory '%s'\n",
|
|
formatted_dir_path.c_str());
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
/********************************************************************
|
|
* Write a number of space to a file
|
|
********************************************************************/
|
|
bool write_space_to_file(std::fstream& fp,
|
|
const size_t& num_space) {
|
|
if (false == valid_file_stream(fp)) {
|
|
return false;
|
|
}
|
|
|
|
for (size_t i = 0; i < num_space; ++i) {
|
|
fp << " ";
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/********************************************************************
|
|
* Write a number of tab to a file
|
|
********************************************************************/
|
|
bool write_tab_to_file(std::fstream& fp,
|
|
const size_t& num_tab) {
|
|
if (false == valid_file_stream(fp)) {
|
|
return false;
|
|
}
|
|
|
|
for (size_t i = 0; i < num_tab; ++i) {
|
|
fp << "\t";
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
} /* namespace openfpga ends */
|