|
|
@@ -0,0 +1,232 @@
|
|
|
+/*=========================================================================
|
|
|
+
|
|
|
+ Program: CMake - Cross-Platform Makefile Generator
|
|
|
+ Module: $RCSfile$
|
|
|
+ Language: C++
|
|
|
+ Date: $Date$
|
|
|
+ Version: $Revision$
|
|
|
+
|
|
|
+ Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved.
|
|
|
+ See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
|
|
|
+
|
|
|
+ This software is distributed WITHOUT ANY WARRANTY; without even
|
|
|
+ the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
|
+ PURPOSE. See the above copyright notices for more information.
|
|
|
+
|
|
|
+=========================================================================*/
|
|
|
+#include "cmScriptGenerator.h"
|
|
|
+
|
|
|
+#include "cmSystemTools.h"
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+cmScriptGenerator
|
|
|
+::cmScriptGenerator(const char* config_var,
|
|
|
+ std::vector<std::string> const& configurations):
|
|
|
+ RuntimeConfigVariable(config_var),
|
|
|
+ Configurations(configurations),
|
|
|
+ ConfigurationName(0),
|
|
|
+ ConfigurationTypes(0),
|
|
|
+ ActionsPerConfig(false)
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+cmScriptGenerator
|
|
|
+::~cmScriptGenerator()
|
|
|
+{
|
|
|
+}
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+void
|
|
|
+cmScriptGenerator
|
|
|
+::Generate(std::ostream& os, const char* config,
|
|
|
+ std::vector<std::string> const& configurationTypes)
|
|
|
+{
|
|
|
+ this->ConfigurationName = config;
|
|
|
+ this->ConfigurationTypes = &configurationTypes;
|
|
|
+ this->GenerateScript(os);
|
|
|
+ this->ConfigurationName = 0;
|
|
|
+ this->ConfigurationTypes = 0;
|
|
|
+}
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+static void cmScriptGeneratorEncodeConfig(const char* config,
|
|
|
+ std::string& result)
|
|
|
+{
|
|
|
+ for(const char* c = config; *c; ++c)
|
|
|
+ {
|
|
|
+ if(*c >= 'a' && *c <= 'z')
|
|
|
+ {
|
|
|
+ result += "[";
|
|
|
+ result += *c + ('A' - 'a');
|
|
|
+ result += *c;
|
|
|
+ result += "]";
|
|
|
+ }
|
|
|
+ else if(*c >= 'A' && *c <= 'Z')
|
|
|
+ {
|
|
|
+ result += "[";
|
|
|
+ result += *c;
|
|
|
+ result += *c + ('a' - 'A');
|
|
|
+ result += "]";
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ result += *c;
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+std::string
|
|
|
+cmScriptGenerator::CreateConfigTest(const char* config)
|
|
|
+{
|
|
|
+ std::string result = "\"${";
|
|
|
+ result += this->RuntimeConfigVariable;
|
|
|
+ result += "}\" MATCHES \"^(";
|
|
|
+ if(config && *config)
|
|
|
+ {
|
|
|
+ cmScriptGeneratorEncodeConfig(config, result);
|
|
|
+ }
|
|
|
+ result += ")$\"";
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+std::string
|
|
|
+cmScriptGenerator::CreateConfigTest(std::vector<std::string> const& configs)
|
|
|
+{
|
|
|
+ std::string result = "\"${";
|
|
|
+ result += this->RuntimeConfigVariable;
|
|
|
+ result += "}\" MATCHES \"^(";
|
|
|
+ const char* sep = "";
|
|
|
+ for(std::vector<std::string>::const_iterator ci = configs.begin();
|
|
|
+ ci != configs.end(); ++ci)
|
|
|
+ {
|
|
|
+ result += sep;
|
|
|
+ sep = "|";
|
|
|
+ cmScriptGeneratorEncodeConfig(ci->c_str(), result);
|
|
|
+ }
|
|
|
+ result += ")$\"";
|
|
|
+ return result;
|
|
|
+}
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+void cmScriptGenerator::GenerateScript(std::ostream& os)
|
|
|
+{
|
|
|
+ // Track indentation.
|
|
|
+ Indent indent;
|
|
|
+
|
|
|
+ // Generate the script possibly with per-configuration code.
|
|
|
+ this->GenerateScriptConfigs(os, indent);
|
|
|
+}
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+void cmScriptGenerator::GenerateScriptConfigs(std::ostream& os,
|
|
|
+ Indent const& indent)
|
|
|
+{
|
|
|
+ if(this->ActionsPerConfig)
|
|
|
+ {
|
|
|
+ this->GenerateScriptActionsPerConfig(os, indent);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ this->GenerateScriptActionsOnce(os, indent);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+void cmScriptGenerator::GenerateScriptActions(std::ostream& os,
|
|
|
+ Indent const& indent)
|
|
|
+{
|
|
|
+ if(this->ActionsPerConfig)
|
|
|
+ {
|
|
|
+ // This is reached for single-configuration build generators in a
|
|
|
+ // per-config script generator.
|
|
|
+ this->GenerateScriptForConfig(os, this->ConfigurationName, indent);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+void cmScriptGenerator::GenerateScriptForConfig(std::ostream&, const char*,
|
|
|
+ Indent const&)
|
|
|
+{
|
|
|
+ // No actions for this generator.
|
|
|
+}
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+bool cmScriptGenerator::GeneratesForConfig(const char* config)
|
|
|
+{
|
|
|
+ // If this is not a configuration-specific rule then we install.
|
|
|
+ if(this->Configurations.empty())
|
|
|
+ {
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ // This is a configuration-specific rule. Check if the config
|
|
|
+ // matches this rule.
|
|
|
+ std::string config_upper = cmSystemTools::UpperCase(config?config:"");
|
|
|
+ for(std::vector<std::string>::const_iterator i =
|
|
|
+ this->Configurations.begin();
|
|
|
+ i != this->Configurations.end(); ++i)
|
|
|
+ {
|
|
|
+ if(cmSystemTools::UpperCase(*i) == config_upper)
|
|
|
+ {
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+void cmScriptGenerator::GenerateScriptActionsOnce(std::ostream& os,
|
|
|
+ Indent const& indent)
|
|
|
+{
|
|
|
+ if(this->Configurations.empty())
|
|
|
+ {
|
|
|
+ // This rule is for all configurations.
|
|
|
+ this->GenerateScriptActions(os, indent);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ // Generate a per-configuration block.
|
|
|
+ std::string config_test = this->CreateConfigTest(this->Configurations);
|
|
|
+ os << indent << "IF(" << config_test << ")\n";
|
|
|
+ this->GenerateScriptActions(os, indent.Next());
|
|
|
+ os << indent << "ENDIF(" << config_test << ")\n";
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+void cmScriptGenerator::GenerateScriptActionsPerConfig(std::ostream& os,
|
|
|
+ Indent const& indent)
|
|
|
+{
|
|
|
+ if(this->ConfigurationTypes->empty())
|
|
|
+ {
|
|
|
+ // In a single-configuration generator there is only one action
|
|
|
+ // and it applies if the runtime-requested configuration is among
|
|
|
+ // the rule's allowed configurations. The configuration built in
|
|
|
+ // the tree does not matter for this decision but will be used to
|
|
|
+ // generate proper target file names into the code.
|
|
|
+ this->GenerateScriptActionsOnce(os, indent);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ // In a multi-configuration generator we produce a separate rule
|
|
|
+ // in a block for each configuration that is built. We restrict
|
|
|
+ // the list of configurations to those to which this rule applies.
|
|
|
+ for(std::vector<std::string>::const_iterator i =
|
|
|
+ this->ConfigurationTypes->begin();
|
|
|
+ i != this->ConfigurationTypes->end(); ++i)
|
|
|
+ {
|
|
|
+ const char* config = i->c_str();
|
|
|
+ if(this->GeneratesForConfig(config))
|
|
|
+ {
|
|
|
+ // Generate a per-configuration block.
|
|
|
+ std::string config_test = this->CreateConfigTest(config);
|
|
|
+ os << indent << "IF(" << config_test << ")\n";
|
|
|
+ this->GenerateScriptForConfig(os, config, indent.Next());
|
|
|
+ os << indent << "ENDIF(" << config_test << ")\n";
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
Brad King