source/architecture.cpp

   1 #include <limits>
   2 #ifndef WIN32
   3 #include <sys/utsname.h>
   4 #endif
   5 #include <msp/strings/format.h>
   6 #include <msp/strings/utils.h>
   7 #include "architecture.h"
   8 #include "builder.h"
   9
  10 using namespace std;
  11 using namespace Msp;
  12
  13 namespace {
  14
  15 const char *types[] =
  16 {
  17         "pc",
  18         "arm",
  19         0
  20 };
  21
  22 const char *cpus[] =
  23 {
  24         "i386",       "pc",
  25         "i486",       "pc",
  26         "pentium",    "pc",
  27         "pentiumpro", "pc",
  28         "pentium2",   "pc",
  29         "pentium3",   "pc",
  30         "pentium4",   "pc",
  31         "core2",      "pc",
  32         "k6",         "pc",
  33         "athlon",     "pc",
  34         "athlonxp",   "pc",
  35         "athlon64",   "pc",
  36         "armv5",      "arm",
  37         0
  38 };
  39
  40 const char *systems[] =
  41 {
  42         "linux",
  43         "freebsd",
  44         "windows",
  45         0
  46 };
  47
  48 const char *aliases[] =
  49 {
  50         "i586",  "pentium",
  51         "i686",  "pentiumpro",
  52         "x86_64", "athlon64",
  53         "win32", "windows",
  54         0
  55 };
  56
  57 }
  58
  59 Architecture::Architecture(Builder &b, const string &spec):
  60         builder(b),
  61         bits(0),
  62         native(false)
  63 {
  64         if(spec.empty())
  65         {
  66 #ifdef WIN32
  67                 system = "windows";
  68 #else
  69                 utsname un;
  70                 if(uname(&un)==0)
  71                 {
  72                         system = tolower(un.sysname);
  73                         parse_specification(tolower(un.machine));
  74                         // We really only want to set type for the default arch
  75                         cpu.clear();
  76                 }
  77 #endif
  78                 bits = sizeof(void *)*numeric_limits<unsigned char>::digits;
  79                 native = true;
  80         }
  81         else
  82         {
  83                 parse_specification(spec);
  84                 const Architecture &native_arch = builder.get_native_arch();
  85                 if(type.empty())
  86                         type = native_arch.type;
  87                 if(cpu.empty())
  88                         cpu = native_arch.cpu;
  89                 if(system.empty())
  90                         system = native_arch.system;
  91                 if(!bits)
  92                 {
  93                         if(type==native_arch.type)
  94                                 bits = native_arch.bits;
  95                         else
  96                                 bits = 32;
  97                 }
  98
  99                 if(type!=native_arch.type || system!=native_arch.system)
 100                         cross_prefix = format("%s-%s", type, system);
 101                 else if(bits==native_arch.bits)
 102                         native = true;
 103         }
 104         name = type;
 105         if(!cpu.empty())
 106                 name += format("-%s", cpu);
 107         name += format("-%d-%s", bits, system);
 108
 109         if(system=="windows")
 110         {
 111                 sharedlib_patterns.push_back(Pattern("%.dll"));
 112                 sharedlib_patterns.push_back(Pattern("lib%.dll"));
 113                 staticlib_patterns.push_back(Pattern("lib%.a"));
 114                 staticlib_patterns.push_back(Pattern("lib%.dll.a"));
 115                 executable_patterns.push_back(Pattern("%.exe"));
 116         }
 117         else
 118         {
 119                 sharedlib_patterns.push_back(Pattern("lib%.so"));
 120                 staticlib_patterns.push_back(Pattern("lib%.a"));
 121                 executable_patterns.push_back(Pattern("%"));
 122         }
 123 }
 124
 125 void Architecture::set_tool(const string &t, const string &p)
 126 {
 127         tools[t] = p;
 128 }
 129
 130 void Architecture::set_cross_prefix(const string &p)
 131 {
 132         cross_prefix = p;
 133 }
 134
 135 std::string Architecture::get_tool(const string &t) const
 136 {
 137         StringMap::const_iterator i = tools.find(t);
 138         if(i!=tools.end())
 139         {
 140                 if(i->second[0]=='-')
 141                         return cross_prefix+i->second;
 142                 else
 143                         return i->second;
 144         }
 145
 146         const Architecture &native_arch = builder.get_native_arch();
 147         if(this!=&native_arch)
 148         {
 149                 if(!cross_prefix.empty())
 150                         return cross_prefix+"-"+native_arch.get_tool(t);
 151                 else
 152                         return native_arch.get_tool(t);
 153         }
 154         else
 155                 throw invalid_argument("Unknown tool");
 156 }
 157
 158 bool Architecture::match_name(const string &pattern) const
 159 {
 160         vector<string> parts = split(pattern, "-");
 161         for(vector<string>::const_iterator i=parts.begin(); i!=parts.end(); ++i)
 162         {
 163                 string part = resolve_alias(*i);
 164                 if((part=="32" && bits==32) || (part=="64" && bits==64))
 165                         ;
 166                 else if(part!=type && part!=cpu && part!=system)
 167                         return false;
 168         }
 169         return true;
 170 }
 171
 172 string Architecture::resolve_alias(const string &part) const
 173 {
 174         for(unsigned j=0; aliases[j]; j+=2)
 175                 if(part==aliases[j])
 176                         return aliases[j+1];
 177
 178         return part;
 179 }
 180
 181 void Architecture::parse_specification(const string &spec)
 182 {
 183         vector<string> parts = split(spec, "-");
 184         for(vector<string>::const_iterator i=parts.begin(); i!=parts.end(); ++i)
 185         {
 186                 string part = resolve_alias(*i);
 187
 188                 bool ok = false;
 189
 190                 for(unsigned j=0; (!ok && types[j]); ++j)
 191                         if(part==types[j])
 192                         {
 193                                 if(!type.empty() && part!=type)
 194                                         throw invalid_argument("Conflicting type specification");
 195                                 type = part;
 196                                 ok = true;
 197                         }
 198
 199                 for(unsigned j=0; (!ok && cpus[j]); j+=2)
 200                         if(part==cpus[j])
 201                         {
 202                                 if(type.empty())
 203                                         type = cpus[j+1];
 204                                 else if(cpus[j+1]!=type)
 205                                         throw invalid_argument("Conflicting CPU specification");
 206                                 cpu = part;
 207                                 ok = true;
 208                         }
 209
 210                 for(unsigned j=0; (!ok && systems[j]); ++j)
 211                         if(part==systems[j])
 212                         {
 213                                 system = part;
 214                                 ok = true;
 215                         }
 216
 217                 if(!ok && (part=="32" || part=="64"))
 218                 {
 219                         bits = lexical_cast<unsigned>(part);
 220                         ok = true;
 221                 }
 222
 223                 if(!ok)
 224                         throw invalid_argument("Unrecognized part in arch specification: "+*i);
 225         }
 226 }
 227
 228
 229 Architecture::Loader::Loader(Architecture &a):
 230         arch(a)
 231 {
 232         add("prefix", &Architecture::cross_prefix);
 233         add("tool",   &Loader::tool);
 234 }
 235
 236 void Architecture::Loader::tool(const string &t, const string &p)
 237 {
 238         arch.tools[t] = p;
 239 }