src/Utils/FileUtils.cpp - third_party/Surelog - Git at Google

 /*
  Copyright 2019 Alain Dargelas

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

  http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
  */

 /*
  * File:   FileUtils.cpp
  * Author: alain
  *
  * Created on March 16, 2017, 11:02 PM
  */

 #include "SourceCompile/SymbolTable.h"
 #include "Utils/FileUtils.h"
 #include "Utils/StringUtils.h"
 #include <sys/stat.h>
 #include <unistd.h>
 #include <string.h>
 #include <limits.h> /* PATH_MAX */
 #include <errno.h>
 #include <stdlib.h>
 #include <iostream>
 #include <algorithm>
 #include <string>
 #include <dirent.h>
 #include <stdio.h>
 #include <regex>
 #include <fstream>
 #include <sstream>

 using namespace SURELOG;

 FileUtils::FileUtils() {}

 FileUtils::FileUtils(const FileUtils& orig) {}

 FileUtils::~FileUtils() {}

 bool FileUtils::fileExists(const std::string name) {
   struct stat buffer;
   return (stat(name.c_str(), &buffer) == 0);
 }

 unsigned long FileUtils::fileSize(const std::string name) {
   struct stat buf;
   stat(name.c_str(), &buf);
   off_t size = buf.st_size;
   return size;
 }

 bool FileUtils::fileIsDirectory(const std::string name) {
   struct stat statbuf;
   if (stat(name.c_str(), &statbuf) != 0) return 0;
   return S_ISDIR(statbuf.st_mode);
 }

 bool FileUtils::fileIsRegular(const std::string name) {
   struct stat statbuf;
   if (stat(name.c_str(), &statbuf) != 0) return 0;
   return S_ISREG(statbuf.st_mode);
 }

 SymbolId FileUtils::locateFile(SymbolId file, SymbolTable* symbols,
                                const std::vector<SymbolId>& paths) {
   const std::string& fileName = symbols->getSymbol(file);
   if (fileExists(fileName)) {
     return file;
   }
   for (auto id : paths) {
     const std::string& path = symbols->getSymbol(id);
     std::string filePath;
     if (path.size() && (path[path.size() - 1] == '/'))
       filePath = path + fileName;
     else
       filePath = path + "/" + fileName;
     if (fileExists(filePath)) {
       return symbols->registerSymbol(filePath);
     }
   }
   return symbols->getBadId();
 }

 int FileUtils::mkDir(const char* path) {
   /* Adapted from http://stackoverflow.com/a/2336245/119527 */
   const size_t len = strlen(path);
   char _path[PATH_MAX];
   char* p;

   errno = 0;

   /* Copy string so its mutable */
   if (len > sizeof(_path) - 1) {
     errno = ENAMETOOLONG;
     return -1;
   }
   strcpy(_path, path);

   /* Iterate the string */
   for (p = _path + 1; *p; p++) {
     if (*p == '/') {
       /* Temporarily truncate */
       *p = '\0';
       if (mkdir(_path, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH) != 0) {
         if (errno != EEXIST) return -1;
       }

       *p = '/';
     }
   }

   if (mkdir(_path, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH) != 0) {
     if (errno != EEXIST) return -1;
   }

   return 0;
 }

 std::string FileUtils::getPathName(const std::string path) {
   char sep = '/';

 #ifdef _WIN32
   sep = '\\';
 #endif

   size_t i = path.rfind(sep, path.length());
   if (i != std::string::npos) {
     return (path.substr(0, i)) + "/";
   }

   return ("");
 }

 std::string FileUtils::getFullPath(const std::string path) {
   char* full_path = realpath(path.c_str(), NULL);
   std::string ret;
   if (full_path) {
     ret = full_path;
     free(full_path);
   } else
     ret = path;
   return ret;
 }

 static bool has_suffix(const std::string& s, const std::string& suffix) {
   return (s.size() >= suffix.size()) &&
          equal(suffix.rbegin(), suffix.rend(), s.rbegin());
 }

 std::vector<SymbolId> FileUtils::collectFiles(SymbolId dirPath, SymbolId ext,
                                               SymbolTable* symbols) {
   return collectFiles(symbols->getSymbol(dirPath), symbols->getSymbol(ext),
                       symbols);
 }

 std::vector<SymbolId> FileUtils::collectFiles(const std::string dirPath,
                                               const std::string ext,
                                               SymbolTable* symbols) {
   std::string path = dirPath;
   if (path.size()) {
     if (path[path.size() - 1] != '/') {
       path += "/";
     }
   }
   std::vector<SymbolId> result;
   DIR* dir = opendir(path.c_str());
   if (!dir) {
     return result;
   }

   dirent* entry;
   while ((entry = readdir(dir)) != NULL) {
     if (has_suffix(entry->d_name, ext)) {
       result.push_back(symbols->registerSymbol(path + entry->d_name));
     }
   }

   closedir(dir);
   return result;
 }

 std::vector<SymbolId> FileUtils::collectFilesRegexp(const std::string dirPath,
                                                     const std::string regexp,
                                                     SymbolTable* symbols) {
   std::vector<SymbolId> result;
   DIR* dir = opendir(dirPath.c_str());
   if (!dir) {
     return result;
   }

   std::string newregexp;
   for (unsigned int i = 0; i < regexp.size(); i++) {
     if (regexp[i] == '.') {
       newregexp += "\\";
     }
     if (regexp[i] == '*') {
       newregexp += "[a-zA-Z0-9_-]*\\.*[a-zA-Z0-9_]*";
       continue;
     }
     if (regexp[i] == '?') {
       newregexp += "[a-zA-Z0-9_-]+";
       continue;
     }
     newregexp += regexp[i];
   }

   std::regex base_regex(newregexp);
   std::smatch base_match;

   dirent* entry;
   while ((entry = readdir(dir)) != NULL) {
     std::string value = entry->d_name;
     if (std::regex_match(value, base_match, base_regex)) {
       result.push_back(symbols->registerSymbol(entry->d_name));
     }
   }

   closedir(dir);
   return result;
 }

 void FileUtils::collectFiles(const std::string dirPath,
                              std::vector<std::string>& dirs, unsigned int level,
                              SymbolTable* symbols,
                              std::vector<SymbolId>& files) {
   char currentDir[4096];
   if (!getcwd(currentDir, 4096)) return;

   if (chdir(dirPath.c_str()) != 0) return;
   char dir[4096];
   if (!getcwd(dir, 4096)) return;

   std::string regexp = dirs[level];
   std::vector<SymbolId> ids = collectFilesRegexp("./", regexp, symbols);
   for (auto id : ids) {
     std::string file = "./" + symbols->getSymbol(id);
     if (fileIsDirectory(file)) {
       if ((level + 1) < dirs.size()) {
         collectFiles(file, dirs, level + 1, symbols, files);
       }
     } else {
       std::string filePath = dir + std::string("/") + symbols->getSymbol(id);
       files.push_back(symbols->registerSymbol(filePath));
     }
   }

   if (chdir(currentDir) != 0) return;
 }

 std::vector<SymbolId> FileUtils::collectFiles(std::string pathSpec,
                                               SymbolTable* symbols) {
   std::vector<SymbolId> result;
   char currentDir[4096];
   if (!getcwd(currentDir, 4096)) return result;

   /*
   ?   single character wildcard (matches any single character)
   *   multiple character wildcard (matches any number of characters in a
   directory/file name)
   ... hierarchical wildcard (matches any number of hierarchical directories)
   ..  specifies the parent directory
   .   specifies the directory containing the lib.map
   Paths that end in / shall include all files in the specified directory.
   Identical to / * Paths that do not begin with / are relative to the directory
   in which the current lib.map file is located.
   */
   if (pathSpec[pathSpec.size() - 1] == '/') {
     pathSpec += "*";
   }

   std::vector<std::string> dirs;
   StringUtils::tokenize(pathSpec, "/", dirs);

   if (pathSpec[0] == '/') {
     // Absolute path
     if (chdir("/") != 0) return result;
   }

   char dir[4096];
   if (!getcwd(dir, 4096)) return result;
   std::vector<SymbolId> subs = collectFilesRegexp("./", dirs[0], symbols);
   for (auto id : subs) {
     std::string file = "./" + symbols->getSymbol(id);
     if (fileIsDirectory(file))
       collectFiles(file, dirs, 1, symbols, result);
     else {
       std::string filePath = dir + std::string("/") + symbols->getSymbol(id);
       result.push_back(symbols->registerSymbol(filePath));
     }
   }

   if (chdir(currentDir) != 0) return result;
   return result;
 }

 std::string FileUtils::getFileContent(const std::string filename) {
   std::ifstream in(filename, std::ios::in | std::ios::binary);
   if (in) {
     std::ostringstream contents;
     contents << in.rdbuf();
     in.close();
     return (contents.str());
   }
   return "FAILED_TO_LOAD_CONTENT";
 }

 std::string FileUtils::fileName(std::string str) {
   char c = '/';
   auto it1 = std::find_if(str.rbegin(), str.rend(),
                           [c](char ch) { return (ch == c); });
   if (it1 != str.rend())
     str.erase(str.begin(), it1.base());
   return str;
 }
	/*
	Copyright 2019 Alain Dargelas

	Licensed under the Apache License, Version 2.0 (the "License");
	you may not use this file except in compliance with the License.
	You may obtain a copy of the License at

	http://www.apache.org/licenses/LICENSE-2.0

	Unless required by applicable law or agreed to in writing, software
	distributed under the License is distributed on an "AS IS" BASIS,
	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	See the License for the specific language governing permissions and
	limitations under the License.
	*/

	/*
	* File: FileUtils.cpp
	* Author: alain
	*
	* Created on March 16, 2017, 11:02 PM
	*/

	#include "SourceCompile/SymbolTable.h"
	#include "Utils/FileUtils.h"
	#include "Utils/StringUtils.h"
	#include <sys/stat.h>
	#include <unistd.h>
	#include <string.h>
	#include <limits.h> /* PATH_MAX */
	#include <errno.h>
	#include <stdlib.h>
	#include <iostream>
	#include <algorithm>
	#include <string>
	#include <dirent.h>
	#include <stdio.h>
	#include <regex>
	#include <fstream>
	#include <sstream>

	using namespace SURELOG;

	FileUtils::FileUtils() {}

	FileUtils::FileUtils(const FileUtils& orig) {}

	FileUtils::~FileUtils() {}

	bool FileUtils::fileExists(const std::string name) {
	struct stat buffer;
	return (stat(name.c_str(), &buffer) == 0);
	}

	unsigned long FileUtils::fileSize(const std::string name) {
	struct stat buf;
	stat(name.c_str(), &buf);
	off_t size = buf.st_size;
	return size;
	}

	bool FileUtils::fileIsDirectory(const std::string name) {
	struct stat statbuf;
	if (stat(name.c_str(), &statbuf) != 0) return 0;
	return S_ISDIR(statbuf.st_mode);
	}

	bool FileUtils::fileIsRegular(const std::string name) {
	struct stat statbuf;
	if (stat(name.c_str(), &statbuf) != 0) return 0;
	return S_ISREG(statbuf.st_mode);
	}

	SymbolId FileUtils::locateFile(SymbolId file, SymbolTable* symbols,
	const std::vector<SymbolId>& paths) {
	const std::string& fileName = symbols->getSymbol(file);
	if (fileExists(fileName)) {
	return file;
	}
	for (auto id : paths) {
	const std::string& path = symbols->getSymbol(id);
	std::string filePath;
	if (path.size() && (path[path.size() - 1] == '/'))
	filePath = path + fileName;
	else
	filePath = path + "/" + fileName;
	if (fileExists(filePath)) {
	return symbols->registerSymbol(filePath);
	}
	}
	return symbols->getBadId();
	}

	int FileUtils::mkDir(const char* path) {
	/* Adapted from http://stackoverflow.com/a/2336245/119527 */
	const size_t len = strlen(path);
	char _path[PATH_MAX];
	char* p;

	errno = 0;

	/* Copy string so its mutable */
	if (len > sizeof(_path) - 1) {
	errno = ENAMETOOLONG;
	return -1;
	}
	strcpy(_path, path);

	/* Iterate the string */
	for (p = _path + 1; *p; p++) {
	if (*p == '/') {
	/* Temporarily truncate */
	*p = '\0';
	if (mkdir(_path, S_IRWXU \| S_IRWXG \| S_IROTH \| S_IXOTH) != 0) {
	if (errno != EEXIST) return -1;
	}

	*p = '/';
	}
	}

	if (mkdir(_path, S_IRWXU \| S_IRWXG \| S_IROTH \| S_IXOTH) != 0) {
	if (errno != EEXIST) return -1;
	}

	return 0;
	}

	std::string FileUtils::getPathName(const std::string path) {
	char sep = '/';

	#ifdef _WIN32
	sep = '\\';
	#endif

	size_t i = path.rfind(sep, path.length());
	if (i != std::string::npos) {
	return (path.substr(0, i)) + "/";
	}

	return ("");
	}

	std::string FileUtils::getFullPath(const std::string path) {
	char* full_path = realpath(path.c_str(), NULL);
	std::string ret;
	if (full_path) {
	ret = full_path;
	free(full_path);
	} else
	ret = path;
	return ret;
	}

	static bool has_suffix(const std::string& s, const std::string& suffix) {
	return (s.size() >= suffix.size()) &&
	equal(suffix.rbegin(), suffix.rend(), s.rbegin());
	}

	std::vector<SymbolId> FileUtils::collectFiles(SymbolId dirPath, SymbolId ext,
	SymbolTable* symbols) {
	return collectFiles(symbols->getSymbol(dirPath), symbols->getSymbol(ext),
	symbols);
	}

	std::vector<SymbolId> FileUtils::collectFiles(const std::string dirPath,
	const std::string ext,
	SymbolTable* symbols) {
	std::string path = dirPath;
	if (path.size()) {
	if (path[path.size() - 1] != '/') {
	path += "/";
	}
	}
	std::vector<SymbolId> result;
	DIR* dir = opendir(path.c_str());
	if (!dir) {
	return result;
	}

	dirent* entry;
	while ((entry = readdir(dir)) != NULL) {
	if (has_suffix(entry->d_name, ext)) {
	result.push_back(symbols->registerSymbol(path + entry->d_name));
	}
	}

	closedir(dir);
	return result;
	}

	std::vector<SymbolId> FileUtils::collectFilesRegexp(const std::string dirPath,
	const std::string regexp,
	SymbolTable* symbols) {
	std::vector<SymbolId> result;
	DIR* dir = opendir(dirPath.c_str());
	if (!dir) {
	return result;
	}

	std::string newregexp;
	for (unsigned int i = 0; i < regexp.size(); i++) {
	if (regexp[i] == '.') {
	newregexp += "\\";
	}
	if (regexp[i] == '*') {
	newregexp += "[a-zA-Z0-9_-]\\.[a-zA-Z0-9_]*";
	continue;
	}
	if (regexp[i] == '?') {
	newregexp += "[a-zA-Z0-9_-]+";
	continue;
	}
	newregexp += regexp[i];
	}

	std::regex base_regex(newregexp);
	std::smatch base_match;

	dirent* entry;
	while ((entry = readdir(dir)) != NULL) {
	std::string value = entry->d_name;
	if (std::regex_match(value, base_match, base_regex)) {
	result.push_back(symbols->registerSymbol(entry->d_name));
	}
	}

	closedir(dir);
	return result;
	}

	void FileUtils::collectFiles(const std::string dirPath,
	std::vector<std::string>& dirs, unsigned int level,
	SymbolTable* symbols,
	std::vector<SymbolId>& files) {
	char currentDir[4096];
	if (!getcwd(currentDir, 4096)) return;

	if (chdir(dirPath.c_str()) != 0) return;
	char dir[4096];
	if (!getcwd(dir, 4096)) return;

	std::string regexp = dirs[level];
	std::vector<SymbolId> ids = collectFilesRegexp("./", regexp, symbols);
	for (auto id : ids) {
	std::string file = "./" + symbols->getSymbol(id);
	if (fileIsDirectory(file)) {
	if ((level + 1) < dirs.size()) {
	collectFiles(file, dirs, level + 1, symbols, files);
	}
	} else {
	std::string filePath = dir + std::string("/") + symbols->getSymbol(id);
	files.push_back(symbols->registerSymbol(filePath));
	}
	}

	if (chdir(currentDir) != 0) return;
	}

	std::vector<SymbolId> FileUtils::collectFiles(std::string pathSpec,
	SymbolTable* symbols) {
	std::vector<SymbolId> result;
	char currentDir[4096];
	if (!getcwd(currentDir, 4096)) return result;

	/*
	? single character wildcard (matches any single character)
	* multiple character wildcard (matches any number of characters in a
	directory/file name)
	... hierarchical wildcard (matches any number of hierarchical directories)
	.. specifies the parent directory
	. specifies the directory containing the lib.map
	Paths that end in / shall include all files in the specified directory.
	Identical to / * Paths that do not begin with / are relative to the directory
	in which the current lib.map file is located.
	*/
	if (pathSpec[pathSpec.size() - 1] == '/') {
	pathSpec += "*";
	}

	std::vector<std::string> dirs;
	StringUtils::tokenize(pathSpec, "/", dirs);

	if (pathSpec[0] == '/') {
	// Absolute path
	if (chdir("/") != 0) return result;
	}

	char dir[4096];
	if (!getcwd(dir, 4096)) return result;
	std::vector<SymbolId> subs = collectFilesRegexp("./", dirs[0], symbols);
	for (auto id : subs) {
	std::string file = "./" + symbols->getSymbol(id);
	if (fileIsDirectory(file))
	collectFiles(file, dirs, 1, symbols, result);
	else {
	std::string filePath = dir + std::string("/") + symbols->getSymbol(id);
	result.push_back(symbols->registerSymbol(filePath));
	}
	}

	if (chdir(currentDir) != 0) return result;
	return result;
	}

	std::string FileUtils::getFileContent(const std::string filename) {
	std::ifstream in(filename, std::ios::in \| std::ios::binary);
	if (in) {
	std::ostringstream contents;
	contents << in.rdbuf();
	in.close();
	return (contents.str());
	}
	return "FAILED_TO_LOAD_CONTENT";
	}

	std::string FileUtils::fileName(std::string str) {
	char c = '/';
	auto it1 = std::find_if(str.rbegin(), str.rend(),
	[c](char ch) { return (ch == c); });
	if (it1 != str.rend())
	str.erase(str.begin(), it1.base());
	return str;
	}