X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Farchitecture.cpp;h=9662bbaa6f08e2dbcaeef2f9a75c9df77818b99d;hb=d1f9551e05c9d341149eb490e05b1465d3d6b711;hp=212f148027d00c5ab4f1465af16dc1bf226d87f5;hpb=e87f8e48e17754a8413bda66e6da67daf933cee2;p=builder.git

diff --git a/source/architecture.cpp b/source/architecture.cpp
index 212f148..9662bba 100644
--- a/source/architecture.cpp
+++ b/source/architecture.cpp
@@ -96,9 +96,7 @@ const char *aliases[] =
 }
 
 Architecture::Architecture(Builder &b, const string &spec):
-	builder(b),
-	bits(0),
-	native(false)
+	builder(b)
 {
 	if(spec.empty())
 	{
@@ -177,41 +175,42 @@ Architecture::Architecture(Builder &b, const string &spec):
 	}
 }
 
-bool Architecture::match_name(const string &pattern) const
+bool Architecture::match_name(const string &pattern, unsigned *quality) 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)
+	for(const string &p: parts)
 	{
-		if((*i=="32" && bits==32) || (*i=="64" && bits==64))
+		if((p=="32" && bits==32) || (p=="64" && bits==64))
 			;
-		else if(*i!=type && *i!=cpu && *i!=fpu && *i!=system && *i!=toolchain)
+		else if(p!=type && p!=cpu && p!=fpu && p!=system && p!=toolchain)
+		{
+			if(quality)
+				*quality = 0;
 			return negate;
+		}
 	}
+
+	if(quality)
+		*quality = parts.size();
 	return !negate;
 }
 
 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)
+	unsigned best_quality = 0;
+	for(const string &n: names)
+	{
+		unsigned quality;
+		if(match_name(n, &quality))
+			if(quality>best_quality)
 			{
-				best = *i;
-				best_size = size;
+				best = n;
+				best_quality = quality;
 			}
-		}
+	}
 
 	return best;
 }
@@ -255,61 +254,61 @@ 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)
+	for(const string &p: parts)
 	{
 		bool ok = false;
 
 		for(unsigned j=0; (!ok && types[j]); ++j)
-			if(*i==types[j])
+			if(p==types[j])
 			{
-				if(!type.empty() && *i!=type)
+				if(!type.empty() && p!=type)
 					throw invalid_argument("Conflicting type specification");
-				type = *i;
+				type = p;
 				ok = true;
 			}
 
 		for(unsigned j=0; (!ok && cpus[j]); j+=2)
-			if(*i==cpus[j])
+			if(p==cpus[j])
 			{
 				if(type.empty())
 					type = cpus[j+1];
 				else if(cpus[j+1]!=type)
 					throw invalid_argument("Conflicting CPU specification");
-				cpu = *i;
+				cpu = p;
 				ok = true;
 			}
 
 		for(unsigned j=0; (!ok && fpus[j]); j+=2)
-			if(*i==fpus[j])
+			if(p==fpus[j])
 			{
 				if(fpus[j+1]!=type)
 					throw invalid_argument("Conflicting FPU specification");
-				fpu = *i;
+				fpu = p;
 				ok = true;
 			}
 
 		for(unsigned j=0; (!ok && systems[j]); ++j)
-			if(*i==systems[j])
+			if(p==systems[j])
 			{
-				system = *i;
+				system = p;
 				ok = true;
 			}
 
 		for(unsigned j=0; (!ok && toolchains[j]); ++j)
-			if(*i==toolchains[j])
+			if(p==toolchains[j])
 			{
-				toolchain = *i;
+				toolchain = p;
 				ok = true;
 			}
 
-		if(!ok && (*i=="32" || *i=="64"))
+		if(!ok && (p=="32" || p=="64"))
 		{
-			bits = lexical_cast<unsigned>(*i);
+			bits = lexical_cast<unsigned>(p);
 			ok = true;
 		}
 
 		if(!ok)
-			throw invalid_argument("Unrecognized part in arch specification: "+*i);
+			throw invalid_argument("Unrecognized part in arch specification: "+p);
 	}
 }