ENH: CABIL -> CABLE rename.

Source/cmCableCommand.cxx

@@ -13,58 +13,58 @@
   See COPYRIGHT.txt for copyright details.
 
 =========================================================================*/
-#include "cmCabilCommand.h"
+#include "cmCableCommand.h"
 #include "cmCacheManager.h"
 
-// cmCabilCommand
+// cmCableCommand
 
 
 /**
- * Constructor initializes to empty m_CabilData.
+ * Constructor initializes to empty m_CableData.
  */
-cmCabilCommand::cmCabilCommand(): m_CabilData(0)
+cmCableCommand::cmCableCommand(): m_CableData(0)
 {
 }
 
 
 /**
- * Destructor frees the cmCabilData only if this command is its owner.
+ * Destructor frees the cmCableData only if this command is its owner.
  */
-cmCabilCommand::~cmCabilCommand()
+cmCableCommand::~cmCableCommand()
 {
-  if(m_CabilData && m_CabilData->OwnerIs(this))
+  if(m_CableData && m_CableData->OwnerIs(this))
     {
-    delete m_CabilData;
+    delete m_CableData;
     }
 }
 
 
 /**
- * Write a CABIL configuration file header.
+ * Write a CABLE configuration file header.
  */
-void cmCabilCommand::WriteConfigurationHeader(std::ostream& os) const
+void cmCableCommand::WriteConfigurationHeader(std::ostream& os) const
 {
   os << "<?xml version=\"1.0\"?>" << std::endl
-     << "<CabilConfiguration>" << std::endl;
+     << "<CableConfiguration>" << std::endl;
 }
 
 
 /**
- * Write a CABIL configuration file footer.
+ * Write a CABLE configuration file footer.
  */
-void cmCabilCommand::WriteConfigurationFooter(std::ostream& os) const
+void cmCableCommand::WriteConfigurationFooter(std::ostream& os) const
 {
-  os << "</CabilConfiguration>" << std::endl;
+  os << "</CableConfiguration>" << std::endl;
 }
 
 
 /**
- * Ensure that this cmCabilCommand has a valid m_CabilData pointer.
+ * Ensure that this cmCableCommand has a valid m_CableData pointer.
  */
-void cmCabilCommand::SetupCabilData()
+void cmCableCommand::SetupCableData()
 {
   // Only do something if the pointer is invalid.
-  if(m_CabilData)
+  if(m_CableData)
     { return; }
   
   // Look through the vector of commands from the makefile.
@@ -73,19 +73,19 @@ void cmCabilCommand::SetupCabilData()
   for(std::vector<cmCommand*>::const_iterator commandIter =
         usedCommands.begin(); commandIter != usedCommands.end(); ++commandIter)
     {
-    // If this command is a cmCabilCommand, see if it has a cmCabilData
+    // If this command is a cmCableCommand, see if it has a cmCableData
     // instance.
-    cmCabilCommand* command = cmCabilCommand::SafeDownCast(*commandIter);
+    cmCableCommand* command = cmCableCommand::SafeDownCast(*commandIter);
     if(command)
-      { m_CabilData = command->m_CabilData; }
+      { m_CableData = command->m_CableData; }
     
-    // If we found an instance of cmCabilData, then we are done.
-    if(m_CabilData)
+    // If we found an instance of cmCableData, then we are done.
+    if(m_CableData)
       { return; }
     }
   
-  // We didn't find another cmCabilCommand with a valid cmCabilData.
-  // We must allocate the new cmCabilData ourselves, and with this
+  // We didn't find another cmCableCommand with a valid cmCableData.
+  // We must allocate the new cmCableData ourselves, and with this
   // command as its owner.
-  m_CabilData = new cmCabilData(this);
+  m_CableData = new cmCableData(this);
 }

Source/cmCableCommand.h

@@ -13,42 +13,42 @@
   See COPYRIGHT.txt for copyright details.
 
 =========================================================================*/
-#ifndef cmCabilCommand_h
-#define cmCabilCommand_h
+#ifndef cmCableCommand_h
+#define cmCableCommand_h
 
 #include "cmStandardIncludes.h"
 #include "cmCommand.h"
-#include "cmCabilData.h"
+#include "cmCableData.h"
 
-/** \class cmCabilCommand
- * \brief Superclass for all cmCabil command classes.
+/** \class cmCableCommand
+ * \brief Superclass for all cmCable command classes.
  *
- * cmCabilCommand is the superclass for all CABIL-related commands.
- * The C++ Automated Bindings for Interpreted Languages (CABIL,
- * pronounced "sawbill") tool is configured using an XML input file.
- * The input format is quite flexible, but XML is hard for humans to
- * write by hand.  The CABIL commands in CMake are designed to simplify
- * the interface with only a small loss in functionality.  These commands
- * can be used to automatically generate CABIL configuration files.
+ * cmCableCommand is the superclass for all CABLE-related commands.
+ * The C++ Automated Bindings for Language Extension (CABLE) tool is
+ * configured using an XML input file.  The input format is quite
+ * flexible, but XML is hard for humans to write by hand.  The CABLE
+ * commands in CMake are designed to simplify the interface with only
+ * a small loss in functionality.  These commands can be used to
+ * automatically generate CABLE configuration files.
  */
-class cmCabilCommand : public cmCommand
+class cmCableCommand : public cmCommand
 {
 public:
-  cmCabilCommand();
-  virtual ~cmCabilCommand();
+  cmCableCommand();
+  virtual ~cmCableCommand();
   
   void WriteConfigurationHeader(std::ostream&) const;
   void WriteConfigurationFooter(std::ostream&) const;
   
-  cmTypeMacro(cmCabilCommand, cmCommand);
+  cmTypeMacro(cmCableCommand, cmCommand);
 protected:
-  void SetupCabilData();
+  void SetupCableData();
   
   /**
-   * The cmCabilData holding common information for all cmCabilCommand
+   * The cmCableData holding common information for all cmCableCommand
    * instances.
    */
-  cmCabilData* m_CabilData;
+  cmCableData* m_CableData;
 };
 
 

Source/cmCableData.cxx

@@ -13,14 +13,14 @@
   See COPYRIGHT.txt for copyright details.
 
 =========================================================================*/
-#include "cmCabilData.h"
+#include "cmCableData.h"
 #include "cmCacheManager.h"
 
 
 /**
  * Free all data that was stored here.
  */
-cmCabilData::~cmCabilData()
+cmCableData::~cmCableData()
 {
   for(OutputFiles::iterator i = m_OutputFiles.begin();
       i != m_OutputFiles.end(); ++i)
@@ -33,8 +33,8 @@ cmCabilData::~cmCabilData()
 /**
  * The constructor attempts to open the file for writing.
  */
-cmCabilData::OutputFile
-::OutputFile(std::string file, const cmCabilCommand* command):
+cmCableData::OutputFile
+::OutputFile(std::string file, const cmCableCommand* command):
   m_FileStream(file.c_str()),
   m_FirstReferencingCommand(command),
   m_LastReferencingCommand(command)
@@ -49,7 +49,7 @@ cmCabilData::OutputFile
 /**
  * Destructor closes the file, if it was open.
  */
-cmCabilData::OutputFile
+cmCableData::OutputFile
 ::~OutputFile()
 {
   if(m_FileStream)
@@ -61,7 +61,7 @@ cmCabilData::OutputFile
  * Get the output stream associated with this OutputFile.
  */
 std::ostream&
-cmCabilData::OutputFile
+cmCableData::OutputFile
 ::GetStream()
 {
   return m_FileStream;
@@ -69,24 +69,24 @@ cmCabilData::OutputFile
 
 
 void
-cmCabilData::OutputFile
-::SetLastReferencingCommand(const cmCabilCommand* command)
+cmCableData::OutputFile
+::SetLastReferencingCommand(const cmCableCommand* command)
 {
   m_LastReferencingCommand = command;
 }
 
 
 bool
-cmCabilData::OutputFile
-::FirstReferencingCommandIs(const cmCabilCommand* command) const
+cmCableData::OutputFile
+::FirstReferencingCommandIs(const cmCableCommand* command) const
 {
   return (m_FirstReferencingCommand == command);
 }
 
 
 bool
-cmCabilData::OutputFile
-::LastReferencingCommandIs(const cmCabilCommand* command) const
+cmCableData::OutputFile
+::LastReferencingCommandIs(const cmCableCommand* command) const
 {
   return (m_LastReferencingCommand == command);
 }
@@ -96,9 +96,9 @@ cmCabilData::OutputFile
  * Get the OutputFile for the file with the given name.  Automatically
  * maintains first and last referencing commands.
  */
-cmCabilData::OutputFile*
-cmCabilData::GetOutputFile(const std::string& name,
-                           const cmCabilCommand* command)
+cmCableData::OutputFile*
+cmCableData::GetOutputFile(const std::string& name,
+                           const cmCableCommand* command)
 {
   OutputFiles::iterator f = m_OutputFiles.find(name);
   // If the file hasn't yet been opened, create an entry for it.

Source/cmCableData.h

@@ -13,33 +13,33 @@
   See COPYRIGHT.txt for copyright details.
 
 =========================================================================*/
-#ifndef cmCabilData_h
-#define cmCabilData_h
+#ifndef cmCableData_h
+#define cmCableData_h
 
 #include "cmStandardIncludes.h"
 #include "cmCommand.h"
 
-class cmCabilCommand;
+class cmCableCommand;
 
-/** \class cmCabilData
- * \brief Hold data in one location for all cmCabilCommand subclasses.
+/** \class cmCableData
+ * \brief Hold data in one location for all cmCableCommand subclasses.
  */
-class cmCabilData
+class cmCableData
 {
 public:
   /**
-   * The cmCabilData instance is owned by one cmCabilCommand, which is given
+   * The cmCableData instance is owned by one cmCableCommand, which is given
    * to this constructor.
    */
-  cmCabilData(const cmCabilCommand* owner): m_Owner(owner) {}
+  cmCableData(const cmCableCommand* owner): m_Owner(owner) {}
   
-  ~cmCabilData();
+  ~cmCableData();
   
   /**
-   * Returns true if the given cmCabilCommand is the owner of this
-   * cmCabilData.
+   * Returns true if the given cmCableCommand is the owner of this
+   * cmCableData.
    */
-  bool OwnerIs(const cmCabilCommand* owner) const
+  bool OwnerIs(const cmCableCommand* owner) const
     { return (owner == m_Owner); }  
   
   /**
@@ -50,27 +50,27 @@ public:
   class OutputFile
   {
   public:
-    OutputFile(std::string, const cmCabilCommand*);
+    OutputFile(std::string, const cmCableCommand*);
     ~OutputFile();
     std::ostream& GetStream();
-    void SetLastReferencingCommand(const cmCabilCommand*);
-    bool FirstReferencingCommandIs(const cmCabilCommand*) const;
-    bool LastReferencingCommandIs(const cmCabilCommand*) const;
+    void SetLastReferencingCommand(const cmCableCommand*);
+    bool FirstReferencingCommandIs(const cmCableCommand*) const;
+    bool LastReferencingCommandIs(const cmCableCommand*) const;
   private:
     std::ofstream m_FileStream;
-    const cmCabilCommand* m_FirstReferencingCommand;
-    const cmCabilCommand* m_LastReferencingCommand;
+    const cmCableCommand* m_FirstReferencingCommand;
+    const cmCableCommand* m_LastReferencingCommand;
   };
   
-  OutputFile* GetOutputFile(const std::string&, const cmCabilCommand*);
+  OutputFile* GetOutputFile(const std::string&, const cmCableCommand*);
   
 private:
   typedef std::map<std::string, OutputFile*>  OutputFiles;
   
   /**
-   * The cmCabilCommand which created this instance of cmCabilCommand.
+   * The cmCableCommand which created this instance of cmCableCommand.
    */
-  const cmCabilCommand* m_Owner;
+  const cmCableCommand* m_Owner;
   
   /**
    * Hold all output streams by file name.

Source/cmCableDefineSetCommand.cxx

@@ -13,14 +13,14 @@
   See COPYRIGHT.txt for copyright details.
 
 =========================================================================*/
-#include "cmCabilDefineSetCommand.h"
+#include "cmCableDefineSetCommand.h"
 #include "cmCacheManager.h"
 
 #include "cmRegularExpression.h"
 
 
-// cmCabilDefineSetCommand
-bool cmCabilDefineSetCommand::Invoke(std::vector<std::string>& args)
+// cmCableDefineSetCommand
+bool cmCableDefineSetCommand::Invoke(std::vector<std::string>& args)
 {
   if(args.size() < 2)
     {
@@ -44,9 +44,9 @@ bool cmCabilDefineSetCommand::Invoke(std::vector<std::string>& args)
 
 
 /**
- * Write the CABIL configuration code to define this Set.
+ * Write the CABLE configuration code to define this Set.
  */
-void cmCabilDefineSetCommand::WriteConfiguration(std::ostream& os) const
+void cmCableDefineSetCommand::WriteConfiguration(std::ostream& os) const
 {
   cmRegularExpression needCdataBlock("[&<>]");
   
@@ -77,13 +77,13 @@ void cmCabilDefineSetCommand::WriteConfiguration(std::ostream& os) const
 
 /**
  * Given the string representing a set element, automatically generate
- * the CABIL element tag for it.
+ * the CABLE element tag for it.
  *
  * **This function determines how the output language of all
- * CABIL-generated wrappers will look!**
+ * CABLE-generated wrappers will look!**
  */
 std::string
-cmCabilDefineSetCommand::GenerateTag(const std::string& element) const
+cmCableDefineSetCommand::GenerateTag(const std::string& element) const
 {
   // Hold the regular expressions for matching against the element.
   cmRegularExpression regex;

Source/cmCableDefineSetCommand.h

@@ -13,20 +13,20 @@
   See COPYRIGHT.txt for copyright details.
 
 =========================================================================*/
-#ifndef cmCabilDefineSetCommand_h
-#define cmCabilDefineSetCommand_h
+#ifndef cmCableDefineSetCommand_h
+#define cmCableDefineSetCommand_h
 
 #include "cmStandardIncludes.h"
-#include "cmCabilCommand.h"
+#include "cmCableCommand.h"
 
-/** \class cmCabilDefineSetCommand
- * \brief Define a command that adds a CABIL Set definition.
+/** \class cmCableDefineSetCommand
+ * \brief Define a command that adds a CABLE Set definition.
  *
- * cmCabilDefineSetCommand is used to define a named CABIL Set.
- * The set can be referenced in other CABIL command arguments
+ * cmCableDefineSetCommand is used to define a named CABLE Set.
+ * The set can be referenced in other CABLE command arguments
  * with a '$' followed by the set name.
  */
-class cmCabilDefineSetCommand : public cmCabilCommand
+class cmCableDefineSetCommand : public cmCableCommand
 {
 public:
   /**
@@ -34,7 +34,7 @@ public:
    */
   virtual cmCommand* Clone()
     {
-      return new cmCabilDefineSetCommand;
+      return new cmCableDefineSetCommand;
     }
 
   /**
@@ -53,14 +53,14 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual const char* GetName() { return "CABIL_DEFINE_SET";}
+  virtual const char* GetName() { return "CABLE_DEFINE_SET";}
 
   /**
    * Succinct documentation.
    */
   virtual const char* GetTerseDocumentation() 
     {
-    return "Define a CABIL Set.";
+    return "Define a CABLE Set.";
     }
   
   /**
@@ -69,15 +69,15 @@ public:
   virtual const char* GetFullDocumentation()
     {
     return
-      "CABIL_DEFINE_SET(name_of_set member1 member2 ...)\n"
-      "Generates a Set definition in the CABIL configuration.  Tags are\n"
-      "automatically generated.  The sets are referenced in other CABIL\n"
+      "CABLE_DEFINE_SET(name_of_set member1 member2 ...)\n"
+      "Generates a Set definition in the CABLE configuration.  Tags are\n"
+      "automatically generated.  The sets are referenced in other CABLE\n"
       "commands by a '$' immediately followed by the set name (ex. $SetName).";
     }
 
   virtual void WriteConfiguration(std::ostream&) const;
   
-  cmTypeMacro(cmCabilDefineSetCommand, cmCabilCommand);
+  cmTypeMacro(cmCableDefineSetCommand, cmCableCommand);
   
 private:
   std::string GenerateTag(const std::string&) const;

Source/cmCableInstantiateClassCommand.cxx

@@ -13,17 +13,17 @@
   See COPYRIGHT.txt for copyright details.
 
 =========================================================================*/
-#include "cmCabilInstantiateClassCommand.h"
+#include "cmCableInstantiateClassCommand.h"
 #include "cmCacheManager.h"
 
 #include "cmRegularExpression.h"
 
 
 /**
- * Write the CABIL configuration code to define this InstantiationSet.
+ * Write the CABLE configuration code to define this InstantiationSet.
  * This includes the "class" keyword to do class template instantiations.
  */
-void cmCabilInstantiateClassCommand::WriteConfiguration(std::ostream& os) const
+void cmCableInstantiateClassCommand::WriteConfiguration(std::ostream& os) const
 {
   cmRegularExpression needCdataBlock("[&<>]");
   

Source/cmCableInstantiateClassCommand.h

@@ -13,21 +13,21 @@
   See COPYRIGHT.txt for copyright details.
 
 =========================================================================*/
-#ifndef cmCabilInstantiateClassCommand_h
-#define cmCabilInstantiateClassCommand_h
+#ifndef cmCableInstantiateClassCommand_h
+#define cmCableInstantiateClassCommand_h
 
 #include "cmStandardIncludes.h"
-#include "cmCabilInstantiateCommand.h"
+#include "cmCableInstantiateCommand.h"
 
-/** \class cmCabilInstantiateClassCommand
+/** \class cmCableInstantiateClassCommand
  * \brief Define a command that generates a rule for explicit template
  * instantiations of classes.
  *
- * cmCabilInstantiateCommand is used to generate a rule in a CABIL
+ * cmCableInstantiateCommand is used to generate a rule in a CABLE
  * configuration file to create explicit template instantiations of
  * classes.
  */
-class cmCabilInstantiateClassCommand : public cmCabilInstantiateCommand
+class cmCableInstantiateClassCommand : public cmCableInstantiateCommand
 {
 public:
   /**
@@ -35,20 +35,20 @@ public:
    */
   virtual cmCommand* Clone() 
     {
-    return new cmCabilInstantiateClassCommand;
+    return new cmCableInstantiateClassCommand;
     }
 
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual const char* GetName() { return "CABIL_INSTANTIATE_CLASS";}
+  virtual const char* GetName() { return "CABLE_INSTANTIATE_CLASS";}
 
   /**
    * Succinct documentation.
    */
   virtual const char* GetTerseDocumentation() 
     {
-    return "Define CABIL InstantiationSet of classes.";
+    return "Define CABLE InstantiationSet of classes.";
     }
   
   /**
@@ -57,17 +57,17 @@ public:
   virtual const char* GetFullDocumentation()
     {
     return
-      "CABIL_INSTANTIATE_CLASS(cabil_config_file member1 member2 ...)\n"
-      "Generates an InstantiationSet in the CABIL configuration.  It is\n"
+      "CABLE_INSTANTIATE_CLASS(cable_config_file member1 member2 ...)\n"
+      "Generates an InstantiationSet in the CABLE configuration.  It is\n"
       "assumed that all members of the set are explicit instantiations of\n"
       "template classes (not functions, operators, etc).";
     }
 
   virtual void WriteConfiguration(std::ostream&) const;  
 
-  cmTypeMacro(cmCabilInstantiateClassCommand, cmCabilInstantiateCommand);
+  cmTypeMacro(cmCableInstantiateClassCommand, cmCableInstantiateCommand);
 protected:
-  typedef cmCabilInstantiateCommand::Elements  Elements;
+  typedef cmCableInstantiateCommand::Elements  Elements;
 };
 
 

Source/cmCableInstantiateCommand.cxx

@@ -13,14 +13,14 @@
   See COPYRIGHT.txt for copyright details.
 
 =========================================================================*/
-#include "cmCabilInstantiateCommand.h"
+#include "cmCableInstantiateCommand.h"
 #include "cmCacheManager.h"
 
-#include "cmCabilDefineSetCommand.h"
+#include "cmCableDefineSetCommand.h"
 #include "cmRegularExpression.h"
 
-// cmCabilInstantiateCommand
-bool cmCabilInstantiateCommand::Invoke(std::vector<std::string>& args)
+// cmCableInstantiateCommand
+bool cmCableInstantiateCommand::Invoke(std::vector<std::string>& args)
 {
   if(args.size() < 2)
     {
@@ -28,8 +28,8 @@ bool cmCabilInstantiateCommand::Invoke(std::vector<std::string>& args)
     return false;
     }
   
-  // This command instance needs to use the cmCabilData instance.
-  this->SetupCabilData();
+  // This command instance needs to use the cmCableData instance.
+  this->SetupCableData();
   
   // The output file must be opened in the output directory.
   std::string file = m_Makefile->GetStartOutputDirectory();
@@ -42,7 +42,7 @@ bool cmCabilInstantiateCommand::Invoke(std::vector<std::string>& args)
   file += "/" + *arg++;
   
   // Get the OutputFile corresponding to this file name.
-  m_OutputFile = m_CabilData->GetOutputFile(file, this);
+  m_OutputFile = m_CableData->GetOutputFile(file, this);
   
   // The rest of the arguments are the elements to be placed in the set.
   for(; arg != args.end(); ++arg)
@@ -54,7 +54,7 @@ bool cmCabilInstantiateCommand::Invoke(std::vector<std::string>& args)
 }
 
 
-void cmCabilInstantiateCommand::FinalPass()
+void cmCableInstantiateCommand::FinalPass()
 {
   // If this command is the first to reference its output file, write the
   // header information.
@@ -70,10 +70,10 @@ void cmCabilInstantiateCommand::FinalPass()
           usedCommands.begin();
         commandIter != usedCommands.end(); ++commandIter)
       {
-      // If this command is a cmCabilDefineSetCommand, ask it to write its
+      // If this command is a cmCableDefineSetCommand, ask it to write its
       // configuration code to the output file.
-      cmCabilDefineSetCommand* command =
-        cmCabilDefineSetCommand::SafeDownCast(*commandIter);
+      cmCableDefineSetCommand* command =
+        cmCableDefineSetCommand::SafeDownCast(*commandIter);
       if(command)
         {
         command->WriteConfiguration(m_OutputFile->GetStream());
@@ -94,9 +94,9 @@ void cmCabilInstantiateCommand::FinalPass()
 
 
 /**
- * Write the CABIL configuration code to define this InstantiationSet.
+ * Write the CABLE configuration code to define this InstantiationSet.
  */
-void cmCabilInstantiateCommand::WriteConfiguration(std::ostream& os) const
+void cmCableInstantiateCommand::WriteConfiguration(std::ostream& os) const
 {
   cmRegularExpression needCdataBlock("[&<>]");
   

Source/cmCableInstantiateCommand.h

@@ -13,20 +13,20 @@
   See COPYRIGHT.txt for copyright details.
 
 =========================================================================*/
-#ifndef cmCabilInstantiateCommand_h
-#define cmCabilInstantiateCommand_h
+#ifndef cmCableInstantiateCommand_h
+#define cmCableInstantiateCommand_h
 
 #include "cmStandardIncludes.h"
-#include "cmCabilCommand.h"
+#include "cmCableCommand.h"
 
-/** \class cmCabilInstantiateCommand
+/** \class cmCableInstantiateCommand
  * \brief Define a command that generates a rule for explicit template
  * instantiations.
  *
- * cmCabilInstantiateCommand is used to generate a rule in a CABIL
+ * cmCableInstantiateCommand is used to generate a rule in a CABLE
  * configuration file to create explicit template instantiations.
  */
-class cmCabilInstantiateCommand : public cmCabilCommand
+class cmCableInstantiateCommand : public cmCableCommand
 {
 public:
   /**
@@ -34,7 +34,7 @@ public:
    */
   virtual cmCommand* Clone() 
     {
-    return new cmCabilInstantiateCommand;
+    return new cmCableInstantiateCommand;
     }
 
   /**
@@ -58,14 +58,14 @@ public:
   /**
    * The name of the command as specified in CMakeList.txt.
    */
-  virtual const char* GetName() { return "CABIL_INSTANTIATE";}
+  virtual const char* GetName() { return "CABLE_INSTANTIATE";}
 
   /**
    * Succinct documentation.
    */
   virtual const char* GetTerseDocumentation() 
     {
-    return "Define CABIL InstantiationSet.";
+    return "Define CABLE InstantiationSet.";
     }
   
   /**
@@ -74,22 +74,22 @@ public:
   virtual const char* GetFullDocumentation()
     {
     return
-      "CABIL_INSTANTIATE(cabil_config_file member1 member2 ...)\n"
-      "Generates an InstantiationSet in the CABIL configuration.  It is\n"
+      "CABLE_INSTANTIATE(cable_config_file member1 member2 ...)\n"
+      "Generates an InstantiationSet in the CABLE configuration.  It is\n"
       "assumed that all members of the set are explicit instantiations of\n"
       "template non-classes (functions, operators, etc).";
     }
 
   virtual void WriteConfiguration(std::ostream&) const;  
 
-  cmTypeMacro(cmCabilInstantiateCommand, cmCabilCommand);
+  cmTypeMacro(cmCableInstantiateCommand, cmCableCommand);
 protected:
   typedef std::vector<std::string>  Elements;
   
   /**
    * The output file to which to write the configuration.
    */
-  cmCabilData::OutputFile* m_OutputFile;
+  cmCableData::OutputFile* m_OutputFile;
 
   /**
    * The elements describing the set of instantiations.

Source/cmCommands.cxx

@@ -24,11 +24,11 @@
 #include "cmWin32DefinesCommand.cxx"
 #include "cmWin32LibrariesCommand.cxx"
 #include "cmConfigureFileNoAutoconf.cxx"
-#include "cmCabilCommand.cxx"
-#include "cmCabilData.cxx"
-#include "cmCabilDefineSetCommand.cxx"
-#include "cmCabilInstantiateCommand.cxx"
-#include "cmCabilInstantiateClassCommand.cxx"
+#include "cmCableCommand.cxx"
+#include "cmCableData.cxx"
+#include "cmCableDefineSetCommand.cxx"
+#include "cmCableInstantiateCommand.cxx"
+#include "cmCableInstantiateClassCommand.cxx"
 #include "cmFindFileCommand.cxx"
 #include "cmWrapExcludeFilesCommand.cxx"
 #include "cmWrapTclCommand.cxx"
@@ -57,9 +57,9 @@ void GetPredefinedCommands(std::list<cmCommand*>& commands)
   commands.push_back(new cmWin32DefinesCommand);
   commands.push_back(new cmWin32LibrariesCommand);
   commands.push_back(new cmConfigureFileNoAutoconf);
-  commands.push_back(new cmCabilDefineSetCommand);
-  commands.push_back(new cmCabilInstantiateCommand);
-  commands.push_back(new cmCabilInstantiateClassCommand);
+  commands.push_back(new cmCableDefineSetCommand);
+  commands.push_back(new cmCableInstantiateCommand);
+  commands.push_back(new cmCableInstantiateClassCommand);
   commands.push_back(new cmFindFileCommand);
   commands.push_back(new cmWrapExcludeFilesCommand);  
   commands.push_back(new cmWrapTclCommand);