]> git.tdb.fi Git - builder.git/blobdiff - source/architecture.cpp
Use a separate category for import library filename patterns
[builder.git] / source / architecture.cpp
index c2e91620de962b3246de8cf4f28434fe3fc53f94..75a64607a395f7726357d52887fb06e65953277c 100644 (file)
-/* $Id$
-
-This file is part of builder
-Copyright © 2007-2009  Mikko Rasa, Mikkosoft Productions
-Distributed under the LGPL
-*/
-
+#include <limits>
+#include <msp/strings/format.h>
+#include <msp/strings/utils.h>
 #include "architecture.h"
 #include "builder.h"
+#include "executable.h"
+#include "importlibrary.h"
+#include "objectfile.h"
+#include "sharedlibrary.h"
+#include "staticlibrary.h"
+#include "sysutils.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[] =
+{
+       "x86",
+       "arm",
+       "ppc",
+       0
+};
+
+const char *cpus[] =
+{
+       "i386",       "x86",
+       "i486",       "x86",
+       "pentium",    "x86",
+       "pentiumpro", "x86",
+       "pentium2",   "x86",
+       "pentium3",   "x86",
+       "pentium4",   "x86",
+       "core2",      "x86",
+       "nehalem",    "x86",
+       "k6",         "x86",
+       "athlon",     "x86",
+       "athlonxp",   "x86",
+       "athlon64",   "x86",
+       "armv5",      "arm",
+       "armv6",      "arm",
+       "armv7",      "arm",
+       "armv7a",     "arm",
+       0
+};
 
-void Architecture::set_tool(const string &t, const string &p)
+const char *fpus[] =
 {
-       tools[t]=p;
+       "387",   "x86",
+       "sse",   "x86",
+       "vfpv3", "arm",
+       "neon",  "arm",
+       0
+};
+
+const char *systems[] =
+{
+       "linux",
+       "freebsd",
+       "darwin",
+       "windows",
+       "android",
+       0
+};
+
+const char *toolchains[] =
+{
+       "gnu",
+       "clang",
+       0
+};
+
+const char *aliases[] =
+{
+       "pc",              "x86",
+       "x86_64",          "x86-64",
+       "x64",             "x86-64",
+       "amd64",           "x86-64",
+       "i586",            "pentium",
+       "i686",            "pentiumpro",
+       "corei7",          "nehalem",
+       "win32",           "windows-32",
+       "win64",           "windows-64",
+       "power macintosh", "ppc",
+       "armeabi",         "arm",
+       "v7a",             "armv7a",
+       "gcc",             "gnu",
+       "mingw",           "windows-gnu",
+       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;
+               parse_specification(get_system_type());
+               // We really only want to set type for the default arch
+               cpu.clear();
+               bits = sizeof(void *)*numeric_limits<unsigned char>::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(type!=native_arch.type || system!=native_arch.system)
+                       cross_prefix = format("%s-%s", type, system);
+               else if(bits==native_arch.bits)
+                       native = true;
+       }
+
+       if(toolchain.empty())
+       {
+               if((system=="darwin" || system=="freebsd") && builder.get_vfs().find_binary("clang"))
+                       toolchain = "clang";
                else
-                       return i->second;
+                       toolchain = "gnu";
        }
 
-       if(!native)
+       name = type;
+       if(!cpu.empty())
+               name += format("-%s", cpu);
+       if(!fpu.empty())
+               name += format("-%s", fpu);
+       name += format("-%d-%s-%s", bits, system, toolchain);
+
+       add_pattern<ObjectFile>("%.o");
+       if(system=="windows")
        {
-               const Architecture &native_arch=builder.get_native_arch();
-               return prefix+"-"+native_arch.get_tool(t);
+               add_pattern<SharedLibrary>("%.dll");
+               add_pattern<SharedLibrary>("lib%.dll");
+               add_pattern<ImportLibrary>("lib%.dll.a");
+               add_pattern<StaticLibrary>("lib%.a");
+               add_pattern<StaticLibrary>("%.lib");
+               add_pattern<Executable>("%.exe");
        }
        else
-               throw KeyError("Unknown tool");
+       {
+               if(system=="darwin")
+                       add_pattern<SharedLibrary>("lib%.dylib");
+               else
+                       add_pattern<SharedLibrary>("lib%.so");
+               add_pattern<StaticLibrary>("lib%.a");
+               add_pattern<Executable>("%");
+       }
 }
 
+bool Architecture::match_name(const string &pattern) const
+{
+       bool negate = (pattern[0]=='!');
+       vector<string> parts = split(pattern.substr(negate), "-");
+       resolve_aliases(parts);
+       for(vector<string>::const_iterator i=parts.begin(); i!=parts.end(); ++i)
+       {
+               if((*i=="32" && bits==32) || (*i=="64" && bits==64))
+                       ;
+               else if(*i!=type && *i!=cpu && *i!=fpu && *i!=system && *i!=toolchain)
+                       return negate;
+       }
+       return !negate;
+}
 
-Architecture::Loader::Loader(Architecture &a):
-       arch(a)
+string Architecture::best_match(const vector<string> &names) const
+{
+       string best;
+       unsigned best_size = 0;
+       for(vector<string>::const_iterator i=names.begin(); i!=names.end(); ++i)
+               if(match_name(*i))
+               {
+                       /* TODO Do full parse and alias resolution here?  Otherwise x86 and
+                       x86_64 are treated as equally good, even though the latter is more
+                       specific. */
+                       unsigned size = 1;
+                       for(string::const_iterator j=i->begin(); j!=i->end(); ++j)
+                               size += (*j=='-');
+
+                       if(size>best_size)
+                       {
+                               best = *i;
+                               best_size = size;
+                       }
+               }
+
+       return best;
+}
+
+template<typename T>
+void Architecture::add_pattern(const string &pat)
+{
+       filename_patterns[typeid(T).name()].push_back(Pattern(pat));
+}
+
+void Architecture::resolve_aliases(vector<string> &parts)
+{
+       for(unsigned i=0; i<parts.size(); ++i)
+       {
+               const string &part = parts[i];
+               const char *replace = 0;
+               for(unsigned j=0; (!replace && aliases[j]); j+=2)
+                       if(part==aliases[j])
+                               replace = aliases[j+1];
+
+               if(replace)
+               {
+                       bool has_dash = false;
+                       for(const char *c=replace; (!has_dash && *c); ++c)
+                               has_dash = (*c=='-');
+
+                       if(has_dash)
+                       {
+                               vector<string> rparts = split(replace, "-");
+                               parts[i] = rparts[0];
+                               parts.insert(parts.begin()+i+1, rparts.begin()+1, rparts.end());
+                               i += rparts.size()-1;
+                       }
+                       else
+                               parts[i] = replace;
+               }
+       }
+}
+
+void Architecture::parse_specification(const string &spec)
 {
-       add("prefix", &Architecture::prefix);
-       add("tool",   &Loader::tool);
+       vector<string> parts = split(spec, "-");
+       resolve_aliases(parts);
+       for(vector<string>::const_iterator i=parts.begin(); i!=parts.end(); ++i)
+       {
+               bool ok = false;
+
+               for(unsigned j=0; (!ok && types[j]); ++j)
+                       if(*i==types[j])
+                       {
+                               if(!type.empty() && *i!=type)
+                                       throw invalid_argument("Conflicting type specification");
+                               type = *i;
+                               ok = true;
+                       }
+
+               for(unsigned j=0; (!ok && cpus[j]); j+=2)
+                       if(*i==cpus[j])
+                       {
+                               if(type.empty())
+                                       type = cpus[j+1];
+                               else if(cpus[j+1]!=type)
+                                       throw invalid_argument("Conflicting CPU specification");
+                               cpu = *i;
+                               ok = true;
+                       }
+
+               for(unsigned j=0; (!ok && fpus[j]); j+=2)
+                       if(*i==fpus[j])
+                       {
+                               if(fpus[j+1]!=type)
+                                       throw invalid_argument("Conflicting FPU specification");
+                               fpu = *i;
+                               ok = true;
+                       }
+
+               for(unsigned j=0; (!ok && systems[j]); ++j)
+                       if(*i==systems[j])
+                       {
+                               system = *i;
+                               ok = true;
+                       }
+
+               for(unsigned j=0; (!ok && toolchains[j]); ++j)
+                       if(*i==toolchains[j])
+                       {
+                               toolchain = *i;
+                               ok = true;
+                       }
+
+               if(!ok && (*i=="32" || *i=="64"))
+               {
+                       bits = lexical_cast<unsigned>(*i);
+                       ok = true;
+               }
+
+               if(!ok)
+                       throw invalid_argument("Unrecognized part in arch specification: "+*i);
+       }
 }
 
-void Architecture::Loader::tool(const string &t, const string &p)
+
+Architecture::Loader::Loader(Architecture &a):
+       DataFile::ObjectLoader<Architecture>(a)
 {
-       arch.tools[t]=p;
+       add("prefix", &Architecture::cross_prefix);
 }