Move version discovery back to GnuCompiler

It's needed to determine whether some options are supported

diff --git a/source/androidcompiler.cpp b/source/androidcompiler.cpp
index cdd98af34f5095dd853521535091e5b37e0fc4e8..68c4e56d2ad675a4ac64f72a492f4ff38305e78c 100644 (file)
--- a/source/androidcompiler.cpp
+++ b/source/androidcompiler.cpp
@@ -42,38 +42,25 @@ AndroidCompiler::AndroidCompiler(Builder &b, const Architecture &a, const string
 void AndroidCompiler::do_prepare()
 {
        GnuCompiler::do_prepare();
-       if(executable && tag=="CXX")
+       if(tag=="CXX")
        {
-               ExternalTask::Arguments argv;
-               argv.push_back(executable->get_path().str());
-               argv.push_back("-dumpversion");
-
-               builder.get_logger().log("auxcommands", format("Running %s", join(argv.begin(), argv.end())));
-               string version;
-               try
-               {
-                       version = strip(ExternalTask::run_and_capture_output(argv));
-                       builder.get_logger().log("tools", format("%s version is %s", FS::basename(executable->get_path()), version));
-               }
-               catch(const runtime_error &)
-               { }
-
+               string version_str = format("%d.%d.%d", version>>16, (version>>8)&0xFF, version&0xFF);
                FS::Path libstdcxx_dir = ndk.get_root_dir()/"sources"/"cxx-stl"/"gnu-libstdc++";
                FS::Path libstdcxx_path;
                while(1)
                {
-                       libstdcxx_path = libstdcxx_dir/version;
+                       libstdcxx_path = libstdcxx_dir/version_str;
                        if(FS::exists(libstdcxx_path))
                                break;
 
-                       string::size_type dot = version.rfind('.');
+                       string::size_type dot = version_str.rfind('.');
                        if(dot==string::npos)
                        {
                                problems.push_back("C++ standard library not found");
                                return;
                        }
 
-                       version = version.substr(0, dot);
+                       version_str = version_str.substr(0, dot);
                }
 
                FS::Path public_dir = libstdcxx_path/"include";

diff --git a/source/gnucompiler.cpp b/source/gnucompiler.cpp
index 470934e0fe7e32432f7d9b344690e9bcbd5be047..b186bb367cdb84350988f143142085c4b690a3ca 100644 (file)
--- a/source/gnucompiler.cpp
+++ b/source/gnucompiler.cpp
@@ -28,7 +28,8 @@ const char *cpus[] =
 }
 
 GnuCompiler::GnuCompiler(Builder &b, const Architecture &a, const string &t):
-       Tool(b, a, t)
+       Tool(b, a, t),
+       version(0)
 {
        if(tag=="CC")
        {
@@ -101,11 +102,17 @@ string GnuCompiler::create_build_signature(const BuildInfo &binfo) const
 }
 
 void GnuCompiler::do_prepare()
+{
+       executable = builder.get_vfs().find_binary(command);
+       prepare_syspath();
+       prepare_version();
+}
+
+void GnuCompiler::prepare_syspath()
 {
        bool path_found = false;
        const FS::Path &sysroot = build_info.sysroot;
 
-       executable = builder.get_vfs().find_binary(command);
        if(executable)
        {
                ExternalTask::Arguments argv;
@@ -159,6 +166,37 @@ void GnuCompiler::do_prepare()
        }
 }
 
+void GnuCompiler::prepare_version()
+{
+       if(!executable)
+               return;
+
+       prepare_version("-dumpversion");
+       if(version>=0x70000)
+               prepare_version("-dumpfullversion");
+       builder.get_logger().log("tools", format("%s version is %d.%d.%d", FS::basename(executable->get_path()), version>>16, (version>>8)&0xFF, version&0xFF));
+}
+
+void GnuCompiler::prepare_version(const string &arg)
+{
+       ExternalTask::Arguments argv;
+       argv.push_back(executable->get_path().str());
+       argv.push_back(arg);
+
+       builder.get_logger().log("auxcommands", format("Running %s", join(argv.begin(), argv.end())));
+       try
+       {
+               string version_str = strip(ExternalTask::run_and_capture_output(argv));
+
+               vector<string> version_parts = split(version_str, '.');
+               version = 0;
+               for(unsigned i=0; (i<3 && i<version_parts.size()); ++i)
+                       version |= lexical_cast<unsigned>(version_parts[i])<<(16-8*i);
+       }
+       catch(const runtime_error &)
+       { }
+}
+
 Task *GnuCompiler::run(const Target &target) const
 {
        const ObjectFile &object = dynamic_cast<const ObjectFile &>(target);

diff --git a/source/gnucompiler.h b/source/gnucompiler.h
index 307aa5ee4115921357ba033b4ceb6437f3c0202a..9f5386d13a856df90a0a777f0a9cb94a802f3e4c 100644 (file)
--- a/source/gnucompiler.h
+++ b/source/gnucompiler.h
@@ -12,6 +12,9 @@ appropriate type.
 */
 class GnuCompiler: public Tool
 {
+protected:
+       unsigned version;
+
 public:
        GnuCompiler(Builder &, const Architecture &, const std::string &);
 
@@ -21,6 +24,9 @@ public:
        virtual std::string create_build_signature(const BuildInfo &) const;
 protected:
        virtual void do_prepare();
+       void prepare_syspath();
+       void prepare_version();
+       void prepare_version(const std::string &);
 public:
        virtual Task *run(const Target &) const;
 };