source/package.cpp

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