ENH: big change that includes immediate subdir support, removing the notion of inherited commands, makefiles no longer read in the parent makefiles but instead inherit thier parent makefiles current settings

63 files changed, 465 insertions, 774 deletions

diff --git a/Source/cmAddDefinitionsCommand.h b/Source/cmAddDefinitionsCommand.h
index 7b63221..f2ab1a3 100644
--- a/Source/cmAddDefinitionsCommand.h
+++ b/Source/cmAddDefinitionsCommand.h
@@ -43,12 +43,6 @@ public:
   virtual bool InitialPass(std::vector<std::string> const& args);
 
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() {return true;}
-
-  /**
    * The name of the command as specified in CMakeList.txt.
    */
   virtual const char* GetName() {return "ADD_DEFINITIONS";}
diff --git a/Source/cmAddTestCommand.cxx b/Source/cmAddTestCommand.cxx
index ec04928..28ee2d7 100644
--- a/Source/cmAddTestCommand.cxx
+++ b/Source/cmAddTestCommand.cxx
@@ -60,7 +60,7 @@ void cmAddTestCommand::FinalPass()
 
     std::vector<std::string>::iterator it;
 
-  // for each arg in the test
+    // for each arg in the test
     fout << "ADD_TEST(";
     it = m_Args.begin();
     fout << (*it).c_str();
diff --git a/Source/cmBootstrapCommands.cxx b/Source/cmBootstrapCommands.cxx
index b093cde..776b765 100644
--- a/Source/cmBootstrapCommands.cxx
+++ b/Source/cmBootstrapCommands.cxx
@@ -25,6 +25,7 @@
 #include "cmAddDependenciesCommand.cxx"
 #include "cmAddExecutableCommand.cxx"
 #include "cmAddLibraryCommand.cxx"
+#include "cmAddSubDirectoryCommand.cxx"
 #include "cmAddTestCommand.cxx"
 #include "cmBuildCommand.cxx"
 #include "cmBuildNameCommand.cxx"
@@ -81,6 +82,7 @@ void GetBootstrapCommands(std::list<cmCommand*>& commands)
   commands.push_back(new cmAddDependenciesCommand);
   commands.push_back(new cmAddExecutableCommand);
   commands.push_back(new cmAddLibraryCommand);
+  commands.push_back(new cmAddSubDirectoryCommand);
   commands.push_back(new cmAddTestCommand);
   commands.push_back(new cmBuildCommand);
   commands.push_back(new cmBuildNameCommand);
diff --git a/Source/cmBuildCommand.h b/Source/cmBuildCommand.h
index d07b169..255f474 100644
--- a/Source/cmBuildCommand.h
+++ b/Source/cmBuildCommand.h
@@ -42,12 +42,6 @@ public:
   virtual bool InitialPass(std::vector<std::string> const& args);
 
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() {return true;}
-
-  /**
    * The name of the command as specified in CMakeList.txt.
    */
   virtual const char* GetName() {return "BUILD_COMMAND";}
diff --git a/Source/cmBuildNameCommand.h b/Source/cmBuildNameCommand.h
index 79a1845..1cd6369 100644
--- a/Source/cmBuildNameCommand.h
+++ b/Source/cmBuildNameCommand.h
@@ -42,12 +42,6 @@ public:
   virtual bool InitialPass(std::vector<std::string> const& args);
 
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() {return true;}
-
-  /**
    * The name of the command as specified in CMakeList.txt.
    */
   virtual const char* GetName() {return "BUILD_NAME";}
diff --git a/Source/cmCMakeMinimumRequired.h b/Source/cmCMakeMinimumRequired.h
index c947644..05f2f1a 100644
--- a/Source/cmCMakeMinimumRequired.h
+++ b/Source/cmCMakeMinimumRequired.h
@@ -42,12 +42,6 @@ public:
   virtual bool InitialPass(std::vector<std::string> const& args);
 
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() {return true;}
-
-  /**
    * This determines if the command is invoked when in script mode.
    */
   virtual bool IsScriptable() { return true; }
diff --git a/Source/cmCommand.h b/Source/cmCommand.h
index 5380b5a..2f5fc7e 100644
--- a/Source/cmCommand.h
+++ b/Source/cmCommand.h
@@ -82,15 +82,6 @@ public:
   virtual cmCommand* Clone() = 0;
   
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() 
-    {
-    return false;
-    }
-
-  /**
    * This determines if the command is invoked when in script mode.
    */
   virtual bool IsScriptable()
diff --git a/Source/cmCreateTestSourceList.h b/Source/cmCreateTestSourceList.h
index 850c2bc..a258654 100644
--- a/Source/cmCreateTestSourceList.h
+++ b/Source/cmCreateTestSourceList.h
@@ -42,12 +42,6 @@ public:
   virtual bool InitialPass(std::vector<std::string> const& args);
 
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() {return true;}
-
-  /**
    * The name of the command as specified in CMakeList.txt.
    */
   virtual const char* GetName() {return "CREATE_TEST_SOURCELIST";}
diff --git a/Source/cmElseCommand.h b/Source/cmElseCommand.h
index fa2b36b..a085cef 100644
--- a/Source/cmElseCommand.h
+++ b/Source/cmElseCommand.h
@@ -42,12 +42,6 @@ public:
   virtual bool InitialPass(std::vector<std::string> const& args);
 
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() {return true;}
-
-  /**
    * This determines if the command is invoked when in script mode.
    */
   virtual bool IsScriptable() { return true; }
diff --git a/Source/cmEnableLanguageCommand.h b/Source/cmEnableLanguageCommand.h
index 2d8106c..b8965ab 100644
--- a/Source/cmEnableLanguageCommand.h
+++ b/Source/cmEnableLanguageCommand.h
@@ -50,15 +50,6 @@ public:
   virtual const char* GetName() {return "ENABLE_LANGUAGE";}
 
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() 
-    {
-    return true;
-    }
-
-  /**
    * Succinct documentation.
    */
   virtual const char* GetTerseDocumentation() 
diff --git a/Source/cmEnableTestingCommand.cxx b/Source/cmEnableTestingCommand.cxx
index 3b717cd..3662596 100644
--- a/Source/cmEnableTestingCommand.cxx
+++ b/Source/cmEnableTestingCommand.cxx
@@ -15,7 +15,7 @@
 
 =========================================================================*/
 #include "cmEnableTestingCommand.h"
-#include "cmSubDirectory.h"
+#include "cmLocalGenerator.h"
 
 // we do this in the final pass so that we now the subdirs have all 
 // been defined
@@ -27,14 +27,20 @@ bool cmEnableTestingCommand::InitialPass(std::vector<std::string> const&)
 
 void cmEnableTestingCommand::FinalPass()
 {
+  // initialize the DartTestfile files for the tree
+  this->CreateDartTestfileForMakefile(m_Makefile);
+}
+
+void cmEnableTestingCommand::CreateDartTestfileForMakefile(cmMakefile *mf)
+{
   // Create a full path filename for output Testfile
   std::string fname;
-  fname = m_Makefile->GetStartOutputDirectory();
+  fname = mf->GetStartOutputDirectory();
   fname += "/";
   fname += "DartTestfile.txt";
   
-  cmSystemTools::MakeDirectory(m_Makefile->GetStartOutputDirectory());
-
+  cmSystemTools::MakeDirectory(mf->GetStartOutputDirectory());
+  
   // Open the output Testfile
   std::ofstream fout(fname.c_str());
   if (!fout)
@@ -46,9 +52,9 @@ void cmEnableTestingCommand::FinalPass()
   
   fout << "# CMake generated Testfile for " << std::endl
        << "#\tSource directory: "
-       << m_Makefile->GetStartDirectory()
+       << mf->GetStartDirectory()
        << std::endl
-       << "#\tBuild directory: " << m_Makefile->GetStartOutputDirectory()
+       << "#\tBuild directory: " << mf->GetStartOutputDirectory()
        << std::endl
        << "# " << std::endl
        << "# This file replicates the SUBDIRS() and ADD_TEST() commands from the source"
@@ -62,23 +68,23 @@ void cmEnableTestingCommand::FinalPass()
        << "# Duh :-)" << std::endl << std::endl;
 
   // get our output directory
-  std::string outDir = m_Makefile->GetStartOutputDirectory();
+  std::string outDir = mf->GetStartOutputDirectory();
   outDir += "/";
   
   // write out the subdirs for the current directory
-  if (!m_Makefile->GetSubDirectories().empty())
+  std::vector<cmLocalGenerator *>& children = 
+    mf->GetLocalGenerator()->GetChildren();
+  
+  unsigned int i;
+  if (children.size())
     {
     fout << "SUBDIRS(";
-    const std::vector<cmSubDirectory>& subdirs 
-      = m_Makefile->GetSubDirectories();
-    std::vector<cmSubDirectory>::const_iterator i = subdirs.begin();
-    std::string binP = (*i).BinaryPath;
+    std::string binP = children[0]->GetMakefile()->GetStartOutputDirectory();
     cmSystemTools::ReplaceString(binP, outDir.c_str(), "");
     fout << binP.c_str();
-    ++i;
-    for(; i != subdirs.end(); ++i)
+    for(i = 1; i < children.size(); ++i)
       {
-      binP = (*i).BinaryPath;
+      binP = children[i]->GetMakefile()->GetStartOutputDirectory();
       cmSystemTools::ReplaceString(binP, outDir.c_str(), "");
       fout << " " << binP.c_str();
       }
@@ -86,6 +92,16 @@ void cmEnableTestingCommand::FinalPass()
     }
   fout.close();  
   
+  // then recurse
+  if (children.size())
+    {
+    for(i = 0; i < children.size(); ++i)
+      {
+      this->CreateDartTestfileForMakefile(children[i]->GetMakefile());
+      }
+    }
+  
+  
   return;
 }
 
diff --git a/Source/cmEnableTestingCommand.h b/Source/cmEnableTestingCommand.h
index d03b218..3c5f01b 100644
--- a/Source/cmEnableTestingCommand.h
+++ b/Source/cmEnableTestingCommand.h
@@ -44,12 +44,6 @@ public:
     }
 
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() {return true;}
-
-  /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
    */
@@ -90,6 +84,10 @@ public:
     }
   
   cmTypeMacro(cmEnableTestingCommand, cmCommand);
+
+  ///! method to recurse and write the DartTestfiles
+  void CreateDartTestfileForMakefile(cmMakefile *mf);
+  
 };
 
 
diff --git a/Source/cmEndForEachCommand.h b/Source/cmEndForEachCommand.h
index 3a65df9..e50a911 100644
--- a/Source/cmEndForEachCommand.h
+++ b/Source/cmEndForEachCommand.h
@@ -48,12 +48,6 @@ public:
   virtual bool InitialPass(std::vector<std::string> const&) {return false;}
 
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() {return true;}
-
-  /**
    * This determines if the command is invoked when in script mode.
    */
   virtual bool IsScriptable() { return true; }
diff --git a/Source/cmEndIfCommand.h b/Source/cmEndIfCommand.h
index 230637d..467f95c 100644
--- a/Source/cmEndIfCommand.h
+++ b/Source/cmEndIfCommand.h
@@ -42,12 +42,6 @@ public:
   virtual bool InitialPass(std::vector<std::string> const& args);
 
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() {return true;}
-
-  /**
    * This determines if the command is invoked when in script mode.
    */
   virtual bool IsScriptable() { return true; }
diff --git a/Source/cmEndWhileCommand.h b/Source/cmEndWhileCommand.h
index 0b401e7..15cb1f2 100644
--- a/Source/cmEndWhileCommand.h
+++ b/Source/cmEndWhileCommand.h
@@ -48,12 +48,6 @@ public:
   virtual bool InitialPass(std::vector<std::string> const&) {return false;}
 
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() {return true;}
-
-  /**
    * This determines if the command is invoked when in script mode.
    */
   virtual bool IsScriptable() { return true; }
diff --git a/Source/cmFileCommand.h b/Source/cmFileCommand.h
index 5d00acf..71bca90 100644
--- a/Source/cmFileCommand.h
+++ b/Source/cmFileCommand.h
@@ -41,12 +41,6 @@ public:
   virtual bool InitialPass(std::vector<std::string> const& args);
 
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() {return true;}
-
-  /**
    * This determines if the command is invoked when in script mode.
    */
   virtual bool IsScriptable() { return true; }
diff --git a/Source/cmFindFileCommand.h b/Source/cmFindFileCommand.h
index 21c07eb..12d1f75 100644
--- a/Source/cmFindFileCommand.h
+++ b/Source/cmFindFileCommand.h
@@ -45,12 +45,6 @@ public:
   virtual bool InitialPass(std::vector<std::string> const& args);
 
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() { return false;  }
-
-  /**
    * This determines if the command is invoked when in script mode.
    */
   virtual bool IsScriptable() { return true; }
diff --git a/Source/cmFindLibraryCommand.h b/Source/cmFindLibraryCommand.h
index 42fc3bd..b5f0f7b 100644
--- a/Source/cmFindLibraryCommand.h
+++ b/Source/cmFindLibraryCommand.h
@@ -45,12 +45,6 @@ public:
   virtual bool InitialPass(std::vector<std::string> const& args);
 
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() {return false;}
-
-  /**
    * This determines if the command is invoked when in script mode.
    */
   virtual bool IsScriptable() { return true; }
diff --git a/Source/cmFindPackageCommand.cxx b/Source/cmFindPackageCommand.cxx
index 9c2aa33..c917ecc 100644
--- a/Source/cmFindPackageCommand.cxx
+++ b/Source/cmFindPackageCommand.cxx
@@ -388,7 +388,7 @@ std::string cmFindPackageCommand::SearchForConfig() const
 //----------------------------------------------------------------------------
 bool cmFindPackageCommand::ReadListFile(const char* f)
 {
-  if(m_Makefile->ReadListFile(m_Makefile->GetCurrentListFile(), f))
+  if(m_Makefile->ReadListFile(m_Makefile->GetCurrentListFile(),f))
     {
     return true;
     }
diff --git a/Source/cmFindPackageCommand.h b/Source/cmFindPackageCommand.h
index 8a90a1d..144941d 100644
--- a/Source/cmFindPackageCommand.h
+++ b/Source/cmFindPackageCommand.h
@@ -35,9 +35,6 @@ public:
     return new cmFindPackageCommand;
     }
 
-  /** This command is inherited. */
-  virtual bool IsInherited() {return true;}
-  
   /**
    * This is called when the command is first encountered in
    * the CMakeLists.txt file.
diff --git a/Source/cmFindPathCommand.h b/Source/cmFindPathCommand.h
index bafc450..6553ca0 100644
--- a/Source/cmFindPathCommand.h
+++ b/Source/cmFindPathCommand.h
@@ -45,12 +45,6 @@ public:
   virtual bool InitialPass(std::vector<std::string> const& args);
 
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() {return false;}
-
-  /**
    * This determines if the command is invoked when in script mode.
    */
   virtual bool IsScriptable() { return true; }
diff --git a/Source/cmFindProgramCommand.h b/Source/cmFindProgramCommand.h
index 83d840b..dd2aa10 100644
--- a/Source/cmFindProgramCommand.h
+++ b/Source/cmFindProgramCommand.h
@@ -45,12 +45,6 @@ public:
   virtual bool InitialPass(std::vector<std::string> const& args);
 
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() { return false;  }
-
-  /**
    * This determines if the command is invoked when in script mode.
    */
   virtual bool IsScriptable() { return true; }
diff --git a/Source/cmForEachCommand.h b/Source/cmForEachCommand.h
index 64602c9..6681729 100644
--- a/Source/cmForEachCommand.h
+++ b/Source/cmForEachCommand.h
@@ -64,12 +64,6 @@ public:
   virtual bool InitialPass(std::vector<std::string> const& args);
 
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() {return true;}
-
-  /**
    * This determines if the command is invoked when in script mode.
    */
   virtual bool IsScriptable() { return true; }
diff --git a/Source/cmGetFilenameComponentCommand.h b/Source/cmGetFilenameComponentCommand.h
index 4aee472..fe490dd 100644
--- a/Source/cmGetFilenameComponentCommand.h
+++ b/Source/cmGetFilenameComponentCommand.h
@@ -43,12 +43,6 @@ public:
   virtual bool InitialPass(std::vector<std::string> const& args);
 
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() { return true;  }
-
-  /**
    * This determines if the command is invoked when in script mode.
    */
   virtual bool IsScriptable() { return true; }
diff --git a/Source/cmGlobalGenerator.cxx b/Source/cmGlobalGenerator.cxx
index 9dc56c8..8984831 100644
--- a/Source/cmGlobalGenerator.cxx
+++ b/Source/cmGlobalGenerator.cxx
@@ -18,7 +18,6 @@
 #include "cmLocalGenerator.h"
 #include "cmake.h"
 #include "cmMakefile.h"
-#include "cmSubDirectory.h"
 
 #include <stdlib.h> // required for atof
 
@@ -492,13 +491,24 @@ void cmGlobalGenerator::Configure()
   m_LocalGenerators.push_back(lg);
 
   // set the Start directories
-  lg->GetMakefile()->SetStartDirectory(m_CMakeInstance->GetStartDirectory());
-  lg->GetMakefile()->SetStartOutputDirectory(m_CMakeInstance->GetStartOutputDirectory());
+  lg->GetMakefile()->SetStartDirectory
+    (m_CMakeInstance->GetStartDirectory());
+  lg->GetMakefile()->SetStartOutputDirectory
+    (m_CMakeInstance->GetStartOutputDirectory());
   lg->GetMakefile()->MakeStartDirectoriesCurrent();
   
   // now do it
-  this->RecursiveConfigure(lg,0.0f,0.9f);
-
+  lg->Configure();
+  
+  // update the cache entry for the number of local generators, this is used
+  // for progress
+  char num[100];
+  sprintf(num,"%d",m_LocalGenerators.size());
+  this->GetCMakeInstance()->AddCacheEntry
+    ("CMAKE_NUMBER_OF_LOCAL_GENERATORS", num,
+     "number of local generators",
+                                          cmCacheManager::INTERNAL);
+  
   std::set<cmStdString> notFoundMap;
   // after it is all done do a ConfigureFinalPass
   cmCacheManager* manager = 0;
@@ -506,7 +516,8 @@ void cmGlobalGenerator::Configure()
     {
     manager = m_LocalGenerators[i]->GetMakefile()->GetCacheManager();
     m_LocalGenerators[i]->ConfigureFinalPass();
-    cmTargets const& targets = m_LocalGenerators[i]->GetMakefile()->GetTargets(); 
+    cmTargets const& targets = 
+      m_LocalGenerators[i]->GetMakefile()->GetTargets(); 
     for (cmTargets::const_iterator l = targets.begin();
          l != targets.end(); l++)
       {
@@ -535,7 +546,7 @@ void cmGlobalGenerator::Configure()
           }
         }
       m_CMakeInstance->UpdateProgress("Configuring", 
-                                    0.9f+0.1f*(i+1.0f)/m_LocalGenerators.size());
+                                      0.9f+0.1f*(i+1.0f)/m_LocalGenerators.size());
       m_LocalGenerators[i]->GetMakefile()->CheckInfiniteLoops();
       }
     }
@@ -572,52 +583,13 @@ void cmGlobalGenerator::Configure()
     }
 }
 
-
-// loop through the directories creating cmLocalGenerators and Configure()
-void cmGlobalGenerator::RecursiveConfigure(cmLocalGenerator *lg, 
-                                           float startProgress, 
-                                           float endProgress)
-{
-  // configure the current directory
-  lg->Configure();
-                                  
-  // get all the subdirectories
-  std::vector<cmSubDirectory> subdirs = 
-    lg->GetMakefile()->GetSubDirectories();
-  
-  float progressPiece = (endProgress - startProgress)/(1.0f+subdirs.size());
-  m_CMakeInstance->UpdateProgress("Configuring",
-                                  startProgress + progressPiece);
-  
-  // for each subdir recurse
-  std::vector<cmSubDirectory>::const_iterator sdi = subdirs.begin();
-  int i;
-  for (i = 0; sdi != subdirs.end(); ++sdi, ++i)
-    {
-    cmLocalGenerator *lg2 = this->CreateLocalGenerator();
-    lg2->SetParent(lg);
-    m_LocalGenerators.push_back(lg2);
-    
-    // add the subdir to the start output directory
-    lg2->GetMakefile()->SetStartOutputDirectory(sdi->BinaryPath.c_str());
-    lg2->SetExcludeAll(!sdi->IncludeTopLevel);
-    // add the subdir to the start source directory
-    lg2->GetMakefile()->SetStartDirectory(sdi->SourcePath.c_str());
-    lg2->GetMakefile()->MakeStartDirectoriesCurrent();
-    
-    this->RecursiveConfigure(lg2, 
-                             startProgress + (i+1.0f)*progressPiece,
-                             startProgress + (i+2.0f)*progressPiece);
-    }
-}
-
 void cmGlobalGenerator::Generate()
 {
   // For each existing cmLocalGenerator
   unsigned int i;
   for (i = 0; i < m_LocalGenerators.size(); ++i)
     {
-    m_LocalGenerators[i]->Generate(true);
+    m_LocalGenerators[i]->Generate();
     m_LocalGenerators[i]->GenerateInstallRules();
     m_CMakeInstance->UpdateProgress("Generating", 
                                     (i+1.0f)/m_LocalGenerators.size());
@@ -753,6 +725,30 @@ int cmGlobalGenerator::Build(
   return retVal;
 }
 
+void cmGlobalGenerator::AddLocalGenerator(cmLocalGenerator *lg)
+{
+  m_LocalGenerators.push_back(lg); 
+
+  // update progress
+  // estimate how many lg there will be
+  const char *numGenC = 
+    m_CMakeInstance->GetCacheManager()->GetCacheValue
+    ("CMAKE_NUMBER_OF_LOCAL_GENERATORS");
+  
+  if (!numGenC)
+    {
+    return;
+    }
+  
+  int numGen = atoi(numGenC);
+  float prog = 0.9f*m_LocalGenerators.size()/numGen;
+  if (prog > 0.9f)
+    {
+    prog = 0.9f;
+    }
+  m_CMakeInstance->UpdateProgress("Configuring", prog);
+}
+
 cmLocalGenerator *cmGlobalGenerator::CreateLocalGenerator()
 {
   cmLocalGenerator *lg = new cmLocalGenerator;
diff --git a/Source/cmGlobalGenerator.h b/Source/cmGlobalGenerator.h
index a16b88c..4ca2be6 100644
--- a/Source/cmGlobalGenerator.h
+++ b/Source/cmGlobalGenerator.h
@@ -109,6 +109,8 @@ public:
 
   void SetConfiguredFilesPath(const char* s){m_ConfiguredFilesPath = s;}
   void GetLocalGenerators(std::vector<cmLocalGenerator *>&g) { g = m_LocalGenerators;}
+  void AddLocalGenerator(cmLocalGenerator *lg);
+  
   static int s_TryCompileTimeout;
   
   bool GetForceUnixPaths() {return m_ForceUnixPaths;}
@@ -149,9 +151,6 @@ protected:
   // map from project name to vector of local generators in that project
   std::map<cmStdString, std::vector<cmLocalGenerator*> > m_ProjectMap;
 
-  ///! used by Configure()
-  void RecursiveConfigure(cmLocalGenerator *lg, float start, float end);
-  
   ///! Find a target by name by searching the local generators.
   cmTarget* FindTarget(const char* project, const char* name);
 private:
diff --git a/Source/cmIfCommand.h b/Source/cmIfCommand.h
index af6dc7b..44d8558 100644
--- a/Source/cmIfCommand.h
+++ b/Source/cmIfCommand.h
@@ -82,12 +82,6 @@ public:
     }
   
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() {return true;}
-
-  /**
    * This determines if the command is invoked when in script mode.
    */
   virtual bool IsScriptable() { return true; }
diff --git a/Source/cmIncludeCommand.h b/Source/cmIncludeCommand.h
index 8df9a36..2a7a726 100644
--- a/Source/cmIncludeCommand.h
+++ b/Source/cmIncludeCommand.h
@@ -45,12 +45,6 @@ public:
   virtual bool InitialPass(std::vector<std::string> const& args);
 
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() {return true;}
-
-  /**
    * This determines if the command is invoked when in script mode.
    */
   virtual bool IsScriptable() { return true; }
diff --git a/Source/cmIncludeDirectoryCommand.h b/Source/cmIncludeDirectoryCommand.h
index 9031c3c..0249f9f 100644
--- a/Source/cmIncludeDirectoryCommand.h
+++ b/Source/cmIncludeDirectoryCommand.h
@@ -43,12 +43,6 @@ public:
   virtual bool InitialPass(std::vector<std::string> const& args);
 
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() {return true;}
-
-  /**
    * The name of the command as specified in CMakeList.txt.
    */
   virtual const char* GetName() { return "INCLUDE_DIRECTORIES";}
diff --git a/Source/cmIncludeRegularExpressionCommand.h b/Source/cmIncludeRegularExpressionCommand.h
index c80414d..f7fc412 100644
--- a/Source/cmIncludeRegularExpressionCommand.h
+++ b/Source/cmIncludeRegularExpressionCommand.h
@@ -49,15 +49,6 @@ public:
   virtual const char* GetName() {return "INCLUDE_REGULAR_EXPRESSION";}
 
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() 
-    {
-    return true;
-    }
-
-  /**
    * Succinct documentation.
    */
   virtual const char* GetTerseDocumentation() 
diff --git a/Source/cmLinkDirectoriesCommand.h b/Source/cmLinkDirectoriesCommand.h
index d7934fe..cb88cd9 100644
--- a/Source/cmLinkDirectoriesCommand.h
+++ b/Source/cmLinkDirectoriesCommand.h
@@ -45,12 +45,6 @@ public:
   virtual bool InitialPass(std::vector<std::string> const& args);
 
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() { return true;  }
-
-  /**
    * The name of the command as specified in CMakeList.txt.
    */
   virtual const char* GetName() { return "LINK_DIRECTORIES";}
diff --git a/Source/cmLinkLibrariesCommand.h b/Source/cmLinkLibrariesCommand.h
index c9b7c53..bd6e80e 100644
--- a/Source/cmLinkLibrariesCommand.h
+++ b/Source/cmLinkLibrariesCommand.h
@@ -44,12 +44,6 @@ public:
   virtual bool InitialPass(std::vector<std::string> const& args);
 
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() {return true;}
-  
-  /**
    * The name of the command as specified in CMakeList.txt.
    */
   virtual const char* GetName() { return "LINK_LIBRARIES";}
diff --git a/Source/cmLoadCacheCommand.h b/Source/cmLoadCacheCommand.h
index 40d6cf8..24892bb 100644
--- a/Source/cmLoadCacheCommand.h
+++ b/Source/cmLoadCacheCommand.h
@@ -42,12 +42,6 @@ public:
   virtual bool InitialPass(std::vector<std::string> const& args);
 
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() {return true;}
-
-  /**
    * The name of the command as specified in CMakeList.txt.
    */
   virtual const char* GetName() { return "LOAD_CACHE";}
diff --git a/Source/cmLoadCommandCommand.cxx b/Source/cmLoadCommandCommand.cxx
index fcdc045..db3b6c5 100644
--- a/Source/cmLoadCommandCommand.cxx
+++ b/Source/cmLoadCommandCommand.cxx
@@ -60,14 +60,6 @@ public:
   virtual void FinalPass();
 
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() {
-    return (info.m_Inherited != 0 ? true : false);
-  }
-  
-  /**
    * The name of the command as specified in CMakeList.txt.
    */
   virtual const char* GetName() { return info.Name; }
diff --git a/Source/cmLoadCommandCommand.h b/Source/cmLoadCommandCommand.h
index aae0342..1ffb225 100644
--- a/Source/cmLoadCommandCommand.h
+++ b/Source/cmLoadCommandCommand.h
@@ -42,12 +42,6 @@ public:
   virtual bool InitialPass(std::vector<std::string> const& args);
 
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() {return true;}
-
-  /**
    * The name of the command as specified in CMakeList.txt.
    */
   virtual const char* GetName() {return "LOAD_COMMAND";}
diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx
index 504b624..f504647 100644
--- a/Source/cmLocalGenerator.cxx
+++ b/Source/cmLocalGenerator.cxx
@@ -20,7 +20,6 @@
 #include "cmMakefile.h"
 #include "cmGeneratedFileStream.h"
 #include "cmSourceFile.h"
-#include "cmSubDirectory.h"
 #include "cmOrderLinkDirectories.h"
 
 cmLocalGenerator::cmLocalGenerator()
@@ -32,6 +31,7 @@ cmLocalGenerator::cmLocalGenerator()
   m_WindowsShell = false;
   m_IgnoreLibPrefix = false;
   m_UseRelativePaths = false;
+  this->Configured = false;
 }
 
 cmLocalGenerator::~cmLocalGenerator()
@@ -53,6 +53,20 @@ void cmLocalGenerator::Configure()
   currentStart += "/CMakeLists.txt";
   m_Makefile->ReadListFile(currentStart.c_str());
 
+  // at the end of the ReadListFile handle any old style subdirs
+  // first get all the subdirectories
+  std::vector<cmLocalGenerator *> subdirs = this->GetChildren();
+  
+  // for each subdir recurse
+  std::vector<cmLocalGenerator *>::iterator sdi = subdirs.begin();
+  for (; sdi != subdirs.end(); ++sdi)
+    {
+    if (!(*sdi)->Configured)
+      {
+      m_Makefile->ConfigureSubDirectory(*sdi);
+      }
+    }  
+  
   // Setup the current output directory components for use by
   // ConvertToRelativePath.
   std::string outdir =
@@ -62,6 +76,8 @@ void cmLocalGenerator::Configure()
   // Check whether relative paths should be used for optionally
   // relative paths.
   m_UseRelativePaths = m_Makefile->IsOn("CMAKE_USE_RELATIVE_PATHS");
+
+  this->Configured = true;
 }
 
 void cmLocalGenerator::SetGlobalGenerator(cmGlobalGenerator *gg)
@@ -316,14 +332,13 @@ void cmLocalGenerator::GenerateInstallRules()
       fout << "INCLUDE(\"" << postinstall << "\")" << std::endl;
       }
     }
-  cmMakefile* mf = this->GetMakefile();
-  if ( !mf->GetSubDirectories().empty() )
+
+  if ( this->Children.size())
     {
-    const std::vector<cmSubDirectory>& subdirs = mf->GetSubDirectories();
-    std::vector<cmSubDirectory>::const_iterator i = subdirs.begin();
-    for(; i != subdirs.end(); ++i)
+    std::vector<cmLocalGenerator*>::const_iterator i = this->Children.begin();
+    for(; i != this->Children.end(); ++i)
       {
-      std::string odir = i->BinaryPath;
+      std::string odir = (*i)->GetMakefile()->GetStartOutputDirectory();
       cmSystemTools::ConvertToUnixSlashes(odir);
       fout << "INCLUDE(\"" <<  odir.c_str() 
            << "/cmake_install.cmake\")" << std::endl;
diff --git a/Source/cmLocalGenerator.h b/Source/cmLocalGenerator.h
index 0ff3725..8d3009b 100644
--- a/Source/cmLocalGenerator.h
+++ b/Source/cmLocalGenerator.h
@@ -39,13 +39,9 @@ public:
   virtual ~cmLocalGenerator();
   
   /**
-   * Generate the makefile for this directory. fromTheTop indicates if this
-   * is being invoked as part of a global Generate or specific to this
-   * directory. The difference is that when done from the Top we might skip
-   * some steps to save time, such as dependency generation for the
-   * makefiles. This is done by a direct invocation from make. 
+   * Generate the makefile for this directory. 
    */
-  virtual void Generate(bool /* fromTheTop */) {};
+  virtual void Generate() {};
 
   /**
    * Process the CMakeLists files for this directory to fill in the
@@ -118,7 +114,12 @@ public:
   
   ///! set/get the parent generator 
   cmLocalGenerator* GetParent(){return m_Parent;}
-  void SetParent(cmLocalGenerator* g) { m_Parent = g;}
+  void SetParent(cmLocalGenerator* g) { m_Parent = g; g->AddChild(this); }
+
+  ///! set/get the children
+  void AddChild(cmLocalGenerator* g) { this->Children.push_back(g); }
+  std::vector<cmLocalGenerator*>& GetChildren() { return this->Children; };
+    
 
   void AddLanguageFlags(std::string& flags, const char* lang);
   void AddSharedFlags(std::string& flags, const char* lang, bool shared);
@@ -185,10 +186,12 @@ protected:
   std::vector<std::string> m_CurrentOutputDirectoryComponents;
   bool m_ExcludeFromAll;
   cmLocalGenerator* m_Parent;
+  std::vector<cmLocalGenerator*> Children;
   std::map<cmStdString, cmStdString> m_LanguageToIncludeFlags;
   bool m_WindowsShell;
   bool m_UseRelativePaths;
   bool m_IgnoreLibPrefix;
+  bool Configured;
 };
 
 #endif
diff --git a/Source/cmLocalKdevelopGenerator.cxx b/Source/cmLocalKdevelopGenerator.cxx
index ae517a3..c7846d8 100644
--- a/Source/cmLocalKdevelopGenerator.cxx
+++ b/Source/cmLocalKdevelopGenerator.cxx
@@ -36,9 +36,3 @@ cmLocalKdevelopGenerator::~cmLocalKdevelopGenerator()
 {
 }
 
-
-void cmLocalKdevelopGenerator::Generate(bool fromTheTop)
-{
-  cmLocalUnixMakefileGenerator2::Generate(fromTheTop); 
-  return;
-}
diff --git a/Source/cmLocalKdevelopGenerator.h b/Source/cmLocalKdevelopGenerator.h
index 1874295..910768a 100644
--- a/Source/cmLocalKdevelopGenerator.h
+++ b/Source/cmLocalKdevelopGenerator.h
@@ -35,7 +35,6 @@ public:
 
   virtual ~cmLocalKdevelopGenerator();
 
-  virtual void Generate(bool fromTheTop);
 };
 
 #endif
diff --git a/Source/cmLocalUnixMakefileGenerator2.cxx b/Source/cmLocalUnixMakefileGenerator2.cxx
index 58053a2..840b439 100644
--- a/Source/cmLocalUnixMakefileGenerator2.cxx
+++ b/Source/cmLocalUnixMakefileGenerator2.cxx
@@ -21,7 +21,6 @@
 #include "cmGlobalGenerator.h"
 #include "cmMakefile.h"
 #include "cmSourceFile.h"
-#include "cmSubDirectory.h"
 #include "cmake.h"
 
 // Include dependency scanners for supported languages.  Only the
@@ -69,16 +68,8 @@ void cmLocalUnixMakefileGenerator2::SetEmptyCommand(const char* cmd)
 }
 
 //----------------------------------------------------------------------------
-void cmLocalUnixMakefileGenerator2::Generate(bool fromTheTop)
+void cmLocalUnixMakefileGenerator2::Generate()
 {
-  // Make sure we never run a local generate.
-  if(!fromTheTop)
-    {
-    cmSystemTools::Error("Local generate invoked in ",
-                         m_Makefile->GetStartOutputDirectory());
-    return;
-    }
-
   // Setup our configuration variables for this directory.
   this->ConfigureOutputPaths();
 
@@ -1314,24 +1305,25 @@ cmLocalUnixMakefileGenerator2
   // boolean is true should be included.  Keep track of the last
   // pre-order and last post-order rule created so that ordering can
   // be enforced.
-  const std::vector<cmSubDirectory>& subdirs = m_Makefile->GetSubDirectories();
   std::string lastPre = "";
   std::string lastPost = "";
-  for(std::vector<cmSubDirectory>::const_iterator
-        i = subdirs.begin(); i != subdirs.end(); ++i)
+  for(std::vector<cmLocalGenerator*>::const_iterator
+        i = this->Children.begin(); i != this->Children.end(); ++i)
     {
-    if(i->IncludeTopLevel)
+    if(!(*i)->GetExcludeAll())
       {
       // Add the subdirectory rule either for pre-order or post-order.
-      if(i->PreOrder)
+      if((*i)->GetMakefile()->GetPreOrder())
         {
         this->WriteSubdirRule(makefileStream, pass, 
-                              i->BinaryPath.c_str(), lastPre);
+                              (*i)->GetMakefile()->GetStartOutputDirectory(), 
+                              lastPre);
         }
       else
         {
         this->WriteSubdirRule(makefileStream, pass, 
-                              i->BinaryPath.c_str(), lastPost);
+                              (*i)->GetMakefile()->GetStartOutputDirectory(), 
+                              lastPost);
         }
       }
     }
diff --git a/Source/cmLocalUnixMakefileGenerator2.h b/Source/cmLocalUnixMakefileGenerator2.h
index 2026abd..63cdc4c 100644
--- a/Source/cmLocalUnixMakefileGenerator2.h
+++ b/Source/cmLocalUnixMakefileGenerator2.h
@@ -85,13 +85,9 @@ public:
   void SetPassMakeflags(bool s){m_PassMakeflags = s;}
 
   /**
-   * Generate the makefile for this directory. fromTheTop indicates if this
-   * is being invoked as part of a global Generate or specific to this
-   * directory. The difference is that when done from the Top we might skip
-   * some steps to save time, such as dependency generation for the
-   * makefiles. This is done by a direct invocation from make.
+   * Generate the makefile for this directory. 
    */
-  virtual void Generate(bool fromTheTop);
+  virtual void Generate();
 
   /** Called from command-line hook to scan dependencies.  */
   static bool ScanDependencies(std::vector<std::string> const& args);
diff --git a/Source/cmLocalVisualStudio6Generator.cxx b/Source/cmLocalVisualStudio6Generator.cxx
index e86983e..5c73194 100644
--- a/Source/cmLocalVisualStudio6Generator.cxx
+++ b/Source/cmLocalVisualStudio6Generator.cxx
@@ -33,7 +33,7 @@ cmLocalVisualStudio6Generator::~cmLocalVisualStudio6Generator()
 }
 
 
-void cmLocalVisualStudio6Generator::Generate(bool /* fromTheTop */)
+void cmLocalVisualStudio6Generator::Generate()
 { 
   std::set<cmStdString> lang;
   lang.insert("C");
diff --git a/Source/cmLocalVisualStudio6Generator.h b/Source/cmLocalVisualStudio6Generator.h
index f4cee58..6e3d459 100644
--- a/Source/cmLocalVisualStudio6Generator.h
+++ b/Source/cmLocalVisualStudio6Generator.h
@@ -40,13 +40,9 @@ public:
   virtual ~cmLocalVisualStudio6Generator();
   
   /**
-   * Generate the makefile for this directory. fromTheTop indicates if this
-   * is being invoked as part of a global Generate or specific to this
-   * directory. The difference is that when done from the Top we might skip
-   * some steps to save time, such as dependency generation for the
-   * makefiles. This is done by a direct invocation from make. 
+   * Generate the makefile for this directory. 
    */
-  virtual void Generate(bool fromTheTop);
+  virtual void Generate();
 
   void OutputDSPFile();
 
diff --git a/Source/cmLocalVisualStudio7Generator.cxx b/Source/cmLocalVisualStudio7Generator.cxx
index a0d1cec..4fa4497 100644
--- a/Source/cmLocalVisualStudio7Generator.cxx
+++ b/Source/cmLocalVisualStudio7Generator.cxx
@@ -32,7 +32,7 @@ cmLocalVisualStudio7Generator::~cmLocalVisualStudio7Generator()
 }
 
 
-void cmLocalVisualStudio7Generator::Generate(bool /* fromTheTop */)
+void cmLocalVisualStudio7Generator::Generate()
 {
   std::set<cmStdString> lang;
   lang.insert("C");
diff --git a/Source/cmLocalVisualStudio7Generator.h b/Source/cmLocalVisualStudio7Generator.h
index a6608bc..0821d36 100644
--- a/Source/cmLocalVisualStudio7Generator.h
+++ b/Source/cmLocalVisualStudio7Generator.h
@@ -41,13 +41,9 @@ public:
   virtual ~cmLocalVisualStudio7Generator();
   
   /**
-   * Generate the makefile for this directory. fromTheTop indicates if this
-   * is being invoked as part of a global Generate or specific to this
-   * directory. The difference is that when done from the Top we might skip
-   * some steps to save time, such as dependency generation for the
-   * makefiles. This is done by a direct invocation from make. 
+   * Generate the makefile for this directory. 
    */
-  virtual void Generate(bool fromTheTop);
+  virtual void Generate();
 
   enum BuildType {STATIC_LIBRARY, DLL, EXECUTABLE, WIN32_EXECUTABLE, UTILITY};
 
diff --git a/Source/cmMacroCommand.cxx b/Source/cmMacroCommand.cxx
index 9db5f16..daf3989 100644
--- a/Source/cmMacroCommand.cxx
+++ b/Source/cmMacroCommand.cxx
@@ -16,214 +16,287 @@
 =========================================================================*/
 #include "cmMacroCommand.h"
 
-bool cmMacroFunctionBlocker::
-IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf) 
+// define the class for macro commands
+class cmMacroHelperCommand : public cmCommand
 {
-  // record commands until we hit the ENDMACRO
-  if (!m_Executing)
+public:
+  cmMacroHelperCommand() {}
+  
+  ///! clean up any memory allocated by the macro
+  ~cmMacroHelperCommand() {};
+  
+  /**
+   * This is a virtual constructor for the command.
+   */
+  virtual cmCommand* Clone() 
+  {
+    cmMacroHelperCommand *newC = new cmMacroHelperCommand;
+    // we must copy when we clone
+    newC->m_Args = this->m_Args;
+    newC->m_Functions = this->m_Functions;
+    return newC;
+  }
+  
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+   */
+  virtual bool InvokeInitialPass(const std::vector<cmListFileArgument>& args);
+
+  virtual bool InitialPass(std::vector<std::string> const& args) 
+  { return false; };
+  
+  /**
+   * The name of the command as specified in CMakeList.txt.
+   */
+  virtual const char* GetName() { return this->m_Args[0].c_str(); }
+  
+  /**
+   * Succinct documentation.
+   */
+  virtual const char* GetTerseDocumentation() 
+  {
+    std::string docs = "Macro named: ";
+    docs += this->GetName();
+    return docs.c_str();
+  }
+  
+  /**
+   * More documentation.
+   */
+  virtual const char* GetFullDocumentation()
+  {
+    return this->GetTerseDocumentation();
+  }
+  
+  cmTypeMacro(cmMacroHelperCommand, cmCommand);
+
+  std::vector<std::string> m_Args;
+  std::vector<cmListFileFunction> m_Functions;
+};
+
+
+bool cmMacroHelperCommand::InvokeInitialPass
+(const std::vector<cmListFileArgument>& args)
+{
+  // Expand the argument list to the macro.
+  std::vector<std::string> expandedArgs;
+  m_Makefile->ExpandArguments(args, expandedArgs);
+  
+  std::string tmps;
+  cmListFileArgument arg;
+  std::string variable;
+
+  // make sure the number of arguments passed is at least the number
+  // required by the signature
+  if (expandedArgs.size() < m_Args.size() - 1)
     {
-    // at the ENDMACRO call we shift gears and start looking for invocations
-    if(lff.m_Name == "ENDMACRO")
-      {
-      std::vector<std::string> expandedArguments;
-      mf.ExpandArguments(lff.m_Arguments, expandedArguments);
-      if(!expandedArguments.empty() && (expandedArguments[0] == m_Args[0]))
-        {
-        m_Executing = true;
-        std::string name = m_Args[0];
-        std::vector<std::string>::size_type cc;
-        name += "(";
-        for ( cc = 0; cc < m_Args.size(); cc ++ )
-          {
-          name += " " + m_Args[cc];
-          }
-        name += " )";
-        mf.AddMacro(m_Args[0].c_str(), name.c_str());
-        return true;
-        }
-      }
-    // if it wasn't an endmacro and we are not executing then we must be
-    // recording
-    m_Functions.push_back(lff);
-    return true;
+    std::string errorMsg = 
+      "Macro invoked with incorrect arguments for macro named: ";
+    errorMsg += m_Args[0];
+    this->SetError(errorMsg.c_str());
+    return false;
     }
   
-  // otherwise the macro has been recorded and we are executing
-  // so we look for macro invocations
-  if(lff.m_Name == m_Args[0])
+  // set the value of argc
+  cmOStringStream argcDefStream;
+  argcDefStream << expandedArgs.size();
+  std::string argcDef = argcDefStream.str();
+  
+  // declare varuiables for ARGV ARGN but do not compute until needed
+  std::string argvDef;
+  std::string argnDef;
+  bool argnDefInitialized = false;
+  bool argvDefInitialized = false;
+  
+  // Invoke all the functions that were collected in the block.
+  cmListFileFunction newLFF;
+  // for each function
+  for(unsigned int c = 0; c < m_Functions.size(); ++c)
     {
-    std::string tmps;
-    cmListFileArgument arg;
-    std::string variable;
-    // Expand the argument list to the macro.
-    std::vector<std::string> expandedArguments;
-    mf.ExpandArguments(lff.m_Arguments, expandedArguments);
-
-    // make sure the number of arguments passed is at least the number
-    // required by the signature
-    if (expandedArguments.size() < m_Args.size() - 1)
+    // Replace the formal arguments and then invoke the command.
+    newLFF.m_Arguments.clear();
+    newLFF.m_Arguments.reserve(m_Functions[c].m_Arguments.size());
+    newLFF.m_Name = m_Functions[c].m_Name;
+    newLFF.m_FilePath = m_Functions[c].m_FilePath;
+    newLFF.m_Line = m_Functions[c].m_Line;
+    // for each argument of the current function
+    for (std::vector<cmListFileArgument>::const_iterator k = 
+           m_Functions[c].m_Arguments.begin();
+         k != m_Functions[c].m_Arguments.end(); ++k)
       {
-      cmOStringStream error;
-      error << "Error in cmake code at\n"
-            << lff.m_FilePath << ":" << lff.m_Line << ":\n"
-            << "Invocation of macro \""
-            << lff.m_Name.c_str() << "\" with incorrect number of arguments.";
-      cmSystemTools::Error(error.str().c_str());
-      return true;
-      }
-
-    // set the value of argc
-    cmOStringStream argcDefStream;
-    argcDefStream << expandedArguments.size();
-    std::string argcDef = argcDefStream.str();
-    
-    // declare varuiables for ARGV ARGN but do not compute until needed
-    std::string argvDef;
-    std::string argnDef;
-    bool argnDefInitialized = false;
-    bool argvDefInitialized = false;
-    
-    // Invoke all the functions that were collected in the block.
-    cmListFileFunction newLFF;
-    // for each function
-    for(unsigned int c = 0; c < m_Functions.size(); ++c)
-      {
-      // Replace the formal arguments and then invoke the command.
-      newLFF.m_Arguments.clear();
-      newLFF.m_Arguments.reserve(m_Functions[c].m_Arguments.size());
-      newLFF.m_Name = m_Functions[c].m_Name;
-      newLFF.m_FilePath = m_Functions[c].m_FilePath;
-      newLFF.m_Line = m_Functions[c].m_Line;
-      // for each argument of the current function
-      for (std::vector<cmListFileArgument>::const_iterator k = 
-             m_Functions[c].m_Arguments.begin();
-           k != m_Functions[c].m_Arguments.end(); ++k)
+      tmps = k->Value;
+      // replace formal arguments
+      for (unsigned int j = 1; j < m_Args.size(); ++j)
         {
-        tmps = k->Value;
-        // replace formal arguments
-        for (unsigned int j = 1; j < m_Args.size(); ++j)
-          {
-          variable = "${";
-          variable += m_Args[j];
-          variable += "}"; 
-          cmSystemTools::ReplaceString(tmps, variable.c_str(),
-                                       expandedArguments[j-1].c_str());
-          }
-        // replace argc
-        cmSystemTools::ReplaceString(tmps, "${ARGC}",argcDef.c_str());
-        
-        // repleace ARGN
-        if (tmps.find("${ARGN}") != std::string::npos)
+        variable = "${";
+        variable += m_Args[j];
+        variable += "}"; 
+        cmSystemTools::ReplaceString(tmps, variable.c_str(),
+                                     expandedArgs[j-1].c_str());
+        }
+      // replace argc
+      cmSystemTools::ReplaceString(tmps, "${ARGC}",argcDef.c_str());
+      
+      // repleace ARGN
+      if (tmps.find("${ARGN}") != std::string::npos)
+        {
+        if (!argnDefInitialized)
           {
-          if (!argnDefInitialized)
+          std::vector<std::string>::const_iterator eit;
+          std::vector<std::string>::size_type cnt = 0;
+          for ( eit = expandedArgs.begin(); eit != expandedArgs.end(); ++eit )
             {
-            std::vector<std::string>::iterator eit;
-            std::vector<std::string>::size_type cnt = 0;
-            for ( eit = expandedArguments.begin();
-                  eit != expandedArguments.end();
-                  ++ eit )
+            if ( cnt >= m_Args.size()-1 )
               {
-              if ( cnt >= m_Args.size()-1 )
+              if ( argnDef.size() > 0 )
                 {
-                if ( argnDef.size() > 0 )
-                  {
-                  argnDef += ";";
-                  }
-                argnDef += *eit;
+                argnDef += ";";
                 }
-              cnt ++;
+              argnDef += *eit;
               }
-            argnDefInitialized = true;
+            cnt ++;
             }
-          cmSystemTools::ReplaceString(tmps, "${ARGN}", argnDef.c_str());
+          argnDefInitialized = true;
           }
+        cmSystemTools::ReplaceString(tmps, "${ARGN}", argnDef.c_str());
+        }
+      
+      // if the current argument of the current function has ${ARGV in it
+      // then try replacing ARGV values
+      if (tmps.find("${ARGV") != std::string::npos)
+        {
+        char argvName[60];
         
-        // if the current argument of the current function has ${ARGV in it
-        // then try replacing ARGV values
-        if (tmps.find("${ARGV") != std::string::npos)
+        // repleace ARGV, compute it only once
+        if (!argvDefInitialized)
           {
-          char argvName[60];
-          
-          // repleace ARGV, compute it only once
-          if (!argvDefInitialized)
+          std::vector<std::string>::const_iterator eit;
+          for ( eit = expandedArgs.begin(); eit != expandedArgs.end(); ++eit )
             {
-            std::vector<std::string>::iterator eit;
-            for ( eit = expandedArguments.begin();
-                  eit != expandedArguments.end();
-                  ++ eit )
+            if ( argvDef.size() > 0 )
               {
-              if ( argvDef.size() > 0 )
-                {
-                argvDef += ";";
-                }
-              argvDef += *eit;
+              argvDef += ";";
               }
-            argvDefInitialized = true;
-            }
-          cmSystemTools::ReplaceString(tmps, "${ARGV}", argvDef.c_str());
-          
-          // also replace the ARGV1 ARGV2 ... etc
-          for (unsigned int t = 0; t < expandedArguments.size(); ++t)
-            {
-            sprintf(argvName,"${ARGV%i}",t);
-            cmSystemTools::ReplaceString(tmps, argvName,
-                                         expandedArguments[t].c_str());
+            argvDef += *eit;
             }
+          argvDefInitialized = true;
           }
+        cmSystemTools::ReplaceString(tmps, "${ARGV}", argvDef.c_str());
         
-        arg.Value = tmps;
-        arg.Quoted = k->Quoted;
-        const char* def =
-          mf.GetDefinition("CMAKE_MACRO_REPORT_DEFINITION_LOCATION");
-        if(def && !cmSystemTools::IsOff(def))
+        // also replace the ARGV1 ARGV2 ... etc
+        for (unsigned int t = 0; t < expandedArgs.size(); ++t)
           {
-          // Report the location of the argument where the macro was
-          // defined.
-          arg.FilePath = k->FilePath;
-          arg.Line = k->Line;
+          sprintf(argvName,"${ARGV%i}",t);
+          cmSystemTools::ReplaceString(tmps, argvName,
+                                       expandedArgs[t].c_str());
+          }
+        }
+      
+      arg.Value = tmps;
+      arg.Quoted = k->Quoted;
+      const char* def =
+        m_Makefile->GetDefinition("CMAKE_MACRO_REPORT_DEFINITION_LOCATION");
+      if(def && !cmSystemTools::IsOff(def))
+        {
+        // Report the location of the argument where the macro was
+        // defined.
+        arg.FilePath = k->FilePath;
+        arg.Line = k->Line;
+        }
+      else
+        {
+        // Report the location of the argument where the macro was
+        // invoked.
+        if (args.size())
+          {
+          arg.FilePath = args[0].FilePath;
+          arg.Line = args[0].Line;
           }
         else
           {
-          // Report the location of the argument where the macro was
-          // invoked.
-          arg.FilePath = lff.m_FilePath;
-          arg.Line = lff.m_Line;
+          arg.FilePath = "Unknown";
+          arg.Line = 0;
           }
-        newLFF.m_Arguments.push_back(arg);
         }
-      if(!mf.ExecuteCommand(newLFF))
+      newLFF.m_Arguments.push_back(arg);
+      }
+    if(!m_Makefile->ExecuteCommand(newLFF))
+      {
+      cmOStringStream error;
+      error << "Error in cmake code at\n"
+            << args[0].FilePath << ":" << args[0].Line << ":\n"
+            << "A command failed during the invocation of macro \""
+            << this->m_Args[0].c_str() << "\".";
+      cmSystemTools::Error(error.str().c_str());
+      return false;
+      }
+    }
+  return true;
+}
+
+bool cmMacroFunctionBlocker::
+IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile &mf) 
+{
+  // record commands until we hit the ENDMACRO
+  // at the ENDMACRO call we shift gears and start looking for invocations
+  if(lff.m_Name == "ENDMACRO")
+    {
+    std::vector<std::string> expandedArguments;
+    mf.ExpandArguments(lff.m_Arguments, expandedArguments);
+    if(!expandedArguments.empty() && (expandedArguments[0] == m_Args[0]))
+      {
+      std::string name = m_Args[0];
+      std::vector<std::string>::size_type cc;
+      name += "(";
+      for ( cc = 0; cc < m_Args.size(); cc ++ )
         {
-        cmOStringStream error;
-        error << "Error in cmake code at\n"
-              << lff.m_FilePath << ":" << lff.m_Line << ":\n"
-              << "A command failed during the invocation of macro \""
-              << lff.m_Name.c_str() << "\".";
-        cmSystemTools::Error(error.str().c_str());
+        name += " " + m_Args[cc];
         }
+      name += " )";
+      mf.AddMacro(m_Args[0].c_str(), name.c_str());
+      
+      // create a new command and add it to cmake
+      cmMacroHelperCommand *f = new cmMacroHelperCommand();
+      f->m_Args = this->m_Args;
+      f->m_Functions = this->m_Functions;
+      mf.AddCommand(f);
+      
+      // remove the function blocker now that the macro is defined
+      mf.RemoveFunctionBlocker(lff);
+      return true;
       }
-    return true;
     }
-
-  // if not an invocation then it is just an ordinary line
-  return false;
+  
+  // if it wasn't an endmacro and we are not executing then we must be
+  // recording
+  m_Functions.push_back(lff);
+  return true;
 }
+  
 
 bool cmMacroFunctionBlocker::
-ShouldRemove(const cmListFileFunction&, cmMakefile &) 
+ShouldRemove(const cmListFileFunction& lff, cmMakefile &mf) 
 {
+  if(lff.m_Name == "ENDMACRO")
+    {
+    std::vector<std::string> expandedArguments;
+    mf.ExpandArguments(lff.m_Arguments, expandedArguments);
+    if(!expandedArguments.empty() && (expandedArguments[0] == m_Args[0]))
+      {
+      return true;
+      }
+    }
   return false;
 }
 
 void cmMacroFunctionBlocker::
 ScopeEnded(cmMakefile &mf) 
 {
-  // macros never leave scope but we should have seen the ENDMACRO call by now
-  if (m_Executing != true)
-    {
-    cmSystemTools::Error("The end of a CMakeLists file was reached with a MACRO statement that was not closed properly. Within the directory: ", 
-                         mf.GetCurrentDirectory(), " with macro ", 
-                         m_Args[0].c_str());
-    }
+  // macros should end with an EndMacro 
+  cmSystemTools::Error("The end of a CMakeLists file was reached with a MACRO statement that was not closed properly. Within the directory: ", 
+                       mf.GetCurrentDirectory(), " with macro ", 
+                       m_Args[0].c_str());
 }
 
 bool cmMacroCommand::InitialPass(std::vector<std::string> const& args)
diff --git a/Source/cmMacroCommand.h b/Source/cmMacroCommand.h
index b0848d1..26d0f85 100644
--- a/Source/cmMacroCommand.h
+++ b/Source/cmMacroCommand.h
@@ -28,7 +28,7 @@
 class cmMacroFunctionBlocker : public cmFunctionBlocker
 {
 public:
-  cmMacroFunctionBlocker() {m_Executing = false;}
+  cmMacroFunctionBlocker() {}
   virtual ~cmMacroFunctionBlocker() {}
   virtual bool IsFunctionBlocked(const cmListFileFunction&, cmMakefile &mf);
   virtual bool ShouldRemove(const cmListFileFunction&, cmMakefile &mf);
@@ -36,7 +36,6 @@ public:
   
   std::vector<std::string> m_Args;
   std::vector<cmListFileFunction> m_Functions;
-  bool m_Executing;
 };
 
 /** \class cmMacroCommand
@@ -62,12 +61,6 @@ public:
   virtual bool InitialPass(std::vector<std::string> const& args);
 
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() {return true;}
-
-  /**
    * This determines if the command is invoked when in script mode.
    */
   virtual bool IsScriptable() { return true; }
diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx
index c3d711c..05c165d 100644
--- a/Source/cmMakefile.cxx
+++ b/Source/cmMakefile.cxx
@@ -73,7 +73,9 @@ cmMakefile::cmMakefile()
   this->AddSourceGroup("CMake Rules", "\\.rule$");
   this->AddDefaultDefinitions();
   m_cmDefineRegex.compile("#cmakedefine[ \t]*([A-Za-z_0-9]*)");
-  }
+
+  this->PreOrder = false;
+}
 
 const char* cmMakefile::GetReleaseVersion()
 {
@@ -248,30 +250,25 @@ bool cmMakefile::ExecuteCommand(const cmListFileFunction& lff)
       (!this->GetCMakeInstance()->GetScriptMode() || 
        usedCommand->IsScriptable()))
       {
-      // if not running in inherit mode or
-      // if the command is inherited then InitialPass it.
-      if(!m_Inheriting || usedCommand->IsInherited())
+      if(!usedCommand->InvokeInitialPass(lff.m_Arguments))
         {
-        if(!usedCommand->InvokeInitialPass(lff.m_Arguments))
-          {
-          cmOStringStream error;
-          error << "Error in cmake code at\n"
-            << lff.m_FilePath << ":" << lff.m_Line << ":\n"
-            << usedCommand->GetError();
-          cmSystemTools::Error(error.str().c_str());
-          result = false;
-          if ( this->GetCMakeInstance()->GetScriptMode() )
-            {
-            cmSystemTools::SetFatalErrorOccured();
-            }
-          }
-        else
+        cmOStringStream error;
+        error << "Error in cmake code at\n"
+              << lff.m_FilePath << ":" << lff.m_Line << ":\n"
+              << usedCommand->GetError();
+        cmSystemTools::Error(error.str().c_str());
+        result = false;
+        if ( this->GetCMakeInstance()->GetScriptMode() )
           {
-          // use the command
-          keepCommand = true;
-          m_UsedCommands.push_back(usedCommand);
+          cmSystemTools::SetFatalErrorOccured();
           }
         }
+      else
+        {
+        // use the command
+        keepCommand = true;
+        m_UsedCommands.push_back(usedCommand);
+        }
       }
     else if ( this->GetCMakeInstance()->GetScriptMode() && !usedCommand->IsScriptable() )
       {
@@ -306,16 +303,9 @@ bool cmMakefile::ExecuteCommand(const cmListFileFunction& lff)
   return result;
 }
 
-// Parse the given CMakeLists.txt file into a list of classes.
-// Reads in current CMakeLists file and all parent CMakeLists files
-// executing all inherited commands in the parents
+// Parse the given CMakeLists.txt file executing all commands
 //
-//   if external is non-zero, this means that we have branched to grab some
-//   commands from a remote list-file (that is, the equivalent of a
-//   #include has been called).  We DO NOT look at the parents of this
-//   list-file, and for all other purposes, the name of this list-file
-//   is "filename" and not "external".
-bool cmMakefile::ReadListFile(const char* filename_in, const char* external_in)
+bool cmMakefile::ReadListFile(const char* filename_in, const char *external_in)
 {
   // used to watch for blockers going out of scope
   // e.g. mismatched IF statement
@@ -358,47 +348,6 @@ bool cmMakefile::ReadListFile(const char* filename_in, const char* external_in)
       }
     }
   
-  // if this is not a remote makefile
-  //  (if it were, this would be called from the "filename" call,
-  //   rather than the "external" call)
-  if (!external)
-    {
-    // is there a parent CMakeLists file that does not go beyond the
-    // Home directory? if so recurse and read in that List file 
-    std::string parentList = this->GetParentListFileName();
-    if (parentList != "")
-      {
-      std::string srcdir = this->GetCurrentDirectory();
-      std::string bindir = this->GetCurrentOutputDirectory();
-      
-      std::string::size_type pos = parentList.rfind('/');
-      this->SetCurrentDirectory(parentList.substr(0, pos).c_str());
-      this->SetCurrentOutputDirectory
-        ((m_HomeOutputDirectory +
-          parentList.substr(m_cmHomeDirectory.size(),
-                            pos - m_cmHomeDirectory.size())).c_str());
-      
-      // if not found, oops
-      if(pos == std::string::npos)
-        {
-        cmSystemTools::Error("Trailing slash not found");
-        }
-      
-      this->ReadListFile(parentList.c_str());
-      
-      // restore the current directory
-      this->SetCurrentDirectory(srcdir.c_str());
-      this->SetCurrentOutputDirectory(bindir.c_str());
-      }
-    }
-  
-  // are we at the start CMakeLists file or are we processing a parent 
-  // lists file
-  //
-  //   this might, or might not be true, irrespective if we are
-  //   off looking at an external makefile.
-  m_Inheriting = (m_cmCurrentDirectory != m_cmStartDirectory);
-                    
   // Now read the input file
   const char *filenametoread= filename;
 
@@ -833,6 +782,36 @@ void cmMakefile::AddLinkDirectory(const char* dir)
     }
 }
 
+void cmMakefile::InitializeFromParent()
+{
+  cmMakefile *parent = m_LocalGenerator->GetParent()->GetMakefile();
+  
+  // copy the definitions
+  this->m_Definitions = parent->m_Definitions;
+
+  // copy include paths
+  this->m_IncludeDirectories = parent->m_IncludeDirectories;
+  
+  // define flags
+  this->m_DefineFlags = parent->m_DefineFlags;
+  
+  // link libraries
+  this->m_LinkLibraries = parent->m_LinkLibraries;
+  
+  // the initial project name
+  this->m_ProjectName = parent->m_ProjectName;
+}
+
+void cmMakefile::ConfigureSubDirectory(cmLocalGenerator *lg2)
+{
+  // copy our variables from the child makefile
+  lg2->GetMakefile()->InitializeFromParent();
+  lg2->GetMakefile()->MakeStartDirectoriesCurrent();
+  
+  // finally configure the subdir
+  lg2->Configure();
+}
+
 void cmMakefile::AddSubDirectory(const char* sub, bool topLevel, bool preorder)
 {
   // the source path must be made full if it isn't already
@@ -854,31 +833,43 @@ void cmMakefile::AddSubDirectory(const char* sub, bool topLevel, bool preorder)
     }
   
   
-  this->AddSubDirectory(srcPath.c_str(), binPath.c_str(), topLevel, preorder);
+  this->AddSubDirectory(srcPath.c_str(), binPath.c_str(), 
+                        topLevel, preorder, false);
 }
 
                         
 void cmMakefile::AddSubDirectory(const char* srcPath, const char *binPath,
-                                 bool topLevel, bool preorder)
+                                 bool topLevel, bool preorder, 
+                                 bool immediate)
 {
+  std::vector<cmLocalGenerator *>& children = m_LocalGenerator->GetChildren();
   // has this directory already been added? If so error
   unsigned int i;
-  for (i = 0; i < m_SubDirectories.size(); ++i)
+  for (i = 0; i < children.size(); ++i)
     {
-    if (m_SubDirectories[i].SourcePath == srcPath)
+    if (srcPath == children[i]->GetMakefile()->GetStartDirectory())
       {
       cmSystemTools::Error("Attempt to add subdirectory multiple times for directory.\n", srcPath);
       return;
       }
     }
   
-  // now add it
-  cmSubDirectory s;
-  s.SourcePath = srcPath;
-  s.BinaryPath = binPath;
-  s.IncludeTopLevel = topLevel;
-  s.PreOrder = preorder;
-  m_SubDirectories.push_back(s);
+  // create a new local generator and set its parent
+  cmLocalGenerator *lg2 = 
+    m_LocalGenerator->GetGlobalGenerator()->CreateLocalGenerator();
+  lg2->SetParent(m_LocalGenerator);
+  m_LocalGenerator->GetGlobalGenerator()->AddLocalGenerator(lg2);
+  
+  // set the subdirs start dirs
+  lg2->GetMakefile()->SetStartDirectory(srcPath);
+  lg2->GetMakefile()->SetStartOutputDirectory(binPath);
+  lg2->SetExcludeAll(!topLevel);
+  lg2->GetMakefile()->SetPreOrder(preorder);
+  
+  if (immediate)
+    {
+    this->ConfigureSubDirectory(lg2);
+    }
 }
 
 void cmMakefile::AddIncludeDirectory(const char* inc, bool before)
@@ -1212,110 +1203,6 @@ void cmMakefile::AddExtraDirectory(const char* dir)
   m_AuxSourceDirectories.push_back(dir);
 }
 
-// return the file name for a parent CMakeLists file. It will return the
-// parent to the CMakeLists file to the m_CurrentDirectory
-
-
-std::string cmMakefile::GetParentListFileName()
-{
-  std::string parentFile;
-
-  bool done = false;
-  cmLocalGenerator *lg = m_LocalGenerator;
-  cmLocalGenerator *lgp = 0;
-  
-  while (!done)
-    {
-    // first find the lg for the current directory
-    if (!strcmp(lg->GetMakefile()->GetStartDirectory(),
-                this->GetCurrentDirectory()))
-      {
-      // now get the parent
-      lgp = lg->GetParent();
-      done = true;
-      }
-    else
-      {
-      lg = lg->GetParent();
-      if (!lg)
-        {
-        return parentFile;
-        }
-      }
-    }
-  
-  // if we are the top then stop
-  if (!lgp)
-    {
-    return parentFile;
-    }
-  
-  // otherwise get the list file for the parent local generator
-  parentFile = lgp->GetMakefile()->GetCurrentDirectory();
-  parentFile += "/CMakeLists.txt";
-  return parentFile;
-}
-
-#if 0
-
-// return the file name for the parent CMakeLists file to the 
-// one passed in. Zero is returned if the CMakeLists file is the
-// one in the home directory or if for some reason a parent cmake lists 
-// file cannot be found.
-std::string cmMakefile::GetParentListFileName(const char *currentFileName)
-{
-  // extract the directory name
-  std::string parentFile;
-  std::string listsDir = currentFileName;
-  std::string::size_type pos = listsDir.rfind('/');
-  // if we could not find the directory return 0
-  if(pos == std::string::npos)
-    {
-    return parentFile;
-    }
-  listsDir = listsDir.substr(0, pos);
-  
-  // if we are in the home directory then stop, return 0
-  if(m_cmHomeDirectory == listsDir)
-    {
-    return parentFile;
-    }
-  
-  // is there a parent directory we can check
-  pos = listsDir.rfind('/');
-  // if we could not find the directory return 0
-  if(pos == std::string::npos)
-    {
-    return parentFile;
-    }
-  listsDir = listsDir.substr(0, pos);
-  
-  // is there a CMakeLists.txt file in the parent directory ?
-  parentFile = listsDir;
-  parentFile += "/CMakeLists.txt";
-  while(!cmSystemTools::FileExists(parentFile.c_str()))
-    {
-    // There is no CMakeLists.txt file in the parent directory.  This
-    // can occur when coming out of a subdirectory resulting from a
-    // SUBDIRS(Foo/Bar) command (coming out of Bar into Foo).  Try
-    // walking up until a CMakeLists.txt is found or the home
-    // directory is hit.
-    
-    // if we are in the home directory then stop, return 0
-    if(m_cmHomeDirectory == listsDir) { return ""; }
-    
-    // is there a parent directory we can check
-    pos = listsDir.rfind('/');
-    // if we could not find the directory return 0
-    if(pos == std::string::npos) { return ""; }
-    listsDir = listsDir.substr(0, pos);
-    parentFile = listsDir;
-    parentFile += "/CMakeLists.txt";
-    }
-
-  return parentFile;
-}
-#endif
 
 // expance CMAKE_BINARY_DIR and CMAKE_SOURCE_DIR in the
 // include and library directories.
diff --git a/Source/cmMakefile.h b/Source/cmMakefile.h
index 2fed10d..3bb7a29 100644
--- a/Source/cmMakefile.h
+++ b/Source/cmMakefile.h
@@ -24,8 +24,6 @@
 #include "cmListFileCache.h"
 #include "cmCacheManager.h"
 
-#include "cmSubDirectory.h"
-
 #include <cmsys/RegularExpression.hxx>
 
 class cmFunctionBlocker;
@@ -215,9 +213,15 @@ public:
    */
   void AddSubDirectory(const char*, bool includeTopLevel=true, bool preorder = false);
   void AddSubDirectory(const char* fullSrcDir,const char *fullBinDir, 
-                       bool includeTopLevel=true, bool preorder = false);
+                       bool includeTopLevel, bool preorder,
+                       bool immediate);
 
   /**
+   * Configure a subdirectory
+   */
+  void ConfigureSubDirectory(cmLocalGenerator *);
+                             
+  /**
    * Add an include directory to the build.
    */
   void AddIncludeDirectory(const char*, bool before = false);
@@ -417,13 +421,6 @@ public:
   const cmTargets &GetTargets() const { return m_Targets; }
 
   cmTarget* FindTarget(const char* name);
-  /**
-   * Get a list of the build subdirectories.
-   */
-  const std::vector<cmSubDirectory>& GetSubDirectories()
-    { 
-    return m_SubDirectories;
-    }
 
   /**
    * Get a list of include directories in the build.
@@ -662,6 +659,14 @@ public:
   const char *GetProperty(const char *prop) const;
   bool GetPropertyAsBool(const char *prop) const;
 
+  typedef std::map<cmStdString, cmStdString> DefinitionMap;
+  ///! Initialize a makefile from its parent
+  void InitializeFromParent();
+  
+  ///! Set/Get the preorder flag
+  void SetPreOrder(bool p) { this->PreOrder = p; }
+  bool GetPreOrder() { return this->PreOrder; }
+    
 protected:
   // add link libraries and directories to the target
   void AddGlobalLinkInformation(const char* name, cmTarget& target);
@@ -684,12 +689,6 @@ protected:
   cmTargets m_Targets;
   std::vector<cmSourceFile*> m_SourceFiles;
 
-  // list of sub directories
-  std::vector<cmSubDirectory> m_SubDirectories; 
-  struct StringSet : public std::set<cmStdString>
-  {
-  };
-  
   // The include and link-library paths.  These may have order
   // dependency, so they must be vectors (not set).
   std::vector<std::string> m_IncludeDirectories;
@@ -706,17 +705,12 @@ protected:
   std::vector<std::string> m_HeaderFileExtensions;
   std::string m_DefineFlags;
   std::vector<cmSourceGroup> m_SourceGroups;
-  typedef std::map<cmStdString, cmStdString> DefinitionMap;
   DefinitionMap m_Definitions;
   std::vector<cmCommand*> m_UsedCommands;
   cmLocalGenerator* m_LocalGenerator;
   bool IsFunctionBlocked(const cmListFileFunction& lff);
   
 private:
-  /**
-   * Get the name of the parent generator's CMakeLists file
-   */
-  std::string GetParentListFileName();
 
   void ReadSources(std::ifstream& fin, bool t);
   friend class cmMakeDepend;    // make depend needs direct access 
@@ -728,7 +722,6 @@ private:
 
   typedef std::map<cmStdString, cmData*> DataMap;
   DataMap m_DataMap;
-  bool m_Inheriting;
 
   typedef std::map<cmStdString, cmStdString> StringStringMap;
   StringStringMap m_MacrosMap;
@@ -740,6 +733,9 @@ private:
   cmsys::RegularExpression m_cmDefineRegex;
 
   std::map<cmStdString,cmStdString> m_Properties;
+
+  // should this makefile be processed before or after processing the parent
+  bool PreOrder;
 };
 
 
diff --git a/Source/cmMarkAsAdvancedCommand.h b/Source/cmMarkAsAdvancedCommand.h
index 108faaa..d3b3fe9 100644
--- a/Source/cmMarkAsAdvancedCommand.h
+++ b/Source/cmMarkAsAdvancedCommand.h
@@ -42,12 +42,6 @@ public:
   virtual bool InitialPass(std::vector<std::string> const& args);
 
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() {return true;}
-
-  /**
    * The name of the command as specified in CMakeList.txt.
    */
   virtual const char* GetName() {return "MARK_AS_ADVANCED";}
diff --git a/Source/cmOptionCommand.h b/Source/cmOptionCommand.h
index 30c9eef..2facc8e 100644
--- a/Source/cmOptionCommand.h
+++ b/Source/cmOptionCommand.h
@@ -42,12 +42,6 @@ public:
   virtual bool InitialPass(std::vector<std::string> const& args);
 
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() {return true;}
-
-  /**
    * The name of the command as specified in CMakeList.txt.
    */
   virtual const char* GetName() {return "OPTION";}
diff --git a/Source/cmProjectCommand.h b/Source/cmProjectCommand.h
index 0deeacb..dd4ae74 100644
--- a/Source/cmProjectCommand.h
+++ b/Source/cmProjectCommand.h
@@ -50,15 +50,6 @@ public:
   virtual const char* GetName() {return "PROJECT";}
 
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() 
-    {
-    return true;
-    }
-
-  /**
    * Succinct documentation.
    */
   virtual const char* GetTerseDocumentation() 
diff --git a/Source/cmRemoveCommand.h b/Source/cmRemoveCommand.h
index 82d1592..a1de010 100644
--- a/Source/cmRemoveCommand.h
+++ b/Source/cmRemoveCommand.h
@@ -42,12 +42,6 @@ public:
   virtual bool InitialPass(std::vector<std::string> const& args);
 
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() {return true;}
-
-  /**
    * This determines if the command is invoked when in script mode.
    */
   virtual bool IsScriptable() { return true; }
diff --git a/Source/cmRemoveDefinitionsCommand.h b/Source/cmRemoveDefinitionsCommand.h
index ac1c75c..531c223 100644
--- a/Source/cmRemoveDefinitionsCommand.h
+++ b/Source/cmRemoveDefinitionsCommand.h
@@ -43,12 +43,6 @@ public:
   virtual bool InitialPass(std::vector<std::string> const& args);
 
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() {return true;}
-
-  /**
    * The name of the command as specified in CMakeList.txt.
    */
   virtual const char* GetName() {return "REMOVE_DEFINITIONS";}
diff --git a/Source/cmSeparateArgumentsCommand.h b/Source/cmSeparateArgumentsCommand.h
index 64d669f..4be21f6 100644
--- a/Source/cmSeparateArgumentsCommand.h
+++ b/Source/cmSeparateArgumentsCommand.h
@@ -42,12 +42,6 @@ public:
   virtual bool InitialPass(std::vector<std::string> const& args);
 
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() {return true;}
-
-  /**
    * This determines if the command is invoked when in script mode.
    */
   virtual bool IsScriptable() { return true; }
diff --git a/Source/cmSetCommand.h b/Source/cmSetCommand.h
index 0556053..5253baf 100644
--- a/Source/cmSetCommand.h
+++ b/Source/cmSetCommand.h
@@ -42,12 +42,6 @@ public:
   virtual bool InitialPass(std::vector<std::string> const& args);
 
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() {return true;}
-
-  /**
    * This determines if the command is invoked when in script mode.
    */
   virtual bool IsScriptable() { return true; }
diff --git a/Source/cmSetDirectoryPropertiesCommand.h b/Source/cmSetDirectoryPropertiesCommand.h
index 1427235..1bc2310 100644
--- a/Source/cmSetDirectoryPropertiesCommand.h
+++ b/Source/cmSetDirectoryPropertiesCommand.h
@@ -34,12 +34,6 @@ public:
   virtual bool InitialPass(std::vector<std::string> const& args);
 
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() {return true;}
-
-  /**
    * The name of the command as specified in CMakeList.txt.
    */
   virtual const char* GetName() { return "SET_DIRECTORY_PROPERTIES";}
diff --git a/Source/cmSiteNameCommand.h b/Source/cmSiteNameCommand.h
index 1a3ef33..a191032 100644
--- a/Source/cmSiteNameCommand.h
+++ b/Source/cmSiteNameCommand.h
@@ -42,12 +42,6 @@ public:
   virtual bool InitialPass(std::vector<std::string> const& args);
 
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() {return true;}
-
-  /**
    * The name of the command as specified in CMakeList.txt.
    */
   virtual const char* GetName() {return "SITE_NAME";}
diff --git a/Source/cmSourceGroupCommand.h b/Source/cmSourceGroupCommand.h
index 337201a..146f8b5 100644
--- a/Source/cmSourceGroupCommand.h
+++ b/Source/cmSourceGroupCommand.h
@@ -48,15 +48,6 @@ public:
   virtual const char* GetName() {return "SOURCE_GROUP";}
 
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() 
-    {
-    return true;
-    }
-
-  /**
    * Succinct documentation.
    */
   virtual const char* GetTerseDocumentation() 
diff --git a/Source/cmStringCommand.h b/Source/cmStringCommand.h
index d392a3d..91463c4 100644
--- a/Source/cmStringCommand.h
+++ b/Source/cmStringCommand.h
@@ -41,12 +41,6 @@ public:
   virtual bool InitialPass(std::vector<std::string> const& args);
 
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() {return true;}
-
-  /**
    * This determines if the command is invoked when in script mode.
    */
   virtual bool IsScriptable() { return true; }
diff --git a/Source/cmSubdirCommand.cxx b/Source/cmSubdirCommand.cxx
index 56cae36..ab43892 100644
--- a/Source/cmSubdirCommand.cxx
+++ b/Source/cmSubdirCommand.cxx
@@ -51,7 +51,7 @@ bool cmSubdirCommand::InitialPass(std::vector<std::string> const& args)
         std::string(m_Makefile->GetCurrentOutputDirectory()) + 
         "/" + i->c_str();
       m_Makefile->AddSubDirectory(srcPath.c_str(), binPath.c_str(),
-                                  intoplevel, preorder);
+                                  intoplevel, preorder, false);
       }
     // otherwise it is a full path
     else if ( cmSystemTools::FileIsDirectory(i->c_str()) )
@@ -62,7 +62,7 @@ bool cmSubdirCommand::InitialPass(std::vector<std::string> const& args)
         std::string(m_Makefile->GetCurrentOutputDirectory()) + 
         "/" + cmSystemTools::GetFilenameName(i->c_str());
       m_Makefile->AddSubDirectory(i->c_str(), binPath.c_str(),
-                                  intoplevel, preorder);
+                                  intoplevel, preorder, false);
       }
     else
       {
diff --git a/Source/cmUtilitySourceCommand.h b/Source/cmUtilitySourceCommand.h
index bab1f6a..3dd58c8 100644
--- a/Source/cmUtilitySourceCommand.h
+++ b/Source/cmUtilitySourceCommand.h
@@ -46,12 +46,6 @@ public:
   virtual bool InitialPass(std::vector<std::string> const& args);
 
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() { return true;  }
-
-  /**
    * The name of the command as specified in CMakeList.txt.
    */
   virtual const char* GetName() { return "UTILITY_SOURCE";}
diff --git a/Source/cmWhileCommand.h b/Source/cmWhileCommand.h
index 752867f..bfb355e 100644
--- a/Source/cmWhileCommand.h
+++ b/Source/cmWhileCommand.h
@@ -70,12 +70,6 @@ public:
   virtual bool InitialPass(std::vector<std::string> const&) { return false; }
 
   /**
-   * This determines if the command gets propagated down
-   * to makefiles located in subdirectories.
-   */
-  virtual bool IsInherited() {return true;}
-
-  /**
    * This determines if the command is invoked when in script mode.
    */
   virtual bool IsScriptable() { return true; }