Builder can build itself now.

[builder.git] / source / package.cpp

diff --git a/source/package.cpp b/source/package.cpp
index 5cf7e07b6bd7e67e00cdf550c217dfb6dc80a6cb..fcbe9f7a6208fe8c10f3bac150f78d5c6986138c 100644 (file)
--- a/source/package.cpp
+++ b/source/package.cpp
@@ -1,4 +1,6 @@
+#include <msp/strutils.h>
 #include "builder.h"
+#include "misc.h"
 #include "package.h"
 
 using namespace std;
@@ -10,7 +12,7 @@ PackageRef::PackageRef(Builder &b, const string &n):
        package(0)
 { }
 
-Package *PackageRef::get_package()
+Package *PackageRef::resolve()
 {
        if(!package)
                package=builder.get_package(name);
@@ -21,14 +23,135 @@ Package::Package(Builder &b, const string &n, const Path::Path &s):
        builder(b),
        name(n),
        source(s),
-       buildable(false)
+       buildable(true),
+       build_info_ready(false)
+{ }
+
+Package::Package(Builder &b, const string &n, const vector<string> &info):
+       builder(b),
+       name(n),
+       buildable(false),
+       build_info_ready(true)
 {
+       for(vector<string>::const_iterator i=info.begin(); i!=info.end(); ++i)
+       {
+               if(!i->compare(0, 2, "-I"))
+                       export_binfo.incpath.push_back(i->substr(2));
+               else if(!i->compare(0, 2, "-D"))
+                       export_binfo.defines.push_back(i->substr(2));
+               else if(!i->compare(0, 2, "-L"))
+                       export_binfo.libpath.push_back(i->substr(2));
+               else if(!i->compare(0, 2, "-l"))
+                       export_binfo.libs.push_back(i->substr(2));
+       }
 }
 
 void Package::resolve_refs()
 {
        for(list<PackageRef>::iterator i=requires.begin(); i!=requires.end(); ++i)
-               i->get_package();
+               i->resolve();
+}
+
+void Package::create_build_info()
+{
+       if(build_info_ready)
+               return;
+       
+       for(list<PackageRef>::iterator i=requires.begin(); i!=requires.end(); ++i)
+       {
+               if(!i->get_package())
+                       continue;
+               i->get_package()->create_build_info();
+               build_info.add(i->get_package()->get_exported_binfo());
+       }
+       
+       build_info.cflags.push_back("-Wall");
+       build_info.cflags.push_back("-Wshadow");
+       build_info.cflags.push_back("-Wextra");
+       build_info.cflags.push_back("-Wpointer-arith");
+       build_info.cflags.push_back("-Wconversion");
+       build_info.cflags.push_back("-Werror");
+
+       unsigned flags=get_install_flags();
+
+       if(flags&INCLUDE)
+               export_binfo.incpath.push_back((Path::Path(config.get_option("prefix").value)/"include").str());
+       if(flags&LIB)
+               export_binfo.libpath.push_back((Path::Path(config.get_option("prefix").value)/"lib").str());
+
+       build_info.unique();
+       export_binfo.unique();
+
+       for(list<Component>::iterator i=components.begin(); i!=components.end(); ++i)
+       {
+               i->create_build_info();
+               if(i->get_type()==Component::LIBRARY)
+                       export_binfo.libs.push_back(i->get_name());
+       }
+
+       build_info_ready=true;
+}
+
+void Package::process_options(const RawOptionMap &opts)
+{
+       config.process(opts);
+}
+
+Package *Package::create(Builder &b, const string &name)
+{
+       list<string> argv;
+       argv.push_back("pkg-config");
+       argv.push_back("--cflags");
+       argv.push_back("--libs");
+       argv.push_back(name);
+       vector<string> info=split(run_command(argv));
+       
+       if(info.empty())
+               return 0;
+       
+       Package *pkg=new Package(b, name, info);
+       return pkg;
+}
+
+void Package::init_buildable()
+{
+       buildable=true;
+
+       config.add_option("tempdir",  "temp", "Directory for storing temporary files");
+       config.add_option("optimize", "0",    "Apply compiler optimizations");
+       config.add_option("debug",    "0",    "Produce debugging symbols");
+
+       const char *home=getenv("HOME");
+       unsigned flags=get_install_flags();
+       if(flags)
+               config.add_option("prefix",     string(home)+"/local"/*"/usr"*/,            "Installation prefix");
+       /*if(flags&INCLUDE)
+               config.add_option("includedir", "$prefix/include", "Header installation directory");
+       if(flags&BIN)
+               config.add_option("includedir", "$prefix/bin",     "Binary installation directory");
+       if(flags&LIB)
+               config.add_option("includedir", "$prefix/lib",     "Library installation directory");
+       if(flags&DATA)
+               config.add_option("includedir", "$prefix/share",   "Data installation directory");*/
+}
+
+unsigned Package::get_install_flags()
+{
+       unsigned flags=0;
+       for(ComponentList::iterator i=components.begin(); i!=components.end(); ++i)
+       {
+               if(i->get_install())
+               {
+                       if(i->get_type()==Component::PROGRAM)
+                               flags|=BIN;
+                       else if(i->get_type()==Component::LIBRARY || i->get_type()==Component::MODULE)
+                               flags|=LIB;
+               }
+               if(!i->get_install_headers().empty())
+                       flags|=INCLUDE;
+       }
+
+       return flags;
 }
 
 Package::Loader::Loader(Package &p):
@@ -43,7 +166,7 @@ Package::Loader::Loader(Package &p):
 
 Package::Loader::~Loader()
 {
-       pkg.buildable=true;
+       pkg.init_buildable();
 }
 
 void Package::Loader::require(const string &n)