BUG: Implement installing of shared library versioning and add test for the whole thing

3 files changed, 108 insertions, 9 deletions

diff --git a/Source/cmFileCommand.cxx b/Source/cmFileCommand.cxx
index 4f578c2..1b49ff7 100644
--- a/Source/cmFileCommand.cxx
+++ b/Source/cmFileCommand.cxx
@@ -249,8 +249,6 @@ bool cmFileCommand::HandleInstallCommand(
   std::string destination = "";
   std::string stype = "FILES";
   const char* build_type = m_Makefile->GetDefinition("BUILD_TYPE");
-  const char* debug_postfix 
-    = m_Makefile->GetDefinition("CMAKE_DEBUG_POSTFIX");
   const char* destdir = cmSystemTools::GetEnv("DESTDIR");
 
   std::string extra_dir = "";
@@ -271,7 +269,10 @@ bool cmFileCommand::HandleInstallCommand(
   std::vector<std::string>::size_type i = 0;
   i++; // Get rid of subcommand
 
+  std::map<cmStdString, const char*> properties;
+
   bool in_files = false;
+  bool in_properties = false;
   bool optional = false;
   for ( ; i != args.size(); ++i )
     {
@@ -281,6 +282,7 @@ bool cmFileCommand::HandleInstallCommand(
       i++;
       destination = args[i];
       in_files = false;
+      in_properties = false;
       }
     else if ( *cstr == "TYPE" && i < args.size()-1 )
       {
@@ -291,11 +293,23 @@ bool cmFileCommand::HandleInstallCommand(
         i++;
         optional = true;
         }
+      in_properties = false;
+      in_files = false;
+      }
+    else if ( *cstr == "PROPERTIES"  )
+      {
+      in_properties = true;
       in_files = false;
       }
     else if ( *cstr == "FILES" && !in_files)
       {
       in_files = true;
+      in_properties = false;
+      }
+    else if ( in_properties && i < args.size()-1 )
+      {
+      properties[args[i]] = args[i+1].c_str();
+      i++;
       }
     else if ( in_files )
       {
@@ -437,9 +451,65 @@ bool cmFileCommand::HandleInstallCommand(
     case cmTarget::MODULE_LIBRARY:
     case cmTarget::STATIC_LIBRARY:
     case cmTarget::SHARED_LIBRARY:
-      if ( debug )
         {
-        fname = fnamewe + debug_postfix + ext;
+        // Handle shared library versioning
+        const char* lib_version = 0;
+        const char* lib_soversion = 0;
+        if ( properties.find("VERSION") != properties.end() )
+          {
+          lib_version = properties["VERSION"];
+          }
+        if ( properties.find("SOVERSION") != properties.end() )
+          {
+          lib_soversion = properties["SOVERSION"];
+          }
+        if ( !lib_version && lib_soversion )
+          {
+          lib_version = lib_soversion;
+          }
+        if ( !lib_soversion && lib_version )
+          {
+          lib_soversion = lib_version;
+          }
+        if ( lib_version && lib_soversion )
+          {
+          std::string libname = destfile;
+          std::string soname = destfile;
+          std::string soname_nopath = fname;
+          soname += ".";
+          soname += lib_soversion;
+          soname_nopath += ".";
+          soname_nopath += lib_soversion;
+
+          fname += ".";
+          fname += lib_version;
+          destfile += ".";
+          destfile += lib_version;
+
+          cmSystemTools::RemoveFile(soname.c_str());
+          cmSystemTools::RemoveFile(libname.c_str());
+
+          if (!cmSystemTools::CreateSymlink(soname_nopath.c_str(), libname.c_str()) )
+            {
+            std::string errstring = "error when creating symlink from: " + libname + " to " + soname_nopath;
+            this->SetError(errstring.c_str());
+            return false;
+            }
+          if ( destfile != soname )
+            {
+            if ( !cmSystemTools::CreateSymlink(fname.c_str(), soname.c_str()) )
+              {
+              std::string errstring = "error when creating symlink from: " + soname + " to " + fname;
+              this->SetError(errstring.c_str());
+              return false;
+              }
+            }
+          }
+        cmOStringStream str;
+        str << cmSystemTools::GetFilenamePath(ctarget) 
+          << "/" << extra_dir << "/" 
+          << fname;
+        ctarget = str.str();
         }
     case cmTarget::EXECUTABLE:
       if ( extra_dir.size() > 0 )
@@ -455,6 +525,7 @@ bool cmFileCommand::HandleInstallCommand(
 
     if ( cmSystemTools::FileExists(ctarget.c_str()) )
       {
+      cmSystemTools::RemoveFile(destfile.c_str());
       if ( !cmSystemTools::CopyFileAlways(ctarget.c_str(), 
           destination.c_str()) )
         {
@@ -482,7 +553,9 @@ bool cmFileCommand::HandleInstallCommand(
 #endif
         ) )
           {
-          perror("problem doing chmod.");
+          cmOStringStream err;
+          err << "Program setting permissions on file: " << destfile.c_str();
+          perror(err.str().c_str());
           }
         }
       smanifest_files += ";" + destfile;
diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx
index 61cb39d..f337ff1 100644
--- a/Source/cmLocalGenerator.cxx
+++ b/Source/cmLocalGenerator.cxx
@@ -189,7 +189,27 @@ void cmLocalGenerator::GenerateInstallRules()
         else
           {
           files = fname.c_str();
-          this->AddInstallRule(fout, dest, type, files);
+          std::string properties;
+          const char* lib_version = l->second.GetProperty("VERSION");
+          const char* lib_soversion = l->second.GetProperty("SOVERSION");
+          if(!m_Makefile->GetDefinition("CMAKE_SHARED_LIBRARY_SONAME_C_FLAG"))
+            {
+            // Versioning is supported only for shared libraries and modules,
+            // and then only when the platform supports an soname flag.
+            lib_version = 0;
+            lib_soversion = 0;
+            }
+          if ( lib_version )
+            {
+            properties += " VERSION ";
+            properties += lib_version;
+            }
+          if ( lib_soversion )
+            {
+            properties += " SOVERSION ";
+            properties += lib_soversion;
+            }
+          this->AddInstallRule(fout, dest, type, files, false, properties.c_str());
           }
         }
         break;
@@ -283,7 +303,7 @@ void cmLocalGenerator::GenerateInstallRules()
 }
 
 void cmLocalGenerator::AddInstallRule(std::ostream& fout, const char* dest, 
-  int type, const char* files, bool optional)
+  int type, const char* files, bool optional /* = false */, const char* properties /* = 0 */)
 {
   std::string sfiles = files;
   std::string destination = dest;
@@ -303,7 +323,12 @@ void cmLocalGenerator::AddInstallRule(std::ostream& fout, const char* dest,
     << "MESSAGE(STATUS \"Installing " << destination.c_str() 
     << "/" << fname.c_str() << "\")\n" 
     << "FILE(INSTALL DESTINATION \"" << destination.c_str() 
-    << "\" TYPE " << stype.c_str() << (optional?" OPTIONAL":"") 
+    << "\" TYPE " << stype.c_str() << (optional?" OPTIONAL":"") ;
+  if ( properties && *properties )
+    {
+    fout << " PROPERTIES" << properties;
+    }
+  fout
     << " FILES \"" << sfiles.c_str() << "\")\n";
 }
 
diff --git a/Source/cmLocalGenerator.h b/Source/cmLocalGenerator.h
index 412d3ac..792d8e1 100644
--- a/Source/cmLocalGenerator.h
+++ b/Source/cmLocalGenerator.h
@@ -90,9 +90,10 @@ public:
   ///! set/get the parent generator 
   cmLocalGenerator* GetParent(){return m_Parent;}
   void SetParent(cmLocalGenerator* g) { m_Parent = g;}
+
 protected:
   virtual void AddInstallRule(std::ostream& fout, const char* dest, int type, 
-    const char* files, bool optional = false);
+    const char* files, bool optional = false, const char* properties = 0);
   
   bool m_FromTheTop;
   cmMakefile *m_Makefile;