From d0a8794746f6de026f1c69652cd09caf8be9cfab Mon Sep 17 00:00:00 2001 From: Brad King 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 << "" << std::endl - << "" << std::endl; + << "" << 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 << "" << std::endl; + os << "" << 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::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 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& args) +// cmCableDefineSetCommand +bool cmCableDefineSetCommand::Invoke(std::vector& args) { if(args.size() < 2) { @@ -44,9 +44,9 @@ bool cmCabilDefineSetCommand::Invoke(std::vector& 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& args) +// cmCableInstantiateCommand +bool cmCableInstantiateCommand::Invoke(std::vector& args) { if(args.size() < 2) { @@ -28,8 +28,8 @@ bool cmCabilInstantiateCommand::Invoke(std::vector& 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& 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& 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 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& 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