Changeset 656 for CMT/HEAD/source

Timestamp:

Dec 4, 2013, 10:57:15 AM (11 years ago)

Author:

rybkin

Message:

See C.L. 515

Location:

CMT/HEAD/source

Files:

• cmt.h (modified) (5 diffs)
• cmt_commands.cxx (modified) (5 diffs)
• cmt_commands.h (modified) (1 diff)
• cmt_error.cxx (modified) (2 diffs)
• cmt_parser.cxx (modified) (34 diffs)
• cmt_symbol.cxx (modified) (55 diffs)
• cmt_symbol.h (modified) (5 diffs)
• cmt_use.cxx (modified) (3 diffs)

CMT/HEAD/source/cmt.h

@@ -35 +35 @@
   cmt_string m_cmt_version;
   bool m_use_cmt;
+  bool m_use_projects;
   
   cmt_string m_current_dir;
@@ -74 +75 @@
 
   bool m_autoconfigure_cmtpath;
+
+  bool m_env_access;
+  PrintMode m_print_mode;
+  bool m_path_strip;
 
 private:
@@ -271 +276 @@
   static int parser (const cmt_string& command_line);
   static int parser (int argc, char* argv[]);
-  static void print (PrintMode mode);
+  static void print (PrintMode mode, ostream& out = cout);
+  //static void print (PrintMode mode);
   static void print_clean (PrintMode mode);
-  static void print_context (Use& use, PrintMode mode, const cmt_string& tag);
+  static void print_context (Use& use, PrintMode mode, const cmt_string& tag, ostream& out = cout);
+  //static void print_context (Use& use, PrintMode mode, const cmt_string& tag);
   static void print_macros (PrintMode mode, const cmt_string& pattern = "",
                             ostream& out = cout);
@@ -302 +309 @@
                                 cmt_string& result);
 
+  static inline const bool& get_env_access ();
+  static inline void set_env_access (const bool& access);
+  static inline const PrintMode& get_print_mode ();
+  static inline void set_print_mode (const PrintMode& mode);
+  static inline const bool& get_path_strip ();
+
 private:
   static CmtContext& m_cmt_context;
@@ -425 +438 @@
 }
 
+inline const bool& Cmt::get_env_access ()
+{
+  return m_cmt_context.m_env_access;
+}
+
+inline void Cmt::set_env_access (const bool& access)
+{
+  m_cmt_context.m_env_access = access;
+}
+
+inline const PrintMode& Cmt::get_print_mode ()
+{
+  return m_cmt_context.m_print_mode;
+}
+
+inline void Cmt::set_print_mode (const PrintMode& mode)
+{
+  m_cmt_context.m_print_mode = mode;
+}
+
+inline const bool& Cmt::get_path_strip ()
+{
+  return m_cmt_context.m_path_strip;
+}
 //----------------------------------------------------------
 

CMT/HEAD/source/cmt_commands.cxx

@@ -256 +256 @@
   pv.push_back (&ArgParser::option_no_cleanup); i++;
 
+  parsers.add ("-no_path_s", i);
+  parsers.add ("-no_path_st", i);
+  parsers.add ("-no_path_str", i);
+  parsers.add ("-no_path_stri", i);
+  parsers.add ("-no_path_strip", i);
+  pv.push_back (&ArgParser::option_no_path_strip); i++;
+
   parsers.add ("-pac", i);
   parsers.add ("-pack", i);
@@ -263 +270 @@
   parsers.add ("-path", i);
   pv.push_back (&ArgParser::option_path); i++;
+
+  parsers.add ("-path_s", i);
+  parsers.add ("-path_st", i);
+  parsers.add ("-path_str", i);
+  parsers.add ("-path_stri", i);
+  parsers.add ("-path_strip", i);
+  pv.push_back (&ArgParser::option_path_strip); i++;
 
   parsers.add ("-pr", i);
@@ -346 +360 @@
   parsers.add ("-without_cmt", i);
   pv.push_back (&ArgParser::option_without_cmt); i++;
+
+  parsers.add ("-with_p", i);
+  parsers.add ("-with_pr", i);
+  parsers.add ("-with_pro", i);
+  parsers.add ("-with_proj", i);
+  parsers.add ("-with_proje", i);
+  parsers.add ("-with_projec", i);
+  parsers.add ("-with_project", i);
+  parsers.add ("-with_projects", i);
+  pv.push_back (&ArgParser::option_with_projects); i++;
+
+  parsers.add ("-without_p", i);
+  parsers.add ("-without_pr", i);
+  parsers.add ("-without_pro", i);
+  parsers.add ("-without_proj", i);
+  parsers.add ("-without_proje", i);
+  parsers.add ("-without_projec", i);
+  parsers.add ("-without_project", i);
+  parsers.add ("-without_projects", i);
+  pv.push_back (&ArgParser::option_without_projects); i++;
 
   parsers.add ("-warn", i);
@@ -2022 +2056 @@
 }
 
+void ArgParser::option_no_path_strip ()
+{
+  cmt.m_path_strip = false;
+  if (!Cmt::add_cmt_flag ("-no_path_strip"))
+    CmtMessage::error ("Cannot add flag `-no_path_strip'");
+}
+
+void ArgParser::option_path_strip ()
+{
+  cmt.m_path_strip = true;
+  if (!Cmt::add_cmt_flag ("-path_strip"))
+    CmtMessage::error ("Cannot add flag `-path_strip'");
+}
+
 void ArgParser::option_tag ()
 {
@@ -2323 +2371 @@
   if (!Cmt::add_cmt_flag ("-without_cmt"))
     CmtMessage::error ("Cannot add flag `-without_cmt'");
+}
+
+void ArgParser::option_with_projects ()
+{
+  cmt.m_use_projects = true;
+  if (!Cmt::add_cmt_flag ("-with_projects"))
+    CmtMessage::error ("Cannot add flag `-with_projects'");
+}
+
+void ArgParser::option_without_projects ()
+{
+  cmt.m_use_projects = false;
+  if (!Cmt::add_cmt_flag ("-without_projects"))
+    CmtMessage::error ("Cannot add flag `-without_projects'");
 }
 

CMT/HEAD/source/cmt_commands.h

@@ -83 +83 @@
   void option_with_cmt ();
   void option_without_cmt ();
+  void option_with_projects ();
+  void option_without_projects ();
   void option_with_version_directory ();
   void option_without_version_directory ();
   void option_no_cleanup ();
+  void option_no_path_strip ();
+  void option_path_strip ();
   void option_private ();
   void option_public ();

CMT/HEAD/source/cmt_error.cxx

@@ -18 +18 @@
   {
     error_names.add() = "ok";
-    error_names.add() = "Warning";
+    error_names.add() = "warning";
     error_names.add() = "symbol not found";
     error_names.add() = "pattern not found";
@@ -159 +159 @@
 
   result = get_error_name (e.get_code ());
-  result += " : ";
+  result += ": ";
   result += e.get_text ();
 

CMT/HEAD/source/cmt_parser.cxx

@@ -68 +68 @@
   m_cmt_version    = "";
   m_use_cmt        = true;
+  m_use_projects   = true;
 
   m_current_dir     = "";
@@ -109 +110 @@
 
   m_autoconfigure_cmtpath = false;
+
+  m_env_access = true;
+  m_print_mode = Csh;
+  m_path_strip = false;
 }
 //----------------------------------------------------------
@@ -627 +632 @@
   Me.m_autoconfigure_cmtpath = true;
   configure_cmt_path (0);
-  Me.m_autoconfigure_cmtpath = false;
+  //  Me.m_autoconfigure_cmtpath = false;
 
   Me.m_quiet = save_quiet;
@@ -710 +715 @@
 {
   if (!Me.m_autoconfigure_cmtpath) return;
+
+  if (!m_cmt_context.m_use_projects) return;
 
   cmt_string s;
@@ -2115 +2122 @@
           ok = selected;
         }
+      else if (up)
+        cmtpath = up->get_cmtpath ();
 
       if (ok)
@@ -3170 +3179 @@
     }
 
-  Symbol::check_all_paths ();
+  if (action_setup != get_action () ||
+      Requirements == ap.mode)
+    // PathBuilder::filter_path_value is called
+    // for each path in Symbol::print
+    Symbol::check_all_paths ();
 
   env = CmtSystem::getenv ("CMTSITE");
@@ -4569 +4582 @@
       break;
     case Requirements :
+      /*
       CmtSystem::cmt_string_vector flags;
       get_cmt_flags (flags);
       cout << "\n# CMTFLAGS: -without_cmt";
+      cout << " -without_projects" ;
       for (int i = 0; i < flags.size (); i++)
         {
@@ -4578 +4593 @@
           else if (flags[i] == "-with_cmt")
             cout << " -without_cmt";
+          else if (flags[i] == "-without_projects")
+            cout << " -with_projects";
+          else if (flags[i] == "-with_projects")
+            cout << " -without_projects";
           else
             cout << " " << flags[i]; 
         }
       cout << endl;
+      */
       break;
-    }
-  print (ap.mode);
+    default:
+      break;
+    }
+
+  ostringstream os;
+  ostringstream oh;
+  bool reset (false);
+  CmtSystem::cmt_string_vector flags;
+  cmt_string path_strip_flag;
+  bool path_strip (false);
+
+  bool strip_saved (get_path_strip ());
+  bool access_saved (Cmt::get_env_access ());
+
+  switch (ap.mode)
+    {
+    case Requirements :
+
+      get_cmt_flags (flags);
+      for (int i = 0; i < flags.size (); i++)
+        {
+          if (flags[i] == "-no_path_strip")
+            path_strip_flag = "-no_path_strip";
+          else if (flags[i] == "-path_strip")
+            path_strip_flag = "-path_strip";
+        }
+      if (path_strip_flag != "-no_path_strip" &&
+          !get_path_strip ())
+        reset = Symbol::set_path_strip (true);
+
+      if (get_path_strip () || reset)
+        path_strip = true;
+      else
+        path_strip = false;
+
+      Cmt::set_env_access (false);
+
+      print (ap.mode, os);
+
+      if (CmtError::get_last_error_code () == CmtError::warning &&
+          (get_path_strip () || reset))
+        {
+          reset = Symbol::set_path_strip (false);
+          if (reset)
+            {
+              path_strip = false;
+
+              CmtError::print ();
+              CmtError::clear ();
+
+              if (Cmt::get_debug ())
+                {
+                  cerr << "|Cmt::do_setup> Failure with:\n" << os.str ()
+                       << "|Cmt::do_setup> Trying again." << endl;
+                }
+
+              // Try again
+              os.str ("");
+              print (ap.mode, os);
+            }
+        }
+
+      if (reset) Symbol::set_path_strip (strip_saved);
+      Cmt::set_env_access (access_saved);
+
+      //get_cmt_flags (flags);
+      oh << "\n# CMTFLAGS:"
+        " -without_cmt"
+        " -without_projects"
+        //" -path_strip"
+        ;
+      for (int i = 0; i < flags.size (); i++)
+        {
+          if (flags[i] == "-without_cmt")
+            oh << " -with_cmt";
+          else if (flags[i] == "-with_cmt")
+            oh << " -without_cmt";
+          else if (flags[i] == "-without_projects")
+            oh << " -with_projects";
+          else if (flags[i] == "-with_projects")
+            oh << " -without_projects";
+          /*
+          else if (flags[i] == "-no_path_strip")
+            oh << " -path_strip";
+          else if (flags[i] == "-path_strip")
+            oh << " -no_path_strip";
+          */
+          else if (flags[i] == "-no_path_strip" ||
+                   flags[i] == "-path_strip")
+            continue;
+          else
+            oh << " " << flags[i]; 
+        }
+      //if (reset) oh << " -path_strip";
+      if (path_strip)
+        oh << " -no_path_strip";
+      else
+        oh << " -path_strip";
+      oh << endl;
+
+      cout << oh.str ();
+      cout << os.str ();
+
+      break;
+
+    default:
+
+      print (ap.mode);
+
+      break;
+    }
+
   switch (ap.mode)
     {
@@ -5680 +5810 @@
 void Cmt::guess_current_project ()
 {
+  if (!m_cmt_context.m_use_projects) return;
+
   Log;
 
@@ -5782 +5914 @@
   //  Use& use = Use::current();
 
+  bool autoconfigure_cmtpath_saved (Me.m_autoconfigure_cmtpath);
+  Me.m_autoconfigure_cmtpath = false;
   bool save_quiet = Me.m_quiet;
   Me.m_quiet = true;
@@ -5788 +5922 @@
 
   Me.m_quiet = save_quiet;
-
-  Me.m_autoconfigure_cmtpath = true;
+  Me.m_autoconfigure_cmtpath = autoconfigure_cmtpath_saved;
+  //  Me.m_autoconfigure_cmtpath = true;
 
   //  CmtSystem::cd (Me.m_current_dir);
@@ -6797 +6931 @@
 
   parse_arguments (ap);
+  // Copy ap.mode into cmt_context member/instance
+  set_print_mode (ap.mode);
 
   //  configure ();
@@ -7741 +7877 @@
  * joined with semi-colons to form one shell command.
  */
-void Cmt::print (PrintMode mode)
+void Cmt::print (PrintMode mode, ostream& out)
 {
   Use::UsePtrVector& Uses = Use::get_ordered_uses ();
@@ -7805 +7941 @@
           if (tag != 0)
             {
-              tag->show (true, cout, "apply_tag ");
+              tag->show (true, out, "apply_tag ");
             }
         }
@@ -7826 +7962 @@
           if (use.m_hidden) continue;
           
-          print_context (use, mode, tag);
-        }
-    }
-
-  print_context (Use::current (), mode, tag);
+          print_context (use, mode, tag, out);
+        }
+    }
+
+  print_context (Use::current (), mode, tag, out);
 
   if (Me.m_debug)
@@ -7837 +7973 @@
     }
 
-  Symbol::all_print (mode);
+  Symbol::all_print (mode, out);
   // Script::all_print (mode);
 
@@ -7850 +7986 @@
       break;
     default :
-  cout << endl;
+      out << endl;
       break;
     }
@@ -7956 +8092 @@
 
 //----------------------------------------------------------
-void Cmt::print_context (Use& use, PrintMode mode, const cmt_string& tag)
+void Cmt::print_context (Use& use, PrintMode mode, const cmt_string& tag, ostream& out)
 {
   if (use.get_package_name () == "cmt_standalone") return;
@@ -7988 +8124 @@
       if (do_root)
         {
-          cout << "setenv " << prefix << "ROOT \"" <<
+          out << "setenv " << prefix << "ROOT \"" <<
             use.get_full_path () << "\"" << endl;
         }
@@ -7994 +8130 @@
       if (use.get_package_name () == "CMT")
         {
-          cout << "setenv CMTCONFIG " << system << endl;
+          out << "setenv CMTCONFIG " << system << endl;
         }
       else
@@ -8000 +8136 @@
           if (do_config)
             {
-              cout << "setenv " << prefix << "CONFIG \"" << tag << "\"" << endl;
+              out << "setenv " << prefix << "CONFIG \"" << tag << "\"" << endl;
             }
         }
@@ -8008 +8144 @@
       if (do_root)
         {
-          cout << prefix << "ROOT=\"" <<
+          out << prefix << "ROOT=\"" <<
             use.get_full_path () << "\"; export " <<
             prefix << "ROOT" << endl;
@@ -8015 +8151 @@
       if (use.get_package_name () == "CMT")
         {
-          cout << "CMTCONFIG=" << system << "; export CMTCONFIG" << endl;
+          out << "CMTCONFIG=" << system << "; export CMTCONFIG" << endl;
         }
       else
@@ -8021 +8157 @@
           if (do_config)
             {
-              cout << prefix << "CONFIG=\"" <<
+              out << prefix << "CONFIG=\"" <<
                 tag << "\"; export " <<
                 prefix << "CONFIG" << endl;
@@ -8031 +8167 @@
       if (do_root)
         {
-          cout << "set " << prefix << "ROOT=" <<
+          out << "set " << prefix << "ROOT=" <<
             CmtSystem::quote (use.get_full_path (), " \t") << endl;
         }
@@ -8037 +8173 @@
       if (use.get_package_name () == "CMT")
         {
-          cout << "set CMTCONFIG=" << system << endl;
+          out << "set CMTCONFIG=" << system << endl;
         }
       else
@@ -8043 +8179 @@
           if (do_config)
             {
-              cout << "set " << prefix << "CONFIG=" << CmtSystem::quote (tag, " \t") << endl;
+              out << "set " << prefix << "CONFIG=" << CmtSystem::quote (tag, " \t") << endl;
             }
         }
@@ -8051 +8187 @@
       if (do_root)
         {
-          cout << "<variable><name>" << prefix << "ROOT</name>"
-               << "<value>" << use.get_full_path () << "</value></variable>";
+          out << "<variable><name>" << prefix << "ROOT</name>"
+              << "<value>" << use.get_full_path () << "</value></variable>";
         }
 
       if (use.get_package_name () == "CMT")
         {
-          cout << "<variable><name>CMTCONFIG</name>"
-               << "<value>" << system << "</value></variable>";
+          out << "<variable><name>CMTCONFIG</name>"
+              << "<value>" << system << "</value></variable>";
         }
       else
@@ -8064 +8200 @@
           if (do_config)
             {
-              cout << "<variable><name>" << prefix << "CONFIG</name>"
-                   << "<value>" << tag << "</value></variable>";
+              out << "<variable><name>" << prefix << "CONFIG</name>"
+                  << "<value>" << tag << "</value></variable>";
             }
         }
@@ -8074 +8210 @@
           use.get_package_name () != "CMT")
         {
-          cout << "set " << use.prefix << "ROOT " <<
+          out << "set " << use.prefix << "ROOT " <<
             CmtSystem::quote (use.get_full_path (), " \t") << endl;
 
@@ -8093 +8229 @@
       if (use.get_package_name () == "CMT")
         {
-          cout << "set CMTCONFIG " << system << endl;
+          out << "set CMTCONFIG " << system << endl;
         }
       else
@@ -8099 +8235 @@
           if (do_config)
             {
-              cout << "set " << use.prefix << "CONFIG " << CmtSystem::quote (tag, " \t") << endl;
+              out << "set " << use.prefix << "CONFIG " << CmtSystem::quote (tag, " \t") << endl;
+              
+              cmt_string name (use.prefix + "CONFIG");
+              Symbol* symbol = Symbol::find (name);
+              if (symbol != 0) 
+                {
+                  symbol->printed = true;
+                }
+              if (symbol == 0 || symbol->type != Symbol::SymbolMacro)
+                {
+                  CmtMessage::warning
+                    (CmtError::get_error_name (CmtError::symbol_not_found)
+                     + ": macro " + name);
+                }
             }
         }
@@ -10333 +10482 @@
           if (0 == Ordered.size ())
             {
-              CmtError::set(CmtError::configuration_error,
-                            "No ordered project: " + use->get_info ());
-              return;
+              if (m_cmt_context.m_use_projects)
+                {
+                  CmtError::set(CmtError::configuration_error,
+                                "No such ordered project: " + use->get_info ());
+                  return;
+                }
+              else
+                {
+                  use->change_path (path);
+                }
             }
-          if (name == CmtSystem::get_home_package ())
-            use->change_path (path, Ordered[Ordered.size () - 1]);
-          else if (name == CmtSystem::get_user_context_package ())
-            use->change_path (path, Ordered[0]);
+          else
+            {
+              if (name == CmtSystem::get_home_package ())
+                use->change_path (path, Ordered[Ordered.size () - 1]);
+              else if (name == CmtSystem::get_user_context_package ())
+                use->change_path (path, Ordered[0]);
+            }
         }
       else
@@ -10370 +10529 @@
     {
       const cmt_string& s = v[i];
-      if (s == "") continue;
+      if (s.size () == 0) continue;
 
       if (result.size () != 0) result += separator;
       //if (i > 0) result += separator;
-      result += v[i];
+      result += s;
     }
 }

CMT/HEAD/source/cmt_symbol.cxx

@@ -15 +15 @@
 #include "cmt_database.h"
 #include "cmt_log.h"
+#include "cmt_error.h"
 
 // Global inhibitor of any display
@@ -42 +43 @@
   const cmt_string clean (const Symbol& symbol,
                           const cmt_string& tag_name = "");
+
+  void filter_path_value (const Symbol& symbol,
+                          cmt_string& value,
+                          const cmt_string& tag_name = "") const;
+  void filter_path_value (const Symbol& symbol,
+                          CmtSystem::cmt_string_vector& value,
+                          const cmt_string& tag_name = "") const;
+  inline const bool& get_path_strip () const;
+  inline void set_path_strip (const bool& path_strip);
+
+  PathBuilder ();
+  PathBuilder (bool path_strip);
+
+private:
+  bool m_path_strip;
 };
 //-------------------------------------------------------------
@@ -248 +264 @@
 }
 
+//
+// Global cache
+//
+namespace
+{
+  cmt_vmap <cmt_string, cmt_string> cmdoutputs;
+}
 /**
 
@@ -285 +308 @@
   int start = 0;
 
+  //  static cmt_vmap <cmt_string, cmt_string> cmdoutputs;
+
   for (;;)
     {
@@ -337 +362 @@
             // to be applied. The output of the command is then substituted
 
+          Symbol::all_set ();
+
           cmt_string result;
-
-          Symbol::all_set ();
-          CmtSystem::execute (command, result);
-          
-          /*
-          int pos;
-          pos = result.find ('\n');
-          if (pos != cmt_string::npos) result.erase (pos);
-          pos = result.find ('\r');
-          if (pos != cmt_string::npos) result.erase (pos);
-          */          
-          process_cmd_output (result);
-
-          if (Cmt::get_debug ())
-            {
-              cout << "resolve_value: Executing [" << command << "] to expand a symbol value =>[" 
-                   << result << "]" << endl;
-            }
-          
+          const cmt_string * presult;
+          if (!(presult = cmdoutputs.find (command)))
+            {
+              CmtSystem::execute (command, result);
+              
+              process_cmd_output (result);
+              cmdoutputs.add (command, result);
+              if (Cmt::get_debug ())
+                {
+                  cout << "resolve_value: Executing [" << command << "] to expand a symbol value =>[" 
+                       << result << "]" << endl;
+                }
+            }
+          else
+            {
+              result = *presult;
+              if (Cmt::get_debug ())
+                {
+                  cout << "resolve_value: Found in cache [" << command << "] to expand a symbol value =>[" 
+                       << result << "]" << endl;
+                }
+            }
+
           text.replace_all (pattern, result);
 
@@ -378 +409 @@
           else
             {
+              if (Cmt::get_env_access () ||
+                  Symbol::std_env_vars ().has (symbol_name))
+                {
                 // Symbol not found. Look for env. variable
               cmt_string value = CmtSystem::getenv (symbol_name);
-              
                 // When the env. variable is not defined, the replacement is empty
                 // thus all $(xxx) ${xxx} %xxx% patterns are always filtered away.
               text.replace_all (pattern, value);
               
+                  if (Cmt::get_debug ())
+                    {
+                      cerr << "resolve_value: getenv (" << symbol_name
+                           << ") => " << value << endl;
+                    }
                 // The substitution will restart from the same place
                 // allowing for recursive replacements
               start = begin;
+                }
+              else
+                {
+                  if (Cmt::get_debug ())
+                    {
+                      cerr << "resolve_value: getenv (" << symbol_name
+                           << ") denied" << endl;
+                    }
+                  CmtError::set (CmtError::warning,
+                                 "getenv (" + symbol_name + ") denied");
+                  return;
+                }
             }
         }
@@ -484 +534 @@
             // to be applied. The output of the command is substituted
 
+          Symbol::all_set ();
+
           cmt_string result;
-
-          Symbol::all_set ();
-          CmtSystem::execute (command, result);
-          
-          /*
-          int pos;
-          pos = result.find ('\n');
-          if (pos != cmt_string::npos) result.erase (pos);
-          pos = result.find ('\r');
-          if (pos != cmt_string::npos) result.erase (pos);
-          */
-          process_cmd_output (result);
-          
-          if (Cmt::get_debug ())
-            {
-              cout << "   Executing [" << command << "] to expand a macro value =>[" 
-                   << result << "]" << endl;
-            }
-          
+          const cmt_string * presult;
+          if (!(presult = cmdoutputs.find (command)))
+            {
+              CmtSystem::execute (command, result);
+              
+              process_cmd_output (result);
+              cmdoutputs.add (command, result);
+              if (Cmt::get_debug ())
+                {
+                  cout << "resolve_value_for_macros: Executing [" << command << "] to expand a symbol value =>[" 
+                       << result << "]" << endl;
+                }
+            }
+          else
+            {
+              result = *presult;
+              if (Cmt::get_debug ())
+                {
+                  cout << "resolve_value_for_macros: Found in cache [" << command << "] to expand a symbol value =>[" 
+                       << result << "]" << endl;
+                }
+            }
+
           text.replace_all (pattern, result);
 
@@ -621 +677 @@
             // to be applied. The output of the command is substituted
 
+          Symbol::all_set ();
+
           cmt_string result;
-
-          Symbol::all_set ();
-          CmtSystem::execute (command, result);
-          
-          /*
-          int pos;
-          pos = result.find ('\n');
-          if (pos != cmt_string::npos) result.erase (pos);
-          pos = result.find ('\r');
-          if (pos != cmt_string::npos) result.erase (pos);
-          */          
-          process_cmd_output (result);
-          
-          if (Cmt::get_debug ())
-            {
-              cout << "   Executing [" << command << "] to expand a macro value =>[" 
-                   << result << "]" << endl;
-            }
-          
+          const cmt_string * presult;
+          if (!(presult = cmdoutputs.find (command)))
+            {
+              CmtSystem::execute (command, result);
+              
+              process_cmd_output (result);
+              cmdoutputs.add (command, result);
+              if (Cmt::get_debug ())
+                {
+                  cout << "suppress_OS_delimiters: Executing [" << command << "] to expand a symbol value =>[" 
+                       << result << "]" << endl;
+                }
+            }
+          else
+            {
+              result = *presult;
+              if (Cmt::get_debug ())
+                {
+                  cout << "suppress_OS_delimiters: Found in cache [" << command << "] to expand a symbol value =>[" 
+                       << result << "]" << endl;
+                }
+            }
+
           text.replace_all (pattern, result);
 
@@ -692 +754 @@
 {
   static SetBuilder Set;
-  static PathBuilder Path;
+  static PathBuilder Path (Cmt::get_path_strip ());
+  //static PathBuilder Path;
   static MacroBuilder Macro;
   static ScriptBuilder Script;
@@ -913 +976 @@
 }
 
+//-------------------------------------------------------------
+Symbol::SymbolMap& Symbol::std_env_vars ()
+{
+  static SymbolMap env_vars;
+  static Symbol std_sym;
+  static bool initialized (false);
+  if (!initialized)
+    {
+      env_vars.add ("SITEROOT", std_sym);
+      env_vars.add ("CMTCONFIG", std_sym);
+      env_vars.add ("CMTBIN", std_sym);
+      env_vars.add ("CMTPATH", std_sym);
+      env_vars.add ("CMTHEADVERSION", std_sym);
+      env_vars.add ("CMTPROJECTPATH", std_sym);
+      env_vars.add ("CMTSITE", std_sym);
+      env_vars.add ("CMTEXTRATAGS", std_sym);
+      env_vars.add ("CMTSTRUCTURINGSTYLE", std_sym);
+      env_vars.add ("CMTHOME", std_sym);
+      env_vars.add ("CMTUSERCONTEXT", std_sym);
+      initialized = true;
+    }
+  return env_vars;
+}
+
 /**
    Filter out faulty items of a path-like symbol value
@@ -1168 +1255 @@
 
 //-------------------------------------------------------------
+bool Symbol::set_path_strip (const bool& path_strip)
+{
+  // searching for a path symbol
+  for (int number = 0; number < Symbol::symbol_number (); number++)
+    {
+      Symbol& symbol = Symbol::symbol (number);
+      
+      if (symbol.type == Symbol::SymbolPath)
+        {
+          static_cast<PathBuilder*> (symbol.builder)->set_path_strip (path_strip);
+          return true;
+        }
+    }
+
+  return false;
+}
+
+//-------------------------------------------------------------
 int Symbol::is_selected (const cmt_string& name)
 {
@@ -1422 +1527 @@
   cmt_string value;
 
+  if (Cmt::get_env_access ())
+    {
   for (number = 0; number < Symbol::symbol_number (); number++)
     {
@@ -1433 +1540 @@
           Symbol::expand (value);
 
+          if (Cmt::get_debug ())
+            {
+              cerr << "Symbol::all_set (set)> " << symbol.name << " = " << value << endl;
+            }
+
           CmtSystem::putenv (symbol.name, value);
         }
+    }
     }
 
@@ -1500 +1613 @@
   }
 
+  static PathBuilder* pb (0);
+
+  if (Cmt::get_env_access ())
+    {
   for (number = 0; number < Symbol::symbol_number (); number++)
     {
@@ -1510 +1627 @@
         {
           Symbol::expand (value);
-          filter_path_value (symbol.name, value);
+          if (!pb)
+            pb = static_cast<PathBuilder*> (symbol.builder);
+          pb->filter_path_value (symbol, value);
+          //filter_path_value (symbol.name, value);
 
 #ifdef WIN32
@@ -1518 +1638 @@
           if (Cmt::get_debug ())
             {
-              cerr << "Symbol::all_set-2> " << symbol.name << " = " << value << endl;
+              cerr << "Symbol::all_set (path)> " << symbol.name << " = " << value << endl;
             }
 
@@ -1524 +1644 @@
         }
     }
+    }
 
   running = false;
@@ -1529 +1650 @@
 
 //-------------------------------------------------------------
-void Symbol::all_print (PrintMode mode)
+void Symbol::all_print (PrintMode mode, ostream& out)
+//void Symbol::all_print (PrintMode mode)
 {
   static SymbolVector& Symbols = symbols ();
@@ -1550 +1672 @@
               (symbol.type == SymbolMacro))
             {
-              if (symbol.print_macro (mode))
+              if (symbol.print_macro (mode, out))
                 {
                   //              cout << endl;
@@ -1567 +1689 @@
               (symbol.type == SymbolPath))
             {
-              if (symbol.print (mode))
+              if (symbol.print (mode, out))
                 {
                   if (mode == Bat)
                     {
-                      cout << endl;
+                      out << endl;
                     }
                   else if (mode == Xml)
@@ -1579 +1701 @@
                   else
                     {
-                      cout << endl;
+                      out << endl;
                     }
                 }
@@ -1593 +1715 @@
   static SymbolVector& Symbols = symbols ();
 
+  static PathBuilder* pb (0);
+
   int number;
 
@@ -1608 +1732 @@
           expand (temp);
 
-          Symbol::filter_path_value (symbol.name, temp);
+          if (!pb)
+            pb = static_cast<PathBuilder*> (symbol.builder);
+          pb->filter_path_value (symbol, temp);
+          //Symbol::filter_path_value (symbol.name, temp);
         }
     }
@@ -1762 +1889 @@
 
 //-------------------------------------------------------------
-int Symbol::print (PrintMode mode)
-{
+int Symbol::print (PrintMode mode, ostream& out)
+{
+  static PathBuilder* pb (0);
+
   int result = 0;
 
@@ -1772 +1901 @@
     {
       expand (temp);
-      Symbol::filter_path_value (name, temp);
+      //Symbol::filter_path_value (name, temp);
+      if (!pb)
+        pb = static_cast<PathBuilder*> (builder);
+      pb->filter_path_value (*this, temp);
     }
 
@@ -1785 +1917 @@
           {
             case Csh :
-              if (empty) cout << "unsetenv " << _name;
-              else cout << "setenv " << _name << " \"" << temp << "\"";
-              //else cout << "setenv " << name << " " << CmtSystem::quote (temp, " \t");
+              if (empty) out << "unsetenv " << _name;
+              else out << "setenv " << _name << " \"" << temp << "\"";
+              //else out << "setenv " << name << " " << CmtSystem::quote (temp, " \t");
 
               result = 1;
               break;
             case Sh :
-              if (empty) cout << "[ -z ${" << _name << "+CMT} ] || unset " << _name;
-              //              if (empty) cout << "unset " << _name;
-              else cout << _name << "=\"" << temp << "\"; export " << _name;
-              //else cout << name << "=" << CmtSystem::quote (temp, " \t") << "; export " << name;
+              if (empty) out << "[ -z ${" << _name << "+CMT} ] || unset " << _name;
+              //              if (empty) out << "unset " << _name;
+              else out << _name << "=\"" << temp << "\"; export " << _name;
+              //else out << name << "=" << CmtSystem::quote (temp, " \t") << "; export " << name;
 
               result = 1;
@@ -1801 +1933 @@
             case Bat :
               temp.replace_all ("/", "\\");
-              cout << "set " << _name << "=" << CmtSystem::quote (temp, " \t");
-              //cout << "set " << name << "=" << temp;
+              out << "set " << _name << "=" << CmtSystem::quote (temp, " \t");
+              //out << "set " << name << "=" << temp;
               result = 1;
               break;
             case Xml :
-              cout << "<variable><name>" << _name << "</name>"
+              out << "<variable><name>" << _name << "</name>"
                    << "<value>" << temp << "</value></variable>";
               result = 1;
@@ -1816 +1948 @@
           {
             case Csh :
-              cout << "alias " << name <<
+              out << "alias " << name <<
                 " \"" << temp << "\"";
               //CmtSystem::quote (temp, " \t");
@@ -1822 +1954 @@
               break;
             case Sh :
-              cout << "alias " << name <<
+              out << "alias " << name <<
                 "=\"" << temp << "\"";
               //"=" << CmtSystem::quote (temp, " \t");
@@ -1828 +1960 @@
               break;
             case Bat :
-              cout << "set " << name <<
+              out << "set " << name <<
                 "=" << CmtSystem::quote (temp, " \t");
               //"=" << temp;
@@ -1834 +1966 @@
               break;
             case Xml :
-              cout << "<alias><name>" << name << "</name>"
+              out << "<alias><name>" << name << "</name>"
                    << "<value>" << temp << "</value></alias>";
               result = 1;
@@ -1852 +1984 @@
               {
                 case Csh :
-                  cout << "if ( -f " << CmtSystem::quote (name, " \t") << ".csh ) then" << endl;
-                  cout << "  source " << CmtSystem::quote (name, " \t") << ".csh" << endl;
-                  cout <<
+                  out << "if ( -f " << CmtSystem::quote (name, " \t") << ".csh ) then" << endl;
+                  out << "  source " << CmtSystem::quote (name, " \t") << ".csh" << endl;
+                  out <<
                     "if ( $status != 0 ) then\n"
                     "    set cmtsetupstatus=1\n"
                     "endif\n";
-                  cout << "endif" << endl;
+                  out << "endif" << endl;
                   result = 1;
                   break;
                 case Sh :
-                  cout << "if test -f " << CmtSystem::quote (name, " \t") << ".sh; then" << endl;
-                  cout << "  . " << CmtSystem::quote (name, " \t") << ".sh" << endl;
-                  cout <<
+                  out << "if test -f " << CmtSystem::quote (name, " \t") << ".sh; then" << endl;
+                  out << "  . " << CmtSystem::quote (name, " \t") << ".sh" << endl;
+                  out <<
                     "if test $? != 0; then\n"
                     "    cmtsetupstatus=1\n"
                     "fi\n";
-                  cout << "fi" << endl;
+                  out << "fi" << endl;
                   result = 1;
                   break;
                 case Bat :
-                  cout << "call " << CmtSystem::quote (name, " \t");
+                  out << "call " << CmtSystem::quote (name, " \t");
                   result = 1;
                   break;
                 case Xml :
-                  cout << "<script>" << name << "</script>";
+                  out << "<script>" << name << "</script>";
                   result = 1;
                   break;
@@ -2124 +2256 @@
       SymbolValue& value = value_list.values[selected];
 
-      result += value_list.print (symbol, value, first_definition);
+      result += value_list.print (symbol, value, first_definition, out);
     }
 
@@ -2202 +2334 @@
             else if (temp == "")
               {
-                temp = CmtSystem::getenv (symbol.name);
+                if (Cmt::get_env_access () ||
+                    Symbol::std_env_vars ().has (symbol.name))
+                  {
+                    temp = CmtSystem::getenv (symbol.name);
+                    if (Cmt::get_debug ())
+                      {
+                        cerr << "SetBuilder::build> getenv (" << symbol.name
+                             << ") => " << temp << endl;
+                      }
+                  }
+                else
+                  {
+                    if (Cmt::get_debug ())
+                      {
+                        cerr << "SetBuilder::build> getenv (" << symbol.name
+                             << ") denied" << endl;
+                      }
+                    CmtError::set (CmtError::warning,
+                                   "getenv (" + symbol.name + ") denied");
+                    return "";
+                  }
               }
 
@@ -2263 +2415 @@
 }
 
+namespace
+{
+int find_path_entry (const CmtSystem::cmt_string_vector& items, const cmt_string& value)
+{
+  //  if (value.size () == 0) return true;
+  
+  static cmt_vmap <cmt_string, cmt_string> realpaths;
+
+  cmt_string rvalue;
+  const cmt_string * prvalue;
+
+  if (!(prvalue = realpaths.find (value)))
+    {
+      // if (!CmtSystem::realpath_ (value, rvalue))
+      //{
+          rvalue = value;
+          CmtSystem::compress_path (rvalue);
+      //}
+      prvalue = &rvalue;
+      realpaths.add (value, rvalue);
+      //      cerr << "realpaths.add: " << value << " , " << rvalue << endl;
+    }
+
+  for (int i = 0; i < items.size (); i++)
+    {
+      const cmt_string& item = items[i];
+      if (item.size () == 0) continue;
+      cmt_string ritem;
+      const cmt_string * pritem;
+
+      if (!(pritem = realpaths.find (item)))
+        {
+          //if (!CmtSystem::realpath_ (item, ritem))
+          //{
+              ritem = item;
+              CmtSystem::compress_path (ritem);
+          //}
+          pritem = &ritem;
+          realpaths.add (item, ritem);
+          //  cerr << "realpaths.add: " << item << " , " << ritem << endl;
+        }
+      if (*pritem == *prvalue)
+        {
+          return i;
+        }
+    }
+
+  return -1;
+}
+
+}
+/*
 static bool find_path_entry (const CmtSystem::cmt_string_vector& items, const cmt_string& value)
+{
+  if (value.size () == 0) return true;
+
+  static cmt_vmap <cmt_string, cmt_string> realpaths;
+
+  cmt_string rvalue;
+  const cmt_string * prvalue;
+
+  if (!(prvalue = realpaths.find (value)))
+    {
+      // if (!CmtSystem::realpath_ (value, rvalue))
+      //{
+          rvalue = value;
+          CmtSystem::compress_path (rvalue);
+      //}
+      prvalue = &rvalue;
+      realpaths.add (value, rvalue);
+      //      cerr << "realpaths.add: " << value << " , " << rvalue << endl;
+    }
+
+  for (int i = 0; i < items.size (); i++)
+    {
+      const cmt_string& item = items[i];
+      if (item.size () == 0) continue;
+      cmt_string ritem;
+      const cmt_string * pritem;
+
+      if (!(pritem = realpaths.find (item)))
+        {
+          //if (!CmtSystem::realpath_ (item, ritem))
+          //{
+              ritem = item;
+              CmtSystem::compress_path (ritem);
+          //}
+          pritem = &ritem;
+          realpaths.add (item, ritem);
+          //  cerr << "realpaths.add: " << item << " , " << ritem << endl;
+        }
+      if (*pritem == *prvalue)
+        {
+          return true;
+        }
+    }
+
+  return false;
+}
+*/
+/*
+static bool find_path_entry (const cmt_string& paths, const cmt_string& value)
 {
   static const cmt_string path_separator = CmtSystem::path_separator ();
   static cmt_vmap <cmt_string, cmt_string> realpaths;
-
-  if (value.size () == 0) return true;
 
   cmt_string rvalue;
@@ -2285 +2536 @@
     }
 
-  //  CmtSystem::cmt_string_vector items;
-  //  CmtSystem::split (paths, path_separator, items);
+  CmtSystem::cmt_string_vector items;
+  CmtSystem::split (paths, path_separator, items);
 
   bool found = false;
@@ -2293 +2544 @@
     {
       const cmt_string& item = items[i];
-      if (item.size () == 0) continue;
       cmt_string ritem;
       const cmt_string * pritem;
@@ -2317 +2567 @@
   return (found);
 }
-
-static bool find_path_entry (const cmt_string& paths, const cmt_string& value)
-{
-  static const cmt_string path_separator = CmtSystem::path_separator ();
-  static cmt_vmap <cmt_string, cmt_string> realpaths;
-
-  cmt_string rvalue;
-  const cmt_string * prvalue;
-
-  if (!(prvalue = realpaths.find (value)))
-    {
-      if (!CmtSystem::realpath_ (value, rvalue))
-        {
-          rvalue = value;
-          CmtSystem::compress_path (rvalue);
-        }
-      prvalue = &rvalue;
-      realpaths.add (value, rvalue);
-      //      cerr << "realpaths.add: " << value << " , " << rvalue << endl;
-    }
-
-  CmtSystem::cmt_string_vector items;
-  CmtSystem::split (paths, path_separator, items);
-
-  bool found = false;
-
-  for (int i = 0; i < items.size (); i++)
-    {
-      const cmt_string& item = items[i];
-      cmt_string ritem;
-      const cmt_string * pritem;
-
-      if (!(pritem = realpaths.find (item)))
-        {
-          if (!CmtSystem::realpath_ (item, ritem))
-            {
-              ritem = item;
-              CmtSystem::compress_path (ritem);
-            }
-          pritem = &ritem;
-          realpaths.add (item, ritem);
-          //  cerr << "realpaths.add: " << item << " , " << ritem << endl;
-        }
-      if (*pritem == *prvalue)
-        {
-          found = true;
-          break;
-        }
-    }
-
-  return (found);
+*/
+//-------------------------------------------------------------
+PathBuilder::PathBuilder ()
+  : m_path_strip (false)
+{
+}
+
+//-------------------------------------------------------------
+PathBuilder::PathBuilder (bool path_strip)
+{
+  PathBuilder ();
+  m_path_strip = path_strip;
 }
 
@@ -2401 +2612 @@
   level++;
 
+                if (Cmt::get_env_access () ||
+                    Symbol::std_env_vars ().has (symbol.name))
+                  {
+  //temp = CmtSystem::getenv (symbol.name);
   CmtSystem::split (CmtSystem::getenv (symbol.name), path_separator, temp_vector);
-  //temp = CmtSystem::getenv (symbol.name);
+  filter_path_value (symbol, temp_vector);
+                    if (Cmt::get_debug ())
+                      {
+                        cmt_string temp_txt;
+                        Cmt::vector_to_string (temp_vector, path_separator, temp_txt);
+                        cerr << "PathBuilder::build> getenv (" << symbol.name
+                             << ") => " << temp_txt << endl;
+                      }
+                  }
+                else
+                  {
+                    if (Cmt::get_debug ())
+                      {
+                        cerr << "PathBuilder::build> getenv (" << symbol.name
+                             << ") denied" << endl;
+                      }
+                    CmtError::set (CmtError::warning,
+                                   "getenv (" + symbol.name + ") denied");
+                    return "";
+                  }
 
   bool first_definition = true;
@@ -2442 +2676 @@
                 CmtSystem::split (new_value, path_separator, temp_vector);
                 //temp = new_value;
+                filter_path_value (symbol, temp_vector);
               }
 
@@ -2451 +2686 @@
                 CmtSystem::split (new_value, path_separator, new_value_vector);
                 for (int i = 0; i < new_value_vector.size (); i++)
-                  if (!find_path_entry (temp_vector, new_value_vector[i]))
-                    //if (!find_path_entry (temp, new_value))
-                    {
-                      temp_vector.push_back (new_value_vector[i]);
-                      /*
-                        if (temp != "") temp += path_separator;
-                        
-                        temp += new_value;
-                      */
-                    }
+                  {
+                    if (new_value_vector[i].size () == 0) continue;
+                    int j = find_path_entry (temp_vector, new_value_vector[i]);
+                    if (j < 0)
+                      {
+                        temp_vector.push_back (new_value_vector[i]);
+                      }
+                    else if (j < temp_vector.size () - 1)
+                      {
+                        temp_vector [j] = "";
+                        temp_vector.push_back (new_value_vector[i]);
+                      }
+                  }
               }
                   
@@ -2473 +2711 @@
                 for (int i = temp_vector.size () - 1; i > n - 1; i--)
                   temp_vector [i] = temp_vector [i - n];
+                for (int i = 0; i < n; i++)
+                  temp_vector [i] = "";
                 for (int i = 0; i < new_value_vector.size (); i++)
-                  if (!find_path_entry (temp_vector, new_value_vector[i]))
-                    //if (!find_path_entry (temp, new_value))
-                    {
-                      temp_vector [i] = new_value_vector[i];
-                      /*
-                        previous_temp = temp;
-                        temp = new_value;
-                        if (previous_temp != "") temp += path_separator;
-                        temp += previous_temp;
-                      */
-                    }
-                  else
-                    temp_vector [i] = "";
+                  {
+                    if (new_value_vector[i].size () == 0) continue;
+                    int j = find_path_entry (temp_vector, new_value_vector[i]);
+                    if (j < 0)
+                      {
+                        temp_vector [i] = new_value_vector[i];
+                      }
+                    else if (j >= n)
+                      {
+                        temp_vector [i] = new_value_vector[i];
+                        temp_vector [j] = "";
+                      }
+                  }
               }
             
@@ -2614 +2854 @@
 
   level--;
-
+  /*
   for (;;)
     {
@@ -2637 +2877 @@
   temp.replace_all ("::", ":");
   temp.replace_all (";;", ";");
-  
+  */
   return (temp);
 }
@@ -2767 +3007 @@
   
   return (temp);
+}
+
+//-------------------------------------------------------------
+void PathBuilder::filter_path_value (const Symbol& symbol,
+                                     CmtSystem::cmt_string_vector& value,
+                                     const cmt_string& /* tag_name */) const
+{
+  static cmt_regexp reg ("[$%`]");
+
+  cmt_vector<int> path (value.size ());
+  int n (0);
+
+  for (int j = 0; j < value.size (); j++)
+    {
+      const cmt_string& v = value[j];
+      bool exists (false);  
+      for (int i = 0; i < j; i++)
+        {
+          if (value[i] == v)
+            {
+              exists = true;
+              break;
+            }
+        }                 
+      if (!exists)
+        {
+          if (m_path_strip)
+            {
+              if (!reg.match (v))
+                {
+                  if (!CmtSystem::test_directory (v))
+                    {
+                      CmtMessage::verbose ("Non-existent directory " + v + " in " + symbol.name + " skipped");
+                      continue;
+                    }
+                }
+              else
+                {
+                  if (CmtMessage::active (Verbose))
+                    {
+                      CmtMessage::warning ("Unresolved directory name " + v + " in " + symbol.name);
+                    }
+                }
+            }
+          else
+            {
+              if (CmtMessage::active (Verbose))
+                if (!reg.match (v) &&
+                    !CmtSystem::test_directory (v))
+                  {
+                    CmtMessage::warning ("Non-existent directory " + v + " in " + symbol.name);
+                  }
+            }
+          path[n++] = j;
+        }
+    }
+
+  for (int i = 0; i < n; i++)
+    if (i != path[i]) value[i] = value[path[i]];
+  
+  value.resize (n);
+}
+
+//-------------------------------------------------------------
+void PathBuilder::filter_path_value (const Symbol& symbol,
+                                     cmt_string& value,
+                                     const cmt_string& tag_name) const
+{
+  static cmt_string ps (CmtSystem::path_separator ());
+  CmtSystem::cmt_string_vector paths;
+
+  CmtSystem::split (value, ps, paths);
+  filter_path_value (symbol, paths, tag_name);
+  Cmt::vector_to_string (paths, ps, value);
+}
+
+//-------------------------------------------------------------
+inline const bool& PathBuilder::get_path_strip () const
+{
+  return m_path_strip;
+}
+
+//-------------------------------------------------------------
+inline void PathBuilder::set_path_strip (const bool& path_strip)
+{
+  m_path_strip = path_strip;
 }
 
@@ -3275 +3601 @@
 int SymbolValueList::print (const Symbol& symbol, 
                             const SymbolValue& value, 
-                            bool& first_definition) const
+                            bool& first_definition,
+                            ostream& out) const
 {
   int result (0);
-
-  //if (use->get_package_name () == "CMT") return result;
 
   cmt_string discarded_text;
   cmt_string define_text;
   ActionType action = Cmt::get_action ();
+
+  static PathBuilder* pb (0);
+  cmt_string rvalue (value.text);
 
   switch (command_type)
@@ -3306 +3634 @@
       case CommandMacroRemoveAllRegexp :
         //case CommandAction :
-        if (value.text == "") return result;
+        if (value.text.size () == 0) return result;
+        break;
+    }
+
+  CmtError::code code (CmtError::ok);
+  cmt_string msg, n;
+  int exec_err (0);
+
+  switch (command_type)
+    {
+      case CommandSet :
+      case CommandSetAppend :
+      case CommandSetPrepend :
+      case CommandSetRemove :
+      case CommandSetRemoveRegexp :
+
+        if (CmtError::has_pending_error ())
+          {
+            code = CmtError::get_last_error_code ();
+            msg = CmtError::get_last_error ();
+            exec_err = CmtError::get_last_execution_error ();
+            n = CmtError::get_error_name (code);
+            CmtError::clear ();
+          }
+        resolve_value_for_macros (rvalue);
+        if (CmtError::get_last_error_code () != CmtError::warning)
+          {
+            if (CmtError::has_pending_error ())
+              {
+                CmtError::print ();
+                CmtError::clear ();
+              }
+            if (CmtError::ok != code)
+              {
+                // restore error occurred before value expansion
+                CmtError::set (code,
+                               (msg.replace (n + ": ", cmt_string ("")), msg),
+                               exec_err);
+              }
+            if (CommandSet != command_type &&
+                rvalue.size () == 0)
+              return result;
+          }
+        else
+          {
+            if (CmtMessage::active (Verbose))
+              CmtError::print ();
+            CmtError::clear ();
+            if (CmtError::ok != code)
+              {
+                // restore error occurred before value expansion
+                CmtError::set (code,
+                               (msg.replace (n + ": ", cmt_string ("")), msg),
+                               exec_err);
+              }
+            // Ignore the error, keep the value unresolved
+            rvalue = value.text;
+          }
+
+        break;
+
+        //case CommandAlias :
+      case CommandPath :
+      case CommandPathAppend :
+      case CommandPathPrepend :
+      case CommandPathRemove :
+      case CommandPathRemoveRegexp :
+        //case CommandMacroPrepend :
+        //case CommandMacro :
+        //case CommandMacroAppend :
+        //case CommandMacroRemove :
+        //case CommandMacroRemoveRegexp :
+        //case CommandMacroRemoveAll :
+        //case CommandMacroRemoveAllRegexp :
+        //case CommandAction :
+
+        if (!pb)
+          pb = static_cast<PathBuilder*> (symbol.builder);
+        if (pb->get_path_strip ())
+          {
+            /*
+            CmtError::code code (CmtError::ok);
+            cmt_string msg, n;
+            int exec_err (0);
+            */
+            if (CmtError::has_pending_error ())
+              {
+                code = CmtError::get_last_error_code ();
+                msg = CmtError::get_last_error ();
+                exec_err = CmtError::get_last_execution_error ();
+                n = CmtError::get_error_name (code);
+                CmtError::clear ();
+              }
+            resolve_value (rvalue);
+            if (CmtError::get_last_error_code () != CmtError::warning)
+              {
+                if (CmtError::has_pending_error ())
+                  {
+                    CmtError::print ();
+                    CmtError::clear ();
+                  }
+                if (CmtError::ok != code)
+                  {
+                    // restore error occurred before value expansion
+                    CmtError::set (code,
+                                   (msg.replace (n + ": ", cmt_string ("")), msg),
+                                   exec_err);
+                  }
+                if (CommandPath != command_type &&
+                    rvalue.size () == 0)
+                  return result;
+              }
+            else
+              {
+                if (CommandPathRemove == command_type ||
+                    CommandPathRemoveRegexp == command_type)
+                  {
+                    // This means that the value is not resolved via symbols
+                    // and, possibly, standard environment variables and
+                    //   * either has no effect on the path at all,
+                    //     or
+                    //   * there should be similar contribution from
+                    //     and, hence, we should get the same error with 
+                    //     CommandPath, CommandPathAppend, or CommandPathPrepend
+                    //  Either way, we can ignore this error.
+
+                    if (CmtMessage::active (Verbose))
+                      CmtError::print ();
+                    CmtError::clear ();
+                    if (CmtError::ok != code)
+                      {
+                        // restore error occurred before value expansion
+                        CmtError::set (code,
+                                       (msg.replace (n + ": ", cmt_string ("")), msg),
+                                       exec_err);
+                      }
+                  }
+                else if (CmtError::ok != code)
+                  {
+                    // print error occurred before value expansion
+                    CmtMessage::error (msg);
+                  }
+                // We keep CmtError::warning to indicate that
+                // we could not resolve path
+                // (without referencing the environment)
+                // and strip path of non-existent directories
+                //
+                rvalue = value.text;
+              }
+          }
+        else // (!pb->get_path_strip ())
+          {
+            if (CmtError::has_pending_error ())
+              {
+                code = CmtError::get_last_error_code ();
+                msg = CmtError::get_last_error ();
+                exec_err = CmtError::get_last_execution_error ();
+                n = CmtError::get_error_name (code);
+                CmtError::clear ();
+              }
+            resolve_value_for_macros (rvalue);
+            if (CmtError::get_last_error_code () != CmtError::warning)
+              {
+                if (CmtError::has_pending_error ())
+                  {
+                    CmtError::print ();
+                    CmtError::clear ();
+                  }
+                if (CmtError::ok != code)
+                  {
+                    // restore error occurred before value expansion
+                    CmtError::set (code,
+                                   (msg.replace (n + ": ", cmt_string ("")), msg),
+                                   exec_err);
+                  }
+                if (CommandPath != command_type &&
+                    rvalue.size () == 0)
+                  return result;
+              }
+            else
+              {
+                if (CmtMessage::active (Verbose))
+                  CmtError::print ();
+                CmtError::clear ();
+                if (CmtError::ok != code)
+                  {
+                    // restore error occurred before value expansion
+                    CmtError::set (code,
+                                   (msg.replace (n + ": ", cmt_string ("")), msg),
+                                   exec_err);
+                  }
+                // Ignore the error, keep the value unresolved
+                rvalue = value.text;
+              }
+          }
+
         break;
     }
@@ -3317 +3840 @@
 
   if (CmtMessage::active (Verbose))
-    cout << "# Package " << (use != 0 ? use->get_package_name () + " " + use->version : "");
-  /*
-  if (use != 0)
-    {
-      cout << use->get_package_name () << " " << use->version;
-    }
-  */
+    out << "# Package " << (use ? use->get_package_name () + " " + use->version : "");
 
   switch (command_type)
@@ -3329 +3846 @@
       case CommandSet :
         if (CmtMessage::active (Verbose))
-          cout << " " << define_text << " set " << symbol.name << " as " << endl;
-        //        cout << " " << define_text << " set " << symbol.name << " as ";
-        cout << "set " << symbol.name;
+          out << " " << define_text << " set " << symbol.name << " as " << endl;
+        //        out << " " << define_text << " set " << symbol.name << " as ";
+        out << "set " << symbol.name;
         first_definition = false;
         result = 1;
@@ -3337 +3854 @@
       case CommandSetAppend :
         if (CmtMessage::active (Verbose))
-          cout << " appends to set " << symbol.name << " : " << endl;
-        //        cout << " appends to set " << symbol.name << " : ";
-        cout << "set_append " << symbol.name;
+          out << " appends to set " << symbol.name << " : " << endl;
+        //        out << " appends to set " << symbol.name << " : ";
+        out << "set_append " << symbol.name;
         result = 1;
         break;
       case CommandSetPrepend :
         if (CmtMessage::active (Verbose))
-          cout << " prepends to set " << symbol.name << " : " << endl;
-        //        cout << " prepends to set " << symbol.name << " : ";
-        cout << "set_prepend " << symbol.name;
+          out << " prepends to set " << symbol.name << " : " << endl;
+        //        out << " prepends to set " << symbol.name << " : ";
+        out << "set_prepend " << symbol.name;
         result = 1;
         break;
       case CommandSetRemove :
         if (CmtMessage::active (Verbose))
-          cout << " removes from set " << symbol.name << " : " << endl;
-        //        cout << " removes from set " << symbol.name << " : ";
-        cout << "set_remove " << symbol.name;
+          out << " removes from set " << symbol.name << " : " << endl;
+        //        out << " removes from set " << symbol.name << " : ";
+        out << "set_remove " << symbol.name;
         result = 1;
         break;
       case CommandSetRemoveRegexp :
         if (CmtMessage::active (Verbose))
-          cout << " removes RE from set " << symbol.name << " : " << endl;
-        //        cout << " removes RE from set " << symbol.name << " : ";
-        cout << "set_remove_regexp " << symbol.name;
+          out << " removes RE from set " << symbol.name << " : " << endl;
+        //        out << " removes RE from set " << symbol.name << " : ";
+        out << "set_remove_regexp " << symbol.name;
         result = 1;
         break;
       case CommandAlias :
         if (CmtMessage::active (Verbose))
-          cout << " " << define_text << " alias " << symbol.name << endl;
-        //        cout << " " << define_text << " alias " << symbol.name << " as ";
-        cout << "alias " << symbol.name;
+          out << " " << define_text << " alias " << symbol.name << endl;
+        //        out << " " << define_text << " alias " << symbol.name << " as ";
+        out << "alias " << symbol.name;
         first_definition = false;
         result = 1;
         break;
-      case CommandPath :
+    case CommandPath :
         if (CmtMessage::active (Verbose))
-          cout << " " << define_text << " path " << symbol.name << endl;
-        //        cout << " " << define_text << " path " << symbol.name << " as ";
-        cout << "path " << symbol.name;
+          out << " " << define_text << " path " << symbol.name << endl;
+        //        out << " " << define_text << " path " << symbol.name << " as ";
+        pb->filter_path_value (symbol, rvalue);
+
+        if (Cmt::get_debug ())
+          {
+            cerr << "|SymbolValueList::print> path " << symbol.name
+                 << " " << value.text << " => " << rvalue << endl;
+          }
+
+        out << "path " << symbol.name;
         first_definition = false;
         result = 1;
@@ -3381 +3906 @@
       case CommandPathAppend :
         if (CmtMessage::active (Verbose))
-          cout << " appends to path " << symbol.name << endl;
-        //        cout << " appends to path " << symbol.name << " : ";
-        cout << "path_append " << symbol.name;
+          out << " appends to path " << symbol.name << endl;
+        //        out << " appends to path " << symbol.name << " : ";
+        pb->filter_path_value (symbol, rvalue);
+
+        if (Cmt::get_debug ())
+          {
+            cerr << "|SymbolValueList::print> path_append " << symbol.name
+                 << " " << value.text << " => " << rvalue << endl;
+          }
+
+        if (rvalue.size () == 0) return result;
+        out << "path_append " << symbol.name;
         result = 1;
         break;
       case CommandPathPrepend :
         if (CmtMessage::active (Verbose))
-          cout << " prepends to path " << symbol.name << " : " << endl;
-        //        cout << " prepends to path " << symbol.name << " : ";
-        cout << "path_prepend " << symbol.name;
+          out << " prepends to path " << symbol.name << " : " << endl;
+        //        out << " prepends to path " << symbol.name << " : ";
+        pb->filter_path_value (symbol, rvalue);
+
+        if (Cmt::get_debug ())
+          {
+            cerr << "|SymbolValueList::print> path_prepend " << symbol.name
+                 << " " << value.text << " => " << rvalue << endl;
+          }
+
+        if (rvalue.size () == 0) return result;
+        out << "path_prepend " << symbol.name;
         result = 1;
         break;
       case CommandPathRemove :
         if (CmtMessage::active (Verbose))
-          cout << " removes from path " << symbol.name << " : " << endl;
-        //        cout << " removes from path " << symbol.name << " : ";
-        cout << "path_remove " << symbol.name;
+          out << " removes from path " << symbol.name << " : " << endl;
+        //        out << " removes from path " << symbol.name << " : ";
+
+        if (Cmt::get_debug ())
+          {
+            cerr << "|SymbolValueList::print> path_remove " << symbol.name
+                 << " " << value.text << " => " << rvalue << endl;
+          }
+
+        out << "path_remove " << symbol.name;
         result = 1;
         break;
       case CommandPathRemoveRegexp :
         if (CmtMessage::active (Verbose))
-          cout << " removes RE from path " << symbol.name << " : " << endl;
-        //        cout << " removes RE from path " << symbol.name << " : ";
-        cout << "path_remove_regexp " << symbol.name;
+          out << " removes RE from path " << symbol.name << " : " << endl;
+        //        out << " removes RE from path " << symbol.name << " : ";
+
+        if (Cmt::get_debug ())
+          {
+            cerr << "|SymbolValueList::print> path_remove_regexp " << symbol.name
+                 << " " << value.text << " => " << rvalue << endl;
+          }
+
+        out << "path_remove_regexp " << symbol.name;
         result = 1;
         break;
       case CommandMacro :
         if (CmtMessage::active (Verbose))
-          cout << " " << define_text << " macro " << symbol.name << " as " << endl;
-        //        cout << " " << define_text << " macro " << symbol.name << " as ";
-        cout << "macro " << symbol.name;
+          out << " " << define_text << " macro " << symbol.name << " as " << endl;
+        //        out << " " << define_text << " macro " << symbol.name << " as ";
+        out << "macro " << symbol.name;
         result = 1;
         break;
       case CommandMacroPrepend :
         if (CmtMessage::active (Verbose))
-          cout << " prepends to macro " << symbol.name << " : " << endl;
-        //        cout << " prepends to macro " << symbol.name << " : ";
-        cout << "macro_prepend " << symbol.name;
+          out << " prepends to macro " << symbol.name << " : " << endl;
+        //        out << " prepends to macro " << symbol.name << " : ";
+        out << "macro_prepend " << symbol.name;
         result = 1;
         break;
       case CommandMacroAppend :
         if (CmtMessage::active (Verbose))
-          cout << " appends to macro " << symbol.name << " : " << endl;
-        //        cout << " appends to macro " << symbol.name << " : ";
-        cout << "macro_append " << symbol.name;
+          out << " appends to macro " << symbol.name << " : " << endl;
+        //        out << " appends to macro " << symbol.name << " : ";
+        out << "macro_append " << symbol.name;
         result = 1;
         break;
       case CommandMacroRemove :
         if (CmtMessage::active (Verbose))
-          cout << " remove from macro " << symbol.name << " : " << endl;
-        //        cout << " remove from macro " << symbol.name << " : ";
-        cout << "macro_remove " << symbol.name;
+          out << " remove from macro " << symbol.name << " : " << endl;
+        //        out << " remove from macro " << symbol.name << " : ";
+        out << "macro_remove " << symbol.name;
         result = 1;
         break;
       case CommandMacroRemoveRegexp :
         if (CmtMessage::active (Verbose))
-          cout << " remove RE from macro " << symbol.name << " : " << endl;
-        //        cout << " remove RE from macro " << symbol.name << " : ";
-        cout << "macro_remove_regexp " << symbol.name;
+          out << " remove RE from macro " << symbol.name << " : " << endl;
+        //        out << " remove RE from macro " << symbol.name << " : ";
+        out << "macro_remove_regexp " << symbol.name;
         result = 1;
         break;
       case CommandMacroRemoveAll :
         if (CmtMessage::active (Verbose))
-          cout << " remove all from macro " << symbol.name << " : " << endl;
-        //        cout << " remove all from macro " << symbol.name << " : ";
-        cout << "macro_remove_all " << symbol.name;
+          out << " remove all from macro " << symbol.name << " : " << endl;
+        //        out << " remove all from macro " << symbol.name << " : ";
+        out << "macro_remove_all " << symbol.name;
         result = 1;
         break;
       case CommandMacroRemoveAllRegexp :
         if (CmtMessage::active (Verbose))
-          cout << " remove all RE from macro " << symbol.name << " : " << endl;
-        //        cout << " remove all RE from macro " << symbol.name << " : ";
-        cout << "macro_remove_all_regexp " << symbol.name;
+          out << " remove all RE from macro " << symbol.name << " : " << endl;
+        //        out << " remove all RE from macro " << symbol.name << " : ";
+        out << "macro_remove_all_regexp " << symbol.name;
         result = 1;
         break;
       case CommandSetupScript :
         if (CmtMessage::active (Verbose))
-          cout << " " << define_text << " setup script " << symbol.name << endl;
-        //       cout << " " << define_text << " action " << symbol.name << " as ";
-        cout << "setup_script" /* << symbol.name */;
+          out << " " << define_text << " setup script " << symbol.name << endl;
+        //       out << " " << define_text << " action " << symbol.name << " as ";
+        out << "setup_script" /* << symbol.name */;
         first_definition = false;
         result = 1;
@@ -3466 +4023 @@
         /*
       case CommandAction :
-        cout << " " << define_text << " action " << symbol.name << " as ";
+        out << " " << define_text << " action " << symbol.name << " as ";
         first_definition = false;
         break;
@@ -3472 +4029 @@
     }
 
-  cout << " " << CmtSystem::quote (value.text, " \t");
-  //  cout << "'" << value.text << "'";
+  out << " " << CmtSystem::quote (rvalue, " \t");
+  //  out << " " << CmtSystem::quote (value.text, " \t");
+  //  out << "'" << value.text << "'";
           
   /*
@@ -3481 +4039 @@
       (selected_tag == Tag::get_default ()))
     {
-      cout << " for default tag";
+      out << " for default tag";
     }
   else
     {
-      cout << " for tag '" << selected_tag->get_name () << "'";
+      out << " for tag '" << selected_tag->get_name () << "'";
     }
   */
 
-  cout << endl;
-  //  cout << discarded_text << endl;
+  out << endl;
+  //  out << discarded_text << endl;
   return result;
 }
@@ -3547 +4105 @@
   else
     {
+                if (Cmt::get_env_access () ||
+                    Symbol::std_env_vars ().has (name))
+                  {
       s = CmtSystem::getenv (name);
+                    if (Cmt::get_debug ())
+                      {
+                        cerr << "Symbol::get_env_value> getenv (" << name
+                             << ") => " << s << endl;
+                      }
+                  }
+                else
+                  {
+                    if (Cmt::get_debug ())
+                      {
+                        cerr << "Symbol::get_env_value> getenv (" << name
+                             << ") denied" << endl;
+                      }
+                    CmtError::set (CmtError::warning,
+                                   "getenv (" + name + ") denied");
+                    return (s);
+                  }
     }
 

CMT/HEAD/source/cmt_symbol.h

@@ -34 +34 @@
   int select_last () const;
   void show (const Symbol& symbol, const SymbolValue& value, bool& first_definition) const;
-  int print (const Symbol& symbol, const SymbolValue& value, bool& first_definition) const;
+  int print (const Symbol& symbol, const SymbolValue& value, bool& first_definition, ostream& out = cout) const;
 
   CommandType command_type;
@@ -89 +89 @@
 
   static void all_set ();
-  static void all_print (PrintMode mode);
+  static void all_print (PrintMode mode, ostream& out = cout);
+  //static void all_print (PrintMode mode);
   static void all_print_clean (PrintMode mode);
   static void check_all_paths ();
@@ -96 +97 @@
   static SymbolVector& symbols ();
   static SymbolMap& symbol_map ();
+  static SymbolMap& std_env_vars ();
   static Symbol& symbol (int index);
   static void clear_all ();
@@ -107 +109 @@
 
   static bool get_inhibit_display ();
+  static bool set_path_strip (const bool& path_strip);
 
 public:
@@ -118 +121 @@
 
   int print_clean (PrintMode mode);
-  int print (PrintMode mode);
+  int print (PrintMode mode, ostream& out = cout);
+  //int print (PrintMode mode);
   cmt_string build_macro_value (bool display_it = false) const;
   int print_macro (PrintMode mode, ostream& out = cout) const;

CMT/HEAD/source/cmt_use.cxx

@@ -1934 +1934 @@
     {
       cout << "|Use::change_path> path: " << new_path
-           << ": project: " << (project ? project->get_cmtpath () : "0")
-           << ": " << get_info () << endl;
+           << " project: " << (project ? project->get_cmtpath () : "0")
+           << " use: " << get_info () << endl;
     }
 
@@ -1978 +1978 @@
     {
       cout << "<Use::change_path| real_path: " << real_path
-           << ": m_project: " << (m_project ? m_project->get_cmtpath () : "0")
-           << ": " << get_info () << endl;
+           << " m_project: " << (m_project ? m_project->get_cmtpath () : "0")
+           << " use: " << get_info () << endl;
     }
 }
@@ -3770 +3770 @@
     }
 
+  if (action_setup == Cmt::get_action () &&
+      Requirements == Cmt::get_print_mode ())
+    {
+      //cerr << "|Use::fill_standard_macros> Checking for " << prefix << "CONFIG" << endl;
+      if (!discarded &&
+          get_package_name () != "cmt_standalone" &&
+          get_strategy ("SetupConfig"))
+        {
+          buffer += "macro ";
+          buffer += prefix;
+          buffer += "CONFIG";
+          buffer += " \"";
+          buffer += CmtSystem::get_cmt_config ();
+          buffer += "\"";
+          buffer += "\n";
+        }
+    }
+
   buffer += "macro ";
   buffer += prefix;