+void Component::configure(const StringMap &opts, unsigned flag)
+{
+ for(StringList::iterator i=sources.begin(); i!=sources.end(); ++i)
+ *i = (pkg.get_source()/pkg.expand_string(*i)).str();
+
+ for(PackageList::const_iterator i=requires.begin(); i!=requires.end(); ++i)
+ (*i)->configure(opts, flag&2);
+}
+
+void Component::create_build_info()
+{
+ const PackageList &pkg_reqs = pkg.get_requires();
+ PackageList direct_reqs = requires;
+ direct_reqs.insert(direct_reqs.end(), pkg_reqs.begin(), pkg_reqs.end());
+
+ PackageList all_reqs = direct_reqs;
+ for(PackageList::iterator i=all_reqs.begin(); i!=all_reqs.end(); ++i)
+ {
+ if(find(direct_reqs.begin(), direct_reqs.end(), *i)!=direct_reqs.end())
+ build_info.add((*i)->get_exported_binfo());
+ else
+ {
+ const BuildInfo &ebi = (*i)->get_exported_binfo();
+ build_info.cflags.insert(build_info.cflags.end(), ebi.cflags.begin(), ebi.cflags.end());
+ build_info.incpath.insert(build_info.incpath.end(), ebi.incpath.begin(), ebi.incpath.end());
+ build_info.defines.insert(build_info.defines.end(), ebi.defines.begin(), ebi.defines.end());
+ }
+
+ const PackageList &reqs = (*i)->get_requires();
+ for(PackageList::const_iterator j=reqs.begin(); j!=reqs.end(); ++j)
+ if(find(all_reqs.begin(), all_reqs.end(), *j)==all_reqs.end())
+ all_reqs.push_back(*j);
+ }
+
+ build_info.add(pkg.get_build_info());
+
+ for(StringList::iterator i=build_info.incpath.begin(); i!=build_info.incpath.end(); ++i)
+ *i = (pkg.get_source() / *i).str();
+ for(StringList::iterator i=build_info.libpath.begin(); i!=build_info.libpath.end(); ++i)
+ *i = (pkg.get_source() / *i).str();
+
+ if(pkg.get_library_mode()!=DYNAMIC)
+ {
+ for(PackageList::iterator i=all_reqs.begin(); i!=all_reqs.end(); ++i)
+ {
+ const BuildInfo &ebi = (*i)->get_exported_binfo();
+ build_info.libpath.insert(build_info.libpath.end(), ebi.libpath.begin(), ebi.libpath.end());
+ }
+ }
+
+ if(type==PROGRAM)
+ {
+ string strip = pkg.get_config().get_option("strip").value;
+ if(lexical_cast<bool>(strip))
+ build_info.ldflags.push_back("-s");
+ }
+ else if(type==LIBRARY)
+ {
+ build_info.cflags.push_back("-fPIC");
+ }
+
+ build_info.unique();
+}
+
+void Component::create_targets() const
+{
+ Builder &builder = pkg.get_builder();
+ Target *world = builder.get_target("world");
+ Target *def_tgt = builder.get_target("default");
+
+ PathList files = collect_source_files();
+ list<FileTarget *> inst_list;
+
+ string inst_loc;
+ if(type==TARBALL)
+ {
+ string tarname = name;
+ if(name=="@src")
+ tarname = pkg.get_name()+"-"+pkg.get_version();
+ TarBall *result = new TarBall(builder, pkg, tarname);
+
+ if(name=="@src")
+ {
+ const Builder::TargetMap &targets = builder.get_targets();
+ for(Builder::TargetMap::const_iterator i=targets.begin(); i!=targets.end(); ++i)
+ if(i->second->get_package()==&pkg && !i->second->is_buildable())
+ result->add_depend(i->second);
+ files.push_back(pkg.get_source()/"Build");
+ }
+
+ for(PathList::const_iterator i=files.begin(); i!=files.end(); ++i)
+ {
+ FileTarget *ft;
+ if(Target *tgt = builder.get_target_by_path(*i))
+ ft = dynamic_cast<FileTarget *>(tgt);
+ else
+ ft = new File(builder, *i);
+ result->add_depend(ft);
+ }
+
+ Target *tarbls_tgt = builder.get_target("tarballs");
+ tarbls_tgt->add_depend(result);
+
+ return;
+ }
+ else if(type==INSTALL)
+ {
+ inst_loc = name;
+ for(PathList::const_iterator i=files.begin(); i!=files.end(); ++i)
+ {
+ FileTarget *ft;
+ if(Target *tgt = builder.get_target_by_path(*i))
+ ft = dynamic_cast<FileTarget *>(tgt);
+ else
+ ft = new File(builder, pkg, *i);
+ inst_list.push_back(ft);
+ }
+ }
+ else if(type==DATAFILE)
+ {
+ File *source;
+ if(Target *tgt = builder.get_target_by_path(files.front()))
+ source = dynamic_cast<File *>(tgt);
+ else
+ source = new File(builder, pkg, files.front());
+ ::DataFile *result = new ::DataFile(builder, *this, *source);
+
+ if(&pkg==builder.get_main_package() && deflt)
+ def_tgt->add_depend(result);
+ else
+ world->add_depend(result);
+ if(install)
+ inst_list.push_back(result);
+ }
+ else
+ {
+ for(PathList::const_iterator i=files.begin(); i!=files.end(); ++i)
+ {
+ string ext = FS::extpart(FS::basename(*i));
+ if(ext==".h")
+ {
+ FileTarget *hdr = builder.get_target_by_path(*i);
+ if(!hdr)
+ hdr = new Header(builder, *this, i->str());
+
+ // Install headers if requested
+ if(type==HEADERS && install)
+ inst_list.push_back(hdr);
+ }
+ }
+ }
+
+ if(type==PROGRAM || type==LIBRARY || type==MODULE)
+ {
+ list<ObjectFile *> objs;
+ for(PathList::const_iterator i=files.begin(); i!=files.end(); ++i)
+ {
+ string ext = FS::extpart(FS::basename(*i));
+ if((ext==".cpp" || ext==".cc" || ext==".c"))
+ {
+ SourceFile *src = new SourceFile(builder, *this, i->str());
+ ObjectFile *obj = new ObjectFile(builder, *this, *src);
+ objs.push_back(obj);
+ }
+ }
+
+ list<FileTarget *> results;
+ if(type==LIBRARY)
+ {
+ results.push_back(new SharedLibrary(builder, *this, objs));
+ results.push_back(new StaticLibrary(builder, *this, objs));
+ }
+ else
+ results.push_back(new Executable(builder, *this, objs));
+
+ for(list<FileTarget *>::const_iterator i=results.begin(); i!=results.end(); ++i)
+ {
+ if(&pkg==builder.get_main_package() && deflt)
+ def_tgt->add_depend(*i);
+ else
+ world->add_depend(*i);
+ if(install)
+ inst_list.push_back(*i);
+ }
+ }
+
+ Target *inst_tgt = builder.get_target("install");
+ for(list<FileTarget *>::const_iterator i=inst_list.begin(); i!=inst_list.end(); ++i)
+ {
+ Install *inst = new Install(builder, pkg, **i, inst_loc);
+ inst_tgt->add_depend(inst);
+
+ if(type==LIBRARY)
+ if(SharedLibrary *shlib = dynamic_cast<SharedLibrary *>(*i))
+ if(!shlib->get_soname().empty())
+ inst_tgt->add_depend(new Symlink(builder, pkg, *inst, shlib->get_name()));
+ }
+}
+
+PathList Component::collect_source_files() const
+{
+ PathList files;
+ for(StringList::const_iterator i=sources.begin(); i!=sources.end(); ++i)
+ {
+ FS::Path path(*i);
+ if(FS::is_dir(path))
+ {
+ list<string> sfiles = list_files(path);
+ for(list<string>::iterator j=sfiles.begin(); j!=sfiles.end(); ++j)
+ files.push_back(path / *j);
+ }
+ else
+ files.push_back(path);
+ }
+
+ return files;
+}
+
+