diff --git a/buildtool.cpp b/buildtool.cpp
index 34f542b3ef57e41692ddfb0fed3136438b4b02e2..6d1dd25a8795f0a920d576bc27d204492d8eaa28 100644 (file)
--- a/buildtool.cpp
+++ b/buildtool.cpp
* or
* btool {target}
*
- * Note: recent win32api builds from MinGW have gettimeofday()
- * defined, so you might need to build with
- * g++ -O3 -DHAVE_GETTIMEOFDAY buildtool.cpp -o btool.exe
+ * Note: if you are using MinGW, and a not very recent version of it,
+ * gettimeofday() might be missing. If so, just build this file with
+ * this command:
+ * g++ -O3 -DNEED_GETTIMEOFDAY buildtool.cpp -o btool.exe
*
*/
-#define BUILDTOOL_VERSION "BuildTool v0.6.6, 2007 Bob Jamison"
+#define BUILDTOOL_VERSION "BuildTool v0.6.12, 2007 Bob Jamison"
#include <stdio.h>
+#include <fcntl.h>
#include <unistd.h>
#include <stdarg.h>
#include <sys/stat.h>
//########################################################################
//# Definition of gettimeofday() for those who don't have it
//########################################################################
-#ifndef HAVE_GETTIMEOFDAY
+#ifdef NEED_GETTIMEOFDAY
#include <sys/timeb.h>
struct timezone {
* Constructor
*/
FileRec()
- {init(); type = UNKNOWN;}
+ { init(); type = UNKNOWN; }
/**
* Copy constructor
*/
FileRec(const FileRec &other)
- {init(); assign(other);}
+ { init(); assign(other); }
/**
* Constructor
*/
FileRec(int typeVal)
- {init(); type = typeVal;}
+ { init(); type = typeVal; }
/**
* Assignment operator
*/
FileRec &operator=(const FileRec &other)
- {init(); assign(other); return *this;}
+ { init(); assign(other); return *this; }
/**
path = other.path;
name = other.name;
suffix = other.suffix;
- files = other.files;
+ files = other.files; //avoid recursion
}
};
* Constructor
*/
DepTool()
- {init();}
+ { init(); }
/**
* Copy constructor
*/
DepTool(const DepTool &other)
- {init(); assign(other);}
+ { init(); assign(other); }
/**
* Assignment operator
*/
DepTool &operator=(const DepTool &other)
- {init(); assign(other); return *this;}
+ { init(); assign(other); return *this; }
/**
/**
*
*/
- bool processDependency(FileRec *ofile,
- FileRec *include,
- int depth);
+ bool processDependency(FileRec *ofile, FileRec *include);
/**
*
/**
* A list of all files which will be processed for
- * dependencies. This is the only list that has the actual
- * records. All other lists have pointers to these records.
+ * dependencies.
*/
std::map<String, FileRec *> allFiles;
* The list of .o files, and the
* dependencies upon them.
*/
- std::map<String, FileRec *> depFiles;
+ std::map<String, FileRec *> oFiles;
int depFileSize;
char *depFileBuf;
fileList.clear();
directories.clear();
- //clear refs
- depFiles.clear();
- //clear records
+ //clear output file list
std::map<String, FileRec *>::iterator iter;
- for (iter=allFiles.begin() ; iter!=allFiles.end() ; iter++)
- delete iter->second;
+ for (iter=oFiles.begin(); iter!=oFiles.end() ; iter++)
+ delete iter->second;
+ oFiles.clear();
+ //allFiles actually contains the master copies. delete them
+ for (iter= allFiles.begin(); iter!=allFiles.end() ; iter++)
+ delete iter->second;
allFiles.clear();
}
*/
bool DepTool::addIncludeFile(FileRec *frec, const String &iname)
{
-
+ //# if the name is an exact match to a path name
+ //# in allFiles, like "myinc.h"
std::map<String, FileRec *>::iterator iter =
allFiles.find(iname);
if (iter != allFiles.end()) //already exists
}
else
{
+ //## Ok, it was not found directly
//look in other dirs
std::vector<String>::iterator diter;
for (diter=directories.begin() ;
String dfname = *diter;
dfname.append("/");
dfname.append(iname);
- iter = allFiles.find(dfname);
+ URI fullPathURI(dfname); //normalize path name
+ String fullPath = fullPathURI.getPath();
+ if (fullPath[0] == '/')
+ fullPath = fullPath.substr(1);
+ //trace("Normalized %s to %s", dfname.c_str(), fullPath.c_str());
+ iter = allFiles.find(fullPath);
if (iter != allFiles.end())
{
FileRec *other = iter->second;
//trace("other: '%s'", iname.c_str());
- frec->files[dfname] = other;
+ frec->files[fullPath] = other;
return true;
}
}
* Recursively check include lists to find all files in allFiles to which
* a given file is dependent.
*/
-bool DepTool::processDependency(FileRec *ofile,
- FileRec *include,
- int depth)
+bool DepTool::processDependency(FileRec *ofile, FileRec *include)
{
std::map<String, FileRec *>::iterator iter;
for (iter=include->files.begin() ; iter!=include->files.end() ; iter++)
FileRec *child = iter->second;
ofile->files[fname] = child;
- processDependency(ofile, child, depth+1);
+ processDependency(ofile, child);
}
FileRec *include = iter->second;
if (include->type == FileRec::CFILE)
{
- String cFileName = iter->first;
- FileRec *ofile = new FileRec(FileRec::OFILE);
- ofile->path = include->path;
- ofile->baseName = include->baseName;
- ofile->suffix = include->suffix;
- String fname = include->path;
+ String cFileName = iter->first;
+ FileRec *ofile = new FileRec(FileRec::OFILE);
+ ofile->path = include->path;
+ ofile->baseName = include->baseName;
+ ofile->suffix = include->suffix;
+ String fname = include->path;
if (fname.size()>0)
fname.append("/");
fname.append(include->baseName);
fname.append(".o");
- depFiles[fname] = ofile;
+ oFiles[fname] = ofile;
//add the .c file first? no, don't
//ofile->files[cFileName] = include;
//trace("ofile:%s", fname.c_str());
- processDependency(ofile, include, 0);
+ processDependency(ofile, include);
}
}
fprintf(f, "<dependencies source='%s'>\n\n", sourceDir.c_str());
std::map<String, FileRec *>::iterator iter;
- for (iter=depFiles.begin() ; iter!=depFiles.end() ; iter++)
+ for (iter=oFiles.begin() ; iter!=oFiles.end() ; iter++)
{
FileRec *frec = iter->second;
if (frec->type == FileRec::OFILE)
if (root->getChildren().size()==0 ||
root->getChildren()[0]->getName()!="dependencies")
{
- error("Main xml element should be <dependencies>");
+ error("loadDepFile: main xml element should be <dependencies>");
delete root;
return result;
}
{
Element *objectElem = objects[i];
String tagName = objectElem->getName();
- if (tagName == "object")
- {
- String objName = objectElem->getAttribute("name");
- //trace("object:%s", objName.c_str());
- DepRec depObject(objName);
- depObject.path = objectElem->getAttribute("path");
- depObject.suffix = objectElem->getAttribute("suffix");
- //########## DESCRIPTION
- std::vector<Element *> depElems = objectElem->getChildren();
- for (unsigned int i=0 ; i<depElems.size() ; i++)
+ if (tagName != "object")
+ {
+ error("loadDepFile: <dependencies> should have only <object> children");
+ return result;
+ }
+
+ String objName = objectElem->getAttribute("name");
+ //trace("object:%s", objName.c_str());
+ DepRec depObject(objName);
+ depObject.path = objectElem->getAttribute("path");
+ depObject.suffix = objectElem->getAttribute("suffix");
+ //########## DESCRIPTION
+ std::vector<Element *> depElems = objectElem->getChildren();
+ for (unsigned int i=0 ; i<depElems.size() ; i++)
+ {
+ Element *depElem = depElems[i];
+ tagName = depElem->getName();
+ if (tagName != "dep")
{
- Element *depElem = depElems[i];
- tagName = depElem->getName();
- if (tagName == "dep")
- {
- String depName = depElem->getAttribute("name");
- //trace(" dep:%s", depName.c_str());
- depObject.files.push_back(depName);
- }
+ error("loadDepFile: <object> should have only <dep> children");
+ return result;
}
- //Insert into the result list, in a sorted manner
- bool inserted = false;
- std::vector<DepRec>::iterator iter;
- for (iter = result.begin() ; iter != result.end() ; iter++)
+ String depName = depElem->getAttribute("name");
+ //trace(" dep:%s", depName.c_str());
+ depObject.files.push_back(depName);
+ }
+
+ //Insert into the result list, in a sorted manner
+ bool inserted = false;
+ std::vector<DepRec>::iterator iter;
+ for (iter = result.begin() ; iter != result.end() ; iter++)
+ {
+ String vpath = iter->path;
+ vpath.append("/");
+ vpath.append(iter->name);
+ String opath = depObject.path;
+ opath.append("/");
+ opath.append(depObject.name);
+ if (vpath > opath)
{
- String vpath = iter->path;
- vpath.append("/");
- vpath.append(iter->name);
- String opath = depObject.path;
- opath.append("/");
- opath.append(depObject.name);
- if (vpath > opath)
- {
- inserted = true;
- iter = result.insert(iter, depObject);
- break;
- }
+ inserted = true;
+ iter = result.insert(iter, depObject);
+ break;
}
- if (!inserted)
- result.push_back(depObject);
}
+ if (!inserted)
+ result.push_back(depObject);
}
delete root;
virtual ~TaskCC()
{}
- virtual bool needsCompiling(const DepRec &depRec,
+ virtual bool needsCompiling(const FileRec &depRec,
const String &src, const String &dest)
{
return false;
//## Select command
String sfx = dep.suffix;
String command = ccCommand;
- if (sfx == "cpp" || sfx == "c++" || sfx == "cc"
- || sfx == "CC")
+ if (sfx == "cpp" || sfx == "cxx" || sfx == "c++" ||
+ sfx == "cc" || sfx == "CC")
command = cxxCommand;
//## Make paths
srcName.append(dep.suffix);
String srcFullName = parent.resolve(srcName);
bool compileMe = false;
+ //# First we check if the source is newer than the .o
if (isNewerThan(srcFullName, destFullName))
{
status(" : compile of %s required by %s",
}
else
{
+ //# secondly, we check if any of the included dependencies
+ //# of the .c/.cpp is newer than the .o
for (unsigned int i=0 ; i<dep.files.size() ; i++)
{
String depName;
- if (srcPath.size()>0)
+ if (source.size()>0)
{
- depName.append(srcPath);
+ depName.append(source);
depName.append("/");
}
depName.append(dep.files[i]);
String depFullName = parent.resolve(depName);
- if (isNewerThan(depFullName, destFullName))
+ bool depRequires = isNewerThan(depFullName, destFullName);
+ //trace("%d %s %s\n", depRequires,
+ // destFullName.c_str(), depFullName.c_str());
+ if (depRequires)
{
status(" : compile of %s required by %s",
destFullName.c_str(), depFullName.c_str());
}
if (!isNewerThan(fullSource, fullDest))
{
+ status(" : skipped");
return true;
}
if (!copyFile(fullSource, fullDest))
}
if (!isNewerThan(fullSource, fullDest))
{
+ status(" : skipped");
return true;
}
if (!copyFile(fullSource, fullDest))
deptool.setSourceDirectory("/dev/ink/inkscape/src");
if (!deptool.generateDependencies("build.dep"))
return false;
- std::vector<buildtool::DepRec> res =
+ std::vector<buildtool::FileRec> res =
deptool.loadDepFile("build.dep");
if (res.size() == 0)
return false;