Changeset 566 for CMT/HEAD

Timestamp:

Apr 15, 2011, 5:01:46 PM (13 years ago)

Author:

rybkin

Message:

See C.L. 449

Location:

CMT/HEAD

Files:

• ChangeLog (modified) (1 diff)
• source/cmt_use.cxx (modified) (18 diffs)
• source/cmt_use.h (modified) (3 diffs)

CMT/HEAD/ChangeLog

@@ +1 @@
+2011-04-15    <rybkin@lal.in2p3.fr> 449
+
+        * source/cmt_use.h: In class Use, introduce functions find_valid,
+        is_head_version, members m_head_version, alternate_is_head_versions
+        * source/cmt_use.cxx: Implement functions find_valid, is_head_version.
+        Make use of find_valid in functions set_auto_imports_state,
+        set_auto_imports to ensure valid uses are followed. Make use of
+        is_head_version, in functions reach_package, add, of
+        alternate_is_head_versions, in function select_alternate to ensure
+        head version satisfies any request and takes priority
+        
 2011-04-12    <rybkin@lal.in2p3.fr> 448
 

CMT/HEAD/source/cmt_use.cxx

@@ -939 +939 @@
       {
         cout << "about to add " << package << endl;
-        show_packages ();
+        //show_packages ();
       }
 
@@ -954 +954 @@
                      << "> auto_imports=" << new_use->auto_imports << endl;
 
-                show_packages ();
+                //show_packages ();
               }
             /*
@@ -1220 +1220 @@
 }
 
+//----------------------------------------------------------
+/**
+ *    Find by @package@ Use-object that is
+ *    o not discarded
+ *    o in ordereded Uses list (i.e., has non-negative m_index)
+ */
+//----------------------------------------------------------
+Use* Use::find_valid (const cmt_string& package)
+{
+  Package* p = Package::find (package);
+  if (p == 0) return (0);
+
+  UsePtrVector& uses = p->get_uses ();
+
+  for (int use_index = 0; use_index < uses.size (); use_index++)
+    {
+      Use* use = uses[use_index];
+
+      if (use->discarded) continue;
+      if (use->m_index < 0) continue;
+      // take the first not discarded and ordered
+      // there should not be more than one
+      return use;
+    }
+
+  return (0);
+}
+
+//----------------------------------------------------------
 void Use::set_auto_imports_state (const Use::UsePtrVector& uses,
                                   cmt_vector<bool>& auto_imports_states,
@@ -1254 +1283 @@
       for (int i = 0; i < use->sub_uses.size (); i++)
         {
-          if (use->sub_uses[i]->m_index >= 0)
+          if (use->sub_uses[i]->m_index >= 0 && !use->sub_uses[i]->discarded)
             {
               if (use->sub_use_auto_imports[i] != Off)
@@ -1267 +1296 @@
           else
             {
-              visited.add (use->sub_uses[i], yes);
               if (Cmt::get_debug ())
                 {
                   cout << "Use::set_auto_imports_state> " << use->get_package_name ()
-                       << ": sub_use " << use->sub_uses[i]->get_package_name () << "["
-                       << use->sub_uses[i] << "] invalid" << endl;
+                       << " -> sub_use " << use->sub_uses[i]->get_package_name ()
+                       << "[" << use->sub_uses[i] << ", discarded="
+                       << use->sub_uses[i]->discarded << ", m_index="
+                       << use->sub_uses[i]->m_index << " : invalid]" << endl;
+                }
+              Use* au (find_valid (use->sub_uses[i]->get_package_name ()));
+              if (au)
+                {
+                  if (Cmt::get_debug ())
+                    {
+                      cout << "Use::set_auto_imports_state> " << use->get_package_name ()
+                           << " -> sub_use " << au->get_package_name ()
+                           << "[" << au << ", discarded="
+                           << au->discarded << ", m_index="
+                           << au->m_index << " : valid]" << endl;
+                    }
+                  if (use->sub_use_auto_imports[i] != Off)
+                    {
+                      subuses.push_back (au);
+                    }
+                  else
+                    {
+                      visited.add (au, yes);
+                    }
+                }
+              else
+                {
+                  visited.add (use->sub_uses[i], yes);
                 }
             }
@@ -1898 +1952 @@
               break;
             case IncompatibleMajorIds:
-              return (0);
+              if (!is_head_version (v))
+                return (0);
+              break;
             }
           version = v;
@@ -2002 +2058 @@
                     This check is not sufficient !! We need to check in addition
                     that the selected directory is really the start of a true CMT
-                    package (ie with either /mgr/requirements or /cmt/requirements below)
+                    package (ie with either cmt/requirements or mgr/requirements below)
                   */
 
@@ -2009 +2065 @@
                   req = name;
                   req += CmtSystem::file_separator ();
-                  req += "mgr";
+                  req += "cmt";
                   req += CmtSystem::file_separator ();
                   req += "requirements";
@@ -2017 +2073 @@
                       req = name;
                       req += CmtSystem::file_separator ();
-                      req += "cmt";
+                      req += "mgr";
                       req += CmtSystem::file_separator ();
                       req += "requirements";
@@ -2028 +2084 @@
                   cmt_string& new_p = alternate_paths.add ();
                   new_p = from_path;
+                  bool& new_i = alternate_is_head_versions.add ();
+                  new_i = is_head_version (name);
 
                   found = true;
@@ -2067 +2125 @@
 
   // Now we have met the exact specified version!
-  if (!CmtSystem::test_file ("cmt/requirements"))
-    {
-      if (!CmtSystem::test_file ("mgr/requirements"))
-        {
-          return (0);
-        }
-      else
-        {
-          CmtSystem::cd ("mgr");
-          style = mgr_style;
-          structuring_style = with_version_directory;
-        }
-    }
-  else
+  if (CmtSystem::test_file ("cmt/requirements"))
     {
       CmtSystem::cd ("cmt");
       style = cmt_style;
       structuring_style = with_version_directory;
+    }
+  else if (CmtSystem::test_file ("mgr/requirements"))
+    {
+      CmtSystem::cd ("mgr");
+      style = mgr_style;
+      structuring_style = with_version_directory;
+    }
+  else
+    {
+      return (0);
     }
 
@@ -2281 +2336 @@
       else
         {
+          if (alternate_is_head_versions[selected_index] &&
+              alternate_is_head_versions[i])
+            {
+              if (strcmp(name.c_str (), alternate_versions[selected_index].c_str ()) > 0)
+                {
+                  selected_index = i;
+                }
+              continue;
+            }
+          else if (alternate_is_head_versions[selected_index])
+            {
+              continue;
+            }
+          else if (alternate_is_head_versions[i])
+            {
+              selected_index = i;
+              continue;
+            }
+
           CmtSystem::is_version_directory (name, v, r, p);
 
@@ -2908 +2982 @@
           // thus we have to choose
           //
-          static BestFitSelector selector;
-          Use* selected_use = selector.operate (old_use, use);
+          bool old_use_is_head_version (use->is_head_version (old_use->version));
+          bool use_is_head_version (use->is_head_version (use->version));
+          Use* selected_use (old_use);
+          if (old_use_is_head_version && use_is_head_version)
+            {
+              if (strcmp(use->version.c_str (), old_use->version.c_str ()) > 0)
+                {
+                  selected_use = use;
+                  if (Cmt::get_debug ())
+                    {
+                      cout << "add> new head version " << use->version
+                           << " wins old head version " << old_use->version
+                           << endl;
+                    }
+                }
+            }
+          else if (old_use_is_head_version)
+            {
+            }
+          else if (use_is_head_version)
+            {
+              selected_use = use;
+              if (Cmt::get_debug ())
+                {
+                  cout << "add> new head version " << use->version
+                       << " wins old version " << old_use->version
+                       << endl;
+                }
+            }
+          else
+            {
+              static BestFitSelector selector;
+              selected_use = selector.operate (old_use, use);
+              if (Cmt::get_debug ())
+                {
+                  cout << "add> operate on old version " << old_use->version
+                       << " and new version " << use->version
+                       << endl;
+                }
+            }
 
           if (Cmt::get_debug ())
             {
-              cout << "after operate old=" << old_use << "(" << old_use->m_index << ")"
-                   << " use=" << use << "(" << use->m_index << ")"
+              cout << "add> old=" << old_use << "i=" << old_use->m_index
+                   << " new=" << use << "i=" << use->m_index
                    << " => selected=" << selected_use
                    << endl;
@@ -3051 +3163 @@
             {
               cout << "add> registering completed" << endl;
-              show_packages ();
+              //show_packages ();
             }
         }
@@ -3826 +3938 @@
 }
 
+//----------------------------------------------------------
 void Use::set_auto_imports (State context_state, State specified_state,
                             cmt_map <Use*, bool>& visited)
@@ -3906 +4019 @@
       else
         {
-          visited.add (sub_uses[i], yes);
           if (Cmt::get_debug ())
             {
               char num[32]; sprintf (num, "%#x", sub_uses[i]);
+              char index[32]; sprintf (index, "%d", sub_uses[i]->m_index);
               s += "[";
               s += num;
               s += ", discarded=";
               s += (sub_uses[i]->discarded ? "1" : "0");
-              s += "] invalid";
+              s += ", m_index=";
+              s += index;
+              s += " : invalid]";
+            }
+          Use* au (find_valid (sub_uses[i]->get_package_name ()));
+          if (au)
+            {
+              if (Cmt::get_debug ())
+                {
+                  char num[32]; sprintf (num, "%#x", au);
+                  char index[32]; sprintf (index, "%d", au->m_index);
+                  s += "[";
+                  s += num;
+                  s += ", discarded=";
+                  s += (au->discarded ? "1" : "0");
+                  s += ", m_index=";
+                  s += index;
+                  s += " : valid]";
+                }
+              au->set_auto_imports (context_state, state, visited);
+            }
+          else
+            {
+              visited.add (sub_uses[i], yes);
             }
         }
@@ -3983 +4119 @@
 }
 */
+
+//----------------------------------------------------------
 void Use::set_native_version (bool state)
 {
@@ -5127 +5265 @@
   //  return get_package_name () + " " + version + (path != "" ? " " + path : "") ;
 }
+
+//----------------------------------------------------------
+/**
+ *    Check whether @version@
+ *    is head version as specified by CMTHEADVERSION symbol/environment variable
+ *    or equals HEAD|head
+ */
+//----------------------------------------------------------
+bool Use::is_head_version (const cmt_string& version)
+{
+  if (!m_head_version.is_valid ())
+    {
+      cmt_string s (Symbol::get_env_value ("CMTHEADVERSION"));
+      static const cmt_string package_template = "<package>";
+      s.replace_all (package_template, get_package_name ());
+      static const cmt_string PACKAGE_template = "<PACKAGE>";
+      s.replace_all (PACKAGE_template, prefix);
+      static const cmt_string revision_template = "<revision>";
+      s.replace_all (revision_template.c_str (), "[0-9]*");
+      if (0 != s.size ())
+        {
+          if ('^' != s[0]) s = "^" + s;
+          if ('$' != s[s.size () - 1]) s = s + "$";
+        }
+      else
+        {
+          s = "^(HEAD|head)$";
+        }
+      m_head_version.set (s);
+      if (!m_head_version.is_valid ())
+        {
+          CmtMessage::warning
+            (CmtError::get_error_name (CmtError::configuration_error)
+             + ": CMTHEADVERSION regular expression invalid `" + s + "'");
+        }
+    }
+
+  return m_head_version.match (version);
+}

CMT/HEAD/source/cmt_use.h

@@ -32 +32 @@
                          const cmt_string& version, 
                          const cmt_string& path);
+  static Use* find_valid (const cmt_string& package);
   //static void set_auto_imports_state (int use_index,
   //cmt_vector<bool>& auto_imports_states);
@@ -147 +148 @@
   Project* get_project ();
   cmt_string get_info () const;
+  bool is_head_version (const cmt_string& version);
 // Public attributes
 public:
@@ -228 +230 @@
   CmtSystem::cmt_string_vector alternate_versions;
   CmtSystem::cmt_string_vector alternate_paths;
+  cmt_vector<bool> alternate_is_head_versions;
 
   CmtSystem::cmt_string_vector requests;
 
- 
+  cmt_regexp m_head_version; 
 
   friend class UseProjectAction;