mirror of
https://github.com/Sneed-Group/Poodletooth-iLand
synced 2024-12-23 19:52:37 -06:00
534 lines
18 KiB
C++
534 lines
18 KiB
C++
// Filename: ppDependableFile.cxx
|
|
// Created by: drose (15Oct00)
|
|
//
|
|
////////////////////////////////////////////////////////////////////
|
|
|
|
#include "ppDependableFile.h"
|
|
#include "ppDirectory.h"
|
|
#include "ppDirectoryTree.h"
|
|
#include "filename.h"
|
|
#include "check_include.h"
|
|
|
|
#ifdef HAVE_UNISTD_H
|
|
#include <unistd.h>
|
|
#endif
|
|
|
|
#include <assert.h>
|
|
#include <sys/stat.h>
|
|
#include <algorithm>
|
|
#include <iterator>
|
|
|
|
class SortDependableFilesByName {
|
|
public:
|
|
bool operator () (PPDependableFile *a, PPDependableFile *b) const {
|
|
return a->get_filename() < b->get_filename();
|
|
}
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: PPDependableFile::Ordering Operator
|
|
// Access: Public
|
|
// Description: We provide this function so we can sort the
|
|
// dependency list into a consistent ordering, so that
|
|
// the makefiles won't get randomly regenerated between
|
|
// different sessions.
|
|
////////////////////////////////////////////////////////////////////
|
|
bool PPDependableFile::Dependency::
|
|
operator < (const Dependency &other) const {
|
|
return _file->get_filename() < other._file->get_filename();
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: PPDependableFile::Constructor
|
|
// Access: Public
|
|
// Description:
|
|
////////////////////////////////////////////////////////////////////
|
|
PPDependableFile::
|
|
PPDependableFile(PPDirectory *directory, const string &filename) :
|
|
_directory(directory),
|
|
_filename(filename)
|
|
{
|
|
_flags = 0;
|
|
_mtime = 0;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: PPDependableFile::update_from_cache
|
|
// Access: Public
|
|
// Description: Called as the dependency cache file is being read,
|
|
// this asks the file to update its information from the
|
|
// cache file if appropriate. This means comparing the
|
|
// cached modification time against the file's actual
|
|
// modification time, and storing the cached
|
|
// dependencies if they match.
|
|
//
|
|
// The return value is true if the cache is valid, false
|
|
// if something appears to be wrong.
|
|
////////////////////////////////////////////////////////////////////
|
|
bool PPDependableFile::
|
|
update_from_cache(const vector<string> &words) {
|
|
// Shouldn't call this once the file has actually been read.
|
|
assert((_flags & F_updated) == 0);
|
|
assert((_flags & F_updating) == 0);
|
|
assert((_flags & F_from_cache) == 0);
|
|
assert(words.size() >= 2);
|
|
|
|
if (!exists()) {
|
|
// The file doesn't even exist; clearly the cache is bad.
|
|
_flags |= F_bad_cache;
|
|
|
|
} else {
|
|
// The second parameter is the cached modification time.
|
|
time_t mtime = strtol(words[1].c_str(), (char **)NULL, 10);
|
|
if (mtime == get_mtime()) {
|
|
// The modification matches; preserve the cache information.
|
|
PPDirectoryTree *tree = _directory->get_tree();
|
|
|
|
_dependencies.clear();
|
|
vector<string>::const_iterator wi;
|
|
for (wi = words.begin() + 2; wi != words.end(); ++wi) {
|
|
string dirpath = (*wi);
|
|
|
|
Dependency dep;
|
|
dep._okcircular = false;
|
|
|
|
if (dirpath.length() > 1 && dirpath[0] == '/') {
|
|
// If the first character is '/', it means that the file has
|
|
// been marked okcircular.
|
|
dep._okcircular = true;
|
|
dirpath = dirpath.substr(1);
|
|
}
|
|
|
|
if (dirpath.length() > 2 && dirpath.substr(0, 2) == "*/") {
|
|
// This is an extra include file, not a file in this source
|
|
// tree.
|
|
_extra_includes.push_back(dirpath.substr(2));
|
|
|
|
} else {
|
|
dep._file =
|
|
tree->get_dependable_file_by_dirpath(dirpath, false);
|
|
if (dep._file != (PPDependableFile *)NULL) {
|
|
_dependencies.push_back(dep);
|
|
}
|
|
}
|
|
}
|
|
|
|
_flags |= F_from_cache;
|
|
sort(_dependencies.begin(), _dependencies.end());
|
|
}
|
|
}
|
|
|
|
return ((_flags & F_bad_cache) == 0);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: PPDependableFile::clear_cache
|
|
// Access: Public
|
|
// Description: Forgets the cache we just read.
|
|
////////////////////////////////////////////////////////////////////
|
|
void PPDependableFile::
|
|
clear_cache() {
|
|
_dependencies.clear();
|
|
_flags &= ~(F_bad_cache | F_from_cache);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: PPDependableFile::write_cache
|
|
// Access: Public
|
|
// Description: Writes the dependency information out as a single
|
|
// line to the indicated dependency cache file.
|
|
////////////////////////////////////////////////////////////////////
|
|
void PPDependableFile::
|
|
write_cache(ostream &out) {
|
|
out << _filename << " " << get_mtime();
|
|
|
|
Dependencies::const_iterator di;
|
|
for (di = _dependencies.begin(); di != _dependencies.end(); ++di) {
|
|
out << " ";
|
|
if ((*di)._okcircular) {
|
|
out << "/";
|
|
}
|
|
if ((*di)._file->get_directory()->get_tree() != get_directory()->get_tree()) {
|
|
out << "+";
|
|
}
|
|
out << (*di)._file->get_dirpath();
|
|
}
|
|
|
|
// Also write out the extra includes--those #include directives
|
|
// which do not reference a file within this source tree. We need
|
|
// those just for comparison's sake later, so we can tell whether
|
|
// the cache line is still current (without having to know which
|
|
// files are part of the tree).
|
|
ExtraIncludes::const_iterator ei;
|
|
for (ei = _extra_includes.begin(); ei != _extra_includes.end(); ++ei) {
|
|
out << " */" << (*ei);
|
|
}
|
|
|
|
out << "\n";
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: PPDependableFile::get_directory
|
|
// Access: Public
|
|
// Description: Returns the directory that this file can be found in.
|
|
////////////////////////////////////////////////////////////////////
|
|
PPDirectory *PPDependableFile::
|
|
get_directory() const {
|
|
return _directory;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: PPDependableFile::get_filename
|
|
// Access: Public
|
|
// Description: Returns the local filename of this particular file
|
|
// within the directory.
|
|
////////////////////////////////////////////////////////////////////
|
|
const string &PPDependableFile::
|
|
get_filename() const {
|
|
return _filename;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: PPDependableFile::get_pathname
|
|
// Access: Public
|
|
// Description: Returns the relative pathname from the root of the
|
|
// source tree to this particular filename.
|
|
////////////////////////////////////////////////////////////////////
|
|
string PPDependableFile::
|
|
get_pathname() const {
|
|
return _directory->get_path() + "/" + _filename;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: PPDependableFile::get_fullpath
|
|
// Access: Public
|
|
// Description: Returns the full pathname to this particular filename.
|
|
////////////////////////////////////////////////////////////////////
|
|
string PPDependableFile::
|
|
get_fullpath() const {
|
|
return _directory->get_fullpath() + "/" + _filename;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: PPDependableFile::get_dirpath
|
|
// Access: Public
|
|
// Description: Returns an abbreviated pathname to this file, in the
|
|
// form dirname/filename.
|
|
////////////////////////////////////////////////////////////////////
|
|
string PPDependableFile::
|
|
get_dirpath() const {
|
|
return _directory->get_dirname() + "/" + _filename;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: PPDependableFile::exists
|
|
// Access: Public
|
|
// Description: Returns true if the file exists, false if it does
|
|
// not.
|
|
////////////////////////////////////////////////////////////////////
|
|
bool PPDependableFile::
|
|
exists() {
|
|
stat_file();
|
|
return ((_flags & F_exists) != 0);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: PPDependableFile::get_mtime
|
|
// Access: Public
|
|
// Description: Returns the last modification time of the file.
|
|
////////////////////////////////////////////////////////////////////
|
|
time_t PPDependableFile::
|
|
get_mtime() {
|
|
stat_file();
|
|
return _mtime;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: PPDependableFile::get_num_dependencies
|
|
// Access: Public
|
|
// Description: Returns the number of files this file depends on.
|
|
////////////////////////////////////////////////////////////////////
|
|
int PPDependableFile::
|
|
get_num_dependencies() {
|
|
update_dependencies();
|
|
return _dependencies.size();
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: PPDependableFile::get_dependency
|
|
// Access: Public
|
|
// Description: Returns the nth file this file depends on.
|
|
////////////////////////////////////////////////////////////////////
|
|
PPDependableFile *PPDependableFile::
|
|
get_dependency(int n) {
|
|
assert((_flags & F_updated) != 0);
|
|
assert(n >= 0 && n < (int)_dependencies.size());
|
|
return _dependencies[n]._file;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: PPDependableFile::get_complete_dependencies
|
|
// Access: Public
|
|
// Description: This flavor of get_complete_dependencies() works like
|
|
// the one below, except it returns the results in a
|
|
// consistently-ordered vector. This allows us to keep
|
|
// the dependencies in the same order between sessions
|
|
// and prevent makefiles from being arbitrarily
|
|
// regenerated.
|
|
////////////////////////////////////////////////////////////////////
|
|
void PPDependableFile::
|
|
get_complete_dependencies(vector<PPDependableFile *> &files) {
|
|
set<PPDependableFile *> files_set;
|
|
get_complete_dependencies(files_set);
|
|
|
|
copy(files_set.begin(), files_set.end(), back_inserter(files));
|
|
sort(files.begin(), files.end(), SortDependableFilesByName());
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: PPDependableFile::get_complete_dependencies
|
|
// Access: Public
|
|
// Description: Recursively determines the complete set of files this
|
|
// file depends on. It is the user's responsibility to
|
|
// empty the set before calling this function; the
|
|
// results will simply be added to the existing set.
|
|
////////////////////////////////////////////////////////////////////
|
|
void PPDependableFile::
|
|
get_complete_dependencies(set<PPDependableFile *> &files) {
|
|
update_dependencies();
|
|
Dependencies::const_iterator di;
|
|
for (di = _dependencies.begin(); di != _dependencies.end(); ++di) {
|
|
PPDependableFile *file = (*di)._file;
|
|
if (files.insert(file).second) {
|
|
file->get_complete_dependencies(files);
|
|
}
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: PPDependableFile::is_circularity
|
|
// Access: Public
|
|
// Description: Returns true if a circular dependency exists between
|
|
// this file and one or more other files.
|
|
////////////////////////////////////////////////////////////////////
|
|
bool PPDependableFile::
|
|
is_circularity() {
|
|
update_dependencies();
|
|
return (_flags & F_circularity) != 0;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: PPDependableFile::get_circularity
|
|
// Access: Public
|
|
// Description: If is_circularity() returns true, returns a string
|
|
// describing the circular dependency path for the user.
|
|
////////////////////////////////////////////////////////////////////
|
|
string PPDependableFile::
|
|
get_circularity() {
|
|
update_dependencies();
|
|
return _circularity;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: PPDependableFile::was_examined
|
|
// Access: Public
|
|
// Description: Returns true if anyone ever asked this file for its
|
|
// list of dependencies, or false otherwise.
|
|
////////////////////////////////////////////////////////////////////
|
|
bool PPDependableFile::
|
|
was_examined() const {
|
|
return ((_flags & F_updated) != 0);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: PPDependableFile::was_cached
|
|
// Access: Public
|
|
// Description: Returns true if this file was found in the cache,
|
|
// false otherwise.
|
|
////////////////////////////////////////////////////////////////////
|
|
bool PPDependableFile::
|
|
was_cached() const {
|
|
return ((_flags & F_from_cache) != 0);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: PPDependableFile::update_dependencies
|
|
// Access: Private
|
|
// Description: Builds up the dependency list--the list of files this
|
|
// file depends on--if it hasn't already been built. If
|
|
// a circular dependency is detected during this
|
|
// process, _circularity and _circularity_detected will
|
|
// be updated accordingly.
|
|
////////////////////////////////////////////////////////////////////
|
|
void PPDependableFile::
|
|
update_dependencies() {
|
|
if ((_flags & F_updated) != 0) {
|
|
return;
|
|
}
|
|
|
|
assert((_flags & F_updating) == 0);
|
|
string circularity;
|
|
compute_dependencies(circularity);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: PPDependableFile::compute_dependencies
|
|
// Access: Private
|
|
// Description: Builds up the dependency list--the list of files this
|
|
// file depends on--if it hasn't already been built.
|
|
//
|
|
// If a circularity is detected, e.g. two files depend
|
|
// on each other, a pointer to the offending file is
|
|
// returned and the string is updated to indicate the
|
|
// circularity. Otherwise, if there is no circularity,
|
|
// NULL is returned.
|
|
////////////////////////////////////////////////////////////////////
|
|
PPDependableFile *PPDependableFile::
|
|
compute_dependencies(string &circularity) {
|
|
if ((_flags & F_updated) != 0) {
|
|
return (PPDependableFile *)NULL;
|
|
|
|
} else if ((_flags & F_updating) != 0) {
|
|
// Oh oh, a circular dependency!
|
|
circularity = get_dirpath();
|
|
return this;
|
|
}
|
|
|
|
_flags |= F_updating;
|
|
|
|
if ((_flags & F_from_cache) == 0) {
|
|
// Now open the file and scan it for #include statements.
|
|
Filename filename(get_fullpath());
|
|
filename.set_text();
|
|
ifstream in;
|
|
if (!filename.open_read(in)) {
|
|
// Can't read the file, or the file doesn't exist. Interesting.
|
|
if (exists()) {
|
|
cerr << "Warning: dependent file " << filename
|
|
<< " exists but cannot be read.\n";
|
|
} else {
|
|
cerr << "Warning: dependent file " << filename
|
|
<< " does not exist.\n";
|
|
_flags |= F_bad_cache;
|
|
}
|
|
|
|
} else {
|
|
if (verbose) {
|
|
cerr << "Reading (dep) \"" << filename << "\"\n";
|
|
}
|
|
PPDirectoryTree *tree = _directory->get_tree()->get_main_tree();
|
|
|
|
bool okcircular = false;
|
|
string line;
|
|
getline(in, line);
|
|
while (!in.fail() && !in.eof()) {
|
|
if (line.substr(0, 16) == "/* okcircular */") {
|
|
okcircular = true;
|
|
} else {
|
|
string filename = check_include(line);
|
|
if (!filename.empty() && filename.find('/') == string::npos) {
|
|
Dependency dep;
|
|
dep._okcircular = okcircular;
|
|
dep._file = tree->find_dependable_file(filename);
|
|
if (dep._file != (PPDependableFile *)NULL) {
|
|
// All right! Here's a file we depend on. Add it to the
|
|
// list.
|
|
_dependencies.push_back(dep);
|
|
|
|
} else {
|
|
// It's an include file from somewhere else, not from within
|
|
// our source tree. We don't care about it, but we do need
|
|
// to record it so we can easily check later if the cache
|
|
// file has gone stale.
|
|
_extra_includes.push_back(filename);
|
|
}
|
|
}
|
|
okcircular = false;
|
|
}
|
|
getline(in, line);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Now recursively expand all our dependent files, so we can check
|
|
// for circularities.
|
|
PPDependableFile *circ = (PPDependableFile *)NULL;
|
|
|
|
Dependencies::iterator di;
|
|
for (di = _dependencies.begin();
|
|
di != _dependencies.end() && circ == (PPDependableFile *)NULL;
|
|
++di) {
|
|
// Skip this file if the user specifically marked it
|
|
// with an "okcircular" comment.
|
|
if (!(*di)._okcircular) {
|
|
circ = (*di)._file->compute_dependencies(circularity);
|
|
if (((*di)._file->_flags & F_bad_cache) != 0) {
|
|
// If our dependent file had a broken cache, our own cache is
|
|
// suspect.
|
|
_flags |= F_bad_cache;
|
|
}
|
|
|
|
if (circ != (PPDependableFile *)NULL) {
|
|
// Oops, a circularity. Silly user.
|
|
circularity = get_dirpath() + " => " + circularity;
|
|
|
|
if (circ == this) {
|
|
_flags |= F_circularity;
|
|
_circularity = circularity;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
_flags = (_flags & ~F_updating) | F_updated;
|
|
sort(_dependencies.begin(), _dependencies.end());
|
|
|
|
if ((_flags & (F_bad_cache | F_from_cache)) == (F_bad_cache | F_from_cache)) {
|
|
// Our cache is suspect. Re-read the file to flush the cache.
|
|
if (verbose) {
|
|
cerr << "Dependency cache for \"" << get_fullpath() << "\" is suspect.\n";
|
|
}
|
|
|
|
clear_cache();
|
|
_flags &= ~F_updated;
|
|
|
|
return compute_dependencies(circularity);
|
|
}
|
|
|
|
return circ;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: PPDependableFile::stat_file
|
|
// Access: Private
|
|
// Description: Performs a stat() on the file, if it has not already
|
|
// been performed, to check whether the file exists and
|
|
// to get its last-modification time.
|
|
////////////////////////////////////////////////////////////////////
|
|
void PPDependableFile::
|
|
stat_file() {
|
|
if ((_flags & F_statted) != 0) {
|
|
// Already done.
|
|
return;
|
|
}
|
|
|
|
_flags |= F_statted;
|
|
struct stat st;
|
|
Filename pathname(get_fullpath());
|
|
string ospath = pathname.to_os_specific();
|
|
if (stat(ospath.c_str(), &st) < 0) {
|
|
// The file doesn't exist!
|
|
return;
|
|
}
|
|
|
|
#ifdef S_ISREG
|
|
if (!S_ISREG(st.st_mode)) {
|
|
// The file exists, but it's not a regular file--we consider that
|
|
// not existing.
|
|
return;
|
|
}
|
|
#endif // S_ISREG
|
|
|
|
_flags |= F_exists;
|
|
_mtime = st.st_mtime;
|
|
}
|