Changeset 588 for CMT/HEAD/source/cmt_generators.cxx

Timestamp:

Nov 27, 2011, 4:36:15 PM (13 years ago)

Author:

rybkin

Message:

See C.L. 465

File:

• CMT/HEAD/source/cmt_generators.cxx (modified) (26 diffs)

CMT/HEAD/source/cmt_generators.cxx

@@ -12 +12 @@
 #include "cmt_error.h"
 #include <assert.h>
+#include "cmt_project.h"
 
 //--------------------------------------------------
@@ -200 +201 @@
   if (Cmt::get_debug ())
     {
-      cout << "CmtGenerator::analyze_file> constituent=" << 
+      cout << "LibraryGenerator::analyze_file> constituent=" << 
         constituent.name <<
         " obj=" << obj << endl;
@@ -408 +409 @@
 
 //--------------------------------------------------
+void LibraryGenerator::fill_names_outputs ()
+{
+  bool l_first = true;
+  bool o_first = true;
+
+  m_LINE = "";
+  m_OBJS = "";
+
+  for (int i = 0; i < m_source_files.size (); i++)
+    {
+      const SourceFile& file = m_source_files[i];
+      const cmt_string name = file.name ();
+      const cmt_string output = file.output ();
+      Language& language = file.language ();
+
+      if (output != "")
+        {
+          if (o_first)
+            {
+              o_first = false;
+            }
+          else
+            {
+              m_OBJS += " ";
+            }
+          m_OBJS += output;
+
+          if (language == Language::null () || !language.native_dependencies ())
+            {
+              if (l_first)
+                {
+                  l_first = false;
+                }
+              else
+                {
+                  m_LINE += " ";
+                }
+              m_LINE += name;
+            }
+        }
+
+      if (Cmt::get_debug ())
+        {
+          cout << "LibraryGenerator::fill_names_outputs>" << endl;
+          cout << "name=" << name << " LINE=" << m_LINE << endl;
+          cout << "output=" << output << " OBJS=" << m_OBJS << endl;
+        }
+    }
+
+  filter_path (m_LINE.value);
+}
+
+//--------------------------------------------------
 void LibraryGenerator::build (const cmt_string& package,
                               const Constituent& constituent,
+                              bool& dependencies,
                               const cmt_string& file_name)
 {
@@ -735 +790 @@
         }
     }
+  dependencies = need_dependencies;
 
   if (constituent.build_triggers)
@@ -893 +949 @@
 DocumentGenerator::DocumentGenerator ()
 {
+  m_FILEEXTENSION.set ("FILEEXTENSION");
+
   document_header_fragment.set ("document_header");
+  dependency_fragment.set ("dependency");
 }
 
@@ -900 +959 @@
 {
   AnyDocumentGenerator::reset ();
+  m_FILEEXTENSION = "";
+
   document_header_fragment.reset ();
+  dependency_fragment.reset ();
 }
 
@@ -906 +968 @@
 void DocumentGenerator::build (const cmt_string& package,
                                const Constituent& constituent,
+                               bool& dependencies,
                                const cmt_string& file_name)
 {
@@ -1062 +1125 @@
     }
 
+  dependencies = fragment.need_dependencies ();
   if (fragment.need_dependencies ())
     {
@@ -1123 +1187 @@
       if (m_FILEPATH.value != "") m_FILEPATH.value += CmtSystem::file_separator ();
       filter_path (m_FILEPATH.value);
-      CmtSystem::basename (file_name, m_FILENAME.value);
-      CmtSystem::get_dot_suffix (m_FILENAME.value, m_FILESUFFIX.value);
+      m_FILENAME.value = m_NAME.value + suffix;
+      //CmtSystem::basename (file_name, m_FILENAME.value);
+      m_FILESUFFIX.value = suffix;
+      //CmtSystem::get_dot_suffix (m_FILENAME.value, m_FILESUFFIX.value);
+      CmtSystem::get_suffix (m_FILENAME.value, m_FILEEXTENSION .value);
       /*
       if (!CmtSystem::test_file (file_name) && !CmtSystem::test_directory (file_name))
@@ -1133 +1200 @@
       filter_path (m_FULLNAME.value);
 
-      fragment.copy (m_output_file, constituent.variables, 8,
+      if (fragment.need_dependencies ())
+        {
+          // ensure that ${CONSTITUENT}_dependencies.make gets rebuilt
+          // whenever source file OR its dependencies change
+          dependency_fragment.copy (m_output_file, constituent.variables, 9,
+                                    &m_FILEPATH,
+                                    &m_SUFFIX,
+                                    &m_CONSTITUENT,
+                                    &m_CONSTITUENTSUFFIX,
+                                    &m_FILENAME,
+                                    &m_NAME,
+                                    &m_FULLNAME,
+                                    &m_FILESUFFIX,
+                                    &m_FILEEXTENSION);
+        }
+      
+      fragment.copy (m_output_file, constituent.variables, 9,
                      &m_FILEPATH,
                      &m_SUFFIX,
@@ -1141 +1224 @@
                      &m_NAME,
                      &m_FULLNAME,
-                     &m_FILESUFFIX);
+                     &m_FILESUFFIX,
+                     &m_FILEEXTENSION);
     }
 
@@ -1201 +1285 @@
 }
 
+//--------------------------------------------------
 ReadmeGenerator::ReadmeGenerator ()
 {
@@ -2702 +2787 @@
 }
 
-
-
+//--------------------------------------------------
+
+PackagesMakefileGenerator::PackagesMakefileGenerator ()
+{
+  m_DEPENDENCIES.set ("DEPENDENCIES");
+  m_PACKAGEMGRPATH.set ("PACKAGEMGRPATH");
+  m_PACKAGEFULLNAME.set ("PACKAGEFULLNAME");
+  m_ISLOCAL.set ("ISLOCAL");
+
+  packages_header_fragment.set ("packages_header");
+  packages_trailer_fragment.set ("packages_trailer");
+  package_fragment.set ("package");
+}
+
+void PackagesMakefileGenerator::reset ()
+{
+  CmtGenerator::reset ();
+  m_DEPENDENCIES = "";
+  m_PACKAGEMGRPATH = "";
+  m_PACKAGEFULLNAME = "";
+  m_ISLOCAL = "";
+
+  packages_header_fragment.reset ();
+  packages_trailer_fragment.reset ();
+  package_fragment.reset ();
+}
+
+//--------------------------------------------------
+void PackagesMakefileGenerator::build (const cmt_string& package,
+                                       const cmt_string& file)
+{
+  reset ();
+
+  cmt_string file_name (file);
+  if (file_name == "")
+    {
+      file_name = "packages.";
+
+      if (Cmt::build_nmake ())
+        {
+          file_name += "nmake";
+        }
+      else
+        {
+          file_name += "make";
+        }
+    }
+
+  cmt_string save_file_name = file_name;
+  save_file_name += "cmtsave";
+
+  if (CmtSystem::test_file (file_name))
+    {
+      rename (file_name, save_file_name);
+    }
+
+  cmt_string new_file_name = file_name;
+  new_file_name += "new";
+
+  m_output_file = fopen (new_file_name, "wb");
+  if (m_output_file != NULL)
+    {
+      m_PACKAGE = package;
+
+      packages_header_fragment.copy (m_output_file, 1, &m_PACKAGE);
+
+      Project* cur = Project::get_current ();
+      Use::UsePtrVector uses (Use::get_ordered_uses ());
+      uses.push_back (&Use::current ());
+      cmt_string temp;
+      for (int i = uses.size () - 1; i >= 0; i--)
+        {
+          Use* use = uses[i];
+          if (use->discarded) continue;
+          if (use->m_hidden) continue;
+          if (!use->located ()) continue;
+          if (use->get_package ()->is_cmt ()) continue;
+
+          if (use->get_project () == cur)
+            m_ISLOCAL = "is_local";
+          else
+            m_ISLOCAL = "is_not_local";
+
+          temp = use->get_full_path ();
+          switch (use->style)
+            {
+            case cmt_style:
+              temp += CmtSystem::file_separator ();
+              temp += "cmt";
+              break;
+            case mgr_style:
+              temp += CmtSystem::file_separator ();
+              temp += "mgr";
+              break;
+            }
+#ifdef WIN32
+          temp += " ";
+#endif
+          m_PACKAGEMGRPATH = temp;
+          //      fprintf (m_output_file, "%s\n", temp.c_str());
+
+          temp = "";
+          if (Symbol* s = Symbol::find (use->get_package_name () + "_offset"))
+            {
+              cmt_string o = s->build_macro_value ();
+              if (o != "")
+                {
+                  temp += o;
+                  temp += CmtSystem::file_separator ();
+                }
+            }
+          else
+            {
+              CmtMessage::warning
+                (CmtError::get_error_name (CmtError::symbol_not_found)
+                 + ": macro " + use->get_package_name () + "_offset");
+            }
+          temp += use->get_package_name ();
+          temp.replace_all (CmtSystem::file_separator (), "_");
+#ifdef WIN32
+          temp += " ";
+#endif
+          m_PACKAGEFULLNAME = temp;
+          //      fprintf (m_output_file, "%s\n", temp.c_str());
+
+          m_PACKAGE = use->get_package_name ();
+
+          Use::UsePtrVector subuses;
+          for (int i = 0; i < use->sub_uses.size (); i++)
+            {
+              if (use->sub_uses[i]->m_index >= 0 && !use->sub_uses[i]->discarded)
+                {
+                  if (use->sub_uses[i]->m_hidden) continue;
+                  subuses.push_back (use->sub_uses[i]);
+                }
+              else
+                {
+                  Use* au (Use::find_valid (use->sub_uses[i]->get_package_name ()));
+                  if (au)
+                    {
+                      subuses.push_back (au);
+                    }
+                }
+            }
+          m_DEPENDENCIES = "";
+          for (int i = 0; i < subuses.size (); i++)
+            {
+              if (i != 0)
+                {
+                  m_DEPENDENCIES += " " + subuses[i]->get_package_name ();
+                }
+              else
+                {
+                  m_DEPENDENCIES += subuses[i]->get_package_name ();
+                }
+            }
+
+          package_fragment.copy (m_output_file, 5, &m_PACKAGE, &m_DEPENDENCIES,
+                             &m_PACKAGEMGRPATH, &m_PACKAGEFULLNAME, &m_ISLOCAL);
+        }
+
+      if (Symbol* s = Symbol::find ("CMTINSTALLAREA"))
+        {
+          cmt_string o = s->build_macro_value ();
+          Symbol::expand (o);
+          if (o != "")
+            {
+              temp  = "CMTINSTALLAREA=";
+              temp += o;
+#ifdef WIN32
+              temp += " ";
+#endif
+              fprintf (m_output_file, "%s\n", temp.c_str());
+            }
+        }
+
+      packages_trailer_fragment.copy (m_output_file, 0);
+
+      CmtSystem::close_ostream (m_output_file, new_file_name);
+      //  fclose (m_output_file);
+
+      commit (new_file_name);
+    }
+  else
+    {
+      CmtError::set (CmtError::file_access_error, new_file_name);
+    }
+}
+
+//--------------------------------------------------
 
 /**
@@ -2794 +3067 @@
 };
 
+//--------------------------------------------------
+void DependencyGenerator::reset ()
+{
+  CmtGenerator::reset ();
+  m_deps_builder.clear ();
+  m_stamps = true;
+  m_name = "";
+}
+
+//--------------------------------------------------
+void DependencyGenerator::prepare_includes ()
+{
+  cmt_string path;
+  cmt_string substitution;
+
+  Use* use = &Use::current ();
+
+  //  m_deps_builder.clear ();
+
+  if (use->include_path != "none")
+    {
+      if (use->include_path == "")
+        {
+          m_deps_builder.add (incdir, "$(src)");
+        }
+      else
+        {
+          substitution = use->include_path;
+          
+          path = substitution;
+          Symbol::expand (path);
+          
+          CmtSystem::reduce_file_separators (path);
+
+          m_deps_builder.add (path, substitution);
+        }
+    }
+
+  m_deps_builder.add_includes (*use);
+
+  Use::UsePtrVector& uses = Use::get_ordered_uses ();
+
+  if (uses.size () > 0)
+    {
+      int number;
+
+      for (number = 0; number < uses.size (); number++)
+        {
+          use = uses[number];
+          if (use->discarded) continue;
+
+          if (use->real_path != "")
+            {
+              if (use->include_path != "none")
+                {
+                  if (use->include_path == "")
+                    {
+                      use->get_full_path (path);
+                      path += CmtSystem::file_separator ();
+                      path += "src";
+
+                      substitution = "$(";
+                      substitution += use->prefix;
+                      substitution += "ROOT)";
+                      substitution += CmtSystem::file_separator ();
+                      substitution += "src";
+                      substitution += CmtSystem::file_separator ();
+                    }
+                  else
+                    {
+                      substitution = use->include_path;
+
+                      path = substitution;
+                      Symbol::expand (path);
+
+                      CmtSystem::reduce_file_separators (path);
+                    }
+
+                  m_deps_builder.add (path, substitution);
+                }
+
+              m_deps_builder.add_includes (*use);
+            }
+        }
+    }
+}
+
+//--------------------------------------------------
+void DependencyGenerator::prepare_header_file_filters ()
+{
+  const Use* current_use = &Use::current ();
+  Use::UsePtrVector uses (Use::get_ordered_uses ());
+  uses.push_back (&Use::current ());
+  bool current_only (true);
+  for (int i = uses.size () - 1; i >= 0; i--)
+    {
+      const Use* use = uses[i];
+      //cerr << "prepare_header_file_filters(0)> " << use->get_package_name () << "[" << use->get_index () << "]\n";
+      if (use->discarded) continue;
+      if (use->m_hidden) continue;
+      if (!use->located ()) continue;
+
+      if (current_only && use != current_use)
+        current_only = false;
+
+      cmt_string package_name = use->get_package_name ();
+      if (package_name == "CMT") continue;
+
+      const Symbol* filter_macro = Symbol::find (package_name + "_header_file_filter");
+      if (filter_macro == 0) continue;
+
+      const Symbol* stamp_macro = Symbol::find (package_name + "_header_file_stamp");
+      cmt_string stamp;
+      if (stamp_macro != 0)
+        {
+          stamp = stamp_macro->resolve_macro_value ();
+        }
+      else
+        {
+          use->get_full_path (stamp);
+          switch (use->style)
+            {
+            case cmt_style:
+              stamp += CmtSystem::file_separator ();
+              stamp += "cmt";
+              break;
+            case mgr_style:
+              stamp += CmtSystem::file_separator ();
+              stamp += "mgr";
+              break;
+            }
+          stamp += CmtSystem::file_separator ();
+          stamp += "cmt_header_file.stamp";
+          //stamp += "cmt_all_headers.stamp";
+          //<package>/cmt/cmt_all_headers.stamp
+        }
+      if (!CmtSystem::test_file (stamp)) continue;
+
+      //cerr << "0: adding filter: " << use->get_package_name () << "[" << use->get_index () << "]\n";
+      cmt_regexp* filter = new cmt_regexp (filter_macro->resolve_macro_value ());
+      assert (filter != 0);
+
+      m_deps_builder.add_header_filter (use, filter, stamp);
+    }
+
+  if (current_only)
+    { // we are most likely reading dependencies[_CONSTITUENT].in without CMT
+      for (int number = 0; number < Symbol::symbol_number (); number++)
+        {
+          const Symbol& symbol = Symbol::symbol (number);
+          if (symbol.type != Symbol::SymbolMacro) continue;
+          int r = symbol.name.find_last_of ("_header_file_filter");
+          if (r == cmt_string::npos ||
+              (r + 19) != symbol.name.size () ||
+              r == 0) continue;
+
+          cmt_string package_name = symbol.name.substr(0, r);
+          const Use* use = Use::find (package_name);
+          if (use == current_use) continue;
+          if (0 != use && use->discarded) continue;
+          if (0 != use && use->m_hidden) continue;
+          if (0 != use && !use->located ()) continue;
+          
+          //Symbol* filter_macro = Symbol::find (package_name + "_header_file_filter");
+          //if (filter_macro == 0) continue;
+          
+          const Symbol* stamp_macro = Symbol::find (package_name + "_header_file_stamp");
+          cmt_string stamp;
+          if (stamp_macro != 0)
+            {
+              stamp = stamp_macro->resolve_macro_value ();
+            }
+          else if (0 != use)
+            {
+              use->get_full_path (stamp);
+              switch (use->style)
+                {
+                case cmt_style:
+                  stamp += CmtSystem::file_separator ();
+                  stamp += "cmt";
+                  break;
+                case mgr_style:
+                  stamp += CmtSystem::file_separator ();
+                  stamp += "mgr";
+                  break;
+                }
+              stamp += CmtSystem::file_separator ();
+              stamp += "cmt_header_file.stamp";
+            }
+          if (!CmtSystem::test_file (stamp)) continue;
+          
+          //cerr << "1: adding filter: " << package_name << "\n";
+          cmt_regexp* filter = new cmt_regexp (symbol.resolve_macro_value ());
+          assert (filter != 0);
+          
+          m_deps_builder.add_header_filter (use, filter, stamp);
+        }
+    }
+}
+
+//--------------------------------------------------
 void DependencyGenerator::build (const CmtSystem::cmt_string_vector& arguments)
 {
   reset ();
-  prepare_use_context ();
-
-  prepare_header_file_filters ();
-
-  const cmt_string& name = arguments[0];
-
-  m_constituent = Constituent::find (name);
-  if (m_constituent == 0)
-    {
-      // Error : wrong constituent name...
-      return;
-    }
-
-  const Constituent& constituent = *m_constituent;
-
-  cmt_string file_name;
-  cmt_string full_name;
-  cmt_string compressed_name;
-  //  cmt_string suffix;
-  cmt_string dependencies;
 
   //
-  // Scan the sources.
+  // Parse arguments first
   //
-
-  //
-  //  We have to rebuild the dependencies for :
-  //
-  //   o all sources if the parameter -all_sources has been received
-  //   o otherwise,
-  //      + all source names provided in the argument list (if any)
-  //      + all source names missing from the existing dependency file (if any)
-  //
-
-  const CmtSystem::cmt_string_vector& sources = constituent.modules;
-  const cmt_vector<cmt_regexp>& excludes = constituent.exclude_exprs;
-  const cmt_vector<cmt_regexp>& selects = constituent.select_exprs;
-
-  m_stamps = true;
+  CmtSystem::cmt_string_vector cli_input, all;
   bool all_sources = false;
-
-  int source_number = arguments.size ();
-  int i;
-
-  //cerr << "source_number=" << source_number << endl;
-
-  for (i = source_number-1; i >= 0; i--)
-    {
-      file_name = arguments[i];
-
-      //cerr << "file_name=" << file_name << endl;
-
-      // Get rid of files that may come from the makefile fragment
-      if (file_name.find ("requirements") != cmt_string::npos) source_number--;
-      else if (file_name.substr (0, 5) == "-out=" ||
-               file_name.substr (0, 5) == "-out:" ||
-               file_name.substr (0, 5) == "/out:" ||
-               file_name.substr (0, 5) == "/out=")
-        {
-          source_number--;
+  bool config_files (false);
+  bool start_all (false);
+
+  for (int i = 0; i < arguments.size (); i++)
+    {
+      cmt_string file_name = arguments[i];
+
+      //cerr << "i: " << i << " file_name=" << file_name << endl;
+
+      if (file_name.substr (0, 5) == "-out=" ||
+          file_name.substr (0, 5) == "-out:" ||
+          file_name.substr (0, 5) == "/out:" ||
+          file_name.substr (0, 5) == "/out=")
+        {
           file_name.erase (0, 5);
           m_output_file_name = file_name;
         }
-      else if (file_name.find (".make") != cmt_string::npos) source_number--;
       else if (file_name == "-all_sources" ||
                file_name == "/all_sources") 
         {
-          source_number = sources.size ();
           all_sources = true;
         }
@@ -2870 +3302 @@
                file_name == "/no_stamps") 
         {
-          source_number--;
           m_stamps = false;
         }
-    }
+      else if (file_name.substr (0, 2) == "-I" ||
+               file_name.substr (0, 2) == "/I")
+        {
+          file_name.erase (0, 2);
+          //cerr << "include: " << file_name << endl;
+          m_deps_builder.add (file_name, file_name);
+        }
+      else if (file_name  == "-start_all" ||
+               file_name  == "/start_all")
+        {
+          if (start_all)
+            {
+              CmtError::set(CmtError::syntax_error,
+                            "Unexpected option " + file_name);
+              return;
+            }
+          start_all = true;
+        }
+      else if (file_name == "-end_all" ||
+               file_name == "/end_all")
+        {
+          if (!start_all)
+            {
+              CmtMessage::warning
+                (CmtError::get_error_name (CmtError::syntax_error)
+                 + ": Unexpected option " + file_name);
+            }
+          start_all = false;
+        }
+      else if (file_name.substr (0, 1) == "-"
+#ifdef WIN32
+               || file_name.substr (0, 1) == "/"
+#endif
+               )
+        {
+          if (CmtMessage::active (Verbose))
+            CmtMessage::warning
+              (CmtError::get_error_name (CmtError::warning)
+               + ": Unknown option " + file_name);
+        }
+      else if (file_name.substr (file_name.size () - 12) == "requirements" ||
+               file_name.substr (file_name.size () - 5) == ".make" ||
+               file_name.substr (file_name.size () - 3) == ".mk" ||
+               file_name.substr (file_name.size () - 6) == ".nmake" ||
+               file_name.substr (file_name.size () - 3) == ".in" ||
+               file_name.substr (file_name.size () - 6) == ".stamp")
+        {
+          // Configuration changed,
+          // want to rebuild dependencies from scratch
+          if (!config_files) config_files = true;
+          if (!all_sources) all_sources = true;
+        }
+      else if (start_all)
+        {
+          all.push_back (file_name);
+        }
+      else if (m_name.size () != 0)
+        {
+          cli_input.push_back (file_name);
+        }
+      else
+        {
+          if (file_name.size () != 0)
+            m_name = file_name;
+        }
+    }
+  
+  if (start_all)
+    CmtMessage::warning
+      (CmtError::get_error_name (CmtError::syntax_error)
+       + ": Missing option -end_all");
+
+  //cerr << "m_name: " << m_name << endl;
+  if (m_name.size () == 0)
+    {
+      CmtError::set(CmtError::syntax_error,
+                    "Name missing as first argument");
+      return;
+    }
+
+  //cerr << "config_files: " << config_files << endl;
+
+  m_constituent = Constituent::find (m_name);
+
+  if (!config_files && 0 == cli_input.size () &&
+      0 == all.size () && 0 == m_constituent)
+    {
+      CmtError::set(CmtError::syntax_error,
+                    m_name + ": Files arguments missing");
+      return;
+    }
+  /*
+  cerr << "cli_input:";
+  for (int i = 0; i < cli_input.size (); i++)
+    cerr << " " << cli_input[i];
+  cerr << "\n";
+
+  cerr << "all:";
+  for (int i = 0; i < all.size (); i++)
+    cerr << " " << all[i];
+  cerr << "\n";
+  */
+  prepare_includes ();
+  prepare_header_file_filters ();
 
   //
@@ -2922 +3456 @@
     {
       m_output_file_name = m_bin;
-      m_output_file_name += name;
+      m_output_file_name += m_name;
       m_output_file_name += "_";
       m_output_file_name += "dependencies.";
@@ -2935 +3469 @@
     }
 
-  if (all_sources)
-    {
-      for (i = 0; i < sources.size (); i++)
-        {
-          file_name = sources[i];
-          
-          set_full_name (full_name, file_name);
-          if (full_name == "") continue;
-
-          CmtSystem::compress_path (full_name, compressed_name);
-          full_name = compressed_name;
-          
-          static CmtSystem::cmt_string_vector files;
-
-          get_all_files (full_name, excludes, selects, files);
-
-          for (int j = 0; j < files.size (); j++)
-            {
-              const cmt_string& name = files[j];
-              
-              if (name != "") 
-                {
-                  const cmt_string& line = build (name);
-                  
-                  add_line_to_text (line, dependencies);
-                }
-            }
-        }
-    }
-  else
-    {
-      //
-      // New read the existing dependency file if any and filter it to
-      // extract the source names
-      //
-      static DependencyFilter filter;
-      dependencies.read (m_output_file_name);
-      filter.run (dependencies);
-      
-      for (i = 1; i < source_number; i++)
-        {
-          file_name = arguments[i];
-
-          set_full_name (full_name, file_name);
-          if (full_name == "") continue;
-
-          CmtSystem::compress_path (full_name, compressed_name);
-          full_name = compressed_name;
-          
-          const cmt_string& line = build (full_name);
-                  
-          add_line_to_text (line, dependencies);
-
-          filter.add_source (full_name);
-
-        }
-
-      // Now : are there still any missing source file in dependencies??
-
-      for (i = 0; i < sources.size (); i++)
-        {
-          file_name = sources[i];
-          
-          set_full_name (full_name, file_name);
-          if (full_name == "") continue;
-          
-          CmtSystem::compress_path (full_name, compressed_name);
-          full_name = compressed_name;
-          
-          static CmtSystem::cmt_string_vector files;
-          
-          get_all_files (full_name, excludes, selects, files);
-
-          for (int j = 0; j < files.size (); j++)
-            {
-              const cmt_string& name = files[j];
-              if (name != "") 
-                {
-                  if (!filter.has_source (name))
-                    {
-                      const cmt_string& line = build (name);
-                  
-                      add_line_to_text (line, dependencies);
-                    }
-                }
-            }
-        }
-    }
+  //-------------------------------------------------------------------------------
+  //
+  // For Makefile, we need to select, from cli_input, source files only,
+  // there may be dependencies of source files (typically, header files) as well
+  //
+  cmt_string dependencies;
+  if (!all_sources)
+    {
+      // want to validate cli_input against
+      //   either
+      // o all cli sources
+      //   or
+      // o m_constituent sources
+      set_source_files (all);
+      if (0 == validate (cli_input))
+        {
+          // cli_input contains source files ONLY
+          // calculate dependencies for them ONLY
+          if (CmtSystem::test_file (m_output_file_name))
+            {
+              if (!dependencies.read (m_output_file_name))
+                {
+                  CmtError::set (CmtError::file_access_error, m_output_file_name);
+                  return;
+                }
+            }
+          fill_dependencies (dependencies, cli_input);
+        }
+      else
+        {
+          all_sources = true;
+          // calculate dependencies for 
+          // all cli sources
+          // or
+          // m_constituent sources
+          fill_dependencies (dependencies);
+        }
+      /*
+      if (0 != all.size ())
+        {
+          // o all cli sources
+          int n_invalid = 0;
+          for (int i = 0; i < cli_input.size (); i++)
+            {
+              bool valid = false;
+              for (int j = 0; j < all.size (); j++)
+                if (cli_input[i] == all[j])
+                  {
+                    valid = true;
+                    break;
+                  }
+              if (!valid)
+                {
+                  n_invalid += 1;
+                  break;
+                }
+            }
+          if (0 == n_invalid)
+            {
+              // cli_input contains source files ONLY
+              // calculate dependencies for them ONLY
+              if (CmtSystem::test_file (m_output_file_name))
+                {
+                  if (!dependencies.read (m_output_file_name))
+                    {
+                      CmtError::set (CmtError::file_access_error, m_output_file_name);
+                      return;
+                    }
+                }
+              fill_dependencies (dependencies, cli_input);
+            }
+          else
+            {
+              all_sources = true;
+              // calculate dependencies for all (all cli sources)
+              fill_dependencies (dependencies, all);
+            }
+        }
+      else // 0 == all.size ()
+        {
+          //      set_source_files ();
+          if (int n = set_source_files ())
+            //    if (0 != m_source_files.size ())
+            {
+              // o m_constituent sources
+              int n_invalid = 0;
+              for (int i = 0; i < cli_input.size (); i++)
+                {
+                  bool valid = false;
+                  for (int j = 0; j < n; j++)
+                    if (cli_input[i] == m_source_files[j].name ())
+                      {
+                        valid = true;
+                        break;
+                      }
+                  if (!valid)
+                    {
+                      n_invalid += 1;
+                      break;
+                    }
+                }
+              if (0 == n_invalid)
+                {
+                  // cli_input contains source files ONLY
+                  // calculate dependencies for them ONLY
+                  if (CmtSystem::test_file (m_output_file_name))
+                    {
+                      if (!dependencies.read (m_output_file_name))
+                        {
+                          CmtError::set (CmtError::file_access_error, m_output_file_name);
+                          return;
+                        }
+                    }
+                  fill_dependencies (dependencies, cli_input);
+                }
+              else
+                {
+                  all_sources = true;
+                  // calculate dependencies for m_source_files
+                  // (m_constituent sources)
+                  fill_dependencies (dependencies);
+                }
+            }
+          else // 0 == m_source_files.size ())
+            {
+              // no source files to validate against
+              fill_dependencies (dependencies, cli_input);
+            }
+        }
+      */
+    }
+  else // all_sources = true
+    {
+      if (int n = set_source_files (all))
+        {
+          // calculate dependencies for m_source_files 
+          //   either
+          // o all cli sources
+          //   or
+          // o m_constituent sources
+          //   if any existing
+          fill_dependencies (dependencies);
+        }
+      else
+        {
+          // calculate dependencies for all we have
+          fill_dependencies (dependencies, cli_input);
+        }
+      /*
+      if (0 != all.size ())
+        {
+          // calculate dependencies for all (all cli sources)
+          fill_dependencies (dependencies, all);
+        }
+      else
+        {
+          if (int n = set_source_files ())
+            {
+              // calculate dependencies for m_source_files (m_constituent sources)
+              fill_dependencies (dependencies);
+            }
+          else
+            {
+              // calculate dependencies for all we have
+              fill_dependencies (dependencies, cli_input);
+            }
+        }
+      */
+    }
+
+  if (CmtError::has_pending_error ())
+    {
+      if (CmtError::get_last_error_code () == CmtError::path_not_found ||
+          CmtError::get_last_error_code () == CmtError::file_access_error ||
+          CmtError::get_last_error_code () == CmtError::execution_failed)
+        return;
+    }
+  //-------------------------------------------------------------------------------
 
   FILE* f = fopen (m_output_file_name.c_str (), "wb");
@@ -3030 +3654 @@
       dependencies.write (f);
       CmtSystem::close_ostream (f, m_output_file_name);
-      //          fclose (f);
     }
   else
     {
       CmtError::set (CmtError::file_access_error, m_output_file_name);
-      //      CmtMessage::error ("Cannot open " + m_output_file_name + " for write");
     }
 
@@ -3043 +3665 @@
 //--------------------------------------------------
 //  o text contains lines with a pattern like :
-//      key = xxxxx
-//
+//      key = value
 //  o line follows the same pattern
 //
-//   This function appends <line> to <text> only if the key found in
-//  <line> is not found in <text>
+//  This function
+//    o if the key found in <line> is found in <text>, removes the first line in <text> with the key, if any
+//    o appends <line> to <text>
 //--------------------------------------------------
-void DependencyGenerator::add_line_to_text (const cmt_string& line, cmt_string& text)
+void DependencyGenerator::add_line_to_text (const cmt_string& line, cmt_string& text) const
 {
   static const cmt_string empty;
@@ -3091 +3713 @@
 }
 
+//--------------------------------------------------
 cmt_string DependencyGenerator::build (const cmt_string& file_name)
 {
   Log;
 
-  const Constituent& constituent = *m_constituent;
+  //  const Constituent& constituent = *m_constituent;
 
   static cmt_string full_name;
@@ -3105 +3728 @@
   line = "";
 
+  /*
   if (!CmtSystem::absolute_path (file_name))
     {
       full_name = srcdir;
     }
+  */
 
   full_name += file_name;
@@ -3116 +3741 @@
   CmtSystem::get_suffix (full_name, suffix);
 
-  if (name == "requirements") return (line);
-
-  const CmtSystem::cmt_string_vector& deps = m_deps_builder.run (full_name);
+  //  if (name == "requirements") return (line);
+
+  const CmtSystem::cmt_string_vector& deps = m_deps_builder.run (full_name, m_name);
+  if (CmtError::has_pending_error ())
+    {
+      return line;
+    }
+  //      CmtError::set (CmtError::execution_failed, preprocessor, status);
+  //      CmtError::set (CmtError::file_access_error, header_file_path);
+  //      CmtError::set (CmtError::path_not_found, name);
 
   line  = name;
@@ -3157 +3789 @@
   if (m_stamps)
     {
-      cmt_string stamp_output_base = constituent.name;
+      cmt_string stamp_output_base = m_name;
+      //      cmt_string stamp_output_base = constituent.name;
       stamp_output_base += "_deps";
 
@@ -3165 +3798 @@
       if (!CmtSystem::mkdir (stamp_output))
         {
-          CmtMessage::error ("Cannot create the binary output directory for this constituent " + stamp_output);
-          //      cerr << "Cannot create the binary output directory for this constituent" << endl;
+          CmtError::set (CmtError::file_access_error, 
+                         + "Cannot create directory " + stamp_output
+                         + " for " + m_name);
+          return line;
         }
 
@@ -3185 +3820 @@
       if (CmtSystem::test_file (stamp_output))
         {
-          old_stamp.read (stamp_output);
-        }
-
-      if (line != old_stamp)
-        {
-          line.write (stamp_output);
+          if (!old_stamp.read (stamp_output))
+            {
+              CmtError::set (CmtError::file_access_error, stamp_output);
+              return line;
+            }
+          //      old_stamp.read (stamp_output);
+        }
+
+      if (line != old_stamp.substr(0, old_stamp.size () - 1))
+        {
+          if (!(line + "\n").write (stamp_output))
+            {
+              CmtError::set (CmtError::file_access_error, stamp_output);
+              return line;
+            }
+          //      (line + "\n").write (stamp_output);
         }
     }
@@ -3198 +3843 @@
 
 //--------------------------------------------------
-void DependencyGenerator::prepare_header_file_filters ()
-{
-//   Use::UsePtrVector& uses = Use::get_ordered_uses ();
-  Use::UsePtrVector uses (Use::get_ordered_uses ());
-  uses.push_back (&Use::current ());
-  for (int i = uses.size () - 1; i >= 0; i--)
-    {
-      Use* use = uses[i];
-      if (use->discarded) continue;
-      if (use->m_hidden) continue;
-      if (!use->located ()) continue;
-
-      cmt_string package_name = use->get_package_name ();
-      if (package_name == "CMT") continue;
-
-      Symbol* filter_macro = Symbol::find (package_name + "_header_file_filter");
-      if (filter_macro == 0) continue;
-
-      Symbol* stamp_macro = Symbol::find (package_name + "_header_file_stamp");
-      cmt_string stamp;
-      if (stamp_macro != 0)
-        {
-          stamp = stamp_macro->resolve_macro_value ();
-        }
-      else
-        {
-          use->get_full_path (stamp);
-          stamp += CmtSystem::file_separator ();
-          if (use->style == mgr_style) stamp += "mgr";
-          else stamp += "cmt";
-          stamp += CmtSystem::file_separator ();
-          stamp += "cmt_header_file.stamp";
-          //stamp += "cmt_all_headers.stamp";
-          //<package>/cmt/cmt_all_headers.stamp
-        }
-      if (!CmtSystem::test_file (stamp)) continue;
-
-      cmt_regexp* filter = new cmt_regexp (filter_macro->resolve_macro_value ());
-      assert (filter != 0);
-
-      m_deps_builder.add_header_filter (use, filter, stamp);
-    }
-}
+int DependencyGenerator::fill_dependencies (cmt_string& dependencies)
+{
+  CmtSystem::cmt_string_vector sources;
+  for (int i = 0; i < m_source_files.size (); i++)
+    {
+      const SourceFile& file = m_source_files[i];
+      sources.push_back (file.name ());
+    }
+  return fill_dependencies (dependencies, sources);
+}
+
+//--------------------------------------------------
+int DependencyGenerator::fill_dependencies (cmt_string& dependencies,
+                                            const CmtSystem::cmt_string_vector& sources)
+{
+  int retval (0);
+  cmt_string file_name;
+  cmt_string compressed_name;
+
+  for (int i = 0; i < sources.size (); i++)
+    {
+      file_name = sources[i];
+      //set_full_name (full_name, file_name);
+      CmtSystem::reduce_file_separators (file_name);
+      if (file_name == "") continue;
+      CmtSystem::compress_path (file_name, compressed_name);
+      file_name = compressed_name;
+      //cerr << "file_name: " << file_name << endl;     
+      if (file_name == "") continue;
+
+      const cmt_string& line = build (file_name);
+      if (CmtError::has_pending_error ())
+        {
+          //      if (CmtError::get_last_error_code () == CmtError::file_access_error)
+          return -1;
+        }
+      
+      //cerr << "line: " << line << endl;     
+      add_line_to_text (line, dependencies);
+      //cerr << "dependencies: " << dependencies << endl;     
+    }
+
+  return retval;
+}
+
+//--------------------------------------------------
+int DependencyGenerator::set_source_files (const CmtSystem::cmt_string_vector& files)
+{
+  m_source_files.clear ();
+
+  for (int j = 0; j < files.size (); j++)
+    {
+      const cmt_string& name = files[j];
+      if (name == "") continue;
+
+      bool included = false;
+      for (int k = m_source_files.size () - 1; k >= 0; k--)
+        if (m_source_files[k].name () == name)
+          {
+            included = true;
+            break;
+          }
+      if (included) continue;
+      
+      SourceFile& source = m_source_files.add ();
+      source.set (name, Language::null (), "");
+    }
+      
+  if (m_source_files.size ()) return m_source_files.size ();
+  else return set_source_files ();
+}
+
+//--------------------------------------------------
+int DependencyGenerator::set_source_files ()
+{
+  if (0 == m_constituent && 0 != m_name.size ())
+    m_constituent = Constituent::find (m_name);
+  if (0 == m_constituent) return 0;
+
+  m_source_files.clear ();
+
+  const CmtSystem::cmt_string_vector& sources = m_constituent->modules;
+  const cmt_vector<cmt_regexp>& excludes = m_constituent->exclude_exprs;
+  const cmt_vector<cmt_regexp>& selects = m_constituent->select_exprs;
+
+  cmt_string file_name, full_name;
+  cmt_string compressed_name;
+  cmt_string visited, token;
+
+  for (int i = 0; i < sources.size (); i++)
+    {
+      file_name = sources[i];
+      set_full_name (full_name, file_name);
+      if (full_name == "") continue;
+      
+      CmtSystem::compress_path (full_name, compressed_name);
+      full_name = compressed_name;
+      
+      static CmtSystem::cmt_string_vector files;
+      
+      get_all_files (full_name, excludes, selects, files);
+      
+      for (int j = 0; j < files.size (); j++)
+        {
+          const cmt_string& name = files[j];
+              
+          if (name == "") continue;
+          
+          cmt_string suffix;
+          CmtSystem::get_suffix (name, suffix);
+          Language& language = Language::find_with_suffix (suffix);
+
+          if ((m_constituent->type == Application || m_constituent->type == Library)
+              && language != Language::null () && language.native_dependencies ())
+            continue;
+
+          bool included = false;
+          for (int k = m_source_files.size () - 1; k >= 0; k--)
+            if (m_source_files[k].name () == name)
+              {
+                included = true;
+                break;
+              }
+          if (included) continue;
+          
+          SourceFile& source = m_source_files.add ();
+          source.set (name, language, "");
+        }
+    }
+  return m_source_files.size ();
+}
+
+//--------------------------------------------------
+/**
+ *  Returns 0, if each file in files is found in m_source_files,
+ *  otherwise returns 1
+ */
+//--------------------------------------------------
+int DependencyGenerator::validate (const CmtSystem::cmt_string_vector& files) const
+{
+  int n_invalid = 0;
+  for (int i = 0; i < files.size (); i++)
+    {
+      bool valid = false;
+      for (int j = 0; j < m_source_files.size (); j++)
+        if (files[i] == m_source_files[j].name ())
+          {
+            valid = true;
+            break;
+          }
+      if (!valid)
+        {
+          n_invalid += 1;
+          break;
+        }
+    }
+
+  return n_invalid;
+}