source: CMT/v1r12p20020606/src/cmt_use.cxx @ 1

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "cmt_use.h"
#include "cmt_system.h"
#include "cmt_symbol.h"
#include "cmt_error.h"
#include "cmt_database.h"

/*
 *   Design.
 *
 *   There is one central database of all Use objects. This in the Database using:
 *       Database::instance().all_uses ();
 *
 *   There is also a list of selected Use pointers available from
 *       Database::instance().uses ();
 *
 *   A new Use object is created when a new use statement requires it:
 *     o if the specified version is specified for the first time
 *     o if the specified path is specified for the first time
 *
 */

class UseContext
{
public:

  static UseContext& current ()
  {
    static UseContext me;

    return (me);
  }

  UseContext ()
  {
    m_auto_imports = On;
    m_scope = ScopePublic;
  }

  UseContext (const UseContext& other)
  {
    m_auto_imports = other.m_auto_imports;
    m_scope = other.m_scope;
  }

  UseContext& operator = (const UseContext& other)
  {
    m_auto_imports = other.m_auto_imports;
    m_scope = other.m_scope;

    return (*this);
  }

  static void set_current (State auto_imports)
  {
    UseContext& c = current ();

    c.m_auto_imports = auto_imports;
  }

  static void set_current (ScopeType scope)
  {
    UseContext& c = current ();

    c.m_scope = scope;
  }

  static State get_current_auto_imports ()
  {
    UseContext& c = current ();

    return (c.m_auto_imports);
  }

  static ScopeType get_current_scope ()
  {
    UseContext& c = current ();

    return (c.m_scope);
  }

private:
  State m_auto_imports;
  ScopeType m_scope;
};

/**
 *    Version selectors provide the mechanism for comparing two 
 *  Use objects and decide which one has to be kept WRT their version
 *  id .
 *    Each strategy is implemented as a separate class (which overrides 
 *  the operate method)
 */
class VersionSelector
{
public:
  static VersionSelector& instance ();

  virtual Use* operate (Use* ref_use, Use* new_use)
  {
    return (ref_use);
  }
};

class BestFitSelector : public VersionSelector
{
public:
  Use* operate (Use* ref_use, Use* new_use);
};

class BestFitNoCheckSelector : public VersionSelector
{
public:
  Use* operate (Use* ref_use, Use* new_use);
};

class FirstChoiceSelector : public VersionSelector
{
public:
  Use* operate (Use* ref_use, Use* new_use);
};

class LastChoiceSelector : public VersionSelector
{
public:
  Use* operate (Use* ref_use, Use* new_use);
};

class KeepAllSelector : public VersionSelector
{
public:
  Use* operate (Use* ref_use, Use* new_use);
};
//----------------------------------------------------------

//----------------------------------------------------------
//
//  Operations on Use
//
//----------------------------------------------------------

/**
 *  Mark all clients of the current package.
 */
void Use::select_clients (const cmt_string& package,
                          const cmt_string& version)
{
  static UsePtrVector& Uses = uses ();

  int number;
  Use* use = 0;

  unselect_all ();
  undiscard_all ();

  for (number = Uses.size () - 1; number >= 0; number--)
    {
      use = Uses[number];
      if (use == 0) continue;
      if (use->is_selected ()) continue;
      use->select ();
      if (!use->is_client (package, version)) use->discard ();
    }
}

//----------------------------------------------------------
void Use::show_all (bool skip_discarded)
{
  show_all ("use ", skip_discarded);
}

//----------------------------------------------------------
void Use::show_all (const cmt_string& prefix, bool skip_discarded)
{
  static UsePtrVector& Uses = uses ();

  Use* use;
  int number;

  unselect_all ();

  use = &(current ());
  use->unselect ();
  if (!Cmt::get_quiet ()) use->show_sub_uses (skip_discarded);

  if (Uses.size () > 0)
    {
      if (!Cmt::get_quiet ())
        {
          cout << "#\n";
          cout << "# Selection :\n";
        }

      //
      //  First move the CMT package to the end of the use set.
      //  (ie. used by everybody)
      //
      use = Use::find ("CMT");
      Use::move (use);

      for (number = Uses.size () - 1; number >= 0; number--)
        {
          use = Uses[number];

          if (use->discarded) continue;

          if (!use->located ())
            {
              if (!Cmt::get_quiet ())
                {
                  cout << "# package " << use->package <<
                      " " << use->version << " " << use->path << 
                      " not found" <<
                      endl;
                }
              CmtError::set (CmtError::package_not_found, use->package);
            }
          else
            {
              static const cmt_string empty;
              cmt_string p = use->real_path;
              if (use->path != "")
                {
                  p.replace (use->path, empty);
                }
              
              cout << prefix << use->package <<
                  " " << use->version <<
                  " " << use->path;

              if (!Cmt::get_quiet ()) 
                {
                  if (p != "") cout << " (" << p << ")";
                  if (use->auto_imports == Off) cout << " (no_auto_imports)";
                }

              cout << endl;
            }
        }

      if (Cmt::get_cmt_home () != "")
        {
          cout << prefix << CmtSystem::get_home_package () <<
              " " << Cmt::get_cmt_home () <<
              endl;
        }

      if (Cmt::get_cmt_user_context () != "")
        {
          cout << prefix << CmtSystem::get_user_context_package () <<
              " " << Cmt::get_cmt_user_context () <<
              endl;
        }
    }
}

/**
 *   This private class parses the use statement after macro expansion
 *   This is a finite state machine.
 *    It maintains the results of the parsing in terms of a package name,
 *   a version, a path, and state variables (no_auto_imports)
 */
class use_action_iterator
{
public:

  use_action_iterator ()
      {
        state = need_package;
        auto_imports = Unspecified;
      }

  void set (const cmt_string& w)
      {
        if (w == "-auto_imports")
          {
            auto_imports = On;
          }
        else if (w == "-no_auto_imports")
          {
            auto_imports = Off;
          }
        else if (w == "|")
          {
            state = need_version_alias;
          }
        else
          {
            switch (state)
              {
                case need_package:
                  package = w;
                  state = need_version;
                  break;
                case need_version:
                  version = w;
                  state = need_path;
                  break;
                case need_path:
                  path = w;
                  state = finished;
                  break;
                case need_version_alias:
                  version_alias = w;
                  state = need_path_alias;
                  break;
                case need_path_alias:
                  path_alias = w;
                  state = finished;
                  break;
              }
          }
      }

  bool ok ()
      {
        if (package == "") return (false);
        if (CmtSystem::is_home_package (package, version)) return (false);
        if (CmtSystem::is_user_context_package (package, version)) return (false);

        return (true);
      }

  /**
   *
   *  Build or retreive the Use object corresponding to the parsed specification.
   *
   */
  Use* get_use (Use* parent)
      {
        static Use::UsePtrVector& Uses = Use::uses ();

        if (version == "") version = "*";

        if (Cmt::get_debug ())
          {
            int i;

            cout << "use::action1> current=" << parent->package <<
                " package=" << package << " ";

            for (i = 0; i < Uses.size (); i++)
              {
                Use* u = Uses[i];
                cout << u->package << " ";
              }
            cout << endl;
          }

        const Use& cu = Use::current ();

        /**
         *   Do not continue the operations for private uses
         *  accessed from an external context.
         *
         *   Exceptions should be considered for 
         *     - cmt broadcast
         *     - cmt show uses
         */

        ActionType action = Cmt::get_action ();

        if (Cmt::get_debug ())
          {
            cout << "before adding " << package <<"> auto_imports=" << auto_imports
                 << " (current AI was " << UseContext::get_current_auto_imports () << ")" 
                 << " (current scope was " << UseContext::get_current_scope () << ")" 
                 << " (Cmt::scope=" << Cmt::get_scope () << ")"
                 << " (parent=" << parent->package << ")"
                 << endl;
          }

        bool hidden_by_scope = false;

        if ((Cmt::get_scope () == ScopePrivate) || (UseContext::get_current_scope () == ScopePrivate))
          {
            hidden_by_scope = true;

            // Do not hide immediate children of the current package.
            if ((parent == 0) || (parent->package == cu.package)) hidden_by_scope = false;

            // Do not hide in broadcast and show uses actions.
            if ((action == action_broadcast) ||
                (action == action_show_uses)) hidden_by_scope = false;
          }

        if (hidden_by_scope)
          {
            return (0);
          }

        // Here the version may contain wild cards

        UseContext save = UseContext::current ();

          /**
           *  "auto_imports" is the state which is specified on the use statement 
           *  currently being parsed.
           */
        switch (auto_imports)
          {
            case Unspecified:

                // unspecified => we forward the state saved in the current use context

              UseContext::set_current (UseContext::get_current_auto_imports ());
              break;
            case Off:

                // off => the context becomes constrained to be off

              UseContext::set_current (Off);
              break;
            case On:

                // on => if current context is off it is kept off
                //       otherwise it is forced to on

              if (UseContext::get_current_auto_imports () != Off)
                {
                  UseContext::set_current (On);
                }
              break;
          }

        if (hidden_by_scope)
          {
            UseContext::set_current (Cmt::get_scope ());
          }

        /// Now do create or retreive the Use object.
        Use* new_use = Use::add (path, package, version, 
                                 version_alias, path_alias, parent,
                                 auto_imports);

        if (new_use != 0)
          {
            if (Cmt::get_debug ())
              {
                cout << "after adding1 " << package << "> auto_imports=" << new_use->auto_imports << endl;
              }

            switch (new_use->auto_imports)
              {
                case Unspecified:
                  new_use->auto_imports = UseContext::get_current_auto_imports ();
                  break;
                case On:
                  break;
                case Off:
                  if (UseContext::get_current_auto_imports () == On)
                    {
                        /**
                         *  Warning : this Use had been previously specified as -no_auto_imports
                         *  Now this new specification tries to turn it to auto_imports.
                         *  It will be required to propagate the change, according to the 
                         *  specifications:
                         *
                         *    for all sub_uses:
                         *       if it is unspecified OR specified as auto_imports:
                         *          turn it to auto_imports
                         *
                         */
                      new_use->set_auto_imports (On);
                    }
                  break;
              }


            if (Cmt::get_debug ())
              {
                cout << "after adding2 " << package << "> auto_imports=" << new_use->auto_imports << endl;
              }

            UseContext& c = UseContext::current ();
            c = save;

            Use::reorder (new_use, parent);
            
            if (Cmt::get_debug ())
              {
                int i;
                
                cout << "use::action2> current=" << parent->package
                     << " package=" << package << " ";

                for (i = 0; i < Uses.size (); i++)
                  {
                    Use* u = Uses[i];
                    cout << u->package << " ";
                  }

                cout << endl;
              }
          }

        return (new_use);
      }

private:

  enum
  {
    need_package,
    need_version,
    need_path,
    need_version_alias,
    need_path_alias,
    finished
  } state;
  
  State auto_imports;

  cmt_string package;
  cmt_string version;
  cmt_string path;
  cmt_string version_alias;
  cmt_string path_alias;
};

//----------------------------------------------------------
Use* Use::action (const CmtSystem::cmt_string_vector& words, Use* parent)
{
  Use* new_use;

  //
  // complete syntax : "use <package> <version> <path>"
  // minimal syntax  : "use <package>"
  //
  //  o if <version> is omitted then take any version available
  //  o <version> can be specified using "v*" or "v<n>r*" or "v<n>r<m>p*"
  //
  //  o the notation "v*" is preferred to omission (particularly since
  //    omission does not permit <path>)
  //
  if (words.size () < 2) return (0);

  use_action_iterator it;

  for (int i = 1; i < words.size (); i++)
    {
      const cmt_string& w = words[i];
      cmt_string ew = w;

      Symbol::expand (ew);
      if (ew != w)
        {
          CmtSystem::cmt_string_vector ws;

          CmtSystem::split (ew, " ", ws);

          for (int j = 0; j < ws.size (); ++j)
            {
              const cmt_string& ww = ws[j];
              it.set (ww);
            }
        }
      else
        {
          it.set (ew);
        }
    }

  if (!it.ok ()) return (0);

  static int level = 0;

  level++;
  new_use = it.get_use (parent);
  level--;

  return (new_use);
}

//----------------------------------------------------------
void Use::author_action (const CmtSystem::cmt_string_vector& words)
{
  if (author != "") author += "\n";
  for (int i = 1; i < words.size (); i++)
    {
      const cmt_string& w = words[i];
      
      if (i > 1) author += " ";
      author += w;
    }
}

//----------------------------------------------------------
void Use::manager_action (const CmtSystem::cmt_string_vector& words)
{
  if (manager != "") manager += "\n";
  for (int i = 1; i < words.size (); i++)
    {
      const cmt_string& w = words[i];
      
      if (i > 1) manager += " ";
      manager += w;
    }
}

//----------------------------------------------------------
Use* Use::find (const cmt_string& package, 
                const cmt_string& version, 
                const cmt_string& path)
{
  static UsePtrVector& Uses = uses ();
  static UseVector& AllUses = all_uses ();

  int use_index;

  if (AllUses.size () == 0) return (0);

  for (use_index = 0; use_index < Uses.size (); use_index++)
    {
      Use& use = (*Uses[use_index]);

      if (use.package == package)
        {
            // If the version argument is omitted then
            // take the first registered version
          if (version == "") return (&use);
          
            // Otherwise compare against specified_version and path
            //if ((use.specified_version == version) && 
            //  (use.specified_path == path)) return (&use);
          
            // what about comparing wild cards?

          if (use.specified_version == version) return (&use);
        }
    }

  return (0);
}

//----------------------------------------------------------
int Use::find_index (const cmt_string& package, 
                     const cmt_string& version, 
                     const cmt_string& path)
{
  static UsePtrVector& Uses = uses ();
  static UseVector& AllUses = all_uses ();

  int use_index;

  if (AllUses.size () == 0) return (-1);

  for (use_index = 0; use_index < Uses.size (); use_index++)
    {
      Use& use = (*Uses[use_index]);

      if (use.package == package)
        {
          // If the version argument is omitted then
          // take the first registered version
          if (version == "") return (use_index);
          
          // Otherwise compare against specified_version and path
          //if ((use.specified_version == version) && 
          //  (use.specified_path == path)) return (&use);
          
          // what about comparing wild cards?

          if (use.specified_version == version) return (use_index);
        }
    }

  return (-1);
}

/**
 *   1) Given a Use object identified by its index in the uses() array,
 *   2) Given a vector of states containing the auto_imports states of all Uses,
 *
 *     we want to switch to 'On' the auto_imports states of all
 *     sub_uses of the argument that were Off.
 *
 */
void Use::set_auto_imports_state (int use_index,
                                  cmt_vector<bool>& auto_imports_states)
{
  // check if this is already done (recursivity ending)
  if (auto_imports_states[use_index]) return;

  Use::UsePtrVector& Uses = Use::uses ();
  Use* use = Uses[use_index];

  // Is this a mistake? we only have to deal with Use objects that were
  // actually turned Off
  if (use->auto_imports != Off) return;

  /**
   *  Here, use points to a Use object which had been declared as
   *  no_auto_imports. But we need to switch it On. Therefore, 
   *
   *    1) the state in auto_imports_states has to be set On 
   *    2) the operation has to be recursively propagated to all
   *         sub_uses which also had no_auto_imports. (only to those)
   *  
   */
  
  auto_imports_states[use_index] = true;

  for (int i = 0; i < use->sub_uses.size (); i++)
    {
      Use* u = use->sub_uses[i];

      if (u->sub_use_auto_imports[i] == Off)
        {
          int j;
          
          // first find the index of this use.
          
          for (j = 0; j < Uses.size(); j++)
            {
              if (u == Uses[j]) break;
            }
          
          set_auto_imports_state (j, auto_imports_states);
        }
    }
}

//----------------------------------------------------------
//
//  Move use to the end
//
//----------------------------------------------------------
void Use::move (Use* use1)
{
  static UsePtrVector& Uses = uses ();

  int use_index;
  Use* use;
  int found = 0;

  if (Uses.size () == 0) return;
  if (use1 == 0) return;

  //
  // On se positionne sur le pointeur.
  //
  for (use_index = 0; use_index < Uses.size (); use_index++)
    {
      use = Uses[use_index];

      if (use == use1)
        {
          found = 1;
          break;
        }
    }

  if (!found) return;

  //
  // On deplace tous les pointeurs d'une case en arriere
  //
  for (use_index++;
       use_index < Uses.size ();
       use_index++)
    {
      Uses[use_index - 1] = Uses[use_index];
    }

  //
  // use1 est donc replace en derniere position
  //
  {
    Uses[Uses.size () - 1] = use1;
  }
}

/**
 *   Reorder use1 versus use2 in the UsePtrVector list, so that the order reflects the fact
 *  that use2 makes use of use1.
 *   The result should be that use1 appears before use2 in the list.
 */
void Use::reorder (Use* use1, Use* use2)
{
  static UsePtrVector& Uses = uses ();

  int use_index;
  int index1 = -1;
  int index2 = -1;
  Use* use;

  if (Uses.size () == 0) return;
  if (use1 == use2) return;

  //
  // First locate the two use objects into the Uses vector.
  //   -> index1 and index 2
  //
  for (use_index = 0; use_index < Uses.size (); use_index++)
    {
      use = (Use*) Uses[use_index];

      if (use == use1) index1 = use_index;
      if (use == use2) index2 = use_index;
    }

  if (Cmt::get_debug ())
    {
      cout << "Use::reorder> 1=" << index1 << " 2=" << index2 << endl;
    }

  //
  // Both objects must be installed in Uses before acting.
  //
  if (index1 == -1) return;
  if (index2 == -1) return;

  if (index2 < index1)
    {
      //
      // 2 is already before 1 so job is finished
      //
      return;
    }
  else
    {
      //
      // before : <a a a 1 b b b 2 c c c>
      //                 ^       ^
      //                 i1      i2
      //
      //  1) move "1 b b b" by one place to the right
      // thus :   <a a a 1 1 b b b c c c>
      //
      //  2) move "2" to [i1]
      //
      // after  : <a a a 2 1 b b b c c c>
      //

      use = use2;

      for (use_index = index2 - 1; use_index >= index1; use_index--)
        {
          Uses[use_index + 1] = Uses[use_index];
        }

      Uses[index1] = use;
    }
}

//----------------------------------------------------------
void Use::clear_all ()
{
  static UsePtrVector& Uses = uses ();
  static UseVector& AllUses = all_uses ();

  int use_index;

  for (use_index = 0; use_index < AllUses.size (); use_index++)
    {
      Use& use = AllUses[use_index];
      use.clear ();
    }

  Uses.clear ();
  AllUses.clear ();
}

//----------------------------------------------------------
void Use::unselect_all ()
{
  static UsePtrVector& Uses = uses ();

  int use_index;

  if (Uses.size () == 0) return;

  for (use_index = 0; use_index < Uses.size (); use_index++)
    {
      Use* use = Uses[use_index];

      if (use != 0)
        {
          use->unselect ();
        }
    }
}

//----------------------------------------------------------
void Use::undiscard_all ()
{
  static UsePtrVector& Uses = uses ();

  int use_index;

  if (Uses.size () == 0) return;

  for (use_index = 0; use_index < Uses.size (); use_index++)
    {
      Use* use = Uses[use_index];

      if (use != 0)
        {
          use->undiscard ();
        }
    }
}

//----------------------------------------------------------
void Use::fill_macro_all (cmt_string& buffer, const cmt_string& suffix)
{
  UsePtrVector& Uses = uses ();

  buffer = "macro_append use_";
  buffer += suffix;
  buffer += " \" ";
  (Use::current()).fill_macro (buffer, suffix);

  for (int number = 0; number < Uses.size (); number++)
    {
      Use* use = Uses[number];
      
      if (use->package == "CMT") continue;
      if (use->package == "methods") continue;
      if (use->discarded) continue;
      if (use->auto_imports == Off) continue;

      use->fill_macro (buffer, suffix);
    }
  
  buffer += "\"";
}

//----------------------------------------------------------
Use::Use ()
{
  done = false;
  discarded = false;
  auto_imports = Unspecified;

  clear ();
}

//----------------------------------------------------------
Use::Use (const cmt_string& new_package,
          const cmt_string& new_version,
          const cmt_string& new_path)
{
  auto_imports = Unspecified;
  m_located = false;
  set (new_package, new_version, new_path);
}

//----------------------------------------------------------
Use::~Use ()
{
  clear ();
}

//----------------------------------------------------------
void Use::clear ()
{
  specified_path = "";
  path      = "";
  package   = "";
  version   = "";
  author    = "";
  manager   = "";
  real_path = "";

  prefix    = "";
  style     = mgr_style;
  scope     = Cmt::get_scope ();
  done      = false;
  discarded = false;
  selected  = false;
  auto_imports = Unspecified;

  includes.clear ();
  include_path = "";
  scripts.clear ();
  apply_patterns.clear ();
  ignore_patterns.clear ();

  sub_uses.clear ();
  sub_use_scopes.clear ();
  sub_use_auto_imports.clear ();

  alternate_versions.clear ();
  alternate_paths.clear ();

  version_alias = "";
  path_alias    = "";

  m_located = false;
  m_has_native_version = false;
}

//----------------------------------------------------------
void Use::set (const cmt_string& new_package,
               const cmt_string& new_version,
               const cmt_string& new_path,
               const cmt_string& new_version_alias,
               const cmt_string& new_path_alias)
{
  clear ();

  package           = new_package;
  specified_path    = new_path;
  // specified_path.replace_all ("\\", "/");

  specified_version = new_version;
  version           = new_version;
  path              = specified_path;
  Symbol::expand (path);
  real_path         = "";
  style             = mgr_style;
  scope             = Cmt::get_scope ();
  done              = false;
  discarded         = false;
  Cmt::build_prefix (new_package, prefix);

  version_alias = new_version_alias;
  path_alias    = new_path_alias;
}

//----------------------------------------------------------
void Use::change_path (const cmt_string& new_path)
{
  // 
  // This methods changes real_path after an actual location
  // where this package/version has been found.
  //

  real_path = "";

  if (new_path != "")
    {
      if ((path.size () > 0) &&
          (!CmtSystem::absolute_path (path)))
        {
          real_path = new_path;
          real_path += CmtSystem::file_separator ();
          real_path += path;
        }
      else
        {
          real_path = new_path;
        }
      // real_path.replace_all ("\\", "/");
    }
  
  m_located = true;
}

//----------------------------------------------------------
int Use::reach_package (const cmt_string& from_path)
{
  //cerr << "Use::reach_package> (" << package << " " << version << ")from " << from_path << endl;

  //
  // We try to reach a package/version starting from from_path
  //

  // check if from_path is at least real
  if ((from_path != "") && !CmtSystem::cd (from_path)) return (0);

  // check in case from_path is a new search path 
  if (from_path != real_path)
    {
      // Move to that prefix only if it is a relative path.
      if ((path.size () > 0) && (!CmtSystem::absolute_path (path)))
        {
          if (!CmtSystem::cd (path))
            {
              return (0);
            }
        }
    }

  // Special treatment for CMTHOME package...
  if (package == CmtSystem::get_home_package ())
    {
      discarded = 1;
      if (!CmtSystem::test_file ("requirements"))
        {
          return (0);
        }
      else
        {
          return (1);
        }
    }

  // Special treatment for CMTUSERCONTEXT package...
  if (package == CmtSystem::get_user_context_package ())
    {
      discarded = 1;
      if (!CmtSystem::test_file ("requirements"))
        {
          return (0);
        }
      else
        {
          return (1);
        }
    }

  // Now from_path exists, try if the package exists there
  if (!CmtSystem::cd (package))
    {
      return (0);
    }

  if (!CmtSystem::cd (version))
    {
      //
      // The specified version cannot be found per-se
      // There are alternate possibilities when it contains wild cards
      //
      if ((version == "") ||
          (version.find ("*") != cmt_string::npos))
        {
          static CmtSystem::cmt_string_vector versions;
          static cmt_string name;

          name = ".";
          name += CmtSystem::file_separator ();
          if (version == "") name += "*";
          else name += version;

          CmtSystem::scan_dir (name, versions);
          
          int i;
          bool found = false;
          
          for (i = 0; i < versions.size (); i++)
            {
              const cmt_string& vers = versions[i];
              
              if (Cmt::get_debug ())
                {
                  cout << "     ... version " << vers << " exists" << endl;
                }

              CmtSystem::basename (vers, name);
              
              int v;
              int r;
              int p;
              
              if (CmtSystem::is_version_directory (name, v, r, p))
                {
                  /*
                    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)
                  */

                  cmt_string req;

                  req = name;
                  req += CmtSystem::file_separator ();
                  req += "mgr";
                  req += CmtSystem::file_separator ();
                  req += "requirements";

                  if (!CmtSystem::test_file (req))
                    {
                      req = name;
                      req += CmtSystem::file_separator ();
                      req += "cmt";
                      req += CmtSystem::file_separator ();
                      req += "requirements";

                      if (!CmtSystem::test_file (req)) continue;
                    }

                  cmt_string& new_v = alternate_versions.add ();
                  new_v = name;
                  cmt_string& new_p = alternate_paths.add ();
                  new_p = from_path;

                  found = true;
                }
            }
        }

      if (Cmt::get_debug ())
        {
          cout << "  ... end of version scan" << endl;
        }

        //
        //  We have now the list of possible alternate versions. However
        // we return that the expected package/version was not found (yet).
        //

      return (0);
    }

  //cerr << "  ... version " << version << " exists" << endl;

  // 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;
        }
    }
  else
    {
      CmtSystem::cd ("cmt");
      style = cmt_style;
    }

  return (1);
}

//----------------------------------------------------------
bool Use::move_to ()
{
  if (m_located)
    {
      //
      // The real path where this version/package can be found 
      // has already been resolved. We thus first go there.
      //

      if (Cmt::get_debug ())
        {
          cout << "move_to1> " << real_path << endl;
        }

      reach_package (real_path);

      return (true);
    }

  cmt_string expanded_path = path;

  //
  // Try here.
  //
  if (expanded_path == "")
    {
      if (reach_package (""))
        {
          if (Cmt::get_debug ())
            {
              cout << "move_to2> " << expanded_path << endl;
            }

          change_path (expanded_path);

          return (true);
        }
      else if (alternate_versions.size () > 0)
        {
          if (select_alternate ()) 
            {
              if (Cmt::get_debug ())
                {
                  cout << "move_to5> " << real_path << endl;
                }
              
              return (true);
            }
        }
    }
      
  //
  // If the path specified in this use is a true absolute path,
  // then we search the package from there first.
  //
  if (CmtSystem::absolute_path (expanded_path))
    {
      if (reach_package (expanded_path))
        {
          if (Cmt::get_debug ())
            {
              cout << "move_to3> " << expanded_path << endl;
            }

          change_path (expanded_path);

          return (true);
        }
      else if (alternate_versions.size () > 0)
        {
          if (select_alternate ()) 
            {
              if (Cmt::get_debug ())
                {
                  cout << "move_to5> " << real_path << endl;
                }
              
              return (true);
            }
        }
    }
      
  //
  // Second try is among the CMTPATHs
  //
      
  static const CmtSystem::cmt_string_vector& search_path = Cmt::get_cmt_path ();
  int path_index = 0;
      
  for (path_index = 0; path_index < search_path.size (); path_index++)
    {
      const cmt_string& next_path = search_path[path_index];
      
      alternate_versions.clear ();
      alternate_paths.clear ();

      if (reach_package (next_path))
        {
          if (Cmt::get_debug ())
            {
              cout << "move_to4> " << next_path << endl;
            }

          change_path (next_path);

          return (true);
        }
      else if (alternate_versions.size () > 0)
        {
          if (select_alternate ()) 
            {
              if (Cmt::get_debug ())
                {
                  cout << "move_to5> " << real_path << endl;
                }
              
              return (true);
            }
        }
    }
  

  return (false);
}

//----------------------------------------------------------
bool Use::select_alternate ()
{
  int i;

  int v0 = 0;
  int r0 = 0;
  int p0 = 0;

  int v = 0;
  int r = 0;
  int p = 0;

  int selected_index = -1;

  for (i = 0; i < alternate_versions.size (); i++)
    {
      cmt_string& name = alternate_versions[i];

        /*
      if (CmtSystem::getenv ("CMTTESTUSEWILDCARDS") != "")
        {
          cout << "select_alternate[" << this << "]> package " << package << 
              " sv=" << specified_version << 
              " v=" << version << 
              " av[" << i << "]=" << name << endl;
        }
        */

      if (i == 0)
        {
          CmtSystem::is_version_directory (name, v0, r0, p0);
          selected_index = 0;
        }
      else
        {
          CmtSystem::is_version_directory (name, v, r, p);

          if (v > v0)
            {
              selected_index = i;
              v0 = v;
              r0 = r;
              p0 = p;
            }
          else if (v == v0)
            {
              if (r > r0)
                {
                  selected_index = i;
                  r0 = r;
                  p0 = p;
                }
              else if (r == r0)
                {
                  if (p > p0)
                    {
                      selected_index = i;
                      p0 = p;
                    }
                }
            }
        }
    }

  if (selected_index >= 0)
    {
      if (CmtSystem::cd (alternate_paths[selected_index]))
        {
          version = alternate_versions[selected_index];
          if (reach_package (alternate_paths[selected_index]))
            {
                /*
              if (CmtSystem::getenv ("CMTTESTUSEWILDCARDS") != "")
                {
                  cout << "select_alternate2> package " << package << 
                      " sv=" << specified_version << 
                      " v=" << version << endl;
                }
                */

              if (Cmt::get_debug ())
                {
                  cout << "select_alternate> " << alternate_paths[selected_index] << endl;
                }

              change_path (alternate_paths[selected_index]);
              return (true);
            }
        }
    }

  return (false);
}

//----------------------------------------------------------
bool Use::need_new (const cmt_string& path,
                    const cmt_string& package,
                    const cmt_string& version,
                    Use** old_use)
{
  bool has_wild_card = (version.find ("*") != cmt_string::npos);

  static UsePtrVector& Uses = uses ();
  static UseVector& AllUses = all_uses ();

  bool result = true;
  Use* found = 0;

  int use_index;

  if (old_use != 0) *old_use = 0;
  if (AllUses.size () == 0) return (true);

  for (use_index = 0; use_index < Uses.size (); use_index++)
    {
      Use& use = (*Uses[use_index]);

      if (use.package != package) continue;

      found = &use;

      /*
        cerr << "Use::need_new> (" << package
        << ") requested version=" << version
        << " vs existing=" << use->version
        << " (specified as " << use->specified_version
        << ")" << endl;
      */

      bool use_has_wild_card = (use.specified_version.find ("*") != cmt_string::npos);

      if (has_wild_card && !use_has_wild_card)
        {
          //cerr << "  ... requested wildcarded loses against existing explicit" << endl;
          result = false;
          break;
        }

      if ((version == use.specified_version) &&
          (path == use.specified_path))
        {
          // exactly same version and path!
          result = false;
          break;
        }

      // requested explicit wins against existing wildcarded
      // In any case when paths are different, consider the new one.
      // Now paths are identical (thus versions are different).
    }

  if (old_use != 0) *old_use = found;
  return (result);
}

//----------------------------------------------------------
//
//  Here the version which is provided here is the specified version.
// It may contain wild cards or it may be simply empty.
//
//----------------------------------------------------------
Use* Use::create (const cmt_string& path,
                  const cmt_string& package,
                  const cmt_string& version,
                  const cmt_string& version_alias,
                  const cmt_string& path_alias)
{
  static UseVector& AllUses = all_uses ();

  // We first look in the database.
  for (int use_index = 0; use_index < AllUses.size (); use_index++)
    {
      Use& use = AllUses[use_index];

      if (use.package == package)
        {
          if ((use.specified_version == version) && 
              (use.specified_path == path)) return (&use);
        }
    }

  // We now really create a new Use entry.

  Use& use_object = AllUses.add ();
  use_object.set (package, version, path, version_alias, path_alias);

  return (&use_object);
}

//----------------------------------------------------------
//  Add a use request into the database.
//
//  o If a use request already exist in the database,
//    check the version compatibility
//
//----------------------------------------------------------
Use* Use::add (const cmt_string& path,
               const cmt_string& package,
               const cmt_string& version,
               const cmt_string& version_alias,
               const cmt_string& path_alias,
               Use* context_use,
               State specified_auto_imports)
{
  static UsePtrVector& Uses = uses ();

  bool do_need_new = false;

  Use* old_use = 0;
  Use* use = 0;

  do_need_new = need_new (path, package, version, &old_use);

  /*
    if (old_use != 0)
    {
    cout << "add> old_use " << old_use->package <<
    " " << old_use->version <<
    " " << old_use->path <<
    endl;
    }
  */

  if (do_need_new)
    {
      use = create (path, package, version, version_alias, path_alias);
    }
  else
    {
      // Since we don't need a new Use, it means that old_use exists !
      use = old_use;
      old_use = 0;
    }

  if (package == CmtSystem::get_home_package ())
    {
      return (use);
    }

  if (package == CmtSystem::get_user_context_package ())
    {
      return (use);
    }

  cmt_string here = CmtSystem::pwd ();

    //
    // Store the specified sub_uses. Some of them may become discarded
    // later on.
    //
  if (context_use != 0)
    {
      context_use->sub_uses.push_back (use);
      context_use->sub_use_scopes.push_back (Cmt::get_scope ());
      context_use->sub_use_auto_imports.push_back (specified_auto_imports);

      if (Cmt::get_debug ())
        {
          cout << "Use::add context(" << context_use->package << ") "
               << "[u:" << package
               << " s:" << Cmt::get_scope ()
               << " ai:" << specified_auto_imports
               << "]" << endl;
        }
    }

  /*
   *   Now we have a Use object. If it is a new one, we have to
   *    1) understand if it exists physically
   *    2) it is better than the old ones.
   *
   *   Here, we may have :
   *    1) old_use = 0 
   *         there was no Use object before for this package
   *         the existing one is fine
   *
   *    2) old_use != 0 
   *         we have created a new Use (which has to be validated)
   */

  bool found = use->move_to ();

  if (Cmt::get_debug ())
    {
      cout << "add> use " << use->package 
           << " " << use->version
           << " " << use->path
           << " found=" << found
           << endl;
    }
      
  if (!found)
    {
      if (!Cmt::get_quiet ())
        {
          cerr << "#(Warning) package " << use->package <<
            " " << use->version << " " << use->path << 
            " not found" <<
            endl;
        }

      CmtError::set (CmtError::package_not_found, use->package);
      use = 0;
    }

  if ((old_use != 0) && (use != old_use))
    {
      /*
       *    There was another version of this Use. But a new one was created due to 
       *   some criteria.
       *    New we are going to apply the version strategy to make the final selection.
       */

      /*
        if (CmtSystem::getenv ("CMTTESTUSEWILDCARDS") != "")
        {
        cout << "select? [" << use << "] vs old_use[" << old_use << "] " << old_use->package <<
        " " << old_use->version <<
        " " << old_use->path <<
        endl;
        }
      */

      if (!found)
        {
          /*
           *  This new Use does not correspond to any physical package.
           *  let's simply discard it 
           */

          if (use != 0) use->discard ();
          use = old_use;
          found = use->move_to ();
        }
      else
        {
            //
            //  This new version is different from the old one
            // thus we have to choose
            //
          VersionSelector& selector = VersionSelector::instance ();
          Use* selected_use = selector.operate (old_use, use);

            //
            // Some situations managed by selector.operate happen
            // to fail discarding the rejected Use.
            //
          if (use != selected_use) 
            {
              use->discard ();
            }
          
          use = selected_use;

          /*
           *   current directory is moved to the selected one
           */
          found = use->move_to ();
        }
    }

    //
    // The following statement is no longer considered as useful.
    // It is commented. But we should clarify why it was really needed!
    //
    //use->undiscard ();

  if (found)
    {
      bool registered = false;
      const Use& cu = Use::current ();

      //
      // A pointer to this new object is also added or replaced.
      //
      if ((use != &cu) && (package == cu.package))
        {
            // This is a recursive call to the current package!!
          registered = true;
          use->done = true;
        }
      else
        {
          for (int i = 0; i < Uses.size(); i++)
            {
              Use* u = Uses[i];
              
              if (u->package == package)
                {
                  registered = true;
                  Uses[i] = use;
                  break;
                }
            }
        }
      
      if (!registered) Uses.push_back (use);

      if (!use->done && Cmt::get_recursive ())
        {
          use->done = true;

          /*
            if (CmtSystem::getenv ("CMTTESTUSEWILDCARDS") != "")
            {
            for (int use_index = 0; use_index < Uses.size (); use_index++)
            {
            Use* u = (Use*) Uses[use_index];
            cout << "  use[" << use_index << "] p=" << u->package <<
            " v=" << u->version <<
            " discarded=" << u->discarded <<
            " selected=" << u->selected <<
            endl;
            }
            
            cout << "parsing at " << CmtSystem::pwd () << endl;
            }
          */
          
          /**
             Get the previous set of effective use statements
             that might have been obtained in a previous build.
             This is stored in uses.log. Ignored if file does not exist.
          */
          
          //Cmt::parse_requirements ("uses.log", use);
          
          if (Cmt::get_debug ())
            {
              cout << "Parsing requirements file at " << CmtSystem::pwd () << endl;
            }
          
          Cmt::parse_requirements ("requirements", use);
        }
    }

  CmtSystem::cd (here);

  return (use);
}

//----------------------------------------------------------
void Use::discard ()
{
  discarded = true;
}

//----------------------------------------------------------
void Use::undiscard ()
{
  discarded = false;
}

//----------------------------------------------------------
void Use::select ()
{
  selected = true;
}

//----------------------------------------------------------
void Use::unselect ()
{
  selected = false;
}

//----------------------------------------------------------
bool Use::is_selected ()
{
  return (selected);
}

/**
 *    Check if the package makes use of the specified package/version
 *
 *    The seach only considers the first level of uses (thus it is
 *   NOT recursive)
 */
bool Use::is_client (const cmt_string& used_package,
                     const cmt_string& used_version)
{
  // A package is client of itself
  if ((package == used_package) &&
      (version == used_version)) return (true);

  if (discarded) return (false);

  int i;

  for (i = 0; i < sub_uses.size (); i++)
    {
      Use* use = sub_uses[i];
      if (use == 0) continue;

      if ((use->package == used_package) &&
          (use->version == used_version)) return (true);

      /*
        if (use->is_client (used_package, used_version))
        {
        return (true);
        }
      */
    }

  return (false);
}

//----------------------------------------------------------
void Use::apply_global_patterns ()
{
  int i;

  Pattern::PatternVector& vector = Pattern::patterns ();

  for (i = 0; i < vector.size (); i++)
    {
      Pattern& p = vector[i];

      if (p.global)
        {
          p.apply (this);
        }
    }
}

//----------------------------------------------------------
void Use::set_include_path (const cmt_string& new_path)
{
  include_path = new_path;
}

/**
 *   Compute the full real path of a found package.
 *   Takes the structuring style into account
 *
 *    Result is used to fill in the referenced string
 *    Result does NOT include the trailing file_separator
 */
void Use::get_full_path (cmt_string& s) const
{
  if (real_path == "") s = CmtSystem::pwd ();
  else s = real_path;

  s += CmtSystem::file_separator ();
  s += package;
  
  s += CmtSystem::file_separator ();
  s += version;
}

/**
 *   Compute the full real path of a found package.
 *   Takes the structuring style into account
 */
cmt_string Use::get_full_path () const
{
  cmt_string result;

  get_full_path (result);

  return (result);
}

/**
 *   Considering a given path, try and reduce the part of it 
 *  that corresponds to the full path of this package into its
 *  normal form ${<PACKAGE>ROOT}
 *   The argument is modified if the pattern is exactly found.
 */
void Use::reduce_path (cmt_string& s) const
{
  cmt_string pattern;
  get_full_path (pattern);
  pattern += CmtSystem::file_separator ();
  
  cmt_string replacement = "${";
  replacement += prefix;
  replacement += "ROOT}";

  s.replace (pattern, replacement);
}

//----------------------------------------------------------
void Use::fill_includes_macro (cmt_string& buffer) const
{
  if (include_path == "")
    {
      buffer += "$(ppcmd)\"$(";
      buffer += package;
      buffer += "_root)";
      buffer += CmtSystem::file_separator ();
      buffer += "src\" ";
    }
  else if (include_path != "none")
    {
      buffer += "$(ppcmd)\"";
      buffer += include_path;
      buffer += "\" ";
    }
  
  for (int i = 0; i < includes.size (); i++)
    {
      Include& incl = includes[i];
      
      buffer += "$(ppcmd)\"";
      buffer += incl.name;
      buffer += "\" ";
    }
}

//----------------------------------------------------------
void Use::fill_macro (cmt_string& buffer, const cmt_string& suffix) const
{
  buffer += " $(";
  buffer += package;
  buffer += "_";
  buffer += suffix;
  buffer += ") ";
}

/**
 *   This function tries to get the replacement of a Use when it has
 *  been discarded by a better match to version constraints.
 */
Use* Use::get_selected_version ()
{
  static Use::UsePtrVector& Uses = uses ();

    //cout << "get_selected_version for package " << package << endl;

  if (!discarded) return (this);

  for (int i = 0; i < Uses.size (); i++)
    {
      Use* u = Uses[i];
      if (u == 0) continue;
      if (u->discarded) continue;
      if (u->package == package) 
        {
            //cout << "  got a version" << endl;
          return (u);
        }
    }

  return (0);
}

void Use::set_auto_imports (State new_state)
{
  if (Cmt::get_debug ())
    {
      cout << "Use::set_auto_imports>(" << package << ") " 
           << auto_imports << " -> " << new_state << endl;
    }

  if (auto_imports == new_state) return;
  
  State old_state = auto_imports;
  
  auto_imports = new_state;

    // We propagate only when we switch from Off to On

  if ((old_state == Off) && (new_state == On))
    {
      cmt_string s;
      static const cmt_string state_text[] = {"Unspecified", "Off", "On"};

      if (Cmt::get_debug ())
        {
          s = "Use::set_auto_imports>(";
          s += package;
          s += ") ";

          cout << s << endl;
        }

      for (int i = 0; i < sub_uses.size (); i++)
        {
          Use* u = sub_uses[i];
          State state = sub_use_auto_imports[i];
          
          if (Cmt::get_debug ())
            {
              s += " ";
              s += u->package;
              s += "(";
              s += state_text[state];
              s += ")";
            }

          if (state == Unspecified)
            {
              u->set_auto_imports (On);
            }
        }
          
      if (Cmt::get_debug ())
        {
          cout << s << endl;
        }
    }
}

void Use::set_native_version (bool state)
{
  m_has_native_version = state;
}

bool Use::has_native_version () const
{
  return (m_has_native_version);
}

//----------------------------------------------------------
bool Use::get_paths (Use* to, UsePtrVector& list)
{
  bool found = false;
  bool cycle = false;

  static int level = 0;
  static UsePtrVector stack;

  if (level == 0)
    {
      stack.clear ();
    }
  
  // Protect against cycles.
  for (int k = 0; k < stack.size (); k++)
    {
      Use* u = stack[k];
      if (u == this) 
        {
          if (Cmt::get_debug ())
            {
              cout << "Use::get_paths." << level << ">" << package << " cycle " << endl;
            }

          return (false);
        }
    }

  // Save this to the protection stack.
  if (stack.size () <= level)
    {
      stack.push_back (this);
    }
  else
    {
      stack[level] = this;
    }

    // First figure out whether 'to' is used by 'this'.

  if (Cmt::get_debug ())
    {
      cout << "Use::get_paths." << level << ">" << package << " to=" << to->package << " list[" << list.size () << "]" << endl;
    }

  if (this == to)
    {
      found = true;
    }
  else
    {
      for (int n = 0; n < sub_uses.size (); n++)
        {
          Use* use = sub_uses[n];

          if (use == 0) continue;

          if (Cmt::get_debug ())
            {
              cout << "  Use::get_paths." << level << "> try1 sub=" << use->package << endl;
            }

          if (use->discarded)
            {
              Use* u;

              u = use->get_selected_version ();
              if (u == 0) continue;

              use = u;
            }

          cycle = false;
      
            // This use must not be already in the list (protection against cycles)

          for (int m = 0; m < list.size (); m++)
            {
              Use* u = list[m];
              if (u == use)
                {
                  cycle = true;
                  break;
                }
            }

          if (cycle) 
            {
              found = true;
              continue;
            }

          if (Cmt::get_debug ())
            {
              cout << "  Use::get_paths." << level << "> try2 sub=" << use->package << endl;
            }

          level++;
          bool r = use->get_paths (to, list);
          level--;

          if (r)
            {
              found = true;
            }
        }
    }

  if (found)
    {
      cycle = false;

      for (int m = 0; m < list.size (); m++)
        {
          Use* u = list[m];
          if (u == this)
            {
              cycle = true;
              break;
            }
        }

      if (!cycle)
        {
          if (Cmt::get_debug ())
            {
              cout << "Use::get_paths." << level << "> push " << package << endl;
            }
          list.push_back (this);
        }
    }

  return (found);  
}

//----------------------------------------------------------
bool Use::located () const
{
  return (m_located);
}

//----------------------------------------------------------
void Use::show_sub_uses (bool skip_discarded)
{
  int n;
  Use* use;
  static int level = 0;

  if (skip_discarded && discarded) return;

  if (level > 0)
    {
      cout << "# ";
      for (n = 0; n < (level-1); n++) cout << "  ";

      cout << "use " << package << " " << specified_version;

      if (specified_path != "") cout << " " << specified_path;

      if (version_alias != "")
        {
          cout << " | " << version_alias << " " << path_alias;
        }

      if (scope == ScopeUnspecified) cout << " unspecified";
      else if (scope != ScopePublic) cout << " (private)";
      //else cout << " private";

      if (auto_imports == Off) cout << " (no_auto_imports)";

      if (m_has_native_version)
        {
          cmt_string n = package;
          n += "_native_version";

          Symbol* s = Symbol::find (n);
          if (s != 0)
            {
              cmt_string value = s->resolve_macro_value ();
              cout << " (native_version=" << value << ")";
            }
        }

      cout << endl;
    }

  if (selected) return;
  selected = true;

  level++;
  for (n = 0; n < sub_uses.size (); n++)
    {
      use = sub_uses[n];
      if (use == 0) continue;

      ScopeType saved_scope = use->scope;
      State saved_state = use->auto_imports;

      use->scope = sub_use_scopes[n];
      use->auto_imports = sub_use_auto_imports[n];

      use->show_sub_uses (skip_discarded);

      use->scope = saved_scope;
      use->auto_imports = saved_state;
    }
  level--;
}

//----------------------------------------------------------
Use& Use::current ()
{
  static UseVector& AllUses = all_uses ();
  static Use* current_use = 0;

  if ((current_use == 0) || (AllUses.size () == 0))
    {
      Use& use_object = AllUses.add ();
      current_use = &use_object;
    }

  return (*current_use);
}

//----------------------------------------------------------
const Use& Use::const_current ()
{
  const Use& use = Use::current ();

  return (use);
}

//----------------------------------------------------------
Use::UseVector& Use::all_uses ()
{
  static Database& db = Database::instance ();
  static UseVector& AllUses = db.all_uses ();

  return (AllUses);
}

//----------------------------------------------------------
Use::UsePtrVector& Use::uses ()
{
  static Database& db = Database::instance ();
  static UsePtrVector& Uses = db.uses ();

  return (Uses);
}

//----------------------------------------------------------
VersionSelector& VersionSelector::instance ()
{
  static BestFitSelector best_fit;
  static BestFitNoCheckSelector best_fit_no_check;
  static FirstChoiceSelector first_choice;
  static LastChoiceSelector last_choice;
  static KeepAllSelector keep_all;

  switch (Cmt::get_current_strategy ())
    {
    case BestFit:
      return (best_fit);
    case BestFitNoCheck:
      return (best_fit_no_check);
    case FirstChoice:
      return (first_choice);
    case LastChoice:
      return (last_choice);
    case KeepAll:
      return (keep_all);
    default:
      return (best_fit);
    }
}

//----------------------------------------------------------
//
//  Check if the specified version is better than the
//  current one.
//
//----------------------------------------------------------
Use* BestFitSelector::operate (Use* ref_use, Use* new_use)
{
  Use* selected = ref_use;

  int old_v = -1;
  int old_r = -1;
  int old_p = -1;
  cmt_string old_pp;

  int new_v = -1;
  int new_r = -1;
  int new_p = -1;
  cmt_string new_pp;

  int alias_v = -1;
  int alias_r = -1;
  int alias_p = -1;
  cmt_string alias_pp;

  enum { no_alias, new_has_alias, ref_has_alias } has_alias = no_alias;

  CmtSystem::is_version_directory (ref_use->version, old_v, old_r, old_p);
  old_pp = ref_use->path;

  CmtSystem::is_version_directory (new_use->version, new_v, new_r, new_p);
  new_pp = new_use->path;

  if (new_use->version_alias != "")
    {
      has_alias = new_has_alias;
      CmtSystem::is_version_directory (new_use->version_alias, 
                                       alias_v, alias_r, alias_p);
      alias_pp = new_use->path_alias;
    }
  else if (ref_use->version_alias != "")
    {
      has_alias = ref_has_alias;
      CmtSystem::is_version_directory (ref_use->version_alias, 
                                       alias_v, alias_r, alias_p);
      alias_pp = ref_use->path_alias;
    }

  ref_use->undiscard ();
  new_use->undiscard ();

  if (new_v != old_v)
    {
      if (has_alias != no_alias)
        {
          if (has_alias == new_has_alias)
            {
              new_v = alias_v;
              new_r = alias_r;
              new_p = alias_p;
              new_pp = alias_pp;
            }
          else if (has_alias == ref_has_alias)
            {
              old_v = alias_v;
              old_r = alias_r;
              old_p = alias_p;
              old_pp = alias_pp;
            }
        }
    }

  if (new_v != old_v)
    {
      if (!Cmt::get_quiet ())
        cout << "# Required version " << new_use->version <<
          " of package " << ref_use->package <<
          " incompatible with selected version " << ref_use->version <<
          endl;

      CmtError::set (CmtError::version_conflict, "BestFitSelector::operate> ");

      if (ref_use != new_use) new_use->discard ();
    }
  else if (new_r < old_r)
    {
      //
      // we plan to discard new_use, but if it was specified as explicit 
      // and ref_use was wildcarded then new_use will win !!
      //
      // So then we'll have to understand where are the wild
      // cards... If they are on v or r, then we consider them.
      // 
      //


      bool new_is_wildcarded = false;
      bool ref_is_wildcarded = false;

      if (new_use->specified_version.find ("*") != cmt_string::npos)
        {
          int nv = -1;
          int nr = -1;
          int np = -1;

          CmtSystem::is_version_directory (new_use->specified_version, nv, nr, np);
          if ((nv == -1) || (nr == -1)) new_is_wildcarded = true;
        }

      if (ref_use->specified_version.find ("*") != cmt_string::npos)
        {
          int nv = -1;
          int nr = -1;
          int np = -1;

          CmtSystem::is_version_directory (ref_use->specified_version, nv, nr, np);
          if ((nv == -1) || (nr == -1)) new_is_wildcarded = true;
        }

      if (!ref_is_wildcarded && new_is_wildcarded)
        {
          if (ref_use != new_use) ref_use->discard ();
          selected = new_use;
          selected->done = false; // Will read the new requirements
        }
      else
        {
          if (!Cmt::get_quiet ())
            cout << "# keep release " << ref_use->version <<
              " of package " << ref_use->package <<
              " (ignore release " << new_use->version << ")" <<
              endl;

          if (ref_use != new_use) new_use->discard ();
        }
    }
  else if (new_r > old_r)
    {
      if (!Cmt::get_quiet ())
        {
          cout << "# Select release " << new_use->version <<
            " of package " << ref_use->package <<
            " instead of existing " << ref_use->version <<
            endl;
        }

      if (ref_use != new_use) ref_use->discard ();
      selected = new_use;
      selected->done = false; // Will read the new requirements
    }
  else if (new_p > old_p)
    {
      if (!Cmt::get_quiet ())
        {
          cout << "# Select patch " << new_use->version <<
            " of package " << ref_use->package <<
            " instead of existing " << ref_use->version <<
            endl;
        }

      if (ref_use != new_use) ref_use->discard ();
      selected = new_use;
      selected->done = false; // Will read the new requirements
    }
  else if (new_pp != old_pp) // same version-r-p but from different path
    {
      if (ref_use != new_use) ref_use->discard ();
      selected = new_use;
      selected->done = false; // Will read the new requirements
    }

  return (selected);
}

//----------------------------------------------------------
//
//  Check if the specified version is better than the
//  current one. We don't check major ids incompatibilities
//
//----------------------------------------------------------
Use* BestFitNoCheckSelector::operate (Use* ref_use, Use* new_use)
{
  Use* selected = ref_use;

  int old_v = -1;
  int old_r = -1;
  int old_p = -1;
  cmt_string old_pp;

  int new_v = -1;
  int new_r = -1;
  int new_p = -1;
  cmt_string new_pp;

  int alias_v = -1;
  int alias_r = -1;
  int alias_p = -1;
  cmt_string alias_pp;

  enum { no_alias, new_has_alias, ref_has_alias } has_alias = no_alias;

  CmtSystem::is_version_directory (ref_use->version, old_v, old_r, old_p);
  old_pp = ref_use->path;

  CmtSystem::is_version_directory (new_use->version, new_v, new_r, new_p);
  new_pp = new_use->path;

  if (new_use->version_alias != "")
    {
      has_alias = new_has_alias;
      CmtSystem::is_version_directory (new_use->version_alias, 
                                       alias_v, alias_r, alias_p);
      alias_pp = new_use->path_alias;
    }
  else if (ref_use->version_alias != "")
    {
      has_alias = ref_has_alias;
      CmtSystem::is_version_directory (ref_use->version_alias, 
                                       alias_v, alias_r, alias_p);
      alias_pp = ref_use->path_alias;
    }

  ref_use->undiscard ();
  new_use->undiscard ();

  if (new_v != old_v)
    {
      if (has_alias != no_alias)
        {
          if (has_alias == new_has_alias)
            {
              new_v = alias_v;
              new_r = alias_r;
              new_p = alias_p;
              new_pp = alias_pp;
            }
          else if (has_alias == ref_has_alias)
            {
              old_v = alias_v;
              old_r = alias_r;
              old_p = alias_p;
              old_pp = alias_pp;
            }
        }
    }

  if (new_v < old_v)
    {
      if (!Cmt::get_quiet ())
        {
          cout << "# Keep version " << ref_use->version <<
            " of package " << ref_use->package <<
            " (ignore version " << new_use->version << ")" <<
            endl;
        }

      if (ref_use != new_use) new_use->discard ();
    }
  else if (new_v > old_v)
    {
      if (!Cmt::get_quiet ())
        {
          cout << "# Select version " << new_use->version <<
            " of package " << ref_use->package <<
            " instead of existing " << ref_use->version <<
            endl;
        }

      if (ref_use != new_use) ref_use->discard ();
      selected = new_use;
      selected->done = false; // Will read the new requirements
    }
  else if (new_r < old_r)
    {
      if (!Cmt::get_quiet ())
        {
          cout << "# keep release " << ref_use->version <<
            " of package " << ref_use->package <<
            " (ignore release " << new_use->version << ")" <<
            endl;
        }

      if (ref_use != new_use) new_use->discard ();
    }
  else if (new_r > old_r)
    {
      if (!Cmt::get_quiet ())
        {
          cout << "# Select release " << new_use->version <<
            " of package " << ref_use->package <<
            " instead of existing " << ref_use->version <<
            endl;
        }

      if (ref_use != new_use) ref_use->discard ();
      selected = new_use;
      selected->done = false; // Will read the new requirements
    }
  else if (new_p > old_p)
    {
      if (!Cmt::get_quiet ())
        {
          cout << "# Select patch " << new_use->version <<
            " of package " << ref_use->package <<
            " instead of existing " << ref_use->version <<
            endl;
        }

      if (ref_use != new_use) ref_use->discard ();
      selected = new_use;
      selected->done = false; // Will read the new requirements
    }
  else if (new_pp != old_pp) // same version-r-p but from different path
    {
      if (ref_use != new_use) ref_use->discard ();
      selected = new_use;
      selected->done = false; // Will read the new requirements
    }

  return (selected);
}

//----------------------------------------------------------
Use* FirstChoiceSelector::operate (Use* ref_use, Use* new_use)
{
  ref_use->undiscard ();
  new_use->undiscard ();

  new_use->done = false; // Will read the new requirements
  if (ref_use != new_use) new_use->discard ();
  return (ref_use);
}

//----------------------------------------------------------
Use* LastChoiceSelector::operate (Use* ref_use, Use* new_use)
{
  ref_use->undiscard ();
  new_use->undiscard ();

  new_use->done = false; // Will read the new requirements
  if (ref_use != new_use) ref_use->discard ();
  return (new_use);
}

//----------------------------------------------------------
Use* KeepAllSelector::operate (Use* ref_use, Use* new_use)
{
  ref_use->undiscard ();
  new_use->undiscard ();

  new_use->done = false; // Will read the new requirements
  return (new_use);
}