Poodletooth-iLand/build/nirai/panda3d/ppremake/ppDependableFile.cxx

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;
}