source/builder.cpp

   1 #include <fstream>
   2 #include <msp/strutils.h>
   3 #include <msp/parser/parser.h>
   4 #include <msp/path/utils.h>
   5 #include "builder.h"
   6 #include "executable.h"
   7 #include "header.h"
   8 #include "misc.h"
   9 #include "objectfile.h"
  10 #include "package.h"
  11 #include "virtualtarget.h"
  12
  13 using namespace std;
  14 using namespace Msp;
  15
  16 Builder::Builder(int argc, char **argv):
  17         verbose(1),
  18         cwd(Path::getcwd())
  19 {
  20         for(int i=1; i<argc; ++i)
  21                 cmdline_targets.push_back(argv[i]);
  22         if(cmdline_targets.empty())
  23                 cmdline_targets.push_back("default");
  24 }
  25
  26 Package *Builder::get_package(const string &n)
  27 {
  28         PackageMap::iterator i=packages.find(n);
  29         if(i!=packages.end())
  30                 return i->second;
  31
  32         list<string> argv;
  33         argv.push_back("pkg-config");
  34         argv.push_back("--variable=source");
  35         argv.push_back(n);
  36         Path::Path srcdir=run_command(argv);
  37         if(srcdir.empty())
  38         {
  39                 string dirname=n;
  40                 if(dirname.compare(0, 3, "msp"))
  41                         dirname.erase(0, 3);
  42                 if(Path::exists(cwd/dirname))
  43                         srcdir=cwd/dirname;
  44                 else if(Path::exists(cwd/".."/dirname))
  45                         srcdir=cwd/".."/dirname;
  46         }
  47         else
  48                 srcdir=strip(srcdir.str());
  49
  50         if(!srcdir.empty())
  51                 load_build_file(srcdir/"Build");
  52
  53         return 0;
  54 }
  55
  56 Target *Builder::get_target(const string &n)
  57 {
  58         TargetMap::iterator i=targets.find(n);
  59         if(i!=targets.end())
  60                 return i->second;
  61         return 0;
  62 }
  63
  64 Target *Builder::get_header(const string &include, const string &from, const list<string> &path)
  65 {
  66         string id=from+":"+include;
  67         TargetMap::iterator i=includes.find(id);
  68         if(i!=includes.end())
  69                 return i->second;
  70
  71         string fn=include.substr(1);
  72         Target *tgt;
  73         if(include[0]=='"' && (tgt=check_header(Path::Path(from)/fn)))
  74                 return tgt;
  75         if((tgt=check_header(Path::Path("/usr/include")/fn)))
  76                 return tgt;
  77         if((tgt=check_header(Path::Path("/usr/include/c++/4.1.2")/fn)))
  78                 return tgt;
  79         for(list<string>::const_iterator j=path.begin(); j!=path.end(); ++j)
  80                 if((tgt=check_header(Path::Path(*j)/fn)))
  81                         return tgt;
  82
  83         return 0;
  84 }
  85
  86 int Builder::main()
  87 {
  88         if(load_build_file("Build"))
  89         {
  90                 cerr<<"No build info here.\n";
  91                 return 1;
  92         }
  93
  94         default_pkg=packages.begin()->second;
  95
  96         while(!new_pkgs.empty())
  97         {
  98                 Package *pkg=new_pkgs.front();
  99                 new_pkgs.erase(new_pkgs.begin());
 100                 pkg->resolve_refs();
 101         }
 102
 103         cout<<"Active packages:";
 104         for(PackageMap::iterator i=packages.begin(); i!=packages.end(); ++i)
 105         {
 106                 cout<<' '<<i->second->get_name();
 107                 if(i->second->get_buildable())
 108                         cout<<'*';
 109         }
 110         cout<<'\n';
 111
 112         create_targets();
 113
 114         for(TargetMap::iterator i=targets.begin(); i!=targets.end(); ++i)
 115                 cout<<i->second->get_name()<<' '<<i->second->get_type()<<'\n';
 116
 117         cout<<"Active targets: "<<targets.size()<<'\n';
 118
 119         return 0;
 120 }
 121
 122 int Builder::load_build_file(const Path::Path &fn)
 123 {
 124         ifstream in(fn.str().c_str());
 125         if(!in)
 126                 return -1;
 127
 128         Parser::Parser parser(in, fn.str());
 129         Loader loader(*this, cwd/fn.subpath(0, fn.size()-1));
 130         loader.load(parser);
 131
 132         return 0;
 133 }
 134
 135 void Builder::create_targets()
 136 {
 137         Target *world=new VirtualTarget(*this, "world");
 138         add_target(world);
 139         Target *def_tgt=new VirtualTarget(*this, "default");
 140         add_target(def_tgt);
 141
 142         for(PackageMap::iterator i=packages.begin(); i!=packages.end(); ++i)
 143         {
 144                 cout<<i->second->get_source()<<'\n';
 145                 const ComponentList &components=i->second->get_components();
 146                 for(ComponentList::const_iterator j=components.begin(); j!=components.end(); ++j)
 147                 {
 148                         Path::Path base=i->second->get_source()/j->get_source();
 149                         cout<<base<<'\n';
 150                         list<string> files=list_files(base);
 151
 152                         list<ObjectFile *> objs;
 153                         for(list<string>::iterator k=files.begin(); k!=files.end(); ++k)
 154                         {
 155                                 Path::Path fn=base/ *k;
 156                                 //cout<<*k<<'\n';
 157                                 string ext=Path::splitext(*k).ext;
 158                                 if(ext==".cpp" || ext==".c")
 159                                 {
 160                                         SourceFile *src=new SourceFile(*this, &*j, fn.str());
 161                                         add_target(src);
 162
 163                                         ObjectFile *obj=new ObjectFile(*this, *j, *src);
 164                                         add_target(obj);
 165                                         objs.push_back(obj);
 166                                 }
 167                                 else if(ext==".h")
 168                                         add_target(new Header(*this, &*j, fn.str()));
 169                         }
 170
 171                         Executable *exe=new Executable(*this, *j, objs);
 172                         add_target(exe);
 173                         if(i->second==default_pkg)
 174                                 def_tgt->add_depend(exe);
 175                 }
 176         }
 177
 178         while(!new_tgts.empty())
 179         {
 180                 Target *tgt=new_tgts.front();
 181                 new_tgts.erase(new_tgts.begin());
 182                 tgt->find_depends();
 183         }
 184 }
 185
 186 Target *Builder::check_header(const Msp::Path::Path &fn)
 187 {
 188         Target *tgt=get_target(fn.str());
 189         if(tgt) return tgt;
 190
 191         if(Path::exists(fn))
 192         {
 193                 add_target(tgt=new SystemHeader(*this, fn.str()));
 194                 return tgt;
 195         }
 196         return 0;
 197 }
 198
 199 void Builder::add_target(Target *t)
 200 {
 201         targets.insert(TargetMap::value_type(t->get_name(), t));
 202         new_tgts.push_back(t);
 203 }
 204
 205 Application::RegApp<Builder> Builder::reg;
 206
 207 Builder::Loader::Loader(Builder &b, const Path::Path &s):
 208         bld(b),
 209         src(s)
 210 {
 211         add("package", &Loader::package);
 212 }
 213
 214 void Builder::Loader::package(const string &n)
 215 {
 216         Package *pkg=new Package(bld, n, src);
 217         load_sub(*pkg);
 218         bld.packages.insert(PackageMap::value_type(n, pkg));
 219         bld.new_pkgs.push_back(pkg);
 220         //cout<<"loaded "<<pkg->get_name()<<'\n';
 221 }
 222