X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Farchitecture.cpp;h=847711e351c3c7fc47ff93b60494e539f8c4c4b3;hb=8ee4fd693c8d15265f0c145221737a322f89618b;hp=1f578af409f72ce367f5fb09ee0fa968e5020976;hpb=3585dea6eabf5f1565886bf09c2bdb2eee978912;p=builder.git diff --git a/source/architecture.cpp b/source/architecture.cpp index 1f578af..847711e 100644 --- a/source/architecture.cpp +++ b/source/architecture.cpp @@ -1,56 +1,209 @@ -/* $Id$ - -This file is part of builder -Copyright © 2006-2007 Mikko Rasa, Mikkosoft Productions -Distributed under the LGPL -*/ - +#include +#ifndef WIN32 +#include +#endif +#include +#include #include "architecture.h" #include "builder.h" using namespace std; using namespace Msp; -Architecture::Architecture(Builder &b, const string &n, bool a): - builder(b), - name(n), - native(a) -{ } +namespace { + +const char *types[] = +{ + "pc", + "arm", + "ppc", + 0 +}; -void Architecture::set_tool(const string &t, const string &p) +const char *cpus[] = { - tools[t]=p; + "i386", "pc", + "i486", "pc", + "pentium", "pc", + "pentiumpro", "pc", + "pentium2", "pc", + "pentium3", "pc", + "pentium4", "pc", + "core2", "pc", + "k6", "pc", + "athlon", "pc", + "athlonxp", "pc", + "athlon64", "pc", + "armv5", "arm", + 0 +}; + +const char *systems[] = +{ + "linux", + "freebsd", + "darwin", + "windows", + "android", + 0 +}; + +const char *aliases[] = +{ + "x86", "pc", + "i586", "pentium", + "i686", "pentiumpro", + "x86_64", "athlon64", + "win32", "windows", + "power macintosh", "ppc", + 0 +}; + } -std::string Architecture::get_tool(const string &t) const +Architecture::Architecture(Builder &b, const string &spec): + builder(b), + bits(0), + native(false) { - StringMap::const_iterator i=tools.find(t); - if(i!=tools.end()) + if(spec.empty()) { - if(i->second[0]=='-') - return prefix+i->second; - else - return i->second; +#ifdef WIN32 + system = "windows"; +#else + utsname un; + if(uname(&un)==0) + { + system = tolower(un.sysname); + parse_specification(tolower(un.machine)); + // We really only want to set type for the default arch + cpu.clear(); + } +#endif + bits = sizeof(void *)*numeric_limits::digits; + native = true; } + else + { + parse_specification(spec); + const Architecture &native_arch = builder.get_native_arch(); + if(type.empty()) + type = native_arch.type; + if(system.empty()) + system = native_arch.system; + if(!bits) + { + if(type==native_arch.type) + bits = native_arch.bits; + else + bits = 32; + } - if(!native) + if(type!=native_arch.type || system!=native_arch.system) + cross_prefix = format("%s-%s", type, system); + else if(bits==native_arch.bits) + native = true; + } + name = type; + if(!cpu.empty()) + name += format("-%s", cpu); + name += format("-%d-%s", bits, system); + + if(system=="windows") { - const Architecture &native_arch=builder.get_native_arch(); - return prefix+"-"+native_arch.get_tool(t); + sharedlib_patterns.push_back(Pattern("%.dll")); + sharedlib_patterns.push_back(Pattern("lib%.dll")); + /* XXX Hack: Consider import libraries (*.dll.a) as dynamic libraries, + even though technically they are linked statically. */ + sharedlib_patterns.push_back(Pattern("lib%.dll.a")); + staticlib_patterns.push_back(Pattern("lib%.a")); + executable_patterns.push_back(Pattern("%.exe")); } else - throw KeyError("Unknown tool"); + { + if(system=="darwin") + sharedlib_patterns.push_back(Pattern("lib%.dylib")); + else + sharedlib_patterns.push_back(Pattern("lib%.so")); + staticlib_patterns.push_back(Pattern("lib%.a")); + executable_patterns.push_back(Pattern("%")); + } } +bool Architecture::match_name(const string &pattern) const +{ + bool negate = (pattern[0]=='!'); + vector parts = split(pattern.substr(negate), "-"); + for(vector::const_iterator i=parts.begin(); i!=parts.end(); ++i) + { + string part = resolve_alias(*i); + if((part=="32" && bits==32) || (part=="64" && bits==64)) + ; + else if(part!=type && part!=cpu && part!=system) + return negate; + } + return !negate; +} -Architecture::Loader::Loader(Architecture &a): - arch(a) +string Architecture::resolve_alias(const string &part) const { - add("prefix", &Architecture::prefix); - add("tool", &Loader::tool); + for(unsigned j=0; aliases[j]; j+=2) + if(part==aliases[j]) + return aliases[j+1]; + + return part; } -void Architecture::Loader::tool(const string &t, const string &p) +void Architecture::parse_specification(const string &spec) +{ + vector parts = split(spec, "-"); + for(vector::const_iterator i=parts.begin(); i!=parts.end(); ++i) + { + string part = resolve_alias(*i); + + bool ok = false; + + for(unsigned j=0; (!ok && types[j]); ++j) + if(part==types[j]) + { + if(!type.empty() && part!=type) + throw invalid_argument("Conflicting type specification"); + type = part; + ok = true; + } + + for(unsigned j=0; (!ok && cpus[j]); j+=2) + if(part==cpus[j]) + { + if(type.empty()) + type = cpus[j+1]; + else if(cpus[j+1]!=type) + throw invalid_argument("Conflicting CPU specification"); + cpu = part; + ok = true; + } + + for(unsigned j=0; (!ok && systems[j]); ++j) + if(part==systems[j]) + { + system = part; + ok = true; + } + + if(!ok && (part=="32" || part=="64")) + { + bits = lexical_cast(part); + ok = true; + } + + if(!ok) + throw invalid_argument("Unrecognized part in arch specification: "+*i); + } +} + + +Architecture::Loader::Loader(Architecture &a): + DataFile::ObjectLoader(a) { - arch.tools[t]=p; + add("prefix", &Architecture::cross_prefix); }