From d0a8794746f6de026f1c69652cd09caf8be9cfab Mon Sep 17 00:00:00 2001
From: Brad King <brad.king@kitware.com>
Date: Wed, 28 Feb 2001 09:34:01 -0500
Subject: ENH: CABIL -> CABLE rename.
---
Source/cmCableCommand.cxx | 50 +++++++++++++++----------------
Source/cmCableCommand.h | 38 +++++++++++------------
Source/cmCableData.cxx | 30 +++++++++----------
Source/cmCableData.h | 42 +++++++++++++-------------
Source/cmCableDefineSetCommand.cxx | 16 +++++-----
Source/cmCableDefineSetCommand.h | 30 +++++++++----------
Source/cmCableInstantiateClassCommand.cxx | 6 ++--
Source/cmCableInstantiateClassCommand.h | 26 ++++++++--------
Source/cmCableInstantiateCommand.cxx | 26 ++++++++--------
Source/cmCableInstantiateCommand.h | 26 ++++++++--------
Source/cmCommands.cxx | 16 +++++-----
11 files changed, 153 insertions(+), 153 deletions(-)
diff --git a/Source/cmCableCommand.cxx b/Source/cmCableCommand.cxx
index f7a28ea..29cfddc 100644
--- a/Source/cmCableCommand.cxx
+++ b/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);
}
diff --git a/Source/cmCableCommand.h b/Source/cmCableCommand.h
index 211b70e..60e0ed9 100644
--- a/Source/cmCableCommand.h
+++ b/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;
};
diff --git a/Source/cmCableData.cxx b/Source/cmCableData.cxx
index a1a811a..15954b9 100644
--- a/Source/cmCableData.cxx
+++ b/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.
diff --git a/Source/cmCableData.h b/Source/cmCableData.h
index 9cc8e39..ba9d238 100644
--- a/Source/cmCableData.h
+++ b/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.
diff --git a/Source/cmCableDefineSetCommand.cxx b/Source/cmCableDefineSetCommand.cxx
index 725ea0e..95f0218 100644
--- a/Source/cmCableDefineSetCommand.cxx
+++ b/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;
diff --git a/Source/cmCableDefineSetCommand.h b/Source/cmCableDefineSetCommand.h
index 3d598b1..8d002cf 100644
--- a/Source/cmCableDefineSetCommand.h
+++ b/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;
diff --git a/Source/cmCableInstantiateClassCommand.cxx b/Source/cmCableInstantiateClassCommand.cxx
index 2491632..ba1f364 100644
--- a/Source/cmCableInstantiateClassCommand.cxx
+++ b/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("[&<>]");
diff --git a/Source/cmCableInstantiateClassCommand.h b/Source/cmCableInstantiateClassCommand.h
index b02b28a..1162992 100644
--- a/Source/cmCableInstantiateClassCommand.h
+++ b/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;
};
diff --git a/Source/cmCableInstantiateCommand.cxx b/Source/cmCableInstantiateCommand.cxx
index b30a1c5..705c313 100644
--- a/Source/cmCableInstantiateCommand.cxx
+++ b/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("[&<>]");
diff --git a/Source/cmCableInstantiateCommand.h b/Source/cmCableInstantiateCommand.h
index 1bb3722..d61eb77 100644
--- a/Source/cmCableInstantiateCommand.h
+++ b/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.
diff --git a/Source/cmCommands.cxx b/Source/cmCommands.cxx
index d60a929..b9d2508 100644
--- a/Source/cmCommands.cxx
+++ b/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);
--
cgit v0.12