Source/cmGlobalGNGenerator.cxx - third_party/cmake - Git at Google

 /* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
    file Copyright.txt or https://cmake.org/licensing for details.  */
 #include "cmGlobalGNGenerator.h"

 #include "cmDocumentationEntry.h"
 #include "cmGeneratedFileStream.h"
 #include "cmGeneratorTarget.h"
 #include "cmLocalGenerator.h"
 #include "cmLocalGNGenerator.h"
 #include "cmMakefile.h"
 #include "cmState.h"
 #include "cmVersion.h"

 class cmake;

 const char* cmGlobalGNGenerator::GN_BUILD_FILE = "BUILD.gn";
 const char* cmGlobalGNGenerator::INDENT = "  ";

 #if 0
 namespace {
 class cmGNWriter
 {
 public:
   cmGNWriter(std::ostream& output, std::size_t level = 0);

 private:
   std::ostream& Output;
   std::size_t Level;
 };

 cmGNWriter::cmGNWriter(std::ostream& output, std::size_t level = 0)
   : Output(output)
   , Level(level)
 {
 }

 void cmGNWriter::StartScope(std::string const& name)
 {
   Output << type + "(\"" + name + "\")";
   Output << "{";
 }

 };
 #endif

 void cmGlobalGNGenerator::Indent(std::ostream& os, int count)
 {
   for (int i = 0; i < count; ++i) {
     os << cmGlobalGNGenerator::INDENT;
   }
 }

 void cmGlobalGNGenerator::WriteComment(std::ostream& os,
                                        const std::string& comment)
 {
   if (comment.empty()) {
     return;
   }

   std::string::size_type lpos = 0;
   std::string::size_type rpos;
   while ((rpos = comment.find('\n', lpos)) != std::string::npos) {
     os << "# " << comment.substr(lpos, rpos - lpos) << "\n";
     lpos = rpos + 1;
   }
   os << "# " << comment.substr(lpos) << "\n";
 }

 void cmGlobalGNGenerator::WriteVariable(std::ostream& os,
                                         const std::string& name,
                                         const std::string& value,
                                         const std::string& comment,
                                         int indent)
 {
   // Make sure we have a name.
   if (name.empty()) {
     cmSystemTools::Error("No name given for WriteVariable! called "
                          "with comment: ",
                          comment.c_str());
     return;
   }

   // Do not add a variable if the value is empty.
   std::string val = cmSystemTools::TrimWhitespace(value);
   if (val.empty()) {
     return;
   }

   cmGlobalGNGenerator::WriteComment(os, comment);
   cmGlobalGNGenerator::Indent(os, indent);
   os << name << " = " << val << "\n";
 }

 void cmGlobalGNGenerator::WriteVariable(std::ostream& os,
                                         const std::string& name,
                                         const std::vector<std::string>& values,
                                         const std::string& comment,
                                         int indent)
 {
   // Make sure we have a name.
   if (name.empty()) {
     cmSystemTools::Error("No name given for WriteVariable! called "
                          "with comment: ",
                          comment.c_str());
     return;
   }

   // Do not add a variable if there are no values.
   if (values.empty()) {
     return;
   }

   cmGlobalGNGenerator::WriteComment(os, comment);
   cmGlobalGNGenerator::Indent(os, indent);
   os << name << " = [\n";
   for (std::vector<std::string>::const_iterator i = values.begin();
        i != values.end(); ++i) {
     std::string val = cmSystemTools::TrimWhitespace(*i);
     cmGlobalGNGenerator::Indent(os, indent + 1);
     os << "\"" << val << "\",\n";
   }
   cmGlobalGNGenerator::Indent(os, indent);
   os << "]\n";
 }

 void cmGlobalGNGenerator::WriteFunction(std::ostream& os,
                                         const std::string& name,
                                         const std::vector<std::string>& args,
                                         const std::string& comment,
                                         int indent)
 {
   // Make sure we have a name.
   if (name.empty()) {
     cmSystemTools::Error("No name given for WriteFunction! called "
                          "with comment: ",
                          comment.c_str());
     return;
   }

   // Do not add a variable if there are no values.
   //if (values.empty()) {
   //  return;
   //}

   cmGlobalGNGenerator::WriteComment(os, comment);
   cmGlobalGNGenerator::Indent(os, indent);
   os << name << "(";
   for (std::vector<std::string>::const_iterator i = args.begin();
        i != args.end(); ++i) {
     std::string val = cmSystemTools::TrimWhitespace(*i);
     os << "\"" << val << "\"";
     if (i + 1 == args.end())
       os << ",";
   }
   os << ")\n";
 }

 void cmGlobalGNGenerator::WriteTarget(
   std::ostream& os, const std::string& comment, const std::string& type,
   const std::string& name, const std::string& output_name,
   const std::vector<std::string>& flags,
   const std::vector<std::string>& defines,
   const std::vector<std::string>& includes,
   const std::vector<std::string>& sources,
   const std::vector<std::string>& deps,
   const std::map<std::string, std::string>& variables,
   int cmdLineLimit)
 {
   cmGlobalGNGenerator::WriteComment(os, comment);

   std::string id = type + "(\"" + name + "\")";

   std::ostringstream variable_assignments;
   cmGlobalGNGenerator::WriteVariable(variable_assignments, "cflags", flags, "", 1);
   cmGlobalGNGenerator::WriteVariable(variable_assignments, "defines", defines, "", 1);
   cmGlobalGNGenerator::WriteVariable(variable_assignments, "include_dirs", includes, "", 1);
   cmGlobalGNGenerator::WriteVariable(variable_assignments, "sources", sources, "", 1);
   cmGlobalGNGenerator::WriteVariable(variable_assignments, "deps", deps, "", 1);

   for (std::map<std::string, std::string>::const_iterator i = variables.begin();
        i != variables.end(); ++i) {
     cmGlobalGNGenerator::WriteVariable(variable_assignments, i->first,
                                        i->second, "", 1);
   }
   std::string assignments = variable_assignments.str();

   os << id << " {\n" << assignments << "}\n";
 }

 cmGlobalGNGenerator::cmGlobalGNGenerator(cmake* cm)
   : cmGlobalCommonGenerator(cm)
   , BuildFileStream(CM_NULLPTR)
 {
   this->FindMakeProgramFile = "CMakeGNFindMake.cmake";
 }

 cmGlobalGNGenerator::~cmGlobalGNGenerator()
 {
 }

 static void WriteDotGN(std::ostream& os)
 {
   cmGlobalGNGenerator::WriteVariable(os, "buildconfig", "\"//build/BUILDCONFIG.gn\"");
 }

 static void WriteBuildConfig(std::ostream& os)
 {
   os << "set_default_toolchain(\"//build:host\")";
 }

 static void WriteToolchainBuild(std::ostream& os)
 {
   os << "toolchain(\"host\") {\n";
   cmGlobalGNGenerator::WriteVariable(os, "cc", "\"cc\"", "", 1);
   cmGlobalGNGenerator::WriteVariable(os, "cxx", "\"c++\"", "", 1);
   cmGlobalGNGenerator::WriteVariable(os, "ar", "\"ar\"", "", 1);
   cmGlobalGNGenerator::WriteVariable(os, "ld", "cxx", "", 1);
   os << "  tool(\"cc\") {\n";
   cmGlobalGNGenerator::WriteVariable(os, "depfile", "\"{{output}}.d\"", "", 2);
   cmGlobalGNGenerator::WriteVariable(os, "command", "\"$cc -MMD -MF $depfile {{defines}} {{include_dirs}} {{cflags}} {{cflags_c}} -c {{source}} -o {{output}}\"", "", 2);
   cmGlobalGNGenerator::WriteVariable(os, "depsformat", "\"gcc\"", "", 2);
   cmGlobalGNGenerator::WriteVariable(os, "description", "\"CC {{output}}\"", "", 2);
   cmGlobalGNGenerator::WriteVariable(os, "outputs", std::vector<std::string>{
       "{{source_out_dir}}/{{target_output_name}}.{{source_name_part}}.o",
     }, "", 2);
   os << "  }\n";
   os << "  tool(\"cxx\") {\n";
   cmGlobalGNGenerator::WriteVariable(os, "depfile", "\"{{output}}.d\"", "", 2);
   cmGlobalGNGenerator::WriteVariable(os, "command", "\"$cxx -MMD -MF $depfile {{defines}} {{include_dirs}} {{cflags}} {{cflags_c}} -c {{source}} -o {{output}}\"", "", 2);
   cmGlobalGNGenerator::WriteVariable(os, "depsformat", "\"gcc\"", "", 2);
   cmGlobalGNGenerator::WriteVariable(os, "description", "\"CXX {{output}}\"", "", 2);
   cmGlobalGNGenerator::WriteVariable(os, "outputs", std::vector<std::string>{
       "{{source_out_dir}}/{{target_output_name}}.{{source_name_part}}.o",
     }, "", 2);
   os << "  }\n";
   os << "  tool(\"alink\") {\n";
   cmGlobalGNGenerator::WriteVariable(os, "rspfile", "\"{{output}}.rsp\"", "", 2);
   cmGlobalGNGenerator::WriteVariable(os, "command", "\"rm -f {{output}} && $ar {{arflags}} rcsD {{output}} @\\\"$rspfile\\\"\"", "", 2);
   cmGlobalGNGenerator::WriteVariable(os, "description", "\"AR {{output}}\"", "", 2);
   cmGlobalGNGenerator::WriteVariable(os, "rspfile_content", "\"{{inputs}}\"", "", 2);
   cmGlobalGNGenerator::WriteVariable(os, "outputs", std::vector<std::string>{
       "{{output_dir}}/{{target_output_name}}{{output_extension}}",
     }, "", 2);
   cmGlobalGNGenerator::WriteVariable(os, "default_output_dir", "\"{{root_out_dir}}\"", "", 2);
   cmGlobalGNGenerator::WriteVariable(os, "default_output_extension", "\".a\"", "", 2);
   cmGlobalGNGenerator::WriteVariable(os, "output_prefix", "\"lib\"", "", 2);
   os << "  }\n";
   os << "  tool(\"solink\") {\n";
   cmGlobalGNGenerator::WriteVariable(os, "outname", "\"{{target_output_name}}{{output_extension}}\"", "", 2);
   cmGlobalGNGenerator::WriteVariable(os, "outfile", "\"{{output_dir}}/$outname\"", "", 2);
   cmGlobalGNGenerator::WriteVariable(os, "rspfile", "\"$outfile.rsp\"", "", 2);
   cmGlobalGNGenerator::WriteVariable(os, "command", "\"$ld -shared {{ldflags}} -o \\\"$outfile\\\" -Wl,-soname=\\\"$outname\\\" @\\\"$rspfile\\\"\"", "", 2);
   cmGlobalGNGenerator::WriteVariable(os, "description", "\"SOLINK $outfile\"", "", 2);
   cmGlobalGNGenerator::WriteVariable(os, "rspfile_content", "\"-Wl,--whole-archive {{inputs}} {{solibs}} -Wl,--no-whole-archive {{libs}}\"", "", 2);
   cmGlobalGNGenerator::WriteVariable(os, "outputs", std::vector<std::string>{
       "{{output_dir}}/{{target_output_name}}{{output_extension}}",
     }, "", 2);
   cmGlobalGNGenerator::WriteVariable(os, "default_output_dir", "\"{{root_out_dir}}\"", "", 2);
   cmGlobalGNGenerator::WriteVariable(os, "default_output_extension", "\".so\"", "", 2);
   cmGlobalGNGenerator::WriteVariable(os, "output_prefix", "\"lib\"", "", 2);
   os << "  }\n";
   os << "  tool(\"link\") {\n";
   cmGlobalGNGenerator::WriteVariable(os, "outfile", "\"{{output_dir}}/{{target_output_name}}{{output_extension}}\"", "", 2);
   cmGlobalGNGenerator::WriteVariable(os, "rspfile", "\"$outfile.rsp\"", "", 2);
   cmGlobalGNGenerator::WriteVariable(os, "command", "\"$ld {{ldflags}} -o $outfile -Wl,--start-group @\\\"$rspfile\\\" {{solibs}} -Wl,--end-group {{libs}}\"", "", 2);
   cmGlobalGNGenerator::WriteVariable(os, "description", "\"LINK $outfile\"", "", 2);
   cmGlobalGNGenerator::WriteVariable(os, "default_output_dir", "\"{{root_out_dir}}\"", "", 2);
   cmGlobalGNGenerator::WriteVariable(os, "rspfile_content", "\"{{inputs}}\"", "", 2);
   cmGlobalGNGenerator::WriteVariable(os, "outputs", std::vector<std::string>{
       "{{output_dir}}/{{target_output_name}}{{output_extension}}",
     }, "", 2);
   os << "  }\n";
   os << "}\n";
 }

 // Implemented by:
 //   cmGlobalUnixMakefileGenerator3
 //   cmGlobalGhsMultiGenerator
 //   cmGlobalVisualStudio10Generator
 //   cmGlobalVisualStudio7Generator
 //   cmGlobalXCodeGenerator
 // Called by:
 //   cmGlobalGenerator::Build()
 void cmGlobalGNGenerator::GenerateBuildCommand(
   std::vector<std::string>& makeCommand, const std::string& makeProgram,
   const std::string& /*projectName*/, const std::string& projectDir,
   const std::string& targetName, const std::string& /*config*/, bool /*fast*/,
   bool verbose, std::vector<std::string> const& makeOptions)
 {
   makeCommand.push_back(this->SelectMakeProgram(makeProgram));

   //if (verbose) {
   //  makeCommand.push_back("-v");
   //}

   if (!projectDir.empty()) {
     cmGeneratedFileStream *dot = new cmGeneratedFileStream(
       (projectDir + "/.gn").c_str(), false, this->GetMakefileEncoding());
     WriteDotGN(*dot);
     delete dot;
     cmGeneratedFileStream *buildconfig = new cmGeneratedFileStream(
       (projectDir + "/build/BUILDCONFIG.gn").c_str(), false, this->GetMakefileEncoding());
     WriteBuildConfig(*buildconfig);
     delete buildconfig;
     cmGeneratedFileStream *toolchain = new cmGeneratedFileStream(
       (projectDir + "/build/BUILD.gn").c_str(), false, this->GetMakefileEncoding());
     WriteToolchainBuild(*toolchain);
     delete toolchain;
   }

   makeCommand.insert(makeCommand.end(), makeOptions.begin(),
                      makeOptions.end());
   if (!targetName.empty()) {
     if (targetName == "clean") {
       makeCommand.push_back("-t");
       makeCommand.push_back("clean");
     } else {
       makeCommand.push_back("gen");
       makeCommand.push_back(targetName);
     }
   }
 }

 // Non-virtual public methods

 std::string cmGlobalGNGenerator::ConvertToGNPath(
   const std::string& path) const
 {
   cmLocalGNGenerator* gn =
     static_cast<cmLocalGNGenerator*>(this->LocalGenerators[0]);
   return gn->ConvertToRelativePath(
     this->LocalGenerators[0]->GetState()->GetBinaryDirectory(), path);
   /*return this->NinjaOutputPath(convPath);*/
 }

 void cmGlobalGNGenerator::AppendTargetDepends(
   cmGeneratorTarget const* target, std::vector<std::string>& outputs)
 {
   if (target->GetType() == cmStateEnums::GLOBAL_TARGET) {
     // These depend only on other CMake-provided targets, e.g. "all".
     std::set<std::string> const& utils = target->GetUtilities();
     for (std::set<std::string>::const_iterator i = utils.begin();
          i != utils.end(); ++i) {
       std::string d =
         target->GetLocalGenerator()->GetCurrentBinaryDirectory() +
         std::string("/") + *i;
       outputs.push_back(this->ConvertToGNPath(d));
     }
   } else {
     std::vector<std::string> outs;
     std::string config =
         target->Target->GetMakefile()->GetSafeDefinition("CMAKE_BUILD_TYPE");

     cmTargetDependSet const& targetDeps = this->GetTargetDirectDepends(target);
     for (cmTargetDependSet::const_iterator i = targetDeps.begin();
          i != targetDeps.end(); ++i) {
       if ((*i)->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
         continue;
       }
       /*outs.push_back(this->ConvertToGNPath(
         (*i)->GetFullPath(config, false, false)));*/
       outs.push_back(this->ConvertToGNPath((*i)->GetName()));
     }
     std::sort(outs.begin(), outs.end());
     outputs.insert(outputs.end(), outs.begin(), outs.end());
   }
 }

 // Virtual public methods.

 cmLocalGenerator* cmGlobalGNGenerator::CreateLocalGenerator(cmMakefile* mf)
 {
   return new cmLocalGNGenerator(this, mf);
 }

 codecvt::Encoding cmGlobalGNGenerator::GetMakefileEncoding() const
 {
   return codecvt::None;
 }

 void cmGlobalGNGenerator::GetDocumentation(cmDocumentationEntry& entry)
 {
   entry.Name = cmGlobalGNGenerator::GetActualName();
   entry.Brief = "Generates BUILD.gn files.";
 }

 void cmGlobalGNGenerator::Generate()
 {
   this->OpenBuildFileStream();

   this->cmGlobalGenerator::Generate();

   this->CloseBuildFileStream();
 }

 // Private methods

 void cmGlobalGNGenerator::OpenBuildFileStream()
 {
   // Compute GN's build file path.
   std::string buildFilePath =
     this->GetCMakeInstance()->GetHomeOutputDirectory();
   buildFilePath += "/";
   buildFilePath += cmGlobalGNGenerator::GN_BUILD_FILE;

   // Get a stream where to generate things.
   if (!this->BuildFileStream) {
     this->BuildFileStream = new cmGeneratedFileStream(
       buildFilePath.c_str(), false, this->GetMakefileEncoding());
     if (!this->BuildFileStream) {
       // An error message is generated by the constructor if it cannot
       // open the file.
       return;
     }
   }

   // Write the do not edit header.
   this->WriteDisclaimer(*this->BuildFileStream);
 }

 void cmGlobalGNGenerator::CloseBuildFileStream()
 {
   if (this->BuildFileStream) {
     delete this->BuildFileStream;
     this->BuildFileStream = CM_NULLPTR;
   } else {
     cmSystemTools::Error("Build file stream was not open.");
   }
 }

 // Private virtual overrides

 void cmGlobalGNGenerator::WriteDisclaimer(std::ostream& os)
 {
   os << "# CMAKE generated file: DO NOT EDIT!\n"
      << "# Generated by \"" << this->GetName() << "\""
      << " Generator, CMake Version " << cmVersion::GetMajorVersion() << "."
      << cmVersion::GetMinorVersion() << "\n\n";
 }

 #if 0
 void cmGlobalNinjaGenerator::AppendTargetOutputs(
   cmGeneratorTarget const* target, cmNinjaDeps& outputs)
 {
   std::string configName =
     target->Target->GetMakefile()->GetSafeDefinition("CMAKE_BUILD_TYPE");

   // for frameworks, we want the real name, not smple name
   // frameworks always appear versioned, and the build.ninja
   // will always attempt to manage symbolic links instead
   // of letting cmOSXBundleGenerator do it.
   bool realname = target->IsFrameworkOnApple();

   switch (target->GetType()) {
     case cmStateEnums::EXECUTABLE:
     case cmStateEnums::SHARED_LIBRARY:
     case cmStateEnums::STATIC_LIBRARY:
     case cmStateEnums::MODULE_LIBRARY: {
       outputs.push_back(this->ConvertToNinjaPath(
         target->GetFullPath(configName, false, realname)));
       break;
     }
     case cmStateEnums::OBJECT_LIBRARY:
     case cmStateEnums::GLOBAL_TARGET:
     case cmStateEnums::UTILITY: {
       std::string path =
         target->GetLocalGenerator()->GetCurrentBinaryDirectory() +
         std::string("/") + target->GetName();
       outputs.push_back(this->ConvertToNinjaPath(path));
       break;
     }

     default:
       return;
   }
 }
 #endif
	/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
	file Copyright.txt or https://cmake.org/licensing for details. */
	#include "cmGlobalGNGenerator.h"

	#include "cmDocumentationEntry.h"
	#include "cmGeneratedFileStream.h"
	#include "cmGeneratorTarget.h"
	#include "cmLocalGenerator.h"
	#include "cmLocalGNGenerator.h"
	#include "cmMakefile.h"
	#include "cmState.h"
	#include "cmVersion.h"

	class cmake;

	const char* cmGlobalGNGenerator::GN_BUILD_FILE = "BUILD.gn";
	const char* cmGlobalGNGenerator::INDENT = " ";

	#if 0
	namespace {
	class cmGNWriter
	{
	public:
	cmGNWriter(std::ostream& output, std::size_t level = 0);

	private:
	std::ostream& Output;
	std::size_t Level;
	};

	cmGNWriter::cmGNWriter(std::ostream& output, std::size_t level = 0)
	: Output(output)
	, Level(level)
	{
	}

	void cmGNWriter::StartScope(std::string const& name)
	{
	Output << type + "(\"" + name + "\")";
	Output << "{";
	}

	};
	#endif

	void cmGlobalGNGenerator::Indent(std::ostream& os, int count)
	{
	for (int i = 0; i < count; ++i) {
	os << cmGlobalGNGenerator::INDENT;
	}
	}

	void cmGlobalGNGenerator::WriteComment(std::ostream& os,
	const std::string& comment)
	{
	if (comment.empty()) {
	return;
	}

	std::string::size_type lpos = 0;
	std::string::size_type rpos;
	while ((rpos = comment.find('\n', lpos)) != std::string::npos) {
	os << "# " << comment.substr(lpos, rpos - lpos) << "\n";
	lpos = rpos + 1;
	}
	os << "# " << comment.substr(lpos) << "\n";
	}

	void cmGlobalGNGenerator::WriteVariable(std::ostream& os,
	const std::string& name,
	const std::string& value,
	const std::string& comment,
	int indent)
	{
	// Make sure we have a name.
	if (name.empty()) {
	cmSystemTools::Error("No name given for WriteVariable! called "
	"with comment: ",
	comment.c_str());
	return;
	}

	// Do not add a variable if the value is empty.
	std::string val = cmSystemTools::TrimWhitespace(value);
	if (val.empty()) {
	return;
	}

	cmGlobalGNGenerator::WriteComment(os, comment);
	cmGlobalGNGenerator::Indent(os, indent);
	os << name << " = " << val << "\n";
	}

	void cmGlobalGNGenerator::WriteVariable(std::ostream& os,
	const std::string& name,
	const std::vector<std::string>& values,
	const std::string& comment,
	int indent)
	{
	// Make sure we have a name.
	if (name.empty()) {
	cmSystemTools::Error("No name given for WriteVariable! called "
	"with comment: ",
	comment.c_str());
	return;
	}

	// Do not add a variable if there are no values.
	if (values.empty()) {
	return;
	}

	cmGlobalGNGenerator::WriteComment(os, comment);
	cmGlobalGNGenerator::Indent(os, indent);
	os << name << " = [\n";
	for (std::vector<std::string>::const_iterator i = values.begin();
	i != values.end(); ++i) {
	std::string val = cmSystemTools::TrimWhitespace(*i);
	cmGlobalGNGenerator::Indent(os, indent + 1);
	os << "\"" << val << "\",\n";
	}
	cmGlobalGNGenerator::Indent(os, indent);
	os << "]\n";
	}

	void cmGlobalGNGenerator::WriteFunction(std::ostream& os,
	const std::string& name,
	const std::vector<std::string>& args,
	const std::string& comment,
	int indent)
	{
	// Make sure we have a name.
	if (name.empty()) {
	cmSystemTools::Error("No name given for WriteFunction! called "
	"with comment: ",
	comment.c_str());
	return;
	}

	// Do not add a variable if there are no values.
	//if (values.empty()) {
	// return;
	//}

	cmGlobalGNGenerator::WriteComment(os, comment);
	cmGlobalGNGenerator::Indent(os, indent);
	os << name << "(";
	for (std::vector<std::string>::const_iterator i = args.begin();
	i != args.end(); ++i) {
	std::string val = cmSystemTools::TrimWhitespace(*i);
	os << "\"" << val << "\"";
	if (i + 1 == args.end())
	os << ",";
	}
	os << ")\n";
	}

	void cmGlobalGNGenerator::WriteTarget(
	std::ostream& os, const std::string& comment, const std::string& type,
	const std::string& name, const std::string& output_name,
	const std::vector<std::string>& flags,
	const std::vector<std::string>& defines,
	const std::vector<std::string>& includes,
	const std::vector<std::string>& sources,
	const std::vector<std::string>& deps,
	const std::map<std::string, std::string>& variables,
	int cmdLineLimit)
	{
	cmGlobalGNGenerator::WriteComment(os, comment);

	std::string id = type + "(\"" + name + "\")";

	std::ostringstream variable_assignments;
	cmGlobalGNGenerator::WriteVariable(variable_assignments, "cflags", flags, "", 1);
	cmGlobalGNGenerator::WriteVariable(variable_assignments, "defines", defines, "", 1);
	cmGlobalGNGenerator::WriteVariable(variable_assignments, "include_dirs", includes, "", 1);
	cmGlobalGNGenerator::WriteVariable(variable_assignments, "sources", sources, "", 1);
	cmGlobalGNGenerator::WriteVariable(variable_assignments, "deps", deps, "", 1);

	for (std::map<std::string, std::string>::const_iterator i = variables.begin();
	i != variables.end(); ++i) {
	cmGlobalGNGenerator::WriteVariable(variable_assignments, i->first,
	i->second, "", 1);
	}
	std::string assignments = variable_assignments.str();

	os << id << " {\n" << assignments << "}\n";
	}

	cmGlobalGNGenerator::cmGlobalGNGenerator(cmake* cm)
	: cmGlobalCommonGenerator(cm)
	, BuildFileStream(CM_NULLPTR)
	{
	this->FindMakeProgramFile = "CMakeGNFindMake.cmake";
	}

	cmGlobalGNGenerator::~cmGlobalGNGenerator()
	{
	}

	static void WriteDotGN(std::ostream& os)
	{
	cmGlobalGNGenerator::WriteVariable(os, "buildconfig", "\"//build/BUILDCONFIG.gn\"");
	}

	static void WriteBuildConfig(std::ostream& os)
	{
	os << "set_default_toolchain(\"//build:host\")";
	}

	static void WriteToolchainBuild(std::ostream& os)
	{
	os << "toolchain(\"host\") {\n";
	cmGlobalGNGenerator::WriteVariable(os, "cc", "\"cc\"", "", 1);
	cmGlobalGNGenerator::WriteVariable(os, "cxx", "\"c++\"", "", 1);
	cmGlobalGNGenerator::WriteVariable(os, "ar", "\"ar\"", "", 1);
	cmGlobalGNGenerator::WriteVariable(os, "ld", "cxx", "", 1);
	os << " tool(\"cc\") {\n";
	cmGlobalGNGenerator::WriteVariable(os, "depfile", "\"{{output}}.d\"", "", 2);
	cmGlobalGNGenerator::WriteVariable(os, "command", "\"$cc -MMD -MF $depfile {{defines}} {{include_dirs}} {{cflags}} {{cflags_c}} -c {{source}} -o {{output}}\"", "", 2);
	cmGlobalGNGenerator::WriteVariable(os, "depsformat", "\"gcc\"", "", 2);
	cmGlobalGNGenerator::WriteVariable(os, "description", "\"CC {{output}}\"", "", 2);
	cmGlobalGNGenerator::WriteVariable(os, "outputs", std::vector<std::string>{
	"{{source_out_dir}}/{{target_output_name}}.{{source_name_part}}.o",
	}, "", 2);
	os << " }\n";
	os << " tool(\"cxx\") {\n";
	cmGlobalGNGenerator::WriteVariable(os, "depfile", "\"{{output}}.d\"", "", 2);
	cmGlobalGNGenerator::WriteVariable(os, "command", "\"$cxx -MMD -MF $depfile {{defines}} {{include_dirs}} {{cflags}} {{cflags_c}} -c {{source}} -o {{output}}\"", "", 2);
	cmGlobalGNGenerator::WriteVariable(os, "depsformat", "\"gcc\"", "", 2);
	cmGlobalGNGenerator::WriteVariable(os, "description", "\"CXX {{output}}\"", "", 2);
	cmGlobalGNGenerator::WriteVariable(os, "outputs", std::vector<std::string>{
	"{{source_out_dir}}/{{target_output_name}}.{{source_name_part}}.o",
	}, "", 2);
	os << " }\n";
	os << " tool(\"alink\") {\n";
	cmGlobalGNGenerator::WriteVariable(os, "rspfile", "\"{{output}}.rsp\"", "", 2);
	cmGlobalGNGenerator::WriteVariable(os, "command", "\"rm -f {{output}} && $ar {{arflags}} rcsD {{output}} @\\\"$rspfile\\\"\"", "", 2);
	cmGlobalGNGenerator::WriteVariable(os, "description", "\"AR {{output}}\"", "", 2);
	cmGlobalGNGenerator::WriteVariable(os, "rspfile_content", "\"{{inputs}}\"", "", 2);
	cmGlobalGNGenerator::WriteVariable(os, "outputs", std::vector<std::string>{
	"{{output_dir}}/{{target_output_name}}{{output_extension}}",
	}, "", 2);
	cmGlobalGNGenerator::WriteVariable(os, "default_output_dir", "\"{{root_out_dir}}\"", "", 2);
	cmGlobalGNGenerator::WriteVariable(os, "default_output_extension", "\".a\"", "", 2);
	cmGlobalGNGenerator::WriteVariable(os, "output_prefix", "\"lib\"", "", 2);
	os << " }\n";
	os << " tool(\"solink\") {\n";
	cmGlobalGNGenerator::WriteVariable(os, "outname", "\"{{target_output_name}}{{output_extension}}\"", "", 2);
	cmGlobalGNGenerator::WriteVariable(os, "outfile", "\"{{output_dir}}/$outname\"", "", 2);
	cmGlobalGNGenerator::WriteVariable(os, "rspfile", "\"$outfile.rsp\"", "", 2);
	cmGlobalGNGenerator::WriteVariable(os, "command", "\"$ld -shared {{ldflags}} -o \\\"$outfile\\\" -Wl,-soname=\\\"$outname\\\" @\\\"$rspfile\\\"\"", "", 2);
	cmGlobalGNGenerator::WriteVariable(os, "description", "\"SOLINK $outfile\"", "", 2);
	cmGlobalGNGenerator::WriteVariable(os, "rspfile_content", "\"-Wl,--whole-archive {{inputs}} {{solibs}} -Wl,--no-whole-archive {{libs}}\"", "", 2);
	cmGlobalGNGenerator::WriteVariable(os, "outputs", std::vector<std::string>{
	"{{output_dir}}/{{target_output_name}}{{output_extension}}",
	}, "", 2);
	cmGlobalGNGenerator::WriteVariable(os, "default_output_dir", "\"{{root_out_dir}}\"", "", 2);
	cmGlobalGNGenerator::WriteVariable(os, "default_output_extension", "\".so\"", "", 2);
	cmGlobalGNGenerator::WriteVariable(os, "output_prefix", "\"lib\"", "", 2);
	os << " }\n";
	os << " tool(\"link\") {\n";
	cmGlobalGNGenerator::WriteVariable(os, "outfile", "\"{{output_dir}}/{{target_output_name}}{{output_extension}}\"", "", 2);
	cmGlobalGNGenerator::WriteVariable(os, "rspfile", "\"$outfile.rsp\"", "", 2);
	cmGlobalGNGenerator::WriteVariable(os, "command", "\"$ld {{ldflags}} -o $outfile -Wl,--start-group @\\\"$rspfile\\\" {{solibs}} -Wl,--end-group {{libs}}\"", "", 2);
	cmGlobalGNGenerator::WriteVariable(os, "description", "\"LINK $outfile\"", "", 2);
	cmGlobalGNGenerator::WriteVariable(os, "default_output_dir", "\"{{root_out_dir}}\"", "", 2);
	cmGlobalGNGenerator::WriteVariable(os, "rspfile_content", "\"{{inputs}}\"", "", 2);
	cmGlobalGNGenerator::WriteVariable(os, "outputs", std::vector<std::string>{
	"{{output_dir}}/{{target_output_name}}{{output_extension}}",
	}, "", 2);
	os << " }\n";
	os << "}\n";
	}

	// Implemented by:
	// cmGlobalUnixMakefileGenerator3
	// cmGlobalGhsMultiGenerator
	// cmGlobalVisualStudio10Generator
	// cmGlobalVisualStudio7Generator
	// cmGlobalXCodeGenerator
	// Called by:
	// cmGlobalGenerator::Build()
	void cmGlobalGNGenerator::GenerateBuildCommand(
	std::vector<std::string>& makeCommand, const std::string& makeProgram,
	const std::string& /projectName/, const std::string& projectDir,
	const std::string& targetName, const std::string& /config/, bool /fast/,
	bool verbose, std::vector<std::string> const& makeOptions)
	{
	makeCommand.push_back(this->SelectMakeProgram(makeProgram));

	//if (verbose) {
	// makeCommand.push_back("-v");
	//}

	if (!projectDir.empty()) {
	cmGeneratedFileStream *dot = new cmGeneratedFileStream(
	(projectDir + "/.gn").c_str(), false, this->GetMakefileEncoding());
	WriteDotGN(*dot);
	delete dot;
	cmGeneratedFileStream *buildconfig = new cmGeneratedFileStream(
	(projectDir + "/build/BUILDCONFIG.gn").c_str(), false, this->GetMakefileEncoding());
	WriteBuildConfig(*buildconfig);
	delete buildconfig;
	cmGeneratedFileStream *toolchain = new cmGeneratedFileStream(
	(projectDir + "/build/BUILD.gn").c_str(), false, this->GetMakefileEncoding());
	WriteToolchainBuild(*toolchain);
	delete toolchain;
	}

	makeCommand.insert(makeCommand.end(), makeOptions.begin(),
	makeOptions.end());
	if (!targetName.empty()) {
	if (targetName == "clean") {
	makeCommand.push_back("-t");
	makeCommand.push_back("clean");
	} else {
	makeCommand.push_back("gen");
	makeCommand.push_back(targetName);
	}
	}
	}

	// Non-virtual public methods

	std::string cmGlobalGNGenerator::ConvertToGNPath(
	const std::string& path) const
	{
	cmLocalGNGenerator* gn =
	static_cast<cmLocalGNGenerator*>(this->LocalGenerators[0]);
	return gn->ConvertToRelativePath(
	this->LocalGenerators[0]->GetState()->GetBinaryDirectory(), path);
	/return this->NinjaOutputPath(convPath);/
	}

	void cmGlobalGNGenerator::AppendTargetDepends(
	cmGeneratorTarget const* target, std::vector<std::string>& outputs)
	{
	if (target->GetType() == cmStateEnums::GLOBAL_TARGET) {
	// These depend only on other CMake-provided targets, e.g. "all".
	std::set<std::string> const& utils = target->GetUtilities();
	for (std::set<std::string>::const_iterator i = utils.begin();
	i != utils.end(); ++i) {
	std::string d =
	target->GetLocalGenerator()->GetCurrentBinaryDirectory() +
	std::string("/") + *i;
	outputs.push_back(this->ConvertToGNPath(d));
	}
	} else {
	std::vector<std::string> outs;
	std::string config =
	target->Target->GetMakefile()->GetSafeDefinition("CMAKE_BUILD_TYPE");

	cmTargetDependSet const& targetDeps = this->GetTargetDirectDepends(target);
	for (cmTargetDependSet::const_iterator i = targetDeps.begin();
	i != targetDeps.end(); ++i) {
	if ((*i)->GetType() == cmStateEnums::INTERFACE_LIBRARY) {
	continue;
	}
	/*outs.push_back(this->ConvertToGNPath(
	(i)->GetFullPath(config, false, false)));/
	outs.push_back(this->ConvertToGNPath((*i)->GetName()));
	}
	std::sort(outs.begin(), outs.end());
	outputs.insert(outputs.end(), outs.begin(), outs.end());
	}
	}

	// Virtual public methods.

	cmLocalGenerator* cmGlobalGNGenerator::CreateLocalGenerator(cmMakefile* mf)
	{
	return new cmLocalGNGenerator(this, mf);
	}

	codecvt::Encoding cmGlobalGNGenerator::GetMakefileEncoding() const
	{
	return codecvt::None;
	}

	void cmGlobalGNGenerator::GetDocumentation(cmDocumentationEntry& entry)
	{
	entry.Name = cmGlobalGNGenerator::GetActualName();
	entry.Brief = "Generates BUILD.gn files.";
	}

	void cmGlobalGNGenerator::Generate()
	{
	this->OpenBuildFileStream();

	this->cmGlobalGenerator::Generate();

	this->CloseBuildFileStream();
	}

	// Private methods

	void cmGlobalGNGenerator::OpenBuildFileStream()
	{
	// Compute GN's build file path.
	std::string buildFilePath =
	this->GetCMakeInstance()->GetHomeOutputDirectory();
	buildFilePath += "/";
	buildFilePath += cmGlobalGNGenerator::GN_BUILD_FILE;

	// Get a stream where to generate things.
	if (!this->BuildFileStream) {
	this->BuildFileStream = new cmGeneratedFileStream(
	buildFilePath.c_str(), false, this->GetMakefileEncoding());
	if (!this->BuildFileStream) {
	// An error message is generated by the constructor if it cannot
	// open the file.
	return;
	}
	}

	// Write the do not edit header.
	this->WriteDisclaimer(*this->BuildFileStream);
	}

	void cmGlobalGNGenerator::CloseBuildFileStream()
	{
	if (this->BuildFileStream) {
	delete this->BuildFileStream;
	this->BuildFileStream = CM_NULLPTR;
	} else {
	cmSystemTools::Error("Build file stream was not open.");
	}
	}

	// Private virtual overrides

	void cmGlobalGNGenerator::WriteDisclaimer(std::ostream& os)
	{
	os << "# CMAKE generated file: DO NOT EDIT!\n"
	<< "# Generated by \"" << this->GetName() << "\""
	<< " Generator, CMake Version " << cmVersion::GetMajorVersion() << "."
	<< cmVersion::GetMinorVersion() << "\n\n";
	}

	#if 0
	void cmGlobalNinjaGenerator::AppendTargetOutputs(
	cmGeneratorTarget const* target, cmNinjaDeps& outputs)
	{
	std::string configName =
	target->Target->GetMakefile()->GetSafeDefinition("CMAKE_BUILD_TYPE");

	// for frameworks, we want the real name, not smple name
	// frameworks always appear versioned, and the build.ninja
	// will always attempt to manage symbolic links instead
	// of letting cmOSXBundleGenerator do it.
	bool realname = target->IsFrameworkOnApple();

	switch (target->GetType()) {
	case cmStateEnums::EXECUTABLE:
	case cmStateEnums::SHARED_LIBRARY:
	case cmStateEnums::STATIC_LIBRARY:
	case cmStateEnums::MODULE_LIBRARY: {
	outputs.push_back(this->ConvertToNinjaPath(
	target->GetFullPath(configName, false, realname)));
	break;
	}
	case cmStateEnums::OBJECT_LIBRARY:
	case cmStateEnums::GLOBAL_TARGET:
	case cmStateEnums::UTILITY: {
	std::string path =
	target->GetLocalGenerator()->GetCurrentBinaryDirectory() +
	std::string("/") + target->GetName();
	outputs.push_back(this->ConvertToNinjaPath(path));
	break;
	}

	default:
	return;
	}
	}
	#endif