major changes to support multiple libraries and source lists

CMakeRules.make.in

@@ -6,7 +6,7 @@
 # 
 #------------------------------------------------------------------------------
 #
-all: CMakeTargets.make  ${LOCAL_BUILD_TARGETS} ${BUILD_LIB_FILE} ${EXECUTABLES} ${SUBDIR_BUILD} ${CMAKE} 
+all: CMakeTargets.make  ${LOCAL_BUILD_TARGETS} ${TARGETS} ${SUBDIR_BUILD} ${CMAKE} 
 
 #------------------------------------------------------------------------------
 
@@ -30,19 +30,6 @@ rebuild_cache: ${CMAKE_CONFIG_DIR}/CMakeCache.txt
 ${CMAKE_CONFIG_DIR}/CMakeCache.txt:
 	${CMAKE} ${topdir}/CMakeLists.txt -MakeCache -S${topdir} -O${CMAKE_CONFIG_DIR} -H${topdir} -B${CMAKE_CONFIG_DIR}
 
-#------------------------------------------------------------------------------
-# rules for the normal library
-#
-lib${LIBRARY}.a: ${SRC_OBJ} ${KIT_OBJ}
-	${AR} cr lib${LIBRARY}.a ${KIT_OBJ}
-	${RANLIB} lib$(LIBRARY).a
-
-
-lib$(LIBRARY)$(SHLIB_SUFFIX): ${KIT_OBJ}
-	rm -f lib$(LIBRARY)$(SHLIB_SUFFIX)
-	$(CXX) ${CXX_FLAGS} ${CMAKE_SHLIB_BUILD_FLAGS} -o \
-	lib$(LIBRARY)$(SHLIB_SUFFIX) \
-	   ${KIT_OBJ} ${SHLIB_LD_LIBS}
 
 install: ${BUILD_LIB_FILE} 
 	@echo "Installing ${BUILD_LIB_FILE}"

Source/CMakeLib.dsp

@@ -97,6 +97,10 @@ SOURCE=.\cmCommands.cxx
 # End Source File
 # Begin Source File
 
+SOURCE=.\cmCustomCommand.cxx
+# End Source File
+# Begin Source File
+
 SOURCE=.\cmDirectory.cxx
 # End Source File
 # Begin Source File

Source/CMakeSetupCMD.dsp

@@ -68,7 +68,8 @@ LINK32=link.exe
 # PROP Ignore_Export_Lib 0
 # PROP Target_Dir ""
 # ADD BASE CPP /W3 /Gm /GR /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /YX /FD /GZ /c
-# ADD CPP /nologo /MDd /W3 /Gm /GR /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /YX /FD /GZ /c
+# ADD CPP /nologo /MDd /W3 /Gm /GR /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /FD /GZ /c
+# SUBTRACT CPP /YX
 # ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
 # ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
 # ADD BASE RSC /l 0x409 /d "_DEBUG"

Source/Makefile.in

@@ -22,6 +22,7 @@ cmSystemTools.o \
 cmDirectory.o \
 cmUnixMakefileGenerator.o \
 cmCommands.o \
+cmCustomCommand.o \
 cmCacheManager.o \
 cmSourceGroup.o
 
@@ -36,6 +37,7 @@ cmAuxSourceDirectoryCommand.o : $(DEPENDS)
 cmRegularExpression.o : $(DEPENDS)
 cmClassFile.o : $(DEPENDS)
 cmDirectory.o : $(DEPENDS)
+cmCustomCommand.o : $(DEPENDS)
 cmUnixMakefileGenerator.o : $(DEPENDS)
 cmCommands.o : $(DEPENDS)
 cmCacheManager.o : $(DEPENDS)

Source/cmAbstractFilesCommand.cxx

@@ -23,16 +23,20 @@ bool cmAbstractFilesCommand::Invoke(std::vector<std::string>& args)
     this->SetError("called with incorrect number of arguments");
     return false;
     }
+  cmMakefile::ClassMap &Classes = m_Makefile->GetClasses();
   for(std::vector<std::string>::iterator j = args.begin();
       j != args.end(); ++j)
     {   
-    std::vector<cmClassFile>& Classes = m_Makefile->GetClasses();
+    for(cmMakefile::ClassMap::iterator l = Classes.begin(); 
-    for(unsigned int i = 0; i < Classes.size(); i++)
+        l != Classes.end(); l++)
       {
-      if(Classes[i].m_ClassName == (*j))
+      for(std::vector<cmClassFile>::iterator i = l->second.begin(); 
+          i != l->second.end(); i++)
         {
-        Classes[i].m_AbstractClass = true;
+        if(i->m_ClassName == (*j))
-        break;
+          {
+          i->m_AbstractClass = true;
+          }
         }
       }
     }

Source/cmAddExecutableCommand.cxx

@@ -0,0 +1,33 @@
+/*=========================================================================
+
+  Program:   Insight Segmentation & Registration Toolkit
+  Module:    $RCSfile$
+  Language:  C++
+  Date:      $Date$
+  Version:   $Revision$
+
+
+  Copyright (c) 2000 National Library of Medicine
+  All rights reserved.
+
+  See COPYRIGHT.txt for copyright details.
+
+=========================================================================*/
+#include "cmAddExecutableCommand.h"
+
+// cmExecutableCommand
+bool cmAddExecutableCommand::Invoke(std::vector<std::string>& args)
+{
+  if(args.size() < 2 )
+    {
+    this->SetError("called with incorrect number of arguments");
+    return false;
+    }
+  
+  std::vector<std::string>::iterator s = args.begin();
+  std::vector<std::string> srclists(++s, args.end());
+  
+  m_Makefile->AddExecutable(args[0].c_str(),srclists);
+  return true;
+}
+

Source/cmAddExecutableCommand.h

@@ -0,0 +1,71 @@
+/*=========================================================================
+
+  Program:   Insight Segmentation & Registration Toolkit
+  Module:    $RCSfile$
+  Language:  C++
+  Date:      $Date$
+  Version:   $Revision$
+
+
+  Copyright (c) 2000 National Library of Medicine
+  All rights reserved.
+
+  See COPYRIGHT.txt for copyright details.
+
+=========================================================================*/
+#ifndef cmExecutablesCommand_h
+#define cmExecutablesCommand_h
+
+#include "cmStandardIncludes.h"
+#include "cmCommand.h"
+
+/** \class cmExecutablesCommand
+ * \brief Defines a list of executables to build.
+ *
+ * cmExecutablesCommand defines a list of executable (i.e., test)
+ * programs to create.
+ */
+class cmAddExecutableCommand : public cmCommand
+{
+public:
+  /**
+   * This is a virtual constructor for the command.
+   */
+  virtual cmCommand* Clone() 
+    {
+    return new cmAddExecutableCommand;
+    }
+
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+   */
+  virtual bool Invoke(std::vector<std::string>& args);
+
+  /**
+   * The name of the command as specified in CMakeList.txt.
+   */
+  virtual const char* GetName() { return "ADD_EXECUTABLE";}
+
+  /**
+   * Succinct documentation.
+   */
+  virtual const char* GetTerseDocumentation() 
+    {
+    return "Add an executable to the project that uses the specified srclists";
+    }
+  
+  /**
+   * More documentation.
+   */
+  virtual const char* GetFullDocumentation()
+    {
+    return
+      "ADD_EXECUTABLE(exename srclist srclist srclist ...)";
+    }
+  
+  cmTypeMacro(cmAddExecutableCommand, cmCommand);
+};
+
+
+#endif

Source/cmAddLibraryCommand.cxx

@@ -0,0 +1,33 @@
+/*=========================================================================
+
+  Program:   Insight Segmentation & Registration Toolkit
+  Module:    $RCSfile$
+  Language:  C++
+  Date:      $Date$
+  Version:   $Revision$
+
+
+  Copyright (c) 2000 National Library of Medicine
+  All rights reserved.
+
+  See COPYRIGHT.txt for copyright details.
+
+=========================================================================*/
+#include "cmAddLibraryCommand.h"
+
+// cmLibraryCommand
+bool cmAddLibraryCommand::Invoke(std::vector<std::string>& args)
+{
+  if(args.size() < 2 )
+    {
+    this->SetError("called with incorrect number of arguments");
+    return false;
+    }
+  
+  std::vector<std::string>::iterator s = args.begin();
+  std::vector<std::string> srclists(++s, args.end());
+  
+  m_Makefile->AddLibrary(args[0].c_str(),srclists);
+  return true;
+}
+

Source/cmAddLibraryCommand.h

@@ -0,0 +1,71 @@
+/*=========================================================================
+
+  Program:   Insight Segmentation & Registration Toolkit
+  Module:    $RCSfile$
+  Language:  C++
+  Date:      $Date$
+  Version:   $Revision$
+
+
+  Copyright (c) 2000 National Library of Medicine
+  All rights reserved.
+
+  See COPYRIGHT.txt for copyright details.
+
+=========================================================================*/
+#ifndef cmLibrarysCommand_h
+#define cmLibrarysCommand_h
+
+#include "cmStandardIncludes.h"
+#include "cmCommand.h"
+
+/** \class cmLibrarysCommand
+ * \brief Defines a list of executables to build.
+ *
+ * cmLibrarysCommand defines a list of executable (i.e., test)
+ * programs to create.
+ */
+class cmAddLibraryCommand : public cmCommand
+{
+public:
+  /**
+   * This is a virtual constructor for the command.
+   */
+  virtual cmCommand* Clone() 
+    {
+    return new cmAddLibraryCommand;
+    }
+
+  /**
+   * This is called when the command is first encountered in
+   * the CMakeLists.txt file.
+   */
+  virtual bool Invoke(std::vector<std::string>& args);
+
+  /**
+   * The name of the command as specified in CMakeList.txt.
+   */
+  virtual const char* GetName() { return "ADD_LIBRARY";}
+
+  /**
+   * Succinct documentation.
+   */
+  virtual const char* GetTerseDocumentation() 
+    {
+    return "Add an library to the project that uses the specified srclists";
+    }
+  
+  /**
+   * More documentation.
+   */
+  virtual const char* GetFullDocumentation()
+    {
+    return
+      "ADD_LIBRARY(libname srclist srclist srclist ...)";
+    }
+  
+  cmTypeMacro(cmAddLibraryCommand, cmCommand);
+};
+
+
+#endif

Source/cmAuxSourceDirectoryCommand.cxx

@@ -19,9 +19,9 @@
 // cmAuxSourceDirectoryCommand
 bool cmAuxSourceDirectoryCommand::Invoke(std::vector<std::string>& args)
 {
-  if(args.size() < 1 || args.size() > 1)
+  if(args.size() < 2 || args.size() > 2)
     {
-    this->SetError("PROJECT called with incorrect number of arguments");
+    this->SetError("called with incorrect number of arguments");
     return false;
     }
   
@@ -52,7 +52,7 @@ bool cmAuxSourceDirectoryCommand::Invoke(std::vector<std::string>& args)
         cmClassFile cmfile;
         cmfile.SetName(fullname.c_str(), m_Makefile->GetCurrentDirectory());
         cmfile.m_AbstractClass = false;
-        m_Makefile->AddClass(cmfile);
+        m_Makefile->AddClass(cmfile,args[1].c_str());
         }
       }
     }

Source/cmAuxSourceDirectoryCommand.h

@@ -56,7 +56,7 @@ public:
   virtual const char* GetTerseDocumentation() 
     {
     return "Add all the source files found in the specified\n"
-           "directory to the build.";
+           "directory to the build as source list NAME.";
     }
   
   /**
@@ -65,7 +65,7 @@ public:
   virtual const char* GetFullDocumentation()
     {
     return
-      "AUX_SOURCE_DIRECTORY(dir)";
+      "AUX_SOURCE_DIRECTORY(dir srcListName)";
     }
   
   cmTypeMacro(cmAuxSourceDirectoryCommand, cmCommand);

Source/cmCableCommand.cxx

@@ -78,40 +78,5 @@ void cmCableCommand::SetupCableData()
   // command as its owner.
   pathName += "/cable_config.xml";
   m_CableData = new cmCableData(this, pathName);
-  
-  // We must add a custom rule to cause the cable_config.xml to be re-built
-  // when it is removed.  Rebuilding it means re-running CMake.
-  std::string cMakeLists = m_Makefile->GetStartDirectory();
-  cMakeLists += "/";
-  cMakeLists += "CMakeLists.txt";
-
-  std::string command;
-#if defined(_WIN32) && !defined(__CYGWIN__)
-  command = "\"";
-  command += m_Makefile->GetHomeDirectory();
-  command += "/CMake/Source/CMakeSetupCMD\" \"";
-  command += cMakeLists;
-  command += "\" -DSP";
-#else
-  command = "\"";
-  command += m_Makefile->GetHomeOutputDirectory();  
-  command += "/CMake/Source/CMakeBuildTargets\" \"";
-  command += cMakeLists;
-  command += "\"";
-#endif
-  command += " -H\"";
-  command += m_Makefile->GetHomeDirectory();
-  command += "\" -S\"";
-  command += m_Makefile->GetStartDirectory();
-  command += "\" -O\"";
-  command += m_Makefile->GetStartOutputDirectory();
-  command += "\" -B\"";
-  command += m_Makefile->GetHomeOutputDirectory();
-  command += "\"";
-
-  std::vector<std::string> depends;
-  m_Makefile->AddCustomCommand(cMakeLists.c_str(), 
-                               command.c_str(),
-                               depends,
-                               "cable_config.xml");
 }
+

Source/cmCableData.cxx

@@ -29,8 +29,7 @@ cmCableData::cmCableData(const cmCableCommand* owner,
   m_OutputFile(configurationFile.c_str()),
   m_Indentation(0),
   m_Package(NULL),
-  m_PackageNamespaceDepth(0),
+  m_PackageNamespaceDepth(0)
-  m_PackageClassIndex(-1)
 {
   this->InitializeOutputFile();
 }

Source/cmCableData.h

@@ -71,8 +71,7 @@ public:
   void BeginPackage(cmCablePackageCommand*);
   void EndPackage();
   
-  void SetPackageClassIndex(int index) { m_PackageClassIndex = index; }
+  cmCablePackageCommand *GetCurrentPackage() { return m_Package; }
-  int GetPackageClassIndex() const { return m_PackageClassIndex; }
   
 private:
   /**
@@ -110,13 +109,6 @@ private:
    * This must be the level when the package is ended.
    */
   unsigned int m_PackageNamespaceDepth;
-  
-  /**
-   * During the final pass, this maintains the index into a cmMakefile's
-   * m_Classes corresponding to the cmClassFile for this package's generated
-   * file.
-   */
-  int m_PackageClassIndex;
 };
 
 std::ostream& operator<<(std::ostream&, const cmCableData::Indentation&);

Source/cmCablePackageCommand.cxx

@@ -36,17 +36,58 @@ cmCablePackageCommand::~cmCablePackageCommand()
 // cmCablePackageCommand
 bool cmCablePackageCommand::Invoke(std::vector<std::string>& args)
 {
-  if(args.size() != 1)
+  if(args.size() != 2)
     {
     this->SetError("called with incorrect number of arguments");
     return false;
     }
-  
+
+  // setup this once. Really this should probably be moved somewhere else
+  // at some point. 
+  {  
+  // We must add a custom rule to cause the cable_config.xml to be re-built
+  // when it is removed.  Rebuilding it means re-running CMake.
+  std::string cMakeLists = m_Makefile->GetStartDirectory();
+  cMakeLists += "/";
+  cMakeLists += "CMakeLists.txt";
+
+  std::string command;
+#if defined(_WIN32) && !defined(__CYGWIN__)
+  command = "\"";
+  command += m_Makefile->GetHomeDirectory();
+  command += "/CMake/Source/CMakeSetupCMD\" \"";
+  command += cMakeLists;
+  command += "\" -DSP";
+#else
+  command = "\"";
+  command += m_Makefile->GetHomeOutputDirectory();  
+  command += "/CMake/Source/CMakeBuildTargets\" \"";
+  command += cMakeLists;
+  command += "\"";
+#endif
+  command += " -H\"";
+  command += m_Makefile->GetHomeDirectory();
+  command += "\" -S\"";
+  command += m_Makefile->GetStartDirectory();
+  command += "\" -O\"";
+  command += m_Makefile->GetStartOutputDirectory();
+  command += "\" -B\"";
+  command += m_Makefile->GetHomeOutputDirectory();
+  command += "\"";
+
+  std::vector<std::string> depends;
+  m_Makefile->AddCustomCommand(cMakeLists.c_str(), 
+                               command.c_str(),
+                               depends,
+                               "cable_config.xml", args[1].c_str());
+  }
+
   // This command needs to access the Cable data.
   this->SetupCableData();
   
   // The argument is the package name.
   m_PackageName = args[0];
+  m_TargetName = args[1];
 
   // Ask the cable data to begin the package.  This may call another
   // cmCablePackageCommand's WritePackageFooter().  This will call
@@ -72,7 +113,7 @@ bool cmCablePackageCommand::Invoke(std::vector<std::string>& args)
   m_Makefile->AddCustomCommand("cable_config.xml",
                                command.c_str(),
                                depends,
-                               outputs);
+                               outputs, m_TargetName.c_str());
   
   return true;
 }
@@ -87,9 +128,7 @@ void cmCablePackageCommand::FinalPass()
   file.m_AbstractClass = false;
   file.m_HeaderFileOnly = false;
   file.SetName(fileName.c_str(), filePath.c_str(), "cxx", false);
-  
+  m_Makefile->AddClass(file, m_PackageName.c_str());
-  m_CableData->SetPackageClassIndex(m_Makefile->GetClasses().size());
-  m_Makefile->AddClass(file);
 }
 
 

Source/cmCablePackageCommand.h

@@ -73,19 +73,21 @@ public:
   virtual const char* GetFullDocumentation()
     {
     return
-      "CABLE_PACKAGE(package_name)\n"
+      "CABLE_PACKAGE(package_name target)\n"
       "Close current package (if any), and open a new package definition.";
     }  
 
   void WritePackageHeader() const;
   void WritePackageFooter() const;  
-  
+  const char *GetPackageName() {return m_PackageName.c_str();}
+      
   cmTypeMacro(cmCablePackageCommand, cmCableCommand);
 private:
   /**
    * The name of the package.
    */
   std::string m_PackageName;  
+  std::string m_TargetName;  
 };
 
 

Source/cmCableSourceFilesCommand.cxx

@@ -20,19 +20,23 @@ void cmCableSourceFilesCommand::FinalPass()
 {
   // Get the index of the current package's cmClassFile.
   // If it doesn't exist, ignore this command.
-  int index = m_CableData->GetPackageClassIndex();
+  cmCablePackageCommand *cablePackage = m_CableData->GetCurrentPackage();
-  if(index < 0)
+  std::string fileName = "Cxx/";
+  fileName += cablePackage->GetPackageName();
+  fileName += "_cxx";
+  cmClassFile *ci = m_Makefile->GetClass(cablePackage->GetPackageName(),
+                                         fileName.c_str());
+  
+  if(ci == 0)
     { return; }
   
   // The package's file has not yet been generated yet.  The dependency
   // finder will need hints.  Add one for each source file.
-  cmClassFile& cFile = m_Makefile->GetClasses()[index];
-  
   for(Entries::const_iterator f = m_Entries.begin();
       f != m_Entries.end(); ++f)
     {
     std::string header = *f+".h";
-    cFile.m_Depends.push_back(header);
+    ci->m_Depends.push_back(header);
     }
 }
 

Source/cmClassFile.cxx

@@ -103,19 +103,23 @@ void cmClassFile::SetName(const char* name, const char* dir, const char *ext,
   return;
 }
 
-void cmClassFile::Print()
+void cmClassFile::Print() const
 {
   if(m_AbstractClass)
+    {
     std::cout <<  "Abstract ";
+    }
   else
+    {
     std::cout << "Concrete ";
+    }
   if(m_HeaderFileOnly)
+    {
     std::cout << "Header file ";
+    }
   else
+    {
     std::cout << "CXX file ";
-  if(m_IsExecutable)
+    }
-    std::cout << "Executable ";
-  else
-    std::cout << "Non Executable ";
   std::cout << m_ClassName << std::endl;
 }

Source/cmClassFile.h

@@ -35,7 +35,6 @@ public:
     {
     m_AbstractClass = false;
     m_HeaderFileOnly = false;
-    m_IsExecutable = false;
     m_WrapExclude = false;
     }
   
@@ -57,7 +56,7 @@ public:
   /**
    * Print the structure to std::cout.
    */
-  void Print();
+  void Print() const;
 
   /**
    * Indicate whether the class is abstract (non-instantiable).
@@ -74,11 +73,6 @@ public:
    */
   bool m_HeaderFileOnly;
 
-  /**
-   * Indicate whether this class is an executable file
-   */
-  bool m_IsExecutable;
-
   /**
    * The full path to the file.
    */

Source/cmCommands.cxx

@@ -4,14 +4,14 @@
 // like to have CMake to build CMake.   
 #include "cmCommands.h"
 #include "cmAbstractFilesCommand.cxx"
+#include "cmAddExecutableCommand.cxx"
+#include "cmAddLibraryCommand.cxx"
 #include "cmAddTargetCommand.cxx"
 #include "cmAuxSourceDirectoryCommand.cxx"
-#include "cmExecutablesCommand.cxx"
 #include "cmFindIncludeCommand.cxx"
 #include "cmFindLibraryCommand.cxx"
 #include "cmFindProgramCommand.cxx"
 #include "cmIncludeDirectoryCommand.cxx"
-#include "cmLibraryCommand.cxx"
 #include "cmLinkDirectoriesCommand.cxx"
 #include "cmLinkLibrariesCommand.cxx"
 #include "cmProjectCommand.cxx"
@@ -47,14 +47,14 @@
 void GetPredefinedCommands(std::list<cmCommand*>& commands)
 {
   commands.push_back(new cmAbstractFilesCommand);
+  commands.push_back(new cmAddExecutableCommand);
+  commands.push_back(new cmAddLibraryCommand);
   commands.push_back(new cmAddTargetCommand);
   commands.push_back(new cmAuxSourceDirectoryCommand);
-  commands.push_back(new cmExecutablesCommand);
   commands.push_back(new cmFindIncludeCommand);
   commands.push_back(new cmFindLibraryCommand);
   commands.push_back(new cmFindProgramCommand);
   commands.push_back(new cmIncludeDirectoryCommand);
-  commands.push_back(new cmLibraryCommand);
   commands.push_back(new cmLinkDirectoriesCommand);
   commands.push_back(new cmLinkLibrariesCommand);
   commands.push_back(new cmProjectCommand);

Source/cmCustomCommand.cxx

@@ -0,0 +1,60 @@
+/*=========================================================================
+
+  Program:   Insight Segmentation & Registration Toolkit
+  Module:    $RCSfile$
+  Language:  C++
+  Date:      $Date$
+  Version:   $Revision$
+
+
+  Copyright (c) 2000 National Library of Medicine
+  All rights reserved.
+
+  See COPYRIGHT.txt for copyright details.
+
+=========================================================================*/
+#include "cmCustomCommand.h"
+#include "cmMakefile.h"
+
+/**
+ * The constructor
+ */
+cmCustomCommand::cmCustomCommand(const char *src, const char *command,
+                                 std::vector<std::string> dep,
+                                 std::vector<std::string> out):
+  m_Source(src),
+  m_Command(command),
+  m_Depends(dep),
+  m_Outputs(out)
+{
+}
+
+
+/**
+ * Copy constructor.
+ */
+cmCustomCommand::cmCustomCommand(const cmCustomCommand& r):
+  m_Source(r.m_Source),
+  m_Command(r.m_Command),
+  m_Depends(r.m_Depends),
+  m_Outputs(r.m_Outputs)
+{
+}
+
+void cmCustomCommand::ExpandVariables(const cmMakefile &mf)
+{
+  mf.ExpandVariablesInString(m_Source);
+  mf.ExpandVariablesInString(m_Command);
+
+  for (std::vector<std::string>::iterator i = m_Depends.begin();
+       i != m_Depends.end(); ++i)
+    {
+    mf.ExpandVariablesInString(*i);
+    }
+  for (std::vector<std::string>::iterator i = m_Outputs.begin();
+       i != m_Outputs.end(); ++i)
+    {
+    mf.ExpandVariablesInString(*i);
+    }  
+}
+

Source/cmCustomCommand.h

@@ -0,0 +1,38 @@
+/*=========================================================================
+
+  Program:   Insight Segmentation & Registration Toolkit
+  Module:    $RCSfile$
+  Language:  C++
+  Date:      $Date$
+  Version:   $Revision$
+
+
+  Copyright (c) 2000 National Library of Medicine
+  All rights reserved.
+
+  See COPYRIGHT.txt for copyright details.
+
+=========================================================================*/
+#ifndef cmCustomCommand_h
+#define cmCustomCommand_h
+
+#include "cmStandardIncludes.h"
+class cmMakefile;
+
+class cmCustomCommand
+{
+public:
+  cmCustomCommand(const char *src, const char *command,
+                  std::vector<std::string> dep,
+                  std::vector<std::string> out);
+  cmCustomCommand(const cmCustomCommand& r);
+  void ExpandVariables(const cmMakefile &);
+  
+  std::string m_Source;
+  std::string m_Command;
+  std::vector<std::string> m_Depends;
+  std::vector<std::string> m_Outputs;
+};
+
+
+#endif

Source/cmDSPMakefile.cxx

@@ -73,84 +73,52 @@ void cmDSPMakefile::OutputDSPFile()
     m_LibraryOptions += "/$(OUTDIR)\" ";
     }
   m_LibraryOptions += "/STACK:10000000 ";
-  m_OutputLibName = m_Makefile->GetLibraryName();
   
   // Create the DSP or set of DSP's for libraries and executables
-  if(strlen(m_Makefile->GetLibraryName()) != 0)
+  const char* cacheValue
+    = cmCacheManager::GetInstance()->GetCacheValue("BUILD_SHARED_LIBS");
+  m_LibraryBuildType = STATIC_LIBRARY;
+  if(cacheValue && strcmp(cacheValue,"0"))
     {
-    const char* cacheValue
+    m_LibraryBuildType = DLL;
-      = cmCacheManager::GetInstance()->GetCacheValue("BUILD_SHARED_LIBS");
+    }
-    if(cacheValue && strcmp(cacheValue,"0"))
+
+  // clear project names
+  m_CreatedProjectNames.clear();
+
+  // build any targets
+  const cmTargets &tgts = m_Makefile->GetTargets();
+  for(cmTargets::const_iterator l = tgts.begin(); 
+      l != tgts.end(); l++)
+    {
+    if (l->second.m_IsALibrary)
       {
-      this->SetBuildType(DLL);
+      this->SetBuildType(m_LibraryBuildType, l->first.c_str());
       }
     else
       {
-      this->SetBuildType(STATIC_LIBRARY);
+      this->SetBuildType(EXECUTABLE,l->first.c_str());
-      }
-    this->CreateSingleDSP();
-    }
-  // if there are executables build them
-  if (m_Makefile->HasExecutables())
-    {
-    this->CreateExecutableDSPFiles();
-    }
-}
-void cmDSPMakefile::CreateExecutableDSPFiles()
-{
-  std::vector<cmClassFile>& Classes = m_Makefile->GetClasses();
-  for(int i = 0; i < Classes.size(); ++i)
-    {
-    cmClassFile& classfile = Classes[i];
-    if (classfile.m_IsExecutable)
-      {
-      std::string fname = m_Makefile->GetStartOutputDirectory();
-      fname += "/";
-      fname += classfile.m_ClassName;
-      fname += ".dsp";
-      std::ofstream fout(fname.c_str());
-      if(!fout)
-        {
-        cmSystemTools::Error("Error Writing ",
-                             fname.c_str());
-        }
-      else
-        {
-//        m_Makefile->SetLibraryName(classfile.m_ClassName.c_str());
-        this->SetBuildType(EXECUTABLE);
-        m_OutputLibName = classfile.m_ClassName;
-        std::string pname = classfile.m_ClassName.c_str(); //m_Makefile->GetLibraryName();
-        m_CreatedProjectNames.push_back(pname);
-        
-        this->WriteDSPHeader(fout);
-        this->WriteDSPBeginGroup(fout, "Source Files", "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat");
-        this->WriteDSPBuildRule(fout, classfile.m_FullPath.c_str());
-        this->WriteDSPEndGroup(fout);
-        this->WriteDSPBuildRule(fout);
-        this->WriteDSPFooter(fout);
-        }
       }
+    this->CreateSingleDSP(l->first.c_str(),l->second);
     }
 }
 
-
+void cmDSPMakefile::CreateSingleDSP(const char *lname, 
-void cmDSPMakefile::CreateSingleDSP()
+                                    const cmTarget &target)
 {
   std::string fname;
   fname = m_Makefile->GetStartOutputDirectory();
   fname += "/";
-  fname += m_Makefile->GetLibraryName();
+  fname += lname;
   fname += ".dsp";
-  m_CreatedProjectNames.clear();
+  std::string pname = lname;
-  std::string pname = m_Makefile->GetLibraryName();
   m_CreatedProjectNames.push_back(pname);
   std::ofstream fout(fname.c_str());
   if(!fout)
     {
-    cmSystemTools::Error("Error Writing ",
+    cmSystemTools::Error("Error Writing ", fname.c_str());
-                         fname.c_str());
     }
-  this->WriteDSPFile(fout);
+  this->WriteDSPFile(fout,lname,target);
 }
 
 void cmDSPMakefile::WriteDSPBuildRule(std::ostream& fout)
@@ -210,19 +178,51 @@ void cmDSPMakefile::AddDSPBuildRule(cmSourceGroup& sourceGroup)
   std::vector<std::string> depends;
   std::vector<std::string> outputs;
   outputs.push_back(dspname);
-  sourceGroup.AddCustomCommand(makefileIn.c_str(), dsprule.c_str(),
+  cmCustomCommand cc(makefileIn.c_str(), dsprule.c_str(),
-                               depends, outputs);
+                     depends, outputs);
+  sourceGroup.AddCustomCommand(cc);
 }
 
 
-void cmDSPMakefile::WriteDSPFile(std::ostream& fout)
+void cmDSPMakefile::WriteDSPFile(std::ostream& fout, 
+                                 const char *libName,
+                                 const cmTarget &target)
 {
   // Write the DSP file's header.
-  this->WriteDSPHeader(fout);
+  this->WriteDSPHeader(fout, libName);
   
   // We may be modifying the source groups temporarily, so make a copy.
   std::vector<cmSourceGroup> sourceGroups = m_Makefile->GetSourceGroups();
   
+  // get the classes from the source lists then add them to the groups
+  std::vector<cmClassFile> classes = 
+    m_Makefile->GetClassesFromSourceLists(target.m_SourceLists);
+  for(std::vector<cmClassFile>::iterator i = classes.begin(); 
+      i != classes.end(); i++)
+    {
+    if(!i->m_HeaderFileOnly)
+      {
+      // Add the file to the list of sources.
+      std::string source = i->m_FullPath;
+      cmSourceGroup& sourceGroup = m_Makefile->FindSourceGroup(source.c_str(),
+                                                               sourceGroups);
+      sourceGroup.AddSource(source.c_str());
+      }
+    }
+  
+  // add any custom rules to the source groups
+  for (std::vector<cmCustomCommand>::const_iterator cr = 
+         target.m_CustomCommands.begin(); 
+       cr != target.m_CustomCommands.end(); ++cr)
+    {
+    cmSourceGroup& sourceGroup = 
+      m_Makefile->FindSourceGroup(cr->m_Source.c_str(),
+                                  sourceGroups);
+    cmCustomCommand cc(*cr);
+    cc.ExpandVariables(*m_Makefile);
+    sourceGroup.AddCustomCommand(cc);
+    }
+  
   // Find the group in which the CMakeLists.txt source belongs, and add
   // the rule to generate this DSP file.
   for(std::vector<cmSourceGroup>::reverse_iterator sg = sourceGroups.rbegin();
@@ -351,9 +351,8 @@ void cmDSPMakefile::WriteDSPEndGroup(std::ostream& fout)
 
 
 
-void cmDSPMakefile::SetBuildType(BuildType b)
+void cmDSPMakefile::SetBuildType(BuildType b, const char *libName)
 {
-  m_BuildType = b;
   switch(b)
     {
     case STATIC_LIBRARY:
@@ -393,8 +392,7 @@ void cmDSPMakefile::SetBuildType(BuildType b)
     {
     fin.getline(buffer, 2048);
     std::string line = buffer;
-    cmSystemTools::ReplaceString(line, "OUTPUT_LIBNAME", 
+    cmSystemTools::ReplaceString(line, "OUTPUT_LIBNAME",libName);
-                                 m_Makefile->GetLibraryName());
     if (reg.find(line))
       {
       m_Configurations.push_back(line.substr(reg.end()));
@@ -402,7 +400,7 @@ void cmDSPMakefile::SetBuildType(BuildType b)
     }
 }
   
-void cmDSPMakefile::WriteDSPHeader(std::ostream& fout)
+void cmDSPMakefile::WriteDSPHeader(std::ostream& fout, const char *libName)
 {
   std::ifstream fin(m_DSPHeaderTemplate.c_str());
   if(!fin)
@@ -419,8 +417,7 @@ void cmDSPMakefile::WriteDSPHeader(std::ostream& fout)
                                     m_LibraryOptions.c_str());
       cmSystemTools::ReplaceString(line, "BUILD_INCLUDES",
                                     m_IncludeOptions.c_str());
-      cmSystemTools::ReplaceString(line, "OUTPUT_LIBNAME", 
+      cmSystemTools::ReplaceString(line, "OUTPUT_LIBNAME",libName);
-                                    m_OutputLibName.c_str());
       cmSystemTools::ReplaceString(line, 
                                     "EXTRA_DEFINES", 
 				   m_Makefile->GetDefineFlags());
@@ -454,25 +451,4 @@ void cmDSPMakefile::WriteDSPBuildRule(std::ostream& fout, const char* path)
   fout << "# End Source File\n";
 }
 
-bool cmDSPMakefile::NeedsDependencies(const char* dspname)
-{
-  if(strcmp(m_Makefile->GetLibraryName(), dspname) == 0)
-    {
-    // only shared libs need depend info
-    const char* cacheValue
-      = cmCacheManager::GetInstance()->GetCacheValue("BUILD_SHARED_LIBS");
-    if(cacheValue && strcmp(cacheValue,"0"))
-      {
-      return true;
-      }
-    else
-      {
-      return false;
-      }
-    }
-  // must be an executable so it needs depends
-  return true;
-}
-
-  
   

Source/cmDSPMakefile.h

@@ -37,11 +37,11 @@ public:
   /**
    * Specify the type of the build: static, dll, or executable.
    */
-  void SetBuildType(BuildType);
+  void SetBuildType(BuildType,const char *name);
 
-  BuildType GetBuildType()
+  BuildType GetLibraryBuildType()
     {
-      return m_BuildType;
+      return m_LibraryBuildType;
     }
   
 
@@ -61,20 +61,20 @@ public:
     {
     return m_Makefile;
     }
-  bool NeedsDependencies(const char* dspname);
+
 private:
   std::string m_DSPHeaderTemplate;
   std::string m_DSPFooterTemplate;
   std::vector<std::string> m_CreatedProjectNames;
   
-  void CreateExecutableDSPFiles();
+  void CreateSingleDSP(const char *lname, const cmTarget &tgt);
-  void CreateSingleDSP();
+  void WriteDSPFile(std::ostream& fout, 
-  void WriteDSPFile(std::ostream& fout);
+                    const char *libName, const cmTarget &tgt);
   void WriteDSPBeginGroup(std::ostream& fout, 
 			  const char* group,
 			  const char* filter);
   void WriteDSPEndGroup(std::ostream& fout);
-  void WriteDSPHeader(std::ostream& fout);
+  void WriteDSPHeader(std::ostream& fout, const char *libName);
   void WriteDSPBuildRule(std::ostream& fout, const char*);
   void WriteDSPBuildRule(std::ostream& fout);
   void WriteDSPFooter(std::ostream& fout);
@@ -86,9 +86,8 @@ private:
 
   std::string m_IncludeOptions;
   std::string m_LibraryOptions;
-  std::string m_OutputLibName;
   cmMakefile* m_Makefile;
-  BuildType m_BuildType;
+  BuildType m_LibraryBuildType;
   std::vector<std::string> m_Configurations;
 };
 

Source/cmDSPWriter.cxx

@@ -73,84 +73,52 @@ void cmDSPMakefile::OutputDSPFile()
     m_LibraryOptions += "/$(OUTDIR)\" ";
     }
   m_LibraryOptions += "/STACK:10000000 ";
-  m_OutputLibName = m_Makefile->GetLibraryName();
   
   // Create the DSP or set of DSP's for libraries and executables
-  if(strlen(m_Makefile->GetLibraryName()) != 0)
+  const char* cacheValue
+    = cmCacheManager::GetInstance()->GetCacheValue("BUILD_SHARED_LIBS");
+  m_LibraryBuildType = STATIC_LIBRARY;
+  if(cacheValue && strcmp(cacheValue,"0"))
     {
-    const char* cacheValue
+    m_LibraryBuildType = DLL;
-      = cmCacheManager::GetInstance()->GetCacheValue("BUILD_SHARED_LIBS");
+    }
-    if(cacheValue && strcmp(cacheValue,"0"))
+
+  // clear project names
+  m_CreatedProjectNames.clear();
+
+  // build any targets
+  const cmTargets &tgts = m_Makefile->GetTargets();
+  for(cmTargets::const_iterator l = tgts.begin(); 
+      l != tgts.end(); l++)
+    {
+    if (l->second.m_IsALibrary)
       {
-      this->SetBuildType(DLL);
+      this->SetBuildType(m_LibraryBuildType, l->first.c_str());
       }
     else
       {
-      this->SetBuildType(STATIC_LIBRARY);
+      this->SetBuildType(EXECUTABLE,l->first.c_str());
-      }
-    this->CreateSingleDSP();
-    }
-  // if there are executables build them
-  if (m_Makefile->HasExecutables())
-    {
-    this->CreateExecutableDSPFiles();
-    }
-}
-void cmDSPMakefile::CreateExecutableDSPFiles()
-{
-  std::vector<cmClassFile>& Classes = m_Makefile->GetClasses();
-  for(int i = 0; i < Classes.size(); ++i)
-    {
-    cmClassFile& classfile = Classes[i];
-    if (classfile.m_IsExecutable)
-      {
-      std::string fname = m_Makefile->GetStartOutputDirectory();
-      fname += "/";
-      fname += classfile.m_ClassName;
-      fname += ".dsp";
-      std::ofstream fout(fname.c_str());
-      if(!fout)
-        {
-        cmSystemTools::Error("Error Writing ",
-                             fname.c_str());
-        }
-      else
-        {
-//        m_Makefile->SetLibraryName(classfile.m_ClassName.c_str());
-        this->SetBuildType(EXECUTABLE);
-        m_OutputLibName = classfile.m_ClassName;
-        std::string pname = classfile.m_ClassName.c_str(); //m_Makefile->GetLibraryName();
-        m_CreatedProjectNames.push_back(pname);
-        
-        this->WriteDSPHeader(fout);
-        this->WriteDSPBeginGroup(fout, "Source Files", "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat");
-        this->WriteDSPBuildRule(fout, classfile.m_FullPath.c_str());
-        this->WriteDSPEndGroup(fout);
-        this->WriteDSPBuildRule(fout);
-        this->WriteDSPFooter(fout);
-        }
       }
+    this->CreateSingleDSP(l->first.c_str(),l->second);
     }
 }
 
-
+void cmDSPMakefile::CreateSingleDSP(const char *lname, 
-void cmDSPMakefile::CreateSingleDSP()
+                                    const cmTarget &target)
 {
   std::string fname;
   fname = m_Makefile->GetStartOutputDirectory();
   fname += "/";
-  fname += m_Makefile->GetLibraryName();
+  fname += lname;
   fname += ".dsp";
-  m_CreatedProjectNames.clear();
+  std::string pname = lname;
-  std::string pname = m_Makefile->GetLibraryName();
   m_CreatedProjectNames.push_back(pname);
   std::ofstream fout(fname.c_str());
   if(!fout)
     {
-    cmSystemTools::Error("Error Writing ",
+    cmSystemTools::Error("Error Writing ", fname.c_str());
-                         fname.c_str());
     }
-  this->WriteDSPFile(fout);
+  this->WriteDSPFile(fout,lname,target);
 }
 
 void cmDSPMakefile::WriteDSPBuildRule(std::ostream& fout)
@@ -210,19 +178,51 @@ void cmDSPMakefile::AddDSPBuildRule(cmSourceGroup& sourceGroup)
   std::vector<std::string> depends;
   std::vector<std::string> outputs;
   outputs.push_back(dspname);
-  sourceGroup.AddCustomCommand(makefileIn.c_str(), dsprule.c_str(),
+  cmCustomCommand cc(makefileIn.c_str(), dsprule.c_str(),
-                               depends, outputs);
+                     depends, outputs);
+  sourceGroup.AddCustomCommand(cc);
 }
 
 
-void cmDSPMakefile::WriteDSPFile(std::ostream& fout)
+void cmDSPMakefile::WriteDSPFile(std::ostream& fout, 
+                                 const char *libName,
+                                 const cmTarget &target)
 {
   // Write the DSP file's header.
-  this->WriteDSPHeader(fout);
+  this->WriteDSPHeader(fout, libName);
   
   // We may be modifying the source groups temporarily, so make a copy.
   std::vector<cmSourceGroup> sourceGroups = m_Makefile->GetSourceGroups();
   
+  // get the classes from the source lists then add them to the groups
+  std::vector<cmClassFile> classes = 
+    m_Makefile->GetClassesFromSourceLists(target.m_SourceLists);
+  for(std::vector<cmClassFile>::iterator i = classes.begin(); 
+      i != classes.end(); i++)
+    {
+    if(!i->m_HeaderFileOnly)
+      {
+      // Add the file to the list of sources.
+      std::string source = i->m_FullPath;
+      cmSourceGroup& sourceGroup = m_Makefile->FindSourceGroup(source.c_str(),
+                                                               sourceGroups);
+      sourceGroup.AddSource(source.c_str());
+      }
+    }
+  
+  // add any custom rules to the source groups
+  for (std::vector<cmCustomCommand>::const_iterator cr = 
+         target.m_CustomCommands.begin(); 
+       cr != target.m_CustomCommands.end(); ++cr)
+    {
+    cmSourceGroup& sourceGroup = 
+      m_Makefile->FindSourceGroup(cr->m_Source.c_str(),
+                                  sourceGroups);
+    cmCustomCommand cc(*cr);
+    cc.ExpandVariables(*m_Makefile);
+    sourceGroup.AddCustomCommand(cc);
+    }
+  
   // Find the group in which the CMakeLists.txt source belongs, and add
   // the rule to generate this DSP file.
   for(std::vector<cmSourceGroup>::reverse_iterator sg = sourceGroups.rbegin();
@@ -351,9 +351,8 @@ void cmDSPMakefile::WriteDSPEndGroup(std::ostream& fout)
 
 
 
-void cmDSPMakefile::SetBuildType(BuildType b)
+void cmDSPMakefile::SetBuildType(BuildType b, const char *libName)
 {
-  m_BuildType = b;
   switch(b)
     {
     case STATIC_LIBRARY:
@@ -393,8 +392,7 @@ void cmDSPMakefile::SetBuildType(BuildType b)
     {
     fin.getline(buffer, 2048);
     std::string line = buffer;
-    cmSystemTools::ReplaceString(line, "OUTPUT_LIBNAME", 
+    cmSystemTools::ReplaceString(line, "OUTPUT_LIBNAME",libName);
-                                 m_Makefile->GetLibraryName());
     if (reg.find(line))
       {
       m_Configurations.push_back(line.substr(reg.end()));
@@ -402,7 +400,7 @@ void cmDSPMakefile::SetBuildType(BuildType b)
     }
 }
   
-void cmDSPMakefile::WriteDSPHeader(std::ostream& fout)
+void cmDSPMakefile::WriteDSPHeader(std::ostream& fout, const char *libName)
 {
   std::ifstream fin(m_DSPHeaderTemplate.c_str());
   if(!fin)
@@ -419,8 +417,7 @@ void cmDSPMakefile::WriteDSPHeader(std::ostream& fout)
                                     m_LibraryOptions.c_str());
       cmSystemTools::ReplaceString(line, "BUILD_INCLUDES",
                                     m_IncludeOptions.c_str());
-      cmSystemTools::ReplaceString(line, "OUTPUT_LIBNAME", 
+      cmSystemTools::ReplaceString(line, "OUTPUT_LIBNAME",libName);
-                                    m_OutputLibName.c_str());
       cmSystemTools::ReplaceString(line, 
                                     "EXTRA_DEFINES", 
 				   m_Makefile->GetDefineFlags());
@@ -454,25 +451,4 @@ void cmDSPMakefile::WriteDSPBuildRule(std::ostream& fout, const char* path)
   fout << "# End Source File\n";
 }
 
-bool cmDSPMakefile::NeedsDependencies(const char* dspname)
-{
-  if(strcmp(m_Makefile->GetLibraryName(), dspname) == 0)
-    {
-    // only shared libs need depend info
-    const char* cacheValue
-      = cmCacheManager::GetInstance()->GetCacheValue("BUILD_SHARED_LIBS");
-    if(cacheValue && strcmp(cacheValue,"0"))
-      {
-      return true;
-      }
-    else
-      {
-      return false;
-      }
-    }
-  // must be an executable so it needs depends
-  return true;
-}
-
-  
   

Source/cmDSPWriter.h

@@ -37,11 +37,11 @@ public:
   /**
    * Specify the type of the build: static, dll, or executable.
    */
-  void SetBuildType(BuildType);
+  void SetBuildType(BuildType,const char *name);
 
-  BuildType GetBuildType()
+  BuildType GetLibraryBuildType()
     {
-      return m_BuildType;
+      return m_LibraryBuildType;
     }
   
 
@@ -61,20 +61,20 @@ public:
     {
     return m_Makefile;
     }
-  bool NeedsDependencies(const char* dspname);
+
 private:
   std::string m_DSPHeaderTemplate;
   std::string m_DSPFooterTemplate;
   std::vector<std::string> m_CreatedProjectNames;
   
-  void CreateExecutableDSPFiles();
+  void CreateSingleDSP(const char *lname, const cmTarget &tgt);
-  void CreateSingleDSP();
+  void WriteDSPFile(std::ostream& fout, 
-  void WriteDSPFile(std::ostream& fout);
+                    const char *libName, const cmTarget &tgt);
   void WriteDSPBeginGroup(std::ostream& fout, 
 			  const char* group,
 			  const char* filter);
   void WriteDSPEndGroup(std::ostream& fout);
-  void WriteDSPHeader(std::ostream& fout);
+  void WriteDSPHeader(std::ostream& fout, const char *libName);
   void WriteDSPBuildRule(std::ostream& fout, const char*);
   void WriteDSPBuildRule(std::ostream& fout);
   void WriteDSPFooter(std::ostream& fout);
@@ -86,9 +86,8 @@ private:
 
   std::string m_IncludeOptions;
   std::string m_LibraryOptions;
-  std::string m_OutputLibName;
   cmMakefile* m_Makefile;
-  BuildType m_BuildType;
+  BuildType m_LibraryBuildType;
   std::vector<std::string> m_Configurations;
 };
 

Source/cmDSWMakefile.cxx

@@ -87,16 +87,19 @@ void cmDSWMakefile::WriteDSWFile(std::ostream& fout)
     // remove the home directory and / from the source directory
     // this gives a relative path 
     cmSystemTools::ReplaceString(dir, homedir.c_str(), "");
+
     // Get the list of create dsp files names from the cmDSPMakefile, more
     // than one dsp could have been created per input CMakeLists.txt file
-    std::vector<std::string> dspnames =
+    // for each target
-      pg->GetDSPMakefile()->GetCreatedProjectNames();
+    std::vector<std::string> dspnames = pg->GetDSPMakefile()->GetCreatedProjectNames();
-    for(std::vector<std::string>::iterator si = dspnames.begin();
+    const cmTargets &tgts = pg->GetDSPMakefile()->GetMakefile()->GetTargets();
-	si != dspnames.end(); ++si)
+    cmTargets::const_iterator l = tgts.begin();
+    for(std::vector<std::string>::iterator si = dspnames.begin(); 
+        l != tgts.end(); ++l, ++si)
       {
       // Write the project into the DSW file
       this->WriteProject(fout, si->c_str(), dir.c_str(), 
-                         pg->GetDSPMakefile());
+                         pg->GetDSPMakefile(),l->second);
       }
     // delete the cmMakefile which also deletes the cmMSProjectGenerator
     delete mf;
@@ -112,7 +115,8 @@ void cmDSWMakefile::WriteDSWFile(std::ostream& fout)
 void cmDSWMakefile::WriteProject(std::ostream& fout, 
 				 const char* dspname,
 				 const char* dir,
-                                 cmDSPMakefile* project)
+                                 cmDSPMakefile* project,
+                                 const cmTarget &l)
 {
   fout << "#########################################################"
     "######################\n\n";
@@ -126,11 +130,12 @@ void cmDSWMakefile::WriteProject(std::ostream& fout,
   std::vector<std::string>::iterator i, end;
   i = project->GetMakefile()->GetLinkLibraries().begin();
   end = project->GetMakefile()->GetLinkLibraries().end();
-  if(project->NeedsDependencies(dspname))
+  for(;i!= end; ++i)
     {
-    for(;i!= end; ++i)
+    if(*i != dspname)
       {
-      if(*i != dspname)
+      if (!l.m_IsALibrary || 
+          project->GetLibraryBuildType() == cmDSPMakefile::DLL)
         {
         fout << "Begin Project Dependency\n";
         fout << "Project_Dep_Name " << *i << "\n";
@@ -138,7 +143,7 @@ void cmDSWMakefile::WriteProject(std::ostream& fout,
         }
       }
     }
-
+  
   // write utility dependencies.
   i = project->GetMakefile()->GetUtilities().begin();
   end = project->GetMakefile()->GetUtilities().end();

Source/cmDSWMakefile.h

@@ -47,7 +47,7 @@ private:
   void WriteDSWHeader(std::ostream& fout);
   void WriteProject(std::ostream& fout, 
                     const char* name, const char* path,
-                    cmDSPMakefile* project);
+                    cmDSPMakefile* project, const cmTarget &t);
   void WriteDSWFooter(std::ostream& fout);
   cmMakefile* m_Makefile;
 };

Source/cmDSWWriter.cxx

@@ -87,16 +87,19 @@ void cmDSWMakefile::WriteDSWFile(std::ostream& fout)
     // remove the home directory and / from the source directory
     // this gives a relative path 
     cmSystemTools::ReplaceString(dir, homedir.c_str(), "");
+
     // Get the list of create dsp files names from the cmDSPMakefile, more
     // than one dsp could have been created per input CMakeLists.txt file
-    std::vector<std::string> dspnames =
+    // for each target
-      pg->GetDSPMakefile()->GetCreatedProjectNames();
+    std::vector<std::string> dspnames = pg->GetDSPMakefile()->GetCreatedProjectNames();
-    for(std::vector<std::string>::iterator si = dspnames.begin();
+    const cmTargets &tgts = pg->GetDSPMakefile()->GetMakefile()->GetTargets();
-	si != dspnames.end(); ++si)
+    cmTargets::const_iterator l = tgts.begin();
+    for(std::vector<std::string>::iterator si = dspnames.begin(); 
+        l != tgts.end(); ++l, ++si)
       {
       // Write the project into the DSW file
       this->WriteProject(fout, si->c_str(), dir.c_str(), 
-                         pg->GetDSPMakefile());
+                         pg->GetDSPMakefile(),l->second);
       }
     // delete the cmMakefile which also deletes the cmMSProjectGenerator
     delete mf;
@@ -112,7 +115,8 @@ void cmDSWMakefile::WriteDSWFile(std::ostream& fout)
 void cmDSWMakefile::WriteProject(std::ostream& fout, 
 				 const char* dspname,
 				 const char* dir,
-                                 cmDSPMakefile* project)
+                                 cmDSPMakefile* project,
+                                 const cmTarget &l)
 {
   fout << "#########################################################"
     "######################\n\n";
@@ -126,11 +130,12 @@ void cmDSWMakefile::WriteProject(std::ostream& fout,
   std::vector<std::string>::iterator i, end;
   i = project->GetMakefile()->GetLinkLibraries().begin();
   end = project->GetMakefile()->GetLinkLibraries().end();
-  if(project->NeedsDependencies(dspname))
+  for(;i!= end; ++i)
     {
-    for(;i!= end; ++i)
+    if(*i != dspname)
       {
-      if(*i != dspname)
+      if (!l.m_IsALibrary || 
+          project->GetLibraryBuildType() == cmDSPMakefile::DLL)
         {
         fout << "Begin Project Dependency\n";
         fout << "Project_Dep_Name " << *i << "\n";
@@ -138,7 +143,7 @@ void cmDSWMakefile::WriteProject(std::ostream& fout,
         }
       }
     }
-
+  
   // write utility dependencies.
   i = project->GetMakefile()->GetUtilities().begin();
   end = project->GetMakefile()->GetUtilities().end();

Source/cmDSWWriter.h

@@ -47,7 +47,7 @@ private:
   void WriteDSWHeader(std::ostream& fout);
   void WriteProject(std::ostream& fout, 
                     const char* name, const char* path,
-                    cmDSPMakefile* project);
+                    cmDSPMakefile* project, const cmTarget &t);
   void WriteDSWFooter(std::ostream& fout);
   cmMakefile* m_Makefile;
 };

Source/cmMakeDepend.cxx

@@ -55,21 +55,23 @@ void cmMakeDepend::SetMakefile(cmMakefile* makefile)
     this->AddSearchPath(j->c_str());
     }
   // Now create cmDependInformation objects for files in the directory
-  int index = 0;
+  cmMakefile::ClassMap &Classes = m_Makefile->GetClasses();
-  std::vector<cmClassFile>::iterator i = makefile->m_Classes.begin();
+  for(cmMakefile::ClassMap::iterator l = Classes.begin(); 
-  while(i != makefile->m_Classes.end())
+      l != Classes.end(); l++)
     {
-    if(!(*i).m_HeaderFileOnly)
+    for(std::vector<cmClassFile>::iterator i = l->second.begin(); 
+        i != l->second.end(); ++i)
       {
-      cmDependInformation* info = new cmDependInformation;
+      if(!i->m_HeaderFileOnly)
-      info->m_FullPath = this->FullPath((*i).m_FullPath.c_str());
+        {
-      this->AddFileToSearchPath(info->m_FullPath.c_str());
+        cmDependInformation* info = new cmDependInformation;
-      info->m_IncludeName = (*i).m_FullPath;
+        info->m_FullPath = this->FullPath(i->m_FullPath.c_str());
-      m_DependInformation.push_back(info);
+        this->AddFileToSearchPath(info->m_FullPath.c_str());
-      info->m_ClassFileIndex = index;
+        info->m_IncludeName = i->m_FullPath;
+        info->m_ClassFileIndex = i;
+        m_DependInformation.push_back(info);
+        }
       }
-    ++i;
-    index++;
     }
 }
 
@@ -99,9 +101,9 @@ void cmMakeDepend::DoDepends()
     // Remove duplicate depends
     info->RemoveDuplicateIndices();
     // find the class 
-    if(info->m_ClassFileIndex != -1)
+    if(info->m_ClassFileIndex != 0)
       {
-      cmClassFile& cfile = m_Makefile->m_Classes[info->m_ClassFileIndex];
+      cmClassFile& cfile = *(info->m_ClassFileIndex);
       for( std::vector<int>::iterator indx = info->m_Indices.begin();
 	   indx != info->m_Indices.end(); ++indx)
 	{
@@ -126,9 +128,9 @@ void cmMakeDepend::Depend(cmDependInformation* info)
     {
     // The cmClassFile may have had hints for dependencies.  Delete any that
     // exist since we can find the dependencies for real.
-    if(info->m_ClassFileIndex != -1)
+    if(info->m_ClassFileIndex != 0)
       {
-      cmClassFile& cFile = m_Makefile->m_Classes[info->m_ClassFileIndex];
+      cmClassFile& cFile = *(info->m_ClassFileIndex);
       cFile.m_Depends.erase(cFile.m_Depends.begin(), cFile.m_Depends.end());
       }
     
@@ -140,10 +142,10 @@ void cmMakeDepend::Depend(cmDependInformation* info)
   
   // The file doesn't exist.  See if the cmClassFile for it has any files
   // specified as dependency hints.
-  if(info->m_ClassFileIndex != -1)
+  if(info->m_ClassFileIndex != 0)
     {
     // Get the cmClassFile corresponding to this.
-    cmClassFile& cFile = m_Makefile->m_Classes[info->m_ClassFileIndex];
+    cmClassFile& cFile = *(info->m_ClassFileIndex);
     // See if there are any hints for finding dependencies for the missing
     // file.
     if(!cFile.m_Depends.empty())

Source/cmMakeDepend.h

@@ -35,7 +35,7 @@ struct cmDependInformation
   cmDependInformation() 
     {
     m_DependDone = false;
-    m_ClassFileIndex = -1;
+    m_ClassFileIndex = 0;
     }
 
   /**
@@ -56,9 +56,9 @@ struct cmDependInformation
 
   /**
    * The index into the cmMakefile::m_Classes list.
-   * The index value of -1 indicates that it is not in the list.
+   * The index value of 0 indicates that it is not in the list.
    */
-  int m_ClassFileIndex;	
+  cmClassFile *m_ClassFileIndex;	
   
   /**
    * This flag indicates whether dependency checking has been

Source/cmMakefile.cxx

@@ -89,9 +89,26 @@ void cmMakefile::PrintStringVector(const char* s, std::vector<std::string>& v)
 // call print on all the classes in the makefile
 void cmMakefile::Print()
 {
+  // print the class lists
   std::cout << "classes:\n";
-  for(unsigned int i = 0; i < m_Classes.size(); i++)
+  for(ClassMap::const_iterator l = m_Classes.begin(); 
-    m_Classes[i].Print();
+      l != m_Classes.end(); l++)
+    {
+    std::cout << " Class list named: " << l->first << std::endl;
+    for(std::vector<cmClassFile>::const_iterator i = l->second.begin(); 
+        i != l->second.end(); i++)
+      {
+      i->Print();
+      }
+    }
+  
+  std::cout << " m_Targets: ";
+  for (cmTargets::const_iterator l = m_Targets.begin();
+       l != m_Targets.end(); l++)
+    {
+    std::cout << l->first << std::endl;
+    }
+
   std::cout << " m_CurrentOutputDirectory; " << 
     m_CurrentOutputDirectory.c_str() << std::endl;
   std::cout << " m_StartOutputDirectory; " << 
@@ -104,7 +121,6 @@ void cmMakefile::Print()
     m_cmStartDirectory.c_str() << std::endl;
   std::cout << " m_cmHomeDirectory; " << 
     m_cmHomeDirectory.c_str() << std::endl;
-  std::cout << " m_LibraryName;	" <<  m_LibraryName.c_str() << std::endl;
   std::cout << " m_ProjectName;	" <<  m_ProjectName.c_str() << std::endl;
   this->PrintStringVector("m_SubDirectories ", m_SubDirectories); 
   this->PrintStringVector("m_MakeVerbatim ", m_MakeVerbatim); 
@@ -192,7 +208,8 @@ bool cmMakefile::ReadListFile(const char* filename)
                 {
                 cmSystemTools::Error(usedCommand->GetName(),
                                      ": Error : \n",
-                                     usedCommand->GetError());
+                                     usedCommand->GetError(),
+                                     m_cmCurrentDirectory.c_str());
                 }
               else
                 {
@@ -221,6 +238,26 @@ bool cmMakefile::ReadListFile(const char* filename)
 
   
 
+cmClassFile *cmMakefile::GetClass(const char *srclist, const char *cname)
+{
+  ClassMap::iterator sl = m_Classes.find(srclist);
+  // find the src list
+  if (sl == m_Classes.end())
+    {
+    return 0;
+    }
+  // find the class
+  for (std::vector<cmClassFile>::iterator i = sl->second.begin();
+       i != sl->second.end(); ++i)
+    {
+    if (i->m_ClassName == cname)
+      {
+      return &(*i);
+      }
+    }
+  return 0;
+}
+
 void cmMakefile::AddCommand(cmCommand* wg)
 {
   std::string name = wg->GetName();
@@ -252,36 +289,34 @@ void cmMakefile::GenerateMakefile()
   m_MakefileGenerator->GenerateMakefile();
 }
 
-void cmMakefile::AddClass(cmClassFile& cmfile)
+void cmMakefile::AddClass(cmClassFile& cmfile, const char *srclist)
 {
-  m_Classes.push_back(cmfile);
+  m_Classes[srclist].push_back(cmfile);
+}
 
-  if(!cmfile.m_IsExecutable && !cmfile.m_HeaderFileOnly)
+void cmMakefile::AddCustomCommand(const char* source,
+                                  const char* command,
+                                  const std::vector<std::string>& depends,
+                                  const std::vector<std::string>& outputs,
+                                  const char *target) 
+{
+  // find the target, 
+  if (m_Targets.find(target) != m_Targets.end())
     {
-    // Add the file to the list of sources.
+    cmCustomCommand cc(source,command,depends,outputs);
-    std::string source = cmfile.m_FullPath;
+    m_Targets[target].m_CustomCommands.push_back(cc);
-    cmSourceGroup& sourceGroup = this->FindSourceGroup(source.c_str());
-    sourceGroup.AddSource(source.c_str());
     }
 }
 
 void cmMakefile::AddCustomCommand(const char* source,
                                   const char* command,
                                   const std::vector<std::string>& depends,
-                                  const std::vector<std::string>& outputs) 
+                                  const char* output, 
-{
+                                  const char *target) 
-  cmSourceGroup& sourceGroup = this->FindSourceGroup(source);
-  sourceGroup.AddCustomCommand(source, command, depends, outputs);
-}
-
-void cmMakefile::AddCustomCommand(const char* source,
-                                  const char* command,
-                                  const std::vector<std::string>& depends,
-                                  const char* output) 
 {
   std::vector<std::string> outputs;
   outputs.push_back(output);
-  this->AddCustomCommand(source, command, depends, outputs);
+  this->AddCustomCommand(source, command, depends, outputs, target);
 }
 
 void cmMakefile::AddDefineFlag(const char* flag)
@@ -290,24 +325,6 @@ void cmMakefile::AddDefineFlag(const char* flag)
   m_DefineFlags += flag;
 }
 
-void cmMakefile::AddExecutable(cmClassFile& cf)
-{
-  cf.m_IsExecutable = true;
-  m_Classes.push_back(cf);
-}
-
-bool cmMakefile::HasExecutables()
-{
-  for(unsigned int i = 0; i < m_Classes.size(); i++)
-    {
-    if (m_Classes[i].m_IsExecutable)
-      {
-      return true;
-      }
-    }
-  return false;
-}
-
 void cmMakefile::AddUtility(const char* util)
 {
   m_Utilities.push_back(util);
@@ -348,11 +365,24 @@ void cmMakefile::SetProjectName(const char* p)
   m_ProjectName = p;
 }
 
-void cmMakefile::SetLibraryName(const char* l)
+void cmMakefile::AddLibrary(const char* lname, const std::vector<std::string> &srcs)
 {
-  m_LibraryName = l;
+  cmTarget target;
+  target.m_IsALibrary = 1;
+  target.m_SourceLists = srcs;
+  m_Targets.insert(cmTargets::value_type(lname,target));
 }
 
+void cmMakefile::AddExecutable(const char *exeName, 
+                               const std::vector<std::string> &srcs)
+{
+  cmTarget target;
+  target.m_IsALibrary = 0;
+  target.m_SourceLists = srcs;
+  m_Targets.insert(cmTargets::value_type(exeName,target));
+}
+
+
 void cmMakefile::AddSourceGroup(const char* name, const char* regex)
 {
   // First see if the group exists.  If so, replace its regular expression.
@@ -491,9 +521,9 @@ int cmMakefile::DumpDocumentationToFile(const char *fileName)
 }
 
 
-void cmMakefile::ExpandVariablesInString(std::string& source)
+void cmMakefile::ExpandVariablesInString(std::string& source) const
 {
-  for(DefinitionMap::iterator i = m_Definitions.begin();
+  for(DefinitionMap::const_iterator i = m_Definitions.begin();
       i != m_Definitions.end(); ++i)
     {
     std::string variable = "${";
@@ -594,7 +624,9 @@ void cmMakefile::AddDefaultDefinitions()
  * non-inherited SOURCE_GROUP commands will have precedence over
  * inherited ones.
  */
-cmSourceGroup& cmMakefile::FindSourceGroup(const char* source)
+cmSourceGroup& 
+cmMakefile::FindSourceGroup(const char* source,
+                            std::vector<cmSourceGroup> &groups)
 {
   std::string file = source;
   std::string::size_type pos = file.rfind('/');
@@ -603,8 +635,8 @@ cmSourceGroup& cmMakefile::FindSourceGroup(const char* source)
     file = file.substr(pos, file.length()-pos);
     }
 
-  for(std::vector<cmSourceGroup>::reverse_iterator sg = m_SourceGroups.rbegin();
+  for(std::vector<cmSourceGroup>::reverse_iterator sg = groups.rbegin();
-      sg != m_SourceGroups.rend(); ++sg)
+      sg != groups.rend(); ++sg)
     {
     if(sg->Matches(file.c_str()))
       {
@@ -613,5 +645,39 @@ cmSourceGroup& cmMakefile::FindSourceGroup(const char* source)
     }
   
   // Shouldn't get here, but just in case, return the default group.
-  return m_SourceGroups.front();
+  return groups.front();
 }
+
+// take srclists and put all the classes into a vector
+std::vector<cmClassFile> 
+cmMakefile::GetClassesFromSourceLists(
+  const std::vector<std::string> &srcLists)
+{
+  std::vector<cmClassFile> result;
+  
+  // for each src lists add the classes
+  for (std::vector<std::string>::const_iterator s = srcLists.begin();
+       s != srcLists.end(); ++s)
+    {
+    // replace any variables
+    std::string temps = *s;
+    this->ExpandVariablesInString(temps);
+    // look for a srclist
+    if (m_Classes.find(temps) != m_Classes.end())
+      {
+      const std::vector<cmClassFile> &clsList = 
+        m_Classes.find(temps)->second;
+      result.insert(result.end(), clsList.begin(), clsList.end());
+      }
+    // if one wasn't found then assume it is a single class
+    else
+      {
+      cmClassFile file;
+      file.m_AbstractClass = false;
+      file.SetName(temps.c_str(), this->GetCurrentDirectory());
+      result.push_back(file);
+      }
+    }
+  return result;
+}
+

Source/cmMakefile.h

@@ -20,7 +20,7 @@
 #include "cmClassFile.h"
 #include "cmSystemTools.h"
 #include "cmSourceGroup.h"
-
+#include "cmTarget.h"
 class cmCommand;
 class cmMakefileGenerator;
 
@@ -77,12 +77,14 @@ public:
   void AddCustomCommand(const char* source,
                         const char* command,
                         const std::vector<std::string>& depends,
-                        const std::vector<std::string>& outputs);
+                        const std::vector<std::string>& outputs,
+                        const char *target);
 
   void AddCustomCommand(const char* source,
                         const char* command,
                         const std::vector<std::string>& depends,
-                        const char* output);
+                        const char* output,
+                        const char* target);
   
   /**
    * Add a define flag to the build.
@@ -92,7 +94,7 @@ public:
   /**
    * Add an executable to the build.
    */
-  void AddExecutable(cmClassFile&);
+  void AddExecutable(const char *exename, const std::vector<std::string> &srcs);
 
   /**
    * Add a utility on which this project depends.
@@ -146,12 +148,12 @@ public:
   /**
    * Set the name of the library.
    */
-  void SetLibraryName(const char*);
+  void AddLibrary(const char *libname, const std::vector<std::string> &srcs);
 
   /**
    * Add a class/source file to the build.
    */
-  void AddClass(cmClassFile& );
+  void AddClass(cmClassFile& ,const char *srcListName);
 
   /**
    * Add a source group for consideration when adding a new source.
@@ -269,12 +271,9 @@ public:
     }
 
   /**
-   * Specify the name of the library that is built by this makefile.
+   * Get the list of targets
    */
-  const char* GetLibraryName()
+  const cmTargets &GetTargets() { return m_Targets; }
-    {
-    return m_LibraryName.c_str();
-    }
 
   /**
    * Get a list of the build subdirectories.
@@ -284,12 +283,6 @@ public:
     return m_SubDirectories;
     }
 
-  /**
-   * Return a boolean flag indicating whether the build generates
-   * any executables.
-   */
-  bool HasExecutables();
-
   /**
    * Get a list of include directories in the build.
    */
@@ -349,9 +342,17 @@ public:
   /**
    * Return a list of source files in this makefile.
    */
-  std::vector<cmClassFile>& GetClasses()
+  typedef std::map<std::string,std::vector<cmClassFile> > ClassMap;
-    {return  m_Classes;}
+  ClassMap &GetClasses() {return  m_Classes;}
-
+  cmClassFile *GetClass(const char *srclist, const char *className);
+  
+    
+  /**
+   * Return a list of classes in the passed source lists
+   */
+  std::vector<cmClassFile> GetClassesFromSourceLists(
+    const std::vector<std::string> &srcLists);
+  
   /**
    * Obtain a list of auxiliary source directories.
    */
@@ -400,7 +401,7 @@ public:
    * entry in the m_Definitions map.  Also @var@ is
    * expanded to match autoconf style expansions.
    */
-  void ExpandVariablesInString(std::string& source);
+  void ExpandVariablesInString(std::string& source) const;
 
   /**
    * Expand variables in the makefiles ivars such as link directories etc
@@ -421,6 +422,12 @@ public:
    */
   void GenerateCacheOnly();
 
+  /**
+   * find what source group this source is in
+   */
+  cmSourceGroup& FindSourceGroup(const char* source,
+                                 std::vector<cmSourceGroup> &groups);
+
 protected:
   std::string m_Prefix;
   std::vector<std::string> m_AuxSourceDirectories; // 
@@ -432,9 +439,12 @@ protected:
   std::string m_cmHomeDirectory; 
   std::string m_HomeOutputDirectory;
 
-  std::string m_LibraryName;	// library name
   std::string m_ProjectName;	// project name
-  std::vector<cmClassFile> m_Classes; // list of classes in makefile
+
+  // libraries, classes, and executables
+  cmTargets m_Targets;
+  ClassMap m_Classes; 
+
   std::vector<std::string> m_SubDirectories; // list of sub directories
   std::vector<std::string> m_MakeVerbatim; // lines copied from input file
   std::vector<std::string> m_IncludeDirectories;
@@ -454,6 +464,7 @@ protected:
   std::vector<cmCommand*> m_UsedCommands;
   cmMakefileGenerator* m_MakefileGenerator;
   
+  
 private:
   /**
    * Get the name of the parent directories CMakeLists file
@@ -468,7 +479,6 @@ private:
   void AddDefaultCommands();
   void AddDefaultDefinitions();
   
-  cmSourceGroup& FindSourceGroup(const char* source);
 };
 
 

Source/cmSourceFilesCommand.cxx

@@ -23,13 +23,13 @@ bool cmSourceFilesCommand::Invoke(std::vector<std::string>& args)
     this->SetError("called with incorrect number of arguments");
     return false;
     }
-  for(std::vector<std::string>::iterator i = args.begin();
+  for(std::vector<std::string>::iterator i = (args.begin() + 1);
       i != args.end(); ++i)
     {
     cmClassFile file;
     file.m_AbstractClass = false;
     file.SetName((*i).c_str(), m_Makefile->GetCurrentDirectory());
-    m_Makefile->AddClass(file);
+    m_Makefile->AddClass(file, args[0].c_str());
     }
   return true;
 }

Source/cmSourceFilesCommand.h

@@ -57,7 +57,7 @@ public:
    */
   virtual const char* GetTerseDocumentation() 
     {
-    return "Add a list of source files.";
+    return "Add a list of source files, associate them with a NAME.";
     }
   
   /**
@@ -66,7 +66,7 @@ public:
   virtual const char* GetFullDocumentation()
     {
     return
-      "SOURCE_FILES(file1 file2 ...)";
+      "SOURCE_FILES(NAME file1 file2 ...)";
     }
   
   cmTypeMacro(cmSourceFilesCommand, cmCommand);

Source/cmSourceFilesRequireCommand.cxx

@@ -18,7 +18,7 @@
 // cmSourceFilesRequireCommand
 bool cmSourceFilesRequireCommand::Invoke(std::vector<std::string>& args)
 {
-  if(args.size() < 3 )
+  if(args.size() < 4 )
     {
     this->SetError("called with incorrect number of arguments");
     return false;
@@ -42,12 +42,14 @@ bool cmSourceFilesRequireCommand::Invoke(std::vector<std::string>& args)
     }
   
   // Add the rest of the arguments as source files
+  const char *sname = (*i).c_str();
+  ++i;
   for(; i != args.end(); ++i)
     {
     cmClassFile file;
     file.m_AbstractClass = false;
     file.SetName((*i).c_str(), m_Makefile->GetCurrentDirectory());
-    m_Makefile->AddClass(file);
+    m_Makefile->AddClass(file, sname);
     }
   return true;
 }

Source/cmSourceFilesRequireCommand.h

@@ -55,8 +55,8 @@ public:
    */
   virtual const char* GetTerseDocumentation() 
     {
-    return "Add a list of source files if the required \n"
+    return "Add a list of source files to the source file list NAME\n"
-           "variables are set.";
+      "if the required variables are set.";
     }
   
   /**
@@ -65,7 +65,7 @@ public:
   virtual const char* GetFullDocumentation()
     {
     return
-      "SOURCE_FILES_REQUIRE(var1 var2 ... SOURCES_BEGIN file1 file2 ...)";
+      "SOURCE_FILES_REQUIRE(var1 var2 ... SOURCES_BEGIN NAME file1 file2 ...)";
     }
   
   cmTypeMacro(cmSourceFilesRequireCommand, cmCommand);

Source/cmSourceGroup.cxx

@@ -53,35 +53,32 @@ bool cmSourceGroup::Matches(const char* name)
  * If the command also already exists, the given dependencies and outputs
  * are added to it.
  */
-void cmSourceGroup::AddCustomCommand(const char* source,
+void cmSourceGroup::AddCustomCommand(const cmCustomCommand &cmd)
-                                     const char* command,
-                                     const std::vector<std::string>& depends,
-                                     const std::vector<std::string>& outputs) 
 {
-  CustomCommands::iterator s = m_CustomCommands.find(source);
+  CustomCommands::iterator s = m_CustomCommands.find(cmd.m_Source);
   if(s == m_CustomCommands.end())
     {
     // The source was not found.  Add it with this command.
-    m_CustomCommands[source][command].m_Depends.insert(depends.begin(),
+    m_CustomCommands[cmd.m_Source][cmd.m_Command].
-                                                       depends.end());
+      m_Depends.insert(cmd.m_Depends.begin(),cmd.m_Depends.end());
-    m_CustomCommands[source][command].m_Outputs.insert(outputs.begin(),
+    m_CustomCommands[cmd.m_Source][cmd.m_Command].
-                                                       outputs.end());
+      m_Outputs.insert(cmd.m_Outputs.begin(),cmd.m_Outputs.end());
     return;
     }
   
   // The source already exists.  See if the command exists.
   Commands& commands = s->second;
-  Commands::iterator c = commands.find(command);
+  Commands::iterator c = commands.find(cmd.m_Command);
   if(c == commands.end())
     {
     // The command did not exist.  Add it.
-    commands[command].m_Depends.insert(depends.begin(), depends.end());
+    commands[cmd.m_Command].m_Depends.insert(cmd.m_Depends.begin(), cmd.m_Depends.end());
-    commands[command].m_Outputs.insert(outputs.begin(), outputs.end());
+    commands[cmd.m_Command].m_Outputs.insert(cmd.m_Outputs.begin(), cmd.m_Outputs.end());
     return;
     }
   
   // The command already exists for this source.  Merge the sets.
   CommandFiles& commandFiles = c->second;
-  commandFiles.m_Depends.insert(depends.begin(), depends.end());
+  commandFiles.m_Depends.insert(cmd.m_Depends.begin(), cmd.m_Depends.end());
-  commandFiles.m_Outputs.insert(outputs.begin(), outputs.end());
+  commandFiles.m_Outputs.insert(cmd.m_Outputs.begin(), cmd.m_Outputs.end());
 }

Source/cmSourceGroup.h

@@ -18,6 +18,7 @@
 
 #include "cmStandardIncludes.h"
 #include "cmRegularExpression.h"
+#include "cmCustomCommand.h"
 #include <set>
 
 /** \class cmSourceGroup
@@ -58,10 +59,7 @@ public:
     { m_GroupRegex.compile(regex); }
   void AddSource(const char* name)
     { m_Sources.push_back(name); }
-  void AddCustomCommand(const char* source,
+  void AddCustomCommand(const cmCustomCommand &cmd);
-                        const char* command,
-                        const std::vector<std::string>& depends,
-                        const std::vector<std::string>& outputs);
   const char* GetName() const
     { return m_Name.c_str(); }
   const std::vector<std::string>& GetSources() const

Source/cmTarget.h

@@ -0,0 +1,38 @@
+/*=========================================================================
+
+  Program:   Insight Segmentation & Registration Toolkit
+  Module:    $RCSfile$
+  Language:  C++
+  Date:      $Date$
+  Version:   $Revision$
+
+
+  Copyright (c) 2000 National Library of Medicine
+  All rights reserved.
+
+  See COPYRIGHT.txt for copyright details.
+
+=========================================================================*/
+#ifndef cmTarget_h
+#define cmTarget_h
+
+#include "cmStandardIncludes.h"
+#include "cmCustomCommand.h"
+
+/** \class cmTarget
+ * \brief Represent a library or executable target loaded from a makefile.
+ *
+ * cmTarget represents a target loaded from 
+ * a makefile.
+ */
+class cmTarget
+{
+public:
+  std::vector<cmCustomCommand> m_CustomCommands;
+  bool m_IsALibrary;
+  std::vector<std::string> m_SourceLists;
+};
+
+typedef std::map<std::string,cmTarget> cmTargets;
+
+#endif

Source/cmTestsCommand.cxx

@@ -18,18 +18,7 @@
 // cmExecutableCommand
 bool cmTestsCommand::Invoke(std::vector<std::string>& args)
 {
-  if(args.size() < 1 )
+  // does nothing in CMake
-    {
-    this->SetError("called with incorrect number of arguments");
-    return false;
-    }
-  for(std::vector<std::string>::iterator i = args.begin();
-      i != args.end(); ++i)
-    {
-    cmClassFile file;
-    file.SetName((*i).c_str(), m_Makefile->GetCurrentDirectory());
-    m_Makefile->AddExecutable(file);
-    }
   return true;
 }
 

Source/cmUnixMakefileGenerator.cxx

@@ -54,49 +54,140 @@ void cmUnixMakefileGenerator::OutputMakefile(const char* file)
     return;
     }
   this->OutputMakeFlags(fout);
-  this->OutputSourceToObjectList(fout);
   this->OutputVerbatim(fout);
-  this->OutputExecutableRules(fout);
+  this->OutputTargetRules(fout);
+  this->OutputLinkLibs(fout);
+  this->OutputTargets(fout);
   this->OutputSubDirectoryRules(fout);
   this->OutputObjectDepends(fout);
   this->OutputCustomRules(fout);
 }
 
-// Output the LIBRARY and SRC_OBJS list based on
+// Output the rules for any targets
-// the library name and cmClassFile objects in the
+void cmUnixMakefileGenerator::OutputTargetRules(std::ostream& fout)
-// makefile
-void cmUnixMakefileGenerator::OutputSourceToObjectList(std::ostream& fout)
 {
-  std::vector<cmClassFile>& Classes = m_Makefile->GetClasses();
+  // for each target add to the list of targets
-  if(Classes.size() == 0)
+  fout << "TARGETS = ";
+  const cmTargets &tgts = m_Makefile->GetTargets();
+  for(cmTargets::const_iterator l = tgts.begin(); 
+      l != tgts.end(); l++)
     {
-    return;
+    if (l->second.m_IsALibrary)
-    }
-  // Ouput Library name if there are SRC_OBJS
-  if(strlen(m_Makefile->GetLibraryName()) > 0)
-    {
-    fout << "LIBRARY = " <<  m_Makefile->GetLibraryName() << "\n\n";
-    fout << "BUILD_LIB_FILE = lib${LIBRARY}${CMAKE_LIB_EXT}\n\n";
-    }
-  // Output SRC_OBJ list for all the classes to be compiled
-  fout << "SRC_OBJ = \\\n";
-  for(unsigned int i = 0; i < Classes.size(); i++)
-    {
-    if(!Classes[i].m_AbstractClass && !Classes[i].m_HeaderFileOnly
-       && !Classes[i].m_IsExecutable)
       {
-      fout << Classes[i].m_ClassName << ".o ";
+      fout << " \\\nlib" << l->first.c_str() << "${CMAKE_LIB_EXT}";
-      if(i ==  Classes.size() -1)
+      }
-        {
+    else
-        fout << "\n\n";
+      {
-        }
+      fout << "\\\n" << l->first.c_str();
-      else
+      }
-        {
+    }
-        fout << "\\\n";
+  fout << "\n\n";
-        }
+  
+  // get the classes from the source lists then add them to the groups
+  for(cmTargets::const_iterator l = tgts.begin(); 
+      l != tgts.end(); l++)
+    {
+    std::vector<cmClassFile> classes = 
+      m_Makefile->GetClassesFromSourceLists(l->second.m_SourceLists);
+    fout << l->first << "_SRC_OBJS = ";
+    for(std::vector<cmClassFile>::iterator i = classes.begin(); 
+        i != classes.end(); i++)
+      {
+      if(!i->m_HeaderFileOnly)
+        {
+        fout << "\\\n" << i->m_ClassName << ".o ";
+        }
+      }
+    fout << "\n\n";
+    }
+}
+
+// Output the rules for any targets
+void cmUnixMakefileGenerator::OutputLinkLibs(std::ostream& fout)
+{
+  // collect all the flags needed for linking libraries
+  std::string linkLibs;        
+  std::vector<std::string>::iterator j;
+  std::vector<std::string>& libdirs = m_Makefile->GetLinkDirectories();
+  for(j = libdirs.begin(); j != libdirs.end(); ++j)
+    { 
+    std::string::size_type pos = (*j).find("-L");
+    if((pos == std::string::npos || pos > 0)
+       && (*j).find("${") == std::string::npos)
+      {
+      linkLibs += "-L";
+      }
+    linkLibs += *j;
+    linkLibs += " ";
+    }
+  std::string librariesLinked;
+  std::vector<std::string>& libs = m_Makefile->GetLinkLibraries();
+  for(j = libs.begin(); j != libs.end(); ++j)
+    {
+    std::string::size_type pos = (*j).find("-l");
+    if((pos == std::string::npos || pos > 0)
+       && (*j).find("${") == std::string::npos)
+      {
+      librariesLinked += "-l";
+      }
+    librariesLinked += *j;
+    librariesLinked += " ";
+    }
+  // Add these in twice so order does not matter
+  linkLibs += librariesLinked;
+  linkLibs += librariesLinked;
+  
+  std::vector<std::string>& libsUnix = m_Makefile->GetLinkLibrariesUnix();
+  for(j = libsUnix.begin(); j != libsUnix.end(); ++j)
+    {
+    linkLibs += *j;
+    linkLibs += " ";
+    }
+  linkLibs += " ${LOCAL_LINK_FLAGS} ";
+  fout << "CMAKE_LINK_LIBS = " << linkLibs << "\n\n";
+  // create and output a varible in the makefile that
+  // each executable will depend on.  This will have all the
+  // libraries that the executable uses
+  fout << "CMAKE_DEPEND_LIBS = ";
+  this->OutputDependencies(fout);
+}
+
+void cmUnixMakefileGenerator::OutputTargets(std::ostream& fout)
+{
+  // for each target
+  const cmTargets &tgts = m_Makefile->GetTargets();
+  for(cmTargets::const_iterator l = tgts.begin(); 
+      l != tgts.end(); l++)
+    {
+    if (l->second.m_IsALibrary)
+      {
+      fout << "#---------------------------------------------------------\n";
+      fout << "# rules for a library\n";
+      fout << "#\n";
+      fout << "lib" << l->first << ".a: ${KIT_OBJ} ${" << 
+        l->first << "_SRC_OBJS} \n";
+      fout << "\t${AR} cr lib" << l->first << ".a ${KIT_OBJ} ${" << 
+        l->first << "_SRC_OBJS} \n";
+      fout << "\t${RANLIB} lib" << l->first << ".a\n";
+      fout << std::endl;
+
+      fout << "lib" << l->first << "$(SHLIB_SUFFIX): ${KIT_OBJ} ${" << 
+        l->first << "_SRC_OBJS} \n";
+      fout << "\trm -f lib" << l->first << "$(SHLIB_SUFFIX)\n";
+      fout << "\t$(CXX) ${CXX_FLAGS} ${CMAKE_SHLIB_BUILD_FLAGS} -o \\\n";
+      fout << "\t  lib" << l->first << "$(SHLIB_SUFFIX) \\\n";
+      fout << "\t  ${KIT_OBJ} ${" << l->first << 
+        "_SRC_OBJS} ${SHLIB_LD_LIBS}\n\n";
+      }
+    else
+      {
+      fout << l->first << ": ${" << 
+        l->first << "_SRC_OBJS} ${CMAKE_DEPEND_LIBS}\n";
+      fout << "\t${CXX}  ${CXX_FLAGS} ${" << 
+        l->first << "_SRC_OBJS} ${CMAKE_LINK_LIBS} -o " 
+           << l->first << "\n\n";
       }
     }
-  fout << "\n";
 }
 
 
@@ -171,7 +262,7 @@ void cmUnixMakefileGenerator::OutputMakeFlags(std::ostream& fout)
     }
   fout << m_Makefile->GetDefineFlags();
   fout << " ${LOCAL_INCLUDE_FLAGS} ";
-  fout << "\n";
+  fout << "\n\n";
   fout << "default_target: all\n\n";
   // see if there are files to compile in this makefile
   // These are used for both libraries and executables
@@ -190,92 +281,6 @@ void cmUnixMakefileGenerator::OutputVerbatim(std::ostream& fout)
   
 }
 
-// output executables
-void cmUnixMakefileGenerator::OutputExecutableRules(std::ostream& fout)
-{
-  if(!m_Makefile->HasExecutables())
-    {
-    return ;
-    }
-  // collect all the flags needed for linking libraries
-  std::string linkLibs;        
-  std::vector<std::string>::iterator j;
-  std::vector<std::string>& libdirs = m_Makefile->GetLinkDirectories();
-  for(j = libdirs.begin(); j != libdirs.end(); ++j)
-    { 
-    std::string::size_type pos = (*j).find("-L");
-    if((pos == std::string::npos || pos > 0)
-       && (*j).find("${") == std::string::npos)
-      {
-      linkLibs += "-L";
-      }
-    linkLibs += *j;
-    linkLibs += " ";
-    }
-  std::string librariesLinked;
-  std::vector<std::string>& libs = m_Makefile->GetLinkLibraries();
-  for(j = libs.begin(); j != libs.end(); ++j)
-    {
-    std::string::size_type pos = (*j).find("-l");
-    if((pos == std::string::npos || pos > 0)
-       && (*j).find("${") == std::string::npos)
-      {
-      librariesLinked += "-l";
-      }
-    librariesLinked += *j;
-    librariesLinked += " ";
-    }
-  // Add these in twice so order does not matter
-  linkLibs += librariesLinked;
-  linkLibs += librariesLinked;
-  
-  std::vector<std::string>& libsUnix = m_Makefile->GetLinkLibrariesUnix();
-  for(j = libsUnix.begin(); j != libsUnix.end(); ++j)
-    {
-    linkLibs += *j;
-    linkLibs += " ";
-    }
-  linkLibs += " ${LOCAL_LINK_FLAGS} ";
-  // create and output a varible in the makefile that
-  // each executable will depend on.  This will have all the
-  // libraries that the executable uses
-  fout << "CMAKE_DEPEND_LIBS = ";
-  this->OutputDependencies(fout);
-  // Now create rules for all of the executables to be built
-  std::vector<cmClassFile>& Classes = m_Makefile->GetClasses();
-  for(unsigned int i = 0; i < Classes.size(); i++)
-    {
-    if(!Classes[i].m_AbstractClass && !Classes[i].m_HeaderFileOnly
-       && Classes[i].m_IsExecutable)
-      { 
-      std::string DotO = Classes[i].m_ClassName;
-      DotO += ".o";
-      fout << Classes[i].m_ClassName << ": " << DotO << " ";
-      fout << "${CMAKE_DEPEND_LIBS}\n";
-      fout << "\t${CXX}  ${CXX_FLAGS}  "
-           << DotO.c_str() << " "
-           << linkLibs.c_str() 
-           << " -o $@ ""\n\n";
-      }
-    }
-  // ouput the list of executables
-  fout << "EXECUTABLES = \\\n";
-  for(unsigned int i = 0; i < Classes.size(); i++)
-    {
-    if(!Classes[i].m_AbstractClass && !Classes[i].m_HeaderFileOnly
-       && Classes[i].m_IsExecutable)
-      { 
-      fout << Classes[i].m_ClassName;
-      if(i < Classes.size()-1)
-        {
-        fout << " \\";
-        }
-      fout << "\n";
-      }
-    }
-  fout << "\n";
-}
-
 // fix up names of directories so they can be used
 // as targets in makefiles.
 inline std::string FixDirectoryName(const char* dir)
@@ -365,29 +370,34 @@ void cmUnixMakefileGenerator::OutputSubDirectoryRules(std::ostream& fout)
 // by the class cmMakeDepend GenerateMakefile
 void cmUnixMakefileGenerator::OutputObjectDepends(std::ostream& fout)
 {
-  std::vector<cmClassFile>& Classes = m_Makefile->GetClasses();
+  cmMakefile::ClassMap &Classes = m_Makefile->GetClasses();
-  for(unsigned int i = 0; i < Classes.size(); i++)
+  for(cmMakefile::ClassMap::iterator l = Classes.begin(); 
+      l != Classes.end(); l++)
     {
-    if(!Classes[i].m_AbstractClass && !Classes[i].m_HeaderFileOnly)
+    for(std::vector<cmClassFile>::iterator i = l->second.begin(); 
+        i != l->second.end(); i++)
       {
-      if( Classes[i].m_Depends.size())
+      if(!i->m_HeaderFileOnly)
-	{
+        {
-	fout << Classes[i].m_ClassName << ".o : \\\n";
+        if(i->m_Depends.size())
-	for(std::vector<std::string>::iterator j =  
+          {
-	      Classes[i].m_Depends.begin();
+          fout << i->m_ClassName << ".o : \\\n";
-	    j != Classes[i].m_Depends.end(); ++j)
+          for(std::vector<std::string>::iterator j =  
-	  {
+                i->m_Depends.begin();
-	  if(j+1 == Classes[i].m_Depends.end())
+              j != i->m_Depends.end(); ++j)
-	    {
+            {
-	    fout << *j << " \n";
+            if(j+1 == i->m_Depends.end())
-	    }
+              {
-	  else
+              fout << *j << " \n";
-	    {
+              }
-	    fout << *j << " \\\n";
+            else
-	    }
+              {
-	  }
+              fout << *j << " \\\n";
-	fout << "\n\n";
+              }
-	}
+            }
+          fout << "\n\n";
+          }
+        }
       }
     }
 }
@@ -398,12 +408,33 @@ void cmUnixMakefileGenerator::OutputObjectDepends(std::ostream& fout)
 //   (tab)   command...
 void cmUnixMakefileGenerator::OutputCustomRules(std::ostream& fout)
 {
+  // We may be modifying the source groups temporarily, so make a copy.
+  std::vector<cmSourceGroup> sourceGroups = m_Makefile->GetSourceGroups();
+  
+  const cmTargets &tgts = m_Makefile->GetTargets();
+  for(cmTargets::const_iterator tgt = tgts.begin(); 
+      tgt != tgts.end(); ++tgt)
+    {
+    // add any custom rules to the source groups
+    for (std::vector<cmCustomCommand>::const_iterator cr = 
+           tgt->second.m_CustomCommands.begin(); 
+         cr != tgt->second.m_CustomCommands.end(); ++cr)
+      {
+      cmSourceGroup& sourceGroup = 
+        m_Makefile->FindSourceGroup(cr->m_Source.c_str(),
+                                    sourceGroups);
+      cmCustomCommand cc(*cr);
+      cc.ExpandVariables(*m_Makefile);
+      sourceGroup.AddCustomCommand(cc);
+      }
+    }
+  
   // Loop through every source group.
   for(std::vector<cmSourceGroup>::const_iterator sg =
-        m_Makefile->GetSourceGroups().begin();
+        sourceGroups.begin(); sg != sourceGroups.end(); ++sg)
-      sg != m_Makefile->GetSourceGroups().end(); ++sg)
     {
-    const cmSourceGroup::CustomCommands& customCommands = sg->GetCustomCommands();
+    const cmSourceGroup::CustomCommands& customCommands = 
+      sg->GetCustomCommands();
     if(customCommands.empty())
       { continue; }
     

Source/cmUnixMakefileGenerator.h

@@ -44,8 +44,9 @@ protected:
   void OutputMakefile(const char* file);
   void OutputMakeFlags(std::ostream&);
   void OutputVerbatim(std::ostream&);
-  void OutputSourceToObjectList(std::ostream& fout);
+  void OutputTargetRules(std::ostream& fout);
-  void OutputExecutableRules(std::ostream&);
+  void OutputLinkLibs(std::ostream& fout);
+  void OutputTargets(std::ostream&);
   void OutputSubDirectoryRules(std::ostream&);
   void OutputDependInformation(std::ostream&);
   void OutputDependencies(std::ostream&);

Source/cmWrapExcludeFilesCommand.cxx

@@ -23,16 +23,21 @@ bool cmWrapExcludeFilesCommand::Invoke(std::vector<std::string>& args)
     this->SetError("called with incorrect number of arguments");
     return false;
     }
+
+  cmMakefile::ClassMap &Classes = m_Makefile->GetClasses();
   for(std::vector<std::string>::iterator j = args.begin();
       j != args.end(); ++j)
     {   
-    std::vector<cmClassFile>& Classes = m_Makefile->GetClasses();
+    for(cmMakefile::ClassMap::iterator l = Classes.begin(); 
-    for(unsigned int i = 0; i < Classes.size(); i++)
+        l != Classes.end(); l++)
       {
-      if(Classes[i].m_ClassName == (*j))
+      for(std::vector<cmClassFile>::iterator i = l->second.begin(); 
+          i != l->second.end(); i++)
         {
-        Classes[i].m_WrapExclude = true;
+        if(i->m_ClassName == (*j))
-        break;
+          {
+          i->m_WrapExclude = true;
+          }
         }
       }
     }

Source/cmWrapTclCommand.cxx

@@ -18,7 +18,7 @@
 // cmWrapTclCommand
 bool cmWrapTclCommand::Invoke(std::vector<std::string>& args)
 {
-  if(args.size() > 0 )
+  if(args.size() < 3 )
     {
     this->SetError("called with incorrect number of arguments");
     return false;
@@ -44,30 +44,43 @@ bool cmWrapTclCommand::Invoke(std::vector<std::string>& args)
       }
     }
 
-  // get the list of classes for this library
-  std::vector<cmClassFile> &classes = m_Makefile->GetClasses();
-  
-  // add in new classes for the wrappers
-  int lastClass = classes.size();
   // what is the current source dir
   std::string cdir = m_Makefile->GetCurrentDirectory();
+
+  // keep the library name
+  m_LibraryName = args[0];
+  m_SourceList = args[1];
   
-  for(int classNum = 0; classNum < lastClass; classNum++)
+  // get the list of classes for this library
-    {
+  cmMakefile::ClassMap &Classes = m_Makefile->GetClasses();
-    cmClassFile &curr = classes[classNum];
+  for(std::vector<std::string>::iterator j = (args.begin() + 2);
-    // if we should wrap the class
+      j != args.end(); ++j)
-    if (!curr.m_WrapExclude)
+    {   
+    for(cmMakefile::ClassMap::iterator l = Classes.begin(); 
+        l != Classes.end(); l++)
       {
-      cmClassFile file;
+      for(std::vector<cmClassFile>::iterator i = l->second.begin(); 
-      file.m_AbstractClass = curr.m_AbstractClass;
+          i != l->second.end(); i++)
-      std::string newName = curr.m_ClassName + "Tcl";
+        {
-      file.SetName(newName.c_str(), m_Makefile->GetCurrentOutputDirectory(),
+        cmClassFile &curr = *i;
-                   "cxx",false);
+        // if we should wrap the class
-      m_WrapClasses.push_back(file);
+        if (!curr.m_WrapExclude)
-      std::string hname = cdir + "/" + curr.m_ClassName + ".h";
+          {
-      m_WrapHeaders.push_back(hname);
+          cmClassFile file;
+          file.m_AbstractClass = curr.m_AbstractClass;
+          std::string newName = curr.m_ClassName + "Tcl";
+          file.SetName(newName.c_str(), m_Makefile->GetCurrentOutputDirectory(),
+                       "cxx",false);
+          std::string hname = cdir + "/" + curr.m_ClassName + ".h";
+          m_WrapHeaders.push_back(hname);
+          // add starting depends
+          file.m_Depends.push_back(hname);
+          m_WrapClasses.push_back(file);
+          }
+        }
       }
     }
+  
   return true;
 }
 
@@ -79,35 +92,31 @@ void cmWrapTclCommand::FinalPass()
   std::string wtcl = "${WRAP_TCL_EXE}";
   std::string hints = "${WRAP_HINTS}";
   
-  m_Makefile->ExpandVariablesInString(wtcl);
-  m_Makefile->ExpandVariablesInString(hints);
-  
   // Create the init file 
-  std::string res = m_Makefile->GetLibraryName();
+  std::string res = m_LibraryName;
   res += "Init.cxx";
   this->CreateInitFile(res);
   
   // add the init file
   cmClassFile cfile;
   cfile.m_AbstractClass = false;
-  std::string newName = m_Makefile->GetLibraryName();
+  std::string newName = m_LibraryName;
   newName += "Init";
   cfile.SetName(newName.c_str(), m_Makefile->GetCurrentOutputDirectory(),
                 "cxx",false);
-  m_Makefile->AddClass(cfile);
+  m_Makefile->AddClass(cfile,m_SourceList.c_str());
   
   // wrap all the .h files
   depends.push_back(wtcl);
   for(int classNum = 0; classNum < lastClass; classNum++)
     {
-    m_Makefile->AddClass(m_WrapClasses[classNum]);
+    m_Makefile->AddClass(m_WrapClasses[classNum],m_SourceList.c_str());
     std::string res = m_WrapClasses[classNum].m_ClassName + ".cxx";
     std::string cmd = wtcl + " " + m_WrapHeaders[classNum] + " "
 		+ hints + (m_WrapClasses[classNum].m_AbstractClass ? " 0 " : " 1 ") + " > " + m_WrapClasses[classNum].m_ClassName + ".cxx";
     m_Makefile->AddCustomCommand(m_WrapHeaders[classNum].c_str(),
-                                 cmd.c_str(),
+                                 cmd.c_str(), depends, 
-                                 depends,
+                                 res.c_str(), m_LibraryName.c_str());
-                                 res.c_str());
     }
   
 }
@@ -117,7 +126,7 @@ bool cmWrapTclCommand::CreateInitFile(std::string& res)
   unsigned int i;
   
   /* we have to make sure that the name is the correct case */
-  std::string kitName = m_Makefile->GetLibraryName();
+  std::string kitName = m_LibraryName;
   if (kitName[0] > 90) kitName[0] -= 32;
   for (i = 1; i < kitName.size(); i++)
     {

Source/cmWrapTclCommand.h

@@ -61,7 +61,7 @@ public:
   virtual const char* GetFullDocumentation()
     {
     return
-      "WRAP_TCL()";
+      "WRAP_TCL(resultingLibraryName SourceListName SourceLists ...)";
     }
 
   /**
@@ -74,6 +74,8 @@ public:
 private:
   std::vector<cmClassFile> m_WrapClasses;
   std::vector<std::string> m_WrapHeaders;
+  std::string m_LibraryName;
+  std::string m_SourceList;
 };