X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Farchitecture.cpp;h=627ba66ccf6ab6defbcaa960c09fbca775845b14;hb=921e8234ff65bd23c0b94ed568ec1fb68e47655b;hp=07f5dbfb0c09159e7fa4fcbb14e7d9e3e6ff03af;hpb=cee450d7cc932811b0d119a132bc9981eb480584;p=builder.git

diff --git a/source/architecture.cpp b/source/architecture.cpp
index 07f5dbf..627ba66 100644
--- a/source/architecture.cpp
+++ b/source/architecture.cpp
@@ -14,26 +14,40 @@ namespace {
 
 const char *types[] =
 {
-	"pc",
+	"x86",
 	"arm",
+	"ppc",
 	0
 };
 
 const char *cpus[] =
 {
-	"i386",       "pc",
-	"i486",       "pc",
-	"pentium",    "pc",
-	"pentiumpro", "pc",
-	"pentium2",   "pc",
-	"pentium3",   "pc",
-	"pentium4",   "pc",
-	"core2",      "pc",
-	"k6",         "pc",
-	"athlon",     "pc",
-	"athlonxp",   "pc",
-	"athlon64",   "pc",
+	"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
+};
+
+const char *fpus[] =
+{
+	"387",   "x86",
+	"sse",   "x86",
+	"vfpv3", "arm",
+	"neon",  "arm",
 	0
 };
 
@@ -49,11 +63,17 @@ const char *systems[] =
 
 const char *aliases[] =
 {
-	"x86",   "pc",
-	"i586",  "pentium",
-	"i686",  "pentiumpro",
-	"x86_64", "athlon64",
-	"win32", "windows",
+	"pc",              "x86",
+	"x86_64",          "x86-64",
+	"amd64",           "x86-64",
+	"i586",            "pentium",
+	"i686",            "pentiumpro",
+	"corei7",          "nehalem",
+	"win32",           "windows-32",
+	"win64",           "windows-64",
+	"power macintosh", "ppc",
+	"armeabi",         "arm",
+	"v7a",             "armv7a",
 	0
 };
 
@@ -105,6 +125,8 @@ Architecture::Architecture(Builder &b, const string &spec):
 	name = type;
 	if(!cpu.empty())
 		name += format("-%s", cpu);
+	if(!fpu.empty())
+		name += format("-%s", fpu);
 	name += format("-%d-%s", bits, system);
 
 	if(system=="windows")
@@ -115,6 +137,7 @@ Architecture::Architecture(Builder &b, const string &spec):
 		even though technically they are linked statically. */
 		sharedlib_patterns.push_back(Pattern("lib%.dll.a"));
 		staticlib_patterns.push_back(Pattern("lib%.a"));
+		staticlib_patterns.push_back(Pattern("%.lib"));
 		executable_patterns.push_back(Pattern("%.exe"));
 	}
 	else
@@ -132,65 +155,117 @@ 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)
 	{
-		string part = resolve_alias(*i);
-		if((part=="32" && bits==32) || (part=="64" && bits==64))
+		if((*i=="32" && bits==32) || (*i=="64" && bits==64))
 			;
-		else if(part!=type && part!=cpu && part!=system)
+		else if(*i!=type && *i!=cpu && *i!=fpu && *i!=system)
 			return negate;
 	}
 	return !negate;
 }
 
-string Architecture::resolve_alias(const string &part) const
+string Architecture::best_match(const list<string> &names) const
+{
+	string best;
+	unsigned best_size = 0;
+	for(list<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;
+}
+
+void Architecture::resolve_aliases(vector<string> &parts)
 {
-	for(unsigned j=0; aliases[j]; j+=2)
-		if(part==aliases[j])
-			return aliases[j+1];
+	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=='-');
 
-	return part;
+			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)
 {
 	vector<string> parts = split(spec, "-");
+	resolve_aliases(parts);
 	for(vector<string>::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(*i==types[j])
 			{
-				if(!type.empty() && part!=type)
+				if(!type.empty() && *i!=type)
 					throw invalid_argument("Conflicting type specification");
-				type = part;
+				type = *i;
 				ok = true;
 			}
 
 		for(unsigned j=0; (!ok && cpus[j]); j+=2)
-			if(part==cpus[j])
+			if(*i==cpus[j])
 			{
 				if(type.empty())
 					type = cpus[j+1];
 				else if(cpus[j+1]!=type)
 					throw invalid_argument("Conflicting CPU specification");
-				cpu = part;
+				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(part==systems[j])
+			if(*i==systems[j])
 			{
-				system = part;
+				system = *i;
 				ok = true;
 			}
 
-		if(!ok && (part=="32" || part=="64"))
+		if(!ok && (*i=="32" || *i=="64"))
 		{
-			bits = lexical_cast<unsigned>(part);
+			bits = lexical_cast<unsigned>(*i);
 			ok = true;
 		}