static bool maybeAddDirectory(const std::string& newPath, Array<Directory>& directoryArray, bool recurse = true) {
if (fileExists(newPath)) {
Directory& d = directoryArray.next();
d.path = newPath;
getFiles(pathConcat(newPath, "*"), d.contents);
Array<std::string> dirs;
getDirs(pathConcat(newPath, "*"), dirs);
d.contents.append(dirs);
if (recurse) {
// Look for subdirectories
static const std::string subdirs[] =
{"font", "gui", "SuperShader", "cubemap", "icon", "material", "image", "md2", "md3", "ifs", "3ds", "sky", ""};
for (int j = 0; j < dirs.size(); ++j) {
for (int i = 0; ! subdirs[i].empty(); ++i) {
if (dirs[j] == subdirs[i]) {
maybeAddDirectory(pathConcat(newPath, dirs[j]), directoryArray, false);
}
}
}
}
return true;
} else {
return false;
}
}
YipDirectory::YipDirectory(const std::string & prjPath, const Project * project)
: m_Path(pathConcat(prjPath, ".yip")),
m_Project(project)
{
pathCreate(m_Path);
m_Path = pathMakeCanonical(m_Path);
m_DB = std::make_shared<SQLiteDatabase>(pathConcat(m_Path, "db"));
initDB();
}
void CppInliner::inlineCode(const vector<string>& cppFilePaths, const string& outputFilePath) const {
const string concatStage{pathConcat(temporaryDirectory, "concat.cpp")};
const string inlinedStage{pathConcat(temporaryDirectory, "inlined.cpp")};
concatFiles(cppFilePaths, concatStage);
internal::Inliner inliner{clangCompilationOptions};
std::string inlinedCode{inliner.doInline(concatStage)};
removePragmaOnce(inlinedCode, inlinedStage);
internal::Optimizer optimizer{clangCompilationOptions, macrosToKeep};
std::string onlyReachableCode{optimizer.doOptimize(inlinedStage)};
removeEmptyLines(onlyReachableCode, maxConsequentEmptyLines, outputFilePath);
}
bool YipDirectory::shouldProcessFile(const std::string & path, const std::string & sourcePath,
bool rebuildIfProjectFileChanged)
{
std::string targetFile = pathSimplify(pathConcat(m_Path, path));
// Always process input file if output file does not exist
if (!pathIsExistent(targetFile))
return true;
// There is no good way to handle non-existence of the input file. Leave it to the caller.
if (!pathIsExistent(sourcePath))
return true;
// Canonicalize output file path
targetFile = pathMakeCanonical(targetFile);
// Get information about file from the database
bool found = false;
time_t old_time = 0;
m_DB->select("SELECT time FROM files WHERE path = ? LIMIT 1", { targetFile },
[&found, &old_time](const SQLiteCursor & cursor) {
found = true;
old_time = cursor.toTimeT(0);
}
);
// This file was never built. Build it now.
if (!found)
return true;
// Check whether file has been modified since last build.
time_t modificationTime = pathGetModificationTime(sourcePath);
if (modificationTime > old_time)
return true;
// Also rebuild the file if Yipfile has been modified since last build
if (rebuildIfProjectFileChanged &&
m_Project->hasModificationTime() && m_Project->modificationTime() > old_time)
return true;
return false;
}
void IconSet::findImages(const String& baseDir, const String& sourceDir, Array<Source>& sourceArray) {
Array<String> filenameArray;
FileSystem::getFiles(pathConcat(pathConcat(baseDir, sourceDir), "*"), filenameArray);
for (int i = 0; i < filenameArray.size(); ++i) {
if (Image::fileSupported(filenameArray[i])) {
String f = pathConcat(sourceDir, filenameArray[i]);
shared_ptr<Image> im = Image::fromFile(pathConcat(baseDir, f));
Source& s = sourceArray.next();
s.filename = f;
s.width = im->width();
s.height = im->height();
// todo (Image upgrade): find replacement calculation for channels
//s.channels = im.channels;
}
}
Array<String> dirArray;
FileSystem::getDirectories(pathConcat(pathConcat(baseDir, sourceDir), "*"), dirArray);
for (int i = 0; i < dirArray.size(); ++i) {
if (dirArray[i] != ".svn" && dirArray[i] != "CVS") {
findImages(baseDir, pathConcat(sourceDir, dirArray[i]), sourceArray);
}
}
}
std::string System::findDataFile
(const std::string& full,
bool errorIfNotFound) {
// Places where specific files were most recently found. This is
// used to cache seeking of common files.
static Table<std::string, std::string> lastFound;
// First check if the file exists as requested. This will go
// through the FileSystemCache, so most calls do not touch disk.
if (FileSystem::exists(full)) {
return full;
}
// Now check where we previously found this file.
std::string* last = lastFound.getPointer(full);
if (last != NULL) {
if (FileSystem::exists(*last)) {
// Even if cwd has changed the file is still present.
// We won't notice if it has been deleted, however.
return *last;
} else {
// Remove this from the cache it is invalid
lastFound.remove(full);
}
}
// Places to look
static Array<std::string> directoryArray;
std::string initialAppDataDir(instance().m_appDataDir);
const char* g3dPath = getenv("G3DDATA");
if (directoryArray.size() == 0) {
// Initialize the directory array
RealTime t0 = System::time();
Array<std::string> baseDirArray;
baseDirArray.append("");
if (! initialAppDataDir.empty()) {
baseDirArray.append(initialAppDataDir);
}
# ifdef G3D_WIN32
if (g3dPath == NULL) {
// If running the demos under visual studio from the G3D.sln file,
// this will locate the data directory.
const char* paths[] = {"../data-files/", "../../data-files/", "../../../data-files/", NULL};
for (int i = 0; paths[i]; ++i) {
if (FileSystem::exists(pathConcat(paths[i], "G3D-DATA-README.TXT"))) {
g3dPath = paths[i];
break;
}
}
}
# endif
if (g3dPath && (initialAppDataDir != g3dPath)) {
baseDirArray.append(g3dPath);
}
static const std::string subdirs[] =
{"font", "gui", "SuperShader", "cubemap", "icon", "material", "image", "md2", "md3", "ifs", "3ds", "sky", ""};
for (int j = 0; j < baseDirArray.size(); ++j) {
std::string d = baseDirArray[j];
if ((d == "") || FileSystem::exists(d)) {
directoryArray.append(d);
for (int i = 0; ! subdirs[i].empty(); ++i) {
const std::string& p = pathConcat(d, subdirs[i]);
if (FileSystem::exists(p)) {
directoryArray.append(p);
}
}
}
}
logLazyPrintf("Initializing System::findDataFile took %fs\n", System::time() - t0);
}
for (int i = 0; i < directoryArray.size(); ++i) {
const std::string& p = pathConcat(directoryArray[i], full);
if (FileSystem::exists(p)) {
lastFound.set(full, p);
return p;
}
}
if (errorIfNotFound) {
// Generate an error message
std::string locations;
for (int i = 0; i < directoryArray.size(); ++i) {
locations += "\'" + pathConcat(directoryArray[i], full) + "'\n";
}
std::string msg = "Could not find '" + full + "'.\n\n";
msg += "cwd = \'" + FileSystem::currentDirectory() + "\'\n";
if (g3dPath) {
msg += "G3DDATA = ";
if (! FileSystem::exists(g3dPath)) {
msg += "(illegal path!) ";
}
msg += std::string(g3dPath) + "\'\n";
} else {
msg += "(G3DDATA environment variable is undefined)\n";
}
msg += "GApp::Settings.dataDir = ";
if (! FileSystem::exists(initialAppDataDir)) {
msg += "(illegal path!) ";
}
msg += std::string(initialAppDataDir) + "\'\n";
msg += "\nLocations searched:\n" + locations;
alwaysAssertM(false, msg);
}
// Not found
return "";
}
std::string System::findDataFile
(const std::string& full,
bool errorIfNotFound) {
// Places where specific files were most recently found. This is
// used to cache seeking of common files.
static Table<std::string, std::string> lastFound;
// First check if the file exists as requested. This will go
// through the FileSystemCache, so most calls do not touch disk.
if (fileExists(full)) {
return full;
}
// Now check where we previously found this file.
std::string* last = lastFound.getPointer(full);
if (last != NULL) {
if (fileExists(*last)) {
// Even if cwd has changed the file is still present.
// We won't notice if it has been deleted, however.
return *last;
} else {
// Remove this from the cache it is invalid
lastFound.remove(full);
}
}
// Places to look
static Array<std::string> directoryArray;
if (directoryArray.size() == 0) {
// Initialize the directory array
RealTime t0 = System::time();
Array<std::string> baseDirArray;
std::string initialAppDataDir(instance().m_appDataDir);
baseDirArray.append("");
if (! initialAppDataDir.empty()) {
baseDirArray.append(initialAppDataDir);
}
const char* g3dPath = getenv("G3DDATA");
if (g3dPath && (initialAppDataDir != g3dPath)) {
baseDirArray.append(g3dPath);
}
static const std::string subdirs[] =
{"font", "gui", "SuperShader", "cubemap", "icon", "material", "image", "md2", "md3", "ifs", "3ds", "sky", ""};
for (int j = 0; j < baseDirArray.size(); ++j) {
std::string d = baseDirArray[j];
if (fileExists(d)) {
directoryArray.append(d);
for (int i = 0; ! subdirs[i].empty(); ++i) {
const std::string& p = pathConcat(d, subdirs[i]);
if (fileExists(p)) {
directoryArray.append(p);
}
}
}
}
logLazyPrintf("Initializing System::findDataFile took %fs\n", System::time() - t0);
}
for (int i = 0; i < directoryArray.size(); ++i) {
const std::string& p = pathConcat(directoryArray[i], full);
if (fileExists(p)) {
lastFound.set(full, p);
return p;
}
}
if (errorIfNotFound) {
// Generate an error message
std::string locations;
for (int i = 0; i < directoryArray.size(); ++i) {
locations += pathConcat(directoryArray[i], full) + "\n";
}
alwaysAssertM(false, "Could not find '" + full + "' in:\n" + locations);
}
// Not found
return "";
}
void StegoModel::openDirectory(const char* path) {
int i, j, k;
int num_sets = 0;
int bin;
char *str = (char*) malloc(512*sizeof(char));
DIR *root = opendir(path);
FILE *file;
featureHeader header;
struct dirent *entry;
if (root == NULL) {
// printf("root is NULL \n");
return;
}
// printf("Root not NULL. \n");
while ((entry = readdir(root)) != NULL) {
if (strstr(entry->d_name, ".fv") != NULL) {
num_sets++;
}
}
// printf("about to open dir with %i feature files \n", num_sets);
rewinddir(root);
for(i = 0; i < num_sets; ) {
entry = readdir(root);
if (strstr(entry->d_name, ".fv") != NULL) {
pathConcat(path, entry->d_name, str);
openFile(str, i, num_sets, header);
// file = fopen(str, "r");
// readHeader(file, &header);
// if (ranges == 0) {
// printf("first file is being added! \n");
// ranges = (int**) malloc(3*sizeof(int*));
// for (k = 0; k < 3; k++) {
// ranges[k] = (int*) malloc(num_coefs[k]*sizeof(int));
// for (j = 0; j < num_coefs[k]; j++)
// ranges[k][j] = header.ranges[k][j];
// }
// }
// fclose(file);
//
// // printf("method: %i \n", header.method);
// // printf("qp range: %i \n", header.qp_range);
// if (header.method == 0) {
// if (cleanSet == 0) {
// cleanSet = openFeatureSet(str, steg);
// } else {
// // printf("adding new feature file to clean set \n");
// newFeatureFile(steg, cleanSet, str);
// }
// } else {
// if (collections[pair<int, int>(header.method,header.accept)] == 0) {
// collections[pair<int, int>(header.method,header.accept)] = new FeatureCollection(&header);
// printf("Created new collection for method %i and accept %i \n", header.method, header.accept);
// }
// collections[pair<int, int>(header.method, header.accept)]->addFeatureFile(str, &header, steg, cleanSet);
// }
// i++;
// progressChanged((double) i / (double) num_sets);
}
}
collectionChanged();
closedir(root);
free(str);
}
std::string YipDirectory::getGitRepositoryPath(const std::string & url)
{
return pathConcat(m_Path, "git-" + sha1(url).substr(1, 10));
}
std::string YipDirectory::writeFile(const std::string & path, const std::string & data, bool * changed)
{
std::string file = pathSimplify(pathConcat(m_Path, path));
bool has_sha1 = false, write = true;
std::string new_sha1;
SQLiteTransaction transaction(m_DB);
// Check whether file has changed
if (pathIsExistent(file))
{
// Canonicalize file path
file = pathMakeCanonical(file);
// Get information about file from the database
bool found = false;
size_t old_size = 0;
time_t old_time = 0;
std::string old_sha1;
m_DB->select("SELECT size, time, sha1 FROM files WHERE path = ? LIMIT 1", { file },
[&found, &old_size, &old_time, &old_sha1](const SQLiteCursor & cursor) {
found = true;
old_size = cursor.toSizeT(0);
old_time = cursor.toTimeT(1);
old_sha1 = cursor.toString(2);
}
);
// Check whether file has been modified
if (found && data.size() == old_size)
{
if (pathGetModificationTime(file) <= old_time)
{
new_sha1 = sha1(data);
has_sha1 = true;
if (new_sha1 == old_sha1)
write = false;
}
}
}
// Do not overwrite file if it did not change
if (!write)
{
std::cout << "keeping " << path << std::endl;
if (changed)
*changed = false;
assert(has_sha1);
m_DB->exec(fmt() << "REPLACE INTO files (path, size, time, sha1) VALUES (?, " << data.size() << ", "
<< time(nullptr) << ", ?)", { file, new_sha1 });
transaction.commit();
return file;
}
std::cout << "writing " << path << std::endl;
if (changed)
*changed = true;
// Calculate SHA1 sum of the file
if (!has_sha1)
new_sha1 = sha1(data);
// Create directory for the file
std::string dir = pathGetDirectory(file);
if (dir.length() > 0)
pathCreate(dir);
// Write the file
::writeFile(file, data);
// Store information about file into the database
m_DB->exec(fmt() << "REPLACE INTO files (path, size, time, sha1) VALUES (?, " << data.size() << ", "
<< time(nullptr) << ", ?)", { file, new_sha1 });
transaction.commit();
return file;
}
