source/package.cpp

   1 #include <msp/strutils.h>
   2 #include "builder.h"
   3 #include "misc.h"
   4 #include "package.h"
   5
   6 using namespace std;
   7 using namespace Msp;
   8
   9 PackageRef::PackageRef(Builder &b, const string &n):
  10         builder(b),
  11         name(n),
  12         package(0)
  13 { }
  14
  15 Package *PackageRef::resolve()
  16 {
  17         if(!package)
  18                 package=builder.get_package(name);
  19         return package;
  20 }
  21
  22 Package::Package(Builder &b, const string &n, const Path::Path &s):
  23         builder(b),
  24         name(n),
  25         source(s),
  26         buildable(true),
  27         build_info_ready(false)
  28 { }
  29
  30 Package::Package(Builder &b, const string &n, const vector<string> &info):
  31         builder(b),
  32         name(n),
  33         buildable(false),
  34         build_info_ready(true)
  35 {
  36         for(vector<string>::const_iterator i=info.begin(); i!=info.end(); ++i)
  37         {
  38                 if(!i->compare(0, 2, "-I"))
  39                         export_binfo.incpath.push_back(i->substr(2));
  40                 else if(!i->compare(0, 2, "-D"))
  41                         export_binfo.defines.push_back(i->substr(2));
  42                 else if(!i->compare(0, 2, "-L"))
  43                         export_binfo.libpath.push_back(i->substr(2));
  44                 else if(!i->compare(0, 2, "-l"))
  45                         export_binfo.libs.push_back(i->substr(2));
  46         }
  47 }
  48
  49 void Package::resolve_refs()
  50 {
  51         for(list<PackageRef>::iterator i=requires.begin(); i!=requires.end(); ++i)
  52                 i->resolve();
  53 }
  54
  55 void Package::create_build_info()
  56 {
  57         if(build_info_ready)
  58                 return;
  59
  60         for(list<PackageRef>::iterator i=requires.begin(); i!=requires.end(); ++i)
  61         {
  62                 if(!i->get_package())
  63                         continue;
  64                 i->get_package()->create_build_info();
  65                 build_info.add(i->get_package()->get_exported_binfo());
  66         }
  67
  68         build_info.cflags.push_back("-Wall");
  69         build_info.cflags.push_back("-Wshadow");
  70         build_info.cflags.push_back("-Wextra");
  71         build_info.cflags.push_back("-Wpointer-arith");
  72         build_info.cflags.push_back("-Wconversion");
  73         build_info.cflags.push_back("-Werror");
  74
  75         unsigned flags=get_install_flags();
  76
  77         if(flags&INCLUDE)
  78                 export_binfo.incpath.push_back((Path::Path(config.get_option("prefix").value)/"include").str());
  79         if(flags&LIB)
  80                 export_binfo.libpath.push_back((Path::Path(config.get_option("prefix").value)/"lib").str());
  81
  82         build_info.unique();
  83         export_binfo.unique();
  84
  85         for(list<Component>::iterator i=components.begin(); i!=components.end(); ++i)
  86         {
  87                 i->create_build_info();
  88                 if(i->get_type()==Component::LIBRARY)
  89                         export_binfo.libs.push_back(i->get_name());
  90         }
  91
  92         build_info_ready=true;
  93 }
  94
  95 void Package::process_options(const RawOptionMap &opts)
  96 {
  97         config.process(opts);
  98 }
  99
 100 Package *Package::create(Builder &b, const string &name)
 101 {
 102         list<string> argv;
 103         argv.push_back("pkg-config");
 104         argv.push_back("--cflags");
 105         argv.push_back("--libs");
 106         argv.push_back(name);
 107         vector<string> info=split(run_command(argv));
 108
 109         if(info.empty())
 110                 return 0;
 111
 112         Package *pkg=new Package(b, name, info);
 113         return pkg;
 114 }
 115
 116 void Package::init_buildable()
 117 {
 118         buildable=true;
 119
 120         config.add_option("tempdir",  "temp", "Directory for storing temporary files");
 121         config.add_option("optimize", "0",    "Apply compiler optimizations");
 122         config.add_option("debug",    "0",    "Produce debugging symbols");
 123
 124         const char *home=getenv("HOME");
 125         unsigned flags=get_install_flags();
 126         if(flags)
 127                 config.add_option("prefix",     string(home)+"/local"/*"/usr"*/,            "Installation prefix");
 128         /*if(flags&INCLUDE)
 129                 config.add_option("includedir", "$prefix/include", "Header installation directory");
 130         if(flags&BIN)
 131                 config.add_option("includedir", "$prefix/bin",     "Binary installation directory");
 132         if(flags&LIB)
 133                 config.add_option("includedir", "$prefix/lib",     "Library installation directory");
 134         if(flags&DATA)
 135                 config.add_option("includedir", "$prefix/share",   "Data installation directory");*/
 136 }
 137
 138 unsigned Package::get_install_flags()
 139 {
 140         unsigned flags=0;
 141         for(ComponentList::iterator i=components.begin(); i!=components.end(); ++i)
 142         {
 143                 if(i->get_install())
 144                 {
 145                         if(i->get_type()==Component::PROGRAM)
 146                                 flags|=BIN;
 147                         else if(i->get_type()==Component::LIBRARY || i->get_type()==Component::MODULE)
 148                                 flags|=LIB;
 149                 }
 150                 if(!i->get_install_headers().empty())
 151                         flags|=INCLUDE;
 152         }
 153
 154         return flags;
 155 }
 156
 157 Package::Loader::Loader(Package &p):
 158         pkg(p)
 159 {
 160         add("version",     &Package::version);
 161         add("description", &Package::description);
 162         add("require",     &Loader::require);
 163         add("program",     &Loader::program);
 164         add("library",     &Loader::library);
 165 }
 166
 167 Package::Loader::~Loader()
 168 {
 169         pkg.init_buildable();
 170 }
 171
 172 void Package::Loader::require(const string &n)
 173 {
 174         pkg.requires.push_back(PackageRef(pkg.builder, n));
 175 }
 176
 177 void Package::Loader::program(const std::string &n)
 178 {
 179         Component prog(pkg, Component::PROGRAM, n);
 180         load_sub(prog);
 181         pkg.components.push_back(prog);
 182 }
 183
 184 void Package::Loader::library(const std::string &n)
 185 {
 186         Component prog(pkg, Component::LIBRARY, n);
 187         load_sub(prog);
 188         pkg.components.push_back(prog);
 189 }